@zapier/zapier-sdk-cli 0.42.1 → 0.43.0

package/dist/cli.cjs

@@ -9,15 +9,18 @@ var chalk7 = require('chalk');
 var ora = require('ora');
 var util = require('util');
 var wrapAnsi = require('wrap-ansi');
-var cliLogin = require('@zapier/zapier-sdk-cli-login');
-var open = require('open');
+var Conf = require('conf');
+var fs = require('fs');
+var jwt = require('jsonwebtoken');
+var crossKeychain = require('cross-keychain');
 var crypto = require('crypto');
+var path = require('path');
+var lockfile = require('proper-lockfile');
+var open = require('open');
 var express = require('express');
 var pkceChallenge = require('pkce-challenge');
 var zapierSdkMcp = require('@zapier/zapier-sdk-mcp');
 var esbuild = require('esbuild');
-var fs = require('fs');
-var path = require('path');
 var promises = require('fs/promises');
 var ts = require('typescript');
 var isInstalledGlobally = require('is-installed-globally');
@@ -53,19 +56,26 @@ var chalk7__default = /*#__PURE__*/_interopDefault(chalk7);
 var ora__default = /*#__PURE__*/_interopDefault(ora);
 var util__default = /*#__PURE__*/_interopDefault(util);
 var wrapAnsi__default = /*#__PURE__*/_interopDefault(wrapAnsi);
-var cliLogin__namespace = /*#__PURE__*/_interopNamespace(cliLogin);
-var open__default = /*#__PURE__*/_interopDefault(open);
+var Conf__default = /*#__PURE__*/_interopDefault(Conf);
+var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
+var jwt__namespace = /*#__PURE__*/_interopNamespace(jwt);
 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 pkceChallenge__default = /*#__PURE__*/_interopDefault(pkceChallenge);
