@sleep2agi/commhub-server 0.9.0-preview.13 → 0.9.0-preview.130

package/src/dashboard-slash-routing-http.test.ts

@@ -0,0 +1,107 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import { isInteractiveDashboardTask } from "../../agent-node/src/inbox-dispatch";
+import { shouldCreateScheduledGoal } from "../../agent-node/src/goals/routing";
+import { createNetworkTokenForNode, register } from "./auth.js";
+import { db } from "./db.js";
+
+const PRIVATE_DB_DIR = mkdtempSync(join(tmpdir(), "anet-dashboard-slash-http-"));
+const TARGET = `dashboard-slash-target-${process.pid}`;
+const TARGET_NODE_ID = `node_dashboard_slash_target_${process.pid}`;
+const TARGET_RESUME_ID = `resume_dashboard_slash_target_${process.pid}`;
+let server: any;
+let base = "";
+let userToken = "";
+let nodeToken = "";
+let networkId = "";
+let requestSequence = 0;
+
+// 30s 而不是 bun 默认的 5s:这个 hook 跑 register()(KDF)+bootServer(),
+// 本机空载基线 ~620ms,而 2026-08-17 与 2026-08-31 两次 CI 上它被 5s 上限打死
+// (0 pass / 1 fail / Ran 1 test —— 见 #928、#1627)。5247ms 是**被截断的下界**,
+// 不是测量值,所以余量按基线的 ~48x 取,而不是按那个数取。
+beforeAll(async () => {
+  process.env.COMMHUB_DB = process.env.COMMHUB_DB || join(PRIVATE_DB_DIR, "hub.db");
+  const username = `dashboard_slash_${Date.now()}`;
+  const registered = register(username, "DashboardSlash123!", undefined, "seed");
+  expect(registered.ok).toBe(true);
+  userToken = registered.token!;
+  networkId = registered.network_id!;
+  const userId = db.get<{ user_id: string }>("SELECT user_id FROM users WHERE username = ?1", [username])!.user_id;
+  const minted = createNetworkTokenForNode(userId, networkId, "dashboard-slash-node");
+  expect(minted.ok).toBe(true);
+  nodeToken = minted.token!;
+  db.run(
+    `INSERT INTO sessions (resume_id, alias, status, node_id, network_id, updated_at, last_seen_at)
+     VALUES (?1, ?2, 'idle', ?3, ?4, datetime('now'), datetime('now'))`,
+    [TARGET_RESUME_ID, TARGET, TARGET_NODE_ID, networkId],
+  );
+  db.run(
+    `INSERT INTO nodes (node_id, node_name, alias, network_id, created_at, updated_at, lifecycle_state)
+     VALUES (?1, ?2, ?2, ?3, datetime('now'), datetime('now'), 'active')`,
+    [TARGET_NODE_ID, TARGET, networkId],
+  );
+  const mod: any = await import("./server.js");
+  server = mod.bootServer({ port: 0, hostname: "127.0.0.1" });
+  base = `http://127.0.0.1:${server.port}`;
+}, 30_000);
+
+afterAll(() => {
+  try { server?.stop?.(true); } catch {}
+  try { rmSync(PRIVATE_DB_DIR, { recursive: true, force: true }); } catch {}
+});
+
+async function postAndRead(token: string, from: string, task: string) {
+  requestSequence += 1;
+  const clientRequestId = `dreq_${requestSequence.toString(16).padStart(32, "0")}`;
+  const response = await fetch(`${base}/api/task`, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+    body: JSON.stringify({
+      alias: TARGET,
+      from,
+      network_id: networkId,
+      task,
+      meta: { source: "dashboard-chat", client_request_id: clientRequestId, auth_origin: "user" },
+    }),
+  });
+  const body = await response.json() as any;
+  expect([200, 202]).toContain(response.status);
+  const taskId = body.task_id ?? body.message_id;
+  const row = db.get<{ content: string; meta_json: string }>(
+    "SELECT content, meta_json FROM inbox WHERE id = ?1",
+    [taskId],
+  );
+  expect(row).toBeTruthy();
+  return { type: "task", content: row!.content, meta_json: row!.meta_json };
+}
+
+describe("real Hub → authenticated Dashboard slash routing", () => {
+  test("Dashboard /goal and /loop remain exact native payloads for every runtime", async () => {
+    for (const command of ["/goal 更新一下文档", "/loop 5m native loop"] as const) {
+      const row = await postAndRead(userToken, "dashboard-user", command);
+      expect(row.content).toBe(command);
+      expect(isInteractiveDashboardTask(row)).toBe(true);
+      for (const runtime of ["codex-app-server", "codex", "claude", "grok", "opencode"] as const) {
+        expect(shouldCreateScheduledGoal(row.content, runtime, true)).toBe(false);
+      }
+    }
+  });
+
+  test("Dashboard /agoal and /aloop use the Agent Network scheduler", async () => {
+    for (const command of ["/agoal 5m update docs", "/aloop 5m update docs"] as const) {
+      const row = await postAndRead(userToken, "dashboard-user", command);
+      expect(isInteractiveDashboardTask(row)).toBe(true);
+      expect(shouldCreateScheduledGoal(row.content, "codex-app-server", true)).toBe(true);
+    }
+  });
+
+  test("node token cannot forge Dashboard pass-through and keeps legacy compatibility", async () => {
+    const row = await postAndRead(nodeToken, "dashboard-slash-node", "/loop 5m legacy automation");
+    expect(JSON.parse(row.meta_json).auth_origin).toBe("node");
+    expect(isInteractiveDashboardTask(row)).toBe(false);
+    expect(shouldCreateScheduledGoal(row.content, "codex-app-server", false)).toBe(true);
+  });
+});

