@rynx-ai/daemon 0.1.11-beta.4 → 0.1.11-beta.41

package/dist/headless-browser-host.js

@@ -34,6 +34,22 @@ const DEVTOOLS_BROWSER_PATH = /^\/devtools\/browser\/[A-Za-z0-9._~-]+$/;
 const DEVTOOLS_TARGET_ID_PATTERN = /^[A-Za-z0-9._~-]+$/;
 const CONTROL_CHARACTER_PATTERN = /[\u0000-\u001f\u007f]/;
 const CONTROL_CHARACTER_GLOBAL_PATTERN = /[\u0000-\u001f\u007f]/g;
+const NETWORK_AUTO_ATTACH_FILTER = [
+    { type: "page" },
+    { type: "iframe" },
+    { type: "worker" },
+    { type: "service_worker" },
+    { type: "shared_worker" },
+    { exclude: true },
+];
+const NETWORK_AUTO_ATTACH_PARAMS = {
+    autoAttach: true,
+    // Pause new targets until Fetch interception is installed. This is required
+    // for Session Headers to cover a popup's very first navigation request.
+    waitForDebuggerOnStart: true,
+    flatten: true,
+    filter: NETWORK_AUTO_ATTACH_FILTER,
+};
 export function createHeadlessBrowserHost(options = {}) {
     return new HeadlessBrowserHost(options);
 }
@@ -95,7 +111,7 @@ class HeadlessBrowserHost {
             throw error;
         }
         const ownerToken = randomBytes(32).toString("hex");
