fix(doctor): prune stale bundled plugin paths

giodl73-repo · giodl73-repo · commit 425fb15c7db4 · 2026-05-23T18:27:08.000-07:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -233,6 +233,7 @@ Docs: https://docs.openclaw.ai
 - CLI/update: pre-pack GitHub/git package update targets before the staged npm install, restoring `openclaw update --tag main` for one-off package updates. (#81296) Thanks @fuller-stack-dev.
 - Gateway: mirror successful same-source message-tool sends into session transcripts so delivered replies stay in later history/context. (#84837) Thanks @iFiras-Max1.
 - Media generation: keep image, music, and video completion delivery from duplicating or losing task ownership when generated media finishes through active session replies. (#84006) Thanks @fuller-stack-dev.
+- CLI/doctor: remove stale bundled plugin load paths from old versioned OpenClaw package roots after pnpm/npm upgrades. Fixes #58626. Thanks @solink7.
 - Infra/json: retry transient `File changed during read` races while loading JSON state so config and state reads recover instead of failing the turn. (#84285)
 - Plugins/providers: fail closed for workspace provider plugins during setup-mode discovery unless explicitly trusted, preventing untrusted workspace plugin code from running during provider setup. (#81069) Thanks @mmaps.
 - Providers/Ollama: resolve configured Ollama Cloud `OLLAMA_API_KEY` markers to the real discovery key so cloud provider entries keep authenticated model catalog access. (#85037)
diff --git a/src/commands/doctor/shared/bundled-plugin-load-paths.test.ts b/src/commands/doctor/shared/bundled-plugin-load-paths.test.ts
@@ -103,6 +103,61 @@ describe("bundled plugin load path repair", () => {
     expect(result.config.plugins?.load?.paths).toStrictEqual([]);
   });
 
+  it("removes stale bundled paths from old versioned OpenClaw package roots", () => {
+    const currentPackageRoot = path.resolve("node_modules", "openclaw");
+    const stalePackageRoot = path.resolve(
+      "pnpm-global",
+      ".pnpm",
+      "openclaw@2026.3.28_@napi-rs+canvas@0.1.97",
+      "node_modules",
+      "openclaw",
+    );
+    const currentBundledPath = bundledDistPluginRootAt(currentPackageRoot, "feishu");
+    const staleBundledPath = bundledDistPluginRootAt(stalePackageRoot, "feishu");
+    mockBundledSource("feishu", currentBundledPath);
+
+    const result = maybeRepairBundledPluginLoadPaths(
+      createPluginLoadPathConfig([staleBundledPath, "/custom/path"]),
+    );
+
+    expect(result.changes).toEqual([
+      `- plugins.load.paths: removed bundled feishu path alias ${staleBundledPath}`,
+    ]);
+    expect(result.config.plugins?.load?.paths).toStrictEqual(["/custom/path"]);
+  });
+
+  it("removes stale legacy bundled paths from old versioned OpenClaw package roots", () => {
+    const currentPackageRoot = path.resolve("node_modules", "openclaw");
+    const stalePackageRoot = path.resolve(
+      "pnpm-global",
+      ".pnpm",
+      "openclaw@2026.3.28_@napi-rs+canvas@0.1.97",
+      "node_modules",
+      "openclaw",
+    );
+    const currentBundledPath = bundledDistPluginRootAt(currentPackageRoot, "feishu");
+    const staleLegacyPath = bundledPluginRootAt(stalePackageRoot, "feishu");
+    mockBundledSource("feishu", currentBundledPath);
+
+    const result = maybeRepairBundledPluginLoadPaths(createPluginLoadPathConfig([staleLegacyPath]));
+
+    expect(result.changes).toEqual([
+      `- plugins.load.paths: removed bundled feishu path alias ${staleLegacyPath}`,
+    ]);
+    expect(result.config.plugins?.load?.paths).toStrictEqual([]);
+  });
+
+  it("does not remove arbitrary missing paths that happen to use the bundled dist layout", () => {
+    const currentPackageRoot = path.resolve("node_modules", "openclaw");
+    const customPath = path.resolve("elsewhere", "dist", "extensions", "feishu");
+    mockBundledSource("feishu", bundledDistPluginRootAt(currentPackageRoot, "feishu"));
+
+    const result = maybeRepairBundledPluginLoadPaths(createPluginLoadPathConfig([customPath]));
+
+    expect(result.changes).toEqual([]);
+    expect(result.config).toEqual(createPluginLoadPathConfig([customPath]));
+  });
+
   it("derives legacy paths from the bundled directory name instead of plugin id", () => {
     const packageRoot = path.resolve("app-node-modules", "openclaw");
     const legacyPath = bundledPluginRootAt(packageRoot, "kimi-coding");
diff --git a/src/commands/doctor/shared/bundled-plugin-load-paths.ts b/src/commands/doctor/shared/bundled-plugin-load-paths.ts
@@ -1,8 +1,11 @@
+import path from "node:path";
 import { resolveAgentWorkspaceDir, resolveDefaultAgentId } from "../../../agents/agent-scope.js";
 import type { OpenClawConfig } from "../../../config/types.openclaw.js";
 import {
   buildBundledPluginLoadPathAliases,
   normalizeBundledLookupPath,
+  parseLegacyBundledPluginPath,
+  parsePackagedBundledPluginPath,
 } from "../../../plugins/bundled-load-path-aliases.js";
 import { resolveBundledPluginSources } from "../../../plugins/bundled-sources.js";
 import { sanitizeForLog } from "../../../terminal/ansi.js";
@@ -20,6 +23,13 @@ function resolveBundledWorkspaceDir(cfg: OpenClawConfig): string | undefined {
   return resolveAgentWorkspaceDir(cfg, resolveDefaultAgentId(cfg)) ?? undefined;
 }
 
+function isOpenClawNodeModulesPackageRoot(packageRoot: string): boolean {
+  const normalized = normalizeBundledLookupPath(packageRoot);
+  const packageDir = path.basename(normalized);
+  const parentDir = path.basename(path.dirname(normalized));
+  return packageDir === "openclaw" && parentDir === "node_modules";
+}
+
 export function scanBundledPluginLoadPathMigrations(
   cfg: OpenClawConfig,
   env: NodeJS.ProcessEnv = process.env,
@@ -40,13 +50,21 @@ export function scanBundledPluginLoadPathMigrations(
   }
 
   const bundledPathMap = new Map<string, { pluginId: string; toPath: string }>();
+  const packagedBundledLeafMap = new Map<string, { pluginId: string; toPath: string }>();
   for (const source of bundled.values()) {
     for (const alias of buildBundledPluginLoadPathAliases(source.localPath)) {
       bundledPathMap.set(normalizeBundledLookupPath(alias.path), {
         pluginId: source.pluginId,
         toPath: source.localPath,
       });
     }
+    const packaged = parsePackagedBundledPluginPath(source.localPath);
+    if (packaged) {
+      packagedBundledLeafMap.set(normalizeBundledLookupPath(packaged.bundledLeaf), {
+        pluginId: source.pluginId,
+        toPath: source.localPath,
+      });
+    }
   }
 
   const hits: BundledPluginLoadPathHit[] = [];
@@ -57,6 +75,23 @@ export function scanBundledPluginLoadPathMigrations(
     const normalized = normalizeBundledLookupPath(resolveUserPath(rawPath, env));
     const match = bundledPathMap.get(normalized);
     if (!match) {
+      const oldPackaged = parsePackagedBundledPluginPath(normalized);
+      const oldLegacy = oldPackaged ? null : parseLegacyBundledPluginPath(normalized);
+      const oldPackageRoot = oldPackaged?.packageRoot ?? oldLegacy?.packageRoot;
+      const oldBundledLeaf = oldPackaged?.bundledLeaf ?? oldLegacy?.bundledLeaf;
+      const oldPackageMatch =
+        oldPackageRoot && oldBundledLeaf && isOpenClawNodeModulesPackageRoot(oldPackageRoot)
+          ? packagedBundledLeafMap.get(normalizeBundledLookupPath(oldBundledLeaf))
+          : undefined;
+      if (!oldPackageMatch) {
+        continue;
+      }
+      hits.push({
+        pluginId: oldPackageMatch.pluginId,
+        fromPath: rawPath,
+        toPath: oldPackageMatch.toPath,
+        pathLabel: "plugins.load.paths",
+      });
       continue;
     }
     hits.push({
diff --git a/src/plugins/bundled-load-path-aliases.ts b/src/plugins/bundled-load-path-aliases.ts
@@ -8,6 +8,18 @@ export type BundledPluginLoadPathAlias = {
   path: string;
 };
 
+export type PackagedBundledPluginPath = {
+  packageRoot: string;
+  bundledRoot: string;
+  bundledLeaf: string;
+};
+
+export type LegacyBundledPluginPath = {
+  packageRoot: string;
+  legacyRoot: string;
+  bundledLeaf: string;
+};
+
 const PACKAGED_BUNDLED_ROOTS = [
   path.join("dist", "extensions"),
   path.join("dist-runtime", "extensions"),
@@ -46,24 +58,54 @@ function findPackagedBundledRoot(localPath: string): {
   return null;
 }
 
-export function buildLegacyBundledPath(localPath: string): string | null {
+export function parsePackagedBundledPluginPath(
+  localPath: string,
+): PackagedBundledPluginPath | null {
   const packaged = findPackagedBundledRoot(localPath);
   if (!packaged) {
     return null;
   }
   const normalized = normalizeBundledLookupPath(localPath);
-  const bundledLeaf =
-    normalized === packaged.bundledRoot
-      ? ""
-      : normalized.slice(packaged.bundledRoot.length + path.sep.length);
-  return bundledLeaf ? path.join(packaged.packageRoot, "extensions", bundledLeaf) : null;
+  if (normalized === packaged.bundledRoot) {
+    return null;
+  }
+  return {
+    ...packaged,
+    bundledLeaf: normalized.slice(packaged.bundledRoot.length + path.sep.length),
+  };
+}
+
+export function buildLegacyBundledPath(localPath: string): string | null {
+  const packaged = parsePackagedBundledPluginPath(localPath);
+  if (!packaged) {
+    return null;
+  }
+  return path.join(packaged.packageRoot, "extensions", packaged.bundledLeaf);
 }
 
 export function buildLegacyBundledRootPath(localPath: string): string | null {
   const packaged = findPackagedBundledRoot(localPath);
   return packaged ? path.join(packaged.packageRoot, "extensions") : null;
 }
 
+export function parseLegacyBundledPluginPath(localPath: string): LegacyBundledPluginPath | null {
+  const normalized = normalizeBundledLookupPath(localPath);
+  const marker = `${path.sep}extensions`;
+  const markerIndex = normalized.lastIndexOf(marker);
+  if (markerIndex === -1) {
+    return null;
+  }
+  const markerEnd = markerIndex + marker.length;
+  if (normalized.length === markerEnd || normalized[markerEnd] !== path.sep) {
+    return null;
+  }
+  return {
+    packageRoot: normalized.slice(0, markerIndex),
+    legacyRoot: normalized.slice(0, markerEnd),
+    bundledLeaf: normalized.slice(markerEnd + path.sep.length),
+  };
+}
+
 export function buildBundledPluginLoadPathAliases(localPath: string): BundledPluginLoadPathAlias[] {
   const legacyPath = buildLegacyBundledPath(localPath);
   if (!legacyPath) {
