@andrewting19/oracle 0.9.1

package/dist/src/browser/providers/geminiDeepThinkDomProvider.js

@@ -0,0 +1,254 @@
+import { joinSelectors } from "../providerDomFlow.js";
+const UI_TIMEOUT_MS = 60_000;
+const RESPONSE_TIMEOUT_MS = 10 * 60_000;
+export const GEMINI_DEEP_THINK_SELECTORS = {
+    input: [
+        "rich-textarea .ql-editor",
+        '[role="textbox"][aria-label*="prompt" i]',
+        'div[contenteditable="true"]',
+    ],
+    sendButton: ["button.send-button", 'button[aria-label="Send message"]'],
+    toolsButton: ["button.toolbox-drawer-button", 'button[aria-label="Tools"]'],
+    toolsMenuItem: ['[role="menuitemcheckbox"]', ".toolbox-drawer-item-list-button"],
+    deepThinkActive: [
+        ".toolbox-drawer-item-deselect-button",
+        'button[aria-label*="Deselect Deep Think"]',
+    ],
+    uploadButton: ['button[aria-label="Open upload file menu"]', ".upload-card-button"],
+    uploadMenuItem: ['[role="menuitem"]'],
+    uploadTrigger: [".hidden-local-file-upload-button", ".hidden-local-upload-button"],
+    uploaderContainer: [".uploader-button-container", ".file-uploader"],
+    uploaderElement: ["uploader.upload-button"],
+    userTurnAttachment: [".file-preview-container"],
+    responseTurn: ["model-response"],
+    responseText: ["message-content", ".model-response-text message-content"],
+    responseComplete: [".response-footer.complete"],
+    userQuery: ["user-query"],
+    userQueryText: ["user-query-content", ".query-text"],
+    spinner: ['[role="progressbar"]'],
+    thoughtsToggle: [".thoughts-header-button", '[data-test-id="thoughts-header-button"]'],
+    thoughtsContent: ["model-thoughts", '[data-test-id="model-thoughts"]'],
+    hasThoughts: [".has-thoughts"],
+};
+function asSelectorLiteral(selectors) {
+    return JSON.stringify(joinSelectors(selectors));
+}
+function readTimeouts(ctx) {
+    const state = ctx.state;
+    const uiTimeoutMs = typeof state?.inputTimeoutMs === "number" && Number.isFinite(state.inputTimeoutMs)
+        ? Math.max(1_000, state.inputTimeoutMs)
+        : UI_TIMEOUT_MS;
+    const responseTimeoutMs = typeof state?.timeoutMs === "number" && Number.isFinite(state.timeoutMs)
+        ? Math.max(1_000, state.timeoutMs)
+        : RESPONSE_TIMEOUT_MS;
+    return { uiTimeoutMs, responseTimeoutMs };
+}
+async function waitForUi(ctx) {
+    ctx.log?.("[gemini-web] Waiting for Gemini UI to load...");
+    const inputSelector = asSelectorLiteral(GEMINI_DEEP_THINK_SELECTORS.input);
+    const { uiTimeoutMs } = readTimeouts(ctx);
+    const uiDeadline = Date.now() + uiTimeoutMs;
+    let uiReady = false;
+    let sawLoginRedirect = false;
+    while (Date.now() < uiDeadline) {
+        const state = await ctx.evaluate(`(() => {
+        const editor = document.querySelector(${inputSelector});
+        const href = location.href || '';
+        const bodyText = (document.body?.innerText || '').toLowerCase();
+        const requiresLogin =
+          href.includes('accounts.google.com') ||
+          (bodyText.includes('sign in') && bodyText.includes('google'));
+        return { ready: Boolean(editor), requiresLogin };
+      })()`);
+        if (state?.ready) {
+            uiReady = true;
+            break;
+        }
+        if (state?.requiresLogin) {
+            sawLoginRedirect = true;
+        }
+        await ctx.delay(1_000);
+    }
+    if (!uiReady) {
+        if (sawLoginRedirect) {
+            throw new Error("Gemini is showing a sign-in flow. Please sign in in Chrome and retry.");
+        }
+        throw new Error("Timed out waiting for Gemini UI prompt input to become ready.");
+    }
+}
+async function selectMode(ctx) {
+    const toolsButtonSelectors = asSelectorLiteral(GEMINI_DEEP_THINK_SELECTORS.toolsButton);
+    const toolsClickResult = await ctx.evaluate(`(() => {
+      const btn = document.querySelector(${toolsButtonSelectors});
+      if (btn instanceof HTMLElement) {
+        btn.click();
+        return 'clicked';
+      }
+      return 'not-found';
+    })()`);
+    if (toolsClickResult !== "clicked") {
+        throw new Error("Unable to open Gemini tools menu; Deep Think toggle is not accessible.");
+    }
+    await ctx.delay(1_000);
+    const deepThinkItemSelectors = asSelectorLiteral(GEMINI_DEEP_THINK_SELECTORS.toolsMenuItem);
+    const deepThinkClickResult = await ctx.evaluate(`(() => {
+      const items = Array.from(document.querySelectorAll(${deepThinkItemSelectors}));
+      for (const item of items) {
+        const text = item.textContent?.trim().toLowerCase() ?? '';
+        if (!text.includes('deep think')) continue;
+        if (item instanceof HTMLElement) item.click();
+        return 'clicked';
+      }
+      return 'not-found';
+    })()`);
+    if (deepThinkClickResult !== "clicked") {
+        throw new Error('Unable to select "Deep Think" from Gemini tools menu.');
+    }
+    await ctx.delay(1_500);
+    const deepThinkActiveSelectors = asSelectorLiteral(GEMINI_DEEP_THINK_SELECTORS.deepThinkActive);
+    const deepThinkActive = await ctx.evaluate(`(() => {
+      const active = document.querySelector(${deepThinkActiveSelectors});
+      if (!(active instanceof HTMLElement)) return false;
+      const label = active.getAttribute('aria-label')?.toLowerCase() ?? '';
+      const text = active.textContent?.toLowerCase() ?? '';
+      return label.includes('deep think') || text.includes('deep think');
+    })()`);
+    if (!deepThinkActive) {
+        throw new Error("Deep Think did not appear selected after clicking the tools menu item.");
+    }
+}
+async function typePrompt(ctx) {
+    ctx.log?.("[gemini-web] Typing prompt...");
+    const inputSelector = asSelectorLiteral(GEMINI_DEEP_THINK_SELECTORS.input);
+    const typeResult = await ctx.evaluate(`(() => {
+      const editor = document.querySelector(${inputSelector});
+      if (!(editor instanceof HTMLElement)) return 'no-editor';
+      editor.focus();
+      editor.textContent = '';
+      if (typeof document.execCommand === 'function') {
+        document.execCommand('insertText', false, ${JSON.stringify(ctx.prompt)});
+      } else {
+        editor.textContent = ${JSON.stringify(ctx.prompt)};
+        editor.dispatchEvent(new InputEvent('input', { bubbles: true, data: ${JSON.stringify(ctx.prompt)} }));
+      }
+      const typed = (editor.textContent || '').trim().length > 0;
+      return typed ? 'typed' : 'empty';
+    })()`);
+    if (typeResult !== "typed") {
+        throw new Error(`Failed to type Gemini prompt (status=${typeResult ?? "unknown"}).`);
+    }
+    await ctx.delay(500);
+}
+async function submitPrompt(ctx) {
+    ctx.log?.("[gemini-web] Sending prompt...");
+    const inputSelector = asSelectorLiteral(GEMINI_DEEP_THINK_SELECTORS.input);
+    const sendButtonSelectors = asSelectorLiteral(GEMINI_DEEP_THINK_SELECTORS.sendButton);
+    const sendResult = await ctx.evaluate(`(() => {
+      const btn = document.querySelector(${sendButtonSelectors});
+      if (btn instanceof HTMLElement) {
+        btn.click();
+        return 'clicked';
+      }
+      const editor = document.querySelector(${inputSelector});
+      if (editor instanceof HTMLElement) {
+        editor.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', code: 'Enter', bubbles: true }));
+        editor.dispatchEvent(new KeyboardEvent('keyup', { key: 'Enter', code: 'Enter', bubbles: true }));
+        return 'enter';
+      }
+      return 'not-found';
+    })()`);
+    if (sendResult !== "clicked" && sendResult !== "enter") {
+        throw new Error("Failed to submit prompt in Gemini Deep Think mode (send control not found).");
+    }
+}
+async function waitForResponse(ctx) {
+    ctx.log?.("[gemini-web] Waiting for Deep Think response (this may take a while)...");
+    const responseTurnSel = asSelectorLiteral(GEMINI_DEEP_THINK_SELECTORS.responseTurn);
+    const responseTextSel = asSelectorLiteral(GEMINI_DEEP_THINK_SELECTORS.responseText);
+    const responseCompleteSel = asSelectorLiteral(GEMINI_DEEP_THINK_SELECTORS.responseComplete);
+    const spinnerSel = asSelectorLiteral(GEMINI_DEEP_THINK_SELECTORS.spinner);
+    const { responseTimeoutMs } = readTimeouts(ctx);
+    const responseDeadline = Date.now() + responseTimeoutMs;
+    let lastLog = 0;
+    let responseText = "";
+    while (Date.now() < responseDeadline) {
+        const payload = await ctx.evaluate(`(() => {
+        const turns = document.querySelectorAll(${responseTurnSel});
+        if (turns.length === 0) return JSON.stringify({ status: 'waiting' });
+        const lastTurn = turns[turns.length - 1];
+        const footer = lastTurn.querySelector(${responseCompleteSel});
+        const content = lastTurn.querySelector(${responseTextSel});
+        const text = content?.textContent?.trim() ?? '';
+        const lower = text.toLowerCase();
+        if (lower.includes('generating your response') || lower.includes('check back later') || lower.includes("i'm on it")) {
+          return JSON.stringify({ status: 'generating' });
+        }
+        if (footer && text.length > 0) {
+          return JSON.stringify({ status: 'done', text });
+        }
+        const spinners = lastTurn.querySelectorAll(${spinnerSel});
+        const visibleSpinners = Array.from(spinners).filter((s) => s instanceof HTMLElement && s.offsetParent !== null);
+        if (text.length > 0 && visibleSpinners.length === 0 && !footer) {
+          return JSON.stringify({ status: 'streaming' });
+        }
+        return JSON.stringify({ status: 'generating' });
+      })()`);
+        try {
+            const parsed = JSON.parse(payload ?? "{}");
+            if (parsed.status === "done" && typeof parsed.text === "string" && parsed.text.length > 0) {
+                responseText = parsed.text;
+                break;
+            }
+            const now = Date.now();
+            if (now - lastLog > 10_000) {
+                ctx.log?.(`[gemini-web] Deep Think still generating... (${parsed.status ?? "unknown"})`);
+                lastLog = now;
+            }
+        }
+        catch {
+            // ignore parse errors while polling
+        }
+        await ctx.delay(3_000);
+    }
+    if (!responseText) {
+        throw new Error(`Deep Think timed out waiting for response (${Math.ceil(responseTimeoutMs / 1000)} seconds).`);
+    }
+    return { text: responseText };
+}
+async function extractThoughts(ctx) {
+    const thoughtsToggleSel = asSelectorLiteral(GEMINI_DEEP_THINK_SELECTORS.thoughtsToggle);
+    const thoughtsContentSel = asSelectorLiteral(GEMINI_DEEP_THINK_SELECTORS.thoughtsContent);
+    const thinkResult = await ctx.evaluate(`(() => {
+      const toggle = document.querySelector(${thoughtsToggleSel});
+      if (!(toggle instanceof HTMLElement)) return 'no-toggle';
+      toggle.click();
+      return 'clicked';
+    })()`);
+    if (thinkResult !== "clicked") {
+        return null;
+    }
+    await ctx.delay(1_500);
+    const extractedThoughts = await ctx.evaluate(`(() => {
+      const el = document.querySelector(${thoughtsContentSel});
+      if (!el) return '';
+      const full = el.textContent?.trim() ?? '';
+      const btn = el.querySelector('.thoughts-header-button, [data-test-id="thoughts-header-button"]');
+      const btnText = btn?.textContent?.trim() ?? '';
+      if (btnText && full.startsWith(btnText)) {
+        return full.slice(btnText.length).trim();
+      }
+      return full;
+    })()`);
+    return typeof extractedThoughts === "string" && extractedThoughts.length > 0
+        ? extractedThoughts
+        : null;
+}
+export const geminiDeepThinkDomProvider = {
+    providerName: "gemini-web",
+    waitForUi,
+    selectMode,
+    typePrompt,
+    submitPrompt,
+    waitForResponse,
+    extractThoughts,
+};

