@deepseek-harness-tui/dsh-tui 0.6.0 → 0.7.0

package/lib/types/utils/execFileNoThrow.js

@@ -10,19 +10,29 @@ import { spawn } from 'node:child_process';
 export function execFileNoThrow(file, args, options) {
     return new Promise(resolve => {
         const child = spawn(file, args ?? [], { timeout: options?.timeout, cwd: options?.cwd });
-        let stdout = '';
-        let stderr = '';
+        // Collect raw bytes and decode once at close: per-chunk toString() splits
+        // multi-byte UTF-8 characters straddling a chunk boundary into U+FFFD.
+        const stdoutChunks = [];
+        const stderrChunks = [];
         child.stdout.on('data', (chunk) => {
-            stdout += chunk.toString();
+            stdoutChunks.push(chunk);
         });
         child.stderr.on('data', (chunk) => {
-            stderr += chunk.toString();
+            stderrChunks.push(chunk);
         });
         child.on('error', () => {
-            resolve({ code: 1, stdout, stderr });
+            resolve({
+                code: 1,
+                stdout: Buffer.concat(stdoutChunks).toString('utf8'),
+                stderr: Buffer.concat(stderrChunks).toString('utf8'),
+            });
         });
         child.on('close', code => {
-            resolve({ code, stdout, stderr });
+            resolve({
+                code,
+                stdout: Buffer.concat(stdoutChunks).toString('utf8'),
+                stderr: Buffer.concat(stderrChunks).toString('utf8'),
+            });
         });
         if (options?.input !== undefined)
             child.stdin.write(options.input);

package/lib/types/utils/externalEditor.d.ts

@@ -0,0 +1,115 @@
+/**
+ * External editor round-trip for the prompt input (issue #123): Ctrl+X dumps
+ * the current draft into a temp file, hands the terminal to `$VISUAL` /
+ * `$EDITOR` (nvim, vim, nano, `code --wait`, …), and returns the saved text
+ * for the input to adopt.
+ *
+ * Terminal handover reuses the Ink core's editor handoff pair —
+ * `enterAlternateScreen()` pauses rendering, suspends raw-mode stdin, and
+ * drops the extended key reporting that non-CSI-u editors (nano) choke on;
+ * `exitAlternateScreen()` re-enters the alt screen (vim's rmcup pops back to
+ * the main screen on quit), repaints, and resumes stdin. See ink.tsx. The
+ * saved file is read back BEFORE stdin is resumed: resuming earlier would
+ * let keystrokes typed right at editor exit race the prompt's `setValue`
+ * and get overwritten. The restore is attempted whenever the handover was
+ * attempted (a partially-failed enter still gets an exit pass), and a
+ * failing restore never overrides the outcome.
+ *
+ * Editor resolution order mirrors readline's edit-and-execute-command:
+ * `$VISUAL` → `$EDITOR` → `vi` on POSIX (always present). Windows has no
+ * console-editor guarantee and `notepad` does not block, so an unresolved
+ * editor there reports `unavailable` and the UI asks the user to set
+ * `$EDITOR`. The variable may carry arguments (`EDITOR="code --wait"`), so
+ * the command line is split quote-aware before spawning.
+ *
+ * Windows launch: libuv resolves bare names to `.exe` on PATH but will NOT
+ * execute `.cmd`/`.bat` shims (VS Code's `code` on PATH is `code.cmd`), and
+ * `spawn(..., {shell: true})` with arguments triggers DEP0190 on Node 24+.
+ * So bare commands are resolved against PATH/PATHEXT up front, and shim
+ * scripts go through an explicit `$comspec /d /s /c` whose payload is built
+ * with the cross-spawn quoting protocol (vendored in shellQuote.ts) and
+ * passed with `windowsVerbatimArguments: true` — without verbatim, libuv
+ * re-quotes the already-quoted payload and corrupts paths containing
+ * spaces (a stock VS Code install path has them).
+ */
+/**
+ * Outcome of one editor round-trip; the caller maps these to UI feedback:
+ * - `edited`: the saved content differs from the draft — adopt `text`
+ * - `unchanged`: the file matches the draft (modulo newline convention), or
+ *   the editor exited non-zero (`:cq` abort semantics) — keep the draft
+ * - `unavailable`: no editor could be resolved (Windows without `$EDITOR`)
+ * - `failed`: the editor process or the temp-file round-trip errored
+ *   (`message` names the failed command or carries the fs error)
+ */
+export type EditorOutcome = {
+    kind: 'edited';
+    text: string;
+} | {
+    kind: 'unchanged';
+} | {
+    kind: 'unavailable';
+} | {
+    kind: 'failed';
+    message: string;
+};
+/**
+ * Split an `$EDITOR`-style command line into argv, honoring single/double
+ * quotes (`code --wait`, `"C:\Program Files\...\nvim.exe" -f`).
+ */
+export declare function splitEditorCommand(commandLine: string): string[];
+/**
+ * Resolve the editor argv from the environment. `$VISUAL` wins over
+ * `$EDITOR` (readline convention); POSIX falls back to `vi`, Windows has no
+ * blocking console editor fallback and returns undefined. `platform` is a
+ * parameter so the Windows branch is unit-testable from CI's Linux runners.
+ */
+export declare function resolveEditorCommand(env?: NodeJS.ProcessEnv, platform?: NodeJS.Platform): string[] | undefined;
+/**
+ * Windows shim resolution: a bare command like `code` usually lives on PATH
+ * as `code.cmd`, which libuv refuses to execute directly. Walk PATH with
+ * PATHEXT (case-insensitive on Windows; both casings tried for tests on
+ * case-sensitive filesystems) and report whether the resolved file needs
+ * cmd.exe to run. Commands carrying an explicit extension are used as-is;
+ * unresolved names fall back to the bare command (spawn then resolves
+ * `.exe`, or fails into the `failed` outcome).
+ */
+export declare function resolveWindowsShim(command: string, env?: NodeJS.ProcessEnv): {
+    command: string;
+    viaCmd: boolean;
+};
+/**
+ * Build the `comspec /d /s /c` spawn descriptor for a `.cmd`/`.bat` editor,
+ * following the cross-spawn protocol: the command is normalized first
+ * (explicit forward-slash paths like `C:/Program Files/.../code.cmd` must
+ * become backslash form — cross-spawn's path.normalize step, without which
+ * Windows can ENOENT), then command and arguments are escaped, joined, and
+ * wrapped in one pair of quotes (`/s` strips exactly those), and passed
+ * with `windowsVerbatimArguments` so libuv does not re-quote the payload.
+ * Exported for tests — the assembly is pure.
+ */
+export declare function buildCmdExeSpawn(command: string, args: readonly string[], env?: NodeJS.ProcessEnv): {
+    file: string;
+    args: string[];
+    verbatim: true;
+};
+/**
+ * Edit `draft` in the user's editor and report what happened. Never throws:
+ * every filesystem, spawn, or terminal-restore failure maps to a `failed`
+ * outcome (or is swallowed in the finally) so the UI notifies instead of
+ * dying on an unhandled rejection.
+ *
+ * The Ink instance is looked up lazily (same pattern as Chat's Ctrl+L
+ * redraw) so the util stays usable in tests and non-TTY contexts: without a
+ * live instance the handover escapes are skipped and the editor simply
+ * inherits stdio.
+ *
+ * Newline handling: the saved file is compared against the draft with BOTH
+ * sides CRLF-normalized, so an editor that only converts line endings (or
+ * a draft that already carries `\r\n`) never counts as an edit. Otherwise
+ * ONE trailing newline is stripped when the normalized draft did not end
+ * with one — that is the terminating newline editors append on save, not
+ * user content. Trailing blank lines the user actually added (or had in
+ * the draft, e.g. from Shift+Enter) survive untouched.
+ */
+export declare function editInExternalEditor(draft: string): Promise<EditorOutcome>;
+//# sourceMappingURL=externalEditor.d.ts.map

package/lib/types/utils/externalEditor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"externalEditor.d.ts","sourceRoot":"","sources":["../../../src/utils/externalEditor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAUH;;;;;;;;GAQG;AACH,MAAM,MAAM,aAAa,GACrB;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAChC;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE,GACrB;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,GACvB;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAA;AAEvC;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,EAAE,CA0BhE;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,GAAG,GAAE,MAAM,CAAC,UAAwB,EACpC,QAAQ,GAAE,MAAM,CAAC,QAA2B,GAC3C,MAAM,EAAE,GAAG,SAAS,CAOtB;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,EACf,GAAG,GAAE,MAAM,CAAC,UAAwB,GACnC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,OAAO,CAAA;CAAE,CAqBtC;AAKD;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,GAAG,GAAE,MAAM,CAAC,UAAwB,GACnC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,EAAE,CAAC;IAAC,QAAQ,EAAE,IAAI,CAAA;CAAE,CAalD;AA8CD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CAsDhF"}

package/lib/types/utils/externalEditor.js

@@ -0,0 +1,270 @@
+/**
+ * External editor round-trip for the prompt input (issue #123): Ctrl+X dumps
+ * the current draft into a temp file, hands the terminal to `$VISUAL` /
+ * `$EDITOR` (nvim, vim, nano, `code --wait`, …), and returns the saved text
+ * for the input to adopt.
+ *
+ * Terminal handover reuses the Ink core's editor handoff pair —
+ * `enterAlternateScreen()` pauses rendering, suspends raw-mode stdin, and
+ * drops the extended key reporting that non-CSI-u editors (nano) choke on;
+ * `exitAlternateScreen()` re-enters the alt screen (vim's rmcup pops back to
+ * the main screen on quit), repaints, and resumes stdin. See ink.tsx. The
+ * saved file is read back BEFORE stdin is resumed: resuming earlier would
+ * let keystrokes typed right at editor exit race the prompt's `setValue`
+ * and get overwritten. The restore is attempted whenever the handover was
+ * attempted (a partially-failed enter still gets an exit pass), and a
+ * failing restore never overrides the outcome.
+ *
+ * Editor resolution order mirrors readline's edit-and-execute-command:
+ * `$VISUAL` → `$EDITOR` → `vi` on POSIX (always present). Windows has no
+ * console-editor guarantee and `notepad` does not block, so an unresolved
+ * editor there reports `unavailable` and the UI asks the user to set
+ * `$EDITOR`. The variable may carry arguments (`EDITOR="code --wait"`), so
+ * the command line is split quote-aware before spawning.
+ *
+ * Windows launch: libuv resolves bare names to `.exe` on PATH but will NOT
+ * execute `.cmd`/`.bat` shims (VS Code's `code` on PATH is `code.cmd`), and
+ * `spawn(..., {shell: true})` with arguments triggers DEP0190 on Node 24+.
+ * So bare commands are resolved against PATH/PATHEXT up front, and shim
+ * scripts go through an explicit `$comspec /d /s /c` whose payload is built
+ * with the cross-spawn quoting protocol (vendored in shellQuote.ts) and
+ * passed with `windowsVerbatimArguments: true` — without verbatim, libuv
+ * re-quotes the already-quoted payload and corrupts paths containing
+ * spaces (a stock VS Code install path has them).
+ */
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { delimiter, join, win32 } from 'node:path';
+import instances from '../ink/instances.js';
+import { cmdEscapeArgument, cmdEscapeCommand } from './shellQuote.js';
+/**
+ * Split an `$EDITOR`-style command line into argv, honoring single/double
+ * quotes (`code --wait`, `"C:\Program Files\...\nvim.exe" -f`).
+ */
+export function splitEditorCommand(commandLine) {
+    const args = [];
+    let current = '';
+    let quote = null;
+    let hasToken = false;
+    for (const ch of commandLine) {
+        if (quote !== null) {
+            if (ch === quote)
+                quote = null;
+            else
+                current += ch;
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            quote = ch;
+            hasToken = true;
+            continue;
+        }
+        if (/\s/.test(ch)) {
+            if (current !== '' || hasToken)
+                args.push(current);
+            current = '';
+            hasToken = false;
+            continue;
+        }
+        current += ch;
+    }
+    if (current !== '' || hasToken)
+        args.push(current);
+    return args;
+}
+/**
+ * Resolve the editor argv from the environment. `$VISUAL` wins over
+ * `$EDITOR` (readline convention); POSIX falls back to `vi`, Windows has no
+ * blocking console editor fallback and returns undefined. `platform` is a
+ * parameter so the Windows branch is unit-testable from CI's Linux runners.
+ */
+export function resolveEditorCommand(env = process.env, platform = process.platform) {
+    const raw = (env.VISUAL ?? '').trim() || (env.EDITOR ?? '').trim();
+    if (raw !== '') {
+        const args = splitEditorCommand(raw);
+        return args.length > 0 ? args : undefined;
+    }
+    return platform === 'win32' ? undefined : ['vi'];
+}
+/**
+ * Windows shim resolution: a bare command like `code` usually lives on PATH
+ * as `code.cmd`, which libuv refuses to execute directly. Walk PATH with
+ * PATHEXT (case-insensitive on Windows; both casings tried for tests on
+ * case-sensitive filesystems) and report whether the resolved file needs
+ * cmd.exe to run. Commands carrying an explicit extension are used as-is;
+ * unresolved names fall back to the bare command (spawn then resolves
+ * `.exe`, or fails into the `failed` outcome).
+ */
+export function resolveWindowsShim(command, env = process.env) {
+    if (/\.[a-z0-9]+$/i.test(command)) {
+        return { command, viaCmd: /\.(cmd|bat)$/i.test(command) };
+    }
+    const extensions = (env.PATHEXT ?? '.COM;.EXE;.BAT;.CMD')
+        .split(';')
+        .map(ext => ext.trim())
+        .filter(ext => ext !== '');
+    const pathValue = env.PATH ?? env.Path ?? env.path ?? '';
+    for (const dir of pathValue.split(delimiter)) {
+        if (dir === '')
+            continue;
+        for (const ext of extensions) {
+            for (const casing of [ext, ext.toLowerCase()]) {
+                const candidate = join(dir, command + casing);
+                if (existsSync(candidate)) {
+                    return { command: candidate, viaCmd: /\.(cmd|bat)$/i.test(candidate) };
+                }
+            }
+        }
+    }
+    return { command, viaCmd: false };
+}
+/** npm-generated node shims re-invoke node, parsing the line a second time. */
+const CMD_SHIM_RE = /node_modules[\\/]\.bin[\\/][^\\/]+\.cmd$/i;
+/**
+ * Build the `comspec /d /s /c` spawn descriptor for a `.cmd`/`.bat` editor,
+ * following the cross-spawn protocol: the command is normalized first
+ * (explicit forward-slash paths like `C:/Program Files/.../code.cmd` must
+ * become backslash form — cross-spawn's path.normalize step, without which
+ * Windows can ENOENT), then command and arguments are escaped, joined, and
+ * wrapped in one pair of quotes (`/s` strips exactly those), and passed
+ * with `windowsVerbatimArguments` so libuv does not re-quote the payload.
+ * Exported for tests — the assembly is pure.
+ */
+export function buildCmdExeSpawn(command, args, env = process.env) {
+    const normalized = win32.normalize(command);
+    const line = [
+        cmdEscapeCommand(normalized),
+        ...args.map(arg => cmdEscapeArgument(arg, CMD_SHIM_RE.test(normalized))),
+    ].join(' ');
+    return {
+        // `||`, not `??`: a present-but-empty ComSpec must fall back too
+        // (cross-spawn semantics); spawning an empty file name fails outright.
+        file: env.comspec || 'cmd.exe',
+        args: ['/d', '/s', '/c', `"${line}"`],
+        verbatim: true,
+    };
+}
+/**
+ * Run the editor to completion with the terminal attached; resolves to the
+ * exit code, or -1 when the process could not start — including a
+ * SYNCHRONOUS spawn failure (e.g. an empty command string), which would
+ * otherwise reject the promise and skip every cleanup step.
+ */
+function runEditor(argv, file) {
+    return new Promise(resolve => {
+        let settled = false;
+        const finish = (code) => {
+            if (settled)
+                return;
+            settled = true;
+            resolve(code);
+        };
+        let child;
+        try {
+            if (process.platform === 'win32') {
+                const shim = resolveWindowsShim(argv[0]);
+                if (shim.viaCmd) {
+                    const cmd = buildCmdExeSpawn(shim.command, [...argv.slice(1), file]);
+                    child = spawn(cmd.file, cmd.args, {
+                        stdio: 'inherit',
+                        windowsVerbatimArguments: cmd.verbatim,
+                    });
+                }
+                else {
+                    child = spawn(shim.command, [...argv.slice(1), file], { stdio: 'inherit' });
+                }
+            }
+            else {
+                child = spawn(argv[0], [...argv.slice(1), file], { stdio: 'inherit' });
+            }
+        }
+        catch {
+            finish(-1);
+            return;
+        }
+        child.once('error', () => finish(-1));
+        child.once('close', code => finish(code ?? 1));
+    });
+}
+/** Error text for the `failed` outcome, err.message when available. */
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/**
+ * Edit `draft` in the user's editor and report what happened. Never throws:
+ * every filesystem, spawn, or terminal-restore failure maps to a `failed`
+ * outcome (or is swallowed in the finally) so the UI notifies instead of
+ * dying on an unhandled rejection.
+ *
+ * The Ink instance is looked up lazily (same pattern as Chat's Ctrl+L
+ * redraw) so the util stays usable in tests and non-TTY contexts: without a
+ * live instance the handover escapes are skipped and the editor simply
+ * inherits stdio.
+ *
+ * Newline handling: the saved file is compared against the draft with BOTH
+ * sides CRLF-normalized, so an editor that only converts line endings (or
+ * a draft that already carries `\r\n`) never counts as an edit. Otherwise
+ * ONE trailing newline is stripped when the normalized draft did not end
+ * with one — that is the terminating newline editors append on save, not
+ * user content. Trailing blank lines the user actually added (or had in
+ * the draft, e.g. from Shift+Enter) survive untouched.
+ */
+export async function editInExternalEditor(draft) {
+    const argv = resolveEditorCommand();
+    if (argv === undefined)
+        return { kind: 'unavailable' };
+    const ink = instances.get(process.stdout) ??
+        // Test harnesses render onto a fake stdout — fall back to the process's
+        // single live instance so the handover path stays exercisable there.
+        (instances.size === 1 ? [...instances.values()][0] : undefined);
+    let handed = false;
+    let dir;
+    try {
+        dir = await mkdtemp(join(tmpdir(), 'dsh-tui-prompt-'));
+        // .md so markdown-aware editors highlight the draft like a chat message.
+        const file = join(dir, 'input.md');
+        await writeFile(file, draft, 'utf8');
+        // Mark the handover as attempted BEFORE entering: if enter fails after
+        // suspending stdin, the finally must still run the restore pass.
+        handed = ink !== undefined;
+        ink?.enterAlternateScreen();
+        const code = await runEditor(argv, file);
+        // Read back BEFORE the finally resumes stdin — keystrokes typed the
+        // moment the editor exits must not race the prompt adopting the result.
+        const saved = await readFile(file, 'utf8').catch(() => null);
+        if (code === -1)
+            return { kind: 'failed', message: argv[0] };
+        if (code !== 0 || saved === null)
+            return { kind: 'unchanged' };
+        const normalized = saved.replace(/\r\n/g, '\n');
+        const draftNormalized = draft.replace(/\r\n/g, '\n');
+        if (normalized === draftNormalized)
+            return { kind: 'unchanged' };
+        const text = !draftNormalized.endsWith('\n') && normalized.endsWith('\n')
+            ? normalized.slice(0, -1)
+            : normalized;
+        return text === draftNormalized ? { kind: 'unchanged' } : { kind: 'edited', text };
+    }
+    catch (error) {
+        return { kind: 'failed', message: errorMessage(error) };
+    }
+    finally {
+        // Cleanup runs before the restore: when the finally ends, stdin must
+        // come back to a fully settled state. Both steps are best-effort — a
+        // failure here never overrides the outcome produced above.
+        if (dir !== undefined) {
+            await rm(dir, { recursive: true, force: true }).catch(() => { });
+        }
+        if (handed) {
+            try {
+                ink?.exitAlternateScreen();
+            }
+            catch {
+                // A stuck alt screen is visible to the user; a rejection on top of
+                // a valid outcome is strictly worse — swallow and keep the outcome.
+            }
+        }
+    }
+}

package/lib/types/utils/fullscreen.d.ts

@@ -1,8 +1,8 @@
 /**
  * Whether mouse click handling is disabled for the ported Ink core. dsh-tui
- * reads its own env flag (`CC_TUI_DISABLE_MOUSE`); the original module
+ * reads its own env flag (`DSH_TUI_DISABLE_MOUSE`); the original module
  * consulted Claude Code's fullscreen state.
- * @returns True when CC_TUI_DISABLE_MOUSE is set to a truthy value.
+ * @returns True when DSH_TUI_DISABLE_MOUSE is set to a truthy value.
  */
 export declare function isMouseClicksDisabled(): boolean;
 //# sourceMappingURL=fullscreen.d.ts.map

package/lib/types/utils/fullscreen.js

@@ -1,10 +1,10 @@
 import { isEnvTruthy } from './envUtils.js';
 /**
  * Whether mouse click handling is disabled for the ported Ink core. dsh-tui
- * reads its own env flag (`CC_TUI_DISABLE_MOUSE`); the original module
+ * reads its own env flag (`DSH_TUI_DISABLE_MOUSE`); the original module
  * consulted Claude Code's fullscreen state.
- * @returns True when CC_TUI_DISABLE_MOUSE is set to a truthy value.
+ * @returns True when DSH_TUI_DISABLE_MOUSE is set to a truthy value.
  */
 export function isMouseClicksDisabled() {
-    return isEnvTruthy(process.env.CC_TUI_DISABLE_MOUSE);
+    return isEnvTruthy(process.env.DSH_TUI_DISABLE_MOUSE);
 }

package/lib/types/utils/loaded-context.d.ts

@@ -1,4 +1,4 @@
-import type { LoadedContext } from '../channel.js';
+import type { LoadedContext } from '../dsh-adapter/channel.js';
 /** Per-entry display cap: the panel shows the beginning of long texts. */
 export declare const CONTEXT_ENTRY_MAX_CHARS = 800;
 /**

package/lib/types/utils/loaded-context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loaded-context.d.ts","sourceRoot":"","sources":["../../../src/utils/loaded-context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAGlD,0EAA0E;AAC1E,eAAO,MAAM,uBAAuB,MAAM,CAAA;AAE1C;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,SAA0B,GAAG,MAAM,CAGvF;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,aAAa,GAAG,MAAM,CAQrE"}
+{"version":3,"file":"loaded-context.d.ts","sourceRoot":"","sources":["../../../src/utils/loaded-context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAA;AAG9D,0EAA0E;AAC1E,eAAO,MAAM,uBAAuB,MAAM,CAAA;AAE1C;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,SAA0B,GAAG,MAAM,CAGvF;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,aAAa,GAAG,MAAM,CAQrE"}

package/lib/types/utils/modifiers.d.ts

@@ -16,4 +16,28 @@ export declare function isMod(key: {
  * "ctrl+" everywhere else. Pair with the bare key, e.g. `${modLabel}o`.
  */
 export declare const modLabel: string;
+/**
+ * Modal-confirm guard. Since #110 the input pipeline can deliver Enter WITH
+ * modifiers: Option+Enter arrives as meta+return (ESC CR), and on
+ * extended-keys terminals (kitty CSI-u / modifyOtherKeys) Shift/Ctrl+Enter
+ * arrive as return+modifier. A bare `key.return` in a decision dialog would
+ * let those commit by accident — approving a permission escalation or
+ * confirming an irreversible session delete when the user only wanted a
+ * newline. Only a modifier-free Enter may commit a modal.
+ */
+export declare function isPlainReturn(key: {
+    return?: boolean;
+    ctrl?: boolean;
+    meta?: boolean;
+    shift?: boolean;
+    super?: boolean;
+}): boolean;
+/**
+ * Modal Enter recognition across parsed key events and Windows ConPTY's raw
+ * CR/LF fallback. PromptInput already handled both forms; shared modal
+ * pickers must do the same or their UI can render while Enter appears inert.
+ */
+export declare function isPlainReturnInput(input: string, key: Parameters<typeof isPlainReturn>[0] & {
+    isPasted?: boolean;
+}): boolean;
 //# sourceMappingURL=modifiers.d.ts.map

package/lib/types/utils/modifiers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"modifiers.d.ts","sourceRoot":"","sources":["../../../src/utils/modifiers.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,eAAO,MAAM,KAAK,SAAgC,CAAA;AAElD,yEAAyE;AACzE,wBAAgB,KAAK,CAAC,GAAG,EAAE;IAAE,IAAI,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,OAAO,CAEvE;AAED;;;GAGG;AACH,eAAO,MAAM,QAAQ,QAAwB,CAAA"}
+{"version":3,"file":"modifiers.d.ts","sourceRoot":"","sources":["../../../src/utils/modifiers.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,eAAO,MAAM,KAAK,SAAgC,CAAA;AAElD,yEAAyE;AACzE,wBAAgB,KAAK,CAAC,GAAG,EAAE;IAAE,IAAI,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,OAAO,CAEvE;AAED;;;GAGG;AACH,eAAO,MAAM,QAAQ,QAAwB,CAAA;AAE7C;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE;IACjC,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,KAAK,CAAC,EAAE,OAAO,CAAA;CAChB,GAAG,OAAO,CAEV;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,UAAU,CAAC,OAAO,aAAa,CAAC,CAAC,CAAC,CAAC,GAAG;IAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,GAChE,OAAO,CAOT"}

package/lib/types/utils/modifiers.js

@@ -15,3 +15,30 @@ export function isMod(key) {
  * "ctrl+" everywhere else. Pair with the bare key, e.g. `${modLabel}o`.
  */
 export const modLabel = isMac ? '⌘' : 'ctrl+';
+/**
+ * Modal-confirm guard. Since #110 the input pipeline can deliver Enter WITH
+ * modifiers: Option+Enter arrives as meta+return (ESC CR), and on
+ * extended-keys terminals (kitty CSI-u / modifyOtherKeys) Shift/Ctrl+Enter
+ * arrive as return+modifier. A bare `key.return` in a decision dialog would
+ * let those commit by accident — approving a permission escalation or
+ * confirming an irreversible session delete when the user only wanted a
+ * newline. Only a modifier-free Enter may commit a modal.
+ */
+export function isPlainReturn(key) {
+    return !!key.return && !key.ctrl && !key.meta && !key.shift && !key.super;
+}
+/**
+ * Modal Enter recognition across parsed key events and Windows ConPTY's raw
+ * CR/LF fallback. PromptInput already handled both forms; shared modal
+ * pickers must do the same or their UI can render while Enter appears inert.
+ */
+export function isPlainReturnInput(input, key) {
+    if (isPlainReturn(key))
+        return true;
+    // Bracketed paste can deliver a chunk that is all line breaks — that is
+    // pasted content, not an Enter press, and must never confirm a modal.
+    if (key.isPasted === true)
+        return false;
+    return /^[\r\n]+$/u.test(input)
+        && !key.ctrl && !key.meta && !key.shift && !key.super;
+}

package/lib/types/utils/paths.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Data-directory paths for the dsh-tui profile, renamed from `~/.dsh-cc` to
+ * `~/.dsh-tui` (issue #120). On first launch the legacy directory is COPIED
+ * (not moved) to the new location; afterwards only the new directory is read
+ * and written. The one exception is `resume.txt`, which sessionHistory
+ * dual-writes for old launchers — see the launcher contract there.
+ *
+ * The compiled copy (lib/types/utils/paths.js) is also imported by the bin
+ * launcher, mirroring the shellQuote precedent.
+ */
+/**
+ * The user's home directory. `os.homedir()` first; the USERPROFILE/HOME
+ * spellings are the last-resort fallback for stripped-down environments.
+ * @returns Absolute home path.
+ */
+export declare function homeDir(): string;
+/** Data directory all preferences/history live in (`~/.dsh-tui`). */
+export declare const DATA_DIR: string;
+/** Pre-rename data directory (`~/.dsh-cc`), read only for migration. */
+export declare const LEGACY_DATA_DIR: string;
+/**
+ * Copy the legacy data directory to the new location on first launch.
+ * A copy (not a move) so old launchers keep working and the user can delete
+ * the legacy directory themselves once satisfied. No-op when the legacy
+ * directory is absent or the new one already exists.
+ * @param legacy - Legacy directory (injectable for tests).
+ * @param target - New directory (injectable for tests).
+ * @returns True when a migration copy happened.
+ */
+export declare function migrateLegacyDataDir(legacy?: string, target?: string): boolean;
+/**
+ * Env vars renamed in issue #120 that no longer take effect: old name → new
+ * name. `DSH_CC_RESUME_SESSION` is deliberately absent — it remains a valid
+ * half of the dual-read launcher contract (see sessionHistory.ts).
+ */
+export declare const RENAMED_ENV: Readonly<Record<string, string>>;
+/**
+ * Old env-var names still set in the environment (they no longer take
+ * effect). Used to print one deprecation line per name before the TUI
+ * renders — stderr writes break the fullscreen UI once it is up.
+ * @param env - Environment to scan (defaults to process.env; injectable).
+ * @returns The legacy names found, in RENAMED_ENV order.
+ */
+export declare function detectLegacyEnv(env?: NodeJS.ProcessEnv): string[];
+//# sourceMappingURL=paths.d.ts.map

package/lib/types/utils/paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../../../src/utils/paths.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAMH;;;;GAIG;AACH,wBAAgB,OAAO,IAAI,MAAM,CAEhC;AAED,qEAAqE;AACrE,eAAO,MAAM,QAAQ,QAA8B,CAAA;AAEnD,wEAAwE;AACxE,eAAO,MAAM,eAAe,QAA6B,CAAA;AAEzD;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,GAAE,MAAwB,EAChC,MAAM,GAAE,MAAiB,GACxB,OAAO,CAIT;AAED;;;;GAIG;AACH,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAaxD,CAAA;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,GAAG,GAAE,MAAM,CAAC,UAAwB,GACnC,MAAM,EAAE,CAEV"}

package/lib/types/utils/paths.js

@@ -0,0 +1,69 @@
+/**
+ * Data-directory paths for the dsh-tui profile, renamed from `~/.dsh-cc` to
+ * `~/.dsh-tui` (issue #120). On first launch the legacy directory is COPIED
+ * (not moved) to the new location; afterwards only the new directory is read
+ * and written. The one exception is `resume.txt`, which sessionHistory
+ * dual-writes for old launchers — see the launcher contract there.
+ *
+ * The compiled copy (lib/types/utils/paths.js) is also imported by the bin
+ * launcher, mirroring the shellQuote precedent.
+ */
+import { cpSync, existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+/**
+ * The user's home directory. `os.homedir()` first; the USERPROFILE/HOME
+ * spellings are the last-resort fallback for stripped-down environments.
+ * @returns Absolute home path.
+ */
+export function homeDir() {
+    return homedir() || process.env.USERPROFILE || process.env.HOME || '';
+}
+/** Data directory all preferences/history live in (`~/.dsh-tui`). */
+export const DATA_DIR = join(homeDir(), '.dsh-tui');
+/** Pre-rename data directory (`~/.dsh-cc`), read only for migration. */
+export const LEGACY_DATA_DIR = join(homeDir(), '.dsh-cc');
+/**
+ * Copy the legacy data directory to the new location on first launch.
+ * A copy (not a move) so old launchers keep working and the user can delete
+ * the legacy directory themselves once satisfied. No-op when the legacy
+ * directory is absent or the new one already exists.
+ * @param legacy - Legacy directory (injectable for tests).
+ * @param target - New directory (injectable for tests).
+ * @returns True when a migration copy happened.
+ */
+export function migrateLegacyDataDir(legacy = LEGACY_DATA_DIR, target = DATA_DIR) {
+    if (!existsSync(legacy) || existsSync(target))
+        return false;
+    cpSync(legacy, target, { recursive: true });
+    return true;
+}
+/**
+ * Env vars renamed in issue #120 that no longer take effect: old name → new
+ * name. `DSH_CC_RESUME_SESSION` is deliberately absent — it remains a valid
+ * half of the dual-read launcher contract (see sessionHistory.ts).
+ */
+export const RENAMED_ENV = {
+    CC_TUI_THEME: 'DSH_TUI_THEME',
+    CC_TUI_LANG: 'DSH_TUI_LANG',
+    CC_TUI_PERSONA: 'DSH_TUI_PERSONA',
+    CC_TUI_PRESET: 'DSH_TUI_PRESET',
+    CC_TUI_DISABLE_MOUSE: 'DSH_TUI_DISABLE_MOUSE',
+    CC_TUI_DEBUG: 'DSH_TUI_DEBUG',
+    CC_TUI_COMPACT_RATIO: 'DSH_TUI_COMPACT_RATIO',
+    CC_TUI_COMPACT_RETAIN: 'DSH_TUI_COMPACT_RETAIN',
+    DSH_CC_UPDATED_FROM: 'DSH_TUI_UPDATED_FROM',
+    DSH_CC_RENDER_LOG: 'DSH_TUI_RENDER_LOG',
+    DSH_CC_SESSION_ROOT: 'DSH_TUI_SESSION_ROOT',
+    DSH_CC_WORKSPACE: 'DSH_TUI_WORKSPACE',
+};
+/**
+ * Old env-var names still set in the environment (they no longer take
+ * effect). Used to print one deprecation line per name before the TUI
+ * renders — stderr writes break the fullscreen UI once it is up.
+ * @param env - Environment to scan (defaults to process.env; injectable).
+ * @returns The legacy names found, in RENAMED_ENV order.
+ */
+export function detectLegacyEnv(env = process.env) {
+    return Object.keys(RENAMED_ENV).filter(name => env[name] !== undefined);
+}