@evantahler/mcpx 0.18.2 → 0.18.5

package/src/update/background.ts

@@ -1,23 +1,23 @@
-import { yellow, cyan, dim } from "ansis";
+import { cyan, dim, yellow } from "ansis";
 import pkg from "../../package.json";
-import { ENV, DEFAULTS } from "../constants.ts";
-import { checkForUpdate, needsCheck, type UpdateCache } from "./checker.ts";
+import { DEFAULTS, ENV } from "../constants.ts";
 import { loadUpdateCache, saveUpdateCache } from "./cache.ts";
+import { checkForUpdate, needsCheck, type UpdateCache } from "./checker.ts";
 
 /** Format an update notice for stderr output. */
 function formatNotice(currentVersion: string, latestVersion: string, changelog?: string): string {
-  const lines: string[] = ["", yellow(`Update available: ${currentVersion} → ${latestVersion}`)];
+	const lines: string[] = ["", yellow(`Update available: ${currentVersion} → ${latestVersion}`)];
 
-  if (changelog) {
-    lines.push("");
-    lines.push(dim(changelog));
-  }
+	if (changelog) {
+		lines.push("");
+		lines.push(dim(changelog));
+	}
 
-  lines.push("");
-  lines.push(cyan(`Run \`mcpx upgrade\` to update`));
-  lines.push("");
+	lines.push("");
+	lines.push(cyan(`Run \`mcpx upgrade\` to update`));
+	lines.push("");
 
-  return lines.join("\n");
+	return lines.join("\n");
 }
 
 /**
@@ -25,52 +25,52 @@ function formatNotice(currentVersion: string, latestVersion: string, changelog?:
  * if an update is available, or null otherwise. Never throws.
  */
 export async function maybeCheckForUpdate(): Promise<string | null> {
-  try {
-    // Opt-out via env var
-    if (process.env[ENV.NO_UPDATE_CHECK] === "1") return null;
+	try {
+		// Opt-out via env var
+		if (process.env[ENV.NO_UPDATE_CHECK] === "1") return null;
 
-    // Skip if this is the check-update or upgrade command
-    const args = process.argv.slice(2);
-    const command = args.find((a) => !a.startsWith("-"));
-    if (command === "check-update" || command === "upgrade") return null;
+		// Skip if this is the check-update or upgrade command
+		const args = process.argv.slice(2);
+		const command = args.find((a) => !a.startsWith("-"));
+		if (command === "check-update" || command === "upgrade") return null;
 
-    // Only show in TTY
-    if (!(process.stderr.isTTY ?? false)) return null;
+		// Only show in TTY
+		if (!(process.stderr.isTTY ?? false)) return null;
 
-    const cache = await loadUpdateCache();
+		const cache = await loadUpdateCache();
 
-    if (!needsCheck(cache)) {
-      // Cache is fresh — use cached result
-      if (cache?.hasUpdate) {
-        return formatNotice(pkg.version, cache.latestVersion, cache.changelog);
-      }
-      return null;
-    }
+		if (!needsCheck(cache)) {
+			// Cache is fresh — use cached result
+			if (cache?.hasUpdate) {
+				return formatNotice(pkg.version, cache.latestVersion, cache.changelog);
+			}
+			return null;
+		}
 
-    // Cache is stale or missing — check with timeout
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), DEFAULTS.UPDATE_CHECK_TIMEOUT_MS);
+		// Cache is stale or missing — check with timeout
+		const controller = new AbortController();
+		const timeout = setTimeout(() => controller.abort(), DEFAULTS.UPDATE_CHECK_TIMEOUT_MS);
 
-    try {
-      const info = await checkForUpdate(pkg.version, controller.signal);
+		try {
+			const info = await checkForUpdate(pkg.version, controller.signal);
 
-      const newCache: UpdateCache = {
-        lastCheckAt: new Date().toISOString(),
-        latestVersion: info.latestVersion,
-        hasUpdate: info.hasUpdate,
-        changelog: info.changelog,
-      };
-      await saveUpdateCache(newCache);
+			const newCache: UpdateCache = {
+				lastCheckAt: new Date().toISOString(),
+				latestVersion: info.latestVersion,
+				hasUpdate: info.hasUpdate,
+				changelog: info.changelog,
+			};
+			await saveUpdateCache(newCache);
 
-      if (info.hasUpdate) {
-        return formatNotice(pkg.version, info.latestVersion, info.changelog);
-      }
-    } finally {
-      clearTimeout(timeout);
-    }
+			if (info.hasUpdate) {
+				return formatNotice(pkg.version, info.latestVersion, info.changelog);
+			}
+		} finally {
+			clearTimeout(timeout);
+		}
 
-    return null;
-  } catch {
-    return null;
-  }
+		return null;
+	} catch {
+		return null;
+	}
 }

package/src/update/cache.ts

