@aion0/forge 0.2.1 → 0.2.3

package/app/api/git/route.ts

@@ -0,0 +1,131 @@
+import { NextResponse, type NextRequest } from 'next/server';
+import { execSync } from 'node:child_process';
+import { existsSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { loadSettings } from '@/lib/settings';
+
+function isUnderProjectRoot(dir: string): boolean {
+  const settings = loadSettings();
+  const roots = (settings.projectRoots || []).map(r => r.replace(/^~/, homedir()));
+  return roots.some(root => dir.startsWith(root) || dir === root);
+}
+
+function git(cmd: string, cwd: string): string {
+  return execSync(`git ${cmd}`, { cwd, encoding: 'utf-8', timeout: 15000 }).trim();
+}
+
+// GET /api/git?dir=<path> — git status for a project
+export async function GET(req: NextRequest) {
+  const dir = req.nextUrl.searchParams.get('dir');
+  if (!dir || !isUnderProjectRoot(dir)) {
+    return NextResponse.json({ error: 'Invalid directory' }, { status: 400 });
+  }
+
+  try {
+    const branch = git('rev-parse --abbrev-ref HEAD', dir);
+    const statusRaw = execSync('git status --porcelain -u', { cwd: dir, encoding: 'utf-8', timeout: 15000 });
+    const changes = statusRaw.replace(/\n$/, '').split('\n').filter(Boolean).map(line => ({
+      status: line.substring(0, 2).trim() || 'M',
+      path: line.substring(3).replace(/\/$/, ''),
+    }));
+
+    let remote = '';
+    try { remote = git('remote get-url origin', dir); } catch {}
+
+    let ahead = 0;
+    let behind = 0;
+    try {
+      const counts = git(`rev-list --left-right --count HEAD...origin/${branch}`, dir);
+      const [a, b] = counts.split('\t');
+      ahead = parseInt(a) || 0;
+      behind = parseInt(b) || 0;
+    } catch {}
+
+    const lastCommit = git('log -1 --format="%h %s" 2>/dev/null || echo ""', dir);
+
+    // Git log — recent commits
+    let log: { hash: string; message: string; author: string; date: string }[] = [];
+    try {
+      const logOut = git('log --format="%h||%s||%an||%ar" -20', dir);
+      log = logOut.split('\n').filter(Boolean).map(line => {
+        const [hash, message, author, date] = line.split('||');
+        return { hash, message, author, date };
+      });
+    } catch {}
+
+    return NextResponse.json({ branch, changes, remote, ahead, behind, lastCommit, log });
+  } catch (e: any) {
+    return NextResponse.json({ error: e.message }, { status: 500 });
+  }
+}
+
+// POST /api/git — git operations (commit, push, pull, clone)
+export async function POST(req: NextRequest) {
+  const body = await req.json();
+  const { action, dir, message, files, repoUrl, targetDir } = body;
+
+  if (action === 'clone') {
+    // Clone a repo into a project root
+    if (!repoUrl) return NextResponse.json({ error: 'repoUrl required' }, { status: 400 });
+    const settings = loadSettings();
+    const roots = (settings.projectRoots || []).map(r => r.replace(/^~/, homedir()));
+    const cloneTarget = targetDir || roots[0];
+    if (!cloneTarget) return NextResponse.json({ error: 'No project root configured' }, { status: 400 });
+
+    try {
+      const output = execSync(`git clone "${repoUrl}"`, {
+        cwd: cloneTarget,
+        encoding: 'utf-8',
+        timeout: 60000,
+      });
+      // Extract cloned dir name from URL
+      const repoName = repoUrl.split('/').pop()?.replace(/\.git$/, '') || 'repo';
+      return NextResponse.json({ ok: true, path: join(cloneTarget, repoName), output });
+    } catch (e: any) {
+      return NextResponse.json({ error: e.message }, { status: 500 });
+    }
+  }
+
+  if (!dir || !isUnderProjectRoot(dir)) {
+    return NextResponse.json({ error: 'Invalid directory' }, { status: 400 });
+  }
+
+  try {
+    if (action === 'commit') {
+      if (!message) return NextResponse.json({ error: 'message required' }, { status: 400 });
+      if (files && files.length > 0) {
+        for (const f of files) {
+          git(`add "${f}"`, dir);
+        }
+      } else {
+        git('add -A', dir);
+      }
+      git(`commit -m "${message.replace(/"/g, '\\"')}"`, dir);
+      return NextResponse.json({ ok: true });
+    }
+
+    if (action === 'push') {
+      const output = git('push', dir);
+      return NextResponse.json({ ok: true, output });
+    }
+
+    if (action === 'pull') {
+      const output = git('pull', dir);
+      return NextResponse.json({ ok: true, output });
+    }
+
+    if (action === 'stage') {
+      if (files && files.length > 0) {
+        for (const f of files) git(`add "${f}"`, dir);
+      } else {
+        git('add -A', dir);
+      }
+      return NextResponse.json({ ok: true });
+    }
+
+    return NextResponse.json({ error: 'Unknown action' }, { status: 400 });
+  } catch (e: any) {
+    return NextResponse.json({ error: e.message }, { status: 500 });
+  }
+}

package/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/app/api/pipelines/[id]/route.ts

@@ -0,0 +1,28 @@
+import { NextResponse } from 'next/server';
+import { getPipeline, cancelPipeline, deletePipeline } 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)
+export async function POST(req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params;
+  const { action } = await req.json();
+
+  if (action === 'cancel') {
+    const ok = cancelPipeline(id);
+    return NextResponse.json({ ok });
+  }
+
+  if (action === 'delete') {
+    const ok = deletePipeline(id);
+    return NextResponse.json({ ok });
+  }
+
+  return NextResponse.json({ error: 'Unknown action' }, { status: 400 });
+}

