claude-synapse 1.0.0

package/dist/collector.mjs

@@ -0,0 +1,679 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+
+// apps/collector/dist/index.js
+import { existsSync } from "node:fs";
+import { resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import Fastify from "fastify";
+import cors from "@fastify/cors";
+import fastifyStatic from "@fastify/static";
+import { Server as SocketIOServer } from "socket.io";
+
+// apps/collector/dist/routes/hooks.js
+import { stat } from "node:fs/promises";
+
+// packages/protocol/dist/labels.js
+var toolLabels = {
+  Bash: { active: "Running command", done: "Ran command", icon: ">" },
+  Write: { active: "Writing code", done: "Wrote file", icon: "\u270E" },
+  Edit: { active: "Editing code", done: "Edited file", icon: "\u270E" },
+  Read: { active: "Reading file", done: "Read file", icon: "\u25C9" },
+  Grep: { active: "Searching code", done: "Searched code", icon: "\u2315" },
+  Glob: { active: "Finding files", done: "Found files", icon: "\u2315" },
+  Agent: { active: "Spawning agent", done: "Agent finished", icon: "\u25CE" },
+  WebSearch: { active: "Searching the web", done: "Web search done", icon: "\u2295" },
+  WebFetch: { active: "Fetching page", done: "Fetched page", icon: "\u2295" },
+  NotebookEdit: { active: "Editing notebook", done: "Edited notebook", icon: "\u270E" },
+  TodoWrite: { active: "Updating tasks", done: "Updated tasks", icon: "\u2611" },
+  TaskCreate: { active: "Creating task", done: "Created task", icon: "\u2611" },
+  TaskUpdate: { active: "Updating task", done: "Updated task", icon: "\u2611" },
+  EnterPlanMode: { active: "Planning", done: "Plan ready", icon: "\u25C7" },
+  ExitPlanMode: { active: "Finishing plan", done: "Plan done", icon: "\u25C7" },
+  AskUserQuestion: { active: "Asking user", done: "Got answer", icon: "?" },
+  Skill: { active: "Running skill", done: "Skill complete", icon: "\u26A1" }
+};
+var agentTypeLabels = {
+  Explore: { active: "Exploring codebase", done: "Exploration done", icon: "\u2315" },
+  Plan: { active: "Planning approach", done: "Plan complete", icon: "\u25C7" },
+  "general-purpose": { active: "Working on task", done: "Task complete", icon: "\u25CE" },
+  root: { active: "Thinking", done: "Done", icon: "\u25CE" }
+};
+function getToolLabel(toolName, phase = "active") {
+  const entry = toolLabels[toolName];
+  if (!entry)
+    return phase === "active" ? `Using ${toolName}` : `Used ${toolName}`;
+  return entry[phase];
+}
+function getAgentLabel(agentType, phase = "active") {
+  const entry = agentTypeLabels[agentType];
+  if (!entry)
+    return phase === "active" ? agentType : `${agentType} done`;
+  return entry[phase];
+}
+function getToolDetail(toolName, toolInput) {
+  if (!toolInput)
+    return "";
+  switch (toolName) {
+    case "Bash":
+      return toolInput.description || toolInput.command?.slice(0, 60) || "";
+    case "Write":
+    case "Read":
+      return shortPath(toolInput.file_path);
+    case "Edit":
+      return shortPath(toolInput.file_path);
+    case "Grep":
+      return toolInput.pattern || "";
+    case "Glob":
+      return toolInput.pattern || "";
+    case "Agent":
+      return toolInput.description || toolInput.subagent_type || "";
+    case "WebSearch":
+      return toolInput.query?.slice(0, 50) || "";
+    case "WebFetch":
+      return shortUrl(toolInput.url);
+    default:
+      return "";
+  }
+}
+function shortPath(p) {
+  if (!p)
+    return "";
+  const parts = p.split("/");
+  return parts.length > 2 ? `.../${parts.slice(-2).join("/")}` : p;
+}
+function shortUrl(u) {
+  if (!u)
+    return "";
+  try {
+    return new URL(u).hostname;
+  } catch {
+    return u.slice(0, 40);
+  }
+}
+
+// packages/protocol/dist/transforms.js
+var eventCounter = 0;
+function generateId() {
+  return `evt_${Date.now()}_${++eventCounter}`;
+}
+var activeSessions = /* @__PURE__ */ new Set();
+var knownSubagents = /* @__PURE__ */ new Map();
+var pendingAgentModels = /* @__PURE__ */ new Map();
+function transformClaudeHook(hookEvent, body) {
+  const events = [];
+  const now = Date.now();
+  const sessionId = body.session_id || "session_default";
+  const rootAgentId = `root_${sessionId}`;
+  const commonMeta = {};
+  if (body.permission_mode)
+    commonMeta.permissionMode = body.permission_mode;
+  if (body.cwd)
+    commonMeta.cwd = body.cwd;
+  if (body.transcript_path)
+    commonMeta.transcriptPath = body.transcript_path;
+  if (!activeSessions.has(sessionId)) {
+    activeSessions.add(sessionId);
+    events.push({
+      id: generateId(),
+      type: "session_start",
+      timestamp: now,
+      sessionId,
+      agentId: "system",
+      agentName: "Session",
+      agentType: "system",
+      parentAgentId: null,
+      payload: { metadata: commonMeta },
+      source: "claude_hooks"
+    });
+    events.push({
+      id: generateId(),
+      type: "agent_spawned",
+      timestamp: now,
+      sessionId,
+      agentId: rootAgentId,
+      agentName: "Claude",
+      agentType: "root",
+      parentAgentId: null,
+      payload: {},
+      source: "claude_hooks"
+    });
+  }
+  if (Object.keys(commonMeta).length > 0) {
+    events.push({
+      id: generateId(),
+      type: "session_meta",
+      timestamp: now,
+      sessionId,
+      agentId: "system",
+      agentName: "Session",
+      agentType: "system",
+      parentAgentId: null,
+      payload: { metadata: commonMeta },
+      source: "claude_hooks"
+    });
+  }
+  if (hookEvent === "SessionStart") {
+    const meta = { ...commonMeta };
+    if (body.model)
+      meta.model = body.model;
+    if (body.source)
+      meta.sessionSource = body.source;
+    events.push({
+      id: generateId(),
+      type: "session_meta",
+      timestamp: now,
+      sessionId,
+      agentId: "system",
+      agentName: "Session started",
+      agentType: "system",
+      parentAgentId: null,
+      payload: {
+        message: body.source === "compact" ? "Context compacted \u2014 session resumed" : body.source === "resume" ? "Session resumed" : body.model ? `Model: ${body.model}` : "Session started",
+        metadata: meta
+      },
+      source: "claude_hooks"
+    });
+  } else if (hookEvent === "PreCompact") {
+    events.push({
+      id: generateId(),
+      type: "context_compact",
+      timestamp: now,
+      sessionId,
+      agentId: "system",
+      agentName: "Context compaction",
+      agentType: "system",
+      parentAgentId: null,
+      payload: {
+        message: body.trigger === "manual" ? "Manual context compaction (/compact)" : "Auto context compaction (nearing limit)",
+        metadata: {
+          trigger: body.trigger,
+          customInstructions: body.custom_instructions
+        }
+      },
+      source: "claude_hooks"
+    });
+  } else if (hookEvent === "UserPromptSubmit") {
+    events.push({
+      id: generateId(),
+      type: "user_prompt",
+      timestamp: now,
+      sessionId,
+      agentId: "system",
+      agentName: "User prompt",
+      agentType: "system",
+      parentAgentId: null,
+      payload: {
+        message: body.prompt?.slice(0, 200)
+      },
+      source: "claude_hooks"
+    });
+    events.push({
+      id: generateId(),
+      type: "agent_thinking",
+      timestamp: now,
+      sessionId,
+      agentId: rootAgentId,
+      agentName: "Claude",
+      agentType: "root",
+      parentAgentId: null,
+      payload: { message: "Processing prompt..." },
+      source: "claude_hooks"
+    });
+  } else if (hookEvent === "Notification") {
+    events.push({
+      id: generateId(),
+      type: "notification",
+      timestamp: now,
+      sessionId,
+      agentId: "system",
+      agentName: body.title || "Notification",
+      agentType: "system",
+      parentAgentId: null,
+      payload: {
+        message: body.message,
+        metadata: {
+          notificationType: body.notification_type
+        }
+      },
+      source: "claude_hooks"
+    });
+  } else if (hookEvent === "SessionEnd") {
+    events.push({
+      id: generateId(),
+      type: "session_end",
+      timestamp: now,
+      sessionId,
+      agentId: "system",
+      agentName: "Session ended",
+      agentType: "system",
+      parentAgentId: null,
+      payload: {
+        message: `Session ended: ${body.reason || "unknown"}`,
+        metadata: { reason: body.reason }
+      },
+      source: "claude_hooks"
+    });
+    activeSessions.delete(sessionId);
+    for (const [id, sub] of knownSubagents) {
+      if (sub.sessionId === sessionId)
+        knownSubagents.delete(id);
+    }
+  } else if (hookEvent === "PermissionRequest") {
+    const toolName = body.tool_name || "unknown";
+    const detail = getToolDetail(toolName, body.tool_input);
+    events.push({
+      id: generateId(),
+      type: "notification",
+      timestamp: now,
+      sessionId,
+      agentId: "system",
+      agentName: "Permission request",
+      agentType: "system",
+      parentAgentId: null,
+      payload: {
+        message: `${getToolLabel(toolName, "active")}${detail ? ": " + detail : ""}`,
+        metadata: { notificationType: "permission_prompt", toolName }
+      },
+      source: "claude_hooks"
+    });
+  } else if (hookEvent === "SubagentStart") {
+    const agentId = body.agent_id || `sub_${generateId()}`;
+    const agentType = body.agent_type || "subagent";
+    const queue = pendingAgentModels.get(sessionId);
+    const agentModel = queue?.shift() || null;
+    if (queue && queue.length === 0)
+      pendingAgentModels.delete(sessionId);
+    knownSubagents.set(agentId, { sessionId, agentType });
+    events.push({
+      id: generateId(),
+      type: "agent_spawned",
+      timestamp: now,
+      sessionId,
+      agentId,
+      agentName: getAgentLabel(agentType, "active"),
+      agentType,
+      parentAgentId: rootAgentId,
+      payload: { metadata: agentModel ? { model: agentModel } : void 0 },
+      source: "claude_hooks"
+    });
+  } else if (hookEvent === "SubagentStop") {
+    const agentId = body.agent_id || "unknown_sub";
+    const sub = knownSubagents.get(agentId);
+    const agentType = sub?.agentType || body.agent_type || "subagent";
+    events.push({
+      id: generateId(),
+      type: "agent_completed",
+      timestamp: now,
+      sessionId,
+      agentId,
+      agentName: getAgentLabel(agentType, "done"),
+      agentType,
+      parentAgentId: rootAgentId,
+      payload: {
+        message: body.last_assistant_message?.slice(0, 200)
+      },
+      source: "claude_hooks"
+    });
+  } else if (hookEvent === "PreToolUse") {
+    const toolName = body.tool_name || "unknown";
+    const toolUseId = body.tool_use_id || `tool_${generateId()}`;
+    const detail = getToolDetail(toolName, body.tool_input);
+    if (toolName === "Agent" && body.tool_input?.model) {
+      const queue = pendingAgentModels.get(sessionId) || [];
+      queue.push(body.tool_input.model);
+      pendingAgentModels.set(sessionId, queue);
+    }
+    events.push({
+      id: generateId(),
+      type: "agent_spawned",
+      timestamp: now,
+      sessionId,
+      agentId: toolUseId,
+      agentName: getToolLabel(toolName, "active"),
+      agentType: toolName,
+      parentAgentId: rootAgentId,
+      payload: {
+        tool: { toolName, toolInput: body.tool_input },
+        message: detail
+      },
+      source: "claude_hooks"
+    });
+    events.push({
+      id: generateId(),
+      type: "agent_tool_start",
+      timestamp: now,
+      sessionId,
+      agentId: toolUseId,
+      agentName: getToolLabel(toolName, "active"),
+      agentType: toolName,
+      parentAgentId: rootAgentId,
+      payload: {
+        tool: { toolName, toolInput: body.tool_input },
+        message: detail
+      },
+      source: "claude_hooks"
+    });
+    events.push({
+      id: generateId(),
+      type: "agent_tool_start",
+      timestamp: now,
+      sessionId,
+      agentId: rootAgentId,
+      agentName: "Claude",
+      agentType: "root",
+      parentAgentId: null,
+      payload: {
+        tool: { toolName }
+      },
+      source: "claude_hooks"
+    });
+  } else if (hookEvent === "PostToolUse") {
+    const toolName = body.tool_name || "unknown";
+    const toolUseId = body.tool_use_id || "";
+    if (toolUseId) {
+      events.push({
+        id: generateId(),
+        type: "agent_completed",
+        timestamp: now,
+        sessionId,
+        agentId: toolUseId,
+        agentName: getToolLabel(toolName, "done"),
+        agentType: toolName,
+        parentAgentId: rootAgentId,
+        payload: {
+          tool: {
+            toolName,
+            toolResult: typeof body.tool_response === "string" ? body.tool_response.slice(0, 500) : body.tool_response ? JSON.stringify(body.tool_response).slice(0, 500) : void 0
+          }
+        },
+        source: "claude_hooks"
+      });
+      events.push({
+        id: generateId(),
+        type: "agent_tool_end",
+        timestamp: now,
+        sessionId,
+        agentId: rootAgentId,
+        agentName: "Claude",
+        agentType: "root",
+        parentAgentId: null,
+        payload: {
+          tool: { toolName }
+        },
+        source: "claude_hooks"
+      });
+    }
+  } else if (hookEvent === "PostToolUseFailure") {
+    const toolName = body.tool_name || "unknown";
+    const toolUseId = body.tool_use_id || "";
+    if (toolUseId) {
+      events.push({
+        id: generateId(),
+        type: "agent_error",
+        timestamp: now,
+        sessionId,
+        agentId: toolUseId,
+        agentName: getToolLabel(toolName, "done"),
+        agentType: toolName,
+        parentAgentId: rootAgentId,
+        payload: {
+          error: body.error,
+          tool: { toolName, error: body.error }
+        },
+        source: "claude_hooks"
+      });
+      events.push({
+        id: generateId(),
+        type: "agent_tool_end",
+        timestamp: now,
+        sessionId,
+        agentId: rootAgentId,
+        agentName: "Claude",
+        agentType: "root",
+        parentAgentId: null,
+        payload: {
+          tool: { toolName }
+        },
+        source: "claude_hooks"
+      });
+    }
+  } else if (hookEvent === "Stop") {
+    events.push({
+      id: generateId(),
+      type: "agent_completed",
+      timestamp: now,
+      sessionId,
+      agentId: rootAgentId,
+      agentName: "Claude",
+      agentType: "root",
+      parentAgentId: null,
+      payload: {
+        message: body.last_assistant_message?.slice(0, 200)
+      },
+      source: "claude_hooks"
+    });
+    activeSessions.delete(sessionId);
+    for (const [id, sub] of knownSubagents) {
+      if (sub.sessionId === sessionId)
+        knownSubagents.delete(id);
+    }
+  }
+  return events;
+}
+
+// apps/collector/dist/store/memory-store.js
+var MemoryStore = class {
+  events = /* @__PURE__ */ new Map();
+  sessions = /* @__PURE__ */ new Map();
+  addEvent(event) {
+    const { sessionId } = event;
+    if (!this.sessions.has(sessionId)) {
+      this.sessions.set(sessionId, {
+        id: sessionId,
+        startedAt: event.timestamp,
+        endedAt: null,
+        eventCount: 0
+      });
+    }
+    const session = this.sessions.get(sessionId);
+    session.eventCount++;
+    if (event.type === "session_end") {
+      session.endedAt = event.timestamp;
+    }
+    if (!this.events.has(sessionId)) {
+      this.events.set(sessionId, []);
+    }
+    this.events.get(sessionId).push(event);
+  }
+  getSessionEvents(sessionId) {
+    return this.events.get(sessionId) || [];
+  }
+  getSessions() {
+    return Array.from(this.sessions.values()).sort((a, b) => b.startedAt - a.startedAt);
+  }
+  getLatestSession() {
+    const sessions = this.getSessions();
+    return sessions[0] || null;
+  }
+  getAllEvents() {
+    const all = [];
+    for (const events of this.events.values()) {
+      all.push(...events);
+    }
+    return all.sort((a, b) => a.timestamp - b.timestamp);
+  }
+  clear() {
+    this.events.clear();
+    this.sessions.clear();
+  }
+};
+var store = new MemoryStore();
+
+// apps/collector/dist/ws/broadcaster.js
+var io = null;
+function initBroadcaster(socketServer) {
+  io = socketServer;
+  io.on("connection", (socket) => {
+    console.log(`[ws] Dashboard connected: ${socket.id}`);
+    socket.on("join_session", (sessionId) => {
+      socket.join(`session:${sessionId}`);
+      console.log(`[ws] ${socket.id} joined session: ${sessionId}`);
+    });
+    socket.on("leave_session", (sessionId) => {
+      socket.leave(`session:${sessionId}`);
+    });
+    socket.on("disconnect", () => {
+      console.log(`[ws] Dashboard disconnected: ${socket.id}`);
+    });
+  });
+}
+function broadcastEvent(event) {
+  if (!io)
+    return;
+  io.emit("agent_event", event);
+  io.to(`session:${event.sessionId}`).emit("session_event", event);
+}
+function broadcastSessionList(sessions) {
+  if (!io)
+    return;
+  io.emit("sessions_updated", sessions);
+}
+
+// apps/collector/dist/routes/hooks.js
+var contextEventCounter = 0;
+function formatBytes(bytes) {
+  if (bytes < 1024)
+    return `${bytes} B`;
+  if (bytes < 1024 * 1024)
+    return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+async function getTranscriptSize(transcriptPath, sessionId) {
+  try {
+    const stats = await stat(transcriptPath);
+    return {
+      id: `ctx_${Date.now()}_${++contextEventCounter}`,
+      type: "session_meta",
+      timestamp: Date.now(),
+      sessionId,
+      agentId: "system",
+      agentName: "Transcript",
+      agentType: "system",
+      parentAgentId: null,
+      payload: {
+        metadata: {
+          transcriptBytes: stats.size,
+          transcriptSize: formatBytes(stats.size)
+        }
+      },
+      source: "claude_hooks"
+    };
+  } catch {
+    return null;
+  }
+}
+async function hookRoutes(app) {
+  app.post("/api/hooks/:hookEvent", async (request, reply) => {
+    const { hookEvent } = request.params;
+    const body = request.body || {};
+    console.log(`[hook] ${hookEvent}`, JSON.stringify(body, null, 2));
+    try {
+      const events = transformClaudeHook(hookEvent, body);
+      for (const event of events) {
+        store.addEvent(event);
+        broadcastEvent(event);
+      }
+      const transcriptPath = body.transcript_path;
+      const sessionId = body.session_id;
+      if (transcriptPath && sessionId) {
+        const ctxEvent = await getTranscriptSize(transcriptPath, sessionId);
+        if (ctxEvent) {
+          store.addEvent(ctxEvent);
+          broadcastEvent(ctxEvent);
+        }
+      }
+      broadcastSessionList(store.getSessions());
+      return reply.status(200).send({ ok: true, eventsCreated: events.length });
+    } catch (err) {
+      console.error(`[hook] Error processing ${hookEvent}:`, err);
+      return reply.status(200).send({ ok: false, error: "processing_error" });
+    }
+  });
+}
+
+// apps/collector/dist/routes/events.js
+async function eventRoutes(app) {
+  app.post("/api/events", async (request, reply) => {
+    const event = request.body;
+    if (!event || !event.type || !event.sessionId) {
+      return reply.status(400).send({ error: "Invalid event: requires type and sessionId" });
+    }
+    console.log(`[sdk] ${event.type} from ${event.agentName}`);
+    store.addEvent(event);
+    broadcastEvent(event);
+    broadcastSessionList(store.getSessions());
+    return reply.status(200).send({ ok: true });
+  });
+  app.post("/api/events/batch", async (request, reply) => {
+    const events = request.body;
+    if (!Array.isArray(events)) {
+      return reply.status(400).send({ error: "Expected array of events" });
+    }
+    for (const event of events) {
+      store.addEvent(event);
+      broadcastEvent(event);
+    }
+    broadcastSessionList(store.getSessions());
+    return reply.status(200).send({ ok: true, count: events.length });
+  });
+}
+
+// apps/collector/dist/routes/sessions.js
+async function sessionRoutes(app) {
+  app.get("/api/sessions", async (_request, reply) => {
+    return reply.send(store.getSessions());
+  });
+  app.get("/api/sessions/:sessionId/events", async (request, reply) => {
+    const { sessionId } = request.params;
+    const events = store.getSessionEvents(sessionId);
+    return reply.send(events);
+  });
+}
+
+// apps/collector/dist/index.js
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var PORT = Number(process.env.PORT) || 4800;
+async function main() {
+  const app = Fastify({ logger: false });
+  await app.register(cors, { origin: true });
+  await app.register(hookRoutes);
+  await app.register(eventRoutes);
+  await app.register(sessionRoutes);
+  app.get("/health", async () => ({ status: "ok", uptime: process.uptime() }));
+  const dashboardDist = resolve(process.env.SYNAPSE_DASHBOARD_DIR || resolve(__dirname, "../../dashboard/dist"));
+  if (existsSync(dashboardDist)) {
+    await app.register(fastifyStatic, {
+      root: dashboardDist,
+      prefix: "/",
+      wildcard: false
+    });
+    app.setNotFoundHandler(async (request, reply) => {
+      if (request.url.startsWith("/api/") || request.url.startsWith("/socket.io/")) {
+        return reply.status(404).send({ error: "Not found" });
+      }
+      return reply.sendFile("index.html");
+    });
+    console.log(`[synapse] Dashboard available at http://localhost:${PORT}`);
+  }
+  await app.listen({ port: PORT, host: "0.0.0.0" });
+  const io2 = new SocketIOServer(app.server, {
+    cors: { origin: "*" }
+  });
+  initBroadcaster(io2);
+  console.log(`[synapse] Collector listening on http://localhost:${PORT}`);
+  console.log(`[synapse] WebSocket ready for dashboard connections`);
+}
+main().catch((err) => {
+  console.error("[synapse] Failed to start:", err);
+  process.exit(1);
+});