mcp-fs-shell-windows 0.2.19 → 0.2.29

package/dist/analyze_project/handler.js

@@ -0,0 +1,62 @@
+// analyze_project/handler.ts — project-wide linting (MCP filesystem fork).
+//
+// Port of the Beledarian analyze_project tool (beledarians-lm-studio-tools
+// src/toolsProvider.ts). Detection ladder, exactly as the reference:
+//   1. package.json with scripts.lint          -> npm run lint        (npm-script)
+//   2. else eslint in (dev)dependencies       -> npx eslint . --format json (eslint)
+//   3. else (only when package.json is absent/unreadable) any .py file -> pylint . (python-lint)
+// The working directory is the shell_cwd default CWD (fork equivalent of the
+// reference's currentWorkingDirectory).
+import { readFile, readdir } from "fs/promises";
+import { join } from "path";
+import { spawn } from "child_process";
+import { getDefaultShellCwd } from "../shell/handler.js";
+export async function handleAnalyzeProject() {
+    // Try to detect available linters
+    const cwd = getDefaultShellCwd();
+    const packageJsonPath = join(cwd, "package.json");
+    let command = "";
+    let type = "unknown";
+    try {
+        const pkg = JSON.parse(await readFile(packageJsonPath, "utf-8"));
+        if (pkg.scripts && pkg.scripts.lint) {
+            command = "npm run lint";
+            type = "npm-script";
+        }
+        else if (pkg.devDependencies?.eslint || pkg.dependencies?.eslint) {
+            command = "npx eslint . --format json"; // JSON for easier parsing? Or just text.
+            type = "eslint";
+        }
+    }
+    catch (e) {
+        // check for python?
+        const entries = await readdir(cwd);
+        if (entries.some(f => f.endsWith(".py"))) {
+            command = "pylint ."; // Assuming pylint is in path
+            type = "python-lint";
+        }
+    }
+    if (!command) {
+        return JSON.stringify({ error: "Could not detect a supported linter (ESLint script or Python)." });
+    }
+    try {
+        const child = spawn(command, {
+            shell: true,
+            cwd,
+            timeout: 60000
+        });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", d => stdout += d);
+        child.stderr.on("data", d => stderr += d);
+        await new Promise((resolve) => child.on("close", () => resolve()));
+        return JSON.stringify({
+            tool: command,
+            type,
+            report: (stdout + stderr).substring(0, 10000) // Limit size
+        });
+    }
+    catch (e) {
+        return JSON.stringify({ error: `Analysis failed: ${e instanceof Error ? e.message : String(e)}` });
+    }
+}

package/dist/analyze_project/schema.js

@@ -0,0 +1,5 @@
+import { z } from "zod";
+// analyze_project takes no parameters: it operates on the current working
+// directory (the shell_cwd default CWD — the fork's equivalent of the
+// reference's currentWorkingDirectory).
+export const AnalyzeProjectArgsSchema = z.object({});

package/dist/browser/browserActions.js

