@dsh-workbench/adapter-supply 0.0.0-stage → 1.0.0-beta.0

package/dist/plugin-units.d.ts

@@ -0,0 +1,48 @@
+import type { Opencli } from '@dsh-workbench/adapter-runtime';
+import type { PluginCatalog } from './plugin-catalog.js';
+import type { UnitRegistry } from './unit-registry-types.js';
+export interface PluginRowRef {
+    readonly id: string;
+    readonly pkg: string;
+    readonly name?: string | undefined;
+}
+export interface PluginRowsSource {
+    listPlugins(workspace: string | null): readonly PluginRowRef[];
+    subscribe?(listener: () => void): () => void;
+}
+export interface PluginUnitRow {
+    readonly plugin: string;
+    readonly pkg: string;
+    readonly version: string;
+    readonly commands: number;
+    readonly synthesized: number;
+    readonly chars: number;
+    readonly tools: readonly string[];
+}
+export interface PluginUnitReport {
+    readonly ok: boolean;
+    readonly at: number;
+    readonly plugins: readonly PluginUnitRow[];
+    readonly problems: readonly string[];
+}
+export interface PluginUnits {
+    refresh(options?: {
+        readonly force?: boolean;
+    }): Promise<PluginUnitReport>;
+    touch(): void;
+    report(): PluginUnitReport;
+    dispose(): void;
+}
+export interface PluginUnitsOptions {
+    readonly registry: UnitRegistry;
+    readonly catalog: PluginCatalog;
+    readonly rows: () => readonly PluginRowRef[];
+    readonly declared: (plugin: string) => ReadonlySet<string>;
+    readonly opencliFor: (plugin: string) => Opencli;
+    readonly toolNames?: () => ReadonlySet<string>;
+    readonly logger?: {
+        info?(message: string): void;
+        warn?(message: string): void;
+    } | undefined;
+}
+export declare function createPluginUnits(options: PluginUnitsOptions): PluginUnits;

package/dist/plugin-units.js

