@bramblex/codex-workbench 0.1.14 → 0.1.15

package/src/model/session-store.js

@@ -2,118 +2,44 @@
 
 const fs = require('fs');
 const path = require('path');
-const { META_PATH, SESSIONS_DIR } = require('../config');
+const { loadMeta, removeMetadata, updateMetadata } = require('./metadata');
+const { getAllSessionFiles, getProvider } = require('../providers');
 
-function readJson(file, fallback) {
-  try {
-    return JSON.parse(fs.readFileSync(file, 'utf8'));
-  } catch {
-    return fallback;
-  }
-}
-
-function writeJson(file, value) {
-  fs.mkdirSync(path.dirname(file), { recursive: true });
-  fs.writeFileSync(file, JSON.stringify(value, null, 2) + '\n');
-}
-
-function walk(dir, out = []) {
-  let entries = [];
-  try {
-    entries = fs.readdirSync(dir, { withFileTypes: true });
-  } catch {
-    return out;
-  }
-  for (const entry of entries) {
-    const full = path.join(dir, entry.name);
-    if (entry.isDirectory()) walk(full, out);
-    else if (entry.isFile() && entry.name.endsWith('.jsonl')) out.push(full);
-  }
-  return out;
-}
+// ---------------------------------------------------------------------------
+// Metadata persistence (provider-agnostic: keyed by session id)
+// ---------------------------------------------------------------------------
 
-function textFromContent(content) {
-  if (!Array.isArray(content)) return '';
-  return content
-    .filter((item) => item && (item.type === 'input_text' || item.type === 'output_text'))
-    .map((item) => item.text || '')
-    .join(' ')
-    .replace(/\s+/g, ' ')
-    .trim();
-}
-
-function isNoiseUserText(text) {
-  return text.includes('<environment_context>') || text.includes('<permissions instructions>');
-}
+// ---------------------------------------------------------------------------
+// Session listing (aggregates across all providers)
+// ---------------------------------------------------------------------------
 
