@lovenyberg/ove 0.2.2 → 0.4.0

package/src/queue.ts

@@ -19,6 +19,18 @@ export interface Task {
   completedAt: string | null;
 }
 
+interface TaskRow {
+  id: string;
+  user_id: string;
+  repo: string;
+  prompt: string;
+  status: string;
+  result: string | null;
+  task_type: string | null;
+  created_at: string;
+  completed_at: string | null;
+}
+
 export class TaskQueue {
   private db: Database;
 
@@ -38,10 +50,9 @@ export class TaskQueue {
       )
     `);
     // Migration: add task_type column if missing (backward compat)
-    try {
-      this.db.run(`ALTER TABLE tasks ADD COLUMN task_type TEXT`);
-    } catch {
-      // Column already exists
+    const columns = this.db.query("PRAGMA table_info(tasks)").all() as { name: string }[];
+    if (!columns.some(c => c.name === "task_type")) {
+      this.db.run("ALTER TABLE tasks ADD COLUMN task_type TEXT");
     }
   }
 
@@ -64,7 +75,7 @@ export class TaskQueue {
          ORDER BY created_at ASC
          LIMIT 1`
       )
-      .get() as any;
+      .get() as TaskRow;
 
     if (!row) return null;
 
@@ -88,7 +99,7 @@ export class TaskQueue {
   }
 
   get(id: string): Task | null {
-    const row = this.db.query(`SELECT * FROM tasks WHERE id = ?`).get(id) as any;
+    const row = this.db.query(`SELECT * FROM tasks WHERE id = ?`).get(id) as TaskRow;
     return row ? this.rowToTask(row) : null;
   }
 
@@ -97,7 +108,7 @@ export class TaskQueue {
       .query(
         `SELECT * FROM tasks WHERE user_id = ? ORDER BY created_at DESC LIMIT ?`
       )
-      .all(userId, limit) as any[];
+      .all(userId, limit) as TaskRow[];
     return rows.map((r) => this.rowToTask(r));
   }
 