@@ -0,0 +1,245 @@
+import { PROBE_TTL_MS, TEXT_OUTPUT, jsonText, sessionWorkspace } from '@dsh-workbench/shared/host';
+import { pluginLoginHint } from './plugin-login-hint.js';
+import { PLUGIN_PROMPT_BUDGET, RUN_CODE_TOOL, pluginApprovalFor, pluginPromptChars, pluginToolArgv, pluginToolDescription, pluginToolName, pluginToolParameters, pluginToolSession, pluginToolWrites, } from './plugin-tools.js';
+function signatureOf(version, commands) {
+    return [
+        version,
+        ...commands.map((command) => `${command.name}:${command.access}:${command.args
+            .map((arg) => `${arg.name}${arg.required ? '!' : ''}`)
+            .join('+')}`),
+    ].join('|');
+}
+function toolsOf(plugin, commands, taken) {
+    const tools = [];
+    const problems = [];
+    const claimed = new Set();
+    for (const command of commands) {
+        const name = pluginToolName(plugin, command.name);
+        if (name === RUN_CODE_TOOL) {
+            problems.push(`工具名 ${RUN_CODE_TOOL}（${plugin} ${command.name}）是 dsh 的保留名（PTC 的传送工具）—— 这条命令这次不合成`);
+            continue;
+        }
+        if (taken.has(name) || claimed.has(name)) {
+            problems.push(`工具名 ${name}（${plugin} ${command.name}）已经被占着 —— 这条命令这次不合成（先来的那份说了算）`);
+            continue;
+        }
+        claimed.add(name);
+        tools.push({ name, command });
+    }
+    return { tools, problems };
+}
+function planOf(options, registered) {
+    const sets = new Map(options.catalog.snapshot().sets.map((set) => [set.plugin, set]));
+    const mine = new Set([...registered.values()].flatMap((item) => item.tools));
+    const taken = new Set([...(options.toolNames?.() ?? [])].filter((name) => !mine.has(name)));
+    const units = [];
+    const rows = [];
+    const problems = [];
+    for (const row of options.rows()) {
+        const plugin = row.name?.trim() ?? '';
+        if (plugin === '') {
+            problems.push(`面板上的插件行 ${row.id}（${row.pkg}）没有 opencli 插件名 —— 认不出它，这次不给它合成工具`);
+            continue;
+        }
+        const set = sets.get(plugin);
+        if (set === undefined) {
+            problems.push(`已装插件「${plugin}」在 opencli 的插件清单 / 命令面里找不到 —— 归属不了，这次不给它合成工具`);
+            continue;
+        }
+        sets.delete(plugin);
+        const declared = options.declared(plugin);
+        const overlapped = set.commands.filter((command) => declared.has(command.name));
+        if (overlapped.length > 0) {
+            problems.push(`「${plugin}」有 ${overlapped.length} 条命令由已装模块自己提供（${overlapped
+                .map((command) => command.name)
+                .join('、')}）—— 通用桥不重复合成`);
+        }
+        const commands = set.commands.filter((command) => !declared.has(command.name));
+        const built = toolsOf(plugin, commands, taken);
+        problems.push(...built.problems);
+        for (const tool of built.tools)
+            taken.add(tool.name);
+        if (built.tools.length === 0 && commands.length === set.commands.length) {
+            problems.push(`「${plugin}」的命令一条都没能合成工具`);
+        }
+        const chars = built.tools.reduce((sum, tool) => sum + pluginPromptChars(tool.command), 0);
+        if (chars > PLUGIN_PROMPT_BUDGET) {
+            problems.push(`「${plugin}」合成出来的 ${String(built.tools.length)} 把工具，描述与参数说明合起来 ${String(chars)} 字，超过 ${String(PLUGIN_PROMPT_BUDGET)} 字的合成面预算 —— 这些字每一步请求都跟着走，插件该精简或按工作区少开一点`);
+        }
+        rows.push({
+            plugin,
+            pkg: row.pkg,
+            version: set.version,
+            commands: set.commands.length,
+            synthesized: built.tools.length,
+            chars,
+            tools: built.tools.map((tool) => tool.name),
+        });
+        if (built.tools.length === 0)
+            continue;
+        units.push({
+            id: row.id,
+            plugin,
+            pkg: row.pkg,
+            version: set.version,
+            signature: signatureOf(set.version, commands),
+            commands,
+            tools: built.tools,
+        });
+    }
+    for (const set of sets.values()) {
+        problems.push(`opencli 里装着「${set.plugin}」（${String(set.commands.length)} 条命令），但它不在插件台账里（不是从市场装的）—— 面板上没有它的开关，它的命令这次不进工具面`);
+    }
+    return { units, rows, problems };
+}
+function faceOf(unit, opencliFor, note) {
+    const byTool = new Map(unit.tools.map((tool) => [tool.name, tool.command]));
+    const manifest = {
+        id: unit.id,
+        card: null,
+        tools: unit.tools.map((tool) => ({ name: tool.name, writes: pluginToolWrites(tool.command) })),
+        host: { inject: [] },
+    };
+    return {
+        unit: unit.id,
+        manifest,
+        mount(deps) {
+            const tools = deps.ctx.get('tools');
+            if (tools === undefined) {
+                deps.logger?.info?.(`[dsh-workbench] 没有 tools 服务，跳过 ${unit.plugin} 的命令工具注册`);
+                return { routes: {}, registerTools: () => [] };
+            }
+            const opencli = opencliFor(unit.plugin);
+            const definitions = unit.tools.map((tool) => ({
+                name: tool.name,
+                description: pluginToolDescription(tool.command),
+                parameters: pluginToolParameters(tool.command),
+                output: TEXT_OUTPUT,
+                async execute(raw, exec) {
+                    const workspace = sessionWorkspace(exec);
+                    try {
+                        const result = await opencli.json([tool.command.name, ...pluginToolArgv(tool.command, raw)], {
+                            session: pluginToolSession(tool.command),
+                            ...(workspace === null ? {} : { workdir: workspace }),
+                        });
+                        return { text: jsonText(result.value) };
+                    }
+                    catch (error) {
+                        throw new Error(pluginLoginHint(error, tool.command.domain), { cause: error });
+                    }
+                },
+            }));
+            return {
+                routes: {},
+                factsOf: () => [],
+                registerTools: () => {
+                    const disposers = [];
+                    for (const definition of definitions) {
+                        try {
+                            disposers.push(tools.register(definition));
+                        }
+                        catch (error) {
+                            note(`「${unit.plugin}」的 ${definition.name} 这把工具没注册上（${error instanceof Error ? error.message : String(error)}）—— 只废这一把，同插件其余命令照常`);
+                        }
+                    }
+                    return disposers;
+                },
+                needsApproval: (call) => {
+                    const command = call.name === undefined ? undefined : byTool.get(call.name);
+                    return command === undefined ? undefined : pluginApprovalFor(command)(call);
+                },
+            };
+        },
+    };
+}
+function reconcile(registered, units, options, note) {
+    const wanted = new Map(units.map((unit) => [unit.id, unit]));
+    for (const [id, item] of [...registered]) {
+        const next = wanted.get(id);
+        if (next !== undefined && next.signature === item.signature)
+            continue;
+        item.drop();
+        registered.delete(id);
+    }
+    for (const unit of units) {
+        if (registered.has(unit.id))
+            continue;
+        registered.set(unit.id, {
+            signature: unit.signature,
+            tools: unit.tools.map((tool) => tool.name),
+            drop: options.registry.registerPlugin(faceOf(unit, options.opencliFor, note)),
+        });
+    }
+}
+export function createPluginUnits(options) {
+    const registered = new Map();
+    const mountProblems = new Set();
+    let report = { ok: false, at: 0, plugins: [], problems: ['还没探过 opencli 的插件命令面'] };
+    let inflight;
+    let lastTouch = 0;
+    let warned = '';
+    function note(problem) {
+        if (mountProblems.has(problem))
+            return;
+        mountProblems.add(problem);
+        options.logger?.warn?.(`[dsh-workbench] ${problem}`);
+    }
+    function snapshot() {
+        const extra = [...mountProblems];
+        return extra.length === 0 ? report : { ...report, problems: [...report.problems, ...extra] };
+    }
+    function warn(problems) {
+        const text = [...problems].sort().join('\n');
+        if (text === '' || text === warned)
+            return;
+        warned = text;
+        options.logger?.warn?.(`[dsh-workbench] opencli 插件命令面：\n${text}`);
+    }
+    async function run(force) {
+        mountProblems.clear();
+        const probed = await options.catalog.refresh(force ? { force: true } : {});
+        if (!probed.ok) {
+            const problems = [
+                ...probed.problems,
+                '这次探测没成功：上面这些插件行的工具面维持在上一份（不是"这些插件没有命令"）',
+            ];
+            report = { ok: false, at: Date.now(), plugins: report.plugins, problems };
+            warn(problems);
+            return snapshot();
+        }
+        const plan = planOf(options, registered);
+        reconcile(registered, plan.units, options, note);
+        report = { ok: true, at: Date.now(), plugins: plan.rows, problems: plan.problems };
+        warn(plan.problems);
+        return snapshot();
+    }
+    function refresh(callOptions = {}) {
+        if (inflight !== undefined)
+            return inflight;
+        const task = run(callOptions.force === true).finally(() => {
+            inflight = undefined;
+        });
+        inflight = task;
+        return task;
+    }
+    return {
+        refresh,
+        touch() {
+            const now = Date.now();
+            if (inflight !== undefined)
+                return;
+            if (now - lastTouch < PROBE_TTL_MS)
+                return;
+            lastTouch = now;
+            void refresh().catch((error) => {
+                options.logger?.warn?.(`[dsh-workbench] 探 opencli 插件命令面时抛了错：${String(error)}`);
+            });
+        },
+        report: () => snapshot(),
+        dispose() {
+            for (const item of registered.values())
+                item.drop();
+            registered.clear();
+        },
+    };
+}

