@askdkc/dsh-cli 0.11.3

package/lib/types/ink/terminal-image.js

@@ -0,0 +1,223 @@
+/** Hard bounds for one decoded image admitted to the terminal renderer. */
+export const TERMINAL_IMAGE_MAX_EDGE = 1024;
+export const TERMINAL_IMAGE_MAX_BYTES = 4 * 1024 * 1024;
+/** Explicit large previews may use a longer edge, but not an unbounded square. */
+export const TERMINAL_IMAGE_PREVIEW_MAX_EDGE = 2048;
+export const TERMINAL_IMAGE_PREVIEW_MAX_BYTES = 8 * 1024 * 1024;
+/** Maximum decoded RGBA bytes represented by placements in one frame. */
+export const TERMINAL_IMAGE_MAX_FRAME_BYTES = 16 * 1024 * 1024;
+/**
+ * Cell-box cap for one placement (a 128×128 grid). Pixel payload is bounded
+ * separately by MAX_EDGE / MAX_BYTES / MAX_FRAME_BYTES; this only bounds the
+ * screen area one image may claim, so a modal preview can fill a large
+ * transcript while thumbnails and status views keep their own small boxes.
+ */
+export const TERMINAL_IMAGE_MAX_CELLS = 128 * 128;
+export const TERMINAL_IMAGE_MAX_PLACEMENTS = 64;
+export const SIXEL_MAX_ENCODED_BYTES = 4 * 1024 * 1024;
+export const SIXEL_THUMBNAIL_FRAME_BYTES = 1024 * 1024;
+export const SIXEL_CACHE_BYTES = 16 * 1024 * 1024;
+export const SIXEL_CACHE_ENTRIES = 64;
+/** Conventional monospace cell used when XTWINOPS pixel queries are absent. */
+export const DEFAULT_TERMINAL_CELL_SIZE = Object.freeze({
+    width: 8,
+    height: 16,
+});
+/**
+ * Normalize terminal-reported cell pixels before they reach allocation math.
+ * The upper bound rejects corrupt or injected XTWINOPS replies; real terminal
+ * cells remain far below it, including HiDPI displays.
+ */
+export function normalizeTerminalCellSize(value) {
+    return plausibleTerminalCellSize(value) ?? DEFAULT_TERMINAL_CELL_SIZE;
+}
+/** Prefer a direct cell report, then derive it from text-area pixels. */
+export function resolveTerminalCellSize(cell, window, columns, rows) {
+    const direct = plausibleTerminalCellSize(cell);
+    if (direct !== undefined)
+        return direct;
+    if (window === undefined ||
+        !Number.isFinite(window.width) ||
+        !Number.isFinite(window.height) ||
+        columns <= 0 ||
+        rows <= 0) {
+        return undefined;
+    }
+    return plausibleTerminalCellSize({
+        width: window.width / columns,
+        height: window.height / rows,
+    });
+}
+function plausibleTerminalCellSize(value) {
+    if (value === undefined ||
+        !Number.isFinite(value.width) ||
+        !Number.isFinite(value.height) ||
+        value.width < 1 ||
+        value.height < 1 ||
+        value.width > 512 ||
+        value.height > 512) {
+        return undefined;
+    }
+    return { width: Math.round(value.width), height: Math.round(value.height) };
+}
+/**
+ * Prepare an RGBA raster that fits a laid-out cell rectangle without
+ * distortion. The transparent canvas has the terminal rectangle's physical
+ * aspect ratio; the host only downsamples source pixels and centers them
+ * inside it. Kitty can then scale that bounded canvas to the requested cells.
+ */
+export function fitTerminalImageSource(source, columns, rows, cellSize = DEFAULT_TERMINAL_CELL_SIZE, presentation) {
+    const cell = normalizeTerminalCellSize(cellSize);
+    const safeColumns = Math.max(1, Math.floor(columns));
+    const safeRows = Math.max(1, Math.floor(rows));
+    const [boxWidth, boxHeight] = boundedPixelBox(safeColumns * cell.width, safeRows * cell.height, presentation === 'preview' ? TERMINAL_IMAGE_PREVIEW_MAX_BYTES : TERMINAL_IMAGE_MAX_BYTES);
+    // Kitty scales the raster to the requested cell rectangle, so its canvas
+    // must have that rectangle's exact physical aspect ratio. Rounding each
+    // side independently would distort tiny sources. Use the smallest integer
+    // multiple of the reduced ratio that contains the fitted source.
+    const requestedWidth = safeColumns * cell.width;
+    const requestedHeight = safeRows * cell.height;
+    const divisor = greatestCommonDivisor(requestedWidth, requestedHeight);
+    let ratioWidth = requestedWidth / divisor;
+    let ratioHeight = requestedHeight / divisor;
+    let maximumMultiple = Math.floor(Math.min(boxWidth / ratioWidth, boxHeight / ratioHeight));
+    // Some coprime physical dimensions need more pixels than the allocation
+    // budget even at their smallest exact ratio. Only then use the nearest
+    // uniformly bounded raster ratio.
+    if (maximumMultiple < 1) {
+        const boundedDivisor = greatestCommonDivisor(boxWidth, boxHeight);
+        ratioWidth = boxWidth / boundedDivisor;
+        ratioHeight = boxHeight / boundedDivisor;
+        maximumMultiple = boundedDivisor;
+    }
+    const multiple = Math.min(maximumMultiple, Math.max(1, Math.ceil(source.width / ratioWidth), Math.ceil(source.height / ratioHeight)));
+    const canvasWidth = ratioWidth * multiple;
+    const canvasHeight = ratioHeight * multiple;
+    const canvasScale = Math.min(1, canvasWidth / source.width, canvasHeight / source.height);
+    const fittedWidth = Math.max(1, Math.min(canvasWidth, Math.round(source.width * canvasScale)));
+    const fittedHeight = Math.max(1, Math.min(canvasHeight, Math.round(source.height * canvasScale)));
+    if (fittedWidth === source.width &&
+        fittedHeight === source.height &&
+        canvasWidth === source.width &&
+        canvasHeight === source.height) {
+        return source;
+    }
+    const content = fittedWidth === source.width && fittedHeight === source.height
+        ? source.data
+        : resizeRgba(source, fittedWidth, fittedHeight);
+    if (canvasWidth === fittedWidth && canvasHeight === fittedHeight) {
+        return { data: content, width: fittedWidth, height: fittedHeight };
+    }
+    const data = new Uint8Array(canvasWidth * canvasHeight * 4);
+    const left = Math.floor((canvasWidth - fittedWidth) / 2);
+    const top = Math.floor((canvasHeight - fittedHeight) / 2);
+    const sourceStride = fittedWidth * 4;
+    for (let row = 0; row < fittedHeight; row++) {
+        const sourceStart = row * sourceStride;
+        const targetStart = ((top + row) * canvasWidth + left) * 4;
+        data.set(content.subarray(sourceStart, sourceStart + sourceStride), targetStart);
+    }
+    return { data, width: canvasWidth, height: canvasHeight };
+}
+function greatestCommonDivisor(left, right) {
+    while (right !== 0) {
+        const remainder = left % right;
+        left = right;
+        right = remainder;
+    }
+    return left;
+}
+function boundedPixelBox(width, height, maxBytes) {
+    const maxPixels = maxBytes / 4;
+    const scale = Math.min(1, Math.sqrt(maxPixels / (width * height)));
+    return [
+        Math.max(1, Math.floor(width * scale)),
+        Math.max(1, Math.floor(height * scale)),
+    ];
+}
+/** Premultiplied-alpha bilinear resize avoids dark fringes at transparency. */
+function resizeRgba(source, width, height) {
+    const output = new Uint8Array(width * height * 4);
+    const xScale = source.width / width;
+    const yScale = source.height / height;
+    for (let y = 0; y < height; y++) {
+        const sourceY = (y + 0.5) * yScale - 0.5;
+        const rawY0 = Math.floor(sourceY);
+        const y0 = Math.max(0, Math.min(source.height - 1, rawY0));
+        const y1 = Math.max(0, Math.min(source.height - 1, rawY0 + 1));
+        const yWeight = sourceY - rawY0;
+        for (let x = 0; x < width; x++) {
+            const sourceX = (x + 0.5) * xScale - 0.5;
+            const rawX0 = Math.floor(sourceX);
+            const x0 = Math.max(0, Math.min(source.width - 1, rawX0));
+            const x1 = Math.max(0, Math.min(source.width - 1, rawX0 + 1));
+            const xWeight = sourceX - rawX0;
+            const weight00 = (1 - xWeight) * (1 - yWeight);
+            const weight10 = xWeight * (1 - yWeight);
+            const weight01 = (1 - xWeight) * yWeight;
+            const weight11 = xWeight * yWeight;
+            const offset00 = (y0 * source.width + x0) * 4;
+            const offset10 = (y0 * source.width + x1) * 4;
+            const offset01 = (y1 * source.width + x0) * 4;
+            const offset11 = (y1 * source.width + x1) * 4;
+            const alpha00 = source.data[offset00 + 3];
+            const alpha10 = source.data[offset10 + 3];
+            const alpha01 = source.data[offset01 + 3];
+            const alpha11 = source.data[offset11 + 3];
+            const alpha = alpha00 * weight00 +
+                alpha10 * weight10 +
+                alpha01 * weight01 +
+                alpha11 * weight11;
+            const red = source.data[offset00] * alpha00 * weight00 +
+                source.data[offset10] * alpha10 * weight10 +
+                source.data[offset01] * alpha01 * weight01 +
+                source.data[offset11] * alpha11 * weight11;
+            const green = source.data[offset00 + 1] * alpha00 * weight00 +
+                source.data[offset10 + 1] * alpha10 * weight10 +
+                source.data[offset01 + 1] * alpha01 * weight01 +
+                source.data[offset11 + 1] * alpha11 * weight11;
+            const blue = source.data[offset00 + 2] * alpha00 * weight00 +
+                source.data[offset10 + 2] * alpha10 * weight10 +
+                source.data[offset01 + 2] * alpha01 * weight01 +
+                source.data[offset11 + 2] * alpha11 * weight11;
+            const target = (y * width + x) * 4;
+            if (alpha > 0) {
+                output[target] = Math.round(red / alpha);
+                output[target + 1] = Math.round(green / alpha);
+                output[target + 2] = Math.round(blue / alpha);
+            }
+            output[target + 3] = Math.round(alpha);
+        }
+    }
+    return output;
+}
+/** Validate an untrusted decoded source without copying its pixel buffer. */
+export function isTerminalImageSource(value, presentation) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        return false;
+    }
+    const source = value;
+    const maxEdge = presentation === 'preview' ? TERMINAL_IMAGE_PREVIEW_MAX_EDGE : TERMINAL_IMAGE_MAX_EDGE;
+    const maxBytes = presentation === 'preview' ? TERMINAL_IMAGE_PREVIEW_MAX_BYTES : TERMINAL_IMAGE_MAX_BYTES;
+    if (!(source.data instanceof Uint8Array) ||
+        !Number.isSafeInteger(source.width) ||
+        !Number.isSafeInteger(source.height) ||
+        source.width <= 0 ||
+        source.height <= 0 ||
+        source.width > maxEdge ||
+        source.height > maxEdge) {
+        return false;
+    }
+    const bytes = source.width * source.height * 4;
+    return bytes <= maxBytes && source.data.byteLength === bytes;
+}
+/** Recover and validate a source stored as primitive Ink host attributes. */
+export function terminalImageSourceFromAttributes(attributes) {
+    const source = {
+        data: attributes['imageData'],
+        width: attributes['imageWidth'],
+        height: attributes['imageHeight'],
+    };
+    const presentation = attributes['imagePresentation'] === 'preview' ? 'preview' : undefined;
+    return isTerminalImageSource(source, presentation) ? source : undefined;
+}

