@posthog/agent 2.3.504 → 2.3.508

package/dist/agent.js

@@ -4030,7 +4030,7 @@ import { v7 as uuidv7 } from "uuid";
 // package.json
 var package_default = {
   name: "@posthog/agent",
-  version: "2.3.504",
+  version: "2.3.508",
   repository: "https://github.com/PostHog/code",
   description: "TypeScript agent framework wrapping Claude Agent SDK with Git-based task execution for PostHog",
   exports: {
@@ -8681,6 +8681,24 @@ function toolContent() {
   return new ToolContentBuilder();
 }
 
+// src/adapters/claude/permissions/posthog-exec-gate.ts
+var POSTHOG_EXEC_TOOL_RE = /^mcp__posthog(?:_[^_]+)*__exec$/;
+var POSTHOG_CALL_COMMAND_RE = /^\s*call\s+(?:--json\s+)?([a-zA-Z0-9_-]+)/;
+var POSTHOG_DESTRUCTIVE_SUBTOOL_RE = /(^|-)(partial-update|update|delete|destroy)(-|$)/i;
+function isPostHogExecTool(toolName) {
+  return POSTHOG_EXEC_TOOL_RE.test(toolName);
+}
+function extractPostHogSubTool(toolInput) {
+  if (!toolInput || typeof toolInput !== "object") return null;
+  const command = toolInput.command;
+  if (typeof command !== "string") return null;
+  const match = command.match(POSTHOG_CALL_COMMAND_RE);
+  return match ? match[1] ?? null : null;
+}
+function isPostHogDestructiveSubTool(subTool) {
+  return POSTHOG_DESTRUCTIVE_SUBTOOL_RE.test(subTool);
+}
+
 // src/adapters/claude/hooks.ts
 function extractTextFromToolResponse(response) {
   if (typeof response === "string") return response;
@@ -8821,6 +8839,19 @@ var createPreToolUseHook = (settingsManager, logger) => async (input, _toolUseID
       `[PreToolUseHook] Tool: ${toolName}, Decision: ${permissionCheck.decision}, Rule: ${permissionCheck.rule}`
     );
   }
+  if (permissionCheck.decision === "allow" && isPostHogExecTool(toolName)) {
+    const subTool = extractPostHogSubTool(toolInput);
+    if (subTool && isPostHogDestructiveSubTool(subTool)) {
+      return {
+        continue: true,
+        hookSpecificOutput: {
+          hookEventName: "PreToolUse",
+          permissionDecision: "ask",
+          permissionDecisionReason: `Destructive PostHog sub-tool '${subTool}' requires explicit approval`
+        }
+      };
+    }
+  }
   switch (permissionCheck.decision) {
     case "allow":
       return {
@@ -10415,6 +10446,12 @@ async function emitToolDenial(context, message) {
     }
   });
 }
+async function buildDenialResult(context, response) {
+  const feedback = response._meta?.customInput?.trim();
+  const message = feedback ? `User refused permission to run tool with feedback: ${feedback}` : "User refused permission to run tool";
+  await emitToolDenial(context, message);
+  return { behavior: "deny", message, interrupt: !feedback };
+}
 function getPlanFromFile(session, fileContentCache) {
   return session.lastPlanContent || (session.lastPlanFilePath ? fileContentCache[session.lastPlanFilePath] : void 0);
 }
@@ -10639,12 +10676,8 @@ async function handleDefaultPermissionFlow(context) {
       behavior: "allow",
       updatedInput: toolInput
     };
-  } else {
-    const feedback = response._meta?.customInput?.trim();
-    const message = feedback ? `User refused permission to run tool with feedback: ${feedback}` : "User refused permission to run tool";
-    await emitToolDenial(context, message);
-    return { behavior: "deny", message, interrupt: !feedback };
   }
