@rynx-ai/runtime 0.1.11-beta.33 → 0.1.11-beta.35

package/dist/runner/child.js

@@ -9,9 +9,10 @@
  */
 import { randomUUID } from "node:crypto";
 import { AgentRuntimeError, } from "@rynx-ai/core";
-import { TerminalRegistry } from "../terminal/registry.js";
+import { TerminalRegistry, } from "../terminal/registry.js";
 import { RUNNER_IMAGE_CHUNK_CHARS, RUNNER_IMAGE_MAX_RESULT_CHARS, toWireError, } from "./protocol.js";
 import { isCodexLineageProvider } from "./startup-policy.js";
+const TERMINAL_PREPARATION_TTL_MS = 30_000;
 /** Maximum time for a fresh Codex-lineage TUI to publish its native thread. */
 const CODEX_THREAD_START_TIMEOUT_MS = 30_000;
 function providerDisplayName(runtime) {
@@ -119,10 +120,13 @@ export class RunnerSession {
     onShutdown;
     /** Live terminals hosted by this session, and per-attach client handles. */
     terminals = new TerminalRegistry();
+    preparations = new Map();
     attachments = new Map();
     attachmentThreadIds = new Map();
+    attachmentRoles = new Map();
     traexStartupWatchers = new Map();
     traexStartupGates = new Map();
+    codexStartupMonitors = new Map();
     terminalWatchers = new Map();
     /** Opens are async; a close received before attach resolves tombstones the id. */
     pendingTerminalOpens = new Set();
@@ -133,7 +137,9 @@ export class RunnerSession {
     mirrorImageAcks = new Map();
     /** Provider name retained for asynchronous Terminal-exit diagnostics. */
     liveRuntimes = new Map();
+    terminalStatuses = new Map();
     shuttingDown = false;
+    shutdownPromise = null;
     constructor({ transport, executor, onShutdown }) {
         this.transport = transport;
         this.executor = executor;
@@ -177,7 +183,9 @@ export class RunnerSession {
                 void this.runCap(msg.capId, msg.name, msg.args);
                 return;
             case "term.open":
-                if (this.pendingTerminalOpens.has(msg.attachId) || this.attachments.has(msg.attachId)) {
+                if (this.pendingTerminalOpens.has(msg.attachId) ||
+                    this.preparations.has(msg.attachId) ||
+                    this.attachments.has(msg.attachId)) {
                     this.transport.send({
                         t: "term.error",
                         attachId: msg.attachId,
@@ -192,29 +200,35 @@ export class RunnerSession {
                     this.cancelledTerminalOpens.delete(msg.attachId);
                 });
                 return;
+            case "term.seed.read":
+                void this.readTerminalSeed(msg);
+                return;
+            case "term.start":
+                void this.startTerminal(msg);
+                return;
+            case "term.read":
+                void this.readTerminalOutput(msg);
+                return;
             case "term.input":
-                {
-                    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);
-                }
+                void this.writeTerminalInput(msg);
                 return;
             case "term.resize":
-                this.attachments.get(msg.attachId)?.resize(msg.cols, msg.rows);
+                void this.resizeTerminal(msg);
                 return;
             case "term.close": {
                 if (this.pendingTerminalOpens.has(msg.attachId)) {
                     this.cancelledTerminalOpens.add(msg.attachId);
                 }
+                const pending = this.preparations.get(msg.attachId);
+                if (pending) {
+                    clearTimeout(pending.timer);
+                    this.preparations.delete(msg.attachId);
+                    pending.preparation.kill();
+                }
                 const attachment = this.attachments.get(msg.attachId);
                 this.attachments.delete(msg.attachId);
                 this.attachmentThreadIds.delete(msg.attachId);
+                this.attachmentRoles.delete(msg.attachId);
                 attachment?.kill();
                 return;
             }
@@ -234,8 +248,11 @@ export class RunnerSession {
             case "live.interrupt":
                 void this.interruptLive(msg);
                 return;
+            case "terminal.reap":
+                void this.reapTerminal(msg);
+                return;
             case "shutdown":
-                this.shutdown();
+                void this.shutdown();
                 return;
         }
     }
@@ -269,14 +286,19 @@ export class RunnerSession {
         const target = { id: localThreadId };
         const emit = (event) => {
             const sessionId = target.id;
+            if (event.type === "session.status") {
+                this.terminalStatuses.set(sessionId, event.status);
+            }
             this.enqueueMirror(() => this.sendMirroredEvent(sessionId, event));
         };
         const retarget = (newId, meta) => {
+            const previousId = target.id;
+            this.transferNativeSessionResources(previousId, newId);
             target.id = newId;
             this.enqueueMirror(() => {
                 this.transport.send({
                     t: "rotate",
-                    from: localThreadId,
+                    from: previousId,
                     to: newId,
                     kind: meta.kind,
                     workspace: meta.workspace,
@@ -287,11 +309,41 @@ export class RunnerSession {
         };
         return { emit, retarget };
     }
+    transferNativeSessionResources(sourceId, targetId) {
+        if (sourceId === targetId)
+            return;
+        const sourceTerminalId = `${sourceId}-main`;
+        const targetTerminalId = `${targetId}-main`;
+        this.terminals.transfer(sourceTerminalId, targetTerminalId);
+        const watcher = this.terminalWatchers.get(sourceId);
+        if (watcher)
+            clearInterval(watcher);
+        this.terminalWatchers.delete(sourceId);
+        const runtime = this.liveRuntimes.get(sourceId);
+        if (runtime) {
+            this.liveRuntimes.delete(sourceId);
+            this.liveRuntimes.set(targetId, runtime);
+        }
+        const status = this.terminalStatuses.get(sourceId);
+        if (status) {
+            this.terminalStatuses.delete(sourceId);
+            this.terminalStatuses.set(targetId, status);
+        }
+        if (this.liveIds.delete(sourceId))
+            this.liveIds.add(targetId);
+        for (const [attachId, sessionId] of this.attachmentThreadIds) {
+            if (sessionId === sourceId)
+                this.attachmentThreadIds.set(attachId, targetId);
+        }
+        const terminal = this.terminals.get(targetTerminalId);
+        if (terminal)
+            this.watchNativeTerminal(targetId, targetTerminalId, terminal);
+    }
     enqueueMirror(operation) {
         this.mirrorQueue = this.mirrorQueue.then(operation).catch((error) => {
             if (!this.shuttingDown) {
                 this.rejectMirrorImageAcks(error instanceof Error ? error : new Error(String(error)));
-                this.shutdown();
+                void this.shutdown();
             }
         });
     }
@@ -477,10 +529,31 @@ export class RunnerSession {
         }
     }
     monitorCodexThreadStartup(localThreadId, runtime, provider) {
+        // Starting (or declining to start) a new monitor invalidates every callback
+        // owned by the previous launch before it can touch the replacement state.
+        this.codexStartupMonitors.delete(localThreadId);
         if (!provider.waitLiveReady)
             return;
+        if (provider.liveSessionFailure?.(localThreadId)?.code === "login_required")
+            return;
+        const expectedTerminal = this.terminals.get(`${localThreadId}-main`);
+        const monitor = Symbol(localThreadId);
+        this.codexStartupMonitors.set(localThreadId, monitor);
+        const claimCurrentLaunch = () => {
+            if (this.codexStartupMonitors.get(localThreadId) !== monitor ||
+                this.terminals.get(`${localThreadId}-main`) !== expectedTerminal)
+                return false;
+            this.codexStartupMonitors.delete(localThreadId);
+            return true;
+        };
         void provider.waitLiveReady(localThreadId, CODEX_THREAD_START_TIMEOUT_MS).then((ready) => {
-            if (ready)
+            if (ready) {
+                if (this.codexStartupMonitors.get(localThreadId) === monitor) {
+                    this.codexStartupMonitors.delete(localThreadId);
+                }
+                return;
+            }
+            if (!claimCurrentLaunch())
                 return;
             const terminal = this.terminals.get(`${localThreadId}-main`);
             const paneFailure = terminal && !terminal.isAlive()
@@ -499,27 +572,30 @@ export class RunnerSession {
                     : `${runtime === "traex" ? "Traex" : "Codex"} TUI did not publish thread/started within ${CODEX_THREAD_START_TIMEOUT_MS / 1_000}s after app-server and observer readiness`);
             this.failCodexThreadStartup(localThreadId, provider, new AgentRuntimeError(detail, 503, paneFailure
                 ? "native_terminal_exited_before_session"
-                : "native_thread_discovery_timeout"));
+                : "native_thread_discovery_timeout"), expectedTerminal);
         }).catch((error) => {
+            if (!claimCurrentLaunch())
+                return;
             this.failCodexThreadStartup(localThreadId, provider, error instanceof AgentRuntimeError
                 ? error
-                : nativePhaseError(runtime, "native_thread_discovery_failed", "native session discovery failed", error));
+                : nativePhaseError(runtime, "native_thread_discovery_failed", "native session discovery failed", error), expectedTerminal);
         });
     }
     /** Discovery failure is terminal for this partial native launch. Publish the
      * exact cause first so an in-flight injection wakes, then drop the observer
      * and TUI so a later task retry creates a clean launch instead of reusing an
      * already-rejected readiness promise. */
-    failCodexThreadStartup(localThreadId, provider, error) {
+    failCodexThreadStartup(localThreadId, provider, error, expectedTerminal) {
         if (!provider.failLiveStartup?.(localThreadId, error))
             return false;
+        this.codexStartupMonitors.delete(localThreadId);
         const watcher = this.terminalWatchers.get(localThreadId);
         if (watcher)
             clearInterval(watcher);
         this.terminalWatchers.delete(localThreadId);
         this.cancelTraexStartupWatcher(localThreadId);
         try {
-            this.terminals.close(`${localThreadId}-main`);
+            this.terminals.close(`${localThreadId}-main`, expectedTerminal);
         }
         catch (closeError) {
             console.warn(`[runner] session=${localThreadId} failed to close native Terminal after startup failure: ${closeError instanceof Error ? closeError.message : String(closeError)}`);
@@ -614,6 +690,43 @@ export class RunnerSession {
             ...(error ? { error } : {}),
         });
     }
+    async reapTerminal(msg) {
+        let error;
+        try {
+            const lifecycle = this.terminals.lifecycle(msg.terminalId);
+            const watcher = this.terminalWatchers.get(msg.localThreadId);
+            if (watcher)
+                clearInterval(watcher);
+            this.terminalWatchers.delete(msg.localThreadId);
+            this.cancelTraexStartupWatcher(msg.localThreadId);
+            for (const [attachId, sessionId] of this.attachmentThreadIds) {
+                if (sessionId !== msg.localThreadId)
+                    continue;
+                this.attachments.get(attachId)?.kill();
+                this.attachments.delete(attachId);
+                this.attachmentThreadIds.delete(attachId);
+                this.attachmentRoles.delete(attachId);
+            }
+            this.terminals.close(msg.terminalId);
+            if (lifecycle === "auxiliary") {
+                await this.liveProvider.teardownAuxiliaryTerminalRuntime?.(msg.localThreadId);
+                this.liveIds.delete(msg.localThreadId);
+                this.liveRuntimes.delete(msg.localThreadId);
+                this.terminalStatuses.delete(msg.localThreadId);
+            }
+        }
+        catch (cause) {
+            error = toWireError(cause);
+        }
+        this.transport.send({
+            t: "terminal.reaped",
+            reqId: msg.reqId,
+            localThreadId: msg.localThreadId,
+            terminalId: msg.terminalId,
+            ok: error === undefined,
+            ...(error ? { error } : {}),
+        });
+    }
     /** Launch (idempotently) the session's codex TUI pane from the executor's
      *  `codexTerminalSpec`. Shares the `${id}-main` terminal id with `term.open`,
      *  so the web attach reuses the same detached pane. */
@@ -623,12 +736,23 @@ export class RunnerSession {
             return;
         const terminalId = `${localThreadId}-main`;
         const term = this.terminals.getOrCreate(terminalId, {
+            lifecycle: spec.lifecycle,
             cwd: spec.cwd,
             command: spec.command,
             args: spec.args,
             cols: cols ?? 120,
             rows: rows ?? 40,
             ...(spec.env ? { env: spec.env } : {}),
+            ...(spec.scrollback === undefined ? {} : { scrollback: spec.scrollback }),
+            ...(spec.tmuxAllowPassthrough === undefined
+                ? {}
+                : { tmuxAllowPassthrough: spec.tmuxAllowPassthrough }),
+            ...(spec.tmuxStartOnAttach === undefined
+                ? {}
+                : { tmuxStartOnAttach: spec.tmuxStartOnAttach }),
+            ...(spec.keepAliveAfterExit === undefined
+                ? {}
+                : { keepAliveAfterExit: spec.keepAliveAfterExit }),
         });
         if (spec.skipTraexStartupPrompts) {
             const watcher = Symbol(localThreadId);
@@ -671,30 +795,39 @@ export class RunnerSession {
                 this.terminalWatchers.delete(localThreadId);
                 this.cancelTraexStartupWatcher(localThreadId);
                 const runtime = this.liveRuntimes.get(localThreadId);
+                const lifecycle = this.terminals.lifecycle(terminalId);
                 const paneFailure = terminalFailureDetail(terminal.capturePane?.() ?? "");
-                const startupFailed = this.failCodexThreadStartup(localThreadId, this.liveProvider, nativePhaseError(runtime, "native_terminal_exited_before_session", "Terminal exited before native session discovery completed", paneFailure || undefined));
-                if (isCodexLineageProvider(runtime)) {
-                    if (!startupFailed) {
-                        try {
-                            this.terminals.close(terminalId);
-                        }
-                        catch (closeError) {
-                            console.warn(`[runner] session=${localThreadId} failed to close exited native Terminal: ${closeError instanceof Error ? closeError.message : String(closeError)}`);
-                        }
-                        const exitError = nativePhaseError(runtime, "native_terminal_exited", "Terminal exited unexpectedly", paneFailure || undefined);
-                        if (this.liveProvider.teardownLiveCodexSession) {
-                            this.liveProvider.teardownLiveCodexSession(localThreadId, exitError);
-                        }
-                        else {
-                            this.liveProvider.failLiveSession?.(localThreadId, exitError);
-                            this.liveProvider.stopLiveCodexSession?.(localThreadId);
-                        }
-                        this.liveIds.delete(localThreadId);
-                        console.warn(`[runner] session=${localThreadId} ${providerDisplayName(runtime)} auxiliary Terminal exited; native runtime torn down for cold resume`);
-                    }
+                const startupFailed = this.failCodexThreadStartup(localThreadId, this.liveProvider, nativePhaseError(runtime, "native_terminal_exited_before_session", "Terminal exited before native session discovery completed", paneFailure || undefined), terminal);
+                if (startupFailed || lifecycle === undefined)
                     return;
+                try {
+                    this.terminals.close(terminalId, terminal);
+                }
+                catch (closeError) {
+                    console.warn(`[runner] session=${localThreadId} failed to close exited native Terminal: ${closeError instanceof Error ? closeError.message : String(closeError)}`);
+                }
+                const status = this.terminalStatuses.get(localThreadId) ?? "unknown";
+                if (lifecycle === "auxiliary") {
+                    console.warn(`[runner] session=${localThreadId} ${providerDisplayName(runtime)} auxiliary Terminal exited`);
                 }
-                this.liveProvider.failLiveSession?.(localThreadId, nativePhaseError(runtime, "native_terminal_exited", "Terminal exited unexpectedly", paneFailure || undefined));
+                else {
+                    if (status !== "idle") {
+                        this.liveProvider.failLiveSession?.(localThreadId, nativePhaseError(runtime, "required_terminal_exited", "Required Terminal exited unexpectedly", paneFailure || undefined));
+                    }
+                    this.liveProvider.stopLiveCodexSession?.(localThreadId);
+                    this.liveIds.delete(localThreadId);
+                    this.liveRuntimes.delete(localThreadId);
+                    this.terminalStatuses.delete(localThreadId);
+                }
+                this.enqueueMirror(() => {
+                    this.transport.send({
+                        t: "terminal.lifecycle.ended",
+                        localThreadId,
+                        terminalId,
+                        lifecycle,
+                        status,
+                    });
+                });
             }).catch((error) => {
                 console.warn(`[runner] session=${localThreadId} native Terminal liveness probe failed: ${error instanceof Error ? error.message : String(error)}`);
             }).finally(() => {
@@ -835,6 +968,7 @@ export class RunnerSession {
         for (const timer of this.terminalWatchers.values())
             clearInterval(timer);
         this.terminalWatchers.clear();
+        this.codexStartupMonitors.clear();
         for (const id of this.liveIds) {
             this.liveProvider.stopLiveCodexSession?.(id, {
                 deferClaudeInteractionCleanup: true,
@@ -846,19 +980,31 @@ export class RunnerSession {
     /** Stop event forwarding, kill native terminals/hooks, then synchronously
      * scrub provider handoff files before the child process is allowed to exit. */
     shutdown() {
-        if (this.shuttingDown)
-            return;
+        if (this.shutdownPromise)
+            return this.shutdownPromise;
         this.shuttingDown = true;
-        this.rejectMirrorImageAcks(new Error("runner is shutting down"));
-        this.stopLive();
-        this.terminals.closeAll();
-        this.liveProvider.finalizeStoppedLiveSessions?.();
-        this.onShutdown();
+        this.shutdownPromise = (async () => {
+            this.rejectMirrorImageAcks(new Error("runner is shutting down"));
+            this.stopLive();
+            for (const pending of this.preparations.values()) {
+                clearTimeout(pending.timer);
+                pending.preparation.kill();
+            }
+            this.preparations.clear();
+            for (const attachment of this.attachments.values())
+                attachment.kill();
+            this.terminals.closeAll();
+            this.attachments.clear();
+            this.attachmentThreadIds.clear();
+            this.attachmentRoles.clear();
+            await this.liveProvider.finalizeStoppedLiveSessions?.();
+            this.onShutdown();
+        })();
+        return this.shutdownPromise;
     }
     async openTerminal(msg) {
         try {
-            // codex/claude-native session (no explicit command): DUMB ATTACH — reference implementation's
-            // reattach (codex_native.py:905-942, `app_server=None`). A tab switch ONLY
+            // codex/claude-native session (no explicit command): DUMB ATTACH. A tab switch ONLY
             // attaches an already-live pane; it NEVER ensures the forwarder or relaunches a
             // dead pane. Creation/relaunch happens on message-send (`live.ensure`) or an
             // explicit restart. A missing/dead pane → `term.error`, so the web shows the
@@ -880,6 +1026,7 @@ export class RunnerSession {
             }
             // Login-shell terminal (explicit command): create-or-reuse as before.
             this.terminals.getOrCreate(msg.terminalId, {
+                lifecycle: "auxiliary",
                 cwd: msg.cwd,
                 command: msg.command,
                 args: msg.args,
@@ -897,14 +1044,14 @@ export class RunnerSession {
             });
         }
     }
-    /** Attach an already-created terminal and forward its data/exit to the parent. */
+    /** Prepare captured history without starting the live control client. */
     async attachExisting(msg) {
-        const { attachment, role } = await this.terminals.attach(msg.terminalId, msg.role, {
+        const { preparation, role } = await this.terminals.prepare(msg.terminalId, msg.role, {
             cols: msg.cols,
             rows: msg.rows,
         });
         if (this.cancelledTerminalOpens.has(msg.attachId)) {
-            attachment.kill();
+            preparation.kill();
             this.transport.send({
                 t: "term.error",
                 attachId: msg.attachId,
@@ -913,20 +1060,168 @@ export class RunnerSession {
             });
             return;
         }
-        this.attachments.set(msg.attachId, attachment);
+        const timer = setTimeout(() => {
+            const pending = this.preparations.get(msg.attachId);
+            if (!pending || pending.preparation !== preparation)
+                return;
+            this.preparations.delete(msg.attachId);
+            this.attachmentThreadIds.delete(msg.attachId);
+            this.attachmentRoles.delete(msg.attachId);
+            preparation.kill();
+        }, TERMINAL_PREPARATION_TTL_MS);
+        timer.unref?.();
+        this.preparations.set(msg.attachId, { preparation, timer });
+        this.attachmentRoles.set(msg.attachId, role);
         if (msg.localThreadId)
             this.attachmentThreadIds.set(msg.attachId, msg.localThreadId);
-        attachment.onData((chunk) => this.transport.send({
-            t: "term.data",
+        this.transport.send({
+            t: "term.prepared",
             attachId: msg.attachId,
-            dataB64: Buffer.from(chunk, "utf8").toString("base64"),
-        }));
-        attachment.onExit((info) => {
-            this.attachments.delete(msg.attachId);
+            role,
+            seedBytes: preparation.seedBytes,
+            ...(preparation.dimensions ?? {}),
+        });
+    }
+    async readTerminalSeed(msg) {
+        const pending = this.preparations.get(msg.attachId);
+        if (!pending) {
+            this.sendTerminalOperationError(msg.attachId, msg.reqId, "terminal is not prepared");
+            return;
+        }
+        try {
+            const result = await pending.preparation.readSeed(msg.offset, msg.maxBytes);
+            await this.transport.sendAndDrain({
+                t: "term.seed.chunk",
+                attachId: msg.attachId,
+                reqId: msg.reqId,
+                dataB64: Buffer.from(result.data).toString("base64"),
+                nextOffset: result.nextOffset,
+                done: result.done,
+                ...(result.finalOffset === undefined ? {} : { finalOffset: result.finalOffset }),
+            });
+        }
+        catch (error) {
+            this.sendTerminalOperationError(msg.attachId, msg.reqId, error);
+        }
+    }
+    async startTerminal(msg) {
+        const pending = this.preparations.get(msg.attachId);
+        if (!pending) {
+            this.sendTerminalOperationError(msg.attachId, msg.reqId, "terminal is not prepared");
+            return;
+        }
+        clearTimeout(pending.timer);
+        this.preparations.delete(msg.attachId);
+        try {
+            const attachment = await pending.preparation.start();
+            this.attachments.set(msg.attachId, attachment);
+            attachment.onResize(({ cols, rows }) => {
+                this.transport.send({ t: "term.dimensions", attachId: msg.attachId, cols, rows });
+            });
+            await this.transport.sendAndDrain({
+                t: "term.started",
+                attachId: msg.attachId,
+                reqId: msg.reqId,
+            });
+            void attachment.readerDone.then(async (info) => {
+                await this.transport.sendAndDrain({
+                    t: "term.reader.done",
+                    attachId: msg.attachId,
+                    finalOffset: info.finalOffset,
+                    reason: info.reason,
+                    exitCode: info.exitCode,
+                }).catch(() => undefined);
+            });
+        }
+        catch (error) {
+            pending.preparation.kill();
             this.attachmentThreadIds.delete(msg.attachId);
-            this.transport.send({ t: "term.exit", attachId: msg.attachId, exitCode: info.exitCode });
+            this.attachmentRoles.delete(msg.attachId);
+            this.sendTerminalOperationError(msg.attachId, msg.reqId, error);
+        }
+    }
+    async readTerminalOutput(msg) {
+        const attachment = this.attachments.get(msg.attachId);
+        if (!attachment) {
+            this.sendTerminalOperationError(msg.attachId, msg.reqId, "terminal has not started");
+            return;
+        }
+        try {
+            const result = await attachment.read(msg.offset, msg.maxBytes);
+            await this.transport.sendAndDrain({
+                t: "term.chunk",
+                attachId: msg.attachId,
+                reqId: msg.reqId,
+                dataB64: Buffer.from(result.data).toString("base64"),
+                nextOffset: result.nextOffset,
+                done: result.done,
+                ...(result.finalOffset === undefined ? {} : { finalOffset: result.finalOffset }),
+            });
+        }
+        catch (error) {
+            this.sendTerminalOperationError(msg.attachId, msg.reqId, error);
+        }
+    }
+    async writeTerminalInput(msg) {
+        if (this.attachmentRoles.get(msg.attachId) !== "owner") {
+            await this.transport.sendAndDrain({
+                t: "term.ack",
+                attachId: msg.attachId,
+                reqId: msg.reqId,
+                operation: "input",
+            });
+            return;
+        }
+        const attachment = this.attachments.get(msg.attachId);
+        if (!attachment) {
+            this.sendTerminalOperationError(msg.attachId, msg.reqId, "terminal has not started");
+            return;
+        }
+        const localThreadId = this.attachmentThreadIds.get(msg.attachId);
+        const input = Buffer.from(msg.dataB64, "base64");
+        if (!isTerminalProtocolResponse(input.toString("utf8"))) {
+            this.cancelTraexStartupWatcher(localThreadId);
+        }
+        try {
+            await attachment.write(input);
+            await this.transport.sendAndDrain({
+                t: "term.ack",
+                attachId: msg.attachId,
+                reqId: msg.reqId,
+                operation: "input",
+            });
+        }
+        catch (error) {
+            this.sendTerminalOperationError(msg.attachId, msg.reqId, error);
+        }
+    }
+    async resizeTerminal(msg) {
+        const attachment = this.attachments.get(msg.attachId);
+        if (!attachment) {
+            this.sendTerminalOperationError(msg.attachId, msg.reqId, "terminal has not started");
+            return;
+        }
+        try {
+            await attachment.resize(msg.cols, msg.rows);
+            await this.transport.sendAndDrain({
+                t: "term.ack",
+                attachId: msg.attachId,
+                reqId: msg.reqId,
+                operation: "resize",
+            });
+        }
+        catch (error) {
+            this.sendTerminalOperationError(msg.attachId, msg.reqId, error);
+        }
+    }
+    sendTerminalOperationError(attachId, reqId, error) {
+        this.transport.send({
+            t: "term.error",
+            attachId,
+            reqId,
+            code: "terminal_open_failed",
+            message: error instanceof Error ? error.message : String(error),
         });
-        this.transport.send({ t: "term.opened", attachId: msg.attachId, role });
     }
     async runCap(capId, name, args) {
         try {