@bramblex/codex-workbench 0.1.5 → 0.1.6

package/README.md

@@ -111,7 +111,7 @@ Most commands accept a full session id, a unique prefix, a saved name, or a sess
 
 ## Interactive UI
 
-The UI groups sessions by source and working directory, with sources/projects on the left, sessions on the upper right, and details below. When you start or resume a session, Codex temporarily takes over the terminal; when Codex exits, codex-workbench redraws the UI.
+The UI groups sessions by source and working directory, with sources/projects on the left, sessions on the upper right, and details below. Local sessions render immediately, while remote SSH sources load in the background. When you start or resume a session, Codex temporarily takes over the terminal; when Codex exits, codex-workbench redraws the UI.
 
 Common keys:
 

package/package.json

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

package/src/services/session-sources.js

@@ -5,7 +5,7 @@ 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 { runRemoteCwb, runRemoteCwbJson, runRemoteCwbJsonAsync } = require('./ssh-runner');
 
 const LOCAL_SOURCE = {
   id: 'local',
@@ -41,9 +41,26 @@ function configuredSources() {
   return [LOCAL_SOURCE, ...listServers().map(sourceForServer)];
 }
 
+function sortSessions(sessions) {
+  sessions.sort((a, b) => new Date(b.updatedAt) - new Date(a.updatedAt));
+  return sessions;
+}
+
+function loadLocalWorkbenchSessions(sources = configuredSources()) {
+  const sessions = listSessions().map((session) => attachSource(session, LOCAL_SOURCE));
+  return { errors: [], sessions, sources };
+}
+
+function loadRemoteSourceSessions(source) {
+  return runRemoteCwbJsonAsync(source, ['list', '--json', '--compact']).then((remoteSessions) => {
+    if (!Array.isArray(remoteSessions)) throw new Error('remote list did not return an array');
+    return remoteSessions.map((session) => attachSource(session, source));
+  });
+}
+
 function loadWorkbenchSessions() {
   const sources = configuredSources();
-  const sessions = listSessions().map((session) => attachSource(session, LOCAL_SOURCE));
+  const sessions = loadLocalWorkbenchSessions(sources).sessions;
   const errors = [];
 
   for (const source of sources.filter((candidate) => candidate.remote)) {
@@ -56,7 +73,7 @@ function loadWorkbenchSessions() {
     }
   }
 
-  sessions.sort((a, b) => new Date(b.updatedAt) - new Date(a.updatedAt));
+  sortSessions(sessions);
   return { errors, sessions, sources };
 }
 
@@ -139,6 +156,8 @@ module.exports = {
   configuredSources,
   createSourceDirectory,
   listSourceDirectories,
+  loadLocalWorkbenchSessions,
+  loadRemoteSourceSessions,
   loadWorkbenchSessions,
   runSourceNewSession,
   runSourceSessionCommand,

package/src/services/ssh-runner.js

@@ -1,8 +1,10 @@
 'use strict';
 
-const { spawnSync } = require('child_process');
+const { spawn, spawnSync } = require('child_process');
 const { shellQuote } = require('./codex-runner');
 
+const DEFAULT_MAX_BUFFER = 64 * 1024 * 1024;
+
 function sshBaseArgs(server, opts = {}) {
   const args = [];
   if (opts.tty) args.push('-t');
@@ -21,11 +23,59 @@ function runRemoteCwb(server, argv, opts = {}) {
   return spawnSync('ssh', args, {
     encoding: opts.encoding,
     env: process.env,
-    maxBuffer: opts.maxBuffer || 64 * 1024 * 1024,
+    maxBuffer: opts.maxBuffer || DEFAULT_MAX_BUFFER,
     stdio: opts.stdio || (opts.encoding ? ['ignore', 'pipe', 'pipe'] : 'inherit'),
   });
 }
 
+function runRemoteCwbAsync(server, argv, opts = {}) {
+  const command = remoteCwbCommand(server, argv);
+  const args = [...sshBaseArgs(server, { tty: opts.tty }), command];
+  const maxBuffer = opts.maxBuffer || DEFAULT_MAX_BUFFER;
+  const encoding = opts.encoding || 'utf8';
+
+  return new Promise((resolve) => {
+    const child = spawn('ssh', args, {
+      env: process.env,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    let stdout = '';
+    let stderr = '';
+    let stdoutSize = 0;
+    let stderrSize = 0;
+    let settled = false;
+
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      resolve(result);
+    };
+
+    const append = (name, chunk) => {
+      const text = Buffer.isBuffer(chunk) ? chunk.toString(encoding) : String(chunk);
+      const size = Buffer.byteLength(text);
+      if (name === 'stdout') {
+        stdout += text;
+        stdoutSize += size;
+      } else {
+        stderr += text;
+        stderrSize += size;
+      }
+      if (stdoutSize + stderrSize > maxBuffer) {
+        child.kill();
+        const error = new Error('spawn ssh ENOBUFS');
+        error.code = 'ENOBUFS';
+        finish({ error, stdout, stderr, status: null, signal: 'SIGTERM' });
+      }
+    };
+
+    child.stdout.on('data', (chunk) => append('stdout', chunk));
+    child.stderr.on('data', (chunk) => append('stderr', chunk));
+    child.on('error', (error) => finish({ error, stdout, stderr, status: null, signal: null }));
+    child.on('close', (status, signal) => finish({ stdout, stderr, status, signal }));
+  });
+}
+
 function runRemoteCwbJson(server, argv) {
   const result = runRemoteCwb(server, argv, { encoding: 'utf8' });
   if (result.error) {
@@ -41,9 +91,26 @@ function runRemoteCwbJson(server, argv) {
   return JSON.parse(result.stdout || 'null');
 }
 
+async function runRemoteCwbJsonAsync(server, argv) {
+  const result = await runRemoteCwbAsync(server, argv, { encoding: 'utf8' });
+  if (result.error) {
+    if (result.error.code === 'ENOBUFS') {
+      throw new Error('remote output exceeded buffer; update the remote codex-workbench so compact listing is available');
+    }
+    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,
+  runRemoteCwbAsync,
   runRemoteCwbJson,
+  runRemoteCwbJsonAsync,
   sshBaseArgs,
 };

package/src/ui/workbench.js

@@ -9,6 +9,8 @@ const {
   LOCAL_SOURCE,
   createSourceDirectory,
   listSourceDirectories,
+  loadLocalWorkbenchSessions,
+  loadRemoteSourceSessions,
   loadWorkbenchSessions,
   runSourceNewSession,
   runSourceSessionCommand,
@@ -34,6 +36,9 @@ async function runWorkbench() {
   let syncingProjects = false;
   let projectWidth = 32;
   let activePanel = 'projects';
+  let remoteLoadId = 0;
+  let remoteLoading = false;
+  let closed = false;
 
   const screen = blessed.screen({
     smartCSR: true,
@@ -159,6 +164,17 @@ async function runWorkbench() {
 
   const currentGroup = () => groups[groupIndex] || groups[0] || { kind: 'all', source: null, cwd: null };
 
+  const groupKey = (group) => {
+    if (!group || group.kind === 'all') return 'all';
+    if (group.kind === 'source') return `source:${group.source.id}`;
+    return `project:${group.source.id}:${group.cwd}`;
+  };
+
+  const restoreGroupKey = (key) => {
+    const index = groups.findIndex((group) => groupKey(group) === key);
+    if (index !== -1) groupIndex = index;
+  };
+
   const currentSessions = () => {
     const group = currentGroup();
     if (group.kind === 'all') return sessions;
@@ -220,20 +236,101 @@ async function runWorkbench() {
     status.style.fg = isError ? 'red' : 'white';
   };
 
-  const reload = () => {
-    const state = loadWorkbenchSessions();
-    sources = state.sources;
-    sourceErrors = state.errors;
-    sessions = state.sessions.filter((s) => !s.archived && !s.hidden);
+  const visibleSession = (session) => !session.archived && !session.hidden;
+
+  const sortSessionList = (list) => {
+    list.sort((a, b) => new Date(b.updatedAt) - new Date(a.updatedAt));
+    return list;
+  };
+
+  const setSourceErrorMessage = () => {
+    if (!sourceErrors.length) return false;
+    const first = sourceErrors[0];
+    const detail = `${first.source.label}: ${first.error}`;
+    const prefix = sourceErrors.length === 1 ? 'Remote source failed' : `${sourceErrors.length} remote sources failed`;
+    setMessage(`${prefix}: ${truncate(detail, 100)}`, true);
+    return true;
+  };
+
+  const updateSessionViews = (preferredGroupKey = groupKey(currentGroup())) => {
     groups = buildGroups();
+    restoreGroupKey(preferredGroupKey);
     if (groupIndex >= groups.length) groupIndex = Math.max(0, groups.length - 1);
     const visible = currentSessions();
     if (selected >= visible.length) selected = Math.max(0, visible.length - 1);
-    if (sourceErrors.length && (!message || message === 'Ready')) {
-      const first = sourceErrors[0];
-      const detail = `${first.source.label}: ${first.error}`;
-      const prefix = sourceErrors.length === 1 ? 'Remote source failed' : `${sourceErrors.length} remote sources failed`;
-      setMessage(`${prefix}: ${truncate(detail, 100)}`, true);
+  };
+
+  const reloadLocal = (preserveRemote = true) => {
+    const preferredGroupKey = groupKey(currentGroup());
+    const state = loadLocalWorkbenchSessions();
+    const sourceIds = new Set(state.sources.map((source) => source.id));
+    const remoteSessions = preserveRemote
+      ? sessions.filter((session) => session.sourceRemote && sourceIds.has(session.sourceId))
+      : [];
+    sources = state.sources;
+    sourceErrors = sourceErrors.filter((item) => sourceIds.has(item.source.id));
+    sessions = sortSessionList([...state.sessions, ...remoteSessions].filter(visibleSession));
+    updateSessionViews(preferredGroupKey);
+  };
+
+  const replaceSourceSessions = (source, sourceSessions) => {
+    const preferredGroupKey = groupKey(currentGroup());
+    sessions = sortSessionList([
+      ...sessions.filter((session) => session.sourceId !== source.id),
+      ...sourceSessions.filter(visibleSession),
+    ]);
+    updateSessionViews(preferredGroupKey);
+  };
+
+  const renderRemoteUpdate = () => {
+    if (closed) return;
+    syncProjects();
+    syncList();
+    render();
+  };
+
+  const startRemoteReload = (quiet = false) => {
+    const remoteSources = sources.filter((source) => source.remote);
+    remoteLoadId += 1;
+    const loadId = remoteLoadId;
+    sourceErrors = [];
+    if (!remoteSources.length) {
+      remoteLoading = false;
+      return;
+    }
+
+    remoteLoading = true;
+    let completed = 0;
+    if (!quiet && (!message || message === 'Ready')) {
+      setMessage(`Loading ${remoteSources.length} remote source${remoteSources.length === 1 ? '' : 's'}...`);
+      renderRemoteUpdate();
+    }
+
+    for (const source of remoteSources) {
+      loadRemoteSourceSessions(source)
+        .then((sourceSessions) => {
+          if (closed || loadId !== remoteLoadId) return;
+          replaceSourceSessions(source, sourceSessions);
+        })
+        .catch((err) => {
+          if (closed || loadId !== remoteLoadId) return;
+          sourceErrors.push({ source, error: err.message });
+        })
+        .finally(() => {
+          if (closed || loadId !== remoteLoadId) return;
+          completed += 1;
+          remoteLoading = completed < remoteSources.length;
+          if (remoteLoading) {
+            if (!quiet && message.startsWith('Loading ')) {
+              setMessage(`Loading remote sources... ${completed}/${remoteSources.length}`);
+            }
+          } else if (sourceErrors.length) {
+            setSourceErrorMessage();
+          } else if (message.startsWith('Loading ')) {
+            setMessage('Remote sources loaded.');
+          }
+          renderRemoteUpdate();
+        });
     }
   };
 
@@ -356,12 +453,13 @@ async function runWorkbench() {
   const promptOpen = () => prompt.visible || question.visible || directoryPicker.isOpen();
 
   const leaveScreen = () => {
+    closed = true;
     screen.destroy();
   };
 
   const refreshAfterAction = (text, isError = false, focusCwd = null, focusSourceId = null) => {
     setMessage(text, isError);
-    reload();
+    reloadLocal();
     if (focusCwd) {
       const nextGroupIndex = groups.findIndex((group) => {
         return group.kind === 'project' &&
@@ -373,6 +471,7 @@ async function runWorkbench() {
     syncProjects();
     syncList();
     render();
+    startRemoteReload(true);
   };
 
   const selectGroup = (index) => {
@@ -453,8 +552,9 @@ async function runWorkbench() {
     }
   };
 
-  reload();
-  if (!sourceErrors.length) setMessage('Ready');
+  reloadLocal(false);
+  const remoteSourceCount = sources.filter((source) => source.remote).length;
+  setMessage(remoteSourceCount ? `Loading ${remoteSourceCount} remote source${remoteSourceCount === 1 ? '' : 's'}...` : 'Ready');
   applyLayout();
   syncProjects();
   syncList();
@@ -648,6 +748,7 @@ async function runWorkbench() {
 
   projectsList.focus();
   render();
+  startRemoteReload(true);
 
   return new Promise(() => {});
 }