@imdeadpool/guardex 7.0.41 → 7.0.43

package/src/cockpit/index.js

@@ -0,0 +1,426 @@
+const { readCockpitState } = require('./state');
+const { readCockpitSettings } = require('./settings');
+const { renderCockpit } = require('./render');
+const { openKittyCockpit } = require('./kitty-layout');
+const control = require('./control');
+const actions = require('./actions');
+const { normalizeBackendName, selectTerminalBackend } = require('../terminal');
+
+const DEFAULT_SESSION_NAME = 'guardex';
+const DEFAULT_BACKEND = 'auto';
+const DEFAULT_INTERACTIVE_BACKEND = 'auto';
+
+function parseCockpitArgs(rawArgs = []) {
+  const options = {
+    sessionName: DEFAULT_SESSION_NAME,
+    backend: process.env.GUARDEX_COCKPIT_BACKEND || DEFAULT_BACKEND,
+    attach: false,
+    target: process.cwd(),
+    host: undefined,
+    socket: undefined,
+  };
+
+  for (let index = 0; index < rawArgs.length; index += 1) {
+    const arg = rawArgs[index];
+    if (arg === '--attach') {
+      options.attach = true;
+      continue;
+    }
+    if (arg === '--kitty') {
+      options.backend = 'kitty';
+      continue;
+    }
+    if (arg === '--host' || arg === '--bootstrap-kitty') {
+      options.host = true;
+      if (!options.backend || options.backend === 'auto' || options.backend === DEFAULT_BACKEND) {
+        options.backend = 'kitty';
+      }
+      continue;
+    }
+    if (arg === '--no-host' || arg === '--no-bootstrap-kitty') {
+      options.host = false;
+      continue;
+    }
+    if (arg === '--socket') {
+      const next = rawArgs[index + 1];
+      if (!next || next.startsWith('-')) {
+        throw new Error('--socket requires a path');
+      }
+      options.socket = next;
+      if (options.host !== false) options.host = true;
+      if (!options.backend || options.backend === 'auto' || options.backend === DEFAULT_BACKEND) {
+        options.backend = 'kitty';
+      }
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith('--socket=')) {
+      const next = arg.slice('--socket='.length);
+      if (!next) throw new Error('--socket requires a path');
+      options.socket = next;
+      if (options.host !== false) options.host = true;
+      if (!options.backend || options.backend === 'auto' || options.backend === DEFAULT_BACKEND) {
+        options.backend = 'kitty';
+      }
+      continue;
+    }
+    if (arg === '--session') {
+      const next = rawArgs[index + 1];
+      if (!next || next.startsWith('-')) {
+        throw new Error('--session requires a tmux session name');
+      }
+      options.sessionName = next;
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith('--session=')) {
+      options.sessionName = arg.slice('--session='.length);
+      if (!options.sessionName) {
+        throw new Error('--session requires a tmux session name');
+      }
+      continue;
+    }
+    if (arg === '--backend') {
+      const next = rawArgs[index + 1];
+      if (!next || next.startsWith('-')) {
+        throw new Error('--backend requires auto, kitty, or tmux');
+      }
+      options.backend = normalizeBackendName(next);
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith('--backend=')) {
+      const next = arg.slice('--backend='.length);
+      if (!next) {
+        throw new Error('--backend requires auto, kitty, or tmux');
+      }
+      options.backend = normalizeBackendName(next);
+      continue;
+    }
+    if (arg === '--target' || arg === '-t') {
+      const next = rawArgs[index + 1];
+      if (!next || next.startsWith('-')) {
+        throw new Error(`${arg} requires a repo path`);
+      }
+      options.target = next;
+      index += 1;
+      continue;
+    }
+    throw new Error(`Unknown cockpit option: ${arg}`);
+  }
+
+  return options;
+}
+
+function parseCockpitControlArgs(rawArgs = []) {
+  const options = {
+    refreshMs: undefined,
+    target: process.cwd(),
+  };
+
+  for (let index = 0; index < rawArgs.length; index += 1) {
+    const arg = rawArgs[index];
+    if (arg === '--target' || arg === '-t') {
+      const next = rawArgs[index + 1];
+      if (!next || next.startsWith('-')) {
+        throw new Error(`${arg} requires a repo path`);
+      }
+      options.target = next;
+      index += 1;
+      continue;
+    }
+    if (arg === '--refresh-ms') {
+      const next = rawArgs[index + 1];
+      if (!next || next.startsWith('-')) {
+        throw new Error('--refresh-ms requires a positive integer');
+      }
+      options.refreshMs = Number.parseInt(next, 10);
+      if (!Number.isFinite(options.refreshMs) || options.refreshMs <= 0) {
+        throw new Error('--refresh-ms requires a positive integer');
+      }
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith('--refresh-ms=')) {
+      options.refreshMs = Number.parseInt(arg.slice('--refresh-ms='.length), 10);
+      if (!Number.isFinite(options.refreshMs) || options.refreshMs <= 0) {
+        throw new Error('--refresh-ms requires a positive integer');
+      }
+      continue;
+    }
+    throw new Error(`Unknown cockpit control option: ${arg}`);
+  }
+
+  return options;
+}
+
+function shellQuote(value) {
+  return `'${String(value).replace(/'/g, "'\\''")}'`;
+}
+
+function cockpitControlCommand(repoRoot, options = {}) {
+  const refresh = Number.isFinite(options.refreshMs) && options.refreshMs > 0
+    ? ` --refresh-ms ${Math.floor(options.refreshMs)}`
+    : '';
+  return `gx cockpit control --target ${shellQuote(repoRoot)}${refresh}`;
+}
+
+function terminalBackendOptionsFromDeps(deps = {}) {
+  const terminalBackendOptions = { ...(deps.terminalBackendOptions || {}) };
+  if (deps.terminalBackends && deps.terminalBackends.kitty) {
+    terminalBackendOptions.kittyBackend = deps.terminalBackends.kitty;
+  }
+  if (deps.terminalBackends && deps.terminalBackends.tmux) {
+    terminalBackendOptions.tmuxBackend = deps.terminalBackends.tmux;
+  }
+  if (deps.tmux) {
+    terminalBackendOptions.tmux = { tmux: deps.tmux };
+  }
+  return terminalBackendOptions;
+}
+
+function writeOpenedCockpitMessage({ backend, action, options, repoRoot, controlCommand, stdout, toolName }) {
+  if (backend.name === 'tmux' && action === 'attached') {
+    stdout.write(`[${toolName}] Attaching tmux session '${options.sessionName}'.\n`);
+    return;
+  }
+
+  if (backend.name === 'tmux') {
+    stdout.write(`[${toolName}] Created tmux session '${options.sessionName}' in ${repoRoot}.\n`);
+  } else {
+    stdout.write(`[${toolName}] Created ${backend.name} cockpit window '${options.sessionName}' in ${repoRoot}.\n`);
+  }
+  stdout.write(`[${toolName}] Control pane: ${controlCommand}\n`);
+}
+
+function shouldAutoHost(options = {}, context = {}) {
+  if (options.host === true || options.host === false) return false;
+  const env = context.env || process.env;
+  const optOut = String(env.GUARDEX_AUTO_HOST || '').trim().toLowerCase();
+  if (optOut === '0' || optOut === 'false' || optOut === 'no' || optOut === 'off') return false;
+  if (env.KITTY_LISTEN_ON) return false;
+  const stdout = context.stdout || process.stdout;
+  return Boolean(stdout && stdout.isTTY);
+}
+
+function openWithBackend(backend, options, repoRoot, controlCommand, deps = {}) {
+  const stdout = deps.stdout || process.stdout;
+  const toolName = deps.toolName || 'gitguardex';
+  const env = deps.env || process.env;
+  if (backend.name === 'kitty') {
+    const autoHost = shouldAutoHost(options, { env, stdout });
+    const result = openKittyCockpit({
+      repoRoot,
+      sessionName: options.sessionName,
+      controlCommand,
+      state: deps.state,
+      settings: deps.settings,
+      readState: deps.readState || readCockpitState,
+      readSettings: deps.readSettings || readCockpitSettings,
+      dryRun: deps.dryRun,
+      controlTitle: options.controlTitle || 'gx cockpit',
+      focusControl: deps.focusControl === undefined ? true : deps.focusControl,
+      runner: deps.kittyRunner || deps.runner,
+      kittyBin: deps.kittyBin || env.GUARDEX_KITTY_BIN,
+      env,
+      backend,
+      bootstrap: options.host === true || (options.host === undefined && autoHost)
+        ? true
+        : options.host === false ? false : undefined,
+      bootstrapWhenHostless: false,
+      socket: options.socket,
+      hostRunner: deps.kittyHostRunner,
+      hostRuntime: deps.kittyHostRuntime,
+      spawn: deps.spawn,
+      fs: deps.fs,
+      sleep: deps.sleep,
+    });
+    const action = result && result.action ? result.action : 'created';
+    writeOpenedCockpitMessage({ backend, action, options, repoRoot, controlCommand, stdout, toolName });
+    return { action, backend: backend.name, sessionName: options.sessionName, repoRoot, plan: result.plan };
+  }
+
+  const result = backend.openCockpitLayout({
+    repoRoot,
+    sessionName: options.sessionName,
+    command: controlCommand,
+    attach: options.attach,
+  });
+  const action = result && result.action ? result.action : 'created';
+
+  writeOpenedCockpitMessage({ backend, action, options, repoRoot, controlCommand, stdout, toolName });
+  return { action, backend: backend.name, sessionName: options.sessionName, repoRoot };
+}
+
+function backendAvailable(backend) {
+  if (!backend || typeof backend.isAvailable !== 'function') return true;
+  try {
+    return Boolean(backend.isAvailable());
+  } catch (_error) {
+    return false;
+  }
+}
+
+function defaultCockpitBackends(preferredBackend, terminalBackendOptions = {}, options = {}) {
+  const preferred = normalizeBackendName(preferredBackend || DEFAULT_INTERACTIVE_BACKEND, DEFAULT_INTERACTIVE_BACKEND);
+  const seen = new Set();
+  const candidates = [];
+  const add = (name, addOptions = {}) => {
+    if (seen.has(name)) return;
+    const backend = selectTerminalBackend(name, terminalBackendOptions);
+    if (!backend) return;
+    if (addOptions.onlyIfAvailable && !backendAvailable(backend)) return;
+    seen.add(name);
+    candidates.push(backend);
+  };
+
+  if (preferred === 'auto') {
+    if (options.autoHostPermitted) {
+      add('kitty');
+    } else {
+      add('kitty', { onlyIfAvailable: true });
+    }
+    add('tmux');
+    return candidates;
+  }
+
+  add(preferred);
+  if (preferred !== 'tmux') add('tmux');
+  return candidates;
+}
+
+function inlineCockpit(repoRoot, deps = {}) {
+  const controlHandle = control.startCockpitControl({
+    repoPath: repoRoot,
+    stdin: deps.stdin,
+    stdout: deps.stdout || process.stdout,
+    readState: deps.readState,
+    readSettings: deps.readSettings,
+    setInterval: deps.setInterval,
+    clearInterval: deps.clearInterval,
+  });
+  return {
+    action: 'rendered',
+    backend: 'inline',
+    sessionName: DEFAULT_SESSION_NAME,
+    repoRoot,
+    control: controlHandle,
+  };
+}
+
+function openDefaultCockpit(deps = {}) {
+  const {
+    resolveRepoRoot,
+    env = process.env,
+  } = deps;
+  if (typeof resolveRepoRoot !== 'function') {
+    throw new Error('openDefaultCockpit requires resolveRepoRoot');
+  }
+
+  const target = deps.target || process.cwd();
+  const stdout = deps.stdout || process.stdout;
+  const options = {
+    sessionName: DEFAULT_SESSION_NAME,
+    backend: env.GUARDEX_COCKPIT_BACKEND || DEFAULT_INTERACTIVE_BACKEND,
+    attach: false,
+    target,
+  };
+  const repoRoot = resolveRepoRoot(target);
+  const controlCommand = cockpitControlCommand(repoRoot);
+  const terminalBackendOptions = terminalBackendOptionsFromDeps(deps);
+  const failures = [];
+  const autoHostPermitted = shouldAutoHost({}, { env, stdout });
+
+  for (const backend of defaultCockpitBackends(options.backend, terminalBackendOptions, { autoHostPermitted })) {
+    try {
+      return openWithBackend(backend, options, repoRoot, controlCommand, deps);
+    } catch (error) {
+      failures.push({
+        backend: backend.name,
+        message: error && error.message ? error.message : String(error),
+      });
+    }
+  }
+
+  const result = inlineCockpit(repoRoot, deps);
+  result.failures = failures;
+  return result;
+}
+
+function render(repoPath = process.cwd()) {
+  return renderCockpit(readCockpitState(repoPath));
+}
+
+function startCockpit(options = {}) {
+  const repoPath = options.repoPath || process.cwd();
+  const refreshMs = Number.isFinite(options.refreshMs) && options.refreshMs > 0
+    ? options.refreshMs
+    : 2000;
+
+  const paint = () => {
+    process.stdout.write('\x1Bc');
+    process.stdout.write(render(repoPath));
+  };
+
+  paint();
+  return setInterval(paint, refreshMs);
+}
+
+function openCockpit(rawArgs = [], deps = {}) {
+  const {
+    resolveRepoRoot,
+    toolName = 'gitguardex',
+    stdout = process.stdout,
+  } = deps;
+  if (typeof resolveRepoRoot !== 'function') {
+    throw new Error('openCockpit requires resolveRepoRoot');
+  }
+
+  if (rawArgs[0] === 'control') {
+    const controlOptions = parseCockpitControlArgs(rawArgs.slice(1));
+    return control.startCockpitControl({
+      repoPath: resolveRepoRoot(controlOptions.target),
+      refreshMs: controlOptions.refreshMs,
+      stdin: deps.stdin,
+      stdout,
+      readState: deps.readState,
+      readSettings: deps.readSettings,
+      setInterval: deps.setInterval,
+      clearInterval: deps.clearInterval,
+    });
+  }
+
+  const options = parseCockpitArgs(rawArgs);
+  const repoRoot = resolveRepoRoot(options.target);
+  const controlCommand = cockpitControlCommand(repoRoot);
+  const terminalBackendOptions = terminalBackendOptionsFromDeps(deps);
+  const backend = selectTerminalBackend(options.backend, terminalBackendOptions);
+
+  return openWithBackend(backend, options, repoRoot, controlCommand, { ...deps, stdout, toolName });
+}
+
+if (require.main === module) {
+  startCockpit({
+    repoPath: process.argv[2] || process.cwd(),
+    refreshMs: Number.parseInt(process.env.GUARDEX_COCKPIT_REFRESH_MS || '2000', 10),
+  });
+}
+
+module.exports = {
+  DEFAULT_SESSION_NAME,
+  DEFAULT_BACKEND,
+  DEFAULT_INTERACTIVE_BACKEND,
+  cockpitControlCommand,
+  defaultCockpitBackends,
+  parseCockpitArgs,
+  parseCockpitControlArgs,
+  openDefaultCockpit,
+  openCockpit,
+  openKittyCockpit,
+  render,
+  startCockpit,
+  ...control,
+  ...actions,
+  control,
+  actions,
+};

