prodboard 0.1.3 → 0.2.1

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # prodboard
 
+## 0.2.1
+
+### Patch Changes
+
+- [#9](https://github.com/G4brym/prodboard/pull/9) [`d418fc4`](https://github.com/G4brym/prodboard/commit/d418fc41b52e26789dd3b5be7f2dcdf9429ef287) Thanks [@G4brym](https://github.com/G4brym)! - Add `daemon restart` command with config validation and webui dependency checks. The `install` command now also validates config before proceeding. Invalid config values produce clear warnings with fix tips.
+
+## 0.2.0
+
+### Minor Changes
+
+- [#6](https://github.com/G4brym/prodboard/pull/6) [`030c913`](https://github.com/G4brym/prodboard/commit/030c9136dc344e93616e0ef6014bab25d45b50d5) Thanks [@G4brym](https://github.com/G4brym)! - Add OpenCode support, prodboard-managed worktrees, tmux session wrapping, configurable base path, and web UI
+
 ## 0.1.3
 
 ### Patch Changes

package/README.md

@@ -1,22 +1,27 @@
 # prodboard
 
-Give Claude Code a persistent task board and a cron scheduler so it can manage work across sessions.
+Give AI coding agents a persistent task board and a cron scheduler so they can manage work across sessions.
 
-**The problem:** Claude Code loses context between sessions. It can't remember what tasks exist, what's in progress, or what to work on next. There's no way to schedule it to run recurring jobs like daily triage or nightly CI.
+**The problem:** AI coding agents lose context between sessions. They can't remember what tasks exist, what's in progress, or what to work on next. There's no way to schedule them to run recurring jobs like daily triage or nightly CI.
 
-**The solution:** prodboard is a local issue tracker backed by SQLite that Claude Code can read and write through MCP tools. It also includes a cron daemon that spawns Claude Code on a schedule to work through tasks autonomously.
+**The solution:** prodboard is a local issue tracker backed by SQLite that agents can read and write through MCP tools. It includes a cron daemon that spawns agents on a schedule, with optional tmux session wrapping and git worktree isolation.
 
 ```
 You (CLI)  ──┐
-              ├──▶  SQLite DB  ◀──  MCP Server  ◀──  Claude Code
-Cron Daemon ──┘
+              ├──▶  SQLite DB  ◀──  MCP Server  ◀──  Claude Code / OpenCode
+Cron Daemon ──┘         ▲
+Web UI ─────────────────┘
 ```
 
 ## What You Get
 
-- **An issue board Claude Code can use** — Claude reads, creates, updates, and completes issues via MCP tools during any session
-- **Scheduled Claude Code runs** — Define cron jobs that spawn Claude Code to triage issues, run maintenance, or work through the backlog
-- **A CLI you can use too** — Same board, human-friendly commands. Add issues, check status, review what Claude did
+- **An issue board your agent can use** — The agent reads, creates, updates, and completes issues via MCP tools during any session
+- **Scheduled agent runs** — Define cron jobs that spawn your agent to triage issues, run maintenance, or work through the backlog
+- **Multiple agent support** — Works with Claude Code (default) and OpenCode
+- **tmux sessions** — Running agents are wrapped in tmux sessions you can attach to and watch live
+- **Git worktree isolation** — Each scheduled run gets its own worktree so concurrent runs don't conflict
+- **Web UI** — Optional browser-based kanban board for managing issues, schedules, and runs
+- **A CLI you can use too** — Same board, human-friendly commands. Add issues, check status, review what the agent did
 - **Everything local** — Single SQLite file at `~/.prodboard/db.sqlite`. No servers, no accounts, no cloud
 
 ## Quick Start
@@ -195,6 +200,30 @@ These are the tools Claude Code sees when connected to the board:
 
 MCP resources: `prodboard://issues` (board summary) and `prodboard://schedules` (active schedules).
 
+## Supported Agents
+
+prodboard works with multiple AI coding agents. Set `daemon.agent` in your config:
+
+| Agent | Config value | Notes |
+|-------|-------------|-------|
+| **Claude Code** | `"claude"` (default) | Uses `claude` CLI with `--dangerously-skip-permissions` |
+| **OpenCode** | `"opencode"` | Uses `opencode run` with JSON output. Prodboard auto-starts `opencode serve` if needed |
+
+OpenCode-specific settings:
+
+```jsonc
+{
+  "daemon": {
+    "agent": "opencode",
+    "opencode": {
+      "serverUrl": null,   // auto-detect or override (e.g., "http://localhost:4096")
+      "model": null,       // e.g., "anthropic/claude-sonnet-4-20250514"
+      "agent": null        // opencode agent name
+    }
+  }
+}
+```
+
 ## Configuration
 
 Config file: `~/.prodboard/config.jsonc`
@@ -207,17 +236,94 @@ Config file: `~/.prodboard/config.jsonc`
     "idPrefix": ""
   },
   "daemon": {
+    "agent": "claude",            // "claude" or "opencode"
+    "basePath": null,             // base path for worktrees and runs (null = use schedule workdir)
+    "useTmux": true,              // wrap agent runs in tmux sessions
     "maxConcurrentRuns": 2,
     "maxTurns": 50,
     "hardMaxTurns": 200,
     "runTimeoutSeconds": 1800,
     "runRetentionDays": 30,
     "logLevel": "info",
+    "logMaxSizeMb": 10,           // max size per log file in MB
+    "logMaxFiles": 5,             // max number of rotated log files
+    "defaultAllowedTools": [...], // tools allowed for git-repo runs
+    "nonGitDefaultAllowedTools": [...], // tools allowed for non-git runs
+    "useWorktrees": "auto"        // "auto", "always", or "never"
+  },
+  "webui": {
+    "enabled": false,             // enable the web UI
+    "port": 3838,
+    "hostname": "127.0.0.1",
+    "password": null              // set a password to require login
+  }
+}
+```
+
+## Web UI
+
+prodboard includes an optional browser-based interface for managing issues, schedules, and runs.
+
+To enable it, set `webui.enabled` in your config:
+
+```jsonc
+{
+  "webui": {
+    "enabled": true,
+    "port": 3838,
+    "password": "your-secret"  // optional — null for no auth
+  }
+}
+```
+
+Start the daemon and open `http://127.0.0.1:3838`. The web UI provides:
+
+- Kanban board with drag-and-drop issue management
+- Schedule creation and editing
+- Run monitoring with status, cost, and token usage
+- Password protection when `password` is set
+
+## tmux Sessions
+
+When `daemon.useTmux` is `true` (the default) and tmux is installed, each agent run is wrapped in a detached tmux session. This lets you attach and watch the agent work in real time:
+
+```bash
+# List active prodboard sessions
+tmux list-sessions | grep prodboard
+
+# Attach to a running agent
+tmux attach -t prodboard-<run-id-prefix>
+```
+
+The session name is `prodboard-` followed by the first 8 characters of the run ID (visible in `prodboard schedule logs`).
+
+If tmux is not installed, runs fall back to direct process spawning with piped stdout. A warning is logged at daemon startup.
+
+## Git Worktrees
+
+prodboard creates isolated git worktrees for each scheduled run, so concurrent runs in the same repository don't conflict.
+
+**Requirement:** You must set `daemon.basePath` in your config for worktrees to work. This tells prodboard where to create the `.worktrees/` directory. If `basePath` is `null` (the default), worktrees are disabled regardless of the `useWorktrees` setting.
+
+```jsonc
+{
+  "daemon": {
+    "basePath": "/home/you/my-project",  // required for worktrees
     "useWorktrees": "auto"
   }
 }
 ```
 
