@lovable.dev/mcp-js 0.16.0 → 0.19.0

package/dist/{recorder-qlzUKFxG.d.ts → base-C9rhAHZ0.d.ts}

@@ -11,11 +11,10 @@ interface InvocationRecord {
     reqBytes?: number;
     resBytes?: number;
 }
+/** A per-request telemetry recorder. `emit` logs the invocation and sends it as a
+ *  single OTLP POST, awaited so it lands before the request ends. */
 interface MetricsRecorder {
-    /** Buffer one invocation. Synchronous, sampled, and never throws. */
-    record(ev: InvocationRecord): void;
-    /** Best-effort POST of the current buffer. Resolves even on network failure. */
-    flush(): Promise<void>;
+    emit(ev: InvocationRecord): Promise<void>;
 }
 
 export type { MetricsRecorder as M };

package/dist/{chunk-W2EZWPJ5.js → chunk-57ZH2WW5.js}

@@ -5,13 +5,12 @@ import {
   JSON_HEADERS,
   assertRestResourceBinding,
   corsPreflightResponse,
-  createRecorderForRuntime,
+  createNoopRecorder,
   createRequestAuthorizer,
   methodNotAllowed,
   nowMs,
-  reportInvocation,
   withCors
-} from "./chunk-H6BKTNJY.js";
+} from "./chunk-5FX6IIQ6.js";
 
 // src/protocols/rest/invoke-tool.ts
 import { getParseErrorMessage, objectFromShape, safeParseAsync } from "@modelcontextprotocol/sdk/server/zod-compat.js";
@@ -27,11 +26,11 @@ function isEmptyArgs(value) {
     return false;
   return Object.keys(value).length === 0;
 }
