@introspection-ai/recipes 0.13.0 → 0.14.1

package/dist/mcp-chunks/generate-cli-runner-6CAZZA3P.js

@@ -0,0 +1,1426 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+import {
+  extractGeneratorFlags,
+  markExecutable,
+  readPackageMetadata,
+  safeCopyFile,
+  stableJsonStringify,
+  writeTemplate
+} from "./chunk-DHBE7UBH.js";
+import {
+  buildGenerateCliCommand,
+  readCliMetadata,
+  resolveGenerateRequestFromArtifact,
+  serializeDefinition
+} from "./chunk-LKIBAYKU.js";
+import {
+  expectValue
+} from "./chunk-XQK2JSW4.js";
+import "./chunk-MZ2NARG7.js";
+import {
+  buildToolMetadataList,
+  toolsTestHelpers
+} from "./chunk-XANPGTLI.js";
+import "./chunk-N46NEFAF.js";
+import "./chunk-BNV3TPE4.js";
+import {
+  splitCommandLine
+} from "./chunk-E22DYOW5.js";
+import {
+  extractHttpServerTarget,
+  looksLikeHttpUrl,
+  normalizeHttpUrl,
+  normalizeHttpUrlCandidate,
+  splitHttpToolSelector
+} from "./chunk-M3TPODXI.js";
+import {
+  createRuntime
+} from "./chunk-NNOEGEUZ.js";
+import "./chunk-7FHEBT5G.js";
+import "./chunk-BZIQOWE6.js";
+import "./chunk-YHQUTU6L.js";
+import "./chunk-TATVT5IT.js";
+import "./chunk-HKRJ6O36.js";
+import {
+  MCPORTER_VERSION
+} from "./chunk-4SQKWYFF.js";
+import "./chunk-6W5QFASN.js";
+import {
+  loadServerDefinitions
+} from "./chunk-2U4BSDC4.js";
+import "./chunk-UKYNQGNE.js";
+import "./chunk-P3PSC54P.js";
+import "./chunk-2XL7MG7R.js";
+import "./chunk-WQJZMCJN.js";
+import "./chunk-ECIVB7P4.js";
+import {
+  resolveLifecycle
+} from "./chunk-LS7PMWSR.js";
+import "./chunk-D3MRAZ6H.js";
+import "./chunk-LRKZP7DJ.js";
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/generate/flags.js
+function parseGenerateFlags(args) {
+  const common = extractGeneratorFlags(args);
+  let server;
+  let name;
+  let command;
+  let description;
+  let output;
+  let bundler;
+  let bundle;
+  let compile;
+  const runtime = common.runtime;
+  const timeout = common.timeout ?? 3e4;
+  let minify;
+  let from;
+  let dryRun = false;
+  let includeTools;
+  let excludeTools;
+  let index = 0;
+  while (index < args.length) {
+    const token = args[index];
+    if (!token) {
+      index += 1;
+      continue;
+    }
+    if (token === "--from") {
+      from = expectValue(token, args[index + 1]);
+      args.splice(index, 2);
+      continue;
+    }
+    if (token === "--dry-run") {
+      dryRun = true;
+      args.splice(index, 1);
+      continue;
+    }
+    if (token === "--include-tools") {
+      const value = expectValue(token, args[index + 1]);
+      includeTools = mergeCsvList(includeTools, value);
+      args.splice(index, 2);
+      continue;
+    }
+    if (token === "--exclude-tools") {
+      const value = expectValue(token, args[index + 1]);
+      excludeTools = mergeCsvList(excludeTools, value);
+      args.splice(index, 2);
+      continue;
+    }
+    if (token === "--server") {
+      server = expectValue(token, args[index + 1]);
+      args.splice(index, 2);
+      continue;
+    }
+    if (token === "--name") {
+      name = expectValue(token, args[index + 1]);
+      args.splice(index, 2);
+      continue;
+    }
+    if (token === "--command") {
+      const value = expectValue(token, args[index + 1]);
+      command = normalizeCommandInput(value);
+      args.splice(index, 2);
+      continue;
+    }
+    if (token === "--description") {
+      description = expectValue(token, args[index + 1]);
+      args.splice(index, 2);
+      continue;
+    }
+    if (token === "--output") {
+      output = expectValue(token, args[index + 1]);
+      args.splice(index, 2);
+      continue;
+    }
+    if (token === "--bundle") {
+      const next = args[index + 1];
+      if (!next || next.startsWith("--")) {
+        bundle = true;
+        args.splice(index, 1);
+      } else {
+        bundle = next;
+        args.splice(index, 2);
+      }
+      continue;
+    }
+    if (token === "--bundler") {
+      const value = expectValue(token, args[index + 1]);
+      if (value !== "rolldown" && value !== "bun") {
+        throw new Error("--bundler must be 'rolldown' or 'bun'.");
+      }
+      bundler = value;
+      args.splice(index, 2);
+      continue;
+    }
+    if (token === "--compile") {
+      const next = args[index + 1];
+      if (!next || next.startsWith("--")) {
+        compile = true;
+        args.splice(index, 1);
+      } else {
+        compile = next;
+        args.splice(index, 2);
+      }
+      continue;
+    }
+    if (token === "--minify") {
+      minify = true;
+      args.splice(index, 1);
+      continue;
+    }
+    if (token === "--no-minify") {
+      minify = false;
+      args.splice(index, 1);
+      continue;
+    }
+    if (token.startsWith("--")) {
+      throw new Error(`Unknown flag '${token}' for generate-cli.`);
+    }
+    index += 1;
+  }
+  const positional = !server && !command && !from ? args.find((token) => token && !token.startsWith("--")) : void 0;
+  if (positional) {
+    const position = args.indexOf(positional);
+    if (position !== -1) {
+      args.splice(position, 1);
+    }
+    if (looksLikeInlineCommand(positional)) {
+      command = normalizeCommandInput(positional);
+    } else if (looksLikeHttpUrl(positional) || positional.includes("://")) {
+      command = positional;
+    } else {
+      server = positional;
+    }
+  }
+  if (!server && !command && common.runtime === "node" && common.timeout && !from && args[0]) {
+    const target = extractHttpServerTarget(args[0]);
+    if (target) {
+      server = target;
+    }
+  }
+  return {
+    server,
+    name,
+    command,
+    description,
+    output,
+    bundler,
+    bundle,
+    compile,
+    runtime,
+    timeout,
+    minify,
+    from,
+    dryRun,
+    includeTools,
+    excludeTools
+  };
+}
+function mergeCsvList(existing, value) {
+  const parts = value.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+  const base = existing ?? [];
+  const merged = [...base, ...parts];
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const name of merged) {
+    if (!seen.has(name)) {
+      seen.add(name);
+      result.push(name);
+    }
+  }
+  return result;
+}
+function normalizeCommandInput(value) {
+  const httpCandidate = normalizeHttpUrlCandidate(value);
+  if (httpCandidate) {
+    const selector = splitHttpToolSelector(httpCandidate);
+    if (selector) {
+      return selector.baseUrl;
+    }
+    return httpCandidate;
+  }
+  if (looksLikeInlineCommand(value)) {
+    return parseInlineCommand(value);
+  }
+  return { command: value };
+}
+function looksLikeInlineCommand(value) {
+  if (!value) {
+    return false;
+  }
+  if (!/\s/.test(value)) {
+    return false;
+  }
+  try {
+    const parts = splitCommandLine(value.trim());
+    return parts.length > 0;
+  } catch {
+    return false;
+  }
+}
+function parseInlineCommand(value) {
+  const parts = splitCommandLine(value.trim());
+  if (parts.length === 0) {
+    throw new Error("--command requires a non-empty value.");
+  }
+  const [command, ...rest] = parts;
+  return { command, args: rest };
+}
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/generate/name-utils.js
+function inferNameFromCommand(command) {
+  if (typeof command === "string") {
+    const normalizedHttp = normalizeHttpUrlCandidate(command);
+    if (normalizedHttp) {
+      try {
+        const url = new URL(normalizedHttp);
+        const segments = url.hostname.split(".").filter(Boolean);
+        for (const segment of segments) {
+          const lowered = segment.toLowerCase();
+          if (lowered === "www" || lowered === "api" || lowered === "mcp") {
+            continue;
+          }
+          const slug = slugify(segment);
+          if (slug) {
+            return slug;
+          }
+        }
+        const fallback = slugify(segments[0] ?? url.hostname);
+        if (fallback) {
+          return fallback;
+        }
+        const derived = deriveNameFromUrl(url);
+        const derivedSlug = derived ? slugify(derived) : void 0;
+        if (derivedSlug) {
+          return derivedSlug;
+        }
+      } catch {
+      }
+    }
+    const trimmed = command.trim();
+    if (looksLikeInlineCommand2(trimmed)) {
+      try {
+        const parsed = parseInlineCommand2(trimmed);
+        const derived = inferNameFromCommand(parsed);
+        if (derived) {
+          return derived;
+        }
+      } catch {
+      }
+    }
+    const firstToken = trimmed.split(/\s+/)[0] ?? trimmed;
+    const candidateToken = firstToken.split(/[\\/]/).pop() ?? firstToken;
+    return slugify(candidateToken.replace(/\.[a-z0-9]+$/i, ""));
+  }
+  const parts = [command.command, ...command.args ?? []];
+  if (parts.length === 0) {
+    return void 0;
+  }
+  const script = parts.find((part) => /\.[cm]?(ts|js)x?$/i.test(part));
+  if (script) {
+    return slugify(stripExtension(basename(script)));
+  }
+  const packageArg = parts.find((_part, index) => index > 0 && /[@/]/.test(_part));
+  if (packageArg) {
+    return slugify(packageArg.replace(/^@/, "").split("@")[0] ?? packageArg);
+  }
+  const bareArg = findLastPositionalArg(parts);
+  if (bareArg) {
+    return slugify(bareArg);
+  }
+  return slugify(basename(parts[0] ?? "command"));
+}
+function looksLikeInlineCommand2(value) {
+  if (!value) {
+    return false;
+  }
+  if (!/\s/.test(value)) {
+    return false;
+  }
+  try {
+    const parts = splitCommandLine(value.trim());
+    return parts.length > 0;
+  } catch {
+    return false;
+  }
+}
+function parseInlineCommand2(value) {
+  const parts = splitCommandLine(value.trim());
+  if (parts.length === 0) {
+    throw new Error("--command requires a non-empty value.");
+  }
+  const [command, ...rest] = parts;
+  return { command, args: rest };
+}
+function slugify(value) {
+  const normalized = value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return normalized || void 0;
+}
+function basename(value) {
+  const segments = value.split(/[\\/]/);
+  return segments[segments.length - 1] ?? value;
+}
+function stripExtension(value) {
+  const index = value.lastIndexOf(".");
+  if (index === -1) {
+    return value;
+  }
+  return value.slice(0, index);
+}
+function findLastPositionalArg(parts) {
+  for (let index = parts.length - 1; index >= 1; index -= 1) {
+    const part = parts[index];
+    if (!part) {
+      continue;
+    }
+    if (part.startsWith("-")) {
+      continue;
+    }
+    if (/^[A-Za-z0-9_]+=/.test(part)) {
+      continue;
+    }
+    if (part.includes("://")) {
+      continue;
+    }
+    return part;
+  }
+  return void 0;
+}
+function deriveNameFromUrl(url) {
+  const genericHosts = /* @__PURE__ */ new Set(["www", "api", "mcp", "service", "services", "app", "localhost"]);
+  const knownTlds = /* @__PURE__ */ new Set(["com", "net", "org", "io", "ai", "app", "dev", "co", "cloud"]);
+  const parts = url.hostname.split(".").filter(Boolean);
+  const filtered = parts.filter((part) => {
+    const lower = part.toLowerCase();
+    if (genericHosts.has(lower)) {
+      return false;
+    }
+    if (knownTlds.has(lower)) {
+      return false;
+    }
+    if (/^\d+$/.test(part)) {
+      return false;
+    }
+    return true;
+  });
+  if (filtered.length > 0) {
+    const last = filtered[filtered.length - 1];
+    if (last) {
+      return last;
+    }
+  }
+  const firstSegment = url.pathname.split("/").find(Boolean);
+  if (firstSegment) {
+    return firstSegment.replace(/[^a-zA-Z0-9-_]/g, "-");
+  }
+  return void 0;
+}
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/generate-cli.js
+import fs3 from "node:fs/promises";
+import { createHash } from "node:crypto";
+import path3 from "node:path";
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/generate/artifacts.js
+import { execFile as execFile2 } from "node:child_process";
+import fsSync from "node:fs";
+import fs from "node:fs/promises";
+import { builtinModules, createRequire } from "node:module";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/generate/runtime.js
+import { execFile } from "node:child_process";
+async function resolveRuntimeKind(runtimeOption, compileOption) {
+  if (runtimeOption) {
+    return runtimeOption;
+  }
+  const bunAvailable = await isBunAvailable();
+  if (compileOption && !bunAvailable) {
+    throw new Error("--compile requires Bun. Install Bun or set BUN_BIN to the bun executable.");
+  }
+  return bunAvailable ? "bun" : "node";
+}
+async function verifyBunAvailable() {
+  const bunBin = process.env.BUN_BIN ?? "bun";
+  await new Promise((resolve, reject) => {
+    execFile(bunBin, ["--version"], { cwd: process.cwd(), env: process.env }, (error) => {
+      if (error) {
+        reject(new Error("Unable to locate Bun runtime. Install Bun or set BUN_BIN to the bun executable."));
+        return;
+      }
+      resolve();
+    });
+  });
+  return bunBin;
+}
+async function isBunAvailable() {
+  try {
+    await verifyBunAvailable();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/generate/artifacts.js
+var localRequire = createRequire(import.meta.url);
+var packageRoot = fileURLToPath(new URL("../../..", import.meta.url));
+var BUNDLED_DEPENDENCIES = ["commander", "mcporter", "jsonc-parser"];
+var dependencyAliasPlugin = createLocalDependencyAliasPlugin([...BUNDLED_DEPENDENCIES]);
+var NODE_BUILTIN_SPECIFIERS = new Set(builtinModules.flatMap((specifier) => [specifier, `node:${specifier}`]));
+async function bundleOutput({ sourcePath, targetPath, runtimeKind, minify, bundler }) {
+  if (bundler === "bun") {
+    return await bundleWithBun({ sourcePath, targetPath, runtimeKind, minify });
+  }
+  return await bundleWithRolldown({ sourcePath, targetPath, runtimeKind, minify });
+}
+async function bundleWithRolldown({ sourcePath, targetPath, runtimeKind, minify }) {
+  let rolldownImpl;
+  try {
+    ({ rolldown: rolldownImpl } = await import("./dist-LK3SHAMX.js"));
+  } catch (error) {
+    const message = "Rolldown bundling is unavailable in this build of mcporter; rerun with --bundler bun or install mcporter via npm (Node.js) to use the Rolldown bundler.";
+    if (error instanceof Error) {
+      error.message = `${message}
+
+${error.message}`;
+      throw error;
+    }
+    throw new Error(message, { cause: error });
+  }
+  const absTarget = path.resolve(targetPath);
+  await fs.mkdir(path.dirname(absTarget), { recursive: true });
+  const plugins = dependencyAliasPlugin ? [dependencyAliasPlugin] : void 0;
+  const bundle = await rolldownImpl({
+    input: sourcePath,
+    treeshake: false,
+    plugins,
+    onLog(level, log, handler) {
+      if (typeof log.code === "string" && log.code === "EVAL") {
+        return;
+      }
+      if (isExpectedNodeBuiltinWarning(log)) {
+        return;
+      }
+      handler(level, log);
+    }
+  });
+  const format = outputFormatForTarget(absTarget, runtimeKind);
+  await bundle.write({
+    file: absTarget,
+    format,
+    codeSplitting: false,
+    sourcemap: false,
+    minify,
+    ...format === "esm" ? { banner: buildEsmRequireBanner() } : {}
+  });
+  await markExecutable(absTarget);
+  return absTarget;
+}
+function isExpectedNodeBuiltinWarning(log) {
+  const record = log;
+  if (record.code !== "UNRESOLVED_IMPORT" || typeof record.message !== "string") {
+    return false;
+  }
+  const match = record.message.match(/Could not resolve ['"]([^'"]+)['"]/);
+  return Boolean(match?.[1] && NODE_BUILTIN_SPECIFIERS.has(match[1]));
+}
+function buildEsmRequireBanner() {
+  return [
+    'import { createRequire as __mcporterCreateRequire } from "node:module";',
+    "const require = __mcporterCreateRequire(import.meta.url);"
+  ].join("\n");
+}
+function outputFormatForTarget(targetPath, runtimeKind) {
+  const extension = path.extname(targetPath).toLowerCase();
+  if (extension === ".mjs") {
+    return "esm";
+  }
+  if (extension === ".cjs") {
+    return "cjs";
+  }
+  return runtimeKind === "bun" ? "esm" : "cjs";
+}
+async function bundleWithBun({ sourcePath, targetPath, runtimeKind, minify }) {
+  const absTarget = path.resolve(targetPath);
+  await fs.mkdir(path.dirname(absTarget), { recursive: true });
+  const bunBin = await verifyBunAvailable();
+  const tmpRoot = path.join(packageRoot, "tmp");
+  await fs.mkdir(tmpRoot, { recursive: true });
+  const stagingDir = await fs.mkdtemp(path.join(tmpRoot, "bundle-"));
+  const stagingEntry = path.join(stagingDir, path.basename(sourcePath));
+  await safeCopyFile(sourcePath, stagingEntry);
+  await ensureBundlerDeps(stagingDir);
+  try {
+    const args = ["build", stagingEntry, "--outfile", absTarget, "--target", runtimeKind === "bun" ? "bun" : "node"];
+    if (minify) {
+      args.push("--minify");
+    }
+    await new Promise((resolve, reject) => {
+      execFile2(bunBin, args, { cwd: stagingDir, env: process.env }, (error) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve();
+      });
+    });
+  } finally {
+    await fs.rm(stagingDir, { recursive: true, force: true }).catch(() => {
+    });
+  }
+  await markExecutable(absTarget);
+  return absTarget;
+}
+async function compileBundleWithBun(bundlePath, outputPath) {
+  const bunBin = await verifyBunAvailable();
+  await new Promise((resolve, reject) => {
+    execFile2(bunBin, ["build", bundlePath, "--compile", "--outfile", outputPath], { cwd: process.cwd(), env: process.env }, (error) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve();
+    });
+  });
+  await markExecutable(outputPath);
+}
+function resolveBundleTarget({ bundle, compile, outputPath }) {
+  if (typeof bundle === "string") {
+    return bundle;
+  }
+  if (bundle) {
+    throw new Error("--bundle requires an explicit output path when used with --compile.");
+  }
+  if (typeof compile === "string") {
+    const ext = path.extname(compile);
+    const base = ext ? path.join(path.dirname(compile), path.basename(compile, ext)) : compile;
+    return `${base}.js`;
+  }
+  if (compile) {
+    const tmpDir = path.join(process.cwd(), "tmp", "mcporter-cli-bundles");
+    const baseName = path.basename(outputPath, path.extname(outputPath)) || "bundle";
+    return path.join(tmpDir, `${baseName}-${Date.now()}.bundle.js`);
+  }
+  throw new Error("--compile requires an explicit bundle target.");
+}
+function computeCompileTarget(compileOption, _bundlePath, serverName) {
+  if (typeof compileOption === "string") {
+    return compileOption;
+  }
+  const baseName = sanitizeFileName(serverName) || "mcporter-cli";
+  return resolveUniquePath(process.cwd(), baseName);
+}
+function createLocalDependencyAliasPlugin(specifiers) {
+  const resolvedEntries = specifiers.map((specifier) => ({ specifier, path: resolveLocalDependency(specifier) })).filter((entry) => Boolean(entry.path));
+  if (resolvedEntries.length === 0) {
+    return void 0;
+  }
+  return {
+    name: "mcporter-local-deps",
+    resolveId(source) {
+      const match = resolvedEntries.find((entry) => entry.specifier === source);
+      if (match) {
+        return match.path;
+      }
+      return null;
+    }
+  };
+}
+function resolveLocalDependency(specifier) {
+  try {
+    if (specifier === "jsonc-parser") {
+      const pkgJsonPath = localRequire.resolve("jsonc-parser/package.json");
+      const pkgDir = path.dirname(pkgJsonPath);
+      try {
+        const pkg = JSON.parse(fsSync.readFileSync(pkgJsonPath, "utf8"));
+        if (pkg.module) {
+          const esmEntry = path.join(pkgDir, pkg.module);
+          if (fsSync.existsSync(esmEntry)) {
+            return esmEntry;
+          }
+        }
+      } catch {
+      }
+    }
+    return localRequire.resolve(specifier);
+  } catch {
+    if (specifier === "mcporter") {
+      const fallbacks = [
+        path.join(packageRoot, "dist", "index.js"),
+        path.join(packageRoot, "dist", "index.mjs"),
+        path.join(packageRoot, "src", "index.ts"),
+        path.join(packageRoot, "src", "index.js")
+      ];
+      for (const candidate of fallbacks) {
+        if (fsSync.existsSync(candidate)) {
+          return candidate;
+        }
+      }
+    }
+  }
+  return void 0;
+}
+async function ensureBundlerDeps(stagingDir) {
+  const nodeModulesDir = path.join(stagingDir, "node_modules");
+  await fs.mkdir(nodeModulesDir, { recursive: true });
+  await Promise.all(BUNDLED_DEPENDENCIES.map(async (specifier) => {
+    const sourceDir = resolveDependencyDirectory(specifier);
+    if (!sourceDir) {
+      return;
+    }
+    const target = path.join(nodeModulesDir, specifier);
+    await linkOrCopyDependency(sourceDir, target);
+  }));
+  const missing = await findMissingBundlerDeps(stagingDir);
+  if (missing.length > 0) {
+    await installPublishedBundlerDeps(stagingDir);
+  }
+}
+async function findMissingBundlerDeps(stagingDir) {
+  const missing = [];
+  for (const specifier of BUNDLED_DEPENDENCIES) {
+    const pkgPath = path.join(stagingDir, "node_modules", specifier, "package.json");
+    try {
+      await fs.access(pkgPath);
+    } catch {
+      missing.push(specifier);
+    }
+  }
+  return missing;
+}
+async function installPublishedBundlerDeps(stagingDir) {
+  const installSpec = process.env.MCPORTER_BUNDLER_DEP_PACKAGE ?? MCPORTER_VERSION;
+  if (installSpec === "0.0.0-dev") {
+    throw new Error("Unable to resolve generated-CLI bundler dependencies from this standalone mcporter binary. Install mcporter via npm/Homebrew or publish the matching mcporter package before using --compile.");
+  }
+  await fs.writeFile(path.join(stagingDir, "package.json"), JSON.stringify({ private: true, type: "module", dependencies: { mcporter: installSpec } }, null, 2), "utf8");
+  await new Promise((resolve, reject) => {
+    execFile2("npm", ["install", "--ignore-scripts", "--no-audit", "--no-fund", "--min-release-age=0"], { cwd: stagingDir, env: process.env }, (error) => {
+      if (error) {
+        reject(new Error(`Unable to install ${formatMcporterInstallSpec(installSpec)} dependencies needed for Bun compilation from this standalone binary. Install mcporter via npm/Homebrew, or ensure npm can reach the registry.
+
+${error.message}`));
+        return;
+      }
+      resolve();
+    });
+  });
+}
+function formatMcporterInstallSpec(installSpec) {
+  if (installSpec === MCPORTER_VERSION) {
+    return `mcporter@${MCPORTER_VERSION}`;
+  }
+  return `mcporter from ${installSpec}`;
+}
+function resolveDependencyDirectory(specifier) {
+  try {
+    if (specifier === "mcporter") {
+      return packageRoot;
+    }
+    const pkgPath = localRequire.resolve(path.join(specifier, "package.json"));
+    return path.dirname(pkgPath);
+  } catch {
+    return void 0;
+  }
+}
+async function linkOrCopyDependency(sourceDir, targetDir) {
+  try {
+    await fs.symlink(sourceDir, targetDir, "dir");
+  } catch (error) {
+    const code = error.code;
+    if (code === "EEXIST") {
+      return;
+    }
+    if (code === "ENOENT") {
+      return;
+    }
+    if (code === "EPERM" || code === "EACCES") {
+      await fs.cp(sourceDir, targetDir, { recursive: true });
+      return;
+    }
+    throw error;
+  }
+}
+function sanitizeFileName(input) {
+  const slug = input.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-");
+  return slug.replace(/^-+|-+$/g, "");
+}
+function resolveUniquePath(directory, baseName) {
+  let attempt = path.join(directory, baseName);
+  let suffix = 1;
+  while (fsSync.existsSync(attempt)) {
+    attempt = path.join(directory, `${baseName}-${suffix}`);
+    suffix += 1;
+  }
+  return attempt;
+}
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/generate/definition.js
+import fs2 from "node:fs/promises";
+import path2 from "node:path";
+function ensureInvocationDefaults(invocation, definition) {
+  const serverRef = invocation.serverRef ?? definition.name;
+  const configPath = invocation.configPath ?? (definition.source && definition.source.kind === "local" ? definition.source.path : void 0);
+  return {
+    ...invocation,
+    serverRef,
+    configPath
+  };
+}
+async function resolveServerDefinition(serverRef, configPath, rootDir) {
+  const trimmed = serverRef.trim();
+  if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+    const parsed = JSON.parse(trimmed);
+    if (!parsed.name) {
+      throw new Error("Inline server definition must include a 'name' field.");
+    }
+    return { definition: normalizeDefinition(parsed), name: parsed.name };
+  }
+  const possiblePath = path2.resolve(trimmed);
+  try {
+    const buffer = await fs2.readFile(possiblePath, "utf8");
+    const parsed = JSON.parse(buffer);
+    if (!parsed.mcpServers || typeof parsed.mcpServers !== "object") {
+      throw new Error(`Config file ${possiblePath} does not contain mcpServers.`);
+    }
+    const entries = Object.entries(parsed.mcpServers);
+    if (entries.length === 0) {
+      throw new Error(`Config file ${possiblePath} does not define any servers.`);
+    }
+    const first = entries[0];
+    if (!first) {
+      throw new Error(`Config file ${possiblePath} does not define any servers.`);
+    }
+    const [name, value] = first;
+    return {
+      definition: normalizeDefinition({
+        name,
+        ...value
+      }),
+      name
+    };
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  const definitions = await loadServerDefinitions({
+    configPath,
+    rootDir
+  });
+  const matchByName = definitions.find((def) => def.name === trimmed);
+  if (matchByName) {
+    return { definition: matchByName, name: matchByName.name };
+  }
+  const httpTarget = extractHttpServerTarget(trimmed);
+  if (httpTarget) {
+    const normalizedTarget = normalizeHttpUrl(httpTarget);
+    if (normalizedTarget) {
+      const matchByUrl = definitions.find((def) => {
+        if (def.command.kind !== "http") {
+          return false;
+        }
+        const normalizedDefinitionUrl = normalizeHttpUrl(def.command.url);
+        return normalizedDefinitionUrl === normalizedTarget;
+      });
+      if (matchByUrl) {
+        return { definition: matchByUrl, name: matchByUrl.name };
+      }
+    }
+  }
+  throw new Error(`Unknown MCP server '${trimmed}'. Provide a name from config, a JSON file, inline JSON, or an HTTP URL that matches a configured server.`);
+}
+async function fetchTools(definition, serverName, configPath, rootDir) {
+  const runtime = await createRuntime({
+    configPath,
+    rootDir,
+    servers: configPath ? void 0 : [definition]
+  });
+  try {
+    const tools = await runtime.listTools(serverName, { includeSchema: true });
+    const derivedDescription = definition.description ? void 0 : await deriveDefinitionDescription(runtime, serverName);
+    return { tools, derivedDescription };
+  } finally {
+    await runtime.close(serverName).catch(() => {
+    });
+  }
+}
+async function deriveDefinitionDescription(runtime, serverName) {
+  try {
+    const context = await runtime.connect(serverName);
+    const instructions = typeof context.client.getInstructions === "function" ? context.client.getInstructions() : void 0;
+    const serverInfo = typeof context.client.getServerVersion === "function" ? context.client.getServerVersion() : void 0;
+    const derived = pickDescription(instructions, serverInfo);
+    return derived;
+  } catch {
+    return void 0;
+  }
+}
+function pickDescription(instructions, serverInfo) {
+  const ordered = [instructions, serverInfo?.title, serverInfo?.name];
+  for (const candidate of ordered) {
+    if (typeof candidate === "string") {
+      const trimmed = candidate.trim();
+      if (trimmed.length > 0) {
+        return trimmed;
+      }
+    }
+  }
+  return void 0;
+}
+function normalizeDefinition(def) {
+  const name = def.name;
+  if (typeof name !== "string" || name.trim().length === 0) {
+    throw new Error("Server definition must include a name.");
+  }
+  const description = typeof def.description === "string" ? def.description : void 0;
+  const env = toStringRecord(def.env);
+  const auth = typeof def.auth === "string" ? def.auth : void 0;
+  const tokenCacheDir = typeof def.tokenCacheDir === "string" ? def.tokenCacheDir : void 0;
+  const clientName = typeof def.clientName === "string" ? def.clientName : void 0;
+  const record = def;
+  const oauthClientId = stringFromAliases(record, "oauthClientId", "oauth_client_id");
+  const oauthClientSecret = stringFromAliases(record, "oauthClientSecret", "oauth_client_secret");
+  const oauthClientSecretEnv = stringFromAliases(record, "oauthClientSecretEnv", "oauth_client_secret_env");
+  const oauthTokenEndpointAuthMethod = stringFromAliases(record, "oauthTokenEndpointAuthMethod", "oauth_token_endpoint_auth_method");
+  const oauthRedirectUrl = typeof def.oauthRedirectUrl === "string" ? def.oauthRedirectUrl : void 0;
+  const oauthScope = typeof def.oauthScope === "string" ? def.oauthScope : void 0;
+  const refresh = getRefresh(record.refresh);
+  const httpFetch = normalizeHttpFetch(stringFromAliases(record, "httpFetch", "http_fetch"));
+  const headers = toStringRecord(def.headers);
+  const oauthCommand = getOauthCommand(record.oauthCommand ?? record.oauth_command);
+  const rawLifecycle = getRawLifecycle(record.lifecycle);
+  const logging = getLogging(record.logging);
+  const allowedTools = getOptionalStringArray(record.allowedTools ?? record.allowed_tools, "allowedTools");
+  const blockedTools = getOptionalStringArray(record.blockedTools ?? record.blocked_tools, "blockedTools");
+  if (allowedTools !== void 0 && blockedTools !== void 0) {
+    throw new Error(`Server definition '${name}' cannot specify both allowedTools and blockedTools.`);
+  }
+  const shared = (command) => ({
+    env,
+    auth,
+    tokenCacheDir,
+    clientName,
+    oauthClientId,
+    oauthClientSecret,
+    oauthClientSecretEnv,
+    oauthTokenEndpointAuthMethod,
+    oauthRedirectUrl,
+    oauthScope,
+    oauthCommand,
+    refresh,
+    httpFetch,
+    lifecycle: resolveLifecycle(name, rawLifecycle, command),
+    logging,
+    ...allowedTools !== void 0 ? { allowedTools } : {},
+    ...blockedTools !== void 0 ? { blockedTools } : {}
+  });
+  const commandValue = def.command;
+  if (isCommandSpec(commandValue)) {
+    const command = normalizeCommand(commandValue, headers);
+    return {
+      name,
+      description,
+      command,
+      ...shared(command)
+    };
+  }
+  if (typeof commandValue === "string" && commandValue.trim().length > 0) {
+    const command = toCommandSpec(commandValue, getStringArray(record.args), headers ? { headers } : void 0);
+    return {
+      name,
+      description,
+      command,
+      ...shared(command)
+    };
+  }
+  if (Array.isArray(commandValue) && commandValue.length > 0) {
+    const [first, ...rest] = commandValue;
+    if (typeof first !== "string" || !rest.every((entry) => typeof entry === "string")) {
+      throw new Error("Command array must contain only strings.");
+    }
+    const command = toCommandSpec(first, rest, headers ? { headers } : void 0);
+    return {
+      name,
+      description,
+      command,
+      ...shared(command)
+    };
+  }
+  throw new Error("Server definition must include command information.");
+}
+function isCommandSpec(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const candidate = value;
+  if (candidate.kind === "http") {
+    return "url" in candidate;
+  }
+  if (candidate.kind === "stdio") {
+    return "command" in candidate;
+  }
+  return false;
+}
+function normalizeCommand(command, headers) {
+  if (command.kind === "http") {
+    const urlValue = command.url;
+    const url = urlValue instanceof URL ? urlValue : new URL(String(urlValue));
+    const mergedHeaders = command.headers ? headers ? { ...command.headers, ...headers } : command.headers : headers;
+    const normalized = {
+      kind: "http",
+      url,
+      ...mergedHeaders ? { headers: mergedHeaders } : {}
+    };
+    return normalized;
+  }
+  return {
+    kind: "stdio",
+    command: command.command,
+    args: [...command.args],
+    cwd: command.cwd ?? process.cwd()
+  };
+}
+function toCommandSpec(command, args, extra) {
+  if (command.startsWith("http://") || command.startsWith("https://")) {
+    const httpCommand = {
+      kind: "http",
+      url: new URL(command),
+      ...extra?.headers ? { headers: extra.headers } : {}
+    };
+    return httpCommand;
+  }
+  const stdio = {
+    kind: "stdio",
+    command,
+    args: args ?? [],
+    cwd: process.cwd()
+  };
+  return stdio;
+}
+function getStringArray(value) {
+  if (!Array.isArray(value)) {
+    return void 0;
+  }
+  const entries = value.filter((item) => typeof item === "string");
+  return entries.length > 0 ? entries : void 0;
+}
+function getOptionalStringArray(value, fieldName) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!Array.isArray(value) || !value.every((item) => typeof item === "string")) {
+    throw new Error(`${fieldName} must be an array of strings.`);
+  }
+  return [...value];
+}
+function getRawLifecycle(value) {
+  if (value === "keep-alive" || value === "ephemeral") {
+    return value;
+  }
+  if (typeof value === "object" && value !== null) {
+    const record = value;
+    if (record.mode === "keep-alive" || record.mode === "ephemeral") {
+      return {
+        mode: record.mode,
+        ...typeof record.idleTimeoutMs === "number" ? { idleTimeoutMs: record.idleTimeoutMs } : {}
+      };
+    }
+  }
+  return void 0;
+}
+function getLogging(value) {
+  if (typeof value !== "object" || value === null) {
+    return void 0;
+  }
+  const daemon = value.daemon;
+  if (typeof daemon !== "object" || daemon === null) {
+    return void 0;
+  }
+  const enabled = daemon.enabled;
+  return typeof enabled === "boolean" ? { daemon: { enabled } } : { daemon: {} };
+}
+function getOauthCommand(value) {
+  if (typeof value !== "object" || value === null) {
+    return void 0;
+  }
+  const args = getStringArray(value.args);
+  return args ? { args } : void 0;
+}
+function getRefresh(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return void 0;
+  }
+  const record = value;
+  const tokenEndpoint = stringFromAliases(record, "tokenEndpoint", "token_endpoint");
+  if (!tokenEndpoint) {
+    return void 0;
+  }
+  const refreshSkewSeconds = record.refreshSkewSeconds ?? record.refresh_skew_seconds;
+  return {
+    tokenEndpoint,
+    clientIdEnv: stringFromAliases(record, "clientIdEnv", "client_id_env"),
+    clientSecretEnv: stringFromAliases(record, "clientSecretEnv", "client_secret_env"),
+    clientAuthMethod: stringFromAliases(record, "clientAuthMethod", "client_auth_method"),
+    ...typeof refreshSkewSeconds === "number" && Number.isInteger(refreshSkewSeconds) && refreshSkewSeconds >= 0 ? { refreshSkewSeconds } : {},
+    accessTokenEnv: stringFromAliases(record, "accessTokenEnv", "access_token_env")
+  };
+}
+function normalizeHttpFetch(value) {
+  return value === "default" || value === "node-http1" ? value : void 0;
+}
+function stringFromAliases(record, ...keys) {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string") {
+      return value;
+    }
+  }
+  return void 0;
+}
+function toStringRecord(value) {
+  if (typeof value !== "object" || value === null) {
+    return void 0;
+  }
+  const result = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (typeof entry === "string") {
+      result[key] = entry;
+    }
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/generate-cli.js
+var REPRODUCIBLE_GENERATED_AT = "1970-01-01T00:00:00.000Z";
+async function generateCli(options) {
+  const runtimeKind = await resolveRuntimeKind(options.runtime, options.compile);
+  const bundlerKind = options.bundler ?? (runtimeKind === "bun" ? "bun" : "rolldown");
+  if (bundlerKind === "bun" && runtimeKind !== "bun") {
+    throw new Error("--bundler bun currently requires --runtime bun.");
+  }
+  const timeoutMs = options.timeoutMs ?? 3e4;
+  const { definition: baseDefinition, name } = await resolveServerDefinition(options.serverRef, options.configPath, options.rootDir);
+  const { tools: allTools, derivedDescription } = await fetchTools(baseDefinition, name, options.configPath, options.rootDir);
+  const tools = applyToolFilters(allTools, options.includeTools, options.excludeTools);
+  const definition = baseDefinition.description || !derivedDescription ? baseDefinition : { ...baseDefinition, description: derivedDescription };
+  const embeddedDefinition = stripBuildSources(definition);
+  const serializedDefinition = serializeDefinition(embeddedDefinition);
+  const toolMetadata = buildToolMetadataList(tools);
+  const generator = await readPackageMetadata();
+  const baseInvocation = ensureInvocationDefaults({
+    serverRef: options.serverRef,
+    configPath: options.configPath,
+    rootDir: options.rootDir,
+    runtime: runtimeKind,
+    bundler: bundlerKind,
+    outputPath: options.outputPath,
+    bundle: options.bundle,
+    compile: options.compile,
+    timeoutMs,
+    minify: options.minify ?? false,
+    includeTools: options.includeTools,
+    excludeTools: options.excludeTools
+  }, embeddedDefinition);
+  const embeddedMetadata = {
+    schemaVersion: 1,
+    generatedAt: REPRODUCIBLE_GENERATED_AT,
+    generator,
+    server: {
+      name,
+      definition: serializedDefinition
+    },
+    artifact: {
+      path: "",
+      kind: "template"
+    },
+    invocation: buildEmbeddedInvocation(baseInvocation, serializedDefinition)
+  };
+  const shouldBundle = Boolean(options.bundle ?? options.compile);
+  let templateTmpDir;
+  let templateOutputPath = options.outputPath;
+  if (!templateOutputPath && shouldBundle) {
+    templateTmpDir = resolveImplicitTemplateDir(name, serializedDefinition);
+    await fs3.mkdir(templateTmpDir, { recursive: true });
+    templateOutputPath = path3.join(templateTmpDir, `${sanitizePathSegment(name) || "server"}.ts`);
+  }
+  const templateSourcePath = path3.resolve(templateOutputPath ?? path3.resolve(process.cwd(), `${name}.ts`));
+  let resolvedBundleTarget;
+  let resolvedCompileTarget;
+  if (shouldBundle) {
+    resolvedBundleTarget = path3.resolve(resolveBundleTarget({
+      bundle: options.bundle,
+      compile: options.compile,
+      outputPath: templateSourcePath
+    }));
+    if (options.compile) {
+      resolvedCompileTarget = path3.resolve(computeCompileTarget(options.compile, resolvedBundleTarget, name));
+    }
+  }
+  const runtimeScriptPath = resolvedCompileTarget ?? resolvedBundleTarget ?? templateSourcePath;
+  const outputPath = await writeTemplate({
+    outputPath: templateOutputPath,
+    runtimeScriptPath,
+    runtimeKind,
+    timeoutMs,
+    definition: embeddedDefinition,
+    serverName: name,
+    tools: toolMetadata,
+    generator,
+    metadata: embeddedMetadata
+  });
+  let bundlePath;
+  let compilePath;
+  try {
+    if (shouldBundle && resolvedBundleTarget) {
+      bundlePath = await bundleOutput({
+        sourcePath: outputPath,
+        runtimeKind,
+        targetPath: resolvedBundleTarget,
+        minify: options.minify ?? false,
+        bundler: bundlerKind
+      });
+      if (options.compile) {
+        if (runtimeKind !== "bun") {
+          throw new Error("--compile is only supported when --runtime bun");
+        }
+        const compileTarget = resolvedCompileTarget ?? computeCompileTarget(options.compile, bundlePath, name);
+        await compileBundleWithBun(bundlePath, compileTarget);
+        compilePath = compileTarget;
+        if (!options.bundle) {
+          await fs3.rm(bundlePath).catch(() => {
+          });
+          bundlePath = void 0;
+        }
+      }
+    }
+  } finally {
+    if (templateTmpDir) {
+      await fs3.rm(outputPath, { force: true }).catch(() => {
+      });
+      await fs3.rmdir(templateTmpDir).catch(() => {
+      });
+      await fs3.rmdir(path3.dirname(templateTmpDir)).catch(() => {
+      });
+    }
+  }
+  return { outputPath: options.outputPath ?? outputPath, bundlePath, compilePath };
+}
+function stripBuildSources(definition) {
+  const { source: _source, sources: _sources, ...runtimeDefinition } = definition;
+  return runtimeDefinition;
+}
+function buildEmbeddedInvocation(invocation, definition) {
+  return {
+    serverRef: stableJsonStringify(definition),
+    runtime: invocation.runtime,
+    bundler: invocation.bundler,
+    timeoutMs: invocation.timeoutMs,
+    minify: invocation.minify,
+    includeTools: invocation.includeTools,
+    excludeTools: invocation.excludeTools,
+    bundle: typeof invocation.bundle === "boolean" ? invocation.bundle : void 0,
+    compile: invocation.compile
+  };
+}
+function resolveImplicitTemplateDir(serverName, definition) {
+  const hash = createHash("sha256").update(stableJsonStringify({ serverName, definition })).digest("hex").slice(0, 12);
+  return path3.join(process.cwd(), "tmp", "mcporter-cli", `${sanitizePathSegment(serverName) || "server"}-${hash}`);
+}
+function sanitizePathSegment(value) {
+  return value.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function applyToolFilters(tools, includeTools, excludeTools) {
+  if (includeTools && excludeTools) {
+    throw new Error("Internal error: both includeTools and excludeTools provided to generateCli.");
+  }
+  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.");
+  }
+  if (!includeTools && !excludeTools) {
+    return tools;
+  }
+  const toolMap = new Map(tools.map((tool) => [tool.name, tool]));
+  if (includeTools && includeTools.length > 0) {
+    const result = [];
+    const missing = [];
+    for (const name of includeTools) {
+      const match = toolMap.get(name);
+      if (match) {
+        result.push(match);
+      } else {
+        missing.push(name);
+      }
+    }
+    if (missing.length > 0) {
+      throw new Error(`Requested tools not found on server: ${missing.join(", ")}. Available tools: ${tools.map((tool) => tool.name).join(", ")}`);
+    }
+    if (result.length === 0) {
+      throw new Error("No tools remain after applying --include-tools filter.");
+    }
+    return result;
+  }
+  if (excludeTools && excludeTools.length > 0) {
+    const excludeSet = new Set(excludeTools);
+    const filtered = tools.filter((tool) => !excludeSet.has(tool.name));
+    if (filtered.length === 0) {
+      throw new Error(`All tools were excluded. Exclude list: ${[...excludeSet].join(", ")}. Available tools: ${tools.map((tool) => tool.name).join(", ")}`);
+    }
+    return filtered;
+  }
+  return tools;
+}
+var __test = { ...toolsTestHelpers, applyToolFilters };
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/generate/output.js
+async function performGenerateFromArtifact(metadata, request) {
+  const { outputPath, bundlePath, compilePath } = await generateCli(request);
+  if (metadata.artifact.kind === "binary" && compilePath) {
+    console.log(`Regenerated compiled CLI at ${compilePath}`);
+  } else if (metadata.artifact.kind === "bundle" && bundlePath) {
+    console.log(`Regenerated bundled CLI at ${bundlePath}`);
+  } else {
+    console.log(`Regenerated template at ${outputPath}`);
+  }
+}
+async function performGenerateFromRequest(request) {
+  const { outputPath, bundlePath, compilePath } = await generateCli(request);
+  if (request.outputPath || !bundlePath && !compilePath) {
+    console.log(`Generated CLI at ${outputPath}`);
+  }
+  if (bundlePath) {
+    console.log(`Bundled executable created at ${bundlePath}`);
+  }
+  if (compilePath) {
+    console.log(`Compiled executable created at ${compilePath}`);
+  }
+}
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/generate/server-utils.js
+function buildInlineServerDefinition(name, command, description) {
+  if (typeof command === "string") {
+    const url = normalizeHttpUrlCandidate(command) ?? command;
+    if (looksLikeHttpUrl(command)) {
+      return {
+        name,
+        description,
+        command: url
+      };
+    }
+    return {
+      name,
+      description,
+      command: {
+        kind: "http",
+        url: new URL(url)
+      },
+      source: { kind: "local", path: "<adhoc>" }
+    };
+  }
+  return {
+    name,
+    description,
+    command: {
+      kind: "stdio",
+      command: command.command,
+      args: command.args ?? []
+    },
+    source: { kind: "local", path: "<adhoc>" }
+  };
+}
+
+// node_modules/.pnpm/mcporter@0.12.3/node_modules/mcporter/dist/cli/generate-cli-runner.js
+async function handleGenerateCli(args, globalFlags) {
+  const parsed = parseGenerateFlags(args);
+  if (parsed.includeTools && parsed.excludeTools) {
+    throw new Error("--include-tools and --exclude-tools cannot be used together.");
+  }
+  if (parsed.includeTools && parsed.includeTools.length === 0) {
+    throw new Error("--include-tools requires at least one tool name.");
+  }
+  if (parsed.excludeTools && parsed.excludeTools.length === 0) {
+    throw new Error("--exclude-tools requires at least one tool name.");
+  }
+  if (parsed.from && (parsed.command || parsed.description || parsed.name)) {
+    throw new Error("--from cannot be combined with --command/--description/--name.");
+  }
+  if (parsed.dryRun && !parsed.from) {
+    throw new Error("--dry-run currently requires --from <artifact>.");
+  }
+  if (parsed.from) {
+    const metadata = await readCliMetadata(parsed.from);
+    const request = resolveGenerateRequestFromArtifact(parsed, metadata, globalFlags);
+    if (parsed.dryRun) {
+      const command = buildGenerateCliCommand({
+        serverRef: request.serverRef,
+        configPath: request.configPath,
+        rootDir: request.rootDir,
+        outputPath: request.outputPath,
+        bundle: request.bundle,
+        compile: request.compile,
+        runtime: request.runtime ?? "node",
+        timeoutMs: request.timeoutMs ?? 3e4,
+        minify: request.minify ?? false,
+        includeTools: request.includeTools,
+        excludeTools: request.excludeTools
+      }, metadata.server.definition, globalFlags);
+      console.log("Dry run \u2014 would execute:");
+      console.log(`  ${command}`);
+      return;
+    }
+    await performGenerateFromArtifact(metadata, request);
+    return;
+  }
+  const inferredName = parsed.name ?? (parsed.command ? inferNameFromCommand(parsed.command) : void 0);
+  const serverRef = parsed.server ?? (parsed.command && inferredName ? JSON.stringify(buildInlineServerDefinition(inferredName, parsed.command, parsed.description)) : void 0);
+  if (!serverRef) {
+    throw new Error("Provide --server with a definition or a command we can infer a name from (use --name to override).");
+  }
+  await performGenerateFromRequest({
+    serverRef,
+    configPath: globalFlags["--config"],
+    rootDir: globalFlags["--root"],
+    outputPath: parsed.output,
+    runtime: parsed.runtime,
+    bundler: parsed.bundler,
+    bundle: parsed.bundle,
+    timeoutMs: parsed.timeout,
+    compile: parsed.compile,
+    minify: parsed.minify ?? false,
+    includeTools: parsed.includeTools,
+    excludeTools: parsed.excludeTools
+  });
+}
+function printGenerateCliHelp() {
+  console.error([
+    "Usage: mcporter generate-cli [server | command | url] [flags]",
+    "",
+    "Targets:",
+    "  <server>                Use a configured server.",
+    "  <command|url>           Infer an inline stdio or HTTP server.",
+    "  --server <name|json>    Server name, HTTP URL, or JSON definition.",
+    "  --command <value>       Inline stdio command or HTTP URL.",
+    "  --from <artifact>       Regenerate from an existing generated CLI.",
+    "",
+    "Flags:",
+    "  --output <path>         Write the TypeScript template to a path.",
+    "  --bundle [path]         Emit a bundled JavaScript artifact.",
+    "  --compile [path]        Emit a Bun-compiled binary.",
+    "  --runtime node|bun      Runtime for generated code.",
+    "  --bundler rolldown|bun  Bundler for JavaScript output.",
+    "  --timeout <ms>          Discovery/call timeout in milliseconds.",
+    "  --minify / --no-minify  Toggle bundle minification.",
+    "  --include-tools a,b     Generate only these tools.",
+    "  --exclude-tools a,b     Omit these tools.",
+    "  --dry-run               Print regeneration command for --from."
+  ].join("\n"));
+}
+export {
+  handleGenerateCli,
+  printGenerateCliHelp
+};