agentp 1.14.0 → 2.0.1

package/lib/ocmux.js

@@ -1,35 +1,18 @@
 'use strict';
 
+// tmux helpers for the agentp v2 model ("sessions live in projects").
+//
+// A project owns a tmux window (TUI only — pane 0) plus a `.ocmux.json` state
+// file recording the target session. The OpenCode **server is user-managed**
+// (started with `opencode serve`); this module never starts or stops it. All
+// tmux interactions must go through `_tmux()`.
+
 const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
 const child_process = require('child_process');
 
 const SESSION = 'Opencode';
-// OpenCode v2 prints `server listening on http://...`; older versions printed
-// `opencode server listening on http://...`. Accept both.
-const URL_RE = /(?:opencode )?server listening on (http:\/\/[^\s]*)/;
-
-// Detect the OpenCode major version: v2 runs the TUI with `opencode --server`,
-// older versions used the `attach` subcommand. Returns null when undetectable.
-function detectOcMajor() {
-  const r = child_process.spawnSync('opencode', ['--version'], { encoding: 'utf8' });
-  const out = (r.stdout || '') + (r.stderr || '');
-  const m = out.match(/v?(\d+)\.(\d+)\./);
-  return m ? parseInt(m[1], 10) : null;
-}
-
-// Command to attach the TUI to a running server. OpenCode v2 dropped the
-// `attach` subcommand in favor of `opencode --server <url>`; older versions
-// still use `opencode attach --continue <url>`. Falls back to the legacy form
-// when the version cannot be detected (keeps old installations working).
-function tuiAttachCommand(url) {
-  const major = detectOcMajor();
-  if (major !== null && major >= 2) {
-    return `opencode --server '${url}' --continue`;
-  }
-  return `opencode attach --continue '${url}'`;
-}
 
 function _tmux(args) {
   const result = child_process.spawnSync('tmux', args, { encoding: 'utf8', maxBuffer: 1024 * 1024 });
@@ -74,15 +57,18 @@ function statefileFor(dir) {
   return path.join(dir, '.ocmux.json');
 }
 
+// Return the pane ID running the TUI in `windowIndex`, or null when the window
+// has no TUI. v2 layout: the TUI is the only pane (pane 0). Legacy layout
+// (transition only): pane 0 is a server and the TUI is a non-zero pane; the
+// last pane is used as the fallback.
 function tuiPaneId(windowIndex) {
   const r = _tmux(['list-panes', '-t', `${SESSION}:${windowIndex}`, '-F', '#{pane_id}\t#{pane_index}']);
   if (r.status !== 0) return null;
-  for (const line of r.stdout.trim().split('\n').filter(Boolean)) {
-    const [paneId, idx] = line.split('\t');
-    // Server is always pane 0, TUI is pane 1+
-    if (idx !== '0') return paneId;
-  }
-  return null;
+  const panes = r.stdout.trim().split('\n').filter(Boolean);
+  if (panes.length === 0) return null;
+  if (panes.length === 1) return panes[0].split('\t')[0];
+  // Legacy layout with a server pane — assume the last pane is the TUI.
+  return panes[panes.length - 1].split('\t')[0];
 }
 
 function windowByDir(dir) {
@@ -120,25 +106,15 @@ function activeWindowIndex() {
   return null;
 }
 
-// Get the URL of the active tmux window (the one currently selected in the Opencode session).
-function getActiveServer() {
-  const idx = activeWindowIndex();
-  if (idx == null) return null;
-  const dir = windowNameByIndex(idx);
-  if (!dir) return null;
-  const sf = statefileFor(dir);
-  if (!fs.existsSync(sf)) return null;
-  const state = readState(sf);
-  return state && state.url ? state.url : null;
-}
-
 function paneCount(windowIndex) {
   const r = _tmux(['list-panes', '-t', `${SESSION}:${windowIndex}`, '-F', '#{pane_id}']);
   if (r.status !== 0) return 0;
   return r.stdout.trim().split('\n').filter(Boolean).length;
 }
 
-function listServers() {
+// List project windows: every tmux window whose name is a directory holding a
+// `.ocmux.json`. Status derives from TUI pane liveness.
+function listProjects() {
   const sessionR = _tmux(['has-session', '-t', SESSION]);
   if (sessionR.status !== 0) return [];
 
@@ -151,155 +127,81 @@ function listServers() {
     const sf = statefileFor(dir);
     if (!fs.existsSync(sf)) continue;
     const state = readState(sf);
-    if (!state || !state.url) continue;
-    const tui = tuiPaneId(parseInt(idx, 10));
-    rows.push({ url: state.url, dir, index: parseInt(idx, 10), status: tui ? 'alive' : 'dead' });
+    if (!state) continue;
+    const winIdx = parseInt(idx, 10);
+    rows.push({
+      dir,
+      index: winIdx,
+      status: tuiPaneId(winIdx) != null ? 'alive' : 'dead',
+      session: state.session || null,
+      server: state.server || state.url || null,
+    });
   }
   return rows;
 }
 
-// Check the state of a server in a given directory.
-// Returns null if no .ocmux.json exists, or an object with status.
-function serverStatus(dir) {
-  const sf = statefileFor(dir);
-  const state = readState(sf);
-  if (!state || !state.url) return null;
-  const winIdx = windowByDir(dir);
-  const tui = winIdx != null ? tuiPaneId(winIdx) : null;
-  return {
-    dir,
-    url: state.url,
-    status: winIdx != null ? 'alive' : 'dead',
-    windowIndex: winIdx,
-    hasTui: tui != null,
-  };
+function isWindowZoomed(windowIndex) {
+  const r = _tmux(['list-windows', '-t', SESSION, '-F', '#{window_index}|#{window_zoomed_flag}']);
+  if (r.status !== 0) return false;
+  for (const line of r.stdout.trim().split('\n').filter(Boolean)) {
+    const [wi, z] = line.split('|');
+    if (parseInt(wi, 10) === windowIndex && z === '1') return true;
+  }
+  return false;
 }
 
-// List dead servers by scanning known directories for orphaned .ocmux.json files.
-// dirs: array of directories to check (e.g. from connections file).
-// Returns entries with status 'dead' that are not already in listServers().
-function listDeadServers(knownDirs) {
-  const alive = new Set(listServers().map(s => s.dir));
-  const dead = [];
-  for (const dir of knownDirs) {
-    if (alive.has(dir)) continue;
-    const status = serverStatus(dir);
-    if (status) dead.push(status);
-  }
-  return dead;
+// v2-only TUI launch command. `sessionId` may be null to continue the last one.
+function tuiAttachCommand(url, sessionId) {
+  if (sessionId) return `opencode --server '${url}' --session '${sessionId}'`;
+  return `opencode --server '${url}' --continue`;
 }
 
-// Switch tmux focus to the given server window and ensure the TUI pane is alive and zoomed.
-function activateServer(dir, index, url) {
-  const winIdx = index;
+function zoomPane(paneId) {
+  if (paneId) _tmux(['resize-pane', '-Z', '-t', paneId]);
+}
 
-  // Pin window name
-  _tmux(['set-window-option', '-t', `${SESSION}:${winIdx}`, 'automatic-rename', 'off']);
+// Focus a project window, restarting its TUI when dead (or opening it for the
+// first time). Reads nothing from disk — the caller supplies server/session.
+function activateProject(dir, index, server, session) {
+  const winIdx = index;
+  pinWindowName(winIdx);
 
-  // Restart TUI pane if dead
-  const tuiPane = tuiPaneId(winIdx);
+  let tuiPane = tuiPaneId(winIdx);
   if (!tuiPane) {
+    const cmd = tuiAttachCommand(server, session);
     const count = paneCount(winIdx);
-    if (count >= 2) {
+    if (count >= 1) {
       const panesR = _tmux(['list-panes', '-t', `${SESSION}:${winIdx}`, '-F', '#{pane_id}']);
-      if (panesR.status === 0) {
-        const panes = panesR.stdout.trim().split('\n').filter(Boolean);
-        const lastPane = panes[panes.length - 1];
-        const respawnR = _tmux(['respawn-pane', '-k', '-t', lastPane, tuiAttachCommand(url)]);
-        if (respawnR.status !== 0) {
-          _tmux(['send-keys', '-t', lastPane, tuiAttachCommand(url), 'Enter']);
-        }
+      const panes = panesR.status === 0 ? panesR.stdout.trim().split('\n').filter(Boolean) : [];
+      const lastPane = panes[panes.length - 1];
+      if (lastPane) {
+        const respawnR = _tmux(['respawn-pane', '-k', '-t', lastPane, cmd]);
+        if (respawnR.status !== 0) _tmux(['send-keys', '-t', lastPane, cmd, 'Enter']);
       }
     } else {
-      _tmux(['split-window', '-v', '-t', `${SESSION}:${winIdx}`, '-c', dir,
-        tuiAttachCommand(url)]);
+      _tmux(['send-keys', '-t', `${SESSION}:${winIdx}.0`, cmd, 'Enter']);
     }
   }
 
-  // Select window
   const activeWin = activeWindowIndex();
   if (activeWin !== null && activeWin !== winIdx) {
     _tmux(['select-window', '-t', `${SESSION}:${winIdx}`]);
   }
 
-  // Zoom TUI pane
-  const zoomR = _tmux(['list-windows', '-t', SESSION, '-F', '#{window_index}|#{window_zoomed_flag}']);
-  if (zoomR.status === 0) {
-    let zoomed = false;
-    for (const line of zoomR.stdout.trim().split('\n').filter(Boolean)) {
-      const [wi, z] = line.split('|');
-      if (parseInt(wi, 10) === winIdx && z === '1') { zoomed = true; break; }
-    }
-    if (!zoomed) {
-      const tui = tuiPaneId(winIdx);
-      if (tui) _tmux(['resize-pane', '-Z', '-t', tui]);
-    }
+  if (!isWindowZoomed(winIdx)) {
+    tuiPane = tuiPaneId(winIdx);
+    zoomPane(tuiPane);
   }
 
   return true;
 }
 
-// Recover a dead/crashed server: kill old window, remove state file,
-// create fresh server + TUI in the same directory.
-// Delegates to startServer for the actual server creation.
-// Returns { url, dir } on success, throws on error.
-function resurrectServer(dir, printLogs) {
-  try { dir = fs.realpathSync(dir); } catch {}
-  const sf = path.join(dir, '.ocmux.json');
-  const state = readState(sf);
-
-  // Kill old tmux window if it exists
-  if (state && state.window_index != null) {
-    let winIdx = state.window_index;
-    const sessionR = _tmux(['has-session', '-t', SESSION]);
-    if (sessionR.status === 0) {
-      const actualName = windowNameByIndex(winIdx);
-      if (actualName !== dir) {
-        const found = windowByDir(dir);
-        if (found == null) {
-          // No window exists for this directory — old server is already dead, skip kill
-          winIdx = null;
-        } else {
-          winIdx = found;
-        }
-      }
-      if (winIdx != null) {
-        _tmux(['select-window', '-t', `${SESSION}:${winIdx}`]);
-        _tmux(['send-keys', '-t', `${SESSION}:${winIdx}.0`, 'C-c']);
-        sleep(0.3);
-        const killR = _tmux(['kill-window', '-t', `${SESSION}:${winIdx}`]);
-        if (killR.status !== 0) {
-          throw new Error(`Failed to kill old tmux window ${winIdx}: ${killR.stderr || 'unknown error'}`);
-        }
-        // Wait for window to actually disappear (up to 2s)
-        for (let i = 0; i < 10; i++) {
-          if (windowByDir(dir) == null) break;
-          sleep(0.2);
-        }
-        if (windowByDir(dir) != null) {
-          throw new Error(`Old tmux window for ${dir} still exists after kill`);
-        }
-      }
-    }
-  }
-
-  // Remove old state file so we can create a fresh one
-  try { fs.unlinkSync(sf); } catch {}
-
-  // Start fresh server (same logic as ocmux serve)
-  return startServer(dir, printLogs);
-}
-
-// Start a new opencode server in the given directory.
-// Creates a tmux window, starts opencode serve, waits for the URL,
-// and writes .ocmux.json. Returns { url, dir } on success.
-function startServer(dir, printLogs) {
-  // Normalize to real path so tmux window names are consistent regardless of symlinks
+// Create a project TUI window (v2 layout: TUI is pane 0, no server pane).
+// Writes the v2 state file. The server must already be reachable.
+function createProjectWindow(dir, url, session) {
   try { dir = fs.realpathSync(dir); } catch {}
   ensureSession();
-  const lf = logfileFor(dir);
 
-  // Create a new tmux window and capture its index directly from the -P output
   const newWinR = _tmux(['new-window', '-d', '-P', '-F', '#{window_index}', '-t', SESSION, '-n', dir, '-c', dir]);
   if (newWinR.status !== 0) throw new Error(`failed to create tmux window for ${dir}`);
   let winIdx = parseInt(newWinR.stdout.trim(), 10);
@@ -310,46 +212,71 @@ function startServer(dir, printLogs) {
 
   pinWindowName(winIdx);
 
-  try { fs.truncateSync(lf); } catch {}
-
-  const serveFlags = printLogs ? '--print-logs' : '';
-  _tmux(['send-keys', '-t', `${SESSION}:${winIdx}.0`,
-    'opencode serve' + (serveFlags ? ' ' + serveFlags : '') + ` 2>&1 | tee '${lf}'`, 'Enter']);
+  const cmd = tuiAttachCommand(url, session);
+  _tmux(['send-keys', '-t', `${SESSION}:${winIdx}.0`, cmd, 'Enter']);
+  sleep(0.5);
+  const tuiPane = tuiPaneId(winIdx);
+  zoomPane(tuiPane);
 
-  let url = null;
-  for (let i = 0; i < 50; i++) {
-    sleep(0.2);
-    const log = (() => { try { return fs.readFileSync(lf, 'utf8'); } catch { return ''; } })();
-    const m = log.match(URL_RE);
-    if (m) { url = m[1]; break; }
+  const activeWin = activeWindowIndex();
+  if (activeWin !== null && activeWin !== winIdx) {
+    _tmux(['select-window', '-t', `${SESSION}:${winIdx}`]);
   }
 
-  if (!url) {
-    _tmux(['kill-window', '-t', `${SESSION}:${winIdx}`]);
-    throw new Error('opencode server did not start within 10 seconds');
-  }
+  const stateFile = path.join(dir, '.ocmux.json');
+  let existing = {};
+  try { existing = JSON.parse(fs.readFileSync(stateFile, 'utf8')); } catch {}
+  const state = { ...existing, version: 2, directory: dir, session: session || existing.session || null, server: url };
+  fs.writeFileSync(stateFile, JSON.stringify(state) + '\n');
 
-  const newState = { url, logfile: lf, window_index: winIdx };
-  fs.writeFileSync(path.join(dir, '.ocmux.json'), JSON.stringify(newState) + '\n');
+  return { url, dir, index: winIdx };
+}
 
-  const splitResult = _tmux(['split-window', '-v', '-P', '-F', '#{pane_id}', '-t', `${SESSION}:${winIdx}`, '-c', dir]);
-  const tuiPane = splitResult.stdout.trim();
-  sleep(0.2);
-  _tmux(['send-keys', '-t', tuiPane, tuiAttachCommand(url), 'Enter']);
-  sleep(0.5);
-  if (tuiPane) _tmux(['resize-pane', '-Z', '-t', tuiPane]);
+// Point an existing project window's TUI at `session` by relaunching the TUI
+// process (OpenCode v2 exposes no HTTP TUI-steering endpoint).
+function relaunchTui(windowIndex, dir, server, session) {
+  const cmd = tuiAttachCommand(server, session);
+  const tuiPane = tuiPaneId(windowIndex);
+  if (tuiPane) {
+    const respawnR = _tmux(['respawn-pane', '-k', '-t', tuiPane, cmd]);
+    if (respawnR.status !== 0) _tmux(['send-keys', '-t', tuiPane, cmd, 'Enter']);
+  } else {
+    _tmux(['send-keys', '-t', `${SESSION}:${windowIndex}.0`, cmd, 'Enter']);
+  }
+  sleep(0.4);
+  // Keep the project's own window active (switching sessions must not leave
+  // another project's window selected).
+  const active = activeWindowIndex();
+  if (active !== null && active !== windowIndex) {
+    _tmux(['select-window', '-t', `${SESSION}:${windowIndex}`]);
+  }
+  const pane = tuiPaneId(windowIndex);
+  if (pane && !isWindowZoomed(windowIndex)) zoomPane(pane);
+}
 
+// Focus the tmux window belonging to a project directory (best-effort). Used by
+// agentp so the target project's TUI window is the one shown when a prompt runs.
+// Returns the window index, or null when the directory has no window.
+function focusWindowByDir(dir) {
+  const idx = windowByDir(dir);
+  if (idx == null) return null;
   const activeWin = activeWindowIndex();
-  if (activeWin !== null && activeWin !== winIdx) {
-    _tmux(['select-window', '-t', `${SESSION}:${winIdx}`]);
+  if (activeWin !== null && activeWin !== idx) {
+    _tmux(['select-window', '-t', `${SESSION}:${idx}`]);
   }
+  const pane = tuiPaneId(idx);
+  if (pane && !isWindowZoomed(idx)) zoomPane(pane);
+  return idx;
+}
 
-  return { url, dir };
+// Close a project's tmux window (no server to stop in the v2 model).
+function closeProjectWindow(windowIndex) {
+  const r = _tmux(['kill-window', '-t', `${SESSION}:${windowIndex}`]);
+  if (r.status !== 0) throw new Error(`failed to kill window ${windowIndex}: ${r.stderr || 'unknown error'}`);
 }
 
 module.exports = {
   SESSION,
-  URL_RE,
   readState,
   statefileFor,
   tuiPaneId,
@@ -357,18 +284,17 @@ module.exports = {
   windowNameByIndex,
   activeWindowIndex,
   paneCount,
-  listServers,
-  activateServer,
-  getActiveServer,
+  listProjects,
+  activateProject,
+  relaunchTui,
+  focusWindowByDir,
+  closeProjectWindow,
+  createProjectWindow,
   hashDir,
   logfileFor,
   sleep,
   ensureSession,
   pinWindowName,
-  resurrectServer,
-  startServer,
-  serverStatus,
-  listDeadServers,
-  detectOcMajor,
   tuiAttachCommand,
-};
+  isWindowZoomed,
+};