dsh-coding-sidebar 1.0.6 → 1.0.8

package/src/client/selection-popup.ts

@@ -0,0 +1,155 @@
+/**
+ * The floating "add selection to conversation" popup shared by the text
+ * viewer: a viewport-anchored button portaled to `document.body`, kept alive
+ * across the selection gesture and committed on click.
+ *
+ * Dismissal contract (upstream issue #425): the popup must never outlive its
+ * editor surface. The sidebar keeps every tab MOUNTED — switching tabs only
+ * flips the pane cell to `display:none` and collapsing the panel translates
+ * it off-screen — while the portaled `position:fixed` button stays pinned to
+ * its viewport anchor, ignoring both. The caller already hides on surface
+ * scrolls, selection collapse and content swaps; this hook adds the global
+ * dismissal that covers everything else:
+ *
+ * - any `mousedown` outside the button (tab bar, composer, another pane,
+ *   the collapse toggle, …) closes it;
+ * - `Escape` closes it;
+ * - the document going hidden (`visibilitychange`) or the window losing
+ *   focus closes it;
+ * - an `IntersectionObserver` on the editor surface closes it as soon as the
+ *   surface leaves the viewport — the tab-switch (`display:none`) and
+ *   panel-collapse (translated off-screen) paths have no DOM events of their
+ *   own, so the geometry signal is the only reliable one.
+ *
+ * The button's own `mousedown` is never treated as an outside click: the
+ * caller preventDefaults it to keep the selection/caret alive until the
+ * click commits (the hook's capture-phase listener runs first and must not
+ * hide for it).
+ */
+import { useEffect, useRef, useState, type RefObject } from 'react'
+
+/** The floating "add to conversation" action: payload + viewport anchor. */
+export interface SelectionPopup {
+  insert: string
+  left: number
+  top: number
+}
+
+export interface SelectionPopupOptions {
+  /** Commit the payload into the composer draft (button click). */
+  onCommit(insert: string): void
+  /**
+   * The DOM surface that must stay on screen for the popup to live: the
+   * CodeMirror host element. Called lazily (refs are null until the content
+   * loads).
+   */
+  getSurface(): HTMLElement | null
+}
+
+export interface SelectionPopupControls {
+  /** The current popup (null = hidden). */
+  popup: SelectionPopup | null
+  /** Attach to the portaled button element. */
+  buttonRef: RefObject<HTMLButtonElement>
+  /** Anchor the popup above a selection (viewport-clamped). */
+  show(insert: string, left: number, top: number): void
+  /** Hide the popup (idempotent). */
+  hide(): void
+  /** The button's click: commit the stored payload, then hide. */
+  commit(): void
+}
+
+export function useSelectionPopup(options: SelectionPopupOptions): SelectionPopupControls {
+  // Latest-callback refs: the dismissal listeners live for the mount's
+  // lifetime, so they must not capture stale closures across renders.
+  const onCommitRef = useRef(options.onCommit)
+  const getSurfaceRef = useRef(options.getSurface)
+  onCommitRef.current = options.onCommit
+  getSurfaceRef.current = options.getSurface
+
+  const [popup, setPopup] = useState<SelectionPopup | null>(null)
+  /** Live mirror for click/event-time reads (no re-render race). */
+  const popupRef = useRef<SelectionPopup | null>(null)
+  /** The portaled button itself (for the outside-click guard). */
+  const buttonRef = useRef<HTMLButtonElement>(null)
+  /** The surface visibility observer (created lazily on open). */
+  const observerRef = useRef<IntersectionObserver | null>(null)
+
+  const show = (insert: string, left: number, top: number): void => {
+    const next: SelectionPopup = {
+      insert,
+      left: Math.min(Math.max(left, 80), window.innerWidth - 80),
+      top,
+    }
+    popupRef.current = next
+    setPopup(next)
+  }
+
+  const hide = (): void => {
+    popupRef.current = null
+    setPopup(null)
+  }
+
+  const commit = (): void => {
+    const current = popupRef.current
+    if (current === null) return
+    onCommitRef.current(current.insert)
+    hide()
+  }
+
+  // Global dismissal listeners, registered once; every handler reads the
+  // live popup ref so it no-ops while no popup is open.
+  useEffect(() => {
+    const onMouseDown = (event: MouseEvent): void => {
+      if (popupRef.current === null) return
+      const button = buttonRef.current
+      if (button !== null && (button === event.target || button.contains(event.target as Node))) return
+      hide()
+    }
+    const onKeyDown = (event: KeyboardEvent): void => {
+      if (event.key === 'Escape' && popupRef.current !== null) hide()
+    }
+    const onVisibilityChange = (): void => {
+      if (document.hidden && popupRef.current !== null) hide()
+    }
+    const onWindowBlur = (): void => {
+      if (popupRef.current !== null) hide()
+    }
+    document.addEventListener('mousedown', onMouseDown, true)
+    document.addEventListener('keydown', onKeyDown, true)
+    document.addEventListener('visibilitychange', onVisibilityChange)
+    window.addEventListener('blur', onWindowBlur)
+    return () => {
+      document.removeEventListener('mousedown', onMouseDown, true)
+      document.removeEventListener('keydown', onKeyDown, true)
+      document.removeEventListener('visibilitychange', onVisibilityChange)
+      window.removeEventListener('blur', onWindowBlur)
+      observerRef.current?.disconnect()
+      observerRef.current = null
+    }
+  }, [])
+
+  // Re-target the visibility observer whenever a popup opens: the surface
+  // refs may have been null at mount (content loads async), so the surface
+  // is only trustworthy at open time.
+  useEffect(() => {
+    if (popup === null) return
+    observerRef.current?.disconnect()
+    observerRef.current = null
+    if (typeof IntersectionObserver === 'undefined') return
+    const surface = getSurfaceRef.current()
+    if (surface === null) return
+    const observer = new IntersectionObserver((entries) => {
+      for (const entry of entries) {
+        if (!entry.isIntersecting) hide()
+      }
+    }, { threshold: 0 })
+    observerRef.current = observer
+    observer.observe(surface)
+    // eslint-disable-next-line react-hooks/exhaustive-deps -- the boolean
+    // flip is the only thing that must re-run this; an anchor move while
+    // open keeps the same surface.
+  }, [popup !== null])
+
+  return { popup, buttonRef, show, hide, commit }
+}

