@introspection-ai/recipes 0.18.0 → 0.19.0

package/dist/mcp-chunks/chunk-CA5WFJZA.js

@@ -0,0 +1,197 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+
+// node_modules/.pnpm/mcporter@0.13.0/node_modules/mcporter/dist/runtime/elicitation.js
+import readline from "node:readline";
+var NON_INTERACTIVE_ELICITATION_HINT = "Server requested interactive input; run mcporter in a terminal.";
+function createInteractiveElicitationResponder(options = {}) {
+  const input = options.input ?? process.stdin;
+  const output = options.output ?? process.stderr;
+  let declined = false;
+  return {
+    handler: async (request, context) => {
+      const result = await handleInteractiveRequest(request.params, context, input, output);
+      if (result.action !== "accept")
+        declined = true;
+      return result;
+    },
+    didDecline: () => declined
+  };
+}
+function createNonInteractiveElicitationResponder(options = {}) {
+  let declined = false;
+  return {
+    handler: async (request, context) => {
+      declined = true;
+      options.onDecline?.(request, context);
+      return { action: "decline" };
+    },
+    didDecline: () => declined
+  };
+}
+function registerElicitationHandler(client, handler, context) {
+  client.setRequestHandler("elicitation/create", async (request) => handler(request, context));
+}
+async function handleInteractiveRequest(params, context, input, output) {
+  const rl = readline.createInterface({ input, output, terminal: true });
+  try {
+    writeLine(output, `
+Server '${sanitizeTerminalText(context.server)}' is requesting input:`);
+    writeLine(output, sanitizeTerminalText(params.message));
+    if (params.mode === "url")
+      return await handleUrlRequest(rl, params, output);
+    return await handleFormRequest(rl, params, output);
+  } finally {
+    rl.close();
+  }
+}
+async function handleUrlRequest(rl, params, output) {
+  writeLine(output, `
+Open this URL to continue:
+${sanitizeTerminalText(params.url)}
+`);
+  const answer = await ask(rl, "Press Enter when you are done (Ctrl-C to decline): ");
+  return answer === void 0 ? { action: "decline" } : { action: "accept" };
+}
+async function handleFormRequest(rl, params, output) {
+  const required = new Set(params.requestedSchema.required ?? []);
+  const content = {};
+  for (const [name, schema] of Object.entries(params.requestedSchema.properties)) {
+    const value = await promptForField(rl, output, name, schema, required.has(name));
+    if (value.kind === "decline")
+      return { action: "decline" };
+    if (value.value !== void 0)
+      content[name] = value.value;
+  }
+  return { action: "accept", content };
+}
+async function promptForField(rl, output, name, schema, required) {
+  const label = sanitizeTerminalText(schema.title ?? name);
+  if (schema.description)
+    writeLine(output, sanitizeTerminalText(schema.description));
+  const choices = enumChoices(schema);
+  const displayChoices = choices.map(sanitizeTerminalText);
+  if (displayChoices.length > 0)
+    writeLine(output, `  Choices: ${displayChoices.join(", ")}`);
+  const defaultValue = "default" in schema ? schema.default : void 0;
+  const suffix = `${required ? " (required)" : ""}${defaultValue !== void 0 ? ` [${formatDefault(defaultValue)}]` : ""}: `;
+  while (true) {
+    const answer = await ask(rl, `${label}${suffix}`);
+    if (answer === void 0)
+      return { kind: "decline" };
+    const trimmed = answer.trim();
+    if (trimmed.length === 0) {
+      if (defaultValue !== void 0)
+        return { kind: "answer", value: defaultValue };
+      if (!required)
+        return { kind: "answer" };
+      writeLine(output, `${label} is required.`);
+      continue;
+    }
+    const parsed = parsePrimitive(trimmed, schema, choices);
+    if (parsed.ok)
+      return { kind: "answer", value: parsed.value };
+    writeLine(output, parsed.message);
+  }
+}
+function parsePrimitive(answer, schema, choices) {
+  const displayChoices = choices.map(sanitizeTerminalText);
+  if (schema.type === "boolean") {
+    const normalized = answer.toLowerCase();
+    if (["true", "yes", "y", "1"].includes(normalized))
+      return { ok: true, value: true };
+    if (["false", "no", "n", "0"].includes(normalized))
+      return { ok: true, value: false };
+    return { ok: false, message: "Enter yes/no or true/false." };
+  }
+  if (schema.type === "number" || schema.type === "integer") {
+    const value = Number(answer);
+    if (!Number.isFinite(value) || schema.type === "integer" && !Number.isInteger(value)) {
+      return { ok: false, message: `Enter a valid ${schema.type}.` };
+    }
+    if (schema.minimum !== void 0 && value < schema.minimum) {
+      return { ok: false, message: `Enter a value greater than or equal to ${schema.minimum}.` };
+    }
+    if (schema.maximum !== void 0 && value > schema.maximum) {
+      return { ok: false, message: `Enter a value less than or equal to ${schema.maximum}.` };
+    }
+    return { ok: true, value };
+  }
+  if (schema.type === "array") {
+    const values = answer.split(",").map((entry) => entry.trim()).filter(Boolean);
+    const invalid = values.find((value) => !choices.includes(value));
+    return invalid ? { ok: false, message: `Choose comma-separated values from: ${displayChoices.join(", ")}.` } : { ok: true, value: values };
+  }
+  if (choices.length > 0 && !choices.includes(answer)) {
+    return { ok: false, message: `Choose one of: ${displayChoices.join(", ")}.` };
+  }
+  if ("minLength" in schema && schema.minLength !== void 0 && answer.length < schema.minLength) {
+    return { ok: false, message: `Enter at least ${schema.minLength} characters.` };
+  }
+  if ("maxLength" in schema && schema.maxLength !== void 0 && answer.length > schema.maxLength) {
+    return { ok: false, message: `Enter no more than ${schema.maxLength} characters.` };
+  }
+  return { ok: true, value: answer };
+}
+function enumChoices(schema) {
+  if ("enum" in schema && Array.isArray(schema.enum))
+    return [...schema.enum];
+  if ("oneOf" in schema && Array.isArray(schema.oneOf))
+    return schema.oneOf.map((entry) => entry.const);
+  if (schema.type === "array") {
+    if ("enum" in schema.items && Array.isArray(schema.items.enum))
+      return [...schema.items.enum];
+    if ("anyOf" in schema.items && Array.isArray(schema.items.anyOf)) {
+      return schema.items.anyOf.map((entry) => entry.const);
+    }
+  }
+  return [];
+}
+function ask(rl, prompt) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const finish = (value) => {
+      if (settled)
+        return;
+      settled = true;
+      rl.off("SIGINT", onInterrupt);
+      rl.off("close", onClose);
+      resolve(value);
+    };
+    const onInterrupt = () => finish(void 0);
+    const onClose = () => finish(void 0);
+    rl.once("SIGINT", onInterrupt);
+    rl.once("close", onClose);
+    rl.question(prompt, (answer) => finish(answer));
+  });
+}
+function formatDefault(value) {
+  return sanitizeTerminalText(Array.isArray(value) ? value.join(", ") : String(value));
+}
+var ANSI_ESCAPE_PATTERN = (
+  // eslint-disable-next-line no-control-regex -- Terminal escape bytes are the exact untrusted input being removed.
+  /(?:\u001b\][^\u0007]*(?:\u0007|\u001b\\)|\u001b[P^_][\s\S]*?\u001b\\|(?:\u001b\[|\u009b)[0-?]*[ -/]*[@-~]|\u001b[@-_])/gu
+);
+function sanitizeTerminalText(value) {
+  const withoutEscapes = value.replace(ANSI_ESCAPE_PATTERN, "");
+  let withoutControls = "";
+  for (const character of withoutEscapes) {
+    const codePoint = character.codePointAt(0) ?? 0;
+    if (character === "\r" || character === "\n" || character === "	") {
+      withoutControls += " ";
+    } else if (codePoint > 31 && (codePoint < 127 || codePoint > 159)) {
+      withoutControls += character;
+    }
+  }
+  return withoutControls.replace(/ {2,}/gu, " ").trim();
+}
+function writeLine(output, message) {
+  output.write(`${message}
+`);
+}
+
+export {
+  NON_INTERACTIVE_ELICITATION_HINT,
+  createInteractiveElicitationResponder,
+  createNonInteractiveElicitationResponder,
+  registerElicitationHandler
+};

