@hotmeshio/long-tail 0.1.0

package/build/system/mcp-servers/playwright/tools-page-interaction.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerPageInteractionTools = registerPageInteractionTools;
+const browser_lifecycle_1 = require("./browser-lifecycle");
+const schemas_1 = require("./schemas");
+function registerPageInteractionTools(srv) {
+    // ── click ────────────────────────────────────────────────
+    srv.registerTool('click', {
+        title: 'Click Element',
+        description: 'Click an element on the page by CSS selector. Accepts _handle for cross-activity access.',
+        inputSchema: schemas_1.clickSchema,
+    }, async (args) => {
+        try {
+            const { page, pageId } = await (0, browser_lifecycle_1.resolvePage)(args);
+            await page.click(args.selector, { timeout: 10_000 });
+            await page.waitForTimeout(500);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            clicked: args.selector,
+                            url: page.url(),
+                            title: await page.title(),
+                            _handle: (0, browser_lifecycle_1.buildHandle)(pageId),
+                        }),
+                    }],
+            };
+        }
+        catch (err) {
+            if (err.code) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: err.message, code: err.code }) }], isError: true };
+            }
+            throw err;
+        }
+    });
+    // ── fill ─────────────────────────────────────────────────
+    srv.registerTool('fill', {
+        title: 'Fill Input',
+        description: 'Type a value into an input field. Accepts _handle for cross-activity access.',
+        inputSchema: schemas_1.fillSchema,
+    }, async (args) => {
+        try {
+            const { page, pageId } = await (0, browser_lifecycle_1.resolvePage)(args);
+            await page.fill(args.selector, args.value, { timeout: 10_000 });
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            filled: args.selector,
+                            value: args.value,
+                            _handle: (0, browser_lifecycle_1.buildHandle)(pageId),
+                        }),
+                    }],
+            };
+        }
+        catch (err) {
+            if (err.code) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: err.message, code: err.code }) }], isError: true };
+            }
+            throw err;
+        }
+    });
+    // ── wait_for ─────────────────────────────────────────────
+    srv.registerTool('wait_for', {
+        title: 'Wait for Element',
+        description: 'Wait for an element to appear. Accepts _handle for cross-activity access.',
+        inputSchema: schemas_1.waitForSchema,
+    }, async (args) => {
+        try {
+            const { page, pageId } = await (0, browser_lifecycle_1.resolvePage)(args);
+            await page.waitForSelector(args.selector, {
+                timeout: args.timeout ?? 10_000,
+            });
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            found: args.selector,
+                            _handle: (0, browser_lifecycle_1.buildHandle)(pageId),
+                        }),
+                    }],
+            };
+        }
+        catch (err) {
+            if (err.code) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: err.message, code: err.code }) }], isError: true };
+            }
+            throw err;
+        }
+    });
+    // ── evaluate ─────────────────────────────────────────────
+    srv.registerTool('evaluate', {
+        title: 'Run JavaScript',
+        description: 'Evaluate JavaScript in the page context. Accepts _handle for cross-activity access.',
+        inputSchema: schemas_1.evaluateSchema,
+    }, async (args) => {
+        try {
+            const { page, pageId } = await (0, browser_lifecycle_1.resolvePage)(args);
+            const result = await page.evaluate(args.script);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            result,
+                            _handle: (0, browser_lifecycle_1.buildHandle)(pageId),
+                        }),
+                    }],
+            };
+        }
+        catch (err) {
+            if (err.code) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: err.message, code: err.code }) }], isError: true };
+            }
+            throw err;
+        }
+    });
+    // ── list_pages ───────────────────────────────────────────
+    srv.registerTool('list_pages', {
+        title: 'List Open Pages',
+        description: 'List all open browser pages with their IDs, URLs, and titles.',
+        inputSchema: schemas_1.listPagesSchema,
+    }, async (_args) => {
+        const result = [];
+        for (const [id, page] of browser_lifecycle_1.pages) {
+            result.push({
+                page_id: id,
+                url: page.url(),
+                title: await page.title(),
+            });
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({ pages: result, count: result.length }),
+                }],
+        };
+    });
+    // ── close_page ───────────────────────────────────────────
+    srv.registerTool('close_page', {
+        title: 'Close Page',
+        description: 'Close a browser page by its ID. Accepts _handle for cross-activity access.',
+        inputSchema: schemas_1.closePageSchema,
+    }, async (args) => {
+        try {
+            const { page, pageId } = await (0, browser_lifecycle_1.resolvePage)(args);
+            await page.close();
+            browser_lifecycle_1.pages.delete(pageId);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ closed: pageId }),
+                    }],
+            };
+        }
+        catch (err) {
+            if (err.code) {
+                return { content: [{ type: 'text', text: JSON.stringify({ error: err.message, code: err.code }) }], isError: true };
+            }
+            throw err;
+        }
+    });
+}

