@sleep2agi/commhub-server 0.9.0-preview.100 → 0.9.0-preview.102

package/src/task-queue-ahead-scale.test.ts

@@ -9,9 +9,9 @@
 //      the whole-table one is driven by the covering idx_tasks_created_queue (no task-row lookups), the alias list
 //      and the per-send count by idx_tasks_to_created;
 //   2. the cost, relative only (no absolute ms, so a slow runner can't fail it): the queue_depth statement is at most
-//      half the #2325 statement measured on the same DB in the same loop, and a full /api/status read (cache
-//      bypassed) with queue_depth is at most 50 % slower than the same read with it switched off (= the pre-#2325
-//      read), alternated request by request on the same server;
+//      half the #2325 statement measured on the same DB in the same loop; and, on the low percentile of alternated
+//      samples (#517), the statement costs at most half a full /api/status read (cache bypassed) without it, and that
+//      read with queue_depth is at most 50 % slower than with it switched off (= the pre-#2325 read);
 //   3. the counts are still right at that scale (stale `acked` rows are outside the 24 h window).
 //
 // 跑法:cd server && COMMHUB_DB=/tmp/x.db bun test src/task-queue-ahead-scale.test.ts
@@ -35,6 +35,8 @@ const RECENT = 1_900;         // created in the last 24 h
 const OPEN_EVERY = 30;        // 3 in every OPEN_EVERY recent tasks are still open (~190 of 1.9k; see the cost test)
 const HOT = "scale-node-7";   // most stuck rows land on this one (the per-send plan must not care)
 const N = 25;
+/** #517: A/B pairs per pass, the percentile compared, and how many extra passes a failing pass gets. */
+const AB_PAIRS = 60, LOW_P = 0.2, RETRIES = 2;
 /** The #2325 statement (bare columns): the in-test baseline the fixed query is measured against. */
 const SQL_2325 = `SELECT network_id, to_name, COUNT(*) AS n FROM tasks
   WHERE status IN ('created', 'delivered', 'acked', 'running') AND created_at >= datetime('now', '-86400 seconds')
@@ -170,34 +172,56 @@ describe.skipIf(PG)("#500 queue_depth at production scale (57k tasks, 31k stuck
       s0 = performance.now(); db.all(SQL_2325); const b = performance.now() - s0;
       if (i >= 3) { fixed.push(a); old.push(b); }
     }
-    // Full /api/status, cache bypassed, A/B request by request: queue_depth on vs off (off = the pre-#2325 read).
-    // Alternating (and flipping the order every iteration) keeps both arms in the same time window — the first
-    // version of this budget timed the statement and the read in separate loops and compared them, which a busy
-    // runner (test638 runs two aggregates at once) skews: CI saw 2.10 ms vs a 5.25 ms read and failed.
+    // Measured locally (this fixture, covering index): ≈ 0.15× (1.0 vs 6.5 ms); on the production copy 0.3 vs 55 ms.
+    const qP50 = pct(fixed, 0.5), oldP50 = pct(old, 0.5);
+    console.log(`[perf] queue_depth p50=${qP50.toFixed(2)}ms vs #2325 statement p50=${oldP50.toFixed(2)}ms`);
+    expect(qP50).toBeLessThanOrEqual(0.5 * oldP50);
+
+    // Second budget: queue_depth adds at most +50 % to a full /api/status read (cache bypassed) — the same read
+    // with it switched off is the pre-#2325 read. #517: the first version compared the p50 of `with` and `without`
+    // on a ~4 ms read and asserted the *difference*; under test638's concurrent aggregates a difference of two
+    // noisy p50s is mostly noise (CI #2355: statement 0.64 ms, yet with−without = 2.4 ms > 2.03 ms budget). Now:
+    //   - each pass alternates A/B request by request (order flipped every pair) and also times the bare
+    //     queue_depth statement between the reads, so all three series share one time window;
+    //   - it compares a low percentile (LOW_P) rather than the p50: scheduler noise only ever adds time, so the
+    //     lower tail is the closest a busy runner gets to the real cost;
+    //   - it asserts both what the comment claims — the statement's own cost ≤ 50 % of the read without it — and
+    //     the end-to-end with/without delta on the same low percentile;
+    //   - a failing pass is re-measured up to RETRIES more times; the real regression (the #2325 statement through
+    //     idx_tasks_status, 5–8× the fixed cost) fails every pass, noise does not.
     const cache = await import("./status-read-cache.js");
     cache.__setStatusCacheBypassForTest(true);
