dsh-code 1.0.4 → 1.0.6

package/src/internals.ts

@@ -44,46 +44,67 @@ 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 : ''),
+      )
+      // 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/permissions.ts

@@ -24,7 +24,7 @@ export function effectivePermission(
   session: Session | undefined,
   pending: string | undefined,
 ): string {
-  return session === undefined ? pending ?? service.defaultPreset : service.current(session.events)
+  return session === undefined ? pending ?? service.defaultPreset : service.current(session)
 }
 
 /** Validate a preset and write it only when a durable session already exists. */

package/src/presets.ts

@@ -21,15 +21,27 @@ export function isBlankSession(events: readonly SessionEvent[]): boolean {
   return !events.some(event => event.type === 'turn/start')
 }
 
+/** Upstream renamed the shipped `code` preset to `ptc` in 0.1.2-rc.1; sessions
+ * and CLI choices recorded before the rename keep resolving through this map. */
+const LEGACY_PRESET_IDS: Readonly<Record<string, string>> = { code: 'ptc' }
+
+/** Translate a preset id recorded before an upstream rename to its current id. */
+export function normalizePresetId(id: string): string
+export function normalizePresetId(id: string | undefined): string | undefined
+export function normalizePresetId(id: string | undefined): string | undefined {
+  return id === undefined ? undefined : LEGACY_PRESET_IDS[id] ?? id
+}
+
 /** Latest logged selection wins; legacy sessions deliberately fall back to standard. */
