@dsh-workbench/shared 0.1.12 → 0.1.14

package/dist/components/ChoiceGroup.css

@@ -10,6 +10,7 @@
 }
 
 .wb-choiceOption {
+  position: relative;
   display: flex;
   align-items: center;
   gap: var(--wb-len-6);
@@ -22,6 +23,54 @@
   color: var(--dsw-alias-label-primary);
 }
 
+.wb-choiceOptionOn {
+  background: var(--dsw-alias-interactive-bg-hover);
+}
+
+.wb-checkbox {
+  position: absolute;
+  width: var(--wb-len-16);
+  height: var(--wb-len-16);
+  margin: 0;
+  opacity: 0;
+  pointer-events: none;
+}
+
+.wb-checkboxBox {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  box-sizing: border-box;
+  flex: none;
+  width: var(--wb-len-16);
+  height: var(--wb-len-16);
+  border: 1px solid var(--dsw-alias-border-l3);
+  border-radius: var(--dsw-radius-xs);
+  corner-shape: round;
+  color: var(--dsw-alias-label-primary-foreground);
+  transition:
+    background-color var(--wb-dur-0-12) ease, border-color var(--wb-dur-0-12) ease;
+}
+
+.wb-choiceOption:hover .wb-checkboxBox {
+  border-color: var(--dsw-alias-label-tertiary);
+}
+
+.wb-checkbox:checked + .wb-checkboxBox {
+  border-color: var(--dsw-alias-brand-primary);
+  background: var(--dsw-alias-brand-primary);
+}
+
+.wb-checkbox:disabled + .wb-checkboxBox {
+  opacity: 0.5;
+}
+
+.wb-checkbox:focus-visible + .wb-checkboxBox {
+  outline: var(--dsw-focus-ring-width, var(--wb-len-2)) solid
+    var(--dsw-focus-ring-color, var(--dsw-alias-state-business-primary));
+  outline-offset: 2px;
+}
+
 .wb-choiceOption:hover {
   background: var(--dsw-alias-interactive-bg-hover);
 }

package/dist/components/ChoiceGroup.d.ts

@@ -4,12 +4,22 @@ export interface ChoiceGroupOption {
     readonly value: string;
     readonly label: ReactNode;
 }
