dsh-code 1.2.0 → 1.4.0

package/src/{theme-panel.ts → panels/theme-panel.ts}

@@ -9,11 +9,11 @@
 
 import { createElement, useState, type ReactElement } from 'react'
 import { Box, Text, useInput, useStdout } from 'ink'
-import { clampScroll, panelViewport } from './render/inspector.ts'
-import { truncateColumns } from './render/text.ts'
-import { panelAccent } from './panel-accent.ts'
-import { getPalette, inkColor, THEMES, type ThemeName } from './theme.ts'
-import { t } from './i18n.ts'
+import { clampScroll, panelViewport } from '../render/inspector.ts'
+import { truncateColumns } from '../render/text.ts'
+import { panelAccent } from '../ui/panel-accent.ts'
+import { getPalette, inkColor, THEMES, type ThemeName } from '../theme.ts'
+import { t } from '../i18n.ts'
 
 /**
  * The /theme list: one row per theme, the current one marked with ●, the

package/src/{update-panel.ts → panels/update-panel.ts}

@@ -11,12 +11,12 @@
 
 import { createElement, useEffect, useState, type ReactElement } from 'react'
 import { Box, Text, useInput, useStdout } from 'ink'
-import type { 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'
+import type { LauncherUpdatePlan, LauncherUpdateStatus } from '../update.ts'
+import { clampScroll, panelViewport } from '../render/inspector.ts'
+import { singleLineText, truncateColumns } from '../render/text.ts'
+import { panelAccent } from '../ui/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
@@ -26,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
@@ -139,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)
@@ -154,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)]))
-    }, status.plan).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')

package/src/provider-settings.ts

@@ -666,6 +666,44 @@ export async function saveProviderConfiguration(
   }
 }
 
+/**
+ * Switch one provider route to its subscription (plan sign-in) channel: the
+ * profile keeps neither a key reference nor an explicit model list, so the
+ * official catalog endpoint serves requests and the stored OAuth record — not
+ * a settings-named key override — authenticates them. Enabling a route that
+ * has no profile yet creates the empty profile that registers it.
+ * @param ctx - context carrying the `settings` service.
+ * @param target - provider row whose settings namespace owns the profile.
+ * @throws when the route is unmanaged or settings are read-only.
+ */
+export async function enableProviderSubscription(ctx: Context, target: ProviderTargetView): Promise<void> {
+  if (target.settingsNs.length === 0) {
+    throw new ProviderSettingsError(`provider "${target.provider}" has no managed settings namespace; configure it in settings.yaml`)
+  }
+  const settings = ctx.get('settings') as SettingsFace | undefined
+  if (settings === undefined || settings.writable !== true) {
+    throw new ProviderSettingsError('settings are read-only; provider configuration cannot be changed here')
+  }
+  const root = target.settingsPath
+  const ops: SettingsPathOpFace[] = target.configured
+    ? [
+      // The key reference would resolve as a request-level override BEFORE
+      // the stored sign-in record, so the subscription channel must drop it;
+      // the endpoint and the explicit model list belong to the key channel.
+      { op: 'unset', path: [...root, 'apiKeyEnv'] },
+      { op: 'unset', path: [...root, 'baseURL'] },
+      { op: 'unset', path: [...root, 'models'] },
+    ]
+    // A route with no profile stays dormant: an empty profile registers it
+    // with the catalog endpoint and every catalog model.
+    : [{ op: 'set', path: [...root], value: {} }]
+  try {
+    await settings.mutate(target.settingsNs, ops, target.settingsRevision)
+  } catch (error) {
+    throw new ProviderSettingsError(singleLine(messageOf(error)))
+  }
+}
+
 /**
  * Interrogate a provider endpoint for the models it really serves, through
  * the model-discovery capability the provider's settings namespace

package/src/rainbow.ts

@@ -115,6 +115,11 @@ function hueOf([r, g, b]: RgbTriple): number {
   return (60 * (r - g) / span + 240) % 360
 }
 
+/** Strict RGB equality for the wrap-collision repair. */
+function sameRgb(left: RgbTriple, right: RgbTriple): boolean {
+  return left[0] === right[0] && left[1] === right[1] && left[2] === right[2]
+}
+
 /** A dark row tint for diff backgrounds: the hue at 22% strength over black. */
 function darkTint(hue: RgbTriple): RgbTriple {
   return [Math.round(hue[0] * 0.22), Math.round(hue[1] * 0.22), Math.round(hue[2] * 0.22)]
@@ -160,14 +165,19 @@ export function rollRainbow(seed: number): RainbowRoll {
     steered: code,
   }
   const ring = shuffle(RAINBOW_POOL, rng).slice(0, 4)
-  // Adjacency by construction: consecutive tones take consecutive slots of a
-  // 12-distinct shuffle, so neighbors can never match (13 tones wrap the
-  // first color onto 'error', which is never adjacent to 'live' on screen).
+  // Consecutive tones take consecutive slots of a 12-distinct shuffle, so
+  // on-screen neighbors never match. 13 tones wrap: live (index 0) and error
+  // (index 12) would share a color. Reassign error to a pool hue that is
+  // neither live nor its neighbor warn — error must not look like the busy dot.
   const offset = Math.floor(rng() * RAINBOW_POOL.length)
   const toneColors = {} as Record<StatusTone, RgbTriple>
   TONE_ORDER.forEach((tone, index) => {
     toneColors[tone] = pool[(offset + index) % pool.length]!
   })
+  if (sameRgb(toneColors.live, toneColors.error)) {
+    const replacement = pool.find(hue => !sameRgb(hue, toneColors.live) && !sameRgb(hue, toneColors.warn))
+    if (replacement !== undefined) toneColors.error = replacement
+  }
   const flowAnchors = [...RAINBOW_POOL].sort((a, b) => hueOf(a) - hueOf(b))
   const flowPhaseMs = Math.floor(rng() * 2400)
   return { seed, palette, ring, toneColors, flowAnchors, flowPhaseMs }

package/src/render/inspector.ts

@@ -99,6 +99,29 @@ export function panelViewport(columns: number, rows: number): InspectorViewport
   }
 }
 
