dsh-code 1.0.5 → 1.0.7

package/src/internals.ts

@@ -19,6 +19,7 @@ import {
   shouldEnableKeyboardEnhancement,
 } from './keyboard.ts'
 import { createSplitStdin } from './input-split.ts'
+import { ensureVsCodeTabTitleSetting } from './terminal-title.ts'
 
 /** A mounted terminal app instance; the runner owns unmount ordering. */
 export interface TuiMount {
@@ -44,46 +45,71 @@ export const internals: {
     // the keyboard protocol on terminals that can safely own those key events.
     const keyboardEnhanced = shouldEnableKeyboardEnhancement()
     const focusReporting = isVsCodeTerminalEnv()
-    process.stdout.write(
-      (keyboardEnhanced ? KEYBOARD_ENHANCE_ENABLE : '')
-      + BRACKETED_PASTE_ENABLE
-      + (focusReporting ? TERMINAL_FOCUS_REPORT_ENABLE : ''),
-    )
-    // App owns Ctrl+C's deliberate three-state contract (interrupt, clear
-    // draft, quit). Ink's default `exitOnCtrlC: true` would intercept the
-    // normalized control byte first, unmount only its renderer, and leave the
-    // Harness runner plus the pushed keyboard protocol alive.
-    // stdin travels through the keypress splitter: Ink parses one chunk as
-    // one keypress, so a coalesced space-then-enter would drop both keys.
-    const tuiStdin = createSplitStdin(process.stdin)
-    // Ink only touches isTTY/setRawMode/ref/read on stdin; the object-mode
-    // proxy satisfies that contract without the full ReadStream surface.
-    const instance = render(element, {
-      exitOnCtrlC: false,
-      stdin: tuiStdin.stdin as unknown as NodeJS.ReadStream,
-      stdout: process.stdout,
-    })
-    return {
-      rerender(element: ReactElement): void {
-        instance.rerender(element)
-      },
-      unmount(): void {
-        // The cleanup below must run even when Ink's unmount throws (a
-        // render-teardown failure): a stdin tap or pushed terminal-protocol
-        // stack outliving the app wedges the terminal for whatever runs
-        // next, and a stray exception here must not skip the exit sequence.
-        try {
-          instance.unmount()
-        } finally {
-          tuiStdin.dispose()
-          // Pop only a stack this mount pushed, then disable bracketed paste.
-          process.stdout.write(
-            (keyboardEnhanced ? KEYBOARD_ENHANCE_DISABLE : '')
-            + BRACKETED_PASTE_DISABLE
-            + (focusReporting ? TERMINAL_FOCUS_REPORT_DISABLE : ''),
-          )
-        }
-      },
+    // Enter raw mode BEFORE pushing any protocol: xterm.js answers `?1004h`
+    // with an immediate focus report (ESC[I), and while the tty still carries
+    // the shell's cooked+ECHO settings that report is echoed to the screen as
+    // a literal `^[[I`. Ink only takes raw mode after its first commit, so
+    // this mount owns the window; the call is idempotent with Ink's later one.
+    if (process.stdin.isTTY === true) process.stdin.setRawMode?.(true)
+    try {
+      process.stdout.write(
+        (keyboardEnhanced ? KEYBOARD_ENHANCE_ENABLE : '')
+        + BRACKETED_PASTE_ENABLE
+        + (focusReporting ? TERMINAL_FOCUS_REPORT_ENABLE : ''),
+      )
+      // Cosmetic best effort: inside a VS Code integrated terminal the tab
+      // shows the process name ("node") unless the user settings map it to
+      // the sequence title; align them once. Total function, never throws.
+      ensureVsCodeTabTitleSetting()
+      // App owns Ctrl+C's deliberate three-state contract (interrupt, clear
+      // draft, quit). Ink's default `exitOnCtrlC: true` would intercept the
+      // normalized control byte first, unmount only its renderer, and leave the
+      // Harness runner plus the pushed keyboard protocol alive.
+      // stdin travels through the keypress splitter: Ink parses one chunk as
+      // one keypress, so a coalesced space-then-enter would drop both keys.
+      const tuiStdin = createSplitStdin(process.stdin)
+      // Ink only touches isTTY/setRawMode/ref/read on stdin; the object-mode
+      // proxy satisfies that contract without the full ReadStream surface.
+      const instance = render(element, {
+        exitOnCtrlC: false,
+        stdin: tuiStdin.stdin as unknown as NodeJS.ReadStream,
+        stdout: process.stdout,
+      })
+      return {
+        rerender(element: ReactElement): void {
+          instance.rerender(element)
+        },
+        unmount(): void {
+          // The cleanup below must run even when Ink's unmount throws (a
+          // render-teardown failure): a stdin tap or pushed terminal-protocol
+          // stack outliving the app wedges the terminal for whatever runs
+          // next, and a stray exception here must not skip the exit sequence.
+          // Pop the stack while raw mode still hides echo — xterm.js keeps
+          // reporting focus changes until `?1004l` lands, and one arriving
+          // after Ink restores the cooked tty would print as `^[[I`.
+          try {
+            process.stdout.write(
+              (keyboardEnhanced ? KEYBOARD_ENHANCE_DISABLE : '')
+              + BRACKETED_PASTE_DISABLE
+              + (focusReporting ? TERMINAL_FOCUS_REPORT_DISABLE : ''),
+            )
+          } finally {
+            try {
+              instance.unmount()
+            } finally {
+              tuiStdin.dispose()
+              // Belt and braces: give the tty back its cooked mode even when
+              // Ink never took raw mode over (idempotent at the termios level).
+              if (process.stdin.isTTY === true) process.stdin.setRawMode?.(false)
+            }
+          }
+        },
+      }
+    } catch (error) {
+      // The synchronous mount path failed before Ink could own the terminal:
+      // undo the raw mode entered above so the shell keeps its echo.
+      if (process.stdin.isTTY === true) process.stdin.setRawMode?.(false)
+      throw error
     }
   },
   stderr: process.stderr,

package/src/kernel-panels.ts

@@ -4,6 +4,7 @@ import { createElement, useEffect, useMemo, useRef, useState, type ReactElement
 import { Box, Text, useInput, useStdout } from 'ink'
 import type { ModelDirectory, ModelRow } from './models.ts'
 import type { SubagentRow } from './subagents.ts'
+import type { ScheduleRow } from './render/projection.ts'
 import type { PermissionRow } from './permissions.ts'
 import type { PresetRow } from './presets.ts'
 import type { PluginRow } from './plugin-inventory.ts'
@@ -123,7 +124,9 @@ export function ModePanel({ current, load, select, close }: {
   const visible = useMemo(() => rows.filter(row => `${row.id} ${row.name ?? ''} ${row.description ?? ''}`.toLowerCase().includes(query.toLowerCase())), [rows, query])
   useEffect(() => setCursor(value => Math.min(value, Math.max(0, visible.length - 1))), [visible.length])
   useInput((input, key) => {
-    if (key.escape || input === 'q') return close()
+    if (key.escape) return close()
+    // q closes only while the query is empty; mid-filter it is query text.
+    if (input === 'q' && query === '') return close()
     if (input === 'r' && query === '') return refresh()
     if (key.upArrow) return setCursor(value => visible.length === 0 ? 0 : (value + visible.length - 1) % visible.length)
     if (key.downArrow) return setCursor(value => visible.length === 0 ? 0 : (value + 1) % visible.length)
@@ -162,7 +165,9 @@ export function PermissionPanel({ current, load, select, close }: {
   const visible = useMemo(() => rows.filter(row => `${row.id} ${row.description ?? ''}`.toLowerCase().includes(query.toLowerCase())), [rows, query])
   useEffect(() => setCursor(value => Math.min(value, Math.max(0, visible.length - 1))), [visible.length])
   useInput((input, key) => {
-    if (key.escape || input === 'q') return close()
+    if (key.escape) return close()
+    // q closes only while the query is empty; mid-filter it is query text.
+    if (input === 'q' && query === '') return close()
     if (input === 'r' && query === '') return refresh()
     if (key.upArrow) return setCursor(value => visible.length === 0 ? 0 : (value + visible.length - 1) % visible.length)
     if (key.downArrow) return setCursor(value => visible.length === 0 ? 0 : (value + 1) % visible.length)
@@ -185,7 +190,9 @@ export function PluginPanel({ load, close, initialQuery = '' }: { load(): readon
   const rows = useMemo(() => load().filter(row => `${row.entryId} ${row.moduleName} ${row.phase ?? ''}`.toLowerCase().includes(query.toLowerCase())), [epoch, query])
   useEffect(() => setCursor(value => Math.min(value, Math.max(0, rows.length - 1))), [rows.length])
   useInput((input, key) => {
-    if (key.escape || input === 'q') return close()
+    if (key.escape) return close()
+    // q closes only while the query is empty; mid-filter it is query text.
+    if (input === 'q' && query === '') return close()
     if (input === 'r' && query === '') return setEpoch(value => value + 1)
     if (key.upArrow) return setCursor(value => rows.length === 0 ? 0 : (value + rows.length - 1) % rows.length)
     if (key.downArrow) return setCursor(value => rows.length === 0 ? 0 : (value + 1) % rows.length)
@@ -928,3 +935,82 @@ export function SubagentPanel({ current, load, pick, inherit, close }: {
     footer: '↑↓ choose · enter apply · r refresh · esc close',
   })
 }
+
+/**
+ * The /schedule panel: the read-only catalog of active reminders folded from
+ * durable schedule/change events (the web ui-schedule contract: overdue
+ * first, then ascending target; the model creates and cancels through its
+ * schedule_* tools, the panel only shows state). A local second-hand keeps
+ * the relative labels live while the panel is open.
+ */
+export interface ScheduleDisplayRow {
+  readonly key: string
+  readonly text: string
+  readonly tone?: 'error'
+}
+
+/** Human frequency label: one-shot kinds read as Once, every rows carry the interval. */
+export function scheduleFrequency(row: ScheduleRow): string {
+  if (row.kind !== 'every') return 'Once'
+  const seconds = row.everySeconds ?? 0
+  if (seconds >= 3600 && seconds % 3600 === 0) return `Every ${seconds / 3600}h`
+  if (seconds >= 60 && seconds % 60 === 0) return `Every ${seconds / 60}m`
+  return `Every ${seconds}s`
+}
+
+/** Relative label for the next target: in N unit, or N unit overdue. */
+export function scheduleRelative(targetAt: number, now: number): string {
+  const delta = Math.max(0, Math.abs(targetAt - now))
+  const minutes = Math.floor(delta / 60_000)
+  const unit = minutes === 0
+    ? '<1m'
+    : minutes >= 60
+      ? `${Math.floor(minutes / 60)}h${String(minutes % 60).padStart(2, '0')}`
+      : `${minutes}m`
+  return targetAt <= now ? `${unit} overdue` : `in ${unit}`
+}
+
+/** Ordered display rows: overdue first (error tone), then ascending target. */
+export function scheduleDisplayRows(rows: readonly ScheduleRow[], now: number): readonly ScheduleDisplayRow[] {
+  return [...rows]
+    .sort((left, right) => (Number(left.targetAt > now) - Number(right.targetAt > now)) || (left.targetAt - right.targetAt))
+    .map(row => ({
+      key: row.id,
+      text: `${row.prompt} · ${scheduleFrequency(row)} · ${new Date(row.targetAt).toLocaleString()} (${scheduleRelative(row.targetAt, now)})`,
+      tone: row.targetAt <= now ? 'error' as const : undefined,
+    }))
+}
+
+export function SchedulePanel({ rows, close }: { rows(): readonly ScheduleRow[]; close(): void }): ReactElement {
+  const [, setTick] = useState(0)
+  useEffect(() => {
+    const id = setInterval(() => setTick(value => value + 1), 1_000)
+    return () => clearInterval(id)
+  }, [])
+  const display = scheduleDisplayRows(rows(), Date.now())
+  const stdout = useStdout().stdout
+  const viewport = panelViewport(stdout?.columns ?? 80, stdout?.rows ?? 30)
+  useInput((input, key) => {
+    if (key.escape || input === 'q') return close()
+  })
+  if (viewport.maxHeight === 0 || viewport.compact) {
+    const summary = display.length === 0 ? 'no active reminders' : singleLineText(display[0]!.text)
+    return createElement(Text, { wrap: 'truncate-end' }, truncateColumns(`/schedule · ${summary}`, viewport.contentColumns))
+  }
+  const budget = Math.max(1, viewport.bodyRows)
+  const visible = display.slice(0, budget)
+  const hidden = display.length - visible.length
+  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(`/schedule · ${display.length} active reminder${display.length === 1 ? '' : 's'}`, viewport.contentColumns)),
+    ...(display.length === 0
+      ? [createElement(Text, { dimColor: true, wrap: 'truncate-end' }, truncateColumns('  no active reminders — the model creates them with schedule_create', viewport.contentColumns))]
+      : visible.map(row => createElement(Text, {
+        key: row.key,
+        color: row.tone === 'error' ? inkColor(getPalette().error) : undefined,
+        wrap: 'truncate-end',
+      }, truncateColumns(`  ${singleLineText(row.text)}`, viewport.contentColumns)))),
+    createElement(Text, { dimColor: true, wrap: 'truncate-end' }, truncateColumns(`esc/q close${hidden > 0 ? ` · +${hidden} more` : ''} · the model schedules via schedule_create`, viewport.contentColumns)),
+  )
+}

package/src/provider-settings.ts

@@ -33,6 +33,8 @@ interface LlmFace {
     readonly settingsNs: string
     readonly settingsPath: readonly string[]
     readonly declared?: boolean
+    /** Configuration diagnostic for repair; unaffected models may remain serviceable. */
+    readonly error?: string
   }[]
   /**
    * Registered endpoint model discovery; absent on an older service. The
@@ -256,18 +258,6 @@ export interface DiscoveredModelView {
   readonly maxTokens?: number
 }
 
-/** One model an endpoint reported about itself (mirrors LlmDiscoveredModel). */
-export interface DiscoveredModelView {
-  /** Model id the endpoint accepts. */
-  readonly id: string
-  /** Human-readable name when the endpoint supplies one. */
-  readonly name?: string
-  /** Context window when disclosed; adoption still owes it if absent. */
-  readonly contextWindow?: number
-  /** Output cap when disclosed. */
-  readonly maxTokens?: number
-}
-
 /**
  * The seven canonical reasoning levels a reasoningEfforts key may name -
  * pi-ai's THINKING_LEVELS. A pi-ai upgrade that adds or removes one fails
@@ -362,6 +352,12 @@ export interface ProviderTargetView {
   readonly configuration: ProviderConfiguration
   /** The owning adapter reports this route as hand-declared (absent when it draws no distinction). */
   readonly declared?: boolean
+  /**
+   * Configuration diagnostic the adapter reported for this route (catalog or
+   * profile damage): the row stays listed and repairable instead of the whole
+   * provider vanishing; absent when the route reads clean.
+   */
+  readonly diagnostic?: string
 }
 
 /** The resolved provider/settings/credential join. */
@@ -431,6 +427,7 @@ export async function loadProviderSettings(ctx: Context): Promise<ProviderSettin
     settingsNs: string
     settingsPath: readonly string[]
     declared?: boolean
+    error?: string
   }> = []
   if (llm.listConfigurableProviders !== undefined) {
     try {
@@ -462,6 +459,7 @@ export async function loadProviderSettings(ctx: Context): Promise<ProviderSettin
     settingsNs: string
     settingsPath: readonly string[]
     declared?: boolean
+    error?: string
   }> = [
     ...directoryEntries.map(entry => ({
       provider: entry.provider,
@@ -470,6 +468,7 @@ export async function loadProviderSettings(ctx: Context): Promise<ProviderSettin
       settingsNs: entry.settingsNs,
       settingsPath: entry.settingsPath,
       ...entry.declared === undefined ? {} : { declared: entry.declared },
+      ...entry.error === undefined ? {} : { error: singleLine(entry.error) },
     })),
     ...registered
       .filter(provider => !declared.has(provider.id))
@@ -508,6 +507,7 @@ export async function loadProviderSettings(ctx: Context): Promise<ProviderSettin
       ...credentialRef === undefined ? {} : { credentialRef },
       suggestedRef: deriveCredentialRef(base.provider),
       ...base.declared === undefined ? {} : { declared: base.declared },
+      ...base.error === undefined ? {} : { diagnostic: base.error },
     }
   })
   const refs = [...new Set(rows.flatMap(row => row.credentialRef === undefined ? [] : [row.credentialRef]))]