@askdkc/dsh-cli 0.11.3

package/lib/types/dsh-adapter/index.d.ts

@@ -0,0 +1,151 @@
+/**
+ * dsh-tui plugin entry. The TUI implementation lives in `./plugin.tsx` (its
+ * render path is JSX); this module owns the plugin surface (`name`/`inject`/
+ * `Config`/`apply`) at the package entry module and delegates
+ * `apply` through a dynamic import so entry-scanning tooling and the Loader
+ * resolve a plain `.ts` module.
+ * @module dsh-cli
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import Schema from '@deepseek-ai/schemastery';
+import type { SessionModeSpec } from '../sessionModes.js';
+import { type PageMarginSetting, type ScrollGutterMode, type StatusBarConfig, type ToolBackground } from '../tuiDisplayPrefs.js';
+import { type ShortcutActionId } from '../utils/keymap.js';
+import { type RuntimeConfig } from './compat/settings.js';
+export declare const name = "dsh-tui";
+export declare const inject: string[];
+/**
+ * dsh-tui plugin configuration: session attachment, model route, working
+ * directory, and display preferences.
+ */
+export interface Config {
+    /** Existing session to attach; a fresh session is created when absent. */
+    sessionId?: string;
+    /** LLM provider route. The route resolves atomically (issue #67): when
+     *  cordis.yml names BOTH `provider` and `model`, that pair wins; otherwise
+     *  the `/model` choice persisted in `~/.dsh-tui/model.json` wins whole;
+     *  otherwise `agentDefaultModel` supplies the provider-neutral Harness
+     *  default. A bare embedder without that service falls back to DeepSeek.
+     *  A provider-only pin never half-overrides the persisted choice. */
+    provider?: string;
+    /** Model override passed to the agent; resolved together with `provider`
+     *  as one atomic route (see `provider`). */
+    model?: string;
+    /** Session working directory. When absent, the git worktree root
+     *  containing the invoking directory wins (the invoking directory itself
+     *  outside any worktree) — never a bare launch subdirectory (issue #96). */
+    cwd?: string;
+    /** Absolute local path, file URL, or provider URI resolved before the
+     *  initial agent is created. */
+    workspace?: string;
+    /** Reasoning effort applied to every request, validated against the live
+     *  route's adapter levels (an unlisted level is ignored and the adapter
+     *  default applies). Wins over the persisted /effort choice; also seeds
+     *  the startup status line until the first request header reports the
+     *  live value. */
+    effort?: string;
+    /** Settings default for future sessions; overrides the `effort` fallback. */
+    effortDefault?: string;
+    /** Show the header whale and its idle animation. */
+    whale?: boolean;
+    whaleIdle?: boolean;
+    /** Reduce decorative header content and colors. */
+    minimal?: boolean;
+    /** Show the live working line derived in-process from base session events. */
+    activity?: boolean;
+    /** Working-activity indicator preset (`moon8`/`moon`/`comet`/`dots`/…
+     *  or `random`; see activityFrames.ts). When absent, the `/activity`
+     *  choice persisted in `~/.dsh-tui/working-activity.json` wins, then the
+     *  `moon8` default. */
+    activityFrames?: string;
+    /** Show the segmented context bar (the band under the input with the
+     *  `ctx used/window` readout) in the status footer; off hides that row
+     *  while the status/mode lines stay (issue #29). */
+    contextBar?: boolean;
+    /** Run in the terminal's alternate screen (full-screen terminal layout).
+     *  Defaults to true — the fullscreen surface is the more complete one
+     *  (mouse, timeline rail, scrollbar gutter, selection copy), so fresh
+     *  installs start there; cordis.yml `fullscreen: false` or a /settings
+     *  toggle opts back into the inline main-screen layout. */
+    fullscreen?: boolean;
+    /** Allow terminal image previews when supported (default true). Saved
+     *  /settings choices override this value after restart. The environment
+     *  override DSH_TUI_DISABLE_TERMINAL_IMAGES can always force previews off. */
+    terminalImages?: boolean;
+    /** UI language: `en` / `zh`. When absent, the `DSH_TUI_LANG` env var wins,
+     *  then the `/lang` choice persisted in `~/.dsh-tui/lang.json`, then `zh`. */
+    lang?: string;
+    /** Agent preset id new sessions compose from (standard/ptc/minimal/
+     *  cordis/… when the roster is mounted). When absent, the `/preset` choice
+     *  persisted in `~/.dsh-tui/agent-preset.json` wins, then the roster
+     *  default (`standard`). */
+    preset?: string;
+    /** Edit/Write diff presentation: `auto` picks side-by-side on wide
+     *  terminals (≥110 cols) and unified below; `split`/`unified` force one
+     *  layout. Editable live from the `/settings` screen. */
+    diffLayout?: 'auto' | 'split' | 'unified';
+    /** Thinking-block display: `preview` (default) streams a 2-3 line live
+     *  preview and folds each step when it settles; `full` keeps thinking
+     *  expanded until the whole turn ends. Editable live from `/settings`. */
+    thinkingFold?: 'preview' | 'full';
+    /** Tool-card background strength; defaults to no added background. */
+    toolBackground?: ToolBackground;
+    /** What the fullscreen transcript's right gutter shows (settings
+     *  `dsh-tui.scrollGutter`): `timeline` turn rail (default), `scrollbar`
+     *  proportional thumb, or `hidden`. */
+    scrollGutter?: ScrollGutterMode;
+    /** Root page inset (settings `dsh-tui.pageMargin`): a preset name
+     *  (`none` / `slim` / `normal` (default) / `roomy`) or a custom `NxM`
+     *  spec (columns per side × rows top/bottom) that insets the whole UI
+     *  from the terminal edges. Terminals without their own viewport padding
+     *  (bare WSL, tmux, SSH) otherwise hug the screen border. */
+    pageMargin?: PageMarginSetting;
+    /** Terminal-card header folding (settings `dsh-tui.foldTerminalCommand`):
+     *  `true` collapses a multi-line command title to its first line plus a
+     *  `+N lines` hint; Ctrl+O / clicking the card expands it. Default off —
+     *  the full title keeps rendering. */
+    foldTerminalCommand?: boolean;
+    /** Show the session name as a chip on the prompt top border's right side
+     *  (settings `dsh-tui.promptSessionLabel`); off by default. */
+    promptSessionLabel?: boolean;
+    /** Fullscreen draft editor (settings `dsh-tui.expandEditor`): the ⛶
+     *  affordance in the input row and the expandEditor shortcut (default
+     *  Ctrl+Shift+E) expand the draft into a whole-screen editor. On by
+     *  default; off removes both entry points. */
+    expandEditor?: boolean;
+    /** Smooth streaming reveal (settings `dsh-tui.smoothStreaming`): live
+     *  assistant text, expanded thinking, and tool call bodies paint through
+     *  a ~30fps reveal instead of jumping per provider burst — bursty or
+     *  one-shot deliveries read as an even flow. On by default. */
+    smoothStreaming?: boolean;
+    /** Mermaid diagrams (settings `dsh-tui.mermaidDiagrams`): ```mermaid
+     *  fences in replies render as Unicode box-drawing art — flowcharts,
+     *  sequence/state/class/ER diagrams, pie, mindmap, timeline, gitGraph —
+     *  laid out in-process, no browser or image protocol. A diagram wider
+     *  than the viewport or of an unsupported type keeps the fenced source.
+     *  On by default; off always shows the source. */
+    mermaidDiagrams?: boolean;
+    /** Status-footer field visibility and compact presentation preferences. */
+    statusBar?: Partial<StatusBarConfig>;
+    /** Built-in action-shortcut overrides (`paste: 'alt+v'`), keyed by action
+     *  id (see the keymap utility). Combos are `ctrl+`/`alt+`/`shift+` plus a
+     *  key; several combos may be comma-separated. Unset actions keep their
+     *  defaults; the `/settings` screen edits the same keys live (its user
+     *  layer wins over this file). */
+    shortcuts?: Partial<Record<ShortcutActionId, string>>;
+    /** Shift+Tab session-mode cycle (array order IS the cycle order; index 0
+     *  is the unmarked base mode). Each entry bundles any subset of the
+     *  `plan`/`sandbox`/`approval` atoms; absent → the built-in
+     *  default/plan/full cycle (see sessionModes.ts). */
+    modes?: SessionModeSpec[];
+}
+export declare const Config: Schema<Config, RuntimeConfig<Config>>;
+/**
+ * Start the interactive TUI front door, delegating to the JSX implementation
+ * in `./plugin.tsx` (see its module doc for the full contract).
+ * @param ctx - the plugin context.
+ * @param config - the validated dsh-tui configuration.
+ * @returns a promise settling when the Loader entry has scheduled its runtime.
+ */
+export declare function apply(ctx: Context, config: RuntimeConfig<Config>): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/dsh-adapter/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/dsh-adapter/index.ts"],"names":[],"mappings":"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"}

