@aion0/forge 0.5.24 → 0.5.26

package/.forge/worktrees/pipeline-ecd7cb0f/app/api/issue-scanner/route.ts

@@ -0,0 +1,116 @@
+import { NextResponse } from 'next/server';
+import {
+  getConfig,
+  saveConfig,
+  listConfigs,
+  scanAndTrigger,
+  restartScanner,
+  getProcessedIssues,
+  resetProcessedIssue,
+  getNextScanTime,
+  type IssueAutofixConfig,
+} from '@/lib/issue-scanner';
+
+// GET /api/issue-scanner?project=PATH — get config + processed issues
+export async function GET(req: Request) {
+  const { searchParams } = new URL(req.url);
+  const projectPath = searchParams.get('project');
+
+  if (projectPath) {
+    const config = getConfig(projectPath);
+    const processed = getProcessedIssues(projectPath);
+    const scanTime = getNextScanTime(projectPath);
+    return NextResponse.json({ config, processed, ...scanTime });
+  }
+
+  // List all enabled configs
+  const configs = listConfigs();
+  return NextResponse.json({ configs });
+}
+
+// POST /api/issue-scanner
+export async function POST(req: Request) {
+  const body = await req.json();
+
+  // Save config
+  if (body.action === 'save-config') {
+    const config: IssueAutofixConfig = {
+      projectPath: body.projectPath,
+      projectName: body.projectName,
+      enabled: !!body.enabled,
+      interval: body.interval || 30,
+      labels: body.labels || [],
+      baseBranch: body.baseBranch || '',
+    };
+    saveConfig(config);
+    restartScanner();
+    return NextResponse.json({ ok: true });
+  }
+
+  // Manual scan & trigger
+  if (body.action === 'scan') {
+    const config = getConfig(body.projectPath);
+    if (!config) return NextResponse.json({ error: 'Not configured' }, { status: 400 });
+    const result = scanAndTrigger(config);
+    return NextResponse.json(result);
+  }
+
+  // Manual trigger for a specific issue
+  if (body.action === 'trigger') {
+    const { startPipeline } = require('@/lib/pipeline');
+    const config = getConfig(body.projectPath);
+    const projectName = config?.projectName || body.projectName;
+    try {
+      const pipeline = startPipeline('issue-fix-and-review', {
+        issue_id: String(body.issueId),
+        project: projectName,
+        base_branch: config?.baseBranch || body.baseBranch || 'auto-detect',
+      });
+      // Track in processed issues
+      const { getDb } = require('@/src/core/db/database');
+      const { getDbPath } = require('@/src/config');
+      getDb(getDbPath()).prepare(`
+        INSERT OR REPLACE INTO issue_autofix_processed (project_path, issue_number, pipeline_id, status)
+        VALUES (?, ?, ?, 'processing')
+      `).run(body.projectPath, body.issueId, pipeline.id);
+      return NextResponse.json({ ok: true, pipelineId: pipeline.id });
+    } catch (e) {
+      return NextResponse.json({ ok: false, error: String(e) }, { status: 500 });
+    }
+  }
+
+  // Reset a processed issue (allow re-scan)
+  if (body.action === 'reset') {
+    resetProcessedIssue(body.projectPath, body.issueId);
+    return NextResponse.json({ ok: true });
+  }
+
+  // Retry with additional context/instructions
+  if (body.action === 'retry') {
+    const { startPipeline } = require('@/lib/pipeline');
+    const config = getConfig(body.projectPath);
+    const projectName = config?.projectName || body.projectName;
+    // Reset the processed record first, then re-create with new pipeline
+    resetProcessedIssue(body.projectPath, body.issueId);
+    try {
+      const pipeline = startPipeline('issue-fix-and-review', {
+        issue_id: String(body.issueId),
+        project: projectName,
+        base_branch: config?.baseBranch || 'auto-detect',
+        extra_context: body.context || '',
+      });
+      // Re-mark as processed with new pipeline ID
+      const { getDb } = require('@/src/core/db/database');
+      const { getDbPath } = require('@/src/config');
+      getDb(getDbPath()).prepare(`
+        INSERT OR REPLACE INTO issue_autofix_processed (project_path, issue_number, pipeline_id, status)
+        VALUES (?, ?, ?, 'processing')
+      `).run(body.projectPath, body.issueId, pipeline.id);
+      return NextResponse.json({ ok: true, pipelineId: pipeline.id });
+    } catch (e) {
+      return NextResponse.json({ ok: false, error: String(e) }, { status: 500 });
+    }
+  }
+
+  return NextResponse.json({ error: 'Invalid action' }, { status: 400 });
+}

