dsh-code 1.0.7 → 1.3.0

package/src/update-panel.ts

@@ -11,10 +11,12 @@
 
 import { createElement, useEffect, useState, type ReactElement } from 'react'
 import { Box, Text, useInput, useStdout } from 'ink'
-import type { LauncherUpdateStatus } from './update.ts'
+import type { LauncherUpdatePlan, LauncherUpdateStatus } from './update.ts'
 import { clampScroll, panelViewport } from './render/inspector.ts'
 import { singleLineText, truncateColumns } from './render/text.ts'
+import { panelAccent } from './panel-accent.ts'
 import { getPalette, inkColor } from './theme.ts'
+import { t } from './i18n.ts'
 
 /** Retained apply-progress lines (ring tail; npm output is ephemeral). */
 export const UPDATE_OUTPUT_CAP = 800
@@ -24,6 +26,84 @@ export function clipUpdateLines(lines: readonly string[]): readonly string[] {
   return lines.length <= UPDATE_OUTPUT_CAP ? lines : lines.slice(lines.length - UPDATE_OUTPUT_CAP)
 }
 
+/** One in-flight `update --apply`. Closing the panel must not start a second. */
+interface UpdateApplyJob {
+  readonly promise: Promise<number>
+  readonly lines: string[]
+  readonly lineListeners: Set<(line: string) => void>
+}
+
+let updateApplyJob: UpdateApplyJob | undefined
+const updateApplyRunningListeners = new Set<(running: boolean) => void>()
+
+function emitUpdateApplyRunning(running: boolean): void {
+  for (const listener of updateApplyRunningListeners) listener(running)
+}
+
+/** True while an apply child is alive, even if the /update panel is closed. */
+export function isUpdateApplyRunning(): boolean {
+  return updateApplyJob !== undefined
+}
+
+/** Subscribe to apply-running changes (frozen-hint "esc waits"). */
+export function subscribeUpdateApplyRunning(listener: (running: boolean) => void): () => void {
+  updateApplyRunningListeners.add(listener)
+  listener(updateApplyJob !== undefined)
+  return () => { updateApplyRunningListeners.delete(listener) }
+}
+
+/** The live apply job, if any: lines already streamed plus the shared promise. */
+export function currentUpdateApply(): UpdateApplyJob | undefined {
+  return updateApplyJob
+}
+
+/**
+ * Run `apply` once. A second call while the child is alive reuses the same
+ * promise and replays buffered lines — closing /update and opening it again
+ * must not spawn a second `npm install`.
+ */
+export function runUpdateApply(
+  apply: (onLine: (line: string) => void, plan: LauncherUpdatePlan) => Promise<number>,
+  plan: LauncherUpdatePlan,
+  onLine?: (line: string) => void,
+): Promise<number> {
+  if (updateApplyJob !== undefined) {
+    if (onLine !== undefined) {
+      for (const line of updateApplyJob.lines) onLine(line)
+      updateApplyJob.lineListeners.add(onLine)
+    }
+    return updateApplyJob.promise
+  }
+  const lines: string[] = []
+  const lineListeners = new Set<(line: string) => void>()
+  if (onLine !== undefined) lineListeners.add(onLine)
+  const promise = apply(line => {
+    const text = singleLineText(line)
+    lines.push(text)
+    if (lines.length > UPDATE_OUTPUT_CAP) lines.splice(0, lines.length - UPDATE_OUTPUT_CAP)
+    for (const listener of lineListeners) listener(text)
+  }, plan)
+  updateApplyJob = { promise, lines, lineListeners }
+  emitUpdateApplyRunning(true)
+  const settle = (): void => {
+    if (updateApplyJob?.promise === promise) {
+      updateApplyJob = undefined
+      emitUpdateApplyRunning(false)
+    }
+  }
+  // Handle both outcomes directly. `finally()` mirrors a rejected source
+  // promise onto its returned promise; discarding that returned promise would
+  // create an unhandled rejection when the update child cannot start.
+  void promise.then(settle, settle)
+  return promise
+}
+
+/** Drop a leftover job between tests. */
+export function resetUpdateApply(): void {
+  updateApplyJob = undefined
+  emitUpdateApplyRunning(false)
+}
+
 /** One display row of the update surface. */
 export interface UpdateRow {
   readonly key: string
@@ -41,9 +121,11 @@ export interface UpdatePlanView {
 export function updatePlanView(status: LauncherUpdateStatus): UpdatePlanView {
   const rows: UpdateRow[] = []
   const latest = status.code.latest ?? 'unknown'
-  rows.push(status.code.latest !== null && status.code.latest === status.code.running
-    ? { key: 'code', text: `dsh-code    ${status.code.running} (latest)` }
-    : { key: 'code', text: `dsh-code    ${status.code.running} → ${latest}` })
+  rows.push(status.aheadOfRegistry === true
+    ? { key: 'code', text: `dsh-code    ${status.code.running} (newer than npm ${latest})` }
+    : status.code.latest !== null && status.code.latest === status.code.running
+      ? { key: 'code', text: `dsh-code    ${status.code.running} (latest)` }
+      : { key: 'code', text: `dsh-code    ${status.code.running} → ${latest}` })
   if (status.host.targetLine === null) {
     rows.push({ key: 'host', text: 'harness     pinned line unreadable — update would install @deepseek-ai/dsh@latest', tone: 'warn' })
   } else if (status.host.installed === null) {
@@ -83,7 +165,9 @@ export function updatePlanView(status: LauncherUpdateStatus): UpdatePlanView {
       rows.push({ key: `blocker:checkout:${index}`, text: line, tone: 'error' })
     }
   }
-  if (status.upToDate) {
+  if (status.aheadOfRegistry === true) {
+    rows.push({ key: 'ahead', text: 'this install is newer than npm latest — refusing to downgrade', tone: 'warn' })
+  } else if (status.upToDate) {
     rows.push({ key: 'uptodate', text: 'everything is already on the pinned line — nothing to update', tone: 'ok' })
   }
   const runnable = status.upToDate !== true
@@ -97,13 +181,14 @@ export function updatePlanView(status: LauncherUpdateStatus): UpdatePlanView {
 export type UpdatePhase = 'probe' | 'error' | 'plan' | 'apply' | 'done'
 
 /** Footer hint line per phase; the plan phase names the confirm key only when runnable. */
-export function updateFooter(phase: UpdatePhase, runnable: boolean, upToDate: boolean): string {
-  if (phase === 'probe') return 'checking… · esc close'
-  if (phase === 'error') return 'r recheck · esc close'
-  if (phase === 'apply') return 'updating… · ↑↓ scroll · esc waits'
-  if (phase === 'done') return 'r recheck · esc close'
-  if (upToDate) return 'up to date · r recheck · esc close'
-  return runnable ? 'enter update · r recheck · esc close' : 'blocked · r recheck · esc close'
+export function updateFooter(phase: UpdatePhase, runnable: boolean, upToDate: boolean, aheadOfRegistry = false): string {
+  if (phase === 'probe') return t('panel.update.footer.probe')
+  if (phase === 'error') return t('panel.update.footer.error')
+  if (phase === 'apply') return t('panel.update.footer.apply')
+  if (phase === 'done') return t('panel.update.footer.error')
+  if (aheadOfRegistry) return t('panel.update.footer.ahead')
+  if (upToDate) return t('panel.update.footer.current')
+  return runnable ? t('panel.update.footer.update') : t('panel.update.footer.blocked')
 }
 
 /**
@@ -114,13 +199,13 @@ export function updateFooter(phase: UpdatePhase, runnable: boolean, upToDate: bo
  */
 export function UpdatePanel({ probe, apply, close, notify }: {
   /** Read-only probe of the launcher update status (never installs). */
-  probe(): Promise<LauncherUpdateStatus>
+  probe: () => Promise<LauncherUpdateStatus>
   /** Run the aligned update; streams sanitized progress lines. */
-  apply(onLine: (line: string) => void): Promise<number>
+  apply: (onLine: (line: string) => void, plan: LauncherUpdateStatus['plan']) => Promise<number>
   /** Close the panel (App keeps ownership of the flag). */
-  close(): void
+  close: () => void
   /** One bounded cross-surface notice (phase completions). */
-  notify(text: string, tone?: 'info' | 'warning' | 'error'): void
+  notify: (text: string, tone?: 'info' | 'warning' | 'error') => void
 }): ReactElement {
   const [phase, setPhase] = useState<UpdatePhase>('probe')
   const [status, setStatus] = useState<LauncherUpdateStatus>()
@@ -132,8 +217,35 @@ export function UpdatePanel({ probe, apply, close, notify }: {
   // visible row (up moves away from the tail, down onto it re-follows).
   const [anchor, setAnchor] = useState<'tail' | number>('tail')
   const [epoch, setEpoch] = useState(0)
+  const appendLine = (line: string): void => {
+    setLines(previous => clipUpdateLines([...previous, line]))
+  }
   useEffect(() => {
     let disposed = false
+    const existing = currentUpdateApply()
+    if (existing !== undefined) {
+      // The apply child outlives the panel: closing for an approval or
+      // Ctrl+C must reconnect to the same job, not probe-and-confirm again.
+      setPhase('apply')
+      setLines(existing.lines)
+      setExit(undefined)
+      setApplyError(undefined)
+      setAnchor('tail')
+      existing.lineListeners.add(appendLine)
+      void existing.promise.then(code => {
+        if (disposed) return
+        setExit(code)
+        setPhase('done')
+      }, reason => {
+        if (disposed) return
+        setApplyError(reason instanceof Error ? reason.message : String(reason))
+        setPhase('done')
+      })
+      return () => {
+        disposed = true
+        existing.lineListeners.delete(appendLine)
+      }
+    }
     setPhase('probe')
     setStatus(undefined)
     setProbeError(undefined)
@@ -147,21 +259,23 @@ export function UpdatePanel({ probe, apply, close, notify }: {
       setProbeError(reason instanceof Error ? reason.message : String(reason))
       setPhase('error')
     })
-    return () => { disposed = true }
+    return () => {
+      disposed = true
+      currentUpdateApply()?.lineListeners.delete(appendLine)
+    }
   }, [epoch, probe])
   const stdout = useStdout().stdout
   const viewport = panelViewport(stdout?.columns ?? 80, stdout?.rows ?? 30)
   const start = (): void => {
     if (phase !== 'plan' || status === undefined) return
     if (!updatePlanView(status).runnable) return
+    if (isUpdateApplyRunning()) return
     setPhase('apply')
     setLines([])
     setExit(undefined)
     setApplyError(undefined)
     setAnchor('tail')
-    apply(line => {
-      setLines(previous => clipUpdateLines([...previous, singleLineText(line)]))
-    }).then(code => {
+    runUpdateApply(apply, status.plan, appendLine).then(code => {
       setExit(code)
       setPhase('done')
       notify(code === 0 ? 'update installed — restart dsh to activate' : `update failed (exit ${code})`, code === 0 ? 'info' : 'error')
@@ -212,12 +326,12 @@ export function UpdatePanel({ probe, apply, close, notify }: {
     else if (key.downArrow) setAnchor(offset + 1)
   })
   if (viewport.maxHeight === 0 || viewport.compact) {
-    const summary = phase === 'probe' ? 'checking…'
-      : phase === 'error' ? 'probe failed'
-      : phase === 'apply' ? singleLineText(lines[lines.length - 1] ?? 'updating…')
-      : phase === 'done' ? (exit === 0 ? 'installed — restart to activate' : 'failed')
-      : status?.upToDate === true ? 'up to date' : planView?.runnable === true ? 'enter updates' : 'blocked'
-    return createElement(Text, { wrap: 'truncate-end' }, truncateColumns(singleLineText(`/update · ${summary}`), viewport.contentColumns))
+    const summary = phase === 'probe' ? t('panel.update.checking')
+      : phase === 'error' ? t('panel.update.probeFailed')
+      : phase === 'apply' ? singleLineText(lines[lines.length - 1] ?? t('panel.update.updating'))
+      : phase === 'done' ? (exit === 0 ? t('panel.update.installed') : t('panel.update.failed'))
+      : status?.aheadOfRegistry === true ? t('panel.update.aheadOfNpm') : status?.upToDate === true ? t('panel.update.upToDate') : planView?.runnable === true ? t('panel.update.enter') : t('panel.update.blocked')
+    return createElement(Text, { wrap: 'truncate-end' }, truncateColumns(singleLineText(t('panel.update.compact', { summary })), viewport.contentColumns))
   }
   const visible = rows.slice(offset, offset + budget)
   const toneColor = (tone: UpdateRow['tone']): ReturnType<typeof inkColor> | undefined => tone === 'ok'
@@ -230,17 +344,20 @@ export function UpdatePanel({ probe, apply, close, notify }: {
     ? inkColor(getPalette().dim)
     : undefined
   const title = status === undefined
-    ? '/update · aligned upgrade'
-    : `/update · dsh-code ${status.code.running}${status.code.latest !== null && status.code.latest !== status.code.running ? ` → ${status.code.latest}` : ''}`
+    ? t('panel.update.title')
+    : status.aheadOfRegistry === true
+      ? `/update · dsh-code ${status.code.running}`
+      : `/update · dsh-code ${status.code.running}${status.code.latest !== null && status.code.latest !== status.code.running ? ` → ${status.code.latest}` : ''}`
+  const accent = panelAccent('update', getPalette().dim, getPalette().brandBright)
   return createElement(
     Box,
-    { width: viewport.outerColumns, borderStyle: 'round', borderColor: inkColor(getPalette().dim), flexDirection: 'column', paddingX: 1 },
-    createElement(Text, { color: inkColor(getPalette().brandBright), wrap: 'truncate-end' }, truncateColumns(singleLineText(title), viewport.contentColumns)),
+    { width: viewport.outerColumns, borderStyle: 'round', borderColor: inkColor(accent.border), flexDirection: 'column', paddingX: 1 },
+    createElement(Text, { color: inkColor(accent.title), wrap: 'truncate-end' }, truncateColumns(singleLineText(title), viewport.contentColumns)),
     ...visible.map(row => createElement(Text, {
       key: row.key,
       color: toneColor(row.tone),
       wrap: 'truncate-end',
     }, truncateColumns(`  ${singleLineText(row.text)}`, viewport.contentColumns))),
-    createElement(Text, { dimColor: true, wrap: 'truncate-end' }, truncateColumns(singleLineText(updateFooter(phase, planView?.runnable ?? false, status?.upToDate === true)), viewport.contentColumns)),
+    createElement(Text, { dimColor: true, wrap: 'truncate-end' }, truncateColumns(singleLineText(updateFooter(phase, planView?.runnable ?? false, status?.upToDate === true, status?.aheadOfRegistry === true)), viewport.contentColumns)),
   )
 }

package/src/update.ts

@@ -20,6 +20,15 @@ export interface LauncherUpdateStatus {
   readonly plan: { readonly dshSpec: string; readonly codeSpec: string; readonly pluginSpecs: readonly string[] }
   readonly blockers: { readonly registry: string | null; readonly downgrade: boolean; readonly localCheckout: readonly string[] | null }
   readonly upToDate: boolean
+  /** True when this install is newer than npm latest (apply would downgrade). */
+  readonly aheadOfRegistry?: boolean
+}
+
+/** Exact specs the TUI confirmed; apply must install these, not re-query latest. */
+export interface LauncherUpdatePlan {
+  readonly dshSpec: string
+  readonly codeSpec: string
+  readonly pluginSpecs: readonly string[]
 }
 
 /** The launcher entrypoint that ships beside this bundle (lib/../bin). */
@@ -89,10 +98,17 @@ export async function probeLauncherUpdate(spawnProcess: SpawnLike = spawn as Spa
  * exit code (0 success); rejects only when the process could not start.
  * No timeout: an npm install may legitimately take minutes.
  */
-export function applyLauncherUpdate(onLine: (line: string) => void, spawnProcess: SpawnLike = spawn as SpawnLike): Promise<number> {
-  const command = launcherUpdateCommand(['update', '--apply'])
+export function applyPlanArgs(plan: LauncherUpdatePlan): string[] {
+  const args = ['update', '--apply', '--dsh', plan.dshSpec, '--code', plan.codeSpec]
+  for (const plugin of plan.pluginSpecs) args.push('--plugin', plugin)
+  return args
+}
+
+export function applyLauncherUpdate(onLine: (line: string) => void, spawnProcess?: SpawnLike, plan?: LauncherUpdatePlan): Promise<number> {
+  const spawnFn = spawnProcess ?? (spawn as SpawnLike)
+  const command = launcherUpdateCommand(plan === undefined ? ['update', '--apply'] : applyPlanArgs(plan))
   return new Promise((resolve, reject) => {
-    const child = spawnProcess(command.command, command.args, { stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true })
+    const child = spawnFn(command.command, command.args, { stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true })
     const split = createLineSplitter(onLine)
     child.stdout?.on('data', (chunk: Buffer) => { split(chunk.toString()) })
     child.stderr?.on('data', (chunk: Buffer) => { split(chunk.toString()) })

package/src/version.ts

@@ -1,6 +1,7 @@
 /** Installed dsh-code version exposed by the terminal header. */
 
-import { readFileSync } from 'node:fs'
+import { readFileSync, realpathSync } from 'node:fs'
+import { createRequire } from 'node:module'
 import { dirname, join, resolve } from 'node:path'
 
 /** Read one package manifest version without making terminal startup depend on it. */
@@ -16,33 +17,39 @@ function readPackageVersion(manifest = new URL('../package.json', import.meta.ur
 /** Version of the installed dsh-code package. */
 export const DSH_CODE_VERSION = readPackageVersion()
 
+/** Header brand line: hide a missing-manifest fallback so we never paint v0.0.0. */
+export function headerBrandTitle(version: string = DSH_CODE_VERSION): string {
+  return version === '0.0.0' ? 'DeepSeek Harness' : `DeepSeek Harness · v${version}`
+}
+
 /** The harness host package: the dsh CLI whose process runs the TUI plugin. */
 const DSH_HOST_PACKAGE_NAME = '@deepseek-ai/dsh'
 
 /** Parent levels above the host entry allowed to hold its package manifest. */
 const DSH_HOST_WALK_LIMIT = 4
 
-/**
- * Resolve the running dsh CLI host's version from its entry file
- * (`process.argv[1]`, e.g. `.../@deepseek-ai/dsh/lib/bin.js`). Only a manifest
- * literally named `@deepseek-ai/dsh` counts, so an unrelated entry (vitest, a
- * plain node script) resolves to undefined instead of faking a kernel version.
- */
-export function resolveDshHostVersion(entry: string | undefined = process.argv[1]): string | undefined {
-  if (entry === undefined || entry === '') return undefined
+/** Read `@deepseek-ai/dsh`'s version from a directory's package.json, or undefined. */
+function readHostVersion(directory: string): string | undefined {
+  try {
+    const parsed = JSON.parse(readFileSync(join(directory, 'package.json'), 'utf8')) as {
+      name?: unknown
+      version?: unknown
+    }
+    if (parsed.name === DSH_HOST_PACKAGE_NAME && typeof parsed.version === 'string' && parsed.version.length > 0) {
+      return parsed.version
+    }
+  } catch {
+    // No readable host manifest at this level.
+  }
+  return undefined
+}
+
+/** Climb from an entry file toward a host package.json. */
+function walkFrom(entry: string): string | undefined {
   let directory = dirname(resolve(entry))
   for (let depth = 0; depth < DSH_HOST_WALK_LIMIT; depth += 1) {
-    try {
-      const parsed = JSON.parse(readFileSync(join(directory, 'package.json'), 'utf8')) as {
-        name?: unknown
-        version?: unknown
-      }
-      if (parsed.name === DSH_HOST_PACKAGE_NAME && typeof parsed.version === 'string' && parsed.version.length > 0) {
-        return parsed.version
-      }
-    } catch {
-      // No readable manifest at this level: keep climbing.
-    }
+    const version = readHostVersion(directory)
+    if (version !== undefined) return version
     const parent = dirname(directory)
     if (parent === directory) return undefined
     directory = parent
@@ -50,6 +57,42 @@ export function resolveDshHostVersion(entry: string | undefined = process.argv[1
   return undefined
 }
 
+/**
+ * Resolve the host package via Node's module lookup from an entry file.
+ * Covers global `bin/dsh` shims that are not inside the package tree.
+ */
+function resolveFromNode(from: string): string | undefined {
+  try {
+    const manifest = createRequire(from).resolve(`${DSH_HOST_PACKAGE_NAME}/package.json`)
+    return readHostVersion(dirname(manifest))
+  } catch {
+    return undefined
+  }
+}
+
+/**
+ * Resolve the running dsh CLI host's version from its entry file
+ * (`process.argv[1]`, e.g. `.../@deepseek-ai/dsh/lib/bin.js` or a PATH
+ * symlink `.../bin/dsh` → that file). Only a manifest literally named
+ * `@deepseek-ai/dsh` counts, so an unrelated entry (vitest, a plain node
+ * script) resolves to undefined instead of faking a kernel version.
+ */
+export function resolveDshHostVersion(entry: string | undefined = process.argv[1]): string | undefined {
+  if (entry === undefined || entry === '') return undefined
+  const fromWalk = walkFrom(entry)
+  if (fromWalk !== undefined) return fromWalk
+  try {
+    const real = realpathSync(entry)
+    if (real !== resolve(entry)) {
+      const fromReal = walkFrom(real)
+      if (fromReal !== undefined) return fromReal
+    }
+  } catch {
+    // Broken or missing symlink: fall through to Node resolution.
+  }
+  return resolveFromNode(resolve(entry))
+}
+
 let cachedDshKernelVersion: string | undefined
 let dshKernelVersionResolved = false
 

package/src/whale-glyph.ts

@@ -1,23 +1,23 @@
-// GENERATED by scripts/gen-whale-glyph.ts — do not edit by hand. Rerun the
-// generator after changing the FishLogo path. Half-block rendering of the
-// DeepSeek fish logo (figma I39:24057;88:8943 fillGeometry, exact extract;
-// native 23.16x17.04 → 26 columns × 8 half-block rows).
-// Blank cells are part of the glyph's fixed 26-column grid: pad, never trim.
-
-/** Half-block whale glyph rows; render with the brand color. */
-export const WHALE_GLYPH: readonly string[] = [
-  '    ▄▄▄▄▄▄▄▄█    ▄█▄     ▄',
-  ' ▄▄██████████▄▄  ▀███▄████',
-  '▄███████████████▄  ███▀▀▀ ',
-  '██     ▀▀█████▄▀██████    ',
-  '██▄       ▀████▄▄████     ',
-  ' ██▄        ▀██████▀      ',
-  '  ▀██▄▄  ██▄  ▀███▄▄      ',
-  '     ▀▀███████▀▀ ▀▀▀      ',
-]
-
-/** Fixed glyph width in terminal columns. */
-export const WHALE_GLYPH_COLUMNS = 26
-
-/** Fixed glyph height in half-block rows. */
-export const WHALE_GLYPH_ROWS = 8
+// GENERATED by scripts/gen-whale-glyph.ts — do not edit by hand. Rerun the
+// generator after changing the FishLogo path. Half-block rendering of the
+// DeepSeek fish logo (figma I39:24057;88:8943 fillGeometry, exact extract;
+// native 23.16x17.04 → 26 columns × 8 half-block rows).
+// Blank cells are part of the glyph's fixed 26-column grid: pad, never trim.
+
+/** Half-block whale glyph rows; render with the brand color. */
+export const WHALE_GLYPH: readonly string[] = [
+  '    ▄▄▄▄▄▄▄▄█    ▄█▄     ▄',
+  ' ▄▄██████████▄▄  ▀███▄████',
+  '▄███████████████▄  ███▀▀▀ ',
+  '██     ▀▀█████▄▀██████    ',
+  '██▄       ▀████▄▄████     ',
+  ' ██▄        ▀██████▀      ',
+  '  ▀██▄▄  ██▄  ▀███▄▄      ',
+  '     ▀▀███████▀▀ ▀▀▀      ',
+]
+
+/** Fixed glyph width in terminal columns. */
+export const WHALE_GLYPH_COLUMNS = 26
+
+/** Fixed glyph height in half-block rows. */
+export const WHALE_GLYPH_ROWS = 8