package/lib/types/dsh-adapter/index.js

@@ -0,0 +1,119 @@
+import Schema from '@deepseek-ai/schemastery';
+import { DEFAULT_STATUS_BAR, normalizePageMargin } from '../tuiDisplayPrefs.js';
+import { SHORTCUT_ACTIONS } from '../utils/keymap.js';
+import { editableConfig } from './compat/settings.js';
+export const name = 'dsh-tui';
+// `tuiWorkspaces` must stay OUT of this code-level inject (issue #183): the
+// dsh CLI resolves the bundle's cordis.patch.yml from the FIRST copy of this
+// package found from its own install anchor (typically the global launcher),
+// while the Loader imports the plugin module from the profile's copy. When
+// the two copies skew, the patch may predate the dsh-tui-workspaces row — a
+// hard inject here then deadlocks the whole tree at boot ("pending (waiting
+// for service: tuiWorkspaces)"). The bundle patch keeps tuiWorkspaces in the
+// row-level inject purely as an ordering guarantee when the row exists; when
+// it does not, plugin.ts/channel.ts fall back to a local workspace runtime.
+export const inject = ['agents'];
+export const Config = editableConfig(Schema.object({
+    sessionId: Schema.string().required(false),
+    // No schema defaults on the route: a `.default()` here would make an
+    // unset key indistinguishable from an explicit cordis.yml choice and the
+    // persisted `/model` preference could never win (issue #30). The defaults
+    // live at the end of the fallback chain in modelRoute.ts instead.
+    provider: Schema.string().required(false),
+    model: Schema.string().required(false),
+    cwd: Schema.string().required(false),
+    workspace: Schema.string().required(false),
+    effort: Schema.string().required(false),
+    effortDefault: Schema.string().required(false),
+    whale: Schema.boolean().default(true),
+    whaleIdle: Schema.boolean().default(true),
+    minimal: Schema.boolean().default(false),
+    activity: Schema.boolean().default(true),
+    activityFrames: Schema.string().required(false),
+    contextBar: Schema.boolean().default(true),
+    fullscreen: Schema.boolean().default(true),
+    terminalImages: Schema.boolean().default(true),
+    lang: Schema.string().required(false),
+    preset: Schema.string().required(false),
+    diffLayout: Schema.union(['auto', 'split', 'unified']).default('auto'),
+    thinkingFold: Schema.union(['preview', 'full']).default('preview'),
+    toolBackground: Schema.union(['none', 'subtle', 'strong']).default('none'),
+    scrollGutter: Schema.union(['timeline', 'scrollbar', 'hidden']).default('timeline'),
+    // Preset names AND custom `NxM` specs must survive validation (a custom
+    // spec is not a fixed union member); junk is normalized to `normal` by
+    // the transform, so every parsed config carries a valid setting.
+    pageMargin: Schema.transform(Schema.string().default('normal'), value => normalizePageMargin(value)),
+    foldTerminalCommand: Schema.boolean().default(false),
+    promptSessionLabel: Schema.boolean().default(false),
+    expandEditor: Schema.boolean().default(true),
+    smoothStreaming: Schema.boolean().default(true),
+    mermaidDiagrams: Schema.boolean().default(true),
+    statusBar: Schema.object({
+        compact: Schema.boolean().default(DEFAULT_STATUS_BAR.compact),
+        model: Schema.boolean().default(DEFAULT_STATUS_BAR.model),
+        thinking: Schema.boolean().default(DEFAULT_STATUS_BAR.thinking),
+        cwd: Schema.boolean().default(DEFAULT_STATUS_BAR.cwd),
+        contextUsage: Schema.boolean().default(DEFAULT_STATUS_BAR.contextUsage),
+        cache: Schema.boolean().default(DEFAULT_STATUS_BAR.cache),
+        tokens: Schema.boolean().default(DEFAULT_STATUS_BAR.tokens),
+        tps: Schema.boolean().default(DEFAULT_STATUS_BAR.tps),
+        gitBranch: Schema.boolean().default(DEFAULT_STATUS_BAR.gitBranch),
+        sessionTitle: Schema.boolean().default(DEFAULT_STATUS_BAR.sessionTitle),
+        sessionId: Schema.boolean().default(DEFAULT_STATUS_BAR.sessionId),
+        goal: Schema.boolean().default(DEFAULT_STATUS_BAR.goal),
+        mode: Schema.boolean().default(DEFAULT_STATUS_BAR.mode),
+        contextBar: Schema.boolean().default(DEFAULT_STATUS_BAR.contextBar),
+        activity: Schema.boolean().default(DEFAULT_STATUS_BAR.activity),
+        trajectory: Schema.boolean().default(DEFAULT_STATUS_BAR.trajectory),
+        shortcutHint: Schema.boolean().default(DEFAULT_STATUS_BAR.shortcutHint),
+    }).default({ ...DEFAULT_STATUS_BAR }),
+    // One optional combo string per customizable action (no defaults: unset
+    // keeps the built-in binding; see Config.shortcuts).
+    shortcuts: Schema.object(Object.fromEntries(SHORTCUT_ACTIONS.map(action => [action.id, Schema.string().required(false)]))).required(false),
+    modes: Schema.array(Schema.object({
+        id: Schema.string(),
+        label: Schema.string().required(false),
+        plan: Schema.boolean().required(false),
+        sandbox: Schema.union(['read-only', 'workspace-write', 'danger-full-access']).required(false),
+        approval: Schema.union(['ask', 'never']).required(false),
+        permission: Schema.string().required(false),
+    })).required(false),
+}), [
+    'diffLayout', 'thinkingFold', 'toolBackground', 'scrollGutter', 'pageMargin',
+    'foldTerminalCommand', 'promptSessionLabel', 'expandEditor', 'smoothStreaming',
+    'mermaidDiagrams', 'effortDefault', 'statusBar', 'whale', 'whaleIdle', 'minimal',
+    'lang', 'fullscreen', 'terminalImages', 'shortcuts',
+]);
+/**
+ * Start the interactive TUI front door, delegating to the JSX implementation
+ * in `./plugin.tsx` (see its module doc for the full contract).
+ * @param ctx - the plugin context.
+ * @param config - the validated dsh-tui configuration.
+ * @returns a promise settling when the Loader entry has scheduled its runtime.
+ */
+export async function apply(ctx, config) {
+    // Upstream drift is NO LONGER spammed to stderr here: per-package
+    // console.warn lines interleave with the TUI frame redraw and arrive
+    // garbled (typewriter animation repaints over them). The merged,
+    // natural-language notice now renders in the logo header under the
+    // startup tip (LogoV2 ← upstreamDriftSummary); CI keeps the hard gate
+    // via scripts/verify-upstream-contract.ts.
+    const { apply: tuiApply, handleStartupError } = await import('./plugin.js');
+    let disposed = false;
+    ctx.effect(() => () => { disposed = true; });
+    // Registry diagnostics can await the whole Loader. Do not make this Host
+    // row await the runtime in return. Let Host providers settle before starting
+    // a Cordis-owned child; the original row still owns volatile Config.
+    const loader = ctx.get('loader');
+    void (loader?.await() ?? ctx.fiber.await()).then(() => {
+        if (disposed)
+            return;
+        return ctx.plugin({
+            name: 'dsh-tui-runtime',
+            apply: (runtimeCtx) => tuiApply(runtimeCtx, config, ctx),
+        });
+    }).catch(error => {
+        if (!disposed)
+            handleStartupError(ctx, error);
+    });
+}

