borgmcp 1.1.15 → 2.0.2

package/src/backends/launch-all-windows.ts

@@ -0,0 +1,110 @@
+// gh#556 Part 2 — windows backend (explicit `--mode windows` only, spec §4.2).
+// Opens each worktree as a new terminal window/tab. macOS: iTerm/Terminal via
+// osascript. Linux: $BORG_TERMINAL / $TERMINAL / probed emulator. No shared
+// session, so no post-launch attach. Hard-fails if no compatible terminal found.
+
+import type { DroneCandidate } from '../launch-all-discovery.js';
+import type { LaunchAllDeps } from '../launch-all-deps.js';
+import { buildLaunchCommand } from '../launch-all-command.js';
+import { writeLockMarker } from '../launch-all-locks.js';
+
+export interface WindowsOpts {
+  borgPath: string;
+  platform: NodeJS.Platform;
+  launchedAtISO: string;
+  /** Stagger between drone launches (ms) to avoid the rate limiter; 0 disables. */
+  launchDelayMs: number;
+  /** Injectable sleep (real setTimeout in prod; no-op spy in tests). */
+  sleep: (ms: number) => Promise<void>;
+}
+
+/** AppleScript string-literal escaping (backslash + double-quote). */
+function appleScriptEscape(s: string): string {
+  return s.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}
+
+class NoTerminalError extends Error {}
+
+/** macOS: open each candidate in iTerm or Terminal via osascript. */
+async function launchMacOS(candidates: DroneCandidate[], opts: WindowsOpts, deps: LaunchAllDeps): Promise<void> {
+  const hasITerm = deps.pathExists('/Applications/iTerm.app');
+  const hasTerminal = deps.pathExists('/Applications/Terminal.app');
+  if (!hasITerm && !hasTerminal) {
+    throw new NoTerminalError(
+      'borg launch-all: --mode windows requires a compatible terminal app.\n' +
+        'Not found: iTerm.app, Terminal.app\n' +
+        'Install iTerm2 (https://iterm2.com) or use --mode tmux (brew install tmux).\n'
+    );
+  }
+  for (let i = 0; i < candidates.length; i++) {
+    const c = candidates[i];
+    if (i > 0 && opts.launchDelayMs > 0) await opts.sleep(opts.launchDelayMs); // rate-limit stagger
+    const cmd = buildLaunchCommand(c.worktreeDir, opts.borgPath);
+    const script = hasITerm
+      ? `tell application "iTerm"\n  tell current window to create tab with default profile command "${appleScriptEscape(cmd)}"\nend tell`
+      : `tell application "Terminal"\n  do script "${appleScriptEscape(cmd)}"\n  activate\nend tell`;
+    deps.runSync('osascript', ['-e', script]);
+    writeLockMarker(deps, c.cubeId, c.droneLabel, c.worktreeDir, opts.launchedAtISO);
+  }
+}
+
+/** Linux: open each candidate in the first available terminal emulator. */
+async function launchLinux(candidates: DroneCandidate[], opts: WindowsOpts, deps: LaunchAllDeps): Promise<void> {
+  const explicit = deps.getEnv('BORG_TERMINAL') || deps.getEnv('TERMINAL');
+  const probe = ['gnome-terminal', 'konsole', 'kitty', 'wezterm', 'xterm'];
+  let term: string | undefined = explicit;
+  if (!term) {
+    for (const name of probe) {
+      if (deps.runSyncExitCode('which', [name]) === 0) {
+        term = name;
+        break;
+      }
+    }
+  }
+  if (!term) {
+    throw new NoTerminalError(
+      'borg launch-all: --mode windows requires a terminal emulator.\n' +
+        'Not found. Set $BORG_TERMINAL=<path> or use --mode tmux.\n'
+    );
+  }
+  for (let i = 0; i < candidates.length; i++) {
+    const c = candidates[i];
+    if (i > 0 && opts.launchDelayMs > 0) await opts.sleep(opts.launchDelayMs); // rate-limit stagger
+    const cmd = buildLaunchCommand(c.worktreeDir, opts.borgPath, { keepOpenOnFail: true });
+    // `<term> -e sh -c '<cmd>'` opens a new window running the command.
+    deps.runSync(term, ['-e', 'sh', '-c', cmd]);
+    writeLockMarker(deps, c.cubeId, c.droneLabel, c.worktreeDir, opts.launchedAtISO);
+  }
+}
+
+/**
+ * Control char (incl. newline) in a worktree path. SR f94bb3fe + Coordinator
+ * c6370c41 fold-in: a newline in the path breaks the macOS osascript AppleScript
+ * string literal (parse error). Reject such paths up front (the user's own path;
+ * pathological) — fail-loud + skip, never silently mangle. Applies to both
+ * platforms defensively (the tmux primary handles control chars fine via
+ * shellEscape + array-args, so this guard is windows-backend-specific).
+ */
+const CONTROL_CHAR_RE = /[\x00-\x1f\x7f]/;
+
+export async function runWindowsBackend(
+  candidates: DroneCandidate[],
+  opts: WindowsOpts,
+  deps: LaunchAllDeps
+): Promise<void> {
+  const safe = candidates.filter((c) => {
+    if (CONTROL_CHAR_RE.test(c.worktreeDir)) {
+      deps.stderr(
+        `skipping ${c.droneLabel} (${JSON.stringify(c.worktreeDir)}): worktree path contains a control ` +
+          `character — unsafe for --mode windows; use --mode tmux instead.\n`
+      );
+      return false;
+    }
+    return true;
+  });
+  if (opts.platform === 'darwin') {
+    await launchMacOS(safe, opts, deps);
+  } else {
+    await launchLinux(safe, opts, deps);
+  }
+}

