magus-cli 7.7.0 → 7.9.0

package/src/services/catalog-cache-store.ts

@@ -35,12 +35,14 @@ import type { MarketplacePlugin } from "./marketplace-catalog.js";
 /**
  * How long a cached catalog is served before we ask again.
  *
- * This is the ONLY refresh rhythm magus has, and it is why the TUI and
- * `magus update` can disagree about the same plugin for up to an hour:
- * `update` fast-forwards the clones and clears this cache before planning,
- * while the TUI serves whatever is here. That is not a bug in either path, but
- * anything that reports "no update" off a cached catalog has to say the answer
- * is up to an hour old.
+ * This is the ONLY refresh rhythm magus has, and it applies to both surfaces:
+ * `magus update` and the TUI read a catalog written here within the hour
+ * before they go to the network. `update` pulls the marketplace clones and
+ * drops its in-process memo before planning, but it does NOT clear this file,
+ * so a release published inside the TTL is not seen by `update` either. Only
+ * an explicit refresh (`r` in the TUI) clears it. Anything that reports "no
+ * update" — or decides a plugin is no longer published — off a cached catalog
+ * is working from an answer up to an hour old, by design.
  */
 export const CATALOG_TTL_MS = 60 * 60 * 1000;
 

package/src/services/claude-cli.ts

@@ -10,6 +10,8 @@
  */
 
 import { execFile } from "node:child_process";
+import { existsSync } from "node:fs";
+import path from "node:path";
 import { promisify } from "node:util";
 import { defaultMarketplaces } from "../data/marketplaces.js";
 import { which } from "../utils/command-utils.js";
@@ -28,13 +30,12 @@ export type PluginScope = "user" | "project" | "local";
  * Get the path to the claude CLI binary
  * @throws Error if claude CLI is not found in PATH
  */
+const CLAUDE_NOT_FOUND =
+	"claude CLI not found in PATH. Install with: npm install -g @anthropic-ai/claude-code";
+
 async function getClaudePath(): Promise<string> {
 	const claudePath = await which("claude");
-	if (!claudePath) {
-		throw new Error(
-			"claude CLI not found in PATH. Install with: npm install -g @anthropic-ai/claude-code",
-		);
-	}
+	if (!claudePath) throw new Error(CLAUDE_NOT_FOUND);
 	return claudePath;
 }
 
