@steerable/agent-shell 0.6.52 → 0.6.53

package/dist/mcp-server-registry.js

@@ -9,7 +9,7 @@
  * 实现，单测用内存实现——本模块不 import electron，保持纯 Node 可测。
  */
 import { randomUUID } from 'node:crypto';
-import { mcpExecutor } from './mcp-executor.js';
+import { MAX_MCP_SERVER_TOOLS, mcpExecutor, } from './mcp-executor.js';
 const STORE_KEY = 'mcpServers';
 /** 工具名只允许 [a-z0-9-]；中文名会被剥光，退化为 srv-<id前6位>。 */
 export function sanitizeServerKey(name, id) {
@@ -19,15 +19,90 @@ export function sanitizeServerKey(name, id) {
         .replace(/^-+|-+$/g, '');
     return cleaned || `srv-${id.slice(0, 6)}`;
 }
+function normalizeStoredEntry(entry) {
+    if ('transport' in entry)
+        return entry;
+    const legacy = entry;
+    return { ...legacy, transport: 'stdio' };
+}
+function normalizeTransportInput(input) {
+    if (input.transport === 'streamable-http') {
+        const raw = input;
+        if (typeof raw.command === 'string' && raw.command.trim()) {
+            throw new Error('Streamable HTTP 配置不能包含 command');
+        }
+        const url = parseMcpHttpUrl(input.url);
+        const headers = { ...(input.headers ?? {}) };
+        if (Object.keys(headers).some((name) => name.toLowerCase() === 'authorization')) {
+            throw new Error('Authorization 不允许明文保存；请使用 bearerTokenEnvVar 或 headersFromEnv');
+        }
+        const bearerTokenEnvVar = input.bearerTokenEnvVar?.trim() || undefined;
+        return {
+            transport: 'streamable-http',
+            url,
+            headers,
+            headersFromEnv: { ...(input.headersFromEnv ?? {}) },
+            bearerTokenEnvVar,
+            reconnect: input.reconnect ? { ...input.reconnect } : undefined,
+        };
+    }
+    if ('url' in input && typeof input.url === 'string' && input.url.trim()) {
+        throw new Error('stdio 配置不能包含 url');
+    }
+    const command = input.command.trim();
+    if (!command)
+        throw new Error('启动命令不能为空');
+    return {
+        transport: 'stdio',
+        command,
+        args: (input.args ?? []).map(String),
+        env: { ...(input.env ?? {}) },
+        cwd: input.cwd?.trim() || undefined,
+    };
+}
+function parseMcpHttpUrl(raw) {
+    let url;
+    try {
+        url = new URL(raw.trim());
+    }
+    catch {
+        throw new Error('MCP HTTP URL 无效');
+    }
+    if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+        throw new Error('MCP HTTP URL 必须使用 http 或 https');
+    }
+    if (url.username || url.password) {
+        throw new Error('MCP HTTP URL 不能包含凭据');
+    }
+    return url.toString();
+}
+function stringRecord(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return {};
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+        key,
+        String(item),
+    ]));
+}
+function stringValue(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
 export class McpServerRegistry {
     store;
+    executor;
     /** serverId → 最近一次 listTools 的结果（内存缓存，重启后由后台刷新重建）。 */
     toolCache = new Map();
-    constructor(store) {
+    constructor(store, executor = mcpExecutor) {
         this.store = store;
+        this.executor = executor;
     }
     list() {
-        return this.store.get(STORE_KEY) ?? [];
+        const stored = this.store.get(STORE_KEY) ?? [];
+        const migrated = stored.map(normalizeStoredEntry);
+        if (migrated.some((entry, index) => entry !== stored[index])) {
+            this.store.set(STORE_KEY, migrated);
+        }
+        return migrated;
     }
     get(idOrName) {
         const needle = idOrName.trim().toLowerCase();
@@ -43,24 +118,18 @@ export class McpServerRegistry {
     }
     create(input) {
         const name = input.name.trim();
-        const command = input.command.trim();
         if (!name)
             throw new Error('服务名称不能为空');
-        if (!command)
-            throw new Error('启动命令不能为空');
         if (this.get(name))
             throw new Error(`已存在同名服务「${name}」`);
         const now = new Date().toISOString();
         const entry = {
             id: randomUUID(),
             name,
-            command,
-            args: (input.args ?? []).map((a) => String(a)),
-            env: { ...(input.env ?? {}) },
-            cwd: input.cwd?.trim() || undefined,
             enabled: input.enabled ?? true,
             createdAt: now,
             updatedAt: now,
+            ...normalizeTransportInput(input),
         };
         this.store.set(STORE_KEY, [...this.list(), entry]);
         return entry;
@@ -77,18 +146,39 @@ export class McpServerRegistry {
         const nameClash = servers.some((s) => s.id !== id && s.name.toLowerCase() === nextName.toLowerCase());
         if (nameClash)
             throw new Error(`已存在同名服务「${nextName}」`);
+        const transport = updates.transport ?? current.transport;
+        const transportInput = transport === 'stdio'
+            ? {
+                name: nextName,
+                transport: 'stdio',
+                command: updates.command ?? (current.transport === 'stdio' ? current.command : ''),
+                args: updates.args ?? (current.transport === 'stdio' ? current.args : []),
+                env: updates.env ?? (current.transport === 'stdio' ? current.env : {}),
+                cwd: updates.cwd ?? (current.transport === 'stdio' ? current.cwd : undefined),
+            }
+            : {
+                name: nextName,
+                transport: 'streamable-http',
+                url: updates.url ?? (current.transport === 'streamable-http' ? current.url : ''),
+                headers: updates.headers ??
+                    (current.transport === 'streamable-http' ? current.headers : {}),
+                headersFromEnv: updates.headersFromEnv ??
+                    (current.transport === 'streamable-http' ? current.headersFromEnv : {}),
+                bearerTokenEnvVar: updates.bearerTokenEnvVar ??
+                    (current.transport === 'streamable-http'
+                        ? current.bearerTokenEnvVar
+                        : undefined),
+                reconnect: updates.reconnect ??
+                    (current.transport === 'streamable-http' ? current.reconnect : undefined),
+            };
         const next = {
-            ...current,
+            id: current.id,
             name: nextName,
-            command: updates.command !== undefined ? updates.command.trim() : current.command,
-            args: updates.args !== undefined ? updates.args.map((a) => String(a)) : current.args,
-            env: updates.env !== undefined ? { ...updates.env } : current.env,
-            cwd: updates.cwd !== undefined ? updates.cwd.trim() || undefined : current.cwd,
             enabled: updates.enabled !== undefined ? updates.enabled : current.enabled,
+            createdAt: current.createdAt,
             updatedAt: new Date().toISOString(),
+            ...normalizeTransportInput(transportInput),
         };
-        if (!next.command)
-            throw new Error('启动命令不能为空');
         servers[idx] = next;
         this.store.set(STORE_KEY, servers);
         // 配置变了，旧工具缓存不可信
@@ -131,10 +221,27 @@ export class McpServerRegistry {
         for (const [name, cfgRaw] of Object.entries(container)) {
             const cfg = (cfgRaw ?? {});
             const command = typeof cfg.command === 'string' ? cfg.command.trim() : '';
-            if (!command || this.get(name)) {
+            const url = typeof cfg.url === 'string' ? cfg.url.trim() : '';
+            if ((!command && !url) || (command && url) || this.get(name)) {
                 result.skipped.push(name);
                 continue;
             }
+            if (url) {
+                const headers = stringRecord(cfg.headers);
+                const headersFromEnv = stringRecord(cfg.envHttpHeaders ?? cfg.env_http_headers ?? cfg.headersFromEnv);
+                const bearerTokenEnvVar = stringValue(cfg.bearerTokenEnvVar ?? cfg.bearer_token_env_var) || undefined;
+                const entry = this.create({
+                    name: name.trim(),
+                    transport: 'streamable-http',
+                    url,
+                    headers,
+                    headersFromEnv,
+                    bearerTokenEnvVar,
+                    enabled: true,
+                });
+                result.added.push(entry);
+                continue;
+            }
             const env = {};
             if (cfg.env && typeof cfg.env === 'object' && !Array.isArray(cfg.env)) {
                 for (const [k, v] of Object.entries(cfg.env)) {
@@ -160,12 +267,48 @@ export class McpServerRegistry {
         return clash ? `${base}-${entry.id.slice(0, 4)}` : base;
     }
     toExecutorConfig(entry) {
-        return {
-            command: entry.command,
-            args: entry.args,
-            env: entry.env,
-            cwd: entry.cwd,
+        return entry.transport === 'stdio'
+            ? {
+                transport: 'stdio',
+                command: entry.command,
+                args: entry.args,
+                env: entry.env,
+                cwd: entry.cwd,
+            }
+            : {
+                transport: 'streamable-http',
+                url: entry.url,
+                headers: entry.headers,
+                headersFromEnv: entry.headersFromEnv,
+                bearerTokenEnvVar: entry.bearerTokenEnvVar,
+                reconnect: entry.reconnect,
+            };
+    }
+    toPublicEntry(entry) {
+        const common = {
+            id: entry.id,
+            name: entry.name,
+            transport: entry.transport,
+            enabled: entry.enabled,
+            createdAt: entry.createdAt,
+            updatedAt: entry.updatedAt,
         };
+        return entry.transport === 'stdio'
+            ? {
+                ...common,
+                command: entry.command,
+                args: [...entry.args],
+                cwd: entry.cwd,
+                envKeys: Object.keys(entry.env).sort(),
+            }
+            : {
+                ...common,
+                url: entry.url,
+                headerNames: Object.keys(entry.headers).sort(),
+                headersFromEnv: { ...entry.headersFromEnv },
+                bearerTokenEnvVar: entry.bearerTokenEnvVar,
+                reconnect: entry.reconnect,
+            };
     }
     getCachedTools(serverId) {
         return this.toolCache.get(serverId) ?? null;
@@ -211,8 +354,24 @@ export class McpServerRegistry {
         const entry = this.list().find((s) => s.id === serverId);
         if (!entry)
             throw new Error('服务不存在');
-        const result = await mcpExecutor.listTools(this.toExecutorConfig(entry));
-        const cached = result.success
+        const applyChanged = (tools) => {
+            if (tools.length > MAX_MCP_SERVER_TOOLS)
+                return;
+            this.toolCache.set(serverId, {
+                tools: tools.map((tool) => ({ ...tool })),
+                fetchedAt: new Date().toISOString(),
+                error: null,
+            });
+        };
+        const result = await this.executor.listTools(this.toExecutorConfig(entry), applyChanged, (error) => {
+            this.toolCache.set(serverId, {
+                tools: [],
+                fetchedAt: new Date().toISOString(),
+                error,
+            });
+        });
+        const overCap = (result.tools?.length ?? 0) > MAX_MCP_SERVER_TOOLS;
+        const cached = result.success && !overCap
             ? {
                 tools: (result.tools ?? []).map((t) => ({
                     name: t.name,
@@ -222,7 +381,13 @@ export class McpServerRegistry {
                 fetchedAt: new Date().toISOString(),
                 error: null,
             }
-            : { tools: [], fetchedAt: new Date().toISOString(), error: result.error ?? '未知错误' };
+            : {
+                tools: [],
+                fetchedAt: new Date().toISOString(),
+                error: overCap
+                    ? `服务工具数超过每服务 ${MAX_MCP_SERVER_TOOLS} 个的上限`
+                    : result.error ?? '未知错误',
+            };
         this.toolCache.set(serverId, cached);
         return cached;
     }

package/dist/product-config.d.ts

@@ -58,6 +58,11 @@ export interface ProductConfig {
      * STEERABLE_APPROVAL=0 仍是调试逃生口。
      */
     approval?: 'host' | 'off';
+    /**
+     * 白名单外出网询问：host = 弹宿主审批；off = 自动加入当前代理会话。
+     * 缺省 host。自动放行仅存活到代理进程退出，不修改持久白名单。
+     */
+    egressApproval?: 'host' | 'off';
     /**
      * 对话模式。缺省 `['agent','plan']`。只留一种时渲染层不显示切换。
      */
@@ -100,11 +105,20 @@ export interface ProductConfig {
      */
     builtinMcp?: Array<{
         name: string;
+        transport?: 'stdio';
         command: string;
         args?: string[];
         env?: Record<string, string>;
         cwd?: string;
         enabled?: boolean;
+    } | {
+        name: string;
+        transport: 'streamable-http';
+        url: string;
+        headers?: Record<string, string>;
+        headersFromEnv?: Record<string, string>;
+        bearerTokenEnvVar?: string;
+        enabled?: boolean;
     }>;
     /**
      * P3.1 多智能体编排六件套 (agent_spawn / agent_wait / agent_send / agent_interrupt / agent_close / agent_list)。

package/dist/shell-exec.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Shell 执行规划：前缀策略，以及本地 / SSH 的启动参数。
+ * 这里不启动进程。多条前缀同时命中时，取更严的决定：
+ * allow < prompt < forbidden。
+ */
+export type ExecDecisionName = 'allow' | 'prompt' | 'forbidden';
+export interface PrefixRule {
+    argv: string[];
+    decision: ExecDecisionName;
+    justification?: string;
+}
+export interface ExecPolicy {
+    rules: PrefixRule[];
+}
+export interface ExecEvaluation {
+    decision: ExecDecisionName;
+    command: string[];
+    rule?: PrefixRule;
+}
+export interface SshEndpoint {
+    kind: 'ssh';
+    destination: string;
+    remoteCwd?: string;
+}
+export type ShellEndpoint = {
+    kind: 'local';
+} | SshEndpoint;
+export interface ShellRunSpec {
+    file: string;
+    args: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+    pty: boolean;
+    transport: 'local' | 'ssh';
+}
+export interface ShellRunLimits {
+    timeoutMs: number;
+    maxOutputBytes: number;
+    gui: boolean;
+}
+export interface ShellRunOutcome {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+    truncated?: boolean;
+    timedOut?: boolean;
+    stillRunning?: boolean;
+    error?: string;
+}
+export interface ShellProcessBackend {
+    run(spec: ShellRunSpec, limits: ShellRunLimits): Promise<ShellRunOutcome>;
+}
+export declare function splitShellScript(script: string): string[][];
+export declare function evaluateExecPolicy(script: string, policy: ExecPolicy): ExecEvaluation;
+export declare function planSshArgv(input: {
+    command: string;
+    cwd?: string;
+    pty: boolean;
+    shell?: 'powershell';
+    endpoint: SshEndpoint;
+}): ShellRunSpec;
+export declare function shellQuote(value: string): string;

package/dist/shell-exec.js

@@ -0,0 +1,147 @@
+/**
+ * Shell 执行规划：前缀策略，以及本地 / SSH 的启动参数。
+ * 这里不启动进程。多条前缀同时命中时，取更严的决定：
+ * allow < prompt < forbidden。
+ */
+const DECISION_RANK = {
+    allow: 0,
+    prompt: 1,
+    forbidden: 2,
+};
+export function splitShellScript(script) {
+    return splitSegments(script).map(tokenize).filter((argv) => argv.length > 0);
+}
+export function evaluateExecPolicy(script, policy) {
+    const commands = splitShellScript(script);
+    let best = { decision: 'allow', command: commands[0] ?? [] };
+    for (const command of commands) {
+        for (const rule of policy.rules) {
+            if (rule.argv.length === 0 || !isPrefix(rule.argv, command))
+                continue;
+            const stricter = DECISION_RANK[rule.decision] > DECISION_RANK[best.decision];
+            const sameDecisionLonger = rule.decision === best.decision && rule.argv.length > (best.rule?.argv.length ?? 0);
+            if (stricter || sameDecisionLonger) {
+                best = { decision: rule.decision, command, rule };
+            }
+        }
+    }
+    return best;
+}
+export function planSshArgv(input) {
+    const destination = input.endpoint.destination.trim();
+    if (!destination) {
+        throw new Error('ssh destination is required');
+    }
+    const cwd = input.cwd ?? input.endpoint.remoteCwd;
+    const script = remoteScript(input.command, cwd, input.shell);
+    const args = ['-o', 'BatchMode=yes', '-o', 'ConnectTimeout=15'];
+    if (input.pty)
+        args.push('-tt');
+    args.push(destination, '--');
+    if (input.shell === 'powershell') {
+        args.push('pwsh', '-NoProfile', '-NonInteractive', '-Command', script);
+    }
+    else {
+        args.push('bash', '-lc', script);
+    }
+    return { file: 'ssh', args, pty: input.pty, transport: 'ssh' };
+}
+export function shellQuote(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function remoteScript(command, cwd, shell) {
+    if (!cwd)
+        return command;
+    if (shell === 'powershell')
+        return `Set-Location ${shellQuote(cwd)}; ${command}`;
+    return `cd ${shellQuote(cwd)} && ${command}`;
+}
+function isPrefix(prefix, argv) {
+    if (prefix.length > argv.length)
+        return false;
+    return prefix.every((token, index) => token === argv[index]);
+}
+function splitSegments(script) {
+    const segments = [];
+    let current = '';
+    let quote = null;
+    for (let i = 0; i < script.length; i += 1) {
+        const ch = script[i];
+        if (quote) {
+            current += ch;
+            if (ch === '\\' && quote === '"' && i + 1 < script.length) {
+                current += script[i + 1];
+                i += 1;
+                continue;
+            }
+            if (ch === quote)
+                quote = null;
+            continue;
+        }
+        if (ch === '\\' && i + 1 < script.length) {
+            current += ch + script[i + 1];
+            i += 1;
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            quote = ch;
+            current += ch;
+            continue;
+        }
+        const two = script.slice(i, i + 2);
+        if (two === '&&' || two === '||' || two === '|&') {
+            segments.push(current);
+            current = '';
+            i += 1;
+            continue;
+        }
+        if (ch === ';' || ch === '|' || ch === '\n') {
+            segments.push(current);
+            current = '';
+            continue;
+        }
+        current += ch;
+    }
+    segments.push(current);
+    return segments.map((segment) => segment.trim()).filter((segment) => segment.length > 0);
+}
+function tokenize(segment) {
+    const tokens = [];
+    let current = '';
+    let quote = null;
+    for (let i = 0; i < segment.length; i += 1) {
+        const ch = segment[i];
+        if (quote) {
+            if (ch === '\\' && quote === '"' && i + 1 < segment.length) {
+                current += segment[i + 1];
+                i += 1;
+                continue;
+            }
+            if (ch === quote) {
+                quote = null;
+                continue;
+            }
+            current += ch;
+            continue;
+        }
+        if (ch === '\\' && i + 1 < segment.length) {
+            current += segment[i + 1];
+            i += 1;
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            quote = ch;
+            continue;
+        }
+        if (ch === ' ' || ch === '\t') {
+            if (current)
+                tokens.push(current);
+            current = '';
+            continue;
+        }
+        current += ch;
+    }
+    if (current)
+        tokens.push(current);
+    return tokens;
+}

package/dist/shell-process.d.ts

@@ -0,0 +1,3 @@
+import type { ShellProcessBackend } from './shell-exec.js';
+export declare function stripAnsi(input: string): string;
+export declare const nodeShellBackend: ShellProcessBackend;

package/dist/shell-process.js

@@ -0,0 +1,137 @@
+/**
+ * 本地进程启动：管道用 child_process，PTY 用 node-pty。
+ * SSH 也走这里，argv 由 shell-exec 规划好，本文件不再解释命令文本。
+ */
+import { spawn } from 'child_process';
+import * as pty from 'node-pty';
+// eslint-disable-next-line no-control-regex
+const ANSI_RE = /[\u001B\u009B][[\]()#;?]*(?:(?:(?:[a-zA-Z\d]*(?:;[a-zA-Z\d]*)*)?\u0007)|(?:(?:\d{1,4}(?:;\d{0,4})*)?[\dA-PR-TZcf-ntqry=><~]))/g;
+export function stripAnsi(input) {
+    return input.replace(ANSI_RE, '').replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+}
+export const nodeShellBackend = {
+    run(spec, limits) {
+        return spec.pty ? runPty(spec, limits) : runPipe(spec, limits);
+    },
+};
+function runPipe(spec, limits) {
+    return new Promise((resolve) => {
+        const stdoutChunks = [];
+        const stderrChunks = [];
+        let stdoutBytes = 0;
+        let stderrBytes = 0;
+        let truncated = false;
+        let settled = false;
+        const child = spawn(spec.file, spec.args, {
+            cwd: spec.cwd,
+            env: spec.env,
+            windowsHide: true,
+        });
+        const finish = (outcome) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve(outcome);
+        };
+        const take = (chunks, bytes, chunk) => {
+            if (bytes >= limits.maxOutputBytes) {
+                truncated = true;
+                return bytes;
+            }
+            const remain = limits.maxOutputBytes - bytes;
+            const safe = chunk.length > remain ? chunk.subarray(0, remain) : chunk;
+            chunks.push(safe);
+            if (safe.length < chunk.length)
+                truncated = true;
+            return bytes + safe.length;
+        };
+        child.stdout?.on('data', (chunk) => {
+            stdoutBytes = take(stdoutChunks, stdoutBytes, chunk);
+        });
+        child.stderr?.on('data', (chunk) => {
+            stderrBytes = take(stderrChunks, stderrBytes, chunk);
+        });
+        const stdout = () => Buffer.concat(stdoutChunks).toString('utf-8');
+        const stderr = () => Buffer.concat(stderrChunks).toString('utf-8');
+        const timer = setTimeout(() => {
+            if (!limits.gui)
+                child.kill();
+            finish({
+                exitCode: -1,
+                stdout: stdout(),
+                stderr: stderr(),
+                truncated,
+                timedOut: true,
+                stillRunning: limits.gui,
+                error: limits.gui ? undefined : `Command timed out after ${limits.timeoutMs}ms`,
+            });
+        }, limits.timeoutMs);
+        child.on('error', (err) => {
+            finish({ exitCode: -1, stdout: stdout(), stderr: stderr(), truncated, error: err.message });
+        });
+        child.on('close', (exitCode) => {
+            finish({
+                exitCode: exitCode ?? -1,
+                stdout: stdout(),
+                stderr: stderr(),
+                truncated,
+            });
+        });
+    });
+}
+function runPty(spec, limits) {
+    return new Promise((resolve) => {
+        let output = '';
+        let truncated = false;
+        let settled = false;
+        const proc = pty.spawn(spec.file, spec.args, {
+            name: 'xterm-256color',
+            cols: 120,
+            rows: 30,
+            cwd: spec.cwd,
+            env: { ...spec.env, TERM: 'xterm-256color' },
+        });
+        const finish = (outcome) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve(outcome);
+        };
+        proc.onData((chunk) => {
+            const next = output + chunk;
+            if (Buffer.byteLength(next) > limits.maxOutputBytes) {
+                truncated = true;
+                output = trimToBytes(next, limits.maxOutputBytes);
+                return;
+            }
+            output = next;
+        });
+        const timer = setTimeout(() => {
+            if (!limits.gui)
+                proc.kill();
+            finish({
+                exitCode: -1,
+                stdout: stripAnsi(output),
+                stderr: '',
+                truncated,
+                timedOut: true,
+                stillRunning: limits.gui,
+                error: limits.gui ? undefined : `Command timed out after ${limits.timeoutMs}ms`,
+            });
+        }, limits.timeoutMs);
+        proc.onExit(({ exitCode }) => {
+            finish({
+                exitCode: exitCode ?? -1,
+                stdout: stripAnsi(output),
+                stderr: '',
+                truncated,
+            });
+        });
+    });
+}
+function trimToBytes(value, maxBytes) {
+    const buffer = Buffer.from(value);
+    return buffer.subarray(0, maxBytes).toString('utf-8');
+}