@chengchenccc/oh-my-agent 0.1.1-rc.1

package/dist/core/tools/grep.js

@@ -0,0 +1,61 @@
+import { WorkspaceSandbox } from "./workspace-sandbox.js";
+const descriptionParam = {
+    type: "string",
+    description: "Must be the first parameter. A short human-readable summary explaining why this search is being performed.",
+};
+export function createGrepTool(opts) {
+    const sandbox = new WorkspaceSandbox(opts.workspaceRoot);
+    return {
+        name: "grep",
+        description: "Search files using ripgrep. Returns matching lines with line numbers. Requires `rg`.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                description: descriptionParam,
+                pattern: { type: "string", description: "The regex pattern to search for" },
+                path: {
+                    type: "string",
+                    description: "File or directory to search in (relative to workspace root)",
+                },
+                glob: { type: "string", description: "Glob pattern to filter files (e.g. '*.ts')" },
+            },
+            required: ["pattern"],
+        },
+        async execute(input) {
+            const { pattern, path: searchPath, glob, } = input;
+            let validatedPath = opts.workspaceRoot;
+            if (searchPath) {
+                try {
+                    validatedPath = sandbox.validate(searchPath);
+                }
+                catch {
+                    return {
+                        content: `Error: path escapes workspace root: ${String(searchPath)}`,
+                        isError: true,
+                    };
+                }
+            }
+            const args = ["rg", "-n", "--color=never"];
+            if (glob)
+                args.push("--glob", glob);
+            args.push(pattern, validatedPath);
+            let proc;
+            try {
+                proc = Bun.spawn(args, { stdout: "pipe", stderr: "pipe" });
+            }
+            catch {
+                return { content: "grep failed: ripgrep not found", isError: true };
+            }
+            const [stdout, stderr, exitCode] = await Promise.all([
+                new Response(proc.stdout).text(),
+                new Response(proc.stderr).text(),
+                proc.exited,
+            ]);
+            if (exitCode === 1)
+                return { content: "" };
+            if (exitCode >= 2)
+                return { content: `grep failed (exit=${exitCode}): ${stderr}`, isError: true };
+            return { content: stdout };
+        },
+    };
+}

package/dist/core/tools/index.d.ts

@@ -0,0 +1,14 @@
+export { type AgentFsLike, pjoin } from "./agent-fs-like.js";
+export { createBashTool } from "./bash.js";
+export { createEvalTool } from "./eval.js";
+export { createEditTool, createReadTool, createWriteTool, withDefaultCwd } from "./file-tools.js";
+export { createGlobTool } from "./glob.js";
+export { createGrepTool } from "./grep.js";
+export { createLsTool, createTreeTool } from "./ls-tree.js";
+export { createReadImageTool } from "./read-image.js";
+export { buildSkillIndex, type SkillIndexEntry } from "./skills.js";
+export type { WebFetchPort, WebSearchPort } from "./web-ports.js";
+export { createWebFetchTool as createPortWebFetchTool, createWebSearchTool as createPortWebSearchTool, } from "./web-ports.js";
+export { createDdgWebSearchPort, createStdWebFetchPort, } from "./web-ports-std.js";
+export { WorkspaceEscapeError, WorkspaceSandbox } from "./workspace-sandbox.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/core/tools/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/tools/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAG7D,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAClG,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC5D,OAAO,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,EAAE,eAAe,EAAE,KAAK,eAAe,EAAE,MAAM,aAAa,CAAC;AACpE,YAAY,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAClE,OAAO,EACL,kBAAkB,IAAI,sBAAsB,EAC5C,mBAAmB,IAAI,uBAAuB,GAC/C,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,sBAAsB,EACtB,qBAAqB,GACtB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC"}

package/dist/core/tools/index.js

