prodboard 0.1.3 → 0.2.1

package/src/config.ts

@@ -72,6 +72,14 @@ export function getDefaults(): Config {
       idPrefix: "",
     },
     daemon: {
+      agent: "claude",
+      basePath: null,
+      useTmux: true,
+      opencode: {
+        serverUrl: null,
+        model: null,
+        agent: null,
+      },
       maxConcurrentRuns: 2,
       maxTurns: 50,
       hardMaxTurns: 200,
@@ -104,6 +112,12 @@ export function getDefaults(): Config {
       ],
       useWorktrees: "auto",
     },
+    webui: {
+      enabled: false,
+      port: 3838,
+      hostname: "127.0.0.1",
+      password: null,
+    },
   };
 }
 
@@ -126,13 +140,13 @@ export function deepMerge(defaults: any, user: any): any {
   return result;
 }
 
-export function loadConfig(configDir?: string): Config {
+export function loadConfigRaw(configDir?: string): { config: Config; rawParsed: any } {
   const dir = configDir ?? PRODBOARD_DIR;
   const configPath = path.join(dir, "config.jsonc");
   const defaults = getDefaults();
 
   if (!fs.existsSync(configPath)) {
-    return defaults;
+    return { config: defaults, rawParsed: {} };
   }
 
   let text: string;
@@ -151,5 +165,90 @@ export function loadConfig(configDir?: string): Config {
     throw new Error(`Invalid JSON in config file ${configPath}: ${err.message}`);
   }
 
-  return deepMerge(defaults, parsed);
+  return { config: deepMerge(defaults, parsed), rawParsed: parsed };
+}
+
+export function loadConfig(configDir?: string): Config {
+  return loadConfigRaw(configDir).config;
+}
+
+export function validateConfig(rawParsed: any): { errors: string[]; warnings: string[] } {
+  const errors: string[] = [];
+  const warnings: string[] = [];
+
+  if (typeof rawParsed !== "object" || rawParsed === null) {
+    errors.push("Config must be a JSON object.");
+    return { errors, warnings };
+  }
+
+  const knownTopLevel = ["general", "daemon", "webui"];
+  for (const key of Object.keys(rawParsed)) {
+    if (!knownTopLevel.includes(key)) {
+      warnings.push(`Unknown top-level key "${key}". Known keys: ${knownTopLevel.join(", ")}`);
+    }
+  }
+
+  const g = rawParsed.general;
+  if (g !== undefined) {
+    if (g.statuses !== undefined && (!Array.isArray(g.statuses) || !g.statuses.every((s: any) => typeof s === "string"))) {
+      warnings.push("general.statuses must be an array of strings.");
+    }
+    if (g.defaultStatus !== undefined && typeof g.defaultStatus !== "string") {
+      warnings.push(`general.defaultStatus must be a string, got ${typeof g.defaultStatus}.`);
+    }
+  }
+
+  const d = rawParsed.daemon;
+  if (d !== undefined) {
+    if (d.agent !== undefined && d.agent !== "claude" && d.agent !== "opencode") {
+      warnings.push(`daemon.agent must be "claude" or "opencode", got "${d.agent}".`);
+    }
+    if (d.useWorktrees !== undefined && !["auto", "always", "never"].includes(d.useWorktrees)) {
+      warnings.push(`daemon.useWorktrees must be "auto", "always", or "never", got "${d.useWorktrees}".`);
+    }
+    if (d.useTmux !== undefined && typeof d.useTmux !== "boolean") {
+      warnings.push(`daemon.useTmux must be a boolean, got ${typeof d.useTmux}.`);
+    }
+    for (const numField of ["maxConcurrentRuns", "maxTurns", "hardMaxTurns", "runTimeoutSeconds", "runRetentionDays"]) {
+      if (d[numField] !== undefined && typeof d[numField] !== "number") {
+        warnings.push(`daemon.${numField} must be a number, got ${typeof d[numField]}.`);
+      }
+    }
+  }
+
+  const w = rawParsed.webui;
+  if (w !== undefined) {
+    if (w.enabled !== undefined && typeof w.enabled !== "boolean") {
+      warnings.push(`webui.enabled must be a boolean, got ${typeof w.enabled}.`);
+    }
+    if (w.port !== undefined && (typeof w.port !== "number" || w.port < 1 || w.port > 65535)) {
+      warnings.push(`webui.port must be a number between 1 and 65535, got ${JSON.stringify(w.port)}.`);
+    }
+    if (w.hostname !== undefined && typeof w.hostname !== "string") {
+      warnings.push(`webui.hostname must be a string, got ${typeof w.hostname}.`);
+    }
+    if (w.password !== undefined && w.password !== null && typeof w.password !== "string") {
+      warnings.push(`webui.password must be a string or null, got ${typeof w.password}.`);
+    }
+  }
+
+  return { errors, warnings };
+}
+
+export async function checkWebuiDependencies(): Promise<string[]> {
+  const warnings: string[] = [];
+  try {
+    await import("hono");
+  } catch {
+    warnings.push("webui is enabled but 'hono' is not installed. Run: bun install");
+  }
+  try {
+    await import("hono/jsx/jsx-runtime");
+  } catch {
+    warnings.push(
+      "webui is enabled but the Hono JSX runtime could not be loaded. " +
+      "If prodboard is installed globally, you may need to install hono in the global package directory."
+    );
+  }
+  return warnings;
 }

package/src/db.ts

@@ -101,6 +101,13 @@ const MIGRATIONS: Migration[] = [
       CREATE INDEX IF NOT EXISTS idx_runs_started ON runs(started_at);
     `,
   },
+  {
+    version: 2,
+    sql: `
+      ALTER TABLE runs ADD COLUMN tmux_session TEXT;
+      ALTER TABLE runs ADD COLUMN agent TEXT NOT NULL DEFAULT 'claude';
+    `,
+  },
 ];
 
 export { MIGRATIONS };

package/src/index.ts

@@ -137,6 +137,8 @@ export async function main(): Promise<void> {
         const daemonMod = await import("./commands/daemon.ts");
         if (sub === "status") {
           await daemonMod.daemonStatus(args.slice(2));
+        } else if (sub === "restart") {
+          await daemonMod.daemonRestart(args.slice(2));
         } else {
           await daemonMod.daemonStart(args.slice(1));
         }
@@ -201,6 +203,8 @@ Commands:
   comments <id>     List comments for an issue
   schedule <sub>    Manage scheduled tasks
   daemon            Start the scheduler daemon
+  daemon restart    Restart the daemon (systemd)
+  daemon status     Show daemon status
   install           Install systemd service
   uninstall         Remove systemd service
   config            Show configuration

package/src/invocation.ts

@@ -1,7 +1,5 @@
-import * as path from "path";
 import type { Config, Schedule, Run, EnvironmentInfo } from "./types.ts";
-import { PRODBOARD_DIR } from "./config.ts";
-import { getLastSessionId } from "./queries/runs.ts";
+import { ClaudeDriver } from "./agents/claude.ts";
 import { Database } from "bun:sqlite";
 
 export function detectEnvironment(workdir: string, config: Config): EnvironmentInfo {
@@ -24,9 +22,18 @@ export function detectEnvironment(workdir: string, config: Config): EnvironmentI
     hasClaude = result.exitCode === 0;
   } catch {}
 
+  let hasOpencode = false;
+  try {
+    const result = Bun.spawnSync(["opencode", "--version"], {
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    hasOpencode = result.exitCode === 0;
+  } catch {}
+
   const worktreeSupported = hasGit && config.daemon.useWorktrees !== "never";
 
-  return { hasGit, hasClaude, worktreeSupported };
+  return { hasGit, hasClaude, hasOpencode, worktreeSupported };
 }
 
 export function buildInvocation(
@@ -37,66 +44,6 @@ export function buildInvocation(
   resolvedPrompt: string,
   db?: Database
 ): string[] {
-  const args: string[] = ["claude"];
-
-  // Prompt
-  args.push("-p", resolvedPrompt);
-
-  // Permissions
-  args.push("--dangerously-skip-permissions");
-
-  // Output format
-  args.push("--verbose", "--output-format", "stream-json");
-
-  // MCP config
-  const mcpConfigPath = path.join(PRODBOARD_DIR, "mcp.json");
-  args.push("--mcp-config", mcpConfigPath);
-
-  // System prompt
-  const systemPromptFile = env.hasGit
-    ? path.join(PRODBOARD_DIR, "system-prompt.md")
-    : path.join(PRODBOARD_DIR, "system-prompt-nogit.md");
-  args.push("--append-system-prompt-file", systemPromptFile);
-
-  // Max turns: min of schedule override, config default, and hard max
-  const scheduleTurns = schedule.max_turns ?? config.daemon.maxTurns;
-  const maxTurns = Math.min(scheduleTurns, config.daemon.hardMaxTurns);
-  args.push("--max-turns", String(maxTurns));
-
-  // Allowed tools
-  let tools: string[];
-  if (schedule.allowed_tools) {
-    try {
-      tools = JSON.parse(schedule.allowed_tools);
-    } catch {
-      tools = env.hasGit ? config.daemon.defaultAllowedTools : config.daemon.nonGitDefaultAllowedTools;
-    }
-  } else if (!env.hasGit) {
-    tools = config.daemon.nonGitDefaultAllowedTools;
-  } else {
-    tools = config.daemon.defaultAllowedTools;
-  }
-  for (const tool of tools) {
-    args.push("--allowedTools", tool);
-  }
-
-  // Worktree
-  if (env.worktreeSupported && schedule.use_worktree !== 0) {
-    args.push("--worktree");
-  }
-
-  // Session resume
-  if (schedule.persist_session && db) {
-    const lastSessionId = getLastSessionId(db, schedule.id);
-    if (lastSessionId) {
-      args.push("--resume", lastSessionId);
-    }
-  }
-
-  // Agents JSON
-  if (schedule.agents_json) {
-    args.push("--agents", schedule.agents_json);
-  }
-
-  return args;
+  const driver = new ClaudeDriver();
+  return driver.buildCommand({ schedule, run, config, env, resolvedPrompt, workdir: schedule.workdir, db: db! });
 }

package/src/opencode-server.ts

@@ -0,0 +1,54 @@
+import type { Config } from "./types.ts";
+
+export class OpenCodeServerManager {
+  private serverProcess: any = null;
+  private _url: string;
+
+  constructor(config: Config) {
+    this._url = config.daemon.opencode.serverUrl ?? "http://localhost:4096";
+  }
+
+  async isRunning(): Promise<boolean> {
+    try {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), 2000);
+      const res = await fetch(`${this._url}/global/health`, { signal: controller.signal });
+      clearTimeout(timeout);
+      return res.ok;
+    } catch {
+      return false;
+    }
+  }
+
+  async ensureRunning(): Promise<string> {
+    if (await this.isRunning()) return this._url;
+
+    this.serverProcess = Bun.spawn(["opencode", "serve"], {
+      stdout: "ignore",
+      stderr: "ignore",
+      env: process.env,
+    });
+
+    // Poll health endpoint for up to 30s
+    const deadline = Date.now() + 30_000;
+    while (Date.now() < deadline) {
+      await new Promise((resolve) => setTimeout(resolve, 1000));
+      if (await this.isRunning()) return this._url;
+    }
+
+    throw new Error(`OpenCode server failed to start at ${this._url} within 30 seconds`);
+  }
+
+  async stop(): Promise<void> {
+    if (this.serverProcess) {
+      try {
+        this.serverProcess.kill("SIGTERM");
+      } catch {}
+      this.serverProcess = null;
+    }
+  }
+
+  get url(): string {
+    return this._url;
+  }
+}

package/src/queries/runs.ts

@@ -4,15 +4,15 @@ import { generateId } from "../ids.ts";
 
 export function createRun(
   db: Database,
-  opts: { schedule_id: string; prompt_used: string; pid?: number }
+  opts: { schedule_id: string; prompt_used: string; pid?: number; agent?: string }
 ): Run {
   const id = generateId();
   const now = new Date().toISOString().replace("T", " ").slice(0, 19);
 
   db.query(`
-    INSERT INTO runs (id, schedule_id, status, prompt_used, pid, started_at)
-    VALUES (?, ?, 'running', ?, ?, ?)
-  `).run(id, opts.schedule_id, opts.prompt_used, opts.pid ?? null, now);
+    INSERT INTO runs (id, schedule_id, status, prompt_used, pid, agent, started_at)
+    VALUES (?, ?, 'running', ?, ?, ?, ?)
+  `).run(id, opts.schedule_id, opts.prompt_used, opts.pid ?? null, opts.agent ?? "claude", now);
 
   return db.query("SELECT * FROM runs WHERE id = ?").get(id) as Run;
 }
@@ -31,6 +31,7 @@ export function updateRun(
     session_id: "session_id", worktree_path: "worktree_path",
     tokens_in: "tokens_in", tokens_out: "tokens_out", cost_usd: "cost_usd",
     tools_used: "tools_used", issues_touched: "issues_touched",
+    tmux_session: "tmux_session", agent: "agent",
     prompt_used: "prompt_used", pid: "pid",
   };