@volter/supercode-terminal 0.3.1 → 0.3.2

package/index.mjs

@@ -1,7 +1,6 @@
 import { execFile, spawn, spawnSync } from 'node:child_process';
 import { randomBytes, randomUUID } from 'node:crypto';
 import { appendFileSync, cpSync, existsSync, mkdirSync, 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 { createRequire } from 'node:module';
@@ -177,6 +176,7 @@ export class TmuxTerminalHost {
   #allowUnownedControl;
   #answered = false;
   #dead = new Map();
+  #homes = new Map();
   #generation = 0;
   #listing = null;
   #attachments = new Map();
@@ -440,7 +440,8 @@ export class TmuxTerminalHost {
     this.#tmux.killSessionProcessTree({ session: entry.name, socket: this.#socket });
     // The close's own record: tmux's session-closed hook writes it too, but not when this session was the server's
     // last (the server exits before the hook's run-shell has started).
-    if (entry.name.startsWith('p_') && !paneExitRecorded(entry.name)) recordPaneExit(entry.name, 0, null, null, hookStamp());
+    const home = this.#homes.get(entry.name) || defaultTmux.paneExitHome();
+    if (entry.name.startsWith('p_') && !paneExitRecorded(entry.name, home)) recordPaneExit(entry.name, 0, null, null, hookStamp(), home);
     this.#generation += 1;
     this.#catalog.delete(sessionId);
     this.#idByName.delete(entry.name);
@@ -523,7 +524,11 @@ export class TmuxTerminalHost {
    * input, a close, a name's reuse). A pane session (p_*) in that state is finished off here as the pane-died hook
    * would: its end written to the pane-exit log when no line names the pane yet (the screen with it when it failed),
    * then the pane closed. So neither the record nor the pane's removal waits on a run-shell inside the server, which
-   * a server without `tmux` on its PATH cannot run. A session of another name is not this host's to close (tmux keeps
+   * a server without `tmux` on its PATH cannot run. The log is the pane's own, in the home of the host that made it
+   * (the session's `@supercode-home`), whichever host on the socket reads the pane first: a host finishing off
+   * another home's pane writes where that home's daemon reads, never under its own. The log is appended to and never
+   * rewritten, so a line is never lost; two writers that both find no line each append one, and every reader takes a
+   * pane's repeated line as one end. A session of another name is not this host's to close (tmux keeps
    * its failed pane for its last screen): it stays listed, marked `dead` with its `exitCode`, as the ConPTY host
    * marks one.
    */
@@ -539,15 +544,18 @@ export class TmuxTerminalHost {
     }
     const names = [];
     this.#dead.clear();
+    this.#homes.clear();
     for (const state of states) {
+      const home = state.home || defaultTmux.paneExitHome();
+      this.#homes.set(state.name, home);
       if (!state.dead) names.push(state.name);
       else if (!state.name.startsWith('p_')) { names.push(state.name); this.#dead.set(state.name, { exitCode: state.exitCode }); }
       else {
-        if (!paneExitRecorded(state.name)) {
+        if (!paneExitRecorded(state.name, home)) {
           const failed = state.exitCode !== 0 || Boolean(state.signal);
           let screen = null;
           if (failed) { try { screen = this.#tmux.capturePane({ lines: 200, preserveEscapes: true, socket: this.#socket, target: state.paneId }); } catch { /* the pane is gone */ } }
-          recordPaneExit(state.name, state.exitCode, state.signal, screen, hookStamp());
+          recordPaneExit(state.name, state.exitCode, state.signal, screen, hookStamp(), home);
         }
         this.#tmux.closeDeadPane({ paneId: state.paneId, session: state.name, socket: this.#socket });
         this.#generation += 1;
@@ -631,16 +639,14 @@ for (const event of ['end', 'close', 'error']) process.stdin.on(event, sweep);
  */
 /**
  * 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.
+ * signal=…` when it failed), in the home of the host that made the pane (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.
  */
-/** Whether the pane-exit log (either home's) holds a line of this pane's end. */
-function paneExitRecorded(pane) {
-  for (const root of new Set([process.env.SUPERCODE_HOME, join(homedir(), '.config', 'supercode')].filter(Boolean))) {
-    try { if (readFileSync(join(root, 'pane-exits.log'), 'utf8').split('\n').some((line) => line.endsWith(` ${pane} closed`) || line.includes(` ${pane} died `))) return true; }
-    catch { /* no log there */ }
-  }
-  return false;
+/** Whether `home`'s pane-exit log holds a line of this pane's end. */
+function paneExitRecorded(pane, home) {
+  try { return readFileSync(join(home, 'pane-exits.log'), 'utf8').split('\n').some((line) => line.endsWith(` ${pane} closed`) || line.includes(` ${pane} died `)); }
+  catch { return false; }
 }
 
 /** Now as the tmux hooks stamp a line (`date +%FT%T`, the machine's own time): one log's lines are ordered by it. */
@@ -649,12 +655,12 @@ function hookStamp() {
   return `${now.getFullYear()}-${two(now.getMonth() + 1)}-${two(now.getDate())}T${two(now.getHours())}:${two(now.getMinutes())}:${two(now.getSeconds())}`;
 }
 
-function recordPaneExit(contextKey, exitCode, signal, screen = null, at = new Date().toISOString().slice(0, 19)) {
+function recordPaneExit(contextKey, exitCode, signal, screen = null, at = new Date().toISOString().slice(0, 19), home = defaultTmux.paneExitHome()) {
   if (!contextKey) return;
   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 */ }
+  try { appendFileSync(join(home, 'pane-exits.log'), line); } catch { /* no log is no worse than before */ }
   if ((exitCode !== 0 || signal) && typeof screen === 'string' && /^p_[A-Za-z0-9_-]+$/.test(contextKey)) {
-    try { const dir=join(process.env.SUPERCODE_HOME || join(homedir(), '.config', 'supercode'),'pane-exits');mkdirSync(dir,{recursive:true,mode:0o700});writeFileSync(join(dir,`${contextKey}.screen`),Buffer.from(screen).subarray(-32768),{mode:0o600}); }
+    try { const dir=join(home,'pane-exits');mkdirSync(dir,{recursive:true,mode:0o700});writeFileSync(join(dir,`${contextKey}.screen`),Buffer.from(screen).subarray(-32768),{mode:0o600}); }
     catch { /* The receipt explicitly reports unavailable output. */ }
   }
 }

package/package.json

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

package/substrate/tmux.d.ts

@@ -28,6 +28,7 @@ export type CreateSessionOptions = {
     optionalSettings?: Record<string, string>;
     socket?: string;
 };
+export declare function paneExitHome(env?: NodeJS.ProcessEnv): string;
 export declare function assertTmux(): void;
 export declare function targetForSession(sessionName: string): string;
 export declare function assertSession(name: string, socket?: string): void;
@@ -60,6 +61,8 @@ export type TmuxSessionState = {
     exitCode: number | null;
     /** The signal that ended the program, as tmux names it; empty when it exited. */
     signal: string;
+    /** The home the pane's end is recorded in (`paneExitHome` of the host that made it); empty when tmux names none. */
+    home: string;
 };
 /**
  * Every session with whether its pane's program has ended, in one tmux process. A session whose pane is dead is

package/substrate/tmux.js

@@ -1,5 +1,5 @@
 import { existsSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
+import { homedir, tmpdir } from "node:os";
 import { join } from "node:path";
 import { isHarnessMarker } from "./harness-env.js";
 import { requireCommand, run, runAsync, runWithInputAsync, spawnInherited } from "./internal/exec.js";
@@ -12,6 +12,15 @@ const PTY_ALLOCATION_HINT = [
 ].join(" ");
 // Session-scoped tmux user option that records which provider created a session.
 const ownerOption = "@supercode-owner";
+// Where a pane's end is recorded: the home of the host that made it. Every session carries it in this user option,
+// set at creation, so the server's hooks write where that host reads, whatever environment the server was started
+// with and whichever other homes have panes on the socket. The server-wide value is the last host's to create a
+// session: what a session made before the option answers with, and what tmux gives the session-closed hook, which
+// runs after its session's own options are gone.
+const paneExitHomeOption = "@supercode-home";
+export function paneExitHome(env = process.env) {
+    return env.SUPERCODE_HOME || join(homedir(), ".config", "supercode");
+}
 // Optional dedicated tmux server (`tmux -L <socket>`). A `-L` server is fully
 // separate from the user's DEFAULT server — the default can't see it and
 // `kill-server` on it can't escape — so a provider (or a test) can run in
@@ -88,7 +97,11 @@ export async function createSession({ command, cwd, env, name, owner, ownerOptio
         return writeSessionEnvironmentBootstrap(directory, pane, sessionEnv, inherited, commandArgs.length === 0 ? [shell, "-l"] : commandArgs);
     };
     try {
-        const startArgs = [...sessionServerOptionArgs(), "new-session", "-d", "-s", name];
+        const exitHome = paneExitHome();
+        assertOptionValue(exitHome);
+        if (exitHome.endsWith(";"))
+            throw new Error(`The home a pane's end is recorded in cannot end in ";": ${exitHome}`);
+        const startArgs = [...sessionServerOptionArgs(exitHome), "new-session", "-d", "-s", name];
         if (cwd) {
             startArgs.push("-c", cwd);
         }
@@ -107,6 +120,7 @@ export async function createSession({ command, cwd, env, name, owner, ownerOptio
         };
         if (owner)
             setOnCreate(ownershipOption, owner);
+        setOnCreate(paneExitHomeOption, exitHome);
         for (const [option, value] of Object.entries(sessionOptions).sort(([left], [right]) => left.localeCompare(right))) {
             assertUserOption(option);
             setOnCreate(option, value);
@@ -333,8 +347,9 @@ export function killSessionProcessTree({ session, socket }) {
 export function listTmuxSessionNames(socket) {
     return run("tmux", tmuxArgs(socket, ["list-sessions", "-F", "#{session_name}"])).split("\n").map((line) => line.trim()).filter(Boolean);
 }
-// The name last: tmux guarantees a session name holds no colon, and the fields before it never do.
-const sessionStateFormat = "#{pane_id}:#{pane_dead}:#{pane_dead_status}:#{pane_dead_signal}:#{session_name}";
+// The home last, after the name: tmux guarantees a session name holds no colon, the fields before it never do, and a
+// path may.
+const sessionStateFormat = `#{pane_id}:#{pane_dead}:#{pane_dead_status}:#{pane_dead_signal}:#{session_name}:#{${paneExitHomeOption}}`;
 /**
  * Every session with whether its pane's program has ended, in one tmux process. A session whose pane is dead is
  * still a session to tmux (`list-sessions` names it, `has-session` finds it) though nothing runs in it: a caller
@@ -342,8 +357,8 @@ const sessionStateFormat = "#{pane_id}:#{pane_dead}:#{pane_dead_status}:#{pane_d
  */
 export function listSessionStates(socket) {
     return run("tmux", tmuxArgs(socket, ["list-sessions", "-F", sessionStateFormat])).split("\n").filter((line) => line.trim()).map((line) => {
-        const [paneId = "", dead = "", status = "", signal = "", ...name] = line.split(":");
-        return { name: name.join(":"), paneId, dead: dead === "1", exitCode: /^\d+$/.test(status) ? Number(status) : null, signal };
+        const [paneId = "", dead = "", status = "", signal = "", name = "", ...home] = line.split(":");
+        return { name, paneId, dead: dead === "1", exitCode: /^\d+$/.test(status) ? Number(status) : null, signal, home: home.join(":") };
     });
 }
 /**
@@ -429,12 +444,17 @@ async function declareSessionColorEnvironmentAsync(socket) {
 // the most recently used session instead, and that session's program was killed.
 // Targets are not expanded as formats, so the shell that run-shell starts resolves
 // the pane and does nothing when it no longer belongs to a p_* session.
-const PANE_EXIT_LOG = '"${SUPERCODE_HOME:-$HOME/.config/supercode}/pane-exits.log"';
-const PANE_EXIT_CAPTURE = 'case "$s" in *[!a-zA-Z0-9_-]*) exit 0 ;; esac; d="${SUPERCODE_HOME:-$HOME/.config/supercode}/pane-exits"; umask 077; mkdir -p "$d"; if t capture-pane -p -e -S -200 -t "$p" > "$d/$s.screen.part" 2>/dev/null; then tail -c 32768 "$d/$s.screen.part" > "$d/$s.screen"; fi; rm -f "$d/$s.screen.part"';
-const PANE_DIED_HOOK = "run-shell 'p=\"#{hook_pane}\"; t() { tmux -S \"#{socket_path}\" \"$@\"; }; r=$(t display -p -t \"$p\" \"##{pane_dead}|##{pane_dead_status}|##{pane_dead_signal}|##{session_name}\" 2>/dev/null) || exit 0; case \"$r\" in 1\\|*) ;; *) exit 0 ;; esac; st=$(printf %s \"$r\" | cut -d\"|\" -f2); sg=$(printf %s \"$r\" | cut -d\"|\" -f3); s=$(printf %s \"$r\" | cut -d\"|\" -f4-); case \"$s\" in p_*) ;; *) exit 0 ;; esac; if [ \"$st\" = 0 ] && [ -z \"$sg\" ]; then printf \"%s %s closed\\n\" \"$(date +%FT%T)\" \"$s\" >> " + PANE_EXIT_LOG + "; else printf \"%s %s died status=%s signal=%s\\n\" \"$(date +%FT%T)\" \"$s\" \"$st\" \"$sg\" >> " + PANE_EXIT_LOG + "; (" + PANE_EXIT_CAPTURE + "); fi; t kill-pane -t \"$p\"'";
-const SESSION_CLOSED_HOOK = "if-shell -F '#{m:p_*,#{hook_session_name}}' { run-shell 'printf \"%s %s closed\\n\" \"$(date +%FT%T)\" \"#{hook_session_name}\" >> " + PANE_EXIT_LOG + "' }";
-function sessionServerOptionArgs() {
+// The record goes to the pane's own home (`paneExitHomeOption`), read with the pane's
+// state into a shell variable: a pane that names none is left as it is, for its host
+// to finish off. The session-closed hook's session is gone, so tmux expands the option
+// there against the server (`q:` quotes it for the shell).
+const PANE_EXIT_LOG = '"$h/pane-exits.log"';
+const PANE_EXIT_CAPTURE = 'case "$s" in *[!a-zA-Z0-9_-]*) exit 0 ;; esac; d="$h/pane-exits"; umask 077; mkdir -p "$d"; if t capture-pane -p -e -S -200 -t "$p" > "$d/$s.screen.part" 2>/dev/null; then tail -c 32768 "$d/$s.screen.part" > "$d/$s.screen"; fi; rm -f "$d/$s.screen.part"';
+const PANE_DIED_HOOK = "run-shell 'p=\"#{hook_pane}\"; t() { tmux -S \"#{socket_path}\" \"$@\"; }; r=$(t display -p -t \"$p\" \"##{pane_dead}|##{pane_dead_status}|##{pane_dead_signal}|##{session_name}|##{" + paneExitHomeOption + "}\" 2>/dev/null) || exit 0; case \"$r\" in 1\\|*) ;; *) exit 0 ;; esac; st=$(printf %s \"$r\" | cut -d\"|\" -f2); sg=$(printf %s \"$r\" | cut -d\"|\" -f3); s=$(printf %s \"$r\" | cut -d\"|\" -f4); h=$(printf %s \"$r\" | cut -d\"|\" -f5-); case \"$s\" in p_*) ;; *) exit 0 ;; esac; [ -n \"$h\" ] || exit 0; if [ \"$st\" = 0 ] && [ -z \"$sg\" ]; then printf \"%s %s closed\\n\" \"$(date +%FT%T)\" \"$s\" >> " + PANE_EXIT_LOG + "; else printf \"%s %s died status=%s signal=%s\\n\" \"$(date +%FT%T)\" \"$s\" \"$st\" \"$sg\" >> " + PANE_EXIT_LOG + "; (" + PANE_EXIT_CAPTURE + "); fi; t kill-pane -t \"$p\"'";
+const SESSION_CLOSED_HOOK = "if-shell -F '#{m:p_*,#{hook_session_name}}' { run-shell 'printf \"%s %s closed\\n\" \"$(date +%FT%T)\" \"#{hook_session_name}\" >> #{q:" + paneExitHomeOption + "}/pane-exits.log' }";
+function sessionServerOptionArgs(exitHome) {
     return [
+        "set-option", "-g", paneExitHomeOption, exitHome, ";",
         "set-option", "-g", "history-limit", "50000", ";",
         "set-option", "-g", "mouse", "on", ";",
         // Every client draws into the viewer's normal screen, so lines that scroll