package/lib/types/dsh-adapter/inject-channel.d.ts

@@ -0,0 +1,108 @@
+/**
+ * External injection channel — lets an out-of-process editor integration
+ * (e.g. the `dsh.nvim` Neovim plugin) push text into the running TUI's
+ * prompt input and, optionally, submit it. This is dsh-TUI's answer to
+ * OpenCode's `POST /tui/publish` (`tui.prompt.append` / `tui.command.execute`),
+ * but over a per-session local socket instead of an HTTP port: no port
+ * allocation, no auth surface, and the endpoint is torn down with the
+ * session.
+ *
+ * Transport: a Unix domain socket at `~/.dsh-tui/inject/<sessionId>.sock`
+ * (a named pipe `\\.\pipe\dsh-tui-inject-<sessionId>` on Windows). Alongside
+ * it the server maintains a discovery file `~/.dsh-tui/inject/servers.json`
+ * listing every live session (`pid`, `sessionId`, `cwd`, `socketPath`) so a
+ * client can pick the instance whose `cwd` overlaps the editor's project —
+ * the same cwd-matching OpenCode's server discovery does.
+ *
+ * Wire format: newline-delimited JSON, one message per line. Messages:
+ *   - `{ "type": "prompt.append", "text": "@src/foo.ts " }`
+ *   - `{ "type": "command.execute", "command": "prompt.submit" }`
+ * A trailing space in appended text (OpenCode's convention) leaves the input
+ * unsubmitted; the client sends `prompt.submit` when it wants the turn sent.
+ *
+ * @module
+ */
+/** Directory holding per-session sockets and the discovery file. */
+export declare const INJECT_DIR: string;
+/** Discovery file listing every live injection endpoint. */
+export declare const SERVERS_FILE: string;
+/**
+ * A discovery record for one live session, written to {@link SERVERS_FILE}.
+ * Clients read the array and match `cwd` against their own project root.
+ */
+export interface InjectServerRecord {
+    /** Process id of the TUI holding this endpoint (staleness/liveness check). */
+    readonly pid: number;
+    /** DSH session id this endpoint injects into. */
+    readonly sessionId: string;
+    /** Session working directory, for client-side cwd matching. */
+    readonly cwd: string;
+    /** Absolute socket path (Unix) or named-pipe path (Windows) to connect to. */
+    readonly socketPath: string;
+    /** Epoch ms when the endpoint was opened (newest-wins tie-break for clients). */
+    readonly startedAt: number;
+}
+/**
+ * A message accepted over the injection socket. `prompt.append` carries the
+ * text to insert at the caret; `command.execute` names a TUI command
+ * (currently only `prompt.submit`).
+ */
+export type InjectMessage = {
+    readonly type: 'prompt.append';
+    readonly text: string;
+} | {
+    readonly type: 'command.execute';
+    readonly command: 'prompt.submit';
+};
+/** Host callbacks the channel drives when a validated message arrives. */
+export interface InjectHandlers {
+    /** Append `text` to the prompt input (does not submit). */
+    append(text: string): void;
+    /** Submit the current prompt input as a turn. */
+    submit(): void;
+}
+/**
+ * The Chat screen's fulfillment of {@link InjectHandlers}: the UI publishes a
+ * controller each render so the adapter-owned socket can drive prompt append
+ * and submit without the socket reaching into React state directly.
+ */
+export type InjectController = InjectHandlers;
+/**
+ * The platform socket path for a session id. Windows named pipes live under
+ * the `\\.\pipe\` namespace and ignore {@link INJECT_DIR}; the discovery file
+ * still records the pipe path so clients connect to the right name.
+ * @param sessionId - DSH session id.
+ * @returns Connectable socket path or pipe name.
+ */
+export declare function socketPathFor(sessionId: string): string;
+/**
+ * Parse and validate one line as an {@link InjectMessage}. Returns `null` for
+ * anything malformed — the socket is a trust boundary (a foreign process
+ * writes to it), so every field is checked rather than trusted.
+ * @param line - One newline-delimited JSON line (already trimmed of the newline).
+ * @returns The validated message, or `null` to ignore the line.
+ */
+export declare function parseInjectMessage(line: string): InjectMessage | null;
+/** A running injection channel; call {@link InjectChannel.close} at teardown. */
+export interface InjectChannel {
+    /** Absolute socket path this channel listens on. */
+    readonly socketPath: string;
+    /** Stop listening, remove this session's discovery record, and unlink the socket. */
+    close(): void;
+}
+/**
+ * Open the injection channel for one session: bind the socket, register the
+ * discovery record, and dispatch validated messages to `handlers`. Returns
+ * `null` when the socket cannot be bound (another process owns a stale socket
+ * that is genuinely in use, or the platform forbids it) — injection is an
+ * optional integration, so a bind failure degrades to "no channel" rather
+ * than failing the session.
+ *
+ * @param sessionId - DSH session id to expose.
+ * @param cwd - Session working directory, recorded for client cwd matching.
+ * @param handlers - Host callbacks invoked per validated message.
+ * @param onError - Optional sink for non-fatal listen/socket errors.
+ * @returns The live channel, or `null` if binding failed.
+ */
+export declare function openInjectChannel(sessionId: string, cwd: string, handlers: InjectHandlers, onError?: (message: string) => void): InjectChannel | null;
+//# sourceMappingURL=inject-channel.d.ts.map

