@bramblex/codex-workbench 0.1.18 → 0.1.19

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) and pi. 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), 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.
 
@@ -131,12 +131,13 @@ Remote backends are supported as long as the remote `cwb` can read them.
 
 ## Backends
 
-codex-workbench auto-detects installed backends by checking their session directories.
+codex-workbench auto-detects installed backends by checking each backend's session storage.
 
 | 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. |
 | `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. |
 
 Session metadata such as custom names, notes, and archive state is stored in workbench's own metadata file, not inside backend session files.
 
@@ -165,6 +166,7 @@ cwb delete <session> --force
 
 cwb new --cwd ~/projects/foo --backend codex "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?"
 
 cwb dirs --cwd ~/projects
@@ -191,10 +193,13 @@ When you run `new` or `resume`, the selected backend takes over the terminal. Wh
 | `CODEX_SESSIONS_DIR` | `$CODEX_HOME/sessions` | 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 |
+| `OPENCODE_DB` | `$OPENCODE_DATA_DIR/opencode.db` | opencode SQLite database |
 | `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 |
 | `PI_BIN` | auto-detected | Force a specific pi executable |
+| `OPENCODE_BIN` | auto-detected | Force a specific opencode executable |
 
 By default, codex-workbench discovers the `codex` binary through your login shell's `PATH`. Set `CODEX_BIN` to override.
 
@@ -222,6 +227,10 @@ Make sure you've run Codex at least once. Sessions are stored as `.jsonl` files
 
 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.
 
+### No opencode sessions found
+
+Make sure you've run opencode at least once. Sessions are stored in the SQLite database at `$OPENCODE_DB` or `$OPENCODE_DATA_DIR/opencode.db`. Run `opencode session list --format json` or `opencode db path` to verify.
+
 ### A backend is missing from doctor
 
 Backends appear only when their session directory exists. For a new backend integration, add a provider under `src/providers/` with session discovery, parsing, binary discovery, and command routing.
@@ -285,6 +294,7 @@ src/
   providers/
     codex.js                 # Codex provider
     pi.js                    # pi provider
+    opencode.js              # opencode provider
     index.js                 # provider registry
   services/
     codex-runner.js          # backward-compatible provider runner wrapper

package/package.json

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

package/src/cli-output.js

@@ -31,9 +31,15 @@ Environment:
   CWB_CONFIG            default: $CWB_HOME/config.json
   CODEX_HOME            default: ~/.codex
   CODEX_SESSIONS_DIR    default: $CODEX_HOME/sessions
+  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
+  OPENCODE_DB           default: $OPENCODE_DATA_DIR/opencode.db
   CODEX_WORKBENCH_META  legacy override for CWB_META
   CODEX_WORKBENCH_CONFIG legacy override for CWB_CONFIG
   CODEX_BIN             default: codex from shell PATH
