@zapier/zapier-sdk-cli 0.42.2 → 0.43.0

package/dist/src/login/index.js

@@ -0,0 +1,442 @@
+/**
+ * Zapier SDK CLI Login Package
+ *
+ * Handles login, logout, token cache and refresh for Zapier SDK CLI.
+ * Provides getToken function that can be optionally imported by zapier-sdk.
+ */
+import Conf from "conf";
+import { existsSync } from "fs";
+import * as jwt from "jsonwebtoken";
+import { getTokensFromKeychain, setTokensInKeychain, clearTokensFromKeychain, } from "./keychain";
+export { createCache } from "./filesystem-cache";
+/**
+ * Authentication error for token refresh failures.
+ * This is a standalone clone of ZapierAuthenticationError from the SDK.
+ * We can't import from SDK because cli-login must remain a standalone package
+ * with no SDK dependencies. The SDK recognizes this error by name.
+ */
+export class ZapierAuthenticationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ZapierAuthenticationError";
+    }
+}
+let config = null;
+// Default OAuth client ID
+const DEFAULT_AUTH_CLIENT_ID = "grwWZD5hUWGvb4V8ODBuOtXer3h0DBEZ2HR8aay6";
+// Buffer time before token expiration to trigger refresh (5 minutes)
+const TOKEN_REFRESH_BUFFER_MS = 5 * 60 * 1000;
+/**
+ * Creates a debug logger function.
+ * Returns a no-op function when debug is disabled.
+ */
+function createDebugLog(enabled) {
+    if (!enabled) {
+        return () => { };
+    }
+    return (message, data) => {
+        if (data === undefined) {
+            console.log(`[Zapier SDK CLI Login] ${message}`);
+        }
+        else {
+            console.log(`[Zapier SDK CLI Login] ${message}`, data);
+        }
+    };
+}
+/**
+ * Censors sensitive values in headers for debug logging.
+ */
+function censorHeaderValue(value) {
+    if (value.length > 12) {
+        return `${value.substring(0, 4)}...${value.substring(value.length - 4)}`;
+    }
+    return `${value.charAt(0)}...`;
+}
+// Get auth client ID - uses passed value or falls back to default.
+// Env var resolution is handled by the SDK before calling cli-login.
+function getAuthClientId(clientId) {
+    return clientId || DEFAULT_AUTH_CLIENT_ID;
+}
+export const AUTH_MODE_HEADER = "X-Auth";
+// Default auth base URL
+const DEFAULT_AUTH_BASE_URL = "https://zapier.com";
+/**
+ * Gets the OAuth token endpoint URL.
+ * baseUrl should be the auth base URL (e.g., https://zapier.com), already resolved by SDK.
+ */
+export function getAuthTokenUrl(options) {
+    const authBaseUrl = options?.baseUrl || DEFAULT_AUTH_BASE_URL;
+    return `${authBaseUrl}/oauth/token/`;
+}
+/**
+ * Gets the OAuth authorization endpoint URL.
+ * baseUrl should be the auth base URL (e.g., https://zapier.com), already resolved by SDK.
+ */
+export function getAuthAuthorizeUrl(options) {
+    const authBaseUrl = options?.baseUrl || DEFAULT_AUTH_BASE_URL;
+    return `${authBaseUrl}/oauth/authorize/`;
+}
+/**
+ * Gets all configuration needed for the PKCE login flow.
+ * Credentials should have baseUrl already resolved by SDK.
+ */
+export function getPkceLoginConfig(options) {
+    return {
+        clientId: getAuthClientId(options?.credentials?.clientId),
+        tokenUrl: getAuthTokenUrl({ baseUrl: options?.credentials?.baseUrl }),
+        authorizeUrl: getAuthAuthorizeUrl({
+            baseUrl: options?.credentials?.baseUrl,
+        }),
+    };
+}
+let cachedLogin;
+export function getConfig() {
+    if (!config) {
+        // Conf does not create the file until the first set() call.
+        config = new Conf({ projectName: "zapier-sdk-cli" });
+        // If the config file already exists but has no cache mode marker, an older
+        // SDK version created it. Set the marker to "config" so the login flow will
+        // prompt the user to upgrade to keychain cache. Otherwise, stamp "keychain"
+        // so that any future writes to the config don't leave it unmarked.
+        if (!config.has("login_storage_mode")) {
+            config.set("login_storage_mode", existsSync(config.path) ? "config" : "keychain");
+        }
+    }
+    return config;
+}
+/**
+ * Drops the cached Conf instance so the next getConfig() call re-initializes
+ * from disk (including re-running the pre-existing file detection).
+ */
+export function unloadConfig() {
+    config = null;
+    cachedLogin = undefined;
+}
+export 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 * 1000;
+    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,
+    };
+}
+// JWT utility functions
+function decodeJwtOrThrow(token) {
+    if (typeof token !== "string") {
+        throw new Error("Expected JWT to be a string");
+    }
+    const decodedJwt = jwt.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;
+}
+/**
+ * Refreshes an expired JWT token using the refresh token.
+ * Returns the new access token or throws an error.
+ */
+async function refreshJwt(refreshToken, options = {}) {
+    const { onEvent, fetch = globalThis.fetch, credentials, debug = false, } = options;
+    const debugLog = createDebugLog(debug);
+    const tokenUrl = getAuthTokenUrl({ baseUrl: credentials?.baseUrl });
+    const clientId = getAuthClientId(credentials?.clientId);
+    const startTime = Date.now();
+    try {
+        onEvent?.({
+            type: "auth_refreshing",
+            payload: {
+                message: "Refreshing your token...",
+                operation: "token_refresh",
+            },
+            timestamp: Date.now(),
+        });
+        debugLog(`→ 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 fetch(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(`← ${response.status} ${response.statusText} (${duration}ms)`);
+            throw new Error(`Token refresh failed: ${response.status} ${response.statusText}`);
+        }
+        debugLog(`← ${response.status} ${response.statusText} (${duration}ms)`);
+        const data = await response.json();
+        // Update stored login data
+        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(`✖ Token refresh failed (${duration}ms)`, {
+            error: error instanceof Error ? error.message : error,
+        });
+        // Clear in-memory cache so the next call re-reads from cache.
+        // Another process may have refreshed successfully in the meantime.
+        cachedLogin = undefined;
+        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;
+    }
+}
+/**
+ * In-flight refresh promise to prevent duplicate concurrent refreshes.
+ * Only one refresh can be in progress at a time within a single process.
+ */
+let pendingRefresh = null;
+let pendingResolve = null;
+/**
+ * Resolves stored login credentials from keychain or config.
+ * Caches the result in memory so the keychain is only read once per process.
+ * Deduplicates concurrent calls so only one keychain read is in flight at a time.
+ */
+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 undefined;
+    }
+    const expiresAt = cfg.get("login_expires_at");
+    // Check for legacy config-only login (all three keys present)
+    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 undefined;
+    }
+    // expires_at exists without config tokens — read from keychain
+    const keychainData = await getTokensFromKeychain({ debugLog });
+    if (!keychainData) {
+        debugLog("No tokens found in keychain");
+        return undefined;
+    }
+    debugLog("Loaded credentials from keychain");
+    cachedLogin = {
+        jwt: keychainData.login_jwt,
+        refreshToken: keychainData.login_refresh_token,
+        expiresAt,
+        storage: "keychain",
+    };
+    return cachedLogin;
+}
+/**
+ * Resolves a valid token, refreshing if expired. Returns undefined if no
+ * stored login exists. Throws on refresh failure.
+ */
+async function resolveOrRefreshToken(options = {}) {
+    const { debug = false } = options;
+    const debugLog = createDebugLog(debug);
+    const stored = await resolveStoredLogin(debugLog);
+    if (!stored) {
+        return undefined;
+    }
+    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;
+}
+/**
+ * Main function exported for zapier-sdk to optionally use.
+ * Returns the stored token from CLI configuration (with auto-refresh).
+ *
+ * Note: Environment variable handling (ZAPIER_CREDENTIALS, ZAPIER_TOKEN)
+ * is done by the SDK before calling this function.
+ *
+ * Returns undefined if no valid token is found.
+ */
+export 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}\nPlease run 'login' to authenticate again.`);
+    }
+}
+/**
+ * Gets the logged-in user information from JWT token.
+ * Automatically refreshes token if expired.
+ */
+export async function getLoggedInUser(options = {}) {
+    const jwt = await getToken(options).catch(() => undefined);
+    if (!jwt) {
+        throw new Error("No valid authentication token available. Please login first.");
+    }
+    let decodedJwt = decodeJwtOrThrow(jwt);
+    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,
+    };
+}
+/**
+ * Checks config to determine current cache mode without reading keychain.
+ * Credential keys in config are ground truth — if login_jwt exists, we're in
+ * config mode regardless of the marker. The marker only matters when no
+ * credential keys are present (e.g. after logout or when using keychain).
+ */
+export function getLoginStorageMode() {
+    const cfg = getConfig();
+    // Config tokens are ground truth — overrides any marker
+    if (typeof cfg.get("login_jwt") === "string") {
+        return "config";
+    }
+    // No config tokens — use the explicit marker (set by getConfig on init or
+    // by updateLogin on write)
+    const explicitMode = cfg.get("login_storage_mode");
+    if (explicitMode === "keychain" || explicitMode === "config") {
+        return explicitMode;
+    }
+    return "keychain";
+}
+/**
+ * Clears stored login information.
+ */
+export async function logout(options = {}) {
+    const { onEvent } = options;
+    // Snapshot the cache mode before clearing tokens, so the marker survives
+    // logout. Without this, an old-SDK config login would lose its "config"
+    // signal once login_jwt is deleted.
+    const mode = getLoginStorageMode();
+    cachedLogin = undefined;
+    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(),
+    });
+}
+/**
+ * Gets the path to the configuration file.
+ */
+export function getConfigPath() {
+    const cfg = getConfig();
+    return cfg.path;
+}