package/dist/mcp-chunks/{chunk-LNH5LAJD.js → chunk-CNDY7WB4.js}

@@ -1,9 +1,9 @@
 import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
 import {
   logWarn
-} from "./chunk-UNKB4SBV.js";
+} from "./chunk-RBVYCKCD.js";
 
-// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/output-utils.js
+// node_modules/.pnpm/mcporter@0.13.0/node_modules/mcporter/dist/cli/output-utils.js
 import fs from "node:fs";
 import path from "node:path";
 import { inspect } from "node:util";

package/dist/mcp-chunks/{chunk-UKYNQGNE.js → chunk-DEUU7WSN.js}

@@ -1,10 +1,14 @@
 import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
 import {
+  SdkHttpError,
+  SseError,
   UnauthorizedError
-} from "./chunk-P3PSC54P.js";
+} from "./chunk-YPJ5EHXR.js";
 
-// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/error-classifier.js
+// node_modules/.pnpm/mcporter@0.13.0/node_modules/mcporter/dist/error-classifier.js
 var AUTH_STATUSES = /* @__PURE__ */ new Set([401, 403]);
+var KEYWORD_AUTH_PATTERNS = [/unauthorized/, /invalid_token/, /forbidden/];
+var NUMERIC_AUTH_PATTERNS = [/(?<![0-9a-z_])401(?![0-9a-z_])/i];
 var OFFLINE_PATTERNS = [
   "fetch failed",
   "econnrefused",
@@ -36,6 +40,20 @@ function analyzeConnectionError(error) {
   if (error instanceof UnauthorizedError) {
     return { kind: "auth", rawMessage };
   }
+  if (error instanceof SdkHttpError) {
+    return {
+      kind: AUTH_STATUSES.has(error.status) ? "auth" : "http",
+      rawMessage,
+      statusCode: error.status
+    };
+  }
+  if (error instanceof SseError && typeof error.code === "number") {
+    return {
+      kind: AUTH_STATUSES.has(error.code) ? "auth" : "http",
+      rawMessage,
+      statusCode: error.code
+    };
+  }
   const stdio = extractStdioExit(rawMessage);
   if (stdio) {
     return { kind: "stdio-exit", rawMessage, ...stdio };
@@ -43,15 +61,23 @@ function analyzeConnectionError(error) {
   const errorCode = extractErrorCode(error);
   const statusCode = errorCode ?? extractStatusCode(rawMessage);
   const normalized = rawMessage.toLowerCase();
-  if (AUTH_STATUSES.has(statusCode ?? -1) || containsAuthToken(normalized)) {
-    return { kind: "auth", rawMessage, statusCode };
+  if (statusCode !== void 0) {
+    if (AUTH_STATUSES.has(statusCode)) {
+      return { kind: "auth", rawMessage, statusCode };
+    }
+    if (statusCode >= 400) {
+      return { kind: "http", rawMessage, statusCode };
+    }
   }
-  if (statusCode && statusCode >= 400) {
-    return { kind: "http", rawMessage, statusCode };
+  if (matchesAny(KEYWORD_AUTH_PATTERNS, normalized)) {
+    return { kind: "auth", rawMessage, statusCode };
   }
   if (OFFLINE_PATTERNS.some((pattern) => normalized.includes(pattern))) {
     return { kind: "offline", rawMessage };
   }
+  if (matchesAny(NUMERIC_AUTH_PATTERNS, normalized)) {
+    return { kind: "auth", rawMessage, statusCode };
+  }
   return { kind: "other", rawMessage };
 }
 function extractMessage(error) {
@@ -110,8 +136,8 @@ function extractStatusCode(message) {
   }
   return void 0;
 }
-function containsAuthToken(normalizedMessage) {
-  return normalizedMessage.includes("401") || normalizedMessage.includes("unauthorized") || normalizedMessage.includes("invalid_token") || normalizedMessage.includes("forbidden");
+function matchesAny(patterns, normalizedMessage) {
+  return patterns.some((pattern) => pattern.test(normalizedMessage));
 }
 function extractStdioExit(message) {
   if (!message.toLowerCase().includes("stdio") && !STDIO_EXIT_PATTERN.test(message)) {

package/dist/mcp-chunks/{chunk-LKIBAYKU.js → chunk-DXPHJFSA.js}

@@ -1,6 +1,9 @@
 import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+import {
+  pickSharedDefinitionFields
+} from "./chunk-H7F5RZXS.js";
 
-// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli-metadata.js
+// node_modules/.pnpm/mcporter@0.13.0/node_modules/mcporter/dist/cli-metadata.js
 import { spawn } from "node:child_process";
 import fs from "node:fs/promises";
 function metadataPathForArtifact(artifactPath) {
@@ -61,6 +64,7 @@ function isErrno(error, code) {
   return Boolean(error && typeof error === "object" && error.code === code);
 }
 function serializeDefinition(definition) {
+  const sharedFields = pickSharedDefinitionFields(definition);
   if (definition.command.kind === "http") {
     return {
       name: definition.name,
@@ -71,18 +75,7 @@ function serializeDefinition(definition) {
         headers: definition.command.headers
       },
       env: definition.env,
-      auth: definition.auth,
-      tokenCacheDir: definition.tokenCacheDir,
-      clientName: definition.clientName,
-      oauthClientId: definition.oauthClientId,
-      oauthClientSecretEnv: definition.oauthClientSecretEnv,
-      oauthTokenEndpointAuthMethod: definition.oauthTokenEndpointAuthMethod,
-      oauthRedirectUrl: definition.oauthRedirectUrl,
-      oauthScope: definition.oauthScope,
-      refresh: definition.refresh,
-      httpFetch: definition.httpFetch,
-      allowedTools: definition.allowedTools,
-      blockedTools: definition.blockedTools
+      ...sharedFields
     };
   }
   return {
@@ -95,22 +88,24 @@ function serializeDefinition(definition) {
       cwd: definition.command.cwd
     },
     env: definition.env,
-    auth: definition.auth,
-    tokenCacheDir: definition.tokenCacheDir,
-    clientName: definition.clientName,
-    oauthClientId: definition.oauthClientId,
-    oauthClientSecretEnv: definition.oauthClientSecretEnv,
-    oauthTokenEndpointAuthMethod: definition.oauthTokenEndpointAuthMethod,
-    oauthRedirectUrl: definition.oauthRedirectUrl,
-    oauthScope: definition.oauthScope,
-    refresh: definition.refresh,
-    httpFetch: definition.httpFetch,
-    allowedTools: definition.allowedTools,
-    blockedTools: definition.blockedTools
+    ...sharedFields
   };
 }
 
-// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/generate/template-data.js
+// node_modules/.pnpm/mcporter@0.13.0/node_modules/mcporter/dist/cli/generate/tool-selection.js
+function validateToolSelection(includeTools, excludeTools, context) {
+  if (includeTools && excludeTools) {
+    throw new Error(context.mutuallyExclusiveMessage);
+  }
+  if (includeTools && includeTools.length === 0) {
+    throw new Error("--include-tools requires at least one tool name.");
+  }
+  if (excludeTools && excludeTools.length === 0) {
+    throw new Error("--exclude-tools requires at least one tool name.");
+  }
+}
+
+// node_modules/.pnpm/mcporter@0.13.0/node_modules/mcporter/dist/cli/generate/template-data.js
 function buildGenerateCliCommand(invocation, definition, globalFlags = {}) {
   const tokens = ["mcporter"];
   const configPath = invocation.configPath ?? globalFlags["--config"];
@@ -168,15 +163,9 @@ function resolveGenerateRequestFromArtifact(parsed, metadata, globalFlags) {
   }
   const includeTools = parsed.includeTools ?? invocation.includeTools;
   const excludeTools = parsed.excludeTools ?? invocation.excludeTools;
-  if (includeTools && excludeTools) {
-    throw new Error("Cannot combine --include-tools and --exclude-tools.");
-  }
-  if (includeTools && includeTools.length === 0) {
-    throw new Error("--include-tools requires at least one tool name.");
-  }
-  if (excludeTools && excludeTools.length === 0) {
-    throw new Error("--exclude-tools requires at least one tool name.");
-  }
+  validateToolSelection(includeTools, excludeTools, {
+    mutuallyExclusiveMessage: "Cannot combine --include-tools and --exclude-tools."
+  });
   return {
     serverRef,
     configPath: globalFlags["--config"] ?? invocation.configPath,
@@ -202,6 +191,7 @@ function shellQuote(value) {
 export {
   readCliMetadata,
   serializeDefinition,
+  validateToolSelection,
   buildGenerateCliCommand,
   resolveGenerateRequestFromArtifact,
   shellQuote

package/dist/mcp-chunks/{chunk-J6LYIZXN.js → chunk-E6RVTWJY.js}

@@ -1,6 +1,6 @@
 import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
 
-// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/record-replay-env.js
+// node_modules/.pnpm/mcporter@0.13.0/node_modules/mcporter/dist/cli/record-replay-env.js
 var KEEP_ALIVE_DISABLED_FOR_MODE = "*";
 function buildRecordCommandEnv(sessionName, server) {
   return buildModeEnv({

package/dist/mcp-chunks/{chunk-7FHEBT5G.js → chunk-E6T37ED6.js}

@@ -1,9 +1,9 @@
 import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
 import {
   legacyMcporterDir
-} from "./chunk-ECIVB7P4.js";
+} from "./chunk-FWP4RACK.js";
 
-// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/runtime/record-transport.js
+// node_modules/.pnpm/mcporter@0.13.0/node_modules/mcporter/dist/runtime/record-transport.js
 import fs from "node:fs/promises";
 import path from "node:path";
 var initializedRecordingPaths = /* @__PURE__ */ new Map();
@@ -14,24 +14,27 @@ var RecordTransport = class {
   onclose;
   onerror;
   onmessage;
-  sessionId;
   finishAuth;
   writes = Promise.resolve();
   closeRecorded = false;
   constructor(opts) {
     this.opts = opts;
-    this.sessionId = opts.inner.sessionId;
+    if ("stderr" in opts.inner && "pid" in opts.inner) {
+      Object.defineProperties(this, {
+        stderr: { get: () => opts.inner.stderr },
+        pid: { get: () => opts.inner.pid }
+      });
+    }
     const finishAuth = opts.inner.finishAuth;
     if (finishAuth) {
-      this.finishAuth = (authorizationCode) => finishAuth.call(opts.inner, authorizationCode);
+      this.finishAuth = (authorizationCode, iss) => finishAuth.call(opts.inner, authorizationCode, iss);
     }
   }
-  get pid() {
-    const pid = this.opts.inner.pid;
-    return typeof pid === "number" && pid > 0 ? pid : null;
+  get hasPerRequestStream() {
+    return this.opts.inner.hasPerRequestStream;
   }
-  get _process() {
-    return this.opts.inner._process ?? null;
+  get sessionId() {
+    return this.opts.inner.sessionId;
   }
   async start() {
     await initializeRecordingFile(this.opts.recordPath);
@@ -42,13 +45,12 @@ var RecordTransport = class {
     this.opts.inner.onerror = (error) => {
       this.onerror?.(error);
     };
-    this.opts.inner.onmessage = (message) => {
+    this.opts.inner.onmessage = (message, extra) => {
       void this.appendLine(this.withMeta(message, "recv"));
-      this.onmessage?.(message);
+      this.onmessage?.(message, extra);
     };
     await this.appendLifecycle("start");
     await this.opts.inner.start();
-    this.sessionId = this.opts.inner.sessionId;
   }
   async send(message, options) {
     await this.appendLine(this.withMeta(message, "send"));
@@ -62,6 +64,9 @@ var RecordTransport = class {
   setProtocolVersion(version) {
     this.opts.inner.setProtocolVersion?.(version);
   }
+  setSupportedProtocolVersions(versions) {
+    this.opts.inner.setSupportedProtocolVersions?.(versions);
+  }
   async appendLifecycle(event) {
     await this.appendLine(this.withMeta({
       jsonrpc: "2.0",

package/dist/mcp-chunks/chunk-ETWN4IIA.js

@@ -0,0 +1,57 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+import {
+  resolveEnvPlaceholders
+} from "./chunk-HAO6PL7Z.js";
+
+// node_modules/.pnpm/mcporter@0.13.0/node_modules/mcporter/dist/runtime/utils.js
+var ENV_PLACEHOLDER_PATTERN = /\$\{[A-Za-z_][A-Za-z0-9_]*(?::-[^}]*)?\}/;
+function resolveCommandArgument(value) {
+  if (!value) {
+    return value;
+  }
+  if (!value.includes("$")) {
+    return value;
+  }
+  const needsInterpolation = value.startsWith("$env:") || ENV_PLACEHOLDER_PATTERN.test(value);
+  if (!needsInterpolation) {
+    return value;
+  }
+  return resolveEnvPlaceholders(value);
+}
+function resolveCommandArguments(args) {
+  if (args.length === 0) {
+    return [];
+  }
+  return args.map((arg) => resolveCommandArgument(arg));
+}
+function normalizeTimeout(raw) {
+  if (raw == null) {
+    return void 0;
+  }
+  if (!Number.isFinite(raw)) {
+    return void 0;
+  }
+  const coerced = Math.trunc(raw);
+  return coerced > 0 ? coerced : void 0;
+}
+function raceWithTimeout(promise, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      reject(new Error("Timeout"));
+    }, timeoutMs);
+    promise.then((value) => {
+      clearTimeout(timer);
+      resolve(value);
+    }, (error) => {
+      clearTimeout(timer);
+      reject(error);
+    });
+  });
+}
+
+export {
+  resolveCommandArgument,
+  resolveCommandArguments,
+  normalizeTimeout,
+  raceWithTimeout
+};

package/dist/mcp-chunks/{chunk-YVZKMV5H.js → chunk-F3LL4EBL.js}

@@ -1,6 +1,6 @@
 import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
 
-// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/output-format.js
+// node_modules/.pnpm/mcporter@0.13.0/node_modules/mcporter/dist/cli/output-format.js
 function consumeOutputFormat(args, options = {}) {
   const allowed = options.allowed ?? ["auto", "text", "markdown", "json", "raw"];
   const defaultFormat = options.defaultFormat ?? "auto";

package/dist/mcp-chunks/chunk-FWP4RACK.js

@@ -0,0 +1,42 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+import {
+  expandHome
+} from "./chunk-HAO6PL7Z.js";
+
+// node_modules/.pnpm/mcporter@0.13.0/node_modules/mcporter/dist/paths.js
+import os from "node:os";
+import path from "node:path";
+var XDG_HOME_ENV = {
+  config: "XDG_CONFIG_HOME",
+  data: "XDG_DATA_HOME",
+  state: "XDG_STATE_HOME",
+  cache: "XDG_CACHE_HOME"
+};
+function legacyMcporterDir() {
+  return path.join(os.homedir(), ".mcporter");
+}
+function mcporterDir(kind) {
+  const raw = process.env[XDG_HOME_ENV[kind]];
+  if (raw && raw.trim().length > 0) {
+    const resolved = expandHome(raw.trim());
+    if (path.isAbsolute(resolved)) {
+      return path.join(resolved, "mcporter");
+    }
+  }
+  return legacyMcporterDir();
+}
+function mcporterConfigCandidates() {
+  const base = mcporterDir("config");
+  const candidates = [path.join(base, "mcporter.json"), path.join(base, "mcporter.jsonc")];
+  if (base !== legacyMcporterDir()) {
+    const legacy = legacyMcporterDir();
+    candidates.push(path.join(legacy, "mcporter.json"), path.join(legacy, "mcporter.jsonc"));
+  }
+  return candidates;
+}
+
+export {
+  legacyMcporterDir,
+  mcporterDir,
+  mcporterConfigCandidates
+};

package/dist/mcp-chunks/{chunk-6W5QFASN.js → chunk-GFYTST6N.js}

@@ -1,6 +1,6 @@
 import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
 
-// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/logging.js
+// node_modules/.pnpm/mcporter@0.13.0/node_modules/mcporter/dist/logging.js
 var LOG_LEVEL_ORDER = {
   debug: 10,
   info: 20,

package/dist/mcp-chunks/{chunk-TEUKFFQL.js → chunk-GIF7LOYU.js}

@@ -1,9 +1,9 @@
 import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
 import {
   normalizeHttpUrl
-} from "./chunk-M3TPODXI.js";
+} from "./chunk-UENXT3NE.js";
 
-// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/server-lookup.js
+// node_modules/.pnpm/mcporter@0.13.0/node_modules/mcporter/dist/cli/server-lookup.js
 function findServerByHttpUrl(definitions, urlString) {
   const normalizedTarget = normalizeHttpUrl(urlString);
   if (!normalizedTarget) {