@zapier/zapier-sdk-cli 0.13.16 → 0.14.1

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @zapier/zapier-sdk-cli
 
+## 0.14.1
+
+### Patch Changes
+
+- 064740d: Add `@latest` to update message.
+
+## 0.14.0
+
+### Minor Changes
+
+- 5d82a5a: Add update/deprecation message.
+
 ## 0.13.16
 
 ### Patch Changes

package/dist/cli.cjs

@@ -19,6 +19,9 @@ var fs = require('fs');
 var path = require('path');
 var promises = require('fs/promises');
 var ts = require('typescript');
+var packageJsonLib = require('package-json');
+var Conf = require('conf');
+var isInstalledGlobally = require('is-installed-globally');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -51,7 +54,30 @@ var ora__default = /*#__PURE__*/_interopDefault(ora);
 var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
 var path__namespace = /*#__PURE__*/_interopNamespace(path);
 var ts__namespace = /*#__PURE__*/_interopNamespace(ts);
+var packageJsonLib__default = /*#__PURE__*/_interopDefault(packageJsonLib);
+var Conf__default = /*#__PURE__*/_interopDefault(Conf);
+var isInstalledGlobally__default = /*#__PURE__*/_interopDefault(isInstalledGlobally);
 
+var ZapierCliError = class extends zapierSdk.ZapierError {
+};
+var ZapierCliUserCancellationError = class extends ZapierCliError {
+  constructor(message = "Operation cancelled by user") {
+    super(message);
+    this.name = "ZapierCliUserCancellationError";
+    this.code = "ZAPIER_CLI_USER_CANCELLATION";
+    this.exitCode = 0;
+  }
+};
+var ZapierCliExitError = class extends ZapierCliError {
+  constructor(message, exitCode = 1) {
+    super(message);
+    this.name = "ZapierCliExitError";
+    this.code = "ZAPIER_CLI_EXIT";
+    this.exitCode = exitCode;
+  }
+};
+
+// src/utils/parameter-resolver.ts
 function getLocalResolutionOrder(paramName, resolvers, resolved = /* @__PURE__ */ new Set()) {
   const resolver = resolvers[paramName];
   if (!resolver || resolver.type === "static") {
@@ -158,7 +184,7 @@ var SchemaParameterResolver = class {
         } catch (error) {
           if (this.isUserCancellation(error)) {
             console.log(chalk3__default.default.yellow("\n\nOperation cancelled by user"));
-            process.exit(0);
+            throw new ZapierCliUserCancellationError();
           }
           throw error;
         }
@@ -196,7 +222,7 @@ var SchemaParameterResolver = class {
         } catch (error) {
           if (this.isUserCancellation(error)) {
             console.log(chalk3__default.default.yellow("\n\nOperation cancelled by user"));
-            process.exit(0);
+            throw new ZapierCliUserCancellationError();
           }
           throw error;
         }
@@ -231,7 +257,7 @@ var SchemaParameterResolver = class {
           } catch (error) {
             if (this.isUserCancellation(error)) {
               console.log(chalk3__default.default.yellow("\n\nOperation cancelled by user"));
-              process.exit(0);
+              throw new ZapierCliUserCancellationError();
             }
             throw error;
           }
@@ -485,7 +511,7 @@ Optional fields${pathContext}:`));
         } catch (error) {
           if (this.isUserCancellation(error)) {
             console.log(chalk3__default.default.yellow("\n\nOperation cancelled by user"));
-            process.exit(0);
+            throw new ZapierCliUserCancellationError();
           }
           throw error;
         }
@@ -550,7 +576,7 @@ Optional fields${pathContext}:`));
     } catch (error) {
       if (this.isUserCancellation(error)) {
         console.log(chalk3__default.default.yellow("\n\nOperation cancelled by user"));
-        process.exit(0);
+        throw new ZapierCliUserCancellationError();
       }
       throw error;
     }
@@ -773,8 +799,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) => {
@@ -916,17 +942,28 @@ function createCommandConfig(cliCommandName, functionInfo, sdk2) {
           console.error(
             "\n" + chalk3__default.default.dim(`Use --help to see available options`)
           );
+          throw new ZapierCliExitError("Validation failed", 1);
         } catch {
-          console.error(chalk3__default.default.red("Error:"), error.message);
+          console.error(
+            chalk3__default.default.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) {
+        throw error;
       } else if (error instanceof zapierSdk.ZapierError) {
         const formattedMessage = zapierSdk.formatErrorMessage(error);
         console.error(chalk3__default.default.red("\u274C Error:"), formattedMessage);
+        throw new ZapierCliExitError(formattedMessage, 1);
       } else {
         const errorMessage = error instanceof Error ? error.message : "Unknown error";
         console.error(chalk3__default.default.red("\u274C Error:"), errorMessage);
+        throw new ZapierCliExitError(errorMessage, 1);
       }
-      process.exit(1);
     }
   };
   return {
@@ -935,10 +972,10 @@ function createCommandConfig(cliCommandName, functionInfo, sdk2) {
     handler
   };
 }
