prodboard 0.2.3 → 0.3.0

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # prodboard
 
+## 0.3.0
+
+### Minor Changes
+
+- [#17](https://github.com/G4brym/prodboard/pull/17) [`20f3860`](https://github.com/G4brym/prodboard/commit/20f38608b1a5a9d986bcf1d04d4dfb579fa7ec18) Thanks [@G4brym](https://github.com/G4brym)! - Add `trigger_schedule` MCP tool to manually trigger a schedule run
+
+  Adds a new MCP tool that allows agents and users to trigger a schedule to run immediately without waiting for the cron interval. The run is started asynchronously and returns the run ID so callers can check status via `list_runs`. Disabled schedules are rejected, and the concurrent run limit is enforced.
+
+### Patch Changes
+
+- [#20](https://github.com/G4brym/prodboard/pull/20) [`53c5d4d`](https://github.com/G4brym/prodboard/commit/53c5d4d1ee7331e50f4b4cc5fb1aa8e37836967e) Thanks [@G4brym](https://github.com/G4brym)! - Fix schedules with identical cron patterns — all matching schedules now fire
+
+  Snapshot the running-run count once before the tick loop instead of re-querying
+  inside the loop. This prevents a run created for schedule A from counting against
+  schedule B's concurrency check when both share the same cron expression.
+
 ## 0.2.3
 
 ### Patch Changes

package/README.md

@@ -197,6 +197,7 @@ These are the tools Claude Code sees when connected to the board:
 | `create_schedule` | Set up a new cron job |
 | `update_schedule` | Modify a schedule |
 | `delete_schedule` | Remove a schedule |
+| `trigger_schedule` | Trigger a schedule to run immediately |
 | `list_runs` | Check run history and results |
 
 MCP resources: `prodboard://issues` (board summary) and `prodboard://schedules` (active schedules).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prodboard",
-  "version": "0.2.3",
+  "version": "0.3.0",
   "description": "Self-hosted, CLI-first issue tracker and cron scheduler for AI coding agents",
   "type": "module",
   "license": "MIT",

package/src/agents/claude.ts

@@ -86,13 +86,14 @@ export class ClaudeDriver implements AgentDriver {
         }
       }
       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.usage) {
+          tokens_in = (event.usage.input_tokens ?? 0)
+            + (event.usage.cache_read_input_tokens ?? 0)
+            + (event.usage.cache_creation_input_tokens ?? 0);
+          tokens_out = event.usage.output_tokens ?? 0;
+        }
+        if (event.total_cost_usd) cost_usd = event.total_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 {

package/src/agents/types.ts

@@ -25,10 +25,12 @@ export interface StreamEvent {
   session_id?: string;
   tool?: string;
   tool_input?: any;
-  result?: {
-    tokens_in?: number;
-    tokens_out?: number;
-    cost_usd?: number;
+  total_cost_usd?: number;
+  usage?: {
+    input_tokens?: number;
+    output_tokens?: number;
+    cache_read_input_tokens?: number;
+    cache_creation_input_tokens?: number;
   };
   [key: string]: any;
 }

package/src/commands/schedules.ts

@@ -205,6 +205,7 @@ export async function scheduleLogs(args: string[], dbOverride?: Database): Promi
     schedule_id: (flags.schedule ?? flags.s) as string | undefined,
     status: flags.status as string | undefined,
     limit: safeParseInt(flags.limit ?? flags.n),
+    include_output: isJson,
   });
 
   if (isJson) {

package/src/mcp.ts

@@ -200,16 +200,28 @@ const TOOLS = [
   },
   {
     name: "list_runs",
-    description: "List run history for schedules.",
+    description: "List run history for schedules. By default excludes large fields (stdout_tail, prompt_used) for compact output.",
     inputSchema: {
       type: "object" as const,
       properties: {
         schedule_id: { type: "string" as const, description: "Filter by schedule ID" },
         status: { type: "string" as const, description: "Filter by run status" },
         limit: { type: "number" as const, description: "Max runs to return" },
+        include_output: { type: "boolean" as const, description: "Include stdout_tail and prompt_used fields (default: false)" },
       },
     },
   },
+  {
+    name: "trigger_schedule",
+    description: "Manually trigger a schedule to run immediately. The run is started asynchronously — returns the run ID so you can check status later via list_runs.",
+    inputSchema: {
+      type: "object" as const,
+      properties: {
+        id: { type: "string" as const, description: "Schedule ID or unique prefix" },
+      },
+      required: ["id"],
+    },
+  },
 ];
 
 const RESOURCES = [
@@ -429,7 +441,50 @@ export async function handleListRuns(db: Database, params: any) {
     schedule_id: params?.schedule_id,
     status: params?.status,
     limit: params?.limit,
+    include_output: params?.include_output,
+  });
+}
+
+export async function handleTriggerSchedule(db: Database, config: Config, params: any) {
+  const sq = await getScheduleQueries();
+  if (!sq) throw new Error("Schedule module not available");
+  const rq = await getRunQueries();
+  if (!rq) throw new Error("Run module not available");
+
+  const schedule = sq.getScheduleByPrefix(db, params.id);
+
+  if (!schedule.enabled) {
+    throw new Error(`Schedule "${schedule.name}" is disabled. Enable it first via update_schedule.`);
+  }
+
+  // Respect concurrent run limit
+  const runningRuns = rq.getRunningRuns(db);
+  if (runningRuns.length >= config.daemon.maxConcurrentRuns) {
+    throw new Error(
+      `Concurrent run limit reached (${runningRuns.length}/${config.daemon.maxConcurrentRuns}). Wait for a running schedule to finish or increase maxConcurrentRuns.`
+    );
+  }
+
+  const run = rq.createRun(db, {
+    schedule_id: schedule.id,
+    prompt_used: schedule.prompt,
+    agent: config.daemon.agent,
   });
+
+  // Fire-and-forget: start execution asynchronously
+  // Note: ExecutionManager created without tmux/worktree managers — MCP-triggered runs
+  // use direct execution only. Daemon-triggered runs get full tmux/worktree support.
+  const { ExecutionManager } = await import("./scheduler.ts");
+  const em = new ExecutionManager(db, config);
+  em.executeRun(schedule, run).catch(() => {});
+
+  return {
+    run_id: run.id,
+    schedule_id: schedule.id,
+    schedule_name: schedule.name,
+    status: "started",
+    message: "Run started asynchronously. Use list_runs to check status.",
+  };
 }
 
 export async function startMcpServer(): Promise<void> {
@@ -497,6 +552,9 @@ export async function startMcpServer(): Promise<void> {
         case "list_runs":
           result = await handleListRuns(db, params ?? {});
           break;
+        case "trigger_schedule":
+          result = await handleTriggerSchedule(db, config, params ?? {});
+          break;
         default:
           return {
             content: [{ type: "text", text: `Unknown tool: ${name}` }],

package/src/queries/runs.ts

@@ -50,7 +50,7 @@ export function updateRun(
 
 export function listRuns(
   db: Database,
-  opts?: { schedule_id?: string; status?: string; limit?: number }
+  opts?: { schedule_id?: string; status?: string; limit?: number; include_output?: boolean }
 ): Run[] {
   const conditions: string[] = [];
   const params: any[] = [];
@@ -67,8 +67,15 @@ export function listRuns(
   const where = conditions.length > 0 ? "WHERE " + conditions.join(" AND ") : "";
   const limit = opts?.limit ?? 50;
 
+  const columns = opts?.include_output
+    ? "r.*"
+    : `r.id, r.schedule_id, r.status, r.pid, r.started_at, r.finished_at,
+       r.exit_code, r.stderr_tail, r.session_id, r.worktree_path,
+       r.tokens_in, r.tokens_out, r.cost_usd, r.tools_used,
+       r.issues_touched, r.tmux_session, r.agent`;
+
   return db.query(`
-    SELECT r.*, s.name as schedule_name
+    SELECT ${columns}, s.name as schedule_name
     FROM runs r
     LEFT JOIN schedules s ON r.schedule_id = s.id
     ${where}

package/src/scheduler.ts

@@ -282,6 +282,13 @@ export class CronLoop {
 
       const schedules = listSchedules(this.db);
 
+      // Snapshot running count once before creating any new runs this tick.
+      // Without this, createRun() for schedule A inserts a 'running' row that
+      // getRunningRuns() would count when evaluating schedule B, causing
+      // schedules with identical cron patterns to block each other.
+      const runningCount = getRunningRuns(this.db).length;
+      let newRunsThisTick = 0;
+
       for (const schedule of schedules) {
         try {
           if (!shouldFire(schedule.cron, now)) continue;
@@ -289,8 +296,7 @@ export class CronLoop {
           const lastFiredMinute = this.lastFired.get(schedule.id);
           if (lastFiredMinute === minuteTs) continue;
 
-          const runningRuns = getRunningRuns(this.db);
-          if (runningRuns.length >= this.config.daemon.maxConcurrentRuns) continue;
+          if (runningCount + newRunsThisTick >= this.config.daemon.maxConcurrentRuns) break;
 
           const run = createRun(this.db, {
             schedule_id: schedule.id,
@@ -299,6 +305,7 @@ export class CronLoop {
           });
 
           this.lastFired.set(schedule.id, minuteTs);
+          newRunsThisTick++;
 
           this.executionManager.executeRun(schedule, run).catch(() => {});
         } catch (err) {

package/src/webui/components/board.tsx

@@ -14,7 +14,7 @@ export const Board: FC<{ issues: Issue[]; statuses: string[] }> = ({ issues, sta
   }
 
   return (
-    <div class="flex gap-4 overflow-x-auto pb-4">
+    <div id="board" data-statuses={JSON.stringify(statuses.filter((s) => s !== "archived"))} class="flex gap-4 overflow-x-auto pb-4">
       {statuses.filter((s) => s !== "archived").map((status) => (
         <div class="flex-1 min-w-[220px]" key={status}>
           <div class="flex items-center gap-2 mb-3 px-1">

package/src/webui/routes/issues.tsx

@@ -21,7 +21,7 @@ export function issueRoutes(db: Database, config: Config) {
         <div class="flex items-center justify-between mb-6">
           <div>
             <h1 class="text-xl font-semibold">Issues</h1>
-            <p class="text-sm text-muted-foreground mt-0.5">{issues.length} total</p>
+            <p id="board-total" class="text-sm text-muted-foreground mt-0.5">{issues.length} total</p>
           </div>
           <button
             onclick="document.getElementById('new-issue-form').classList.toggle('hidden')"
@@ -76,6 +76,84 @@ export function issueRoutes(db: Database, config: Config) {
         </div>
 
         <Board issues={issues} statuses={config.general.statuses} />
+
+        <p id="board-updated" class="text-xs text-muted-foreground/50 mt-2 text-right"></p>
+
+        <script dangerouslySetInnerHTML={{ __html: `
+(function() {
+  var INTERVAL = 30000;
+  var board = document.getElementById('board');
+  var updatedEl = document.getElementById('board-updated');
+  var statuses = JSON.parse(board.dataset.statuses);
+  var lastUpdate = Date.now();
+
+  var STATUS_STYLES = {
+    'todo': 'bg-zinc-700/50 text-zinc-300 border-zinc-600',
+    'in-progress': 'bg-blue-500/15 text-blue-400 border-blue-500/30',
+    'review': 'bg-amber-500/15 text-amber-400 border-amber-500/30',
+    'done': 'bg-emerald-500/15 text-emerald-400 border-emerald-500/30',
+    'human-approval': 'bg-amber-500/15 text-amber-400 border-amber-500/30',
+    'running': 'bg-blue-500/15 text-blue-400 border-blue-500/30'
+  };
+  var DEFAULT_STYLE = 'bg-zinc-700/50 text-zinc-300 border-zinc-600';
+
+  function escapeHtml(s) {
+    var d = document.createElement('div');
+    d.textContent = s;
+    return d.innerHTML;
+  }
+
+  function renderBoard(issues) {
+    var grouped = {};
+    statuses.forEach(function(s) { grouped[s] = []; });
+    issues.forEach(function(issue) {
+      if (grouped[issue.status]) grouped[issue.status].push(issue);
+    });
+
+    var html = '';
+    statuses.forEach(function(status) {
+      var items = grouped[status] || [];
+      html += '<div class="flex-1 min-w-[220px]">';
+      html += '<div class="flex items-center gap-2 mb-3 px-1">';
+      html += '<h3 class="text-xs font-semibold uppercase tracking-wider text-muted-foreground">' + escapeHtml(status) + '</h3>';
+      html += '<span class="text-xs text-muted-foreground/60">' + items.length + '</span>';
+      html += '</div>';
+      html += '<div class="space-y-2">';
+      items.forEach(function(issue) {
+        html += '<a href="/issues/' + escapeHtml(issue.id) + '" class="block rounded-lg border border-border bg-card p-3 hover:bg-accent transition-colors group">';
+        html += '<div class="text-sm font-medium text-card-foreground group-hover:text-foreground">' + escapeHtml(issue.title) + '</div>';
+        html += '<div class="text-xs text-muted-foreground mt-1 font-mono">' + escapeHtml(issue.id.slice(0, 8)) + '</div>';
+        html += '</a>';
+      });
+      html += '</div></div>';
+    });
+
+    board.innerHTML = html;
+  }
+
+  function updateTimestamp() {
+    var secs = Math.round((Date.now() - lastUpdate) / 1000);
+    updatedEl.textContent = 'Updated ' + secs + 's ago';
+  }
+
+  function poll() {
+    fetch('/api/issues')
+      .then(function(r) { return r.ok ? r.json() : null; })
+      .then(function(issues) {
+        if (!issues) return;
+        renderBoard(issues);
+        var countEl = document.getElementById('board-total');
+        if (countEl) countEl.textContent = issues.length + ' total';
+        lastUpdate = Date.now();
+        updateTimestamp();
+      })
+      .catch(function() {});
+  }
+
+  setInterval(poll, INTERVAL);
+  setInterval(updateTimestamp, 5000);
+})();
+        ` }} />
       </Layout>
     );
   });

package/src/webui/routes/runs.tsx

@@ -5,6 +5,7 @@ import type { Config } from "../../types.ts";
 import { Layout } from "../components/layout.tsx";
 import { StatusBadge } from "../components/status-badge.tsx";
 import { listRuns, getRunningRuns } from "../../queries/runs.ts";
+import { listIssues } from "../../queries/issues.ts";
 import type { Run } from "../../types.ts";
 
 export function runRoutes(db: Database, _config: Config) {
@@ -137,5 +138,10 @@ export function apiRoutes(db: Database, _config: Config) {
     });
   });
 
+  app.get("/issues", (c) => {
+    const { issues } = listIssues(db, { includeArchived: true, limit: 500 });
+    return c.json(issues);
+  });
+
   return app;
 }