package/src/client/service.ts

@@ -150,7 +150,7 @@ export interface TabComponentProps {
   /** The explorer's reveal-highlight set (ExplorerView; "Show in folder" targets). */
   revealed?: string[]
   onToggleDir?: (path: string) => void
-  onReferenceFile?: (path: string) => void
+  onReferenceFile?: (path: string, isDir: boolean) => void
   onOpenFile?: (path: string) => void
   onOpenDiff?: (tab: SidebarTab) => void
   onSubagentJump?: (childSessionId: string) => void

package/src/client/state.ts

@@ -137,7 +137,7 @@ export function mintTabId(): string {
 
 /**
  * The largest numeric suffix across a raw persisted state's counter ids
- * (`pane:N` / `tab:N` / `split:N`). The uid counter is module-global and
+ * (`pane:N` / `tab:N` / `split:N` / `float:N`). The uid counter is module-global and
  * resets on every reload, so a split minted AFTER a reload would collide
  * with the persisted ids (a fresh "pane:1" beside the persisted "pane:1");
  * mapLeaf would then visit BOTH leaves and every open would land in both
@@ -148,7 +148,7 @@ function maxCounterId(parsed: unknown): number {
   let max = 0
   const consider = (id: unknown): void => {
     if (typeof id !== 'string') return
-    const match = /^(?:pane|tab|split):(\d+)$/.exec(id)
+    const match = /^(?:pane|tab|split|float):(\d+)$/.exec(id)
     if (match !== null) max = Math.max(max, Number(match[1]))
   }
   const walk = (node: unknown): void => {
@@ -994,6 +994,7 @@ function resetRequested(): boolean {
 
 function loadState(sessionId: string, prefs: SidebarPrefs): SidebarState {
   const reset = resetRequested()
+  const viewport = typeof window !== 'undefined' ? window.innerWidth : undefined
   if (reset) {
     try {
       localStorage.removeItem(`${STORAGE_PREFIX}:${sessionId}`)
@@ -1016,7 +1017,15 @@ function loadState(sessionId: string, prefs: SidebarPrefs): SidebarState {
         nextIdCounter = maxCounterId(parsed)
         const sanitized = sanitizeState(parsed)
         if (sanitized !== undefined) {
-          return globalWidth === undefined ? sanitized : { ...sanitized, width: globalWidth }
+          const restored = globalWidth === undefined ? sanitized : { ...sanitized, width: globalWidth }
+          // A narrow panel is a full-screen drawer, so every page/session load
+          // starts it closed even when the prior desktop/mobile state persisted
+          // `panelOpen: true`. Preserve the entire restored workbench (panes,
+          // tabs, and free windows); visibility is the sole viewport-derived
+          // override.
+          return viewport !== undefined && isNarrowWidth(viewport) && restored.panelOpen
+            ? { ...restored, panelOpen: false }
+            : restored
         }
       }
     } catch {
@@ -1031,10 +1040,8 @@ function loadState(sessionId: string, prefs: SidebarPrefs): SidebarState {
   // disabled editor type seeds nothing. On a NARROW viewport a brand-new
   // session starts collapsed instead — the panel is a full-screen drawer
   // there, and auto-opening it on first paint would cover the conversation
-  // before the user asked. Only the first seeding is affected: once the
-  // user expands the drawer, `panelOpen: true` persists like any other
-  // state.
-  const viewport = typeof window !== 'undefined' ? window.innerWidth : undefined
+  // before the user asked. Persisted layouts follow the same narrow-load
+  // visibility rule above, while their workbench contents remain intact.
   const width = globalWidth ?? (viewport === undefined
     ? PANEL_DEFAULT
     : defaultWidthFor(viewport, prefs.defaultWidthPercent))

package/src/client/terminal-font.ts

@@ -198,12 +198,43 @@ function usableBase(value: string | undefined): string {
   return trimmed
 }
 
+/**
+ * Guarantee the stack ends in a generic family, so a font the browser cannot
+ * resolve degrades to a monospace one.
+ *
+ * Without this a stack of unresolvable names (a misspelled family, or one only
+ * installed on the machine running the shell rather than the one running the
+ * browser) falls through to the browser's *standard* font, which is
+ * proportional — xterm then measures its cell from a proportional advance and
+ * the whole grid breaks, rather than merely losing the requested typeface.
+ *
+ * This does not sniff whether the named families exist (an explicit non-goal
+ * of the terminal font design): it only terminates the stack. A stack that
+ * already names a generic family is returned untouched, so a user who
+ * deliberately wrote one keeps it. Generics are matched unquoted only — a
+ * quoted `"monospace"` is a family *name*, not the keyword.
+ *
+ * @param stack - the resolved font-family value.
+ * @returns the stack, ending in a generic family.
+ */
+export function withMonospaceFallback(stack: string): string {
+  const families = splitFamilies(stack)
+  if (families.length === 0) return DEFAULT_TERMINAL_FONT_FAMILY
+  const only = families.length === 1 ? families[0] : undefined
+  if (only !== undefined && CSS_WIDE_KEYWORDS.has(only.toLowerCase())) return DEFAULT_TERMINAL_FONT_FAMILY
+  if (families.some((family) => GENERIC_FAMILIES.has(family.toLowerCase()))) return families.join(', ')
+  return `${families.join(', ')}, monospace`
+}
+
 /**
  * Resolve the xterm font options for the given prefs.
  *
  * The base family keeps its existing precedence — user pref > theme code
- * font > built-in stack — and then {@link withIconFontFallbacks} tops it up
- * so prompt icons resolve regardless of which base won.
+ * font > built-in stack. {@link withMonospaceFallback} then terminates the
+ * stack with a generic family so an unresolvable name degrades to a
+ * monospace instead of the proportional standard font, and finally
+ * {@link withIconFontFallbacks} tops it up so prompt icons resolve
+ * regardless of which base won.
  *
  * @param prefs - the current side card preferences.
  * @param themeFontFamily - the app's theme code font (`--ds-font-family-code`
@@ -218,7 +249,7 @@ export function resolveTerminalFont(
     || usableBase(themeFontFamily)
     || DEFAULT_TERMINAL_FONT_FAMILY
   return {
-    fontFamily: withIconFontFallbacks(base),
+    fontFamily: withIconFontFallbacks(withMonospaceFallback(base)),
     fontSize: clampTerminalFontSize(prefs.terminalFontSize),
   }
 }

package/src/context-types.ts

@@ -428,9 +428,10 @@ export interface SidebarLocaleService {
 
 /** The composer draft face the sidebar reaches through `ctx.conversation.input`. */
 export interface SidebarSessionInput {
-  /** The live input store (draft read for append). */
+  /** The live input store (draft read for append). `draftRev` is the machine's
+   *  span-CAS revision — required to mint a structured file-reference chip. */
   state: {
-    getSnapshot(): { draft: string }
+    getSnapshot(): { draft: string; draftRev?: number }
   }
   /** Replace the draft text (the input machine's single public write path). */
   setDraft(text: string): void

package/src/git.ts

@@ -323,11 +323,27 @@ function pathIdentity(path: string): string {
   return process.platform === 'win32' ? absolute.toLowerCase() : absolute
 }
 
+/** Whether the current Git binary supports NUL-framed `worktree list` output.
+ * Git < 2.36 rejects `-z`; cache the capability after the first attempt so
+ * the SCM panel's polling does not repeatedly spawn a command known to fail. */
+let worktreeListSupportsZ: boolean | undefined
+
 /** Raw usable checkout records, shared by inventory and target validation.
  * Prunable records point at missing paths and are deliberately excluded from
  * both the selector and the command-target allowlist. */
 async function listedWorktrees(cwd: string): Promise<GitWorktreeRecord[]> {
-  const raw = await runGit(cwd, ['worktree', 'list', '--porcelain', '-z'])
+  let raw: string
+  if (worktreeListSupportsZ === false) {
+    raw = await runGit(cwd, ['worktree', 'list', '--porcelain'])
+  } else {
+    try {
+      raw = await runGit(cwd, ['worktree', 'list', '--porcelain', '-z'])
+      worktreeListSupportsZ = true
+    } catch {
+      worktreeListSupportsZ = false
+      raw = await runGit(cwd, ['worktree', 'list', '--porcelain'])
+    }
+  }
   return parseWorktreeList(raw).filter(entry => !entry.prunable)
 }
 

package/src/index.ts

@@ -40,7 +40,7 @@ import { launchExternal } from './open-external.ts'
 import * as git from './git.ts'
 import { SettingsConflictError, type SettingsNamespace } from '@deepseek-ai/dsh-settings'
 import { defaultShell, ensureSpawnHelper, PtyManager, shellDisplayName } from './pty-manager.ts'
-import { AgentPtyRegistry, clampDims, type AgentTerminalHandle } from './agent-pty.ts'
+import { AgentPtyRegistry, armPtyResizeGate, tryResizePty, type AgentTerminalHandle } from './agent-pty.ts'
 import {
   DSH_NODE_PTY_RANGE,
   depsStatus,
@@ -1036,6 +1036,38 @@ async function attachAgentList(
   }
 }
 
+/**
+ * The WS close reason for a failed terminal attach. A missing configured
+ * shell gets a SHORT machine-readable marker (`shell-not-found:<name>`,
+ * capped by BYTES — a WS close reason allows at most 123 bytes, which `ws`
+ * validates with `Buffer.byteLength`) that the client maps to a localized,
+ * actionable banner; every other failure keeps the raw message (the
+ * model-side tool errors read it verbatim).
+ */
+export function wsCloseReasonOf(error: unknown): string {
+  if (error instanceof SidebarError && error.code === 'shell-not-found') {
+    const name = truncateUtf8Bytes(shellDisplayName(String(error.meta?.shell ?? '')), 100)
+    return `shell-not-found:${name}`
+  }
+  return error instanceof Error ? error.message : String(error)
+}
+
+/**
+ * Truncate to at most `maxBytes` UTF-8 bytes without splitting a code point.
+ * A character-count `slice` does not bound the WS close reason: `ws` measures
+ * `Buffer.byteLength` against its 123-byte cap, and the resulting throw would
+ * replace the very error the reason describes.
+ */
+function truncateUtf8Bytes(value: string, maxBytes: number): string {
+  if (Buffer.byteLength(value) <= maxBytes) return value
+  let truncated = ''
+  for (const character of value) {
+    if (Buffer.byteLength(truncated + character) > maxBytes) break
+    truncated += character
+  }
+  return truncated
+}
+
 /**
  * Wire one terminal socket to its pty: replay transcript, pump both ways.
  * Two attach modes share the wire protocol:
@@ -1097,6 +1129,9 @@ async function attachTerminal(
     // terminals opened from now on (existing pty handles keep their shell).
     const overrides = shellOverridesOf(getSettings)
     const handle = ptyManager.open(sessionId, tabId, cwd, 80, 24, overrides.shell, overrides.shellArgs)
+    // Windows pre-ready gate for the resize frames this socket may deliver
+    // (see armPtyResizeGate; inert on POSIX).
+    armPtyResizeGate(handle.pty)
     // Replay the transcript, then follow live output.
     if (handle.transcript !== '') ws.send(handle.transcript)
     const onData = (data: string): void => {
@@ -1143,8 +1178,7 @@ async function attachTerminal(
         && control.type === 'resize'
         && typeof control.cols === 'number' && typeof control.rows === 'number'
       ) {
-        const dims = clampDims(control.cols, control.rows)
-        handle.pty.resize(dims.cols, dims.rows)
+        tryResizePty(handle.pty, control.cols, control.rows)
       } else {
         handle.pty.write(text)
       }
@@ -1162,7 +1196,7 @@ async function attachTerminal(
       }
     })
   } catch (error) {
-    ws.close(1011, error instanceof Error ? error.message : String(error))
+    ws.close(1011, wsCloseReasonOf(error))
   }
 }
 
@@ -1212,8 +1246,7 @@ function pumpAgentTerminal(
       && control.type === 'resize'
       && typeof control.cols === 'number' && typeof control.rows === 'number'
     ) {
-      const dims = clampDims(control.cols, control.rows)
-      handle.pty.resize(dims.cols, dims.rows)
+      tryResizePty(handle.pty, control.cols, control.rows)
     } else if (control === null) {
       // Raw text input (a JSON-looking string the pty would have received
       // verbatim is reachable in theory but is exotic for an agent terminal;

package/src/open-external.ts

@@ -28,11 +28,10 @@ export function revealCommand(path: string, platform: NodeJS.Platform = process.
   switch (platform) {
     case 'darwin':
       return { command: 'open', args: ['-R', path] }
-    // `explorer /select,<path>` — the classic "show in folder" incantation.
-    // Passed as separate argv entries (no shell); verify on Windows, with
-    // `cmd /c start "" explorer.exe "/select,<path>"` as the fallback.
+    // Explorer expects `/select,<path>` as one argument. Keep the spawn
+    // shell-free: a command shell would reinterpret valid path characters.
     case 'win32':
-      return { command: 'explorer.exe', args: ['/select,', path] }
+      return { command: 'explorer.exe', args: [`/select,${path}`] }
     default: {
       const parent = parentOf(path)
       return { command: 'xdg-open', args: [parent ?? path] }

package/src/prefs-shared.ts

@@ -16,14 +16,16 @@ export interface SidebarPrefs {
   /** Default panel width as a percent of the window width (20–60). */
   defaultWidthPercent: number
   /**
-   * Whether the sidebar auto-activates (opens the panel) and expands the
-   * Subagent page when the current conversation spawns a new subagent.
+   * Whether the sidebar auto-activates the Subagent page when the current
+   * conversation spawns a new subagent. Wide viewports also open the panel;
+   * narrow viewports prepare the tab without opening the full-screen drawer.
    */
   autoOpenSubagent: boolean
   /**
-   * Whether the sidebar auto-activates (opens the panel) and expands the
-   * Jobs page when a NEW background job appears for the current
-   * conversation (any new job id, not just the first one).
+   * Whether the sidebar auto-activates the Jobs page when a NEW background
+   * job appears for the current conversation (any new job id, not just the
+   * first one). Wide viewports also open the panel; narrow viewports prepare
+   * the tab without opening the full-screen drawer.
    */
   autoOpenJobs: boolean
   /**