package/src/bare-launch-menu.ts

@@ -0,0 +1,148 @@
+/**
+ * gh#853 — bare `borg` (no-args) interactive launch menu.
+ *
+ * When `borg` is run with NO arguments in a TTY, offer a small launch selector
+ * instead of launching immediately:
+ *   1. Launch (default)             — the configured agent (Enter selects).
+ *   2. Launch with <other> instead  — the OTHER installed agent, ONE-SHOT
+ *                                      (does NOT persist the preference).
+ *   3. Launch all                   — runLaunchAll for the active cube.
+ *
+ * The option-set, the selection→action mapping, and the show/collapse decision
+ * are pure functions so they're unit-testable without a real TTY. claude.ts
+ * main() is thin glue: it computes the inputs (default cli, other-installed cli,
+ * launch-all targets), gates on shouldShowLaunchMenu, runs the orchestrator with
+ * the real readline prompt, then dispatches the returned action.
+ *
+ * Load-bearing safety: TTY-only + bare-args-only (shouldShowLaunchMenu) so every
+ * scripted/programmatic `borg` and every explicit subcommand/flag is untouched.
+ */
+import type { BorgCli } from './cubes.js';
+
+export type LaunchMenuAction =
+  | { kind: 'launch'; cli: BorgCli }
+  | { kind: 'launch-all' };
+
+export interface LaunchMenuOption {
+  /** The keystroke that selects this option (sequential: '1', '2', …). */
+  key: string;
+  label: string;
+  action: LaunchMenuAction;
+}
+
+export interface LaunchMenuInputs {
+  /** The configured/resolved current agent (option 1). */
+  defaultCli: BorgCli;
+  /** All installed agents that are NOT the default, in display order. */
+  otherInstalledClis: BorgCli[];
+  /** True iff there's an active cube with >=1 discoverable drone (option 3). */
+  hasLaunchAllTargets: boolean;
+}
+
+const PRETTY: Record<BorgCli, string> = { claude: 'Claude', codex: 'Codex', opencode: 'OpenCode' };
+
+/**
+ * Gate: the menu fires ONLY for bare `borg` (no args) in a TTY. Any explicit
+ * subcommand/flag, or a non-TTY (piped/scripted/CI) invocation, falls straight
+ * through to the existing default launch — no menu, no behavior change.
+ */
+export function shouldShowLaunchMenu(args: {
+  extraArgs: string[];
+  stdinIsTTY: boolean;
+  stdoutIsTTY: boolean;
+}): boolean {
+  return args.extraArgs.length === 0 && args.stdinIsTTY && args.stdoutIsTTY;
+}
+
+export function explicitCliLaunchHint(args: {
+  explicitCli: BorgCli | undefined;
+  stdinIsTTY: boolean;
+  stdoutIsTTY: boolean;
+  hasActiveCube: boolean;
+  hasLaunchAllTargets: boolean;
+}): string | null {
+  if (!args.explicitCli || !args.stdinIsTTY || !args.stdoutIsTTY) return null;
+  if (!args.hasActiveCube || !args.hasLaunchAllTargets) return null;
+  return `borg --cli ${args.explicitCli} launches ${PRETTY[args.explicitCli]} directly; use bare borg for the launch menu or borg launch-all --cli ${args.explicitCli} for all drone worktrees.\n`;
+}
+
+export function shouldResolveExplicitCliLaunchHintTargets(args: {
+  explicitCli: BorgCli | undefined;
+  stdinIsTTY: boolean;
+  stdoutIsTTY: boolean;
+  hasActiveCube: boolean;
+}): boolean {
+  return Boolean(args.explicitCli && args.stdinIsTTY && args.stdoutIsTTY && args.hasActiveCube);
+}
+
+/**
+ * The context-filtered option set. Option 1 is always present; options 2/3 are
+ * included only when applicable. Keys are sequential with no gaps, so a hidden
+ * middle option never produces a "1) … 3) …" gap menu.
+ */
+export function buildLaunchMenuOptions(inputs: LaunchMenuInputs): LaunchMenuOption[] {
+  const options: LaunchMenuOption[] = [
+    {
+      key: '1',
+      label: `Launch (default · ${PRETTY[inputs.defaultCli]})`,
+      action: { kind: 'launch', cli: inputs.defaultCli },
+    },
+  ];
+  for (const cli of inputs.otherInstalledClis) {
+    options.push({
+      key: String(options.length + 1),
+      label: `Launch with ${PRETTY[cli]} (one-shot)`,
+      action: { kind: 'launch', cli },
+    });
+  }
+  if (inputs.hasLaunchAllTargets) {
+    options.push({
+      key: String(options.length + 1),
+      label: "Launch all (this cube's drone worktrees)",
+      action: { kind: 'launch-all' },
+    });
+  }
+  return options;
+}
+
+/** Map a raw prompt answer to an action. Empty/Enter → option 1 (default). */
+export function resolveLaunchMenuChoice(
+  options: LaunchMenuOption[],
+  rawInput: string
+): { ok: true; action: LaunchMenuAction } | { ok: false } {
+  const trimmed = rawInput.trim();
+  if (trimmed === '') return { ok: true, action: options[0].action };
+  const match = options.find((o) => o.key === trimmed);
+  return match ? { ok: true, action: match.action } : { ok: false };
+}
+
+/** The rendered menu text (prompt suffix `[1]:` defaults to option 1 on Enter). */
+export function renderLaunchMenu(options: LaunchMenuOption[]): string {
+  const lines = options.map((o) => `  ${o.key}) ${o.label}`);
+  return `borg — how do you want to launch?\n${lines.join('\n')}\n[1]: `;
+}
+
+/**
+ * Orchestrate the menu with an injected readline-style prompt. Collapses to a
+ * direct default launch (no render, no prompt) when only option 1 applies.
+ * Re-prompts on invalid input up to `maxAttempts`, then falls back to the safe
+ * default (option 1) so a fat-fingered session still launches.
+ */
+export async function runBareLaunchMenu(
+  inputs: LaunchMenuInputs,
+  prompt: (message: string) => Promise<string>,
+  opts: { maxAttempts?: number; warn?: (message: string) => void } = {}
+): Promise<LaunchMenuAction> {
+  const options = buildLaunchMenuOptions(inputs);
+  if (options.length === 1) return options[0].action; // collapse — never a 1-item menu
+
+  const maxAttempts = opts.maxAttempts ?? 3;
+  const menu = renderLaunchMenu(options);
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    const raw = await prompt(attempt === 0 ? menu : `Invalid choice.\n${menu}`);
+    const res = resolveLaunchMenuChoice(options, raw);
+    if (res.ok) return res.action;
+    opts.warn?.(`invalid launch-menu selection: ${JSON.stringify(raw.trim())}`);
+  }
+  return options[0].action; // exhausted → safe default
+}

