@bramblex/codex-workbench 0.1.3 → 0.1.4

package/src/config.js

@@ -0,0 +1,18 @@
+'use strict';
+
+const os = require('os');
+const path = require('path');
+
+const HOME = os.homedir();
+const CODEX_HOME = process.env.CODEX_HOME || path.join(HOME, '.codex');
+const SESSIONS_DIR = process.env.CODEX_SESSIONS_DIR || path.join(CODEX_HOME, 'sessions');
+const META_PATH = process.env.CODEX_WORKBENCH_META || process.env.CSM_META || path.join(CODEX_HOME, 'codex-workbench.json');
+const CONFIG_PATH = process.env.CODEX_WORKBENCH_CONFIG || path.join(CODEX_HOME, 'codex-workbench.config.json');
+
+module.exports = {
+  HOME,
+  CODEX_HOME,
+  CONFIG_PATH,
+  SESSIONS_DIR,
+  META_PATH,
+};

package/src/model/directories.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+function directoryNameError(name) {
+  if (!name) return 'Directory name is required.';
+  if (name === '.' || name === '..') return 'Directory name cannot be . or ..';
+  if (path.isAbsolute(name)) return 'Directory name must be relative.';
+  if (name.includes('/') || name.includes('\\') || name.includes('\0')) return 'Directory name cannot contain path separators.';
+  return '';
+}
+
+function listDirectories(dir, usableCwd) {
+  const cwd = usableCwd ? usableCwd(dir) : path.resolve(dir || process.cwd());
+  const entries = fs.readdirSync(cwd, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => ({
+      name: entry.name,
+      path: path.join(cwd, entry.name),
+    }))
+    .sort((a, b) => a.name.localeCompare(b.name));
+  return { cwd, entries };
+}
+
+function createChildDirectory(parent, name) {
+  const error = directoryNameError(name);
+  if (error) throw new Error(error);
+  const target = path.join(parent, name);
+  fs.mkdirSync(target);
+  return target;
+}
+
+module.exports = {
+  createChildDirectory,
+  directoryNameError,
+  listDirectories,
+};

package/src/model/format.js

@@ -0,0 +1,21 @@
+'use strict';
+
+function shortId(id) {
+  return id.slice(0, 13);
+}
+
+function localTime(iso) {
+  if (!iso) return '';
+  return new Date(iso).toLocaleString();
+}
+
+function truncate(text, width) {
+  if (!text) return '';
+  return text.length > width ? text.slice(0, Math.max(0, width - 1)) + '...' : text;
+}
+
+module.exports = {
+  localTime,
+  shortId,
+  truncate,
+};

package/src/model/session-store.js

@@ -0,0 +1,156 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { META_PATH, SESSIONS_DIR } = require('../config');
+
+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;
+}
+
+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 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('-');
+  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,
+  };
+}
+
+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));
+}
+
+function resolveSession(query, 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 ||
+      session.id.startsWith(query) ||
+      session.name === query ||
+      path.basename(session.file) === query;
+  });
+  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);
+}
+
+function deleteSessionFile(session) {
+  fs.unlinkSync(session.file);
+  removeMetadata(session);
+}
+
+module.exports = {
+  deleteSessionFile,
+  listSessions,
+  loadMeta,
+  parseSession,
+  removeMetadata,
+  resolveSession,
+  updateMetadata,
+};

package/src/model/workbench-config.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const fs = require('fs');
+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 {};
+  }
+}
+
+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, '-');
+  return {
+    id,
+    label: server.label || server.name || id || `server-${index + 1}`,
+    target,
+    command: server.command || 'cwb',
+    sshArgs: Array.isArray(server.sshArgs) ? server.sshArgs.map(String) : [],
+  };
+}
+
+function listServers(config = readWorkbenchConfig()) {
+  return (Array.isArray(config.servers) ? config.servers : [])
+    .map(normalizeServer)
+    .filter(Boolean);
+}
+
+module.exports = {
+  listServers,
+  normalizeServer,
+  readWorkbenchConfig,
+};

package/src/services/codex-runner.js

