@andrewting19/oracle 0.10.2 → 0.11.0

package/dist/bin/oracle-cli.js

@@ -470,8 +470,11 @@ function resolveHeartbeatIntervalMs(seconds) {
     return Math.round(seconds * 1000);
 }
 function assertFollowupSupported({ engine, model, baseUrl, azureEndpoint, }) {
+    // Browser engine: follow-up navigates to an existing ChatGPT conversation URL.
+    if (engine === "browser")
+        return;
     if (engine !== "api") {
-        throw new Error("--followup requires --engine api.");
+        throw new Error("--followup requires --engine api or --engine browser.");
     }
     if (model.startsWith("gemini") || model.startsWith("claude")) {
         throw new Error(`--followup is only supported for OpenAI Responses API runs. Model ${model} uses a provider client without previous_response_id support.`);
@@ -538,7 +541,7 @@ async function suggestFollowupSessionIds(input, limit = 3) {
         .slice(0, limit);
     return ranked.map((entry) => entry.id);
 }
-async function resolveFollowupReference(value, followupModel) {
+async function resolveFollowupReference(value, followupModel, engine) {
     const trimmed = value.trim();
     if (trimmed.length === 0) {
         throw new Error("--followup requires a session id or response id.");
@@ -555,6 +558,14 @@ async function resolveFollowupReference(value, followupModel) {
             : "";
         throw new Error(`No session found with ID ${trimmed}.${suggestionText} Run "oracle status --hours 72 --limit 20" to list recent sessions.`);
     }
+    // Browser follow-up: extract conversation URL from the parent session.
+    if (engine === "browser") {
+        const conversationUrl = meta.browser?.runtime?.tabUrl;
+        if (!conversationUrl || !conversationUrl.includes("/c/")) {
+            throw new Error(`Session "${trimmed}" has no ChatGPT conversation URL stored. Cannot follow up in browser mode.`);
+        }
+        return { sessionId: meta.id, conversationUrl };
+    }
     const fromMetadata = extractResponseIdFromSession(meta, followupModel);
     if (fromMetadata) {
         return { responseId: fromMetadata, sessionId: meta.id };
@@ -917,7 +928,7 @@ async function runRootCommand(options) {
             if (normalizedMultiModels.length > 0) {
                 throw new Error("--followup cannot be combined with --models.");
             }
-            const followup = await resolveFollowupReference(options.followup, options.followupModel);
+            const followup = await resolveFollowupReference(options.followup, options.followupModel, engine);
             resolvedOptions.previousResponseId = followup.responseId;
             resolvedOptions.followupSessionId = followup.sessionId;
             resolvedOptions.followupModel = options.followupModel;
@@ -964,6 +975,7 @@ async function runRootCommand(options) {
         options.prompt = `${options.prompt.trim()}\n${userConfig.promptSuffix}`;
     }
     resolvedOptions.prompt = options.prompt;
+    let browserFollowupConversationUrl;
     if (options.followup) {
         assertFollowupSupported({
             engine,
@@ -974,10 +986,11 @@ async function runRootCommand(options) {
         if (normalizedMultiModels.length > 0) {
             throw new Error("--followup cannot be combined with --models.");
         }
-        const followup = await resolveFollowupReference(options.followup, options.followupModel);
+        const followup = await resolveFollowupReference(options.followup, options.followupModel, engine);
         resolvedOptions.previousResponseId = followup.responseId;
         resolvedOptions.followupSessionId = followup.sessionId;
         resolvedOptions.followupModel = options.followupModel;
+        browserFollowupConversationUrl = followup.conversationUrl;
     }
     const duplicateBlocked = await shouldBlockDuplicatePrompt({
         prompt: resolvedOptions.prompt,
@@ -1018,6 +1031,13 @@ async function runRootCommand(options) {
             browserModelLabel: browserModelLabelOverride,
         })
         : undefined;
+    // For browser follow-ups, navigate to the existing conversation and skip model selection.
+    if (browserConfig && browserFollowupConversationUrl) {
+        browserConfig.url = browserFollowupConversationUrl;
+        browserConfig.chatgptUrl = browserFollowupConversationUrl;
+        browserConfig.modelStrategy = "ignore";
+        console.log(chalk.dim(`Following up on conversation: ${browserFollowupConversationUrl}`));
+    }
     let browserDeps;
     if (browserConfig && remoteHost) {
         browserDeps = {

package/dist/src/browser/chromeLifecycle.js

@@ -158,14 +158,24 @@ async function connectToNewTarget(host, port, url, logger, messages, rootSession
     try {
         let target;
         if (rootSession) {
-            // Hidden target: not in tab strip, no window, no focus steal.
+            // Try hidden target (no tab strip, no window), fall back to background+focus:false.
             // Lifetime tied to rootSession (kept alive by the serve).
-            const result = await rootSession.Target.createTarget({
-                url,
-                hidden: true,
-                background: true,
-            });
-            target = { id: result.targetId };
+            try {
+                const result = await rootSession.Target.createTarget({
+                    url,
+                    hidden: true,
+                    background: true,
+                });
+                target = { id: result.targetId };
+            }
+            catch {
+                const result = await rootSession.Target.createTarget({
+                    url,
+                    background: true,
+                    focus: false,
+                });
+                target = { id: result.targetId };
+            }
         }
         else {
             // No root session: try background + focus:false, fallback to CDP.New()

package/dist/src/browser/sessionRunner.js

@@ -124,6 +124,8 @@ export async function runBrowserSessionExecution({ runOptions, browserConfig, cw
             chromePort: browserResult.chromePort,
             chromeHost: browserResult.chromeHost,
             userDataDir: browserResult.userDataDir,
+            chromeTargetId: browserResult.chromeTargetId,
+            tabUrl: browserResult.tabUrl,
             controllerPid: browserResult.controllerPid ?? process.pid,
         },
         answerText,

package/dist/src/remote/server.js

@@ -12,6 +12,7 @@ import { CHATGPT_URL } from "../browser/constants.js";
 import { getCliVersion } from "../version.js";
 import { cleanupStaleProfileState, readDevToolsPort, verifyDevToolsReachable, writeChromePid, writeDevToolsActivePort, } from "../browser/profileState.js";
 import { normalizeChatgptUrl } from "../browser/utils.js";
+import { hideChromeWindow } from "../browser/chromeLifecycle.js";
 async function findAvailablePort() {
     return await new Promise((resolve, reject) => {
         const srv = net.createServer();
@@ -290,6 +291,7 @@ export async function serveRemote(options = {}) {
                     "--disable-hang-monitor",
                     "--disable-popup-blocking",
                     "--disable-features=TranslateUI,AutomationControlled",
+                    "--remote-allow-origins=*",
                     "--mute-audio",
                     "--window-size=1280,720",
                     "--password-store=basic",
@@ -313,15 +315,30 @@ export async function serveRemote(options = {}) {
             console.log(`Root CDP session connecting to ${browserWsUrl}`);
             const rootSession = await CDP({ target: browserWsUrl });
             sharedRootSession = rootSession;
-            // Sync ChatGPT cookies into the shared Chrome via a hidden target.
+            // Sync ChatGPT cookies into the shared Chrome via a background target.
+            // Try hidden first (no tab strip / no window), fall back to background+focus:false.
             try {
                 const { syncCookies } = await import("../browser/cookies.js");
-                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 });
+                let syncTargetId;
+                try {
+                    const result = await rootSession.Target.createTarget({
+                        url: "about:blank",
+                        hidden: true,
+                        background: true,
+                    });
+                    syncTargetId = result.targetId;
+                    console.log("Cookie sync: created hidden target.");
+                }
+                catch {
+                    const result = await rootSession.Target.createTarget({
+                        url: "about:blank",
+                        background: true,
+                        focus: false,
+                    });
+                    syncTargetId = result.targetId;
+                    console.log("Cookie sync: hidden targets unavailable, using background+focus:false.");
+                }
+                const syncClient = await CDP({ host: "127.0.0.1", port: chrome.port, target: syncTargetId });
                 const { Network } = syncClient;
                 await Network.enable({});
                 const syncLogger = ((msg) => { if (msg)
@@ -332,12 +349,20 @@ export async function serveRemote(options = {}) {
                 });
                 console.log(`Synced ${count} ChatGPT cookies into shared Chrome.`);
                 await syncClient.close();
-                await rootSession.Target.closeTarget({ targetId });
+                await rootSession.Target.closeTarget({ targetId: syncTargetId });
             }
             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.`);
             }
+            // Hide the serve Chrome from the macOS Dock (set visible = false).
+            // This is safe because we interact via CDP, not GUI.
+            try {
+                await hideChromeWindow(chrome, console.log);
+            }
+            catch {
+                // Non-fatal: hideChromeWindow logs its own errors.
+            }
             sharedChrome = { host: "127.0.0.1", port: chrome.port, rootSession };
         }
         catch (error) {
@@ -398,6 +423,7 @@ function sanitizeResult(result) {
         tookMs: result.tookMs,
         answerTokens: result.answerTokens,
         answerChars: result.answerChars,
+        tabUrl: result.tabUrl,
         chromePid: undefined,
         chromePort: undefined,
         userDataDir: undefined,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@andrewting19/oracle",
-  "version": "0.10.2",
+  "version": "0.11.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",