@lovenyberg/ove 0.3.0 → 0.4.0

package/src/router.ts

@@ -15,7 +15,8 @@ export type MessageType =
   | "list-schedules"
   | "remove-schedule"
   | "list-tasks"
-  | "cancel-task";
+  | "cancel-task"
+  | "trace";
 
 export interface ParsedMessage {
   type: MessageType;
@@ -45,6 +46,9 @@ export function parseMessage(text: string): ParsedMessage {
   const cancelMatch = trimmed.match(/^(?:\/)?cancel\s+(\S+)$/i);
   if (cancelMatch) return { type: "cancel-task", args: { taskId: cancelMatch[1] }, rawText: trimmed };
 
+  const traceMatch = trimmed.match(/^(?:\/)?trace(?:\s+(\S+))?$/i);
+  if (traceMatch) return { type: "trace", args: { taskId: traceMatch[1] }, rawText: trimmed };
+
   // Natural language status inquiries — short messages asking about progress
   if (isStatusInquiry(lower)) return { type: "status", args: {}, rawText: trimmed };
 
@@ -142,6 +146,8 @@ export function buildCronPrompt(prompt: string): string {
   return `This is an autonomous scheduled task. Do not ask questions — make your own decisions and proceed with the work. If there are multiple options, pick the best one and go.\n\n${prompt}`;
 }
 
+const CHAT_PIPELINE_HINT = "You are running in a chat pipeline — your text output is sent to the user via a messaging app. Do NOT use AskUserQuestion or other interactive CLI tools (they don't work here). If you need to ask the user something, include the question and numbered options directly in your text response — the user will reply in chat and you'll see their answer in the next message.";
+
 export function buildContextualPrompt(
   parsed: ParsedMessage,
   history: { role: string; content: string }[],
@@ -152,7 +158,7 @@ export function buildContextualPrompt(
       history.slice(0, -1).map((m) => `${m.role}: ${m.content}`).join("\n") +
       "\n\nCurrent request:\n"
     : "";
-  return persona + "\n\n" + contextPrefix + buildPrompt(parsed);
+  return persona + "\n\n" + CHAT_PIPELINE_HINT + "\n\n" + contextPrefix + buildPrompt(parsed);
 }
 
 export function buildPrompt(parsed: ParsedMessage): string {

package/src/runners/claude.ts

@@ -3,6 +3,20 @@ import { logger } from "../logger";
 import { which } from "bun";
 import { realpathSync } from "node:fs";
 
+const TIMEOUT_MS = 30 * 60 * 1000; // 30 minutes
+
+function withTimeout(proc: { exited: Promise<number>; kill(): void }): Promise<number | "timeout"> {
+  return Promise.race([
+    proc.exited,
+    new Promise<"timeout">((resolve) =>
+      setTimeout(() => {
+        proc.kill();
+        resolve("timeout");
+      }, TIMEOUT_MS)
+    ),
+  ]);
+}
+
 export function summarizeToolInput(name: string, input: any): string {
   if (!input) return "";
   switch (name) {
@@ -36,7 +50,7 @@ export class ClaudeRunner implements AgentRunner {
 
   buildArgs(prompt: string, opts: RunOptions): string[] {
     // stream-json requires --verbose in claude CLI
-    const args = ["-p", prompt, "--output-format", "stream-json", "--verbose", "--max-turns", String(opts.maxTurns), "--dangerously-skip-permissions"];
+    const args = ["-p", prompt, "--output-format", "stream-json", "--verbose", "--max-turns", String(opts.maxTurns), "--dangerously-skip-permissions", "--disallowed-tools", "AskUserQuestion"];
     if (opts.mcpConfigPath) args.push("--mcp-config", opts.mcpConfigPath);
     return args;
   }
@@ -58,7 +72,7 @@ export class ClaudeRunner implements AgentRunner {
     }
 
     let resultText: string | null = null;
-    let lastTextBlock: string | null = null;
+    const textBlocks: string[] = [];
     const decoder = new TextDecoder();
     const reader = proc.stdout.getReader();
     try {
@@ -76,7 +90,7 @@ export class ClaudeRunner implements AgentRunner {
             if (msg.type === "assistant" && msg.message?.content) {
               for (const block of msg.message.content) {
                 if (block.type === "text") {
-                  lastTextBlock = block.text;
+                  textBlocks.push(block.text);
                   if (onStatus) onStatus({ kind: "text", text: block.text });
                 }
                 if (block.type === "tool_use" && onStatus) {
@@ -97,16 +111,21 @@ export class ClaudeRunner implements AgentRunner {
       reader.releaseLock();
     }
 
-    const exitCode = await proc.exited;
+    const exitCode = await withTimeout(proc);
     const durationMs = Date.now() - startTime;
 
+    if (exitCode === "timeout") {
+      logger.error("claude task timed out", { durationMs });
+      return { success: false, output: `Claude task timed out after ${TIMEOUT_MS / 60000} minutes`, durationMs };
+    }
+
     if (exitCode !== 0) {
       const stderr = await new Response(proc.stderr).text();
       logger.error("claude task failed", { exitCode, stderr, durationMs });
       return { success: false, output: stderr || "Claude task failed", durationMs };
     }
 
-    const finalOutput = resultText || lastTextBlock || "Task completed (no output)";
+    const finalOutput = resultText || textBlocks.join("\n\n") || "Task completed (no output)";
     logger.info("claude task completed", { durationMs });
     return { success: true, output: finalOutput, durationMs };
   }

package/src/runners/codex.ts

@@ -8,6 +8,20 @@ import { logger } from "../logger";
 import { which } from "bun";
 import { realpathSync } from "node:fs";
 
+const TIMEOUT_MS = 30 * 60 * 1000; // 30 minutes
+
+function withTimeout(proc: { exited: Promise<number>; kill(): void }): Promise<number | "timeout"> {
+  return Promise.race([
+    proc.exited,
+    new Promise<"timeout">((resolve) =>
+      setTimeout(() => {
+        proc.kill();
+        resolve("timeout");
+      }, TIMEOUT_MS)
+    ),
+  ]);
+}
+
 export function summarizeCodexItem(
   item: any
 ): { tool: string; input: string } | null {
@@ -125,9 +139,14 @@ export class CodexRunner implements AgentRunner {
       reader.releaseLock();
     }
 
-    const exitCode = await proc.exited;
+    const exitCode = await withTimeout(proc);
     const durationMs = Date.now() - startTime;
 
+    if (exitCode === "timeout") {
+      logger.error("codex task timed out", { durationMs });
+      return { success: false, output: `Codex task timed out after ${TIMEOUT_MS / 60000} minutes`, durationMs };
+    }
+
     if (exitCode !== 0) {
       const stderr = await new Response(proc.stderr).text();
       const output = errorMessage || stderr || "Codex task failed";

package/src/trace.ts

@@ -0,0 +1,71 @@
+import { Database } from "bun:sqlite";
+
+export interface TraceEvent {
+  id: number;
+  taskId: string;
+  ts: string;
+  kind: "status" | "tool" | "lifecycle" | "output" | "error";
+  summary: string;
+  detail: string | null;
+}
+
+interface TraceRow {
+  id: number;
+  task_id: string;
+  ts: string;
+  kind: string;
+  summary: string;
+  detail: string | null;
+}
+
+export class TraceStore {
+  private db: Database;
+  private enabled: boolean;
+
+  constructor(db: Database) {
+    this.db = db;
+    this.enabled = process.env.OVE_TRACE === "true";
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS task_traces (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        task_id TEXT NOT NULL,
+        ts TEXT NOT NULL,
+        kind TEXT NOT NULL,
+        summary TEXT NOT NULL,
+        detail TEXT
+      )
+    `);
+    this.db.run(`CREATE INDEX IF NOT EXISTS idx_trace_task_id ON task_traces(task_id)`);
+  }
+
+  isEnabled(): boolean {
+    return this.enabled;
+  }
+
+  append(taskId: string, kind: TraceEvent["kind"], summary: string, detail?: string) {
+    if (!this.enabled) return;
+    this.db.run(
+      `INSERT INTO task_traces (task_id, ts, kind, summary, detail) VALUES (?, ?, ?, ?, ?)`,
+      [taskId, new Date().toISOString(), kind, summary, detail ?? null]
+    );
+  }
+
+  getByTask(taskId: string, limit: number = 100): TraceEvent[] {
+    const rows = this.db
+      .query(`SELECT * FROM task_traces WHERE task_id = ? ORDER BY id ASC LIMIT ?`)
+      .all(taskId, limit) as TraceRow[];
+    return rows.map((r) => ({
+      id: r.id,
+      taskId: r.task_id,
+      ts: r.ts,
+      kind: r.kind as TraceEvent["kind"],
+      summary: r.summary,
+      detail: r.detail,
+    }));
+  }
+
+  cleanup(olderThanDays: number = 7) {
+    const cutoff = new Date(Date.now() - olderThanDays * 86_400_000).toISOString();
+    this.db.run(`DELETE FROM task_traces WHERE ts < ?`, [cutoff]);
+  }
+}

package/src/worker.ts

@@ -7,20 +7,53 @@ import type { Config } from "./config";
 import type { TaskQueue, Task } from "./queue";
 import type { RepoManager } from "./repos";
 import type { SessionStore } from "./sessions";
-import type { IncomingMessage, EventAdapter, IncomingEvent } from "./adapters/types";
+import type { IncomingMessage, ChatAdapter, EventAdapter, IncomingEvent } from "./adapters/types";
 import type { AgentRunner, RunOptions, StatusEvent } from "./runner";
+import type { TraceStore } from "./trace";
+import type { DebouncedFunction } from "./adapters/debounce";
 
 export interface WorkerDeps {
   config: Config;
   queue: TaskQueue;
   repos: RepoManager;
   sessions: SessionStore;
+  adapters: ChatAdapter[];
   pendingReplies: Map<string, IncomingMessage>;
   pendingEventReplies: Map<string, { adapter: EventAdapter; event: IncomingEvent }>;
   runningProcesses: Map<string, { abort: AbortController; task: Task }>;
   getRunnerForRepo: (repo: string) => AgentRunner;
   getRunnerOptsForRepo: (repo: string, baseOpts: RunOptions) => RunOptions;
   getRepoInfo: (repoName: string) => { url: string; defaultBranch: string } | null;
+  trace: TraceStore;
+}
+
+function findAdapterForUser(userId: string, adapters: ChatAdapter[]): ChatAdapter | undefined {
+  const platform = userId.split(":")[0]; // e.g. "telegram", "slack", "discord"
+  return adapters.find((a) => a.constructor.name.toLowerCase().includes(platform));
+}
+
+async function replyWithFallback(
+  text: string,
+  originalMsg: IncomingMessage | undefined,
+  userId: string,
+  adapters: ChatAdapter[],
+) {
+  if (originalMsg) {
+    try {
+      await originalMsg.reply(text);
+      return;
+    } catch (err) {
+      logger.warn("original reply failed, trying fallback", { userId, error: String(err) });
+    }
+  }
+  const adapter = findAdapterForUser(userId, adapters);
+  if (adapter?.sendToUser) {
+    try {
+      await adapter.sendToUser(userId, text);
+    } catch (err) {
+      logger.warn("fallback sendToUser failed", { userId, error: String(err) });
+    }
+  }
 }
 
 async function processTask(task: Task, deps: WorkerDeps) {
@@ -37,6 +70,10 @@ async function processTask(task: Task, deps: WorkerDeps) {
 
   const originalMsg = deps.pendingReplies.get(task.id);
   const statusLog: string[] = [];
+  const trace = deps.trace;
+  const startTime = Date.now();
+
+  trace.append(task.id, "lifecycle", "Task started", task.prompt);
 
   try {
     await originalMsg?.updateStatus(`Working on it...`);
@@ -65,8 +102,11 @@ async function processTask(task: Task, deps: WorkerDeps) {
       }
 
       const taskRunner = deps.getRunnerForRepo(task.repo);
+      // Cron tasks are autonomous — give them plenty of room to finish
+      const baseTurns = deps.config.claude.maxTurns;
+      const maxTurns = task.taskType === "cron" ? Math.max(baseTurns, 100) : baseTurns;
       const runOpts = deps.getRunnerOptsForRepo(task.repo, {
-        maxTurns: deps.config.claude.maxTurns,
+        maxTurns,
         mcpConfigPath,
         signal: abortController.signal,
       });
@@ -80,8 +120,10 @@ async function processTask(task: Task, deps: WorkerDeps) {
             const last = statusLog[statusLog.length - 1];
             const summary = `Using ${event.tool}...`;
             if (last !== summary) statusLog.push(summary);
+            trace.append(task.id, "tool", summary, event.input.slice(0, 2000));
           } else {
             statusLog.push(event.text.slice(0, 200));
+            trace.append(task.id, "status", event.text.slice(0, 200));
           }
           originalMsg?.updateStatus(statusLog.slice(-5).join("\n"));
         }
@@ -95,15 +137,26 @@ async function processTask(task: Task, deps: WorkerDeps) {
         }
       }
 
+      // Cancel any pending debounced status update before sending final reply
+      const updateFn = originalMsg?.updateStatus as DebouncedFunction<any> | undefined;
+      if (updateFn?.cancel) updateFn.cancel();
+
+      trace.append(task.id, "output", "Runner output", result.output.slice(0, 10_000));
+
       if (result.success) {
         deps.queue.complete(task.id, result.output);
         logger.info("task completed", { taskId: task.id, durationMs: result.durationMs });
 
         const platform = originalMsg?.platform || "slack";
-        const parts = splitAndReply(result.output, platform);
+        const isCron = task.taskType === "cron";
+        const replyText = isCron
+          ? `[Scheduled: ${task.repo}]\n${result.output}`
+          : result.output;
+        const parts = splitAndReply(replyText, platform);
         for (const part of parts) {
-          await originalMsg?.reply(part);
+          await replyWithFallback(part, originalMsg, task.userId, deps.adapters);
         }
+        trace.append(task.id, "lifecycle", "Reply sent");
         deps.sessions.addMessage(task.userId, "assistant", result.output.slice(0, 500));
 
         const eventReply = deps.pendingEventReplies.get(task.id);
@@ -111,10 +164,13 @@ async function processTask(task: Task, deps: WorkerDeps) {
           await eventReply.adapter.respondToEvent(eventReply.event.eventId, result.output);
           deps.pendingEventReplies.delete(task.id);
         }
+
+        const elapsed = Date.now() - startTime;
+        trace.append(task.id, "lifecycle", `Task completed in ${elapsed}ms`);
       } else {
         deps.queue.fail(task.id, result.output);
         logger.error("task failed", { taskId: task.id });
-        await originalMsg?.reply(`Task failed: ${result.output.slice(0, 500)}`);
+        await replyWithFallback(`Task failed: ${result.output.slice(0, 500)}`, originalMsg, task.userId, deps.adapters);
         deps.sessions.addMessage(task.userId, "assistant", `Task failed: ${result.output.slice(0, 200)}`);
 
         const eventReply = deps.pendingEventReplies.get(task.id);
@@ -122,6 +178,9 @@ async function processTask(task: Task, deps: WorkerDeps) {
           await eventReply.adapter.respondToEvent(eventReply.event.eventId, `Task failed: ${result.output.slice(0, 500)}`);
           deps.pendingEventReplies.delete(task.id);
         }
+
+        const elapsed = Date.now() - startTime;
+        trace.append(task.id, "lifecycle", `Task failed in ${elapsed}ms`, result.output.slice(0, 2000));
       }
     } finally {
       if (!isCreateProject) {
@@ -131,7 +190,10 @@ async function processTask(task: Task, deps: WorkerDeps) {
   } catch (err) {
     deps.queue.fail(task.id, String(err));
     logger.error("task processing error", { taskId: task.id, error: String(err) });
-    await originalMsg?.reply(`Task error: ${String(err).slice(0, 500)}`);
+    trace.append(task.id, "error", "Task processing error", String(err).slice(0, 2000));
+    const updateFn = originalMsg?.updateStatus as DebouncedFunction<any> | undefined;
+    if (updateFn?.cancel) updateFn.cancel();
+    await replyWithFallback(`Task error: ${String(err).slice(0, 500)}`, originalMsg, task.userId, deps.adapters);
   } finally {
     deps.runningProcesses.delete(task.id);
     deps.pendingReplies.delete(task.id);