package/lib/types/dsh-adapter/inject-channel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject-channel.d.ts","sourceRoot":"","sources":["../../../src/dsh-adapter/inject-channel.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAOH,oEAAoE;AACpE,eAAO,MAAM,UAAU,QAA2B,CAAA;AAElD,4DAA4D;AAC5D,eAAO,MAAM,YAAY,QAAmC,CAAA;AAE5D;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IACjC,8EAA8E;IAC9E,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,iDAAiD;IACjD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,+DAA+D;IAC/D,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,8EAA8E;IAC9E,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,iFAAiF;IACjF,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAC3B;AAED;;;;GAIG;AACH,MAAM,MAAM,aAAa,GACrB;IAAE,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACzD;IAAE,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAA;CAAE,CAAA;AAE3E,0EAA0E;AAC1E,MAAM,WAAW,cAAc;IAC7B,2DAA2D;IAC3D,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,iDAAiD;IACjD,MAAM,IAAI,IAAI,CAAA;CACf;AAED;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,GAAG,cAAc,CAAA;AAE7C;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAKvD;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI,CAmBrE;AAkED,iFAAiF;AACjF,MAAM,WAAW,aAAa;IAC5B,oDAAoD;IACpD,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,qFAAqF;IACrF,KAAK,IAAI,IAAI,CAAA;CACd;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,cAAc,EACxB,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,GAClC,aAAa,GAAG,IAAI,CAgGtB"}