@@ -111,7 +122,7 @@ export class TaskQueue {
           COUNT(*) FILTER (WHERE status = 'failed') as failed
         FROM tasks`
       )
-      .get() as any;
+      .get() as { pending: number; running: number; completed: number; failed: number };
     return row;
   }
 
@@ -120,7 +131,7 @@ export class TaskQueue {
       .query(
         `SELECT * FROM tasks WHERE status IN ('running', 'pending') ORDER BY created_at ASC LIMIT ?`
       )
-      .all(limit) as any[];
+      .all(limit) as TaskRow[];
     return rows.map((r) => this.rowToTask(r));
   }
 
@@ -132,6 +143,28 @@ export class TaskQueue {
     return result.changes > 0;
   }
 
+  listRecentFailed(limit: number = 20): Task[] {
+    const rows = this.db
+      .query(
+        `SELECT * FROM tasks WHERE status = 'failed' ORDER BY completed_at DESC LIMIT ?`
+      )
+      .all(limit) as TaskRow[];
+    return rows.map((r) => this.rowToTask(r));
+  }
+
+  listRecent(limit: number = 20, status?: string): Task[] {
+    let sql = `SELECT * FROM tasks`;
+    const params: (string | number)[] = [];
+    if (status) {
+      sql += ` WHERE status = ?`;
+      params.push(status);
+    }
+    sql += ` ORDER BY created_at DESC LIMIT ?`;
+    params.push(limit);
+    const rows = this.db.query(sql).all(...params) as TaskRow[];
+    return rows.map((r) => this.rowToTask(r));
+  }
+
   resetStale(): number {
     const result = this.db.run(
       `UPDATE tasks SET status = 'failed', result = 'Interrupted — process restarted', completed_at = ? WHERE status = 'running'`,
@@ -140,13 +173,13 @@ export class TaskQueue {
     return result.changes;
   }
 
-  private rowToTask(row: any): Task {
+  private rowToTask(row: TaskRow): Task {
     return {
       id: row.id,
       userId: row.user_id,
       repo: row.repo,
       prompt: row.prompt,
-      status: row.status,
+      status: row.status as "pending" | "running" | "completed" | "failed",
       result: row.result,
       taskType: row.task_type || null,
       createdAt: row.created_at,

package/src/repo-registry.ts

@@ -11,6 +11,16 @@ export interface RepoRecord {
   lastSyncedAt: string | null;
 }
 
+interface RepoRow {
+  name: string;
+  url: string;
+  owner: string | null;
+  default_branch: string;
+  source: string;
+  excluded: number;
+  last_synced_at: string | null;
+}
+
 export interface RepoUpsertInput {
   name: string;
   url: string;
@@ -62,17 +72,17 @@ export class RepoRegistry {
   }
 
   getByName(name: string): RepoRecord | null {
-    const row = this.db.query(`SELECT * FROM repos WHERE name = ?`).get(name) as any;
+    const row = this.db.query(`SELECT * FROM repos WHERE name = ?`).get(name) as RepoRow;
     return row ? this.rowToRecord(row) : null;
   }
 
   getAll(): RepoRecord[] {
-    const rows = this.db.query(`SELECT * FROM repos WHERE excluded = 0 ORDER BY name`).all() as any[];
+    const rows = this.db.query(`SELECT * FROM repos WHERE excluded = 0 ORDER BY name`).all() as RepoRow[];
     return rows.map(r => this.rowToRecord(r));
   }
 
   getAllNames(): string[] {
-    const rows = this.db.query(`SELECT name FROM repos WHERE excluded = 0 ORDER BY name`).all() as any[];
+    const rows = this.db.query(`SELECT name FROM repos WHERE excluded = 0 ORDER BY name`).all() as { name: string }[];
     return rows.map(r => r.name);
   }
 
@@ -94,7 +104,7 @@ export class RepoRegistry {
     }
   }
 
-  private rowToRecord(row: any): RepoRecord {
+  private rowToRecord(row: RepoRow): RepoRecord {
     return {
       name: row.name,
       url: row.url,
@@ -124,6 +134,13 @@ export function parseGhRepoLine(line: string): GhRepoParsed | null {
   return { name, owner, fullName };
 }
 
+interface GhRepoResponse {
+  name: string;
+  owner?: { login: string };
+  defaultBranchRef?: { name: string };
+  isArchived: boolean;
+}
+
 export async function syncGitHub(
   registry: RepoRegistry,
   orgs?: string[]
@@ -150,10 +167,11 @@ export async function syncGitHub(
         continue;
       }
 
-      let repos: any[];
+      let repos: GhRepoResponse[];
       try {
         repos = JSON.parse(output);
       } catch {
+        // JSON parsing failed — log and skip this org
         logger.warn("gh repo list returned invalid JSON", { org });
         continue;
       }

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) {
@@ -88,23 +102,30 @@ export class ClaudeRunner implements AgentRunner {
                 }
               }
             }
-          } catch {}
+          } catch {
+            // Non-JSON line in stream output — skip
+          }
         }
       }
     } finally {
       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 {
@@ -116,16 +130,23 @@ export class CodexRunner implements AgentRunner {
             if (event.type === "turn.failed") {
               errorMessage = event.error?.message || "Turn failed";
             }
-          } catch {}
+          } catch {
+            // Non-JSON line in stream output — skip
+          }
         }
       }
     } finally {
       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/schedules.ts

@@ -1,5 +1,15 @@
 import { Database } from "bun:sqlite";
 
+interface ScheduleRow {
+  id: number;
+  user_id: string;
+  repo: string;
+  prompt: string;
+  schedule: string;
+  description: string | null;
+  created_at: string;
+}
+
 export interface Schedule {
   id: number;
   userId: string;
@@ -45,7 +55,7 @@ export class ScheduleStore {
   }
 
   listByUser(userId: string): Schedule[] {
-    return (this.db.query(`SELECT * FROM schedules WHERE user_id = ? ORDER BY id`).all(userId) as any[])
+    return (this.db.query(`SELECT * FROM schedules WHERE user_id = ? ORDER BY id`).all(userId) as ScheduleRow[])
       .map(this.rowToSchedule);
   }
 
@@ -55,11 +65,11 @@ export class ScheduleStore {
   }
 
   getAll(): Schedule[] {
-    return (this.db.query(`SELECT * FROM schedules ORDER BY id`).all() as any[])
+    return (this.db.query(`SELECT * FROM schedules ORDER BY id`).all() as ScheduleRow[])
       .map(this.rowToSchedule);
   }
 
-  private rowToSchedule(row: any): Schedule {
+  private rowToSchedule(row: ScheduleRow): Schedule {
     return {
       id: row.id,
       userId: row.user_id,

package/src/sessions.ts

@@ -6,6 +6,12 @@ export interface ChatMessage {
   timestamp: string;
 }
 
+interface ChatMessageRow {
+  role: string;
+  content: string;
+  created_at: string;
+}
+
 export class SessionStore {
   private db: Database;
 
@@ -38,12 +44,12 @@ export class SessionStore {
          ORDER BY id DESC
          LIMIT ?`
       )
-      .all(userId, limit) as any[];
+      .all(userId, limit) as ChatMessageRow[];
 
     return rows
       .reverse()
       .map((r) => ({
-        role: r.role,
+        role: r.role as "user" | "assistant",
         content: r.content,
         timestamp: r.created_at,
       }));

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]);
+  }
+}