@steipete/oracle 0.17.2 → 0.18.0

package/dist/src/browser/keytarShim.js

@@ -0,0 +1,56 @@
+const defaultLabels = [
+    { service: 'Chrome Safe Storage', account: 'Chrome' },
+    { service: 'Chromium Safe Storage', account: 'Chromium' },
+    { service: 'Microsoft Edge Safe Storage', account: 'Microsoft Edge' },
+    { service: 'Brave Safe Storage', account: 'Brave' },
+    { service: 'Vivaldi Safe Storage', account: 'Vivaldi' },
+];
+function loadEnvLabels() {
+    const raw = process.env.ORACLE_KEYCHAIN_LABELS;
+    if (!raw)
+        return [];
+    try {
+        const parsed = JSON.parse(raw);
+        if (Array.isArray(parsed)) {
+            return parsed
+                .map((entry) => (entry && typeof entry === 'object' ? entry : null))
+                .filter((entry) => Boolean(entry?.service && entry?.account));
+        }
+    }
+    catch {
+        // ignore invalid env payload
+    }
+    return [];
+}
+const fallbackLabels = [...loadEnvLabels(), ...defaultLabels];
+const disableKeytar = process.env.ORACLE_DISABLE_KEYTAR === '1' || process.env.CI === 'true';
+let keytar;
+if (disableKeytar) {
+    keytar = {
+        getPassword: async () => null,
+        setPassword: async () => undefined,
+        deletePassword: async () => false,
+    };
+}
+else {
+    const keytarModule = await import('keytar');
+    keytar = (keytarModule.default ?? keytarModule);
+    const originalGetPassword = keytar.getPassword.bind(keytar);
+    keytar.getPassword = async (service, account) => {
+        const primary = await originalGetPassword(service, account);
+        if (primary) {
+            return primary;
+        }
+        for (const label of fallbackLabels) {
+            if (label.service === service && label.account === account) {
+                continue; // already tried
+            }
+            const value = await originalGetPassword(label.service, label.account);
+            if (value) {
+                return value;
+            }
+        }
+        return null;
+    };
+}
+export default keytar;

package/dist/src/browser/policies.js

@@ -24,6 +24,11 @@ export function buildAttachmentPlan(sections, { inlineFiles, bundleRequested, ma
         shouldBundle,
     };
 }
