@aluvia/sdk 1.4.1 → 2.0.0

package/dist/esm/bin/session.js

@@ -1,252 +0,0 @@
-import crypto from 'node:crypto';
-import { handleOpen } from './open.js';
-import { handleClose } from './close.js';
-import { listSessions } from '../session/lock.js';
-import { requireApi, resolveSession, requireConnectionId } from './api-helpers.js';
-import { output } from './cli.js';
-export function parseSessionArgs(args) {
-    let url;
-    let connectionId;
-    let headed = false;
-    let sessionName;
-    let autoUnblock = false;
-    let disableBlockDetection = false;
-    let run;
-    for (let i = 0; i < args.length; i++) {
-        if (args[i] === '--connection-id' && args[i + 1]) {
-            const parsed = Number(args[i + 1]);
-            if (!Number.isInteger(parsed) || parsed < 1) {
-                output({ error: `Invalid --connection-id: '${args[i + 1]}' must be a positive integer.` }, 1);
-            }
-            connectionId = parsed;
-            i++;
-        }
-        else if (args[i] === '--browser-session' && args[i + 1]) {
-            sessionName = args[i + 1];
-            i++;
-        }
-        else if (args[i] === '--run' && args[i + 1]) {
-            run = args[i + 1];
-            i++;
-        }
-        else if (args[i] === '--headful') {
-            headed = true;
-        }
-        else if (args[i] === '--auto-unblock') {
-            autoUnblock = true;
-        }
-        else if (args[i] === '--disable-block-detection') {
-            disableBlockDetection = true;
-        }
-        else if (!url && !args[i].startsWith('--')) {
-            url = args[i];
-        }
-    }
-    return { url, connectionId, headed, sessionName, autoUnblock, disableBlockDetection, run };
-}
-export async function handleSession(args) {
-    const subcommand = args[0];
-    if (!subcommand) {
-        return output({ error: 'Missing session subcommand. Run "aluvia help" for usage.' }, 1);
-    }
-    switch (subcommand) {
-        case 'start':
-            return handleSessionStart(args.slice(1));
-        case 'close':
-            return handleSessionClose(args.slice(1));
-        case 'list':
-            return handleSessionList();
-        case 'get':
-            return handleSessionGet(args.slice(1));
-        case 'rotate-ip':
-            return handleSessionRotateIp(args.slice(1));
-        case 'set-geo':
-            return handleSessionSetGeo(args.slice(1));
-        case 'set-rules':
-            return handleSessionSetRules(args.slice(1));
-        default:
-            return output({ error: `Unknown session subcommand: '${subcommand}'. Run "aluvia help" for usage.` }, 1);
-    }
-}
-async function handleSessionStart(args) {
-    const parsed = parseSessionArgs(args);
-    if (!parsed.url) {
-        return output({ error: 'URL is required. Usage: aluvia session start <url> [options]' }, 1);
-    }
-    const opts = {
-        url: parsed.url,
-        connectionId: parsed.connectionId,
-        headless: !parsed.headed,
-        sessionName: parsed.sessionName,
-        autoUnblock: parsed.autoUnblock,
-        disableBlockDetection: parsed.disableBlockDetection,
-        run: parsed.run,
-    };
-    // Delegates to the existing open handler (spawns daemon, waits for ready)
-    await handleOpen(opts);
-}
-async function handleSessionClose(args) {
-    let sessionName;
-    let all = false;
-    for (let i = 0; i < args.length; i++) {
-        if (args[i] === '--browser-session' && args[i + 1]) {
-            sessionName = args[i + 1];
-            i++;
-        }
-        else if (args[i] === '--all') {
-            all = true;
-        }
-    }
-    await handleClose(sessionName, all);
-}
-function handleSessionList() {
-    const sessions = listSessions();
-    return output({
-        sessions: sessions.map((s) => ({
-            browserSession: s.session,
-            pid: s.pid,
-            startUrl: s.url ?? null,
-            cdpUrl: s.cdpUrl ?? null,
-            connectionId: s.connectionId ?? null,
-            blockDetection: s.blockDetection ?? false,
-            autoUnblock: s.autoUnblock ?? false,
-        })),
-        count: sessions.length,
-    });
-}
-async function handleSessionGet(args) {
-    let sessionName;
-    for (let i = 0; i < args.length; i++) {
-        if (args[i] === '--browser-session' && args[i + 1]) {
-            sessionName = args[i + 1];
-            i++;
-        }
-    }
-    const { session, lock } = resolveSession(sessionName);
-    const connId = lock.connectionId;
-    const base = {
-        browserSession: session,
-        pid: lock.pid,
-        startUrl: lock.url ?? null,
-        cdpUrl: lock.cdpUrl ?? null,
-        connectionId: connId ?? null,
-        blockDetection: lock.blockDetection ?? false,
-        autoUnblock: lock.autoUnblock ?? false,
-        lastDetection: lock.lastDetection ?? null,
-    };
-    // If we have a connection ID, enrich with full connection object from API
-    if (connId != null) {
-        try {
-            const api = requireApi();
-            const conn = await api.account.connections.get(connId);
-            if (conn) {
-                base.connection = conn;
-            }
-        }
-        catch {
-            // API enrichment is best-effort; base lock data is still returned
-        }
-    }
-    return output(base);
-}
-async function handleSessionRotateIp(args) {
-    let sessionName;
-    for (let i = 0; i < args.length; i++) {
-        if (args[i] === '--browser-session' && args[i + 1]) {
-            sessionName = args[i + 1];
-            i++;
-        }
-    }
-    const { session, lock } = resolveSession(sessionName);
-    const connId = requireConnectionId(lock, session);
-    const api = requireApi();
-    const newSessionId = crypto.randomUUID().replace(/-/g, '');
-    await api.account.connections.patch(connId, { session_id: newSessionId });
-    return output({
-        browserSession: session,
-        connectionId: connId,
-        sessionId: newSessionId,
-    });
-}
-async function handleSessionSetGeo(args) {
-    let sessionName;
-    let geo;
-    let clear = false;
-    for (let i = 0; i < args.length; i++) {
-        if (args[i] === '--browser-session' && args[i + 1]) {
-            sessionName = args[i + 1];
-            i++;
-        }
-        else if (args[i] === '--clear') {
-            clear = true;
-        }
-        else if (!geo && !args[i].startsWith('--')) {
-            geo = args[i];
-        }
-    }
-    if (!geo && !clear) {
-        return output({ error: 'Geo code is required. Usage: aluvia session set-geo <geo> [--browser-session <name>]' }, 1);
-    }
-    if (geo && !geo.trim()) {
-        return output({ error: 'Geo code cannot be empty. Provide a valid geo code or use --clear.' }, 1);
-    }
-    const { session, lock } = resolveSession(sessionName);
-    const connId = requireConnectionId(lock, session);
-    const api = requireApi();
-    const targetGeo = clear ? null : geo.trim();
-    await api.account.connections.patch(connId, { target_geo: targetGeo });
-    return output({
-        browserSession: session,
-        connectionId: connId,
-        targetGeo,
-    });
-}
-async function handleSessionSetRules(args) {
-    let sessionName;
-    let removeRules;
-    let appendRules;
-    for (let i = 0; i < args.length; i++) {
-        if (args[i] === '--browser-session' && args[i + 1]) {
-            sessionName = args[i + 1];
-            i++;
-        }
-        else if (args[i] === '--remove' && args[i + 1]) {
-            removeRules = args[i + 1];
-            i++;
-        }
-        else if (!appendRules && !args[i].startsWith('--')) {
-            appendRules = args[i];
-        }
-    }
-    if (!appendRules && !removeRules) {
-        return output({ error: 'Rules are required. Usage: aluvia session set-rules <rules> [--browser-session <name>]' }, 1);
-    }
-    if (appendRules && removeRules) {
-        return output({ error: 'Cannot both append and remove rules. Use either <rules> or --remove <rules>, not both.' }, 1);
-    }
-    const { session, lock } = resolveSession(sessionName);
-    const connId = requireConnectionId(lock, session);
-    const api = requireApi();
-    // Fetch current rules
-    const conn = await api.account.connections.get(connId);
-    const currentRules = conn?.rules ?? [];
-    let newRules;
-    if (removeRules) {
-        // Remove mode: filter out specified rules
-        const toRemove = new Set(removeRules.split(',').map((r) => r.trim()).filter(Boolean));
-        newRules = currentRules.filter((r) => !toRemove.has(r));
-    }
-    else {
-        // Append mode: add new rules to existing (deduplicate)
-        const toAdd = appendRules.split(',').map((r) => r.trim()).filter(Boolean);
-        const existing = new Set(currentRules);
-        newRules = [...currentRules, ...toAdd.filter((r) => !existing.has(r))];
-    }
-    await api.account.connections.patch(connId, { rules: newRules });
-    return output({
-        browserSession: session,
-        connectionId: connId,
-        rules: newRules,
-        count: newRules.length,
-    });
-}