@@ -0,0 +1,128 @@
+export async function executeBrowserActions(page, actions) {
+    const actionLog = [];
+    const clickRetryDelayMs = 300;
+    const safeClick = async (selector, clickCount) => {
+        await page.waitForSelector(selector, { timeout: 15000 });
+        const performClick = async () => {
+            if (clickCount) {
+                await page.click(selector, { clickCount });
+            }
+            else {
+                await page.click(selector);
+            }
+        };
+        try {
+            await performClick();
+            return;
+        }
+        catch {
+            try {
+                await new Promise(resolve => setTimeout(resolve, clickRetryDelayMs));
+                await performClick();
+                return;
+            }
+            catch {
+                // Continue to DOM fallback.
+            }
+            const fallbackResult = await page.evaluate(({ targetSelector, targetClickCount }) => {
+                const target = document.querySelector(targetSelector);
+                if (!(target instanceof HTMLElement)) {
+                    return { ok: false, reason: "not-an-element" };
+                }
+                target.scrollIntoView({ behavior: "auto", block: "center", inline: "center" });
+                const rect = target.getBoundingClientRect();
+                if (rect.width <= 0 || rect.height <= 0) {
+                    return { ok: false, reason: "not-clickable" };
+                }
+                if (targetClickCount && targetClickCount >= 3 && (target instanceof HTMLInputElement || target instanceof HTMLTextAreaElement)) {
+                    target.select();
+                }
+                target.click();
+                return { ok: true };
+            }, { targetSelector: selector, targetClickCount: clickCount ?? 1 });
+            if (!fallbackResult?.ok) {
+                const reason = fallbackResult?.reason || "unknown";
+                throw new Error(`Action 'click' failed for selector '${selector}' (${reason}).`);
+            }
+        }
+    };
+    for (const action of actions) {
+        if (action.type === "wait_for_selector") {
+            if (!action.selector)
+                throw new Error("Action 'wait_for_selector' requires 'selector'.");
+            await page.waitForSelector(action.selector, { timeout: 15000 });
+            actionLog.push(`wait_for_selector:${action.selector}`);
+        }
+        else if (action.type === "wait") {
+            const ms = action.milliseconds ?? 500;
+            await new Promise(resolve => setTimeout(resolve, ms));
+            actionLog.push(`wait:${ms}`);
+        }
+        else if (action.type === "click") {
+            if (!action.selector)
+                throw new Error("Action 'click' requires 'selector'.");
+            await safeClick(action.selector);
+            actionLog.push(`click:${action.selector}`);
+        }
+        else if (action.type === "type") {
+            if (!action.selector)
+                throw new Error("Action 'type' requires 'selector'.");
+            if (typeof action.text !== "string")
+                throw new Error("Action 'type' requires 'text'.");
+            await safeClick(action.selector, 3);
+            await page.keyboard.press("Backspace");
+            await page.type(action.selector, action.text, { delay: 20 });
+            actionLog.push(`type:${action.selector}`);
+        }
+        else if (action.type === "press") {
+            if (!action.key)
+                throw new Error("Action 'press' requires 'key'.");
+            await page.keyboard.press(action.key);
+            actionLog.push(`press:${action.key}`);
+        }
+        else if (action.type === "select") {
+            if (!action.selector)
+                throw new Error("Action 'select' requires 'selector'.");
+            if (typeof action.value !== "string")
+                throw new Error("Action 'select' requires 'value'.");
+            const selected = await page.select(action.selector, action.value);
+            if (selected.length === 0)
+                throw new Error(`Action 'select' found no matching option for '${action.value}'.`);
+            actionLog.push(`select:${action.selector}`);
+        }
+        else if (action.type === "hover") {
+            if (!action.selector)
+                throw new Error("Action 'hover' requires 'selector'.");
+            await page.hover(action.selector);
+            actionLog.push(`hover:${action.selector}`);
+        }
+        else if (action.type === "scroll") {
+            if (action.selector) {
+                await page.evaluate((selector) => {
+                    const target = document.querySelector(selector);
+                    if (!target)
+                        throw new Error(`Selector not found: ${selector}`);
+                    target.scrollIntoView({ behavior: "auto", block: "center", inline: "nearest" });
+                }, action.selector);
+                actionLog.push(`scroll_into_view:${action.selector}`);
+            }
+            else {
+                const x = action.x ?? 0;
+                const y = action.y ?? 600;
+                await page.evaluate(({ dx, dy }) => { window.scrollBy(dx, dy); }, { dx: x, dy: y });
+                actionLog.push(`scroll:${x},${y}`);
+            }
+        }
+        else if (action.type === "evaluate") {
+            if (!action.script)
+                throw new Error("Action 'evaluate' requires 'script'.");
+            await page.evaluate((script) => {
+                // Intentionally executes custom page-side code for advanced automation.
+                // eslint-disable-next-line no-new-func
+                return Function(`"use strict";\n${script}`)();
+            }, action.script);
+            actionLog.push("evaluate");
+        }
+    }
+    return actionLog;
+}

package/dist/browser/fuzzySearch.js