+  return buildDenialResult(context, response);
 }
 function parseMcpToolName(toolName) {
   const parts2 = toolName.split("__");
@@ -10707,10 +10740,61 @@ ${metadata2.description}` : "";
       updatedInput: toolInput
     };
   }
-  const feedback = response._meta?.customInput?.trim();
-  const message = feedback ? `User refused permission to run tool with feedback: ${feedback}` : "User refused permission to run tool";
-  await emitToolDenial(context, message);
-  return { behavior: "deny", message, interrupt: !feedback };
+  return buildDenialResult(context, response);
+}
+async function handlePostHogExecApprovalFlow(context, subTool) {
+  const { toolName, toolInput, toolUseID, client, sessionId, session } = context;
+  const response = await client.requestPermission({
+    options: [
+      { kind: "allow_once", name: "Yes", optionId: "allow" },
+      {
+        kind: "allow_always",
+        name: "Yes, always allow",
+        optionId: "allow_always"
+      },
+      {
+        kind: "reject_once",
+        name: "Type here to tell the agent what to do differently",
+        optionId: "reject",
+        _meta: { customInput: true }
+      }
+    ],
+    sessionId,
+    toolCall: {
+      toolCallId: toolUseID,
+      title: `The agent wants to run \`${subTool}\` on PostHog`,
+      kind: "other",
+      content: [
+        {
+          type: "content",
+          content: text(
+            "This will modify live PostHog data. Approve to run this sub-tool."
+          )
+        }
+      ],
+      rawInput: { ...toolInput, toolName }
+    }
+  });
+  if (context.signal?.aborted || response.outcome?.outcome === "cancelled") {
+    throw new Error("Tool use aborted");
+  }
+  if (response.outcome?.outcome === "selected" && (response.outcome.optionId === "allow" || response.outcome.optionId === "allow_always")) {
+    if (response.outcome.optionId === "allow_always") {
+      try {
+        await session.settingsManager.addPostHogExecApproval(subTool);
+      } catch (error) {
+        context.logger.warn(
+          "[canUseTool] Failed to persist PostHog exec approval",
+          { error: error instanceof Error ? error.message : String(error) }
+        );
+      }
+    }
+    return {
+      behavior: "allow",
+      updatedInput: toolInput
+    };
+  }
+  return buildDenialResult(context, response);
 }
 function handlePlanFileException(context) {
   const { session, toolName, toolInput } = context;
@@ -10792,6 +10876,24 @@ async function canUseTool(context) {
     if (approvalState === "needs_approval") {
       return handleMcpApprovalFlow(context);
     }
+    if (isPostHogExecTool(toolName)) {
+      const subTool = extractPostHogSubTool(toolInput);
+      if (subTool && isPostHogDestructiveSubTool(subTool)) {
+        if (session.permissionMode === "auto" || session.permissionMode === "bypassPermissions") {
+          return {
+            behavior: "allow",
+            updatedInput: toolInput
+          };
+        }
+        if (session.settingsManager.hasPostHogExecApproval(subTool)) {
+          return {
+            behavior: "allow",
+            updatedInput: toolInput
+          };
+        }
+        return handlePostHogExecApprovalFlow(context, subTool);
+      }
+    }
   }
   if (isToolAllowedForMode(toolName, session.permissionMode)) {
     return {
@@ -16318,6 +16420,7 @@ var SettingsManager = class {
       ask: []
     };
     const merged = { permissions };
+    const posthogApprovedExecTools = /* @__PURE__ */ new Set();
     for (const settings of allSettings) {
       if (settings.permissions) {
         if (settings.permissions.allow) {
@@ -16345,6 +16448,14 @@ var SettingsManager = class {
       if (settings.model) {
         merged.model = settings.model;
       }
+      if (settings.posthogApprovedExecTools) {
+        for (const tool of settings.posthogApprovedExecTools) {
+          posthogApprovedExecTools.add(tool);
+        }
+      }
+    }
+    if (posthogApprovedExecTools.size > 0) {
+      merged.posthogApprovedExecTools = Array.from(posthogApprovedExecTools);
     }
     this.mergedSettings = merged;
   }
@@ -16409,6 +16520,39 @@ var SettingsManager = class {
       const next = { ...existing, permissions };
       await fs7.promises.mkdir(path11.dirname(filePath), { recursive: true });
       await writeFileAtomic(filePath, `${JSON.stringify(next, null, 2)}
+`);
+      this.localSettings = next;
+      this.mergeAllSettings();
+    } finally {
+      this.writeMutex.release();
+    }
+  }
+  hasPostHogExecApproval(subTool) {
+    return this.mergedSettings.posthogApprovedExecTools?.includes(subTool) ?? false;
+  }
+  /**
+   * Persists an approved PostHog MCP `exec` sub-tool (e.g. `experiment-update`)
+   * to the local settings file so future calls skip the prompt. Mirrors
+   * `addAllowRules` — serialised via `writeMutex`, atomic temp-file + rename.
+   */
+  async addPostHogExecApproval(subTool) {
+    if (!subTool) return;
+    if (!this.initialized) await this.initialize();
+    await this.writeMutex.acquire();
+    try {
+      const filePath = this.getLocalSettingsPath();
+      const existing = await readSettingsFileForUpdate(filePath);
+      const current2 = new Set(existing.posthogApprovedExecTools ?? []);
+      if (current2.has(subTool)) {
+        return;
+      }
+      current2.add(subTool);
+      const next = {
+        ...existing,
+        posthogApprovedExecTools: Array.from(current2)
+      };
+      await fs7.promises.mkdir(path11.dirname(filePath), { recursive: true });
+      await writeFileAtomic(filePath, `${JSON.stringify(next, null, 2)}
 `);
       this.localSettings = next;
       this.mergeAllSettings();