@mobius-os/mobius 0.2.2

package/src/config.ts

@@ -0,0 +1,159 @@
+/**
+ * Local persistence for the Mobius terminal client under ~/.mobius/.
+ *
+ * Files (per the TUI spec):
+ *   login.json                     — { server, username, password?, token, user }
+ *   projects.json                  — cached list of known projects
+ *   dir2project.json               — { [cwd]: projectId }
+ *   dir2project_preference.json    — { [cwd]: CwdPreference }
+ *
+ * "Preferences are saved inside the task (Issue)": each cwd remembers the
+ * currently-selected issueId plus a per-issue preference store, so switching
+ * issues restores that issue's model / language / skill / memory choices.
+ *
+ * The base directory is resolved lazily so tests can redirect it via the
+ * MOBIUS_TUI_HOME env var (or setMobiusHome()) without touching the real home.
+ */
+import { promises as fs } from 'node:fs'
+import path from 'node:path'
+import os from 'node:os'
+import type { Project, User } from './types.js'
+
+let _homeOverride: string | null = null
+export function setMobiusHome(p: string): void { _homeOverride = p }
+export function mobiusHome(): string {
+  return _homeOverride ?? process.env.MOBIUS_TUI_HOME ?? path.join(os.homedir(), '.mobius')
+}
+const LOGIN_FILE = () => path.join(mobiusHome(), 'login.json')
+const PROJECTS_FILE = () => path.join(mobiusHome(), 'projects.json')
+const DIR2PROJECT_FILE = () => path.join(mobiusHome(), 'dir2project.json')
+const PREFERENCE_FILE = () => path.join(mobiusHome(), 'dir2project_preference.json')
+
+export const MOBIUS_DIR = mobiusHome() // back-compat for any importer
+
+export interface LoginRecord {
+  server: string
+  username: string
+  password?: string
+  token: string
+  user: User
+}
+
+/** Preferences bound to a single Issue (task). */
+export interface IssuePreference {
+  model?: string
+  language?: 'zh' | 'en'
+  excluded_skill_ids: string[]
+  excluded_memory_ids: string[]
+  /** completed wizard step keys: 'model' | 'language' | 'skills' | 'memories' */
+  done?: string[]
+}
+
+/** Per-cwd preference state: which issue is active + each issue's saved prefs. */
+export interface CwdPreference {
+  issueId?: string
+  issueTitle?: string
+  prefs: { [issueId: string]: IssuePreference }
+}
+
+async function readJson<T>(file: string, fallback: T): Promise<T> {
+  try {
+    const raw = await fs.readFile(file, 'utf8')
+    return JSON.parse(raw) as T
+  } catch {
+    return fallback
+  }
+}
+
+async function writeJson(file: string, data: unknown): Promise<void> {
+  await fs.mkdir(mobiusHome(), { recursive: true })
+  await fs.writeFile(file, JSON.stringify(data, null, 2), { mode: 0o600 })
+}
+
+// ── login.json ───────────────────────────────────────────────────────────────
+export async function loadLogin(): Promise<LoginRecord | null> {
+  const rec = await readJson<LoginRecord | null>(LOGIN_FILE(), null)
+  if (!rec || !rec.token || !rec.server) return null
+  return rec
+}
+
+export async function saveLogin(rec: LoginRecord): Promise<void> {
+  await writeJson(LOGIN_FILE(), rec)
+}
+
+export async function clearLogin(): Promise<void> {
+  try { await fs.unlink(LOGIN_FILE()) } catch { /* ignore */ }
+}
+
+// ── projects.json (cache) ────────────────────────────────────────────────────
+export async function loadProjectsCache(): Promise<Project[]> {
+  const data = await readJson<{ projects?: Project[] } | Project[]>(PROJECTS_FILE(), [])
+  return Array.isArray(data) ? data : (data.projects ?? [])
+}
+
+export async function saveProjectsCache(projects: Project[]): Promise<void> {
+  await writeJson(PROJECTS_FILE(), { projects })
+}
+
+// ── dir2project.json ─────────────────────────────────────────────────────────
+export async function loadDir2Project(): Promise<Record<string, string>> {
+  return readJson<Record<string, string>>(DIR2PROJECT_FILE(), {})
+}
+
+export async function saveDir2Project(map: Record<string, string>): Promise<void> {
+  await writeJson(DIR2PROJECT_FILE(), map)
+}
+
+export async function bindCwdToProject(cwd: string, projectId: string): Promise<void> {
+  const map = await loadDir2Project()
+  map[cwd] = projectId
+  await saveDir2Project(map)
+}
+
+// ── dir2project_preference.json ──────────────────────────────────────────────
+export async function loadPreferences(): Promise<Record<string, CwdPreference>> {
+  return readJson<Record<string, CwdPreference>>(PREFERENCE_FILE(), {})
+}
+
+export async function savePreferences(map: Record<string, CwdPreference>): Promise<void> {
+  await writeJson(PREFERENCE_FILE(), map)
+}
+
+export async function getCwdPreference(cwd: string): Promise<CwdPreference> {
+  const map = await loadPreferences()
+  return map[cwd] ?? { prefs: {} }
+}
+
+/** Persist the active issue for a cwd. */
+export async function setCwdIssue(cwd: string, issueId: string, issueTitle?: string): Promise<IssuePreference> {
+  const map = await loadPreferences()
+  const cur = map[cwd] ?? { prefs: {} }
+  cur.issueId = issueId
+  cur.issueTitle = issueTitle
+  if (!cur.prefs[issueId]) {
+    cur.prefs[issueId] = { excluded_skill_ids: [], excluded_memory_ids: [] }
+  }
+  map[cwd] = cur
+  await savePreferences(map)
+  return cur.prefs[issueId]
+}
+
+/** Update one issue's preference fields for the cwd (merges into stored). */
+export async function updateIssuePreference(
+  cwd: string,
+  issueId: string,
+  patch: Partial<IssuePreference>,
+): Promise<IssuePreference> {
+  const map = await loadPreferences()
+  const cur = map[cwd] ?? { prefs: {} }
+  const base: IssuePreference = cur.prefs[issueId] ?? { excluded_skill_ids: [], excluded_memory_ids: [] }
+  const merged: IssuePreference = { ...base, ...patch }
+  cur.prefs[issueId] = merged
+  map[cwd] = cur
+  await savePreferences(map)
+  return merged
+}
+
+export function cwd(): string {
+  return process.cwd()
+}