package/build/system/mcp-servers/playwright/tools-run-script.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerRunScript(srv: McpServer): void;

package/build/system/mcp-servers/playwright/tools-run-script.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerRunScript = registerRunScript;
+const logger_1 = require("../../../services/logger");
+const storage_1 = require("../../../services/storage");
+const types_1 = require("./types");
+const browser_lifecycle_1 = require("./browser-lifecycle");
+const schemas_1 = require("./schemas");
+function registerRunScript(srv) {
+    srv.registerTool('run_script', {
+        title: 'Run Browser Script',
+        description: 'Execute a multi-step browser script (navigate, screenshot, click, fill, etc.) ' +
+            'in a single call. All steps share one page — no cross-activity session issues. ' +
+            'Preferred for deterministic YAML workflows.',
+        inputSchema: schemas_1.runScriptSchema,
+    }, async (args) => {
+        let page;
+        let pageId;
+        // Reuse existing page via _handle, or create a new one on first navigate
+        if (args._handle) {
+            try {
+                ({ page, pageId } = await (0, browser_lifecycle_1.resolvePage)(args));
+            }
+            catch {
+                // If handle resolution fails, we'll create a new page on first navigate
+                page = null;
+                pageId = '';
+            }
+        }
+        else {
+            page = null;
+            pageId = '';
+        }
+        const stepResults = [];
+        for (let i = 0; i < args.steps.length; i++) {
+            const step = args.steps[i];
+            // Navigate: reuse existing page to preserve session (cookies, localStorage, SPA state).
+            // Only create a new page on the first navigate.
+            if (step.action === 'navigate') {
+                if (!step.url) {
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify({
+                                    error: `Step ${i}: navigate requires url`,
+                                    code: types_1.RESOURCE_NOT_FOUND,
+                                }) }],
+                        isError: true,
+                    };
+                }
+                if (!page) {
+                    const b = await (0, browser_lifecycle_1.ensureBrowser)();
+                    page = await b.newPage();
+                    pageId = (0, browser_lifecycle_1.allocatePageId)();
+                    browser_lifecycle_1.pages.set(pageId, page);
+                }
+                await page.goto(step.url, {
+                    waitUntil: step.wait_until || 'load',
+                    timeout: 30_000,
+                });
+                stepResults.push({
+                    step: i,
+                    action: 'navigate',
+                    result: { url: step.url, title: await page.title() },
+                });
+                continue;
+            }
+            // All other actions require a page
+            if (!page) {
+                return {
+                    content: [{ type: 'text', text: JSON.stringify({
+                                error: `Step ${i}: no page available. Start with a navigate step or provide a _handle.`,
+                                code: types_1.SESSION_NOT_FOUND,
+                            }) }],
+                    isError: true,
+                };
+            }
+            switch (step.action) {
+                case 'screenshot': {
+                    if (!step.path) {
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify({
+                                        error: `Step ${i}: screenshot requires path`,
+                                        code: types_1.RESOURCE_NOT_FOUND,
+                                    }) }],
+                            isError: true,
+                        };
+                    }
+                    const ssBackend = (0, storage_1.getStorageBackend)();
+                    const ssLocalPath = await ssBackend.getLocalPath(step.path);
+                    if (step.selector) {
+                        const el = await page.$(step.selector);
+                        if (!el) {
+                            stepResults.push({ step: i, action: 'screenshot', result: { error: `Element not found: ${step.selector}`, code: types_1.RESOURCE_NOT_FOUND } });
+                            continue;
+                        }
+                        await el.screenshot({ path: ssLocalPath });
+                    }
+                    else {
+                        await page.screenshot({ path: ssLocalPath, fullPage: step.full_page ?? false });
+                    }
+                    const { size: ssSize } = await ssBackend.commitLocalPath(step.path, ssLocalPath);
+                    logger_1.loggerRegistry.info(`[lt-mcp:playwright] screenshot saved: ${step.path} (${ssSize} bytes)`);
+                    stepResults.push({ step: i, action: 'screenshot', result: { path: step.path, size_bytes: ssSize, url: page.url() } });
+                    break;
+                }
+                case 'click': {
+                    if (!step.selector) {
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify({ error: `Step ${i}: click requires selector`, code: types_1.RESOURCE_NOT_FOUND }) }],
+                            isError: true,
+                        };
+                    }
+                    await page.click(step.selector, { timeout: 10_000 });
+                    await page.waitForTimeout(500);
+                    stepResults.push({ step: i, action: 'click', result: { clicked: step.selector, url: page.url() } });
+                    break;
+                }
+                case 'fill': {
+                    if (!step.selector || step.value === undefined) {
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify({ error: `Step ${i}: fill requires selector and value`, code: types_1.RESOURCE_NOT_FOUND }) }],
+                            isError: true,
+                        };
+                    }
+                    await page.fill(step.selector, step.value, { timeout: 10_000 });
+                    stepResults.push({ step: i, action: 'fill', result: { filled: step.selector, value: step.value } });
+                    break;
+                }
+                case 'wait_for': {
+                    if (!step.selector) {
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify({ error: `Step ${i}: wait_for requires selector`, code: types_1.RESOURCE_NOT_FOUND }) }],
+                            isError: true,
+                        };
+                    }
+                    await page.waitForSelector(step.selector, { timeout: step.timeout ?? 10_000 });
+                    stepResults.push({ step: i, action: 'wait_for', result: { found: step.selector } });
+                    break;
+                }
+                case 'wait_for_url': {
+                    if (!step.url) {
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify({ error: `Step ${i}: wait_for_url requires url`, code: types_1.RESOURCE_NOT_FOUND }) }],
+                            isError: true,
+                        };
+                    }
+                    const urlTimeout = step.timeout ?? 10_000;
+                    if (step.not) {
+                        // Wait until URL does NOT contain the pattern
+                        await page.waitForFunction((pattern) => !window.location.href.includes(pattern), step.url, { timeout: urlTimeout });
+                    }
+                    else {
+                        // Wait until URL contains the pattern
+                        await page.waitForURL(`**${step.url}**`, { timeout: urlTimeout });
+                    }
+                    stepResults.push({ step: i, action: 'wait_for_url', result: { url: page.url(), matched: !step.not } });
+                    break;
+                }
+                case 'wait': {
+                    const ms = step.timeout ?? 2000;
+                    await page.waitForTimeout(ms);
+                    stepResults.push({ step: i, action: 'wait', result: { waited_ms: ms } });
+                    break;
+                }
+                case 'evaluate': {
+                    if (!step.script) {
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify({ error: `Step ${i}: evaluate requires script`, code: types_1.RESOURCE_NOT_FOUND }) }],
+                            isError: true,
+                        };
+                    }
+                    const evalResult = await page.evaluate(step.script);
+                    stepResults.push({ step: i, action: 'evaluate', result: { result: evalResult } });
+                    break;
+                }
+            }
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        steps_completed: stepResults.length,
+                        steps: stepResults,
+                        page_id: pageId,
+                        url: page?.url?.() ?? null,
+                        _handle: pageId ? (0, browser_lifecycle_1.buildHandle)(pageId) : undefined,
+                    }),
+                }],
+        };
+    });
+}

