@aion0/forge 0.9.1 → 0.9.2

package/app/api/schedules/[id]/route.ts

@@ -0,0 +1,173 @@
+/**
+ * GET    /api/schedules/:id     single (decorated)
+ * PATCH  /api/schedules/:id     update name / input / schedule fields / enabled
+ * DELETE /api/schedules/:id?cancel_inflight=1
+ */
+
+import { NextResponse } from 'next/server';
+import {
+  getSchedule,
+  updateSchedule,
+  deleteSchedule,
+  listInflightForSchedule,
+} from '@/lib/schedules/store';
+import { decorateSchedule } from '@/lib/schedules/state';
+import { listWorkflows, cancelPipeline } from '@/lib/pipeline';
+import type { ScheduleKind, ScheduleActionKind, UpdateScheduleInput } from '@/lib/schedules/types';
+
+const VALID_KINDS: ScheduleKind[] = ['period', 'once', 'cron', 'manual'];
+const VALID_ACTION_KINDS: ScheduleActionKind[] = ['none', 'chat', 'email', 'telegram'];
+
+export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params;
+  const s = getSchedule(id);
+  if (!s) return NextResponse.json({ error: 'schedule not found' }, { status: 404 });
+  return NextResponse.json({ schedule: decorateSchedule(s) });
+}
+
+export async function PATCH(req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params;
+  const existing = getSchedule(id);
+  if (!existing) return NextResponse.json({ error: 'schedule not found' }, { status: 404 });
+
+  let body: any = {};
+  try { body = await req.json(); } catch {}
+
+  // body_ref + body_kind are immutable — must build a new schedule
+  // to change what the schedule fires. Accept legacy pipeline_name as
+  // an alias for the body_ref equality check.
+  const incomingBodyRef = body.body_ref ?? body.pipeline_name;
+  if (incomingBodyRef && incomingBodyRef !== existing.body_ref) {
+    return NextResponse.json({
+      error: 'body_ref cannot be changed; create a new schedule instead',
+    }, { status: 400 });
+  }
+  if (body.body_kind && body.body_kind !== existing.body_kind) {
+    return NextResponse.json({
+      error: 'body_kind cannot be changed; create a new schedule instead',
+    }, { status: 400 });
+  }
+
+  const patch: UpdateScheduleInput = {};
+
+  if (typeof body.name === 'string') patch.name = body.name.trim();
+  if (typeof body.enabled === 'boolean') patch.enabled = body.enabled;
+
+  if (body.input !== undefined) {
+    if (!body.input || typeof body.input !== 'object' || Array.isArray(body.input)) {
+      return NextResponse.json({ error: 'input must be an object' }, { status: 400 });
+    }
+    // For pipeline body, validate keys against pipeline.input declarations.
+    // Skill / connector_tool bodies have free-form input — no validation here yet.
+    if (existing.body_kind === 'pipeline') {
+      const workflow = listWorkflows().find((w) => w.name === existing.body_ref);
+      if (workflow) {
+        const declared = new Set(Object.keys(workflow.input || {}));
+        for (const k of Object.keys(body.input)) {
+          if (!declared.has(k)) {
+            return NextResponse.json({
+              error: `input field "${k}" is not declared by pipeline "${existing.body_ref}"`,
+            }, { status: 400 });
+          }
+        }
+      }
+    }
+    patch.input = body.input;
+  }
+
+  if (body.skills !== undefined) {
+    if (!Array.isArray(body.skills)) {
+      return NextResponse.json({ error: 'skills must be an array of skill names' }, { status: 400 });
+    }
+    patch.skills = body.skills
+      .filter((s: unknown) => typeof s === 'string' && s.trim())
+      .map((s: string) => s.trim());
+  }
+
+  if (body.schedule_kind !== undefined) {
+    if (!VALID_KINDS.includes(body.schedule_kind)) {
+      return NextResponse.json({ error: 'schedule_kind must be one of: ' + VALID_KINDS.join(', ') }, { status: 400 });
+    }
+    patch.schedule_kind = body.schedule_kind;
+  }
+  if (body.schedule_interval_minutes !== undefined && body.schedule_interval_minutes !== null) {
+    // null is the client's way of saying "this trigger kind doesn't need
+    // an interval" (manual / cron / once), so skip — don't reject it.
+    const n = Number(body.schedule_interval_minutes);
+    if (!Number.isFinite(n) || n < 1) {
+      return NextResponse.json({ error: 'schedule_interval_minutes must be ≥ 1' }, { status: 400 });
+    }
+    patch.schedule_interval_minutes = Math.max(1, Math.trunc(n));
+  }
+  if (body.schedule_at !== undefined) patch.schedule_at = body.schedule_at || null;
+  if (body.schedule_cron !== undefined) patch.schedule_cron = body.schedule_cron || null;
+
+  // Action — same validation as POST. action_config is replaced wholesale
+  // (not merged) when supplied, so the caller must send the full new shape.
+  if (body.action_kind !== undefined) {
+    if (!VALID_ACTION_KINDS.includes(body.action_kind)) {
+      return NextResponse.json({ error: 'action_kind must be one of: ' + VALID_ACTION_KINDS.join(', ') }, { status: 400 });
+    }
+    patch.action_kind = body.action_kind;
+  }
+  if (body.action_config !== undefined) {
+    if (!body.action_config || typeof body.action_config !== 'object' || Array.isArray(body.action_config)) {
+      return NextResponse.json({ error: 'action_config must be an object' }, { status: 400 });
+    }
+    patch.action_config = body.action_config;
+  }
+  const effectiveActionKind = patch.action_kind ?? existing.action_kind;
+  const effectiveActionConfig = patch.action_config ?? existing.action_config ?? {};
+  if (effectiveActionKind === 'chat') {
+    const sid = typeof effectiveActionConfig.session_id === 'string' ? effectiveActionConfig.session_id.trim() : '';
+    if (!sid) return NextResponse.json({ error: 'action_kind=chat requires action_config.session_id' }, { status: 400 });
+  }
+  if (effectiveActionKind === 'email') {
+    const toRaw = effectiveActionConfig.to;
+    const to = Array.isArray(toRaw)
+      ? toRaw.filter((x) => typeof x === 'string' && x.trim())
+      : (typeof toRaw === 'string' && toRaw.trim() ? [toRaw] : []);
+    if (to.length === 0) {
+      return NextResponse.json({ error: 'action_kind=email requires action_config.to (recipient address or array)' }, { status: 400 });
+    }
+  }
+
+  // Cross-field consistency
+  const effectiveKind = patch.schedule_kind ?? existing.schedule_kind;
+  if (effectiveKind === 'cron' && !(patch.schedule_cron ?? existing.schedule_cron)) {
+    return NextResponse.json({ error: 'schedule_cron is required when schedule_kind=cron' }, { status: 400 });
+  }
+  if (effectiveKind === 'once' && !(patch.schedule_at ?? existing.schedule_at)) {
+    return NextResponse.json({ error: 'schedule_at is required when schedule_kind=once' }, { status: 400 });
+  }
+
+  updateSchedule(id, patch);
+  return NextResponse.json({ schedule: decorateSchedule(getSchedule(id)!) });
+}
+
+export async function DELETE(req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params;
+  const s = getSchedule(id);
+  if (!s) return NextResponse.json({ error: 'schedule not found' }, { status: 404 });
+
+  const url = new URL(req.url);
+  const cancelInflight = url.searchParams.get('cancel_inflight') === '1';
+
+  let cancelledPipelines = 0;
+  if (cancelInflight) {
+    for (const run of listInflightForSchedule(id)) {
+      // Phase 1: target_id is always a pipeline_id. When skill /
+      // connector_tool body lands, dispatch cancel by body_kind.
+      try { if (cancelPipeline(run.target_id)) cancelledPipelines++; }
+      catch (e) {
+        console.warn(`[schedules/delete] cancelPipeline(${run.target_id}) failed: ${(e as Error).message}`);
+      }
+    }
+  }
+  const ok = deleteSchedule(id);
+  return NextResponse.json({
+    ok,
+    cancelled_pipelines: cancelledPipelines,
+    cancel_inflight_requested: cancelInflight,
+  });
+}