package/src/claude-launch-args.ts

@@ -0,0 +1,35 @@
+/**
+ * gh#702 — borg-launched Claude Code drones auto-allow the borg MCP
+ * coordination tools so a drone never prompts on borg_regen / borg_log /
+ * borg_ack / etc. mid-loop.
+ *
+ * SCOPED, by deliberate design (Option A, per-launch — avoids the gh#844
+ * settings-mutation/consent class):
+ *   - ONLY `mcp__borg__*` is auto-allowed. Bash, file edits (Read/Write/Edit),
+ *     web (WebFetch/WebSearch), and everything else STILL prompt. This is an
+ *     allowlist ADD, NOT `--dangerously-skip-permissions` and NOT a blanket
+ *     allow.
+ *   - Applied ONLY by the borg launcher (a per-invocation CLI flag) — there is
+ *     NO persistent user-settings write, so no consent gate is involved.
+ *   - claude only. Codex parity is a separate follow-up (different permission
+ *     model) — intentionally not handled here.
+ */
+
+/** The allowlist pattern matching every tool from the `borg` MCP server. */
+export const BORG_MCP_ALLOWED_TOOLS = 'mcp__borg__*';
+
+/**
+ * Build the argv for a borg-launched `claude` process: the user's passthrough
+ * args.
+ *
+ * ORDER IS LOAD-BEARING (CR blocker 0e5c697e): `--allowedTools` is a VARIADIC
+ * option (`<tools...>`, a space-separated list), so it greedily consumes every
+ * following non-flag argv element. If the kickoff prompt came AFTER it, claude
+ * would absorb the prompt as a 2nd "allowed tool" and launch with NO kickoff.
+ * So the kickoff positional goes FIRST and the variadic flag goes LAST, where
+ * it can only consume its own single value:
+ *   [...passthrough, kickoff, '--allowedTools', 'mcp__borg__*']
+ */
+export function buildClaudeLaunchArgs(passthroughArgs: string[], kickoff: string): string[] {
+  return [...passthroughArgs, kickoff, '--allowedTools', BORG_MCP_ALLOWED_TOOLS];
+}