@toddzheng024/dscode-bundle 0.7.12 → 0.7.14

package/vendor/tui/lib/input-split.mjs

@@ -0,0 +1,170 @@
+/**
+ * Terminal input arrives as byte chunks, and one chunk can carry several
+ * keypresses: a fast space-then-enter, a bridged stdin that batches reads, a
+ * middle-click paste. Ink parses each chunk as exactly one keypress —
+ * `parseKeypress(' \r')` matches neither member, so both keys silently
+ * vanish (a multi-select question answered with an empty set). The splitter
+ * below cuts every chunk into the individual keypress units Ink's parser
+ * expects, keeping escape sequences and bracketed-paste blocks intact, and
+ * the stdin proxy feeds the split stream to the Ink mount.
+ *
+ * @module @deepseek-ai/dsh-tui/input-split
+ */
+import { PassThrough } from 'node:stream';
+import { PASTE_BRACKET_TIMEOUT_MS } from './keyboard.mjs';
+/** Bracketed-paste wrapper bytes; the whole block travels as one unit. */
+const PASTE_START = '\x1b[200~';
+const PASTE_END = '\x1b[201~';
+/** Final byte of a CSI sequence (\x40-\x7e per ECMA-48). */
+const isCsiFinal = (char) => char >= '@' && char <= '~';
+/**
+ * Build a stateful chunk splitter. A partial unit at the end of one chunk
+ * (a cut CSI sequence, an open paste block) waits in the buffer for the
+ * rest. A chunk-trailing lone ESC emits as the Escape key right away:
+ * terminals send Escape as its own chunk, and holding it hostage for a
+ * sequence that may never continue would break every Esc cancel.
+ */
+export function createKeypressSplitter() {
+    let buffer = '';
+    const push = (chunk) => {
+        buffer += chunk;
+        const units = [];
+        while (buffer !== '') {
+            // A bracketed paste block is display text, not keypresses: keep the
+            // whole wrapper plus its payload as the single unit the composer
+            // expects, even when the payload contains ESC-looking bytes.
+            if (buffer.startsWith(PASTE_START)) {
+                const end = buffer.indexOf(PASTE_END, PASTE_START.length);
+                if (end < 0)
+                    break;
+                const stop = end + PASTE_END.length;
+                units.push(buffer.slice(0, stop));
+                buffer = buffer.slice(stop);
+                continue;
+            }
+            const head = buffer[0];
+            if (head !== '\x1b') {
+                // Plain bytes key one at a time; a surrogate pair is one grapheme
+                // and must not split into two lone surrogates.
+                const pair = head >= '\uD800' && head <= '\uDBFF' && buffer[1] !== undefined;
+                const take = pair ? 2 : 1;
+                units.push(buffer.slice(0, take));
+                buffer = buffer.slice(take);
+                continue;
+            }
+            // CSI (\x1b[…final) and SS3 (\x1bO<char): hold until complete.
+            if (buffer[1] === '[') {
+                let end = -1;
+                for (let at = 2; at < buffer.length; at += 1) {
+                    if (isCsiFinal(buffer[at])) {
+                        end = at;
+                        break;
+                    }
+                }
+                if (end < 0)
+                    break;
+                units.push(buffer.slice(0, end + 1));
+                buffer = buffer.slice(end + 1);
+                continue;
+            }
+            if (buffer[1] === 'O') {
+                if (buffer[2] === undefined)
+                    break;
+                units.push(buffer.slice(0, 3));
+                buffer = buffer.slice(3);
+                continue;
+            }
+            if (buffer[1] === undefined) {
+                // Lone ESC: Escape key (see the tradeoff above).
+                units.push(buffer);
+                buffer = '';
+                continue;
+            }
+            // Alt+key: ESC glued to one more byte travels as one unit.
+            units.push(buffer.slice(0, 2));
+            buffer = buffer.slice(2);
+        }
+        return units;
+    };
+    return {
+        push,
+        openPaste() {
+            return buffer.startsWith(PASTE_START);
+        },
+        releaseStalePaste() {
+            if (!buffer.startsWith(PASTE_START))
+                return [];
+            // Strip the unterminated start marker, then re-run the unit loop: the
+            // held bytes flow as ordinary keypresses under all the normal rules.
+            buffer = buffer.slice(PASTE_START.length);
+            return push('');
+        },
+    };
+}
+/**
+ * Wrap one real stdin in the splitting proxy: keypress units flow into a
+ * PassThrough Ink reads, while raw-mode/ref calls forward to the source.
+ * @param source - the process (or harness) input stream in raw mode.
+ * @returns the proxy stream plus a dispose that detaches the tap.
+ */
+export function createSplitStdin(source) {
+    // Object mode matters: a plain stream's read() without a size drains the
+    // whole buffer as one chunk, which would re-coalesce the units this module
+    // exists to separate. In object mode every pushed unit reads back alone.
+    const stream = new PassThrough({ objectMode: true });
+    const splitter = createKeypressSplitter();
+    let stalePasteTimer;
+    const disarmStalePasteTimer = () => {
+        if (stalePasteTimer === undefined)
+            return;
+        clearTimeout(stalePasteTimer);
+        stalePasteTimer = undefined;
+    };
+    // A terminal that drops the end marker must not swallow every following
+    // keypress forever: past the shared paste window the held block is released
+    // as plain text, keeping Esc/Ctrl+C reachable. The App-level paste flag has
+    // its own reset net with the same window, but it can only see markers that
+    // reach Ink — this one guards the bytes that never do.
+    const armStalePasteTimer = () => {
+        if (stalePasteTimer !== undefined || !splitter.openPaste())
+            return;
+        stalePasteTimer = setTimeout(() => {
+            stalePasteTimer = undefined;
+            for (const unit of splitter.releaseStalePaste())
+                stream.write(unit);
+            armStalePasteTimer();
+        }, PASTE_BRACKET_TIMEOUT_MS);
+        stalePasteTimer.unref?.();
+    };
+    const onChunk = (chunk) => {
+        for (const unit of splitter.push(String(chunk)))
+            stream.write(unit);
+        if (splitter.openPaste())
+            armStalePasteTimer();
+        else
+            disarmStalePasteTimer();
+    };
+    const proxy = Object.assign(stream, {
+        isTTY: source.isTTY === true,
+        setRawMode(value) {
+            source.setRawMode?.(value);
+            return stream;
+        },
+        ref() {
+            source.ref?.();
+        },
+        unref() {
+            source.unref?.();
+        },
+    });
+    source.setEncoding('utf8');
+    source.on('data', onChunk);
+    return {
+        stdin: proxy,
+        dispose() {
+            disarmStalePasteTimer();
+            source.removeListener('data', onChunk);
+            source.pause();
+        },
+    };
+}

