@zapier/zapier-sdk-cli 0.67.6 → 0.69.0

package/dist/experimental.cjs

@@ -11,7 +11,7 @@ var zapierSdk = require('@zapier/zapier-sdk');
 var zod = require('zod');
 var experimental = require('@zapier/zapier-sdk/experimental');
 var os = require('os');
-var inquirer = require('inquirer');
+var inquirer3 = require('inquirer');
 var express = require('express');
 var promises$1 = require('readline/promises');
 var open = require('open');
@@ -26,7 +26,12 @@ require('is-installed-globally');
 var child_process = require('child_process');
 var Handlebars = require('handlebars');
 var url = require('url');
-require('wrap-ansi');
+var core = require('@inquirer/core');
+var packageJsonLib = require('package-json');
+var semver = require('semver');
+var crossSpawn = require('cross-spawn');
+var wrapAnsi = require('wrap-ansi');
+var Table = require('cli-table3');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -55,7 +60,7 @@ 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 inquirer__default = /*#__PURE__*/_interopDefault(inquirer);
+var inquirer3__default = /*#__PURE__*/_interopDefault(inquirer3);
 var express__default = /*#__PURE__*/_interopDefault(express);
 var open__default = /*#__PURE__*/_interopDefault(open);
 var chalk3__default = /*#__PURE__*/_interopDefault(chalk3);
@@ -63,6 +68,11 @@ var ora__default = /*#__PURE__*/_interopDefault(ora);
 var pkceChallenge__default = /*#__PURE__*/_interopDefault(pkceChallenge);
 var ts__namespace = /*#__PURE__*/_interopNamespace(ts);
 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 wrapAnsi__default = /*#__PURE__*/_interopDefault(wrapAnsi);
