@aion0/forge 0.5.25 → 0.5.26

package/.forge/worktrees/pipeline-e7f78b7a/app/api/tasks/link/route.ts

@@ -0,0 +1,37 @@
+import { NextResponse } from 'next/server';
+import { createTask } from '@/lib/task-manager';
+import { getProjectInfo } from '@/lib/projects';
+import { getDb } from '@/src/core/db/database';
+import { getDbPath } from '@/src/config';
+
+/**
+ * Link an existing local Claude Code session to a project.
+ * Creates a placeholder task with the conversation_id so future tasks
+ * for this project automatically continue that session.
+ */
+export async function POST(req: Request) {
+  const { projectName, conversationId } = await req.json();
+
+  if (!projectName || !conversationId) {
+    return NextResponse.json({ error: 'projectName and conversationId required' }, { status: 400 });
+  }
+
+  const project = getProjectInfo(projectName);
+  if (!project) {
+    return NextResponse.json({ error: `Project not found: ${projectName}` }, { status: 404 });
+  }
+
+  // Create a placeholder "done" task that carries the conversation_id
+  const db = getDb(getDbPath());
+  const id = `link-${Date.now().toString(36)}`;
+  db.prepare(`
+    INSERT INTO tasks (id, project_name, project_path, prompt, status, priority, conversation_id, log, result_summary, completed_at)
+    VALUES (?, ?, ?, ?, 'done', 0, ?, '[]', ?, datetime('now'))
+  `).run(id, project.name, project.path, '(linked from local CLI)', conversationId, `Session ${conversationId} linked from local CLI`);
+
+  return NextResponse.json({
+    id,
+    projectName: project.name,
+    conversationId,
+  });
+}

package/.forge/worktrees/pipeline-e7f78b7a/app/api/tasks/route.ts

@@ -0,0 +1,44 @@
+import { NextResponse } from 'next/server';
+import { createTask, listTasks } from '@/lib/task-manager';
+import { ensureInitialized } from '@/lib/init';
+import { getProjectInfo } from '@/lib/projects';
+import type { TaskStatus } from '@/src/types';
+
+// List tasks — optionally filter by status
+export async function GET(req: Request) {
+  ensureInitialized();
+  const url = new URL(req.url);
+  const status = url.searchParams.get('status') as TaskStatus | null;
+  return NextResponse.json(listTasks(status || undefined));
+}
+
+// Create a new task
+export async function POST(req: Request) {
+  const { projectName, prompt, priority, newSession, conversationId, scheduledAt, mode, watchConfig, agent } = await req.json();
+
+  if (!projectName || !prompt) {
+    return NextResponse.json({ error: 'projectName and prompt are required' }, { status: 400 });
+  }
+
+  const project = getProjectInfo(projectName);
+  if (!project) {
+    return NextResponse.json({ error: `Project not found: ${projectName}` }, { status: 404 });
+  }
+
+  // conversationId: explicit value → use it; newSession → empty string (force new); otherwise → auto-inherit
+  const convId = conversationId || (newSession ? '' : undefined);
+
+  const task = createTask({
+    projectName: project.name,
+    projectPath: project.path,
+    prompt,
+    priority: priority || 0,
+    conversationId: convId,
+    scheduledAt: scheduledAt || undefined,
+    mode: mode || 'prompt',
+    watchConfig: watchConfig || undefined,
+    agent: agent || undefined,
+  });
+
+  return NextResponse.json(task);
+}

package/.forge/worktrees/pipeline-e7f78b7a/app/api/tasks/session/route.ts

@@ -0,0 +1,14 @@
+import { NextResponse } from 'next/server';
+import { getProjectConversationId } from '@/lib/task-manager';
+
+export async function GET(req: Request) {
+  const url = new URL(req.url);
+  const project = url.searchParams.get('project');
+
+  if (!project) {
+    return NextResponse.json({ error: 'project parameter required' }, { status: 400 });
+  }
+
+  const conversationId = getProjectConversationId(project);
+  return NextResponse.json({ conversationId });
+}