package/app/api/schedules/[id]/run/route.ts

@@ -0,0 +1,45 @@
+/**
+ * POST /api/schedules/:id/run[?cancel_inflight=1]
+ *
+ * Manual fire (trigger='manual'). 409 if busy unless cancel_inflight=1.
+ */
+
+import { NextResponse } from 'next/server';
+import { getSchedule, listInflightForSchedule } from '@/lib/schedules/store';
+import { executeSchedule, isScheduleBusy } from '@/lib/schedules/scheduler';
+import { cancelPipeline } from '@/lib/pipeline';
+
+export async function POST(req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params;
+  const s = getSchedule(id);
+  if (!s) return NextResponse.json({ error: 'schedule not found' }, { status: 404 });
+
+  const url = new URL(req.url);
+  const cancelInflight = url.searchParams.get('cancel_inflight') === '1';
+
+  const busy = isScheduleBusy(id);
+  if (busy.busy) {
+    if (!cancelInflight) {
+      return NextResponse.json({
+        error: `schedule is busy: ${busy.reason}. Pass ?cancel_inflight=1 to cancel + run anyway.`,
+        busy: true,
+        reason: busy.reason,
+      }, { status: 409 });
+    }
+    // Cancel each inflight pipeline before firing a new one.
+    // Phase 1: target_id is always a pipeline_id.
+    for (const run of listInflightForSchedule(id)) {
+      try { cancelPipeline(run.target_id); }
+      catch (e) {
+        console.warn(`[schedules/run] cancelPipeline(${run.target_id}) failed: ${(e as Error).message}`);
+      }
+    }
+  }
+
+  try {
+    const targetId = await executeSchedule(s, 'manual');
+    return NextResponse.json({ target_id: targetId, pipeline_id: targetId }, { status: 202 });
+  } catch (e) {
+    return NextResponse.json({ error: (e as Error).message }, { status: 500 });
+  }
+}

