claudeup 6.2.0 → 6.3.0

package/src/services/manifest.ts

@@ -7,8 +7,8 @@
  * structural subset of a v2 manifest entry, so migration is a version bump.
  */
 
-import fs from "fs-extra";
 import path from "node:path";
+import fs from "fs-extra";
 import type { ProfileManifest, ProfileManifestEntry } from "../types/index.js";
 
 const PROFILES_FILE = "profiles.json";

package/src/services/marketplace-catalog-git.ts

@@ -32,8 +32,8 @@ import fs from "node:fs";
 import path from "node:path";
 import { claudeConfigDirOrNull } from "../utils/config-dir.js";
 import {
-	normalizeCatalogJson,
 	type MarketplacePlugin,
+	normalizeCatalogJson,
 } from "./marketplace-catalog.js";
 
 /** Network reach; a wedged fetch must never hold up the screen. */
@@ -160,7 +160,10 @@ export async function readCatalogFromRemote(
 	}
 
 	try {
-		const plugins = normalizeCatalogJson(marketplaceName, JSON.parse(shown.out));
+		const plugins = normalizeCatalogJson(
+			marketplaceName,
+			JSON.parse(shown.out),
+		);
 		catalogCache.set(marketplaceName, plugins);
 		return plugins;
 	} catch {

package/src/services/marketplace-fetcher.ts

@@ -9,35 +9,35 @@
 
 import { isValidGitHubRepo } from "../utils/string-utils.js";
 import {
-  clearCachedCatalogs,
-  readCachedCatalog,
-  writeCachedCatalog,
+	clearCachedCatalogs,
+	readCachedCatalog,
+	writeCachedCatalog,
 } from "./catalog-cache-store.js";
 import {
-  cooldownFor,
-  describeCooldown,
-  hydrateGitHubBudget,
-  recordRateLimit,
-  recordSuccess,
-  type GitHubHost,
+	type GitHubHost,
+	cooldownFor,
+	describeCooldown,
+	hydrateGitHubBudget,
+	recordRateLimit,
+	recordSuccess,
 } from "./github-budget.js";
 import type { LocalMarketplace } from "./local-marketplace.js";
 import {
-  clearGitCatalogCache,
-  readCatalogFromRemote,
+	clearGitCatalogCache,
+	readCatalogFromRemote,
 } from "./marketplace-catalog-git.js";
 import {
-  clearMarketplaceVersionCache,
-  normalizeCatalogJson,
-  type MarketplacePlugin,
+	type MarketplacePlugin,
+	clearMarketplaceVersionCache,
+	normalizeCatalogJson,
 } from "./marketplace-catalog.js";
 
 // Re-exported: these used to live here, and plugin-manager plus several screens
 // import them from this module.
 export {
-  getMarketplaceVersion,
-  normalizeCatalogJson,
-  type MarketplacePlugin,
+	getMarketplaceVersion,
+	normalizeCatalogJson,
+	type MarketplacePlugin,
 } from "./marketplace-catalog.js";
 
 // Session-level cache for fetched marketplace data (no TTL - persists until explicit refresh)
@@ -45,31 +45,31 @@ const marketplaceCache = new Map<string, MarketplacePlugin[]>();
 
 /** Why a catalog fetch did not produce an authoritative plugin list. */
 export type MarketplaceFetchFailureKind =
-  | "rate-limited"
-  | "http"
-  | "timeout"
-  | "network"
-  | "invalid-repo"
-  | "invalid-content";
+	| "rate-limited"
+	| "http"
+	| "timeout"
+	| "network"
+	| "invalid-repo"
+	| "invalid-content";
 
 export interface MarketplaceFetchFailure {
-  marketplace: string;
-  kind: MarketplaceFetchFailureKind;
-  httpStatus?: number;
-  /** Short, user-facing reason — rendered verbatim in the TUI. */
-  detail: string;
-  /**
-   * Wall-clock ms when a retry is due, for rate limits. Lets the UI count down
-   * and retry itself instead of telling the user to try again "later" and leaving
-   * them to guess how much later.
-   */
-  retryAt?: number;
+	marketplace: string;
+	kind: MarketplaceFetchFailureKind;
+	httpStatus?: number;
+	/** Short, user-facing reason — rendered verbatim in the TUI. */
+	detail: string;
+	/**
+	 * Wall-clock ms when a retry is due, for rate limits. Lets the UI count down
+	 * and retry itself instead of telling the user to try again "later" and leaving
+	 * them to guess how much later.
+	 */
+	retryAt?: number;
 }
 
 export interface MarketplaceFetchResult {
-  plugins: MarketplacePlugin[];
-  /** Present exactly when `plugins` is not an authoritative remote answer. */
-  failure?: MarketplaceFetchFailure;
+	plugins: MarketplacePlugin[];
+	/** Present exactly when `plugins` is not an authoritative remote answer. */
+	failure?: MarketplaceFetchFailure;
 }
 
 /**
@@ -88,17 +88,17 @@ export type CatalogSource = "remote" | "remote-git" | "local-clone" | "none";
 
 /** Sources whose versions may be reported to the user as current. */
 export function isAuthoritative(source: CatalogSource): boolean {
-  return source === "remote" || source === "remote-git";
+	return source === "remote" || source === "remote-git";
 }
 
 export interface MarketplaceResolution {
-  plugins: MarketplacePlugin[];
-  source: CatalogSource;
-  /**
-   * The remote failure, if any. Set even when `source` is `local-clone` — the
-   * fallback succeeded, but the versions in it are not known to be current.
-   */
-  failure?: MarketplaceFetchFailure;
+	plugins: MarketplacePlugin[];
+	source: CatalogSource;
+	/**
+	 * The remote failure, if any. Set even when `source` is `local-clone` — the
+	 * fallback succeeded, but the versions in it are not known to be current.
+	 */
+	failure?: MarketplaceFetchFailure;
 }
 
 /**
@@ -114,19 +114,22 @@ export interface MarketplaceResolution {
  * freezes the catalog for a whole session — which would be the same
  * silent-staleness trap this module exists to close.
  */
-const failureCache = new Map<string, { failure: MarketplaceFetchFailure; at: number }>();
+const failureCache = new Map<
+	string,
+	{ failure: MarketplaceFetchFailure; at: number }
+>();
 const NEGATIVE_TTL_MS = 60_000;
 
 /** Monotonic clock, so a system clock change cannot expire the cache early. */
 function now(): number {
-  return performance.now();
+	return performance.now();
 }
 
 export function clearMarketplaceCache(): void {
-  marketplaceCache.clear();
-  clearMarketplaceVersionCache();
-  clearGitCatalogCache();
-  failureCache.clear();
+	marketplaceCache.clear();
+	clearMarketplaceVersionCache();
+	clearGitCatalogCache();
+	failureCache.clear();
 }
 
 /**
@@ -141,7 +144,7 @@ export function clearMarketplaceCache(): void {
  * and refetches by itself when the window opens.
  */
 export async function clearPersistedCatalogs(): Promise<void> {
-  await clearCachedCatalogs();
+	await clearCachedCatalogs();
 }
 
 /**
@@ -151,30 +154,30 @@ export async function clearPersistedCatalogs(): Promise<void> {
  * only proof that the versions on screen were actually checked against GitHub.
  */
 export function getMarketplaceFetchFailures(): MarketplaceFetchFailure[] {
-  const out: MarketplaceFetchFailure[] = [];
-  for (const [, entry] of failureCache) {
-    if (now() - entry.at < NEGATIVE_TTL_MS) out.push(entry.failure);
-  }
-  return out;
+	const out: MarketplaceFetchFailure[] = [];
+	for (const [, entry] of failureCache) {
+		if (now() - entry.at < NEGATIVE_TTL_MS) out.push(entry.failure);
+	}
+	return out;
 }
 
 /** Record a failure and return it as the result, so callers cannot ignore it. */
 function fail(
-  marketplace: string,
-  kind: MarketplaceFetchFailureKind,
-  detail: string,
-  httpStatus?: number,
-  retryAt?: number,
+	marketplace: string,
+	kind: MarketplaceFetchFailureKind,
+	detail: string,
+	httpStatus?: number,
+	retryAt?: number,
 ): MarketplaceFetchResult {
-  const failure: MarketplaceFetchFailure = {
-    marketplace,
-    kind,
-    detail,
-    httpStatus,
-    retryAt,
-  };
-  failureCache.set(marketplace, { failure, at: now() });
-  return { plugins: [], failure };
+	const failure: MarketplaceFetchFailure = {
+		marketplace,
+		kind,
+		detail,
+		httpStatus,
+		retryAt,
+	};
+	failureCache.set(marketplace, { failure, at: now() });
+	return { plugins: [], failure };
 }
 
 /**
@@ -185,19 +188,19 @@ function fail(
  * right now", the second is usually "this machine has no route at all".
  */
 function classifyThrown(
-  marketplace: string,
-  error: unknown,
+	marketplace: string,
+	error: unknown,
 ): MarketplaceFetchResult {
-  const name = (error as { name?: string } | null)?.name;
-  if (name === "TimeoutError" || name === "AbortError") {
-    return fail(
-      marketplace,
-      "timeout",
-      `no response in ${FETCH_TIMEOUT_MS / 1000}s`,
-    );
-  }
-  const message = error instanceof Error ? error.message : String(error);
-  return fail(marketplace, "network", message);
+	const name = (error as { name?: string } | null)?.name;
+	if (name === "TimeoutError" || name === "AbortError") {
+		return fail(
+			marketplace,
+			"timeout",
+			`no response in ${FETCH_TIMEOUT_MS / 1000}s`,
+		);
+	}
+	const message = error instanceof Error ? error.message : String(error);
+	return fail(marketplace, "network", message);
 }
 
 const FETCH_TIMEOUT_MS = 10_000;
@@ -213,110 +216,113 @@ const FETCH_TIMEOUT_MS = 10_000;
  * one. A failure must be a value the caller has to look at.
  */
 export async function fetchMarketplacePlugins(
-  marketplaceName: string,
-  repo: string,
+	marketplaceName: string,
+	repo: string,
 ): Promise<MarketplaceFetchResult> {
-  // Check cache first - session-level, no TTL
-  const cached = marketplaceCache.get(marketplaceName);
-  if (cached) {
-    return { plugins: cached };
-  }
-
-  // A fresh failure is reused rather than re-attempted: see `failureCache`.
-  const priorFailure = failureCache.get(marketplaceName);
-  if (priorFailure && now() - priorFailure.at < NEGATIVE_TTL_MS) {
-    return { plugins: [], failure: priorFailure.failure };
-  }
-
-  // Validate repo format to prevent SSRF
-  if (!isValidGitHubRepo(repo)) {
-    return fail(
-      marketplaceName,
-      "invalid-repo",
-      `not a valid GitHub repo: "${repo}"`,
-    );
-  }
-
-  const host: GitHubHost = "raw.githubusercontent.com";
-
-  // Cooldowns recorded by a PREVIOUS launch count too. Without this the gate is
-  // per-process, and a TUI's process lives for one screen session.
-  await hydrateGitHubBudget();
-
-  // Already known to be rate-limited: do not spend an attempt to rediscover it.
-  // The budget is per-host and shared with every other service, so six
-  // marketplaces used to trip the same limit six times over — and on some
-  // endpoints a rejected request extends the penalty.
-  const cooling = cooldownFor(host);
-  if (cooling) {
-    return fail(
-      marketplaceName,
-      "rate-limited",
-      describeCooldown(cooling),
-      429,
-      cooling.until,
-    );
-  }
-
-  try {
-    // Fetch marketplace.json from GitHub
-    const url = `https://raw.githubusercontent.com/${repo}/main/.claude-plugin/marketplace.json`;
-    const response = await fetch(url, {
-      signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
-    });
-
-    if (!response.ok) {
-      // 429/403 are the rate-limit shapes GitHub returns for unauthenticated
-      // traffic. Called out separately because the fix is "wait, or
-      // authenticate", not "check your network".
-      const rateLimited = response.status === 429 || response.status === 403;
-      if (rateLimited) {
-        // Hand the response headers over: api.github.com states when the window
-        // reopens, raw.githubusercontent.com states nothing, and the budget
-        // module is what knows the difference.
-        const cooldown = recordRateLimit(host, response.headers);
-        return fail(
-          marketplaceName,
-          "rate-limited",
-          describeCooldown(cooldown),
-          response.status,
-          cooldown.until,
-        );
-      }
-      return fail(
-        marketplaceName,
-        "http",
-        `HTTP ${response.status} ${response.statusText}`.trim(),
-        response.status,
-      );
-    }
-
-    // Validate content-type
-    const contentType = response.headers.get("content-type");
-    if (
-      contentType &&
-      !contentType.includes("application/json") &&
-      !contentType.includes("text/plain")
-    ) {
-      return fail(
-        marketplaceName,
-        "invalid-content",
-        `unexpected content-type "${contentType}"`,
-      );
-    }
-
-    const plugins = normalizeCatalogJson(marketplaceName, await response.json());
-
-    // Cache the result (session-level)
-    marketplaceCache.set(marketplaceName, plugins);
-    // A success retires any recorded failure, so the banner clears itself.
-    failureCache.delete(marketplaceName);
-    recordSuccess(host);
-
-    return { plugins };
-  } catch (error) {
-    return classifyThrown(marketplaceName, error);
-  }
+	// Check cache first - session-level, no TTL
+	const cached = marketplaceCache.get(marketplaceName);
+	if (cached) {
+		return { plugins: cached };
+	}
+
+	// A fresh failure is reused rather than re-attempted: see `failureCache`.
+	const priorFailure = failureCache.get(marketplaceName);
+	if (priorFailure && now() - priorFailure.at < NEGATIVE_TTL_MS) {
+		return { plugins: [], failure: priorFailure.failure };
+	}
+
+	// Validate repo format to prevent SSRF
+	if (!isValidGitHubRepo(repo)) {
+		return fail(
+			marketplaceName,
+			"invalid-repo",
+			`not a valid GitHub repo: "${repo}"`,
+		);
+	}
+
+	const host: GitHubHost = "raw.githubusercontent.com";
+
+	// Cooldowns recorded by a PREVIOUS launch count too. Without this the gate is
+	// per-process, and a TUI's process lives for one screen session.
+	await hydrateGitHubBudget();
+
+	// Already known to be rate-limited: do not spend an attempt to rediscover it.
+	// The budget is per-host and shared with every other service, so six
+	// marketplaces used to trip the same limit six times over — and on some
+	// endpoints a rejected request extends the penalty.
+	const cooling = cooldownFor(host);
+	if (cooling) {
+		return fail(
+			marketplaceName,
+			"rate-limited",
+			describeCooldown(cooling),
+			429,
+			cooling.until,
+		);
+	}
+
+	try {
+		// Fetch marketplace.json from GitHub
+		const url = `https://raw.githubusercontent.com/${repo}/main/.claude-plugin/marketplace.json`;
+		const response = await fetch(url, {
+			signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+		});
+
+		if (!response.ok) {
+			// 429/403 are the rate-limit shapes GitHub returns for unauthenticated
+			// traffic. Called out separately because the fix is "wait, or
+			// authenticate", not "check your network".
+			const rateLimited = response.status === 429 || response.status === 403;
+			if (rateLimited) {
+				// Hand the response headers over: api.github.com states when the window
+				// reopens, raw.githubusercontent.com states nothing, and the budget
+				// module is what knows the difference.
+				const cooldown = recordRateLimit(host, response.headers);
+				return fail(
+					marketplaceName,
+					"rate-limited",
+					describeCooldown(cooldown),
+					response.status,
+					cooldown.until,
+				);
+			}
+			return fail(
+				marketplaceName,
+				"http",
+				`HTTP ${response.status} ${response.statusText}`.trim(),
+				response.status,
+			);
+		}
+
+		// Validate content-type
+		const contentType = response.headers.get("content-type");
+		if (
+			contentType &&
+			!contentType.includes("application/json") &&
+			!contentType.includes("text/plain")
+		) {
+			return fail(
+				marketplaceName,
+				"invalid-content",
+				`unexpected content-type "${contentType}"`,
+			);
+		}
+
+		const plugins = normalizeCatalogJson(
+			marketplaceName,
+			await response.json(),
+		);
+
+		// Cache the result (session-level)
+		marketplaceCache.set(marketplaceName, plugins);
+		// A success retires any recorded failure, so the banner clears itself.
+		failureCache.delete(marketplaceName);
+		recordSuccess(host);
+
+		return { plugins };
+	} catch (error) {
+		return classifyThrown(marketplaceName, error);
+	}
 }
 
 /**
@@ -341,54 +347,54 @@ export async function fetchMarketplacePlugins(
  * reporting a guess as a fact.
  */
 export async function resolveMarketplacePlugins(
-  mpName: string,
-  repo: string,
-  localMarketplaces: Map<string, LocalMarketplace>,
+	mpName: string,
+	repo: string,
+	localMarketplaces: Map<string, LocalMarketplace>,
 ): Promise<MarketplaceResolution> {
-  // Disk cache first, so a relaunch costs no network at all. Measured before this
-  // existed: every process spent six requests and ~13s re-fetching catalogs it had
-  // already read minutes earlier.
-  const cached = await readCachedCatalog(mpName);
-  if (cached) {
-    return {
-      plugins: cached.plugins,
-      source: cached.source as CatalogSource,
-    };
-  }
-
-  const remote = await fetchMarketplacePlugins(mpName, repo);
-  if (remote.plugins.length > 0) {
-    void writeCachedCatalog(mpName, remote.plugins, "remote");
-    return { plugins: remote.plugins, source: "remote" };
-  }
-
-  // HTTP failed — most often rate-limited. Before falling back to the pinned
-  // working tree, ask git for upstream's catalog. `git fetch` moves only remote
-  // refs, so this respects `autoUpdate: false` (the install source stays pinned)
-  // while still answering "what version exists upstream". It is also on a
-  // different transport, so a raw.githubusercontent.com rate limit does not
-  // affect it.
-  const viaGit = await readCatalogFromRemote(mpName);
-  if (viaGit && viaGit.length > 0) {
-    void writeCachedCatalog(mpName, viaGit, "remote-git");
-    return { plugins: viaGit, source: "remote-git", failure: remote.failure };
-  }
-
-  const local = localMarketplaces.get(mpName);
-  if (!local || local.plugins.length === 0) {
-    return { plugins: [], source: "none", failure: remote.failure };
-  }
-
-  return {
-    plugins: local.plugins.map((p) => ({
-      name: p.name,
-      version: p.version,
-      description: p.description,
-      category: p.category,
-      author: p.author,
-      releases: p.releases,
-    })),
-    source: "local-clone",
-    failure: remote.failure,
-  };
+	// Disk cache first, so a relaunch costs no network at all. Measured before this
+	// existed: every process spent six requests and ~13s re-fetching catalogs it had
+	// already read minutes earlier.
+	const cached = await readCachedCatalog(mpName);
+	if (cached) {
+		return {
+			plugins: cached.plugins,
+			source: cached.source as CatalogSource,
+		};
+	}
+
+	const remote = await fetchMarketplacePlugins(mpName, repo);
+	if (remote.plugins.length > 0) {
+		void writeCachedCatalog(mpName, remote.plugins, "remote");
+		return { plugins: remote.plugins, source: "remote" };
+	}
+
+	// HTTP failed — most often rate-limited. Before falling back to the pinned
+	// working tree, ask git for upstream's catalog. `git fetch` moves only remote
+	// refs, so this respects `autoUpdate: false` (the install source stays pinned)
+	// while still answering "what version exists upstream". It is also on a
+	// different transport, so a raw.githubusercontent.com rate limit does not
+	// affect it.
+	const viaGit = await readCatalogFromRemote(mpName);
+	if (viaGit && viaGit.length > 0) {
+		void writeCachedCatalog(mpName, viaGit, "remote-git");
+		return { plugins: viaGit, source: "remote-git", failure: remote.failure };
+	}
+
+	const local = localMarketplaces.get(mpName);
+	if (!local || local.plugins.length === 0) {
+		return { plugins: [], source: "none", failure: remote.failure };
+	}
+
+	return {
+		plugins: local.plugins.map((p) => ({
+			name: p.name,
+			version: p.version,
+			description: p.description,
+			category: p.category,
+			author: p.author,
+			releases: p.releases,
+		})),
+		source: "local-clone",
+		failure: remote.failure,
+	};
 }