@@ -1,4 +1,4 @@
-import { join } from "path";
+import { join } from "node:path";
 import { DEFAULT_CONFIG_DIR } from "../constants.ts";
 import type { UpdateCache } from "./checker.ts";
 
@@ -6,32 +6,32 @@ const UPDATE_CACHE_PATH = join(DEFAULT_CONFIG_DIR, "update.json");
 
 /** Load the cached update check result, if it exists. */
 export async function loadUpdateCache(): Promise<UpdateCache | undefined> {
-  try {
-    const file = Bun.file(UPDATE_CACHE_PATH);
-    if (!(await file.exists())) return undefined;
-    return JSON.parse(await file.text()) as UpdateCache;
-  } catch {
-    return undefined;
-  }
+	try {
+		const file = Bun.file(UPDATE_CACHE_PATH);
+		if (!(await file.exists())) return undefined;
+		return JSON.parse(await file.text()) as UpdateCache;
+	} catch {
+		return undefined;
+	}
 }
 
 /** Save update check result to the cache file. */
 export async function saveUpdateCache(cache: UpdateCache): Promise<void> {
-  try {
-    await Bun.write(UPDATE_CACHE_PATH, JSON.stringify(cache, null, 2) + "\n");
-  } catch {
-    // Ignore write failures (e.g. permissions)
-  }
+	try {
+		await Bun.write(UPDATE_CACHE_PATH, `${JSON.stringify(cache, null, 2)}\n`);
+	} catch {
+		// Ignore write failures (e.g. permissions)
+	}
 }
 
 /** Remove the cached update check result. */
 export async function clearUpdateCache(): Promise<void> {
-  try {
-    const file = Bun.file(UPDATE_CACHE_PATH);
-    if (await file.exists()) {
-      await Bun.write(UPDATE_CACHE_PATH, "");
-    }
-  } catch {
-    // Ignore
-  }
+	try {
+		const file = Bun.file(UPDATE_CACHE_PATH);
+		if (await file.exists()) {
+			await Bun.write(UPDATE_CACHE_PATH, "");
+		}
+	} catch {
+		// Ignore
+	}
 }

package/src/update/checker.ts

@@ -2,121 +2,116 @@ import pkg from "../../package.json";
 import { DEFAULTS } from "../constants.ts";
 
 const NPM_REGISTRY_URL = `https://registry.npmjs.org/${pkg.name}/latest`;