package/app/api/pipelines/route.ts

@@ -0,0 +1,52 @@
+import { NextResponse } from 'next/server';
+import { listPipelines, listWorkflows, startPipeline } from '@/lib/pipeline';
+import { writeFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import YAML from 'yaml';
+
+const FLOWS_DIR = join(homedir(), '.forge', '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());
+  }
+
+  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 });
+    }
+  }
+
+  // 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 });
+  }
+}

package/app/api/preview/[...path]/route.ts

@@ -0,0 +1,64 @@
+import { NextResponse, type NextRequest } from 'next/server';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+const CONFIG_FILE = join(homedir(), '.forge', 'preview.json');
+
+function getPort(): number {
+  try {
+    const data = JSON.parse(readFileSync(CONFIG_FILE, 'utf-8'));
+    return data.port || 0;
+  } catch {
+    return 0;
+  }
+}
+
+async function proxy(req: NextRequest) {
+  const port = getPort();
+  if (!port) {
+    return NextResponse.json({ error: 'Preview not configured' }, { status: 503 });
+  }
+
+  const url = new URL(req.url);
+  const path = url.pathname.replace(/^\/api\/preview/, '') || '/';
+  const target = `http://localhost:${port}${path}${url.search}`;
+
+  try {
+    const headers: Record<string, string> = {};
+    req.headers.forEach((v, k) => {
+      if (!['host', 'connection', 'transfer-encoding'].includes(k.toLowerCase())) {
+        headers[k] = v;
+      }
+    });
+
+    const res = await fetch(target, {
+      method: req.method,
+      headers,
+      body: req.method !== 'GET' && req.method !== 'HEAD' ? await req.arrayBuffer() : undefined,
+      redirect: 'manual',
+    });
+
+    const responseHeaders = new Headers();
+    res.headers.forEach((v, k) => {
+      if (!['transfer-encoding', 'content-encoding'].includes(k.toLowerCase())) {
+        responseHeaders.set(k, v);
+      }
+    });
+
+    return new NextResponse(res.body, {
+      status: res.status,
+      headers: responseHeaders,
+    });
+  } catch {
+    return NextResponse.json({ error: `Cannot connect to localhost:${port}` }, { status: 502 });
+  }
+}
+
+export const GET = proxy;
+export const POST = proxy;
+export const PUT = proxy;
+export const DELETE = proxy;
+export const PATCH = proxy;
+export const HEAD = proxy;
+export const OPTIONS = proxy;

package/app/api/preview/route.ts

