@sleep2agi/commhub-server 0.4.4 → 0.5.0-preview.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sleep2agi/commhub-server",
-  "version": "0.4.4",
+  "version": "0.5.0-preview.2",
   "description": "CommHub MCP Server — AI Agent communication hub with SSE push, MCP protocol, and REST API",
   "type": "module",
   "main": "src/index.ts",

package/src/db.ts

@@ -58,6 +58,83 @@ db.exec(`
   );
 `);
 
+// ── V2 schema migration (ALTER TABLE, safe to re-run) ──
+
+// sessions: add node_id, session_id, config_path, channels, last_seen_at
+for (const col of [
+  { name: "node_id", def: "TEXT" },
+  { name: "session_id", def: "TEXT" },
+  { name: "config_path", def: "TEXT" },
+  { name: "channels", def: "TEXT" },
+  { name: "last_seen_at", def: "TEXT" },
+]) {
+  try { db.exec(`ALTER TABLE sessions ADD COLUMN ${col.name} ${col.def}`); } catch {}
+}
+
+// inbox: add in_reply_to, requires_response, expires_at, scope
+for (const col of [
+  { name: "in_reply_to", def: "TEXT" },
+  { name: "requires_response", def: "TEXT DEFAULT 'reply'" },
+  { name: "expires_at", def: "TEXT" },
+  { name: "scope", def: "TEXT DEFAULT 'single'" },
+]) {
+  try { db.exec(`ALTER TABLE inbox ADD COLUMN ${col.name} ${col.def}`); } catch {}
+}
+
+// indexes for new columns
+try { db.exec("CREATE INDEX IF NOT EXISTS idx_inbox_type ON inbox(type)"); } catch {}
+try { db.exec("CREATE INDEX IF NOT EXISTS idx_inbox_from ON inbox(from_session)"); } catch {}
+try { db.exec("CREATE INDEX IF NOT EXISTS idx_inbox_reply ON inbox(in_reply_to)"); } catch {}
+try { db.exec("CREATE INDEX IF NOT EXISTS idx_sessions_node ON sessions(node_id)"); } catch {}
+
+// tasks table (V2)
+db.exec(`
+  CREATE TABLE IF NOT EXISTS tasks (
+    task_id           TEXT PRIMARY KEY,
+    from_node_id      TEXT,
+    from_name         TEXT NOT NULL DEFAULT 'hub',
+    to_node_id        TEXT,
+    to_name           TEXT NOT NULL,
+    priority          TEXT NOT NULL DEFAULT 'normal',
+    status            TEXT NOT NULL DEFAULT 'created',
+    content           TEXT NOT NULL,
+    result            TEXT,
+    in_reply_to       TEXT,
+    requires_response TEXT DEFAULT 'reply',
+    scope             TEXT DEFAULT 'single',
+    created_at        TEXT NOT NULL DEFAULT (datetime('now')),
+    delivered_at      TEXT,
+    started_at        TEXT,
+    completed_at      TEXT,
+    expires_at        TEXT
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_tasks_to ON tasks(to_name);
+  CREATE INDEX IF NOT EXISTS idx_tasks_from ON tasks(from_name);
+  CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
+  CREATE INDEX IF NOT EXISTS idx_tasks_created ON tasks(created_at);
+`);
+
+// nodes table (V2 Sprint 2) — persistent node identity, separate from runtime sessions
+db.exec(`
+  CREATE TABLE IF NOT EXISTS nodes (
+    node_id       TEXT PRIMARY KEY,
+    node_name     TEXT NOT NULL,
+    alias         TEXT,
+    runtime       TEXT,
+    model         TEXT,
+    config_path   TEXT,
+    channels      TEXT,
+    server        TEXT,
+    hostname      TEXT,
+    created_at    TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at    TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_nodes_name ON nodes(node_name);
+  CREATE INDEX IF NOT EXISTS idx_nodes_alias ON nodes(alias);
+`);
+
 // Helpers
 export function uuidv4(): string {
   return crypto.randomUUID();

package/src/index.ts

@@ -74,6 +74,20 @@ function withCors(req: Request, res: Response): Response {
 const wsTmuxIntervals = new Map<object, ReturnType<typeof setInterval>>();
 
 
+// ── Task expiration patrol (every 5 minutes) ──
+setInterval(() => {
+  try {
+    const result = db.run(
+      `UPDATE tasks SET status = 'expired', completed_at = datetime('now')
+       WHERE expires_at IS NOT NULL AND expires_at < datetime('now')
+         AND status IN ('created', 'delivered')`
+    );
+    if (result.changes > 0) {
+      console.log(`[patrol] expired ${result.changes} stale task(s)`);
+    }
+  } catch {}
+}, 5 * 60 * 1000);
+
 Bun.serve({
   port: PORT,
   idleTimeout: 255, // max value: keep SSE connections alive (seconds)
@@ -88,13 +102,16 @@ Bun.serve({
 
     // ── WebSocket: tmux terminal ──
     const wsMatch = url.pathname.match(/^\/ws\/tmux\/([a-zA-Z0-9_-]+)$/);
-    if (wsMatch && server.upgrade(req, { data: { tmuxName: wsMatch[1] } })) {
-      return; // upgraded
+    if (wsMatch) {
+      const authErr = requireAuth(req);
+      if (authErr) return withCors(req, authErr);
+      if (server.upgrade(req, { data: { tmuxName: wsMatch[1] } })) return;
     }
 
     // ── MCP Streamable HTTP endpoint ──
-    // MCP protocol handles its own auth — skip token check here
     if (url.pathname === "/mcp") {
+      const authErr = requireAuth(req);
+      if (authErr) return withCors(req, authErr);
       const fwd = req.headers.get("x-forwarded-for");
       const clientIP = fwd ? fwd.split(",")[0].trim() : (req.headers.get("x-real-ip") ?? "unknown");
       const transport = new WebStandardStreamableHTTPServerTransport({
@@ -264,6 +281,40 @@ Bun.serve({
       return withCors(req, Response.json({ ok: true, messages: rows }));
     }
 
+    // ── REST: nodes table (V2 Sprint 2) ──
+    if (url.pathname === "/api/nodes") {
+      const nodeId = url.searchParams.get("node_id");
+      const alias = url.searchParams.get("alias");
+      let sql = "SELECT * FROM nodes WHERE 1=1";
+      const params: any[] = [];
+      if (nodeId) { sql += ` AND node_id = ?${params.length + 1}`; params.push(nodeId); }
+      if (alias) { sql += ` AND alias = ?${params.length + 1}`; params.push(alias); }
+      sql += " ORDER BY updated_at DESC";
+      const rows = db.query(sql).all(...params);
+      return withCors(req, Response.json({ ok: true, nodes: rows, count: rows.length }));
+    }
+
+    // ── REST: tasks table (V2) ──
+    if (url.pathname === "/api/tasks") {
+      const taskId = url.searchParams.get("task_id");
+      const status = url.searchParams.get("status");
+      const toName = url.searchParams.get("to_name");
+      const fromName = url.searchParams.get("from_name");
+      const limit = Math.min(Number(url.searchParams.get("limit")) || 50, 200);
+
+      let sql = "SELECT * FROM tasks WHERE 1=1";
+      const params: any[] = [];
+      if (taskId) { sql += ` AND task_id = ?${params.length + 1}`; params.push(taskId); }
+      if (status) { sql += ` AND status = ?${params.length + 1}`; params.push(status); }
+      if (toName) { sql += ` AND to_name = ?${params.length + 1}`; params.push(toName); }
+      if (fromName) { sql += ` AND from_name = ?${params.length + 1}`; params.push(fromName); }
+      sql += ` ORDER BY created_at DESC LIMIT ?${params.length + 1}`;
+      params.push(limit);
+
+      const rows = db.query(sql).all(...params);
+      return withCors(req, Response.json({ ok: true, tasks: rows, count: rows.length }));
+    }
+
     // ── REST: recent completions ──
     if (url.pathname === "/api/completions") {
       const since = url.searchParams.get("since") ?? new Date(Date.now() - 86400000).toISOString();
@@ -280,6 +331,7 @@ Endpoints:
   GET  /health            - Health check
   GET  /api/status        - All sessions ${AUTH_TOKEN ? "(auth required)" : ""}
   POST /api/task          - Send task via REST ${AUTH_TOKEN ? "(auth required)" : ""}
+  GET  /api/tasks         - Tasks table (V2) ${AUTH_TOKEN ? "(auth required)" : ""}
   GET  /api/completions   - Recent completions ${AUTH_TOKEN ? "(auth required)" : ""}
   GET  /api/tmux/:name    - Capture tmux pane output ${AUTH_TOKEN ? "(auth required)" : ""}
   POST /api/tmux/:name/send - Send keys to tmux ${AUTH_TOKEN ? "(auth required)" : ""}

package/src/tools.ts

@@ -18,7 +18,7 @@ export function registerTools(server: McpServer, clientIP?: string) {
     {
       resume_id: z.string().min(1).max(200).describe("Claude Code session UUID (unique per session)"),
       alias: z.string().min(1).max(200).describe("Human-readable session name for dispatching (e.g. 指挥室/知识哥)"),
-      status: z.enum(["working", "idle", "blocked", "error", "waiting_input"]),
+      status: z.enum(["working", "idle", "blocked", "error", "waiting_input", "offline"]),
       task: z.string().max(10000).optional().describe("Current task description"),
       output: z.string().max(50000).optional().describe("Recent output (max 4000 chars stored)"),
       score: z.number().min(0).max(10).optional().describe("Self-score 1-10"),
@@ -29,36 +29,84 @@ export function registerTools(server: McpServer, clientIP?: string) {
       project_dir: z.string().max(1000).optional().describe("Agent working directory"),
       version: z.string().max(100).optional().describe("Agent version"),
       tmux_name: z.string().max(200).optional().describe("tmux session name"),
+      // V2 fields
+      node_id: z.string().max(200).optional().describe("Stable node identifier"),
+      session_id: z.string().max(200).optional().describe("Runtime session/thread ID"),
+      config_path: z.string().max(1000).optional().describe("Config file path"),
+      channels: z.string().max(2000).optional().describe("JSON array of channels"),
+      model: z.string().max(200).optional().describe("AI model name"),
     },
-    async ({ resume_id, alias, status, task, output, score, progress, server: srv, hostname: hn, agent: ag, project_dir: pd, version: ver, tmux_name: tmux }) => {
+    async ({ resume_id, alias, status, task, output, score, progress, server: srv, hostname: hn, agent: ag, project_dir: pd, version: ver, tmux_name: tmux, node_id, session_id, config_path, channels, model: mdl }) => {
       console.log(`[${ts()}] ${alias} (${resume_id.slice(0, 8)}) → report_status: ${status}${task ? " | " + task.slice(0, 60) : ""}`);
       const trimmedOutput = output?.slice(0, 4000);
 
-      // Wrap DELETE + UPSERT in transaction to prevent race conditions
-      db.run("BEGIN IMMEDIATE");
-      db.run("DELETE FROM sessions WHERE alias = ?1 AND resume_id != ?2", [alias, resume_id]);
-      db.run(
-        `INSERT INTO sessions (resume_id, alias, tmux_name, server, ip, hostname, agent, project_dir, version, status, task, output, progress, score, updated_at)
-         VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13, ?14, datetime('now'))
-         ON CONFLICT(resume_id) DO UPDATE SET
-           alias = COALESCE(?2, sessions.alias),
-           tmux_name = COALESCE(?3, sessions.tmux_name),
-           server = COALESCE(?4, sessions.server),
-           ip = COALESCE(?5, sessions.ip),
-           hostname = COALESCE(?6, sessions.hostname),
-           agent = COALESCE(?7, sessions.agent),
-           project_dir = COALESCE(?8, sessions.project_dir),
-           version = COALESCE(?9, sessions.version),
-           status = ?10,
-           task = COALESCE(?11, sessions.task),
-           output = COALESCE(?12, sessions.output),
-           progress = COALESCE(?13, sessions.progress),
-           score = COALESCE(?14, sessions.score),
-           updated_at = datetime('now')`,
-        [resume_id, alias, tmux ?? null, srv ?? null, clientIP ?? null, hn ?? null, ag ?? null, pd ?? null, ver ?? null, status, task ?? null, trimmedOutput ?? null, progress ?? null, score ?? null]
-      );
+      try {
+        db.run("BEGIN IMMEDIATE");
+        db.run("DELETE FROM sessions WHERE alias = ?1 AND resume_id != ?2", [alias, resume_id]);
+        db.run(
+          `INSERT INTO sessions (resume_id, alias, tmux_name, server, ip, hostname, agent, project_dir, version, status, task, output, progress, score, node_id, session_id, config_path, channels, last_seen_at, updated_at)
+           VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13, ?14, ?15, ?16, ?17, ?18, datetime('now'), datetime('now'))
+           ON CONFLICT(resume_id) DO UPDATE SET
+             alias = COALESCE(?2, sessions.alias),
+             tmux_name = COALESCE(?3, sessions.tmux_name),
+             server = COALESCE(?4, sessions.server),
+             ip = COALESCE(?5, sessions.ip),
+             hostname = COALESCE(?6, sessions.hostname),
+             agent = COALESCE(?7, sessions.agent),
+             project_dir = COALESCE(?8, sessions.project_dir),
+             version = COALESCE(?9, sessions.version),
+             status = ?10,
+             task = COALESCE(?11, sessions.task),
+             output = COALESCE(?12, sessions.output),
+             progress = COALESCE(?13, sessions.progress),
+             score = COALESCE(?14, sessions.score),
+             node_id = COALESCE(?15, sessions.node_id),
+             session_id = COALESCE(?16, sessions.session_id),
+             config_path = COALESCE(?17, sessions.config_path),
+             channels = COALESCE(?18, sessions.channels),
+             last_seen_at = datetime('now'),
+             updated_at = datetime('now')`,
+          [resume_id, alias, tmux ?? null, srv ?? null, clientIP ?? null, hn ?? null, ag ?? null, pd ?? null, ver ?? null, status, task ?? null, trimmedOutput ?? null, progress ?? null, score ?? null, node_id ?? null, session_id ?? null, config_path ?? null, channels ?? null]
+        );
+        db.run("COMMIT");
+      } catch (e) {
+        try { db.run("ROLLBACK"); } catch {}
+        throw e;
+      }
+
+      // V2: sync tasks table — report_status(working) → tasks.running
+      if (status === "working" && task) {
+        try {
+          db.run(
+            `UPDATE tasks SET status = 'running', started_at = datetime('now')
+             WHERE to_name = ?1 AND status IN ('delivered', 'acked') AND content = ?2`,
+            [alias, task]
+          );
+        } catch {}
+      }
 
-      db.run("COMMIT");
+      // V2: upsert nodes table for persistent node identity
+      if (node_id) {
+        try {
+          // Extract runtime from agent field (e.g., "agent-node:codex" → "codex-sdk")
+          const nodeRuntime = ag?.includes(":") ? ag.split(":")[1] + "-sdk" : ag ?? null;
+          db.run(
+            `INSERT INTO nodes (node_id, node_name, alias, runtime, model, config_path, channels, server, hostname, updated_at)
+             VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, datetime('now'))
+             ON CONFLICT(node_id) DO UPDATE SET
+               node_name = COALESCE(?2, nodes.node_name),
+               alias = COALESCE(?3, nodes.alias),
+               runtime = COALESCE(?4, nodes.runtime),
+               model = COALESCE(?5, nodes.model),
+               config_path = COALESCE(?6, nodes.config_path),
+               channels = COALESCE(?7, nodes.channels),
+               server = COALESCE(?8, nodes.server),
+               hostname = COALESCE(?9, nodes.hostname),
+               updated_at = datetime('now')`,
+            [node_id, alias, alias, nodeRuntime, mdl ?? null, config_path ?? null, channels ?? null, srv ?? null, hn ?? null]
+          );
+        } catch {}
+      }
 
       // inbox uses alias for routing
       const row = db.query<{ cnt: number }, [string]>(
@@ -95,17 +143,46 @@ export function registerTools(server: McpServer, clientIP?: string) {
     async ({ alias, task, result, artifacts, score, duration_minutes }) => {
       console.log(`[${ts()}] ${alias} → report_completion: ${task.slice(0, 60)}`);
       const id = uuidv4();
-      db.run(
-        `INSERT INTO completions (id, session_name, task, result, artifacts, score, duration_minutes)
-         VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7)`,
-        [id, alias, task, result, artifacts ? JSON.stringify(artifacts) : null, score ?? null, duration_minutes ?? null]
-      );
+      try {
+        db.run("BEGIN IMMEDIATE");
+        db.run(
+          `INSERT INTO completions (id, session_name, task, result, artifacts, score, duration_minutes)
+           VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7)`,
+          [id, alias, task, result, artifacts ? JSON.stringify(artifacts) : null, score ?? null, duration_minutes ?? null]
+        );
 
-      db.run(
-        `UPDATE sessions SET status = 'idle', task = NULL, progress = 0, updated_at = datetime('now')
-         WHERE alias = ?1`,
-        [alias]
-      );
+        db.run(
+          `UPDATE sessions SET status = 'idle', task = NULL, progress = 0, updated_at = datetime('now')
+           WHERE alias = ?1`,
+          [alias]
+        );
+
+        // V2: sync tasks table — try by task_id first, then by content
+        const taskUpdate = db.run(
+          `UPDATE tasks SET status = 'replied', result = ?1, completed_at = datetime('now')
+           WHERE task_id = ?2 AND status IN ('delivered', 'acked', 'running')`,
+          [result.slice(0, 4000), task]
+        );
+        if (taskUpdate.changes === 0) {
+          // fallback: match most recent task by to_name + content (legacy path)
+          const match = db.query<{ task_id: string }, [string, string]>(
+            `SELECT task_id FROM tasks WHERE to_name = ?1 AND content = ?2
+             AND status IN ('delivered', 'acked', 'running') ORDER BY created_at DESC LIMIT 1`
+          ).get(alias, task);
+          if (match) {
+            db.run(
+              `UPDATE tasks SET status = 'replied', result = ?1, completed_at = datetime('now')
+               WHERE task_id = ?2`,
+              [result.slice(0, 4000), match.task_id]
+            );
+          }
+        }
+
+        db.run("COMMIT");
+      } catch (e) {
+        try { db.run("ROLLBACK"); } catch {}
+        throw e;
+      }
 
       return {
         content: [{ type: "text" as const, text: JSON.stringify({ ok: true, completion_id: id }) }],
@@ -154,6 +231,13 @@ export function registerTools(server: McpServer, clientIP?: string) {
           content: [{ type: "text" as const, text: JSON.stringify({ ok: false, error: "message not found or not yours" }) }],
         };
       }
+      // V2: sync tasks table — ack_inbox means delivered→acked
+      try {
+        db.run(
+          `UPDATE tasks SET status = 'acked' WHERE task_id = ?1 AND status = 'delivered'`,
+          [message_id]
+        );
+      } catch {}
       return {
         content: [{ type: "text" as const, text: JSON.stringify({ ok: true }) }],
       };
@@ -239,12 +323,24 @@ export function registerTools(server: McpServer, clientIP?: string) {
     async ({ alias, task, priority, context, from_session }) => {
       console.log(`[${ts()}] ${from_session} → send_task → ${alias}: ${task.slice(0, 60)}${priority === "high" ? " [HIGH]" : ""}`);
       const id = uuidv4();
-      // inbox.session_name stores alias
-      db.run(
-        `INSERT INTO inbox (id, session_name, type, priority, content, context, from_session)
-         VALUES (?1, ?2, 'task', ?3, ?4, ?5, ?6)`,
-        [id, alias, priority, task, context ?? null, from_session]
-      );
+      // 事务：inbox + tasks 双写
+      try {
+        db.run("BEGIN IMMEDIATE");
+        db.run(
+          `INSERT INTO inbox (id, session_name, type, priority, content, context, from_session, requires_response)
+           VALUES (?1, ?2, 'task', ?3, ?4, ?5, ?6, 'reply')`,
+          [id, alias, priority, task, context ?? null, from_session]
+        );
+        db.run(
+          `INSERT INTO tasks (task_id, from_name, to_name, priority, status, content, requires_response, created_at, delivered_at, expires_at)
+           VALUES (?1, ?2, ?3, ?4, 'delivered', ?5, 'reply', datetime('now'), datetime('now'), datetime('now', '+1 hour'))`,
+          [id, from_session, alias, priority, task]
+        );
+        db.run("COMMIT");
+      } catch (e) {
+        try { db.run("ROLLBACK"); } catch {}
+        throw e;
+      }
 
       const session = db.query<any, [string]>("SELECT status FROM sessions WHERE alias = ?1").get(alias);
 
@@ -305,6 +401,80 @@ export function registerTools(server: McpServer, clientIP?: string) {
     }
   );
 
+  // ── V2: send_reply (关联 task_id，不触发 think) ──
+  server.tool(
+    "send_reply",
+    "Send a reply to a task. Linked to task_id via in_reply_to. Does NOT trigger agent processing.",
+    {
+      alias: z.string().min(1).max(200).describe("Target session alias"),
+      text: z.string().min(1).max(10000).describe("Reply content"),
+      in_reply_to: z.string().max(200).optional().describe("Original task/message ID"),
+      status: z.enum(["replied", "failed", "cancelled"]).optional().default("replied").describe("Task outcome"),
+      from_session: z.string().max(200).optional().default("hub"),
+    },
+    async ({ alias, text, in_reply_to, status: replyStatus, from_session }) => {
+      console.log(`[${ts()}] ${from_session} → send_reply (${replyStatus}) → ${alias}: ${text.slice(0, 60)}`);
+      const id = uuidv4();
+      try {
+        db.run("BEGIN IMMEDIATE");
+        db.run(
+          `INSERT INTO inbox (id, session_name, type, priority, content, from_session, in_reply_to, requires_response)
+           VALUES (?1, ?2, 'reply', 'normal', ?3, ?4, ?5, 'none')`,
+          [id, alias, text, from_session, in_reply_to ?? null]
+        );
+
+        // 更新 tasks 表
+        if (in_reply_to) {
+          const result = db.run(
+            `UPDATE tasks SET status = ?1, result = ?2, completed_at = datetime('now')
+             WHERE task_id = ?3 AND status IN ('created', 'delivered', 'acked', 'running')`,
+            [replyStatus, text, in_reply_to]
+          );
+          if (result.changes === 0) {
+            console.log(`[${ts()}] ⚠ send_reply: task ${in_reply_to?.slice(0, 8)} not found or already terminal`);
+          }
+        }
+        db.run("COMMIT");
+      } catch (e) {
+        try { db.run("ROLLBACK"); } catch {}
+        throw e;
+      }
+
+      const session = db.query<any, [string]>("SELECT status FROM sessions WHERE alias = ?1").get(alias);
+      pushEvent(alias, { type: "new_reply", from: from_session, message_id: id, in_reply_to, status: replyStatus });
+
+      return {
+        content: [{
+          type: "text" as const,
+          text: JSON.stringify({ ok: true, message_id: id, session_status: session?.status ?? "unknown" }),
+        }],
+      };
+    }
+  );
+
+  // ── V2: send_ack (不入 inbox，仅更新状态) ──
+  server.tool(
+    "send_ack",
+    "Acknowledge receipt of a task. Does NOT enter inbox. Updates task status only.",
+    {
+      task_id: z.string().min(1).max(200).describe("Task ID to acknowledge"),
+      from_session: z.string().max(200).optional().default("hub"),
+    },
+    async ({ task_id, from_session }) => {
+      console.log(`[${ts()}] ${from_session} → send_ack → task ${task_id.slice(0, 8)}`);
+      const result = db.run(
+        `UPDATE tasks SET status = 'acked' WHERE task_id = ?1 AND status IN ('created', 'delivered')`,
+        [task_id]
+      );
+      return {
+        content: [{
+          type: "text" as const,
+          text: JSON.stringify({ ok: result.changes > 0, task_id, updated: result.changes }),
+        }],
+      };
+    }
+  );
+
   server.tool(
     "broadcast",
     "Send a message to multiple sessions.",