@steipete/oracle 0.9.0 → 0.11.0

package/dist/src/browser/profileState.js

@@ -1,16 +1,16 @@
-import path from 'node:path';
-import { randomUUID } from 'node:crypto';
-import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
-import { delay } from './utils.js';
-const DEVTOOLS_ACTIVE_PORT_FILENAME = 'DevToolsActivePort';
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { delay } from "./utils.js";
+const DEVTOOLS_ACTIVE_PORT_FILENAME = "DevToolsActivePort";
 const DEVTOOLS_ACTIVE_PORT_RELATIVE_PATHS = [
     DEVTOOLS_ACTIVE_PORT_FILENAME,
-    path.join('Default', DEVTOOLS_ACTIVE_PORT_FILENAME),
+    path.join("Default", DEVTOOLS_ACTIVE_PORT_FILENAME),
 ];
-const CHROME_PID_FILENAME = 'chrome.pid';
-const ORACLE_PROFILE_LOCK_FILENAME = 'oracle-automation.lock';
+const CHROME_PID_FILENAME = "chrome.pid";
+const ORACLE_PROFILE_LOCK_FILENAME = "oracle-automation.lock";
 const execFileAsync = promisify(execFile);
 export function getDevToolsActivePortPaths(userDataDir) {
     return DEVTOOLS_ACTIVE_PORT_RELATIVE_PATHS.map((relative) => path.join(userDataDir, relative));
@@ -18,9 +18,9 @@ export function getDevToolsActivePortPaths(userDataDir) {
 export async function readDevToolsPort(userDataDir) {
     for (const candidate of getDevToolsActivePortPaths(userDataDir)) {
         try {
-            const raw = await readFile(candidate, 'utf8');
+            const raw = await readFile(candidate, "utf8");
             const firstLine = raw.split(/\r?\n/u)[0]?.trim();
-            const port = Number.parseInt(firstLine ?? '', 10);
+            const port = Number.parseInt(firstLine ?? "", 10);
             if (Number.isFinite(port)) {
                 return port;
             }
@@ -36,7 +36,7 @@ export async function writeDevToolsActivePort(userDataDir, port) {
     for (const candidate of getDevToolsActivePortPaths(userDataDir)) {
         try {
             await mkdir(path.dirname(candidate), { recursive: true });
-            await writeFile(candidate, contents, 'utf8');
+            await writeFile(candidate, contents, "utf8");
         }
         catch {
             // best effort
@@ -46,7 +46,7 @@ export async function writeDevToolsActivePort(userDataDir, port) {
 export async function readChromePid(userDataDir) {
     const pidPath = path.join(userDataDir, CHROME_PID_FILENAME);
     try {
-        const raw = (await readFile(pidPath, 'utf8')).trim();
+        const raw = (await readFile(pidPath, "utf8")).trim();
         const pid = Number.parseInt(raw, 10);
         if (!Number.isFinite(pid) || pid <= 0) {
             return null;
@@ -63,12 +63,83 @@ export async function writeChromePid(userDataDir, pid) {
     const pidPath = path.join(userDataDir, CHROME_PID_FILENAME);
     try {
         await mkdir(path.dirname(pidPath), { recursive: true });
-        await writeFile(pidPath, `${Math.trunc(pid)}\n`, 'utf8');
+        await writeFile(pidPath, `${Math.trunc(pid)}\n`, "utf8");
     }
     catch {
         // best effort
     }
 }
+export async function findRunningChromeDebugTargetForProfile(userDataDir) {
+    if (process.platform === "win32") {
+        return null;
+    }
+    try {
+        const { stdout } = await execFileAsync("ps", ["-ax", "-o", "pid=", "-o", "command="], {
+            maxBuffer: 10 * 1024 * 1024,
+        });
+        return findChromeDebugTargetForProfileFromProcessList(String(stdout ?? ""), userDataDir);
+    }
+    catch {
+        return null;
+    }
+}
+function findChromeDebugTargetForProfileFromProcessList(processList, userDataDir) {
+    for (const line of processList.split("\n")) {
+        const match = line.match(/^\s*(\d+)\s+(.+)$/);
+        if (!match)
+            continue;
+        const pid = Number.parseInt(match[1] ?? "", 10);
+        const command = match[2] ?? "";
+        const lower = command.toLowerCase();
+        if (!Number.isFinite(pid) || pid <= 0)
+            continue;
+        if (!lower.includes("chrome") && !lower.includes("chromium"))
+            continue;
+        if (!lower.includes("user-data-dir") || !command.includes(userDataDir))
+            continue;
+        const portMatch = command.match(/--remote-debugging-port(?:=|\s+)(\d+)/);
+        const port = Number.parseInt(portMatch?.[1] ?? "", 10);
+        if (!Number.isFinite(port) || port <= 0)
+            continue;
+        return { pid, port };
+    }
+    return null;
+}
+export function findChromeDebugTargetForProfileFromProcessListForTest(processList, userDataDir) {
+    return findChromeDebugTargetForProfileFromProcessList(processList, userDataDir);
+}
+export async function terminateRecordedChromeForProfile(userDataDir, logger) {
+    const pid = await readChromePid(userDataDir);
+    if (!pid || !isProcessAlive(pid)) {
+        return false;
+    }
+    const command = await readProcessCommand(pid);
+    if (!isChromeCommandForUserDataDir(command, userDataDir)) {
+        logger?.(`Recorded Chrome pid ${pid} does not match ${userDataDir}; skipping termination`);
+        return false;
+    }
+    try {
+        process.kill(pid, "SIGTERM");
+        logger?.(`Terminated shared manual-login Chrome pid ${pid}`);
+        return true;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger?.(`Failed to terminate shared manual-login Chrome pid ${pid}: ${message}`);
+        return false;
+    }
+}
+function isChromeCommandForUserDataDir(command, userDataDir) {
+    if (!command)
+        return false;
+    const lower = command.toLowerCase();
+    return ((lower.includes("chrome") || lower.includes("chromium")) &&
+        lower.includes("user-data-dir") &&
+        command.includes(userDataDir));
+}
+export function isChromeCommandForUserDataDirForTest(command, userDataDir) {
+    return isChromeCommandForUserDataDir(command, userDataDir);
+}
 export function isProcessAlive(pid) {
     if (!Number.isFinite(pid) || pid <= 0)
         return false;
@@ -78,7 +149,10 @@ export function isProcessAlive(pid) {
     }
     catch (error) {
         // EPERM means "exists but no permission"; treat as alive.
-        if (error && typeof error === 'object' && 'code' in error && error.code === 'EPERM') {
+        if (error &&
+            typeof error === "object" &&
+            "code" in error &&
+            error.code === "EPERM") {
             return true;
         }
         return false;
@@ -91,7 +165,7 @@ function parseProfileRunLock(payload) {
         const parsed = JSON.parse(payload);
         if (!Number.isFinite(parsed.pid) || parsed.pid <= 0)
             return null;
-        if (!parsed.lockId || typeof parsed.lockId !== 'string')
+        if (!parsed.lockId || typeof parsed.lockId !== "string")
             return null;
         return parsed;
     }
@@ -104,7 +178,7 @@ export async function acquireProfileRunLock(userDataDir, options) {
     if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
         return null;
     }
-    const pollMs = typeof options.pollMs === 'number' && Number.isFinite(options.pollMs) && options.pollMs > 0
+    const pollMs = typeof options.pollMs === "number" && Number.isFinite(options.pollMs) && options.pollMs > 0
         ? options.pollMs
         : 1000;
     const lockPath = path.join(userDataDir, ORACLE_PROFILE_LOCK_FILENAME);
@@ -120,7 +194,7 @@ export async function acquireProfileRunLock(userDataDir, options) {
                 sessionId: options.sessionId,
             };
             await mkdir(path.dirname(lockPath), { recursive: true });
-            await writeFile(lockPath, JSON.stringify(payload), { encoding: 'utf8', flag: 'wx' });
+            await writeFile(lockPath, JSON.stringify(payload), { encoding: "utf8", flag: "wx" });
             options.logger?.(`Acquired Oracle profile lock at ${lockPath}`);
             return {
                 path: lockPath,
@@ -130,16 +204,16 @@ export async function acquireProfileRunLock(userDataDir, options) {
         }
         catch (error) {
             const code = error.code;
-            if (code !== 'EEXIST') {
+            if (code !== "EEXIST") {
                 throw error;
             }
-            let existing = parseProfileRunLock(await readFile(lockPath, 'utf8').catch(() => null));
+            let existing = parseProfileRunLock(await readFile(lockPath, "utf8").catch(() => null));
             if (!existing) {
                 // Likely partial write / corruption; re-read once, then delete (user preference: delete unreadable lockfiles).
                 await delay(200);
-                existing = parseProfileRunLock(await readFile(lockPath, 'utf8').catch(() => null));
+                existing = parseProfileRunLock(await readFile(lockPath, "utf8").catch(() => null));
                 if (!existing) {
-                    options.logger?.('Oracle profile lock unreadable; deleting lockfile.');
+                    options.logger?.("Oracle profile lock unreadable; deleting lockfile.");
                     await rm(lockPath, { force: true }).catch(() => undefined);
                     continue;
                 }
@@ -163,7 +237,7 @@ export async function acquireProfileRunLock(userDataDir, options) {
 }
 export async function releaseProfileRunLock(lockPath, lockId, logger) {
     try {
-        const existing = parseProfileRunLock(await readFile(lockPath, 'utf8').catch(() => null));
+        const existing = parseProfileRunLock(await readFile(lockPath, "utf8").catch(() => null));
         if (!existing || existing.lockId !== lockId) {
             return;
         }
@@ -174,7 +248,7 @@ export async function releaseProfileRunLock(lockPath, lockId, logger) {
         // best effort
     }
 }
-export async function verifyDevToolsReachable({ port, host = '127.0.0.1', attempts = 3, timeoutMs = 3000, }) {
+export async function verifyDevToolsReachable({ port, host = "127.0.0.1", attempts = 3, timeoutMs = 3000, }) {
     const versionUrl = `http://${host}:${port}/json/version`;
     for (let attempt = 0; attempt < attempts; attempt++) {
         try {
@@ -196,12 +270,9 @@ export async function verifyDevToolsReachable({ port, host = '127.0.0.1', attemp
             return { ok: false, error: message };
         }
     }
-    return { ok: false, error: 'unreachable' };
+    return { ok: false, error: "unreachable" };
 }
 export async function shouldCleanupManualLoginProfileState(userDataDir, logger, options = {}) {
-    if (!options.connectionClosedUnexpectedly) {
-        return true;
-    }
     const port = await readDevToolsPort(userDataDir);
     if (!port) {
         return true;
@@ -224,8 +295,8 @@ export async function cleanupStaleProfileState(userDataDir, logger, options = {}
             // ignore cleanup errors
         }
     }
-    const lockRemovalMode = options.lockRemovalMode ?? 'never';
-    if (lockRemovalMode === 'never') {
+    const lockRemovalMode = options.lockRemovalMode ?? "never";
+    if (lockRemovalMode === "never") {
         return;
     }
     const pid = await readChromePid(userDataDir);
@@ -239,36 +310,38 @@ export async function cleanupStaleProfileState(userDataDir, logger, options = {}
     // Extra safety: if Chrome is running with this profile (but with a different PID, e.g. user relaunched
     // without remote debugging), never delete lock files.
     if (await isChromeUsingUserDataDir(userDataDir)) {
-        logger?.('Detected running Chrome using this profile; skipping profile lock cleanup');
+        logger?.("Detected running Chrome using this profile; skipping profile lock cleanup");
         return;
     }
     const lockFiles = [
-        path.join(userDataDir, 'lockfile'),
-        path.join(userDataDir, 'SingletonLock'),
-        path.join(userDataDir, 'SingletonSocket'),
-        path.join(userDataDir, 'SingletonCookie'),
+        path.join(userDataDir, "lockfile"),
+        path.join(userDataDir, "SingletonLock"),
+        path.join(userDataDir, "SingletonSocket"),
+        path.join(userDataDir, "SingletonCookie"),
     ];
     for (const lock of lockFiles) {
         await rm(lock, { force: true }).catch(() => undefined);
     }
-    logger?.('Cleaned up stale Chrome profile locks');
+    logger?.("Cleaned up stale Chrome profile locks");
 }
 async function isChromeUsingUserDataDir(userDataDir) {
-    if (process.platform === 'win32') {
+    if (process.platform === "win32") {
         // On Windows, lockfiles are typically held open and removal should fail anyway; avoid expensive process scans.
         return false;
     }
     try {
-        const { stdout } = await execFileAsync('ps', ['-ax', '-o', 'command='], { maxBuffer: 10 * 1024 * 1024 });
-        const lines = String(stdout ?? '').split('\n');
+        const { stdout } = await execFileAsync("ps", ["-ax", "-o", "command="], {
+            maxBuffer: 10 * 1024 * 1024,
+        });
+        const lines = String(stdout ?? "").split("\n");
         const needle = userDataDir;
         for (const line of lines) {
             if (!line)
                 continue;
             const lower = line.toLowerCase();
-            if (!lower.includes('chrome') && !lower.includes('chromium'))
+            if (!lower.includes("chrome") && !lower.includes("chromium"))
                 continue;
-            if (line.includes(needle) && lower.includes('user-data-dir')) {
+            if (line.includes(needle) && lower.includes("user-data-dir")) {
                 return true;
             }
         }
@@ -278,3 +351,15 @@ async function isChromeUsingUserDataDir(userDataDir) {
     }
     return false;
 }
+async function readProcessCommand(pid) {
+    try {
+        const { stdout } = await execFileAsync("ps", ["-p", String(Math.trunc(pid)), "-o", "command="], {
+            maxBuffer: 1024 * 1024,
+        });
+        const command = String(stdout ?? "").trim();
+        return command || null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/src/browser/projectSourcesRunner.js

@@ -0,0 +1,366 @@
+import { mkdtemp, mkdir, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { closeTab, connectWithNewTab, hideChromeWindow, launchChrome, registerTerminationHooks, } from "./chromeLifecycle.js";
+import { resolveBrowserConfig } from "./config.js";
+import { syncCookies } from "./cookies.js";
+import { installJavaScriptDialogAutoDismissal, navigateToChatGPT, ensureLoggedIn, } from "./pageActions.js";
+import { acquireBrowserTabLease, hasOtherActiveBrowserTabLeases, } from "./tabLeaseRegistry.js";
+import { acquireProfileRunLock, cleanupStaleProfileState, findRunningChromeDebugTargetForProfile, readChromePid, readDevToolsPort, shouldCleanupManualLoginProfileState, verifyDevToolsReachable, writeChromePid, writeDevToolsActivePort, } from "./profileState.js";
+import { CHATGPT_URL } from "./constants.js";
+import { delay } from "./utils.js";
+import { openProjectSourcesTab, uploadProjectSources, waitForProjectSourcesReady, waitForProjectSourcesListSettled, } from "./actions/projectSources.js";
+import { normalizeProjectSourcesUrl } from "../projectSources/url.js";
+import { buildProjectSourcesUploadPlan, diffAddedProjectSources } from "../projectSources/plan.js";
+export async function runBrowserProjectSources(request) {
+    const startedAt = Date.now();
+    const logger = ((message) => request.log?.(message));
+    const projectUrl = normalizeProjectSourcesUrl(request.chatgptUrl);
+    const operation = request.operation;
+    const files = request.files ?? [];
+    const plannedUploads = buildProjectSourcesUploadPlan(files);
+    const warnings = [];
+    if (operation === "add" && files.length === 0) {
+        throw new Error("Project Sources add requires at least one file.");
+    }
+    if (request.dryRun) {
+        return {
+            status: "dry-run",
+            operation,
+            projectUrl,
+            dryRun: true,
+            plannedUploads,
+            warnings,
+            tookMs: Date.now() - startedAt,
+        };
+    }
+    let config = resolveBrowserConfig({
+        ...request.config,
+        url: projectUrl,
+        chatgptUrl: projectUrl,
+    });
+    if (config.remoteChrome) {
+        throw new Error("Project Sources v1 uses local browser automation only. Run it on the signed-in browser host.");
+    }
+    const manualLogin = Boolean(config.manualLogin);
+    const manualProfileDir = config.manualLoginProfileDir
+        ? path.resolve(config.manualLoginProfileDir)
+        : path.join(os.homedir(), ".oracle", "browser-profile");
+    const userDataDir = manualLogin
+        ? manualProfileDir
+        : await mkdtemp(path.join(os.tmpdir(), "oracle-project-sources-"));
+    if (manualLogin) {
+        await mkdir(userDataDir, { recursive: true });
+        logger(`Manual login mode enabled; reusing persistent profile at ${userDataDir}`);
+    }
+    else {
+        logger(`Created temporary Chrome profile at ${userDataDir}`);
+    }
+    let tabLease = null;
+    if (manualLogin) {
+        tabLease = await acquireBrowserTabLease(userDataDir, {
+            maxConcurrentTabs: config.maxConcurrentTabs,
+            timeoutMs: config.timeoutMs,
+            logger,
+            sessionId: "project-sources",
+        });
+    }
+    let chrome = null;
+    let reusedChrome = null;
+    let client = null;
+    let isolatedTargetId = null;
+    let removeTerminationHooks = null;
+    let removeDialogHandler = null;
+    let connectionClosedUnexpectedly = false;
+    let completed = false;
+    const effectiveKeepBrowser = Boolean(config.keepBrowser);
+    try {
+        const acquired = manualLogin
+            ? await acquireManualLoginChromeForProjectSources(userDataDir, config, logger)
+            : {
+                chrome: await launchChrome({ ...config, remoteChrome: null }, userDataDir, logger),
+                reusedChrome: null,
+            };
+        chrome = acquired.chrome;
+        reusedChrome = acquired.reusedChrome;
+        const chromeHost = chrome.host ?? "127.0.0.1";
+        if (tabLease) {
+            await tabLease.update({ chromeHost, chromePort: chrome.port });
+        }
+        removeTerminationHooks = registerTerminationHooks(chrome, userDataDir, effectiveKeepBrowser, logger, {
+            isInFlight: () => !completed,
+            preserveUserDataDir: manualLogin,
+        });
+        const strictTabIsolation = Boolean(manualLogin && reusedChrome);
+        const connection = await connectWithNewTab(chrome.port, logger, "about:blank", chromeHost, {
+            fallbackToDefault: !strictTabIsolation,
+            retries: strictTabIsolation ? 3 : 0,
+            retryDelayMs: 500,
+        });
+        client = connection.client;
+        isolatedTargetId = connection.targetId ?? null;
+        if (tabLease && isolatedTargetId) {
+            await tabLease.update({
+                chromeHost,
+                chromePort: chrome.port,
+                chromeTargetId: isolatedTargetId,
+                tabUrl: projectUrl,
+            });
+        }
+        const disconnectPromise = new Promise((_, reject) => {
+            client?.on("disconnect", () => {
+                connectionClosedUnexpectedly = true;
+                reject(new Error("Chrome window closed before Project Sources finished."));
+            });
+        });
+        const raceWithDisconnect = (promise) => Promise.race([promise, disconnectPromise]);
+        const { Network, Page, Runtime, Input, DOM } = client;
+        if (!config.headless && config.hideWindow) {
+            await hideChromeWindow(chrome, logger);
+        }
+        const domainEnablers = [Network.enable({}), Page.enable(), Runtime.enable()];
+        if (DOM && typeof DOM.enable === "function") {
+            domainEnablers.push(DOM.enable());
+        }
+        await Promise.all(domainEnablers);
+        removeDialogHandler = installJavaScriptDialogAutoDismissal(Page, logger);
+        if (!manualLogin) {
+            await Network.clearBrowserCookies();
+        }
+        const appliedCookies = await applyProjectSourcesCookies({
+            config,
+            network: Network,
+            manualLogin,
+            logger,
+        });
+        await raceWithDisconnect(navigateToChatGPT(Page, Runtime, CHATGPT_URL, logger));
+        await raceWithDisconnect(waitForProjectSourcesLogin({
+            runtime: Runtime,
+            logger,
+            appliedCookies,
+            manualLogin,
+            timeoutMs: config.timeoutMs,
+        }));
+        await raceWithDisconnect(navigateToChatGPT(Page, Runtime, projectUrl, logger));
+        await raceWithDisconnect(openProjectSourcesTab(Runtime, Input, config.inputTimeoutMs, logger));
+        await raceWithDisconnect(waitForProjectSourcesReady(Runtime, config.inputTimeoutMs, logger));
+        const sourcesBefore = await raceWithDisconnect(waitForProjectSourcesListSettled(Runtime, config.inputTimeoutMs, logger));
+        let sourcesAfter = sourcesBefore;
+        if (operation === "add") {
+            sourcesAfter = await raceWithDisconnect(uploadProjectSources({ runtime: Runtime, dom: DOM, input: Input }, files, logger, config.timeoutMs));
+        }
+        const added = operation === "add" ? diffAddedProjectSources(sourcesBefore, sourcesAfter) : [];
+        completed = true;
+        return {
+            status: "ok",
+            operation,
+            projectUrl,
+            dryRun: false,
+            sourcesBefore,
+            sourcesAfter,
+            plannedUploads,
+            added,
+            warnings,
+            tookMs: Date.now() - startedAt,
+        };
+    }
+    finally {
+        removeDialogHandler?.();
+        removeTerminationHooks?.();
+        const chromeHost = chrome?.host ?? "127.0.0.1";
+        try {
+            await client?.close();
+        }
+        catch {
+            // ignore close failures
+        }
+        if (completed && isolatedTargetId && chrome?.port) {
+            await closeTab(chrome.port, isolatedTargetId, logger, chromeHost).catch(() => undefined);
+        }
+        let keepBrowserOpen = effectiveKeepBrowser;
+        let cleanupProfileLock = null;
+        let terminatedRecordedChrome = false;
+        if (!keepBrowserOpen && manualLogin && tabLease) {
+            const cleanupLockTimeoutMs = Math.max(0, config.profileLockTimeoutMs ?? 0);
+            if (cleanupLockTimeoutMs > 0) {
+                cleanupProfileLock = await acquireProfileRunLock(userDataDir, {
+                    timeoutMs: cleanupLockTimeoutMs,
+                    logger,
+                    sessionId: "project-sources",
+                }).catch(() => null);
+            }
+            keepBrowserOpen = await hasOtherActiveBrowserTabLeases(userDataDir, tabLease.id).catch(() => false);
+            if (keepBrowserOpen) {
+                logger("[browser] Other ChatGPT tab leases still active; leaving shared Chrome running.");
+            }
+            else if (reusedChrome && !connectionClosedUnexpectedly) {
+                keepBrowserOpen = true;
+                logger("[browser] Reused shared Chrome; leaving browser process running.");
+            }
+        }
+        if (tabLease) {
+            const handle = tabLease;
+            tabLease = null;
+            await handle.release().catch(() => undefined);
+        }
+        if (!keepBrowserOpen && chrome) {
+            if (!connectionClosedUnexpectedly) {
+                try {
+                    if (!terminatedRecordedChrome) {
+                        await chrome.kill();
+                    }
+                }
+                catch {
+                    // ignore kill failures
+                }
+            }
+            if (manualLogin) {
+                const shouldCleanup = await shouldCleanupManualLoginProfileState(userDataDir, logger.verbose ? logger : undefined, { connectionClosedUnexpectedly, host: chrome.host ?? "127.0.0.1" });
+                if (shouldCleanup) {
+                    await cleanupStaleProfileState(userDataDir, logger, { lockRemovalMode: "never" }).catch(() => undefined);
+                }
+            }
+            else {
+                await rm(userDataDir, { recursive: true, force: true }).catch(() => undefined);
+            }
+        }
+        else if (chrome) {
+            try {
+                chrome.process?.unref();
+            }
+            catch {
+                // best effort
+            }
+            logger(`Chrome left running on port ${chrome.port} with profile ${userDataDir}`);
+        }
+        if (cleanupProfileLock) {
+            await cleanupProfileLock.release().catch(() => undefined);
+        }
+    }
+}
+async function applyProjectSourcesCookies({ config, network, manualLogin, logger, }) {
+    const manualLoginCookieSync = manualLogin && Boolean(config.manualLoginCookieSync);
+    const cookieSyncEnabled = config.cookieSync && (!manualLogin || manualLoginCookieSync);
+    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)");
+        return 0;
+    }
+    const cookieCount = await syncCookies(network, config.url, config.chromeProfile, logger, {
+        allowErrors: config.allowCookieErrors ?? false,
+        filterNames: config.cookieNames ?? undefined,
+        inlineCookies: config.inlineCookies ?? undefined,
+        cookiePath: config.chromeCookiePath ?? undefined,
+        waitMs: config.cookieSyncWaitMs ?? 0,
+    });
+    logger(cookieCount > 0
+        ? config.inlineCookies
+            ? `Applied ${cookieCount} inline cookies`
+            : `Copied ${cookieCount} cookies from Chrome profile ${config.chromeProfile ?? "Default"}`
+        : "No Chrome cookies found; continuing without session reuse");
+    return cookieCount;
+}
+async function waitForProjectSourcesLogin({ runtime, logger, appliedCookies, manualLogin, timeoutMs, }) {
+    if (!manualLogin) {
+        await ensureLoggedIn(runtime, logger, { appliedCookies });
+        return;
+    }
+    const deadline = Date.now() + Math.min(timeoutMs ?? 1_200_000, 20 * 60_000);
+    let lastNotice = 0;
+    while (Date.now() < deadline) {
+        try {
+            await ensureLoggedIn(runtime, logger, { appliedCookies });
+            return;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const retryable = message.toLowerCase().includes("login button") ||
+                message.toLowerCase().includes("session not detected");
+            if (!retryable) {
+                throw error;
+            }
+            const now = Date.now();
+            if (now - lastNotice > 5000) {
+                logger("Manual login mode: please sign into chatgpt.com in the opened Chrome window; waiting for session to appear...");
+                lastNotice = now;
+            }
+            await delay(1000);
+        }
+    }
+    throw new Error("Manual login mode timed out waiting for ChatGPT session; please sign in and retry.");
+}
+async function acquireManualLoginChromeForProjectSources(userDataDir, config, logger) {
+    const lockTimeoutMs = Math.max(0, config.profileLockTimeoutMs ?? 0);
+    let launchLock = null;
+    if (lockTimeoutMs > 0) {
+        launchLock = await acquireProfileRunLock(userDataDir, {
+            timeoutMs: lockTimeoutMs,
+            logger,
+            sessionId: "project-sources",
+        });
+    }
+    try {
+        const reusedChrome = await maybeReuseProjectSourcesChrome(userDataDir, logger, {
+            waitForPortMs: config.reuseChromeWaitMs,
+        });
+        const chrome = reusedChrome ??
+            (await launchChrome({
+                ...config,
+                remoteChrome: null,
+            }, userDataDir, logger));
+        if (chrome.port) {
+            await writeDevToolsActivePort(userDataDir, chrome.port);
+            if (!reusedChrome && chrome.pid) {
+                await writeChromePid(userDataDir, chrome.pid);
+            }
+        }
+        return { chrome, reusedChrome };
+    }
+    finally {
+        await launchLock?.release().catch(() => undefined);
+    }
+}
+async function maybeReuseProjectSourcesChrome(userDataDir, logger, options = {}) {
+    const waitForPortMs = Math.max(0, options.waitForPortMs ?? 0);
+    let port = await readDevToolsPort(userDataDir);
+    if (!port && waitForPortMs > 0) {
+        const deadline = Date.now() + waitForPortMs;
+        logger(`Waiting up to ${Math.round(waitForPortMs / 1000)}s for shared Chrome to appear...`);
+        while (!port && Date.now() < deadline) {
+            await delay(250);
+            port = await readDevToolsPort(userDataDir);
+        }
+    }
+    let pid = await readChromePid(userDataDir);
+    if (!port) {
+        const discovered = await findRunningChromeDebugTargetForProfile(userDataDir);
+        if (!discovered) {
+            return null;
+        }
+        const probe = await verifyDevToolsReachable({ port: discovered.port });
+        if (!probe.ok) {
+            logger(`Discovered Chrome for ${userDataDir} on port ${discovered.port} but it was unreachable (${probe.error}); launching new Chrome.`);
+            return null;
+        }
+        await writeDevToolsActivePort(userDataDir, discovered.port);
+        await writeChromePid(userDataDir, discovered.pid);
+        port = discovered.port;
+        pid = discovered.pid;
+        logger(`Discovered running Chrome for ${userDataDir}; reusing (DevTools port ${port}, pid ${pid})`);
+        return { port, pid, kill: async () => { }, process: undefined };
+    }
+    const probe = await verifyDevToolsReachable({ port });
+    if (!probe.ok) {
+        logger(`Recorded Chrome DevTools port ${port} is stale (${probe.error}); launching new Chrome.`);
+        await cleanupStaleProfileState(userDataDir, logger, { lockRemovalMode: "if_oracle_pid_dead" });
+        return null;
+    }
+    logger(`Reusing running Chrome on port ${port} with profile ${userDataDir}`);
+    return {
+        port,
+        pid: pid ?? undefined,
+        kill: async () => { },
+        process: undefined,
+    };
+}