@toddzheng024/dscode-bundle 0.7.12 → 0.7.14

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

@@ -0,0 +1,239 @@
+/**
+ * The /update panel: one bounded surface over the launcher update
+ * pipeline. The panel never decides versions itself — it renders the
+ * launcher `update --json` probe (plan plus refusals), takes one
+ * confirmation, then streams `update --apply` progress and reports the
+ * result with a restart hint. Every alignment guarantee (host pinned to
+ * the release peers line, companion plugins carried, downgrade and
+ * local-checkout refusals) lives in the launcher and is only displayed
+ * here.
+ */
+import { createElement, useEffect, useState } from 'react';
+import { Box, Text, useInput, useStdout } from 'ink';
+import { clampScroll, panelViewport } from './render/inspector.mjs';
+import { singleLineText, truncateColumns } from './render/text.mjs';
+import { panelAccent } from './panel-accent.mjs';
+import { getPalette, inkColor } from './theme.mjs';
+import { t } from './i18n.mjs';
+/** Retained apply-progress lines (ring tail; npm output is ephemeral). */
+export const UPDATE_OUTPUT_CAP = 800;
+/** Keep the newest UPDATE_OUTPUT_CAP lines of streamed update output. */
+export function clipUpdateLines(lines) {
+    return lines.length <= UPDATE_OUTPUT_CAP ? lines : lines.slice(lines.length - UPDATE_OUTPUT_CAP);
+}
+/** Rendered facts of one probe: current/target versions, actions, refusals. */
+export function updatePlanView(status) {
+    const rows = [];
+    const latest = status.code.latest ?? 'unknown';
+    rows.push(status.aheadOfRegistry === true
+        ? { key: 'code', text: `dsh-code    ${status.code.running} (newer than npm ${latest})` }
+        : status.code.latest !== null && status.code.latest === status.code.running
+            ? { key: 'code', text: `dsh-code    ${status.code.running} (latest)` }
+            : { key: 'code', text: `dsh-code    ${status.code.running} → ${latest}` });
+    if (status.host.targetLine === null) {
+        rows.push({ key: 'host', text: 'harness     pinned line unreadable — update would install @deepseek-ai/dsh@latest', tone: 'warn' });
+    }
+    else if (status.host.installed === null) {
+        rows.push({ key: 'host', text: `harness     not installed → ${status.host.targetLine}` });
+    }
+    else if (status.host.installed === status.host.targetLine) {
+        rows.push({ key: 'host', text: `harness     ${status.host.installed} (on pinned line)` });
+    }
+    else {
+        rows.push({ key: 'host', text: `harness     ${status.host.installed} → ${status.host.targetLine}` });
+    }
+    const mounted = status.profile.mounted === null
+        ? status.profile.spec ?? 'not mounted'
+        : `dsh-code ${status.profile.mounted}`;
+    rows.push({
+        key: 'profile',
+        text: `profile     ${mounted}${status.profile.localCheckout ? ' · local checkout' : ''}`,
+        tone: status.profile.localCheckout ? 'dim' : undefined,
+    });
+    for (const plugin of status.plan.pluginSpecs) {
+        rows.push({ key: `plugin:${plugin}`, text: `plugin      ${plugin}`, tone: 'dim' });
+    }
+    // A blocker key may be absent entirely (JSON.stringify drops undefined);
+    // a missing value reads as "no blocker", never as an undefined row body.
+    const registryBlocker = status.blockers.registry ?? null;
+    if (registryBlocker !== null) {
+        rows.push({ key: 'blocker:registry', text: registryBlocker, tone: 'error' });
+    }
+    if (status.blockers.downgrade) {
+        rows.push({
+            key: 'blocker:downgrade',
+            text: `refusing to downgrade the host: dsh-code@${latest} needs ${status.host.targetLine ?? 'the pinned line'}, but ${status.host.installed ?? 'the installed host'} is newer — wait for the next dsh-code release`,
+            tone: 'error',
+        });
+    }
+    const checkoutBlocker = status.blockers.localCheckout ?? null;
+    if (checkoutBlocker !== null) {
+        for (const [index, line] of checkoutBlocker.entries()) {
+            rows.push({ key: `blocker:checkout:${index}`, text: line, tone: 'error' });
+        }
+    }
+    if (status.aheadOfRegistry === true) {
+        rows.push({ key: 'ahead', text: 'this install is newer than npm latest — refusing to downgrade', tone: 'warn' });
+    }
+    else if (status.upToDate) {
+        rows.push({ key: 'uptodate', text: 'everything is already on the pinned line — nothing to update', tone: 'ok' });
+    }
+    const runnable = status.upToDate !== true
+        && registryBlocker === null
+        && status.blockers.downgrade !== true
+        && checkoutBlocker === null;
+    return { rows, runnable };
+}
+/** Footer hint line per phase; the plan phase names the confirm key only when runnable. */
+export function updateFooter(phase, runnable, upToDate, aheadOfRegistry = false) {
+    if (phase === 'probe')
+        return t('panel.update.footer.probe');
+    if (phase === 'error')
+        return t('panel.update.footer.error');
+    if (phase === 'apply')
+        return t('panel.update.footer.apply');
+    if (phase === 'done')
+        return t('panel.update.footer.error');
+    if (aheadOfRegistry)
+        return t('panel.update.footer.ahead');
+    if (upToDate)
+        return t('panel.update.footer.current');
+    return runnable ? t('panel.update.footer.update') : t('panel.update.footer.blocked');
+}
+/**
+ * The /update surface: probe on open (and on r), confirm with enter/y,
+ * stream the aligned apply, and land on a bounded result view. Escape is
+ * locked while the apply child runs — killing npm mid-install is exactly
+ * the half-updated state this command exists to prevent.
+ */
+export function UpdatePanel({ probe, apply, close, notify }) {
+    const [phase, setPhase] = useState('probe');
+    const [status, setStatus] = useState();
+    const [probeError, setProbeError] = useState();
+    const [lines, setLines] = useState([]);
+    const [exit, setExit] = useState();
+    const [applyError, setApplyError] = useState();
+    // Viewport anchor: 'tail' follows new output; a number pins the first
+    // visible row (up moves away from the tail, down onto it re-follows).
+    const [anchor, setAnchor] = useState('tail');
+    const [epoch, setEpoch] = useState(0);
+    useEffect(() => {
+        let disposed = false;
+        setPhase('probe');
+        setStatus(undefined);
+        setProbeError(undefined);
+        setAnchor('tail');
+        probe().then(value => {
+            if (disposed)
+                return;
+            setStatus(value);
+            setPhase('plan');
+        }, reason => {
+            if (disposed)
+                return;
+            setProbeError(reason instanceof Error ? reason.message : String(reason));
+            setPhase('error');
+        });
+        return () => { disposed = true; };
+    }, [epoch, probe]);
+    const stdout = useStdout().stdout;
+    const viewport = panelViewport(stdout?.columns ?? 80, stdout?.rows ?? 30);
+    const start = () => {
+        if (phase !== 'plan' || status === undefined)
+            return;
+        if (!updatePlanView(status).runnable)
+            return;
+        setPhase('apply');
+        setLines([]);
+        setExit(undefined);
+        setApplyError(undefined);
+        setAnchor('tail');
+        apply(line => {
+            setLines(previous => clipUpdateLines([...previous, singleLineText(line)]));
+        }, status.plan).then(code => {
+            setExit(code);
+            setPhase('done');
+            notify(code === 0 ? 'update installed — restart dsh to activate' : `update failed (exit ${code})`, code === 0 ? 'info' : 'error');
+        }, reason => {
+            const message = reason instanceof Error ? reason.message : String(reason);
+            setApplyError(message);
+            setPhase('done');
+            notify(`update failed: ${message}`, 'error');
+        });
+    };
+    const planView = status === undefined ? undefined : updatePlanView(status);
+    const rows = phase === 'probe'
+        ? [{ key: 'probe', text: 'checking npm for the aligned update…', tone: 'dim' }]
+        : phase === 'error'
+            ? [{ key: 'error', text: singleLineText(probeError ?? 'probe failed'), tone: 'error' }]
+            : phase === 'plan' && planView !== undefined
+                ? planView.rows
+                : phase === 'apply'
+                    ? lines.map((line, index) => ({ key: `out:${index}`, text: line, tone: 'dim' }))
+                    : [
+                        ...(exit === 0 ? [{ key: 'ok', text: 'update installed — restart dsh to load the new version (/quit or ctrl+c)', tone: 'ok' }] : []),
+                        ...(exit !== undefined && exit !== 0 ? [{ key: 'fail', text: `update failed (exit ${exit})`, tone: 'error' }] : []),
+                        ...(applyError !== undefined ? [{ key: 'fail:start', text: singleLineText(applyError), tone: 'error' }] : []),
+                        ...lines.map((line, index) => ({ key: `out:${index}`, text: line, tone: 'dim' })),
+                    ];
+    const budget = Math.max(1, viewport.bodyRows);
+    const tailOffset = clampScroll(Math.max(0, rows.length - budget), rows.length, budget);
+    const offset = anchor === 'tail' ? tailOffset : clampScroll(anchor, rows.length, budget);
+    useInput((input, key) => {
+        if (phase === 'apply') {
+            // Scroll-only while the installer runs: escape stays locked.
+            if (key.upArrow)
+                setAnchor(offset <= 0 ? 0 : offset - 1);
+            if (key.downArrow && offset >= tailOffset)
+                setAnchor('tail');
+            else if (key.downArrow)
+                setAnchor(offset + 1);
+            return;
+        }
+        if (key.escape || input === 'q')
+            return close();
+        if (input === 'r') {
+            setEpoch(value => value + 1);
+            return;
+        }
+        if (key.return || input === 'y') {
+            void start();
+            return;
+        }
+        if (key.upArrow)
+            setAnchor(offset <= 0 ? 0 : offset - 1);
+        if (key.downArrow && offset >= tailOffset)
+            setAnchor('tail');
+        else if (key.downArrow)
+            setAnchor(offset + 1);
+    });
+    if (viewport.maxHeight === 0 || viewport.compact) {
+        const summary = phase === 'probe' ? t('panel.update.checking')
+            : phase === 'error' ? t('panel.update.probeFailed')
+                : phase === 'apply' ? singleLineText(lines[lines.length - 1] ?? t('panel.update.updating'))
+                    : phase === 'done' ? (exit === 0 ? t('panel.update.installed') : t('panel.update.failed'))
+                        : status?.aheadOfRegistry === true ? t('panel.update.aheadOfNpm') : status?.upToDate === true ? t('panel.update.upToDate') : planView?.runnable === true ? t('panel.update.enter') : t('panel.update.blocked');
+        return createElement(Text, { wrap: 'truncate-end' }, truncateColumns(singleLineText(t('panel.update.compact', { summary })), viewport.contentColumns));
+    }
+    const visible = rows.slice(offset, offset + budget);
+    const toneColor = (tone) => tone === 'ok'
+        ? inkColor(getPalette().success)
+        : tone === 'error'
+            ? inkColor(getPalette().error)
+            : tone === 'warn'
+                ? inkColor(getPalette().warn)
+                : tone === 'dim'
+                    ? inkColor(getPalette().dim)
+                    : undefined;
+    const title = status === undefined
+        ? t('panel.update.title')
+        : status.aheadOfRegistry === true
+            ? `/update · dsh-code ${status.code.running}`
+            : `/update · dsh-code ${status.code.running}${status.code.latest !== null && status.code.latest !== status.code.running ? ` → ${status.code.latest}` : ''}`;
+    const accent = panelAccent('update', getPalette().dim, getPalette().brandBright);
+    return createElement(Box, { width: viewport.outerColumns, borderStyle: 'round', borderColor: inkColor(accent.border), flexDirection: 'column', paddingX: 1 }, createElement(Text, { color: inkColor(accent.title), wrap: 'truncate-end' }, truncateColumns(singleLineText(title), viewport.contentColumns)), ...visible.map(row => createElement(Text, {
+        key: row.key,
+        color: toneColor(row.tone),
+        wrap: 'truncate-end',
+    }, truncateColumns(`  ${singleLineText(row.text)}`, viewport.contentColumns))), createElement(Text, { dimColor: true, wrap: 'truncate-end' }, truncateColumns(singleLineText(updateFooter(phase, planView?.runnable ?? false, status?.upToDate === true, status?.aheadOfRegistry === true)), viewport.contentColumns)));
+}

