@dsh-workbench/shared 0.1.6 → 0.1.8

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;

package/dist/host/mount-units.js

@@ -0,0 +1,186 @@
+import { runsRouteOf } from '@dsh-workbench/shared';
+import { param } from './http';
+import { createLongTaskHost } from './long-task';
+import { unitReadiness } from './unit-readiness';
+import { createWorkspaceStore } from './workspace-store';
+function withRunsRoute(result, unit) {
+    const runs = result.longTasks;
+    if (runs === undefined)
+        return result;
+    return {
+        ...result,
+        routes: {
+            ...result.routes,
+            [runsRouteOf(unit)]: (search) => {
+                const path = (param(search, 'path') ?? '').trim();
+                return { ok: true, runs: path === '' ? [] : runs.current(path) };
+            },
+        },
+    };
+}
+function collectRoutes(mounted) {
+    const routes = {};
+    const owner = new Map();
+    const routesOfUnit = new Map();
+    for (const item of mounted) {
+        const unit = item.face.manifest.id;
+        for (const [key, handler] of Object.entries(item.result.routes)) {
+            if (key !== unit && !key.startsWith(`${unit}/`)) {
+                throw new Error(`路由名要住在自己那一格的命名空间里（${unit} 或 ${unit}/…）：${key} 不属于 ${unit} —— ` +
+                    `装 / 升 / 卸时点名不到它，那个模块的数据会停在旧值`);
+            }
+            const previous = owner.get(key);
+            if (previous !== undefined) {
+                throw new Error(`路由名冲突：${key} 由套件 ${previous} 与 ${unit} 同时声明`);
+            }
+            owner.set(key, unit);
+            routes[key] = handler;
+            const own = routesOfUnit.get(unit);
+            if (own === undefined)
+                routesOfUnit.set(unit, [key]);
+            else
+                own.push(key);
+        }
+    }
+    return { routes, owners: owner, routesOfUnit };
+}
+function pickGate(mounted) {
+    const providers = mounted.filter((item) => item.result.gate !== undefined);
+    if (providers.length > 1) {
+        throw new Error(`启停闸门只能有一个提供者，现在是：${providers.map((item) => item.face.manifest.id).join('、')}`);
+    }
+    return providers[0]?.result.gate;
+}
+function pickProvision(mounted) {
+    const providers = mounted.filter((item) => item.result.provision !== undefined);
+    if (providers.length > 1) {
+        throw new Error(`机器供给只能有一个提供者，现在是：${providers.map((item) => item.face.manifest.id).join('、')}`);
+    }
+    return providers[0]?.result.provision;
+}
+function collectPrefs(mounted) {
+    const owner = new Map();
+    const prefs = [];
+    for (const item of mounted) {
+        const entry = item.result.prefs;
+        if (entry === undefined)
+            continue;
+        const previous = owner.get(entry.resource);
+        if (previous !== undefined) {
+            throw new Error(`偏好资源名冲突：${entry.resource} 由套件 ${previous} 与 ${item.face.manifest.id} 同时声明`);
+        }
+        owner.set(entry.resource, item.face.manifest.id);
+        prefs.push({ ...entry, unit: item.face.manifest.id });
+    }
+    return prefs;
+}
+function collectActions(mounted) {
+    const owner = new Map();
+    const actions = [];
+    for (const item of mounted) {
+        for (const entry of item.result.actions ?? []) {
+            const previous = owner.get(entry.resource);
+            if (previous !== undefined) {
+                throw new Error(`动作资源名冲突：${entry.resource} 由套件 ${previous} 与 ${item.face.manifest.id} 同时声明`);
+            }
+            owner.set(entry.resource, item.face.manifest.id);
+            actions.push({ ...entry, unit: item.face.manifest.id });
+        }
+    }
+    return actions;
+}
+function collectWarmReads(mounted) {
+    const declarations = mounted
+        .map((item) => item.result.warmReads)
+        .filter((declare) => declare !== undefined);
+    return () => {
+        const seen = new Set();
+        const reads = [];
+        for (const read of declarations.flatMap((declare) => declare())) {
+            const key = read.join(' ');
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            reads.push(read);
+        }
+        return reads;
+    };
+}
+function collectContextRenderers(mounted) {
+    const table = new Map();
+    const owner = new Map();
+    for (const item of mounted) {
+        const context = item.result.context;
+        if (context === undefined)
+            continue;
+        for (const kind of context.kinds) {
+            const previous = owner.get(kind);
+            if (previous !== undefined) {
+                throw new Error(`对话引用的 kind 冲突：${kind} 由套件 ${previous} 与 ${item.face.manifest.id} 同时认领`);
+            }
+            owner.set(kind, item.face.manifest.id);
+            table.set(kind, (ref) => context.render(ref));
+        }
+    }
+    return table;
+}
+export function mountUnits(faces, deps) {
+    const store = deps.store ?? createWorkspaceStore({ root: null });
+    const mounted = [];
+    const skipped = [];
+    const longTaskDisposers = [];
+    for (const face of faces) {
+        const readiness = unitReadiness(face.manifest, (dep) => deps.ctx.get(dep));
+        if (!readiness.canMount) {
+            skipped.push({ id: face.manifest.id, missing: readiness.missingHard });
+            continue;
+        }
+        const unit = face.manifest.id;
+        const longTasks = deps.longTasks === undefined
+            ? undefined
+            : createLongTaskHost({ scope: deps.longTasks.scope, unit, bump: deps.longTasks.bump });
+        if (longTasks !== undefined)
+            longTaskDisposers.push(longTasks.dispose);
+        const result = face.mount({
+            ctx: deps.ctx,
+            logger: deps.logger,
+            manifests: deps.manifests,
+            ...(deps.opencliCommand === undefined ? {} : { opencliCommand: deps.opencliCommand }),
+            ...(deps.probe === undefined ? {} : { probe: deps.probe }),
+            ...(deps.values === undefined ? {} : { values: deps.values }),
+            ...(longTasks === undefined ? {} : { longTasks: longTasks.host }),
+            store,
+        });
+        mounted.push({ face, readiness, result: withRunsRoute(result, unit) });
+    }
+    const collected = collectRoutes(mounted);
+    const prefs = collectPrefs(mounted);
+    const actions = collectActions(mounted);
+    const owners = new Map(collected.owners);
+    for (const entry of [...prefs, ...actions])
+        owners.set(entry.resource, entry.unit);
+    const factsOf = new Map();
+    for (const item of mounted) {
+        const declare = item.result.factsOf;
+        if (declare !== undefined)
+            factsOf.set(item.face.manifest.id, declare);
+    }
+    return {
+        mounted,
+        routes: collected.routes,
+        owners,
+        routesOfUnit: collected.routesOfUnit,
+        factsOf,
+        gate: pickGate(mounted),
+        prefs,
+        actions,
+        provision: pickProvision(mounted),
+        contextRenderers: collectContextRenderers(mounted),
+        skipped,
+        warmReads: collectWarmReads(mounted),
+        disposeLongTasks: () => {
+            for (const dispose of longTaskDisposers.splice(0))
+                dispose();
+        },
+    };
+}

