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

package/dist/package-kind.d.ts

@@ -0,0 +1,21 @@
+export type PackageKind = 'opencli-plugin' | 'dsh-bundle' | 'both' | 'neither';
+export interface PackageVerdict {
+    readonly kind: PackageKind;
+    readonly pkg?: string;
+    readonly pluginName?: string;
+}
+export interface NpmRef {
+    readonly name: string;
+    readonly version?: string;
+}
+export declare const OPENCLI_MANIFEST_FILE = "opencli-plugin.json";
+export declare function splitNpmSpec(spec: string): NpmRef | undefined;
+export declare function isCommandFile(name: string): boolean;
+export declare function pluginManifestOf(dir: string): Readonly<Record<string, unknown>> | undefined;
+export declare function hasCommandFile(dir: string): boolean;
+export declare function pluginAt(dir: string): {
+    readonly name?: string;
+} | undefined;
+export declare function dshMarkersOf(raw: unknown): boolean;
+export declare function verdictOf(dir: string): PackageVerdict | undefined;
+export declare function refusalReason(): string;

package/dist/package-kind.js

@@ -0,0 +1,73 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { isPackageName } from './installed-module.js';
+import { dshRecordOf, packageManifestOf, packageNameOf } from './registry-declaration.js';
+export const OPENCLI_MANIFEST_FILE = 'opencli-plugin.json';
+const VERSION = /^[a-zA-Z0-9][a-zA-Z0-9._+-]*$/;
+export function splitNpmSpec(spec) {
+    const value = spec.trim();
+    const at = value.lastIndexOf('@');
+    const name = at > 0 ? value.slice(0, at) : value;
+    const version = at > 0 ? value.slice(at + 1) : '';
+    if (!isPackageName(name))
+        return undefined;
+    if (version !== '' && !VERSION.test(version))
+        return undefined;
+    return { name, ...(version === '' ? {} : { version }) };
+}
+function asRecord(value) {
+    return typeof value === 'object' && value !== null ? value : undefined;
+}
+export function isCommandFile(name) {
+    if (name.endsWith('.d.ts') || name.endsWith('.test.ts'))
+        return false;
+    if (name.endsWith('.d.js'))
+        return false;
+    return name.endsWith('.ts') || name.endsWith('.js');
+}
+export function pluginManifestOf(dir) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(path.join(dir, OPENCLI_MANIFEST_FILE), 'utf8'));
+        if (Array.isArray(parsed))
+            return undefined;
+        return asRecord(parsed);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function hasCommandFile(dir) {
+    try {
+        return fs.readdirSync(dir).some(isCommandFile);
+    }
+    catch {
+        return false;
+    }
+}
+export function pluginAt(dir) {
+    const manifest = pluginManifestOf(dir);
+    if (manifest === undefined || !hasCommandFile(dir))
+        return undefined;
+    const name = manifest.name;
+    return typeof name === 'string' && name.trim() !== '' ? { name: name.trim() } : {};
+}
+export function dshMarkersOf(raw) {
+    const record = asRecord(raw);
+    return record !== undefined && ('bundle' in record || 'workbench' in record);
+}
+export function verdictOf(dir) {
+    const plugin = pluginAt(dir);
+    if (packageManifestOf(dir) === undefined && plugin === undefined)
+        return undefined;
+    const dsh = dshMarkersOf(dshRecordOf(dir));
+    const kind = plugin !== undefined && dsh ? 'both' : plugin !== undefined ? 'opencli-plugin' : dsh ? 'dsh-bundle' : 'neither';
+    const pkg = packageNameOf(dir);
+    return {
+        kind,
+        ...(pkg === undefined ? {} : { pkg }),
+        ...(plugin?.name === undefined ? {} : { pluginName: plugin.name }),
+    };
+}
+export function refusalReason() {
+    return '这个包既不是工作台的模块，也不是 opencli 的插件，装了也用不上';
+}

package/dist/package-route.d.ts

