@rynx-ai/daemon 0.1.11-beta.38 → 0.1.11-beta.39

package/bundled-plugins/plugins/lark/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rynx-ai/plugin-channel-lark",
-  "version": "0.1.11-beta.38",
+  "version": "0.1.11-beta.39",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/rynx-ai/rynx.git",

package/dist/headless-browser-host.js

@@ -42,6 +42,14 @@ const NETWORK_AUTO_ATTACH_FILTER = [
     { 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);
 }
@@ -235,12 +243,7 @@ class HeadlessBrowserHandle {
     }
     async initialize() {
         await this.host.connection.command("Target.setDiscoverTargets", { discover: true });
-        await this.host.connection.command("Target.setAutoAttach", {
-            autoAttach: true,
-            waitForDebuggerOnStart: true,
-            flatten: true,
-            filter: NETWORK_AUTO_ATTACH_FILTER,
-        });
+        await this.host.connection.command("Target.setAutoAttach", NETWORK_AUTO_ATTACH_PARAMS);
         await this.createFreshStartupPage();
         await this.refreshTargets();
         const requestedUrl = this.host.input.url;
@@ -433,14 +436,28 @@ class HeadlessBrowserHandle {
         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();
@@ -501,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))
@@ -700,6 +725,13 @@ class HeadlessBrowserHandle {
             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))
@@ -744,6 +776,16 @@ class HeadlessBrowserHandle {
             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;
@@ -765,7 +807,12 @@ 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;
         }
@@ -778,6 +825,10 @@ class HeadlessBrowserHandle {
         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;
@@ -856,17 +907,14 @@ class HeadlessBrowserHandle {
     }
     async initializeAttachedTarget(sessionId, target, waitingForDebugger) {
         try {
-            await this.host.connection.command("Network.enable", {}, sessionId);
+            // 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", {
-                    autoAttach: true,
-                    waitForDebuggerOnStart: true,
-                    flatten: true,
-                    filter: NETWORK_AUTO_ATTACH_FILTER,
-                }, sessionId);
+                await this.host.connection.command("Target.setAutoAttach", NETWORK_AUTO_ATTACH_PARAMS, sessionId);
             }
             if (target.type === "page") {
                 await this.host.connection.command("Page.enable", {}, sessionId);
@@ -874,14 +922,52 @@ class HeadlessBrowserHandle {
             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);
             }
-            this.markUnavailable("Headless Browser could not initialize a network target");
-            throw this.mapOperationError(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) {
@@ -898,6 +984,27 @@ class HeadlessBrowserHandle {
             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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rynx-ai/daemon",
-  "version": "0.1.11-beta.38",
+  "version": "0.1.11-beta.39",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/rynx-ai/rynx.git",
@@ -51,17 +51,18 @@
     "tar": "^7.5.19",
     "undici": "^7.28.0",
     "ws": "^8.21.0",
-    "@rynx-ai/core": "0.1.11-beta.38",
-    "@rynx-ai/emulator": "0.1.11-beta.38",
-    "@rynx-ai/plugin-runner": "0.1.11-beta.38",
-    "@rynx-ai/plugin-sdk": "0.1.11-beta.38",
-    "@rynx-ai/protocol": "0.1.11-beta.38",
-    "@rynx-ai/remote-runtime-client": "0.1.11-beta.38",
-    "@rynx-ai/server": "0.1.11-beta.38"
+    "@rynx-ai/core": "0.1.11-beta.39",
+    "@rynx-ai/emulator": "0.1.11-beta.39",
+    "@rynx-ai/plugin-runner": "0.1.11-beta.39",
+    "@rynx-ai/plugin-sdk": "0.1.11-beta.39",
+    "@rynx-ai/protocol": "0.1.11-beta.39",
+    "@rynx-ai/remote-runtime-client": "0.1.11-beta.39",
+    "@rynx-ai/server": "0.1.11-beta.39"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1",
-    "@rynx-ai/plugin-channel-lark": "0.1.11-beta.38"
+    "@rynx-ai/browser-cdp": "0.1.11-beta.39",
+    "@rynx-ai/plugin-channel-lark": "0.1.11-beta.39"
   },
   "scripts": {
     "build": "rm -rf dist bundled-plugins && tsc -p tsconfig.json && chmod +x dist/index-daemon.js && node ../../scripts/stage-bundled-plugins.mjs",