@zapier/zapier-sdk-cli 0.68.0 → 0.69.0

package/dist/cli.cjs

@@ -8,14 +8,15 @@ var inquirer = require('inquirer');
 var chalk8 = require('chalk');
 var core = require('@inquirer/core');
 var ora = require('ora');
+var fs = require('fs');
+var path = require('path');
+var isInstalledGlobally = require('is-installed-globally');
 var util = require('util');
-var wrapAnsi3 = require('wrap-ansi');
+var wrapAnsi4 = require('wrap-ansi');
 var jwt = require('jsonwebtoken');
 var crossKeychain = require('cross-keychain');
 var Conf = require('conf');
-var fs = require('fs');
 var crypto = require('crypto');
-var path = require('path');
 var lockfile = require('proper-lockfile');
 var os = require('os');
 var express = require('express');
@@ -26,13 +27,14 @@ var zapierSdkMcp = require('@zapier/zapier-sdk-mcp');
 var esbuild = require('esbuild');
 var promises = require('fs/promises');
 var ts = require('typescript');
-var isInstalledGlobally = require('is-installed-globally');
 var child_process = require('child_process');
 var Handlebars = require('handlebars');
 var url = require('url');
-var experimental = require('@zapier/zapier-sdk/experimental');
 var packageJsonLib = require('package-json');
 var semver = require('semver');
+var crossSpawn = require('cross-spawn');
+var Table = require('cli-table3');
+var experimental = require('@zapier/zapier-sdk/experimental');
 var readline = require('readline');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
@@ -59,22 +61,24 @@ function _interopNamespace(e) {
 var inquirer__default = /*#__PURE__*/_interopDefault(inquirer);
 var chalk8__default = /*#__PURE__*/_interopDefault(chalk8);
 var ora__default = /*#__PURE__*/_interopDefault(ora);
+var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
+var path__namespace = /*#__PURE__*/_interopNamespace(path);
+var isInstalledGlobally__default = /*#__PURE__*/_interopDefault(isInstalledGlobally);
 var util__default = /*#__PURE__*/_interopDefault(util);
-var wrapAnsi3__default = /*#__PURE__*/_interopDefault(wrapAnsi3);
+var wrapAnsi4__default = /*#__PURE__*/_interopDefault(wrapAnsi4);
 var jwt__namespace = /*#__PURE__*/_interopNamespace(jwt);
 var Conf__default = /*#__PURE__*/_interopDefault(Conf);
-var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
 var crypto__default = /*#__PURE__*/_interopDefault(crypto);
-var path__namespace = /*#__PURE__*/_interopNamespace(path);
 var lockfile__namespace = /*#__PURE__*/_interopNamespace(lockfile);
 var express__default = /*#__PURE__*/_interopDefault(express);
 var open__default = /*#__PURE__*/_interopDefault(open);
 var pkceChallenge__default = /*#__PURE__*/_interopDefault(pkceChallenge);
 var ts__namespace = /*#__PURE__*/_interopNamespace(ts);
-var isInstalledGlobally__default = /*#__PURE__*/_interopDefault(isInstalledGlobally);
 var Handlebars__default = /*#__PURE__*/_interopDefault(Handlebars);
 var packageJsonLib__default = /*#__PURE__*/_interopDefault(packageJsonLib);
 var semver__default = /*#__PURE__*/_interopDefault(semver);
+var crossSpawn__default = /*#__PURE__*/_interopDefault(crossSpawn);
+var Table__default = /*#__PURE__*/_interopDefault(Table);
 var readline__namespace = /*#__PURE__*/_interopNamespace(readline);
 
 var __defProp = Object.defineProperty;
@@ -236,11 +240,21 @@ async function promptText({
   password
 }) {
   const { value } = await inquirer__default.default.prompt([
-    { type: password ? "password" : "input", name: "value", message }
+    {
+      type: password ? "password" : "input",
+      name: "value",
+      message,
+      theme: HIGH_CONTRAST_PROMPT_THEME
+    }
   ]);
   return value;
 }
 var display = (c) => c.hint ? `${c.label} ${chalk8__default.default.dim(`(${c.hint})`)}` : c.label;
+var HIGH_CONTRAST_PROMPT_THEME = {
+  style: {
+    answer: (text) => chalk8__default.default.inverse.bold(` ${text} `)
+  }
+};
 function buildSelectRows(question, term) {
   const row = (name, action) => ({
     name,
@@ -307,9 +321,39 @@ function foldPage(acc, question, field) {
     checked: []
   };
 }
-async function answerSelect(question, field, box, failed = false) {
+async function answerSelect(question, field, box, failed, mode) {
   const acc = failed ? void 0 : box.acc = foldPage(box.acc, question, field);
   const view = acc ? { ...question, choices: acc.choices } : question;
+  const isClosedListPrompt = mode === "closed-list" && !failed && !view.multiple;
+  const booleanValues = view.choices.map(({ value: value2 }) => value2);
+  if (isClosedListPrompt && booleanValues.length === 2 && booleanValues.includes("true") && booleanValues.includes("false")) {
+    const { value: value2 } = await inquirer__default.default.prompt([
+      {
+        type: "confirm",
+        name: "value",
+        message: view.message,
+        default: booleanValues[0] === "true",
+        theme: HIGH_CONTRAST_PROMPT_THEME
+      }
+    ]);
+    return { type: "choose", value: String(value2) };
+  }
+  if (isClosedListPrompt && view.choices.length > 0 && !offers(view, "search") && !offers(view, "next_page") && !offers(view, "retry")) {
+    const choices = view.choices.map((choice) => ({
+      name: display(choice),
+      value: choice.value
+    }));
+    const { value: value2 } = await inquirer__default.default.prompt([
+      {
+        type: "list",
+        name: "value",
+        message: view.message,
+        choices,
+        theme: HIGH_CONTRAST_PROMPT_THEME
+      }
+    ]);
+    return { type: "choose", value: value2 };
+  }
   if (question.multiple && acc) {
     if (acc.newStart > 0 && process.stdout.isTTY) {
       process.stdout.write("\x1B[1A\x1B[2K");
@@ -333,7 +377,13 @@ async function answerSelect(question, field, box, failed = false) {
       }))
     ];
     const { values } = await inquirer__default.default.prompt([
-      { type: "checkbox", name: "values", message: question.message, choices }
+      {
+        type: "checkbox",
+        name: "values",
+        message: question.message,
+        choices,
+        theme: HIGH_CONTRAST_PROMPT_THEME
+      }
     ]);
     const selected = values;
     const picked = selected.filter((v) => !isActionRow(v));
@@ -428,7 +478,8 @@ async function answerCollection(question) {
       type: "confirm",
       name: "again",
       message: question.message,
-      default: false
+      default: false,
+      theme: HIGH_CONTRAST_PROMPT_THEME
     }
   ]);
   return again ? { type: "add" } : { type: "done" };
@@ -443,22 +494,37 @@ function withEngineSpinner(answer, spinner) {
     }
   };
 }