+| `useWorktrees` | Behavior |
+|---------------|----------|
+| `"auto"` (default) | Create worktrees when `basePath` is set, the directory is a git repo, and the schedule allows it |
+| `"always"` | Always create worktrees (fails if directory is not a git repo) |
+| `"never"` | Never create worktrees |
+
+Worktrees are created under `<basePath>/.worktrees/<run-id>` on a branch named `prodboard/<run-id>`, and automatically cleaned up (directory + branch deleted) after the run completes.
+
+Per-schedule control: set `use_worktree` to `false` on a schedule to skip worktree creation for that specific job.
+
 ## Scheduler Details
 
 ### Cron Syntax
@@ -282,10 +388,14 @@ prodboard install --force
 
 **MCP not connecting** — Verify `claude mcp add prodboard -- bunx prodboard mcp` was run, or check `~/.prodboard/mcp.json`.
 
-**Daemon not starting** — Check `~/.prodboard/logs/daemon.log`. Make sure `claude` CLI is installed and `ANTHROPIC_API_KEY` is set.
+**Daemon not starting** — Check `~/.prodboard/logs/daemon.log`. Make sure your agent CLI is installed (`claude` or `opencode`) and `ANTHROPIC_API_KEY` is set.
 
 **Stale PID file** — The daemon crashed. Run `prodboard daemon` to restart (auto-cleans stale PIDs).
 