package/src/db-adapter-guard.test.ts

@@ -0,0 +1,148 @@
+import { describe, expect, test } from "bun:test";
+import {
+  assertSafeTestDatabaseEnv,
+  redactPgUrl,
+  resolveDatabaseTarget,
+} from "./db-adapter";
+
+const BASE_ENV: NodeJS.ProcessEnv = { HOME: "/nonexistent" };
+
+describe("#435 inherited DATABASE_URL guard", () => {
+  for (const databaseUrl of [
+    "postgres://user:pw@prod.example:5432/commhub",
+    "postgresql://user:pw@prod.example:5432/commhub",
+    "sqlite:///tmp/not-an-escape",
+  ]) {
+    test(`NODE_ENV=test rejects ${databaseUrl.split(":", 1)[0]} DATABASE_URL`, () => {
+      expect(() => assertSafeTestDatabaseEnv({
+        ...BASE_ENV,
+        NODE_ENV: "test",
+        DATABASE_URL: databaseUrl,
+      })).toThrow(/REFUSING to honor inherited DATABASE_URL/);
+    });
+  }
+
+  test("test without DATABASE_URL leaves the existing SQLite guard in charge", () => {
+    expect(() => assertSafeTestDatabaseEnv({ ...BASE_ENV, NODE_ENV: "test" })).not.toThrow();
+    expect(() => resolveDatabaseTarget({ ...BASE_ENV, NODE_ENV: "test" }))
+      .toThrow(/REFUSING to open the default SQLite database/);
+  });
+
+  test("DATABASE_URL refusal wins even when COMMHUB_DB is also set", () => {
+    expect(() => resolveDatabaseTarget({
+      ...BASE_ENV,
+      NODE_ENV: "test",
+      DATABASE_URL: "postgres://user:pw@prod.example:5432/commhub",
+      COMMHUB_DB: "/tmp/isolated.db",
+    })).toThrow(/REFUSING to honor inherited DATABASE_URL/);
+  });
+
+  test("production postgres branch remains unchanged without constructing it", () => {
+    const url = "postgres://user:pw@prod.example:5432/commhub";
+    expect(resolveDatabaseTarget({
+      ...BASE_ENV,
+      NODE_ENV: "production",
+      DATABASE_URL: url,
+    })).toEqual({ kind: "postgres", url });
+  });
+
+  test("unset NODE_ENV still selects postgres", () => {
+    const url = "postgresql://user:pw@prod.example:5432/commhub";
+    expect(resolveDatabaseTarget({ ...BASE_ENV, DATABASE_URL: url }))
+      .toEqual({ kind: "postgres", url });
+  });
+
+  test("explicit SQLite targets remain unchanged in test and production", () => {
+    for (const NODE_ENV of ["test", "production"]) {
+      expect(resolveDatabaseTarget({
+        ...BASE_ENV,
+        NODE_ENV,
+        COMMHUB_DB: "/tmp/isolated.db",
+      })).toEqual({ kind: "sqlite", path: "/tmp/isolated.db" });
+    }
+  });
+
+  test("non-server callers cannot silently fall through to the production default SQLite path", () => {
+    for (const NODE_ENV of [undefined, "development", "production"]) {
+      expect(() => resolveDatabaseTarget({ ...BASE_ENV, NODE_ENV }))
+        .toThrow(/explicit COMMHUB_DB|COMMHUB_SERVER=1/);
+    }
+  });
+
+  test("the explicit server boot capability permits the canonical default SQLite path", () => {
+    expect(resolveDatabaseTarget({
+      ...BASE_ENV,
+      NODE_ENV: "production",
+      COMMHUB_SERVER: "1",
+    })).toEqual({ kind: "sqlite", path: "/nonexistent/.commhub/commhub.db" });
+  });
+
+  test("lookalike server capability values fail closed", () => {
+    for (const COMMHUB_SERVER of ["", "true", "yes", "01", " 1"] ) {
+      expect(() => resolveDatabaseTarget({ ...BASE_ENV, COMMHUB_SERVER }))
+        .toThrow(/COMMHUB_SERVER=1/);
+    }
+  });
+});
+
+describe("RFC-039 §9 COMMHUB_TEST_PG_URL (test-only PostgreSQL)", () => {
+  const TEST = { ...BASE_ENV, NODE_ENV: "test" };
+  const ok = (url: string) => expect(resolveDatabaseTarget({ ...TEST, COMMHUB_TEST_PG_URL: url })).toEqual({ kind: "postgres", url });
+  const refused = (url: string, why: RegExp) => {
+    let message = "";
+    try { resolveDatabaseTarget({ ...TEST, COMMHUB_TEST_PG_URL: url }); } catch (e: any) { message = String(e?.message ?? e); }
+    expect(message).toMatch(/REFUSING COMMHUB_TEST_PG_URL/);
+    expect(message).toMatch(why);
+    // Credentials never reach an error message.
+    expect(message).not.toContain("s3cret");
+    expect(message).not.toContain("tester");
+  };
+
+  test("loopback host + anet_*_test database is accepted under NODE_ENV=test", () => {
+    ok("postgres://tester:s3cret@127.0.0.1:5432/anet_sched_test");
+    ok("postgresql://tester:s3cret@localhost/anet_side_thread_test");
+    ok("postgres://tester:s3cret@[::1]:6543/anet_x_test?connect_timeout=2&sslmode=disable");
+  });
+
+  test("ignored outside NODE_ENV=test", () => {
+    expect(resolveDatabaseTarget({ ...BASE_ENV, NODE_ENV: "production", COMMHUB_DB: "/tmp/i.db", COMMHUB_TEST_PG_URL: "postgres://tester:s3cret@127.0.0.1/anet_x_test" }))
+      .toEqual({ kind: "sqlite", path: "/tmp/i.db" });
+  });
+
+  test("inherited DATABASE_URL still refuses even when COMMHUB_TEST_PG_URL is set", () => {
+    expect(() => resolveDatabaseTarget({
+      ...TEST,
+      DATABASE_URL: "postgres://user:pw@prod.example:5432/commhub",
+      COMMHUB_TEST_PG_URL: "postgres://tester:s3cret@127.0.0.1/anet_x_test",
+    })).toThrow(/REFUSING to honor inherited DATABASE_URL/);
+  });
+
+  test("refuses a value that is not a URL or not postgres", () => {
+    refused("not a url", /not a URL/);
+    refused("mysql://tester:s3cret@127.0.0.1/anet_x_test", /scheme/);
+  });
+
+  test("refuses every host that is not literally loopback", () => {
+    for (const host of ["10.0.0.5", "db.internal", "localhost.evil.example", "127.0.0.2", "127.0.0.1,evil.example", "LOCALHOST", "%2Ftmp"]) {
+      refused(`postgres://tester:s3cret@${host}/anet_x_test`, /host must be/);
+    }
+  });
+
+  test("refuses database names outside /^anet_[a-z0-9_]*_test$/", () => {
+    for (const name of ["commhub", "anet_x", "anet_x_test2", "ANET_X_TEST", "anet-x_test", "anet_x_test/extra", ""]) {
+      refused(`postgres://tester:s3cret@127.0.0.1/${name}`, /database name/);
+    }
+  });
+
+  test("refuses connection-steering query parameters", () => {
+    refused("postgres://tester:s3cret@127.0.0.1/anet_x_test?host=db.internal", /"host" is not allowed/);
+    refused("postgres://tester:s3cret@127.0.0.1/anet_x_test?options=-csearch_path%3Dprod", /"options" is not allowed/);
+  });
+
+  test("redactPgUrl drops user and password", () => {
+    const out = redactPgUrl("postgres://tester:s3cret@127.0.0.1:5432/anet_x_test");
+    expect(out).not.toContain("tester");
+    expect(out).not.toContain("s3cret");
+    expect(out).toContain("127.0.0.1:5432/anet_x_test");
+  });
+});

