@volter/supercode-terminal 0.2.72 → 0.2.74

package/index.d.ts

@@ -58,7 +58,7 @@ export class TmuxTerminalHost {
     env?: Record<string, string>;
     name?: string;
   }): Promise<TerminalSession>;
-  capture(sessionId: string, options?: { lines?: number; preserveEscapes?: boolean }): string;
+  capture(sessionId: string, options?: { lines?: number; preserveEscapes?: boolean }): Promise<string>;
   sendInput(
     sessionId: string,
     data: string,
@@ -258,6 +258,7 @@ export function composerReadyForInput(kind: string, screen: string | undefined):
 export function composerHoldsDraft(kind: string, screen: string | undefined): boolean | null;
 
 export { classifyAttentionSignal, observeLifecycle, gatherLifecycleObservation, createLifecycleStore, snapshotProcessTree, snapshotProcessTreeAsync } from './substrate/session-lifecycle.js';
+export { HARNESS_MARKERS, HARNESS_CHILD_SESSION_MARKERS, isHarnessMarker, withoutHarnessMarkers, dropOwnHarnessMarkers } from './substrate/harness-env.js';
 export type {
   LifecycleSnapshot,
   LifecycleStore,

package/index.mjs

@@ -9,6 +9,7 @@ import { fileURLToPath } from 'node:url';
 import { createServer as defaultCreateServer } from 'node:http';
 
 import { NativeTerminalSessionHost } from './substrate/native-host.js';
+import { withoutHarnessMarkers } from './substrate/harness-env.js';
 import * as defaultTmux from './substrate/tmux.js';
 import { openLocalTerminal as defaultOpenLocalTerminal } from './substrate/local-terminal.js';
 
@@ -293,14 +294,24 @@ export class TmuxTerminalHost {
     return created;
   }
 
-  capture(sessionId, options = {}) {
-    const entry = this.#entry(sessionId);
-    return this.#tmux.capturePane({
-      lines: options.lines,
-      preserveEscapes: options.preserveEscapes === true,
-      socket: this.#socket,
-      target: `${entry.name}:0.0`,
-    });
+  // Asynchronous, and one tmux process: the daemon reads every pane's screen each time it judges attention, and a
+  // synchronous read (a session listing and a capture per pane, each a spawnSync) held its event loop for all of them
+  // back to back, so a local client's hello waited behind the whole pass. A session that is gone is told from the
+  // failed capture, by the same listing as before.
+  async capture(sessionId, options = {}) {
+    const entry = this.#catalog.get(sessionId);
+    if (!entry) throw new TerminalHostError('session_not_found', 'The tmux session no longer exists.');
+    try {
+      return await this.#tmux.capturePaneAsync({
+        lines: options.lines,
+        preserveEscapes: options.preserveEscapes === true,
+        socket: this.#socket,
+        target: `${entry.name}:0.0`,
+      });
+    } catch (error) {
+      this.#entry(sessionId);
+      throw error;
+    }
   }
 
   async sendInput(sessionId, data, options = {}) {
@@ -672,7 +683,7 @@ export class PtyTerminalHost {
       // a half-installed package): the pane server answers this code by ending itself, and the next one loads afresh.
       throw new TerminalHostError('pane_runtime_missing', `The pane runtime could not load: ${errorMessage(error)}`);
     }
-    const env = { ...process.env, ...(input.env ?? {}) };
+    const env = { ...withoutHarnessMarkers(process.env), ...(input.env ?? {}) };
     const { file, args } = windowsLaunch(input.command.program, input.command.arguments ?? [], env);
     // The watchdog is running before the pane is, and the pane is on its list the moment it exists.
     this.#startWatchdog();
@@ -1230,7 +1241,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.#script(), 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: withoutHarnessMarkers(process.env) });
           child.on('error', () => {});
           child.unref();
         }