+**tmux not working** — Install tmux (`apt install tmux` / `brew install tmux`). The daemon falls back to direct spawning without it.
+
+**Worktree errors** — Ensure the working directory is a git repo with at least one commit. Set `useWorktrees: "never"` to disable.
+
 ## Development
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prodboard",
-  "version": "0.1.3",
+  "version": "0.2.1",
   "description": "Self-hosted, CLI-first issue tracker and cron scheduler for AI coding agents",
   "type": "module",
   "license": "MIT",
@@ -33,7 +33,8 @@
     "release": "bun run test && bun run typecheck && npm publish"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.12.1"
+    "@modelcontextprotocol/sdk": "^1.12.1",
+    "hono": "^4.12.5"
   },
   "engines": {
     "bun": ">=1.0.0"
@@ -46,6 +47,7 @@
     "CHANGELOG.md"
   ],
   "devDependencies": {
+    "@changesets/changelog-github": "^0.5.2",
     "@changesets/cli": "^2.29.8",
     "@types/bun": "^1.3.9"
   }

package/src/agents/claude.ts

@@ -0,0 +1,107 @@
+import * as path from "path";
+import { PRODBOARD_DIR } from "../config.ts";
+import { getLastSessionId } from "../queries/runs.ts";
+import type { AgentDriver, AgentRunContext, AgentResult, StreamEvent } from "./types.ts";
+
+export class ClaudeDriver implements AgentDriver {
+  readonly name = "claude";
+
+  buildCommand(ctx: AgentRunContext): string[] {
+    const { schedule, config, env, resolvedPrompt, db } = ctx;
+    const args: string[] = ["claude"];
+
+    args.push("-p", resolvedPrompt);
+    args.push("--dangerously-skip-permissions");
+    args.push("--verbose", "--output-format", "stream-json");
+
+    const mcpConfigPath = path.join(PRODBOARD_DIR, "mcp.json");
+    args.push("--mcp-config", mcpConfigPath);
+
+    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);
+
+    const scheduleTurns = schedule.max_turns ?? config.daemon.maxTurns;
+    const maxTurns = Math.min(scheduleTurns, config.daemon.hardMaxTurns);
+    args.push("--max-turns", String(maxTurns));
+
+    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);
+    }
+
+    if (schedule.persist_session && db) {
+      const lastSessionId = getLastSessionId(db, schedule.id);
+      if (lastSessionId) {
+        args.push("--resume", lastSessionId);
+      }
+    }
+
+    if (schedule.agents_json) {
+      args.push("--agents", schedule.agents_json);
+    }
+
+    return args;
+  }
+
+  parseEvent(line: string): StreamEvent | null {
+    try {
+      return JSON.parse(line.trim());
+    } catch {
+      return null;
+    }
+  }
+
+  extractResult(events: StreamEvent[]): AgentResult {
+    let tokens_in = 0;
+    let tokens_out = 0;
+    let cost_usd = 0;
+    let session_id: string | null = null;
+    const tools_used = new Set<string>();
+    const issues_touched = new Set<string>();
+
+    for (const event of events) {
+      if (event.type === "init" && event.session_id) {
+        session_id = event.session_id;
+      }
+      if (event.type === "tool_use" && event.tool) {
+        tools_used.add(event.tool);
+        if (event.tool.startsWith("mcp__prodboard__") && event.tool_input?.id) {
+          issues_touched.add(event.tool_input.id);
+        }
+        if (event.tool.startsWith("mcp__prodboard__") && event.tool_input?.issue_id) {
+          issues_touched.add(event.tool_input.issue_id);
+        }
+      }
+      if (event.type === "result") {
+        if (event.result?.tokens_in) tokens_in = event.result.tokens_in;
+        if (event.result?.tokens_out) tokens_out = event.result.tokens_out;
+        if (event.result?.cost_usd) cost_usd = event.result.cost_usd;
+      }
+      if (event.tokens_in) tokens_in = event.tokens_in;
+      if (event.tokens_out) tokens_out = event.tokens_out;
+      if (event.cost_usd) cost_usd = event.cost_usd;
+    }
+
+    return {
+      tokens_in,
+      tokens_out,
+      cost_usd,
+      session_id,
+      tools_used: [...tools_used],
+      issues_touched: [...issues_touched],
+    };
+  }
+}

