fix(cli): clear each plugin-cache root independently in doctor

Follow-up to #199 (cubic P2): the bulk cache clear ran all roots inside one
try/catch, so a mid-loop rmSync failure aborted the rest and the error result
reported clearTargets[0] - a root that may have already been deleted - while
hiding that one root was cleared. Now each root is removed independently: the
error result points at the root that ACTUALLY failed, successfully-cleared roots
still get removed, and partial outcomes are reported accurately. Added an
injected-remover seam so the per-root failure path is deterministically tested.

Gate: CLI 213/0, tsc + biome clean.

Co-authored-by: Alfonso [Magic Context] <288211368+alfonso-magic-context@users.noreply.github.com>

Author: ualtinok

packages/cli/src/commands/doctor-opencode-cache.ts

@@ -26,7 +26,12 @@ function readCachedPluginVersion(pluginCacheDir: string): string | undefined {
 
 export async function clearPluginCache(
     options: { force?: boolean; latestVersion?: string | null } = {},
+    deps: { remove?: (path: string) => void } = {},
 ): Promise<PluginCacheResult> {
+    // Injected remover keeps the per-root deletion failure path deterministically
+    // testable; defaults to a real recursive remove.
+    const remove =
+        deps.remove ?? ((path: string) => rmSync(path, { recursive: true, force: true }));
     const pluginCacheRoots = getOpenCodePluginCacheRoots();
     const existingRoots = pluginCacheRoots.filter((root) => existsSync(root));
 
@@ -66,24 +71,39 @@ export async function clearPluginCache(
         };
     }
 
-    try {
-        for (const entry of clearTargets) {
-            rmSync(entry.path, { recursive: true, force: true });
+    // Clear each root independently so one root's failure neither aborts the
+    // others nor mislabels an already-deleted path as the one needing manual
+    // cleanup. The error result points at the root that actually failed.
+    const cleared: typeof clearTargets = [];
+    const failed: Array<{ path: string; error: string }> = [];
+    for (const entry of clearTargets) {
+        try {
+            remove(entry.path);
+            cleared.push(entry);
+        } catch (err: unknown) {
+            failed.push({
+                path: entry.path,
+                error: err instanceof Error ? err.message : String(err),
+            });
         }
-        const firstTarget = clearTargets[0];
-        return {
-            action: "cleared",
-            path: firstTarget?.path ?? pluginCacheRoots[0] ?? "",
-            paths: clearTargets.map((entry) => entry.path),
-            cached: firstTarget?.cached,
-            latest: latestVersion,
-        };
-    } catch (err: unknown) {
-        const message = err instanceof Error ? err.message : String(err);
+    }
+
+    if (failed.length > 0) {
+        const firstFailure = failed[0];
         return {
             action: "error",
-            path: clearTargets[0]?.path ?? existingRoots[0] ?? "",
-            error: message,
+            path: firstFailure?.path ?? clearTargets[0]?.path ?? existingRoots[0] ?? "",
+            paths: failed.map((entry) => entry.path),
+            error: firstFailure?.error,
         };
     }
+
+    const firstTarget = cleared[0];
+    return {
+        action: "cleared",
+        path: firstTarget?.path ?? pluginCacheRoots[0] ?? "",
+        paths: cleared.map((entry) => entry.path),
+        cached: firstTarget?.cached,
+        latest: latestVersion,
+    };
 }

packages/cli/src/commands/doctor-opencode.test.ts

@@ -253,6 +253,43 @@ describe("doctor OpenCode plugin cache", () => {
         expect(result.latest).toBeUndefined();
         expect(existsSync(pluginCachePath)).toBe(false);
     });
+
+    it("reports the actually-failed root and clears the rest when one root fails", async () => {
+        const cacheRoot = makeTempDir("mc-opencode-cache-");
+        originalXdgCacheHome = process.env.XDG_CACHE_HOME;
+        process.env.XDG_CACHE_HOME = cacheRoot;
+        const latestCachePath = createCachedOpenCodePlugin(cacheRoot, "0.26.0");
+        const versionlessCachePath = createCachedOpenCodePlugin(
+            cacheRoot,
+            "0.26.0",
+            OPENCODE_PLUGIN_NAME,
+        );
+
+        // Fail only the second root: the first must still be removed, and the
+        // error must point at the failed root, not the already-removed one.
+        const removed: string[] = [];
+        const result = await clearPluginCache(
+            { latestVersion: "0.29.1" },
+            {
+                remove: (path) => {
+                    if (path === versionlessCachePath) {
+                        throw new Error("EACCES: permission denied");
+                    }
+                    rmSync(path, { recursive: true, force: true });
+                    removed.push(path);
+                },
+            },
+        );
+
+        expect(result).toMatchObject({
+            action: "error",
+            path: versionlessCachePath,
+            paths: [versionlessCachePath],
+            error: "EACCES: permission denied",
+        });
+        expect(removed).toEqual([latestCachePath]);
+        expect(existsSync(latestCachePath)).toBe(false);
+    });
 });
 
 describe("doctor v22 backfill commands", () => {