@zapier/zapier-sdk-cli 0.52.12 → 0.53.1

package/dist/experimental.cjs

@@ -12,11 +12,12 @@ var zod = require('zod');
 var experimental = require('@zapier/zapier-sdk/experimental');
 var os = require('os');
 var inquirer = require('inquirer');
-var open = require('open');
 var express = require('express');
-var pkceChallenge = require('pkce-challenge');
-var ora = require('ora');
+var promises$1 = require('readline/promises');
+var open = require('open');
 var chalk3 = require('chalk');
+var ora = require('ora');
+var pkceChallenge = require('pkce-challenge');
 var zapierSdkMcp = require('@zapier/zapier-sdk-mcp');
 var esbuild = require('esbuild');
 var promises = require('fs/promises');
@@ -55,11 +56,11 @@ var crypto__default = /*#__PURE__*/_interopDefault(crypto);
 var path__namespace = /*#__PURE__*/_interopNamespace(path);
 var lockfile__namespace = /*#__PURE__*/_interopNamespace(lockfile);
 var inquirer__default = /*#__PURE__*/_interopDefault(inquirer);
-var open__default = /*#__PURE__*/_interopDefault(open);
 var express__default = /*#__PURE__*/_interopDefault(express);
-var pkceChallenge__default = /*#__PURE__*/_interopDefault(pkceChallenge);
-var ora__default = /*#__PURE__*/_interopDefault(ora);
+var open__default = /*#__PURE__*/_interopDefault(open);
 var chalk3__default = /*#__PURE__*/_interopDefault(chalk3);
+var ora__default = /*#__PURE__*/_interopDefault(ora);
+var pkceChallenge__default = /*#__PURE__*/_interopDefault(pkceChallenge);
 var ts__namespace = /*#__PURE__*/_interopNamespace(ts);
 var Handlebars__default = /*#__PURE__*/_interopDefault(Handlebars);
 
@@ -888,10 +889,27 @@ async function revokeCredentials({
   });
   emitAuthLogout(onEvent);
 }
+function getBaseUrlFromResolvedCredentials(credentials) {
+  if (credentials && zapierSdk.isCredentialsObject(credentials)) {
+    return credentials.baseUrl;
+  }
+  return void 0;
+}
+function getBaseUrlFromOptionsCredentials(credentials) {
+  if (credentials && typeof credentials === "object" && "baseUrl" in credentials && typeof credentials.baseUrl === "string") {
+    return credentials.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;
+// src/utils/non-interactive.ts
+function resolveNonInteractive(options) {
+  return options.nonInteractive === true || options.skipPrompts === true || !process.stdin.isTTY || !process.stdout.isTTY;
+}
 var ZapierCliError = class extends zapierSdk.ZapierError {
 };
 var ZapierCliUserCancellationError = class extends ZapierCliError {
@@ -919,22 +937,90 @@ var ZapierCliValidationError = class extends ZapierCliError {
   }
 };
 
-// src/utils/spinner.ts
-var spinPromise = async (promise, text) => {
-  const spinner = ora__default.default(text).start();
+// 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,
+  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: credentialsBaseUrl
+      })
+    });
+  } 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.error(chalk3__default.default.blue("\u2139"), message, ...args);
@@ -955,6 +1041,60 @@ var log = {
   }
 };
 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 = () => {
@@ -985,179 +1125,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
+  baseUrl,
+  redirectUri,
+  entryPoint = "login"
 }) {
   const { clientId, tokenUrl, authorizeUrl } = getPkceLoginConfig({
     credentials: pkceCredentials,
     baseUrl
   });
-  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
@@ -1169,7 +1207,6 @@ async function runOauthFlow({
       }
     }
   );
