@steipete/oracle 0.7.6 → 0.8.0

package/dist/src/cli/browserDefaults.js

@@ -42,4 +42,7 @@ export function applyBrowserDefaultsFromConfig(options, config, getSource) {
     if (isUnset('browserKeepBrowser') && browser.keepBrowser !== undefined) {
         options.browserKeepBrowser = browser.keepBrowser;
     }
+    if (isUnset('browserModelStrategy') && browser.modelStrategy !== undefined) {
+        options.browserModelStrategy = browser.modelStrategy;
+    }
 }

package/dist/src/cli/sessionDisplay.js

@@ -61,6 +61,13 @@ export async function attachSession(sessionId, options) {
         process.exitCode = 1;
         return;
     }
+    if (metadata.mode === 'browser' && metadata.status === 'running' && !metadata.browser?.runtime) {
+        await wait(250);
+        const refreshed = await sessionStore.readSession(sessionId);
+        if (refreshed) {
+            metadata = refreshed;
+        }
+    }
     const normalizedModelFilter = options?.model?.trim().toLowerCase();
     if (normalizedModelFilter) {
         const availableModels = metadata.models?.map((model) => model.model.toLowerCase()) ??

package/dist/src/gemini-web/executor.js

@@ -1,5 +1,27 @@
 import path from 'node:path';
+import { getCookies } from '@steipete/sweet-cookie';
 import { runGeminiWebWithFallback, saveFirstGeminiImageFromOutput } from './client.js';
+const GEMINI_COOKIE_NAMES = [
+    '__Secure-1PSID',
+    '__Secure-1PSIDTS',
+    '__Secure-1PSIDCC',
+    '__Secure-1PAPISID',
+    'NID',
+    'AEC',
+    'SOCS',
+    '__Secure-BUCKET',
+    '__Secure-ENID',
+    'SID',
+    'HSID',
+    'SSID',
+    'APISID',
+    'SAPISID',
+    '__Secure-3PSID',
+    '__Secure-3PSIDTS',
+    '__Secure-3PAPISID',
+    'SIDCC',
+];
+const GEMINI_REQUIRED_COOKIES = ['__Secure-1PSID', '__Secure-1PSIDTS'];
 function estimateTokenCount(text) {
     return Math.ceil(text.length / 4);
 }
@@ -30,59 +52,84 @@ function resolveGeminiWebModel(desiredModel, log) {
             return 'gemini-3-pro';
     }
 }
