dsh-code 1.0.0 → 1.0.2

package/src/internals.ts

@@ -8,7 +8,16 @@
 
 import { render } from 'ink'
 import type { ReactElement } from 'react'
-import { BRACKETED_PASTE_DISABLE, BRACKETED_PASTE_ENABLE, KEYBOARD_ENHANCE_DISABLE, KEYBOARD_ENHANCE_ENABLE } from './keyboard.ts'
+import {
+  BRACKETED_PASTE_DISABLE,
+  BRACKETED_PASTE_ENABLE,
+  KEYBOARD_ENHANCE_DISABLE,
+  KEYBOARD_ENHANCE_ENABLE,
+  TERMINAL_FOCUS_REPORT_DISABLE,
+  TERMINAL_FOCUS_REPORT_ENABLE,
+  isVsCodeTerminalEnv,
+  shouldEnableKeyboardEnhancement,
+} from './keyboard.ts'
 
 /** A mounted terminal app instance; the runner owns unmount ordering. */
 export interface TuiMount {
@@ -29,11 +38,16 @@ export const internals: {
   stderr: { write(chunk: string): unknown }
 } = {
   mount: (element: ReactElement): TuiMount => {
-    // Codex keyboard_modes parity: push the kitty keyboard protocol so
-    // Shift+Enter arrives as CSI 13;2u instead of a bare CR, and enable
-    // bracketed paste so pasted newlines insert instead of submitting. Both
-    // are inert in terminals without support.
-    process.stdout.write(KEYBOARD_ENHANCE_ENABLE + BRACKETED_PASTE_ENABLE)
+    // VS Code's integrated terminal can route Tab to the workbench when Kitty
+    // enhancement is enabled. Keep bracketed paste everywhere, but only push
+    // 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
@@ -45,9 +59,12 @@ export const internals: {
       },
       unmount(): void {
         instance.unmount()
-        // Pop the stack so the parent shell does not inherit enhanced key
-        // reporting (Codex resets even harder on forced exit).
-        process.stdout.write(KEYBOARD_ENHANCE_DISABLE + BRACKETED_PASTE_DISABLE)
+        // 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 : ''),
+        )
       },
     }
   },

package/src/keyboard.ts

@@ -2,33 +2,74 @@
  * Keyboard enhancement protocol (Codex `keyboard_modes` parity) and the
  * kitty CSI-u normalization layer.
  *
- * The TUI pushes the kitty keyboard protocol with DISAMBIGUATE_ESCAPE_CODES
- * and REPORT_ALTERNATE_KEYS (flags 1|4 = `\x1b[>5u`), which makes terminals
- * report Shift+Enter as `CSI 13;2u` instead of a bare CR. Event types are
- * deliberately NOT requested: Ink 5's parser cannot decode the
- * `:event-type` suffix, and repeat/release reporting buys this surface
- * nothing.
+ * The TUI pushes the kitty keyboard protocol with DISAMBIGUATE_ESCAPE_CODES
+ * and REPORT_ALTERNATE_KEYS (flags 1|4 = `\x1b[>5u`). Event types are
+ * deliberately NOT requested: Ink 5's parser cannot decode the
+ * `:event-type` suffix, and repeat/release reporting buys this surface
+ * nothing.
  *
  * Ink 5 also cannot parse most CSI-u forms at all — they fall through its
  * regex as unnamed sequences and get INSERTED AS DRAFT TEXT. The composer's
  * stdin read patch therefore rewrites every CSI-u form it can decode back
  * to the legacy byte or canonical sequence the existing key handling
- * already understands, before Ink ever parses the chunk.
- *
- * @module @deepseek-ai/dsh-code/keyboard
- */
-
-/** Push keyboard enhancement (modifyOtherKeys off, kitty flags 1|4). */
-export const KEYBOARD_ENHANCE_ENABLE = '\x1b[>4;0m\x1b[>5u'
+ * already understands, before Ink ever parses the chunk.
+ * @module @deepseek-ai/dsh-code/keyboard
+ */
+
+/** Push keyboard enhancement (modifyOtherKeys off, kitty flags 1|4). */
+export const KEYBOARD_ENHANCE_ENABLE = '\x1b[>4;0m\x1b[>5u'
 
 /** Pop the enhancement stack and reset modifyOtherKeys (exit path). */