-function parseSession(file) {
-  const stat = fs.statSync(file);
-  const raw = fs.readFileSync(file, 'utf8').trim();
-  const lines = raw ? raw.split(/\n/) : [];
-  let meta = {};
-  const messages = [];
-  let turns = 0;
+function listSessions() {
+  const meta = loadMeta();
+  const fileEntries = getAllSessionFiles();
 
-  for (const line of lines) {
-    let row;
+  const sessions = [];
+  for (const { file, backend } of fileEntries) {
     try {
-      row = JSON.parse(line);
-    } catch {
-      continue;
-    }
-    if (row.type === 'session_meta') meta = row.payload || {};
-    if (row.type === 'response_item' && row.payload && row.payload.type === 'message') {
-      const msg = row.payload;
-      if (msg.role === 'developer') continue;
-      const text = textFromContent(msg.content);
-      if (!text) continue;
-      if (msg.role === 'user' && isNoiseUserText(text)) continue;
-      messages.push({
-        role: msg.role,
-        phase: msg.phase || '',
-        text,
-      });
-      if (msg.role === 'user') turns += 1;
+      const provider = getProvider(backend);
+      const session = provider.parseSession(file);
+      // Merge workbench metadata (name, note, archived)
+      const custom = meta.sessions[session.id] || {};
+      sessions.push({ ...session, ...custom });
+    } catch (_err) {
+      // Skip unparseable files
     }
   }
 
-  const id = meta.id || path.basename(file, '.jsonl').split('-').slice(-5).join('-');
-  const firstUser = messages.find((msg) => msg.role === 'user');
-  const lastUser = [...messages].reverse().find((msg) => msg.role === 'user');
-  const lastAssistant = [...messages].reverse().find((msg) => msg.role === 'assistant');
-
-  return {
-    id,
-    file,
-    cwd: meta.cwd || '(unknown)',
-    startedAt: meta.timestamp || null,
-    updatedAt: stat.mtime.toISOString(),
-    cliVersion: meta.cli_version || '',
-    source: meta.source || '',
-    provider: meta.model_provider || '',
-    turns,
-    first: firstUser ? firstUser.text : '',
-    last: lastUser ? lastUser.text : '',
-    lastAssistant: lastAssistant ? lastAssistant.text : '',
-    messages,
-  };
+  sessions.sort((a, b) => new Date(b.updatedAt) - new Date(a.updatedAt));
+  return sessions;
 }
 
-function loadMeta() {
-  const data = readJson(META_PATH, { sessions: {} });
-  if (!data.sessions) data.sessions = {};
-  return data;
-}
-
-function listSessions() {
-  const meta = loadMeta();
-  return walk(SESSIONS_DIR)
-    .map(parseSession)
-    .map((session) => ({ ...session, ...(meta.sessions[session.id] || {}) }))
-    .sort((a, b) => new Date(b.updatedAt) - new Date(a.updatedAt));
-}
+// ---------------------------------------------------------------------------
+// Session resolution
+// ---------------------------------------------------------------------------
 
-function resolveSession(query, sessions = listSessions()) {
+function resolveSession(query, sessions) {
+  if (!sessions) sessions = listSessions();
   if (!query) throw new Error('Missing session. Run `codex-workbench list` to find a session id.');
   const matches = sessions.filter((session) => {
     return session.id === query ||
@@ -123,21 +49,9 @@ function resolveSession(query, sessions = listSessions()) {
   });
   if (matches.length === 1) return matches[0];
   if (matches.length === 0) throw new Error(`No session matched: ${query}`);
-  throw new Error(`Ambiguous session: ${query}\n${matches.map((s) => `  ${s.id} ${s.name || ''}`).join('\n')}`);
-}
-
-function updateMetadata(session, patch) {
-  const meta = loadMeta();
-  meta.sessions[session.id] = { ...(meta.sessions[session.id] || {}), ...patch };
-  meta.updatedAt = new Date().toISOString();
-  writeJson(META_PATH, meta);
-}
-
-function removeMetadata(session) {
-  const meta = loadMeta();
-  delete meta.sessions[session.id];
-  meta.updatedAt = new Date().toISOString();
-  writeJson(META_PATH, meta);
+  throw new Error(
+    `Ambiguous session: ${query}\n${matches.map((s) => `  ${s.id} ${s.name || ''}`).join('\n')}`
+  );
 }
 
 function deleteSessionFile(session) {
@@ -145,6 +59,15 @@ function deleteSessionFile(session) {
   removeMetadata(session);
 }
 
+// ---------------------------------------------------------------------------
+// Re-export parseSession for backward compat (uses codex provider by default)
+// ---------------------------------------------------------------------------
+
+function parseSession(file) {
+  const codex = getProvider('codex');
+  return codex.parseSession(file);
+}
+
 module.exports = {
   deleteSessionFile,
   listSessions,

package/src/model/workbench-config.js

@@ -6,29 +6,65 @@ const { CONFIG_PATH } = require('../config');
 function readWorkbenchConfig(file = CONFIG_PATH) {
   try {
     const data = JSON.parse(fs.readFileSync(file, 'utf8'));
-    return data && typeof data === 'object' ? data : {};
-  } catch {
-    return {};
+    if (!data || typeof data !== 'object' || Array.isArray(data)) {
+      throw new Error(`Workbench config must be a JSON object: ${file}`);
+    }
+    return data;
+  } catch (err) {
+    if (err && err.code === 'ENOENT') return {};
+    if (err instanceof SyntaxError) throw new Error(`Invalid workbench config JSON: ${file}`);
+    throw err;
   }
 }
 
+function configError(index, message) {
+  return new Error(`Invalid server config at servers[${index}]: ${message}`);
+}
+
+function stringField(value, field, index, required = false) {
+  if (value === undefined || value === null || value === '') {
+    if (required) throw configError(index, `${field} is required`);
+    return '';
+  }
+  if (typeof value !== 'string') throw configError(index, `${field} must be a string`);
+  return value;
+}
+
+function normalizeSshArgs(value, index) {
+  if (value === undefined) return [];
+  if (!Array.isArray(value)) throw configError(index, 'sshArgs must be an array');
+  return value.map((item, argIndex) => {
+    if (typeof item !== 'string') {
+      throw configError(index, `sshArgs[${argIndex}] must be a string`);
+    }
+    return item;
+  });
+}
+
 function normalizeServer(server, index) {
-  const target = server.target || server.host || '';
-  if (!target) return null;
-  const id = server.id || target.replace(/[^a-zA-Z0-9_.-]+/g, '-');
+  if (!server || typeof server !== 'object' || Array.isArray(server)) {
+    throw configError(index, 'server must be an object');
+  }
+  const target = stringField(server.target || server.host, 'target', index, true);
+  const id = stringField(server.id, 'id', index) || target.replace(/[^a-zA-Z0-9_.-]+/g, '-');
+  const label = stringField(server.label || server.name, 'label', index) || id || `server-${index + 1}`;
+  const command = stringField(server.command, 'command', index) || 'cwb';
+  const sshArgs = normalizeSshArgs(server.sshArgs, index);
   return {
     id,
-    label: server.label || server.name || id || `server-${index + 1}`,
+    label,
     target,
-    command: server.command || 'cwb',
-    sshArgs: Array.isArray(server.sshArgs) ? server.sshArgs.map(String) : [],
+    command,
+    sshArgs,
   };
 }
 
 function listServers(config = readWorkbenchConfig()) {
-  return (Array.isArray(config.servers) ? config.servers : [])
-    .map(normalizeServer)
-    .filter(Boolean);
+  if (config.servers === undefined) return [];
+  if (!Array.isArray(config.servers)) {
+    throw new Error('Invalid workbench config: servers must be an array');
+  }
+  return config.servers.map(normalizeServer);
 }
 
 module.exports = {

package/src/providers/codex.js

@@ -0,0 +1,267 @@
+'use strict';
+
+// ---------------------------------------------------------------------------
+// Codex provider – session parsing, binary discovery, and CLI operations
+// ---------------------------------------------------------------------------
+
+const fs = require('fs');
+const path = require('path');
+const { spawn, spawnSync } = require('child_process');
+const { HOME } = require('../config');
+
+// ---------------------------------------------------------------------------
+// Binary discovery (extracted from codex-bin.js)
+// ---------------------------------------------------------------------------
+
+const DEFAULT_CODEX_BIN = '/Applications/Codex.app/Contents/Resources/codex';
+
+function isExecutable(file) {
+  try { fs.accessSync(file, fs.constants.X_OK); return true; } catch { return false; }
+}
+
+function findOnPath(command, pathValue) {
+  for (const dir of (pathValue || process.env.PATH || '').split(path.delimiter)) {
+    if (!dir) continue;
+    const candidate = path.join(dir, command);
+    if (isExecutable(candidate)) return candidate;
+  }
+  return null;
+}
+
+function shellQuote(value) {
+  return `'${String(value).replace(/'/g, "'\\''")}'`;
+}
+
+function executableFromOutput(output) {
+  for (const line of String(output || '').split(/\r?\n/)) {
+    const candidate = line.trim();
+    if (candidate && path.isAbsolute(candidate) && isExecutable(candidate)) return candidate;
+  }
+  return null;
+}
+
+function runShellLookup(shell, shellArgs, command, env) {
+  const result = spawnSync(shell, [...shellArgs, `command -v ${shellQuote(command)}`], {
+    encoding: 'utf8', env, stdio: ['ignore', 'pipe', 'pipe'],
+  });
+  if (result.error || result.status !== 0) return null;
+  return executableFromOutput(result.stdout);
+}
+
+function findWithShell(command, env) {
+  const shell = (env || process.env).SHELL || '/bin/sh';
+  if (!isExecutable(shell)) return null;
+  return runShellLookup(shell, ['-lc'], command, env) ||
+         runShellLookup(shell, ['-ic'], command, env);
+}
+
+function resolveCodexBin() {
+  const env = process.env;
+
+  if (env.CODEX_BIN) {
+    if (isExecutable(env.CODEX_BIN)) return env.CODEX_BIN;
+    throw new Error(`CODEX_BIN is not executable: ${env.CODEX_BIN}`);
+  }
+
+  const fromLogin = findWithShell('codex', env);
+  if (fromLogin) return fromLogin;
+
+  const fromPath = findOnPath('codex', env.PATH);
+  if (fromPath) return fromPath;
+
+  if (DEFAULT_CODEX_BIN && isExecutable(DEFAULT_CODEX_BIN)) return DEFAULT_CODEX_BIN;
+
+  throw new Error('Could not find the codex executable. Set CODEX_BIN or add codex to your shell PATH.');
+}
+
+// ---------------------------------------------------------------------------
+// CLI execution (extracted from codex-runner.js)
+// ---------------------------------------------------------------------------
+
+function usableCwd(dir) {
+  for (const candidate of [dir, process.cwd(), HOME]) {
+    if (!candidate || candidate === '(unknown)') continue;
+    try { if (fs.statSync(candidate).isDirectory()) return candidate; } catch { /* skip */ }
+  }
+  return HOME;
+}
+
+function commandShell() {
+  const shell = process.env.SHELL || '/bin/sh';
+  try { fs.accessSync(shell, fs.constants.X_OK); return shell; } catch { return '/bin/sh'; }
+}
+
+function runArgv(argv, cwd, inherit) {
+  const shellCommand = `exec ${argv.map(shellQuote).join(' ')}`;
+  const shell = commandShell();
+  if (inherit) {
+    const child = spawn(shell, ['-lc', shellCommand], { stdio: 'inherit', cwd, env: process.env });
+    child.on('error', (err) => { console.error(`error: failed to start codex: ${err.message}`); process.exit(1); });
+    child.on('exit', (code, signal) => { if (signal) process.kill(process.pid, signal); process.exit(code || 0); });
+    return undefined;
+  }
+  const result = spawnSync(shell, ['-lc', shellCommand], { stdio: 'inherit', cwd, env: process.env });
+  if (result.error) throw new Error(`failed to start codex: ${result.error.message}`);
+  const status = typeof result.status === 'number' ? result.status : 1;
+  process.exitCode = status;
+  return status;
+}
+
+function runCommand(command, session, args, inherit) {
+  const executable = resolveCodexBin();
+  const argv = [executable, command, session.id, ...(args || [])];
+  return runArgv(argv, usableCwd(session.cwd), inherit);
+}
+
+function runNew(cwd, args, inherit) {
+  const executable = resolveCodexBin();
+  const argv = [executable, ...(args || [])];
+  return runArgv(argv, usableCwd(cwd), inherit);
+}
+
+// ---------------------------------------------------------------------------
+// Session parsing (extracted from session-store.js)
+// ---------------------------------------------------------------------------
+
+const CODEX_SESSIONS_DIR = process.env.CODEX_SESSIONS_DIR || path.join(
+  process.env.CODEX_HOME || path.join(HOME, '.codex'),
+  'sessions'
+);
+
+function textFromContent(content) {
+  if (!Array.isArray(content)) return '';
+  return content
+    .filter((item) => item && (item.type === 'input_text' || item.type === 'output_text'))
+    .map((item) => item.text || '')
+    .join(' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function isNoiseUserText(text) {
+  return text.includes('<environment_context>') || text.includes('<permissions instructions>');
+}
+
+function walk(dir, out) {
+  out = out || [];
+  let entries;
+  try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return out; }
+  for (const entry of entries) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) walk(full, out);
+    else if (entry.isFile() && entry.name.endsWith('.jsonl')) out.push(full);
+  }
+  return out;
+}
+
+function parseSession(file) {
+  const stat = fs.statSync(file);
+  const raw = fs.readFileSync(file, 'utf8').trim();
+  const lines = raw ? raw.split(/\n/) : [];
+  let meta = {};
+  const messages = [];
+  let turns = 0;
+
+  for (const line of lines) {
+    let row;
+    try { row = JSON.parse(line); } catch { continue; }
+    if (row.type === 'session_meta') meta = row.payload || {};
+    if (row.type === 'response_item' && row.payload && row.payload.type === 'message') {
+      const msg = row.payload;
+      if (msg.role === 'developer') continue;
+      const text = textFromContent(msg.content);
+      if (!text) continue;
+      if (msg.role === 'user' && isNoiseUserText(text)) continue;
+      messages.push({ role: msg.role, phase: msg.phase || '', text });
+      if (msg.role === 'user') turns += 1;
+    }
+  }
+
+  const id = meta.id || path.basename(file, '.jsonl').split('-').slice(-5).join('-');
+
+  return {
+    id,
+    file,
+    cwd: meta.cwd || '(unknown)',
+    startedAt: meta.timestamp || null,
+    updatedAt: stat.mtime.toISOString(),
+    cliVersion: meta.cli_version || '',
+    provider: meta.model_provider || '',
+    turns,
+    first: firstUserText(messages),
+    last: lastUserText(messages),
+    lastAssistant: lastAssistantText(messages),
+    messages,
+    backend: 'codex',
+  };
+}
+
+function firstUserText(messages) {
+  const m = messages.find((msg) => msg.role === 'user');
+  return m ? m.text : '';
+}
+
+function lastUserText(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i].role === 'user') return messages[i].text;
+  }
+  return '';
+}
+
+function lastAssistantText(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i].role === 'assistant') return messages[i].text;
+  }
+  return '';
+}
+
+// ---------------------------------------------------------------------------
+// Provider interface
+// ---------------------------------------------------------------------------
+
+function isAvailable() {
+  try { return fs.statSync(CODEX_SESSIONS_DIR).isDirectory(); } catch { return false; }
+}
+
+function getSessionFiles() {
+  return walk(CODEX_SESSIONS_DIR);
+}
+
+function resolveBin() {
+  try { return resolveCodexBin(); } catch { return null; }
+}
+
+// Map workbench command names → codex CLI commands
+const COMMAND_MAP = {
+  resume:  'resume',
+  fork:    'fork',
+  delete:  'delete',
+  archive: 'archive',
+  unarchive: 'unarchive',
+};
+
+function runSessionCommand(command, session, args, inherit) {
+  const codexCmd = COMMAND_MAP[command];
+  if (!codexCmd) throw new Error(`Unknown command for codex backend: ${command}`);
+  return runCommand(codexCmd, session, args, inherit);
+}
+
+module.exports = {
+  id: 'codex',
+  label: 'Codex',
+  isAvailable,
+  getSessionFiles,
+  parseSession,
+  resolveBin,
+  runCommand: runSessionCommand,
+  runNew,
+  usableCwd,
+  // Re-export for backward compat
+  shellQuote,
+  commandShell,
+  resolveCodexBin,
+  DEFAULT_CODEX_BIN,
+  findOnPath,
+  findWithShell,
+  isExecutable,
+};

