@aion0/forge 0.5.20 → 0.5.22

package/lib/plugins/registry.ts

@@ -0,0 +1,228 @@
+/**
+ * Plugin Registry — load, install, uninstall, list plugins.
+ *
+ * Plugins are stored as YAML files:
+ * - Built-in: lib/builtin-plugins/*.yaml
+ * - User-installed: ~/.forge/plugins/<id>/plugin.yaml
+ *
+ * Installed plugin configs are stored in:
+ * - ~/.forge/data/plugin-configs.json
+ */
+
+import { existsSync, readdirSync, readFileSync, writeFileSync, mkdirSync, rmSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { homedir } from 'node:os';
+import { fileURLToPath } from 'node:url';
+import YAML from 'yaml';
+import type { PluginDefinition, InstalledPlugin, PluginSource } from './types';
+
+const _filename = typeof __filename !== 'undefined' ? __filename : fileURLToPath(import.meta.url);
+const _dirname = typeof __dirname !== 'undefined' ? __dirname : dirname(_filename);
+
+const BUILTIN_DIR_COMPILED = join(_dirname, '..', 'builtin-plugins');
+const BUILTIN_DIR_SOURCE = join(process.cwd(), 'lib', 'builtin-plugins');
+const BUILTIN_DIR = existsSync(BUILTIN_DIR_COMPILED) ? BUILTIN_DIR_COMPILED : BUILTIN_DIR_SOURCE;
+const USER_PLUGINS_DIR = join(homedir(), '.forge', 'plugins');
+const CONFIGS_FILE = join(homedir(), '.forge', 'data', 'plugin-configs.json');
+
+// ─── Load Plugin Definition ──────────────────────────────
+
+function loadPluginYaml(filePath: string): PluginDefinition | null {
+  try {
+    const raw = readFileSync(filePath, 'utf-8');
+    const def = YAML.parse(raw) as PluginDefinition;
+    if (!def.id || !def.name || !def.actions) return null;
+    // Defaults
+    if (!def.config) def.config = {};
+    if (!def.params) def.params = {};
+    if (!def.icon) def.icon = '🔌';
+    if (!def.version) def.version = '0.0.1';
+    return def;
+  } catch {
+    return null;
+  }
+}
+
+// ─── Config Storage ──────────────────────────────────────
+
+function loadConfigs(): Record<string, { config: Record<string, any>; installedAt: string; enabled: boolean }> {
+  try {
+    if (existsSync(CONFIGS_FILE)) {
+      return JSON.parse(readFileSync(CONFIGS_FILE, 'utf-8'));
+    }
+  } catch {}
+  return {};
+}
+
+function saveConfigs(configs: Record<string, any>): void {
+  const dir = dirname(CONFIGS_FILE);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(CONFIGS_FILE, JSON.stringify(configs, null, 2));
+}
+
+// ─── Public API ──────────────────────────────────────────
+
+/** List all available plugins (built-in + user-installed) */
+export function listPlugins(): PluginSource[] {
+  const sources: PluginSource[] = [];
+  const configs = loadConfigs();
+
+  // Check if any config entry references this plugin (base install or instance)
+  const isInstalledOrHasInstance = (id: string) =>
+    Object.entries(configs).some(([key, cfg]) => key === id || (cfg as any).source === id);
+
+  // Built-in plugins
+  if (existsSync(BUILTIN_DIR)) {
+    for (const file of readdirSync(BUILTIN_DIR).filter(f => f.endsWith('.yaml') || f.endsWith('.yml'))) {
+      const def = loadPluginYaml(join(BUILTIN_DIR, file));
+      if (def) {
+        sources.push({
+          id: def.id,
+          name: def.name,
+          icon: def.icon,
+          version: def.version,
+          author: def.author || 'forge',
+          description: def.description || '',
+          source: 'builtin',
+          installed: isInstalledOrHasInstance(def.id),
+          configCount: Object.keys(def.config).length,
+        });
+      }
+    }
+  }
+
+  // User-installed plugins
+  mkdirSync(USER_PLUGINS_DIR, { recursive: true });
+  for (const dir of readdirSync(USER_PLUGINS_DIR, { withFileTypes: true })) {
+    if (!dir.isDirectory()) continue;
+    const yamlPath = join(USER_PLUGINS_DIR, dir.name, 'plugin.yaml');
+    const ymlPath = join(USER_PLUGINS_DIR, dir.name, 'plugin.yml');
+    const filePath = existsSync(yamlPath) ? yamlPath : existsSync(ymlPath) ? ymlPath : null;
+    if (!filePath) continue;
+    const def = loadPluginYaml(filePath);
+    if (def) {
+      // Don't duplicate if also built-in
+      if (sources.some(s => s.id === def.id)) continue;
+      sources.push({
+        id: def.id,
+        name: def.name,
+        icon: def.icon,
+        version: def.version,
+        author: def.author || 'local',
+        description: def.description || '',
+        source: 'local',
+        installed: isInstalledOrHasInstance(def.id),
+        configCount: Object.keys(def.config).length,
+      });
+    }
+  }
+
+  return sources;
+}
+
+/** Get a plugin definition by ID */
+export function getPlugin(id: string): PluginDefinition | null {
+  // Check built-in first
+  if (existsSync(BUILTIN_DIR)) {
+    for (const file of readdirSync(BUILTIN_DIR).filter(f => f.endsWith('.yaml') || f.endsWith('.yml'))) {
+      const def = loadPluginYaml(join(BUILTIN_DIR, file));
+      if (def?.id === id) return def;
+    }
+  }
+
+  // Check user plugins
+  const yamlPath = join(USER_PLUGINS_DIR, id, 'plugin.yaml');
+  const ymlPath = join(USER_PLUGINS_DIR, id, 'plugin.yml');
+  if (existsSync(yamlPath)) return loadPluginYaml(yamlPath);
+  if (existsSync(ymlPath)) return loadPluginYaml(ymlPath);
+
+  return null;
+}
+
+/** Get an installed plugin with its config */
+export function getInstalledPlugin(id: string): InstalledPlugin | null {
+  const configs = loadConfigs();
+  const cfg = configs[id] as any;
+  if (!cfg) return null;
+  // Resolve definition: use source field for instances, fallback to id
+  const sourceId = cfg.source || id;
+  const def = getPlugin(sourceId);
+  if (!def) return null;
+  return {
+    id,
+    definition: def,
+    config: cfg.config || {},
+    installedAt: cfg.installedAt || new Date().toISOString(),
+    enabled: cfg.enabled !== false,
+    instanceName: cfg.name,
+    source: sourceId !== id ? sourceId : undefined,
+  };
+}
+
+/** List all installed plugins (including instances) */
+export function listInstalledPlugins(): InstalledPlugin[] {
+  const configs = loadConfigs();
+  const installed: InstalledPlugin[] = [];
+  for (const [id, cfg] of Object.entries(configs)) {
+    const sourceId = (cfg as any).source || id;
+    const def = getPlugin(sourceId);
+    if (def) {
+      installed.push({
+        id,
+        definition: def,
+        config: (cfg as any).config || {},
+        installedAt: (cfg as any).installedAt || '',
+        enabled: (cfg as any).enabled !== false,
+        instanceName: (cfg as any).name,
+        source: sourceId !== id ? sourceId : undefined,
+      });
+    }
+  }
+  return installed;
+}
+
+/** Install a plugin or create an instance */
+export function installPlugin(id: string, config: Record<string, any>, opts?: { source?: string; name?: string }): boolean {
+  const sourceId = opts?.source || id;
+  const def = getPlugin(sourceId);
+  if (!def) return false;
+  const configs = loadConfigs();
+  configs[id] = {
+    config,
+    installedAt: new Date().toISOString(),
+    enabled: true,
+    ...(opts?.source ? { source: opts.source } : {}),
+    ...(opts?.name ? { name: opts.name } : {}),
+  };
+  saveConfigs(configs);
+  console.log(`[plugins] Installed: ${opts?.name || def.name} (${id}${opts?.source ? ' ← ' + opts.source : ''})`);
+  return true;
+}
+
+/** Uninstall a plugin or instance */
+export function uninstallPlugin(id: string): boolean {
+  const configs = loadConfigs();
+  if (!configs[id]) return false;
+  delete configs[id];
+  saveConfigs(configs);
+  console.log(`[plugins] Uninstalled: ${id}`);
+  return true;
+}
+
+/** Update plugin config */
+export function updatePluginConfig(id: string, config: Record<string, any>): boolean {
+  const configs = loadConfigs();
+  if (!configs[id]) return false;
+  (configs[id] as any).config = config;
+  saveConfigs(configs);
+  return true;
+}
+
+/** Enable/disable a plugin */
+export function setPluginEnabled(id: string, enabled: boolean): boolean {
+  const configs = loadConfigs();
+  if (!configs[id]) return false;
+  (configs[id] as any).enabled = enabled;
+  saveConfigs(configs);
+  return true;
+}

package/lib/plugins/types.ts

@@ -0,0 +1,103 @@
+/**
+ * Plugin Types — defines the plugin system for pipeline node extensions.
+ *
+ * A plugin is a reusable, configurable capability that can be used as a
+ * pipeline node. Plugins are declarative YAML files with config schema,
+ * params schema, and actions.
+ */
+
+/** Plugin action execution type */
+export type PluginActionType = 'http' | 'poll' | 'shell' | 'script';
+
+/** Schema field definition for config/params */
+export interface PluginFieldSchema {
+  type: 'string' | 'number' | 'boolean' | 'secret' | 'json' | 'select';
+  label?: string;
+  description?: string;
+  required?: boolean;
+  default?: any;
+  options?: string[];  // for select type
+}
+
+/** A single action a plugin can perform */
+export interface PluginAction {
+  /** Execution type */
+  run: PluginActionType;
+
+  // HTTP action fields
+  method?: string;            // GET, POST, PUT, DELETE
+  url?: string;               // URL template (supports {{config.x}}, {{params.x}})
+  headers?: Record<string, string>;
+  body?: string;              // body template
+
+  // Poll action fields (extends HTTP)
+  interval?: number;          // poll interval in seconds
+  until?: string;             // JSONPath condition: "$.result != null"
+  timeout?: number;           // max wait in seconds
+
+  // Shell action fields
+  command?: string;           // shell command template
+  cwd?: string;               // working directory
+
+  // Script action fields
+  script?: string;            // path to JS/Python script
+  runtime?: 'node' | 'python';
+
+  // Output extraction
+  output?: Record<string, string>;  // { fieldName: "$.json.path" or "$body" or "$stdout" }
+}
+
+/** Plugin definition (loaded from plugin.yaml) */
+export interface PluginDefinition {
+  id: string;
+  name: string;
+  icon: string;
+  version: string;
+  author?: string;
+  description?: string;
+
+  /** Global config — set once when installing the plugin */
+  config: Record<string, PluginFieldSchema>;
+
+  /** Per-use params — set each time the plugin is used in a pipeline node */
+  params: Record<string, PluginFieldSchema>;
+
+  /** Named actions this plugin can perform */
+  actions: Record<string, PluginAction>;
+
+  /** Default action to run if none specified */
+  defaultAction?: string;
+}
+
+/** Installed plugin instance (definition + user config values) */
+export interface InstalledPlugin {
+  id: string;                   // instance ID (e.g., 'jenkins-backend')
+  definition: PluginDefinition;
+  config: Record<string, any>;  // user-provided config values
+  installedAt: string;
+  enabled: boolean;
+  instanceName?: string;        // display name (e.g., 'Jenkins Backend')
+  source?: string;              // source plugin ID if this is an instance (e.g., 'jenkins')
+}
+
+/** Result of executing a plugin action */
+export interface PluginActionResult {
+  ok: boolean;
+  output: Record<string, any>;
+  rawResponse?: string;
+  error?: string;
+  duration?: number;
+}
+
+/** Plugin source for marketplace */
+export interface PluginSource {
+  id: string;
+  name: string;
+  icon: string;
+  version: string;
+  author: string;
+  description: string;
+  source: 'builtin' | 'local' | 'registry';
+  installed: boolean;
+  configCount: number;  // number of config fields — 0 means no config needed
+}

package/lib/project-sessions.ts

@@ -13,13 +13,18 @@ function getFilePath(): string {
   return join(dir, 'project-sessions.json');
 }
 
+let cache: Record<string, string> | null = null;
+
 function loadAll(): Record<string, string> {
+  if (cache !== null) return cache;
   const fp = getFilePath();
-  if (!existsSync(fp)) return {};
-  try { return JSON.parse(readFileSync(fp, 'utf-8')); } catch { return {}; }
+  if (!existsSync(fp)) { cache = {}; return cache; }
+  try { cache = JSON.parse(readFileSync(fp, 'utf-8')) as Record<string, string>; } catch { cache = {}; }
+  return cache;
 }
 
 function saveAll(data: Record<string, string>): void {
+  cache = data;
   writeFileSync(getFilePath(), JSON.stringify(data, null, 2));
 }
 

package/lib/session-utils.ts

@@ -40,10 +40,14 @@ export function buildResumeFlag(fixedSessionId: string | null, hasExistingSessio
   return '';
 }
 
-/** Get --mcp-config flag for claude-code. Triggers server-side mcp.json creation. */
+const _mcpReady = new Set<string>();
+
+/** Get --mcp-config flag for claude-code. Triggers server-side mcp.json creation (once per projectPath). */
 export async function getMcpFlag(projectPath: string): Promise<string> {
-  // Ensure .forge/mcp.json exists (server generates it)
-  await fetch(`/api/project-sessions?projectPath=${encodeURIComponent(projectPath)}`).catch(() => {});
+  if (!_mcpReady.has(projectPath)) {
+    await fetch(`/api/project-sessions?projectPath=${encodeURIComponent(projectPath)}`).catch(() => {});
+    _mcpReady.add(projectPath);
+  }
   return ` --mcp-config "${projectPath}/.forge/mcp.json"`;
 }
 

package/lib/terminal-standalone.ts

@@ -64,24 +64,6 @@ function saveTerminalState(data: unknown): void {
   }
 }
 