package/dist/src/browser/providers/index.js

@@ -0,0 +1,2 @@
+export { chatgptDomProvider } from "./chatgptDomProvider.js";
+export { geminiDeepThinkDomProvider, GEMINI_DEEP_THINK_SELECTORS, } from "./geminiDeepThinkDomProvider.js";

package/dist/src/browser/reattach.js

@@ -0,0 +1,189 @@
+import CDP from "chrome-remote-interface";
+import os from "node:os";
+import path from "node:path";
+import { mkdtemp, mkdir, rm } from "node:fs/promises";
+import { waitForAssistantResponse, captureAssistantMarkdown, navigateToChatGPT, ensureNotBlocked, ensureLoggedIn, ensurePromptReady, } from "./pageActions.js";
+import { launchChrome, connectToChrome, hideChromeWindow } from "./chromeLifecycle.js";
+import { resolveBrowserConfig } from "./config.js";
+import { syncCookies } from "./cookies.js";
+import { CHATGPT_URL } from "./constants.js";
+import { cleanupStaleProfileState } from "./profileState.js";
+import { pickTarget, extractConversationIdFromUrl, buildConversationUrl, withTimeout, openConversationFromSidebar, openConversationFromSidebarWithRetry, waitForLocationChange, readConversationTurnIndex, buildPromptEchoMatcher, recoverPromptEcho, alignPromptEchoMarkdown, } from "./reattachHelpers.js";
+export async function resumeBrowserSession(runtime, config, logger, deps = {}) {
+    const recoverSession = deps.recoverSession ??
+        (async (runtimeMeta, configMeta) => resumeBrowserSessionViaNewChrome(runtimeMeta, configMeta, logger, deps));
+    if (!runtime.chromePort) {
+        logger("No running Chrome detected; reopening browser to locate the session.");
+        return recoverSession(runtime, config);
+    }
+    const host = runtime.chromeHost ?? "127.0.0.1";
+    try {
+        const listTargets = deps.listTargets ??
+            (async () => {
+                const targets = await CDP.List({ host, port: runtime.chromePort });
+                return targets;
+            });
+        const connect = deps.connect ?? ((options) => CDP(options));
+        const targetList = (await listTargets());
+        const target = pickTarget(targetList, runtime);
+        const client = (await connect({
+            host,
+            port: runtime.chromePort,
+            target: target?.targetId,
+        }));
+        const { Runtime, DOM } = client;
+        if (Runtime?.enable) {
+            await Runtime.enable();
+        }
+        if (DOM && typeof DOM.enable === "function") {
+            await DOM.enable();
+        }
+        const ensureConversationOpen = async () => {
+            const { result } = await Runtime.evaluate({
+                expression: "location.href",
+                returnByValue: true,
+            });
+            const href = typeof result?.value === "string" ? result.value : "";
+            if (href.includes("/c/")) {
+                const currentId = extractConversationIdFromUrl(href);
+                if (!runtime.conversationId || (currentId && currentId === runtime.conversationId)) {
+                    return;
+                }
+            }
+            const opened = await openConversationFromSidebarWithRetry(Runtime, {
+                conversationId: runtime.conversationId ?? extractConversationIdFromUrl(runtime.tabUrl ?? ""),
+                preferProjects: true,
+                promptPreview: deps.promptPreview,
+            }, 15_000);
+            if (!opened) {
+                throw new Error("Unable to locate prior ChatGPT conversation in sidebar.");
+            }
+            await waitForLocationChange(Runtime, 15_000);
+        };
+        const waitForResponse = deps.waitForAssistantResponse ?? waitForAssistantResponse;
+        const captureMarkdown = deps.captureAssistantMarkdown ?? captureAssistantMarkdown;
+        const timeoutMs = config?.timeoutMs ?? 120_000;
+        const pingTimeoutMs = Math.min(5_000, Math.max(1_500, Math.floor(timeoutMs * 0.05)));
+        await withTimeout(Runtime.evaluate({ expression: "1+1", returnByValue: true }), pingTimeoutMs, "Reattach target did not respond");
+        await ensureConversationOpen();
+        const minTurnIndex = await readConversationTurnIndex(Runtime, logger);
+        const promptEcho = buildPromptEchoMatcher(deps.promptPreview);
+        const answer = await withTimeout(waitForResponse(Runtime, timeoutMs, logger, minTurnIndex ?? undefined), timeoutMs + 5_000, "Reattach response timed out");
+        const recovered = await recoverPromptEcho(Runtime, answer, promptEcho, logger, minTurnIndex, timeoutMs);
+        const markdown = (await withTimeout(captureMarkdown(Runtime, recovered.meta, logger), 15_000, "Reattach markdown capture timed out")) ?? recovered.text;
+        const aligned = alignPromptEchoMarkdown(recovered.text, markdown, promptEcho, logger);
+        if (client && typeof client.close === "function") {
+            try {
+                await client.close();
+            }
+            catch {
+                // ignore
+            }
+        }
+        return { answerText: aligned.answerText, answerMarkdown: aligned.answerMarkdown };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger(`Existing Chrome reattach failed (${message}); reopening browser to locate the session.`);
+        return recoverSession(runtime, config);
+    }
+}
+async function resumeBrowserSessionViaNewChrome(runtime, config, logger, deps) {
+    const resolved = resolveBrowserConfig(config ?? {});
+    const manualLogin = Boolean(resolved.manualLogin);
+    const userDataDir = manualLogin
+        ? (resolved.manualLoginProfileDir ?? path.join(os.homedir(), ".oracle", "browser-profile"))
+        : await mkdtemp(path.join(os.tmpdir(), "oracle-reattach-"));
+    if (manualLogin) {
+        await mkdir(userDataDir, { recursive: true });
+    }
+    const chrome = await launchChrome(resolved, userDataDir, logger);
+    const chromeHost = chrome.host ?? "127.0.0.1";
+    const client = await connectToChrome(chrome.port, logger, chromeHost);
+    const { Network, Page, Runtime, DOM } = client;
+    if (Runtime?.enable) {
+        await Runtime.enable();
+    }
+    if (DOM && typeof DOM.enable === "function") {
+        await DOM.enable();
+    }
+    if (!resolved.headless && resolved.hideWindow) {
+        await hideChromeWindow(chrome, logger);
+    }
+    let appliedCookies = 0;
+    if (!manualLogin && resolved.cookieSync) {
+        appliedCookies = await syncCookies(Network, resolved.url, resolved.chromeProfile, logger, {
+            allowErrors: resolved.allowCookieErrors,
+            filterNames: resolved.cookieNames ?? undefined,
+            inlineCookies: resolved.inlineCookies ?? undefined,
+            cookiePath: resolved.chromeCookiePath ?? undefined,
+            waitMs: resolved.cookieSyncWaitMs ?? 0,
+        });
+    }
+    await navigateToChatGPT(Page, Runtime, CHATGPT_URL, logger);
+    await ensureNotBlocked(Runtime, resolved.headless, logger);
+    await ensureLoggedIn(Runtime, logger, { appliedCookies });
+    if (resolved.url !== CHATGPT_URL) {
+        await navigateToChatGPT(Page, Runtime, resolved.url, logger);
+        await ensureNotBlocked(Runtime, resolved.headless, logger);
+    }
+    await ensurePromptReady(Runtime, resolved.inputTimeoutMs, logger);
+    const conversationUrl = buildConversationUrl(runtime, resolved.url);
+    if (conversationUrl) {
+        logger(`Reopening conversation at ${conversationUrl}`);
+        await navigateToChatGPT(Page, Runtime, conversationUrl, logger);
+        await ensureNotBlocked(Runtime, resolved.headless, logger);
+        await ensurePromptReady(Runtime, resolved.inputTimeoutMs, logger);
+    }
+    else {
+        const opened = await openConversationFromSidebarWithRetry(Runtime, {
+            conversationId: runtime.conversationId ?? extractConversationIdFromUrl(runtime.tabUrl ?? ""),
+            preferProjects: resolved.url !== CHATGPT_URL ||
+                Boolean(runtime.tabUrl && (/\/g\//.test(runtime.tabUrl) || runtime.tabUrl.includes("/project"))),
+            promptPreview: deps.promptPreview,
+        }, 15_000);
+        if (!opened) {
+            throw new Error("Unable to locate prior ChatGPT conversation in sidebar.");
+        }
+        await waitForLocationChange(Runtime, 15_000);
+    }
+    const waitForResponse = deps.waitForAssistantResponse ?? waitForAssistantResponse;
+    const captureMarkdown = deps.captureAssistantMarkdown ?? captureAssistantMarkdown;
+    const timeoutMs = resolved.timeoutMs ?? 120_000;
+    const minTurnIndex = await readConversationTurnIndex(Runtime, logger);
+    const promptEcho = buildPromptEchoMatcher(deps.promptPreview);
+    const answer = await waitForResponse(Runtime, timeoutMs, logger, minTurnIndex ?? undefined);
+    const recovered = await recoverPromptEcho(Runtime, answer, promptEcho, logger, minTurnIndex, timeoutMs);
+    const markdown = (await captureMarkdown(Runtime, recovered.meta, logger)) ?? recovered.text;
+    const aligned = alignPromptEchoMarkdown(recovered.text, markdown, promptEcho, logger);
+    if (client && typeof client.close === "function") {
+        try {
+            await client.close();
+        }
+        catch {
+            // ignore
+        }
+    }
+    if (!resolved.keepBrowser) {
+        try {
+            await chrome.kill();
+        }
+        catch {
+            // ignore
+        }
+        if (manualLogin) {
+            await cleanupStaleProfileState(userDataDir, logger, { lockRemovalMode: "never" }).catch(() => undefined);
+        }
+        else {
+            await rm(userDataDir, { recursive: true, force: true }).catch(() => undefined);
+        }
+    }
+    return { answerText: aligned.answerText, answerMarkdown: aligned.answerMarkdown };
+}
+// biome-ignore lint/style/useNamingConvention: test-only export used in vitest suite
+export const __test__ = {
+    pickTarget,
+    extractConversationIdFromUrl,
+    buildConversationUrl,
+    openConversationFromSidebar,
+};