-const GITHUB_REPO = pkg.repository.url
-  .replace(/^https:\/\/github\.com\//, "")
-  .replace(/\.git$/, "");
+const GITHUB_REPO = pkg.repository.url.replace(/^https:\/\/github\.com\//, "").replace(/\.git$/, "");
 
 export interface UpdateInfo {
-  currentVersion: string;
-  latestVersion: string;
-  hasUpdate: boolean;
-  aheadOfLatest: boolean;
-  changelog?: string;
+	currentVersion: string;
+	latestVersion: string;
+	hasUpdate: boolean;
+	aheadOfLatest: boolean;
+	changelog?: string;
 }
 
 export interface UpdateCache {
-  lastCheckAt: string;
-  latestVersion: string;
-  hasUpdate: boolean;
-  changelog?: string;
+	lastCheckAt: string;
+	latestVersion: string;
+	hasUpdate: boolean;
+	changelog?: string;
 }
 
 export type InstallMethod = "npm" | "bun" | "binary" | "local-dev";
 
 /** Compare two semver strings. Returns true if latest > current. */
 export function isNewerVersion(current: string, latest: string): boolean {
-  return Bun.semver.order(current, latest) === -1;
+	return Bun.semver.order(current, latest) === -1;
 }
 
 /** Fetch the latest version from the npm registry. */
 export async function fetchLatestVersion(signal?: AbortSignal): Promise<string> {
-  try {
-    const res = await fetch(NPM_REGISTRY_URL, { signal });
-    if (!res.ok) return pkg.version;
-    const data = (await res.json()) as { version: string };
-    return data.version;
-  } catch {
-    return pkg.version;
-  }
+	try {
+		const res = await fetch(NPM_REGISTRY_URL, { signal });
+		if (!res.ok) return pkg.version;
+		const data = (await res.json()) as { version: string };
+		return data.version;
+	} catch {
+		return pkg.version;
+	}
 }
 
 /** Fetch changelog from GitHub releases between two versions. */
 export async function fetchChangelog(
-  fromVersion: string,
-  toVersion: string,
-  signal?: AbortSignal,
+	fromVersion: string,
+	toVersion: string,
+	signal?: AbortSignal,
 ): Promise<string | undefined> {
-  try {
-    const res = await fetch(`https://api.github.com/repos/${GITHUB_REPO}/releases?per_page=20`, {
-      signal,
-      headers: { Accept: "application/vnd.github.v3+json" },
-    });
-    if (!res.ok) return undefined;
-
-    const releases = (await res.json()) as Array<{
-      tag_name: string;
-      body: string | null;
-    }>;
-
-    const relevant = releases.filter((r) => {
-      const v = r.tag_name.replace(/^v/, "");
-      return isNewerVersion(fromVersion, v) && !isNewerVersion(toVersion, v);
-    });
-
-    if (relevant.length === 0) return undefined;
-
-    return relevant
-      .map((r) => `## ${r.tag_name}\n${r.body ?? ""}`)
-      .join("\n\n")
-      .trim();
-  } catch {
-    return undefined;
-  }
+	try {
+		const res = await fetch(`https://api.github.com/repos/${GITHUB_REPO}/releases?per_page=20`, {
+			signal,
+			headers: { Accept: "application/vnd.github.v3+json" },
+		});
+		if (!res.ok) return undefined;
+
+		const releases = (await res.json()) as Array<{
+			tag_name: string;
+			body: string | null;
+		}>;
+
+		const relevant = releases.filter((r) => {
+			const v = r.tag_name.replace(/^v/, "");
+			return isNewerVersion(fromVersion, v) && !isNewerVersion(toVersion, v);
+		});
+
+		if (relevant.length === 0) return undefined;
+
+		return relevant
+			.map((r) => `## ${r.tag_name}\n${r.body ?? ""}`)
+			.join("\n\n")
+			.trim();
+	} catch {
+		return undefined;
+	}
 }
 
 /** Check npm for a newer version and fetch changelog if available. */
-export async function checkForUpdate(
-  currentVersion: string,
-  signal?: AbortSignal,
-): Promise<UpdateInfo> {
-  const latestVersion = await fetchLatestVersion(signal);
-  const hasUpdate = isNewerVersion(currentVersion, latestVersion);
-  const aheadOfLatest = isNewerVersion(latestVersion, currentVersion);
-
-  let changelog: string | undefined;
-  if (hasUpdate) {
-    changelog = await fetchChangelog(currentVersion, latestVersion, signal);
-  }
-
-  return { currentVersion, latestVersion, hasUpdate, aheadOfLatest, changelog };
+export async function checkForUpdate(currentVersion: string, signal?: AbortSignal): Promise<UpdateInfo> {
+	const latestVersion = await fetchLatestVersion(signal);
+	const hasUpdate = isNewerVersion(currentVersion, latestVersion);
+	const aheadOfLatest = isNewerVersion(latestVersion, currentVersion);
+
+	let changelog: string | undefined;
+	if (hasUpdate) {
+		changelog = await fetchChangelog(currentVersion, latestVersion, signal);
+	}
+
+	return { currentVersion, latestVersion, hasUpdate, aheadOfLatest, changelog };
 }
 
 /** Returns true if the cache is missing or older than 24 hours. */
 export function needsCheck(cache?: UpdateCache): boolean {
-  if (!cache?.lastCheckAt) return true;
-  return Date.now() - new Date(cache.lastCheckAt).getTime() > DEFAULTS.UPDATE_CHECK_INTERVAL_MS;
+	if (!cache?.lastCheckAt) return true;
+	return Date.now() - new Date(cache.lastCheckAt).getTime() > DEFAULTS.UPDATE_CHECK_INTERVAL_MS;
 }
 
 /** Detect how mcpx was installed. */
 export function detectInstallMethod(): InstallMethod {
-  const script = process.argv[1] ?? "";
-  const execPath = process.execPath;
-
-  // Local dev: running src/cli.ts directly outside node_modules
-  if (script.includes("src/cli.ts") && !script.includes("node_modules")) {
-    return "local-dev";
-  }
-
-  // Compiled binary: execPath is the binary itself (not bun/node)
-  if (!execPath.includes("bun") && !execPath.includes("node")) {
-    return "binary";
-  }
-
-  // Bun global install: path contains .bun/install
-  if (script.includes(".bun/install") || script.includes(".bun/bin")) {
-    return "bun";
-  }
-
-  // npm global install: fallback for node_modules paths
-  return "npm";
+	const script = process.argv[1] ?? "";
+	const execPath = process.execPath;
+
+	// Local dev: running src/cli.ts directly outside node_modules
+	if (script.includes("src/cli.ts") && !script.includes("node_modules")) {
+		return "local-dev";
+	}
+
+	// Compiled binary: execPath is the binary itself (not bun/node)
+	if (!execPath.includes("bun") && !execPath.includes("node")) {
+		return "binary";
+	}
+
+	// Bun global install: path contains .bun/install
+	if (script.includes(".bun/install") || script.includes(".bun/bin")) {
+		return "bun";
+	}
+
+	// npm global install: fallback for node_modules paths
+	return "npm";
 }

package/src/validation/schema.ts

@@ -7,85 +7,79 @@ const ajv = new Ajv({ allErrors: true, strict: false });
 const validatorCache = new Map<string, ReturnType<typeof ajv.compile>>();
 
 export interface ValidationError {
-  path: string;
-  message: string;
+	path: string;
+	message: string;
 }
 
 export interface ValidationResult {
-  valid: boolean;
-  errors: ValidationError[];
+	valid: boolean;
+	errors: ValidationError[];
 }
 
 /** Compile (or retrieve from cache), validate, and return result */
 function validateWithSchema(
-  cacheKey: string,
-  schema: Record<string, unknown>,
-  input: Record<string, unknown>,
+	cacheKey: string,
+	schema: Record<string, unknown>,
+	input: Record<string, unknown>,
 ): ValidationResult {
-  let validate = validatorCache.get(cacheKey);
+	let validate = validatorCache.get(cacheKey);
 
-  if (!validate) {
-    try {
-      validate = ajv.compile(schema);
-      validatorCache.set(cacheKey, validate);
-    } catch {
-      return { valid: true, errors: [] };
-    }
-  }
+	if (!validate) {
+		try {
+			validate = ajv.compile(schema);
+			validatorCache.set(cacheKey, validate);
+		} catch {
+			return { valid: true, errors: [] };
+		}
+	}
 
-  const valid = validate(input);
-  if (valid) {
-    return { valid: true, errors: [] };
-  }
+	const valid = validate(input);
+	if (valid) {
+		return { valid: true, errors: [] };
+	}
 
-  const errors = (validate.errors ?? []).map(formatAjvError);
-  return { valid: false, errors };
+	const errors = (validate.errors ?? []).map(formatAjvError);
+	return { valid: false, errors };
 }
 
 /** Validate tool arguments against the tool's inputSchema */
-export function validateToolInput(
-  serverName: string,
-  tool: Tool,
-  input: Record<string, unknown>,
-): ValidationResult {
-  const schema = tool.inputSchema;
-  if (!schema || Object.keys(schema).length === 0) {
-    return { valid: true, errors: [] };
-  }
-  return validateWithSchema(`${serverName}/${tool.name}`, schema, input);
+export function validateToolInput(serverName: string, tool: Tool, input: Record<string, unknown>): ValidationResult {
+	const schema = tool.inputSchema;
+	if (!schema || Object.keys(schema).length === 0) {
+		return { valid: true, errors: [] };
+	}
+	return validateWithSchema(`${serverName}/${tool.name}`, schema, input);
 }
 
 /** Validate user-collected form data against an elicitation requestedSchema */
 export function validateElicitationResponse(
-  schema: Record<string, unknown>,
-  input: Record<string, unknown>,
+	schema: Record<string, unknown>,
+	input: Record<string, unknown>,
 ): ValidationResult {
-  return validateWithSchema(`__elicitation__${JSON.stringify(schema)}`, schema, input);
+	return validateWithSchema(`__elicitation__${JSON.stringify(schema)}`, schema, input);
 }
 
 function formatAjvError(err: ErrorObject): ValidationError {
-  const path = err.instancePath
-    ? err.instancePath.replace(/^\//, "").replace(/\//g, ".")
-    : "(root)";
+	const path = err.instancePath ? err.instancePath.replace(/^\//, "").replace(/\//g, ".") : "(root)";
 
-  switch (err.keyword) {
-    case "required": {
-      const field = (err.params as { missingProperty: string }).missingProperty;
-      return { path: field, message: `missing required field "${field}"` };
-    }
-    case "type": {
-      const expected = (err.params as { type: string }).type;
-      return { path, message: `must be ${expected}` };
-    }
-    case "enum": {
-      const allowed = (err.params as { allowedValues: unknown[] }).allowedValues;
-      return { path, message: `must be one of: ${allowed.join(", ")}` };
-    }
-    case "additionalProperties": {
-      const extra = (err.params as { additionalProperty: string }).additionalProperty;
-      return { path: extra, message: `unknown property "${extra}"` };
-    }
-    default:
-      return { path, message: err.message ?? "validation failed" };
-  }
+	switch (err.keyword) {
+		case "required": {
+			const field = (err.params as { missingProperty: string }).missingProperty;
+			return { path: field, message: `missing required field "${field}"` };
+		}
+		case "type": {
+			const expected = (err.params as { type: string }).type;
+			return { path, message: `must be ${expected}` };
+		}
+		case "enum": {
+			const allowed = (err.params as { allowedValues: unknown[] }).allowedValues;
+			return { path, message: `must be one of: ${allowed.join(", ")}` };
+		}
+		case "additionalProperties": {
+			const extra = (err.params as { additionalProperty: string }).additionalProperty;
+			return { path: extra, message: `unknown property "${extra}"` };
+		}
+		default:
+			return { path, message: err.message ?? "validation failed" };
+	}
 }