package/dist/host/preflight.d.ts

@@ -0,0 +1,58 @@
+import type { DshShell } from '@dsh-workbench/shared';
+export type PreflightStepId = 'opencli' | 'bridge' | 'warm';
+export type PreflightStepStatus = 'pending' | 'running' | 'ok' | 'warn' | 'failed';
+export interface PreflightStep {
+    readonly id: PreflightStepId;
+    readonly status: PreflightStepStatus;
+    readonly detail?: string;
+    readonly action?: string;
+    readonly command?: string;
+}
+export type PreflightFailure = 'permission' | 'network' | 'missing' | 'unknown';
+export declare function classifyFailure(text: string): PreflightFailure;
+export type PreflightGuidance = 'install' | 'path' | 'shell';
+export type PreflightBridgeIssue = 'daemon' | 'extension' | 'profile' | 'stale' | 'unknown';
+export declare function readBridgeReport(stdout: string): {
+    readonly ok: boolean;
+    readonly issues: readonly PreflightBridgeIssue[];
+    readonly detail: string;
+};
+export interface PreflightSnapshot {
+    readonly phase: 'idle' | 'checking' | 'installing' | 'ready' | 'failed';
+    readonly steps: readonly PreflightStep[];
+    readonly at: number;
+    readonly error?: string;
+    readonly failure?: PreflightFailure;
+    readonly guidance?: PreflightGuidance;
+    readonly bridgeIssues?: readonly PreflightBridgeIssue[];
+}
+export interface Preflight {
+    run(options?: {
+        force?: boolean;
+    }): Promise<PreflightSnapshot>;
+    snapshot(): PreflightSnapshot;
+}
+export declare const OPENCLI_INSTALL_COMMAND: string;
+export interface BridgeVerdict {
+    readonly ok: boolean;
+    readonly detail: string;
+    readonly issues: readonly PreflightBridgeIssue[];
+    readonly command?: string | undefined;
+}
+export declare function canWarm(bridge: {
+    ok: boolean;
+    issues: readonly PreflightBridgeIssue[];
+}): boolean;
+export declare function createPreflight(options: {
+    shell: DshShell;
+    command?: string;
+    installCommand?: string;
+    logger?: {
+        warn?(message: string): void;
+    } | undefined;
+    install?: (() => Promise<{
+        ok: boolean;
+        detail: string;
+    }>) | undefined;
+    warmReads?: (() => readonly (readonly string[])[]) | undefined;
+}): Preflight;