package/lib/types/ink/terminal-querier.d.ts

@@ -0,0 +1,203 @@
+/**
+ * Query the terminal and await responses without timeouts.
+ *
+ * Terminal queries (DECRQM, DA1, OSC 11, etc.) share the stdin stream
+ * with keyboard input. Response sequences are syntactically
+ * distinguishable from key events, so the input parser recognizes them
+ * and dispatches them here.
+ *
+ * To avoid timeouts, each query batch is terminated by a DA1 sentinel
+ * (CSI c) — every terminal since VT100 responds to DA1, and terminals
+ * answer queries in order. So: if your query's response arrives before
+ * DA1's, the terminal supports it; if DA1 arrives first, it doesn't.
+ *
+ * Usage:
+ *   const [sync, grapheme] = await Promise.all([
+ *     querier.send(decrqm(2026)),
+ *     querier.send(decrqm(2027)),
+ *     querier.flush(),
+ *   ])
+ *   // sync and grapheme are DECRPM responses or undefined if unsupported
+ */
+import type { TerminalResponse } from './parse-keypress.js';
+/** A terminal query: an outbound request sequence paired with a matcher
+ *  that recognizes the expected inbound response. Built by `decrqm()`,
+ *  `oscColor()`, `kittyKeyboard()`, etc. */
+export type TerminalQuery<T extends TerminalResponse = TerminalResponse> = {
+    /** Escape sequence to write to stdout */
+    request: string;
+    /** Recognizes the expected response in the inbound stream */
+    match: (r: TerminalResponse) => r is T;
+};
+type DecrpmResponse = Extract<TerminalResponse, {
+    type: 'decrpm';
+}>;
+type Da1Response = Extract<TerminalResponse, {
+    type: 'da1';
+}>;
+type Da2Response = Extract<TerminalResponse, {
+    type: 'da2';
+}>;
+type KittyResponse = Extract<TerminalResponse, {
+    type: 'kittyKeyboard';
+}>;
+type KittyGraphicsResponse = Extract<TerminalResponse, {
+    type: 'kittyGraphics';
+}>;
+type TerminalPixelSizeResponse = Extract<TerminalResponse, {
+    type: 'terminalPixelSize';
+}>;
+type CursorPosResponse = Extract<TerminalResponse, {
+    type: 'cursorPosition';
+}>;
+type OscResponse = Extract<TerminalResponse, {
+    type: 'osc';
+}>;
+type XtversionResponse = Extract<TerminalResponse, {
+    type: 'xtversion';
+}>;
+/**
+ * DECRQM: request DEC private mode status (CSI ? mode $ p).
+ * Terminal replies with DECRPM (CSI ? mode ; status $ y) or ignores.
+ * @param mode - the DEC private mode number to query.
+ * @returns a query whose response is the DECRPM reply for mode.
+ */
+export declare function decrqm(mode: number): TerminalQuery<DecrpmResponse>;
+/**
+ * Primary Device Attributes query (CSI c). Every terminal answers this —
+ * used internally by flush() as a universal sentinel. Call directly if
+ * you want the DA1 params.
+ * @returns a query whose response is the DA1 reply.
+ */
+export declare function da1(): TerminalQuery<Da1Response>;
+/**
+ * Secondary Device Attributes query (CSI > c). Returns terminal version.
+ * @returns a query whose response is the DA2 reply.
+ */
+export declare function da2(): TerminalQuery<Da2Response>;
+/**
+ * Query current Kitty keyboard protocol flags (CSI ? u).
+ * Terminal replies with CSI ? flags u or ignores.
+ * @returns a query whose response is the Kitty keyboard reply.
+ */
+export declare function kittyKeyboard(): TerminalQuery<KittyResponse>;
+/**
+ * Query direct-data and zlib support for the Kitty graphics protocol with one
+ * transparent 1×1 RGBA pixel. The terminal echoes the image id in its reply.
+ */
+export declare function kittyGraphics(imageId: number): TerminalQuery<KittyGraphicsResponse>;
+/** XTWINOPS: query the physical pixel dimensions of one terminal cell. */
+export declare function terminalCellSizePixels(): TerminalQuery<TerminalPixelSizeResponse>;
+/** XTWINOPS: query the terminal text area's physical pixel dimensions. */
+export declare function terminalWindowSizePixels(): TerminalQuery<TerminalPixelSizeResponse>;
+/**
+ * DECXCPR: request cursor position with DEC-private marker (CSI ? 6 n).
+ * Terminal replies with CSI ? row ; col R. The `?` marker is critical —
+ * the plain DSR form (CSI 6 n → CSI row;col R) is ambiguous with
+ * modified F3 keys (Shift+F3 = CSI 1;2 R, etc.).
+ * @returns a query whose response is the cursor-position reply.
+ */
+export declare function cursorPosition(): TerminalQuery<CursorPosResponse>;
+/**
+ * OSC dynamic color query (e.g. OSC 11 for bg color, OSC 10 for fg).
+ * The `?` data slot asks the terminal to reply with the current value.
+ * @param code - the OSC color code to query (10 = fg, 11 = bg, etc.).
+ * @returns a query whose response is the OSC color reply.
+ */
+export declare function oscColor(code: number): TerminalQuery<OscResponse>;
+/**
+ * XTVERSION: request terminal name/version (CSI > 0 q).
+ * Terminal replies with DCS > | name ST (e.g. "xterm.js(5.5.0)") or ignores.
+ * This survives SSH — the query goes through the pty, not the environment,
+ * so it identifies the *client* terminal even when TERM_PROGRAM isn't
+ * forwarded. Used to detect xterm.js for wheel-scroll compensation.
+ * @returns a query whose response is the XTVERSION reply.
+ */
+export declare function xtversion(): TerminalQuery<XtversionResponse>;
+/**
+ * Sends terminal queries to stdout and resolves their responses, using a
+ * flush() sentinel barrier so queries never time out.
+ */
+export declare class TerminalQuerier {
+    private stdout;
+    private setRawMode?;
+    /**
+     * Interleaved queue of queries and sentinels in send order. Terminals
+     * respond in order, so each flush() barrier only drains queries queued
+     * before it — concurrent batches from independent callers stay isolated.
+     */
+    private queue;
+    /**
+     * Set by dispose(). Post-dispose send()/flush() must not touch the
+     * terminal: they would re-enable raw mode (holdRawMode) and emit query
+     * bytes after the exit funnel's cleanup has already restored cooked
+     * mode — the replies then leak into the shell (#507). Resolving as
+     * "no answer" keeps callers' .then() chains inert instead of pending.
+     */
+    private disposed;
+    private suspended;
+    constructor(stdout: NodeJS.WriteStream, setRawMode?: ((enabled: boolean) => void) | undefined);
+    /** Whether terminal query I/O is paused for an external process handoff. */
+    get isSuspended(): boolean;
+    private holdRawMode;
+    /**
+     * Send a query and wait for its response.
+     *
+     * Resolves with the response when `query.match` matches an incoming
+     * TerminalResponse, or with `undefined` when a flush() sentinel arrives
+     * before any matching response (meaning the terminal ignored the query).
+     *
+     * Never rejects; never times out on its own. If you never call flush()
+     * and the terminal doesn't respond, the promise remains pending.
+     * @param query - the query to send and await a response for.
+     * @returns the matched response, or undefined when the terminal did not
+     *   answer before the next flush() sentinel.
+     */
+    send<T extends TerminalResponse>(query: TerminalQuery<T>): Promise<T | undefined>;
+    /**
+     * Send the DA1 sentinel. Resolves when DA1's response arrives.
+     *
+     * As a side effect, all queries still pending when DA1 arrives are
+     * resolved with `undefined` (terminal didn't respond → doesn't support
+     * the query). This is the barrier that makes send() timeout-free.
+     *
+     * Safe to call with no pending queries — still waits for a round-trip.
+     */
+    flush(): Promise<void>;
+    flush(options: {
+        attributes: true;
+    }): Promise<Da1Response | undefined>;
+    /** Resolve and release all pending queries when their owning app unmounts. */
+    dispose(): void;
+    /**
+     * Dispatch a response parsed from stdin. Called by App.tsx's
+     * processKeysInBatch for every `kind: 'response'` item.
+     *
+     * Matching strategy:
+     * - First, try to match a pending query (FIFO, first match wins).
+     *   This lets callers send(da1()) explicitly if they want the DA1
+     *   params — a separate DA1 write means the terminal sends TWO DA1
+     *   responses. The first matches the explicit query; the second
+     *   (unmatched) fires the sentinel.
+     * - Otherwise, if this is a DA1, fire the FIRST pending sentinel:
+     *   resolve any queries queued before that sentinel with undefined
+     *   (the terminal answered DA1 without answering them → unsupported)
+     *   and signal its flush() completion. Only draining up to the first
+     *   sentinel keeps later batches intact when multiple callers have
+     *   concurrent queries in flight.
+     * - Unsolicited responses (no match, no sentinel) are silently dropped.
+     * @param r - the response parsed from stdin.
+     */
+    onResponse(r: TerminalResponse): void;
+    /**
+     * Resolve outstanding queries before stdin is handed to another process.
+     * Their replies can no longer be routed reliably once the child owns the
+     * terminal; later queries remain available after the handoff.
+     */
+    suspend(): void;
+    /** Resume queries after the caller's terminal-reply quarantine has ended. */
+    resume(): void;
+    private drainPending;
+}
+export {};
+//# sourceMappingURL=terminal-querier.d.ts.map

package/lib/types/ink/terminal-querier.d.ts.map

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