@@ -0,0 +1,135 @@
+import { NextResponse } from 'next/server';
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { homedir } from 'node:os';
+import { spawn, execSync, type ChildProcess } from 'node:child_process';
+
+const CONFIG_FILE = join(homedir(), '.forge', 'preview.json');
+
+// Persist tunnel state across hot-reloads
+const stateKey = Symbol.for('mw-preview-state');
+const g = globalThis as any;
+if (!g[stateKey]) g[stateKey] = { process: null, port: 0, url: null, status: 'stopped' };
+const state: { process: ChildProcess | null; port: number; url: string | null; status: string } = g[stateKey];
+
+function getConfig(): { port: number } {
+  try {
+    return JSON.parse(readFileSync(CONFIG_FILE, 'utf-8'));
+  } catch {
+    return { port: 0 };
+  }
+}
+
+function saveConfig(config: { port: number }) {
+  const dir = dirname(CONFIG_FILE);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+
+function getCloudflaredPath(): string | null {
+  const binPath = join(homedir(), '.forge', 'bin', 'cloudflared');
+  if (existsSync(binPath)) return binPath;
+  try {
+    return execSync('which cloudflared', { encoding: 'utf-8' }).trim();
+  } catch {
+    return null;
+  }
+}
+
+// GET — get current preview status
+export async function GET() {
+  return NextResponse.json({
+    port: state.port,
+    url: state.url,
+    status: state.status,
+  });
+}
+
+// POST — start/stop preview tunnel
+export async function POST(req: Request) {
+  const { port, action } = await req.json();
+
+  if (action === 'stop' || port === 0) {
+    if (state.process) {
+      state.process.kill('SIGTERM');
+      state.process = null;
+    }
+    state.port = 0;
+    state.url = null;
+    state.status = 'stopped';
+    saveConfig({ port: 0 });
+    return NextResponse.json({ port: 0, url: null, status: 'stopped' });
+  }
+
+  const p = parseInt(port) || 0;
+  if (!p || p < 1 || p > 65535) {
+    return NextResponse.json({ error: 'Invalid port' }, { status: 400 });
+  }
+
+  // Kill existing tunnel if any
+  if (state.process) {
+    state.process.kill('SIGTERM');
+    state.process = null;
+  }
+
+  const binPath = getCloudflaredPath();
+  if (!binPath) {
+    return NextResponse.json({ error: 'cloudflared not installed. Start the main tunnel first to auto-download it.' }, { status: 500 });
+  }
+
+  state.port = p;
+  state.status = 'starting';
+  state.url = null;
+  saveConfig({ port: p });
+
+  // Start tunnel
+  return new Promise<NextResponse>((resolve) => {
+    let resolved = false;
+
+    const child = spawn(binPath, ['tunnel', '--url', `http://localhost:${p}`], {
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    state.process = child;
+
+    const handleOutput = (data: Buffer) => {
+      const text = data.toString();
+      const urlMatch = text.match(/(https:\/\/[a-z0-9-]+\.trycloudflare\.com)/);
+      if (urlMatch && !state.url) {
+        state.url = urlMatch[1];
+        state.status = 'running';
+        if (!resolved) {
+          resolved = true;
+          resolve(NextResponse.json({ port: p, url: state.url, status: 'running' }));
+        }
+      }
+    };
+
+    child.stdout?.on('data', handleOutput);
+    child.stderr?.on('data', handleOutput);
+
+    child.on('exit', () => {
+      state.process = null;
+      state.status = 'stopped';
+      state.url = null;
+      if (!resolved) {
+        resolved = true;
+        resolve(NextResponse.json({ port: p, url: null, status: 'stopped', error: 'Tunnel exited' }));
+      }
+    });
+
+    child.on('error', (err) => {
+      state.status = 'error';
+      if (!resolved) {
+        resolved = true;
+        resolve(NextResponse.json({ error: err.message }, { status: 500 }));
+      }
+    });
+
+    setTimeout(() => {
+      if (!resolved) {
+        resolved = true;
+        resolve(NextResponse.json({ port: p, url: null, status: state.status, error: 'Timeout waiting for tunnel URL' }));
+      }
+    }, 30000);
+  });
+}

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

@@ -1,5 +1,6 @@
 import { NextResponse } from 'next/server';
 import { getTask, cancelTask, deleteTask, retryTask, updateTask } from '@/lib/task-manager';
+import { getProjectInfo } from '@/lib/projects';
 
 // Get task details (including full log)
 export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
@@ -28,12 +29,17 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
   return NextResponse.json({ error: 'Unknown action' }, { status: 400 });
 }
 
-// Edit a queued task
+// Edit a task
 export async function PATCH(req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params;
   const body = await req.json();
+  // Resolve projectName to projectPath if changed
+  if (body.projectName && !body.projectPath) {
+    const project = getProjectInfo(body.projectName);
+    if (project) body.projectPath = project.path;
+  }
   const updated = updateTask(id, body);
-  if (!updated) return NextResponse.json({ error: 'Cannot edit (only queued tasks)' }, { status: 400 });
+  if (!updated) return NextResponse.json({ error: 'Cannot edit this task' }, { status: 400 });
   return NextResponse.json(updated);
 }