package/src/hooks/useChat.ts

@@ -0,0 +1,332 @@
+/**
+ * useChat — drives one Mobius chat session.
+ *
+ * Lifecycle (per the TUI spec):
+ *   - lazily create a session (POST /api/issues/:issueId/sessions) on the first
+ *     submitted message, using the saved preferences;
+ *   - open the SSE stream (GET /api/sessions/:id/events?token=) and append
+ *     `jsonl_entry` payloads to the transcript as they arrive;
+ *   - keep the agent's busy state synchronized with the runtime status API.
+ * `/clear` remounts the hook (fresh session next time); `/resume` injects a
+ * pre-existing sessionId so the stream replays its history.
+ */
+import { useCallback, useEffect, useRef, useState } from 'react'
+import { MobiusClient, ApiError } from '../api.js'
+import { SseConnection } from '../sse.js'
+import { updateIssuePreference } from '../config.js'
+import { tuiAimuxIdentifier, probeAimuxBridgeConnection } from '../aimux.js'
+import type { AnyEntry } from '../types.js'
+import type { ReadyState } from '../components/PrepScreen.js'
+
+export interface ChatApi {
+  client: MobiusClient
+  ready: ReadyState
+  resumeSessionId?: string | null
+}
+
+export interface ChatController {
+  entries: AnyEntry[]
+  pendingUser: string | null
+  typing: boolean
+  sending: boolean
+  error: string | null
+  sessionId: string | null
+  send: (text: string) => Promise<void>
+  stop: () => Promise<void>
+}
+
+let ID = 0
+function nextId(): number { ID += 1; return ID }
+
+// Retry transient gateway/transport errors so a brief 502/503/504 (a reverse-
+// proxy blip, a backend worker recycling after a deploy, a transient upstream
+// failure) doesn't immediately fail a message dispatch. 4xx errors are not
+// retried — repeating them won't change the outcome. The caller passes one
+// fixed reqId so the backend can de-duplicate across attempts.
+async function sendWithRetry(fn: () => Promise<unknown>, maxAttempts = 3): Promise<void> {
+  for (let attempt = 0; ; attempt++) {
+    try {
+      await fn()
+      return
+    } catch (e: any) {
+      const status = e?.status
+      const transient =
+        status === 502 || status === 503 || status === 504 ||
+        status === 0 || e?.name === 'TypeError' // fetch-level network failure
+      if (!transient || attempt >= maxAttempts - 1) throw e
+      await new Promise(r => setTimeout(r, 500 * 2 ** attempt))
+    }
+  }
+}
+
+export function useChat({ client, ready, resumeSessionId }: ChatApi): ChatController {
+  const [sessionId, setSessionId] = useState<string | null>(resumeSessionId ?? null)
+  const [entries, setEntries] = useState<AnyEntry[]>([])
+  const [pendingUser, setPendingUser] = useState<string | null>(null)
+  const [typing, setTyping] = useState(false)
+  const [sending, setSending] = useState(false)
+  const [error, setError] = useState<string | null>(null)
+  const sseRef = useRef<SseConnection | null>(null)
+  const pollNowRef = useRef<(() => void) | null>(null)
+  const typingRef = useRef(false)
+  const sendingRef = useRef(false)
+  const workingHintUntilRef = useRef(0)
+  const statusEpochRef = useRef(0)
+  // SSE auto-reconnect state. A reverse proxy's idle timeout (or a server
+  // restart) drops the stream mid-session; without reconnect the TUI stops
+  // receiving new jsonl entries even though the web client keeps updating.
+  // On reconnect the server replays jsonl_history, so no entries are lost.
+  const reconnectTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null)
+  const reconnectAttemptRef = useRef(0)
+  const aliveRef = useRef(true)
+  const stoppedRef = useRef(false)
+  const doConnectRef = useRef<(sid: string) => void>(() => {})
+
+  const updateTyping = useCallback((active: boolean) => {
+    typingRef.current = active
+    setTyping(active)
+  }, [])
+
+  const appendEntries = useCallback((newOnes: AnyEntry[]) => {
+    if (!newOnes.length) return
+    setEntries(prev => {
+      const stamped = newOnes.map(e => ({ ...e, __id: e.__id ?? nextId() }))
+      return [...prev, ...stamped]
+    })
+  }, [])
+
+  const setHistory = useCallback((list: AnyEntry[]) => {
+    setEntries(list.map(e => ({ ...e, __id: e.__id ?? nextId() })))
+  }, [])
+
+  // ── SSE connection ────────────────────────────────────────────────────────
+  const connect = useCallback((sid: string) => {
+    if (process.env.MOBIUS_TUI_DEBUG) console.error('[connect]', sid)
+    sseRef.current?.close()
+    if (reconnectTimerRef.current) { clearTimeout(reconnectTimerRef.current); reconnectTimerRef.current = null }
+    const url = `${client.server}/api/sessions/${encodeURIComponent(sid)}/events?token=${encodeURIComponent(client.token)}`
+    const conn = new SseConnection(url, {
+      onHistoryEntries: (es, _done) => {
+        if (es.length) setHistory(es)
+      },
+      onEntry: (entry) => {
+        if (process.env.MOBIUS_TUI_DEBUG) console.error('[onEntry]', entry?.type, (entry?.message?.content?.[0]?.text ?? '').slice(0, 40))
+        appendEntries([entry])
+        setPendingUser(null)
+      },
+      onSubscribed: () => { reconnectAttemptRef.current = 0 },
+      onTyping: (active) => {
+        // SSE is a low-latency hint, not the source of truth. A `true` event
+        // lights the indicator immediately; either edge requests a fresh
+        // runtime status so missed/replayed events cannot leave stale UI.
+        statusEpochRef.current += 1
+        if (active) {
+          workingHintUntilRef.current = Date.now() + 1_500
+          updateTyping(true)
+        } else {
+          workingHintUntilRef.current = 0
+        }
+        pollNowRef.current?.()
+      },
+      onError: (msg) => setError(msg),
+      onClose: () => {
+        // Reconnect with exponential backoff as long as the session is still
+        // alive; stop once it ends (alive=false) or after a few failed tries.
+        if (stoppedRef.current || !aliveRef.current) return
+        const attempt = reconnectAttemptRef.current
+        if (attempt >= 6) return
+        const delay = Math.min(15_000, 500 * 2 ** attempt)
+        reconnectAttemptRef.current = attempt + 1
+        reconnectTimerRef.current = setTimeout(() => {
+          reconnectTimerRef.current = null
+          if (!stoppedRef.current) doConnectRef.current(sid)
+        }, delay)
+      },
+    })
+    sseRef.current = conn
+    conn.start()
+  }, [client.server, client.token, appendEntries, setHistory, updateTyping])
+  doConnectRef.current = connect
+
+  // Connect immediately when a resume session is provided, or after we create one.
+  useEffect(() => {
+    if (sessionId && !sseRef.current) connect(sessionId)
+    return () => { /* keep connection across re-renders; closed on unmount */ }
+  }, [sessionId, connect])
+
+  useEffect(() => () => {
+    stoppedRef.current = true
+    sseRef.current?.close()
+    if (reconnectTimerRef.current) clearTimeout(reconnectTimerRef.current)
+  }, [])
+
+  // ── Runtime status synchronization ──────────────────────────────────────
+  // GET /api/sessions/:id/status is the only authoritative execution state.
+  // Poll recursively after each request completes so a slow network cannot
+  // accumulate overlapping requests. SSE merely asks this loop to run sooner.
+  useEffect(() => {
+    if (!sessionId) return
+
+    let stopped = false
+    let inFlight = false
+    let rerunImmediately = false
+    let timer: ReturnType<typeof setTimeout> | null = null
+    let controller: AbortController | null = null
+    let poll: () => Promise<void>
+
+    const schedule = (delayMs: number) => {
+      if (stopped) return
+      if (timer) clearTimeout(timer)
+      timer = setTimeout(() => { void poll() }, delayMs)
+    }
+
+    const requestNow = () => {
+      if (stopped) return
+      if (inFlight) {
+        rerunImmediately = true
+        return
+      }
+      schedule(0)
+    }
+
+    poll = async () => {
+      if (stopped || inFlight) return
+      inFlight = true
+      timer = null
+      const epoch = statusEpochRef.current
+      controller = new AbortController()
+      const timeout = setTimeout(() => controller?.abort(), 10_000)
+      let nextDelay = 5_000
+
+      try {
+        const status = await client.sessionStatus(sessionId, controller.signal)
+        if (stopped || epoch !== statusEpochRef.current) return
+        aliveRef.current = !!status.alive
+
+        if (status.alive && status.working) {
+          workingHintUntilRef.current = 0
+          updateTyping(true)
+          nextDelay = 2_000
+        } else {
+          const hintRemaining = workingHintUntilRef.current - Date.now()
+          if (hintRemaining > 0 || sendingRef.current) {
+            // Session creation and message dispatch can briefly precede the
+            // worker becoming observable. Preserve instant feedback while
+            // retrying quickly, with a bounded grace period.
+            updateTyping(true)
+            nextDelay = Math.max(100, Math.min(500, hintRemaining || 500))
+          } else {
+            updateTyping(false)
+            nextDelay = status.alive ? 5_000 : 15_000
+          }
+        }
+      } catch (e: any) {
+        // A status timeout or transient transport error must not disturb the
+        // transcript or make Working flicker. The next recursive poll retries.
+        if (process.env.MOBIUS_TUI_DEBUG && e?.name !== 'AbortError') {
+          console.error('[status-poll]', e?.message ?? e)
+        }
+        nextDelay = typingRef.current ? 2_000 : 5_000
+      } finally {
+        clearTimeout(timeout)
+        controller = null
+        inFlight = false
+        if (!stopped) {
+          if (rerunImmediately) {
+            rerunImmediately = false
+            schedule(0)
+          } else {
+            schedule(nextDelay)
+          }
+        }
+      }
+    }
+
+    pollNowRef.current = requestNow
+    requestNow()
+
+    return () => {
+      stopped = true
+      pollNowRef.current = null
+      if (timer) clearTimeout(timer)
+      controller?.abort()
+    }
+  }, [client, sessionId, updateTyping])
+
+  const ensureSession = useCallback(async (): Promise<string> => {
+    if (sessionId) return sessionId
+    const { project, issue, prefs } = ready
+    // 创建会话前确认 aimux reverse connect 已注册到服务器 bridge, 否则 codex 启动时
+    // 注入的 MCP server (aimux mcp serve --remote <id>) 会因 remote 不存在而退出.
+    // 不阻塞创建: 超时则继续 (aimux mcp serve 自身会兜底校验并报错给 codex).
+    const aimuxId = tuiAimuxIdentifier()
+    const probeDeadline = Date.now() + 8000
+    while (Date.now() < probeDeadline) {
+      try { if (await probeAimuxBridgeConnection(client.server, client.token, aimuxId)) break } catch {}
+      await new Promise(r => setTimeout(r, 500))
+    }
+    const name = `TUI ${new Date().toISOString().slice(5, 16).replace('T', ' ')}`
+    const s = await client.createSession(issue.id, {
+      name,
+      model: prefs.model,
+      language: prefs.language,
+      excluded_skill_ids: prefs.excluded_skill_ids,
+      excluded_memory_ids: prefs.excluded_memory_ids,
+      pc_client_metadata: {
+        work_mode: 'pc',
+        aimux_id: tuiAimuxIdentifier(),
+        local_path: process.cwd(),
+        is_tui: true,
+        add_remote_aimux_mcp: true,
+      },
+    })
+    const sid = s.session_id
+    setSessionId(sid)
+    // persist the chosen model/language onto this issue for next time
+    await updateIssuePreference(process.cwd(), issue.id, { model: prefs.model, language: prefs.language })
+    return sid
+  }, [sessionId, ready, client])
+
+  const send = useCallback(async (text: string) => {
+    const body = text.trim()
+    if (!body || sending) return
+    setError(null)
+    setPendingUser(body)
+    statusEpochRef.current += 1
+    workingHintUntilRef.current = Date.now() + 2_000
+    sendingRef.current = true
+    updateTyping(true)
+    setSending(true)
+    try {
+      const sid = await ensureSession()
+      // SSE may not be connected yet for a freshly created session; give it a tick.
+      if (!sseRef.current) await new Promise(r => setTimeout(r, 200))
+      if (process.env.MOBIUS_TUI_DEBUG) console.error('[send-post]', sid, 'sse=', !!sseRef.current, 'closed=', sseRef.current?.isClosed())
+      const reqId = `tui-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`
+      await sendWithRetry(() => client.sendMessage(sid, body, reqId))
+      pollNowRef.current?.()
+    } catch (e: any) {
+      const msg = e instanceof ApiError ? e.message : `发送失败: ${e?.message ?? e}`
+      setError(msg)
+      setPendingUser(null)
+      workingHintUntilRef.current = 0
+      updateTyping(false)
+    } finally {
+      sendingRef.current = false
+      setSending(false)
+      pollNowRef.current?.()
+    }
+  }, [sending, ensureSession, client, updateTyping])
+
+  const stop = useCallback(async () => {
+    if (!sessionId) return
+    statusEpochRef.current += 1
+    workingHintUntilRef.current = 0
+    sendingRef.current = false
+    updateTyping(false)
+    try { await client.stopSession(sessionId) } catch { /* ignore */ }
+    pollNowRef.current?.()
+  }, [sessionId, client, updateTyping])
+
+  return { entries, pendingUser, typing, sending, error, sessionId, send, stop }
+}