claudeup 5.0.0 → 6.0.0

package/src/cli/live.ts

@@ -0,0 +1,374 @@
+/**
+ * live.ts — an in-place animated block that leaves its record in scrollback.
+ *
+ * `claudeup update` spends most of its wall clock inside three calls that print
+ * nothing: git pulls over the network, a catalog read, then serial binary
+ * probes. Then the apply loop prints one line per plugin, each only once that
+ * plugin has finished installing. The terminal sat frozen for the slow parts,
+ * which reads as a hang.
+ *
+ * This is the fix, and it is deliberately NOT a renderer. Two channels:
+ *
+ *   - `note()` writes a PERMANENT line. It is the record, it scrolls, and it is
+ *     printed in every mode including a pipe. Anything a user might paste into
+ *     a bug report goes here.
+ *   - `start(render)` drives a TRANSIENT block under that record, repainted on
+ *     a timer so a spinner keeps moving while an await is outstanding. It is
+ *     erased before the next note and again on `stop()`.
+ *
+ * The split is what lets the same command be both animated and pipeable. In a
+ * pipe, in CI, or under NO_COLOR the transient block is simply never painted;
+ * the notes still print, in order, exactly as before.
+ *
+ * ## Why the region hijacks `console`
+ *
+ * Anything printed while the region is live must go through `note()`. A bare
+ * `console.log` lands inside the block, and the next repaint's cursor-up count
+ * is then short by however many rows it wrote — so the erase starts partway
+ * INTO the block, leaves orphaned rows on screen, and scrolls the message that
+ * caused it out of reach.
+ *
+ * That was documented as a rule and it was not enough. `getAvailablePlugins`
+ * reaches `plugin-manager.ts`'s stale-marketplace advisory through two call
+ * layers, and it printed with a bare `console.log` from inside the catalog
+ * step: the advisory was erased unread and the frame smeared, every time a
+ * marketplace clone was stale. A rule that has to hold across a call graph this
+ * file does not own is not a rule, it is a hope.
+ *
+ * So the region CAPTURES `console` for as long as it is painting, and routes
+ * every write through the same erase-write-repaint path `note()` uses. The
+ * invariant is now a mechanism. Streams are preserved: `log`/`info` keep going
+ * to stdout and `warn`/`error` to stderr, because stderr is legitimately
+ * redirected on its own and silently moving it to stdout would break that.
+ */
+
+import { format } from "node:util";
+import { colorEnabled, truncate, width } from "./ansi.js";
+
+const HIDE_CURSOR = "\x1b[?25l";
+const SHOW_CURSOR = "\x1b[?25h";
+/** Erase from the cursor to the end of the display. */
+const ERASE_BELOW = "\x1b[0J";
+
+/**
+ * Cursor visibility and a patched `console` are process-global state, so
+ * restoring them is too.
+ *
+ * A region killed by Ctrl+C or a crash without this leaves the user typing
+ * blind in their shell — a genuinely hostile failure they have to fix with
+ * `reset`. Registered once, on first use, and never removed.
+ */
+let restoreHooked = false;
+const liveRegions = new Set<LiveRegion>();
+
+function hookRestore(): void {
+	if (restoreHooked) return;
+	restoreHooked = true;
+	const restore = () => {
+		for (const region of liveRegions) region.forceRestore();
+	};
+	process.on("exit", restore);
+	// 128 + signum is the shell convention: SIGINT 130, SIGTERM 143, SIGHUP 129.
+	// Reporting 130 for all three told a CI runner "interrupted" when it had
+	// actually sent SIGTERM.
+	for (const [signal, signum] of [
+		["SIGINT", 2],
+		["SIGTERM", 15],
+		["SIGHUP", 1],
+	] as const) {
+		process.on(signal, () => {
+			restore();
+			process.exit(128 + signum);
+		});
+	}
+}
+
+export interface LiveOptions {
+	stream?: NodeJS.WriteStream;
+	/** Stderr sink for captured `console.warn`/`console.error`. */
+	errorStream?: NodeJS.WriteStream;
+	/** Repaints per second. 12 reads as motion without strobing the spinner. */
+	fps?: number;
+	/** Force the transient block on or off. Default: TTY and colour capable. */
+	animate?: boolean;
+	/**
+	 * Capture `console` while painting. On by default — see the file header.
+	 * Off only for tests that need to assert on the real console.
+	 */
+	captureConsole?: boolean;
+}
+
+/** A frame, rebuilt from scratch each repaint. `tick` advances once per frame. */
+export type RenderFrame = (tick: number) => string[];
+
+type ConsoleMethod = "log" | "info" | "warn" | "error";
+
+export class LiveRegion {
+	private readonly stream: NodeJS.WriteStream;
+	private readonly errorStream: NodeJS.WriteStream;
+	private readonly interval: number;
+	private readonly wantsConsoleCapture: boolean;
+	/** Rows the transient block currently occupies. 0 means nothing is painted. */
+	private painted = 0;
+	private timer: ReturnType<typeof setInterval> | null = null;
+	private render: RenderFrame | null = null;
+	private tick = 0;
+	private cursorHidden = false;
+	/** True between `pause()` and `resume()`: something else owns the terminal. */
+	private paused = false;
+	private restoreConsole: (() => void) | null = null;
+	private onResize: (() => void) | null = null;
+
+	/** Whether the transient block is painted at all. */
+	readonly animated: boolean;
+
+	constructor(opts: LiveOptions = {}) {
+		this.stream = opts.stream ?? process.stdout;
+		this.errorStream = opts.errorStream ?? process.stderr;
+		this.interval = Math.max(1, Math.round(1000 / (opts.fps ?? 12)));
+		this.wantsConsoleCapture = opts.captureConsole ?? true;
+		this.animated =
+			opts.animate ?? (this.stream.isTTY === true && colorEnabled());
+		liveRegions.add(this);
+	}
+
+	/** Begin animating `render`. Replaces any frame already running. */
+	start(render: RenderFrame): void {
+		this.render = render;
+		if (!this.animated) return;
+		this.hideCursor();
+		this.captureConsole();
+		this.watchResize();
+		this.paint();
+		this.startTimer();
+	}
+
+	/** Repaint now rather than waiting for the next tick, after a state change. */
+	refresh(): void {
+		if (this.animated && this.render && !this.paused) this.paint();
+	}
+
+	/**
+	 * Write permanent lines above the block: the scrollback record.
+	 *
+	 * Erase, write, repaint — in that order. Writing first would put the line
+	 * below the block, where the next repaint's cursor-up arithmetic would
+	 * count it as part of the frame and start eating the record.
+	 */
+	note(...lines: string[]): void {
+		this.writeThrough(this.stream, lines);
+	}
+
+	/** The same, on stderr — for captured `console.warn` / `console.error`. */
+	noteError(...lines: string[]): void {
+		this.writeThrough(this.errorStream, lines);
+	}
+
+	/**
+	 * Hand the terminal to something else — a readline prompt, or a subprocess
+	 * inheriting stdio. Both move the cursor themselves, so the block has to be
+	 * gone and the cursor visible before either starts.
+	 *
+	 * `console` goes back to normal here too: whatever now owns the terminal is
+	 * writing to it directly, so routing through a region that is not painting
+	 * would reorder its output.
+	 */
+	pause(): void {
+		this.paused = true;
+		this.stopTimer();
+		this.erase();
+		this.releaseConsole();
+		this.showCursor();
+	}
+
+	/** Take the terminal back after `pause()`. */
+	resume(): void {
+		this.paused = false;
+		if (!this.animated || !this.render) return;
+		this.hideCursor();
+		this.captureConsole();
+		this.paint();
+		this.startTimer();
+	}
+
+	/**
+	 * Stop animating. `final` is written as a permanent record — the transient
+	 * frame is erased first, so the last thing on screen is the record and not a
+	 * spinner frozen mid-rotation.
+	 */
+	stop(final: string[] = []): void {
+		this.stopTimer();
+		this.erase();
+		this.render = null;
+		this.paused = false;
+		this.releaseConsole();
+		this.unwatchResize();
+		for (const line of final) this.stream.write(`${line}\n`);
+		this.showCursor();
+		liveRegions.delete(this);
+	}
+
+	/** Exit hook only: put global state back without touching anything else. */
+	forceRestore(): void {
+		this.releaseConsole();
+		this.showCursor();
+	}
+
+	// -- internals -------------------------------------------------------------
+
+	private startTimer(): void {
+		if (this.timer) return;
+		this.timer = setInterval(() => {
+			this.tick++;
+			this.paint();
+		}, this.interval);
+		// Never let the repaint timer be the reason the process stays alive.
+		this.timer.unref?.();
+	}
+
+	private stopTimer(): void {
+		if (this.timer) {
+			clearInterval(this.timer);
+			this.timer = null;
+		}
+	}
+
+	/** Erase, write the lines to `to`, repaint. The one safe write order. */
+	private writeThrough(to: NodeJS.WriteStream, lines: string[]): void {
+		if (lines.length === 0) return;
+		this.erase();
+		for (const line of lines) to.write(`${line}\n`);
+		// Never repaint while paused: something else owns the terminal, and a
+		// frame drawn under its output is both corrupt and in the way.
+		if (this.animated && this.render && !this.paused) this.paint();
+	}
+
+	/**
+	 * Route `console` through this region for as long as it is painting.
+	 *
+	 * Multi-line and format-string calls are handled by `util.format`, then
+	 * split, so `console.log("a\nb")` becomes two permanent rows rather than one
+	 * row containing a newline the erase arithmetic cannot see.
+	 */
+	private captureConsole(): void {
+		if (this.restoreConsole || !this.animated || !this.wantsConsoleCapture)
+			return;
+		const original: Record<ConsoleMethod, (...args: unknown[]) => void> = {
+			log: console.log,
+			info: console.info,
+			warn: console.warn,
+			error: console.error,
+		};
+		const route =
+			(method: ConsoleMethod, toStderr: boolean) =>
+			(...args: unknown[]) => {
+				if (this.paused || !this.render) {
+					original[method](...args);
+					return;
+				}
+				const lines = format(...args).split("\n");
+				if (toStderr) this.noteError(...lines);
+				else this.note(...lines);
+			};
+		console.log = route("log", false);
+		console.info = route("info", false);
+		console.warn = route("warn", true);
+		console.error = route("error", true);
+		this.restoreConsole = () => {
+			console.log = original.log;
+			console.info = original.info;
+			console.warn = original.warn;
+			console.error = original.error;
+			this.restoreConsole = null;
+		};
+	}
+
+	private releaseConsole(): void {
+		this.restoreConsole?.();
+	}
+
+	/**
+	 * A resize invalidates `painted`.
+	 *
+	 * `painted` is a row count measured at the OLD width, so after a narrowing
+	 * the block occupies more rows than it says and the cursor-up erase lands
+	 * inside it. There is no way to recover the true count, so the old frame is
+	 * abandoned where it stands — one stale block left in scrollback, once —
+	 * rather than mis-erased on every subsequent frame.
+	 */
+	private watchResize(): void {
+		if (this.onResize || typeof this.stream.on !== "function") return;
+		this.onResize = () => {
+			this.painted = 0;
+			if (this.animated && this.render && !this.paused) this.paint();
+		};
+		this.stream.on("resize", this.onResize);
+	}
+
+	private unwatchResize(): void {
+		if (!this.onResize) return;
+		this.stream.off?.("resize", this.onResize);
+		this.onResize = null;
+	}
+
+	private hideCursor(): void {
+		if (this.cursorHidden || !this.animated) return;
+		this.stream.write(HIDE_CURSOR);
+		this.cursorHidden = true;
+		// Only now is there global state worth restoring on the way out.
+		hookRestore();
+	}
+
+	private showCursor(): void {
+		if (!this.cursorHidden) return;
+		this.stream.write(SHOW_CURSOR);
+		this.cursorHidden = false;
+	}
+
+	private erase(): void {
+		if (this.painted === 0) return;
+		this.stream.write(`\x1b[${this.painted}A${ERASE_BELOW}`);
+		this.painted = 0;
+	}
+
+	/**
+	 * Repaint the block.
+	 *
+	 * Two clamps, both load-bearing. Lines are clipped one column short of the
+	 * terminal width, because a line that reaches the last column auto-wraps in
+	 * most terminals and then occupies two rows while `painted` still counts it
+	 * as one — the block smears a row further down the screen every frame. And
+	 * the block is capped one row short of the terminal height, because a block
+	 * taller than the viewport scrolls the terminal and moves the rows the next
+	 * cursor-up was aiming at.
+	 */
+	private paint(): void {
+		if (!this.animated || !this.render) return;
+		const cols = Math.max(20, this.stream.columns ?? 80);
+		const rows = Math.max(4, this.stream.rows ?? 24);
+		let lines = this.render(this.tick).map((l) =>
+			width(l) > cols - 1 ? truncate(l, cols - 1) : l,
+		);
+		if (lines.length > rows - 1) lines = lines.slice(0, rows - 1);
+		this.erase();
+		if (lines.length === 0) return;
+		this.stream.write(`${lines.join("\n")}\n`);
+		this.painted = lines.length;
+	}
+}
+
+/**
+ * Run `work` with the terminal handed back — for readline and for subprocesses
+ * that inherit stdio. Always resumes, including when `work` throws.
+ */
+export async function withPaused<T>(
+	region: LiveRegion,
+	work: () => Promise<T>,
+): Promise<T> {
+	region.pause();
+	try {
+		return await work();
+	} finally {
+		region.resume();
+	}
+}