@@ -0,0 +1,49 @@
+function normalize(input) {
+    return input.toLowerCase().replace(/\s+/g, " ").trim();
+}
+export function levenshteinDistance(a, b) {
+    const left = normalize(a);
+    const right = normalize(b);
+    const m = left.length;
+    const n = right.length;
+    if (m === 0)
+        return n;
+    if (n === 0)
+        return m;
+    const prev = new Array(n + 1);
+    const curr = new Array(n + 1);
+    for (let j = 0; j <= n; j++)
+        prev[j] = j;
+    for (let i = 1; i <= m; i++) {
+        curr[0] = i;
+        for (let j = 1; j <= n; j++) {
+            const cost = left[i - 1] === right[j - 1] ? 0 : 1;
+            curr[j] = Math.min(prev[j] + 1, curr[j - 1] + 1, prev[j - 1] + cost);
+        }
+        for (let j = 0; j <= n; j++)
+            prev[j] = curr[j];
+    }
+    return prev[n];
+}
+export function computeFuzzyScore(query, candidate) {
+    const q = normalize(query);
+    const c = normalize(candidate);
+    if (!q || !c)
+        return 0;
+    if (q === c)
+        return 1;
+    if (c.includes(q)) {
+        const coverage = q.length / c.length;
+        return Math.min(1, 0.85 + coverage * 0.15);
+    }
+    const distance = levenshteinDistance(q, c);
+    const maxLen = Math.max(q.length, c.length);
+    return Math.max(0, 1 - distance / maxLen);
+}
+export function rankFuzzyMatches(query, candidates, limit = 5) {
+    const ranked = candidates
+        .map(value => ({ value, score: computeFuzzyScore(query, value) }))
+        .sort((a, b) => b.score - a.score || a.value.length - b.value.length)
+        .slice(0, limit);
+    return ranked;
+}

package/dist/browser/handler.js