package/dist/types/bin/account.d.ts

@@ -1 +0,0 @@
-export declare function handleAccount(args: string[]): Promise<void>;

package/dist/types/bin/api-helpers.d.ts

@@ -1,20 +0,0 @@
-import { AluviaApi } from '../api/AluviaApi.js';
-import type { LockData } from '../session/lock.js';
-/**
- * Create an AluviaApi instance from ALUVIA_API_KEY env var.
- * Calls output() and exits if the key is missing.
- */
-export declare function requireApi(): AluviaApi;
-/**
- * Resolve a session by name or auto-select when only one is running.
- * Calls output() and exits on error (no sessions, ambiguous sessions, stale lock).
- */
-export declare function resolveSession(sessionName?: string): {
-    session: string;
-    lock: LockData;
-};
-/**
- * Require a connection ID from lock data.
- * Calls output() and exits if connectionId is missing.
- */
-export declare function requireConnectionId(lock: LockData, session: string): number;

package/dist/types/bin/cli-adapter.d.ts

@@ -1,8 +0,0 @@
-/**
- * Re-exports for @aluvia/mcp. MCP package imports from @aluvia/sdk/cli.
- */
-export { handleSession } from "./session.js";
-export { handleAccount } from "./account.js";
-export { handleGeos } from "./geos.js";
-export { handleOpen } from "./open.js";
-export { captureOutput } from "./mcp-helpers.js";

