@zapier/zapier-sdk-cli 0.30.0 → 0.31.1

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

@@ -0,0 +1,234 @@
+import { createWriteStream } from "fs";
+import { promises as fs } from "fs";
+import { dirname } from "path";
+import { CurlSchema } from "./schemas";
+import { CurlExitError, parseHeaderLine, basicAuthHeader, deriveRemoteFilename, formatWriteOut, appendQueryParams, readAllStdin, resolveDataArgText, resolveDataArgBinary, buildFormData, } from "./utils";
+export const 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 !== undefined;
+        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) {
+                // @file => read file, URL-encode contents
+                if (raw.startsWith("@")) {
+                    const content = await resolveDataArgText(raw);
+                    resolvedUrlEncodeParts.push(encodeURIComponent(content));
+                    continue;
+                }
+                const atIdx = raw.indexOf("@");
+                const eqIdx = raw.indexOf("=");
+                if (eqIdx !== -1) {
+                    // name=value => encode both
+                    const key = raw.slice(0, eqIdx);
+                    const value = raw.slice(eqIdx + 1);
+                    resolvedUrlEncodeParts.push(`${encodeURIComponent(key)}=${encodeURIComponent(value)}`);
+                }
+                else if (atIdx !== -1) {
+                    // name@file => read file, encode contents as value
+                    const key = raw.slice(0, atIdx);
+                    const filePath = raw.slice(atIdx + 1);
+                    const buf = filePath === "-"
+                        ? await readAllStdin()
+                        : await fs.readFile(filePath);
+                    resolvedUrlEncodeParts.push(`${encodeURIComponent(key)}=${encodeURIComponent(buf.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";
+                }
+            }
+        }
+        // curl defaults to NOT following redirects
+        const redirect = location ? "follow" : "manual";
+        if (verbose && !silent) {
+            process.stderr.write(`> ${method} ${effectiveUrl.toString()}\n`);
+            for (const [k, v] of Object.entries(headers)) {
+                process.stderr.write(`> ${k}: ${v}\n`);
+            }
+            process.stderr.write(">\n");
+        }
+        const signal = maxTime ? AbortSignal.timeout(maxTime * 1000) : undefined;
+        const start = performance.now();
+        const response = await sdk.fetch(effectiveUrl.toString(), {
+            method,
+            headers,
+            body,
+            redirect,
+            signal,
+            connectionId,
+        });
+        const timeTotalSeconds = (performance.now() - start) / 1000;
+        if (verbose && !silent) {
+            process.stderr.write(`< HTTP ${response.status} ${response.statusText}\n`);
+            response.headers.forEach((value, key) => {
+                process.stderr.write(`< ${key}: ${value}\n`);
+            });
+            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}\n${Array.from(response.headers.entries())
+                .map(([k, v]) => `${k}: ${v}`)
+                .join("\n")}\n\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)
+                : undefined;
+        if (outputFile) {
+            const dir = dirname(outputFile);
+            if (dir !== ".") {
+                await fs.mkdir(dir, { recursive: true });
+            }
+            const ws = createWriteStream(outputFile);
+            if (headerText) {
+                ws.write(headerText);
+            }
+            if (buf.length) {
+                ws.write(buf);
+            }
+            await new Promise((resolve, reject) => {
+                ws.end(() => resolve());
+                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}\n`);
+            }
+            throw new CurlExitError("HTTP request failed", 22);
+        }
+        return undefined;
+    }
+    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",
+                    },
+                },
+            },
+        },
+    };
+};

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

@@ -0,0 +1,39 @@
+import { z } from "zod";
+export declare const CurlSchema: z.ZodObject<{
+    url: z.ZodString;
+    request: z.ZodOptional<z.ZodEnum<{
+        POST: "POST";
+        GET: "GET";
+        PUT: "PUT";
+        DELETE: "DELETE";
+        PATCH: "PATCH";
+        HEAD: "HEAD";
+        OPTIONS: "OPTIONS";
+    }>>;
+    header: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    data: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    dataRaw: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    dataAscii: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    dataBinary: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    dataUrlencode: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    json: z.ZodOptional<z.ZodString>;
+    form: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    formString: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    get: z.ZodOptional<z.ZodBoolean>;
+    head: z.ZodOptional<z.ZodBoolean>;
+    location: z.ZodOptional<z.ZodBoolean>;
+    include: z.ZodOptional<z.ZodBoolean>;
+    output: z.ZodOptional<z.ZodString>;
+    remoteName: z.ZodOptional<z.ZodBoolean>;
+    verbose: z.ZodOptional<z.ZodBoolean>;
+    silent: z.ZodOptional<z.ZodBoolean>;
+    showError: z.ZodOptional<z.ZodBoolean>;
+    fail: z.ZodOptional<z.ZodBoolean>;
+    failWithBody: z.ZodOptional<z.ZodBoolean>;
+    writeOut: z.ZodOptional<z.ZodString>;
+    maxTime: z.ZodOptional<z.ZodNumber>;
+    user: z.ZodOptional<z.ZodString>;
+    compressed: z.ZodOptional<z.ZodBoolean>;
+    connectionId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+}, z.core.$strip>;
+export type CurlOptions = z.infer<typeof CurlSchema>;

