@aluvia/sdk 1.4.1 → 2.0.0

package/dist/cjs/bin/close.js

@@ -1,120 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleClose = handleClose;
-const lock_js_1 = require("../session/lock.js");
-const cli_js_1 = require("./cli.js");
-async function handleClose(sessionName, closeAll) {
-    if (closeAll) {
-        const sessions = (0, lock_js_1.listSessions)();
-        if (sessions.length === 0) {
-            return (0, cli_js_1.output)({ error: 'No running browser sessions found.', closed: [], count: 0 }, 1);
-        }
-        // Send SIGTERM to all sessions
-        for (const s of sessions) {
-            try {
-                process.kill(s.pid, 'SIGTERM');
-            }
-            catch {
-                // ignore
-            }
-        }
-        // Wait up to 10 seconds for all processes to exit
-        const maxWait = 40;
-        const alive = new Set(sessions.map((s) => s.pid));
-        for (let i = 0; i < maxWait && alive.size > 0; i++) {
-            await new Promise((r) => setTimeout(r, 250));
-            for (const pid of alive) {
-                if (!(0, lock_js_1.isProcessAlive)(pid)) {
-                    alive.delete(pid);
-                }
-            }
-        }
-        // Force-kill any survivors
-        for (const pid of alive) {
-            try {
-                process.kill(pid, 'SIGKILL');
-            }
-            catch {
-                // ignore
-            }
-        }
-        // Now remove all locks
-        const closed = [];
-        for (const s of sessions) {
-            (0, lock_js_1.removeLock)(s.session);
-            closed.push(s.session);
-        }
-        return (0, cli_js_1.output)({ message: 'All browser sessions closed.', closed, count: closed.length });
-    }
-    // If no session name specified, figure out what to close
-    if (!sessionName) {
-        const sessions = (0, lock_js_1.listSessions)();
-        if (sessions.length === 0) {
-            return (0, cli_js_1.output)({ error: 'No running browser sessions found.' }, 1);
-        }
-        if (sessions.length > 1) {
-            return (0, cli_js_1.output)({
-                error: 'Multiple sessions running. Specify --browser-session <name> or --all.',
-                browserSessions: sessions.map((s) => s.session),
-            }, 1);
-        }
-        // Single session — use its data directly instead of re-reading the lock file
-        const session = sessions[0];
-        sessionName = session.session;
-        return closeSession(sessionName, (0, lock_js_1.toLockData)(session));
-    }
-    // Session name provided — need to verify it's alive
-    const sessions = (0, lock_js_1.listSessions)();
-    const match = sessions.find((s) => s.session === sessionName);
-    if (!match) {
-        return (0, cli_js_1.output)({ browserSession: sessionName, error: 'No running browser session found.' }, 1);
-    }
-    return closeSession(sessionName, (0, lock_js_1.toLockData)(match));
-}
-async function closeSession(sessionName, lock) {
-    if (!(0, lock_js_1.isProcessAlive)(lock.pid)) {
-        (0, lock_js_1.removeLock)(sessionName);
-        return (0, cli_js_1.output)({
-            browserSession: sessionName,
-            message: 'Browser process was not running. Lock file cleaned up.',
-        });
-    }
-    try {
-        process.kill(lock.pid, 'SIGTERM');
-    }
-    catch (err) {
-        return (0, cli_js_1.output)({ browserSession: sessionName, error: `Failed to stop process: ${err.message}` }, 1);
-    }
-    // Wait for the process to exit (up to 10 seconds)
-    const maxWait = 40;
-    for (let i = 0; i < maxWait; i++) {
-        await new Promise((r) => setTimeout(r, 250));
-        if (!(0, lock_js_1.isProcessAlive)(lock.pid)) {
-            (0, lock_js_1.removeLock)(sessionName);
-            return (0, cli_js_1.output)({
-                browserSession: sessionName,
-                pid: lock.pid,
-                message: 'Browser session closed.',
-                startUrl: lock.url ?? null,
-                cdpUrl: lock.cdpUrl ?? null,
-                connectionId: lock.connectionId ?? null,
-            });
-        }
-    }
-    // Force kill if still alive
-    try {
-        process.kill(lock.pid, 'SIGKILL');
-    }
-    catch {
-        // ignore
-    }
-    (0, lock_js_1.removeLock)(sessionName);
-    return (0, cli_js_1.output)({
-        browserSession: sessionName,
-        pid: lock.pid,
-        message: 'Browser session force-killed.',
-        startUrl: lock.url ?? null,
-        cdpUrl: lock.cdpUrl ?? null,
-        connectionId: lock.connectionId ?? null,
-    });
-}

