magus-cli 7.11.5 → 7.11.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "magus-cli",
-  "version": "7.11.5",
+  "version": "7.11.7",
   "description": "TUI tool for managing Claude Code plugins, MCPs, and configuration",
   "type": "module",
   "main": "src/main.tsx",
@@ -65,8 +65,8 @@
     "typescript": "^5.6.3"
   },
   "optionalDependencies": {
-    "magus-cli-darwin-arm64": "7.11.5",
-    "magus-cli-darwin-x64": "7.11.5",
-    "magus-cli-linux-x64": "7.11.5"
+    "magus-cli-darwin-arm64": "7.11.7",
+    "magus-cli-darwin-x64": "7.11.7",
+    "magus-cli-linux-x64": "7.11.7"
   }
 }

package/src/__tests__/marketplace-refresh.test.ts

@@ -344,3 +344,116 @@ describe("fastForwardCloneIfPresent — single-clone helper (shared with claude-
 		expect(readPin(dir).pin).toBe("x@dirty");
 	});
 });
+
+/**
+ * Point the clone's origin at a fake ssh that hangs. git pull -> git fetch ->
+ * ssh: the fake ssh is NOT runBounded's direct child, so killing `git pull`
+ * leaves it holding the inherited stdout/stderr open. It records its own pid and
+ * its grandparent's (the `git pull` runBounded spawned) so the case can check
+ * them and the cleanup can kill them by pid, never by pattern.
+ */
+function hangSshTransport(dir: string): { sshPid: string; pullPid: string } {
+	const sshPid = path.join(tmp, "fake-ssh.pid");
+	const pullPid = path.join(tmp, "git-pull.pid");
+	const fakeSsh = path.join(tmp, "fake-ssh.sh");
+	fs.writeFileSync(
+		fakeSsh,
+		[
+			"#!/bin/sh",
+			`echo $$ > '${sshPid}'`,
+			`ps -o ppid= -p $PPID | tr -d ' ' > '${pullPid}'`,
+			`ps -o command= -p "$(cat '${pullPid}')" > '${pullPid}.cmd'`,
+			"exec sleep 60",
+			"",
+		].join("\n"),
+		{ mode: 0o755 },
+	);
+	git(dir, "remote", "set-url", "origin", "ssh://example.invalid/repo.git");
+	git(dir, "config", "core.sshCommand", fakeSsh);
+	hungPidFiles = [sshPid, pullPid];
+	return { sshPid, pullPid };
+}
+
+function readPid(file: string): number {
+	return Number(fs.readFileSync(file, "utf8").trim());
+}
+
+/** True once `pid` no longer exists, polling briefly to let the runtime reap it. */
+async function goneWithin(pid: number, ms: number): Promise<boolean> {
+	const until = Date.now() + ms;
+	for (;;) {
+		try {
+			process.kill(pid, 0);
+		} catch {
+			return true;
+		}
+		if (Date.now() > until) return false;
+		await Bun.sleep(20);
+	}
+}
+
+// pid files written by hangSshTransport; killed by pid after each case.
+let hungPidFiles: string[] = [];
+
+afterEach(() => {
+	for (const file of hungPidFiles) {
+		if (!fs.existsSync(file)) continue;
+		const pid = readPid(file);
+		if (pid > 0) {
+			try {
+				process.kill(pid, "SIGKILL");
+			} catch {
+				// already gone
+			}
+		}
+	}
+	hungPidFiles = [];
+});
+
+describe("fastForwardCloneIfPresent — a hung ssh transport", () => {
+	// REGRESSION: magus update stalls on the marketplaces step past the 30 s git timeout (ssh grandchild holds the pipes) — Fixed in /dev:fix session dev-fix-20261102-160435-22278 (MTL-365)
+	it("settles as 'failed' near the 30 s git timeout when ssh (a grandchild of git pull) holds the pipes", async () => {
+		const dir = installClone("magus");
+		hangSshTransport(dir);
+
+		const started = Date.now();
+		const status = await fastForwardCloneIfPresent("magus");
+		const elapsed = Date.now() - started;
+
+		expect(status).toBe("failed");
+		// 30 s timeout + grace. On the bug it settles only when ssh exits (~60 s).
+		expect(elapsed).toBeLessThan(40_000);
+		expect(fs.existsSync(dir)).toBe(true);
+	}, 45_000);
+});
+
+describe("fastForwardCloneIfPresent — per-clone deadline", () => {
+	// REGRESSION: the marketplaces step ran 56 min — a per-clone deadline bounds it whatever hangs (MTL-365)
+	it("returns 'failed' at the deadline while ssh still hangs, clone intact", async () => {
+		const dir = installClone("magus");
+		hangSshTransport(dir);
+
+		const started = Date.now();
+		const status = await fastForwardCloneIfPresent("magus", 1_000);
+		const elapsed = Date.now() - started;
+
+		expect(status).toBe("failed");
+		// Deadline 1 s plus slack. Without the deadline it settles at the 30 s git timeout.
+		expect(elapsed).toBeLessThan(3_000);
+		expect(fs.existsSync(dir)).toBe(true);
+	}, 10_000);
+
+	it("kills the in-flight git pull when the deadline wins, rather than leaving it running", async () => {
+		const dir = installClone("magus");
+		const { pullPid } = hangSshTransport(dir);
+
+		const status = await fastForwardCloneIfPresent("magus", 1_000);
+
+		expect(status).toBe("failed");
+		// The fake ssh got far enough to record its grandparent, the git pull.
+		expect(fs.existsSync(pullPid)).toBe(true);
+		expect(fs.readFileSync(`${pullPid}.cmd`, "utf8")).toContain("pull");
+		// Without the abort, git pull lives on until its own 30 s timeout.
+		expect(await goneWithin(readPid(pullPid), 1_000)).toBe(true);
+	}, 10_000);
+});