@aion0/forge 0.6.1 → 0.8.0

package/lib/task-manager.ts

@@ -12,12 +12,7 @@ import { loadSettings } from './settings';
 import { notifyTaskComplete, notifyTaskFailed } from './notify';
 import type { Task, TaskLogEntry, TaskStatus, TaskMode, WatchConfig } from '@/src/types';
 
-/** Normalize SQLite datetime('now') → ISO 8601 UTC string. */
-function toIsoUTC(s: string | null | undefined): string | null {
-  if (!s) return null;
-  if (/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/.test(s)) return s.replace(' ', 'T') + 'Z';
-  return s;
-}
+import { toIsoUTC } from './iso-time';
 
 const runnerKey = Symbol.for('mw-task-runner');
 const gRunner = globalThis as any;
@@ -362,33 +357,55 @@ function executeShellTask(task: Task): Promise<void> {
     db().prepare('UPDATE tasks SET started_at = datetime(\'now\') WHERE id = ?').run(task.id);
     console.log(`[task:shell] ${task.projectName}: "${task.prompt.slice(0, 80)}"`);
 
-    const child = spawn('bash', ['-c', task.prompt], {
+    // Use an absolute path: when the parent's PATH is stripped (which has
+    // happened under certain supervisor relaunches), bare 'bash' becomes
+    // ENOENT, the 'error' event fires, and without the listener below it
+    // bubbles up to the process as an uncaughtException — crashing the
+    // entire Next.js worker and triggering a supervisor restart loop.
+    const shell = process.env.SHELL && process.env.SHELL.endsWith('bash') ? process.env.SHELL : '/bin/bash';
+    const child = spawn(shell, ['-c', task.prompt], {
       cwd: task.projectPath,
-      env: { ...process.env },
+      env: { ...process.env, PATH: process.env.PATH || '/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin' },
       stdio: ['ignore', 'pipe', 'pipe'],
     });
 
     let stdout = '';
     let stderr = '';
-    child.stdout.on('data', (chunk: Buffer) => {
-      const text = chunk.toString();
-      stdout += text;
-      appendLog(task.id, { type: 'system', subtype: 'text', content: text, timestamp: new Date().toISOString() });
-    });
-    child.stderr.on('data', (chunk: Buffer) => { stderr += chunk.toString(); });
-
-    child.on('exit', (code) => {
-      if (code === 0) {
+    let resolved = false;
+    const finish = (status: 'done' | 'failed', summary: string, error?: string) => {
+      if (resolved) return;
+      resolved = true;
+      if (status === 'done') {
         db().prepare('UPDATE tasks SET status = ?, result_summary = ?, completed_at = datetime(\'now\') WHERE id = ?')
-          .run('done', stdout.trim(), task.id);
+          .run('done', summary, task.id);
         emit(task.id, 'status', 'done');
       } else {
-        const errMsg = stderr.trim() || `Exit code ${code}`;
         db().prepare('UPDATE tasks SET status = ?, error = ?, completed_at = datetime(\'now\') WHERE id = ?')
-          .run('failed', errMsg, task.id);
+          .run('failed', error || summary || 'unknown error', task.id);
         emit(task.id, 'status', 'failed');
       }
       resolve();
+    };
+
+    // CRITICAL: without this listener, spawn errors (ENOENT, EACCES, …)
+    // become uncaughtException and crash the worker.
+    child.on('error', (err: NodeJS.ErrnoException) => {
+      const msg = `spawn failed: ${err.code || ''} ${err.message}`.trim();
+      console.error(`[task:shell] ${task.id} ${msg}`);
+      appendLog(task.id, { type: 'system', subtype: 'text', content: msg + '\n', timestamp: new Date().toISOString() });
+      finish('failed', '', msg);
+    });
+
+    child.stdout?.on('data', (chunk: Buffer) => {
+      const text = chunk.toString();
+      stdout += text;
+      appendLog(task.id, { type: 'system', subtype: 'text', content: text, timestamp: new Date().toISOString() });
+    });
+    child.stderr?.on('data', (chunk: Buffer) => { stderr += chunk.toString(); });
+
+    child.on('exit', (code) => {
+      if (code === 0) finish('done', stdout.trim());
+      else            finish('failed', '', stderr.trim() || `Exit code ${code}`);
     });
   });
 }
@@ -591,10 +608,21 @@ function executeTask(task: Task): Promise<void> {
         db().prepare('UPDATE tasks SET conversation_id = ? WHERE id = ?').run(sessionId, task.id);
       }
 
-      // Capture git diff
+      // Capture git diff. Three-way fallback so pipeline nodes (which commit
+      // their own work in a worktree) don't end up with an empty diff:
+      //   1. `git diff HEAD`        — uncommitted changes (interactive tasks)
+      //   2. `git diff @{u}..HEAD`  — commits ahead of upstream (worktree pushed nothing yet)
+      //   3. `git show HEAD`        — last commit's diff (fallback when no upstream tracking)
       try {
         const { execSync } = require('node:child_process');
-        const diff = execSync('git diff HEAD', { cwd: task.projectPath, timeout: 5000 }).toString();
+        const tryDiff = (cmd: string): string => {
+          try {
+            return execSync(cmd, { cwd: task.projectPath, timeout: 5000, stdio: ['ignore', 'pipe', 'ignore'] }).toString();
+          } catch { return ''; }
+        };
+        let diff = tryDiff('git diff HEAD');
+        if (!diff.trim()) diff = tryDiff('git diff @{upstream}..HEAD --no-color');
+        if (!diff.trim()) diff = tryDiff('git show HEAD --no-color');
         if (diff.trim()) {
           db().prepare('UPDATE tasks SET git_diff = ? WHERE id = ?').run(diff, task.id);
         }

package/lib/telegram-bot.ts

@@ -296,6 +296,20 @@ async function handleMessage(msg: any) {
         await send(chatId, 'Inject target cleared.');
         break;
       }
+      case '/chat':
+      case '/c':
+        if (args.length === 0) {
+          await send(chatId, 'Usage: /chat <message>\n/chat_new to start a fresh session\n/chat_session to show the active session id');
+        } else {
+          await handleChat(chatId, args.join(' '));
+        }
+        break;
+      case '/chat_new':
+        await handleChatReset(chatId);
+        break;
+      case '/chat_session':
+        await handleChatStatus(chatId);
+        break;
       case '/tunnel':
         await handleTunnelStatus(chatId);
         break;
@@ -354,6 +368,9 @@ async function sendHelp(chatId: number) {
     `🔧 /cancel <id>  /retry <id>\n` +
     `/projects — list projects\n` +
     `🤖 /agents — list available agents\n\n` +
+    `💬 /chat <msg> — chat with Forge agent\n` +
+    `/chat_new — start a fresh chat session\n` +
+    `/chat_session — show active session id\n\n` +
     `🌐 /tunnel — status\n` +
     `/tunnel_start / /tunnel_stop\n` +
     `/tunnel_code <admin_pw> — get session code\n\n` +
@@ -361,6 +378,40 @@ async function sendHelp(chatId: number) {
   );
 }
 
+async function handleChat(chatId: number, userText: string) {
+  try {
+    const { runTelegramTurn } = require('./chat/telegram-bridge') as typeof import('./chat/telegram-bridge');
+    await runTelegramTurn({
+      telegramChatId: chatId,
+      userText,
+      cb: {
+        sendPlaceholder: (text: string) => send(chatId, text),
+        editPlaceholder: (mid: number, text: string) => editMessage(chatId, mid, text),
+        sendNew: (text: string) => send(chatId, text),
+      },
+    });
+  } catch (err) {
+    console.error('[telegram] /chat failed', err);
+    await send(chatId, `✗ chat error: ${(err as Error).message}`);
+  }
+}
+
+async function handleChatReset(chatId: number) {
+  const { clearTelegramSession } = require('./chat/telegram-bridge') as typeof import('./chat/telegram-bridge');
+  clearTelegramSession(chatId);
+  await send(chatId, '✓ Chat session cleared. The next /chat starts fresh.');
+}
+
+async function handleChatStatus(chatId: number) {
+  const { getTelegramSession } = require('./chat/telegram-bridge') as typeof import('./chat/telegram-bridge');
+  const id = getTelegramSession(chatId);
+  if (!id) {
+    await send(chatId, 'No active chat session. /chat <message> creates one.');
+    return;
+  }
+  await send(chatId, `Active session: ${id}\n/chat_new to start fresh`);
+}
+
 async function sendAgentList(chatId: number) {
   try {
     const { listAgents, getDefaultAgentId } = require('./agents');
@@ -1668,6 +1719,24 @@ async function send(chatId: number, text: string): Promise<number | null> {
   }
 }
 
+/** Edit a previously-sent message. Failures (rate-limit, message-not-modified) are swallowed. */
+async function editMessage(chatId: number, messageId: number, text: string): Promise<void> {
+  const settings = loadSettings();
+  if (!settings.telegramBotToken) return;
+  try {
+    await fetch(`https://api.telegram.org/bot${settings.telegramBotToken}/editMessageText`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        chat_id: chatId,
+        message_id: messageId,
+        text,
+        disable_web_page_preview: true,
+      }),
+    });
+  } catch {}
+}
+
 /** Delete a message after a delay (seconds) */
 function deleteMessageLater(chatId: number, messageId: number, delaySec: number = 30) {
   setTimeout(async () => {
@@ -1691,6 +1760,8 @@ async function setBotCommands(token: string) {
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({
         commands: [
+          { command: 'chat', description: '💬 Chat with Forge agent' },
+          { command: 'chat_new', description: 'Start a fresh chat session' },
           { command: 'i', description: '🎯 Inject text into a terminal' },
           { command: 'iclear', description: 'Clear inject target' },
           { command: 'sessions', description: 'Session summary (AI)' },

package/lib/terminal-standalone.ts

@@ -116,12 +116,63 @@ function getDefaultCwd(): string {
   return homedir();
 }
 
+/** Recognize the "system out of pty / process slots" family of errors. */
+function isPtyExhaustedError(e: any): boolean {
+  const msg = e?.stderr?.toString() || e?.message || '';
+  return /posix_spawn|fork failed|EAGAIN|EMFILE|ENFILE|No such file/.test(msg);
+}
+
+/** Aggressive last-resort cleanup when posix_spawn fails: kill every session
+ *  with no live WebSocket client, regardless of whether it's "attached" from
+ *  tmux's POV or appears in saved layout. Saved layout will rebuild lost
+ *  sessions on the next user reconnect. Workspace agent sessions
+ *  (`mw-forge-*`) are still preserved — orchestrator owns those. */
+function reapIdleForPtyRecovery(): number {
+  const all = listTmuxSessions();
+  let killed = 0;
+  for (const s of all) {
+    if (s.name.startsWith(`${SESSION_PREFIX}forge-`)) continue;
+    if ((sessionClients.get(s.name)?.size ?? 0) > 0) continue;
+    if (killTmuxSession(s.name)) {
+      killed++;
+      console.log(`[terminal] PTY-recovery cleanup: killed "${s.name}"`);
+    }
+  }
+  return killed;
+}
+
+/** Run `tmux new-session` with auto-recovery on PTY exhaustion. Used by both
+ *  the random-name and fixed-name create paths so neither leaves the user
+ *  staring at a raw `posix_spawnp failed` error. */
+function tmuxNewSession(name: string, cols: number, rows: number, cwd: string): void {
+  const args = `${TMUX} new-session -d -s ${name} -x ${cols} -y ${rows}`;
+  const env = { ...process.env, TERM: 'xterm-256color' };
+  try {
+    execSync(args, { cwd, env });
+  } catch (e: any) {
+    if (!isPtyExhaustedError(e)) throw e;
+    console.error(`[terminal] PTY exhausted, running recovery cleanup…`);
+    const killed = reapIdleForPtyRecovery();
+    if (killed === 0) {
+      throw new Error('Failed to create terminal session: PTY devices exhausted and no idle sessions to reclaim. Try: sudo sysctl kern.tty.ptmx_max=2048');
+    }
+    try {
+      execSync(args, { cwd, env });
+    } catch (retryErr: any) {
+      if (isPtyExhaustedError(retryErr)) {
+        throw new Error('Failed to create terminal session after cleanup. PTY pool still exhausted — try: sudo sysctl kern.tty.ptmx_max=2048');
+      }
+      throw retryErr;
+    }
+  }
+}
+
 function createTmuxSession(cols: number, rows: number): string {
-  // Auto-cleanup: if too many sessions, kill the oldest idle ones
+  // Preemptive: if too many sessions, kill the oldest idle ones to stay
+  // under the soft cap (separate from PTY-exhaustion recovery).
   const existing = listTmuxSessions();
   if (existing.length >= MAX_SESSIONS) {
     const idle = existing.filter(s => !s.attached);
-    // Kill oldest idle sessions to make room
     const toKill = idle.slice(0, Math.max(1, idle.length - Math.floor(MAX_SESSIONS / 2)));
     for (const s of toKill) {
       console.log(`[terminal] Auto-cleanup: killing idle session "${s.name}"`);
@@ -131,36 +182,7 @@ function createTmuxSession(cols: number, rows: number): string {
 
   const id = Date.now().toString(36) + Math.random().toString(36).slice(2, 6);
   const name = `${SESSION_PREFIX}${id}`;
-  try {
-    execSync(`${TMUX} new-session -d -s ${name} -x ${cols} -y ${rows}`, {
-      cwd: getDefaultCwd(),
-      env: { ...process.env, TERM: 'xterm-256color' },
-    });
-  } catch (e: any) {
-    const msg = e.stderr?.toString() || e.message || '';
-    if (msg.includes('posix_spawn') || msg.includes('fork failed') || msg.includes('No such file')) {
-      // PTY exhausted — aggressive cleanup: kill ALL idle sessions
-      console.error(`[terminal] PTY exhausted, cleaning up all idle sessions...`);
-      const all = listTmuxSessions();
-      for (const s of all) {
-        if (!s.attached) {
-          killTmuxSession(s.name);
-          console.log(`[terminal] Killed idle session: ${s.name}`);
-        }
-      }
-      // Retry once
-      try {
-        execSync(`${TMUX} new-session -d -s ${name} -x ${cols} -y ${rows}`, {
-          cwd: getDefaultCwd(),
-          env: { ...process.env, TERM: 'xterm-256color' },
-        });
-      } catch {
-        throw new Error('Failed to create terminal session. PTY devices exhausted. Run: sudo sysctl kern.tty.ptmx_max=2048');
-      }
-    } else {
-      throw e;
-    }
-  }
+  tmuxNewSession(name, cols, rows, getDefaultCwd());
   // Mouse and scrollback are set in attachToTmux (always called after create)
   return name;
 }
@@ -337,10 +359,10 @@ wss.on('connection', (ws: WebSocket) => {
                 break;
               }
               name = parsed.sessionName;
-              execSync(`${TMUX} new-session -d -s ${name} -x ${cols} -y ${rows}`, {
-                cwd: homedir(),
-                env: { ...process.env, TERM: 'xterm-256color' },
-              });
+              // Goes through the same PTY-exhaustion recovery path as random-name creates,
+              // so workspace-agent reconnects and named-tab creates don't fail with raw
+              // `posix_spawnp failed` after the server has been running for a long time.
+              tmuxNewSession(name, cols, rows, homedir());
               // Mouse and scrollback are set in attachToTmux (always called after create)
             } else {
               name = createTmuxSession(cols, rows);

package/lib/workspace/orchestrator.ts

@@ -2577,6 +2577,7 @@ Silently ingest this context. Do NOT respond — await an actual task.`;
           cliCmd = info.cliCmd || 'claude';
           cliType = info.cliType || 'claude-code';
           supportsSession = info.supportsSession ?? true;
+          if (info.skipPermissionsFlag) skipPermissionsFlag = info.skipPermissionsFlag;
           const agents = listAgents();
           const agentDef = agents.find((a: any) => a.id === config.agentId);
           if (agentDef?.skipPermissionsFlag) skipPermissionsFlag = agentDef.skipPermissionsFlag;

package/middleware.ts

@@ -24,6 +24,16 @@ export function middleware(req: NextRequest) {
     return NextResponse.next();
   }
 
+  // /api/connector-tool — loopback-only, no auth (used by Forge-internal
+  // callers: pipelines via curl, jobs scheduler, CLI). Non-loopback hosts
+  // fall through to the normal token check.
+  if (pathname === '/api/connector-tool') {
+    const host = req.headers.get('host') || '';
+    if (host.startsWith('127.0.0.1:') || host.startsWith('localhost:')) {
+      return NextResponse.next();
+    }
+  }
+
   // Check for NextAuth session cookie (browser login)
   const hasSession =
     req.cookies.has('authjs.session-token') ||

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aion0/forge",
-  "version": "0.6.1",
+  "version": "0.8.0",
   "description": "Unified AI workflow platform — multi-model task orchestration, persistent sessions, web terminal, remote access",
   "type": "module",
   "scripts": {
@@ -24,13 +24,14 @@
     "multi-model",
     "telegram"
   ],
-  "author": "zliu",
+  "author": "",
   "license": "MIT",
   "packageManager": "pnpm@10.32.1",
   "dependencies": {
     "@ai-sdk/anthropic": "^3.0.58",
     "@ai-sdk/google": "^3.0.43",
     "@ai-sdk/openai": "^3.0.41",
+    "@anthropic-ai/sdk": "^0.96.0",
     "@auth/core": "^0.34.3",
     "@modelcontextprotocol/sdk": "^1.28.0",
     "@xterm/addon-fit": "^0.11.0",

package/scripts/bench/README.md

@@ -13,7 +13,7 @@ Compares a single Claude Code run against a Forge multi-smith workspace on the s
 
 1. **Forge running**: `forge server start` (listening on port 8403)
 2. **Claude Code installed** and authenticated (`claude --version` works)
-3. **harness_test project** exists at `/Users/zliu/IdeaProjects/harness_test`
+3. **harness_test project** exists at `~/Projects/sandbox`
 
 ## Run
 

package/scripts/bench/tasks/01-text-utils/validator.sh

@@ -3,7 +3,7 @@
 # Runs in harness_test project root. Exits 0 = pass, non-zero = fail.
 set -e
 
-PROJECT_ROOT="${1:-/Users/zliu/IdeaProjects/harness_test}"
+PROJECT_ROOT="${1:-~/Projects/sandbox}"
 cd "$PROJECT_ROOT/src" || { echo "FAIL: src/ directory not found"; exit 1; }
 
 # 1. Check files exist

package/scripts/bench/tasks/02-pagination/setup.sh

@@ -1,7 +1,7 @@
 #!/usr/bin/env bash
 # Create a basic user list module without pagination.
 set -e
-PROJECT="${1:-/Users/zliu/IdeaProjects/harness_test}"
+PROJECT="${1:-~/Projects/sandbox}"
 mkdir -p "$PROJECT/src/api"
 
 cat > "$PROJECT/src/api/users.js" <<'EOF'

package/scripts/bench/tasks/02-pagination/validator.sh

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 set -e
-PROJECT="${1:-/Users/zliu/IdeaProjects/harness_test}"
+PROJECT="${1:-~/Projects/sandbox}"
 cd "$PROJECT/src"
 
 [ -f api/users.js ] || { echo "FAIL: api/users.js missing"; exit 1; }

package/scripts/bench/tasks/03-bug-fix/setup.sh

@@ -1,7 +1,7 @@
 #!/usr/bin/env bash
 # Create a date range calculator with 2 bugs.
 set -e
-PROJECT="${1:-/Users/zliu/IdeaProjects/harness_test}"
+PROJECT="${1:-~/Projects/sandbox}"
 mkdir -p "$PROJECT/src/lib" "$PROJECT/src/lib/__tests__"
 
 cat > "$PROJECT/src/lib/dateRange.js" <<'EOF'

package/scripts/bench/tasks/03-bug-fix/validator.sh

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 set -e
-PROJECT="${1:-/Users/zliu/IdeaProjects/harness_test}"
+PROJECT="${1:-~/Projects/sandbox}"
 cd "$PROJECT/src"
 
 [ -f lib/dateRange.js ] || { echo "FAIL: lib/dateRange.js missing (agent deleted it?)"; exit 1; }

package/src/core/db/database.ts

@@ -41,20 +41,29 @@ function initSchema(db: Database.Database) {
   try { db.exec("SELECT day FROM token_usage LIMIT 1"); } catch { try { db.exec("DROP TABLE IF EXISTS token_usage"); db.exec("DROP TABLE IF EXISTS usage_scan_state"); } catch {} }
   // Unique index for dedup (only applies when dedup_key is NOT NULL)
   try { db.exec('CREATE UNIQUE INDEX IF NOT EXISTS idx_pipeline_runs_dedup ON pipeline_runs(project_path, workflow_name, dedup_key)'); } catch {}
-  // Migrate old issue_autofix_processed → pipeline_runs
+  // One-shot migration of old issue_autofix_processed → pipeline_runs.
+  // Previously this ran every startup (reading + re-inserting all rows on
+  // every cold worker boot — visible as `[db] Migrated N records …`).
+  // Now: skip entirely if the source table has zero rows OR if any rows
+  // have already been migrated (presence of issue: dedup keys is the
+  // tell — INSERT OR IGNORE already protects against dups, the loop
+  // itself was just wasted work).
   try {
-    const old = db.prepare('SELECT * FROM issue_autofix_processed').all() as any[];
-    if (old.length > 0) {
-      const ins = db.prepare('INSERT OR IGNORE INTO pipeline_runs (id, project_path, workflow_name, pipeline_id, status, dedup_key, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)');
-      for (const r of old) {
-        ins.run(
-          r.pipeline_id?.slice(0, 8) || ('mig-' + r.issue_number),
-          r.project_path, 'issue-fix-and-review', r.pipeline_id || '',
-          r.status === 'processing' ? 'running' : (r.status || 'done'),
-          `issue:${r.issue_number}`, r.created_at || new Date().toISOString()
-        );
+    const alreadyMigrated = db.prepare("SELECT 1 FROM pipeline_runs WHERE dedup_key LIKE 'issue:%' LIMIT 1").get();
+    if (!alreadyMigrated) {
+      const old = db.prepare('SELECT * FROM issue_autofix_processed').all() as any[];
+      if (old.length > 0) {
+        const ins = db.prepare('INSERT OR IGNORE INTO pipeline_runs (id, project_path, workflow_name, pipeline_id, status, dedup_key, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)');
+        for (const r of old) {
+          ins.run(
+            r.pipeline_id?.slice(0, 8) || ('mig-' + r.issue_number),
+            r.project_path, 'issue-fix-and-review', r.pipeline_id || '',
+            r.status === 'processing' ? 'running' : (r.status || 'done'),
+            `issue:${r.issue_number}`, r.created_at || new Date().toISOString()
+          );
+        }
+        console.log(`[db] Migrated ${old.length} issue_autofix_processed records to pipeline_runs (one-shot)`);
       }
-      console.log(`[db] Migrated ${old.length} issue_autofix_processed records to pipeline_runs`);
     }
   } catch {}