switchroom 0.13.35 → 0.13.36

package/telegram-plugin/dist/gateway/gateway.js

@@ -25292,6 +25292,39 @@ function parseDriveScope(scope) {
   return { action, target: { kind: "doc", doc_id: rest } };
 }
 
+// gateway/oversize-card-body.ts
+function truncateRawToFit(input) {
+  const { raw, render, cap, sentinel } = input;
+  const hardLimit = input.hardLimit ?? cap + 196;
+  const fullBody = render(raw);
+  if (fullBody.length <= cap) {
+    return { body: fullBody, truncated: false };
+  }
+  let lo = 0;
+  let hi = raw.length;
+  let bestSliceLen = 0;
+  while (lo <= hi) {
+    const mid = lo + hi >>> 1;
+    const candidate = raw.slice(0, mid) + sentinel;
+    if (render(candidate).length <= cap) {
+      bestSliceLen = mid;
+      lo = mid + 1;
+    } else {
+      hi = mid - 1;
+    }
+  }
+  let chosenRaw = raw.slice(0, bestSliceLen);
+  const lastNl = chosenRaw.lastIndexOf(`
+`);
+  if (lastNl > 0)
+    chosenRaw = chosenRaw.slice(0, lastNl);
+  let body = render(chosenRaw + sentinel);
+  if (body.length > hardLimit) {
+    body = body.slice(0, hardLimit - 1);
+  }
+  return { body, truncated: true };
+}
+
 // secret-detect/suppressor.ts
 function isSuppressed(text, start, end) {
   const left = Math.max(0, start - WINDOW);
@@ -29060,49 +29093,90 @@ var init_materialize_bot_token = __esm(() => {
 // gateway/config-approval-handler.ts
 var exports_config_approval_handler = {};
 __export(exports_config_approval_handler, {
+  truncateDiffForCard: () => truncateDiffForCard,
   resolvePendingConfigApproval: () => resolvePendingConfigApproval,
   parseConfigApprovalCallback: () => parseConfigApprovalCallback,
   handleRequestConfigFinalize: () => handleRequestConfigFinalize,
   handleRequestConfigApproval: () => handleRequestConfigApproval,
   buildConfigApprovalCardBody: () => buildConfigApprovalCardBody,
   _resetPendingConfigApprovalsForTest: () => _resetPendingConfigApprovalsForTest,
-  _peekPendingConfigApprovalForTest: () => _peekPendingConfigApprovalForTest
+  _peekPendingConfigApprovalForTest: () => _peekPendingConfigApprovalForTest,
+  DIFF_SENTINEL: () => DIFF_SENTINEL
 });
+function truncateDiffForCard(unifiedDiff, maxLines = 50, maxChars = 3000) {
+  const sentinel = `
+[\u2026 diff continues, see attached file]`;
+  const lines = unifiedDiff.split(`
+`);
+  let out;
+  if (lines.length <= maxLines) {
+    out = unifiedDiff;
+  } else {
+    out = lines.slice(0, maxLines).join(`
+`);
+  }
+  if (out.length > maxChars) {
+    const cap = out.slice(0, maxChars);
+    const lastNl = cap.lastIndexOf(`
+`);
+    out = lastNl > 0 ? cap.slice(0, lastNl) : cap;
+  }
+  return out === unifiedDiff ? out : out + sentinel;
+}
+function escapeHtml11(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function clipReason(reason) {
+  if (reason.length <= REASON_MAX_CHARS)
+    return reason;
+  return reason.slice(0, REASON_MAX_CHARS - REASON_ELLIPSIS.length) + REASON_ELLIPSIS;
+}
 function buildConfigApprovalCardBody(args) {
-  const esc = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-  return `\uD83D\uDEE0 <b>Config edit proposed</b>
-` + `Agent: <code>${esc(args.agentName)}</code>
-` + `Reason: ${esc(args.reason)}
-
-` + `<pre>${esc(args.unifiedDiff)}</pre>`;
+  const safeReason = clipReason(args.reason);
+  const render = (diff) => `\uD83D\uDEE0 <b>Config edit proposed</b>
+` + `Agent: <code>${escapeHtml11(args.agentName)}</code>
+` + `Reason: ${escapeHtml11(safeReason)}
+
+` + `<pre>${escapeHtml11(diff)}</pre>`;
+  return truncateRawToFit({
+    raw: args.unifiedDiff,
+    render,
+    cap: RENDERED_BODY_CAP2,
+    sentinel: DIFF_SENTINEL,
+    hardLimit: TELEGRAM_SENDMESSAGE_LIMIT2
+  });
 }
 async function handleRequestConfigApproval(client3, msg, deps) {
-  const reply = (verdict, reason) => {
+  const reply = (verdict, reason, denySource) => {
     try {
       client3.send({
         type: "config_approval_resolved",
         requestId: msg.requestId,
         verdict,
-        ...reason ? { reason } : {}
+        ...reason ? { reason } : {},
+        ...denySource ? { denySource } : {}
       });
     } catch (err) {
       deps.log?.(`config_approval_resolved send failed (requestId=${msg.requestId}): ${err.message}`);
     }
   };
   if (msg.agentName !== deps.agentName) {
-    reply("deny", `gateway serves '${deps.agentName}', not '${msg.agentName}'`);
+    reply("deny", `gateway serves '${deps.agentName}', not '${msg.agentName}'`, "dispatch_failure");
     return;
   }
   const target = deps.loadTargetChat();
   if (target === null) {
-    reply("deny", "no target chat available \u2014 operator not paired?");
+    reply("deny", "no target chat available \u2014 operator not paired?", "dispatch_failure");
     return;
   }
-  const body = buildConfigApprovalCardBody({
+  const prelim = truncateDiffForCard(msg.unifiedDiff);
+  const built = buildConfigApprovalCardBody({
     agentName: msg.agentName,
     reason: msg.reason,
-    unifiedDiff: msg.unifiedDiff
+    unifiedDiff: prelim
   });
+  const body = built.body;
+  const oversize = prelim !== msg.unifiedDiff || built.truncated;
   const replyMarkup = deps.buildKeyboard(msg.requestId);
   const posted = await deps.postCard({
     chatId: target.chatId,
@@ -29111,9 +29185,12 @@ async function handleRequestConfigApproval(client3, msg, deps) {
     replyMarkup
   });
   if (posted === null) {
-    reply("deny", "Telegram sendMessage failed");
+    reply("deny", "Telegram sendMessage failed", "dispatch_failure");
     return;
   }
+  if (oversize) {
+    await maybePostAttachment(deps, target, msg);
+  }
   const entry = {
     requestId: msg.requestId,
     client: client3,
@@ -29179,8 +29256,21 @@ ${escapeHtml11(msg.detail)}` : ""}`;
     deps.log?.(`config finalize card edit failed (requestId=${msg.requestId}): ${err.message}`);
   }
 }
-function escapeHtml11(s) {
-  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+async function maybePostAttachment(deps, target, msg) {
+  if (deps.postAttachment === undefined) {
+    deps.log?.(`oversize config approval card but no postAttachment dep wired (requestId=${msg.requestId})`);
+    return;
+  }
+  try {
+    await deps.postAttachment({
+      chatId: target.chatId,
+      ...target.threadId !== undefined ? { threadId: target.threadId } : {},
+      filename: `config-edit-${msg.requestId}.patch`,
+      content: msg.unifiedDiff
+    });
+  } catch (err) {
+    deps.log?.(`config approval attachment failed (requestId=${msg.requestId}): ${err.message}`);
+  }
 }
 function _resetPendingConfigApprovalsForTest() {
   for (const entry of pending.values()) {
@@ -29207,7 +29297,8 @@ function parseConfigApprovalCallback(data) {
     return null;
   return { requestId, choice };
 }
-var pending;
+var pending, TELEGRAM_SENDMESSAGE_LIMIT2 = 4096, RENDERED_BODY_CAP2 = 3900, REASON_MAX_CHARS = 500, REASON_ELLIPSIS = "\u2026", DIFF_SENTINEL = `
+[\u2026 diff continues, see attached file]`;
 var init_config_approval_handler = __esm(() => {
   pending = new Map;
 });
@@ -37491,6 +37582,10 @@ function tick2(now) {
       clearPending(key, "timeout");
       continue;
     }
+    if (activeDeps2.isActiveTurnNewerThan != null && activeDeps2.isActiveTurnNewerThan(key, s.activatedAt)) {
+      clearPending(key, "stale_turn");
+      continue;
+    }
     const sinceEdit = s.lastEditAt == null ? 0 : now - s.lastEditAt;
     if (sinceEdit < EDIT_INTERVAL_MS)
       continue;
@@ -44123,6 +44218,10 @@ function validateInput(input) {
 var DEFAULT_TTL_MS = 5 * 60 * 1000;
 var MAX_TTL_MS = 30 * 60 * 1000;
 var MIN_TTL_MS = 30 * 1000;
+var TELEGRAM_SENDMESSAGE_LIMIT = 4096;
+var RENDERED_BODY_CAP = 3900;
+var OVERSIZE_SENTINEL = `
+[\u2026 preview truncated; open in Drive for full context]`;
 async function handleRequestDriveApproval(client3, msg, deps) {
   const reply = (event) => {
     try {
@@ -44198,20 +44297,36 @@ async function handleRequestDriveApproval(client3, msg, deps) {
     });
     return;
   }
+  let cardText = card.text;
+  let truncatedForFit = false;
+  if (cardText.length > RENDERED_BODY_CAP) {
+    const fit = truncateRawToFit({
+      raw: card.text,
+      render: (slice) => slice,
+      cap: RENDERED_BODY_CAP,
+      sentinel: OVERSIZE_SENTINEL,
+      hardLimit: TELEGRAM_SENDMESSAGE_LIMIT
+    });
+    cardText = fit.body;
+    truncatedForFit = fit.truncated;
+  }
   const posted = await deps.postCard({
     chatId: target.chatId,
     ...target.threadId !== undefined ? { threadId: target.threadId } : {},
-    text: card.text,
+    text: cardText,
     replyMarkup: card.reply_markup
   });
   if (posted === null) {
     reply({
       correlationId: msg.correlationId,
       ok: false,
-      reason: "Telegram sendMessage failed"
+      reason: truncatedForFit ? "Telegram sendMessage failed even after oversize-body truncation" : "Telegram sendMessage failed"
     });
     return;
   }
+  if (truncatedForFit) {
+    deps.log?.(`drive_approval_posted oversize-truncated correlation=${msg.correlationId} original_len=${card.text.length} rendered_len=${cardText.length}`);
+  }
   deps.log?.(`drive_approval_posted ok correlation=${msg.correlationId} request_id=${registered.request_id} file=${fileId}`);
   reply({
     correlationId: msg.correlationId,
@@ -44235,10 +44350,10 @@ var REQUEST_ID_RE = /^[0-9a-f]{32}$/;
 var PENDING_FILE_ID_SENTINEL = "pending-create";
 function buildDiffPreviewCard(input) {
   if (!REQUEST_ID_RE.test(input.suggestRequestId)) {
-    throw new Error(`buildDiffPreviewCard: suggestRequestId must be 8 hex chars (got '${input.suggestRequestId}')`);
+    throw new Error(`buildDiffPreviewCard: suggestRequestId must be 32 hex chars (got '${input.suggestRequestId}')`);
   }
   if (input.writeRequestId !== undefined && !REQUEST_ID_RE.test(input.writeRequestId)) {
-    throw new Error(`buildDiffPreviewCard: writeRequestId must be 8 hex chars (got '${input.writeRequestId}')`);
+    throw new Error(`buildDiffPreviewCard: writeRequestId must be 32 hex chars (got '${input.writeRequestId}')`);
   }
   const preview = input.preview;
   const bodyLines = [];
@@ -48556,10 +48671,10 @@ function sweepStaleTurnActiveMarker(stateDir, opts) {
 }
 
 // ../src/build-info.ts
-var VERSION = "0.13.35";
-var COMMIT_SHA = "c41aabe5";
-var COMMIT_DATE = "2026-05-25T01:43:28Z";
-var LATEST_PR = 1765;
+var VERSION = "0.13.36";
+var COMMIT_SHA = "73e8bb05";
+var COMMIT_DATE = "2026-05-25T03:53:49Z";
+var LATEST_PR = 1785;
 var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts
@@ -50465,7 +50580,11 @@ startTimer2({
       ...ctx.threadId != null ? { threadId: ctx.threadId } : {}
     });
   },
-  emitMetric: (event) => emitRuntimeMetric(event)
+  emitMetric: (event) => emitRuntimeMetric(event),
+  isActiveTurnNewerThan: (key, activatedAt) => {
+    const turnStartedAt = activeTurnStartedAt.get(key);
+    return turnStartedAt != null && turnStartedAt > activatedAt;
+  }
 });
 var inboundSpool = STATIC ? undefined : createInboundSpool({
   path: join32(STATE_DIR, "inbound-spool.jsonl"),
@@ -50867,6 +50986,16 @@ ${reminder}
 `);
         }
       },
+      postAttachment: async (args) => {
+        const input = new import_grammy9.InputFile(Buffer.from(args.content, "utf8"), args.filename);
+        await robustApiCall(() => bot.api.sendDocument(args.chatId, input, {
+          ...args.threadId !== undefined ? { message_thread_id: args.threadId } : {}
+        }), {
+          chat_id: String(args.chatId),
+          verb: "config-approval-attachment",
+          ...args.threadId !== undefined ? { threadId: args.threadId } : {}
+        });
+      },
       log: (m) => process.stderr.write(`telegram gateway: config-approval \u2014 ${m}
 `)
     });
@@ -51222,6 +51351,7 @@ ${url}`;
           logOutbound("edit", chat_id, decision.messageId, decision.mergedText.length, "silent-anchor-merge");
           process.stderr.write(`telegram gateway: silent-reply auto-edit \u2014 ` + `chat=${chat_id} anchor=${decision.messageId} merged_len=${decision.mergedText.length}
 `);
+          clearPending(statusKey(chat_id, threadId), "reply_finalize");
           noteOutbound3(statusKey(chat_id, threadId), {
             messageId: decision.messageId,
             text: decision.mergedText,
@@ -51362,6 +51492,7 @@ ${url}`;
   if (sentIds.length === chunks.length && chunks.length > 0) {
     const anchorMsgId = sentIds[chunks.length - 1];
     if (typeof anchorMsgId === "number") {
+      clearPending(statusKey(chat_id, threadId), "reply_finalize");
       noteOutbound3(statusKey(chat_id, threadId), {
         messageId: anchorMsgId,
         text: chunks[chunks.length - 1],
@@ -51577,6 +51708,7 @@ async function executeStreamReply(args) {
     outboundDedup.record(sChatId, sThreadId, args.text, Date.now(), currentTurn?.registryKey ?? null);
     const streamFormat = args.format ?? (access.parseMode ?? "html");
     const streamParseMode = streamFormat === "html" ? "HTML" : streamFormat === "markdownv2" ? "MarkdownV2" : undefined;
+    clearPending(statusKey(sChatId, sThreadId), "reply_finalize");
     noteOutbound3(statusKey(sChatId, sThreadId), {
       messageId: result.messageId,
       text: args.text,

package/telegram-plugin/gateway/config-approval-handler.test.ts

@@ -17,6 +17,7 @@ import {
   handleRequestConfigFinalize,
   parseConfigApprovalCallback,
   resolvePendingConfigApproval,
+  truncateDiffForCard,
   _resetPendingConfigApprovalsForTest,
   _peekPendingConfigApprovalForTest,
 } from "./config-approval-handler.js";
@@ -66,7 +67,7 @@ afterEach(() => {
 
 describe("buildConfigApprovalCardBody", () => {
   it("HTML-escapes the diff body so `<` / `&` can't break out of the <pre> block", () => {
-    const body = buildConfigApprovalCardBody({
+    const { body } = buildConfigApprovalCardBody({
       agentName: "klanker",
       reason: "<script>",
       unifiedDiff: "a & b <c>",
@@ -74,6 +75,97 @@ describe("buildConfigApprovalCardBody", () => {
     expect(body).toContain("&lt;script&gt;");
     expect(body).toContain("a &amp; b &lt;c&gt;");
   });
+
+  it("rendered body stays under Telegram's 4096-char limit when raw diff is all `&` (worst-case 5x escape inflation)", () => {
+    // 3000 `&` chars escape to 15000 `&amp;` chars — far past 4096.
+    // The post-escape cap MUST kick in and truncate the rendered body.
+    const evilDiff = "&".repeat(3000);
+    const { body } = buildConfigApprovalCardBody({
+      agentName: "klanker",
+      reason: "test",
+      unifiedDiff: evilDiff,
+    });
+    expect(body.length).toBeLessThanOrEqual(4096);
+    expect(body).toContain("diff continues, see attached file");
+  });
+
+  it("rendered body stays under 4096 when raw diff is all `<` (5x escape)", () => {
+    const evilDiff = "<".repeat(3000);
+    const { body } = buildConfigApprovalCardBody({
+      agentName: "klanker",
+      reason: "test",
+      unifiedDiff: evilDiff,
+    });
+    expect(body.length).toBeLessThanOrEqual(4096);
+    expect(body).toContain("&lt;");
+  });
+
+  it("clips an unbounded operator-supplied `reason` to ~500 chars with ellipsis", () => {
+    const longReason = "x".repeat(2000);
+    const { body } = buildConfigApprovalCardBody({
+      agentName: "klanker",
+      reason: longReason,
+      unifiedDiff: "small",
+    });
+    // The escaped reason should appear, but capped.
+    const reasonLine = body
+      .split("\n")
+      .find((l) => l.startsWith("Reason: "))!;
+    // "Reason: " prefix (8) + clipped reason.
+    expect(reasonLine.length).toBeLessThanOrEqual(8 + 500);
+    expect(reasonLine.endsWith("…")).toBe(true);
+  });
+
+  it("returns truncated:false when the rendered body fits without trimming", () => {
+    const { body, truncated } = buildConfigApprovalCardBody({
+      agentName: "klanker",
+      reason: "small",
+      unifiedDiff: "-a\n+b\n",
+    });
+    expect(truncated).toBe(false);
+    expect(body).toContain("<pre>-a\n+b\n</pre>");
+  });
+
+  it("returns truncated:true and appends the sentinel when the body has to shrink", () => {
+    const { body, truncated } = buildConfigApprovalCardBody({
+      agentName: "klanker",
+      reason: "test",
+      unifiedDiff: "&".repeat(3000),
+    });
+    expect(truncated).toBe(true);
+    expect(body).toContain("diff continues, see attached file");
+  });
+
+  it("handles a single unbroken line (no `\\n` to snap to) by char-truncation fallback", () => {
+    // 8000 `x` chars on a single line. After HTML escape (no inflation
+    // for `x`) the diff body alone is 8000 chars + framing — way past
+    // the cap. There's no newline to snap to, so the helper must fall
+    // through to char-truncation rather than returning empty.
+    const oneLongLine = "x".repeat(8000);
+    const { body, truncated } = buildConfigApprovalCardBody({
+      agentName: "klanker",
+      reason: "test",
+      unifiedDiff: oneLongLine,
+    });
+    expect(truncated).toBe(true);
+    expect(body.length).toBeLessThanOrEqual(4096);
+    // Should still contain SOME of the line content — the helper
+    // shouldn't degenerate to "framing + sentinel only" when char-
+    // truncation is available.
+    expect(body).toMatch(/x{100,}/);
+    expect(body).toContain("diff continues, see attached file");
+  });
+
+  it("rendered body stays under 4096 even when reason is also adversarial", () => {
+    const evilDiff = "&".repeat(3000);
+    const evilReason = "&".repeat(2000);
+    const { body } = buildConfigApprovalCardBody({
+      agentName: "klanker",
+      reason: evilReason,
+      unifiedDiff: evilDiff,
+    });
+    expect(body.length).toBeLessThanOrEqual(4096);
+  });
 });
 
 describe("handleRequestConfigApproval", () => {
@@ -100,6 +192,7 @@ describe("handleRequestConfigApproval", () => {
         requestId: "req-1",
         verdict: "deny",
         reason: expect.stringContaining("gateway serves 'klanker'"),
+        denySource: "dispatch_failure",
       },
     ]);
   });
@@ -225,6 +318,100 @@ describe("handleRequestConfigFinalize", () => {
   });
 });
 
+describe("oversize diff → attachment fallback (#1762)", () => {
+  function bigDiff(lines: number): string {
+    // Each line ~80 chars → 200 lines ≈ 16 KB, comfortably > 4096.
+    const row =
+      "-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
+    return Array.from({ length: lines }, (_, i) => `${row}${i}`).join("\n");
+  }
+
+  it("truncateDiffForCard caps the diff and appends a sentinel", () => {
+    const truncated = truncateDiffForCard(bigDiff(200), 50, 3000);
+    expect(truncated.length).toBeLessThanOrEqual(3050);
+    expect(truncated.endsWith("[… diff continues, see attached file]")).toBe(
+      true,
+    );
+  });
+
+  it("returns the original diff unchanged when below the line cap", () => {
+    const small = "--- a\n+++ b\n@@\n-x\n+y\n";
+    expect(truncateDiffForCard(small, 50)).toBe(small);
+  });
+
+  it("oversize body still posts a card with buttons AND fires postAttachment", async () => {
+    const huge = bigDiff(200);
+    const attachmentCalls: Array<{
+      chatId: number | string;
+      filename: string;
+      content: string;
+    }> = [];
+    const { client, sent, deps } = fakeDeps({
+      postAttachment: async (a: {
+        chatId: number | string;
+        filename: string;
+        content: string;
+      }) => {
+        attachmentCalls.push({
+          chatId: a.chatId,
+          filename: a.filename,
+          content: a.content,
+        });
+      },
+    });
+    await handleRequestConfigApproval(
+      client,
+      { ...baseMsg, unifiedDiff: huge },
+      deps,
+    );
+
+    // Card was posted exactly once, with buttons, and within Telegram's limit.
+    expect(deps.postCard).toHaveBeenCalledTimes(1);
+    const postArgs = (deps.postCard as ReturnType<typeof vi.fn>).mock
+      .calls[0]![0] as { text: string; replyMarkup: unknown };
+    expect(postArgs.text.length).toBeLessThanOrEqual(4096);
+    expect(postArgs.text).toMatch(/diff continues, see attached file/);
+    expect(postArgs.replyMarkup).toBeDefined();
+
+    // Attachment carries the FULL diff, named .patch, keyed by requestId.
+    expect(attachmentCalls.length).toBe(1);
+    expect(attachmentCalls[0]!.filename).toBe("config-edit-req-1.patch");
+    expect(attachmentCalls[0]!.content).toBe(huge);
+
+    // The pending entry is registered — handler hasn't auto-denied.
+    expect(_peekPendingConfigApprovalForTest("req-1")).toBeDefined();
+    // No verdict has crossed the wire yet (still pending operator tap).
+    expect(sent.filter((s) => s.type === "config_approval_resolved")).toEqual(
+      [],
+    );
+  });
+
+  it("oversize but no postAttachment dep → card still posts, missing-attachment is logged", async () => {
+    const huge = bigDiff(200);
+    const logs: string[] = [];
+    const { client, deps } = fakeDeps({ log: (m: string) => logs.push(m) });
+    await handleRequestConfigApproval(
+      client,
+      { ...baseMsg, unifiedDiff: huge },
+      deps,
+    );
+    expect(deps.postCard).toHaveBeenCalledTimes(1);
+    expect(
+      logs.some((l) => l.includes("no postAttachment dep wired")),
+    ).toBe(true);
+    expect(_peekPendingConfigApprovalForTest("req-1")).toBeDefined();
+  });
+
+  it("postCard failure → deny carries denySource='dispatch_failure'", async () => {
+    const { client, sent, deps } = fakeDeps({
+      postCard: vi.fn(async () => null),
+    });
+    await handleRequestConfigApproval(client, baseMsg, deps);
+    expect(sent[0]!.verdict).toBe("deny");
+    expect(sent[0]!.denySource).toBe("dispatch_failure");
+  });
+});
+
 describe("parseConfigApprovalCallback", () => {
   it("parses well-formed callbacks", () => {
     expect(parseConfigApprovalCallback("cfg:abc:approve")).toEqual({