package/src/agents/index.ts

@@ -0,0 +1,18 @@
+import type { Config } from "../types.ts";
+import type { AgentDriver } from "./types.ts";
+import { ClaudeDriver } from "./claude.ts";
+import { OpenCodeDriver } from "./opencode.ts";
+
+export function createAgentDriver(config: Config): AgentDriver {
+  switch (config.daemon.agent) {
+    case "opencode":
+      return new OpenCodeDriver();
+    case "claude":
+    default:
+      return new ClaudeDriver();
+  }
+}
+
+export type { AgentDriver, AgentRunContext, AgentResult, StreamEvent } from "./types.ts";
+export { ClaudeDriver } from "./claude.ts";
+export { OpenCodeDriver } from "./opencode.ts";

package/src/agents/opencode.ts

@@ -0,0 +1,108 @@
+import type { AgentDriver, AgentRunContext, AgentResult, StreamEvent } from "./types.ts";
+import { getLastSessionId } from "../queries/runs.ts";
+
+export class OpenCodeDriver implements AgentDriver {
+  readonly name = "opencode";
+
+  buildCommand(ctx: AgentRunContext): string[] {
+    const { schedule, config, resolvedPrompt, workdir, db } = ctx;
+    const args: string[] = ["opencode", "run", resolvedPrompt];
+
+    args.push("--format", "json");
+    args.push("--dir", workdir);
+
+    const opencode = config.daemon.opencode;
+
+    if (opencode.serverUrl) {
+      args.push("--attach", opencode.serverUrl);
+    }
+
+    if (opencode.model) {
+      args.push("--model", opencode.model);
+    }
+
+    if (opencode.agent) {
+      args.push("--agent", opencode.agent);
+    }
+
+    if (schedule.persist_session && db) {
+      const lastSessionId = getLastSessionId(db, schedule.id);
+      if (lastSessionId) {
+        args.push("--session", lastSessionId, "--continue");
+      }
+    }
+
+    return args;
+  }
+
+  parseEvent(line: string): StreamEvent | null {
+    let text = line.trim();
+    if (!text) return null;
+
+    // Strip SSE data: prefix
+    if (text.startsWith("data: ")) {
+      text = text.slice(6);
+    }
+
+    try {
+      return JSON.parse(text);
+    } catch {
+      return null;
+    }
+  }
+
+  extractResult(events: StreamEvent[]): AgentResult {
+    let tokens_in = 0;
+    let tokens_out = 0;
+    let cost_usd = 0;
+    let session_id: string | null = null;
+    const tools_used = new Set<string>();
+    const issues_touched = new Set<string>();
+
+    for (const event of events) {
+      // OpenCode session.updated events
+      if (event.type === "session.updated" && event.session?.id) {
+        session_id = event.session.id;
+      }
+      if (event.type === "session.updated" && event.session?.usage) {
+        const usage = event.session.usage;
+        if (usage.input_tokens) tokens_in = usage.input_tokens;
+        if (usage.output_tokens) tokens_out = usage.output_tokens;
+        if (usage.cost_usd) cost_usd = usage.cost_usd;
+      }
+
+      // OpenCode tool events
+      if (event.type === "tool_use" && event.tool) {
+        tools_used.add(event.tool);
+        if (event.tool.startsWith("mcp__prodboard__") && event.tool_input?.id) {
+          issues_touched.add(event.tool_input.id);
+        }
+        if (event.tool.startsWith("mcp__prodboard__") && event.tool_input?.issue_id) {
+          issues_touched.add(event.tool_input.issue_id);
+        }
+      }
+
+      // Also handle message.part.updated events with tool info
+      if (event.type === "message.part.updated" && event.part?.type === "tool-invocation") {
+        if (event.part.toolName) {
+          tools_used.add(event.part.toolName);
+        }
+      }
+
+      // Fallback top-level fields
+      if (event.session_id) session_id = event.session_id;
+      if (event.tokens_in) tokens_in = event.tokens_in;
+      if (event.tokens_out) tokens_out = event.tokens_out;
+      if (event.cost_usd) cost_usd = event.cost_usd;
+    }
+
+    return {
+      tokens_in,
+      tokens_out,
+      cost_usd,
+      session_id,
+      tools_used: [...tools_used],
+      issues_touched: [...issues_touched],
+    };
+  }
+}

