@zapier/zapier-sdk-cli 0.44.1 → 0.45.0

package/dist/index.cjs

@@ -23,6 +23,7 @@ require('is-installed-globally');
 var child_process = require('child_process');
 var Handlebars = require('handlebars');
 var url = require('url');
+require('wrap-ansi');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -660,6 +661,14 @@ var ZapierCliExitError = class extends ZapierCliError {
     this.exitCode = exitCode;
   }
 };
+var ZapierCliValidationError = class extends ZapierCliError {
+  constructor(message) {
+    super(message);
+    this.name = "ZapierCliValidationError";
+    this.code = "ZAPIER_CLI_VALIDATION_ERROR";
+    this.exitCode = 1;
+  }
+};
 
 // src/utils/spinner.ts
 var spinPromise = async (promise, text) => {
@@ -996,7 +1005,8 @@ var mcpPlugin = zapierSdk.definePlugin(
       await zapierSdkMcp.startMcpServer({
         ...options,
         debug: sdk2.context.options?.debug,
-        extensions: sdk2.context.extensions
+        extensions: sdk2.context.extensions,
+        experimental: sdk2.context.experimental
       });
     }
   })
@@ -1019,15 +1029,6 @@ var bundleCodePlugin = zapierSdk.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,
@@ -1055,14 +1056,14 @@ async function bundleCode(options) {
     });
     if (result.errors.length > 0) {
       const errorMessages = result.errors.map((e) => e.text);
-      throw new ZapierBundleError(
+      throw new zapierSdk.ZapierBundleError(
         `Bundle failed: ${errorMessages.join(", ")}`,
-        errorMessages
+        { buildErrors: errorMessages }
       );
     }
     const bundledCode = result.outputFiles?.[0]?.text;
     if (!bundledCode) {
-      throw new ZapierBundleError("No output generated");
+      throw new zapierSdk.ZapierBundleError("No output generated");
     }
     let finalOutput = bundledCode;
     if (returnString) {
@@ -1074,13 +1075,12 @@ async function bundleCode(options) {
     }
     return finalOutput;
   } catch (error) {
-    if (error instanceof ZapierBundleError) {
+    if (error instanceof zapierSdk.ZapierBundleError) {
       throw error;
     }
-    throw new ZapierBundleError(
+    throw new zapierSdk.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 }
     );
   }
 }
@@ -1255,7 +1255,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,
@@ -2132,11 +2132,12 @@ var CurlSchema = zod.z.object({
   /** @deprecated Use `connection` instead. */
   connectionId: zod.z.union([zod.z.string(), zod.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 zapierSdk.ZapierError {
   constructor(message, exitCode) {
     super(message);
+    this.name = "ZapierCurlExitError";
+    this.code = "ZAPIER_CURL_EXIT_ERROR";
     this.exitCode = exitCode;
-    this.name = "CurlExitError";
   }
 };
 function parseHeaderLine(input) {
@@ -2228,7 +2229,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
     );
@@ -2237,7 +2238,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
       );
@@ -2245,7 +2246,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
       );
@@ -2482,7 +2483,7 @@ ${Array.from(
 `
         );
       }
-      throw new CurlExitError("HTTP request failed", 22);
+      throw new ZapierCurlExitError("HTTP request failed", 22);
     }
     return void 0;
   }
@@ -3001,11 +3002,491 @@ var initPlugin = zapierSdk.definePlugin(
     }
   })
 );
+function jsonReplacer(_key, value) {
+  if (value instanceof Error) {
+    return {
+      name: value.name,
+      message: value.message,
+      ...value.stack ? { stack: value.stack } : {}
+    };
+  }
+  return value;
+}
+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(
+      `
+${chalk3__default.default.bold(`Message #${messageNumber}`)} ${chalk3__default.default.dim(message.id)} ${chalk3__default.default.dim(`(lease #${attrs.lease_count})`)}`
+    );
+    if (attrs.error_message) {
+      console.log(chalk3__default.default.yellow(`  upstream error: ${attrs.error_message}`));
+    }
+    if (attrs.possible_duplicate_data) {
+      console.log(chalk3__default.default.yellow("  possible duplicate data"));
+    }
+    while (true) {
+      let action;
+      try {
+        const answer = await inquirer__default.default.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 zapierSdk.ZapierAbortDrainSignal("user pressed Ctrl-C");
+        }
+        throw error;
+      }
+      if (action === "view") {
+        console.log(chalk3__default.default.dim(JSON.stringify(message.payload, null, 2)));
+        continue;
+      }
+      if (action === "ack") {
+        return;
+      }
+      if (action === "skip-release") {
+        throw new zapierSdk.ZapierReleaseTriggerMessageSignal("user skipped (release)");
+      }
+      if (action === "skip-expire") {
+        throw new CliSkipLeaseExpireError();
+      }
+      if (action === "quit") {
+        throw new zapierSdk.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 = child_process.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 zapierSdk.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(
+    chalk3__default.default.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(
+    chalk3__default.default.dim(
+      `
+Processed ${total} message${total === 1 ? "" : "s"} (${parts.join(", ")}).`
+    )
+  );
+}
+function warnInteractiveContinueOnErrorOverride() {
+  console.warn(
+    chalk3__default.default.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 = zod.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 = zod.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 = zod.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."
+);
+zapierSdk.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
+    }) : zod.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 zapierSdk.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 = zod.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 = zod.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 = zod.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."
+);
+zapierSdk.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
+    }) : zod.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 zapierSdk.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_default = {
   name: "@zapier/zapier-sdk-cli",
-  version: "0.44.1"};
+  version: "0.45.0"};
 
 // src/sdk.ts
 zapierSdk.injectCliLogin(login_exports);
@@ -3033,7 +3514,7 @@ function createZapierCliSdk(options = {}) {
 
 // package.json
 var package_default2 = {
-  version: "0.44.1"};
+  version: "0.45.0"};
 
 // src/telemetry/builders.ts
 function createCliBaseEvent(context = {}) {