@@ -0,0 +1,227 @@
+import { validatePath } from "../helpers/path.js";
+import { launchBrowser, closeBrowserQuiet } from "./launcher.js";
+import { closeSession, getSession, setSession } from "./session.js";
+import { executeBrowserActions } from "./browserActions.js";
+import { rankFuzzyMatches } from "./fuzzySearch.js";
+// In-page candidate collection for fuzzy find (ported from the Beledarian
+// reference): interactive + text nodes, deduped on (text||selector), capped
+// at 400 candidates. Runs inside the page context.
+const collectFuzzyCandidates = (page) => page.evaluate(() => {
+    const dedup = new Map();
+    const nodes = document.querySelectorAll("a,button,input,textarea,select,[role='button'],[aria-label],h1,h2,h3,h4,h5,h6,p,span");
+    const clean = (value) => value.replace(/\s+/g, " ").trim();
+    const classSelector = (el) => {
+        const classes = Array.from(el.classList).slice(0, 2).map(c => c.replace(/[^a-zA-Z0-9_-]/g, ""));
+        return classes.length > 0 ? `.${classes.join(".")}` : "";
+    };
+    const buildSelector = (el) => {
+        if (el.id)
+            return `#${el.id}`;
+        const name = el.getAttribute("name");
+        if (name)
+            return `${el.tagName.toLowerCase()}[name="${name.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"]`;
+        return `${el.tagName.toLowerCase()}${classSelector(el)}`;
+    };
+    for (const node of nodes) {
+        const element = node;
+        const text = clean(element.innerText ||
+            element.value ||
+            element.getAttribute("aria-label") ||
+            "");
+        if (!text)
+            continue;
+        const selector = buildSelector(element);
+        const key = `${text}||${selector}`;
+        if (!dedup.has(key)) {
+            dedup.set(key, { text: text.substring(0, 200), selector });
+        }
+        if (dedup.size >= 400)
+            break;
+    }
+    return Array.from(dedup.values());
+});
+// browser_session_open: launch (replacing any existing session), navigate,
+// optionally wait for a selector, and optionally return full page text.
+export async function handleBrowserSessionOpen(url, waitForSelector, includePageText) {
+    try {
+        if (getSession()) {
+            await closeSession();
+        }
+        const browser = await launchBrowser();
+        const page = await browser.newPage();
+        try {
+            await page.goto(url, { waitUntil: "networkidle0", timeout: 30000 });
+            if (waitForSelector) {
+                await page.waitForSelector(waitForSelector, { timeout: 15000 });
+            }
+        }
+        catch (error) {
+            await closeBrowserQuiet(browser);
+            throw error;
+        }
+        setSession({ browser, page, currentUrl: page.url() });
+        const pageText = includePageText !== false
+            ? await page.evaluate(() => document.body.innerText || "")
+            : undefined;
+        return JSON.stringify({
+            success: true,
+            session_active: true,
+            url: page.url(),
+            title: await page.title(),
+            text_content: pageText,
+            text_length: pageText ? pageText.length : 0,
+            message: "Browser session opened.",
+        });
+    }
+    catch (error) {
+        return JSON.stringify({
+            error: `Failed to open browser session: ${error instanceof Error ? error.message : String(error)}`,
+        });
+    }
+}
+// browser_session_control: run actions on the active page, optionally capture
+// a screenshot, return page metadata (full text only on URL change or with
+// full_read), and optionally fuzzy-find in-page text/selectors.
+export async function handleBrowserSessionControl(args, allowedDirectories) {
+    const session = getSession();
+    if (!session) {
+        return JSON.stringify({
+            error: "No active browser session. Call 'browser_session_open' first.",
+        });
+    }
+    try {
+        const beforeUrl = session.page.url();
+        const actionLog = await executeBrowserActions(session.page, args.actions || []);
+        const afterUrl = session.page.url();
+        const urlChanged = beforeUrl !== afterUrl;
+        session.currentUrl = afterUrl;
+        let screenshotSaved = false;
+        if (args.screenshot_path) {
+            const screenshotFilePath = await validatePath(args.screenshot_path, allowedDirectories);
+            await session.page.screenshot({ path: screenshotFilePath, fullPage: args.full_page_screenshot ?? false });
+            screenshotSaved = true;
+        }
+        let pageSnapshot = undefined;
+        if (args.read_page !== false) {
+            const title = await session.page.title();
+            if (urlChanged || args.full_read) {
+                const textContent = await session.page.evaluate(() => document.body.innerText || "");
+                pageSnapshot = {
+                    url: afterUrl,
+                    title,
+                    text_content: textContent,
+                    text_length: textContent.length,
+                };
+            }
+            else {
+                pageSnapshot = {
+                    url: afterUrl,
+                    title,
+                    note: "Full page text omitted (URL unchanged). Set full_read=true to force full output.",
+                };
+            }
+        }
+        let fuzzyResults = [];
+        if (typeof args.fuzzy_find === "string" && args.fuzzy_find.trim()) {
+            const query = args.fuzzy_find;
+            const candidates = await collectFuzzyCandidates(session.page);
+            const ranked = candidates
+                .map(candidate => ({
+                ...candidate,
+                score: Math.max(rankFuzzyMatches(query, [candidate.text], 1)[0]?.score ?? 0, rankFuzzyMatches(query, [candidate.selector], 1)[0]?.score ?? 0),
+            }))
+                .sort((a, b) => b.score - a.score)
+                .slice(0, args.max_results ?? 5);
+            fuzzyResults = ranked.map(item => ({
+                text: item.text,
+                selector: item.selector,
+                score: item.score,
+            }));
+        }
+        return JSON.stringify({
+            success: true,
+            session_active: true,
+            actions_executed: actionLog,
+            screenshot_saved: screenshotSaved,
+            url_changed: urlChanged,
+            url_change_notice: urlChanged ? `Url changed to -> [${afterUrl}]` : undefined,
+            page: pageSnapshot,
+            fuzzy_find_results: fuzzyResults,
+        });
+    }
+    catch (error) {
+        return JSON.stringify({
+            error: `Browser session control failed: ${error instanceof Error ? error.message : String(error)}`,
+        });
+    }
+}
+// browser_session_close: tear down the active session (idempotent).
+export async function handleBrowserSessionClose() {
+    if (!getSession()) {
+        return JSON.stringify({
+            success: true,
+            session_active: false,
+            message: "No active browser session.",
+        });
+    }
+    try {
+        await closeSession();
+        return JSON.stringify({
+            success: true,
+            session_active: false,
+            message: "Browser session closed.",
+        });
+    }
+    catch (error) {
+        return JSON.stringify({
+            error: `Failed to close browser session: ${error instanceof Error ? error.message : String(error)}`,
+        });
+    }
+}
+// browser_open_page: stateless one-shot render (own browser instance, always
+// closed on return; never touches the persistent session).
+export async function handleBrowserOpenPage(args, allowedDirectories) {
+    let browser;
+    try {
+        browser = await launchBrowser();
+        const page = await browser.newPage();
+        try {
+            await page.goto(args.url, { waitUntil: "networkidle0", timeout: 30000 });
+            if (args.wait_for_selector) {
+                await page.waitForSelector(args.wait_for_selector, { timeout: 10000 });
+            }
+            const beforeActionUrl = page.url();
+            const actionLog = await executeBrowserActions(page, args.actions || []);
+            const currentUrl = page.url();
+            const urlChanged = currentUrl !== beforeActionUrl;
+            const title = await page.title();
+            const textContent = await page.evaluate(() => document.body.innerText || "");
+            let screenshotSaved = false;
+            if (args.screenshot_path) {
+                const screenshotFilePath = await validatePath(args.screenshot_path, allowedDirectories);
+                await page.screenshot({ path: screenshotFilePath, fullPage: args.full_page_screenshot ?? false });
+                screenshotSaved = true;
+            }
+            return JSON.stringify({
+                url: currentUrl,
+                title,
+                text_content: textContent.substring(0, 5000),
+                screenshot_saved: screenshotSaved,
+                actions_executed: actionLog,
+                url_changed: urlChanged,
+                url_change_notice: urlChanged ? `Url changed to -> [${currentUrl}]` : undefined,
+            });
+        }
+        finally {
+            await closeBrowserQuiet(browser);
+        }
+    }
+    catch (error) {
+        if (browser) {
+            await closeBrowserQuiet(browser);
+        }
+        return JSON.stringify({
+            error: `Browser operation failed: ${error instanceof Error ? error.message : String(error)}`,
+        });
+    }
+}