-function createInvokeToolHandler(mcp, options = {}, recorder = createRecorderForRuntime(mcp)) {
+function createInvokeToolHandler(mcp, options = {}) {
   assertRestResourceBinding(mcp, options);
-  const authorizer = createRequestAuthorizer(mcp, options, recorder);
-  const handle = async (request, toolName) => {
-    const authResult = await authorizer.authorize(request);
+  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")
@@ -87,7 +86,7 @@ function createInvokeToolHandler(mcp, options = {}, recorder = createRecorderFor
     try {
       result = await tool.handler(args, new ToolContext(authResult.auth));
     } catch {
-      reportInvocation(recorder, {
+      await recorder.emit({
         tool: tool.name,
         method: "tools/call",
         outcome: "handler_error",
@@ -99,7 +98,7 @@ function createInvokeToolHandler(mcp, options = {}, recorder = createRecorderFor
       });
     }
     if (result == null) {
-      reportInvocation(recorder, {
+      await recorder.emit({
         tool: tool.name,
         method: "tools/call",
         outcome: "handler_error",
@@ -110,7 +109,7 @@ function createInvokeToolHandler(mcp, options = {}, recorder = createRecorderFor
         headers: JSON_HEADERS
       });
     }
-    reportInvocation(recorder, {
+    await recorder.emit({
       tool: tool.name,
       method: "tools/call",
       outcome: result.isError ? "tool_error" : "ok",
@@ -122,10 +121,10 @@ function createInvokeToolHandler(mcp, options = {}, recorder = createRecorderFor
       isError: result.isError
     });
   };
-  return async (request, toolName) => {
+  return async (request, toolName, recorder = createNoopRecorder()) => {
     if (request.method === "OPTIONS")
       return corsPreflightResponse("POST, OPTIONS");
-    return withCors(await handle(request, toolName));
+    return withCors(await handle(request, toolName, recorder));
   };
 }
 

package/dist/{chunk-H6BKTNJY.js → chunk-5FX6IIQ6.js}

@@ -1,17 +1,19 @@
 import {
   DEFAULT_METRICS_ENDPOINT,
+  LOG_LEVEL_ENV_VAR,
+  applyLogLevelFromEnv,
   describeError,
   log,
   parseSafeUrl,
   resolveMetricsConfig,
   trimTrailingSlash
-} from "./chunk-DCWYK4CA.js";
+} from "./chunk-H37EB22A.js";
 import {
   OAUTH_PROTECTED_RESOURCE_METADATA_PATH
 } from "./chunk-6DXGZZA4.js";
 import {
   version
-} from "./chunk-SKSKC747.js";
+} from "./chunk-CDZ7MBXC.js";
 
 // src/core/http.ts
 var JSON_HEADERS = { "Content-Type": "application/json" };
@@ -72,6 +74,7 @@ function toLogRecord(rec) {
     attributes.push(intAttr("mcp.request_size_bytes", rec.reqBytes));
   if (rec.resBytes !== void 0)
     attributes.push(intAttr("mcp.response_size_bytes", rec.resBytes));
+  attributes.push(strAttr("mcp.stack", rec.stack));
   return {
     timeUnixNano: rec.timeUnixNano,
     observedTimeUnixNano: rec.timeUnixNano,
@@ -108,127 +111,148 @@ function nowUnixNano() {
   return `${Date.now()}000000`;
 }
 
-// src/metrics/recorder.ts
+// src/metrics/impl/base.ts
 function nowMs() {
   return typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
 }
-function reportInvocation(recorder, ev) {
-  log.info("tool.invoked", { tool: ev.tool, method: ev.method, outcome: ev.outcome, durationMs: ev.durationMs });
-  recorder.record(ev);
-}
-var NOOP_RECORDER = {
-  record() {
-  },
-  async flush() {
-  }
-};
+var NOOP_RECORDER = { async emit() {
+} };
 function createNoopRecorder() {
   return NOOP_RECORDER;
 }
-function readRuntimeEnv(name) {
+function readProcessEnv(name) {
   try {
-    const denoEnv = globalThis.Deno?.env;
-    const value = denoEnv?.get?.(name);
-    if (value)
-      return value;
-  } catch {
-  }
-  try {
-    if (typeof process !== "undefined") {
-      const value = process.env?.[name];
-      if (value)
-        return value;
-    }
+    return typeof process !== "undefined" ? process.env?.[name] || void 0 : void 0;
   } catch {
+    return void 0;
   }
-  return void 0;
-}
-function probeWaitUntil() {
-  const fn = globalThis.EdgeRuntime?.waitUntil;
-  return typeof fn === "function" ? fn.bind(globalThis.EdgeRuntime) : void 0;
 }
-function createMetricsRecorder(ctx, deps = {}) {
-  const { config, server } = ctx;
-  if (!config.enabled)
-    return NOOP_RECORDER;
-  const doFetch = deps.fetch ?? globalThis.fetch;
-  if (!doFetch) {
-    log.warn("metrics.disabled_no_fetch", { endpoint: config.endpoint });
-    return NOOP_RECORDER;
-  }
-  const usesLovableEndpoint = config.endpoint === DEFAULT_METRICS_ENDPOINT;
-  const apiKey = usesLovableEndpoint ? (deps.getApiKey ?? (() => readRuntimeEnv(config.apiKeyEnvVar)))() : void 0;
-  if (usesLovableEndpoint && !apiKey) {
-    log.warn("metrics.disabled_no_api_key", { envVar: config.apiKeyEnvVar, endpoint: config.endpoint });
-    return NOOP_RECORDER;
-  }
-  const waitUntil = deps.waitUntil ?? probeWaitUntil();
-  const buffer = [];
-  let timer;
-  const schedule = (p) => {
-    if (waitUntil) {
-      try {
-        waitUntil(p);
-        return;
-      } catch (err) {
-        log.warn("metrics.wait_until_failed", describeError(err));
+var BaseMetricRecorder = class {
+  constructor(config, server, deps = {}) {
+    this.config = config;
+    this.server = server;
+    this.deps = deps;
+    this.doFetch = deps.fetch ?? globalThis.fetch;
+    this.usesLovableEndpoint = config.endpoint === DEFAULT_METRICS_ENDPOINT;
+    const headers = {};
+    if (!this.usesLovableEndpoint) {
+      for (const [key, value] of Object.entries(config.headers)) {
+        if (key.toLowerCase() !== "content-type")
+          headers[key] = value;
       }
     }
-    void p.catch(() => {
-    });
-  };
-  const headers = {};
-  if (!usesLovableEndpoint) {
-    for (const [key, value] of Object.entries(config.headers)) {
-      if (key.toLowerCase() !== "content-type")
-        headers[key] = value;
-    }
+    headers["content-type"] = "application/json";
+    this.baseHeaders = headers;
   }
-  headers["content-type"] = "application/json";
-  if (apiKey)
-    headers.authorization = `Bearer ${apiKey}`;
-  const flush = async () => {
-    if (buffer.length === 0)
+  doFetch;
+  usesLovableEndpoint;
+  baseHeaders;
+  apiKey;
+  lazyLogLevelApplied = false;
+  async emit(ev) {
+    await this.applyLazyLogLevel();
+    log.info("tool.invoked", {
+      tool: ev.tool,
+      method: ev.method,
+      outcome: ev.outcome,
+      durationMs: ev.durationMs,
+      stack: this.stack
+    });
+    if (!this.config.enabled)
       return;
-    const records = buffer.splice(0, buffer.length);
-    const dropped = records.length;
-    try {
-      const res = await doFetch(config.endpoint, {
-        method: "POST",
-        headers,
-        body: buildLogsPayload(records, server),
-        keepalive: true
-      });
-      if (!res.ok) {
-        log.warn("metrics.flush_rejected", { status: res.status, dropped, endpoint: config.endpoint });
+    if (!this.doFetch) {
+      log.warn("metrics.disabled_no_fetch", { endpoint: this.config.endpoint });
+      return;
+    }
+    const headers = { ...this.baseHeaders };
+    if (this.usesLovableEndpoint) {
+      const key = await this.resolveApiKey();
+      if (!key) {
+        log.warn("metrics.disabled_no_api_key", { envVar: this.config.apiKeyEnvVar, endpoint: this.config.endpoint });
+        return;
       }
+      headers.authorization = `Bearer ${key}`;
+    }
+    const body = buildLogsPayload([{ ...ev, timeUnixNano: nowUnixNano(), stack: this.stack }], this.server);
+    try {
+      const res = await this.doFetch(this.config.endpoint, { method: "POST", headers, body, keepalive: true });
+      if (!res.ok)
+        log.warn("metrics.rejected", { status: res.status, endpoint: this.config.endpoint });
     } catch (err) {
-      log.warn("metrics.flush_failed", { ...describeError(err), dropped, endpoint: config.endpoint });
+      log.warn("metrics.failed", { ...describeError(err), endpoint: this.config.endpoint });
     }
-  };
-  const ensureTimer = () => {
-    if (timer !== void 0)
+  }
+  // Cache only a successful resolution so a miss is retried on the next emit (the
+  // Cloudflare binding may not be readable on the very first attempt in an isolate).
+  async resolveApiKey() {
+    if (this.apiKey)
+      return this.apiKey;
+    this.apiKey = this.deps.getApiKey ? this.deps.getApiKey() : await this.readEnv(this.config.apiKeyEnvVar);
+    return this.apiKey;
+  }
+  async applyLazyLogLevel() {
+    if (this.lazyLogLevelApplied)
       return;
-    timer = setInterval(() => schedule(flush()), config.flushIntervalMs);
-    timer.unref?.();
-  };
-  return {
-    record(ev) {
-      if (config.sampleRate < 1 && Math.random() >= config.sampleRate)
-        return;
-      buffer.push({ ...ev, timeUnixNano: nowUnixNano() });
-      ensureTimer();
-      if (buffer.length >= config.maxBatchSize)
-        schedule(flush());
-    },
-    flush
-  };
+    this.lazyLogLevelApplied = true;
+    applyLogLevelFromEnv(await this.readEnv(LOG_LEVEL_ENV_VAR));
+  }
+};
+
+// src/metrics/impl/cloudflare.ts
+var cloudflareEnvPromise;
+async function readCloudflareEnv(name) {
+  try {
+    const moduleSpecifier = "cloudflare:workers";
+    cloudflareEnvPromise ??= import(
+      /* @vite-ignore */
+      moduleSpecifier
+    ).then((m) => m.env).catch((err) => {
+      log.debug("metrics.cloudflare_env_import_failed", describeError(err));
+      return void 0;
+    });
+    const env = await cloudflareEnvPromise;
+    const raw = env?.[name];
+    const value = typeof raw === "string" && raw ? raw : void 0;
+    log.debug("metrics.read_cloudflare_env", { name, hasEnvBinding: !!env, found: value !== void 0 });
+    return value;
+  } catch (err) {
+    log.debug("metrics.read_cloudflare_env_error", { name, ...describeError(err) });
+    return void 0;
+  }
+}
+var TanStackMetricRecorder = class extends BaseMetricRecorder {
+  stack = "tanstack";
+  async readEnv(name) {
+    return readProcessEnv(name) ?? await readCloudflareEnv(name);
+  }
+};
+
+// src/metrics/impl/supabase.ts
+function readDenoEnv(name) {
+  try {
+    const denoEnv = globalThis.Deno?.env;
+    const value = denoEnv?.get?.(name) || void 0;
+    log.debug("metrics.read_deno_env", { name, hasDenoEnv: !!denoEnv, found: !!value });
+    return value;
+  } catch (err) {
+    log.debug("metrics.read_deno_env_error", { name, ...describeError(err) });
+    return void 0;
+  }
 }
-function createRecorderForRuntime(mcp) {
+var SupabaseMetricRecorder = class extends BaseMetricRecorder {
+  stack = "supabase";
+  async readEnv(name) {
+    return readDenoEnv(name) ?? readProcessEnv(name);
+  }
+};
+
+// src/metrics/recorder.ts
+function createRecorderForRuntime(mcp, opts) {
   const config = resolveMetricsConfig(mcp.metrics);
+  const server = { name: mcp.name, version: mcp.version };
   if (!config.enabled)
     return createNoopRecorder();
-  return createMetricsRecorder({ config, server: { name: mcp.name, version: mcp.version } });
+  return opts.stack === "tanstack" ? new TanStackMetricRecorder(config, server) : new SupabaseMetricRecorder(config, server);
 }
 
 // src/core/promise.ts
@@ -596,10 +620,10 @@ function assertRequiredScopes(auth, context) {
     throw new OAuthTokenError(403, "insufficient_scope", "Additional OAuth scope is required");
   }
 }
-function createRequestAuthorizer(mcp, options = {}, recorder) {
+function createRequestAuthorizer(mcp, options = {}) {
   const runtime = getOAuthRuntime(mcp, options);
   return {
-    async authorize(request) {
+    async authorize(request, recorder) {
       if (runtime.kind === "unconfigured")
         return { ok: true };
       const startedAt = nowMs();
@@ -615,7 +639,7 @@ function createRequestAuthorizer(mcp, options = {}, recorder) {
       } catch (err) {
         if (err instanceof OAuthConfigurationError) {
           log.error("auth.config_error", { ...describeError(err), outcome: "500" });
-          recorder?.record({
+          await recorder?.emit({
             tool: null,
             method: "authorize",
             outcome: "auth_config_error",
@@ -679,7 +703,7 @@ export {
   headResponse,
   methodNotAllowed,
   nowMs,
-  reportInvocation,
+  createNoopRecorder,
   createRecorderForRuntime,
   resolveProtectedResource,
   assertResourcePathShape,

package/dist/{chunk-SKSKC747.js → chunk-CDZ7MBXC.js}

@@ -1,5 +1,5 @@
 // package.json
-var version = "0.16.0";
+var version = "0.19.0";
 
 export {
   version

package/dist/{chunk-EZQVUNXB.js → chunk-CLXKPZZE.js}

@@ -3,16 +3,15 @@ import {
 } from "./chunk-MA5H6PSF.js";
 import {
   corsPreflightResponse,
-  createRecorderForRuntime,
+  createNoopRecorder,
   createRequestAuthorizer,
   nowMs,
-  reportInvocation,
   withCors
-} from "./chunk-H6BKTNJY.js";
+} from "./chunk-5FX6IIQ6.js";
 import {
   describeError,
   log
-} from "./chunk-DCWYK4CA.js";
+} from "./chunk-H37EB22A.js";
 
 // src/protocols/mcp/protocol.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -25,7 +24,7 @@ function adaptToolToSdkCallback(tool, auth, recorder) {
     try {
       result = await tool.handler(args, new ToolContext(auth));
     } catch {
-      reportInvocation(recorder, {
+      await recorder.emit({
         tool: tool.name,
         method: "tools/call",
         outcome: "handler_error",
@@ -34,7 +33,7 @@ function adaptToolToSdkCallback(tool, auth, recorder) {
       return { content: [{ type: "text", text: "tool execution failed" }], isError: true };
     }
     if (result == null) {
-      reportInvocation(recorder, {
+      await recorder.emit({
         tool: tool.name,
         method: "tools/call",
         outcome: "handler_error",
@@ -42,7 +41,7 @@ function adaptToolToSdkCallback(tool, auth, recorder) {
       });
       return { content: [{ type: "text", text: `tool "${tool.name}" returned no result` }], isError: true };
     }
-    reportInvocation(recorder, {
+    await recorder.emit({
       tool: tool.name,
       method: "tools/call",
       outcome: result.isError ? "tool_error" : "ok",
@@ -51,10 +50,10 @@ function adaptToolToSdkCallback(tool, auth, recorder) {
     return { content: result.content ?? [], structuredContent: result.structuredContent, isError: result.isError };
   };
 }
-function createMcpProtocolHandler(mcp, options = {}, recorder = createRecorderForRuntime(mcp)) {
-  const authorizer = createRequestAuthorizer(mcp, options, recorder);
-  const handle = async (request) => {
-    const authResult = await authorizer.authorize(request);
+function createMcpProtocolHandler(mcp, options = {}) {
+  const authorizer = createRequestAuthorizer(mcp, options);
+  const handle = async (request, recorder) => {
+    const authResult = await authorizer.authorize(request, recorder);
     if (!authResult.ok)
       return authResult.response;
     try {
@@ -81,7 +80,7 @@ function createMcpProtocolHandler(mcp, options = {}, recorder = createRecorderFo
       await server.connect(transport);
       return await transport.handleRequest(request);
     } catch (err) {
-      recorder.record({ tool: null, method: "transport", outcome: "transport_error", durationMs: 0 });
+      await recorder.emit({ tool: null, method: "transport", outcome: "transport_error", durationMs: 0 });
       log.error("mcp.transport_error", { ...describeError(err), outcome: "500 internal error" });
       return Response.json(
         { jsonrpc: "2.0", id: null, error: { code: -32603, message: "internal error" } },
@@ -89,10 +88,10 @@ function createMcpProtocolHandler(mcp, options = {}, recorder = createRecorderFo
       );
     }
   };
-  return async (request) => {
+  return async (request, recorder = createNoopRecorder()) => {
     if (request.method === "OPTIONS")
       return corsPreflightResponse("GET, POST, DELETE, OPTIONS");
-    return withCors(await handle(request));
+    return withCors(await handle(request, recorder));
   };
 }
 

package/dist/{chunk-DCWYK4CA.js → chunk-H37EB22A.js}

@@ -3,19 +3,27 @@ var LEVEL_RANK = { silent: 0, error: 1, warn: 2, info: 3, debug: 4 };
 function isLogLevel(value) {
   return typeof value === "string" && value in LEVEL_RANK;
 }
+var LOG_LEVEL_ENV_VAR = "LOVABLE_MCP_LOG_LEVEL";
 function readEnvLevel() {
   try {
-    const raw = typeof process !== "undefined" ? process.env?.["LOVABLE_MCP_LOG_LEVEL"] : void 0;
+    const raw = typeof process !== "undefined" ? process.env?.[LOG_LEVEL_ENV_VAR] : void 0;
     const normalized = raw?.trim().toLowerCase();
     return isLogLevel(normalized) ? normalized : void 0;
   } catch {
     return void 0;
   }
 }
-var currentLevel = readEnvLevel() ?? "silent";
+var currentLevel = readEnvLevel() ?? "debug";
 function setLogLevel(level) {
   currentLevel = level;
 }
+function parseLogLevel(raw) {
+  const normalized = raw?.trim().toLowerCase();
+  return isLogLevel(normalized) ? normalized : void 0;
+}
+function applyLogLevelFromEnv(raw) {
+  setLogLevel(parseLogLevel(raw) ?? "debug");
+}
 function enabled(level) {
   return LEVEL_RANK[level] <= LEVEL_RANK[currentLevel];
 }
@@ -45,9 +53,6 @@ function describeError(err) {
 // src/metrics/config.ts
 var DEFAULT_METRICS_ENDPOINT = "https://api.lovable.dev/v1/app-mcp-usage";
 var METRICS_API_KEY_ENV_VAR = "LOVABLE_API_KEY";
-var METRICS_SAMPLE_RATE = 1;
-var METRICS_FLUSH_INTERVAL_MS = 5e3;
-var METRICS_MAX_BATCH_SIZE = 50;
 function assertMetricsEndpoint(endpoint) {
   let url;
   try {
@@ -67,10 +72,7 @@ function resolveMetricsConfig(config = true) {
     enabled: options.enabled ?? true,
     endpoint,
     headers: options.headers ?? {},
-    apiKeyEnvVar: METRICS_API_KEY_ENV_VAR,
-    sampleRate: METRICS_SAMPLE_RATE,
-    flushIntervalMs: METRICS_FLUSH_INTERVAL_MS,
-    maxBatchSize: METRICS_MAX_BATCH_SIZE
+    apiKeyEnvVar: METRICS_API_KEY_ENV_VAR
   });
 }
 
@@ -115,7 +117,9 @@ export {
   resolveMetricsConfig,
   trimTrailingSlash,
   parseSafeUrl,
+  LOG_LEVEL_ENV_VAR,
   setLogLevel,
+  applyLogLevelFromEnv,
   log,
   describeError
 };

package/dist/{chunk-I5CAQUQI.js → chunk-OMWXY6WY.js}

@@ -1,12 +1,12 @@
 import {
   assertRestResourceBinding,
   corsPreflightResponse,
-  createRecorderForRuntime,
+  createNoopRecorder,
   createRequestAuthorizer,
   headResponse,
   methodNotAllowed,
   withCors
-} from "./chunk-H6BKTNJY.js";
+} from "./chunk-5FX6IIQ6.js";
 
 // src/protocols/rest/list-tools.ts
 import { objectFromShape } from "@modelcontextprotocol/sdk/server/zod-compat.js";
@@ -33,11 +33,11 @@ function buildMcpListing(mcp) {
     }))
   };
 }
-function createListToolsHandler(mcp, options = {}, recorder = createRecorderForRuntime(mcp)) {
+function createListToolsHandler(mcp, options = {}) {
   assertRestResourceBinding(mcp, options);
-  const authorizer = createRequestAuthorizer(mcp, options, recorder);
-  const handle = async (request) => {
-    const authResult = await authorizer.authorize(request);
+  const authorizer = createRequestAuthorizer(mcp, options);
+  const handle = async (request, recorder) => {
+    const authResult = await authorizer.authorize(request, recorder);
     if (!authResult.ok)
       return authResult.response;
     if (request.method !== "GET" && request.method !== "HEAD")
@@ -45,10 +45,10 @@ function createListToolsHandler(mcp, options = {}, recorder = createRecorderForR
     const response = Response.json(buildMcpListing(mcp));
     return request.method === "HEAD" ? headResponse(response) : response;
   };
-  return async (request) => {
+  return async (request, recorder = createNoopRecorder()) => {
     if (request.method === "OPTIONS")
       return corsPreflightResponse("GET, HEAD, OPTIONS");
-    return withCors(await handle(request));
+    return withCors(await handle(request, recorder));
   };
 }
 

package/dist/{chunk-T24Z753F.js → chunk-UEOBGHXF.js}

@@ -7,11 +7,11 @@ import {
   oauthConfigurationErrorResponse,
   resolveProtectedResource,
   withCors
-} from "./chunk-H6BKTNJY.js";
+} from "./chunk-5FX6IIQ6.js";
 import {
   describeError,
   log
-} from "./chunk-DCWYK4CA.js";
+} from "./chunk-H37EB22A.js";
 
 // src/protocols/oauth-metadata.ts
 function notFound() {

package/dist/cli/extract-manifest.cjs

@@ -13,7 +13,7 @@ function isFileMissing(err) {
 }
 
 // package.json
-var version = "0.16.0";
+var version = "0.19.0";
 
 // src/protocols/rest/list-tools.ts
 var import_zod_compat = require("@modelcontextprotocol/sdk/server/zod-compat.js");
@@ -24,16 +24,17 @@ var LEVEL_RANK = { silent: 0, error: 1, warn: 2, info: 3, debug: 4 };
 function isLogLevel(value) {
   return typeof value === "string" && value in LEVEL_RANK;
 }
+var LOG_LEVEL_ENV_VAR = "LOVABLE_MCP_LOG_LEVEL";
 function readEnvLevel() {
   try {
-    const raw = typeof process !== "undefined" ? process.env?.["LOVABLE_MCP_LOG_LEVEL"] : void 0;
+    const raw = typeof process !== "undefined" ? process.env?.[LOG_LEVEL_ENV_VAR] : void 0;
     const normalized = raw?.trim().toLowerCase();
     return isLogLevel(normalized) ? normalized : void 0;
   } catch {
     return void 0;
   }
 }
-var currentLevel = readEnvLevel() ?? "silent";
+var currentLevel = readEnvLevel() ?? "debug";
 
 // src/auth/verifier.ts
 var import_jose = require("jose");

package/dist/cli/extract-manifest.js

@@ -1,16 +1,16 @@
 #!/usr/bin/env node
 import {
   buildMcpListing
-} from "../chunk-I5CAQUQI.js";
-import "../chunk-H6BKTNJY.js";
-import "../chunk-DCWYK4CA.js";
+} from "../chunk-OMWXY6WY.js";
+import "../chunk-5FX6IIQ6.js";
+import "../chunk-H37EB22A.js";
 import "../chunk-6DXGZZA4.js";
 import {
   isFileMissing
 } from "../chunk-Y3ZFPEQH.js";
 import {
   version
-} from "../chunk-SKSKC747.js";
+} from "../chunk-CDZ7MBXC.js";
 
 // src/manifest/io.ts
 import { randomUUID } from "crypto";