-    const on: number[] = [], off: number[] = [];
     const readOnce = async (depthOn: boolean) => {
       mod.__setQueueDepthOffForTest(!depthOn);
       const s0 = performance.now();
       await (await fetch(`${BASE}/api/status?network_id=${NET}`, { headers: { Authorization: `Bearer ${token}` } })).text();
       return performance.now() - s0;
     };
-    try {
-      for (let i = 0; i < 2 * N + 3; i++) {
+    const abPass = async () => {
+      const on: number[] = [], off: number[] = [], q: number[] = [];
+      for (let i = 0; i < AB_PAIRS + 3; i++) {
         const first = i % 2 === 0;
         const a = await readOnce(first), b = await readOnce(!first);
-        if (i >= 3) { (first ? on : off).push(a); (first ? off : on).push(b); }
+        mod.__setQueueDepthOffForTest(false);
+        const s0 = performance.now(); mod.queueDepthByNode(); const c = performance.now() - s0;
+        if (i >= 3) { (first ? on : off).push(a); (first ? off : on).push(b); q.push(c); }
+      }
+      const onLow = pct(on, LOW_P), offLow = pct(off, LOW_P), qLow = pct(q, LOW_P);
+      return { onLow, offLow, qLow, onP50: pct(on, 0.5), offP50: pct(off, 0.5),
+        okDirect: qLow <= 0.5 * offLow, okRead: onLow - offLow <= 0.5 * offLow };
+    };
+    let r: Awaited<ReturnType<typeof abPass>> | null = null;
+    try {
+      for (let attempt = 0; attempt <= RETRIES; attempt++) {
+        r = await abPass();
+        console.log(`[perf] pass ${attempt + 1}: p${LOW_P * 100} queue_depth=${r.qLow.toFixed(2)}ms; full /api/status (bypass) p${LOW_P * 100} with=${r.onLow.toFixed(2)}ms without=${r.offLow.toFixed(2)}ms (+${(100 * (r.onLow - r.offLow) / r.offLow).toFixed(0)}%); p50 with=${r.onP50.toFixed(2)}ms without=${r.offP50.toFixed(2)}ms; direct ${r.okDirect ? "ok" : "OVER"} read ${r.okRead ? "ok" : "OVER"}`);
+        if (r.okDirect && r.okRead) break;
       }
     } finally {
       mod.__setQueueDepthOffForTest(false);
       cache.__setStatusCacheBypassForTest(false);
     }
-    const qP50 = pct(fixed, 0.5), oldP50 = pct(old, 0.5), onP50 = pct(on, 0.5), offP50 = pct(off, 0.5);
-    console.log(`[perf] queue_depth p50=${qP50.toFixed(2)}ms vs #2325 statement p50=${oldP50.toFixed(2)}ms; full /api/status (bypass) p50 with=${onP50.toFixed(2)}ms without=${offP50.toFixed(2)}ms (+${(100 * (onP50 - offP50) / offP50).toFixed(0)}%) p90 with=${pct(on, 0.9).toFixed(2)}ms`);
-    // Measured locally (this fixture, covering index): ≈ 0.15× (1.0 vs 6.5 ms); on the production copy 0.3 vs 55 ms.
-    expect(qP50).toBeLessThanOrEqual(0.5 * oldP50);
-    // Why the budget is "vs the same read without queue_depth", and what it was measured at (2026-10-04):
+    // What the read budget was measured at (2026-10-04, p50s, before #517):
     //   production copy (VACUUM INTO of the live DB: 306 sessions, 57k tasks, 64 open in the last 24 h on 4 nodes),
     //   full /api/status p50, cache bypassed, 3 runs each —
     //     pre-#2325 10.5–11.3 ms · #2325 68–71 ms · first fix (idx_tasks_created + row lookups) 16.1–17.1 ms (+50 %,
@@ -205,7 +229,8 @@ describe.skipIf(PG)("#500 queue_depth at production scale (57k tasks, 31k stuck
     //   this fixture: +17–31 %. It is harsher than production: ~190 open tasks in the window spread over ~150 nodes
     //   (3× production's open count, ~38× its groups) and one-word session rows that make the rest of the read cheap.
     //   With the original 1-in-7 open share (813 open) it measured +55–62 % even with the covering index — the
-    //   GROUP BY over 300 groups, not the index. CI's 67 % (before the covering index) is consistent with that plus the separate-loop skew above.
-    expect(onP50 - offP50).toBeLessThanOrEqual(0.5 * offP50);
-  }, 60_000);
+    //   GROUP BY over 300 groups, not the index.
+    expect(r!.qLow).toBeLessThanOrEqual(0.5 * r!.offLow);
+    expect(r!.onLow - r!.offLow).toBeLessThanOrEqual(0.5 * r!.offLow);
+  }, 120_000);
 });

