@postmcp/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,828 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ALL_PRESETS: () => import_presets.ALL_PRESETS,
+  BUNDLED_PRESETS: () => BUNDLED_PRESETS,
+  PRESETS_BY_ID: () => import_presets.PRESETS_BY_ID,
+  Preset: () => import_presets.Preset,
+  buildClientConfigSnippet: () => buildClientConfigSnippet,
+  buildPresetAuthConfig: () => import_presets.buildPresetAuthConfig,
+  estimateSpecTokenSavings: () => estimateSpecTokenSavings,
+  exportCommand: () => exportCommand,
+  findStudioDir: () => findStudioDir,
+  generateCommand: () => generateCommand,
+  generatePythonProject: () => import_core6.generatePythonProject,
+  generateTypeScriptProject: () => import_core5.generateTypeScriptProject,
+  getClientConfigPath: () => getClientConfigPath,
+  getPreset: () => import_presets.getPreset,
+  getPresetCacheDir: () => getPresetCacheDir,
+  inspectCommand: () => inspectCommand,
+  listPresetsCommand: () => listPresetsCommand,
+  loadConfigFile: () => loadConfigFile,
+  loadEnvFile: () => loadEnvFile,
+  parseApiKeyFlag: () => parseApiKeyFlag,
+  parseHeaderFlags: () => parseHeaderFlags,
+  resolvePresetSpec: () => resolvePresetSpec,
+  runCommand: () => runCommand,
+  studioCommand: () => studioCommand,
+  syncAllPresets: () => syncAllPresets,
+  syncPresetsCommand: () => syncPresetsCommand,
+  waitForServer: () => waitForServer
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/commands/run.ts
+var import_core = require("@postmcp/core");
+
+// src/config/loader.ts
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var import_dotenv = __toESM(require("dotenv"));
+function loadEnvFile(envFilePath) {
+  if (envFilePath) {
+    const resolved = path.resolve(envFilePath);
+    if (fs.existsSync(resolved)) {
+      import_dotenv.default.config({ path: resolved });
+    }
+  } else {
+    const defaultEnv = path.resolve(process.cwd(), ".env");
+    if (fs.existsSync(defaultEnv)) {
+      import_dotenv.default.config({ path: defaultEnv });
+    }
+  }
+}
+function loadConfigFile(configPath) {
+  let targetPath = configPath ? path.resolve(configPath) : null;
+  if (!targetPath) {
+    const candidates = ["postmcp.config.json", "postmcp.json", ".postmcprc.json"];
+    for (const c of candidates) {
+      const candidatePath = path.resolve(process.cwd(), c);
+      if (fs.existsSync(candidatePath)) {
+        targetPath = candidatePath;
+        break;
+      }
+    }
+  }
+  if (targetPath && fs.existsSync(targetPath)) {
+    try {
+      const content = fs.readFileSync(targetPath, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return {};
+    }
+  }
+  return {};
+}
+function parseHeaderFlags(headers) {
+  if (!headers || !Array.isArray(headers)) return {};
+  const result = {};
+  for (const h of headers) {
+    const colonIdx = h.indexOf(":");
+    if (colonIdx !== -1) {
+      const key = h.slice(0, colonIdx).trim();
+      const val = h.slice(colonIdx + 1).trim();
+      if (key && val) {
+        result[key] = val;
+      }
+    }
+  }
+  return result;
+}
+function parseApiKeyFlag(apiKeyStr) {
+  if (!apiKeyStr) return void 0;
+  let location = "header";
+  let rest = apiKeyStr;
+  if (apiKeyStr.startsWith("query:")) {
+    location = "query";
+    rest = apiKeyStr.slice(6);
+  } else if (apiKeyStr.startsWith("header:")) {
+    location = "header";
+    rest = apiKeyStr.slice(7);
+  } else if (apiKeyStr.startsWith("cookie:")) {
+    location = "cookie";
+    rest = apiKeyStr.slice(7);
+  }
+  const eqIdx = rest.indexOf("=");
+  if (eqIdx !== -1) {
+    const name = rest.slice(0, eqIdx).trim();
+    const value = rest.slice(eqIdx + 1).trim();
+    if (name && value) {
+      return { name, value, in: location };
+    }
+  }
+  return void 0;
+}
+
+// src/presets/index.ts
+var fs2 = __toESM(require("fs"));
+var path2 = __toESM(require("path"));
+var os = __toESM(require("os"));
+var import_axios = __toESM(require("axios"));
+var import_presets = require("@postmcp/presets");
+var BUNDLED_PRESETS = import_presets.PRESETS_BY_ID;
+function getPresetCacheDir() {
+  try {
+    const dir = path2.join(os.homedir(), ".postmcp", "presets");
+    if (!fs2.existsSync(dir)) {
+      fs2.mkdirSync(dir, { recursive: true });
+    }
+    return dir;
+  } catch {
+    const fallbackDir = path2.join(os.tmpdir(), "postmcp-presets");
+    if (!fs2.existsSync(fallbackDir)) {
+      try {
+        fs2.mkdirSync(fallbackDir, { recursive: true });
+      } catch {
+      }
+    }
+    return fallbackDir;
+  }
+}
+async function resolvePresetSpec(presetIdOrAlias) {
+  const cleanId = presetIdOrAlias.replace(/^@/, "").toLowerCase().trim();
+  const preset = (0, import_presets.getPreset)(cleanId);
+  if (!preset) {
+    throw new Error(`Unknown preset '@${cleanId}'. Run 'postmcp presets list' to see all available presets.`);
+  }
+  const cacheDir = getPresetCacheDir();
+  const cacheFile = path2.join(cacheDir, `${cleanId}.json`);
+  if (fs2.existsSync(cacheFile)) {
+    return cacheFile;
+  }
+  if (preset.specUrl) {
+    try {
+      const res = await import_axios.default.get(preset.specUrl, { timeout: 8e3, responseType: "text" });
+      try {
+        fs2.writeFileSync(cacheFile, res.data, "utf-8");
+        return cacheFile;
+      } catch {
+        return res.data;
+      }
+    } catch {
+    }
+  }
+  if (preset.bundledSpec) {
+    try {
+      fs2.writeFileSync(cacheFile, JSON.stringify(preset.bundledSpec, null, 2), "utf-8");
+      return cacheFile;
+    } catch {
+      return preset.bundledSpec;
+    }
+  }
+  if (preset.specUrl) {
+    return preset.specUrl;
+  }
+  throw new Error(`Preset '@${cleanId}' has no specification available.`);
+}
+async function syncAllPresets() {
+  const synced = [];
+  const cacheDir = getPresetCacheDir();
+  for (const preset of import_presets.ALL_PRESETS) {
+    const filePath = path2.join(cacheDir, `${preset.id}.json`);
+    let wrote = false;
+    if (preset.specUrl) {
+      try {
+        const res = await import_axios.default.get(preset.specUrl, { timeout: 8e3, responseType: "text" });
+        fs2.writeFileSync(filePath, res.data, "utf-8");
+        wrote = true;
+      } catch {
+      }
+    }
+    if (!wrote && preset.bundledSpec) {
+      try {
+        fs2.writeFileSync(filePath, JSON.stringify(preset.bundledSpec, null, 2), "utf-8");
+        wrote = true;
+      } catch {
+      }
+    }
+    if (wrote) {
+      synced.push(preset.id);
+    }
+  }
+  return synced;
+}
+
+// src/commands/run.ts
+var import_picocolors = __toESM(require("picocolors"));
+async function runCommand(specArg, options) {
+  loadEnvFile(options.envFile);
+  const fileConfig = loadConfigFile(options.config);
+  let specPath = specArg || fileConfig.spec;
+  if (!specPath) {
+    console.error(import_picocolors.default.red("Error: No OpenAPI spec provided. Usage: postmcp run <spec-path-or-url-or-@preset>"));
+    process.exit(1);
+    return;
+  }
+  let preset = void 0;
+  if (typeof specPath === "string" && specPath.startsWith("@")) {
+    preset = (0, import_presets.getPreset)(specPath);
+    try {
+      specPath = await resolvePresetSpec(specPath);
+    } catch (err) {
+      console.error(import_picocolors.default.red(`Error resolving preset: ${err.message}`));
+      process.exit(1);
+      return;
+    }
+  }
+  let parsedSpec;
+  try {
+    parsedSpec = await (0, import_core.parseOpenAPI)(specPath);
+  } catch (err) {
+    console.error(import_picocolors.default.red(`Failed to parse OpenAPI specification: ${err.message}`));
+    process.exit(1);
+    return;
+  }
+  if (preset && preset.macros && preset.macros.length > 0) {
+    parsedSpec.macros = [...parsedSpec.macros || [], ...preset.macros];
+  }
+  if (fileConfig.macros && fileConfig.macros.length > 0) {
+    parsedSpec.macros = [...parsedSpec.macros || [], ...fileConfig.macros];
+  }
+  if (fileConfig.enabledOperations && Object.keys(fileConfig.enabledOperations).length > 0) {
+    parsedSpec.operations = parsedSpec.operations.filter(
+      (op) => fileConfig.enabledOperations[op.id] !== false
+    );
+  }
+  const cliHeaders = parseHeaderFlags(options.header);
+  const cliApiKey = parseApiKeyFlag(options.apiKey);
+  const presetAuthConfig = preset ? (0, import_presets.buildPresetAuthConfig)(preset, process.env) : {};
+  const authConfig = {
+    headers: { ...presetAuthConfig.headers, ...fileConfig.auth?.headers, ...cliHeaders },
+    bearerToken: options.bearer || fileConfig.auth?.bearerToken || presetAuthConfig.bearerToken || process.env.API_KEY || process.env.BEARER_TOKEN,
+    apiKey: cliApiKey || fileConfig.auth?.apiKey || presetAuthConfig.apiKey,
+    basicAuth: fileConfig.auth?.basicAuth || presetAuthConfig.basicAuth,
+    securitySchemes: {
+      ...presetAuthConfig.securitySchemes,
+      ...fileConfig.auth?.securitySchemes
+    },
+    allowedExternalHosts: fileConfig.auth?.allowedExternalHosts,
+    allowCrossOriginAuth: fileConfig.auth?.allowCrossOriginAuth
+  };
+  const transport = options.transport || fileConfig.transport || (options.port ? "http" : "stdio");
+  const resolvedBaseUrl = options.baseUrl || fileConfig.baseUrl || process.env.BASE_URL || (parsedSpec.servers.length > 0 ? parsedSpec.servers[0].url : preset?.defaultBaseUrl);
+  const isJit = options.jit !== void 0 ? options.jit : fileConfig.jit !== void 0 ? fileConfig.jit : void 0;
+  const isDryRun = options.dryRun !== void 0 ? options.dryRun : fileConfig.dryRun;
+  const isTokenDiet = options.tokenDiet !== void 0 ? options.tokenDiet : fileConfig.tokenDiet?.enabled !== false;
+  const maxTokens = options.maxTokens ? parseInt(options.maxTokens, 10) : fileConfig.tokenDiet?.maxTokens || 2500;
+  const pathFieldMasks = {};
+  if (preset?.fieldMasks) {
+    for (const fm of preset.fieldMasks) {
+      pathFieldMasks[fm.path] = fm.fields;
+    }
+  }
+  if (fileConfig.fieldMasks) {
+    Object.assign(pathFieldMasks, fileConfig.fieldMasks);
+  }
+  const serverOptions = {
+    spec: parsedSpec,
+    baseUrl: resolvedBaseUrl,
+    auth: authConfig,
+    jit: isJit,
+    dryRun: isDryRun,
+    tokenDiet: {
+      enabled: isTokenDiet,
+      maxTokens,
+      pathFieldMasks: isTokenDiet && Object.keys(pathFieldMasks).length > 0 ? pathFieldMasks : void 0,
+      convertToMarkdownTable: fileConfig.tokenDiet?.convertToMarkdownTable !== false
+    },
+    serverName: parsedSpec.title,
+    serverVersion: parsedSpec.version
+  };
+  if (transport === "http") {
+    const port = options.port ? parseInt(options.port, 10) : fileConfig.port || 3e3;
+    const host = options.host || "localhost";
+    const { url } = await (0, import_core.startHttpServer)({
+      ...serverOptions,
+      port,
+      host
+    });
+    console.log(import_picocolors.default.green(`PostMCP Streamable HTTP server listening at: ${import_picocolors.default.bold(url)}`));
+    console.log(import_picocolors.default.dim(`  Service: ${parsedSpec.title} (v${parsedSpec.version}) | Endpoints: ${parsedSpec.operations.length}`));
+    if (isDryRun) {
+      console.log(import_picocolors.default.yellow(`  Mode: DRY-RUN SIMULATION (Mutations simulated, no real side effects)`));
+    }
+  } else {
+    await (0, import_core.startStdioServer)(serverOptions);
+  }
+}
+
+// src/commands/inspect.ts
+var import_core2 = require("@postmcp/core");
+var import_cli_table3 = __toESM(require("cli-table3"));
+var import_picocolors2 = __toESM(require("picocolors"));
+function estimateSpecTokenSavings(spec) {
+  const rawTokensPerOp = spec.operations.map((op) => {
+    const descLen = (op.description || op.summary || "").length;
+    const schemaLen = JSON.stringify(op.inputSchema || {}).length;
+    return Math.ceil((descLen + schemaLen + 50) / 4);
+  });
+  const totalRawToolTokens = rawTokensPerOp.reduce((a, b) => a + b, 0);
+  const avgOpTokens = spec.operations.length > 0 ? Math.ceil(totalRawToolTokens / spec.operations.length) : 0;
+  const jitPromptTokens = 120 + Math.min(spec.operations.length, 5) * Math.ceil(avgOpTokens * 0.4);
+  const raw = Math.max(totalRawToolTokens, 200);
+  const optimized = Math.min(raw, jitPromptTokens);
+  const savingsPct = Math.max(15, Math.round((raw - optimized) / raw * 100));
+  return {
+    rawTokens: raw,
+    optimizedTokens: optimized,
+    savingsPct
+  };
+}
+async function inspectCommand(specArg, options) {
+  let specPath = specArg;
+  if (!specPath) {
+    console.error(import_picocolors2.default.red("Error: No OpenAPI spec provided. Usage: postmcp inspect <spec-path-or-url-or-@preset>"));
+    process.exit(1);
+    return;
+  }
+  let preset = void 0;
+  if (typeof specPath === "string" && specPath.startsWith("@")) {
+    preset = (0, import_presets.getPreset)(specPath);
+    try {
+      specPath = await resolvePresetSpec(specPath);
+    } catch (err) {
+      console.error(import_picocolors2.default.red(`Error resolving preset: ${err.message}`));
+      process.exit(1);
+      return;
+    }
+  }
+  let spec;
+  try {
+    spec = await (0, import_core2.parseOpenAPI)(specPath);
+    if (preset && preset.macros && preset.macros.length > 0) {
+      spec.macros = [...spec.macros || [], ...preset.macros];
+    }
+  } catch (err) {
+    console.error(import_picocolors2.default.red(`Failed to parse specification: ${err.message}`));
+    process.exit(1);
+    return;
+  }
+  if (options.json) {
+    console.log(JSON.stringify(spec, null, 2));
+    return;
+  }
+  const tokenMetrics = estimateSpecTokenSavings(spec);
+  console.log();
+  console.log(import_picocolors2.default.bold(import_picocolors2.default.cyan(`PostMCP API Inspection: ${spec.title} (v${spec.version})`)));
+  if (spec.description) {
+    console.log(import_picocolors2.default.dim(spec.description.slice(0, 120) + (spec.description.length > 120 ? "..." : "")));
+  }
+  console.log();
+  const overviewTable = new import_cli_table3.default({
+    head: [import_picocolors2.default.bold("Metric"), import_picocolors2.default.bold("Value")],
+    colWidths: [25, 55]
+  });
+  const totalOps = spec.operations.length;
+  const methodsCount = {};
+  const riskCounts = { READ_ONLY: 0, MUTATION: 0, CRITICAL: 0 };
+  for (const op of spec.operations) {
+    const m = op.method.toUpperCase();
+    methodsCount[m] = (methodsCount[m] || 0) + 1;
+    riskCounts[op.riskTier] = (riskCounts[op.riskTier] || 0) + 1;
+  }
+  const methodsStr = Object.entries(methodsCount).map(([m, c]) => `${m}: ${c}`).join(" | ");
+  const defaultUrl = spec.servers.length > 0 ? spec.servers[0].url : "None declared";
+  const secSchemes = Object.keys(spec.securitySchemes).join(", ") || "None declared";
+  const recommendedJit = totalOps > 20 ? import_picocolors2.default.green("Yes (Dynamic JIT routing recommended)") : import_picocolors2.default.blue("No (Static direct tools)");
+  const savingsDisplay = import_picocolors2.default.green(`~${tokenMetrics.savingsPct}% (${tokenMetrics.rawTokens.toLocaleString()} \u2192 ${tokenMetrics.optimizedTokens.toLocaleString()} tokens)`);
+  overviewTable.push(
+    ["Total Endpoints", `${totalOps} operations`],
+    ["HTTP Methods", methodsStr],
+    ["Base URL", defaultUrl],
+    ["Security Schemes", secSchemes],
+    ["JIT Router Mode", recommendedJit],
+    ["Est. Token Savings", savingsDisplay],
+    ["Macros / Workflows", `${spec.macros?.length || 0} composite macros`]
+  );
+  console.log(overviewTable.toString());
+  console.log();
+  console.log(import_picocolors2.default.bold("Token Diet & Context Optimization Preview:"));
+  console.log(`  \u25CF Full Static Tool Declarations: ~${tokenMetrics.rawTokens.toLocaleString()} tokens`);
+  console.log(`  \u25CF PostMCP JIT + Token Diet:      ~${tokenMetrics.optimizedTokens.toLocaleString()} tokens`);
+  console.log(`  \u25CF Context Window Savings:        ${import_picocolors2.default.bold(import_picocolors2.default.green(`~${tokenMetrics.savingsPct}% saved`))}`);
+  console.log();
+  console.log(import_picocolors2.default.bold("Safety & Risk Tier Breakdown:"));
+  console.log(`  ${import_picocolors2.default.green("\u25CF READ_ONLY")}:  ${riskCounts.READ_ONLY} endpoints (Safe for autonomous exploration)`);
+  console.log(`  ${import_picocolors2.default.yellow("\u25CF MUTATION")}:   ${riskCounts.MUTATION} endpoints (Creates or updates data)`);
+  console.log(`  ${import_picocolors2.default.red("\u25CF CRITICAL")}:   ${riskCounts.CRITICAL} endpoints (Destructive actions / simulated in dry-run)`);
+  console.log();
+  console.log(import_picocolors2.default.bold(`Operations List (Showing first 10 of ${totalOps}):`));
+  const opTable = new import_cli_table3.default({
+    head: [import_picocolors2.default.bold("Tool Name (ID)"), import_picocolors2.default.bold("Method"), import_picocolors2.default.bold("Path"), import_picocolors2.default.bold("Risk Tier")],
+    colWidths: [22, 10, 32, 14]
+  });
+  const sampleOps = spec.operations.slice(0, 10);
+  for (const op of sampleOps) {
+    const tierColor = op.riskTier === "READ_ONLY" ? import_picocolors2.default.green(op.riskTier) : op.riskTier === "CRITICAL" ? import_picocolors2.default.red(op.riskTier) : import_picocolors2.default.yellow(op.riskTier);
+    opTable.push([op.id, op.method.toUpperCase(), op.path, tierColor]);
+  }
+  console.log(opTable.toString());
+  if (totalOps > 10) {
+    console.log(import_picocolors2.default.dim(`  ... and ${totalOps - 10} more endpoints.`));
+  }
+  console.log();
+}
+
+// src/commands/generate.ts
+var fs3 = __toESM(require("fs"));
+var path3 = __toESM(require("path"));
+var import_core3 = require("@postmcp/core");
+var import_picocolors3 = __toESM(require("picocolors"));
+async function generateCommand(specArg, options) {
+  let specPath = specArg;
+  if (!specPath) {
+    console.error(import_picocolors3.default.red("Error: No OpenAPI spec provided. Usage: postmcp generate <spec-path-or-url-or-@preset> --target <python|typescript>"));
+    process.exit(1);
+    return;
+  }
+  if (typeof specPath === "string" && specPath.startsWith("@")) {
+    try {
+      specPath = await resolvePresetSpec(specPath);
+    } catch (err) {
+      console.error(import_picocolors3.default.red(`Error resolving preset: ${err.message}`));
+      process.exit(1);
+      return;
+    }
+  }
+  let spec;
+  try {
+    spec = await (0, import_core3.parseOpenAPI)(specPath);
+  } catch (err) {
+    console.error(import_picocolors3.default.red(`Failed to parse specification: ${err.message}`));
+    process.exit(1);
+    return;
+  }
+  const rawLang = (options.lang || options.target || "ts").toLowerCase();
+  let targetLang;
+  if (rawLang === "ts" || rawLang === "typescript") {
+    targetLang = "ts";
+  } else if (rawLang === "py" || rawLang === "python") {
+    targetLang = "py";
+  } else {
+    console.error(import_picocolors3.default.red(`Unsupported language '${rawLang}'. Supported languages: 'ts', 'py'.`));
+    process.exit(1);
+    return;
+  }
+  const outDir = path3.resolve(options.out || `./${spec.title.toLowerCase().replace(/[^a-z0-9]/g, "-")}-mcp`);
+  console.log(import_picocolors3.default.cyan(`Generating standalone ${import_picocolors3.default.bold(targetLang.toUpperCase())} MCP server for '${spec.title}'...`));
+  const project = targetLang === "ts" ? (0, import_core3.generateTypeScriptProject)(spec) : (0, import_core3.generatePythonProject)(spec);
+  if (!fs3.existsSync(outDir)) {
+    fs3.mkdirSync(outDir, { recursive: true });
+  }
+  for (const [relativePath, content] of Object.entries(project.files)) {
+    const filePath = path3.join(outDir, relativePath);
+    const parentDir = path3.dirname(filePath);
+    if (!fs3.existsSync(parentDir)) {
+      fs3.mkdirSync(parentDir, { recursive: true });
+    }
+    fs3.writeFileSync(filePath, content, "utf-8");
+    console.log(`  ${import_picocolors3.default.green("+")} ${relativePath}`);
+  }
+  console.log();
+  console.log(import_picocolors3.default.green(`Standalone MCP server successfully generated at:`));
+  console.log(`  ${import_picocolors3.default.bold(outDir)}`);
+  console.log();
+  console.log(import_picocolors3.default.dim("Next steps:"));
+  if (targetLang === "ts") {
+    console.log(`  cd ${path3.relative(process.cwd(), outDir) || "."}`);
+    console.log("  npm install");
+    console.log("  npm run build");
+    console.log("  npm start");
+  } else {
+    console.log(`  cd ${path3.relative(process.cwd(), outDir) || "."}`);
+    console.log("  pip install -r requirements.txt");
+    console.log("  python server.py");
+  }
+}
+
+// src/commands/export.ts
+var fs4 = __toESM(require("fs"));
+var path4 = __toESM(require("path"));
+var os2 = __toESM(require("os"));
+var import_core4 = require("@postmcp/core");
+var import_picocolors4 = __toESM(require("picocolors"));
+function getClientConfigPath(client) {
+  const home = os2.homedir();
+  if (client === "cursor") {
+    return path4.join(process.cwd(), ".cursor", "mcp.json");
+  }
+  if (client === "claude") {
+    if (process.platform === "darwin") {
+      return path4.join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
+    }
+    if (process.platform === "win32") {
+      return path4.join(process.env.APPDATA || path4.join(home, "AppData", "Roaming"), "Claude", "claude_desktop_config.json");
+    }
+    return path4.join(home, ".config", "Claude", "claude_desktop_config.json");
+  }
+  if (client === "windsurf") {
+    return path4.join(home, ".codeium", "windsurf", "mcp_config.json");
+  }
+  return path4.join(process.cwd(), "mcp.json");
+}
+function buildClientConfigSnippet(serverKey, specPath, options) {
+  const env = {};
+  if (options.bearer) {
+    env["API_KEY"] = options.bearer;
+  }
+  if (options.baseUrl) {
+    env["BASE_URL"] = options.baseUrl;
+  }
+  if (options.env) {
+    for (const e of options.env) {
+      const [k, v] = e.split("=");
+      if (k && v) env[k] = v;
+    }
+  }
+  return {
+    mcpServers: {
+      [serverKey]: {
+        command: "npx",
+        args: ["-y", "postmcp", "run", specPath],
+        env: Object.keys(env).length > 0 ? env : void 0
+      }
+    }
+  };
+}
+async function exportCommand(specArg, options) {
+  let specPath = specArg;
+  if (!specPath) {
+    console.error(import_picocolors4.default.red("Error: No OpenAPI spec provided. Usage: postmcp export <spec-path-or-url-or-@preset> --target cursor|claude|windsurf|all"));
+    process.exit(1);
+  }
+  let serverKey = "api-server";
+  if (specPath.startsWith("@")) {
+    serverKey = specPath.replace(/^@/, "").toLowerCase();
+  } else {
+    try {
+      const parsed = await (0, import_core4.parseOpenAPI)(specPath);
+      serverKey = parsed.title.toLowerCase().replace(/[^a-z0-9]/g, "-") || "api-server";
+    } catch {
+      serverKey = "api-server";
+    }
+  }
+  const selectedTarget = (options.client || options.target || "all").toLowerCase();
+  const clientsToExport = selectedTarget === "all" ? ["cursor", "claude", "windsurf"] : [selectedTarget];
+  console.log(import_picocolors4.default.bold(import_picocolors4.default.cyan(`PostMCP 1-Click Client Configuration Exporter`)));
+  console.log();
+  for (const c of clientsToExport) {
+    const configPath = getClientConfigPath(c);
+    const snippet = buildClientConfigSnippet(serverKey, specPath, options);
+    const formattedSnippet = JSON.stringify(snippet, null, 2);
+    console.log(import_picocolors4.default.bold(import_picocolors4.default.green(`\u25B6 ${c.toUpperCase()} (${c === "cursor" ? "Project Local" : "Global Client"})`)));
+    console.log(import_picocolors4.default.dim(`  Config path: ${configPath}`));
+    console.log();
+    console.log(import_picocolors4.default.gray(formattedSnippet));
+    console.log();
+    if (options.write) {
+      try {
+        let existingConfig = {};
+        if (fs4.existsSync(configPath)) {
+          const raw = fs4.readFileSync(configPath, "utf-8");
+          existingConfig = JSON.parse(raw);
+        }
+        existingConfig.mcpServers = existingConfig.mcpServers || {};
+        existingConfig.mcpServers[serverKey] = snippet.mcpServers[serverKey];
+        const parentDir = path4.dirname(configPath);
+        if (!fs4.existsSync(parentDir)) {
+          fs4.mkdirSync(parentDir, { recursive: true });
+        }
+        fs4.writeFileSync(configPath, JSON.stringify(existingConfig, null, 2), "utf-8");
+        console.log(import_picocolors4.default.green(`  Successfully merged and written to ${configPath}`));
+      } catch (err) {
+        console.error(import_picocolors4.default.red(`  Failed to write to ${configPath}: ${err.message}`));
+      }
+      console.log();
+    }
+  }
+  if (!options.write) {
+    console.log(import_picocolors4.default.dim(`Tip: Pass '--write' to automatically install this configuration into your client settings.`));
+  }
+}
+
+// src/commands/presets.ts
+var import_cli_table32 = __toESM(require("cli-table3"));
+var import_picocolors5 = __toESM(require("picocolors"));
+async function listPresetsCommand(categoryOrQuery) {
+  console.log();
+  console.log(import_picocolors5.default.bold(import_picocolors5.default.cyan(`PostMCP Presets Catalog (${import_presets.ALL_PRESETS.length} Curated Developer APIs)`)));
+  console.log(import_picocolors5.default.dim(`Run any preset instantly using: postmcp run @<preset_id>`));
+  console.log();
+  let displayedPresets = import_presets.ALL_PRESETS;
+  if (categoryOrQuery) {
+    const q = categoryOrQuery.toLowerCase().trim();
+    displayedPresets = import_presets.ALL_PRESETS.filter((p) => {
+      return p.id.toLowerCase().includes(q) || p.name.toLowerCase().includes(q) || p.category.toLowerCase().includes(q) || p.tags && p.tags.some((t) => t.toLowerCase().includes(q));
+    });
+  }
+  const table = new import_cli_table32.default({
+    head: [import_picocolors5.default.bold("Preset ID"), import_picocolors5.default.bold("API Name"), import_picocolors5.default.bold("Category"), import_picocolors5.default.bold("Authentication"), import_picocolors5.default.bold("Run Command")],
+    colWidths: [14, 26, 22, 28, 26]
+  });
+  for (const meta of displayedPresets) {
+    table.push([
+      import_picocolors5.default.bold(import_picocolors5.default.magenta(`@${meta.id}`)),
+      meta.name,
+      meta.category,
+      import_picocolors5.default.dim(meta.authType),
+      import_picocolors5.default.green(`postmcp run @${meta.id}`)
+    ]);
+  }
+  console.log(table.toString());
+  console.log();
+  console.log(import_picocolors5.default.dim(`Total Presets: ${displayedPresets.length} of ${import_presets.ALL_PRESETS.length}`));
+  console.log(import_picocolors5.default.dim(`Run 'postmcp presets sync' to update offline cached schemas from GitHub.`));
+  console.log();
+}
+async function syncPresetsCommand() {
+  console.log(import_picocolors5.default.cyan(`Syncing latest OpenAPI schemas for all presets...`));
+  try {
+    const synced = await syncAllPresets();
+    console.log(import_picocolors5.default.green(`Successfully synced ${synced.length} presets to local cache (~/.postmcp/presets/):`));
+    for (const id of synced) {
+      console.log(`  ${import_picocolors5.default.green("\u25CF")} @${id}`);
+    }
+  } catch (err) {
+    console.error(import_picocolors5.default.red(`Failed to sync presets: ${err.message}`));
+  }
+}
+
+// src/commands/studio.ts
+var path5 = __toESM(require("path"));
+var fs5 = __toESM(require("fs"));
+var import_node_module = require("module");
+var import_node_child_process = require("child_process");
+var import_open = __toESM(require("open"));
+var import_axios2 = __toESM(require("axios"));
+var import_picocolors6 = __toESM(require("picocolors"));
+function findStudioDir() {
+  try {
+    const customRequire = typeof import_node_module.createRequire !== "undefined" ? (0, import_node_module.createRequire)(__filename) : require;
+    const pkgPath = customRequire.resolve("@postmcp/studio/package.json");
+    if (fs5.existsSync(pkgPath)) {
+      return path5.dirname(pkgPath);
+    }
+  } catch {
+  }
+  const candidates = [
+    path5.resolve(__dirname, "..", "..", "studio"),
+    path5.resolve(__dirname, "..", "..", "..", "packages", "studio"),
+    path5.resolve(process.cwd(), "packages", "studio"),
+    path5.resolve(process.cwd(), "node_modules", "@postmcp", "studio")
+  ];
+  for (const candidate of candidates) {
+    if (fs5.existsSync(path5.join(candidate, "package.json"))) {
+      return candidate;
+    }
+  }
+  return path5.resolve(process.cwd(), "packages", "studio");
+}
+async function waitForServer(url, timeoutMs = 2e4) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    try {
+      const res = await import_axios2.default.get(url, { timeout: 1e3, validateStatus: () => true });
+      if (res.status >= 200 && res.status < 500) {
+        return true;
+      }
+    } catch {
+    }
+    await new Promise((r) => setTimeout(r, 400));
+  }
+  return false;
+}
+async function studioCommand(specArg, options = {}) {
+  const port = options.port || "3000";
+  const baseUrl = `http://localhost:${port}`;
+  const targetUrl = specArg ? `${baseUrl}?spec=${encodeURIComponent(specArg)}` : baseUrl;
+  const studioDir = findStudioDir();
+  console.log();
+  console.log(import_picocolors6.default.bold(import_picocolors6.default.cyan(`Starting PostMCP Visual Web Studio...`)));
+  console.log(`  Port: ${import_picocolors6.default.bold(import_picocolors6.default.green(port))}`);
+  console.log(`  Studio Dir: ${import_picocolors6.default.dim(studioDir)}`);
+  if (specArg) {
+    console.log(`  Initial Spec: ${import_picocolors6.default.dim(specArg)}`);
+  }
+  console.log();
+  let child = null;
+  if (fs5.existsSync(studioDir)) {
+    const isBuilt = fs5.existsSync(path5.join(studioDir, ".next"));
+    const isPnpm = fs5.existsSync(path5.join(studioDir, "..", "..", "pnpm-lock.yaml"));
+    const command = isPnpm ? "pnpm" : "npx";
+    const args = isPnpm ? isBuilt ? ["start", "--port", port] : ["dev", "--port", port] : isBuilt ? ["next", "start", "-p", port] : ["next", "dev", "-p", port];
+    try {
+      child = (0, import_node_child_process.spawn)(command, args, {
+        cwd: studioDir,
+        stdio: "inherit",
+        shell: true,
+        env: {
+          ...process.env,
+          PORT: port,
+          NEXT_PUBLIC_INITIAL_SPEC: specArg || "",
+          STUDIO_INITIAL_SPEC: specArg || "",
+          POSTMCP_WORKSPACE: process.cwd(),
+          WORKSPACE_CWD: process.cwd()
+        }
+      });
+      const cleanup = () => {
+        if (child) {
+          try {
+            child.kill("SIGINT");
+          } catch {
+          }
+        }
+      };
+      process.on("SIGINT", cleanup);
+      process.on("SIGTERM", cleanup);
+      process.on("exit", cleanup);
+    } catch (err) {
+      console.log(import_picocolors6.default.yellow(`  Note: Running in detached standalone mode: ${err.message}`));
+    }
+  }
+  const isReady = await waitForServer(baseUrl, 15e3);
+  if (isReady) {
+    console.log(import_picocolors6.default.green(`PostMCP Visual Web Studio ready at: ${import_picocolors6.default.bold(targetUrl)}`));
+  } else {
+    console.log(import_picocolors6.default.dim(`  Studio server starting at: ${targetUrl}`));
+  }
+  if (!options.noOpen) {
+    try {
+      await (0, import_open.default)(targetUrl);
+      console.log(import_picocolors6.default.dim(`Opening Web Studio in your default browser...`));
+    } catch {
+      console.log(import_picocolors6.default.dim(`Please open ${targetUrl} in your browser.`));
+    }
+  }
+  if (child) {
+    await new Promise((resolve4) => {
+      child?.on("close", () => resolve4());
+    });
+  }
+}
+
+// src/generators/typescript.ts
+var import_core5 = require("@postmcp/core");
+
+// src/generators/python.ts
+var import_core6 = require("@postmcp/core");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ALL_PRESETS,
+  BUNDLED_PRESETS,
+  PRESETS_BY_ID,
+  Preset,
+  buildClientConfigSnippet,
+  buildPresetAuthConfig,
+  estimateSpecTokenSavings,
+  exportCommand,
+  findStudioDir,
+  generateCommand,
+  generatePythonProject,
+  generateTypeScriptProject,
+  getClientConfigPath,
+  getPreset,
+  getPresetCacheDir,
+  inspectCommand,
+  listPresetsCommand,
+  loadConfigFile,
+  loadEnvFile,
+  parseApiKeyFlag,
+  parseHeaderFlags,
+  resolvePresetSpec,
+  runCommand,
+  studioCommand,
+  syncAllPresets,
+  syncPresetsCommand,
+  waitForServer
+});
+//# sourceMappingURL=index.js.map