@rynx-ai/runtime 0.1.11-beta.5 → 0.1.11-beta.7

package/dist/runner/child.js

@@ -1,5 +1,18 @@
 import { TerminalRegistry } from "../terminal/registry.js";
 import { toWireError } from "./protocol.js";
+const TRAEX_STARTUP_WATCH_MS = 20_000;
+const TRAEX_STARTUP_POLL_MS = 100;
+const TRAEX_PROMPT_RETRY_MS = 500;
+function normalizeTraexPane(pane) {
+    return pane.toLowerCase().replace(/\s+/g, " ").trim();
+}
+function isTerminalProtocolResponse(input) {
+    // xterm answers terminal queries through the same onData channel as real
+    // keystrokes. CSI carries device/focus/position reports; OSC carries color
+    // query replies such as `OSC 10;rgb:... ST` and `OSC 11;rgb:... ST`.
+    // Neither is evidence that the user has taken over startup prompt handling.
+    return /^(?:\x1b\[(?:(?:\?|>)[0-9;]*c|[0-9;]*(?:n|R|t)|[IO])|\x1b\][0-9]+;[^\x07\x1b]*(?:\x07|\x1b\\))+$/.test(input);
+}
 export class RunnerSession {
     transport;
     executor;
@@ -48,8 +61,17 @@ export class RunnerSession {
                 });
                 return;
             case "term.input":
-                this.cancelTraexStartupWatcher(this.attachmentThreadIds.get(msg.attachId));
-                this.attachments.get(msg.attachId)?.write(Buffer.from(msg.dataB64, "base64").toString("utf8"));
+                {
+                    const localThreadId = this.attachmentThreadIds.get(msg.attachId);
+                    const input = Buffer.from(msg.dataB64, "base64").toString("utf8");
+                    // xterm sends device/focus reports through the same onData channel as
+                    // keystrokes. They must reach the TUI without pretending the user has
+                    // taken over startup prompt handling.
+                    if (!isTerminalProtocolResponse(input)) {
+                        this.cancelTraexStartupWatcher(localThreadId);
+                    }
+                    this.attachments.get(msg.attachId)?.write(input);
+                }
                 return;
             case "term.resize":
                 this.attachments.get(msg.attachId)?.resize(msg.cols, msg.rows);