package/dist/src/login/keychain.d.ts

@@ -0,0 +1,18 @@
+export interface StoredTokens {
+    login_jwt: string;
+    login_refresh_token: string;
+}
+type DebugLog = (message: string, data?: unknown) => void;
+export declare function getBackendInfo(): Promise<string>;
+export declare function enqueue<T>(fn: () => Promise<T>): Promise<T>;
+export declare function getTokensFromKeychain({ debugLog, }?: {
+    debugLog?: DebugLog;
+}): Promise<StoredTokens | undefined>;
+export declare function setTokensInKeychain({ data, debugLog, }: {
+    data: StoredTokens;
+    debugLog?: DebugLog;
+}): Promise<void>;
+export declare function clearTokensFromKeychain({ debugLog, }?: {
+    debugLog?: DebugLog;
+}): Promise<void>;
+export {};

package/dist/src/login/keychain.js

@@ -0,0 +1,74 @@
+import { getPassword, setPassword, deletePassword, getKeyring, } from "cross-keychain";
+const SERVICE = "zapier-sdk-cli";
+const ACCOUNT = "login";
+let cachedBackendInfo;
+export async function getBackendInfo() {
+    if (!cachedBackendInfo) {
+        const keyring = await getKeyring();
+        cachedBackendInfo = `${keyring.name} (${keyring.id})`;
+    }
+    return cachedBackendInfo;
+}
+// Serialize all keychain operations so concurrent reads and writes never
+// overlap. Mostly, this is to ensure we don't try to read user info while
+// in the middle of a logout. We don't really need to make reads serial, but
+// we cache those elsewhere anyway, so we use a simple serial queue.
+let keychainQueue = Promise.resolve();
+export function enqueue(fn) {
+    // fn is passed as both fulfillment and rejection handler so a failed
+    // operation never blocks subsequent ones from running.
+    const result = keychainQueue.then(fn, fn);
+    keychainQueue = result.then(() => { }, () => { });
+    return result;
+}
+export async function getTokensFromKeychain({ debugLog, } = {}) {
+    return enqueue(async () => {
+        const backendInfo = await getBackendInfo();
+        debugLog?.(`Keychain read via ${backendInfo}`);
+        const startTime = Date.now();
+        const raw = await getPassword(SERVICE, ACCOUNT);
+        debugLog?.(`Keychain read completed in ${Date.now() - startTime}ms`);
+        if (!raw) {
+            debugLog?.("Keychain returned no data");
+            return undefined;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            debugLog?.("Keychain data is not valid JSON");
+            return undefined;
+        }
+        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 undefined;
+    });
+}
+export async function setTokensInKeychain({ data, debugLog, }) {
+    return enqueue(async () => {
+        const backendInfo = await getBackendInfo();
+        debugLog?.(`Keychain write via ${backendInfo}`);
+        const startTime = Date.now();
+        await setPassword(SERVICE, ACCOUNT, JSON.stringify(data));
+        debugLog?.(`Keychain write completed in ${Date.now() - startTime}ms`);
+    });
+}
+export async function clearTokensFromKeychain({ debugLog, } = {}) {
+    return enqueue(async () => {
+        try {
+            const backendInfo = await getBackendInfo();
+            debugLog?.(`Keychain clear via ${backendInfo}`);
+            await deletePassword(SERVICE, ACCOUNT);
+        }
+        catch {
+            // Best-effort: keychain may not have an entry or may be unavailable
+        }
+    });
+}

