@skills-store/rednote 0.1.0 → 0.1.2

package/dist/utils/browser-core.js

@@ -0,0 +1,705 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import net from 'node:net';
+import { execFile, spawn, spawnSync } from 'node:child_process';
+import { promisify } from 'node:util';
+import { fileURLToPath } from 'node:url';
+import chromePath from 'chrome-paths';
+import { getEdgePath } from 'edge-paths';
+import psList from 'ps-list';
+import { portToPid } from 'pid-port';
+import { stringifyError } from './browser-cli.js';
+const execFileAsync = promisify(execFile);
+const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
+const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
+export const PACKAGE_ROOT = path.resolve(SCRIPT_DIR, '../..');
+export const SKILLS_ROUTER_HOME = path.join(os.homedir(), '.skills-router');
+export const REDNOTE_STORAGE_ROOT = path.join(SKILLS_ROUTER_HOME, 'rednote');
+export const INSTANCES_DIR = path.join(REDNOTE_STORAGE_ROOT, 'instances');
+export const INSTANCE_STORE_PATH = path.join(INSTANCES_DIR, 'data.json');
+export const LEGACY_PACKAGE_INSTANCES_DIR = path.join(PACKAGE_ROOT, 'instances');
+export function normalizePath(inputPath) {
+    let resolved = path.resolve(inputPath);
+    if (process.platform === 'win32') {
+        resolved = resolved.toLowerCase();
+    }
+    return resolved.replace(/[\\/]+$/, '');
+}
+function unique(values) {
+    return [
+        ...new Set(values)
+    ];
+}
+function defaultInstanceStore() {
+    return {
+        version: 1,
+        lastConnect: null,
+        instances: []
+    };
+}
+function currentManagedInstanceDir(name) {
+    return path.join(INSTANCES_DIR, name);
+}
+function legacyManagedInstanceDirs(name) {
+    return [
+        path.join(LEGACY_PACKAGE_INSTANCES_DIR, name),
+        path.resolve(PACKAGE_ROOT, '../../skills/rednote/instances', name)
+    ];
+}
+function resolvePersistedInstanceUserDataDir(name, userDataDir) {
+    const normalizedInput = normalizePath(userDataDir);
+    const managedCurrentDir = currentManagedInstanceDir(name);
+    if (normalizedInput === normalizePath(managedCurrentDir)) {
+        return managedCurrentDir;
+    }
+    if (legacyManagedInstanceDirs(name).some((dirPath)=>normalizedInput === normalizePath(dirPath))) {
+        return managedCurrentDir;
+    }
+    const instancesSuffix = path.sep + 'instances' + path.sep + name;
+    if (normalizedInput.endsWith(instancesSuffix)) {
+        return managedCurrentDir;
+    }
+    return userDataDir;
+}
+export function exists(filePath) {
+    try {
+        fs.accessSync(filePath, fs.constants.F_OK);
+        return true;
+    } catch  {
+        return false;
+    }
+}
+function migrateLegacyInstanceStoreIfNeeded() {
+    if (normalizePath(LEGACY_PACKAGE_INSTANCES_DIR) === normalizePath(INSTANCES_DIR)) {
+        return;
+    }
+    if (exists(INSTANCE_STORE_PATH) || !exists(LEGACY_PACKAGE_INSTANCES_DIR)) {
+        return;
+    }
+    fs.mkdirSync(REDNOTE_STORAGE_ROOT, {
+        recursive: true
+    });
+    fs.cpSync(LEGACY_PACKAGE_INSTANCES_DIR, INSTANCES_DIR, {
+        recursive: true,
+        force: false,
+        errorOnExist: false
+    });
+}
+function ensureInstanceStoreDir() {
+    migrateLegacyInstanceStoreIfNeeded();
+    fs.mkdirSync(INSTANCES_DIR, {
+        recursive: true
+    });
+}
+export function getRednoteEnvironmentInfo() {
+    return {
+        packageRoot: PACKAGE_ROOT,
+        homeDir: os.homedir(),
+        platform: process.platform,
+        nodeVersion: process.version,
+        storageHome: SKILLS_ROUTER_HOME,
+        storageRoot: REDNOTE_STORAGE_ROOT,
+        instancesDir: INSTANCES_DIR,
+        instanceStorePath: INSTANCE_STORE_PATH,
+        legacyPackageInstancesDir: LEGACY_PACKAGE_INSTANCES_DIR
+    };
+}
+export function readInstanceStore() {
+    ensureInstanceStoreDir();
+    if (!exists(INSTANCE_STORE_PATH)) {
+        return defaultInstanceStore();
+    }
+    try {
+        const raw = fs.readFileSync(INSTANCE_STORE_PATH, 'utf8');
+        const parsed = JSON.parse(raw);
+        return {
+            version: 1,
+            lastConnect: parsed.lastConnect && (parsed.lastConnect.scope === 'default' || parsed.lastConnect.scope === 'custom') && typeof parsed.lastConnect.name === 'string' && typeof parsed.lastConnect.browser === 'string' ? {
+                scope: parsed.lastConnect.scope,
+                name: parsed.lastConnect.name,
+                browser: parsed.lastConnect.browser
+            } : null,
+            instances: Array.isArray(parsed.instances) ? parsed.instances.flatMap((item)=>{
+                if (item && typeof item.name === 'string' && typeof item.browser === 'string' && typeof item.userDataDir === 'string' && typeof item.createdAt === 'string') {
+                    return [
+                        {
+                            name: item.name,
+                            browser: item.browser,
+                            userDataDir: resolvePersistedInstanceUserDataDir(item.name, item.userDataDir),
+                            createdAt: item.createdAt,
+                            remoteDebuggingPort: typeof item.remoteDebuggingPort === 'number' && Number.isInteger(item.remoteDebuggingPort) && item.remoteDebuggingPort > 0 ? item.remoteDebuggingPort : undefined
+                        }
+                    ];
+                }
+                return [];
+            }) : []
+        };
+    } catch  {
+        return defaultInstanceStore();
+    }
+}
+export function writeInstanceStore(store) {
+    ensureInstanceStoreDir();
+    fs.writeFileSync(INSTANCE_STORE_PATH, `${JSON.stringify(store, null, 2)}
+`, 'utf8');
+}
+export function updateInstanceRemoteDebuggingPort(name, remoteDebuggingPort) {
+    const store = readInstanceStore();
+    const instanceName = validateInstanceName(name);
+    const nextInstances = store.instances.map((instance)=>instance.name === instanceName ? {
+            ...instance,
+            remoteDebuggingPort
+        } : instance);
+    if (!nextInstances.some((instance)=>instance.name === instanceName)) {
+        throw new Error(`Instance not found: ${instanceName}`);
+    }
+    writeInstanceStore({
+        ...store,
+        instances: nextInstances
+    });
+}
+export async function getRandomAvailablePort() {
+    return await new Promise((resolve, reject)=>{
+        const server = net.createServer();
+        server.once('error', reject);
+        server.listen(0, '127.0.0.1', ()=>{
+            const address = server.address();
+            if (!address || typeof address === 'string') {
+                server.close(()=>reject(new Error('Failed to allocate a random port')));
+                return;
+            }
+            server.close((error)=>{
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                resolve(address.port);
+            });
+        });
+    });
+}
+export function customInstanceUserDataDir(name) {
+    return path.join(INSTANCES_DIR, name);
+}
+export function isSubPath(parentPath, childPath) {
+    const normalizedParent = normalizePath(parentPath);
+    const normalizedChild = normalizePath(childPath);
+    return normalizedChild === normalizedParent || normalizedChild.startsWith(`${normalizedParent}${path.sep}`);
+}
+export function validateInstanceName(name) {
+    const trimmed = name.trim();
+    if (!trimmed) {
+        throw new Error('Instance name cannot be empty');
+    }
+    if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]{1,63}$/.test(trimmed)) {
+        throw new Error('Instance name must match /^[a-zA-Z0-9][a-zA-Z0-9._-]{1,63}$/');
+    }
+    return trimmed;
+}
+export function isLastConnectMatch(lastConnect, scope, instanceName, browser) {
+    return Boolean(lastConnect && lastConnect.scope === scope && lastConnect.name === instanceName && lastConnect.browser === browser);
+}
+export function updateLastConnect(lastConnect) {
+    const store = readInstanceStore();
+    writeInstanceStore({
+        ...store,
+        lastConnect
+    });
+}
+function basenameMatches(procName, names) {
+    const base = path.basename(procName).toLowerCase();
+    return names.some((name)=>base === name.toLowerCase());
+}
+function spawnSyncText(command, args) {
+    const result = spawnSync(command, args, {
+        encoding: 'utf8',
+        windowsHide: true
+    });
+    if (result.error) {
+        throw result.error;
+    }
+    if (result.status !== 0) {
+        throw new Error(result.stderr || `Command failed: ${command} ${args.join(' ')}`);
+    }
+    return result.stdout;
+}
+function commandExists(command) {
+    try {
+        const probe = process.platform === 'win32' ? 'where' : 'command';
+        const args = process.platform === 'win32' ? [
+            command
+        ] : [
+            '-v',
+            command
+        ];
+        const result = spawnSync(probe, args, {
+            stdio: 'ignore',
+            shell: process.platform !== 'win32'
+        });
+        return result.status === 0;
+    } catch  {
+        return false;
+    }
+}
+function findExecutableInPath(commands) {
+    for (const command of commands){
+        if (!commandExists(command)) {
+            continue;
+        }
+        try {
+            if (process.platform === 'win32') {
+                const output = spawnSyncText('where', [
+                    command
+                ]).trim().split(/\r?\n/)[0];
+                if (output) {
+                    return output;
+                }
+            } else {
+                const output = spawnSyncText('command', [
+                    '-v',
+                    command
+                ]);
+                const resolved = output.trim().split(/\r?\n/)[0];
+                if (resolved) {
+                    return resolved;
+                }
+            }
+        } catch  {
+            continue;
+        }
+    }
+    return null;
+}
+export function browserSpecs() {
+    const homeDir = os.homedir();
+    return [
+        {
+            type: 'chrome',
+            displayName: 'Google Chrome',
+            executableCandidates: process.platform === 'darwin' ? [
+                '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome'
+            ] : process.platform === 'win32' ? [
+                'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe',
+                'C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe'
+            ] : [
+                '/usr/bin/google-chrome',
+                '/usr/bin/google-chrome-stable'
+            ],
+            userDataDir: process.platform === 'darwin' ? path.join(homeDir, 'Library/Application Support/Google/Chrome') : process.platform === 'win32' ? path.join(process.env.LOCALAPPDATA || path.join(homeDir, 'AppData/Local'), 'Google/Chrome/User Data') : path.join(homeDir, '.config/google-chrome'),
+            processNames: [
+                'Google Chrome',
+                'Google Chrome Helper',
+                'chrome.exe',
+                'google-chrome',
+                'google-chrome-stable'
+            ],
+            pathCommands: [
+                'google-chrome',
+                'google-chrome-stable'
+            ]
+        },
+        {
+            type: 'edge',
+            displayName: 'Microsoft Edge',
+            executableCandidates: process.platform === 'darwin' ? [
+                '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge'
+            ] : process.platform === 'win32' ? [
+                'C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe',
+                'C:\\Program Files\\Microsoft\\Edge\\Application\\msedge.exe'
+            ] : [
+                '/usr/bin/microsoft-edge',
+                '/usr/bin/microsoft-edge-stable'
+            ],
+            userDataDir: process.platform === 'darwin' ? path.join(homeDir, 'Library/Application Support/Microsoft Edge') : process.platform === 'win32' ? path.join(process.env.LOCALAPPDATA || path.join(homeDir, 'AppData/Local'), 'Microsoft/Edge/User Data') : path.join(homeDir, '.config/microsoft-edge'),
+            processNames: [
+                'Microsoft Edge',
+                'msedge.exe',
+                'microsoft-edge',
+                'microsoft-edge-stable'
+            ],
+            pathCommands: [
+                'microsoft-edge',
+                'microsoft-edge-stable'
+            ]
+        },
+        {
+            type: 'chromium',
+            displayName: 'Chromium',
+            executableCandidates: process.platform === 'darwin' ? [
+                '/Applications/Chromium.app/Contents/MacOS/Chromium'
+            ] : process.platform === 'win32' ? [
+                'C:\\Program Files\\Chromium\\Application\\chrome.exe',
+                'C:\\Program Files (x86)\\Chromium\\Application\\chrome.exe'
+            ] : [
+                '/usr/bin/chromium',
+                '/usr/bin/chromium-browser'
+            ],
+            userDataDir: process.platform === 'darwin' ? path.join(homeDir, 'Library/Application Support/Chromium') : process.platform === 'win32' ? path.join(process.env.LOCALAPPDATA || path.join(homeDir, 'AppData/Local'), 'Chromium/User Data') : path.join(homeDir, '.config/chromium'),
+            processNames: [
+                'Chromium',
+                'chromium',
+                'chromium-browser',
+                'chrome.exe'
+            ],
+            pathCommands: [
+                'chromium',
+                'chromium-browser'
+            ]
+        },
+        {
+            type: 'brave',
+            displayName: 'Brave',
+            executableCandidates: process.platform === 'darwin' ? [
+                '/Applications/Brave Browser.app/Contents/MacOS/Brave Browser'
+            ] : process.platform === 'win32' ? [
+                'C:\\Program Files\\BraveSoftware\\Brave-Browser\\Application\\brave.exe',
+                'C:\\Program Files (x86)\\BraveSoftware\\Brave-Browser\\Application\\brave.exe'
+            ] : [
+                '/usr/bin/brave-browser',
+                '/usr/bin/brave'
+            ],
+            userDataDir: process.platform === 'darwin' ? path.join(homeDir, 'Library/Application Support/BraveSoftware/Brave-Browser') : process.platform === 'win32' ? path.join(process.env.LOCALAPPDATA || path.join(homeDir, 'AppData/Local'), 'BraveSoftware/Brave-Browser/User Data') : path.join(homeDir, '.config/BraveSoftware/Brave-Browser'),
+            processNames: [
+                'Brave Browser',
+                'brave.exe',
+                'brave-browser',
+                'brave'
+            ],
+            pathCommands: [
+                'brave-browser',
+                'brave'
+            ]
+        }
+    ];
+}
+export function resolveExecutablePath(spec) {
+    if (spec.type === 'chrome' && chromePath?.chrome) {
+        return chromePath.chrome;
+    }
+    if (spec.type === 'edge') {
+        const edge = getEdgePath();
+        if (edge) {
+            return edge;
+        }
+    }
+    for (const candidate of spec.executableCandidates){
+        if (exists(candidate)) {
+            return candidate;
+        }
+    }
+    return findExecutableInPath(spec.pathCommands);
+}
+export async function listProcesses() {
+    try {
+        return (await psList()).map((proc)=>({
+                pid: proc.pid,
+                name: proc.name,
+                cmdline: proc.cmd ?? ''
+            }));
+    } catch  {
+        return [];
+    }
+}
+function extractUserDataDirFromCmdline(cmdline) {
+    const patterns = [
+        /--user-data-dir=(?:"([^"]+)"|'([^']+)'|(.+?))(?=\s--[a-zA-Z]|$)/i,
+        /--user-data-dir\s+(?:"([^"]+)"|'([^']+)'|(.+?))(?=\s--[a-zA-Z]|$)/i
+    ];
+    for (const pattern of patterns){
+        const match = cmdline.match(pattern);
+        if (!match) {
+            continue;
+        }
+        const value = match[1] || match[2] || match[3] || null;
+        return value ? value.trim() : null;
+    }
+    return null;
+}
+function extractRemoteDebuggingPortFromCmdline(cmdline) {
+    const patterns = [
+        /--remote-debugging-port=(\d+)/i,
+        /--remote-debugging-port\s+(\d+)/i
+    ];
+    for (const pattern of patterns){
+        const match = cmdline.match(pattern);
+        if (match) {
+            return Number(match[1]);
+        }
+    }
+    return null;
+}
+async function findPidsUsingFiles(filePaths) {
+    if (process.platform === 'win32') {
+        return [];
+    }
+    if (!commandExists('lsof')) {
+        return [];
+    }
+    try {
+        const stdout = await execFileAsync('lsof', [
+            '-F',
+            'p',
+            '--',
+            ...filePaths
+        ], {
+            encoding: 'utf8',
+            maxBuffer: 1024 * 1024
+        });
+        return unique(stdout.stdout.split(/\r?\n/).flatMap((line)=>line.startsWith('p') ? [
+                Number(line.slice(1))
+            ] : []).filter((pid)=>Number.isInteger(pid) && pid > 0));
+    } catch  {
+        return [];
+    }
+}
+export async function findListeningPortsByPid(pid) {
+    try {
+        const ports = await portToPid(pid, 'tcp');
+        return unique(ports.filter((port)=>Number.isInteger(port) && port > 0));
+    } catch  {
+        return [];
+    }
+}
+function lockFilesFor(userDataDir) {
+    return [
+        path.join(userDataDir, 'SingletonLock'),
+        path.join(userDataDir, 'SingletonCookie'),
+        path.join(userDataDir, 'SingletonSocket')
+    ].filter((filePath)=>exists(filePath));
+}
+function processMatchesBrowser(spec, executablePath, userDataDir, proc) {
+    if (!basenameMatches(proc.name, spec.processNames) && !proc.cmdline.includes(executablePath)) {
+        return false;
+    }
+    const cmdlineUserDataDir = extractUserDataDirFromCmdline(proc.cmdline);
+    if (!cmdlineUserDataDir) {
+        return normalizePath(userDataDir) === normalizePath(spec.userDataDir);
+    }
+    return normalizePath(cmdlineUserDataDir) === normalizePath(userDataDir);
+}
+function pickPrimaryProcess(processes) {
+    return processes.find((proc)=>!proc.cmdline.includes('--type=')) ?? processes.find((proc)=>proc.cmdline.includes('--remote-debugging-port=')) ?? processes[0] ?? null;
+}
+export function removeLockFiles(lockFiles) {
+    for (const filePath of lockFiles){
+        try {
+            fs.rmSync(filePath, {
+                force: true
+            });
+        } catch  {}
+    }
+}
+export function toBrowserInstanceInfo(instance) {
+    return {
+        type: instance.type,
+        name: instance.name,
+        executablePath: instance.executablePath,
+        userDataDir: instance.userDataDir,
+        exists: instance.exists,
+        inUse: instance.inUse,
+        pid: instance.pid,
+        lockFiles: instance.lockFiles,
+        matchedProcess: instance.matchedProcess,
+        staleLock: instance.staleLock,
+        remotePort: instance.remotePort
+    };
+}
+export async function inspectBrowserInstance(spec, executablePath, userDataDir) {
+    const resolvedExecutablePath = executablePath || resolveExecutablePath(spec) || spec.executableCandidates[0] || spec.displayName;
+    const resolvedUserDataDir = userDataDir ? path.resolve(userDataDir) : spec.userDataDir;
+    const lockFiles = lockFilesFor(resolvedUserDataDir);
+    const processes = await listProcesses();
+    const matchedProcesses = processes.filter((proc)=>processMatchesBrowser(spec, resolvedExecutablePath, resolvedUserDataDir, proc));
+    const primaryProcess = pickPrimaryProcess(matchedProcesses);
+    const pids = unique([
+        ...matchedProcesses.map((proc)=>proc.pid),
+        ...lockFiles.length > 0 ? await findPidsUsingFiles(lockFiles) : []
+    ]);
+    const listeningPorts = unique((await Promise.all(pids.map((pid)=>findListeningPortsByPid(pid)))).flat());
+    const cmdlineRemotePort = primaryProcess ? extractRemoteDebuggingPortFromCmdline(primaryProcess.cmdline) : null;
+    const remotePort = cmdlineRemotePort ?? listeningPorts[0] ?? null;
+    return {
+        type: spec.type,
+        name: spec.type,
+        executablePath: resolvedExecutablePath,
+        userDataDir: resolvedUserDataDir,
+        exists: exists(resolvedUserDataDir),
+        inUse: pids.length > 0,
+        pid: primaryProcess?.pid ?? pids[0] ?? null,
+        pids,
+        lockFiles,
+        matchedProcess: primaryProcess,
+        matchedProcesses,
+        staleLock: lockFiles.length > 0 && pids.length === 0,
+        remotePort
+    };
+}
+export function isDefaultInstanceName(name) {
+    return browserSpecs().some((spec)=>spec.type === name);
+}
+export function findSpec(browserType) {
+    const spec = browserSpecs().find((item)=>item.type === browserType);
+    if (!spec) {
+        throw new Error(`Unsupported browser type: ${browserType}`);
+    }
+    return spec;
+}
+export async function getPidsListeningOnPort(port) {
+    try {
+        return unique(await portToPid(port, 'tcp'));
+    } catch  {
+        return [];
+    }
+}
+function isPidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    } catch  {
+        return false;
+    }
+}
+async function closePidGracefully(pid) {
+    try {
+        process.kill(pid, 'SIGTERM');
+        return true;
+    } catch  {
+        return false;
+    }
+}
+async function killPidForce(pid) {
+    try {
+        process.kill(pid, 'SIGKILL');
+        return true;
+    } catch  {
+        return false;
+    }
+}
+async function waitForPidExit(pid, timeoutMs = 8_000, intervalMs = 250) {
+    const deadline = Date.now() + timeoutMs;
+    while(Date.now() < deadline){
+        if (!isPidAlive(pid)) {
+            return true;
+        }
+        await sleep(intervalMs);
+    }
+    return !isPidAlive(pid);
+}
+export async function waitForPortToClose(port, timeoutMs = 8_000) {
+    const deadline = Date.now() + timeoutMs;
+    while(Date.now() < deadline){
+        if ((await getPidsListeningOnPort(port)).length === 0) {
+            return true;
+        }
+        await sleep(250);
+    }
+    return (await getPidsListeningOnPort(port)).length === 0;
+}
+export async function getCdpWebSocketUrl(port) {
+    try {
+        const response = await fetch(`http://127.0.0.1:${port}/json/version`);
+        if (!response.ok) {
+            return null;
+        }
+        const data = await response.json();
+        return data.webSocketDebuggerUrl || null;
+    } catch  {
+        return null;
+    }
+}
+export async function waitForCdpReady(port, timeoutMs = 15_000) {
+    const deadline = Date.now() + timeoutMs;
+    while(Date.now() < deadline){
+        const wsUrl = await getCdpWebSocketUrl(port);
+        if (wsUrl) {
+            return wsUrl;
+        }
+        await sleep(250);
+    }
+    return null;
+}
+async function waitForPortBound(port, timeoutMs = 5_000) {
+    const deadline = Date.now() + timeoutMs;
+    while(Date.now() < deadline){
+        await new Promise((resolve)=>{
+            const socket = net.connect({
+                host: '127.0.0.1',
+                port
+            }, ()=>{
+                socket.end();
+                resolve();
+            });
+            socket.on('error', ()=>resolve());
+        });
+        if ((await getPidsListeningOnPort(port)).length > 0) {
+            return true;
+        }
+        await sleep(200);
+    }
+    return false;
+}
+async function loadPlaywrightChromium() {
+    const playwright = await import('playwright-core');
+    return playwright.chromium;
+}
+export async function connectOverCdp(endpoint) {
+    const chromium = await loadPlaywrightChromium();
+    const url = typeof endpoint === 'number' ? `http://127.0.0.1:${endpoint}` : endpoint;
+    const browser = await chromium.connectOverCDP(url);
+    return browser;
+}
+export function ensureDir(dirPath) {
+    fs.mkdirSync(dirPath, {
+        recursive: true
+    });
+    return dirPath;
+}
+export function resolveUserDataDir(spec, options) {
+    return ensureDir(options.userDataDir ? path.resolve(options.userDataDir) : spec.userDataDir);
+}
+export function isBrowserProcess(spec, proc) {
+    return basenameMatches(proc.name, spec.processNames);
+}
+export async function closeProcessesByPid(pids, timeoutMs) {
+    const closedPids = [];
+    for (const pid of unique(pids.filter((value)=>Number.isInteger(value) && value > 0))){
+        if (!isPidAlive(pid)) {
+            closedPids.push(pid);
+            continue;
+        }
+        await closePidGracefully(pid);
+        if (!await waitForPidExit(pid, timeoutMs)) {
+            await killPidForce(pid);
+            await waitForPidExit(pid, timeoutMs);
+        }
+        if (!isPidAlive(pid)) {
+            closedPids.push(pid);
+        }
+    }
+    return closedPids;
+}
+export async function launchBrowser(spec, executablePath, userDataDir, port, startupUrl) {
+    const browserProcess = spawn(executablePath, [
+        `--remote-debugging-port=${port}`,
+        `--user-data-dir=${userDataDir}`,
+        '--no-first-run',
+        '--no-default-browser-check',
+        startupUrl
+    ], {
+        detached: process.platform !== 'win32',
+        stdio: 'ignore',
+        windowsHide: true,
+        env: process.env
+    });
+    browserProcess.unref();
+    await waitForPortBound(port, 5_000);
+    const wsUrl = await waitForCdpReady(port);
+    if (!wsUrl) {
+        throw new Error(`Browser started but CDP did not become ready on port ${port}`);
+    }
+    return {
+        pid: browserProcess.pid ?? null,
+        wsUrl
+    };
+}