linkshell-cli 0.5.2 → 0.5.5

package/dist/cli/src/runtime/bridge-session.js

@@ -4,7 +4,7 @@ import WebSocket from "ws";
 import { hostname, platform, homedir } from "node:os";
 import { writeFileSync, readFileSync, readdirSync, statSync, unlinkSync, mkdirSync, existsSync, openSync, readSync, closeSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { join, basename, resolve } from "node:path";
+import { join, basename, resolve, relative, isAbsolute } from "node:path";
 import { agentV2MessageRoute, createEnvelope, parseEnvelope, parseTypedPayload, serializeEnvelope, PROTOCOL_VERSION, } from "@linkshell/protocol";
 import { ScrollbackBuffer } from "./scrollback.js";
 import { ScreenFallback } from "./screen-fallback.js";
@@ -12,16 +12,34 @@ import { ScreenShare } from "./screen-share.js";
 import { getLanIp } from "../utils/lan-ip.js";
 import { startKeepAwake } from "../utils/keep-awake.js";
 import { loadOrCreateMachineIdentity } from "../machine-id.js";
-import { getValidToken } from "../auth.js";
+import { getValidToken, refreshAccessToken } from "../auth.js";
 import { AgentSessionProxy } from "./acp/agent-session.js";
 import { AgentWorkspaceProxy } from "./acp/agent-workspace.js";
 import { detectAvailableProviders } from "./acp/provider-resolver.js";
 const HEARTBEAT_INTERVAL = 15_000;
+// Transport-layer WS keepalive: ping the gateway periodically; if a pong
+// doesn't arrive before the next ping, the socket is half-open (network
+// silently dropped, no FIN) — terminate it so the reconnect loop kicks in.
+const WS_PING_INTERVAL = 20_000;
 const RECONNECT_BASE_DELAY = 1_000;
 const RECONNECT_MAX_DELAY = 30_000;
-const RECONNECT_MAX_ATTEMPTS = 20;
+// Cap the exponent so the backoff levels off at RECONNECT_MAX_DELAY instead of
+// overflowing. There is NO attempt ceiling — a connected host never gives up
+// (only `stop()`/all-PTYs-exited ends it), so it survives gateway restarts and
+// arbitrarily long network outages, reconnecting whenever connectivity returns.
+const RECONNECT_MAX_EXPONENT = 5;
 const DEFAULT_TERMINAL_ID = "default";
 const HOOK_BODY_LIMIT = 256 * 1024;
+const SCROLLBACK_LINES = 500;
+// Upper bound on concurrent live terminals — forceNew removed the cwd-dedup
+// ceiling, so bound growth to avoid PTY/fd exhaustion from a runaway client.
+const MAX_TERMINALS = 12;
+// How long to keep an exited terminal (with its scrollback) in memory so the
+// client can replay its final output before it is reaped.
+const EXITED_TERMINAL_GRACE_MS = 30_000;
+// Default ports the bridge will proxy tunnel requests to when no explicit
+// allowlist is configured. Covers the common dev servers the app tunnels to.
+const DEFAULT_TUNNEL_PORTS = [3000, 3001, 4321, 5173, 5174, 8080, 8000, 8081];
 const PERMISSION_REQUEST_TIMEOUT_MS = Number(process.env.LINKSHELL_PERMISSION_TIMEOUT_MS ?? 5 * 60_000);
 const LINKSHELL_PERMISSION_GUARD_MARKER = "LINKSHELL_PERMISSION_GUARD";
 function isLinkShellHookEntry(entry, marker) {
@@ -231,10 +249,15 @@ export class BridgeSession {
     socket;
     terminals = new Map();
     heartbeatTimer;
+    wsPingTimer;
+    // True between sending a WS ping and receiving its pong. If still true at the
+    // next ping tick, the socket is half-open and gets terminated.
+    awaitingPong = false;
     reconnectTimer;
     reconnectAttempts = 0;
     reconnecting = false;
     sessionId = "";
+    hostToken;
     exited = false;
     stopped = false;
     permissionStacks = new Map();
@@ -248,9 +271,48 @@ export class BridgeSession {
     agentSession;
     agentWorkspace;
     machineIdentity;
+    // Confinement root for client-driven filesystem ops; resolved once at construction.
+    fileRoot;
+    // Ports the tunnel proxy may connect to on 127.0.0.1.
+    allowedTunnelPorts;
+    // Pending deletions of exited terminals (terminalId → timer) so we can clear on stop().
+    exitedTerminalTimers = new Map();
+    // Invoked when all terminals have exited naturally — closes embedded gateway,
+    // removes daemon PID file, etc. Set by the CLI entry point.
+    onAllTerminalsExited;
     constructor(options) {
         this.options = options;
         this.sessionId = options.sessionId ?? "";
+        // Confine client-driven file ops to the user's home by default (single-user
+        // self-hosted model: the owner browses their own projects under ~). This
+        // still blocks /etc, /usr, other users' dirs. Override via --file-root.
+        this.fileRoot = resolve(options.fileRoot ?? homedir());
+        this.allowedTunnelPorts = new Set(options.allowedTunnelPorts && options.allowedTunnelPorts.length > 0
+            ? options.allowedTunnelPorts
+            : DEFAULT_TUNNEL_PORTS);
+    }
+    /** Register a callback invoked once all terminals exit naturally (process self-cleanup). */
+    setOnAllTerminalsExited(handler) {
+        this.onAllTerminalsExited = handler;
+    }
+    /**
+     * Resolve a client-supplied path inside the confinement root.
+     * Returns the absolute resolved path, or null if it escapes the root.
+     */
+    resolveConfinedPath(clientPath) {
+        const expanded = clientPath.startsWith("~")
+            ? clientPath.replace(/^~/, homedir())
+            : clientPath;
+        // Resolve relative paths against the confinement root, not process.cwd().
+        const target = isAbsolute(expanded)
+            ? resolve(expanded)
+            : resolve(this.fileRoot, expanded);
+        const rel = relative(this.fileRoot, target);
+        if (rel === "")
+            return target; // the root itself
+        if (rel.startsWith("..") || isAbsolute(rel))
+            return null;
+        return target;
     }
     log(msg) {
         if (this.options.verbose) {
@@ -264,6 +326,9 @@ export class BridgeSession {
     async start() {
         this.log(`starting session (gateway=${this.options.gatewayUrl}, provider=${this.options.providerConfig.provider})`);
         this.machineIdentity = loadOrCreateMachineIdentity();
+        // Sweep stale LinkShell hook entries (dead curl ports) left by a prior crash
+        // before we write fresh ones for this session.
+        this.sweepStaleHookConfigs();
         if (!this.sessionId) {
             await this.createPairing();
         }
@@ -311,6 +376,10 @@ export class BridgeSession {
         }
         const body = (await res.json());
         this.sessionId = body.sessionId;
+        // Secret token proving we are the legitimate host for this session; sent on
+        // every host WS connect so a third party who learns the sessionId can't
+        // hijack the host role.
+        this.hostToken = body.hostToken;
         const pairingGateway = resolvePairingGateway(this.options.gatewayHttpUrl, this.options.pairingGateway);
         const deepLink = pairingGateway
             ? `linkshell://pair?code=${body.pairingCode}&gateway=${encodeURIComponent(pairingGateway)}`
@@ -352,15 +421,40 @@ export class BridgeSession {
                 this.options.authToken = token;
                 return token;
             }
-            process.stderr.write("[bridge] login token expired and refresh failed; run `linkshell login` if the gateway rejects the connection\n");
-            this.options.authToken = undefined;
-            return undefined;
+            // Refresh failed (e.g. offline / transient Supabase error). Do NOT clear
+            // the token — keep using the last one we had. It may be expired and the
+            // gateway may reject it, but the close handler force-refreshes on the next
+            // attempt, and clearing it would permanently downgrade us to no-auth and
+            // lock a pro host out of its own sessions once connectivity returns.
+            process.stderr.write("[bridge] token refresh failed; reusing last token (will retry refresh on reconnect)\n");
+            return this.options.authToken;
         }
         catch (error) {
             this.log(`failed to refresh login token: ${error instanceof Error ? error.message : String(error)}`);
             return this.options.authToken;
         }
     }
+    // After an auth-class WS close, force a token refresh before reconnecting so
+    // we don't spin on 401/4001/4003. A gateway restart surfaces as 1006 right
+    // after a fresh connect, so we refresh on that too (cheap, debounced by the
+    // reconnect backoff). No-op for clean/normal closes.
+    async maybeRefreshTokenForClose(code) {
+        if (!this.options.authToken)
+            return;
+        const authClass = code === 4001 || code === 4003 || code === 1006 || code === 401;
+        if (!authClass)
+            return;
+        try {
+            const refreshed = await refreshAccessToken();
+            if (refreshed?.accessToken) {
+                this.options.authToken = refreshed.accessToken;
+                this.log("refreshed auth token after auth-class close");
+            }
+        }
+        catch {
+            // Offline — keep the old token; the reconnect loop will retry later.
+        }
+    }
     async connectGateway() {
         if (this.stopped) {
             return;
@@ -369,10 +463,23 @@ export class BridgeSession {
         url.searchParams.set("sessionId", this.sessionId);
         url.searchParams.set("role", "host");
         const authToken = await this.resolveAuthToken();
+        const wsOptions = {};
+        const headers = {};
         if (authToken) {
+            // Prefer the Authorization header so the token doesn't leak into URLs/logs.
+            headers["Authorization"] = `Bearer ${authToken}`;
+            // TODO: remove the query param once all gateways read the Authorization
+            // header. Kept for backward compatibility with older gateways that only
+            // read the `auth_token` query parameter.
             url.searchParams.set("auth_token", authToken);
         }
-        this.socket = new WebSocket(url);
+        if (this.hostToken) {
+            headers["x-linkshell-host-token"] = this.hostToken;
+        }
+        if (Object.keys(headers).length > 0) {
+            wsOptions.headers = headers;
+        }
+        this.socket = new WebSocket(url, wsOptions);
         this.socket.on("open", () => {
             process.stderr.write(this.reconnectAttempts > 0
                 ? "[bridge] gateway reconnected\n"
@@ -395,6 +502,11 @@ export class BridgeSession {
                 },
             }));
             this.startHeartbeat();
+            this.startWsPing();
+        });
+        // Gateway answered our WS ping — connection is alive.
+        this.socket.on("pong", () => {
+            this.awaitingPong = false;
         });
         this.socket.on("message", (data) => {
             let envelope;
@@ -412,15 +524,29 @@ export class BridgeSession {
         });
         this.socket.on("close", (code, reasonBuffer) => {
             this.stopHeartbeat();
+            this.stopWsPing();
             this.socket = undefined;
             const reason = reasonBuffer.toString();
-            process.stderr.write(`[bridge] gateway connection closed (code=${code}${reason ? `, reason=${reason}` : ""})\n`);
+            // Quiet during an ongoing outage: log the first close (we were connected,
+            // attempts==0) and every 10th, so multi-hour outages don't flood the log.
+            if (this.reconnectAttempts === 0 || this.reconnectAttempts % 10 === 0) {
+                process.stderr.write(`[bridge] gateway connection closed (code=${code}${reason ? `, reason=${reason}` : ""})\n`);
+            }
             if (!this.exited) {
-                this.scheduleReconnect();
+                // Auth-class closes (token expired / gateway restarted) get a forced
+                // token refresh before the next attempt, so we don't loop on 401/4xxx.
+                this.maybeRefreshTokenForClose(code).finally(() => {
+                    this.scheduleReconnect();
+                });
             }
         });
         this.socket.on("error", (error) => {
-            process.stderr.write(`[bridge] gateway error: ${error.message}\n`);
+            // During an outage every retry emits a connection error; the `close`
+            // handler already logs (quietly) and drives reconnect. Only surface the
+            // first error of an outage to avoid flooding the daemon log.
+            if (this.reconnectAttempts <= 1) {
+                process.stderr.write(`[bridge] gateway error: ${error.message || "connection failed"}\n`);
+            }
         });
     }
     async handleMessage(envelope) {
@@ -486,8 +612,22 @@ export class BridgeSession {
             case "terminal.spawn": {
                 const p = parseTypedPayload("terminal.spawn", envelope.payload);
                 const normalizedCwd = resolve(p.cwd);
-                // Dedup: if a running terminal already exists for this cwd, return it
-                const existing = [...this.terminals.values()].find((t) => t.status === "running" && resolve(t.cwd) === normalizedCwd);
+                // Cap concurrent terminals — forceNew removed the cwd-dedup ceiling, so
+                // bound growth explicitly to avoid PTY/fd exhaustion from a runaway client.
+                const liveCount = [...this.terminals.values()].filter((t) => t.status === "running").length;
+                if (liveCount >= MAX_TERMINALS) {
+                    this.send(createEnvelope({
+                        type: "session.error",
+                        sessionId: this.sessionId,
+                        payload: { code: "too_many_terminals", message: `最多同时打开 ${MAX_TERMINALS} 个终端` },
+                    }));
+                    break;
+                }
+                // Dedup by cwd UNLESS the client explicitly asks for a fresh terminal
+                // (forceNew lets web open multiple tabs in the same directory).
+                const existing = p.forceNew
+                    ? undefined
+                    : [...this.terminals.values()].find((t) => t.status === "running" && resolve(t.cwd) === normalizedCwd);
                 if (existing) {
                     this.send(createEnvelope({
                         type: "terminal.spawned",
@@ -530,9 +670,15 @@ export class BridgeSession {
             }
             case "terminal.browse": {
                 const p = parseTypedPayload("terminal.browse", envelope.payload);
-                // Expand ~ to home directory
-                const rawPath = p.path.startsWith("~") ? p.path.replace(/^~/, homedir()) : p.path;
-                const browsePath = resolve(rawPath);
+                const browsePath = this.resolveConfinedPath(p.path);
+                if (browsePath === null) {
+                    this.send(createEnvelope({
+                        type: "terminal.browse.result",
+                        sessionId: this.sessionId,
+                        payload: { path: p.path, entries: [], error: "Path is outside the allowed root", requestId: p.requestId },
+                    }));
+                    break;
+                }
                 try {
                     const entries = readdirSync(browsePath, { withFileTypes: true })
                         .filter((d) => !d.name.startsWith(".") && (d.isDirectory() || (p.includeFiles && d.isFile())))
@@ -569,8 +715,22 @@ export class BridgeSession {
             }
             case "terminal.file.read": {
                 const p = parseTypedPayload("terminal.file.read", envelope.payload);
-                const rawPath = p.path.startsWith("~") ? p.path.replace(/^~/, homedir()) : p.path;
-                const filePath = resolve(rawPath);
+                const filePath = this.resolveConfinedPath(p.path);
+                if (filePath === null) {
+                    this.send(createEnvelope({
+                        type: "terminal.file.read.result",
+                        sessionId: this.sessionId,
+                        payload: {
+                            path: p.path,
+                            content: "",
+                            encoding: "utf8",
+                            truncated: false,
+                            error: "Path is outside the allowed root",
+                            requestId: p.requestId,
+                        },
+                    }));
+                    break;
+                }
                 try {
                     const stats = statSync(filePath);
                     if (!stats.isFile()) {
@@ -620,8 +780,15 @@ export class BridgeSession {
             }
             case "terminal.mkdir": {
                 const p = parseTypedPayload("terminal.mkdir", envelope.payload);
-                const rawPath = p.path.startsWith("~") ? p.path.replace(/^~/, homedir()) : p.path;
-                const dirPath = resolve(rawPath);
+                const dirPath = this.resolveConfinedPath(p.path);
+                if (dirPath === null) {
+                    this.send(createEnvelope({
+                        type: "terminal.browse.result",
+                        sessionId: this.sessionId,
+                        payload: { path: p.path, entries: [], error: "Path is outside the allowed root" },
+                    }));
+                    break;
+                }
                 try {
                     mkdirSync(dirPath, { recursive: true });
                     // Browse the parent to refresh the listing
@@ -856,6 +1023,21 @@ export class BridgeSession {
     // ── Tunnel handlers ────────────────────────────────────────────────
     handleTunnelRequest(payload) {
         const { requestId, method, url: reqUrl, headers, body, port } = payload;
+        // SSRF guard: only proxy to ports in the allowlist (pinned to 127.0.0.1).
+        if (!this.allowedTunnelPorts.has(port)) {
+            this.log(`rejecting tunnel request to disallowed port ${port}`);
+            if (headers.upgrade === "websocket") {
+                this.send(createEnvelope({
+                    type: "tunnel.ws.close",
+                    sessionId: this.sessionId,
+                    payload: { requestId, code: 1008, reason: `Port ${port} is not allowed` },
+                }));
+            }
+            else {
+                this.sendTunnelError(requestId, 403, `Port ${port} is not allowed`);
+            }
+            return;
+        }
         // WebSocket upgrade request
         if (headers.upgrade === "websocket") {
             this.handleTunnelWsUpgrade(requestId, port, reqUrl);
@@ -1067,7 +1249,7 @@ export class BridgeSession {
             cwd,
             projectName: basename(cwd),
             provider,
-            scrollback: new ScrollbackBuffer(1000),
+            scrollback: new ScrollbackBuffer(SCROLLBACK_LINES),
             outputSeq: 0,
             statusSeq: 0,
             status: "running",
@@ -1104,6 +1286,20 @@ export class BridgeSession {
                 payload: { exitCode, signal },
             }));
             this.sendTerminalList();
+            // Reap the exited terminal (and its scrollback) after a grace period so
+            // clients can replay final output, then free the memory. Tracked so the
+            // timer can be cleared on stop().
+            const reapTimer = setTimeout(() => {
+                this.exitedTerminalTimers.delete(terminalId);
+                const t = this.terminals.get(terminalId);
+                if (t && t.status === "exited") {
+                    this.terminals.delete(terminalId);
+                    this.log(`reaped exited terminal ${terminalId}`);
+                }
+            }, EXITED_TERMINAL_GRACE_MS);
+            if (typeof reapTimer.unref === "function")
+                reapTimer.unref();
+            this.exitedTerminalTimers.set(terminalId, reapTimer);
             // If all terminals exited, close the session
             const allExited = [...this.terminals.values()].every((t) => t.status === "exited");
             if (allExited) {
@@ -1111,6 +1307,9 @@ export class BridgeSession {
                 setTimeout(() => {
                     this.stopHeartbeat();
                     this.socket?.close();
+                    // Self-clean process-level resources (embedded gateway + PID file)
+                    // since the PTYs exited naturally rather than via a signal handler.
+                    void this.onAllTerminalsExited?.();
                 }, 500);
                 process.exitCode = exitCode ?? 0;
             }
@@ -1798,6 +1997,60 @@ export class BridgeSession {
         }
         catch { /* ignore parse errors */ }
     }
+    /**
+     * Remove ALL LinkShell hook entries (any marker) from a JSON config file.
+     * Used on startup to sweep stale entries left behind by a crashed instance,
+     * whose curl ports are now dead. Matches via isLinkShellHookEntry rather than
+     * a single marker so entries from previous runs are also cleaned.
+     */
+    sweepLinkShellHookEntries(configPath) {
+        if (!existsSync(configPath))
+            return;
+        try {
+            // Re-read immediately before write to minimize the window for a
+            // concurrent writer to clobber our changes.
+            const raw = JSON.parse(readFileSync(configPath, "utf8"));
+            const hooks = raw.hooks;
+            if (!hooks)
+                return;
+            let changed = false;
+            for (const [eventName, entries] of Object.entries(hooks)) {
+                if (!Array.isArray(entries))
+                    continue;
+                const filtered = entries.filter((entry) => !isLinkShellHookEntry(entry));
+                if (filtered.length !== entries.length) {
+                    changed = true;
+                    if (filtered.length === 0) {
+                        delete hooks[eventName];
+                    }
+                    else {
+                        hooks[eventName] = filtered;
+                    }
+                }
+            }
+            if (changed) {
+                if (Object.keys(hooks).length === 0) {
+                    delete raw.hooks;
+                }
+                writeFileSync(configPath, JSON.stringify(raw, null, 2));
+                this.log(`swept stale LinkShell hook entries from ${configPath}`);
+            }
+        }
+        catch { /* ignore parse errors */ }
+    }
+    /** Sweep stale LinkShell hook entries from known shared config files on startup. */
+    sweepStaleHookConfigs() {
+        const home = homedir();
+        const candidates = [
+            join(home, ".claude", "settings.json"),
+            join(home, ".codex", "hooks.json"),
+            join(home, ".gemini", "settings.json"),
+            join(process.cwd(), "hooks.json"), // copilot (per-cwd)
+        ];
+        for (const path of candidates) {
+            this.sweepLinkShellHookEntries(path);
+        }
+    }
     send(message) {
         if (!this.socket || this.socket.readyState !== WebSocket.OPEN) {
             return;
@@ -1834,6 +2087,47 @@ export class BridgeSession {
             this.heartbeatTimer = undefined;
         }
     }
+    // Transport-layer keepalive. WS ping/pong detects a half-open socket (network
+    // dropped without a TCP FIN, e.g. laptop sleep / Wi-Fi loss) that would
+    // otherwise hang silently. If the previous ping's pong never arrived, the
+    // socket is dead → terminate it, which fires `close` → scheduleReconnect.
+    startWsPing() {
+        this.stopWsPing();
+        this.awaitingPong = false;
+        this.wsPingTimer = setInterval(() => {
+            const sock = this.socket;
+            if (!sock || sock.readyState !== WebSocket.OPEN)
+                return;
+            if (this.awaitingPong) {
+                // No pong since the last ping → half-open. Forcibly close so we reconnect.
+                process.stderr.write("[bridge] no pong from gateway; terminating dead connection\n");
+                this.awaitingPong = false;
+                try {
+                    sock.terminate();
+                }
+                catch {
+                    // terminate may throw if already closing; close handler still runs.
+                }
+                return;
+            }
+            this.awaitingPong = true;
+            try {
+                sock.ping();
+            }
+            catch {
+                // ping failed → let the next tick terminate, or close already fired.
+            }
+        }, WS_PING_INTERVAL);
+        if (typeof this.wsPingTimer.unref === "function")
+            this.wsPingTimer.unref();
+    }
+    stopWsPing() {
+        if (this.wsPingTimer) {
+            clearInterval(this.wsPingTimer);
+            this.wsPingTimer = undefined;
+        }
+        this.awaitingPong = false;
+    }
     startScreenCapture(fps, quality, scale) {
         if (!this.options.screen) {
             this.log("screen sharing not enabled (use --screen)");
@@ -1892,17 +2186,22 @@ export class BridgeSession {
         }
     }
     scheduleReconnect() {
-        if (this.reconnecting)
+        if (this.reconnecting || this.stopped || this.exited)
             return;
-        // In daemon mode, never give up — reset attempts after hitting max
-        if (this.reconnectAttempts >= RECONNECT_MAX_ATTEMPTS) {
-            process.stderr.write("[bridge] max reconnect attempts reached, resetting counter and continuing...\n");
-            this.reconnectAttempts = 0;
-        }
         this.reconnecting = true;
-        const delay = Math.min(RECONNECT_BASE_DELAY * 2 ** this.reconnectAttempts, RECONNECT_MAX_DELAY);
+        // Exponential backoff capped at RECONNECT_MAX_DELAY, with full jitter so a
+        // fleet of hosts doesn't stampede a restarting gateway. The attempt counter
+        // only ever grows toward the cap — it is NEVER reset to "give up"; the host
+        // keeps trying forever until stop()/exit.
+        const exponent = Math.min(this.reconnectAttempts, RECONNECT_MAX_EXPONENT);
+        const base = Math.min(RECONNECT_BASE_DELAY * 2 ** exponent, RECONNECT_MAX_DELAY);
+        const delay = Math.round(base * (0.5 + Math.random() * 0.5));
         this.reconnectAttempts++;
-        process.stderr.write(`[bridge] reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})\n`);
+        // Quiet logging: only the first retry of an outage and every 10th attempt,
+        // so a multi-hour offline window doesn't flood the daemon log.
+        if (this.reconnectAttempts === 1 || this.reconnectAttempts % 10 === 0) {
+            process.stderr.write(`[bridge] reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})\n`);
+        }
         this.reconnectTimer = setTimeout(() => {
             this.reconnectTimer = undefined;
             if (this.stopped || this.exited) {
@@ -1919,6 +2218,7 @@ export class BridgeSession {
         this.stopped = true;
         this.exited = true;
         this.stopHeartbeat();
+        this.stopWsPing();
         this.stopScreenCapture();
         this.agentSession?.stop();
         this.agentSession = undefined;
@@ -1937,6 +2237,11 @@ export class BridgeSession {
             ws.close(1001, "Session stopped");
         }
         this.tunnelSockets.clear();
+        // Clear pending exited-terminal reap timers.
+        for (const timer of this.exitedTerminalTimers.values()) {
+            clearTimeout(timer);
+        }
+        this.exitedTerminalTimers.clear();
         for (const term of this.terminals.values()) {
             this.cleanupHookServer(term);
             if (term.status === "running")