package/build/system/mcp-servers/playwright/types.d.ts

@@ -0,0 +1,8 @@
+export interface PlaywrightHandle {
+    type: 'playwright_page';
+    cdp_endpoint?: string;
+    page_id: string;
+}
+export declare const SESSION_NOT_FOUND = "SESSION_NOT_FOUND";
+export declare const SESSION_UNREACHABLE = "SESSION_UNREACHABLE";
+export declare const RESOURCE_NOT_FOUND = "RESOURCE_NOT_FOUND";

package/build/system/mcp-servers/playwright/types.js

@@ -0,0 +1,30 @@
+"use strict";
+// ── _handle convention ──────────────────────────────────────────────────────
+//
+// Tools that create external state (browser pages, file handles, connections)
+// return a `_handle` object in their result. The handle contains everything
+// needed to locate the resource from any container:
+//
+//   _handle: {
+//     type: "playwright_page",
+//     cdp_endpoint: "ws://host:port/...",   // CDP WebSocket (cross-container)
+//     page_id: "page_3",                     // local in-memory lookup (fast path)
+//   }
+//
+// Subsequent tools accept `_handle` and use it to reconnect:
+// 1. Fast path: check local `pages` Map by page_id (same container)
+// 2. Slow path: connect via CDP endpoint (different container / cloud)
+//
+// The YAML generator threads `_handle` automatically between sequential
+// activities from the same server. No hardcoded tool-pair knowledge needed.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RESOURCE_NOT_FOUND = exports.SESSION_UNREACHABLE = exports.SESSION_NOT_FOUND = void 0;
+// ── Standard error codes for stateful resource tools ────────────────────────
+// Any MCP server managing stateful resources should use these codes:
+//   SESSION_NOT_FOUND    — resource ID unknown (never existed or already cleaned up)
+//   SESSION_EXPIRED      — resource was closed / cleaned up
+//   SESSION_UNREACHABLE  — remote endpoint (e.g. CDP) not reachable
+//   RESOURCE_NOT_FOUND   — sub-resource (element, file) not found within session
+exports.SESSION_NOT_FOUND = 'SESSION_NOT_FOUND';
+exports.SESSION_UNREACHABLE = 'SESSION_UNREACHABLE';
+exports.RESOURCE_NOT_FOUND = 'RESOURCE_NOT_FOUND';