-export interface ChoiceGroupProps {
+interface ChoiceGroupCommon {
     readonly label: string;
     readonly name: string;
-    readonly value: string;
     readonly options: readonly ChoiceGroupOption[];
     readonly disabled?: boolean | undefined;
+}
+export interface ChoiceGroupSingleProps extends ChoiceGroupCommon {
+    readonly multi?: false | undefined;
+    readonly value: string;
     readonly onChange: (next: string) => void;
 }
-export declare function ChoiceGroup({ label, name, value, options, disabled, onChange }: ChoiceGroupProps): JSX.Element;
+export interface ChoiceGroupMultiProps extends ChoiceGroupCommon {
+    readonly multi: true;
+    readonly values: readonly string[];
+    readonly onChange: (next: readonly string[]) => void;
+}
+export type ChoiceGroupProps = ChoiceGroupSingleProps | ChoiceGroupMultiProps;
+export declare function ChoiceGroup(props: ChoiceGroupProps): JSX.Element;
+export {};

package/dist/components/ChoiceGroup.js

@@ -1,8 +1,41 @@
 import { Fragment, h } from '../lib/react.js';
+import { IconCheckOutlineRegular } from '@deepseek-ai/dsh-client-ui-primitives';
 import './ChoiceGroup.css';
-export function ChoiceGroup({ label, name, value, options, disabled, onChange }) {
-    return (h("div", { className: "wb-choiceMenu", role: "radiogroup", "aria-label": label }, options.map((option) => (h(Fragment, { key: option.value },
-        h("label", { className: "wb-choiceOption" },
-            h("input", { className: "wb-radio", type: "radio", name: name, checked: option.value === value, disabled: disabled === true, onChange: () => onChange(option.value) }),
-            h("span", { className: "wb-choiceLabel" }, option.label)))))));
+function ChoiceMenu(input) {
+    return (h("div", { className: "wb-choiceMenu", role: input.multi ? 'group' : 'radiogroup', "aria-label": input.label }, input.options.map((option) => {
+        const row = input.rowOf(option.value);
+        return (h(Fragment, { key: option.value },
+            h("label", { className: `wb-choiceOption${row.checked ? ' wb-choiceOptionOn' : ''}` },
+                h("input", { className: input.multi ? 'wb-checkbox' : 'wb-radio', type: input.multi ? 'checkbox' : 'radio', name: input.name, checked: row.checked, disabled: input.disabled, onChange: row.onSelect }),
+                input.multi ? (h("span", { className: "wb-checkboxBox", "aria-hidden": "true" }, row.checked ? h(IconCheckOutlineRegular, { size: 12 }) : null)) : null,
+                h("span", { className: "wb-choiceLabel" }, option.label))));
+    })));
+}
+export function ChoiceGroup(props) {
+    const common = {
+        label: props.label,
+        name: props.name,
+        options: props.options,
+        disabled: props.disabled === true,
+    };
+    if (props.multi === true) {
+        const values = props.values;
+        const onChange = props.onChange;
+        return (h(ChoiceMenu, { label: common.label, name: common.name, options: common.options, disabled: common.disabled, multi: true, rowOf: (value) => ({
+                checked: values.includes(value),
+                onSelect: () => {
+                    onChange(values.includes(value)
+                        ? values.filter((one) => one !== value)
+                        : [...values, value]);
+                },
+            }) }));
+    }
+    const value = props.value;
+    const onChange = props.onChange;
+    return (h(ChoiceMenu, { label: common.label, name: common.name, options: common.options, disabled: common.disabled, multi: false, rowOf: (option) => ({
+            checked: option === value,
+            onSelect: () => {
+                onChange(option);
+            },
+        }) }));
 }

package/dist/components/StateDot.d.ts

@@ -0,0 +1,5 @@
+export type DotState = 'ongoing' | 'warning' | 'done' | 'idle' | string;
+export declare function StateDot({ state, size }: {
+    state: DotState;
+    size: number;
+}): JSX.Element;

package/dist/components/StateDot.js

@@ -0,0 +1,10 @@
+import { h } from '../lib/react.js';
+export function StateDot({ state, size }) {
+    if (state === 'ongoing') {
+        return (h("svg", { className: "wb-loading", viewBox: "0 0 24 24", width: size, height: size, "aria-hidden": "true", style: { display: 'block' } },
+            h("g", { className: "wb-loadingMotion" },
+                h("circle", { className: "wb-loadingTrack", cx: 12, cy: 12, r: 9.5 }),
+                h("circle", { className: "wb-loadingArc", cx: 12, cy: 12, r: 9.5 }))));
+    }
+    return (h("span", { className: "wb-stateDot", "data-state": state, style: { width: size, height: size }, "aria-hidden": "true" }));
+}

package/dist/host/__tests__/fakes.d.ts

@@ -0,0 +1,41 @@
+import type { DshShell } from '../../api/dsh.js';
+import type { Opencli } from '../../host/opencli.js';
+export interface ShellCall {
+    command: string;
+    workdir?: string;
+    timeoutMs?: number;
+    onExpiry?: string;
+    stdoutMaxBytes?: number;
+}
+export interface ShellReply {
+    stdout?: string;
+    stderr?: string;
+    exitCode?: number | null;
+    timedOut?: boolean;
+    aborted?: boolean;
+    failWith?: Error;
+}
+export declare function createFakeShell(replies?: ShellReply[] | ((call: ShellCall, index: number) => ShellReply)): {
+    shell: DshShell;
+    calls: ShellCall[];
+    peak: () => number;
+    commands: () => string[];
+};
+export interface OpencliCall {
+    args: readonly string[];
+    key?: string;
+    workdir?: string;
+    refresh?: boolean;
+}
+export declare function createFakeOpencli(replies?: Array<unknown | Error> | ((call: OpencliCall, index: number) => unknown | Error)): {
+    opencli: Opencli;
+    calls: OpencliCall[];
+    keys: () => (string | undefined)[];
+};
+export declare function createFakeLogger(): {
+    logger: {
+        info: () => void;
+        warn: (message: string) => void;
+    };
+    warnings: string[];
+};

package/dist/host/__tests__/fakes.js

@@ -0,0 +1,76 @@
+import { setTimeout as delay } from 'node:timers/promises';
+const tick = () => delay(0);
+export function createFakeShell(replies = []) {
+    const calls = [];
+    let running = 0;
+    let peak = 0;
+    const replyAt = (index) => typeof replies === 'function' ? replies(calls[index], index) : (replies[index] ?? {});
+    const shell = {
+        resolve(request) {
+            calls.push(request);
+            return request;
+        },
+        async execute() {
+            const index = calls.length - 1;
+            const reply = replyAt(index);
+            if (reply.failWith !== undefined)
+                throw reply.failWith;
+            running += 1;
+            peak = Math.max(peak, running);
+            return {
+                async result() {
+                    await tick();
+                    running -= 1;
+                    return {
+                        exitCode: reply.exitCode ?? 0,
+                        timedOut: reply.timedOut ?? false,
+                        aborted: reply.aborted ?? false,
+                        stdout: { text: reply.stdout ?? '', truncated: false },
+                        stderr: { text: reply.stderr ?? '', truncated: false },
+                    };
+                },
+            };
+        },
+    };
+    return {
+        shell,
+        calls,
+        peak: () => peak,
+        commands: () => calls.map((call) => call.command),
+    };
+}
+export function createFakeOpencli(replies = []) {
+    const calls = [];
+    const opencli = {
+        async json(args, options = {}) {
+            const call = {
+                args,
+                ...(options.key === undefined ? {} : { key: options.key }),
+                ...(options.workdir === undefined ? {} : { workdir: options.workdir }),
+            };
+            calls.push(call);
+            const index = calls.length - 1;
+            const reply = typeof replies === 'function' ? replies(call, index) : (replies[index] ?? []);
+            if (reply instanceof Error)
+                throw reply;
+            return { value: reply, at: Date.now() };
+        },
+    };
+    return {
+        opencli,
+        calls,
+        keys: () => calls.map((call) => call.key),
+    };
+}
+export function createFakeLogger() {
+    const warnings = [];
+    return {
+        logger: {
+            info: () => { },
+            warn: (message) => {
+                warnings.push(message);
+            },
+        },
+        warnings,
+    };
+}

package/dist/host/__tests__/preflight-fixtures.d.ts

@@ -0,0 +1,19 @@
+import { createFakeShell } from './fakes';
+export declare const GOOD_BRIDGE_REPORT: string;
+export declare const ALL_OK: {
+    stdout: string;
+}[];
+export declare const STALE_DAEMON_BRIDGE: string;
+export declare const BROKEN_BRIDGE: string;
+export declare function build(replies: Parameters<typeof createFakeShell>[0], install?: () => Promise<{
+    ok: boolean;
+    detail: string;
+}>, warmReads?: () => readonly (readonly string[])[]): {
+    fake: {
+        shell: import("../..").DshShell;
+        calls: import("./fakes").ShellCall[];
+        peak: () => number;
+        commands: () => string[];
+    };
+    preflight: import("../preflight").Preflight;
+};

package/dist/host/__tests__/preflight-fixtures.js

@@ -0,0 +1,47 @@
+import { createPreflight } from '../preflight';
+import { createFakeShell } from './fakes';
+export const GOOD_BRIDGE_REPORT = [
+    'opencli v1.8.7 doctor (node v24.15.0)',
+    '',
+    '[OK] Daemon: running on port 19825 (v1.8.7)',
+    '[OK] Extension: connected (v1.0.24)',
+    '[OK] Connectivity: connected in 0.0s',
+    '',
+    'Everything looks good!',
+].join('\n');
+export const ALL_OK = [{ stdout: '1.8.8\n' }, { stdout: GOOD_BRIDGE_REPORT }];
+export const STALE_DAEMON_BRIDGE = [
+    'opencli v1.8.7 doctor (node v24.15.0)',
+    '',
+    '[STALE] Daemon: running on port 19825 (v1.8.8 != CLI v1.8.7)',
+    '[OK] Extension: connected (v1.0.24)',
+    '[OK] Connectivity: connected in 0.0s',
+    '',
+    'Issues:',
+    '  • Stale daemon detected: daemon v1.8.8 != CLI v1.8.7.',
+    '  Run: opencli daemon restart',
+].join('\n');
+export const BROKEN_BRIDGE = [
+    'opencli v1.8.7 doctor (node v24.15.0)',
+    '',
+    '[MISSING] Daemon: not running',
+    '[MISSING] Extension: not connected',
+    '[FAIL] Connectivity: failed (daemon not reachable)',
+    '',
+    'Issues:',
+    "  • Daemon is not running. It should start automatically when you run an opencli browser command.",
+    '  • Daemon is running but the Chrome/Chromium extension is not connected.',
+    'If the extension is not installed:',
+    '  1. Download from https://github.com/jackwener/opencli/releases',
+    '  2. Open chrome://extensions/ → Enable Developer Mode',
+    '  3. Click "Load unpacked" → select the extension folder',
+].join('\n');
+export function build(replies, install, warmReads) {
+    const fake = createFakeShell(replies);
+    const preflight = createPreflight({
+        shell: fake.shell,
+        ...(install === undefined ? {} : { install }),
+        ...(warmReads === undefined ? {} : { warmReads }),
+    });
+    return { fake, preflight };
+}

package/dist/host/context-inject.d.ts

@@ -0,0 +1,24 @@
+import { type ContextRef } from '@dsh-workbench/shared';
+import type { ContextRenderer } from './unit-face';
+export declare const CONTEXT_SOURCE_KIND = "workbench";
+export interface ScannableMessage {
+    readonly source?: {
+        readonly kind?: string;
+    };
+    readonly content?: readonly {
+        readonly type?: string;
+        readonly text?: string;
+    }[];
+}
+export type { ContextRenderer };
+export declare function collectContextRefs(messages: readonly ScannableMessage[]): ContextRef[];
+export declare function buildContextMessage(text: string, summary: string): unknown;
+export interface ContextInjector {
+    inject(messages: readonly ScannableMessage[], agent: unknown): Promise<unknown | undefined>;
+}
+export declare function createContextInjector(options: {
+    renderers: ReadonlyMap<string, ContextRenderer>;
+    logger?: {
+        warn?(message: string): void;
+    } | undefined;
+}): ContextInjector;

package/dist/host/context-inject.js

@@ -0,0 +1,74 @@
+import { randomUUID } from 'node:crypto';
+import { encodeRef, parseMarkers } from '@dsh-workbench/shared';
+export const CONTEXT_SOURCE_KIND = 'workbench';
+export function collectContextRefs(messages) {
+    const seen = new Set();
+    const refs = [];
+    for (const message of messages) {
+        if (message.source?.kind !== 'user')
+            continue;
+        for (const block of message.content ?? []) {
+            if (block.type !== 'text' || typeof block.text !== 'string')
+                continue;
+            for (const ref of parseMarkers(block.text)) {
+                const key = encodeRef(ref);
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                refs.push(ref);
+            }
+        }
+    }
+    return refs;
+}
+export function buildContextMessage(text, summary) {
+    return {
+        role: 'user',
+        id: randomUUID(),
+        content: [{ type: 'text', text }],
+        source: { kind: CONTEXT_SOURCE_KIND, form: 'notice', summary },
+    };
+}
+export function createContextInjector(options) {
+    const done = new WeakMap();
+    return {
+        async inject(messages, agent) {
+            const refs = collectContextRefs(messages);
+            if (refs.length === 0)
+                return undefined;
+            const key = typeof agent === 'object' && agent !== null ? agent : undefined;
+            const seen = key === undefined ? undefined : (done.get(key) ?? new Set());
+            if (key !== undefined && seen !== undefined)
+                done.set(key, seen);
+            const fresh = [];
+            for (const ref of refs) {
+                const encoded = encodeRef(ref);
+                if (seen?.has(encoded) === true)
+                    continue;
+                seen?.add(encoded);
+                fresh.push(ref);
+            }
+            if (fresh.length === 0)
+                return undefined;
+            const texts = [];
+            for (const ref of fresh) {
+                const render = options.renderers.get(ref.kind);
+                if (render === undefined)
+                    continue;
+                let text;
+                try {
+                    text = await render(ref);
+                }
+                catch (error) {
+                    options.logger?.warn?.(`[dsh-workbench] 渲染对话引用失败：${String(error)}`);
+                    text = `工作台面板引用了一条内容（${encodeRef(ref)}），但当前渲染不出来（项目未选中或数据源不可用）。`;
+                }
+                if (text !== '')
+                    texts.push(text);
+            }
+            if (texts.length === 0)
+                return undefined;
+            return buildContextMessage(texts.join('\n\n'), `工作台引用：${fresh.length} 条`);
+        },
+    };
+}

package/dist/host/events.d.ts

@@ -0,0 +1,9 @@
+import type { DshHostContext, DshRequest, DshResponse } from '@dsh-workbench/shared';
+import type { FactLog } from './facts';
+export interface FactStream {
+    handler(req: DshRequest, res: DshResponse): void;
+    closeAll(): void;
+    size(): number;
+}
+export declare function createFactStream(log: FactLog): FactStream;
+export declare function registerFactStream(ctx: DshHostContext, log: FactLog): () => void;

package/dist/host/events.js

@@ -0,0 +1,70 @@
+import { EVENTS_PATH } from '@dsh-workbench/shared';
+const HEARTBEAT_MS = 25_000;
+function frame(payload) {
+    return `data: ${JSON.stringify(payload)}\n\n`;
+}
+export function createFactStream(log) {
+    const connections = new Set();
+    const cleanups = new Map();
+    const drop = (res) => {
+        cleanups.get(res)?.();
+        cleanups.delete(res);
+        connections.delete(res);
+    };
+    return {
+        size: () => connections.size,
+        closeAll() {
+            for (const res of [...connections]) {
+                drop(res);
+                res.end?.();
+            }
+        },
+        handler(req, res) {
+            if (req.method !== undefined && req.method !== 'GET') {
+                res.statusCode = 405;
+                res.end();
+                return;
+            }
+            const url = req.url ?? '/';
+            const cut = url.indexOf('?');
+            const since = Number(new URLSearchParams(cut === -1 ? '' : url.slice(cut + 1)).get('since') ?? 0) || 0;
+            const opening = log.since(since);
+            if (typeof res.write !== 'function') {
+                res.statusCode = 200;
+                res.setHeader('content-type', 'application/json; charset=utf-8');
+                res.end(JSON.stringify({ ok: true, ...opening }));
+                return;
+            }
+            const headers = {
+                'content-type': 'text/event-stream; charset=utf-8',
+                'cache-control': 'no-store, no-transform',
+                connection: 'keep-alive',
+            };
+            if (typeof res.writeHead === 'function')
+                res.writeHead(200, headers);
+            else {
+                res.statusCode = 200;
+                for (const [name, value] of Object.entries(headers))
+                    res.setHeader(name, value);
+            }
+            res.write(': connected\n\n');
+            res.write(frame({ type: 'sync', ...opening }));
+            connections.add(res);
+            const timer = setInterval(() => res.write?.(': ping\n\n'), HEARTBEAT_MS);
+            const unsubscribe = log.subscribe((change) => res.write?.(frame({ type: 'bump', ...change })));
+            cleanups.set(res, () => {
+                clearInterval(timer);
+                unsubscribe();
+            });
+            res.on?.('close', () => drop(res));
+        },
+    };
+}
+export function registerFactStream(ctx, log) {
+    const stream = createFactStream(log);
+    const unregister = ctx.webServer.register({ kind: 'exact', path: EVENTS_PATH, handler: stream.handler });
+    return () => {
+        stream.closeAll();
+        unregister();
+    };
+}

package/dist/host/mount-units.d.ts

@@ -0,0 +1,52 @@
+import type { DshHostContext } from '@dsh-workbench/shared';
+import type { UnitManifest } from '@dsh-workbench/shared';
+import { type RouteTable } from './http';
+import type { ContextRenderer, UnitHostFace, UnitMountDeps, UnitMountResult, UnitCall } from './unit-face';
+import { type UnitReadiness } from './unit-readiness';
+export interface MountedUnit {
+    readonly face: UnitHostFace;
+    readonly result: UnitMountResult;
+    readonly readiness: UnitReadiness;
+}
+export interface UnitsPlan {
+    readonly mounted: readonly MountedUnit[];
+    readonly routes: RouteTable;
+    readonly gate: UnitMountResult['gate'];
+    readonly prefs: ReadonlyArray<{
+        readonly resource: string;
+        readonly unit: string;
+        handle(payload: unknown): unknown;
+    }>;
+    readonly actions: ReadonlyArray<{
+        readonly resource: string;
+        readonly unit: string;
+        handle(payload: unknown): unknown;
+    }>;
+    readonly provision: UnitMountResult['provision'];
+    readonly contextRenderers: ReadonlyMap<string, ContextRenderer>;
+    readonly owners: ReadonlyMap<string, string>;
+    readonly routesOfUnit: ReadonlyMap<string, readonly string[]>;
+    readonly factsOf: ReadonlyMap<string, (call: UnitCall) => readonly string[] | undefined>;
+    readonly skipped: ReadonlyArray<{
+        readonly id: string;
+        readonly missing: readonly string[];
+    }>;
+    readonly warmReads: () => readonly (readonly string[])[];
+    readonly disposeLongTasks: () => void;
+}
+export declare function mountUnits(faces: readonly UnitHostFace[], deps: {
+    ctx: DshHostContext;
+    logger?: {
+        info?(m: string): void;
+        warn?(m: string): void;
+    } | undefined;
+    manifests: () => readonly UnitManifest[];
+    opencliCommand?: string;
+    probe?: UnitMountDeps['probe'];
+    store?: UnitMountDeps['store'];
+    values?: UnitMountDeps['values'];
+    longTasks?: {
+        readonly scope: string;
+        readonly bump: (facts: readonly string[]) => void;
+    } | undefined;
+}): UnitsPlan;