A failed connect from the add/edit form reopens it with the typed values and the error, instead of dropping back to the list. Far more useful when the address is wrong. Bump version to 0.1.4 (build 5).
603 lines
15 KiB
Go
603 lines
15 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)
|
|
node := ui.Stack(c.screen, ui.ScreenOptions{
|
|
Title: ui.Val("OpenChamber"),
|
|
Actions: []ui.Action{
|
|
{
|
|
Title: ui.Val("新建"),
|
|
Icon: ui.IconPlus,
|
|
Disabled: signal.Func(func() bool { return !c.connected.Get() }),
|
|
OnPress: c.openNewSession,
|
|
},
|
|
{
|
|
Title: ui.Val("刷新"),
|
|
Icon: ui.IconRefresh,
|
|
Disabled: signal.Func(func() bool { return !c.connected.Get() || c.busy.Get() }),
|
|
OnPress: c.refresh,
|
|
},
|
|
},
|
|
})
|
|
return c, node
|
|
}
|
|
|
|
type controller struct {
|
|
st storage.Store
|
|
|
|
connections *signal.Signal[[]storage.Connection]
|
|
|
|
url *signal.Signal[string]
|
|
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(""),
|
|
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
|
|
}
|
|
|
|
func (c *controller) screen() ui.Node {
|
|
return ui.SafeArea(ui.Style{Grow: 1},
|
|
ui.Show(c.connected, c.sessionsScreen, c.connectionsScreen),
|
|
c.formSheet(),
|
|
c.passwordSheet(),
|
|
c.instancesSheet(),
|
|
c.newSessionSheetNode(),
|
|
)
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
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"})
|
|
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.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))
|
|
}
|
|
}
|