assistme 0.4.0 → 0.5.0

package/dist/{chunk-4SBIN27G.js → chunk-KAS2PTOX.js}

@@ -61,6 +61,7 @@ import chalk from "chalk";
 import { randomUUID } from "crypto";
 var currentLevel = "info";
 var currentCorrelationId = null;
+var logHook = null;
 var LEVEL_ORDER = {
   debug: 0,
   info: 1,
@@ -70,6 +71,9 @@ var LEVEL_ORDER = {
 function setLogLevel(level) {
   currentLevel = level;
 }
+function setLogHook(hook) {
+  logHook = hook;
+}
 function setCorrelationId(id) {
   currentCorrelationId = id;
 }
@@ -91,39 +95,56 @@ function prefix() {
 var log = {
   debug(msg, ...args) {
     if (shouldLog("debug")) {
+      const text = formatArgs(msg, args);
+      logHook?.("stdout", `[DEBUG] ${text}`);
       console.log(chalk.gray(`[${prefix()}] DEBUG`), msg, ...args);
     }
   },
   info(msg, ...args) {
     if (shouldLog("info")) {
+      const text = formatArgs(msg, args);
+      logHook?.("stdout", text);
       console.log(chalk.blue(`[${prefix()}]`), msg, ...args);
     }
   },
   success(msg, ...args) {
     if (shouldLog("info")) {
+      const text = formatArgs(msg, args);
+      logHook?.("stdout", `\u2713 ${text}`);
       console.log(chalk.green(`[${prefix()}] \u2713`), msg, ...args);
     }
   },
   warn(msg, ...args) {
     if (shouldLog("warn")) {
+      const text = formatArgs(msg, args);
+      logHook?.("stderr", `[WARN] ${text}`);
       console.log(chalk.yellow(`[${prefix()}] WARN`), msg, ...args);
     }
   },
   error(msg, ...args) {
     if (shouldLog("error")) {
+      const text = formatArgs(msg, args);
+      logHook?.("stderr", `[ERROR] ${text}`);
       console.error(chalk.red(`[${prefix()}] ERROR`), msg, ...args);
     }
   },
   agent(msg) {
+    logHook?.("stdout", `\u25B8 ${msg}`);
     console.log(chalk.cyan("  \u25B8"), msg);
   },
   tool(name, msg) {
+    logHook?.("stdout", `\u26A1 ${name}: ${msg}`);
     console.log(chalk.magenta(`  \u26A1 ${name}:`), msg);
   },
   result(msg) {
+    logHook?.("stdout", `\u2190 ${msg}`);
     console.log(chalk.green("  \u2190"), msg);
   }
 };
+function formatArgs(msg, args) {
+  if (args.length === 0) return msg;
+  return `${msg} ${args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ")}`;
+}
 
 // src/utils/schemas.ts
 import { z } from "zod";
@@ -424,6 +445,7 @@ export {
   writeAuthStore,
   callMcpHandler,
   setLogLevel,
+  setLogHook,
   setCorrelationId,
   newCorrelationId,
   log,

package/dist/index.js

@@ -35,9 +35,10 @@ import {
   readAuthStore,
   safeParse,
   setCorrelationId,
+  setLogHook,
   setLogLevel,
   writeAuthStore
-} from "./chunk-4SBIN27G.js";
+} from "./chunk-KAS2PTOX.js";
 import {
   clearConfig,
   getConfig,
@@ -6119,6 +6120,57 @@ var TaskProcessor = class {
   }
 };
 
+// src/db/session-log.ts
+var FLUSH_INTERVAL_MS = 3e3;
+var MAX_BATCH_SIZE = 100;
+var SessionLogEmitter = class {
+  constructor(sessionId) {
+    this.sessionId = sessionId;
+    this.flushTimer = setInterval(() => this.flush(), FLUSH_INTERVAL_MS);
+  }
+  sequence = 0;
+  buffer = [];
+  flushTimer = null;
+  flushing = false;
+  /** Queue a log entry for batch insertion */
+  push(logType, message) {
+    this.sequence++;
+    this.buffer.push({ log_type: logType, message, seq: this.sequence });
+    if (this.buffer.length >= MAX_BATCH_SIZE) {
+      this.flush();
+    }
+  }
+  /** Flush buffered logs to Supabase */
+  async flush() {
+    if (this.flushing || this.buffer.length === 0) return;
+    const batch = this.buffer.splice(0);
+    this.flushing = true;
+    try {
+      await callMcpHandler("log.emit_batch", {
+        session_id: this.sessionId,
+        logs: batch
+      });
+    } catch (err) {
+      log.debug(
+        `Failed to flush session logs: ${err instanceof Error ? err.message : err}`
+      );
+      if (this.buffer.length < MAX_BATCH_SIZE * 5) {
+        this.buffer.unshift(...batch);
+      }
+    } finally {
+      this.flushing = false;
+    }
+  }
+  /** Stop the emitter and flush remaining logs */
+  async stop() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+    await this.flush();
+  }
+};
+
 // src/commands/start.ts
 function registerStartCommand(program2) {
   program2.command("start", { isDefault: true, hidden: true }).description("Start the agent (default command)").option("-w, --workspace <path>", "Workspace path (default: current directory)").option("-n, --name <name>", "Session name").option("-v, --verbose", "Enable verbose/debug logging").action(runAgent);
@@ -6182,10 +6234,16 @@ async function runAgent(opts) {
   const processor = new TaskProcessor();
   processor.init(userId);
   const sessionManager = new SessionManager();
+  let logEmitter = null;
   const browserRef = getBrowser();
   const shutdown = async () => {
     console.log();
     log.info("Shutting down...");
+    setLogHook(null);
+    try {
+      if (logEmitter) await logEmitter.stop();
+    } catch {
+    }
     try {
       if (browserRef.isConnected()) await browserRef.disconnect();
     } catch {
@@ -6200,6 +6258,10 @@ async function runAgent(opts) {
       await processor.processTask(task);
     });
     processor.setSessionId(session.id);
+    logEmitter = new SessionLogEmitter(session.id);
+    setLogHook((logType, message) => {
+      logEmitter?.push(logType, message);
+    });
     log.info("Listening for tasks (chat + jobs) from web UI...");
     log.info("Press Ctrl+C to stop.\n");
     const rl = createInterface2({
@@ -6605,7 +6667,7 @@ function registerJobCommands(program2) {
   jobCmd.command("list").description("List your defined jobs").action(async () => {
     try {
       const userId = await getCurrentUserId();
-      const { JobRunner: JobRunner2 } = await import("./job-runner-CJ7HM4GZ.js");
+      const { JobRunner: JobRunner2 } = await import("./job-runner-AT3V6LAQ.js");
       const runner = new JobRunner2();
       const jobs = await runner.listJobs();
       if (jobs.length === 0) {
@@ -6629,7 +6691,7 @@ function registerJobCommands(program2) {
   jobCmd.command("status [name]").description("Show run history for a job (or all jobs)").option("-l, --limit <number>", "Max runs to show (default: 5)").action(async (name, opts) => {
     try {
       const userId = await getCurrentUserId();
-      const { JobRunner: JobRunner2 } = await import("./job-runner-CJ7HM4GZ.js");
+      const { JobRunner: JobRunner2 } = await import("./job-runner-AT3V6LAQ.js");
       const runner = new JobRunner2();
       const runs = await runner.getRunHistory(name, parseInt(opts.limit || "5"));
       if (runs.length === 0) {
@@ -6668,7 +6730,7 @@ Job Run History${name ? ` \u2014 ${name}` : ""}:`));
         process.exit(1);
       }
       const userId = await getCurrentUserId();
-      const { JobRunner: JobRunner2 } = await import("./job-runner-CJ7HM4GZ.js");
+      const { JobRunner: JobRunner2 } = await import("./job-runner-AT3V6LAQ.js");
       const runner = new JobRunner2();
       const job = await runner.loadJob(name);
       if (!job) {

package/dist/{job-runner-CJ7HM4GZ.js → job-runner-AT3V6LAQ.js}

@@ -1,6 +1,6 @@
 import {
   JobRunner
-} from "./chunk-4SBIN27G.js";
+} from "./chunk-KAS2PTOX.js";
 import "./chunk-JVA6DHXD.js";
 export {
   JobRunner

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "assistme",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "AssistMe CLI Agent - AI-powered assistant that controls your real browser",
   "type": "module",
   "main": "dist/index.js",

package/src/commands/start.ts

@@ -4,10 +4,11 @@ import ora from "ora";
 import { createInterface } from "readline";
 import { getCurrentUserId } from "../db/supabase.js";
 import { setConfig } from "../utils/config.js";
-import { log, setLogLevel } from "../utils/logger.js";
+import { log, setLogLevel, setLogHook } from "../utils/logger.js";
 import { SessionManager } from "../agent/session.js";
 import { TaskProcessor } from "../agent/processor.js";
 import { getBrowser, ensureBrowserAvailable } from "../tools/browser.js";
+import { SessionLogEmitter } from "../db/session-log.js";
 
 export function registerStartCommand(program: Command): void {
   program
@@ -85,12 +86,19 @@ async function runAgent(opts: { workspace?: string; name?: string; verbose?: boo
   const processor = new TaskProcessor();
   processor.init(userId);
   const sessionManager = new SessionManager();
+  let logEmitter: SessionLogEmitter | null = null;
 
   // Graceful shutdown
   const browserRef = getBrowser();
   const shutdown = async () => {
     console.log();
     log.info("Shutting down...");
+    setLogHook(null);
+    try {
+      if (logEmitter) await logEmitter.stop();
+    } catch {
+      /* ignore */
+    }
     try {
       if (browserRef.isConnected()) await browserRef.disconnect();
     } catch {
@@ -109,6 +117,12 @@ async function runAgent(opts: { workspace?: string; name?: string; verbose?: boo
     });
     processor.setSessionId(session.id);
 
+    // Start persisting logs to Supabase
+    logEmitter = new SessionLogEmitter(session.id);
+    setLogHook((logType, message) => {
+      logEmitter?.push(logType, message);
+    });
+
     log.info("Listening for tasks (chat + jobs) from web UI...");
     log.info("Press Ctrl+C to stop.\n");
 

package/src/db/session-log.ts

@@ -0,0 +1,71 @@
+import { callMcpHandler } from "./api-client.js";
+import { log } from "../utils/logger.js";
+
+const FLUSH_INTERVAL_MS = 3_000;
+const MAX_BATCH_SIZE = 100;
+
+interface PendingLog {
+  log_type: "stdout" | "stderr" | "status";
+  message: string;
+  seq: number;
+}
+
+/**
+ * Batches agent process logs and flushes them to Supabase periodically.
+ * Each session gets its own emitter with an auto-incrementing sequence.
+ */
+export class SessionLogEmitter {
+  private sequence = 0;
+  private buffer: PendingLog[] = [];
+  private flushTimer: ReturnType<typeof setInterval> | null = null;
+  private flushing = false;
+
+  constructor(private sessionId: string) {
+    this.flushTimer = setInterval(() => this.flush(), FLUSH_INTERVAL_MS);
+  }
+
+  /** Queue a log entry for batch insertion */
+  push(logType: "stdout" | "stderr" | "status", message: string): void {
+    this.sequence++;
+    this.buffer.push({ log_type: logType, message, seq: this.sequence });
+
+    // Flush immediately if buffer is large
+    if (this.buffer.length >= MAX_BATCH_SIZE) {
+      this.flush();
+    }
+  }
+
+  /** Flush buffered logs to Supabase */
+  async flush(): Promise<void> {
+    if (this.flushing || this.buffer.length === 0) return;
+
+    const batch = this.buffer.splice(0);
+    this.flushing = true;
+
+    try {
+      await callMcpHandler("log.emit_batch", {
+        session_id: this.sessionId,
+        logs: batch,
+      });
+    } catch (err) {
+      log.debug(
+        `Failed to flush session logs: ${err instanceof Error ? err.message : err}`
+      );
+      // Re-queue failed batch at the front (best-effort, drop if too old)
+      if (this.buffer.length < MAX_BATCH_SIZE * 5) {
+        this.buffer.unshift(...batch);
+      }
+    } finally {
+      this.flushing = false;
+    }
+  }
+
+  /** Stop the emitter and flush remaining logs */
+  async stop(): Promise<void> {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+    await this.flush();
+  }
+}

package/src/utils/logger.ts

@@ -2,9 +2,11 @@ import chalk from "chalk";
 import { randomUUID } from "crypto";
 
 export type LogLevel = "debug" | "info" | "warn" | "error";
+export type LogHook = (logType: "stdout" | "stderr", message: string) => void;
 
 let currentLevel: LogLevel = "info";
 let currentCorrelationId: string | null = null;
+let logHook: LogHook | null = null;
 
 const LEVEL_ORDER: Record<LogLevel, number> = {
   debug: 0,
@@ -17,6 +19,14 @@ export function setLogLevel(level: LogLevel) {
   currentLevel = level;
 }
 
+/**
+ * Set a hook to capture all log output for persistence.
+ * Call with null to remove.
+ */
+export function setLogHook(hook: LogHook | null) {
+  logHook = hook;
+}
+
 /**
  * Set a correlation ID that will be included in all subsequent log messages.
  * Call with null to clear.
@@ -54,36 +64,54 @@ function prefix(): string {
 export const log = {
   debug(msg: string, ...args: unknown[]) {
     if (shouldLog("debug")) {
+      const text = formatArgs(msg, args);
+      logHook?.("stdout", `[DEBUG] ${text}`);
       console.log(chalk.gray(`[${prefix()}] DEBUG`), msg, ...args);
     }
   },
   info(msg: string, ...args: unknown[]) {
     if (shouldLog("info")) {
+      const text = formatArgs(msg, args);
+      logHook?.("stdout", text);
       console.log(chalk.blue(`[${prefix()}]`), msg, ...args);
     }
   },
   success(msg: string, ...args: unknown[]) {
     if (shouldLog("info")) {
+      const text = formatArgs(msg, args);
+      logHook?.("stdout", `✓ ${text}`);
       console.log(chalk.green(`[${prefix()}] ✓`), msg, ...args);
     }
   },
   warn(msg: string, ...args: unknown[]) {
     if (shouldLog("warn")) {
+      const text = formatArgs(msg, args);
+      logHook?.("stderr", `[WARN] ${text}`);
       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}`);
       console.error(chalk.red(`[${prefix()}] ERROR`), msg, ...args);
     }
   },
   agent(msg: string) {
+    logHook?.("stdout", `▸ ${msg}`);
     console.log(chalk.cyan("  ▸"), msg);
   },
   tool(name: string, msg: string) {
+    logHook?.("stdout", `⚡ ${name}: ${msg}`);
     console.log(chalk.magenta(`  ⚡ ${name}:`), msg);
   },
   result(msg: string) {
+    logHook?.("stdout", `← ${msg}`);
     console.log(chalk.green("  ←"), msg);
   },
 };
+
+function formatArgs(msg: string, args: unknown[]): string {
+  if (args.length === 0) return msg;
+  return `${msg} ${args.map((a) => (typeof a === "string" ? a : JSON.stringify(a))).join(" ")}`;
+}