@evantahler/mcpx 0.18.3 → 0.18.6

package/src/commands/upgrade.ts

@@ -1,226 +1,209 @@
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { dim, green, red, yellow } from "ansis";
 import { $ } from "bun";
-import { green, yellow, red, cyan, dim } from "ansis";
 import type { Command } from "commander";
 import { createSpinner } from "nanospinner";
-import { tmpdir } from "os";
-import { join } from "path";
 import pkg from "../../package.json";
-import {
-  checkForUpdate,
-  detectInstallMethod,
-  needsCheck,
-  type InstallMethod,
-} from "../update/checker.ts";
-import { loadUpdateCache, saveUpdateCache, clearUpdateCache } from "../update/cache.ts";
-import type { UpdateCache } from "../update/checker.ts";
 import pkgMeta from "../../package.json";
+import { clearUpdateCache, loadUpdateCache, saveUpdateCache } from "../update/cache.ts";
+import type { UpdateCache } from "../update/checker.ts";
+import { checkForUpdate, detectInstallMethod, type InstallMethod, needsCheck } from "../update/checker.ts";
 
-const GITHUB_REPO = pkgMeta.repository.url
-  .replace(/^https:\/\/github\.com\//, "")
-  .replace(/\.git$/, "");
+const GITHUB_REPO = pkgMeta.repository.url.replace(/^https:\/\/github\.com\//, "").replace(/\.git$/, "");
 
 function platformArtifactName(): string {
-  let os: string;
-  let ext = "";
-  switch (process.platform) {
-    case "darwin":
-      os = "darwin";
-      break;
-    case "win32":
-      os = "windows";
-      ext = ".exe";
-      break;
-    default:
-      os = "linux";
-      break;
-  }
-  const arch = process.arch === "arm64" ? "arm64" : "x64";
-  return `mcpx-${os}-${arch}${ext}`;
+	let os: string;
+	let ext = "";
+	switch (process.platform) {
+		case "darwin":
+			os = "darwin";
+			break;
+		case "win32":
+			os = "windows";
+			ext = ".exe";
+			break;
+		default:
+			os = "linux";
+			break;
+	}
+	const arch = process.arch === "arm64" ? "arm64" : "x64";
+	return `mcpx-${os}-${arch}${ext}`;
 }
 
 async function upgradeWithPackageManager(command: string, args: string[]): Promise<boolean> {
-  const result = await $`${command} ${args}`.nothrow();
-  return result.exitCode === 0;
+	const result = await $`${command} ${args}`.nothrow();
+	return result.exitCode === 0;
 }
 
 async function upgradeFromBinary(latestVersion: string): Promise<boolean> {
-  const artifact = platformArtifactName();
-  const tag = `v${latestVersion}`;
-  const url = `https://github.com/${GITHUB_REPO}/releases/download/${tag}/${artifact}`;
-
-  const tmpPath = join(tmpdir(), `mcpx-upgrade-${Date.now()}`);
-  const targetPath = process.execPath;
-
-  try {
-    const res = await fetch(url);
-    if (!res.ok) {
-      console.error(red(`Failed to download binary: HTTP ${res.status}`));
-      return false;
-    }
-
-    const bytes = await res.arrayBuffer();
-    await Bun.write(tmpPath, bytes);
-
-    await $`chmod +x ${tmpPath}`.quiet();
-
-    // Try to move into place
-    const mv = await $`mv ${tmpPath} ${targetPath}`.quiet().nothrow();
-
-    if (mv.exitCode !== 0) {
-      // Try with sudo
-      console.log(dim("Requires elevated permissions..."));
-      const sudo = await $`sudo mv ${tmpPath} ${targetPath}`.nothrow();
-      if (sudo.exitCode !== 0) {
-        console.error(red("Failed to install binary. Try running with sudo."));
-        return false;
-      }
-    }
-
-    return true;
-  } catch (err) {
-    console.error(red(`Failed to upgrade binary: ${err}`));
-    // Clean up temp file
-    await $`rm -f ${tmpPath}`.quiet().nothrow();
-    return false;
-  }
+	const artifact = platformArtifactName();
+	const tag = `v${latestVersion}`;
+	const url = `https://github.com/${GITHUB_REPO}/releases/download/${tag}/${artifact}`;
+
+	const tmpPath = join(tmpdir(), `mcpx-upgrade-${Date.now()}`);
+	const targetPath = process.execPath;
+
+	try {
+		const res = await fetch(url);
+		if (!res.ok) {
+			console.error(red(`Failed to download binary: HTTP ${res.status}`));
+			return false;
+		}
+
+		const bytes = await res.arrayBuffer();
+		await Bun.write(tmpPath, bytes);
+
+		await $`chmod +x ${tmpPath}`.quiet();
+
+		// Try to move into place
+		const mv = await $`mv ${tmpPath} ${targetPath}`.quiet().nothrow();
+
+		if (mv.exitCode !== 0) {
+			// Try with sudo
+			console.log(dim("Requires elevated permissions..."));
+			const sudo = await $`sudo mv ${tmpPath} ${targetPath}`.nothrow();
+			if (sudo.exitCode !== 0) {
+				console.error(red("Failed to install binary. Try running with sudo."));
+				return false;
+			}
+		}
+
+		return true;
+	} catch (err) {
+		console.error(red(`Failed to upgrade binary: ${err}`));
+		// Clean up temp file
+		await $`rm -f ${tmpPath}`.quiet().nothrow();
+		return false;
+	}
 }
 
 export function registerUpgradeCommand(program: Command) {
-  program
-    .command("upgrade")
-    .description("Upgrade mcpx to the latest version")
-    .action(async () => {
-      const opts = program.opts();
-      const json = !!(opts.json as boolean | undefined);
-      const isTTY = process.stderr.isTTY ?? false;
-
-      const spinner =
-        !json && isTTY
-          ? createSpinner("Checking for updates...", { stream: process.stderr }).start()
-          : null;
-
-      try {
-        // Check for update (use cache if fresh)
-        const cache = await loadUpdateCache();
-        let latestVersion: string;
-        let hasUpdate: boolean;
-
-        if (!needsCheck(cache) && cache) {
-          latestVersion = cache.latestVersion;
-          hasUpdate = cache.hasUpdate;
-        } else {
-          const info = await checkForUpdate(pkg.version);
-          latestVersion = info.latestVersion;
-          hasUpdate = info.hasUpdate;
-
-          const newCache: UpdateCache = {
-            lastCheckAt: new Date().toISOString(),
-            latestVersion,
-            hasUpdate,
-            changelog: info.changelog,
-          };
-          await saveUpdateCache(newCache);
-        }
-
-        if (!hasUpdate) {
-          spinner?.stop();
-          if (json) {
-            console.log(
-              JSON.stringify({
-                upgraded: false,
-                currentVersion: pkg.version,
-                message: "Already up to date",
-              }),
-            );
-          } else {
-            console.log(green(`mcpx is already up to date (v${pkg.version})`));
-          }
-          return;
-        }
-
-        const method: InstallMethod = detectInstallMethod();
-        spinner?.update({
-          text: `Upgrading from v${pkg.version} to v${latestVersion} (${method})...`,
-        });
-
-        let success = false;
-
-        switch (method) {
-          case "bun":
-            spinner?.stop();
-            success = await upgradeWithPackageManager("bun", [
-              "install",
-              "-g",
-              `@evantahler/mcpx@${latestVersion}`,
-            ]);
-            break;
-
-          case "npm":
-            spinner?.stop();
-            success = await upgradeWithPackageManager("npm", [
-              "install",
-              "-g",
-              `@evantahler/mcpx@${latestVersion}`,
-            ]);
-            break;
-
-          case "binary":
-            spinner?.stop();
-            success = await upgradeFromBinary(latestVersion);
-            break;
-
-          case "local-dev":
-            spinner?.stop();
-            if (json) {
-              console.log(
-                JSON.stringify({
-                  upgraded: false,
-                  currentVersion: pkg.version,
-                  latestVersion,
-                  installMethod: "local-dev",
-                  message: "Running from source. Use `git pull && bun install` to update.",
-                }),
-              );
-            } else {
-              console.log(yellow("Running from source. Use `git pull && bun install` to update."));
-            }
-            return;
-        }
-
-        if (success) {
-          await clearUpdateCache();
-          if (json) {
-            console.log(
-              JSON.stringify({
-                upgraded: true,
-                previousVersion: pkg.version,
-                newVersion: latestVersion,
-                installMethod: method,
-              }),
-            );
-          } else {
-            console.log(green(`Successfully upgraded mcpx: v${pkg.version} → v${latestVersion}`));
-          }
-        } else {
-          if (json) {
-            console.log(
-              JSON.stringify({
-                upgraded: false,
-                currentVersion: pkg.version,
-                latestVersion,
-                installMethod: method,
-                message: "Upgrade failed",
-              }),
-            );
-          } else {
-            console.error(red("Upgrade failed. See errors above."));
-          }
-          process.exit(1);
-        }
-      } catch (err) {
-        spinner?.error({ text: "Upgrade failed" });
-        console.error(String(err));
-        process.exit(1);
-      }
-    });
+	program
+		.command("upgrade")
+		.description("Upgrade mcpx to the latest version")
+		.action(async () => {
+			const opts = program.opts();
+			const json = !!(opts.json as boolean | undefined);
+			const isTTY = process.stderr.isTTY ?? false;
+
+			const spinner =
+				!json && isTTY ? createSpinner("Checking for updates...", { stream: process.stderr }).start() : null;
+
+			try {
+				// Check for update (use cache if fresh)
+				const cache = await loadUpdateCache();
+				let latestVersion: string;
+				let hasUpdate: boolean;
+
+				if (!needsCheck(cache) && cache) {
+					latestVersion = cache.latestVersion;
+					hasUpdate = cache.hasUpdate;
+				} else {
+					const info = await checkForUpdate(pkg.version);
+					latestVersion = info.latestVersion;
+					hasUpdate = info.hasUpdate;
+
+					const newCache: UpdateCache = {
+						lastCheckAt: new Date().toISOString(),
+						latestVersion,
+						hasUpdate,
+						changelog: info.changelog,
+					};
+					await saveUpdateCache(newCache);
+				}
+
+				if (!hasUpdate) {
+					spinner?.stop();
+					if (json) {
+						console.log(
+							JSON.stringify({
+								upgraded: false,
+								currentVersion: pkg.version,
+								message: "Already up to date",
+							}),
+						);
+					} else {
+						console.log(green(`mcpx is already up to date (v${pkg.version})`));
+					}
+					return;
+				}
+
+				const method: InstallMethod = detectInstallMethod();
+				spinner?.update({
+					text: `Upgrading from v${pkg.version} to v${latestVersion} (${method})...`,
+				});
+
+				let success = false;
+
+				switch (method) {
+					case "bun":
+						spinner?.stop();
+						success = await upgradeWithPackageManager("bun", ["install", "-g", `@evantahler/mcpx@${latestVersion}`]);
+						break;
+
+					case "npm":
+						spinner?.stop();
+						success = await upgradeWithPackageManager("npm", ["install", "-g", `@evantahler/mcpx@${latestVersion}`]);
+						break;
+
+					case "binary":
+						spinner?.stop();
+						success = await upgradeFromBinary(latestVersion);
+						break;
+
+					case "local-dev":
+						spinner?.stop();
+						if (json) {
+							console.log(
+								JSON.stringify({
+									upgraded: false,
+									currentVersion: pkg.version,
+									latestVersion,
+									installMethod: "local-dev",
+									message: "Running from source. Use `git pull && bun install` to update.",
+								}),
+							);
+						} else {
+							console.log(yellow("Running from source. Use `git pull && bun install` to update."));
+						}
+						return;
+				}
+
+				if (success) {
+					await clearUpdateCache();
+					if (json) {
+						console.log(
+							JSON.stringify({
+								upgraded: true,
+								previousVersion: pkg.version,
+								newVersion: latestVersion,
+								installMethod: method,
+							}),
+						);
+					} else {
+						console.log(green(`Successfully upgraded mcpx: v${pkg.version} → v${latestVersion}`));
+					}
+				} else {
+					if (json) {
+						console.log(
+							JSON.stringify({
+								upgraded: false,
+								currentVersion: pkg.version,
+								latestVersion,
+								installMethod: method,
+								message: "Upgrade failed",
+							}),
+						);
+					} else {
+						console.error(red("Upgrade failed. See errors above."));
+					}
+					process.exit(1);
+				}
+			} catch (err) {
+				spinner?.error({ text: "Upgrade failed" });
+				console.error(String(err));
+				process.exit(1);
+			}
+		});
 }

package/src/commands/with-command.ts

@@ -1,24 +1,24 @@
 import type { Command } from "commander";
-import { getContext, type AppContext } from "../context.ts";
+import { type AppContext, getContext } from "../context.ts";
 import { formatError } from "../output/formatter.ts";
 import { logger, type Spinner } from "../output/logger.ts";
 
 export interface CommandContext extends AppContext {
-  spinner: Spinner;
+	spinner: Spinner;
 }
 
 interface WithCommandOptions {
-  /** Spinner text shown during execution. If omitted, no spinner is started. */
-  spinnerText?: string;
-  /** Error message for spinner.error(). Defaults to "Failed". */
-  errorLabel?: string;
+	/** Spinner text shown during execution. If omitted, no spinner is started. */
+	spinnerText?: string;
+	/** Error message for spinner.error(). Defaults to "Failed". */
+	errorLabel?: string;
 }
 
 const noopSpinner: Spinner = {
-  update() {},
-  success() {},
-  error() {},
-  stop() {},
+	update() {},
+	success() {},
+	error() {},
+	stop() {},
 };
 
 /**
@@ -34,26 +34,24 @@ const noopSpinner: Spinner = {
  * manager.close() is always called in finally.
  */
 export function withCommand<TArgs extends unknown[]>(
-  program: Command,
-  options: WithCommandOptions,
-  handler: (ctx: CommandContext, ...args: TArgs) => Promise<void>,
+	program: Command,
+	options: WithCommandOptions,
+	handler: (ctx: CommandContext, ...args: TArgs) => Promise<void>,
 ): (...args: TArgs) => Promise<void> {
-  return async (...args: TArgs) => {
-    const appCtx = await getContext(program);
-    const { manager, formatOptions } = appCtx;
+	return async (...args: TArgs) => {
+		const appCtx = await getContext(program);
+		const { manager, formatOptions } = appCtx;
 
-    const spinner = options.spinnerText
-      ? logger.startSpinner(options.spinnerText, formatOptions)
-      : noopSpinner;
+		const spinner = options.spinnerText ? logger.startSpinner(options.spinnerText, formatOptions) : noopSpinner;
 
-    try {
-      await handler({ ...appCtx, spinner }, ...args);
-    } catch (err) {
-      spinner.error(options.errorLabel ?? "Failed");
-      console.error(formatError(String(err), formatOptions));
-      process.exit(1);
-    } finally {
-      await manager.close();
-    }
-  };
+		try {
+			await handler({ ...appCtx, spinner }, ...args);
+		} catch (err) {
+			spinner.error(options.errorLabel ?? "Failed");
+			console.error(formatError(String(err), formatOptions));
+			process.exit(1);
+		} finally {
+			await manager.close();
+		}
+	};
 }

package/src/config/env.ts

@@ -4,40 +4,38 @@ const ENV_VAR_PATTERN = /\$\{([^}]+)\}/g;
 
 /** Whether to throw on missing env vars (default: true) */
 function isStrictEnv(): boolean {
-  return process.env[ENV.STRICT_ENV] !== "false";
+	return process.env[ENV.STRICT_ENV] !== "false";
 }
 
 /** Replace ${VAR_NAME} in a string with the corresponding env var value */
 export function interpolateEnvString(value: string): string {
-  return value.replace(ENV_VAR_PATTERN, (_match, varName: string) => {
-    const envValue = process.env[varName];
-    if (envValue === undefined) {
-      if (isStrictEnv()) {
-        throw new Error(
-          `Environment variable "${varName}" is not set (set ${ENV.STRICT_ENV}=false to warn instead)`,
-        );
-      }
-      console.warn(`Warning: environment variable "${varName}" is not set`);
-      return "";
-    }
-    return envValue;
-  });
+	return value.replace(ENV_VAR_PATTERN, (_match, varName: string) => {
+		const envValue = process.env[varName];
+		if (envValue === undefined) {
+			if (isStrictEnv()) {
+				throw new Error(`Environment variable "${varName}" is not set (set ${ENV.STRICT_ENV}=false to warn instead)`);
+			}
+			console.warn(`Warning: environment variable "${varName}" is not set`);
+			return "";
+		}
+		return envValue;
+	});
 }
 
 /** Recursively interpolate env vars in all string values of an object */
 export function interpolateEnv<T>(obj: T): T {
-  if (typeof obj === "string") {
-    return interpolateEnvString(obj) as T;
-  }
-  if (Array.isArray(obj)) {
-    return obj.map((item) => interpolateEnv(item)) as T;
-  }
-  if (typeof obj === "object" && obj !== null) {
-    const result: Record<string, unknown> = {};
-    for (const [key, value] of Object.entries(obj)) {
-      result[key] = interpolateEnv(value);
-    }
-    return result as T;
-  }
-  return obj;
+	if (typeof obj === "string") {
+		return interpolateEnvString(obj) as T;
+	}
+	if (Array.isArray(obj)) {
+		return obj.map((item) => interpolateEnv(item)) as T;
+	}
+	if (typeof obj === "object" && obj !== null) {
+		const result: Record<string, unknown> = {};
+		for (const [key, value] of Object.entries(obj)) {
+			result[key] = interpolateEnv(value);
+		}
+		return result as T;
+	}
+	return obj;
 }