+var Table__default = /*#__PURE__*/_interopDefault(Table);
 
 var __defProp = Object.defineProperty;
 var __export = (target, all) => {
@@ -1996,7 +2006,7 @@ async function promptCredentialsName({
   email,
   promptMessage
 }) {
-  const { credentialName } = await inquirer__default.default.prompt([
+  const { credentialName } = await inquirer3__default.default.prompt([
     {
       type: "input",
       name: "credentialName",
@@ -2059,7 +2069,7 @@ async function promptConfirm({
   message,
   defaultValue
 }) {
-  const { confirmed } = await inquirer__default.default.prompt([
+  const { confirmed } = await inquirer3__default.default.prompt([
     { type: "confirm", name: "confirmed", message, default: defaultValue }
   ]);
   return confirmed;
@@ -4135,26 +4145,57 @@ var InitSchema = zod.z.object({
 }).describe(
   "Create a new Zapier SDK project in a new directory with starter files"
 );
+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 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" };
+  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: "unknown", source: "fallback" };
+  return { name: "npm", source: "fallback" };
 }
 function getDirentParentPath(entry) {
   const e = entry;
@@ -4202,7 +4243,7 @@ async function promptYesNo({
   nonInteractive
 }) {
   if (nonInteractive) return defaultValue;
-  const { answer } = await inquirer__default.default.prompt([
+  const { answer } = await inquirer3__default.default.prompt([
     { type: "confirm", name: "answer", message, default: defaultValue }
   ]);
   return answer;
@@ -4552,17 +4593,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 = [];
@@ -4590,8 +4630,1729 @@ var initPlugin = zapierSdk.defineMethod({
       projectName,
       steps,
       completedSetupStepIds,
-      packageManager
+      packageManager: packageManager.name
+    });
+  }
+});
+function isSelectable(item) {
+  return !core.Separator.isSeparator(item) && !item.disabled;
+}
+function normalizeChoices(choices) {
+  return choices.map((choice) => {
+    if (core.Separator.isSeparator(choice)) return choice;
+    const name = choice.name ?? String(choice.value);
+    return {
+      value: choice.value,
+      name,
+      short: choice.short ?? name,
+      disabled: choice.disabled ?? false
+    };
+  });
+}
+var theme = core.makeTheme({
+  icon: { cursor: "\u276F" },
+  style: {
+    disabled: (text) => chalk3__default.default.dim(`- ${text}`),
+    searchTerm: (text) => chalk3__default.default.cyan(text),
+    keysHelpTip: (keys) => keys.map(([key, action]) => `${chalk3__default.default.bold(key)} ${chalk3__default.default.dim(action)}`).join(chalk3__default.default.dim(" \u2022 "))
+  }
+});
+var searchSelect = core.createPrompt(
+  (config2, done) => {
+    const { pageSize = 7 } = config2;
+    const [status, setStatus] = core.useState(
+      "loading"
+    );
+    const [searchTerm, setSearchTerm] = core.useState("");
+    const [searchResults, setSearchResults] = core.useState([]);
+    const [searchError, setSearchError] = core.useState();
+    const prefix = core.usePrefix({ status, theme });
+    const bounds = core.useMemo(() => {
+      const first = searchResults.findIndex(isSelectable);
+      let last = -1;
+      for (let i = searchResults.length - 1; i >= 0; i--) {
+        if (isSelectable(searchResults[i])) {
+          last = i;
+          break;
+        }
+      }
+      return { first, last };
+    }, [searchResults]);
+    const defaultActive = core.useMemo(() => {
+      const requested = config2.initialActive;
+      if (searchTerm === "" && requested !== void 0 && requested >= 0 && requested < searchResults.length && isSelectable(searchResults[requested])) {
+        return requested;
+      }
+      return bounds.first;
+    }, [searchResults, searchTerm, bounds.first]);
+    const [active = defaultActive, setActive] = core.useState();
+    core.useEffect(() => {
+      const controller = new AbortController();
+      setStatus("loading");
+      setSearchError(void 0);
+      const fetchResults = async () => {
+        try {
+          const results = await config2.source(searchTerm || void 0);
+          if (!controller.signal.aborted) {
+            setActive(void 0);
+            setSearchError(void 0);
+            setSearchResults(normalizeChoices(results));
+            setStatus("idle");
+          }
+        } catch (error2) {
+          if (!controller.signal.aborted && error2 instanceof Error) {
+            setSearchError(error2.message);
+          }
+        }
+      };
+      void fetchResults();
+      return () => {
+        controller.abort();
+      };
+    }, [searchTerm]);
+    const selectedChoice = searchResults[active];
+    core.useKeypress((key, rl) => {
+      if (core.isEnterKey(key)) {
+        if (selectedChoice && isSelectable(selectedChoice)) {
+          setStatus("done");
+          done(selectedChoice.value);
+        } else {
+          rl.write(searchTerm);
+        }
+      } else if (core.isTabKey(key) && selectedChoice && isSelectable(selectedChoice)) {
+        rl.clearLine(0);
+        rl.write(selectedChoice.name);
+        setSearchTerm(selectedChoice.name);
+      } else if (status !== "loading" && (core.isUpKey(key) || core.isDownKey(key))) {
+        rl.clearLine(0);
+        if (core.isUpKey(key) && active !== bounds.first || core.isDownKey(key) && active !== bounds.last) {
+          const offset = core.isUpKey(key) ? -1 : 1;
+          let next = active;
+          do {
+            next = (next + offset + searchResults.length) % searchResults.length;
+          } while (!isSelectable(searchResults[next]));
+          setActive(next);
+        }
+      } else {
+        setSearchTerm(rl.line);
+      }
+    });
+    const page = core.usePagination({
+      items: searchResults,
+      active,
+      renderItem({ item, isActive }) {
+        if (core.Separator.isSeparator(item)) {
+          return ` ${item.separator}`;
+        }
+        if (item.disabled) {
+          const disabledLabel = typeof item.disabled === "string" ? item.disabled : "(disabled)";
+          return theme.style.disabled(`${item.name} ${disabledLabel}`);
+        }
+        const color = isActive ? theme.style.highlight : (x) => x;
+        const cursor = isActive ? theme.icon.cursor : ` `;
+        return color(`${cursor} ${item.name}`);
+      },
+      pageSize,
+      loop: false
+    });
+    const message = theme.style.message(config2.message, status);
+    if (status === "done" && selectedChoice && isSelectable(selectedChoice)) {
+      return [prefix, message, theme.style.answer(selectedChoice.short)].filter(Boolean).join(" ").trimEnd();
+    }
+    const searchStr = theme.style.searchTerm(searchTerm);
+    const helpTip = theme.style.keysHelpTip([
+      ["\u2191\u2193", "navigate"],
+      ["\u23CE", "select"]
+    ]);
+    let error;
+    if (searchError) {
+      error = theme.style.error(searchError);
+    } else if (searchResults.length === 0 && searchTerm !== "" && status === "idle") {
+      error = theme.style.error("No results found");
+    }
+    const header = [prefix, message, searchStr].filter(Boolean).join(" ").trimEnd();
+    const body = [error ?? page, " ", helpTip].filter(Boolean).join("\n").trimEnd();
+    return [header, body];
+  }
+);
+
+// src/utils/controller-answer.ts
+function offers(question, action) {
+  return question.actions.some((a) => a.action === action);
+}
+function isActionRow(value) {
+  return typeof value === "object" && value !== null && "action" in value;
+}
+async function promptText({
+  message,
+  password
+}) {
+  const { value } = await inquirer3__default.default.prompt([
+    {
+      type: password ? "password" : "input",
+      name: "value",
+      message,
+      theme: HIGH_CONTRAST_PROMPT_THEME
+    }
+  ]);
+  return value;
+}
+var display = (c) => c.hint ? `${c.label} ${chalk3__default.default.dim(`(${c.hint})`)}` : c.label;
+var HIGH_CONTRAST_PROMPT_THEME = {
+  style: {
+    answer: (text) => chalk3__default.default.inverse.bold(` ${text} `)
+  }
+};
+function buildSelectRows(question, term) {
+  const row = (name, action) => ({
+    name,
+    value: { action }
+  });
+  const t = term.trim().toLowerCase();
+  const matched = t ? question.choices.filter(
+    (c) => `${c.label} ${c.hint ?? ""}`.toLowerCase().includes(t)
+  ) : question.choices;
+  const matchRows = matched.map((c) => ({
+    name: display(c),
+    value: c.value
+  }));
+  const skipRow = offers(question, "skip") ? [row(chalk3__default.default.dim("Skip (optional)"), "skip")] : [];
+  const customRow = offers(question, "custom") ? [row(chalk3__default.default.dim("Enter a value manually\u2026"), "custom")] : [];
+  const committed = !!t || question.search !== void 0;
+  let rows;
+  if (!committed) {
+    rows = [...skipRow, ...customRow, ...matchRows];
+  } else if (matchRows.length > 0) {
+    rows = [...matchRows, ...skipRow, ...customRow];
+  } else {
+    rows = [...customRow, ...skipRow];
+  }
+  if (offers(question, "search"))
+    rows.push(row(chalk3__default.default.cyan("Search again\u2026"), "search"));
+  if (offers(question, "next_page"))
+    rows.push(row(chalk3__default.default.dim("Load more\u2026"), "next_page"));
+  if (offers(question, "retry")) rows.push(row(chalk3__default.default.yellow("Retry"), "retry"));
+  if (offers(question, "cancel")) rows.push(row(chalk3__default.default.dim("Cancel"), "cancel"));
+  for (const note of question.notes ?? [])
+    rows.push({ name: chalk3__default.default.dim(note), value: note, disabled: true });
+  return rows;
+}
+function foldPage(acc, question, field) {
+  const page = question.page;
+  if (!page) {
+    return {
+      key: field,
+      pageIndex: 0,
+      choices: question.choices,
+      newStart: 0,
+      checked: []
+    };
+  }
+  const key = `${field}#${page.generation}`;
+  if (acc?.key === key && page.index === acc.pageIndex + 1) {
+    return {
+      key,
+      pageIndex: page.index,
+      choices: [...acc.choices, ...question.choices],
+      newStart: acc.choices.length,
+      checked: acc.checked
+    };
+  }
+  if (acc?.key === key && page.index === acc.pageIndex) {
+    return { ...acc, newStart: 0 };
+  }
+  return {
+    key,
+    pageIndex: page.index,
+    choices: question.choices,
+    newStart: 0,
+    checked: []
+  };
+}
+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 inquirer3__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 inquirer3__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");
+    }
+    const choices = [
+      ...acc.choices.map((c) => ({
+        name: display(c),
+        value: c.value,
+        checked: acc.checked.includes(c.value)
+      })),
+      ...offers(question, "next_page") ? [
+        {
+          name: chalk3__default.default.dim("Load more\u2026"),
+          value: { action: "next_page" }
+        }
+      ] : [],
+      ...(question.notes ?? []).map((note) => ({
+        name: chalk3__default.default.dim(note),
+        value: note,
+        disabled: true
+      }))
+    ];
+    const { values } = await inquirer3__default.default.prompt([
+      {
+        type: "checkbox",
+        name: "values",
+        message: question.message,
+        choices,
+        theme: HIGH_CONTRAST_PROMPT_THEME
+      }
+    ]);
+    const selected = values;
+    const picked = selected.filter((v) => !isActionRow(v));
+    if (selected.some(isActionRow)) {
+      box.acc = { ...acc, checked: picked };
+      return { type: "next_page" };
+    }
+    if (picked.length === 0 && offers(question, "skip")) {
+      return { type: "skip" };
+    }
+    return { type: "choose", value: picked };
+  }
+  if (offers(question, "search") && question.search === void 0) {
+    const optional = offers(question, "skip");
+    const parts = [
+      ...optional ? ["optional"] : [],
+      ...question.placeholder ? [question.placeholder] : []
+    ];
+    const hint = parts.length ? ` (${parts.join(", ")})` : "";
+    while (true) {
+      const term = (await promptText({
+        message: `Enter or search ${field}${hint}:`,
+        password: false
+      })).trim();
+      if (term) return { type: "search", term };
+      if (optional) return { type: "skip" };
+    }
+  }
+  const newStart = acc?.newStart ?? 0;
+  const firstFreshValue = newStart > 0 ? view.choices[newStart]?.value : void 0;
+  const initialActive = firstFreshValue !== void 0 ? buildSelectRows(view, "").findIndex((r) => r.value === firstFreshValue) : -1;
+  const value = await searchSelect(
+    {
+      message: view.message,
+      source: (term) => buildSelectRows(view, term ?? ""),
+      ...initialActive >= 0 ? { initialActive } : {}
+    },
+    { clearPromptOnDone: true }
+  );
+  if (!isActionRow(value)) {
+    const picked = view.choices.find((c) => c.value === value);
+    printAnswered(view.message, picked?.label ?? String(value));
+    return { type: "choose", value };
+  }
+  switch (value.action) {
+    case "search": {
+      const term = await promptText({
+        message: `Search ${field}:`,
+        password: false
+      });
+      return { type: "search", term };
+    }
+    case "custom": {
+      const custom = await promptText({
+        message: `Enter ${field}:`,
+        password: false
+      });
+      return { type: "custom", value: custom };
+    }
+    case "next_page":
+      return { type: "next_page" };
+    case "retry":
+      return { type: "retry" };
+    case "skip":
+      printAnswered(view.message, chalk3__default.default.dim("(skipped)"));
+      return { type: "skip" };
+    case "cancel":
+      return { type: "cancel" };
+  }
+}
+function printAnswered(message, label) {
+  console.log(`${chalk3__default.default.green("\u2714")} ${message} ${chalk3__default.default.cyan(label)}`);
+}
+async function answerInput(question) {
+  const message = question.placeholder ? question.message.replace(/:?\s*$/, ` (${question.placeholder}):`) : question.message;
+  const value = await promptText({
+    message,
+    password: question.inputType === "password"
+  });
+  if (value === "" && offers(question, "skip")) {
+    return { type: "skip" };
+  }
+  return { type: "custom", value };
+}
+async function answerCollection(question) {
+  if (!offers(question, "done")) {
+    return { type: "add" };
+  }
+  if (question.description) console.log(question.description);
+  const { again } = await inquirer3__default.default.prompt([
+    {
+      type: "confirm",
+      name: "again",
+      message: question.message,
+      default: false,
+      theme: HIGH_CONTRAST_PROMPT_THEME
+    }
+  ]);
+  return again ? { type: "add" } : { type: "done" };
+}
+function createCliAnswer({
+  mode = "search"
+} = {}) {
+  const box = {};
+  return async ({ result }) => {
+    try {
+      if (result.error !== void 0) {
+        const message = typeof result.error === "string" ? result.error : result.error.message;
+        console.log(chalk3__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;
+    }
+  };
+}
+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
+    };
+  }
+}
+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 ? `${chalk3__default.default.bold(label)}  ${chalk3__default.default.dim(detail)}` : chalk3__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 ? chalk3__default.default.bold.yellow(cell) : chalk3__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)}  ${chalk3__default.default.dim(`${elapsedSeconds}s`)}`);
+    return result;
+  } catch (error) {
+    clearInterval(animationTimer);
+    const elapsedSeconds = ((Date.now() - startedAt) / 1e3).toFixed(1);
+    loader.fail(`${formatPhase(phase)}  ${chalk3__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(chalk3__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(chalk3__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(chalk3__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(wrapAnsi__default.default(text, width));
+}
+function showReadyMessage() {
+  console.log();
+  console.log(chalk3__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(chalk3__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(chalk3__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 }));
   }
 });
 
@@ -4633,7 +6394,7 @@ ${chalk3__default.default.bold(`Message #${messageNumber}`)} ${chalk3__default.d
     while (true) {
       let action;
       try {
-        const answer = await inquirer__default.default.prompt([
+        const answer = await inquirer3__default.default.prompt([
           {
             type: "list",
             name: "action",
@@ -5100,7 +6861,7 @@ function collectDeprecationNoticeAndForward(event, onEvent) {
 // package.json with { type: 'json' }
 var package_default = {
   name: "@zapier/zapier-sdk-cli",
-  version: "0.67.6"};
+  version: "0.69.0"};
 
 // src/sdk.ts
 var warnedDeprecatedMethods = /* @__PURE__ */ new Set();
@@ -5140,6 +6901,7 @@ zapierSdk.definePlugin({
     mcpPlugin,
     getLoginConfigPathPlugin,
     initPlugin,
+    setupPlugin,
     bundleCodePlugin,
     feedbackPlugin,
     curlPlugin,
@@ -5178,6 +6940,7 @@ function createZapierCliSdk(options = {}) {
       mcpPlugin,
       getLoginConfigPathPlugin,
       initPlugin,
+      setupPlugin,
       bundleCodePlugin,
       feedbackPlugin,
       curlPlugin,