package/vendor/tui/lib/update.mjs

@@ -0,0 +1,101 @@
+/**
+ * Child-process adapter for the launcher update pipeline. The launcher
+ * (bin/deepseek.mjs) stays the single owner of update semantics — plan,
+ * guards, and the aligned install sequence — so the TUI only spawns
+ * `update --json` (read-only probe) and `update --apply` (streamed run)
+ * and never re-implements version-line decisions.
+ */
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+/** The launcher entrypoint that ships beside this bundle (lib/../bin). */
+export function launcherUpdateCommand(args, moduleUrl = import.meta.url) {
+    return { command: process.execPath, args: [fileURLToPath(new URL('../bin/deepseek.mjs', moduleUrl)), ...args] };
+}
+/**
+ * Split a streamed chunk sequence into complete display lines: CR is
+ * stripped, a chunk boundary may split a line, and the trailing partial
+ * stays pending until its newline arrives (npm writes whole lines, but a
+ * pipe may cut anywhere). Blank lines carry no progress information and
+ * are dropped so the panel budget is not spent on gaps.
+ */
+export function createLineSplitter(onLine) {
+    let pending = '';
+    return chunk => {
+        pending += chunk;
+        for (let index = pending.indexOf('\n'); index >= 0; index = pending.indexOf('\n')) {
+            const line = pending.slice(0, index).replace(/\r$/u, '');
+            pending = pending.slice(index + 1);
+            if (line !== '')
+                onLine(line);
+        }
+    };
+}
+/**
+ * Probe the aligned update status. Read-only: `update --json` never
+ * installs anything. The probe is bounded (npm view may hang on a broken
+ * network) and resolves with the parsed status.
+ */
+export async function probeLauncherUpdate(spawnProcess = spawn) {
+    const command = launcherUpdateCommand(['update', '--json']);
+    return await new Promise((resolve, reject) => {
+        const child = spawnProcess(command.command, command.args, { stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true });
+        const timer = setTimeout(() => {
+            child.kill();
+            reject(new Error('update probe timed out'));
+        }, 30_000);
+        let stdout = '';
+        let stderr = '';
+        child.stdout?.on('data', (chunk) => { stdout += chunk.toString(); });
+        child.stderr?.on('data', (chunk) => { stderr += chunk.toString(); });
+        child.once('error', error => {
+            clearTimeout(timer);
+            reject(new Error(`update probe failed to start: ${error.message}`));
+        });
+        child.once('exit', code => {
+            clearTimeout(timer);
+            if (code === 0) {
+                try {
+                    resolve(JSON.parse(stdout));
+                }
+                catch {
+                    reject(new Error('update probe returned an unreadable status'));
+                }
+                return;
+            }
+            const tail = stderr.trim().split(/\r?\n/u).pop() ?? '';
+            reject(new Error(`update probe failed${tail === '' ? '' : `: ${tail}`}`));
+        });
+    });
+}
+/**
+ * Run the aligned update (`update --apply`) as a child process and stream
+ * its sanitized progress lines to the caller. Resolves with the child
+ * exit code (0 success); rejects only when the process could not start.
+ * No timeout: an npm install may legitimately take minutes.
+ */
+export function applyPlanArgs(plan) {
+    const args = ['update', '--apply', '--dsh', plan.dshSpec, '--code', plan.codeSpec];
+    for (const plugin of plan.pluginSpecs)
+        args.push('--plugin', plugin);
+    return args;
+}
+export function applyLauncherUpdate(onLine, spawnProcess, plan) {
+    const spawnFn = spawnProcess ?? spawn;
+    const command = launcherUpdateCommand(plan === undefined ? ['update', '--apply'] : applyPlanArgs(plan));
+    return new Promise((resolve, reject) => {
+        const child = spawnFn(command.command, command.args, { stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true });
+        const split = createLineSplitter(onLine);
+        child.stdout?.on('data', (chunk) => { split(chunk.toString()); });
+        child.stderr?.on('data', (chunk) => { split(chunk.toString()); });
+        child.once('error', error => {
+            reject(new Error(`update failed to start: ${error.message}`));
+        });
+        // 'close' fires once the stdio streams have ended, so a final line the
+        // child left without its newline still reaches the panel; a bare '\n'
+        // flushes any pending partial without adding a blank row.
+        child.once('close', (code, signal) => {
+            split('\n');
+            resolve(code ?? (signal === null ? 0 : 1));
+        });
+    });
+}

