@mobius-os/mobius 0.3.27 → 0.3.34

package/src/lib/windows-input.ts

@@ -0,0 +1,186 @@
+import { Transform } from 'node:stream'
+
+const ENABLE_WIN32_INPUT_MODE = '\x1b[?9001h'
+const DISABLE_WIN32_INPUT_MODE = '\x1b[?9001l'
+
+const WIN32_KEY_RECORD_RE = /^\x1b\[(\d*);(\d*);(\d*);(\d*);(\d*);(\d*)_/
+
+/**
+ * Decode Windows Terminal's win32-input-mode KEY_EVENT_RECORD sequences back
+ * into the VT input Ink expects. This preserves modifiers that legacy ConPTY
+ * input loses, most importantly the distinction between Enter and Shift+Enter.
+ */
+export class WindowsInputDecoder {
+  private buffer = ''
+
+  get hasPendingInput(): boolean {
+    return this.buffer.length > 0
+  }
+
+  push(chunk: string): string {
+    this.buffer += chunk
+    let output = ''
+
+    while (this.buffer) {
+      const start = this.buffer.indexOf('\x1b[')
+      if (start < 0) {
+        if (this.buffer.endsWith('\x1b')) {
+          output += this.buffer.slice(0, -1)
+          this.buffer = '\x1b'
+        } else {
+          output += this.buffer
+          this.buffer = ''
+        }
+        break
+      }
+
+      output += this.buffer.slice(0, start)
+      this.buffer = this.buffer.slice(start)
+      const match = WIN32_KEY_RECORD_RE.exec(this.buffer)
+      if (match) {
+        this.buffer = this.buffer.slice(match[0].length)
+        output += translateWindowsKeyRecord(match.slice(1))
+        continue
+      }
+
+      if (isPartialWindowsKeyRecord(this.buffer)) break
+
+      // A normal VT sequence (arrows, mouse, paste markers, and so on) is not
+      // part of win32-input-mode. Release its ESC byte and scan the remainder.
+      output += this.buffer[0]
+      this.buffer = this.buffer.slice(1)
+    }
+
+    return output
+  }
+
+  flush(): string {
+    const remainder = this.buffer
+    this.buffer = ''
+    return remainder
+  }
+}
+
+function isPartialWindowsKeyRecord(value: string): boolean {
+  if (value === '\x1b' || value === '\x1b[') return true
+  if (!value.startsWith('\x1b[')) return false
+  const body = value.slice(2)
+  return /^[\d;]*$/.test(body) && body.split(';').length <= 6
+}
+
+function numberParam(value: string | undefined, fallback: number): number {
+  return value === undefined || value === '' ? fallback : Number(value)
+}
+
+function translateWindowsKeyRecord(params: string[]): string {
+  const virtualKey = numberParam(params[0], 0)
+  const unicode = numberParam(params[2], 0)
+  const keyDown = numberParam(params[3], 1) !== 0
+  const controlState = numberParam(params[4], 0)
+  const repeat = Math.max(1, Math.min(100, numberParam(params[5], 1)))
+  if (!keyDown) return ''
+
+  const shift = (controlState & 0x0010) !== 0
+  const leftAlt = (controlState & 0x0002) !== 0
+  const rightAlt = (controlState & 0x0001) !== 0
+  const leftCtrl = (controlState & 0x0008) !== 0
+  const altGr = rightAlt && leftCtrl
+
+  // Modifier-only records carry no text and must not leak into the composer.
+  if (unicode === 0 && [0x10, 0x11, 0x12, 0x14, 0x5b, 0x5c].includes(virtualKey)) return ''
+
+  let encoded = ''
+  if (virtualKey === 0x0d) {
+    encoded = shift ? '\x1b[13;2u' : '\r'
+  } else if (virtualKey === 0x08) {
+    encoded = '\x7f'
+  } else if (virtualKey === 0x09) {
+    encoded = shift ? '\x1b[Z' : '\t'
+  } else if (virtualKey === 0x1b) {
+    encoded = '\x1b'
+  } else if (unicode !== 0) {
+    encoded = String.fromCharCode(unicode)
+    if ((leftAlt || rightAlt) && !altGr) encoded = `\x1b${encoded}`
+  } else {
+    encoded = virtualKeySequence(virtualKey, controlState)
+  }
+
+  return encoded.repeat(repeat)
+}
+
+function virtualKeySequence(virtualKey: number, controlState: number): string {
+  const shift = (controlState & 0x0010) !== 0
+  const alt = (controlState & 0x0003) !== 0
+  const ctrl = (controlState & 0x000c) !== 0
+  const modifier = 1 + (shift ? 1 : 0) + (alt ? 2 : 0) + (ctrl ? 4 : 0)
+  const suffix = modifier === 1 ? '' : `1;${modifier}`
+  const csiLetter: Record<number, string> = {
+    0x23: 'F', 0x24: 'H', 0x25: 'D', 0x26: 'A',
+    0x27: 'C', 0x28: 'B',
+  }
+  if (csiLetter[virtualKey]) return `\x1b[${suffix}${csiLetter[virtualKey]}`
+
+  const csiTilde: Record<number, number> = {
+    0x21: 5, 0x22: 6, 0x2d: 2, 0x2e: 3,
+    0x74: 15, 0x75: 17, 0x76: 18, 0x77: 19,
+    0x78: 20, 0x79: 21, 0x7a: 23, 0x7b: 24,
+  }
+  if (csiTilde[virtualKey]) {
+    const code = csiTilde[virtualKey]
+    return modifier === 1 ? `\x1b[${code}~` : `\x1b[${code};${modifier}~`
+  }
+
+  const ss3: Record<number, string> = { 0x70: 'P', 0x71: 'Q', 0x72: 'R', 0x73: 'S' }
+  if (ss3[virtualKey]) return modifier === 1 ? `\x1bO${ss3[virtualKey]}` : `\x1b[1;${modifier}${ss3[virtualKey]}`
+  return ''
+}
+
+/** Use a translating stdin only on a real Windows TTY; other platforms remain untouched. */
+export function createInkInputStream(
+  input: NodeJS.ReadStream,
+  output: NodeJS.WriteStream,
+): NodeJS.ReadStream {
+  if (process.platform !== 'win32' || !input.isTTY) return input
+
+  const decoder = new WindowsInputDecoder()
+  let modeEnabled = false
+  let pendingTimer: ReturnType<typeof setTimeout> | null = null
+  const translated = new Transform({
+    transform(chunk, _encoding, callback) {
+      if (pendingTimer) clearTimeout(pendingTimer)
+      const decoded = decoder.push(String(chunk))
+      if (decoder.hasPendingInput) {
+        // An unsupported terminal still sends a legacy standalone Esc. Give a
+        // split win32 record one event-loop beat to finish, then release it.
+        pendingTimer = setTimeout(() => {
+          pendingTimer = null
+          translated.push(decoder.flush())
+        }, 15)
+      }
+      callback(null, decoded)
+    },
+    flush(callback) {
+      if (pendingTimer) clearTimeout(pendingTimer)
+      callback(null, decoder.flush())
+    },
+  }) as Transform & Partial<NodeJS.ReadStream>
+
+  Object.defineProperty(translated, 'isTTY', { value: true })
+  Object.defineProperty(translated, 'isRaw', { get: () => input.isRaw })
+  translated.setRawMode = (enabled: boolean) => {
+    input.setRawMode?.(enabled)
+    if (enabled !== modeEnabled) {
+      output.write(enabled ? ENABLE_WIN32_INPUT_MODE : DISABLE_WIN32_INPUT_MODE)
+      modeEnabled = enabled
+    }
+    return translated as NodeJS.ReadStream
+  }
+  translated.ref = () => { input.ref(); return translated as NodeJS.ReadStream }
+  translated.unref = () => { input.unref(); return translated as NodeJS.ReadStream }
+
+  input.pipe(translated)
+  process.once('exit', () => {
+    if (modeEnabled) output.write(DISABLE_WIN32_INPUT_MODE)
+  })
+  return translated as NodeJS.ReadStream
+}

package/src/main.tsx

@@ -9,5 +9,9 @@
 import React from 'react'
 import { render } from 'ink'
 import { App } from './App.js'
+import { createInkInputStream } from './lib/windows-input.js'
 
-render(React.createElement(App), { exitOnCtrlC: true })
+render(React.createElement(App), {
+  exitOnCtrlC: true,
+  stdin: createInkInputStream(process.stdin, process.stdout),
+})

package/src/version.ts

@@ -0,0 +1,21 @@
+/**
+ * The TUI package version has one source of truth: package.json.
+ *
+ * Keep all runtime/UI consumers behind this module so a release cannot show
+ * a stale hard-coded version while the npm package has already been bumped.
+ */
+import { createRequire } from 'node:module'
+
+interface TuiPackageMetadata {
+  name?: string
+  version?: string
+}
+
+const packageJson = createRequire(import.meta.url)('../package.json') as TuiPackageMetadata
+
+if (!packageJson.version) {
+  throw new Error('TUI package.json is missing a version')
+}
+
+export const TUI_VERSION = packageJson.version
+export const TUI_PACKAGE_NAME = packageJson.name ?? '@mobius-os/mobius'

package/tests/aimux.test.tsx

@@ -0,0 +1,210 @@
+/** AIMUX status UI + heartbeat/reconnect regression tests. */
+import React from 'react'
+import { EventEmitter } from 'node:events'
+import { spawn } from 'node:child_process'
+import { promises as fs, existsSync } from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { render } from 'ink-testing-library'
+import { AimuxStatusLine } from '../src/components/AimuxStatus.js'
+import { AimuxSupervisor, probeAimuxBridgeConnection, bundleArch, bundleUrl, spawnLauncher, ensureFromBundle, downloadBundleForTest, reverseConnectArgs, aimuxLogPath, bundleHealthCheckCode } from '../src/aimux.js'
+
+const delay = (ms: number) => new Promise<void>(resolve => setTimeout(resolve, ms))
+let pass = 0, fail = 0
+function ok(condition: boolean, message: string) {
+  if (condition) { pass += 1; console.log(`  ✓ ${message}`) }
+  else { fail += 1; console.error(`  ✗ ${message}`) }
+}
+
+function fakeChild(onKill: () => void): any {
+  const child: any = new EventEmitter()
+  child.pid = 12345
+  child.stdout = new EventEmitter()
+  child.stderr = new EventEmitter()
+  child.kill = () => { onKill(); return true }
+  return child
+}
+
+async function testStatusLine() {
+  console.log('\n[AIMUX 1] status display')
+  const { lastFrame, rerender, unmount } = render(
+    <AimuxStatusLine status={{ state: 'starting', phase: 'install', detail: '下载并安装 aimux… 48%' }} />,
+  )
+  ok((lastFrame() ?? '').includes('AIMUX · 安装') && (lastFrame() ?? '').includes('48%'), 'installation phase and progress stay visible')
+  rerender(<AimuxStatusLine status={{ state: 'failed', phase: 'retrying', detail: '心跳中断，2 秒后进行第 2 次重连…', attempt: 2 }} />)
+  ok((lastFrame() ?? '').includes('AIMUX · 重连') && (lastFrame() ?? '').includes('第 2 次重连'), 'retry phase and attempt are explicit')
+  unmount()
+}
+
+async function testProbeContract() {
+  console.log('\n[AIMUX 2] bridge heartbeat contract')
+  const realFetch = globalThis.fetch
+  let requestedUrl = '', auth = ''
+  globalThis.fetch = (async (input: any, init?: RequestInit) => {
+    requestedUrl = String(input)
+    auth = String((init?.headers as Record<string, string>)?.Authorization ?? '')
+    return new Response(JSON.stringify({ identifier: 'tui-test', event_stream_connected: true }), { status: 200 })
+  }) as typeof fetch
+  try {
+    const connected = await probeAimuxBridgeConnection('https://mobius.test/', 'jwt-test', 'tui-test', 100)
+    ok(connected, 'heartbeat accepts only an active event stream for this identifier')
+    ok(requestedUrl.endsWith('/aimux_bridge/api/remotes/tui-test/connection'), 'heartbeat calls the bridge connection endpoint')
+    ok(auth === 'Bearer jwt-test', 'heartbeat carries the Mobius JWT')
+  } finally { globalThis.fetch = realFetch }
+}
+
+async function testAutomaticReconnect() {
+  console.log('\n[AIMUX 3] heartbeat-triggered reconnect')
+  const statuses: string[] = []
+  let probes = 0, spawns = 0, kills = 0
+  const supervisor = new AimuxSupervisor({
+    server: 'https://mobius.test', token: 'jwt-test', identifier: 'tui-test',
+    heartbeatIntervalMs: 5, heartbeatFailureThreshold: 2, retryBaseMs: 5,
+    probeConnection: async () => { probes += 1; return probes >= 3 },
+    spawnProcess: () => { spawns += 1; return fakeChild(() => { kills += 1 }) },
+    onStatus: status => statuses.push(`${status.state}:${status.phase}:${status.detail}`),
+  })
+  supervisor.start()
+  for (let i = 0; i < 30 && !statuses.some(s => s.startsWith('connected:')); i += 1) await delay(5)
+  ok(kills >= 1, 'two failed heartbeats terminate the stale AIMUX process')
+  ok(spawns >= 2, 'supervisor starts a fresh AIMUX process after heartbeat loss')
+  ok(statuses.some(s => s.includes('第 1 次重连')), 'reconnect status reports its retry attempt')
+  ok(statuses.some(s => s.startsWith('connected:connected:心跳正常')), 'a later successful heartbeat restores connected state')
+  await supervisor.stop()
+}
+
+async function testBundleArchAndUrl() {
+  console.log('\n[AIMUX 4] Plan B bundle arch / url')
+  const arch = bundleArch()
+  ok(arch === 'linux-x64' || arch === 'win-x64' || arch === 'mac-x64', `bundleArch returns a supported arch on this host (${arch})`)
+  const before = bundleUrl('linux-x64')
+  ok(before.includes('mobius-python-linux-x64-v2') && before.endsWith('.zip'), 'bundleUrl follows the fixed filename pattern')
+  const saved = process.env.MOBIUS_TUI_PYTHON_BUNDLE_URL
+  process.env.MOBIUS_TUI_PYTHON_BUNDLE_URL = 'https://example.test/cdn/'
+  try {
+    ok(bundleUrl('win-x64') === 'https://example.test/cdn/mobius-python-win-x64-v2.zip', 'MOBIUS_TUI_PYTHON_BUNDLE_URL overrides the CDN base and trims trailing slash')
+  } finally { if (saved === undefined) delete process.env.MOBIUS_TUI_PYTHON_BUNDLE_URL; else process.env.MOBIUS_TUI_PYTHON_BUNDLE_URL = saved }
+}
+
+async function testPersistentProcessLog() {
+  console.log('\n[AIMUX 9] persistent process diagnostics')
+  const home = await fs.mkdtemp(path.join(os.tmpdir(), 'mobius-tui-aimux-log-'))
+  const savedHome = process.env.MOBIUS_TUI_HOME
+  process.env.MOBIUS_TUI_HOME = home
+  const statuses: string[] = []
+  let childRef: any
+  const supervisor = new AimuxSupervisor({
+    server: 'https://mobius.test', token: 'secret-token', identifier: 'tui-log',
+    retryBaseMs: 100_000,
+    probeConnection: async () => true,
+    spawnProcess: () => {
+      childRef = fakeChild(() => {})
+      return childRef
+    },
+    onStatus: status => statuses.push(status.detail || ''),
+  })
+  supervisor.start()
+  childRef.stderr.emit('data', Buffer.from('Traceback\n  File "site-packages/loguru/_ctime_functions.py", line 7\nImportError: win32_setctime missing\n'))
+  childRef.emit('exit', 1)
+  await delay(40)
+  const log = await fs.readFile(aimuxLogPath(), 'utf8')
+  ok(log.includes('win32_setctime missing') && log.includes('AIMUX exit code=1'), 'AIMUX stdout/stderr and exit code are persisted')
+  ok(log.includes('_ctime_functions.py') && !log.includes('secret-token'), 'diagnostic log keeps traceback context without JWT')
+  ok(statuses.some(s => s.includes('日志:') && s.includes('aimux.log')), 'failure status points to the persistent log path')
+  await supervisor.stop()
+  if (savedHome === undefined) delete process.env.MOBIUS_TUI_HOME; else process.env.MOBIUS_TUI_HOME = savedHome
+  await fs.rm(home, { recursive: true, force: true })
+}
+
+function captureStdout(child: ReturnType<typeof spawn>): Promise<string> {
+  let out = ''
+  child.stdout?.on('data', d => { out += d.toString() })
+  return new Promise(resolve => child.on('close', () => resolve(out)))
+}
+
+async function testSpawnLauncher() {
+  console.log('\n[AIMUX 5] Plan B spawnLauncher routing')
+  // exe launcher: spawn the binary directly with the given args
+  let out = await captureStdout(spawnLauncher({ kind: 'exe', path: '/bin/echo' }, ['HELLO', 'arg']))
+  ok(out.trim() === 'HELLO arg', `exe launcher runs the aimux binary directly (got: ${out.trim()})`)
+  // module launcher: inject `-m aimux` in front (so `<python> -m aimux ...`)
+  out = await captureStdout(spawnLauncher({ kind: 'module', python: '/bin/echo' }, ['reverse', 'connect']))
+  ok(out.trim() === '-m aimux reverse connect', `module launcher prepends -m aimux (got: ${out.trim()})`)
+}
+
+function testReverseConnectArgs() {
+  console.log('\n[AIMUX 6] reverse connect Windows shell visibility')
+  const win = reverseConnectArgs('https://mobius.test/', 'tui-win', 'jwt-test', 'win32')
+  const linux = reverseConnectArgs('https://mobius.test/', 'tui-linux', 'jwt-test', 'linux')
+  ok(win.includes('--silent-shell'), 'Windows reverse connection always requests hidden command shells')
+  ok(!linux.includes('--silent-shell'), 'non-Windows reverse connection does not receive the Windows-only flag')
+  ok(win[2] === 'https://mobius.test/aimux_bridge', 'reverse connection normalizes the bridge URL')
+}
+
+function testBundleHealthCheck() {
+  console.log('\n[AIMUX 6b] bundle dependency health check')
+  const win = bundleHealthCheckCode('win32')
+  const linux = bundleHealthCheckCode('linux')
+  ok(win.includes('aimux.bridge_client') && win.includes('win32_setctime'), 'Windows bundle probe imports the real bridge path and its platform dependency')
+  ok(win.includes("aimux.__version__ == '0.1.21'"), 'bundle probe rejects stale AIMUX versions')
+  ok(!linux.includes('win32_setctime'), 'non-Windows bundle probe does not require the Windows-only package')
+}
+
+async function testEnsureFromBundleReady() {
+  console.log('\n[AIMUX 7] Plan B ensureFromBundle fast-path (bundle already extracted)')
+  const home = await fs.mkdtemp(path.join(os.tmpdir(), 'mobius-tui-bundle-'))
+  const savedHome = process.env.MOBIUS_TUI_HOME
+  process.env.MOBIUS_TUI_HOME = home
+  // 放一个"假 python": 任何 `-c import aimux` 都返回 0 → bundleReady() 为真
+  const fakePy = path.join(home, 'python-bundle', 'python', 'bin', 'python3')
+  await fs.mkdir(path.dirname(fakePy), { recursive: true })
+  await fs.writeFile(fakePy, '#!/bin/sh\nexit 0\n', { mode: 0o755 })
+  try {
+    const r = await ensureFromBundle()
+    ok(r.ok === true && r.launcher?.kind === 'module', 'ensureFromBundle short-circuits when the bundle is already present')
+    ok(r.launcher?.kind === 'module' && r.launcher.python.endsWith(path.join('python-bundle', 'python', 'bin', 'python3')), 'launcher points at the bundled python')
+    ok(!existsSync(path.join(home, 'python-bundle-v1.zip.tmp')), 'no download tmp is left behind on the fast-path')
+  } finally { if (savedHome === undefined) delete process.env.MOBIUS_TUI_HOME; else process.env.MOBIUS_TUI_HOME = savedHome; await fs.rm(home, { recursive: true, force: true }) }
+}
+
+async function testDownloadBundleStream() {
+  console.log('\n[AIMUX 8] Plan B downloadBundle streams body to file + reports progress')
+  const home = await fs.mkdtemp(path.join(os.tmpdir(), 'mobius-tui-dl-'))
+  const savedHome = process.env.MOBIUS_TUI_HOME
+  process.env.MOBIUS_TUI_HOME = home
+  const realFetch = globalThis.fetch
+  const payload = Buffer.from(Array.from({ length: 64 * 1024 }, (_, i) => i & 0xff))
+  globalThis.fetch = (async () => new Response(payload as any, {
+    status: 200, headers: { 'content-length': String(payload.length) },
+  })) as typeof fetch
+  let progressCalls = 0
+  try {
+    const r = await downloadBundleForTest('linux-x64', () => { progressCalls += 1 })
+    ok(r.ok === true && !!r.zipPath, 'downloadBundle writes the streamed body to a zip tmp')
+    const written = await fs.readFile(r.zipPath!)
+    ok(written.length === payload.length && written[0] === 0 && written[65535] === 255, 'downloaded bytes match the streamed payload')
+    ok(progressCalls > 0, 'progress callback fires during streaming download')
+    await fs.unlink(r.zipPath!)
+  } finally {
+    globalThis.fetch = realFetch
+    if (savedHome === undefined) delete process.env.MOBIUS_TUI_HOME; else process.env.MOBIUS_TUI_HOME = savedHome
+    await fs.rm(home, { recursive: true, force: true })
+  }
+}
+
+async function main() {
+  await testStatusLine()
+  await testProbeContract()
+  await testAutomaticReconnect()
+  await testBundleArchAndUrl()
+  await testSpawnLauncher()
+  testReverseConnectArgs()
+  testBundleHealthCheck()
+  await testEnsureFromBundleReady()
+  await testDownloadBundleStream()
+  await testPersistentProcessLog()
+  console.log(`\n==== AIMUX RESULT: ${pass} passed, ${fail} failed ====\n`)
+  process.exit(fail === 0 ? 0 : 1)
+}
+
+main().catch(error => { console.error('FATAL', error); process.exit(2) })

package/tests/flow.test.tsx

@@ -0,0 +1,211 @@
+/**
+ * Flow test — drive the WHOLE App as a user would, end to end, through the real
+ * Ink screens (login → prep wizard → chat → /clear → /resume), against a mocked
+ * backend. Captures rendered frames at each milestone as evidence.
+ *
+ * Run:  npm run test:flow
+ */
+import os from 'node:os'
+import path from 'node:path'
+import fs from 'node:fs'
+
+const TMP_HOME = fs.mkdtempSync(path.join(os.tmpdir(), 'mobius-tui-flow-'))
+process.env.MOBIUS_TUI_HOME = TMP_HOME
+
+import React from 'react'
+import { render } from 'ink-testing-library'
+import { App } from '../src/App.js'
+
+const delay = (ms: number) => new Promise<void>((r) => setTimeout(r, ms))
+const RS: any = (globalThis as any).ReadableStream
+const enc = new TextEncoder()
+let sseController: any = null
+function emit(ev: string, data: Record<string, unknown>) {
+  sseController?.enqueue(enc.encode(`event: ${ev}\ndata: ${JSON.stringify({ event: ev, ...data })}\n\n`))
+}
+function json(body: unknown, status = 200) {
+  return new Response(JSON.stringify(body), { status, headers: { 'content-type': 'application/json' } })
+}
+
+const snapshots: { step: string; frame: string }[] = []
+function snap(step: string, frame: string) { snapshots.push({ step, frame: frame.replace(/\x1b\[[0-9;?]*[a-zA-Z]/g, '') }) }
+
+let pass = 0, fail = 0
+function ok(c: boolean, m: string) { c ? (pass++, console.log(`  ✓ ${m}`)) : (fail++, console.error(`  ✗ ${m}`)) }
+
+// ── mocked backend (precise URL matchers — substring overlaps broke an earlier draft) ─
+const PID = 'proj-1', IID = 'issue-1', SID = 'sess-1'
+function mockFetch(url: string, init?: RequestInit): Response {
+  // SSE
+  if (url.includes('/events')) {
+    return new Response(new RS({ start(c: any) { sseController = c; c.enqueue(enc.encode('event: subscribed\ndata: {"event":"subscribed"}\n\n')) } }),
+      { status: 200, headers: { 'content-type': 'text/event-stream' } })
+  }
+  const method = init?.method ?? 'GET'
+  // auth
+  if (url.endsWith('/api/auth/config')) return json({ password_required: false })
+  if (url.endsWith('/api/auth/me')) return json({ id: 'tester', display_name: 'Test User', role: 'admin', work_dir: '/tmp' })
+  if (url.endsWith('/api/auth/login')) return json({ token: 'mock-jwt-token', user: { id: 'tester', display_name: 'Test User', role: 'admin' } })
+  if (url.includes('/aimux_bridge/api/remotes/') && url.endsWith('/connection')) {
+    const match = url.match(/remotes\/([^/]+)\/connection/)
+    return json({ identifier: match ? decodeURIComponent(match[1]) : 'tui-test', event_stream_connected: true })
+  }
+  // sessions (must be checked before issues/projects — the session URL contains /issues too)
+  if (url.includes('/sessions') && url.includes('/issues') && method === 'POST') return json({ session_id: SID })         // create session
+  if (url.includes('/sessions') && url.includes('/issues') && method === 'GET') {                                            // list sessions (resume)
+    return json([{ session_id: SID, name: '历史会话一', last_active: new Date(Date.now() - 3600_000).toISOString(), message_count: 5, model: 'codex', issue_title: '命令行任务' }])
+  }
+  if (url.endsWith('/messages') && method === 'POST') {
+    setTimeout(() => {
+      emit('typing', { active: true })
+      emit('jsonl_entry', { session_id: SID, entry: { type: 'assistant', message: { role: 'assistant', content: [{ type: 'text', text: '已收到，这是来自 TUI 的回复。' }] } } })
+      emit('typing', { active: false })
+    }, 200)
+    return json({ ok: true, session_id: SID, turn_number: 1 })
+  }
+  if (url.endsWith(`/api/sessions/${SID}/status`)) {
+    return json({ session_id: SID, alive: true, working: false })
+  }
+  // issues
+  if (url.includes('/api/projects/') && url.includes('/issues') && method === 'POST') return json({ id: IID, project_id: PID, title: '命令行任务' })  // create issue
+  if (url.includes('/api/projects/') && url.includes('/issues') && method === 'GET') return json([{ id: IID, project_id: PID, title: '命令行任务' }]) // list issues
+  // projects
+  if (url.includes('/api/projects') && method === 'GET') return json([{ id: PID, name: '已有项目甲' }])   // list projects
+  if (url.endsWith('/api/projects') && method === 'POST') return json({ id: PID, name: '测试项目PTY' })   // create project (exact)
+  // preference lookups
+  if (url.includes('/sessions/model-options')) return json([{ key: 'codex', label: 'GPT-5.5', title: 'GPT-5.5', sub: 'Codex', backend: 'tmux-codex' }])
+  if (url.includes('/sessions/default-model')) return json({ model: 'codex' })
+  if (url.includes('/skills')) return json([])
+  if (url.includes('/memories')) return json([])
+  return json({ error: `unmocked ${method} ${url}` }, 404)
+}
+
+async function waitFor(lastFrame: () => string | undefined, needle: string, timeoutMs = 4000) {
+  for (let i = 0; i < timeoutMs / 50; i++) {
+    if ((lastFrame() ?? '').includes(needle)) return true
+    await delay(50)
+  }
+  return false
+}
+
+async function main() {
+  // Pre-seed login so App auto-logs in (login form itself is covered in ui.test).
+  fs.writeFileSync(path.join(TMP_HOME, 'login.json'), JSON.stringify({
+    server: 'http://mock.local', username: 'tester', token: 'mock-jwt-token',
+    user: { id: 'tester', display_name: 'Test User', role: 'admin' },
+  }))
+  const realFetch = globalThis.fetch
+  globalThis.fetch = ((u: any, init?: any) => mockFetch(String(u), init)) as unknown as typeof fetch
+  process.env.MOBIUS_TUI_DEBUG = '1'
+
+  console.log('\n[FLOW] full App drive (mocked backend)\n')
+  const { stdin, lastFrame, unmount } = render(React.createElement(App))
+
+  try {
+    // ── prep: project picker (auto-logged in) ────────────────────────────────
+    ok(await waitFor(lastFrame, '选择当前路径的绑定项目'), 'booted into project picker')
+    // pick "➕ 创建新项目" (active index 0) → name wizard
+    stdin.write('\r'); await delay(120)
+    ok(await waitFor(lastFrame, '项目名称'), 'project create wizard opened')
+    stdin.write('测试项目PTY'); await delay(120)
+    stdin.write('\r'); await delay(300)                             // submit project name
+    snap('1-prep-project-created', lastFrame() ?? '')
+
+    // ── prep: issue picker (no issues → create) ──────────────────────────────
+    ok(await waitFor(lastFrame, '创建新任务'), 'issue picker shown')
+    stdin.write('\r'); await delay(120)                             // → create-name
+    ok(await waitFor(lastFrame, '输入任务名称'), 'issue name wizard opened')
+    stdin.write('\x1b'); await delay(120)                           // Esc → issue list
+    ok(await waitFor(lastFrame, '选择任务（Issue）'), 'Esc returns from issue name wizard to issue list')
+    stdin.write('\r'); await delay(120)                             // → create-name again
+    ok(await waitFor(lastFrame, '输入任务名称'), 'issue name wizard can be reopened after Esc')
+    stdin.write('命令行任务'); await delay(120)
+    stdin.write('\r'); await delay(300)                             // create issue (worktree off) → model
+
+    // ── prep: preferences ────────────────────────────────────────────────────
+    ok(await waitFor(lastFrame, '选择模型'), 'model picker shown')
+    stdin.write('\r'); await delay(250)                             // pick codex
+    ok(await waitFor(lastFrame, '选择回复语言'), 'language picker shown')
+    stdin.write('\r'); await delay(400)                             // zh; skills+memories empty → auto-skip
+
+    // ── chat ─────────────────────────────────────────────────────────────────
+    ok(await waitFor(lastFrame, '输入问题'), 'entered chat (preferences complete)')
+    snap('2-chat-ready', lastFrame() ?? '')
+
+    // send a message — expect streamed assistant reply
+    stdin.write('你好，请回复一句话'); await delay(120)
+    stdin.write('\r')
+    ok(await waitFor(lastFrame, '已收到', 6000), 'assistant reply streamed into transcript')
+    await delay(300)
+    snap('3-chat-after-reply', lastFrame() ?? '')
+
+    // ── /clear ───────────────────────────────────────────────────────────────
+    stdin.write('/clear'); await delay(120)
+    stdin.write('\r')
+    ok(await waitFor(lastFrame, '输入问题'), '/clear reset to a fresh chat')
+    snap('4-after-clear', lastFrame() ?? '')
+
+    // ── /resume ──────────────────────────────────────────────────────────────
+    // /resume — wait for the post-/clear remount to settle, then type slowly.
+    await delay(500)
+    stdin.write('/resume'); await delay(300)
+    stdin.write('\r')
+    await delay(500)
+    snap('4b-resume-picker', lastFrame() ?? '')
+    ok(await waitFor(lastFrame, '恢复历史会话'), '/resume picker opened')
+    ok((lastFrame() ?? '').includes('历史会话一'), 'resume list shows the past session')
+    stdin.write('\r'); await delay(500)                             // pick session → reconnect SSE
+    ok(await waitFor(lastFrame, '输入问题'), 'resumed into chat')
+    snap('5-after-resume', lastFrame() ?? '')
+
+    // ── /config: full reconfigure (project → issue → model) ──────────────
+    // Unlike /model, /config walks through project, issue, AND model steps.
+    await delay(400)
+    stdin.write('/config'); await delay(300)
+    stdin.write('\r')
+    ok(await waitFor(lastFrame, '重新配置'), '/config opens the full reconfig flow')
+    ok(await waitFor(lastFrame, '选择项目'), '/config shows project picker first')
+    // Pick the first project (created above).
+    stdin.write('\r'); await delay(400)
+    ok(await waitFor(lastFrame, '选择任务'), '/config shows issue picker after project')
+    // Pick the first issue.
+    stdin.write('\r'); await delay(400)
+    ok(await waitFor(lastFrame, '选择模型'), '/config shows model picker after issue')
+    ok(await waitFor(lastFrame, 'GPT-5.5'), '/config model list rendered')
+    stdin.write('\r'); await delay(700)                             // pick codex → create session
+    ok(await waitFor(lastFrame, '输入问题'), '/config creates a fresh session and returns to chat')
+    ok((lastFrame() ?? '').includes('?session=sess-1'), 'reconfigured chat is attached to the new session')
+    snap('6-after-config', lastFrame() ?? '')
+
+    // ── /model: swap model only, keep current task ─────────────────────────
+    // No issue/project step — the current task is kept; pick a model and App
+    // remounts Chat on the eagerly created session.
+    await delay(400)
+    stdin.write('/model'); await delay(300)
+    stdin.write('\r')
+    ok(await waitFor(lastFrame, '更换模型'), '/model opens the model picker directly')
+    ok(await waitFor(lastFrame, '选择模型'), 'model picker shown without an issue-selection step')
+    ok((lastFrame() ?? '').includes('当前任务: 命令行任务'), 'current task is kept (issue not changed)')
+    ok(await waitFor(lastFrame, 'GPT-5.5'), 'model list rendered (Select mounted)')
+    stdin.write('\r'); await delay(700)                             // pick codex → create session
+    ok(await waitFor(lastFrame, '输入问题'), '/model creates a fresh session and returns to chat')
+    ok((lastFrame() ?? '').includes('?session=sess-1'), '/model new session attached')
+    snap('7-after-model', lastFrame() ?? '')
+    snap('6-after-config', lastFrame() ?? '')
+  } finally {
+    unmount()
+    globalThis.fetch = realFetch
+  }
+
+  console.log('\n──────── captured frames ────────')
+  for (const s of snapshots) {
+    console.log(`\n── ${s.step} ──`)
+    console.log(s.frame.replace(/\n{3,}/g, '\n\n').trim())
+  }
+
+  try { fs.rmSync(TMP_HOME, { recursive: true, force: true }) } catch { /* ignore */ }
+  console.log(`\n==== FLOW RESULT: ${pass} passed, ${fail} failed ====\n`)
+  process.exit(fail === 0 ? 0 : 1)
+}
+
+main().catch((e) => { console.error('FATAL', e); process.exit(2) })