@volter/supercode-terminal 0.2.60 → 0.2.62

package/index.mjs

@@ -1069,12 +1069,20 @@ export class PaneServerHost {
   }
 
   async #request(op, args, extra = {}) {
-    const connection = await this.#connect();
-    const id = this.#next++;
-    return new Promise((resolve, reject) => {
-      this.#pending.set(id, { resolve, reject });
-      connection.write(`${JSON.stringify({ id, op, args, ...extra })}\n`);
-    });
+    // A server that is leaving refuses a request unrun (`pane_server_restarting`): it is asked again of the next one.
+    for (let attempt = 0; ; attempt += 1) {
+      const connection = await this.#connect();
+      const id = this.#next++;
+      try {
+        return await new Promise((resolve, reject) => {
+          this.#pending.set(id, { resolve, reject, connection });
+          connection.write(`${JSON.stringify({ id, op, args, ...extra })}\n`);
+        });
+      } catch (error) {
+        if (error?.code !== 'pane_server_restarting' || attempt >= 20) throw error;
+        await sleep(250);
+      }
+    }
   }
 
   #connect() {
@@ -1124,15 +1132,27 @@ export class PaneServerHost {
         const waiter = this.#pending.get(message.id);
         if (!waiter) continue;
         this.#pending.delete(message.id);
-        if (message.error) waiter.reject(new TerminalHostError(message.error.code, message.error.message));
+        if (message.error) {
+          // The server ends after a runtime that failed to load: the next request opens a new connection.
+          // The server is leaving: this client lets go of it, and its next request opens (or starts) the next one.
+          if (message.error.code === 'pane_runtime_missing' || message.error.code === 'pane_server_restarting') {
+            if (this.#connection === connection) this.#connection = null;
+            connection.end();
+          }
+          waiter.reject(new TerminalHostError(message.error.code, message.error.message));
+        }
         else waiter.resolve(message.result);
       }
     });
     // The server went (or this connection did): waiting requests fail, and viewers are told; the next call reconnects.
     connection.on('close', () => {
       if (this.#connection === connection) this.#connection = null;
-      for (const waiter of this.#pending.values()) waiter.reject(new TerminalHostError('pane_server_unreachable', 'The pane server connection closed.'));
-      this.#pending.clear();
+      // Only the requests sent on this connection fail with it; one already replaced keeps the next one's requests.
+      for (const [id, waiter] of this.#pending) {
+        if (waiter.connection && waiter.connection !== connection) continue;
+        this.#pending.delete(id);
+        waiter.reject(new TerminalHostError('pane_server_unreachable', 'The pane server connection closed.'));
+      }
       for (const relay of [...this.#streams.values()]) { relay.disposed = true; relay.socket?.close?.(1011, 'pane server connection closed'); }
       this.#streams.clear();
     });

package/package.json

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

package/substrate/pane-server.mjs

@@ -20,6 +20,18 @@ const clients = new Set();
 const IDLE_EXIT_MS = 60_000;
 let idleTimer = null;
 
+let leaving = false;
+/**
+ * Leave once no client holds a connection: each client closes its own on the answer that says the runtime is missing
+ * (or on a refusal while this server is leaving), so nothing it sends is lost between servers. A client that never
+ * closes (an older daemon) is ended after a few seconds.
+ */
+function leave() {
+  const done = () => { host.dispose(); process.exit(0); };
+  if (!clients.size) done();
+  setTimeout(() => { server.close(); for (const connection of clients) connection.end(); setTimeout(done, 500); }, 3_000).unref?.();
+}
+
 const OPS = new Set(['listSessions', 'createSession', 'capture', 'sendInput', 'closeSession', 'renameWindow', 'issueAttachment', 'bindContext']);
 
 function scheduleIdleExit() {
@@ -86,19 +98,23 @@ const server = createServer((connection) => {
       const { id, op, args = [] } = message;
       if (op === 'attach') { attach(id, args, message.stream); continue; }
       if (!OPS.has(op)) { refuse(id, { code: 'unsupported', message: `pane server: no operation ${op}` }); continue; }
+      // A server that is leaving runs nothing more: the request is refused unrun, and its client asks the next server.
+      if (leaving) { refuse(id, { code: 'pane_server_restarting', message: 'The pane server is restarting; ask again.' }); continue; }
       Promise.resolve().then(() => host[op](...args)).then((result) => answer(id, result), async (error) => {
-        refuse(id, error);
-        // The pane runtime failed to load in this process: with no pane to keep, it ends once the answer is out, so
+        // The pane runtime failed to load in this process: with no pane to keep, it ends once its answers are out, so
         // the next request starts a pane server that loads the runtime afresh (one installed since this one started).
-        if (error?.code === 'pane_runtime_missing' && !(await host.listSessions().catch(() => [])).length) {
-          connection.end(() => { host.dispose(); process.exit(0); });
-        }
+        if (error?.code === 'pane_runtime_missing') leaving = true;
+        refuse(id, error);
+        if (!leaving) return;
+        if ((await host.listSessions().catch(() => [])).length) { leaving = false; return; }
+        leave();
       });
     }
   });
   // A client that goes (its daemon restarting) takes only its viewers with it: the panes stay.
   connection.on('close', () => {
     clients.delete(connection);
+    if (leaving && !clients.size) { host.dispose(); process.exit(0); }
     for (const { socketLike, attachment } of streams.values()) { socketLike.emitClose(); attachment?.dispose(); }
     streams.clear();
     scheduleIdleExit();

package/substrate/tmux.js

@@ -59,12 +59,22 @@ export async function createSession({ command, cwd, env, name, owner, ownerOptio
     // set-options just configured. On an already-running server they are simply
     // reapplied.
     const sessionEnv = env ?? {};
+    // A tmux server keeps the environment of whoever started it as its global environment, and every pane inherits
+    // it. When an agent's session started the server (or is the launcher), that includes the session's own harness
+    // identity, so a new pane would resolve as that session. A pane's identity is only what its own session sets:
+    // every identity variable the server or the launcher holds and the session does not set is unset in the pane.
+    const identity = /^(CLAUDECODE|CLAUDE_CODE_SESSION_ID|CLAUDE_CODE_ENTRYPOINT|CODEX_THREAD_ID|CODEX_SESSION_ID|SUPERCODE_CALLER|SUPERCODE_CALLER_NAME|SUPERCODE_AGENT_[A-Z_]+)$/;
+    const serverNames = await runAsync("tmux", tmuxArgs(socket, ["show-environment", "-g"]))
+        .then((out) => out.split("\n").map((line) => /^([A-Za-z_][A-Za-z0-9_]*)=/.exec(line)?.[1]).filter((name) => Boolean(name)))
+        .catch(() => []); // no server yet: the one this creates starts from this launcher's environment
+    const inherited = [...new Set([...serverNames, ...Object.keys(process.env)])]
+        .filter((name) => identity.test(name) && !(name in sessionEnv));
     const bootstrapDirectories = [];
     const paneBootstrapArgs = (pane) => {
         const commandArgs = command === undefined ? [] : [command.program, ...(command.arguments ?? [])];
         // With neither command nor overrides, retain tmux's default-shell and
         // default-command behavior rather than choosing a shell for it.
-        if (command === undefined && Object.keys(sessionEnv).length === 0)
+        if (command === undefined && Object.keys(sessionEnv).length === 0 && inherited.length === 0)
             return [];
         // The complete command rides the private bootstrap file as well as its
         // environment. tmux's command message is bounded (roughly 16 KiB), much
@@ -72,7 +82,7 @@ export async function createSession({ command, cwd, env, name, owner, ownerOptio
         const directory = mkdtempSync(join(tmpdir(), "tmux-session-env-"));
         bootstrapDirectories.push(directory);
         const shell = process.env.SHELL ?? "/bin/sh";
-        return writeSessionEnvironmentBootstrap(directory, pane, sessionEnv, commandArgs.length === 0 ? [shell, "-l"] : commandArgs);
+        return writeSessionEnvironmentBootstrap(directory, pane, sessionEnv, inherited, commandArgs.length === 0 ? [shell, "-l"] : commandArgs);
     };
     try {
         const startArgs = [...sessionServerOptionArgs(), "new-session", "-d", "-s", name];
@@ -395,7 +405,7 @@ function tmuxClientEnvironment(source = process.env) {
     }
     return environment;
 }
-function writeSessionEnvironmentBootstrap(directory, pane, environment, command) {
+function writeSessionEnvironmentBootstrap(directory, pane, environment, unset, command) {
     const environmentPath = join(directory, `pane-${pane}.env`);
     const wrapperPath = join(directory, `pane-${pane}.sh`);
     const lines = Object.entries(environment).map(([name, value]) => {
@@ -404,6 +414,7 @@ function writeSessionEnvironmentBootstrap(directory, pane, environment, command)
         }
         return `export ${name}=${shellQuote(value)}`;
     });
+    lines.unshift(...unset.map((name) => `unset ${name}`));
     writeFileSync(environmentPath, `${lines.join("\n")}\n`, { flag: "wx", mode: 0o600 });
     writeFileSync(wrapperPath, [
         "#!/bin/sh",