talon-agent 1.9.2 → 1.10.1

package/src/__tests__/handlers.test.ts

@@ -1731,45 +1731,103 @@ describe("handleAnimationMessage — downloads and enqueues", () => {
 });
 
 describe("processAndReply — onToolUse callback triggers appendDailyLogResponse", () => {
-  it("calls appendDailyLogResponse when execute invokes onToolUse with send tool", async () => {
-    const { appendDailyLogResponse } = await import("../storage/daily-log.js");
-
-    executeMock.mockImplementationOnce(
-      async (params: Record<string, unknown>) => {
-        // Simulate execute calling onToolUse with a "send" tool
-        const onToolUse = params.onToolUse as (
-          toolName: string,
-          input: Record<string, unknown>,
-        ) => void;
-        onToolUse?.("send", { type: "text", text: "Hello from Claude!" });
-        return {
-          text: "",
-          durationMs: 5,
-          inputTokens: 1,
-          outputTokens: 2,
-          cacheRead: 0,
-          cacheWrite: 0,
-          bridgeMessageCount: 1,
-        };
-      },
-    );
-
-    const ctx = {
-      chat: { id: 96001, type: "private" },
-      message: { text: "hi", message_id: 950, reply_to_message: null },
-      me: { id: 999, username: "testbot" },
-      from: { id: 93, first_name: "Yuki" },
-    } as any;
-
-    await handleTextMessage(ctx, mockBot, mockConfig);
-    await new Promise((r) => setTimeout(r, 700));
+  // The SDK emits MCP-prefixed tool names in production
+  // (`mcp__telegram-tools__send` etc.). Bare names like `send` are how the
+  // tool is registered but NOT what the handler actually receives. This
+  // test matrix exercises both shapes — the prefixed forms are what would
+  // catch a regression where the strip-prefix logic gets dropped.
+  const cases = [
+    {
+      label: "MCP-prefixed send (production shape)",
+      toolName: "mcp__telegram-tools__send",
+      input: { type: "text", text: "Production send text" },
+      expectedText: "Production send text",
+      shouldCapture: true,
+    },
+    {
+      label: "MCP-prefixed end_turn (production shape)",
+      toolName: "mcp__telegram-tools__end_turn",
+      input: { text: "Production end_turn text" },
+      expectedText: "Production end_turn text",
+      shouldCapture: true,
+    },
+    {
+      label: "bare send (defensive — registry-shape compat)",
+      toolName: "send",
+      input: { type: "text", text: "Bare send text" },
+      expectedText: "Bare send text",
+      shouldCapture: true,
+    },
+    {
+      label: "bare end_turn (defensive — registry-shape compat)",
+      toolName: "end_turn",
+      input: { text: "Bare end_turn text" },
+      expectedText: "Bare end_turn text",
+      shouldCapture: true,
+    },
+    {
+      label: "non-text send (photo) — should NOT capture",
+      toolName: "mcp__telegram-tools__send",
+      input: { type: "photo", file_path: "/x.jpg", caption: "ignored" },
+      expectedText: "",
+      shouldCapture: false,
+    },
+    {
+      label: "react tool — should NOT capture",
+      toolName: "mcp__telegram-tools__react",
+      input: { message_id: 1, emoji: "👍" },
+      expectedText: "",
+      shouldCapture: false,
+    },
+  ];
+
+  for (const c of cases) {
+    it(`${c.shouldCapture ? "captures" : "ignores"} ${c.label}`, async () => {
+      const { appendDailyLogResponse } =
+        await import("../storage/daily-log.js");
+      const mockedFn = vi.mocked(appendDailyLogResponse);
+      const before = mockedFn.mock.calls.length;
+
+      executeMock.mockImplementationOnce(
+        async (params: Record<string, unknown>) => {
+          const onToolUse = params.onToolUse as (
+            toolName: string,
+            input: Record<string, unknown>,
+          ) => void;
+          onToolUse?.(c.toolName, c.input);
+          return {
+            text: "",
+            durationMs: 5,
+            inputTokens: 1,
+            outputTokens: 2,
+            cacheRead: 0,
+            cacheWrite: 0,
+            bridgeMessageCount: 1,
+          };
+        },
+      );
 
-    expect(appendDailyLogResponse).toHaveBeenCalledWith(
-      "Talon",
-      "Hello from Claude!",
-      expect.anything(),
-    );
-  }, 3000);
+      const ctx = {
+        chat: { id: 96001, type: "private" },
+        message: { text: "hi", message_id: 950, reply_to_message: null },
+        me: { id: 999, username: "testbot" },
+        from: { id: 93, first_name: "Yuki" },
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      } as any;
+
+      await handleTextMessage(ctx, mockBot, mockConfig);
+      await new Promise((r) => setTimeout(r, 700));
+
+      const newCalls = mockedFn.mock.calls.slice(before);
+      if (c.shouldCapture) {
+        expect(newCalls).toHaveLength(1);
+        expect(newCalls[0][0]).toBe("Talon");
+        expect(newCalls[0][1]).toBe(c.expectedText);
+      } else {
+        expect(newCalls).toHaveLength(0);
+      }
+    }, 3000);
+  }
 });
 
 describe("createStreamCallbacks — onTextBlock delivers message via sendHtml", () => {
@@ -2676,13 +2734,19 @@ describe("processAndReply — group message without senderId", () => {
   }, 3000);
 });
 
