aether-mcp-server 2.0.2 → 2.1.1

package/dist/bridge/navigation.js

@@ -0,0 +1,146 @@
+"use strict";
+/**
+ * Browser navigation and tab management functions extracted from cdp-bridge.ts.
+ *
+ * Each function takes a CdpClient, params, and optional dependencies (snapshotCache,
+ * logger) and returns a result. This module is designed to be consumed by the bridge
+ * layer and can also be used directly by other parts of the server.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connect = connect;
+exports.navigate = navigate;
+exports.getTabs = getTabs;
+exports.newTab = newTab;
+exports.switchTab = switchTab;
+exports.closeTab = closeTab;
+exports.smartNavigate = smartNavigate;
+const eval_scripts_1 = require("../eval-scripts");
+// ─── Connect ────────────────────────────────────────────────────────────
+/**
+ * Connect to an existing Chrome instance on the given debugging port.
+ */
+async function connect(client, params) {
+    const port = params.port ?? 9222;
+    await client.connect(port);
+    return 'Connected to browser';
+}
+// ─── Navigate ────────────────────────────────────────────────────────────
+/**
+ * Navigate the active tab to a URL and wait for the page to settle.
+ * Invalidates the snapshot cache after navigation.
+ */
+async function navigate(client, params, snapshotCache) {
+    await client.navigateAndWait(params.url, params.timeout ?? 10000);
+    snapshotCache.invalidate('navigate');
+    return 'Navigated';
+}
+// ─── Tab Management ─────────────────────────────────────────────────────
+/**
+ * Get all open browser tabs (targets).
+ */
+async function getTabs(client, _params) {
+    const result = await client.sendCommand('Target.getTargets', {});
+    return result.targetInfos ?? [];
+}
+/**
+ * Open a new tab with an optional URL.
+ */
+async function newTab(client, params) {
+    const result = await client.sendCommand('Target.createTarget', {
+        url: params.url ?? 'about:blank',
+    });
+    return result.targetId
+        ? `Created new tab: ${result.targetId}`
+        : 'Created new tab';
+}
+/**
+ * Switch the active debugging session to a different tab.
+ * Requires the targetId of the tab to switch to.
+ */
+async function switchTab(client, params) {
+    if (!params.targetId) {
+        throw new Error('targetId required to switch tabs');
+    }
+    await client.sendCommand('Target.activateTarget', {
+        targetId: params.targetId,
+    });
+    await client.switchToTarget(params.targetId, params.port ?? 9222);
+    return `Switched to tab ${params.targetId}`;
+}
+/**
+ * Close a tab by its targetId.
+ */
+async function closeTab(client, params) {
+    await client.sendCommand('Target.closeTarget', {
+        targetId: params.targetId,
+    });
+    return 'Closed tab';
+}
+/**
+ * Navigate to a URL with optional popup dismissal, condition waiting, and
+ * screenshot capture. This is a higher-level wrapper around navigate().
+ */
+async function smartNavigate(client, params, snapshotCache, logger) {
+    const { url, waitFor, dismissPopups, screenshot, timeout } = params;
+    const timeoutMs = timeout ?? 30000;
+    try {
+        logger.info(`smartNavigate: Navigating to ${url}`, { timeout: timeoutMs });
+        await client.navigateAndWait(url, timeoutMs);
+        snapshotCache.invalidate('smartNavigate');
+        // Dismiss popups if requested (default: true)
+        if (dismissPopups !== false) {
+            logger.debug('smartNavigate: Dismissing popups');
+            await client.evaluate(eval_scripts_1.DISMISS_POPUPS_SCRIPT).catch((err) => {
+                logger.warn('smartNavigate: Popup dismissal failed', {
+                    error: err.message,
+                });
+            });
+        }
+        // Wait for a specific condition after navigation
+        if (waitFor) {
+            if (waitFor.type === 'network_idle') {
+                logger.debug('smartNavigate: Waiting for network idle', {
+                    timeout: waitFor.timeout ?? 3000,
+                });
+                await client
+                    .waitForNetworkIdle(500, waitFor.timeout ?? 3000)
+                    .catch(() => { });
+            }
+            else if (waitFor.type === 'element' && waitFor.selector) {
+                logger.debug('smartNavigate: Waiting for selector', {
+                    selector: waitFor.selector,
+                    timeout: waitFor.timeout ?? 5000,
+                });
+                await client
+                    .waitForSelector(waitFor.selector, waitFor.timeout ?? 5000)
+                    .catch(() => { });
+            }
+        }
+        // Collect current page info
+        const currentUrl = await client
+            .evaluate('window.location.href')
+            .catch(() => url);
+        const title = await client
+            .evaluate('document.title')
+            .catch(() => 'Unknown');
+        // Optionally take a screenshot
+        const screenshotData = screenshot === true
+            ? await client.screenshot('jpeg', 70).catch(() => null)
+            : null;
+        logger.info('smartNavigate: Complete', {
+            finalUrl: currentUrl,
+            title,
+            hasScreenshot: screenshotData !== null,
+        });
+        return {
+            success: true,
+            url: currentUrl,
+            title,
+            screenshot: screenshotData,
+        };
+    }
+    catch (e) {
+        logger.error('smartNavigate: Failed', { error: e.message, url });
+        return { success: false, url, title: 'Unknown', error: e.message };
+    }
+}

