@sleep2agi/commhub-server 0.8.8-preview.0 → 0.8.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sleep2agi/commhub-server",
-  "version": "0.8.8-preview.0",
+  "version": "0.8.8",
   "description": "CommHub Server — AI Agent communication hub with MCP protocol, multi-network isolation, user auth, and 17 MCP tools.",
   "type": "module",
   "main": "src/index.ts",
@@ -13,7 +13,8 @@
   ],
   "scripts": {
     "start": "bun run src/index.ts",
-    "dev": "bun --watch run src/index.ts"
+    "dev": "bun --watch run src/index.ts",
+    "test": "COMMHUB_DB=/tmp/test-commhub-$$.db bun test src/"
   },
   "keywords": [
     "commhub",

package/src/db-adapter.ts

@@ -216,6 +216,25 @@ export class PgAdapter implements DbAdapter {
  * Create the appropriate adapter based on environment.
  * - DATABASE_URL starts with "postgres://" → PgAdapter
  * - Otherwise → SQLiteAdapter with COMMHUB_DB or default path
+ *
+ * Test-default-prod GUARD: when `NODE_ENV === "test"` (set automatically by
+ * `bun test`) AND `COMMHUB_DB` is unset, we REFUSE to fall through to the
+ * default `~/.commhub/commhub.db` path. Several modules (notably
+ * `server/src/auth.ts register()`) write into the configured database at
+ * import-time-side-effect granularity; running their tests against the
+ * production hub DB silently created spurious users / networks / tokens
+ * on 2026-06-23 (4u / 4net / 8tok by one `bun -e` probe + an unknown
+ * pre-existing history of test pollution in the same DB). The guard makes
+ * the failure mode loud + actionable instead of silent + destructive.
+ *
+ * The guard does NOT fire when:
+ *   - COMMHUB_DB is set (the test runner's documented contract); or
+ *   - NODE_ENV is unset (production server) or any non-"test" value.
+ *
+ * Operators who run `bun -e` snippets that touch the DB are expected to
+ * `COMMHUB_DB=/tmp/...` themselves — `bun -e` doesn't set NODE_ENV, so the
+ * guard can't catch that case. The rule is documented in CLAUDE.md /
+ * memory ([[feedback_no_prod_db_access.md]]).
  */
 export function createAdapter(): DbAdapter {
   const dbUrl = process.env.DATABASE_URL;
@@ -226,6 +245,18 @@ export function createAdapter(): DbAdapter {
   // Default: SQLite
   const { mkdirSync } = require("fs");
   const { dirname } = require("path");
+
+  // Test-default-prod GUARD (see docblock above).
+  if (process.env.NODE_ENV === "test" && !process.env.COMMHUB_DB) {
+    throw new Error(
+      "[commhub] REFUSING to open the default SQLite database under NODE_ENV=test.\n" +
+      "  Tests must explicitly set COMMHUB_DB to a throwaway path so they don't\n" +
+      "  pollute the production hub DB. Run tests via:\n" +
+      "    COMMHUB_DB=/tmp/test-$$.db bun test src/\n" +
+      "  (or use the `npm run test` script which sets this for you)."
+    );
+  }
+
   const dbPath = process.env.COMMHUB_DB || `${process.env.HOME}/.commhub/commhub.db`;
   mkdirSync(dirname(dbPath), { recursive: true });
   console.log(`[commhub] database: ${dbPath}`);

package/src/push.ts

@@ -7,6 +7,10 @@ import { eventBus, type RenameCommittedEvent } from "./event_bus";
 type SSEClient = {
   controller: ReadableStreamDefaultController;
   encoder: TextEncoder;
+  // 30s keepalive interval — stored so cancel() can clear it without
+  // relying on stringly-typed any-cast. Set in start(), cleared in cancel()
+  // or by the interval itself on enqueue failure.
+  keepalive?: ReturnType<typeof setInterval>;
 };
 
 // 一个 session 可能有多个 SSE 连接（重连时短暂并存）
@@ -44,7 +48,7 @@ export function createSSEStream(sessionName: string, networkId?: string | null):
           clearInterval(keepalive);
         }
       }, 30_000);
-      (client as any)._keepalive = keepalive;
+      client.keepalive = keepalive;
     },
     cancel() {
       // 断线清理
@@ -52,7 +56,7 @@ export function createSSEStream(sessionName: string, networkId?: string | null):
       if (arr) {
         const idx = arr.findIndex(c => c.controller === ctrl);
         if (idx !== -1) {
-          clearInterval((arr[idx] as any)._keepalive);
+          if (arr[idx].keepalive) clearInterval(arr[idx].keepalive);
           arr.splice(idx, 1);
         }
         if (arr.length === 0) clients.delete(key);
@@ -98,7 +102,12 @@ eventBus.on("rename-committed", (event: RenameCommittedEvent) => {
 
 /** 推送事件给指定 session 的所有 SSE 连接 */
 export function pushEvent(sessionName: string, event: Record<string, unknown>, networkId?: string | null): void {
-  const arr = clients.get(clientKey(sessionName, networkId ?? (event.network_id as string | null | undefined)));
+  // Resolve the key once — both lookup and post-cleanup `clients.delete` MUST
+  // use the same key, otherwise an emptied bucket would leak (the explicit
+  // arg wins over event.network_id, falling back so legacy callers that pass
+  // network_id inside `event` still hit the right bucket).
+  const key = clientKey(sessionName, networkId ?? (event.network_id as string | null | undefined));
+  const arr = clients.get(key);
   if (!arr || arr.length === 0) return;
 
   const data = `data: ${JSON.stringify(event)}\n\n`;
@@ -112,11 +121,16 @@ export function pushEvent(sessionName: string, event: Record<string, unknown>, n
     }
   }
 
-  // 清理死连接
+  // 清理死连接 — also clear their keepalive timers so the dead client doesn't
+  // keep an interval handle alive past its controller (small leak previously
+  // bounded by the next failed enqueue catching itself, but cleanup-on-detect
+  // is cheaper than waiting 30s).
   for (let i = dead.length - 1; i >= 0; i--) {
+    const c = arr[dead[i]];
+    if (c.keepalive) clearInterval(c.keepalive);
     arr.splice(dead[i], 1);
   }
-  if (arr.length === 0) clients.delete(clientKey(sessionName, networkId ?? (event.network_id as string | null | undefined)));
+  if (arr.length === 0) clients.delete(key);
 }
 
 export function __resetSSEClientsForTest(): void {

package/src/send_dedup.test.ts

@@ -117,6 +117,24 @@ describe("SendDedup", () => {
     expect(d.size).toBeGreaterThan(0);
   });
 
+  it("evictOldest drops to exactly floor(maxKeys * 0.9) on the first trigger", () => {
+    // Regression guard for the size-during-loop bug fixed in the
+    // robustness pass. Insert exactly maxKeys+1 records to fire exactly
+    // ONE evictOldest call, then snapshot size before any further inserts
+    // can re-grow it. With the bug, the loop bound
+    // `i < this.last.size - target` shrunk each iteration and only
+    // ~half the intended deletions ran (e.g. 14 of 27 for maxKeys=256,
+    // landing size at ~243 instead of 230). After the fix size lands at
+    // the documented target = floor(maxKeys * 0.9).
+    const maxKeys = 256;
+    const target = Math.floor(maxKeys * 0.9); // 230
+    const d = new SendDedup({ windowMs: 600_000, maxKeys });
+    for (let i = 0; i <= maxKeys; i++) {
+      d.record(`from-${i}`, "bob", `content-${i}`, 1_000 + i);
+    }
+    expect(d.size).toBe(target);
+  });
+
   it("hashes content rather than holding the raw bytes", () => {
     // The key function is the public surface that proves we don't keep
     // raw content in memory between sends — the map keys themselves are

package/src/send_dedup.ts

@@ -44,13 +44,20 @@ export type DedupConfig = {
 };
 
 export function readDedupConfig(env: NodeJS.ProcessEnv = process.env): DedupConfig {
-  const rawWindow = env.COMMHUB_SEND_DEDUP_WINDOW_MS;
-  const windowMs = rawWindow !== undefined ? Math.max(0, Number(rawWindow)) : 300_000;
-  const rawMax = env.COMMHUB_SEND_DEDUP_MAX_KEYS;
-  const maxKeys = rawMax !== undefined ? Math.max(64, Number(rawMax)) : 4096;
+  // Parse-then-validate-then-clamp: `Number("abc")` is NaN and `Math.max(0, NaN)`
+  // is ALSO NaN per spec, so the old inline `Math.max(0, Number(rawWindow))`
+  // relied on the later `Number.isFinite` fallback to repair the result.
+  // Hoisting the validity check first makes the intent explicit and removes
+  // the risk that a future refactor drops the `isFinite` rescue.
+  const parseClamped = (raw: string | undefined, min: number, fallback: number): number => {
+    if (raw === undefined) return fallback;
+    const n = Number(raw);
+    if (!Number.isFinite(n)) return fallback;
+    return Math.max(min, n);
+  };
   return {
-    windowMs: Number.isFinite(windowMs) ? windowMs : 300_000,
-    maxKeys: Number.isFinite(maxKeys) ? maxKeys : 4096,
+    windowMs: parseClamped(env.COMMHUB_SEND_DEDUP_WINDOW_MS, 0, 300_000),
+    maxKeys: parseClamped(env.COMMHUB_SEND_DEDUP_MAX_KEYS, 64, 4096),
   };
 }
 
@@ -133,8 +140,16 @@ export class SendDedup {
   private evictOldest(): void {
     const target = Math.max(64, Math.floor(this.cfg.maxKeys * 0.9));
     if (this.last.size <= target) return;
+    // CACHE toDelete BEFORE the deletion loop. Previously the loop bound
+    // was `i < this.last.size - target`, which is re-evaluated every
+    // iteration — and `this.last.size` shrinks by 1 per delete. The result
+    // was that we only evicted ~half of the intended count (size landed
+    // around 95 % of maxKeys instead of the documented ~90 %). The map
+    // stayed bounded so this was efficiency-only, not a leak, but the
+    // documented contract was being violated.
+    const toDelete = this.last.size - target;
     const entries = Array.from(this.last.entries()).sort((a, b) => a[1] - b[1]);
-    for (let i = 0; i < this.last.size - target; i++) this.last.delete(entries[i][0]);
+    for (let i = 0; i < toDelete; i++) this.last.delete(entries[i][0]);
   }
 }
 

package/src/uploads.test.ts

@@ -187,6 +187,26 @@ describe("UploadRateLimiter", () => {
     }
     expect(lim.check("token-y", 1000).allowed).toBe(false);
   });
+
+  test("caps in-memory state by evicting oldest entries past maxEntries", () => {
+    // A small maxEntries lets us drive the eviction path deterministically.
+    // Without this cap the limiter would grow unbounded under an IP-flood
+    // (public-facing hub, IPv6 rotation makes each request a "new" key).
+    const lim = new UploadRateLimiter(60_000, 5, 4);
+    const t0 = 1_700_000_000_000;
+    // Fill to cap with non-expired entries — eviction should fire on insert 5.
+    for (let i = 0; i < 4; i++) {
+      lim.check(`key-${i}`, t0);
+    }
+    expect(lim.size()).toBe(4);
+    lim.check("key-new", t0 + 100);
+    expect(lim.size()).toBeLessThanOrEqual(4);
+    // Hitting an EXISTING key while at cap must NOT trigger an eviction
+    // (an attacker hitting the same key shouldn't push out other callers).
+    const beforeSize = lim.size();
+    lim.check("key-new", t0 + 200);
+    expect(lim.size()).toBe(beforeSize);
+  });
 });
 
 describe("validateAttachments", () => {

package/src/uploads.ts

@@ -37,6 +37,12 @@ export const MAX_REQUEST_CONTENT_LENGTH = MAX_UPLOAD_BYTES + 1024 * 1024;
 // the source of truth; resets on restart).
 export const UPLOAD_RATE_WINDOW_MS = 60 * 60 * 1000;
 export const UPLOAD_RATE_MAX_PER_WINDOW = 60;
+// Cap the in-memory rate-limit map so a public-facing hub can't be
+// pushed to OOM by a flood of unique IPs / token ids (the call site
+// uses IP-as-key for legacy auth, which is rotatable cheaply over IPv6).
+// Matches LOGIN_GUARD_MAX_ENTRIES in auth_login_guard.ts for symmetric
+// behaviour across the two in-memory limiters this hub maintains.
+export const UPLOAD_RATE_MAX_ENTRIES = 50_000;
 
 // Strict file_id regex. Generated server-side via crypto.randomUUID()
 // with hyphens stripped, so the natural output is 32 hex chars. The
@@ -159,6 +165,7 @@ export class UploadRateLimiter {
   constructor(
     private readonly windowMs: number = UPLOAD_RATE_WINDOW_MS,
     private readonly maxPerWindow: number = UPLOAD_RATE_MAX_PER_WINDOW,
+    private readonly maxEntries: number = UPLOAD_RATE_MAX_ENTRIES,
   ) {}
 
   /**
@@ -169,6 +176,14 @@ export class UploadRateLimiter {
    * Window is rolling on first touch (not aligned to wall-clock hours).
    */
   check(key: string, nowMs: number = Date.now()): { allowed: boolean; remaining: number; resetAt: number; retryAfterMs?: number } {
+    // Before inserting a brand-new key into a full map, sweep expired
+    // entries and (if still over cap) evict the oldest by insertion order.
+    // Existing-key updates skip the eviction path so an attacker who
+    // keeps hitting the same key can't push out other callers.
+    if (this.state.size >= this.maxEntries && !this.state.has(key)) {
+      this.pruneExpired(nowMs);
+      this.evictOldestUntilBelowCap();
+    }
     const entry = this.state.get(key);
     if (!entry || nowMs >= entry.resetAt) {
       const resetAt = nowMs + this.windowMs;
@@ -191,6 +206,20 @@ export class UploadRateLimiter {
   size(): number {
     return this.state.size;
   }
+
+  private pruneExpired(nowMs: number): void {
+    for (const [key, entry] of this.state) {
+      if (nowMs >= entry.resetAt) this.state.delete(key);
+    }
+  }
+
+  private evictOldestUntilBelowCap(): void {
+    while (this.state.size >= this.maxEntries) {
+      const oldest = this.state.keys().next().value as string | undefined;
+      if (!oldest) return;
+      this.state.delete(oldest);
+    }
+  }
 }
 
 /** Module-level singleton shared by the HTTP /api/upload handler. */