package/lib/types/dsh-adapter/inject-channel.js

@@ -0,0 +1,247 @@
+/**
+ * External injection channel — lets an out-of-process editor integration
+ * (e.g. the `dsh.nvim` Neovim plugin) push text into the running TUI's
+ * prompt input and, optionally, submit it. This is dsh-TUI's answer to
+ * OpenCode's `POST /tui/publish` (`tui.prompt.append` / `tui.command.execute`),
+ * but over a per-session local socket instead of an HTTP port: no port
+ * allocation, no auth surface, and the endpoint is torn down with the
+ * session.
+ *
+ * Transport: a Unix domain socket at `~/.dsh-tui/inject/<sessionId>.sock`
+ * (a named pipe `\\.\pipe\dsh-tui-inject-<sessionId>` on Windows). Alongside
+ * it the server maintains a discovery file `~/.dsh-tui/inject/servers.json`
+ * listing every live session (`pid`, `sessionId`, `cwd`, `socketPath`) so a
+ * client can pick the instance whose `cwd` overlaps the editor's project —
+ * the same cwd-matching OpenCode's server discovery does.
+ *
+ * Wire format: newline-delimited JSON, one message per line. Messages:
+ *   - `{ "type": "prompt.append", "text": "@src/foo.ts " }`
+ *   - `{ "type": "command.execute", "command": "prompt.submit" }`
+ * A trailing space in appended text (OpenCode's convention) leaves the input
+ * unsubmitted; the client sends `prompt.submit` when it wants the turn sent.
+ *
+ * @module
+ */
+import { createServer } from 'node:net';
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { DATA_DIR } from '../utils/paths.js';
+/** Directory holding per-session sockets and the discovery file. */
+export const INJECT_DIR = join(DATA_DIR, 'inject');
+/** Discovery file listing every live injection endpoint. */
+export const SERVERS_FILE = join(INJECT_DIR, 'servers.json');
+/**
+ * The platform socket path for a session id. Windows named pipes live under
+ * the `\\.\pipe\` namespace and ignore {@link INJECT_DIR}; the discovery file
+ * still records the pipe path so clients connect to the right name.
+ * @param sessionId - DSH session id.
+ * @returns Connectable socket path or pipe name.
+ */
+export function socketPathFor(sessionId) {
+    if (process.platform === 'win32') {
+        return `\\\\.\\pipe\\dsh-tui-inject-${sessionId}`;
+    }
+    return join(INJECT_DIR, `${sessionId}.sock`);
+}
+/**
+ * Parse and validate one line as an {@link InjectMessage}. Returns `null` for
+ * anything malformed — the socket is a trust boundary (a foreign process
+ * writes to it), so every field is checked rather than trusted.
+ * @param line - One newline-delimited JSON line (already trimmed of the newline).
+ * @returns The validated message, or `null` to ignore the line.
+ */
+export function parseInjectMessage(line) {
+    const trimmed = line.trim();
+    if (trimmed === '')
+        return null;
+    let raw;
+    try {
+        raw = JSON.parse(trimmed);
+    }
+    catch {
+        // A foreign client sent a non-JSON line; ignore rather than crash.
+        return null;
+    }
+    if (typeof raw !== 'object' || raw === null)
+        return null;
+    const msg = raw;
+    if (msg.type === 'prompt.append' && typeof msg.text === 'string') {
+        return { type: 'prompt.append', text: msg.text };
+    }
+    if (msg.type === 'command.execute' && msg.command === 'prompt.submit') {
+        return { type: 'command.execute', command: 'prompt.submit' };
+    }
+    return null;
+}
+/**
+ * Read the discovery file, dropping records whose process is gone. Returns an
+ * empty array when the file is absent or unreadable.
+ * @returns Live server records.
+ */
+function readServers() {
+    let text;
+    try {
+        text = readFileSync(SERVERS_FILE, 'utf8');
+    }
+    catch {
+        // No discovery file yet, or a concurrent writer replaced it mid-read.
+        return [];
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        // A partially written file; the current writer will overwrite it.
+        return [];
+    }
+    if (!Array.isArray(parsed))
+        return [];
+    return parsed.filter((entry) => {
+        if (typeof entry !== 'object' || entry === null)
+            return false;
+        const rec = entry;
+        return (typeof rec.pid === 'number' &&
+            typeof rec.sessionId === 'string' &&
+            typeof rec.cwd === 'string' &&
+            typeof rec.socketPath === 'string' &&
+            typeof rec.startedAt === 'number');
+    });
+}
+/**
+ * Whether a process id is still alive. `process.kill(pid, 0)` sends no signal
+ * but throws `ESRCH` when the process is gone; `EPERM` means it exists but is
+ * owned by another user (still alive for our purposes).
+ * @param pid - Process id to probe.
+ * @returns True when the process appears to exist.
+ */
+function pidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === 'EPERM';
+    }
+}
+/**
+ * Rewrite the discovery file to `records`, best-effort. Never throws: a
+ * failed discovery write must not take down the session.
+ * @param records - The complete record set to persist.
+ */
+function writeServers(records) {
+    try {
+        mkdirSync(INJECT_DIR, { recursive: true });
+        writeFileSync(SERVERS_FILE, JSON.stringify(records, null, 2), 'utf8');
+    }
+    catch {
+        // Discovery is an optimization; the socket still works without the file.
+    }
+}
+/**
+ * Open the injection channel for one session: bind the socket, register the
+ * discovery record, and dispatch validated messages to `handlers`. Returns
+ * `null` when the socket cannot be bound (another process owns a stale socket
+ * that is genuinely in use, or the platform forbids it) — injection is an
+ * optional integration, so a bind failure degrades to "no channel" rather
+ * than failing the session.
+ *
+ * @param sessionId - DSH session id to expose.
+ * @param cwd - Session working directory, recorded for client cwd matching.
+ * @param handlers - Host callbacks invoked per validated message.
+ * @param onError - Optional sink for non-fatal listen/socket errors.
+ * @returns The live channel, or `null` if binding failed.
+ */
+export function openInjectChannel(sessionId, cwd, handlers, onError) {
+    const socketPath = socketPathFor(sessionId);
+    try {
+        mkdirSync(INJECT_DIR, { recursive: true });
+    }
+    catch {
+        // Directory creation failing means we cannot host a Unix socket; on
+        // Windows the pipe namespace does not need it, so fall through and let
+        // listen() decide.
+    }
+    // A previous crash may have left a stale socket file. Removing it before
+    // bind is safe on Unix; on Windows the pipe name is reclaimed by the OS.
+    if (process.platform !== 'win32') {
+        try {
+            rmSync(socketPath, { force: true });
+        }
+        catch {
+            // Nothing to remove, or a live socket we are about to fail binding —
+            // listen() surfaces the real error below.
+        }
+    }
+    let server;
+    try {
+        server = createServer((socket) => {
+            socket.setEncoding('utf8');
+            let buffer = '';
+            socket.on('data', (chunk) => {
+                buffer += chunk;
+                let newline = buffer.indexOf('\n');
+                while (newline !== -1) {
+                    const line = buffer.slice(0, newline);
+                    buffer = buffer.slice(newline + 1);
+                    const message = parseInjectMessage(line);
+                    if (message?.type === 'prompt.append') {
+                        handlers.append(message.text);
+                    }
+                    else if (message?.type === 'command.execute') {
+                        handlers.submit();
+                    }
+                    newline = buffer.indexOf('\n');
+                }
+            });
+            socket.on('error', () => {
+                // A client that disconnects mid-write raises EPIPE/ECONNRESET here;
+                // the per-connection error is not the session's concern.
+            });
+        });
+    }
+    catch (error) {
+        onError?.(`inject channel: failed to create server: ${String(error)}`);
+        return null;
+    }
+    server.on('error', (error) => {
+        onError?.(`inject channel: socket error: ${String(error)}`);
+    });
+    try {
+        server.listen(socketPath);
+    }
+    catch (error) {
+        onError?.(`inject channel: failed to listen on ${socketPath}: ${String(error)}`);
+        return null;
+    }
+    const record = {
+        pid: process.pid,
+        sessionId,
+        cwd,
+        socketPath,
+        startedAt: Date.now(),
+    };
+    const others = readServers().filter((entry) => entry.sessionId !== sessionId && pidAlive(entry.pid));
+    writeServers([...others, record]);
+    return {
+        socketPath,
+        close() {
+            try {
+                server.close();
+            }
+            catch {
+                // Already closed or never fully listened; nothing to undo.
+            }
+            const remaining = readServers().filter((entry) => entry.sessionId !== sessionId && pidAlive(entry.pid));
+            writeServers(remaining);
+            if (process.platform !== 'win32') {
+                try {
+                    rmSync(socketPath, { force: true });
+                }
+                catch {
+                    // The socket file was already removed by close() on some platforms.
+                }
+            }
+        },
+    };
+}