package/app/api/schedules/[id]/runs/route.ts

@@ -0,0 +1,22 @@
+/**
+ * GET /api/schedules/:id/runs?limit=20
+ *
+ * Recent schedule_runs for this schedule, newest first.
+ */
+
+import { NextResponse } from 'next/server';
+import { getSchedule, listScheduleRuns } from '@/lib/schedules/store';
+
+export async function GET(req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params;
+  const s = getSchedule(id);
+  if (!s) return NextResponse.json({ error: 'schedule not found' }, { status: 404 });
+
+  const url = new URL(req.url);
+  const limitParam = url.searchParams.get('limit');
+  const limit = limitParam && Number.isFinite(Number(limitParam))
+    ? Math.min(Math.max(Number(limitParam), 1), 200)
+    : 20;
+
+  return NextResponse.json({ runs: listScheduleRuns(id, limit) });
+}

package/app/api/schedules/[id]/stop/route.ts

@@ -0,0 +1,33 @@
+/**
+ * POST /api/schedules/:id/stop
+ *
+ * One-shot Pause + Cancel: disables the schedule AND cancels every
+ * inflight pipeline it launched. Use when user wants to fully halt.
+ */
+
+import { NextResponse } from 'next/server';
+import {
+  getSchedule,
+  updateSchedule,
+  listInflightForSchedule,
+} from '@/lib/schedules/store';
+import { cancelPipeline } from '@/lib/pipeline';
+
+export async function POST(_req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params;
+  const s = getSchedule(id);
+  if (!s) return NextResponse.json({ error: 'schedule not found' }, { status: 404 });
+
+  updateSchedule(id, { enabled: false });
+
+  let cancelled = 0;
+  for (const run of listInflightForSchedule(id)) {
+    // Phase 1: target_id is always a pipeline_id.
+    try { if (cancelPipeline(run.target_id)) cancelled++; }
+    catch (e) {
+      console.warn(`[schedules/stop] cancelPipeline(${run.target_id}) failed: ${(e as Error).message}`);
+    }
+  }
+
+  return NextResponse.json({ ok: true, cancelled });
+}

package/app/api/schedules/route.ts

