@zapier/zapier-sdk-cli 0.52.10 → 0.53.0

package/dist/cli.cjs

@@ -18,8 +18,9 @@ var crypto = require('crypto');
 var path = require('path');
 var lockfile = require('proper-lockfile');
 var os = require('os');
-var open = require('open');
 var express = require('express');
+var promises$1 = require('readline/promises');
+var open = require('open');
 var pkceChallenge = require('pkce-challenge');
 var zapierSdkMcp = require('@zapier/zapier-sdk-mcp');
 var esbuild = require('esbuild');
@@ -66,8 +67,8 @@ 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 open__default = /*#__PURE__*/_interopDefault(open);
 var express__default = /*#__PURE__*/_interopDefault(express);
+var open__default = /*#__PURE__*/_interopDefault(open);
 var pkceChallenge__default = /*#__PURE__*/_interopDefault(pkceChallenge);
 var ts__namespace = /*#__PURE__*/_interopNamespace(ts);
 var isInstalledGlobally__default = /*#__PURE__*/_interopDefault(isInstalledGlobally);
@@ -200,7 +201,7 @@ var SchemaParameterResolver = class {
   debugLog(message) {
     if (this.debug) {
       this.stopSpinner();
-      console.log(chalk__default.default.gray(`[Zapier CLI] ${message}`));
+      console.error(chalk__default.default.gray(`[Zapier CLI] ${message}`));
     }
   }
   startSpinner() {
@@ -1572,7 +1573,7 @@ var SHARED_COMMAND_CLI_OPTIONS = [
 
 // package.json
 var package_default = {
-  version: "0.52.10"};
+  version: "0.53.0"};
 
 // src/telemetry/builders.ts
 function createCliBaseEvent(context = {}) {
@@ -1626,12 +1627,6 @@ function buildCliCommandExecutedEvent({
     subprocess_count: data.subprocess_count ?? null
   };
 }
-function getFormatMetadata(schema) {
-  return schema?._zod?.def?.formatMeta;
-}
-function getOutputSchema(schema) {
-  return schema?._zod?.def?.outputSchema;
-}
 function formatJsonOutput(data) {
   if (data === void 0) {
     return;
@@ -1640,21 +1635,26 @@ function formatJsonOutput(data) {
     util__default.default.inspect(data, { colors: true, depth: null, breakLength: 80 })
   );
 }
-async function formatItemsFromSchema(functionInfo, items, startingNumber = 0, options) {
-  const outputSchema = functionInfo.outputSchema || getOutputSchema(functionInfo.inputSchema);
-  if (!outputSchema) {
-    formatItemsGeneric(items, startingNumber);
-    return;
-  }
-  const formatMeta = getFormatMetadata(outputSchema);
-  if (!formatMeta) {
-    formatItemsGeneric(items, startingNumber);
+async function formatItemsFromSchema(_functionInfo, items, startingNumber = 0, options) {
+  if (options?.formatter) {
+    let context;
+    if (options.formatter.fetch && options.sdk && options.params) {
+      for (const item of items) {
+        context = await options.formatter.fetch(
+          options.sdk,
+          options.params,
+          item,
+          context
+        );
+      }
+    }
+    items.forEach((item, index) => {
+      const formatted = options.formatter.format(item, context);
+      formatSingleItem(formatted, startingNumber + index);
+    });
     return;
   }
-  items.forEach((item, index) => {
-    const formatted = formatMeta.format(item);
-    formatSingleItem(formatted, startingNumber + index);
-  });
+  formatItemsGeneric(items, startingNumber);
 }
 function formatSingleItem(formatted, itemNumber) {
   let titleLine = `${chalk__default.default.gray(`${itemNumber + 1}.`)} ${chalk__default.default.cyan(formatted.title)}`;
@@ -1814,7 +1814,7 @@ function createJsonRenderer() {
         errors: []
       });
     },
-    renderCollectedList(items, _options) {
+    async renderCollectedList(items, _options) {
       outputJson({ data: items, errors: [] });
     },
     renderItem(value, options) {
@@ -1846,27 +1846,32 @@ function getListTitle(functionInfo) {
   if (functionInfo.itemType) return `Available ${functionInfo.itemType} items`;
   return "items";
 }
-function renderItemsForDisplay(items, functionInfo, startingNumber = 0) {
-  if (functionInfo?.inputSchema) {
-    formatItemsFromSchema(
-      functionInfo,
-      items,
-      startingNumber
-    );
-  } else {
-    items.forEach((item, index) => {
-      const obj = item;
-      const name = obj?.name || obj?.key || obj?.id || "Item";
-      console.log(
-        `${chalk__default.default.gray(`${startingNumber + index + 1}.`)} ${chalk__default.default.cyan(String(name))}`
+function createInteractiveRenderer(context = {}) {
+  async function renderItemsForDisplay(items, functionInfo, startingNumber = 0) {
+    if (functionInfo?.inputSchema) {
+      await formatItemsFromSchema(
+        functionInfo,
+        items,
+        startingNumber,
+        {
+          formatter: functionInfo.formatter,
+          sdk: context.sdk,
+          params: context.params
+        }
       );
-      if (obj?.description)
-        console.log(`   ${chalk__default.default.dim(String(obj.description))}`);
-      console.log();
-    });
+    } else {
+      items.forEach((item, index) => {
+        const obj = item;
+        const name = obj?.name || obj?.key || obj?.id || "Item";
+        console.log(
+          `${chalk__default.default.gray(`${startingNumber + index + 1}.`)} ${chalk__default.default.cyan(String(name))}`
+        );
+        if (obj?.description)
+          console.log(`   ${chalk__default.default.dim(String(obj.description))}`);
+        console.log();
+      });
+    }
   }
-}
-function createInteractiveRenderer() {
   return {
     async renderPaginatedList(source, functionInfo) {
       const itemName = getItemName(functionInfo);
@@ -1876,7 +1881,7 @@ function createInteractiveRenderer() {
           console.log(chalk__default.default.yellow(`No ${itemName} found.`));
           return;
         }
-        renderItemsForDisplay(items, functionInfo, 0);
+        await renderItemsForDisplay(items, functionInfo, 0);
         console.log(chalk__default.default.green(`
 \u2705 Showing ${items.length} ${itemName}`));
         return;
@@ -1898,7 +1903,7 @@ function createInteractiveRenderer() {
           console.log(chalk__default.default.blue(`\u{1F4CB} ${getListTitle(functionInfo)}
 `));
         }
-        renderItemsForDisplay(items, functionInfo, totalShown);
+        await renderItemsForDisplay(items, functionInfo, totalShown);
         totalShown += items.length;
         console.log(
           chalk__default.default.green(
@@ -1923,7 +1928,7 @@ function createInteractiveRenderer() {
       console.log(chalk__default.default.gray(`
 \u{1F4C4} Finished browsing ${itemName}`));
     },
-    renderCollectedList(items, { maxItems, userSpecifiedMaxItems, functionInfo } = {}) {
+    async renderCollectedList(items, { maxItems, userSpecifiedMaxItems, functionInfo } = {}) {
       if (!Array.isArray(items)) {
         formatJsonOutput(items);
         return;
@@ -1936,7 +1941,7 @@ function createInteractiveRenderer() {
       console.log(chalk__default.default.green(`
 \u2705 Found ${items.length} ${itemName}:
 `));
-      renderItemsForDisplay(items, functionInfo);
+      await renderItemsForDisplay(items, functionInfo);
       if (userSpecifiedMaxItems && maxItems) {
         console.log(
           chalk__default.default.gray(
@@ -2399,11 +2404,11 @@ function createCommandConfig(cliCommandName, functionInfo, sdk) {
     const startTime = Date.now();
     let success = true;
     let errorMessage = null;
-    let resolvedParams = {};
+    const resolvedParams = {};
     const commandObj = args[args.length - 1];
     const options = commandObj.opts();
     const interactiveMode = !options.json;
-    const renderer = interactiveMode ? createInteractiveRenderer() : createJsonRenderer();
+    const renderer = interactiveMode ? createInteractiveRenderer({ sdk, params: resolvedParams }) : createJsonRenderer();
     try {
       emitDeprecationWarning({
         cliCommandName,
@@ -2436,7 +2441,7 @@ function createCommandConfig(cliCommandName, functionInfo, sdk) {
       }
       if (schema && !usesInputParameters) {
         const resolver = new SchemaParameterResolver();
-        resolvedParams = await resolver.resolveParameters(
+        const resolved = await resolver.resolveParameters(
           schema,
           rawParams,
           sdk,
@@ -2446,8 +2451,9 @@ function createCommandConfig(cliCommandName, functionInfo, sdk) {
             debug: !!options.debug || process.env.DEBUG === "true" || process.argv.includes("--debug")
           }
         );
+        Object.assign(resolvedParams, resolved);
       } else {
-        resolvedParams = rawParams;
+        Object.assign(resolvedParams, rawParams);
       }
       const confirm = functionInfo.confirm;
       let confirmMessageAfter;
@@ -2476,7 +2482,7 @@ function createCommandConfig(cliCommandName, functionInfo, sdk) {
             sdkResult,
             maxItems
           });
-          renderer.renderCollectedList(allItems, {
+          await renderer.renderCollectedList(allItems, {
             maxItems,
             userSpecifiedMaxItems: hasUserSpecifiedMaxItems,
             functionInfo
@@ -2510,7 +2516,7 @@ function createCommandConfig(cliCommandName, functionInfo, sdk) {
           if (normalizedResult.kind === "response") {
             await renderer.renderResponse(normalizedResult.value);
           } else if (normalizedResult.kind === "list") {
-            renderer.renderCollectedList(normalizedResult.data, {
+            await renderer.renderCollectedList(normalizedResult.data, {
               maxItems: resolvedParams.maxItems,
               userSpecifiedMaxItems: hasUserSpecifiedMaxItems,
               functionInfo
@@ -2566,7 +2572,7 @@ ${confirmMessageAfter}`));
     description,
     parameters,
     handler,
-    hidden: functionInfo.categories?.includes("deprecated") ?? false,
+    hidden: !!functionInfo.deprecation,
     aliases: functionInfo.aliases,
     supportsJsonOutput: functionInfo.supportsJsonOutput
   };
@@ -2725,7 +2731,7 @@ var login_exports = {};
 __export(login_exports, {
   AUTH_MODE_HEADER: () => AUTH_MODE_HEADER,
   DEFAULT_AUTH_BASE_URL: () => DEFAULT_AUTH_BASE_URL,
-  ZapierAuthenticationError: () => ZapierAuthenticationError,
+  ZapierAuthenticationError: () => zapierSdk.ZapierAuthenticationError,
   clearTokensFromKeychain: () => clearTokensFromKeychain,
   createCache: () => createCache,
   getActiveCredentials: () => getActiveCredentials,
@@ -3129,12 +3135,6 @@ async function deleteStoredClientCredentials({
 }
 
 // src/login/index.ts
-var ZapierAuthenticationError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "ZapierAuthenticationError";
-  }
-};
 var DEFAULT_AUTH_CLIENT_ID = "grwWZD5hUWGvb4V8ODBuOtXer3h0DBEZ2HR8aay6";
 var TOKEN_REFRESH_BUFFER_MS = 5 * 60 * 1e3;
 function createDebugLog(enabled) {
@@ -3144,9 +3144,9 @@ function createDebugLog(enabled) {
   }
   return (message, data) => {
     if (data === void 0) {
-      console.log(`[Zapier SDK CLI Login] ${message}`);
+      console.error(`[Zapier SDK CLI Login] ${message}`);
     } else {
-      console.log(`[Zapier SDK CLI Login] ${message}`, data);
+      console.error(`[Zapier SDK CLI Login] ${message}`, data);
     }
   };
 }
@@ -3392,7 +3392,7 @@ async function getToken(options = {}) {
     return await resolveOrRefreshToken(options);
   } catch (error) {
     const message = error instanceof Error ? error.message : "Token refresh failed";
-    throw new ZapierAuthenticationError(
+    throw new zapierSdk.ZapierAuthenticationError(
       `${message}
 Please run 'login' to authenticate again.`
     );
@@ -3545,45 +3545,186 @@ async function revokeCredentials({
   });
   emitAuthLogout(onEvent);
 }
+function getBaseUrlFromResolvedCredentials(credentials2) {
+  if (credentials2 && zapierSdk.isCredentialsObject(credentials2)) {
+    return credentials2.baseUrl;
+  }
+  return void 0;
+}
+function getBaseUrlFromOptionsCredentials(credentials2) {
+  if (credentials2 && typeof credentials2 === "object" && "baseUrl" in credentials2 && typeof credentials2.baseUrl === "string") {
+    return credentials2.baseUrl;
+  }
+  return void 0;
+}
+async function resolveCredentialsBaseUrl(context) {
+  const resolvedCredentials = "resolvedCredentials" in context ? context.resolvedCredentials : await context.resolveCredentials?.();
+  return getBaseUrlFromResolvedCredentials(resolvedCredentials) ?? getBaseUrlFromOptionsCredentials(context.options?.credentials) ?? context.options?.baseUrl;
+}
 
-// src/utils/constants.ts
-var LOGIN_PORTS = [49505, 50575, 52804, 55981, 61010, 63851];
-var LOGIN_TIMEOUT_MS = 3e5;
-var spinPromise = async (promise, text) => {
-  const spinner = ora__default.default(text).start();
+// src/utils/non-interactive.ts
+function resolveNonInteractive(options) {
+  return options.nonInteractive === true || options.skipPrompts === true || !process.stdin.isTTY || !process.stdout.isTTY;
+}
+
+// src/utils/auth/client-credentials.ts
+var CREDENTIALS_SCOPES = ["external", "credentials"];
+var EMPTY_POLICY = {
+  version: 2,
+  statements: []
+};
+async function createCredentialsOnServer(api2, name, policy) {
+  const response = await api2.post(
+    "/api/v0/client-credentials",
+    {
+      name,
+      allowed_scopes: CREDENTIALS_SCOPES,
+      ...policy !== void 0 && { policy }
+    },
+    { authRequired: true, requiredScopes: ["credentials"] }
+  );
+  return {
+    clientId: response.data.client_id,
+    clientSecret: response.data.client_secret
+  };
+}
+async function deleteCredentialsOnServer(api2, clientId) {
+  await api2.delete(`/api/v0/client-credentials/${clientId}`, void 0, {
+    authRequired: true,
+    requiredScopes: ["credentials"]
+  });
+}
+async function setupClientCredentials({
+  api: api2,
+  name,
+  credentialsBaseUrl: credentialsBaseUrl2,
+  policy
+}) {
+  const { clientId, clientSecret } = await createCredentialsOnServer(
+    api2,
+    name,
+    policy
+  );
   try {
-    const result = await promise;
-    spinner.succeed();
-    return result;
-  } catch (error) {
-    if (error instanceof ZapierCliUserCancellationError) {
-      spinner.stop();
-    } else {
-      spinner.fail();
+    await withRetry({
+      action: () => storeClientCredentials({
+        name,
+        clientId,
+        clientSecret,
+        scopes: [...CREDENTIALS_SCOPES],
+        baseUrl: credentialsBaseUrl2
+      })
+    });
+  } catch (storeErr) {
+    try {
+      await withRetry({
+        action: () => deleteCredentialsOnServer(api2, clientId)
+      });
+    } catch {
+      console.error(
+        `Failed to roll back orphaned credential ${clientId}. Delete it manually with: zapier-sdk delete-client-credentials ${clientId}`
+      );
     }
-    throw error;
+    throw storeErr;
   }
+  return { clientId };
+}
+
+// src/utils/constants.ts
+var LOGIN_PORTS = [49505, 50575, 52804, 55981, 61010, 63851];
+var LOGIN_TIMEOUT_MS = 3e5;
+
+// src/utils/getCallablePromise.ts
+var getCallablePromise = () => {
+  let resolve4 = () => {
+  };
+  let reject = () => {
+  };
+  const promise = new Promise((_resolve, _reject) => {
+    resolve4 = _resolve;
+    reject = _reject;
+  });
+  return {
+    promise,
+    resolve: resolve4,
+    reject
+  };
 };
+var getCallablePromise_default = getCallablePromise;
 var log = {
   info: (message, ...args) => {
-    console.log(chalk__default.default.blue("\u2139"), message, ...args);
+    console.error(chalk__default.default.blue("\u2139"), message, ...args);
   },
   error: (message, ...args) => {
     console.error(chalk__default.default.red("\u2716"), message, ...args);
   },
   success: (message, ...args) => {
-    console.log(chalk__default.default.green("\u2713"), message, ...args);
+    console.error(chalk__default.default.green("\u2713"), message, ...args);
   },
   warn: (message, ...args) => {
-    console.log(chalk__default.default.yellow("\u26A0"), message, ...args);
+    console.error(chalk__default.default.yellow("\u26A0"), message, ...args);
   },
   debug: (message, ...args) => {
     if (process.env.DEBUG === "true" || process.argv.includes("--debug")) {
-      console.log(chalk__default.default.gray("\u{1F41B}"), message, ...args);
+      console.error(chalk__default.default.gray("\u{1F41B}"), message, ...args);
     }
   }
 };
 var log_default = log;
+var spinPromise = async (promise, text) => {
+  const spinner = ora__default.default(text).start();
+  try {
+    const result = await promise;
+    spinner.succeed();
+    return result;
+  } catch (error) {
+    if (error instanceof ZapierCliUserCancellationError) {
+      spinner.stop();
+    } else {
+      spinner.fail();
+    }
+    throw error;
+  }
+};
+
+// src/utils/auth/oauth-callback.ts
+function getCallbackCode({
+  callbackUrl,
+  transaction,
+  recoveryMessage
+}) {
+  let parsed;
+  try {
+    parsed = new URL(callbackUrl.trim());
+  } catch {
+    throw new ZapierCliValidationError(
+      "Paste the final OAuth callback URL from your browser."
+    );
+  }
+  const expected = new URL(transaction.redirectUri);
+  if (parsed.protocol !== "http:" || parsed.hostname !== expected.hostname || parsed.pathname !== expected.pathname || parsed.port !== expected.port) {
+    throw new ZapierCliValidationError(
+      `Expected the final OAuth callback URL to start with ${transaction.redirectUri}.`
+    );
+  }
+  if (parsed.searchParams.get("state") !== transaction.state) {
+    throw new ZapierCliValidationError(
+      `OAuth state mismatch.${recoveryMessage ? ` ${recoveryMessage}` : ""}`
+    );
+  }
+  if (parsed.searchParams.has("error")) {
+    throw new ZapierCliValidationError(
+      `Authorization denied: ${parsed.searchParams.get("error_description") ?? parsed.searchParams.get("error")}.${recoveryMessage ? ` ${recoveryMessage}` : ""}`
+    );
+  }
+  const code = parsed.searchParams.get("code");
+  if (!code) {
+    throw new ZapierCliValidationError(
+      "No authorization code found in the pasted callback URL."
+    );
+  }
+  return code;
+}
 
 // src/utils/api/client.ts
 var createApiClient = () => {
@@ -3614,179 +3755,77 @@ var createApiClient = () => {
 var api = createApiClient();
 var client_default = api;
 
-// src/utils/getCallablePromise.ts
-var getCallablePromise = () => {
-  let resolve4 = () => {
-  };
-  let reject = () => {
-  };
-  const promise = new Promise((_resolve, _reject) => {
-    resolve4 = _resolve;
-    reject = _reject;
-  });
-  return {
-    promise,
-    resolve: resolve4,
-    reject
-  };
-};
-var getCallablePromise_default = getCallablePromise;
-
-// src/utils/auth/oauth-flow.ts
-var findAvailablePort = () => {
-  return new Promise((resolve4, reject) => {
-    let portIndex = 0;
-    const tryPort = (port) => {
-      const server = express__default.default().listen(port, () => {
-        server.close();
-        resolve4(port);
-      });
-      server.on("error", (err) => {
-        if (err.code === "EADDRINUSE") {
-          if (portIndex < LOGIN_PORTS.length) {
-            tryPort(LOGIN_PORTS[portIndex++]);
-          } else {
-            reject(
-              new Error(
-                `All configured OAuth callback ports are busy: ${LOGIN_PORTS.join(", ")}. Please try again later or close applications using these ports.`
-              )
-            );
-          }
-        } else {
-          reject(err);
-        }
-      });
-    };
-    if (LOGIN_PORTS.length > 0) {
-      tryPort(LOGIN_PORTS[portIndex++]);
-    } else {
-      reject(new Error("No OAuth callback ports configured"));
-    }
-  });
-};
-var generateRandomString = () => {
+// src/utils/auth/oauth-transaction.ts
+var OAUTH_LOOPBACK_HOST = "localhost";
+function buildBrowserAuthUrl({
+  authorizeUrl,
+  entryPoint = "login"
+}) {
+  if (entryPoint === "login") return authorizeUrl;
+  const parsedAuthorizeUrl = new URL(authorizeUrl);
+  const signupUrl = new URL("/sign-up", parsedAuthorizeUrl);
+  signupUrl.searchParams.set("skipOnboarding", "true");
+  signupUrl.searchParams.set(
+    "next",
+    `${parsedAuthorizeUrl.pathname}${parsedAuthorizeUrl.search}`
+  );
+  return signupUrl.toString();
+}
+function generateRandomString() {
   const array = new Uint32Array(28);
   crypto__default.default.getRandomValues(array);
   return Array.from(array, (dec) => ("0" + dec.toString(16)).slice(-2)).join(
     ""
   );
-};
+}
 function ensureOfflineAccess(scope) {
-  if (scope.includes("offline_access")) {
-    return scope;
-  }
+  if (scope.includes("offline_access")) return scope;
   return `${scope} offline_access`;
 }
-async function runOauthFlow({
-  timeoutMs = LOGIN_TIMEOUT_MS,
+async function prepareOauthTransaction({
   pkceCredentials,
-  baseUrl: baseUrl2
+  baseUrl: baseUrl2,
+  redirectUri,
+  entryPoint = "login"
 }) {
   const { clientId, tokenUrl, authorizeUrl } = getPkceLoginConfig({
     credentials: pkceCredentials,
     baseUrl: baseUrl2
   });
-  const scope = ensureOfflineAccess(
-    pkceCredentials?.scope || "internal credentials"
-  );
-  const availablePort = await findAvailablePort();
-  const redirectUri = `http://localhost:${availablePort}/oauth`;
-  log_default.info(`Using port ${availablePort} for OAuth callback`);
-  const {
-    promise: promisedCode,
-    resolve: setCode,
-    reject: rejectCode
-  } = getCallablePromise_default();
-  const oauthState = generateRandomString();
-  const expressApp = express__default.default();
-  expressApp.get("/oauth", (req, res) => {
-    res.setHeader("Connection", "close");
-    if (req.query.state !== oauthState) {
-      rejectCode(new Error("OAuth state mismatch \u2014 possible CSRF"));
-      res.status(400).end("Invalid state. You can close this tab.");
-      return;
-    }
-    if (req.query.error) {
-      const desc = req.query.error_description ?? req.query.error;
-      rejectCode(new Error(`Authorization denied: ${desc}`));
-      res.end("Authorization was denied. You can close this tab.");
-      return;
-    }
-    if (!req.query.code) {
-      rejectCode(new Error("No authorization code received"));
-      res.end("No authorization code received. You can close this tab.");
-      return;
-    }
-    setCode(String(req.query.code));
-    res.end("You can now close this tab and return to the CLI.");
-  });
-  const server = expressApp.listen(availablePort);
-  const connections = /* @__PURE__ */ new Set();
-  server.on("connection", (conn) => {
-    connections.add(conn);
-    conn.on("close", () => connections.delete(conn));
-  });
-  const cleanup = () => {
-    server.close();
-    log_default.info("\n\u274C Login cancelled by user");
-    rejectCode(new ZapierCliUserCancellationError());
-  };
-  process.on("SIGINT", cleanup);
-  process.on("SIGTERM", cleanup);
   const { code_verifier: codeVerifier, code_challenge: codeChallenge } = await pkceChallenge__default.default();
+  const state = generateRandomString();
   const authUrl = `${authorizeUrl}?${new URLSearchParams({
     response_type: "code",
     client_id: clientId,
     redirect_uri: redirectUri,
-    scope,
-    state: oauthState,
+    scope: ensureOfflineAccess(
+      pkceCredentials?.scope || "internal credentials"
+    ),
+    state,
     code_challenge: codeChallenge,
     code_challenge_method: "S256"
   }).toString()}`;
-  log_default.info("Opening your browser to log in.");
-  log_default.info("If it doesn't open, visit:", authUrl);
-  open__default.default(authUrl);
-  let timeoutTimer;
-  try {
-    await spinPromise(
-      Promise.race([
-        promisedCode,
-        new Promise((_resolve, reject) => {
-          timeoutTimer = setTimeout(() => {
-            reject(
-              new Error(
-                `Login timed out after ${Math.round(timeoutMs / 1e3)} seconds.`
-              )
-            );
-          }, timeoutMs);
-        })
-      ]),
-      "Waiting for you to login and authorize"
-    );
-  } finally {
-    if (timeoutTimer) {
-      clearTimeout(timeoutTimer);
-    }
-    process.off("SIGINT", cleanup);
-    process.off("SIGTERM", cleanup);
-    await new Promise((resolve4) => {
-      const timeout = setTimeout(() => {
-        log_default.info("Server close timed out, forcing connection shutdown...");
-        connections.forEach((conn) => conn.destroy());
-        resolve4();
-      }, 1e3);
-      server.close(() => {
-        clearTimeout(timeout);
-        resolve4();
-      });
-    });
-  }
-  log_default.info("Exchanging authorization code for tokens...");
+  return {
+    browserAuthUrl: buildBrowserAuthUrl({ authorizeUrl: authUrl, entryPoint }),
+    clientId,
+    codeVerifier,
+    redirectUri,
+    state,
+    tokenUrl
+  };
+}
+async function exchangeOauthCode({
+  tokenUrl,
+  code,
+  redirectUri,
+  clientId,
+  codeVerifier
+}) {
   const { data } = await client_default.post(
     tokenUrl,
     {
       grant_type: "authorization_code",
-      code: await promisedCode,
+      code,
       redirect_uri: redirectUri,
       client_id: clientId,
       code_verifier: codeVerifier
@@ -3798,7 +3837,6 @@ async function runOauthFlow({
       }
     }
   );
-  log_default.info("Token exchange completed successfully");
   return {
     accessToken: data.access_token,
     refreshToken: data.refresh_token,
@@ -3806,105 +3844,467 @@ async function runOauthFlow({
   };
 }
 
-// src/utils/auth/client-credentials.ts
-var CREDENTIALS_SCOPES = ["external", "credentials"];
-var EMPTY_POLICY = {
-  version: 2,
-  statements: []
+// src/utils/auth/oauth-flow.ts
+var OauthFlowTimeoutError = class extends Error {
+  constructor(timeoutMs) {
+    super("OAuth flow timed out");
+    this.timeoutMs = timeoutMs;
+    this.name = "OauthFlowTimeoutError";
+  }
 };
-async function createCredentialsOnServer(api2, name, policy) {
-  const response = await api2.post(
-    "/api/v0/client-credentials",
-    {
-      name,
-      allowed_scopes: CREDENTIALS_SCOPES,
-      ...policy !== void 0 && { policy }
-    },
-    { authRequired: true, requiredScopes: ["credentials"] }
-  );
-  return {
-    clientId: response.data.client_id,
-    clientSecret: response.data.client_secret
-  };
+var OauthAuthorizationDeniedError = class extends Error {
+  constructor(reason) {
+    super("OAuth authorization denied");
+    this.reason = reason;
+    this.name = "OauthAuthorizationDeniedError";
+  }
+};
+function findAvailablePort() {
+  return new Promise((resolve4, reject) => {
+    let portIndex = 0;
+    const tryPort = (port) => {
+      const server = express__default.default().listen(port, OAUTH_LOOPBACK_HOST, () => {
+        server.close();
+        resolve4(port);
+      });
+      server.on("error", (err) => {
+        if (err.code === "EADDRINUSE" && portIndex < LOGIN_PORTS.length) {
+          tryPort(LOGIN_PORTS[portIndex++]);
+        } else if (err.code === "EADDRINUSE") {
+          reject(
+            new Error(
+              `All configured OAuth callback ports are busy: ${LOGIN_PORTS.join(", ")}. Please try again later or close applications using these ports.`
+            )
+          );
+        } else {
+          reject(err);
+        }
+      });
+    };
+    if (LOGIN_PORTS.length > 0) tryPort(LOGIN_PORTS[portIndex++]);
+    else reject(new Error("No OAuth callback ports configured"));
+  });
 }
-async function deleteCredentialsOnServer(api2, clientId) {
-  await api2.delete(`/api/v0/client-credentials/${clientId}`, void 0, {
-    authRequired: true,
-    requiredScopes: ["credentials"]
+async function runLoginOauthFlow(options) {
+  return runOauthFlowEntryPoint({
+    ...options,
+    entryPoint: "login",
+    authAction: "log in",
+    flowName: "Login"
   });
 }
-async function setupClientCredentials({
-  api: api2,
-  name,
-  credentialsBaseUrl: credentialsBaseUrl2,
-  policy
+async function runSignupOauthFlow(options) {
+  if (options.headless) {
+    return runOauthFlowEntryPoint({
+      ...options,
+      entryPoint: "signup",
+      authAction: "sign up",
+      flowName: "Signup",
+      headless: true
+    });
+  }
+  return runOauthFlowEntryPoint({
+    ...options,
+    entryPoint: "signup",
+    authAction: "sign up",
+    flowName: "Signup"
+  });
+}
+async function runOauthFlowEntryPoint({
+  flowName,
+  ...options
 }) {
-  const { clientId, clientSecret } = await createCredentialsOnServer(
-    api2,
-    name,
-    policy
+  try {
+    return options.headless ? await runHeadlessSignupOauthFlow(options) : await runOauthFlow(options);
+  } catch (error) {
+    if (error instanceof OauthFlowTimeoutError) {
+      throw new Error(
+        withRecoveryMessage(
+          `${flowName} timed out after ${Math.round(error.timeoutMs / 1e3)} seconds.`,
+          options.recoveryMessage
+        )
+      );
+    }
+    if (error instanceof OauthAuthorizationDeniedError) {
+      throw new Error(
+        withRecoveryMessage(
+          `Authorization denied: ${error.reason}.`,
+          options.recoveryMessage
+        )
+      );
+    }
+    if (error instanceof ZapierCliUserCancellationError && !options.silent) {
+      log_default.info(`
+\u274C ${flowName} cancelled by user`);
+    }
+    throw error;
+  }
+}
+function withRecoveryMessage(message, recoveryMessage) {
+  return recoveryMessage ? `${message} ${recoveryMessage}` : message;
+}
+async function runOauthFlow({
+  timeoutMs = LOGIN_TIMEOUT_MS,
+  pkceCredentials,
+  baseUrl: baseUrl2,
+  entryPoint,
+  authAction,
+  silent = false,
+  onProgress
+}) {
+  const port = await findAvailablePort();
+  if (!silent) log_default.info(`Using port ${port} for OAuth callback`);
+  const transaction = await prepareOauthTransaction({
+    pkceCredentials,
+    baseUrl: baseUrl2,
+    redirectUri: `http://${OAUTH_LOOPBACK_HOST}:${port}/oauth`,
+    entryPoint
+  });
+  const code = await collectLocalCallbackCode({
+    transaction,
+    timeoutMs,
+    authAction,
+    silent,
+    onProgress
+  });
+  onProgress?.({ type: "callback_accepted" });
+  if (!silent) log_default.info("Exchanging authorization code for tokens...");
+  onProgress?.({ type: "token_exchange_started" });
+  const tokens = await exchangeOauthCode({ ...transaction, code });
+  if (!silent) log_default.info("Token exchange completed successfully");
+  onProgress?.({ type: "token_exchange_completed" });
+  return tokens;
+}
+async function readHeadlessCallbackUrl({
+  timeoutMs,
+  interactive,
+  recoveryMessage
+}) {
+  const timeoutMessage = withRecoveryMessage(
+    `Signup timed out after ${Math.round(timeoutMs / 1e3)} seconds.`,
+    recoveryMessage
+  );
+  const missingCallbackUrlMessage = withRecoveryMessage(
+    "Paste the final OAuth callback URL from your browser.",
+    recoveryMessage
   );
+  const rl = promises$1.createInterface({ input: process.stdin, output: process.stderr });
+  const abortController = new AbortController();
+  const timeoutTimer = setTimeout(() => abortController.abort(), timeoutMs);
+  const readUrl = interactive ? rl.question("Paste the final OAuth callback URL: ", {
+    signal: abortController.signal
+  }) : new Promise((resolve4, reject) => {
+    let settled = false;
+    const settleResolve = (value) => {
+      settled = true;
+      resolve4(value);
+    };
+    const settleReject = (error) => {
+      if (settled) return;
+      settled = true;
+      reject(error);
+    };
+    abortController.signal.addEventListener(
+      "abort",
+      () => settleReject(new Error(timeoutMessage)),
+      { once: true }
+    );
+    rl.once("line", settleResolve);
+    rl.once(
+      "close",
+      () => settleReject(new ZapierCliValidationError(missingCallbackUrlMessage))
+    );
+    rl.once("error", settleReject);
+  });
   try {
-    await withRetry({
-      action: () => storeClientCredentials({
-        name,
-        clientId,
-        clientSecret,
-        scopes: [...CREDENTIALS_SCOPES],
-        baseUrl: credentialsBaseUrl2
-      })
+    return await readUrl.catch((error) => {
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new Error(timeoutMessage);
+      }
+      throw error;
     });
-  } catch (storeErr) {
-    try {
-      await withRetry({
-        action: () => deleteCredentialsOnServer(api2, clientId)
-      });
-    } catch {
-      console.error(
-        `Failed to roll back orphaned credential ${clientId}. Delete it manually with: zapier-sdk delete-client-credentials ${clientId}`
+  } finally {
+    clearTimeout(timeoutTimer);
+    rl.close();
+  }
+}
+async function runHeadlessSignupOauthFlow({
+  timeoutMs = LOGIN_TIMEOUT_MS,
+  pkceCredentials,
+  baseUrl: baseUrl2,
+  interactive = true,
+  onProgress,
+  recoveryMessage
+}) {
+  const port = LOGIN_PORTS[0];
+  const transaction = await prepareOauthTransaction({
+    pkceCredentials,
+    baseUrl: baseUrl2,
+    redirectUri: `http://${OAUTH_LOOPBACK_HOST}:${port}/oauth`,
+    entryPoint: "signup"
+  });
+  console.log(
+    "Use this mode when signing up from a machine that has no browser."
+  );
+  console.log("Open this signup URL in a browser on another machine:");
+  console.log(transaction.browserAuthUrl);
+  console.log(
+    `When the browser lands on ${transaction.redirectUri} and cannot connect, paste the full final URL back here.`
+  );
+  const callbackUrl = await readHeadlessCallbackUrl({
+    timeoutMs,
+    interactive,
+    recoveryMessage
+  });
+  const code = getCallbackCode({
+    callbackUrl,
+    transaction,
+    recoveryMessage
+  });
+  onProgress?.({ type: "callback_accepted" });
+  console.log("Exchanging authorization code for tokens...");
+  onProgress?.({ type: "token_exchange_started" });
+  const tokens = await exchangeOauthCode({ ...transaction, code });
+  onProgress?.({ type: "token_exchange_completed" });
+  return tokens;
+}
+async function collectLocalCallbackCode({
+  transaction,
+  timeoutMs,
+  authAction,
+  silent,
+  onProgress
+}) {
+  const { promise, resolve: resolve4, reject } = getCallablePromise_default();
+  const app = express__default.default();
+  app.get("/oauth", (req, res) => {
+    res.setHeader("Connection", "close");
+    if (req.query.state !== transaction.state) {
+      res.status(400).end("Invalid state. You can close this tab.");
+    } else if (req.query.error) {
+      reject(
+        new OauthAuthorizationDeniedError(
+          String(req.query.error_description ?? req.query.error)
+        )
       );
+      res.end("Authorization was denied. You can close this tab.");
+    } else if (!req.query.code) {
+      reject(new Error("No authorization code received"));
+      res.end("No authorization code received. You can close this tab.");
+    } else {
+      resolve4(String(req.query.code));
+      res.end("You can now close this tab and return to the CLI.");
     }
-    throw storeErr;
+  });
+  const server = app.listen(
+    Number(new URL(transaction.redirectUri).port),
+    OAUTH_LOOPBACK_HOST
+  );
+  const connections = /* @__PURE__ */ new Set();
+  server.on("connection", (conn) => {
+    connections.add(conn);
+    conn.on("close", () => connections.delete(conn));
+  });
+  const cleanup = () => {
+    server.close();
+    reject(new ZapierCliUserCancellationError());
+  };
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+  let timeoutTimer;
+  try {
+    await waitForServerListening(server);
+    await openBrowser({ transaction, authAction, silent, onProgress });
+    const waitForCode = Promise.race([
+      promise,
+      new Promise((_resolve, rejectTimeout) => {
+        timeoutTimer = setTimeout(() => {
+          rejectTimeout(new OauthFlowTimeoutError(timeoutMs));
+        }, timeoutMs);
+      })
+    ]);
+    onProgress?.({ type: "callback_waiting" });
+    return silent ? await waitForCode : await spinPromise(
+      waitForCode,
+      `Waiting for you to ${authAction} and authorize`
+    );
+  } finally {
+    if (timeoutTimer) clearTimeout(timeoutTimer);
+    process.off("SIGINT", cleanup);
+    process.off("SIGTERM", cleanup);
+    await closeServer({ server, connections, silent });
   }
-  return { clientId };
 }
-function getBaseUrlFromResolvedCredentials(credentials2) {
-  if (credentials2 && zapierSdk.isCredentialsObject(credentials2)) {
-    return credentials2.baseUrl;
-  }
-  return void 0;
+async function waitForServerListening(server) {
+  if (server.listening) return;
+  await new Promise((resolve4, reject) => {
+    const cleanup = () => {
+      server.off("listening", handleListening);
+      server.off("error", handleError);
+    };
+    const handleListening = () => {
+      cleanup();
+      resolve4();
+    };
+    const handleError = (error) => {
+      cleanup();
+      reject(error);
+    };
+    server.once("listening", handleListening);
+    server.once("error", handleError);
+  });
 }
-function getBaseUrlFromOptionsCredentials(credentials2) {
-  if (credentials2 && typeof credentials2 === "object" && "baseUrl" in credentials2 && typeof credentials2.baseUrl === "string") {
-    return credentials2.baseUrl;
+async function openBrowser({
+  transaction,
+  authAction,
+  silent,
+  onProgress
+}) {
+  if (!silent) {
+    log_default.info(`Opening your browser to ${authAction}.`);
+    log_default.info("If it doesn't open, visit:", transaction.browserAuthUrl);
+  }
+  onProgress?.({ type: "browser_opening", url: transaction.browserAuthUrl });
+  try {
+    await open__default.default(transaction.browserAuthUrl);
+    onProgress?.({ type: "browser_opened", url: transaction.browserAuthUrl });
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    if (!silent) {
+      log_default.info(
+        `Browser did not open automatically to ${authAction}: ${reason}`
+      );
+      log_default.info("Visit this URL manually:", transaction.browserAuthUrl);
+    }
+    onProgress?.({
+      type: "browser_open_failed",
+      url: transaction.browserAuthUrl,
+      reason
+    });
   }
-  return void 0;
 }
-async function resolveCredentialsBaseUrl(context) {
-  const resolvedCredentials = "resolvedCredentials" in context ? context.resolvedCredentials : await context.resolveCredentials?.();
-  return getBaseUrlFromResolvedCredentials(resolvedCredentials) ?? getBaseUrlFromOptionsCredentials(context.options?.credentials) ?? context.options?.baseUrl;
+async function closeServer({
+  server,
+  connections,
+  silent
+}) {
+  await new Promise((resolve4) => {
+    const timeout = setTimeout(() => {
+      if (!silent)
+        log_default.info("Server close timed out, forcing connection shutdown...");
+      connections.forEach((conn) => conn.destroy());
+      resolve4();
+    }, 1e3);
+    server.close(() => {
+      clearTimeout(timeout);
+      resolve4();
+    });
+  });
 }
 
-// src/utils/non-interactive.ts
-function resolveNonInteractive(options) {
-  return (options.nonInteractive ?? options.skipPrompts) === true || !process.stdin.isTTY || !process.stdout.isTTY;
+// src/utils/auth/oauth-errors.ts
+var SENSITIVE_OAUTH_FIELDS = [
+  "access_token",
+  "refresh_token",
+  "id_token",
+  "client_secret",
+  "code_verifier",
+  "code_challenge"
+];
+function getErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function toCamelCase(field) {
+  return field.replace(
+    /_([a-z])/g,
+    (_match, letter) => letter.toUpperCase()
+  );
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var sensitiveOauthFieldPattern = Array.from(
+  new Set(
+    SENSITIVE_OAUTH_FIELDS.flatMap((field) => [field, toCamelCase(field)])
+  )
+).map(escapeRegExp).join("|");
+var sensitiveQueryParamPattern = new RegExp(
+  `([?&])(${sensitiveOauthFieldPattern})(=)[^&#\\s"'<>]*`,
+  "gi"
+);
+function redactSensitiveOauthErrorMessage(message) {
+  return message.replace(
+    sensitiveQueryParamPattern,
+    (_match, prefix, key, separator) => `${prefix}${key}${separator}[REDACTED]`
+  ).replace(
+    new RegExp(`"(${sensitiveOauthFieldPattern})"(\\s*:\\s*)"[^"]*"`, "g"),
+    (_match, key, separator) => `"${key}"${separator}"[REDACTED]"`
+  );
+}
+function toRedactedOauthError(error) {
+  const message = redactSensitiveOauthErrorMessage(getErrorMessage(error));
+  if (error instanceof ZapierCliValidationError) {
+    return new ZapierCliValidationError(message);
+  }
+  if (error instanceof Error) {
+    const redactedError = new Error(message);
+    redactedError.name = error.name;
+    return redactedError;
+  }
+  return new ZapierCliValidationError(message);
 }
-var LoginSchema = zod.z.object({
-  timeout: zod.z.string().optional().describe("Login timeout in seconds (default: 300)"),
-  useApprovals: zod.z.boolean().optional().describe(
-    "Require approvals for actions performed with these credentials"
-  ),
-  nonInteractive: zod.z.boolean().optional().describe(
-    "Skip interactive prompts. Uses defaults where possible; errors instead of prompting when input is required. Useful in CI, piped output, or environments where TTY detection is unreliable."
-  ),
-  /** @deprecated Use `nonInteractive` instead. */
-  skipPrompts: zod.z.boolean().optional().meta({
-    deprecated: true,
-    deprecationMessage: "Use --non-interactive instead."
-  })
-}).describe("Log in to Zapier to access your account");
 
-// src/plugins/login/index.ts
+// src/utils/auth/account-auth.ts
+var LEGACY_JWT_UPGRADE_PROMPT = "We're upgrading your login to client credentials for a simpler, more reliable experience and to support future security controls. Older Zapier SDK/CLI versions on this machine may stop working after the upgrade. Continue?";
+var SIGNUP_RECOVERY_MESSAGE = "Restart `zapier-sdk signup` to generate a fresh signup URL and try again.";
+var HEADLESS_SIGNUP_RECOVERY_MESSAGE = "Restart `zapier-sdk signup --headless` to generate a fresh signup URL and try again.";
+function getEntryPointLabel(entryPoint) {
+  return entryPoint === "signup" ? "Signup" : "Login";
+}
+function getActiveCredentialsAction(entryPoint) {
+  return entryPoint === "signup" ? "continue signup" : "log in again";
+}
+function getCredentialsPromptMessage(entryPoint) {
+  return entryPoint === "signup" ? "Enter a name to identify these credentials:" : "Enter a name to identify them:";
+}
+function getProfileMessage(entryPoint, email) {
+  return entryPoint === "signup" ? `\u{1F464} Authenticated as ${email}` : `\u{1F464} Logged in as ${email}`;
+}
+function defaultCredentialsName(email) {
+  return `${email}@${os.hostname()}`;
+}
+function validateCredentialsName(name) {
+  const trimmedName = name.trim();
+  if (!trimmedName) throw new ZapierCliValidationError("Name cannot be empty");
+  return trimmedName;
+}
+async function promptCredentialsName({
+  email,
+  promptMessage
+}) {
+  const { credentialName } = await inquirer__default.default.prompt([
+    {
+      type: "input",
+      name: "credentialName",
+      message: promptMessage,
+      default: defaultCredentialsName(email),
+      validate: (input) => {
+        try {
+          validateCredentialsName(input);
+          return true;
+        } catch (err) {
+          return err instanceof Error ? err.message : String(err);
+        }
+      }
+    }
+  ]);
+  return validateCredentialsName(credentialName);
+}
+function resolveDefaultCredentialsName({
+  email
+}) {
+  return validateCredentialsName(defaultCredentialsName(email));
+}
 function toPkceCredentials(credentials2) {
   if (credentials2 && zapierSdk.isCredentialsObject(credentials2) && !("clientSecret" in credentials2)) {
     return {
@@ -3916,104 +4316,125 @@ function toPkceCredentials(credentials2) {
   }
   return void 0;
 }
-async function confirmRevokeAndRelogin(activeCredentials, nonInteractive) {
-  if (nonInteractive) {
+function parseTimeoutSeconds(timeout) {
+  if (timeout === void 0) return 300;
+  const timeoutSeconds = Number(timeout);
+  if (!Number.isInteger(timeoutSeconds) || timeoutSeconds <= 0) {
     throw new ZapierCliValidationError(
-      `Already logged in as "${activeCredentials.name}". Run \`logout\` first or use an interactive terminal to re-authenticate.`
+      "Timeout must be a positive integer (seconds)."
     );
   }
+  return timeoutSeconds;
+}
+async function promptConfirm2({
+  message,
+  defaultValue
+}) {
   const { confirmed } = await inquirer__default.default.prompt([
-    {
-      type: "confirm",
-      name: "confirmed",
+    { type: "confirm", name: "confirmed", message, default: defaultValue }
+  ]);
+  return confirmed;
+}
+function promptlessCredentialResetError(credentials2) {
+  throw new ZapierCliValidationError(
+    `Already logged in as "${credentials2.name}". Run \`logout\` first or use an interactive terminal to re-authenticate.`
+  );
+}
+function promptlessLegacyJwtUpgradeError() {
+  throw new ZapierCliValidationError(
+    "Legacy JWT login detected. Run `logout` first or use an interactive terminal to migrate to client credentials."
+  );
+}
+async function clearExistingAuthState({
+  sdk,
+  baseUrl: baseUrl2,
+  interactive,
+  entryPoint
+}) {
+  const activeCredentials = getActiveCredentials({ baseUrl: baseUrl2 });
+  const flowLabel = getEntryPointLabel(entryPoint);
+  if (activeCredentials) {
+    const confirmed = interactive ? await promptConfirm2({
+      defaultValue: false,
       message: `You are already logged in as "${activeCredentials.name}".
 Logging out will delete these credentials and may interrupt other Zapier SDK or CLI sessions using them.
-Log out and log in again?`,
-      default: false
+Log out and ${getActiveCredentialsAction(entryPoint)}?`
+    }) : promptlessCredentialResetError(activeCredentials);
+    if (!confirmed) {
+      console.log(`${flowLabel} cancelled.`);
+      return false;
     }
-  ]);
-  if (!confirmed) {
-    console.log("Login cancelled.");
-    return false;
-  }
-  return true;
-}
-async function confirmJwtMigration(nonInteractive) {
-  if (nonInteractive) {
-    throw new ZapierCliValidationError(
-      "Legacy JWT login detected. Run `logout` first or use an interactive terminal to migrate to client credentials."
-    );
-  }
-  const { confirmed } = await inquirer__default.default.prompt([
-    {
-      type: "confirm",
-      name: "confirmed",
-      message: "We're upgrading your login to client credentials for a simpler, more reliable experience and to support future security controls. Older Zapier SDK/CLI versions on this machine may stop working after the upgrade. Continue?",
-      default: true
+    try {
+      await revokeCredentials({
+        api: sdk.context.api,
+        credentials: activeCredentials
+      });
+    } catch {
+      if (!interactive) {
+        throw new ZapierCliValidationError(
+          `${flowLabel} cleanup failed and cannot be reset without confirmation. Re-run with an interactive terminal.`
+        );
+      }
+      const reset = await promptConfirm2({
+        defaultValue: false,
+        message: `${flowLabel} cleanup failed. Reset local session state and continue?`
+      });
+      if (!reset) {
+        console.log(`${flowLabel} cancelled.`);
+        return false;
+      }
+      await deleteStoredClientCredentials({
+        name: activeCredentials.name,
+        baseUrl: activeCredentials.baseUrl
+      });
     }
-  ]);
-  if (!confirmed) {
-    console.log("Login cancelled.");
-    return false;
-  }
-  return true;
-}
-async function confirmLocalLoginReset(nonInteractive) {
-  if (nonInteractive) {
-    throw new ZapierCliValidationError(
-      "Login cleanup failed and cannot be reset without confirmation. Re-run with an interactive terminal."
-    );
-  }
-  const { confirmed } = await inquirer__default.default.prompt([
-    {
-      type: "confirm",
-      name: "confirmed",
-      message: "Login cleanup failed. Reset local session state and continue?",
-      default: false
+  } else if (hasLegacyJwtConfig()) {
+    const confirmed = interactive ? await promptConfirm2({
+      defaultValue: true,
+      message: LEGACY_JWT_UPGRADE_PROMPT
+    }) : promptlessLegacyJwtUpgradeError();
+    if (!confirmed) {
+      console.log(`${flowLabel} cancelled.`);
+      return false;
     }
-  ]);
-  if (!confirmed) {
-    console.log("Login cancelled.");
-    return false;
   }
   return true;
 }
-function parseTimeoutSeconds(timeout) {
-  const timeoutSeconds = timeout ? parseInt(timeout, 10) : 300;
-  if (isNaN(timeoutSeconds) || timeoutSeconds <= 0) {
-    throw new Error("Timeout must be a positive number");
-  }
-  return timeoutSeconds;
+async function getProfile(api2) {
+  return api2.get("/zapier/api/v4/profile/", {
+    authRequired: true
+  });
 }
-async function promptCredentialsName(email, nonInteractive) {
-  const fallback = `${email}@${os.hostname()}`;
-  if (nonInteractive) {
-    return fallback;
+async function saveClientCredentials({
+  api: api2,
+  name,
+  credentialsBaseUrl: credentialsBaseUrl2,
+  useApprovals,
+  cleanupLogPrefix
+}) {
+  await setupClientCredentials({
+    api: api2,
+    name,
+    credentialsBaseUrl: credentialsBaseUrl2,
+    ...useApprovals && { policy: EMPTY_POLICY }
+  });
+  try {
+    await clearLegacyJwtState();
+  } catch (err) {
+    console.error(
+      `[${cleanupLogPrefix}] Best-effort legacy JWT cleanup failed:`,
+      err
+    );
   }
-  const { credentialName } = await inquirer__default.default.prompt([
-    {
-      type: "input",
-      name: "credentialName",
-      message: "Enter a name to identify them:",
-      default: fallback,
-      validate: (input) => {
-        if (!input.trim()) return "Name cannot be empty";
-        return true;
-      }
-    }
-  ]);
-  return credentialName;
 }
-function emitLoginSuccess({
+function emitAccountAuthSuccess({
   sdk,
   profile
 }) {
   sdk.context.eventEmission.emit(
     "platform.sdk.ApplicationLifecycleEvent",
     zapierSdk.buildApplicationLifecycleEvent(
-      {
-        lifecycle_event_type: "login_success"
-      },
+      { lifecycle_event_type: "login_success" },
       {
         customuser_id: profile.user_id,
         account_id: profile.roles[0]?.account_id ?? null
@@ -4021,18 +4442,128 @@ function emitLoginSuccess({
     )
   );
 }
-async function getProfile(api2) {
-  return api2.get("/zapier/api/v4/profile/", {
-    authRequired: true
-  });
+function emitSignupSuccess({
+  sdk
+}) {
+  sdk.context.eventEmission.emit(
+    "platform.sdk.ApplicationLifecycleEvent",
+    zapierSdk.buildApplicationLifecycleEvent({ lifecycle_event_type: "signup_success" })
+  );
 }
-async function bestEffortClearLegacyJwtState() {
+async function runOauthWithRedaction(runOauth) {
   try {
-    await clearLegacyJwtState();
-  } catch (err) {
-    console.error("[login] Best-effort legacy JWT cleanup failed:", err);
+    return await runOauth();
+  } catch (error) {
+    if (error instanceof ZapierCliUserCancellationError) throw error;
+    throw toRedactedOauthError(error);
+  }
+}
+async function runOauthForEntryPoint({
+  sdk,
+  entryPoint,
+  timeoutMs,
+  pkceCredentials,
+  baseUrl: baseUrl2,
+  headless,
+  interactive
+}) {
+  if (entryPoint === "signup") {
+    return runOauthWithRedaction(
+      () => runSignupOauthFlow({
+        timeoutMs,
+        pkceCredentials,
+        baseUrl: baseUrl2,
+        headless,
+        interactive,
+        recoveryMessage: headless ? HEADLESS_SIGNUP_RECOVERY_MESSAGE : SIGNUP_RECOVERY_MESSAGE,
+        onProgress: (event) => {
+          if (event.type === "callback_accepted") {
+            emitSignupSuccess({ sdk });
+          }
+        }
+      })
+    );
   }
+  return runOauthWithRedaction(
+    () => runLoginOauthFlow({ timeoutMs, pkceCredentials, baseUrl: baseUrl2 })
+  );
+}
+async function runAccountAuth({
+  sdk,
+  options,
+  entryPoint
+}) {
+  const timeoutSeconds = parseTimeoutSeconds(options.timeout);
+  const interactive = !resolveNonInteractive(options);
+  const resolvedCredentials = await sdk.context.resolveCredentials();
+  const pkceCredentials = toPkceCredentials(resolvedCredentials);
+  const credentialsBaseUrl2 = await resolveCredentialsBaseUrl({
+    ...sdk.context,
+    resolvedCredentials
+  });
+  if (!await clearExistingAuthState({
+    sdk,
+    baseUrl: credentialsBaseUrl2,
+    interactive,
+    entryPoint
+  })) {
+    return;
+  }
+  const { accessToken } = await runOauthForEntryPoint({
+    sdk,
+    entryPoint,
+    timeoutMs: timeoutSeconds * 1e3,
+    pkceCredentials,
+    baseUrl: credentialsBaseUrl2,
+    headless: options.headless === true,
+    interactive
+  });
+  const scopedApi = zapierSdk.getOrCreateApiClient({
+    credentials: accessToken,
+    baseUrl: credentialsBaseUrl2
+  });
+  const profile = await getProfile(scopedApi);
+  console.log(getProfileMessage(entryPoint, profile.email));
+  console.log(
+    "\nGenerating credentials so this machine can make authenticated requests on your behalf."
+  );
+  const resolveCredentialsName = interactive ? ({ email }) => promptCredentialsName({
+    email,
+    promptMessage: getCredentialsPromptMessage(entryPoint)
+  }) : resolveDefaultCredentialsName;
+  const credentialName = await resolveCredentialsName({ email: profile.email });
+  const useApprovals = options.useApprovals === true;
+  await saveClientCredentials({
+    api: scopedApi,
+    name: credentialName,
+    credentialsBaseUrl: credentialsBaseUrl2,
+    useApprovals,
+    cleanupLogPrefix: entryPoint
+  });
+  console.log(
+    `\u2705 Credentials "${credentialName}" created and set as default. You are ready to use the Zapier SDK.`
+  );
+  if (useApprovals) {
+    console.log("\u{1F510} Approvals are enabled for these credentials.");
+  }
+  emitAccountAuthSuccess({ sdk, profile });
 }
+var LoginSchema = zod.z.object({
+  timeout: zod.z.string().optional().describe("Login timeout in seconds (default: 300)"),
+  useApprovals: zod.z.boolean().optional().describe(
+    "Require approvals for actions performed with these credentials"
+  ),
+  nonInteractive: zod.z.boolean().optional().describe(
+    "Skip interactive prompts. Uses defaults where possible; errors instead of prompting when input is required. Useful in CI, piped output, or environments where TTY detection is unreliable."
+  ),
+  /** @deprecated Use `nonInteractive` instead. */
+  skipPrompts: zod.z.boolean().optional().meta({
+    deprecated: true,
+    deprecationMessage: "Use --non-interactive instead."
+  })
+}).describe("Log in to Zapier to access your account");
+
+// src/plugins/login/index.ts
 var loginPlugin = zapierSdk.definePlugin(
   (sdk) => zapierSdk.createPluginMethod(sdk, {
     name: "login",
@@ -4040,68 +4571,37 @@ var loginPlugin = zapierSdk.definePlugin(
     inputSchema: LoginSchema,
     supportsJsonOutput: false,
     handler: async ({ sdk: sdk2, options }) => {
-      const timeoutSeconds = parseTimeoutSeconds(options.timeout);
-      const nonInteractive = resolveNonInteractive(options);
-      const resolvedCredentials = await sdk2.context.resolveCredentials();
-      const pkceCredentials = toPkceCredentials(resolvedCredentials);
-      const credentialsBaseUrl2 = await resolveCredentialsBaseUrl({
-        ...sdk2.context,
-        resolvedCredentials
-      });
-      const activeCredentials = getActiveCredentials({
-        baseUrl: credentialsBaseUrl2
-      });
-      if (activeCredentials) {
-        if (!await confirmRevokeAndRelogin(activeCredentials, nonInteractive))
-          return;
-        try {
-          await revokeCredentials({
-            api: sdk2.context.api,
-            credentials: activeCredentials
-          });
-        } catch {
-          if (!await confirmLocalLoginReset(nonInteractive)) return;
-          await deleteStoredClientCredentials({
-            name: activeCredentials.name,
-            baseUrl: activeCredentials.baseUrl
-          });
-        }
-      } else if (hasLegacyJwtConfig()) {
-        if (!await confirmJwtMigration(nonInteractive)) return;
-      }
-      const { accessToken } = await runOauthFlow({
-        timeoutMs: timeoutSeconds * 1e3,
-        pkceCredentials,
-        baseUrl: credentialsBaseUrl2
-      });
-      const scopedApi = zapierSdk.getOrCreateApiClient({
-        credentials: accessToken,
-        baseUrl: credentialsBaseUrl2
-      });
-      const profile = await getProfile(scopedApi);
-      console.log(`\u{1F464} Logged in as ${profile.email}`);
-      console.log(
-        "\nGenerating credentials so this machine can make authenticated requests on your behalf."
-      );
-      const credentialName = await promptCredentialsName(
-        profile.email,
-        nonInteractive
-      );
-      const useApprovals = options.useApprovals === true;
-      await setupClientCredentials({
-        api: scopedApi,
-        name: credentialName,
-        credentialsBaseUrl: credentialsBaseUrl2,
-        ...useApprovals && { policy: EMPTY_POLICY }
-      });
-      await bestEffortClearLegacyJwtState();
-      console.log(
-        `\u2705 Credentials "${credentialName}" created and set as default. You are ready to use the Zapier SDK.`
-      );
-      if (useApprovals) {
-        console.log("\u{1F510} Approvals are enabled for these credentials.");
-      }
-      emitLoginSuccess({ sdk: sdk2, profile });
+      await runAccountAuth({ sdk: sdk2, options, entryPoint: "login" });
+    }
+  })
+);
+var SignupSchema = zod.z.object({
+  timeout: zod.z.string().optional().describe("Signup timeout in seconds (default: 300)"),
+  useApprovals: zod.z.boolean().optional().describe(
+    "Require approvals for actions performed with these credentials"
+  ),
+  nonInteractive: zod.z.boolean().optional().describe(
+    "Skip interactive prompts. Uses defaults where possible; errors instead of prompting when input is required. Useful in CI, piped output, or environments where TTY detection is unreliable."
+  ),
+  /** @deprecated Use `nonInteractive` instead. */
+  skipPrompts: zod.z.boolean().optional().meta({
+    deprecated: true,
+    deprecationMessage: "Use --non-interactive instead."
+  }),
+  headless: zod.z.boolean().optional().describe(
+    "Use when signing up from a machine that has no browser. Prints a signup link to open elsewhere, then accepts the pasted loopback callback URL."
+  )
+}).describe("Set up Zapier account access and SDK credentials");
+
+// src/plugins/signup/index.ts
+var signupPlugin = zapierSdk.definePlugin(
+  (sdk) => zapierSdk.createPluginMethod(sdk, {
+    name: "signup",
+    categories: ["account"],
+    inputSchema: SignupSchema,
+    supportsJsonOutput: false,
+    handler: async ({ sdk: sdk2, options }) => {
+      await runAccountAuth({ sdk: sdk2, options, entryPoint: "signup" });
     }
   })
 );
@@ -4168,7 +4668,8 @@ var BundleCodeSchema = zod.z.object({
 var bundleCodePlugin = zapierSdk.definePlugin(
   (sdk) => zapierSdk.createPluginMethod(sdk, {
     name: "bundleCode",
-    categories: ["utility", "deprecated"],
+    categories: ["utility"],
+    deprecation: { message: "bundleCode is no longer maintained." },
     inputSchema: BundleCodeSchema,
     handler: async ({ options }) => bundleCode(options)
   })
@@ -4264,7 +4765,7 @@ async function detectTypesOutputDirectory() {
   }
   return "./zapier/apps/";
 }
-var addPlugin = zapierSdk.definePlugin(
+var addAppsPlugin = zapierSdk.definePlugin(
   (sdk) => zapierSdk.createPluginMethod(sdk, {
     name: "add",
     categories: ["utility"],
@@ -5669,10 +6170,6 @@ var cliOverridesPlugin = zapierSdk.definePlugin(
     if (sdk.context.meta.fetch) {
       meta.fetch = {
         ...sdk.context.meta.fetch,
-        categories: [
-          ...sdk.context.meta.fetch.categories || [],
-          "deprecated"
-        ],
         deprecation: {
           message: "This command is deprecated and will be removed soon. Use `curl` instead. Learn more: https://docs.zapier.com/sdk/cli-reference#curl"
         }
@@ -6653,7 +7150,7 @@ var watchTriggerInboxCliPlugin = zapierSdk.definePlugin(
 // package.json with { type: 'json' }
 var package_default2 = {
   name: "@zapier/zapier-sdk-cli",
-  version: "0.52.10"};
+  version: "0.53.0"};
 
 // src/sdk.ts
 zapierSdk.injectCliLogin(login_exports);
@@ -6662,21 +7159,21 @@ function createZapierCliSdk(options = {}) {
   const extensionsContextPlugin = () => ({
     context: { extensions }
   });
-  let chain = zapierSdk.createZapierSdk({
+  const sdk = zapierSdk.createZapierSdkStack({
     ...sdkOptions,
     eventEmission: { ...sdkOptions.eventEmission, callContext: "cli" },
     callerPackage: { name: package_default2.name, version: package_default2.version }
-  }).addPlugin(extensionsContextPlugin).addPlugin(generateAppTypesPlugin).addPlugin(buildManifestPlugin).addPlugin(bundleCodePlugin).addPlugin(getLoginConfigPathPlugin).addPlugin(addPlugin).addPlugin(feedbackPlugin).addPlugin(curlPlugin).addPlugin(initPlugin).addPlugin(mcpPlugin).addPlugin(loginPlugin).addPlugin(logoutPlugin).addPlugin(cliOverridesPlugin);
+  }).use(extensionsContextPlugin).use(generateAppTypesPlugin).use(buildManifestPlugin).use(bundleCodePlugin).use(getLoginConfigPathPlugin).use(addAppsPlugin).use(feedbackPlugin).use(curlPlugin).use(initPlugin).use(mcpPlugin).use(loginPlugin).use(signupPlugin).use(logoutPlugin).use(cliOverridesPlugin, { override: true }).toSdk();
   for (const ext of extensions) {
     try {
-      chain = chain.addPlugin(ext);
+      zapierSdk.addPlugin(sdk, ext);
     } catch (err) {
       console.warn(
         `Extension plugin failed to construct: ${err.message}; skipping.`
       );
     }
   }
-  return chain;
+  return sdk;
 }
 experimental.injectCliLogin(login_exports);
 function createZapierCliSdk2(options = {}) {
@@ -6687,21 +7184,21 @@ function createZapierCliSdk2(options = {}) {
   const experimentalContextPlugin = () => ({
     context: { experimental: true }
   });
-  let chain = experimental.createZapierSdk({
+  const sdk = experimental.createZapierSdkStack({
     ...sdkOptions,
     eventEmission: { ...sdkOptions.eventEmission, callContext: "cli" },
     callerPackage: { name: package_default2.name, version: package_default2.version }
-  }).addPlugin(extensionsContextPlugin).addPlugin(experimentalContextPlugin).addPlugin(generateAppTypesPlugin).addPlugin(buildManifestPlugin).addPlugin(bundleCodePlugin).addPlugin(getLoginConfigPathPlugin).addPlugin(addPlugin).addPlugin(feedbackPlugin).addPlugin(curlPlugin).addPlugin(initPlugin).addPlugin(drainTriggerInboxCliPlugin, { override: true }).addPlugin(watchTriggerInboxCliPlugin, { override: true }).addPlugin(mcpPlugin).addPlugin(loginPlugin).addPlugin(logoutPlugin).addPlugin(cliOverridesPlugin);
+  }).use(extensionsContextPlugin).use(experimentalContextPlugin).use(generateAppTypesPlugin).use(buildManifestPlugin).use(bundleCodePlugin).use(getLoginConfigPathPlugin).use(addAppsPlugin).use(feedbackPlugin).use(curlPlugin).use(initPlugin).use(drainTriggerInboxCliPlugin, { override: true }).use(watchTriggerInboxCliPlugin, { override: true }).use(mcpPlugin).use(loginPlugin).use(signupPlugin).use(logoutPlugin).use(cliOverridesPlugin, { override: true }).toSdk();
   for (const ext of extensions) {
     try {
-      chain = chain.addPlugin(ext);
+      experimental.addPlugin(sdk, ext);
     } catch (err) {
       console.warn(
         `Extension plugin failed to construct: ${err.message}; skipping.`
       );
     }
   }
-  return chain;
+  return sdk;
 }
 
 // src/utils/extensions.ts
@@ -6835,7 +7332,9 @@ async function checkForUpdates({
         currentVersion
       );
     } catch (error) {
-      log_default.debug(`Failed to check deprecation for current version: ${error}`);
+      if (!(error instanceof packageJsonLib.VersionNotFoundError)) {
+        log_default.debug(`Failed to check deprecation for current version: ${error}`);
+      }
       currentPackageInfo = latestPackageInfo;
     }
     const isDeprecated = Boolean(currentPackageInfo.deprecated);