@zapier/zapier-sdk-cli 0.30.0 → 0.31.0

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # @zapier/zapier-sdk-cli
 
+## 0.31.0
+
+### Minor Changes
+
+- ad5ee3b: Adds a new curl plugin.
+  Switch -v flag to -V for version information.
+  Fix CLI to properly handle string and object types.
+  Add redirect passthrough to fetch plugin (to support curl plugin).
+
+### Patch Changes
+
+- Updated dependencies [ad5ee3b]
+  - @zapier/zapier-sdk@0.29.0
+  - @zapier/zapier-sdk-mcp@0.9.4
+
 ## 0.30.0
 
 ### Minor Changes

package/README.md

@@ -30,7 +30,7 @@
   - [`get-connection`](#get-connection)
   - [`list-connections`](#list-connections)
 - [HTTP Requests](#http-requests)
-  - [`fetch`](#fetch)
+  - [`curl`](#curl)
 - [Utilities](#utilities)
   - [`add`](#add)
   - [`build-manifest`](#build-manifest)
@@ -85,7 +85,7 @@ These options are available for all commands:
 
 | Option                                 | Short | Description                                        |
 | -------------------------------------- | ----- | -------------------------------------------------- |
-| `--version`                            | `-v`  | Display version number                             |
+| `--version`                            | `-V`  | Display version number                             |
 | `--help`                               | `-h`  | Display help for command                           |
 | `--debug`                              |       | Enable debug logging                               |
 | `--json`                               |       | Output raw JSON instead of formatted results       |
@@ -450,25 +450,46 @@ npx zapier-sdk list-connections [--search] [--title] [--owner] [--app-key] [--co
 
 ### HTTP Requests
 
-#### `fetch`
+#### `curl`
 
-Make authenticated HTTP requests to any API through Zapier's Relay service. Pass a connectionId to automatically inject the user's stored credentials (OAuth tokens, API keys, etc.) into the outgoing request. Mirrors the native fetch(url, init?) signature with additional Zapier-specific options.
+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.
 
 **Options:**
 
-| Option            | Type                             | Required | Default | Possible Values                                            | Description                                                                                         |
-| ----------------- | -------------------------------- | -------- | ------- | ---------------------------------------------------------- | --------------------------------------------------------------------------------------------------- |
-| `<url>`           | `string, custom`                 | ✅       | —       | —                                                          | The full URL of the API endpoint to call (proxied through Zapier's Relay service)                   |
-| `--method`        | `string`                         | ❌       | —       | `GET`, `POST`, `PUT`, `DELETE`, `PATCH`, `HEAD`, `OPTIONS` | HTTP method for the request (defaults to GET)                                                       |
-| `--headers`       | `object`                         | ❌       | —       | —                                                          | HTTP headers to include in the request                                                              |
-| `--body`          | `string, custom, custom, record` | ❌       | —       | —                                                          | Request body — plain objects and JSON strings are auto-detected and Content-Type is set accordingly |
-| `--connection-id` | `string, number`                 | ❌       | —       | —                                                          | Connection ID to use for this action                                                                |
-| `--callback-url`  | `string`                         | ❌       | —       | —                                                          | URL to send async response to (makes request async)                                                 |
+| Option             | Type             | Required | Default | Possible Values                                            | Description                                                  |
+| ------------------ | ---------------- | -------- | ------- | ---------------------------------------------------------- | ------------------------------------------------------------ |
+| `<url>`            | `string`         | ✅       | —       | —                                                          | Request URL                                                  |
+| `--request`        | `string`         | ❌       | —       | `GET`, `POST`, `PUT`, `DELETE`, `PATCH`, `HEAD`, `OPTIONS` | HTTP method (defaults to GET, or POST if data is provided)   |
+| `--header`         | `array`          | ❌       | —       | —                                                          | HTTP headers in 'Key: Value' format (repeatable)             |
+| `--data`           | `array`          | ❌       | —       | —                                                          | HTTP POST data (repeatable, joined with &)                   |
+| `--data-raw`       | `array`          | ❌       | —       | —                                                          | HTTP POST data without special interpretation (repeatable)   |
+| `--data-ascii`     | `array`          | ❌       | —       | —                                                          | HTTP POST ASCII data (repeatable)                            |
+| `--data-binary`    | `array`          | ❌       | —       | —                                                          | HTTP POST binary data (repeatable)                           |
+| `--data-urlencode` | `array`          | ❌       | —       | —                                                          | HTTP POST data, URL-encoded (repeatable)                     |
+| `--json`           | `string`         | ❌       | —       | —                                                          | Send JSON body (sets Content-Type and Accept headers)        |
+| `--form`           | `array`          | ❌       | —       | —                                                          | Multipart form data as 'name=value' (repeatable)             |
+| `--form-string`    | `array`          | ❌       | —       | —                                                          | Multipart form string field (repeatable)                     |
+| `--get`            | `boolean`        | ❌       | —       | —                                                          | Force GET method and append data to query string             |
+| `--head`           | `boolean`        | ❌       | —       | —                                                          | Fetch headers only (HEAD request)                            |
+| `--location`       | `boolean`        | ❌       | —       | —                                                          | Follow redirects                                             |
+| `--include`        | `boolean`        | ❌       | —       | —                                                          | Include response headers in output                           |
+| `--output`         | `string`         | ❌       | —       | —                                                          | Write output to file instead of stdout                       |
+| `--remote-name`    | `boolean`        | ❌       | —       | —                                                          | Write output to file named like the remote file              |
+| `--verbose`        | `boolean`        | ❌       | —       | —                                                          | Verbose output (show request/response headers on stderr)     |
+| `--silent`         | `boolean`        | ❌       | —       | —                                                          | Silent mode (suppress errors)                                |
+| `--show-error`     | `boolean`        | ❌       | —       | —                                                          | Show errors even when in silent mode                         |
+| `--fail`           | `boolean`        | ❌       | —       | —                                                          | Fail silently on HTTP errors (exit code 22)                  |
+| `--fail-with-body` | `boolean`        | ❌       | —       | —                                                          | Fail on HTTP errors but still output the body                |
+| `--write-out`      | `string`         | ❌       | —       | —                                                          | Output format string after completion (e.g., '%{http_code}') |
+| `--max-time`       | `number`         | ❌       | —       | —                                                          | Maximum time in seconds for the request                      |
+| `--user`           | `string`         | ❌       | —       | —                                                          | Basic auth credentials as 'user:password'                    |
+| `--compressed`     | `boolean`        | ❌       | —       | —                                                          | Request compressed response (sends Accept-Encoding header)   |
+| `--connection-id`  | `string, number` | ❌       | —       | —                                                          | Zapier connection ID for authentication                      |
 
 **Usage:**
 
 ```bash
-npx zapier-sdk fetch <url> [--method] [--headers] [--body] [--connection-id] [--callback-url]
+npx zapier-sdk curl <url> [--request] [--header] [--data] [--data-raw] [--data-ascii] [--data-binary] [--data-urlencode] [--json] [--form] [--form-string] [--get] [--head] [--location] [--include] [--output] [--remote-name] [--verbose] [--silent] [--show-error] [--fail] [--fail-with-body] [--write-out] [--max-time] [--user] [--compressed] [--connection-id]
 ```
 
 ### Utilities

package/dist/cli.cjs

@@ -963,7 +963,7 @@ function analyzeZodField(name, schema, functionInfo) {
     paramType = "string";
     choices = baseSchema.options;
   } else if (baseSchema instanceof zod.z.ZodRecord) {
-    paramType = "string";
+    paramType = "object";
   }
   let paramHasResolver = false;
   if (functionInfo?.resolvers?.[name]) {
@@ -1278,9 +1278,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;
@@ -1299,10 +1304,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(
@@ -1315,16 +1322,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(
@@ -1335,7 +1343,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) {
@@ -1371,6 +1382,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 {
@@ -1780,7 +1801,7 @@ var LoginSchema = zod.z.object({
 
 // package.json
 var package_default = {
-  version: "0.30.0"};
+  version: "0.31.0"};
 
 // src/telemetry/builders.ts
 function createCliBaseEvent(context = {}) {
@@ -3116,18 +3137,450 @@ var feedbackPlugin = ({
     }
   };
 };
+var CurlSchema = zod.z.object({
+  url: zod.z.string().describe("Request URL"),
+  request: zod.z.enum(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"]).optional().describe("HTTP method (defaults to GET, or POST if data is provided)"),
+  header: zod.z.array(zod.z.string()).optional().describe("HTTP headers in 'Key: Value' format (repeatable)"),
+  data: zod.z.array(zod.z.string()).optional().describe("HTTP POST data (repeatable, joined with &)"),
+  dataRaw: zod.z.array(zod.z.string()).optional().describe("HTTP POST data without special interpretation (repeatable)"),
+  dataAscii: zod.z.array(zod.z.string()).optional().describe("HTTP POST ASCII data (repeatable)"),
+  dataBinary: zod.z.array(zod.z.string()).optional().describe("HTTP POST binary data (repeatable)"),
+  dataUrlencode: zod.z.array(zod.z.string()).optional().describe("HTTP POST data, URL-encoded (repeatable)"),
+  json: zod.z.string().optional().describe("Send JSON body (sets Content-Type and Accept headers)"),
+  form: zod.z.array(zod.z.string()).optional().describe("Multipart form data as 'name=value' (repeatable)"),
+  formString: zod.z.array(zod.z.string()).optional().describe("Multipart form string field (repeatable)"),
+  get: zod.z.boolean().optional().describe("Force GET method and append data to query string"),
+  head: zod.z.boolean().optional().describe("Fetch headers only (HEAD request)"),
+  location: zod.z.boolean().optional().describe("Follow redirects"),
+  include: zod.z.boolean().optional().describe("Include response headers in output"),
+  output: zod.z.string().optional().describe("Write output to file instead of stdout"),
+  remoteName: zod.z.boolean().optional().describe("Write output to file named like the remote file"),
+  verbose: zod.z.boolean().optional().describe("Verbose output (show request/response headers on stderr)"),
+  silent: zod.z.boolean().optional().describe("Silent mode (suppress errors)"),
+  showError: zod.z.boolean().optional().describe("Show errors even when in silent mode"),
+  fail: zod.z.boolean().optional().describe("Fail silently on HTTP errors (exit code 22)"),
+  failWithBody: zod.z.boolean().optional().describe("Fail on HTTP errors but still output the body"),
+  writeOut: zod.z.string().optional().describe("Output format string after completion (e.g., '%{http_code}')"),
+  maxTime: zod.z.number().optional().describe("Maximum time in seconds for the request"),
+  user: zod.z.string().optional().describe("Basic auth credentials as 'user:password'"),
+  compressed: zod.z.boolean().optional().describe("Request compressed response (sends Accept-Encoding header)"),
+  connectionId: zod.z.union([zod.z.string(), zod.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" : path.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 fs.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 fs.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 fs.promises.readFile(filePath);
+      if (typeof Blob === "undefined") {
+        fd.append(name, buf.toString("utf8"));
+        return;
+      }
+      const blob = new Blob([buf]);
+      const filename = filePath === "-" ? `stdin-${crypto.createHash("sha1").update(buf).digest("hex").slice(0, 8)}` : path.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 fs.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 = path.dirname(outputFile);
+      if (dir !== ".") {
+        await fs.promises.mkdir(dir, { recursive: true });
+      }
+      const ws = fs.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 zapierSdk.createZapierSdkWithoutRegistry({
     ...options
-  }).addPlugin(generateAppTypesPlugin).addPlugin(buildManifestPlugin).addPlugin(bundleCodePlugin).addPlugin(getLoginConfigPathPlugin).addPlugin(addPlugin).addPlugin(feedbackPlugin).addPlugin(mcpPlugin).addPlugin(loginPlugin).addPlugin(logoutPlugin).addPlugin(zapierSdk.registryPlugin);
+  }).addPlugin(generateAppTypesPlugin).addPlugin(buildManifestPlugin).addPlugin(bundleCodePlugin).addPlugin(getLoginConfigPathPlugin).addPlugin(addPlugin).addPlugin(feedbackPlugin).addPlugin(curlPlugin).addPlugin(mcpPlugin).addPlugin(loginPlugin).addPlugin(logoutPlugin).addPlugin(cliOverridesPlugin).addPlugin(zapierSdk.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) {
@@ -3330,7 +3783,7 @@ async function checkAndNotifyUpdates({
 
 // src/cli.ts
 var program = new commander.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(
@@ -3342,7 +3795,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);