@dsh-workbench/shared 0.1.0

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/data-root.d.ts

@@ -0,0 +1,3 @@
+export declare function dshHome(): string;
+export declare function workbenchRoot(): string;
+export declare function workspacesRoot(): string;

package/dist/host/data-root.js

@@ -0,0 +1,12 @@
+export function dshHome() {
+    const configured = process.env.DSH_HOME?.trim();
+    if (configured !== undefined && configured !== '')
+        return configured;
+    return `${process.env.HOME ?? ''}/.dsh`;
+}
+export function workbenchRoot() {
+    return `${dshHome()}/workbench`;
+}
+export function workspacesRoot() {
+    return `${workbenchRoot()}/workspaces`;
+}

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/facts.d.ts

@@ -0,0 +1,24 @@
+import type { UnitManifest } from '../api/unit.js';
+export interface FactChange {
+    readonly rev: number;
+    readonly facts: readonly string[];
+}
+export interface FactSnapshot extends FactChange {
+    readonly epoch: string;
+}
+export interface FactLog {
+    bump(facts: readonly string[]): FactChange;
+    revision(): number;
+    epoch(): string;
+    since(rev: number): FactSnapshot;
+    subscribe(listener: (change: FactChange) => void): () => void;
+}
+export declare function createFactLog(options?: {
+    readonly epoch?: string;
+}): FactLog;
+export interface ToolUnit {
+    readonly unit: string;
+    readonly writes: boolean;
+}
+export declare function toolUnits(manifests: readonly UnitManifest[]): Map<string, ToolUnit>;
+export declare function wroteNow(result: unknown): boolean | undefined;

package/dist/host/facts.js

@@ -0,0 +1,44 @@
+export function createFactLog(options = {}) {
+    const epoch = options.epoch ?? `e${Date.now().toString(36)}${Math.random().toString(36).slice(2, 8)}`;
+    let rev = 0;
+    const last = new Map();
+    const listeners = new Set();
+    return {
+        epoch: () => epoch,
+        revision: () => rev,
+        bump(facts) {
+            rev += 1;
+            const named = [...new Set(facts.filter((name) => name !== ''))];
+            for (const name of named)
+                last.set(name, rev);
+            const change = { rev, facts: named };
+            for (const listener of [...listeners])
+                listener(change);
+            return change;
+        },
+        since(seen) {
+            const facts = [...last.entries()].filter(([, at]) => at > seen).map(([name]) => name);
+            return { epoch, rev, facts };
+        },
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+    };
+}
+export function toolUnits(manifests) {
+    const map = new Map();
+    for (const manifest of manifests) {
+        for (const tool of manifest.tools ?? []) {
+            map.set(tool.name, { unit: manifest.id, writes: tool.writes });
+        }
+    }
+    return map;
+}
+export function wroteNow(result) {
+    const value = result?.value;
+    const wrote = value?.wrote;
+    return typeof wrote === 'boolean' ? wrote : undefined;
+}

package/dist/host/git.d.ts

@@ -0,0 +1,55 @@
+import type { DshShell } from '../api/dsh.js';
+export type OriginRead = {
+    readonly kind: 'ok';
+    readonly remote: string;
+} | {
+    readonly kind: 'no-origin';
+    readonly detail?: string;
+} | {
+    readonly kind: 'unknown';
+    readonly reason: string;
+    readonly detail?: string;
+};
+export type OriginReader = (path: string) => Promise<OriginRead>;
+export type BranchRead = {
+    readonly kind: 'ok';
+    readonly branch: string;
+} | {
+    readonly kind: 'no-branch';
+    readonly detail?: string | undefined;
+} | {
+    readonly kind: 'unknown';
+    readonly reason: string;
+    readonly detail?: string | undefined;
+};
+export type BranchReader = (path: string) => Promise<BranchRead>;
+export type HeadRead = {
+    readonly kind: 'ok';
+    readonly commit: string;
+} | {
+    readonly kind: 'no-head';
+    readonly detail?: string;
+} | {
+    readonly kind: 'unknown';
+    readonly reason: string;
+    readonly detail?: string;
+};
+export type HeadReader = (path: string) => Promise<HeadRead>;
+export declare function createHeadReader(options: {
+    shell: DshShell;
+    logger?: {
+        warn?(message: string): void;
+    } | undefined;
+}): HeadReader;
+export declare function createBranchReader(options: {
+    shell: DshShell;
+    logger?: {
+        warn?(message: string): void;
+    } | undefined;
+}): BranchReader;
+export declare function createOriginReader(options: {
+    shell: DshShell;
+    logger?: {
+        warn?(message: string): void;
+    } | undefined;
+}): OriginReader;

