@steerable/agent-shell 0.6.15

package/dist/mcp-executor.d.ts

@@ -0,0 +1,45 @@
+/**
+ * 给超时类错误追加可操作的排查提示。独立成纯函数便于单测。
+ */
+export declare function withMcpTroubleshootHint(message: string): string;
+export interface McpServerConfig {
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+    cwd?: string;
+}
+/**
+ * Pure eviction predicate, split out so it's unit-testable without spinning
+ * up a real MCP child process (`McpExecutor` isn't otherwise exported —
+ * everything else about it talks to a real stdio transport).
+ */
+export declare function shouldEvictMcpConnection(entry: {
+    lastUsed: number;
+    inflight: number;
+}, now: number, idleTimeoutMs: number): boolean;
+declare class McpExecutor {
+    private pool;
+    private cleanupTimer;
+    constructor();
+    executeTool(config: McpServerConfig, toolName: string, toolArgs: Record<string, unknown>): Promise<{
+        success: boolean;
+        text?: string;
+        error?: string;
+    }>;
+    listTools(config: McpServerConfig): Promise<{
+        success: boolean;
+        tools?: {
+            name: string;
+            description: string;
+            inputSchema?: unknown;
+        }[];
+        error?: string;
+    }>;
+    private getOrCreate;
+    private closeEntry;
+    /** 关闭连接池中的所有连接（应用退出 / 测试收尾时调用）。 */
+    shutdownAll(): Promise<void>;
+    private evictIdle;
+}
+export declare const mcpExecutor: McpExecutor;
+export {};

package/dist/mcp-executor.js

