@aion0/forge 0.2.1 → 0.2.2

package/app/api/code/route.ts

@@ -123,12 +123,39 @@ export async function GET(req: Request) {
     }
     try {
       const stat = statSync(fullPath);
-      if (stat.size > 500_000) {
-        return NextResponse.json({ content: '// File too large to display', language: 'text' });
+      const ext = extname(fullPath).replace('.', '').toLowerCase();
+      const size = stat.size;
+      const sizeKB = Math.round(size / 1024);
+      const sizeMB = (size / (1024 * 1024)).toFixed(1);
+
+      // Binary/unsupported file types
+      const BINARY_EXTS = new Set([
+        'png', 'jpg', 'jpeg', 'gif', 'bmp', 'ico', 'webp', 'svg', 'avif',
+        'mp3', 'mp4', 'wav', 'ogg', 'webm', 'mov', 'avi',
+        'zip', 'gz', 'tar', 'bz2', 'xz', '7z', 'rar',
+        'pdf', 'doc', 'docx', 'xls', 'xlsx', 'ppt', 'pptx',
+        'exe', 'dll', 'so', 'dylib', 'bin', 'o', 'a',
+        'woff', 'woff2', 'ttf', 'eot', 'otf',
+        'sqlite', 'db', 'sqlite3',
+        'class', 'jar', 'war',
+        'pyc', 'pyo', 'wasm',
+      ]);
+      if (BINARY_EXTS.has(ext)) {
+        return NextResponse.json({ binary: true, fileType: ext, size, sizeLabel: sizeKB > 1024 ? `${sizeMB} MB` : `${sizeKB} KB` });
       }
+
+      const force = searchParams.get('force') === '1';
+
+      // Large file warning (> 200KB needs confirmation, > 2MB blocked)
+      if (size > 2_000_000) {
+        return NextResponse.json({ tooLarge: true, size, sizeLabel: `${sizeMB} MB`, message: 'File exceeds 2 MB limit' });
+      }
+      if (size > 200_000 && !force) {
+        return NextResponse.json({ large: true, size, sizeLabel: `${sizeKB} KB`, language: ext });
+      }
+
       const content = readFileSync(fullPath, 'utf-8');
-      const ext = extname(fullPath).replace('.', '') || 'text';
-      return NextResponse.json({ content, language: ext });
+      return NextResponse.json({ content, language: ext, size });
     } catch {
       return NextResponse.json({ error: 'File not found' }, { status: 404 });
     }

package/app/api/docs/route.ts

@@ -8,9 +8,12 @@ interface FileNode {
   name: string;
   path: string;      // relative to docRoot
   type: 'file' | 'dir';
+  fileType?: 'md' | 'image' | 'other';
   children?: FileNode[];
 }
 
+const IMAGE_EXTS = new Set(['.png', '.jpg', '.jpeg', '.gif', '.svg', '.webp', '.bmp', '.ico', '.avif']);
+
 function scanDir(dir: string, base: string, depth: number = 0): FileNode[] {
   if (depth > 6) return [];
   try {
@@ -35,8 +38,15 @@ function scanDir(dir: string, base: string, depth: number = 0): FileNode[] {
         if (children.length > 0) {
           nodes.push({ name: entry.name, path: relPath, type: 'dir', children });
         }
-      } else if (extname(entry.name) === '.md') {
-        nodes.push({ name: entry.name, path: relPath, type: 'file' });
+      } else {
+        const ext = extname(entry.name).toLowerCase();
+        if (ext === '.md') {
+          nodes.push({ name: entry.name, path: relPath, type: 'file', fileType: 'md' });
+        } else if (IMAGE_EXTS.has(ext)) {
+          nodes.push({ name: entry.name, path: relPath, type: 'file', fileType: 'image' });
+        } else if (!entry.name.startsWith('.')) {
+          nodes.push({ name: entry.name, path: relPath, type: 'file', fileType: 'other' });
+        }
       }
     }
     return nodes;
@@ -60,15 +70,50 @@ export async function GET(req: Request) {
 
   const rootNames = docRoots.map(r => r.split('/').pop() || r);
 
+  // Serve image
+  const imagePath = searchParams.get('image');
+  if (imagePath && rootIdx < docRoots.length) {
+    const root = docRoots[rootIdx];
+    const fullPath = join(root, imagePath);
+    if (!fullPath.startsWith(root)) {
+      return NextResponse.json({ error: 'Invalid path' }, { status: 400 });
+    }
+    try {
+      const { readFileSync: readBin } = require('node:fs');
+      const data = readBin(fullPath);
+      const ext = extname(fullPath).toLowerCase();
+      const mimeMap: Record<string, string> = {
+        '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg',
+        '.gif': 'image/gif', '.svg': 'image/svg+xml', '.webp': 'image/webp',
+        '.bmp': 'image/bmp', '.ico': 'image/x-icon', '.avif': 'image/avif',
+      };
+      return new Response(data, {
+        headers: { 'Content-Type': mimeMap[ext] || 'application/octet-stream', 'Cache-Control': 'public, max-age=3600' },
+      });
+    } catch {
+      return NextResponse.json({ error: 'Image not found' }, { status: 404 });
+    }
+  }
+
   // Read file content
   if (filePath && rootIdx < docRoots.length) {
     const root = docRoots[rootIdx];
     const fullPath = join(root, filePath);
-    // Security: ensure path doesn't escape root
     if (!fullPath.startsWith(root)) {
       return NextResponse.json({ error: 'Invalid path' }, { status: 400 });
     }
     try {
+      const stat = statSync(fullPath);
+      const size = stat.size;
+      const sizeKB = Math.round(size / 1024);
+      const sizeMB = (size / (1024 * 1024)).toFixed(1);
+
+      if (size > 2_000_000) {
+        return NextResponse.json({ tooLarge: true, size, sizeLabel: `${sizeMB} MB`, message: 'File exceeds 2 MB limit' });
+      }
+      if (size > 200_000) {
+        return NextResponse.json({ large: true, size, sizeLabel: `${sizeKB} KB` });
+      }
       const content = readFileSync(fullPath, 'utf-8');
       return NextResponse.json({ content });
     } catch {

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/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);
 }