claude-code-swarm 0.3.4 → 0.3.6

package/src/opentasks-client.mjs

@@ -0,0 +1,269 @@
+/**
+ * opentasks-client.mjs — Daemon IPC client for opentasks integration
+ *
+ * Speaks JSON-RPC 2.0 over Unix socket to the opentasks daemon.
+ * Provides lifecycle management (discovery, health check, auto-start)
+ * and graph operations for forwarding MAP sync events.
+ *
+ * Pattern: src/sidecar-client.mjs (never-throw, best-effort, timeouts)
+ * Key difference: JSON-RPC 2.0 (request/response with id) vs sidecar's
+ * fire-and-forget NDJSON.
+ */
+
+import fs from "fs";
+import path from "path";
+import net from "net";
+import { spawn } from "child_process";
+import { randomUUID } from "crypto";
+import { OPENTASKS_DIR } from "./paths.mjs";
+
+/**
+ * Discover the opentasks daemon socket path.
+ * Priority:
+ *   1. .swarm/opentasks/daemon.sock (swarmkit layout)
+ *   2. .opentasks/daemon.sock (walk up directory tree)
+ *   3. .git/opentasks/daemon.sock (git multi-location)
+ *
+ * Returns the first path that exists, or the swarmkit default.
+ */
+export function findSocketPath() {
+  const candidates = [
+    path.join(".swarm", "opentasks", "daemon.sock"),
+    path.join(".opentasks", "daemon.sock"),
+    path.join(".git", "opentasks", "daemon.sock"),
+  ];
+
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) return candidate;
+  }
+
+  // Walk up for .opentasks/daemon.sock
+  let dir = process.cwd();
+  const root = path.parse(dir).root;
+  while (dir !== root) {
+    const sock = path.join(dir, ".opentasks", "daemon.sock");
+    if (fs.existsSync(sock)) return sock;
+    dir = path.dirname(dir);
+  }
+
+  // Default to swarmkit layout (will be created by ensureDaemon)
+  return path.join(".swarm", "opentasks", "daemon.sock");
+}
+
+/**
+ * Send a JSON-RPC 2.0 request to the opentasks daemon.
+ * Returns the result on success, null on any failure. Never throws.
+ *
+ * @param {string} method - JSON-RPC method name (e.g., "ping", "graph.update")
+ * @param {object} params - Method parameters
+ * @param {string} [socketPath] - Unix socket path (auto-discovered if omitted)
+ * @param {number} [timeoutMs=2000] - Request timeout in milliseconds
+ * @returns {Promise<object|null>} Result payload or null on failure
+ */
+export function rpcRequest(method, params = {}, socketPath, timeoutMs = 2000) {
+  const sock = socketPath || findSocketPath();
+
+  return new Promise((resolve) => {
+    const id = randomUUID();
+    const request = JSON.stringify({
+      jsonrpc: "2.0",
+      id,
+      method,
+      params,
+    }) + "\n";
+
+    let buffer = "";
+    const client = net.createConnection(sock, () => {
+      client.write(request);
+    });
+
+    client.on("data", (data) => {
+      buffer += data.toString();
+      // Try to parse complete response
+      const lines = buffer.split("\n");
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const response = JSON.parse(line);
+          if (response.id === id) {
+            clearTimeout(timer);
+            client.destroy();
+            if (response.error) {
+              resolve(null);
+            } else {
+              resolve(response.result ?? {});
+            }
+            return;
+          }
+        } catch {
+          // Incomplete JSON, wait for more data
+        }
+      }
+    });
+
+    client.on("error", () => {
+      clearTimeout(timer);
+      resolve(null);
+    });
+
+    const timer = setTimeout(() => {
+      client.destroy();
+      resolve(null);
+    }, timeoutMs);
+    // Don't let this timer keep the hook process alive after response
+    timer.unref();
+  });
+}
+
+/**
+ * Check if the opentasks daemon is alive via ping.
+ * Returns true if responsive. Never throws.
+ */
+export async function isDaemonAlive(socketPath) {
+  const result = await rpcRequest("ping", {}, socketPath);
+  return result !== null;
+}
+
+/**
+ * Ensure the opentasks daemon is running.
+ * If not alive, attempts to start via `opentasks daemon start`.
+ * Returns true if daemon is available after this call.
+ */
+export async function ensureDaemon(config) {
+  const socketPath = findSocketPath();
+
+  // 1. Check if already alive
+  if (await isDaemonAlive(socketPath)) return true;
+
+  // 2. Try to start the daemon
+  try {
+    fs.mkdirSync(OPENTASKS_DIR, { recursive: true });
+
+    const child = spawn("opentasks", ["daemon", "start"], {
+      detached: true,
+      stdio: ["ignore", "ignore", "pipe"],
+      env: { ...process.env },
+    });
+    child.unref();
+
+    // Collect stderr briefly for diagnostics
+    let stderr = "";
+    child.stderr.on("data", (d) => { stderr += d.toString(); });
+
+    // Wait for socket to appear (up to 3s)
+    for (let i = 0; i < 12; i++) {
+      await new Promise((r) => setTimeout(r, 250));
+      if (await isDaemonAlive(socketPath)) return true;
+    }
+
+    if (stderr) {
+      process.stderr.write(`[opentasks-client] Daemon start stderr: ${stderr.trim()}\n`);
+    }
+  } catch (err) {
+    process.stderr.write(`[opentasks-client] Failed to start daemon: ${err.message}\n`);
+  }
+
+  return false;
+}
+
+/**
+ * Create a task in the opentasks graph.
+ * Returns the created node or null on failure.
+ *
+ * @param {string} socketPath - Daemon socket path
+ * @param {object} params - { type, title, status, assignee?, metadata? }
+ * @returns {Promise<object|null>}
+ */
+export async function createTask(socketPath, params) {
+  return rpcRequest("graph.create", {
+    type: "task",
+    ...params,
+  }, socketPath);
+}
+
+/**
+ * Update a task in the opentasks graph.
+ * Returns the updated node or null on failure.
+ *
+ * @param {string} socketPath - Daemon socket path
+ * @param {string} id - Node ID
+ * @param {object} updates - { status?, title?, assignee?, metadata? }
+ * @returns {Promise<object|null>}
+ */
+export async function updateTask(socketPath, id, updates) {
+  return rpcRequest("graph.update", { id, ...updates }, socketPath);
+}
+
+/**
+ * Forward a MAP task sync event to the opentasks graph.
+ * Translates MAP task.* event payloads into opentasks graph operations.
+ * Best-effort: returns true on success, false on failure. Never throws.
+ *
+ * @param {string} socketPath - Daemon socket path
+ * @param {object} evt - MAP task event payload (e.g., { type: "task.sync", uri: "...", status: "..." })
+ * @returns {Promise<boolean>}
+ */
+export async function pushSyncEvent(socketPath, evt) {
+  try {
+    switch (evt.type) {
+      case "task.sync": {
+        // Try to find and update existing node by querying for it
+        // If we have an ID, update directly; otherwise create
+        if (evt.id) {
+          const result = await rpcRequest("graph.update", {
+            id: evt.id,
+            status: evt.status,
+            title: evt.subject,
+            metadata: { source: evt.source, syncedAt: new Date().toISOString() },
+          }, socketPath);
+          if (result !== null) return true;
+        }
+        // Create new node
+        await rpcRequest("graph.create", {
+          type: "task",
+          uri: evt.uri,
+          title: evt.subject || "",
+          status: evt.status || "open",
+          metadata: { source: evt.source, syncedAt: new Date().toISOString() },
+        }, socketPath);
+        return true;
+      }
+
+      case "task.claimed": {
+        if (!evt.id) return false;
+        await rpcRequest("graph.update", {
+          id: evt.id,
+          status: "in_progress",
+          assignee: evt.agent,
+          metadata: { source: evt.source, claimedAt: new Date().toISOString() },
+        }, socketPath);
+        return true;
+      }
+
+      case "task.unblocked": {
+        if (!evt.id) return false;
+        await rpcRequest("graph.update", {
+          id: evt.id,
+          status: "open",
+          metadata: { unblockedBy: evt.unblockedBy, source: evt.source },
+        }, socketPath);
+        return true;
+      }
+
+      case "task.linked": {
+        await rpcRequest("tools.link", {
+          fromId: evt.from,
+          toId: evt.to,
+          type: evt.linkType || "related",
+          metadata: { source: evt.source },
+        }, socketPath);
+        return true;
+      }
+
+      default:
+        return false;
+    }
+  } catch {
+    return false;
+  }
+}