@@ -0,0 +1,14 @@
+// cwd-based tool factories (Phase 1)
+export { pjoin } from "./agent-fs-like.js";
+// standalone tools
+export { createBashTool } from "./bash.js";
+export { createEvalTool } from "./eval.js";
+export { createEditTool, createReadTool, createWriteTool, withDefaultCwd } from "./file-tools.js";
+export { createGlobTool } from "./glob.js";
+export { createGrepTool } from "./grep.js";
+export { createLsTool, createTreeTool } from "./ls-tree.js";
+export { createReadImageTool } from "./read-image.js";
+export { buildSkillIndex } from "./skills.js";
+export { createWebFetchTool as createPortWebFetchTool, createWebSearchTool as createPortWebSearchTool, } from "./web-ports.js";
+export { createDdgWebSearchPort, createStdWebFetchPort, } from "./web-ports-std.js";
+export { WorkspaceEscapeError, WorkspaceSandbox } from "./workspace-sandbox.js";

package/dist/core/tools/ls-tree.d.ts

@@ -0,0 +1,10 @@
+import type { Tool } from "@chengchenccc/message";
+/** ls tool: list directory entries sorted by mtime (newest first). */
+export declare function createLsTool(opts: {
+    cwd: string;
+}): Tool;
+/** tree tool: recursive directory listing with depth control. */
+export declare function createTreeTool(opts: {
+    cwd: string;
+}): Tool;
+//# sourceMappingURL=ls-tree.d.ts.map

package/dist/core/tools/ls-tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ls-tree.d.ts","sourceRoot":"","sources":["../../../src/core/tools/ls-tree.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AA0ClD,sEAAsE;AACtE,wBAAgB,YAAY,CAAC,IAAI,EAAE;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CA4DxD;AAED,iEAAiE;AACjE,wBAAgB,cAAc,CAAC,IAAI,EAAE;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAyE1D"}

package/dist/core/tools/ls-tree.js

