@introspection-ai/recipes 0.13.0 → 0.14.1

package/dist/mcp-chunks/config-command-NLAGKID5.js

@@ -0,0 +1,1101 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+import {
+  CliUsageError
+} from "./chunk-BV56DXPW.js";
+import {
+  chooseClosestIdentifier,
+  renderIdentifierResolutionMessages
+} from "./chunk-BWHIA4PC.js";
+import {
+  boldText,
+  dimText,
+  extraDimText,
+  supportsAnsiColor
+} from "./chunk-N46NEFAF.js";
+import {
+  clearOAuthCaches
+} from "./chunk-YHQUTU6L.js";
+import "./chunk-TATVT5IT.js";
+import {
+  MCPORTER_VERSION
+} from "./chunk-4SQKWYFF.js";
+import {
+  loadRawConfig,
+  loadServerDefinitions,
+  pathsForImport,
+  readExternalEntries,
+  resolveConfigPath,
+  writeRawConfig
+} from "./chunk-2U4BSDC4.js";
+import "./chunk-P3PSC54P.js";
+import {
+  withFileLock
+} from "./chunk-2XL7MG7R.js";
+import "./chunk-WQJZMCJN.js";
+import {
+  expandHome,
+  mcporterConfigCandidates,
+  mcporterDir
+} from "./chunk-ECIVB7P4.js";
+import "./chunk-LS7PMWSR.js";
+import "./chunk-D3MRAZ6H.js";
+import "./chunk-LRKZP7DJ.js";
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/config/add.js
+import path2 from "node:path";
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/config/shared.js
+import fs from "node:fs/promises";
+import path from "node:path";
+var COLOR_ENABLED = () => Boolean(supportsAnsiColor && process.stdout.isTTY);
+function cloneConfig(config) {
+  return {
+    mcpServers: config.mcpServers ? { ...config.mcpServers } : {},
+    imports: config.imports ? [...config.imports] : void 0
+  };
+}
+async function loadOrCreateConfig(loadOptions) {
+  try {
+    const { config, path: configPath } = await loadRawConfig(loadOptions);
+    return { config, path: configPath };
+  } catch (error) {
+    if (isErrno(error, "ENOENT")) {
+      const rootDir = loadOptions.rootDir ?? process.cwd();
+      const resolved = resolveConfigPath(loadOptions.configPath, rootDir);
+      return { config: { mcpServers: {} }, path: resolved.path };
+    }
+    throw error;
+  }
+}
+async function resolveConfigLocations(loadOptions) {
+  const rootDir = loadOptions.rootDir ?? process.cwd();
+  const projectPath = path.resolve(rootDir, "config", "mcporter.json");
+  const projectExists = await pathExists(projectPath);
+  const systemCandidates = buildSystemConfigCandidates();
+  const systemResolved = await resolveFirstExisting(systemCandidates);
+  return {
+    projectPath,
+    projectExists,
+    systemPath: systemResolved.path,
+    systemExists: systemResolved.exists
+  };
+}
+function logConfigLocations(summary, options) {
+  const shouldAddNewline = options?.leadingNewline ?? true;
+  if (shouldAddNewline) {
+    console.log("");
+  }
+  console.log(`Project config: ${formatPath(summary.projectPath, summary.projectExists)}`);
+  console.log(`System config: ${formatPath(summary.systemPath, summary.systemExists)}`);
+}
+function findServerNameWithFuzzyMatch(name, candidates, logger = console.log) {
+  if (candidates.includes(name)) {
+    return name;
+  }
+  const resolution = chooseClosestIdentifier(name, candidates);
+  if (!resolution) {
+    return null;
+  }
+  const messages = renderIdentifierResolutionMessages({
+    entity: "server",
+    attempted: name,
+    resolution
+  });
+  if (messages.auto && logger) {
+    logger(dimText(messages.auto));
+  }
+  if (resolution.kind === "auto") {
+    return resolution.value;
+  }
+  if (messages.suggest && logger) {
+    logger(dimText(messages.suggest));
+  }
+  return null;
+}
+function resolveServerDefinition(name, servers, logger = console.log) {
+  const direct = servers.find((server) => server.name === name);
+  if (direct) {
+    return direct;
+  }
+  const resolution = chooseClosestIdentifier(name, servers.map((server) => server.name));
+  if (!resolution) {
+    throw new CliUsageError(`[mcporter] Unknown server '${name}'.`);
+  }
+  const messages = renderIdentifierResolutionMessages({
+    entity: "server",
+    attempted: name,
+    resolution
+  });
+  if (messages.auto && logger) {
+    logger(dimText(messages.auto));
+  }
+  if (resolution.kind === "auto") {
+    const match = servers.find((server) => server.name === resolution.value);
+    if (match) {
+      return match;
+    }
+  }
+  if (messages.suggest && logger) {
+    logger(dimText(messages.suggest));
+  }
+  throw new CliUsageError(`[mcporter] Unknown server '${name}'.`);
+}
+function buildSystemConfigCandidates() {
+  return mcporterConfigCandidates();
+}
+async function resolveFirstExisting(pathsToCheck) {
+  for (const candidate of pathsToCheck) {
+    if (await pathExists(candidate)) {
+      return { path: candidate, exists: true };
+    }
+  }
+  return { path: pathsToCheck[0] ?? "", exists: false };
+}
+async function pathExists(targetPath) {
+  try {
+    await fs.access(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function formatPath(targetPath, exists) {
+  return exists ? targetPath : `${targetPath} (missing)`;
+}
+function isErrno(error, code) {
+  return Boolean(error && typeof error === "object" && error.code === code);
+}
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/config/add.js
+async function handleAddCommand(options, args) {
+  const name = args.shift();
+  if (!name) {
+    throw new CliUsageError("Usage: mcporter config add <name> [target]");
+  }
+  let positionalTarget;
+  if (args[0] && !args[0].startsWith("--")) {
+    positionalTarget = args.shift();
+  }
+  const flags = extractAddFlags(args);
+  const targetPath = resolveWriteTarget(flags, options.loadOptions, options.loadOptions.rootDir ?? process.cwd());
+  const effectiveLoadOptions = { ...options.loadOptions, configPath: targetPath };
+  const baseEntry = await resolveBaseEntry(flags.copyFrom, options.loadOptions);
+  const entry = baseEntry ? { ...baseEntry } : {};
+  applyTargetToEntry(entry, positionalTarget, flags);
+  applyFlagsToEntry(entry, flags);
+  validateTransportChoice(entry, flags.transport);
+  const hasHttpTarget = Boolean(entry.baseUrl) || Boolean(entry.base_url) || Boolean(entry.url) || Boolean(entry.serverUrl) || Boolean(entry.server_url);
+  const hasCommandTarget = Boolean(entry.command ?? entry.executable);
+  if (flags.args.length > 0 && !hasCommandTarget) {
+    throw new CliUsageError("--arg/--args requires a stdio command (use --command, --stdio, or provide a positional target).");
+  }
+  if (!hasHttpTarget && !hasCommandTarget) {
+    throw new CliUsageError("Server definitions require either a --url/target or a stdio command.");
+  }
+  if (flags.dryRun) {
+    console.log(JSON.stringify({ [name]: entry }, null, 2));
+    console.log("(dry-run) No changes were written.");
+    return;
+  }
+  let configPath = targetPath;
+  await withFileLock(targetPath, async () => {
+    const loaded = await loadOrCreateConfig(effectiveLoadOptions);
+    configPath = loaded.path;
+    const nextConfig = cloneConfig(loaded.config);
+    if (!nextConfig.mcpServers) {
+      nextConfig.mcpServers = {};
+    }
+    nextConfig.mcpServers[name] = entry;
+    await writeRawConfig(configPath, nextConfig);
+  });
+  console.log(`Added '${name}' to ${configPath}`);
+}
+function resolveWriteTarget(flags, loadOptions, rootDir) {
+  if (flags.persistPath) {
+    return path2.resolve(expandHome(flags.persistPath));
+  }
+  if (flags.scope === "home") {
+    return path2.join(mcporterDir("config"), "mcporter.json");
+  }
+  if (flags.scope === "project") {
+    return path2.resolve(rootDir, "config", "mcporter.json");
+  }
+  if (loadOptions.configPath) {
+    return path2.resolve(expandHome(loadOptions.configPath));
+  }
+  return path2.resolve(rootDir, "config", "mcporter.json");
+}
+function extractAddFlags(args) {
+  const flags = { args: [], env: {}, headers: {} };
+  let index = 0;
+  while (index < args.length) {
+    const token = args[index];
+    switch (token) {
+      case "--transport":
+        flags.transport = parseTransport(requireValue(args, index, token));
+        args.splice(index, 2);
+        continue;
+      case "--url":
+        flags.url = requireValue(args, index, token);
+        args.splice(index, 2);
+        continue;
+      case "--command":
+        flags.command = requireValue(args, index, token);
+        args.splice(index, 2);
+        continue;
+      case "--stdio":
+        flags.stdio = requireValue(args, index, token);
+        args.splice(index, 2);
+        continue;
+      case "--arg":
+      case "--args":
+        flags.args.push(requireValue(args, index, token));
+        args.splice(index, 2);
+        continue;
+      case "--description":
+        flags.description = requireValue(args, index, token);
+        args.splice(index, 2);
+        continue;
+      case "--env":
+        parseKeyValue(requireValue(args, index, token), flags.env, "--env");
+        args.splice(index, 2);
+        continue;
+      case "--header":
+        parseKeyValue(requireValue(args, index, token), flags.headers, "--header");
+        args.splice(index, 2);
+        continue;
+      case "--token-cache-dir":
+        flags.tokenCacheDir = requireValue(args, index, token);
+        args.splice(index, 2);
+        continue;
+      case "--client-name":
+        flags.clientName = requireValue(args, index, token);
+        args.splice(index, 2);
+        continue;
+      case "--oauth-client-id":
+        flags.oauthClientId = requireValue(args, index, token);
+        args.splice(index, 2);
+        continue;
+      case "--oauth-client-secret-env":
+        flags.oauthClientSecretEnv = requireValue(args, index, token);
+        args.splice(index, 2);
+        continue;
+      case "--oauth-token-endpoint-auth-method":
+        flags.oauthTokenEndpointAuthMethod = requireValue(args, index, token);
+        args.splice(index, 2);
+        continue;
+      case "--oauth-redirect-url":
+        flags.oauthRedirectUrl = requireValue(args, index, token);
+        args.splice(index, 2);
+        continue;
+      case "--auth":
+        flags.auth = requireValue(args, index, token);
+        args.splice(index, 2);
+        continue;
+      case "--copy-from":
+        flags.copyFrom = requireValue(args, index, token);
+        args.splice(index, 2);
+        continue;
+      case "--persist":
+        flags.persistPath = requireValue(args, index, token);
+        args.splice(index, 2);
+        continue;
+      case "--scope": {
+        const scopeValue = requireValue(args, index, token);
+        if (scopeValue !== "home" && scopeValue !== "project") {
+          throw new CliUsageError('--scope must be either "home" or "project".');
+        }
+        flags.scope = scopeValue;
+        args.splice(index, 2);
+        continue;
+      }
+      case "--dry-run":
+        flags.dryRun = true;
+        args.splice(index, 1);
+        continue;
+      case "--":
+        args.splice(index, 1);
+        while (index < args.length) {
+          const value = args[index];
+          if (value !== void 0) {
+            flags.args.push(value);
+          }
+          args.splice(index, 1);
+        }
+        continue;
+      default:
+        index += 1;
+        break;
+    }
+  }
+  return flags;
+}
+function parseTransport(value) {
+  if (value !== "http" && value !== "sse" && value !== "stdio") {
+    throw new CliUsageError("--transport must be one of 'http', 'sse', or 'stdio'.");
+  }
+  return value;
+}
+function parseKeyValue(input, target, flagName) {
+  if (!input?.includes("=")) {
+    throw new CliUsageError(`${flagName} requires KEY=value.`);
+  }
+  const [key, ...rest] = input.split("=");
+  if (!key) {
+    throw new CliUsageError(`${flagName} requires KEY=value.`);
+  }
+  target[key] = rest.join("=");
+}
+function requireValue(args, index, flagName) {
+  const value = args[index + 1];
+  if (!value) {
+    throw new CliUsageError(`Flag '${flagName}' requires a value.`);
+  }
+  return value;
+}
+async function resolveBaseEntry(copyFrom, options) {
+  if (!copyFrom) {
+    return null;
+  }
+  const [kind, ...rest] = copyFrom.split(":");
+  const name = rest.join(":");
+  if (!kind || !name) {
+    throw new CliUsageError("--copy-from requires the format '<import>:<name>'.");
+  }
+  const rootDir = options.rootDir ?? process.cwd();
+  const paths = pathsForImport(kind, rootDir);
+  for (const candidate of paths) {
+    const resolved = expandHome(candidate);
+    const entries = await readExternalEntries(resolved, { projectRoot: rootDir, importKind: kind });
+    if (!entries) {
+      continue;
+    }
+    const entry = entries.get(name);
+    if (entry) {
+      return structuredClone(entry);
+    }
+  }
+  throw new CliUsageError(`Unable to find '${name}' in import '${kind}'.`);
+}
+function applyTargetToEntry(entry, positionalTarget, flags) {
+  if (flags.url) {
+    entry.baseUrl = flags.url;
+    return;
+  }
+  if (flags.command) {
+    entry.command = flags.command;
+  }
+  if (flags.stdio) {
+    entry.command = flags.stdio;
+  }
+  if (positionalTarget) {
+    if (looksLikeHttp(positionalTarget)) {
+      entry.baseUrl = positionalTarget;
+    } else {
+      entry.command = positionalTarget;
+    }
+  }
+}
+function applyFlagsToEntry(entry, flags) {
+  if (flags.args.length > 0) {
+    entry.args = flags.args;
+  }
+  if (flags.description) {
+    entry.description = flags.description;
+  }
+  if (Object.keys(flags.env).length > 0) {
+    entry.env = entry.env ? { ...entry.env, ...flags.env } : { ...flags.env };
+  }
+  if (Object.keys(flags.headers).length > 0) {
+    entry.headers = entry.headers ? { ...entry.headers, ...flags.headers } : { ...flags.headers };
+  }
+  if (flags.tokenCacheDir) {
+    entry.tokenCacheDir = flags.tokenCacheDir;
+  }
+  if (flags.clientName) {
+    entry.clientName = flags.clientName;
+  }
+  if (flags.oauthClientId) {
+    entry.oauthClientId = flags.oauthClientId;
+  }
+  if (flags.oauthClientSecretEnv) {
+    entry.oauthClientSecretEnv = flags.oauthClientSecretEnv;
+  }
+  if (flags.oauthTokenEndpointAuthMethod) {
+    entry.oauthTokenEndpointAuthMethod = flags.oauthTokenEndpointAuthMethod;
+  }
+  if (flags.oauthRedirectUrl) {
+    entry.oauthRedirectUrl = flags.oauthRedirectUrl;
+  }
+  if (flags.auth) {
+    entry.auth = flags.auth;
+  }
+}
+function validateTransportChoice(entry, transport) {
+  if (!transport) {
+    return;
+  }
+  const isHttp = Boolean(entry.baseUrl ?? entry.url ?? entry.serverUrl);
+  const isStdio = Boolean(entry.command ?? entry.args);
+  if (transport === "stdio" && !isStdio) {
+    throw new CliUsageError("Transport 'stdio' requires a stdio command.");
+  }
+  if ((transport === "http" || transport === "sse") && !isHttp) {
+    throw new CliUsageError(`Transport '${transport}' requires a URL target.`);
+  }
+}
+function looksLikeHttp(value) {
+  return value.startsWith("http://") || value.startsWith("https://");
+}
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/config/auth.js
+async function handleLoginCommand(options, args) {
+  if (args.length === 0) {
+    throw new CliUsageError("Usage: mcporter config login <name|url>");
+  }
+  await options.invokeAuth([...args]);
+}
+async function handleLogoutCommand(options, args) {
+  const name = args.shift();
+  if (!name) {
+    throw new CliUsageError("Usage: mcporter config logout <name>");
+  }
+  const servers = await loadServerDefinitions(options.loadOptions);
+  const target = resolveServerDefinition(name, servers);
+  await clearOAuthCaches(target);
+  console.log(`Cleared cached credentials for '${target.name}'`);
+}
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/config/doctor.js
+import path3 from "node:path";
+async function handleDoctorCommand(options, _args) {
+  console.log(`MCPorter ${MCPORTER_VERSION}`);
+  const configLocations = await resolveConfigLocations(options.loadOptions);
+  logConfigLocations(configLocations, { leadingNewline: false });
+  console.log("");
+  const servers = await loadServerDefinitions(options.loadOptions);
+  const issues = [];
+  for (const server of servers) {
+    if (server.command.kind === "stdio" && !path3.isAbsolute(server.command.cwd)) {
+      issues.push(`Server '${server.name}' has a non-absolute working directory.`);
+    }
+  }
+  if (issues.length === 0) {
+    console.log("Config looks good.");
+    return;
+  }
+  console.log("Config issues detected:");
+  for (const issue of issues) {
+    console.log(`  - ${issue}`);
+  }
+}
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/config/render.js
+function serializeDefinition(definition) {
+  const origin = definition.source ?? { kind: "local", path: "" };
+  if (definition.command.kind === "http") {
+    return {
+      name: definition.name,
+      description: definition.description,
+      source: origin,
+      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,
+      env: definition.env,
+      transport: "http",
+      baseUrl: definition.command.url.href,
+      headers: definition.command.headers
+    };
+  }
+  return {
+    name: definition.name,
+    description: definition.description,
+    source: origin,
+    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,
+    env: definition.env,
+    transport: "stdio",
+    command: definition.command.command,
+    args: definition.command.args,
+    cwd: definition.command.cwd
+  };
+}
+function printServerSummary(definition) {
+  const colorize = COLOR_ENABLED();
+  const origin = definition.source;
+  const header = colorize ? boldText(definition.name) : definition.name;
+  const label = (text) => colorize ? dimText(text) : text;
+  console.log(header);
+  if (origin) {
+    console.log(`  ${label("Source")}: ${origin.kind}${origin.path ? ` (${origin.path})` : ""}`);
+  } else {
+    console.log(`  ${label("Source")}: local`);
+  }
+  if (definition.command.kind === "http") {
+    console.log(`  ${label("Transport")}: http (${definition.command.url.href})`);
+  } else {
+    const renderedArgs = definition.command.args.length > 0 ? ` ${definition.command.args.join(" ")}` : "";
+    console.log(`  ${label("Transport")}: stdio (${definition.command.command}${renderedArgs})`);
+    console.log(`  ${label("CWD")}: ${definition.command.cwd}`);
+  }
+  if (definition.description) {
+    console.log(`  ${label("Description")}: ${definition.description}`);
+  }
+  if (definition.auth) {
+    console.log(`  ${label("Auth")}: ${definition.auth}`);
+  }
+  if (definition.allowedTools !== void 0) {
+    const rendered = definition.allowedTools.length > 0 ? definition.allowedTools.join(", ") : "<none>";
+    console.log(`  ${label("Allowed tools")}: ${rendered}`);
+  }
+  if (definition.blockedTools !== void 0) {
+    const rendered = definition.blockedTools.length > 0 ? definition.blockedTools.join(", ") : "<none>";
+    console.log(`  ${label("Blocked tools")}: ${rendered}`);
+  }
+}
+function printImportSummary(importServers) {
+  if (importServers.length === 0) {
+    return;
+  }
+  const colorize = COLOR_ENABLED();
+  const grouped = /* @__PURE__ */ new Map();
+  for (const server of importServers) {
+    const sourcePath = server.source?.path ?? "<unknown>";
+    const list = grouped.get(sourcePath) ?? [];
+    list.push(server.name);
+    grouped.set(sourcePath, list);
+  }
+  console.log("");
+  const header = colorize ? boldText("Other sources available via --source import") : "Other sources available via --source import";
+  console.log(header);
+  for (const [path5, names] of grouped) {
+    names.sort();
+    const sample = names.slice(0, 3).join(", ");
+    const suffix = names.length > 3 ? ", \u2026" : "";
+    const countLabel = `${names.length} server${names.length === 1 ? "" : "s"}`;
+    const pathLabel = colorize ? dimText(path5) : path5;
+    console.log(`  ${pathLabel} \u2014 ${countLabel} (${sample}${suffix})`);
+  }
+  const guidance = "Use `mcporter config import <kind>` to copy them locally.";
+  console.log(colorize ? dimText(guidance) : guidance);
+}
+function printConfigUsageExamples() {
+  return [
+    "pnpm mcporter config list --json",
+    "pnpm mcporter config add linear https://mcp.linear.app/mcp",
+    "pnpm mcporter config import cursor --copy"
+  ];
+}
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/config/get.js
+async function handleGetCommand(options, args) {
+  const flags = extractGetFlags(args);
+  const name = args.shift();
+  if (!name) {
+    throw new CliUsageError("Usage: mcporter config get <name>");
+  }
+  const servers = await loadServerDefinitions(options.loadOptions);
+  const target = resolveServerDefinition(name, servers);
+  if (flags.format === "json") {
+    console.log(JSON.stringify(serializeDefinition(target), null, 2));
+    return;
+  }
+  printServerSummary(target);
+  if (target.command.kind === "http" && target.command.headers && Object.keys(target.command.headers).length > 0) {
+    console.log("  Headers:");
+    for (const [key, value] of Object.entries(target.command.headers)) {
+      console.log(`    ${key}: ${value}`);
+    }
+  }
+  if (target.env && Object.keys(target.env).length > 0) {
+    console.log("  Env:");
+    for (const [key, value] of Object.entries(target.env)) {
+      console.log(`    ${key}=${value}`);
+    }
+  }
+}
+function extractGetFlags(args) {
+  let format = "text";
+  let index = 0;
+  while (index < args.length) {
+    const token = args[index];
+    if (token === "--json") {
+      format = "json";
+      args.splice(index, 1);
+      continue;
+    }
+    index += 1;
+  }
+  return { format };
+}
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/config/help.js
+var CONFIG_HELP_ENTRIES = {
+  list: {
+    name: "list [options] [filter]",
+    summary: "Show merged servers",
+    usage: "mcporter config list [options] [filter]",
+    description: "Lists configured servers. Defaults to local entries, but you can view imports and emit JSON.",
+    flags: [
+      { flag: "--json", description: "Print JSON payloads instead of ANSI text." },
+      { flag: "--source <local|import>", description: "Filter to local definitions or imported entries only." },
+      { flag: "filter (positional)", description: "Substring match applied to server names." }
+    ],
+    examples: ["pnpm mcporter config list", "pnpm mcporter config list --json --source import cursor"]
+  },
+  get: {
+    name: "get <name> [--json]",
+    summary: "Inspect a single server",
+    usage: "mcporter config get <name> [--json]",
+    description: "Shows one server definition, including transport, headers, and env overrides.",
+    flags: [{ flag: "--json", description: "Emit the server entry as JSON." }],
+    examples: ["pnpm mcporter config get linear", "pnpm mcporter config get claude --json"]
+  },
+  add: {
+    name: "add [options] <name> [target]",
+    summary: "Persist a server definition",
+    usage: "mcporter config add [options] <name> [target]",
+    description: "Adds HTTP or stdio servers to the local config. Accepts URLs, commands, env vars, and OAuth metadata.",
+    flags: [
+      { flag: "--url <https://host>", description: "Set the HTTP/S base URL (implies http transport)." },
+      { flag: "--command <binary>", description: "Set the stdio executable (implies stdio transport)." },
+      { flag: "--stdio <binary>", description: "Alias for --command." },
+      { flag: "--transport <http|sse|stdio>", description: "Force a specific transport (validates target)." },
+      { flag: "--arg <value>", description: "Pass through additional stdio arguments (repeatable)." },
+      { flag: "--description <text>", description: "Set a human-friendly summary." },
+      { flag: "--env KEY=value", description: "Attach environment variables (repeatable)." },
+      { flag: "--header KEY=value", description: "Attach HTTP headers (repeatable)." },
+      { flag: "--token-cache-dir <path>", description: "Override where OAuth tokens are persisted." },
+      { flag: "--client-name <name>", description: "Customize the OAuth client identifier." },
+      { flag: "--oauth-client-id <id>", description: "Use a pre-registered OAuth client id." },
+      { flag: "--oauth-client-secret-env <env>", description: "Read the OAuth client secret from an env var." },
+      {
+        flag: "--oauth-token-endpoint-auth-method <method>",
+        description: "Set token auth, e.g. client_secret_post."
+      },
+      { flag: "--oauth-redirect-url <url>", description: "Set a custom OAuth redirect URL." },
+      { flag: "--auth <strategy>", description: "Force the auth type (e.g., oauth)." },
+      { flag: "--copy-from <import:name>", description: "Start with an imported definition by name." },
+      { flag: "--persist <config-path>", description: "Write to an alternate mcporter.json path." },
+      {
+        flag: "--scope <home|project>",
+        description: "Choose whether to write to the home or project config (default: project)."
+      },
+      { flag: "--dry-run", description: "Print the would-be entry without writing to disk." },
+      { flag: "--", description: "Forward every subsequent token as a stdio arg." }
+    ],
+    examples: [
+      "pnpm mcporter config add linear https://mcp.linear.app/mcp",
+      'pnpm mcporter config add cursor --command "npx -y cursor" --arg --stdio'
+    ]
+  },
+  remove: {
+    name: "remove <name>",
+    summary: "Delete a local entry",
+    usage: "mcporter config remove <name>",
+    description: "Removes a server definition from the active mcporter.json file.",
+    examples: ["pnpm mcporter config remove linear"]
+  },
+  import: {
+    name: "import <kind> [options]",
+    summary: "Inspect or copy imported servers",
+    usage: "mcporter config import <kind> [options]",
+    description: "Shows entries from Cursor, Claude, Codex, and other supported imports. Optionally copies them locally.",
+    flags: [
+      { flag: "--path <file>", description: "Manually point at a config file path." },
+      { flag: "--filter <substring>", description: "Match server names by substring before listing/copying." },
+      { flag: "--copy", description: "Write the filtered entries into the local config." },
+      { flag: "--json", description: "Emit JSON instead of plain text listings." }
+    ],
+    examples: ["pnpm mcporter config import cursor --copy", "pnpm mcporter config import claude --filter notion"]
+  },
+  login: {
+    name: "login <name|url> [options]",
+    summary: "Run the OAuth/auth flow",
+    usage: "mcporter config login <name|url> [options]",
+    description: "Delegates to `mcporter auth`, so you can pass ephemeral flags like --http-url/--stdio/--reset and browser-suppression flags for headless OAuth.",
+    flags: [
+      { flag: "--no-browser", description: "Print the OAuth authorization URL without launching a browser." },
+      { flag: "--browser none", description: "Alias for --no-browser." },
+      {
+        flag: "MCPORTER_OAUTH_NO_BROWSER=1|true|yes",
+        description: "Environment default for browser-suppressed OAuth."
+      }
+    ],
+    examples: [
+      "pnpm mcporter config login linear",
+      "pnpm mcporter config login linear --no-browser",
+      "pnpm mcporter config login https://example.com/mcp --reset"
+    ]
+  },
+  logout: {
+    name: "logout <name>",
+    summary: "Clear cached credentials",
+    usage: "mcporter config logout <name>",
+    description: "Deletes the token cache directory for an OAuth-enabled server.",
+    examples: ["pnpm mcporter config logout linear"]
+  },
+  doctor: {
+    name: "doctor",
+    summary: "Validate config files",
+    usage: "mcporter config doctor",
+    description: "Validates config files, warns about missing token caches, and prints config locations.",
+    examples: ["pnpm mcporter config doctor"]
+  }
+};
+var CONFIG_HELP_ORDER = [
+  "list",
+  "get",
+  "add",
+  "remove",
+  "import",
+  "login",
+  "logout",
+  "doctor"
+];
+function isHelpToken(token) {
+  return token === "--help" || token === "-h";
+}
+function consumeInlineHelpTokens(args) {
+  let found = false;
+  for (let index = args.length - 1; index >= 0; index -= 1) {
+    const token = args[index];
+    if (token && isHelpToken(token)) {
+      args.splice(index, 1);
+      found = true;
+    }
+  }
+  return found;
+}
+function printConfigHelp(subcommand) {
+  const colorize = COLOR_ENABLED();
+  if (!subcommand) {
+    printConfigOverview(colorize);
+    return;
+  }
+  const resolved = resolveHelpSubcommand(subcommand);
+  if (!resolved) {
+    console.log(`Unknown config subcommand '${subcommand}'. Available commands: ${CONFIG_HELP_ORDER.join(", ")}.`);
+    return;
+  }
+  printSubcommandHelp(resolved, colorize);
+}
+function resolveHelpSubcommand(token) {
+  if (!token) {
+    return void 0;
+  }
+  const normalized = token.toLowerCase();
+  return normalized in CONFIG_HELP_ENTRIES ? normalized : void 0;
+}
+function printConfigOverview(colorize) {
+  const title = colorize ? boldText("mcporter config") : "mcporter config";
+  const subtitle = colorize ? dimText("Manage configured MCP servers, imports, and ad-hoc discoveries.") : "Manage configured MCP servers, imports, and ad-hoc discoveries.";
+  const commandsHeader = colorize ? boldText("Commands") : "Commands";
+  const examplesHeader = colorize ? boldText("Examples") : "Examples";
+  const lines = [title, subtitle, "", commandsHeader];
+  const maxName = Math.max(...CONFIG_HELP_ORDER.map((key) => CONFIG_HELP_ENTRIES[key].name.length));
+  for (const key of CONFIG_HELP_ORDER) {
+    const entry = CONFIG_HELP_ENTRIES[key];
+    const padded = entry.name.padEnd(maxName);
+    const renderedName = colorize ? boldText(padded) : padded;
+    const renderedDesc = colorize ? dimText(entry.summary) : entry.summary;
+    lines.push(`  ${renderedName}  ${renderedDesc}`);
+  }
+  lines.push("", examplesHeader);
+  for (const example of printConfigUsageExamples()) {
+    lines.push(`  ${colorize ? extraDimText(example) : example}`);
+  }
+  const pointer = "Run 'mcporter config <command> --help' for detailed flag info.";
+  lines.push("", colorize ? extraDimText(pointer) : pointer);
+  console.log(lines.join("\n"));
+}
+function printSubcommandHelp(subcommand, colorize) {
+  const entry = CONFIG_HELP_ENTRIES[subcommand];
+  const title = colorize ? boldText(`mcporter config ${subcommand}`) : `mcporter config ${subcommand}`;
+  const description = colorize ? dimText(entry.description) : entry.description;
+  const usageHeader = colorize ? boldText("Usage") : "Usage";
+  const lines = [title, description, "", usageHeader, `  ${entry.usage}`];
+  if (entry.flags && entry.flags.length > 0) {
+    const flagsHeader = colorize ? boldText("Flags") : "Flags";
+    const maxFlag = Math.max(...entry.flags.map((flag) => flag.flag.length));
+    lines.push("", flagsHeader);
+    for (const flag of entry.flags) {
+      const padded = flag.flag.padEnd(maxFlag);
+      const renderedFlag = colorize ? boldText(padded) : padded;
+      const renderedDesc = colorize ? dimText(flag.description) : flag.description;
+      lines.push(`  ${renderedFlag}  ${renderedDesc}`);
+    }
+  }
+  if (entry.examples && entry.examples.length > 0) {
+    const examplesHeader = colorize ? boldText("Examples") : "Examples";
+    lines.push("", examplesHeader);
+    for (const example of entry.examples) {
+      lines.push(`  ${colorize ? extraDimText(example) : example}`);
+    }
+  }
+  console.log(lines.join("\n"));
+}
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/config/import.js
+import path4 from "node:path";
+async function handleImportCommand(options, args) {
+  const kind = args.shift();
+  if (!kind) {
+    throw new CliUsageError("Usage: mcporter config import <kind>");
+  }
+  const flags = extractImportFlags(args);
+  const rootDir = options.loadOptions.rootDir ?? process.cwd();
+  const paths = flags.path ? [path4.resolve(expandHome(flags.path))] : pathsForImport(kind, rootDir);
+  const entries = [];
+  const seenNames = /* @__PURE__ */ new Set();
+  for (const candidate of paths) {
+    const resolved = expandHome(candidate);
+    const map = await readExternalEntries(resolved, { projectRoot: rootDir, importKind: kind });
+    if (!map) {
+      continue;
+    }
+    for (const [name, entry] of map) {
+      if (flags.filter && !name.includes(flags.filter)) {
+        continue;
+      }
+      if (seenNames.has(name)) {
+        continue;
+      }
+      seenNames.add(name);
+      entries.push({ name, entry, source: resolved });
+    }
+  }
+  if (entries.length === 0) {
+    console.log("No entries found.");
+    return;
+  }
+  if (flags.format === "json") {
+    console.log(JSON.stringify({ entries }, null, 2));
+  } else {
+    for (const item of entries) {
+      console.log(`${item.name} (${item.source})`);
+    }
+  }
+  if (flags.copy) {
+    const lockPath = resolveImportCopyTarget(options.loadOptions.configPath, rootDir);
+    let configPath = lockPath;
+    await withFileLock(lockPath, async () => {
+      const loaded = await loadOrCreateConfig({ ...options.loadOptions, configPath: lockPath });
+      configPath = loaded.path;
+      const nextConfig = cloneConfig(loaded.config);
+      if (!nextConfig.mcpServers) {
+        nextConfig.mcpServers = {};
+      }
+      for (const item of entries) {
+        nextConfig.mcpServers[item.name] = structuredClone(item.entry);
+      }
+      await writeRawConfig(configPath, nextConfig);
+    });
+    console.log(`Copied ${entries.length} entr${entries.length === 1 ? "y" : "ies"} to ${configPath}`);
+  }
+}
+function resolveImportCopyTarget(configPath, rootDir) {
+  if (configPath || process.env.MCPORTER_CONFIG) {
+    return resolveConfigPath(configPath, rootDir).path;
+  }
+  return path4.resolve(rootDir, "config", "mcporter.json");
+}
+function extractImportFlags(args) {
+  const flags = { format: "text" };
+  let index = 0;
+  while (index < args.length) {
+    const token = args[index];
+    switch (token) {
+      case "--path":
+        flags.path = args[index + 1];
+        args.splice(index, 2);
+        continue;
+      case "--filter":
+        flags.filter = args[index + 1];
+        args.splice(index, 2);
+        continue;
+      case "--copy":
+        flags.copy = true;
+        args.splice(index, 1);
+        continue;
+      case "--json":
+        flags.format = "json";
+        args.splice(index, 1);
+        continue;
+      default:
+        index += 1;
+        break;
+    }
+  }
+  return flags;
+}
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/config/list.js
+async function handleListCommand(options, args) {
+  const flags = extractListFlags(args);
+  const filter = args.shift();
+  const servers = await loadServerDefinitions(options.loadOptions);
+  let filtered = servers;
+  if (flags.source) {
+    filtered = filtered.filter((server) => (server.source?.kind ?? "local") === flags.source);
+  }
+  if (filter) {
+    filtered = filtered.filter((server) => filterMatches(filter, server));
+  }
+  if (flags.format === "json") {
+    const payload = filtered.map((server) => serializeDefinition(server));
+    console.log(JSON.stringify({ servers: payload }, null, 2));
+    return;
+  }
+  const colorize = COLOR_ENABLED();
+  if (filtered.length === 0) {
+    console.log(colorize ? dimText("No local servers match the provided filters.") : "No local servers match the provided filters.");
+  } else {
+    for (const server of filtered) {
+      printServerSummary(server);
+    }
+  }
+  if ((!flags.source || flags.source === "local") && flags.format === "text") {
+    printImportSummary(servers.filter((server) => server.source?.kind === "import"));
+  }
+  if (flags.format === "text") {
+    const summary = await resolveConfigLocations(options.loadOptions);
+    logConfigLocations(summary, { leadingNewline: true });
+  }
+}
+function extractListFlags(args) {
+  const flags = { format: "text", source: "local" };
+  let index = 0;
+  while (index < args.length) {
+    const token = args[index];
+    if (token === "--json") {
+      flags.format = "json";
+      args.splice(index, 1);
+      continue;
+    }
+    if (token === "--source") {
+      const value = args[index + 1];
+      if (value !== "local" && value !== "import") {
+        throw new CliUsageError("--source must be either 'local' or 'import'.");
+      }
+      flags.source = value;
+      args.splice(index, 2);
+      continue;
+    }
+    index += 1;
+  }
+  return flags;
+}
+function filterMatches(filter, server) {
+  if (filter.startsWith("source:")) {
+    const origin = server.source?.kind ?? "local";
+    return `source:${origin}` === filter;
+  }
+  return server.name.includes(filter);
+}
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/config/remove.js
+async function handleRemoveCommand(options, args) {
+  const name = args.shift();
+  if (!name) {
+    throw new CliUsageError("Usage: mcporter config remove <name>");
+  }
+  const rootDir = options.loadOptions.rootDir ?? process.cwd();
+  const lockPath = resolveConfigPath(options.loadOptions.configPath, rootDir).path;
+  let configPath = lockPath;
+  let targetName = name;
+  await withFileLock(lockPath, async () => {
+    const loaded = await loadOrCreateConfig({ ...options.loadOptions, configPath: lockPath });
+    configPath = loaded.path;
+    const matched = findServerNameWithFuzzyMatch(name, Object.keys(loaded.config.mcpServers ?? {}));
+    if (!matched) {
+      throw new CliUsageError(`Server '${name}' does not exist in ${configPath}.`);
+    }
+    targetName = matched;
+    const nextConfig = cloneConfig(loaded.config);
+    delete nextConfig.mcpServers[targetName];
+    await writeRawConfig(configPath, nextConfig);
+  });
+  console.log(`Removed '${targetName}' from ${configPath}`);
+}
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/config-command.js
+async function handleConfigCli(options, args) {
+  const initialToken = args[0];
+  if (args.length === 0 || initialToken && isHelpToken(initialToken)) {
+    printConfigHelp();
+    return;
+  }
+  const subcommand = args.shift();
+  if (!subcommand) {
+    printConfigHelp();
+    return;
+  }
+  if (subcommand === "help") {
+    const target = args[0];
+    if (!target || isHelpToken(target)) {
+      printConfigHelp();
+    } else {
+      printConfigHelp(target);
+    }
+    return;
+  }
+  if (consumeInlineHelpTokens(args)) {
+    printConfigHelp(subcommand);
+    return;
+  }
+  switch (subcommand) {
+    case "list":
+      await handleListCommand(options, args);
+      return;
+    case "get":
+      await handleGetCommand(options, args);
+      return;
+    case "add":
+      await handleAddCommand(options, args);
+      return;
+    case "remove":
+      await handleRemoveCommand(options, args);
+      return;
+    case "import":
+      await handleImportCommand(options, args);
+      return;
+    case "login":
+      await handleLoginCommand(options, args);
+      return;
+    case "logout":
+      await handleLogoutCommand(options, args);
+      return;
+    case "doctor":
+      await handleDoctorCommand(options, args);
+      return;
+    default:
+      throw new CliUsageError(`Unknown config subcommand '${subcommand}'. Run 'mcporter config --help'.`);
+  }
+}
+var __configCommandInternals = {
+  resolveWriteTarget
+};
+export {
+  __configCommandInternals,
+  handleConfigCli
+};