@lijian-ui/dsh-term 0.2.0 → 0.3.0

package/src/client/term/term.module.css

@@ -151,3 +151,140 @@
   color: var(--aion-text-tertiary, #86909c);
   font-size: 13px;
 }
+
+.shellSelect {
+  flex: none;
+  height: 22px;
+  padding: 0 6px;
+  border: 1px solid var(--aion-border-base, #e5e6eb);
+  border-radius: 5px;
+  background: var(--aion-bg-base, #ffffff);
+  color: var(--aion-text-primary, #1f2329);
+  font-size: 12px;
+  cursor: pointer;
+  outline: none;
+}
+
+.shellSelect:hover {
+  border-color: var(--aion-border-strong, #c9cdd4);
+}
+
+.shellSelect:focus {
+  border-color: var(--aion-primary, #1677ff);
+}
+
+.reopenBtn {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  height: 22px;
+  padding: 0 6px;
+  border: none;
+  border-radius: 5px;
+  background: var(--aion-bg-2, #f2f3f5);
+  color: var(--aion-text-secondary, #454d5f);
+  font-size: 12px;
+  cursor: pointer;
+  gap: 2px;
+}
+
+.reopenBtn:hover {
+  background: var(--aion-bg-3, #e5e6eb);
+  color: var(--aion-text-primary, #000000);
+}
+
+.reopenDropdown {
+  position: absolute;
+  top: 32px;
+  left: 6px;
+  z-index: 50;
+  min-width: 180px;
+  max-width: 280px;
+  padding: 4px 0;
+  border: 1px solid var(--aion-border-base, #e5e6eb);
+  border-radius: 8px;
+  background: var(--aion-bg-base, #ffffff);
+  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.08);
+}
+
+.reopenHeader {
+  padding: 4px 10px;
+  font-size: 11px;
+  font-weight: 600;
+  color: var(--aion-text-tertiary, #86909c);
+  user-select: none;
+}
+
+.reopenItem {
+  display: flex;
+  align-items: center;
+  gap: 4px;
+  padding: 0 6px 0 4px;
+}
+
+.reopenItemBtn {
+  flex: 1;
+  display: flex;
+  align-items: center;
+  height: 28px;
+  padding: 0 8px;
+  border: none;
+  border-radius: 5px;
+  background: transparent;
+  color: var(--aion-text-primary, #1f2329);
+  font-size: 12px;
+  cursor: pointer;
+  text-align: left;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.reopenItemBtn:hover {
+  background: var(--aion-bg-2, #f2f3f5);
+}
+
+.reopenItemKill {
+  flex: none;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 20px;
+  height: 20px;
+  border: none;
+  border-radius: 4px;
+  background: transparent;
+  color: var(--aion-text-tertiary, #86909c);
+  font-size: 13px;
+  cursor: pointer;
+}
+
+.reopenItemKill:hover {
+  background: var(--aion-bg-3, #e5e6eb);
+  color: var(--aion-text-primary, #000000);
+}
+
+.addToChatBtn {
+  position: absolute;
+  z-index: 60;
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
+  height: 28px;
+  padding: 0 10px;
+  border: 1px solid var(--aion-border-base, #e5e6eb);
+  border-radius: 14px;
+  background: var(--aion-bg-base, #ffffff);
+  color: var(--aion-text-primary, #1f2329);
+  font-size: 12px;
+  font-weight: 500;
+  cursor: pointer;
+  box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
+  white-space: nowrap;
+}
+
+.addToChatBtn:hover {
+  background: var(--aion-bg-2, #f2f3f5);
+  border-color: var(--aion-primary, #1677ff);
+  color: var(--aion-primary, #1677ff);
+}

package/src/core/types.ts

@@ -4,6 +4,16 @@
  * @module dsh-term/core/types
  */
 
+/** Shell kinds the user can pick from in the panel dropdown. */
+export type ShellType = 'bash' | 'zsh' | 'powershell' | 'cmd' | 'gitbash'
+
+/** One shell option surfaced to the browser (id + display label key). */
+export interface ShellInfo {
+  readonly id: ShellType
+  /** i18n key suffix, e.g. 'bash' → t('ui.shell.bash'). */
+  readonly labelKey: string
+}
+
 /** One live PTY session as the browser knows it. */
 export interface TermSessionInfo {
   /** Stable session id (the wire handle). */
@@ -19,21 +29,27 @@ export interface TermSessionInfo {
   readonly alive: boolean
   /** POSIX exit code when the session ended (null while alive). */
   readonly exitCode: number | null
+  /** Shell kind this session was spawned with. */
+  readonly shell: ShellType
+  /** Whether the session is detached (tab closed but PTY still running). */
+  readonly detached: boolean
 }
 
 /** Request: open a new PTY session. */
 export interface TermSpawnRequest {
   /** Optional session display name. */
   name?: string
-  /** Working directory (defaults to the session's workspace cwd). */
+  /** Working directory (defaults to the session's workspace cwd, fallback homedir). */
   cwd?: string
-  /** Shell executable (defaults to the platform shell). */
-  shell?: string
+  /** Shell kind (defaults to the platform default). */
+  shell?: ShellType
   /** Shell arguments (defaults to an interactive login-less profile). */
   args?: string[]
   /** Initial terminal size. */
   cols?: number
   rows?: number
+  /** Extra environment variables merged into the PTY env. */
+  env?: Record<string, string>
 }
 
 /** Request: deliver terminal input. */
@@ -65,9 +81,11 @@ export interface TermListResponse {
 /** One output chunk pushed over the SSE change stream. */
 export type TermEvent =
   | { readonly kind: 'output'; readonly id: string; readonly data: string }
-  | { readonly kind: 'exit'; readonly id: string; readonly exitCode: number }
+  | { readonly kind: 'exit'; readonly id: string; readonly exitCode: number; readonly message?: string }
   | { readonly kind: 'start'; readonly session: TermSessionInfo }
   | { readonly kind: 'closed'; readonly id: string }
+  | { readonly kind: 'detached'; readonly id: string }
+  | { readonly kind: 'reattached'; readonly session: TermSessionInfo }
 
 /** The workspace-gated session id (host-minted; the wire carries only this). */
 export type TermSessionId = string

package/src/gateway/i18n.ts

@@ -0,0 +1,67 @@
+/**
+ * 国际化模块：dsh-term Host 端中英文翻译。
+ *
+ * 用法：
+ *   const t = createTranslator('en')
+ *   t('msg.sessionExited', 0)  // → "Session exited (code 0)"
+ *
+ * @module dsh-term/gateway/i18n
+ */
+
+export type Lang = 'zh' | 'en'
+
+type Dict = Record<string, string>
+
+const zh: Dict = {
+  // ── pty-service.ts / TerminalPanel.tsx ──
+  'msg.sessionExited': '[dsh-term] 进程已退出（code {0}）',
+  'msg.spawnFailed': '[dsh-term] 启动失败: {0}',
+  'ui.panel.title': '终端',
+  'ui.panel.addTabTitle': '新建终端',
+  'ui.panel.collapseTitle': '收起',
+  'ui.panel.emptyHint': '点击 + 新建终端',
+  'ui.dock.label': '终端',
+  'ui.tab.closeAria': '关闭 {0}',
+  'ui.panel.shellTitle': 'Shell',
+  'ui.shell.bash': 'Bash',
+  'ui.shell.zsh': 'Zsh',
+  'ui.shell.powershell': 'PowerShell',
+  'ui.shell.cmd': '命令提示符',
+  'ui.shell.gitbash': 'Git Bash',
+}
+
+const en: Dict = {
+  'msg.sessionExited': '[dsh-term] Process exited (code {0})',
+  'msg.spawnFailed': '[dsh-term] Spawn failed: {0}',
+  'ui.panel.title': 'Terminal',
+  'ui.panel.addTabTitle': 'New Terminal',
+  'ui.panel.collapseTitle': 'Collapse',
+  'ui.panel.emptyHint': 'Click + to create a terminal',
+  'ui.dock.label': 'Terminal',
+  'ui.tab.closeAria': 'Close {0}',
+  'ui.panel.shellTitle': 'Shell',
+  'ui.shell.bash': 'Bash',
+  'ui.shell.zsh': 'Zsh',
+  'ui.shell.powershell': 'PowerShell',
+  'ui.shell.cmd': 'Command Prompt',
+  'ui.shell.gitbash': 'Git Bash',
+}
+
+const dicts: Record<Lang, Dict> = { zh, en }
+
+export class Translator {
+  constructor(readonly lang: Lang) {}
+
+  t(key: string, ...args: (string | number)[]): string {
+    const dict = dicts[this.lang] ?? zh
+    let s = dict[key] ?? zh[key] ?? key
+    for (let i = 0; i < args.length; i++) {
+      s = s.replaceAll(`{${i}}`, String(args[i]))
+    }
+    return s
+  }
+}
+
+export function createTranslator(lang: Lang): Translator {
+  return new Translator(lang)
+}

package/src/host/pty-service.ts

@@ -13,8 +13,12 @@
  */
 
 import { randomUUID } from 'node:crypto'
+import { existsSync, statSync } from 'node:fs'
+import { exec } from 'node:child_process'
+import { resolve } from 'node:path'
+import { homedir } from 'node:os'
 import * as nodePty from 'node-pty'
-import type { TermSessionInfo, TermSpawnRequest } from '../core/types.ts'
+import type { ShellInfo, ShellType, TermSessionInfo, TermSpawnRequest } from '../core/types.ts'
 
 /** Live session plus its pty handle (service-private). */
 interface LiveSession {
@@ -22,17 +26,89 @@ interface LiveSession {
   readonly pty: nodePty.IPty
 }
 
-/** Default interactive shell for the platform. */
-export function defaultShell(): string {
-  if (process.platform === 'win32') return 'powershell.exe'
-  return process.env.SHELL ?? '/bin/bash'
+const IS_WIN = process.platform === 'win32'
+
+/** Windows-only Git Bash locations. */
+const GIT_BASH_CANDIDATES_WIN = [
+  'C:\\Program Files\\Git\\bin\\bash.exe',
+  'C:\\Program Files (x86)\\Git\\bin\\bash.exe',
+]
+
+/** macOS / Linux stock shells (always present on a normal desktop install). */
+const UNIX_SHELL_PATHS: Record<'zsh' | 'bash', string> = {
+  zsh: '/bin/zsh',
+  bash: '/bin/bash',
+}
+
+/** All shell kinds in display order. */
+const ALL_SHELLS: readonly ShellType[] = ['zsh', 'bash', 'gitbash', 'powershell', 'cmd']
+
+/** True if `name` resolves on PATH. Uses `where` on Windows, `command -v` on Unix. */
+function commandExistsAsync(name: string): Promise<boolean> {
+  const probe = IS_WIN ? `where ${name}` : `command -v ${name}`
+  return new Promise((r) => {
+    exec(probe, { windowsHide: true, timeout: 5000 }, (err) => { r(!err) })
+  })
+}
+
+/** Git Bash is only relevant on Windows (probed via launcher / bash / git). */
+async function hasGitBash(): Promise<boolean> {
+  if (!IS_WIN) return false
+  if (await commandExistsAsync('git-bash.exe')) return true
+  if (
+    (await commandExistsAsync('bash.exe')) &&
+    ((await commandExistsAsync('git.exe')) ||
+      GIT_BASH_CANDIDATES_WIN.some((p) => existsSync(p)))
+  ) {
+    return true
+  }
+  return GIT_BASH_CANDIDATES_WIN.some((p) => existsSync(p))
+}
+
+/** Map a ShellType to { command, args } for node-pty.spawn. */
+function resolveShell(shell: ShellType): { command: string; args: string[] } {
+  switch (shell) {
+    case 'powershell':
+      return { command: 'powershell.exe', args: ['-NoLogo'] }
+    case 'cmd':
+      return { command: 'cmd.exe', args: [] }
+    case 'bash':
+      return { command: IS_WIN ? 'bash.exe' : UNIX_SHELL_PATHS.bash, args: ['--login', '-i'] }
+    case 'zsh':
+      return { command: UNIX_SHELL_PATHS.zsh, args: ['-l', '-i'] }
+    case 'gitbash':
+    default: {
+      if (IS_WIN) {
+        for (const c of GIT_BASH_CANDIDATES_WIN) {
+          if (existsSync(c)) return { command: c, args: ['--login', '-i'] }
+        }
+        return { command: 'bash', args: ['--login', '-i'] }
+      }
+      return { command: UNIX_SHELL_PATHS.bash, args: ['--login', '-i'] }
+    }
+  }
+}
+
+/** Default shell kind for the platform. */
+export function defaultShellType(): ShellType {
+  if (IS_WIN) return 'powershell'
+  return existsSync(UNIX_SHELL_PATHS.zsh) ? 'zsh' : 'bash'
 }
 
-/** Default args for an interactive login-less shell. */
-export function defaultArgs(shell: string): string[] {
-  if (process.platform === 'win32') return []
-  const base = shell.endsWith('bash') ? ['--noprofile', '--norc', '-i'] : ['-i']
-  return base
+/**
+ * Resolve a spawn cwd that is guaranteed to be an existing directory.
+ * node-pty fails at spawn time (macOS: "posix_spawnp failed") if the cwd
+ * does not exist — which happens on a cross-platform machine when a stale
+ * Windows-style workspace path is still in the store, or when the renderer
+ * sends an empty/null cwd. Fall back to $HOME so the PTY always spawns.
+ */
+function resolveCwd(cwd?: string): string {
+  const candidate = cwd && cwd.trim().length > 0 ? cwd.trim() : process.cwd()
+  try {
+    const abs = resolve(candidate)
+    if (existsSync(abs) && statSync(abs).isDirectory()) return abs
+  } catch { /* fall through to home */ }
+  return homedir()
 }
 
 /**
@@ -42,34 +118,66 @@ export function defaultArgs(shell: string): string[] {
  */
 export class PtyService {
   private readonly sessions = new Map<string, LiveSession>()
+  /** Cached available shells (computed once on first query). */
+  private availableShellsCache: readonly ShellInfo[] | null = null
 
   /** Fired with raw PTY output chunks (UTF-8). Bound by the route layer. */
   onOutput: (sessionId: string, data: string) => void = () => {}
   /** Fired once when a session exits. Bound by the route layer. */
   onExit: (sessionId: string, exitCode: number) => void = () => {}
+  /** Fired when a session is detached (tab closed, PTY kept alive). */
+  onDetach: (sessionId: string) => void = () => {}
+  /** Fired when a session is reattached. */
+  onReattach: (session: TermSessionInfo) => void = () => {}
+
+  /**
+   * Returns the shells actually available on this machine, so the browser
+   * can hide options the user never installed (Git Bash) instead of letting
+   * node-pty fail at spawn time. Results are cached after the first async
+   * detection to avoid repeated `where` calls.
+   */
+  async detectShells(): Promise<readonly ShellInfo[]> {
+    if (this.availableShellsCache !== null) return this.availableShellsCache
+    const available: ShellType[] = []
+    if (await hasGitBash()) available.push('gitbash')
+    if (IS_WIN) {
+      if (await commandExistsAsync('powershell.exe') || await commandExistsAsync('pwsh.exe')) available.push('powershell')
+      if (await commandExistsAsync('cmd.exe')) available.push('cmd')
+    } else {
+      if (existsSync(UNIX_SHELL_PATHS.zsh)) available.push('zsh')
+      if (existsSync(UNIX_SHELL_PATHS.bash)) available.push('bash')
+    }
+    this.availableShellsCache = available.map((id) => ({ id, labelKey: `ui.shell.${id}` }))
+    return this.availableShellsCache
+  }
 
   /** Open one session; returns the wire info immediately (output streams async). */
   spawn(req: TermSpawnRequest): TermSessionInfo {
     const id = randomUUID()
-    const shell = req.shell ?? defaultShell()
-    const args = req.args ?? defaultArgs(shell)
+    const shellType: ShellType = req.shell ?? defaultShellType()
+    const { command, args } = resolveShell(shellType)
+    const finalArgs = req.args ?? args
     const cols = req.cols ?? 80
     const rows = req.rows ?? 24
-    const cwd = req.cwd ?? process.cwd()
-    const pty = nodePty.spawn(shell, args, {
+    const cwd = resolveCwd(req.cwd)
+    const env = { ...process.env, TERM: 'xterm-256color', FORCE_COLOR: '1', ...(req.env ?? {}) }
+    const pty = nodePty.spawn(command, finalArgs, {
       name: 'xterm-256color',
       cols,
       rows,
       cwd,
+      env,
     })
     const info: TermSessionInfo = {
       id,
-      title: req.name ?? shell,
+      title: req.name ?? shellType,
       cwd,
       cols,
       rows,
       alive: true,
       exitCode: null,
+      shell: shellType,
+      detached: false,
     }
     this.sessions.set(id, { info, pty })
     pty.onData((data) => { this.onOutput(id, data) })
@@ -108,19 +216,54 @@ export class PtyService {
     return true
   }
 
-  /** Close a session forcefully (SIGHUP semantics via kill). Returns false when unknown. */
+  /**
+   * Detach a session: mark it as detached but keep the PTY process alive.
+   * This lets the user close a tab without losing a running command (e.g.
+   * `npm install`); reopening re-attaches to the same session.
+   */
+  detach(id: string): boolean {
+    const live = this.sessions.get(id)
+    if (live === undefined) return false
+    const newInfo: TermSessionInfo = { ...live.info, detached: true }
+    this.sessions.set(id, { info: newInfo, pty: live.pty })
+    this.onDetach(id)
+    return true
+  }
+
+  /**
+   * Reattach to a detached session: mark it as attached and return the info.
+   * The caller creates a fresh xterm and starts routing SSE output to it.
+   */
+  reattach(id: string): TermSessionInfo | null {
+    const live = this.sessions.get(id)
+    if (live === undefined) return null
+    const newInfo: TermSessionInfo = { ...live.info, detached: false }
+    this.sessions.set(id, { info: newInfo, pty: live.pty })
+    this.onReattach(newInfo)
+    return newInfo
+  }
+
+  /** Close a session forcefully (kill the PTY). Returns false when unknown. */
   close(id: string): boolean {
     const live = this.sessions.get(id)
     if (live === undefined) return false
     try { live.pty.kill() } catch { /* already dead */ }
+    this.sessions.delete(id)
     return true
   }
 
-  /** The full session listing snapshot. */
+  /** The full session listing snapshot (including detached sessions). */
   list(): readonly TermSessionInfo[] {
     return [...this.sessions.values()].map(({ info }) => ({ ...info }))
   }
 
+  /** Only the detached sessions (for the "reopen" dropdown). */
+  detachedList(): readonly TermSessionInfo[] {
+    return [...this.sessions.values()]
+      .filter(({ info }) => info.detached)
+      .map(({ info }) => ({ ...info }))
+  }
+
   /** Close every session (route teardown). */
   dispose(): void {
     for (const live of this.sessions.values()) {

package/src/host/routes.ts

@@ -9,9 +9,10 @@
 import type { IncomingMessage, ServerResponse } from 'node:http'
 import type { Context } from '@deepseek-ai/cordis'
 import type {} from '@deepseek-ai/dsh-host-webserver'
-import type { TermEvent, TermSpawnRequest } from '../core/types.ts'
+import type { ShellType, TermEvent, TermSpawnRequest } from '../core/types.ts'
 import type { PtyService } from './pty-service.ts'
 import { isLoopbackRequest } from './loopback.ts'
+import type { Translator } from '../gateway/i18n.ts'
 
 /** JSON envelope mirrors the file-manager panel shape. */
 type Envelope<T> = { ok: true; value: T } | { ok: false; error: { code: string; message: string } }
@@ -63,9 +64,10 @@ function json(res: ServerResponse, envelope: Envelope<unknown>, status = 200): v
  * Register the /dsh-term routes.
  * @param ctx - context carrying the webServer service.
  * @param pty - the session registry.
+ * @param getT - lazy translator getter (reflects current language).
  * @returns route disposers.
  */
-export function registerTermRoutes(ctx: Context, pty: PtyService): () => void {
+export function registerTermRoutes(ctx: Context, pty: PtyService, getT: () => Translator): () => void {
   const subscribers = new Set<Subscriber>()
   const push = (event: TermEvent): void => {
     for (const subscriber of subscribers) {
@@ -74,7 +76,12 @@ export function registerTermRoutes(ctx: Context, pty: PtyService): () => void {
   }
 
   pty.onOutput = (id, data) => push({ kind: 'output', id, data })
-  pty.onExit = (id, exitCode) => push({ kind: 'exit', id, exitCode })
+  pty.onExit = (id, exitCode) => {
+    const msg = getT().t('msg.sessionExited', exitCode)
+    push({ kind: 'exit', id, exitCode, message: msg })
+  }
+  pty.onDetach = (id) => push({ kind: 'detached', id })
+  pty.onReattach = (session) => push({ kind: 'reattached', session })
 
   const handler = async (req: IncomingMessage, res: ServerResponse): Promise<void> => {
     if (!isLoopbackRequest(req)) {
@@ -87,6 +94,11 @@ export function registerTermRoutes(ctx: Context, pty: PtyService): () => void {
         json(res, OK({ sessions: pty.list() }))
         return
       }
+      if (req.method === 'GET' && url.pathname === '/dsh-term/shells') {
+        const shells = await pty.detectShells()
+        json(res, OK({ shells }))
+        return
+      }
       if (req.method !== 'POST') {
         json(res, MALFORMED, 405)
         return
@@ -105,13 +117,18 @@ export function registerTermRoutes(ctx: Context, pty: PtyService): () => void {
             json(res, MALFORMED, 400)
             return
           }
+          const validShells: readonly ShellType[] = ['bash', 'zsh', 'powershell', 'cmd', 'gitbash']
           const session = pty.spawn({
             name: typeof request.name === 'string' ? request.name : undefined,
             cwd: typeof request.cwd === 'string' ? request.cwd : undefined,
-            shell: typeof request.shell === 'string' ? request.shell : undefined,
+            shell: typeof request.shell === 'string' && validShells.includes(request.shell as ShellType)
+              ? request.shell as ShellType : undefined,
             args: Array.isArray(request.args) ? request.args.filter((a): a is string => typeof a === 'string') : undefined,
             cols: typeof request.cols === 'number' ? request.cols : undefined,
             rows: typeof request.rows === 'number' ? request.rows : undefined,
+            env: typeof request.env === 'object' && request.env !== null
+              ? Object.fromEntries(Object.entries(request.env).filter(([, v]) => typeof v === 'string')) as Record<string, string>
+              : undefined,
           })
           push({ kind: 'start', session })
           json(res, OK(session))
@@ -153,6 +170,29 @@ export function registerTermRoutes(ctx: Context, pty: PtyService): () => void {
           json(res, OK({ ok: pty.close(body.id) }))
           return
         }
+        case '/dsh-term/detach': {
+          const body = payload as { id?: unknown }
+          if (typeof body?.id !== 'string') {
+            json(res, MALFORMED, 400)
+            return
+          }
+          json(res, OK({ ok: pty.detach(body.id) }))
+          return
+        }
+        case '/dsh-term/reattach': {
+          const body = payload as { id?: unknown }
+          if (typeof body?.id !== 'string') {
+            json(res, MALFORMED, 400)
+            return
+          }
+          const session = pty.reattach(body.id)
+          if (session === null) {
+            json(res, FAIL('session not found', 'not_found'), 404)
+            return
+          }
+          json(res, OK(session))
+          return
+        }
         default:
           json(res, MALFORMED, 404)
       }

package/src/index.ts

@@ -7,9 +7,11 @@
 
 import type { Context } from '@deepseek-ai/cordis'
 import type {} from '@deepseek-ai/dsh-host-webserver'
+import { settingsNamespace } from '@deepseek-ai/dsh-settings'
 import { mountOnce } from './mount-once.ts'
 import { PtyService } from './host/pty-service.ts'
 import { registerTermRoutes } from './host/routes.ts'
+import { createTranslator, type Lang } from './gateway/i18n.ts'
 
 /** Required services: the route registry. */
 export const inject = ['webServer']
@@ -25,13 +27,41 @@ export const apply = mountOnce('@lijian-ui/dsh-term', applyImpl)
 
 function applyImpl(ctx: Context): void {
   const pty = new PtyService()
+
+  /** Current language; resolved from dsh global settings. */
+  let lang: Lang = 'zh'
+  const t = createTranslator(lang)
+
+  /** Resolve the user's language preference from dsh settings. */
+  function resolveLang(): Lang {
+    try {
+      const settings = ctx.get('settings') as
+        | { get(ns: unknown): { preference?: string } | undefined }
+        | undefined
+      if (!settings) return 'zh'
+      const section = settings.get(settingsNamespace('locale'))
+      return section?.preference === 'en' ? 'en' : 'zh'
+    } catch {
+      return 'zh'
+    }
+  }
+
   // Route registration + pty teardown both ride the effect fiber: the effect
   // callback runs immediately and its return value is the fiber disposer.
   ctx.effect(() => {
-    const disposeRoutes = registerTermRoutes(ctx, pty)
+    lang = resolveLang()
+    // t is a closure over lang; no separate sync needed.
+    const disposeRoutes = registerTermRoutes(ctx, pty, () => createTranslator(lang))
     return () => {
       disposeRoutes()
       pty.dispose()
     }
   }, 'dsh-term: routes + pty lifecycle')
+
+  // Listen for global language changes (dsh settings → General → Language).
+  ctx.root.on('settings/updated', (ns, next) => {
+    if (ns !== settingsNamespace('locale')) return
+    const pref = (next as { preference?: string })?.preference
+    lang = pref === 'en' ? 'en' : 'zh'
+  })
 }