@@ -0,0 +1,23 @@
+import type { DshShell } from '@dsh-workbench/shared';
+import { type ResolvedPluginSource } from './plugin-source.js';
+export type PackageRouteKind = 'opencli-plugin' | 'dsh-bundle' | 'neither';
+export interface PackageRoute {
+    readonly kind: PackageRouteKind;
+    readonly pkg?: string;
+    readonly pluginName?: string;
+}
+export declare const LOCAL_PLUGIN_ENV = "DSH_WB_OPENCLI_PLUGIN_PATH";
+export declare const PLUGIN_REGISTRY_ENV = "DSH_WB_OPENCLI_PLUGIN_REGISTRY";
+export declare function packageRouteOf(options: {
+    readonly spec: string;
+    readonly shell?: DshShell | undefined;
+    readonly registry?: string | undefined;
+    readonly force?: boolean;
+}): Promise<PackageRoute | undefined>;
+export declare function resetPackageRouteCache(): void;
+export declare function pluginInstallPlan(options: {
+    readonly spec: string;
+    readonly command: string;
+    readonly registry?: string | undefined;
+    readonly pluginName?: string | undefined;
+}): ResolvedPluginSource;

package/dist/package-route.js

@@ -0,0 +1,74 @@
+import { VERSION_CHECK_TTL_MS } from '@dsh-workbench/shared/host';
+import { resolvePluginSource } from './plugin-source.js';
+import { dshMarkersOf, splitNpmSpec, verdictOf } from './package-kind.js';
+import { withPackageDir } from './package-content.js';
+import { localDirOf, registryDshOf } from './registry-declaration.js';
+export const LOCAL_PLUGIN_ENV = 'DSH_WB_OPENCLI_PLUGIN_PATH';
+export const PLUGIN_REGISTRY_ENV = 'DSH_WB_OPENCLI_PLUGIN_REGISTRY';
+const cache = new Map();
+function routeOfVerdict(verdict, fallback) {
+    const pkg = verdict.pkg ?? fallback;
+    if (verdict.kind === 'neither')
+        return { kind: 'neither', ...(pkg === undefined ? {} : { pkg }) };
+    if (verdict.kind === 'dsh-bundle' || verdict.kind === 'both')
+        return { kind: 'dsh-bundle' };
+    return {
+        kind: 'opencli-plugin',
+        ...(pkg === undefined ? {} : { pkg }),
+        ...(verdict.pluginName === undefined ? {} : { pluginName: verdict.pluginName }),
+    };
+}
+export async function packageRouteOf(options) {
+    const local = localDirOf(options.spec);
+    if (local !== undefined) {
+        const verdict = verdictOf(local);
+        return verdict === undefined ? undefined : routeOfVerdict(verdict, splitNpmSpec(options.spec)?.name);
+    }
+    const ref = splitNpmSpec(options.spec);
+    if (ref === undefined)
+        return undefined;
+    const shell = options.shell;
+    const registry = options.registry;
+    if (shell === undefined || registry === undefined)
+        return undefined;
+    const key = `${registry}|${options.spec}`;
+    const hit = cache.get(key);
+    if (options.force !== true && hit !== undefined && Date.now() - hit.at < VERSION_CHECK_TTL_MS) {
+        return hit.route ?? undefined;
+    }
+    const found = await registryDshOf({ shell, name: options.spec, registry });
+    let route;
+    if (found.readable && dshMarkersOf(found.raw)) {
+        route = { kind: 'dsh-bundle' };
+    }
+    else {
+        const verdict = await withPackageDir({ shell, spec: options.spec, registry }, (dir) => verdictOf(dir));
+        route = verdict === undefined ? undefined : routeOfVerdict(verdict, ref.name);
+    }
+    cache.set(key, { at: Date.now(), route: route ?? null });
+    return route;
+}
+export function resetPackageRouteCache() {
+    cache.clear();
+}
+export function pluginInstallPlan(options) {
+    const local = localDirOf(options.spec);
+    if (local !== undefined) {
+        return resolvePluginSource({ kind: 'local', env: LOCAL_PLUGIN_ENV }, { [LOCAL_PLUGIN_ENV]: local }, { command: options.command });
+    }
+    const ref = splitNpmSpec(options.spec);
+    if (ref === undefined)
+        return { ok: false, problem: 'malformed' };
+    const source = {
+        kind: 'npm',
+        package: ref.name,
+        registryEnv: PLUGIN_REGISTRY_ENV,
+        ...(options.registry === undefined ? {} : { registryDefault: options.registry }),
+    };
+    return resolvePluginSource(source, { [PLUGIN_REGISTRY_ENV]: options.registry }, {
+        command: options.command,
+        ...(options.pluginName === undefined ? {} : { plugin: options.pluginName }),
+        ...(ref.version === undefined ? {} : { version: ref.version }),
+        mode: 'install',
+    });
+}