-export function resolvePreset(session: Pick<Session, 'header' | 'events'>): string {
-  for (let index = session.events.length - 1; index >= 0; index -= 1) {
-    const event = session.events[index] as unknown as { type: string; data?: { agentPreset?: string } }
+export function resolvePreset(session: Pick<Session, 'header' | 'snapshotEvents'>): string {
+  const events = session.snapshotEvents()
+  for (let index = events.length - 1; index >= 0; index -= 1) {
+    const event = events[index] as unknown as { type: string; data?: { agentPreset?: string } }
     if (event.type === 'agent-preset/selected' && event.data?.agentPreset !== undefined) {
-      return event.data.agentPreset
+      return normalizePresetId(event.data.agentPreset) as string
     }
   }
-  return session.header.agentPreset ?? 'standard'
+  return normalizePresetId(session.header.agentPreset) ?? 'standard'
 }
 
 /** Resolve a pre-session choice, or recompose an active blank Agent. */
@@ -38,6 +50,7 @@ export async function selectPreset(
   agent: Agent | undefined,
   presetId: string,
 ): Promise<PresetRow> {
+  presetId = normalizePresetId(presetId)
   if (agent !== undefined) return switchPreset(service, agent, presetId)
   const preset = await service.resolve(presetId)
   if (preset.broken !== undefined) throw new Error(preset.broken)
@@ -50,7 +63,7 @@ export async function switchPreset(
   agent: Agent,
   presetId: string,
 ): Promise<PresetRow> {
-  if (!isBlankSession(agent.session.events)) {
+  if (!isBlankSession(agent.session.snapshotEvents())) {
     throw new Error('mode is locked after the first turn; use /new <mode>')
   }
   const preset = await service.recompose(agent.ctx, presetId)

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]))]

package/src/questions.ts

@@ -1,12 +1,12 @@
 /**
- * The terminal ask_user_question provider: registers the single UI provider
- * on `ctx.userQuestions` and drives it with a FIFO queue — one question
- * request on screen at a time, everything else waiting — then resolves the
- * collected answers back into the tool's promise. The community TUI proved
- * this exact pipeline shape; here the dialog is an Ink bar instead of a
- * pi-tui inline modal.
+ * The terminal ask_user_question answerer: one `user-questions/request`
+ * waterfall listener that drives a FIFO queue — one question request on
+ * screen at a time, everything else waiting — then resolves the collected
+ * answers back into the waterfall. Mirrors the approval answerer's claim/
+ * defer split: only agents this TUI owns are answered, every other request
+ * falls through to the next answerer.
  *
- * Plan reviews (`exit_plan_mode`) arrive through the same service with an
+ * Plan reviews (`exit_plan_mode`) arrive through the same waterfall with an
  * `intent: { kind: 'plan-review' }` — the renderer highlights the approve
  * option; the answer encoding is identical either way.
  *
@@ -14,6 +14,7 @@
  */
 
 import type { Context } from '@deepseek-ai/cordis'
+import type { Agent } from '@deepseek-ai/dsh-agent'
 import {
   UserQuestionError,
   type AskUserQuestionAnswer,
@@ -56,13 +57,15 @@ const ABORT_ERROR = new UserQuestionError(
 )
 
 /**
- * Mount the single `ctx.userQuestions` UI provider over a FIFO queue.
- * @param ctx - context carrying the `userQuestions` service (dsh-base).
- * @returns the store the renderer subscribes to; a context without the
- * service yields a permanently empty store.
+ * Mount the `user-questions/request` answerer over a FIFO queue.
+ * @param ctx - plugin context whose event bus carries the waterfall.
+ * @param owns - agents this terminal answers for; every other request is
+ * deferred back into the waterfall (`next()`), so sibling answerers stay
+ * usable. Agent-less asks are claimed: this TUI is the only human surface
+ * in the process.
+ * @returns the store the renderer subscribes to.
  */
-export function mountQuestionProvider(ctx: Context): QuestionStore {
-  const service = ctx.get('userQuestions')
+export function mountQuestionProvider(ctx: Context, owns: (agent: Agent) => boolean): QuestionStore {
   let snapshot: QuestionSnapshot = { pending: undefined }
   let active: PendingQuestion | undefined
   const queue: PendingQuestion[] = []
@@ -79,69 +82,49 @@ export function mountQuestionProvider(ctx: Context): QuestionStore {
     set({ pending: next })
   }
 
-  if (service !== undefined) {
-    // Capability guard against contract drift: the pinned release exposes
-    // registerProvider, but an upstream alignment may replace it with the
-    // 'user-questions/request' waterfall. Degrade to the permanently-empty
-    // store (the no-service path) instead of failing startup with a
-    // TypeError on a missing method.
-    if (typeof (service as unknown as { registerProvider?: unknown }).registerProvider !== 'function') {
-      return {
-        subscribe(listener: () => void): () => void {
-          listeners.add(listener)
-          return () => {
-            listeners.delete(listener)
-          }
-        },
-        getSnapshot(): QuestionSnapshot {
-          return snapshot
-        },
-        submit(): void {},
-        cancel(): void {},
+  ctx.on('user-questions/request', (
+    request: AskUserQuestionRequest,
+    next: () => Promise<AskUserQuestionAnswer>,
+  ): Promise<AskUserQuestionAnswer> => {
+    if (request.agent !== undefined && !owns(request.agent)) return next()
+    return new Promise((resolve, reject) => {
+      // Abort settles through the same channel as an Esc cancel: the
+      // owning tool/step died, so the answer must not linger.
+      const onAbort = (): void => {
+        if (active === pending) {
+          active = undefined
+          set({ pending: undefined })
+          advance()
+        } else {
+          const at = queue.indexOf(pending)
+          if (at >= 0) queue.splice(at, 1)
+        }
+        reject(ABORT_ERROR)
+      }
+      // Detach on every settle so an answered/cancelled question never
+      // retains a listener on the owning tool call's signal.
+      const detachAbort = (): void => {
+        if (request.signal !== undefined) request.signal.removeEventListener('abort', onAbort)
+      }
+      const pending: PendingQuestion = {
+        request,
+        resolve,
+        reject,
+        detachAbort,
+      }
+      if (request.signal?.aborted === true) {
+        reject(ABORT_ERROR)
+        return
+      }
+      request.signal?.addEventListener('abort', onAbort, { once: true })
+      if (active === undefined) {
+        active = pending
+        set({ pending })
+      } else {
+        queue.push(pending)
       }
-    }
-    service.registerProvider({
-      ask(request: AskUserQuestionRequest): Promise<AskUserQuestionAnswer> {
-        return new Promise((resolve, reject) => {
-          // Abort settles through the same channel as an Esc cancel: the
-          // owning tool/step died, so the answer must not linger.
-          const onAbort = (): void => {
-            if (active === pending) {
-              active = undefined
-              set({ pending: undefined })
-              advance()
-            } else {
-              const at = queue.indexOf(pending)
-              if (at >= 0) queue.splice(at, 1)
-            }
-            reject(ABORT_ERROR)
-          }
-          // Detach on every settle so an answered/cancelled question never
-          // retains a listener on the owning tool call's signal.
-          const detachAbort = (): void => {
-            if (request.signal !== undefined) request.signal.removeEventListener('abort', onAbort)
-          }
-          const pending: PendingQuestion = {
-            request,
-            resolve,
-            reject,
-            detachAbort,
-          }
-          if (request.signal?.aborted === true) {
-            reject(ABORT_ERROR)
-            return
-          }
-          request.signal?.addEventListener('abort', onAbort, { once: true })
-          if (active === undefined) {
-            active = pending
-            set({ pending })
-          } else {
-            queue.push(pending)
-          }
-        })
-      },
     })
-  }
+  })
 
   return {
     subscribe(listener: () => void): () => void {