@lovenyberg/ove 0.1.1 → 0.2.1

package/src/index.ts

@@ -1,8 +1,9 @@
 import { Database } from "bun:sqlite";
-import { loadConfig, isAuthorized, getUserRepos } from "./config";
+import { loadConfig, isAuthorized, getUserRepos, addRepo, addUser } from "./config";
 import { TaskQueue } from "./queue";
 import { RepoManager } from "./repos";
 import { ClaudeRunner } from "./runners/claude";
+import { CodexRunner } from "./runners/codex";
 import { parseMessage, buildContextualPrompt } from "./router";
 import { SlackAdapter } from "./adapters/slack";
 import { WhatsAppAdapter } from "./adapters/whatsapp";
@@ -13,7 +14,7 @@ import { HttpApiAdapter } from "./adapters/http";
 import { GitHubAdapter } from "./adapters/github";
 import type { ChatAdapter, IncomingMessage } from "./adapters/types";
 import type { EventAdapter, IncomingEvent } from "./adapters/types";
-import type { AgentRunner, StatusEvent } from "./runner";
+import type { AgentRunner, RunOptions, StatusEvent } from "./runner";
 import { logger } from "./logger";
 import { SessionStore } from "./sessions";
 import { startCronLoop } from "./cron";
@@ -42,7 +43,38 @@ const queue = new TaskQueue(db);
 const repos = new RepoManager(config.reposDir);
 const sessions = new SessionStore(db);
 const schedules = new ScheduleStore(db);
-const runner: AgentRunner = new ClaudeRunner();
+const runners = new Map<string, AgentRunner>();
+
+function getRunner(name: string = "claude"): AgentRunner {
+  let r = runners.get(name);
+  if (!r) {
+    switch (name) {
+      case "codex":
+        r = new CodexRunner();
+        break;
+      case "claude":
+      default:
+        r = new ClaudeRunner();
+        break;
+    }
+    runners.set(name, r);
+  }
+  return r;
+}
+
+function getRunnerForRepo(repo: string): AgentRunner {
+  const repoRunner = config.repos[repo]?.runner;
+  const globalRunner = config.runner;
+  const name = repoRunner?.name || globalRunner?.name || "claude";
+  return getRunner(name);
+}
+
+function getRunnerOptsForRepo(repo: string, baseOpts: RunOptions): RunOptions {
+  const repoRunner = config.repos[repo]?.runner;
+  const globalRunner = config.runner;
+  const model = repoRunner?.model || globalRunner?.model;
+  return model ? { ...baseOpts, model } : baseOpts;
+}
 
 // Reply callback map — stores original message for replying after task completion
 const pendingReplies = new Map<string, IncomingMessage>();
