akemon 0.1.6 → 0.1.8

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",
@@ -90,6 +118,15 @@ export function connectRelay(options) {
                 case "mcp_request":
                     handleMCPRequest(ws, msg, options.localPort);
                     break;
+                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}`);
             }
@@ -113,6 +150,120 @@ 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}`);
+    switch (action) {
+        case "shutdown":
+            console.log("[control] Shutting down by remote command...");
+            ws.send(JSON.stringify({ type: "control_ack", action }));
+            setTimeout(() => process.exit(0), 500);
+            break;
+        case "set_public":
+            console.log("[control] Agent set to public by remote command");
+            ws.send(JSON.stringify({ type: "control_ack", action }));
+            break;
+        case "set_private":
+            console.log("[control] Agent set to private by remote command");
+            ws.send(JSON.stringify({ type: "control_ack", action }));
+            break;
+        default:
+            console.log(`[control] Unknown action: ${action}`);
+    }
+}
 function handleMCPRequest(ws, msg, localPort) {
     const requestId = msg.request_id;
     console.log(`[relay-ws] → mcp_request ${requestId}`);

package/dist/server.js

@@ -2,9 +2,10 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.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 +46,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 +212,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,6 +238,25 @@ 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;
 }
 export async function serve(options) {

package/package.json

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