@aion0/forge 0.3.2 → 0.3.4

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/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';
@@ -156,5 +157,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/login/page.tsx

@@ -12,7 +12,7 @@ export default function LoginPage() {
 
   useEffect(() => {
     const host = window.location.hostname;
-    setIsRemote(!['localhost', '127.0.0.1'].includes(host));
+    setIsRemote(host.endsWith('.trycloudflare.com'));
     // Restore theme
     const saved = localStorage.getItem('forge-theme');
     if (saved === 'light') document.documentElement.setAttribute('data-theme', 'light');

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);
@@ -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 }) {

package/components/PipelineView.tsx

@@ -17,6 +17,7 @@ interface WorkflowNode {
 interface Workflow {
   name: string;
   description?: string;
+  builtin?: boolean;
   vars: Record<string, string>;
   input: Record<string, string>;
   nodes: Record<string, WorkflowNode>;
@@ -168,7 +169,7 @@ export default function PipelineView({ onViewTask }: { onViewTask?: (taskId: str
           >
             <option value="">Editor ▾</option>
             <option value="">+ New workflow</option>
-            {workflows.map(w => <option key={w.name} value={w.name}>{w.name}</option>)}
+            {workflows.map(w => <option key={w.name} value={w.name}>{w.builtin ? '⚙ ' : ''}{w.name}</option>)}
           </select>
           <button
             onClick={() => setShowCreate(v => !v)}
@@ -188,7 +189,7 @@ export default function PipelineView({ onViewTask }: { onViewTask?: (taskId: str
             >
               <option value="">Select workflow...</option>
               {workflows.map(w => (
-                <option key={w.name} value={w.name}>{w.name}{w.description ? ` — ${w.description}` : ''}</option>
+                <option key={w.name} value={w.name}>{w.builtin ? '[Built-in] ' : ''}{w.name}{w.description ? ` — ${w.description}` : ''}</option>
               ))}
             </select>