@posthog/agent 2.1.115 → 2.1.120

package/dist/server/bin.cjs

@@ -904,7 +904,7 @@ var import_hono = require("hono");
 // package.json
 var package_default = {
   name: "@posthog/agent",
-  version: "2.1.115",
+  version: "2.1.120",
   repository: "https://github.com/PostHog/twig",
   description: "TypeScript agent framework wrapping Claude Agent SDK with Git-based task execution for PostHog",
   exports: {
@@ -1520,6 +1520,10 @@ ${chunk.resource.text}
 function promptToClaude(prompt) {
   const content = [];
   const context = [];
+  const prContext = prompt._meta?.prContext;
+  if (typeof prContext === "string") {
+    content.push(sdkText(prContext));
+  }
   for (const chunk of prompt.prompt) {
     processPromptChunk(chunk, content, context);
   }
@@ -2966,9 +2970,10 @@ async function handleAskUserQuestionTool(context) {
     }
   });
   if (response.outcome?.outcome !== "selected") {
+    const customMessage = response._meta?.message;
     return {
       behavior: "deny",
-      message: "User cancelled the questions",
+      message: typeof customMessage === "string" ? customMessage : "User cancelled the questions",
       interrupt: true
     };
   }
@@ -3353,12 +3358,10 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
   toolUseCache;
   backgroundTerminals = {};
   clientCapabilities;
-  logWriter;
   options;
   lastSentConfigOptions;
-  constructor(client, logWriter, options) {
+  constructor(client, options) {
     super(client);
-    this.logWriter = logWriter;
     this.options = options;
     this.toolUseCache = {};
     this.logger = new Logger({ debug: true, prefix: "[ClaudeAcpAgent]" });
@@ -3403,7 +3406,14 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
   async newSession(params) {
     this.checkAuthStatus();
     const meta = params._meta;
+    const taskId = meta?.persistence?.taskId;
     const sessionId = (0, import_uuid.v7)();
+    this.logger.info("Creating new session", {
+      sessionId,
+      taskId,
+      taskRunId: meta?.taskRunId,
+      cwd: params.cwd
+    });
     const permissionMode = meta?.permissionMode && TWIG_EXECUTION_MODES.includes(meta.permissionMode) ? meta.permissionMode : "default";
     const mcpServers = parseMcpServers(params);
     const options = buildSessionOptions({
@@ -3432,7 +3442,6 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
       options.abortController
     );
     session.taskRunId = meta?.taskRunId;
-    this.registerPersistence(sessionId, meta);
     if (meta?.taskRunId) {
       await this.client.extNotification("_posthog/sdk_session", {
         taskRunId: meta.taskRunId,
@@ -3458,6 +3467,7 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
   }
   async resumeSession(params) {
     const meta = params._meta;
+    const taskId = meta?.persistence?.taskId;
     const sessionId = meta?.sessionId;
     if (!sessionId) {
       throw new Error("Cannot resume session without sessionId");
@@ -3465,6 +3475,12 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
     if (this.sessionId === sessionId) {
       return {};
     }
+    this.logger.info("Resuming session", {
+      sessionId,
+      taskId,
+      taskRunId: meta?.taskRunId,
+      cwd: params.cwd
+    });
     const mcpServers = parseMcpServers(params);
     const permissionMode = meta?.permissionMode && TWIG_EXECUTION_MODES.includes(meta.permissionMode) ? meta.permissionMode : "default";
     const { query: q, session } = await this.initializeQuery({
@@ -3477,15 +3493,36 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
       isResume: true,
       additionalDirectories: meta?.claudeCode?.options?.additionalDirectories
     });
+    this.logger.info("Session query initialized, awaiting resumption", {
+      sessionId,
+      taskId,
+      taskRunId: meta?.taskRunId
+    });
     session.taskRunId = meta?.taskRunId;
-    this.registerPersistence(sessionId, meta);
-    const validation = await withTimeout(
-      q.initializationResult(),
-      SESSION_VALIDATION_TIMEOUT_MS
-    );
-    if (validation.result === "timeout") {
-      throw new Error("Session validation timed out");
+    try {
+      const result = await withTimeout(
+        q.initializationResult(),
+        SESSION_VALIDATION_TIMEOUT_MS
+      );
+      if (result.result === "timeout") {
+        throw new Error(
+          `Session resumption timed out for sessionId=${sessionId}`
+        );
+      }
+    } catch (err) {
+      this.logger.error("Session resumption failed", {
+        sessionId,
+        taskId,
+        taskRunId: meta?.taskRunId,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      throw err;
     }
+    this.logger.info("Session resumed successfully", {
+      sessionId,
+      taskId,
+      taskRunId: meta?.taskRunId
+    });
     this.deferBackgroundFetches(q, sessionId);
     const configOptions = await this.buildConfigOptions();
     return { configOptions };
@@ -3684,12 +3721,6 @@ var ClaudeAcpAgent = class extends BaseAcpAgent {
       this.logger.warn("Failed to fetch deferred session data", { err });
     });
   }
-  registerPersistence(sessionId, meta) {
-    const persistence = meta?.persistence;
-    if (persistence && this.logWriter) {
-      this.logWriter.register(sessionId, persistence);
-    }
-  }
   sendAvailableCommandsUpdate(sessionId, availableCommands) {
     setTimeout(() => {
       this.client.sessionUpdate({
@@ -3977,7 +4008,7 @@ function createClaudeConnection(config) {
   const agentStream = (0, import_sdk3.ndJsonStream)(agentWritable, streams.agent.readable);
   let agent = null;
   const agentConnection = new import_sdk3.AgentSideConnection((client) => {
-    agent = new ClaudeAcpAgent(client, logWriter, config.processCallbacks);
+    agent = new ClaudeAcpAgent(client, config.processCallbacks);
     logger.info(`Created ${agent.adapterName} agent`);
     return agent;
   }, agentStream);
@@ -4312,6 +4343,16 @@ var PostHogAPIClient = class {
       }
     );
   }
+  async relayMessage(taskId, runId, text2) {
+    const teamId = this.getTeamId();
+    await this.apiRequest(
+      `/api/projects/${teamId}/tasks/${taskId}/runs/${runId}/relay_message/`,
+      {
+        method: "POST",
+        body: JSON.stringify({ text: text2 })
+      }
+    );
+  }
   async uploadTaskArtifacts(taskId, runId, artifacts) {
     if (!artifacts.length) {
       return [];
@@ -4417,11 +4458,15 @@ var SessionLogWriter = class _SessionLogWriter {
   }
   async flushAll() {
     const sessionIds = [...this.sessions.keys()];
-    const pendingCounts = sessionIds.map((id) => ({
-      id,
-      pending: this.pendingEntries.get(id)?.length ?? 0,
-      messages: this.messageCounts.get(id) ?? 0
-    }));
+    const pendingCounts = sessionIds.map((id) => {
+      const session = this.sessions.get(id);
+      return {
+        taskId: session?.context.taskId,
+        runId: session?.context.runId,
+        pending: this.pendingEntries.get(id)?.length ?? 0,
+        messages: this.messageCounts.get(id) ?? 0
+      };
+    });
     this.logger.info("flushAll called", {
       sessions: sessionIds.length,
       pending: pendingCounts
@@ -4437,8 +4482,8 @@ var SessionLogWriter = class _SessionLogWriter {
       return;
     }
     this.logger.info("Session registered", {
-      sessionId,
-      taskId: context.taskId
+      taskId: context.taskId,
+      runId: context.runId
     });
     this.sessions.set(sessionId, { context });
     this.lastFlushAttemptTime.set(sessionId, Date.now());
@@ -4472,7 +4517,11 @@ var SessionLogWriter = class _SessionLogWriter {
     const count = (this.messageCounts.get(sessionId) ?? 0) + 1;
     this.messageCounts.set(sessionId, count);
     if (count % 10 === 1) {
-      this.logger.info("Messages received", { count, sessionId });
+      this.logger.info("Messages received", {
+        count,
+        taskId: session.context.taskId,
+        runId: session.context.runId
+      });
     }
     try {
       const message = JSON.parse(line);
@@ -4489,6 +4538,10 @@ var SessionLogWriter = class _SessionLogWriter {
         return;
       }
       this.emitCoalescedMessage(sessionId, session);
+      const nonChunkAgentText = this.extractAgentMessageText(message);
+      if (nonChunkAgentText) {
+        session.lastAgentMessage = nonChunkAgentText;
+      }
       const entry = {
         type: "notification",
         timestamp,
@@ -4503,7 +4556,8 @@ var SessionLogWriter = class _SessionLogWriter {
       }
     } catch {
       this.logger.warn("Failed to parse raw line for persistence", {
-        sessionId,
+        taskId: session.context.taskId,
+        runId: session.context.runId,
         lineLength: line.length
       });
     }
@@ -4518,7 +4572,8 @@ var SessionLogWriter = class _SessionLogWriter {
     const pending = this.pendingEntries.get(sessionId);
     if (!this.posthogAPI || !pending?.length) {
       this.logger.info("flush: nothing to persist", {
-        sessionId,
+        taskId: session.context.taskId,
+        runId: session.context.runId,
         hasPosthogAPI: !!this.posthogAPI,
         pendingCount: pending?.length ?? 0
       });
@@ -4539,7 +4594,8 @@ var SessionLogWriter = class _SessionLogWriter {
       );
       this.retryCounts.set(sessionId, 0);
       this.logger.info("Flushed session logs", {
-        sessionId,
+        taskId: session.context.taskId,
+        runId: session.context.runId,
         entryCount: pending.length
       });
     } catch (error) {
@@ -4548,7 +4604,11 @@ var SessionLogWriter = class _SessionLogWriter {
       if (retryCount >= _SessionLogWriter.MAX_FLUSH_RETRIES) {
         this.logger.error(
           `Dropping ${pending.length} session log entries after ${retryCount} failed flush attempts`,
-          { sessionId, error }
+          {
+            taskId: session.context.taskId,
+            runId: session.context.runId,
+            error
+          }
         );
         this.retryCounts.set(sessionId, 0);
       } else {
@@ -4581,6 +4641,7 @@ var SessionLogWriter = class _SessionLogWriter {
     if (!session.chunkBuffer) return;
     const { text: text2, firstTimestamp } = session.chunkBuffer;
     session.chunkBuffer = void 0;
+    session.lastAgentMessage = text2;
     const entry = {
       type: "notification",
       timestamp: firstTimestamp,
@@ -4603,6 +4664,29 @@ var SessionLogWriter = class _SessionLogWriter {
       this.scheduleFlush(sessionId);
     }
   }
+  getLastAgentMessage(sessionId) {
+    return this.sessions.get(sessionId)?.lastAgentMessage;
+  }
+  extractAgentMessageText(message) {
+    if (message.method !== "session/update") {
+      return null;
+    }
+    const params = message.params;
+    const update = params?.update;
+    if (update?.sessionUpdate !== "agent_message") {
+      return null;
+    }
+    const content = update.content;
+    if (content?.type === "text" && typeof content.text === "string") {
+      const trimmed2 = content.text.trim();
+      return trimmed2.length > 0 ? trimmed2 : null;
+    }
+    if (typeof update.message === "string") {
+      const trimmed2 = update.message.trim();
+      return trimmed2.length > 0 ? trimmed2 : null;
+    }
+    return null;
+  }
   scheduleFlush(sessionId) {
     const existing = this.flushTimeouts.get(sessionId);
     if (existing) clearTimeout(existing);
@@ -4637,7 +4721,12 @@ var SessionLogWriter = class _SessionLogWriter {
       import_node_fs2.default.appendFileSync(logPath, `${JSON.stringify(entry)}
 `);
     } catch (error) {
-      this.logger.warn("Failed to write to local cache", { logPath, error });
+      this.logger.warn("Failed to write to local cache", {
+        taskId: session.context.taskId,
+        runId: session.context.runId,
+        logPath,
+        error
+      });
     }
   }
 };
@@ -10270,6 +10359,8 @@ var AgentServer = class {
   session = null;
   app;
   posthogAPI;
+  questionRelayedToSlack = false;
+  detectedPrUrl = null;
   constructor(config) {
     this.config = config;
     this.logger = new Logger({ debug: true, prefix: "[AgentServer]" });
@@ -10482,11 +10573,21 @@ var AgentServer = class {
       case "user_message": {
         const content = params.content;
         this.logger.info(
-          `Processing user message: ${content.substring(0, 100)}...`
+          `Processing user message (detectedPrUrl=${this.detectedPrUrl ?? "none"}): ${content.substring(0, 100)}...`
         );
         const result = await this.session.clientConnection.prompt({
           sessionId: this.session.acpSessionId,
-          prompt: [{ type: "text", text: content }]
+          prompt: [{ type: "text", text: content }],
+          ...this.detectedPrUrl && {
+            _meta: {
+              prContext: `IMPORTANT \u2014 OVERRIDE PREVIOUS INSTRUCTIONS ABOUT CREATING BRANCHES/PRs.
+You already have an open pull request: ${this.detectedPrUrl}
+You MUST:
+1. Check out the existing PR branch with \`gh pr checkout ${this.detectedPrUrl}\`
+2. Make changes, commit, and push to that branch
+You MUST NOT create a new branch, close the existing PR, or create a new PR.`
+            }
+          }
         });
         return { stopReason: result.stopReason };
       }
@@ -10571,13 +10672,29 @@ var AgentServer = class {
       protocolVersion: import_sdk4.PROTOCOL_VERSION,
       clientCapabilities: {}
     });
+    let preTaskRun = null;
+    try {
+      preTaskRun = await this.posthogAPI.getTaskRun(
+        payload.task_id,
+        payload.run_id
+      );
+    } catch {
+      this.logger.warn("Failed to fetch task run for session context", {
+        taskId: payload.task_id,
+        runId: payload.run_id
+      });
+    }
+    const prUrl = typeof preTaskRun?.state?.slack_notified_pr_url === "string" ? (preTaskRun?.state).slack_notified_pr_url : null;
+    if (prUrl) {
+      this.detectedPrUrl = prUrl;
+    }
     const sessionResponse = await clientConnection.newSession({
       cwd: this.config.repositoryPath,
       mcpServers: [],
       _meta: {
         sessionId: payload.run_id,
         taskRunId: payload.run_id,
-        systemPrompt: { append: this.buildCloudSystemPrompt() }
+        systemPrompt: { append: this.buildCloudSystemPrompt(prUrl) }
       }
     });
     const acpSessionId = sessionResponse.sessionId;
@@ -10601,28 +10718,51 @@ var AgentServer = class {
     }).catch(
       (err) => this.logger.warn("Failed to set task run to in_progress", err)
     );
-    await this.sendInitialTaskMessage(payload);
+    await this.sendInitialTaskMessage(payload, preTaskRun);
   }
-  async sendInitialTaskMessage(payload) {
+  async sendInitialTaskMessage(payload, prefetchedRun) {
     if (!this.session) return;
     try {
-      this.logger.info("Fetching task details", { taskId: payload.task_id });
       const task = await this.posthogAPI.getTask(payload.task_id);
-      if (!task.description) {
+      let taskRun = prefetchedRun ?? null;
+      if (!taskRun) {
+        try {
+          taskRun = await this.posthogAPI.getTaskRun(
+            payload.task_id,
+            payload.run_id
+          );
+        } catch (error) {
+          this.logger.warn(
+            "Failed to fetch task run for initial prompt override",
+            {
+              taskId: payload.task_id,
+              runId: payload.run_id,
+              error
+            }
+          );
+        }
+      }
+      const initialPromptOverride = taskRun ? this.getInitialPromptOverride(taskRun) : null;
+      const initialPrompt = initialPromptOverride ?? task.description;
+      if (!initialPrompt) {
         this.logger.warn("Task has no description, skipping initial message");
         return;
       }
       this.logger.info("Sending initial task message", {
         taskId: payload.task_id,
-        descriptionLength: task.description.length
+        descriptionLength: initialPrompt.length,
+        usedInitialPromptOverride: !!initialPromptOverride
       });
       const result = await this.session.clientConnection.prompt({
         sessionId: this.session.acpSessionId,
-        prompt: [{ type: "text", text: task.description }]
+        prompt: [{ type: "text", text: initialPrompt }]
       });
       this.logger.info("Initial task message completed", {
         stopReason: result.stopReason
       });
+      if (result.stopReason === "end_turn") {
+        await this.relayAgentResponse(payload);
+      }
     } catch (error) {
       this.logger.error("Failed to send initial task message", error);
       if (this.session) {
@@ -10631,7 +10771,33 @@ var AgentServer = class {
       await this.signalTaskComplete(payload, "error");
     }
   }
-  buildCloudSystemPrompt() {
+  getInitialPromptOverride(taskRun) {
+    const state = taskRun.state;
+    const override = state?.initial_prompt_override;
+    if (typeof override !== "string") {
+      return null;
+    }
+    const trimmed2 = override.trim();
+    return trimmed2.length > 0 ? trimmed2 : null;
+  }
+  buildCloudSystemPrompt(prUrl) {
+    if (prUrl) {
+      return `
+# Cloud Task Execution
+
+This task already has an open pull request: ${prUrl}
+
+After completing the requested changes:
+1. Check out the existing PR branch with \`gh pr checkout ${prUrl}\`
+2. Stage and commit all changes with a clear commit message
+3. Push to the existing PR branch
+
+Important:
+- Do NOT create a new branch or a new pull request.
+- Do NOT add "Co-Authored-By" trailers to commit messages.
+- Do NOT add "Generated with [Claude Code]" or similar attribution lines to PR descriptions.
+`;
+    }
     return `
 # Cloud Task Execution
 
@@ -10701,19 +10867,34 @@ Important:
   }
   createCloudClient(payload) {
     const mode = this.getEffectiveMode(payload);
+    const interactionOrigin = process.env.TWIG_INTERACTION_ORIGIN;
     return {
       requestPermission: async (params) => {
         this.logger.debug("Permission request", {
           mode,
+          interactionOrigin,
           options: params.options
         });
         const allowOption = params.options.find(
           (o) => o.kind === "allow_once" || o.kind === "allow_always"
         );
+        const selectedOptionId = allowOption?.optionId ?? params.options[0].optionId;
+        if (interactionOrigin === "slack") {
+          const twigToolKind = params.toolCall?._meta?.twigToolKind;
+          if (twigToolKind === "question") {
+            this.relaySlackQuestion(payload, params.toolCall?._meta);
+            return {
+              outcome: { outcome: "cancelled" },
+              _meta: {
+                message: "This question has been relayed to the Slack thread where this task originated. The user will reply there. Do NOT re-ask the question or pick an answer yourself. Simply let the user know you are waiting for their reply."
+              }
+            };
+          }
+        }
         return {
           outcome: {
             outcome: "selected",
-            optionId: allowOption?.optionId ?? params.options[0].optionId
+            optionId: selectedOptionId
           }
         };
       },
@@ -10732,6 +10913,97 @@ Important:
       }
     };
   }
+  async relayAgentResponse(payload) {
+    if (!this.session) {
+      return;
+    }
+    if (this.questionRelayedToSlack) {
+      this.questionRelayedToSlack = false;
+      return;
+    }
+    try {
+      await this.session.logWriter.flush(payload.run_id);
+    } catch (error) {
+      this.logger.warn("Failed to flush logs before Slack relay", {
+        taskId: payload.task_id,
+        runId: payload.run_id,
+        error
+      });
+    }
+    const message = this.session.logWriter.getLastAgentMessage(payload.run_id);
+    if (!message) {
+      this.logger.warn("No agent message found for Slack relay", {
+        taskId: payload.task_id,
+        runId: payload.run_id,
+        sessionRegistered: this.session.logWriter.isRegistered(payload.run_id)
+      });
+      return;
+    }
+    try {
+      await this.posthogAPI.relayMessage(
+        payload.task_id,
+        payload.run_id,
+        message
+      );
+    } catch (error) {
+      this.logger.warn("Failed to relay initial agent response to Slack", {
+        taskId: payload.task_id,
+        runId: payload.run_id,
+        error
+      });
+    }
+  }
+  relaySlackQuestion(payload, toolMeta2) {
+    const firstQuestion = this.getFirstQuestionMeta(toolMeta2);
+    if (!this.isQuestionMeta(firstQuestion)) {
+      return;
+    }
+    let message = `*${firstQuestion.question}*
+
+`;
+    if (firstQuestion.options?.length) {
+      firstQuestion.options.forEach(
+        (opt, i) => {
+          message += `${i + 1}. *${opt.label}*`;
+          if (opt.description) message += ` \u2014 ${opt.description}`;
+          message += "\n";
+        }
+      );
+    }
+    message += "\nReply in this thread with your choice.";
+    this.questionRelayedToSlack = true;
+    this.posthogAPI.relayMessage(payload.task_id, payload.run_id, message).catch(
+      (err) => this.logger.warn("Failed to relay question to Slack", { err })
+    );
+  }
+  getFirstQuestionMeta(toolMeta2) {
+    if (!toolMeta2) {
+      return null;
+    }
+    const questionsValue = toolMeta2.questions;
+    if (!Array.isArray(questionsValue) || questionsValue.length === 0) {
+      return null;
+    }
+    return questionsValue[0];
+  }
+  isQuestionMeta(value) {
+    if (!value || typeof value !== "object") {
+      return false;
+    }
+    const candidate = value;
+    if (typeof candidate.question !== "string") {
+      return false;
+    }
+    if (candidate.options === void 0) {
+      return true;
+    }
+    if (!Array.isArray(candidate.options)) {
+      return false;
+    }
+    return candidate.options.every(
+      (option) => !!option && typeof option === "object" && typeof option.label === "string"
+    );
+  }
   detectAndAttachPrUrl(payload, update) {
     try {
       const meta = update?._meta?.claudeCode;
@@ -10762,6 +11034,7 @@ Important:
       );
       if (!prUrlMatch) return;
       const prUrl = prUrlMatch[0];
+      this.detectedPrUrl = prUrl;
       this.logger.info("Detected PR URL in bash output", {
         runId: payload.run_id,
         prUrl