package/dist/browser/launcher.js

@@ -0,0 +1,103 @@
+import fs from "fs";
+import nodePath from "path";
+import os from "os";
+// Chrome-for-Testing build 142.0.7444.175, preinstalled at
+// C:\Users\Gerar\.cache\puppeteer (installed for the Beledarian browser tools;
+// pairs with puppeteer 24.31). puppeteer-core is a pure-JS dependency (no
+// browser download); ALL browser launches in this repo go through this single
+// module so web_search's browser legs (duckduckgo-html / google / bing) and
+// the browser_session_* / browser_open_page tools share one launcher:
+//
+//   * getSharedBrowser / closeSharedBrowser - the web_search shared browser
+//     (module-level; one search call reuses a single instance across legs and
+//     each leg closes it afterwards).
+//   * launchBrowser - a fresh standalone instance (used by the persistent
+//     browser session and the stateless browser_open_page one-shot).
+//
+// The persistent session (browser/session.ts) deliberately holds its OWN
+// browser instance so web_search legs can never close it mid-session.
+//
+// Executable resolution (v0.2.29 publish portability):
+//   1. env MCP_CHROME_PATH (explicit; must exist)
+//   2. the standard puppeteer cache <home>/.cache/puppeteer/chrome/<build>/,
+//      highest version wins (e.g. win64-142.0.7444.175/chrome-win64/chrome.exe)
+//   3. the legacy hardcoded path (the reference machine's preinstall)
+export const CHROME_PATH = "C:\\Users\\Gerar\\.cache\\puppeteer\\chrome\\win64-142.0.7444.175\\chrome-win64\\chrome.exe";
+// Compare two "win64-<a.b.c.d>" build dirs numerically (ascending).
+function compareBuildDirs(a, b) {
+    const pa = a.replace(/^win64-/, "").split(".").map((n) => parseInt(n, 10) || 0);
+    const pb = b.replace(/^win64-/, "").split(".").map((n) => parseInt(n, 10) || 0);
+    for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+        const d = (pb[i] || 0) - (pa[i] || 0);
+        if (d !== 0)
+            return d;
+    }
+    return 0;
+}
+// Resolve the Chrome-for-Testing executable (null when nothing is found).
+export function resolveChromePath() {
+    const env = process.env.MCP_CHROME_PATH;
+    if (env && fs.existsSync(env))
+        return env;
+    const base = nodePath.join(os.homedir(), ".cache", "puppeteer", "chrome");
+    if (fs.existsSync(base)) {
+        const builds = fs
+            .readdirSync(base, { withFileTypes: true })
+            .filter((e) => e.isDirectory() && e.name.startsWith("win64-"))
+            .map((e) => e.name)
+            .sort(compareBuildDirs);
+        for (let i = builds.length - 1; i >= 0; i--) {
+            const p = nodePath.join(base, builds[i], "chrome-win64", "chrome.exe");
+            if (fs.existsSync(p))
+                return p;
+        }
+    }
+    if (fs.existsSync(CHROME_PATH))
+        return CHROME_PATH;
+    return null;
+}
+const LAUNCH_ARGS = ["--no-sandbox", "--disable-setuid-sandbox"];
+// Launch a fresh headless browser with the standard options.
+export const launchBrowser = async () => {
+    const puppeteer = await import("puppeteer-core");
+    const chromePath = resolveChromePath();
+    if (!chromePath) {
+        throw new Error("No Chrome-for-Testing executable found. Set MCP_CHROME_PATH to the path of chrome.exe, " +
+            `or install a build under ${nodePath.join(os.homedir(), ".cache", "puppeteer", "chrome")} ` +
+            "(standard layout: win64-<version>/chrome-win64/chrome.exe).");
+    }
+    return puppeteer.launch({
+        headless: true,
+        executablePath: chromePath,
+        args: LAUNCH_ARGS,
+    });
+};
+// Close a browser, swallowing already-closed errors.
+export const closeBrowserQuiet = async (browser) => {
+    try {
+        await browser.close();
+    }
+    catch {
+        // already closed
+    }
+};
+let sharedBrowser = null;
+// Shared browser used by the web_search browser legs. Lazily launched so a
+// missing browser never breaks the non-puppeteer legs (errors surface per
+// provider and are collected, not fatal).
+export const getSharedBrowser = async () => {
+    if (!sharedBrowser) {
+        sharedBrowser = await launchBrowser();
+    }
+    return sharedBrowser;
+};
+// Close and drop the shared browser so a later provider can relaunch cleanly
+// (the reference kept a stale closed instance; nulling here is strictly safer
+// for manual multi-provider mode).
+export const closeSharedBrowser = async () => {
+    if (sharedBrowser) {
+        const browser = sharedBrowser;
+        sharedBrowser = null;
+        await closeBrowserQuiet(browser);
+    }
+};

