akemon 0.1.8 → 0.1.9

package/dist/cli.js

@@ -31,6 +31,7 @@ program
     .option("--approve", "Review every task before execution")
     .option("--mock", "Use mock responses (for demo/testing)")
     .option("--allow-all", "Skip all permission prompts (for self-use)")
+    .option("--mcp-server <command>", "Wrap a community MCP server (stdio) and expose its tools via relay")
     .option("--relay <url>", "Relay WebSocket URL", RELAY_WS)
     .action(async (opts) => {
     const port = parseInt(opts.port);
@@ -51,6 +52,7 @@ program
         engine,
         relayHttp,
         secretKey: credentials.secretKey,
+        mcpServer: opts.mcpServer,
     });
     console.log(``);
     if (!opts.public) {

package/dist/server.js

@@ -1,6 +1,10 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { ListToolsRequestSchema, CallToolRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 import { z } from "zod";
 import { spawn, exec } from "child_process";
 import { createServer } from "http";
@@ -259,8 +263,84 @@ function createMcpServer(opts) {
     });
     return server;
 }
+async function initMcpProxy(mcpServerCmd, workdir) {
+    const parts = mcpServerCmd.match(/(?:[^\s"]+|"[^"]*")+/g) || [mcpServerCmd];
+    const [command, ...args] = parts.map(p => p.replace(/^"|"$/g, ""));
+    console.log(`[mcp-proxy] Starting child MCP server: ${command} ${args.join(" ")}`);
+    const transport = new StdioClientTransport({ command, args, cwd: workdir, stderr: "pipe" });
+    const client = new Client({ name: "akemon-proxy", version: "0.1.0" });
+    await client.connect(transport);
+    const { tools } = await client.listTools();
+    console.log(`[mcp-proxy] Connected. ${tools.length} tools: ${tools.map((t) => t.name).join(", ")}`);
+    return { client, tools };
+}
+function createMcpProxyServer(proxy, agentName) {
+    const server = new Server({ name: agentName, version: "0.1.0" }, { capabilities: { tools: {} } });
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        return {
+            tools: [
+                ...proxy.tools,
+                {
+                    name: "call_agent",
+                    description: "Call another akemon agent by name. The target agent will execute the task and return the result.",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            agent: { type: "string", description: "Target agent name" },
+                            task: { type: "string", description: "Task to send" },
+                        },
+                        required: ["agent", "task"],
+                    },
+                },
+            ],
+        };
+    });
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: toolArgs } = request.params;
+        if (name === "call_agent") {
+            console.log(`[call_agent] ${agentName} → ${toolArgs?.agent}: ${String(toolArgs?.task).slice(0, 80)}`);
+            try {
+                const result = await callAgent(toolArgs?.agent, toolArgs?.task);
+                return { content: [{ type: "text", text: result }] };
+            }
+            catch (err) {
+                return { content: [{ type: "text", text: `[error] ${err.message}` }], isError: true };
+            }
+        }
+        // Forward to child MCP server
+        console.log(`[mcp-proxy] → ${name}(${JSON.stringify(toolArgs).slice(0, 100)})`);
+        try {
+            const result = await proxy.client.callTool({ name, arguments: toolArgs });
+            // Normalize response format
+            if ("toolResult" in result) {
+                return { content: [{ type: "text", text: JSON.stringify(result.toolResult) }] };
+            }
+            return result;
+        }
+        catch (err) {
+            console.error(`[mcp-proxy] Tool ${name} error: ${err.message}`);
+            return { content: [{ type: "text", text: `[error] ${err.message}` }], isError: true };
+        }
+    });
+    return server;
+}
 export async function serve(options) {
     const workdir = options.workdir || process.cwd();
+    // Expose port to engine subprocesses so they can callback to local MCP server
+    process.env.AKEMON_PORT = String(options.port);
+    if (options.key)
+        process.env.AKEMON_KEY = options.key;
+    // Initialize MCP proxy if --mcp-server specified
+    let mcpProxy = null;
+    if (options.mcpServer) {
+        try {
+            mcpProxy = await initMcpProxy(options.mcpServer, workdir);
+        }
+        catch (err) {
+            console.error(`[mcp-proxy] Failed to start child MCP server: ${err.message}`);
+            process.exit(1);
+        }
+    }
     const sessions = new Map();
     const publisherIds = new Map();
     const httpServer = createServer(async (req, res) => {
@@ -303,19 +383,25 @@ export async function serve(options) {
                     publisherIds.delete(sid);
                 }
             };
-            const mcpServer = createMcpServer({
-                workdir,
-                agentName: options.agentName,
-                mock: options.mock,
-                model: options.model,
-                approve: options.approve,
-                engine: options.engine,
-                allowAll: options.allowAll,
-                relayHttp: options.relayHttp,
-                secretKey: options.secretKey,
-                publisherIds,
-            });
-            await mcpServer.connect(transport);
+            if (mcpProxy) {
+                const proxyServer = createMcpProxyServer(mcpProxy, options.agentName);
+                await proxyServer.connect(transport);
+            }
+            else {
+                const mcpServer = createMcpServer({
+                    workdir,
+                    agentName: options.agentName,
+                    mock: options.mock,
+                    model: options.model,
+                    approve: options.approve,
+                    engine: options.engine,
+                    allowAll: options.allowAll,
+                    relayHttp: options.relayHttp,
+                    secretKey: options.secretKey,
+                    publisherIds,
+                });
+                await mcpServer.connect(transport);
+            }
             await transport.handleRequest(req, res);
             if (transport.sessionId) {
                 sessions.set(transport.sessionId, transport);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akemon",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "description": "Agent work marketplace — train your agent, let it work for others",
   "type": "module",
   "license": "MIT",