@posthog/agent 2.3.173 → 2.3.202

package/dist/server/bin.cjs

@@ -894,7 +894,7 @@ var require_dist2 = __commonJS({
 
 // src/server/bin.ts
 var import_commander = require("commander");
-var import_zod4 = require("zod");
+var import_v42 = require("zod/v4");
 
 // src/server/agent-server.ts
 var import_sdk5 = require("@agentclientprotocol/sdk");
@@ -904,7 +904,7 @@ var import_hono = require("hono");
 // package.json
 var package_default = {
   name: "@posthog/agent",
-  version: "2.3.173",
+  version: "2.3.202",
   repository: "https://github.com/PostHog/code",
   description: "TypeScript agent framework wrapping Claude Agent SDK with Git-based task execution for PostHog",
   exports: {
@@ -1917,7 +1917,15 @@ function toolInfoFromToolUse(toolUse, options) {
       const writeDisplayPath = writeFilePath ? toDisplayPath(writeFilePath, options?.cwd) : void 0;
       const contentStr = input?.content ? String(input.content) : void 0;
       if (writeFilePath) {
-        const oldContent = options?.cachedFileContent && writeFilePath in options.cachedFileContent ? options.cachedFileContent[writeFilePath] : null;
+        let oldContent = null;
+        if (options?.cachedFileContent && writeFilePath in options.cachedFileContent) {
+          oldContent = options.cachedFileContent[writeFilePath];
+        } else {
+          try {
+            oldContent = import_node_fs.default.readFileSync(writeFilePath, "utf-8");
+          } catch {
+          }
+        }
         contentResult = toolContent().diff(writeFilePath, oldContent, contentStr ?? "").build();
       } else if (contentStr) {
         contentResult = toolContent().text(contentStr).build();
@@ -3369,7 +3377,10 @@ async function handleDefaultPermissionFlow(context) {
     sessionId,
     suggestions
   } = context;
-  const toolInfo = toolInfoFromToolUse({ name: toolName, input: toolInput });
+  const toolInfo = toolInfoFromToolUse(
+    { name: toolName, input: toolInput },
+    { cachedFileContent: context.fileContentCache, cwd: session?.cwd }
+  );
   const options = buildPermissionOptions(
     toolName,
     toolInput,
@@ -12102,45 +12113,45 @@ function validateJwt(token, publicKey) {
 }
 
 // src/server/schemas.ts
-var import_zod3 = require("zod");
-var httpHeaderSchema = import_zod3.z.object({
-  name: import_zod3.z.string(),
-  value: import_zod3.z.string()
+var import_v4 = require("zod/v4");
+var httpHeaderSchema = import_v4.z.object({
+  name: import_v4.z.string(),
+  value: import_v4.z.string()
 });
-var remoteMcpServerSchema = import_zod3.z.object({
-  type: import_zod3.z.enum(["http", "sse"]),
-  name: import_zod3.z.string().min(1, "MCP server name is required"),
-  url: import_zod3.z.url({ error: "MCP server url must be a valid URL" }),
-  headers: import_zod3.z.array(httpHeaderSchema).default([])
+var remoteMcpServerSchema = import_v4.z.object({
+  type: import_v4.z.enum(["http", "sse"]),
+  name: import_v4.z.string().min(1, "MCP server name is required"),
+  url: import_v4.z.url({ error: "MCP server url must be a valid URL" }),
+  headers: import_v4.z.array(httpHeaderSchema).default([])
 });
-var mcpServersSchema = import_zod3.z.array(remoteMcpServerSchema);
-var claudeCodeConfigSchema = import_zod3.z.object({
-  systemPrompt: import_zod3.z.union([
-    import_zod3.z.string(),
-    import_zod3.z.object({
-      type: import_zod3.z.literal("preset"),
-      preset: import_zod3.z.literal("claude_code"),
-      append: import_zod3.z.string().optional()
+var mcpServersSchema = import_v4.z.array(remoteMcpServerSchema);
+var claudeCodeConfigSchema = import_v4.z.object({
+  systemPrompt: import_v4.z.union([
+    import_v4.z.string(),
+    import_v4.z.object({
+      type: import_v4.z.literal("preset"),
+      preset: import_v4.z.literal("claude_code"),
+      append: import_v4.z.string().optional()
     })
   ]).optional(),
-  plugins: import_zod3.z.array(import_zod3.z.object({ type: import_zod3.z.literal("local"), path: import_zod3.z.string() })).optional()
+  plugins: import_v4.z.array(import_v4.z.object({ type: import_v4.z.literal("local"), path: import_v4.z.string() })).optional()
 });
-var jsonRpcRequestSchema = import_zod3.z.object({
-  jsonrpc: import_zod3.z.literal("2.0"),
-  method: import_zod3.z.string(),
-  params: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown()).optional(),
-  id: import_zod3.z.union([import_zod3.z.string(), import_zod3.z.number()]).optional()
+var jsonRpcRequestSchema = import_v4.z.object({
+  jsonrpc: import_v4.z.literal("2.0"),
+  method: import_v4.z.string(),
+  params: import_v4.z.record(import_v4.z.string(), import_v4.z.unknown()).optional(),
+  id: import_v4.z.union([import_v4.z.string(), import_v4.z.number()]).optional()
 });
-var userMessageParamsSchema = import_zod3.z.object({
-  content: import_zod3.z.string().min(1, "Content is required")
+var userMessageParamsSchema = import_v4.z.object({
+  content: import_v4.z.string().min(1, "Content is required")
 });
 var commandParamsSchemas = {
   user_message: userMessageParamsSchema,
   "posthog/user_message": userMessageParamsSchema,
-  cancel: import_zod3.z.object({}).optional(),
-  "posthog/cancel": import_zod3.z.object({}).optional(),
-  close: import_zod3.z.object({}).optional(),
-  "posthog/close": import_zod3.z.object({}).optional()
+  cancel: import_v4.z.object({}).optional(),
+  "posthog/cancel": import_v4.z.object({}).optional(),
+  close: import_v4.z.object({}).optional(),
+  "posthog/close": import_v4.z.object({}).optional()
 };
 function validateCommandParams(method, params) {
   const schema = commandParamsSchemas[method] ?? commandParamsSchemas[method.replace("posthog/", "")];
@@ -13364,17 +13375,17 @@ ${attributionInstructions}
 };
 
 // src/server/bin.ts
-var envSchema = import_zod4.z.object({
-  JWT_PUBLIC_KEY: import_zod4.z.string({
+var envSchema = import_v42.z.object({
+  JWT_PUBLIC_KEY: import_v42.z.string({
     error: "JWT_PUBLIC_KEY is required for authenticating client connections"
   }).min(1, "JWT_PUBLIC_KEY cannot be empty"),
-  POSTHOG_API_URL: import_zod4.z.url({
+  POSTHOG_API_URL: import_v42.z.url({
     error: "POSTHOG_API_URL is required for LLM gateway communication"
   }),
-  POSTHOG_PERSONAL_API_KEY: import_zod4.z.string({
+  POSTHOG_PERSONAL_API_KEY: import_v42.z.string({
     error: "POSTHOG_PERSONAL_API_KEY is required for authenticating with PostHog services"
   }).min(1, "POSTHOG_PERSONAL_API_KEY cannot be empty"),
-  POSTHOG_PROJECT_ID: import_zod4.z.string({
+  POSTHOG_PROJECT_ID: import_v42.z.string({
     error: "POSTHOG_PROJECT_ID is required for routing requests to the correct project"
   }).regex(/^\d+$/, "POSTHOG_PROJECT_ID must be a numeric string").transform((val) => parseInt(val, 10))
 });