Make cockpit lane actions executable on demand (#486)

The cockpit control loop should keep rendering intents without launching work, while selected-lane actions need a bounded runner for files, diff, locks, sync, finish, pane focus, close, copy path, and editor open. This adds that runner and explicit control wrappers without replacing the current TUI reducer.

Constraint: Existing control-loop tests require menu selection to emit intents, not launch agents directly.

Rejected: Reuse stale worktree control.js wholesale | it deleted the current TUI control loop from PR #482.

Confidence: high

Scope-risk: moderate

Directive: Keep close limited to tmux pane cleanup; do not delete branch/worktree/session metadata from that action.

Tested: node --test test/cockpit-action-runner.test.js test/cockpit-control.test.js

Not-tested: Manual tmux cockpit interaction

Co-authored-by: NagyVikt <nagy.viktordp@gmail.com>

Author: NagyVikt

src/cockpit/action-runner.js

@@ -0,0 +1,375 @@
+'use strict';
+
+const cp = require('node:child_process');
+const path = require('node:path');
+const { readCockpitSettings } = require('./settings');
+
+const ACTION_ALIASES = new Map([
+  ['finish-pr', 'finish'],
+  ['finish / pr', 'finish'],
+  ['copy path', 'copy-path'],
+  ['open in editor', 'open-editor'],
+  ['open-editor', 'open-editor'],
+]);
+
+const CLIPBOARD_COMMANDS = [
+  { cmd: 'wl-copy', args: [] },
+  { cmd: 'termux-clipboard-set', args: [] },
+  { cmd: 'pbcopy', args: [], input: true },
+  { cmd: 'xclip', args: ['-selection', 'clipboard'], input: true },
+  { cmd: 'xsel', args: ['--clipboard', '--input'], input: true },
+];
+
+function defaultRunCommand(cmd, args = [], options = {}) {
+  return cp.spawnSync(cmd, args, {
+    cwd: options.cwd,
+    env: options.env ? { ...process.env, ...options.env } : process.env,
+    encoding: 'utf8',
+    input: options.input,
+    stdio: 'pipe',
+    timeout: options.timeout,
+  });
+}
+
+function firstString(...values) {
+  for (const value of values) {
+    if (typeof value === 'string' && value.trim().length > 0) {
+      return value.trim();
+    }
+  }
+  return '';
+}
+
+function normalizeAction(action) {
+  const raw = typeof action === 'string'
+    ? action
+    : firstString(action && action.id, action && action.action, action && action.type, action && action.label);
+  const normalized = String(raw || '').trim().toLowerCase();
+  return ACTION_ALIASES.get(normalized) || normalized;
+}
+
+function normalizeResult(result) {
+  const payload = result && typeof result === 'object' ? result : {};
+  const status = Number.isInteger(payload.status) ? payload.status : 0;
+  const ok = !payload.error && status === 0;
+  return {
+    ok,
+    stdout: String(payload.stdout || ''),
+    stderr: payload.error ? String(payload.error.message || payload.error) : String(payload.stderr || ''),
+  };
+}
+
+function shellQuote(value) {
+  const text = String(value);
+  if (/^[A-Za-z0-9_/:=.,@%+-]+$/.test(text)) return text;
+  return `'${text.replace(/'/g, "'\\''")}'`;
+}
+
+function renderCommand(cmd, args = []) {
+  return [cmd, ...args].map(shellQuote).join(' ');
+}
+
+function resultShape({ ok, message, command = '', stdout = '', stderr = '' }) {
+  return {
+    ok: Boolean(ok),
+    message: String(message || ''),
+    command: String(command || ''),
+    stdout: String(stdout || ''),
+    stderr: String(stderr || ''),
+  };
+}
+
+function selectedSession(context = {}) {
+  return context.session || context.selectedSession || context.lane || {};
+}
+
+function resolveBranch(context = {}) {
+  const session = selectedSession(context);
+  return firstString(
+    context.branch,
+    session.branch,
+    session.lane && session.lane.branch,
+  );
+}
+
+function resolveWorktreePath(context = {}) {
+  const session = selectedSession(context);
+  return firstString(
+    context.worktreePath,
+    context.path,
+    session.worktreePath,
+    session.worktree && session.worktree.path,
+    session.path,
+  );
+}
+
+function resolvePaneId(context = {}) {
+  const session = selectedSession(context);
+  return firstString(
+    context.paneId,
+    context.tmuxPaneId,
+    context.tmuxTarget,
+    session.paneId,
+    session.tmuxPaneId,
+    session.tmuxTarget,
+    session.tmux && session.tmux.paneId,
+    session.pane && session.pane.id,
+  );
+}
+
+function resolveRepoRoot(context = {}) {
+  return path.resolve(firstString(context.repoRoot, context.repoPath, context.target, process.cwd()));
+}
+
+function runCommand(context, cmd, args = [], options = {}) {
+  const runner = typeof context.runCommand === 'function' ? context.runCommand : defaultRunCommand;
+  const rendered = renderCommand(cmd, args);
+  const payload = normalizeResult(runner(cmd, args, options));
+  const detail = payload.ok ? payload.stdout : payload.stderr || payload.stdout;
+  return resultShape({
+    ok: payload.ok,
+    message: payload.ok ? 'Command completed.' : `Command failed: ${detail.trim() || rendered}`,
+    command: rendered,
+    stdout: payload.stdout,
+    stderr: payload.stderr,
+  });
+}
+
+function commandExists(context, cmd) {
+  if (typeof context.commandExists === 'function') {
+    return Boolean(context.commandExists(cmd));
+  }
+  const runner = typeof context.runCommand === 'function' ? context.runCommand : defaultRunCommand;
+  const result = normalizeResult(runner('which', [cmd], { cwd: resolveRepoRoot(context) }));
+  return result.ok && result.stdout.trim().length > 0;
+}
+
+function requireBranch(context, actionName) {
+  const branch = resolveBranch(context);
+  if (branch) return { branch };
+  return resultShape({
+    ok: false,
+    message: `${actionName} requires a selected lane branch.`,
+  });
+}
+
+function requireWorktreePath(context, actionName) {
+  const worktreePath = resolveWorktreePath(context);
+  if (worktreePath) return { worktreePath };
+  return resultShape({
+    ok: false,
+    message: `${actionName} requires a selected lane worktree path.`,
+  });
+}
+
+function runGxAgentsInspect(subcommand, context) {
+  const required = requireBranch(context, subcommand);
+  if (!required.branch) return required;
+  return runCommand(
+    context,
+    context.gxCommand || 'gx',
+    ['agents', subcommand, '--target', resolveRepoRoot(context), '--branch', required.branch],
+    { cwd: resolveRepoRoot(context) },
+  );
+}
+
+function runView(context) {
+  const paneId = resolvePaneId(context);
+  if (paneId) {
+    return runCommand(context, context.tmuxCommand || 'tmux', ['select-pane', '-t', paneId], {
+      cwd: resolveRepoRoot(context),
+    });
+  }
+
+  return runGxAgentsInspect('files', context);
+}
+
+function runSync(context) {
+  const required = requireWorktreePath(context, 'Sync');
+  if (!required.worktreePath) return required;
+  const args = ['sync', '--target', required.worktreePath];
+  const base = firstString(context.base, context.baseBranch, selectedSession(context).base);
+  if (base) args.push('--base', base);
+  return runCommand(context, context.gxCommand || 'gx', args, { cwd: required.worktreePath });
+}
+
+function runFinish(context) {
+  const required = requireBranch(context, 'Finish');
+  if (!required.branch) return required;
+  return runCommand(
+    context,
+    context.gxCommand || 'gx',
+    [
+      'agents',
+      'finish',
+      '--target',
+      resolveRepoRoot(context),
+      '--branch',
+      required.branch,
+      '--via-pr',
+      '--wait-for-merge',
+      '--cleanup',
+    ],
+    { cwd: resolveRepoRoot(context) },
+  );
+}
+
+function runClose(context) {
+  const paneId = resolvePaneId(context);
+  if (!paneId) {
+    return resultShape({
+      ok: false,
+      message: 'Close requires an associated tmux pane; branch, worktree, and session metadata were left untouched.',
+    });
+  }
+  const result = runCommand(context, context.tmuxCommand || 'tmux', ['kill-pane', '-t', paneId], {
+    cwd: resolveRepoRoot(context),
+  });
+  return {
+    ...result,
+    message: result.ok
+      ? 'Closed associated tmux pane only; branch, worktree, and session metadata were left untouched.'
+      : result.message,
+  };
+}
+
+function resolveClipboardCommand(context) {
+  if (context.clipboardCommand && typeof context.clipboardCommand === 'object') {
+    return {
+      cmd: context.clipboardCommand.cmd,
+      args: Array.isArray(context.clipboardCommand.args) ? context.clipboardCommand.args : [],
+      input: Boolean(context.clipboardCommand.input),
+    };
+  }
+  if (typeof context.clipboardCommand === 'string' && context.clipboardCommand.trim()) {
+    return { cmd: context.clipboardCommand.trim(), args: [], input: true };
+  }
+  return CLIPBOARD_COMMANDS.find((candidate) => commandExists(context, candidate.cmd)) || null;
+}
+
+function runCopyPath(context) {
+  const required = requireWorktreePath(context, 'Copy Path');
+  if (!required.worktreePath) return required;
+  const clipboard = resolveClipboardCommand(context);
+  if (!clipboard) {
+    return resultShape({
+      ok: true,
+      message: 'No clipboard utility found; printed worktree path.',
+      command: renderCommand('printf', ['%s\\n', required.worktreePath]),
+      stdout: `${required.worktreePath}\n`,
+    });
+  }
+
+  const args = clipboard.input ? clipboard.args : [...clipboard.args, required.worktreePath];
+  const result = runCommand(context, clipboard.cmd, args, {
+    cwd: required.worktreePath,
+    input: clipboard.input ? required.worktreePath : undefined,
+  });
+  return {
+    ...result,
+    message: result.ok ? 'Copied worktree path.' : result.message,
+  };
+}
+
+function splitCommand(rawCommand) {
+  const parts = [];
+  let current = '';
+  let quote = '';
+  let escaped = false;
+
+  for (const char of String(rawCommand || '')) {
+    if (escaped) {
+      current += char;
+      escaped = false;
+      continue;
+    }
+    if (char === '\\') {
+      escaped = true;
+      continue;
+    }
+    if (quote) {
+      if (char === quote) {
+        quote = '';
+      } else {
+        current += char;
+      }
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      continue;
+    }
+    if (/\s/.test(char)) {
+      if (current) {
+        parts.push(current);
+        current = '';
+      }
+      continue;
+    }
+    current += char;
+  }
+  if (current) parts.push(current);
+  return parts;
+}
+
+function resolveEditorParts(context, worktreePath) {
+  const settings = context.settings && typeof context.settings === 'object'
+    ? context.settings
+    : readCockpitSettings(resolveRepoRoot(context));
+  const configured = firstString(settings.editorCommand);
+  if (configured) return splitCommand(configured);
+  if (commandExists(context, 'code')) return ['code'];
+
+  return {
+    printOnly: true,
+    parts: ['code', worktreePath],
+  };
+}
+
+function runOpenEditor(context) {
+  const required = requireWorktreePath(context, 'Open in Editor');
+  if (!required.worktreePath) return required;
+  const resolved = resolveEditorParts(context, required.worktreePath);
+  if (resolved.printOnly) {
+    return resultShape({
+      ok: true,
+      message: 'No editor command configured and code was not found; printed editor command.',
+      command: renderCommand(resolved.parts[0], resolved.parts.slice(1)),
+      stdout: `${renderCommand(resolved.parts[0], resolved.parts.slice(1))}\n`,
+    });
+  }
+
+  const [cmd, ...args] = resolved;
+  const result = runCommand(context, cmd, [...args, required.worktreePath], {
+    cwd: required.worktreePath,
+  });
+  return {
+    ...result,
+    message: result.ok ? 'Opened worktree in editor.' : result.message,
+  };
+}
+
+function runCockpitAction(action, context = {}) {
+  const normalized = normalizeAction(action);
+
+  if (normalized === 'view') return runView(context);
+  if (normalized === 'files') return runGxAgentsInspect('files', context);
+  if (normalized === 'diff') return runGxAgentsInspect('diff', context);
+  if (normalized === 'locks') return runGxAgentsInspect('locks', context);
+  if (normalized === 'sync') return runSync(context);
+  if (normalized === 'finish') return runFinish(context);
+  if (normalized === 'close') return runClose(context);
+  if (normalized === 'copy-path') return runCopyPath(context);
+  if (normalized === 'open-editor') return runOpenEditor(context);
+
+  return resultShape({
+    ok: false,
+    message: `Unknown cockpit action: ${normalized || '(empty)'}`,
+  });
+}
+
+module.exports = {
+  runCockpitAction,
+  splitCommand,
+  renderCommand,
+};