package/src/agents/types.ts

@@ -0,0 +1,41 @@
+import type { Database } from "bun:sqlite";
+import type { Config, Schedule, Run, EnvironmentInfo } from "../types.ts";
+
+export interface AgentResult {
+  tokens_in: number;
+  tokens_out: number;
+  cost_usd: number;
+  session_id: string | null;
+  tools_used: string[];
+  issues_touched: string[];
+}
+
+export interface AgentRunContext {
+  schedule: Schedule;
+  run: Run;
+  config: Config;
+  env: EnvironmentInfo;
+  resolvedPrompt: string;
+  workdir: string;
+  db: Database;
+}
+
+export interface StreamEvent {
+  type: string;
+  session_id?: string;
+  tool?: string;
+  tool_input?: any;
+  result?: {
+    tokens_in?: number;
+    tokens_out?: number;
+    cost_usd?: number;
+  };
+  [key: string]: any;
+}
+
+export interface AgentDriver {
+  readonly name: string;
+  buildCommand(ctx: AgentRunContext): string[];
+  parseEvent(line: string): StreamEvent | null;
+  extractResult(events: StreamEvent[]): AgentResult;
+}

package/src/commands/daemon.ts

@@ -1,11 +1,13 @@
 import * as fs from "fs";
 import * as path from "path";
+import * as os from "os";
 import { ensureDb } from "../db.ts";
-import { loadConfig, PRODBOARD_DIR } from "../config.ts";
+import { loadConfig, loadConfigRaw, validateConfig, checkWebuiDependencies, PRODBOARD_DIR } from "../config.ts";
 import { listSchedules } from "../queries/schedules.ts";
 import { getNextFire } from "../cron.ts";
 import { formatDate } from "../format.ts";
 import { Daemon } from "../scheduler.ts";
+import { systemctlAvailable, runSystemctl } from "./install.ts";
 
 function parseArgs(args: string[]): { flags: Record<string, string | boolean>; positional: string[] } {
   const flags: Record<string, string | boolean> = {};
@@ -110,3 +112,57 @@ export async function daemonStatus(args: string[]): Promise<void> {
     try { fs.unlinkSync(pidFile); } catch {}
   }
 }