package/dist/plugin-catalog.d.ts

@@ -0,0 +1,65 @@
+import type { DshShell } from '@dsh-workbench/shared';
+export interface PluginCommandArg {
+    readonly name: string;
+    readonly type: string;
+    readonly required: boolean;
+    readonly positional: boolean;
+    readonly valueRequired: boolean;
+    readonly choices: readonly string[];
+    readonly defaultValue?: unknown;
+    readonly help: string;
+}
+export interface PluginCommand {
+    readonly plugin: string;
+    readonly name: string;
+    readonly description: string;
+    readonly access: string;
+    readonly browser: boolean;
+    readonly siteSession: string;
+    readonly domain?: string;
+    readonly args: readonly PluginCommandArg[];
+}
+export interface PluginCommandSet {
+    readonly plugin: string;
+    readonly version: string;
+    readonly commands: readonly PluginCommand[];
+}
+export interface PluginRow {
+    readonly name: string;
+    readonly version: string;
+    readonly commands: readonly string[];
+}
+export interface CommandRow {
+    readonly site: string;
+    readonly name: string;
+    readonly description: string;
+    readonly access: string;
+    readonly browser: boolean;
+    readonly siteSession: string;
+    readonly domain?: string;
+    readonly args: readonly PluginCommandArg[];
+}
+export interface PluginCatalogSnapshot {
+    readonly ok: boolean;
+    readonly at: number;
+    readonly sets: readonly PluginCommandSet[];
+    readonly problems: readonly string[];
+}
+export interface PluginCatalog {
+    refresh(options?: {
+        readonly force?: boolean;
+    }): Promise<PluginCatalogSnapshot>;
+    snapshot(): PluginCatalogSnapshot;
+}
+export interface PluginCatalogOptions {
+    readonly shell?: DshShell | undefined;
+    readonly command: string;
+    readonly timeoutMs?: number;
+}
+export declare function parsePluginRows(stdout: string): PluginRow[] | undefined;
+export declare function parseCommandRows(stdout: string): CommandRow[] | undefined;
+export declare function attributeCommands(plugins: readonly PluginRow[], rows: readonly CommandRow[]): {
+    readonly sets: PluginCommandSet[];
+    readonly problems: string[];
+};
+export declare function createPluginCatalog(options: PluginCatalogOptions): PluginCatalog;

package/dist/plugin-catalog.js