package/dist/cjs/bin/geos.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleGeos = handleGeos;
-const api_helpers_js_1 = require("./api-helpers.js");
-const cli_js_1 = require("./cli.js");
-async function handleGeos() {
-    const api = (0, api_helpers_js_1.requireApi)();
-    const geos = await api.geos.list();
-    return (0, cli_js_1.output)({ geos, count: geos.length });
-}

package/dist/cjs/bin/mcp-helpers.js

@@ -1,57 +0,0 @@
-"use strict";
-/**
- * MCP output capture helpers.
- *
- * The CLI handlers call `output()` which normally does `console.log` + `process.exit()`.
- * In MCP mode, we switch `output()` to throw an MCPOutputCapture instead,
- * allowing us to catch and return the data without exiting the process.
- *
- * Uses AsyncLocalStorage so concurrent MCP tool calls don't interfere.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MCPOutputCapture = void 0;
-exports.isCapturing = isCapturing;
-exports.captureOutput = captureOutput;
-const node_async_hooks_1 = require("node:async_hooks");
-/**
- * Thrown by output() when in capture mode.
- * Contains the JSON data and exit code that would have been written to stdout.
- */
-class MCPOutputCapture {
-    constructor(data, exitCode) {
-        this.data = data;
-        this.exitCode = exitCode;
-    }
-}
-exports.MCPOutputCapture = MCPOutputCapture;
-const captureContext = new node_async_hooks_1.AsyncLocalStorage();
-function isCapturing() {
-    return captureContext.getStore() ?? false;
-}
-/**
- * Run a CLI handler function in capture mode.
- * Returns the data that output() would have written to stdout.
- * Safe for concurrent use — each call gets its own async context.
- */
-async function captureOutput(fn) {
-    return captureContext.run(true, async () => {
-        try {
-            await fn();
-            // Handler completed without calling output() — shouldn't happen for CLI handlers
-            return { data: { error: "Handler did not produce output" }, isError: true };
-        }
-        catch (err) {
-            if (err instanceof MCPOutputCapture) {
-                return {
-                    data: err.data,
-                    isError: err.exitCode !== 0,
-                };
-            }
-            // Unexpected error (not from output())
-            return {
-                data: { error: err instanceof Error ? err.message : String(err) },
-                isError: true,
-            };
-        }
-    });
-}

package/dist/cjs/bin/open.js

