dsh-code 1.0.4 → 1.0.6

package/src/attachments.ts

@@ -1,10 +1,10 @@
-/** Terminal image-file adapter over the Harness durable attachment service. */
+/** Terminal image- and file-attachment adapter over the Harness durable attachment service. */
 
 import { open, readFile, stat } from 'node:fs/promises'
 import { fileURLToPath } from 'node:url'
 import { basename, extname, isAbsolute, resolve } from 'node:path'
-import type { AttachmentStore, ImageMediaType, SaveImageAttachment } from '@deepseek-ai/dsh-attachment'
-import type { ImageBlock } from '@deepseek-ai/dsh-llm'
+import type { AttachmentStore, ImageMediaType, SaveFileAttachment, SaveImageAttachment } from '@deepseek-ai/dsh-attachment'
+import type { FileBlock, ImageBlock } from '@deepseek-ai/dsh-llm'
 
 /** A validated path retained in the editor until submission persists it. */
 export interface ImagePathInspection {
@@ -14,6 +14,22 @@ export interface ImagePathInspection {
   readonly bytes: number
 }
 
+/** A validated non-image file path retained the same way (0.1.5 file blocks). */
+export interface FilePathInspection {
+  readonly path: string
+  readonly name: string
+  readonly bytes: number
+}
+
+/**
+ * Terminal-side file admission bounds. Upstream exposes image limits through
+ * the attachment service but no file limits (files ride verbatim storage);
+ * these keep a dragged file from silently ingesting a disk-sized blob and
+ * bound one message the way the image batch is bounded.
+ */
+export const MAX_FILE_BYTES = 8 * 1024 * 1024
+export const MAX_FILES_PER_MESSAGE = 8
+
 const IMAGE_EXTENSIONS = new Set(['.png', '.jpg', '.jpeg', '.webp', '.gif'])
 
 /** Detect the supported encoded raster formats from bytes, never from a path suffix. */
@@ -36,11 +52,27 @@ export function looksLikeImagePath(path: string): boolean {
   return IMAGE_EXTENSIONS.has(extname(path).toLowerCase())
 }
 
-/** Parse a terminal paste/drop containing only one or more image paths. */
-export function parsePastedImagePaths(input: string): readonly string[] {
+/**
+ * Parse a paste/drop into its image and file paths: image-suffixed tokens
+ * stay images, other path-shaped tokens ride as file attachments (0.1.5
+ * file blocks), and anything that is neither leaves both empty — the caller
+ * then treats the paste as plain text.
+ *
+ * File tokens are held to an absolute-path-with-shape bar (drive/backslash
+ * or a dot-suffixed leaf after a separator): a dropped terminal path always
+ * carries one of those, while prose, slash commands, and option flags never
+ * do. A POSIX absolute path without any dot-suffixed leaf falls through as
+ * text — the @ mention route still attaches such files deliberately.
+ */
+export function parsePastedAttachmentPaths(input: string): { readonly images: readonly string[]; readonly files: readonly string[] } {
   const text = input.trim()
-  if (text === '') return []
-  const tokens: string[] = []
+  if (text === '') return { images: [], files: [] }
+  const images: string[] = []
+  const files: string[] = []
+  const looksLikeDroppedFile = (path: string): boolean =>
+    /^[A-Za-z]:[\\/]/u.test(path)
+    || /^\\\\/u.test(path)
+    || (/^\/|^\.\.?\//u.test(path) && /\.[A-Za-z0-9]{1,16}$/u.test(path))
   const matcher = /"([^"]+)"|'([^']+)'|(\S+)/gu
   for (const match of text.matchAll(matcher)) {
     const token = match[1] ?? match[2] ?? match[3]
@@ -50,13 +82,20 @@ export function parsePastedImagePaths(input: string): readonly string[] {
       try {
         path = fileURLToPath(path)
       } catch {
-        return []
+        return { images: [], files: [] }
       }
+      if (looksLikeImagePath(path)) images.push(path)
+      else files.push(path)
+      continue
     }
-    if (!looksLikeImagePath(path)) return []
-    tokens.push(path)
+    if (looksLikeImagePath(path)) {
+      images.push(path)
+      continue
+    }
+    if (!looksLikeDroppedFile(path)) return { images: [], files: [] }
+    files.push(path)
   }
-  return tokens
+  return { images, files }
 }
 
 /** Validate path, byte size and encoded signature without writing an attachment object. */
@@ -133,3 +172,63 @@ export async function saveImagePaths(
   checkCancelled()
   return refs.map(attachment => ({ type: 'image', attachment }))
 }
+
+/** Validate path and byte size for non-image file attachments without writing. */
+export async function inspectFilePaths(
+  paths: readonly string[],
+  attachments: AttachmentStore | undefined,
+  cwd = process.cwd(),
+): Promise<readonly FilePathInspection[]> {
+  if (paths.length === 0) return []
+  if (attachments === undefined) throw new Error('file attachments are unavailable in this profile')
+  if (paths.length > MAX_FILES_PER_MESSAGE) {
+    throw new Error(`too many files (${paths.length}; limit ${MAX_FILES_PER_MESSAGE})`)
+  }
+  const inspected: FilePathInspection[] = []
+  for (const raw of paths) {
+    const path = isAbsolute(raw) ? resolve(raw) : resolve(cwd, raw)
+    let facts: Awaited<ReturnType<typeof stat>>
+    try {
+      facts = await stat(path)
+    } catch (error: unknown) {
+      throw new Error(`cannot read file "${raw}": ${error instanceof Error ? error.message : String(error)}`)
+    }
+    if (!facts.isFile()) throw new Error(`file path is not a file: "${raw}"`)
+    if (facts.size > MAX_FILE_BYTES) {
+      throw new Error(`file "${basename(path)}" is ${facts.size} bytes; limit ${MAX_FILE_BYTES}`)
+    }
+    inspected.push({ path, name: basename(path), bytes: facts.size })
+  }
+  return inspected
+}
+
+/** Read and persist an ordered non-image file path list as model file blocks. */
+export async function saveFilePaths(
+  paths: readonly string[],
+  attachments: AttachmentStore | undefined,
+  signal?: AbortSignal,
+): Promise<readonly FileBlock[]> {
+  if (paths.length === 0) return []
+  if (attachments === undefined) throw new Error('file attachments are unavailable in this profile')
+  // The bounds are re-checked here so a draft inspected earlier still guards
+  // the actual read at submission time.
+  await inspectFilePaths(paths, attachments)
+  const checkCancelled = (): void => {
+    if (signal?.aborted === true) throw new Error('file submission cancelled')
+  }
+  const inputs: SaveFileAttachment[] = []
+  for (const path of paths) {
+    checkCancelled()
+    let data: Uint8Array
+    try {
+      data = await readFile(path)
+    } catch (error: unknown) {
+      throw new Error(`cannot read file "${path}": ${error instanceof Error ? error.message : String(error)}`)
+    }
+    inputs.push({ data, name: basename(path) })
+  }
+  checkCancelled()
+  const refs = await Promise.all(inputs.map(input => attachments.saveFile(input)))
+  checkCancelled()
+  return refs.map(attachment => ({ type: 'file', attachment }))
+}

package/src/commands.ts

@@ -43,20 +43,50 @@ export function watchCommands(ctx: Context): CommandsView {
   // another session's commands completable here.
   let loadedFor: Agent | undefined
   const listeners = new Set<() => void>()
+  // Content gate: the host registry allocates a fresh array on every list()
+  // call and 0.1.5 emits commands/change for every scoped register AND
+  // dispose (a startup registration wave lands inside React's commit
+  // windows). A fresh identity per event chains nested passive updates past
+  // React's 50-deep limit ("Maximum update depth exceeded"), so an unchanged
+  // catalog keeps the previous array identity and notifies nobody — the same
+  // discipline the skills gate and the store's frame throttle established.
+  const descriptorFingerprint = (list: readonly CommandDescriptor[]): string =>
+    JSON.stringify(list.map(descriptor => [descriptor.name, descriptor.description, descriptor.input?.hint ?? '', descriptor.input?.attachments === true]))
+  let lastFingerprint = '[]'
+  let lastNotifiedError: string | undefined
+  const changed = (next: readonly CommandDescriptor[], nextError: string | undefined): boolean =>
+    descriptorFingerprint(next) !== lastFingerprint || nextError !== lastNotifiedError
+  // Frame throttle: coalesce a same-tick event storm into one notification
+  // (the transcript store's NOTIFY_FRAME_MS contract).
+  let notifyScheduled = false
+  const notify = (): void => {
+    if (notifyScheduled) return
+    notifyScheduled = true
+    setImmediate(() => {
+      notifyScheduled = false
+      for (const listener of listeners) listener()
+    })
+  }
   const refresh = (): void => {
     if (commands === undefined || agent === undefined) return
+    let next: readonly CommandDescriptor[]
+    let nextError: string | undefined
     try {
-      descriptors = commands.list(agent)
+      next = commands.list(agent)
       loadedFor = agent
-      error = undefined
     } catch (cause: unknown) {
       // 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)
+      next = loadedFor === agent ? [...descriptors] : []
+      nextError = cause instanceof Error ? cause.message : String(cause)
     }
-    for (const listener of listeners) listener()
+    if (!changed(next, nextError)) return
+    descriptors = next
+    error = nextError
+    lastFingerprint = descriptorFingerprint(next)
+    lastNotifiedError = nextError
+    notify()
   }
   if (commands !== undefined) {
     ctx.on('commands/change', () => refresh())

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.
  */