package/dist/browser/schema.js

@@ -0,0 +1,37 @@
+import { z } from "zod";
+// Shared actions schema: scripted browser steps executed in order on a page.
+// (Ported from the Beledarian reference; per-action required fields are
+// enforced at execution time by executeBrowserActions with clear errors.)
+export const BrowserActionSchema = z.object({
+    type: z.enum(["wait_for_selector", "wait", "click", "type", "press", "select", "hover", "scroll", "evaluate"]),
+    selector: z.string().optional().describe("CSS selector used by selector-based actions."),
+    text: z.string().optional().describe("Text payload for type action."),
+    value: z.string().optional().describe("Value payload for select action."),
+    key: z.string().optional().describe("Keyboard key for press action (e.g., Enter, Tab)."),
+    milliseconds: z.number().int().min(0).max(30000).optional().describe("Delay in milliseconds for wait action."),
+    x: z.number().optional().describe("Horizontal scroll delta for scroll action."),
+    y: z.number().optional().describe("Vertical scroll delta for scroll action."),
+    script: z.string().optional().describe("JavaScript snippet for evaluate action (executed in page context)."),
+});
+export const BrowserSessionOpenArgsSchema = z.object({
+    url: z.string(),
+    wait_for_selector: z.string().optional().describe("Optional selector to wait for after navigation."),
+    include_page_text: z.boolean().optional().describe("If true (default), returns full page text content after opening."),
+});
+export const BrowserSessionControlArgsSchema = z.object({
+    actions: z.array(BrowserActionSchema).optional().describe("Optional scripted browser actions to execute on the active page."),
+    read_page: z.boolean().optional().describe("If true (default), returns page metadata. Full text is returned only on URL change or when full_read=true."),
+    full_read: z.boolean().optional().describe("If true, forces full page text output even when URL has not changed."),
+    screenshot_path: z.string().optional().describe("Optional screenshot output path (must be within an allowed directory)."),
+    full_page_screenshot: z.boolean().optional().describe("If true, captures full page screenshot."),
+    fuzzy_find: z.string().optional().describe("Optional fuzzy-find query for in-page content/selectors."),
+    max_results: z.number().int().min(1).max(20).optional().describe("Max fuzzy results to return (default: 5)."),
+});
+export const BrowserSessionCloseArgsSchema = z.object({});
+export const BrowserOpenPageArgsSchema = z.object({
+    url: z.string(),
+    screenshot_path: z.string().optional().describe("Path to save a screenshot (e.g., 'screenshot.png'); must be within an allowed directory."),
+    wait_for_selector: z.string().optional().describe("CSS selector to wait for before returning."),
+    full_page_screenshot: z.boolean().optional().describe("If true, captures the full page when taking a screenshot."),
+    actions: z.array(BrowserActionSchema).optional().describe("Optional scripted browser steps to run after navigation."),
+});

package/dist/browser/session.js

@@ -0,0 +1,14 @@
+import { closeBrowserQuiet } from "./launcher.js";
+let session = null;
+export const getSession = () => session;
+export const setSession = (s) => {
+    session = s;
+};
+// Close the active session's browser and drop the state. No-op when none.
+export const closeSession = async () => {
+    if (session) {
+        const s = session;
+        session = null;
+        await closeBrowserQuiet(s.browser);
+    }
+};