switchroom 0.21.6 → 0.21.8

package/telegram-plugin/tests/hermes-messages-paging.test.ts

@@ -0,0 +1,149 @@
+/**
+ * `GET /api/sessions/:id/messages` — ordering and pagination, against a REAL
+ * turns DB.
+ *
+ * Separate from `hermes-rest-parity.test.ts` for one reason: that fixture
+ * points `SWITCHROOM_AGENTS_DIR` at an empty tmpdir, so every session has zero
+ * messages and an assertion about ORDER or about which slice came back passes
+ * vacuously there. Ordering and offset windowing are exactly the properties
+ * that need real rows, and the turns DB is `bun:sqlite` — hence a bun test
+ * (vitest excludes it; see vitest.config.ts). It lives under
+ * telegram-plugin/tests/ rather than beside the adapter because that is the only
+ * tree the bun CI job walks — `bun test` runs with cwd telegram-plugin/, so a
+ * root-level src/ bun test is executed by NEITHER runner
+ * (scripts/check-test-runner-coverage.mjs, and the debt list it guards).
+ *
+ * Upstream contract being asserted (`hermes_cli/web_routers/sessions.py:601-651`
+ * at 9da6d455c9e1f2bf74bb9f47766ee9fc52e17bfb):
+ *   - messages come back CHRONOLOGICAL within the page;
+ *   - `order=oldest` windows from the start, `order=latest` from the end;
+ *   - `pagination.returned` is the real row count of that window.
+ *
+ * The bug each case guards, stated so a future edit cannot weaken it into a
+ * code-path check: the adapter read `listTurnsForAgent` (newest-first) and
+ * projected it without reversing, so the transcript arrived backwards; and it
+ * emitted no `pagination`, which `getAllSessionMessages` (hermes.ts:713-750)
+ * reads as "legacy backend, that was everything" and stops paging on.
+ */
+
+import { test, expect, beforeEach, afterEach } from "bun:test";
+import { mkdtempSync, rmSync, mkdirSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { openTurnsDb } from "../registry/turns-schema.js";
+import { handleHermesRest, type HermesRestResult } from "../../src/web/hermes-adapter.js";
+import type { SwitchroomConfig } from "../../src/config/schema.js";
+
+const AGENT = "alpha";
+let agentsDir = "";
+
+const CONFIG = { agents: { [AGENT]: {} } } as unknown as SwitchroomConfig;
+
+/** Seed `n` completed turns with explicit, strictly-increasing start times. */
+function seedTurns(n: number) {
+  const dir = join(agentsDir, AGENT);
+  mkdirSync(dir, { recursive: true });
+  const db = openTurnsDb(dir);
+  try {
+    for (let i = 0; i < n; i++) {
+      const ts = 1_700_000_000_000 + i * 1000;
+      db.prepare(
+        `INSERT INTO turns
+           (turn_key, chat_id, thread_id, started_at, ended_at, ended_via,
+            user_prompt_preview, assistant_reply_preview, created_at, updated_at)
+         VALUES (?, ?, NULL, ?, ?, 'stop', ?, ?, ?, ?)`,
+      ).run(`t${i}`, "chat", ts, ts + 500, `u${i}`, `a${i}`, ts, ts);
+    }
+  } finally {
+    db.close();
+  }
+}
+
+async function messages(search: string): Promise<Record<string, unknown>> {
+  const res = (await handleHermesRest(
+    "GET",
+    `/api/sessions/${AGENT}/messages`,
+    CONFIG,
+    search,
+  )) as HermesRestResult;
+  expect(res).not.toBeNull();
+  expect(res.status).toBe(200);
+  return res.body as Record<string, unknown>;
+}
+
+function contents(body: Record<string, unknown>): string[] {
+  return (body.messages as { content: string }[]).map((m) => m.content);
+}
+
+beforeEach(() => {
+  agentsDir = mkdtempSync(join(tmpdir(), "sr-hermes-msgs-"));
+  process.env.SWITCHROOM_AGENTS_DIR = agentsDir;
+});
+
+afterEach(() => {
+  rmSync(agentsDir, { recursive: true, force: true });
+});
+
+test("messages are chronological, not the newest-first order the turns DB reads in", async () => {
+  seedTurns(3);
+  const body = await messages("?limit=500&offset=0&order=oldest");
+  // u0/a0 is the OLDEST turn. Before the fix this list started at u2.
+  expect(contents(body)).toEqual(["u0", "a0", "u1", "a1", "u2", "a2"]);
+});
+
+test("order=oldest windows from the start and reports what it returned", async () => {
+  seedTurns(3);
+  const body = await messages("?limit=2&offset=2&order=oldest");
+  expect(contents(body)).toEqual(["u1", "a1"]);
+  expect(body.pagination).toEqual({ limit: 2, offset: 2, order: "oldest", returned: 2 });
+});
+
+test("order=latest windows from the END, still chronological inside the page", async () => {
+  seedTurns(3);
+  const body = await messages("?limit=3&order=latest");
+  expect(contents(body)).toEqual(["a1", "u2", "a2"]);
+  expect(body.pagination).toEqual({ limit: 3, offset: 0, order: "latest", returned: 3 });
+});
+
+test("paging with the desktop's own loop terminates having read every message once", async () => {
+  seedTurns(5); // 10 messages
+  // getAllSessionMessages (hermes.ts:713-750): limit=500, order=oldest, advance
+  // offset by the page length, stop when the page is short of `limit`.
+  const seen: string[] = [];
+  let offset = 0;
+  for (let guard = 0; guard < 10; guard++) {
+    const page = await messages(`?limit=4&offset=${offset}&order=oldest`);
+    const pagination = page.pagination as { limit: number };
+    seen.push(...contents(page));
+    if (contents(page).length === 0 || contents(page).length < pagination.limit) break;
+    offset += contents(page).length;
+  }
+  expect(seen).toEqual(["u0", "a0", "u1", "a1", "u2", "a2", "u3", "a3", "u4", "a4"]);
+});
+
+test("an omitted limit defaults to the latest 500, an explicit one defaults to oldest", async () => {
+  seedTurns(1);
+  expect((await messages("")).pagination).toEqual({
+    limit: 500,
+    offset: 0,
+    order: "latest",
+    returned: 2,
+  });
+  expect((await messages("?limit=10")).pagination).toEqual({
+    limit: 10,
+    offset: 0,
+    order: "oldest",
+    returned: 2,
+  });
+});
+
+test("an unrecognised order is a 400, not a silently-reinterpreted page", async () => {
+  seedTurns(1);
+  const res = await handleHermesRest(
+    "GET",
+    `/api/sessions/${AGENT}/messages`,
+    CONFIG,
+    "?order=sideways",
+  );
+  expect(res?.status).toBe(400);
+});

package/telegram-plugin/tests/hermes-session-search.test.ts

@@ -0,0 +1,146 @@
+/**
+ * `GET /api/sessions/search` — that it actually SEARCHES.
+ *
+ * `hermes-rest-parity.test.ts` can only assert the contract floor here
+ * (`Array.isArray(results)`), because it points `SWITCHROOM_AGENTS_DIR` at an
+ * empty tmpdir: with no turns anywhere, "found the right rows", "found nothing
+ * for a miss" and "hardcoded `{results: []}`" are indistinguishable. A
+ * hardcoded empty list would pass that floor forever, and an always-200 empty
+ * body is the exact bug class the desktop cannot detect —
+ * `isEndpointMissingError` only matches 404s.
+ *
+ * So this file seeds a real turns registry (`bun:sqlite`, hence a bun test —
+ * vitest excludes it; it lives under telegram-plugin/tests/ because that is the
+ * only tree the bun CI job walks) and asserts the discriminating outcomes:
+ * a query that should hit, hits; a query that should miss, misses.
+ */
+
+import { test, expect, beforeEach, afterEach } from "bun:test";
+import { mkdtempSync, rmSync, mkdirSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { openTurnsDb } from "../registry/turns-schema.js";
+import { handleHermesRest, type HermesRestResult } from "../../src/web/hermes-adapter.js";
+import type { SwitchroomConfig } from "../../src/config/schema.js";
+
+const CONFIG = {
+  agents: { alpha: { model: "sonnet" }, beta: {} },
+} as unknown as SwitchroomConfig;
+
+let agentsDir = "";
+
+function seed(agent: string, rows: { user: string; assistant: string }[]) {
+  const dir = join(agentsDir, agent);
+  mkdirSync(dir, { recursive: true });
+  const db = openTurnsDb(dir);
+  try {
+    rows.forEach((r, i) => {
+      const ts = 1_700_000_000_000 + i * 1000;
+      db.prepare(
+        `INSERT INTO turns
+           (turn_key, chat_id, thread_id, started_at, ended_at, ended_via,
+            user_prompt_preview, assistant_reply_preview, created_at, updated_at)
+         VALUES (?, ?, NULL, ?, ?, 'stop', ?, ?, ?, ?)`,
+      ).run(`${agent}-t${i}`, "chat", ts, ts + 500, r.user, r.assistant, ts, ts);
+    });
+  } finally {
+    db.close();
+  }
+}
+
+type Result = {
+  session_id: string;
+  lineage_root: string;
+  snippet: string;
+  role: string | null;
+  source: string | null;
+  model: string | null;
+  session_started: number | null;
+};
+
+async function search(query: string): Promise<Result[]> {
+  const res = (await handleHermesRest(
+    "GET",
+    "/api/sessions/search",
+    CONFIG,
+    query,
+  )) as HermesRestResult;
+  expect(res).not.toBeNull();
+  // The pre-fix behaviour: the /api/sessions/:id regex matched "search" as an
+  // id and answered 404 {error:'Unknown session'}, which threw the panel.
+  expect(res.status).toBe(200);
+  return (res.body as { results: Result[] }).results;
+}
+
+beforeEach(() => {
+  agentsDir = mkdtempSync(join(tmpdir(), "sr-hermes-search-"));
+  process.env.SWITCHROOM_AGENTS_DIR = agentsDir;
+});
+
+afterEach(() => {
+  rmSync(agentsDir, { recursive: true, force: true });
+});
+
+test("a session-id match comes back, with role null and the id as its own lineage root", async () => {
+  const results = await search("?q=alph");
+  expect(results.map((r) => r.session_id)).toEqual(["alpha"]);
+  expect(results[0].role).toBeNull();
+  expect(results[0].lineage_root).toBe("alpha");
+});
+
+test("a message-content match comes back tagged with the role it matched on", async () => {
+  seed("alpha", [{ user: "deploy the gateway", assistant: "done" }]);
+  seed("beta", [{ user: "unrelated", assistant: "also unrelated" }]);
+
+  const onUser = await search("?q=deploy");
+  expect(onUser.map((r) => r.session_id)).toEqual(["alpha"]);
+  expect(onUser[0].role).toBe("user");
+  expect(onUser[0].snippet).toBe("deploy the gateway");
+
+  const onAssistant = await search("?q=also%20unrelated");
+  expect(onAssistant.map((r) => r.session_id)).toEqual(["beta"]);
+  expect(onAssistant[0].role).toBe("assistant");
+  expect(onAssistant[0].snippet).toBe("also unrelated");
+});
+
+test("a query that matches nothing returns nothing — not the whole fleet", async () => {
+  seed("alpha", [{ user: "deploy the gateway", assistant: "done" }]);
+  // The discriminating case: a stub returning every session, and a stub
+  // returning none, are told apart only by running both this and the hit above.
+  expect(await search("?q=zzz-no-such-token")).toEqual([]);
+});
+
+test("an empty or whitespace query is short-circuited, not treated as match-everything", async () => {
+  seed("alpha", [{ user: "deploy", assistant: "done" }]);
+  expect(await search("?q=")).toEqual([]);
+  expect(await search("?q=%20%20")).toEqual([]);
+  expect(await search("")).toEqual([]);
+});
+
+test("one row per session even when several turns match", async () => {
+  seed("alpha", [
+    { user: "deploy one", assistant: "ok" },
+    { user: "deploy two", assistant: "ok" },
+    { user: "deploy three", assistant: "ok" },
+  ]);
+  const results = await search("?q=deploy");
+  expect(results.length).toBe(1);
+  expect(results[0].session_id).toBe("alpha");
+});
+
+test("?limit= caps the result set", async () => {
+  seed("alpha", [{ user: "shared token", assistant: "ok" }]);
+  seed("beta", [{ user: "shared token", assistant: "ok" }]);
+  expect((await search("?q=shared&limit=1")).length).toBe(1);
+  expect((await search("?q=shared")).length).toBe(2);
+});
+
+test("id matches are ordered ahead of content matches", async () => {
+  // beta matches by id; alpha only by content. Upstream surfaces direct
+  // session-id hits first (sessions.py:169-383) and the panel relies on it.
+  seed("alpha", [{ user: "beta is mentioned here", assistant: "ok" }]);
+  const results = await search("?q=beta");
+  expect(results.map((r) => r.session_id)).toEqual(["beta", "alpha"]);
+  expect(results[0].role).toBeNull();
+  expect(results[1].role).toBe("user");
+});

package/telegram-plugin/tests/parked-turn-start-preload.test.ts

@@ -0,0 +1,65 @@
+import { afterEach, describe, expect, it } from 'bun:test'
+import {
+  handleSessionEvent,
+  __parkedTurnStartCountForTest,
+  __resetParkedTurnStartsForTest,
+} from '../gateway/stream-render.js'
+import { enqueue, makeHarness } from './turn-mint-harness.js'
+
+/**
+ * Runtime alarm for the parked-turn-start leak guard (#4611).
+ *
+ * `parkedTurnStarts` is module-scope by design (one CLI session, one queue) and
+ * `bun test` runs all ~657 telegram-plugin files in ONE process, so a file that
+ * exits mid-park changes global state for every file after it:
+ * `gateway/obligation-wiring.ts` folds the parked count into `sessionBusy`, and
+ * `tests/represent-guard.test.ts`'s idle case then asserts `toHaveLength(1)`
+ * against `0`. Two PRs were ejected from the merge queue that way, with
+ * byte-identical retries passing, because bun's file order is not stable.
+ *
+ * `npm run lint:parked-turn-start-hermeticity` pins the WIRING statically; this
+ * pins the EFFECT, so a bunfig that is present but no longer loading the guard
+ * (wrong relative path, bun config-discovery change) fails a test rather than
+ * silently un-protecting the runner.
+ */
+// This suite deliberately parks, so it follows the discipline the guard
+// enforces for every other suite: reset on EXIT, not just on entry.
+afterEach(() => {
+  __resetParkedTurnStartsForTest()
+})
+
+describe('bun test runs with the parked-turn-start leak guard installed', () => {
+  it('the preload registered the global afterEach', () => {
+    const installed = (globalThis as { __switchroomParkedTurnStartGuard?: { hook: () => void } })
+      .__switchroomParkedTurnStartGuard
+    expect(
+      installed,
+      'guard absent — bunfig.toml `[test] preload` did not load parked-turn-start-guard.mjs',
+    ).toBeTruthy()
+    expect(typeof installed!.hook).toBe('function')
+  })
+
+  it('the hook throws on a leaked entry AND resets the store (one failure, not a cascade)', () => {
+    const { hook } = (globalThis as { __switchroomParkedTurnStartGuard: { hook: () => void } })
+      .__switchroomParkedTurnStartGuard
+
+    // Reproduce the #4611 leak shape: a mid-turn enqueue parks behind a live
+    // turn and is never dequeued — exactly queued-card-surface.test.ts:318.
+    const h = makeHarness()
+    handleSessionEvent(h.deps, enqueue('501'))
+    handleSessionEvent(h.deps, enqueue('502', 'real mid-turn message'))
+    expect(__parkedTurnStartCountForTest()).toBe(1)
+
+    expect(() => hook()).toThrow(/SWITCHROOM_PARKED_TURN_START_LEAK/)
+    // Reset-before-throw is what turns the ~1800-deep victim cascade into one
+    // attributable failure — and is why this test's own leak does not escape.
+    expect(__parkedTurnStartCountForTest()).toBe(0)
+
+    // A clean store is silent.
+    expect(() => hook()).not.toThrow()
+  })
+
+  it('leaves the store clean for the next file', () => {
+    expect(__parkedTurnStartCountForTest()).toBe(0)
+  })
+})