@toddzheng024/dscode-bundle 0.7.11 → 0.7.13

package/vendor/tui/lib/approval.mjs

@@ -0,0 +1,122 @@
+/**
+ * The terminal approval answerer: one `approval/request` waterfall listener
+ * that renders the pending question as a y/n bar and resolves the decision
+ * back into the waterfall. Mirrors the web host's composer takeover — the
+ * service (audit pair, policy gate, fail-closed defaults) all live in
+ * dsh-base; this module only answers for agents this TUI owns.
+ *
+ * Vocabulary note: a client answerer may only ever resolve `'allowed-once'`
+ * or `'rejected'`; `'cancelled'` belongs to the request signal and
+ * `'unavailable'` to the fail-closed waterfall default.
+ *
+ * @module @deepseek-ai/dsh-code/approval
+ */
+/**
+ * Create the approval store and mount the answerer listener on the context.
+ * The listener claims only requests for `owns`-owned agents and defers every
+ * other request back into the waterfall (`next()`), so sibling answerers stay
+ * usable. An aborted ask never reaches the human. Plugin teardown removes the
+ * listener; the service then fails its own question closed.
+ * @param ctx - plugin context whose event bus carries `approval/request`.
+ * @param owns - agents this terminal answers for.
+ * @param preview - resolves a tool-call preview for a pending request (the
+ * request contract carries no arguments; the UI self-serves from the
+ * transcript projection via `callId`).
+ * @returns the store the renderer subscribes to.
+ */
+export function mountApprovalAnswerer(ctx, owns, preview) {
+    const queue = [];
+    let snapshot = { pending: undefined, answered: false, queued: 0 };
+    const listeners = new Set();
+    const publish = () => {
+        const head = queue[0];
+        snapshot = {
+            pending: head === undefined ? undefined : head.pending,
+            answered: head !== undefined && head.answered,
+            queued: Math.max(0, queue.length - 1),
+        };
+        for (const listener of listeners)
+            listener();
+    };
+    const removeSlot = (slot) => {
+        const at = queue.indexOf(slot);
+        if (at !== -1)
+            queue.splice(at, 1);
+    };
+    ctx.on('approval/request', (request, next) => {
+        if (!owns(request.agent))
+            return next();
+        // An already-aborted ask never reaches the human (mirrors the host bridge).
+        if (request.signal?.aborted === true)
+            return Promise.resolve('cancelled');
+        let resolved = false;
+        let settle;
+        // Established BEFORE the abort listener mounts: a synchronous throw
+        // between the listener registration and a later construction site would
+        // otherwise leave a subsequent abort invoking an unassigned settle from
+        // inside the AbortSignal listener (an uncaughtException).
+        const settled = new Promise((resolve) => {
+            settle = resolve;
+        });
+        const signal = request.signal;
+        const onAbort = () => withdraw();
+        // Detach on every settle so an answered ask never retains a listener on
+        // the tool call's signal (long turns ask many times; each ask must let go).
+        const detachAbort = () => {
+            if (signal !== undefined)
+                signal.removeEventListener('abort', onAbort);
+        };
+        const withdraw = () => {
+            if (resolved)
+                return;
+            resolved = true;
+            detachAbort();
+            removeSlot(slot);
+            publish();
+            // The service's signal race would conclude 'cancelled' anyway; settle
+            // the same way so this listener never dangles a pending promise.
+            settle('cancelled');
+        };
+        if (signal !== undefined) {
+            signal.addEventListener('abort', onAbort, { once: true });
+        }
+        const slot = {
+            answered: false,
+            pending: {
+                headline: request.reason ?? `tool ${request.toolName} asks for your approval`,
+                toolName: request.toolName,
+                command: preview(request),
+                answer: (outcome) => {
+                    // One-shot latch: a second keypress after submission is inert.
+                    if (resolved)
+                        return;
+                    resolved = true;
+                    detachAbort();
+                    slot.answered = true;
+                    publish();
+                    settle(outcome);
+                },
+            },
+        };
+        queue.push(slot);
+        publish();
+        return settled.then((outcome) => {
+            if (outcome !== 'cancelled') {
+                removeSlot(slot);
+                publish();
+            }
+            return outcome;
+        });
+    });
+    return {
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+        getSnapshot() {
+            return snapshot;
+        },
+    };
+}

