@zapier/zapier-sdk-cli 0.13.15 → 0.14.0

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

@@ -20,8 +20,6 @@ const loginWithSdk = createFunction(async (options) => {
     });
     const user = await getLoggedInUser();
     console.log(`✅ Successfully logged in as ${user.email}`);
-    // Force immediate exit to prevent hanging (especially in development with tsx)
-    setTimeout(() => process.exit(0), 100);
 });
 export const loginPlugin = ({ context }) => {
     // Wrap the login function to emit telemetry events

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

@@ -8,6 +8,7 @@ import log from "../log";
 import api from "../api/client";
 import getCallablePromise from "../getCallablePromise";
 import { updateLogin, logout, getAuthTokenUrl, getAuthAuthorizeUrl, } from "@zapier/zapier-sdk-cli-login";
+import { ZapierCliUserCancellationError } from "../errors";
 const findAvailablePort = () => {
     return new Promise((resolve, reject) => {
         let portIndex = 0;
@@ -55,7 +56,7 @@ const login = async ({ timeoutMs = LOGIN_TIMEOUT_MS, baseUrl, authBaseUrl, authC
     const availablePort = await findAvailablePort();
     const redirectUri = `http://localhost:${availablePort}/oauth`;
     log.info(`Using port ${availablePort} for OAuth callback`);
-    const { promise: promisedCode, resolve: setCode } = getCallablePromise();
+    const { promise: promisedCode, resolve: setCode, reject: rejectCode, } = getCallablePromise();
     const app = express();
     app.get("/oauth", (req, res) => {
         setCode(String(req.query.code));
@@ -74,7 +75,7 @@ const login = async ({ timeoutMs = LOGIN_TIMEOUT_MS, baseUrl, authBaseUrl, authC
     const cleanup = () => {
         server.close();
         log.info("\n❌ Login cancelled by user");
-        process.exit(0);
+        rejectCode(new ZapierCliUserCancellationError());
     };
     process.on("SIGINT", cleanup);
     process.on("SIGTERM", cleanup);

package/dist/src/utils/cli-generator.js

@@ -4,6 +4,7 @@ import { SchemaParameterResolver } from "./parameter-resolver";
 import { formatItemsFromSchema, formatJsonOutput } from "./schema-formatter";
 import chalk from "chalk";
 import inquirer from "inquirer";
+import { ZapierCliError, ZapierCliExitError } from "./errors";
 // ============================================================================
 // Schema Analysis
 // ============================================================================
@@ -254,22 +255,29 @@ function createCommandConfig(cliCommandName, functionInfo, sdk) {
                         console.error(chalk.yellow(`  • ${field}: ${errorObj?.message || "Unknown error"}`));
                     });
                     console.error("\n" + chalk.dim(`Use --help to see available options`));
+                    throw new ZapierCliExitError("Validation failed", 1);
                 }
                 catch {
-                    console.error(chalk.red("Error:"), error.message);
+                    console.error(chalk.red("Error:"), error instanceof Error ? error.message : String(error));
+                    throw new ZapierCliExitError(error instanceof Error ? error.message : String(error), 1);
                 }
             }
+            else if (error instanceof ZapierCliError) {
+                // Re-throw all CLI errors as-is
+                throw error;
+            }
             else if (error instanceof ZapierError) {
                 // Handle SDK errors with clean, user-friendly messages using our formatter
                 const formattedMessage = formatErrorMessage(error);
                 console.error(chalk.red("❌ Error:"), formattedMessage);
+                throw new ZapierCliExitError(formattedMessage, 1);
             }
             else {
                 // Handle other errors
                 const errorMessage = error instanceof Error ? error.message : "Unknown error";
                 console.error(chalk.red("❌ Error:"), errorMessage);
+                throw new ZapierCliExitError(errorMessage, 1);
             }
-            process.exit(1);
         }
     };
     return {

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

@@ -0,0 +1,16 @@
+import { ZapierError } from "@zapier/zapier-sdk";
+export declare abstract class ZapierCliError extends ZapierError {
+    abstract readonly exitCode: number;
+}
+export declare class ZapierCliUserCancellationError extends ZapierCliError {
+    readonly name = "ZapierCliUserCancellationError";
+    readonly code = "ZAPIER_CLI_USER_CANCELLATION";
+    readonly exitCode = 0;
+    constructor(message?: string);
+}
+export declare class ZapierCliExitError extends ZapierCliError {
+    readonly name = "ZapierCliExitError";
+    readonly code = "ZAPIER_CLI_EXIT";
+    readonly exitCode: number;
+    constructor(message: string, exitCode?: number);
+}

package/dist/src/utils/errors.js

@@ -0,0 +1,19 @@
+import { ZapierError } from "@zapier/zapier-sdk";
+export class ZapierCliError extends ZapierError {
+}
+export class ZapierCliUserCancellationError extends ZapierCliError {
+    constructor(message = "Operation cancelled by user") {
+        super(message);
+        this.name = "ZapierCliUserCancellationError";
+        this.code = "ZAPIER_CLI_USER_CANCELLATION";
+        this.exitCode = 0;
+    }
+}
+export class ZapierCliExitError extends ZapierCliError {
+    constructor(message, exitCode = 1) {
+        super(message);
+        this.name = "ZapierCliExitError";
+        this.code = "ZAPIER_CLI_EXIT";
+        this.exitCode = exitCode;
+    }
+}

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

@@ -3,5 +3,6 @@ declare const log: {
     error: (message: string, ...args: unknown[]) => void;
     success: (message: string, ...args: unknown[]) => void;
     warn: (message: string, ...args: unknown[]) => void;
+    debug: (message: string, ...args: unknown[]) => void;
 };
 export default log;

package/dist/src/utils/log.js

@@ -12,5 +12,10 @@ const log = {
     warn: (message, ...args) => {
         console.log(chalk.yellow("⚠"), message, ...args);
     },
+    debug: (message, ...args) => {
+        if (process.env.DEBUG === "true" || process.argv.includes("--debug")) {
+            console.log(chalk.gray("🐛"), message, ...args);
+        }
+    },
 };
 export default log;

package/dist/src/utils/package-manager-detector.d.ts

@@ -0,0 +1,16 @@
+export interface PackageManagerInfo {
+    name: "npm" | "yarn" | "pnpm" | "bun" | "unknown";
+    source: "runtime" | "lockfile" | "fallback";
+}
+/**
+ * Detect which package manager is being used or configured for this project.
+ *
+ * Returns an object like:
+ *   { name: 'npm' | 'yarn' | 'pnpm' | 'bun' | 'unknown', source: 'runtime' | 'lockfile' | 'fallback' }
+ */
+export declare function detectPackageManager(cwd?: string): PackageManagerInfo;
+/**
+ * Get the appropriate update command for the detected package manager.
+ * Returns global update commands if globally installed, local commands if locally installed.
+ */
+export declare function getUpdateCommand(packageName: string): string;

package/dist/src/utils/package-manager-detector.js

@@ -0,0 +1,77 @@
+import { existsSync } from "fs";
+import { join } from "path";
+import isInstalledGlobally from "is-installed-globally";
+/**
+ * Detect which package manager is being used or configured for this project.
+ *
+ * Returns an object like:
+ *   { name: 'npm' | 'yarn' | 'pnpm' | 'bun' | 'unknown', source: 'runtime' | 'lockfile' | 'fallback' }
+ */
+export function detectPackageManager(cwd = process.cwd()) {
+    // --- 1. Runtime detection (based on env)
+    const ua = process.env.npm_config_user_agent;
+    if (ua) {
+        if (ua.includes("yarn"))
+            return { name: "yarn", source: "runtime" };
+        if (ua.includes("pnpm"))
+            return { name: "pnpm", source: "runtime" };
+        if (ua.includes("bun"))
+            return { name: "bun", source: "runtime" };
+        if (ua.includes("npm"))
+            return { name: "npm", source: "runtime" };
+    }
+    // --- 2. Lockfile detection (based on files in cwd)
+    const files = [
+        ["pnpm-lock.yaml", "pnpm"],
+        ["yarn.lock", "yarn"],
+        ["bun.lockb", "bun"],
+        ["package-lock.json", "npm"],
+    ];
+    for (const [file, name] of files) {
+        if (existsSync(join(cwd, file))) {
+            return { name, source: "lockfile" };
+        }
+    }
+    // --- 3. Fallback
+    return { name: "unknown", source: "fallback" };
+}
+/**
+ * Get the appropriate update command for the detected package manager.
+ * Returns global update commands if globally installed, local commands if locally installed.
+ */
+export function getUpdateCommand(packageName) {
+    const pm = detectPackageManager();
+    const isGlobal = isInstalledGlobally;
+    if (isGlobal) {
+        // Global update commands
+        switch (pm.name) {
+            case "yarn":
+                return `yarn global upgrade ${packageName}`;
+            case "pnpm":
+                return `pnpm update -g ${packageName}`;
+            case "bun":
+                return `bun update -g ${packageName}`;
+            case "npm":
+                return `npm update -g ${packageName}`;
+            case "unknown":
+                // Default to npm since it's most widely supported
+                return `npm update -g ${packageName}`;
+        }
+    }
+    else {
+        // Local update commands
+        switch (pm.name) {
+            case "yarn":
+                return `yarn upgrade ${packageName}`;
+            case "pnpm":
+                return `pnpm update ${packageName}`;
+            case "bun":
+                return `bun update ${packageName}`;
+            case "npm":
+                return `npm update ${packageName}`;
+            case "unknown":
+                // Default to npm since it's most widely supported
+                return `npm update ${packageName}`;
+        }
+    }
+}

package/dist/src/utils/parameter-resolver.js

@@ -1,6 +1,7 @@
 import inquirer from "inquirer";
 import chalk from "chalk";
 import { z } from "zod";
+import { ZapierCliUserCancellationError } from "./errors";
 // ============================================================================
 // Local Resolution Helper Functions
 // ============================================================================
@@ -137,7 +138,7 @@ export class SchemaParameterResolver {
                 catch (error) {
                     if (this.isUserCancellation(error)) {
                         console.log(chalk.yellow("\n\nOperation cancelled by user"));
-                        process.exit(0);
+                        throw new ZapierCliUserCancellationError();
                     }
                     throw error;
                 }
@@ -164,7 +165,7 @@ export class SchemaParameterResolver {
                 catch (error) {
                     if (this.isUserCancellation(error)) {
                         console.log(chalk.yellow("\n\nOperation cancelled by user"));
-                        process.exit(0);
+                        throw new ZapierCliUserCancellationError();
                     }
                     throw error;
                 }
@@ -198,7 +199,7 @@ export class SchemaParameterResolver {
                     catch (error) {
                         if (this.isUserCancellation(error)) {
                             console.log(chalk.yellow("\n\nOperation cancelled by user"));
-                            process.exit(0);
+                            throw new ZapierCliUserCancellationError();
                         }
                         throw error;
                     }
@@ -431,7 +432,7 @@ export class SchemaParameterResolver {
                 catch (error) {
                     if (this.isUserCancellation(error)) {
                         console.log(chalk.yellow("\n\nOperation cancelled by user"));
-                        process.exit(0);
+                        throw new ZapierCliUserCancellationError();
                     }
                     throw error;
                 }
@@ -492,7 +493,7 @@ export class SchemaParameterResolver {
         catch (error) {
             if (this.isUserCancellation(error)) {
                 console.log(chalk.yellow("\n\nOperation cancelled by user"));
-                process.exit(0);
+                throw new ZapierCliUserCancellationError();
             }
             throw error;
         }

package/dist/src/utils/spinner.js

@@ -1,4 +1,5 @@
 import ora from "ora";
+import { ZapierCliUserCancellationError } from "./errors";
 export const spinPromise = async (promise, text) => {
     const spinner = ora(text).start();
     try {
@@ -7,7 +8,14 @@ export const spinPromise = async (promise, text) => {
         return result;
     }
     catch (error) {
-        spinner.fail();
+        if (error instanceof ZapierCliUserCancellationError) {
+            // For user cancellation, just stop the spinner without showing failure
+            spinner.stop();
+        }
+        else {
+            // For actual errors, show failure
+            spinner.fail();
+        }
         throw error;
     }
 };

package/dist/src/utils/version-checker.d.ts

@@ -0,0 +1,17 @@
+interface VersionInfo {
+    hasUpdate: boolean;
+    latestVersion?: string;
+    currentVersion: string;
+    isDeprecated: boolean;
+    deprecationMessage?: string;
+}
+export declare function checkForUpdates({ packageName, currentVersion, }: {
+    packageName: string;
+    currentVersion: string;
+}): Promise<VersionInfo>;
+export declare function displayUpdateNotification(versionInfo: VersionInfo, packageName: string): void;
+export declare function checkAndNotifyUpdates({ packageName, currentVersion, }: {
+    packageName: string;
+    currentVersion: string;
+}): Promise<void>;
+export {};

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

@@ -0,0 +1,154 @@
+import packageJsonLib from "package-json";
+import chalk from "chalk";
+import log from "./log";
+import Conf from "conf";
+import { getUpdateCommand } from "./package-manager-detector";
+let config = null;
+function getConfig() {
+    if (!config) {
+        config = new Conf({ projectName: "zapier-sdk-cli" });
+    }
+    return config;
+}
+const ONE_DAY_MS = 24 * 60 * 60 * 1000;
+const CACHE_RESET_INTERVAL_MS = (() => {
+    const { ZAPIER_SDK_UPDATE_CHECK_INTERVAL_MS = `${ONE_DAY_MS}` } = process.env;
+    const interval = parseInt(ZAPIER_SDK_UPDATE_CHECK_INTERVAL_MS);
+    if (isNaN(interval) || interval < 0) {
+        return -1;
+    }
+    return interval;
+})();
+function getVersionCache() {
+    try {
+        const cache = getConfig().get("version_cache");
+        const now = Date.now();
+        // If no cache, missing timestamp, or it's been more than a day, reset the cache
+        if (!cache ||
+            !cache.last_reset_timestamp ||
+            now - cache.last_reset_timestamp >= CACHE_RESET_INTERVAL_MS) {
+            const newCache = {
+                last_reset_timestamp: now,
+                packages: {},
+            };
+            getConfig().set("version_cache", newCache);
+            return newCache;
+        }
+        return cache;
+    }
+    catch (error) {
+        log.debug(`Failed to read version cache: ${error}`);
+        return {
+            last_reset_timestamp: Date.now(),
+            packages: {},
+        };
+    }
+}
+function setCachedPackageInfo(packageName, version, info) {
+    try {
+        const cache = getVersionCache();
+        if (!cache.packages[packageName]) {
+            cache.packages[packageName] = {};
+        }
+        cache.packages[packageName][version] = info;
+        getConfig().set("version_cache", cache);
+    }
+    catch (error) {
+        log.debug(`Failed to cache package info: ${error}`);
+    }
+}
+function getCachedPackageInfo(packageName, version) {
+    try {
+        const cache = getVersionCache();
+        return cache.packages[packageName]?.[version];
+    }
+    catch (error) {
+        log.debug(`Failed to get cached package info: ${error}`);
+        return undefined;
+    }
+}
+async function fetchCachedPackageInfo(packageName, version) {
+    const cacheKey = version || "latest";
+    // Try cache first
+    let cachedInfo = getCachedPackageInfo(packageName, cacheKey);
+    if (cachedInfo) {
+        return cachedInfo;
+    }
+    // Not in cache, fetch from npm
+    const packageInfo = await packageJsonLib(packageName, {
+        version,
+        fullMetadata: true,
+    });
+    const info = {
+        version: packageInfo.version,
+        deprecated: packageInfo.deprecated,
+        fetched_at: new Date().toISOString(),
+    };
+    // Cache for next time
+    setCachedPackageInfo(packageName, cacheKey, info);
+    return info;
+}
+export async function checkForUpdates({ packageName, currentVersion, }) {
+    try {
+        // Get latest version info (with caching)
+        const latestPackageInfo = await fetchCachedPackageInfo(packageName);
+        const latestVersion = latestPackageInfo.version;
+        const hasUpdate = currentVersion !== latestVersion;
+        // Check deprecation status of the current version (with caching)
+        let currentPackageInfo;
+        try {
+            currentPackageInfo = await fetchCachedPackageInfo(packageName, currentVersion);
+        }
+        catch (error) {
+            // If we can't fetch the current version info, use the latest version info
+            log.debug(`Failed to check deprecation for current version: ${error}`);
+            currentPackageInfo = latestPackageInfo;
+        }
+        const isDeprecated = Boolean(currentPackageInfo.deprecated);
+        const deprecationMessage = isDeprecated
+            ? String(currentPackageInfo.deprecated)
+            : undefined;
+        return {
+            hasUpdate,
+            latestVersion,
+            currentVersion,
+            isDeprecated,
+            deprecationMessage,
+        };
+    }
+    catch (error) {
+        // If we can't check for updates (network issues, etc.), fail silently
+        log.debug(`Failed to check for updates: ${error}`);
+        return {
+            hasUpdate: false,
+            currentVersion,
+            isDeprecated: false,
+        };
+    }
+}
+export function displayUpdateNotification(versionInfo, packageName) {
+    if (versionInfo.isDeprecated) {
+        console.error();
+        console.error(chalk.red.bold("⚠️  DEPRECATION WARNING") +
+            chalk.red(` - ${packageName} v${versionInfo.currentVersion} is deprecated.`));
+        if (versionInfo.deprecationMessage) {
+            console.error(chalk.red(`   ${versionInfo.deprecationMessage}`));
+        }
+        console.error(chalk.red(`   Please update to the latest version.`));
+        console.error();
+    }
+    if (versionInfo.hasUpdate) {
+        console.log();
+        console.log(chalk.yellow.bold("📦 Update available!") +
+            chalk.yellow(` ${packageName} v${versionInfo.currentVersion} → v${versionInfo.latestVersion}`));
+        console.log(chalk.yellow(`   Run ${chalk.bold(getUpdateCommand(packageName))} to update.`));
+        console.log();
+    }
+}
+export async function checkAndNotifyUpdates({ packageName, currentVersion, }) {
+    if (CACHE_RESET_INTERVAL_MS < 0) {
+        return;
+    }
+    const versionInfo = await checkForUpdates({ packageName, currentVersion });
+    displayUpdateNotification(versionInfo, packageName);
+}