package/src/task-rejection-log-http.test.ts

@@ -0,0 +1,160 @@
+// #552 — every rejected REST POST /api/task leaves exactly one hub log line.
+//
+// Incident: a restricted member's app sends were refused and the hub log
+// showed nothing, so "never arrived" and "rejected" were indistinguishable.
+// Real Bun.serve on a private port + temp DB; console.log is captured around
+// each request. The line must carry status + error + user + requested
+// alias/network/client_request_id, and must NOT carry the bearer token or the
+// task text.
+
+import { describe, expect, test, beforeAll, afterAll } from "bun:test";
+import { mkdtempSync, rmSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import { register } from "./auth.js";
+import { db } from "./db.js";
+import { formatTaskRejection } from "./task-rejection-log.js";
+
+const DIR = mkdtempSync(join(tmpdir(), "anet-task-reject-log-"));
+let BASE = "";
+let hub: any = null;
+const PW = "RejectLogPassw0rd!x";
+let adminToken = "";
+let adminName = "";
+let NET = "";
+let aliceToken = "";
+const AGENT = { alias: "rejlog-agent", node: "node_rejlog" };
+const SECRET_TEXT = "TOP-SECRET-TASK-BODY-552";
+
+async function postTask(token: string | null, body: string): Promise<{ status: number; json: any; lines: string[] }> {
+  const lines: string[] = [];
+  const orig = console.log;
+  console.log = (...args: any[]) => { lines.push(args.map(String).join(" ")); };
+  try {
+    const headers: Record<string, string> = { "Content-Type": "application/json" };
+    if (token) headers.Authorization = `Bearer ${token}`;
+    const res = await fetch(`${BASE}/api/task`, { method: "POST", headers, body });
+    const text = await res.text();
+    let json: any = text;
+    try { json = JSON.parse(text); } catch {}
+    return { status: res.status, json, lines };
+  } finally {
+    console.log = orig;
+  }
+}
+const rejectedLines = (lines: string[]) => lines.filter(l => l.includes("→ /api/task →") && l.includes("REJECTED"));
+
+beforeAll(async () => {
+  process.env.COMMHUB_DB ||= join(DIR, "hub.db");
+  process.env.COMMHUB_UPLOADS_DIR = join(DIR, "uploads");
+  process.env.HOST = "127.0.0.1";
+
+  const admin = register(`rejlog_admin_${Date.now()}`, PW, undefined, "Admin");
+  expect(admin.ok).toBe(true);
+  adminToken = admin.token!;
+  adminName = admin.user!.username;
+  NET = admin.network_id!;
+  db.run("UPDATE users SET role = 'admin' WHERE user_id = ?1", [admin.user!.user_id]);
+  db.run(
+    `INSERT INTO nodes (node_id, node_name, alias, network_id, owner_user_id, updated_at) VALUES (?1, ?2, ?2, ?3, ?4, datetime('now'))`,
+    [AGENT.node, AGENT.alias, NET, admin.user!.user_id],
+  );
+  db.run(
+    `INSERT INTO sessions (resume_id, alias, node_id, status, network_id, updated_at, last_seen_at)
+     VALUES (?1, ?2, ?3, 'idle', ?4, datetime('now'), datetime('now'))`,
+    [`resume_${AGENT.node}`, AGENT.alias, AGENT.node, NET],
+  );
+
+  const mod: any = await import("./server.js");
+  hub = mod.bootServer({ port: 0, hostname: "127.0.0.1" });
+  BASE = `http://127.0.0.1:${hub.port}`;
+
+  // A restricted member (default agent_access='granted', zero grants) who also
+  // owns a personal network → two memberships, like the #552 app user.
+  const created = await fetch(`${BASE}/api/admin/users`, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${adminToken}`, "Content-Type": "application/json" },
+    body: JSON.stringify({ username: "rejlog_alice", password: PW, network_id: NET, role: "member" }),
+  });
+  expect(created.status).toBe(200);
+  const login = await fetch(`${BASE}/api/auth/login`, {
+    method: "POST", headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ username: "rejlog_alice", password: PW }),
+  });
+  expect(login.status).toBe(200);
+  aliceToken = (await login.json() as any).token;
+}, 30_000);
+
+afterAll(() => {
+  try { hub?.stop?.(true); } catch {}
+  try { rmSync(DIR, { recursive: true, force: true }); } catch {}
+});
+
+function assertNoSecrets(line: string, token: string) {
+  expect(line).not.toContain(token);
+  expect(line).not.toContain(SECRET_TEXT);
+  expect(line).not.toContain("file_");
+}
+
+describe("#552 REST POST /api/task rejections are logged", () => {
+  test("alias_not_found (404): one line with status, error, user, alias, network, client_request_id", async () => {
+    const r = await postTask(adminToken, JSON.stringify({ alias: "no-such-agent", task: SECRET_TEXT, network_id: NET, meta: { client_request_id: "crid-552-a" } }));
+    expect(r.status).toBe(404);
+    expect(r.json.error).toBe("alias_not_found");
+    const lines = rejectedLines(r.lines);
+    expect(lines.length).toBe(1);
+    expect(lines[0]).toMatch(/^\[\d\d:\d\d:\d\d\] /);
+    expect(lines[0]).toContain(`${adminName} → /api/task → no-such-agent: REJECTED 404 alias_not_found`);
+    expect(lines[0]).toContain(`net=${NET}`);
+    expect(lines[0]).toContain("crid=crid-552-a");
+    assertNoSecrets(lines[0], adminToken);
+  });
+
+  test("network_id_required (400) for a member of two networks who omits network_id", async () => {
+    const r = await postTask(aliceToken, JSON.stringify({ alias: AGENT.alias, task: SECRET_TEXT }));
+    expect(r.status).toBe(400);
+    expect(r.json.error).toBe("network_id_required");
+    const lines = rejectedLines(r.lines);
+    expect(lines.length).toBe(1);
+    expect(lines[0]).toContain(`rejlog_alice → /api/task → ${AGENT.alias}: REJECTED 400 network_id_required (net=-)`);
+    assertNoSecrets(lines[0], aliceToken);
+  });
+
+  test("agent_not_granted (403) — the restricted-member case from #552", async () => {
+    const r = await postTask(aliceToken, JSON.stringify({ alias: AGENT.alias, task: SECRET_TEXT, network_id: NET, attachments: [{ file_id: "file_deadbeef" }] }));
+    expect(r.status).toBe(403);
+    expect(r.json.error).toBe("agent_not_granted");
+    const lines = rejectedLines(r.lines);
+    expect(lines.length).toBe(1);
+    expect(lines[0]).toContain(`rejlog_alice → /api/task → ${AGENT.alias}: REJECTED 403 agent_not_granted (net=${NET})`);
+    assertNoSecrets(lines[0], aliceToken);
+  });
+
+  test("invalid JSON (400) is logged with the user and '-' placeholders", async () => {
+    const r = await postTask(aliceToken, "{not json");
+    expect(r.status).toBe(400);
+    const lines = rejectedLines(r.lines);
+    expect(lines.length).toBe(1);
+    expect(lines[0]).toContain("rejlog_alice → /api/task → -: REJECTED 400 invalid JSON (net=-)");
+  });
+
+  test("a successful send logs no REJECTED line", async () => {
+    const r = await postTask(adminToken, JSON.stringify({ alias: AGENT.alias, task: "hello", network_id: NET }));
+    expect(r.status).toBe(200);
+    expect(rejectedLines(r.lines).length).toBe(0);
+  });
+});
+
+describe("formatTaskRejection", () => {
+  test("request-supplied values cannot inject extra log lines and are clipped", () => {
+    const line = formatTaskRejection({
+      status: 404, error: "alias_not_found", username: null,
+      body: { alias: "evil\n[00:00:00] admin → forged", network_id: "n".repeat(200), meta: { client_request_id: "x\r\ny" } },
+    });
+    expect(line).not.toContain("\n");
+    expect(line).not.toContain("\r");
+    expect(line).toContain("anon → /api/task → evil [00:00:00] admin → forged: REJECTED 404 alias_not_found");
+    expect(line).toContain(`net=${"n".repeat(64)}…`);
+    expect(line).toContain("crid=x y");
+  });
+});

package/src/task-rejection-log.ts

@@ -0,0 +1,49 @@
+// #552 — one log line for every non-2xx answer from REST POST /api/task.
+//
+// A restricted member's app sends were rejected and the hub log showed
+// nothing, so "the request never arrived" and "the hub refused it" looked
+// identical from the server side. Every rejection branch now goes through
+// logTaskRejection().
+//
+// What is logged is deliberately narrow: status, error code, the
+// authenticated username, and the *requested* alias / network_id /
+// client_request_id. Never the bearer token, the task text, or attachment
+// ids. Request-supplied values are clipped and stripped of control
+// characters so a client cannot forge extra log lines.
+
+function ts(): string {
+  return new Date().toTimeString().slice(0, 8);
+}
+
+function clip(value: unknown, max = 64): string {
+  if (typeof value !== "string" || !value) return "-";
+  const clean = value.replace(/[\u0000-\u001f\u007f\s]+/g, " ").trim();
+  if (!clean) return "-";
+  return clean.length > max ? `${clean.slice(0, max)}…` : clean;
+}
+
+export interface TaskRejectionContext {
+  status: number;
+  error: unknown;
+  username: string | null | undefined;
+  /** The raw request body (or null when it did not parse). Only alias, network_id and meta.client_request_id are read. */
+  body: unknown;
+}
+
+export function formatTaskRejection(ctx: TaskRejectionContext): string {
+  const b = ctx.body && typeof ctx.body === "object" ? (ctx.body as Record<string, any>) : {};
+  const meta = b.meta && typeof b.meta === "object" ? b.meta : {};
+  const crid = typeof meta.client_request_id === "string" ? ` crid=${clip(meta.client_request_id)}` : "";
+  return `[${ts()}] ${clip(ctx.username ?? "anon")} → /api/task → ${clip(b.alias)}: REJECTED ${ctx.status} ${clip(ctx.error)} (net=${clip(b.network_id)}${crid})`;
+}
+
+/** Logs one line for a non-2xx response and returns the response unchanged. */
+export async function logTaskRejection(res: Response, username: string | null | undefined, body: unknown): Promise<Response> {
+  if (res.status >= 200 && res.status < 300) return res;
+  let error: unknown = null;
+  try {
+    error = ((await res.clone().json()) as any)?.error;
+  } catch {}
+  console.log(formatTaskRejection({ status: res.status, error: error ?? "unknown", username: username || "anon", body }));
+  return res;
+}

package/src/tools.ts

@@ -1034,7 +1034,8 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
           `SELECT tmux_name, server, ip, hostname, agent, project_dir, version, node_id, session_id, config_path,
                   channels, model, cpu_load_1min, cpu_cores, mem_total_gb, mem_used_gb, mem_avail_gb, disk_total_gb,
                   disk_used_gb, disk_avail_gb, process_rss_bytes, process_rss_mb, process_cpu_pct,
-                  process_uptime_seconds, process_in_flight_count, external_schedules, registered_at
+                  process_uptime_seconds, process_in_flight_count, external_schedules, registered_at,
+                  rules_file_capable, skills_capable, files_capable, logs_capable
              FROM sessions WHERE alias = ?1 AND resume_id != ?2 AND network_id = ?3
              ORDER BY updated_at DESC LIMIT 1`,
           effectiveAlias, resume_id, sessionNetId,
@@ -1104,6 +1105,26 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
              handover.registered_at ?? null],
           );
         }
+        // #550 — the sticky capability flags survive a session handover. The
+        // DELETE+INSERT above starts the new resume_id row at the column default
+        // (0), so a node whose MCP channel reconnected under a new resume_id lost
+        // its rules-file / skills / files / logs doorbell until it next reported
+        // the flag (board #548). Carry each flag that was 1 on the replaced row —
+        // only-ever-set-to-1, and under the same binding as setting it: a node
+        // token bound to this alias. Fixed statement, every parameter used (PG).
+        if (handover && callerTokenIsNetwork && callerAlias && callerAlias === effectiveAlias) {
+          db.run(
+            `UPDATE sessions SET
+               rules_file_capable = CASE WHEN ?2 = 1 THEN 1 ELSE rules_file_capable END,
+               skills_capable = CASE WHEN ?3 = 1 THEN 1 ELSE skills_capable END,
+               files_capable = CASE WHEN ?4 = 1 THEN 1 ELSE files_capable END,
+               logs_capable = CASE WHEN ?5 = 1 THEN 1 ELSE logs_capable END
+             WHERE resume_id = ?1`,
+            [resume_id,
+             Number(handover.rules_file_capable) === 1 ? 1 : 0, Number(handover.skills_capable) === 1 ? 1 : 0,
+             Number(handover.files_capable) === 1 ? 1 : 0, Number(handover.logs_capable) === 1 ? 1 : 0],
+          );
+        }
         // app#225 follow-up — separate statement on purpose: the INSERT above is
         // byte-pinned by test698's mutation harness. Sticky: only ever set to 1,
         // and only by a node token bound to this alias (a user token or another