claude-code-swarm 0.3.5 → 0.3.7

package/.claude-plugin/marketplace.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-swarm",
-  "version": "0.3.5",
+  "version": "0.3.7",
   "description": "Launch Claude Code with swarmkit capabilities, including team orchestration, MAP observability, and session tracking.",
   "owner": {
     "name": "alexngai"

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "claude-code-swarm",
   "description": "Spin up Claude Code agent teams from openteams YAML topologies with optional MAP (Multi-Agent Protocol) observability and coordination. Provides hooks for session lifecycle, agent spawn/complete tracking, and a /swarm skill to launch team configurations.",
-  "version": "0.3.5",
+  "version": "0.3.7",
   "author": {
     "name": "alexngai"
   },

package/.claude-plugin/run-agent-inbox-mcp.sh

@@ -1,7 +1,8 @@
 #!/bin/bash
 # Wrapper script to run agent-inbox MCP server
-# Reads scope from swarm config, discovers inbox socket
-# Exits silently if inbox is not enabled or not installed
+# When the sidecar's inbox socket exists, runs in proxy mode (IPC client).
+# Otherwise falls back to standalone mode with its own storage.
+# Exits silently if inbox is not enabled or not installed.
 
 # Check if inbox is enabled in config
 ENABLED=false
@@ -45,9 +46,26 @@ if [ -n "$SWARM_INBOX_SCOPE" ]; then
   SCOPE="$SWARM_INBOX_SCOPE"
 fi
 
-# Set env vars for agent-inbox MCP mode
 export INBOX_SCOPE="$SCOPE"
 
+# Discover sidecar inbox socket for proxy mode
+# Check well-known paths: .swarm/claude-swarm/tmp/map/inbox.sock
+INBOX_SOCK=""
+if [ -S .swarm/claude-swarm/tmp/map/inbox.sock ]; then
+  INBOX_SOCK=".swarm/claude-swarm/tmp/map/inbox.sock"
+fi
+
+# Also check per-session paths
+if [ -z "$INBOX_SOCK" ] && [ -d .swarm/claude-swarm/tmp/map/sessions ]; then
+  # Find the most recently modified inbox.sock in session dirs
+  INBOX_SOCK=$(find .swarm/claude-swarm/tmp/map/sessions -name inbox.sock -type s 2>/dev/null | head -1)
+fi
+
+# If inbox socket found, enable proxy mode
+if [ -n "$INBOX_SOCK" ]; then
+  export INBOX_SOCKET_PATH="$INBOX_SOCK"
+fi
+
 # Try to find the agent-inbox module entry point
 INBOX_MAIN=""
 
@@ -68,6 +86,7 @@ if [ -z "$INBOX_MAIN" ]; then
 fi
 
 if [ -n "$INBOX_MAIN" ]; then
+  # Uses proxy mode when INBOX_SOCKET_PATH is set, standalone otherwise
   exec node "$INBOX_MAIN" mcp
 fi
 

package/.gitattributes

@@ -0,0 +1,3 @@
+
+# OpenTasks merge driver for graph.jsonl
+.opentasks/graph.jsonl merge=opentasks

package/.opentasks/config.json

@@ -0,0 +1,9 @@
+{
+  "version": "1.0",
+  "location": {
+    "hash": "5bkyrjlx",
+    "uuid": "7b496a03-dd73-4d0b-a243-d9108ecc2f20",
+    "name": "claude-code-swarm"
+  },
+  "connections": []
+}

package/e2e/helpers/opentasks-daemon.mjs

@@ -0,0 +1,149 @@
+/**
+ * Test helper: minimal opentasks daemon for e2e tests
+ *
+ * Creates a JSON-RPC 2.0 server on a Unix socket that implements the
+ * subset of opentasks daemon methods used by opentasks-client.mjs:
+ *   - ping → { pong: true }
+ *   - graph.create → stores node, returns { id, ...params }
+ *   - graph.update → updates stored node, returns updated node
+ *   - tools.link → stores edge, returns { ok: true }
+ *
+ * Uses in-memory storage. No persistence, no providers, no flush.
+ */
+
+import net from "net";
+import fs from "fs";
+import { randomUUID } from "crypto";
+
+/**
+ * Start a minimal opentasks daemon on a Unix socket.
+ * Returns { socketPath, stop(), nodes, edges }.
+ */
+export function startTestDaemon(socketPath) {
+  const nodes = new Map();
+  const edges = [];
+  let server;
+
+  return new Promise((resolve, reject) => {
+    // Remove stale socket
+    try { fs.unlinkSync(socketPath); } catch { /* ignore */ }
+
+    server = net.createServer((conn) => {
+      let buffer = "";
+
+      conn.on("data", (data) => {
+        buffer += data.toString();
+        const lines = buffer.split("\n");
+        buffer = lines.pop(); // Keep incomplete line
+
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          try {
+            const req = JSON.parse(line);
+            const result = handleRequest(req, nodes, edges);
+            conn.write(JSON.stringify(result) + "\n");
+          } catch (err) {
+            conn.write(JSON.stringify({
+              jsonrpc: "2.0",
+              id: null,
+              error: { code: -32700, message: "Parse error", data: err.message },
+            }) + "\n");
+          }
+        }
+      });
+    });
+
+    server.on("error", reject);
+
+    server.listen(socketPath, () => {
+      resolve({
+        socketPath,
+        nodes,
+        edges,
+        stop: () => new Promise((res) => {
+          server.close(() => {
+            try { fs.unlinkSync(socketPath); } catch { /* ignore */ }
+            res();
+          });
+          // Force close connections
+          server.unref();
+        }),
+      });
+    });
+  });
+}
+
+function handleRequest(req, nodes, edges) {
+  const { id, method, params } = req;
+
+  switch (method) {
+    case "ping":
+      return { jsonrpc: "2.0", id, result: { pong: true } };
+
+    case "graph.create": {
+      const nodeId = randomUUID();
+      const node = {
+        id: nodeId,
+        type: params?.type || "task",
+        title: params?.title || "",
+        status: params?.status || "open",
+        assignee: params?.assignee || null,
+        uri: params?.uri || null,
+        metadata: params?.metadata || {},
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      };
+      nodes.set(nodeId, node);
+      return { jsonrpc: "2.0", id, result: node };
+    }
+
+    case "graph.update": {
+      const nodeId = params?.id;
+      if (!nodeId || !nodes.has(nodeId)) {
+        return {
+          jsonrpc: "2.0", id,
+          error: { code: -32602, message: `Node not found: ${nodeId}` },
+        };
+      }
+      const existing = nodes.get(nodeId);
+      const updated = {
+        ...existing,
+        ...(params.status !== undefined && { status: params.status }),
+        ...(params.title !== undefined && { title: params.title }),
+        ...(params.assignee !== undefined && { assignee: params.assignee }),
+        ...(params.metadata !== undefined && { metadata: { ...existing.metadata, ...params.metadata } }),
+        updatedAt: new Date().toISOString(),
+      };
+      nodes.set(nodeId, updated);
+      return { jsonrpc: "2.0", id, result: updated };
+    }
+
+    case "graph.query": {
+      const allNodes = Array.from(nodes.values());
+      const filtered = params?.type
+        ? allNodes.filter((n) => n.type === params.type)
+        : allNodes;
+      return { jsonrpc: "2.0", id, result: filtered };
+    }
+
+    case "tools.link": {
+      const edge = {
+        fromId: params?.fromId,
+        toId: params?.toId,
+        type: params?.type || "related",
+        metadata: params?.metadata || {},
+      };
+      edges.push(edge);
+      return { jsonrpc: "2.0", id, result: { ok: true } };
+    }
+
+    case "shutdown":
+      return { jsonrpc: "2.0", id, result: { ok: true } };
+
+    default:
+      return {
+        jsonrpc: "2.0", id,
+        error: { code: -32601, message: `Method not found: ${method}` },
+      };
+  }
+}