@zapier/zapier-sdk-cli 0.44.0 → 0.45.0

package/dist/cli.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { Command, CommanderError, Option } from 'commander';
 import { z } from 'zod';
-import { definePlugin, createPluginMethod, buildApplicationLifecycleEvent, OutputPropertySchema, DEFAULT_CONFIG_PATH, ZapierValidationError, ZapierUnknownError, injectCliLogin, BaseSdkOptionsSchema, isCredentialsObject, batch, toSnakeCase, createZapierSdk, ZapierError, isPositional, runWithTelemetryContext, buildCapabilityMessage, formatErrorMessage, getOsInfo, getPlatformVersions, getCiPlatform, isCi, getReleaseId, getCurrentTimestamp, generateEventId } from '@zapier/zapier-sdk';
+import { definePlugin, createPluginMethod, buildApplicationLifecycleEvent, OutputPropertySchema, ZapierBundleError, DEFAULT_CONFIG_PATH, ZapierValidationError, ZapierUnknownError, ZapierReleaseTriggerMessageSignal, injectCliLogin, BaseSdkOptionsSchema, isCredentialsObject, batch, toSnakeCase, ZapierAbortDrainSignal, createZapierSdk as createZapierSdk$1, ZapierError, isPositional, runWithTelemetryContext, buildCapabilityMessage, formatErrorMessage, getOsInfo, getPlatformVersions, getCiPlatform, isCi, getReleaseId, getCurrentTimestamp, generateEventId } from '@zapier/zapier-sdk';
 import inquirer from 'inquirer';
 import chalk7 from 'chalk';
 import ora from 'ora';
@@ -24,9 +24,10 @@ import { buildSync } from 'esbuild';
 import { mkdir, writeFile, access } from 'fs/promises';
 import * as ts from 'typescript';
 import isInstalledGlobally from 'is-installed-globally';
-import { execSync } from 'child_process';
+import { execSync, spawn } from 'child_process';
 import Handlebars from 'handlebars';
 import { fileURLToPath } from 'url';
+import { injectCliLogin as injectCliLogin$1, createZapierSdk } from '@zapier/zapier-sdk/experimental';
 import packageJsonLib from 'package-json';
 import semver from 'semver';
 