package/.forge/worktrees/pipeline-e7f78b7a/app/api/telegram/route.ts

@@ -0,0 +1,23 @@
+import { NextResponse, type NextRequest } from 'next/server';
+import { loadSettings } from '@/lib/settings';
+import { handleTelegramMessage } from '@/lib/telegram-bot';
+
+// POST /api/telegram — receives messages from telegram-standalone process
+export async function POST(req: NextRequest) {
+  const settings = loadSettings();
+
+  // Verify the request comes from our standalone process
+  const secret = req.headers.get('x-telegram-secret');
+  if (!secret || secret !== settings.telegramBotToken) {
+    return NextResponse.json({ error: 'unauthorized' }, { status: 401 });
+  }
+
+  const message = await req.json();
+
+  try {
+    await handleTelegramMessage(message);
+    return NextResponse.json({ ok: true });
+  } catch (e: any) {
+    return NextResponse.json({ error: e.message }, { status: 500 });
+  }
+}

package/.forge/worktrees/pipeline-e7f78b7a/app/api/templates/route.ts

@@ -0,0 +1,6 @@
+import { NextResponse } from 'next/server';
+import { loadAllTemplates } from '@/src/config';
+
+export async function GET() {
+  return NextResponse.json(loadAllTemplates());
+}

package/.forge/worktrees/pipeline-e7f78b7a/app/api/terminal-bell/route.ts

@@ -0,0 +1,35 @@
+import { NextResponse } from 'next/server';
+import { loadSettings } from '@/lib/settings';
+import { addNotification } from '@/lib/notifications';
+
+export async function POST(req: Request) {
+  const { tabLabel } = await req.json();
+
+  const label = tabLabel || 'Terminal';
+
+  // In-app notification
+  try {
+    addNotification('terminal_bell', `Terminal idle: ${label}`, `Claude appears to have finished in "${label}".`);
+  } catch {}
+
+  // Telegram notification
+  const settings = loadSettings();
+  const { telegramBotToken, telegramChatId } = settings;
+  if (telegramBotToken && telegramChatId) {
+    try {
+      const chatIds = String(telegramChatId).split(',').map(s => s.trim()).filter(Boolean);
+      for (const chatId of chatIds) {
+        await fetch(`https://api.telegram.org/bot${telegramBotToken}/sendMessage`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            chat_id: chatId,
+            text: `🔔 Forge — Terminal idle\n\n"${label}" appears to have finished.`,
+          }),
+        });
+      }
+    } catch {}
+  }
+
+  return NextResponse.json({ ok: true });
+}

package/.forge/worktrees/pipeline-e7f78b7a/app/api/terminal-cwd/route.ts

@@ -0,0 +1,19 @@
+import { NextResponse } from 'next/server';
+import { execSync } from 'node:child_process';
+
+export async function GET(req: Request) {
+  const { searchParams } = new URL(req.url);
+  const session = searchParams.get('session');
+  if (!session || !session.startsWith('mw-')) {
+    return NextResponse.json({ path: null });
+  }
+  try {
+    const cwd = execSync(`tmux display-message -p -t ${session} '#{pane_current_path}'`, {
+      encoding: 'utf-8',
+      timeout: 3000,
+    }).trim();
+    return NextResponse.json({ path: cwd || null });
+  } catch {
+    return NextResponse.json({ path: null });
+  }
+}

package/.forge/worktrees/pipeline-e7f78b7a/app/api/terminal-state/route.ts

@@ -0,0 +1,15 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { NextResponse } from 'next/server';
+import { getDataDir } from '@/lib/dirs';
+
+const STATE_FILE = join(getDataDir(), 'terminal-state.json');
+
+export async function GET() {
+  try {
+    const data = JSON.parse(readFileSync(STATE_FILE, 'utf-8'));
+    return NextResponse.json(data);
+  } catch {
+    return NextResponse.json(null);
+  }
+}

package/.forge/worktrees/pipeline-e7f78b7a/app/api/tunnel/route.ts

