akemon 0.1.7 → 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/relay-client.js

@@ -1,6 +1,33 @@
 import WebSocket from "ws";
 import http from "http";
 const DEFAULT_RELAY_URL = "wss://relay.akemon.dev";
+// Pending agent_call results (callId → resolve function)
+const pendingAgentCalls = new Map();
+let relayWsRef = null;
+/** Call another agent through the relay. Available to any engine. */
+export function callAgent(target, task) {
+    return new Promise((resolve, reject) => {
+        if (!relayWsRef || relayWsRef.readyState !== WebSocket.OPEN) {
+            reject(new Error("Not connected to relay"));
+            return;
+        }
+        const callId = Math.random().toString(36).slice(2) + Date.now().toString(36);
+        pendingAgentCalls.set(callId, resolve);
+        relayWsRef.send(JSON.stringify({
+            type: "agent_call",
+            call_id: callId,
+            target,
+            task,
+        }));
+        // Timeout after 5 minutes
+        setTimeout(() => {
+            if (pendingAgentCalls.has(callId)) {
+                pendingAgentCalls.delete(callId);
+                reject(new Error(`agent_call to ${target} timed out`));
+            }
+        }, 300_000);
+    });
+}
 export function connectRelay(options) {
     const relayUrl = options.relayUrl || DEFAULT_RELAY_URL;
     let wsUrl = relayUrl.replace(/^http/, "ws");
@@ -52,6 +79,7 @@ export function connectRelay(options) {
         ws.on("open", () => {
             console.log(`[relay-ws] Connected. Registering agent "${options.agentName}"...`);
             reconnectDelay = 1000; // reset backoff
+            relayWsRef = ws;
             // Send registration message
             const reg = {
                 type: "register",
@@ -93,6 +121,12 @@ export function connectRelay(options) {
                 case "control":
                     handleControl(ws, msg);
                     break;
+                case "agent_call":
+                    handleIncomingAgentCall(ws, msg, options.localPort);
+                    break;
+                case "agent_call_result":
+                    handleAgentCallResult(msg);
+                    break;
                 default:
                     console.log(`[relay-ws] Unknown message type: ${msg.type}`);
             }
@@ -116,6 +150,99 @@ export function connectRelay(options) {
     }
     connect();
 }
+function handleIncomingAgentCall(ws, msg, localPort) {
+    const callId = msg.call_id || "";
+    const caller = msg.caller || "unknown";
+    const task = msg.task || "";
+    console.log(`[agent_call] Incoming from ${caller}: ${task.slice(0, 80)}`);
+    // Forward to local MCP as a submit_task call
+    const initBody = JSON.stringify({
+        jsonrpc: "2.0", id: 1,
+        method: "initialize",
+        params: { protocolVersion: "2025-03-26", capabilities: {}, clientInfo: { name: "agent-call", version: "1.0" } },
+    });
+    const doRequest = (body, sessionId) => {
+        return new Promise((resolve, reject) => {
+            const headers = {
+                "Content-Type": "application/json",
+                "Accept": "application/json, text/event-stream",
+            };
+            if (sessionId)
+                headers["mcp-session-id"] = sessionId;
+            const req = http.request({ hostname: "127.0.0.1", port: localPort, path: "/mcp", method: "POST", headers: { ...headers, "Content-Length": Buffer.byteLength(body) } }, (res) => {
+                const chunks = [];
+                res.on("data", (c) => chunks.push(c));
+                res.on("end", () => {
+                    const sid = res.headers["mcp-session-id"];
+                    resolve({ data: Buffer.concat(chunks).toString(), sessionId: sid || sessionId });
+                });
+            });
+            req.on("error", reject);
+            req.write(body);
+            req.end();
+        });
+    };
+    // Initialize → call tool → return result
+    doRequest(initBody)
+        .then(({ sessionId: sid }) => {
+        const callBody = JSON.stringify({
+            jsonrpc: "2.0", id: 2,
+            method: "tools/call",
+            params: { name: "submit_task", arguments: { task } },
+        });
+        return doRequest(callBody, sid);
+    })
+        .then(({ data }) => {
+        // Extract text from SSE or JSON response
+        let result = data;
+        try {
+            // Try SSE extraction
+            const lines = data.split("\n");
+            let lastData = "";
+            for (const line of lines) {
+                if (line.startsWith("data: "))
+                    lastData = line.slice(6);
+            }
+            if (lastData) {
+                const parsed = JSON.parse(lastData);
+                const content = parsed?.result?.content;
+                if (content)
+                    result = content.map((c) => c.text || "").join("\n");
+            }
+            else {
+                const parsed = JSON.parse(data);
+                const content = parsed?.result?.content;
+                if (content)
+                    result = content.map((c) => c.text || "").join("\n");
+            }
+        }
+        catch { /* use raw */ }
+        ws.send(JSON.stringify({
+            type: "agent_call_result",
+            call_id: callId,
+            caller,
+            result,
+        }));
+        console.log(`[agent_call] Replied to ${caller} (${result.length} bytes)`);
+    })
+        .catch((err) => {
+        ws.send(JSON.stringify({
+            type: "agent_call_result",
+            call_id: callId,
+            caller,
+            result: `[error] ${err.message}`,
+        }));
+    });
+}
+function handleAgentCallResult(msg) {
+    const callId = msg.call_id || "";
+    const resolve = pendingAgentCalls.get(callId);
+    if (resolve) {
+        pendingAgentCalls.delete(callId);
+        resolve(msg.result || "");
+        console.log(`[agent_call] Got result for call_id=${callId.slice(0, 8)} from ${msg.caller}`);
+    }
+}
 function handleControl(ws, msg) {
     const action = msg.action || "";
     console.log(`[control] Received: ${action}`);

package/dist/server.js

@@ -1,10 +1,15 @@
 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 } from "child_process";
+import { spawn, exec } from "child_process";
 import { createServer } from "http";
 import { createInterface } from "readline";
+import { callAgent } from "./relay-client.js";
 function runCommand(cmd, args, task, cwd, stdinMode = true) {
     return new Promise((resolve, reject) => {
         const { CLAUDECODE, ...cleanEnv } = process.env;
@@ -45,6 +50,19 @@ function runCommand(cmd, args, task, cwd, stdinMode = true) {
         child.on("error", reject);
     });
 }
+function runTerminal(command, cwd) {
+    return new Promise((resolve) => {
+        exec(command, { cwd, timeout: 300_000, maxBuffer: 1024 * 1024 }, (err, stdout, stderr) => {
+            const output = (stdout || "") + (stderr ? "\n[stderr]\n" + stderr : "");
+            if (err && !output.trim()) {
+                resolve(`[error] ${err.message}`);
+            }
+            else {
+                resolve(output.trim() || "[no output]");
+            }
+        });
+    });
+}
 // stdinMode: true = send task via stdin, false = send task as argument
 function buildEngineCommand(engine, model, allowAll) {
     switch (engine) {
@@ -198,8 +216,15 @@ function createMcpServer(opts) {
             console.log(`[approve] Owner approved. Executing with ${engine}...`);
         }
         try {
-            const { cmd, args, stdinMode } = buildEngineCommand(engine, model, allowAll);
-            const output = await runCommand(cmd, args, safeTask, workdir, stdinMode);
+            let output;
+            if (engine === "terminal") {
+                console.log(`[terminal] Executing: ${task}`);
+                output = await runTerminal(task, workdir);
+            }
+            else {
+                const { cmd, args, stdinMode } = buildEngineCommand(engine, model, allowAll);
+                output = await runCommand(cmd, args, safeTask, workdir, stdinMode);
+            }
             // Store updated context
             if (contextEnabled && publisherId) {
                 const newContext = buildContextPayload(prevContext, task, output);
@@ -217,10 +242,105 @@ function createMcpServer(opts) {
             };
         }
     });
+    // Agent-to-agent calling tool
+    server.tool("call_agent", "Call another akemon agent by name. The target agent will execute the task and return the result. Use this to delegate subtasks to specialized agents.", {
+        agent: z.string().describe("Name of the target agent to call"),
+        task: z.string().describe("Task to send to the target agent"),
+    }, async ({ agent: target, task }) => {
+        console.log(`[call_agent] ${agentName} → ${target}: ${task.slice(0, 80)}`);
+        try {
+            const result = await callAgent(target, task);
+            return {
+                content: [{ type: "text", text: result }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `[error] Failed to call agent "${target}": ${err.message}` }],
+                isError: true,
+            };
+        }
+    });
+    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) => {
@@ -263,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.7",
+  "version": "0.1.9",
   "description": "Agent work marketplace — train your agent, let it work for others",
   "type": "module",
   "license": "MIT",