package/dist/src/login.d.ts

@@ -1 +1,10 @@
-export * from "@zapier/zapier-sdk-cli-login";
+/**
+ * Public entrypoint for CLI login + cache functionality.
+ *
+ * The SDK dynamically imports from here (via the `./login` export map)
+ * to find PKCE `getToken` and the default `createCache` provider.
+ * This package also hosts the implementation directly — there is no
+ * longer a separate @zapier/zapier-sdk-cli-login package.
+ */
+export * from "./login/index";
+export { createCache } from "./login/filesystem-cache";

package/dist/src/login.js

@@ -1 +1,10 @@
-export * from "@zapier/zapier-sdk-cli-login";
+/**
+ * Public entrypoint for CLI login + cache functionality.
+ *
+ * The SDK dynamically imports from here (via the `./login` export map)
+ * to find PKCE `getToken` and the default `createCache` provider.
+ * This package also hosts the implementation directly — there is no
+ * longer a separate @zapier/zapier-sdk-cli-login package.
+ */
+export * from "./login/index";
+export { createCache } from "./login/filesystem-cache";

package/dist/src/plugins/feedback/index.js

@@ -1,6 +1,6 @@
 import { FeedbackSchema } from "./schemas";
 import { createFunction } from "@zapier/zapier-sdk";