package/src/cockpit/keybindings.js

@@ -0,0 +1,224 @@
+'use strict';
+
+const { PANE_MENU_ACTION_IDS } = require('./pane-menu');
+
+const DEFAULT_ACTION_ROWS = Object.freeze(['new-agent', 'terminal', 'settings', 'shortcuts']);
+const VALID_MODES = new Set(['main', 'menu', 'settings', 'shortcuts', 'new-agent', 'terminal', 'prompt']);
+
+function action(type, payload = {}) {
+  return { type, payload };
+}
+
+const NAVIGATION_BINDINGS = {
+  j: action('next'),
+  down: action('next'),
+  k: action('previous'),
+  up: action('previous'),
+  enter: action('view-selected'),
+};
+
+const MAIN_BINDINGS = {
+  n: action('new-agent'),
+  t: action('terminal'),
+  m: action('menu'),
+  'alt-shift-m': action('menu'),
+  s: action('settings'),
+  '?': action('shortcuts'),
+  x: action(PANE_MENU_ACTION_IDS.CLOSE),
+  b: action(PANE_MENU_ACTION_IDS.CREATE_CHILD_WORKTREE),
+  f: action(PANE_MENU_ACTION_IDS.BROWSE_FILES),
+  h: action(PANE_MENU_ACTION_IDS.HIDE_PANE),
+  P: action(PANE_MENU_ACTION_IDS.PROJECT_FOCUS),
+  a: action(PANE_MENU_ACTION_IDS.ADD_AGENT),
+  A: action(PANE_MENU_ACTION_IDS.ADD_TERMINAL),
+  r: action(PANE_MENU_ACTION_IDS.REOPEN_CLOSED_WORKTREE),
+  D: action('doctor'),
+  d: action('diff'),
+  l: action('locks'),
+  y: action('sync'),
+  F: action('finish'),
+  c: action('cleanup-sessions'),
+  q: action('quit'),
+  ...NAVIGATION_BINDINGS,
+};
+
+const BASE_BINDINGS = {
+  main: MAIN_BINDINGS,
+  menu: {
+    ...NAVIGATION_BINDINGS,
+    esc: action('close-menu'),
+    q: action('quit'),
+  },
+  settings: {
+    ...NAVIGATION_BINDINGS,
+    esc: action('close-settings'),
+    q: action('quit'),
+  },
+  shortcuts: {
+    esc: action('close-popup'),
+    q: action('quit'),
+  },
+  'new-agent': {
+    enter: action('agent:start'),
+    esc: action('close-popup'),
+    q: action('quit'),
+  },
+  terminal: {
+    enter: action('terminal:open'),
+    esc: action('close-popup'),
+    q: action('quit'),
+  },
+  prompt: {},
+};
+
+function cloneAction(binding) {
+  return action(binding.type, { ...binding.payload });
+}
+
+function cloneBindings(bindings) {
+  return Object.fromEntries(
+    Object.entries(bindings).map(([mode, modeBindings]) => [
+      mode,
+      Object.fromEntries(
+        Object.entries(modeBindings).map(([key, binding]) => [key, cloneAction(binding)]),
+      ),
+    ]),
+  );
+}
+
+function defaultKeybindings() {
+  return cloneBindings(BASE_BINDINGS);
+}
+
+function normalizeMode(context = {}) {
+  return VALID_MODES.has(context.mode) ? context.mode : 'main';
+}
+
+function normalizeKey(key) {
+  if (key && typeof key === 'object') {
+    if ((key.meta || key.alt) && key.shift && String(key.name || key.key || '').toLowerCase() === 'm') {
+      return 'alt-shift-m';
+    }
+    return normalizeKey(key.name || key.sequence || key.key || '');
+  }
+  if (key === '\r' || key === '\n') return 'enter';
+  if (key === '\x1bM' || key === '\x1bm') return 'alt-shift-m';
+  if (key === '\x1b') return 'esc';
+  if (typeof key !== 'string') return '';
+
+  const normalized = key.trim();
+  if (normalized === '\x1bM' || normalized === '\x1bm') return 'alt-shift-m';
+  if (/^alt(?:\+|-)?shift(?:\+|-)?m$/i.test(normalized)) return 'alt-shift-m';
+  if (normalized.length === 1) return normalized;
+
+  const namedKey = normalized.toLowerCase();
+  if (namedKey === 'arrowdown') return 'down';
+  if (namedKey === 'arrowup') return 'up';
+  if (namedKey === 'return') return 'enter';
+  if (namedKey === 'escape') return 'esc';
+  return namedKey;
+}
+
+function resolveKeyAction(key, context = {}) {
+  const mode = normalizeMode(context);
+  const normalizedKey = normalizeKey(key);
+  const keybindings = context.keybindings || BASE_BINDINGS;
+  const binding = keybindings[mode] && keybindings[mode][normalizedKey];
+
+  if (!binding) {
+    return action('noop', { key: normalizedKey, mode });
+  }
+
+  return action(binding.type, {
+    ...binding.payload,
+    key: normalizedKey,
+    mode,
+  });
+}
+
+function number(value, fallback) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+
+function wrapIndex(index, length) {
+  if (length <= 0) return 0;
+  const next = Number.isInteger(index) ? index : 0;
+  return ((next % length) + length) % length;
+}
+
+function actionRows(state = {}) {
+  if (!Array.isArray(state.actionRows) || state.actionRows.length === 0) {
+    return [...DEFAULT_ACTION_ROWS];
+  }
+  return state.actionRows.map((row) => String(row || '').trim()).filter(Boolean);
+}
+
+function moveSelection(state = {}, direction) {
+  const sessions = Array.isArray(state.sessions) ? state.sessions : [];
+  if (sessions.length > 0) {
+    return {
+      ...state,
+      selectedScope: 'lane',
+      selectedIndex: wrapIndex(number(state.selectedIndex, 0) + direction, sessions.length),
+      selectedSessionId: '',
+    };
+  }
+
+  const rows = actionRows(state);
+  return {
+    ...state,
+    actionRows: rows,
+    selectedScope: 'action',
+    selectedIndex: 0,
+    actionIndex: wrapIndex(number(state.actionIndex, 0) + direction, rows.length),
+    selectedSessionId: '',
+  };
+}
+
+function closeMode(state = {}) {
+  return {
+    ...state,
+    mode: 'main',
+    lastIntent: null,
+  };
+}
+
+function applyCockpitKey(state = {}, key) {
+  const current = {
+    ...state,
+    mode: normalizeMode(state),
+  };
+  const resolved = resolveKeyAction(key, current);
+
+  switch (resolved.type) {
+    case 'next':
+      return moveSelection(current, 1);
+    case 'previous':
+      return moveSelection(current, -1);
+    case 'new-agent':
+      return { ...current, mode: 'new-agent', lastIntent: null };
+    case 'terminal':
+      return { ...current, mode: 'terminal', lastIntent: null };
+    case 'shortcuts':
+      return { ...current, mode: 'shortcuts', lastIntent: null };
+    case 'settings':
+      return { ...current, mode: 'settings', lastIntent: null };
+    case 'menu':
+      return { ...current, mode: 'menu', lastIntent: null };
+    case 'close-menu':
+    case 'close-settings':
+    case 'close-popup':
+      return closeMode(current);
+    case 'quit':
+      return { ...current, shouldExit: true };
+    default:
+      return current;
+  }
+}
+
+module.exports = {
+  applyCockpitKey,
+  defaultKeybindings,
+  resolveKeyAction,
+};