@aion0/forge 0.3.3 → 0.3.5

package/CLAUDE.md

@@ -9,7 +9,8 @@ forge server start              # production via npm link/install
 forge server start --dev        # dev mode
 forge server start              # background by default, logs to ~/.forge/forge.log
 forge server start --foreground # foreground mode
-forge server stop               # stop background server
+forge server stop               # stop default instance (port 3000)
+forge server stop --port 4000 --dir ~/.forge-staging  # stop specific instance
 forge server restart            # stop + start (safe for remote)
 forge server rebuild            # force rebuild
 forge server start --port 4000 --terminal-port 4001 --dir ~/.forge-staging

package/app/api/favorites/route.ts

@@ -0,0 +1,26 @@
+import { NextResponse } from 'next/server';
+import { getDb } from '@/src/core/db/database';
+import { getDbPath } from '@/src/config';
+
+function db() { return getDb(getDbPath()); }
+
+// GET /api/favorites — list all favorites
+export async function GET() {
+  const rows = db().prepare('SELECT project_path FROM project_favorites ORDER BY created_at ASC').all() as any[];
+  return NextResponse.json(rows.map(r => r.project_path));
+}
+
+// POST /api/favorites — add or remove
+export async function POST(req: Request) {
+  const { action, projectPath } = await req.json();
+  if (!projectPath) return NextResponse.json({ error: 'projectPath required' }, { status: 400 });
+
+  if (action === 'add') {
+    db().prepare('INSERT OR IGNORE INTO project_favorites (project_path) VALUES (?)').run(projectPath);
+  } else if (action === 'remove') {
+    db().prepare('DELETE FROM project_favorites WHERE project_path = ?').run(projectPath);
+  }
+
+  const rows = db().prepare('SELECT project_path FROM project_favorites ORDER BY created_at ASC').all() as any[];
+  return NextResponse.json(rows.map(r => r.project_path));
+}

package/app/api/git/route.ts

@@ -1,8 +1,9 @@
 import { NextResponse, type NextRequest } from 'next/server';
