@posthog/agent 1.24.0 → 1.24.2

package/src/task-manager.ts

@@ -1,9 +1,9 @@
-import { randomBytes } from "node:crypto";
+import { randomBytes } from 'crypto';
 
 export interface TaskExecutionState {
   taskId: string;
-  status: "running" | "completed" | "failed" | "canceled" | "timeout";
-  mode: "plan_only" | "plan_and_build" | "build_only";
+  status: 'running' | 'completed' | 'failed' | 'canceled' | 'timeout';
+  mode: 'plan_only' | 'plan_and_build' | 'build_only';
   result?: any;
   startedAt: number;
   completedAt?: number;
@@ -11,21 +11,21 @@ export interface TaskExecutionState {
 }
 
 export class TaskManager {
-  public executionStates = new Map<string, TaskExecutionState>();
+  private executionStates = new Map<string, TaskExecutionState>();
   private defaultTimeout = 10 * 60 * 1000; // 10 minutes
 
   generateExecutionId(): string {
-    return randomBytes(16).toString("hex");
+    return randomBytes(16).toString('hex');
   }
 
   startExecution(
-    taskId: string,
-    mode: "plan_only" | "plan_and_build" | "build_only",
-    executionId: string = this.generateExecutionId(),
+    taskId: string, 
+    mode: 'plan_only' | 'plan_and_build' | 'build_only',
+    executionId: string = this.generateExecutionId()
   ): TaskExecutionState {
     const executionState: TaskExecutionState = {
       taskId,
-      status: "running",
+      status: 'running',
       mode,
       startedAt: Date.now(),
       abortController: new AbortController(),
@@ -33,7 +33,7 @@ export class TaskManager {
 
     this.executionStates.set(executionId, executionState);
     this.scheduleTimeout(executionId);
-
+    
     return executionState;
   }
 
@@ -43,7 +43,7 @@ export class TaskManager {
       throw new Error(`Execution ${executionId} not found`);
     }
 
-    if (execution.result && execution.status === "completed") {
+    if (execution.result && execution.status === 'completed') {
       return execution.result;
     }
 
@@ -56,21 +56,16 @@ export class TaskManager {
           return;
         }
 
-        if (
-          currentExecution.status === "completed" &&
-          currentExecution.result
-        ) {
+        if (currentExecution.status === 'completed' && currentExecution.result) {
           clearInterval(checkInterval);
           resolve(currentExecution.result);
         } else if (
-          currentExecution.status === "failed" ||
-          currentExecution.status === "canceled" ||
-          currentExecution.status === "timeout"
+          currentExecution.status === 'failed' || 
+          currentExecution.status === 'canceled' || 
+          currentExecution.status === 'timeout'
         ) {
           clearInterval(checkInterval);
-          reject(
-            new Error(`Execution ${executionId} ${currentExecution.status}`),
-          );
+          reject(new Error(`Execution ${executionId} ${currentExecution.status}`));
         }
       }, 100);
     });
@@ -82,7 +77,7 @@ export class TaskManager {
       throw new Error(`Execution ${executionId} not found`);
     }
 
-    execution.status = "completed";
+    execution.status = 'completed';
     execution.result = result;
     execution.completedAt = Date.now();
   }
@@ -93,11 +88,11 @@ export class TaskManager {
       throw new Error(`Execution ${executionId} not found`);
     }
 
-    execution.status = "failed";
+    execution.status = 'failed';
     execution.completedAt = Date.now();
     execution.result = {
       error: error.message,
-      status: "failed",
+      status: 'failed',
     };
   }
 
@@ -107,14 +102,14 @@ export class TaskManager {
       throw new Error(`Execution ${executionId} not found`);
     }
 
-    execution.status = "canceled";
+    execution.status = 'canceled';
     execution.completedAt = Date.now();
     execution.abortController?.abort();
-
+    
     if (!execution.result) {
       execution.result = {
-        status: "canceled",
-        message: "Execution was canceled",
+        status: 'canceled',
+        message: 'Execution was canceled',
       };
     }
   }
@@ -131,21 +126,18 @@ export class TaskManager {
     return this.executionStates.get(executionId)?.abortController;
   }
 
