@zapier/zapier-sdk-cli 0.13.16 → 0.14.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zapier/zapier-sdk-cli",
-  "version": "0.13.16",
+  "version": "0.14.1",
   "description": "Command line interface for Zapier SDK",
   "main": "dist/index.cjs",
   "module": "dist/index.mjs",
@@ -34,12 +34,15 @@
     "chalk": "^5.3.0",
     "cli-table3": "^0.6.5",
     "commander": "^12.0.0",
+    "conf": "^14.0.0",
     "esbuild": "^0.25.5",
     "express": "^5.1.0",
     "inquirer": "^12.6.3",
+    "is-installed-globally": "^1.0.0",
     "jsonwebtoken": "^9.0.2",
     "open": "^10.2.0",
     "ora": "^8.2.0",
+    "package-json": "^10.0.1",
     "pkce-challenge": "^5.0.0",
     "typescript": "^5.8.3",
     "zod": "^3.25.67",

package/src/cli.ts

@@ -1,9 +1,11 @@
 #!/usr/bin/env node
 
-import { Command } from "commander";
+import { Command, CommanderError } from "commander";
 import { generateCliCommands } from "./utils/cli-generator";
 import { createZapierCliSdk } from "./sdk";
 import packageJson from "../package.json" with { type: "json" };
+import { ZapierCliError } from "./utils/errors";
+import { checkAndNotifyUpdates } from "./utils/version-checker";
 
 const program = new Command();
 
@@ -61,4 +63,34 @@ generateCliCommands(program, sdk);
 
 // MCP command now handled by plugin
 
-program.parse();
+// Override Commander's default exit behavior to handle our custom errors
+program.exitOverride();
+
+(async () => {
+  let exitCode = 0;
+
+  // Start version checking non-blocking
+  const versionCheckPromise = checkAndNotifyUpdates({
+    packageName: packageJson.name,
+    currentVersion: packageJson.version,
+  });
+
+  try {
+    await program.parseAsync();
+  } catch (error) {
+    if (error instanceof ZapierCliError) {
+      exitCode = error.exitCode;
+    } else if (error instanceof CommanderError) {
+      exitCode = error.exitCode;
+    } else {
+      // For any other unexpected errors, exit with code 1
+      console.error("Unexpected error:", error);
+      exitCode = 1;
+    }
+  }
+
+  // Wait for version checking to complete
+  await versionCheckPromise;
+
+  process.exit(exitCode);
+})();

package/src/plugins/login/index.ts

@@ -54,9 +54,6 @@ const loginWithSdk = createFunction(
     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);
   },
 );
 

package/src/utils/auth/login.ts

@@ -20,6 +20,7 @@ import {
   getAuthTokenUrl,
   getAuthAuthorizeUrl,
 } from "@zapier/zapier-sdk-cli-login";
