@volter/supercode-terminal 0.2.59 → 0.2.61

package/index.mjs

@@ -157,6 +157,8 @@ export class TerminalWebSocketBridge {
 
 export class TmuxTerminalHost {
   #allowUnownedControl;
+  #generation = 0;
+  #listing = null;
   #attachments = new Map();
   #attachSocket;
   #catalog = new Map();
@@ -186,7 +188,19 @@ export class TmuxTerminalHost {
     this.#ttlMs = positiveInteger(options.attachmentTtlMs ?? DEFAULT_ATTACHMENT_TTL_MS, 'attachmentTtlMs');
   }
 
-  async listSessions() {
+  /**
+   * The panes, as tmux lists them. Callers asking while a listing is running share it (one listing is five tmux
+   * processes, and a daemon's doors ask together); a change made through this host since starts a fresh one.
+   */
+  listSessions() {
+    if (this.#listing && this.#listing.generation === this.#generation) return this.#listing.promise;
+    const listing = { generation: this.#generation, promise: null };
+    listing.promise = this.#listSessions().finally(() => { if (this.#listing === listing) this.#listing = null; });
+    this.#listing = listing;
+    return listing.promise;
+  }
+
+  async #listSessions() {
     this.#pruneAttachments();
     const names = this.#sessionNames();
     const liveNames = new Set(names);
@@ -215,6 +229,8 @@ export class TmuxTerminalHost {
         label: name,
         owned: ownedNames.has(name),
         size: size ? Object.freeze({ columns: size.width, rows: size.height }) : null,
+        // When the pane last printed, as tmux keeps it (milliseconds): idle time without a screen capture.
+        lastOutputAt: size?.activity ? size.activity * 1000 : null,
       });
     });
   }
@@ -246,6 +262,8 @@ export class TmuxTerminalHost {
       settings: TERMINAL_LIKE_SESSION,
       socket: this.#socket,
     });
+    // Raised once tmux has the session: a listing started before then cannot be the one that answers below.
+    this.#generation += 1;
     const id = this.#catalogId(name);
     const created = (await this.listSessions()).find((session) => session.id === id);
     if (!created) {
@@ -285,6 +303,7 @@ export class TmuxTerminalHost {
       throw new TerminalHostError('bind_not_allowed', 'This host does not own that tmux session.');
     }
     await this.#tmux.setSessionOptionAsync(entry.name, this.#contextOption, contextKey, this.#socket);
+    this.#generation += 1;
     const bound = (await this.listSessions()).find((session) => session.id === sessionId);
     if (!bound) {
       throw new TerminalHostError('session_not_found', 'The tmux session exited before it could be bound.');
@@ -372,6 +391,7 @@ export class TmuxTerminalHost {
       throw new TerminalHostError('close_not_allowed', 'This host does not own that tmux session.');
     }
     this.#tmux.killSessionProcessTree({ session: entry.name, socket: this.#socket });
+    this.#generation += 1;
     this.#catalog.delete(sessionId);
     this.#idByName.delete(entry.name);
     for (const [id, grant] of this.#attachments) {

package/package.json

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

package/substrate/tmux.d.ts

@@ -8,6 +8,8 @@ export type TmuxPane = {
 export type TmuxWindowSize = {
     width: number;
     height: number;
+    /** When the window last had output, in Unix seconds (tmux's `window_activity`); absent when tmux did not say. */
+    activity?: number;
 };
 export type TmuxCommand = {
     arguments?: string[];

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",
@@ -670,7 +681,7 @@ export async function listWindowSizesAsync(socket) {
             "list-windows",
             "-a",
             "-F",
-            `#{session_name}${separator}#{window_index}${separator}#{window_width}${separator}#{window_height}`
+            `#{session_name}${separator}#{window_index}${separator}#{window_width}${separator}#{window_height}${separator}#{window_activity}`
         ]))).trim();
     }
     catch (error) {
@@ -692,7 +703,7 @@ export async function listWindowSizesAsync(socket) {
         return sizes;
     }
     for (const line of output.split("\n")) {
-        const [session, windowIndex, width, height] = line.split(separator);
+        const [session, windowIndex, width, height, activity] = line.split(separator);
         // Match getWindowSize, which reads window 0; ignore extra windows of a session.
         if (!session || windowIndex !== "0") {
             continue;
@@ -700,7 +711,8 @@ export async function listWindowSizesAsync(socket) {
         const parsedWidth = Number(width);
         const parsedHeight = Number(height);
         if (Number.isInteger(parsedWidth) && Number.isInteger(parsedHeight) && parsedWidth >= 1 && parsedHeight >= 1) {
-            sizes.set(session, { height: parsedHeight, width: parsedWidth });
+            const parsedActivity = Number(activity);
+            sizes.set(session, { height: parsedHeight, width: parsedWidth, ...(Number.isInteger(parsedActivity) && parsedActivity > 0 ? { activity: parsedActivity } : {}) });
         }
     }
     return sizes;