+  PI_BIN                default: pi from shell PATH
+  OPENCODE_BIN          default: opencode from shell PATH
 `);
 }
 
@@ -106,8 +112,13 @@ function printDoctor() {
       try { provider.resolveBin(); } catch (err) { console.log(`  error:    ${err.message}`); }
     }
     try {
-      const files = provider.getSessionFiles();
-      console.log(`  sessions: ${files.length} file${files.length === 1 ? '' : 's'}`);
+      if (provider.listSessions) {
+        const sessions = provider.listSessions();
+        console.log(`  sessions: ${sessions.length}`);
+      } else {
+        const files = provider.getSessionFiles();
+        console.log(`  sessions: ${files.length} file${files.length === 1 ? '' : 's'}`);
+      }
     } catch (err) {
       console.log(`  sessions: error - ${err.message}`);
     }

package/src/model/session-store.js

@@ -18,10 +18,10 @@ function listSessions() {
   const fileEntries = getAllSessionFiles();
 
   const sessions = [];
-  for (const { file, backend } of fileEntries) {
+  for (const { file, backend, session: listedSession } of fileEntries) {
     try {
       const provider = getProvider(backend);
-      const session = provider.parseSession(file);
+      const session = listedSession || provider.parseSession(file);
       // Merge workbench metadata (name, note, archived)
       const custom = meta.sessions[session.id] || {};
       sessions.push({ ...session, ...custom });
@@ -45,7 +45,7 @@ function resolveSession(query, sessions) {
     return session.id === query ||
       session.id.startsWith(query) ||
       session.name === query ||
-      path.basename(session.file) === query;
+      (session.file && path.basename(session.file) === query);
   });
   if (matches.length === 1) return matches[0];
   if (matches.length === 0) throw new Error(`No session matched: ${query}`);
@@ -55,6 +55,7 @@ function resolveSession(query, sessions) {
 }
 
 function deleteSessionFile(session) {
+  if (!session.file) throw new Error(`Session does not have a standalone file: ${session.id}`);
   fs.unlinkSync(session.file);
   removeMetadata(session);
 }

package/src/providers/index.js

@@ -5,9 +5,10 @@
 // ---------------------------------------------------------------------------
 
 const codex = require('./codex');
+const opencode = require('./opencode');
 const pi = require('./pi');
 
-const ALL_PROVIDERS = [codex, pi];
+const ALL_PROVIDERS = [codex, pi, opencode];
 const providerMap = new Map(ALL_PROVIDERS.map((p) => [p.id, p]));
 
 /**
@@ -41,6 +42,10 @@ function providerForSession(session) {
 function getAllSessionFiles() {
   const files = [];
   for (const provider of getAvailableProviders()) {
+    if (provider.listSessions) {
+      for (const session of provider.listSessions()) files.push({ session, backend: provider.id });
+      continue;
+    }
     for (const file of provider.getSessionFiles()) {
       files.push({ file, backend: provider.id });
     }
@@ -55,5 +60,6 @@ module.exports = {
   providerForSession,
   getAllSessionFiles,
   codex,
+  opencode,
   pi,
 };

package/src/providers/opencode.js

@@ -0,0 +1,231 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawn, spawnSync } = require('child_process');
+const { removeMetadata } = require('../model/metadata');
+
+const HOME = os.homedir();
+const OPENCODE_DATA_DIR = process.env.OPENCODE_DATA_DIR ||
+  path.join(process.env.XDG_DATA_HOME || path.join(HOME, '.local', 'share'), 'opencode');
+const OPENCODE_DB = process.env.OPENCODE_DB || path.join(OPENCODE_DATA_DIR, 'opencode.db');
+
+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 resolveOpenCodeBin() {
+  if (process.env.OPENCODE_BIN) {
+    if (isExecutable(process.env.OPENCODE_BIN)) return process.env.OPENCODE_BIN;
+    throw new Error(`OPENCODE_BIN is not executable: ${process.env.OPENCODE_BIN}`);
+  }
+  const fromPath = findOnPath('opencode', process.env.PATH);
+  if (fromPath) return fromPath;
+  throw new Error('Could not find the opencode executable. Set OPENCODE_BIN or add opencode to PATH.');
+}
+
+function dbQuery(sql) {
+  const result = spawnSync(resolveOpenCodeBin(), ['db', sql, '--format', 'json'], {
+    encoding: 'utf8',
+    env: process.env,
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+  if (result.error) throw result.error;
+  if (result.status !== 0) throw new Error((result.stderr || '').trim() || `opencode db exited with code ${result.status}`);
+  return JSON.parse(result.stdout || '[]');
+}
+
+function sqlString(value) {
+  return `'${String(value).replace(/'/g, "''")}'`;
+}
+
+function parseJson(value, fallback) {
+  try { return JSON.parse(value || ''); } catch { return fallback; }
+}
+
+function collectText(value, out = []) {
+  if (!value) return out;
+  if (typeof value === 'string') {
+    if (value.trim()) out.push(value.trim());
+    return out;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) collectText(item, out);
+    return out;
+  }
+  if (typeof value === 'object') {
+    for (const key of ['text', 'content', 'prompt', 'message', 'title']) {
+      if (Object.prototype.hasOwnProperty.call(value, key)) collectText(value[key], out);
+    }
+  }
+  return out;
+}
+
+function messageRole(row, data) {
+  const type = String(row.type || data.role || data.type || '').toLowerCase();
+  if (type.includes('user') || type.includes('input')) return 'user';
+  if (type.includes('assistant') || type.includes('agent')) return 'assistant';
+  return type || 'message';
+}
+
+function listMessages(sessionId) {
+  const rows = dbQuery(
+    `select type, data from session_message where session_id = ${sqlString(sessionId)} order by seq asc`
+  );
+  return rows.map((row) => {
+    const data = parseJson(row.data, {});
+    return {
+      role: messageRole(row, data),
+      text: collectText(data).join(' ').replace(/\s+/g, ' ').trim(),
+    };
+  }).filter((message) => message.text);
+}
+
+function firstUserText(messages) {
+  const message = messages.find((item) => item.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 millisToIso(value) {
+  const number = Number(value);
+  if (!Number.isFinite(number) || number <= 0) return null;
+  return new Date(number).toISOString();
+}
+
+function sessionFromRow(row) {
+  const messages = listMessages(row.id);
+  const turns = messages.filter((message) => message.role === 'user').length;
+  return {
+    id: row.id,
+    file: '',
+    cwd: row.directory || '(unknown)',
+    startedAt: millisToIso(row.time_created),
+    updatedAt: millisToIso(row.time_updated),
+    cliVersion: row.version || '',
+    provider: row.model || '',
+    turns,
+    first: row.title || firstUserText(messages),
+    last: lastText(messages, 'user'),
+    lastAssistant: lastText(messages, 'assistant'),
+    messages,
+    archived: Boolean(row.time_archived),
+    backend: 'opencode',
+  };
+}
+
+function listSessions() {
+  const rows = dbQuery(
+    'select id, title, directory, version, model, time_created, time_updated, time_archived from session order by time_updated desc'
+  );
+  return rows.map(sessionFromRow);
+}
+
+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 runArgv(argv, cwd, inherit) {
+  if (inherit) {
+    const child = spawn(argv[0], argv.slice(1), { stdio: 'inherit', cwd, env: process.env });
+    child.on('error', (err) => { console.error(`error: failed to start opencode: ${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(argv[0], argv.slice(1), { stdio: 'inherit', cwd, env: process.env });
+  if (result.error) throw new Error(`failed to start opencode: ${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 = resolveOpenCodeBin();
+  const cwd = usableCwd(session.cwd);
+  switch (command) {
+    case 'resume':
+      {
+        const argv = [executable, cwd, '--session', session.id];
+        if (args && args.length) argv.push('--prompt', args.join(' '));
+        return runArgv(argv, cwd, inherit);
+      }
+    case 'fork':
+      return runArgv([executable, cwd, '--session', session.id, '--fork'], cwd, inherit);
+    case 'delete': {
+      const status = runArgv([executable, 'session', 'delete', session.id], cwd, false);
+      if (status === 0) removeMetadata(session);
+      return status;
+    }
+    case 'archive':
+      dbQuery(`update session set time_archived = ${Date.now()} where id = ${sqlString(session.id)}`);
+      return 0;
+    case 'unarchive':
+      dbQuery(`update session set time_archived = null where id = ${sqlString(session.id)}`);
+      return 0;
+    default:
+      throw new Error(`Unknown command for opencode backend: ${command}`);
+  }
+}
+
+function runNew(cwd, args, inherit) {
+  const resolvedCwd = usableCwd(cwd);
+  const argv = [resolveOpenCodeBin(), resolvedCwd];
+  if (args && args.length) argv.push('--prompt', args.join(' '));
+  return runArgv(argv, resolvedCwd, inherit);
+}
+
+function isAvailable() {
+  try {
+    resolveOpenCodeBin();
+    return fs.statSync(OPENCODE_DB).isFile();
+  } catch {
+    return false;
+  }
+}
+
+function getSessionFiles() {
+  return [];
+}
+
+function resolveBin() {
+  try { return resolveOpenCodeBin(); } catch { return null; }
+}
+
+module.exports = {
+  id: 'opencode',
+  label: 'opencode',
+  capabilities: {
+    new: true,
+    resume: true,
+    fork: true,
+    archive: true,
+    unarchive: true,
+    delete: true,
+  },
+  isAvailable,
+  getSessionFiles,
+  listSessions,
+  resolveBin,
+  runCommand: runSessionCommand,
+  runNew,
+};

package/src/ui/workbench.js

@@ -94,6 +94,7 @@ async function runWorkbench() {
     mouse: true,
     keys: true,
     vi: false,
+    tags: true,
     scrollbar: { ch: ' ', track: { bg: 'black' }, style: { bg: 'cyan' } },
     style: {
       border: { fg: 'cyan' },
@@ -225,6 +226,18 @@ async function runWorkbench() {
 
   const styledListLabel = (color, text) => `{${color}-fg}{bold}${blessed.escape(text)}{/}`;
 
+  const backendThemes = {
+    codex: 'cyan',
+    pi: 'magenta',
+    opencode: 'green',
+  };
+
+  const backendLabel = (backend, width = 0) => {
+    const text = backend || 'unknown';
+    const color = backendThemes[text] || 'yellow';
+    return `{${color}-fg}{bold}${blessed.escape(text.padEnd(width))}{/}`;
+  };
+
   const machineLabel = (source, count) => {
     const shortcut = sourceShortcut(source);
     const prefix = shortcut ? `${shortcut} ` : '';
@@ -248,14 +261,12 @@ async function runWorkbench() {
   };
 
   const sessionLabel = (session) => {
-    const flags = [
-      session.backend || '',
-      session.name ? 'renamed' : '',
-      session.note ? 'note' : '',
-    ].filter(Boolean).join(',');
     const title = session.name || session.first || session.last || '(no prompt)';
-    const flagText = flags ? `[${flags}]` : '';
-    return `${shortId(session.id)}  ${String(session.turns).padStart(2)}t  ${truncate(localTime(session.updatedAt), 18)}  ${flagText} ${truncate(title, 88)}`;
+    const width = Math.max(24, (screen.width || 80) - projectWidth - 8);
+    const backendWidth = Math.max(8, Math.min(12, String(session.backend || 'unknown').length + 2));
+    const time = truncate(localTime(session.updatedAt), 18).padEnd(18);
+    const detailWidth = Math.max(12, width - backendWidth - 22);
+    return `${backendLabel(session.backend, backendWidth)}  ${time}  ${blessed.escape(truncate(title, detailWidth))}`;
   };
 
   const detailContent = (session) => {