@@ -215,8 +237,8 @@ export class RunnerSession {
         try {
             const input = msg.input ?? msg.text;
             const outcome = (await provider.injectMessage?.(msg.localThreadId, input)) ?? "notLive";
-            if (outcome === "injected")
-                this.cancelTraexStartupWatcher(msg.localThreadId);
+            // App-server injection is independent of the Terminal TUI startup, so it
+            // must not cancel prompt handling for the pane that is still starting.
             this.transport.send({ t: "injected", reqId: msg.reqId, localThreadId: msg.localThreadId, outcome });
         }
         catch (error) {
@@ -255,7 +277,6 @@ export class RunnerSession {
         if (!spec)
             return;
         const terminalId = `${localThreadId}-main`;
-        const coldStart = !this.terminals.has(terminalId);
         const term = this.terminals.getOrCreate(terminalId, {
             cwd: spec.cwd,
             command: spec.command,
@@ -264,7 +285,7 @@ export class RunnerSession {
             rows: rows ?? 40,
             ...(spec.env ? { env: spec.env } : {}),
         });
-        if (coldStart && spec.skipTraexStartupPrompts) {
+        if (spec.skipTraexStartupPrompts) {
             const watcher = Symbol(localThreadId);
             this.traexStartupWatchers.set(localThreadId, watcher);
             void this.skipTraexStartupPrompts(localThreadId, term, watcher);
@@ -279,46 +300,48 @@ export class RunnerSession {
         const prompts = [
             {
                 id: "welcome",
-                matches: (pane) => pane.includes("Welcome to TRAE CLI") && pane.includes("Press enter to continue"),
+                matches: (pane) => pane.includes("welcome to trae cli") && pane.includes("press enter to continue"),
                 dismiss: () => terminal.sendEnter(),
             },
             {
                 id: "migration",
-                matches: (pane) => pane.includes("Legacy TRAE CLI data detected") &&
-                    pane.includes("Would you like to migrate detected data to the new TRAE CLI storage?") &&
-                    pane.includes("Select what to import:"),
+                matches: (pane) => pane.includes("legacy trae cli data detected") &&
+                    pane.includes("select what to import") &&
+                    (pane.includes("skip for now") || pane.includes("don't ask again")),
                 dismiss: () => terminal.interrupt(),
             },
             {
                 id: "hooks",
-                matches: (pane) => pane.includes("Hooks need review") &&
-                    pane.includes("hooks are new or changed.") &&
-                    pane.includes("Trust all and continue") &&
-                    pane.includes("Continue without trusting"),
+                matches: (pane) => pane.includes("hooks need review") &&
+                    pane.includes("trust all and continue") &&
+                    pane.includes("continue without trusting"),
                 dismiss: () => terminal.interrupt(),
             },
         ];
-        const dismissed = new Set();
-        const deadline = Date.now() + 20_000;
+        let activePromptId;
+        let lastDismissedAt = 0;
+        const deadline = Date.now() + TRAEX_STARTUP_WATCH_MS;
         const terminalId = `${localThreadId}-main`;
         while (!this.shuttingDown &&
             Date.now() < deadline &&
             this.traexStartupWatchers.get(localThreadId) === watcher &&
             this.terminals.get(terminalId) === terminal) {
-            const pane = terminal.capturePane();
-            // Once the normal composer is visible, startup is complete and there is
-            // no reason to keep polling the tmux pane for the remainder of the window.
-            if (pane.includes("TRAE CLI Next"))
-                break;
+            // Do not treat a composer frame as completion: Traex can render it before
+            // the startup modals arrive. The bounded deadline stops this watcher.
+            const pane = normalizeTraexPane(terminal.capturePane());
             const prompt = prompts.find((candidate) => candidate.matches(pane));
-            if (prompt && !dismissed.has(prompt.id)) {
+            const now = Date.now();
+            if (!prompt) {
+                activePromptId = undefined;
+            }
+            else if (prompt.id !== activePromptId ||
+                now - lastDismissedAt >= TRAEX_PROMPT_RETRY_MS) {
                 prompt.dismiss();
-                dismissed.add(prompt.id);
-                if (dismissed.size === prompts.length)
-                    break;
+                activePromptId = prompt.id;
+                lastDismissedAt = now;
             }
             await new Promise((resolve) => {
-                const timer = setTimeout(resolve, 100);
+                const timer = setTimeout(resolve, TRAEX_STARTUP_POLL_MS);
                 timer.unref();
             });
         }

package/dist/runner/manager.d.ts

@@ -43,6 +43,9 @@ export interface RunnerManagerOptions {
     runnerEntry?: string;
     /** Idle TTL (ms) after which an unused runner is reaped. */
     idleTtlMs?: number;
+    /** Maximum time without user/control activity that an active response may
+     * protect a detached runner from idle reaping. */
+    staleActiveTtlMs?: number;
     /** Background reap sweep interval (ms); `0` disables the timer (tests). */
     reapIntervalMs?: number;
     /** Grace period between SIGTERM and SIGKILL during runner shutdown. */
@@ -136,6 +139,7 @@ export declare class RunnerManager implements AgentCapabilities {
     private readonly sessionStore;
     private readonly runnerEntry;
     private readonly idleTtlMs;
+    private readonly staleActiveTtlMs;
     private readonly spawn;
     private readonly childEnv;
     private readonly sessionContextProvider;
@@ -312,5 +316,13 @@ export declare class RunnerManager implements AgentCapabilities {
     private failHandle;
     private terminateHandle;
     private reapIdle;
+    /** Close server-side runtime state before fencing a Provider that stayed
+     * active past its hard inactivity deadline. The child transport is closed by
+     * terminateHandle immediately afterwards, so these are the final events for
+     * the abandoned responses. */
+    private failStaleActiveResponses;
+    /** Track only response lifecycle, not output volume. Output deltas from a
+     * runaway TUI/Provider must not refresh the stale-active deadline. */
+    private observeHandleRuntimeEvent;
     private openSessionContext;
 }

package/dist/runner/manager.js

@@ -44,6 +44,12 @@ const DEFAULT_TERMINAL_INPUT_HANDOFF_TIMEOUT_MS = 30_000;
 /** Retry transient terminal-server cleanup without spinning forever. */
 const DEFAULT_TERMINAL_INPUT_CLEANUP_RETRY_MS = 1_000;
 const MAX_TERMINAL_INPUT_CLEANUP_RETRY_MS = 30_000;
+/** A Provider that never closes its active response must not keep a detached
+ * runner + tmux server alive forever. This is intentionally much longer than
+ * the normal idle TTL so legitimate long-running turns are not treated as
+ * stale. User input/control activity refreshes the deadline; Provider output
+ * does not, because a runaway redraw loop is the failure mode this bounds. */
+const DEFAULT_STALE_ACTIVE_TTL_MS = 60 * 60_000;
 /** Keep per-Session spawn context small enough to remain an environment handoff,
  * not an unbounded transport. */
 const MAX_SESSION_CONTEXT_ENV_ENTRIES = 32;
@@ -144,6 +150,7 @@ export class RunnerManager {
     sessionStore;
     runnerEntry;
     idleTtlMs;
+    staleActiveTtlMs;
     spawn;
     childEnv;
     sessionContextProvider;
@@ -198,6 +205,7 @@ export class RunnerManager {
         this.sessionStore = opts.sessionStore;
         this.runnerEntry = opts.runnerEntry ?? defaultRunnerEntry();
         this.idleTtlMs = opts.idleTtlMs ?? 300_000;
+        this.staleActiveTtlMs = Math.max(this.idleTtlMs, opts.staleActiveTtlMs ?? DEFAULT_STALE_ACTIVE_TTL_MS);
         this.spawn = opts.spawn ?? nodeSpawn;
         this.childEnv = opts.childEnv ?? {};
         this.sessionContextProvider = opts.sessionContextProvider;
@@ -261,6 +269,8 @@ export class RunnerManager {
             pendingEscape: "",
         };
         const terminal = new ManagedTerminal(attachId, (msg) => {
+            if (msg.t === "term.input")
+                handle.lastUsedAt = this.now();
             const handoffs = msg.t === "term.input" && opts.role === "owner"
                 ? this.beginTerminalInputHandoffs(handle, this.currentTerminalSessionId(handle, localThreadId), trackedTerminalSubmissions(inputTracker, Buffer.from(msg.dataB64, "base64").toString("utf8")))
                 : [];
@@ -1011,6 +1021,7 @@ export class RunnerManager {
         if (handle.dead)
             return;
         if (message.t === "mirror") {
+            this.observeHandleRuntimeEvent(handle, message.event);
             this.mirrorListener?.(message.sessionId, message.event);
             if (message.event.type === "response.created") {
                 this.settleTerminalInputHandoff(handle, message.sessionId, "turn");
@@ -1078,6 +1089,7 @@ export class RunnerManager {
             this.settleTerminalRotationHandoff(handle, message.from, message.to);
             if (handle.dead)
                 return;
+            handle.activeResponseIds.clear();
             this.handles.set(message.to, handle);
             this.liveSessionKeys.add(message.to);
             this.liveOptions.set(message.to, {
@@ -1144,6 +1156,7 @@ export class RunnerManager {
             transport,
             stderr: [],
             lastUsedAt: this.now(),
+            activeResponseIds: new Set(),
             dead: false,
             completion,
             terminalCleanupRetryFailures: 0,
@@ -1210,6 +1223,7 @@ export class RunnerManager {
                     return;
                 if (this.bufferForkTargetMessage(handle, msg))
                     return;
+                this.observeHandleRuntimeEvent(handle, msg.event);
                 this.mirrorListener?.(msg.sessionId, msg.event);
                 if (msg.event.type === "response.created") {
                     // The listener projects response.created into SessionRuntimeIndex
@@ -1331,22 +1345,86 @@ export class RunnerManager {
     reapIdle() {
         const now = this.now();
         for (const [key, handle] of this.handles) {
-            if (handle.caps.size > 0 || handle.terminals.size > 0) {
+            if (handle.caps.size > 0 || handle.terminals.size > 0 || handle.live.size > 0) {
                 continue;
             }
-            // A live codex forwarder must outlive terminal detach / idle turns — it is
-            // the session's single event writer, so never reap a session that has one.
-            if (this.liveSessionKeys.has(key)) {
+            const idleForMs = now - handle.lastUsedAt;
+            if (idleForMs < this.idleTtlMs) {
                 continue;
             }
-            if (now - handle.lastUsedAt < this.idleTtlMs) {
+            const hasActiveResponse = handle.activeResponseIds.size > 0;
+            if (hasActiveResponse && idleForMs < this.staleActiveTtlMs) {
                 continue;
             }
-            void this.terminateHandle(handle, "idle runner reaped").catch((error) => {
+            const reason = hasActiveResponse
+                ? "stale active runner reaped"
+                : this.liveSessionKeys.has(key)
+                    ? "idle live runner reaped"
+                    : "idle runner reaped";
+            if (hasActiveResponse) {
+                this.failStaleActiveResponses(handle, idleForMs);
+            }
+            void this.terminateHandle(handle, reason).catch((error) => {
                 logTerminationFailure(handle, error);
             });
         }
     }
+    /** Close server-side runtime state before fencing a Provider that stayed
+     * active past its hard inactivity deadline. The child transport is closed by
+     * terminateHandle immediately afterwards, so these are the final events for
+     * the abandoned responses. */
+    failStaleActiveResponses(handle, idleForMs) {
+        const responseIds = [...handle.activeResponseIds];
+        handle.activeResponseIds.clear();
+        const sessionId = this.currentTerminalSessionId(handle, handle.key);
+        for (const responseId of responseIds) {
+            this.mirrorListener?.(sessionId, {
+                type: "response.failed",
+                responseId,
+                error: {
+                    source: "execution",
+                    code: "stale_runner_reaped",
+                    message: `Runner was reaped after ${Math.floor(idleForMs / 1000)}s without user activity`,
+                },
+            });
+        }
+    }
+    /** Track only response lifecycle, not output volume. Output deltas from a
+     * runaway TUI/Provider must not refresh the stale-active deadline. */
+    observeHandleRuntimeEvent(handle, event) {
+        switch (event.type) {
+            case "response.created":
+            case "response.output_text.delta":
+            case "response.reasoning_summary_text.delta":
+            case "response.function_call_output.delta":
+            case "response.output_item.done":
+                handle.activeResponseIds.add(event.responseId);
+                return;
+            case "session.interaction.requested":
+                handle.activeResponseIds.add(event.responseId);
+                return;
+            case "response.completed":
+            case "response.failed":
+                handle.activeResponseIds.delete(event.responseId);
+                return;
+            case "session.status":
+                if (event.status === "running" && event.responseId) {
+                    handle.activeResponseIds.add(event.responseId);
+                }
+                else if (event.status !== "running") {
+                    if (event.responseId)
+                        handle.activeResponseIds.delete(event.responseId);
+                    else
+                        handle.activeResponseIds.clear();
+                }
+                return;
+            case "session.rotated":
+                handle.activeResponseIds.clear();
+                return;
+            default:
+                return;
+        }
+    }
     openSessionContext(sessionId) {
         if (!this.sessionContextProvider)
             return undefined;

package/dist/terminal/tmux.d.ts

@@ -146,7 +146,9 @@ export declare class TmuxTerminal {
     paste(text: string, bufferName?: string): void;
     /**
      * Attach a client. `role: "read-only"` passes tmux `-r` so the viewer cannot
-     * type (defense-in-depth on top of the WS bridge dropping input frames).
+     * type and `ignore-size` so even its initial PTY dimensions cannot resize the
+     * owner's pane (defense-in-depth on top of the WS bridge dropping input and
+     * resize frames).
      */
     attach(role: "owner" | "read-only", dims?: {
         cols?: number;

package/dist/terminal/tmux.js

@@ -16,7 +16,7 @@
  */
 import { execFile, execFileSync } from "node:child_process";
 import { createHash } from "node:crypto";
-import { existsSync, mkdirSync } from "node:fs";
+import { existsSync, mkdirSync, unlinkSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 const TMUX_TARGET = "main";
@@ -54,10 +54,28 @@ export function terminateTmuxServer(name, tmuxBin = "tmux") {
         return false;
     }
     catch (error) {
-        return !(error &&
-            typeof error === "object" &&
-            "code" in error &&
-            error.code === "ENOENT");
+        // Only a real tmux exit status proves the server/session is absent. Spawn
+        // failures (missing/unexecutable tmux) leave liveness unproven and must not
+        // unlink a socket that could still belong to a live server.
+        if (!error ||
+            typeof error !== "object" ||
+            !("status" in error) ||
+            typeof error.status !== "number") {
+            return false;
+        }
+        try {
+            // tmux custom-socket servers can exit while leaving the filesystem entry
+            // behind. Remove that verified-stale socket so process/socket inventories
+            // do not accumulate dead terminals forever.
+            unlinkSync(socketPath);
+            return true;
+        }
+        catch (unlinkError) {
+            return Boolean(unlinkError &&
+                typeof unlinkError === "object" &&
+                "code" in unlinkError &&
+                unlinkError.code === "ENOENT");
+        }
     }
 }
 /** Is a usable `tmux` on PATH? Cheap probe for the capability gate. */
@@ -319,14 +337,17 @@ export class TmuxTerminal {
     }
     /**
      * Attach a client. `role: "read-only"` passes tmux `-r` so the viewer cannot
-     * type (defense-in-depth on top of the WS bridge dropping input frames).
+     * type and `ignore-size` so even its initial PTY dimensions cannot resize the
+     * owner's pane (defense-in-depth on top of the WS bridge dropping input and
+     * resize frames).
      */
     async attach(role, dims) {
         this.start();
         const spawn = this.injectedSpawn ?? (await loadPtySpawn());
-        const args = [...this.base(), "attach-session", "-t", TMUX_TARGET];
+        const args = [...this.base(), "attach-session"];
         if (role === "read-only")
-            args.push("-r");
+            args.push("-r", "-f", "ignore-size");
+        args.push("-t", TMUX_TARGET);
         const proc = spawn(this.tmuxBin, args, {
             name: "xterm-256color",
             cols: dims?.cols ?? this.cols,
@@ -386,12 +407,7 @@ export class TmuxTerminal {
     }
     /** Kill the tmux server (ends the session and all attaches). */
     kill() {
-        try {
-            execFileSync(this.tmuxBin, [...this.base(), "kill-server"], { stdio: "ignore" });
-        }
-        catch {
-            // Already gone — nothing to clean up.
-        }
+        terminateTmuxServer(this.name, this.tmuxBin);
         this.started = false;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rynx-ai/runtime",
-  "version": "0.1.11-beta.5",
+  "version": "0.1.11-beta.7",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/rynx-ai/rynx.git",
@@ -24,9 +24,9 @@
     }
   },
   "dependencies": {
-    "node-pty": "^1.0.0",
+    "node-pty": "1.2.0-beta.15",
     "ws": "^8.21.0",
-    "@rynx-ai/core": "0.1.11-beta.5"
+    "@rynx-ai/core": "0.1.11-beta.7"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"