package/dist/registry-declaration.d.ts

@@ -0,0 +1,23 @@
+import type { DshShell } from '@dsh-workbench/shared';
+export declare function localDirOf(spec: string): string | undefined;
+export declare function packageManifestOf(dir: string): Readonly<Record<string, unknown>> | undefined;
+export declare function dshRecordOf(dir: string): unknown | undefined;
+export declare function packageNameOf(dir: string): string | undefined;
+export declare function pathDeclarationOf(spec: string): unknown | undefined;
+export interface RegistryDshLookup {
+    readonly readable: boolean;
+    readonly raw: unknown;
+}
+export declare function registryDshOf(options: {
+    shell: DshShell;
+    name: string;
+    registry?: string | undefined;
+    force?: boolean;
+}): Promise<RegistryDshLookup>;
+export declare function registryDeclarationOf(options: {
+    shell: DshShell;
+    name: string;
+    registry: string;
+    force?: boolean;
+}): Promise<unknown | undefined>;
+export declare function declarationRefusalOf(name: string, raw: unknown): readonly string[];

package/dist/registry-declaration.js

@@ -0,0 +1,56 @@
+import fs from 'node:fs';
+import { npmCacheDir } from '@dsh-workbench/adapter-runtime';
+import path from 'node:path';
+import { declarationProblemsOf, parseJsonLoose, quoteShellArg, runShell, VERSION_CHECK_TIMEOUT_MS, VERSION_CHECK_TTL_MS, } from '@dsh-workbench/shared/host';
+const cache = new Map();
+function asRecord(value) {
+    return typeof value === 'object' && value !== null ? value : undefined;
+}
+export function localDirOf(spec) {
+    const dir = spec.trim().replace(/^(?:file|link):/, '');
+    return path.isAbsolute(dir) ? dir : undefined;
+}
+export function packageManifestOf(dir) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf8'));
+        return asRecord(parsed);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function dshRecordOf(dir) {
+    return packageManifestOf(dir)?.dsh;
+}
+export function packageNameOf(dir) {
+    const name = packageManifestOf(dir)?.name;
+    return typeof name === 'string' && name.trim() !== '' ? name.trim() : undefined;
+}
+export function pathDeclarationOf(spec) {
+    const dir = localDirOf(spec);
+    return dir === undefined ? undefined : asRecord(dshRecordOf(dir))?.workbench;
+}
+export async function registryDshOf(options) {
+    const { shell, name, registry, force = false } = options;
+    const key = `${registry ?? ''}|${name}`;
+    const hit = cache.get(key);
+    if (!force && hit !== undefined && Date.now() - hit.at < VERSION_CHECK_TTL_MS) {
+        return { readable: true, raw: hit.raw };
+    }
+    const at = registry === undefined ? '' : ` --registry ${quoteShellArg(registry)}`;
+    const result = await runShell(shell, `npm view ${quoteShellArg(name)} dsh --json${at} --cache ${quoteShellArg(npmCacheDir())}`, { timeoutMs: VERSION_CHECK_TIMEOUT_MS }).catch(() => undefined);
+    const parsed = result?.exitCode === 0 ? parseJsonLoose(result.stdout) : undefined;
+    if (parsed === undefined)
+        return { readable: false, raw: undefined };
+    cache.set(key, { at: Date.now(), raw: parsed });
+    return { readable: true, raw: parsed };
+}
+export async function registryDeclarationOf(options) {
+    const found = await registryDshOf(options);
+    return found.readable ? asRecord(found.raw)?.workbench : undefined;
+}
+export function declarationRefusalOf(name, raw) {
+    if (raw === undefined)
+        return [];
+    return declarationProblemsOf(name, raw);
+}

package/dist/unit-registry-types.d.ts

@@ -0,0 +1,12 @@
+export interface UnitRefusal {
+    readonly unit: string;
+    readonly reason: string;
+}
+export interface UnitRegistry {
+    all(): readonly unknown[];
+    declarationOf?(unit: string): {
+        readonly pkg: string;
+        readonly declaration: unknown;
+    } | undefined;
+    registerPlugin(face: unknown): () => void;
+}

package/dist/unit-registry-types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,40 @@
 {
   "name": "@dsh-workbench/adapter-supply",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "1.0.0-beta.0",
+  "description": "Workbench supply adapter package.",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/novaeth/dsh-workbench.git",
+    "directory": "packages/adapter-supply"
+  },
+  "dependencies": {
+    "@dsh-workbench/adapter-runtime": "1.0.0-beta.0",
+    "@dsh-workbench/shared": "1.0.0-beta.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.19.0",
+    "vitest": "^5.0.2",
+    "@vitest/coverage-v8": "^5.0.2"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run",
+    "arch": "arch-guard",
+    "check:runtimes": "node ../../scripts/check-adapter-package.mjs --runtime",
+    "coverage": "vitest run --coverage --coverage.reporter=text-summary --testTimeout=20000"
+  }
 }