-  private scheduleTimeout(
-    executionId: string,
-    timeout: number = this.defaultTimeout,
-  ): void {
+  private scheduleTimeout(executionId: string, timeout: number = this.defaultTimeout): void {
     setTimeout(() => {
       const execution = this.executionStates.get(executionId);
-      if (execution && execution.status === "running") {
-        execution.status = "timeout";
+      if (execution && execution.status === 'running') {
+        execution.status = 'timeout';
         execution.completedAt = Date.now();
         execution.abortController?.abort();
-
+        
         if (!execution.result) {
           execution.result = {
-            status: "timeout",
-            message: "Execution timed out",
+            status: 'timeout',
+            message: 'Execution timed out',
           };
         }
       }
@@ -160,4 +152,4 @@ export class TaskManager {
       }
     }
   }
-}
+}

package/src/task-progress-reporter.ts

@@ -1,6 +1,6 @@
-import type { PostHogAPIClient, TaskRunUpdate } from "./posthog-api.js";
-import type { AgentEvent, LogEntry, TaskRun } from "./types.js";
-import type { Logger } from "./utils/logger.js";
+import type { Logger } from './utils/logger.js';
+import type { PostHogAPIClient, TaskRunUpdate } from './posthog-api.js';
+import type { AgentEvent, TaskRun, LogEntry } from './types.js';
 
 interface ProgressMetadata {
   totalSteps?: number;
@@ -17,9 +17,10 @@ export class TaskProgressReporter {
   private logger: Logger;
   private taskRun?: TaskRun;
   private taskId?: string;
+  private outputLog: string[] = [];
   private totalSteps?: number;
   private lastLogEntry?: string;
-  private tokenBuffer: string = "";
+  private tokenBuffer: string = '';
   private tokenCount: number = 0;
   private tokenFlushTimer?: NodeJS.Timeout;
   private readonly TOKEN_BATCH_SIZE = 100;
@@ -30,7 +31,7 @@ export class TaskProgressReporter {
 
   constructor(posthogAPI: PostHogAPIClient | undefined, logger: Logger) {
     this.posthogAPI = posthogAPI;
-    this.logger = logger.child("TaskProgressReporter");
+    this.logger = logger.child('TaskProgressReporter');
   }
 
   get runId(): string | undefined {
@@ -47,15 +48,13 @@ export class TaskProgressReporter {
 
     try {
       const run = await this.posthogAPI.createTaskRun(taskId, {
-        status: "started",
+        status: 'started',
       });
       this.taskRun = run;
-      this.logger.debug("Created task run", { taskId, runId: run.id });
+      this.outputLog = [];
+      this.logger.debug('Created task run', { taskId, runId: run.id });
     } catch (error) {
-      this.logger.warn("Failed to create task run", {
-        taskId,
-        error: (error as Error).message,
-      });
+      this.logger.warn('Failed to create task run', { taskId, error: (error as Error).message });
     }
   }
 
@@ -64,32 +63,25 @@ export class TaskProgressReporter {
     try {
       await this.logWriteQueue;
     } catch (error) {
-      this.logger.debug("Pending logs failed to write during completion", {
-        error,
-      });
+      this.logger.debug('Pending logs failed to write during completion', { error });
     }
 
     if (this.tokenFlushTimer) {
       clearTimeout(this.tokenFlushTimer);
       this.tokenFlushTimer = undefined;
     }
-    await this.update({ status: "completed" }, "Task execution completed");
+    await this.update({ status: 'completed' }, 'Task execution completed');
   }
 
   async fail(error: Error | string): Promise<void> {
     try {
       await this.logWriteQueue;
     } catch (logError) {
-      this.logger.debug("Pending logs failed to write during fail", {
-        error: logError,
-      });
+      this.logger.debug('Pending logs failed to write during fail', { error: logError });
     }
 
-    const message = typeof error === "string" ? error : error.message;
-    await this.update(
-      { status: "failed", error_message: message },
-      `Task execution failed: ${message}`,
-    );
+    const message = typeof error === 'string' ? error : error.message;
+    await this.update({ status: 'failed', error_message: message }, `Task execution failed: ${message}`);
   }
 
   async appendLog(line: string): Promise<void> {
@@ -102,11 +94,11 @@ export class TaskProgressReporter {
     }
 
     const buffer = this.tokenBuffer;
-    this.tokenBuffer = "";
+    this.tokenBuffer = '';
     this.tokenCount = 0;
 
     await this.appendLogEntry({
-      type: "token",
+      type: 'token',
       message: buffer,
     });
   }
@@ -119,7 +111,7 @@ export class TaskProgressReporter {
     this.tokenFlushTimer = setTimeout(() => {
       this.tokenFlushTimer = undefined;
       this.flushTokens().catch((err) => {
-        this.logger.warn("Failed to flush tokens", { error: err });
+        this.logger.warn('Failed to flush tokens', { error: err });
       });
     }, this.TOKEN_FLUSH_INTERVAL_MS);
   }
@@ -134,7 +126,7 @@ export class TaskProgressReporter {
 
     this.logWriteQueue = this.logWriteQueue
       .catch((error) => {
-        this.logger.debug("Previous log append failed", {
+        this.logger.debug('Previous log append failed', {
           taskId,
           runId,
           error: error instanceof Error ? error.message : String(error),
@@ -159,7 +151,7 @@ export class TaskProgressReporter {
         await this.posthogAPI.appendTaskRunLog(taskId, runId, [entry]);
         return;
       } catch (error) {
-        this.logger.warn("Failed to append log entry", {
+        this.logger.warn('Failed to append log entry', {
           taskId,
           runId,
           attempt,
@@ -172,7 +164,7 @@ export class TaskProgressReporter {
         }
 
         const delayMs =
-          this.LOG_APPEND_RETRY_BASE_DELAY_MS * 2 ** (attempt - 1);
+          this.LOG_APPEND_RETRY_BASE_DELAY_MS * Math.pow(2, attempt - 1);
         await new Promise((resolve) => setTimeout(resolve, delayMs));
       }
     }
@@ -184,7 +176,7 @@ export class TaskProgressReporter {
     }
 
     switch (event.type) {
-      case "token": {
+      case 'token': {
         // Batch tokens for efficiency
         this.tokenBuffer += event.content;
         this.tokenCount++;
@@ -201,9 +193,9 @@ export class TaskProgressReporter {
         return;
       }
 
-      case "content_block_start": {
+      case 'content_block_start': {
         await this.appendLogEntry({
-          type: "content_block_start",
+          type: 'content_block_start',
           message: JSON.stringify({
             index: event.index,
             contentType: event.contentType,
@@ -215,9 +207,9 @@ export class TaskProgressReporter {
         return;
       }
 
-      case "content_block_stop": {
+      case 'content_block_stop': {
         await this.appendLogEntry({
-          type: "content_block_stop",
+          type: 'content_block_stop',
           message: JSON.stringify({
             index: event.index,
             ts: event.ts,
@@ -226,9 +218,9 @@ export class TaskProgressReporter {
         return;
       }
 
-      case "message_start": {
+      case 'message_start': {
         await this.appendLogEntry({
-          type: "message_start",
+          type: 'message_start',
           message: JSON.stringify({
             messageId: event.messageId,
             model: event.model,
@@ -238,9 +230,9 @@ export class TaskProgressReporter {
         return;
       }
 
-      case "message_delta": {
+      case 'message_delta': {
         await this.appendLogEntry({
-          type: "message_delta",
+          type: 'message_delta',
           message: JSON.stringify({
             stopReason: event.stopReason,
             stopSequence: event.stopSequence,
@@ -251,17 +243,17 @@ export class TaskProgressReporter {
         return;
       }
 
-      case "message_stop": {
+      case 'message_stop': {
         await this.appendLogEntry({
-          type: "message_stop",
+          type: 'message_stop',
           message: JSON.stringify({ ts: event.ts }),
         });
         return;
       }
 
-      case "status": {
+      case 'status': {
         await this.appendLogEntry({
-          type: "status",
+          type: 'status',
           message: JSON.stringify({
             phase: event.phase,
             kind: event.kind,
@@ -276,9 +268,9 @@ export class TaskProgressReporter {
         return;
       }
 
-      case "artifact": {
+      case 'artifact': {
         await this.appendLogEntry({
-          type: "artifact",
+          type: 'artifact',
           message: JSON.stringify({
             kind: event.kind,
             content: event.content,
@@ -288,9 +280,9 @@ export class TaskProgressReporter {
         return;
       }
 
-      case "init": {
+      case 'init': {
         await this.appendLogEntry({
-          type: "init",
+          type: 'init',
           message: JSON.stringify({
             model: event.model,
             tools: event.tools,
@@ -303,9 +295,9 @@ export class TaskProgressReporter {
         return;
       }
 
-      case "metric": {
+      case 'metric': {
         await this.appendLogEntry({
-          type: "metric",
+          type: 'metric',
           message: JSON.stringify({
             key: event.key,
             value: event.value,
@@ -316,9 +308,9 @@ export class TaskProgressReporter {
         return;
       }
 
-      case "compact_boundary": {
+      case 'compact_boundary': {
         await this.appendLogEntry({
-          type: "compact_boundary",
+          type: 'compact_boundary',
           message: JSON.stringify({
             trigger: event.trigger,
             preTokens: event.preTokens,
@@ -328,9 +320,9 @@ export class TaskProgressReporter {
         return;
       }
 
-      case "tool_call": {
+      case 'tool_call': {
         await this.appendLogEntry({
-          type: "tool_call",
+          type: 'tool_call',
           message: JSON.stringify({
             toolName: event.toolName,
             callId: event.callId,
@@ -342,9 +334,9 @@ export class TaskProgressReporter {
         return;
       }
 
-      case "tool_result": {
+      case 'tool_result': {
         await this.appendLogEntry({
-          type: "tool_result",
+          type: 'tool_result',
           message: JSON.stringify({
             toolName: event.toolName,
             callId: event.callId,
@@ -357,9 +349,9 @@ export class TaskProgressReporter {
         return;
       }
 
-      case "error": {
+      case 'error': {
         await this.appendLogEntry({
-          type: "error",
+          type: 'error',
           message: JSON.stringify({
             message: event.message,
             errorType: event.errorType,
@@ -370,9 +362,9 @@ export class TaskProgressReporter {
         return;
       }
 
-      case "done": {
+      case 'done': {
         await this.appendLogEntry({
-          type: "done",
+          type: 'done',
           message: JSON.stringify({
             result: event.result,
             durationMs: event.durationMs,
@@ -388,9 +380,9 @@ export class TaskProgressReporter {
         return;
       }
 
-      case "user_message": {
+      case 'user_message': {
         await this.appendLogEntry({
-          type: "user_message",
+          type: 'user_message',
           message: JSON.stringify({
             content: event.content,
             isSynthetic: event.isSynthetic,
@@ -400,14 +392,14 @@ export class TaskProgressReporter {
         return;
       }
 
-      case "raw_sdk_event": {
+      case 'raw_sdk_event': {
         // Skip raw SDK events - too verbose for persistence
         return;
       }
 
       default:
         // For any unfamiliar event types, log them as-is
-        this.logger.debug("Unknown event type", { type: (event as any).type });
+        this.logger.debug('Unknown event type', { type: (event as any).type });
         return;
     }
   }
@@ -421,11 +413,11 @@ export class TaskProgressReporter {
     if (logLine && logLine !== this.lastLogEntry) {
       try {
         await this.posthogAPI.appendTaskRunLog(this.taskId, this.runId, [
-          { type: "info", message: logLine },
+          { type: 'info', message: logLine }
         ]);
         this.lastLogEntry = logLine;
       } catch (error) {
-        this.logger.warn("Failed to append log entry", {
+        this.logger.warn('Failed to append log entry', {
           taskId: this.taskId,
           runId: this.runId,
           error: (error as Error).message,
@@ -436,14 +428,10 @@ export class TaskProgressReporter {
     // Update other fields if provided
     if (Object.keys(update).length > 0) {
       try {
-        const run = await this.posthogAPI.updateTaskRun(
-          this.taskId,
-          this.runId,
-          update,
-        );
+        const run = await this.posthogAPI.updateTaskRun(this.taskId, this.runId, update);
         this.taskRun = run;
       } catch (error) {
-        this.logger.warn("Failed to update task run", {
+        this.logger.warn('Failed to update task run', {
           taskId: this.taskId,
           runId: this.runId,
           error: (error as Error).message,
@@ -451,4 +439,5 @@ export class TaskProgressReporter {
       }
     }
   }
+
 }