package/dist/host/git.js

@@ -0,0 +1,64 @@
+import { quoteShellArg, tailLines } from '../lib/text.js';
+import { runShell } from './shell.js';
+export function createHeadReader(options) {
+    const { shell, logger } = options;
+    return async function readHead(path) {
+        const key = String(path ?? '').trim();
+        if (!key)
+            return { kind: 'unknown', reason: 'no-path' };
+        let result;
+        try {
+            result = await runShell(shell, `git -C ${quoteShellArg(key)} rev-parse HEAD`);
+        }
+        catch (error) {
+            logger?.warn?.(`[dsh-workbench] git rev-parse 执行失败：${String(error)}`);
+            return { kind: 'unknown', reason: 'exec-failed', detail: String(error) };
+        }
+        if (result.exitCode !== 0) {
+            return { kind: 'no-head', detail: tailLines(result.stderr, 3) };
+        }
+        return { kind: 'ok', commit: result.stdout.trim() };
+    };
+}
+export function createBranchReader(options) {
+    const { shell, logger } = options;
+    return async function readBranch(path) {
+        const key = String(path ?? '').trim();
+        if (!key)
+            return { kind: 'unknown', reason: 'no-path' };
+        let result;
+        try {
+            result = await runShell(shell, `git -C ${quoteShellArg(key)} rev-parse --abbrev-ref HEAD`);
+        }
+        catch (error) {
+            logger?.warn?.(`[dsh-workbench] git rev-parse --abbrev-ref 执行失败：${String(error)}`);
+            return { kind: 'unknown', reason: 'exec-failed', detail: String(error) };
+        }
+        const name = result.stdout.trim();
+        if (result.exitCode !== 0)
+            return { kind: 'no-branch', detail: tailLines(result.stderr, 3) };
+        if (name === '' || name === 'HEAD')
+            return { kind: 'no-branch', detail: name };
+        return { kind: 'ok', branch: name };
+    };
+}
+export function createOriginReader(options) {
+    const { shell, logger } = options;
+    return async function readOrigin(path) {
+        const key = String(path ?? '').trim();
+        if (!key)
+            return { kind: 'unknown', reason: 'no-path' };
+        let result;
+        try {
+            result = await runShell(shell, `git -C ${quoteShellArg(key)} remote get-url origin`);
+        }
+        catch (error) {
+            logger?.warn?.(`[dsh-workbench] git remote 执行失败：${String(error)}`);
+            return { kind: 'unknown', reason: 'exec-failed', detail: String(error) };
+        }
+        if (result.exitCode !== 0) {
+            return { kind: 'no-origin', detail: tailLines(result.stderr, 3) };
+        }
+        return { kind: 'ok', remote: result.stdout.trim() };
+    };
+}

package/dist/host/http.d.ts

@@ -0,0 +1,36 @@
+import type { DshHostContext } from '../api/dsh.js';
+import { type ProvisionHandler } from './provision';
+export type RouteHandler = (search: URLSearchParams) => Promise<unknown> | unknown;
+export type RouteTable = Record<string, RouteHandler>;
+export declare function flag(search: URLSearchParams, name: string): boolean;
+export declare function param(search: URLSearchParams, name: string): string | undefined;
+export declare function registerApi(ctx: DshHostContext, routes: RouteTable): () => void;
+export declare function registerProvision(ctx: DshHostContext, provision: ProvisionHandler, log?: {
+    bump(facts: readonly string[]): unknown;
+} | undefined): () => void;
+export interface PostResource {
+    readonly resource: string;
+    readonly unit?: string;
+    handle(payload: unknown): Promise<unknown> | unknown;
+}
+export interface PostWrite {
+    readonly args: unknown;
+    readonly result: unknown;
+}
+export declare function changesHandler(log: {
+    epoch(): string;
+    since(rev: number): {
+        rev: number;
+        facts: readonly string[];
+    };
+}): RouteHandler;
+export declare function preflightHandler(preflight: {
+    run(options?: {
+        force?: boolean;
+    }): Promise<unknown>;
+    snapshot(): unknown;
+}): RouteHandler;
+export declare function capabilityHandler(probe: (unit: string | undefined, force: boolean) => Promise<unknown> | unknown): RouteHandler;
+export declare function healthHandler(ctx: DshHostContext): RouteHandler;
+export declare function registerPrefs(ctx: DshHostContext, resources: readonly PostResource[], wrote?: ((resource: string, write: PostWrite) => void) | undefined): () => void;
+export declare function registerActions(ctx: DshHostContext, resources: readonly PostResource[], wrote?: ((resource: string, write: PostWrite) => void) | undefined): () => void;

package/dist/host/http.js