-function createCliAnswer() {
+function createCliAnswer({
+  mode = "search"
+} = {}) {
   const box = {};
-  return ({ result }) => {
-    if (result.error !== void 0) {
-      const message = typeof result.error === "string" ? result.error : result.error.message;
-      console.log(chalk8__default.default.yellow(`! ${message}`));
-    }
-    const question = result.question;
-    const field = question.path.length ? question.path.join(".") : "value";
-    switch (question.type) {
-      case "select":
-        return answerSelect(question, field, box, result.status === "failed");
-      case "input":
-        return answerInput(question);
-      case "collection":
-        return answerCollection(question);
+  return async ({ result }) => {
+    try {
+      if (result.error !== void 0) {
+        const message = typeof result.error === "string" ? result.error : result.error.message;
+        console.log(chalk8__default.default.yellow(`! ${message}`));
+      }
+      const question = result.question;
+      const field = question.path.length ? question.path.join(".") : "value";
+      switch (question.type) {
+        case "select":
+          return await answerSelect(
+            question,
+            field,
+            box,
+            result.status === "failed",
+            mode
+          );
+        case "input":
+          return await answerInput(question);
+        case "collection":
+          return await answerCollection(question);
+      }
+    } catch (error) {
+      if (error instanceof Error && error.name === "ExitPromptError") {
+        return { type: "cancel" };
+      }
+      throw error;
     }
   };
 }
@@ -536,7 +602,86 @@ var SHARED_COMMAND_CLI_OPTIONS = [
 
 // package.json
 var package_default = {
-  version: "0.68.0"};
+  version: "0.69.0"};
+var PACKAGE_MANAGERS = ["npm", "pnpm", "yarn", "bun"];
+var LOCKFILES = [
+  ["pnpm-lock.yaml", "pnpm"],
+  ["yarn.lock", "yarn"],
+  ["bun.lock", "bun"],
+  ["bun.lockb", "bun"],
+  ["package-lock.json", "npm"]
+];
+function readDeclaredPackageManager(cwd) {
+  try {
+    const manifest = JSON.parse(
+      fs.readFileSync(path.join(cwd, "package.json"), "utf8")
+    );
+    if (typeof manifest !== "object" || manifest === null || !("packageManager" in manifest) || typeof manifest.packageManager !== "string") {
+      return void 0;
+    }
+    const [name] = manifest.packageManager.split("@", 1);
+    return PACKAGE_MANAGERS.find((packageManager) => packageManager === name);
+  } catch {
+    return void 0;
+  }
+}
+function detectPackageManager(cwd = process.cwd()) {
+  const lockfileManagers = new Set(
+    LOCKFILES.filter(([file]) => fs.existsSync(path.join(cwd, file))).map(
+      ([, packageManager]) => packageManager
+    )
+  );
+  if (lockfileManagers.size === 1) {
+    return { name: [...lockfileManagers][0], source: "lockfile" };
+  }
+  const declaredPackageManager = readDeclaredPackageManager(cwd);
+  if (declaredPackageManager) {
+    return { name: declaredPackageManager, source: "package-json" };
+  }
+  const userAgent = process.env.npm_config_user_agent;
+  if (userAgent) {
+    if (userAgent.includes("yarn")) {
+      return { name: "yarn", source: "runtime" };
+    }
+    if (userAgent.includes("pnpm")) {
+      return { name: "pnpm", source: "runtime" };
+    }
+    if (userAgent.includes("bun")) {
+      return { name: "bun", source: "runtime" };
+    }
+    if (userAgent.includes("npm")) {
+      return { name: "npm", source: "runtime" };
+    }
+  }
+  return { name: "npm", source: "fallback" };
+}
+function getUpdateCommand(packageName) {
+  const pm = detectPackageManager();
+  const isGlobal = isInstalledGlobally__default.default;
+  if (isGlobal) {
+    switch (pm.name) {
+      case "yarn":
+        return `yarn global upgrade ${packageName}@latest`;
+      case "pnpm":
+        return `pnpm update -g ${packageName}@latest`;
+      case "bun":
+        return `bun update -g ${packageName}@latest`;
+      default:
+        return `npm install -g ${packageName}@latest`;
+    }
+  } else {
+    switch (pm.name) {
+      case "yarn":
+        return `yarn upgrade ${packageName}@latest`;
+      case "pnpm":
+        return `pnpm update ${packageName}@latest`;
+      case "bun":
+        return `bun update ${packageName}@latest`;
+      default:
+        return `npm install ${packageName}@latest`;
+    }
+  }
+}
 
 // src/telemetry/builders.ts
 function createCliBaseEvent(context = {}) {
@@ -584,8 +729,7 @@ function buildCliCommandExecutedEvent({
     ci_platform: zapierSdk.getCiPlatform(),
     ...zapierSdk.getTtyContext(),
     agent: zapierSdk.getAgent(),
-    package_manager: data.package_manager ?? "pnpm",
-    // Default based on project setup
+    package_manager: data.package_manager ?? detectPackageManager(process.cwd()).name,
     made_network_requests: data.made_network_requests ?? null,
     files_modified_count: data.files_modified_count ?? null,
     files_created_count: data.files_created_count ?? null,
@@ -679,7 +823,7 @@ var DETAIL_INDENT = "   ";
 var DETAIL_MAX_LINES = 5;
 function formatDetailText(text, indent = DETAIL_INDENT) {
   const columns = Math.max((process.stdout.columns || 80) - indent.length, 40);
-  const wrapped = wrapAnsi3__default.default(text, columns, { hard: true, trim: false });
+  const wrapped = wrapAnsi4__default.default(text, columns, { hard: true, trim: false });
   const lines = wrapped.split("\n");
   if (lines.length <= DETAIL_MAX_LINES) {
     return lines.join("\n" + indent);
@@ -5757,54 +5901,6 @@ var InitSchema = zod.z.object({
 }).describe(
   "Create a new Zapier SDK project in a new directory with starter files"
 );
-function detectPackageManager(cwd = process.cwd()) {
-  const ua = process.env.npm_config_user_agent;
-  if (ua) {
-    if (ua.includes("yarn")) return { name: "yarn", source: "runtime" };
-    if (ua.includes("pnpm")) return { name: "pnpm", source: "runtime" };
-    if (ua.includes("bun")) return { name: "bun", source: "runtime" };
-    if (ua.includes("npm")) return { name: "npm", source: "runtime" };
-  }
-  const files = [
-    ["pnpm-lock.yaml", "pnpm"],
-    ["yarn.lock", "yarn"],
-    ["bun.lockb", "bun"],
-    ["package-lock.json", "npm"]
-  ];
-  for (const [file, name] of files) {
-    if (fs.existsSync(path.join(cwd, file))) {
-      return { name, source: "lockfile" };
-    }
-  }
-  return { name: "unknown", source: "fallback" };
-}
-function getUpdateCommand(packageName) {
-  const pm = detectPackageManager();
-  const isGlobal = isInstalledGlobally__default.default;
-  if (isGlobal) {
-    switch (pm.name) {
-      case "yarn":
-        return `yarn global upgrade ${packageName}@latest`;
-      case "pnpm":
-        return `pnpm update -g ${packageName}@latest`;
-      case "bun":
-        return `bun update -g ${packageName}@latest`;
-      default:
-        return `npm install -g ${packageName}@latest`;
-    }
-  } else {
-    switch (pm.name) {
-      case "yarn":
-        return `yarn upgrade ${packageName}@latest`;
-      case "pnpm":
-        return `pnpm update ${packageName}@latest`;
-      case "bun":
-        return `bun update ${packageName}@latest`;
-      default:
-        return `npm install ${packageName}@latest`;
-    }
-  }
-}
 function getDirentParentPath(entry) {
   const e = entry;
   const parent = e.parentPath ?? e.path;
@@ -6201,17 +6297,16 @@ var initPlugin = zapierSdk.defineMethod({
     const cwd = process.cwd();
     const { projectName, projectDir } = validateInitOptions({ rawName, cwd });
     const displayHooks = createConsoleDisplayHooks();
-    const packageManagerInfo = detectPackageManager(cwd);
-    if (packageManagerInfo.name === "unknown") {
+    const packageManager = detectPackageManager(cwd);
+    if (packageManager.source === "fallback") {
       displayHooks.onWarn(
         "Could not detect package manager, defaulting to npm."
       );
     }
-    const packageManager = packageManagerInfo.name === "unknown" ? "npm" : packageManagerInfo.name;
     const steps = getInitSteps({
       projectDir,
       projectName,
-      packageManager,
+      packageManager: packageManager.name,
       displayHooks
     });
     const completedSetupStepIds = [];
@@ -6239,95 +6334,1423 @@ var initPlugin = zapierSdk.defineMethod({
       projectName,
       steps,
       completedSetupStepIds,
-      packageManager
+      packageManager: packageManager.name
     });
   }
 });
-var CliSkipLeaseExpireError = class extends Error {
-  constructor() {
-    super("user skipped (let lease expire)");
-    this.name = "CliSkipLeaseExpireError";
+var ONE_DAY_MILLISECONDS = 24 * 60 * 60 * 1e3;
+var CACHE_RESET_INTERVAL_MILLISECONDS = (() => {
+  const {
+    ZAPIER_SDK_UPDATE_CHECK_INTERVAL_SECONDS,
+    ZAPIER_SDK_UPDATE_CHECK_INTERVAL_MS
+  } = process.env;
+  let intervalMs;
+  if (ZAPIER_SDK_UPDATE_CHECK_INTERVAL_SECONDS !== void 0) {
+    const seconds = parseInt(ZAPIER_SDK_UPDATE_CHECK_INTERVAL_SECONDS);
+    intervalMs = isNaN(seconds) ? NaN : seconds * 1e3;
+  } else if (ZAPIER_SDK_UPDATE_CHECK_INTERVAL_MS !== void 0) {
+    intervalMs = parseInt(ZAPIER_SDK_UPDATE_CHECK_INTERVAL_MS);
+  } else {
+    intervalMs = ONE_DAY_MILLISECONDS;
   }
-};
-function createInteractiveCallback() {
-  let messageNumber = 0;
-  return async (message) => {
-    messageNumber++;
-    const attrs = message.message_attributes;
-    console.log(
-      `
-${chalk8__default.default.bold(`Message #${messageNumber}`)} ${chalk8__default.default.dim(message.id)} ${chalk8__default.default.dim(`(lease #${attrs.lease_count})`)}`
-    );
-    if (attrs.error_message) {
-      console.log(chalk8__default.default.yellow(`  upstream error: ${attrs.error_message}`));
-    }
-    if (attrs.possible_duplicate_data) {
-      console.log(chalk8__default.default.yellow("  possible duplicate data"));
+  if (isNaN(intervalMs) || intervalMs < 0) {
+    return -1;
+  }
+  return intervalMs;
+})();
+function getVersionCache() {
+  try {
+    const cache = getConfig().get("version_cache");
+    const now = Date.now();
+    if (!cache || !cache.last_reset_timestamp || now - cache.last_reset_timestamp >= CACHE_RESET_INTERVAL_MILLISECONDS) {
+      const newCache = {
+        last_reset_timestamp: now,
+        packages: {}
+      };
+      getConfig().set("version_cache", newCache);
+      return newCache;
     }
-    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(chalk8__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");
-      }
+    return cache;
+  } catch (error) {
+    log_default.debug(`Failed to read version cache: ${error}`);
+    return {
+      last_reset_timestamp: Date.now(),
+      packages: {}
+    };
+  }
+}
+function setCachedPackageInfo(packageName, version, info) {
+  try {
+    const cache = getVersionCache();
+    if (!cache.packages[packageName]) {
+      cache.packages[packageName] = {};
     }
-  };
+    cache.packages[packageName][version] = info;
+    getConfig().set("version_cache", cache);
+  } catch (error) {
+    log_default.debug(`Failed to cache package info: ${error}`);
+  }
 }
-function createNdjsonCallback() {
-  return (message) => new Promise((resolve4, reject) => {
-    process.stdout.write(JSON.stringify(message) + "\n", (err) => {
-      if (err) reject(err);
-      else resolve4();
-    });
-  });
+function getCachedPackageInfo(packageName, version) {
+  try {
+    const cache = getVersionCache();
+    return cache.packages[packageName]?.[version];
+  } catch (error) {
+    log_default.debug(`Failed to get cached package info: ${error}`);
+    return void 0;
+  }
 }
-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) {
+async function fetchCachedPackageInfo(packageName, version) {
+  const cacheKey = version || "latest";
+  let cachedInfo = getCachedPackageInfo(packageName, cacheKey);
+  if (cachedInfo) {
+    return cachedInfo;
+  }
+  const packageInfo = await packageJsonLib__default.default(packageName, {
+    version,
+    fullMetadata: true
+  });
+  const info = {
+    version: packageInfo.version,
+    deprecated: packageInfo.deprecated,
+    fetched_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  setCachedPackageInfo(packageName, cacheKey, info);
+  return info;
+}
+async function checkForUpdates({
+  packageName,
+  currentVersion
+}) {
+  try {
+    const latestPackageInfo = await fetchCachedPackageInfo(packageName);
+    const latestVersion = latestPackageInfo.version;
+    const hasUpdate = semver__default.default.gt(latestVersion, currentVersion);
+    let currentPackageInfo;
+    try {
+      currentPackageInfo = await fetchCachedPackageInfo(
+        packageName,
+        currentVersion
+      );
+    } catch (error) {
+      if (!(error instanceof packageJsonLib.VersionNotFoundError)) {
+        log_default.debug(`Failed to check deprecation for current version: ${error}`);
+      }
+      currentPackageInfo = latestPackageInfo;
+    }
+    const isDeprecated = Boolean(currentPackageInfo.deprecated);
+    const deprecationMessage = isDeprecated ? String(currentPackageInfo.deprecated) : void 0;
+    return {
+      hasUpdate,
+      latestVersion,
+      currentVersion,
+      isDeprecated,
+      deprecationMessage
+    };
+  } catch (error) {
+    log_default.debug(`Failed to check for updates: ${error}`);
+    return {
+      hasUpdate: false,
+      currentVersion,
+      isDeprecated: false
+    };
+  }
+}
+function displayUpdateNotification(versionInfo, packageName) {
+  if (versionInfo.isDeprecated) {
+    console.error();
+    console.error(
+      chalk8__default.default.red.bold("\u26A0\uFE0F  DEPRECATION WARNING") + chalk8__default.default.red(
+        ` - ${packageName} v${versionInfo.currentVersion} is deprecated.`
+      )
+    );
+    if (versionInfo.deprecationMessage) {
+      console.error(chalk8__default.default.red(`   ${versionInfo.deprecationMessage}`));
+    }
+    console.error(chalk8__default.default.red(`   Please update to the latest version.`));
+    console.error();
+  }
+  if (versionInfo.hasUpdate) {
+    console.error();
+    console.error(
+      chalk8__default.default.yellow.bold("\u{1F4E6} Update available!") + chalk8__default.default.yellow(
+        ` ${packageName} v${versionInfo.currentVersion} \u2192 v${versionInfo.latestVersion}`
+      )
+    );
+    console.error(
+      chalk8__default.default.yellow(
+        `   Run ${chalk8__default.default.bold(getUpdateCommand(packageName))} to update.`
+      )
+    );
+    console.error();
+  }
+}
+async function checkAndNotifyUpdates({
+  packageName,
+  currentVersion
+}) {
+  if (CACHE_RESET_INTERVAL_MILLISECONDS < 0) {
+    return;
+  }
+  const versionInfo = await checkForUpdates({ packageName, currentVersion });
+  displayUpdateNotification(versionInfo, packageName);
+}
+var BRAILLE_BLANK = "\u2800";
+var LIGHTNING_INTERVAL_MILLISECONDS = 140;
+var boltRows = [
+  "\u2800\u2800\u2880\u28FE\u2800\u2800\u2800\u2800",
+  "\u2800\u2800\u28E0\u28FF\u28FF\u2800\u2800\u2800",
+  "\u2800\u28FC\u28FF\u28FF\u28FF\u28C0\u28C0\u2840",
+  "\u2808\u2809\u2809\u28FF\u28FF\u28FF\u285F\u2800",
+  "\u2800\u2800\u2800\u28FF\u28FF\u280B\u2800\u2800",
+  "\u2800\u2800\u2800\u287F\u2801\u2800\u2800\u2800"
+];
+var boltFillOrder = boltRows.flatMap(
+  (row, rowIndex) => [...row].flatMap(
+    (cell, columnIndex) => cell === BRAILLE_BLANK ? [] : rowIndex * row.length + columnIndex
+  )
+);
+var fillStages = [
+  ...Array.from({ length: boltFillOrder.length + 1 }, (_, index) => index),
+  boltFillOrder.length,
+  0
+];
+var boltFillRanks = new Map(
+  boltFillOrder.map((cellIndex, fillIndex) => [cellIndex, fillIndex])
+);
+var STATUS_ROW_INDEX = Math.floor(boltRows.length / 2);
+function formatPhase({ label, detail }) {
+  return detail ? `${chalk8__default.default.bold(label)}  ${chalk8__default.default.dim(detail)}` : chalk8__default.default.bold(label);
+}
+function formatLoaderFrame({
+  phase,
+  fillStage
+}) {
+  return boltRows.map((row, rowIndex) => {
+    const bolt = [...row].map((cell, columnIndex) => {
+      if (cell === BRAILLE_BLANK) return cell;
+      const cellIndex = rowIndex * row.length + columnIndex;
+      const fillRank = boltFillRanks.get(cellIndex);
+      const isFilled = fillRank !== void 0 && fillRank < fillStage;
+      return isFilled ? chalk8__default.default.bold.yellow(cell) : chalk8__default.default.dim.yellow(cell);
+    }).join("");
+    const status = rowIndex === STATUS_ROW_INDEX ? `   ${formatPhase(phase)}` : "";
+    return `${bolt}${status}`;
+  }).join("\n");
+}
+async function runWithSetupLoader({
+  promise,
+  ...phase
+}) {
+  const startedAt = Date.now();
+  let fillFrameIndex = 0;
+  const loader = ora__default.default({
+    isEnabled: process.stderr.isTTY === true,
+    spinner: { interval: 80, frames: [""] },
+    text: formatLoaderFrame({
+      phase,
+      fillStage: fillStages[fillFrameIndex]
+    })
+  }).start();
+  const animationTimer = setInterval(() => {
+    fillFrameIndex = (fillFrameIndex + 1) % fillStages.length;
+    loader.text = formatLoaderFrame({
+      phase,
+      fillStage: fillStages[fillFrameIndex]
+    });
+  }, LIGHTNING_INTERVAL_MILLISECONDS);
+  animationTimer.unref?.();
+  try {
+    const result = await promise;
+    clearInterval(animationTimer);
+    const elapsedSeconds = ((Date.now() - startedAt) / 1e3).toFixed(1);
+    loader.succeed(`${formatPhase(phase)}  ${chalk8__default.default.dim(`${elapsedSeconds}s`)}`);
+    return result;
+  } catch (error) {
+    clearInterval(animationTimer);
+    const elapsedSeconds = ((Date.now() - startedAt) / 1e3).toFixed(1);
+    loader.fail(`${formatPhase(phase)}  ${chalk8__default.default.dim(`${elapsedSeconds}s`)}`);
+    throw error;
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readPackageJson({
+  directory
+}) {
+  try {
+    const manifest = JSON.parse(
+      fs.readFileSync(path.join(directory, "package.json"), "utf8")
+    );
+    return isRecord(manifest) ? manifest : void 0;
+  } catch {
+    return void 0;
+  }
+}
+var SetupOptionSchema = zod.z.object({
+  label: zod.z.string(),
+  value: zod.z.string()
+});
+var SetupOptionsSchema = zod.z.array(SetupOptionSchema).min(1);
+var SetupDecisionSchema = zod.z.object({
+  message: zod.z.string(),
+  options: SetupOptionsSchema,
+  answer: zod.z.string()
+});
+var SetupInputSchema = zod.z.object({
+  message: zod.z.string(),
+  answer: zod.z.string()
+});
+var setupDecisionResolver = zapierSdk.defineResolver({
+  requireParameters: ["message", "options"],
+  listItems: ({ input }) => ({ data: input.options }),
+  prompt: ({ items, input }) => ({
+    type: "list",
+    message: input.message,
+    choices: items
+  }),
+  validate: ({ input, value }) => {
+    if (typeof value !== "string") return "Choose an available option.";
+    return input.options.some((option) => option.value === value) || "Choose one of the available options.";
+  }
+});
+var setupInputResolver = zapierSdk.defineResolver({
+  type: "static",
+  inputType: "text",
+  requireParameters: ["message"]
+});
+var resolveSetupDecisionPlugin = zapierSdk.defineMethod({
+  name: "resolveSetupDecision",
+  description: "Resolve one setup wizard decision.",
+  inputSchema: SetupDecisionSchema,
+  resolvers: { answer: setupDecisionResolver },
+  run: ({ input }) => input
+});
+var resolveSetupInputPlugin = zapierSdk.defineMethod({
+  name: "resolveSetupInput",
+  description: "Resolve one setup wizard text input.",
+  inputSchema: SetupInputSchema,
+  resolvers: { answer: setupInputResolver },
+  run: ({ input }) => input
+});
+function createSetupController() {
+  const setupResolutionSdk = zapierSdk.createSdk(
+    zapierSdk.definePlugin({
+      name: "setup-resolution",
+      exports: [
+        resolveSetupDecisionPlugin,
+        resolveSetupInputPlugin,
+        zapierSdk.getRegistryPlugin
+      ]
+    })
+  );
+  return zapierSdk.createController(setupResolutionSdk);
+}
+async function resolveWithCancellation({
+  run
+}) {
+  try {
+    return await run();
+  } catch (error) {
+    if (zapierSdk.isCoreCancelledSignal(error)) {
+      throw new ZapierCliUserCancellationError();
+    }
+    throw error;
+  }
+}
+async function resolveSetupDecision({
+  answer,
+  controller,
+  message,
+  options
+}) {
+  const parsedOptions = SetupOptionsSchema.parse(options);
+  const resolved = await resolveWithCancellation({
+    run: () => controller.resolve({
+      method: "resolveSetupDecision",
+      input: { message, options: parsedOptions },
+      answer,
+      interactive: true
+    })
+  });
+  return SetupDecisionSchema.parse(resolved).answer;
+}
+async function resolveSetupConfirm({
+  answer,
+  controller,
+  defaultValue,
+  message
+}) {
+  const values = defaultValue ? [true, false] : [false, true];
+  const resolved = await resolveSetupDecision({
+    answer,
+    controller,
+    message,
+    options: values.map((value) => ({
+      label: value ? "Yes" : "No",
+      value: String(value)
+    }))
+  });
+  return resolved === "true";
+}
+async function resolveSetupInput({
+  answer,
+  controller,
+  message
+}) {
+  const resolved = await resolveWithCancellation({
+    run: () => controller.resolve({
+      method: "resolveSetupInput",
+      input: { message },
+      answer: ({ result, state }) => answer({
+        state,
+        result: {
+          ...result,
+          question: { ...result.question, message }
+        }
+      }),
+      interactive: true
+    })
+  });
+  return SetupInputSchema.parse(resolved).answer.trim();
+}
+async function resolveSetupSelect({
+  answer,
+  controller,
+  choices,
+  message
+}) {
+  const resolved = await resolveSetupDecision({
+    answer,
+    controller,
+    message,
+    options: choices
+  });
+  const selected = choices.find(({ value }) => value === resolved);
+  if (!selected) {
+    throw new Error("Resolved setup selection is not an available choice.");
+  }
+  return selected.value;
+}
+
+// src/plugins/setup/dependencies.ts
+var REQUIRED_PACKAGES = [
+  { name: "@zapier/zapier-sdk", dev: false, checkForUpdates: true },
+  { name: "@zapier/zapier-sdk-cli", dev: true, checkForUpdates: true },
+  {
+    name: "@types/node",
+    dev: true,
+    checkForUpdates: false,
+    typescriptOnly: true
+  },
+  {
+    name: "typescript",
+    dev: true,
+    checkForUpdates: false,
+    typescriptOnly: true
+  },
+  { name: "tsx", dev: true, checkForUpdates: false, typescriptOnly: true }
+];
+function getInstallCommand({
+  packageManager,
+  packages,
+  dev = false
+}) {
+  const verb = packageManager === "npm" ? "install" : "add";
+  const devFlag = packageManager === "bun" ? "-d" : "-D";
+  return {
+    command: packageManager,
+    args: [verb, ...dev ? [devFlag] : [], ...packages]
+  };
+}
+async function executeInstall(context, command) {
+  try {
+    await context.runCommand({ ...command, cwd: context.cwd });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.includes("EPERM") && message.includes(".npm/_cacache")) {
+      console.error(
+        "This EPERM usually means the command sandbox blocked npm cache writes; it does not usually mean your file permissions are broken."
+      );
+    }
+    throw error;
+  }
+}
+function getDeclaredPackageNames(cwd) {
+  const manifest = readPackageJson({ directory: cwd });
+  if (!manifest) return /* @__PURE__ */ new Set();
+  const names = /* @__PURE__ */ new Set();
+  for (const section of ["dependencies", "devDependencies"]) {
+    const dependencies = manifest[section];
+    if (!isRecord(dependencies)) continue;
+    for (const name of Object.keys(dependencies)) names.add(name);
+  }
+  return names;
+}
+function getInstalledPackageVersion({
+  cwd,
+  packageName
+}) {
+  let directory = cwd;
+  while (true) {
+    const manifest = readPackageJson({
+      directory: path.join(directory, "node_modules", ...packageName.split("/"))
+    });
+    if (manifest?.name === packageName && typeof manifest.version === "string") {
+      return manifest.version;
+    }
+    const parent = path.dirname(directory);
+    if (parent === directory) return void 0;
+    directory = parent;
+  }
+}
+async function installPackages({
+  context,
+  packages
+}) {
+  const runtimePackages = packages.filter(({ dependency }) => !dependency.dev).map(({ dependency }) => dependency.name);
+  if (runtimePackages.length > 0) {
+    await executeInstall(
+      context,
+      getInstallCommand({
+        packageManager: context.packageManager,
+        packages: runtimePackages
+      })
+    );
+  }
+  const developmentPackages = packages.filter(({ dependency }) => dependency.dev).map(({ dependency }) => dependency.name);
+  if (developmentPackages.length > 0) {
+    await executeInstall(
+      context,
+      getInstallCommand({
+        packageManager: context.packageManager,
+        packages: developmentPackages,
+        dev: true
+      })
+    );
+  }
+}
+async function offerMissingPackageInstall({
+  context,
+  packages
+}) {
+  if (packages.length === 0) return;
+  const shouldInstall = await resolveSetupConfirm({
+    answer: context.createAnswer(),
+    controller: context.setupController,
+    message: `These packages are required to continue. Install them now: ${packages.map(({ dependency }) => dependency.name).join(", ")}?`,
+    defaultValue: true
+  });
+  if (!shouldInstall) {
+    console.log(
+      "The Zapier SDK packages are required to continue. Setup cancelled without installing dependencies."
+    );
+    throw new ZapierCliUserCancellationError(
+      "Required Zapier SDK packages were not installed"
+    );
+  }
+  await installPackages({ context, packages });
+}
+async function offerPackageUpdate({
+  context,
+  packageState
+}) {
+  const { currentVersion, dependency } = packageState;
+  if (!currentVersion || !dependency.checkForUpdates) return;
+  const update = await runWithSetupLoader({
+    promise: context.checkForUpdates({
+      packageName: dependency.name,
+      currentVersion
+    }),
+    label: "Checking for updates",
+    detail: dependency.name
+  });
+  if (!update.hasUpdate || !update.latestVersion) return;
+  const shouldUpdate = await resolveSetupConfirm({
+    answer: context.createAnswer(),
+    controller: context.setupController,
+    message: `Update ${dependency.name} from ${currentVersion} to ${update.latestVersion}?`,
+    defaultValue: true
+  });
+  if (!shouldUpdate) return;
+  await executeInstall(
+    context,
+    getInstallCommand({
+      packageManager: context.packageManager,
+      packages: [`${dependency.name}@${update.latestVersion}`],
+      dev: dependency.dev
+    })
+  );
+}
+async function prepareDependencies(context) {
+  const declaredPackageNames = getDeclaredPackageNames(context.cwd);
+  const requiredPackages = REQUIRED_PACKAGES.filter(
+    ({ typescriptOnly }) => !typescriptOnly || context.projectLanguage === "typescript"
+  );
+  const packages = requiredPackages.map((dependency) => ({
+    dependency,
+    currentVersion: declaredPackageNames.has(dependency.name) ? getInstalledPackageVersion({
+      cwd: context.cwd,
+      packageName: dependency.name
+    }) : void 0
+  }));
+  await offerMissingPackageInstall({
+    context,
+    packages: packages.filter(
+      ({ dependency }) => !declaredPackageNames.has(dependency.name)
+    )
+  });
+  for (const packageState of packages) {
+    await offerPackageUpdate({ context, packageState });
+  }
+}
+
+// src/plugins/setup/package-commands.ts
+function createLocalPackageCommand({
+  packageManager,
+  binary,
+  args = []
+}) {
+  const runner = {
+    npm: { command: "npx", args: ["--no-install"] },
+    pnpm: { command: "pnpm", args: ["exec"] },
+    yarn: { command: "yarn", args: ["exec"] },
+    bun: { command: "bunx", args: ["--no-install"] }
+  };
+  return {
+    command: runner[packageManager].command,
+    args: [...runner[packageManager].args, binary, ...args]
+  };
+}
+function createPackageRunnerCommand({
+  packageManager,
+  packageName,
+  args = []
+}) {
+  const runner = {
+    npm: { command: "npx", args: ["--yes"] },
+    pnpm: { command: "pnpm", args: ["dlx"] },
+    yarn: { command: "yarn", args: ["dlx"] },
+    bun: { command: "bunx", args: [] }
+  };
+  return {
+    command: runner[packageManager].command,
+    args: [...runner[packageManager].args, packageName, ...args]
+  };
+}
+function formatPackageCommand({
+  command,
+  args
+}) {
+  return [command, ...args].join(" ");
+}
+
+// src/plugins/setup/project.ts
+var COMMAND_MAX_BUFFER_BYTES = 10 * 1024 * 1024;
+var PROJECT_INIT_COMMANDS = {
+  npm: { command: "npm", args: ["init", "-y"] },
+  pnpm: { command: "pnpm", args: ["init"] },
+  yarn: { command: "yarn", args: ["init", "-y"] },
+  bun: { command: "bun", args: ["init", "-y"] }
+};
+var CapturedCommandError = class extends Error {
+  constructor(error, stdout, stderr) {
+    super(error.message);
+    this.stdout = stdout;
+    this.stderr = stderr;
+  }
+};
+function commandError({
+  command,
+  code,
+  signal
+}) {
+  return new Error(
+    signal ? `${command} was terminated by ${signal}` : `${command} exited with code ${code ?? "unknown"}`
+  );
+}
+function executeCapturedCommand({
+  command,
+  args,
+  cwd,
+  input
+}) {
+  return new Promise((resolve4, reject) => {
+    const child = crossSpawn__default.default(command, args, {
+      cwd,
+      shell: false,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    const append = ({
+      chunk,
+      stream
+    }) => {
+      if (stream === "stdout") stdout += chunk.toString();
+      else stderr += chunk.toString();
+      if (Buffer.byteLength(stdout) + Buffer.byteLength(stderr) > COMMAND_MAX_BUFFER_BYTES) {
+        child.kill();
+        reject(new Error("Command output exceeded the capture limit."));
+      }
+    };
+    child.stdout?.on(
+      "data",
+      (chunk) => append({ chunk, stream: "stdout" })
+    );
+    child.stderr?.on(
+      "data",
+      (chunk) => append({ chunk, stream: "stderr" })
+    );
+    child.once("error", reject);
+    child.once("close", (code, signal) => {
+      if (code === 0) {
+        resolve4(stdout.trim());
+        return;
+      }
+      reject(
+        new CapturedCommandError(
+          commandError({ command, code, signal }),
+          stdout,
+          stderr
+        )
+      );
+    });
+    child.stdin?.end(input);
+  });
+}
+function executeStreamingCommand({
+  command,
+  args,
+  cwd,
+  input
+}) {
+  return new Promise((resolve4, reject) => {
+    const child = crossSpawn__default.default(command, args, {
+      cwd,
+      shell: false,
+      stdio: [input === void 0 ? "inherit" : "pipe", "inherit", "inherit"]
+    });
+    child.once("error", reject);
+    child.once("close", (code, signal) => {
+      if (code === 0) {
+        resolve4("");
+        return;
+      }
+      reject(commandError({ command, code, signal }));
+    });
+    if (input !== void 0) child.stdin?.end(input);
+  });
+}
+async function runCommand({
+  command,
+  args = [],
+  cwd,
+  capture = true,
+  input
+}) {
+  const commandLabel = `$ ${command} ${args.join(" ")}`.trim();
+  const execute = capture ? executeCapturedCommand({ command, args, cwd, input }) : executeStreamingCommand({ command, args, cwd, input });
+  try {
+    if (capture) {
+      return await runWithSetupLoader({
+        promise: execute,
+        label: "Running command",
+        detail: commandLabel
+      });
+    }
+    console.log(chalk8__default.default.dim(commandLabel));
+    return await execute;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (error instanceof CapturedCommandError) {
+      if (error.stdout) process.stdout.write(error.stdout);
+      if (error.stderr) process.stderr.write(error.stderr);
+      if (!error.stdout && !error.stderr) console.error(message);
+    } else {
+      console.error(message);
+    }
+    throw new ZapierCliExitError(message);
+  }
+}
+async function chooseDirectory(context) {
+  const useCurrentDirectory = await resolveSetupConfirm({
+    answer: context.createAnswer(),
+    controller: context.setupController,
+    message: `Set up the Zapier SDK in ${context.cwd}?`,
+    defaultValue: true
+  });
+  if (useCurrentDirectory) return;
+  const setupCommand = formatPackageCommand(
+    createLocalPackageCommand({
+      packageManager: context.packageManager,
+      binary: "zapier-sdk",
+      args: ["setup"]
+    })
+  );
+  console.log(
+    `Setup cancelled. Navigate to the intended directory and run \`${setupCommand}\` again.`
+  );
+  throw new ZapierCliUserCancellationError("Setup cancelled by user");
+}
+async function ensureSupportedNode(context) {
+  let version;
+  try {
+    version = await context.runCommand({
+      command: "node",
+      args: ["-v"],
+      cwd: context.cwd,
+      capture: true
+    });
+  } catch {
+    console.error(
+      "Node.js 20 or higher is required. Install it from https://nodejs.org, then run setup again."
+    );
+    throw new ZapierCliExitError(
+      "Setup could not continue without Node.js 20 or higher."
+    );
+  }
+  const major = Number(version.replace(/^v/, "").split(".")[0]);
+  if (!Number.isFinite(major) || major < 20) {
+    console.error(
+      `Node.js 20 or higher is required; found ${version}. Upgrade Node.js, then run setup again.`
+    );
+    throw new ZapierCliExitError(
+      "Setup could not continue without Node.js 20 or higher."
+    );
+  }
+  console.log(`Node.js ${version} is ready.`);
+}
+function detectProjectLanguage({
+  cwd,
+  hasExistingProject
+}) {
+  if (!hasExistingProject || fs.existsSync(path.join(cwd, "tsconfig.json"))) {
+    return "typescript";
+  }
+  const manifest = readPackageJson({ directory: cwd });
+  const hasTypeScript = [
+    manifest?.dependencies,
+    manifest?.devDependencies
+  ].some(
+    (dependencies) => isRecord(dependencies) && "typescript" in dependencies
+  );
+  return hasTypeScript ? "typescript" : "javascript";
+}
+async function prepareProject(context) {
+  context.packageManager = detectPackageManager(context.cwd).name;
+  console.log(`Using ${context.packageManager} for dependency installs.`);
+  const hasExistingProject = fs.existsSync(path.join(context.cwd, "package.json"));
+  context.projectLanguage = detectProjectLanguage({
+    cwd: context.cwd,
+    hasExistingProject
+  });
+  if (hasExistingProject) {
+    console.log("Found package.json; using this project as-is.");
+  } else {
+    await context.runCommand({
+      ...PROJECT_INIT_COMMANDS[context.packageManager],
+      cwd: context.cwd
+    });
+  }
+  await prepareDependencies(context);
+}
+
+// src/plugins/setup/context.ts
+function createWizardContext({
+  imports
+}) {
+  return {
+    cwd: process.cwd(),
+    imports,
+    createAnswer: () => createCliAnswer({ mode: "closed-list" }),
+    setupController: createSetupController(),
+    checkForUpdates,
+    openUrl: async (url) => {
+      await open__default.default(url);
+    },
+    runCommand,
+    packageManager: detectPackageManager(process.cwd()).name,
+    projectLanguage: "typescript"
+  };
+}
+var SetupSchema = zod.z.object({}).describe("Set up the Zapier SDK in an existing or new project");
+function printAuthCommand({
+  context,
+  flow,
+  headless
+}) {
+  const command = createLocalPackageCommand({
+    packageManager: context.packageManager,
+    binary: "zapier-sdk",
+    args: [flow, ...headless ? ["--headless"] : []]
+  });
+  console.log(`$ ${formatPackageCommand(command)}`);
+  if (headless) {
+    console.log(
+      "Open the printed URL in another browser, then paste the final OAuth callback URL when prompted."
+    );
+  }
+}
+function isCredentialWriteError(error) {
+  const code = typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : "";
+  if (/^(eacces|eperm)$/i.test(code)) return true;
+  const message = error instanceof Error ? error.message : String(error);
+  return /permission|sandbox|eacces|eperm/i.test(message);
+}
+async function authenticate(context) {
+  const activeProfile = await runWithSetupLoader({
+    promise: context.imports.getProfile({}).then(({ data }) => data).catch((error) => {
+      if (zapierSdk.isZapierAuthenticationError(error)) return void 0;
+      throw error;
+    }),
+    label: "Checking Zapier authentication"
+  });
+  if (activeProfile) {
+    const shouldLogout = await resolveSetupConfirm({
+      answer: context.createAnswer(),
+      controller: context.setupController,
+      message: `You are already logged in as "${activeProfile.email}".
+Logging out will delete these credentials and may interrupt other Zapier SDK or CLI sessions using them.
+Log out and use a different account?`,
+      defaultValue: false
+    });
+    if (!shouldLogout) {
+      context.accountEmail = activeProfile.email;
+      console.log(`Continuing as ${activeProfile.email}.`);
+      return;
+    }
+    const logoutCommand = createLocalPackageCommand({
+      packageManager: context.packageManager,
+      binary: "zapier-sdk",
+      args: ["logout"]
+    });
+    console.log(`$ ${formatPackageCommand(logoutCommand)}`);
+    await context.imports.logout({});
+  }
+  const flow = await resolveSetupSelect({
+    answer: context.createAnswer(),
+    controller: context.setupController,
+    message: "Zapier account:",
+    choices: [
+      { label: "Log in to an existing account", value: "login" },
+      { label: "Create a new Zapier account", value: "signup" }
+    ]
+  });
+  const environment = await resolveSetupSelect({
+    answer: context.createAnswer(),
+    controller: context.setupController,
+    message: "Environment:",
+    choices: [
+      { label: "Local machine with a browser", value: "local" },
+      { label: "Remote or headless", value: "headless" }
+    ]
+  });
+  const headless = environment === "headless";
+  const runAuth = flow === "login" ? context.imports.login : context.imports.signup;
+  printAuthCommand({ context, flow, headless });
+  try {
+    await runAuth({ headless });
+  } catch (error) {
+    if (isCredentialWriteError(error)) {
+      console.error(
+        "Authentication could not write credentials. A permissions or sandbox restriction may be blocking disk access."
+      );
+    }
+    throw error;
+  }
+  const { data: profile } = await runWithSetupLoader({
+    promise: context.imports.getProfile({}),
+    label: "Confirming Zapier account"
+  });
+  context.accountEmail = profile.email;
+  console.log(`Authenticated as ${profile.email}.`);
+}
+var agentLabels = {
+  claude: "Claude Code",
+  codex: "Codex",
+  cursor: "Cursor",
+  "vscode-copilot": "VS Code Copilot"
+};
+function buildAgentPrompt({ context }) {
+  const listConnectionsCommand = formatPackageCommand(
+    createLocalPackageCommand({
+      packageManager: context.packageManager,
+      binary: "zapier-sdk",
+      args: ["list-connections", "--owner", "me", "--json"]
+    })
+  );
+  const listActionsCommand = formatPackageCommand(
+    createLocalPackageCommand({
+      packageManager: context.packageManager,
+      binary: "zapier-sdk",
+      args: ["list-actions", "APP_KEY"]
+    })
+  );
+  return `Start by running this command to discover my active connected apps outside of your sandbox:
+
+${listConnectionsCommand}
+
+Using the connected apps returned by that command:
+
+- Pick 1-3 apps and show commands I can use to explore their actions, such as: ${listActionsCommand}
+- Do not run those list-actions commands.
+- Suggest 3 specific ideas based on my connected apps. Each idea should read from one app, optionally process data, and write to another.
+- Do not suggest event-driven workflows.
+- Keep each idea to one sentence. Example: "pull in-progress Jira issues and DM yourself a summary on Slack".
+
+Do not inspect files or modify the project. If fewer than two distinct apps are listed, explain that cross-app ideas require another active connection instead of inventing apps.`;
+}
+function printAgentPrompt({
+  context,
+  message
+}) {
+  console.log();
+  console.log(chalk8__default.default.bgYellow.black.bold(message));
+  console.log();
+  console.log(buildAgentPrompt({ context }));
+}
+async function openAgentHandoff(context) {
+  const agent = await resolveSetupSelect({
+    answer: context.createAnswer(),
+    controller: context.setupController,
+    message: "Want to open your agent and have it give you suggestions to start?",
+    choices: [
+      { label: "No", value: "none" },
+      { label: "Claude Code", value: "claude" },
+      { label: "Cursor", value: "cursor" },
+      { label: "Codex", value: "codex" },
+      { label: "VS Code Copilot", value: "vscode-copilot" },
+      { label: "Other", value: "other" }
+    ]
+  });
+  if (agent === "none") return;
+  if (agent === "other") {
+    printAgentPrompt({
+      context,
+      message: "Paste this prompt into your AI agent:"
+    });
+    return;
+  }
+  const prompt = buildAgentPrompt({ context });
+  const encodedPrompt = encodeURIComponent(prompt);
+  const encodedPath = encodeURIComponent(context.cwd);
+  try {
+    switch (agent) {
+      case "claude":
+        await context.openUrl(
+          `claude://code/new?q=${encodedPrompt}&folder=${encodedPath}`
+        );
+        break;
+      case "codex":
+        await context.openUrl(
+          `codex://threads/new?prompt=${encodedPrompt}&path=${encodedPath}`
+        );
+        break;
+      case "cursor":
+        await context.runCommand({
+          command: "cursor",
+          args: ["."],
+          cwd: context.cwd,
+          capture: true
+        });
+        console.log(`Cursor opened in ${context.cwd}.`);
+        break;
+      case "vscode-copilot":
+        await context.runCommand({
+          command: "code",
+          args: ["chat", "--mode", "agent", "-"],
+          cwd: context.cwd,
+          input: prompt
+        });
+        break;
+      default: {
+        const unsupportedAgent = agent;
+        throw new Error(`Unsupported agent: ${unsupportedAgent}`);
+      }
+    }
+  } catch {
+    console.warn(
+      `Could not open ${agentLabels[agent]}. Open it manually to continue.`
+    );
+  }
+  printAgentPrompt({
+    context,
+    message: "If it didn't load correctly, paste this prompt into your agent:"
+  });
+}
+var CONNECTIONS_URL = "https://zapier.com/app/assets/connections";
+var CONNECTION_DISPLAY_LIMIT = 10;
+async function ensureConnectionsAvailable(context) {
+  const page = await runWithSetupLoader({
+    promise: context.imports.listConnections({
+      owner: "me",
+      maxItems: CONNECTION_DISPLAY_LIMIT
+    }),
+    label: "Loading app connections"
+  });
+  if (page.data.length === 0) {
+    console.log(
+      `No active connections found. Connect or reconnect an app at ${CONNECTIONS_URL}, then come back and run setup again.`
+    );
+    throw new ZapierCliExitError(
+      "Setup stopped before completion because no active connections are available."
+    );
+  }
+  const table = new Table__default.default({
+    head: ["App", "Connection"],
+    style: { compact: true }
+  });
+  table.push(
+    ...page.data.map((connection) => [
+      connection.slug || connection.app_key,
+      connection.title
+    ])
+  );
+  console.log(
+    `Active Zapier connections (showing up to ${CONNECTION_DISPLAY_LIMIT}):`
+  );
+  console.log(table.toString());
+}
+var CONNECTION_PLACEHOLDER = "__ZAPIER_SDK_SLACK_CONNECTION__";
+var EMAIL_PLACEHOLDER = "__ZAPIER_SDK_ACCOUNT_EMAIL__";
+var APP_PLACEHOLDER = "__ZAPIER_SDK_SLACK_APP__";
+var SLACK_SLUG = "slack";
+function getSlackTestPath(context) {
+  const extension = context.projectLanguage === "typescript" ? "ts" : "mjs";
+  return path.join("src", "sdk-demo", `zapier-slack-test.${extension}`);
+}
+function getSlackTestTemplatePath(context) {
+  const extension = context.projectLanguage === "typescript" ? "ts" : "mjs";
+  return path.join(TEMPLATES_DIR, "setup", `zapier-slack-test.${extension}`);
+}
+async function findSlackConnection(context) {
+  const page = await runWithSetupLoader({
+    promise: context.imports.listConnections({
+      owner: "me",
+      app: SLACK_SLUG,
+      maxItems: 1
+    }),
+    label: "Looking for a Slack connection"
+  });
+  return page.data.find(({ slug }) => slug === SLACK_SLUG);
+}
+function toTemplateString(value) {
+  return JSON.stringify(value).slice(1, -1);
+}
+function renderSlackTest({
+  context,
+  app,
+  connection,
+  email
+}) {
+  return fs.readFileSync(getSlackTestTemplatePath(context), "utf8").replace(APP_PLACEHOLDER, () => toTemplateString(app)).replace(CONNECTION_PLACEHOLDER, () => toTemplateString(connection)).replace(EMAIL_PLACEHOLDER, () => toTemplateString(email));
+}
+function writeSlackTest({
+  context,
+  app,
+  connection,
+  email
+}) {
+  const slackTestPath = getSlackTestPath(context);
+  const path2 = path.join(context.cwd, slackTestPath);
+  if (!fs.existsSync(path.dirname(path2))) fs.mkdirSync(path.dirname(path2), { recursive: true });
+  fs.writeFileSync(path2, renderSlackTest({ context, app, connection, email }));
+  console.log(`Created ${slackTestPath}.`);
+}
+async function executeSlackTest(context) {
+  const slackTestPath = getSlackTestPath(context);
+  if (context.projectLanguage === "javascript") {
+    await context.runCommand({
+      command: "node",
+      args: [slackTestPath],
+      cwd: context.cwd,
+      capture: false
+    });
+    return;
+  }
+  const command = context.packageManager === "bun" ? { command: "bun", args: [] } : createLocalPackageCommand({
+    packageManager: context.packageManager,
+    binary: "tsx"
+  });
+  const args = [...command.args, slackTestPath];
+  await context.runCommand({
+    command: command.command,
+    args,
+    cwd: context.cwd,
+    capture: false
+  });
+}
+async function trySlackTest(context) {
+  try {
+    await executeSlackTest(context);
+    return true;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`Slack demo failed: ${message}. Setup will continue.`);
+    return false;
+  }
+}
+async function offerSlackTest(context) {
+  if (!context.accountEmail) {
+    console.log("No account email found; skipping the Slack demo.");
+    return;
+  }
+  const slackConnection = await findSlackConnection(context);
+  if (!slackConnection) {
+    console.log("No active Slack connection found; skipping the Slack demo.");
+    return;
+  }
+  const slackTestPath = getSlackTestPath(context);
+  const shouldRun = await resolveSetupConfirm({
+    answer: context.createAnswer(),
+    controller: context.setupController,
+    message: `Run the Slack self-DM test using ${context.accountEmail}?`,
+    defaultValue: true
+  });
+  if (!shouldRun) return;
+  const path2 = path.join(context.cwd, slackTestPath);
+  if (fs.existsSync(path2)) {
+    const shouldOverwrite = await resolveSetupConfirm({
+      answer: context.createAnswer(),
+      controller: context.setupController,
+      message: `${slackTestPath} already exists. Is it okay to overwrite it?`,
+      defaultValue: false
+    });
+    if (!shouldOverwrite) {
+      console.log("Keeping the existing Slack test file.");
+      const shouldRunExisting = await resolveSetupConfirm({
+        answer: context.createAnswer(),
+        controller: context.setupController,
+        message: `Run the existing ${slackTestPath}?`,
+        defaultValue: false
+      });
+      if (shouldRunExisting) await trySlackTest(context);
+      return;
+    }
+  }
+  let email = context.accountEmail;
+  writeSlackTest({
+    context,
+    app: SLACK_SLUG,
+    connection: slackConnection.id,
+    email
+  });
+  if (await trySlackTest(context)) return;
+  email = await resolveSetupInput({
+    answer: context.createAnswer(),
+    controller: context.setupController,
+    message: "Slack email for one retry after the failed test:"
+  });
+  if (!email) {
+    console.log("Skipping the Slack test.");
+    return;
+  }
+  writeSlackTest({
+    context,
+    app: SLACK_SLUG,
+    connection: slackConnection.id,
+    email
+  });
+  await trySlackTest(context);
+}
+
+// src/plugins/setup/skill.ts
+async function installOptionalSkill(context) {
+  const shouldInstall = await resolveSetupConfirm({
+    answer: context.createAnswer(),
+    controller: context.setupController,
+    message: "Install the optional Zapier SDK skill for extra agent context? This is not required for SDK setup.",
+    defaultValue: true
+  });
+  if (!shouldInstall) {
+    console.log("Skipping the optional Zapier SDK skill.");
+    return;
+  }
+  const command = createPackageRunnerCommand({
+    packageManager: context.packageManager,
+    packageName: "skills",
+    args: ["add", "zapier/sdk", "-y"]
+  });
+  try {
+    await context.runCommand({
+      ...command,
+      cwd: context.cwd,
+      capture: true
+    });
+  } catch {
+    console.warn(
+      `Could not install the optional Zapier SDK skill. To install it manually, run: ${formatPackageCommand(command)}`
+    );
+  }
+}
+
+// src/plugins/setup/wizard.ts
+var PHASE_COUNT = 6;
+var MINIMUM_MESSAGE_WIDTH = 20;
+var MAXIMUM_MESSAGE_WIDTH = 88;
+function showPhase({ number, title }) {
+  console.log();
+  console.log(chalk8__default.default.bgCyan.black.bold(` ${number}/${PHASE_COUNT}  ${title} `));
+}
+function printWrapped(text) {
+  const width = Math.max(
+    MINIMUM_MESSAGE_WIDTH,
+    Math.min(
+      process.stdout.columns ?? MAXIMUM_MESSAGE_WIDTH,
+      MAXIMUM_MESSAGE_WIDTH
+    )
+  );
+  console.log(wrapAnsi4__default.default(text, width));
+}
+function showReadyMessage() {
+  console.log();
+  console.log(chalk8__default.default.bgGreen.black.bold(" \u2713 Zapier SDK setup complete "));
+  console.log();
+  printWrapped(
+    "Use active Zapier connections to access 9,000+ app connectors without managing each app's OAuth, token refresh, or retries."
+  );
+  console.log();
+  printWrapped(
+    "To learn more about the Zapier SDK, visit https://docs.zapier.com/sdk"
+  );
+  console.log();
+}
+async function runWizard(context) {
+  console.log(chalk8__default.default.bold("Zapier SDK setup"));
+  showPhase({ number: 1, title: "Project directory" });
+  await chooseDirectory(context);
+  showPhase({ number: 2, title: "Node.js" });
+  await ensureSupportedNode(context);
+  showPhase({ number: 3, title: "Dependencies" });
+  await prepareProject(context);
+  await installOptionalSkill(context);
+  showPhase({ number: 4, title: "Zapier account" });
+  await authenticate(context);
+  showPhase({ number: 5, title: "App connections" });
+  await ensureConnectionsAvailable(context);
+  showPhase({ number: 6, title: "Slack demo" });
+  await offerSlackTest(context);
+  showReadyMessage();
+  console.log(chalk8__default.default.bgCyan.black.bold(" Next steps "));
+  await openAgentHandoff(context);
+}
+
+// src/plugins/setup/index.ts
+var getProfileRef = zapierSdk.declareMethod({ id: "getProfile" });
+var listConnectionsRef2 = zapierSdk.declareMethod({ id: "listConnections" });
+var loginRef = zapierSdk.declareMethod({ id: "login" });
+var logoutRef = zapierSdk.declareMethod({ id: "logout" });
+var signupRef = zapierSdk.declareMethod({ id: "signup" });
+var setupImports = [
+  getProfileRef,
+  listConnectionsRef2,
+  loginRef,
+  logoutRef,
+  signupRef
+];
+var setupPlugin = zapierSdk.defineMethod({
+  name: "setup",
+  imports: setupImports,
+  categories: ["utility"],
+  supportsJsonOutput: false,
+  inputSchema: SetupSchema,
+  output: "raw",
+  run: async ({ imports }) => {
+    if (process.stdin.isTTY !== true || process.stdout.isTTY !== true) {
+      throw new ZapierCliExitError(
+        "`zapier-sdk setup` requires an interactive terminal."
+      );
+    }
+    await runWizard(createWizardContext({ imports }));
+  }
+});
+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(
+      `
+${chalk8__default.default.bold(`Message #${messageNumber}`)} ${chalk8__default.default.dim(message.id)} ${chalk8__default.default.dim(`(lease #${attrs.lease_count})`)}`
+    );
+    if (attrs.error_message) {
+      console.log(chalk8__default.default.yellow(`  upstream error: ${attrs.error_message}`));
+    }
+    if (attrs.possible_duplicate_data) {
+      console.log(chalk8__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(chalk8__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 = () => {
@@ -6747,7 +8170,7 @@ function renderDeprecationNotices() {
 function buildBoxLines(message) {
   const innerWidth = BOX_WIDTH - 4;
   const pad = (line) => `\u2502 ${line.padEnd(innerWidth)} \u2502`;
-  const wrapped = wrapAnsi3__default.default(message, innerWidth, { hard: true }).split("\n");
+  const wrapped = wrapAnsi4__default.default(message, innerWidth, { hard: true }).split("\n");
   return [
     `\u256D${"\u2500".repeat(BOX_WIDTH - 2)}\u256E`,
     pad(BOX_TITLE),
@@ -6760,7 +8183,7 @@ function buildBoxLines(message) {
 // package.json with { type: 'json' }
 var package_default2 = {
   name: "@zapier/zapier-sdk-cli",
-  version: "0.68.0"};
+  version: "0.69.0"};
 
 // src/sdk.ts
 var warnedDeprecatedMethods = /* @__PURE__ */ new Set();
@@ -6800,6 +8223,7 @@ var cliSdkPlugin = zapierSdk.definePlugin({
     mcpPlugin,
     getLoginConfigPathPlugin,
     initPlugin,
+    setupPlugin,
     bundleCodePlugin,
     feedbackPlugin,
     curlPlugin,
@@ -6868,6 +8292,7 @@ function createZapierCliSdk2(options = {}) {
       mcpPlugin,
       getLoginConfigPathPlugin,
       initPlugin,
+      setupPlugin,
       bundleCodePlugin,
       feedbackPlugin,
       curlPlugin,
@@ -6952,163 +8377,6 @@ function readEnvSpecs() {
   if (!raw) return [];
   return raw.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
 }
-var ONE_DAY_MILLISECONDS = 24 * 60 * 60 * 1e3;
-var CACHE_RESET_INTERVAL_MILLISECONDS = (() => {
-  const {
-    ZAPIER_SDK_UPDATE_CHECK_INTERVAL_SECONDS,
-    ZAPIER_SDK_UPDATE_CHECK_INTERVAL_MS
-  } = process.env;
-  let intervalMs;
-  if (ZAPIER_SDK_UPDATE_CHECK_INTERVAL_SECONDS !== void 0) {
-    const seconds = parseInt(ZAPIER_SDK_UPDATE_CHECK_INTERVAL_SECONDS);
-    intervalMs = isNaN(seconds) ? NaN : seconds * 1e3;
-  } else if (ZAPIER_SDK_UPDATE_CHECK_INTERVAL_MS !== void 0) {
-    intervalMs = parseInt(ZAPIER_SDK_UPDATE_CHECK_INTERVAL_MS);
-  } else {
-    intervalMs = ONE_DAY_MILLISECONDS;
-  }
-  if (isNaN(intervalMs) || intervalMs < 0) {
-    return -1;
-  }
-  return intervalMs;
-})();
-function getVersionCache() {
-  try {
-    const cache = getConfig().get("version_cache");
-    const now = Date.now();
-    if (!cache || !cache.last_reset_timestamp || now - cache.last_reset_timestamp >= CACHE_RESET_INTERVAL_MILLISECONDS) {
-      const newCache = {
-        last_reset_timestamp: now,
-        packages: {}
-      };
-      getConfig().set("version_cache", newCache);
-      return newCache;
-    }
-    return cache;
-  } catch (error) {
-    log_default.debug(`Failed to read version cache: ${error}`);
-    return {
-      last_reset_timestamp: Date.now(),
-      packages: {}
-    };
-  }
-}
-function setCachedPackageInfo(packageName, version, info) {
-  try {
-    const cache = getVersionCache();
-    if (!cache.packages[packageName]) {
-      cache.packages[packageName] = {};
-    }
-    cache.packages[packageName][version] = info;
-    getConfig().set("version_cache", cache);
-  } catch (error) {
-    log_default.debug(`Failed to cache package info: ${error}`);
-  }
-}
-function getCachedPackageInfo(packageName, version) {
-  try {
-    const cache = getVersionCache();
-    return cache.packages[packageName]?.[version];
-  } catch (error) {
-    log_default.debug(`Failed to get cached package info: ${error}`);
-    return void 0;
-  }
-}
-async function fetchCachedPackageInfo(packageName, version) {
-  const cacheKey = version || "latest";
-  let cachedInfo = getCachedPackageInfo(packageName, cacheKey);
-  if (cachedInfo) {
-    return cachedInfo;
-  }
-  const packageInfo = await packageJsonLib__default.default(packageName, {
-    version,
-    fullMetadata: true
-  });
-  const info = {
-    version: packageInfo.version,
-    deprecated: packageInfo.deprecated,
-    fetched_at: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  setCachedPackageInfo(packageName, cacheKey, info);
-  return info;
-}
-async function checkForUpdates({
-  packageName,
-  currentVersion
-}) {
-  try {
-    const latestPackageInfo = await fetchCachedPackageInfo(packageName);
-    const latestVersion = latestPackageInfo.version;
-    const hasUpdate = semver__default.default.gt(latestVersion, currentVersion);
-    let currentPackageInfo;
-    try {
-      currentPackageInfo = await fetchCachedPackageInfo(
-        packageName,
-        currentVersion
-      );
-    } catch (error) {
-      if (!(error instanceof packageJsonLib.VersionNotFoundError)) {
-        log_default.debug(`Failed to check deprecation for current version: ${error}`);
-      }
-      currentPackageInfo = latestPackageInfo;
-    }
-    const isDeprecated = Boolean(currentPackageInfo.deprecated);
-    const deprecationMessage = isDeprecated ? String(currentPackageInfo.deprecated) : void 0;
-    return {
-      hasUpdate,
-      latestVersion,
-      currentVersion,
-      isDeprecated,
-      deprecationMessage
-    };
-  } catch (error) {
-    log_default.debug(`Failed to check for updates: ${error}`);
-    return {
-      hasUpdate: false,
-      currentVersion,
-      isDeprecated: false
-    };
-  }
-}
-function displayUpdateNotification(versionInfo, packageName) {
-  if (versionInfo.isDeprecated) {
-    console.error();
-    console.error(
-      chalk8__default.default.red.bold("\u26A0\uFE0F  DEPRECATION WARNING") + chalk8__default.default.red(
-        ` - ${packageName} v${versionInfo.currentVersion} is deprecated.`
-      )
-    );
-    if (versionInfo.deprecationMessage) {
-      console.error(chalk8__default.default.red(`   ${versionInfo.deprecationMessage}`));
-    }
-    console.error(chalk8__default.default.red(`   Please update to the latest version.`));
-    console.error();
-  }
-  if (versionInfo.hasUpdate) {
-    console.error();
-    console.error(
-      chalk8__default.default.yellow.bold("\u{1F4E6} Update available!") + chalk8__default.default.yellow(
-        ` ${packageName} v${versionInfo.currentVersion} \u2192 v${versionInfo.latestVersion}`
-      )
-    );
-    console.error(
-      chalk8__default.default.yellow(
-        `   Run ${chalk8__default.default.bold(getUpdateCommand(packageName))} to update.`
-      )
-    );
-    console.error();
-  }
-}
-async function checkAndNotifyUpdates({
-  packageName,
-  currentVersion
-}) {
-  if (CACHE_RESET_INTERVAL_MILLISECONDS < 0) {
-    return;
-  }
-  const versionInfo = await checkForUpdates({ packageName, currentVersion });
-  displayUpdateNotification(versionInfo, packageName);
-}
 var EMOJI_PRESENTATION_PATTERN = /\p{Emoji_Presentation}/u;
 var WIDE_CODE_POINT_RANGES = [
   [4352, 4447],
@@ -7212,7 +8480,7 @@ function buildFrameLines(state, frameIndex) {
   const hasMessages = recentMessages.length > 0;
   recentMessages.forEach((message, index) => {
     const dimmed = Boolean(state.verdict) || index < recentMessages.length - 1;
-    const segments = wrapAnsi3__default.default(message, bodyTextWidth, { hard: true }).split(
+    const segments = wrapAnsi4__default.default(message, bodyTextWidth, { hard: true }).split(
       "\n"
     );
     segments.forEach((segment, segmentIndex) => {
@@ -7223,7 +8491,7 @@ function buildFrameLines(state, frameIndex) {
   if (state.streamError) {
     if (hasMessages || !state.verdict) content.push("");
     content.push(chalk8__default.default.bold.red("Approval stream error"));
-    for (const segment of wrapAnsi3__default.default(state.streamError, bodyTextWidth, {
+    for (const segment of wrapAnsi4__default.default(state.streamError, bodyTextWidth, {
       hard: true
     }).split("\n")) {
       content.push(`  ${segment}`);
@@ -7235,7 +8503,7 @@ function buildFrameLines(state, frameIndex) {
       chalk8__default.default.bold.green(`${state.verdict.icon} ${state.verdict.label}`)
     );
     if (state.verdict.reason) {
-      for (const segment of wrapAnsi3__default.default(state.verdict.reason, bodyTextWidth, {
+      for (const segment of wrapAnsi4__default.default(state.verdict.reason, bodyTextWidth, {
         hard: true
       }).split("\n")) {
         content.push(`  ${segment}`);