-import { execSync } from 'node:child_process';
+import { execSync, exec } from 'node:child_process';
 import { existsSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
+import { promisify } from 'node:util';
 import { loadSettings } from '@/lib/settings';
 
 function isUnderProjectRoot(dir: string): boolean {
@@ -11,8 +12,17 @@ function isUnderProjectRoot(dir: string): boolean {
   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, stdio: ['pipe', 'pipe', 'pipe'] }).toString().trim();
+const execAsync = promisify(exec);
+
+function gitSync(cmd: string, cwd: string): string {
+  return execSync(`git ${cmd}`, { cwd, encoding: 'utf-8', timeout: 10000, stdio: ['pipe', 'pipe', 'pipe'] }).toString().trim();
+}
+
+async function gitAsync(cmd: string, cwd: string): Promise<string> {
+  try {
+    const { stdout } = await execAsync(`git ${cmd}`, { cwd, encoding: 'utf-8', timeout: 10000 });
+    return stdout.trim();
+  } catch { return ''; }
 }
 
 // GET /api/git?dir=<path> — git status for a project
@@ -23,38 +33,33 @@ export async function GET(req: NextRequest) {
   }
 
   try {
-    const branch = git('rev-parse --abbrev-ref HEAD', dir);
-    const statusRaw = execSync('git status --porcelain -u', { cwd: dir, encoding: 'utf-8', timeout: 15000, stdio: ['pipe', 'pipe', 'pipe'] }).toString();
-    const changes = statusRaw.replace(/\n$/, '').split('\n').filter(Boolean).map(line => ({
+    // Run all git commands in parallel
+    const [branchOut, statusOut, remoteOut, lastCommitOut, logOut] = await Promise.all([
+      gitAsync('rev-parse --abbrev-ref HEAD', dir),
+      gitAsync('status --porcelain -u', dir),
+      gitAsync('remote get-url origin', dir),
+      gitAsync('log -1 --format="%h %s"', dir),
+      gitAsync('log --format="%h||%s||%an||%ar" -10', dir),
+    ]);
+
+    const branch = branchOut;
+    const changes = statusOut ? statusOut.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;
+    let ahead = 0, 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;
+      const counts = await gitAsync(`rev-list --left-right --count HEAD...origin/${branch}`, dir);
+      if (counts) { 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 {}
+    const log = logOut ? logOut.split('\n').filter(Boolean).map(line => {
+      const [hash, message, author, date] = line.split('||');
+      return { hash, message, author, date };
+    }) : [];
 
-    return NextResponse.json({ branch, changes, remote, ahead, behind, lastCommit, log });
+    return NextResponse.json({ branch, changes, remote: remoteOut, ahead, behind, lastCommit: lastCommitOut, log });
   } catch (e: any) {
     return NextResponse.json({ error: e.message }, { status: 500 });
   }
@@ -96,30 +101,30 @@ export async function POST(req: NextRequest) {
       if (!message) return NextResponse.json({ error: 'message required' }, { status: 400 });
       if (files && files.length > 0) {
         for (const f of files) {
-          git(`add "${f}"`, dir);
+          gitSync(`add "${f}"`, dir);
         }
       } else {
-        git('add -A', dir);
+        gitSync('add -A', dir);
       }
-      git(`commit -m "${message.replace(/"/g, '\\"')}"`, dir);
+      gitSync(`commit -m "${message.replace(/"/g, '\\"')}"`, dir);
       return NextResponse.json({ ok: true });
     }
 
     if (action === 'push') {
-      const output = git('push', dir);
+      const output = gitSync('push', dir);
       return NextResponse.json({ ok: true, output });
     }
 
     if (action === 'pull') {
-      const output = git('pull', dir);
+      const output = gitSync('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);
+        for (const f of files) gitSync(`add "${f}"`, dir);
       } else {
-        git('add -A', dir);
+        gitSync('add -A', dir);
       }
       return NextResponse.json({ ok: true });
     }

package/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-auto-fix', {
+        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-auto-fix', {
+        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/app/api/pipelines/route.ts

@@ -24,9 +24,17 @@ export async function GET(req: Request) {
       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({ error: 'Not found' }, { status: 404 });
-      const yaml = readFileSync(path, 'utf-8');
-      return NextResponse.json({ yaml });
+      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 });
     }

package/app/api/skills/route.ts

@@ -8,6 +8,7 @@ import {
   uninstallProject,
   refreshInstallState,
   checkLocalModified,
+  purgeDeletedSkill,
 } from '@/lib/skills';
 import { loadSettings } from '@/lib/settings';
 import { homedir } from 'node:os';
@@ -98,8 +99,6 @@ export async function GET(req: Request) {
       return NextResponse.json({ content: '(Failed to load)' });
     }
   }
-  // Refresh install state from filesystem
-  refreshInstallState(getProjectPaths());
   const skills = listSkills();
   const projects = getProjectPaths().map(p => ({ path: p, name: p.split('/').pop() || p }));
   return NextResponse.json({ skills, projects });
@@ -156,5 +155,16 @@ export async function POST(req: Request) {
     }
   }
 
+  if (body.action === 'purge-deleted') {
+    const { name } = body;
+    if (!name) return NextResponse.json({ ok: false, error: 'name required' }, { status: 400 });
+    try {
+      purgeDeletedSkill(name);
+      return NextResponse.json({ ok: true });
+    } catch (e) {
+      return NextResponse.json({ ok: false, error: String(e) }, { status: 500 });
+    }
+  }
+
   return NextResponse.json({ error: 'Invalid action' }, { status: 400 });
 }

package/app/api/tabs/route.ts

@@ -0,0 +1,25 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getDb } from '@/src/core/db/database';
+import { getDbPath } from '@/src/config';
+
+function db() { return getDb(getDbPath()); }
+
+export async function GET(req: NextRequest) {
+  const type = req.nextUrl.searchParams.get('type') || 'projects';
+  try {
+    const row = db().prepare('SELECT data FROM tab_state WHERE type = ?').get(type) as any;
+    if (row?.data) return NextResponse.json(JSON.parse(row.data));
+  } catch {}
+  return NextResponse.json({ tabs: [], activeTabId: 0 });
+}
+
+export async function POST(req: NextRequest) {
+  const type = req.nextUrl.searchParams.get('type') || 'projects';
+  try {
+    const body = await req.json();
+    db().prepare('INSERT OR REPLACE INTO tab_state (type, data) VALUES (?, ?)').run(type, JSON.stringify(body));
+    return NextResponse.json({ ok: true });
+  } catch (e: any) {
+    return NextResponse.json({ ok: false, error: e.message }, { status: 500 });
+  }
+}

package/bin/forge-server.mjs