@@ -82,7 +83,7 @@ function formatZodError(error) {
 }
 function getLocalResolutionOrder(paramName, resolvers, resolved = /* @__PURE__ */ new Set()) {
   const resolver = resolvers[paramName];
-  if (!resolver || resolver.type === "static") {
+  if (!resolver || resolver.type === "static" || resolver.type === "constant") {
     return [paramName];
   }
   const order = [];
@@ -165,7 +166,11 @@ var SchemaParameterResolver = class {
         }
         return parseResult.data;
       }
-      const resolvedParams = { ...providedParams };
+      const resolverConstants = this.getResolverConstants(sdk, functionName);
+      const resolvedParams = {
+        ...resolverConstants,
+        ...providedParams
+      };
       const context = {
         sdk,
         currentParams: providedParams,
@@ -326,12 +331,22 @@ var SchemaParameterResolver = class {
     const missingParams = [];
     for (const param of params) {
       const resolver = this.getResolver(param.name, context.sdk, functionName);
-      const autoResolution = resolver?.type === "dynamic" ? await this.tryAutoResolve(resolver, context) : null;
-      if (autoResolution != null) {
+      let autoResolved = null;
+      if (resolver?.type === "constant") {
+        autoResolved = {
+          resolvedValue: resolver.value
+        };
+      } else if (resolver?.type === "dynamic") {
+        autoResolved = await this.tryAutoResolve(
+          resolver,
+          context
+        );
+      }
+      if (autoResolved != null) {
         this.setNestedValue(
           resolvedParams,
           param.path,
-          autoResolution.resolvedValue
+          autoResolved.resolvedValue
         );
         context.resolvedParams = resolvedParams;
       } else {
@@ -365,7 +380,11 @@ var SchemaParameterResolver = class {
     const promptLabel = inArrayContext ? `${param.name}[${arrayIndex}]` : param.name;
     const promptName = inArrayContext ? "value" : param.name;
     this.debugLog(`Resolving ${promptLabel}${isOptional ? " (optional)" : ""}`);
-    if (resolver.type === "static") {
+    if (resolver.type === "constant") {
+      const constantResolver = resolver;
+      this.stopSpinner();
+      return constantResolver.value;
+    } else if (resolver.type === "static") {
       const staticResolver = resolver;
       const promptConfig = {
         type: staticResolver.inputType === "password" ? "password" : "input",
@@ -433,6 +452,14 @@ var SchemaParameterResolver = class {
           context.resolvedParams
         );
         promptConfig.name = promptName;
+        const hasSelectableChoice = promptConfig.choices?.some(
+          (c) => !c.disabled
+        );
+        if (!hasSelectableChoice && !hasMore) {
+          throw new ZapierCliValidationError(
+            `No ${promptLabel} available to select.`
+          );
+        }
         if (isOptional && promptConfig.choices) {
           promptConfig.choices.unshift({
             name: chalk7.dim("(Skip)"),
@@ -803,7 +830,7 @@ Optional fields${pathContext}:`));
         cursor ? `Fetching more choices for ${fieldMeta.title}` : `Fetching choices for ${fieldMeta.title}`
       );
       this.startSpinner();
-      const page = await context.sdk.listInputFieldChoices({
+      const page = await context.sdk.listActionInputFieldChoices({
         app: context.resolvedParams.app,
         action: context.resolvedParams.action,
         actionType: context.resolvedParams.actionType,
@@ -1040,6 +1067,23 @@ Optional fields${pathContext}:`));
     );
     return functionInfo?.resolvers || {};
   }
+  getResolverConstants(sdk, functionName) {
+    if (!functionName || typeof sdk.getRegistry !== "function") {
+      return {};
+    }
+    const registry = sdk.getRegistry();
+    const functionInfo = registry.functions.find(
+      (f) => f.name === functionName
+    );
+    const resolvers = functionInfo?.resolvers ?? {};
+    const constants = {};
+    for (const [key, resolver] of Object.entries(resolvers)) {
+      if (resolver && typeof resolver === "object" && resolver.type === "constant") {
+        constants[key] = resolver.value;
+      }
+    }
+    return constants;
+  }
 };
 
 // src/utils/cli-options.ts
@@ -1072,7 +1116,7 @@ var SHARED_COMMAND_CLI_OPTIONS = [
 
 // package.json
 var package_default = {
-  version: "0.44.0"};
+  version: "0.45.0"};
 
 // src/telemetry/builders.ts
 function createCliBaseEvent(context = {}) {
@@ -1283,8 +1327,18 @@ async function unwrapHttpResponse(response) {
     );
   }
 }
+function jsonReplacer(_key, value) {
+  if (value instanceof Error) {
+    return {
+      name: value.name,
+      message: value.message,
+      ...value.stack ? { stack: value.stack } : {}
+    };
+  }
+  return value;
+}
 function outputJson(envelope) {
-  console.log(JSON.stringify(envelope, null, 2));
+  console.log(JSON.stringify(envelope, jsonReplacer, 2));
 }
 function createJsonRenderer() {
   return {
@@ -1685,6 +1739,10 @@ function analyzeZodField(name, schema, functionInfo) {
       break;
     }
   }
+  const baseSchemaDef = baseSchema._zod?.def;
+  if (baseSchema instanceof z.ZodFunction || baseSchemaDef?.type === "custom") {
+    return null;
+  }
   let paramType = "string";
   let elementType;
   let choices;
@@ -1879,7 +1937,8 @@ function createCommandConfig(cliCommandName, functionInfo, sdk) {
       }
     }
   }
-  const description = functionInfo.description || schema?.description || `${cliCommandName} command`;
+  const baseDescription = functionInfo.description || schema?.description || `${cliCommandName} command`;
+  const description = functionInfo.experimental ? `${baseDescription} (experimental)` : baseDescription;
   const handler = async (...args) => {
     const startTime = Date.now();
     let success = true;
@@ -3115,7 +3174,8 @@ var mcpPlugin = definePlugin(
       await startMcpServer({
         ...options,
         debug: sdk2.context.options?.debug,
-        extensions: sdk2.context.extensions
+        extensions: sdk2.context.extensions,
+        experimental: sdk2.context.experimental
       });
     }
   })
@@ -3138,15 +3198,6 @@ var bundleCodePlugin = definePlugin(
     handler: async ({ options }) => bundleCode(options)
   })
 );
-var ZapierBundleError = class extends Error {
-  constructor(message, details, originalError) {
-    super(message);
-    this.code = "ZAPIER_BUNDLE_ERROR";
-    this.name = "ZapierBundleError";
-    this.details = details;
-    this.originalError = originalError;
-  }
-};
 async function bundleCode(options) {
   const {
     input,
@@ -3176,7 +3227,7 @@ async function bundleCode(options) {
       const errorMessages = result.errors.map((e) => e.text);
       throw new ZapierBundleError(
         `Bundle failed: ${errorMessages.join(", ")}`,
-        errorMessages
+        { buildErrors: errorMessages }
       );
     }
     const bundledCode = result.outputFiles?.[0]?.text;
@@ -3198,8 +3249,7 @@ async function bundleCode(options) {
     }
     throw new ZapierBundleError(
       `Bundle failed: ${error instanceof Error ? error.message : "Unknown error"}`,
-      void 0,
-      error instanceof Error ? error : void 0
+      { cause: error instanceof Error ? error : void 0 }
     );
   }
 }
@@ -3374,7 +3424,7 @@ var AstTypeGenerator = class {
     const actions = actionsResult.data;
     const actionsWithFields = [];
     const inputFieldsTasks = actions.map(
-      (action) => () => sdk.listInputFields({
+      (action) => () => sdk.listActionInputFields({
         appKey: app.implementation_id,
         actionKey: action.key,
         actionType: action.action_type,
@@ -4251,11 +4301,12 @@ var CurlSchema = z.object({
   /** @deprecated Use `connection` instead. */
   connectionId: z.union([z.string(), z.number()]).optional().meta({ deprecated: true })
 }).describe("Make HTTP requests through Zapier Relay with curl-like options");
-var CurlExitError = class extends Error {
+var ZapierCurlExitError = class extends ZapierError {
   constructor(message, exitCode) {
     super(message);
+    this.name = "ZapierCurlExitError";
+    this.code = "ZAPIER_CURL_EXIT_ERROR";
     this.exitCode = exitCode;
-    this.name = "CurlExitError";
   }
 };
 function parseHeaderLine(input) {
@@ -4347,7 +4398,7 @@ async function resolveDataArgBinary(raw) {
 }
 async function buildFormData(formArgs, formStringArgs) {
   if (typeof FormData === "undefined") {
-    throw new CurlExitError(
+    throw new ZapierCurlExitError(
       "FormData is not available in this runtime; cannot use --form.",
       2
     );
@@ -4356,7 +4407,7 @@ async function buildFormData(formArgs, formStringArgs) {
   const addField = async (item, forceString) => {
     const idx = item.indexOf("=");
     if (idx === -1) {
-      throw new CurlExitError(
+      throw new ZapierCurlExitError(
         `Invalid form field: '${item}'. Expected 'name=value' or 'name=@file'.`,
         2
       );
@@ -4364,7 +4415,7 @@ async function buildFormData(formArgs, formStringArgs) {
     const name = item.slice(0, idx);
     const value = item.slice(idx + 1);
     if (!name) {
-      throw new CurlExitError(
+      throw new ZapierCurlExitError(
         `Invalid form field: '${item}'. Field name cannot be empty.`,
         2
       );
@@ -4601,7 +4652,7 @@ ${Array.from(
 `
         );
       }
-      throw new CurlExitError("HTTP request failed", 22);
+      throw new ZapierCurlExitError("HTTP request failed", 22);
     }
     return void 0;
   }
@@ -5147,11 +5198,481 @@ var initPlugin = definePlugin(
     }
   })
 );
+var CliSkipLeaseExpireError = class extends Error {
+  constructor() {
+    super("user skipped (let lease expire)");
+    this.name = "CliSkipLeaseExpireError";
+  }
+};
+function createInteractiveCallback() {
+  let messageNumber = 0;
+  return async (message) => {
+    messageNumber++;
+    const attrs = message.message_attributes;
+    console.log(
+      `
+${chalk7.bold(`Message #${messageNumber}`)} ${chalk7.dim(message.id)} ${chalk7.dim(`(lease #${attrs.lease_count})`)}`
+    );
+    if (attrs.error_message) {
+      console.log(chalk7.yellow(`  upstream error: ${attrs.error_message}`));
+    }
+    if (attrs.possible_duplicate_data) {
+      console.log(chalk7.yellow("  possible duplicate data"));
+    }
+    while (true) {
+      let action;
+      try {
+        const answer = await inquirer.prompt([
+          {
+            type: "list",
+            name: "action",
+            message: "Action?",
+            choices: [
+              { name: "Ack (remove from inbox)", value: "ack" },
+              {
+                name: "Skip (release after draining)",
+                value: "skip-release"
+              },
+              { name: "Skip (let lease expire)", value: "skip-expire" },
+              { name: "View payload", value: "view" },
+              { name: "Quit", value: "quit" }
+            ]
+          }
+        ]);
+        action = answer.action;
+      } catch (error) {
+        if (error instanceof Error && error.name === "ExitPromptError") {
+          throw new ZapierAbortDrainSignal("user pressed Ctrl-C");
+        }
+        throw error;
+      }
+      if (action === "view") {
+        console.log(chalk7.dim(JSON.stringify(message.payload, null, 2)));
+        continue;
+      }
+      if (action === "ack") {
+        return;
+      }
+      if (action === "skip-release") {
+        throw new ZapierReleaseTriggerMessageSignal("user skipped (release)");
+      }
+      if (action === "skip-expire") {
+        throw new CliSkipLeaseExpireError();
+      }
+      if (action === "quit") {
+        throw new ZapierAbortDrainSignal("user requested quit");
+      }
+    }
+  };
+}
+function createNdjsonCallback() {
+  return (message) => new Promise((resolve4, reject) => {
+    process.stdout.write(JSON.stringify(message) + "\n", (err) => {
+      if (err) reject(err);
+      else resolve4();
+    });
+  });
+}
+function runSubprocess(options) {
+  const { command, args, shell, label, message, signal } = options;
+  return new Promise((resolve4, reject) => {
+    const child = spawn(command, args, {
+      shell,
+      stdio: ["pipe", "inherit", "inherit"]
+    });
+    let abortListener;
+    if (signal) {
+      if (signal.aborted) {
+        child.kill();
+      } else {
+        abortListener = () => {
+          child.kill();
+        };
+        signal.addEventListener("abort", abortListener, { once: true });
+      }
+    }
+    child.on("error", (err) => {
+      if (signal && abortListener) {
+        signal.removeEventListener("abort", abortListener);
+      }
+      reject(err);
+    });
+    child.on("close", (code) => {
+      if (signal && abortListener) {
+        signal.removeEventListener("abort", abortListener);
+      }
+      if (signal?.aborted) {
+        reject(new ZapierAbortDrainSignal(`${label} aborted`));
+        return;
+      }
+      if (code === 0) resolve4();
+      else
+        reject(
+          new Error(
+            `${label} exited with code ${code} for message ${message.id}`
+          )
+        );
+    });
+    child.stdin.on("error", (err) => {
+      if (err.code !== "EPIPE") reject(err);
+    });
+    child.stdin.end(JSON.stringify(message) + "\n");
+  });
+}
+function runShellCommand(command, message, signal) {
+  return runSubprocess({
+    command,
+    args: [],
+    shell: true,
+    label: "exec-shell",
+    message,
+    signal
+  });
+}
+function runExecCommand(argv, message, signal) {
+  if (argv.length === 0) {
+    return Promise.reject(
+      new Error("exec requires at least one element (the binary)")
+    );
+  }
+  const [command, ...args] = argv;
+  return runSubprocess({
+    command,
+    args,
+    shell: false,
+    label: "exec",
+    message,
+    signal
+  });
+}
+function describeReason(reason) {
+  return reason instanceof Error ? reason.message : String(reason);
+}
+function printDrainError(reason, message) {
+  console.error(
+    chalk7.red(`Error processing ${message.id}: ${describeReason(reason)}`)
+  );
+}
+function printDrainSummary(counts) {
+  const skipped = counts.skipped ?? 0;
+  const total = counts.fulfilled + counts.rejected + skipped;
+  const parts = [`${counts.fulfilled} fulfilled`];
+  if (skipped > 0) parts.push(`${skipped} skipped`);
+  parts.push(`${counts.rejected} rejected`);
+  console.log(
+    chalk7.dim(
+      `
+Processed ${total} message${total === 1 ? "" : "s"} (${parts.join(", ")}).`
+    )
+  );
+}
+function warnInteractiveContinueOnErrorOverride() {
+  console.warn(
+    chalk7.yellow(
+      'Note: continueOnError=false is overridden to true in interactive mode (the "Skip (let lease expire)" choice would otherwise terminate the drain).'
+    )
+  );
+}
+function requireInteractiveTty(commandName) {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    throw new ZapierCliValidationError(
+      `${commandName} needs an interactive terminal by default. Pass --exec '<bin>' (with optional \`-- args...\`) or --exec-shell '<cmd>' to run a script per message, or --json for non-interactive output.`
+    );
+  }
+}
+function rejectExecJsonMutex(opts) {
+  const picked = [
+    opts.exec ? "--exec" : null,
+    opts.execShell ? "--exec-shell" : null,
+    opts.json ? "--json" : null
+  ].filter((x) => x !== null);
+  if (picked.length > 1) {
+    throw new ZapierCliValidationError(
+      `${picked.join(", ")} are mutually exclusive. Pick one.`
+    );
+  }
+}
+function getPostDashArgs(argv = process.argv) {
+  const idx = argv.indexOf("--");
+  if (idx === -1) return [];
+  return argv.slice(idx + 1);
+}
+function combineSignals(a, b) {
+  if (!a) {
+    return { signal: b, dispose: () => void 0 };
+  }
+  const controller = new AbortController();
+  const onAbort = () => controller.abort();
+  if (a.aborted || b.aborted) controller.abort();
+  else {
+    a.addEventListener("abort", onAbort, { once: true });
+    b.addEventListener("abort", onAbort, { once: true });
+  }
+  return {
+    signal: controller.signal,
+    dispose: () => {
+      a.removeEventListener("abort", onAbort);
+      b.removeEventListener("abort", onAbort);
+    }
+  };
+}
+
+// src/plugins/drainTriggerInbox/index.ts
+var 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."
+);
+var 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."
+);
+var 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."
+);
+var drainTriggerInboxCliPlugin = definePlugin(
+  (sdk) => {
+    const original = sdk.drainTriggerInbox;
+    const existingMeta = sdk.context.meta.drainTriggerInbox;
+    const baseInputSchema = existingMeta.inputSchema;
+    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 });
+        if (!exec && !execShell && !json) {
+          requireInteractiveTty("drain-trigger-inbox");
+        }
+        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
+            });
+            return;
+          }
+          if (execShell) {
+            await original({
+              ...sdkArgs,
+              signal: combined.signal,
+              onMessage: async (message) => {
+                await runShellCommand(execShell, message, combined.signal);
+                fulfilled++;
+              },
+              onError: liveOnError
+            });
+            return;
+          }
+          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;
+          }
+          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) {
+                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: void 0
+          }
+        }
+      }
+    };
+  }
+);
+var JsonProperty2 = 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."
+);
+var ExecCliProperty2 = 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."
+);
+var ExecShellCliProperty2 = 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."
+);
+var watchTriggerInboxCliPlugin = definePlugin(
+  (sdk) => {
+    const original = sdk.watchTriggerInbox;
+    const existingMeta = sdk.context.meta.watchTriggerInbox;
+    const baseInputSchema = existingMeta.inputSchema;
+    const extendedInputSchema = baseInputSchema ? baseInputSchema.extend({
+      exec: ExecCliProperty2,
+      execShell: ExecShellCliProperty2,
+      json: JsonProperty2
+    }) : z.object({
+      exec: ExecCliProperty2,
+      execShell: ExecShellCliProperty2,
+      json: JsonProperty2
+    });
+    return {
+      watchTriggerInbox: async (options) => {
+        const { json, exec, execShell, ...sdkArgs } = options;
+        rejectExecJsonMutex({ exec, execShell, json });
+        if (!exec && !execShell && !json) {
+          requireInteractiveTty("watch-trigger-inbox");
+        }
+        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 {
+            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) {
+                  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: {
+          watchTriggerInbox: {
+            ...existingMeta,
+            inputSchema: extendedInputSchema,
+            packages: void 0
+          }
+        }
+      }
+    };
+  }
+);
 
 // package.json with { type: 'json' }
 var package_default2 = {
   name: "@zapier/zapier-sdk-cli",
-  version: "0.44.0"};
+  version: "0.45.0"};
 
 // src/sdk.ts
 injectCliLogin(login_exports);
@@ -5160,7 +5681,7 @@ function createZapierCliSdk(options = {}) {
   const extensionsContextPlugin = () => ({
     context: { extensions }
   });
-  let chain = createZapierSdk({
+  let chain = createZapierSdk$1({
     ...sdkOptions,
     eventEmission: { ...sdkOptions.eventEmission, callContext: "cli" },
     callerPackage: { name: package_default2.name, version: package_default2.version }
@@ -5176,6 +5697,31 @@ function createZapierCliSdk(options = {}) {
   }
   return chain;
 }
+injectCliLogin$1(login_exports);
+function createZapierCliSdk2(options = {}) {
+  const { extensions = [], ...sdkOptions } = options;
+  const extensionsContextPlugin = () => ({
+    context: { extensions }
+  });
+  const experimentalContextPlugin = () => ({
+    context: { experimental: true }
+  });
+  let chain = createZapierSdk({
+    ...sdkOptions,
+    eventEmission: { ...sdkOptions.eventEmission, callContext: "cli" },
+    callerPackage: { name: package_default2.name, version: package_default2.version }
+  }).addPlugin(extensionsContextPlugin).addPlugin(experimentalContextPlugin).addPlugin(generateAppTypesPlugin).addPlugin(buildManifestPlugin).addPlugin(bundleCodePlugin).addPlugin(getLoginConfigPathPlugin).addPlugin(addPlugin).addPlugin(feedbackPlugin).addPlugin(curlPlugin).addPlugin(initPlugin).addPlugin(drainTriggerInboxCliPlugin, { override: true }).addPlugin(watchTriggerInboxCliPlugin, { override: true }).addPlugin(mcpPlugin).addPlugin(loginPlugin).addPlugin(logoutPlugin).addPlugin(cliOverridesPlugin);
+  for (const ext of extensions) {
+    try {
+      chain = chain.addPlugin(ext);
+    } catch (err) {
+      console.warn(
+        `Extension plugin failed to construct: ${err.message}; skipping.`
+      );
+    }
+  }
+  return chain;
+}
 
 // src/utils/extensions.ts
 var ENV_VAR = "ZAPIER_SDK_EXTENSIONS";
@@ -5388,7 +5934,7 @@ program.name("zapier-sdk").description("CLI for Zapier SDK").version(
 ).option(
   "--max-network-retry-delay-ms <ms>",
   "Max delay in ms to wait for rate limit retry (default: 60000)"
-);
+).option("--experimental", "Use the experimental SDK / CLI surface");
 var booleanFlags = [];
 for (const [key, fieldSchema] of Object.entries(
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -5453,11 +5999,13 @@ for (const { camelName, kebabFlag } of booleanFlags) {
     flagOverrides[camelName] = true;
   }
 }
+var useExperimental = process.argv.includes("--experimental") || process.env.ZAPIER_EXPERIMENTAL === "1" || process.env.ZAPIER_EXPERIMENTAL === "true";
+var createZapierCliSdk3 = useExperimental ? createZapierCliSdk2 : createZapierCliSdk;
 program.exitOverride();
 (async () => {
   let exitCode = 0;
   const extensions = await resolveExtensions();
-  const sdk = createZapierCliSdk({
+  const sdk = createZapierCliSdk3({
     debug: isDebugMode,
     credentials,
     baseUrl,