@@ -169,6 +201,7 @@ async function handleMessage(msg: IncomingMessage) {
       "• validate <repo> — run tests, unlike some people",
       "• discuss <topic> — I'll brainstorm, but no promises I'll be nice",
       "• create project <name> [with template <type>]",
+      "• init repo <name> <git-url> [branch] — set up a repo from chat",
       "• status / history / clear",
       "• <task> every day/weekday at <time> [on <repo>] — schedule a recurring task",
       "• list schedules — see your scheduled tasks",
@@ -216,7 +249,7 @@ async function handleMessage(msg: IncomingMessage) {
     const userRepos = getUserRepos(config, msg.userId);
 
     if (userRepos.length === 0) {
-      await msg.reply("You don't have access to any repos. Can't schedule what I can't reach.");
+      await msg.reply("You don't have access to any repos. Set one up first with `init repo <name> <git-url>`.");
       return;
     }
 
@@ -265,7 +298,8 @@ async function handleMessage(msg: IncomingMessage) {
     await msg.updateStatus("Thinking...");
 
     try {
-      const result = await runner.run(
+      const discussRunner = getRunner(config.runner?.name);
+      const result = await discussRunner.run(
         prompt,
         config.reposDir,
         { maxTurns: 5 },
@@ -306,6 +340,32 @@ async function handleMessage(msg: IncomingMessage) {
     return;
   }
 
+  // Init repo — onboarding a new repo from chat
+  if (parsed.type === "init-repo") {
+    const { name, url, branch } = parsed.args;
+
+    if (!/^[a-zA-Z0-9_-]+$/.test(name)) {
+      await msg.reply("Repo name must be alphanumeric, dashes, or underscores. Try again.");
+      return;
+    }
+
+    if (config.repos[name]) {
+      // Repo exists — just grant access
+      addUser(config, msg.userId, msg.userId, [name]);
+      const reply = `Repo "${name}" already exists. I've added you to it. Go ahead.`;
+      await msg.reply(reply);
+      sessions.addMessage(msg.userId, "assistant", reply);
+      return;
+    }
+
+    addRepo(config, name, url, branch);
+    addUser(config, msg.userId, msg.userId, [name]);
+    const reply = `Fine. Added repo "${name}" (${url}, branch: ${branch}). You're good to go — ask me to do something on ${name}.`;
+    await msg.reply(reply);
+    sessions.addMessage(msg.userId, "assistant", reply);
+    return;
+  }
+
   // Need a repo for task commands
   if (!parsed.repo) {
     const userRepos = getUserRepos(config, msg.userId);
@@ -317,7 +377,8 @@ async function handleMessage(msg: IncomingMessage) {
       sessions.addMessage(msg.userId, "assistant", reply);
       return;
     } else {
-      await msg.reply("You don't have access to any repos. Talk to someone about that.");
+      const reply = "You don't have access to any repos yet. Set one up:\n`init repo <name> <git-url> [branch]`\nExample: `init repo my-app git@github.com:user/my-app.git`";
+      await msg.reply(reply);
       return;
     }
   }
@@ -441,13 +502,16 @@ async function processTask(task: import("./queue").Task) {
         await Bun.write(mcpConfigPath, JSON.stringify({ mcpServers: config.mcpServers }));
       }
 
-      const result = await runner.run(
+      const taskRunner = getRunnerForRepo(task.repo);
+      const runOpts = getRunnerOptsForRepo(task.repo, {
+        maxTurns: config.claude.maxTurns,
+        mcpConfigPath,
+      });
+
+      const result = await taskRunner.run(
         task.prompt,
         workDir,
-        {
-          maxTurns: config.claude.maxTurns,
-          mcpConfigPath,
-        },
+        runOpts,
         (event: StatusEvent) => {
           if (event.kind === "tool") {
             statusLog.push(`${event.tool}: ${event.input}`);
@@ -528,7 +592,7 @@ async function workerLoop() {
 
 // Main
 async function main() {
-  logger.info("ove starting", { chatAdapters: adapters.length, eventAdapters: eventAdapters.length, runner: runner.name });
+  logger.info("ove starting", { chatAdapters: adapters.length, eventAdapters: eventAdapters.length, runner: config.runner?.name || "claude" });
 
   for (const adapter of adapters) {
     await adapter.start(handleMessage);

package/src/router.test.ts

@@ -124,6 +124,31 @@ describe("parseMessage", () => {
     expect(result.args.scheduleId).toBe(1);
   });
 
+  it("parses init repo with SSH URL", () => {
+    const result = parseMessage("init repo my-app git@github.com:user/my-app.git");
+    expect(result.type).toBe("init-repo");
+    expect(result.args.name).toBe("my-app");
+    expect(result.args.url).toBe("git@github.com:user/my-app.git");
+    expect(result.args.branch).toBe("main");
+  });
+
+  it("parses setup repo with HTTPS URL", () => {
+    const result = parseMessage("setup repo my-app https://github.com/user/my-app.git");
+    expect(result.type).toBe("init-repo");
+    expect(result.args.url).toBe("https://github.com/user/my-app.git");
+  });
+
+  it("parses add repo with custom branch", () => {
+    const result = parseMessage("add repo my-app git@github.com:org/my-app.git develop");
+    expect(result.type).toBe("init-repo");
+    expect(result.args.branch).toBe("develop");
+  });
+
+  it("does not match init repo without URL", () => {
+    const result = parseMessage("init repo my-app");
+    expect(result.type).not.toBe("init-repo");
+  });
+
   it("falls back to free-form for unrecognized input", () => {
     const result = parseMessage("what does the auth middleware do in my-app");
     expect(result.type).toBe("free-form");

package/src/router.ts

@@ -5,6 +5,7 @@ export type MessageType =
   | "validate"
   | "discuss"
   | "create-project"
+  | "init-repo"
   | "free-form"
   | "status"
   | "history"
@@ -84,6 +85,16 @@ export function parseMessage(text: string): ParsedMessage {
     return { type: "discuss", args: { topic: trimmed }, rawText: trimmed };
   }
 
+  // init repo <name> <url> [branch]
+  const initRepoMatch = trimmed.match(/^(?:init|setup|add)\s+repo\s+(\S+)\s+((?:git@|https:\/\/)\S+)(?:\s+(\S+))?$/i);
+  if (initRepoMatch) {
+    return {
+      type: "init-repo",
+      args: { name: initRepoMatch[1], url: initRepoMatch[2], branch: initRepoMatch[3] || "main" },
+      rawText: trimmed,
+    };
+  }
+
   const repoHint = trimmed.match(/(?:in|on)\s+(\S+)\s*$/i);
   return { type: "free-form", repo: repoHint?.[1], args: {}, rawText: trimmed };
 }

package/src/runner.ts

@@ -1,6 +1,7 @@
 export interface RunOptions {
   maxTurns: number;
   mcpConfigPath?: string;
+  model?: string;
 }
 
 export interface RunResult {

package/src/runners/codex.test.ts

@@ -0,0 +1,85 @@
+import { describe, it, expect } from "bun:test";
+import { CodexRunner, summarizeCodexItem } from "./codex";
+
+describe("CodexRunner", () => {
+  const runner = new CodexRunner();
+
+  it("has correct name", () => {
+    expect(runner.name).toBe("codex");
+  });
+
+  it("builds correct args for a prompt", () => {
+    const args = runner.buildArgs("fix the bug", "/tmp/work", {
+      maxTurns: 25,
+    });
+    expect(args).toContain("exec");
+    expect(args).toContain("--json");
+    expect(args).toContain("--dangerously-bypass-approvals-and-sandbox");
+    expect(args).toContain("--skip-git-repo-check");
+    expect(args).toContain("--ephemeral");
+    expect(args).toContain("-C");
+    expect(args).toContain("/tmp/work");
+    expect(args).toContain("fix the bug");
+  });
+
+  it("includes model flag when provided", () => {
+    const args = runner.buildArgs("test", "/tmp/work", {
+      maxTurns: 25,
+      model: "o3",
+    });
+    expect(args).toContain("-m");
+    expect(args).toContain("o3");
+  });
+
+  it("omits model flag when not provided", () => {
+    const args = runner.buildArgs("test", "/tmp/work", { maxTurns: 25 });
+    expect(args).not.toContain("-m");
+  });
+
+  it("ignores mcpConfigPath (not supported by codex CLI)", () => {
+    const args = runner.buildArgs("test", "/tmp/work", {
+      maxTurns: 25,
+      mcpConfigPath: "/tmp/mcp.json",
+    });
+    expect(args).not.toContain("--mcp-config");
+    expect(args).not.toContain("/tmp/mcp.json");
+  });
+});
+
+describe("summarizeCodexItem", () => {
+  it("summarizes command_execution", () => {
+    expect(
+      summarizeCodexItem({ type: "command_execution", command: "bun test" })
+    ).toEqual({ tool: "shell", input: "bun test" });
+  });
+
+  it("summarizes file_change with paths", () => {
+    const result = summarizeCodexItem({
+      type: "file_change",
+      changes: [
+        { path: "src/a.ts", kind: "update" },
+        { path: "src/b.ts", kind: "add" },
+      ],
+    });
+    expect(result).toEqual({ tool: "file_change", input: "src/a.ts, src/b.ts" });
+  });
+
+  it("summarizes mcp_tool_call", () => {
+    const result = summarizeCodexItem({
+      type: "mcp_tool_call",
+      tool: "search",
+      arguments: '{"q":"hello"}',
+    });
+    expect(result).toEqual({ tool: "search", input: '{"q":"hello"}' });
+  });
+
+  it("returns null for agent_message", () => {
+    expect(
+      summarizeCodexItem({ type: "agent_message", text: "done" })
+    ).toBeNull();
+  });
+
+  it("returns null for unknown types", () => {
+    expect(summarizeCodexItem({ type: "reasoning", text: "thinking" })).toBeNull();
+  });
+});

package/src/runners/codex.ts

@@ -0,0 +1,137 @@
+import type {
+  AgentRunner,
+  RunOptions,
+  RunResult,
+  StatusCallback,
+} from "../runner";
+import { logger } from "../logger";
+import { which } from "bun";
+import { realpathSync } from "node:fs";
+
+export function summarizeCodexItem(
+  item: any
+): { tool: string; input: string } | null {
+  if (!item) return null;
+  switch (item.type) {
+    case "command_execution":
+      return { tool: "shell", input: item.command || "" };
+    case "file_change": {
+      const paths = (item.changes || [])
+        .map((c: any) => c.path)
+        .filter(Boolean)
+        .join(", ");
+      return { tool: "file_change", input: paths };
+    }
+    case "mcp_tool_call":
+      return {
+        tool: item.tool || "mcp",
+        input:
+          typeof item.arguments === "string"
+            ? item.arguments
+            : JSON.stringify(item.arguments || "").slice(0, 80),
+      };
+    default:
+      return null;
+  }
+}
+
+export class CodexRunner implements AgentRunner {
+  name = "codex";
+  private codexPath: string;
+
+  constructor() {
+    const found = which("codex");
+    this.codexPath = found ? realpathSync(found) : "codex";
+  }
+
+  buildArgs(prompt: string, workDir: string, opts: RunOptions): string[] {
+    const args = [
+      "exec",
+      "--json",
+      "--dangerously-bypass-approvals-and-sandbox",
+      "--skip-git-repo-check",
+      "--ephemeral",
+      "-C",
+      workDir,
+    ];
+    if (opts.model) args.push("-m", opts.model);
+    args.push(prompt);
+    return args;
+  }
+
+  async run(
+    prompt: string,
+    workDir: string,
+    opts: RunOptions,
+    onStatus?: StatusCallback
+  ): Promise<RunResult> {
+    const args = this.buildArgs(prompt, workDir, opts);
+    const startTime = Date.now();
+    logger.info("starting codex task", {
+      workDir,
+      model: opts.model,
+      codexPath: this.codexPath,
+    });
+
+    const proc = Bun.spawn([this.codexPath, ...args], {
+      cwd: workDir,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    let lastAgentMessage: string | null = null;
+    let errorMessage: string | null = null;
+    const decoder = new TextDecoder();
+    const reader = proc.stdout.getReader();
+
+    try {
+      let buffer = "";
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          try {
+            const event = JSON.parse(line);
+            if (
+              event.type === "item.completed" &&
+              event.item?.type === "agent_message"
+            ) {
+              lastAgentMessage = event.item.text || "";
+              if (onStatus) onStatus({ kind: "text", text: lastAgentMessage });
+            }
+            if (event.type === "item.started" && event.item) {
+              const summary = summarizeCodexItem(event.item);
+              if (summary && onStatus) {
+                onStatus({ kind: "tool", ...summary });
+              }
+            }
+            if (event.type === "turn.failed") {
+              errorMessage = event.error?.message || "Turn failed";
+            }
+          } catch {}
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+
+    const exitCode = await proc.exited;
+    const durationMs = Date.now() - startTime;
+
+    if (exitCode !== 0) {
+      const stderr = await new Response(proc.stderr).text();
+      const output = errorMessage || stderr || "Codex task failed";
+      logger.error("codex task failed", { exitCode, output, durationMs });
+      return { success: false, output, durationMs };
+    }
+
+    const finalOutput =
+      lastAgentMessage || "Task completed (no output)";
+    logger.info("codex task completed", { durationMs });
+    return { success: true, output: finalOutput, durationMs };
+  }
+}

package/src/setup.test.ts

@@ -4,29 +4,30 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { validateConfig } from "./setup";
 
+const TRANSPORT_ENV_KEYS = [
+  "CLI_MODE", "SLACK_BOT_TOKEN", "SLACK_APP_TOKEN",
+  "TELEGRAM_BOT_TOKEN", "DISCORD_BOT_TOKEN", "WHATSAPP_ENABLED",
+  "HTTP_API_PORT", "HTTP_API_KEY", "GITHUB_POLL_REPOS",
+] as const;
+
 describe("validateConfig", () => {
   let dir: string;
-  const origCliMode = process.env.CLI_MODE;
-  const origSlackBot = process.env.SLACK_BOT_TOKEN;
-  const origSlackApp = process.env.SLACK_APP_TOKEN;
+  const origEnv: Record<string, string | undefined> = {};
 
   beforeEach(() => {
     dir = mkdtempSync(join(tmpdir(), "ove-setup-test-"));
-    // Clear env to avoid interference
-    delete process.env.CLI_MODE;
-    delete process.env.SLACK_BOT_TOKEN;
-    delete process.env.SLACK_APP_TOKEN;
+    for (const key of TRANSPORT_ENV_KEYS) {
+      origEnv[key] = process.env[key];
+      delete process.env[key];
+    }
   });
 
   afterEach(() => {
     rmSync(dir, { recursive: true, force: true });
-    // Restore env
-    if (origCliMode !== undefined) process.env.CLI_MODE = origCliMode;
-    else delete process.env.CLI_MODE;
-    if (origSlackBot !== undefined) process.env.SLACK_BOT_TOKEN = origSlackBot;
-    else delete process.env.SLACK_BOT_TOKEN;
-    if (origSlackApp !== undefined) process.env.SLACK_APP_TOKEN = origSlackApp;
-    else delete process.env.SLACK_APP_TOKEN;
+    for (const key of TRANSPORT_ENV_KEYS) {
+      if (origEnv[key] !== undefined) process.env[key] = origEnv[key];
+      else delete process.env[key];
+    }
   });
 
   it("reports missing config.json", () => {
@@ -105,14 +106,14 @@ describe("validateConfig", () => {
     expect(result.issues).toContain("SLACK_APP_TOKEN is a placeholder");
   });
 
-  it("skips Slack token checks when CLI_MODE=true in env file", () => {
+  it("skips Slack validation when no Slack tokens present", () => {
     const configPath = join(dir, "config.json");
     const envPath = join(dir, ".env");
     writeFileSync(configPath, JSON.stringify({
       repos: { app: { url: "git@github.com:o/a.git", defaultBranch: "main" } },
       users: { "cli:local": { name: "test", repos: ["app"] } },
     }));
-    writeFileSync(envPath, "CLI_MODE=true\nSLACK_BOT_TOKEN=xoxb-...\n");
+    writeFileSync(envPath, "CLI_MODE=true\n");
 
     const result = validateConfig({ configPath, envPath });
 
@@ -120,16 +121,82 @@ describe("validateConfig", () => {
     expect(result.issues).toEqual([]);
   });
 
-  it("skips Slack token checks when CLI_MODE=true in process.env", () => {
+  it("still validates Slack placeholders even in CLI_MODE", () => {
+    const configPath = join(dir, "config.json");
+    const envPath = join(dir, ".env");
+    writeFileSync(configPath, JSON.stringify({
+      repos: { app: { url: "git@github.com:o/a.git", defaultBranch: "main" } },
+      users: { "cli:local": { name: "test", repos: ["app"] } },
+    }));
+    writeFileSync(envPath, "CLI_MODE=true\nSLACK_BOT_TOKEN=xoxb-...\n");
+
+    const result = validateConfig({ configPath, envPath });
+
+    expect(result.valid).toBe(false);
+    expect(result.issues).toContain("SLACK_BOT_TOKEN is a placeholder");
+  });
+
+  it("reports no transport configured", () => {
     const configPath = join(dir, "config.json");
     const envPath = join(dir, ".env");
     writeFileSync(configPath, JSON.stringify({
       repos: { app: { url: "git@github.com:o/a.git", defaultBranch: "main" } },
       users: { "cli:local": { name: "test", repos: ["app"] } },
     }));
-    writeFileSync(envPath, "SLACK_BOT_TOKEN=xoxb-...\n");
+    writeFileSync(envPath, "REPOS_DIR=./repos\n");
+
+    const result = validateConfig({ configPath, envPath });
+
+    expect(result.valid).toBe(false);
+    expect(result.issues).toContain("No transport configured");
+  });
+
+  it("valid with Telegram-only config", () => {
+    const configPath = join(dir, "config.json");
+    const envPath = join(dir, ".env");
+    writeFileSync(configPath, JSON.stringify({
+      repos: { app: { url: "git@github.com:o/a.git", defaultBranch: "main" } },
+      users: { "telegram:123456": { name: "test", repos: ["app"] } },
+    }));
+    writeFileSync(envPath, "TELEGRAM_BOT_TOKEN=123456:ABC-DEF\n");
+
+    const result = validateConfig({ configPath, envPath });
+
+    expect(result.valid).toBe(true);
+    expect(result.issues).toEqual([]);
+  });
+
+  it("valid with Discord-only config", () => {
+    const configPath = join(dir, "config.json");
+    const envPath = join(dir, ".env");
+    writeFileSync(configPath, JSON.stringify({
+      repos: { app: { url: "git@github.com:o/a.git", defaultBranch: "main" } },
+      users: { "discord:987654": { name: "test", repos: ["app"] } },
+    }));
+    writeFileSync(envPath, "DISCORD_BOT_TOKEN=MTIz-abc\n");
+
+    const result = validateConfig({ configPath, envPath });
+
+    expect(result.valid).toBe(true);
+    expect(result.issues).toEqual([]);
+  });
+
+  it("valid with multiple transports", () => {
+    const configPath = join(dir, "config.json");
+    const envPath = join(dir, ".env");
+    writeFileSync(configPath, JSON.stringify({
+      repos: { app: { url: "git@github.com:o/a.git", defaultBranch: "main" } },
+      users: {
+        "slack:U123": { name: "test", repos: ["app"] },
+        "telegram:456": { name: "test", repos: ["app"] },
+      },
+    }));
+    writeFileSync(envPath, [
+      "SLACK_BOT_TOKEN=xoxb-real-token",
+      "SLACK_APP_TOKEN=xapp-real-token",
+      "TELEGRAM_BOT_TOKEN=123:ABC",
+    ].join("\n") + "\n");
 
-    process.env.CLI_MODE = "true";
     const result = validateConfig({ configPath, envPath });
 
     expect(result.valid).toBe(true);
@@ -178,7 +245,7 @@ describe("validateConfig", () => {
     expect(result.issues).toContain("config.json is invalid JSON");
   });
 
-  it("returns valid for complete config", () => {
+  it("returns valid for complete Slack config", () => {
     const configPath = join(dir, "config.json");
     const envPath = join(dir, ".env");
     writeFileSync(configPath, JSON.stringify({