@timetotest/cli 0.1.10 → 0.2.0

package/dist/src/lib/tool-registry.js

@@ -0,0 +1,803 @@
+/**
+ * Tool Registry - Mirror of backend schemas for CLI agent tools
+ * Ensures exact parity between local and remote tool execution
+ */
+// UI TOOLS (Playwright MCP)
+export const BROWSER_NAVIGATE_SCHEMA = {
+    name: "browser_navigate",
+    description: "Navigate the browser to a specific URL.",
+    parameters: {
+        type: "object",
+        properties: {
+            url: {
+                type: "string",
+                description: "Absolute URL (e.g., https://example.com/path)",
+            },
+        },
+        required: ["url"],
+    },
+};
+export const BROWSER_CLICK_SCHEMA = {
+    name: "browser_click",
+    description: "Click an element using the Playwright MCP ref and accompanying description.",
+    parameters: {
+        type: "object",
+        properties: {
+            element: {
+                type: "string",
+                description: "Human-readable element description (used for permission / audit trail).",
+            },
+            ref: {
+                type: "string",
+                description: "Exact ref from the cached snapshot output.",
+            },
+            doubleClick: {
+                type: "boolean",
+                description: "Whether to perform a double click instead of single tap.",
+            },
+            button: {
+                type: "string",
+                enum: ["left", "right", "middle"],
+                description: "Mouse button to use when clicking.",
+            },
+            modifiers: {
+                type: "array",
+                items: {
+                    type: "string",
+                    enum: ["Alt", "Control", "ControlOrMeta", "Meta", "Shift"],
+                },
+                description: "Optional modifier keys to press during the click.",
+            },
+        },
+        required: ["element", "ref"],
+    },
+};
+export const BROWSER_HOVER_SCHEMA = {
+    name: "browser_hover",
+    description: "Hover over an element using its Playwright MCP ref.",
+    parameters: {
+        type: "object",
+        properties: {
+            element: {
+                type: "string",
+                description: "Human-readable element description.",
+            },
+            ref: {
+                type: "string",
+                description: "Exact ref from the cached snapshot output.",
+            },
+        },
+        required: ["element", "ref"],
+    },
+};
+export const BROWSER_TYPE_SCHEMA = {
+    name: "browser_type",
+    description: "Type text into an element resolved via the cached snapshot.",
+    parameters: {
+        type: "object",
+        properties: {
+            element: {
+                type: "string",
+                description: "Human-readable element description.",
+            },
+            ref: {
+                type: "string",
+                description: "Exact ref from the cached snapshot output.",
+            },
+            text: {
+                type: "string",
+                description: "Text to type into the element.",
+            },
+            submit: {
+                type: "boolean",
+                description: "Whether to press Enter after typing.",
+            },
+            slowly: {
+                type: "boolean",
+                description: "Type characters one-by-one instead of filling the entire value at once.",
+            },
+        },
+        required: ["element", "ref", "text"],
+    },
+};
+export const BROWSER_PRESS_KEY_SCHEMA = {
+    name: "browser_press_key",
+    description: "Press a keyboard key on the active page.",
+    parameters: {
+        type: "object",
+        properties: {
+            key: {
+                type: "string",
+                description: "Key name to press (e.g., ArrowLeft, Enter, Shift+Key).",
+            },
+        },
+        required: ["key"],
+    },
+};
+export const BROWSER_WAIT_FOR_SCHEMA = {
+    name: "browser_wait_for",
+    description: "Wait for text to appear or disappear, or simply wait for a number of seconds.",
+    parameters: {
+        type: "object",
+        properties: {
+            time: {
+                type: "number",
+                description: "Time to wait in seconds.",
+            },
+            text: {
+                type: "string",
+                description: "Text that must appear before the wait finishes.",
+            },
+            textGone: {
+                type: "string",
+                description: "Text that must disappear before the wait finishes.",
+            },
+        },
+    },
+};
+export const BROWSER_TAKE_SCREENSHOT_SCHEMA = {
+    name: "browser_take_screenshot",
+    description: "Capture a screenshot of the current page or a specific element.",
+    parameters: {
+        type: "object",
+        properties: {
+            type: {
+                type: "string",
+                enum: ["png", "jpeg"],
+                description: "Image format for the screenshot.",
+            },
+            filename: {
+                type: "string",
+                description: "Optional filename hint; defaults to page-{timestamp}.{png|jpeg}.",
+            },
+            element: {
+                type: "string",
+                description: "Human-readable element description to permission the screenshot.",
+            },
+            ref: {
+                type: "string",
+                description: "Element ref from browser_snapshot. Required if element is provided.",
+            },
+            fullPage: {
+                type: "boolean",
+                description: "Capture the entire scrollable page (cannot be combined with element screenshots).",
+            },
+        },
+    },
+};
+export const BROWSER_SELECT_OPTION_SCHEMA = {
+    name: "browser_select_option",
+    description: "Select option(s) in a dropdown element.",
+    parameters: {
+        type: "object",
+        properties: {
+            element: {
+                type: "string",
+                description: "Human-readable element description.",
+            },
+            ref: {
+                type: "string",
+                description: "Exact ref from the cached snapshot output.",
+            },
+            values: {
+                type: "array",
+                items: { type: "string" },
+                description: "Array of option values/labels to select (one or many).",
+            },
+        },
+        required: ["element", "ref", "values"],
+    },
+};
+export const BROWSER_FILL_FORM_SCHEMA = {
+    name: "browser_fill_form",
+    description: "Fill multiple form fields in a single action.",
+    parameters: {
+        type: "object",
+        properties: {
+            fields: {
+                type: "array",
+                description: "Fields to fill in.",
+                items: {
+                    type: "object",
+                    properties: {
+                        name: {
+                            type: "string",
+                            description: "Human-readable field name.",
+                        },
+                        type: {
+                            type: "string",
+                            enum: ["textbox", "checkbox", "radio", "combobox", "slider"],
+                            description: "Type of the field.",
+                        },
+                        ref: {
+                            type: "string",
+                            description: "Exact ref from the cached snapshot output.",
+                        },
+                        value: {
+                            type: "string",
+                            description: "Value to set (checkbox expects 'true'/'false', combobox expects option label).",
+                        },
+                    },
+                    required: ["name", "type", "ref", "value"],
+                },
+            },
+        },
+        required: ["fields"],
+    },
+};
+export const BROWSER_TABS_SCHEMA = {
+    name: "browser_tabs",
+    description: "List, create, close, or select browser tabs.",
+    parameters: {
+        type: "object",
+        properties: {
+            action: {
+                type: "string",
+                enum: ["list", "new", "close", "select"],
+                description: "Operation to perform.",
+            },
+            index: {
+                type: "number",
+                description: "Tab index used for close/select. When omitted for close, current tab is closed.",
+            },
+        },
+        required: ["action"],
+    },
+};
+export const BROWSER_HANDLE_DIALOG_SCHEMA = {
+    name: "browser_handle_dialog",
+    description: "Accept or dismiss the currently visible dialog.",
+    parameters: {
+        type: "object",
+        properties: {
+            accept: {
+                type: "boolean",
+                description: "Whether to accept the dialog (dismiss if false).",
+            },
+            promptText: {
+                type: "string",
+                description: "Optional text to send when accepting a prompt dialog.",
+            },
+        },
+        required: ["accept"],
+    },
+};
+export const BROWSER_NETWORK_REQUESTS_SCHEMA = {
+    name: "browser_network_requests",
+    description: "Return network requests since the current page load.",
+    parameters: {
+        type: "object",
+        properties: {},
+    },
+};
+export const BROWSER_CONSOLE_MESSAGES_SCHEMA = {
+    name: "browser_console_messages",
+    description: "Retrieve recent console messages from the page.",
+    parameters: {
+        type: "object",
+        properties: {},
+    },
+};
+export const BROWSER_RESIZE_SCHEMA = {
+    name: "browser_resize",
+    description: "Resize the browser viewport.",
+    parameters: {
+        type: "object",
+        properties: {
+            width: {
+                type: "number",
+                description: "Viewport width in pixels.",
+            },
+            height: {
+                type: "number",
+                description: "Viewport height in pixels.",
+            },
+        },
+        required: ["width", "height"],
+    },
+};
+export const BROWSER_DRAG_SCHEMA = {
+    name: "browser_drag",
+    description: "Drag between two elements identified by their Playwright MCP refs.",
+    parameters: {
+        type: "object",
+        properties: {
+            startElement: {
+                type: "string",
+                description: "Human-readable description of the source element.",
+            },
+            startRef: {
+                type: "string",
+                description: "Source element ref from browser_snapshot.",
+            },
+            endElement: {
+                type: "string",
+                description: "Human-readable description of the target element.",
+            },
+            endRef: {
+                type: "string",
+                description: "Target element ref from browser_snapshot.",
+            },
+        },
+        required: ["startElement", "startRef", "endElement", "endRef"],
+    },
+};
+export const BROWSER_SNAPSHOT_QUERY_SCHEMA = {
+    name: "browser_snapshot_query",
+    description: "Search accessibility snapshot for elements by text. Text must be at least 5 words.",
+    parameters: {
+        type: "object",
+        properties: {
+            text: {
+                type: "string",
+                description: "Element description (min 5 words). Uses fuzzy search.",
+                minLength: 1,
+            },
+            limit: {
+                type: "integer",
+                default: 10,
+                description: "Maximum number of matches to return (default 10).",
+            },
+        },
+        required: ["text"],
+    },
+};
+// API TOOLS
+export const API_REQUEST_SCHEMA = {
+    name: "api_request",
+    description: "HTTP request (GET, POST, PUT, PATCH, DELETE). No payload for GET/DELETE.",
+    parameters: {
+        type: "object",
+        properties: {
+            method: {
+                type: "string",
+                enum: ["GET", "POST", "PUT", "PATCH", "DELETE"],
+            },
+            url: {
+                type: "string",
+            },
+            headers: {
+                type: "object",
+            },
+            payload: {
+                type: "object",
+            },
+            query_params: {
+                type: "object",
+            },
+            timeout: {
+                type: "number",
+            },
+            use_secret_keys: {
+                type: "boolean",
+            },
+        },
+        required: ["method", "url"],
+    },
+};
+export const BUILD_API_REQUEST_SCHEMA = {
+    name: "build_api_request",
+    description: "Compose method, URL, headers, and payload based on get_api_parameters output or inputs; returns cURL too.",
+    parameters: {
+        type: "object",
+        properties: {
+            method: {
+                type: "string",
+            },
+            url: {
+                type: "string",
+            },
+            headers: {
+                type: "object",
+            },
+            payload: {
+                type: "object",
+            },
+            parameters: {
+                type: "object",
+                description: "Grouped params {path,query,header,cookie}",
+            },
+            request_body: {
+                type: "object",
+                description: "From get_api_parameters",
+            },
+        },
+        required: ["method", "url"],
+    },
+};
+export const GENERATE_CURL_SCHEMA = {
+    name: "generate_curl",
+    description: "Generate a cURL command from method/url/headers/payload.",
+    parameters: {
+        type: "object",
+        properties: {
+            method: {
+                type: "string",
+            },
+            url: {
+                type: "string",
+            },
+            headers: {
+                type: "object",
+            },
+            payload: {
+                type: "object",
+            },
+        },
+        required: ["method", "url"],
+    },
+};
+export const GENERATE_API_TEST_SCHEMA = {
+    name: "generate_api_test",
+    description: "Generate basic or comprehensive API test cases for a list of endpoints.",
+    parameters: {
+        type: "object",
+        properties: {
+            base_url: {
+                type: "string",
+                description: "Base URL of the API (e.g., https://api.example.com)",
+            },
+            endpoints: {
+                type: "array",
+                items: { type: "string" },
+                description: "List of endpoint paths or full URLs to test",
+            },
+            test_type: {
+                type: "string",
+                enum: ["basic", "comprehensive", "performance"],
+                description: "Test strategy: 'basic' single checks, 'comprehensive' multi-method, or 'performance' oriented",
+            },
+        },
+        required: ["base_url", "endpoints"],
+    },
+};
+export const GET_API_PARAMETERS_SCHEMA = {
+    name: "get_api_parameters",
+    description: "Get structured parameters and request body details for discovered endpoint.",
+    parameters: {
+        type: "object",
+        properties: {
+            method: {
+                type: "string",
+                description: "HTTP method (GET, POST, etc.)",
+            },
+            path: {
+                type: "string",
+                description: "Endpoint path (e.g., /api/v1/auth/login)",
+            },
+            url: {
+                type: "string",
+                description: "Full URL",
+            },
+            spec_url: {
+                type: "string",
+                description: "OpenAPI/Swagger JSON URL",
+            },
+            documentation_url: {
+                type: "string",
+                description: "Documentation page URL",
+            },
+            base_url: {
+                type: "string",
+                description: "API base URL",
+            },
+        },
+        required: [],
+    },
+};
+export const VALIDATE_API_RESPONSE_SCHEMA = {
+    name: "validate_api_response",
+    description: "Validate response with flexible expected_status (single, list, or class: '2xx').",
+    parameters: {
+        type: "object",
+        properties: {
+            response: {
+                type: "object",
+            },
+            expected_status: {
+                oneOf: [
+                    { type: "integer" },
+                    { type: "array", items: { type: "integer" } },
+                    { type: "string" },
+                ],
+            },
+            expected_content_type: {
+                type: "string",
+            },
+            max_response_time: {
+                type: "number",
+            },
+        },
+        required: ["response"],
+    },
+};
+export const ASSERT_RESPONSE_SCHEMA = {
+    name: "assert_response_schema",
+    description: "Assert the response matches the OpenAPI schema for the endpoint.",
+    parameters: {
+        type: "object",
+        properties: {
+            method: {
+                type: "string",
+            },
+            path: {
+                type: "string",
+            },
+            url: {
+                type: "string",
+            },
+            spec_url: {
+                type: "string",
+            },
+            documentation_url: {
+                type: "string",
+            },
+            base_url: {
+                type: "string",
+            },
+            response: {
+                type: "object",
+            },
+        },
+        required: ["response"],
+    },
+};
+export const EXTRACT_RESPONSE_FIELDS_SCHEMA = {
+    name: "extract_response_fields",
+    description: "Extract fields from JSON response using simple dot paths (e.g., user.token).",
+    parameters: {
+        type: "object",
+        properties: {
+            response: {
+                type: "object",
+            },
+            paths: {
+                type: "array",
+                items: { type: "string" },
+            },
+        },
+        required: ["response", "paths"],
+    },
+};
+export const SET_AUTH_HEADER_SCHEMA = {
+    name: "set_auth_header",
+    description: "Set or update Authorization header (Bearer ...) in the agent context for future requests.",
+    parameters: {
+        type: "object",
+        properties: {
+            token: {
+                type: "string",
+                description: "Bearer token (raw)",
+            },
+        },
+        required: ["token"],
+    },
+};
+export const API_DISCOVERY_SCHEMA = {
+    name: "api_discovery",
+    description: "Unified API discovery: action=discover|search. Discover performs an upsert of endpoints per test to avoid duplicates while updating changes.",
+    parameters: {
+        type: "object",
+        properties: {
+            action: {
+                type: "string",
+                enum: ["discover", "search"],
+            },
+            documentation_url: {
+                type: "string",
+            },
+            spec_url: {
+                type: "string",
+            },
+            base_url: {
+                type: "string",
+            },
+            timeout_ms: {
+                type: "integer",
+            },
+            force: {
+                type: "boolean",
+                description: "Force rediscovery even if endpoints already exist",
+            },
+            test_id: {
+                type: "integer",
+            },
+            q: {
+                type: "string",
+            },
+            method: {
+                type: "string",
+            },
+            tag: {
+                type: "string",
+            },
+            path_contains: {
+                type: "string",
+            },
+            parameter_name: {
+                type: "string",
+            },
+            response_code: {
+                type: "string",
+            },
+            has_request_body: {
+                type: "boolean",
+            },
+            limit: {
+                type: "integer",
+                default: 20,
+            },
+            cursor: {
+                type: "string",
+            },
+        },
+        required: ["action"],
+    },
+};
+// BROWSER SESSION MANAGEMENT TOOLS
+export const BROWSER_SESSION_SCHEMA = {
+    name: "browser_session",
+    description: "Start or stop a browser session for UI testing. Always launches a visible browser and navigates to Google.com. Must start a session before using any UI tools.",
+    parameters: {
+        type: "object",
+        properties: {
+            action: {
+                type: "string",
+                enum: ["start", "stop"],
+                description: "Whether to start or stop the browser session",
+            },
+            viewport: {
+                type: "object",
+                properties: {
+                    width: { type: "integer", default: 1280 },
+                    height: { type: "integer", default: 800 },
+                },
+                description: "Browser viewport size (only used when action=start)",
+            },
+        },
+        required: ["action"],
+    },
+};
+export const FINISH_SCHEMA = {
+    name: "finish",
+    description: "Finish the current task and stop the agent loop. Use this when the task is complete or when you need to stop.",
+    parameters: {
+        type: "object",
+        properties: {
+            summary: {
+                type: "string",
+                description: "Brief summary of what was accomplished",
+            },
+            reason: {
+                type: "string",
+                description: "Reason for finishing (optional)",
+            },
+        },
+        required: [],
+    },
+};
+// GENERAL TOOLS
+export const SET_TESTING_MODE_SCHEMA = {
+    name: "set_testing_mode",
+    description: "Switch the active testing mode to control which tools are available (ui or api).",
+    parameters: {
+        type: "object",
+        properties: {
+            mode: {
+                type: "string",
+                enum: ["ui", "api"],
+            },
+            base_url: {
+                type: "string",
+                description: "Optional base URL for the chosen mode",
+            },
+            api_base_url: {
+                type: "string",
+                description: "Optional API base URL for api mode",
+            },
+            viewport: {
+                type: "object",
+                properties: {
+                    width: { type: "integer" },
+                    height: { type: "integer" },
+                },
+            },
+        },
+        required: ["mode"],
+    },
+};
+export const FINISH_OVERALL_TEST_SCHEMA = {
+    name: "finish_overall_test",
+    description: "End the test session with a summary and report of what was accomplished.",
+    parameters: {
+        type: "object",
+        properties: {
+            summary: {
+                type: "string",
+                description: "A summary of what was accomplished during the entire test execution",
+            },
+        },
+        required: ["summary"],
+    },
+};
+// Build registry by domain and testing mode
+export function getToolSchemasByDomain(domain) {
+    const all = {
+        browser_navigate: { schema: BROWSER_NAVIGATE_SCHEMA, domain: "ui" },
+        browser_click: { schema: BROWSER_CLICK_SCHEMA, domain: "ui" },
+        browser_hover: { schema: BROWSER_HOVER_SCHEMA, domain: "ui" },
+        browser_type: { schema: BROWSER_TYPE_SCHEMA, domain: "ui" },
+        browser_press_key: { schema: BROWSER_PRESS_KEY_SCHEMA, domain: "ui" },
+        browser_wait_for: { schema: BROWSER_WAIT_FOR_SCHEMA, domain: "ui" },
+        browser_take_screenshot: {
+            schema: BROWSER_TAKE_SCREENSHOT_SCHEMA,
+            domain: "ui",
+        },
+        browser_select_option: {
+            schema: BROWSER_SELECT_OPTION_SCHEMA,
+            domain: "ui",
+        },
+        browser_fill_form: { schema: BROWSER_FILL_FORM_SCHEMA, domain: "ui" },
+        browser_tabs: { schema: BROWSER_TABS_SCHEMA, domain: "ui" },
+        browser_handle_dialog: {
+            schema: BROWSER_HANDLE_DIALOG_SCHEMA,
+            domain: "ui",
+        },
+        browser_network_requests: {
+            schema: BROWSER_NETWORK_REQUESTS_SCHEMA,
+            domain: "ui",
+        },
+        browser_console_messages: {
+            schema: BROWSER_CONSOLE_MESSAGES_SCHEMA,
+            domain: "ui",
+        },
+        browser_resize: { schema: BROWSER_RESIZE_SCHEMA, domain: "ui" },
+        browser_drag: { schema: BROWSER_DRAG_SCHEMA, domain: "ui" },
+        browser_snapshot_query: {
+            schema: BROWSER_SNAPSHOT_QUERY_SCHEMA,
+            domain: "ui",
+        },
+        api_request: { schema: API_REQUEST_SCHEMA, domain: "api" },
+        build_api_request: { schema: BUILD_API_REQUEST_SCHEMA, domain: "api" },
+        generate_curl: { schema: GENERATE_CURL_SCHEMA, domain: "api" },
+        generate_api_test: { schema: GENERATE_API_TEST_SCHEMA, domain: "api" },
+        get_api_parameters: { schema: GET_API_PARAMETERS_SCHEMA, domain: "api" },
+        validate_api_response: {
+            schema: VALIDATE_API_RESPONSE_SCHEMA,
+            domain: "api",
+        },
+        assert_response_schema: { schema: ASSERT_RESPONSE_SCHEMA, domain: "api" },
+        extract_response_fields: {
+            schema: EXTRACT_RESPONSE_FIELDS_SCHEMA,
+            domain: "api",
+        },
+        set_auth_header: { schema: SET_AUTH_HEADER_SCHEMA, domain: "api" },
+        api_discovery: { schema: API_DISCOVERY_SCHEMA, domain: "api" },
+        set_testing_mode: { schema: SET_TESTING_MODE_SCHEMA, domain: "general" },
+        browser_session: { schema: BROWSER_SESSION_SCHEMA, domain: "general" },
+        finish: { schema: FINISH_SCHEMA, domain: "general" },
+        finish_overall_test: {
+            schema: FINISH_OVERALL_TEST_SCHEMA,
+            domain: "general",
+        },
+    };
+    const filtered = Object.entries(all).filter(([, { domain: d }]) => d === domain);
+    if (domain !== "general") {
+        const generalEntries = Object.entries(all).filter(([, { domain: d }]) => d === "general");
+        filtered.push(...generalEntries);
+    }
+    return Object.fromEntries(filtered.map(([name, { schema }]) => [name, schema]));
+}
+export function getAllToolSchemas() {
+    const unique = new Map();
+    const domains = ["ui", "api", "general"];
+    for (const domain of domains) {
+        for (const [name, schema] of Object.entries(getToolSchemasByDomain(domain))) {
+            if (!unique.has(name)) {
+                unique.set(name, schema);
+            }
+        }
+    }
+    return Array.from(unique.values());
+}
+//# sourceMappingURL=tool-registry.js.map