mcp-camoufox 0.4.8 → 0.5.0

package/dist/index.js

@@ -134,27 +134,56 @@ server.tool("browser_launch", "Launch Camoufox stealth browser and navigate to U
     const w = width > 0 ? width : 1280;
     const h = height > 0 ? height : 800;
     // Auto-download Camoufox binary if not installed
-    try {
+    // camoufox-js does NOT auto-download — we handle it here
+    await (async () => {
         const { execSync } = await import("child_process");
         const { existsSync, readdirSync } = await import("fs");
         const { join: pathJoin } = await import("path");
-        // Check common cache locations
-        const homeDir = process.env.HOME || process.env.USERPROFILE || "";
-        const cacheLocations = [
-            pathJoin(homeDir, ".cache", "camoufox"),
-            pathJoin(homeDir, "Library", "Caches", "camoufox"),
-            pathJoin(homeDir, "AppData", "Local", "camoufox"),
-        ];
-        const isInstalled = cacheLocations.some(dir => existsSync(dir) && readdirSync(dir).length > 2);
+        const os = await import("os");
+        // Detect cache dir per platform (same logic as camoufox-js pkgman.ts)
+        const homeDir = os.homedir();
+        const platform = os.platform();
+        let cacheDir;
+        if (platform === "darwin") {
+            cacheDir = pathJoin(homeDir, "Library", "Caches", "camoufox");
+        }
+        else if (platform === "win32") {
+            cacheDir = pathJoin(process.env.LOCALAPPDATA || pathJoin(homeDir, "AppData", "Local"), "camoufox");
+        }
+        else {
+            cacheDir = pathJoin(process.env.XDG_CACHE_HOME || pathJoin(homeDir, ".cache"), "camoufox");
+        }
+        // Check if binary exists (look for version.json inside cache dir)
+        const versionFile = pathJoin(cacheDir, "version.json");
+        const isInstalled = existsSync(versionFile);
         if (!isInstalled) {
-            console.error("[mcp-camoufox] Camoufox browser not found. Auto-downloading (~500MB, one-time)...");
-            execSync("npx camoufox-js fetch", { stdio: "inherit", timeout: 600000 });
-            console.error("[mcp-camoufox] Download complete.");
+            console.error("");
+            console.error("=".repeat(60));
+            console.error("[mcp-camoufox] First-time setup: downloading Camoufox browser");
+            console.error("[mcp-camoufox] This is ~500MB and only happens once.");
+            console.error("[mcp-camoufox] Please wait 2-5 minutes...");
+            console.error("=".repeat(60));
+            console.error("");
+            try {
+                // Use npx to run camoufox-js CLI fetch command
+                const cmd = platform === "win32" ? "npx.cmd" : "npx";
+                execSync(`${cmd} camoufox-js fetch`, {
+                    stdio: "inherit",
+                    timeout: 900000, // 15 min max
+                    env: { ...process.env, npm_config_yes: "true" },
+                });
+                console.error("");
+                console.error("[mcp-camoufox] Download complete! Browser ready.");
+                console.error("");
+            }
+            catch (fetchErr) {
+                console.error(`[mcp-camoufox] Auto-download failed: ${fetchErr.message?.slice(0, 200)}`);
+                console.error("[mcp-camoufox] Try manually: npx camoufox-js fetch");
+                throw new Error("Camoufox browser binary not found. Auto-download failed. " +
+                    "Please run manually: npx camoufox-js fetch");
+            }
         }
-    }
-    catch (e) {
-        console.error(`[mcp-camoufox] Auto-download check: ${e.message?.slice(0, 100)}`);
-    }
+    })();
     const ctx = await Camoufox({
         headless,
         humanize,
@@ -1250,6 +1279,184 @@ server.tool("scrape_page", "Smart page scraper — auto-detect and extract main
   })()`);
     return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
 });
+// ── Tools: Compound (reduce round-trips) ───────────────────────────────────
+server.tool("wait_and_snapshot", "Wait for selector/text then return snapshot. Combines wait_for + browser_snapshot in one call.", {
+    selector: z.string().default("").describe("CSS selector to wait for"),
+    text: z.string().default("").describe("Text to wait for"),
+    state: z.enum(["visible", "hidden", "attached", "detached"]).default("visible"),
+    timeout: z.number().default(10000),
+}, async ({ selector, text, state, timeout }) => {
+    const page = getPage();
+    if (selector) {
+        await page.locator(selector).first().waitFor({ state, timeout });
+    }
+    else if (text) {
+        await page.getByText(text).first().waitFor({ state, timeout });
+    }
+    const elements = await page.evaluate(SNAPSHOT_JS) || [];
+    const snap = formatSnapshot(elements, page.url(), await page.title());
+    return { content: [{ type: "text", text: snap }] };
+});
+server.tool("back_and_snapshot", "Navigate back + return snapshot.", {}, async () => {
+    const page = getPage();
+    await page.goBack({ waitUntil: "domcontentloaded", timeout: 15000 });
+    await page.waitForTimeout(500);
+    const elements = await page.evaluate(SNAPSHOT_JS) || [];
+    const snap = formatSnapshot(elements, page.url(), await page.title());
+    return { content: [{ type: "text", text: snap }] };
+});
+server.tool("reload_and_snapshot", "Reload page + return snapshot.", {}, async () => {
+    const page = getPage();
+    await page.reload({ waitUntil: "domcontentloaded", timeout: 15000 });
+    await page.waitForTimeout(500);
+    const elements = await page.evaluate(SNAPSHOT_JS) || [];
+    const snap = formatSnapshot(elements, page.url(), await page.title());
+    return { content: [{ type: "text", text: snap }] };
+});
+server.tool("click_and_snapshot", "Click element by ref + wait + return snapshot. Perfect for buttons that trigger navigation/dialog.", {
+    ref: z.string().describe("Element ref from browser_snapshot"),
+    wait_ms: z.number().default(1500).describe("Wait after click before snapshot"),
+}, async ({ ref, wait_ms }) => {
+    const page = getPage();
+    const loc = page.locator(`[data-mcp-ref="${ref}"]`).first();
+    try {
+        await loc.click({ timeout: 5000 });
+    }
+    catch {
+        await loc.evaluate((el) => el.click());
+    }
+    await page.waitForTimeout(wait_ms);
+    const elements = await page.evaluate(SNAPSHOT_JS) || [];
+    const snap = formatSnapshot(elements, page.url(), await page.title());
+    return { content: [{ type: "text", text: snap }] };
+});
+// ── Tools: Smart Selectors (no snapshot needed) ────────────────────────────
+server.tool("find_by_text", "Find element by visible text — returns ref ID or null. Skip browser_snapshot if you know exact text.", {
+    text: z.string().describe("Visible text to search for"),
+    exact: z.boolean().default(true),
+}, async ({ text, exact }) => {
+    const page = getPage();
+    const loc = page.getByText(text, { exact }).first();
+    const count = await loc.count();
+    if (count === 0) {
+        return { content: [{ type: "text", text: `No element found with text "${text}"` }] };
+    }
+    // Tag with ref
+    const info = await loc.evaluate((el) => {
+        const ref = 'f' + Math.floor(Math.random() * 10000);
+        el.setAttribute('data-mcp-ref', ref);
+        return {
+            ref,
+            tag: el.tagName.toLowerCase(),
+            role: el.getAttribute('role') || '',
+            text: (el.innerText || el.value || '').trim().slice(0, 100),
+            href: el.href || '',
+        };
+    });
+    return { content: [{ type: "text", text: JSON.stringify(info, null, 2) }] };
+});
+server.tool("find_by_label", "Find input element by its label text (<label>). Returns ref.", {
+    label: z.string().describe("Label text (e.g. 'Email', 'Password')"),
+}, async ({ label }) => {
+    const page = getPage();
+    const loc = page.getByLabel(label).first();
+    const count = await loc.count();
+    if (count === 0) {
+        return { content: [{ type: "text", text: `No input found with label "${label}"` }] };
+    }
+    const info = await loc.evaluate((el) => {
+        const ref = 'l' + Math.floor(Math.random() * 10000);
+        el.setAttribute('data-mcp-ref', ref);
+        return {
+            ref,
+            tag: el.tagName.toLowerCase(),
+            type: el.type || '',
+            name: el.name || '',
+            placeholder: el.placeholder || '',
+            value: el.value || '',
+        };
+    });
+    return { content: [{ type: "text", text: JSON.stringify(info, null, 2) }] };
+});
+server.tool("find_by_placeholder", "Find input by placeholder text. Returns ref.", {
+    placeholder: z.string(),
+}, async ({ placeholder }) => {
+    const page = getPage();
+    const loc = page.getByPlaceholder(placeholder).first();
+    const count = await loc.count();
+    if (count === 0) {
+        return { content: [{ type: "text", text: `No input with placeholder "${placeholder}"` }] };
+    }
+    const info = await loc.evaluate((el) => {
+        const ref = 'p' + Math.floor(Math.random() * 10000);
+        el.setAttribute('data-mcp-ref', ref);
+        return {
+            ref, tag: el.tagName.toLowerCase(), type: el.type || '', placeholder: el.placeholder || '',
+        };
+    });
+    return { content: [{ type: "text", text: JSON.stringify(info, null, 2) }] };
+});
+// ── Tools: Cookie Portability ──────────────────────────────────────────────
+server.tool("cookie_export", "Export all cookies as JSON string. Use with cookie_import to transfer session.", {
+    domain: z.string().default("").describe("Filter by domain (empty = all)"),
+}, async ({ domain }) => {
+    if (!browserContext)
+        throw new Error("Browser not running.");
+    let cookies = await browserContext.cookies();
+    if (domain)
+        cookies = cookies.filter(c => c.domain.includes(domain));
+    return { content: [{ type: "text", text: JSON.stringify(cookies, null, 2) }] };
+});
+server.tool("cookie_import", "Import cookies from JSON (from cookie_export). Restores session state.", {
+    cookies_json: z.string().describe("JSON array of cookies"),
+}, async ({ cookies_json }) => {
+    if (!browserContext)
+        throw new Error("Browser not running.");
+    let cookies;
+    try {
+        cookies = JSON.parse(cookies_json);
+        if (!Array.isArray(cookies))
+            throw new Error("not an array");
+    }
+    catch (e) {
+        return { content: [{ type: "text", text: `Invalid cookies JSON: ${e.message}` }] };
+    }
+    await browserContext.addCookies(cookies);
+    return { content: [{ type: "text", text: `Imported ${cookies.length} cookies.` }] };
+});
+// ── Tools: Page Stats (debug/decision) ─────────────────────────────────────
+server.tool("page_stats", "Page statistics: element count, size, load metrics. Use to decide extraction strategy.", {}, async () => {
+    const page = getPage();
+    const stats = await page.evaluate(`(() => {
+      var all = document.querySelectorAll('*').length;
+      var interactive = document.querySelectorAll('button, a, input, select, textarea, [role="button"], [role="link"]').length;
+      var images = document.querySelectorAll('img').length;
+      var forms = document.querySelectorAll('form').length;
+      var iframes = document.querySelectorAll('iframe').length;
+      var scripts = document.querySelectorAll('script').length;
+      var bodyTextLen = (document.body.innerText || '').length;
+      var htmlLen = document.documentElement.outerHTML.length;
+      var perf = window.performance && window.performance.timing ? {
+        domComplete: window.performance.timing.domComplete - window.performance.timing.navigationStart,
+        loadEnd: window.performance.timing.loadEventEnd - window.performance.timing.navigationStart,
+      } : null;
+      return {
+        url: location.href,
+        title: document.title,
+        total_elements: all,
+        interactive_elements: interactive,
+        images: images,
+        forms: forms,
+        iframes: iframes,
+        scripts: scripts,
+        body_text_length: bodyTextLen,
+        html_size: htmlLen,
+        performance_ms: perf,
+        recommendation: all > 3000 ? 'Use extract_structured or scrape_page (heavy page)' : 'browser_snapshot OK',
+      };
+    })()`);
+    return { content: [{ type: "text", text: JSON.stringify(stats, null, 2) }] };
+});
 // ── Start Server ───────────────────────────────────────────────────────────
 async function main() {
     const transport = new StdioServerTransport();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-camoufox",
-  "version": "0.4.8",
+  "version": "0.5.0",
   "description": "MCP server for stealth browser automation via Camoufox — 39 tools, Chrome DevTools MCP-level power with anti-bot stealth",
   "type": "module",
   "main": "dist/index.js",
@@ -16,8 +16,7 @@
     "build": "tsc",
     "start": "node dist/index.js",
     "dev": "tsc --watch",
-    "prepublishOnly": "npm run build",
-    "postinstall": "npx camoufox-js fetch || echo '[mcp-camoufox] Browser will download on first launch.'"
+    "prepublishOnly": "npm run build"
   },
   "keywords": [
     "mcp",