@@ -0,0 +1,192 @@
+import { OPENCLI_TIMEOUT_MS, parseJsonLoose, runShell } from '@dsh-workbench/shared/host';
+function recordOf(value) {
+    return typeof value === 'object' && value !== null ? value : undefined;
+}
+function textOf(value) {
+    return typeof value === 'string' ? value : '';
+}
+function stringsOf(value) {
+    return Array.isArray(value) ? value.filter((item) => typeof item === 'string') : [];
+}
+function argsOf(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    return raw.flatMap((item) => {
+        const record = recordOf(item);
+        if (record === undefined)
+            return [];
+        const name = textOf(record['name']).trim();
+        if (name === '')
+            return [];
+        const fallback = record['default'];
+        return [
+            {
+                name,
+                type: textOf(record['type']) || 'string',
+                required: record['required'] === true,
+                positional: record['positional'] === true,
+                valueRequired: record['valueRequired'] === true,
+                choices: stringsOf(record['choices']),
+                ...(fallback === undefined || fallback === null ? {} : { defaultValue: fallback }),
+                help: textOf(record['help']),
+            },
+        ];
+    });
+}
+export function parsePluginRows(stdout) {
+    const parsed = parseJsonLoose(stdout);
+    if (!Array.isArray(parsed))
+        return undefined;
+    const rows = [];
+    for (const item of parsed) {
+        const record = recordOf(item);
+        if (record === undefined)
+            return undefined;
+        const name = textOf(record['name']).trim();
+        if (name === '')
+            return undefined;
+        rows.push({ name, version: textOf(record['version']), commands: stringsOf(record['commands']) });
+    }
+    return rows;
+}
+export function parseCommandRows(stdout) {
+    const parsed = parseJsonLoose(stdout);
+    if (!Array.isArray(parsed))
+        return undefined;
+    const rows = [];
+    for (const item of parsed) {
+        const record = recordOf(item);
+        if (record === undefined)
+            return undefined;
+        const site = textOf(record['site']).trim();
+        const name = textOf(record['name']).trim();
+        if (site === '' || name === '')
+            return undefined;
+        rows.push({
+            site,
+            name,
+            description: textOf(record['description']),
+            access: textOf(record['access']),
+            browser: record['browser'] === true,
+            siteSession: textOf(record['siteSession']),
+            ...(textOf(record['domain']) === '' ? {} : { domain: textOf(record['domain']) }),
+            args: argsOf(record['args']),
+        });
+    }
+    return rows;
+}
+function commandOf(plugin, row) {
+    return {
+        plugin,
+        name: row.name,
+        description: row.description,
+        access: row.access,
+        browser: row.browser,
+        siteSession: row.siteSession,
+        ...(row.domain === undefined ? {} : { domain: row.domain }),
+        args: row.args,
+    };
+}
+export function attributeCommands(plugins, rows) {
+    const bySite = new Map();
+    for (const row of rows) {
+        const site = bySite.get(row.site) ?? new Map();
+        site.set(row.name, row);
+        bySite.set(row.site, site);
+    }
+    const sets = [];
+    const problems = [];
+    if (plugins.length > 0 && rows.length === 0) {
+        problems.push(`opencli 报了 ${String(plugins.length)} 个插件，但命令面（opencli list -f json）里一条命令都没有 —— 两份清单对不上`);
+    }
+    for (const plugin of plugins) {
+        const found = bySite.get(plugin.name) ?? new Map();
+        if (found.size === 0) {
+            problems.push(`「${plugin.name}」在 opencli 插件清单里，但命令面里没有一条 site=${plugin.name} 的命令 —— 归属不了，它这次不合成工具`);
+            continue;
+        }
+        const declared = plugin.commands.length > 0 ? plugin.commands : [...found.keys()];
+        const missing = declared.filter((name) => !found.has(name));
+        if (missing.length > 0) {
+            problems.push(`「${plugin.name}」自己的清单里有 ${String(missing.length)} 条命令在命令面里找不到：${missing.join('、')}（插件版本旧或命令面没更新）`);
+        }
+        const commands = declared.flatMap((name) => {
+            const row = found.get(name);
+            return row === undefined ? [] : [commandOf(plugin.name, row)];
+        });
+        if (commands.length === 0) {
+            problems.push(`「${plugin.name}」没有任何一条能归属的命令 —— 它这次不合成工具`);
+            continue;
+        }
+        sets.push({ plugin: plugin.name, version: plugin.version, commands });
+    }
+    return { sets, problems };
+}
+function fingerprintOf(plugins) {
+    return plugins
+        .map((plugin) => `${plugin.name}@${plugin.version}:${[...plugin.commands].sort().join(',')}`)
+        .sort()
+        .join('|');
+}
+function messageOf(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+export function createPluginCatalog(options) {
+    const timeoutMs = options.timeoutMs ?? OPENCLI_TIMEOUT_MS;
+    let current = {
+        ok: false,
+        at: 0,
+        sets: [],
+        problems: ['还没探过 opencli 的插件命令面'],
+    };
+    let heavy;
+    async function read(line) {
+        const shell = options.shell;
+        if (shell === undefined) {
+            return { ok: false, problem: '没有执行缝（shell 服务不可用），探不了这个命令面' };
+        }
+        try {
+            const result = await runShell(shell, line, { timeoutMs });
+            if (result.timedOut)
+                return { ok: false, problem: `${line} 超过 ${String(Math.round(timeoutMs / 1000))} 秒没返回` };
+            if (result.exitCode !== 0) {
+                const tail = result.stderr.trim() || result.stdout.trim();
+                return { ok: false, problem: `${line} 退出码 ${String(result.exitCode)}${tail === '' ? '' : `：${tail.split('\n').slice(-3).join(' ')}`}` };
+            }
+            return { ok: true, stdout: result.stdout };
+        }
+        catch (error) {
+            return { ok: false, problem: `${line} 没跑起来：${messageOf(error)}` };
+        }
+    }
+    function fail(problem) {
+        current = { ok: false, at: Date.now(), sets: current.sets, problems: [problem] };
+        return current;
+    }
+    async function refresh(callOptions = {}) {
+        const pluginsRun = await read(`${options.command} plugin list -f json`);
+        if (!pluginsRun.ok)
+            return fail(pluginsRun.problem);
+        const plugins = parsePluginRows(pluginsRun.stdout);
+        if (plugins === undefined) {
+            return fail('opencli plugin list -f json 的输出读不懂（不是带 name 的 JSON 数组）');
+        }
+        const fingerprint = fingerprintOf(plugins);
+        if (!callOptions.force && heavy !== undefined && heavy.fingerprint === fingerprint) {
+            current = { ok: true, at: Date.now(), sets: heavy.sets, problems: heavy.problems };
+            return current;
+        }
+        const commandsRun = await read(`${options.command} list -f json`);
+        if (!commandsRun.ok)
+            return fail(commandsRun.problem);
+        const rows = parseCommandRows(commandsRun.stdout);
+        if (rows === undefined) {
+            return fail('opencli list -f json 的输出读不懂（不是带 site / name 的 JSON 数组）');
+        }
+        const attributed = attributeCommands(plugins, rows);
+        heavy = { fingerprint, sets: attributed.sets, problems: attributed.problems };
+        current = { ok: true, at: Date.now(), sets: attributed.sets, problems: attributed.problems };
+        return current;
+    }
+    return { refresh, snapshot: () => current };
+}

package/dist/plugin-login-hint.d.ts

@@ -0,0 +1,2 @@
+export declare function loginUrlOfDomain(domain: string | undefined): string | undefined;
+export declare function pluginLoginHint(error: unknown, domain: string | undefined): string;

package/dist/plugin-login-hint.js

@@ -0,0 +1,33 @@
+const NOT_LOGGED_IN = /未登录|请先登录|not logged in/i;
+function propertyOf(error, key) {
+    return typeof error === 'object' && error !== null
+        ? error[key]
+        : undefined;
+}
+function helpUrlOfError(error) {
+    const raw = propertyOf(error, 'helpUrl');
+    if (typeof raw !== 'string')
+        return undefined;
+    const trimmed = raw.trim();
+    return trimmed === '' ? undefined : trimmed;
+}
+function isAuthFailure(error, message) {
+    if (NOT_LOGGED_IN.test(message))
+        return true;
+    return propertyOf(error, 'code') === 'auth-required';
+}
+export function loginUrlOfDomain(domain) {
+    const bare = (domain ?? '').trim().replace(/\/+$/, '');
+    if (bare === '' || bare.includes('*'))
+        return undefined;
+    return /^https?:\/\//.test(bare) ? bare : `https://${bare}/login`;
+}
+export function pluginLoginHint(error, domain) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (!isAuthFailure(error, message))
+        return message;
+    const url = helpUrlOfError(error) ?? loginUrlOfDomain(domain);
+    if (url !== undefined)
+        return `${message}\n在 opencli 那扇浏览器窗里打开 ${url} 登一次，然后重试。`;
+    return `${message}\n在 opencli 那扇浏览器窗里登录这个站点（插件没给出具体地址，工作台拼不出来）—— 或跑一次工作台的体检/预热，然后重试。`;
+}