package/lib/types/dsh-adapter/invariant.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Package-owned invariant companion for `dsh-cli`.
+ *
+ * The vendored renderer core is third-party code written against
+ * looser compiler flags; the relaxed `tsconfig` options exist only for that
+ * subtree and must not spread to new code.
+ * @module dsh-cli/invariant
+ */
+import type { Context } from '@deepseek-ai/cordis';
+/** Cordis companion plugin name. */
+export declare const name = "dsh-tui-invariant";
+/** Service required before the companion can reserve package ownership. */
+export declare const inject: string[];
+/**
+ * Register this package's invariant companion.
+ * @param ctx - Cordis context carrying the invariant service.
+ * @returns the installed registration's disposer after setup succeeds.
+ */
+export declare const apply: (ctx: Context) => Promise<() => void>;
+//# sourceMappingURL=invariant.d.ts.map

package/lib/types/dsh-adapter/invariant.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invariant.d.ts","sourceRoot":"","sources":["../../../src/dsh-adapter/invariant.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAKlD,oCAAoC;AACpC,eAAO,MAAM,IAAI,sBAAsB,CAAA;AACvC,2EAA2E;AAC3E,eAAO,MAAM,MAAM,UAAiB,CAAA;AASpC;;;;GAIG;AACH,eAAO,MAAM,KAAK,GAAI,KAAK,OAAO,KAAG,OAAO,CAAC,MAAM,IAAI,CACU,CAAA"}