@aion0/forge 0.6.3 → 0.8.1

package/app/api/monitor/route.ts

@@ -22,8 +22,25 @@ export async function GET() {
   const terminal = countProcess('terminal-standalone');
   const telegram = countProcess('telegram-standalone');
   const workspace = countProcess('workspace-standalone');
+  const chat = countProcess('chat-standalone');
+  const browserBridge = countProcess('browser-bridge-standalone');
   const tunnel = countProcess('cloudflared tunnel');
 
+  // Chat backend health (port 8408 — process can be alive but crashed)
+  let chatStatus: { running: boolean; sessions: number; port: number } = {
+    running: false,
+    sessions: 0,
+    port: Number(process.env.CHAT_PORT) || 8408,
+  };
+  try {
+    const chatRes = run(`curl -s http://127.0.0.1:${chatStatus.port}/api/status 2>/dev/null`);
+    if (chatRes) {
+      const data = JSON.parse(chatRes);
+      chatStatus.running = true;
+      chatStatus.sessions = data.active_sse_sessions ?? 0;
+    }
+  } catch {}
+
   // MCP Server (runs inside workspace process, check /health endpoint)
   let mcpStatus = { running: false, sessions: 0 };
   try {
@@ -65,6 +82,15 @@ export async function GET() {
       terminal: { running: terminal.count > 0, pid: terminal.pid, startedAt: terminal.startedAt },
       telegram: { running: telegram.count > 0, pid: telegram.pid, startedAt: telegram.startedAt },
       workspace: { running: workspace.count > 0, pid: workspace.pid, startedAt: workspace.startedAt },
+      browserBridge: { running: browserBridge.count > 0, pid: browserBridge.pid, startedAt: browserBridge.startedAt },
+      chat: {
+        running: chatStatus.running,
+        pid: chat.pid,
+        startedAt: chat.startedAt,
+        port: chatStatus.port,
+        sessions: chatStatus.sessions,
+        processAlive: chat.count > 0,
+      },
       tunnel: { running: tunnel.count > 0, pid: tunnel.pid, url: tunnelUrl, startedAt: tunnel.startedAt },
       mcp: { running: mcpStatus.running, port: 8406, sessions: mcpStatus.sessions },
     },

package/app/api/notify/test/route.ts

@@ -9,25 +9,57 @@ export async function POST() {
     return NextResponse.json({ ok: false, error: 'Telegram bot token or chat ID not configured' });
   }
 
+  // telegramChatId may be a comma-separated whitelist. The test message
+  // goes to the FIRST id so a misconfigured later id doesn't fail the test.
+  const firstChatId = telegramChatId.split(',').map((s) => s.trim()).filter(Boolean)[0];
+  if (!firstChatId) {
+    return NextResponse.json({ ok: false, error: 'telegramChatId is empty / malformed' });
+  }
+
   try {
     const url = `https://api.telegram.org/bot${telegramBotToken}/sendMessage`;
+    // Plain text — no parse_mode — so an em-dash / asterisk / underscore
+    // can never trip Telegram's Markdown parser ("can't parse entities").
     const res = await fetch(url, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({
-        chat_id: telegramChatId,
-        text: '✅ *Forge* — Test notification!\n\nTelegram notifications are working.',
-        parse_mode: 'Markdown',
+        chat_id: firstChatId,
+        text: '✅ Forge — Test notification! Telegram notifications are working.',
       }),
     });
 
+    const body = await res.text();
     if (!res.ok) {
-      const body = await res.text();
-      return NextResponse.json({ ok: false, error: body });
+      // Surface Telegram's "description" — covers the common cases like
+      // "chat not found", "Unauthorized" (token revoked), "bot was blocked".
+      try {
+        const j = JSON.parse(body);
+        return NextResponse.json({ ok: false, error: `${res.status} ${j.description || body}` });
+      } catch {
+        return NextResponse.json({ ok: false, error: `${res.status} ${body}` });
+      }
     }
-
     return NextResponse.json({ ok: true });
   } catch (err: any) {
-    return NextResponse.json({ ok: false, error: err.message });
+    // 'fetch failed' from Node is opaque — almost always corp SSL inspection
+    // (Zscaler / corporate firewall) or proxy / DNS / network. Surface
+    // concrete remediation in the alert so the user doesn't have to guess.
+    const msg = String(err?.message || err);
+    if (/fetch failed|ENOTFOUND|ECONNREFUSED|ETIMEDOUT|UNABLE_TO_VERIFY|self.signed/i.test(msg)) {
+      const cause = err?.cause?.code || err?.cause?.message || '';
+      return NextResponse.json({
+        ok: false,
+        error: [
+          `${msg}${cause ? ' (cause: ' + cause + ')' : ''}`,
+          '',
+          'Forge could not reach api.telegram.org. Common causes:',
+          '  • Corporate TLS inspection — set NODE_EXTRA_CA_CERTS=/path/to/corp-ca.pem then `forge server restart`',
+          '  • HTTP proxy required — set HTTPS_PROXY=http://proxy.corp:port then restart',
+          '  • Network / DNS — curl -v https://api.telegram.org/bot<TOKEN>/getMe',
+        ].join('\n'),
+      });
+    }
+    return NextResponse.json({ ok: false, error: msg });
   }
 }

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

