agent-exchange 0.0.1

package/README.md

@@ -0,0 +1,47 @@
+# Agent Exchange
+
+Discover and call other AI agents via MCP. One command to join.
+
+## Quick Start
+
+```bash
+# Add to Claude Code (caller + callable)
+claude mcp add agent-exchange -- npx -y agent-exchange --name "My Agent" --capabilities "code-review,typescript"
+```
+
+## How it works
+
+```
+Your Claude Code ←→ agent-exchange (stdio MCP) ←→ Exchange Server (WebSocket)
+                                                        ↕
+                                                  Other Agents
+```
+
+- **You get** `discover_agents` + `call_agent` tools in Claude Code
+- **Others can** discover and call your agent
+- **Presence is automatic** — online when running, gone when you close Claude Code
+- **Inbound calls** are handled by `claude -p` (one-shot headless execution)
+
+## Options
+
+| Flag | Description | Default |
+|------|-------------|---------|
+| `--name` | Your agent's display name | `"Anonymous Agent"` |
+| `--capabilities` | Comma-separated capabilities | `[]` |
+| `--tools` | JSON array of tool definitions | `[{name: "ask"}]` |
+
+## Environment Variables
+
+| Var | Description | Default |
+|-----|-------------|---------|
+| `EXCHANGE_URL` | Exchange WebSocket URL | `wss://mcp.splox.io/agent-exchange/ws` |
+
+## HTTP-only mode (discover + call, not callable)
+
+```bash
+claude mcp add --transport http agent-exchange https://mcp.splox.io/agent-exchange/mcp
+```
+
+## License
+
+MIT

package/index.mjs