@@ -0,0 +1,175 @@
+/**
+ * GET  /api/schedules    list with decorated state fields
+ * POST /api/schedules    create
+ *
+ * V2: body is described by body_kind + body_ref instead of pipeline_name.
+ * Phase 1 only accepts body_kind='pipeline' (and defaults to it if
+ * omitted) so existing clients posting pipeline_name still work via a
+ * compat alias. skill / connector_tool bodies land in later phases.
+ */
+
+import { NextResponse } from 'next/server';
+import {
+  listSchedules,
+  createSchedule,
+  reconcileStaleScheduleRuns,
+} from '@/lib/schedules/store';
+import { decorateSchedule } from '@/lib/schedules/state';
+import { listWorkflows } from '@/lib/pipeline';
+import { listSkills } from '@/lib/skills';
+import { getProjectInfo } from '@/lib/projects';
+import { getInstalledConnector } from '@/lib/connectors/registry';
+import type {
+  ScheduleKind,
+  ScheduleBodyKind,
+  ScheduleActionKind,
+  CreateScheduleInput,
+} from '@/lib/schedules/types';
+
+export async function GET() {
+  // Reconcile zombies before reading so UI sees correct inflight counts.
+  reconcileStaleScheduleRuns();
+  const schedules = listSchedules().map(decorateSchedule);
+  return NextResponse.json({ schedules });
+}
+
+const VALID_KINDS: ScheduleKind[] = ['period', 'once', 'cron', 'manual'];
+const VALID_BODY_KINDS: ScheduleBodyKind[] = ['pipeline', 'skill', 'connector_tool'];
+const VALID_ACTION_KINDS: ScheduleActionKind[] = ['none', 'chat', 'email', 'telegram'];
+
+export async function POST(req: Request) {
+  let body: any = {};
+  try { body = await req.json(); } catch {}
+
+  // Required
+  if (!body?.name || typeof body.name !== 'string') {
+    return NextResponse.json({ error: 'name is required' }, { status: 400 });
+  }
+
+  // Compat: accept body_ref OR legacy pipeline_name (with body_kind defaulting to 'pipeline').
+  const bodyRef: string | undefined = body.body_ref || body.pipeline_name;
+  const bodyKind: ScheduleBodyKind = VALID_BODY_KINDS.includes(body.body_kind)
+    ? body.body_kind : 'pipeline';
+
+  if (!bodyRef || typeof bodyRef !== 'string') {
+    return NextResponse.json({ error: 'body_ref is required' }, { status: 400 });
+  }
+  const input = (body.input && typeof body.input === 'object' && !Array.isArray(body.input))
+    ? body.input as Record<string, unknown> : {};
+
+  if (bodyKind === 'pipeline') {
+    // Pipeline must exist + input shape check
+    const workflow = listWorkflows().find((w) => w.name === bodyRef);
+    if (!workflow) {
+      return NextResponse.json({ error: `pipeline "${bodyRef}" not found` }, { status: 400 });
+    }
+    const declaredKeys = new Set(Object.keys(workflow.input || {}));
+    for (const k of Object.keys(input)) {
+      if (!declaredKeys.has(k)) {
+        return NextResponse.json({
+          error: `input field "${k}" is not declared by pipeline "${bodyRef}". Allowed: ${Array.from(declaredKeys).join(', ')}`,
+        }, { status: 400 });
+      }
+    }
+  } else if (bodyKind === 'skill') {
+    // Skill must be installed
+    const installed = listSkills().some((sk) => sk.name === bodyRef && (sk.installedGlobal || (sk.installedProjects && sk.installedProjects.length > 0)));
+    if (!installed) {
+      return NextResponse.json({ error: `skill "${bodyRef}" is not installed` }, { status: 400 });
+    }
+    // input.project is required and must resolve
+    const projectName = typeof input.project === 'string' ? input.project.trim() : '';
+    if (!projectName) {
+      return NextResponse.json({
+        error: 'skill body requires input.project (a Forge project name)',
+      }, { status: 400 });
+    }
+    if (!getProjectInfo(projectName)) {
+      return NextResponse.json({
+        error: `project "${projectName}" not found in Forge's projects list`,
+      }, { status: 400 });
+    }
+  } else if (bodyKind === 'connector_tool') {
+    // body_ref is "<plugin_id>.<tool_name>"
+    const dot = bodyRef.indexOf('.');
+    if (dot <= 0 || dot === bodyRef.length - 1) {
+      return NextResponse.json({
+        error: 'connector_tool body_ref must be "<plugin_id>.<tool_name>"',
+      }, { status: 400 });
+    }
+    const pluginId = bodyRef.slice(0, dot);
+    const toolName = bodyRef.slice(dot + 1);
+    const connector = getInstalledConnector(pluginId);
+    if (!connector || !connector.enabled) {
+      return NextResponse.json({
+        error: `connector "${pluginId}" is not installed or disabled`,
+      }, { status: 400 });
+    }
+    const tools = connector.definition.tools || {};
+    if (!tools[toolName]) {
+      return NextResponse.json({
+        error: `tool "${toolName}" not found on connector "${pluginId}". Available: ${Object.keys(tools).join(', ')}`,
+      }, { status: 400 });
+    }
+  }
+
+  // Action — phase 4 ships chat. email/telegram land in phases 5-6.
+  const actionKind: ScheduleActionKind = VALID_ACTION_KINDS.includes(body.action_kind)
+    ? body.action_kind : 'none';
+  const actionConfig = (body.action_config && typeof body.action_config === 'object' && !Array.isArray(body.action_config))
+    ? body.action_config as Record<string, unknown> : {};
+  if (actionKind === 'chat') {
+    const sessionId = typeof actionConfig.session_id === 'string' ? actionConfig.session_id.trim() : '';
+    if (!sessionId) {
+      return NextResponse.json({
+        error: 'action_kind=chat requires action_config.session_id',
+      }, { status: 400 });
+    }
+  }
+  if (actionKind === 'email') {
+    const toRaw = actionConfig.to;
+    const to = Array.isArray(toRaw)
+      ? toRaw.filter((x) => typeof x === 'string' && x.trim())
+      : (typeof toRaw === 'string' && toRaw.trim() ? [toRaw] : []);
+    if (to.length === 0) {
+      return NextResponse.json({
+        error: 'action_kind=email requires action_config.to (recipient address or array)',
+      }, { status: 400 });
+    }
+  }
+
+  // Schedule kind + consistency
+  const kind: ScheduleKind = VALID_KINDS.includes(body.schedule_kind) ? body.schedule_kind : 'period';
+  if (kind === 'cron' && !body.schedule_cron) {
+    return NextResponse.json({ error: 'schedule_cron is required when schedule_kind=cron' }, { status: 400 });
+  }
+  if (kind === 'once' && !body.schedule_at) {
+    return NextResponse.json({ error: 'schedule_at is required when schedule_kind=once' }, { status: 400 });
+  }
+
+  // Skills (optional). Array of installed skill names; forwarded as
+  // --append-system-prompt to the dispatched body's task(s). Ignored for
+  // body_kind=connector_tool (no Claude task there).
+  const skills: string[] = Array.isArray(body.skills)
+    ? body.skills.filter((s: unknown) => typeof s === 'string' && s.trim()).map((s: string) => s.trim())
+    : [];
+
+  const input2: CreateScheduleInput = {
+    name: body.name.trim(),
+    body_kind: bodyKind,
+    body_ref: bodyRef,
+    input,
+    skills,
+    action_kind: actionKind,
+    action_config: actionConfig,
+    action_skip_on_empty: !!body.action_skip_on_empty,
+    enabled: body.enabled !== false,
+    schedule_kind: kind,
+    schedule_interval_minutes: Number.isFinite(Number(body.schedule_interval_minutes))
+      ? Math.max(1, Number(body.schedule_interval_minutes)) : 30,
+    schedule_at: body.schedule_at || null,
+    schedule_cron: body.schedule_cron || null,
+  };
+  const created = createSchedule(input2);
+  return NextResponse.json({ schedule: decorateSchedule(created) });
+}

