switchroom 0.5.0

package/telegram-plugin/tests/gateway-no-reply-single-emit.test.ts

@@ -0,0 +1,103 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { createAnswerStream, __resetDraftIdForTests } from '../answer-stream.js'
+
+/**
+ * #656 — gateway turn_end no-reply path.
+ *
+ * Background: gateway.ts at the turn_end handler used to materialize() the
+ * answer-lane stream when no reply tool was called, in parallel with the
+ * turn-flush emitter (gateway.ts ~3475). Both gates fire on the same
+ * `!replyCalled && capturedText.length > 0` condition, no dedup between
+ * them, and materialize() posts the raw model text without HTML conversion
+ * — producing a visible duplicate where one copy shows raw <b> tags and
+ * the other renders cleanly.
+ *
+ * Fix: drop the materialize branch entirely. Always retract() the
+ * answer-stream at turn_end. Turn-flush is the sole canonical emitter for
+ * no-reply turns (it runs markdownToHtml + records to outboundDedup).
+ *
+ * This test pins the contract that retract() does NOT emit a fresh
+ * sendMessage — only deletes any preliminary message previously sent. The
+ * gateway's no-reply path now relies on this property.
+ */
+
+async function flushMicrotasks(times = 10): Promise<void> {
+  for (let i = 0; i < times; i++) {
+    await Promise.resolve()
+  }
+}
+
+let nextMessageId = 5000
+
+beforeEach(() => {
+  __resetDraftIdForTests()
+  nextMessageId = 5000
+  vi.useFakeTimers()
+})
+
+afterEach(() => {
+  vi.useRealTimers()
+})
+
+describe('#656 — answer-stream retract() at turn_end emits nothing', () => {
+  it('retract before any preliminary send: no sendMessage, no deleteMessage', async () => {
+    const sendMessage = vi.fn(async () => ({ message_id: nextMessageId++ }))
+    const editMessageText = vi.fn(async () => {})
+    const deleteMessage = vi.fn(async () => {})
+
+    const stream = createAnswerStream({
+      chatId: 'chat-no-reply',
+      isPrivateChat: false,
+      minInitialChars: 400,
+      throttleMs: 250,
+      sendMessage: sendMessage as never,
+      editMessageText: editMessageText as never,
+      deleteMessage: deleteMessage as never,
+    })
+
+    // Seed a sub-threshold blob so nothing has been sent yet
+    stream.update('x'.repeat(50))
+    await flushMicrotasks()
+    expect(sendMessage).not.toHaveBeenCalled()
+
+    await stream.retract()
+
+    // Critically: retract() must NOT emit a fresh sendMessage. The gateway's
+    // no-reply path delegates the user-visible emit to turn-flush.
+    expect(sendMessage).not.toHaveBeenCalled()
+    expect(deleteMessage).not.toHaveBeenCalled()
+  })
+
+  it('retract after a preliminary send: deletes the prelim, no fresh sendMessage', async () => {
+    const THROTTLE = 1000
+    const sendMessage = vi.fn(async () => ({ message_id: nextMessageId++ }))
+    const editMessageText = vi.fn(async () => {})
+    const deleteMessage = vi.fn(async () => {})
+
+    const stream = createAnswerStream({
+      chatId: 'chat-no-reply',
+      isPrivateChat: false,
+      minInitialChars: 10,
+      throttleMs: THROTTLE,
+      sendMessage: sendMessage as never,
+      editMessageText: editMessageText as never,
+      deleteMessage: deleteMessage as never,
+    })
+
+    // Cross threshold so a preliminary send fires
+    stream.update('x'.repeat(50))
+    await flushMicrotasks()
+    vi.advanceTimersByTime(THROTTLE)
+    await flushMicrotasks()
+    expect(sendMessage).toHaveBeenCalledTimes(1)
+
+    const sendCallsBefore = sendMessage.mock.calls.length
+
+    await stream.retract()
+
+    // Retract should delete the preliminary message (cleanup) but must NOT
+    // emit any new sendMessage — turn-flush owns the user-visible emit.
+    expect(deleteMessage).toHaveBeenCalledTimes(1)
+    expect(sendMessage.mock.calls.length).toBe(sendCallsBefore)
+  })
+})

package/telegram-plugin/tests/gateway-secret-detect.test.ts

