@steipete/oracle 0.7.6 → 0.8.0

package/dist/src/browser/cookies.js

@@ -1,10 +1,11 @@
 import { COOKIE_URLS } from './constants.js';
-import { loadChromeCookies } from './chromeCookies.js';
+import { getCookies } from '@steipete/sweet-cookie';
 export class ChromeCookieSyncError extends Error {
 }
 export async function syncCookies(Network, url, profile, logger, options = {}) {
     const { allowErrors = false, filterNames, inlineCookies, cookiePath } = options;
     try {
+        // Learned: inline cookies are the most deterministic (avoid Keychain + profile ambiguity).
         const cookies = inlineCookies?.length
             ? normalizeInlineCookies(inlineCookies, new URL(url).hostname)
             : await readChromeCookies(url, profile, filterNames ?? undefined, cookiePath ?? undefined);
@@ -15,6 +16,7 @@ export async function syncCookies(Network, url, profile, logger, options = {}) {
         for (const cookie of cookies) {
             const cookieWithUrl = attachUrl(cookie, url);
             try {
+                // Learned: CDP will silently drop cookies without a url; always attach one.
                 const result = await Network.setCookie(cookieWithUrl);
                 if (result?.success) {
                     applied += 1;
@@ -37,23 +39,31 @@ export async function syncCookies(Network, url, profile, logger, options = {}) {
     }
 }
 async function readChromeCookies(url, profile, filterNames, cookiePath) {
-    const urlsToCheck = Array.from(new Set([stripQuery(url), ...COOKIE_URLS]));
+    const origins = Array.from(new Set([stripQuery(url), ...COOKIE_URLS]));
+    const chromeProfile = cookiePath ?? profile ?? undefined;
+    const timeoutMs = readDuration('ORACLE_COOKIE_LOAD_TIMEOUT_MS', 5_000);
+    // Learned: read from multiple origins to capture auth cookies that land on chat.openai.com + atlas.
+    const { cookies, warnings } = await getCookies({
+        url,
+        origins,
+        names: filterNames?.length ? filterNames : undefined,
+        browsers: ['chrome'],
+        mode: 'merge',
+        chromeProfile,
+        timeoutMs,
+    });
+    if (process.env.ORACLE_DEBUG_COOKIES === '1' && warnings.length) {
+        // eslint-disable-next-line no-console
+        console.log(`[cookies] sweet-cookie warnings:\n- ${warnings.join('\n- ')}`);
+    }
     const merged = new Map();
-    const allowlist = normalizeCookieNames(filterNames);
-    for (const candidateUrl of urlsToCheck) {
-        const cookies = await loadChromeCookies({
-            targetUrl: candidateUrl,
-            profile: profile ?? undefined,
-            explicitCookiePath: cookiePath ?? undefined,
-            filterNames: allowlist ?? undefined,
-        });
-        const fallbackHostname = new URL(candidateUrl).hostname;
-        for (const cookie of cookies) {
-            const key = `${cookie.domain ?? fallbackHostname}:${cookie.name}`;
-            if (!merged.has(key)) {
-                merged.set(key, cookie);
-            }
-        }
+    for (const cookie of cookies) {
+        const normalized = toCdpCookie(cookie);
+        if (!normalized)
+            continue;
+        const key = `${normalized.domain ?? ''}:${normalized.name}`;
+        if (!merged.has(key))
+            merged.set(key, normalized);
     }
     return Array.from(merged.values());
 }
@@ -62,15 +72,17 @@ function normalizeInlineCookies(rawCookies, fallbackHost) {
     for (const cookie of rawCookies) {
         if (!cookie?.name)
             continue;
+        // Learned: inline cookies may omit url/domain; default to current host with a safe path.
         const normalized = {
-            ...cookie,
             name: cookie.name,
             value: cookie.value ?? '',
+            url: cookie.url,
             domain: cookie.domain ?? fallbackHost,
             path: cookie.path ?? '/',
             expires: normalizeExpiration(cookie.expires),
             secure: cookie.secure ?? true,
             httpOnly: cookie.httpOnly ?? false,
+            sameSite: cookie.sameSite,
         };
         const key = `${normalized.domain ?? fallbackHost}:${normalized.name}`;
         if (!merged.has(key)) {
@@ -79,11 +91,23 @@ function normalizeInlineCookies(rawCookies, fallbackHost) {
     }
     return Array.from(merged.values());
 }
-function normalizeCookieNames(names) {
-    if (!names || names.length === 0) {
+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 new Set(names.map((name) => name.trim()).filter(Boolean));
+    return out;
 }
 function attachUrl(cookie, fallbackUrl) {
     const cookieWithUrl = { ...cookie };
@@ -97,6 +121,7 @@ function attachUrl(cookie, fallbackUrl) {
     }
     // When url is present, let Chrome derive the host from it; keeping domain can trigger CDP sanitization errors.
     if (cookieWithUrl.url) {
+        // Learned: CDP rejects cookies with both url + domain in some cases; drop domain to avoid failures.
         delete cookieWithUrl.domain;
     }
     return cookieWithUrl;
@@ -121,10 +146,19 @@ function normalizeExpiration(expires) {
         return undefined;
     }
     if (value > 1_000_000_000_000) {
+        // Learned: Chrome may store WebKit microseconds since 1601; convert to Unix seconds.
         return Math.round(value / 1_000_000 - 11644473600);
     }
     if (value > 1_000_000_000) {
+        // Likely milliseconds; normalize to seconds for CDP.
         return Math.round(value / 1000);
     }
     return Math.round(value);
 }
+function readDuration(envKey, defaultValueMs) {
+    const raw = process.env[envKey];
+    if (!raw)
+        return defaultValueMs;
+    const value = Number.parseInt(raw, 10);
+    return Number.isFinite(value) && value > 0 ? value : defaultValueMs;
+}