Reach the first-party mobile client's everyday features: - sessions: a search button opens a field; typing asks the server with its search parameter (350 ms settle) and clearing restores the list - composer: attach photos or files (up to five, 10 MB each) as data URLs with the prompt; attachments show as removable chips and are named under the sent message - turn menu: read the answer aloud with the system voice, or stop it - chat: a "latest" button appears after scrolling up and returns to the end of the conversation - reset a live search when a connection ends Bump version to 0.2.0 (build 14).
649 lines
16 KiB
Go
649 lines
16 KiB
Go
// Package appui holds the OpenChamber screens and their state.
|
|
package appui
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"sort"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/egoist/asuka/signal"
|
|
"github.com/egoist/asuka/ui"
|
|
"github.com/openchamber/openchamber-native/internal/ocapi"
|
|
"github.com/openchamber/openchamber-native/internal/storage"
|
|
)
|
|
|
|
// Root is the app's root component.
|
|
func Root() ui.Node {
|
|
return rootWithStore(storage.New())
|
|
}
|
|
|
|
func rootWithStore(st storage.Store) ui.Node {
|
|
_, node := newApp(st)
|
|
return node
|
|
}
|
|
|
|
func newApp(st storage.Store) (*controller, ui.Node) {
|
|
c := newController(st)
|
|
signal.OnCleanup(c.shutdown)
|
|
return c, c.screen()
|
|
}
|
|
|
|
type controller struct {
|
|
st storage.Store
|
|
|
|
connections *signal.Signal[[]storage.Connection]
|
|
|
|
url *signal.Signal[string]
|
|
sessionQuery *signal.Signal[string]
|
|
searchOpen *signal.Signal[bool]
|
|
status *signal.Signal[string]
|
|
errorMsg *signal.Signal[string]
|
|
|
|
formOpen *signal.Signal[bool]
|
|
formConnecting bool
|
|
formEditID string
|
|
formLabel *signal.Signal[string]
|
|
formUseProxy *signal.Signal[bool]
|
|
formProxy *signal.Signal[string]
|
|
formInsecure *signal.Signal[bool]
|
|
|
|
passwordOpen *signal.Signal[bool]
|
|
passwordFor storage.Connection
|
|
passwordText *signal.Signal[string]
|
|
passwordBusy *signal.Signal[bool]
|
|
|
|
instancesOpen *signal.Signal[bool]
|
|
|
|
server *signal.Signal[string]
|
|
connected *signal.Signal[bool]
|
|
busy *signal.Signal[bool]
|
|
connecting *signal.Signal[string]
|
|
activeID *signal.Signal[string]
|
|
sessions *signal.Signal[[]ocapi.Session]
|
|
active *signal.Signal[map[string]bool]
|
|
perms *signal.Signal[[]ocapi.PermissionRequest]
|
|
defaultDir *signal.Signal[string]
|
|
|
|
newOpen *signal.Signal[bool]
|
|
newTitle *signal.Signal[string]
|
|
newDir *signal.Signal[int]
|
|
creating *signal.Signal[bool]
|
|
|
|
client *ocapi.Client
|
|
cancelSSE context.CancelFunc
|
|
chat *chat
|
|
nav *ui.Navigator
|
|
}
|
|
|
|
func newController(st storage.Store) *controller {
|
|
conns := st.Connections()
|
|
sort.SliceStable(conns, func(i, j int) bool { return conns[i].LastUsedAt > conns[j].LastUsedAt })
|
|
c := &controller{
|
|
st: st,
|
|
connections: signal.NewFunc(conns, nil),
|
|
url: signal.New(""),
|
|
sessionQuery: signal.New(""),
|
|
searchOpen: signal.New(false),
|
|
status: signal.New(""),
|
|
errorMsg: signal.New(""),
|
|
formOpen: signal.New(false),
|
|
formLabel: signal.New(""),
|
|
formUseProxy: signal.New(false),
|
|
formProxy: signal.New(""),
|
|
formInsecure: signal.New(false),
|
|
passwordOpen: signal.New(false),
|
|
passwordText: signal.New(""),
|
|
passwordBusy: signal.New(false),
|
|
instancesOpen: signal.New(false),
|
|
server: signal.New(""),
|
|
connected: signal.New(false),
|
|
busy: signal.New(false),
|
|
connecting: signal.New(""),
|
|
activeID: signal.New(""),
|
|
sessions: signal.NewFunc([]ocapi.Session{}, nil),
|
|
active: signal.NewFunc(map[string]bool{}, nil),
|
|
perms: signal.NewFunc([]ocapi.PermissionRequest{}, nil),
|
|
defaultDir: signal.New(""),
|
|
newOpen: signal.New(false),
|
|
newTitle: signal.New(""),
|
|
newDir: signal.New(0),
|
|
creating: signal.New(false),
|
|
}
|
|
// Come back to the server last used, as the first-party client does.
|
|
if len(conns) > 0 {
|
|
c.connectTo(conns[0], "", false)
|
|
}
|
|
return c
|
|
}
|
|
|
|
// screen is the app's tree: a navigation stack while connected (its bar
|
|
// holds the session actions), and the bare server list while not, so the
|
|
// list is not framed by a bar whose buttons would do nothing.
|
|
func (c *controller) screen() ui.Node {
|
|
return ui.Column(ui.Style{Grow: 1},
|
|
ui.Show(c.connected,
|
|
func() ui.Node {
|
|
return ui.Stack(c.sessionsScreen, ui.ScreenOptions{
|
|
Title: ui.Val("OpenChamber"),
|
|
Actions: c.barActions(),
|
|
}, ui.Style{Grow: 1})
|
|
},
|
|
func() ui.Node {
|
|
return ui.SafeArea(ui.Style{Grow: 1}, c.connectionsScreen())
|
|
}),
|
|
c.formSheet(),
|
|
c.passwordSheet(),
|
|
c.instancesSheet(),
|
|
c.newSessionSheetNode(),
|
|
)
|
|
}
|
|
|
|
func (c *controller) barActions() []ui.Action {
|
|
return []ui.Action{
|
|
{
|
|
Title: ui.Val("新建"),
|
|
Icon: ui.IconPlus,
|
|
OnPress: c.openNewSession,
|
|
},
|
|
{
|
|
Title: ui.Val("刷新"),
|
|
Icon: ui.IconRefresh,
|
|
Disabled: signal.Func(func() bool { return c.busy.Get() }),
|
|
OnPress: c.refresh,
|
|
},
|
|
}
|
|
}
|
|
|
|
func (c *controller) shutdown() {
|
|
if c.cancelSSE != nil {
|
|
c.cancelSSE()
|
|
c.cancelSSE = nil
|
|
}
|
|
c.client = nil
|
|
}
|
|
|
|
// connectTo starts a connection attempt off the main thread. password is
|
|
// the one the user typed, if any; explicit marks a tap (a password may be
|
|
// asked for), while the launch reconnect stays quiet.
|
|
func (c *controller) connectTo(conn storage.Connection, password string, explicit bool) {
|
|
if c.connecting.Peek() != "" {
|
|
return
|
|
}
|
|
c.connecting.Set(conn.ID)
|
|
c.errorMsg.Set("")
|
|
go func() {
|
|
c.establish(conn, password, explicit)
|
|
}()
|
|
}
|
|
|
|
// establish runs the whole connect sequence: health, token probe, optional
|
|
// password login, first page of sessions.
|
|
func (c *controller) establish(conn storage.Connection, password string, explicit bool) {
|
|
ctx, cancel := context.WithTimeout(context.Background(), 25*time.Second)
|
|
defer cancel()
|
|
|
|
fail := func(err error) {
|
|
ui.Post(func() {
|
|
c.connecting.Set("")
|
|
c.errorMsg.Set(friendlyError(err))
|
|
if c.formConnecting {
|
|
// The connect came from the add/edit form: bring it back
|
|
// with what the user typed so it can be fixed.
|
|
c.formConnecting = false
|
|
c.formOpen.Set(true)
|
|
}
|
|
})
|
|
}
|
|
if !strings.Contains(conn.URL, "://") {
|
|
normalized, err := ocapi.NormalizeBaseURL(conn.URL)
|
|
if err != nil {
|
|
fail(err)
|
|
return
|
|
}
|
|
conn.URL = normalized
|
|
}
|
|
|
|
client, err := ocapi.New(conn.URL, ocapi.Options{Proxy: conn.Proxy, InsecureSkipVerify: conn.Insecure})
|
|
if err != nil {
|
|
fail(err)
|
|
return
|
|
}
|
|
health, err := client.Health(ctx)
|
|
if err != nil {
|
|
fail(err)
|
|
return
|
|
}
|
|
if health.OpenChamberVersion == "" {
|
|
fail(errors.New("这个地址不是 OpenChamber 服务器"))
|
|
return
|
|
}
|
|
|
|
token := ""
|
|
if !conn.Passwordless {
|
|
if t, ok, err := c.st.LoadToken(conn); err == nil && ok {
|
|
token = t
|
|
client.SetToken(t)
|
|
}
|
|
}
|
|
passwordless := conn.Passwordless
|
|
auth, authErr := client.SessionStatus(ctx)
|
|
switch {
|
|
case authErr == nil:
|
|
passwordless = auth.Disabled
|
|
case ocapi.IsUnauthorized(authErr):
|
|
if strings.TrimSpace(password) == "" {
|
|
if explicit {
|
|
ui.Post(func() {
|
|
c.connecting.Set("")
|
|
c.askPassword(conn)
|
|
})
|
|
} else {
|
|
ui.Post(func() {
|
|
c.connecting.Set("")
|
|
c.errorMsg.Set("登录已失效,请重新输入密码")
|
|
c.askPassword(conn)
|
|
})
|
|
}
|
|
if token != "" {
|
|
go func() { _ = c.st.ClearToken(conn) }()
|
|
}
|
|
return
|
|
}
|
|
res, err := client.Login(ctx, ocapi.LoginRequest{
|
|
Password: password,
|
|
DedupeKey: c.st.InstallID(),
|
|
ClientLabel: "OpenChamber Native",
|
|
ClientKind: "mobile",
|
|
DevicePlatform: "android",
|
|
})
|
|
if err != nil {
|
|
ui.Post(func() {
|
|
c.connecting.Set("")
|
|
c.errorMsg.Set(friendlyError(err))
|
|
c.passwordBusy.Set(false)
|
|
c.passwordOpen.Set(true)
|
|
})
|
|
return
|
|
}
|
|
if res.ClientToken == "" {
|
|
fail(errors.New("登录没有返回设备 token"))
|
|
return
|
|
}
|
|
_ = c.st.SaveToken(conn.ID, res.ClientToken)
|
|
passwordless = false
|
|
default:
|
|
fail(authErr)
|
|
return
|
|
}
|
|
|
|
if loc, err := client.Location(ctx); err == nil && loc.Directory != "" {
|
|
ui.Post(func() { c.defaultDir.Set(loc.Directory) })
|
|
}
|
|
page, err := client.ListSessions(ctx, ocapi.ListSessionsOptions{Limit: 50, Order: "desc"})
|
|
if err != nil {
|
|
fail(err)
|
|
return
|
|
}
|
|
active, _ := client.ActiveSessions(ctx)
|
|
running := make(map[string]bool, len(active))
|
|
for id := range active {
|
|
running[id] = true
|
|
}
|
|
perms, _ := client.PendingPermissions(ctx, "")
|
|
|
|
info := fmt.Sprintf("%s · OpenChamber %s", c.labelOf(conn), health.OpenChamberVersion)
|
|
if !health.IsOpenCodeReady {
|
|
info += " · OpenCode 未就绪"
|
|
}
|
|
|
|
conn.URL = client.BaseURL()
|
|
if conn.Label == "" {
|
|
conn.Label = hostOf(conn.URL)
|
|
}
|
|
conn.ServerID = health.ServerID
|
|
conn.Passwordless = passwordless
|
|
conn.LastUsedAt = time.Now().UnixMilli()
|
|
|
|
ui.Post(func() {
|
|
c.connecting.Set("")
|
|
c.saveConnection(conn)
|
|
c.activeID.Set(conn.ID)
|
|
c.client = client
|
|
c.sessions.Set(page.Data)
|
|
c.active.Set(running)
|
|
c.perms.Set(perms)
|
|
c.server.Set(info)
|
|
c.connected.Set(true)
|
|
c.busy.Set(false)
|
|
c.formConnecting = false
|
|
c.formOpen.Set(false)
|
|
c.passwordOpen.Set(false)
|
|
c.passwordText.Set("")
|
|
c.passwordBusy.Set(false)
|
|
c.instancesOpen.Set(false)
|
|
c.errorMsg.Set("")
|
|
c.status.Set(fmt.Sprintf("已连接,%d 个会话", len(page.Data)))
|
|
c.startEvents(client)
|
|
})
|
|
}
|
|
|
|
func (c *controller) saveConnection(conn storage.Connection) {
|
|
conns := c.connections.Peek()
|
|
found := false
|
|
next := make([]storage.Connection, 0, len(conns)+1)
|
|
for _, existing := range conns {
|
|
if existing.ID == conn.ID {
|
|
next = append(next, conn)
|
|
found = true
|
|
} else {
|
|
next = append(next, existing)
|
|
}
|
|
}
|
|
if !found {
|
|
if conn.ID == "" {
|
|
conn.ID = storage.NewID()
|
|
}
|
|
next = append(next, conn)
|
|
}
|
|
sort.SliceStable(next, func(i, j int) bool { return next[i].LastUsedAt > next[j].LastUsedAt })
|
|
c.st.SaveConnections(next)
|
|
c.connections.Set(next)
|
|
}
|
|
|
|
func (c *controller) labelOf(conn storage.Connection) string {
|
|
label := strings.TrimSpace(conn.Label)
|
|
if label != "" && label != conn.URL {
|
|
return label
|
|
}
|
|
if host := hostOf(conn.URL); host != "" {
|
|
return host
|
|
}
|
|
return label
|
|
}
|
|
|
|
// searchSessions runs the query the search field holds.
|
|
func (c *controller) searchSessions(q string) {
|
|
if c.client == nil || c.busy.Peek() {
|
|
return
|
|
}
|
|
c.busy.Set(true)
|
|
client := c.client
|
|
go func() {
|
|
ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
|
|
defer cancel()
|
|
page, err := client.ListSessions(ctx, ocapi.ListSessionsOptions{Limit: 50, Order: "desc", Search: q})
|
|
ui.Post(func() {
|
|
c.busy.Set(false)
|
|
if err != nil {
|
|
c.errorMsg.Set(friendlyError(err))
|
|
return
|
|
}
|
|
c.sessions.Set(page.Data)
|
|
if q == "" {
|
|
c.status.Set(fmt.Sprintf("已更新,%d 个会话", len(page.Data)))
|
|
} else {
|
|
c.status.Set(fmt.Sprintf("找到 %d 个会话", len(page.Data)))
|
|
}
|
|
})
|
|
}()
|
|
}
|
|
|
|
func (c *controller) refresh() {
|
|
if c.client == nil || c.busy.Peek() {
|
|
return
|
|
}
|
|
c.busy.Set(true)
|
|
client := c.client
|
|
go func() {
|
|
ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
|
|
defer cancel()
|
|
page, err := client.ListSessions(ctx, ocapi.ListSessionsOptions{
|
|
Limit: 50, Order: "desc", Search: c.sessionQuery.Peek(),
|
|
})
|
|
active, aerr := client.ActiveSessions(ctx)
|
|
running := make(map[string]bool, len(active))
|
|
for id := range active {
|
|
running[id] = true
|
|
}
|
|
perms, perr := client.PendingPermissions(ctx, "")
|
|
ui.Post(func() {
|
|
c.busy.Set(false)
|
|
if err != nil {
|
|
if ocapi.IsUnauthorized(err) {
|
|
c.logout("登录已失效,请输入密码重新连接")
|
|
return
|
|
}
|
|
c.errorMsg.Set(friendlyError(err))
|
|
return
|
|
}
|
|
c.sessions.Set(page.Data)
|
|
if aerr == nil {
|
|
c.active.Set(running)
|
|
}
|
|
if perr == nil {
|
|
c.perms.Set(perms)
|
|
}
|
|
c.status.Set(fmt.Sprintf("已更新,%d 个会话", len(page.Data)))
|
|
})
|
|
}()
|
|
}
|
|
|
|
// logout drops the live session but keeps the saved servers.
|
|
func (c *controller) logout(reason string) {
|
|
if c.cancelSSE != nil {
|
|
c.cancelSSE()
|
|
c.cancelSSE = nil
|
|
}
|
|
var conn storage.Connection
|
|
if id := c.activeID.Peek(); id != "" {
|
|
for _, saved := range c.connections.Peek() {
|
|
if saved.ID == id {
|
|
conn = saved
|
|
}
|
|
}
|
|
}
|
|
c.client = nil
|
|
c.connected.Set(false)
|
|
c.activeID.Set("")
|
|
c.sessions.Set(nil)
|
|
c.active.Set(map[string]bool{})
|
|
c.perms.Set(nil)
|
|
c.server.Set("")
|
|
c.sessionQuery.Set("")
|
|
c.searchOpen.Set(false)
|
|
c.errorMsg.Set(reason)
|
|
if conn.ID != "" && reason != "" {
|
|
go func() { _ = c.st.ClearToken(conn) }()
|
|
}
|
|
}
|
|
|
|
func (c *controller) disconnect() {
|
|
if c.chat != nil && c.chat.nav != nil && c.chat.nav.Depth() > 1 {
|
|
c.chat.nav.Pop()
|
|
}
|
|
c.logout("")
|
|
}
|
|
|
|
// --- form ---------------------------------------------------------------
|
|
|
|
func (c *controller) openAddForm() {
|
|
c.formEditID = ""
|
|
c.url.Set("")
|
|
c.formLabel.Set("")
|
|
c.formUseProxy.Set(false)
|
|
c.formProxy.Set("")
|
|
c.formInsecure.Set(false)
|
|
c.errorMsg.Set("")
|
|
c.formOpen.Set(true)
|
|
}
|
|
|
|
func (c *controller) openEditForm(conn storage.Connection) {
|
|
c.formEditID = conn.ID
|
|
c.url.Set(conn.URL)
|
|
c.formLabel.Set(conn.Label)
|
|
c.formUseProxy.Set(conn.Proxy != "")
|
|
c.formProxy.Set(conn.Proxy)
|
|
c.formInsecure.Set(conn.Insecure)
|
|
c.errorMsg.Set("")
|
|
c.formOpen.Set(true)
|
|
}
|
|
|
|
func (c *controller) closeForm() {
|
|
c.formOpen.Set(false)
|
|
c.errorMsg.Set("")
|
|
}
|
|
|
|
func (c *controller) submitForm() {
|
|
raw := strings.TrimSpace(c.url.Peek())
|
|
if raw == "" {
|
|
c.errorMsg.Set("请输入服务器地址")
|
|
return
|
|
}
|
|
normalized, err := ocapi.NormalizeBaseURL(raw)
|
|
if err != nil {
|
|
c.errorMsg.Set(friendlyError(err))
|
|
return
|
|
}
|
|
conn := storage.Connection{ID: c.formEditID, URL: normalized, Label: strings.TrimSpace(c.formLabel.Peek())}
|
|
if c.formUseProxy.Peek() {
|
|
conn.Proxy = strings.TrimSpace(c.formProxy.Peek())
|
|
}
|
|
conn.Insecure = c.formInsecure.Peek()
|
|
if conn.ID != "" {
|
|
for _, saved := range c.connections.Peek() {
|
|
if saved.ID == conn.ID {
|
|
conn.ServerID = saved.ServerID
|
|
conn.Passwordless = saved.Passwordless
|
|
conn.LastUsedAt = saved.LastUsedAt
|
|
}
|
|
}
|
|
}
|
|
if conn.ID == "" {
|
|
conn.ID = storage.NewID()
|
|
}
|
|
c.saveConnection(conn)
|
|
c.formOpen.Set(false)
|
|
|
|
if !c.connected.Peek() {
|
|
c.formConnecting = true
|
|
c.connectTo(conn, "", true)
|
|
return
|
|
}
|
|
c.status.Set("已保存")
|
|
}
|
|
|
|
// --- password -----------------------------------------------------------
|
|
|
|
func (c *controller) askPassword(conn storage.Connection) {
|
|
c.passwordFor = conn
|
|
c.passwordText.Set("")
|
|
c.passwordBusy.Set(false)
|
|
c.passwordOpen.Set(true)
|
|
}
|
|
|
|
func (c *controller) submitPassword() {
|
|
if c.passwordBusy.Peek() {
|
|
return
|
|
}
|
|
pw := c.passwordText.Peek()
|
|
if strings.TrimSpace(pw) == "" {
|
|
return
|
|
}
|
|
conn := c.passwordFor
|
|
c.passwordBusy.Set(true)
|
|
c.passwordOpen.Set(false)
|
|
c.connectToPassword(conn, pw)
|
|
}
|
|
|
|
func (c *controller) connectToPassword(conn storage.Connection, password string) {
|
|
if c.connecting.Peek() != "" {
|
|
return
|
|
}
|
|
c.connecting.Set(conn.ID)
|
|
c.errorMsg.Set("")
|
|
go func() { c.establish(conn, password, true) }()
|
|
}
|
|
|
|
func (c *controller) cancelPassword() {
|
|
c.passwordOpen.Set(false)
|
|
c.passwordText.Set("")
|
|
c.passwordBusy.Set(false)
|
|
}
|
|
|
|
var errUnauthorized = errors.New("这个服务器需要密码")
|
|
|
|
func friendlyError(err error) string {
|
|
if err == nil {
|
|
return ""
|
|
}
|
|
if wait, ok := ocapi.IsRateLimited(err); ok {
|
|
secs := int(wait.Seconds() + 0.5)
|
|
if secs <= 0 {
|
|
secs = 30
|
|
}
|
|
return fmt.Sprintf("尝试过于频繁,请 %d 秒后重试", secs)
|
|
}
|
|
if ocapi.IsUnauthorized(err) {
|
|
return "密码错误"
|
|
}
|
|
if errors.Is(err, errUnauthorized) {
|
|
return "该服务器需要密码"
|
|
}
|
|
msg := err.Error()
|
|
switch {
|
|
case strings.Contains(msg, "certificate"):
|
|
return "TLS 证书校验失败:" + msg
|
|
case strings.Contains(msg, "no such host"):
|
|
return "找不到这个地址:" + msg
|
|
case strings.Contains(msg, "connection refused"):
|
|
return "连接被拒绝,请确认服务器地址与端口"
|
|
case strings.Contains(msg, "timeout") || strings.Contains(msg, "deadline exceeded"):
|
|
return "连接超时,请检查网络或代理"
|
|
case strings.Contains(msg, "proxy"):
|
|
return "代理连接失败:" + msg
|
|
}
|
|
return msg
|
|
}
|
|
|
|
func hostOf(raw string) string {
|
|
s := strings.TrimSpace(raw)
|
|
if i := strings.Index(s, "://"); i >= 0 {
|
|
s = s[i+3:]
|
|
}
|
|
if i := strings.IndexByte(s, '/'); i >= 0 {
|
|
s = s[:i]
|
|
}
|
|
return s
|
|
}
|
|
|
|
func shortPath(p string) string {
|
|
p = strings.TrimRight(p, "/")
|
|
if p == "" {
|
|
return ""
|
|
}
|
|
if i := strings.LastIndex(p, "/"); i >= 0 && i+1 < len(p) {
|
|
return p[i+1:]
|
|
}
|
|
return p
|
|
}
|
|
|
|
func relativeTime(ms int64) string {
|
|
if ms <= 0 {
|
|
return ""
|
|
}
|
|
d := time.Since(time.UnixMilli(ms))
|
|
switch {
|
|
case d < time.Minute:
|
|
return "刚刚"
|
|
case d < time.Hour:
|
|
return fmt.Sprintf("%d 分钟前", int(d.Minutes()))
|
|
case d < 24*time.Hour:
|
|
return fmt.Sprintf("%d 小时前", int(d.Hours()))
|
|
default:
|
|
return fmt.Sprintf("%d 天前", int(d.Hours()/24))
|
|
}
|
|
}
|