-export const KEYBOARD_ENHANCE_DISABLE = '\x1b[<u\x1b[>4;0m'
-
-/** Enable bracketed paste reporting. */
-export const BRACKETED_PASTE_ENABLE = '\x1b[?2004h'
+export const KEYBOARD_ENHANCE_DISABLE = '\x1b[<u\x1b[>4;0m'
+
+/** Explicit environment overrides for terminal keyboard enhancement. */
+export const DSH_DISABLE_KEYBOARD_ENHANCEMENT = 'DSH_DISABLE_KEYBOARD_ENHANCEMENT'
+export const DSH_ENABLE_KEYBOARD_ENHANCEMENT = 'DSH_ENABLE_KEYBOARD_ENHANCEMENT'
+
+function parseBooleanEnv(value: string | undefined): boolean | undefined {
+  if (value === undefined) return undefined
+  const normalized = value.trim().toLowerCase()
+  if (normalized === '1' || normalized === 'true' || normalized === 'yes') return true
+  if (normalized === '0' || normalized === 'false' || normalized === 'no') return false
+  return undefined
+}
+
+/** True when the process is running inside the VS Code integrated terminal. */
+export function isVsCodeTerminalEnv(env: NodeJS.ProcessEnv = process.env): boolean {
+  return env.TERM_PROGRAM?.trim().toLowerCase() === 'vscode' || env.VSCODE_INJECTION === '1'
+}
+
+/** Whether to push Kitty keyboard enhancement for the current terminal. */
+export function shouldEnableKeyboardEnhancement(env: NodeJS.ProcessEnv = process.env): boolean {
+  const explicitDisable = parseBooleanEnv(env[DSH_DISABLE_KEYBOARD_ENHANCEMENT])
+  if (explicitDisable === true) return false
+  const explicitEnable = parseBooleanEnv(env[DSH_ENABLE_KEYBOARD_ENHANCEMENT])
+  if (explicitEnable !== undefined) return explicitEnable
+  return !isVsCodeTerminalEnv(env)
+}
 
