@zapier/zapier-sdk-cli 0.30.0 → 0.31.1

package/dist/index.mjs

@@ -1,6 +1,6 @@
 import { createFunction, OutputPropertySchema, DEFAULT_CONFIG_PATH, getOsInfo, getPlatformVersions, getCiPlatform, isCi, createZapierSdkWithoutRegistry, registryPlugin, getReleaseId, getCurrentTimestamp, generateEventId, ZapierValidationError, ZapierUnknownError, batch, toSnakeCase, isCredentialsObject, ZapierError } from '@zapier/zapier-sdk';
 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';
@@ -10,8 +10,9 @@ import { z } from 'zod';
 import { startMcpServer } from '@zapier/zapier-sdk-mcp';
 import { buildSync } from 'esbuild';
 import * as fs from 'fs';
+import { promises, createWriteStream } 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';
 
@@ -271,7 +272,7 @@ var LoginSchema = z.object({
 
 // package.json
 var package_default = {
-  version: "0.30.0"};
+  version: "0.31.1"};
 
 // src/telemetry/builders.ts
 function createCliBaseEvent(context = {}) {
@@ -1607,12 +1608,444 @@ 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
+}) => {
+  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 sdk.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);
 }
 
 export { buildCliCommandExecutedEvent, createZapierCliSdk };

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@zapier/zapier-sdk-cli",
-    "version": "0.30.0",
+    "version": "0.31.1",
     "description": "Command line interface for Zapier SDK",
     "main": "dist/index.cjs",
     "module": "dist/index.mjs",

package/dist/src/cli.js

@@ -9,7 +9,7 @@ const program = new Command();
 program
     .name("zapier-sdk")
     .description("CLI for Zapier SDK")
-    .version(packageJson.version, "-v, --version", "display version number")
+    .version(packageJson.version, undefined, "Display version number")
     .option("--debug", "Enable debug logging")
     .option("--base-url <url>", "Base URL for Zapier API endpoints")
     .option("--credentials <token>", "Authentication token")
@@ -18,7 +18,8 @@ program
     .option("--credentials-base-url <url>", "Base URL for authentication endpoints")
     .option("--tracking-base-url <url>", "Base URL for Zapier tracking endpoints")
     .option("--max-network-retries <count>", "Max retries for rate-limited requests (default: 3)")
-    .option("--max-network-retry-delay-ms <ms>", "Max delay in ms to wait for rate limit retry (default: 60000)");
+    .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");
 // Check for debug flag early (support both flag and env var)
 const isDebugMode = process.env.DEBUG === "true" || process.argv.includes("--debug");
 // Helper to get flag value from argv

package/dist/src/plugins/cliOverrides/index.d.ts

@@ -0,0 +1,21 @@
+import type { Plugin } from "@zapier/zapier-sdk";
+interface FetchMeta {
+    categories?: string[];
+}
+interface CliOverridesProvides {
+    context: {
+        meta: {
+            fetch?: FetchMeta;
+        };
+    };
+}
+/**
+ * CLI-specific metadata overrides.
+ * Adds "deprecated" category to fetch so it's hidden from CLI help.
+ */
+export declare const cliOverridesPlugin: Plugin<{}, {
+    meta: {
+        fetch?: FetchMeta;
+    };
+}, CliOverridesProvides>;
+export {};

package/dist/src/plugins/cliOverrides/index.js

@@ -0,0 +1,19 @@
+/**
+ * CLI-specific metadata overrides.
+ * Adds "deprecated" category to fetch so it's hidden from CLI help.
+ */
+export const cliOverridesPlugin = ({ context }) => {
+    if (!context.meta.fetch) {
+        return { context: { meta: {} } };
+    }
+    return {
+        context: {
+            meta: {
+                fetch: {
+                    ...context.meta.fetch,
+                    categories: [...(context.meta.fetch.categories || []), "deprecated"],
+                },
+            },
+        },
+    };
+};

package/dist/src/plugins/curl/index.d.ts

@@ -0,0 +1,17 @@
+import type { Plugin, FetchPluginProvides } from "@zapier/zapier-sdk";
+import { CurlSchema, type CurlOptions } from "./schemas";
+export interface CurlPluginProvides {
+    curl: (options: CurlOptions) => Promise<undefined>;
+    context: {
+        meta: {
+            curl: {
+                inputSchema: typeof CurlSchema;
+            };
+        };
+    };
+}
+type SdkWithFetch = FetchPluginProvides["fetch"] extends infer F ? {
+    fetch: F;
+} : never;
+export declare const curlPlugin: Plugin<SdkWithFetch, {}, CurlPluginProvides>;
+export {};