@@ -0,0 +1,177 @@
+import { readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { WorkspaceSandbox } from "./workspace-sandbox.js";
+const descriptionParam = {
+    type: "string",
+    description: "Must be the first parameter. A short human-readable summary explaining why this tool is being called.",
+};
+const DEFAULT_IGNORES = new Set([
+    "node_modules",
+    ".git",
+    ".svn",
+    ".hg",
+    ".DS_Store",
+    "Thumbs.db",
+    ".cache",
+    ".next",
+    ".nuxt",
+    ".turbo",
+    ".parcel-cache",
+    "dist",
+    "build",
+    "out",
+    "coverage",
+    "__pycache__",
+    ".pytest_cache",
+    ".mypy_cache",
+    ".venv",
+    "venv",
+]);
+function isIgnored(name) {
+    return DEFAULT_IGNORES.has(name);
+}
+function formatSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes}B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)}KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+/** ls tool: list directory entries sorted by mtime (newest first). */
+export function createLsTool(opts) {
+    const { cwd } = opts;
+    const sandbox = new WorkspaceSandbox(cwd);
+    return {
+        name: "ls",
+        description: "List files and directories at a given path. Returns entry names sorted by modification time (newest first). " +
+            "Common noise directories (node_modules, .git, build output) are omitted.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                description: descriptionParam,
+                path: {
+                    type: "string",
+                    description: "Directory path to list, relative to workspace root. Defaults to workspace root.",
+                },
+            },
+            required: [],
+        },
+        async execute(input) {
+            const rec = input;
+            let dir = cwd;
+            if (rec.path) {
+                try {
+                    dir = sandbox.validate(rec.path);
+                }
+                catch {
+                    return {
+                        content: `Error: path escapes workspace root: ${String(rec.path)}`,
+                        isError: true,
+                    };
+                }
+            }
+            try {
+                const entries = readdirSync(dir, { withFileTypes: true })
+                    .filter((e) => !isIgnored(e.name))
+                    .map((e) => {
+                    const fullPath = join(dir, e.name);
+                    try {
+                        const stat = statSync(fullPath);
+                        return { name: e.name, isDir: e.isDirectory(), mtime: stat.mtimeMs, size: stat.size };
+                    }
+                    catch {
+                        return { name: e.name, isDir: e.isDirectory(), mtime: 0, size: 0 };
+                    }
+                })
+                    .sort((a, b) => b.mtime - a.mtime);
+                if (entries.length === 0)
+                    return { content: "(empty)" };
+                const lines = entries.map((e) => {
+                    const type = e.isDir ? "dir " : "file";
+                    const size = e.isDir ? "" : formatSize(e.size).padStart(8);
+                    return `${type}  ${size}  ${e.name}`;
+                });
+                return { content: lines.join("\n") };
+            }
+            catch (err) {
+                return { content: `Error: ${err instanceof Error ? err.message : err}`, isError: true };
+            }
+        },
+    };
+}
+/** tree tool: recursive directory listing with depth control. */
+export function createTreeTool(opts) {
+    const { cwd } = opts;
+    const sandbox = new WorkspaceSandbox(cwd);
+    return {
+        name: "tree",
+        description: "Show a recursive tree view of a directory. Useful for understanding project structure. " +
+            "Common noise directories are omitted. Use max_depth to limit recursion.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                description: descriptionParam,
+                path: {
+                    type: "string",
+                    description: "Directory path, relative to workspace root. Defaults to workspace root.",
+                },
+                max_depth: {
+                    type: "number",
+                    description: "Maximum recursion depth. Defaults to 3.",
+                },
+            },
+            required: [],
+        },
+        async execute(input) {
+            const rec = input;
+            let dir = cwd;
+            if (rec.path) {
+                try {
+                    dir = sandbox.validate(rec.path);
+                }
+                catch {
+                    return {
+                        content: `Error: path escapes workspace root: ${String(rec.path)}`,
+                        isError: true,
+                    };
+                }
+            }
+            const maxDepth = rec.max_depth ?? 3;
+            const lines = [];
+            function walk(currentDir, prefix, depth) {
+                if (depth > maxDepth)
+                    return;
+                let entries;
+                try {
+                    entries = readdirSync(currentDir, { withFileTypes: true })
+                        .filter((e) => !isIgnored(e.name))
+                        .sort((a, b) => {
+                        if (a.isDirectory() !== b.isDirectory())
+                            return a.isDirectory() ? -1 : 1;
+                        return a.name.localeCompare(b.name);
+                    });
+                }
+                catch {
+                    return;
+                }
+                for (let i = 0; i < entries.length; i++) {
+                    const e = entries[i];
+                    const isLast = i === entries.length - 1;
+                    const connector = isLast ? "└── " : "├── ";
+                    lines.push(`${prefix}${connector}${e.name}${e.isDirectory() ? "/" : ""}`);
+                    if (e.isDirectory()) {
+                        walk(join(currentDir, e.name), prefix + (isLast ? "    " : "│   "), depth + 1);
+                    }
+                }
+            }
+            try {
+                lines.push(rec.path ?? ".");
+                walk(dir, "", 1);
+                return { content: lines.join("\n") };
+            }
+            catch (err) {
+                return { content: `Error: ${err instanceof Error ? err.message : err}`, isError: true };
+            }
+        },
+    };
+}

package/dist/core/tools/mcp-mount.d.ts