@@ -42,29 +43,84 @@ async function getClaudePath(): Promise<string> {
  * Execute a claude CLI command and return stdout
  * @param args - Arguments to pass to claude
  * @param timeoutMs - Timeout in milliseconds (default: 30s)
+ * @param cwd - Working directory; Claude Code resolves project and local
+ *   scope from it. Defaults to this process's.
  * @returns stdout from the command
  */
-async function execClaude(args: string[], timeoutMs = 30000): Promise<string> {
+async function execClaude(
+	args: string[],
+	timeoutMs = 30000,
+	cwd?: string,
+): Promise<string> {
 	const claudePath = await getClaudePath();
 	try {
 		const { stdout } = await execFileAsync(claudePath, args, {
 			timeout: timeoutMs,
+			...(cwd ? { cwd } : {}),
 		});
 		return stdout.trim();
 	} catch (error: unknown) {
-		const execError = error as {
-			stderr?: string;
-			stdout?: string;
-			message?: string;
-			code?: number;
-		};
-		const msg =
-			execError.stderr?.trim() ||
-			execError.stdout?.trim() ||
-			execError.message ||
-			"claude command failed";
-		throw new Error(msg);
+		throw new Error(claudeFailureMessage(error, args, timeoutMs, cwd));
+	}
+}
+
+/**
+ * What a failed `claude` command says, in the words a user reads.
+ *
+ * Claude Code's own output first — stderr, then stdout — since that is the
+ * reason. Only when it printed nothing does Node's error message stand in, and
+ * that one opens with `Command failed: /absolute/path/to/claude plugin …`:
+ * the path and the argument list are the mechanism, not the reason, so that
+ * line is dropped and what follows it kept. A run that was killed for taking
+ * too long says so.
+ *
+ * A spawn that fails with ENOENT is not always a missing `claude`: Node and
+ * Bun both report a working directory that does not exist the same way,
+ * naming the binary. So when the run was given a `cwd` that is gone, that is
+ * what is said — by the folder's name, never its absolute path — rather than
+ * telling someone with Claude Code installed to install it.
+ */
+export function claudeFailureMessage(
+	error: unknown,
+	args: readonly string[],
+	timeoutMs: number,
+	cwd?: string,
+): string {
+	const execError = error as {
+		code?: string | number;
+		stderr?: string;
+		stdout?: string;
+		message?: string;
+		killed?: boolean;
+		signal?: string | null;
+	};
+	const output = execError.stderr?.trim() || execError.stdout?.trim();
+	if (output) return output;
+	if (execError.killed) {
+		return `claude ${args.slice(0, 2).join(" ")} did not finish within ${Math.round(timeoutMs / 1000)}s`;
+	}
+	const message = execError.message ?? "";
+	// The binary vanished between the PATH lookup and the spawn (Node says
+	// `spawn <path> ENOENT`, Bun `Executable not found in $PATH`). Same fact as
+	// the lookup failing, so the same words — and never the absolute path.
+	if (
+		execError.code === "ENOENT" ||
+		/\bENOENT\b|Executable not found in \$PATH/.test(message)
+	) {
+		if (cwd && !existsSync(cwd)) {
+			return `the folder ${path.basename(cwd) || cwd} no longer exists`;
+		}
+		return CLAUDE_NOT_FOUND;
+	}
+	if (execError.code === "EACCES" || /\bEACCES\b/.test(message)) {
+		return "claude could not be started: permission denied";
 	}
+	const rest = message
+		.replace(/^Command failed: [^\n]*\n?/, "")
+		// Any leftover mention of the binary by absolute path is mechanism.
+		.replace(/(?:\/[^\s/:]+)+\/claude\b/g, "claude")
+		.trim();
+	return rest || `claude ${args.slice(0, 2).join(" ")} failed`;
 }
 
 /**
@@ -186,6 +242,32 @@ export async function uninstallPlugin(
 	}
 }
 
+/**
+ * Uninstall through `claude plugin uninstall` and NOTHING else: its error is
+ * thrown, never absorbed.
+ *
+ * {@link uninstallPlugin} falls back to editing the settings files directly
+ * when the command fails. That fallback is a direct writer of Claude Code's
+ * files, and it turns every failure into an apparent success — so a caller
+ * that reads the result back, as removing a deprecated plugin does, could
+ * never see why the plugin was still there. This one lets the command's own
+ * words reach the caller.
+ *
+ * Runs in `projectPath` when given, because Claude Code resolves project and
+ * local scope from its working directory.
+ */
+export async function uninstallPluginViaCli(
+	pluginId: string,
+	scope: PluginScope,
+	projectPath?: string,
+): Promise<void> {
+	await execClaude(
+		["plugin", "uninstall", pluginId, "--scope", scope],
+		30000,
+		projectPath,
+	);
+}
+
 /**
  * Repair a plugin whose files drifted from the marketplace under an unchanged
  * version — uninstall, then install again at the same scope.
@@ -270,7 +352,12 @@ export async function disablePlugin(
  * {@link installPlugin}, and content drift under an unchanged version still
  * needs {@link repairPlugin} — `update` has no version bump to act on there.
  *
- * Retries with marketplace update on "not found" errors (same as installPlugin).
+ * On a "not found in marketplace" error it recovers once and retries, exactly
+ * as {@link installPlugin} does (see `recoverMissingMarketplace`): a registered
+ * marketplace has its source repaired and its clone fast-forwarded with
+ * `git pull --ff-only` — never `claude plugin marketplace update`, which
+ * deletes the clone before re-cloning — and a missing clone or an unregistered
+ * default marketplace is added with `claude plugin marketplace add`.
  */
 export async function updatePlugin(
 	pluginId: string,