@@ -0,0 +1,26 @@
+import { NextResponse } from 'next/server';
+import { startTunnel, stopTunnel, getTunnelStatus } from '@/lib/cloudflared';
+import { verifyAdmin } from '@/lib/password';
+
+export async function GET() {
+  return NextResponse.json(getTunnelStatus());
+}
+
+export async function POST(req: Request) {
+  const body = await req.json() as { action: 'start' | 'stop'; password?: string };
+
+  if (body.action === 'start') {
+    if (!body.password || !verifyAdmin(body.password)) {
+      return NextResponse.json({ ok: false, error: 'Wrong password' }, { status: 403 });
+    }
+    const result = await startTunnel();
+    return NextResponse.json({ ok: !result.error, ...getTunnelStatus() });
+  }
+
+  if (body.action === 'stop') {
+    stopTunnel();
+    return NextResponse.json({ ok: true, ...getTunnelStatus() });
+  }
+
+  return NextResponse.json({ ok: false, error: 'Invalid action' }, { status: 400 });
+}

package/.forge/worktrees/pipeline-e7f78b7a/app/api/upgrade/route.ts

@@ -0,0 +1,43 @@
+import { NextResponse } from 'next/server';
+import { join } from 'node:path';
+import { execSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+
+export async function POST() {
+  try {
+    // Get global npm root first (before any cwd changes)
+    const pkgRoot = execSync('npm root -g', { encoding: 'utf-8', timeout: 5000, cwd: homedir() }).trim();
+    const forgeRoot = join(pkgRoot, '@aion0', 'forge');
+
+    // Upgrade from npm — use cwd instead of cd
+    execSync('npm install -g @aion0/forge@latest --prefer-online 2>&1', {
+      encoding: 'utf-8',
+      timeout: 120000,
+      cwd: homedir(),
+    });
+
+    // Install devDependencies for build
+    try {
+      execSync('npm install --include=dev 2>&1', { cwd: forgeRoot, timeout: 120000 });
+    } catch {}
+
+    // Read installed version
+    let installedVersion = '';
+    try {
+      const pkg = JSON.parse(readFileSync(join(forgeRoot, 'package.json'), 'utf-8'));
+      installedVersion = pkg.version;
+    } catch {}
+
+    return NextResponse.json({
+      ok: true,
+      message: `Upgraded to v${installedVersion}. Restart server to apply.`,
+    });
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    return NextResponse.json({
+      ok: false,
+      error: `Upgrade failed: ${msg.slice(0, 300)}`,
+    });
+  }
+}

package/.forge/worktrees/pipeline-e7f78b7a/app/api/usage/route.ts

@@ -0,0 +1,20 @@
+import { NextResponse } from 'next/server';
+import { scanUsage, queryUsage } from '@/lib/usage-scanner';
+
+// GET /api/usage?days=7&project=forge&source=task&model=claude-opus-4
+export async function GET(req: Request) {
+  const { searchParams } = new URL(req.url);
+  const days = searchParams.get('days') ? parseInt(searchParams.get('days')!) : undefined;
+  const projectName = searchParams.get('project') || undefined;
+  const source = searchParams.get('source') || undefined;
+  const model = searchParams.get('model') || undefined;
+
+  const data = queryUsage({ days, projectName, source, model });
+  return NextResponse.json(data);
+}
+
+// POST /api/usage — trigger scan
+export async function POST() {
+  const result = scanUsage();
+  return NextResponse.json(result);
+}

package/.forge/worktrees/pipeline-e7f78b7a/app/api/version/route.ts

@@ -0,0 +1,78 @@
+import { NextResponse } from 'next/server';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+// Read version once at module load (= server start), not on every request
+const CURRENT_VERSION = (() => {
+  try {
+    const pkg = JSON.parse(readFileSync(join(process.cwd(), 'package.json'), 'utf-8'));
+    return pkg.version as string;
+  } catch {
+    return '0.0.0';
+  }
+})();
+
+// Cache npm version check for 10 minutes
+let cachedLatest: { version: string; checkedAt: number } | null = null;
+const CACHE_TTL = 10 * 60 * 1000;
+
+// Track which versions we already notified about (avoid duplicates)
+let notifiedVersion = '';
+
+async function getLatestVersion(force = false): Promise<string> {
+  if (!force && cachedLatest && Date.now() - cachedLatest.checkedAt < CACHE_TTL) {
+    return cachedLatest.version;
+  }
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5000);
+    const res = await fetch('https://registry.npmjs.org/@aion0/forge/latest', {
+      signal: controller.signal,
+      headers: { 'Accept': 'application/json' },
+    });
+    clearTimeout(timeout);
+    if (!res.ok) return cachedLatest?.version || '';
+    const data = await res.json();
+    cachedLatest = { version: data.version, checkedAt: Date.now() };
+    return data.version;
+  } catch {
+    return cachedLatest?.version || '';
+  }
+}
+
+function compareVersions(a: string, b: string): number {
+  const pa = a.split('.').map(Number);
+  const pb = b.split('.').map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((pa[i] || 0) < (pb[i] || 0)) return -1;
+    if ((pa[i] || 0) > (pb[i] || 0)) return 1;
+  }
+  return 0;
+}
+
+export async function GET(req: Request) {
+  const { searchParams } = new URL(req.url);
+  const force = searchParams.has('force');
+  const current = CURRENT_VERSION;
+  const latest = await getLatestVersion(force);
+  const hasUpdate = !!(latest && compareVersions(current, latest) < 0);
+
+  // Create a notification when new version is detected (once per version)
+  if (hasUpdate && latest !== notifiedVersion) {
+    notifiedVersion = latest;
+    try {
+      const { addNotification } = require('@/lib/notifications');
+      addNotification(
+        'system',
+        `Update available: v${latest}`,
+        `Current: v${current}\nforge upgrade\nnpm install -g @aion0/forge@latest`,
+      );
+    } catch {}
+  }
+
+  return NextResponse.json({
+    current,
+    latest: latest || current,
+    hasUpdate,
+  });
+}

