@aion0/forge 0.5.21 → 0.5.22

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.`;