jbai-cli 1.9.2 → 2.1.0

package/bin/jbai-council.js

@@ -0,0 +1,665 @@
+#!/usr/bin/env node
+
+const { spawnSync } = require('child_process');
+const path = require('path');
+const { ensureToken } = require('../lib/ensure-token');
+const { PROXY_PORT, ensureProxy } = require('../lib/proxy');
+
+const SESSION_NAME = 'jbai-council';
+
+const AGENTS = [
+  { name: 'claude', command: 'jbai-claude', extraArgs: ['--allow-dangerously-skip-permissions'] },
+  { name: 'codex', command: 'jbai-codex' },
+  { name: 'opencode', command: 'jbai-opencode' },
+];
+
+// Catppuccin Mocha color palette (truecolor ANSI escape sequences)
+const C = {
+  blue:    '\x1b[38;2;137;180;250m',  // #89b4fa — primary
+  green:   '\x1b[38;2;166;227;161m',  // #a6e3a1 — success
+  red:     '\x1b[38;2;243;139;168m',  // #f38ba8 — error
+  yellow:  '\x1b[38;2;249;226;175m',  // #f9e2af — warning
+  mauve:   '\x1b[38;2;203;166;247m',  // #cba6f7 — claude
+  teal:    '\x1b[38;2;148;226;213m',  // #94e2d5 — opencode
+  peach:   '\x1b[38;2;250;179;135m',  // #fab387 — codex
+  text:    '\x1b[38;2;205;214;244m',  // #cdd6f4 — default text
+  muted:   '\x1b[38;2;127;132;156m',  // #7f849c — dim text
+  surface: '\x1b[38;2;69;71;90m',     // #45475a — borders
+  bold:    '\x1b[1m',
+  dim:     '\x1b[2m',
+  reset:   '\x1b[0m',
+};
+
+// Agent display colors
+const AGENT_COLORS = {
+  claude:   C.mauve,
+  codex:    C.peach,
+  opencode: C.teal,
+};
+
+function tmux(args, options = {}) {
+  const result = spawnSync('tmux', args, { encoding: 'utf-8', ...options });
+  if (result.error) {
+    throw result.error;
+  }
+  if (result.status !== 0) {
+    const stderr = (result.stderr || '').toString().trim();
+    const stdout = (result.stdout || '').toString().trim();
+    const message = stderr || stdout || `tmux ${args.join(' ')} failed`;
+    const err = new Error(message);
+    err.code = result.status;
+    throw err;
+  }
+  return (result.stdout || '').toString().trim();
+}
+
+function tmuxSafe(args, options = {}) {
+  try {
+    return tmux(args, options);
+  } catch {
+    return null;
+  }
+}
+
+function isTmuxInstalled() {
+  const result = spawnSync('tmux', ['-V'], { stdio: 'pipe' });
+  return result.status === 0;
+}
+
+function isSessionAlive() {
+  return tmuxSafe(['has-session', '-t', SESSION_NAME]) !== null;
+}
+
+function killExistingSession() {
+  tmuxSafe(['kill-session', '-t', SESSION_NAME]);
+}
+
+function getWindowId() {
+  const output = tmux(['list-windows', '-t', SESSION_NAME, '-F', '#{window_id}']);
+  const first = output.split('\n').find(Boolean);
+  if (!first) {
+    throw new Error('No windows found for council session.');
+  }
+  return first.trim();
+}
+
+function listPanes(windowId) {
+  const format = '#{pane_id}\t#{pane_left}\t#{pane_top}\t#{pane_width}\t#{pane_height}';
+  const output = tmux(['list-panes', '-t', windowId, '-F', format]);
+  return output
+    .split('\n')
+    .filter(Boolean)
+    .map((line) => {
+      const [id, left, top, width, height] = line.split('\t');
+      return {
+        id,
+        left: Number(left),
+        top: Number(top),
+        width: Number(width),
+        height: Number(height),
+      };
+    });
+}
+
+function getPaneMap() {
+  const windowId = getWindowId();
+  const panes = listPanes(windowId);
+  if (panes.length < 4) {
+    throw new Error(`Expected 4 panes, found ${panes.length}`);
+  }
+
+  const topRowTop = Math.min(...panes.map(p => p.top));
+  const topPanes = panes.filter(p => p.top === topRowTop).sort((a, b) => a.left - b.left);
+  const bottomPanes = panes
+    .filter(p => p.top !== topRowTop)
+    .sort((a, b) => b.top - a.top || a.left - b.left);
+
+  if (topPanes.length < 3) {
+    throw new Error(`Expected 3 top panes, found ${topPanes.length}`);
+  }
+
+  return {
+    windowId,
+    orchestratorPane: bottomPanes[0] ? bottomPanes[0].id : null,
+    paneMap: {
+      claude: topPanes[0].id,
+      codex: topPanes[1].id,
+      opencode: topPanes[2].id,
+    },
+  };
+}
+
+function sendKeys(paneId, keys) {
+  tmux(['send-keys', '-t', paneId, ...keys]);
+}
+
+function sendKeysLiteral(paneId, text) {
+  tmux(['send-keys', '-t', paneId, '-l', text]);
+}
+
+// POSIX-safe shell argument escaping. Wraps in single quotes and escapes
+// embedded single quotes with the '\'' pattern. Safe for arbitrary input
+// including paths with spaces, semicolons, backticks, etc.
+function shellEscapeArg(value) {
+  if (value === '') return "''";
+  if (/^[A-Za-z0-9_\/.:=-]+$/.test(value)) return value;
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}
+
+function buildAgentCommand(scriptPath, superMode, extraArgs = []) {
+  const args = [process.execPath, scriptPath];
+  if (superMode) args.push('--super');
+  args.push(...extraArgs);
+  return args.map(shellEscapeArg).join(' ');
+}
+
+function createSession(superMode) {
+  const cwd = process.cwd();
+
+  tmux(['new-session', '-d', '-s', SESSION_NAME, '-x', '200', '-y', '50']);
+
+  // Enable extended-keys so Shift+Enter passthrough works (kitty protocol)
+  tmuxSafe(['set-option', '-t', SESSION_NAME, 'extended-keys', 'on']);
+
+  const windowId = getWindowId();
+
+  // Split FULL-WIDTH bottom pane for orchestrator FIRST, before columnar splits.
+  // This ensures the orchestrator spans the entire terminal width.
+  tmux(['split-window', '-v', '-t', windowId, '-l', '10']);
+
+  // Now split the TOP pane into 3 vertical columns.
+  // After the vertical split: top pane is still selected, bottom is orchestrator.
+  // We need to target the top pane specifically.
+  const panesAfterV = listPanes(windowId);
+  const topPane = panesAfterV.reduce((a, b) => (a.top < b.top ? a : b));
+  tmux(['split-window', '-h', '-t', topPane.id, '-p', '66']);
+  // Now the top area has 2 panes: left (34%) and right (66%). Split right in half.
+  const panesAfterH1 = listPanes(windowId);
+  const topPanes = panesAfterH1
+    .filter(p => p.top === topPane.top)
+    .sort((a, b) => a.left - b.left);
+  const rightPane = topPanes[topPanes.length - 1];
+  tmux(['split-window', '-h', '-t', rightPane.id, '-p', '50']);
+
+  const { orchestratorPane, paneMap } = getPaneMap();
+  if (!orchestratorPane) {
+    throw new Error('Unable to find orchestrator pane after layout.');
+  }
+
+  const binDir = __dirname;
+  const cwdEscaped = shellEscapeArg(cwd);
+
+  for (const agent of AGENTS) {
+    const paneId = paneMap[agent.name];
+    const scriptPath = path.join(binDir, `${agent.command}.js`);
+    const cmd = `cd ${cwdEscaped} && ${buildAgentCommand(scriptPath, superMode, agent.extraArgs || [])}`;
+    sendKeysLiteral(paneId, cmd);
+    sendKeys(paneId, ['Enter']);
+  }
+
+  const orchScript = path.join(binDir, 'jbai-council.js');
+  const orchCmd = `cd ${cwdEscaped} && ${buildAgentCommand(orchScript, false, ['--_orchestrator'])}`;
+  sendKeysLiteral(orchestratorPane, orchCmd);
+  sendKeys(orchestratorPane, ['Enter']);
+
+  tmux(['select-pane', '-t', orchestratorPane]);
+
+  return { orchestratorPane, paneMap };
+}
+
+function runOrchestrator() {
+  let paneMap;
+  try {
+    paneMap = getPaneMap().paneMap;
+  } catch (err) {
+    console.error(`Failed to detect panes: ${err.message}`);
+    process.exit(1);
+  }
+
+  const agentNames = Object.keys(paneMap);
+
+  const agentList = agentNames
+    .map(n => `${AGENT_COLORS[n] || C.text}${n}${C.reset}`)
+    .join(`${C.muted}, ${C.reset}`);
+
+  console.log('');
+  console.log(`${C.blue}${C.bold}  council${C.reset}${C.muted} — multi-agent orchestrator${C.reset}`);
+  console.log(`${C.surface}  ${'─'.repeat(44)}${C.reset}`);
+  console.log(`${C.muted}  agents: ${C.reset}${agentList}`);
+  console.log(`${C.muted}  broadcast: ${C.text}type normally${C.muted}  target: ${C.text}@agent <msg>${C.reset}`);
+  console.log(`${C.muted}  multiline: ${C.text}Alt+Enter${C.muted} or ${C.text}Shift+Enter${C.muted} for new line${C.reset}`);
+  console.log(`${C.muted}  /focus /status /quit /help${C.reset}`);
+  console.log('');
+
+  // --- Raw stdin multiline input handler ---
+  const lines = [''];
+  let currentLine = 0;
+  let renderedRowCount = 0;
+
+  const promptPrefix = `${C.blue}${C.bold}council${C.reset}${C.muted}>${C.reset} `;
+  const continuationPrefix = `${C.muted}       │${C.reset} `;
+
+  const ANSI_PATTERN = /\x1b\[[0-9;?]*[ -/]*[@-~]/g;
+
+  function stripAnsi(text) {
+    return text.replace(ANSI_PATTERN, '');
+  }
+
+  function visibleWidth(text, startColumn = 0) {
+    const clean = stripAnsi(text);
+    let col = startColumn;
+    for (const ch of clean) {
+      if (ch === '\t') {
+        const nextTab = 8 - (col % 8);
+        col += nextTab;
+      } else if (ch === '\r' || ch === '\n') {
+        col = 0;
+      } else if (ch >= '\x00' && ch <= '\x1f') {
+        // Control chars: ignore for width calculation
+      } else {
+        col += 1;
+      }
+    }
+    return col - startColumn;
+  }
+
+  function rowsForLine(prefixLen, lineText, cols) {
+    const contentWidth = visibleWidth(lineText, prefixLen);
+    const total = prefixLen + contentWidth;
+    const width = Math.max(cols, 1);
+    return Math.max(1, Math.ceil(total / width));
+  }
+
+  function renderPrompt() {
+    const cols = process.stdout.columns || 80;
+
+    // Move cursor up to clear previous render
+    if (renderedRowCount > 1) {
+      process.stdout.write(`\x1b[${renderedRowCount - 1}A`);
+    }
+    // Go to start of line, clear everything below
+    process.stdout.write('\r\x1b[J');
+
+    renderedRowCount = 0;
+    for (let i = 0; i < lines.length; i++) {
+      if (i > 0) process.stdout.write('\n');
+      const prefix = i === 0 ? promptPrefix : continuationPrefix;
+      process.stdout.write(`${prefix}${lines[i]}`);
+      const prefixLen = visibleWidth(prefix);
+      renderedRowCount += rowsForLine(prefixLen, lines[i], cols);
+    }
+  }
+
+  function resetInput() {
+    lines.length = 0;
+    lines.push('');
+    currentLine = 0;
+    renderedRowCount = 0;
+  }
+
+  function insertNewline() {
+    lines.splice(currentLine + 1, 0, '');
+    currentLine++;
+    renderPrompt();
+  }
+
+  function backspace() {
+    if (lines[currentLine].length > 0) {
+      lines[currentLine] = lines[currentLine].slice(0, -1);
+    } else if (currentLine > 0) {
+      lines.splice(currentLine, 1);
+      currentLine--;
+    }
+    renderPrompt();
+  }
+
+  function submit() {
+    const text = lines.join('\n');
+    const hasContent = text.trim().length > 0;
+    process.stdout.write('\n');
+    resetInput();
+
+    if (!hasContent) {
+      renderPrompt();
+      return;
+    }
+
+    if (text.startsWith('/')) {
+      handleCommand(text, paneMap);
+      renderPrompt();
+      return;
+    }
+
+    const atMatch = text.match(/^@(\w+)\s+([\s\S]+)$/);
+    if (atMatch) {
+      const target = atMatch[1].toLowerCase();
+      const message = atMatch[2];
+      if (paneMap[target]) {
+        sendToPane(paneMap[target], message, target);
+        const color = AGENT_COLORS[target] || C.text;
+        console.log(`${C.dim}  → ${color}${target}${C.reset}`);
+      } else {
+        console.log(`${C.red}  unknown agent: ${C.text}${target}${C.muted} — use ${agentNames.join(', ')}${C.reset}`);
+      }
+      renderPrompt();
+      return;
+    }
+
+    for (const agent of agentNames) {
+      sendToPane(paneMap[agent], text, agent);
+    }
+    console.log(`${C.dim}  → ${C.blue}all agents${C.reset}`);
+    renderPrompt();
+  }
+
+  // Enable bracketed paste mode for reliable paste detection
+  process.stdout.write('\x1b[?2004h');
+
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(true);
+  }
+  process.stdin.resume();
+  if (process.stdout.isTTY) {
+    process.stdout.on('resize', renderPrompt);
+  }
+
+  const PASTE_START = '\x1b[200~';
+  const PASTE_END = '\x1b[201~';
+
+  let inPaste = false;
+  let pasteBuffer = '';
+  let pending = '';
+  let escapeBuffer = '';
+  let ignoreNextLF = false;
+
+  function longestPartialSuffix(buffer, sequence) {
+    const max = Math.min(sequence.length - 1, buffer.length);
+    for (let len = max; len > 0; len--) {
+      if (sequence.startsWith(buffer.slice(-len))) {
+        return len;
+      }
+    }
+    return 0;
+  }
+
+  function handleEscapeSequence() {
+    if (escapeBuffer === '\x1b\r' || escapeBuffer === '\x1b\n') {
+      insertNewline();
+      return true;
+    }
+    if (escapeBuffer === '\x1b[13;2u') {
+      insertNewline();
+      return true;
+    }
+    if (/^\x1b\[[0-9;]*[A-Za-z~]$/.test(escapeBuffer)) {
+      return true;
+    }
+    if (escapeBuffer.length > 8) {
+      return true;
+    }
+    return false;
+  }
+
+  function handleInput(text) {
+    if (!text) return;
+    for (let i = 0; i < text.length; i++) {
+      const ch = text[i];
+
+      if (escapeBuffer) {
+        escapeBuffer += ch;
+        if (handleEscapeSequence()) {
+          escapeBuffer = '';
+        }
+        continue;
+      }
+
+      if (ch === '\x1b') {
+        escapeBuffer = '\x1b';
+        continue;
+      }
+
+      if (ignoreNextLF && ch !== '\n') {
+        ignoreNextLF = false;
+      }
+
+      if (ch === '\r') {
+        submit();
+        ignoreNextLF = true;
+      } else if (ch === '\n') {
+        if (ignoreNextLF) {
+          ignoreNextLF = false;
+        } else {
+          submit();
+        }
+      } else if (ch === '\x7f' || ch === '\b') {
+        backspace();
+      } else if (ch === '\x03') {
+        // Ctrl+C → exit
+        process.stdout.write('\x1b[?2004l\n'); // disable bracketed paste
+        process.exit(0);
+      } else if (ch === '\x04') {
+        // Ctrl+D → exit if empty
+        if (lines.join('').length === 0) {
+          process.stdout.write('\x1b[?2004l\n');
+          process.exit(0);
+        }
+      } else {
+        // Printable characters
+        lines[currentLine] += ch;
+        renderPrompt();
+      }
+    }
+  }
+
+  function processChunk(chunk) {
+    pending += chunk;
+
+    while (pending.length > 0) {
+      if (inPaste) {
+        const endIndex = pending.indexOf(PASTE_END);
+        if (endIndex === -1) {
+          const keep = longestPartialSuffix(pending, PASTE_END);
+          pasteBuffer += pending.slice(0, pending.length - keep);
+          pending = pending.slice(pending.length - keep);
+          return;
+        }
+        pasteBuffer += pending.slice(0, endIndex);
+        pending = pending.slice(endIndex + PASTE_END.length);
+        inPaste = false;
+        handlePaste(pasteBuffer);
+        pasteBuffer = '';
+        continue;
+      }
+
+      const startIndex = pending.indexOf(PASTE_START);
+      if (startIndex === -1) {
+        const keep = longestPartialSuffix(pending, PASTE_START);
+        handleInput(pending.slice(0, pending.length - keep));
+        pending = pending.slice(pending.length - keep);
+        return;
+      }
+
+      handleInput(pending.slice(0, startIndex));
+      pending = pending.slice(startIndex + PASTE_START.length);
+      inPaste = true;
+    }
+  }
+
+  process.stdin.on('data', (data) => {
+    const chunk = data.toString('utf-8');
+    processChunk(chunk);
+  });
+
+  function handlePaste(text) {
+    const pasteLines = text.split(/\r\n|\r|\n/);
+    lines[currentLine] += pasteLines[0];
+    for (let i = 1; i < pasteLines.length; i++) {
+      lines.push(pasteLines[i]);
+      currentLine++;
+    }
+    renderPrompt();
+  }
+
+  renderPrompt();
+}
+
+function sendToPane(paneId, text, agentName) {
+  try {
+    if (agentName === 'codex') {
+      // Codex sometimes ignores paste+Enter. Send as typed input, then Enter slightly later.
+      tmux(['send-keys', '-t', paneId, '-l', text]);
+      setTimeout(() => {
+        try {
+          sendKeys(paneId, ['Enter']);
+        } catch {
+          // Pane may be gone
+        }
+      }, 150);
+      return;
+    }
+
+    // Use tmux set-buffer + paste-buffer for reliable delivery.
+    // send-keys -l delivers chars individually which some TUI frameworks
+    // may not process atomically before the Enter arrives.
+    // paste-buffer delivers the full text as a single paste event.
+    const payload = text.endsWith('\n') ? text : `${text}\n`;
+    tmux(['set-buffer', '-b', 'council-input', '--', payload]);
+    tmux(['paste-buffer', '-b', 'council-input', '-t', paneId, '-d']);
+  } catch {
+    // Pane may be gone
+  }
+}
+
+function handleCommand(input, paneMap) {
+  const parts = input.split(/\s+/);
+  const cmd = parts[0].toLowerCase();
+
+  switch (cmd) {
+    case '/focus': {
+      const target = (parts[1] || '').toLowerCase();
+      if (paneMap[target]) {
+        const color = AGENT_COLORS[target] || C.text;
+        console.log(`${C.dim}  → focusing ${color}${target}${C.reset}${C.muted} (Ctrl+B ↑ to return)${C.reset}`);
+        try {
+          tmux(['select-pane', '-t', paneMap[target]]);
+        } catch {
+          console.log(`${C.red}  failed to focus pane${C.reset}`);
+        }
+      } else {
+        console.log(`${C.muted}  usage: ${C.text}/focus ${C.blue}<claude|codex|opencode>${C.reset}`);
+      }
+      break;
+    }
+    case '/status': {
+      for (const [name, paneId] of Object.entries(paneMap)) {
+        const color = AGENT_COLORS[name] || C.text;
+        try {
+          const pid = tmux(['display-message', '-p', '-t', paneId, '#{pane_pid}']);
+          try {
+            process.kill(Number(pid), 0);
+            console.log(`  ${C.green}●${C.reset} ${color}${name}${C.muted}  pid ${pid}${C.reset}`);
+          } catch {
+            console.log(`  ${C.red}●${C.reset} ${color}${name}${C.muted}  stopped${C.reset}`);
+          }
+        } catch {
+          console.log(`  ${C.red}●${C.reset} ${color}${name}${C.muted}  pane not found${C.reset}`);
+        }
+      }
+      break;
+    }
+    case '/help': {
+      console.log(`${C.muted}  broadcast:  ${C.text}type normally`);
+      console.log(`${C.muted}  target:     ${C.text}@claude ${C.muted}/ ${C.text}@codex ${C.muted}/ ${C.text}@opencode ${C.muted}<msg>`);
+      console.log(`${C.muted}  multiline:  ${C.text}Alt+Enter ${C.muted}or ${C.text}Shift+Enter ${C.muted}for new line`);
+      console.log(`${C.muted}  /focus      ${C.text}switch to agent pane`);
+      console.log(`${C.muted}  /status     ${C.text}show agent status`);
+      console.log(`${C.muted}  /quit       ${C.text}kill all and exit`);
+      console.log(`${C.muted}  /help       ${C.text}show this help${C.reset}`);
+      break;
+    }
+    case '/quit':
+    case '/exit': {
+      console.log(`${C.muted}  killing council session...${C.reset}`);
+      try {
+        tmux(['kill-session', '-t', SESSION_NAME]);
+      } catch {
+        // Session may already be dead
+      }
+      process.exit(0);
+    }
+    default:
+      console.log(`${C.red}  unknown command: ${C.text}${cmd}${C.muted} — try /help${C.reset}`);
+  }
+}
+
+(async () => {
+  const args = process.argv.slice(2);
+
+  if (args.includes('--_orchestrator')) {
+    runOrchestrator();
+    return;
+  }
+
+  const superFlags = ['--super', '--yolo', '-s'];
+  const superMode = args.some(a => superFlags.includes(a));
+  const helpMode = args.some(a => ['--help', '-h'].includes(a));
+
+  if (helpMode) {
+    console.log(`jbai-council - Launch Claude + Codex + OpenCode in tmux council mode
+
+Usage:
+  jbai-council              Launch all 3 agents
+  jbai-council --super      Launch all agents in super mode
+
+Requires: tmux (brew install tmux)
+
+Inside the council:
+  Type normally              Broadcast to all agents
+  @claude <msg>              Send only to Claude
+  @codex <msg>               Send only to Codex
+  @opencode <msg>            Send only to OpenCode
+  /focus <agent>             Switch to agent pane (Ctrl+B arrows to return)
+  /status                    Show agent status
+  /quit or /exit             Kill all agents and exit
+`);
+    return;
+  }
+
+  if (!isTmuxInstalled()) {
+    console.error('tmux is not installed.');
+    console.error('Install with: brew install tmux');
+    process.exit(1);
+  }
+
+  const insideTmux = Boolean(process.env.TMUX);
+
+  if (insideTmux && isSessionAlive()) {
+    console.error('Council session already running. Switching to it...');
+    tmux(['switch-client', '-t', SESSION_NAME], { stdio: 'inherit' });
+    return;
+  }
+
+  if (isSessionAlive()) {
+    console.log('Existing council session found. Attaching...');
+    tmux(['attach', '-t', SESSION_NAME], { stdio: 'inherit' });
+    return;
+  }
+
+  await ensureToken();
+  await ensureProxy();
+
+  console.log(`${C.blue}${C.bold}council${C.reset}${C.muted} starting ${C.mauve}claude${C.muted} + ${C.peach}codex${C.muted} + ${C.teal}opencode${C.muted}...${C.reset}`);
+  createSession(superMode);
+
+  if (insideTmux) {
+    tmux(['switch-client', '-t', SESSION_NAME], { stdio: 'inherit' });
+  } else {
+    tmux(['attach', '-t', SESSION_NAME], { stdio: 'inherit' });
+  }
+})().catch((err) => {
+  console.error(`Error: ${err.message}`);
+  if (isSessionAlive()) {
+    killExistingSession();
+  }
+  process.exit(1);
+});

package/bin/jbai-gemini-3.1.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+require('../lib/shortcut').run({
+  tool: 'gemini',
+  model: 'gemini-3.1-pro-preview',
+  label: 'Gemini + 3.1 Pro Preview',
+});

package/bin/jbai-gemini-supernova.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+require('../lib/shortcut').run({
+  tool: 'gemini',
+  model: 'supernova',
+  label: 'Gemini + Supernova (Google EAP)',
+});