package/build/system/mcp-servers/playwright-cli/helpers.d.ts

@@ -0,0 +1,11 @@
+export declare function saveScreenshot(page: import('playwright').Page, filePath: string, fullPage: boolean): Promise<{
+    path: string;
+    size_bytes: number;
+}>;
+export declare function errorResult(message: string, code: string, details?: Record<string, unknown>): {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError: boolean;
+};

package/build/system/mcp-servers/playwright-cli/helpers.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveScreenshot = saveScreenshot;
+exports.errorResult = errorResult;
+const logger_1 = require("../../../services/logger");
+const storage_1 = require("../../../services/storage");
+async function saveScreenshot(page, filePath, fullPage) {
+    const backend = (0, storage_1.getStorageBackend)();
+    const localPath = await backend.getLocalPath(filePath);
+    await page.screenshot({ path: localPath, fullPage });
+    const { size } = await backend.commitLocalPath(filePath, localPath);
+    logger_1.loggerRegistry.info(`[lt-mcp:playwright-cli] screenshot: ${filePath} (${size} bytes)`);
+    return { path: filePath, size_bytes: size };
+}
+function errorResult(message, code, details) {
+    return {
+        content: [{ type: 'text', text: JSON.stringify({ error: message, code, ...details }) }],
+        isError: true,
+    };
+}

package/build/system/mcp-servers/playwright-cli/index.d.ts

@@ -0,0 +1,4 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function createPlaywrightCliServer(options?: {
+    name?: string;
+}): Promise<McpServer>;