@@ -1,317 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleOpen = handleOpen;
-exports.handleOpenDaemon = handleOpenDaemon;
-const AluviaClient_js_1 = require("../client/AluviaClient.js");
-const lock_js_1 = require("../session/lock.js");
-const cli_js_1 = require("./cli.js");
-const node_child_process_1 = require("node:child_process");
-const fs = __importStar(require("node:fs"));
-const path = __importStar(require("node:path"));
-const node_url_1 = require("node:url");
-// Determine the directory of this module at load time
-// @ts-ignore - import.meta.url exists at runtime in ESM
-const thisModuleDir = path.dirname((0, node_url_1.fileURLToPath)(import.meta.url));
-/**
- * Get the path to cli.js for spawning daemon processes.
- * Looks in the same directory as this module (works for both dev and installed).
- */
-function getCliScriptPath() {
-    // cli.js should be in the same directory as open.js
-    const cliPath = path.join(thisModuleDir, 'cli.js');
-    if (fs.existsSync(cliPath)) {
-        return cliPath;
-    }
-    throw new Error(`Could not find cli.js at ${cliPath}`);
-}
-/**
- * Called from cli.ts when running `session start <url>`.
- * Spawns the actual browser in a detached child and polls until ready.
- * Returns a Promise that resolves via process.exit() (never returns normally).
- */
-function handleOpen({ url, connectionId, headless, sessionName, autoUnblock, disableBlockDetection, run }) {
-    // Generate session name if not provided
-    const session = sessionName ?? (0, lock_js_1.generateSessionName)();
-    // Validate session name early (before spawning daemon)
-    if (sessionName && !(0, lock_js_1.validateSessionName)(sessionName)) {
-        (0, cli_js_1.output)({ error: 'Invalid session name. Use only letters, numbers, hyphens, and underscores.' }, 1);
-    }
-    // Check for existing instance with this session name
-    const existing = (0, lock_js_1.readLock)(session);
-    if (existing !== null && (0, lock_js_1.isProcessAlive)(existing.pid)) {
-        (0, cli_js_1.output)({
-            error: `A browser session named '${session}' is already running.`,
-            browserSession: session,
-            startUrl: existing.url ?? null,
-            cdpUrl: existing.cdpUrl ?? null,
-            connectionId: existing.connectionId ?? null,
-            pid: existing.pid,
-        }, 1);
-    }
-    // Clean up stale lock if process is dead
-    if (existing !== null) {
-        (0, lock_js_1.removeLock)(session);
-    }
-    // Require API key
-    const apiKey = process.env.ALUVIA_API_KEY;
-    if (!apiKey) {
-        (0, cli_js_1.output)({ error: 'ALUVIA_API_KEY environment variable is required.' }, 1);
-    }
-    // Spawn a detached child process that runs the daemon
-    const logFile = (0, lock_js_1.getLogFilePath)(session);
-    const out = fs.openSync(logFile, 'a');
-    const args = ['--daemon', url, '--browser-session', session];
-    if (connectionId != null) {
-        args.push('--connection-id', String(connectionId));
-    }
-    if (!headless) {
-        args.push('--headful');
-    }
-    if (autoUnblock) {
-        args.push('--auto-unblock');
-    }
-    if (disableBlockDetection) {
-        args.push('--disable-block-detection');
-    }
-    if (run) {
-        args.push('--run', run);
-    }
-    let child;
-    try {
-        // Get the path to cli.js in the same directory as this module
-        const cliPath = getCliScriptPath();
-        child = (0, node_child_process_1.spawn)(process.execPath, [cliPath, ...args], {
-            detached: true,
-            stdio: ['ignore', out, out],
-            env: { ...process.env, ALUVIA_API_KEY: apiKey },
-        });
-        child.unref();
-    }
-    catch (err) {
-        fs.closeSync(out);
-        return (0, cli_js_1.output)({ browserSession: session, error: `Failed to spawn browser process: ${err.message}` }, 1);
-    }
-    fs.closeSync(out);
-    // Wait for the daemon to be fully ready (lock file with ready: true)
-    return new Promise((resolve, reject) => {
-        let attempts = 0;
-        const maxAttempts = 240; // 60 seconds max
-        const poll = setInterval(() => {
-            attempts++;
-            try {
-                // Early exit if daemon process died
-                if (child.pid && !(0, lock_js_1.isProcessAlive)(child.pid)) {
-                    clearInterval(poll);
-                    (0, lock_js_1.removeLock)(session);
-                    (0, cli_js_1.output)({
-                        browserSession: session,
-                        error: 'Browser process exited unexpectedly.',
-                        logFile,
-                    }, 1);
-                }
-                const lock = (0, lock_js_1.readLock)(session);
-                if (lock && lock.ready) {
-                    clearInterval(poll);
-                    (0, cli_js_1.output)({
-                        browserSession: session,
-                        pid: lock.pid,
-                        startUrl: lock.url ?? null,
-                        cdpUrl: lock.cdpUrl ?? null,
-                        connectionId: lock.connectionId ?? null,
-                        blockDetection: lock.blockDetection ?? false,
-                        autoUnblock: lock.autoUnblock ?? false,
-                    });
-                }
-                if (attempts >= maxAttempts) {
-                    clearInterval(poll);
-                    const alive = child.pid ? (0, lock_js_1.isProcessAlive)(child.pid) : false;
-                    (0, cli_js_1.output)({
-                        browserSession: session,
-                        error: alive ? 'Browser is still initializing (timeout).' : 'Browser process exited unexpectedly.',
-                        logFile,
-                    }, 1);
-                }
-            }
-            catch (err) {
-                // In MCP capture mode, output() throws MCPOutputCapture which we need to propagate
-                clearInterval(poll);
-                reject(err);
-            }
-        }, 250);
-    });
-}
-/**
- * Daemon entry point — runs in the detached child process.
- * Starts the proxy + browser, writes lock, and stays alive.
- * Logs go to the daemon log file (stdout is redirected), not to the user.
- */
-async function handleOpenDaemon({ url, connectionId, headless, sessionName, autoUnblock, disableBlockDetection, run }) {
-    const apiKey = process.env.ALUVIA_API_KEY;
-    const blockDetectionEnabled = !disableBlockDetection;
-    const updateLockWithDetection = (result) => {
-        const lock = (0, lock_js_1.readLock)(sessionName);
-        if (!lock)
-            return;
-        const lastDetection = {
-            hostname: result.hostname,
-            lastUrl: result.url,
-            blockStatus: result.blockStatus,
-            score: result.score,
-            signals: result.signals.map((s) => s.name),
-            pass: result.pass,
-            persistentBlock: result.persistentBlock,
-            timestamp: Date.now(),
-        };
-        (0, lock_js_1.writeLock)({ ...lock, lastDetection }, sessionName);
-    };
-    const client = new AluviaClient_js_1.AluviaClient({
-        apiKey,
-        startPlaywright: true,
-        ...(connectionId != null ? { connectionId } : {}),
-        headless: headless ?? true,
-        blockDetection: blockDetectionEnabled
-            ? autoUnblock
-                ? { enabled: true, autoUnblock: true, onDetection: updateLockWithDetection }
-                : { enabled: true, onDetection: updateLockWithDetection }
-            : { enabled: false },
-    });
-    const connection = await client.start();
-    // Write early lock so parent knows daemon is alive
-    (0, lock_js_1.writeLock)({ pid: process.pid, session: sessionName, url, proxyUrl: connection.url, blockDetection: blockDetectionEnabled, autoUnblock: blockDetectionEnabled && !!autoUnblock }, sessionName);
-    if (autoUnblock)
-        console.log('[daemon] Auto-unblock enabled');
-    console.log(`[daemon] Browser initialized — proxy: ${connection.url}`);
-    if (connection.cdpUrl)
-        console.log(`[daemon] CDP URL: ${connection.cdpUrl}`);
-    if (connectionId != null)
-        console.log(`[daemon] Connection ID: ${connectionId}`);
-    if (sessionName)
-        console.log(`[daemon] Session: ${sessionName}`);
-    console.log(`[daemon] Opening ${url}`);
-    // Navigate to URL in the browser
-    const page = await connection.browserContext.newPage();
-    await page.goto(url, { waitUntil: 'domcontentloaded' });
-    // Gather session info
-    const pageTitle = await page.title().catch(() => '');
-    const cdpUrl = connection.cdpUrl ?? '';
-    // Get connection ID: use the one passed in, or read from ConfigManager
-    const connId = connectionId ?? client.connectionId;
-    // Write lock file with full session metadata (marks session as ready)
-    // Read existing lock first to preserve lastDetection written by the onDetection callback
-    const existingLock = (0, lock_js_1.readLock)(sessionName);
-    (0, lock_js_1.writeLock)({
-        pid: process.pid,
-        session: sessionName,
-        connectionId: connId,
-        cdpUrl,
-        proxyUrl: connection.url,
-        url,
-        ready: true,
-        blockDetection: blockDetectionEnabled,
-        autoUnblock: blockDetectionEnabled && !!autoUnblock,
-        lastDetection: existingLock?.lastDetection,
-    }, sessionName);
-    console.log(`[daemon] Session ready — session: ${sessionName ?? 'default'}, url: ${url}, cdpUrl: ${cdpUrl}, connectionId: ${connId ?? 'unknown'}, pid: ${process.pid}`);
-    if (pageTitle)
-        console.log(`[daemon] Page title: ${pageTitle}`);
-    // If --run was provided, execute the script and then shut down
-    if (run) {
-        const scriptPath = path.resolve(run);
-        if (!fs.existsSync(scriptPath)) {
-            console.error(`[daemon] Script not found: ${scriptPath}`);
-            (0, lock_js_1.removeLock)(sessionName);
-            await connection.close();
-            process.exit(1);
-        }
-        console.log(`[daemon] Running script: ${scriptPath}`);
-        // Inject page, browser, context as globals so the script can use them directly
-        const browser = connection.browser;
-        const context = connection.browserContext;
-        globalThis.page = page;
-        globalThis.browser = browser;
-        globalThis.context = context;
-        let exitCode = 0;
-        try {
-            await Promise.resolve(`${(0, node_url_1.pathToFileURL)(scriptPath).href}`).then(s => __importStar(require(s)));
-        }
-        catch (err) {
-            console.error(`[daemon] Script error: ${err.message}`);
-            if (err.stack)
-                console.error(err.stack);
-            exitCode = 1;
-        }
-        // Clean up globals
-        delete globalThis.page;
-        delete globalThis.browser;
-        delete globalThis.context;
-        console.log(`[daemon] Script finished.`);
-        (0, lock_js_1.removeLock)(sessionName);
-        await connection.close();
-        process.exit(exitCode);
-    }
-    // Graceful shutdown handler
-    let stopping = false;
-    const shutdown = async () => {
-        if (stopping)
-            return;
-        stopping = true;
-        console.log('[daemon] Shutting down...');
-        try {
-            await connection.close();
-        }
-        catch {
-            // ignore
-        }
-        (0, lock_js_1.removeLock)(sessionName);
-        console.log('[daemon] Stopped.');
-        process.exit(0);
-    };
-    process.on('SIGINT', shutdown);
-    process.on('SIGTERM', shutdown);
-    // Detect when the browser is closed by the user
-    if (connection.browser) {
-        connection.browser.on('disconnected', () => {
-            if (!stopping) {
-                console.log('[daemon] Browser closed by user.');
-                (0, lock_js_1.removeLock)(sessionName);
-                client
-                    .stop()
-                    .catch(() => { })
-                    .finally(() => process.exit(0));
-            }
-        });
-    }
-}