@zapier/zapier-sdk-cli 0.30.0 → 0.31.0

package/dist/cli.mjs

@@ -6,7 +6,7 @@ import inquirer from 'inquirer';
 import chalk3 from 'chalk';
 import util from 'util';
 import open from 'open';
-import crypto from 'crypto';
+import crypto, { createHash } from 'crypto';
 import express from 'express';
 import pkceChallenge from 'pkce-challenge';
 import { logout, getConfigPath, getLoggedInUser, getPkceLoginConfig, AUTH_MODE_HEADER, updateLogin } from '@zapier/zapier-sdk-cli-login';
@@ -14,9 +14,9 @@ import ora from 'ora';
 import { startMcpServer } from '@zapier/zapier-sdk-mcp';
 import { buildSync } from 'esbuild';
 import * as fs from 'fs';
-import { existsSync } from 'fs';
+import { promises, createWriteStream, existsSync } from 'fs';
 import * as path from 'path';
-import { resolve, join } from 'path';
+import { resolve, join, dirname, basename } from 'path';
 import { mkdir, writeFile, access } from 'fs/promises';
 import * as ts from 'typescript';
 import packageJsonLib from 'package-json';
@@ -927,7 +927,7 @@ function analyzeZodField(name, schema, functionInfo) {
     paramType = "string";
     choices = baseSchema.options;
   } else if (baseSchema instanceof z.ZodRecord) {
-    paramType = "string";
+    paramType = "object";
   }
   let paramHasResolver = false;
   if (functionInfo?.resolvers?.[name]) {
@@ -1242,9 +1242,14 @@ ${confirmMessageAfter}`));
     description,
     parameters,
     handler,
-    hidden: functionInfo.categories?.includes("deprecated") ?? false
+    hidden: functionInfo.categories?.includes("deprecated") ?? false,
+    aliases: functionInfo.aliases
   };
 }
+function collect(value, previous = []) {
+  previous.push(value);
+  return previous;
+}
 function addCommand(program2, commandName, config2) {
   const command = program2.command(commandName, { hidden: config2.hidden ?? false }).description(config2.description);
   let hasPositionalArray = false;
@@ -1263,10 +1268,12 @@ function addCommand(program2, commandName, config2) {
       );
     } else if (param.required && param.type === "array") {
       const flags = [`--${kebabName}`];
-      const flagSignature = flags.join(", ") + ` <values...>`;
+      const flagSignature = flags.join(", ") + ` <value>`;
       command.requiredOption(
         flagSignature,
-        param.description || `${kebabName} parameter (required)`
+        param.description || `${kebabName} parameter (required, repeatable)`,
+        collect,
+        []
       );
     } else if (param.required) {
       command.argument(
@@ -1279,16 +1286,17 @@ function addCommand(program2, commandName, config2) {
         param.description || `${kebabName} parameter`
       );
     } else {
-      const flags = [`--${kebabName}`];
+      const flags = [];
+      const alias = config2.aliases?.[param.name];
+      if (alias && alias.length === 1) {
+        flags.push(`-${alias}`);
+      }
+      flags.push(`--${kebabName}`);
       if (param.type === "boolean") {
         command.option(flags.join(", "), param.description);
       } else if (param.type === "array") {
-        const flagSignature = flags.join(", ") + ` <values...>`;
-        command.option(
-          flagSignature,
-          param.description,
-          param.default
-        );
+        const flagSignature = flags.join(", ") + ` <value>`;
+        command.option(flagSignature, param.description || "", collect, []);
       } else {
         const flagSignature = flags.join(", ") + ` <${param.type}>`;
         command.option(
@@ -1299,7 +1307,10 @@ function addCommand(program2, commandName, config2) {
       }
     }
   });
-  command.option("--json", "Output raw JSON instead of formatted results");
+  const hasJsonParam = config2.parameters.some((p) => p.name === "json");
+  if (!hasJsonParam) {
+    command.option("--json", "Output raw JSON instead of formatted results");
+  }
   command.action(config2.handler);
 }
 function convertCliArgsToSdkParams(parameters, positionalArgs, options) {
@@ -1335,6 +1346,16 @@ function convertValue(value, type) {
     case "array":
       return Array.isArray(value) ? value : [value];
     case "string":
+      return value;
+    case "object":
+      if (typeof value === "string") {
+        try {
+          return JSON.parse(value);
+        } catch {
+          return value;
+        }
+      }
+      return value;
     default:
       if (typeof value === "string" && (value.startsWith("{") || value.startsWith("["))) {
         try {
@@ -1744,7 +1765,7 @@ var LoginSchema = z.object({
 
 // package.json
 var package_default = {
-  version: "0.30.0"};
+  version: "0.31.0"};
 
 // src/telemetry/builders.ts
 function createCliBaseEvent(context = {}) {
@@ -3080,18 +3101,450 @@ var feedbackPlugin = ({
     }
   };
 };
+var CurlSchema = z.object({
+  url: z.string().describe("Request URL"),
+  request: z.enum(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"]).optional().describe("HTTP method (defaults to GET, or POST if data is provided)"),
+  header: z.array(z.string()).optional().describe("HTTP headers in 'Key: Value' format (repeatable)"),
+  data: z.array(z.string()).optional().describe("HTTP POST data (repeatable, joined with &)"),
+  dataRaw: z.array(z.string()).optional().describe("HTTP POST data without special interpretation (repeatable)"),
+  dataAscii: z.array(z.string()).optional().describe("HTTP POST ASCII data (repeatable)"),
+  dataBinary: z.array(z.string()).optional().describe("HTTP POST binary data (repeatable)"),
+  dataUrlencode: z.array(z.string()).optional().describe("HTTP POST data, URL-encoded (repeatable)"),
+  json: z.string().optional().describe("Send JSON body (sets Content-Type and Accept headers)"),
+  form: z.array(z.string()).optional().describe("Multipart form data as 'name=value' (repeatable)"),
+  formString: z.array(z.string()).optional().describe("Multipart form string field (repeatable)"),
+  get: z.boolean().optional().describe("Force GET method and append data to query string"),
+  head: z.boolean().optional().describe("Fetch headers only (HEAD request)"),
+  location: z.boolean().optional().describe("Follow redirects"),
+  include: z.boolean().optional().describe("Include response headers in output"),
+  output: z.string().optional().describe("Write output to file instead of stdout"),
+  remoteName: z.boolean().optional().describe("Write output to file named like the remote file"),
+  verbose: z.boolean().optional().describe("Verbose output (show request/response headers on stderr)"),
+  silent: z.boolean().optional().describe("Silent mode (suppress errors)"),
+  showError: z.boolean().optional().describe("Show errors even when in silent mode"),
+  fail: z.boolean().optional().describe("Fail silently on HTTP errors (exit code 22)"),
+  failWithBody: z.boolean().optional().describe("Fail on HTTP errors but still output the body"),
+  writeOut: z.string().optional().describe("Output format string after completion (e.g., '%{http_code}')"),
+  maxTime: z.number().optional().describe("Maximum time in seconds for the request"),
+  user: z.string().optional().describe("Basic auth credentials as 'user:password'"),
+  compressed: z.boolean().optional().describe("Request compressed response (sends Accept-Encoding header)"),
+  connectionId: z.union([z.string(), z.number()]).optional().describe("Zapier connection ID for authentication")
+}).describe("Make HTTP requests through Zapier Relay with curl-like options");
+var CurlExitError = class extends Error {
+  constructor(message, exitCode) {
+    super(message);
+    this.exitCode = exitCode;
+    this.name = "CurlExitError";
+  }
+};
+function parseHeaderLine(input) {
+  const idx = input.indexOf(":");
+  if (idx === -1) {
+    return null;
+  }
+  const key = input.slice(0, idx).trim();
+  const value = input.slice(idx + 1).trim();
+  if (!key) {
+    return null;
+  }
+  return { key, value };
+}
+function basicAuthHeader(userpass) {
+  const idx = userpass.indexOf(":");
+  const user = idx === -1 ? userpass : userpass.slice(0, idx);
+  const pass = idx === -1 ? "" : userpass.slice(idx + 1);
+  const token = Buffer.from(`${user}:${pass}`, "utf8").toString("base64");
+  return `Basic ${token}`;
+}
+function deriveRemoteFilename(url) {
+  const path2 = url.pathname;
+  const candidate = path2.endsWith("/") ? "index.html" : basename(path2);
+  return candidate || "index.html";
+}
+function decodeWriteOutEscapes(input) {
+  return input.replace(/\\n/g, "\n").replace(/\\r/g, "\r").replace(/\\t/g, "	");
+}
+function formatWriteOut(params) {
+  const { template } = params;
+  const replacements = {
+    "%{http_code}": String(params.httpCode).padStart(3, "0"),
+    "%{time_total}": params.timeTotalSeconds.toFixed(3),
+    "%{size_download}": String(params.sizeDownloadBytes),
+    "%{url_effective}": params.urlEffective,
+    "%{content_type}": params.contentType ?? ""
+  };
+  let out = template;
+  for (const [token, value] of Object.entries(replacements)) {
+    out = out.split(token).join(value);
+  }
+  return decodeWriteOutEscapes(out);
+}
+function appendQueryParams(url, dataParts) {
+  const out = new URL(url.toString());
+  for (const part of dataParts) {
+    const segments = part.split("&");
+    for (const seg of segments) {
+      if (!seg) continue;
+      const idx = seg.indexOf("=");
+      if (idx === -1) {
+        out.searchParams.append(seg, "");
+      } else {
+        out.searchParams.append(seg.slice(0, idx), seg.slice(idx + 1));
+      }
+    }
+  }
+  return out;
+}
+async function readAllStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks);
+}
+async function resolveDataArgText(raw) {
+  if (!raw.startsWith("@")) {
+    return raw;
+  }
+  const source = raw.slice(1);
+  if (source === "-") {
+    const buf2 = await readAllStdin();
+    return buf2.toString("utf8");
+  }
+  const buf = await promises.readFile(source);
+  return buf.toString("utf8");
+}
+async function resolveDataArgBinary(raw) {
+  if (!raw.startsWith("@")) {
+    return Buffer.from(raw, "utf8");
+  }
+  const source = raw.slice(1);
+  if (source === "-") {
+    return await readAllStdin();
+  }
+  return await promises.readFile(source);
+}
+async function buildFormData(formArgs, formStringArgs) {
+  if (typeof FormData === "undefined") {
+    throw new CurlExitError(
+      "FormData is not available in this runtime; cannot use --form.",
+      2
+    );
+  }
+  const fd = new FormData();
+  const addField = async (item, forceString) => {
+    const idx = item.indexOf("=");
+    if (idx === -1) {
+      throw new CurlExitError(
+        `Invalid form field: '${item}'. Expected 'name=value' or 'name=@file'.`,
+        2
+      );
+    }
+    const name = item.slice(0, idx);
+    const value = item.slice(idx + 1);
+    if (!name) {
+      throw new CurlExitError(
+        `Invalid form field: '${item}'. Field name cannot be empty.`,
+        2
+      );
+    }
+    if (!forceString && value.startsWith("@")) {
+      const filePath = value.slice(1);
+      const buf = filePath === "-" ? await readAllStdin() : await promises.readFile(filePath);
+      if (typeof Blob === "undefined") {
+        fd.append(name, buf.toString("utf8"));
+        return;
+      }
+      const blob = new Blob([buf]);
+      const filename = filePath === "-" ? `stdin-${createHash("sha1").update(buf).digest("hex").slice(0, 8)}` : basename(filePath);
+      fd.append(name, blob, filename);
+      return;
+    }
+    fd.append(name, value);
+  };
+  for (const item of formArgs) {
+    await addField(item, false);
+  }
+  for (const item of formStringArgs) {
+    await addField(item, true);
+  }
+  return fd;
+}
+
+// src/plugins/curl/index.ts
+var curlPlugin = ({
+  sdk: sdk2
+}) => {
+  async function curl(options) {
+    const {
+      url: rawUrl,
+      request,
+      header = [],
+      data = [],
+      dataRaw = [],
+      dataAscii = [],
+      dataBinary = [],
+      dataUrlencode = [],
+      json,
+      form = [],
+      formString = [],
+      get: forceGet,
+      head: forceHead,
+      location,
+      include,
+      output,
+      remoteName,
+      verbose,
+      silent,
+      showError,
+      fail,
+      failWithBody,
+      writeOut,
+      maxTime,
+      user,
+      compressed,
+      connectionId
+    } = options;
+    const parsedUrl = new URL(rawUrl);
+    const headers = {};
+    for (const h of header) {
+      const parsed = parseHeaderLine(h);
+      if (parsed) {
+        headers[parsed.key] = parsed.value;
+      }
+    }
+    if (user) {
+      headers["Authorization"] = basicAuthHeader(user);
+    }
+    if (compressed) {
+      headers["Accept-Encoding"] = "gzip, deflate, br";
+    }
+    const rawTextDataArgs = [...data, ...dataRaw, ...dataAscii];
+    const rawBinaryDataArgs = [...dataBinary];
+    const rawUrlencodeArgs = [...dataUrlencode];
+    const hasForm = form.length > 0 || formString.length > 0;
+    const hasJson = json !== void 0;
+    const hasAnyData = hasJson || hasForm || rawTextDataArgs.length > 0 || rawBinaryDataArgs.length > 0 || rawUrlencodeArgs.length > 0;
+    let method = "GET";
+    if (forceHead) {
+      method = "HEAD";
+    } else if (request) {
+      method = request;
+    } else if (forceGet) {
+      method = "GET";
+    } else if (hasAnyData) {
+      method = "POST";
+    }
+    let body;
+    let effectiveUrl = parsedUrl;
+    if (hasJson) {
+      if (!headers["Content-Type"]) {
+        headers["Content-Type"] = "application/json";
+      }
+      if (!headers["Accept"]) {
+        headers["Accept"] = "application/json";
+      }
+      body = json;
+    } else if (hasForm) {
+      body = await buildFormData(form, formString);
+    } else {
+      const resolvedTextParts = [];
+      for (const raw of rawTextDataArgs) {
+        resolvedTextParts.push(await resolveDataArgText(raw));
+      }
+      const resolvedUrlEncodeParts = [];
+      for (const raw of rawUrlencodeArgs) {
+        if (raw.startsWith("@")) {
+          const content = await resolveDataArgText(raw);
+          resolvedUrlEncodeParts.push(encodeURIComponent(content));
+          continue;
+        }
+        const atIdx = raw.indexOf("@");
+        const eqIdx = raw.indexOf("=");
+        if (eqIdx !== -1) {
+          const key = raw.slice(0, eqIdx);
+          const value = raw.slice(eqIdx + 1);
+          resolvedUrlEncodeParts.push(
+            `${encodeURIComponent(key)}=${encodeURIComponent(value)}`
+          );
+        } else if (atIdx !== -1) {
+          const key = raw.slice(0, atIdx);
+          const filePath = raw.slice(atIdx + 1);
+          const buf2 = filePath === "-" ? await readAllStdin() : await promises.readFile(filePath);
+          resolvedUrlEncodeParts.push(
+            `${encodeURIComponent(key)}=${encodeURIComponent(buf2.toString("utf8"))}`
+          );
+        } else {
+          resolvedUrlEncodeParts.push(encodeURIComponent(raw));
+        }
+      }
+      const resolvedBinaryParts = [];
+      for (const raw of rawBinaryDataArgs) {
+        resolvedBinaryParts.push(await resolveDataArgBinary(raw));
+      }
+      const allTextParts = [...resolvedTextParts, ...resolvedUrlEncodeParts];
+      if (forceGet && allTextParts.length > 0) {
+        effectiveUrl = appendQueryParams(parsedUrl, allTextParts);
+      } else if (resolvedBinaryParts.length > 0) {
+        body = Buffer.concat(resolvedBinaryParts);
+      } else if (allTextParts.length > 0) {
+        body = allTextParts.join("&");
+        if (!headers["Content-Type"]) {
+          headers["Content-Type"] = "application/x-www-form-urlencoded";
+        }
+      }
+    }
+    const redirect = location ? "follow" : "manual";
+    if (verbose && !silent) {
+      process.stderr.write(`> ${method} ${effectiveUrl.toString()}
+`);
+      for (const [k, v] of Object.entries(headers)) {
+        process.stderr.write(`> ${k}: ${v}
+`);
+      }
+      process.stderr.write(">\n");
+    }
+    const signal = maxTime ? AbortSignal.timeout(maxTime * 1e3) : void 0;
+    const start = performance.now();
+    const response = await sdk2.fetch(effectiveUrl.toString(), {
+      method,
+      headers,
+      body,
+      redirect,
+      signal,
+      connectionId
+    });
+    const timeTotalSeconds = (performance.now() - start) / 1e3;
+    if (verbose && !silent) {
+      process.stderr.write(
+        `< HTTP ${response.status} ${response.statusText}
+`
+      );
+      response.headers.forEach((value, key) => {
+        process.stderr.write(`< ${key}: ${value}
+`);
+      });
+      process.stderr.write("<\n");
+    }
+    const isHttpError = response.status >= 400;
+    const shouldFail = (fail || failWithBody) && isHttpError;
+    const shouldOutputBody = !shouldFail || !!failWithBody;
+    const headerText = include ? `HTTP ${response.status} ${response.statusText}
+${Array.from(
+      response.headers.entries()
+    ).map(([k, v]) => `${k}: ${v}`).join("\n")}
+
+` : "";
+    let bodyBytes = 0;
+    const buf = shouldOutputBody ? Buffer.from(await response.arrayBuffer()) : Buffer.alloc(0);
+    bodyBytes = buf.length;
+    const outputFile = output && output !== "-" ? output : remoteName ? deriveRemoteFilename(parsedUrl) : void 0;
+    if (outputFile) {
+      const dir = dirname(outputFile);
+      if (dir !== ".") {
+        await promises.mkdir(dir, { recursive: true });
+      }
+      const ws = createWriteStream(outputFile);
+      if (headerText) {
+        ws.write(headerText);
+      }
+      if (buf.length) {
+        ws.write(buf);
+      }
+      await new Promise((resolve4, reject) => {
+        ws.end(() => resolve4());
+        ws.on("error", reject);
+      });
+    } else {
+      if (headerText) {
+        process.stdout.write(headerText);
+      }
+      if (buf.length) {
+        process.stdout.write(buf);
+      }
+    }
+    if (writeOut) {
+      const formatted = formatWriteOut({
+        template: writeOut,
+        urlEffective: response.url || effectiveUrl.toString(),
+        httpCode: response.status,
+        timeTotalSeconds,
+        sizeDownloadBytes: bodyBytes,
+        contentType: response.headers.get("content-type")
+      });
+      process.stdout.write(formatted);
+    }
+    if (shouldFail) {
+      if (!silent || showError) {
+        process.stderr.write(
+          `curl: (22) The requested URL returned error: ${response.status}
+`
+        );
+      }
+      throw new CurlExitError("HTTP request failed", 22);
+    }
+    return void 0;
+  }
+  return {
+    curl,
+    context: {
+      meta: {
+        curl: {
+          description: "Make authenticated HTTP requests to any API through Zapier. Pass a connection ID to automatically inject the user's stored credentials (OAuth tokens, API keys, etc.) into the outgoing request. Use it in place of the native curl command with additional Zapier-specific options.",
+          categories: ["http"],
+          inputSchema: CurlSchema,
+          aliases: {
+            request: "X",
+            header: "H",
+            data: "d",
+            form: "F",
+            get: "G",
+            head: "I",
+            location: "L",
+            include: "i",
+            output: "o",
+            remoteName: "O",
+            verbose: "v",
+            silent: "s",
+            showError: "S",
+            writeOut: "w",
+            maxTime: "m",
+            user: "u"
+          }
+        }
+      }
+    }
+  };
+};
+
+// src/plugins/cliOverrides/index.ts
+var cliOverridesPlugin = ({ context }) => {
+  if (!context.meta.fetch) {
+    return { context: { meta: {} } };
+  }
+  return {
+    context: {
+      meta: {
+        fetch: {
+          ...context.meta.fetch,
+          categories: [...context.meta.fetch.categories || [], "deprecated"]
+        }
+      }
+    }
+  };
+};
 
 // src/sdk.ts
 function createZapierCliSdk(options = {}) {
   return createZapierSdkWithoutRegistry({
     ...options
-  }).addPlugin(generateAppTypesPlugin).addPlugin(buildManifestPlugin).addPlugin(bundleCodePlugin).addPlugin(getLoginConfigPathPlugin).addPlugin(addPlugin).addPlugin(feedbackPlugin).addPlugin(mcpPlugin).addPlugin(loginPlugin).addPlugin(logoutPlugin).addPlugin(registryPlugin);
+  }).addPlugin(generateAppTypesPlugin).addPlugin(buildManifestPlugin).addPlugin(bundleCodePlugin).addPlugin(getLoginConfigPathPlugin).addPlugin(addPlugin).addPlugin(feedbackPlugin).addPlugin(curlPlugin).addPlugin(mcpPlugin).addPlugin(loginPlugin).addPlugin(logoutPlugin).addPlugin(cliOverridesPlugin).addPlugin(registryPlugin);
 }
 
 // package.json with { type: 'json' }
 var package_default2 = {
   name: "@zapier/zapier-sdk-cli",
-  version: "0.30.0"};
+  version: "0.31.0"};
 function detectPackageManager(cwd = process.cwd()) {
   const ua = process.env.npm_config_user_agent;
   if (ua) {
@@ -3294,7 +3747,7 @@ async function checkAndNotifyUpdates({
 
 // src/cli.ts
 var program = new Command();
-program.name("zapier-sdk").description("CLI for Zapier SDK").version(package_default2.version, "-v, --version", "display version number").option("--debug", "Enable debug logging").option("--base-url <url>", "Base URL for Zapier API endpoints").option("--credentials <token>", "Authentication token").option("--credentials-client-id <id>", "OAuth client ID for authentication").option(
+program.name("zapier-sdk").description("CLI for Zapier SDK").version(package_default2.version, void 0, "Display version number").option("--debug", "Enable debug logging").option("--base-url <url>", "Base URL for Zapier API endpoints").option("--credentials <token>", "Authentication token").option("--credentials-client-id <id>", "OAuth client ID for authentication").option(
   "--credentials-client-secret <secret>",
   "OAuth client secret for authentication"
 ).option(
@@ -3306,7 +3759,7 @@ program.name("zapier-sdk").description("CLI for Zapier SDK").version(package_def
 ).option(
   "--max-network-retry-delay-ms <ms>",
   "Max delay in ms to wait for rate limit retry (default: 60000)"
-);
+).helpOption("-h, --help", "Display help for command");
 var isDebugMode = process.env.DEBUG === "true" || process.argv.includes("--debug");
 function getFlagValue(flagName) {
   const index = process.argv.indexOf(flagName);