-/** Disable bracketed paste reporting. */
-export const BRACKETED_PASTE_DISABLE = '\x1b[?2004l'
+/** Enable bracketed paste reporting. */
+export const BRACKETED_PASTE_ENABLE = '\x1b[?2004h'
+
+/** Disable bracketed paste reporting. */
+export const BRACKETED_PASTE_DISABLE = '\x1b[?2004l'
+
+/** Enable terminal focus-in/focus-out reporting (xterm focus protocol). */
+export const TERMINAL_FOCUS_REPORT_ENABLE = '\x1b[?1004h'
+
+/** Disable terminal focus-in/focus-out reporting. */
+export const TERMINAL_FOCUS_REPORT_DISABLE = '\x1b[?1004l'
+
+/**
+ * Remove xterm focus reports from one input chunk and update the caller's
+ * focus state. Focus reports are terminal protocol, not composer text.
+ */
+export function stripTerminalFocusEvents(chunk: string, onFocus: (focused: boolean) => void): string {
+  return chunk.replace(/\x1b\[(I|O)/gu, (_whole, event: string) => {
+    onFocus(event === 'I')
+    return ''
+  })
+}
 
 /** Bracketed paste markers as Ink delivers them (it strips the leading ESC). */
 export const PASTE_START_MARKER = '[200~'
@@ -39,9 +80,13 @@ export const PASTE_END_MARKER = '[201~'
  * `input` text, where an unhandled paste would otherwise persist the literal
  * "[200~"/"[201~" markers Ink leaves after stripping the ESC byte.
  */
-export function stripPasteMarkers(text: string): string {
-  return text.replaceAll(PASTE_START_MARKER, '').replaceAll(PASTE_END_MARKER, '')
-}
+export function stripPasteMarkers(text: string): string {
+  return text
+    .replaceAll(`\x1b${PASTE_START_MARKER}`, '')
+    .replaceAll(`\x1b${PASTE_END_MARKER}`, '')
+    .replaceAll(PASTE_START_MARKER, '')
+    .replaceAll(PASTE_END_MARKER, '')
+}
 
 /** One decoded CSI-u keypress: key code, 1-based modifier param, alternate code. */
 interface CsiUKey {
@@ -51,21 +96,20 @@ interface CsiUKey {
 }
 
 /** Match one CSI-u sequence (code, optional ;modifiers, then :event or ;alternate). */
-const CSI_U_SOURCE = '\x1b\\[(\\d+)(?:;(\\d+))?(?:[:;](\\d+))?u'
-
-/** Legacy equivalent for one decoded CSI-u key, or undefined to pass through. */
-function legacyForKey(key: CsiUKey): string | undefined {
+const CSI_U_SOURCE = '\x1b\\[(\\d+)(?:;(\\d+))?(?:[:;](\\d+))?u'
+
+/** Legacy equivalent for one decoded CSI-u key, or undefined to pass through. */
+function legacyForKey(key: CsiUKey): string | undefined {
   const bits = Math.max(0, key.modifiers - 1)
   const shift = (bits & 1) !== 0
   const alt = (bits & 2) !== 0
-  const ctrl = (bits & 4) !== 0
-  if (key.code === 13) {
-    // Enter: shift keeps the canonical enhanced form the composer detects;
-    // ctrl maps to LF (the Ctrl+J newline binding), alt to ESC+CR.
-    if (shift) return '\x1b[13;2u'
-    if (ctrl) return '\n'
-    if (alt) return '\x1b\r'
-    return '\r'
+  const ctrl = (bits & 4) !== 0
+  if (key.code === 13) {
+    // Modified Enter has no dedicated composer behavior. Preserve the legacy
+    // Ctrl/Alt bytes and collapse every other form to ordinary Enter.
+    if (ctrl) return '\n'
+    if (alt) return '\x1b\r'
+    return '\r'
   }
   if (key.code === 27) return '\x1b'
   if (key.code === 9) return shift ? '\x1b[Z' : '\t'
@@ -111,10 +155,10 @@ function legacyForKey(key: CsiUKey): string | undefined {
  * sequences pass through untouched, so terminals without the protocol are
  * unaffected.
  */
-export function normalizeKeyboardChunk(chunk: string): string {
-  if (!chunk.includes('\x1b[') || !chunk.includes('u')) return chunk
-  const pattern = new RegExp(CSI_U_SOURCE, 'g')
-  return chunk.replace(pattern, (whole, code: string, mods?: string, third?: string) => {
+export function normalizeKeyboardChunk(chunk: string): string {
+  if (!chunk.includes('\x1b[') || !chunk.includes('u')) return chunk
+  const pattern = new RegExp(CSI_U_SOURCE, 'g')
+  return chunk.replace(pattern, (whole, code: string, mods?: string, third?: string) => {
     const legacy = legacyForKey({
       code: Number.parseInt(code, 10),
       modifiers: mods === undefined || mods === '' ? 1 : Math.max(1, Number.parseInt(mods, 10)),
@@ -122,4 +166,85 @@ export function normalizeKeyboardChunk(chunk: string): string {
     })
     return legacy ?? whole
   })
-}
+}
+
+/** Editor actions Ink cannot distinguish reliably when terminal bytes batch. */
+export type RawEditorToken =
+  | { readonly kind: 'text'; readonly text: string }
+  | { readonly kind: 'home' | 'end' | 'delete-backward' | 'delete-word-backward' | 'delete-forward' | 'delete-word-forward' }
+
+const HOME_SEQUENCES = ['\x1b[H', '\x1b[1~', '\x1b[7~', '\x1bOH'] as const
+const END_SEQUENCES = ['\x1b[F', '\x1b[4~', '\x1b[8~', '\x1bOF'] as const
+
+/** Parse one CSI functional-key sequence at `offset`. */
+function functionalToken(chunk: string, offset: number): { token: RawEditorToken; length: number } | undefined {
+  const tail = chunk.slice(offset)
+  for (const sequence of HOME_SEQUENCES) {
+    if (tail.startsWith(sequence)) return { token: { kind: 'home' }, length: sequence.length }
+  }
+  for (const sequence of END_SEQUENCES) {
+    if (tail.startsWith(sequence)) return { token: { kind: 'end' }, length: sequence.length }
+  }
+  const modifiedHome = /^\x1b\[1;(\d+)H/u.exec(tail)
+  if (modifiedHome !== null) return { token: { kind: 'home' }, length: modifiedHome[0].length }
+  const modifiedEnd = /^\x1b\[1;(\d+)F/u.exec(tail)
+  if (modifiedEnd !== null) return { token: { kind: 'end' }, length: modifiedEnd[0].length }
+  const modifiedDelete = /^\x1b\[3(?:;(\d+))?~/u.exec(tail)
+  if (modifiedDelete !== null) {
+    const modifiers = Number.parseInt(modifiedDelete[1] ?? '1', 10) - 1
+    const byWord = (modifiers & 2) !== 0 || (modifiers & 4) !== 0
+    return {
+      token: { kind: byWord ? 'delete-word-forward' : 'delete-forward' },
+      length: modifiedDelete[0].length,
+    }
+  }
+  return undefined
+}
+
+/**
+ * Tokenize a stdin chunk containing at least one editor-only key. Ink calls
+ * `useInput` once for a pasted/batched chunk, so preserving each action here
+ * prevents repeated Backspace/Home/End/Delete presses from collapsing into
+ * one blurred key event. Unknown escape sequences return undefined and stay
+ * under Ink's ownership.
+ */
+export function tokenizeRawEditorChunk(chunk: string): readonly RawEditorToken[] | undefined {
+  const tokens: RawEditorToken[] = []
+  let text = ''
+  let special = false
+  const flushText = (): void => {
+    if (text === '') return
+    tokens.push({ kind: 'text', text })
+    text = ''
+  }
+  for (let offset = 0; offset < chunk.length;) {
+    if (chunk.startsWith('\x1b\x7f', offset) || chunk.startsWith('\x1b\b', offset)) {
+      flushText()
+      tokens.push({ kind: 'delete-word-backward' })
+      special = true
+      offset += 2
+      continue
+    }
+    const functional = functionalToken(chunk, offset)
+    if (functional !== undefined) {
+      flushText()
+      tokens.push(functional.token)
+      special = true
+      offset += functional.length
+      continue
+    }
+    const char = chunk[offset]!
+    if (char === '\x7f' || char === '\b') {
+      flushText()
+      tokens.push({ kind: 'delete-backward' })
+      special = true
+      offset += 1
+      continue
+    }
+    if (char === '\x1b') return undefined
+    text += char
+    offset += 1
+  }
+  flushText()
+  return special ? tokens : undefined
+}

package/src/mentions.ts

@@ -22,6 +22,7 @@
 
 import type { Context } from '@deepseek-ai/cordis'
 import type { Agent } from '@deepseek-ai/dsh-agent'
+import { isAbsolute, resolve } from 'node:path'
 import {
   DEFAULT_FILE_SEARCH_EXCLUDED_DIRECTORIES,
   DEFAULT_FILE_SEARCH_MAX_ENTRIES,
@@ -46,6 +47,8 @@ export interface MentionCandidate {
   description: string
   /** Origin kind for icon/coloring decisions. */
   kind: 'file' | 'directory' | 'session'
+  /** Absolute path for file candidates; never rendered or persisted directly. */
+  path?: string
 }
 
 /** Prepared submission: readable content plus optional injected context. */
@@ -72,6 +75,11 @@ interface FileReferenceServiceLike {
 /** Menu cap on file rows; the service owns ranking and default rows. */
 const MAX_FILE_ROWS = 20
 
+/** Whether a mention token is already navigating a filesystem path. */
+export function isPathLikeMentionQuery(query: string): boolean {
+  return /[\\/]/u.test(query)
+}
+
 /** The mention API the input editor and the runner share. */
 export interface MentionsApi {
   /** Ranked menu candidates for the typed `@` query. */
@@ -133,7 +141,7 @@ export function createMentions(ctx: Context, agent: Agent | undefined, cwd: stri
           : agent === undefined
             ? preSessionFiles(needle, signal).catch(() => [] as readonly ServiceFileCandidate[])
             : Promise.resolve([] as readonly ServiceFileCandidate[]),
-        sessionCapable && needle !== '' && agent !== undefined
+        sessionCapable && needle !== '' && !isPathLikeMentionQuery(needle) && agent !== undefined
           ? resolver!.listCandidates(agent, needle, 10, signal).catch(() => [] as readonly SessionReferenceCandidate[])
           : Promise.resolve([] as readonly SessionReferenceCandidate[]),
       ])
@@ -144,6 +152,9 @@ export function createMentions(ctx: Context, agent: Agent | undefined, cwd: stri
         label: candidate.path,
         description: candidate.kind === 'directory' ? 'Folder' : 'File',
         kind: candidate.kind,
+        ...candidate.kind === 'file'
+          ? { path: isAbsolute(candidate.path) ? candidate.path : resolve(cwd, candidate.path) }
+          : {},
       }))
       const sessionRows: MentionCandidate[] = sessions.map(candidate => ({
         label: formatSessionReferenceMention(candidate),

package/src/models.ts

@@ -13,10 +13,11 @@ import type { ModelSelection } from '@deepseek-ai/dsh-agent'
 import {
   ReasoningEffortId,
   type LlmCallConfig,
-  type LlmModelInfo,
-  type LlmModelReasoningInfo,
-  type LlmResolvedModelInfo,
-} from '@deepseek-ai/dsh-llm'
+  type LlmModelInfo,
+  type LlmModelReasoningInfo,
+  type LlmResolvedModelInfo,
+  type ModelModality,
+} from '@deepseek-ai/dsh-llm'
 
 /** Display metadata for one adapter-owned reasoning effort (mirrors `LlmReasoningEffortInfo`). */
 export interface ModelReasoningEffort {
@@ -44,9 +45,11 @@ export interface ModelRow {
   providerName: string
   /** Provider-owned model id. */
   model: string
-  /** Human-readable model name. */
-  modelName: string
-  /** Adapter-owned selectable reasoning levels when the model exposes any. */
+  /** Human-readable model name. */
+  modelName: string
+  /** Request modalities advertised for this exact route; absent means unknown. */
+  inputModalities?: readonly ModelModality[]
+  /** Adapter-owned selectable reasoning levels when the model exposes any. */
   reasoning?: ModelReasoning
 }
 
@@ -194,16 +197,19 @@ export async function loadModelDirectory(ctx: Context): Promise<ModelDirectory>
       const rows = await Promise.all(models.map(async (model): Promise<ModelRow> => {
         const row: ModelRow = {
           provider: provider.id,
-          providerName: provider.name,
-          model: model.id,
-          modelName: model.name,
-        }
+          providerName: provider.name,
+          model: model.id,
+          modelName: model.name,
+          ...model.inputModalities === undefined ? {} : { inputModalities: [...model.inputModalities] },
+        }
         if (llmResolve.resolveModelInfo === undefined) return row
         try {
           const resolved = await llmResolve.resolveModelInfo(provider.id, model.id)
-          return resolved.reasoning === undefined
-            ? row
-            : { ...row, reasoning: mapReasoning(resolved.reasoning) }
+          return {
+            ...row,
+            ...resolved.inputModalities === undefined ? {} : { inputModalities: [...resolved.inputModalities] },
+            ...resolved.reasoning === undefined ? {} : { reasoning: mapReasoning(resolved.reasoning) },
+          }
         } catch {
           reasoningFailures.push(`${provider.id}/${model.id}`)
           return row

package/src/permissions.ts

@@ -1,7 +1,8 @@
 /** Permission-preset policy for pending and active TUI sessions. */
 
 import type { Context } from '@deepseek-ai/cordis'
-import type { Session, SessionEvent } from '@deepseek-ai/dsh-session'
+import type { PermissionPresetService } from '@deepseek-ai/dsh-permission-presets'
+import type { Session } from '@deepseek-ai/dsh-session'
 
 /** One selectable permission preset row for the /permission panel. */
 export interface PermissionRow {
@@ -9,20 +10,12 @@ export interface PermissionRow {
   readonly description?: string
 }
 
-/** Structural boundary over Harness permission presets; values stay service-owned. */
-export interface PermissionPresetsService {
-  readonly names: readonly string[]
-  readonly defaultPreset: string
-  resolve(name: string): unknown
-  current(events: readonly SessionEvent[]): string
-  set(session: Session, preset: string): void
-  /** Client presentation metadata for one preset; may reject unknown names. */
-  optionOf?(name: string): { name: string; description?: string } | undefined
-}
+/** Public compatibility alias for the official upstream permission service. */
+export type PermissionPresetsService = PermissionPresetService
 
 /** Read the optional Harness service without importing its runtime package. */
 export function permissionPresetsFrom(ctx: Context): PermissionPresetsService | undefined {
-  return (ctx as unknown as { get(name: string): unknown }).get('permissionPresets') as PermissionPresetsService | undefined
+  return ctx.get('permissionPresets')
 }
 
 /** Effective label for either an active session or the not-yet-created first one. */
@@ -75,7 +68,6 @@ export function applyPendingPermission(
  */
 export function listPermissionRows(service: PermissionPresetsService): readonly PermissionRow[] {
   return service.names.map((id) => {
-    if (service.optionOf === undefined) return { id }
     try {
       return { id, description: service.optionOf(id)?.description }
     } catch {

package/src/presets.ts

@@ -2,31 +2,18 @@
 
 import type { Context } from '@deepseek-ai/cordis'
 import type { Agent } from '@deepseek-ai/dsh-agent'
+import type { AgentPreset, AgentPresets } from '@deepseek-ai/dsh-agent-presets'
 import type { Session, SessionEvent } from '@deepseek-ai/dsh-session'
 
 /** One discoverable agent composition. */
-export interface PresetRow {
-  readonly id: string
-  readonly trust: 'system' | 'user'
-  readonly name?: string
-  readonly description?: string
-  readonly order?: number
-  readonly broken?: string
-}
+export type PresetRow = AgentPreset
 
-/** Structural boundary for the optional upstream AgentPresets service. */
-export interface AgentPresetsService {
-  readonly defaultId: string
-  list(): Promise<PresetRow[]>
-  resolve(id?: string): Promise<PresetRow>
-  mount(agentCtx: Context, id?: string): Promise<PresetRow>
-  recompose(agentCtx: Context, id: string): Promise<PresetRow>
-  composedPreset(agentCtx: Context): string | undefined
-}
+/** Public compatibility alias for the official upstream service type. */
+export type AgentPresetsService = AgentPresets
 
 /** Read an optional Cordis service without requiring its package at build time. */
 export function agentPresetsFrom(ctx: Context): AgentPresetsService | undefined {
-  return (ctx as unknown as { get(name: string): unknown }).get('agentPresets') as AgentPresetsService | undefined
+  return ctx.get('agentPresets')
 }
 
 /** A preset may change only before the first durable turn begins. */

package/src/provider-settings.ts

@@ -249,7 +249,7 @@ export interface ProviderSettingsDirectory {
 
 /** Events that invalidate the official Models provider/settings/credential join. */
 const PROVIDER_SETTINGS_EVENTS = [
-  'credentials/updated',
+  'credentials/reference-updated',
   'settings/document-updated',
   'llm/adapters-updated',
 ] as const