package/dist/bridge/session.js

@@ -0,0 +1,287 @@
+"use strict";
+/**
+ * Session, auth, and browser management functions extracted from cdp-bridge.ts.
+ *
+ * Each function takes a CdpClient (and optional dependencies like PageSnapshotCache)
+ * and returns a result. This module is designed to be consumed by the bridge layer
+ * and can also be used directly by other parts of the server.
+ */
+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.defaultAuthStatePath = defaultAuthStatePath;
+exports.toCookieParam = toCookieParam;
+exports.saveAuthState = saveAuthState;
+exports.loadAuthState = loadAuthState;
+exports.launchBrowser = launchBrowser;
+exports.killBrowser = killBrowser;
+exports.listBrowsers = listBrowsers;
+exports.listBrowserProfiles = listBrowserProfiles;
+exports.getCookies = getCookies;
+exports.setCookie = setCookie;
+exports.clearCache = clearCache;
+const eval_scripts_1 = require("../eval-scripts");
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+// ─── Helpers ───────────────────────────────────────────────────────────
+/**
+ * Resolve the default path for the auth-state JSON file.
+ * Defaults to <cwd>/.aether/auth-state.json unless a custom path is provided.
+ */
+function defaultAuthStatePath(custom) {
+    if (custom)
+        return path.resolve(String(custom));
+    return path.resolve(process.cwd(), ".aether", "auth-state.json");
+}
+/**
+ * Strip read-only fields from CDP Cookie objects so they can be passed
+ * to Network.setCookies as CookieParam objects.
+ *
+ * CDP Network.getAllCookies returns Cookie objects with extra fields
+ * (size, session, etc.) that Network.setCookies rejects.
+ * Keep only the writable CookieParam fields.
+ */
+function toCookieParam(c) {
+    const param = {
+        name: c.name,
+        value: c.value,
+        domain: c.domain,
+        path: c.path,
+        secure: c.secure,
+        httpOnly: c.httpOnly,
+    };
+    if (typeof c.expires === "number" && c.expires > 0)
+        param.expires = c.expires;
+    if (c.sameSite)
+        param.sameSite = c.sameSite;
+    if (c.priority)
+        param.priority = c.priority;
+    if (c.sourceScheme)
+        param.sourceScheme = c.sourceScheme;
+    if (typeof c.sourcePort === "number")
+        param.sourcePort = c.sourcePort;
+    if (c.partitionKey)
+        param.partitionKey = c.partitionKey;
+    return param;
+}
+/**
+ * Export the current session (cookies + localStorage + sessionStorage of the
+ * active origin) to a JSON file so a logged-in state can be reused later.
+ */
+async function saveAuthState(client, params, snapshotCache) {
+    const filePath = defaultAuthStatePath(params.path);
+    // Collect cookies (try Network API first, fall back to Storage API)
+    const cookiesRes = await client
+        .sendCommand("Network.getAllCookies", {})
+        .catch(() => client.sendCommand("Storage.getCookies", {}).catch(() => ({ cookies: [] })));
+    const cookies = (cookiesRes?.cookies || []).map((c) => toCookieParam(c));
+    // Collect localStorage and sessionStorage for the active origin
+    const storage = await client.evaluate(eval_scripts_1.EXPORT_STORAGE_SCRIPT).catch(() => null);
+    const state = {
+        version: 1,
+        savedAt: new Date().toISOString(),
+        cookies,
+        origins: storage ? [storage] : [],
+    };
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, JSON.stringify(state, null, 2), "utf8");
+    return {
+        success: true,
+        path: filePath,
+        cookies: cookies.length,
+        origins: state.origins.length,
+        storageKeys: storage
+            ? Object.keys(storage.localStorage).length +
+                Object.keys(storage.sessionStorage).length
+            : 0,
+    };
+}
+/**
+ * Restore a session saved by saveAuthState. Cookies are set globally; storage
+ * is restored for the active origin (navigate to the site first), then the tab
+ * is reloaded so the session takes effect.
+ */
+async function loadAuthState(client, params, snapshotCache) {
+    const filePath = defaultAuthStatePath(params.path);
+    let raw;
+    try {
+        raw = await fs.readFile(filePath, "utf8");
+    }
+    catch (e) {
+        return {
+            success: false,
+            path: filePath,
+            message: `Could not read auth state: ${e?.message}`,
+        };
+    }
+    let state;
+    try {
+        state = JSON.parse(raw);
+    }
+    catch (e) {
+        return {
+            success: false,
+            path: filePath,
+            message: `Invalid auth state JSON: ${e?.message}`,
+        };
+    }
+    let cookiesSet = 0;
+    if (Array.isArray(state.cookies) && state.cookies.length) {
+        const cookieParams = state.cookies.map((c) => toCookieParam(c));
+        await client.setCookies(cookieParams).catch((err) => {
+            console.error("[Aether] setCookies failed during loadAuthState:", err?.message);
+        });
+        cookiesSet = cookieParams.length;
+    }
+    let storageRestored = 0;
+    let storageSkipped = 0;
+    const currentOrigin = await client
+        .evaluate("location.origin")
+        .catch(() => "");
+    for (const entry of state.origins || []) {
+        if (entry.origin && currentOrigin && entry.origin !== currentOrigin) {
+            storageSkipped++;
+            continue;
+        }
+        const data = JSON.stringify({
+            localStorage: entry.localStorage || {},
+            sessionStorage: entry.sessionStorage || {},
+        });
+        const ok = await client
+            .evaluate(`
+                (function() {
+                    try {
+                        const data = ${data};
+                        for (const k in data.localStorage) localStorage.setItem(k, data.localStorage[k]);
+                        for (const k in data.sessionStorage) sessionStorage.setItem(k, data.sessionStorage[k]);
+                        return true;
+                    } catch (e) { return false; }
+                })()
+            `)
+            .catch(() => false);
+        if (ok)
+            storageRestored++;
+    }
+    if (params.reload !== false) {
+        await client.reload(false).catch(() => { });
+    }
+    snapshotCache.invalidate("load_auth_state");
+    return {
+        success: true,
+        path: filePath,
+        cookiesSet,
+        storageRestored,
+        storageSkipped,
+        note: storageSkipped > 0
+            ? "Some storage origins were skipped; navigate to that origin before loading to restore them."
+            : undefined,
+    };
+}
+/**
+ * Launch a new browser instance using automatic detection.
+ * If no browser is specified, the client will auto-detect available browsers.
+ */
+async function launchBrowser(client, options) {
+    await client.launchAuto({
+        browser: options?.browser,
+        headless: options?.headless,
+        port: options?.port,
+        profile: options?.profile,
+        profileDirectory: options?.profileDirectory,
+        userDataDir: options?.userDataDir,
+    });
+    const profileLabel = options?.profile || options?.profileDirectory;
+    return profileLabel
+        ? `Browser launched successfully with profile "${profileLabel}"`
+        : "Browser launched successfully";
+}
+/**
+ * Kill the currently managed browser process.
+ */
+async function killBrowser(client) {
+    await client.killBrowser();
+    return "Browser killed";
+}
+/**
+ * List all available (installed) browsers on the system.
+ */
+async function listBrowsers(client) {
+    return await client.listAvailableBrowsers();
+}
+/**
+ * List browser profiles for a given browser (defaults to Brave).
+ */
+async function listBrowserProfiles(client, browser) {
+    return await client.listBrowserProfiles(browser || "brave");
+}
+// ─── Cookie & Cache Management ─────────────────────────────────────────
+/**
+ * Get all cookies for the current page URL.
+ */
+async function getCookies(client) {
+    const result = await client.sendCommand("Network.getCookies", {
+        urls: [
+            (await client.evaluate("window.location.href").catch(() => "*")) ||
+                "*",
+        ],
+    });
+    return result.cookies || [];
+}
+/**
+ * Set a single cookie on the current page.
+ */
+async function setCookie(client, params) {
+    const cookies = [
+        {
+            name: params.cookieName || params.name,
+            value: params.cookieValue || params.value,
+            url: params.url ||
+                (await client.evaluate("window.location.href").catch(() => undefined)),
+            domain: params.domain,
+            path: params.path || "/",
+            secure: params.secure || false,
+            httpOnly: params.httpOnly || false,
+        },
+    ];
+    await client.sendCommand("Network.setCookies", { cookies });
+    return "Cookie set";
+}
+/**
+ * Clear the browser cache and all cookies.
+ */
+async function clearCache(client) {
+    await client.sendCommand("Network.clearBrowserCache", {});
+    await client.sendCommand("Network.clearBrowserCookies", {});
+    return "Cache cleared";
+}