@volter/supercode-terminal 0.2.39 → 0.2.41

package/index.mjs

@@ -1,6 +1,8 @@
 import { execFile, spawn, spawnSync } from 'node:child_process';
 import { randomBytes, randomUUID } from 'node:crypto';
-import { existsSync } from 'node:fs';
+import { appendFileSync, cpSync, existsSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
 import { connect as netConnect } from 'node:net';
 import { fileURLToPath } from 'node:url';
 import { createServer as defaultCreateServer } from 'node:http';
@@ -508,6 +510,18 @@ for (const event of ['end', 'close', 'error']) process.stdin.on(event, sweep);
  * disposing), so every pane here is this host's own. As with tmux's `remain-on-exit failed`, a pane whose program
  * fails stays listed and capturable, marked dead, until it is closed; one that exits cleanly leaves at once.
  */
+/**
+ * A pane's end in the pane-exit log, as the tmux lane's hooks write it (`<time> <pane> closed`, or `died status=…
+ * signal=…` when it failed), under SUPERCODE_HOME or ~/.config/supercode: the machine daemon tells a clean finish from
+ * a failure by it, and a ConPTY pane that ended cleanly is otherwise gone without a trace.
+ */
+function recordPaneExit(contextKey, exitCode, signal) {
+  if (!contextKey) return;
+  const at = new Date().toISOString().slice(0, 19);
+  const line = exitCode === 0 && !signal ? `${at} ${contextKey} closed\n` : `${at} ${contextKey} died status=${exitCode ?? ''} signal=${signal || ''}\n`;
+  try { appendFileSync(join(process.env.SUPERCODE_HOME || join(homedir(), '.config', 'supercode'), 'pane-exits.log'), line); } catch { /* no log is no worse than before */ }
+}
+
 export class PtyTerminalHost {
   #attachments = new Map();
   #liveAttachments = new Set();
@@ -584,6 +598,7 @@ export class PtyTerminalHost {
         // server) outlives it, as it outlives a tmux pane. What stayed in the pane's console ends with the console.
         // Only closing a pane, or its daemon dying, ends a whole tree.
         releasePane(child);
+        recordPaneExit(entry.contextKey, exitCode, signal);
         this.#tellExit(entry);
         this.#writeWatchList();
         if (exitCode === 0) this.#forget(entry);
@@ -904,6 +919,20 @@ export class PtyTerminalHost {
  * connection; the panes and their programs go on, and the next daemon finds them there. The server starts on first
  * use, detached, and leaves a minute after it holds no pane and no client.
  */
+/** What the pane server loads beyond this package (PtyTerminalHost's dynamic imports). */
+const PANE_RUNTIME_PACKAGES = ['@homebridge/node-pty-prebuilt-multiarch', '@xterm/headless', '@xterm/addon-serialize'];
+
+/** A dependency's package directory: the nearest one above its entry named for it (ESM resolution, as it is loaded). */
+function packageDir(name) {
+  let dir = dirname(fileURLToPath(import.meta.resolve(name)));
+  for (;;) {
+    try { if (JSON.parse(readFileSync(join(dir, 'package.json'), 'utf8')).name === name) return dir; } catch { /* not a package root */ }
+    const up = dirname(dir);
+    if (up === dir) throw new Error(`no package directory for ${name}`);
+    dir = up;
+  }
+}
+
 export class PaneServerHost {
   #connection = null;
   #connecting = null;
@@ -912,11 +941,44 @@ export class PaneServerHost {
   #streams = new Map();
   #pipe;
   #serverScript;
+  #runtimeDir;
 
+  /**
+   * `runtimeDir`: where the pane server runs from, a copy of this package and its runtime dependencies per version
+   * (`<runtimeDir>/<version>`). A running pane server holds node-pty's native module open, and Windows cannot replace
+   * a file in use, so a server started from the installed package would stop the next install of it; started from its
+   * own copy, it leaves the installed package free to change under it. Without one, it runs from the package.
+   */
   constructor(options = {}) {
     if (!options.pipe) throw new TypeError('PaneServerHost requires a pipe name');
     this.#pipe = options.pipe;
-    this.#serverScript = options.serverScript ?? fileURLToPath(new URL('./substrate/pane-server.mjs', import.meta.url));
+    this.#serverScript = options.serverScript ?? null;
+    this.#runtimeDir = options.runtimeDir ?? null;
+  }
+
+  /** The pane server's script: its own versioned copy under runtimeDir, made once, else the package's. */
+  #script() {
+    if (this.#serverScript) return this.#serverScript;
+    const installed = fileURLToPath(new URL('./substrate/pane-server.mjs', import.meta.url));
+    if (!this.#runtimeDir) return installed;
+    const root = fileURLToPath(new URL('.', import.meta.url));
+    const version = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8')).version;
+    const target = join(this.#runtimeDir, version);
+    const script = join(target, 'node_modules', '@volter', 'supercode-terminal', 'substrate', 'pane-server.mjs');
+    if (existsSync(join(target, '.complete'))) return script;
+    try {
+      const staging = `${target}.${process.pid}.staging`;
+      rmSync(staging, { recursive: true, force: true });
+      cpSync(root, join(staging, 'node_modules', '@volter', 'supercode-terminal'), { recursive: true, filter: (path) => !path.slice(root.length).split(/[\\/]/).includes('node_modules') });
+      for (const name of PANE_RUNTIME_PACKAGES) cpSync(packageDir(name), join(staging, 'node_modules', ...name.split('/')), { recursive: true });
+      writeFileSync(join(staging, '.complete'), `${version}\n`);
+      rmSync(target, { recursive: true, force: true });
+      renameSync(staging, target);
+      return script;
+    } catch {
+      // A copy that cannot be made (a full disk, a racing daemon) leaves the package's own script, as before.
+      return existsSync(join(target, '.complete')) ? script : installed;
+    }
   }
 
   listSessions() { return this.#request('listSessions', []); }
@@ -998,7 +1060,7 @@ export class PaneServerHost {
       } catch (error) {
         // No server on the pipe yet: start one, detached from this daemon, and try again as it comes up.
         if (attempt === 0 && (error.code === 'ENOENT' || error.code === 'ECONNREFUSED')) {
-          const child = spawn(process.execPath, [this.#serverScript, this.#pipe], { detached: true, stdio: 'ignore', windowsHide: true, env: process.env });
+          const child = spawn(process.execPath, [this.#script(), this.#pipe], { detached: true, stdio: 'ignore', windowsHide: true, env: process.env });
           child.on('error', () => {});
           child.unref();
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-terminal",
-  "version": "0.2.39",
+  "version": "0.2.41",
   "type": "module",
   "description": "Optional leak-safe terminal and tmux host adapter for Volter Harness frontends",
   "exports": {