package/vendor/tui/lib/attachments.mjs

@@ -0,0 +1,218 @@
+/** Terminal image- and file-attachment adapter over the Harness durable attachment service. */
+import { open, readFile, stat } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import { basename, extname, isAbsolute, resolve } from 'node:path';
+/**
+ * Terminal-side file admission bounds. Upstream exposes image limits through
+ * the attachment service but no file limits (files ride verbatim storage);
+ * these keep a dragged file from silently ingesting a disk-sized blob and
+ * bound one message the way the image batch is bounded.
+ */
+export const MAX_FILE_BYTES = 8 * 1024 * 1024;
+export const MAX_FILES_PER_MESSAGE = 8;
+const IMAGE_EXTENSIONS = new Set(['.png', '.jpg', '.jpeg', '.webp', '.gif']);
+/** Detect the supported encoded raster formats from bytes, never from a path suffix. */
+export function detectImageMediaType(data) {
+    if (data.length >= 8 && data[0] === 0x89 && data[1] === 0x50 && data[2] === 0x4e && data[3] === 0x47
+        && data[4] === 0x0d && data[5] === 0x0a && data[6] === 0x1a && data[7] === 0x0a)
+        return 'image/png';
+    if (data.length >= 3 && data[0] === 0xff && data[1] === 0xd8 && data[2] === 0xff)
+        return 'image/jpeg';
+    if (data.length >= 6) {
+        const signature = String.fromCharCode(...data.subarray(0, 6));
+        if (signature === 'GIF87a' || signature === 'GIF89a')
+            return 'image/gif';
+    }
+    if (data.length >= 12
+        && String.fromCharCode(...data.subarray(0, 4)) === 'RIFF'
+        && String.fromCharCode(...data.subarray(8, 12)) === 'WEBP')
+        return 'image/webp';
+    return undefined;
+}
+/** Whether a path-like token is worth probing as an image attachment. */
+export function looksLikeImagePath(path) {
+    return IMAGE_EXTENSIONS.has(extname(path).toLowerCase());
+}
+/**
+ * Parse a paste/drop into its image and file paths: image-suffixed tokens
+ * stay images, other path-shaped tokens ride as file attachments (0.1.5
+ * file blocks), and anything that is neither leaves both empty — the caller
+ * then treats the paste as plain text.
+ *
+ * File tokens are held to an absolute-path-with-shape bar (drive/backslash
+ * or a dot-suffixed leaf after a separator): a dropped terminal path always
+ * carries one of those, while prose, slash commands, and option flags never
+ * do. A POSIX absolute path without any dot-suffixed leaf falls through as
+ * text — the @ mention route still attaches such files deliberately.
+ */
+export function parsePastedAttachmentPaths(input) {
+    const text = input.trim();
+    if (text === '')
+        return { images: [], files: [] };
+    const images = [];
+    const files = [];
+    const looksLikeDroppedFile = (path) => /^[A-Za-z]:[\\/]/u.test(path)
+        || /^\\\\/u.test(path)
+        || (/^\/|^\.\.?\//u.test(path) && /\.[A-Za-z0-9]{1,16}$/u.test(path));
+    const matcher = /"([^"]+)"|'([^']+)'|(\S+)/gu;
+    for (const match of text.matchAll(matcher)) {
+        const token = match[1] ?? match[2] ?? match[3];
+        if (token === undefined)
+            continue;
+        let path = token;
+        if (path.startsWith('file://')) {
+            try {
+                path = fileURLToPath(path);
+            }
+            catch {
+                return { images: [], files: [] };
+            }
+            if (looksLikeImagePath(path))
+                images.push(path);
+            else
+                files.push(path);
+            continue;
+        }
+        if (looksLikeImagePath(path)) {
+            images.push(path);
+            continue;
+        }
+        if (!looksLikeDroppedFile(path))
+            return { images: [], files: [] };
+        files.push(path);
+    }
+    return { images, files };
+}
+/** Validate path, byte size and encoded signature without writing an attachment object. */
+export async function inspectImagePaths(paths, attachments, cwd = process.cwd()) {
+    if (paths.length === 0)
+        return [];
+    if (attachments === undefined)
+        throw new Error('image attachments are unavailable in this profile');
+    if (paths.length > attachments.imageLimits.maxImagesPerMessage) {
+        throw new Error(`too many images (${paths.length}; limit ${attachments.imageLimits.maxImagesPerMessage})`);
+    }
+    const inspected = [];
+    let totalBytes = 0;
+    for (const raw of paths) {
+        const path = isAbsolute(raw) ? resolve(raw) : resolve(cwd, raw);
+        let facts;
+        try {
+            facts = await stat(path);
+        }
+        catch (error) {
+            throw new Error(`cannot read image "${raw}": ${error instanceof Error ? error.message : String(error)}`);
+        }
+        if (!facts.isFile())
+            throw new Error(`image path is not a file: "${raw}"`);
+        if (facts.size > attachments.imageLimits.maxImageBytes) {
+            throw new Error(`image "${basename(path)}" is ${facts.size} bytes; limit ${attachments.imageLimits.maxImageBytes}`);
+        }
+        totalBytes += facts.size;
+        if (totalBytes > attachments.imageLimits.maxMessageImageBytes) {
+            throw new Error(`image batch is ${totalBytes} bytes; limit ${attachments.imageLimits.maxMessageImageBytes}`);
+        }
+        const handle = await open(path, 'r');
+        try {
+            const signature = new Uint8Array(16);
+            const { bytesRead } = await handle.read(signature, 0, signature.length, 0);
+            const mediaType = detectImageMediaType(signature.subarray(0, bytesRead));
+            if (mediaType === undefined || !attachments.imageLimits.mediaTypes.includes(mediaType)) {
+                throw new Error(`unsupported image file "${raw}" (expected PNG, JPEG, WebP, or GIF)`);
+            }
+            inspected.push({ path, name: basename(path), mediaType, bytes: facts.size });
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    return inspected;
+}
+/** Read, validate, and persist an ordered image path list as model content blocks. */
+export async function saveImagePaths(paths, attachments, signal) {
+    if (paths.length === 0)
+        return [];
+    if (attachments === undefined)
+        throw new Error('image attachments are unavailable in this profile');
+    const checkCancelled = () => {
+        if (signal?.aborted === true)
+            throw new Error('image submission cancelled');
+    };
+    const inputs = [];
+    for (const path of paths) {
+        checkCancelled();
+        let data;
+        try {
+            data = await readFile(path);
+        }
+        catch (error) {
+            throw new Error(`cannot read image "${path}": ${error instanceof Error ? error.message : String(error)}`);
+        }
+        const mediaType = detectImageMediaType(data);
+        if (mediaType === undefined)
+            throw new Error(`unsupported image file "${path}" (expected PNG, JPEG, WebP, or GIF)`);
+        inputs.push({ data, mediaType, name: basename(path) });
+    }
+    checkCancelled();
+    const refs = await attachments.saveImages(inputs);
+    checkCancelled();
+    return refs.map(attachment => ({ type: 'image', attachment }));
+}
+/** Validate path and byte size for non-image file attachments without writing. */
+export async function inspectFilePaths(paths, attachments, cwd = process.cwd()) {
+    if (paths.length === 0)
+        return [];
+    if (attachments === undefined)
+        throw new Error('file attachments are unavailable in this profile');
+    if (paths.length > MAX_FILES_PER_MESSAGE) {
+        throw new Error(`too many files (${paths.length}; limit ${MAX_FILES_PER_MESSAGE})`);
+    }
+    const inspected = [];
+    for (const raw of paths) {
+        const path = isAbsolute(raw) ? resolve(raw) : resolve(cwd, raw);
+        let facts;
+        try {
+            facts = await stat(path);
+        }
+        catch (error) {
+            throw new Error(`cannot read file "${raw}": ${error instanceof Error ? error.message : String(error)}`);
+        }
+        if (!facts.isFile())
+            throw new Error(`file path is not a file: "${raw}"`);
+        if (facts.size > MAX_FILE_BYTES) {
+            throw new Error(`file "${basename(path)}" is ${facts.size} bytes; limit ${MAX_FILE_BYTES}`);
+        }
+        inspected.push({ path, name: basename(path), bytes: facts.size });
+    }
+    return inspected;
+}
+/** Read and persist an ordered non-image file path list as model file blocks. */
+export async function saveFilePaths(paths, attachments, signal) {
+    if (paths.length === 0)
+        return [];
+    if (attachments === undefined)
+        throw new Error('file attachments are unavailable in this profile');
+    // The bounds are re-checked here so a draft inspected earlier still guards
+    // the actual read at submission time.
+    await inspectFilePaths(paths, attachments);
+    const checkCancelled = () => {
+        if (signal?.aborted === true)
+            throw new Error('file submission cancelled');
+    };
+    const inputs = [];
+    for (const path of paths) {
+        checkCancelled();
+        let data;
+        try {
+            data = await readFile(path);
+        }
+        catch (error) {
+            throw new Error(`cannot read file "${path}": ${error instanceof Error ? error.message : String(error)}`);
+        }
+        inputs.push({ data, name: basename(path) });
+    }
+    checkCancelled();
+    const refs = await Promise.all(inputs.map(input => attachments.saveFile(input)));
+    checkCancelled();
+    return refs.map(attachment => ({ type: 'file', attachment }));
+}

package/vendor/tui/lib/authorization-panel.mjs

@@ -0,0 +1,242 @@
+/** Bounded Ink surfaces for provider login and logout. */
+import { createElement, useEffect, useRef, useState } from 'react';
+import { Box, Text, useInput, useStdout } from 'ink';
+import { AuthorizationDeclinedError, } from '@deepseek-ai/dsh-authorization';
+import { panelViewport } from './render/inspector.mjs';
+import { displayText, singleLineText, truncateColumns } from './render/text.mjs';
+import { panelAccent } from './panel-accent.mjs';
+import { getPalette, inkColor } from './theme.mjs';
+import { t } from './i18n.mjs';
+/** Run one upstream authorization flow without letting notices or prompts exceed the panel budget. */
+export function ProviderAuthorizationPanel(props) {
+    const stdout = useStdout().stdout;
+    const viewport = panelViewport(stdout?.columns ?? 80, stdout?.rows ?? 30);
+    const [phase, setPhase] = useState('methods');
+    const [cursor, setCursor] = useState(0);
+    const [notices, setNotices] = useState([]);
+    const [prompt, setPrompt] = useState(undefined);
+    const [draft, setDraft] = useState('');
+    const [promptCursor, setPromptCursor] = useState(0);
+    const [error, setError] = useState(undefined);
+    const [copyState, setCopyState] = useState(undefined);
+    const controllerRef = useRef(undefined);
+    const replyRef = useRef(undefined);
+    const openedUrls = useRef(new Set());
+    const clearReply = () => {
+        replyRef.current?.detach();
+        replyRef.current = undefined;
+        setPrompt(undefined);
+        setDraft('');
+        setPromptCursor(0);
+    };
+    const decline = () => {
+        const reply = replyRef.current;
+        clearReply();
+        reply?.reject(new AuthorizationDeclinedError());
+    };
+    const stop = () => {
+        controllerRef.current?.abort();
+        controllerRef.current = undefined;
+        props.cancel(props.row.key);
+        decline();
+    };
+    useEffect(() => () => {
+        controllerRef.current?.abort();
+        props.cancel(props.row.key);
+        const reply = replyRef.current;
+        replyRef.current = undefined;
+        reply?.detach();
+        reply?.reject(new AuthorizationDeclinedError());
+    }, [props.row.key]);
+    const start = (method) => {
+        setPhase('running');
+        setError(undefined);
+        setNotices([]);
+        setCopyState(undefined);
+        const controller = new AbortController();
+        controllerRef.current = controller;
+        const interaction = {
+            notify(notice) {
+                setNotices(current => [...current.slice(-19), notice]);
+                if (notice.url !== undefined && !openedUrls.current.has(notice.url)) {
+                    openedUrls.current.add(notice.url);
+                    props.openUrl(notice.url);
+                }
+            },
+            prompt(next) {
+                return new Promise((resolve, reject) => {
+                    const onWithdraw = () => {
+                        if (replyRef.current?.reject !== reject)
+                            return;
+                        clearReply();
+                        reject(new Error('authorization prompt was withdrawn'));
+                    };
+                    next.signal?.addEventListener('abort', onWithdraw, { once: true });
+                    replyRef.current = {
+                        resolve,
+                        reject,
+                        detach: () => next.signal?.removeEventListener('abort', onWithdraw),
+                    };
+                    setPrompt(next);
+                    setDraft('');
+                    setPromptCursor(0);
+                });
+            },
+        };
+        void props.begin(props.row, method, interaction, controller.signal).then((status) => {
+            controllerRef.current = undefined;
+            clearReply();
+            if (status === 'authorized')
+                props.done();
+            else
+                props.back();
+        }, (reason) => {
+            controllerRef.current = undefined;
+            clearReply();
+            if (controller.signal.aborted) {
+                props.back();
+                return;
+            }
+            setError(reason instanceof Error ? reason.message : String(reason));
+            setPhase('methods');
+        });
+    };
+    const answer = (value) => {
+        const reply = replyRef.current;
+        clearReply();
+        reply?.resolve(value);
+    };
+    useInput((input, key) => {
+        if (phase === 'methods') {
+            if (key.escape || input === 'q') {
+                props.back();
+                return;
+            }
+            if (props.row.methods.length === 0)
+                return;
+            if (key.upArrow) {
+                setCursor(current => (current + props.row.methods.length - 1) % props.row.methods.length);
+                return;
+            }
+            if (key.downArrow) {
+                setCursor(current => (current + 1) % props.row.methods.length);
+                return;
+            }
+            if (key.return)
+                start(props.row.methods[cursor]?.id ?? props.row.methods[0].id);
+            return;
+        }
+        if (key.escape) {
+            stop();
+            props.back();
+            return;
+        }
+        const copyValue = notices.at(-1)?.code ?? notices.at(-1)?.url;
+        if ((input === 'c' || input === 'C') && copyValue !== undefined) {
+            void props.copy(copyValue).then(() => setCopyState('copied'), reason => setCopyState(`copy failed: ${reason instanceof Error ? reason.message : String(reason)}`));
+            return;
+        }
+        if (prompt === undefined)
+            return;
+        if (prompt.kind === 'select') {
+            if (prompt.options.length === 0)
+                return;
+            if (key.upArrow) {
+                setPromptCursor(current => (current + prompt.options.length - 1) % prompt.options.length);
+                return;
+            }
+            if (key.downArrow) {
+                setPromptCursor(current => (current + 1) % prompt.options.length);
+                return;
+            }
+            if (key.return)
+                answer(prompt.options[promptCursor]?.id ?? prompt.options[0].id);
+            return;
+        }
+        if (key.backspace || key.delete) {
+            setDraft(current => [...current].slice(0, -1).join(''));
+            return;
+        }
+        if (key.return) {
+            if (draft.trim() !== '')
+                answer(draft);
+            return;
+        }
+        if (input !== '' && !key.ctrl && !key.meta)
+            setDraft(current => current + input);
+    });
+    if (viewport.maxHeight === 0 || viewport.compact) {
+        return createElement(Text, { wrap: 'truncate-end' }, truncateColumns(t('panel.auth.compact'), viewport.contentColumns));
+    }
+    const rows = [];
+    if (phase === 'methods') {
+        if (error !== undefined)
+            rows.push({ key: 'error', text: `  ${singleLineText(error)}`, color: inkColor(getPalette().error) });
+        props.row.methods.forEach((method, index) => {
+            rows.push({
+                key: method.id,
+                text: `${index === cursor ? '› ' : '  '}${displayText(method.label)}`,
+                color: inkColor(index === cursor ? getPalette().brandBright : getPalette().dim),
+            });
+        });
+    }
+    else {
+        notices.forEach((notice, index) => {
+            rows.push({ key: `notice-${index}`, text: `  ${displayText(notice.message)}` });
+            if (notice.url !== undefined)
+                rows.push({ key: `url-${index}`, text: `  ${displayText(notice.url)}`, color: inkColor(getPalette().brandBright) });
+            if (notice.code !== undefined)
+                rows.push({ key: `code-${index}`, text: `  code ${displayText(notice.code)}`, color: inkColor(getPalette().success), bold: true });
+        });
+        if (prompt !== undefined) {
+            rows.push({ key: 'prompt', text: `  ${displayText(prompt.message)}`, color: inkColor(getPalette().brandBright) });
+            if (prompt.kind === 'select') {
+                prompt.options.forEach((option, index) => rows.push({
+                    key: `option-${option.id}`,
+                    text: `${index === promptCursor ? '› ' : '  '}${displayText(option.label)}${option.description === undefined ? '' : ` · ${displayText(option.description)}`}`,
+                    color: inkColor(index === promptCursor ? getPalette().brandBright : getPalette().dim),
+                }));
+            }
+            else {
+                const shown = prompt.kind === 'secret' ? '•'.repeat([...draft].length) : displayText(draft);
+                rows.push({ key: 'draft', text: `  ${shown}▏`, color: inkColor(getPalette().text) });
+            }
+        }
+        else {
+            rows.push({ key: 'waiting', text: `  ${t('panel.auth.waiting')}`, color: inkColor(getPalette().dim) });
+        }
+        if (copyState !== undefined)
+            rows.push({ key: 'copy', text: `  ${singleLineText(copyState)}`, color: inkColor(copyState === 'copied' ? getPalette().success : getPalette().error) });
+    }
+    const visible = rows.slice(Math.max(0, rows.length - viewport.bodyRows));
+    const footer = phase === 'methods'
+        ? t('panel.auth.methodsFooter')
+        : t('panel.auth.answerFooter');
+    const accent = panelAccent('auth-login', getPalette().brand);
+    return createElement(Box, { flexDirection: 'column', width: viewport.outerColumns, paddingX: 1, borderStyle: 'round', borderColor: inkColor(accent.border) }, createElement(Text, { color: inkColor(accent.title), bold: true, wrap: 'truncate-end' }, truncateColumns(t('panel.auth.title', { provider: displayText(props.row.label) }), viewport.contentColumns)), ...visible.map(row => createElement(Text, { key: row.key, color: row.color, bold: row.bold, wrap: 'truncate-end' }, truncateColumns(row.text, viewport.contentColumns))), createElement(Text, { color: inkColor(getPalette().dim), wrap: 'truncate-end' }, truncateColumns(footer, viewport.contentColumns)));
+}
+export function ProviderAuthorizationLogoutPanel({ row, confirm, done, back }) {
+    const stdout = useStdout().stdout;
+    const viewport = panelViewport(stdout?.columns ?? 80, stdout?.rows ?? 30);
+    const [busy, setBusy] = useState(false);
+    const [error, setError] = useState(undefined);
+    useInput((input, key) => {
+        if (busy)
+            return;
+        if (key.escape || input === 'n' || input === 'N') {
+            back();
+            return;
+        }
+        if (input !== 'y' && input !== 'Y')
+            return;
+        setBusy(true);
+        setError(undefined);
+        void confirm(row).then(done, (reason) => {
+            setBusy(false);
+            setError(reason instanceof Error ? reason.message : String(reason));
+        });
+    });
+    if (viewport.maxHeight === 0 || viewport.compact)
+        return createElement(Text, { wrap: 'truncate-end' }, truncateColumns(t('panel.auth.logoutCompact'), viewport.contentColumns));
+    return createElement(Box, { flexDirection: 'column', width: viewport.outerColumns, paddingX: 1, borderStyle: 'round', borderColor: inkColor(getPalette().warn) }, createElement(Text, { color: inkColor(getPalette().warn), bold: true, wrap: 'truncate-end' }, truncateColumns(t('panel.auth.logoutTitle'), viewport.contentColumns)), createElement(Text, { wrap: 'truncate-end' }, truncateColumns(`  ${t('panel.auth.removeRecord', { provider: displayText(row.label) })}`, viewport.contentColumns)), createElement(Text, { color: inkColor(getPalette().dim), wrap: 'truncate-end' }, truncateColumns(`  ${t('panel.auth.unchanged')}`, viewport.contentColumns)), error === undefined ? undefined : createElement(Text, { color: inkColor(getPalette().error), wrap: 'truncate-end' }, truncateColumns(`  ${singleLineText(error)}`, viewport.contentColumns)), createElement(Text, { color: inkColor(getPalette().dim), wrap: 'truncate-end' }, truncateColumns(busy ? t('panel.auth.working') : t('panel.auth.logoutFooter'), viewport.contentColumns)));
+}