package/dist/plugin-source.d.ts

@@ -0,0 +1,2 @@
+export type { ProvisionProblem } from '@dsh-workbench/shared/host';
+export { npmRegistryOf, resolvePluginSource, type PluginSourceCommand, type PluginSourceOptions, type ResolvedPluginSource, } from '@dsh-workbench/shared/host';

package/dist/plugin-source.js

@@ -0,0 +1 @@
+export { npmRegistryOf, resolvePluginSource, } from '@dsh-workbench/shared/host';

package/dist/plugin-tools.d.ts

@@ -0,0 +1,15 @@
+import type { ApprovalDetail, ApprovalPolicy } from '@dsh-workbench/shared/host';
+import type { OpencliSession } from '@dsh-workbench/adapter-runtime';
+import type { PluginCommand } from './plugin-catalog.js';
+export declare const RUN_CODE_TOOL = "run_code";
+export declare const PLUGIN_PROMPT_BUDGET = 4000;
+export declare function pluginToolName(plugin: string, command: string): string;
+export declare function pluginPromptChars(command: PluginCommand): number;
+export declare function pluginToolParameters(command: PluginCommand): Record<string, unknown>;
+export declare function pluginToolDescription(command: PluginCommand): string;
+export declare function pluginToolWrites(command: PluginCommand): boolean;
+export declare function pluginToolSession(command: PluginCommand): OpencliSession;
+export declare function pluginToolArgv(command: PluginCommand, raw: unknown): string[];
+export declare function pluginKeyArgs(command: PluginCommand, raw: unknown): string;
+export declare function pluginApprovalQuestion(command: PluginCommand, raw: unknown): ApprovalDetail;
+export declare function pluginApprovalFor(command: PluginCommand): ApprovalPolicy;