+function resolveCookieDomain(cookie) {
+    const rawDomain = cookie.domain?.trim();
+    if (rawDomain) {
+        return rawDomain.startsWith('.') ? rawDomain.slice(1) : rawDomain;
+    }
+    const rawUrl = cookie.url?.trim();
+    if (rawUrl) {
+        try {
+            return new URL(rawUrl).hostname;
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}
+function pickCookieValue(cookies, name) {
+    const matches = cookies.filter((cookie) => cookie.name === name && typeof cookie.value === 'string');
+    if (matches.length === 0)
+        return undefined;
+    const preferredDomain = matches.find((cookie) => {
+        const domain = resolveCookieDomain(cookie);
+        return domain === 'google.com' && (cookie.path ?? '/') === '/';
+    });
+    const googleDomain = matches.find((cookie) => (resolveCookieDomain(cookie) ?? '').endsWith('google.com'));
+    return (preferredDomain ?? googleDomain ?? matches[0])?.value;
+}
+function buildGeminiCookieMap(cookies) {
+    const cookieMap = {};
+    for (const name of GEMINI_COOKIE_NAMES) {
+        const value = pickCookieValue(cookies, name);
+        if (value)
+            cookieMap[name] = value;
+    }
+    return cookieMap;
+}
+function hasRequiredGeminiCookies(cookieMap) {
+    return GEMINI_REQUIRED_COOKIES.every((name) => Boolean(cookieMap[name]));
+}
+async function loadGeminiCookiesFromInline(browserConfig, log) {
+    const inline = browserConfig?.inlineCookies;
+    if (!inline || inline.length === 0)
+        return {};
+    const cookieMap = buildGeminiCookieMap(inline.filter((cookie) => Boolean(cookie?.name && typeof cookie.value === 'string')));
+    if (Object.keys(cookieMap).length > 0) {
+        const source = browserConfig?.inlineCookiesSource ?? 'inline';
+        log?.(`[gemini-web] Loaded Gemini cookies from inline payload (${source}): ${Object.keys(cookieMap).length} cookie(s).`);
+    }
+    else {
+        log?.('[gemini-web] Inline cookie payload provided but no Gemini cookies matched.');
+    }
+    return cookieMap;
+}
 async function loadGeminiCookiesFromChrome(browserConfig, log) {
     try {
-        const mod = (await import('chrome-cookies-secure'));
-        const chromeCookies = mod.default ??
-            mod;
-        const profile = typeof browserConfig?.chromeProfile === 'string' &&
-            browserConfig.chromeProfile.trim().length > 0
-            ? browserConfig.chromeProfile.trim()
+        // Learned: Gemini web relies on Google auth cookies in the *browser* profile, not API keys.
+        const profileCandidate = browserConfig?.chromeCookiePath ?? browserConfig?.chromeProfile ?? undefined;
+        const profile = typeof profileCandidate === 'string' && profileCandidate.trim().length > 0
+            ? profileCandidate.trim()
             : undefined;
         const sources = [
             'https://gemini.google.com',
             'https://accounts.google.com',
             'https://www.google.com',
         ];
-        const wantNames = [
-            '__Secure-1PSID',
-            '__Secure-1PSIDTS',
-            '__Secure-1PSIDCC',
-            '__Secure-1PAPISID',
-            'NID',
-            'AEC',
-            'SOCS',
-            '__Secure-BUCKET',
-            '__Secure-ENID',
-            'SID',
-            'HSID',
-            'SSID',
-            'APISID',
-            'SAPISID',
-            '__Secure-3PSID',
-            '__Secure-3PSIDTS',
-            '__Secure-3PAPISID',
-            'SIDCC',
-        ];
-        const cookieMap = {};
-        for (const url of sources) {
-            const cookies = (await chromeCookies.getCookiesPromised(url, 'puppeteer', profile));
-            for (const name of wantNames) {
-                if (cookieMap[name])
-                    continue;
-                const matches = cookies.filter((cookie) => cookie.name === name);
-                if (matches.length === 0)
-                    continue;
-                const preferredDomain = matches.find((cookie) => cookie.domain === '.google.com' && (cookie.path ?? '/') === '/');
-                const googleDomain = matches.find((cookie) => (cookie.domain ?? '').endsWith('google.com'));
-                const value = (preferredDomain ?? googleDomain ?? matches[0])?.value;
-                if (value)
-                    cookieMap[name] = value;
-            }
-        }
-        if (!cookieMap['__Secure-1PSID'] || !cookieMap['__Secure-1PSIDTS']) {
-            return {};
+        const { cookies, warnings } = await getCookies({
+            url: sources[0],
+            origins: sources,
+            names: [...GEMINI_COOKIE_NAMES],
+            browsers: ['chrome'],
+            mode: 'merge',
+            chromeProfile: profile,
+            timeoutMs: 5_000,
+        });
+        if (warnings.length && log?.verbose) {
+            log(`[gemini-web] Cookie warnings:\n- ${warnings.join('\n- ')}`);
         }
+        const cookieMap = buildGeminiCookieMap(cookies);
         log?.(`[gemini-web] Loaded Gemini cookies from Chrome (node): ${Object.keys(cookieMap).length} cookie(s).`);
         return cookieMap;
     }
@@ -91,13 +138,27 @@ async function loadGeminiCookiesFromChrome(browserConfig, log) {
         return {};
     }
 }
+async function loadGeminiCookies(browserConfig, log) {
+    const inlineMap = await loadGeminiCookiesFromInline(browserConfig, log);
+    const hasInlineRequired = hasRequiredGeminiCookies(inlineMap);
+    if (hasInlineRequired && browserConfig?.cookieSync === false) {
+        return inlineMap;
+    }
+    if (browserConfig?.cookieSync === false && !hasInlineRequired) {
+        log?.('[gemini-web] Cookie sync disabled and inline cookies missing Gemini auth tokens.');
+        return inlineMap;
+    }
+    const chromeMap = await loadGeminiCookiesFromChrome(browserConfig, log);
+    const merged = { ...chromeMap, ...inlineMap };
+    return merged;
+}
 export function createGeminiWebExecutor(geminiOptions) {
     return async (runOptions) => {
         const startTime = Date.now();
         const log = runOptions.log;
         log?.('[gemini-web] Starting Gemini web executor (TypeScript)');
-        const cookieMap = await loadGeminiCookiesFromChrome(runOptions.config, log);
-        if (!cookieMap['__Secure-1PSID'] || !cookieMap['__Secure-1PSIDTS']) {
+        const cookieMap = await loadGeminiCookies(runOptions.config, log);
+        if (!hasRequiredGeminiCookies(cookieMap)) {
             throw new Error('Gemini browser mode requires Chrome cookies for google.com (missing __Secure-1PSID/__Secure-1PSIDTS).');
         }
         const configTimeout = typeof runOptions.config?.timeoutMs === 'number' && Number.isFinite(runOptions.config.timeoutMs)

package/dist/src/oracle/run.js

@@ -20,7 +20,7 @@ import { createFsAdapter } from './fsAdapter.js';
 import { resolveGeminiModelId } from './gemini.js';
 import { resolveClaudeModelId } from './claude.js';
 import { renderMarkdownAnsi } from '../cli/markdownRenderer.js';
-import { createLiveRenderer } from 'markdansi';
+import { createMarkdownStreamer } from 'markdansi';
 import { executeBackgroundResponse } from './background.js';
 import { formatTokenEstimate, formatTokenValue, resolvePreviewMode } from './runUtils.js';
 import { estimateUsdCost } from 'tokentally';
@@ -312,8 +312,6 @@ export async function runOracle(options, deps = {}) {
     let response = null;
     let elapsedMs = 0;
     let sawTextDelta = false;
-    let streamedText = '';
-    let lastLiveFrameAtMs = 0;
     let answerHeaderPrinted = false;
     const allowAnswerHeader = options.suppressAnswerHeader !== true;
     const timeoutExceeded = () => now() - runStart >= timeoutMs;
@@ -381,14 +379,23 @@ export async function runOracle(options, deps = {}) {
                     },
                 });
             }
-            let liveRenderer = null;
+            let markdownStreamer = null;
+            const flushMarkdownStreamer = () => {
+                if (!markdownStreamer)
+                    return;
+                const rendered = markdownStreamer.finish();
+                markdownStreamer = null;
+                if (rendered) {
+                    stdoutWrite(rendered);
+                }
+            };
             try {
-                liveRenderer =
+                markdownStreamer =
                     isTty && !renderPlain
-                        ? createLiveRenderer({
-                            write: stdoutWrite,
-                            width: process.stdout.columns ?? 80,
-                            renderFrame: renderMarkdownAnsi,
+                        ? createMarkdownStreamer({
+                            render: renderMarkdownAnsi,
+                            spacing: 'single',
+                            mode: 'hybrid',
                         })
                         : null;
                 for await (const event of stream) {
@@ -409,38 +416,27 @@ export async function runOracle(options, deps = {}) {
                         stdoutWrite(event.delta);
                         continue;
                     }
-                    if (liveRenderer) {
-                        streamedText += event.delta;
-                        const currentMs = now();
-                        const due = currentMs - lastLiveFrameAtMs >= 120;
-                        const hasNewline = event.delta.includes('\n');
-                        if (hasNewline || due) {
-                            liveRenderer.render(streamedText);
-                            lastLiveFrameAtMs = currentMs;
+                    if (markdownStreamer) {
+                        const rendered = markdownStreamer.push(event.delta);
+                        if (rendered) {
+                            stdoutWrite(rendered);
                         }
                         continue;
                     }
                     // Non-TTY streams should still surface output; fall back to raw stdout.
                     stdoutWrite(event.delta);
                 }
-                if (liveRenderer) {
-                    streamedText = streamedText.trim();
-                    if (streamedText.length > 0) {
-                        liveRenderer.render(streamedText);
-                    }
-                }
+                flushMarkdownStreamer();
                 throwIfTimedOut();
             }
             catch (streamError) {
                 // stream.abort() is not available on the interface
+                flushMarkdownStreamer();
                 stopHeartbeatNow();
                 const transportError = toTransportError(streamError, requestBody.model);
                 log(chalk.yellow(describeTransportError(transportError, timeoutMs)));
                 throw transportError;
             }
-            finally {
-                liveRenderer?.finish();
-            }
             response = await stream.finalResponse();
             throwIfTimedOut();
             stopHeartbeatNow();
@@ -455,17 +451,12 @@ export async function runOracle(options, deps = {}) {
     }
     // We only add spacing when streamed text was printed.
     if (sawTextDelta && !options.silent) {
-        const shouldRenderAfterStream = isTty && !renderPlain && streamedText.length > 0;
         if (renderPlain) {
             // Plain streaming already wrote chunks; ensure clean separation.
             stdoutWrite('\n');
         }
-        else if (!shouldRenderAfterStream) {
-            // Non-TTY streams should still surface output; ensure separation.
-            log('');
-        }
         else {
-            // Live-rendered mode already drew the final frame; only separate from logs.
+            // Separate streamed output from logs.
             log('');
         }
     }

package/dist/src/remote/server.js

@@ -7,7 +7,7 @@ import { spawn, spawnSync } from 'node:child_process';
 import { mkdtemp, rm, mkdir, writeFile } from 'node:fs/promises';
 import chalk from 'chalk';
 import { runBrowserMode } from '../browserMode.js';
-import { loadChromeCookies } from '../browser/chromeCookies.js';
+import { getCookies } from '@steipete/sweet-cookie';
 import { CHATGPT_URL } from '../browser/constants.js';
 import { cleanupStaleProfileState, readDevToolsPort, verifyDevToolsReachable, writeChromePid, writeDevToolsActivePort, } from '../browser/profileState.js';
 import { normalizeChatgptUrl } from '../browser/utils.js';
@@ -331,13 +331,17 @@ function formatReachableAddresses(bindAddress, port) {
 async function loadLocalChatgptCookies(logger, targetUrl) {
     try {
         logger('Loading ChatGPT cookies from this host\'s Chrome profile...');
-        const cookies = await Promise.resolve(loadChromeCookies({
-            targetUrl,
-            profile: 'Default',
-        })).catch((error) => {
-            logger(`Unable to load local ChatGPT cookies on this host: ${error instanceof Error ? error.message : String(error)}`);
-            return [];
+        const { cookies: rawCookies, warnings } = await getCookies({
+            url: targetUrl,
+            browsers: ['chrome'],
+            mode: 'merge',
+            chromeProfile: 'Default',
+            timeoutMs: 5_000,
         });
+        if (warnings.length) {
+            logger(`Cookie warnings:\n- ${warnings.join('\n- ')}`);
+        }
+        const cookies = rawCookies.map(toCdpCookie).filter((c) => Boolean(c));
         if (!cookies || cookies.length === 0) {
             logger('No local ChatGPT cookies found on this host. Please log in once; opening ChatGPT...');
             const opened = triggerLocalLoginPrompt(logger, targetUrl);
@@ -348,14 +352,7 @@ async function loadLocalChatgptCookies(logger, targetUrl) {
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        const missingDbMatch = message.match(/Unable to locate Chrome cookie DB at (.+)/);
-        if (missingDbMatch) {
-            const lookedPath = missingDbMatch[1];
-            logger(`Chrome cookies not found at ${lookedPath}. Set --browser-cookie-path to your Chrome profile or log in manually.`);
-        }
-        else {
-            logger(`Unable to load local ChatGPT cookies on this host: ${message}`);
-        }
+        logger(`Unable to load local ChatGPT cookies on this host: ${message}`);
         if (process.platform === 'linux' && isWsl()) {
             logger('WSL hint: Chrome lives under /mnt/c/Users/<you>/AppData/Local/Google/Chrome/User Data/Default; pass --browser-cookie-path to that directory if auto-detect fails.');
         }
@@ -363,6 +360,24 @@ async function loadLocalChatgptCookies(logger, targetUrl) {
         return { cookies: null, opened };
     }
 }
+function toCdpCookie(cookie) {
+    if (!cookie?.name)
+        return null;
+    const out = {
+        name: cookie.name,
+        value: cookie.value,
+        domain: cookie.domain,
+        path: cookie.path ?? '/',
+        secure: cookie.secure ?? true,
+        httpOnly: cookie.httpOnly ?? false,
+    };
+    if (typeof cookie.expires === 'number')
+        out.expires = cookie.expires;
+    if (cookie.sameSite === 'Lax' || cookie.sameSite === 'Strict' || cookie.sameSite === 'None') {
+        out.sameSite = cookie.sameSite;
+    }
+    return out;
+}
 function triggerLocalLoginPrompt(logger, url) {
     const verbose = process.argv.includes('--verbose') || process.env.ORACLE_SERVE_VERBOSE === '1';
     const openers = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@steipete/oracle",
-  "version": "0.7.6",
+  "version": "0.8.0",
   "description": "CLI wrapper around OpenAI Responses API with GPT-5.2 Pro (via gpt-5.1-pro alias), GPT-5.2, GPT-5.1, and GPT-5.1 Codex high reasoning modes.",
   "type": "module",
   "main": "dist/bin/oracle-cli.js",
@@ -42,13 +42,13 @@
     "url": "git+https://github.com/steipete/oracle.git"
   },
   "engines": {
-    "node": ">=20"
+    "node": ">=22"
   },
   "devEngines": {
     "runtime": [
       {
         "name": "node",
-        "version": ">=20"
+        "version": ">=22"
       }
     ]
   },
@@ -64,8 +64,8 @@
     "@google/genai": "^1.34.0",
     "@google/generative-ai": "^0.24.1",
     "@modelcontextprotocol/sdk": "^1.25.1",
+    "@steipete/sweet-cookie": "^0.1.0",
     "chalk": "^5.6.2",
-    "chrome-cookies-secure": "3.0.0",
     "chrome-launcher": "^1.2.1",
     "chrome-remote-interface": "^0.33.3",
     "clipboardy": "^5.0.2",
@@ -75,13 +75,11 @@
     "gpt-tokenizer": "^3.4.0",
     "inquirer": "13.1.0",
     "json5": "^2.2.3",
-    "keytar": "^7.9.0",
     "kleur": "^4.1.5",
-    "markdansi": "0.1.7",
+    "markdansi": "0.2.0",
     "openai": "^6.15.0",
-    "osc-progress": "^0.1.0",
+    "osc-progress": "^0.2.0",
     "shiki": "^3.20.0",
-    "sqlite3": "^5.1.7",
     "toasted-notifier": "^10.1.0",
     "tokentally": "^0.1.1",
     "zod": "^4.2.1"
@@ -102,20 +100,13 @@
     "typescript": "^5.9.3",
     "vitest": "^4.0.16"
   },
-  "optionalDependencies": {
-    "win-dpapi": "npm:@primno/dpapi@2.0.1"
-  },
   "pnpm": {
     "overrides": {
-      "devtools-protocol": "0.0.1561482",
-      "win-dpapi": "npm:@primno/dpapi@2.0.1"
+      "devtools-protocol": "0.0.1561482"
     },
     "onlyBuiltDependencies": [
       "@cdktf/node-pty-prebuilt-multiarch",
-      "esbuild",
-      "keytar",
-      "sqlite3",
-      "win-dpapi"
+      "esbuild"
     ]
   },
   "packageManager": "pnpm@10.23.0+sha512.21c4e5698002ade97e4efe8b8b4a89a8de3c85a37919f957e7a0f30f38fbc5bbdd05980ffe29179b2fb6e6e691242e098d945d1601772cad0fef5fb6411e2a4b"