package/.forge/worktrees/pipeline-ecd7cb0f/app/api/logs/route.ts

@@ -0,0 +1,100 @@
+import { NextResponse } from 'next/server';
+import { existsSync, statSync, openSync, readSync, closeSync, writeFileSync, renameSync } from 'node:fs';
+import { join } from 'node:path';
+import { getDataDir } from '@/lib/dirs';
+import { execSync } from 'node:child_process';
+
+const LOG_FILE = join(getDataDir(), 'forge.log');
+const MAX_LOG_SIZE = 5 * 1024 * 1024; // 5MB — auto-rotate above this
+
+/** Read last N bytes from file (efficient tail) */
+function tailFile(filePath: string, maxBytes: number): string {
+  const stat = statSync(filePath);
+  const size = stat.size;
+  const readSize = Math.min(size, maxBytes);
+  const buf = Buffer.alloc(readSize);
+  const fd = openSync(filePath, 'r');
+  readSync(fd, buf, 0, readSize, size - readSize);
+  closeSync(fd);
+  // Skip partial first line
+  const str = buf.toString('utf-8');
+  const firstNewline = str.indexOf('\n');
+  return firstNewline > 0 ? str.slice(firstNewline + 1) : str;
+}
+
+/** Rotate log if too large: forge.log → forge.log.old, start fresh */
+function rotateIfNeeded() {
+  if (!existsSync(LOG_FILE)) return;
+  const stat = statSync(LOG_FILE);
+  if (stat.size > MAX_LOG_SIZE) {
+    const oldFile = LOG_FILE + '.old';
+    try { renameSync(LOG_FILE, oldFile); } catch {}
+    writeFileSync(LOG_FILE, `[forge] Log rotated at ${new Date().toISOString()} (previous: ${(stat.size / 1024 / 1024).toFixed(1)}MB)\n`, 'utf-8');
+  }
+}
+
+// GET /api/logs?lines=200&search=keyword
+export async function GET(req: Request) {
+  const { searchParams } = new URL(req.url);
+  const lines = Math.min(parseInt(searchParams.get('lines') || '200'), 1000);
+  const search = searchParams.get('search') || '';
+
+  rotateIfNeeded();
+
+  if (!existsSync(LOG_FILE)) {
+    return NextResponse.json({ lines: [], total: 0, size: 0 });
+  }
+
+  try {
+    const stat = statSync(LOG_FILE);
+    // Read last 512KB max (enough for ~5000 lines)
+    const raw = tailFile(LOG_FILE, 512 * 1024);
+    let allLines = raw.split('\n').filter(Boolean);
+
+    if (search) {
+      allLines = allLines.filter(l => l.toLowerCase().includes(search.toLowerCase()));
+    }
+
+    const result = allLines.slice(-lines);
+
+    return NextResponse.json({
+      lines: result,
+      total: allLines.length,
+      size: stat.size,
+      file: LOG_FILE,
+    });
+  } catch (e: any) {
+    return NextResponse.json({ error: e.message }, { status: 500 });
+  }
+}
+
+// POST /api/logs — actions
+export async function POST(req: Request) {
+  const body = await req.json();
+
+  if (body.action === 'clear') {
+    try {
+      writeFileSync(LOG_FILE, `[forge] Log cleared at ${new Date().toISOString()}\n`, 'utf-8');
+      return NextResponse.json({ ok: true });
+    } catch (e: any) {
+      return NextResponse.json({ error: e.message }, { status: 500 });
+    }
+  }
+
+  if (body.action === 'processes') {
+    try {
+      const out = execSync("ps aux | grep -E 'next-server|telegram-standalone|terminal-standalone|cloudflared' | grep -v grep", {
+        encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'],
+      }).trim();
+      const processes = out.split('\n').filter(Boolean).map(line => {
+        const parts = line.trim().split(/\s+/);
+        return { pid: parts[1], cpu: parts[2], mem: parts[3], cmd: parts.slice(10).join(' ').slice(0, 80) };
+      });
+      return NextResponse.json({ processes });
+    } catch {
+      return NextResponse.json({ processes: [] });
+    }
+  }
+
+  return NextResponse.json({ error: 'Invalid action' }, { status: 400 });
+}

