opentestmcp 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 OpenTest
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,231 @@
+# OpenTest MCP
+
+AI QA engineer for your IDE. Test UI flows and API endpoints from Cursor, Claude Code, or any MCP-compatible coding agent.
+
+## What it does
+
+- **Test UI flows** in your real Chrome browser -- already logged in, no credential hassle
+- **Test API endpoints** with assertions and variable chaining
+- **Fullstack testing** -- run UI and API tests in parallel
+- **Endpoint registry** -- tested endpoints are automatically shared between backend and frontend agents
+- **`test_endpoint_by_id`** -- run a saved registry endpoint by UUID from `get_endpoints` (no manual URL assembly); optional `body` for login payloads
+
+### Monorepo (Flow backend in this repo)
+
+See repo root **`AGENTS.md`** for **`ot_live_`** API keys, **`POST /mcp/call-tool`**, the **golden path** (`get_endpoints` → `test_api` or `test_endpoint_by_id`), MCP **Apps** / iframe dashboard, and smoke scripts: [`scripts/smoke-call-tool.mjs`](scripts/smoke-call-tool.mjs), [`scripts/smoke-mcp-flow.mjs`](scripts/smoke-mcp-flow.mjs), [`scripts/smoke-local-endpoint-and-mcp.mjs`](scripts/smoke-local-endpoint-and-mcp.mjs).
+
+### Local debug: prove MCP hit your endpoint
+
+If you want to verify local end-to-end behavior (direct endpoint call + MCP `test_api` call against the same URL), run:
+
+```bash
+OPENTEST_BACKEND=http://127.0.0.1:8000 \
+OPENTEST_API_KEY=ot_live_xxx \
+LOGIN_EMAIL=you@example.com \
+LOGIN_PASSWORD=your-password \
+node opentest-mcp/scripts/smoke-local-endpoint-and-mcp.mjs
+```
+
+It prints both responses and a `debug_run` id so you can match backend logs for:
+1. `POST /mcp/call-tool` (tool dispatch)
+2. the target endpoint hit by the MCP tool
+
+### Real endpoints, not fake servers
+
+OpenTest tools hit **your real HTTP APIs** (localhost or deployed). The **`preview_login_mock`** name means a **login-shaped form UI** (Postman-style), not a mocked backend: the browser runs `fetch()` to whatever **`api_base` + path** you set. In **Cursor**, the agent opens that URL in the **Agent Browser tab**, runs the same request you would in Postman, and you see **status + body** in the panel. **`test_api`** is the headless path without a browser tab.
+
+### Deprecation: `preview_login_mock` / mock-login UI (**~2 days**)
+
+**Removal target: 2026-04-08.** This login panel and `preview_login_mock` are in a short deprecation window so we can finish testing **hosted OpenTest MCP** (`OPENTEST_BACKEND`, `POST /mcp/call-tool`, **`test_api`** / **`get_endpoints`** without the local lite server). After that date, migrate to the hosted flow and headless tools; do not extend the mock-login stack.
+
+## Quick Start
+
+### 1. Install in Cursor
+
+Run this once:
+
+```bash
+npx opentestmcp install
+```
+
+That writes an `opentest` MCP server into `~/.cursor/mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "opentest": {
+      "command": "npx",
+      "args": ["-y", "opentestmcp"],
+      "env": {
+        "OPENTEST_API_KEY": "ot_live_YOUR_API_KEY_HERE",
+        "OPENTEST_BACKEND": "https://flow.opentest.live",
+        "OPENTEST_FRONTEND": "https://www.flowtest.opentest.live"
+      }
+    }
+  }
+}
+```
+
+Replace `ot_live_YOUR_API_KEY_HERE` with your OpenTest API key, then restart Cursor or toggle the MCP server off/on.
+
+You can also pass the key directly:
+
+```bash
+npx opentestmcp install --api-key ot_live_xxx
+```
+
+For a project-local config, run:
+
+```bash
+npx opentestmcp install --project
+```
+
+### 2. Add to Claude Code
+
+```bash
+claude mcp add opentest -- npx -y opentest
+```
+
+### 3. Add to Cursor manually
+
+Add to `.cursor/mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "opentest": {
+      "command": "npx",
+      "args": ["-y", "opentestmcp"],
+      "env": {
+        "OPENTEST_API_KEY": "ot_live_YOUR_API_KEY_HERE"
+      }
+    }
+  }
+}
+```
+
+### 4. Authenticate (one time)
+
+No manual API key needed. Just ask your agent:
+
+> "Log in to OpenTest"
+
+This runs the `opentest_login` tool which:
+1. Starts a device authorization flow
+2. Opens a browser link where you approve access
+3. Stores the API key locally at `~/.opentest/credentials.json`
+
+You only need to do this once — credentials persist across sessions. You can also set `OPENTEST_API_KEY` in the env config if you prefer manual key management.
+
+### 5. Install the Chrome extension (optional)
+
+For browser testing, load the extension:
+
+1. Open `chrome://extensions`
+2. Enable "Developer mode"
+3. Click "Load unpacked"
+4. Select the `browser/` folder from this package
+
+### 6. Start testing
+
+In your IDE, just ask:
+
+> "Test the signup flow on localhost:3000"
+
+> "Test POST /api/users with email test@example.com"
+
+> "Run fullstack test: signup UI + POST /api/users in parallel"
+
+## Inline Visual Results (MCP Apps)
+
+When you call OpenTest tools from supported clients (Claude, VS Code, Goose), you'll see interactive results rendered directly in the conversation:
+
+- **test_api** -- Editable API console in the IDE: method, full URL, headers/body JSON, response, inferred schema, and re-send without a new chat message
+- **test_endpoint_by_id** -- Same as test_api but keyed by registry UUID from get_endpoints; optional body for login payloads
+- **get_endpoints** -- Structured JSON endpoint registry; use `open_endpoints_ui` for the visual dashboard (grouped by tested/needed/draft where the client shows the inline panel)
+- **test_flow** -- Step-by-step browser test progress; the MCP server also opens the **starting URL** in your default browser so you can watch the live tab (Hanzi extension). Inline panel shows task + results.
+- **import_collection** (Postman / OpenAPI / Bruno / curl) -- Inline panel: generated `.ot.yaml`, per-endpoint request/response schemas when present, dashboard id when saved
+- **generate_tests** -- Generated YAML, scenario counts, and save instructions
+- **get_coverage** -- Coverage score, top gaps, and summary
+- **detect_drift** -- Drift rows with severity and assertion/connection details
+
+These tools attach `_meta` with a `ui://` resource (`collection-inspector.html`) so the IDE can render the panel (same MCP Apps pattern as `test_api`).
+
+- **preview_login_mock** — **IDE login / Postman panel** (real `fetch` to your API): set **`api_base`** + **`login_path`**, POST JSON `{ email, password }`, see status/body and inferred shape. Not a mock server—only the form is a small static page. Pair with **`test_api`** for headless-only. Example: `api_base: "http://127.0.0.1:8000"`, `login_path: "/auth/login"`, then **Send login request** or let the agent navigate + click in **Agent Browser**.
+
+**Cursor — inline browser (recommended):** Enable **Agent Browser** ([Cursor docs: Agent → Browser](https://cursor.com/docs/agent/browser)). After `preview_login_mock`, the tool returns **`mock_login_http_url`**; the agent should use **Browser → navigate** to that URL so the mock login opens **inside Cursor** (tab/pane), not only in external Chrome.
+
+**If Browser tools do not appear:** Open **Cursor Settings**, enable the **Browser / Agent Browser** integration (enterprise: admins may need to toggle Browser under MCP). Then ask again to navigate to `mock_login_http_url`.
+
+**Cursor:** `preview_login_mock` does **not** open Safari/Chrome by default (only the **Agent Browser** via `browser_navigate` to `mock_login_http_url`). Set **`OPENTEST_OPEN_MOCK_LOGIN=1`** if you also want the **OS default browser** tab. Or run `npm run open-mock-login` / open `dist/ui/src/ui/mock-login-lite.html` manually after `npm run build`.
+
+The inline MCP UI panel and Cursor Agent Browser (`browser_navigate` on `ui.url`) are the supported surfaces — the MCP server no longer auto-opens system or Playwright browser windows.
+
+Click **Re-send from editor** (or **Send**) to re-run API tests without typing a new message.
+
+### Supported Clients
+- Claude (web + desktop)
+- VS Code (GitHub Copilot)
+- Goose
+- ChatGPT
+
+## MCP Tools
+
+| Tool | What it does |
+|------|-------------|
+| `opentest_login` | One-time device auth — opens browser link, stores API key locally |
+| `opentest_login_complete` | Finishes the login flow after browser approval |
+| `opentest_status` | Check authentication status and connection info |
+| `opentest_logout` | Clear stored credentials and log out |
+| `test_flow` | Test a UI flow in your real Chrome browser |
+| `test_api` | Test an API endpoint with assertions |
+| `test_fullstack` | Run UI + API tests in parallel |
+| `get_endpoints` | Structured JSON inventory of endpoints (registry, sessions, collections) |
+| `endpoints_dashboard` | Aggregated endpoint summary from all sources (structured JSON) |
+| `open_endpoints_ui` | Open the visual endpoints dashboard in the browser |
+| `need_endpoint` | Declare an endpoint the frontend needs |
+| `browser_screenshot` | Capture the current browser page |
+| `import_api_spec` | Import OpenAPI/Swagger/Postman specs |
+| `auto_test` | Auto-discover and test all API endpoints |
+
+## CLI Options
+
+```
+npx opentestmcp                         # Start — uses stored credentials or OPENTEST_API_KEY
+npx opentestmcp --local                 # Local only, no dashboard sync
+npx opentestmcp install                 # Install Cursor MCP config
+```
+
+Environment variables:
+
+- `OPENTEST_API_KEY` -- Manual API key override (skips device auth / stored credentials)
+- `OPENTEST_BACKEND` -- Backend URL (default: `https://flow.opentest.live`)
+- `OPENTEST_FRONTEND` -- Frontend URL (default: `https://www.flowtest.opentest.live`; use `www` to match the live site and avoid apex/`www` redirect issues in embedded browsers)
+
+Tool responses and **`endpoints_page_url`** use the SPA entry: `/?agent_session=<uuid>&ot_agent_route=/endpoints` (and similar routes) so the first request always loads `index.html` on static hosting. The Flow app should read **`ot_agent_route`** on boot and run client-side **`navigate()`** to that path.
+
+## Dashboard (Optional)
+
+Sign up at [flow.opentest.live](https://flow.opentest.live) for:
+- Team endpoint registry
+- Test history and video recordings
+- Jira/Slack integration
+- Scheduled test runs
+
+```bash
+OPENTEST_API_KEY=ot_live_your_api_key npx opentestmcp
+```
+
+## Python MCP Server
+
+This package also includes a Python MCP server for API-only testing via `uvx`:
+
+```bash
+uvx opentest-mcp --project-dir ./
+```
+
+See `pyproject.toml` for Python package details.
+
+## License
+
+MIT

package/bin/cli.js

@@ -0,0 +1,168 @@
+#!/usr/bin/env node
+
+/**
+ * OpenTest CLI.
+ *
+ * Usage:
+ *   npx opentestmcp install
+ *   npx opentestmcp install --api-key ot_live_xxx
+ *   npx opentestmcp
+ */
+
+import { spawn } from "node:child_process";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const ROOT = path.join(__dirname, "..");
+const DEFAULT_BACKEND = "https://flow.opentest.live";
+const DEFAULT_FRONTEND = "https://www.flowtest.opentest.live";
+const API_KEY_PLACEHOLDER = "ot_live_YOUR_API_KEY_HERE";
+
+const args = process.argv.slice(2);
+const command = args[0] === "--help" || args[0] === "-h"
+  ? "help"
+  : args[0] && !args[0].startsWith("-")
+    ? args[0]
+    : "start";
+const commandArgs = command === "start" ? args : args.slice(1);
+
+function argValue(name, fallback = "") {
+  const index = commandArgs.indexOf(name);
+  if (index === -1) return fallback;
+  return commandArgs[index + 1] || fallback;
+}
+
+function hasFlag(name) {
+  return commandArgs.includes(name);
+}
+
+function printHelp() {
+  process.stdout.write(`OpenTest MCP
+
+Usage:
+  npx opentestmcp install [options]  Install OpenTest into Cursor MCP config
+  npx opentestmcp                   Start the OpenTest MCP server
+
+Install options:
+  --api-key <key>       OpenTest API key. Defaults to ${API_KEY_PLACEHOLDER}
+  --backend <url>       OpenTest backend URL. Defaults to ${DEFAULT_BACKEND}
+  --frontend <url>      OpenTest frontend URL. Defaults to ${DEFAULT_FRONTEND}
+  --name <name>         MCP server name. Defaults to opentest
+  --project             Write .cursor/mcp.json in the current project
+  --global              Write ~/.cursor/mcp.json (default)
+  --print               Print the config instead of writing it
+
+Examples:
+  npx opentestmcp install
+  npx opentestmcp install --api-key ot_live_xxx
+  npx opentestmcp install --project --backend http://127.0.0.1:8000
+`);
+}
+
+function readJsonFile(filePath) {
+  if (!existsSync(filePath)) return {};
+  const raw = readFileSync(filePath, "utf8").trim();
+  if (!raw) return {};
+  try {
+    return JSON.parse(raw);
+  } catch (error) {
+    throw new Error(`Could not parse ${filePath}: ${error.message}`);
+  }
+}
+
+function buildServerConfig() {
+  const apiKey = argValue("--api-key", process.env.OPENTEST_API_KEY || API_KEY_PLACEHOLDER);
+  const backend = argValue("--backend", process.env.OPENTEST_BACKEND || DEFAULT_BACKEND);
+  const frontend = argValue("--frontend", process.env.OPENTEST_FRONTEND || DEFAULT_FRONTEND);
+
+  return {
+    command: "npx",
+    args: ["-y", "opentestmcp"],
+    env: {
+      OPENTEST_API_KEY: apiKey,
+      OPENTEST_BACKEND: backend,
+      OPENTEST_FRONTEND: frontend,
+    },
+  };
+}
+
+function installCursorMcp() {
+  const serverName = argValue("--name", "opentest");
+  const projectInstall = hasFlag("--project");
+  const serverConfig = buildServerConfig();
+
+  if (hasFlag("--print")) {
+    process.stdout.write(`${JSON.stringify({ mcpServers: { [serverName]: serverConfig } }, null, 2)}\n`);
+    return;
+  }
+
+  const configPath = projectInstall
+    ? path.join(process.cwd(), ".cursor", "mcp.json")
+    : path.join(os.homedir(), ".cursor", "mcp.json");
+
+  const config = {
+    ...readJsonFile(configPath),
+  };
+  config.mcpServers = {
+    ...(config.mcpServers || {}),
+    [serverName]: serverConfig,
+  };
+
+  const rendered = `${JSON.stringify(config, null, 2)}\n`;
+  mkdirSync(path.dirname(configPath), { recursive: true });
+  writeFileSync(configPath, rendered, { mode: 0o600 });
+
+  const usedPlaceholder = config.mcpServers[serverName].env.OPENTEST_API_KEY === API_KEY_PLACEHOLDER;
+  process.stdout.write(`OpenTest MCP installed in ${configPath}
+
+Server name: ${serverName}
+Backend: ${config.mcpServers[serverName].env.OPENTEST_BACKEND}
+
+Next steps:
+1. ${usedPlaceholder ? `Replace ${API_KEY_PLACEHOLDER} with your OpenTest API key in ${configPath}.` : "Your OpenTest API key was written to the MCP config."}
+2. Restart Cursor or toggle the OpenTest MCP server off/on.
+3. Ask your agent: "Use OpenTest to list my endpoints."
+`);
+}
+
+function startServer() {
+  const serverPath = path.join(ROOT, "dist", "server.js");
+  if (!existsSync(serverPath)) {
+    process.stderr.write(`[opentest] MCP server not found at ${serverPath}. Run npm run build before publishing.\n`);
+    process.exit(1);
+  }
+
+  const env = { ...process.env };
+  const apiKey = argValue("--api-key", argValue("--key", ""));
+  const backend = argValue("--backend", "");
+  const frontend = argValue("--frontend", "");
+  if (apiKey) env.OPENTEST_API_KEY = apiKey;
+  if (backend) env.OPENTEST_BACKEND = backend;
+  if (frontend) env.OPENTEST_FRONTEND = frontend;
+  if (hasFlag("--local")) env.OPENTEST_BACKEND = "";
+
+  const child = spawn(process.execPath, [serverPath, ...commandArgs], {
+    env,
+    stdio: "inherit",
+  });
+
+  child.on("exit", (code, signal) => {
+    if (signal) process.kill(process.pid, signal);
+    process.exit(code || 0);
+  });
+}
+
+if (command === "install") {
+  installCursorMcp();
+} else if (command === "help" || command === "--help" || command === "-h") {
+  printHelp();
+} else if (command === "start") {
+  startServer();
+} else {
+  process.stderr.write(`Unknown command: ${command}\n\n`);
+  printHelp();
+  process.exit(1);
+}

package/browser/README.md

@@ -0,0 +1,9 @@
+# Browser Extension
+
+The Chrome extension and relay server are in the `opentest-browser/` directory at the repo root.
+
+To load the extension:
+1. Open chrome://extensions
+2. Enable Developer mode
+3. Click "Load unpacked"
+4. Select the `opentest-browser/` directory

package/dist/mcp-preview-panel.d.ts

@@ -0,0 +1,30 @@
+export declare const MCP_PREVIEW_RESOURCE_URI = "ui://opentest/mcp-preview";
+export declare const RESOURCE_URI_META_KEY = "ui/resourceUri";
+export declare function escapeHtmlAttr(s: string): string;
+export declare function escapeHtmlText(s: string): string;
+export interface PreviewTool {
+    name?: string;
+    description?: string;
+    inputSchema?: unknown;
+    _endpoint_ref?: {
+        method?: string;
+        path_template?: string;
+        tags?: string[];
+        source?: string;
+    };
+}
+export interface PreviewPayload {
+    intent?: string | string[];
+    selection_method?: string | string[];
+    rationale?: string | string[] | Record<string, string>;
+    selected_count?: number;
+    spec_preview?: {
+        upstream_base_url?: string | string[];
+        tools?: PreviewTool[];
+    };
+}
+export declare function buildConversionPanelHtml(data: PreviewPayload): string;
+export declare function writeMcpPreviewFile(panelHtml: string): Promise<{
+    absolutePath: string;
+    fileUrl: string;
+}>;

package/dist/mcp-preview-panel.js

@@ -0,0 +1,166 @@
+/**
+ * Two-pane HTML for mcp_preview — shared by the MCP stdio server and
+ * scripts/emit-mcp-preview.mjs (browser tab fallback when Cursor does not render mcp-app).
+ */
+import fs from "node:fs/promises";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+export const MCP_PREVIEW_RESOURCE_URI = "ui://opentest/mcp-preview";
+export const RESOURCE_URI_META_KEY = "ui/resourceUri";
+export function escapeHtmlAttr(s) {
+    return s.replace(/&/g, "&").replace(/"/g, """);
+}
+export function escapeHtmlText(s) {
+    return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+export function buildConversionPanelHtml(data) {
+    const toStr = (v) => {
+        if (v == null)
+            return "";
+        if (Array.isArray(v))
+            return v.filter((x) => x != null).map((x) => String(x)).join("; ");
+        if (typeof v === "object") {
+            try {
+                return Object.entries(v)
+                    .map(([k, val]) => `${k}: ${val == null ? "" : String(val)}`)
+                    .join(" · ");
+            }
+            catch {
+                try {
+                    return JSON.stringify(v);
+                }
+                catch {
+                    return String(v);
+                }
+            }
+        }
+        return String(v);
+    };
+    const intent = toStr(data.intent).trim() || "(unspecified)";
+    const method = toStr(data.selection_method).trim() || "unknown";
+    const rationale = toStr(data.rationale).trim();
+    const upstream = toStr(data.spec_preview?.upstream_base_url).trim();
+    const tools = Array.isArray(data.spec_preview?.tools) ? data.spec_preview.tools : [];
+    const selectedCount = typeof data.selected_count === "number" ? data.selected_count : tools.length;
+    const linkKey = (m, p) => `${(m || "").toUpperCase()} ${p || ""}`.trim();
+    const endpointRows = tools
+        .map((t) => {
+        const ref = t._endpoint_ref ?? {};
+        const m = (ref.method ?? "").toUpperCase();
+        const p = ref.path_template ?? "";
+        const key = linkKey(m, p);
+        const tags = Array.isArray(ref.tags) && ref.tags.length > 0 ? ref.tags.join(", ") : "";
+        return `
+        <div class="row" data-link="${escapeHtmlAttr(key)}">
+          <div class="row-head">
+            <span class="method ${escapeHtmlAttr(m)}">${escapeHtmlText(m)}</span>
+            <span class="path">${escapeHtmlText(p)}</span>
+          </div>
+          ${tags ? `<div class="row-meta">tags: ${escapeHtmlText(tags)}</div>` : ""}
+        </div>`;
+    })
+        .join("");
+    const toolRows = tools
+        .map((t) => {
+        const ref = t._endpoint_ref ?? {};
+        const key = linkKey(ref.method, ref.path_template);
+        const schemaJson = (() => {
+            try {
+                return JSON.stringify(t.inputSchema ?? {}, null, 2);
+            }
+            catch {
+                return "{}";
+            }
+        })();
+        return `
+        <div class="row" data-link="${escapeHtmlAttr(key)}">
+          <div class="tool-name">${escapeHtmlText(t.name ?? "(unnamed)")}</div>
+          ${t.description ? `<div class="tool-desc">${escapeHtmlText(t.description)}</div>` : ""}
+          <pre class="tool-schema">${escapeHtmlText(schemaJson)}</pre>
+        </div>`;
+    })
+        .join("");
+    const empty = tools.length === 0
+        ? `<div class="empty">No matching endpoints. Try a different intent or run <code>verify_endpoints_live</code> first.</div>`
+        : "";
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1.0" />
+<title>OpenTest · MCP Preview</title>
+<style>
+  :root { color-scheme: light dark; --bg:#0d1117; --bg2:#161b22; --border:#30363d; --fg:#e6edf3; --muted:#8b949e; --accent:#58a6ff; --green:#2ea043; --orange:#bf8700; --red:#cf222e; --purple:#8957e5; }
+  * { margin:0; padding:0; box-sizing:border-box; }
+  html, body { height:100%; background:var(--bg); color:var(--fg); font-family:-apple-system,BlinkMacSystemFont,sans-serif; font-size:13px; }
+  body { display:flex; flex-direction:column; overflow:hidden; }
+  header { padding:10px 14px; border-bottom:1px solid var(--border); background:var(--bg2); flex-shrink:0; }
+  header h1 { font-size:13px; font-weight:600; color:var(--accent); }
+  header .meta { font-size:11px; color:var(--muted); margin-top:3px; }
+  header .meta strong { color:var(--fg); font-weight:600; }
+  header .rationale { font-size:11px; color:var(--muted); margin-top:5px; font-style:italic; max-width:900px; }
+  .columns { flex:1; display:grid; grid-template-columns:1fr 1fr; gap:1px; background:var(--border); overflow:hidden; min-height:0; }
+  .col { background:var(--bg); overflow-y:auto; }
+  .col-header { padding:7px 12px; font-size:10px; font-weight:700; letter-spacing:0.06em; text-transform:uppercase; color:var(--muted); border-bottom:1px solid var(--border); position:sticky; top:0; background:var(--bg2); z-index:1; }
+  .row { padding:9px 12px; border-bottom:1px solid var(--border); transition:background 0.1s; }
+  .row:last-child { border-bottom:none; }
+  .row:hover, .row.linked { background:rgba(88,166,255,0.08); }
+  .row-head { display:flex; align-items:center; gap:8px; }
+  .row-meta { font-size:10px; color:var(--muted); margin-top:3px; padding-left:56px; }
+  .method { display:inline-block; min-width:48px; text-align:center; padding:2px 6px; border-radius:3px; font-weight:700; font-size:10px; color:white; font-family:SFMono-Regular,Consolas,monospace; }
+  .method.GET{background:var(--accent);} .method.POST{background:var(--green);} .method.PATCH{background:var(--orange);} .method.PUT{background:var(--purple);} .method.DELETE{background:var(--red);}
+  .path { font-family:SFMono-Regular,Consolas,monospace; font-size:12px; word-break:break-all; }
+  .tool-name { font-family:SFMono-Regular,Consolas,monospace; font-size:12px; font-weight:600; color:var(--accent); }
+  .tool-desc { font-size:11px; color:var(--muted); margin-top:3px; line-height:1.4; }
+  .tool-schema { font-family:SFMono-Regular,Consolas,monospace; font-size:10px; background:var(--bg2); padding:6px 8px; border-radius:3px; margin-top:6px; white-space:pre-wrap; word-break:break-all; max-height:120px; overflow-y:auto; line-height:1.4; color:var(--muted); }
+  .empty { padding:24px; text-align:center; color:var(--muted); font-style:italic; }
+  .empty code { font-family:SFMono-Regular,Consolas,monospace; color:var(--accent); background:var(--bg2); padding:1px 5px; border-radius:3px; font-style:normal; }
+  footer { padding:8px 14px; border-top:1px solid var(--border); background:var(--bg2); display:flex; gap:10px; align-items:center; flex-shrink:0; font-size:11px; color:var(--muted); }
+  footer .upstream { font-family:SFMono-Regular,Consolas,monospace; color:var(--accent); }
+  footer .deploy-hint { margin-left:auto; }
+  footer .deploy-hint code { font-family:SFMono-Regular,Consolas,monospace; color:var(--fg); background:var(--bg); padding:2px 6px; border-radius:3px; }
+</style>
+</head>
+<body>
+  <header>
+    <h1>API → MCP Conversion preview</h1>
+    <div class="meta">
+      Intent: <strong>${escapeHtmlText(intent)}</strong> · Selected <strong>${selectedCount}</strong> endpoint${selectedCount === 1 ? "" : "s"} · Method: ${escapeHtmlText(method)}
+    </div>
+    ${rationale ? `<div class="rationale">${escapeHtmlText(rationale)}</div>` : ""}
+  </header>
+  <main class="columns">
+    <div class="col">
+      <div class="col-header">Your API endpoints (${tools.length})</div>
+      ${endpointRows}${tools.length === 0 ? empty : ""}
+    </div>
+    <div class="col">
+      <div class="col-header">Generated MCP tools (${tools.length})</div>
+      ${toolRows}${tools.length === 0 ? empty : ""}
+    </div>
+  </main>
+  <footer>
+    <span>Upstream: <span class="upstream">${escapeHtmlText(upstream || "(not set)")}</span></span>
+    <span class="deploy-hint">Next: ask the agent to call <code>mcp_deploy</code></span>
+  </footer>
+  <script>
+    document.querySelectorAll('.row[data-link]').forEach(row => {
+      const key = row.getAttribute('data-link');
+      if (!key) return;
+      const matches = () => document.querySelectorAll('[data-link="' + CSS.escape(key) + '"]');
+      row.addEventListener('mouseenter', () => matches().forEach(r => r.classList.add('linked')));
+      row.addEventListener('mouseleave', () => matches().forEach(r => r.classList.remove('linked')));
+    });
+  </script>
+</body>
+</html>`;
+}
+export async function writeMcpPreviewFile(panelHtml) {
+    const outPath = path.join(process.cwd(), "opentest-mcp", "mcp-preview-last.html");
+    await fs.mkdir(path.dirname(outPath), { recursive: true });
+    await fs.writeFile(outPath, panelHtml, "utf8");
+    return {
+        absolutePath: outPath,
+        fileUrl: pathToFileURL(outPath).href,
+    };
+}

package/dist/server.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function createServer(): McpServer;