@@ -0,0 +1,241 @@
+import { execSync } from 'child_process';
+import { createRequire } from 'module';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+// In ESM there is no `__filename` global; use the module URL to seed a local
+// CommonJS require() so we can `require.resolve()` MCP server packages that
+// ship as CJS (npx -y <pkg> targets, e.g. apple-notes-mcp).
+const localRequire = createRequire(import.meta.url);
+const IDLE_TIMEOUT_MS = 5 * 60 * 1000;
+/**
+ * 单次 MCP 请求（initialize 握手 / listTools / callTool）的超时。
+ * SDK 默认 60s 太短：`npx -y <pkg>` 首次运行要从 npm registry 下载包，
+ * 国内网络或走代理时 60s 内完不成握手，报 "MCP error -32001: Request
+ * timed out"（2026-07-31 用户实测遇到）。放宽到 3 分钟覆盖冷启动下载。
+ */
+const MCP_REQUEST_TIMEOUT_MS = 3 * 60 * 1000;
+/**
+ * 给超时类错误追加可操作的排查提示。独立成纯函数便于单测。
+ */
+export function withMcpTroubleshootHint(message) {
+    if (!/timed?\s*out|超时|-32001/i.test(message))
+        return message;
+    return (`${message}。若为首次启动该服务：npx/uvx 需要现场下载包，可能较慢——` +
+        `可先在终端手动执行一次相同命令预热缓存，或为 npm 配置国内镜像源 ` +
+        `(npm config set registry https://registry.npmmirror.com)，之后重试"测试连接"。`);
+}
+const COMMAND_HINTS = {
+    npx: '请安装 Node.js (https://nodejs.org)',
+    node: '请安装 Node.js (https://nodejs.org)',
+    uvx: '请安装 uv (https://docs.astral.sh/uv)',
+    uv: '请安装 uv (https://docs.astral.sh/uv)',
+    python: '请安装 Python (https://python.org)',
+    python3: '请安装 Python (https://python.org)',
+};
+function commandExists(cmd) {
+    try {
+        const which = process.platform === 'win32' ? 'where' : 'which';
+        execSync(`${which} ${cmd}`, { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function tryResolveBundled(config) {
+    if (config.command !== 'npx')
+        return null;
+    const args = config.args ?? [];
+    const yIdx = args.indexOf('-y');
+    if (yIdx === -1 || yIdx + 1 >= args.length)
+        return null;
+    const pkgName = args[yIdx + 1];
+    const extraArgs = args.slice(yIdx + 2);
+    try {
+        const entryPath = localRequire.resolve(pkgName);
+        return {
+            command: process.execPath,
+            args: [entryPath, ...extraArgs],
+            env: { ...config.env, ELECTRON_RUN_AS_NODE: '1' },
+            cwd: config.cwd,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function configKey(cfg) {
+    return `${cfg.command}::${(cfg.args ?? []).join(' ')}`;
+}
+/**
+ * Pure eviction predicate, split out so it's unit-testable without spinning
+ * up a real MCP child process (`McpExecutor` isn't otherwise exported —
+ * everything else about it talks to a real stdio transport).
+ */
+export function shouldEvictMcpConnection(entry, now, idleTimeoutMs) {
+    if (entry.inflight > 0)
+        return false;
+    return now - entry.lastUsed > idleTimeoutMs;
+}
+function coerceArgs(args, schema) {
+    if (!schema?.inputSchema?.properties)
+        return args;
+    const props = schema.inputSchema.properties;
+    const out = { ...args };
+    for (const [key, value] of Object.entries(args)) {
+        const expected = props[key]?.type;
+        if (expected === 'string' && typeof value !== 'string') {
+            out[key] = String(value);
+        }
+        else if (expected === 'integer' && typeof value === 'string') {
+            const n = parseInt(value, 10);
+            if (!isNaN(n))
+                out[key] = n;
+        }
+        else if (expected === 'number' && typeof value === 'string') {
+            const n = parseFloat(value);
+            if (!isNaN(n))
+                out[key] = n;
+        }
+    }
+    return out;
+}
+class McpExecutor {
+    pool = new Map();
+    cleanupTimer = null;
+    constructor() {
+        this.cleanupTimer = setInterval(() => this.evictIdle(), 60_000);
+    }
+    async executeTool(config, toolName, toolArgs) {
+        let entry;
+        try {
+            entry = await this.getOrCreate(config);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return { success: false, error: withMcpTroubleshootHint(`MCP server startup failed: ${msg}`) };
+        }
+        entry.inflight += 1;
+        try {
+            const coerced = coerceArgs(toolArgs, entry.toolSchemas.get(toolName));
+            const result = await entry.client.callTool({ name: toolName, arguments: coerced }, undefined, {
+                timeout: MCP_REQUEST_TIMEOUT_MS,
+            });
+            const textParts = [];
+            if (Array.isArray(result.content)) {
+                for (const item of result.content) {
+                    if (typeof item === 'object' && item !== null && 'text' in item) {
+                        textParts.push(String(item.text));
+                    }
+                }
+            }
+            const text = textParts.join('\n') || JSON.stringify(result.content);
+            if (result.isError)
+                return { success: false, error: text };
+            return { success: true, text };
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            const key = configKey(config);
+            await this.closeEntry(key);
+            return { success: false, error: withMcpTroubleshootHint(`Tool execution failed: ${msg}`) };
+        }
+        finally {
+            entry.inflight -= 1;
+            entry.lastUsed = Date.now();
+        }
+    }
+    async listTools(config) {
+        let entry;
+        try {
+            entry = await this.getOrCreate(config);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return { success: false, error: withMcpTroubleshootHint(`MCP server startup failed: ${msg}`) };
+        }
+        entry.inflight += 1;
+        try {
+            const listing = await entry.client.listTools(undefined, { timeout: MCP_REQUEST_TIMEOUT_MS });
+            return {
+                success: true,
+                tools: listing.tools.map(t => ({ name: t.name, description: t.description ?? '', inputSchema: t.inputSchema })),
+            };
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            const key = configKey(config);
+            await this.closeEntry(key);
+            return { success: false, error: withMcpTroubleshootHint(`List tools failed: ${msg}`) };
+        }
+        finally {
+            entry.inflight -= 1;
+            entry.lastUsed = Date.now();
+        }
+    }
+    async getOrCreate(config) {
+        const key = configKey(config);
+        const existing = this.pool.get(key);
+        if (existing)
+            return existing;
+        const resolved = tryResolveBundled(config) ?? config;
+        if (!commandExists(resolved.command)) {
+            const hint = COMMAND_HINTS[config.command] || `请确保 ${config.command} 已安装并在 PATH 中`;
+            throw new Error(`命令 "${config.command}" 不可用。${hint}`);
+        }
+        const transport = new StdioClientTransport({
+            command: resolved.command,
+            args: resolved.args,
+            env: { ...process.env, ...(resolved.env ?? {}) },
+            cwd: resolved.cwd ?? undefined,
+            stderr: 'pipe',
+        });
+        const client = new Client({ name: 'agent-shell', version: '1.0.0' }, { capabilities: {} });
+        await client.connect(transport, { timeout: MCP_REQUEST_TIMEOUT_MS });
+        const toolSchemas = new Map();
+        try {
+            const listing = await client.listTools(undefined, { timeout: MCP_REQUEST_TIMEOUT_MS });
+            for (const t of listing.tools) {
+                toolSchemas.set(t.name, {
+                    name: t.name,
+                    inputSchema: t.inputSchema,
+                });
+            }
+        }
+        catch {
+            // no-op
+        }
+        const entry = { client, transport, lastUsed: Date.now(), key, toolSchemas, inflight: 0 };
+        this.pool.set(key, entry);
+        transport.onclose = () => {
+            this.pool.delete(key);
+        };
+        return entry;
+    }
+    async closeEntry(key) {
+        const entry = this.pool.get(key);
+        if (!entry)
+            return;
+        this.pool.delete(key);
+        try {
+            await entry.client.close();
+        }
+        catch {
+            // ignore
+        }
+    }
+    /** 关闭连接池中的所有连接（应用退出 / 测试收尾时调用）。 */
+    async shutdownAll() {
+        const keys = [...this.pool.keys()];
+        await Promise.all(keys.map((key) => this.closeEntry(key)));
+    }
+    evictIdle() {
+        const now = Date.now();
+        for (const [key, entry] of this.pool) {
+            if (shouldEvictMcpConnection(entry, now, IDLE_TIMEOUT_MS)) {
+                this.closeEntry(key).catch(() => { });
+            }
+        }
+    }
+}
+export const mcpExecutor = new McpExecutor();

package/dist/mcp-server-registry.d.ts

@@ -0,0 +1,104 @@
+/**
+ * MCP 外部服务注册表。
+ *
+ * 用户在「设置 → MCP 服务」里导入/登记的外部 MCP server（stdio 型），
+ * 持久化在 userData/agent-mcp-servers.json。已启用服务的工具会经
+ * ToolRouter 以 `mcp__<serverKey>__<toolName>` 一等工具身份暴露给模型。
+ *
+ * 存储通过 {@link McpServerKvStore} 接口注入：main.ts 用 electron-store
+ * 实现，单测用内存实现——本模块不 import electron，保持纯 Node 可测。
+ */
+import { type McpServerConfig } from './mcp-executor.js';
+export interface McpServerEntry {
+    id: string;
+    /** 用户可见名称，也用于生成工具前缀（如 "filesystem"）。 */
+    name: string;
+    command: string;
+    args: string[];
+    env: Record<string, string>;
+    cwd?: string;
+    enabled: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface CreateMcpServerInput {
+    name: string;
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+    cwd?: string;
+    enabled?: boolean;
+}
+/** 最小 KV 存储接口，避免本模块直接依赖 electron-store。 */
+export interface McpServerKvStore {
+    get(key: 'mcpServers'): McpServerEntry[] | undefined;
+    set(key: 'mcpServers', value: McpServerEntry[]): void;
+}
+export interface CachedToolList {
+    tools: Array<{
+        name: string;
+        description: string;
+        inputSchema?: unknown;
+    }>;
+    fetchedAt: string;
+    error: string | null;
+}
+export interface ImportResult {
+    added: McpServerEntry[];
+    /** 因重名或缺少 command 被跳过的服务名。 */
+    skipped: string[];
+}
+/**
+ * 一个可调用 MCP 工具的扁平视图（跨服务），供 "/" 选择器与消息触发解析用。
+ * `token` 即模型侧的一等工具名 `mcp__<serverKey>__<toolName>`（命名规则与
+ * tool-router.ts 的动态工具保持一致）。
+ */
+export interface McpToolEntry {
+    token: string;
+    toolName: string;
+    serverKey: string;
+    serverName: string;
+    description: string;
+    serverId: string;
+}
+/** 工具名只允许 [a-z0-9-]；中文名会被剥光，退化为 srv-<id前6位>。 */
+export declare function sanitizeServerKey(name: string, id: string): string;
+export declare class McpServerRegistry {
+    private readonly store;
+    /** serverId → 最近一次 listTools 的结果（内存缓存，重启后由后台刷新重建）。 */
+    private readonly toolCache;
+    constructor(store: McpServerKvStore);
+    list(): McpServerEntry[];
+    get(idOrName: string): McpServerEntry | null;
+    create(input: CreateMcpServerInput): McpServerEntry;
+    update(id: string, updates: Partial<CreateMcpServerInput>): McpServerEntry;
+    delete(id: string): boolean;
+    /**
+     * 解析 Claude Desktop 风格的配置并批量导入：
+     *
+     * ```json
+     * { "mcpServers": { "filesystem": { "command": "npx", "args": ["-y", "@modelcontextprotocol/server-filesystem", "C:/"] } } }
+     * ```
+     *
+     * 也兼容裸对象（不带 mcpServers 包裹）。重名或缺 command 的条目跳过。
+     */
+    importClaudeConfig(raw: string | Record<string, unknown>): ImportResult;
+    /** 工具名前缀（同一名称多实例撞名时追加 id 后缀保证唯一）。 */
+    serverKey(entry: McpServerEntry): string;
+    toExecutorConfig(entry: McpServerEntry): McpServerConfig;
+    getCachedTools(serverId: string): CachedToolList | null;
+    /**
+     * 所有「已启用 + 工具缓存非空」服务的工具扁平清单（"/" 选择器数据源）。
+     */
+    listEnabledToolEntries(): McpToolEntry[];
+    /**
+     * 按完整 token（大小写不敏感）反查工具；命中时返回注册表里的规范 token
+     * （用户手敲可能大小写不符，tool_call 必须用规范名）。未启用 / 无缓存 /
+     * 不存在均返回 null。
+     */
+    findToolByToken(token: string): McpToolEntry | null;
+    /** 连接服务并刷新工具缓存；失败时缓存错误信息（tools 为空）。 */
+    refreshTools(serverId: string): Promise<CachedToolList>;
+    /** 后台刷新所有已启用服务的工具列表（启动时调用，不阻塞、不抛错）。 */
+    refreshAllEnabled(): Promise<void>;
+}

package/dist/mcp-server-registry.js

@@ -0,0 +1,234 @@
+/**
+ * MCP 外部服务注册表。
+ *
+ * 用户在「设置 → MCP 服务」里导入/登记的外部 MCP server（stdio 型），
+ * 持久化在 userData/agent-mcp-servers.json。已启用服务的工具会经
+ * ToolRouter 以 `mcp__<serverKey>__<toolName>` 一等工具身份暴露给模型。
+ *
+ * 存储通过 {@link McpServerKvStore} 接口注入：main.ts 用 electron-store
+ * 实现，单测用内存实现——本模块不 import electron，保持纯 Node 可测。
+ */
+import { randomUUID } from 'node:crypto';
+import { mcpExecutor } from './mcp-executor.js';
+const STORE_KEY = 'mcpServers';
+/** 工具名只允许 [a-z0-9-]；中文名会被剥光，退化为 srv-<id前6位>。 */
+export function sanitizeServerKey(name, id) {
+    const cleaned = name
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+    return cleaned || `srv-${id.slice(0, 6)}`;
+}
+export class McpServerRegistry {
+    store;
+    /** serverId → 最近一次 listTools 的结果（内存缓存，重启后由后台刷新重建）。 */
+    toolCache = new Map();
+    constructor(store) {
+        this.store = store;
+    }
+    list() {
+        return this.store.get(STORE_KEY) ?? [];
+    }
+    get(idOrName) {
+        const needle = idOrName.trim().toLowerCase();
+        return (this.list().find((s) => s.id === idOrName || s.name.toLowerCase() === needle) ?? null);
+    }
+    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,
+        };
+        this.store.set(STORE_KEY, [...this.list(), entry]);
+        return entry;
+    }
+    update(id, updates) {
+        const servers = this.list();
+        const idx = servers.findIndex((s) => s.id === id);
+        if (idx === -1)
+            throw new Error('服务不存在');
+        const current = servers[idx];
+        const nextName = updates.name !== undefined ? updates.name.trim() : current.name;
+        if (!nextName)
+            throw new Error('服务名称不能为空');
+        const nameClash = servers.some((s) => s.id !== id && s.name.toLowerCase() === nextName.toLowerCase());
+        if (nameClash)
+            throw new Error(`已存在同名服务「${nextName}」`);
+        const next = {
+            ...current,
+            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,
+            updatedAt: new Date().toISOString(),
+        };
+        if (!next.command)
+            throw new Error('启动命令不能为空');
+        servers[idx] = next;
+        this.store.set(STORE_KEY, servers);
+        // 配置变了，旧工具缓存不可信
+        this.toolCache.delete(id);
+        return next;
+    }
+    delete(id) {
+        const servers = this.list();
+        const next = servers.filter((s) => s.id !== id);
+        if (next.length === servers.length)
+            return false;
+        this.store.set(STORE_KEY, next);
+        this.toolCache.delete(id);
+        return true;
+    }
+    /**
+     * 解析 Claude Desktop 风格的配置并批量导入：
+     *
+     * ```json
+     * { "mcpServers": { "filesystem": { "command": "npx", "args": ["-y", "@modelcontextprotocol/server-filesystem", "C:/"] } } }
+     * ```
+     *
+     * 也兼容裸对象（不带 mcpServers 包裹）。重名或缺 command 的条目跳过。
+     */
+    importClaudeConfig(raw) {
+        let parsed = raw;
+        if (typeof raw === 'string') {
+            parsed = JSON.parse(raw); // JSON 语法错误直接抛给调用方
+        }
+        if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+            throw new Error('配置必须是 JSON 对象');
+        }
+        const container = 'mcpServers' in parsed
+            ? parsed.mcpServers
+            : parsed;
+        if (typeof container !== 'object' || container === null || Array.isArray(container)) {
+            throw new Error('mcpServers 必须是对象（服务名 → 配置）');
+        }
+        const result = { added: [], skipped: [] };
+        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)) {
+                result.skipped.push(name);
+                continue;
+            }
+            const env = {};
+            if (cfg.env && typeof cfg.env === 'object' && !Array.isArray(cfg.env)) {
+                for (const [k, v] of Object.entries(cfg.env)) {
+                    env[k] = String(v);
+                }
+            }
+            const entry = this.create({
+                name: name.trim(),
+                command,
+                args: Array.isArray(cfg.args) ? cfg.args.map((a) => String(a)) : [],
+                env,
+                cwd: typeof cfg.cwd === 'string' ? cfg.cwd : undefined,
+                enabled: true,
+            });
+            result.added.push(entry);
+        }
+        return result;
+    }
+    /** 工具名前缀（同一名称多实例撞名时追加 id 后缀保证唯一）。 */
+    serverKey(entry) {
+        const base = sanitizeServerKey(entry.name, entry.id);
+        const clash = this.list().some((s) => s.id !== entry.id && sanitizeServerKey(s.name, s.id) === base);
+        return clash ? `${base}-${entry.id.slice(0, 4)}` : base;
+    }
+    toExecutorConfig(entry) {
+        return {
+            command: entry.command,
+            args: entry.args,
+            env: entry.env,
+            cwd: entry.cwd,
+        };
+    }
+    getCachedTools(serverId) {
+        return this.toolCache.get(serverId) ?? null;
+    }
+    /**
+     * 所有「已启用 + 工具缓存非空」服务的工具扁平清单（"/" 选择器数据源）。
+     */
+    listEnabledToolEntries() {
+        const out = [];
+        for (const server of this.list()) {
+            if (!server.enabled)
+                continue;
+            const cached = this.getCachedTools(server.id);
+            if (!cached || cached.tools.length === 0)
+                continue;
+            const serverKey = this.serverKey(server);
+            for (const tool of cached.tools) {
+                out.push({
+                    token: `mcp__${serverKey}__${tool.name}`,
+                    toolName: tool.name,
+                    serverKey,
+                    serverName: server.name,
+                    description: tool.description ?? '',
+                    serverId: server.id,
+                });
+            }
+        }
+        return out;
+    }
+    /**
+     * 按完整 token（大小写不敏感）反查工具；命中时返回注册表里的规范 token
+     * （用户手敲可能大小写不符，tool_call 必须用规范名）。未启用 / 无缓存 /
+     * 不存在均返回 null。
+     */
+    findToolByToken(token) {
+        const needle = token.trim().toLowerCase();
+        if (!needle.startsWith('mcp__'))
+            return null;
+        return (this.listEnabledToolEntries().find((e) => e.token.toLowerCase() === needle) ?? null);
+    }
+    /** 连接服务并刷新工具缓存；失败时缓存错误信息（tools 为空）。 */
+    async refreshTools(serverId) {
+        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
+            ? {
+                tools: (result.tools ?? []).map((t) => ({
+                    name: t.name,
+                    description: t.description,
+                    inputSchema: t.inputSchema,
+                })),
+                fetchedAt: new Date().toISOString(),
+                error: null,
+            }
+            : { tools: [], fetchedAt: new Date().toISOString(), error: result.error ?? '未知错误' };
+        this.toolCache.set(serverId, cached);
+        return cached;
+    }
+    /** 后台刷新所有已启用服务的工具列表（启动时调用，不阻塞、不抛错）。 */
+    async refreshAllEnabled() {
+        const jobs = this.list()
+            .filter((s) => s.enabled)
+            .map((s) => this.refreshTools(s.id).catch((err) => {
+            this.toolCache.set(s.id, {
+                tools: [],
+                fetchedAt: new Date().toISOString(),
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }));
+        await Promise.allSettled(jobs);
+    }
+}

package/dist/preload-default.d.ts

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

package/dist/preload-default.js

@@ -0,0 +1,9 @@
+/**
+ * shell 默认 preload 入口：无包贡献的中性面（buildPreloadApi()）。
+ * 由本包构建（esbuild → dist/preload.cjs）打包成单文件 CJS，供
+ * shell main.ts 的默认 preload 路径与纯 shell/demo 启动使用。
+ * 带 invoke 型包贡献的产品用自己的 preload 入口（产品构建打包到
+ * 产品 main.js 旁）并经 setPreloadPath 注入，不走本入口。
+ */
+import { buildPreloadApi } from './preload.js';
+buildPreloadApi();