-describe("processAndReply — suppressed fallback text logged (L572 TRUE branch)", () => {
-  it("logs when bridgeMessageCount=0 and result.text is non-empty", async () => {
+describe("processAndReply — fallback text no longer suppressed", () => {
+  // Pre-end_turn behavior: when bridgeMessageCount=0 and result.text was
+  // non-empty, the frontend logged "Suppressed fallback text" and dropped
+  // the content (the scratchpad bug). The handler now fires onTextBlock
+  // with trailing text instead, so:
+  //   - the "Suppressed fallback" log is gone entirely
+  //   - the delivery path is exercised by createStreamCallbacks tests above
+  it("does NOT log a 'Suppressed fallback' warning anymore", async () => {
     const { log } = await import("../util/log.js");
     (log as ReturnType<typeof vi.fn>).mockClear();
 
     executeMock.mockResolvedValueOnce({
-      text: "internal reasoning only",
+      text: "trailing prose that used to be suppressed",
       durationMs: 10,
       inputTokens: 1,
       outputTokens: 1,
@@ -2694,7 +2758,7 @@ describe("processAndReply — suppressed fallback text logged (L572 TRUE branch)
     const ctx = {
       chat: { id: 99600, type: "private" },
       message: {
-        text: "test suppressed fallback",
+        text: "test fallback delivery",
         message_id: 1600,
         reply_to_message: null,
       },
@@ -2709,7 +2773,7 @@ describe("processAndReply — suppressed fallback text logged (L572 TRUE branch)
     const suppressedLog = logCalls.find((c: unknown[]) =>
       String(c[1]).includes("Suppressed fallback"),
     );
-    expect(suppressedLog).toBeDefined();
+    expect(suppressedLog).toBeUndefined();
   }, 3000);
 });
 

package/src/__tests__/integration/sdk-stub.test.ts

@@ -0,0 +1,208 @@
+/**
+ * End-to-end integration tests against the real Claude Agent SDK driving a
+ * stub `claude` binary (see `stub-claude/`).
+ *
+ * Unlike the unit tests in `src/__tests__/`, these don't `vi.mock` the SDK —
+ * the real `query()` runs, real subprocess spawn, real hook dispatcher, real
+ * stream-json protocol. The binary is replaced with a scripted stub so we
+ * can assert on what the SDK produces given known inputs.
+ *
+ * What this catches that unit tests can't:
+ *  - Bugs in our integration with the SDK's protocol shapes (e.g. the
+ *    MCP-prefix bug in `isTurnTerminator` would have surfaced here).
+ *  - Hook wiring — confirms options.hooks actually gets invoked by the SDK.
+ *  - Stream sequence handling against authentic message ordering.
+ */
+
+import { describe, it, expect } from "vitest";
+import {
+  runWithStub,
+  cleanup,
+  assistantText,
+  assistantToolUse,
+  successResult,
+  fireHook,
+} from "./stub-claude/helpers.js";
+
+// On Windows the stub binary is a SEA-compiled `.exe` (built via
+// `npm run build:stub-sea`). On POSIX it's the `.mjs` source with shebang.
+// If the .exe isn't present (build step skipped), we skip the suite cleanly
+// rather than fail with `ENOENT`.
+import { existsSync } from "node:fs";
+import { resolve as resolvePath, dirname as dirnamePath } from "node:path";
+import { fileURLToPath as fileUrl } from "node:url";
+const __testDir = dirnamePath(fileUrl(import.meta.url));
+const stubBinaryPath = resolvePath(
+  __testDir,
+  process.platform === "win32"
+    ? "stub-claude/fake-claude.exe"
+    : "stub-claude/fake-claude.mjs",
+);
+const stubReady = existsSync(stubBinaryPath);
+
+describe.skipIf(!stubReady)("SDK integration (stub binary)", () => {
+  it("completes a simple text-only turn", async () => {
+    const result = await runWithStub({
+      prompt: "say hi",
+      script: {
+        turns: [
+          {
+            emit: [assistantText("hello from stub"), successResult("hello")],
+          },
+        ],
+      },
+    });
+
+    // Should have system init, assistant message, and result
+    const types = result.messages.map((m) => (m as { type: string }).type);
+    expect(types).toContain("system");
+    expect(types).toContain("assistant");
+    expect(types).toContain("result");
+
+    cleanup(result);
+  }, 15000);
+
+  it("yields assistant content blocks intact", async () => {
+    const result = await runWithStub({
+      prompt: "test",
+      script: {
+        turns: [
+          {
+            emit: [assistantText("specific text payload"), successResult()],
+          },
+        ],
+      },
+    });
+
+    const assistant = result.messages.find(
+      (m) => (m as { type: string }).type === "assistant",
+    ) as
+      | { message: { content: { type: string; text?: string }[] } }
+      | undefined;
+
+    expect(assistant).toBeDefined();
+    const text = assistant?.message.content.find((b) => b.type === "text");
+    expect(text?.text).toBe("specific text payload");
+
+    cleanup(result);
+  }, 15000);
+
+  it("invokes registered PostToolBatch hooks", async () => {
+    // The stub emits an assistant message with a tool_use, then synthesizes a
+    // PostToolBatch hook fire (via fireHook). The SDK should look up the
+    // callback id we registered during init and invoke our hook function.
+    const result = await runWithStub({
+      prompt: "trigger end_turn",
+      script: {
+        turns: [
+          {
+            emit: [
+              assistantToolUse("mcp__telegram-tools__end_turn", {
+                text: "delivered",
+              }),
+              fireHook("PostToolBatch", {
+                tool_calls: [
+                  {
+                    tool_name: "mcp__telegram-tools__end_turn",
+                    tool_input: { text: "delivered" },
+                    tool_use_id: "tu_1",
+                  },
+                ],
+              }),
+              successResult("delivered"),
+            ],
+          },
+        ],
+      },
+      sdkOptions: {
+        hooks: {
+          PostToolBatch: [
+            {
+              hooks: [
+                async () => ({
+                  continue: false,
+                  stopReason: "test: end_turn fired",
+                }),
+              ],
+            },
+          ],
+        },
+      },
+    });
+
+    expect(result.hookFires.PostToolBatch ?? 0).toBeGreaterThanOrEqual(1);
+
+    const calls = result.hookInputs.PostToolBatch ?? [];
+    const firstInput = calls[0] as
+      | { tool_calls: { tool_name: string }[] }
+      | undefined;
+    expect(firstInput?.tool_calls.map((tc) => tc.tool_name)).toContain(
+      "mcp__telegram-tools__end_turn",
+    );
+
+    cleanup(result);
+  }, 15000);
+
+  it("runs the production turn-terminator hook (PostToolBatch + isTurnTerminator)", async () => {
+    // This test composes the actual hook from `src/backend/claude-sdk/options.ts`
+    // — we reach into the module to grab it. If the hook implementation drifts
+    // from what the SDK calls, this test fails.
+    const { isTurnTerminator } = await import("../../core/tools/index.js");
+
+    const result = await runWithStub({
+      prompt: "drive end_turn through the real isTurnTerminator helper",
+      script: {
+        turns: [
+          {
+            emit: [
+              assistantToolUse("mcp__telegram-tools__end_turn", {
+                text: "ok",
+              }),
+              fireHook("PostToolBatch", {
+                tool_calls: [
+                  {
+                    tool_name: "mcp__telegram-tools__end_turn",
+                    tool_input: { text: "ok" },
+                    tool_use_id: "tu_1",
+                  },
+                ],
+              }),
+              successResult(),
+            ],
+          },
+        ],
+      },
+      sdkOptions: {
+        hooks: {
+          PostToolBatch: [
+            {
+              hooks: [
+                async (input) => {
+                  type Batch = {
+                    hook_event_name: string;
+                    tool_calls: { tool_name: string }[];
+                  };
+                  if ((input as Batch).hook_event_name !== "PostToolBatch") {
+                    return { continue: true };
+                  }
+                  const batch = input as Batch;
+                  const ended = batch.tool_calls.some((tc) =>
+                    isTurnTerminator(tc.tool_name),
+                  );
+                  return ended
+                    ? { continue: false, stopReason: "turn terminated" }
+                    : { continue: true };
+                },
+              ],
+            },
+          ],
+        },
+      },
+    });
+
+    // Hook should have fired exactly once and matched the MCP-prefixed name.
+    expect(result.hookFires.PostToolBatch).toBe(1);
+
+    cleanup(result);
+  }, 15000);
+});

package/src/__tests__/integration/stub-claude/build-sea.mjs

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+/**
+ * Build a Single Executable Application (SEA) wrapping `fake-claude.mjs`.
+ *
+ * Why we need this: on Windows, Node 20.19+ refuses to spawn `.cmd` / `.bat`
+ * shims via `child_process.spawn` without `shell: true` (CVE-2024-27980).
+ * The Claude Agent SDK calls `spawn(claudeBinary, args)` directly, so a
+ * `.cmd` wrapper around our `.mjs` stub is unspawnable. SEA produces a
+ * native `.exe` (or platform-equivalent binary) that the SDK can spawn.
+ *
+ * Steps:
+ *   1. Bundle `fake-claude.mjs` (ESM) → `fake-claude.cjs` (CJS) with esbuild,
+ *      because Node SEA loads main as CommonJS by default.
+ *   2. Generate the SEA preparation blob:
+ *        node --experimental-sea-config sea-config.json
+ *   3. Copy the running `node` binary to `fake-claude(.exe)`.
+ *   4. Inject the blob with postject (Sentinel: `NODE_SEA_FUSE_…`).
+ *
+ * The build is idempotent — safe to re-run. Output binary lives next to
+ * the source files in `stub-claude/`.
+ *
+ * Usage:
+ *   node build-sea.mjs        # builds for the current platform
+ *   npm run build:stub-sea    # same, via the npm script
+ */
+
+import { spawnSync } from "node:child_process";
+import { copyFileSync, chmodSync, existsSync, statSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const BUNDLE_SRC = resolve(__dirname, "fake-claude.mjs");
+const BUNDLE_DEST = resolve(__dirname, "fake-claude.cjs");
+const BLOB_PATH = resolve(__dirname, "sea-prep.blob");
+const EXE_NAME =
+  process.platform === "win32" ? "fake-claude.exe" : "fake-claude";
+const EXE_PATH = resolve(__dirname, EXE_NAME);
+const SEA_CONFIG = resolve(__dirname, "sea-config.json");
+const SENTINEL_FUSE = "NODE_SEA_FUSE_fce680ab2cc467b6e072b8b5df1996b2";
+
+function step(label) {
+  process.stdout.write(`\n[build-sea] ${label}\n`);
+}
+
+function run(label, cmd, args, opts = {}) {
+  step(label);
+  const result = spawnSync(cmd, args, {
+    stdio: "inherit",
+    cwd: __dirname,
+    shell: process.platform === "win32",
+    ...opts,
+  });
+  if (result.status !== 0) {
+    throw new Error(`${label} failed (exit ${result.status})`);
+  }
+}
+
+// ── 1. Bundle ESM → CJS ────────────────────────────────────────────────────
+const esbuildBin = resolve(
+  __dirname,
+  "../../../../node_modules/.bin/esbuild" +
+    (process.platform === "win32" ? ".cmd" : ""),
+);
+if (!existsSync(esbuildBin)) {
+  throw new Error(
+    `esbuild not found at ${esbuildBin}. Run \`npm install\` first.`,
+  );
+}
+run("Bundling fake-claude.mjs → fake-claude.cjs", esbuildBin, [
+  BUNDLE_SRC,
+  "--bundle",
+  "--platform=node",
+  "--format=cjs",
+  `--outfile=${BUNDLE_DEST}`,
+]);
+
+// ── 2. Generate SEA blob ───────────────────────────────────────────────────
+run("Generating SEA preparation blob", process.execPath, [
+  "--experimental-sea-config",
+  SEA_CONFIG,
+]);
+
+if (!existsSync(BLOB_PATH)) {
+  throw new Error(`Expected blob at ${BLOB_PATH} but it doesn't exist`);
+}
+
+// ── 3. Copy node binary ────────────────────────────────────────────────────
+step(`Copying ${process.execPath} → ${EXE_PATH}`);
+copyFileSync(process.execPath, EXE_PATH);
+if (process.platform !== "win32") {
+  chmodSync(EXE_PATH, 0o755);
+}
+
+// ── 4. Inject blob via postject ────────────────────────────────────────────
+const postjectArgs = [
+  "postject",
+  EXE_PATH,
+  "NODE_SEA_BLOB",
+  BLOB_PATH,
+  "--sentinel-fuse",
+  SENTINEL_FUSE,
+];
+if (process.platform === "darwin") {
+  // macOS requires the mach-o segment name to be specified.
+  postjectArgs.push("--macho-segment-name", "NODE_SEA");
+}
+run("Injecting SEA blob with postject", "npx", ["--yes", ...postjectArgs]);
+
+// ── Summary ────────────────────────────────────────────────────────────────
+const finalSize = statSync(EXE_PATH).size;
+step(
+  `Done. ${EXE_NAME} (${(finalSize / 1024 / 1024).toFixed(1)} MB) ready at ${EXE_PATH}`,
+);