+/**
+ * Viewport for an expanded (near-fullscreen) document overlay: the document
+ * replaces the transcript area entirely, so the half-screen overlay cap and
+ * the inter-section gaps drop away while the bottom live region (composer,
+ * status) and the Static-rewrite margin stay reserved. The result stays
+ * below terminal height, which is what keeps Ink off its full-rewrite path.
+ */
+export function expandedDocumentViewport(columns: number, rows: number): InspectorViewport {
+  const safeColumns = Math.max(1, Math.floor(columns))
+  const safeRows = Math.max(1, Math.floor(rows))
+  const maxHeight = Math.max(0, safeRows - 2 - INSPECTOR_CHROME_ROWS - layoutGutterRows(safeRows))
+  const compact = maxHeight < 5 || safeColumns < 8
+  const outerColumns = compact ? safeColumns : Math.max(1, safeColumns - 1)
+  return {
+    maxHeight,
+    bodyRows: compact ? 0 : maxHeight - 4,
+    gapRows: 0,
+    contentColumns: compact ? Math.max(1, safeColumns - 1) : Math.max(1, outerColumns - 4),
+    outerColumns,
+    compact,
+  }
+}
+
 /** Backward-compatible name for the Ctrl+O-specific caller and tests. */
 export function inspectorViewport(columns: number, rows: number): InspectorViewport {
   return panelViewport(columns, rows)

package/src/render/status.ts

@@ -17,7 +17,7 @@ import { singleLineText, truncateColumns, formatTokens } from './text.ts'
 
 // Re-exported for the callers that have always read the formatter here.
 export { formatTokens }
-import { t } from '../i18n.ts'
+import { t, type MessageKey } from '../i18n.ts'
 
 
 /**
@@ -29,7 +29,11 @@ export function formatDuration(ms: number): string {
   const s = ms / 1_000
   if (s < 60) return String(Math.round(s * 10) / 10) + 's'
   const whole = Math.round(s)
-  return Math.floor(whole / 60) + 'm' + (whole % 60) + 's'
+  const hours = Math.floor(whole / 3_600)
+  const minutes = Math.floor((whole % 3_600) / 60)
+  const seconds = whole % 60
+  if (hours > 0) return `${hours}h${minutes}m${seconds === 0 ? '' : `${seconds}s`}`
+  return `${minutes}m${seconds}s`
 }
 
 /**
@@ -251,6 +255,31 @@ export const STATUS_ITEMS: readonly StatusItemInfo[] = [
   { id: 'sandbox', label: 'sandbox', description: 'divergent sandbox-mode override', side: 'left' },
 ]
 
+const STATUSLINE_ITEM_KEYS: Record<StatusItemId, { label: MessageKey; description: MessageKey }> = {
+  model: { label: 'statusline.item.model', description: 'statusline.item.model.desc' },
+  cwd: { label: 'statusline.item.cwd', description: 'statusline.item.cwd.desc' },
+  mode: { label: 'statusline.item.mode', description: 'statusline.item.mode.desc' },
+  branch: { label: 'statusline.item.branch', description: 'statusline.item.branch.desc' },
+  context: { label: 'statusline.item.context', description: 'statusline.item.context.desc' },
+  permission: { label: 'statusline.item.permission', description: 'statusline.item.permission.desc' },
+  plan: { label: 'statusline.item.plan', description: 'statusline.item.plan.desc' },
+  turns: { label: 'statusline.item.turns', description: 'statusline.item.turns.desc' },
+  durations: { label: 'statusline.item.durations', description: 'statusline.item.durations.desc' },
+  cache: { label: 'statusline.item.cache', description: 'statusline.item.cache.desc' },
+  tokens: { label: 'statusline.item.tokens', description: 'statusline.item.tokens.desc' },
+  title: { label: 'statusline.item.title', description: 'statusline.item.title.desc' },
+  goal: { label: 'statusline.item.goal', description: 'statusline.item.goal.desc' },
+  sandbox: { label: 'statusline.item.sandbox', description: 'statusline.item.sandbox.desc' },
+}
+
+/** Picker rows with labels/descriptions in the active interface language. */
+export function localizedStatusItems(): readonly StatusItemInfo[] {
+  return STATUS_ITEMS.map(item => {
+    const keys = STATUSLINE_ITEM_KEYS[item.id]
+    return { ...item, label: t(keys.label), description: t(keys.description) }
+  })
+}
+
 /**
  * Default order: the whole catalog (matches the pre-customization bar).
  * The busy dot is not an item — it always leads the identity cluster.
@@ -292,9 +321,10 @@ export const STATUS_ROW2_INDENT = 2
 const TITLE_BUDGET = 48
 
 /**
- * Primary-row drop ranks: context drops before permission; the identity
- * cluster never drops and ellipsizes only after the right badge is gone.
- * Secondary-row groups reuse the remaining ranks independently.
+ * Primary-row drop ranks: identity never drops; permission outranks context.
+ * The drop ladder peels hint and trailing identity facts before removing
+ * the context meter, so occupancy stays visible on a typical 120-column
+ * terminal. Secondary-row groups reuse the remaining ranks independently.
  */
 const RANK_TITLE = 10
 const RANK_TOKENS = 50
@@ -358,6 +388,30 @@ function sep(): StatusSpan {
   return { text: ' · ', tone: 'label' }
 }
 
+/** True for the dim ` · ` that joins identity facts. */
+function isIdentitySep(span: StatusSpan): boolean {
+  return span.text === ' · ' && span.tone === 'label'
+}
+
+/**
+ * Drop the trailing identity fact (branch, then mode, then cwd) so the
+ * context meter can keep a column. Returns undefined once only the busy
+ * dot and model remain.
+ */
+function peelIdentityFact(spans: readonly StatusSpan[]): StatusSpan[] | undefined {
+  if (spans.length < 3) return undefined
+  const last = spans[spans.length - 1]
+  const before = spans[spans.length - 2]
+  const modeSep = spans[spans.length - 3]
+  if (last?.tone === 'accent' && modeSep !== undefined && isIdentitySep(modeSep) && before?.tone === 'label') {
+    return spans.slice(0, -3)
+  }
+  if ((last?.tone === 'branch' || last?.tone === 'path') && before !== undefined && isIdentitySep(before)) {
+    return spans.slice(0, -2)
+  }
+  return undefined
+}
+
 /** Total visible columns of a span list (separators ride inside the spans). */
 function spansWidth(spans: readonly StatusSpan[]): number {
   let width = 0
@@ -511,8 +565,8 @@ function buildCandidates(
       group: {
         spans: [{
           text: facts.goal.phase === 'active'
-            ? '◎ round ' + facts.goal.rounds + '/' + facts.goal.max
-            : '◎ ' + safe(facts.goal.phase),
+            ? t('status.goal.round', { current: facts.goal.rounds, max: facts.goal.max })
+            : t('status.goal.phase', { phase: safe(facts.goal.phase) }),
           tone: 'accent',
         }],
       },
@@ -523,7 +577,7 @@ function buildCandidates(
   // The sandbox override stays implicit when it merely echoes the preset.
   const sandbox = safe(facts.sandbox ?? '')
   if (sandbox !== '' && sandbox.toLowerCase() !== facts.permission.toLowerCase() && enabled.has('sandbox')) {
-    row2.push({ group: { spans: [{ text: 'sandbox ' + sandbox, tone: 'warn' }] }, rank: RANK_SANDBOX, id: 'sandbox' })
+    row2.push({ group: { spans: [{ text: t('status.label.sandbox') + ' ' + sandbox, tone: 'warn' }] }, rank: RANK_SANDBOX, id: 'sandbox' })
   }
   const permission = safe(facts.permission)
   let badge = -1
@@ -536,7 +590,7 @@ function buildCandidates(
   if (permission !== '' && enabled.has('permission')) {
     right.push({
       span: planStation
-        ? { text: 'plan on', tone: 'plan' }
+        ? { text: t('status.plan.on'), tone: 'plan' }
         : { text: permission, tone: permissionTone(permission) },
       rank: RANK_BADGE,
       id: 'permission',
@@ -544,7 +598,7 @@ function buildCandidates(
     badge = right.length - 1
   }
   if (facts.plan && enabled.has('plan')) {
-    row2.push({ group: { spans: [{ text: '⧉ plan', tone: 'accent' }] }, rank: RANK2_PLAN, id: 'plan' })
+    row2.push({ group: { spans: [{ text: t('status.plan.mark'), tone: 'accent' }] }, rank: RANK2_PLAN, id: 'plan' })
   }
   return { left, right, badge, row2 }
 }
@@ -552,7 +606,8 @@ function buildCandidates(
 /**
  * Compose the two-row footer layout under a column budget. Row 1 keeps model,
  * cwd, mode, branch, context, then the right-pinned permission badge and cycle
- * hint. It drops hint, context, and permission before ellipsizing identity.
+ * hint. It shrinks the context bar, drops the hint, and peels trailing
+ * identity facts before removing the context group or the permission badge.
  * Row 2 fits all secondary figures and state within its own budget.
  * @param facts - identity facts resolved by the runner.
  * @param stats - session figures folded from the durable log.
@@ -623,11 +678,10 @@ export function layoutStatusBar(
   }
 
   while (width() > budget) {
-    // Context is the lowest-priority visual group: the bar shrinks inside
-    // its own budget first (the absolute readout survives), then the
-    // readout degrades to the bare percent, and only then does the whole
-    // group go — before the permission badge or its Shift+Tab affordance
-    // is touched.
+    // Occupancy outranks the cycle hint and trailing identity facts
+    // (cwd/mode/branch): shrink the bar, drop the hint, then peel those
+    // facts before removing the context group. Permission stays until
+    // context is already gone.
     if (leftKept.some(entry => entry.id === 'context')) {
       if (contextWidth > CONTEXT_MIN_WIDTH) {
         const overflow = width() - budget
@@ -640,24 +694,21 @@ export function layoutStatusBar(
         rebuildContext()
         continue
       }
-      leftKept.splice(leftKept.findIndex(entry => entry.id === 'context'), 1)
+    }
+    if (hint) {
+      hint = false
       continue
     }
-    if (hint && rightKept.length > 0 && leftKept.length > 0) {
-      const identity = leftKept[0]
-      const identityText = identity.group.spans.map(span => span.text).join('')
-      const rightWidth = joinWidth(rightKept.map(entry => visibleColumns(entry.span.text)), itemSeparator)
-      const identityBudget = budget - rightWidth - LEFT_RIGHT_GAP - visibleColumns(statusCycleHint())
-      if (identityBudget > 0 && visibleColumns(identityText) > identityBudget) {
-        leftKept[0] = {
-          ...identity,
-          group: { spans: [{ text: truncateColumns(identityText, identityBudget), tone: 'model' }] },
-        }
+    const identityEntry = leftKept[0]
+    if (identityEntry?.id === 'identity') {
+      const peeled = peelIdentityFact(identityEntry.group.spans)
+      if (peeled !== undefined) {
+        leftKept[0] = { ...identityEntry, group: { spans: peeled } }
         continue
       }
     }
-    if (hint) {
-      hint = false
+    if (leftKept.some(entry => entry.id === 'context')) {
+      leftKept.splice(leftKept.findIndex(entry => entry.id === 'context'), 1)
       continue
     }
     let dropLeft = -1

package/src/render/text.ts

@@ -14,6 +14,8 @@
 
 import { graphemeWidth, splitGraphemes, stringWidth } from './width.ts'
 
+export { stringWidth }
+
 /**
  * Compact token count: exact below 1K, then one-decimal-ish K/M.
  * @param n - token count.
@@ -23,7 +25,8 @@ export function formatTokens(n: number): string {
   const scaled = (v: number): string =>
     v >= 100 ? String(Math.round(v)) : String(Math.round(v * 10) / 10)
   if (n < 1_000) return String(n)
-  if (n < 1_000_000) return scaled(n / 1_000) + 'K'
+  // 999,500+ rounds to 1000K; step up to M instead of printing four digits.
+  if (n < 999_500) return scaled(n / 1_000) + 'K'
   return scaled(n / 1_000_000) + 'M'
 }
 
@@ -83,6 +86,12 @@ export function truncateColumns(text: string, columns: number): string {
   return `${result}…`
 }
 
+/** Sanitize, clip, and right-pad one cell to an exact terminal-column width. */
+export function padColumns(text: string, columns: number): string {
+  const clipped = truncateColumns(singleLineText(text), columns)
+  return clipped + ' '.repeat(Math.max(0, columns - stringWidth(clipped)))
+}
+
 /** A display-safe suffix bounded by terminal rows and columns. */
 export interface DisplayTail {
   /** Sanitized suffix suitable for direct terminal rendering. */