package/vendor/tui/lib/internals.mjs

@@ -0,0 +1,90 @@
+/**
+ * Injectable process-facing effects for the TUI runner. Tests substitute the
+ * Ink mount with a capturing fake and the streams with string sinks, keeping
+ * the runner's lifecycle testable without a terminal.
+ *
+ * @module @deepseek-ai/dsh-tui/internals
+ */
+import { render } from 'ink';
+import { BRACKETED_PASTE_DISABLE, BRACKETED_PASTE_ENABLE, KEYBOARD_ENHANCE_DISABLE, KEYBOARD_ENHANCE_ENABLE, TERMINAL_FOCUS_REPORT_DISABLE, TERMINAL_FOCUS_REPORT_ENABLE, isVsCodeTerminalEnv, shouldEnableKeyboardEnhancement, } from './keyboard.mjs';
+import { createSplitStdin } from './input-split.mjs';
+import { ensureVsCodeTabTitleSetting } from './terminal-title.mjs';
+/** Substitutable runner effects; production values write to the real terminal. */
+export const internals = {
+    mount: (element) => {
+        // VS Code's integrated terminal can route Tab to the workbench when Kitty
+        // enhancement is enabled. Keep bracketed paste everywhere, but only push
+        // the keyboard protocol on terminals that can safely own those key events.
+        const keyboardEnhanced = shouldEnableKeyboardEnhancement();
+        const focusReporting = isVsCodeTerminalEnv();
+        // Enter raw mode BEFORE pushing any protocol: xterm.js answers `?1004h`
+        // with an immediate focus report (ESC[I), and while the tty still carries
+        // the shell's cooked+ECHO settings that report is echoed to the screen as
+        // a literal `^[[I`. Ink only takes raw mode after its first commit, so
+        // this mount owns the window; the call is idempotent with Ink's later one.
+        if (process.stdin.isTTY === true)
+            process.stdin.setRawMode?.(true);
+        try {
+            process.stdout.write((keyboardEnhanced ? KEYBOARD_ENHANCE_ENABLE : '')
+                + BRACKETED_PASTE_ENABLE
+                + (focusReporting ? TERMINAL_FOCUS_REPORT_ENABLE : ''));
+            // Cosmetic best effort: inside a VS Code integrated terminal the tab
+            // shows the process name ("node") unless the user settings map it to
+            // the sequence title; align them once. Total function, never throws.
+            ensureVsCodeTabTitleSetting();
+            // App owns Ctrl+C's deliberate three-state contract (interrupt, clear
+            // draft, quit). Ink's default `exitOnCtrlC: true` would intercept the
+            // normalized control byte first, unmount only its renderer, and leave the
+            // Harness runner plus the pushed keyboard protocol alive.
+            // stdin travels through the keypress splitter: Ink parses one chunk as
+            // one keypress, so a coalesced space-then-enter would drop both keys.
+            const tuiStdin = createSplitStdin(process.stdin);
+            // Ink only touches isTTY/setRawMode/ref/read on stdin; the object-mode
+            // proxy satisfies that contract without the full ReadStream surface.
+            const instance = render(element, {
+                exitOnCtrlC: false,
+                stdin: tuiStdin.stdin,
+                stdout: process.stdout,
+            });
+            return {
+                rerender(element) {
+                    instance.rerender(element);
+                },
+                unmount() {
+                    // The cleanup below must run even when Ink's unmount throws (a
+                    // render-teardown failure): a stdin tap or pushed terminal-protocol
+                    // stack outliving the app wedges the terminal for whatever runs
+                    // next, and a stray exception here must not skip the exit sequence.
+                    // Pop the stack while raw mode still hides echo — xterm.js keeps
+                    // reporting focus changes until `?1004l` lands, and one arriving
+                    // after Ink restores the cooked tty would print as `^[[I`.
+                    try {
+                        process.stdout.write((keyboardEnhanced ? KEYBOARD_ENHANCE_DISABLE : '')
+                            + BRACKETED_PASTE_DISABLE
+                            + (focusReporting ? TERMINAL_FOCUS_REPORT_DISABLE : ''));
+                    }
+                    finally {
+                        try {
+                            instance.unmount();
+                        }
+                        finally {
+                            tuiStdin.dispose();
+                            // Belt and braces: give the tty back its cooked mode even when
+                            // Ink never took raw mode over (idempotent at the termios level).
+                            if (process.stdin.isTTY === true)
+                                process.stdin.setRawMode?.(false);
+                        }
+                    }
+                },
+            };
+        }
+        catch (error) {
+            // The synchronous mount path failed before Ink could own the terminal:
+            // undo the raw mode entered above so the shell keeps its echo.
+            if (process.stdin.isTTY === true)
+                process.stdin.setRawMode?.(false);
+            throw error;
+        }
+    },
+    stderr: process.stderr,
+};

package/vendor/tui/lib/invariant.mjs

@@ -0,0 +1,22 @@
+/**
+ * Package-owned invariant companion for `dsh-code`.
+ * @module dsh-code/invariant
+ */
+const PACKAGE_NAME = 'dsh-code';
+/** Cordis companion plugin name. */
+export const name = 'tui-invariant';
+/** Service required before the companion can register. */
+export const inject = ['invariants'];
+/**
+ * No runtime invariant beyond the projection's own contract: the TUI renders
+ * only from `session/event` (model-visible means logged), so the display
+ * relation the renderer could desync from is already asserted by the session
+ * log's projection invariants; this companion registers nothing.
+ */
+const install = () => { };
+/**
+ * Register this package's invariant companion.
+ * @param ctx - Cordis context carrying the invariant service.
+ * @returns the installed registration's disposer after setup succeeds.
+ */
+export const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));