package/.forge/worktrees/pipeline-ecd7cb0f/app/api/mobile-chat/route.ts

@@ -0,0 +1,115 @@
+import { NextResponse } from 'next/server';
+import { spawn } from 'node:child_process';
+import { loadSettings } from '@/lib/settings';
+
+export const dynamic = 'force-dynamic';
+export const runtime = 'nodejs';
+
+// POST /api/mobile-chat — send a message to claude and stream response
+export async function POST(req: Request) {
+  const { message, projectPath, resume, agent: agentId } = await req.json() as {
+    message: string;
+    projectPath: string;
+    resume?: boolean;
+    agent?: string;
+  };
+
+  if (!message || !projectPath) {
+    return NextResponse.json({ error: 'message and projectPath required' }, { status: 400 });
+  }
+
+  const { getAgent } = require('@/lib/agents');
+  const adapter = getAgent(agentId);
+  const projectName = projectPath.split('/').pop() || projectPath;
+
+  const spawnOpts = adapter.buildTaskSpawn({
+    projectPath,
+    prompt: message,
+    skipPermissions: true,
+    outputFormat: adapter.config.capabilities?.supportsStreamJson ? 'json' : undefined,
+    conversationId: resume ? 'last' : undefined,
+  });
+
+  const child = spawn(spawnOpts.cmd, spawnOpts.args, {
+    cwd: projectPath,
+    env: { ...process.env, ...(spawnOpts.env || {}) },
+    stdio: ['pipe', 'pipe', 'pipe'],
+  });
+
+  child.stdin.write(message);
+  child.stdin.end();
+
+  const encoder = new TextEncoder();
+  let closed = false;
+  let fullOutput = '';
+
+  const stream = new ReadableStream({
+    start(controller) {
+      child.stdout.on('data', (chunk: Buffer) => {
+        if (closed) return;
+        const text = chunk.toString();
+        fullOutput += text;
+        try {
+          controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: 'chunk', text })}\n\n`));
+        } catch {}
+      });
+
+      child.stderr.on('data', (chunk: Buffer) => {
+        if (closed) return;
+        const text = chunk.toString();
+        if (text.includes('npm update') || text.includes('WARN')) return;
+        try {
+          controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: 'stderr', text })}\n\n`));
+        } catch {}
+      });
+
+      child.on('exit', (code) => {
+        if (closed) return;
+        closed = true;
+
+        // Record usage from the JSON output
+        try {
+          const parsed = JSON.parse(fullOutput);
+          if (parsed.session_id) {
+            const { recordUsage } = require('@/lib/usage-scanner');
+            recordUsage({
+              sessionId: parsed.session_id,
+              source: 'mobile',
+              projectPath,
+              projectName,
+              model: parsed.model || 'unknown',
+              inputTokens: parsed.usage?.input_tokens || parsed.total_input_tokens || 0,
+              outputTokens: parsed.usage?.output_tokens || parsed.total_output_tokens || 0,
+            });
+          }
+        } catch {}
+
+        try {
+          controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: 'done', code })}\n\n`));
+          controller.close();
+        } catch {}
+      });
+
+      child.on('error', (err) => {
+        if (closed) return;
+        closed = true;
+        try {
+          controller.enqueue(encoder.encode(`data: ${JSON.stringify({ type: 'error', message: err.message })}\n\n`));
+          controller.close();
+        } catch {}
+      });
+    },
+    cancel() {
+      closed = true;
+      try { child.kill('SIGTERM'); } catch {}
+    },
+  });
+
+  return new Response(stream, {
+    headers: {
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache, no-transform',
+      Connection: 'keep-alive',
+    },
+  });
+}

package/.forge/worktrees/pipeline-ecd7cb0f/app/api/monitor/route.ts

@@ -0,0 +1,74 @@
+import { NextResponse } from 'next/server';
+import { execSync } from 'node:child_process';
+
+function run(cmd: string): string {
+  try {
+    return execSync(cmd, { encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+  } catch { return ''; }
+}
+
+function countProcess(pattern: string): { count: number; pid: string; startedAt: string } {
+  const out = run(`ps aux | grep '${pattern}' | grep -v grep | head -1`);
+  const pid = out ? out.split(/\s+/)[1] || '' : '';
+  const count = out ? run(`ps aux | grep '${pattern}' | grep -v grep | wc -l`).trim() : '0';
+  // Get start time from ps
+  const startedAt = pid ? run(`ps -o lstart= -p ${pid} 2>/dev/null`).trim() : '';
+  return { count: parseInt(count), pid, startedAt };
+}
+
+export async function GET() {
+  // Processes
+  const nextjs = countProcess('next-server');
+  const terminal = countProcess('terminal-standalone');
+  const telegram = countProcess('telegram-standalone');
+  const workspace = countProcess('workspace-standalone');
+  const tunnel = countProcess('cloudflared tunnel');
+
+  // MCP Server (runs inside workspace process, check /health endpoint)
+  let mcpStatus = { running: false, sessions: 0 };
+  try {
+    const mcpPort = Number(process.env.MCP_PORT) || 8406;
+    const mcpRes = run(`curl -s http://localhost:${mcpPort}/health 2>/dev/null`);
+    if (mcpRes.includes('"ok":true')) {
+      const data = JSON.parse(mcpRes);
+      mcpStatus = { running: true, sessions: data.sessions || 0 };
+    }
+  } catch {}
+
+  // Tunnel URL
+  let tunnelUrl = '';
+  try {
+    const { readFileSync } = require('fs');
+    const { join } = require('path');
+    const { getDataDir: _gdd } = require('@/lib/dirs');
+    const state = JSON.parse(readFileSync(join(_gdd(), 'tunnel-state.json'), 'utf-8'));
+    tunnelUrl = state.url || '';
+  } catch {}
+
+  // tmux sessions
+  let sessions: { name: string; created: string; attached: boolean; windows: number }[] = [];
+  try {
+    const out = run("tmux list-sessions -F '#{session_name}||#{session_created}||#{session_attached}||#{session_windows}' 2>/dev/null");
+    sessions = out.split('\n').filter(l => l.startsWith('mw-')).map(line => {
+      const [name, created, attached, windows] = line.split('||');
+      return { name, created: new Date(Number(created) * 1000).toISOString(), attached: attached !== '0', windows: Number(windows) || 1 };
+    });
+  } catch {}
+
+  // System info
+  const uptime = run('uptime');
+  const memory = run("ps -o rss= -p $$ 2>/dev/null || echo 0");
+
+  return NextResponse.json({
+    processes: {
+      nextjs: { running: nextjs.count > 0, pid: nextjs.pid, startedAt: nextjs.startedAt },
+      terminal: { running: terminal.count > 0, pid: terminal.pid, startedAt: terminal.startedAt },
+      telegram: { running: telegram.count > 0, pid: telegram.pid, startedAt: telegram.startedAt },
+      workspace: { running: workspace.count > 0, pid: workspace.pid, startedAt: workspace.startedAt },
+      tunnel: { running: tunnel.count > 0, pid: tunnel.pid, url: tunnelUrl, startedAt: tunnel.startedAt },
+      mcp: { running: mcpStatus.running, port: 8406, sessions: mcpStatus.sessions },
+    },
+    sessions,
+    uptime: uptime.replace(/.*up\s+/, '').replace(/,\s+\d+ user.*/, '').trim(),
+  });
+}

