@sleep2agi/commhub-server 0.4.3 → 0.5.0-preview.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sleep2agi/commhub-server",
-  "version": "0.4.3",
+  "version": "0.5.0-preview.1",
   "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,63 @@ 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);
+`);
+
 // Helpers
 export function uuidv4(): string {
   return crypto.randomUUID();

package/src/index.ts

@@ -34,6 +34,7 @@ const TaskSchema = z.object({
   alias: z.string().min(1).max(200),
   task: z.string().min(1).max(10000),
   priority: z.enum(["high", "normal", "low"]).default("normal"),
+  from: z.string().max(200).optional(),
 });
 
 const BroadcastSchema = z.object({
@@ -73,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)
@@ -87,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({
@@ -159,16 +177,17 @@ Bun.serve({
       }
       const body = parsed.data;
       const id = crypto.randomUUID();
+      const fromSession = body.from || "api";
       db.run(
         `INSERT INTO inbox (id, session_name, type, priority, content, from_session)
-         VALUES (?1, ?2, 'task', ?3, ?4, 'api')`,
-        [id, body.alias, body.priority, body.task]
+         VALUES (?1, ?2, 'task', ?3, ?4, ?5)`,
+        [id, body.alias, body.priority, body.task, fromSession]
       );
       // SSE push: 秒达
       const pending = db.query<{ cnt: number }, [string]>(
         "SELECT COUNT(*) as cnt FROM inbox WHERE session_name = ?1 AND acked = 0"
       ).get(body.alias);
-      pushEvent(body.alias, { type: "new_task", inbox_count: pending?.cnt ?? 1, priority: body.priority });
+      pushEvent(body.alias, { type: "new_task", inbox_count: pending?.cnt ?? 1, priority: body.priority, from: fromSession });
       return withCors(req, Response.json({ ok: true, message_id: id }));
     }
 
@@ -262,6 +281,27 @@ Bun.serve({
       return withCors(req, Response.json({ ok: true, messages: rows }));
     }
 
+    // ── 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();
@@ -278,6 +318,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,60 @@ 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"),
     },
-    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 }) => {
       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;
+      }
 
-      db.run("COMMIT");
+      // 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 {}
+      }
 
       // inbox uses alias for routing
       const row = db.query<{ cnt: number }, [string]>(
@@ -95,17 +119,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 +207,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 +299,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 +377,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.",