package/build/system/mcp-servers/playwright-cli/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPlaywrightCliServer = createPlaywrightCliServer;
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const logger_1 = require("../../../services/logger");
+const tools_auth_1 = require("./tools-auth");
+const tools_capture_1 = require("./tools-capture");
+async function createPlaywrightCliServer(options) {
+    const name = options?.name || 'long-tail-playwright-cli';
+    const instance = new mcp_js_1.McpServer({ name, version: '1.0.0' });
+    (0, tools_auth_1.registerAuthTools)(instance);
+    (0, tools_capture_1.registerCaptureTools)(instance);
+    logger_1.loggerRegistry.info(`[lt-mcp:playwright-cli] ${name} ready (5 tools registered)`);
+    return instance;
+}

package/build/system/mcp-servers/playwright-cli/schemas.d.ts

@@ -0,0 +1,219 @@
+import { z } from 'zod';
+export declare const loginAndCaptureSchema: z.ZodObject<{
+    url: z.ZodString;
+    username_selector: z.ZodString;
+    password_selector: z.ZodString;
+    username: z.ZodString;
+    password: z.ZodString;
+    submit_selector: z.ZodString;
+    wait_after_login: z.ZodOptional<z.ZodString>;
+    screenshot_path: z.ZodOptional<z.ZodString>;
+    full_page: z.ZodOptional<z.ZodBoolean>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    password: string;
+    url: string;
+    username: string;
+    submit_selector: string;
+    username_selector: string;
+    password_selector: string;
+    timeout?: number | undefined;
+    screenshot_path?: string | undefined;
+    full_page?: boolean | undefined;
+    wait_after_login?: string | undefined;
+}, {
+    password: string;
+    url: string;
+    username: string;
+    submit_selector: string;
+    username_selector: string;
+    password_selector: string;
+    timeout?: number | undefined;
+    screenshot_path?: string | undefined;
+    full_page?: boolean | undefined;
+    wait_after_login?: string | undefined;
+}>;
+export declare const capturePageSchema: z.ZodObject<{
+    url: z.ZodString;
+    screenshot_path: z.ZodOptional<z.ZodString>;
+    page_id: z.ZodOptional<z.ZodString>;
+    full_page: z.ZodOptional<z.ZodBoolean>;
+    wait_for_selector: z.ZodOptional<z.ZodString>;
+    wait_ms: z.ZodOptional<z.ZodNumber>;
+    wait_until: z.ZodOptional<z.ZodEnum<["load", "domcontentloaded", "networkidle"]>>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+    timeout?: number | undefined;
+    page_id?: string | undefined;
+    screenshot_path?: string | undefined;
+    wait_until?: "load" | "domcontentloaded" | "networkidle" | undefined;
+    wait_ms?: number | undefined;
+    full_page?: boolean | undefined;
+    wait_for_selector?: string | undefined;
+}, {
+    url: string;
+    timeout?: number | undefined;
+    page_id?: string | undefined;
+    screenshot_path?: string | undefined;
+    wait_until?: "load" | "domcontentloaded" | "networkidle" | undefined;
+    wait_ms?: number | undefined;
+    full_page?: boolean | undefined;
+    wait_for_selector?: string | undefined;
+}>;
+export declare const captureAuthenticatedPagesSchema: z.ZodObject<{
+    login: z.ZodObject<{
+        url: z.ZodString;
+        username_selector: z.ZodString;
+        password_selector: z.ZodString;
+        username: z.ZodString;
+        password: z.ZodString;
+        submit_selector: z.ZodString;
+        wait_after_login: z.ZodOptional<z.ZodString>;
+        timeout: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        password: string;
+        url: string;
+        username: string;
+        submit_selector: string;
+        username_selector: string;
+        password_selector: string;
+        timeout?: number | undefined;
+        wait_after_login?: string | undefined;
+    }, {
+        password: string;
+        url: string;
+        username: string;
+        submit_selector: string;
+        username_selector: string;
+        password_selector: string;
+        timeout?: number | undefined;
+        wait_after_login?: string | undefined;
+    }>;
+    pages: z.ZodArray<z.ZodObject<{
+        url: z.ZodString;
+        screenshot_path: z.ZodString;
+        wait_for_selector: z.ZodOptional<z.ZodString>;
+        wait_ms: z.ZodOptional<z.ZodNumber>;
+        full_page: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        url: string;
+        screenshot_path: string;
+        wait_ms?: number | undefined;
+        full_page?: boolean | undefined;
+        wait_for_selector?: string | undefined;
+    }, {
+        url: string;
+        screenshot_path: string;
+        wait_ms?: number | undefined;
+        full_page?: boolean | undefined;
+        wait_for_selector?: string | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    login: {
+        password: string;
+        url: string;
+        username: string;
+        submit_selector: string;
+        username_selector: string;
+        password_selector: string;
+        timeout?: number | undefined;
+        wait_after_login?: string | undefined;
+    };
+    pages: {
+        url: string;
+        screenshot_path: string;
+        wait_ms?: number | undefined;
+        full_page?: boolean | undefined;
+        wait_for_selector?: string | undefined;
+    }[];
+}, {
+    login: {
+        password: string;
+        url: string;
+        username: string;
+        submit_selector: string;
+        username_selector: string;
+        password_selector: string;
+        timeout?: number | undefined;
+        wait_after_login?: string | undefined;
+    };
+    pages: {
+        url: string;
+        screenshot_path: string;
+        wait_ms?: number | undefined;
+        full_page?: boolean | undefined;
+        wait_for_selector?: string | undefined;
+    }[];
+}>;
+export declare const extractContentSchema: z.ZodObject<{
+    url: z.ZodOptional<z.ZodString>;
+    page_id: z.ZodOptional<z.ZodString>;
+    selector: z.ZodOptional<z.ZodString>;
+    script: z.ZodOptional<z.ZodString>;
+    extract_links: z.ZodOptional<z.ZodBoolean>;
+    extract_metadata: z.ZodOptional<z.ZodBoolean>;
+    wait_for_selector: z.ZodOptional<z.ZodString>;
+    wait_ms: z.ZodOptional<z.ZodNumber>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    url?: string | undefined;
+    timeout?: number | undefined;
+    page_id?: string | undefined;
+    selector?: string | undefined;
+    wait_ms?: number | undefined;
+    extract_links?: boolean | undefined;
+    extract_metadata?: boolean | undefined;
+    script?: string | undefined;
+    wait_for_selector?: string | undefined;
+}, {
+    url?: string | undefined;
+    timeout?: number | undefined;
+    page_id?: string | undefined;
+    selector?: string | undefined;
+    wait_ms?: number | undefined;
+    extract_links?: boolean | undefined;
+    extract_metadata?: boolean | undefined;
+    script?: string | undefined;
+    wait_for_selector?: string | undefined;
+}>;
+export declare const submitFormSchema: z.ZodObject<{
+    url: z.ZodString;
+    fields: z.ZodArray<z.ZodObject<{
+        selector: z.ZodString;
+        value: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        value: string;
+        selector: string;
+    }, {
+        value: string;
+        selector: string;
+    }>, "many">;
+    submit_selector: z.ZodString;
+    wait_after_submit: z.ZodOptional<z.ZodString>;
+    screenshot_path: z.ZodOptional<z.ZodString>;
+    full_page: z.ZodOptional<z.ZodBoolean>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+    submit_selector: string;
+    fields: {
+        value: string;
+        selector: string;
+    }[];
+    timeout?: number | undefined;
+    screenshot_path?: string | undefined;
+    full_page?: boolean | undefined;
+    wait_after_submit?: string | undefined;
+}, {
+    url: string;
+    submit_selector: string;
+    fields: {
+        value: string;
+        selector: string;
+    }[];
+    timeout?: number | undefined;
+    screenshot_path?: string | undefined;
+    full_page?: boolean | undefined;
+    wait_after_submit?: string | undefined;
+}>;