package/src/paths.mjs

@@ -2,22 +2,29 @@
  * paths.mjs — Path constants and directory helpers for claude-code-swarm
  *
  * Centralizes all file paths used by hooks, sidecar, and bootstrap.
- * Plugin-specific files live under .swarm/claude-swarm/ in the user's project root.
- * Generated/runtime artifacts go under .swarm/claude-swarm/tmp/ (gitignored).
- * Package-level dirs (.swarm/openteams/, .swarm/sessionlog/) are managed by swarmkit.
  *
- * Directory layout:
- *   .swarm/claude-swarm/config.json               — user config
+ * Path resolution priority:
+ *   1. If .swarm/claude-swarm/ exists in CWD → use project-level paths
+ *   2. Otherwise → use global paths at ~/.claude/claude-swarm/tmp/
+ *
+ * Global layout:
+ *   ~/.claude/claude-swarm/tmp/teams/<template>/   — shared template artifact cache
+ *   ~/.claude/claude-swarm/tmp/map/<cwd-hash>/     — per-project MAP runtime state
+ *
+ * Project layout (backward-compatible):
+ *   .swarm/claude-swarm/config.json                — user config (always project-relative)
  *   .swarm/claude-swarm/tmp/teams/<template>/      — per-template artifact cache
- *   .swarm/claude-swarm/tmp/map/                   — shared MAP runtime state
+ *   .swarm/claude-swarm/tmp/map/                   — MAP runtime state
  */
 