package/vendor/tui/lib/version.mjs

@@ -0,0 +1,105 @@
+/** Installed dsh-code version exposed by the terminal header. */
+import { readFileSync, realpathSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, join, resolve } from 'node:path';
+/** Read one package manifest version without making terminal startup depend on it. */
+function readPackageVersion(manifest = new URL('../package.json', import.meta.url)) {
+    try {
+        const parsed = JSON.parse(readFileSync(manifest, 'utf8'));
+        return typeof parsed.version === 'string' && parsed.version.length > 0 ? parsed.version : '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+/** Version of the installed dsh-code package. */
+export const DSH_CODE_VERSION = readPackageVersion();
+/** The harness host package: the dsh CLI whose process runs the TUI plugin. */
+const DSH_HOST_PACKAGE_NAME = '@deepseek-ai/dsh';
+/** Parent levels above the host entry allowed to hold its package manifest. */
+const DSH_HOST_WALK_LIMIT = 4;
+/** Read `@deepseek-ai/dsh`'s version from a directory's package.json, or undefined. */
+function readHostVersion(directory) {
+    try {
+        const parsed = JSON.parse(readFileSync(join(directory, 'package.json'), 'utf8'));
+        if (parsed.name === DSH_HOST_PACKAGE_NAME && typeof parsed.version === 'string' && parsed.version.length > 0) {
+            return parsed.version;
+        }
+    }
+    catch {
+        // No readable host manifest at this level.
+    }
+    return undefined;
+}
+/** Climb from an entry file toward a host package.json. */
+function walkFrom(entry) {
+    let directory = dirname(resolve(entry));
+    for (let depth = 0; depth < DSH_HOST_WALK_LIMIT; depth += 1) {
+        const version = readHostVersion(directory);
+        if (version !== undefined)
+            return version;
+        const parent = dirname(directory);
+        if (parent === directory)
+            return undefined;
+        directory = parent;
+    }
+    return undefined;
+}
+/**
+ * Resolve the host package via Node's module lookup from an entry file.
+ * Covers global `bin/dsh` shims that are not inside the package tree.
+ */
+function resolveFromNode(from) {
+    try {
+        const manifest = createRequire(from).resolve(`${DSH_HOST_PACKAGE_NAME}/package.json`);
+        return readHostVersion(dirname(manifest));
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Resolve the running dsh CLI host's version from its entry file
+ * (`process.argv[1]`, e.g. `.../@deepseek-ai/dsh/lib/bin.js` or a PATH
+ * symlink `.../bin/dsh` → that file). Only a manifest literally named
+ * `@deepseek-ai/dsh` counts, so an unrelated entry (vitest, a plain node
+ * script) resolves to undefined instead of faking a kernel version.
+ */
+export function resolveDshHostVersion(entry = process.argv[1]) {
+    if (entry === undefined || entry === '')
+        return undefined;
+    const fromWalk = walkFrom(entry);
+    if (fromWalk !== undefined)
+        return fromWalk;
+    try {
+        const real = realpathSync(entry);
+        if (real !== resolve(entry)) {
+            const fromReal = walkFrom(real);
+            if (fromReal !== undefined)
+                return fromReal;
+        }
+    }
+    catch {
+        // Broken or missing symlink: fall through to Node resolution.
+    }
+    return resolveFromNode(resolve(entry));
+}
+let cachedDshKernelVersion;
+let dshKernelVersionResolved = false;
+/**
+ * The dsh kernel version the TUI runs on, memoized after the first probe: the
+ * host process never changes within a run, and the header reads this on every
+ * Static replay.
+ */
+export function dshKernelVersion() {
+    if (!dshKernelVersionResolved) {
+        cachedDshKernelVersion = resolveDshHostVersion();
+        dshKernelVersionResolved = true;
+    }
+    return cachedDshKernelVersion;
+}
+/** Test-only: forget the memoized kernel version so a new argv can be probed. */
+export function _resetDshKernelVersionForTests() {
+    cachedDshKernelVersion = undefined;
+    dshKernelVersionResolved = false;
+}

package/vendor/tui/lib/whale-glyph.mjs

@@ -0,0 +1,20 @@
+// GENERATED by scripts/gen-whale-glyph.ts — do not edit by hand. Rerun the
+// generator after changing the FishLogo path. Half-block rendering of the
+// DeepSeek fish logo (figma I39:24057;88:8943 fillGeometry, exact extract;
+// native 23.16x17.04 → 26 columns × 8 half-block rows).
+// Blank cells are part of the glyph's fixed 26-column grid: pad, never trim.
+/** Half-block whale glyph rows; render with the brand color. */
+export const WHALE_GLYPH = [
+    '    ▄▄▄▄▄▄▄▄█    ▄█▄     ▄',
+    ' ▄▄██████████▄▄  ▀███▄████',
+    '▄███████████████▄  ███▀▀▀ ',
+    '██     ▀▀█████▄▀██████    ',
+    '██▄       ▀████▄▄████     ',
+    ' ██▄        ▀██████▀      ',
+    '  ▀██▄▄  ██▄  ▀███▄▄      ',
+    '     ▀▀███████▀▀ ▀▀▀      ',
+];
+/** Fixed glyph width in terminal columns. */
+export const WHALE_GLYPH_COLUMNS = 26;
+/** Fixed glyph height in half-block rows. */
+export const WHALE_GLYPH_ROWS = 8;

package/vendor/tui/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 unlinearity
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.