package/.forge/worktrees/pipeline-ecd7cb0f/app/api/notifications/route.ts

@@ -0,0 +1,42 @@
+import { NextResponse } from 'next/server';
+import {
+  getNotifications,
+  getUnreadCount,
+  markRead,
+  markAllRead,
+  deleteNotification,
+} from '@/lib/notifications';
+
+// GET /api/notifications — list notifications + unread count
+export async function GET(req: Request) {
+  const { searchParams } = new URL(req.url);
+  const limit = parseInt(searchParams.get('limit') || '50');
+  const offset = parseInt(searchParams.get('offset') || '0');
+
+  const notifications = getNotifications(limit, offset);
+  const unread = getUnreadCount();
+
+  return NextResponse.json({ notifications, unread });
+}
+
+// POST /api/notifications — actions: markRead, markAllRead, delete
+export async function POST(req: Request) {
+  const body = await req.json();
+
+  if (body.action === 'markRead' && body.id) {
+    markRead(body.id);
+    return NextResponse.json({ ok: true });
+  }
+
+  if (body.action === 'markAllRead') {
+    markAllRead();
+    return NextResponse.json({ ok: true });
+  }
+
+  if (body.action === 'delete' && body.id) {
+    deleteNotification(body.id);
+    return NextResponse.json({ ok: true });
+  }
+
+  return NextResponse.json({ error: 'Invalid action' }, { status: 400 });
+}