@@ -2164,3 +2175,4 @@ function randomToken() {
 // every surface that triages panes shares one precision rather than each
 // inventing its own patterns.
 export { classifyAttentionSignal, observeLifecycle, gatherLifecycleObservation, createLifecycleStore, snapshotProcessTree, snapshotProcessTreeAsync } from './substrate/session-lifecycle.js';
+export { HARNESS_MARKERS, HARNESS_CHILD_SESSION_MARKERS, isHarnessMarker, withoutHarnessMarkers, dropOwnHarnessMarkers } from './substrate/harness-env.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-terminal",
-  "version": "0.2.72",
+  "version": "0.2.74",
   "type": "module",
   "description": "Optional leak-safe terminal and tmux host adapter for Volter Harness frontends",
   "exports": {
@@ -29,6 +29,7 @@
       "types": "./react/stream.d.ts",
       "import": "./react/stream.mjs"
     },
+    "./harness-markers.json": "./substrate/harness-markers.json",
     "./docker-exec": {
       "types": "./substrate/docker-exec.d.ts",
       "import": "./substrate/docker-exec.js"

package/substrate/harness-env.d.ts

@@ -0,0 +1,12 @@
+/** What a harness takes itself for a nested session by. Each is read for truth, so an empty value is no mark. */
+export declare const HARNESS_CHILD_SESSION_MARKERS: readonly string[];
+/** Every mark: the child-session ones, and what names the session a command ran for. */
+export declare const HARNESS_MARKERS: readonly string[];
+export declare function isHarnessMarker(name: string): boolean;
+/**
+ * The environment a process supercode starts gets: `env` without the calling harness's own marks. `keep` names what
+ * the launch sets on purpose.
+ */
+export declare function withoutHarnessMarkers<T extends Record<string, string | undefined>>(env: T, keep?: Iterable<string>): T;
+/** Drops the marks from this process's own environment, so nothing it starts later can inherit them. */
+export declare function dropOwnHarnessMarkers(env?: NodeJS.ProcessEnv): void;

package/substrate/harness-env.js

@@ -0,0 +1,29 @@
+import { readFileSync } from "node:fs";
+// A coding harness marks what its tools run: Claude Code exports CLAUDECODE, CLAUDE_CODE_CHILD_SESSION and the rest
+// to every command of a session, Codex its thread. A process supercode starts that outlives the command (a terminal
+// app, an attach client, a pane, the daemon) is not that session's child: carrying the marks, every shell a person
+// opens in that terminal starts harnesses that take themselves for a nested session (Claude Code then saves no
+// transcript). The names are harness-markers.json beside the built module, the one list; the CLI reads the same file
+// (crates/cli/src/harness_env.rs).
+const listed = JSON.parse(readFileSync(new URL("./harness-markers.json", import.meta.url), "utf8"));
+/** What a harness takes itself for a nested session by. Each is read for truth, so an empty value is no mark. */
+export const HARNESS_CHILD_SESSION_MARKERS = Object.freeze([...listed.child_session]);
+/** Every mark: the child-session ones, and what names the session a command ran for. */
+export const HARNESS_MARKERS = Object.freeze([...listed.child_session, ...listed.session]);
+const markers = new Set(HARNESS_MARKERS);
+export function isHarnessMarker(name) {
+    return markers.has(name);
+}
+/**
+ * The environment a process supercode starts gets: `env` without the calling harness's own marks. `keep` names what
+ * the launch sets on purpose.
+ */
+export function withoutHarnessMarkers(env, keep = []) {
+    const kept = new Set(keep);
+    return Object.fromEntries(Object.entries(env).filter(([name]) => !markers.has(name) || kept.has(name)));
+}
+/** Drops the marks from this process's own environment, so nothing it starts later can inherit them. */
+export function dropOwnHarnessMarkers(env = process.env) {
+    for (const name of HARNESS_MARKERS)
+        delete env[name];
+}

package/substrate/harness-markers.json

@@ -0,0 +1,23 @@
+{
+  "child_session": [
+    "CLAUDECODE",
+    "CLAUDE_CODE_CHILD_SESSION"
+  ],
+  "session": [
+    "CLAUDE_CODE_ENTRYPOINT",
+    "CLAUDE_CODE_SESSION_ID",
+    "CLAUDE_CODE_SESSION_ATTENDED",
+    "CLAUDE_CODE_EXECPATH",
+    "CLAUDE_CODE_MESSAGING_SOCKET",
+    "CLAUDE_CODE_MESSAGING_TOKEN",
+    "CLAUDE_CODE_INVOKED_SKILLS",
+    "CLAUDE_PID",
+    "CLAUDE_EFFORT",
+    "AI_AGENT",
+    "CODEX_THREAD_ID",
+    "CODEX_SESSION_ID",
+    "CODEX_SANDBOX",
+    "CODEX_SANDBOX_NETWORK_DISABLED",
+    "CODEX_INTERNAL_ORIGINATOR_OVERRIDE"
+  ]
+}

package/substrate/internal/exec.js

@@ -1,4 +1,5 @@
 import { spawn, spawnSync } from "node:child_process";
+import { withoutHarnessMarkers } from "../harness-env.js";
 function runEnvironment(options) {
     if (options.inheritEnv === false) {
         return options.env ?? {};
@@ -181,7 +182,7 @@ async function spawnAsync(command, args, options, input) {
     });
 }
 export function spawnInherited(command, args) {
-    const child = spawn(command, args, { stdio: "inherit" });
+    const child = spawn(command, args, { stdio: "inherit", env: withoutHarnessMarkers(process.env) });
     child.on("exit", (code, signal) => {
         if (signal) {
             process.kill(process.pid, signal);

package/substrate/tmux-stream.js

@@ -1,5 +1,6 @@
 import pty from "@homebridge/node-pty-prebuilt-multiarch";
 import fs from "node:fs";
+import { withoutHarnessMarkers } from "./harness-env.js";
 import { assertSession, getStatusLineCount, getWindowSize } from "./tmux.js";
 export class TmuxTerminalAttachError extends Error {
     phase;
@@ -46,7 +47,7 @@ export function attachTmuxTerminalSocket(options) {
             cols,
             cwd: options.cwd ?? process.cwd(),
             env: {
-                ...process.env,
+                ...withoutHarnessMarkers(process.env),
                 TERM: "screen-256color"
             },
             rows

package/substrate/tmux.js

@@ -1,6 +1,7 @@
 import { existsSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { 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";
 import { snapshotDescendantPids } from "./internal/process-tree.js";
 const TMUX_INSTALL_HINT = "Install it with: brew install tmux";
@@ -63,12 +64,14 @@ export async function createSession({ command, cwd, env, name, owner, ownerOptio
     // 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_LAUNCHED_BY|SUPERCODE_AGENT_[A-Z_]+)$/;
+    // The harnesses' own marks are the shared list (harness-env); supercode's caller and agent variables are its own.
+    const supercodeIdentity = /^(SUPERCODE_CALLER|SUPERCODE_CALLER_NAME|SUPERCODE_LAUNCHED_BY|SUPERCODE_AGENT_[A-Z_]+)$/;
+    const identity = (name) => isHarnessMarker(name) || supercodeIdentity.test(name);
     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));
+        .filter((name) => identity(name) && !(name in sessionEnv));
     const bootstrapDirectories = [];
     const paneBootstrapArgs = (pane) => {
         const commandArgs = command === undefined ? [] : [command.program, ...(command.arguments ?? [])];