@aion0/forge 0.10.90 → 0.11.0

package/lib/kanban/task-listener.ts

@@ -0,0 +1,63 @@
+/**
+ * Settles task-mode kanban cards. Two paths, same logic:
+ *  - event: a global task listener fires on terminal status.
+ *  - reconcile: the tick / API sweep catches cards stuck 'running' whose task
+ *    already reached terminal (missed events from races / multi-worker / restart).
+ *
+ * The widget FILE wins over the task's exit code: the CLI often writes a valid
+ * widget.json and then exits non-zero ("Process exited with code 1") — that is
+ * still a success. Mirrors Schedules V3's settle + zombie reconciliation.
+ */
+
+import { onTaskEvent, getTask } from '../task-manager';
+import { getCardByTaskId, setCardResult, setCardError } from './store';
+import { readWidgetFile } from './artifacts';
+import { parseWidget } from './executor';
+import type { KanbanCard } from './types';
+
+const TERMINAL = new Set(['done', 'failed', 'cancelled', 'error']);
+let installed = false;
+
+export function installKanbanTaskListener(): void {
+  if (installed) return;
+  installed = true;
+  onTaskEvent((taskId, event, data) => {
+    if (event !== 'status' || !TERMINAL.has(String(data))) return;
+    try { settleKanbanTask(taskId); } catch (e) {
+      console.error(`[kanban] settle task ${taskId} failed: ${(e as Error).message}`);
+    }
+  });
+}
+
+/** Settle one card from its (terminal) task. File wins over exit code. */
+export function settleKanbanTask(taskId: string): void {
+  const card = getCardByTaskId(taskId);
+  if (!card) return; // not a kanban task
+
+  const fromFile = readWidgetFile(card.id);
+  if (fromFile) { setCardResult(card.id, fromFile); return; }
+
+  const t = getTask(taskId);
+  const fromSummary = t?.resultSummary ? parseWidget(t.resultSummary) : null;
+  if (fromSummary) { setCardResult(card.id, fromSummary); return; }
+
+  setCardError(card.id, t?.error || 'task finished but wrote no widget.json');
+}
+
+/** Backstop for missed terminal events: settle any task-mode card stuck in
+ *  'running' whose task is already terminal (or whose task row is gone). */
+export function reconcileRunningKanbanTaskCards(cards: KanbanCard[]): void {
+  for (const c of cards) {
+    if (c.execMode !== 'task' || c.status !== 'running' || !c.taskId) continue;
+    const t = getTask(c.taskId);
+    if (!t) {
+      // Task row vanished but a widget may still be on disk — prefer it.
+      const w = readWidgetFile(c.id);
+      if (w) setCardResult(c.id, w); else setCardError(c.id, 'task row gone');
+      continue;
+    }
+    if (TERMINAL.has(String(t.status))) {
+      try { settleKanbanTask(c.taskId); } catch { /* keep going */ }
+    }
+  }
+}

package/lib/kanban/tick.ts

@@ -0,0 +1,41 @@
+/**
+ * Kanban tick — find due cards and run them. Driven by the same loop that
+ * ticks schedules (period reuse, per-card cadence). Inline cards run in-process
+ * (sequential, a single in-flight guard prevents overlap); task-mode cards are
+ * dispatched as one-shot tasks (fire-and-forget — the task listener settles
+ * them) with a small per-tick cap so the board can't flood the task queue.
+ */
+
+import { listCards, listDueCards } from './store';
+import { runKanbanCard } from './executor';
+import { runKanbanCardViaTask } from './task-executor';
+import { installKanbanTaskListener, reconcileRunningKanbanTaskCards } from './task-listener';
+
+let running = false;
+const MAX_TASK_DISPATCH_PER_TICK = 2;
+
+export async function kanbanTick(): Promise<void> {
+  if (running) return;
+  running = true;
+  installKanbanTaskListener(); // idempotent; ensures task cards get settled
+  reconcileRunningKanbanTaskCards(listCards()); // backstop for missed events
+  try {
+    const due = listDueCards();
+    let taskDispatched = 0;
+    for (const card of due) {
+      try {
+        if (card.execMode === 'task') {
+          if (taskDispatched >= MAX_TASK_DISPATCH_PER_TICK) continue; // next tick
+          runKanbanCardViaTask(card.id); // async; listener settles on terminal
+          taskDispatched++;
+        } else {
+          await runKanbanCard(card.id);
+        }
+      } catch (e) {
+        console.warn(`[kanban] card ${card.id} (${card.connectorId}) failed: ${(e as Error).message}`);
+      }
+    }
+  } finally {
+    running = false;
+  }
+}

package/lib/kanban/types.ts