-var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
-var path__namespace = /*#__PURE__*/_interopNamespace(path);
 var ts__namespace = /*#__PURE__*/_interopNamespace(ts);
 var isInstalledGlobally__default = /*#__PURE__*/_interopDefault(isInstalledGlobally);
 var Handlebars__default = /*#__PURE__*/_interopDefault(Handlebars);
 var packageJsonLib__default = /*#__PURE__*/_interopDefault(packageJsonLib);
 var semver__default = /*#__PURE__*/_interopDefault(semver);
 
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var ZapierCliError = class extends zapierSdk.ZapierError {
 };
 var ZapierCliUserCancellationError = class extends ZapierCliError {
@@ -1103,7 +1113,7 @@ var SHARED_COMMAND_CLI_OPTIONS = [
 
 // package.json
 var package_default = {
-  version: "0.42.1"};
+  version: "0.43.0"};
 
 // src/telemetry/builders.ts
 function createCliBaseEvent(context = {}) {
@@ -1833,8 +1843,8 @@ function generateCliCommands(program2, sdk2) {
       return;
     }
     const cliCommandName = methodNameToCliCommand(fnInfo.name);
-    const config = createCommandConfig(cliCommandName, fnInfo, sdk2);
-    addCommand(program2, cliCommandName, config);
+    const config2 = createCommandConfig(cliCommandName, fnInfo, sdk2);
+    addCommand(program2, cliCommandName, config2);
   });
   program2.configureHelp({
     formatHelp: (cmd, helper) => {
@@ -2091,10 +2101,10 @@ function collect(value, previous = []) {
   previous.push(value);
   return previous;
 }
-function addCommand(program2, commandName, config) {
-  const command = program2.command(commandName, { hidden: config.hidden ?? false }).description(config.description);
+function addCommand(program2, commandName, config2) {
+  const command = program2.command(commandName, { hidden: config2.hidden ?? false }).description(config2.description);
   let hasPositionalArray = false;
-  config.parameters.forEach((param) => {
+  config2.parameters.forEach((param) => {
     const kebabName = toKebabCase(param.name);
     if (param.hasResolver && param.required) {
       command.argument(
@@ -2128,7 +2138,7 @@ function addCommand(program2, commandName, config) {
       );
     } else {
       const flags = [];
-      const alias = config.aliases?.[param.name];
+      const alias = config2.aliases?.[param.name];
       if (alias && alias.length === 1) {
         flags.push(`-${alias}`);
       }
@@ -2157,13 +2167,13 @@ function addCommand(program2, commandName, config) {
       }
     }
   });
-  const paramNames = new Set(config.parameters.map((p) => p.name));
+  const paramNames = new Set(config2.parameters.map((p) => p.name));
   SHARED_COMMAND_CLI_OPTIONS.forEach((opt) => {
     if (paramNames.has(opt.name)) return;
-    if (config.supportsJsonOutput === false && opt.name === "json") return;
+    if (config2.supportsJsonOutput === false && opt.name === "json") return;
     command.option(opt.flag, opt.description);
   });
-  command.action(config.handler);
+  command.action(config2.handler);
 }
 function convertCliArgsToSdkParams(parameters, positionalArgs, options) {
   const sdkParams = {};
@@ -2235,6 +2245,581 @@ function convertValue(value, type, elementType) {
       return value;
   }
 }
+
+// src/login.ts
+var login_exports = {};
+__export(login_exports, {
+  AUTH_MODE_HEADER: () => AUTH_MODE_HEADER,
+  ZapierAuthenticationError: () => ZapierAuthenticationError,
+  createCache: () => createCache,
+  getAuthAuthorizeUrl: () => getAuthAuthorizeUrl,
+  getAuthTokenUrl: () => getAuthTokenUrl,
+  getConfig: () => getConfig,
+  getConfigPath: () => getConfigPath,
+  getLoggedInUser: () => getLoggedInUser,
+  getLoginStorageMode: () => getLoginStorageMode,
+  getPkceLoginConfig: () => getPkceLoginConfig,
+  getToken: () => getToken,
+  logout: () => logout,
+  unloadConfig: () => unloadConfig,
+  updateLogin: () => updateLogin
+});
+var SERVICE = "zapier-sdk-cli";
+var ACCOUNT = "login";
+var cachedBackendInfo;
+async function getBackendInfo() {
+  if (!cachedBackendInfo) {
+    const keyring = await crossKeychain.getKeyring();
+    cachedBackendInfo = `${keyring.name} (${keyring.id})`;
+  }
+  return cachedBackendInfo;
+}
+var keychainQueue = Promise.resolve();
+function enqueue(fn) {
+  const result = keychainQueue.then(fn, fn);
+  keychainQueue = result.then(
+    () => {
+    },
+    () => {
+    }
+  );
+  return result;
+}
+async function getTokensFromKeychain({
+  debugLog
+} = {}) {
+  return enqueue(async () => {
+    const backendInfo = await getBackendInfo();
+    debugLog?.(`Keychain read via ${backendInfo}`);
+    const startTime = Date.now();
+    const raw = await crossKeychain.getPassword(SERVICE, ACCOUNT);
+    debugLog?.(`Keychain read completed in ${Date.now() - startTime}ms`);
+    if (!raw) {
+      debugLog?.("Keychain returned no data");
+      return void 0;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      debugLog?.("Keychain data is not valid JSON");
+      return void 0;
+    }
+    if (typeof parsed.login_jwt === "string" && typeof parsed.login_refresh_token === "string") {
+      return {
+        login_jwt: parsed.login_jwt,
+        login_refresh_token: parsed.login_refresh_token
+      };
+    }
+    debugLog?.("Keychain data has invalid shape", parsed);
+    return void 0;
+  });
+}
+async function setTokensInKeychain({
+  data,
+  debugLog
+}) {
+  return enqueue(async () => {
+    const backendInfo = await getBackendInfo();
+    debugLog?.(`Keychain write via ${backendInfo}`);
+    const startTime = Date.now();
+    await crossKeychain.setPassword(SERVICE, ACCOUNT, JSON.stringify(data));
+    debugLog?.(`Keychain write completed in ${Date.now() - startTime}ms`);
+  });
+}
+async function clearTokensFromKeychain({
+  debugLog
+} = {}) {
+  return enqueue(async () => {
+    try {
+      const backendInfo = await getBackendInfo();
+      debugLog?.(`Keychain clear via ${backendInfo}`);
+      await crossKeychain.deletePassword(SERVICE, ACCOUNT);
+    } catch {
+    }
+  });
+}
+var SERVICE2 = "zapier-sdk-cache";
+var CONFIG_KEY = "cache";
+var LOCK_UPDATE_MS = 5e3;
+var LOCK_STALE_MS = 1e4;
+var LOCK_RETRY_WAIT_MS = 100;
+var LOCK_RETRY_MAX_WAIT_MS = 1e3;
+var LOCK_RETRY_COUNT = 120;
+function keychainAccount(key) {
+  return crypto.createHash("sha256").update(key).digest("hex");
+}
+function readConfigMap() {
+  const cfg = getConfig();
+  const stored = cfg.get(CONFIG_KEY);
+  if (stored && typeof stored === "object") {
+    return stored;
+  }
+  return {};
+}
+function writeConfigMap(map) {
+  getConfig().set(CONFIG_KEY, map);
+}
+function entryIsExpired(entry) {
+  return entry.expires_at !== void 0 && entry.expires_at <= Date.now();
+}
+function createCache() {
+  return {
+    async get(key) {
+      const entry = readConfigMap()[key];
+      if (!entry) return void 0;
+      if (entryIsExpired(entry)) return void 0;
+      if (entry.secret) {
+        const stored = await enqueue(async () => {
+          await getBackendInfo();
+          return crossKeychain.getPassword(SERVICE2, keychainAccount(key));
+        });
+        if (!stored) {
+          return void 0;
+        }
+        return { value: stored, expiresAt: entry.expires_at };
+      }
+      if (entry.value === void 0) return void 0;
+      return { value: entry.value, expiresAt: entry.expires_at };
+    },
+    async set(key, value, options) {
+      const secret = options?.secret ?? false;
+      const expiresAt = options?.ttl ? Date.now() + options.ttl * 1e3 : void 0;
+      if (secret) {
+        try {
+          await enqueue(async () => {
+            await getBackendInfo();
+            await crossKeychain.setPassword(SERVICE2, keychainAccount(key), value);
+          });
+        } catch {
+          return;
+        }
+        const map = readConfigMap();
+        map[key] = { secret: true, expires_at: expiresAt };
+        try {
+          writeConfigMap(map);
+        } catch {
+        }
+      } else {
+        const map = readConfigMap();
+        map[key] = { secret: false, value, expires_at: expiresAt };
+        try {
+          writeConfigMap(map);
+        } catch {
+        }
+      }
+    },
+    async delete(key) {
+      const map = readConfigMap();
+      const entry = map[key];
+      if (entry) {
+        delete map[key];
+        try {
+          writeConfigMap(map);
+        } catch {
+        }
+      }
+      if (entry?.secret) {
+        try {
+          await enqueue(async () => {
+            await getBackendInfo();
+            await crossKeychain.deletePassword(SERVICE2, keychainAccount(key));
+          });
+        } catch {
+        }
+      }
+    },
+    async withLock(_key, fn) {
+      const cfg = getConfig();
+      const lockTarget = `${cfg.path}.cache-lock`;
+      try {
+        fs.mkdirSync(path.dirname(lockTarget), { recursive: true });
+        if (!fs.existsSync(lockTarget)) {
+          fs.writeFileSync(lockTarget, "");
+        }
+      } catch {
+        return fn();
+      }
+      let release = null;
+      try {
+        release = await lockfile__namespace.lock(lockTarget, {
+          stale: LOCK_STALE_MS,
+          update: LOCK_UPDATE_MS,
+          retries: {
+            retries: LOCK_RETRY_COUNT,
+            factor: 1.2,
+            minTimeout: LOCK_RETRY_WAIT_MS,
+            maxTimeout: LOCK_RETRY_MAX_WAIT_MS
+          }
+        });
+      } catch {
+        return fn();
+      }
+      try {
+        return await fn();
+      } finally {
+        try {
+          await release();
+        } catch {
+        }
+      }
+    }
+  };
+}
+
+// src/login/index.ts
+var ZapierAuthenticationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ZapierAuthenticationError";
+  }
+};
+var config = null;
+var DEFAULT_AUTH_CLIENT_ID = "grwWZD5hUWGvb4V8ODBuOtXer3h0DBEZ2HR8aay6";
+var TOKEN_REFRESH_BUFFER_MS = 5 * 60 * 1e3;
+function createDebugLog(enabled) {
+  if (!enabled) {
+    return () => {
+    };
+  }
+  return (message, data) => {
+    if (data === void 0) {
+      console.log(`[Zapier SDK CLI Login] ${message}`);
+    } else {
+      console.log(`[Zapier SDK CLI Login] ${message}`, data);
+    }
+  };
+}
+function censorHeaderValue(value) {
+  if (value.length > 12) {
+    return `${value.substring(0, 4)}...${value.substring(value.length - 4)}`;
+  }
+  return `${value.charAt(0)}...`;
+}
+function getAuthClientId(clientId) {
+  return clientId || DEFAULT_AUTH_CLIENT_ID;
+}
+var AUTH_MODE_HEADER = "X-Auth";
+var DEFAULT_AUTH_BASE_URL = "https://zapier.com";
+function getAuthTokenUrl(options) {
+  const authBaseUrl = options?.baseUrl || DEFAULT_AUTH_BASE_URL;
+  return `${authBaseUrl}/oauth/token/`;
+}
+function getAuthAuthorizeUrl(options) {
+  const authBaseUrl = options?.baseUrl || DEFAULT_AUTH_BASE_URL;
+  return `${authBaseUrl}/oauth/authorize/`;
+}
+function getPkceLoginConfig(options) {
+  return {
+    clientId: getAuthClientId(options?.credentials?.clientId),
+    tokenUrl: getAuthTokenUrl({ baseUrl: options?.credentials?.baseUrl }),
+    authorizeUrl: getAuthAuthorizeUrl({
+      baseUrl: options?.credentials?.baseUrl
+    })
+  };
+}
+var cachedLogin;
+function getConfig() {
+  if (!config) {
+    config = new Conf__default.default({ projectName: "zapier-sdk-cli" });
+    if (!config.has("login_storage_mode")) {
+      config.set(
+        "login_storage_mode",
+        fs.existsSync(config.path) ? "config" : "keychain"
+      );
+    }
+  }
+  return config;
+}
+function unloadConfig() {
+  config = null;
+  cachedLogin = void 0;
+}
+async function updateLogin(loginData, options = {}) {
+  const debugLog = createDebugLog(options.debug ?? false);
+  const storage = options.storage ?? cachedLogin?.storage ?? "keychain";
+  const expiresAt = Date.now() + loginData.expires_in * 1e3;
+  const cfg = getConfig();
+  cfg.set("login_storage_mode", storage);
+  if (storage === "keychain") {
+    await setTokensInKeychain({
+      data: {
+        login_jwt: loginData.access_token,
+        login_refresh_token: loginData.refresh_token
+      },
+      debugLog
+    });
+    cfg.set("login_expires_at", expiresAt);
+    cfg.delete("login_jwt");
+    cfg.delete("login_refresh_token");
+  } else {
+    cfg.set("login_jwt", loginData.access_token);
+    cfg.set("login_refresh_token", loginData.refresh_token);
+    cfg.set("login_expires_at", expiresAt);
+    await clearTokensFromKeychain({ debugLog });
+  }
+  cachedLogin = {
+    jwt: loginData.access_token,
+    refreshToken: loginData.refresh_token,
+    expiresAt,
+    storage
+  };
+}
+function decodeJwtOrThrow(token) {
+  if (typeof token !== "string") {
+    throw new Error("Expected JWT to be a string");
+  }
+  const decodedJwt = jwt__namespace.decode(token, { complete: true });
+  if (!decodedJwt) {
+    throw new Error("Could not decode JWT");
+  }
+  if (typeof decodedJwt.payload === "string") {
+    throw new Error("Did not expect JWT payload to be a string");
+  }
+  return decodedJwt;
+}
+async function refreshJwt(refreshToken, options = {}) {
+  const {
+    onEvent,
+    fetch: fetch2 = globalThis.fetch,
+    credentials: credentials2,
+    debug = false
+  } = options;
+  const debugLog = createDebugLog(debug);
+  const tokenUrl = getAuthTokenUrl({ baseUrl: credentials2?.baseUrl });
+  const clientId = getAuthClientId(credentials2?.clientId);
+  const startTime = Date.now();
+  try {
+    onEvent?.({
+      type: "auth_refreshing",
+      payload: {
+        message: "Refreshing your token...",
+        operation: "token_refresh"
+      },
+      timestamp: Date.now()
+    });
+    debugLog(`\u2192 POST ${tokenUrl}`, {
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        [AUTH_MODE_HEADER]: "no"
+      },
+      body: {
+        client_id: clientId,
+        refresh_token: censorHeaderValue(refreshToken),
+        grant_type: "refresh_token"
+      }
+    });
+    const response = await fetch2(tokenUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        [AUTH_MODE_HEADER]: "no"
+      },
+      body: new URLSearchParams({
+        client_id: clientId,
+        refresh_token: refreshToken,
+        grant_type: "refresh_token"
+      })
+    });
+    const duration = Date.now() - startTime;
+    if (!response.ok) {
+      debugLog(`\u2190 ${response.status} ${response.statusText} (${duration}ms)`);
+      throw new Error(
+        `Token refresh failed: ${response.status} ${response.statusText}`
+      );
+    }
+    debugLog(`\u2190 ${response.status} ${response.statusText} (${duration}ms)`);
+    const data = await response.json();
+    await updateLogin(data, { debug });
+    debugLog(
+      `Token refreshed and saved to ${cachedLogin?.storage ?? "keychain"}`
+    );
+    onEvent?.({
+      type: "auth_success",
+      payload: {
+        message: "Token refreshed successfully",
+        operation: "token_refresh"
+      },
+      timestamp: Date.now()
+    });
+    return data.access_token;
+  } catch (error) {
+    const duration = Date.now() - startTime;
+    debugLog(`\u2716 Token refresh failed (${duration}ms)`, {
+      error: error instanceof Error ? error.message : error
+    });
+    cachedLogin = void 0;
+    const errorMessage = `Token refresh failed: ${error instanceof Error ? error.message : "Unknown error"}`;
+    onEvent?.({
+      type: "auth_error",
+      payload: {
+        message: errorMessage,
+        error: errorMessage,
+        operation: "token_refresh"
+      },
+      timestamp: Date.now()
+    });
+    throw error;
+  }
+}
+var pendingRefresh = null;
+var pendingResolve = null;
+async function resolveStoredLogin(debugLog) {
+  if (cachedLogin) {
+    debugLog("Using in-memory cached credentials");
+    return cachedLogin;
+  }
+  if (pendingResolve) {
+    debugLog("Waiting for existing keychain read to complete");
+    return pendingResolve;
+  }
+  pendingResolve = resolveStoredLoginFromStorage(debugLog).finally(() => {
+    pendingResolve = null;
+  });
+  return pendingResolve;
+}
+async function resolveStoredLoginFromStorage(debugLog) {
+  let cfg;
+  try {
+    cfg = getConfig();
+  } catch (error) {
+    debugLog("Failed to load config", {
+      error: error instanceof Error ? error.message : error
+    });
+    return void 0;
+  }
+  const expiresAt = cfg.get("login_expires_at");
+  const configJwt = cfg.get("login_jwt");
+  const configRefresh = cfg.get("login_refresh_token");
+  if (configJwt && configRefresh && typeof expiresAt === "number") {
+    debugLog("Loaded credentials from config (legacy format)");
+    cachedLogin = {
+      jwt: configJwt,
+      refreshToken: configRefresh,
+      expiresAt,
+      storage: "config"
+    };
+    return cachedLogin;
+  }
+  if (typeof expiresAt !== "number") {
+    debugLog("No stored login credentials found");
+    return void 0;
+  }
+  const keychainData = await getTokensFromKeychain({ debugLog });
+  if (!keychainData) {
+    debugLog("No tokens found in keychain");
+    return void 0;
+  }
+  debugLog("Loaded credentials from keychain");
+  cachedLogin = {
+    jwt: keychainData.login_jwt,
+    refreshToken: keychainData.login_refresh_token,
+    expiresAt,
+    storage: "keychain"
+  };
+  return cachedLogin;
+}
+async function resolveOrRefreshToken(options = {}) {
+  const { debug = false } = options;
+  const debugLog = createDebugLog(debug);
+  const stored = await resolveStoredLogin(debugLog);
+  if (!stored) {
+    return void 0;
+  }
+  const { jwt: storedJwt, refreshToken, expiresAt } = stored;
+  if (expiresAt > Date.now() + TOKEN_REFRESH_BUFFER_MS) {
+    debugLog("Using cached token (still valid)");
+    return storedJwt;
+  }
+  debugLog("Token expired, refreshing...");
+  if (pendingRefresh) {
+    debugLog("Waiting for existing refresh to complete");
+    return pendingRefresh;
+  }
+  pendingRefresh = refreshJwt(refreshToken, options).finally(() => {
+    pendingRefresh = null;
+  });
+  return await pendingRefresh;
+}
+async function getToken(options = {}) {
+  try {
+    return await resolveOrRefreshToken(options);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Token refresh failed";
+    throw new ZapierAuthenticationError(
+      `${message}
+Please run 'login' to authenticate again.`
+    );
+  }
+}
+async function getLoggedInUser(options = {}) {
+  const jwt2 = await getToken(options).catch(() => void 0);
+  if (!jwt2) {
+    throw new Error(
+      "No valid authentication token available. Please login first."
+    );
+  }
+  let decodedJwt = decodeJwtOrThrow(jwt2);
+  if (decodedJwt.payload["sub_type"] == "service") {
+    decodedJwt = decodeJwtOrThrow(decodedJwt.payload["njwt"]);
+  }
+  if (typeof decodedJwt.payload["zap:acc"] !== "string") {
+    throw new Error("JWT payload does not contain accountId");
+  }
+  const accountId = parseInt(decodedJwt.payload["zap:acc"], 10);
+  if (isNaN(accountId)) {
+    throw new Error("JWT accountId is not a number");
+  }
+  if (decodedJwt.payload["sub_type"] !== "customuser" || typeof decodedJwt.payload["sub"] !== "string") {
+    throw new Error("JWT payload does not contain customUserId");
+  }
+  const customUserId = parseInt(decodedJwt.payload["sub"], 10);
+  if (isNaN(customUserId)) {
+    throw new Error("JWT customUserId is not a number");
+  }
+  const email = decodedJwt.payload["zap:uname"];
+  if (typeof email !== "string") {
+    throw new Error("JWT payload does not contain email");
+  }
+  return {
+    accountId,
+    customUserId,
+    email
+  };
+}
+function getLoginStorageMode() {
+  const cfg = getConfig();
+  if (typeof cfg.get("login_jwt") === "string") {
+    return "config";
+  }
+  const explicitMode = cfg.get("login_storage_mode");
+  if (explicitMode === "keychain" || explicitMode === "config") {
+    return explicitMode;
+  }
+  return "keychain";
+}
+async function logout(options = {}) {
+  const { onEvent } = options;
+  const mode = getLoginStorageMode();
+  cachedLogin = void 0;
+  await clearTokensFromKeychain();
+  const cfg = getConfig();
+  cfg.set("login_storage_mode", mode);
+  cfg.delete("login_expires_at");
+  cfg.delete("login_jwt");
+  cfg.delete("login_refresh_token");
+  onEvent?.({
+    type: "auth_logout",
+    payload: { message: "Logged out successfully", operation: "logout" },
+    timestamp: Date.now()
+  });
+}
+function getConfigPath() {
+  const cfg = getConfig();
+  return cfg.path;
+}
+
+// src/utils/constants.ts
 var LOGIN_PORTS = [49505, 50575, 52804, 55981, 61010, 63851];
 var LOGIN_TIMEOUT_MS = 3e5;
 var spinPromise = async (promise, text) => {
@@ -2368,13 +2953,13 @@ var login = async ({
   timeoutMs = LOGIN_TIMEOUT_MS,
   credentials: credentials2
 }) => {
-  const { clientId, tokenUrl, authorizeUrl } = cliLogin.getPkceLoginConfig({
+  const { clientId, tokenUrl, authorizeUrl } = getPkceLoginConfig({
     credentials: credentials2
   });
   const scope = ensureOfflineAccess(
     credentials2?.scope || "internal credentials"
   );
-  await cliLogin.logout();
+  await logout();
   const availablePort = await findAvailablePort();
   const redirectUri = `http://localhost:${availablePort}/oauth`;
   log_default.info(`Using port ${availablePort} for OAuth callback`);
@@ -2462,13 +3047,13 @@ var login = async ({
     },
     {
       headers: {
-        [cliLogin.AUTH_MODE_HEADER]: "no",
+        [AUTH_MODE_HEADER]: "no",
         "Content-Type": "application/x-www-form-urlencoded"
       }
     }
   );
   let targetStorage;
-  if (cliLogin.getLoginStorageMode() === "config") {
+  if (getLoginStorageMode() === "config") {
     const { upgrade } = await inquirer__default.default.prompt([
       {
         type: "confirm",
@@ -2482,13 +3067,13 @@ var login = async ({
     targetStorage = "keychain";
   }
   try {
-    await cliLogin.updateLogin(data, { storage: targetStorage });
+    await updateLogin(data, { storage: targetStorage });
   } catch (err) {
     if (targetStorage === "keychain") {
       log_default.warn(
-        `Could not store credentials in system keychain. Storing in plaintext at ${cliLogin.getConfigPath()}.`
+        `Could not store credentials in system keychain. Storing in plaintext at ${getConfigPath()}.`
       );
-      await cliLogin.updateLogin(data, { storage: "config" });
+      await updateLogin(data, { storage: "config" });
     } else {
       throw err;
     }
@@ -2525,7 +3110,7 @@ var loginPlugin = (sdk2) => {
       timeoutMs: timeoutSeconds * 1e3,
       credentials: pkceCredentials
     });
-    const user = await cliLogin.getLoggedInUser();
+    const user = await getLoggedInUser();
     sdk2.context.eventEmission.emit(
       "platform.sdk.ApplicationLifecycleEvent",
       zapierSdk.buildApplicationLifecycleEvent(
@@ -2552,7 +3137,7 @@ var LogoutSchema = zod.z.object({}).describe("Log out of your Zapier account");
 
 // src/plugins/logout/index.ts
 var logoutWithSdk = zapierSdk.createFunction(async function logoutWithSdk2(_options) {
-  await cliLogin.logout();
+  await logout();
   console.log("\u2705 Successfully logged out");
 }, LogoutSchema);
 var logoutPlugin = () => ({
@@ -2687,7 +3272,7 @@ var GetLoginConfigPathSchema = zod.z.object({}).describe("Show the path to the l
 var getLoginConfigPathPlugin = () => {
   const getLoginConfigPathWithSdk = zapierSdk.createFunction(
     async function getLoginConfigPathWithSdk2(_options) {
-      return cliLogin.getConfigPath();
+      return getConfigPath();
     },
     GetLoginConfigPathSchema
   );
@@ -3716,7 +4301,7 @@ async function postWithRetry({
 var feedbackPlugin = (sdk2) => {
   const debug = sdk2.context.options?.debug;
   const feedbackWithSdk = zapierSdk.createFunction(async function feedback(options) {
-    const user = await cliLogin.getLoggedInUser();
+    const user = await getLoggedInUser();
     const body = JSON.stringify({
       email: user.email,
       customuser_id: user.customUserId,
@@ -4688,10 +5273,10 @@ var initPlugin = () => {
 // package.json with { type: 'json' }
 var package_default2 = {
   name: "@zapier/zapier-sdk-cli",
-  version: "0.42.1"};
+  version: "0.43.0"};
 
 // src/sdk.ts
-zapierSdk.injectCliLogin(cliLogin__namespace);
+zapierSdk.injectCliLogin(login_exports);
 function createZapierCliSdk(options = {}) {
   return zapierSdk.createZapierSdk({
     ...options,
@@ -4710,14 +5295,14 @@ var CACHE_RESET_INTERVAL_MS = (() => {
 })();
 function getVersionCache() {
   try {
-    const cache = cliLogin.getConfig().get("version_cache");
+    const cache = getConfig().get("version_cache");
     const now = Date.now();
     if (!cache || !cache.last_reset_timestamp || now - cache.last_reset_timestamp >= CACHE_RESET_INTERVAL_MS) {
       const newCache = {
         last_reset_timestamp: now,
         packages: {}
       };
-      cliLogin.getConfig().set("version_cache", newCache);
+      getConfig().set("version_cache", newCache);
       return newCache;
     }
     return cache;
@@ -4736,7 +5321,7 @@ function setCachedPackageInfo(packageName, version, info) {
       cache.packages[packageName] = {};
     }
     cache.packages[packageName][version] = info;
-    cliLogin.getConfig().set("version_cache", cache);
+    getConfig().set("version_cache", cache);
   } catch (error) {
     log_default.debug(`Failed to cache package info: ${error}`);
   }