forward logs to main and renderer

Author: joshsny

apps/array/src/main/index.ts

@@ -10,6 +10,7 @@ import {
   type MenuItemConstructorOptions,
   shell,
 } from "electron";
+import "./lib/logger";
 import { ANALYTICS_EVENTS } from "../types/analytics.js";
 import { registerAgentIpc, type TaskController } from "./services/agent.js";
 import { registerFoldersIpc } from "./services/folders.js";

apps/array/src/main/lib/logger.ts

@@ -1,7 +1,10 @@
 import log from "electron-log/main";
 
+// Initialize IPC transport to forward main process logs to renderer dev tools
+log.initialize();
+
 log.transports.file.level = "info";
-log.transports.console.level = "debug";
+log.transports.console.level = "info";
 
 export const logger = {
   info: (message: string, ...args: unknown[]) => log.info(message, ...args),

apps/array/src/main/services/agent.ts

@@ -2,7 +2,7 @@ import { randomUUID } from "node:crypto";
 import { mkdirSync, rmSync, symlinkSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { Agent, PermissionMode } from "@posthog/agent";
+import { Agent, type OnLogCallback, PermissionMode } from "@posthog/agent";
 import {
   app,
   type BrowserWindow,
@@ -13,6 +13,15 @@ import { logger } from "../lib/logger";
 
 const log = logger.scope("agent");
 
+const onAgentLog: OnLogCallback = (level, scope, message, data) => {
+  const scopedLog = logger.scope(scope);
+  if (data !== undefined) {
+    scopedLog[level](message, data);
+  } else {
+    scopedLog[level](message);
+  }
+};
+
 interface AgentStartParams {
   taskId: string;
   repoPath: string;
@@ -146,6 +155,7 @@ export function registerAgentIpc(
         posthogApiUrl: apiHost,
         posthogProjectId: projectId,
         debug: true,
+        onLog: onAgentLog,
       });
 
       const controllerEntry: TaskController = {

apps/array/src/renderer/lib/logger.ts

@@ -1,5 +1,8 @@
 import log from "electron-log/renderer";
 
+// Ensure logs appear in dev tools console
+log.transports.console.level = "debug";
+
 export const logger = {
   info: (message: string, ...args: unknown[]) => log.info(message, ...args),
   warn: (message: string, ...args: unknown[]) => log.warn(message, ...args),

packages/agent/index.ts

@@ -33,7 +33,9 @@ export type {
   AgentConfig,
   AgentEvent,
   ExecutionResult,
+  LogLevel as LogLevelType,
   McpServerConfig,
+  OnLogCallback,
   ResearchEvaluation,
   SupportingFile,
   Task,

packages/agent/src/agent.ts

@@ -65,7 +65,11 @@ export class Agent {
       ...defaultMcpServers,
       ...config.mcpServers,
     };
-    this.logger = new Logger({ debug: this.debug, prefix: "[PostHog Agent]" });
+    this.logger = new Logger({
+      debug: this.debug,
+      prefix: "[PostHog Agent]",
+      onLog: config.onLog,
+    });
     this.taskManager = new TaskManager();
     // Hardcode Claude adapter for now - extensible for other providers later
     this.adapter = new ClaudeAdapter();

packages/agent/src/types.ts

@@ -337,6 +337,15 @@ export type McpServerConfig =
       instance?: any;
     };
 
+export type LogLevel = "debug" | "info" | "warn" | "error";
+
+export type OnLogCallback = (
+  level: LogLevel,
+  scope: string,
+  message: string,
+  data?: unknown,
+) => void;
+
 export interface AgentConfig {
   workingDirectory?: string;
   onEvent?: (event: AgentEvent) => void;
@@ -356,6 +365,7 @@ export interface AgentConfig {
 
   // Logging configuration
   debug?: boolean;
+  onLog?: OnLogCallback;
 
   // Fine-grained permission control for direct run() calls
   // See: https://docs.claude.com/en/api/agent-sdk/permissions

packages/agent/src/utils/logger.ts

@@ -1,5 +1,7 @@
+import type { LogLevel as LogLevelType, OnLogCallback } from "../types.js";
+
 /**
- * Simple logger utility with configurable debug mode
+ * Simple logger utility with configurable debug mode and external log forwarding
  */
 export enum LogLevel {
   ERROR = 0,
@@ -11,28 +13,38 @@ export enum LogLevel {
 export interface LoggerConfig {
   debug?: boolean;
   prefix?: string;
+  scope?: string;
+  onLog?: OnLogCallback;
 }
 
 export class Logger {
   private debugEnabled: boolean;
   private prefix: string;
+  private scope: string;
+  private onLog?: OnLogCallback;
 
   constructor(config: LoggerConfig = {}) {
     this.debugEnabled = config.debug ?? false;
     this.prefix = config.prefix ?? "[PostHog Agent]";
+    this.scope = config.scope ?? "agent";
+    this.onLog = config.onLog;
   }
 
   setDebug(enabled: boolean) {
     this.debugEnabled = enabled;
   }
 
+  setOnLog(onLog: OnLogCallback | undefined) {
+    this.onLog = onLog;
+  }
+
   private formatMessage(
     level: string,
     message: string,
     data?: unknown,
   ): string {
     const timestamp = new Date().toISOString();
-    const base = `${timestamp} ${this.prefix} ${level} ${message}`;
+    const base = `${timestamp} ${this.prefix} [${level}] ${message}`;
 
     if (data !== undefined) {
       return `${base} ${JSON.stringify(data, null, 2)}`;
@@ -41,45 +53,49 @@ export class Logger {
     return base;
   }
 
-  error(message: string, error?: Error | unknown) {
-    // Always log errors
-    if (error instanceof Error) {
-      console.error(
-        this.formatMessage("[ERROR]", message, {
-          message: error.message,
-          stack: error.stack,
-        }),
-      );
-    } else {
-      console.error(this.formatMessage("[ERROR]", message, error));
+  private emitLog(level: LogLevelType, message: string, data?: unknown) {
+    if (this.onLog) {
+      this.onLog(level, this.scope, message, data);
+      return;
+    }
+
+    const shouldLog = this.debugEnabled || level === "error";
+
+    if (shouldLog) {
+      console[level](this.formatMessage(level.toLowerCase(), message, data));
     }
   }
 
+  error(message: string, error?: Error | unknown) {
+    const data =
+      error instanceof Error
+        ? { message: error.message, stack: error.stack }
+        : error;
+    
+    this.emitLog("error", message, data);
+  }
+
   warn(message: string, data?: unknown) {
-    if (this.debugEnabled) {
-      console.warn(this.formatMessage("[WARN]", message, data));
-    }
+    this.emitLog("warn", message, data);
   }
 
   info(message: string, data?: unknown) {
-    if (this.debugEnabled) {
-      console.log(this.formatMessage("[INFO]", message, data));
-    }
+    this.emitLog("info", message, data);
   }
 
   debug(message: string, data?: unknown) {
-    if (this.debugEnabled) {
-      console.log(this.formatMessage("[DEBUG]", message, data));
-    }
+    this.emitLog("debug", message, data);
   }
 
   /**
-   * Create a child logger with additional prefix
+   * Create a child logger with additional prefix and scope
    */
   child(childPrefix: string): Logger {
     return new Logger({
       debug: this.debugEnabled,
       prefix: `${this.prefix} [${childPrefix}]`,
+      scope: `${this.scope}:${childPrefix}`,
+      onLog: this.onLog,
     });
   }
 }