@andrewting19/oracle 0.9.9 → 0.10.0

package/dist/src/browser/chromeLifecycle.js

@@ -123,14 +123,14 @@ export async function connectToChrome(port, logger, host) {
     logger("Connected to Chrome DevTools protocol");
     return client;
 }
-export async function connectToRemoteChrome(host, port, logger, targetUrl) {
+export async function connectToRemoteChrome(host, port, logger, targetUrl, rootSession) {
     if (targetUrl) {
         const targetConnection = await connectToNewTarget(host, port, targetUrl, logger, {
-            opened: () => `Opened dedicated remote Chrome tab targeting ${targetUrl}`,
+            opened: (targetId) => `Opened dedicated remote Chrome ${rootSession ? "hidden " : ""}target ${targetId}`,
             openFailed: (message) => `Failed to open dedicated remote Chrome tab (${message}); falling back to first target.`,
             attachFailed: (targetId, message) => `Failed to attach to dedicated remote Chrome tab ${targetId} (${message}); falling back to first target.`,
             closeFailed: (targetId, message) => `Failed to close unused remote Chrome tab ${targetId}: ${message}`,
-        });
+        }, rootSession);
         if (targetConnection) {
             return { client: targetConnection.client, targetId: targetConnection.targetId };
         }
@@ -154,9 +154,35 @@ export async function closeRemoteChromeTarget(host, port, targetId, logger) {
         logger(`Failed to close remote Chrome tab ${targetId}: ${message}`);
     }
 }
