switchroom 0.21.17 → 0.21.19

package/telegram-plugin/tests/llm-error-present.test.ts

@@ -27,6 +27,7 @@ import {
 } from '../llm-error-present.js'
 import { truncateDetailPreservingRequestId } from '../raw-error-scrub.js'
 import { projectTranscriptLine, detectErrorInTranscriptLine } from '../session-tail.js'
+import { isConnectionDropText } from '../connection-drop.js'
 import { renderOperatorEvent, type OperatorEvent } from '../operator-events.js'
 import { redact } from '../secret-detect/redact.js'
 
@@ -137,6 +138,188 @@ describe('parseLlmError — classification table', () => {
   })
 })
 
+// ─── Connection-drop classification (PR 0: unify drop classification) ─────────
+//
+// The two classifiers historically disagreed about a mid-stream connection /
+// SSE drop: Path A (`parseLlmError`) mapped it to a transient/network error,
+// while Path B (`detectErrorInTranscriptLine`) let a drop-worded line whose
+// wording `classifyClaudeError` did not recognise fall through to a generic
+// `unknown-*` terminal. These blocks assert the SAME line is now identifiable
+// as a connection drop on BOTH paths — and, critically, that auth / quota /
+// overload / provider-credit walls are NEVER flagged as drops on either path
+// (the greedy-matcher failure mode that would later cause a wrong auto-resume).
+
+const OPENROUTER_402_CREDIT =
+  'litellm.APIError: OpenrouterException - {"error":{"code":402,"message":"Your account or API key has insufficient credits. Add more credits and retry the request.","metadata":{"provider_name":"openrouter"}}}'
+
+/** Build the v2.1.x `isApiErrorMessage` synthetic-assistant transcript line. */
+function apiErrorLine(text: string, opts: { error?: string; status?: number } = {}): string {
+  return JSON.stringify({
+    type: 'assistant',
+    message: { role: 'assistant', model: '<synthetic>', content: [{ type: 'text', text }] },
+    isApiErrorMessage: true,
+    ...(opts.error != null ? { error: opts.error } : { error: '' }),
+    ...(opts.status != null ? { apiErrorStatus: opts.status } : {}),
+  })
+}
+
+describe('connection-drop — identifiable on BOTH classification paths', () => {
+  // The canonical mid-stream abort shape: isApiErrorMessage + error:"server_error",
+  // NO status. Path A sees the worded string; Path B sees the transcript line.
+  it('a "Connection closed mid-response" line is a connection-drop on Path A AND Path B', () => {
+    const wording = 'API Error: Connection closed mid-response'
+
+    // Path A
+    const a = parseLlmError(wording)
+    expect(a.connectionDrop).toBe(true)
+    expect(a.kind).toBe('transient')
+    expect(a.source).toBe('network')
+
+    // Path B
+    const b = detectErrorInTranscriptLine(apiErrorLine(wording, { error: 'server_error' }))
+    expect(b).not.toBeNull()
+    expect(b!.connectionDrop).toBe(true)
+    expect(b!.kind).toBe('transport-transient')
+  })
+
+  // The exact Path-B bug: a drop-worded line whose wording `classifyClaudeError`
+  // does NOT recognise (no server_error type, no status) fell through to
+  // unknown-5xx. It must STILL be flagged a connection-drop.
+  it('a "socket hang up" line unknown to classifyClaudeError is still a connection-drop on both paths', () => {
+    const wording = 'API Error: socket hang up'
+
+    const a = parseLlmError(wording)
+    expect(a.connectionDrop).toBe(true)
+
+    const b = detectErrorInTranscriptLine(apiErrorLine(wording))
+    expect(b).not.toBeNull()
+    expect(b!.kind).toBe('unknown-5xx') // classifyClaudeError does not recognise the wording…
+    expect(b!.connectionDrop).toBe(true) // …yet the drop is identified anyway.
+  })
+
+  // The wrapper-error line shape (`type:"error"`, nested error object).
+  it('a server_error wrapper line carrying a drop wording is a connection-drop on Path B', () => {
+    const line = JSON.stringify({
+      type: 'error',
+      error: { type: 'server_error', message: 'Connection closed mid-response' },
+    })
+    const b = detectErrorInTranscriptLine(line)
+    expect(b).not.toBeNull()
+    expect(b!.kind).toBe('transport-transient')
+    expect(b!.connectionDrop).toBe(true)
+  })
+
+  // EPIPE is a genuine drop wording that `detectModelUnavailable` does not
+  // classify as network — Path A lands it on `unknown`, but it must still be a
+  // connection-drop (proving the discriminator is NOT tied to source:'network').
+  it('EPIPE is a connection-drop on Path A even though its kind stays unknown', () => {
+    const a = parseLlmError('write EPIPE: half-dead socket')
+    expect(a.kind).toBe('unknown')
+    expect(a.connectionDrop).toBe(true)
+  })
+})
+
+describe('connection-drop — negatives (auth / quota / overload / provider-credit are NEVER drops)', () => {
+  it('auth is not a connection-drop on either path', () => {
+    const a = parseLlmError('authentication_error: OAuth token expired, please refresh')
+    expect(a.kind).toBe('auth')
+    expect(a.connectionDrop).toBe(false)
+
+    const b = detectErrorInTranscriptLine(
+      apiErrorLine('authentication_error: OAuth token expired', { error: 'authentication_error', status: 401 }),
+    )
+    expect(b).not.toBeNull()
+    expect(b!.connectionDrop).toBe(false)
+  })
+
+  it('quota_wall is not a connection-drop on either path', () => {
+    const a = parseLlmError("You've hit your limit · resets 5pm")
+    expect(a.kind).toBe('quota_wall')
+    expect(a.connectionDrop).toBe(false)
+
+    const b = detectErrorInTranscriptLine(
+      apiErrorLine("You've hit your limit · resets 5pm", { error: 'rate_limit_error', status: 429 }),
+    )
+    expect(b).not.toBeNull()
+    expect(b!.kind).toBe('quota-exhausted')
+    expect(b!.connectionDrop).toBe(false)
+  })
+
+  it('overload_529 is not a connection-drop on either path', () => {
+    const a = parseLlmError('Overloaded (overloaded_error) — HTTP 529')
+    expect(a.kind).toBe('overload_529')
+    expect(a.connectionDrop).toBe(false)
+
+    const b = detectErrorInTranscriptLine(apiErrorLine('Overloaded', { error: 'overloaded_error' }))
+    expect(b).not.toBeNull()
+    expect(b!.connectionDrop).toBe(false)
+  })
+
+  it('provider_credit is not a connection-drop on either path', () => {
+    const a = parseLlmError(OPENROUTER_402_CREDIT)
+    expect(a.kind).toBe('provider_credit')
+    expect(a.connectionDrop).toBe(false)
+
+    const b = detectErrorInTranscriptLine(apiErrorLine(OPENROUTER_402_CREDIT, { status: 402 }))
+    expect(b).not.toBeNull()
+    expect(b!.kind).toBe('provider-credit-exhausted')
+    expect(b!.connectionDrop).toBe(false)
+  })
+
+  // The single highest-risk case: a wrapped auth/quota wall whose OUTER text
+  // coincidentally carries a drop wording ("fetch failed") must NOT be flagged a
+  // drop — the classification wins over the wording, on both paths.
+  it('a wrapped auth error whose outer text says "fetch failed" is NOT a connection-drop', () => {
+    const a = parseLlmError('authentication_error: invalid api key (underlying: fetch failed)')
+    expect(a.kind).toBe('auth')
+    expect(a.connectionDrop).toBe(false)
+
+    const b = detectErrorInTranscriptLine(
+      JSON.stringify({
+        type: 'error',
+        error: { type: 'authentication_error', message: 'invalid api key; underlying: fetch failed' },
+      }),
+    )
+    expect(b).not.toBeNull()
+    expect(b!.kind).toBe('credentials-invalid')
+    expect(b!.connectionDrop).toBe(false)
+  })
+})
+
+describe('isConnectionDropText — the canonical matcher is conservative', () => {
+  it('matches the canonical drop wordings', () => {
+    for (const s of [
+      'socket hang up',
+      'read ECONNRESET',
+      'connect ECONNREFUSED 1.2.3.4:443',
+      'write EPIPE',
+      'fetch failed',
+      'network error',
+      'Connection closed mid-response',
+      'connection lost',
+      'Premature close',
+      'the stream disconnected unexpectedly',
+    ]) {
+      expect(isConnectionDropText(s)).toBe(true)
+    }
+  })
+
+  it('does NOT over-match "upstream"/"downstream"/"terminated" or auth/quota wording', () => {
+    for (const s of [
+      'the upstream provider returned a result',
+      'downstream consumer finished',
+      'the worker terminated cleanly',
+      'authentication_error: invalid api key',
+      "You've hit your usage limit",
+      'overloaded_error',
+      'insufficient credits',
+      '',
+    ]) {
+      expect(isConnectionDropText(s)).toBe(false)
+    }
+  })
+})
+
 // ─── local-time render ───────────────────────────────────────────────────────
 
 describe('renderLlmError / formatResetLocal — local-time rendering', () => {

package/telegram-plugin/uat/flip/allowlist.test.ts

@@ -0,0 +1,229 @@
+/**
+ * Unit suite for the UAT allowlist add/remove helper. Runs under `bun test`
+ * (this tree is vitest-excluded) via the `uat/flip/` entry in
+ * telegram-plugin/scripts/bun-test-ci.sh.
+ *
+ * Everything is hermetic: a tmp `agentsDir` is built per-test and torn down,
+ * and the clock is injected so `expiresAt`/`--expired` are deterministic. No
+ * real ~/.switchroom is touched.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import {
+  mkdtempSync,
+  mkdirSync,
+  writeFileSync,
+  readFileSync,
+  existsSync,
+  rmSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  addToAllowlist,
+  removeFromAllowlist,
+  sweepAllowlist,
+  runAllowlistCli,
+  accessFilePath,
+  receiptPath,
+  DEFAULT_TTL_MS,
+  type AllowlistReceipt,
+} from "./allowlist.js";
+
+let agentsDir: string;
+let root: string;
+
+function seedAccess(agent: string, obj: unknown): void {
+  const p = accessFilePath(agentsDir, agent);
+  mkdirSync(join(p, ".."), { recursive: true });
+  writeFileSync(p, JSON.stringify(obj, null, 2) + "\n");
+}
+
+function readAccess(agent: string): Record<string, unknown> {
+  return JSON.parse(readFileSync(accessFilePath(agentsDir, agent), "utf8"));
+}
+
+function readReceipt(agent: string): AllowlistReceipt {
+  return JSON.parse(readFileSync(receiptPath(agentsDir, agent), "utf8"));
+}
+
+function mkAgentDir(agent: string): void {
+  mkdirSync(join(agentsDir, agent, "telegram"), { recursive: true });
+}
+
+beforeEach(() => {
+  root = mkdtempSync(join(tmpdir(), "sr-uat-allowlist-"));
+  agentsDir = join(root, "agents");
+  mkdirSync(agentsDir, { recursive: true });
+});
+
+afterEach(() => {
+  rmSync(root, { recursive: true, force: true });
+});
+
+describe("addToAllowlist", () => {
+  it("appends the id, preserves sibling keys, and writes a receipt first", () => {
+    seedAccess("ziggy", {
+      dmPolicy: "allowlist",
+      allowFrom: ["111"],
+      groups: { "-100": { allowFrom: ["222"] } },
+      voice_in: true,
+    });
+    const now = Date.parse("2026-08-18T00:00:00.000Z");
+    const r = addToAllowlist("ziggy", "999", { agentsDir, now: () => now });
+
+    expect(r.added).toBe(true);
+    expect(r.preexisting).toBe(false);
+
+    const access = readAccess("ziggy");
+    expect(access.allowFrom).toEqual(["111", "999"]);
+    // sibling keys survive the whole-object rewrite.
+    expect(access.groups).toEqual({ "-100": { allowFrom: ["222"] } });
+    expect(access.voice_in).toBe(true);
+    expect(access.dmPolicy).toBe("allowlist");
+
+    const rcpt = readReceipt("ziggy");
+    expect(rcpt).toMatchObject({ agent: "ziggy", userId: "999", preexisting: false });
+    expect(rcpt.addedAt).toBe("2026-08-18T00:00:00.000Z");
+    expect(Date.parse(rcpt.expiresAt) - now).toBe(DEFAULT_TTL_MS);
+  });
+
+  it("creates access.json when none exists yet", () => {
+    mkAgentDir("newbie");
+    const r = addToAllowlist("newbie", "42", { agentsDir });
+    expect(r.added).toBe(true);
+    expect(readAccess("newbie").allowFrom).toEqual(["42"]);
+  });
+
+  it("is a no-op with preexisting:true when the id is already allowlisted", () => {
+    seedAccess("ziggy", { allowFrom: ["999"] });
+    const r = addToAllowlist("ziggy", "999", { agentsDir });
+    expect(r.added).toBe(false);
+    expect(r.preexisting).toBe(true);
+    // access.json unchanged; receipt records preexisting so revert won't strip it.
+    expect(readAccess("ziggy").allowFrom).toEqual(["999"]);
+    expect(readReceipt("ziggy").preexisting).toBe(true);
+  });
+
+  it("a second add is a no-op preserving the original receipt", () => {
+    seedAccess("ziggy", { allowFrom: [] });
+    const first = addToAllowlist("ziggy", "999", { agentsDir, now: () => 1000 });
+    const second = addToAllowlist("ziggy", "999", { agentsDir, now: () => 5000 });
+    expect(first.added).toBe(true);
+    expect(second.added).toBe(false);
+    // original addedAt preserved (not re-stamped to 5000).
+    expect(readReceipt("ziggy").addedAt).toBe(new Date(1000).toISOString());
+  });
+});
+
+describe("removeFromAllowlist", () => {
+  it("reverts an id the UAT added and clears the receipt", () => {
+    seedAccess("ziggy", { allowFrom: ["111"] });
+    addToAllowlist("ziggy", "999", { agentsDir });
+    expect(readAccess("ziggy").allowFrom).toEqual(["111", "999"]);
+
+    const r = removeFromAllowlist("ziggy", { agentsDir });
+    expect(r.reverted).toBe(true);
+    expect(r.receiptCleared).toBe(true);
+    expect(readAccess("ziggy").allowFrom).toEqual(["111"]);
+    expect(existsSync(receiptPath(agentsDir, "ziggy"))).toBe(false);
+  });
+
+  it("does NOT strip a preexisting id, but clears the receipt", () => {
+    seedAccess("ziggy", { allowFrom: ["999"] });
+    addToAllowlist("ziggy", "999", { agentsDir }); // preexisting
+    const r = removeFromAllowlist("ziggy", { agentsDir });
+    expect(r.reverted).toBe(false);
+    expect(r.reason).toBe("preexisting");
+    expect(r.receiptCleared).toBe(true);
+    expect(readAccess("ziggy").allowFrom).toEqual(["999"]);
+    expect(existsSync(receiptPath(agentsDir, "ziggy"))).toBe(false);
+  });
+
+  it("no-ops with no-receipt when there is nothing to revert", () => {
+    seedAccess("ziggy", { allowFrom: ["111"] });
+    const r = removeFromAllowlist("ziggy", { agentsDir });
+    expect(r.reverted).toBe(false);
+    expect(r.reason).toBe("no-receipt");
+    expect(readAccess("ziggy").allowFrom).toEqual(["111"]);
+  });
+
+  it("is idempotent — a second remove after revert is a no-op", () => {
+    seedAccess("ziggy", { allowFrom: [] });
+    addToAllowlist("ziggy", "999", { agentsDir });
+    removeFromAllowlist("ziggy", { agentsDir });
+    const second = removeFromAllowlist("ziggy", { agentsDir });
+    expect(second.reverted).toBe(false);
+    expect(second.reason).toBe("no-receipt");
+  });
+
+  it("handles a receipt whose id was already manually removed", () => {
+    seedAccess("ziggy", { allowFrom: [] });
+    addToAllowlist("ziggy", "999", { agentsDir });
+    // someone else stripped the id out of band.
+    seedAccess("ziggy", { allowFrom: [] });
+    const r = removeFromAllowlist("ziggy", { agentsDir });
+    expect(r.reverted).toBe(false);
+    expect(r.reason).toBe("not-present");
+    expect(r.receiptCleared).toBe(true);
+  });
+});
+
+describe("sweepAllowlist", () => {
+  it("reverts every agent's receipt and is idempotent on a clean second pass", () => {
+    seedAccess("a", { allowFrom: [] });
+    seedAccess("b", { allowFrom: ["7"] });
+    addToAllowlist("a", "999", { agentsDir });
+    addToAllowlist("b", "888", { agentsDir });
+
+    const first = sweepAllowlist({ agentsDir });
+    expect(first.map((r) => r.agent).sort()).toEqual(["a", "b"]);
+    expect(first.every((r) => r.reverted)).toBe(true);
+    expect(readAccess("a").allowFrom).toEqual([]);
+    expect(readAccess("b").allowFrom).toEqual(["7"]);
+
+    const second = sweepAllowlist({ agentsDir });
+    expect(second).toEqual([]);
+  });
+
+  it("with expiredOnly, leaves un-expired receipts alone", () => {
+    seedAccess("a", { allowFrom: [] });
+    seedAccess("b", { allowFrom: [] });
+    const t0 = Date.parse("2026-08-18T00:00:00.000Z");
+    addToAllowlist("a", "111", { agentsDir, now: () => t0, ttlMs: 1000 });
+    addToAllowlist("b", "222", { agentsDir, now: () => t0, ttlMs: 60 * 60 * 1000 });
+
+    // 2s later: a's receipt (ttl 1s) is expired, b's (ttl 1h) is not.
+    const swept = sweepAllowlist({ agentsDir, expiredOnly: true, now: () => t0 + 2000 });
+    expect(swept.map((r) => r.agent)).toEqual(["a"]);
+    expect(readAccess("a").allowFrom).toEqual([]);
+    // b untouched.
+    expect(readAccess("b").allowFrom).toEqual(["222"]);
+    expect(existsSync(receiptPath(agentsDir, "b"))).toBe(true);
+  });
+
+  it("returns empty on a missing agents dir", () => {
+    expect(sweepAllowlist({ agentsDir: join(root, "nope") })).toEqual([]);
+  });
+});
+
+describe("runAllowlistCli", () => {
+  it("add then remove --sweep round-trips to zero residue", () => {
+    seedAccess("ziggy", { allowFrom: ["1"] });
+    expect(runAllowlistCli(["add", "ziggy", "999", "--agents-dir", agentsDir])).toBe(0);
+    expect(readAccess("ziggy").allowFrom).toEqual(["1", "999"]);
+
+    expect(runAllowlistCli(["remove", "--sweep", "--agents-dir", agentsDir])).toBe(0);
+    expect(readAccess("ziggy").allowFrom).toEqual(["1"]);
+    expect(existsSync(receiptPath(agentsDir, "ziggy"))).toBe(false);
+  });
+
+  it("add without a userId is a usage error (exit 1)", () => {
+    expect(runAllowlistCli(["add", "ziggy", "--agents-dir", agentsDir])).toBe(1);
+  });
+
+  it("unknown command is exit 1; bare invocation is exit 0", () => {
+    expect(runAllowlistCli(["frobnicate"])).toBe(1);
+    expect(runAllowlistCli([])).toBe(0);
+  });
+});