-import { getLoggedInUser } from "@zapier/zapier-sdk-cli-login";
+import { getLoggedInUser } from "../../login";
 const feedbackResolver = {
     type: "static",
     inputType: "text",

package/dist/src/plugins/getLoginConfigPath/index.js

@@ -1,6 +1,6 @@
 import { GetLoginConfigPathSchema, } from "./schemas";
 import { createFunction } from "@zapier/zapier-sdk";
-import { getConfigPath } from "@zapier/zapier-sdk-cli-login";
+import { getConfigPath } from "../../login";
 export const getLoginConfigPathPlugin = () => {
     const getLoginConfigPathWithSdk = createFunction(async function getLoginConfigPathWithSdk(_options) {
         return getConfigPath();

package/dist/src/plugins/login/index.js

@@ -1,6 +1,6 @@
 import { isCredentialsObject, buildApplicationLifecycleEvent, } from "@zapier/zapier-sdk";
 import login from "../../utils/auth/login";
-import { getLoggedInUser, } from "@zapier/zapier-sdk-cli-login";
+import { getLoggedInUser } from "../../login";
 import { LoginSchema } from "./schemas";
 function toPkceCredentials(credentials) {
     if (credentials &&

package/dist/src/plugins/logout/index.js

@@ -1,5 +1,5 @@
 import { createFunction } from "@zapier/zapier-sdk";
-import { logout } from "@zapier/zapier-sdk-cli-login";
+import { logout } from "../../login";
 import { LogoutSchema } from "./schemas";
 const logoutWithSdk = createFunction(async function logoutWithSdk(_options) {
     await logout();

package/dist/src/sdk.js

@@ -1,4 +1,4 @@
-import * as cliLogin from "@zapier/zapier-sdk-cli-login";
+import * as cliLogin from "./login";
 import { createZapierSdk, injectCliLogin, } from "@zapier/zapier-sdk";
 import { loginPlugin, logoutPlugin, mcpPlugin, bundleCodePlugin, getLoginConfigPathPlugin, addPlugin, generateAppTypesPlugin, buildManifestPlugin, feedbackPlugin, curlPlugin, cliOverridesPlugin, initPlugin, } from "./plugins/index";
 import packageJson from "../package.json" with { type: "json" };

package/dist/src/utils/auth/login.d.ts

@@ -1,4 +1,4 @@
-import { type PkceCredentials } from "@zapier/zapier-sdk-cli-login";
+import { type PkceCredentials } from "../../login";
 interface LoginOptions {
     timeoutMs?: number;
     credentials?: PkceCredentials;

package/dist/src/utils/auth/login.js

@@ -8,7 +8,7 @@ import log from "../log";
 import api from "../api/client";
 import getCallablePromise from "../getCallablePromise";
 import inquirer from "inquirer";
-import { updateLogin, logout, getPkceLoginConfig, getLoginStorageMode, getConfigPath, } from "@zapier/zapier-sdk-cli-login";
+import { updateLogin, logout, getPkceLoginConfig, getLoginStorageMode, getConfigPath, } from "../../login";
 import { ZapierCliUserCancellationError } from "../errors";
 const findAvailablePort = () => {
     return new Promise((resolve, reject) => {

package/dist/src/utils/constants.d.ts

@@ -1,3 +1,3 @@
-export { AUTH_MODE_HEADER } from "@zapier/zapier-sdk-cli-login";
+export { AUTH_MODE_HEADER } from "../login";
 export declare const LOGIN_PORTS: number[];
 export declare const LOGIN_TIMEOUT_MS = 300000;

package/dist/src/utils/constants.js

@@ -1,5 +1,5 @@
 // Import shared OAuth constants from login package
-export { AUTH_MODE_HEADER } from "@zapier/zapier-sdk-cli-login";
+export { AUTH_MODE_HEADER } from "../login";
 // CLI-specific constants
 export const LOGIN_PORTS = [49505, 50575, 52804, 55981, 61010, 63851];
 export const LOGIN_TIMEOUT_MS = 300000; // 5 minutes

package/dist/src/utils/version-checker.js

@@ -1,7 +1,7 @@
 import packageJsonLib from "package-json";
 import chalk from "chalk";
 import log from "./log";
-import { getConfig } from "@zapier/zapier-sdk-cli-login";
+import { getConfig } from "../login";
 import { getUpdateCommand } from "./package-manager-detector";
 import semver from "semver";
 const ONE_DAY_MS = 24 * 60 * 60 * 1000;