@cjhyy/code-shell-server 0.9.47 → 0.9.49

package/dist/mobile-remote/mobile-static.d.ts

@@ -38,12 +38,11 @@ export declare function mobileEntryRedirect(reqUrl: string): string | null;
  *  can see through it. Guarding that would need inode/device policy, and anyone
  *  able to hardlink into the served root can already write files there.
  *
- *  The returned path is the REQUESTED one, not the realpath: callers stream it
- *  directly and the resolved-name contract is relied on elsewhere (on macOS the
- *  realpath of a /var root is /private/var, which would change every result).
- *  That leaves the same synchronous stat-then-read window this module always
- *  had; closing it properly needs an open-then-fstat rework of both callers,
- *  which is out of scope for this fix. */
+ *  The returned path is the REQUESTED one, not the realpath: the resolved-name
+ *  contract is relied on elsewhere (on macOS the realpath of a /var root is
+ *  /private/var, which would change every result). This is only a routing check;
+ *  both HTTP callers open and revalidate the selected file through
+ *  streamStaticFile before returning bytes. */
 export declare function resolveSafe(root: string, subPath: string): string | null;
 export interface MobileStaticOptions {
     /** Absolute path to the built mobile app (out/mobile). */

package/dist/mobile-remote/mobile-static.js

@@ -1,7 +1,7 @@
-import { createReadStream, existsSync, realpathSync, statSync } from "node:fs";
+import { existsSync, realpathSync, statSync } from "node:fs";
 import { isAbsolute, join, normalize, relative, resolve, sep, extname } from "node:path";
 import { request as httpRequest } from "node:http";
-import { contentTypeFor } from "../static-files.js";
+import { contentTypeFor, streamStaticFile } from "../static-files.js";
 /**
  * Serves the built mobile web app (out/mobile) as static assets for the
  * `/mobile` route family, replacing the old inline `mobileRemoteHtml()` string.
@@ -61,12 +61,11 @@ function isContained(root, target) {
  *  can see through it. Guarding that would need inode/device policy, and anyone
  *  able to hardlink into the served root can already write files there.
  *
- *  The returned path is the REQUESTED one, not the realpath: callers stream it
- *  directly and the resolved-name contract is relied on elsewhere (on macOS the
- *  realpath of a /var root is /private/var, which would change every result).
- *  That leaves the same synchronous stat-then-read window this module always
- *  had; closing it properly needs an open-then-fstat rework of both callers,
- *  which is out of scope for this fix. */
+ *  The returned path is the REQUESTED one, not the realpath: the resolved-name
+ *  contract is relied on elsewhere (on macOS the realpath of a /var root is
+ *  /private/var, which would change every result). This is only a routing check;
+ *  both HTTP callers open and revalidate the selected file through
+ *  streamStaticFile before returning bytes. */
 export function resolveSafe(root, subPath) {
     const rootResolved = resolve(root);
     const rel = normalize(subPath || "index.html");
@@ -77,11 +76,11 @@ export function resolveSafe(root, subPath) {
     const full = resolve(join(rootResolved, rel));
     if (!isContained(rootResolved, full))
         return null;
-    if (!existsSync(full) || !statSync(full).isFile())
-        return null;
     // realpathSync throws on a dangling link or a race-deleted file; a missing
     // target is a 404 through the normal contract, never a 500.
     try {
+        if (!existsSync(full) || !statSync(full).isFile())
+            return null;
         if (!isContained(realpathSync(rootResolved), realpathSync(full)))
             return null;
     }
@@ -143,15 +142,15 @@ export function serveMobile(req, res, opts) {
     // stale index.html would reference deleted assets → 404 → blank page until a
     // hard refresh.
     const isHtml = type.startsWith("text/html");
-    res.writeHead(200, {
-        "content-type": type,
-        "cache-control": isHtml
+    void streamStaticFile(req, res, {
+        rootDir: opts.rootDir,
+        filePath: file,
+        cacheControl: isHtml
             ? "no-store"
             : sub.startsWith("assets/")
                 ? "public, max-age=31536000, immutable"
                 : "no-cache",
     });
-    createReadStream(file).pipe(res);
 }
 /** Dev-only: forward the request to the mobile vite dev server. The mobile vite
  *  config sets base "/mobile/", so vite serves its HMR client, module graph, and

package/dist/mobile-remote/remote-host-manager.d.ts

@@ -21,7 +21,8 @@ export interface RemoteHostStartOptions {
     /**
      * "lan" (default) keeps the existing LAN behaviour unchanged. "tunnel" binds
      * 127.0.0.1 (cloudflared connects to loopback) and inserts a passcode gate in
-     * front of every HTTP route and the WS upgrade. "relay" also requires an
+     * front of ordinary HTTP routes and the WS upgrade. Host-verified Panel asset
+     * capabilities use their own short-lived authorization. "relay" also requires an
      * initialized passcode and a stable HTTPS origin before pairing/WS upgrades.
      */
     mode?: "lan" | "tunnel" | "relay";
@@ -76,6 +77,8 @@ export declare class RemoteHostManager extends EventEmitter {
     private publicBaseUrl?;
     /** Passcode gate, present only in tunnel mode. */
     private passcode?;
+    private socketAccessValidity;
+    private accessSweep?;
     /** Where the built mobile app lives (out/mobile). */
     private readonly mobileRootDir;
     /** Dev proxy target for /mobile (HMR); undefined in prod. */
@@ -122,6 +125,8 @@ export declare class RemoteHostManager extends EventEmitter {
     /** Reply only to the currently authenticated tab; retired/revoked viewers receive nothing. */
     hasAuthenticatedViewer(viewerId: string, deviceId: string): boolean;
     sendToViewer(viewerId: string, event: MobileServerEvent): void;
+    /** Preserve the full worker envelope while retaining exact authenticated-tab routing. */
+    sendRawToViewer(viewerId: string, payload: string): void;
     /** Send a raw JSON-RPC worker line to ONLY one authenticated device. */
     sendRawToDevice(deviceId: string, payload: string): void;
     /** Broadcast a raw line (e.g. a mirrored worker→renderer JSON-RPC line) to
@@ -136,6 +141,7 @@ export declare class RemoteHostManager extends EventEmitter {
      * socket is still delivered. Returns false when retired.
      */
     private sendBounded;
+    private hasSocketAccess;
     private releaseSocket;
     private bindSocketDevice;
     /** Call after revoking/removing a trusted device to release both transports immediately. */

package/dist/mobile-remote/remote-host-manager.js

@@ -10,6 +10,16 @@ import { parseMobileClientEvent } from "./mobile-client-event-validator.js";
 import { isRelayOrigin } from "../remote-relay/protocol.js";
 /** Outbound bytes one paired socket may leave unread before it is retired. */
 const MAX_SOCKET_BACKLOG_BYTES = 4 * 1024 * 1024;
+/** The query suffix ("" or "?…") when the raw request target is exactly the
+ *  root entry, else undefined. The redirect path is fixed, so only the query
+ *  is carried over and it can never form an off-site Location. */
+function rootEntryQuery(target) {
+    if (target === "/")
+        return "";
+    if (target?.startsWith("/?"))
+        return target.slice(1);
+    return undefined;
+}
 /**
  * Pick the Mac's real LAN IPv4 so a phone on the same Wi-Fi can reach the
  * remote host. We bind to a concrete LAN address (NOT 0.0.0.0) per the design's
@@ -57,6 +67,8 @@ export class RemoteHostManager extends EventEmitter {
     publicBaseUrl;
     /** Passcode gate, present only in tunnel mode. */
     passcode;
+    socketAccessValidity = new WeakMap();
+    accessSweep;
     /** Where the built mobile app lives (out/mobile). */
     mobileRootDir;
     /** Dev proxy target for /mobile (HMR); undefined in prod. */
@@ -117,8 +129,8 @@ export class RemoteHostManager extends EventEmitter {
     async startOnce(options) {
         const relay = options.mode === "relay";
         const publicAccess = relay || options.mode === "tunnel";
-        if (relay && !options.passcode?.isSet()) {
-            throw new Error("Relay mode requires an initialized access passcode");
+        if (publicAccess && !options.passcode?.isSet()) {
+            throw new Error(`${relay ? "Relay" : "Tunnel"} mode requires an initialized access passcode`);
         }
         if (relay)
             this.publicBaseUrl = undefined;
@@ -136,60 +148,88 @@ export class RemoteHostManager extends EventEmitter {
                 req.resume();
                 return;
             }
-            // Tunnel mode: a passcode gate sits in front of EVERY route. The gate
-            // either allows (returns true) or writes its own 401/403 challenge.
-            if (gate && !gate.gate(req, res))
-                return;
-            if (req.url === "/health") {
-                res.writeHead(200, { "content-type": "application/json" });
-                res.end(JSON.stringify({ ok: true }));
-                return;
-            }
-            if (req.url?.startsWith("/api/v1/") && this.opts.webApi) {
-                const baseUrl = this.publicBaseUrl ?? this.started?.url;
-                if (!baseUrl) {
-                    res.writeHead(503);
-                    res.end("remote host is starting");
+            const serve = () => {
+                // All ordinary routes retain the tunnel passcode gate. Only a Host-verified
+                // short-lived Panel asset capability may use independent authorization.
+                if (gate && !gate.gate(req, res))
+                    return;
+                if (req.url === "/health") {
+                    res.writeHead(200, { "content-type": "application/json" });
+                    res.end(JSON.stringify({ ok: true }));
                     return;
                 }
-                void this.opts.webApi
-                    .handle(req, res, { baseUrl })
-                    .then((handled) => {
-                    if (!handled && !res.writableEnded) {
-                        res.writeHead(404);
-                        res.end("not found");
+                if (req.url?.startsWith("/api/v1/") && this.opts.webApi) {
+                    const baseUrl = this.publicBaseUrl ?? this.started?.url;
+                    if (!baseUrl) {
+                        res.writeHead(503);
+                        res.end("remote host is starting");
+                        return;
                     }
-                })
-                    .catch(() => {
+                    void this.opts.webApi
+                        .handle(req, res, { baseUrl, isAccessAuthorized: gate?.captureValidity() })
+                        .then((handled) => {
+                        if (!handled && !res.writableEnded) {
+                            res.writeHead(404);
+                            res.end("not found");
+                        }
+                    })
+                        .catch(() => {
+                        if (!res.headersSent)
+                            res.writeHead(500);
+                        if (!res.writableEnded)
+                            res.end("remote request failed");
+                    });
+                    return;
+                }
+                const uploadPath = pathname.match(/^\/api\/mobile\/uploads\/([A-Za-z0-9_-]+)$/);
+                if (uploadPath && this.opts.uploads) {
+                    void this.opts.uploads.acceptPut(uploadPath[1], req, res);
+                    return;
+                }
+                // The mobile app is built/served with vite base "/mobile/", so ALL of its
+                // assets — and in dev, vite's HMR/module URLs — live under the /mobile
+                // prefix. A single prefix route serves prod (static out/mobile) and dev
+                // (proxy to the mobile vite server) symmetrically. Tunnel mode never
+                // proxies dev: Vite's HMR socket and @fs module URLs don't survive a
+                // public trycloudflare hop, so a public tunnel always serves the build.
+                // Match the route family exactly ("/mobile", "/mobile/…", "/mobile?…",
+                // "/mobile#…") — NOT a sibling like "/mobilexyz", which falls to 404.
+                if (req.url && /^\/mobile(?:[/?#]|$)/.test(req.url)) {
+                    serveMobile(req, res, {
+                        rootDir: this.mobileRootDir,
+                        devUrl: publicAccess ? undefined : this.mobileDevUrl,
+                    });
+                    return;
+                }
+                // The bare origin is what people type or share; send it to the app with
+                // the query (e.g. ?pairing=) intact. Match the raw target, not the
+                // parsed pathname: "//other.host/" parses to "/" but must stay a 404.
+                const rootQuery = rootEntryQuery(req.url);
+                if (rootQuery !== undefined && (req.method === "GET" || req.method === "HEAD")) {
+                    res.writeHead(302, { location: `/mobile/${rootQuery}`, "cache-control": "no-store" });
+                    res.end();
+                    return;
+                }
+                res.writeHead(404);
+                res.end("not found");
+            };
+            const webApi = this.opts.webApi;
+            if (gate?.isSet() &&
+                ["GET", "HEAD"].includes(req.method ?? "") &&
+                pathname.startsWith("/api/v1/panel-assets/") &&
+                webApi?.handleCapabilityAsset) {
+                void webApi.handleCapabilityAsset(req, res).then((handled) => {
+                    if (!handled && !res.writableEnded)
+                        serve();
+                }, () => {
                     if (!res.headersSent)
                         res.writeHead(500);
                     if (!res.writableEnded)
-                        res.end("remote request failed");
-                });
-                return;
-            }
-            const uploadPath = pathname.match(/^\/api\/mobile\/uploads\/([A-Za-z0-9_-]+)$/);
-            if (uploadPath && this.opts.uploads) {
-                void this.opts.uploads.acceptPut(uploadPath[1], req, res);
-                return;
-            }
-            // The mobile app is built/served with vite base "/mobile/", so ALL of its
-            // assets — and in dev, vite's HMR/module URLs — live under the /mobile
-            // prefix. A single prefix route serves prod (static out/mobile) and dev
-            // (proxy to the mobile vite server) symmetrically. Tunnel mode never
-            // proxies dev: Vite's HMR socket and @fs module URLs don't survive a
-            // public trycloudflare hop, so a public tunnel always serves the build.
-            // Match the route family exactly ("/mobile", "/mobile/…", "/mobile?…",
-            // "/mobile#…") — NOT a sibling like "/mobilexyz", which falls to 404.
-            if (req.url && /^\/mobile(?:[/?#]|$)/.test(req.url)) {
-                serveMobile(req, res, {
-                    rootDir: this.mobileRootDir,
-                    devUrl: publicAccess ? undefined : this.mobileDevUrl,
+                        res.end("remote asset request failed");
                 });
                 return;
             }
-            res.writeHead(404);
-            res.end("not found");
+            serve();
         });
         // In tunnel mode we must gate the WS handshake too. `noServer` lets us run
         // the passcode check during the HTTP `upgrade` event before completing the
@@ -225,7 +265,9 @@ export class RemoteHostManager extends EventEmitter {
                     socket.destroy();
                     return;
                 }
+                const isAccessAuthorized = gate.captureValidity();
                 this.wss.handleUpgrade(req, socket, head, (ws) => {
+                    this.socketAccessValidity.set(ws, isAccessAuthorized);
                     this.wss.emit("connection", ws, req);
                 });
             });
@@ -241,17 +283,19 @@ export class RemoteHostManager extends EventEmitter {
                 this.emit("host-error", error);
             });
             ws.on("message", (raw) => {
+                if (!this.hasSocketAccess(ws))
+                    return;
                 let parsed;
                 try {
                     parsed = JSON.parse(String(raw));
                 }
                 catch {
-                    ws.send(JSON.stringify({ type: "error", message: "Invalid JSON" }));
+                    this.sendBounded(ws, JSON.stringify({ type: "error", message: "Invalid JSON" }));
                     return;
                 }
                 const event = parseMobileClientEvent(parsed);
                 if (!event) {
-                    ws.send(JSON.stringify({ type: "error", message: "Invalid client event" }));
+                    this.sendBounded(ws, JSON.stringify({ type: "error", message: "Invalid client event" }));
                     return;
                 }
                 // Pairing/auth are handled inline and bind device identity to this
@@ -262,7 +306,7 @@ export class RemoteHostManager extends EventEmitter {
                     reply = this.handleClientEvent(event);
                 }
                 catch {
-                    ws.send(JSON.stringify({ type: "error", message: "Client event failed" }));
+                    this.sendBounded(ws, JSON.stringify({ type: "error", message: "Client event failed" }));
                     return;
                 }
                 if (event.type === "auth.device" && reply?.type === "auth.ok") {
@@ -273,11 +317,11 @@ export class RemoteHostManager extends EventEmitter {
                     this.bindSocketDevice(ws, reply.device.id);
                 }
                 if (reply) {
-                    ws.send(JSON.stringify(reply));
+                    this.sendBounded(ws, JSON.stringify(reply));
                     return;
                 }
                 if (!this.authed.has(ws)) {
-                    ws.send(JSON.stringify({ type: "auth.failed", message: "Not authenticated" }));
+                    this.sendBounded(ws, JSON.stringify({ type: "auth.failed", message: "Not authenticated" }));
                     return;
                 }
                 // Authenticated, non-auth event → hand to the main dispatcher, which
@@ -286,12 +330,12 @@ export class RemoteHostManager extends EventEmitter {
                     const dispatched = this.opts.onClientEvent({ ...event, deviceId: this.authed.get(ws), viewerId: this.viewers.get(ws) }, ws);
                     void Promise.resolve(dispatched).catch(() => {
                         if (ws.readyState === ws.OPEN) {
-                            ws.send(JSON.stringify({ type: "error", message: "Client event failed" }));
+                            this.sendBounded(ws, JSON.stringify({ type: "error", message: "Client event failed" }));
                         }
                     });
                 }
                 catch {
-                    ws.send(JSON.stringify({ type: "error", message: "Client event failed" }));
+                    this.sendBounded(ws, JSON.stringify({ type: "error", message: "Client event failed" }));
                 }
             });
             ws.on("close", () => {
@@ -346,6 +390,17 @@ export class RemoteHostManager extends EventEmitter {
             url: `http://${bindHost}:${port}`,
             mode: options.mode ?? "lan",
         };
+        if (gate) {
+            const sockets = this.wss;
+            // Idle public tabs must also relinquish viewer-owned state after rotation.
+            // Traffic is checked synchronously in both directions, without rehashing
+            // any plaintext or spending the passcode attempt budget.
+            this.accessSweep = setInterval(() => {
+                for (const client of sockets?.clients ?? [])
+                    this.hasSocketAccess(client);
+            }, 1000);
+            this.accessSweep.unref();
+        }
         return this.started;
     }
     /**
@@ -473,7 +528,7 @@ export class RemoteHostManager extends EventEmitter {
     /** Reply only to the currently authenticated tab; retired/revoked viewers receive nothing. */
     hasAuthenticatedViewer(viewerId, deviceId) {
         for (const client of this.wss?.clients ?? []) {
-            if (client.readyState === client.OPEN &&
+            if (this.hasSocketAccess(client) &&
                 this.authed.get(client) === deviceId &&
                 this.viewers.get(client) === viewerId)
                 return true;
@@ -481,7 +536,10 @@ export class RemoteHostManager extends EventEmitter {
         return false;
     }
     sendToViewer(viewerId, event) {
-        const payload = JSON.stringify(event);
+        this.sendRawToViewer(viewerId, JSON.stringify(event));
+    }
+    /** Preserve the full worker envelope while retaining exact authenticated-tab routing. */
+    sendRawToViewer(viewerId, payload) {
         for (const client of this.wss?.clients ?? []) {
             if (client.readyState === client.OPEN &&
                 this.authed.has(client) &&
@@ -519,6 +577,8 @@ export class RemoteHostManager extends EventEmitter {
      * socket is still delivered. Returns false when retired.
      */
     sendBounded(client, payload) {
+        if (!this.hasSocketAccess(client))
+            return false;
         if (client.bufferedAmount > 0 &&
             client.bufferedAmount + Buffer.byteLength(payload) > MAX_SOCKET_BACKLOG_BYTES) {
             this.releaseSocket(client);
@@ -528,6 +588,20 @@ export class RemoteHostManager extends EventEmitter {
         client.send(payload);
         return true;
     }
+    hasSocketAccess(client) {
+        if (client.readyState !== client.OPEN)
+            return false;
+        if (this.socketAccessValidity.get(client)?.() !== false)
+            return true;
+        this.releaseSocket(client);
+        // Distinct from paired-device rejection (4401/4403): the browser keeps its
+        // identity and offers a fresh HTTP challenge instead of silently retrying.
+        client.close(4407, "Access passcode changed");
+        const deadline = setTimeout(() => client.terminate(), 1000);
+        deadline.unref();
+        client.once("close", () => clearTimeout(deadline));
+        return false;
+    }
     releaseSocket(ws) {
         const deviceId = this.authed.get(ws);
         const viewerId = this.viewers.get(ws);
@@ -584,6 +658,8 @@ export class RemoteHostManager extends EventEmitter {
     async stopOnce() {
         if (this.starting)
             await this.starting.catch(() => undefined);
+        clearInterval(this.accessSweep);
+        this.accessSweep = undefined;
         this.relayLifetime?.abort();
         this.relayLifetime = undefined;
         const server = this.server;

package/dist/mobile-remote/resident-agent.js

@@ -1,5 +1,5 @@
 import { spawn } from "node:child_process";
-import { stopRoomProcess } from "./room-process-stop.js";
+import { releaseStdioAfterExit, stopRoomProcess } from "./room-process-stop.js";
 import { createInterface } from "node:readline";
 import { pathWithCommonBins } from "./path-bins.js";
 /**
@@ -149,6 +149,8 @@ export class ResidentAgentProcess {
             stdio: ["pipe", "pipe", "pipe"],
         });
         this.child = child;
+        // Settle on `close` so trailing output is read, without waiting on grandchildren.
+        releaseStdioAfterExit(child);
         if (child.stdout) {
             const rl = createInterface({ input: child.stdout });
             rl.on("line", (line) => {

package/dist/mobile-remote/room-manager.d.ts

@@ -119,6 +119,10 @@ export interface RoomManagerOptions {
      * Returning null means the transcript is absent. The returned identity is
      * checked again here so a stale or mismatched locator fails closed. */
     resolveLinkedSession?: (target: Readonly<LinkedSessionTarget>) => LinkedSessionTarget | null | undefined;
+    /** Throws while a background task (DriveAgent) may still be writing this
+     * external session. Checked before any resident agent can start on it, so
+     * desktop and phone entry points share one ownership gate. */
+    assertExternalSessionAvailable?: (externalSessionId: string, kind: RoomKind) => void;
     /** Called whenever a room gains a new persisted message (push to phone). */
     onMessage: (roomId: string, msg: RoomMessage) => void;
     /** Called when a room's resident agent requests tool-use approval. For

package/dist/mobile-remote/room-manager.js

@@ -777,6 +777,8 @@ export class RoomManager {
      * so a given claude session maps to exactly one room. Returns the room id.
      */
     openForSession(claudeSessionId, cwd, mode, kind = "claude-code") {
+        if (claudeSessionId)
+            this.opts.assertExternalSessionAvailable?.(claudeSessionId, kind);
         // Reuse must match BOTH id and kind: a codex thread id and a claude session
         // id live in the same `claudeSessionId` field, so a bare id match could
         // otherwise hand back a claude room when a codex room was asked for.
@@ -851,6 +853,7 @@ export class RoomManager {
      * silently start a different session. */
     takeOverLinkedSession(roomId, externalSessionId, cwd, kind) {
         const target = this.requireLinkedSessionTarget({ externalSessionId, cwd, kind });
+        this.opts.assertExternalSessionAvailable?.(target.externalSessionId, target.kind);
         const meta = this.getRoom(roomId);
         if (!meta ||
             meta.claudeSessionId !== target.externalSessionId ||
@@ -969,6 +972,8 @@ export class RoomManager {
         if (meta.linkedSessionMode === "observe-only")
             return { status: "observing" };
         if (!this.agents.has(id)) {
+            if (meta.claudeSessionId)
+                this.opts.assertExternalSessionAvailable?.(meta.claudeSessionId, meta.kind);
             let agent = undefined;
             agent = this.opts.createAgent(meta, (event) => {
                 // stop() sends a signal; an old process can still drain output or emit

package/dist/mobile-remote/room-process-stop.d.ts

@@ -1,3 +1,11 @@
 import type { ChildProcess } from "node:child_process";
 /** Retire an unusable room transport without leaving an unresponsive CLI alive. */
 export declare function stopRoomProcess(child: ChildProcess): void;
+/**
+ * `close` waits for every holder of the child's stdout/stderr. A grandchild the
+ * CLI backgrounded with inherited stdio (a dev server, say) keeps them open
+ * after the CLI exits, so the room would never settle. Once the CLI has exited
+ * and its buffered output had a grace period to drain, release the pipes;
+ * the grandchild itself is left running.
+ */
+export declare function releaseStdioAfterExit(child: ChildProcess, graceMs?: number): void;

package/dist/mobile-remote/room-process-stop.js

@@ -26,3 +26,21 @@ export function stopRoomProcess(child) {
     timer.unref();
     child.once("exit", () => clearTimeout(timer));
 }
+/**
+ * `close` waits for every holder of the child's stdout/stderr. A grandchild the
+ * CLI backgrounded with inherited stdio (a dev server, say) keeps them open
+ * after the CLI exits, so the room would never settle. Once the CLI has exited
+ * and its buffered output had a grace period to drain, release the pipes;
+ * the grandchild itself is left running.
+ */
+export function releaseStdioAfterExit(child, graceMs = 1_000) {
+    child.once("exit", () => {
+        const timer = setTimeout(() => {
+            child.stdout?.destroy();
+            child.stderr?.destroy();
+            child.stdin?.destroy();
+        }, graceMs);
+        timer.unref();
+        child.once("close", () => clearTimeout(timer));
+    });
+}

package/dist/mobile-remote/tunnel-manager.d.ts

@@ -51,6 +51,7 @@ export declare class TunnelManager extends EventEmitter {
     private readonly killGraceMs;
     private readonly killHardTimeoutMs;
     private child?;
+    private cancelPendingStart?;
     /** In-flight teardown of a previous child. Any start() awaits this first so a
      *  new cloudflared never spawns while the old one still owns the metrics port. */
     private pendingTeardown?;