package/app/api/tasks/bulk-delete/route.ts

@@ -0,0 +1,47 @@
+/**
+ * POST /api/tasks/bulk-delete
+ *
+ *   { older_than_days?: number, before?: ISO, statuses?: string[] }
+ *
+ * Deletes tasks matching the filter. Running tasks are skipped — only
+ * terminal-state rows (done/failed/cancelled by default) are removed.
+ *
+ *   older_than_days: 7  → cutoff = now - 7 days
+ *   before: "ISO"       → explicit cutoff
+ *   statuses: ["failed"] → narrow to just failures (default = done+failed+cancelled)
+ *
+ * Returns { removed: <count>, before: <ISO cutoff> }.
+ */
+
+import { NextResponse } from 'next/server';
+import { bulkDeleteTasks } from '@/lib/task-manager';
+import type { TaskStatus } from '@/src/types';
+
+export async function POST(req: Request) {
+  let body: any = {};
+  try { body = await req.json(); } catch {}
+
+  let before: string;
+  if (typeof body.before === 'string' && body.before) {
+    before = body.before;
+  } else if (Number.isFinite(Number(body.older_than_days))) {
+    const days = Math.max(0, Number(body.older_than_days));
+    before = new Date(Date.now() - days * 86_400_000).toISOString();
+  } else {
+    return NextResponse.json({ error: 'pass `older_than_days` (number) or `before` (ISO timestamp)' }, { status: 400 });
+  }
+
+  const validStatuses: TaskStatus[] = ['queued', 'running', 'done', 'failed', 'cancelled'];
+  let statuses: TaskStatus[] | undefined;
+  if (Array.isArray(body.statuses) && body.statuses.length) {
+    statuses = (body.statuses as string[])
+      .filter((s) => validStatuses.includes(s as TaskStatus))
+      .filter((s) => s !== 'running' && s !== 'queued') as TaskStatus[];
+    if (statuses.length === 0) {
+      return NextResponse.json({ error: 'statuses filter excluded everything (running/queued can never be bulk-deleted)' }, { status: 400 });
+    }
+  }
+
+  const removed = bulkDeleteTasks({ before, statuses });
+  return NextResponse.json({ removed, before, statuses: statuses ?? ['done', 'failed', 'cancelled'] });
+}