package/dist/src/plugins/curl/schemas.js

@@ -0,0 +1,101 @@
+import { z } from "zod";
+export const 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");

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

@@ -0,0 +1,24 @@
+export declare class CurlExitError extends Error {
+    exitCode: number;
+    constructor(message: string, exitCode: number);
+}
+export declare function parseHeaderLine(input: string): {
+    key: string;
+    value: string;
+} | null;
+export declare function basicAuthHeader(userpass: string): string;
+export declare function deriveRemoteFilename(url: URL): string;
+export declare function decodeWriteOutEscapes(input: string): string;
+export declare function formatWriteOut(params: {
+    template: string;
+    urlEffective: string;
+    httpCode: number;
+    timeTotalSeconds: number;
+    sizeDownloadBytes: number;
+    contentType?: string | null;
+}): string;
+export declare function appendQueryParams(url: URL, dataParts: string[]): URL;
+export declare function readAllStdin(): Promise<Buffer>;
+export declare function resolveDataArgText(raw: string): Promise<string>;
+export declare function resolveDataArgBinary(raw: string): Promise<Buffer>;
+export declare function buildFormData(formArgs: string[], formStringArgs: string[]): Promise<FormData>;

package/dist/src/plugins/curl/utils.js

@@ -0,0 +1,141 @@
+import { createHash } from "crypto";
+import { promises as fs } from "fs";
+import { basename } from "path";
+export class CurlExitError extends Error {
+    constructor(message, exitCode) {
+        super(message);
+        this.exitCode = exitCode;
+        this.name = "CurlExitError";
+    }
+}
+export 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 };
+}
+export 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}`;
+}
+export function deriveRemoteFilename(url) {
+    const path = url.pathname;
+    const candidate = path.endsWith("/") ? "index.html" : basename(path);
+    return candidate || "index.html";
+}
+export function decodeWriteOutEscapes(input) {
+    return input
+        .replace(/\\n/g, "\n")
+        .replace(/\\r/g, "\r")
+        .replace(/\\t/g, "\t");
+}
+export 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);
+}
+export 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;
+}
+export 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);
+}
+export async function resolveDataArgText(raw) {
+    if (!raw.startsWith("@")) {
+        return raw;
+    }
+    const source = raw.slice(1);
+    if (source === "-") {
+        const buf = await readAllStdin();
+        return buf.toString("utf8");
+    }
+    const buf = await fs.readFile(source);
+    return buf.toString("utf8");
+}
+export 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.readFile(source);
+}
+export 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.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;
+}

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

@@ -7,3 +7,5 @@ export { addPlugin } from "./add";
 export { generateAppTypesPlugin } from "./generateAppTypes";
 export { buildManifestPlugin } from "./buildManifest";
 export { feedbackPlugin } from "./feedback";
+export { curlPlugin } from "./curl";
+export { cliOverridesPlugin } from "./cliOverrides";

package/dist/src/plugins/index.js

@@ -7,3 +7,5 @@ export { addPlugin } from "./add";
 export { generateAppTypesPlugin } from "./generateAppTypes";
 export { buildManifestPlugin } from "./buildManifest";
 export { feedbackPlugin } from "./feedback";
+export { curlPlugin } from "./curl";
+export { cliOverridesPlugin } from "./cliOverrides";

package/dist/src/sdk.js

@@ -1,5 +1,5 @@
 import { createZapierSdkWithoutRegistry, registryPlugin, } from "@zapier/zapier-sdk";
-import { loginPlugin, logoutPlugin, mcpPlugin, bundleCodePlugin, getLoginConfigPathPlugin, addPlugin, generateAppTypesPlugin, buildManifestPlugin, feedbackPlugin, } from "./plugins/index";
+import { loginPlugin, logoutPlugin, mcpPlugin, bundleCodePlugin, getLoginConfigPathPlugin, addPlugin, generateAppTypesPlugin, buildManifestPlugin, feedbackPlugin, curlPlugin, cliOverridesPlugin, } from "./plugins/index";
 /**
  * Create a Zapier SDK instance configured specifically for the CLI
  * Includes all CLI-specific plugins in addition to the standard SDK functionality
@@ -17,9 +17,12 @@ export function createZapierCliSdk(options = {}) {
         .addPlugin(getLoginConfigPathPlugin)
         .addPlugin(addPlugin)
         .addPlugin(feedbackPlugin)
+        .addPlugin(curlPlugin)
         .addPlugin(mcpPlugin)
         .addPlugin(loginPlugin)
         .addPlugin(logoutPlugin)
+        // Apply CLI-specific overrides (e.g., hide fetch in favor of curl)
+        .addPlugin(cliOverridesPlugin)
         // Add registry plugin to finalize SDK
         .addPlugin(registryPlugin));
 }