+import { createHash } from "crypto";
 import fs from "fs";
-import path from "path";
 import os from "os";
+import path from "path";
 import { fileURLToPath } from "url";
 
-// Root plugin directory within .swarm
+// --- Fixed paths (always project-relative) ---
+
 export const SWARM_DIR = ".swarm/claude-swarm";
 export const CONFIG_PATH = ".swarm/claude-swarm/config.json";
 
@@ -25,40 +32,103 @@ export const CONFIG_PATH = ".swarm/claude-swarm/config.json";
 export const GLOBAL_CONFIG_DIR = path.join(os.homedir(), ".claude-swarm");
 export const GLOBAL_CONFIG_PATH = path.join(GLOBAL_CONFIG_DIR, "config.json");
 
-// Temporary/generated artifacts (gitignored)
-export const TMP_DIR = ".swarm/claude-swarm/tmp";
+export const SESSIONLOG_DIR = path.join(".git", "sessionlog-sessions");
 
-// Per-template team artifact cache
-export const TEAMS_DIR = ".swarm/claude-swarm/tmp/teams";
+// --- Global base directory ---
 
-// Shared MAP runtime files (not per-template)
-export const MAP_DIR = ".swarm/claude-swarm/tmp/map";
-export const SOCKET_PATH = ".swarm/claude-swarm/tmp/map/sidecar.sock";
-export const INBOX_PATH = ".swarm/claude-swarm/tmp/map/inbox.jsonl";
-export const PID_PATH = ".swarm/claude-swarm/tmp/map/sidecar.pid";
-export const ROLES_PATH = ".swarm/claude-swarm/tmp/map/roles.json";
-export const SESSIONLOG_STATE_PATH = ".swarm/claude-swarm/tmp/map/sessionlog-state.json";
-export const SIDECAR_LOG_PATH = ".swarm/claude-swarm/tmp/map/sidecar.log";
+const GLOBAL_BASE = path.join(os.homedir(), ".claude", "claude-swarm");
 