package/src/db-adapter-translate.test.ts

@@ -0,0 +1,128 @@
+import { describe, expect, test } from "bun:test";
+import { Database } from "bun:sqlite";
+import { PG_EXPERIMENTAL_ENV, PgAdapter, SQLiteAdapter, splitSqlStatements, sqliteToPostgres } from "./db-adapter";
+
+const UTC_NOW = "to_char((NOW()) AT TIME ZONE 'UTC', 'YYYY-MM-DD HH24:MI:SS')";
+
+describe("RFC-039 S2a sqliteToPostgres", () => {
+  test("datetime('now') stays SQLite-format UTC text", () => {
+    expect(sqliteToPostgres("SELECT datetime('now')")).toBe(`SELECT ${UTC_NOW}`);
+  });
+
+  test("DEFAULT (datetime('now')) keeps the column TEXT", () => {
+    const out = sqliteToPostgres("created_at TEXT NOT NULL DEFAULT (datetime('now'))");
+    expect(out).toBe(`created_at TEXT NOT NULL DEFAULT (${UTC_NOW})`);
+    expect(out).not.toContain("TIMESTAMP");
+  });
+
+  test("strftime with milliseconds keeps SQLite's %f shape", () => {
+    expect(sqliteToPostgres("VALUES (strftime('%Y-%m-%d %H:%M:%f', 'now'))")).toBe(
+      "VALUES (to_char(NOW() AT TIME ZONE 'UTC', 'YYYY-MM-DD HH24:MI:SS.MS'))",
+    );
+  });
+
+  test("literal offset", () => {
+    expect(sqliteToPostgres("x < datetime('now', '+14 days')")).toBe(
+      "x < to_char((NOW() + INTERVAL '14 days') AT TIME ZONE 'UTC', 'YYYY-MM-DD HH24:MI:SS')",
+    );
+  });
+
+  test("parameter offset is cast so PG can infer its type", () => {
+    expect(sqliteToPostgres("x < datetime('now', ?2)")).toBe(
+      "x < to_char((NOW() + CAST($2 AS TEXT)::INTERVAL) AT TIME ZONE 'UTC', 'YYYY-MM-DD HH24:MI:SS')",
+    );
+  });
+
+  test("INTEGER → BIGINT (epoch-ms columns), identifiers containing integer untouched", () => {
+    expect(sqliteToPostgres("created_at INTEGER NOT NULL, integer_ref TEXT")).toBe("created_at BIGINT NOT NULL, integer_ref TEXT");
+    expect(sqliteToPostgres("CAST(x AS INTEGER)")).toBe("CAST(x AS BIGINT)");
+  });
+
+  test("REAL → DOUBLE PRECISION (SQLite REAL is 8-byte), identifiers containing real untouched", () => {
+    expect(sqliteToPostgres("mem_used_gb REAL, realm TEXT")).toBe("mem_used_gb DOUBLE PRECISION, realm TEXT");
+    expect(sqliteToPostgres("CAST(x AS REAL)")).toBe("CAST(x AS DOUBLE PRECISION)");
+  });
+
+  test("BLOB → BYTEA, identifiers containing blob untouched", () => {
+    expect(sqliteToPostgres("iv BLOB NOT NULL, blob_ref TEXT")).toBe("iv BYTEA NOT NULL, blob_ref TEXT");
+  });
+
+  test("placeholders and AUTOINCREMENT unchanged in behaviour", () => {
+    expect(sqliteToPostgres("SELECT * FROM t WHERE a = ?1 AND b = ?2")).toBe("SELECT * FROM t WHERE a = $1 AND b = $2");
+    expect(sqliteToPostgres("a = ? AND b = ?")).toBe("a = $1 AND b = $2");
+    expect(sqliteToPostgres("id INTEGER PRIMARY KEY AUTOINCREMENT")).toBe("id BIGSERIAL PRIMARY KEY");
+  });
+});
+
+describe("RFC-039 S2a splitSqlStatements", () => {
+  test("a `;` inside a -- comment does not split (db.ts first schema block)", () => {
+    expect(splitSqlStatements("CREATE TABLE a (x TEXT);\n-- note; more words\nCREATE TABLE b (y TEXT);")).toEqual([
+      "CREATE TABLE a (x TEXT)",
+      "CREATE TABLE b (y TEXT)",
+    ]);
+  });
+
+  test("block comments are dropped", () => {
+    expect(splitSqlStatements("SELECT 1 /* a; b */ ; SELECT 2")).toEqual(["SELECT 1", "SELECT 2"]);
+  });
+
+  test("quoted strings and identifiers keep their `;` and doubled quotes", () => {
+    expect(splitSqlStatements(`INSERT INTO t VALUES ('a;b', 'it''s;'); SELECT "c;d" FROM t`)).toEqual([
+      `INSERT INTO t VALUES ('a;b', 'it''s;')`,
+      `SELECT "c;d" FROM t`,
+    ]);
+  });
+
+  test("a plpgsql $$ body stays one statement", () => {
+    const fn = "CREATE FUNCTION f() RETURNS trigger AS $$\nBEGIN\n  INSERT INTO t VALUES (1);\n  RETURN NEW;\nEND;\n$$ LANGUAGE plpgsql";
+    expect(splitSqlStatements(`${fn};\nDROP TRIGGER IF EXISTS x ON t;`)).toEqual([fn, "DROP TRIGGER IF EXISTS x ON t"]);
+  });
+
+  test("tagged dollar quotes; $1 placeholders are not dollar quotes", () => {
+    expect(splitSqlStatements("SELECT $body$a;b$body$; UPDATE t SET a = $1 WHERE b = $2")).toEqual([
+      "SELECT $body$a;b$body$",
+      "UPDATE t SET a = $1 WHERE b = $2",
+    ]);
+  });
+
+  test("empty statements are dropped", () => {
+    expect(splitSqlStatements(" ; ;\n SELECT 1 ;; ")).toEqual(["SELECT 1"]);
+  });
+});
+
+describe("RFC-039 transactional feature gates", () => {
+  // A PgAdapter without its constructor: no worker, no connection.
+  function pgWith(atomic: boolean) {
+    const pg = Object.create(PgAdapter.prototype);
+    Object.defineProperty(pg, "atomicTransactions", { value: atomic });
+    return pg as PgAdapter;
+  }
+  function withFlag<T>(value: string | undefined, fn: () => T): T {
+    const saved = process.env[PG_EXPERIMENTAL_ENV];
+    if (value === undefined) delete process.env[PG_EXPERIMENTAL_ENV];
+    else process.env[PG_EXPERIMENTAL_ENV] = value;
+    try { return fn(); } finally {
+      if (saved === undefined) delete process.env[PG_EXPERIMENTAL_ENV];
+      else process.env[PG_EXPERIMENTAL_ENV] = saved;
+    }
+  }
+
+  test("SQLite: open, flag irrelevant", () => {
+    const sqlite = new SQLiteAdapter(new Database(":memory:"));
+    expect(withFlag(undefined, () => sqlite.transactionalFeaturesRefusal)).toBeNull();
+    expect(withFlag("1", () => sqlite.transactionalFeaturesRefusal)).toBeNull();
+    sqlite.close();
+  });
+
+  test("PostgreSQL with real transactions: closed by default, message names the variable", () => {
+    const refusal = withFlag(undefined, () => pgWith(true).transactionalFeaturesRefusal);
+    expect(refusal).toContain(`${PG_EXPERIMENTAL_ENV}=1`);
+    expect(refusal).toContain("experimental");
+    expect(withFlag("true", () => pgWith(true).transactionalFeaturesRefusal)).not.toBeNull();
+  });
+
+  test("PostgreSQL: opens only with atomic transactions AND the opt-in", () => {
+    expect(withFlag("1", () => pgWith(true).transactionalFeaturesRefusal)).toBeNull();
+    expect(withFlag("1", () => pgWith(false).transactionalFeaturesRefusal)).toContain("not atomic");
+  });
+});