package/.forge/worktrees/pipeline-ecd7cb0f/app/api/notify/test/route.ts

@@ -0,0 +1,33 @@
+import { NextResponse } from 'next/server';
+import { loadSettings } from '@/lib/settings';
+
+export async function POST() {
+  const settings = loadSettings();
+  const { telegramBotToken, telegramChatId } = settings;
+
+  if (!telegramBotToken || !telegramChatId) {
+    return NextResponse.json({ ok: false, error: 'Telegram bot token or chat ID not configured' });
+  }
+
+  try {
+    const url = `https://api.telegram.org/bot${telegramBotToken}/sendMessage`;
+    const res = await fetch(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        chat_id: telegramChatId,
+        text: '✅ *Forge* — Test notification!\n\nTelegram notifications are working.',
+        parse_mode: 'Markdown',
+      }),
+    });
+
+    if (!res.ok) {
+      const body = await res.text();
+      return NextResponse.json({ ok: false, error: body });
+    }
+
+    return NextResponse.json({ ok: true });
+  } catch (err: any) {
+    return NextResponse.json({ ok: false, error: err.message });
+  }
+}

package/.forge/worktrees/pipeline-ecd7cb0f/app/api/online/route.ts

@@ -0,0 +1,40 @@
+import { NextResponse, type NextRequest } from 'next/server';
+
+// Track active users: IP/identifier → last seen timestamp
+const activeUsers = new Map<string, { lastSeen: number; isRemote: boolean }>();
+const TIMEOUT = 30_000; // 30s — user is "offline" if no ping in 30s
+
+function cleanup() {
+  const now = Date.now();
+  for (const [key, val] of activeUsers) {
+    if (now - val.lastSeen > TIMEOUT) activeUsers.delete(key);
+  }
+}
+
+// POST /api/online — heartbeat ping
+export async function POST(req: NextRequest) {
+  cleanup();
+
+  const ip = req.headers.get('x-forwarded-for')?.split(',')[0]?.trim()
+    || req.headers.get('x-real-ip')
+    || 'local';
+  const host = req.headers.get('host') || '';
+  const isRemote = host.includes('.trycloudflare.com') || (ip !== 'local' && ip !== '127.0.0.1' && ip !== '::1');
+
+  activeUsers.set(ip, { lastSeen: Date.now(), isRemote });
+
+  const total = activeUsers.size;
+  const remote = [...activeUsers.values()].filter(v => v.isRemote).length;
+
+  return NextResponse.json({ total, remote });
+}
+
+// GET /api/online — just get counts
+export async function GET() {
+  cleanup();
+
+  const total = activeUsers.size;
+  const remote = [...activeUsers.values()].filter(v => v.isRemote).length;
+
+  return NextResponse.json({ total, remote });
+}

package/.forge/worktrees/pipeline-ecd7cb0f/app/api/pipelines/[id]/route.ts

@@ -0,0 +1,41 @@
+import { NextResponse } from 'next/server';
+import { getPipeline, cancelPipeline, deletePipeline, injectConversationMessage } from '@/lib/pipeline';
+
+// GET /api/pipelines/:id
+export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params;
+  const pipeline = getPipeline(id);
+  if (!pipeline) return NextResponse.json({ error: 'Not found' }, { status: 404 });
+  return NextResponse.json(pipeline);
+}
+
+// POST /api/pipelines/:id — actions (cancel, delete, inject)
+export async function POST(req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params;
+  const body = await req.json();
+  const { action } = body;
+
+  if (action === 'cancel') {
+    const ok = cancelPipeline(id);
+    return NextResponse.json({ ok });
+  }
+
+  if (action === 'delete') {
+    const ok = deletePipeline(id);
+    return NextResponse.json({ ok });
+  }
+
+  // Inject a message into a running conversation
+  if (action === 'inject') {
+    const { agentId, message } = body;
+    if (!agentId || !message) return NextResponse.json({ error: 'agentId and message required' }, { status: 400 });
+    try {
+      const ok = injectConversationMessage(id, agentId, message);
+      return NextResponse.json({ ok });
+    } catch (e: any) {
+      return NextResponse.json({ error: e.message }, { status: 400 });
+    }
+  }
+
+  return NextResponse.json({ error: 'Unknown action' }, { status: 400 });
+}

