opentestmcp 0.3.0

package/dist/user_auth_flow.d.ts

@@ -0,0 +1,11 @@
+/**
+ * App user auth (JWT) — tools that call the FastAPI backend at OPENTEST_BACKEND /auth/*.
+ * Separate from opentest_login (device flow + ot_live_ API key). No API key is required
+ * for these tools; for JWT-protected routes, pass the access_token from login/verify.
+ */
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+/**
+ * Register MCP tools for routes/auth (email, OTP, password, JWT).
+ * Proxies to the same process as opentest-local (OPENTEST_BACKEND, e.g. http://127.0.0.1:8000).
+ */
+export declare function registerUserAuthFlowTools(server: McpServer, backendUrl: string): void;

package/dist/user_auth_flow.js

@@ -0,0 +1,251 @@
+import { z } from "zod";
+function toolError(message, code = "backend_error", hints) {
+    const payload = { error: message, error_code: code };
+    if (hints)
+        payload._agent_hints = hints;
+    return {
+        content: [{ type: "text", text: JSON.stringify(payload) }],
+        isError: true,
+    };
+}
+function jsonOk(obj) {
+    return { content: [{ type: "text", text: JSON.stringify(obj) }] };
+}
+function normalizeBase(backendUrl) {
+    return backendUrl.replace(/\/+$/, "");
+}
+async function callAuthJson(base, method, path, opts) {
+    const url = new URL(path.startsWith("/") ? path.slice(1) : path, `${base}/`);
+    if (opts?.query) {
+        for (const [k, v] of Object.entries(opts.query)) {
+            if (v != null && v !== "")
+                url.searchParams.set(k, v);
+        }
+    }
+    const headers = { Accept: "application/json" };
+    const hasBody = opts?.json != null && (method === "POST" || method === "PUT" || method === "PATCH" || method === "DELETE");
+    if (hasBody) {
+        headers["Content-Type"] = "application/json";
+    }
+    if (opts?.token) {
+        headers.Authorization = `Bearer ${opts.token.trim()}`;
+    }
+    const init = { method, headers };
+    if (hasBody && opts?.json) {
+        init.body = JSON.stringify(opts.json);
+    }
+    const resp = await fetch(url, init);
+    const text = await resp.text();
+    let parsed;
+    try {
+        parsed = text ? JSON.parse(text) : {};
+    }
+    catch {
+        parsed = { raw: text };
+    }
+    const body = typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)
+        ? parsed
+        : { value: parsed };
+    return {
+        status_code: resp.status,
+        ok: resp.ok,
+        ...body,
+    };
+}
+/**
+ * Register MCP tools for routes/auth (email, OTP, password, JWT).
+ * Proxies to the same process as opentest-local (OPENTEST_BACKEND, e.g. http://127.0.0.1:8000).
+ */
+export function registerUserAuthFlowTools(server, backendUrl) {
+    const base = normalizeBase(backendUrl);
+    server.tool("user_auth_signup", "Register with email and password. Sends an OTP; next call user_auth_verify_otp. Uses POST /auth/signup on OPENTEST_BACKEND (no API key).", {
+        email: z.string().describe("User email"),
+        password: z.string().describe("Password (min 6 characters on the server)"),
+    }, async (args) => {
+        try {
+            const r = await callAuthJson(base, "POST", "/auth/signup", {
+                json: { email: args.email, password: args.password },
+            });
+            if (!r.ok) {
+                return toolError(String(r.detail ?? r.message ?? "signup failed"), r.status_code === 400 ? "invalid_input" : "backend_error", {
+                    next_actions: ["If email exists, use user_auth_login or user_auth_resend_otp."],
+                    related_tools: ["user_auth_verify_otp", "user_auth_login"],
+                });
+            }
+            return jsonOk(r);
+        }
+        catch (e) {
+            const m = e instanceof Error ? e.message : String(e);
+            return toolError(m, "backend_error", {
+                next_actions: ["Ensure OPENTEST_BACKEND is running and JWT_SECRET is set on the server."],
+            });
+        }
+    });
+    server.tool("user_auth_verify_otp", "Verify the email OTP and receive access_token (JWT). POST /auth/verify-otp.", { email: z.string(), otp: z.string().describe("6-digit code from email") }, async (args) => {
+        try {
+            const r = await callAuthJson(base, "POST", "/auth/verify-otp", {
+                json: { email: args.email, otp: args.otp },
+            });
+            if (!r.ok) {
+                return toolError(String(r.detail ?? "verify failed"), "auth_required", {
+                    next_actions: ["Request a new code with user_auth_resend_otp if expired."],
+                    related_tools: ["user_auth_resend_otp", "user_auth_signup"],
+                });
+            }
+            return jsonOk(r);
+        }
+        catch (e) {
+            return toolError(e instanceof Error ? e.message : String(e), "backend_error");
+        }
+    });
+    server.tool("user_auth_login", "Login with email and password. Returns access_token if email is verified. POST /auth/login.", { email: z.string(), password: z.string() }, async (args) => {
+        try {
+            const r = await callAuthJson(base, "POST", "/auth/login", {
+                json: { email: args.email, password: args.password },
+            });
+            if (!r.ok) {
+                const sc = r.status_code;
+                const code = sc === 403 || sc === 401 ? "auth_required" : "backend_error";
+                return toolError(String(r.detail ?? "login failed"), code, {
+                    next_actions: [
+                        "If 403 email not verified: use user_auth_verify_otp or user_auth_resend_otp.",
+                        "If 403 migrated account: use user_auth_forgot_password or user_auth_set_password flow.",
+                    ],
+                    related_tools: ["user_auth_verify_otp", "user_auth_needs_password", "user_auth_set_password"],
+                });
+            }
+            return jsonOk(r);
+        }
+        catch (e) {
+            return toolError(e instanceof Error ? e.message : String(e), "backend_error");
+        }
+    });
+    server.tool("user_auth_needs_password", "Check if an account must set a password (e.g. migrated user). GET /auth/needs-password?email=", { email: z.string().optional().describe("Email to check; omit to return false/false from server") }, async (args) => {
+        try {
+            const r = await callAuthJson(base, "GET", "/auth/needs-password", {
+                query: { email: args.email },
+            });
+            if (!r.ok) {
+                return toolError(String(r.detail ?? "request failed"), "backend_error");
+            }
+            return jsonOk(r);
+        }
+        catch (e) {
+            return toolError(e instanceof Error ? e.message : String(e), "backend_error");
+        }
+    });
+    server.tool("user_auth_resend_otp", "Resend verification OTP. POST /auth/resend-otp with { email }.", { email: z.string() }, async (args) => {
+        try {
+            const r = await callAuthJson(base, "POST", "/auth/resend-otp", {
+                json: { email: args.email },
+            });
+            if (!r.ok) {
+                return toolError(String(r.detail ?? "resend failed"), "invalid_input");
+            }
+            return jsonOk(r);
+        }
+        catch (e) {
+            return toolError(e instanceof Error ? e.message : String(e), "backend_error");
+        }
+    });
+    server.tool("user_auth_forgot_password", "Request password reset OTP. POST /auth/forgot-password with { email }.", { email: z.string() }, async (args) => {
+        try {
+            const r = await callAuthJson(base, "POST", "/auth/forgot-password", {
+                json: { email: args.email },
+            });
+            if (!r.ok) {
+                return toolError(String(r.detail ?? "forgot failed"), "backend_error");
+            }
+            return jsonOk(r);
+        }
+        catch (e) {
+            return toolError(e instanceof Error ? e.message : String(e), "backend_error");
+        }
+    });
+    server.tool("user_auth_set_password", "Set a new password using OTP (migrated / forgot flow). Returns access_token. POST /auth/set-password.", {
+        email: z.string(),
+        otp: z.string(),
+        new_password: z.string().min(6),
+    }, async (args) => {
+        try {
+            const r = await callAuthJson(base, "POST", "/auth/set-password", {
+                json: {
+                    email: args.email,
+                    otp: args.otp,
+                    new_password: args.new_password,
+                },
+            });
+            if (!r.ok) {
+                return toolError(String(r.detail ?? "set password failed"), "auth_required", {
+                    next_actions: ["Request a new OTP with user_auth_forgot_password or user_auth_resend_otp."],
+                    related_tools: ["user_auth_forgot_password"],
+                });
+            }
+            return jsonOk(r);
+        }
+        catch (e) {
+            return toolError(e instanceof Error ? e.message : String(e), "backend_error");
+        }
+    });
+    server.tool("user_auth_me", "Current user profile (JWT). GET /auth/me with Authorization: Bearer access_token from login/verify.", {
+        access_token: z.string().describe("JWT from user_auth_login or user_auth_verify_otp"),
+    }, async (args) => {
+        try {
+            const r = await callAuthJson(base, "GET", "/auth/me", {
+                token: args.access_token,
+            });
+            if (!r.ok) {
+                return toolError(String(r.detail ?? "unauthorized"), "auth_required", {
+                    next_actions: ["Call user_auth_login to obtain a fresh access_token."],
+                    related_tools: ["user_auth_login"],
+                });
+            }
+            return jsonOk(r);
+        }
+        catch (e) {
+            return toolError(e instanceof Error ? e.message : String(e), "backend_error");
+        }
+    });
+    server.tool("user_auth_change_password", "Change password for the signed-in user. POST /auth/change-password with JWT.", {
+        access_token: z.string(),
+        current_password: z.string(),
+        new_password: z.string().min(6),
+    }, async (args) => {
+        try {
+            const r = await callAuthJson(base, "POST", "/auth/change-password", {
+                token: args.access_token,
+                json: {
+                    current_password: args.current_password,
+                    new_password: args.new_password,
+                },
+            });
+            if (!r.ok) {
+                return toolError(String(r.detail ?? "change password failed"), r.status_code === 401 ? "auth_required" : "invalid_input", {
+                    related_tools: ["user_auth_login", "user_auth_me"],
+                });
+            }
+            return jsonOk(r);
+        }
+        catch (e) {
+            return toolError(e instanceof Error ? e.message : String(e), "backend_error");
+        }
+    });
+    server.tool("user_auth_delete_account", "Delete the current account. DELETE /auth/me with JWT. Irreversible.", {
+        access_token: z.string().describe("JWT from user_auth_login or user_auth_verify_otp"),
+    }, async (args) => {
+        try {
+            const r = await callAuthJson(base, "DELETE", "/auth/me", {
+                token: args.access_token,
+            });
+            if (!r.ok) {
+                return toolError(String(r.detail ?? "delete failed"), "auth_required", {
+                    related_tools: ["user_auth_login"],
+                });
+            }
+            return jsonOk(r);
+        }
+        catch (e) {
+            return toolError(e instanceof Error ? e.message : String(e), "backend_error");
+        }
+    });
+}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "opentestmcp",
+  "version": "0.3.0",
+  "description": "AI QA engineer for your IDE — test UI flows and API endpoints with inline visual results",
+  "type": "module",
+  "bin": {
+    "opentestmcp": "bin/cli.js",
+    "opentest-mcp": "bin/cli.js"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.server.json",
+    "dev": "tsx src/server.ts",
+    "open-mcp-preview": "node scripts/emit-mcp-preview.mjs",
+    "open-mcp-preview-in-cursor": "node scripts/open-cursor-preview.mjs"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/ext-apps": "^0.1.0",
+    "@modelcontextprotocol/sdk": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "tsx": "^4.0.0",
+    "typescript": "^5.8.0"
+  },
+  "keywords": [
+    "mcp",
+    "testing",
+    "qa",
+    "mcp-apps",
+    "playwright",
+    "browser-automation",
+    "api-testing",
+    "cursor",
+    "claude-code"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/anthropics/opentest-mcp.git"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "dist/",
+    "bin/",
+    "browser/",
+    "README.md",
+    "LICENSE"
+  ]
+}