package/dist/plugin-tools.js

@@ -0,0 +1,134 @@
+import { withApprovalNote } from '@dsh-workbench/shared/host';
+const SCHEMA_TYPE = {
+    int: 'integer',
+    integer: 'integer',
+    number: 'number',
+    float: 'number',
+    bool: 'boolean',
+    boolean: 'boolean',
+    string: 'string',
+};
+const KEY_ARG_LIMIT = 3;
+const NO_KEY_ARGS = '没有带参数';
+export const RUN_CODE_TOOL = 'run_code';
+export const PLUGIN_PROMPT_BUDGET = 4_000;
+export function pluginToolName(plugin, command) {
+    return `${plugin}_${command}`
+        .toLowerCase()
+        .replace(/[^a-z0-9_]+/g, '_')
+        .replace(/_{2,}/g, '_')
+        .replace(/^_+|_+$/g, '');
+}
+function schemaTypeOf(arg) {
+    return SCHEMA_TYPE[arg.type.toLowerCase()] ?? 'string';
+}
+function propertyOf(arg) {
+    const type = schemaTypeOf(arg);
+    const enumValues = type === 'string' && arg.choices.length > 0 ? [...arg.choices] : undefined;
+    return {
+        type,
+        ...(arg.help.trim() === '' ? {} : { description: arg.help.trim() }),
+        ...(enumValues === undefined ? {} : { enum: enumValues }),
+        ...(arg.defaultValue === undefined ? {} : { default: arg.defaultValue }),
+    };
+}
+export function pluginPromptChars(command) {
+    return (pluginToolDescription(command).length +
+        command.args.reduce((sum, arg) => sum + arg.help.trim().length, 0));
+}
+export function pluginToolParameters(command) {
+    const properties = {};
+    for (const arg of command.args)
+        properties[arg.name] = propertyOf(arg);
+    const required = command.args.filter((arg) => arg.required).map((arg) => arg.name);
+    const schema = {
+        type: 'object',
+        properties,
+        ...(required.length === 0 ? {} : { required }),
+        additionalProperties: false,
+    };
+    return pluginToolWrites(command) ? withApprovalNote(schema, { required: true }) : schema;
+}
+export function pluginToolDescription(command) {
+    const described = command.description.trim();
+    return described === '' ? `${command.plugin} ${command.name}（opencli 命令）` : described;
+}
+export function pluginToolWrites(command) {
+    return command.access !== 'read';
+}
+export function pluginToolSession(command) {
+    if (!command.browser)
+        return 'none';
+    if (command.siteSession === 'persistent' || command.siteSession === 'ephemeral') {
+        return command.siteSession;
+    }
+    return command.access === 'read' ? 'persistent' : 'ephemeral';
+}
+function valuesOf(raw) {
+    return typeof raw === 'object' && raw !== null ? raw : {};
+}
+export function pluginToolArgv(command, raw) {
+    const values = valuesOf(raw);
+    const argv = [];
+    for (const arg of command.args) {
+        if (!arg.positional)
+            continue;
+        const value = values[arg.name];
+        if (value === undefined || value === null)
+            continue;
+        argv.push(String(value));
+    }
+    for (const arg of command.args) {
+        if (arg.positional)
+            continue;
+        const value = values[arg.name];
+        if (value === undefined || value === null)
+            continue;
+        if (typeof value === 'boolean')
+            argv.push(`--${arg.name}=${value ? 'true' : 'false'}`);
+        else if (Array.isArray(value))
+            argv.push(`--${arg.name}=${value.map((item) => String(item)).join(',')}`);
+        else
+            argv.push(`--${arg.name}=${String(value)}`);
+    }
+    return argv;
+}
+export function pluginKeyArgs(command, raw) {
+    const values = valuesOf(raw);
+    const ordered = [...command.args.filter((arg) => arg.required), ...command.args.filter((arg) => !arg.required)];
+    const parts = [];
+    for (const arg of ordered) {
+        const value = values[arg.name];
+        if (value === undefined || value === null || value === '')
+            continue;
+        parts.push(`${arg.name}=${String(value)}`);
+        if (parts.length === KEY_ARG_LIMIT)
+            break;
+    }
+    return parts.length === 0 ? NO_KEY_ARGS : parts.join('、');
+}
+export function pluginApprovalQuestion(command, raw) {
+    const key = pluginKeyArgs(command, raw);
+    const zhKey = key === NO_KEY_ARGS ? '这次没带参数' : key;
+    const enKey = key === NO_KEY_ARGS ? 'no arguments' : key;
+    return {
+        zh: `agent 想执行工作台 [${command.plugin}] opencli 插件的 [${command.name}] 命令（${zhKey}），允许吗？`,
+        en: `The agent wants to run the [${command.name}] command of the workbench opencli plugin [${command.plugin}] (${enKey}). Allow?`,
+    };
+}
+export function pluginApprovalFor(command) {
+    const denied = command.access === 'read';
+    return (call) => {
+        if (denied)
+            return { kind: 'read' };
+        const question = pluginApprovalQuestion(command, call.arguments);
+        return {
+            kind: 'ask',
+            reason: command.access === 'write'
+                ? `${command.plugin} ${command.name} 在 opencli 里标着 write`
+                : `${command.plugin} ${command.name} 没有拿到 access（fail-safe：按写处理）`,
+            question,
+            fallback: question,
+        };
+    };
+}