package/dist/types/bin/cli.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export declare function output(data: Record<string, unknown>, exitCode?: number): never;

package/dist/types/bin/close.d.ts

@@ -1 +0,0 @@
-export declare function handleClose(sessionName?: string, closeAll?: boolean): Promise<void>;

package/dist/types/bin/geos.d.ts

@@ -1 +0,0 @@
-export declare function handleGeos(): Promise<void>;

package/dist/types/bin/mcp-helpers.d.ts

@@ -1,28 +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.
- */
-/**
- * Thrown by output() when in capture mode.
- * Contains the JSON data and exit code that would have been written to stdout.
- */
-export declare class MCPOutputCapture {
-    readonly data: Record<string, unknown>;
-    readonly exitCode: number;
-    constructor(data: Record<string, unknown>, exitCode: number);
-}
-export declare function isCapturing(): boolean;
-/**
- * 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 declare function captureOutput(fn: () => Promise<void> | void): Promise<{
-    data: Record<string, unknown>;
-    isError: boolean;
-}>;

package/dist/types/bin/open.d.ts

@@ -1,21 +0,0 @@
-export type OpenOptions = {
-    url: string;
-    connectionId?: number;
-    headless?: boolean;
-    sessionName?: string;
-    autoUnblock?: boolean;
-    disableBlockDetection?: boolean;
-    run?: string;
-};
-/**
- * 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 declare function handleOpen({ url, connectionId, headless, sessionName, autoUnblock, disableBlockDetection, run }: OpenOptions): Promise<never>;
-/**
- * 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 declare function handleOpenDaemon({ url, connectionId, headless, sessionName, autoUnblock, disableBlockDetection, run }: OpenOptions): Promise<void>;

package/dist/types/bin/session.d.ts

@@ -1,11 +0,0 @@
-export type ParsedSessionArgs = {
-    url?: string;
-    connectionId?: number;
-    headed: boolean;
-    sessionName?: string;
-    autoUnblock: boolean;
-    disableBlockDetection: boolean;
-    run?: string;
-};
-export declare function parseSessionArgs(args: string[]): ParsedSessionArgs;
-export declare function handleSession(args: string[]): Promise<void>;