@mobius-os/mobius 0.3.27 → 0.3.31

package/src/lib/screen-text.ts

@@ -103,8 +103,29 @@ export function headTailLines(text: string, width: number, maxLines: number): st
 export interface ScreenRows {
   /** Whether this view renders with a leading blank row (its Box has marginTop). */
   marginTop: boolean
-  /** Full screen lines: prefix included, wrapped/truncated, plain text (no ANSI). */
-  rows: string[]
+  /** Full screen rows: a plain layout/copy projection plus its styled ANSI text. */
+  rows: ScreenRow[]
+}
+
+export type ScreenRowTone =
+  | 'normal'
+  | 'user'
+  | 'tool'
+  | 'tool_result'
+  | 'tool_error'
+  | 'edit_header'
+  | 'edit_old'
+  | 'edit_new'
+  | 'reasoning'
+  | 'system'
+  | 'error'
+
+export interface ScreenRow {
+  /** Visible text used for geometry, hit-testing, and clipboard extraction. */
+  plain: string
+  /** Same row with Markdown/syntax ANSI styling preserved for terminal output. */
+  styled: string
+  tone: ScreenRowTone
 }
 
 const textWidth = (columns: number) => Math.max(8, columns - 4)
@@ -114,72 +135,97 @@ const fullWidth = (columns: number) => Math.max(1, columns - 2) // root paddingX
 export function viewScreenRows(view: EntryView, columns: number): ScreenRows {
   const width = textWidth(columns)
   const full = fullWidth(columns)
-  const fit = (rows: string[]): string[] => rows.map((r) => truncateText(r, full))
+  const row = (styled: string, tone: ScreenRowTone = 'normal'): ScreenRow => ({
+    plain: stripAnsi(styled),
+    styled,
+    tone,
+  })
+  // Keep the original styled string and let Ink perform its ANSI-aware
+  // truncate-end rendering. The plain projection mirrors the visible row.
+  const fit = (rows: string[], tone: ScreenRowTone = 'normal'): ScreenRow[] => rows.map((styled) => ({
+    plain: truncateText(stripAnsi(styled), full),
+    styled,
+    tone,
+  }))
+  const wrap = (styled: string, tone: ScreenRowTone = 'normal'): ScreenRow[] => (
+    wrapAnsi(styled, full, { trim: false, hard: true }).split('\n').map(text => row(text, tone))
+  )
   switch (view.kind) {
     case 'skip':
       return { marginTop: false, rows: [] }
     case 'user': {
       const rows = view.text.split('\n').map((l, i) => (i === 0 ? `› ${l}` : `  ${l}`))
-      return { marginTop: true, rows: fit(rows) }
+      return { marginTop: true, rows: fit(rows, 'user') }
     }
     case 'assistant': {
       const md = renderMarkdownLines(view.text)
-      const rows: string[] = []
+      const rows: ScreenRow[] = []
       md.forEach((line, i) => {
         const prefix = i === 0 ? '• ' : '  '
-        const fullLine = prefix + stripAnsi(line.text || ' ')
-        if (line.code) rows.push(truncateText(fullLine, full))
-        else rows.push(...wrapText(fullLine, full))
+        const fullLine = prefix + (line.text || ' ')
+        if (line.code) rows.push(...fit([fullLine]))
+        else rows.push(...wrap(fullLine))
       })
       return { marginTop: true, rows }
     }
     case 'tool_call': {
       const head = clampLines(`${toolLabel(view.toolName)} ${view.summary}`.trim(), width - 2, 1)[0]
-      const rows = [`• ${head}`]
-      if (view.result) rows.push(`  └ ${clampLines(view.result.text, width - 4, 1)[0] || '(无输出)'}`)
-      return { marginTop: true, rows: fit(rows) }
+      const rows = fit([`• ${head}`], 'tool')
+      if (view.result) rows.push(...fit(
+        [`  └ ${clampLines(view.result.text, width - 4, 1)[0] || '(无输出)'}`],
+        view.result.isError ? 'tool_error' : 'tool_result',
+      ))
+      return { marginTop: true, rows }
     }
     case 'tool_result': {
       const lines = headTailLines(view.text, width - 4, 5)
-      return { marginTop: false, rows: fit(lines.map((l, i) => `${i === 0 ? '  └ ' : '    '}${l}`)) }
+      return { marginTop: false, rows: fit(
+        lines.map((l, i) => `${i === 0 ? '  └ ' : '    '}${l}`),
+        view.isError ? 'tool_error' : 'tool_result',
+      ) }
     }
     case 'code_edit': {
-      const rows = [`✎ 编辑 ${view.filePath || '(未指定文件)'}`]
-      if (view.oldString) rows.push(...view.oldString.split('\n').map((l) => `  − ${l}`))
-      if (view.newString) rows.push(...view.newString.split('\n').map((l) => `  + ${l}`))
-      return { marginTop: true, rows: fit(rows) }
+      const rows = fit([`✎ 编辑 ${view.filePath || '(未指定文件)'}`], 'edit_header')
+      if (view.oldString) rows.push(...fit(view.oldString.split('\n').map((l) => `  − ${l}`), 'edit_old'))
+      if (view.newString) rows.push(...fit(view.newString.split('\n').map((l) => `  + ${l}`), 'edit_new'))
+      return { marginTop: true, rows }
     }
     case 'write_file': {
-      const rows = [`✎ 写入 ${view.filePath || '(未指定文件)'}`]
-      rows.push(...view.content.split('\n').map((l) => `  + ${l}`))
-      return { marginTop: true, rows: fit(rows) }
+      const rows = fit([`✎ 写入 ${view.filePath || '(未指定文件)'}`], 'edit_header')
+      rows.push(...fit(view.content.split('\n').map((l) => `  + ${l}`), 'edit_new'))
+      return { marginTop: true, rows }
     }
     case 'reasoning': {
       const lines = clampLines(view.text, width - 4, 2)
-      return { marginTop: true, rows: fit(lines.map((l, i) => `${i === 0 ? '  ◇ ' : '    '}${l}`)) }
+      return { marginTop: true, rows: fit(lines.map((l, i) => `${i === 0 ? '  ◇ ' : '    '}${l}`), 'reasoning') }
     }
     case 'system':
-      return { marginTop: false, rows: fit([`  ${clampLines(view.text, width - 2, 2)[0]}`]) }
+      return { marginTop: false, rows: fit([`  ${clampLines(view.text, width - 2, 2)[0]}`], 'system') }
     case 'error': {
       const rows = view.text.split('\n').map((l, i) => `${i === 0 ? '⚠ ' : '  '}${l}`)
-      return { marginTop: true, rows: fit(rows) }
+      return { marginTop: true, rows: fit(rows, 'error') }
     }
     default:
       return { marginTop: false, rows: [] }
   }
 }
 
