assistme 0.7.0 → 0.8.2

package/src/utils/logger.ts

@@ -1,12 +1,35 @@
 import chalk from "chalk";
 import { randomUUID } from "crypto";
+import { readFileSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
 
 export type LogLevel = "debug" | "info" | "warn" | "error";
-export type LogHook = (logType: "stdout" | "stderr", message: string) => void;
+export type LogHook = (logType: "stdout" | "stderr", message: string, conversationId?: string | null) => void;
+export type LogMethod = "debug" | "info" | "success" | "warn" | "error" | "agent" | "tool" | "result";
+export type LogTransport = (method: LogMethod, message: string, extra?: string) => void;
 
 let currentLevel: LogLevel = "info";
 let currentCorrelationId: string | null = null;
+let currentConversationId: string | null = null;
 let logHook: LogHook | null = null;
+/** When set, ALL log output is sent via transport instead of console. Used by worker processes. */
+let logTransport: LogTransport | null = null;
+
+/** Package version, loaded once from package.json. */
+const PKG_VERSION = (() => {
+  try {
+    const __dirname = dirname(fileURLToPath(import.meta.url));
+    // Works from both src/ and dist/
+    for (const rel of ["../package.json", "../../package.json"]) {
+      try {
+        const pkg = JSON.parse(readFileSync(join(__dirname, rel), "utf-8"));
+        if (pkg.version) return pkg.version as string;
+      } catch { /* try next */ }
+    }
+  } catch { /* fallback */ }
+  return "unknown";
+})();
 
 const LEVEL_ORDER: Record<LogLevel, number> = {
   debug: 0,
@@ -27,6 +50,15 @@ export function setLogHook(hook: LogHook | null) {
   logHook = hook;
 }
 
+/**
+ * Set a transport that replaces console output. Used by worker processes
+ * to forward all log output via IPC to the orchestrator.
+ * When set, log methods send structured data via transport instead of printing to console.
+ */
+export function setLogTransport(transport: LogTransport | null) {
+  logTransport = transport;
+}
+
 /**
  * Set a correlation ID that will be included in all subsequent log messages.
  * Call with null to clear.
@@ -35,6 +67,15 @@ export function setCorrelationId(id: string | null) {
   currentCorrelationId = id;
 }
 
+/**
+ * Set the current conversation ID for log context.
+ * Passed to logHook so logs can be associated with a conversation.
+ * JS is single-threaded, so set before log calls and clear after.
+ */
+export function setLogConversationId(id: string | null) {
+  currentConversationId = id;
+}
+
 /**
  * Generate a new short correlation ID (first 8 chars of UUID).
  */
@@ -58,55 +99,64 @@ function timestamp(): string {
 
 function prefix(): string {
   const ts = timestamp();
-  return currentCorrelationId ? `${ts} ${currentCorrelationId}` : ts;
+  const base = `${ts} v${PKG_VERSION}`;
+  return currentCorrelationId ? `${base} ${currentCorrelationId}` : base;
 }
 
 export const log = {
   debug(msg: string, ...args: unknown[]) {
     if (shouldLog("debug")) {
       const text = formatArgs(msg, args);
-      logHook?.("stdout", `[DEBUG] ${text}`);
+      if (logTransport) { logTransport("debug", text); return; }
+      logHook?.("stdout", `[DEBUG] ${text}`, currentConversationId);
       console.log(chalk.gray(`[${prefix()}] DEBUG`), msg, ...args);
     }
   },
   info(msg: string, ...args: unknown[]) {
     if (shouldLog("info")) {
       const text = formatArgs(msg, args);
-      logHook?.("stdout", text);
+      if (logTransport) { logTransport("info", text); return; }
+      logHook?.("stdout", text, currentConversationId);
       console.log(chalk.blue(`[${prefix()}]`), msg, ...args);
     }
   },
   success(msg: string, ...args: unknown[]) {
     if (shouldLog("info")) {
       const text = formatArgs(msg, args);
-      logHook?.("stdout", `✓ ${text}`);
+      if (logTransport) { logTransport("success", text); return; }
+      logHook?.("stdout", `✓ ${text}`, currentConversationId);
       console.log(chalk.green(`[${prefix()}] ✓`), msg, ...args);
     }
   },
   warn(msg: string, ...args: unknown[]) {
     if (shouldLog("warn")) {
       const text = formatArgs(msg, args);
-      logHook?.("stderr", `[WARN] ${text}`);
+      if (logTransport) { logTransport("warn", text); return; }
+      logHook?.("stderr", `[WARN] ${text}`, currentConversationId);
       console.log(chalk.yellow(`[${prefix()}] WARN`), msg, ...args);
     }
   },
   error(msg: string, ...args: unknown[]) {
     if (shouldLog("error")) {
       const text = formatArgs(msg, args);
-      logHook?.("stderr", `[ERROR] ${text}`);
+      if (logTransport) { logTransport("error", text); return; }
+      logHook?.("stderr", `[ERROR] ${text}`, currentConversationId);
       console.error(chalk.red(`[${prefix()}] ERROR`), msg, ...args);
     }
   },
   agent(msg: string) {
-    logHook?.("stdout", `▸ ${msg}`);
+    if (logTransport) { logTransport("agent", msg); return; }
+    logHook?.("stdout", `▸ ${msg}`, currentConversationId);
     console.log(chalk.cyan("  ▸"), msg);
   },
   tool(name: string, msg: string) {
-    logHook?.("stdout", `⚡ ${name}: ${msg}`);
+    if (logTransport) { logTransport("tool", msg, name); return; }
+    logHook?.("stdout", `⚡ ${name}: ${msg}`, currentConversationId);
     console.log(chalk.magenta(`  ⚡ ${name}:`), msg);
   },
   result(msg: string) {
-    logHook?.("stdout", `← ${msg}`);
+    if (logTransport) { logTransport("result", msg); return; }
+    logHook?.("stdout", `← ${msg}`, currentConversationId);
     console.log(chalk.green("  ←"), msg);
   },
 };

package/src/workers/base-handler.ts

@@ -0,0 +1,94 @@
+/**
+ * Base class for worker handlers running inside a forked child process.
+ *
+ * Handles IPC communication with the orchestrator, lifecycle management,
+ * and provides hooks for subclasses to implement specific logic.
+ *
+ * Installs a log transport so that all `log.*` calls in the worker process
+ * (including processor, event-hooks, skill-evaluator, etc.) are forwarded
+ * to the orchestrator via IPC for centralized logging and persistence.
+ */
+
+import type { OrchestratorMessage, WorkerMessage, WorkerConfig, WorkerType, LogMethod } from "./types.js";
+import { setLogTransport } from "../utils/logger.js";
+
+export abstract class BaseHandler {
+  protected config: WorkerConfig | null = null;
+  protected running = false;
+
+  abstract readonly workerType: WorkerType;
+
+  /** Initialize with config. Called once after fork. */
+  abstract onInit(config: WorkerConfig): Promise<void>;
+
+  /** Handle incoming messages from orchestrator. */
+  abstract onMessage(message: OrchestratorMessage): Promise<void>;
+
+  /** Cleanup before shutdown. */
+  abstract onShutdown(): Promise<void>;
+
+  /** Start listening for IPC messages from the orchestrator. */
+  start(): void {
+    this.running = true;
+
+    // Install log transport: forward all log.* calls to orchestrator via IPC
+    setLogTransport((method: LogMethod, message: string, extra?: string) => {
+      this.send({ type: "log_forward", method, message, extra });
+    });
+
+    process.on("message", async (raw: unknown) => {
+      const message = raw as OrchestratorMessage;
+
+      try {
+        switch (message.type) {
+          case "init":
+            this.config = message.config;
+            await this.onInit(message.config);
+            this.send({ type: "ready" });
+            break;
+
+          case "shutdown":
+            this.running = false;
+            setLogTransport(null);
+            await this.onShutdown();
+            process.exit(0);
+            break;
+
+          default:
+            await this.onMessage(message);
+            break;
+        }
+      } catch (err) {
+        this.send({
+          type: "error",
+          error: err instanceof Error ? err.message : String(err),
+        });
+      }
+    });
+
+    // Graceful shutdown on signals
+    process.on("SIGTERM", async () => {
+      this.running = false;
+      await this.onShutdown();
+      process.exit(0);
+    });
+
+    process.on("disconnect", () => {
+      // Parent process exited — shut down
+      this.running = false;
+      process.exit(0);
+    });
+  }
+
+  /** Send a message to the orchestrator (main process). */
+  protected send(message: WorkerMessage): void {
+    if (process.send) {
+      process.send(message);
+    }
+  }
+
+  /** Log via IPC (logs are displayed by the orchestrator). */
+  protected log(level: string, message: string): void {
+    this.send({ type: "log", level, message });
+  }
+}

package/src/workers/conversation.ts

@@ -0,0 +1,74 @@
+/**
+ * Conversation worker handler.
+ *
+ * Runs inside a forked child process. Handles one conversation at a time,
+ * maintaining in-memory state (history cache, skill manager) across tasks
+ * within the same conversation.
+ *
+ * Note: HeartbeatEngine runs in the main process (orchestrator).
+ * The heartbeat MCP tools gracefully degrade when accessed from a worker
+ * (they return "not available in this context").
+ */
+
+import { config as loadEnv } from "dotenv";
+import type { OrchestratorMessage, WorkerConfig } from "./types.js";
+import { BaseHandler } from "./base-handler.js";
+import { TaskProcessor } from "../agent/processor.js";
+import { getBrowser } from "../tools/browser.js";
+
+loadEnv();
+
+export class ConversationHandler extends BaseHandler {
+  readonly workerType = "conversation" as const;
+  private processor: TaskProcessor | null = null;
+
+  async onInit(config: WorkerConfig): Promise<void> {
+    this.processor = new TaskProcessor();
+    this.processor.setUserId(config.userId);
+    this.processor.setSessionId(config.sessionId);
+    // HeartbeatEngine is intentionally not set — it runs in the main process.
+    // The heartbeat MCP tools handle this gracefully (return "not available").
+
+    this.log(
+      "info",
+      `Conversation worker initialized (conversation: ${config.conversationId ?? "any"})`
+    );
+  }
+
+  async onMessage(message: OrchestratorMessage): Promise<void> {
+    switch (message.type) {
+      case "process_task": {
+        const { task } = message;
+        this.log("info", `Processing task ${task.id.slice(0, 8)}...`);
+
+        try {
+          await this.processor!.processTask(task);
+          this.send({ type: "task_completed", taskId: task.id });
+        } catch (err) {
+          this.send({
+            type: "task_failed",
+            taskId: task.id,
+            error: err instanceof Error ? err.message : String(err),
+          });
+        }
+        break;
+      }
+
+      default:
+        this.log("warn", `Unknown message type: ${message.type}`);
+    }
+  }
+
+  async onShutdown(): Promise<void> {
+    this.log("info", "Conversation worker shutting down");
+
+    try {
+      const browser = getBrowser();
+      if (browser.isConnected()) {
+        await browser.disconnect();
+      }
+    } catch {
+      // Ignore cleanup errors
+    }
+  }
+}

package/src/workers/entry.ts

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+
+/**
+ * Worker process entry point.
+ *
+ * This file is forked by the WorkerManager. It reads the worker type
+ * from the command-line argument and starts the appropriate handler.
+ *
+ * Usage: node dist/workers/entry.js --type conversation
+ */
+
+import type { WorkerType } from "./types.js";
+import { ConversationHandler } from "./conversation.js";
+import type { BaseHandler } from "./base-handler.js";
+
+function getWorkerType(): WorkerType {
+  const typeIndex = process.argv.indexOf("--type");
+  if (typeIndex === -1 || !process.argv[typeIndex + 1]) {
+    console.error("Usage: worker --type <conversation>");
+    process.exit(1);
+  }
+  return process.argv[typeIndex + 1] as WorkerType;
+}
+
+function createHandler(type: WorkerType): BaseHandler {
+  switch (type) {
+    case "conversation":
+      return new ConversationHandler();
+    default:
+      console.error(`Unknown worker type: ${type}`);
+      process.exit(1);
+  }
+}
+
+const type = getWorkerType();
+const handler = createHandler(type);
+handler.start();

package/src/workers/index.ts

@@ -0,0 +1,9 @@
+export { WorkerManager, type BusyChangeCallback } from "./manager.js";
+export type {
+  WorkerType,
+  WorkerConfig,
+  WorkerInfo,
+  WorkerStatus,
+  OrchestratorMessage,
+  WorkerMessage,
+} from "./types.js";