@aluvia/sdk 1.0.0 → 1.3.0

package/dist/esm/bin/session.js

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