@@ -1,5 +1,5 @@
 import { NextResponse } from 'next/server';
-import { getPipeline, cancelPipeline, deletePipeline, injectConversationMessage } from '@/lib/pipeline';
+import { getPipeline, cancelPipeline, deletePipeline, injectConversationMessage, retryNode } from '@/lib/pipeline';
 
 // GET /api/pipelines/:id
 export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
@@ -25,6 +25,15 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
     return NextResponse.json({ ok });
   }
 
+  // Retry a single failed node — see lib/pipeline.ts retryNode for semantics.
+  if (action === 'retry-node') {
+    const { nodeId } = body;
+    if (!nodeId) return NextResponse.json({ error: 'nodeId required' }, { status: 400 });
+    const result = await retryNode(id, String(nodeId));
+    if (!result.ok) return NextResponse.json({ error: result.error }, { status: 400 });
+    return NextResponse.json({ ok: true });
+  }
+
   // Inject a message into a running conversation
   if (action === 'inject') {
     const { agentId, message } = body;

package/app/api/pipelines/route.ts

@@ -1,5 +1,5 @@
 import { NextResponse } from 'next/server';
-import { listPipelines, listWorkflows, startPipeline } from '@/lib/pipeline';
+import { listPipelines, listPipelinesSummary, listWorkflows, startPipeline } from '@/lib/pipeline';
 import { writeFileSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
 import YAML from 'yaml';
@@ -40,7 +40,21 @@ export async function GET(req: Request) {
     }
   }
 
-  return NextResponse.json(listPipelines().sort((a, b) => b.createdAt.localeCompare(a.createdAt)));
+  // Light summary by default — strips heavy node outputs / conversation
+  // bodies that the list UI doesn't render. Default limit 100 newest.
+  // Callers can opt into:
+  //   ?full=1         — full Pipeline objects (rare; per-id endpoint is cheaper)
+  //   ?limit=500      — more rows (server caps at 500)
+  //   ?workflow=<name>— scope to one workflow (combine with high limit)
+  //   ?before=<iso>   — cursor for "Load more"
+  const wantFull = searchParams.get('full') === '1';
+  if (wantFull) {
+    return NextResponse.json(listPipelines().sort((a, b) => b.createdAt.localeCompare(a.createdAt)));
+  }
+  const limit = Number(searchParams.get('limit')) || undefined;
+  const workflow = searchParams.get('workflow') || undefined;
+  const before = searchParams.get('before') || undefined;
+  return NextResponse.json(listPipelinesSummary({ limit, workflow, before }));
 }
 
 // POST /api/pipelines — start a pipeline or save a workflow

package/app/api/plugins/route.ts

@@ -1,7 +1,36 @@
 import { NextResponse } from 'next/server';
-import { listPlugins, getPlugin, installPlugin, uninstallPlugin, updatePluginConfig, listInstalledPlugins, getInstalledPlugin } from '@/lib/plugins/registry';
+import { listPlugins, getPlugin, installPlugin, uninstallPlugin, updatePluginConfig, listInstalledPlugins, getInstalledPlugin, getSecretFieldNames } from '@/lib/plugins/registry';
 import { executePluginAction } from '@/lib/plugins/executor';
 