@@ -0,0 +1,127 @@
+import { describe, it, expect } from 'vitest'
+import { readFileSync } from 'node:fs'
+
+/**
+ * Structural integration test for the secret-detect intercept in the
+ * gateway's handleInbound.
+ *
+ * Why structural: gateway/gateway.ts does not export handleInbound, so a
+ * pure-functional invocation would require either a refactor (risky for
+ * a security fix) or end-to-end harnessing of Bot/Grammy/Context. The
+ * pipeline itself is exhaustively unit-tested in
+ * `secret-detect-pipeline.test.ts` and `secret-detect.test.ts`, and the
+ * fail-closed contract has its own structural test
+ * (`secret-detect-fail-closed.test.ts`). What's left to assert here is:
+ *   1. The gateway actually wires runPipeline into handleInbound.
+ *   2. The intercept sits AFTER the auth/vault intercepts (those bypass
+ *      the LLM entirely; secret-detect must run on text that survived
+ *      them).
+ *   3. The intercept sits BEFORE recordInbound() and ipcServer.broadcast()
+ *      (those are the sinks that would leak raw bytes to SQLite + agent).
+ *   4. Both the cached-passphrase store path and the no-passphrase
+ *      deferred-warning path are present.
+ *
+ * If a future refactor moves the intercept into the wrong slot, these
+ * assertions break and the security regression is caught at build time
+ * rather than live.
+ */
+describe('gateway secret-detect intercept — structural wiring', () => {
+  const src = readFileSync(
+    new URL('../gateway/gateway.ts', import.meta.url),
+    'utf8',
+  )
+
+  it('imports the pipeline + staging modules', () => {
+    expect(src).toMatch(/from '\.\.\/secret-detect\/pipeline\.js'/)
+    expect(src).toMatch(/from '\.\.\/secret-detect\/staging\.js'/)
+    expect(src).toMatch(/from '\.\.\/secret-detect\/vault-write\.js'/)
+    expect(src).toMatch(/from '\.\.\/secret-detect\/index\.js'/)
+  })
+
+  it('invokes runPipeline inside handleInbound', () => {
+    const handleInboundIdx = src.indexOf('async function handleInbound(')
+    expect(handleInboundIdx).toBeGreaterThan(0)
+    const pipelineIdx = src.indexOf('runPipeline({', handleInboundIdx)
+    expect(pipelineIdx).toBeGreaterThan(0)
+  })
+
+  it('runPipeline call sits AFTER the vault intercept', () => {
+    const vaultIdx = src.indexOf('// Vault intercept')
+    const pipelineIdx = src.indexOf('runPipeline({')
+    expect(vaultIdx).toBeGreaterThan(0)
+    expect(pipelineIdx).toBeGreaterThan(0)
+    expect(pipelineIdx).toBeGreaterThan(vaultIdx)
+  })
+
+  it('runPipeline call sits BEFORE recordInbound() and ipcServer.broadcast(inboundMsg)', () => {
+    const pipelineIdx = src.indexOf('runPipeline({')
+    const recordIdx = src.indexOf('recordInbound(', pipelineIdx)
+    const broadcastIdx = src.indexOf('ipcServer.broadcast(inboundMsg)', pipelineIdx)
+    expect(pipelineIdx).toBeGreaterThan(0)
+    expect(recordIdx).toBeGreaterThan(pipelineIdx)
+    expect(broadcastIdx).toBeGreaterThan(pipelineIdx)
+  })
+
+  it('cached-passphrase path: rewrites effectiveText, deletes message, posts masked summary', () => {
+    const pipelineIdx = src.indexOf('runPipeline({')
+    const tail = src.slice(pipelineIdx, pipelineIdx + 4000)
+    // Rewrites effectiveText so the broadcast carries the redacted text.
+    expect(tail).toMatch(/effectiveText = pipeRes\.rewritten_text/)
+    // Deletes the original Telegram message containing the raw bytes.
+    expect(tail).toMatch(/bot\.api\.deleteMessage\(chat_id, msgId\)/)
+    // Tells the user what was captured (masked).
+    expect(tail).toMatch(/captured \$\{pipeRes\.stored\.length\} secret/)
+    // Surfaces the masked form (s.masked is computed via maskToken in the pipeline).
+    expect(tail).toMatch(/s\.masked/)
+  })
+
+  it('no-passphrase deferred path: prompts user, deletes message, returns (no broadcast)', () => {
+    // Issue #44 turned the deferred path into a one-tap inline-button
+    // flow. The structural invariants we still want to pin:
+    //   1. The deferred record is set in `deferredSecrets` so the
+    //      post-unlock callback can find it.
+    //   2. The original message containing the raw bytes is deleted.
+    //   3. The path returns before falling through to recordInbound /
+    //      broadcast.
+    //   4. The reply uses the deferred-secret keyboard so a one-tap
+    //      unlock is offered instead of the legacy "/vault list +
+    //      re-paste" instructions.
+    const pipelineIdx = src.indexOf('runPipeline({')
+    const tail = src.slice(pipelineIdx, pipelineIdx + 8000)
+    // 1. Deferred record set with the suggested slug captured up-front.
+    expect(tail).toMatch(/deferredSecrets\.set\(/)
+    expect(tail).toMatch(/suggested_slug:/)
+    // 2. The original message is deleted (so the raw bytes are scrubbed
+    //    from the chat client even before the user reacts).
+    expect(tail).toMatch(/bot\.api\.deleteMessage\(chat_id, msgId\)/)
+    // 4. The new inline keyboard helper is used in lieu of the legacy
+    //    plain-text "run /vault list" warning.
+    expect(tail).toMatch(/buildDeferredSecretKeyboard\(/)
+    // 3. `return` after the reply so the no-broadcast contract holds.
+    const keyboardIdx = tail.indexOf('buildDeferredSecretKeyboard(')
+    const afterKeyboard = tail.slice(keyboardIdx)
+    expect(afterKeyboard).toMatch(/\n\s*return\b/)
+  })
+
+  it('issue #44: deferred-secret callback handler + auto-write helper exist', () => {
+    // Static wiring check — the inline buttons need a dispatcher branch
+    // and a write helper, otherwise tapping the card does nothing.
+    expect(src).toMatch(/handleVaultDeferCallback\b/)
+    expect(src).toMatch(/executeDeferredSecretSave\b/)
+    expect(src).toMatch(/passphrase-for-deferred/)
+    // Dispatcher routes vd: prefix to the new handler.
+    const dispatcherIdx = src.indexOf("data.startsWith('vd:')")
+    expect(dispatcherIdx).toBeGreaterThan(0)
+  })
+
+  it('detectSecrets is used for the deferred peek (no-passphrase path)', () => {
+    expect(src).toMatch(/const detections = detectSecrets\(effectiveText\)/)
+  })
+
+  it('staging follow-up commands (stash/ignore/rename/forget) are wired', () => {
+    const handleInboundIdx = src.indexOf('async function handleInbound(')
+    const tail = src.slice(handleInboundIdx, handleInboundIdx + 30000)
+    expect(tail).toMatch(/\(stash\|ignore\|rename\|forget\)/)
+    expect(tail).toMatch(/secretStaging\.latestForChat\(chat_id\)/)
+  })
+})

package/telegram-plugin/tests/gateway-startup-mutex.test.ts

@@ -0,0 +1,284 @@
+/**
+ * Regression tests for the gateway startup mutex + SIGTERM drain.
+ *
+ * Background — 2026-04-23 incident:
+ *   Two clerk-gateway processes were alive simultaneously after a
+ *   restart. The new one looped 13+ times on `409: Conflict: terminated
+ *   by other getUpdates request` because the OLD one's long-poll TCP
+ *   connection hadn't FIN'd yet. PRs #45–#50 added a PID-file probe
+ *   and SIGTERM marker but no real startup mutex.
+ *
+ * These tests pin the invariants of the architectural fix:
+ *   - Startup mutex prevents double-start when a live PID holds the file
+ *   - Startup mutex auto-recovers when the holder PID is dead
+ *   - Lock releases on clean shutdown
+ *   - SIGTERM drain returns within budget for cooperative in-flight
+ *   - SIGTERM drain reports timed_out=true when in-flight never drops
+ *
+ * Run with:
+ *   bun test telegram-plugin/tests/gateway-startup-mutex.test.ts
+ */
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import { mkdtempSync, writeFileSync, existsSync, readFileSync, rmSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import {
+  acquireStartupLock,
+  releaseStartupLock,
+  type MutexRecord,
+} from "../gateway/startup-mutex.js";
+import { drainShutdown } from "../gateway/shutdown-drain.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function tmpLockPath(): { dir: string; path: string } {
+  const dir = mkdtempSync(join(tmpdir(), "gw-mutex-test-"));
+  return { dir, path: join(dir, "gateway.pid.json") };
+}
+
+function makeRecord(pid: number, startedAtMs = Date.now()): MutexRecord {
+  return { pid, startedAtMs };
+}
+
+function noopLog(): { lines: string[]; log: (s: string) => void } {
+  const lines: string[] = [];
+  return { lines, log: (s: string) => { lines.push(s); } };
+}
+
+// ---------------------------------------------------------------------------
+// Mutex tests
+// ---------------------------------------------------------------------------
+
+describe("acquireStartupLock", () => {
+  const cleanups: string[] = [];
+
+  afterEach(() => {
+    while (cleanups.length > 0) {
+      const dir = cleanups.pop();
+      if (dir) {
+        try { rmSync(dir, { recursive: true, force: true }); } catch {}
+      }
+    }
+  });
+
+  it("(a) blocks when an alive holder owns the file", async () => {
+    // Setup: someone else holds the lock with PID 12345 (which our
+    // injected isPidAlive will report as alive).
+    const { dir, path } = tmpLockPath();
+    cleanups.push(dir);
+    const incumbent = makeRecord(12345, Date.now() - 5000);
+    writeFileSync(path, JSON.stringify(incumbent), "utf-8");
+
+    const { lines, log } = noopLog();
+    const result = await acquireStartupLock({
+      path,
+      record: makeRecord(99999),
+      isPidAlive: (pid) => pid === 12345, // incumbent is alive
+      log,
+      agentName: "test-agent",
+    });
+
+    expect(result.status).toBe("blocked");
+    if (result.status !== "blocked") throw new Error("unreachable");
+    expect(result.holder.pid).toBe(12345);
+    expect(result.holderAgeSec).toBeGreaterThanOrEqual(4);
+
+    // File should still contain the incumbent record (not overwritten).
+    const onDisk = JSON.parse(readFileSync(path, "utf-8")) as MutexRecord;
+    expect(onDisk.pid).toBe(12345);
+
+    // Should have logged a boot.lock_blocked line for journalctl.
+    const blocked = lines.find((l) => l.includes("boot.lock_blocked"));
+    expect(blocked).toBeDefined();
+    expect(blocked).toContain("holder_pid=12345");
+    expect(blocked).toContain("agent=test-agent");
+  });
+
+  it("(b) releases the lock on shutdown — file is gone afterwards", async () => {
+    const { dir, path } = tmpLockPath();
+    cleanups.push(dir);
+
+    const { log } = noopLog();
+    const acquired = await acquireStartupLock({
+      path,
+      record: makeRecord(process.pid),
+      isPidAlive: () => true,
+      log,
+    });
+    expect(acquired.status).toBe("acquired");
+    expect(existsSync(path)).toBe(true);
+
+    const releaseLog = noopLog();
+    await releaseStartupLock({
+      path,
+      pid: process.pid,
+      log: releaseLog.log,
+      agentName: "test-agent",
+    });
+    expect(existsSync(path)).toBe(false);
+    const released = releaseLog.lines.find((l) => l.includes("shutdown.lock_released"));
+    expect(released).toBeDefined();
+    expect(released).toContain(`pid=${process.pid}`);
+  });
+
+  it("(c) auto-recovers a stale lock (dead PID) and writes our own", async () => {
+    const { dir, path } = tmpLockPath();
+    cleanups.push(dir);
+    // Pre-populate with a "dead" PID. 999999 is effectively impossible
+    // to allocate on Linux (kernel.pid_max default is 4194304 on
+    // x86_64 but most systems use the older 32768 ceiling — either way,
+    // 999999 is almost certainly unallocated). We override isPidAlive
+    // to make the test deterministic regardless of kernel config.
+    const stalePid = 999999;
+    const stale = makeRecord(stalePid, Date.now() - 600_000); // 10min old
+    writeFileSync(path, JSON.stringify(stale), "utf-8");
+
+    const ourPid = 4242;
+    const { lines, log } = noopLog();
+    const result = await acquireStartupLock({
+      path,
+      record: makeRecord(ourPid),
+      isPidAlive: (pid) => pid !== stalePid, // stale is dead, all else alive
+      log,
+      agentName: "test-agent",
+    });
+
+    expect(result.status).toBe("acquired");
+    if (result.status !== "acquired") throw new Error("unreachable");
+    expect(result.recoveredFrom).toBeDefined();
+    expect(result.recoveredFrom?.pid).toBe(stalePid);
+
+    // File should now contain OUR record.
+    const onDisk = JSON.parse(readFileSync(path, "utf-8")) as MutexRecord;
+    expect(onDisk.pid).toBe(ourPid);
+
+    // Audit log: must include the stale-recovered line so an operator
+    // grepping journalctl can see what happened.
+    const recovered = lines.find((l) => l.includes("boot.lock_stale_recovered"));
+    expect(recovered).toBeDefined();
+    expect(recovered).toContain(`prior_pid=${stalePid}`);
+    expect(recovered).toContain("agent=test-agent");
+
+    const acquired = lines.find((l) => l.includes("boot.lock_acquired"));
+    expect(acquired).toBeDefined();
+    expect(acquired).toContain(`pid=${ourPid}`);
+  });
+
+  it("(c.bonus) double-acquire by the SAME process does NOT corrupt state", async () => {
+    // Defensive: if the boot path somehow runs acquireStartupLock twice
+    // in the same process, we should detect ourselves as the holder and
+    // NOT mutate the file. (Currently we report blocked, which is the
+    // safe failure mode — caller exits non-zero.)
+    const { dir, path } = tmpLockPath();
+    cleanups.push(dir);
+    const { log } = noopLog();
+    const first = await acquireStartupLock({
+      path,
+      record: makeRecord(process.pid),
+      isPidAlive: () => true,
+      log,
+    });
+    expect(first.status).toBe("acquired");
+
+    const second = await acquireStartupLock({
+      path,
+      record: makeRecord(process.pid),
+      isPidAlive: () => true,
+      log,
+    });
+    expect(second.status).toBe("blocked");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Drain tests
+// ---------------------------------------------------------------------------
+
+describe("drainShutdown", () => {
+  // Real-time tests for the drain. We use real setTimeout (the module
+  // default) and small budgets so the suite stays under a second total.
+  // Mocking the clock is fragile here because Promise.race against the
+  // budget sleep tangles with the in-flight poll loop's clock.
+
+  it("(d.1) returns timed_out=false when in-flight drains within budget", async () => {
+    // In-flight starts at 3, drops to 0 after ~200ms of real time.
+    let count = 3;
+    setTimeout(() => { count = 0; }, 200);
+
+    const { lines, log } = noopLog();
+    const result = await drainShutdown({
+      signal: "SIGTERM",
+      stopPolling: async () => { /* cooperative — returns immediately */ },
+      inFlight: () => count,
+      budgetMs: 1000,
+      pollIntervalMs: 25,
+      log,
+      agentName: "test-agent",
+    });
+
+    expect(result.timedOut).toBe(false);
+    expect(result.inFlightRemaining).toBe(0);
+    expect(result.elapsedMs).toBeLessThan(1000);
+    expect(result.elapsedMs).toBeGreaterThanOrEqual(150);
+
+    const start = lines.find((l) => l.includes("shutdown.drain_start"));
+    expect(start).toBeDefined();
+    expect(start).toContain("signal=SIGTERM");
+    expect(start).toContain("in_flight=3");
+
+    const complete = lines.find((l) => l.includes("shutdown.drain_complete"));
+    expect(complete).toBeDefined();
+    expect(complete).toContain("timed_out=false");
+    expect(complete).toContain("in_flight_remaining=0");
+  });
+
+  it("(d.2) returns timed_out=true when in-flight never drops", async () => {
+    const { lines, log } = noopLog();
+    const result = await drainShutdown({
+      signal: "SIGTERM",
+      stopPolling: async () => { /* returns instantly; in-flight never clears */ },
+      inFlight: () => 5,
+      budgetMs: 250, // small budget keeps the test fast
+      pollIntervalMs: 25,
+      log,
+      agentName: "test-agent",
+    });
+
+    expect(result.timedOut).toBe(true);
+    expect(result.inFlightRemaining).toBe(5);
+    expect(result.elapsedMs).toBeGreaterThanOrEqual(250);
+    // Tight upper bound — 2× headroom over budget catches obvious
+    // slow-drain regressions without flaking under normal load.
+    expect(result.elapsedMs).toBeLessThan(500);
+
+    const complete = lines.find((l) => l.includes("shutdown.drain_complete"));
+    expect(complete).toBeDefined();
+    expect(complete).toContain("timed_out=true");
+    expect(complete).toContain("in_flight_remaining=5");
+  });
+
+  it("(d.3) survives stopPolling throwing without aborting the drain", async () => {
+    let count = 2;
+    setTimeout(() => { count = 0; }, 100);
+
+    const { lines, log } = noopLog();
+    const result = await drainShutdown({
+      signal: "SIGTERM",
+      stopPolling: async () => {
+        throw new Error("simulated bot.stop() failure");
+      },
+      inFlight: () => count,
+      budgetMs: 1000,
+      pollIntervalMs: 25,
+      log,
+    });
+
+    expect(result.timedOut).toBe(false);
+    expect(result.inFlightRemaining).toBe(0);
+    const errLine = lines.find((l) => l.includes("stop_polling_error"));
+    expect(errLine).toBeDefined();
+    expect(errLine).toContain("simulated bot.stop() failure");
+  });
+});