@zapier/zapier-sdk-cli 0.86.7 → 0.87.2

package/dist/experimental.cjs

@@ -31,6 +31,7 @@ var packageJsonLib = require('package-json');
 var semver = require('semver');
 var crossSpawn = require('cross-spawn');
 var wrapAnsi = require('wrap-ansi');
+var module$1 = require('module');
 var Table = require('cli-table3');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
@@ -1035,6 +1036,7 @@ var SENSITIVE_FLAGS = [
   "--credentials-client-id",
   "--credentials-base-url",
   "--callback-url",
+  "--answer",
   "--user",
   "--header",
   "-H",
@@ -1271,6 +1273,7 @@ var searchSelect = core.createPrompt(
 );
 
 // src/utils/auth/credentials-picker.ts
+var CREDENTIALS_PICKER_QUESTION = "Select credentials or add a new account:";
 function isSameCredentials(left, right) {
   return left.name === right.name && left.baseUrl === right.baseUrl;
 }
@@ -1376,7 +1379,7 @@ async function promptForCredentials({
   activeCredentials
 }) {
   return searchSelect({
-    message: "Select credentials or add a new account:",
+    message: CREDENTIALS_PICKER_QUESTION,
     source: (term) => buildCredentialsChoices({
       credentials,
       activeCredentials,
@@ -1439,14 +1442,15 @@ async function switchCredentials({
 async function chooseStoredLoginCredentialsAtBaseUrl({
   baseUrl,
   options,
-  resolvedCredentials
+  resolvedCredentials,
+  prompt = promptForCredentials
 }) {
   if (resolvedCredentials !== void 0 || authFlowOnlyOptions(options).length > 0) {
     return "none";
   }
   const storedCredentials = listStoredCredentials({ baseUrl });
   if (storedCredentials.length === 0) return "none";
-  const selection = await promptForCredentials({
+  const selection = await prompt({
     credentials: storedCredentials,
     activeCredentials: getActiveCredentials({ baseUrl })
   });
@@ -1460,7 +1464,8 @@ async function chooseStoredLoginCredentialsAtBaseUrl({
 }
 async function chooseStoredLoginCredentials({
   imports,
-  options
+  options,
+  prompt
 }) {
   const resolvedCredentials = await imports.resolveCredentials();
   const credentialsBaseUrl = await resolveCredentialsBaseUrl({
@@ -1470,7 +1475,8 @@ async function chooseStoredLoginCredentials({
   return chooseStoredLoginCredentialsAtBaseUrl({
     baseUrl: credentialsBaseUrl,
     options,
-    resolvedCredentials
+    resolvedCredentials,
+    prompt
   });
 }
 async function confirmNewCredentialsName(name) {
@@ -1841,6 +1847,7 @@ var PendingOauthTransactionSchema = zod.z.object({
   credentialName: zod.z.string().optional(),
   useApprovals: zod.z.boolean(),
   headless: zod.z.boolean().default(false),
+  preserveExistingCredentials: zod.z.boolean().default(false),
   transaction: OauthTransactionSchema
 });
 function savePendingOauthTransaction({
@@ -1850,7 +1857,8 @@ function savePendingOauthTransaction({
   credentialsBaseUrl,
   credentialName,
   useApprovals,
-  headless
+  headless,
+  preserveExistingCredentials = false
 }) {
   const pendingTransaction = {
     version: 1,
@@ -1858,6 +1866,7 @@ function savePendingOauthTransaction({
     expiresAt,
     useApprovals,
     headless,
+    preserveExistingCredentials,
     transaction,
     ...credentialsBaseUrl !== void 0 && { credentialsBaseUrl },
     ...credentialName !== void 0 && { credentialName }
@@ -1876,6 +1885,7 @@ function clearPendingOauthTransaction() {
 }
 
 // src/utils/auth/oauth-flow.ts
+var OAUTH_CALLBACK_QUESTION = "Paste the final OAuth callback URL:";
 var PENDING_OAUTH_RECOVERY_MESSAGE = "Start a new non-interactive login or signup flow to generate a fresh URL.";
 var LOGIN_OAUTH_COPY = {
   flowName: "Login",
@@ -1939,7 +1949,9 @@ async function startPendingOauthFlow({
   entryPoint,
   credentialName,
   useApprovals,
-  headless
+  headless,
+  preserveExistingCredentials = false,
+  silent = false
 }) {
   const copy = entryPoint === "signup" ? SIGNUP_OAUTH_COPY : LOGIN_OAUTH_COPY;
   const port = LOGIN_PORTS[0];
@@ -1956,8 +1968,10 @@ async function startPendingOauthFlow({
     credentialsBaseUrl: baseUrl,
     credentialName,
     useApprovals,
-    headless
+    headless,
+    preserveExistingCredentials
   });
+  if (silent) return pending;
   process.stderr.write(
     `Open this ${copy.urlLabel} in a browser to continue:
 `
@@ -1983,23 +1997,24 @@ async function startPendingOauthFlow({
   return pending;
 }
 function getPendingOauthFlow({
-  entryPoint
+  entryPoint,
+  recoveryMessage = PENDING_OAUTH_RECOVERY_MESSAGE
 }) {
   const pending = getPendingOauthTransaction();
   if (!pending) {
     throw new ZapierCliValidationError(
-      `No pending ${entryPoint} OAuth flow found. ${PENDING_OAUTH_RECOVERY_MESSAGE}`
+      `No pending ${entryPoint} OAuth flow found. ${recoveryMessage}`
     );
   }
   if (Date.now() > pending.expiresAt) {
     clearPendingOauthTransaction();
     throw new ZapierCliValidationError(
-      `Pending ${pending.entryPoint} OAuth flow has expired. ${PENDING_OAUTH_RECOVERY_MESSAGE}`
+      `Pending ${pending.entryPoint} OAuth flow has expired. ${recoveryMessage}`
     );
   }
   if (pending.entryPoint !== entryPoint) {
     throw new ZapierCliValidationError(
-      `Pending OAuth flow is for ${pending.entryPoint}, not ${entryPoint}. ${PENDING_OAUTH_RECOVERY_MESSAGE}`
+      `Pending OAuth flow is for ${pending.entryPoint}, not ${entryPoint}. ${recoveryMessage}`
     );
   }
   return pending;
@@ -2162,7 +2177,7 @@ async function readHeadlessCallbackUrl({
     process.once("SIGINT", handleCancellation);
     process.once("SIGTERM", handleCancellation);
     if (interactive) {
-      void rl.question("Paste the final OAuth callback URL: ", {
+      void rl.question(`${OAUTH_CALLBACK_QUESTION} `, {
         signal: abortController.signal
       }).then(settleResolve).catch((error) => {
         if (error instanceof Error && error.name === "AbortError") {
@@ -2649,7 +2664,7 @@ async function runOauthForEntryPoint({
           if (event.type === "callback_accepted") {
             emitSignupSuccess({
               imports,
-              isNonInteractive: false,
+              isNonInteractive: !interactive,
               isHeadless: headless === true
             });
           }
@@ -2731,7 +2746,9 @@ async function runAccountAuth({
   options,
   entryPoint,
   storedCredentialsMode = "choose",
-  preserveExistingCredentials = false
+  preserveExistingCredentials = false,
+  useBrowserCallback = false,
+  silent = false
 }) {
   if (options.callbackUrl !== void 0) {
     const { callbackUrl } = options;
@@ -2764,7 +2781,8 @@ async function runAccountAuth({
       imports,
       baseUrl: pending.credentialsBaseUrl,
       interactive: false,
-      entryPoint
+      entryPoint,
+      preserveExistingCredentials: pending.preserveExistingCredentials
     })) {
       return;
     }
@@ -2841,7 +2859,7 @@ async function runAccountAuth({
       );
     }
   }
-  if (entryPoint === "login" && !interactive && providedName === void 0) {
+  if (entryPoint === "login" && !interactive && providedName === void 0 && !preserveExistingCredentials) {
     const activeCredentials = getActiveCredentials({
       baseUrl: credentialsBaseUrl
     });
@@ -2858,7 +2876,7 @@ async function runAccountAuth({
   }
   const timeoutSeconds = parseTimeoutSeconds(options.timeout);
   const useApprovals = options.useApprovals === true;
-  if (!interactive) {
+  if (!interactive && (headless || !useBrowserCallback)) {
     await startPendingOauthFlow({
       entryPoint,
       timeoutMs: timeoutSeconds * 1e3,
@@ -2866,7 +2884,9 @@ async function runAccountAuth({
       baseUrl: credentialsBaseUrl,
       credentialName: providedName,
       useApprovals,
-      headless
+      headless,
+      preserveExistingCredentials,
+      silent
     });
     return;
   }
@@ -2887,7 +2907,7 @@ async function runAccountAuth({
     credentialName: providedName,
     interactive,
     useApprovals,
-    isNonInteractive: false,
+    isNonInteractive: !interactive,
     isHeadless: headless
   });
 }
@@ -4778,6 +4798,7 @@ function createProjectDir({
 var TEMPLATES_DIR = url.fileURLToPath(
   new URL("../templates", (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('experimental.cjs', document.baseURI).href)))
 );
+var SOURCE_CLI_PATH = (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('experimental.cjs', document.baseURI).href)).endsWith(".ts") ? url.fileURLToPath(new URL("./cli.ts", (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('experimental.cjs', document.baseURI).href)))) : void 0;
 
 // src/plugins/init/steps.ts
 var DEFAULT_TEMPLATE = "basic";
@@ -5488,84 +5509,6 @@ async function checkForUpdates({
     };
   }
 }
-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 ? `${chalk5__default.default.bold(label)}  ${chalk5__default.default.dim(detail)}` : chalk5__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 ? chalk5__default.default.bold.yellow(cell) : chalk5__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)}  ${chalk5__default.default.dim(`${elapsedSeconds}s`)}`);
-    return result;
-  } catch (error) {
-    clearInterval(animationTimer);
-    const elapsedSeconds = ((Date.now() - startedAt) / 1e3).toFixed(1);
-    loader.fail(`${formatPhase(phase)}  ${chalk5__default.default.dim(`${elapsedSeconds}s`)}`);
-    throw error;
-  }
-}
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -5851,7 +5794,7 @@ async function offerPackageUpdate({
 }) {
   const { currentVersion, dependency } = packageState;
   if (!currentVersion || !dependency.checkForUpdates) return;
-  const update = await runWithSetupLoader({
+  const update = await context.load({
     promise: context.checkForUpdates({
       packageName: dependency.name,
       currentVersion
@@ -5876,28 +5819,108 @@ async function offerPackageUpdate({
     })
   );
 }
-async function prepareDependencies(context) {
+function getPackageStates(context) {
   const declaredPackageNames = getDeclaredPackageNames(context.cwd);
   const requiredPackages = REQUIRED_PACKAGES.filter(
     ({ typescriptOnly }) => !typescriptOnly || context.projectLanguage === "typescript"
   );
-  const packages = requiredPackages.map((dependency) => ({
+  return requiredPackages.map((dependency) => ({
     dependency,
+    declared: declaredPackageNames.has(dependency.name),
     currentVersion: declaredPackageNames.has(dependency.name) ? getInstalledPackageVersion({
       cwd: context.cwd,
       packageName: dependency.name
     }) : void 0
   }));
+}
+async function prepareDependencies(context) {
+  const packages = getPackageStates(context);
   await offerMissingPackageInstall({
     context,
-    packages: packages.filter(
-      ({ dependency }) => !declaredPackageNames.has(dependency.name)
-    )
+    packages: packages.filter(({ declared }) => !declared)
   });
   for (const packageState of packages) {
     await offerPackageUpdate({ context, packageState });
   }
 }
+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 ? `${chalk5__default.default.bold(label)}  ${chalk5__default.default.dim(detail)}` : chalk5__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 ? chalk5__default.default.bold.yellow(cell) : chalk5__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)}  ${chalk5__default.default.dim(`${elapsedSeconds}s`)}`);
+    return result;
+  } catch (error) {
+    clearInterval(animationTimer);
+    const elapsedSeconds = ((Date.now() - startedAt) / 1e3).toFixed(1);
+    loader.fail(`${formatPhase(phase)}  ${chalk5__default.default.dim(`${elapsedSeconds}s`)}`);
+    throw error;
+  }
+}
 
 // src/plugins/setup/package-commands.ts
 function createLocalPackageCommand({
@@ -5936,7 +5959,10 @@ function formatPackageCommand({
   command,
   args
 }) {
-  return [command, ...args].join(" ");
+  return [command, ...args].map(quoteShellArgument).join(" ");
+}
+function quoteShellArgument(value) {
+  return /^[a-zA-Z0-9_@%+=:,./-]+$/.test(value) ? value : `'${value.replace(/'/g, `'"'"'`)}'`;
 }
 
 // src/plugins/setup/project.ts
@@ -6041,13 +6067,14 @@ async function runCommand({
   args = [],
   cwd,
   capture = true,
-  input
+  input,
+  load = runWithSetupLoader
 }) {
   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({
+      return await load({
         promise: execute,
         label: "Running command",
         detail: commandLabel
@@ -6131,7 +6158,7 @@ function detectProjectLanguage({
   );
   return hasTypeScript ? "typescript" : "javascript";
 }
-async function prepareProject(context) {
+async function initializeProject(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"));
@@ -6147,182 +6174,161 @@ async function prepareProject(context) {
       cwd: context.cwd
     });
   }
+}
+async function prepareProject(context) {
+  await initializeProject(context);
   await prepareDependencies(context);
 }
 
 // src/plugins/setup/context.ts
 function createWizardContext({
-  imports
+  imports,
+  agent = false
 }) {
-  return {
+  const context = {
     cwd: process.cwd(),
+    load: agent ? ({ promise }) => promise : runWithSetupLoader,
     imports,
     createAnswer: () => createCliAnswer({ mode: "closed-list" }),
     setupController: createSetupController(),
-    selectStoredLoginCredentials: () => chooseStoredLoginCredentials({ imports, options: {} }),
-    authenticateNewAccount: ({ entryPoint, headless }) => runAccountAuth({
+    selectStoredLoginCredentials: () => chooseStoredLoginCredentials({
+      imports,
+      options: {},
+      ...agent ? {
+        prompt: async (options) => {
+          const credentialChoices = buildCredentialsChoices(options);
+          const choices = credentialChoices.map(({ name, value }) => ({
+            label: name,
+            value: value.action === "create" ? "create" : `account:${value.credentials.name}`,
+            result: value
+          }));
+          const selected = await resolveSetupSelect({
+            answer: context.createAnswer(),
+            controller: context.setupController,
+            message: CREDENTIALS_PICKER_QUESTION,
+            choices
+          });
+          const selectedIndex = choices.findIndex(
+            ({ value }) => value === selected
+          );
+          return choices[selectedIndex].result;
+        }
+      } : {}
+    }),
+    authenticateNewAccount: ({ entryPoint, ...options }) => runAccountAuth({
       imports,
-      options: { headless },
+      options,
       entryPoint,
       storedCredentialsMode: "fresh",
-      preserveExistingCredentials: true
+      preserveExistingCredentials: true,
+      useBrowserCallback: agent && options.headless === false,
+      silent: agent && options.headless
     }),
     checkForUpdates,
     openUrl: async (url) => {
       await open__default.default(url);
     },
-    runCommand,
+    runCommand: agent ? (options) => runCommand({
+      ...options,
+      capture: true,
+      load: ({ promise, detail }) => {
+        console.log(detail);
+        return promise;
+      }
+    }) : runCommand,
     packageManager: detectPackageManager(process.cwd()).name,
     projectLanguage: "typescript"
   };
+  return context;
+}
+var SetupStepSchema = zod.z.enum([
+  "directory",
+  "project",
+  "install",
+  "sdk-update",
+  "cli-update",
+  "skill",
+  "account",
+  "account-flow",
+  "account-environment",
+  "authorize",
+  "confirm-account",
+  "connections",
+  "slack",
+  "slack-overwrite",
+  "slack-existing",
+  "slack-retry",
+  "handoff"
+]);
+var SetupSchema = zod.z.object({
+  agent: zod.z.boolean().optional().describe(
+    "For AI agents and callers without a terminal: print the next setup question and the exact command to run for each answer."
+  ),
+  step: SetupStepSchema.optional().describe(
+    "Setup operation to inspect or execute."
+  ),
+  nonInteractive: zod.z.boolean().optional().describe("Execute the named setup step without terminal prompts."),
+  answer: zod.z.string().optional().describe(
+    "User selection or input for a non-interactive setup step. Omitted confirmations use the terminal wizard's default."
+  ),
+  flow: zod.z.enum(["login", "signup"]).optional().describe(
+    "Account flow selected for the environment and OAuth callback steps."
+  ),
+  language: zod.z.enum(["javascript", "typescript"]).optional().describe(
+    "Project language for dependency installation and the Slack demo."
+  )
+}).describe(
+  "Set up the Zapier SDK in an existing or new project. Runs an interactive terminal wizard; AI agents should use --agent instead."
+);
+
+// package.json
+var package_default = {
+  version: "0.87.2"};
+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.`;
 }
-var SetupSchema = zod.z.object({}).describe("Set up the Zapier SDK in an existing or new project");
-function printAuthCommand({
+function printAgentPrompt({
   context,
-  flow,
-  headless
+  message
 }) {
-  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 confirmAuthentication(context) {
-  const { data: profile } = await runWithSetupLoader({
-    promise: context.imports.getProfile({}),
-    label: "Confirming Zapier account"
-  });
-  context.accountEmail = profile.email;
-  console.log(`Authenticated as ${profile.email}.`);
-}
-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"
-  });
-  const storedCredentialsSelection = await context.selectStoredLoginCredentials();
-  if (storedCredentialsSelection === "switch") {
-    await confirmAuthentication(context);
-    return;
-  }
-  if (storedCredentialsSelection === "none" && 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";
-  printAuthCommand({ context, flow, headless });
-  try {
-    if (storedCredentialsSelection === "create") {
-      await context.authenticateNewAccount({ entryPoint: flow, headless });
-    } else {
-      const runAuth = flow === "login" ? context.imports.login : context.imports.signup;
-      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;
-  }
-  await confirmAuthentication(context);
-}
-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(chalk5__default.default.bgYellow.black.bold(message));
-  console.log();
-  console.log(buildAgentPrompt({ context }));
+  console.log();
+  console.log(chalk5__default.default.bgYellow.black.bold(message));
+  console.log();
+  console.log(buildAgentPrompt({ context }));
 }
 async function openAgentHandoff(context) {
   const agent = await resolveSetupSelect({
@@ -6393,27 +6399,291 @@ async function openAgentHandoff(context) {
     message: "If it didn't load correctly, paste this prompt into your agent:"
   });
 }
+
+// src/plugins/setup/agent-output.ts
+var REQUIRED_STEPS = [
+  "directory",
+  "install"
+];
+function formatSetupCommand({
+  context,
+  target,
+  answer
+}) {
+  const args = [
+    "setup",
+    "--step",
+    target.step,
+    "--non-interactive",
+    ...target.flow ? ["--flow", target.flow] : [],
+    "--language",
+    context.projectLanguage,
+    ...answer !== void 0 ? ["--answer", answer] : []
+  ];
+  return formatPackageCommand(
+    SOURCE_CLI_PATH ? {
+      command: process.execPath,
+      args: [
+        "--import",
+        module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('experimental.cjs', document.baseURI).href))).resolve("tsx"),
+        "--conditions",
+        "source",
+        SOURCE_CLI_PATH,
+        ...args
+      ]
+    } : createPackageRunnerCommand({
+      packageManager: context.packageManager,
+      packageName: `@zapier/zapier-sdk-cli@${package_default.version}`,
+      args
+    })
+  );
+}
+function printAgentStep({
+  context,
+  target,
+  question
+}) {
+  console.log(
+    `Step: ${target.step}
+Working directory: ${context.cwd}
+Detected package manager: ${context.packageManager}
+Project language: ${context.projectLanguage}`
+  );
+  if (!question) {
+    console.log(
+      `Run this exact command:
+  ${formatSetupCommand({ context, target })}`
+    );
+  } else {
+    if (target.step === "authorize" && context.authorizationUrl)
+      console.log(
+        `Give the user this URL to open in a browser where they can sign in to Zapier:
+  ${context.authorizationUrl}
+After they approve, the browser opens a localhost page that may fail to load. That is expected: ask them to copy the full address from the browser's address bar. Pass that address only to the command below; do not save it or repeat it elsewhere.`
+      );
+    console.log(`Ask the user this question verbatim: "${question.message}"`);
+    if (question.type === "select") {
+      for (const { value, label } of question.choices)
+        console.log(`${JSON.stringify(value)}: ${label}`);
+      for (const { value } of question.choices) {
+        const decision = value === "true" ? "agrees" : value === "false" ? "declines" : `chooses ${JSON.stringify(value)}`;
+        if (value === "false" && REQUIRED_STEPS.includes(target.step))
+          console.log("If the user declines, stop setup.");
+        else
+          console.log(
+            `If the user ${decision}, run this exact command:
+  ${formatSetupCommand({ context, target, answer: value })}`
+          );
+      }
+    } else {
+      console.log(
+        `Run this exact command with their answer as one shell-quoted argument (an empty answer is ''):
+  ${formatSetupCommand({ context, target, answer: "<answer>" })}`
+      );
+    }
+    if (target.step === "account-environment")
+      console.log(
+        `The local command opens a browser and waits up to ${LOGIN_TIMEOUT_MILLISECONDS / 1e3} seconds for authorization, using the terminal login flow. Keep the process running until it completes and allow extra time for credential creation. If the browser does not open, use its printed fallback URL or choose headless instead.`
+      );
+    console.log(
+      "Use your tool for asking the user questions if you have one. Do not answer on the user's behalf."
+    );
+  }
+  console.log(
+    "On success, follow the next step's guidance printed by that operation. On failure, stop and report the error; do not proceed or retry automatically. Ignore CLI update notices; setup offers package updates as their own steps."
+  );
+}
+function printAgentCompletion({
+  context,
+  cancelled = false
+}) {
+  console.log(
+    cancelled ? "Setup cancelled." : `Setup walkthrough finished. Report which operations succeeded, failed, or were skipped based on their command results.
+Learn more: https://docs.zapier.com/sdk
+
+Continue in this agent. Do not open another agent or ask the user to choose one.
+${buildAgentPrompt({ context })}`
+  );
+}
+
+// src/plugins/setup/authentication.ts
+function printAuthCommand({
+  context,
+  flow,
+  headless = false
+}) {
+  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 confirmAuthentication(context) {
+  const { data: profile } = await context.load({
+    promise: context.imports.getProfile({}),
+    label: "Confirming Zapier account"
+  });
+  context.accountEmail = profile.email;
+  console.log(`Authenticated as ${profile.email}.`);
+}
+function selectAccountFlow(context) {
+  return 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" }
+    ]
+  });
+}
+function selectAuthenticationEnvironment(context) {
+  return resolveSetupSelect({
+    answer: context.createAnswer(),
+    controller: context.setupController,
+    message: "Environment:",
+    choices: [
+      { label: "Local machine with a browser", value: "local" },
+      { label: "Remote or headless", value: "headless" }
+    ]
+  });
+}
+async function selectAccount(context) {
+  const activeProfile = await context.load({
+    promise: context.imports.getProfile({}).then(({ data }) => data).catch((error) => {
+      if (zapierSdk.isZapierAuthenticationError(error)) return void 0;
+      throw error;
+    }),
+    label: "Checking Zapier authentication"
+  });
+  const storedCredentialsSelection = await context.selectStoredLoginCredentials();
+  if (storedCredentialsSelection === "none" && 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 "continue";
+    }
+    printAuthCommand({ context, flow: "logout" });
+    await context.imports.logout({});
+  }
+  return storedCredentialsSelection;
+}
+async function authenticate(context) {
+  const next = await runAuthenticationStep({ context, options: {} });
+  if (next.step === "confirm-account") await confirmAuthentication(context);
+}
+async function runAuthenticationStep({
+  context,
+  options
+}) {
+  const { step } = options;
+  let newAccount = step === "account-environment";
+  if (!step || step === "account") {
+    const selection = await selectAccount(context);
+    if (selection === "switch") return { step: "confirm-account" };
+    if (selection === "continue")
+      return { step: step ? "confirm-account" : "connections" };
+    if (step) return { step: "account-flow" };
+    newAccount = selection === "create";
+  }
+  if (step === "confirm-account") {
+    await confirmAuthentication(context);
+    return { step: "connections" };
+  }
+  const flow = !step || step === "account-flow" ? await selectAccountFlow(context) : options.flow;
+  if (step === "account-flow")
+    return {
+      step: "account-environment",
+      flow
+    };
+  if (!flow)
+    throw new ZapierCliValidationError(
+      "This setup step requires --flow login or --flow signup."
+    );
+  let headless = true;
+  let callbackUrl;
+  let recoveryMessage;
+  if (step === "authorize") {
+    recoveryMessage = `Generate a fresh authorization URL with \`${formatSetupCommand(
+      {
+        context,
+        target: { step: "account-environment", flow },
+        answer: "headless"
+      }
+    )}\`.`;
+    const pending = getPendingOauthFlow({ entryPoint: flow, recoveryMessage });
+    context.authorizationUrl = pending.transaction.browserAuthUrl;
+    callbackUrl = await resolveSetupInput({
+      answer: context.createAnswer(),
+      controller: context.setupController,
+      message: OAUTH_CALLBACK_QUESTION
+    });
+  } else {
+    headless = await selectAuthenticationEnvironment(context) === "headless";
+    if (!step) printAuthCommand({ context, flow, headless });
+  }
+  const authOptions = {
+    headless,
+    ...step ? { nonInteractive: true } : {},
+    ...callbackUrl !== void 0 ? { callbackUrl } : {}
+  };
+  try {
+    if (newAccount) {
+      await context.authenticateNewAccount({
+        entryPoint: flow,
+        ...authOptions
+      });
+    } else {
+      await context.imports[flow](authOptions);
+    }
+  } catch (error) {
+    if (recoveryMessage) console.error(recoveryMessage);
+    if (isCredentialWriteError(error)) {
+      console.error(
+        "Authentication could not write credentials. A permissions or sandbox restriction may be blocking disk access."
+      );
+    }
+    throw error;
+  }
+  return step === "account-environment" && headless ? { step: "authorize", flow } : { step: "confirm-account" };
+}
 var CONNECTIONS_URL = "https://zapier.com/app/assets/connections";
 var CONNECTION_DISPLAY_LIMIT = 10;
-async function ensureConnectionsAvailable(context) {
-  const page = await runWithSetupLoader({
+async function showActiveConnections(context) {
+  const page = await context.load({
     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."
-    );
-  }
+  if (page.data.length === 0) return false;
   const table = new Table__default.default({
     head: ["App", "Connection"],
-    style: { compact: true }
+    style: {
+      compact: true,
+      ...process.stdout.isTTY ? {} : { head: [], border: [] }
+    }
   });
   table.push(
     ...page.data.map((connection) => [
@@ -6425,11 +6695,22 @@ async function ensureConnectionsAvailable(context) {
     `Active Zapier connections (showing up to ${CONNECTION_DISPLAY_LIMIT}):`
   );
   console.log(table.toString());
+  return true;
+}
+async function ensureConnectionsAvailable(context) {
+  if (await showActiveConnections(context)) return;
+  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."
+  );
 }
 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";
+var SLACK_RETRY_QUESTION = "Slack email for one retry after the failed test:";
 function getSlackTestPath(context) {
   const extension = context.projectLanguage === "typescript" ? "ts" : "mjs";
   return path.join("src", "sdk-demo", `zapier-slack-test.${extension}`);
@@ -6439,7 +6720,7 @@ function getSlackTestTemplatePath(context) {
   return path.join(TEMPLATES_DIR, "setup", `zapier-slack-test.${extension}`);
 }
 async function findSlackConnection(context) {
-  const page = await runWithSetupLoader({
+  const page = await context.load({
     promise: context.imports.listConnections({
       owner: "me",
       app: SLACK_SLUG,
@@ -6460,17 +6741,22 @@ function renderSlackTest({
 }) {
   return fs.readFileSync(getSlackTestTemplatePath(context), "utf8").replace(APP_PLACEHOLDER, () => toTemplateString(app)).replace(CONNECTION_PLACEHOLDER, () => toTemplateString(connection)).replace(EMAIL_PLACEHOLDER, () => toTemplateString(email));
 }
-function writeSlackTest({
+async function createAndRunSlackTest({
   context,
-  app,
   connection,
-  email
+  email,
+  overwrite = true
 }) {
   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 }));
+  fs.writeFileSync(
+    path2,
+    renderSlackTest({ context, app: SLACK_SLUG, connection, email }),
+    { flag: overwrite ? "w" : "wx" }
+  );
   console.log(`Created ${slackTestPath}.`);
+  return trySlackTest(context);
 }
 async function executeSlackTest(context) {
   const slackTestPath = getSlackTestPath(context);
@@ -6498,75 +6784,76 @@ async function executeSlackTest(context) {
 async function trySlackTest(context) {
   try {
     await executeSlackTest(context);
+    (context.outcomes ?? (context.outcomes = {})).slack = "succeeded";
     return true;
   } catch (error) {
+    (context.outcomes ?? (context.outcomes = {})).slack = "failed";
     const message = error instanceof Error ? error.message : String(error);
     console.warn(`Slack demo failed: ${message}. Setup will continue.`);
     return false;
   }
 }
-async function offerSlackTest(context) {
+async function runSlackStep({
+  context,
+  step,
+  connection
+}) {
   if (!context.accountEmail) {
     console.log("No account email found; skipping the Slack demo.");
-    return;
+    return "handoff";
   }
-  const slackConnection = await findSlackConnection(context);
-  if (!slackConnection) {
+  if (!connection) {
     console.log("No active Slack connection found; skipping the Slack demo.");
-    return;
+    return "handoff";
   }
-  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({
+  if (step === "slack-retry") {
+    const email = await resolveSetupInput({
       answer: context.createAnswer(),
       controller: context.setupController,
-      message: `${slackTestPath} already exists. Is it okay to overwrite it?`,
-      defaultValue: false
+      message: SLACK_RETRY_QUESTION
     });
-    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 (email)
+      await createAndRunSlackTest({
+        context,
+        connection: connection.id,
+        email
       });
-      if (shouldRunExisting) await trySlackTest(context);
-      return;
-    }
+    else console.log("Skipping the Slack test.");
+    return "handoff";
   }
-  let email = context.accountEmail;
-  writeSlackTest({
-    context,
-    app: SLACK_SLUG,
-    connection: slackConnection.id,
-    email
-  });
-  if (await trySlackTest(context)) return;
-  email = await resolveSetupInput({
+  const slackTestPath = getSlackTestPath(context);
+  const shouldRun = await resolveSetupConfirm({
     answer: context.createAnswer(),
     controller: context.setupController,
-    message: "Slack email for one retry after the failed test:"
+    message: step === "slack" ? `Run the Slack self-DM test using ${context.accountEmail}?` : step === "slack-overwrite" ? `${slackTestPath} already exists. Is it okay to overwrite it?` : `Run the existing ${slackTestPath}?`,
+    defaultValue: step === "slack"
   });
-  if (!email) {
-    console.log("Skipping the Slack test.");
-    return;
+  if (!shouldRun) {
+    if (step === "slack-overwrite") {
+      console.log("Keeping the existing Slack test file.");
+      return "slack-existing";
+    }
+    return "handoff";
+  }
+  if (step === "slack" && fs.existsSync(path.join(context.cwd, slackTestPath)))
+    return "slack-overwrite";
+  if (step === "slack-existing") {
+    await trySlackTest(context);
+    return "handoff";
   }
-  writeSlackTest({
+  const succeeded = await createAndRunSlackTest({
     context,
-    app: SLACK_SLUG,
-    connection: slackConnection.id,
-    email
+    connection: connection.id,
+    email: context.accountEmail,
+    overwrite: step === "slack-overwrite"
   });
-  await trySlackTest(context);
+  return succeeded ? "handoff" : "slack-retry";
+}
+async function offerSlackTest(context) {
+  const connection = context.accountEmail ? await findSlackConnection(context) : void 0;
+  let step = "slack";
+  while (step !== "handoff")
+    step = await runSlackStep({ context, step, connection });
 }
 
 // src/plugins/setup/skill.ts
@@ -6592,7 +6879,9 @@ async function installOptionalSkill(context) {
       cwd: context.cwd,
       capture: true
     });
+    (context.outcomes ?? (context.outcomes = {})).skill = "succeeded";
   } catch {
+    (context.outcomes ?? (context.outcomes = {})).skill = "failed";
     console.warn(
       `Could not install the optional Zapier SDK skill. To install it manually, run: ${formatPackageCommand(command)}`
     );
@@ -6649,6 +6938,177 @@ async function runWizard(context) {
   console.log(chalk5__default.default.bgCyan.black.bold(" Next steps "));
   await openAgentHandoff(context);
 }
+var UNPROMPTED_STEPS = [
+  "project",
+  "confirm-account",
+  "connections"
+];
+var ZapierSetupQuestionSignal = class extends zapierSdk.ZapierSignal {
+  constructor(question) {
+    super(question.message);
+    this.question = question;
+    this.name = "ZapierSetupQuestionSignal";
+    this.code = "ZAPIER_SETUP_QUESTION";
+  }
+};
+function isZapierSetupQuestionSignal(error) {
+  return zapierSdk.isZapierSignal(error) && error.code === "ZAPIER_SETUP_QUESTION";
+}
+function createSetupAnswer({
+  answer,
+  execute
+}) {
+  let answered = false;
+  return async ({ result: { question } }) => {
+    if (question.type === "collection")
+      throw new ZapierCliValidationError(
+        "Setup expects a selection or text input."
+      );
+    if (!execute) throw new ZapierSetupQuestionSignal(question);
+    if (answered)
+      throw new ZapierCliValidationError(
+        "Each setup step can answer only one question. Inspect the next question with --agent and run it in a separate command."
+      );
+    answered = true;
+    const confirmation = question.type === "select" && question.choices.some(({ value }) => value === "true") && question.choices.some(({ value }) => value === "false");
+    if (answer === void 0 && !confirmation)
+      throw new ZapierCliValidationError(
+        "This setup step requires --answer. Inspect it with --agent and pass the user's selection or input."
+      );
+    if (question.type === "input")
+      return { type: "custom", value: answer?.trim() ?? "" };
+    const selected = answer?.trim() ?? question.choices[0].value;
+    if (!question.choices.some(({ value }) => value === selected))
+      throw new ZapierCliValidationError(
+        `Answer must be one of: ${question.choices.map(({ value }) => value).join(", ")}.`
+      );
+    return { type: "choose", value: selected };
+  };
+}
+async function runSetupStep({
+  context,
+  target
+}) {
+  switch (target.step) {
+    case "directory":
+      await chooseDirectory(context);
+      return { step: "project" };
+    case "project":
+      await ensureSupportedNode(context);
+      await initializeProject(context);
+      return { step: "install" };
+    case "install":
+      await offerMissingPackageInstall({
+        context,
+        packages: getPackageStates(context).filter(({ declared }) => !declared)
+      });
+      return { step: "sdk-update" };
+    case "sdk-update":
+    case "cli-update": {
+      const name = target.step === "sdk-update" ? "@zapier/zapier-sdk" : "@zapier/zapier-sdk-cli";
+      const packageState = getPackageStates(context).find(
+        ({ dependency }) => dependency.name === name
+      );
+      if (packageState) await offerPackageUpdate({ context, packageState });
+      return { step: target.step === "sdk-update" ? "cli-update" : "skill" };
+    }
+    case "skill":
+      await installOptionalSkill(context);
+      return { step: "account" };
+    case "account":
+    case "account-flow":
+    case "account-environment":
+    case "authorize":
+    case "confirm-account":
+      return runAuthenticationStep({ context, options: target });
+    case "connections":
+      if (!await showActiveConnections(context)) {
+        console.log(
+          `No active connections found. Ask the user to connect or reconnect an app at ${CONNECTIONS_URL}. After they confirm, run this exact command:
+  ${formatSetupCommand({ context, target })}
+Success means it prints the active connections table.`
+        );
+        throw new ZapierCliExitError(
+          "Setup stopped until an app connection is active."
+        );
+      }
+      console.log(
+        "Show the user every app and connection title in the table above before continuing. Do not just report that connections were found."
+      );
+      return { step: "slack" };
+    case "slack":
+    case "slack-overwrite":
+    case "slack-existing":
+    case "slack-retry": {
+      const { data: profile } = await context.imports.getProfile({});
+      context.accountEmail = profile.email;
+      return {
+        step: await runSlackStep({
+          context,
+          step: target.step,
+          connection: await findSlackConnection(context)
+        })
+      };
+    }
+  }
+}
+async function runAgentSetup({
+  context,
+  options
+}) {
+  if (options.agent && options.nonInteractive)
+    throw new ZapierCliValidationError(
+      "Use --agent to inspect a step or --non-interactive to execute it, not both."
+    );
+  if (!options.agent && !options.nonInteractive)
+    throw new ZapierCliValidationError(
+      options.step ? "Use --agent to inspect the named step or --non-interactive to execute it." : "--answer, --flow, and --language require a setup step."
+    );
+  if (options.nonInteractive && !options.step)
+    throw new ZapierCliValidationError(
+      "--non-interactive requires --step. Start with setup --agent and follow its printed commands."
+    );
+  if (options.answer !== void 0 && !options.nonInteractive)
+    throw new ZapierCliValidationError("--answer requires --non-interactive.");
+  context.cwd = fs.realpathSync(context.cwd);
+  context.projectLanguage = options.language ?? detectProjectLanguage({
+    cwd: context.cwd,
+    hasExistingProject: fs.existsSync(path.join(context.cwd, "package.json"))
+  });
+  let target = {
+    step: options.step ?? "directory",
+    flow: options.flow
+  };
+  let execute = options.nonInteractive === true;
+  while (true) {
+    const { step, flow } = target;
+    if (step === "handoff") return printAgentCompletion({ context });
+    if (!execute && UNPROMPTED_STEPS.includes(step))
+      return printAgentStep({ context, target });
+    const answer = createSetupAnswer({
+      answer: execute ? options.answer : void 0,
+      execute
+    });
+    context.createAnswer = () => answer;
+    try {
+      const next = await runSetupStep({ context, target: { step, flow } });
+      if (options.language) context.projectLanguage = options.language;
+      if (execute)
+        for (const [operation, outcome] of Object.entries(
+          context.outcomes ?? {}
+        ))
+          console.log(`${operation}: ${outcome}`);
+      target = next;
+      execute = false;
+    } catch (error) {
+      if (isZapierSetupQuestionSignal(error))
+        return printAgentStep({ context, target, question: error.question });
+      if (error instanceof ZapierCliUserCancellationError)
+        return printAgentCompletion({ context, cancelled: true });
+      throw error;
+    }
+  }
+}
 
 // src/plugins/setup/index.ts
 var getProfileRef = zapierSdk.declareMethod({ id: "getProfile" });
@@ -6673,10 +7133,19 @@ var setupPlugin = zapierSdk.defineMethod({
   supportsJsonOutput: false,
   inputSchema: SetupSchema,
   output: "raw",
-  run: async ({ imports }) => {
+  run: async ({ imports, input }) => {
+    if (input.agent || input.nonInteractive || [input.step, input.answer, input.flow, input.language].some(
+      (value) => value !== void 0
+    )) {
+      await runAgentSetup({
+        context: createWizardContext({ imports, agent: true }),
+        options: input
+      });
+      return;
+    }
     if (process.stdin.isTTY !== true || process.stdout.isTTY !== true) {
-      throw new ZapierCliExitError(
-        "`zapier-sdk setup` requires an interactive terminal."
+      throw new ZapierCliValidationError(
+        "`zapier-sdk setup` requires an interactive terminal. AI agents and other callers without a terminal should run `zapier-sdk setup --agent` and follow its printed steps."
       );
     }
     await runWizard(createWizardContext({ imports }));
@@ -7171,59 +7640,6 @@ var watchTriggerInboxCliPlugin = zapierSdk.defineMethod({
     return doWatch();
   }
 });
-var createWorkflowRef = experimental.declareMethod({ id: "createWorkflow" });
-function createPublicInputSchema(schema) {
-  const publicSchema = zod.z.object(
-    Object.fromEntries(
-      Object.entries(schema.shape).filter(
-        ([name]) => !experimental.INTERNAL_CREATE_WORKFLOW_FIELDS.includes(
-          name
-        )
-      )
-    )
-  );
-  return schema.description === void 0 ? publicSchema : publicSchema.describe(schema.description);
-}
-var CreateWorkflowCliOptionsSchema = createPublicInputSchema(
-  experimental.CreateWorkflowOptionsSchema
-);
-var createWorkflowCliPlugin = experimental.defineMethod({
-  namespace: "cli",
-  name: "createWorkflow",
-  imports: [createWorkflowRef],
-  type: "create",
-  itemType: "Workflow",
-  categories: ["code-workflow"],
-  stability: "experimental",
-  inputSchema: CreateWorkflowCliOptionsSchema,
-  outputSchema: experimental.CreateWorkflowResponseSchema,
-  skipOutputValidation: true,
-  output: "raw",
-  run: ({ imports, input }) => imports.createWorkflow({
-    ...input,
-    creationHarness: experimental.getAgent(),
-    creationAccessMethod: "sdk_cli"
-  })
-});
-var importWorkflowRef = experimental.declareMethod({ id: "importWorkflow" });
-var importWorkflowCliPlugin = experimental.defineMethod({
-  namespace: "cli",
-  name: "importWorkflow",
-  imports: [importWorkflowRef],
-  type: "create",
-  itemType: "Workflow",
-  categories: ["code-workflow"],
-  stability: "experimental",
-  inputSchema: createPublicInputSchema(experimental.ImportWorkflowOptionsSchema),
-  outputSchema: experimental.ImportWorkflowResponseSchema,
-  skipOutputValidation: true,
-  output: "raw",
-  run: ({ imports, input }) => imports.importWorkflow({
-    ...input,
-    creationHarness: experimental.getAgent(),
-    creationAccessMethod: "sdk_cli"
-  })
-});
 function warningBlock({
   banner,
   message,
@@ -7249,9 +7665,9 @@ function collectDeprecationNoticeAndForward(event, onEvent) {
 }
 
 // package.json with { type: 'json' }
-var package_default = {
+var package_default2 = {
   name: "@zapier/zapier-sdk-cli",
-  version: "0.86.7"};
+  version: "0.87.2"};
 
 // src/sdk.ts
 var warnedDeprecatedMethods = /* @__PURE__ */ new Set();
@@ -7320,7 +7736,7 @@ function createZapierCliSdk(options = {}) {
   const stackOptions = {
     ...sdkOptions,
     eventEmission: { ...sdkOptions.eventEmission, callContext: "cli" },
-    callerPackage: { name: package_default.name, version: package_default.version },
+    callerPackage: { name: package_default2.name, version: package_default2.version },
     // Collected for the boxed stderr warning rendered in the exit path. The
     // box is additive: the SDK's own inline warn still fires, so the notice
     // cannot be hidden by any rendering path.
@@ -7332,14 +7748,10 @@ function createZapierCliSdk(options = {}) {
     exports: [
       experimental.omitExports(experimental.zapierExperimentalSdkPlugin, [
         "drainTriggerInbox",
-        "watchTriggerInbox",
-        "createWorkflow",
-        "importWorkflow"
+        "watchTriggerInbox"
       ]),
       drainTriggerInboxCliPlugin,
       watchTriggerInboxCliPlugin,
-      createWorkflowCliPlugin,
-      importWorkflowCliPlugin,
       loginPlugin,
       signupPlugin,
       logoutPlugin,