-/** Get session names that have custom labels (user-renamed) */
-function getRenamedSessions(): Set<string> {
-  try {
-    const state = loadTerminalState() as any;
-    if (!state?.sessionLabels) return new Set();
-    // sessionLabels: { "mw-xxx": "My Custom Name", ... }
-    // A session is "renamed" if its label differs from default patterns
-    const renamed = new Set<string>();
-    for (const [sessionName, label] of Object.entries(state.sessionLabels)) {
-      if (label && typeof label === 'string') {
-        renamed.add(sessionName);
-      }
-    }
-    return renamed;
-  } catch {
-    return new Set();
-  }
-}
 
 // ─── tmux helpers ──────────────────────────────────────────────
 
@@ -179,11 +161,7 @@ function createTmuxSession(cols: number, rows: number): string {
       throw e;
     }
   }
-  // Enable mouse scrolling and set large scrollback buffer
-  try {
-    execSync(`${TMUX} set-option -t ${name} mouse on 2>/dev/null`);
-    execSync(`${TMUX} set-option -t ${name} history-limit 50000 2>/dev/null`);
-  } catch {}
+  // Mouse and scrollback are set in attachToTmux (always called after create)
   return name;
 }
 
@@ -211,8 +189,6 @@ function tmuxSessionExists(name: string): boolean {
 /** Map from tmux session name → Set of WebSocket clients attached to it */
 const sessionClients = new Map<string, Set<WebSocket>>();
 
-/** Map from WebSocket → timestamp when the session was *created* (not attached) by this client */
-const createdAt = new Map<WebSocket, { session: string; time: number }>();
 
 function trackAttach(ws: WebSocket, sessionName: string) {
   if (!sessionClients.has(sessionName)) sessionClients.set(sessionName, new Set());
@@ -232,9 +208,11 @@ function cleanupOrphanedSessions() {
   const sessions = listTmuxSessions();
   for (const s of sessions) {
     if (s.attached) continue;
+    if (s.name.startsWith(`${SESSION_PREFIX}forge-`)) continue; // workspace agent session — managed by orchestrator
     if (knownSessions.has(s.name)) continue; // saved in terminal state — preserve
     const clients = sessionClients.get(s.name)?.size ?? 0;
     if (clients === 0) {
+      console.log(`[terminal] Orphan cleanup: killing "${s.name}"`);
       killTmuxSession(s.name);
     }
   }
@@ -362,14 +340,10 @@ wss.on('connection', (ws: WebSocket) => {
                 cwd: homedir(),
                 env: { ...process.env, TERM: 'xterm-256color' },
               });
-              try {
-                execSync(`${TMUX} set-option -t ${name} mouse on 2>/dev/null`);
-                execSync(`${TMUX} set-option -t ${name} history-limit 50000 2>/dev/null`);
-              } catch {}
+              // Mouse and scrollback are set in attachToTmux (always called after create)
             } else {
               name = createTmuxSession(cols, rows);
             }
-            createdAt.set(ws, { session: name, time: Date.now() });
             attachToTmux(name, cols, rows);
           } catch (e: unknown) {
             const errMsg = e instanceof Error ? e.message : 'unknown error';
@@ -439,11 +413,9 @@ wss.on('connection', (ws: WebSocket) => {
     }
 
     // Untrack this client
-    const disconnectedSession = sessionName;
     if (sessionName) trackDetach(ws, sessionName);
-    createdAt.delete(ws);
 
-    // Orphan cleanup is handled by the periodic cleanupOrphanedSessions() (every 30s)
-    // which checks sessionClients and getRenamedSessions() from terminal-state.json
+    // Orphan cleanup is handled by the periodic cleanupOrphanedSessions() (every 60s)
+    // which checks sessionClients and getKnownSessions() from terminal-state.json
   });
 });

package/lib/workspace/agent-worker.ts

@@ -423,7 +423,7 @@ export class AgentWorker extends EventEmitter {
     let prompt: string;
     switch (reason.type) {
       case 'bus_message':
-        prompt = `You received new messages from other agents:\n${reason.messages.map(m => m.content).join('\n')}\n\nReact accordingly — update your work, respond, or take action as needed.`;
+        prompt = `You received new messages from other agents:\n${reason.messages.map(m => m.content).join('\n')}\n\nAct on these messages. Be concise — don't repeat the message content back. Use tools to inspect files or git history if you need more details.`;
         break;
       case 'upstream_changed':
         prompt = `Your upstream dependency (agent ${reason.agentId}) has produced new output: ${reason.files.join(', ')}.\n\nRe-analyze and update your work based on the new upstream output.`;