@aion0/forge 0.10.78 → 0.10.80

package/lib/pipeline.ts

@@ -59,6 +59,10 @@ export interface WorkflowNode {
   /** Milliseconds to wait before each retry. Default 0 (immediate).
    *  Use 5000+ for downstream rate-limit recovery. */
   retryDelayMs?: number;
+  /** Execution backend for this node's task. Overrides the workflow-level
+   *  default. 'tmux' = interactive claude in a dedicated tmux session
+   *  (subscription billing); 'headless' / omitted = default `claude -p`. */
+  backend?: 'tmux' | 'headless';
 }
 
 // ─── Conversation Mode Types ──────────────────────────────
@@ -168,6 +172,10 @@ export interface Workflow {
   /** Declares the pipeline pushes to git. Enables an up-front OTP/2FA preflight
    *  so a 2fa_verify wall aborts BEFORE any code work instead of at push time. */
   git_push?: boolean;
+  /** Default execution backend for every node's task. 'tmux' runs interactive
+   *  claude in a per-node tmux session (subscription billing); 'headless' /
+   *  omitted uses default `claude -p`. Per-node `backend:` overrides this. */
+  backend?: 'tmux' | 'headless';
   // Conversation mode fields (only when type === 'conversation')
   conversation?: ConversationConfig;
 }