package/src/providers/index.js

@@ -0,0 +1,59 @@
+'use strict';
+
+// ---------------------------------------------------------------------------
+// Provider registry – auto-detects available backends, routes operations
+// ---------------------------------------------------------------------------
+
+const codex = require('./codex');
+const pi = require('./pi');
+
+const ALL_PROVIDERS = [codex, pi];
+const providerMap = new Map(ALL_PROVIDERS.map((p) => [p.id, p]));
+
+/**
+ * Auto-detect which providers are available (their session directories exist).
+ */
+function getAvailableProviders() {
+  return ALL_PROVIDERS.filter((p) => p.isAvailable());
+}
+
+/**
+ * Get a specific provider by id. Throws if not registered.
+ */
+function getProvider(id) {
+  const p = providerMap.get(id);
+  if (!p) throw new Error(`Unknown backend: ${id}. Available: ${[...providerMap.keys()].join(', ')}`);
+  return p;
+}
+
+/**
+ * Get the provider for a session (reads session.backend).
+ */
+function providerForSession(session) {
+  const backend = session.backend || 'codex';
+  return getProvider(backend);
+}
+
+/**
+ * List all session files across all available providers.
+ * Returns [{ file, backend, providerId }].
+ */
+function getAllSessionFiles() {
+  const files = [];
+  for (const provider of getAvailableProviders()) {
+    for (const file of provider.getSessionFiles()) {
+      files.push({ file, backend: provider.id });
+    }
+  }
+  return files;
+}
+
+module.exports = {
+  ALL_PROVIDERS,
+  getAvailableProviders,
+  getProvider,
+  providerForSession,
+  getAllSessionFiles,
+  codex,
+  pi,
+};