+export const CHROME_COOKIE_SYNC_WARNING = "Warning: copying cookies from a live Chrome profile can invalidate that browser's ChatGPT session when tokens rotate. Prefer --browser-manual-login or inline cookies when possible.";
+export function shouldSyncBrowserCookies(config, { manualLogin, profileIsPreSigned = manualLogin, }) {
+    const explicitManualLoginSync = manualLogin && config.manualLoginCookieSync === true;
+    return config.cookieSync && (!profileIsPreSigned || explicitManualLoginSync);
+}
 export function buildCookiePlan(config) {
     if (config?.inlineCookies && config.inlineCookies.length > 0) {
         const source = config.inlineCookiesSource ?? "inline";
@@ -32,8 +37,11 @@ export function buildCookiePlan(config) {
             description: `Cookies: inline payload (${config.inlineCookies.length}) via ${source}.`,
         };
     }
-    if (config?.cookieSync === false) {
-        return { type: "disabled", description: "Cookies: sync disabled (--browser-no-cookie-sync)." };
+    if (config?.cookieSync !== true) {
+        return {
+            type: "disabled",
+            description: "Cookies: Chrome copy disabled (use --browser-manual-login, inline cookies, or --browser-cookie-sync).",
+        };
     }
     const allowlist = config?.cookieNames && config.cookieNames.length > 0
         ? config.cookieNames.join(", ")

package/dist/src/browser/profileSync.js

@@ -0,0 +1,141 @@
+import { mkdir, rm, cp as copyDir } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import path from 'node:path';
+import { defaultProfileRoot, expandPath, looksLikePath } from './chromeCookies.js';
+const DIR_EXCLUDES = [
+    'Cache',
+    'Code Cache',
+    'GPUCache',
+    'Service Worker',
+    'Crashpad',
+    'BrowserMetrics*',
+    'GrShaderCache',
+    'ShaderCache',
+    'OptimizationGuide',
+];
+const FILE_EXCLUDES = [
+    'SingletonLock',
+    'SingletonSocket',
+    'SingletonCookie',
+    '*.lock',
+    'lockfile',
+    'Lock',
+    '*.tmp',
+    'DevToolsActivePort',
+    path.join('Default', 'DevToolsActivePort'),
+    path.join('Sessions', '*'),
+    'Current Session',
+    'Current Tabs',
+    'Last Session',
+    'Last Tabs',
+];
+export async function syncChromeProfile(options) {
+    const { targetDir } = options;
+    await mkdir(targetDir, { recursive: true });
+    const { sourceDir, profileName } = await resolveProfileSource(options.profile, options.explicitPath);
+    const logger = options.logger;
+    if (!existsSync(sourceDir)) {
+        throw new Error(`Chrome profile not found at ${sourceDir}. Log in once in Chrome, then retry.`);
+    }
+    // Clean any stale DevTools ports/locks in the target before copying.
+    await rm(targetDir, { recursive: true, force: true }).catch(() => undefined);
+    await mkdir(targetDir, { recursive: true });
+    const result = process.platform === 'win32'
+        ? await copyWithRobocopy(sourceDir, targetDir, logger)
+        : await copyWithRsync(sourceDir, targetDir, logger);
+    // Remove lock files in the copied profile to avoid "already running" errors.
+    await removeLocks(targetDir);
+    return {
+        source: sourceDir,
+        profileName,
+        method: result.method,
+        status: result.copied ? 'copied' : 'skipped',
+    };
+}
+async function copyWithRsync(sourceDir, targetDir, logger) {
+    const rsyncArgs = [
+        '-a',
+        '--delete',
+        ...DIR_EXCLUDES.flatMap((entry) => ['--exclude', entry]),
+        ...FILE_EXCLUDES.flatMap((entry) => ['--exclude', entry]),
+        `${sourceDir}/`,
+        `${targetDir}/`,
+    ];
+    const attempt = spawnSync('rsync', rsyncArgs, { stdio: 'pipe' });
+    if (!attempt.error && (attempt.status ?? 0) === 0) {
+        return { copied: true, method: 'rsync' };
+    }
+    logger?.('rsync unavailable or failed; falling back to Node copy');
+    await copyDirWithFilter(sourceDir, targetDir);
+    return copyWithNodeFs();
+}
+async function copyWithRobocopy(sourceDir, targetDir, logger) {
+    const args = [sourceDir, targetDir, '/MIR', '/NFL', '/NDL', '/NJH', '/NJS', '/NP', '/Z'];
+    if (DIR_EXCLUDES.length) {
+        args.push('/XD', ...DIR_EXCLUDES);
+    }
+    if (FILE_EXCLUDES.length) {
+        args.push('/XF', ...FILE_EXCLUDES);
+    }
+    const attempt = spawnSync('robocopy', args, { stdio: 'pipe' });
+    const exitCode = attempt.status ?? 0;
+    // Robocopy treats 0-7 as success/partial success; >=8 is failure.
+    if (!attempt.error && exitCode < 8) {
+        return { copied: true, method: 'robocopy' };
+    }
+    logger?.('robocopy failed; falling back to Node copy');
+    await copyDirWithFilter(sourceDir, targetDir);
+    return copyWithNodeFs();
+}
+function copyWithNodeFs() {
+    return { copied: true, method: 'node' };
+}
+function shouldExclude(relativePath) {
+    const normalized = relativePath.replace(/\\/g, '/');
+    return DIR_EXCLUDES.some((entry) => normalized === entry || normalized.startsWith(`${entry}/`)) ||
+        FILE_EXCLUDES.some((entry) => {
+            if (entry.endsWith('*')) {
+                return normalized.startsWith(entry.slice(0, -1));
+            }
+            if (entry.includes('*')) {
+                // simple glob support for BrowserMetrics*
+                const prefix = entry.replace('*', '');
+                return normalized.startsWith(prefix);
+            }
+            return path.basename(normalized) === entry || normalized.endsWith(`/${entry}`);
+        });
+}
+async function removeLocks(targetDir) {
+    const lockNames = ['SingletonLock', 'SingletonSocket', 'SingletonCookie', 'DevToolsActivePort'];
+    for (const lock of lockNames) {
+        await rm(path.join(targetDir, lock), { force: true }).catch(() => undefined);
+        await rm(path.join(targetDir, 'Default', lock), { force: true }).catch(() => undefined);
+    }
+}
+async function resolveProfileSource(profile, explicitPath) {
+    const profileName = profile?.trim() ? profile.trim() : 'Default';
+    if (explicitPath?.trim()) {
+        const resolved = expandPath(explicitPath.trim());
+        if (resolved.toLowerCase().endsWith('cookies')) {
+            return { sourceDir: path.dirname(resolved), profileName };
+        }
+        return { sourceDir: resolved, profileName };
+    }
+    if (looksLikePath(profileName)) {
+        return { sourceDir: expandPath(profileName), profileName };
+    }
+    const baseRoot = await defaultProfileRoot();
+    return { sourceDir: path.join(baseRoot, profileName), profileName };
+}
+async function copyDirWithFilter(sourceDir, targetDir) {
+    await copyDir(sourceDir, targetDir, {
+        recursive: true,
+        filter: async (source) => {
+            const rel = path.relative(sourceDir, source);
+            if (!rel)
+                return true;
+            return !shouldExclude(rel);
+        },
+    });
+}

package/dist/src/browser/projectSourcesRunner.js

@@ -13,6 +13,7 @@ import { assertManualLoginProfileReadyForRun, defaultManualLoginProfileDir, form
 import { openProjectSourcesTab, uploadProjectSources, waitForProjectSourcesReady, waitForProjectSourcesListSettled, } from "./actions/projectSources.js";
 import { normalizeProjectSourcesUrl } from "../projectSources/url.js";
 import { buildProjectSourcesUploadPlan, diffAddedProjectSources } from "../projectSources/plan.js";
+import { CHROME_COOKIE_SYNC_WARNING, shouldSyncBrowserCookies } from "./policies.js";
 export async function runBrowserProjectSources(request) {
     const startedAt = Date.now();
     const logger = ((message) => request.log?.(message));
@@ -248,14 +249,16 @@ export async function runBrowserProjectSources(request) {
     }
 }
 async function applyProjectSourcesCookies({ config, network, manualLogin, logger, }) {
-    const manualLoginCookieSync = manualLogin && Boolean(config.manualLoginCookieSync);
-    const cookieSyncEnabled = config.cookieSync && (!manualLogin || manualLoginCookieSync);
+    const cookieSyncEnabled = shouldSyncBrowserCookies(config, { manualLogin });
     if (!cookieSyncEnabled) {
         logger(manualLogin
             ? "Skipping Chrome cookie sync (--browser-manual-login enabled); reuse the opened profile after signing in."
-            : "Skipping Chrome cookie sync (--browser-no-cookie-sync)");
+            : "Skipping Chrome cookie copy (disabled by default; use --browser-cookie-sync to opt in).");
         return 0;
     }
+    if (!config.inlineCookies) {
+        logger(CHROME_COOKIE_SYNC_WARNING);
+    }
     const cookieCount = await syncCookies(network, config.url, config.chromeProfile, logger, {
         allowErrors: config.allowCookieErrors ?? false,
         filterNames: config.cookieNames ?? undefined,

package/dist/src/browser/reattach.js

@@ -12,6 +12,7 @@ import { cleanupStaleProfileState } from "./profileState.js";
 import { readDevToolsActivePortInfo } from "./detect.js";
 import { pickTarget, extractConversationIdFromUrl, buildConversationUrl, withTimeout, openConversationFromSidebar, openConversationFromSidebarWithRetry, waitForLocationChange, readConversationTurnIndex, buildPromptEchoMatcher, recoverPromptEcho, alignPromptEchoMarkdown, } from "./reattachHelpers.js";
 import { waitForDeepResearchCompletion } from "./actions/deepResearch.js";
+import { CHROME_COOKIE_SYNC_WARNING, shouldSyncBrowserCookies } from "./policies.js";
 export async function resumeBrowserSession(runtime, config, logger, deps = {}) {
     const recoverSession = deps.recoverSession ??
         (async (runtimeMeta, configMeta) => resumeBrowserSessionViaNewChrome(runtimeMeta, configMeta, logger, deps));
@@ -176,9 +177,37 @@ async function resumeBrowserSessionViaNewChrome(runtime, config, logger, deps) {
     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 launch = deps.launchChrome ?? launchChrome;
+    const connectToLaunchedChrome = deps.connectToChrome ?? connectToChrome;
+    const chrome = await launch(resolved, userDataDir, logger);
+    const chromeHost = chrome && typeof chrome === "object" && "host" in chrome && typeof chrome.host === "string"
+        ? chrome.host
+        : "127.0.0.1";
+    const client = await connectToLaunchedChrome(chrome.port, logger, chromeHost);
+    const cleanup = async () => {
+        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);
+            }
+        }
+    };
     const { Network, Page, Runtime, DOM, Target } = client;
     if (Runtime?.enable) {
         await Runtime.enable();
@@ -190,14 +219,24 @@ async function resumeBrowserSessionViaNewChrome(runtime, config, logger, deps) {
         await positionChromeWindowOffscreen(client, 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,
-        });
+    if (shouldSyncBrowserCookies(resolved, { manualLogin })) {
+        if (!resolved.inlineCookies) {
+            logger(CHROME_COOKIE_SYNC_WARNING);
+        }
+        const sync = deps.syncCookies ?? syncCookies;
+        try {
+            appliedCookies = await sync(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,
+            });
+        }
+        catch (error) {
+            await cleanup();
+            throw error;
+        }
     }
     await clearStaleChatGptConversationCookies(Network, Target, logger, {
         preserveConversationIds: [
@@ -242,30 +281,6 @@ async function resumeBrowserSessionViaNewChrome(runtime, config, logger, deps) {
     const waitForResponse = deps.waitForAssistantResponse ?? waitForAssistantResponse;
     const captureMarkdown = deps.captureAssistantMarkdown ?? captureAssistantMarkdown;
     const timeoutMs = resolved.timeoutMs ?? 120_000;
-    const cleanup = async () => {
-        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);
-            }
-        }
-    };
     const minTurnIndex = (await readPromptPreviewTurnIndex(Runtime, deps.promptPreview)) ??
         (deps.promptPreview ? null : await readConversationTurnIndex(Runtime, logger));
     if (resolved.researchMode === "deep") {

package/dist/src/browser/windowsCookies.js

@@ -0,0 +1,219 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs/promises';
+import { existsSync, promises as fsp } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import sqlite3 from 'sqlite3';
+import { createRequire } from 'node:module';
+import { spawnSync } from 'node:child_process';
+let cachedUnprotect = null;
+function getUnprotectData() {
+    if (cachedUnprotect) {
+        return cachedUnprotect;
+    }
+    try {
+        // win-dpapi is CommonJS; require it explicitly and support both named/default shapes.
+        const dpapiModule = createRequire(import.meta.url)('win-dpapi');
+        const unprotect = dpapiModule?.Dpapi?.unprotectData ??
+            dpapiModule?.default?.unprotectData ??
+            ((_) => {
+                throw new Error('win-dpapi unprotectData not available');
+            });
+        cachedUnprotect = unprotect;
+        return unprotect;
+    }
+    catch (error) {
+        if (process.platform !== 'win32') {
+            // On macOS/Linux we don't need DPAPI; return a function that makes misuse obvious.
+            cachedUnprotect = () => {
+                throw new Error('win-dpapi is unavailable on non-Windows platforms');
+            };
+            return cachedUnprotect;
+        }
+        throw error;
+    }
+}
+export async function loadWindowsCookies(dbPath, filterNames) {
+    if (process.platform !== 'win32') {
+        throw new Error('loadWindowsCookies is only supported on Windows');
+    }
+    const localStatePath = await locateLocalState(dbPath);
+    const cookiesCopy = await copyLockedFile(dbPath, 'Cookies'); // name the copy exactly "Cookies"
+    const cookiesDirForFallback = await ensureCookiesDirForFallback(cookiesCopy);
+    const localStateCopy = await copyLockedFile(localStatePath, 'Local State');
+    const aesKey = await extractWindowsAesKey(localStateCopy);
+    const rows = await readChromeCookiesDb(cookiesCopy, filterNames);
+    const cookies = [];
+    for (const row of rows) {
+        const enc = row.encrypted_value && row.encrypted_value.length > 0 ? row.encrypted_value : Buffer.from(row.value ?? '', 'utf8');
+        const decrypted = enc.length > 0 ? decryptCookie(enc, aesKey) : '';
+        cookies.push({
+            name: row.name,
+            value: decrypted,
+            domain: row.host_key?.startsWith('.') ? row.host_key.slice(1) : row.host_key,
+            path: row.path ?? '/',
+            expires: normalizeExpiration(row.expires_utc),
+            secure: Boolean(row.is_secure),
+            httpOnly: Boolean(row.is_httponly),
+        });
+    }
+    if (process.env.ORACLE_DEBUG_COOKIES === '1') {
+        // eslint-disable-next-line no-console
+        console.log(`[cookies] windows decrypt decoded ${cookies.length} cookies from ${cookiesCopy} (fallback dir ${cookiesDirForFallback})`);
+    }
+    return cookies.filter((c) => c.value);
+}
+function decryptCookie(value, aesKey) {
+    const prefix = value.slice(0, 3).toString();
+    // Chrome prefixes AES-GCM encrypted cookies with version markers like v10/v11/v20; treat all v** the same.
+    if (/^v\d{2}$/u.test(prefix)) {
+        const iv = value.slice(3, 15);
+        const tag = value.slice(value.length - 16);
+        const data = value.slice(15, value.length - 16);
+        const decipher = crypto.createDecipheriv('aes-256-gcm', aesKey, iv);
+        decipher.setAuthTag(tag);
+        const decrypted = Buffer.concat([decipher.update(data), decipher.final()]);
+        return decrypted.toString('utf8');
+    }
+    const unprotectData = getUnprotectData();
+    const unprotected = unprotectData(value, undefined, 'CurrentUser');
+    return Buffer.from(unprotected).toString('utf8');
+}
+async function locateLocalState(dbPath) {
+    // Prefer sibling Local State near the profile path; fall back to default location.
+    const guess = path.resolve(path.join(path.dirname(dbPath), '..', 'Local State'));
+    if (existsSync(guess))
+        return guess;
+    const localState = path.join(os.homedir(), 'AppData', 'Local', 'Google', 'Chrome', 'User Data', 'Local State');
+    if (existsSync(localState))
+        return localState;
+    throw new Error('Chrome Local State not found for AES key');
+}
+async function extractWindowsAesKey(localStatePath) {
+    const raw = await fs.readFile(localStatePath, 'utf8');
+    const state = JSON.parse(raw);
+    const encKeyB64 = state?.os_crypt?.encrypted_key;
+    if (!encKeyB64)
+        throw new Error('encrypted_key missing in Local State');
+    const encKey = Buffer.from(encKeyB64, 'base64');
+    const dpapiBlob = encKey.slice(5); // strip "DPAPI"
+    const unprotectData = getUnprotectData();
+    const unprotected = unprotectData(dpapiBlob, undefined, 'CurrentUser');
+    return Buffer.from(unprotected);
+}
+async function readChromeCookiesDb(dbPath, filterNames) {
+    const db = await openSqlite(dbPath);
+    const placeholders = filterNames && filterNames.size > 0 ? `AND name IN (${Array.from(filterNames).map(() => '?').join(',')})` : '';
+    const params = filterNames ? Array.from(filterNames) : [];
+    const sql = `SELECT name,value,encrypted_value,host_key,path,expires_utc,is_secure,is_httponly FROM cookies WHERE host_key LIKE '%chatgpt.com%' ${placeholders}`;
+    try {
+        return await allSqlite(db, sql, params);
+    }
+    finally {
+        db.close();
+    }
+}
+function openSqlite(dbPath) {
+    return new Promise((resolve, reject) => {
+        const db = new sqlite3.Database(dbPath, sqlite3.OPEN_READONLY, (err) => {
+            if (err)
+                reject(err);
+            else
+                resolve(db);
+        });
+    });
+}
+async function copyLockedFile(sourcePath, targetName) {
+    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'oracle-cookie-'));
+    const tempPath = targetName ? path.join(tempDir, targetName) : path.join(tempDir, path.basename(sourcePath));
+    const psScript = `
+$src = '${sourcePath.replace(/'/g, "''")}'
+$dst = '${tempPath.replace(/'/g, "''")}'
+try {
+  $fs = [System.IO.File]::Open($src, [System.IO.FileMode]::Open, [System.IO.FileAccess]::Read, [System.IO.FileShare]::ReadWrite)
+  $bytes = New-Object byte[] $fs.Length
+  $null = $fs.Read($bytes, 0, $fs.Length)
+  $fs.Close()
+  [System.IO.File]::WriteAllBytes($dst, $bytes)
+  exit 0
+} catch {
+  exit 1
+}
+`;
+    const encoded = Buffer.from(psScript, 'utf16le').toString('base64');
+    const result = spawnSync('powershell.exe', ['-NoProfile', '-NonInteractive', '-EncodedCommand', encoded], {
+        timeout: 15000,
+        encoding: 'utf8',
+    });
+    if (result.status !== 0) {
+        // Fallback: best-effort normal copy
+        await fs.copyFile(sourcePath, tempPath);
+    }
+    if (process.env.ORACLE_DEBUG_COOKIES === '1') {
+        // eslint-disable-next-line no-console
+        console.log(`[cookies] copied locked file ${sourcePath} -> ${tempPath}`);
+    }
+    return tempPath;
+}
+// Create a directory containing a file named "Cookies" for chrome-cookies-secure fallback
+export async function ensureCookiesDirForFallback(cookieFile) {
+    const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'oracle-cookies-secure-'));
+    const target = path.join(dir, 'Cookies');
+    await fs.copyFile(cookieFile, target);
+    return dir;
+}
+function allSqlite(db, sql, params) {
+    return new Promise((resolve, reject) => {
+        db.all(sql, params, (err, rows) => {
+            if (err)
+                reject(err);
+            else
+                resolve((rows ?? []));
+        });
+    });
+}
+function normalizeExpiration(expires) {
+    if (!expires || Number.isNaN(expires)) {
+        return undefined;
+    }
+    const value = Number(expires);
+    if (value <= 0)
+        return undefined;
+    if (value > 1_000_000_000_000) {
+        return Math.round(value / 1_000_000 - 11644473600);
+    }
+    if (value > 1_000_000_000) {
+        return Math.round(value / 1000);
+    }
+    return Math.round(value);
+}
+export async function materializeCookieFile(sourcePath) {
+    if (process.platform !== 'win32')
+        return sourcePath;
+    const resolved = await resolveDirectoryCandidate(sourcePath);
+    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'oracle-cookies-'));
+    const tempPath = path.join(tempDir, 'Cookies');
+    await fs.copyFile(resolved, tempPath);
+    return tempPath;
+}
+async function resolveDirectoryCandidate(inputPath) {
+    const stat = await fs.stat(inputPath).catch(() => null);
+    if (!stat?.isDirectory())
+        return inputPath;
+    const network = path.join(inputPath, 'Network', 'Cookies');
+    const direct = path.join(inputPath, 'Cookies');
+    if (await fileExists(network))
+        return network;
+    if (await fileExists(direct))
+        return direct;
+    return inputPath;
+}
+async function fileExists(candidate) {
+    try {
+        const stat = await fsp.stat(candidate);
+        return stat.isFile();
+    }
+    catch {
+        return false;
+    }
+}