@posthog/agent 2.3.526 → 2.3.535

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@posthog/agent",
-  "version": "2.3.526",
+  "version": "2.3.535",
   "repository": "https://github.com/PostHog/code",
   "description": "TypeScript agent framework wrapping Claude Agent SDK with Git-based task execution for PostHog",
   "exports": {
@@ -20,6 +20,10 @@
       "types": "./dist/posthog-api.d.ts",
       "import": "./dist/posthog-api.js"
     },
+    "./pr-url-detector": {
+      "types": "./dist/pr-url-detector.d.ts",
+      "import": "./dist/pr-url-detector.js"
+    },
     "./types": {
       "types": "./dist/types.d.ts",
       "import": "./dist/types.js"
@@ -103,8 +107,8 @@
     "typescript": "^5.5.0",
     "vitest": "^2.1.8",
     "@posthog/shared": "1.0.0",
-    "@posthog/enricher": "1.0.0",
-    "@posthog/git": "1.0.0"
+    "@posthog/git": "1.0.0",
+    "@posthog/enricher": "1.0.0"
   },
   "dependencies": {
     "@agentclientprotocol/sdk": "0.19.0",

package/src/adapters/claude/conversion/sdk-to-acp.ts

@@ -90,13 +90,23 @@ function toolMeta(
   toolName: string,
   toolResponse?: unknown,
   parentToolCallId?: string,
+  bashCommand?: string,
 ): ToolUpdateMeta {
   const meta: ToolUpdateMeta["claudeCode"] = { toolName };
   if (toolResponse !== undefined) meta.toolResponse = toolResponse;
   if (parentToolCallId) meta.parentToolCallId = parentToolCallId;
+  if (bashCommand) meta.bashCommand = bashCommand;
   return { claudeCode: meta };
 }
 
+function bashCommandFromToolUse(
+  toolUse: ToolUseCache[string] | undefined,
+): string | undefined {
+  if (!toolUse || toolUse.name !== "Bash") return undefined;
+  const command = (toolUse.input as { command?: unknown } | undefined)?.command;
+  return typeof command === "string" ? command : undefined;
+}
+
 function handleTextChunk(
   chunk: { text: string },
   role: Role,
@@ -181,7 +191,12 @@ function handleToolUseChunk(
           await ctx.client.sessionUpdate({
             sessionId: ctx.sessionId,
             update: {
-              _meta: toolMeta(toolUse.name, toolResponse, ctx.parentToolCallId),
+              _meta: toolMeta(
+                toolUse.name,
+                toolResponse,
+                ctx.parentToolCallId,
+                bashCommandFromToolUse(toolUse),
+              ),
               toolCallId: toolUseId,
               sessionUpdate: "tool_call_update",
               ...(editUpdate ? editUpdate : {}),
@@ -211,7 +226,12 @@ function handleToolUseChunk(
   });
 
   const meta: Record<string, unknown> = {
-    ...toolMeta(chunk.name, undefined, ctx.parentToolCallId),
+    ...toolMeta(
+      chunk.name,
+      undefined,
+      ctx.parentToolCallId,
+      bashCommandFromToolUse(chunk),
+    ),
   };
   if (chunk.name === "Bash" && ctx.supportsTerminalOutput && !alreadyCached) {
     meta.terminal_info = { terminal_id: chunk.id };
@@ -351,7 +371,12 @@ function handleToolResultChunk(
   }
 
   const meta: Record<string, unknown> = {
-    ...toolMeta(toolUse.name, undefined, ctx.parentToolCallId),
+    ...toolMeta(
+      toolUse.name,
+      undefined,
+      ctx.parentToolCallId,
+      bashCommandFromToolUse(toolUse),
+    ),
     ...(resultMeta?.terminal_exit
       ? { terminal_exit: resultMeta.terminal_exit }
       : {}),

package/src/adapters/claude/types.ts

@@ -106,6 +106,7 @@ export type ToolUpdateMeta = {
     toolName: string;
     toolResponse?: unknown;
     parentToolCallId?: string;
+    bashCommand?: string;
   };
   terminal_info?: TerminalInfo;
   terminal_output?: TerminalOutput;

package/src/pr-url-detector.test.ts

@@ -0,0 +1,140 @@
+import { describe, expect, it } from "vitest";
+import {
+  type ExtractCreatedPrUrlInput,
+  extractCreatedPrUrl,
+} from "./pr-url-detector";
+
+const PR_URL = "https://github.com/PostHog/posthog/pull/12345";
+
+interface Case {
+  name: string;
+  input: ExtractCreatedPrUrlInput;
+  expected: string | null;
+}
+
+const cases: Case[] = [
+  {
+    name: "returns the URL when gh pr create produced it (string toolResponse)",
+    input: {
+      toolName: "Bash",
+      bashCommand: 'gh pr create --title "x" --body "y"',
+      toolResponse: `${PR_URL}\n`,
+    },
+    expected: PR_URL,
+  },
+  {
+    name: "returns the URL when gh pr create produced it (object toolResponse)",
+    input: {
+      toolName: "Bash",
+      bashCommand: "gh pr create --fill",
+      toolResponse: { stdout: `${PR_URL}\n`, stderr: "" },
+    },
+    expected: PR_URL,
+  },
+  {
+    name: "ignores PR URLs from gh pr view",
+    input: {
+      toolName: "Bash",
+      bashCommand: `gh pr view ${PR_URL}`,
+      toolResponse: { stdout: PR_URL },
+    },
+    expected: null,
+  },
+  {
+    name: "ignores PR URLs from gh search prs",
+    input: {
+      toolName: "Bash",
+      bashCommand: 'gh search prs "fix login"',
+      toolResponse: PR_URL,
+    },
+    expected: null,
+  },
+  {
+    name: "ignores PR URLs from gh pr list",
+    input: {
+      toolName: "Bash",
+      bashCommand: "gh pr list --json url",
+      toolResponse: PR_URL,
+    },
+    expected: null,
+  },
+  {
+    name: "returns null when bashCommand is missing",
+    input: {
+      toolName: "Bash",
+      bashCommand: undefined,
+      toolResponse: PR_URL,
+    },
+    expected: null,
+  },
+  {
+    name: "returns null for non-Bash tools",
+    input: {
+      toolName: "Edit",
+      bashCommand: "gh pr create",
+      toolResponse: PR_URL,
+    },
+    expected: null,
+  },
+  {
+    name: "accepts the lowercase 'bash' tool variant",
+    input: {
+      toolName: "bash",
+      bashCommand: "gh pr create",
+      toolResponse: PR_URL,
+    },
+    expected: PR_URL,
+  },
+  {
+    name: "returns null when output has no PR URL",
+    input: {
+      toolName: "Bash",
+      bashCommand: "gh pr create",
+      toolResponse: "no pr was created",
+    },
+    expected: null,
+  },
+  {
+    name: "finds the URL in the content array when toolResponse is empty",
+    input: {
+      toolName: "Bash",
+      bashCommand: "gh pr create --fill",
+      toolResponse: undefined,
+      content: [{ type: "text", text: `Created: ${PR_URL}` }],
+    },
+    expected: PR_URL,
+  },
+  {
+    name: "handles output field on object toolResponse",
+    input: {
+      toolName: "Bash",
+      bashCommand: "gh pr create",
+      toolResponse: { output: PR_URL },
+    },
+    expected: PR_URL,
+  },
+  {
+    name: "matches gh pr create even with a chained command",
+    input: {
+      toolName: "Bash",
+      bashCommand: "git push -u origin feat/x && gh pr create --fill",
+      toolResponse: { stdout: PR_URL },
+    },
+    expected: PR_URL,
+  },
+  {
+    name: "does not match a fake command containing 'pr create' as text",
+    input: {
+      toolName: "Bash",
+      bashCommand: "echo 'i should pr create later'",
+      toolResponse: PR_URL,
+    },
+    expected: null,
+  },
+];
+
+describe("extractCreatedPrUrl", () => {
+  it.each(cases)("$name", ({ input, expected }) => {
+    expect(extractCreatedPrUrl(input)).toBe(expected);
+  });
+});

package/src/pr-url-detector.ts

@@ -0,0 +1,46 @@
+const PR_URL_REGEX = /https:\/\/github\.com\/[^/]+\/[^/]+\/pull\/\d+/;
+const GH_PR_CREATE_REGEX = /\bgh\s+pr\s+create\b/;
+
+export interface ExtractCreatedPrUrlInput {
+  toolName: string | undefined;
+  bashCommand: string | undefined;
+  toolResponse: unknown;
+  content?: Array<{ type?: string; text?: string }>;
+}
+
+export function extractCreatedPrUrl(
+  input: ExtractCreatedPrUrlInput,
+): string | null {
+  const { toolName, bashCommand, toolResponse, content } = input;
+
+  if (!toolName || !/bash/i.test(toolName)) return null;
+  if (!bashCommand || !GH_PR_CREATE_REGEX.test(bashCommand)) return null;
+
+  let textToSearch = "";
+
+  if (toolResponse) {
+    if (typeof toolResponse === "string") {
+      textToSearch = toolResponse;
+    } else if (typeof toolResponse === "object" && toolResponse !== null) {
+      const respObj = toolResponse as Record<string, unknown>;
+      textToSearch =
+        String(respObj.stdout || "") + String(respObj.stderr || "");
+      if (!textToSearch && respObj.output) {
+        textToSearch = String(respObj.output);
+      }
+    }
+  }
+
+  if (Array.isArray(content)) {
+    for (const item of content) {
+      if (item.type === "text" && item.text) {
+        textToSearch += ` ${item.text}`;
+      }
+    }
+  }
+
+  if (!textToSearch) return null;
+
+  const match = textToSearch.match(PR_URL_REGEX);
+  return match ? match[0] : null;
+}

package/src/server/agent-server.test.ts

@@ -279,16 +279,27 @@ describe("AgentServer HTTP Mode", () => {
       const keepaliveCallback: { current: (() => void) | null } = {
         current: null,
       };
+      // Pass through to real setInterval for non-keepalive timers; otherwise
+      // unrelated internals (undici, http server, MSW) lose their periodic
+      // callbacks and can hang the test.
+      const realSetInterval = globalThis.setInterval;
       const setIntervalSpy = vi
         .spyOn(globalThis, "setInterval")
-        .mockImplementation(
-          (callback: (_: undefined) => void, timeout?: number) => {
-            if (timeout === SSE_KEEPALIVE_INTERVAL_MS) {
-              keepaliveCallback.current = () => callback(undefined);
-            }
+        .mockImplementation(((
+          callback: (_: undefined) => void,
+          timeout?: number,
+          ...args: unknown[]
+        ) => {
+          if (timeout === SSE_KEEPALIVE_INTERVAL_MS) {
+            keepaliveCallback.current = () => callback(undefined);
             return setTimeout(() => undefined, 60_000);
-          },
-        );
+          }
+          return (realSetInterval as (...rest: unknown[]) => unknown)(
+            callback,
+            timeout,
+            ...args,
+          );
+        }) as unknown as typeof setInterval);
 
       let reader: ReadableStreamDefaultReader<Uint8Array> | null = null;
       try {
@@ -307,8 +318,9 @@ describe("AgentServer HTTP Mode", () => {
           throw new Error("Expected SSE response body reader");
         }
 
-        await vi.waitFor(() =>
-          expect(keepaliveCallback.current).not.toBeNull(),
+        await vi.waitFor(
+          () => expect(keepaliveCallback.current).not.toBeNull(),
+          { timeout: 10_000, interval: 50 },
         );
         const emitKeepalive = keepaliveCallback.current;
         if (!emitKeepalive) {
@@ -318,7 +330,7 @@ describe("AgentServer HTTP Mode", () => {
 
         const decoder = new TextDecoder();
         let streamText = "";
-        for (let attempts = 0; attempts < 5; attempts++) {
+        for (let attempts = 0; attempts < 10; attempts++) {
           const { done, value } = await reader.read();
           if (done) break;
           streamText += decoder.decode(value, { stream: true });
@@ -331,7 +343,7 @@ describe("AgentServer HTTP Mode", () => {
         await reader?.cancel();
         setIntervalSpy.mockRestore();
       }
-    }, 20000);
+    }, 30000);
   });
 
   describe("POST /command", () => {
@@ -625,7 +637,7 @@ describe("AgentServer HTTP Mode", () => {
   });
 
   describe("detectedPrUrl tracking", () => {
-    it("stores PR URL when detectAndAttachPrUrl finds a match", () => {
+    it("stores PR URL when gh pr create produces it", () => {
       const s = createServer();
       const payload = {
         task_id: "test-task-id",
@@ -635,6 +647,7 @@ describe("AgentServer HTTP Mode", () => {
         _meta: {
           claudeCode: {
             toolName: "Bash",
+            bashCommand: 'gh pr create --title "x" --body "y"',
             toolResponse: {
               stdout:
                 "https://github.com/PostHog/posthog/pull/42\nCreating pull request...",
@@ -659,6 +672,7 @@ describe("AgentServer HTTP Mode", () => {
         _meta: {
           claudeCode: {
             toolName: "Bash",
+            bashCommand: "gh pr create",
             toolResponse: { stdout: "just some output" },
           },
         },
@@ -667,6 +681,71 @@ describe("AgentServer HTTP Mode", () => {
       (s as unknown as TestableServer).detectAndAttachPrUrl(payload, update);
       expect((s as unknown as TestableServer).detectedPrUrl).toBeNull();
     });
+
+    it("does not attach PR URL when the bash command is gh pr view", () => {
+      const s = createServer();
+      const payload = {
+        task_id: "test-task-id",
+        run_id: "test-run-id",
+      };
+      const update = {
+        _meta: {
+          claudeCode: {
+            toolName: "Bash",
+            bashCommand: "gh pr view 42 --json url",
+            toolResponse: {
+              stdout: "https://github.com/PostHog/posthog/pull/42",
+            },
+          },
+        },
+      };
+
+      (s as unknown as TestableServer).detectAndAttachPrUrl(payload, update);
+      expect((s as unknown as TestableServer).detectedPrUrl).toBeNull();
+    });
+
+    it("does not attach PR URL when the bash command is gh search prs", () => {
+      const s = createServer();
+      const payload = {
+        task_id: "test-task-id",
+        run_id: "test-run-id",
+      };
+      const update = {
+        _meta: {
+          claudeCode: {
+            toolName: "Bash",
+            bashCommand: 'gh search prs "fix login"',
+            toolResponse: {
+              stdout: "https://github.com/PostHog/posthog/pull/42",
+            },
+          },
+        },
+      };
+
+      (s as unknown as TestableServer).detectAndAttachPrUrl(payload, update);
+      expect((s as unknown as TestableServer).detectedPrUrl).toBeNull();
+    });
+
+    it("does not attach PR URL when bashCommand is missing", () => {
+      const s = createServer();
+      const payload = {
+        task_id: "test-task-id",
+        run_id: "test-run-id",
+      };
+      const update = {
+        _meta: {
+          claudeCode: {
+            toolName: "Bash",
+            toolResponse: {
+              stdout: "https://github.com/PostHog/posthog/pull/42",
+            },
+          },
+        },
+      };
+
+      (s as unknown as TestableServer).detectAndAttachPrUrl(payload, update);
+      expect((s as unknown as TestableServer).detectedPrUrl).toBeNull();
+    });
   });
 
   describe("buildCloudSystemPrompt", () => {

package/src/server/agent-server.ts

@@ -29,6 +29,7 @@ import type { PermissionMode } from "../execution-mode";
 import { DEFAULT_CODEX_MODEL } from "../gateway-models";
 import { HandoffCheckpointTracker } from "../handoff-checkpoint";
 import { PostHogAPIClient } from "../posthog-api";
+import { extractCreatedPrUrl } from "../pr-url-detector";
 import {
   formatConversationForResume,
   type ResumeState,
@@ -2131,45 +2132,21 @@ ${attributionInstructions}
       const meta = (update?._meta as Record<string, unknown>)?.claudeCode as
         | Record<string, unknown>
         | undefined;
-      const toolResponse = meta?.toolResponse;
-
-      // Extract text content from tool response
-      let textToSearch = "";
-
-      if (toolResponse) {
-        if (typeof toolResponse === "string") {
-          textToSearch = toolResponse;
-        } else if (typeof toolResponse === "object" && toolResponse !== null) {
-          const respObj = toolResponse as Record<string, unknown>;
-          textToSearch =
-            String(respObj.stdout || "") + String(respObj.stderr || "");
-          if (!textToSearch && respObj.output) {
-            textToSearch = String(respObj.output);
-          }
-        }
-      }
-
-      // Also check content array
-      const content = update?.content;
-      if (Array.isArray(content)) {
-        for (const item of content) {
-          if (item.type === "text" && item.text) {
-            textToSearch += ` ${item.text}`;
-          }
-        }
-      }
 
-      if (!textToSearch) return;
+      const content = update?.content as
+        | Array<{ type?: string; text?: string }>
+        | undefined;
 
-      // Match GitHub PR URLs
-      const prUrlMatch = textToSearch.match(
-        /https:\/\/github\.com\/[^/]+\/[^/]+\/pull\/\d+/,
-      );
-      if (!prUrlMatch) return;
+      const prUrl = extractCreatedPrUrl({
+        toolName: meta?.toolName as string | undefined,
+        bashCommand: meta?.bashCommand as string | undefined,
+        toolResponse: meta?.toolResponse,
+        content,
+      });
+      if (!prUrl) return;
 
-      const prUrl = prUrlMatch[0];
       this.detectedPrUrl = prUrl;
-      this.logger.debug("Detected PR URL in bash output", {
+      this.logger.debug("Detected PR URL from gh pr create", {
         runId: payload.run_id,
         prUrl,
       });