specli 0.0.5 → 0.0.8

package/dist/src/cli/runtime/generated.js

@@ -0,0 +1,869 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/cli/runtime/body-flags.ts
+var exports_body_flags = {};
+__export(exports_body_flags, {
+  parseDotNotationFlags: () => parseDotNotationFlags,
+  generateBodyFlags: () => generateBodyFlags,
+  findMissingRequired: () => findMissingRequired
+});
+function generateBodyFlags(schema, reservedFlags) {
+  if (!schema || schema.type !== "object" || !schema.properties) {
+    return [];
+  }
+  const flags = [];
+  const requiredSet = new Set(schema.required ?? []);
+  collectFlags(schema.properties, [], requiredSet, flags, reservedFlags);
+  return flags;
+}
+function collectFlags(properties, pathPrefix, requiredAtRoot, out, reservedFlags) {
+  for (const [name, propSchema] of Object.entries(properties)) {
+    if (!name || typeof name !== "string")
+      continue;
+    if (!propSchema || typeof propSchema !== "object")
+      continue;
+    const path = [...pathPrefix, name];
+    const flagName = `--${path.join(".")}`;
+    if (reservedFlags.has(flagName))
+      continue;
+    const t = propSchema.type;
+    if (t === "object" && propSchema.properties) {
+      const nestedRequired = new Set(propSchema.required ?? []);
+      collectFlags(propSchema.properties, path, nestedRequired, out, reservedFlags);
+    } else if (t === "string" || t === "number" || t === "integer" || t === "boolean") {
+      const isRequired = pathPrefix.length === 0 ? requiredAtRoot.has(name) : false;
+      out.push({
+        flag: flagName,
+        path,
+        type: t,
+        description: propSchema.description ?? `Body field '${path.join(".")}'`,
+        required: isRequired
+      });
+    }
+  }
+}
+function parseDotNotationFlags(flagValues, flagDefs) {
+  const result = {};
+  for (const def of flagDefs) {
+    const dotKey = def.path.join(".");
+    const value = flagValues[dotKey];
+    if (value === undefined)
+      continue;
+    setNestedValue(result, def.path, value, def.type);
+  }
+  return result;
+}
+function setNestedValue(obj, path, value, type) {
+  let current = obj;
+  for (let i = 0;i < path.length - 1; i++) {
+    const key = path[i];
+    if (!(key in current) || typeof current[key] !== "object") {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  const finalKey = path[path.length - 1];
+  if (type === "boolean") {
+    current[finalKey] = true;
+  } else if (type === "integer") {
+    current[finalKey] = Number.parseInt(String(value), 10);
+  } else if (type === "number") {
+    current[finalKey] = Number(String(value));
+  } else {
+    current[finalKey] = String(value);
+  }
+}
+function findMissingRequired(flagValues, flagDefs) {
+  const missing = [];
+  for (const def of flagDefs) {
+    if (!def.required)
+      continue;
+    const dotKey = def.path.join(".");
+    if (flagValues[dotKey] === undefined) {
+      missing.push(dotKey);
+    }
+  }
+  return missing;
+}
+
+// src/cli/runtime/generated.ts
+import { Command } from "commander";
+
+// src/cli/runtime/auth/resolve.ts
+var BEARER_COMPATIBLE_KINDS = new Set([
+  "http-bearer",
+  "oauth2",
+  "openIdConnect"
+]);
+function resolveAuthScheme(authSchemes, required, inputs) {
+  if (inputs.flagAuthScheme)
+    return inputs.flagAuthScheme;
+  if (inputs.profileAuthScheme && authSchemes.some((s) => s.key === inputs.profileAuthScheme)) {
+    return inputs.profileAuthScheme;
+  }
+  if (inputs.embeddedAuthScheme && authSchemes.some((s) => s.key === inputs.embeddedAuthScheme)) {
+    return inputs.embeddedAuthScheme;
+  }
+  const alts = required.alternatives;
+  if (alts.length === 1 && alts[0]?.length === 1)
+    return alts[0][0]?.key;
+  if (authSchemes.length === 1)
+    return authSchemes[0]?.key;
+  if (inputs.hasStoredToken && alts.length > 0) {
+    for (const alt of alts) {
+      if (alt.length !== 1)
+        continue;
+      const key = alt[0]?.key;
+      const scheme = authSchemes.find((s) => s.key === key);
+      if (scheme && BEARER_COMPATIBLE_KINDS.has(scheme.kind)) {
+        return key;
+      }
+    }
+  }
+  return;
+}
+
+// src/cli/runtime/compat.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { parse as parseYaml } from "yaml";
+var isBun = typeof globalThis.Bun !== "undefined";
+async function readFileText(path) {
+  if (isBun) {
+    return Bun.file(path).text();
+  }
+  return readFileSync(path, "utf-8");
+}
+async function fileExists(path) {
+  if (isBun) {
+    return Bun.file(path).exists();
+  }
+  return existsSync(path);
+}
+function parseYamlContent(text) {
+  if (isBun) {
+    const { YAML } = globalThis.Bun;
+    return YAML.parse(text);
+  }
+  return parseYaml(text);
+}
+
+// src/cli/runtime/profile/secrets.ts
+var bunLiteral = "bun";
+function secretServiceForSpec(specId) {
+  return `specli:${specId}`;
+}
+function tokenSecretKey(specId, profile) {
+  return {
+    service: secretServiceForSpec(specId),
+    name: `profile:${profile}:token`
+  };
+}
+async function getToken(specId, profile) {
+  if (!isBun) {
+    return null;
+  }
+  const { secrets } = await import(bunLiteral);
+  const key = tokenSecretKey(specId, profile);
+  return await secrets.get({ service: key.service, name: key.name });
+}
+
+// src/cli/runtime/profile/store.ts
+function configDir() {
+  const home = process.env.HOME;
+  if (!home)
+    throw new Error("Missing HOME env var");
+  return `${home}/.config/specli`;
+}
+function configPathJson() {
+  return `${configDir()}/profiles.json`;
+}
+function configPathYaml() {
+  return `${configDir()}/profiles.yaml`;
+}
+async function readProfiles() {
+  const jsonPath = configPathJson();
+  const yamlPath = configPathYaml();
+  const jsonExists = await fileExists(jsonPath);
+  const yamlExists = await fileExists(yamlPath);
+  const filePath = jsonExists ? jsonPath : yamlExists ? yamlPath : null;
+  if (!filePath)
+    return { profiles: [] };
+  const text = await readFileText(filePath);
+  let parsed;
+  try {
+    parsed = parseYamlContent(text);
+  } catch {
+    parsed = JSON.parse(text);
+  }
+  const obj = parsed && typeof parsed === "object" ? parsed : {};
+  const profiles = Array.isArray(obj.profiles) ? obj.profiles : [];
+  return {
+    profiles: profiles.filter(Boolean),
+    defaultProfile: typeof obj.defaultProfile === "string" ? obj.defaultProfile : undefined
+  };
+}
+function getProfile(data, name) {
+  const wanted = name ?? data.defaultProfile;
+  if (!wanted)
+    return;
+  return data.profiles.find((p) => p?.name === wanted);
+}
+
+// src/cli/runtime/template.ts
+function extractTemplateVars(template) {
+  const out = [];
+  const re = /\{([^}]+)\}/g;
+  while (true) {
+    const match = re.exec(template);
+    if (!match)
+      break;
+    out.push((match[1] ?? "").trim());
+  }
+  return out.filter(Boolean);
+}
+function applyTemplate(template, vars, options) {
+  const encode = options?.encode ?? false;
+  return template.replace(/\{([^}]+)\}/g, (_, rawName) => {
+    const name = String(rawName).trim();
+    const value = vars[name];
+    if (typeof value !== "string") {
+      throw new Error(`Missing template variable: ${name}`);
+    }
+    return encode ? encodeURIComponent(value) : value;
+  });
+}
+
+// src/cli/runtime/server-url.ts
+function resolveServerUrl(input) {
+  const base = input.serverOverride || input.servers[0]?.url;
+  if (!base) {
+    throw new Error("No server URL found. Provide --server <url> or define servers in the OpenAPI spec.");
+  }
+  const names = extractTemplateVars(base);
+  if (!names.length)
+    return base;
+  const vars = {};
+  for (const name of names) {
+    const provided = input.serverVars[name];
+    if (typeof provided === "string") {
+      vars[name] = provided;
+      continue;
+    }
+    const match = input.servers.find((s) => s.url === base);
+    const v = match?.variables.find((x) => x.name === name);
+    if (typeof v?.default === "string") {
+      vars[name] = v.default;
+      continue;
+    }
+    throw new Error(`Missing server variable '${name}'. Provide --server-var ${name}=...`);
+  }
+  return applyTemplate(base, vars);
+}
+
+// src/cli/runtime/validate/ajv.ts
+import Ajv from "ajv";
+import addFormats from "ajv-formats";
+function createAjv() {
+  const ajv = new Ajv({
+    allErrors: true,
+    strict: false,
+    coerceTypes: false
+  });
+  addFormats(ajv);
+  return ajv;
+}
+// src/cli/runtime/validate/coerce.ts
+import { InvalidArgumentError } from "commander";
+function coerceValue(raw, type) {
+  if (type === "string" || type === "unknown")
+    return raw;
+  if (type === "boolean") {
+    if (raw === "true")
+      return true;
+    if (raw === "false")
+      return false;
+    throw new InvalidArgumentError(`Expected boolean, got '${raw}'`);
+  }
+  if (type === "integer") {
+    const n = Number.parseInt(raw, 10);
+    if (!Number.isFinite(n))
+      throw new InvalidArgumentError(`Expected integer, got '${raw}'`);
+    return n;
+  }
+  if (type === "number") {
+    const n = Number(raw);
+    if (!Number.isFinite(n))
+      throw new InvalidArgumentError(`Expected number, got '${raw}'`);
+    return n;
+  }
+  if (type === "object") {
+    try {
+      return JSON.parse(raw);
+    } catch {
+      throw new InvalidArgumentError(`Expected JSON object, got '${raw}'. Use --data/--file for complex bodies.`);
+    }
+  }
+  if (type === "array") {
+    return coerceArrayInput(raw, "string");
+  }
+  return raw;
+}
+function coerceArrayInput(raw, itemType) {
+  const trimmed = raw.trim();
+  if (!trimmed)
+    return [];
+  if (trimmed.startsWith("[")) {
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      throw new InvalidArgumentError(`Expected JSON array, got '${raw}'`);
+    }
+    if (!Array.isArray(parsed)) {
+      throw new InvalidArgumentError(`Expected JSON array, got '${raw}'`);
+    }
+    return parsed.map((v) => coerceValue(String(v), itemType));
+  }
+  return trimmed.split(",").map((s) => s.trim()).filter(Boolean).map((s) => coerceValue(s, itemType));
+}
+// src/cli/runtime/validate/error.ts
+function formatAjvErrors(errors) {
+  if (!errors?.length)
+    return "Invalid input";
+  return errors.map((e) => {
+    const path = e.instancePath || e.schemaPath || "";
+    if (e.keyword === "required" && e.params && typeof e.params === "object" && "missingProperty" in e.params) {
+      const missing = String(e.params.missingProperty);
+      const where = e.instancePath || "/";
+      return `${where} missing required property '${missing}'`.trim();
+    }
+    const msg = e.message || "invalid";
+    return `${path} ${msg}`.trim();
+  }).join(`
+`);
+}
+// src/cli/runtime/validate/schema.ts
+function deriveValidationSchemas(action) {
+  const query = { type: "object", properties: {}, required: [] };
+  const header = { type: "object", properties: {}, required: [] };
+  const cookie = { type: "object", properties: {}, required: [] };
+  for (const p of action.params) {
+    if (p.kind !== "flag")
+      continue;
+    const target = p.in === "query" ? query : p.in === "header" ? header : p.in === "cookie" ? cookie : undefined;
+    if (!target)
+      continue;
+    const schema = p.schema ?? (p.type === "unknown" ? {} : { type: p.type });
+    target.properties[p.name] = schema;
+    if (p.required) {
+      if (!target.required)
+        target.required = [];
+      target.required.push(p.name);
+    }
+  }
+  if (!query.required?.length)
+    delete query.required;
+  if (!header.required?.length)
+    delete header.required;
+  if (!cookie.required?.length)
+    delete cookie.required;
+  return {
+    querySchema: Object.keys(query.properties).length ? query : undefined,
+    headerSchema: Object.keys(header.properties).length ? header : undefined,
+    cookieSchema: Object.keys(cookie.properties).length ? cookie : undefined
+  };
+}
+// src/cli/runtime/request.ts
+function parseKeyValuePairs(pairs) {
+  const out = {};
+  for (const pair of pairs ?? []) {
+    const idx = pair.indexOf("=");
+    if (idx === -1)
+      throw new Error(`Invalid pair '${pair}', expected name=value`);
+    const name = pair.slice(0, idx).trim();
+    const value = pair.slice(idx + 1).trim();
+    if (!name)
+      throw new Error(`Invalid pair '${pair}', missing name`);
+    out[name] = value;
+  }
+  return out;
+}
+function pickAuthSchemeKey(action, globals) {
+  if (globals.auth)
+    return globals.auth;
+  const req = action.auth.alternatives;
+  if (req.length === 1 && req[0]?.length === 1) {
+    return req[0][0]?.key;
+  }
+  return;
+}
+function applyAuth(headers, url, action, globals, authSchemes) {
+  const schemeKey = pickAuthSchemeKey(action, globals);
+  if (!schemeKey)
+    return { headers, url };
+  const scheme = authSchemes.find((s) => s.key === schemeKey);
+  if (!scheme) {
+    throw new Error(`Unknown auth scheme '${schemeKey}'. Available: ${authSchemes.map((s) => s.key).join(", ")}`);
+  }
+  if (scheme.kind === "http-bearer" || scheme.kind === "oauth2" || scheme.kind === "openIdConnect") {
+    const token = globals.bearerToken ?? globals.oauthToken;
+    if (!token)
+      throw new Error("Missing token. Provide --bearer-token <token>.");
+    headers.set("Authorization", `Bearer ${token}`);
+    return { headers, url };
+  }
+  if (scheme.kind === "http-basic") {
+    if (!globals.username)
+      throw new Error("Missing --username for basic auth");
+    if (!globals.password)
+      throw new Error("Missing --password for basic auth");
+    const raw = `${globals.username}:${globals.password}`;
+    const encoded = Buffer.from(raw, "utf8").toString("base64");
+    headers.set("Authorization", `Basic ${encoded}`);
+    return { headers, url };
+  }
+  if (scheme.kind === "api-key") {
+    if (!scheme.name)
+      throw new Error(`apiKey scheme '${scheme.key}' missing name`);
+    if (!scheme.in)
+      throw new Error(`apiKey scheme '${scheme.key}' missing location`);
+    if (!globals.apiKey)
+      throw new Error("Missing --api-key for apiKey auth");
+    if (scheme.in === "header") {
+      headers.set(scheme.name, globals.apiKey);
+    }
+    if (scheme.in === "query") {
+      url.searchParams.set(scheme.name, globals.apiKey);
+    }
+    if (scheme.in === "cookie") {
+      const existing = headers.get("Cookie");
+      const part = `${scheme.name}=${globals.apiKey}`;
+      headers.set("Cookie", existing ? `${existing}; ${part}` : part);
+    }
+    return { headers, url };
+  }
+  return { headers, url };
+}
+async function buildRequest(input) {
+  const defaultProfileName = "default";
+  const profilesFile = await readProfiles();
+  const profile = getProfile(profilesFile, defaultProfileName);
+  const embedded = input.embeddedDefaults;
+  const embeddedServerVars = parseKeyValuePairs(embedded?.serverVars);
+  const cliServerVars = parseKeyValuePairs(input.globals.serverVar);
+  const serverVars = { ...embeddedServerVars, ...cliServerVars };
+  const serverUrl = resolveServerUrl({
+    serverOverride: input.globals.server ?? profile?.server ?? embedded?.server,
+    servers: input.servers,
+    serverVars
+  });
+  const pathVars = {};
+  for (let i = 0;i < input.action.positionals.length; i++) {
+    const pos = input.action.positionals[i];
+    const raw = input.action.pathArgs[i];
+    const value = input.positionalValues[i];
+    if (typeof raw === "string" && typeof value === "string") {
+      pathVars[raw] = value;
+    }
+    if (pos?.name && typeof value === "string") {
+      pathVars[pos.name] = value;
+    }
+  }
+  const path = applyTemplate(input.action.path, pathVars, { encode: true });
+  const baseUrl = serverUrl.endsWith("/") ? serverUrl : `${serverUrl}/`;
+  const relativePath = path.startsWith("/") ? path.slice(1) : path;
+  const url = new URL(relativePath, baseUrl);
+  const headers = new Headers;
+  const queryValues = {};
+  const headerValues = {};
+  const cookieValues = {};
+  for (const p of input.action.params) {
+    if (p.kind !== "flag")
+      continue;
+    const optValue = input.flagValues[optionKeyFromFlag(p.flag)];
+    if (typeof optValue === "undefined")
+      continue;
+    if (p.in === "query") {
+      queryValues[p.name] = optValue;
+    }
+    if (p.in === "header") {
+      headerValues[p.name] = optValue;
+    }
+    if (p.in === "cookie") {
+      cookieValues[p.name] = optValue;
+    }
+  }
+  const schemas = deriveValidationSchemas(input.action);
+  const ajv2 = createAjv();
+  if (schemas.querySchema) {
+    const validate = ajv2.compile(schemas.querySchema);
+    if (!validate(queryValues)) {
+      throw new Error(formatAjvErrors(validate.errors));
+    }
+  }
+  if (schemas.headerSchema) {
+    const validate = ajv2.compile(schemas.headerSchema);
+    if (!validate(headerValues)) {
+      throw new Error(formatAjvErrors(validate.errors));
+    }
+  }
+  if (schemas.cookieSchema) {
+    const validate = ajv2.compile(schemas.cookieSchema);
+    if (!validate(cookieValues)) {
+      throw new Error(formatAjvErrors(validate.errors));
+    }
+  }
+  for (const [name, value] of Object.entries(queryValues)) {
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        url.searchParams.append(name, String(item));
+      }
+      continue;
+    }
+    url.searchParams.set(name, String(value));
+  }
+  for (const [name, value] of Object.entries(headerValues)) {
+    headers.set(name, String(value));
+  }
+  for (const [name, value] of Object.entries(cookieValues)) {
+    const existing = headers.get("Cookie");
+    const part = `${name}=${String(value)}`;
+    headers.set("Cookie", existing ? `${existing}; ${part}` : part);
+  }
+  let body;
+  if (input.action.requestBody) {
+    const bodyFlagDefs = input.bodyFlagDefs ?? [];
+    const hasBodyFlags = bodyFlagDefs.some((def) => {
+      const dotKey = def.path.join(".");
+      return input.flagValues[dotKey] !== undefined;
+    });
+    const contentType = input.action.requestBody.preferredContentType;
+    if (contentType)
+      headers.set("Content-Type", contentType);
+    const schema2 = input.action.requestBodySchema;
+    const requiredFields = bodyFlagDefs.filter((d) => d.required);
+    if (!hasBodyFlags) {
+      if (requiredFields.length > 0) {
+        const flagList = requiredFields.map((d) => `--${d.path.join(".")}`);
+        throw new Error(`Required: ${flagList.join(", ")}`);
+      }
+      if (input.action.requestBody.required) {
+        body = "{}";
+      }
+    } else {
+      if (!contentType?.includes("json")) {
+        throw new Error("Body field flags are only supported for JSON request bodies.");
+      }
+      const { findMissingRequired: findMissingRequired2, parseDotNotationFlags: parseDotNotationFlags2 } = await Promise.resolve().then(() => exports_body_flags);
+      const missing = findMissingRequired2(input.flagValues, bodyFlagDefs);
+      if (missing.length > 0) {
+        const missingFlags = missing.map((m) => `--${m}`).join(", ");
+        throw new Error(`Missing required fields: ${missingFlags}`);
+      }
+      const built = parseDotNotationFlags2(input.flagValues, bodyFlagDefs);
+      if (schema2) {
+        const validate = ajv2.compile(schema2);
+        if (!validate(built)) {
+          throw new Error(formatAjvErrors(validate.errors));
+        }
+      }
+      body = JSON.stringify(built);
+    }
+  }
+  const storedToken = profile?.name ? await getToken(input.specId, profile.name) : null;
+  const resolvedAuthScheme = resolveAuthScheme(input.authSchemes, input.action.auth, {
+    flagAuthScheme: input.globals.auth,
+    profileAuthScheme: profile?.authScheme,
+    embeddedAuthScheme: embedded?.auth,
+    hasStoredToken: Boolean(storedToken)
+  });
+  const tokenFromProfile = resolvedAuthScheme ? storedToken : null;
+  const globalsWithProfileAuth = {
+    ...input.globals,
+    auth: resolvedAuthScheme,
+    bearerToken: input.globals.bearerToken ?? input.globals.oauthToken ?? tokenFromProfile ?? undefined
+  };
+  const final = applyAuth(headers, url, input.action, globalsWithProfileAuth, input.authSchemes);
+  const req = new Request(final.url.toString(), {
+    method: input.action.method,
+    headers: final.headers,
+    body
+  });
+  const curl = buildCurl(req, body);
+  return { request: req, curl };
+}
+function buildCurl(req, body) {
+  const parts = ["curl", "-sS", "-X", req.method];
+  for (const [k, v] of req.headers.entries()) {
+    parts.push("-H", shellQuote(`${k}: ${v}`));
+  }
+  if (typeof body === "string") {
+    parts.push("--data", shellQuote(body));
+  }
+  parts.push(shellQuote(req.url));
+  return parts.join(" ");
+}
+function shellQuote(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function optionKeyFromFlag(flag) {
+  const name = flag.replace(/^--/, "");
+  return name.replace(/-([a-z])/g, (_, c) => String(c).toUpperCase());
+}
+
+// src/cli/runtime/execute.ts
+function formatError(message, resourceName, actionName) {
+  const helpCmd = resourceName ? `${resourceName} ${actionName} --help` : `${actionName} --help`;
+  return `${message}
+
+Run '${helpCmd}' to see available options.`;
+}
+async function execute(input) {
+  const { request, curl } = await buildRequest({
+    specId: input.specId,
+    action: input.action,
+    positionalValues: input.positionalValues,
+    flagValues: input.flagValues,
+    globals: input.globals,
+    servers: input.servers,
+    authSchemes: input.authSchemes,
+    embeddedDefaults: input.embeddedDefaults,
+    bodyFlagDefs: input.bodyFlagDefs
+  });
+  const res = await fetch(request);
+  const contentType = res.headers.get("content-type") ?? "";
+  const text = await res.text();
+  let body = text;
+  if (contentType.includes("json") && text) {
+    try {
+      body = JSON.parse(text);
+    } catch {}
+  }
+  return {
+    ok: res.ok,
+    status: res.status,
+    body,
+    curl
+  };
+}
+async function executeAction(input) {
+  const actionName = input.action.action;
+  const resourceName = input.resourceName;
+  try {
+    if (input.globals.curl) {
+      const { curl } = await buildRequest({
+        specId: input.specId,
+        action: input.action,
+        positionalValues: input.positionalValues,
+        flagValues: input.flagValues,
+        globals: input.globals,
+        servers: input.servers,
+        authSchemes: input.authSchemes,
+        embeddedDefaults: input.embeddedDefaults,
+        bodyFlagDefs: input.bodyFlagDefs
+      });
+      process.stdout.write(`${curl}
+`);
+      return;
+    }
+    const result = await execute(input);
+    if (!result.ok) {
+      if (input.globals.json) {
+        process.stdout.write(`${JSON.stringify({ status: result.status, body: result.body })}
+`);
+      } else {
+        process.stderr.write(`HTTP ${result.status}
+`);
+        process.stderr.write(`${typeof result.body === "string" ? result.body : JSON.stringify(result.body, null, 2)}
+`);
+      }
+      process.exitCode = 1;
+      return;
+    }
+    if (input.globals.json) {
+      process.stdout.write(`${JSON.stringify(result.body)}
+`);
+      return;
+    }
+    if (typeof result.body === "string") {
+      process.stdout.write(result.body);
+      if (!result.body.endsWith(`
+`))
+        process.stdout.write(`
+`);
+    } else {
+      process.stdout.write(`${JSON.stringify(result.body, null, 2)}
+`);
+    }
+  } catch (err) {
+    const rawMessage = err instanceof Error ? err.message : String(err);
+    const message = formatError(rawMessage, resourceName, actionName);
+    if (input.globals.json) {
+      process.stdout.write(`${JSON.stringify({ error: rawMessage })}
+`);
+    } else {
+      process.stderr.write(`error: ${message}
+`);
+    }
+    process.exitCode = 1;
+  }
+}
+
+// src/cli/runtime/generated.ts
+function formatCustomHelp(cmd, action, operationFlags, bodyFlagDefs) {
+  const lines = [];
+  const cmdName = cmd.name();
+  const parentName = cmd.parent?.name() ?? "";
+  const fullCmd = parentName ? `${parentName} ${cmdName}` : cmdName;
+  const positionals = action.positionals.map((p) => `<${p.name}>`).join(" ");
+  const usageSuffix = positionals ? ` ${positionals}` : "";
+  lines.push(`Usage: ${fullCmd}${usageSuffix} [options]`);
+  lines.push("");
+  const desc = action.summary ?? action.description ?? `${action.method} ${action.path}`;
+  lines.push(desc);
+  lines.push("");
+  const requiredOpts = [];
+  const optionalOpts = [];
+  const formatOpt = (flag, type, desc2, required) => {
+    const typeStr = type === "boolean" ? "" : ` <${type}>`;
+    const reqMarker = required ? " (required)" : "";
+    return `  ${flag}${typeStr}${reqMarker}
+      ${desc2}`;
+  };
+  for (const f of operationFlags) {
+    const type = f.type === "array" ? `${f.itemType ?? "string"}[]` : f.type;
+    const line = formatOpt(f.flag, type, f.description ?? `${f.in} parameter`, f.required);
+    if (f.required) {
+      requiredOpts.push(line);
+    } else {
+      optionalOpts.push(line);
+    }
+  }
+  for (const def of bodyFlagDefs) {
+    const line = formatOpt(def.flag, def.type, def.description, def.required);
+    if (def.required) {
+      requiredOpts.push(line);
+    } else {
+      optionalOpts.push(line);
+    }
+  }
+  if (requiredOpts.length > 0) {
+    lines.push("Required:");
+    lines.push(...requiredOpts);
+    lines.push("");
+  }
+  if (optionalOpts.length > 0) {
+    lines.push("Options:");
+    lines.push(...optionalOpts);
+    lines.push("");
+  }
+  lines.push("Global:");
+  lines.push(`  --curl
+      Print curl command instead of executing`);
+  lines.push(`  --json
+      Output response as JSON`);
+  lines.push(`  --server <url>
+      Override the API server URL`);
+  lines.push(`  --bearer-token <token>
+      Provide auth token (or use 'login' command)`);
+  lines.push(`  -h, --help
+      Show this help message`);
+  lines.push("");
+  return lines.join(`
+`);
+}
+function addGeneratedCommands(program, context) {
+  for (const resource of context.commands.resources) {
+    const resourceCmd = program.command(resource.resource).description(`Operations for ${resource.resource}`);
+    for (const action of resource.actions) {
+      const cmd = resourceCmd.command(action.action);
+      cmd.description(action.summary ?? action.description ?? `${action.method} ${action.path}`);
+      for (const pos of action.positionals) {
+        cmd.argument(`<${pos.name}>`, pos.description);
+      }
+      for (const flag of action.flags) {
+        const opt = flag.flag;
+        const desc = flag.description ?? `${flag.in} parameter`;
+        if (flag.type === "boolean") {
+          cmd.option(opt, desc);
+          continue;
+        }
+        const isArray = flag.type === "array";
+        const itemType = flag.itemType ?? "string";
+        const flagType = isArray ? itemType : flag.type;
+        const parser = (raw) => coerceValue(raw, flagType);
+        if (isArray) {
+          const key2 = `${opt} <value>`;
+          cmd.option(key2, desc, (value, prev) => {
+            const next = [...prev ?? []];
+            const items = coerceArrayInput(value, itemType);
+            for (const item of items) {
+              next.push(item);
+            }
+            return next;
+          });
+          continue;
+        }
+        const key = `${opt} <value>`;
+        if (flag.required)
+          cmd.requiredOption(key, desc, parser);
+        else
+          cmd.option(key, desc, parser);
+      }
+      const operationFlagSet = new Set(action.flags.map((f) => f.flag));
+      const reservedFlags = new Set([...operationFlagSet, "--curl"]);
+      if (!operationFlagSet.has("--curl")) {
+        cmd.option("--curl", "Print curl command without sending");
+      }
+      let bodyFlagDefs = [];
+      if (action.requestBody) {
+        bodyFlagDefs = generateBodyFlags(action.requestBodySchema, reservedFlags);
+        for (const def of bodyFlagDefs) {
+          if (def.type === "boolean") {
+            cmd.option(def.flag, def.description);
+          } else {
+            cmd.option(`${def.flag} <value>`, def.description);
+          }
+        }
+      }
+      cmd.configureHelp({
+        formatHelp: () => formatCustomHelp(cmd, action, action.flags, bodyFlagDefs)
+      });
+      cmd.action(async (...args) => {
+        const command = args[args.length - 1];
+        const positionalValues = args.slice(0, -1).map((v) => String(v));
+        if (!(command instanceof Command)) {
+          throw new Error("Unexpected commander action signature");
+        }
+        const globals = command.optsWithGlobals();
+        const local = command.opts();
+        await executeAction({
+          action,
+          positionalValues,
+          flagValues: local,
+          globals,
+          servers: context.servers,
+          authSchemes: context.authSchemes,
+          specId: context.specId,
+          embeddedDefaults: context.embeddedDefaults,
+          bodyFlagDefs,
+          resourceName: resource.resource
+        });
+      });
+    }
+  }
+}
+export {
+  addGeneratedCommands
+};
+
+//# debugId=79BE30BC262E0F9D64756E2164756E21