@bramblex/codex-workbench 0.1.19 → 0.1.20

package/README.md

@@ -18,7 +18,7 @@ codex-workbench is an **interactive terminal UI** for coding-agent sessions. Ins
 
 It also connects to **remote machines over SSH**, so you can manage sessions across all your servers from a single pane of glass.
 
-Built-in backends currently include [Codex](https://github.com/openai/codex), pi, and opencode. The backend layer is intentionally provider-based so additional agents can be added without changing the TUI workflow.
+Built-in backends currently include [Codex](https://github.com/openai/codex), Claude Code, pi, and opencode. The backend layer is intentionally provider-based so additional agents can be added without changing the TUI workflow.
 
 A handful of CLI subcommands are available for scripting, but the TUI is the product.
 
@@ -136,6 +136,7 @@ codex-workbench auto-detects installed backends by checking each backend's sessi
 | Backend | Sessions | Binary override | Notes |
 |---------|----------|-----------------|-------|
 | `codex` | `$CODEX_SESSIONS_DIR` or `~/.codex/sessions` | `CODEX_BIN` | Uses the Codex CLI for new, resume, fork, archive, unarchive, and delete. |
+| `claude` | `$CLAUDE_PROJECTS_DIR` or `~/.claude/projects` | `CLAUDE_BIN` | Uses the Claude Code CLI for new, resume, and fork. Archive/unarchive use workbench metadata; delete removes the session file. |
 | `pi` | `$PI_CODING_AGENT_SESSION_DIR` or `$PI_CODING_AGENT_DIR/sessions` | `PI_BIN` | Uses the pi CLI for new, resume, and fork. Archive/unarchive use workbench metadata; delete removes the session file. |
 | `opencode` | `$OPENCODE_DB`, `$OPENCODE_DATA_DIR/opencode.db`, or `~/.local/share/opencode/opencode.db` | `OPENCODE_BIN` | Uses the opencode CLI and database for list, new, resume, fork, archive, unarchive, and delete. |
 
@@ -165,6 +166,7 @@ cwb fork <session>
 cwb delete <session> --force
 
 cwb new --cwd ~/projects/foo --backend codex "Summarize this repo"
+cwb new --cwd ~/projects/foo --backend claude "Summarize this repo"
 cwb new --cwd ~/projects/foo --backend pi "Summarize this repo"
 cwb new --cwd ~/projects/foo --backend opencode "Summarize this repo"
 cwb resume <session> "what was the conclusion about the rate limiter?"
@@ -191,6 +193,8 @@ When you run `new` or `resume`, the selected backend takes over the terminal. Wh
 | `CWB_CONFIG` | `$CWB_HOME/config.json` | SSH remote sources config |
 | `CODEX_HOME` | `~/.codex` | Codex data directory |
 | `CODEX_SESSIONS_DIR` | `$CODEX_HOME/sessions` | Session JSONL files |
+| `CLAUDE_HOME` | `~/.claude` | Claude Code data directory |
+| `CLAUDE_PROJECTS_DIR` | `$CLAUDE_HOME/projects` | Claude Code project session JSONL files |
 | `PI_CODING_AGENT_DIR` | `~/.pi/agent` | pi coding agent data directory |
 | `PI_CODING_AGENT_SESSION_DIR` | `$PI_CODING_AGENT_DIR/sessions` | pi session JSONL files |
 | `OPENCODE_DATA_DIR` | `~/.local/share/opencode` | opencode data directory |
@@ -198,6 +202,7 @@ When you run `new` or `resume`, the selected backend takes over the terminal. Wh
 | `CODEX_WORKBENCH_META` | unset | Legacy override for `CWB_META` |
 | `CODEX_WORKBENCH_CONFIG` | unset | Legacy override for `CWB_CONFIG` |
 | `CODEX_BIN` | auto-detected | Force a specific Codex executable |
+| `CLAUDE_BIN` | auto-detected | Force a specific Claude Code executable |
 | `PI_BIN` | auto-detected | Force a specific pi executable |
 | `OPENCODE_BIN` | auto-detected | Force a specific opencode executable |
 
@@ -223,6 +228,10 @@ Run `codex-workbench doctor` to see where codex-workbench is looking. Common fix
 
 Make sure you've run Codex at least once. Sessions are stored as `.jsonl` files under `$CODEX_SESSIONS_DIR`. Run `ls ~/.codex/sessions/` to verify.
 
+### No Claude Code sessions appear
+
+Make sure you've run Claude Code at least once. Sessions are stored as `.jsonl` files under `$CLAUDE_PROJECTS_DIR`. Run `find ~/.claude/projects -name '*.jsonl'` to verify.
+
 ### No pi sessions appear
 
 Make sure you've run the pi coding agent at least once. Sessions are stored as `.jsonl` files under `$PI_CODING_AGENT_SESSION_DIR` or `$PI_CODING_AGENT_DIR/sessions`. Run `ls ~/.pi/agent/sessions/` to verify.
@@ -293,6 +302,7 @@ src/
     workbench-config.js      # SSH remote source config loader
   providers/
     codex.js                 # Codex provider
+    claude.js                # Claude Code provider
     pi.js                    # pi provider
     opencode.js              # opencode provider
     index.js                 # provider registry

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bramblex/codex-workbench",
-  "version": "0.1.19",
+  "version": "0.1.20",
   "description": "Terminal workbench for browsing and managing local and SSH Codex sessions.",
   "license": "MIT",
   "repository": {

package/src/cli-output.js

@@ -31,6 +31,8 @@ Environment:
   CWB_CONFIG            default: $CWB_HOME/config.json
   CODEX_HOME            default: ~/.codex
   CODEX_SESSIONS_DIR    default: $CODEX_HOME/sessions
+  CLAUDE_HOME           default: ~/.claude
+  CLAUDE_PROJECTS_DIR   default: $CLAUDE_HOME/projects
   PI_CODING_AGENT_DIR   default: ~/.pi/agent
   PI_CODING_AGENT_SESSION_DIR default: $PI_CODING_AGENT_DIR/sessions
   OPENCODE_DATA_DIR     default: ~/.local/share/opencode
@@ -38,6 +40,7 @@ Environment:
   CODEX_WORKBENCH_META  legacy override for CWB_META
   CODEX_WORKBENCH_CONFIG legacy override for CWB_CONFIG
   CODEX_BIN             default: codex from shell PATH
+  CLAUDE_BIN            default: claude from shell PATH
   PI_BIN                default: pi from shell PATH
   OPENCODE_BIN          default: opencode from shell PATH
 `);

package/src/providers/claude.js

@@ -0,0 +1,283 @@
+'use strict';
+
+// ---------------------------------------------------------------------------
+// Claude Code provider – session parsing, binary discovery, and CLI operations
+// ---------------------------------------------------------------------------
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawn, spawnSync } = require('child_process');
+const { removeMetadata, updateMetadata } = require('../model/metadata');
+
+const HOME = os.homedir();
+const CLAUDE_HOME = process.env.CLAUDE_HOME || path.join(HOME, '.claude');
+const CLAUDE_PROJECTS_DIR = process.env.CLAUDE_PROJECTS_DIR || path.join(CLAUDE_HOME, 'projects');
+
+function shellQuote(value) {
+  return `'${String(value).replace(/'/g, "'\\''")}'`;
+}
+
+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 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 resolveClaudeBin() {
+  const env = process.env;
+  if (env.CLAUDE_BIN) {
+    if (isExecutable(env.CLAUDE_BIN)) return env.CLAUDE_BIN;
+    throw new Error(`CLAUDE_BIN is not executable: ${env.CLAUDE_BIN}`);
+  }
+  const fromShell = findWithShell('claude', env);
+  if (fromShell) return fromShell;
+  const fromPath = findOnPath('claude', env.PATH);
+  if (fromPath) return fromPath;
+  throw new Error('Could not find the claude executable. Set CLAUDE_BIN or add claude to PATH.');
+}
+
+function commandShell() {
+  const shell = process.env.SHELL || '/bin/sh';
+  try { fs.accessSync(shell, fs.constants.X_OK); return shell; } catch { return '/bin/sh'; }
+}
+
+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 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 textFromContent(content) {
+  if (typeof content === 'string') return content.trim();
+  if (!Array.isArray(content)) return '';
+  return content
+    .map((item) => {
+      if (!item) return '';
+      if (typeof item === 'string') return item;
+      if (item.type === 'text') return item.text || '';
+      if (item.type === 'tool_result') return '';
+      return '';
+    })
+    .filter(Boolean)
+    .join(' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function firstUserText(messages) {
+  const message = messages.find((msg) => msg.role === 'user');
+  return message ? message.text : '';
+}
+
+function lastText(messages, role) {
+  for (let i = messages.length - 1; i >= 0; i -= 1) {
+    if (!role || messages[i].role === role) return messages[i].text;
+  }
+  return '';
+}
+
+function isNoiseUserText(text) {
+  return /^<local-command-/.test(text) ||
+    /^<command-name>/.test(text) ||
+    text.includes('<environment_context>') ||
+    text.includes('<permissions instructions>');
+}
+
+function emptySession(file, stat) {
+  return {
+    id: path.basename(file, '.jsonl'),
+    file,
+    cwd: '(unknown)',
+    startedAt: stat.birthtime?.toISOString() || null,
+    updatedAt: stat.mtime.toISOString(),
+    cliVersion: '',
+    provider: '',
+    turns: 0,
+    first: '',
+    last: '',
+    lastAssistant: '',
+    messages: [],
+    backend: 'claude',
+  };
+}
+
+function parseSession(file) {
+  const stat = fs.statSync(file);
+  const raw = fs.readFileSync(file, 'utf8').trim();
+  if (!raw) return emptySession(file, stat);
+
+  const messages = [];
+  let id = path.basename(file, '.jsonl');
+  let cwd = '';
+  let startedAt = '';
+  let updatedAt = stat.mtime.toISOString();
+  let cliVersion = '';
+  let provider = '';
+  let turns = 0;
+
+  for (const line of raw.split(/\n/)) {
+    let row;
+    try { row = JSON.parse(line); } catch { continue; }
+
+    if (row.sessionId) id = row.sessionId;
+    if (row.cwd) cwd = row.cwd;
+    if (row.version) cliVersion = row.version;
+    if (row.timestamp) {
+      if (!startedAt) startedAt = row.timestamp;
+      updatedAt = row.timestamp;
+    }
+
+    if ((row.type === 'user' || row.type === 'assistant') && row.message) {
+      const role = row.message.role || row.type;
+      const text = textFromContent(row.message.content);
+      if (!text) continue;
+      if (role === 'user' && isNoiseUserText(text)) continue;
+      messages.push({ role, text });
+      if (role === 'user') turns += 1;
+      if (!provider && role === 'assistant' && row.message.model) provider = row.message.model;
+    }
+  }
+
+  return {
+    id,
+    file,
+    cwd: cwd || '(unknown)',
+    startedAt: startedAt || stat.birthtime?.toISOString() || null,
+    updatedAt,
+    cliVersion,
+    provider,
+    turns,
+    first: firstUserText(messages),
+    last: lastText(messages, 'user'),
+    lastAssistant: lastText(messages, 'assistant'),
+    messages,
+    backend: 'claude',
+  };
+}
+
+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 claude: ${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 claude: ${result.error.message}`);
+  const status = typeof result.status === 'number' ? result.status : 1;
+  process.exitCode = status;
+  return status;
+}
+
+function runSessionCommand(command, session, args, inherit) {
+  const executable = resolveClaudeBin();
+  const cwd = usableCwd(session.cwd);
+  switch (command) {
+    case 'resume': {
+      const argv = [executable, '--resume', session.id];
+      if (args && args.length) argv.push(args.join(' '));
+      return runArgv(argv, cwd, inherit);
+    }
+    case 'fork': {
+      return runArgv([executable, '--resume', session.id, '--fork-session'], cwd, inherit);
+    }
+    case 'delete': {
+      fs.unlinkSync(session.file);
+      removeMetadata(session);
+      return 0;
+    }
+    case 'archive':
+    case 'unarchive': {
+      updateMetadata(session, { archived: command === 'archive' });
+      return 0;
+    }
+    default:
+      throw new Error(`Unknown command for claude backend: ${command}`);
+  }
+}
+
+function runNew(cwd, args, inherit) {
+  const argv = [resolveClaudeBin(), ...(args || [])];
+  return runArgv(argv, usableCwd(cwd), inherit);
+}
+
+function isAvailable() {
+  try { return fs.statSync(CLAUDE_PROJECTS_DIR).isDirectory(); } catch { return false; }
+}
+
+function getSessionFiles() {
+  return walk(CLAUDE_PROJECTS_DIR);
+}
+
+function resolveBin() {
+  try { return resolveClaudeBin(); } catch { return null; }
+}
+
+module.exports = {
+  id: 'claude',
+  label: 'Claude Code',
+  capabilities: {
+    new: true,
+    resume: true,
+    fork: true,
+    archive: true,
+    unarchive: true,
+    delete: true,
+  },
+  isAvailable,
+  getSessionFiles,
+  parseSession,
+  resolveBin,
+  runCommand: runSessionCommand,
+  runNew,
+  resolveClaudeBin,
+};

package/src/providers/index.js

@@ -5,10 +5,11 @@
 // ---------------------------------------------------------------------------
 
 const codex = require('./codex');
+const claude = require('./claude');
 const opencode = require('./opencode');
 const pi = require('./pi');
 
-const ALL_PROVIDERS = [codex, pi, opencode];
+const ALL_PROVIDERS = [codex, pi, opencode, claude];
 const providerMap = new Map(ALL_PROVIDERS.map((p) => [p.id, p]));
 
 /**
@@ -59,6 +60,7 @@ module.exports = {
   getProvider,
   providerForSession,
   getAllSessionFiles,
+  claude,
   codex,
   opencode,
   pi,

package/src/providers/opencode.js

@@ -24,6 +24,35 @@ function findOnPath(command, pathValue) {
   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 resolveOpenCodeBin() {
   if (process.env.OPENCODE_BIN) {
     if (isExecutable(process.env.OPENCODE_BIN)) return process.env.OPENCODE_BIN;
@@ -31,6 +60,8 @@ function resolveOpenCodeBin() {
   }
   const fromPath = findOnPath('opencode', process.env.PATH);
   if (fromPath) return fromPath;
+  const fromShell = findWithShell('opencode', process.env);
+  if (fromShell) return fromShell;
   throw new Error('Could not find the opencode executable. Set OPENCODE_BIN or add opencode to PATH.');
 }
 

package/src/ui/workbench.js

@@ -227,6 +227,7 @@ async function runWorkbench() {
   const styledListLabel = (color, text) => `{${color}-fg}{bold}${blessed.escape(text)}{/}`;
 
   const backendThemes = {
+    claude: 'yellow',
     codex: 'cyan',
     pi: 'magenta',
     opencode: 'green',