@@ -0,0 +1,63 @@
+import type { PluginTool } from "../agent-runtime.js";
+import type { PluginMcpConfig } from "../plugins/plugin-resolve.js";
+/** Generic .mcp.json mounting (ADR 0022): the workspace bridge writes one
+ *  .mcp.json (user servers + product-tools + knowledge); the child mounts
+ *  every server. Tool names that collide with the native tool table are
+ *  skipped (the native table wins). One client per server, kept alive for
+ *  the run. */
+interface McpJsonServer {
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    url?: string;
+    headers?: Record<string, string>;
+}
+/** One configured server as a listing row (pi's /mcp list). */
+export interface McpServerInfo {
+    name: string;
+    kind: "stdio" | "url" | "invalid";
+    detail: string;
+}
+/** Configured servers from the workspace .mcp.json, sorted by name.
+ *  Never throws — a corrupt file yields []. */
+export declare function listMcpServers(workspaceRoot: string): McpServerInfo[];
+/** Live-connect one configured server and list its tools (pi's /mcp test).
+ *  Reports failure reasons; never throws.
+ *  ponytail: a connect that hangs past the timeout leaves the stdio child
+ *  running (connectServer exposes no pid) — rare in practice, pkill by
+ *  command if it bites. */
+export declare function testMcpServer(workspaceRoot: string, name: string): Promise<{
+    ok: boolean;
+    tools: string[];
+    error?: string;
+}>;
+/** Per-call timeout for mounted MCP tools (ms). A hung server must never
+ * block the Run forever — product tools already bound theirs. Default 120s
+ * (MCP tools legitimately run longer than file tools); OMA_MCP_TIMEOUT_MS
+ * overrides, 0 disables. */
+export declare function mcpCallTimeoutMs(): number;
+/** Race a tool call against a wall-clock timeout and the run's abort
+ * signal. The losing call keeps running server-side (the MCP SDK's
+ * callTool takes no signal) but its result lands nowhere. The Bun timer
+ * MUST be cleared or the process lingers — hence the finally. */
+export declare function withCallTimeout<T>(call: Promise<T>, label: string, timeoutMs: number, signal?: AbortSignal): Promise<T>;
+/** Mount the workspace .mcp.json servers as plugin tools. Never throws;
+ *  per-server failures degrade to "server absent". */
+export interface MountedMcpServers {
+    tools: PluginTool[];
+    /** Close every mounted server's transport (kills stdio children). */
+    close(): Promise<void>;
+}
+export declare function mountWorkspaceMcpServers(workspaceRoot: string, nativeNames: ReadonlySet<string>, pluginServers?: readonly PluginMcpConfig[], includeWorkspace?: boolean): Promise<MountedMcpServers>;
+/** Expand ${CLAUDE_PLUGIN_ROOT}/${CLAUDE_PROJECT_DIR} in a plugin server
+ *  config (spec: Claude plugin .mcp.json compatibility) and export both as
+ *  env vars to the spawned server process. */
+export declare function substitutePluginVars(server: McpJsonServer, ctx: {
+    pluginRoot: string;
+    workspaceRoot: string;
+}): McpJsonServer;
+/** Workspace .mcp.json wins on name conflicts (spec conflict matrix);
+ *  plugin servers keep resolver order otherwise. */
+export declare function mergeMcpConfigs(workspaceRoot: string, plugins: readonly PluginMcpConfig[]): Record<string, McpJsonServer>;
+export {};
+//# sourceMappingURL=mcp-mount.d.ts.map

package/dist/core/tools/mcp-mount.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-mount.d.ts","sourceRoot":"","sources":["../../../src/core/tools/mcp-mount.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAGpE;;;;eAIe;AAEf,UAAU,aAAa;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAClC;AA8FD,+DAA+D;AAC/D,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,OAAO,GAAG,KAAK,GAAG,SAAS,CAAC;IAClC,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;+CAC+C;AAC/C,wBAAgB,cAAc,CAAC,aAAa,EAAE,MAAM,GAAG,aAAa,EAAE,CAerE;AAID;;;;2BAI2B;AAC3B,wBAAsB,aAAa,CACjC,aAAa,EAAE,MAAM,EACrB,IAAI,EAAE,MAAM,GACX,OAAO,CAAC;IAAE,EAAE,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAmC3D;AAED;;;4BAG4B;AAC5B,wBAAgB,gBAAgB,IAAI,MAAM,CAQzC;AAED;;;iEAGiE;AACjE,wBAAsB,eAAe,CAAC,CAAC,EACrC,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC,EAChB,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,EACjB,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,CAAC,CAAC,CAkBZ;AAED;sDACsD;AACtD,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,UAAU,EAAE,CAAC;IACpB,qEAAqE;IACrE,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAED,wBAAsB,wBAAwB,CAC5C,aAAa,EAAE,MAAM,EACrB,WAAW,EAAE,WAAW,CAAC,MAAM,CAAC,EAChC,aAAa,GAAE,SAAS,eAAe,EAAO,EAC9C,gBAAgB,UAAO,GACtB,OAAO,CAAC,iBAAiB,CAAC,CAkD5B;AAED;;8CAE8C;AAC9C,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,aAAa,EACrB,GAAG,EAAE;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAE,GACjD,aAAa,CAqBf;AAED;oDACoD;AACpD,wBAAgB,eAAe,CAC7B,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE,SAAS,eAAe,EAAE,GAClC,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAa/B"}