package/.forge/worktrees/pipeline-ecd7cb0f/app/api/pipelines/route.ts

@@ -0,0 +1,90 @@
+import { NextResponse } from 'next/server';
+import { listPipelines, listWorkflows, startPipeline } from '@/lib/pipeline';
+import { writeFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import YAML from 'yaml';
+import { getDataDir } from '@/lib/dirs';
+
+const FLOWS_DIR = join(getDataDir(), 'flows');
+
+// GET /api/pipelines — list all pipelines + available workflows
+export async function GET(req: Request) {
+  const { searchParams } = new URL(req.url);
+  const type = searchParams.get('type');
+
+  if (type === 'workflows') {
+    return NextResponse.json(listWorkflows());
+  }
+
+  if (type === 'workflow-yaml') {
+    const name = searchParams.get('name');
+    if (!name) return NextResponse.json({ error: 'name required' }, { status: 400 });
+    try {
+      const { readFileSync, existsSync } = await import('node:fs');
+      const filePath = join(FLOWS_DIR, `${name}.yaml`);
+      const altPath = join(FLOWS_DIR, `${name}.yml`);
+      const path = existsSync(filePath) ? filePath : existsSync(altPath) ? altPath : null;
+      if (path) {
+        return NextResponse.json({ yaml: readFileSync(path, 'utf-8') });
+      }
+      // Check built-in workflows
+      const workflow = listWorkflows().find(w => w.name === name);
+      if (workflow?.builtin) {
+        const { BUILTIN_WORKFLOWS } = await import('@/lib/pipeline');
+        const yaml = BUILTIN_WORKFLOWS[name];
+        if (yaml) return NextResponse.json({ yaml: yaml.trim(), builtin: true });
+      }
+      return NextResponse.json({ error: 'Not found' }, { status: 404 });
+    } catch {
+      return NextResponse.json({ error: 'Failed to read' }, { status: 500 });
+    }
+  }
+
+  return NextResponse.json(listPipelines().sort((a, b) => b.createdAt.localeCompare(a.createdAt)));
+}
+
+// POST /api/pipelines — start a pipeline or save a workflow
+export async function POST(req: Request) {
+  const body = await req.json();
+
+  // Save workflow YAML from visual editor
+  if (body.action === 'save-workflow' && body.yaml) {
+    try {
+      mkdirSync(FLOWS_DIR, { recursive: true });
+      const parsed = YAML.parse(body.yaml);
+      const name = parsed.name || 'unnamed';
+      const filePath = join(FLOWS_DIR, `${name}.yaml`);
+      writeFileSync(filePath, body.yaml, 'utf-8');
+      return NextResponse.json({ ok: true, name, path: filePath });
+    } catch (e: any) {
+      return NextResponse.json({ error: e.message }, { status: 400 });
+    }
+  }
+
+  // Delete workflow
+  if (body.action === 'delete-workflow' && body.name) {
+    const { existsSync: ex, unlinkSync: ul } = await import('node:fs');
+    const filePath = join(FLOWS_DIR, `${body.name}.yaml`);
+    const altPath = join(FLOWS_DIR, `${body.name}.yml`);
+    const path = ex(filePath) ? filePath : ex(altPath) ? altPath : null;
+    if (!path) return NextResponse.json({ error: 'Not found' }, { status: 404 });
+    // Check if built-in
+    const w = listWorkflows().find(w => w.name === body.name);
+    if (w?.builtin) return NextResponse.json({ error: 'Cannot delete built-in workflow' }, { status: 400 });
+    ul(path);
+    return NextResponse.json({ ok: true });
+  }
+
+  // Start pipeline
+  const { workflow, input } = body;
+  if (!workflow) {
+    return NextResponse.json({ error: 'workflow name required' }, { status: 400 });
+  }
+
+  try {
+    const pipeline = startPipeline(workflow, input || {});
+    return NextResponse.json(pipeline);
+  } catch (e: any) {
+    return NextResponse.json({ error: e.message }, { status: 400 });
+  }
+}