package/src/cli/profile.ts

@@ -72,7 +72,7 @@ export async function initProfile(
 	}
 	// `profile init` exists to create the manifest, so it is the one caller that
 	// may do so unattended.
-	return (await ensureManifest(projectPath, { yes, allowAdopt: yes })) ? 0 : 1;
+	return (await ensureManifest(projectPath, { allowAdopt: yes })) ? 0 : 1;
 }
 
 export async function listProfiles(projectPath: string): Promise<number> {

package/src/cli/router.ts

@@ -98,9 +98,13 @@ without one is offered adoption on first run. See docs/team-configuration.md.
                      behind the version its marketplace publishes. Only the
                      newest version is installable, so a pin naming an older
                      one is reported, not chased.
-    --check          Report only, write nothing (exits 1 if anything is
-                     missing or known to be behind)
-    --yes, -y        Skip the confirmation prompt
+                     APPLIES WITHOUT ASKING. It can only move forward — there
+                     is no downgrade and no delete — so the plan is printed as
+                     it runs rather than gated behind a prompt. This includes
+                     running a profile's CLI-tool installers (brew, bun).
+    --dry-run        Show the plan and stop. Writes nothing, exits 0.
+    --check          Report only, write nothing. Exits 1 if anything is
+                     missing or known to be behind — the CI gate.
   profile list       Show every profile; ● marks the active one
   profile show <n>   Print a profile's fully resolved closure
   profile switch <n> Repoint the active profile — offline, no reinstall