@@ -67,6 +67,7 @@ const terminalPort = parseInt(getArg('--terminal-port')) || (webPort + 1);
 const DATA_DIR = getArg('--dir')?.replace(/^~/, homedir()) || join(homedir(), '.forge', 'data');
 
 const PID_FILE = join(DATA_DIR, 'forge.pid');
+const PIDS_FILE = join(DATA_DIR, 'forge.pids'); // all child process PIDs
 const LOG_FILE = join(DATA_DIR, 'forge.log');
 
 process.chdir(ROOT);
@@ -188,7 +189,7 @@ if (!isStop) {
     writeFileSync(settingsFile, YAML.stringify(settings), 'utf-8');
     console.log('[forge] Admin password saved');
 
-    if (resetPassword && !isDev && !isBackground && !isRestart) {
+    if (resetPassword) {
       process.exit(0);
     }
   }
@@ -208,16 +209,43 @@ if (resetTerminal) {
   }
 }
 
+// ── PID tracking for clean shutdown ──
+
+function savePids(pids) {
+  writeFileSync(PIDS_FILE, JSON.stringify(pids), 'utf-8');
+}
+
+function loadPids() {
+  try { return JSON.parse(readFileSync(PIDS_FILE, 'utf-8')); } catch { return []; }
+}
+
+function killTrackedPids() {
+  const pids = loadPids();
+  for (const pid of pids) {
+    try { process.kill(pid, 'SIGTERM'); } catch {}
+  }
+  // Give them a moment, then force kill
+  if (pids.length > 0) {
+    setTimeout(() => {
+      for (const pid of pids) {
+        try { process.kill(pid, 'SIGKILL'); } catch {}
+      }
+    }, 2000);
+  }
+  try { unlinkSync(PIDS_FILE); } catch {}
+}
+
 // ── Kill orphan standalone processes ──
 const protectedPids = new Set();
 
 function cleanupOrphans() {
+  const myPid = String(process.pid);
+  const instanceTag = `--forge-port=${webPort}`;
   try {
-    // Only kill processes on OUR ports, not other instances
+    // Kill processes on our ports
     for (const port of [webPort, terminalPort]) {
       try {
         const pids = execSync(`lsof -ti:${port}`, { encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'] }).trim();
-        const myPid = String(process.pid);
         for (const pid of pids.split('\n').filter(Boolean)) {
           const p = pid.trim();
           if (p === myPid || protectedPids.has(p)) continue;
@@ -225,20 +253,18 @@ function cleanupOrphans() {
         }
       } catch {}
     }
-    // Kill standalone processes that belong to this instance (match by FORGE_DATA_DIR)
+    // Kill standalone processes: our instance's + orphans without any tag
     try {
       const out = execSync(`ps aux | grep -E 'telegram-standalone|terminal-standalone' | grep -v grep`, {
         encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'],
       }).trim();
-      if (out) {
-        const myPid = String(process.pid);
-        for (const line of out.split('\n').filter(Boolean)) {
-          // Only kill if it matches our DATA_DIR or port
-          if (!line.includes(DATA_DIR) && !line.includes(`PORT=${webPort}`) && !line.includes(`TERMINAL_PORT=${terminalPort}`)) continue;
-          const pid = line.trim().split(/\s+/)[1];
-          if (pid === myPid || protectedPids.has(pid)) continue;
-          try { process.kill(parseInt(pid), 'SIGTERM'); } catch {}
-        }
+      for (const line of out.split('\n').filter(Boolean)) {
+        const isOurs = line.includes(instanceTag);
+        const isOrphan = !line.includes('--forge-port='); // no tag = legacy orphan
+        if (!isOurs && !isOrphan) continue; // belongs to another instance, skip
+        const pid = line.trim().split(/\s+/)[1];
+        if (pid === myPid || protectedPids.has(pid)) continue;
+        try { process.kill(parseInt(pid), 'SIGTERM'); } catch {}
       }
     } catch {}
   } catch {}
@@ -250,9 +276,11 @@ const services = [];
 function startServices() {
   cleanupOrphans();
 
+  const instanceTag = `--forge-port=${webPort}`;
+
   // Terminal server
   const termScript = join(ROOT, 'lib', 'terminal-standalone.ts');
-  const termChild = spawn('npx', ['tsx', termScript], {
+  const termChild = spawn('npx', ['tsx', termScript, instanceTag], {
     cwd: ROOT,
     stdio: ['ignore', 'inherit', 'inherit'],
     env: { ...process.env },
@@ -262,13 +290,17 @@ function startServices() {
 
   // Telegram bot
   const telegramScript = join(ROOT, 'lib', 'telegram-standalone.ts');
-  const telegramChild = spawn('npx', ['tsx', telegramScript], {
+  const telegramChild = spawn('npx', ['tsx', telegramScript, instanceTag], {
     cwd: ROOT,
     stdio: ['ignore', 'inherit', 'inherit'],
     env: { ...process.env },
   });
   services.push(telegramChild);
   console.log(`[forge] Telegram bot started (pid: ${telegramChild.pid})`);
+
+  // Track all child PIDs for clean shutdown
+  const childPids = services.map(c => c.pid).filter(Boolean);
+  savePids(childPids);
 }
 
 function stopServices() {
@@ -280,20 +312,47 @@ function stopServices() {
 }
 
 // ── Helper: stop running instance ──
-function stopServer() {
+async function stopServer() {
   stopServices();
   try { unlinkSync(join(DATA_DIR, 'tunnel-state.json')); } catch {}
 
+  // Kill all tracked child PIDs first
+  killTrackedPids();
+
+  let stopped = false;
+
+  // Try PID file first
   try {
     const pid = parseInt(readFileSync(PID_FILE, 'utf-8').trim());
     process.kill(pid, 'SIGTERM');
-    unlinkSync(PID_FILE);
     console.log(`[forge] Stopped (pid ${pid})`);
-    return true;
-  } catch {
+    stopped = true;
+  } catch {}
+  try { unlinkSync(PID_FILE); } catch {}
+
+  // Also kill by port (in case PID file is stale)
+  const portPids = [];
+  try {
+    const pids = execSync(`lsof -ti:${webPort}`, { encoding: 'utf-8', timeout: 3000 }).trim();
+    for (const p of pids.split('\n').filter(Boolean)) {
+      const pid = parseInt(p.trim());
+      try { process.kill(pid, 'SIGTERM'); stopped = true; portPids.push(pid); } catch {}
+    }
+    if (pids) console.log(`[forge] Killed processes on port ${webPort}`);
+  } catch {}
+
+  // Force kill after 2 seconds if SIGTERM didn't work
+  if (portPids.length > 0) {
+    await new Promise(r => setTimeout(r, 2000));
+    for (const pid of portPids) {
+      try { process.kill(pid, 'SIGKILL'); } catch {}
+    }
+  }
+
+  if (!stopped) {
     console.log('[forge] No running server found');
-    return false;
   }
+  return stopped;
 }
 
 // ── Helper: start background server ──
@@ -329,13 +388,13 @@ function startBackground() {
 
 // ── Stop ──
 if (isStop) {
-  stopServer();
+  await stopServer();
   process.exit(0);
 }
 
 // ── Restart ──
 if (isRestart) {
-  stopServer();
+  await stopServer();
   // Wait for port to fully release
   const net = await import('node:net');
   for (let i = 0; i < 20; i++) {

package/cli/mw.ts

@@ -16,7 +16,8 @@
  *   mw watch <id>                  — live stream task output
  */
 
-const BASE = process.env.MW_URL || 'http://localhost:3000';
+const _cliPort = process.argv.find((a, i) => i > 0 && process.argv[i - 1] === '--port');
+const BASE = process.env.MW_URL || `http://localhost:${_cliPort || '3000'}`;
 
 const [, , cmd, ...args] = process.argv;
 

package/components/DocTerminal.tsx

@@ -8,13 +8,14 @@ import '@xterm/xterm/css/xterm.css';
 const SESSION_NAME = 'mw-docs-claude';
 
 function getWsUrl() {
-  if (typeof window === 'undefined') return 'ws://localhost:3001';
+  if (typeof window === 'undefined') return `ws://localhost:${parseInt(process.env.TERMINAL_PORT || '3001')}`;
   const wsProtocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
   const wsHost = window.location.hostname;
   if (wsHost !== 'localhost' && wsHost !== '127.0.0.1') {
     return `${wsProtocol}//${window.location.host}/terminal-ws`;
   }
-  return `${wsProtocol}//${wsHost}:3001`;
+  const webPort = parseInt(window.location.port) || 3000;
+  return `${wsProtocol}//${wsHost}:${webPort + 1}`;
 }
 
 export default function DocTerminal({ docRoot }: { docRoot: string }) {