sprag-cli 3.53.0 → 3.54.0

package/src/codex-panel-launcher.js

@@ -0,0 +1,48 @@
+import { execFileSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { fileURLToPath } from 'node:url';
+import { resolve } from 'node:path';
+import { codexUserDir } from './agent.js';
+
+const quote = (value) => `'${String(value).replace(/'/g, `'"'"'`)}'`;
+
+export function panelLaunchCommand(root, { node = process.execPath, cli = fileURLToPath(new URL('../bin/cli.js', import.meta.url)), home = codexUserDir(), sessionId, sessionFile } = {}) {
+  return ['env', `CODEX_HOME=${home}`, node, cli, 'panel', '--agent', 'codex', '--project', resolve(root),
+    ...(sessionId ? ['--session', sessionId] : []), ...(sessionFile ? ['--session-file', sessionFile] : [])]
+    .map(quote).join(' ');
+}
+
+export function openCodexPanel(root, { platform = process.platform, exec = execFileSync, ...options } = {}) {
+  if (platform !== 'darwin') throw new Error('Automatic panel windows currently require macOS Terminal. Run sprag panel --agent codex in a separate terminal.');
+  const identity = [options.home || codexUserDir(), options.sessionId ? `session\0${options.sessionId}` : `project\0${resolve(root)}`].join('\0');
+  const title = `Sprag | Codex | ${createHash('sha256').update(identity).digest('hex').slice(0, 16)}`;
+  // Arguments travel through osascript argv, never through AppleScript source.
+  // Reuse only the same session (or an explicitly project-following window).
+  const script = `on run argv
+set panelTitle to item 1 of argv
+set panelCommand to item 2 of argv
+tell application "Terminal"
+repeat with w in windows
+repeat with t in tabs of w
+if custom title of t is panelTitle then
+set miniaturized of w to false
+set visible of w to true
+set selected tab of w to t
+set index of w to 1
+activate
+if busy of t then return "already-open"
+do script panelCommand in t
+return "restarted"
+end if
+end repeat
+end repeat
+set t to do script panelCommand
+set custom title of t to panelTitle
+activate
+return "opened"
+end tell
+end run`;
+  return exec('/usr/bin/osascript', ['-e', script, title, panelLaunchCommand(root, options)], {
+    encoding: 'utf8', timeout: 8000, stdio: ['ignore', 'pipe', 'pipe'],
+  }).trim();
+}

package/src/codex-panel-runner.js

@@ -0,0 +1,74 @@
+import { execFileSync, spawnSync } from 'node:child_process';
+import { mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { tmpdir, homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { panelLaunchCommand } from './codex-panel-launcher.js';
+import { createPanelBinding } from './codex-panel-session.js';
+
+const quote = (s) => `'${String(s).replace(/'/g, `'"'"'`)}'`;
+
+export function resizeInlinePanel(rows, { exec = execFileSync, env = process.env, state } = {}) {
+  if (env.SPRAG_CODEX_PANEL !== '1' || !env.TMUX_PANE || !env.TMUX) return;
+  try {
+    const info = exec('tmux', ['display-message', '-p', '-t', env.TMUX_PANE, '#{window_height} #{pane_height} #{window_width}'], { encoding: 'utf8', timeout: 1000 }).trim().split(/\s+/).map(Number);
+    const size = `${info[2]}x${info[0]}`;
+    // Keep the high-water mark until the terminal is resized. Timer labels and
+    // disappearing warnings must not repeatedly resize the prompt above us.
+    const contentRows = state && state.size === size ? Math.max(rows, state.rows) : rows;
+    const wanted = Math.max(1, Math.min(contentRows + 1, info[0] - 11));
+    if (state) { state.size = size; state.rows = contentRows; }
+    if (Number.isFinite(wanted) && wanted !== info[1]) exec('tmux', ['resize-pane', '-t', env.TMUX_PANE, '-y', String(wanted)], { stdio: 'ignore' });
+  } catch { /* A disappearing client must not stop the panel. */ }
+}
+
+export function createInlinePanelResizer(options = {}) {
+  const state = {};
+  return (rows) => resizeInlinePanel(rows, { ...options, state });
+}
+
+// A private server leaves the user's tmux configuration and sessions untouched.
+export function runCodexWithPanel(args, { root = process.cwd(), codex = 'codex', tmux = 'tmux',
+  exec = execFileSync, spawn = spawnSync, tty = !!process.stdin.isTTY && !!process.stdout.isTTY,
+  env = process.env, columns = process.stdout.columns || 100, rows = process.stdout.rows || 30,
+  keepNativeStatusline = false } = {}) {
+  if (!tty) throw new Error('Panel run requires an interactive terminal. Use codex directly for scripts.');
+  const options = args.slice(0, args.indexOf('--') < 0 ? args.length : args.indexOf('--'));
+  if (options.some((arg) => arg === '--remote' || arg.startsWith('--remote='))) {
+    throw new Error('Inline panels require a local Codex process. For remote Codex, run codex directly and use a separate panel with --session ID and local logs.');
+  }
+  try { exec(tmux, ['-V'], { stdio: 'pipe' }); }
+  catch { throw new Error('The inline Codex panel requires tmux. Install it with brew install tmux on macOS.'); }
+  const socket = `sprag-${randomUUID()}`;
+  const base = ['-L', socket, '-f', '/dev/null'];
+  const dir = mkdtempSync(join(tmpdir(), 'sprag-codex-'));
+  const status = join(dir, 'exit');
+  const sessionFile = join(dir, 'session.json');
+  const home = resolve(env.CODEX_HOME || join(env.HOME || homedir(), '.codex'));
+  const childEnv = { ...env, TMUX: '', SPRAG_CODEX_PANEL: '1', SPRAG_CODEX_PANEL_BINDING: sessionFile };
+  // Hide duplicate model/effort only in this layout. Later caller overrides win;
+  // putting the default before args also preserves subcommands and `--` prompts.
+  const launchArgs = [...(options.includes('--no-daemon') ? [] : ['--no-daemon']),
+    ...(keepNativeStatusline ? [] : ['-c', 'tui.status_line=[]']), ...args];
+  const call = (argv) => exec(tmux, [...base, ...argv], { env: childEnv, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+  try {
+    createPanelBinding(sessionFile);
+    const tmuxCommand = [tmux, ...base].map(quote).join(' ');
+    const command = `${tmuxCommand} wait-for ready; ${[codex, ...launchArgs].map(quote).join(' ')}; result=$?; printf '%s' "$result" > ${quote(status)}; ${tmuxCommand} kill-session -t codex`;
+    const top = call(['new-session', '-d', '-P', '-F', '#{pane_id}', '-s', 'codex', '-c', process.cwd(),
+      '-x', String(columns), '-y', String(Math.max(16, rows)), command]).trim();
+    call(['set-option', '-t', 'codex', 'status', 'off']);
+    call(['set-option', '-t', 'codex', 'destroy-unattached', 'off']);
+    call(['split-window', '-d', '-v', '-l', '6', '-t', top,
+      `${panelLaunchCommand(resolve(root), { home, sessionFile })} --compact`]);
+    call(['select-pane', '-t', top]);
+    call(['wait-for', '-S', 'ready']);
+    const attached = spawn(tmux, [...base, 'attach-session', '-t', 'codex'], { env: childEnv, stdio: 'inherit' });
+    if (attached.error) throw attached.error;
+    try { return Number(readFileSync(status, 'utf8')); }
+    catch { return attached.status || 0; }
+  } finally {
+    try { call(['kill-server']); } catch { /* Already gone after normal exit. */ }
+    rmSync(dir, { recursive: true, force: true });
+  }
+}

package/src/codex-panel-session.js

@@ -0,0 +1,35 @@
+import { readFileSync, writeFileSync, renameSync } from 'node:fs';
+import { isAbsolute } from 'node:path';
+
+export function createPanelBinding(file) {
+  writeFileSync(file, JSON.stringify({ version: 1, sessionId: null, transcriptPath: null }), { mode: 0o600 });
+}
+
+export function readPanelBinding(file) {
+  try {
+    const data = JSON.parse(readFileSync(file, 'utf8'));
+    if (data.version !== 1) return null;
+    if (typeof data.sessionId !== 'string' || !data.sessionId.trim()) return null;
+    return { sessionId: data.sessionId,
+      transcriptPath: typeof data.transcriptPath === 'string' && isAbsolute(data.transcriptPath) ? data.transcriptPath : null };
+  } catch { return null; }
+}
+
+// The inline runner uses --no-daemon so this path belongs to this Codex process,
+// not an environment inherited by a shared server from a different terminal.
+export function bindPanelSession(event, payload, { file = process.env.SPRAG_CODEX_PANEL_BINDING } = {}) {
+  if (!file || !['session-start', 'panel-start'].includes(event)) return false;
+  if (!['startup', 'resume', 'clear', 'compact'].includes(payload?.source)) return false;
+  if (typeof payload.session_id !== 'string' || !payload.session_id.trim()) return false;
+  try {
+    // Never recreate a binding after its launcher has exited and cleaned up.
+    const current = JSON.parse(readFileSync(file, 'utf8'));
+    if (current.version !== 1) return false;
+    if (payload.source === 'compact' && current.sessionId && current.sessionId !== payload.session_id) return false;
+    const tmp = `${file}.${process.pid}.tmp`;
+    writeFileSync(tmp, JSON.stringify({ version: 1, sessionId: payload.session_id,
+      transcriptPath: typeof payload.transcript_path === 'string' && isAbsolute(payload.transcript_path) ? payload.transcript_path : null }), { mode: 0o600 });
+    renameSync(tmp, file);
+    return true;
+  } catch { return false; }
+}

package/src/codex-panel-shell.js

@@ -0,0 +1,51 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { homedir } from 'node:os';
+
+const BEGIN = '# >>> sprag codex panel >>>';
+const END = '# <<< sprag codex panel <<<';
+
+export const PANEL_SHELL_BLOCK = `${BEGIN}
+function codex() {
+  local sprag_root="$PWD" sprag_open=1 sprag_next=0 sprag_arg
+  case "\${1-}" in
+    exec|e|review|login|logout|mcp|plugin|app-server|remote-control|completion|update|doctor|sandbox|debug|apply|queue|archive|delete|migrate-rollouts|unarchive|cloud|exec-server|features|help|agents|app) sprag_open=0 ;;
+  esac
+  for sprag_arg in "$@"; do
+    if (( sprag_next )); then
+      sprag_root="$sprag_arg"
+      sprag_next=0
+      continue
+    fi
+    case "$sprag_arg" in
+      -C|--cd) sprag_next=1 ;;
+      --cd=*) sprag_root="\${sprag_arg#--cd=}" ;;
+      --help|-h|--version|-V) sprag_open=0 ;;
+    esac
+  done
+  if [[ -t 0 && -t 1 && "\${SPRAG_CODEX_PANEL-}" != 1 ]] && (( sprag_open )); then
+    command sprag panel run --agent codex -- "$@"
+    return $?
+  fi
+  command codex "$@"
+}
+${END}
+`;
+
+export function installPanelShell({ file = join(process.env.ZDOTDIR || homedir(), '.zshrc'), remove = false } = {}) {
+  const text = existsSync(file) ? readFileSync(file, 'utf8') : '';
+  const start = text.indexOf(BEGIN);
+  const end = text.indexOf(END);
+  if ((start < 0) !== (end < 0) || (start >= 0 && end < start)) throw new Error('Malformed Sprag shell block; repair it before installation.');
+  if (start < 0 && !remove && /(?:function\s+codex\b|\bcodex\s*\(\)|\balias\s+codex=)/m.test(text)) {
+    throw new Error('An existing codex alias/function is present; keeping it unchanged.');
+  }
+  const next = start >= 0 ? text.slice(0, start) + (remove ? '' : PANEL_SHELL_BLOCK.trimEnd()) + text.slice(end + END.length)
+    : remove ? text : text + (text.endsWith('\n') || !text ? '' : '\n') + PANEL_SHELL_BLOCK;
+  if (next !== text) {
+    mkdirSync(dirname(file), { recursive: true });
+    if (text) writeFileSync(`${file}.bak-${Date.now()}`, text);
+    writeFileSync(file, next);
+  }
+  return file;
+}

package/src/codex-panel-state.js

@@ -0,0 +1,40 @@
+import { createHash } from 'node:crypto';
+import { readFileSync, writeFileSync, mkdirSync, renameSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { userDataDir } from './paths.js';
+import { codexUserDir } from './agent.js';
+
+export function panelStatePath(root, kind, dir = userDataDir(), sessionId) {
+  const key = createHash('sha256').update(codexUserDir() + '\0' + resolve(root) + (sessionId ? `\0${sessionId}` : '')).digest('hex');
+  return join(dir, `codex-panel-${key}-${kind}.json`);
+}
+
+export function recordPanelState(root, kind, value, dir = userDataDir()) {
+  try {
+    mkdirSync(dir, { recursive: true });
+    const file = panelStatePath(root, kind, dir);
+    const tmp = `${file}.${process.pid}.tmp`;
+    const text = JSON.stringify({ ...value, at: new Date().toISOString() });
+    writeFileSync(tmp, text);
+    renameSync(tmp, file);
+    if (value.sessionId) {
+      const sessionFile = panelStatePath(root, kind, dir, value.sessionId);
+      const sessionTmp = `${sessionFile}.${process.pid}.tmp`;
+      writeFileSync(sessionTmp, text);
+      renameSync(sessionTmp, sessionFile);
+    }
+  } catch { /* Diagnostics must not stop a session or panel. */ }
+}
+
+export function readPanelState(root, kind, dir = userDataDir(), sessionId) {
+  try { return JSON.parse(readFileSync(panelStatePath(root, kind, dir, sessionId), 'utf8')); }
+  catch { return null; }
+}
+
+export function panelHealth(root, { now = Date.now(), dir, sessionId } = {}) {
+  const hook = readPanelState(root, 'hook', dir, sessionId);
+  const frame = readPanelState(root, 'frame', dir, sessionId);
+  const age = frame ? now - Date.parse(frame.at) : Infinity;
+  const live = frame?.status === 'rendered' && age >= 0 && age < 15000;
+  return { hook, frame, live };
+}