@@ -0,0 +1,242 @@
+import { unitFactScope } from '../api/facts.js';
+import { ACTIONS_PREFIX, API_PREFIX, PLUGIN_ID, PREFS_PREFIX, PROVISION_PREFIX } from '../config/constants.js';
+import { isDependencyAction, PROVISION_ACTIONS, } from './provision';
+import { WorkbenchDataError } from '../host/opencli.js';
+import { writeResultForClient } from './write-result';
+const MAX_PREFS_BODY_BYTES = 8 * 1024;
+const PROVISION_FACTS = ['capability', 'panels'];
+function provisionFacts(provision, request) {
+    const scopes = (provision.affectedUnits?.(request) ?? []).map(unitFactScope);
+    return [...PROVISION_FACTS, ...scopes];
+}
+function sendJson(res, status, body) {
+    res.statusCode = status;
+    res.setHeader('content-type', 'application/json; charset=utf-8');
+    res.setHeader('cache-control', 'no-store');
+    res.end(JSON.stringify(body));
+}
+function toErrorPayload(error) {
+    if (error instanceof WorkbenchDataError) {
+        return {
+            code: error.code,
+            message: error.message,
+            ...(error.detail === undefined ? {} : { detail: error.detail }),
+            ...(error.hint === undefined ? {} : { hint: error.hint }),
+            ...(error.helpUrl === undefined ? {} : { helpUrl: error.helpUrl }),
+            ...(error.project === undefined ? {} : { project: error.project }),
+        };
+    }
+    return { code: 'internal', message: error instanceof Error ? error.message : String(error) };
+}
+export function flag(search, name) {
+    const raw = search.get(name);
+    if (raw === null)
+        return false;
+    return raw === '' || raw === '1' || raw.toLowerCase() === 'true';
+}
+export function param(search, name) {
+    const raw = search.get(name);
+    return raw === null || raw === '' ? undefined : raw;
+}
+export function registerApi(ctx, routes) {
+    return ctx.webServer.register({
+        kind: 'prefix',
+        path: API_PREFIX,
+        handler: async (req, res) => {
+            const raw = req.url ?? '/';
+            const cut = raw.indexOf('?');
+            const pathname = cut === -1 ? raw : raw.slice(0, cut);
+            const search = new URLSearchParams(cut === -1 ? '' : raw.slice(cut + 1));
+            const route = pathname.slice(API_PREFIX.length).replace(/^\//, '');
+            if (req.method !== 'GET') {
+                sendJson(res, 405, { ok: false, error: { code: 'method-not-allowed', message: '只支持 GET' } });
+                return;
+            }
+            const handler = Object.prototype.hasOwnProperty.call(routes, route) ? routes[route] : undefined;
+            if (handler === undefined) {
+                sendJson(res, 404, { ok: false, error: { code: 'not-found', message: `没有这个接口：${route}` } });
+                return;
+            }
+            try {
+                sendJson(res, 200, await handler(search));
+            }
+            catch (error) {
+                if (error instanceof WorkbenchDataError) {
+                    sendJson(res, 200, { ok: false, error: toErrorPayload(error) });
+                    return;
+                }
+                ctx.logger?.warn?.(`[dsh-workbench] 路由 ${route} 失败：${String(error)}`);
+                sendJson(res, 500, { ok: false, error: toErrorPayload(error) });
+            }
+        },
+    });
+}
+export function registerProvision(ctx, provision, log) {
+    return ctx.webServer.register({
+        kind: 'prefix',
+        path: PROVISION_PREFIX,
+        handler: async (req, res) => {
+            if (req.method !== 'POST') {
+                sendJson(res, 405, { ok: false, error: { code: 'method-not-allowed', message: '机器供给只支持 POST' } });
+                return;
+            }
+            let payload;
+            try {
+                const raw = await readBoundedBody(req);
+                if (raw === null) {
+                    sendJson(res, 413, { ok: false, error: { code: 'body-too-large', message: '请求体太大' } });
+                    return;
+                }
+                payload = raw === '' ? {} : JSON.parse(raw);
+            }
+            catch (error) {
+                sendJson(res, 400, { ok: false, error: { code: 'bad-json', message: String(error) } });
+                return;
+            }
+            const body = typeof payload === 'object' && payload !== null
+                ? payload
+                : {};
+            const action = body.action;
+            if (typeof action !== 'string' || !PROVISION_ACTIONS.includes(action)) {
+                sendJson(res, 400, {
+                    ok: false,
+                    error: {
+                        code: 'workbench/bad-action',
+                        message: `不认识的 action：${String(action)}（可用：${PROVISION_ACTIONS.join(' / ')}）`,
+                    },
+                });
+                return;
+            }
+            const wanted = action;
+            const target = isDependencyAction(wanted) ? body.id : body.unit;
+            if (typeof target !== 'string' || target.trim() === '') {
+                sendJson(res, 400, {
+                    ok: false,
+                    error: {
+                        code: isDependencyAction(wanted) ? 'workbench/no-id' : 'workbench/no-unit',
+                        message: isDependencyAction(wanted) ? '缺少 id' : '缺少 unit',
+                    },
+                });
+                return;
+            }
+            const key = target.trim();
+            const request = isDependencyAction(wanted)
+                ? { action: wanted, id: key }
+                : { action: wanted, unit: key };
+            try {
+                const result = await provision.handle(request);
+                log?.bump(provisionFacts(provision, request));
+                sendJson(res, 200, result);
+            }
+            catch (error) {
+                log?.bump(provisionFacts(provision, request));
+                sendJson(res, 200, { ok: false, error: toErrorPayload(error) });
+            }
+        },
+    });
+}
+function registerPost(ctx, options) {
+    const { prefix, what, resources, refusedCode, wrote } = options;
+    const table = new Map(resources.map((item) => [item.resource, item.handle]));
+    return ctx.webServer.register({
+        kind: 'prefix',
+        path: prefix,
+        handler: async (req, res) => {
+            if (req.method !== 'POST') {
+                sendJson(res, 405, { ok: false, error: { code: 'method-not-allowed', message: `${what}只支持 POST` } });
+                return;
+            }
+            const raw = await readBoundedBody(req);
+            if (raw === null) {
+                sendJson(res, 413, { ok: false, error: { code: 'payload-too-large', message: '请求体过大' } });
+                return;
+            }
+            let payload;
+            try {
+                payload = raw === '' ? {} : JSON.parse(raw);
+            }
+            catch {
+                sendJson(res, 400, { ok: false, error: { code: 'bad-json', message: '请求体不是 JSON' } });
+                return;
+            }
+            const requested = (req.url ?? '/').slice(prefix.length).replace(/^\//, '').split('?')[0] ?? '';
+            const handle = table.get(requested);
+            if (handle === undefined) {
+                sendJson(res, 404, { ok: false, error: { code: 'not-found', message: `没有这个${what}资源：${requested}` } });
+                return;
+            }
+            try {
+                const result = await handle(payload);
+                wrote?.(requested, { args: payload, result });
+                sendJson(res, 200, writeResultForClient(result, refusedCode));
+            }
+            catch (error) {
+                sendJson(res, 200, { ok: false, error: toErrorPayload(error) });
+            }
+        },
+    });
+}
+async function readBoundedBody(req) {
+    if (typeof req[Symbol.asyncIterator] !== 'function')
+        return '';
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of req) {
+        size += chunk.byteLength;
+        if (size > MAX_PREFS_BODY_BYTES)
+            return null;
+        chunks.push(chunk);
+    }
+    return Buffer.concat(chunks).toString('utf8');
+}
+export function changesHandler(log) {
+    return (search) => ({ ok: true, epoch: log.epoch(), ...log.since(Number(param(search, 'since') ?? 0) || 0) });
+}
+export function preflightHandler(preflight) {
+    return (search) => {
+        void preflight.run({ force: flag(search, 'force') });
+        return { ok: true, ...preflight.snapshot() };
+    };
+}
+export function capabilityHandler(probe) {
+    return async (search) => {
+        const unit = param(search, 'unit');
+        const result = await probe(unit, flag(search, 'force'));
+        if (result === undefined) {
+            return { ok: false, error: { code: 'workbench/unknown-unit', message: `没有这个单元：${unit}` } };
+        }
+        return { ok: true, ...result };
+    };
+}
+export function healthHandler(ctx) {
+    return () => {
+        const profile = ctx.get('profileContext');
+        const dir = profile?.dir;
+        return {
+            ok: true,
+            plugin: PLUGIN_ID,
+            profile: dir === undefined ? null : dir.split('/').pop(),
+            profileDir: dir ?? null,
+            pid: process.pid,
+            now: new Date().toISOString(),
+        };
+    };
+}
+export function registerPrefs(ctx, resources, wrote) {
+    return registerPost(ctx, {
+        prefix: PREFS_PREFIX,
+        what: '偏好写',
+        refusedCode: 'write-refused',
+        resources,
+        ...(wrote === undefined ? {} : { wrote }),
+    });
+}
+export function registerActions(ctx, resources, wrote) {
+    return registerPost(ctx, {
+        prefix: ACTIONS_PREFIX,
+        what: '动作',
+        refusedCode: 'action-refused',
+        resources,
+        ...(wrote === undefined ? {} : { wrote }),
+    });
+}