@zapier/zapier-sdk-cli 0.44.1 → 0.46.0

package/dist/src/generators/ast-generator.js

@@ -27,7 +27,7 @@ export class AstTypeGenerator {
         // Fetch all input fields with concurrency limiting for better reliability
         // Using batch() instead of Promise.allSettled() prevents overwhelming the API
         // and triggering rate limits when apps have many actions
-        const inputFieldsTasks = actions.map((action) => () => sdk.listInputFields({
+        const inputFieldsTasks = actions.map((action) => () => sdk.listActionInputFields({
             appKey: app.implementation_id,
             actionKey: action.key,
             actionType: action.action_type,

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

@@ -105,7 +105,7 @@ export declare const addPlugin: (sdk: {
         };
     };
 } & {
-    listInputFields: (options?: (({
+    listActionInputFields: (options?: (({
         app: string;
         actionType: "filter" | "read" | "read_bulk" | "run" | "search" | "search_and_write" | "search_or_write" | "write";
         action: string;
@@ -155,7 +155,7 @@ export declare const addPlugin: (sdk: {
 } & {
     context: {
         meta: {
-            listInputFields: import("@zapier/zapier-sdk").PluginMeta;
+            listActionInputFields: import("@zapier/zapier-sdk").PluginMeta;
         };
     };
 } & {

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

@@ -1,5 +1,5 @@
 import { BundleCodeSchema } from "./schemas";
-import { createPluginMethod, definePlugin, } from "@zapier/zapier-sdk";
+import { createPluginMethod, definePlugin, ZapierBundleError, } from "@zapier/zapier-sdk";
 import { buildSync } from "esbuild";
 import * as fs from "fs";
 import * as path from "path";
@@ -9,15 +9,6 @@ export const bundleCodePlugin = definePlugin((sdk) => createPluginMethod(sdk, {
     inputSchema: BundleCodeSchema,
     handler: async ({ options }) => bundleCode(options),
 }));
-class ZapierBundleError extends Error {
-    constructor(message, details, originalError) {
-        super(message);
-        this.code = "ZAPIER_BUNDLE_ERROR";
-        this.name = "ZapierBundleError";
-        this.details = details;
-        this.originalError = originalError;
-    }
-}
 /**
  * Bundle TypeScript code into executable JavaScript (CLI version)
  */
@@ -42,7 +33,7 @@ async function bundleCode(options) {
         });
         if (result.errors.length > 0) {
             const errorMessages = result.errors.map((e) => e.text);
-            throw new ZapierBundleError(`Bundle failed: ${errorMessages.join(", ")}`, errorMessages);
+            throw new ZapierBundleError(`Bundle failed: ${errorMessages.join(", ")}`, { buildErrors: errorMessages });
         }
         const bundledCode = result.outputFiles?.[0]?.text;
         if (!bundledCode) {
@@ -65,6 +56,6 @@ async function bundleCode(options) {
         if (error instanceof ZapierBundleError) {
             throw error;
         }
-        throw new ZapierBundleError(`Bundle failed: ${error instanceof Error ? error.message : "Unknown error"}`, undefined, error instanceof Error ? error : undefined);
+        throw new ZapierBundleError(`Bundle failed: ${error instanceof Error ? error.message : "Unknown error"}`, { cause: error instanceof Error ? error : undefined });
     }
 }

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

@@ -3,7 +3,7 @@ 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";
+import { ZapierCurlExitError, parseHeaderLine, basicAuthHeader, deriveRemoteFilename, formatWriteOut, appendQueryParams, readAllStdin, resolveDataArgText, resolveDataArgBinary, buildFormData, } from "./utils";
 export const curlPlugin = definePlugin((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, connection: connectionParam, connectionId, } = options;
@@ -195,7 +195,7 @@ export const curlPlugin = definePlugin((sdk) => {
             if (!silent || showError) {
                 process.stderr.write(`curl: (22) The requested URL returned error: ${response.status}\n`);
             }
-            throw new CurlExitError("HTTP request failed", 22);
+            throw new ZapierCurlExitError("HTTP request failed", 22);
         }
         return undefined;
     }

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

@@ -1,7 +1,17 @@
-export declare class CurlExitError extends Error {
+import { ZapierError } from "@zapier/zapier-sdk";
+/**
+ * Thrown when a curl-style invocation fails — captures the exit code so
+ * the CLI can surface it (mirrors curl's own non-zero exit codes for
+ * different failure modes).
+ */
+export declare class ZapierCurlExitError extends ZapierError {
+    readonly name = "ZapierCurlExitError";
+    readonly code: "ZAPIER_CURL_EXIT_ERROR";
     exitCode: number;
     constructor(message: string, exitCode: number);
 }
+/** @deprecated Use {@link ZapierCurlExitError} instead. */
+export declare const CurlExitError: typeof ZapierCurlExitError;
 export declare function parseHeaderLine(input: string): {
     key: string;
     value: string;

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

@@ -1,13 +1,22 @@
 import { createHash } from "crypto";
 import { promises as fs } from "fs";
 import { basename } from "path";
-export class CurlExitError extends Error {
+import { ZapierError } from "@zapier/zapier-sdk";
+/**
+ * Thrown when a curl-style invocation fails — captures the exit code so
+ * the CLI can surface it (mirrors curl's own non-zero exit codes for
+ * different failure modes).
+ */
+export class ZapierCurlExitError extends ZapierError {
     constructor(message, exitCode) {
         super(message);
+        this.name = "ZapierCurlExitError";
+        this.code = "ZAPIER_CURL_EXIT_ERROR";
         this.exitCode = exitCode;
-        this.name = "CurlExitError";
     }
 }
+/** @deprecated Use {@link ZapierCurlExitError} instead. */
+export const CurlExitError = ZapierCurlExitError;
 export function parseHeaderLine(input) {
     const idx = input.indexOf(":");
     if (idx === -1) {
@@ -102,18 +111,18 @@ export async function resolveDataArgBinary(raw) {
 }
 export async function buildFormData(formArgs, formStringArgs) {
     if (typeof FormData === "undefined") {
-        throw new CurlExitError("FormData is not available in this runtime; cannot use --form.", 2);
+        throw new ZapierCurlExitError("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);
+            throw new ZapierCurlExitError(`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);
+            throw new ZapierCurlExitError(`Invalid form field: '${item}'. Field name cannot be empty.`, 2);
         }
         if (!forceString && value.startsWith("@")) {
             const filePath = value.slice(1);

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

@@ -0,0 +1,46 @@
+import { z } from "zod";
+import type { ZapierSdk } from "@zapier/zapier-sdk/experimental";
+type SdkWithDrainTriggerInbox = {
+    drainTriggerInbox: ZapierSdk["drainTriggerInbox"];
+    context: {
+        meta: {
+            drainTriggerInbox: {
+                inputSchema?: z.ZodObject;
+                [key: string]: unknown;
+            };
+        };
+    };
+};
+/**
+ * CLI command for `drain-trigger-inbox`. `--continue-on-error` flows
+ * through from the auto-generated SDK schema flag; without it, the
+ * first handler failure rejects (fail-fast). For exec / exec-shell
+ * and interactive modes, errors print live to stderr via `onError` so
+ * they appear next to the message that failed (rather than in a
+ * deferred dump at the end).
+ *
+ * `--json` mode collects messages into a `data` array and prints
+ * `{ data, errors }` once at the end — that's its contract. We
+ * always pass `continueOnError: true` in JSON mode so partial
+ * failures don't truncate the envelope.
+ */
+export declare const drainTriggerInboxCliPlugin: (sdk: SdkWithDrainTriggerInbox & {
+    context: {
+        meta: Record<string, import("@zapier/zapier-sdk").PluginMeta>;
+    };
+}) => {
+    drainTriggerInbox: ZapierSdk["drainTriggerInbox"];
+    context: {
+        meta: {
+            drainTriggerInbox: {
+                inputSchema: z.ZodObject<{
+                    exec: z.ZodOptional<z.ZodString>;
+                    execShell: z.ZodOptional<z.ZodString>;
+                    json: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>;
+                packages: undefined;
+            };
+        };
+    };
+};
+export {};

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

@@ -0,0 +1,178 @@
+import { z } from "zod";
+import { definePlugin, ZapierReleaseTriggerMessageSignal, } from "@zapier/zapier-sdk";
+import { jsonReplacer } from "../../utils/cli-renderer";
+import { CliSkipLeaseExpireError, combineSignals, createInteractiveCallback, getPostDashArgs, printDrainError, printDrainSummary, rejectExecJsonMutex, requireInteractiveTty, runExecCommand, runShellCommand, warnInteractiveContinueOnErrorOverride, } from "../../utils/triggerDrain";
+const JsonProperty = z
+    .boolean()
+    .optional()
+    .describe("Format the drained result as a JSON object on stdout: { data, errors }. Use for scripts or piping. Mutually exclusive with --exec / --exec-shell and the interactive default.");
+// Both `--exec` and `--exec-shell` are CLI-only: the SDK exposes only
+// `onMessage`, and the CLI plugin wraps these flags into an onMessage
+// before delegating. On the CLI, the binary is the flag value and any
+// argv after a literal `--` is appended (xargs / npm-run convention).
+const ExecCliProperty = z
+    .string()
+    .optional()
+    .describe("Run a binary per message with no shell interpretation. Message JSON is piped to stdin; exit code 0 acks, non-zero records the error per the same rules as a thrown handler. Pass extra argv after `--` (e.g. `--exec ./handler -- --verbose`). Mutually exclusive with --exec-shell and --json.");
+const ExecShellCliProperty = z
+    .string()
+    .optional()
+    .describe("Run a shell command per message. Message JSON is piped to the subprocess on stdin; exit code 0 acks, non-zero records the error per the same rules as a thrown handler. Interpreted by the platform's default shell (sh on POSIX, cmd.exe on Windows). Mutually exclusive with --exec and --json.");
+/**
+ * CLI command for `drain-trigger-inbox`. `--continue-on-error` flows
+ * through from the auto-generated SDK schema flag; without it, the
+ * first handler failure rejects (fail-fast). For exec / exec-shell
+ * and interactive modes, errors print live to stderr via `onError` so
+ * they appear next to the message that failed (rather than in a
+ * deferred dump at the end).
+ *
+ * `--json` mode collects messages into a `data` array and prints
+ * `{ data, errors }` once at the end — that's its contract. We
+ * always pass `continueOnError: true` in JSON mode so partial
+ * failures don't truncate the envelope.
+ */
+export const drainTriggerInboxCliPlugin = definePlugin((sdk) => {
+    const original = sdk.drainTriggerInbox;
+    const existingMeta = sdk.context.meta.drainTriggerInbox;
+    const baseInputSchema = existingMeta.inputSchema;
+    // `.extend` overrides `exec` from the SDK's array form to the CLI's
+    // single-string form. The post-`--` argv is reattached by the
+    // handler below before `runExecCommand`.
+    const extendedInputSchema = baseInputSchema
+        ? baseInputSchema.extend({
+            exec: ExecCliProperty,
+            execShell: ExecShellCliProperty,
+            json: JsonProperty,
+        })
+        : z.object({
+            exec: ExecCliProperty,
+            execShell: ExecShellCliProperty,
+            json: JsonProperty,
+        });
+    return {
+        drainTriggerInbox: (async (options) => {
+            const { json, exec, execShell, ...sdkArgs } = options;
+            rejectExecJsonMutex({ exec, execShell, json });
+            // Validate TTY before installing the SIGINT handler / finally,
+            // so a preflight failure doesn't print a misleading
+            // "Processed 0 messages" summary on its way out.
+            if (!exec && !execShell && !json) {
+                requireInteractiveTty("drain-trigger-inbox");
+            }
+            // SIGINT in non-interactive modes → kill subprocesses cleanly.
+            const sigintController = new AbortController();
+            const onSigint = () => sigintController.abort();
+            process.on("SIGINT", onSigint);
+            const combined = combineSignals(sdkArgs.signal, sigintController.signal);
+            let fulfilled = 0;
+            let rejected = 0;
+            let skipped = 0;
+            const liveOnError = (reason, message) => {
+                rejected++;
+                printDrainError(reason, message);
+            };
+            try {
+                // --exec: direct binary invocation (no shell). Append any
+                // argv after a literal `--` so users can pass flags to the
+                // exec'd binary without quoting tricks.
+                if (exec) {
+                    const execArgv = [exec, ...getPostDashArgs()];
+                    await original({
+                        ...sdkArgs,
+                        signal: combined.signal,
+                        onMessage: async (message) => {
+                            await runExecCommand(execArgv, message, combined.signal);
+                            fulfilled++;
+                        },
+                        onError: liveOnError,
+                    });
+                    return;
+                }
+                // --exec-shell: shell handler. Errors print live; user's
+                // --continue-on-error decides whether to keep going.
+                if (execShell) {
+                    await original({
+                        ...sdkArgs,
+                        signal: combined.signal,
+                        onMessage: async (message) => {
+                            await runShellCommand(execShell, message, combined.signal);
+                            fulfilled++;
+                        },
+                        onError: liveOnError,
+                    });
+                    return;
+                }
+                // --json: collect into envelope. Always continue-on-error
+                // because partial-result truncation isn't useful here.
+                if (json) {
+                    const data = [];
+                    const errors = [];
+                    await original({
+                        ...sdkArgs,
+                        signal: combined.signal,
+                        continueOnError: true,
+                        onMessage: (message) => {
+                            data.push(message);
+                        },
+                        onError: (reason, message) => {
+                            errors.push({ reason, message });
+                        },
+                    });
+                    process.stdout.write(JSON.stringify({ data, errors }, jsonReplacer, 2) + "\n");
+                    return;
+                }
+                // Default: interactive triage. continueOnError forced true
+                // so "skip (let lease expire)" doesn't tear down the loop.
+                // No onError — user-driven skips aren't errors worth
+                // reporting, and real SDK failures still propagate. TTY
+                // validation already ran above the try block.
+                if (sdkArgs.continueOnError === false) {
+                    warnInteractiveContinueOnErrorOverride();
+                }
+                const interactive = createInteractiveCallback();
+                await original({
+                    ...sdkArgs,
+                    signal: combined.signal,
+                    concurrency: 1,
+                    continueOnError: true,
+                    onMessage: async (message) => {
+                        try {
+                            await interactive(message);
+                            fulfilled++;
+                        }
+                        catch (err) {
+                            // Count both skip flavors (release-after-draining +
+                            // let-lease-expire) toward `skipped` so the final
+                            // summary's total matches what the user actually saw.
+                            // Quit (ZapierAbortDrainSignal) and unknown errors
+                            // fall through uncounted — quit ends the drain and
+                            // unknown errors are pre-existing silently-swallowed
+                            // behavior in interactive mode.
+                            if (err instanceof ZapierReleaseTriggerMessageSignal ||
+                                err instanceof CliSkipLeaseExpireError) {
+                                skipped++;
+                            }
+                            throw err;
+                        }
+                    },
+                });
+            }
+            finally {
+                process.off("SIGINT", onSigint);
+                combined.dispose();
+                if (!json) {
+                    printDrainSummary({ fulfilled, rejected, skipped });
+                }
+            }
+        }),
+        context: {
+            meta: {
+                drainTriggerInbox: {
+                    ...existingMeta,
+                    inputSchema: extendedInputSchema,
+                    packages: undefined,
+                },
+            },
+        },
+    };
+});

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

@@ -106,7 +106,7 @@ export declare const generateAppTypesPlugin: (sdk: {
         };
     };
 } & {
-    listInputFields: (options?: (({
+    listActionInputFields: (options?: (({
         app: string;
         actionType: "filter" | "read" | "read_bulk" | "run" | "search" | "search_and_write" | "search_or_write" | "write";
         action: string;
@@ -156,7 +156,7 @@ export declare const generateAppTypesPlugin: (sdk: {
 } & {
     context: {
         meta: {
-            listInputFields: import("@zapier/zapier-sdk").PluginMeta;
+            listActionInputFields: import("@zapier/zapier-sdk").PluginMeta;
         };
     };
 } & {

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

@@ -10,3 +10,5 @@ export { feedbackPlugin } from "./feedback";
 export { curlPlugin } from "./curl";
 export { cliOverridesPlugin } from "./cliOverrides";
 export { initPlugin } from "./init";
+export { drainTriggerInboxCliPlugin } from "./drainTriggerInbox";
+export { watchTriggerInboxCliPlugin } from "./watchTriggerInbox";

package/dist/src/plugins/index.js

@@ -10,3 +10,5 @@ export { feedbackPlugin } from "./feedback";
 export { curlPlugin } from "./curl";
 export { cliOverridesPlugin } from "./cliOverrides";
 export { initPlugin } from "./init";
+export { drainTriggerInboxCliPlugin } from "./drainTriggerInbox";
+export { watchTriggerInboxCliPlugin } from "./watchTriggerInbox";

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

@@ -5,6 +5,7 @@ export declare const mcpPlugin: (sdk: {
             debug?: boolean;
         };
         extensions?: Plugin<unknown, PluginProvides>[];
+        experimental?: boolean;
     };
 } & {
     context: import("@zapier/zapier-sdk").EventEmissionContext;

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

@@ -9,11 +9,15 @@ export const mcpPlugin = definePlugin((sdk) => createPluginMethod(sdk, {
         // Forward debug + the extensions resolved at CLI startup so the MCP
         // server's registry includes extension functions as tools. Without
         // this forward, MCP would build a vanilla SDK and the CLI/MCP
-        // surfaces would diverge.
+        // surfaces would diverge. The `experimental` flag (set by the
+        // experimental CLI factory) tells the MCP server to build against
+        // `@zapier/zapier-sdk/experimental` so experimental tools are
+        // exposed.
         await startMcpServer({
             ...options,
             debug: sdk.context.options?.debug,
             extensions: sdk.context.extensions,
+            experimental: sdk.context.experimental,
         });
     },
 }));

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

@@ -0,0 +1,45 @@
+import { z } from "zod";
+import type { ZapierSdk } from "@zapier/zapier-sdk/experimental";
+type SdkWithWatchTriggerInbox = {
+    watchTriggerInbox: ZapierSdk["watchTriggerInbox"];
+    context: {
+        meta: {
+            watchTriggerInbox: {
+                inputSchema?: z.ZodObject;
+                [key: string]: unknown;
+            };
+        };
+    };
+};
+/**
+ * CLI command for `watch-trigger-inbox`. Same flag dispatch as
+ * drain-trigger-inbox. `--continue-on-error` flows through from the
+ * auto-generated SDK schema flag; without it, the first handler
+ * failure rejects (fail-fast). Errors print live to stderr via
+ * `onError`, not buffered until the end — for a forever loop "the
+ * end" is Ctrl-C, which is too late.
+ *
+ * `--json` for watch is NDJSON streaming (one record per line)
+ * rather than a final envelope. The watch loop has no terminal
+ * aggregate to format.
+ */
+export declare const watchTriggerInboxCliPlugin: (sdk: SdkWithWatchTriggerInbox & {
+    context: {
+        meta: Record<string, import("@zapier/zapier-sdk").PluginMeta>;
+    };
+}) => {
+    watchTriggerInbox: ZapierSdk["watchTriggerInbox"];
+    context: {
+        meta: {
+            watchTriggerInbox: {
+                inputSchema: z.ZodObject<{
+                    exec: z.ZodOptional<z.ZodString>;
+                    execShell: z.ZodOptional<z.ZodString>;
+                    json: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>;
+                packages: undefined;
+            };
+        };
+    };
+};
+export {};

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

@@ -0,0 +1,157 @@
+import { z } from "zod";
+import { definePlugin, ZapierReleaseTriggerMessageSignal, } from "@zapier/zapier-sdk";
+import { CliSkipLeaseExpireError, combineSignals, createInteractiveCallback, createNdjsonCallback, getPostDashArgs, printDrainError, printDrainSummary, rejectExecJsonMutex, requireInteractiveTty, runExecCommand, runShellCommand, warnInteractiveContinueOnErrorOverride, } from "../../utils/triggerDrain";
+const JsonProperty = z
+    .boolean()
+    .optional()
+    .describe("Stream each message as JSON to stdout (one record per line, NDJSON), acking as each write completes. Use for piping to other tools. Mutually exclusive with --exec / --exec-shell and the interactive default.");
+// Both `--exec` and `--exec-shell` are CLI-only — see drainTriggerInbox/index.ts.
+const ExecCliProperty = z
+    .string()
+    .optional()
+    .describe("Run a binary per message with no shell interpretation. Message JSON is piped to stdin; exit code 0 acks, non-zero records the error per the same rules as a thrown handler. Pass extra argv after `--` (e.g. `--exec ./handler -- --verbose`). Mutually exclusive with --exec-shell and --json.");
+const ExecShellCliProperty = z
+    .string()
+    .optional()
+    .describe("Run a shell command per message. Message JSON is piped to the subprocess on stdin; exit code 0 acks, non-zero records the error per the same rules as a thrown handler. Interpreted by the platform's default shell (sh on POSIX, cmd.exe on Windows). Mutually exclusive with --exec and --json.");
+/**
+ * CLI command for `watch-trigger-inbox`. Same flag dispatch as
+ * drain-trigger-inbox. `--continue-on-error` flows through from the
+ * auto-generated SDK schema flag; without it, the first handler
+ * failure rejects (fail-fast). Errors print live to stderr via
+ * `onError`, not buffered until the end — for a forever loop "the
+ * end" is Ctrl-C, which is too late.
+ *
+ * `--json` for watch is NDJSON streaming (one record per line)
+ * rather than a final envelope. The watch loop has no terminal
+ * aggregate to format.
+ */
+export const watchTriggerInboxCliPlugin = definePlugin((sdk) => {
+    const original = sdk.watchTriggerInbox;
+    const existingMeta = sdk.context.meta.watchTriggerInbox;
+    const baseInputSchema = existingMeta.inputSchema;
+    const extendedInputSchema = baseInputSchema
+        ? baseInputSchema.extend({
+            exec: ExecCliProperty,
+            execShell: ExecShellCliProperty,
+            json: JsonProperty,
+        })
+        : z.object({
+            exec: ExecCliProperty,
+            execShell: ExecShellCliProperty,
+            json: JsonProperty,
+        });
+    return {
+        watchTriggerInbox: (async (options) => {
+            const { json, exec, execShell, ...sdkArgs } = options;
+            rejectExecJsonMutex({ exec, execShell, json });
+            // Validate TTY before installing the SIGINT handler / finally,
+            // so a preflight failure doesn't print a misleading
+            // "Processed 0 messages" summary on its way out.
+            if (!exec && !execShell && !json) {
+                requireInteractiveTty("watch-trigger-inbox");
+            }
+            // SIGINT + user signal → combined.
+            const sigintController = new AbortController();
+            const onSigint = () => sigintController.abort();
+            process.on("SIGINT", onSigint);
+            const combined = combineSignals(sdkArgs.signal, sigintController.signal);
+            let fulfilled = 0;
+            let rejected = 0;
+            let skipped = 0;
+            const liveOnError = (reason, message) => {
+                rejected++;
+                printDrainError(reason, message);
+            };
+            try {
+                if (exec) {
+                    const execArgv = [exec, ...getPostDashArgs()];
+                    await original({
+                        ...sdkArgs,
+                        signal: combined.signal,
+                        onMessage: async (message) => {
+                            await runExecCommand(execArgv, message, combined.signal);
+                            fulfilled++;
+                        },
+                        onError: liveOnError,
+                    });
+                }
+                else if (execShell) {
+                    await original({
+                        ...sdkArgs,
+                        signal: combined.signal,
+                        onMessage: async (message) => {
+                            await runShellCommand(execShell, message, combined.signal);
+                            fulfilled++;
+                        },
+                        onError: liveOnError,
+                    });
+                }
+                else if (json) {
+                    const ndjson = createNdjsonCallback();
+                    await original({
+                        ...sdkArgs,
+                        signal: combined.signal,
+                        onMessage: async (message) => {
+                            await ndjson(message);
+                            fulfilled++;
+                        },
+                        onError: liveOnError,
+                    });
+                }
+                else {
+                    // Interactive: continueOnError is forced true so the user's
+                    // "skip (let lease expire)" choice (which throws a plain
+                    // Error) doesn't tear down the loop. We don't pass onError
+                    // here — user-driven skips aren't errors worth reporting,
+                    // and SDK-level failures still propagate as a rejection.
+                    // TTY validation already ran above the try block.
+                    if (sdkArgs.continueOnError === false) {
+                        warnInteractiveContinueOnErrorOverride();
+                    }
+                    const interactive = createInteractiveCallback();
+                    await original({
+                        ...sdkArgs,
+                        signal: combined.signal,
+                        concurrency: 1,
+                        continueOnError: true,
+                        onMessage: async (message) => {
+                            try {
+                                await interactive(message);
+                                fulfilled++;
+                            }
+                            catch (err) {
+                                // See drainTriggerInbox for the counting policy: both
+                                // skip flavors land in `skipped`; quit and unknown
+                                // errors fall through uncounted.
+                                if (err instanceof ZapierReleaseTriggerMessageSignal ||
+                                    err instanceof CliSkipLeaseExpireError) {
+                                    skipped++;
+                                }
+                                throw err;
+                            }
+                        },
+                    });
+                }
+            }
+            finally {
+                process.off("SIGINT", onSigint);
+                combined.dispose();
+                // NDJSON mode emitted everything per-line; printing a
+                // summary on top would mix with the data stream.
+                if (!json) {
+                    printDrainSummary({ fulfilled, rejected, skipped });
+                }
+            }
+        }),
+        context: {
+            meta: {
+                watchTriggerInbox: {
+                    ...existingMeta,
+                    inputSchema: extendedInputSchema,
+                    packages: undefined,
+                },
+            },
+        },
+    };
+});

package/dist/src/sdk.js

@@ -1,6 +1,10 @@
 import * as cliLogin from "./login";
 import { createZapierSdk, injectCliLogin, } from "@zapier/zapier-sdk";
-import { loginPlugin, logoutPlugin, mcpPlugin, bundleCodePlugin, getLoginConfigPathPlugin, addPlugin, generateAppTypesPlugin, buildManifestPlugin, feedbackPlugin, curlPlugin, cliOverridesPlugin, initPlugin, } from "./plugins/index";
+import { loginPlugin, logoutPlugin, mcpPlugin, bundleCodePlugin, getLoginConfigPathPlugin, addPlugin, generateAppTypesPlugin, buildManifestPlugin, feedbackPlugin, curlPlugin, cliOverridesPlugin, initPlugin,
+// drainTriggerInboxForeverCliPlugin is experimental — registered only
+// in `./experimental.ts`. See the "Experimental gating" section in
+// `docs/design/2026-05-01-triggers-in-sdk.md`.
+ } from "./plugins/index";
 import packageJson from "../package.json" with { type: "json" };
 injectCliLogin(cliLogin);
 /**