-function addCommand(program2, commandName, config) {
-  const command = program2.command(commandName).description(config.description);
+function addCommand(program2, commandName, config2) {
+  const command = program2.command(commandName).description(config2.description);
   let hasPositionalArray = false;
-  config.parameters.forEach((param) => {
+  config2.parameters.forEach((param) => {
     const kebabName = param.name.replace(/([A-Z])/g, "-$1").toLowerCase();
     if (param.hasResolver && param.required) {
       command.argument(
@@ -990,7 +1027,7 @@ function addCommand(program2, commandName, config) {
     }
   });
   command.option("--json", "Output raw JSON instead of formatted results");
-  command.action(config.handler);
+  command.action(config2.handler);
 }
 function convertCliArgsToSdkParams(parameters, positionalArgs, options) {
   const sdkParams = {};
@@ -1200,7 +1237,11 @@ var spinPromise = async (promise, text) => {
     spinner.succeed();
     return result;
   } catch (error) {
-    spinner.fail();
+    if (error instanceof ZapierCliUserCancellationError) {
+      spinner.stop();
+    } else {
+      spinner.fail();
+    }
     throw error;
   }
 };
@@ -1216,6 +1257,11 @@ var log = {
   },
   warn: (message, ...args) => {
     console.log(chalk3__default.default.yellow("\u26A0"), message, ...args);
+  },
+  debug: (message, ...args) => {
+    if (process.env.DEBUG === "true" || process.argv.includes("--debug")) {
+      console.log(chalk3__default.default.gray("\u{1F41B}"), message, ...args);
+    }
   }
 };
 var log_default = log;
@@ -1318,7 +1364,11 @@ var login = async ({
   const availablePort = await findAvailablePort();
   const redirectUri = `http://localhost:${availablePort}/oauth`;
   log_default.info(`Using port ${availablePort} for OAuth callback`);
-  const { promise: promisedCode, resolve: setCode } = getCallablePromise_default();
+  const {
+    promise: promisedCode,
+    resolve: setCode,
+    reject: rejectCode
+  } = getCallablePromise_default();
   const app = express__default.default();
   app.get("/oauth", (req, res) => {
     setCode(String(req.query.code));
@@ -1334,7 +1384,7 @@ var login = async ({
   const cleanup = () => {
     server.close();
     log_default.info("\n\u274C Login cancelled by user");
-    process.exit(0);
+    rejectCode(new ZapierCliUserCancellationError());
   };
   process.on("SIGINT", cleanup);
   process.on("SIGTERM", cleanup);
@@ -1410,7 +1460,7 @@ var LoginSchema = zod.z.object({
 
 // package.json
 var package_default = {
-  version: "0.13.16"};
+  version: "0.14.1"};
 
 // src/telemetry/builders.ts
 function createCliBaseEvent(context = {}) {
@@ -1482,7 +1532,6 @@ var loginWithSdk = zapierSdk.createFunction(
     });
     const user = await zapierSdkCliLogin.getLoggedInUser();
     console.log(`\u2705 Successfully logged in as ${user.email}`);
-    setTimeout(() => process.exit(0), 100);
   }
 );
 var loginPlugin = ({ context }) => {
@@ -2682,7 +2731,213 @@ function createZapierCliSdk(options = {}) {
 
 // package.json with { type: 'json' }
 var package_default2 = {
-  version: "0.13.16"};
+  name: "@zapier/zapier-sdk-cli",
+  version: "0.14.1"};
+function detectPackageManager(cwd = process.cwd()) {
+  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" };
+  }
+  const files = [
+    ["pnpm-lock.yaml", "pnpm"],
+    ["yarn.lock", "yarn"],
+    ["bun.lockb", "bun"],
+    ["package-lock.json", "npm"]
+  ];
+  for (const [file, name] of files) {
+    if (fs.existsSync(path.join(cwd, file))) {
+      return { name, source: "lockfile" };
+    }
+  }
+  return { name: "unknown", source: "fallback" };
+}
+function getUpdateCommand(packageName) {
+  const pm = detectPackageManager();
+  const isGlobal = isInstalledGlobally__default.default;
+  if (isGlobal) {
+    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":
+        return `npm update -g ${packageName}@latest`;
+    }
+  } else {
+    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":
+        return `npm update ${packageName}@latest`;
+    }
+  }
+}
+
+// src/utils/version-checker.ts
+var config = null;
+function getConfig() {
+  if (!config) {
+    config = new Conf__default.default({ projectName: "zapier-sdk-cli" });
+  }
+  return config;
+}
+var ONE_DAY_MS = 24 * 60 * 60 * 1e3;
+var 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 (!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_default.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_default.debug(`Failed to cache package info: ${error}`);
+  }
+}
+function getCachedPackageInfo(packageName, version) {
+  try {
+    const cache = getVersionCache();
+    return cache.packages[packageName]?.[version];
+  } catch (error) {
+    log_default.debug(`Failed to get cached package info: ${error}`);
+    return void 0;
+  }
+}
+async function fetchCachedPackageInfo(packageName, version) {
+  const cacheKey = version || "latest";
+  let cachedInfo = getCachedPackageInfo(packageName, cacheKey);
+  if (cachedInfo) {
+    return cachedInfo;
+  }
+  const packageInfo = await packageJsonLib__default.default(packageName, {
+    version,
+    fullMetadata: true
+  });
+  const info = {
+    version: packageInfo.version,
+    deprecated: packageInfo.deprecated,
+    fetched_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  setCachedPackageInfo(packageName, cacheKey, info);
+  return info;
+}
+async function checkForUpdates({
+  packageName,
+  currentVersion
+}) {
+  try {
+    const latestPackageInfo = await fetchCachedPackageInfo(packageName);
+    const latestVersion = latestPackageInfo.version;
+    const hasUpdate = currentVersion !== latestVersion;
+    let currentPackageInfo;
+    try {
+      currentPackageInfo = await fetchCachedPackageInfo(
+        packageName,
+        currentVersion
+      );
+    } catch (error) {
+      log_default.debug(`Failed to check deprecation for current version: ${error}`);
+      currentPackageInfo = latestPackageInfo;
+    }
+    const isDeprecated = Boolean(currentPackageInfo.deprecated);
+    const deprecationMessage = isDeprecated ? String(currentPackageInfo.deprecated) : void 0;
+    return {
+      hasUpdate,
+      latestVersion,
+      currentVersion,
+      isDeprecated,
+      deprecationMessage
+    };
+  } catch (error) {
+    log_default.debug(`Failed to check for updates: ${error}`);
+    return {
+      hasUpdate: false,
+      currentVersion,
+      isDeprecated: false
+    };
+  }
+}
+function displayUpdateNotification(versionInfo, packageName) {
+  if (versionInfo.isDeprecated) {
+    console.error();
+    console.error(
+      chalk3__default.default.red.bold("\u26A0\uFE0F  DEPRECATION WARNING") + chalk3__default.default.red(
+        ` - ${packageName} v${versionInfo.currentVersion} is deprecated.`
+      )
+    );
+    if (versionInfo.deprecationMessage) {
+      console.error(chalk3__default.default.red(`   ${versionInfo.deprecationMessage}`));
+    }
+    console.error(chalk3__default.default.red(`   Please update to the latest version.`));
+    console.error();
+  }
+  if (versionInfo.hasUpdate) {
+    console.log();
+    console.log(
+      chalk3__default.default.yellow.bold("\u{1F4E6} Update available!") + chalk3__default.default.yellow(
+        ` ${packageName} v${versionInfo.currentVersion} \u2192 v${versionInfo.latestVersion}`
+      )
+    );
+    console.log(
+      chalk3__default.default.yellow(
+        `   Run ${chalk3__default.default.bold(getUpdateCommand(packageName))} to update.`
+      )
+    );
+    console.log();
+  }
+}
+async function checkAndNotifyUpdates({
+  packageName,
+  currentVersion
+}) {
+  if (CACHE_RESET_INTERVAL_MS < 0) {
+    return;
+  }
+  const versionInfo = await checkForUpdates({ packageName, currentVersion });
+  displayUpdateNotification(versionInfo, packageName);
+}
 
 // src/cli.ts
 var program = new commander.Command();
@@ -2710,4 +2965,25 @@ var sdk = createZapierCliSdk({
   trackingBaseUrl
 });
 generateCliCommands(program, sdk);
-program.parse();
+program.exitOverride();
+(async () => {
+  let exitCode = 0;
+  const versionCheckPromise = checkAndNotifyUpdates({
+    packageName: package_default2.name,
+    currentVersion: package_default2.version
+  });
+  try {
+    await program.parseAsync();
+  } catch (error) {
+    if (error instanceof ZapierCliError) {
+      exitCode = error.exitCode;
+    } else if (error instanceof commander.CommanderError) {
+      exitCode = error.exitCode;
+    } else {
+      console.error("Unexpected error:", error);
+      exitCode = 1;
+    }
+  }
+  await versionCheckPromise;
+  process.exit(exitCode);
+})();