-  log_default.info("Token exchange completed successfully");
   return {
     accessToken: data.access_token,
     refreshToken: data.refresh_token,
@@ -1177,105 +1214,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,
-  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,
+  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,
+    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: credentialsBaseUrl
-      })
+    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,
+  interactive = true,
+  onProgress,
+  recoveryMessage
+}) {
+  const port = LOGIN_PORTS[0];
+  const transaction = await prepareOauthTransaction({
+    pkceCredentials,
+    baseUrl,
+    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(credentials) {
-  if (credentials && zapierSdk.isCredentialsObject(credentials)) {
-    return credentials.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(credentials) {
-  if (credentials && typeof credentials === "object" && "baseUrl" in credentials && typeof credentials.baseUrl === "string") {
-    return credentials.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(credentials) {
   if (credentials && zapierSdk.isCredentialsObject(credentials) && !("clientSecret" in credentials)) {
     return {
@@ -1287,104 +1686,125 @@ function toPkceCredentials(credentials) {
   }
   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 promptConfirm({
+  message,
+  defaultValue
+}) {
   const { confirmed } = await inquirer__default.default.prompt([
-    {
-      type: "confirm",
-      name: "confirmed",
+    { type: "confirm", name: "confirmed", message, default: defaultValue }
+  ]);
+  return confirmed;
+}
+function promptlessCredentialResetError(credentials) {
+  throw new ZapierCliValidationError(
+    `Already logged in as "${credentials.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,
+  interactive,
+  entryPoint
+}) {
+  const activeCredentials = getActiveCredentials({ baseUrl });
+  const flowLabel = getEntryPointLabel(entryPoint);
+  if (activeCredentials) {
+    const confirmed = interactive ? await promptConfirm({
+      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 promptConfirm({
+        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 promptConfirm({
+      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,
+  useApprovals,
+  cleanupLogPrefix
+}) {
+  await setupClientCredentials({
+    api: api2,
+    name,
+    credentialsBaseUrl,
+    ...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
@@ -1392,18 +1812,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,
+  headless,
+  interactive
+}) {
+  if (entryPoint === "signup") {
+    return runOauthWithRedaction(
+      () => runSignupOauthFlow({
+        timeoutMs,
+        pkceCredentials,
+        baseUrl,
+        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 })
+  );
 }
+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 credentialsBaseUrl = await resolveCredentialsBaseUrl({
+    ...sdk.context,
+    resolvedCredentials
+  });
+  if (!await clearExistingAuthState({
+    sdk,
+    baseUrl: credentialsBaseUrl,
+    interactive,
+    entryPoint
+  })) {
+    return;
+  }
+  const { accessToken } = await runOauthForEntryPoint({
+    sdk,
+    entryPoint,
+    timeoutMs: timeoutSeconds * 1e3,
+    pkceCredentials,
+    baseUrl: credentialsBaseUrl,
+    headless: options.headless === true,
+    interactive
+  });
+  const scopedApi = zapierSdk.getOrCreateApiClient({
+    credentials: accessToken,
+    baseUrl: credentialsBaseUrl
+  });
+  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,
+    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",
@@ -1411,68 +1941,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 credentialsBaseUrl = await resolveCredentialsBaseUrl({
-        ...sdk2.context,
-        resolvedCredentials
-      });
-      const activeCredentials = getActiveCredentials({
-        baseUrl: credentialsBaseUrl
-      });
-      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: credentialsBaseUrl
-      });
-      const scopedApi = zapierSdk.getOrCreateApiClient({
-        credentials: accessToken,
-        baseUrl: credentialsBaseUrl
-      });
-      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,
-        ...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" });
     }
   })
 );
@@ -4004,7 +4503,7 @@ var watchTriggerInboxCliPlugin = zapierSdk.definePlugin(
 // package.json with { type: 'json' }
 var package_default = {
   name: "@zapier/zapier-sdk-cli",
-  version: "0.52.12"};
+  version: "0.53.1"};
 
 // src/experimental.ts
 experimental.injectCliLogin(login_exports);
@@ -4020,7 +4519,7 @@ function createZapierCliSdk(options = {}) {
     ...sdkOptions,
     eventEmission: { ...sdkOptions.eventEmission, callContext: "cli" },
     callerPackage: { name: package_default.name, version: package_default.version }
-  }).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(logoutPlugin).use(cliOverridesPlugin, { override: true }).toSdk();
+  }).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 {
       experimental.addPlugin(sdk, ext);