package/.forge/worktrees/pipeline-e7f78b7a/app/api/watchers/route.ts

@@ -0,0 +1,33 @@
+import { NextResponse } from 'next/server';
+import { ensureInitialized } from '@/lib/init';
+import { listWatchers, createWatcher, deleteWatcher, toggleWatcher } from '@/lib/session-watcher';
+
+export async function GET() {
+  ensureInitialized();
+  return NextResponse.json(listWatchers());
+}
+
+export async function POST(req: Request) {
+  ensureInitialized();
+  const body = await req.json();
+
+  if (body.action === 'delete') {
+    deleteWatcher(body.id);
+    return NextResponse.json({ ok: true });
+  }
+
+  if (body.action === 'toggle') {
+    toggleWatcher(body.id, body.active);
+    return NextResponse.json({ ok: true });
+  }
+
+  // Create new watcher
+  const watcher = createWatcher({
+    projectName: body.projectName,
+    sessionId: body.sessionId,
+    label: body.label,
+    checkInterval: body.checkInterval || 60,
+  });
+
+  return NextResponse.json(watcher);
+}

package/.forge/worktrees/pipeline-e7f78b7a/app/api/workspace/[id]/agents/route.ts

@@ -0,0 +1,35 @@
+import { NextResponse } from 'next/server';
+
+const WORKSPACE_PORT = Number(process.env.WORKSPACE_PORT) || 8405;
+const DAEMON_URL = `http://localhost:${WORKSPACE_PORT}`;
+
+// Proxy to workspace daemon — Agent operations
+export async function POST(req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params;
+  const body = await req.json();
+
+  try {
+    const res = await fetch(`${DAEMON_URL}/workspace/${id}/agents`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body),
+    });
+    const data = await res.json();
+    return NextResponse.json(data, { status: res.status });
+  } catch (err: any) {
+    return NextResponse.json({ error: 'Workspace daemon not available' }, { status: 503 });
+  }
+}
+
+// Proxy to workspace daemon — Get agent states
+export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params;
+
+  try {
+    const res = await fetch(`${DAEMON_URL}/workspace/${id}/agents`);
+    const data = await res.json();
+    return NextResponse.json(data, { status: res.status });
+  } catch (err: any) {
+    return NextResponse.json({ error: 'Workspace daemon not available' }, { status: 503 });
+  }
+}