+const SECRET_MASK = '••••••••';
+
+function maskInstalledConfig<T extends { definition?: any; config?: Record<string, any> } | null | undefined>(inst: T): T {
+  if (!inst || !inst.config) return inst;
+  const secrets = getSecretFieldNames(inst.definition || null);
+  if (!secrets.length) return inst;
+  const masked = { ...inst.config };
+  for (const k of secrets) {
+    if (typeof masked[k] === 'string' && masked[k]) masked[k] = SECRET_MASK;
+  }
+  return { ...inst, config: masked } as T;
+}
+
+function restoreInstalledConfig(id: string, incoming: Record<string, any>): Record<string, any> {
+  const existing = getInstalledPlugin(id);
+  if (!existing) return incoming;
+  const secrets = getSecretFieldNames(existing.definition);
+  if (!secrets.length) return incoming;
+  const out = { ...incoming };
+  for (const k of secrets) {
+    if (out[k] === SECRET_MASK) {
+      const prev = existing.config?.[k];
+      if (typeof prev === 'string') out[k] = prev;
+      else delete out[k];
+    }
+  }
+  return out;
+}
+
 // GET: list plugins or get plugin details
 export async function GET(req: Request) {
   const url = new URL(req.url);
@@ -13,17 +42,18 @@ export async function GET(req: Request) {
     const plugin = getPlugin(id);
     const inst = getInstalledPlugin(id);
     if (!plugin && !inst) return NextResponse.json({ error: 'Plugin not found' }, { status: 404 });
+    const masked = maskInstalledConfig(inst);
     return NextResponse.json({
-      plugin: inst?.definition || plugin,
+      plugin: masked?.definition || plugin,
       installed: !!inst,
-      config: inst?.config,
-      instanceName: inst?.instanceName,
-      source: inst?.source,
+      config: masked?.config,
+      instanceName: masked?.instanceName,
+      source: masked?.source,
     });
   }
 
   if (installed === 'true') {
-    return NextResponse.json({ plugins: listInstalledPlugins() });
+    return NextResponse.json({ plugins: listInstalledPlugins().map(p => maskInstalledConfig(p)) });
   }
 
   return NextResponse.json({ plugins: listPlugins() });
@@ -37,7 +67,8 @@ export async function POST(req: Request) {
   switch (action) {
     case 'install': {
       if (!id) return NextResponse.json({ error: 'id required' }, { status: 400 });
-      const ok = installPlugin(id, config || {}, body.source ? { source: body.source, name: body.name } : undefined);
+      const merged = restoreInstalledConfig(id, config || {});
+      const ok = installPlugin(id, merged, body.source ? { source: body.source, name: body.name } : undefined);
       return NextResponse.json({ ok });
     }
     case 'create_instance': {
@@ -59,7 +90,8 @@ export async function POST(req: Request) {
     }
     case 'update_config': {
       if (!id || !config) return NextResponse.json({ error: 'id and config required' }, { status: 400 });
-      const ok = updatePluginConfig(id, config);
+      const merged = restoreInstalledConfig(id, config);
+      const ok = updatePluginConfig(id, merged);
       return NextResponse.json({ ok });
     }
     case 'test': {

package/app/api/project-sessions/route.ts

@@ -1,6 +1,7 @@
 import { NextResponse } from 'next/server';
 import { getFixedSession, setFixedSession, clearFixedSession, getAllFixedSessions } from '@/lib/project-sessions';
-import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { loadSettings } from '@/lib/settings';
+import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 
 // GET: get fixed session for a project, or all bindings
@@ -35,27 +36,66 @@ export async function POST(req: Request) {
   return NextResponse.json({ ok: true, projectPath, fixedSessionId });
 }
 
-/** Generate .forge/mcp.json in the project directory with workspace context baked in */
+/**
+ * Generate the project's MCP config. Two locations:
+ *   1. <project>/.forge/mcp.json  — Forge-internal copy, referenced by workspace
+ *      orchestrator's --mcp-config flag when it launches agent terminals.
+ *   2. <project>/.mcp.json        — picked up automatically by `claude` (and
+ *      most other Claude Code-compatible CLIs) when launched at the project
+ *      root, so users get Forge MCP tools without needing --mcp-config.
+ * Both files have identical content; (1) is authoritative — (2) is a mirror
+ * that's only written if it doesn't already exist OR is also a Forge-managed
+ * copy (to avoid stomping a user's hand-rolled .mcp.json).
+ */
 function ensureMcpConfig(projectPath: string): void {
   try {
     const forgeDir = join(projectPath, '.forge');
-    const configPath = join(forgeDir, 'mcp.json');
+    const forgeConfigPath = join(forgeDir, 'mcp.json');
+    const rootConfigPath = join(projectPath, '.mcp.json');
     const mcpPort = Number(process.env.MCP_PORT) || 8406;
 
-    // Resolve workspace + primary agent for this project
     let wsParam = '';
     try {
       const { findWorkspaceByProject } = require('@/lib/workspace');
       const ws = findWorkspaceByProject(projectPath);
-      if (ws) {
-        wsParam = `?workspaceId=${ws.id}`;
-      }
+      if (ws) wsParam = `?workspaceId=${ws.id}`;
     } catch {}
 
-    const config = { mcpServers: { forge: { type: 'sse', url: `http://localhost:${mcpPort}/sse${wsParam}` } } };
+    // Built-in Forge MCP server (agent bus, workspace ops)
+    const forgeEntry = { type: 'sse', url: `http://localhost:${mcpPort}/sse${wsParam}` };
+
+    // User-managed external MCP servers — chrome-devtools-mcp etc.
+    let userServers: Record<string, any> = {};
+    try {
+      const settings = loadSettings();
+      userServers = settings.mcpServers || {};
+    } catch {}
+
+    // Forge owns the `forge` key; users can shadow other keys here.
+    const config = {
+      mcpServers: { forge: forgeEntry, ...userServers },
+    };
+    const serialized = JSON.stringify(config, null, 2);
+    const forgeManagedKeys = new Set(Object.keys(config.mcpServers));
 
-    // Always rewrite (workspace context may have changed)
     mkdirSync(forgeDir, { recursive: true });
-    writeFileSync(configPath, JSON.stringify(config, null, 2));
+    writeFileSync(forgeConfigPath, serialized);
+
+    // Mirror to root .mcp.json so plain `claude` in the project picks up
+    // Forge's MCP servers. Two policies:
+    //   - Don't CREATE the root file. Users who delete it want it gone;
+    //     auto-recreating broke that expectation (and pulled global
+    //     mcp servers into pipeline worktrees where they don't belong).
+    //   - DO update an existing root file IF every server in it is one
+    //     we manage — keeps the convenience for users who chose to have it,
+    //     without stomping a hand-rolled one.
+    if (existsSync(rootConfigPath)) {
+      try {
+        const existing = JSON.parse(readFileSync(rootConfigPath, 'utf8'));
+        const existingKeys = Object.keys(existing?.mcpServers ?? {});
+        const allForgeManaged = existingKeys.length > 0 && existingKeys.every(k => forgeManagedKeys.has(k));
+        if (allForgeManaged) writeFileSync(rootConfigPath, serialized);
+      } catch { /* malformed user file — leave alone */ }
+    }
   } catch {}
 }

package/app/api/settings/route.ts

@@ -53,6 +53,19 @@ export async function PUT(req: Request) {
     }
   }
 
+  // Nested agent profile apiKeys are masked by loadSettingsMasked too —
+  // restore them here so a normal settings save doesn't overwrite a real
+  // key with '••••••••'. Empty string means user explicitly cleared it.
+  if (updated.agents) {
+    for (const [id, a] of Object.entries(updated.agents)) {
+      const newKey = (a as any)?.apiKey;
+      if (newKey === '••••••••') {
+        const existing = settings.agents?.[id]?.apiKey;
+        if (existing) (a as any).apiKey = existing;
+      }
+    }
+  }
+
   // Remove internal fields
   delete (updated as any)._secretStatus;