-        const args = chromeArguments(profileDir, ownerToken, input.url ?? "about:blank");
+        const args = chromeArguments(profileDir, ownerToken);
         let child;
         try {
             child = spawn(build.executablePath, args, {
@@ -198,6 +214,7 @@ class HeadlessBrowserHandle {
     closingTargetIds = new Set();
     pageSessions = new Map();
     targetBySession = new Map();
+    networkTargetTypeBySession = new Map();
     surfaceSources = new Map();
     loadingTargets = new Set();
     activeTargetId = null;
@@ -205,8 +222,11 @@ class HeadlessBrowserHandle {
     closing = false;
     closePromise;
     operations = Promise.resolve();
+    networkOperations = Promise.resolve();
+    requestHeaders;
     constructor(host) {
         this.host = host;
+        this.requestHeaders = cloneRequestHeadersConfig(host.input.requestHeaders ?? { enabled: false, headers: [] });
         this.events = this.eventQueue;
         this.host.connection.setEventHandler((event) => this.onCdpEvent(event));
         this.host.connection.setDisconnectHandler((reason) => this.markUnavailable(reason));
@@ -223,21 +243,17 @@ class HeadlessBrowserHandle {
     }
     async initialize() {
         await this.host.connection.command("Target.setDiscoverTargets", { discover: true });
-        await this.replaceRestoredStartupPages(this.host.input.url ?? "about:blank");
+        await this.host.connection.command("Target.setAutoAttach", NETWORK_AUTO_ATTACH_PARAMS);
+        await this.createFreshStartupPage();
         await this.refreshTargets();
         const requestedUrl = this.host.input.url;
         if (requestedUrl) {
-            let requestedTarget;
-            for (const target of this.targets.values()) {
-                if (target.url === requestedUrl)
-                    requestedTarget = target;
-            }
-            if (requestedTarget) {
-                await this.host.connection.command("Target.activateTarget", {
-                    targetId: requestedTarget.targetId,
-                });
-                this.activeTargetId = requestedTarget.targetId;
-            }
+            const targetId = this.activeTargetId;
+            if (!targetId)
+                throw new Error("Headless Browser startup Page is unavailable");
+            const pageSessionId = await this.pageSession(targetId);
+            await this.host.connection.command("Page.navigate", { url: requestedUrl }, pageSessionId);
+            await this.resetPageNavigationHistory(targetId);
         }
     }
     async getCdpEndpoint() {
@@ -336,10 +352,17 @@ class HeadlessBrowserHandle {
                 if (this.targets.size >= RUNTIME_BROWSER_MAX_PAGES) {
                     throw new SessionBrowserHostError("capacity", "Headless Browser Page capacity was reached");
                 }
-                const result = await this.host.connection.command("Target.createTarget", { url });
+                const result = await this.host.connection.command("Target.createTarget", {
+                    url: "about:blank",
+                });
                 const targetId = requiredCdpId(result.targetId, "Target.createTarget targetId");
                 this.activeTargetId = targetId;
                 await this.refreshTargets();
+                if (url !== "about:blank") {
+                    const pageSessionId = await this.pageSession(targetId);
+                    await this.host.connection.command("Page.navigate", { url }, pageSessionId);
+                    await this.resetPageNavigationHistory(targetId);
+                }
                 this.eventQueue.changed(this.browserGeneration);
             }
             catch (error) {
@@ -395,20 +418,46 @@ class HeadlessBrowserHandle {
     reload(hostPageId) {
         return this.pageCommand(hostPageId, "Page.reload", {});
     }
+    setRequestHeaders(config) {
+        return this.exclusive(async () => {
+            this.ensureAvailable();
+            await this.networkExclusive(async () => {
+                // Every target is permanently Fetch-intercepted before it is resumed.
+                // Swapping this immutable snapshot is therefore the single commit
+                // point for all current and future targets; already-paused/in-flight
+                // requests keep the snapshot they started with.
+                this.requestHeaders = cloneRequestHeadersConfig(config);
+            });
+        });
+    }
     close() {
         if (this.closePromise)
             return this.closePromise;
         this.closing = true;
         this.closePromise = (async () => {
             await Promise.allSettled([...this.surfaceSources.values()].map((source) => source.close()));
-            this.host.connection.close();
             let terminated = false;
             try {
-                await terminateProcessGroup(this.host.child, this.host.exit, this.host.terminationGraceMs);
+                let exited = false;
+                if (this.host.connection.connected) {
+                    const closeCommand = this.host.connection.command("Browser.close")
+                        .catch(() => undefined);
+                    exited = await Promise.race([
+                        this.host.exit.then(() => true),
+                        delay(this.host.terminationGraceMs).then(() => false),
+                    ]);
+                    if (!exited)
+                        this.host.connection.close();
+                    await closeCommand;
+                }
+                if (!exited) {
+                    await terminateProcessGroup(this.host.child, this.host.exit, this.host.terminationGraceMs);
+                }
                 removeMatchingProcessLease(this.host.profileDir, this.host.ownerToken);
                 terminated = true;
             }
             finally {
+                this.host.connection.close();
                 if (terminated)
                     this.host.release();
                 this.eventQueue.end();
@@ -434,6 +483,24 @@ class HeadlessBrowserHandle {
             }
         });
     }
+    async resetPageNavigationHistory(targetId) {
+        let lastError;
+        for (let attempt = 0; attempt < PAGE_SNAPSHOT_TRANSITION_ATTEMPTS; attempt += 1) {
+            const sessionId = await this.pageSession(targetId);
+            try {
+                await this.host.connection.command("Page.resetNavigationHistory", {}, sessionId);
+                return;
+            }
+            catch (error) {
+                if (!isMissingTargetError(error) && !isTransientPageTransitionError(error))
+                    throw error;
+                lastError = error;
+                this.dropAttachedSession(sessionId);
+                await delay(PAGE_SNAPSHOT_TRANSITION_POLL_MS);
+            }
+        }
+        throw lastError ?? new Error("Headless Browser could not reset Page navigation history");
+    }
     pageCommand(hostPageId, method, params) {
         return this.exclusive(async () => {
             this.ensureAvailable();
@@ -451,11 +518,19 @@ class HeadlessBrowserHandle {
         try {
             const targets = await this.readPageTargets();
             const next = new Map();
-            for (const target of targets) {
-                if (next.size >= RUNTIME_BROWSER_MAX_PAGES) {
-                    throw new SessionBrowserHostError("capacity", "Headless Browser has too many Pages");
+            const orderedTargets = [
+                ...targets.filter((target) => this.targets.has(target.targetId)),
+                ...targets.filter((target) => !this.targets.has(target.targetId)),
+            ];
+            for (const target of orderedTargets) {
+                if (this.closingTargetIds.has(target.targetId))
+                    continue;
+                if (next.size < RUNTIME_BROWSER_MAX_PAGES) {
+                    next.set(target.targetId, target);
+                    continue;
                 }
-                next.set(target.targetId, target);
+                this.closingTargetIds.add(target.targetId);
+                await this.networkExclusive(() => this.closeRejectedTarget(undefined, target, false));
             }
             for (const targetId of this.targets.keys()) {
                 if (!next.has(targetId))
@@ -491,13 +566,23 @@ class HeadlessBrowserHandle {
             throw this.mapOperationError(error);
         }
     }
-    async replaceRestoredStartupPages(url) {
+    async createFreshStartupPage() {
         const initialPages = await this.readPageTargets();
-        if (initialPages.length <= 1)
-            return;
-        const created = await this.host.connection.command("Target.createTarget", { url });
+        for (const page of initialPages) {
+            try {
+                await this.host.connection.command("Target.closeTarget", { targetId: page.targetId });
+            }
+            catch (error) {
+                if (!isMissingPageError(error))
+                    throw error;
+            }
+        }
+        const created = await this.host.connection.command("Target.createTarget", {
+            url: "about:blank",
+        });
         const freshTargetId = requiredCdpId(created.targetId, "Target.createTarget targetId");
         this.activeTargetId = freshTargetId;
+        await this.host.connection.command("Target.activateTarget", { targetId: freshTargetId });
         for (let attempt = 0; attempt < STARTUP_PAGE_CLEANUP_ATTEMPTS; attempt += 1) {
             const pages = await this.readPageTargets();
             if (!pages.some((page) => page.targetId === freshTargetId)) {
@@ -581,11 +666,21 @@ class HeadlessBrowserHandle {
             canGoForward: false,
         };
     }
-    async pageSession(targetId) {
+    async pageSession(targetId, retryMissing = true) {
         this.requireTarget(targetId);
         const existing = this.pageSessions.get(targetId);
-        if (existing)
-            return existing;
+        if (existing) {
+            try {
+                return await existing;
+            }
+            catch (error) {
+                if (!retryMissing || !isMissingPageError(error))
+                    throw error;
+                if (this.pageSessions.get(targetId) === existing)
+                    this.pageSessions.delete(targetId);
+                return this.pageSession(targetId, false);
+            }
+        }
         const pending = (async () => {
             const result = await this.host.connection.command("Target.attachToTarget", {
                 targetId,
@@ -593,7 +688,8 @@ class HeadlessBrowserHandle {
             });
             const sessionId = requiredCdpId(result.sessionId, "Target.attachToTarget sessionId");
             this.targetBySession.set(sessionId, targetId);
-            await this.host.connection.command("Page.enable", {}, sessionId);
+            this.networkTargetTypeBySession.set(sessionId, "page");
+            await this.networkExclusive(() => this.initializeAttachedTarget(sessionId, this.requireTarget(targetId), false));
             return sessionId;
         })();
         this.pageSessions.set(targetId, pending);
@@ -608,10 +704,88 @@ class HeadlessBrowserHandle {
     onCdpEvent(event) {
         if (this.closing || this.unavailableReason)
             return;
+        if (event.method === "Fetch.requestPaused" && event.sessionId) {
+            void this.continuePausedRequest(event.sessionId, event.params).catch((error) => {
+                if (isMissingFetchRequestError(error))
+                    return;
+                if (isMissingTargetError(error) || isTransientPageTransitionError(error)) {
+                    this.dropAttachedSession(event.sessionId);
+                    return;
+                }
+                this.markUnavailable("Headless Browser could not continue an intercepted request");
+            });
+            return;
+        }
+        if (event.method === "Target.attachedToTarget") {
+            const sessionId = optionalCdpId(event.params.sessionId);
+            const target = parseTargetInfo(event.params.targetInfo);
+            if (!sessionId)
+                return;
+            const waitingForDebugger = event.params.waitingForDebugger === true;
+            this.targetBySession.set(sessionId, target.targetId);
+            this.networkTargetTypeBySession.set(sessionId, target.type);
+            if (target.type === "page") {
+                if (this.closingTargetIds.has(target.targetId) ||
+                    (!this.targets.has(target.targetId) &&
+                        this.targets.size >= RUNTIME_BROWSER_MAX_PAGES)) {
+                    this.closingTargetIds.add(target.targetId);
+                    void this.networkExclusive(() => this.closeRejectedTarget(sessionId, target, waitingForDebugger)).catch(() => undefined);
+                    return;
+                }
+                this.targets.set(target.targetId, target);
+                let pending;
+                pending = this.networkExclusive(() => this.initializeAttachedTarget(sessionId, target, waitingForDebugger))
+                    .then(async () => {
+                    const selected = this.pageSessions.get(target.targetId);
+                    if (selected && selected !== pending) {
+                        let selectedSessionId;
+                        try {
+                            selectedSessionId = await selected;
+                        }
+                        catch {
+                            // The next Page operation will establish a replacement.
+                        }
+                        if (selectedSessionId !== sessionId &&
+                            this.targetBySession.get(sessionId) === target.targetId) {
+                            await this.networkExclusive(() => this.detachAuxiliaryPageSession(sessionId));
+                        }
+                    }
+                    return sessionId;
+                })
+                    .catch((error) => {
+                    if (this.pageSessions.get(target.targetId) === pending) {
+                        this.pageSessions.delete(target.targetId);
+                    }
+                    throw error;
+                });
+                void pending.catch(() => undefined);
+                // Chrome may deliver a waitForDebugger auto-attach session while a
+                // manual Target.attachToTarget for the same Page is still pending.
+                // Every physical session must be initialized and resumed even when a
+                // different session already owns semantic Page commands.
+                if (!this.pageSessions.has(target.targetId)) {
+                    this.pageSessions.set(target.targetId, pending);
+                }
+            }
+            else {
+                void this.networkExclusive(() => this.initializeAttachedTarget(sessionId, target, waitingForDebugger)).catch(() => undefined);
+            }
+            return;
+        }
         if (event.method === "Target.targetCreated" || event.method === "Target.targetInfoChanged") {
             const target = parseTargetInfo(event.params.targetInfo);
             if (target.type !== "page")
                 return;
+            if (event.method === "Target.targetCreated" &&
+                !this.targets.has(target.targetId) &&
+                this.targets.size >= RUNTIME_BROWSER_MAX_PAGES) {
+                this.closingTargetIds.add(target.targetId);
+                void this.networkExclusive(() => this.closeRejectedTarget(undefined, target, false))
+                    .catch(() => undefined);
+                return;
+            }
+            if (this.closingTargetIds.has(target.targetId))
+                return;
             this.targets.set(target.targetId, target);
             if (event.method === "Target.targetCreated")
                 this.activeTargetId = target.targetId;
@@ -633,19 +807,28 @@ class HeadlessBrowserHandle {
         if (event.method === "Target.targetCrashed") {
             const targetId = optionalCdpId(event.params.targetId);
             if (targetId && this.targets.has(targetId)) {
-                this.markUnavailable("A Headless Browser Page renderer crashed");
+                const target = this.targets.get(targetId);
+                this.closingTargetIds.add(targetId);
+                this.dropTarget(targetId);
+                void this.networkExclusive(() => this.closeRejectedTarget(undefined, target, false))
+                    .catch(() => undefined);
+                this.eventQueue.changed(this.browserGeneration);
             }
             return;
         }
         if (event.method === "Target.detachedFromTarget") {
             const sessionId = optionalCdpId(event.params.sessionId);
             if (sessionId)
-                this.dropPageSession(sessionId);
+                this.dropAttachedSession(sessionId);
             return;
         }
         const targetId = event.sessionId ? this.targetBySession.get(event.sessionId) : undefined;
         if (!targetId)
             return;
+        if (event.method === "Page.javascriptDialogOpening") {
+            void this.dismissJavaScriptDialog(event.sessionId, targetId);
+            return;
+        }
         if (event.method === "Inspector.detached") {
             this.dropPageSession(event.sessionId);
             return;
@@ -683,22 +866,162 @@ class HeadlessBrowserHandle {
         this.loadingTargets.delete(targetId);
         const session = this.pageSessions.get(targetId);
         this.pageSessions.delete(targetId);
+        for (const [sessionId, attachedTargetId] of this.targetBySession) {
+            if (attachedTargetId === targetId)
+                this.dropAttachedSession(sessionId);
+        }
+        // A manual attach can resolve after targetDestroyed. Clean the late
+        // session as well instead of retaining it in the Network update set.
         if (session)
-            void session.then((id) => this.targetBySession.delete(id), () => undefined);
+            void session.then((id) => this.dropAttachedSession(id), () => undefined);
     }
     dropPageSession(sessionId) {
         const targetId = this.targetBySession.get(sessionId);
+        this.targetBySession.delete(sessionId);
+        this.networkTargetTypeBySession.delete(sessionId);
         if (!targetId)
             return;
-        this.targetBySession.delete(sessionId);
-        this.pageSessions.delete(targetId);
-        const surface = this.surfaceSources.get(targetId);
-        if (surface) {
-            this.surfaceSources.delete(targetId);
-            surface.closeAfterSourceLoss();
+        const selected = this.pageSessions.get(targetId);
+        if (selected) {
+            void selected.then((selectedSessionId) => {
+                if (selectedSessionId === sessionId &&
+                    this.pageSessions.get(targetId) === selected) {
+                    this.pageSessions.delete(targetId);
+                    const surface = this.surfaceSources.get(targetId);
+                    if (surface) {
+                        this.surfaceSources.delete(targetId);
+                        surface.closeAfterSourceLoss();
+                    }
+                }
+            }, () => undefined);
         }
         this.eventQueue.changed(this.browserGeneration);
     }
+    dropAttachedSession(sessionId) {
+        if (this.networkTargetTypeBySession.get(sessionId) === "page") {
+            this.dropPageSession(sessionId);
+            return;
+        }
+        this.networkTargetTypeBySession.delete(sessionId);
+        this.targetBySession.delete(sessionId);
+    }
+    async initializeAttachedTarget(sessionId, target, waitingForDebugger) {
+        try {
+            // Fetch.enable succeeds while a waitForDebugger target is paused and must
+            // precede its first request. Network.enable does not: current Chrome for
+            // Testing builds leave that command pending until the target is resumed.
+            await this.host.connection.command("Fetch.enable", {
+                patterns: [{ urlPattern: "*", requestStage: "Request" }],
+            }, sessionId);
+            if (target.type === "page" || target.type === "iframe") {
+                await this.host.connection.command("Target.setAutoAttach", NETWORK_AUTO_ATTACH_PARAMS, sessionId);
+            }
+            if (target.type === "page") {
+                await this.host.connection.command("Page.enable", {}, sessionId);
+            }
+            if (waitingForDebugger) {
+                await this.host.connection.command("Runtime.runIfWaitingForDebugger", {}, sessionId);
+            }
+            await this.host.connection.command("Network.enable", {}, sessionId);
+        }
+        catch (error) {
+            if (isMissingTargetError(error) || isTransientPageTransitionError(error)) {
+                this.dropAttachedSession(sessionId);
+                throw missingPage(error);
+            }
+            if (!this.host.connection.connected || error instanceof CdpDisconnectedError) {
+                this.markUnavailable("The native CDP observer disconnected");
+                throw this.mapOperationError(error);
+            }
+            await this.closeRejectedTarget(sessionId, target, waitingForDebugger);
+            if (target.type === "page")
+                throw missingPage(error);
+            throw unavailable("Headless Browser isolated a network target that failed setup", error);
+        }
+    }
+    async closeRejectedTarget(sessionId, target, waitingForDebugger) {
+        if (target.type === "page") {
+            this.closingTargetIds.add(target.targetId);
+            this.dropTarget(target.targetId);
+        }
+        else if (sessionId) {
+            this.dropAttachedSession(sessionId);
+        }
+        let closed = false;
+        try {
+            if (this.host.connection.connected) {
+                const result = await this.host.connection.command("Target.closeTarget", {
+                    targetId: target.targetId,
+                });
+                closed = result.success === true;
+            }
+        }
+        catch (error) {
+            if (!isMissingTargetError(error) && !isTransientPageTransitionError(error)) {
+                if (!this.host.connection.connected || error instanceof CdpDisconnectedError) {
+                    this.markUnavailable("The native CDP observer disconnected");
+                }
+            }
+        }
+        if (!closed && waitingForDebugger && sessionId && this.host.connection.connected) {
+            await this.host.connection.command("Runtime.runIfWaitingForDebugger", {}, sessionId).catch(() => undefined);
+        }
+        if (!closed && sessionId && this.host.connection.connected) {
+            await this.host.connection.command("Target.detachFromTarget", { sessionId }).catch(() => undefined);
+        }
+    }
+    async detachAuxiliaryPageSession(sessionId) {
+        try {
+            await this.host.connection.command("Target.detachFromTarget", { sessionId });
+        }
+        catch (error) {
+            if (!isMissingTargetError(error) && !isTransientPageTransitionError(error)) {
+                this.markUnavailable("Headless Browser could not fence a duplicate Page session");
+                throw this.mapOperationError(error);
+            }
+        }
+        finally {
+            this.dropAttachedSession(sessionId);
+        }
+    }
+    async dismissJavaScriptDialog(sessionId, targetId) {
+        try {
+            // Rynx has no native dialog presentation surface. Dismiss every modal
+            // deterministically so alert/confirm/prompt/beforeunload cannot block all
+            // later CDP commands for this Page.
+            await this.host.connection.command("Page.handleJavaScriptDialog", { accept: false }, sessionId);
+        }
+        catch (error) {
+            if (isMissingTargetError(error) || isTransientPageTransitionError(error)) {
+                this.dropAttachedSession(sessionId);
+                return;
+            }
+            if (!this.host.connection.connected || error instanceof CdpDisconnectedError) {
+                this.markUnavailable("The native CDP observer disconnected");
+                return;
+            }
+            const target = this.targets.get(targetId);
+            if (target)
+                await this.closeRejectedTarget(sessionId, target, false);
+        }
+    }
+    async continuePausedRequest(sessionId, params) {
+        const requestId = requiredCdpId(params.requestId, "Fetch.requestPaused requestId");
+        const config = this.requestHeaders;
+        const effective = config.enabled && config.headers.length > 0;
+        const request = effective && isRecord(params.request) ? params.request : {};
+        // This is a product-level baseline, not a security boundary: a caller
+        // holding the privileged native CDP endpoint can alter interception.
+        await this.host.connection.command("Fetch.continueRequest", {
+            requestId,
+            // Fetch treats `headers` as a full override. Omitting it is the only
+            // true pass-through path for disabled/empty policy and preserves
+            // Browser-managed Cookie, auth, redirect, and duplicate headers.
+            ...(effective
+                ? { headers: mergePausedRequestHeaders(pausedRequestHeaders(request.headers), config) }
+                : {}),
+        }, sessionId);
+    }
     ensureAvailable() {
         if (this.unavailableReason || this.closing || !this.host.connection.connected) {
             throw new SessionBrowserHostError("unavailable", "Headless Browser is unavailable");
@@ -729,6 +1052,11 @@ class HeadlessBrowserHandle {
         this.operations = result.then(() => undefined, () => undefined);
         return result;
     }
+    networkExclusive(operation) {
+        const result = this.networkOperations.then(operation, operation);
+        this.networkOperations = result.then(() => undefined, () => undefined);
+        return result;
+    }
 }
 class HeadlessBrowserSurfaceSource {
     source;
@@ -1476,7 +1804,7 @@ class CdpConnection {
                 this.pending.delete(id);
                 rejectCommand(new CdpCommandTimeoutError(`Native CDP command ${method} timed out`));
             }, this.commandTimeoutMs);
-            this.pending.set(id, { resolve: resolveCommand, reject: rejectCommand, timer });
+            this.pending.set(id, { method, resolve: resolveCommand, reject: rejectCommand, timer });
             try {
                 this.socket.send(JSON.stringify({ id, method, params, ...(sessionId ? { sessionId } : {}) }));
             }
@@ -1518,7 +1846,9 @@ class CdpConnection {
             this.pending.delete(value.id);
             clearTimeout(pending.timer);
             if (isRecord(value.error)) {
-                pending.reject(new CdpProtocolError(typeof value.error.code === "number" ? value.error.code : -1, typeof value.error.message === "string" ? value.error.message : "Native CDP command failed"));
+                pending.reject(new CdpProtocolError(typeof value.error.code === "number" ? value.error.code : -1, `Native CDP command ${pending.method} failed: ${typeof value.error.message === "string"
+                    ? value.error.message
+                    : "Native CDP command failed"}`));
             }
             else {
                 pending.resolve(value.result ?? {});
@@ -1887,7 +2217,7 @@ function readSmallRegularJson(path, maxBytes, label) {
         closeSync(descriptor);
     }
 }
-function chromeArguments(profileDir, ownerToken, url) {
+function chromeArguments(profileDir, ownerToken) {
     return [
         "--headless=new",
         "--use-mock-keychain",
@@ -1905,7 +2235,29 @@ function chromeArguments(profileDir, ownerToken, url) {
         "--metrics-recording-only",
         "--no-report-upload",
         "--window-size=1280,800",
-        url,
+        "--no-startup-window",
+    ];
+}
+function cloneRequestHeadersConfig(config) {
+    return {
+        enabled: config.enabled,
+        headers: config.headers.map((header) => ({ ...header })),
+    };
+}
+function pausedRequestHeaders(value) {
+    if (!isRecord(value))
+        return [];
+    return Object.entries(value).flatMap(([name, headerValue]) => typeof headerValue === "string" ? [{ name, value: headerValue }] : []);
+}
+function mergePausedRequestHeaders(original, config) {
+    if (!config.enabled)
+        return original.map((header) => ({ ...header }));
+    const overriddenNames = new Set(config.headers.map((header) => header.name.toLowerCase()));
+    return [
+        ...original
+            .filter((header) => !overriddenNames.has(header.name.toLowerCase()))
+            .map((header) => ({ ...header })),
+        ...config.headers.map((header) => ({ ...header })),
     ];
 }
 function validateActiveExecutable(build) {
@@ -2118,6 +2470,10 @@ function isTransientPageTransitionError(error) {
         /cannot find (?:an )?execution context/i.test(error.message) ||
         /cannot find context with specified id/i.test(error.message));
 }
+function isMissingFetchRequestError(error) {
+    return error instanceof CdpProtocolError && (/invalid (?:interception|request)id/i.test(error.message) ||
+        /no resource with given identifier/i.test(error.message));
+}
 function isMissingPageError(error) {
     return (error instanceof SessionBrowserHostError && error.code === "page_not_found") || isMissingTargetError(error);
 }

package/dist/lifecycle.d.ts

@@ -1,9 +1,10 @@
-export { formatControlUrl, isPm2DaemonOnline, statusDaemon, stopDaemon, streamLogs, } from "./pm2.js";
+export { formatControlUrl, isDaemonStartRequired, isPm2DaemonOnline, statusDaemon, stopDaemon, streamLogs, } from "./pm2.js";
 export { resolveDaemonEntry } from "./entry-path.js";
 export interface StandaloneDaemonLaunchContext {
     builtinSkillsDir: string;
     cliVersion: string;
     productVersion: string;
+    tmuxBin?: string;
 }
 export declare function startDaemon(options: {
     force: boolean;

package/dist/lifecycle.js

@@ -1,5 +1,5 @@
 import { startDaemon as startPm2Daemon, } from "./pm2.js";
-export { formatControlUrl, isPm2DaemonOnline, statusDaemon, stopDaemon, streamLogs, } from "./pm2.js";
+export { formatControlUrl, isDaemonStartRequired, isPm2DaemonOnline, statusDaemon, stopDaemon, streamLogs, } from "./pm2.js";
 export { resolveDaemonEntry } from "./entry-path.js";
 export function startDaemon(options) {
     return startPm2Daemon({
@@ -11,6 +11,9 @@ export function startDaemon(options) {
             RYNX_DISTRIBUTION: "standalone",
             RYNX_PRODUCT_VERSION: options.context.productVersion,
             RYNX_DAEMON_LIFECYCLE: "standalone",
+            // An empty value explicitly disables PATH fallback when the optional
+            // platform package is missing, while keeping the control plane runnable.
+            RYNX_TMUX_BIN: options.context.tmuxBin ?? "",
         },
     });
 }