package/.forge/worktrees/pipeline-e7f78b7a/app/api/workspace/[id]/memory/route.ts

@@ -0,0 +1,23 @@
+import { NextResponse } from 'next/server';
+
+const WORKSPACE_PORT = Number(process.env.WORKSPACE_PORT) || 8405;
+const DAEMON_URL = `http://localhost:${WORKSPACE_PORT}`;
+
+// Proxy to workspace daemon — Memory query
+export async function GET(req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id: workspaceId } = await params;
+  const url = new URL(req.url);
+  const agentId = url.searchParams.get('agentId');
+
+  if (!agentId) {
+    return NextResponse.json({ error: 'agentId required' }, { status: 400 });
+  }
+
+  try {
+    const res = await fetch(`${DAEMON_URL}/workspace/${workspaceId}/memory?agentId=${encodeURIComponent(agentId)}`);
+    const data = await res.json();
+    return NextResponse.json(data, { status: res.status });
+  } catch (err: any) {
+    return NextResponse.json({ error: 'Workspace daemon not available' }, { status: 503 });
+  }
+}

package/.forge/worktrees/pipeline-e7f78b7a/app/api/workspace/[id]/smith/route.ts

@@ -0,0 +1,22 @@
+import { NextResponse } from 'next/server';
+
+const WORKSPACE_PORT = Number(process.env.WORKSPACE_PORT) || 8405;
+const DAEMON_URL = `http://localhost:${WORKSPACE_PORT}`;
+
+// Proxy to workspace daemon — Smith API (called by forge skills in terminal)
+export async function POST(req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params;
+  const body = await req.json();
+
+  try {
+    const res = await fetch(`${DAEMON_URL}/workspace/${id}/smith`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body),
+    });
+    const data = await res.json();
+    return NextResponse.json(data, { status: res.status });
+  } catch (err: any) {
+    return NextResponse.json({ error: 'Workspace daemon not available' }, { status: 503 });
+  }
+}

package/.forge/worktrees/pipeline-e7f78b7a/app/api/workspace/[id]/stream/route.ts

@@ -0,0 +1,28 @@
+const WORKSPACE_PORT = Number(process.env.WORKSPACE_PORT) || 8405;
+const DAEMON_URL = `http://localhost:${WORKSPACE_PORT}`;
+
+// SSE relay — proxy daemon's SSE stream to browser
+export async function GET(req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params;
+
+  try {
+    const daemonRes = await fetch(`${DAEMON_URL}/workspace/${id}/stream`, {
+      signal: req.signal,
+    });
+
+    if (!daemonRes.ok || !daemonRes.body) {
+      return new Response(daemonRes.statusText || 'Daemon error', { status: daemonRes.status });
+    }
+
+    // Pipe daemon SSE stream directly to browser
+    return new Response(daemonRes.body, {
+      headers: {
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache, no-transform',
+        'Connection': 'keep-alive',
+      },
+    });
+  } catch (err: any) {
+    return new Response('Workspace daemon not available', { status: 503 });
+  }
+}

package/.forge/worktrees/pipeline-e7f78b7a/app/api/workspace/route.ts

