@aion0/forge 0.6.0 → 0.6.3

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

@@ -1,37 +0,0 @@
-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-316c6574/app/api/tasks/route.ts

@@ -1,44 +0,0 @@
-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-316c6574/app/api/tasks/session/route.ts

@@ -1,14 +0,0 @@
-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-316c6574/app/api/telegram/route.ts

@@ -1,23 +0,0 @@
-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-316c6574/app/api/templates/route.ts

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

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

@@ -1,35 +0,0 @@
-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-316c6574/app/api/terminal-cwd/route.ts

@@ -1,19 +0,0 @@
-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-316c6574/app/api/terminal-state/route.ts

@@ -1,15 +0,0 @@
-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-316c6574/app/api/tunnel/route.ts

@@ -1,26 +0,0 @@
-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-316c6574/app/api/upgrade/route.ts

@@ -1,43 +0,0 @@
-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-316c6574/app/api/usage/route.ts

@@ -1,20 +0,0 @@
-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-316c6574/app/api/version/route.ts

@@ -1,78 +0,0 @@
-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-316c6574/app/api/watchers/route.ts

@@ -1,33 +0,0 @@
-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-316c6574/app/api/workspace/[id]/agents/route.ts

@@ -1,35 +0,0 @@
-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-316c6574/app/api/workspace/[id]/memory/route.ts

@@ -1,23 +0,0 @@
-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-316c6574/app/api/workspace/[id]/smith/route.ts

@@ -1,22 +0,0 @@
-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-316c6574/app/api/workspace/[id]/stream/route.ts

@@ -1,28 +0,0 @@
-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-316c6574/app/api/workspace/route.ts

@@ -1,100 +0,0 @@
-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-316c6574/app/global-error.tsx

@@ -1,21 +0,0 @@
-'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>
-  );
-}