-async function connectToNewTarget(host, port, url, logger, messages) {
+async function connectToNewTarget(host, port, url, logger, messages, rootSession) {
     try {
-        const target = await CDP.New({ host, port, url });
+        let target;
+        if (rootSession) {
+            // Hidden target: not in tab strip, no window, no focus steal.
+            // Lifetime tied to rootSession (kept alive by the serve).
+            const result = await rootSession.Target.createTarget({
+                url,
+                hidden: true,
+                background: true,
+            });
+            target = { id: result.targetId };
+        }
+        else {
+            // No root session: try background + focus:false, fallback to CDP.New()
+            try {
+                const bgClient = await CDP({ host, port });
+                const result = await bgClient.Target.createTarget({
+                    url,
+                    background: true,
+                    focus: false,
+                });
+                target = { id: result.targetId };
+                await bgClient.close();
+            }
+            catch (_bgErr) {
+                target = await CDP.New({ host, port, url });
+            }
+        }
         try {
             const client = await CDP({ host, port, target: target.id });
             if (messages.opened) {

package/dist/src/browser/index.js

@@ -1023,8 +1023,8 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
     if (!remoteChromeConfig) {
         throw new Error("Remote Chrome configuration missing. Pass --remote-chrome <host:port> to use this mode.");
     }
-    const { host, port } = remoteChromeConfig;
-    logger(`Connecting to remote Chrome at ${host}:${port}`);
+    const { host, port, rootSession } = remoteChromeConfig;
+    logger(`Connecting to remote Chrome at ${host}:${port}${rootSession ? " (hidden targets)" : ""}`);
     let client = null;
     let remoteTargetId = null;
     let lastUrl;
@@ -1054,7 +1054,7 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
     let stopThinkingMonitor = null;
     let removeDialogHandler = null;
     try {
-        const connection = await connectToRemoteChrome(host, port, logger, config.url);
+        const connection = await connectToRemoteChrome(host, port, logger, config.url, rootSession);
         client = connection.client;
         remoteTargetId = connection.targetId ?? null;
         await emitRuntimeHint();
@@ -1069,8 +1069,19 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
         }
         await Promise.all(domainEnablers);
         removeDialogHandler = installJavaScriptDialogAutoDismissal(Page, logger);
-        // Skip cookie sync for remote Chrome - it already has cookies
-        logger("Skipping cookie sync for remote Chrome (using existing session)");
+        // Sync cookies into this tab for remote Chrome (needed for headed + Cloudflare).
+        try {
+            const cookieCount = await syncCookies(Network, config.url, config.chromeProfile, logger, {
+                allowErrors: true,
+                filterNames: config.cookieNames ?? undefined,
+                cookiePath: config.chromeCookiePath ?? undefined,
+                waitMs: config.cookieSyncWaitMs ?? 0,
+            });
+            logger(`Remote tab: synced ${cookieCount} cookies`);
+        }
+        catch (_syncErr) {
+            logger("Remote tab: cookie sync failed, continuing with existing session");
+        }
         await navigateToChatGPT(Page, Runtime, config.url, logger);
         await ensureNotBlocked(Runtime, config.headless, logger);
         await ensureLoggedIn(Runtime, logger, { remoteSession: true });

package/dist/src/remote/server.js

@@ -269,12 +269,15 @@ export async function serveRemote(options = {}) {
         console.log(`Detected ${cookies.length} ChatGPT cookies on this host; runs will reuse this session.`);
     }
     // Launch a shared Chrome instance for concurrent tab-based runs.
+    // Each run gets a hidden CDP target (no tab strip entry, no window, no focus stealing).
     let sharedChrome;
+    let sharedChromeProcess = null;
+    let sharedRootSession = null;
     if (!preferManualLogin) {
         try {
             const userDataDir = await mkdtemp(path.join(os.tmpdir(), "oracle-serve-chrome-"));
-            // Launch headed Chrome with --no-startup-window: no visible window, no focus stealing,
-            // but NOT headless (avoids Cloudflare fingerprinting). CDP creates tabs as needed.
+            // Launch headed Chrome with no initial window. Headed mode passes Cloudflare;
+            // hidden CDP targets prevent focus stealing on macOS.
             const { launch: launchChromeRaw } = await import("chrome-launcher");
             const chrome = await launchChromeRaw({
                 chromeFlags: [
@@ -295,16 +298,23 @@ export async function serveRemote(options = {}) {
                 userDataDir,
                 handleSIGINT: false,
             });
-            sharedChrome = { host: "127.0.0.1", port: chrome.port };
-            console.log(`Shared Chrome launched (pid ${chrome.pid}, port ${chrome.port}, no-startup-window). Concurrent runs will use isolated tabs.`);
-            // Sync ChatGPT cookies into the shared Chrome so all tabs are authenticated.
-            // With --no-startup-window, there are no targets. Create a temp tab to inject cookies.
+            sharedChromeProcess = chrome;
+            console.log(`Shared Chrome launched (pid ${chrome.pid}, port ${chrome.port}, headed + no-startup-window). Runs will use hidden CDP targets.`);
+            // Create a persistent root CDP session. Hidden target lifetimes are tied to
+            // the session that created them, so this must stay alive for the serve lifetime.
+            const CDP = (await import("chrome-remote-interface")).default;
+            const rootSession = await CDP({ host: "127.0.0.1", port: chrome.port });
+            sharedRootSession = rootSession;
+            // Sync ChatGPT cookies into the shared Chrome via a hidden target.
             try {
                 const { syncCookies } = await import("../browser/cookies.js");
-                const CDP = (await import("chrome-remote-interface")).default;
-                const tempTarget = await CDP.New({ host: "127.0.0.1", port: chrome.port, url: "about:blank" });
-                const client = await CDP({ host: "127.0.0.1", port: chrome.port, target: tempTarget.id });
-                const { Network } = client;
+                const { targetId } = await rootSession.Target.createTarget({
+                    url: "about:blank",
+                    hidden: true,
+                    background: true,
+                });
+                const syncClient = await CDP({ host: "127.0.0.1", port: chrome.port, target: targetId });
+                const { Network } = syncClient;
                 await Network.enable({});
                 const syncLogger = ((msg) => { if (msg)
                     console.log(`[shared-chrome] ${msg}`); });
@@ -313,13 +323,14 @@ export async function serveRemote(options = {}) {
                     allowErrors: true,
                 });
                 console.log(`Synced ${count} ChatGPT cookies into shared Chrome.`);
-                await client.close();
-                await CDP.Close({ host: "127.0.0.1", port: chrome.port, id: tempTarget.id });
+                await syncClient.close();
+                await rootSession.Target.closeTarget({ targetId });
             }
             catch (cookieErr) {
                 const msg = cookieErr instanceof Error ? cookieErr.message : String(cookieErr);
                 console.log(`Warning: failed to sync cookies into shared Chrome (${msg}). Runs may need to authenticate.`);
             }
+            sharedChrome = { host: "127.0.0.1", port: chrome.port, rootSession };
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
@@ -335,10 +346,27 @@ export async function serveRemote(options = {}) {
     await new Promise((resolve) => {
         const shutdown = () => {
             console.log("Shutting down remote service...");
-            server
-                .close()
-                .catch((error) => console.error("Failed to close remote server:", error))
-                .finally(() => resolve());
+            // Close root CDP session and kill shared Chrome before stopping the HTTP server.
+            const cleanupPromises = [];
+            if (sharedRootSession) {
+                cleanupPromises.push(sharedRootSession.close().catch((err) => {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    console.error(`Failed to close root CDP session: ${msg}`);
+                }));
+            }
+            if (sharedChromeProcess) {
+                cleanupPromises.push(Promise.resolve(sharedChromeProcess.kill()).catch((err) => {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    console.error(`Failed to kill shared Chrome: ${msg}`);
+                }));
+            }
+            Promise.all(cleanupPromises)
+                .finally(() => {
+                server
+                    .close()
+                    .catch((error) => console.error("Failed to close remote server:", error))
+                    .finally(() => resolve());
+            });
         };
         process.on("SIGINT", shutdown);
         process.on("SIGTERM", shutdown);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@andrewting19/oracle",
-  "version": "0.9.9",
+  "version": "0.10.0",
   "description": "CLI wrapper around OpenAI Responses API with GPT-5.4 Pro, GPT-5.4, GPT-5.2, GPT-5.1, and GPT-5.1 Codex high reasoning modes.",
   "keywords": [],
   "homepage": "https://github.com/steipete/oracle#readme",