@lovable.dev/mcp-js 0.21.0 → 0.21.1-rc.1

package/dist/chunk-QPKPYDPB.js

@@ -1,137 +0,0 @@
-import {
-  extractTextContent
-} from "./chunk-6QFZYYUV.js";
-import {
-  ToolContext
-} from "./chunk-MA5H6PSF.js";
-import {
-  JSON_HEADERS,
-  assertRestResourceBinding,
-  corsPreflightResponse,
-  createNoopRecorder,
-  createRequestAuthorizer,
-  methodNotAllowed,
-  nowMs,
-  withCors
-} from "./chunk-YLU2JTHL.js";
-
-// src/protocols/rest/invoke-tool.ts
-import { getParseErrorMessage, objectFromShape, safeParseAsync } from "@modelcontextprotocol/sdk/server/zod-compat.js";
-var MAX_REFLECTED_TOOL_NAME = 256;
-function safeReflectName(name) {
-  const text = String(name);
-  return text.length > MAX_REFLECTED_TOOL_NAME ? `${text.slice(0, MAX_REFLECTED_TOOL_NAME)}\u2026` : text;
-}
-function isEmptyArgs(value) {
-  if (value == null)
-    return true;
-  if (typeof value !== "object" || Array.isArray(value))
-    return false;
-  return Object.keys(value).length === 0;
-}
-function createInvokeToolHandler(mcp, options = {}) {
-  assertRestResourceBinding(mcp, options);
-  const authorizer = createRequestAuthorizer(mcp, options);
-  const handle = async (request, toolName, recorder) => {
-    const authResult = await authorizer.authorize(request, recorder);
-    if (!authResult.ok)
-      return authResult.response;
-    if (request.method !== "POST")
-      return methodNotAllowed("POST, OPTIONS");
-    const tool = mcp.tools.find((t) => t.name === toolName);
-    if (!tool) {
-      return new Response(JSON.stringify({ error: `unknown tool: ${safeReflectName(toolName)}` }), {
-        status: 404,
-        headers: JSON_HEADERS
-      });
-    }
-    let rawArgs = {};
-    const text = await request.text();
-    if (text) {
-      try {
-        rawArgs = JSON.parse(text);
-      } catch {
-        return new Response(JSON.stringify({ error: "invalid JSON body" }), {
-          status: 400,
-          headers: JSON_HEADERS
-        });
-      }
-    }
-    let args = rawArgs;
-    if (tool.inputSchema) {
-      try {
-        const schema = objectFromShape(tool.inputSchema);
-        const parsed = await safeParseAsync(schema, rawArgs);
-        if (!parsed.success) {
-          return new Response(
-            JSON.stringify({
-              error: "validation failed",
-              details: getParseErrorMessage(parsed.error)
-            }),
-            { status: 400, headers: JSON_HEADERS }
-          );
-        }
-        args = parsed.data;
-      } catch {
-        return new Response(JSON.stringify({ error: "schema error", tool: toolName }), {
-          status: 500,
-          headers: JSON_HEADERS
-        });
-      }
-    } else if (!isEmptyArgs(rawArgs)) {
-      return new Response(JSON.stringify({ error: "tool has no inputSchema; expected empty body" }), {
-        status: 400,
-        headers: JSON_HEADERS
-      });
-    }
-    let result;
-    const start = nowMs();
-    try {
-      result = await tool.handler(args, new ToolContext(authResult.auth));
-    } catch {
-      await recorder.emit({
-        tool: tool.name,
-        method: "tools/call",
-        outcome: "handler_error",
-        durationMs: nowMs() - start
-      });
-      return new Response(JSON.stringify({ error: "handler threw", tool: toolName }), {
-        status: 500,
-        headers: JSON_HEADERS
-      });
-    }
-    if (result == null) {
-      await recorder.emit({
-        tool: tool.name,
-        method: "tools/call",
-        outcome: "handler_error",
-        durationMs: nowMs() - start
-      });
-      return new Response(JSON.stringify({ error: `tool "${toolName}" returned no result` }), {
-        status: 500,
-        headers: JSON_HEADERS
-      });
-    }
-    await recorder.emit({
-      tool: tool.name,
-      method: "tools/call",
-      outcome: result.isError ? "tool_error" : "ok",
-      durationMs: nowMs() - start,
-      errorText: result.isError ? extractTextContent(result.content) : void 0
-    });
-    return Response.json({
-      content: result.content ?? [],
-      structuredContent: result.structuredContent,
-      isError: result.isError
-    });
-  };
-  return async (request, toolName, recorder = createNoopRecorder()) => {
-    if (request.method === "OPTIONS")
-      return corsPreflightResponse("POST, OPTIONS");
-    return withCors(await handle(request, toolName, recorder));
-  };
-}
-
-export {
-  createInvokeToolHandler
-};

package/dist/chunk-UQK5UO6C.js

@@ -1,26 +0,0 @@
-// src/core/forwarded.ts
-function applyForwardedOrigin(request, options) {
-  const proto = options.trustForwardedProto ? firstForwardedValue(request, "x-forwarded-proto") : void 0;
-  const host = options.trustForwardedHost ? firstForwardedValue(request, "x-forwarded-host") : void 0;
-  if (proto === void 0 && host === void 0)
-    return request;
-  const url = new URL(request.url);
-  let changed = false;
-  if (proto !== void 0 && `${proto}:` !== url.protocol) {
-    url.protocol = `${proto}:`;
-    changed = true;
-  }
-  if (host !== void 0 && host !== url.host) {
-    url.host = host;
-    changed = true;
-  }
-  return changed ? new Request(url.href, request) : request;
-}
-function firstForwardedValue(request, header) {
-  const value = request.headers.get(header)?.split(",")[0]?.trim();
-  return value ? value : void 0;
-}
-
-export {
-  applyForwardedOrigin
-};

package/dist/chunk-XQWJN6DC.js

@@ -1,14 +0,0 @@
-// src/stacks/supabase/paths.ts
-var FUNCTIONS_MOUNT_PREFIX = "/functions/v1/";
-function assertFunctionName(value, label = "functionName") {
-  if (!/^[a-zA-Z0-9_-]+$/.test(value)) {
-    throw new Error(
-      `@lovable.dev/mcp-js: ${label} must be a single path segment matching [A-Za-z0-9_-], got ${JSON.stringify(value)}`
-    );
-  }
-}
-
-export {
-  FUNCTIONS_MOUNT_PREFIX,
-  assertFunctionName
-};

package/dist/chunk-Y3ZFPEQH.js

@@ -1,8 +0,0 @@
-// src/core/fs-errors.ts
-function isFileMissing(err) {
-  return typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT";
-}
-
-export {
-  isFileMissing
-};