claudeup 5.0.0 → 6.0.0

package/src/services/doctor-bins.ts

@@ -23,6 +23,12 @@ export interface BinCheckResult {
 /**
  * Check each resolved binary for presence on PATH. `isPresent` is injectable
  * for tests; it defaults to a real PATH lookup.
+ *
+ * The probes are deliberately SERIAL — a PATH walk per binary, each resolving
+ * symlinks — so a profile declaring a dozen tools spends real time here. That
+ * is what `onProbe` is for: it fires with the name about to be checked, before
+ * the await, so a caller can name the binary it is currently blocked on rather
+ * than showing a bare spinner.
  */
 export async function checkBinaries(
 	bins: ResolvedBin[],
@@ -30,9 +36,11 @@ export async function checkBinaries(
 	// (the tmux-mcp / npx-cache failure mode) reads as MISSING, not present.
 	isPresent: (name: string) => Promise<boolean> = async (name) =>
 		(await resolveExecutable(name)) !== null,
+	onProbe?: (name: string, index: number, total: number) => void,
 ): Promise<BinCheckResult[]> {
 	const results: BinCheckResult[] = [];
-	for (const bin of bins) {
+	for (const [index, bin] of bins.entries()) {
+		onProbe?.(bin.name, index, bins.length);
 		results.push({
 			name: bin.name,
 			present: await isPresent(bin.name),

package/src/services/dotenv.ts

@@ -16,9 +16,14 @@ import path from "node:path";
  * Two rules this loader keeps that the autoload did not:
  *
  *   1. Only regular files are read. A FIFO, socket or device is skipped, never
- *      opened. That dodges the crash, and it is right on its own terms: a FIFO
- *      hands its bytes to whoever opens it FIRST, so reading one would swallow
- *      the secrets a dev server or `op run` was waiting for.
+ *      opened, because opening a pipe BLOCKS until some process opens the other
+ *      end — with no writer standing by, claudeup hangs on startup instead of
+ *      running. That is the whole reason. It is NOT that reading would steal
+ *      another process's secrets: 1Password's pipe re-serves its contents on
+ *      every open, and `readFileSync` reads it correctly (`Bun.file().text()`
+ *      is the API that hangs on a FIFO). An earlier version of this comment,
+ *      the warning text, and the 4.42.1 changelog all claimed the one-reader
+ *      story; it is wrong, so do not restore it.
  *   2. Nothing here is fatal. A missing, unreadable or malformed .env produces a
  *      warning and claudeup carries on. Managing ~/.claude must never depend on
  *      the state of whatever directory you happen to be standing in.
@@ -89,7 +94,7 @@ export function parseDotenv(text: string): Record<string, string> {
 /** What a non-regular entry actually is, for a warning a human can act on. */
 function describeKind(info: Stats): string {
 	if (info.isFIFO()) {
-		return "it is a named pipe; reading it would consume another process's secrets";
+		return "it is a named pipe; opening one blocks until a writer appears, and claudeup must not hang before it starts";
 	}
 	if (info.isSocket()) return "it is a socket, not a regular file";
 	if (info.isDirectory()) return "it is a directory, not a regular file";

package/src/services/marketplace-refresh.ts

@@ -130,12 +130,44 @@ export async function fastForwardCloneIfPresent(
 	}
 }
 
+/**
+ * Progress taps, so a caller can show what is happening during the pulls.
+ *
+ * This is the slowest thing on the update path — a git fetch per marketplace,
+ * over the network, with a 30s timeout each — and it used to report only after
+ * every clone had settled.
+ *
+ * Both callbacks are purely observational and CANNOT affect the refresh: each
+ * is invoked inside a try/catch that discards whatever it throws. `onSettled`
+ * in particular runs inside the `Promise.all` fan-out, so an unguarded throw
+ * there would reject the batch and turn a display error into a failed refresh —
+ * exactly the coupling this function's "never throws" contract exists to
+ * prevent.
+ */
+export interface RefreshProgress {
+	/** The eligible set, once selection is done and before any pull starts. */
+	onStart?: (names: string[]) => void;
+	/** One clone settled. Fires in completion order, not in `names` order. */
+	onSettled?: (name: string, status: CloneRefresh) => void;
+}
+
+/** Invoke an observer without letting it affect the caller. */
+function tap(fn: (() => void) | undefined): void {
+	if (!fn) return;
+	try {
+		fn();
+	} catch {
+		// A progress display is never worth failing a refresh over.
+	}
+}
+
 /**
  * Non-destructively fast-forward the on-disk clone of every registered,
  * auto-update-enabled, github-sourced marketplace.
  *
  * @param skip marketplaces already refreshed this run (e.g. re-registered ones),
  *   so they aren't pulled twice.
+ * @param progress optional taps for a live progress display.
  * @returns which marketplaces were refreshed, which failed (clone left intact),
  *   and which were skipped. Failures and skips are collected rather than thrown —
  *   one unreachable marketplace must not block launching Claude. Pulls run
@@ -143,6 +175,7 @@ export async function fastForwardCloneIfPresent(
  */
 export async function refreshRegisteredMarketplaces(
 	skip: Iterable<string> = [],
+	progress: RefreshProgress = {},
 ): Promise<RefreshResult> {
 	const refreshed: string[] = [];
 	const failed: string[] = [];
@@ -170,8 +203,13 @@ export async function refreshRegisteredMarketplaces(
 	// Fast-forward every eligible clone in parallel so a slow one doesn't
 	// serialize the rest onto the launch path. fastForwardCloneIfPresent never
 	// throws, so the batch always resolves.
+	tap(() => progress.onStart?.([...eligible]));
 	const statuses = await Promise.all(
-		eligible.map((name) => fastForwardCloneIfPresent(name)),
+		eligible.map(async (name) => {
+			const status = await fastForwardCloneIfPresent(name);
+			tap(() => progress.onSettled?.(name, status));
+			return status;
+		}),
 	);
 
 	statuses.forEach((status, i) => {