@jlongo78/agent-spaces 1.0.0 → 1.0.2

package/bin/lib/runtime/claude-sessions.js

@@ -9,22 +9,33 @@
 // conversation exactly. Guessing from the newest transcript in the pane's
 // folder instead picks up any other Claude working in the same folder.
 //
+// Windows has no `ps`, and ancestry breaks there anyway: the `claude` shim
+// is a shell script that `exec`s the real program, and Git Bash leaves a
+// dead pid in the chain when it does. What every process in a pane does
+// share is the pane's console, so on Windows the pane is found by asking
+// which processes are attached to its console instead.
+//
 // Recorded so that a pane stopped by a server restart or a reboot resumes
 // its conversation (pane.restart) rather than starting a new one.
 
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
-const { execFile } = require('child_process');
+const { execFile, fork } = require('child_process');
 
 const POLL_MS = 5000;
 // Deeper than any shell → wrapper → node → claude chain, and a bound on a
 // corrupt table that loops.
 const MAX_DEPTH = 32;
+// A console-list helper that hangs is given up on; the pane stays unplaced
+// and is looked at again next tick.
+const CONSOLE_LIST_MS = 5000;
 
-/** pid → ppid from `ps`, or null where that is unavailable (Windows). */
-function readProcessTree(callback, run = execFile) {
-  if (process.platform === 'win32') return callback(null);
+/**
+ * pid → ppid from `ps`, or null when it cannot be read. `panes` is unused
+ * here; the Windows reader takes the same arguments.
+ */
+function readProcessTree(panes, callback, run = execFile) {
   run('ps', ['-A', '-o', 'pid=,ppid='], { timeout: 3000 }, (error, stdout) => {
     if (error) return callback(null);
     const tree = new Map();
@@ -32,10 +43,59 @@ function readProcessTree(callback, run = execFile) {
       const [pid, ppid] = line.trim().split(/\s+/).map(Number);
       if (Number.isInteger(pid) && Number.isInteger(ppid)) tree.set(pid, ppid);
     }
-    callback(tree);
+    callback(tree.size ? tree : null);
   });
 }
 
+// node-pty ships this helper for its own kill(): it must run in a separate
+// process, since a process can attach to only one console at a time.
+function consoleListAgent() {
+  try { return require.resolve('node-pty/lib/conpty_console_list_agent'); } catch { return null; }
+}
+
+/** The pids attached to the console of `pid`, or [] when that cannot be read. */
+function readConsoleProcesses(pid, callback, forkProcess = fork) {
+  const agentPath = consoleListAgent();
+  if (!agentPath) return callback([]);
+  let agent;
+  try {
+    agent = forkProcess(agentPath, [String(pid)], { stdio: ['ignore', 'ignore', 'ignore', 'ipc'], windowsHide: true });
+  } catch {
+    return callback([]);
+  }
+  let done = false;
+  const finish = (list) => {
+    if (done) return;
+    done = true;
+    clearTimeout(timer);
+    callback(list);
+  };
+  const timer = setTimeout(() => { try { agent.kill(); } catch { /* gone */ } finish([]); }, CONSOLE_LIST_MS);
+  agent.on('message', (m) => finish(Array.isArray(m?.consoleProcessList) ? m.consoleProcessList.filter(Number.isInteger) : []));
+  agent.on('error', () => finish([]));
+  agent.on('exit', () => finish([]));
+}
+
+/**
+ * The Windows reader: a tree in which every process attached to a pane's
+ * console hangs directly off that pane's pid, so matchSessions needs one
+ * step. Null when no console could be read, so the watcher tries again.
+ */
+function readConsoleTree(panes, callback, readConsole = readConsoleProcesses) {
+  const shells = panes.filter(p => Number.isInteger(p.pid));
+  if (!shells.length) return callback(null);
+  const tree = new Map();
+  let pending = shells.length;
+  let anyRead = false;
+  for (const { pid } of shells) {
+    readConsole(pid, (list) => {
+      if (list.length) anyRead = true;
+      for (const member of list) if (member !== pid) tree.set(member, pid);
+      if (--pending === 0) callback(anyRead ? tree : null);
+    });
+  }
+}
+
 /** `{ pid, sessionId }` for every interactive Claude session file. */
 function readClaudeSessions(home, fsMod = fs) {
   const dir = path.join(home, '.claude', 'sessions');
@@ -86,23 +146,55 @@ function matchSessions(panes, sessions, tree) {
  */
 function createClaudeSessionWatcher({
   listPanes, onSession, home = os.homedir(), intervalMs = POLL_MS,
-  readTree = readProcessTree, readSessions = readClaudeSessions,
+  readTree = process.platform === 'win32' ? readConsoleTree : readProcessTree,
+  readSessions = readClaudeSessions,
 }) {
   let busy = false;
+  // A process's parents are fixed when it starts, so a session's pid, once
+  // placed in a pane (or in none), needs no second look at the process
+  // table: /resume and /clear change the sessionId under the same pid.
+  // Forgotten when the set of panes changes, since a pane listed late may be
+  // the one a session already looked at belongs to.
+  const placed = new Map(); // pid → paneId | null
+  let placedFor = '';
+
+  function report(panes, found) {
+    for (const [paneId, sessionId] of found) {
+      const pane = panes.find(p => p.paneId === paneId);
+      if (pane && pane.sessionId !== sessionId) {
+        try { onSession(paneId, sessionId); } catch { /* bookkeeping only */ }
+      }
+    }
+  }
+
   function tick() {
     if (busy) return;
     const panes = listPanes();
     if (!panes.length) return;
+    const key = panes.map(p => `${p.paneId}:${p.pid}`).sort().join(',');
+    if (key !== placedFor) { placed.clear(); placedFor = key; }
+    const sessions = readSessions(home);
+    const current = new Set(sessions.map(s => s.pid));
+    for (const pid of placed.keys()) if (!current.has(pid)) placed.delete(pid);
+
+    const known = new Map();
+    for (const { pid, sessionId } of sessions) {
+      const paneId = placed.get(pid);
+      if (paneId) known.set(paneId, sessionId);
+    }
+    report(panes, known);
+    const unplaced = sessions.filter(s => !placed.has(s.pid));
+    if (!unplaced.length) return;
+
     busy = true;
-    readTree((tree) => {
+    readTree(panes, (tree) => {
       busy = false;
       if (!tree) return;
-      for (const [paneId, sessionId] of matchSessions(panes, readSessions(home), tree)) {
-        const pane = panes.find(p => p.paneId === paneId);
-        if (pane && pane.sessionId !== sessionId) {
-          try { onSession(paneId, sessionId); } catch { /* bookkeeping only */ }
-        }
+      for (const s of unplaced) {
+        const [paneId] = matchSessions(panes, [s], tree).keys();
+        placed.set(s.pid, paneId ?? null);
       }
+      report(panes, matchSessions(panes, unplaced, tree));
     });
   }
   const timer = setInterval(tick, intervalMs);
@@ -110,4 +202,7 @@ function createClaudeSessionWatcher({
   return { tick, stop: () => clearInterval(timer) };
 }
 
-module.exports = { createClaudeSessionWatcher, matchSessions, readClaudeSessions, readProcessTree };
+module.exports = {
+  createClaudeSessionWatcher, matchSessions, readClaudeSessions,
+  readProcessTree, readConsoleTree, readConsoleProcesses,
+};

package/bin/lib/runtime/index.js

@@ -1000,7 +1000,7 @@ function createRuntime({ nodeId = 'local', spacesDbPath, getApiPort, federationD
         // spawnPane starts only the shell. A fresh pane gets its agent from
         // the client's follow-up agent.start; a restart types it here, so the
         // pane comes back running what it ran before with no second call.
-        if (spawned.launchCommand) writePane(params.paneId, `${spawned.launchCommand}
+        if (spawned.launchCommand) writePane(params.paneId, `${spawned.launchCommand}\r`);
         return ok({ paneId: params.paneId, workspaceId, agentType, cwd, resumed: Boolean(agentSession), launchCommand: spawned.launchCommand });
       }