+
+export async function daemonRestart(_args: string[]): Promise<void> {
+  // Validate config
+  let config;
+  try {
+    const { config: cfg, rawParsed } = loadConfigRaw();
+    config = cfg;
+    const { errors, warnings } = validateConfig(rawParsed);
+    for (const e of errors) {
+      console.error(`✗ Config: ${e}`);
+    }
+    if (errors.length > 0) {
+      process.exit(1);
+    }
+    for (const w of warnings) {
+      console.warn(`⚠ Config: ${w}`);
+    }
+  } catch (err: any) {
+    console.error(`Config error: ${err.message}`);
+    process.exit(1);
+  }
+
+  // Check webui dependencies
+  if (config.webui.enabled) {
+    const depWarnings = await checkWebuiDependencies();
+    for (const w of depWarnings) {
+      console.warn(`⚠ ${w}`);
+    }
+  }
+
+  // Check systemd availability
+  if (!(await systemctlAvailable())) {
+    console.error("systemd is not available. daemon restart requires systemd.");
+    process.exit(1);
+  }
+
+  // Check service file exists
+  const servicePath = path.join(os.homedir(), ".config", "systemd", "user", "prodboard.service");
+  if (!fs.existsSync(servicePath)) {
+    console.error("prodboard is not installed as a systemd service. Run: prodboard install");
+    process.exit(1);
+  }
+
+  // Restart and show status
+  const restart = await runSystemctl("restart", "prodboard");
+  if (restart.exitCode !== 0) {
+    console.error("Failed to restart prodboard:", restart.stderr);
+    process.exit(1);
+  }
+
+  console.log("prodboard daemon restarted.");
+  const { stdout } = await runSystemctl("status", "prodboard");
+  console.log(stdout);
+}

package/src/commands/install.ts

@@ -1,6 +1,7 @@
 import * as fs from "fs";
 import * as path from "path";
 import * as os from "os";
+import { loadConfigRaw, validateConfig, checkWebuiDependencies } from "../config.ts";
 
 const SERVICE_NAME = "prodboard";
 const SERVICE_DIR = path.join(os.homedir(), ".config", "systemd", "user");
@@ -16,7 +17,7 @@ function parseArgs(args: string[]): { flags: Record<string, boolean> } {
   return { flags };
 }
 
-async function systemctlAvailable(): Promise<boolean> {
+export async function systemctlAvailable(): Promise<boolean> {
   try {
     const proc = Bun.spawn(["systemctl", "--version"], {
       stdout: "ignore",
@@ -29,7 +30,7 @@ async function systemctlAvailable(): Promise<boolean> {
   }
 }
 
-async function runSystemctl(...args: string[]): Promise<{ exitCode: number; stdout: string; stderr: string }> {
+export async function runSystemctl(...args: string[]): Promise<{ exitCode: number; stdout: string; stderr: string }> {
   const proc = Bun.spawn(["systemctl", "--user", ...args], {
     stdout: "pipe",
     stderr: "pipe",
@@ -62,6 +63,24 @@ WantedBy=default.target
 export async function install(args: string[]): Promise<void> {
   const { flags } = parseArgs(args);
 
+  // Validate config before proceeding
+  try {
+    const { config, rawParsed } = loadConfigRaw();
+    const { warnings } = validateConfig(rawParsed);
+    for (const w of warnings) {
+      console.warn(`⚠ Config: ${w}`);
+    }
+    if (config.webui.enabled) {
+      const depWarnings = await checkWebuiDependencies();
+      for (const w of depWarnings) {
+        console.warn(`⚠ ${w}`);
+      }
+    }
+  } catch (err: any) {
+    console.error(`Config error: ${err.message}`);
+    process.exit(1);
+  }
+
   if (!(await systemctlAvailable())) {
     console.error("systemd is not available on this system.");
     console.error("The install command requires systemd (Linux).");

package/src/commands/schedules.ts

@@ -251,6 +251,7 @@ export async function scheduleRun(args: string[], dbOverride?: Database): Promis
     prompt_used: schedule.prompt,
   });
 
+  // CLI schedule run is a lightweight path without tmux/worktree support
   const em = new ExecutionManager(db, config);
   await em.executeRun(schedule, run);