dsh-code 1.0.3 → 1.0.5

package/src/approval.ts

@@ -96,6 +96,13 @@ export function mountApprovalAnswerer(
 
     let resolved = false
     let settle!: (outcome: ApprovalOutcome) => void
+    // Established BEFORE the abort listener mounts: a synchronous throw
+    // between the listener registration and a later construction site would
+    // otherwise leave a subsequent abort invoking an unassigned settle from
+    // inside the AbortSignal listener (an uncaughtException).
+    const settled = new Promise<ApprovalOutcome>((resolve) => {
+      settle = resolve
+    })
     const signal = request.signal
     const onAbort = (): void => withdraw()
     // Detach on every settle so an answered ask never retains a listener on
@@ -136,9 +143,7 @@ export function mountApprovalAnswerer(
     queue.push(slot)
     publish()
 
-    return new Promise<ApprovalOutcome>((resolve) => {
-      settle = resolve
-    }).then((outcome) => {
+    return settled.then((outcome) => {
       if (outcome !== 'cancelled') {
         removeSlot(slot)
         publish()

package/src/authorization-panel.ts

@@ -196,8 +196,7 @@ export function ProviderAuthorizationPanel(props: ProviderAuthorizationPanelProp
     if (input !== '' && !key.ctrl && !key.meta) setDraft(current => current + input)
   })
 
-  if (viewport.maxHeight === 0) return createElement(Box, { display: 'none' })
-  if (viewport.compact) {
+  if (viewport.maxHeight === 0 || viewport.compact) {
     return createElement(Text, { wrap: 'truncate-end' }, truncateColumns('provider login · esc cancel', viewport.contentColumns))
   }
 
@@ -271,8 +270,7 @@ export function ProviderAuthorizationLogoutPanel({ row, confirm, done, back }: {
       setError(reason instanceof Error ? reason.message : String(reason))
     })
   })
-  if (viewport.maxHeight === 0) return createElement(Box, { display: 'none' })
-  if (viewport.compact) return createElement(Text, { wrap: 'truncate-end' }, truncateColumns('y logout · n/esc back', viewport.contentColumns))
+  if (viewport.maxHeight === 0 || viewport.compact) return createElement(Text, { wrap: 'truncate-end' }, truncateColumns('y logout · n/esc back', viewport.contentColumns))
   return createElement(
     Box,
     { flexDirection: 'column', width: viewport.outerColumns, paddingX: 1, borderStyle: 'round', borderColor: inkColor(getPalette().warn) },

package/src/commands.ts

@@ -38,16 +38,22 @@ export function watchCommands(ctx: Context): CommandsView {
   let agent: Agent | undefined
   let descriptors: readonly CommandDescriptor[] = []
   let error: string | undefined
+  // The agent whose scoped view the current descriptors were read for: a
+  // failure before this agent ever loaded clears the list instead of keeping
+  // another session's commands completable here.
+  let loadedFor: Agent | undefined
   const listeners = new Set<() => void>()
   const refresh = (): void => {
     if (commands === undefined || agent === undefined) return
     try {
       descriptors = commands.list(agent)
+      loadedFor = agent
       error = undefined
     } catch (cause: unknown) {
-      // Keep the last good catalog, but change its identity so subscribers
-      // can render the recoverable failure in /help.
-      descriptors = [...descriptors]
+      // Keep the last good catalog for the SAME agent, but change its identity
+      // so subscribers can render the recoverable failure in /help; an agent
+      // that never loaded starts from empty.
+      descriptors = loadedFor === agent ? [...descriptors] : []
       error = cause instanceof Error ? cause.message : String(cause)
     }
     for (const listener of listeners) listener()
@@ -83,3 +89,21 @@ export function watchCommands(ctx: Context): CommandsView {
 export function isSlashLine(line: string): boolean {
   return /^\/[a-z][a-z0-9_-]*(?=$|[\t ])/u.test(line)
 }
+
+/**
+ * The submission payload for one composer line. Trim is a blank check, not a
+ * rewrite: an ordinary prompt keeps its exact leading indentation, inner
+ * layout, and trailing spaces (pasted code must reach the model verbatim).
+ * Only trailing line terminators are stripped — a draft's final newline is a
+ * paste/Enter artifact (an open bracketed paste turns Enter into an inserted
+ * newline), never deliberate content. A syntactic slash line still normalizes
+ * fully so command routing stays stable (completion inserts a trailing space
+ * after `/name`).
+ * @param line - the complete draft text.
+ * @returns the text to submit verbatim.
+ */
+export function submissionPayload(line: string): string {
+  const withoutTrailingNewlines = line.replace(/[\r\n]+$/u, '')
+  const trimmed = withoutTrailingNewlines.trim()
+  return isSlashLine(trimmed) ? trimmed : withoutTrailingNewlines
+}

package/src/git-workflow.ts

@@ -1,4 +1,9 @@
-/** Read-only Git inspection used by /diff and /review. */
+/**
+ * Read-only Git inspection used by /diff and /review. Every diff
+ * invocation carries --no-ext-diff and --no-textconv, so configured
+ * external diff drivers and text converters can never execute as a
+ * side effect of reading a diff.
+ */
 
 import { execFile } from 'node:child_process'
 
@@ -36,12 +41,12 @@ export function parseGitDiffFiles(text: string): readonly GitDiffFile[] {
 /** Parse the intentionally small, option-safe /diff argument vocabulary. */
 export function parseGitDiffSpec(argument: string): GitDiffSpec {
   const value = argument.trim()
-  if (value === '') return { label: 'working tree vs HEAD', args: ['diff', '--no-ext-diff', '--unified=3', 'HEAD', '--'] }
+  if (value === '') return { label: 'working tree vs HEAD', args: ['diff', '--no-ext-diff', '--no-textconv', '--unified=3', 'HEAD', '--'] }
   if (value === '--staged' || value === '--cached') {
-    return { label: 'staged changes', args: ['diff', '--no-ext-diff', '--unified=3', '--cached', '--'] }
+    return { label: 'staged changes', args: ['diff', '--no-ext-diff', '--no-textconv', '--unified=3', '--cached', '--'] }
   }
   if (value.startsWith('-') || /\s/u.test(value)) throw new Error('usage: /diff [--staged|git-ref]')
-  return { label: `changes since ${value}`, args: ['diff', '--no-ext-diff', '--unified=3', value, '--'] }
+  return { label: `changes since ${value}`, args: ['diff', '--no-ext-diff', '--no-textconv', '--unified=3', value, '--'] }
 }
 
 function executeGit(cwd: string, args: readonly string[], signal?: AbortSignal): Promise<string> {
@@ -56,8 +61,18 @@ function executeGit(cwd: string, args: readonly string[], signal?: AbortSignal):
   })
 }
 
+/** Arguments for the unstaged-only fallback below. */
+const UNSTAGED_DIFF_ARGS = ['diff', '--no-ext-diff', '--no-textconv', '--unified=3', '--'] as const
+
+/** Whether the repository has at least one commit (a HEAD revision). */
+function hasHeadRevision(cwd: string, signal?: AbortSignal): Promise<boolean> {
+  return executeGit(cwd, ['rev-parse', '--verify', '--quiet', 'HEAD'], signal)
+    .then(() => true)
+    .catch(() => false)
+}
+
 /**
- * Load one complete textual diff without invoking external diff drivers.
+ * Load one complete textual diff without invoking external programs.
  * @param signal - aborted by the caller on session switches/quit, killing the
  * git subprocess instead of letting a stale repository's diff land later.
  */
@@ -67,11 +82,15 @@ export async function loadGitDiff(cwd: string, argument: string, signal?: AbortS
     const text = await executeGit(cwd, spec.args, signal)
     return { title: `git diff - ${spec.label}`, files: parseGitDiffFiles(text) }
   } catch (error: unknown) {
-    // An unborn repository has no HEAD. Preserve useful unstaged output for
-    // the default form while still surfacing all other Git failures.
-    if (argument.trim() !== '') throw error
-    const text = await executeGit(cwd, ['diff', '--no-ext-diff', '--unified=3', '--'], signal)
-    return { title: 'git diff - working tree', files: parseGitDiffFiles(text) }
+    // Only a repository without commits (no HEAD to diff against) may
+    // narrow the default form to the unstaged fallback. Every other
+    // failure — output past the buffer limit, a corrupt index, a missing
+    // repository, or the caller aborting between the two calls — must
+    // surface, not silently shrink what /diff and /review end up seeing
+    // (an aborted probe would otherwise masquerade as an unborn repo).
+    if (argument.trim() !== '' || signal?.aborted === true || (await hasHeadRevision(cwd, signal))) throw error
+    const text = await executeGit(cwd, UNSTAGED_DIFF_ARGS, signal)
+    return { title: 'git diff - working tree (no commits yet)', files: parseGitDiffFiles(text) }
   }
 }
 

package/src/history.ts

@@ -42,16 +42,25 @@ export function parseHistoryFile(raw: string, max = HISTORY_MAX_ENTRIES): readon
 }
 
 /**
- * Append one entry to the persistent file content: JSON line, capped to the
- * newest `max` entries with a trailing newline.
- * @param current - existing file content.
- * @param text - submission to persist.
- * @param max - entry cap.
- * @returns the new file content.
+ * The append unit for the persistent file: one JSON line, so a multi-line
+ * draft still occupies exactly one physical line. Each submission appends
+ * this unit at the end of the file, so concurrent terminals add entries
+ * after each other. Node chunks one append at 512 KiB: a pasted entry
+ * beyond that size could interleave mid-line with another writer's
+ * chunks, and the damaged line then drops out at the next parse —
+ * recall tolerates the loss by design.
  */
-export function appendHistoryContent(current: string, text: string, max = HISTORY_MAX_ENTRIES): string {
-  const entries = [...parseHistoryFile(current, max), text].slice(-max)
-  return entries.map(serializeHistoryEntry).join('\n') + '\n'
+export function historyLine(text: string): string {
+  return serializeHistoryEntry(text) + '\n'
+}
+
+/**
+ * Whether the file on disk differs from its canonical form (deduped and
+ * capped). True means stale lines have accumulated and the next boot
+ * should rewrite it once, atomically.
+ */
+export function needsCompaction(raw: string, max = HISTORY_MAX_ENTRIES): boolean {
+  return serializeHistoryList(parseHistoryFile(raw, max)) !== raw
 }
 
 /**
@@ -70,10 +79,10 @@ export function recordLocalEntry(local: readonly string[], text: string, max = H
 }
 
 /**
- * Serialize a capped entry list to the history file format (one JSON line per
- * entry, trailing newline). The runner writes the in-memory list as the whole
- * file, so rapid same-process submissions cannot lose entries to a
- * read-modify-write race (the file is never read back before writing).
+ * Serialize a capped entry list to the history file format (one JSON line
+ * per entry, trailing newline). The boot-time compaction writes this
+ * canonical form once when stale lines have accumulated; submissions
+ * themselves only ever append a single line.
  * @param entries - the entries to persist, oldest first.
  * @returns the file content, '' for an empty list.
  */