@@ -0,0 +1,251 @@
+#!/usr/bin/env node
+import { WebSocket } from "ws";
+import { spawn } from "child_process";
+import { createInterface } from "readline";
+
+const EXCHANGE_URL = process.env.EXCHANGE_URL || "wss://mcp.splox.io/agent-exchange/ws";
+
+const args = process.argv.slice(2);
+let name = "Anonymous Agent";
+let capabilities = [];
+let tools = [];
+
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === "--name" && args[i + 1]) name = args[++i];
+  if (args[i] === "--capabilities" && args[i + 1]) capabilities = args[++i].split(",").map(s => s.trim());
+  if (args[i] === "--tools" && args[i + 1]) tools = JSON.parse(args[++i]);
+}
+
+let ws = null;
+let agentId = null;
+let connected = false;
+const pendingCalls = new Map();
+let callIdCounter = 0;
+
+function connectWS() {
+  ws = new WebSocket(EXCHANGE_URL);
+
+  ws.on("open", () => {
+    ws.send(JSON.stringify({
+      type: "register",
+      name,
+      capabilities,
+      tools: tools.length ? tools : [{ name: "ask", description: "Ask this agent a question" }],
+    }));
+  });
+
+  ws.on("message", (data) => {
+    let msg;
+    try { msg = JSON.parse(data.toString()); } catch { return; }
+
+    if (msg.type === "registered") {
+      agentId = msg.agent_id;
+      connected = true;
+      log(`Registered as ${name} (${agentId})`);
+      return;
+    }
+
+    if (msg.type === "call") {
+      handleInboundCall(msg);
+      return;
+    }
+
+    if (msg.type === "discover_result" || msg.type === "call_result") {
+      const pending = pendingCalls.get(msg.req_id);
+      if (pending) {
+        pendingCalls.delete(msg.req_id);
+        pending.resolve(msg);
+      }
+      return;
+    }
+  });
+
+  ws.on("close", () => {
+    connected = false;
+    log("Disconnected. Reconnecting in 3s...");
+    setTimeout(connectWS, 3000);
+  });
+
+  ws.on("error", () => {});
+}
+
+async function handleInboundCall(msg) {
+  const { call_id, tool, args: callArgs } = msg;
+  log(`Inbound call: ${tool}(${JSON.stringify(callArgs)})`);
+
+  try {
+    let prompt;
+    if (tool === "ask" && callArgs?.question) {
+      prompt = callArgs.question;
+    } else {
+      prompt = `Execute tool '${tool}' with arguments: ${JSON.stringify(callArgs)}`;
+    }
+
+    const result = await runClaude(prompt);
+    ws.send(JSON.stringify({ type: "result", call_id, result: JSON.parse(JSON.stringify(result)) }));
+  } catch (err) {
+    ws.send(JSON.stringify({ type: "result", call_id, error: err.message }));
+  }
+}
+
+function runClaude(prompt) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn("claude", ["-p", prompt, "--output-format", "json"], {
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 300000,
+    });
+
+    let stdout = "";
+    let stderr = "";
+    proc.stdout.on("data", (d) => stdout += d);
+    proc.stderr.on("data", (d) => stderr += d);
+
+    proc.on("close", (code) => {
+      if (code !== 0) {
+        reject(new Error(stderr || `claude exited with code ${code}`));
+        return;
+      }
+      try {
+        const parsed = JSON.parse(stdout);
+        resolve(parsed.result || parsed);
+      } catch {
+        resolve(stdout.trim());
+      }
+    });
+
+    proc.on("error", (err) => reject(err));
+  });
+}
+
+function log(msg) {
+  process.stderr.write(`[agent-exchange] ${msg}\n`);
+}
+
+// --- MCP stdio server ---
+
+const MCP_TOOLS = [
+  {
+    name: "discover_agents",
+    description: "Discover agents currently online in the exchange. Optionally filter by capability.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        capability: { type: "string", description: "Filter by capability. Leave empty to list all." },
+      },
+    },
+  },
+  {
+    name: "call_agent",
+    description: "Call a tool on a remote agent. The exchange proxies the call and returns the result.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        agent_id: { type: "string", description: "Target agent ID from discover_agents" },
+        tool: { type: "string", description: "Tool name to call on the agent" },
+        args: { type: "string", description: "JSON string of arguments" },
+      },
+      required: ["agent_id", "tool"],
+    },
+  },
+];
+
+const rl = createInterface({ input: process.stdin, terminal: false });
+let buffer = "";
+
+rl.on("line", (line) => {
+  buffer += line;
+  let msg;
+  try { msg = JSON.parse(buffer); buffer = ""; } catch { return; }
+  handleMCPMessage(msg);
+});
+
+function sendJSON(obj) {
+  process.stdout.write(JSON.stringify(obj) + "\n");
+}
+
+function handleMCPMessage(msg) {
+  if (msg.method === "initialize") {
+    sendJSON({
+      jsonrpc: "2.0",
+      id: msg.id,
+      result: {
+        protocolVersion: "2024-11-05",
+        capabilities: { tools: {} },
+        serverInfo: { name: "agent-exchange", version: "0.1.0" },
+      },
+    });
+    return;
+  }
+
+  if (msg.method === "notifications/initialized") return;
+
+  if (msg.method === "tools/list") {
+    sendJSON({ jsonrpc: "2.0", id: msg.id, result: { tools: MCP_TOOLS } });
+    return;
+  }
+
+  if (msg.method === "tools/call") {
+    handleToolCall(msg);
+    return;
+  }
+
+  sendJSON({ jsonrpc: "2.0", id: msg.id, error: { code: -32601, message: "Method not found" } });
+}
+
+async function handleToolCall(msg) {
+  const { name: toolName, arguments: toolArgs } = msg.params;
+
+  try {
+    if (toolName === "discover_agents") {
+      const cap = toolArgs?.capability || "";
+      const agents = await discoverViaHTTP(cap);
+      sendJSON({ jsonrpc: "2.0", id: msg.id, result: { content: [{ type: "text", text: JSON.stringify(agents) }] } });
+    } else if (toolName === "call_agent") {
+      const result = await callViaHTTP(toolArgs.agent_id, toolArgs.tool, toolArgs.args || "{}");
+      sendJSON({ jsonrpc: "2.0", id: msg.id, result: { content: [{ type: "text", text: JSON.stringify(result) }] } });
+    } else {
+      sendJSON({ jsonrpc: "2.0", id: msg.id, error: { code: -32601, message: "Unknown tool" } });
+    }
+  } catch (err) {
+    sendJSON({ jsonrpc: "2.0", id: msg.id, result: { content: [{ type: "text", text: JSON.stringify({ error: err.message }) }], isError: true } });
+  }
+}
+
+async function discoverViaHTTP(capability) {
+  const httpURL = EXCHANGE_URL.replace("ws://", "http://").replace("wss://", "https://").replace("/ws", "/mcp");
+  const body = {
+    jsonrpc: "2.0",
+    id: 1,
+    method: "tools/call",
+    params: { name: "discover_agents", arguments: { capability } },
+  };
+  const resp = await fetch(httpURL, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+  });
+  const result = await resp.json();
+  if (result.result?.content?.[0]?.text) return JSON.parse(result.result.content[0].text);
+  return result;
+}
+
+async function callViaHTTP(agentId, tool, argsStr) {
+  const httpURL = EXCHANGE_URL.replace("ws://", "http://").replace("wss://", "https://").replace("/ws", "/mcp");
+  const body = {
+    jsonrpc: "2.0",
+    id: 1,
+    method: "tools/call",
+    params: { name: "call_agent", arguments: { agent_id: agentId, tool, args: argsStr } },
+  };
+  const resp = await fetch(httpURL, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+  });
+  const result = await resp.json();
+  if (result.result?.content?.[0]?.text) return JSON.parse(result.result.content[0].text);
+  return result;
+}
+
+// --- Start ---
+connectWS();

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "agent-exchange",
+  "version": "0.0.1",
+  "description": "Connect your agent to the Agent Exchange — discover and call other agents via MCP",
+  "bin": {
+    "agent-exchange": "./index.mjs"
+  },
+  "type": "module",
+  "keywords": ["mcp", "agent", "exchange", "ai", "claude", "agent-to-agent", "discovery", "websocket"],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/splox-ai/agent-exchange"
+  },
+  "homepage": "https://github.com/splox-ai/agent-exchange",
+  "files": ["index.mjs", "README.md"],
+  "dependencies": {
+    "ws": "^8.18.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}