@aluvia/sdk 1.4.1 → 2.0.1

package/dist/esm/bin/close.js

@@ -1,117 +0,0 @@
-import { removeLock, isProcessAlive, listSessions, toLockData } from '../session/lock.js';
-import { output } from './cli.js';
-export async function handleClose(sessionName, closeAll) {
-    if (closeAll) {
-        const sessions = listSessions();
-        if (sessions.length === 0) {
-            return 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 (!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) {
-            removeLock(s.session);
-            closed.push(s.session);
-        }
-        return output({ message: 'All browser sessions closed.', closed, count: closed.length });
-    }
-    // If no session name specified, figure out what to close
-    if (!sessionName) {
-        const sessions = listSessions();
-        if (sessions.length === 0) {
-            return output({ error: 'No running browser sessions found.' }, 1);
-        }
-        if (sessions.length > 1) {
-            return 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, toLockData(session));
-    }
-    // Session name provided — need to verify it's alive
-    const sessions = listSessions();
-    const match = sessions.find((s) => s.session === sessionName);
-    if (!match) {
-        return output({ browserSession: sessionName, error: 'No running browser session found.' }, 1);
-    }
-    return closeSession(sessionName, toLockData(match));
-}
-async function closeSession(sessionName, lock) {
-    if (!isProcessAlive(lock.pid)) {
-        removeLock(sessionName);
-        return output({
-            browserSession: sessionName,
-            message: 'Browser process was not running. Lock file cleaned up.',
-        });
-    }
-    try {
-        process.kill(lock.pid, 'SIGTERM');
-    }
-    catch (err) {
-        return 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 (!isProcessAlive(lock.pid)) {
-            removeLock(sessionName);
-            return 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
-    }
-    removeLock(sessionName);
-    return 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/esm/bin/geos.js

@@ -1,7 +0,0 @@
-import { requireApi } from './api-helpers.js';
-import { output } from './cli.js';
-export async function handleGeos() {
-    const api = requireApi();
-    const geos = await api.geos.list();
-    return output({ geos, count: geos.length });
-}

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

@@ -1,51 +0,0 @@
-/**
- * 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.
- */
-import { AsyncLocalStorage } from "node:async_hooks";
-/**
- * Thrown by output() when in capture mode.
- * Contains the JSON data and exit code that would have been written to stdout.
- */
-export class MCPOutputCapture {
-    constructor(data, exitCode) {
-        this.data = data;
-        this.exitCode = exitCode;
-    }
-}
-const captureContext = new AsyncLocalStorage();
-export 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.
- */
-export 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/esm/bin/open.js

@@ -1,280 +0,0 @@
-import { AluviaClient } from '../client/AluviaClient.js';
-import { writeLock, readLock, removeLock, isProcessAlive, getLogFilePath, generateSessionName, validateSessionName } from '../session/lock.js';
-import { output } from './cli.js';
-import { spawn } from 'node:child_process';
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import { pathToFileURL, fileURLToPath } from '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(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).
- */
-export function handleOpen({ url, connectionId, headless, sessionName, autoUnblock, disableBlockDetection, run }) {
-    // Generate session name if not provided
-    const session = sessionName ?? generateSessionName();
-    // Validate session name early (before spawning daemon)
-    if (sessionName && !validateSessionName(sessionName)) {
-        output({ error: 'Invalid session name. Use only letters, numbers, hyphens, and underscores.' }, 1);
-    }
-    // Check for existing instance with this session name
-    const existing = readLock(session);
-    if (existing !== null && isProcessAlive(existing.pid)) {
-        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) {
-        removeLock(session);
-    }
-    // Require API key
-    const apiKey = process.env.ALUVIA_API_KEY;
-    if (!apiKey) {
-        output({ error: 'ALUVIA_API_KEY environment variable is required.' }, 1);
-    }
-    // Spawn a detached child process that runs the daemon
-    const logFile = 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 = 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 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 && !isProcessAlive(child.pid)) {
-                    clearInterval(poll);
-                    removeLock(session);
-                    output({
-                        browserSession: session,
-                        error: 'Browser process exited unexpectedly.',
-                        logFile,
-                    }, 1);
-                }
-                const lock = readLock(session);
-                if (lock && lock.ready) {
-                    clearInterval(poll);
-                    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 ? isProcessAlive(child.pid) : false;
-                    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.
- */
-export 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 = 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(),
-        };
-        writeLock({ ...lock, lastDetection }, sessionName);
-    };
-    const client = new 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
-    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 = readLock(sessionName);
-    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}`);
-            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 import(pathToFileURL(scriptPath).href);
-        }
-        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.`);
-        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
-        }
-        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.');
-                removeLock(sessionName);
-                client
-                    .stop()
-                    .catch(() => { })
-                    .finally(() => process.exit(0));
-            }
-        });
-    }
-}