-// External paths
-export const SESSIONLOG_DIR = path.join(".git", "sessionlog-sessions");
+// --- Path resolution ---
+
+/**
+ * Compute a short hash of the current working directory.
+ * Used to scope MAP runtime files per-project when using global paths.
+ */
+function cwdHash() {
+  return createHash("sha256").update(process.cwd()).digest("hex").slice(0, 12);
+}
+
+/**
+ * Resolve the base tmp directory.
+ * If .swarm/claude-swarm/ exists in CWD, use project-level paths.
+ * Otherwise, use global paths at ~/.claude/claude-swarm/tmp/.
+ */
+function resolveBaseTmpDir() {
+  if (fs.existsSync(SWARM_DIR)) {
+    return path.join(SWARM_DIR, "tmp");
+  }
+  return path.join(GLOBAL_BASE, "tmp");
+}
+
+/**
+ * Resolve the MAP runtime directory.
+ * When using global paths, scope by CWD hash for per-project isolation.
+ * When using project-level paths, no hash needed (already project-scoped).
+ */
+function resolveMapDir(baseTmpDir) {
+  if (baseTmpDir.startsWith(GLOBAL_BASE)) {
+    return path.join(baseTmpDir, "map", cwdHash());
+  }
+  return path.join(baseTmpDir, "map");
+}
+
+/**
+ * Whether we're using global paths (vs project-level).
+ */
+function isGlobal(baseTmpDir) {
+  return baseTmpDir.startsWith(GLOBAL_BASE);
+}
+
+// --- Computed path constants ---
+
+const _tmpDir = resolveBaseTmpDir();
+const _mapDir = resolveMapDir(_tmpDir);
+const _isGlobal = isGlobal(_tmpDir);
+
+export const TMP_DIR = _tmpDir;
+export const TEAMS_DIR = path.join(_tmpDir, "teams");
+export const MAP_DIR = _mapDir;
+export const SOCKET_PATH = path.join(_mapDir, "sidecar.sock");
+export const INBOX_SOCKET_PATH = path.join(_mapDir, "inbox.sock");
+export const PID_PATH = path.join(_mapDir, "sidecar.pid");
+export const ROLES_PATH = path.join(_mapDir, "roles.json");
+export const SESSIONLOG_STATE_PATH = path.join(_mapDir, "sessionlog-state.json");
+export const SIDECAR_LOG_PATH = path.join(_mapDir, "sidecar.log");
+
+// opentasks runtime state
+export const OPENTASKS_DIR = path.join(_tmpDir, "opentasks");
+export const OPENTASKS_SYNC_STATE_PATH = path.join(_tmpDir, "opentasks", "sync-state.json");
+
+/**
+ * Whether paths resolved to global (~/.claude/claude-swarm/tmp/) vs project-level.
+ */
+export const IS_GLOBAL_PATHS = _isGlobal;
+
+// --- Functions ---
 
 /**
  * Get the per-template team directory.
- * E.g. teamDir("gsd") → ".swarm/claude-swarm/tmp/teams/gsd"
+ * E.g. teamDir("gsd") → ".swarm/claude-swarm/tmp/teams/gsd" or
+ *      "~/.claude/claude-swarm/tmp/teams/gsd"
  */
 export function teamDir(templateName) {
   return path.join(TEAMS_DIR, templateName);
 }
 
 /**
- * Ensure the .swarm/claude-swarm/ directory exists with a .gitignore for tmp/.
+ * Ensure the necessary directories exist.
+ * - Project-level: creates .swarm/claude-swarm/ with .gitignore for tmp/
+ * - Global: creates ~/.claude/claude-swarm/tmp/ (no .gitignore needed)
  */
 export function ensureSwarmDir() {
-  fs.mkdirSync(SWARM_DIR, { recursive: true });
-  const gitignorePath = path.join(SWARM_DIR, ".gitignore");
-  if (!fs.existsSync(gitignorePath)) {
-    fs.writeFileSync(gitignorePath, "tmp/\n");
+  if (_isGlobal) {
+    fs.mkdirSync(TMP_DIR, { recursive: true });
+  } else {
+    fs.mkdirSync(SWARM_DIR, { recursive: true });
+    const gitignorePath = path.join(SWARM_DIR, ".gitignore");
+    if (!fs.existsSync(gitignorePath)) {
+      fs.writeFileSync(gitignorePath, "tmp/\n");
+    }
   }
 }
 
@@ -69,6 +139,13 @@ export function ensureMapDir() {
   fs.mkdirSync(MAP_DIR, { recursive: true });
 }
 
+/**
+ * Ensure the opentasks runtime directory exists.
+ */
+export function ensureOpentasksDir() {
+  fs.mkdirSync(OPENTASKS_DIR, { recursive: true });
+}
+
 /**
  * Resolve the plugin root directory.
  * Works from any file in src/ or scripts/.
@@ -77,3 +154,76 @@ export function pluginDir() {
   const thisFile = fileURLToPath(import.meta.url);
   return path.resolve(path.dirname(thisFile), "..");
 }
+
+// --- Per-session MAP paths ---
+
+/**
+ * Compute per-session MAP sidecar paths.
+ * When sessionId is provided, scopes files to MAP_DIR/sessions/<sessionId>/.
+ * When sessionId is null/undefined, returns the fixed legacy paths
+ * (used by persistent sidecar mode or when session ID is unavailable).
+ *
+ * Long session IDs (>12 chars) are hashed to avoid Unix socket path length limits (~104 chars on macOS).
+ */
+export function sessionPaths(sessionId) {
+  if (!sessionId) {
+    return {
+      socketPath: SOCKET_PATH,
+      inboxSocketPath: INBOX_SOCKET_PATH,
+      pidPath: PID_PATH,
+      sidecarLogPath: SIDECAR_LOG_PATH,
+      sessionDir: null,
+    };
+  }
+  const safeId = sessionId.length > 12
+    ? createHash("sha256").update(sessionId).digest("hex").slice(0, 12)
+    : sessionId;
+  const dir = path.join(_mapDir, "sessions", safeId);
+  return {
+    socketPath: path.join(dir, "sidecar.sock"),
+    inboxSocketPath: path.join(dir, "inbox.sock"),
+    pidPath: path.join(dir, "sidecar.pid"),
+    sidecarLogPath: path.join(dir, "sidecar.log"),
+    sessionDir: dir,
+  };
+}
+
+/**
+ * Ensure the per-session MAP directory exists.
+ * Falls back to creating MAP_DIR when sessionId is null.
+ */
+export function ensureSessionDir(sessionId) {
+  const { sessionDir } = sessionPaths(sessionId);
+  if (sessionDir) {
+    fs.mkdirSync(sessionDir, { recursive: true });
+  } else {
+    fs.mkdirSync(MAP_DIR, { recursive: true });
+  }
+}
+
+/**
+ * List all session directories under MAP_DIR/sessions/.
+ * Returns array of { sessionId, dir, pidPath }.
+ * Used for stale session cleanup.
+ */
+export function listSessionDirs() {
+  const sessionsDir = path.join(_mapDir, "sessions");
+  if (!fs.existsSync(sessionsDir)) return [];
+  try {
+    return fs.readdirSync(sessionsDir)
+      .filter((d) => {
+        try {
+          return fs.statSync(path.join(sessionsDir, d)).isDirectory();
+        } catch {
+          return false;
+        }
+      })
+      .map((d) => ({
+        sessionId: d,
+        dir: path.join(sessionsDir, d),
+        pidPath: path.join(sessionsDir, d, "sidecar.pid"),
+      }));
+  } catch {
+    return [];
+  }
+}

package/src/sessionlog.mjs

@@ -8,7 +8,7 @@
 import fs from "fs";
 import path from "path";
 import { execSync } from "child_process";
-import { SESSIONLOG_DIR, SESSIONLOG_STATE_PATH } from "./paths.mjs";
+import { SESSIONLOG_DIR, SESSIONLOG_STATE_PATH, sessionPaths } from "./paths.mjs";
 import { resolveTeamName } from "./config.mjs";
 import { sendToSidecar, ensureSidecar } from "./sidecar-client.mjs";
 import { fireAndForgetTrajectory } from "./map-connection.mjs";
@@ -123,8 +123,9 @@ export function buildTrajectoryCheckpoint(state, syncLevel, config) {
 
 /**
  * Full sessionlog sync flow: find session, build checkpoint, send to MAP.
+ * When sessionId is provided, uses per-session sidecar paths.
  */
-export async function syncSessionlog(config) {
+export async function syncSessionlog(config, sessionId) {
   const syncLevel = config.sessionlog?.sync || "off";
   if (syncLevel === "off") return;
 
@@ -132,23 +133,27 @@ export async function syncSessionlog(config) {
   if (!session) return;
 
   const checkpoint = buildTrajectoryCheckpoint(session, syncLevel, config);
+  const sPaths = sessionPaths(sessionId);
 
   // Try sidecar trajectory-checkpoint command
-  const sent = await sendToSidecar({
-    action: "trajectory-checkpoint",
-    checkpoint,
-  });
+  const sent = await sendToSidecar(
+    { action: "trajectory-checkpoint", checkpoint },
+    sPaths.socketPath
+  );
 
   if (!sent) {
-    const recovered = await ensureSidecar(config);
+    const recovered = await ensureSidecar(config, sessionId);
     if (recovered) {
-      await sendToSidecar({ action: "trajectory-checkpoint", checkpoint });
+      await sendToSidecar(
+        { action: "trajectory-checkpoint", checkpoint },
+        sPaths.socketPath
+      );
     } else {
       await fireAndForgetTrajectory(config, checkpoint);
     }
   }
 
-  // Cache latest state
+  // Cache latest state (shared, not per-session)
   try {
     fs.mkdirSync(path.dirname(SESSIONLOG_STATE_PATH), { recursive: true });
     fs.writeFileSync(