package/dist/core/tools/mcp-mount.js

@@ -0,0 +1,287 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { killProcessTree } from "../runtime/process-tree.js";
+function loadMcpConfig(workspaceRoot) {
+    const path = join(workspaceRoot, ".mcp.json");
+    if (!existsSync(path))
+        return {};
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf-8"));
+        return parsed.mcpServers ?? {};
+    }
+    catch {
+        return {};
+    }
+}
+/** Expand `${VAR}` placeholders in .mcp.json headers/env from process.env. */
+function expandEnvVars(value) {
+    return value.replace(/\$\{([A-Z_][A-Z0-9_]*)\}/g, (_, name) => process.env[name] ?? "");
+}
+async function connectServer(name, server) {
+    try {
+        const { Client } = await import("@modelcontextprotocol/sdk/client/index.js");
+        let stdioRootPid = null;
+        let closeSdk;
+        let callTool;
+        let listTools;
+        if (server.url) {
+            const { SSEClientTransport } = await import("@modelcontextprotocol/sdk/client/sse.js");
+            const headers = server.headers
+                ? Object.fromEntries(Object.entries(server.headers).map(([k, v]) => [k, expandEnvVars(v)]))
+                : undefined;
+            const transport = new SSEClientTransport(new URL(server.url), headers ? { requestInit: { headers } } : undefined);
+            const client = new Client({ name: "oma", version: "0.1.0" }, { capabilities: {} });
+            await client.connect(transport);
+            callTool = (params) => 
+            // MCP wire boundary: the SDK returns a wide content union; our
+            // consumer only reads text blocks and isError.
+            client.callTool(params);
+            listTools = () => client.listTools();
+            closeSdk = () => client.close();
+        }
+        else if (server.command) {
+            const { StdioClientTransport } = await import("@modelcontextprotocol/sdk/client/stdio.js");
+            const env = server.env
+                ? Object.fromEntries(Object.entries(server.env).map(([k, v]) => [k, expandEnvVars(v)]))
+                : undefined;
+            const transport = new StdioClientTransport({
+                command: server.command,
+                args: server.args ?? [],
+                env,
+            });
+            const client = new Client({ name: "oma", version: "0.1.0" }, { capabilities: {} });
+            await client.connect(transport);
+            stdioRootPid = transport.pid;
+            callTool = (params) => 
+            // MCP wire boundary: see the sse branch above.
+            client.callTool(params);
+            listTools = () => client.listTools();
+            closeSdk = () => client.close();
+        }
+        else {
+            return null;
+        }
+        return {
+            callTool,
+            listTools,
+            async close() {
+                await closeSdk();
+                if (stdioRootPid !== null)
+                    killProcessTree(stdioRootPid);
+            },
+        };
+    }
+    catch (err) {
+        console.error(`[mcp-mount] server ${name} failed:`, err instanceof Error ? err.message : err);
+        return null;
+    }
+}
+/** Configured servers from the workspace .mcp.json, sorted by name.
+ *  Never throws — a corrupt file yields []. */
+export function listMcpServers(workspaceRoot) {
+    const servers = loadMcpConfig(workspaceRoot);
+    return Object.entries(servers)
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([name, server]) => {
+        if (server.url)
+            return { name, kind: "url", detail: server.url };
+        if (server.command) {
+            return {
+                name,
+                kind: "stdio",
+                detail: [server.command, ...(server.args ?? [])].join(" "),
+            };
+        }
+        return { name, kind: "invalid", detail: "no command or url" };
+    });
+}
+const MCP_TEST_TIMEOUT_MS = 10_000;
+/** Live-connect one configured server and list its tools (pi's /mcp test).
+ *  Reports failure reasons; never throws.
+ *  ponytail: a connect that hangs past the timeout leaves the stdio child
+ *  running (connectServer exposes no pid) — rare in practice, pkill by
+ *  command if it bites. */
+export async function testMcpServer(workspaceRoot, name) {
+    const servers = loadMcpConfig(workspaceRoot);
+    const server = servers[name];
+    if (!server) {
+        return { ok: false, tools: [], error: `no server named "${name}" in .mcp.json` };
+    }
+    let timer;
+    const timeout = new Promise((resolve) => {
+        timer = setTimeout(() => resolve(null), MCP_TEST_TIMEOUT_MS);
+    });
+    let client;
+    try {
+        client = await Promise.race([connectServer(name, server), timeout]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+    if (!client) {
+        return {
+            ok: false,
+            tools: [],
+            error: `connect failed or timed out (${MCP_TEST_TIMEOUT_MS / 1000}s)`,
+        };
+    }
+    try {
+        const { tools } = await client.listTools();
+        return { ok: true, tools: tools.map((t) => t.name) };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            tools: [],
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+/** Per-call timeout for mounted MCP tools (ms). A hung server must never
+ * block the Run forever — product tools already bound theirs. Default 120s
+ * (MCP tools legitimately run longer than file tools); OMA_MCP_TIMEOUT_MS
+ * overrides, 0 disables. */
+export function mcpCallTimeoutMs() {
+    const raw = process.env.OMA_MCP_TIMEOUT_MS;
+    let n = raw === undefined ? 120_000 : Number(raw);
+    if (!Number.isFinite(n))
+        n = 120_000;
+    const capRaw = process.env.OMA_MAX_TOOL_TIMEOUT_MS;
+    const cap = capRaw ? Number(capRaw) : 0;
+    if (Number.isFinite(cap) && cap > 0)
+        n = Math.min(n, cap);
+    return n;
+}
+/** Race a tool call against a wall-clock timeout and the run's abort
+ * signal. The losing call keeps running server-side (the MCP SDK's
+ * callTool takes no signal) but its result lands nowhere. The Bun timer
+ * MUST be cleared or the process lingers — hence the finally. */
+export async function withCallTimeout(call, label, timeoutMs, signal) {
+    if (signal?.aborted)
+        throw new Error("Aborted");
+    if (timeoutMs <= 0 && !signal)
+        return call;
+    let timer;
+    const bail = new Promise((_, reject) => {
+        if (timeoutMs > 0) {
+            timer = setTimeout(() => reject(new Error(`${label} timed out after ${timeoutMs}ms`)), timeoutMs);
+        }
+        signal?.addEventListener("abort", () => reject(new Error("Aborted")), { once: true });
+    });
+    try {
+        return await Promise.race([call, bail]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+export async function mountWorkspaceMcpServers(workspaceRoot, nativeNames, pluginServers = [], includeWorkspace = true) {
+    const servers = includeWorkspace
+        ? mergeMcpConfigs(workspaceRoot, pluginServers)
+        : mergePluginMcpConfigs(pluginServers);
+    const tools = [];
+    const clients = [];
+    for (const [name, server] of Object.entries(servers)) {
+        const client = await connectServer(name, server);
+        if (!client)
+            continue;
+        clients.push(client);
+        let listed;
+        try {
+            listed = (await client.listTools()).tools;
+        }
+        catch (err) {
+            console.error(`[mcp-mount] listTools ${name} failed:`, err instanceof Error ? err.message : err);
+            continue;
+        }
+        for (const t of listed) {
+            if (nativeNames.has(t.name))
+                continue; // native table wins on collision
+            tools.push({
+                name: t.name,
+                description: t.description ?? `MCP tool ${t.name} (server ${name})`,
+                inputSchema: (t.inputSchema ?? { type: "object" }),
+                timeoutMs: mcpCallTimeoutMs(),
+                async execute(args, signal) {
+                    const res = await withCallTimeout(client.callTool({ name: t.name, arguments: args }), `mcp tool ${t.name}`, mcpCallTimeoutMs(), signal);
+                    const text = (res.content ?? [])
+                        .filter((c) => c.type === "text" && c.text)
+                        .map((c) => c.text)
+                        .join("\n");
+                    if (res.isError)
+                        throw new Error(text || `mcp tool ${t.name} failed`);
+                    return { content: text };
+                },
+            });
+        }
+    }
+    return {
+        tools,
+        async close() {
+            await Promise.allSettled(clients.map((c) => c.close().catch(() => { })));
+        },
+    };
+}
+/** Expand ${CLAUDE_PLUGIN_ROOT}/${CLAUDE_PROJECT_DIR} in a plugin server
+ *  config (spec: Claude plugin .mcp.json compatibility) and export both as
+ *  env vars to the spawned server process. */
+export function substitutePluginVars(server, ctx) {
+    const sub = (s) => s
+        .replaceAll("${CLAUDE_PLUGIN_ROOT}", ctx.pluginRoot)
+        .replaceAll("${CLAUDE_PROJECT_DIR}", ctx.workspaceRoot);
+    const out = { ...server };
+    if (server.command)
+        out.command = sub(server.command);
+    if (server.args)
+        out.args = server.args.map(sub);
+    if (server.env) {
+        const env = {};
+        for (const [k, v] of Object.entries(server.env))
+            env[k] = sub(String(v));
+        env.CLAUDE_PLUGIN_ROOT = ctx.pluginRoot;
+        env.CLAUDE_PROJECT_DIR = ctx.workspaceRoot;
+        out.env = env;
+    }
+    if (server.headers) {
+        const headers = {};
+        for (const [k, v] of Object.entries(server.headers))
+            headers[k] = sub(String(v));
+        out.headers = headers;
+    }
+    return out;
+}
+/** Workspace .mcp.json wins on name conflicts (spec conflict matrix);
+ *  plugin servers keep resolver order otherwise. */
+export function mergeMcpConfigs(workspaceRoot, plugins) {
+    const merged = loadMcpConfig(workspaceRoot);
+    for (const p of plugins) {
+        for (const [name, raw] of Object.entries(p.servers)) {
+            if (name in merged)
+                continue;
+            if (typeof raw !== "object" || raw === null)
+                continue;
+            merged[name] = substitutePluginVars(raw, {
+                pluginRoot: p.pluginRoot,
+                workspaceRoot,
+            });
+        }
+    }
+    return merged;
+}
+/** Plugin servers only (workspace .mcp.json gated off — standalone trust). */
+function mergePluginMcpConfigs(plugins) {
+    const merged = {};
+    for (const p of plugins) {
+        for (const [name, raw] of Object.entries(p.servers)) {
+            if (name in merged)
+                continue;
+            if (typeof raw !== "object" || raw === null)
+                continue;
+            merged[name] = raw;
+        }
+    }
+    return merged;
+}

package/dist/core/tools/read-image.d.ts

@@ -0,0 +1,6 @@
+import type { Tool } from "@chengchenccc/message";
+/** read_image: return a workspace image as a vision tool result block. */
+export declare function createReadImageTool(opts: {
+    cwd: string;
+}): Tool;
+//# sourceMappingURL=read-image.d.ts.map

package/dist/core/tools/read-image.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-image.d.ts","sourceRoot":"","sources":["../../../src/core/tools/read-image.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAqB,MAAM,uBAAuB,CAAC;AA0BrE,0EAA0E;AAC1E,wBAAgB,mBAAmB,CAAC,IAAI,EAAE;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAoE/D"}