-/** Flatten a whole entry (all its views) into screen lines, margins as ''. */
-export function entryScreenLines(views: EntryView[], columns: number): string[] {
-  const lines: string[] = []
+/** Flatten a whole entry into stable rows, with margins represented explicitly. */
+export function entryScreenRows(views: EntryView[], columns: number): ScreenRow[] {
+  const lines: ScreenRow[] = []
   for (const v of views) {
     const { marginTop, rows } = viewScreenRows(v, columns)
-    if (marginTop) lines.push('')
+    if (marginTop) lines.push({ plain: '', styled: '', tone: 'normal' })
     lines.push(...rows)
   }
   return lines
 }
 
+/** Plain projection used by fitting, geometry, hit-testing, and copying. */
+export function entryScreenLines(views: EntryView[], columns: number): string[] {
+  return entryScreenRows(views, columns).map(row => row.plain)
+}
+
 // ── vertical geometry ────────────────────────────────────────────────────────
 export interface TranscriptGeometry {
   /** Screen row where the transcript box's top edge sits. */
@@ -269,7 +315,7 @@ function charAtDisplayWidth(line: string, col: number): number {
     const w = displayWidth(ch)
     if (col < acc + w) return i
     acc += w
-    i++
+    i += ch.length
   }
   return i
 }

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/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) })