@steipete/oracle 0.9.0 → 0.10.0

package/dist/oracle/src/sessionManager.js

@@ -1,205 +0,0 @@
-import os from 'node:os';
-import path from 'node:path';
-import fs from 'node:fs/promises';
-import { createWriteStream } from 'node:fs';
-const ORACLE_HOME = process.env.ORACLE_HOME_DIR ?? path.join(os.homedir(), '.oracle');
-const SESSIONS_DIR = path.join(ORACLE_HOME, 'sessions');
-const MAX_STATUS_LIMIT = 1000;
-const DEFAULT_SLUG = 'session';
-const MAX_SLUG_WORDS = 5;
-const MIN_CUSTOM_SLUG_WORDS = 3;
-async function ensureDir(dirPath) {
-    await fs.mkdir(dirPath, { recursive: true });
-}
-export async function ensureSessionStorage() {
-    await ensureDir(SESSIONS_DIR);
-}
-function slugify(text, maxWords = MAX_SLUG_WORDS) {
-    const normalized = text?.toLowerCase() ?? '';
-    const words = normalized.match(/[a-z0-9]+/g) ?? [];
-    const trimmed = words.slice(0, maxWords);
-    return trimmed.length > 0 ? trimmed.join('-') : DEFAULT_SLUG;
-}
-function countSlugWords(slug) {
-    return slug.split('-').filter(Boolean).length;
-}
-function normalizeCustomSlug(candidate) {
-    const slug = slugify(candidate, MAX_SLUG_WORDS);
-    const wordCount = countSlugWords(slug);
-    if (wordCount < MIN_CUSTOM_SLUG_WORDS || wordCount > MAX_SLUG_WORDS) {
-        throw new Error(`Custom slug must include between ${MIN_CUSTOM_SLUG_WORDS} and ${MAX_SLUG_WORDS} words.`);
-    }
-    return slug;
-}
-export function createSessionId(prompt, customSlug) {
-    if (customSlug) {
-        return normalizeCustomSlug(customSlug);
-    }
-    return slugify(prompt);
-}
-function sessionDir(id) {
-    return path.join(SESSIONS_DIR, id);
-}
-function metaPath(id) {
-    return path.join(sessionDir(id), 'session.json');
-}
-function logPath(id) {
-    return path.join(sessionDir(id), 'output.log');
-}
-function requestPath(id) {
-    return path.join(sessionDir(id), 'request.json');
-}
-async function fileExists(targetPath) {
-    try {
-        await fs.access(targetPath);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function ensureUniqueSessionId(baseSlug) {
-    let candidate = baseSlug;
-    let suffix = 2;
-    while (await fileExists(sessionDir(candidate))) {
-        candidate = `${baseSlug}-${suffix}`;
-        suffix += 1;
-    }
-    return candidate;
-}
-export async function initializeSession(options, cwd) {
-    await ensureSessionStorage();
-    const baseSlug = createSessionId(options.prompt || DEFAULT_SLUG, options.slug);
-    const sessionId = await ensureUniqueSessionId(baseSlug);
-    const dir = sessionDir(sessionId);
-    await ensureDir(dir);
-    const mode = options.mode ?? 'api';
-    const browserConfig = options.browserConfig;
-    const metadata = {
-        id: sessionId,
-        createdAt: new Date().toISOString(),
-        status: 'pending',
-        promptPreview: (options.prompt || '').slice(0, 160),
-        model: options.model,
-        cwd,
-        mode,
-        browser: browserConfig ? { config: browserConfig } : undefined,
-        options: {
-            prompt: options.prompt,
-            file: options.file ?? [],
-            model: options.model,
-            maxInput: options.maxInput,
-            system: options.system,
-            maxOutput: options.maxOutput,
-            silent: options.silent,
-            filesReport: options.filesReport,
-            slug: sessionId,
-            mode,
-            browserConfig,
-            verbose: options.verbose,
-            heartbeatIntervalMs: options.heartbeatIntervalMs,
-            browserInlineFiles: options.browserInlineFiles,
-            background: options.background,
-        },
-    };
-    await fs.writeFile(metaPath(sessionId), JSON.stringify(metadata, null, 2), 'utf8');
-    await fs.writeFile(requestPath(sessionId), JSON.stringify(metadata.options, null, 2), 'utf8');
-    await fs.writeFile(logPath(sessionId), '', 'utf8');
-    return metadata;
-}
-export async function readSessionMetadata(sessionId) {
-    try {
-        const raw = await fs.readFile(metaPath(sessionId), 'utf8');
-        return JSON.parse(raw);
-    }
-    catch {
-        return null;
-    }
-}
-export async function updateSessionMetadata(sessionId, updates) {
-    const existing = (await readSessionMetadata(sessionId)) ?? { id: sessionId };
-    const next = { ...existing, ...updates };
-    await fs.writeFile(metaPath(sessionId), JSON.stringify(next, null, 2), 'utf8');
-    return next;
-}
-export function createSessionLogWriter(sessionId) {
-    const stream = createWriteStream(logPath(sessionId), { flags: 'a' });
-    const logLine = (line = '') => {
-        stream.write(`${line}\n`);
-    };
-    const writeChunk = (chunk) => {
-        stream.write(chunk);
-        return true;
-    };
-    return { stream, logLine, writeChunk, logPath: logPath(sessionId) };
-}
-export async function listSessionsMetadata() {
-    await ensureSessionStorage();
-    const entries = await fs.readdir(SESSIONS_DIR).catch(() => []);
-    const metas = [];
-    for (const entry of entries) {
-        const meta = await readSessionMetadata(entry);
-        if (meta) {
-            metas.push(meta);
-        }
-    }
-    return metas.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
-}
-export function filterSessionsByRange(metas, { hours = 24, includeAll = false, limit = 100 }) {
-    const maxLimit = Math.min(limit, MAX_STATUS_LIMIT);
-    let filtered = metas;
-    if (!includeAll) {
-        const cutoff = Date.now() - hours * 60 * 60 * 1000;
-        filtered = metas.filter((meta) => new Date(meta.createdAt).getTime() >= cutoff);
-    }
-    const limited = filtered.slice(0, maxLimit);
-    const truncated = filtered.length > maxLimit;
-    return { entries: limited, truncated, total: filtered.length };
-}
-export async function readSessionLog(sessionId) {
-    try {
-        return await fs.readFile(logPath(sessionId), 'utf8');
-    }
-    catch {
-        return '';
-    }
-}
-export async function deleteSessionsOlderThan({ hours = 24, includeAll = false, } = {}) {
-    await ensureSessionStorage();
-    const entries = await fs.readdir(SESSIONS_DIR).catch(() => []);
-    if (!entries.length) {
-        return { deleted: 0, remaining: 0 };
-    }
-    const cutoff = includeAll ? Number.NEGATIVE_INFINITY : Date.now() - hours * 60 * 60 * 1000;
-    let deleted = 0;
-    for (const entry of entries) {
-        const dir = sessionDir(entry);
-        let createdMs;
-        const meta = await readSessionMetadata(entry);
-        if (meta?.createdAt) {
-            const parsed = Date.parse(meta.createdAt);
-            if (!Number.isNaN(parsed)) {
-                createdMs = parsed;
-            }
-        }
-        if (createdMs == null) {
-            try {
-                const stats = await fs.stat(dir);
-                createdMs = stats.birthtimeMs || stats.mtimeMs;
-            }
-            catch {
-                continue;
-            }
-        }
-        if (includeAll || (createdMs != null && createdMs < cutoff)) {
-            await fs.rm(dir, { recursive: true, force: true });
-            deleted += 1;
-        }
-    }
-    const remaining = Math.max(entries.length - deleted, 0);
-    return { deleted, remaining };
-}
-export async function wait(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-export { ORACLE_HOME, SESSIONS_DIR, MAX_STATUS_LIMIT };

package/dist/oracle/src/version.js

@@ -1,39 +0,0 @@
-import { readFileSync } from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-let cachedVersion = null;
-export function getCliVersion() {
-    if (cachedVersion) {
-        return cachedVersion;
-    }
-    cachedVersion = readVersionFromPackage();
-    return cachedVersion;
-}
-function readVersionFromPackage() {
-    const modulePath = fileURLToPath(import.meta.url);
-    let currentDir = path.dirname(modulePath);
-    const filesystemRoot = path.parse(currentDir).root;
-    // biome-ignore lint/nursery/noUnnecessaryConditions: deliberate sentinel loop to walk up directories
-    while (true) {
-        const candidate = path.join(currentDir, 'package.json');
-        try {
-            const raw = readFileSync(candidate, 'utf8');
-            const parsed = JSON.parse(raw);
-            const version = typeof parsed.version === 'string' && parsed.version.trim().length > 0
-                ? parsed.version.trim()
-                : '0.0.0';
-            return version;
-        }
-        catch (error) {
-            const code = error instanceof Error && 'code' in error ? error.code : undefined;
-            if (code && code !== 'ENOENT') {
-                break;
-            }
-        }
-        if (currentDir === filesystemRoot) {
-            break;
-        }
-        currentDir = path.dirname(currentDir);
-    }
-    return '0.0.0';
-}

package/dist/scripts/chrome/browser-tools.js

@@ -1,295 +0,0 @@
-import { Command } from 'commander';
-import { execSync, spawn } from 'node:child_process';
-import os from 'node:os';
-import path from 'node:path';
-import puppeteer from 'puppeteer-core';
-const DEFAULT_PORT = 9222;
-const DEFAULT_PROFILE_DIR = path.join(os.homedir(), '.cache', 'scraping');
-const DEFAULT_CHROME_BIN = '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome';
-function browserURL(port) {
-    return `http://localhost:${port}`;
-}
-async function connectBrowser(port) {
-    return puppeteer.connect({ browserURL: browserURL(port), defaultViewport: null });
-}
-async function getActivePage(port) {
-    const browser = await connectBrowser(port);
-    const pages = await browser.pages();
-    const page = pages.at(-1);
-    if (!page) {
-        await browser.disconnect();
-        throw new Error('No active tab found');
-    }
-    return { browser, page };
-}
-const program = new Command();
-program
-    .name('browser-tools')
-    .description('Minimal Chrome DevTools helpers inspired by Mario Zechner’s “What if you don’t need MCP?” article.')
-    .configureHelp({
-    sortSubcommands: true,
-})
-    .showSuggestionAfterError();
-program
-    .command('start')
-    .description('Launch Chrome with remote debugging enabled.')
-    .option('-p, --port <number>', 'Remote debugging port (default: 9222)', (value) => Number.parseInt(value, 10), DEFAULT_PORT)
-    .option('--profile', 'Copy your existing Chrome profile before launching.', false)
-    .option('--profile-dir <path>', 'Directory for the temporary Chrome profile.', DEFAULT_PROFILE_DIR)
-    .option('--chrome-path <path>', 'Path to the Chrome binary.', DEFAULT_CHROME_BIN)
-    .action(async (options) => {
-    const { port, profile, profileDir, chromePath } = options;
-    try {
-        execSync("killall 'Google Chrome'", { stdio: 'ignore' });
-    }
-    catch {
-        // ignore
-    }
-    await new Promise((resolve) => setTimeout(resolve, 1000));
-    execSync(`mkdir -p "${profileDir}"`);
-    if (profile) {
-        const source = path.join(os.homedir(), 'Library', 'Application Support', 'Google', 'Chrome') + '/';
-        execSync(`rsync -a --delete "${source}" "${profileDir}/"`, { stdio: 'ignore' });
-    }
-    spawn(chromePath, ['--remote-debugging-port=' + port, `--user-data-dir=${profileDir}`, '--no-first-run', '--disable-popup-blocking'], {
-        detached: true,
-        stdio: 'ignore',
-    }).unref();
-    let connected = false;
-    for (let attempt = 0; attempt < 30; attempt++) {
-        try {
-            const browser = await connectBrowser(port);
-            await browser.disconnect();
-            connected = true;
-            break;
-        }
-        catch {
-            await new Promise((resolve) => setTimeout(resolve, 500));
-        }
-    }
-    if (!connected) {
-        console.error(`✗ Failed to start Chrome on port ${port}`);
-        process.exit(1);
-    }
-    console.log(`✓ Chrome listening on http://localhost:${port}${profile ? ' (with your profile)' : ''}`);
-});
-program
-    .command('nav <url>')
-    .description('Navigate the current tab or open a new tab.')
-    .option('--port <number>', 'Debugger port (default: 9222)', (value) => Number.parseInt(value, 10), DEFAULT_PORT)
-    .option('--new', 'Open in a new tab instead of reusing the current tab.', false)
-    .action(async (url, options) => {
-    const port = options.port;
-    const browser = await connectBrowser(port);
-    try {
-        if (options.new) {
-            const page = await browser.newPage();
-            await page.goto(url, { waitUntil: 'domcontentloaded' });
-            console.log('✓ Opened in new tab:', url);
-        }
-        else {
-            const pages = await browser.pages();
-            const page = pages.at(-1);
-            if (!page) {
-                throw new Error('No active tab found');
-            }
-            await page.goto(url, { waitUntil: 'domcontentloaded' });
-            console.log('✓ Navigated current tab to:', url);
-        }
-    }
-    finally {
-        await browser.disconnect();
-    }
-});
-program
-    .command('eval <code...>')
-    .description('Evaluate JavaScript in the active page context.')
-    .option('--port <number>', 'Debugger port (default: 9222)', (value) => Number.parseInt(value, 10), DEFAULT_PORT)
-    .action(async (code, options) => {
-    const snippet = code.join(' ');
-    const port = options.port;
-    const { browser, page } = await getActivePage(port);
-    try {
-        const result = await page.evaluate((body) => {
-            const AsyncFunctionConstructor = Object.getPrototypeOf(async function () { }).constructor;
-            return new AsyncFunctionConstructor(`return (${body})`)();
-        }, snippet);
-        if (Array.isArray(result)) {
-            result.forEach((entry, index) => {
-                if (index > 0)
-                    console.log('');
-                Object.entries(entry).forEach(([key, value]) => console.log(`${key}: ${value}`));
-            });
-        }
-        else if (typeof result === 'object' && result !== null) {
-            Object.entries(result).forEach(([key, value]) => console.log(`${key}: ${value}`));
-        }
-        else {
-            console.log(result);
-        }
-    }
-    finally {
-        await browser.disconnect();
-    }
-});
-program
-    .command('screenshot')
-    .description('Capture the current viewport and print the temp PNG path.')
-    .option('--port <number>', 'Debugger port (default: 9222)', (value) => Number.parseInt(value, 10), DEFAULT_PORT)
-    .action(async (options) => {
-    const port = options.port;
-    const { browser, page } = await getActivePage(port);
-    try {
-        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-        const filePath = path.join(os.tmpdir(), `screenshot-${timestamp}.png`);
-        await page.screenshot({ path: filePath });
-        console.log(filePath);
-    }
-    finally {
-        await browser.disconnect();
-    }
-});
-program
-    .command('pick <message...>')
-    .description('Interactive DOM picker that prints metadata for clicked elements.')
-    .option('--port <number>', 'Debugger port (default: 9222)', (value) => Number.parseInt(value, 10), DEFAULT_PORT)
-    .action(async (messageParts, options) => {
-    const message = messageParts.join(' ');
-    const port = options.port;
-    const { browser, page } = await getActivePage(port);
-    try {
-        await page.evaluate(() => {
-            const scope = globalThis;
-            if (scope.pickOverlayInjected) {
-                return;
-            }
-            scope.pickOverlayInjected = true;
-            scope.pick = async (prompt) => new Promise((resolve) => {
-                const selections = [];
-                const selectedElements = new Set();
-                const overlay = document.createElement('div');
-                overlay.style.cssText =
-                    'position:fixed;top:0;left:0;width:100%;height:100%;z-index:2147483647;pointer-events:none';
-                const highlight = document.createElement('div');
-                highlight.style.cssText =
-                    'position:absolute;border:2px solid #3b82f6;background:rgba(59,130,246,0.1);transition:all 0.05s ease';
-                overlay.appendChild(highlight);
-                const banner = document.createElement('div');
-                banner.style.cssText =
-                    'position:fixed;bottom:20px;left:50%;transform:translateX(-50%);background:#1f2937;color:#fff;padding:12px 24px;border-radius:8px;font:14px system-ui;box-shadow:0 4px 12px rgba(0,0,0,0.3);pointer-events:auto;z-index:2147483647';
-                const updateBanner = () => {
-                    banner.textContent = `${prompt} (${selections.length} selected, Cmd/Ctrl+click to add, Enter to finish, ESC to cancel)`;
-                };
-                const cleanup = () => {
-                    document.removeEventListener('mousemove', onMove, true);
-                    document.removeEventListener('click', onClick, true);
-                    document.removeEventListener('keydown', onKey, true);
-                    overlay.remove();
-                    banner.remove();
-                    selectedElements.forEach((el) => (el.style.outline = ''));
-                };
-                const serialize = (el) => {
-                    const parents = [];
-                    let current = el.parentElement;
-                    while (current && current !== document.body) {
-                        const id = current.id ? `#${current.id}` : '';
-                        const cls = current.className ? `.${current.className.trim().split(/\\s+/).join('.')}` : '';
-                        parents.push(`${current.tagName.toLowerCase()}${id}${cls}`);
-                        current = current.parentElement;
-                    }
-                    return {
-                        tag: el.tagName.toLowerCase(),
-                        id: el.id || null,
-                        class: el.className || null,
-                        text: el.textContent?.trim()?.slice(0, 200) || null,
-                        html: el.outerHTML.slice(0, 500),
-                        parents: parents.join(' > '),
-                    };
-                };
-                const onMove = (event) => {
-                    const node = document.elementFromPoint(event.clientX, event.clientY);
-                    if (!node || overlay.contains(node) || banner.contains(node))
-                        return;
-                    const rect = node.getBoundingClientRect();
-                    highlight.style.cssText = `position:absolute;border:2px solid #3b82f6;background:rgba(59,130,246,0.1);top:${rect.top}px;left:${rect.left}px;width:${rect.width}px;height:${rect.height}px`;
-                };
-                const onClick = (event) => {
-                    if (banner.contains(event.target))
-                        return;
-                    event.preventDefault();
-                    event.stopPropagation();
-                    const node = document.elementFromPoint(event.clientX, event.clientY);
-                    if (!node || overlay.contains(node) || banner.contains(node))
-                        return;
-                    if (event.metaKey || event.ctrlKey) {
-                        if (!selectedElements.has(node)) {
-                            selectedElements.add(node);
-                            node.style.outline = '3px solid #10b981';
-                            selections.push(serialize(node));
-                            updateBanner();
-                        }
-                    }
-                    else {
-                        cleanup();
-                        const info = serialize(node);
-                        resolve(selections.length > 0 ? selections : info);
-                    }
-                };
-                const onKey = (event) => {
-                    if (event.key === 'Escape') {
-                        cleanup();
-                        resolve(null);
-                    }
-                    else if (event.key === 'Enter' && selections.length > 0) {
-                        cleanup();
-                        resolve(selections);
-                    }
-                };
-                document.addEventListener('mousemove', onMove, true);
-                document.addEventListener('click', onClick, true);
-                document.addEventListener('keydown', onKey, true);
-                document.body.append(overlay, banner);
-                updateBanner();
-            });
-        });
-        const result = await page.evaluate((msg) => {
-            const pickFn = window.pick;
-            if (!pickFn) {
-                return null;
-            }
-            return pickFn(msg);
-        }, message);
-        if (Array.isArray(result)) {
-            result.forEach((entry, index) => {
-                if (index > 0)
-                    console.log('');
-                Object.entries(entry).forEach(([key, value]) => console.log(`${key}: ${value}`));
-            });
-        }
-        else if (result && typeof result === 'object') {
-            Object.entries(result).forEach(([key, value]) => console.log(`${key}: ${value}`));
-        }
-        else {
-            console.log(result);
-        }
-    }
-    finally {
-        await browser.disconnect();
-    }
-});
-program
-    .command('cookies')
-    .description('Dump cookies from the active tab as JSON.')
-    .option('--port <number>', 'Debugger port (default: 9222)', (value) => Number.parseInt(value, 10), DEFAULT_PORT)
-    .action(async (options) => {
-    const port = options.port;
-    const { browser, page } = await getActivePage(port);
-    try {
-        const cookies = await page.cookies();
-        console.log(JSON.stringify(cookies, null, 2));
-    }
-    finally {
-        await browser.disconnect();
-    }
-});
-program.parseAsync(process.argv);

package/dist/src/browser/profileSync.js

@@ -1,141 +0,0 @@
-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);
-        },
-    });
-}