@@ -0,0 +1,100 @@
+import { NextResponse } from 'next/server';
+import { listWorkspaces, findWorkspaceByProject, loadWorkspace, saveWorkspace, deleteWorkspace } from '@/lib/workspace';
+import type { WorkspaceState } from '@/lib/workspace';
+import { randomUUID } from 'node:crypto';
+
+// List workspaces, find by projectPath, or export template
+export async function GET(req: Request) {
+  const url = new URL(req.url);
+  const projectPath = url.searchParams.get('projectPath');
+  const exportId = url.searchParams.get('export');
+
+  if (exportId) {
+    // Export workspace as template (agents + positions, no state/logs)
+    const ws = loadWorkspace(exportId);
+    if (!ws) return NextResponse.json({ error: 'not found' }, { status: 404 });
+    const template = {
+      name: ws.projectName + ' template',
+      agents: ws.agents.map(a => ({ ...a, entries: undefined })),  // strip Input entries
+      nodePositions: ws.nodePositions,
+      exportedAt: Date.now(),
+    };
+    return NextResponse.json(template);
+  }
+
+  if (projectPath) {
+    const ws = findWorkspaceByProject(projectPath);
+    return NextResponse.json(ws || null);
+  }
+
+  return NextResponse.json(listWorkspaces());
+}
+
+// Create workspace or import template
+export async function POST(req: Request) {
+  const body = await req.json();
+  const { projectPath, projectName, template } = body;
+
+  if (!projectPath || !projectName) {
+    return NextResponse.json({ error: 'projectPath and projectName are required' }, { status: 400 });
+  }
+
+  const existing = findWorkspaceByProject(projectPath);
+  if (existing && !template) {
+    return NextResponse.json(existing);
+  }
+
+  const state: WorkspaceState = {
+    id: existing?.id || randomUUID(),
+    projectPath,
+    projectName,
+    agents: [],
+    agentStates: {},
+    nodePositions: {},
+    busLog: [],
+    createdAt: existing?.createdAt || Date.now(),
+    updatedAt: Date.now(),
+  };
+
+  // Import template: create agents from template with new IDs
+  if (template?.agents) {
+    const idMap = new Map<string, string>(); // old ID → new ID
+    const ts = Date.now();
+    for (const agent of template.agents) {
+      const newId = `${agent.label.toLowerCase().replace(/\s+/g, '-')}-${ts}-${Math.random().toString(36).slice(2, 5)}`;
+      idMap.set(agent.id, newId);
+    }
+    for (const agent of template.agents) {
+      state.agents.push({
+        ...agent,
+        id: idMap.get(agent.id) || agent.id,
+        dependsOn: agent.dependsOn.map((d: string) => idMap.get(d) || d),
+        entries: agent.type === 'input' ? [] : undefined,
+      });
+      state.agentStates[idMap.get(agent.id) || agent.id] = { smithStatus: 'down', taskStatus: 'idle', history: [], artifacts: [] };
+    }
+    if (template.nodePositions) {
+      for (const [oldId, pos] of Object.entries(template.nodePositions)) {
+        const newId = idMap.get(oldId);
+        if (newId) state.nodePositions[newId] = pos as { x: number; y: number };
+      }
+    }
+  }
+
+  await saveWorkspace(state);
+  return NextResponse.json(state, { status: 201 });
+}
+
+// Delete a workspace
+export async function DELETE(req: Request) {
+  const url = new URL(req.url);
+  const id = url.searchParams.get('id');
+  if (!id) return NextResponse.json({ error: 'id required' }, { status: 400 });
+
+  // Unload from daemon if active
+  const daemonUrl = `http://localhost:${Number(process.env.WORKSPACE_PORT) || 8405}`;
+  try { await fetch(`${daemonUrl}/workspace/${id}/unload`, { method: 'POST' }); } catch {}
+
+  deleteWorkspace(id);
+  return NextResponse.json({ ok: true });
+}

package/.forge/worktrees/pipeline-e7f78b7a/app/global-error.tsx

@@ -0,0 +1,21 @@
+'use client';
+
+export default function GlobalError({ error, reset }: { error: Error & { digest?: string }; reset: () => void }) {
+  return (
+    <html lang="en">
+      <head>
+        <meta charSet="utf-8" />
+      </head>
+      <body style={{ background: '#0a0a0a', color: '#e5e5e5', fontFamily: 'monospace', padding: '2rem' }}>
+        <h2>Something went wrong</h2>
+        <p style={{ color: '#999' }}>{error?.message || 'Unknown error'}</p>
+        <button
+          onClick={() => reset()}
+          style={{ marginTop: '1rem', padding: '0.5rem 1rem', background: '#3b82f6', color: '#fff', border: 'none', borderRadius: '4px', cursor: 'pointer' }}
+        >
+          Try again
+        </button>
+      </body>
+    </html>
+  );
+}