switchroom 0.19.48 → 0.20.1

package/telegram-plugin/tests/ipc-server-buzz-peer.test.ts

@@ -0,0 +1,269 @@
+import { describe, it, expect, afterEach, vi } from "vitest";
+import { mkdtempSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import { createConnection, type Socket } from "net";
+import { createIpcServer, type IpcServer, type IpcClient } from "../gateway/ipc-server.js";
+import type { OutboundToBuzzMessage } from "../gateway/ipc-protocol.js";
+
+/**
+ * Buzz co-channel Phase 2b — S7 role-disjointness, enforced as a GATEWAY CODE
+ * mechanism (not sidecar self-discipline). These are real-Unix-socket tests: a
+ * raw net client sends hand-crafted frames so we can exercise the adversarial
+ * orderings a well-behaved sidecar would never emit.
+ *
+ * The invariants (ipc-server.ts handleHelloBuzzPeer / handleRegister):
+ *   - a hello_buzz_peer parks the connection as the single Buzz peer, NEVER in
+ *     agentIndex (getClient stays undefined; the peer's agentName is null);
+ *   - register on a peer connection is refused (close+drop);
+ *   - hello on an already-registered connection is refused (close+drop);
+ *   - the peer rides the watchdog's agentName===null exemption (never evicted);
+ *   - the peer slot is released on disconnect (identity-checked).
+ */
+
+function tmpSocket(): string {
+  const dir = mkdtempSync(join(tmpdir(), "ipc-buzz-peer-"));
+  return join(dir, "test.sock");
+}
+function wait(ms: number): Promise<void> {
+  return new Promise((r) => setTimeout(r, ms));
+}
+const OUTBOUND: OutboundToBuzzMessage = {
+  type: "outbound_to_buzz",
+  correlationId: "c1",
+  agentName: "klanker",
+  channelId: "chan",
+  payload: { kind: "message", text: "x" },
+};
+
+describe("ipc-server — Buzz peer role-disjointness (S7)", () => {
+  const servers: IpcServer[] = [];
+  const sockets: Socket[] = [];
+
+  afterEach(async () => {
+    for (const s of sockets) { try { s.destroy(); } catch { /* ignore */ } }
+    sockets.length = 0;
+    for (const srv of servers) await srv.close();
+    servers.length = 0;
+  });
+
+  function makeServer(overrides: Partial<Parameters<typeof createIpcServer>[0]> = {}) {
+    const registered: IpcClient[] = [];
+    const server = createIpcServer({
+      socketPath: overrides.socketPath ?? tmpSocket(),
+      onClientRegistered: (c) => registered.push(c),
+      onClientDisconnected: () => {},
+      onToolCall: async (_c, m) => ({ type: "tool_call_result", id: m.id, success: true }),
+      onSessionEvent: () => {},
+      onPermissionRequest: () => {},
+      onHeartbeat: () => {},
+      onScheduleRestart: () => {},
+      ...overrides,
+    });
+    servers.push(server);
+    return { server, registered };
+  }
+
+  /** Open a raw client, resolve once connected. Detects server-side close. */
+  function rawClient(socketPath: string) {
+    const sock = createConnection(socketPath);
+    sockets.push(sock);
+    let closedByServer = false;
+    sock.on("close", () => { closedByServer = true; });
+    sock.on("error", () => { /* server may reset on refuse */ });
+    const send = (obj: unknown) => sock.write(JSON.stringify(obj) + "\n");
+    const ready = new Promise<void>((res) => sock.on("connect", () => res()));
+    return { sock, send, ready, wasClosed: () => closedByServer };
+  }
+
+  it("parks a hello_buzz_peer as the Buzz peer, NOT in agentIndex", async () => {
+    const path = tmpSocket();
+    const { server } = makeServer({ socketPath: path });
+    const c = rawClient(path);
+    await c.ready;
+    c.send({ type: "hello_buzz_peer", agentName: "klanker" });
+    await wait(60);
+
+    // Addressable as the peer, but never as an agent bridge.
+    expect(server.sendToBuzzPeer(OUTBOUND)).toBe(true);
+    expect(server.getClient("klanker")).toBeUndefined();
+  });
+
+  it("REFUSES a register after hello_buzz_peer (peer must never claim a slot)", async () => {
+    const path = tmpSocket();
+    const { server } = makeServer({ socketPath: path });
+    const c = rawClient(path);
+    await c.ready;
+    c.send({ type: "hello_buzz_peer", agentName: "klanker" });
+    await wait(40);
+    c.send({ type: "register", agentName: "klanker" });
+    await wait(80);
+
+    // The offending connection was closed+dropped; no agent slot was created.
+    expect(c.wasClosed()).toBe(true);
+    expect(server.getClient("klanker")).toBeUndefined();
+  });
+
+  it("REFUSES a hello_buzz_peer after register (bridge must never become the peer)", async () => {
+    const path = tmpSocket();
+    const { server } = makeServer({ socketPath: path });
+    const c = rawClient(path);
+    await c.ready;
+    c.send({ type: "register", agentName: "klanker" });
+    await wait(40);
+    expect(server.getClient("klanker")).toBeDefined(); // registered as a bridge
+    c.send({ type: "hello_buzz_peer", agentName: "klanker" });
+    await wait(80);
+
+    // The connection is closed+dropped; no Buzz peer was installed.
+    expect(c.wasClosed()).toBe(true);
+    expect(server.sendToBuzzPeer(OUTBOUND)).toBe(false);
+  });
+
+  it("EXEMPTS the peer from the heartbeat watchdog (agentName===null)", async () => {
+    const path = tmpSocket();
+    // Aggressive watchdog: 200ms timeout, no heartbeats from the peer.
+    const { server } = makeServer({ socketPath: path, heartbeatTimeoutMs: 200 });
+    const c = rawClient(path);
+    await c.ready;
+    c.send({ type: "hello_buzz_peer", agentName: "klanker" });
+    await wait(60);
+    expect(server.sendToBuzzPeer(OUTBOUND)).toBe(true);
+
+    // Well past the timeout with no heartbeat — a registered bridge would be
+    // evicted, but the peer (agentName===null) is exempt and survives.
+    await wait(500);
+    expect(c.wasClosed()).toBe(false);
+    expect(server.sendToBuzzPeer(OUTBOUND)).toBe(true);
+  });
+
+  it("releases the peer slot on disconnect (sendToBuzzPeer → false)", async () => {
+    const path = tmpSocket();
+    const { server } = makeServer({ socketPath: path });
+    const c = rawClient(path);
+    await c.ready;
+    c.send({ type: "hello_buzz_peer", agentName: "klanker" });
+    await wait(60);
+    expect(server.sendToBuzzPeer(OUTBOUND)).toBe(true);
+
+    c.sock.destroy();
+    await wait(100);
+    expect(server.sendToBuzzPeer(OUTBOUND)).toBe(false);
+  });
+
+  it("forwards outbound_to_buzz to the peer and delivers buzz_publish_result to the handler", async () => {
+    const path = tmpSocket();
+    const onBuzzPublishResult = vi.fn();
+    const { server } = makeServer({ socketPath: path, onBuzzPublishResult });
+    const c = rawClient(path);
+    const received: unknown[] = [];
+    c.sock.on("data", (d: Buffer) => {
+      for (const line of d.toString().split("\n")) {
+        if (line.trim()) received.push(JSON.parse(line));
+      }
+    });
+    await c.ready;
+    c.send({ type: "hello_buzz_peer", agentName: "klanker" });
+    await wait(60);
+
+    // Hub → peer.
+    expect(server.sendToBuzzPeer(OUTBOUND)).toBe(true);
+    await wait(40);
+    expect(received).toContainEqual(expect.objectContaining({ type: "outbound_to_buzz", correlationId: "c1" }));
+
+    // Peer → hub.
+    c.send({ type: "buzz_publish_result", correlationId: "c1", ok: true, eventId: "evt-x" });
+    await wait(60);
+    expect(onBuzzPublishResult).toHaveBeenCalledTimes(1);
+    expect(onBuzzPublishResult.mock.calls[0][1]).toMatchObject({ correlationId: "c1", ok: true, eventId: "evt-x" });
+  });
+
+  // ── MAJOR-1a: confused-deputy close on the agent→peer surface ─────────────
+  it("IGNORES buzz_publish_result from a NON-peer connection (MAJOR-1a)", async () => {
+    const path = tmpSocket();
+    const onBuzzPublishResult = vi.fn();
+    makeServer({ socketPath: path, onBuzzPublishResult });
+
+    // (1) A fresh anonymous client that never announced hello_buzz_peer forges a
+    // publish result carrying a valid-looking correlationId + a foreign eventId.
+    const impostor = rawClient(path);
+    await impostor.ready;
+    impostor.send({ type: "buzz_publish_result", correlationId: "forged-1", ok: true, eventId: "attacker-evt" });
+    await wait(80);
+    expect(onBuzzPublishResult).not.toHaveBeenCalled();
+
+    // (2) A registered AGENT bridge (also not the peer) is likewise refused.
+    const bridge = rawClient(path);
+    await bridge.ready;
+    bridge.send({ type: "register", agentName: "klanker" });
+    await wait(40);
+    bridge.send({ type: "buzz_publish_result", correlationId: "forged-2", ok: true, eventId: "attacker-evt-2" });
+    await wait(80);
+    expect(onBuzzPublishResult).not.toHaveBeenCalled();
+
+    // (3) Contrast — the REAL peer's result DOES reach the handler, proving the
+    // guard blocks impostors specifically, not the mechanism wholesale.
+    const peer = rawClient(path);
+    await peer.ready;
+    peer.send({ type: "hello_buzz_peer", agentName: "klanker" });
+    await wait(40);
+    peer.send({ type: "buzz_publish_result", correlationId: "real-1", ok: true, eventId: "evt-real" });
+    await wait(80);
+    expect(onBuzzPublishResult).toHaveBeenCalledTimes(1);
+    expect(onBuzzPublishResult.mock.calls[0][1]).toMatchObject({ correlationId: "real-1" });
+  });
+
+  // ── MAJOR-1b: a fresh hello cannot displace a LIVE peer ───────────────────
+  it("REFUSES a second hello_buzz_peer while a LIVE peer is connected (MAJOR-1b)", async () => {
+    const path = tmpSocket();
+    const onBuzzPublishResult = vi.fn();
+    const { server } = makeServer({ socketPath: path, onBuzzPublishResult });
+
+    const peer1 = rawClient(path);
+    await peer1.ready;
+    peer1.send({ type: "hello_buzz_peer", agentName: "klanker" });
+    await wait(60);
+    expect(server.sendToBuzzPeer(OUTBOUND)).toBe(true);
+
+    // An impostor tries to seize the peer slot with a fresh hello, then forge a
+    // publish result — the attack that would poison msgToBuzz.
+    const impostor = rawClient(path);
+    await impostor.ready;
+    impostor.send({ type: "hello_buzz_peer", agentName: "klanker" });
+    await wait(60);
+    impostor.send({ type: "buzz_publish_result", correlationId: "forged", ok: true, eventId: "attacker-evt" });
+    await wait(80);
+
+    // The impostor was refused (close+drop); the real peer is UNDISTURBED and
+    // still the addressed peer; the forged result never reached the handler.
+    expect(impostor.wasClosed()).toBe(true);
+    expect(peer1.wasClosed()).toBe(false);
+    expect(server.sendToBuzzPeer(OUTBOUND)).toBe(true);
+    expect(onBuzzPublishResult).not.toHaveBeenCalled();
+  });
+
+  it("ALLOWS a legitimate reconnect after the prior peer connection CLOSES (MAJOR-1b)", async () => {
+    const path = tmpSocket();
+    const { server } = makeServer({ socketPath: path });
+
+    const peer1 = rawClient(path);
+    await peer1.ready;
+    peer1.send({ type: "hello_buzz_peer", agentName: "klanker" });
+    await wait(60);
+    expect(server.sendToBuzzPeer(OUTBOUND)).toBe(true);
+
+    // The sidecar's socket drops (crash/restart); removeClient nulls the slot.
+    peer1.sock.destroy();
+    await wait(120);
+    expect(server.sendToBuzzPeer(OUTBOUND)).toBe(false);
+
+    // A fresh reconnect + hello must succeed — the refuse-only-while-alive rule
+    // must not brick a real reconnect.
+    const peer2 = rawClient(path);
+    await peer2.ready;
+    peer2.send({ type: "hello_buzz_peer", agentName: "klanker" });
+    await wait(60);
+    expect(peer2.wasClosed()).toBe(false);
+    expect(server.sendToBuzzPeer(OUTBOUND)).toBe(true);
+  });
+});

package/telegram-plugin/tests/operator-events-session-tail.test.ts

@@ -107,6 +107,42 @@ describe('detectErrorInTranscriptLine — error detection', () => {
     expect(result!.terminal).toBe(true)
   })
 
+  it('marks an in-flight transport-transient retry NOT terminal (does not count toward escalation)', () => {
+    // A flaky request Claude Code is internally retrying (retryAttempt <
+    // maxRetries), surfaced as a bare `server_error` with no status. Pre-fix
+    // `transient` was false for transport-transient, so it was UNCONDITIONALLY
+    // terminal → a single recoverable request retried 3x could cross the ≥3
+    // escalation threshold and fire the operator "Repeated stream failures"
+    // card. It must be transient + in-flight (suppressed), counting nothing.
+    const line = JSON.stringify({
+      type: 'system',
+      subtype: 'api_error',
+      error: { type: 'server_error', message: 'Connection closed mid-response' },
+      retryAttempt: 2,
+      maxRetries: 10,
+    })
+    const result = detectErrorInTranscriptLine(line)
+    expect(result!.kind).toBe('transport-transient')
+    expect(result!.transient).toBe(true)
+    // 2 < 10 — still retrying → in-flight → the caller suppresses it (not counted).
+    expect(result!.terminal).toBe(false)
+  })
+
+  it('marks an exhausted transport-transient retry terminal (counts toward escalation)', () => {
+    const line = JSON.stringify({
+      type: 'system',
+      subtype: 'api_error',
+      error: { type: 'server_error', message: 'Connection closed mid-response' },
+      retryAttempt: 10,
+      maxRetries: 10,
+    })
+    const result = detectErrorInTranscriptLine(line)
+    expect(result!.kind).toBe('transport-transient')
+    expect(result!.transient).toBe(true)
+    // retries exhausted → terminal → escalates.
+    expect(result!.terminal).toBe(true)
+  })
+
   it('marks non-transient errors terminal (always escalate)', () => {
     const line = JSON.stringify({
       type: 'api_error',
@@ -156,6 +192,33 @@ describe('detectErrorInTranscriptLine — error detection', () => {
     expect(result!.detail).toContain('hit your limit')
   })
 
+  // Regression — the transport-abort bug this PR fixes. On a mid-response stream
+  // abort Claude Code emits `isApiErrorMessage:true` with `error:"server_error"`
+  // and NO `apiErrorStatus`. Pre-fix that had no transport branch and fell
+  // through to the status fallback, FABRICATING `unknown-4xx` — a card carrying a
+  // wrong Reauth button, broadcast to every chat. It must classify
+  // transport-transient (terminal, non-transient) instead.
+  it('classifies the verbatim server_error mid-stream abort as transport-transient (not unknown-4xx)', () => {
+    // The exact on-disk shape: isApiErrorMessage, error "server_error", NO status.
+    const line = JSON.stringify({
+      type: 'assistant',
+      message: {
+        role: 'assistant',
+        model: '<synthetic>',
+        content: [{ type: 'text', text: 'API Error: Connection closed mid-response' }],
+      },
+      error: 'server_error',
+      isApiErrorMessage: true,
+    })
+    const result = detectErrorInTranscriptLine(line)
+    expect(result).not.toBeNull()
+    expect(result!.kind).toBe('transport-transient')
+    expect(result!.kind).not.toBe('unknown-4xx')
+    // Claude writes this shape only after its own retries are exhausted → terminal.
+    expect(result!.terminal).toBe(true)
+    expect(result!.transient).toBe(false)
+  })
+
   // Regression — the carrie incident (2026-07-12). Anthropic also emits a
   // 429 for a TRANSIENT per-account burst / RPM throttle whose wording
   // explicitly negates the account-quota reading ("would exceed your

package/telegram-plugin/tests/operator-events.test.ts

@@ -142,13 +142,61 @@ describe('classifyClaudeError — safety: must never throw', () => {
   }
 })
 
-describe('classifyClaudeError — unknown-4xx is the default fallback', () => {
-  it('unknown object with no status defaults to unknown-4xx', () => {
-    expect(classifyClaudeError({ totally: 'unrecognised' })).toBe('unknown-4xx')
+describe('classifyClaudeError — no-status default is the neutral 5xx (never a fabricated 4xx)', () => {
+  it('unknown object with no status defaults to unknown-5xx, NOT unknown-4xx', () => {
+    // Regression: an unrecognized shape with no HTTP status used to fabricate
+    // `unknown-4xx`, whose card carried a wrong Reauth remedy broadcast to every
+    // chat. With no status the honest neutral default is unknown-5xx.
+    expect(classifyClaudeError({ totally: 'unrecognised' })).toBe('unknown-5xx')
+    expect(classifyClaudeError({ totally: 'unrecognised' })).not.toBe('unknown-4xx')
   })
 
-  it('empty string → unknown-4xx', () => {
-    expect(classifyClaudeError('')).toBe('unknown-4xx')
+  it('empty string → unknown-5xx', () => {
+    expect(classifyClaudeError('')).toBe('unknown-5xx')
+  })
+
+  it('still honors an explicit 4xx status', () => {
+    expect(classifyClaudeError({ status: 404 })).toBe('unknown-4xx')
+  })
+})
+
+describe('classifyClaudeError — transport-transient (mid-response stream abort)', () => {
+  it('classifies a bare server_error type as transport-transient', () => {
+    expect(classifyClaudeError({ type: 'server_error' })).toBe('transport-transient')
+  })
+
+  it('classifies server_error via error_code / code / nested error.type', () => {
+    expect(classifyClaudeError({ error_code: 'server_error' })).toBe('transport-transient')
+    expect(classifyClaudeError({ code: 'server_error' })).toBe('transport-transient')
+    expect(classifyClaudeError({ error: { type: 'server_error' } })).toBe('transport-transient')
+  })
+
+  it('classifies api_error (Anthropic HTTP 500) as transport-transient', () => {
+    expect(classifyClaudeError({ type: 'api_error' })).toBe('transport-transient')
+  })
+
+  it('classifies api_error/server_error carrying a 5xx status as transport-transient', () => {
+    expect(classifyClaudeError({ type: 'api_error', status: 500 })).toBe('transport-transient')
+    expect(classifyClaudeError({ type: 'server_error', status: 503 })).toBe('transport-transient')
+  })
+
+  it('does NOT swallow a status-bearing 4xx api_error (LiteLLM-wrapped 401) as transport-transient', () => {
+    // LiteLLM stamps a generic `type: "api_error"` on WRAPPED upstream faults
+    // that carry a 4xx status; session-tail threads that status through. The
+    // transport branch is guarded to status-less/5xx shapes, so the HTTP status
+    // wins and this surfaces an operator card (unknown-4xx) — NOT the silent
+    // transport-transient path. Branch-order regression guard: unlike the bare
+    // `{status:404}` test above, this exercises a TYPED api_error + 4xx status.
+    expect(classifyClaudeError({ type: 'api_error', status: 401 })).toBe('unknown-4xx')
+    expect(classifyClaudeError({ type: 'api_error', status: 401 })).not.toBe('transport-transient')
+    expect(classifyClaudeError({ type: 'server_error', status: 429 })).toBe('unknown-4xx')
+  })
+
+  it('does NOT fire on an unrelated error that merely mentions "server error" in prose', () => {
+    // Exact type/code equality only — never a message substring — so a genuine
+    // auth fault mislabeled with server-error prose still classifies as auth.
+    expect(classifyClaudeError({ type: 'authentication_error', message: 'server error while validating' }))
+      .toBe('credentials-invalid')
   })
 })
 
@@ -238,10 +286,25 @@ describe('renderOperatorEvent — agent-restarted-unexpectedly', () => {
 })
 
 describe('renderOperatorEvent — unknown-4xx', () => {
-  it('surfaces "API error (4xx)" with dismiss button', () => {
+  it('surfaces "API error (4xx)" with a Dismiss button and NO Reauth button', () => {
     const { text, keyboard } = renderOperatorEvent(makeEvent('unknown-4xx'))
     expect(text).toContain('4xx')
-    expect(keyboard.inline_keyboard.flat().some(b => b.callback_data?.includes('dismiss'))).toBe(true)
+    const buttons = keyboard.inline_keyboard.flat()
+    expect(buttons.some(b => b.callback_data?.includes('dismiss'))).toBe(true)
+    // Reauth was REMOVED — it is the wrong remedy for a catch-all client error,
+    // and Reauth buttons now live ONLY on credentials-* cards. Assert the OUTCOME.
+    expect(buttons.some(b => b.callback_data?.includes('op:reauth'))).toBe(false)
+    expect(buttons.some(b => b.callback_data?.includes('reauth'))).toBe(false)
+  })
+})
+
+describe('renderOperatorEvent — transport-transient (defensive fallback)', () => {
+  it('is calm and Dismiss-only — NEVER a Reauth button', () => {
+    const { text, keyboard } = renderOperatorEvent(makeEvent('transport-transient'))
+    expect(text).toContain('transport')
+    const buttons = keyboard.inline_keyboard.flat()
+    expect(buttons.some(b => b.callback_data?.includes('dismiss'))).toBe(true)
+    expect(buttons.some(b => b.callback_data?.includes('reauth'))).toBe(false)
   })
 })
 
@@ -289,6 +352,7 @@ describe('renderOperatorEvent — all kinds produce valid keyboard structure', (
     'rate-limited',
     'agent-crashed',
     'agent-restarted-unexpectedly',
+    'transport-transient',
     'unknown-4xx',
     'unknown-5xx',
     'config-warning',

package/telegram-plugin/tests/outbound-send-path.test.ts

@@ -18,6 +18,7 @@ import {
   computeReplyChunks,
   resplitOversizeChunk,
   chunkText,
+  resolveMirrorAntecedentKey,
 } from '../gateway/outbound-send-path.js'
 
 /**
@@ -413,3 +414,26 @@ describe('outbound-send-path — temporal pass wiring (#3501)', () => {
     expect(viaSeam).toBe(viaModule)
   })
 })
+
+// ── Buzz-mirror antecedent gating (#4300 / #4301) ──────────────────────────
+describe('resolveMirrorAntecedentKey — Buzz-mirror antecedent gating', () => {
+  it('#4300: replyMode "off" stamps NO antecedent → Buzz mirror stays flat', () => {
+    // With reply-mode off the Telegram copy renders no reply, so the Buzz copy
+    // must not thread either — otherwise the surfaces diverge.
+    expect(resolveMirrorAntecedentKey('555', 100, 'off')).toBeUndefined()
+  })
+
+  it('stamps the antecedent for reply-rendering modes (first / all)', () => {
+    expect(resolveMirrorAntecedentKey('555', 100, 'first')).toBe('555:100')
+    expect(resolveMirrorAntecedentKey('555', 100, 'all')).toBe('555:100')
+  })
+
+  it('#4301: a non-numeric reply_to (NaN) stamps NO antecedent (no chat:NaN key)', () => {
+    expect(resolveMirrorAntecedentKey('555', Number('not-a-number'), 'first')).toBeUndefined()
+    expect(resolveMirrorAntecedentKey('555', NaN, 'all')).toBeUndefined()
+  })
+
+  it('stamps NO antecedent when there is no reply_to', () => {
+    expect(resolveMirrorAntecedentKey('555', undefined, 'first')).toBeUndefined()
+  })
+})