+import { ZapierCliUserCancellationError } from "../errors";
 
 const findAvailablePort = (): Promise<number> => {
   return new Promise((resolve, reject) => {
@@ -91,8 +92,11 @@ const login = async ({
 
   log.info(`Using port ${availablePort} for OAuth callback`);
 
-  const { promise: promisedCode, resolve: setCode } =
-    getCallablePromise<string>();
+  const {
+    promise: promisedCode,
+    resolve: setCode,
+    reject: rejectCode,
+  } = getCallablePromise<string>();
 
   const app = express();
 
@@ -116,7 +120,7 @@ const login = async ({
   const cleanup = () => {
     server.close();
     log.info("\n❌ Login cancelled by user");
-    process.exit(0);
+    rejectCode(new ZapierCliUserCancellationError());
   };
 
   process.on("SIGINT", cleanup);

package/src/utils/cli-generator.ts

@@ -11,6 +11,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";
 
 // ============================================================================
 // Types
@@ -387,20 +388,32 @@ function createCommandConfig(
           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);
     }
   };
 

package/src/utils/errors.ts

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

package/src/utils/log.ts

@@ -13,6 +13,11 @@ const log = {
   warn: (message: string, ...args: unknown[]) => {
     console.log(chalk.yellow("⚠"), message, ...args);
   },
+  debug: (message: string, ...args: unknown[]) => {
+    if (process.env.DEBUG === "true" || process.argv.includes("--debug")) {
+      console.log(chalk.gray("🐛"), message, ...args);
+    }
+  },
 };
 
 export default log;

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

@@ -0,0 +1,83 @@
+import { existsSync } from "fs";
+import { join } from "path";
+import isInstalledGlobally from "is-installed-globally";
+
+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 function detectPackageManager(cwd = process.cwd()): PackageManagerInfo {
+  // --- 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: Array<[string, PackageManagerInfo["name"]]> = [
+    ["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: string): string {
+  const pm = detectPackageManager();
+  const isGlobal = isInstalledGlobally;
+
+  if (isGlobal) {
+    // Global update commands
+    switch (pm.name) {
+      case "yarn":
+        return `yarn global upgrade ${packageName}@latest`;
+      case "pnpm":
+        return `pnpm update -g ${packageName}@latest`;
+      case "bun":
+        return `bun update -g ${packageName}@latest`;
+      case "npm":
+        return `npm update -g ${packageName}@latest`;
+      case "unknown":
+        // Default to npm since it's most widely supported
+        return `npm update -g ${packageName}@latest`;
+    }
+  } else {
+    // Local update commands
+    switch (pm.name) {
+      case "yarn":
+        return `yarn upgrade ${packageName}@latest`;
+      case "pnpm":
+        return `pnpm update ${packageName}@latest`;
+      case "bun":
+        return `bun update ${packageName}@latest`;
+      case "npm":
+        return `npm update ${packageName}@latest`;
+      case "unknown":
+        // Default to npm since it's most widely supported
+        return `npm update ${packageName}@latest`;
+    }
+  }
+}

package/src/utils/parameter-resolver.ts

@@ -2,6 +2,7 @@ import inquirer from "inquirer";
 import chalk from "chalk";
 import { z } from "zod";
 import type { ZapierSdk } from "@zapier/zapier-sdk";
+import { ZapierCliUserCancellationError } from "./errors";
 
 // ============================================================================
 // Types
@@ -209,7 +210,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;
         }
@@ -257,7 +258,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;
         }
@@ -302,7 +303,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;
           }
@@ -670,7 +671,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;
         }
@@ -755,7 +756,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/src/utils/spinner.ts

@@ -1,4 +1,5 @@
 import ora from "ora";
+import { ZapierCliUserCancellationError } from "./errors";
 
 export const spinPromise = async <T>(
   promise: Promise<T>,
@@ -10,7 +11,13 @@ export const spinPromise = async <T>(
     spinner.succeed();
     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/src/utils/version-checker.test.ts

@@ -0,0 +1,199 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { checkForUpdates, displayUpdateNotification } from "./version-checker";
+
+// Mock package-json
+vi.mock("package-json", () => ({
+  default: vi.fn(),
+}));
+
+// Mock chalk to make testing easier
+vi.mock("chalk", () => ({
+  default: {
+    red: Object.assign((text: string) => text, {
+      bold: (text: string) => text,
+    }),
+    yellow: Object.assign((text: string) => text, {
+      bold: (text: string) => text,
+    }),
+    bold: (text: string) => text,
+  },
+}));
+
+// Mock log module
+vi.mock("./log", () => ({
+  default: {
+    debug: vi.fn(),
+  },
+}));
+
+// Mock conf module
+const mockConf = {
+  get: vi.fn(),
+  set: vi.fn(),
+};
+vi.mock("conf", () => ({
+  default: vi.fn().mockImplementation(() => mockConf),
+}));
+
+const mockPackageJson = vi.mocked(await import("package-json")).default;
+
+describe("version-checker", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    // Ensure cache is cleared between tests by returning undefined from get
+    mockConf.get.mockReturnValue(undefined);
+    // Suppress console output during tests
+    vi.spyOn(console, "log").mockImplementation(() => {});
+    vi.spyOn(console, "error").mockImplementation(() => {});
+  });
+
+  describe("checkForUpdates", () => {
+    it("should detect when an update is available", async () => {
+      mockPackageJson.mockResolvedValue({
+        version: "1.0.1",
+        deprecated: false,
+      });
+
+      const result = await checkForUpdates({
+        packageName: "test-package",
+        currentVersion: "1.0.0",
+      });
+
+      expect(result).toEqual({
+        hasUpdate: true,
+        latestVersion: "1.0.1",
+        currentVersion: "1.0.0",
+        isDeprecated: false,
+        deprecationMessage: undefined,
+      });
+    });
+
+    it("should detect when package is deprecated", async () => {
+      mockPackageJson.mockResolvedValue({
+        version: "1.0.0",
+        deprecated: "This package is no longer maintained",
+      });
+
+      const result = await checkForUpdates({
+        packageName: "test-package",
+        currentVersion: "1.0.0",
+      });
+
+      expect(result).toEqual({
+        hasUpdate: false,
+        latestVersion: "1.0.0",
+        currentVersion: "1.0.0",
+        isDeprecated: true,
+        deprecationMessage: "This package is no longer maintained",
+      });
+    });
+
+    it("should handle when no update is available", async () => {
+      mockPackageJson.mockResolvedValue({
+        version: "1.0.0",
+        deprecated: false,
+      });
+
+      const result = await checkForUpdates({
+        packageName: "test-package",
+        currentVersion: "1.0.0",
+      });
+
+      expect(result).toEqual({
+        hasUpdate: false,
+        latestVersion: "1.0.0",
+        currentVersion: "1.0.0",
+        isDeprecated: false,
+        deprecationMessage: undefined,
+      });
+    });
+
+    it("should handle network errors gracefully", async () => {
+      mockPackageJson.mockRejectedValue(new Error("Network error"));
+
+      const result = await checkForUpdates({
+        packageName: "test-package",
+        currentVersion: "1.0.0",
+      });
+
+      expect(result).toEqual({
+        hasUpdate: false,
+        currentVersion: "1.0.0",
+        isDeprecated: false,
+      });
+    });
+  });
+
+  describe("displayUpdateNotification", () => {
+    it("should display deprecation warning", () => {
+      const consoleSpy = vi
+        .spyOn(console, "error")
+        .mockImplementation(() => {});
+
+      displayUpdateNotification(
+        {
+          hasUpdate: false,
+          currentVersion: "1.0.0",
+          isDeprecated: true,
+          deprecationMessage: "This package is deprecated",
+        },
+        "test-package",
+      );
+
+      expect(consoleSpy).toHaveBeenCalledWith(
+        expect.stringContaining("DEPRECATION WARNING"),
+      );
+      expect(consoleSpy).toHaveBeenCalledWith(
+        expect.stringContaining("This package is deprecated"),
+      );
+    });
+
+    it("should display update notification", () => {
+      const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+
+      displayUpdateNotification(
+        {
+          hasUpdate: true,
+          currentVersion: "1.0.0",
+          latestVersion: "1.0.1",
+          isDeprecated: false,
+        },
+        "test-package",
+      );
+
+      expect(consoleSpy).toHaveBeenCalledWith(
+        expect.stringContaining("Update available!"),
+      );
+      expect(consoleSpy).toHaveBeenCalledWith(
+        expect.stringContaining("pnpm update test-package"),
+      );
+    });
+
+    it("should display both deprecation and update notifications", () => {
+      const consoleErrorSpy = vi
+        .spyOn(console, "error")
+        .mockImplementation(() => {});
+      const consoleLogSpy = vi
+        .spyOn(console, "log")
+        .mockImplementation(() => {});
+
+      displayUpdateNotification(
+        {
+          hasUpdate: true,
+          currentVersion: "1.0.0",
+          latestVersion: "1.0.1",
+          isDeprecated: true,
+          deprecationMessage: "This package is deprecated",
+        },
+        "test-package",
+      );
+
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
+        expect.stringContaining("DEPRECATION WARNING"),
+      );
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        expect.stringContaining("Update available!"),
+      );
+    });
+  });
+});