@volter/supercode-terminal 0.2.40 → 0.2.42

package/index.mjs

@@ -1,6 +1,7 @@
 import { execFile, spawn, spawnSync } from 'node:child_process';
 import { randomBytes, randomUUID } from 'node:crypto';
-import { cpSync, existsSync, readFileSync, renameSync, rmSync, writeFileSync } 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';
@@ -509,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();
@@ -585,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);

package/package.json

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

package/substrate/tmux.js

@@ -75,16 +75,29 @@ export async function createSession({ command, cwd, env, name, owner, ownerOptio
             startArgs.push("-c", cwd);
         }
         startArgs.push(...paneBootstrapArgs(0));
-        await runTmuxSessionCreateAsync(startArgs, { cwd, operation: "create tmux session", session: name, socket });
-        if (owner) {
-            await runAsync("tmux", tmuxArgs(socket, ["set-option", "-t", name, ownershipOption, owner]));
-        }
+        // The session's own options ride the SAME invocation as its creation. A
+        // program that exits at once (a name not on PATH) otherwise takes the
+        // session with it before `remain-on-exit` or the owner stamp is set, and
+        // the next set-option's "no such session" replaces the program's own
+        // failure in what the launcher reports.
+        const setOnCreate = (option, value) => {
+            assertOptionValue(value);
+            // tmux splits commands at an argument that ends in `;`.
+            if (value.endsWith(";"))
+                throw new Error(`A tmux option value set at creation cannot end in ";": ${option}`);
+            startArgs.push(";", "set-option", "-t", name, option, value);
+        };
+        if (owner)
+            setOnCreate(ownershipOption, owner);
         for (const [option, value] of Object.entries(sessionOptions).sort(([left], [right]) => left.localeCompare(right))) {
-            await setSessionOptionAsync(name, option, value, socket);
+            assertUserOption(option);
+            setOnCreate(option, value);
         }
         for (const [option, value] of Object.entries(settings).sort(([left], [right]) => left.localeCompare(right))) {
-            await setSessionSettingAsync(name, option, value, socket);
+            assertSettingName(option);
+            setOnCreate(option, value);
         }
+        await runTmuxSessionCreateAsync(startArgs, { cwd, operation: "create tmux session", session: name, socket });
         await declareSessionColorEnvironmentAsync(socket);
         const target = targetForSession(name);
         for (let i = 1; i < panes; i += 1) {
@@ -150,11 +163,17 @@ export async function sessionOptionValuesAsync(option, socket) {
 export async function setSessionSettingAsync(session, option, value, socket) {
     if (!session)
         throw new Error("A session name is required.");
+    assertSettingName(option);
+    assertOptionValue(value);
+    await runAsync("tmux", tmuxArgs(socket, ["set-option", "-t", session, option, value]));
+}
+function assertSettingName(option) {
     if (!/^[a-z][a-z0-9-]*$/.test(option))
         throw new Error(`Not a tmux session option name: ${option}`);
+}
+function assertOptionValue(value) {
     if (/\0|\t|\r|\n/.test(value))
         throw new Error("A tmux option value cannot contain control separators.");
-    await runAsync("tmux", tmuxArgs(socket, ["set-option", "-t", session, option, value]));
 }
 /** Set one session-scoped user option without exposing it in the session name. */
 export async function setSessionOptionAsync(session, option, value, socket) {