@@ -0,0 +1,104 @@
+/**
+ * Kanban dashboard — types. A card = one connector + a prompt + a period.
+ * The card's prompt runs (connector-scoped LLM turn) and must return a
+ * WidgetSpec, which a generic renderer draws. See
+ * obsidian forge/forge-kanban-dashboard-design.md.
+ */
+
+export type WidgetColor =
+  | 'gray' | 'red' | 'amber' | 'yellow' | 'green' | 'emerald' | 'blue' | 'violet';
+
+/** The constrained block vocabulary the card LLM may emit. The renderer maps
+ *  each to a component; unknown types degrade to 'text' so it never crashes.
+ *  Deliberately NOT free HTML — keeps it XSS/injection-safe and visually
+ *  consistent. Extend the union (+ renderer) to add new block kinds. */
+export type WidgetBlock =
+  | { type: 'metric_row'; items: { label: string; value: string | number; color?: WidgetColor }[] }
+  | { type: 'list'; items: { text: string; badge?: string; badgeColor?: WidgetColor; sub?: string; href?: string; avatar?: string }[] }
+  | { type: 'stat'; value: string | number; label: string; delta?: string; deltaColor?: WidgetColor }
+  | { type: 'progress'; label: string; value: number; max: number; color?: WidgetColor }
+  | { type: 'table'; columns: string[]; rows: string[][] }
+  | { type: 'badges'; items: { text: string; color?: WidgetColor }[] }
+  | { type: 'callout'; text: string; color?: WidgetColor; icon?: string }
+  | { type: 'text'; markdown: string };
+
+export interface WidgetSpec {
+  accent?: WidgetColor;
+  blocks: WidgetBlock[];
+  footer?: string;
+}
+
+export type KanbanCardStatus = 'idle' | 'running' | 'ok' | 'error';
+
+/** How a card's prompt is executed:
+ *  - inline: fast headless streamLlm turn (API profile) — simple cards.
+ *  - task:   dispatched as a one-shot CLI task (relay backend) that can do
+ *            multi-step work + write the widget to a file. Heavy cards. */
+export type KanbanExecMode = 'inline' | 'task';
+
+export interface KanbanCard {
+  id: string;
+  connectorId: string;        // card runs scoped to THIS connector's tools
+  title: string;
+  icon?: string | null;       // emoji
+  prompt: string;             // what to pull + how to summarize
+  periodSec: number;          // refresh cadence (per card)
+  order: number;              // drag-to-reorder
+  enabled: boolean;
+  execMode: KanbanExecMode;   // inline (default) | task
+  taskId?: string | null;     // current/last dispatched task (task mode)
+  lastResult?: WidgetSpec | null;
+  lastRunAt?: string | null;
+  lastError?: string | null;
+  status: KanbanCardStatus;
+  createdAt: string;
+  updatedAt: string;
+  /** Derived (not stored): the connector's website / base_url, attached by the
+   *  API so the card can link out. */
+  connectorUrl?: string | null;
+}
+
+export interface CreateKanbanCardInput {
+  connectorId: string;
+  title: string;
+  prompt: string;
+  icon?: string | null;
+  periodSec?: number;         // default 1800
+  order?: number;
+  enabled?: boolean;
+  execMode?: KanbanExecMode;  // default 'inline'
+  seedKey?: string;           // set when auto-created from a connector default
+}
+
+export interface UpdateKanbanCardInput {
+  title?: string;
+  prompt?: string;
+  icon?: string | null;
+  periodSec?: number;
+  order?: number;
+  enabled?: boolean;
+  execMode?: KanbanExecMode;
+}
+
+// ─── Connector-declared kanban defaults ───────────────────
+// These live HERE (not in lib/connectors/types.ts) on purpose: the core
+// connector subsystem stays untouched, so old connectors load exactly as
+// before. seed.ts reads `definition.kanban` via a structural cast — a manifest
+// `kanban:` block is plain pass-through YAML the connector loader never parses.
+
+export interface ConnectorKanban {
+  enabled?: boolean;          // default: true when `cards` is non-empty
+  cards?: KanbanCardDecl[];
+}
+
+export interface KanbanCardDecl {
+  title: string;
+  icon?: string;
+  prompt: string;
+  period_sec?: number;        // refresh cadence; default 1800
+  mode?: KanbanExecMode;      // 'task' for heavy multi-step cards; default inline
+}
+
+/** A connector definition that may carry kanban defaults — used by seed.ts to
+ *  read the field without coupling lib/connectors/types.ts to kanban. */
+export type WithKanban = { id: string; icon?: string | null; kanban?: ConnectorKanban };

package/lib/schedules/scheduler.ts

@@ -83,6 +83,12 @@ async function tick(): Promise<void> {
       console.error(`[schedules-scheduler] execute ${s.id} crashed`, err);
     });
   }
+
+  // Kanban cards reuse this same tick (per-card period). Lazy-imported so the
+  // scheduler module doesn't statically pull in the chat agent-loop graph.
+  void import('../kanban/tick')
+    .then(({ kanbanTick }) => kanbanTick())
+    .catch((e) => console.warn(`[kanban] tick failed: ${(e as Error).message}`));
 }
 
 function toSqlIso(d: Date): string {

package/lib/task-manager.ts

@@ -5,7 +5,9 @@
 
 import { randomUUID } from 'node:crypto';
 import { spawn, execSync } from 'node:child_process';
-import { realpathSync } from 'node:fs';
+import { realpathSync, existsSync } from 'node:fs';
+import { join as pathJoin } from 'node:path';
+import { getConfigDir } from './dirs';
 import * as pty from 'node-pty';
 import { getDb } from '../src/core/db/database';
 import { getDbPath } from '../src/config';
@@ -676,6 +678,14 @@ function executeTask(task: Task): Promise<void> {
     const env = { ...process.env, ...connectorEnv(), ...(spawnOpts.env || {}) };
     delete env.CLAUDECODE;
 
+    // Corporate SSL: if the server was launched without NODE_EXTRA_CA_CERTS but
+    // a CA bundle exists at <configDir>/corporate-ca.pem, wire it through so the
+    // spawned CLI doesn't die with "SSL certificate verification failed".
+    if (!env.NODE_EXTRA_CA_CERTS) {
+      const corpCa = pathJoin(getConfigDir(), 'corporate-ca.pem');
+      if (existsSync(corpCa)) env.NODE_EXTRA_CA_CERTS = corpCa;
+    }
+
     updateTaskStatus(task.id, 'running');
     db().prepare('UPDATE tasks SET started_at = datetime(\'now\') WHERE id = ?').run(task.id);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aion0/forge",
-  "version": "0.10.90",
+  "version": "0.11.0",
   "description": "Unified AI workflow platform — multi-model task orchestration, persistent sessions, web terminal, remote access",
   "type": "module",
   "engines": {