package/bin/forge-server.mjs

@@ -329,6 +329,28 @@ function cleanupOrphans() {
         try { process.kill(parseInt(pid), 'SIGTERM'); } catch {}
       }
     } catch {}
+    // Kill zombie tsx scripts holding workflow.db open. Any tsx script that
+    // imported lib/task-manager (directly or via lib/pipeline) starts its
+    // own setInterval task runner that never exits — those run in parallel
+    // with the real runner and silently steal tasks. Detect via lsof on
+    // workflow.db, exclude our own next-server + standalones.
+    try {
+      const dbPath = join(DATA_DIR, 'workflow.db');
+      const lsofOut = execSync(`lsof -t "${dbPath}"`, { encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+      for (const pid of lsofOut.split('\n').map(s => s.trim()).filter(Boolean)) {
+        if (pid === myPid || protectedPids.has(pid)) continue;
+        let cmd = '';
+        try {
+          cmd = execSync(`ps -p ${pid} -o command=`, { encoding: 'utf-8', timeout: 2000, stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+        } catch { continue; }
+        // Skip legit holders: next-server + our standalones (handled above)
+        if (/next-server|next start|telegram-standalone|terminal-standalone|workspace-standalone|browser-bridge-standalone|chat-standalone/.test(cmd)) continue;
+        // Only kill tsx-loaded scripts (typical zombie debug runner shape)
+        if (!/tsx/.test(cmd)) continue;
+        console.log(`[forge] Killing zombie task-runner (pid=${pid}): ${cmd.slice(0, 120)}`);
+        try { process.kill(parseInt(pid), 'SIGTERM'); } catch {}
+      }
+    } catch {}
   } catch {}
 }
 
@@ -464,7 +486,6 @@ function startBackground() {
   console.log(`[forge] Terminal: ws://localhost:${terminalPort}`);
   console.log(`[forge] Data: ${DATA_DIR}`);
   console.log(`[forge] Log: ${LOG_FILE}`);
-  console.log(`[forge] Stop: forge server stop`);
 }
 
 // ── Stop ──