@@ -0,0 +1,75 @@
+'use strict';
+
+const fs = require('fs');
+const { spawn, spawnSync } = require('child_process');
+const { HOME } = require('../config');
+const { resolveCodexBin } = require('../codex-bin');
+
+function usableCwd(dir) {
+  const candidates = [dir, process.cwd(), HOME];
+  for (const candidate of candidates) {
+    if (!candidate || candidate === '(unknown)') continue;
+    try {
+      if (fs.statSync(candidate).isDirectory()) return candidate;
+    } catch {
+      // Try the next fallback.
+    }
+  }
+  return HOME;
+}
+
+function shellQuote(value) {
+  return `'${String(value).replace(/'/g, "'\\''")}'`;
+}
+
+function commandShell() {
+  const shell = process.env.SHELL || '/bin/sh';
+  try {
+    fs.accessSync(shell, fs.constants.X_OK);
+    return shell;
+  } catch {
+    return '/bin/sh';
+  }
+}
+
+function runCodexArgv(argv, cwd, inherit = false) {
+  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 runCodexCommand(command, session, args = [], inherit = false) {
+  const executable = resolveCodexBin();
+  const argv = [executable, command, session.id, ...args];
+  return runCodexArgv(argv, usableCwd(session.cwd), inherit);
+}
+
+function runNewCodexSession(cwd, args = [], inherit = false) {
+  const executable = resolveCodexBin();
+  const argv = [executable, ...args];
+  return runCodexArgv(argv, usableCwd(cwd), inherit);
+}
+
+module.exports = {
+  commandShell,
+  runCodexCommand,
+  runNewCodexSession,
+  shellQuote,
+  usableCwd,
+};

package/src/services/session-sources.js

@@ -0,0 +1,148 @@
+'use strict';
+
+const path = require('path');
+const { createChildDirectory, listDirectories } = require('../model/directories');
+const { listSessions, updateMetadata } = require('../model/session-store');
+const { listServers } = require('../model/workbench-config');
+const { runCodexCommand, runNewCodexSession, usableCwd } = require('./codex-runner');
+const { runRemoteCwb, runRemoteCwbJson } = require('./ssh-runner');
+
+const LOCAL_SOURCE = {
+  id: 'local',
+  label: 'Local',
+  type: 'local',
+  remote: false,
+};
+
+function sourceForServer(server) {
+  return {
+    ...server,
+    type: 'ssh',
+    remote: true,
+  };
+}
+
+function sourceKey(sourceId, id) {
+  return `${sourceId}:${id}`;
+}
+
+function attachSource(session, source) {
+  return {
+    ...session,
+    sourceId: source.id,
+    sourceLabel: source.label,
+    sourceType: source.type,
+    sourceRemote: source.remote,
+    sourceKey: sourceKey(source.id, session.id),
+  };
+}
+
+function configuredSources() {
+  return [LOCAL_SOURCE, ...listServers().map(sourceForServer)];
+}
+
+function loadWorkbenchSessions() {
+  const sources = configuredSources();
+  const sessions = listSessions().map((session) => attachSource(session, LOCAL_SOURCE));
+  const errors = [];
+
+  for (const source of sources.filter((candidate) => candidate.remote)) {
+    try {
+      const remoteSessions = runRemoteCwbJson(source, ['list', '--json']);
+      if (!Array.isArray(remoteSessions)) throw new Error('remote list did not return an array');
+      sessions.push(...remoteSessions.map((session) => attachSource(session, source)));
+    } catch (err) {
+      errors.push({ source, error: err.message });
+    }
+  }
+
+  sessions.sort((a, b) => new Date(b.updatedAt) - new Date(a.updatedAt));
+  return { errors, sessions, sources };
+}
+
+function sourceById(sources, sourceId) {
+  return sources.find((source) => source.id === sourceId) || LOCAL_SOURCE;
+}
+
+function configuredSourceOrThrow(sourceId) {
+  const source = configuredSources().find((candidate) => candidate.id === sourceId);
+  if (!source) throw new Error(`Remote source is not configured: ${sourceId}`);
+  return source;
+}
+
+function resultStatus(result) {
+  return typeof result.status === 'number' ? result.status : 1;
+}
+
+function runSourceSessionCommand(session, command, args = []) {
+  if (!session.sourceRemote) return runCodexCommand(command, session, args);
+  const source = configuredSourceOrThrow(session.sourceId);
+  const tty = command === 'resume' || command === 'fork';
+  const result = runRemoteCwb(source, [command, session.id, ...args], { tty });
+  if (result.error) throw result.error;
+  const status = resultStatus(result);
+  process.exitCode = status;
+  return status;
+}
+
+function runSourceNewSession(source, cwd, args = []) {
+  if (!source || !source.remote) return runNewCodexSession(cwd, args);
+  const result = runRemoteCwb(source, ['new', '--cwd', cwd, ...args], { tty: true });
+  if (result.error) throw result.error;
+  const status = resultStatus(result);
+  process.exitCode = status;
+  return status;
+}
+
+function updateSourceMetadata(session, patch) {
+  if (!session.sourceRemote) {
+    updateMetadata(session, patch);
+    return 0;
+  }
+  const source = configuredSourceOrThrow(session.sourceId);
+  let result = null;
+  if (Object.prototype.hasOwnProperty.call(patch, 'name')) {
+    result = runRemoteCwb(source, ['rename', session.id, patch.name || '']);
+  } else if (Object.prototype.hasOwnProperty.call(patch, 'note')) {
+    result = runRemoteCwb(source, ['note', session.id, patch.note || '']);
+  } else if (Object.prototype.hasOwnProperty.call(patch, 'hidden')) {
+    result = runRemoteCwb(source, [patch.hidden ? 'hide' : 'unhide', session.id]);
+  }
+  if (!result) return 0;
+  if (result.error) throw result.error;
+  const status = resultStatus(result);
+  process.exitCode = status;
+  return status;
+}
+
+function listSourceDirectories(source, dir) {
+  if (!source || !source.remote) return listDirectories(dir, usableCwd);
+  const payload = runRemoteCwbJson(source, ['dirs', '--cwd', dir, '--json']);
+  return {
+    cwd: payload.cwd || dir || '.',
+    entries: (payload.entries || []).map((entry) => ({
+      name: entry.name || path.basename(entry.path),
+      path: entry.path,
+    })),
+  };
+}
+
+function createSourceDirectory(source, parent, name) {
+  if (!source || !source.remote) return createChildDirectory(parent, name);
+  const payload = runRemoteCwbJson(source, ['mkdir', '--cwd', parent, '--json', name]);
+  return payload.path;
+}
+
+module.exports = {
+  LOCAL_SOURCE,
+  attachSource,
+  configuredSources,
+  createSourceDirectory,
+  listSourceDirectories,
+  loadWorkbenchSessions,
+  runSourceNewSession,
+  runSourceSessionCommand,
+  sourceById,
+  sourceKey,
+  updateSourceMetadata,
+};

package/src/services/ssh-runner.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const { spawnSync } = require('child_process');
+const { shellQuote } = require('./codex-runner');
+
+function sshBaseArgs(server, opts = {}) {
+  const args = [];
+  if (opts.tty) args.push('-t');
+  args.push(...(server.sshArgs || []), server.target);
+  return args;
+}
+
+function remoteCwbCommand(server, argv) {
+  const command = server.command || 'cwb';
+  return [command, ...argv].map(shellQuote).join(' ');
+}
+
+function runRemoteCwb(server, argv, opts = {}) {
+  const command = remoteCwbCommand(server, argv);
+  const args = [...sshBaseArgs(server, { tty: opts.tty }), command];
+  return spawnSync('ssh', args, {
+    encoding: opts.encoding,
+    env: process.env,
+    stdio: opts.stdio || (opts.encoding ? ['ignore', 'pipe', 'pipe'] : 'inherit'),
+  });
+}
+
+function runRemoteCwbJson(server, argv) {
+  const result = runRemoteCwb(server, argv, { encoding: 'utf8' });
+  if (result.error) throw result.error;
+  if (result.status !== 0) {
+    const stderr = (result.stderr || '').trim();
+    throw new Error(stderr || `ssh exited with code ${result.status}`);
+  }
+  return JSON.parse(result.stdout || 'null');
+}
+
+module.exports = {
+  remoteCwbCommand,
+  runRemoteCwb,
+  runRemoteCwbJson,
+  sshBaseArgs,
+};