@@ -247,6 +255,13 @@ export interface Pipeline {
    * recovery use the same set as the original run.
    */
   skills?: string[];
+  /**
+   * Resolved execution backend for this run, frozen from the workflow's
+   * `backend:` at start so retries / recovery reuse it. Each node's task
+   * inherits this unless the node declares its own `backend:`. Omitted =
+   * default headless.
+   */
+  backend?: 'tmux' | 'headless';
   /**
    * Absolute path to this run's scratch dir, served to YAML nodes as
    * `{{run.tmp_dir}}`. Layout: `<project_dir>/.forge/worktrees/pipeline-<id>/`.
@@ -460,6 +475,7 @@ export function parseWorkflow(raw: string): Workflow {
       retryDelayMs: Number.isFinite(Number(n.retry_delay_ms ?? n.retryDelayMs))
         ? Math.max(0, Math.trunc(Number(n.retry_delay_ms ?? n.retryDelayMs)))
         : 0,
+      backend: n.backend === 'tmux' || n.backend === 'headless' ? n.backend : undefined,
     };
   }
 
@@ -500,6 +516,7 @@ export function parseWorkflow(raw: string): Workflow {
     nodes,
     for_each,
     conversation,
+    backend: parsed.backend === 'tmux' || parsed.backend === 'headless' ? parsed.backend : undefined,
   };
 }
 
@@ -975,7 +992,7 @@ function renderSkillsAppendPrompt(skills: string[] | undefined): string {
 export function startPipeline(
   workflowName: string,
   input: Record<string, string>,
-  opts: { skills?: string[] } = {},
+  opts: { skills?: string[]; backend?: 'tmux' | 'headless' } = {},
 ): Pipeline {
   const workflow = getWorkflow(workflowName);
   if (!workflow) throw new Error(`Workflow not found: ${workflowName}`);
@@ -1001,7 +1018,7 @@ export function startPipeline(
 
   // Conversation mode — separate execution path
   if (workflow.type === 'conversation' && workflow.conversation) {
-    return startConversationPipeline(workflow, input);
+    return startConversationPipeline(workflow, input, opts.backend);
   }
 
   const id = randomUUID().slice(0, 8);
@@ -1059,6 +1076,8 @@ export function startPipeline(
     nodeOrder,
     createdAt: new Date().toISOString(),
     skills: opts.skills && opts.skills.length ? [...opts.skills] : undefined,
+    // Runtime override (e.g. chat "use tmux") wins over the workflow's declared default.
+    backend: opts.backend ?? workflow.backend,
     forEach: forEachState,
   };
 
@@ -1124,7 +1143,7 @@ type ConversationState = {
 
 // ─── Conversation Mode Execution ──────────────────────────
 
-function startConversationPipeline(workflow: Workflow, input: Record<string, string>): Pipeline {
+function startConversationPipeline(workflow: Workflow, input: Record<string, string>, backendOverride?: 'tmux' | 'headless'): Pipeline {
   const conv = workflow.conversation!;
   const id = randomUUID().slice(0, 8);
 
@@ -1146,6 +1165,7 @@ function startConversationPipeline(workflow: Workflow, input: Record<string, str
     nodes: {},
     nodeOrder: [],
     createdAt: new Date().toISOString(),
+    backend: backendOverride ?? workflow.backend,
     conversation: {
       config: {
         ...conv,
@@ -1206,6 +1226,7 @@ function scheduleNextConversationTurn(pipeline: Pipeline, contextForAgent: strin
     prompt: fullPrompt,
     mode: 'prompt',
     agent: agentDef.agent,
+    backend: pipeline.backend === 'tmux' ? 'tmux' : undefined,
     conversationId: '', // fresh session — no resume for conversation mode
   });
   pipelineTaskIds.add(task.id);
@@ -2074,6 +2095,9 @@ async function scheduleReadyNodes(pipeline: Pipeline, workflow: Workflow) {
       prompt: effectivePrompt,
       mode: taskMode as any,
       agent: nodeDef.agent || undefined,
+      // Backend: per-node override > pipeline default > headless. Only 'tmux'
+      // is a real Task backend value; 'headless'/undefined → omit (default).
+      backend: (nodeDef.backend || pipeline.backend) === 'tmux' ? 'tmux' : undefined,
       // Pipeline nodes always start a fresh Claude session. Without this,
       // createTask falls back to getProjectConversationId() which returns
       // the project's last interactive session id — but pipeline nodes

package/lib/session-utils.ts

@@ -51,3 +51,22 @@ export async function getMcpFlag(projectPath: string): Promise<string> {
   return ` --mcp-config "${projectPath}/.forge/mcp.json"`;
 }
 
+
+/**
+ * tmux env injection — keep secret env (API keys) out of pane echo + shell
+ * history. The server stores values via `tmux set-environment` (the `setenv` WS
+ * message); this prefix pulls them back at launch time so only var NAMES appear
+ * in the typed command, never the values.
+ *
+ * Uses a single `eval "$(tmux show-environment -s | grep …)"` instead of one
+ * `export K="$(tmux show-environment K | sed …)"` per var — the latter form
+ * grows O(N) in length and hits tmux send-keys buffer limits with many vars.
+ * `tmux show-environment -s` outputs `KEY="val"; export KEY;` per line, so
+ * grepping `^(K1|K2)=` and eval-ing the matches is both short and safe.
+ */
+export function tmuxEnvPrefix(keys: string[]): string {
+  const valid = keys.filter((k) => /^[A-Za-z_][A-Za-z0-9_]*$/.test(k));
+  if (!valid.length) return '';
+  const pattern = `^(${valid.join('|')})=`;
+  return `eval "$(tmux show-environment -s 2>/dev/null | grep -E '${pattern}')" && `;
+}

package/lib/task-manager.ts

@@ -17,6 +17,10 @@ import { recordUsage } from './usage-scanner';
 import type { Task, TaskLogEntry, TaskStatus, TaskMode, WatchConfig } from '../src/types';
 
 import { toIsoUTC } from './iso-time';
+import { executeTmuxTask, killTmuxTaskSession } from './task-tmux-backend';
+import { installForgeStopHook } from './workspace/skill-installer';
+
+let _tmuxHookInstalled = false;
 
 /** Access pipeline.ts's pipelineTaskIds Set via the shared globalThis
  *  Symbol it registers at module load. Avoids the circular static
@@ -77,6 +81,7 @@ export function createTask(opts: {
   scheduledAt?: string;     // ISO timestamp — task won't run until this time
   watchConfig?: WatchConfig;
   agent?: string;           // Agent ID (default: from settings)
+  backend?: 'tmux';         // 'tmux' = run in dedicated tmux session; omit = default headless
 }): Task {
   const id = randomUUID().slice(0, 8);
   const mode = opts.mode || 'prompt';
@@ -89,13 +94,14 @@ export function createTask(opts: {
     : (opts.conversationId || (mode === 'prompt' ? getProjectConversationId(opts.projectName) : null));
 
   db().prepare(`
-    INSERT INTO tasks (id, project_name, project_path, prompt, mode, status, priority, conversation_id, log, scheduled_at, watch_config, agent)
-    VALUES (?, ?, ?, ?, ?, 'queued', ?, ?, '[]', ?, ?, ?)
+    INSERT INTO tasks (id, project_name, project_path, prompt, mode, status, priority, conversation_id, log, scheduled_at, watch_config, agent, backend)
+    VALUES (?, ?, ?, ?, ?, 'queued', ?, ?, '[]', ?, ?, ?, ?)
   `).run(
     id, opts.projectName, opts.projectPath, opts.prompt, mode,
     opts.priority || 0, convId || null, opts.scheduledAt || null,
     opts.watchConfig ? JSON.stringify(opts.watchConfig) : null,
     agent || null,
+    opts.backend || null,
   );
 
   // Kick the runner
@@ -171,7 +177,7 @@ export function listTasks(status?: TaskStatus): Task[] {
 export function listTasksLite(status?: TaskStatus): Task[] {
   const SLIM_COLS = `
     id, project_name, project_path, prompt, mode, status, priority,
-    conversation_id, watch_config, git_branch, cost_usd, error, agent,
+    conversation_id, watch_config, git_branch, cost_usd, error, agent, backend,
     created_at, started_at, completed_at, scheduled_at,
     length(log) AS log_size,
     CASE WHEN result_summary IS NULL THEN NULL ELSE substr(result_summary, 1, 1024) END AS result_summary,
@@ -270,6 +276,7 @@ function rowToLiteTask(row: any): Task {
     completedAt: toIsoUTC(row.completed_at) ?? undefined,
     scheduledAt: toIsoUTC(row.scheduled_at) ?? undefined,
     agent: row.agent || undefined,
+    backend: row.backend || undefined,
     logSize: row.log_size || 0,
     hasGitDiff: !!row.has_git_diff,
   } as Task;
@@ -286,6 +293,11 @@ export function cancelTask(id: string): boolean {
     return true;
   }
 
+  // Kill tmux session for tmux-backend tasks
+  if ((task as any).backend === 'tmux') {
+    killTmuxTaskSession(id);
+  }
+
   updateTaskStatus(id, 'cancelled');
 
   // Clean up project lock if this was a running prompt task
@@ -300,6 +312,8 @@ export function deleteTask(id: string): boolean {
   const task = getTask(id);
   if (!task) return false;
   if (task.status === 'running') cancelTask(id);
+  // Always attempt cleanup for tmux tasks (session may be alive for debugging)
+  if ((task as any).backend === 'tmux') killTmuxTaskSession(id);
   db().prepare('DELETE FROM tasks WHERE id = ?').run(id);
   return true;
 }
@@ -372,6 +386,20 @@ export function retryTask(id: string): Task | null {
   });
 }
 
+/**
+ * Complete a tmux task whose in-memory waiter was lost (e.g. server restart).
+ * Called by the hook endpoint fallback path in task-tmux-backend.
+ */
+export function finishTmuxTask(id: string, paneCapture: string): void {
+  const summary = paneCapture.slice(0, 2048);
+  db().prepare("UPDATE tasks SET status = 'done', result_summary = ?, completed_at = datetime('now') WHERE id = ? AND status = 'running'").run(summary, id);
+  runningProjects.delete(getTask(id)?.projectName || '');
+  appendLog(id, { type: 'result', content: paneCapture, timestamp: new Date().toISOString() });
+  emit(id, 'status', 'done');
+  const doneTask = getTask(id);
+  if (doneTask) notifyTaskComplete(doneTask).catch(() => {});
+}
+
 // ─── Background Runner ───────────────────────────────────────
 
 export function ensureRunnerStarted() {
@@ -500,6 +528,46 @@ export function connectorEnv(): Record<string, string> {
   }
 }
 
+function executeTmuxBackendTask(task: Task): Promise<void> {
+  // Ensure Stop hook is installed (idempotent; workspace daemon does this too,
+  // but tmux tasks may run without the workspace daemon active)
+  if (!_tmuxHookInstalled) {
+    _tmuxHookInstalled = true;
+    try { installForgeStopHook(Number(process.env.PORT) || 8403); } catch {}
+  }
+
+  updateTaskStatus(task.id, 'running');
+  db().prepare('UPDATE tasks SET started_at = datetime(\'now\') WHERE id = ?').run(task.id);
+  appendLog(task.id, { type: 'system', subtype: 'init', content: `Agent: ${(task as any).agent || 'claude'} | Backend: tmux`, timestamp: new Date().toISOString() });
+
+  return executeTmuxTask(task, {
+    appendLog: (entry) => appendLog(task.id, entry),
+    isCancelled: () => getTask(task.id)?.status === 'cancelled',
+    setStatus: (status, detail) => {
+      if (status === 'done') {
+        updateTaskStatus(task.id, 'done');
+        if (detail?.resultSummary) db().prepare('UPDATE tasks SET result_summary = ? WHERE id = ?').run(detail.resultSummary.slice(0, 2048), task.id);
+        if (detail?.costUSD) db().prepare('UPDATE tasks SET cost_usd = ? WHERE id = ?').run(detail.costUSD, task.id);
+        runningProjects.delete(task.projectName);
+        const doneTask = getTask(task.id); if (doneTask) notifyTaskComplete(doneTask).catch(() => {});
+      } else if (status === 'failed') {
+        updateTaskStatus(task.id, 'failed', detail?.error);
+        if (detail?.costUSD) db().prepare('UPDATE tasks SET cost_usd = ? WHERE id = ?').run(detail.costUSD, task.id);
+        runningProjects.delete(task.projectName);
+        const failedTask = getTask(task.id); if (failedTask) notifyTaskFailed(failedTask).catch(() => {});
+      } else {
+        updateTaskStatus(task.id, 'cancelled');
+        runningProjects.delete(task.projectName);
+      }
+      emit(task.id, 'status');
+    },
+  }).catch((err) => {
+    updateTaskStatus(task.id, 'failed', err?.message || String(err));
+    runningProjects.delete(task.projectName);
+    emit(task.id, 'status');
+  });
+}
+
 function executeShellTask(task: Task): Promise<void> {
   return new Promise((resolve) => {
     updateTaskStatus(task.id, 'running');
@@ -565,6 +633,7 @@ function executeShellTask(task: Task): Promise<void> {
 
 function executeTask(task: Task): Promise<void> {
   if (task.mode === 'shell') return executeShellTask(task);
+  if ((task as any).backend === 'tmux') return executeTmuxBackendTask(task);
 
   return new Promise((resolve, reject) => {
     const settings = loadSettings();
@@ -1017,6 +1086,7 @@ function rowToTask(row: any): Task {
     completedAt: toIsoUTC(row.completed_at) ?? undefined,
     scheduledAt: toIsoUTC(row.scheduled_at) ?? undefined,
     agent: row.agent || undefined,
+    backend: row.backend || undefined,
   } as Task;
 }