fix: suppress false duplicate plugin id warning for symlinked extensions

shadril238 · steipete · commit 788ea6e9d1c2 · 2026-02-14T15:25:51.000+01:00
When the same plugin directory is discovered through different path representations (e.g. symlinks), the manifest registry incorrectly warns about a duplicate plugin id. This is a false positive that appears for bundled extensions like feishu (#16208). Compare fs.realpathSync() of both candidates' rootDir before emitting the duplicate warning. If they resolve to the same physical directory, silently skip the duplicate instead of warning. Also change seenIds from Set<string> to Map<string, PluginCandidate> to track the first-seen candidate for comparison. Closes #16208
diff --git a/src/plugins/manifest-registry.test.ts b/src/plugins/manifest-registry.test.ts
@@ -0,0 +1,138 @@
+import { randomUUID } from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import type { PluginCandidate } from "./discovery.js";
+import { loadPluginManifestRegistry } from "./manifest-registry.js";
+
+const tempDirs: string[] = [];
+
+function makeTempDir() {
+  const dir = path.join(os.tmpdir(), `openclaw-manifest-registry-${randomUUID()}`);
+  fs.mkdirSync(dir, { recursive: true });
+  tempDirs.push(dir);
+  return dir;
+}
+
+function writeManifest(dir: string, manifest: Record<string, unknown>) {
+  fs.writeFileSync(path.join(dir, "openclaw.plugin.json"), JSON.stringify(manifest), "utf-8");
+}
+
+afterEach(() => {
+  for (const dir of tempDirs.splice(0)) {
+    try {
+      fs.rmSync(dir, { recursive: true, force: true });
+    } catch {
+      // ignore cleanup failures
+    }
+  }
+});
+
+describe("loadPluginManifestRegistry", () => {
+  it("emits duplicate warning for truly distinct plugins with same id", () => {
+    const dirA = makeTempDir();
+    const dirB = makeTempDir();
+    const manifest = { id: "test-plugin", configSchema: { type: "object" } };
+    writeManifest(dirA, manifest);
+    writeManifest(dirB, manifest);
+
+    const candidates: PluginCandidate[] = [
+      {
+        idHint: "test-plugin",
+        source: path.join(dirA, "index.ts"),
+        rootDir: dirA,
+        origin: "bundled",
+      },
+      {
+        idHint: "test-plugin",
+        source: path.join(dirB, "index.ts"),
+        rootDir: dirB,
+        origin: "global",
+      },
+    ];
+
+    const registry = loadPluginManifestRegistry({
+      candidates,
+      cache: false,
+    });
+
+    const duplicateWarnings = registry.diagnostics.filter(
+      (d) => d.level === "warn" && d.message?.includes("duplicate plugin id"),
+    );
+    expect(duplicateWarnings.length).toBe(1);
+  });
+
+  it("suppresses duplicate warning when candidates share the same physical directory via symlink", () => {
+    const realDir = makeTempDir();
+    const manifest = { id: "feishu", configSchema: { type: "object" } };
+    writeManifest(realDir, manifest);
+
+    // Create a symlink pointing to the same directory
+    const symlinkParent = makeTempDir();
+    const symlinkPath = path.join(symlinkParent, "feishu-link");
+    try {
+      fs.symlinkSync(realDir, symlinkPath, "junction");
+    } catch {
+      // On systems where symlinks are not supported (e.g. restricted Windows),
+      // skip this test gracefully.
+      return;
+    }
+
+    const candidates: PluginCandidate[] = [
+      {
+        idHint: "feishu",
+        source: path.join(realDir, "index.ts"),
+        rootDir: realDir,
+        origin: "bundled",
+      },
+      {
+        idHint: "feishu",
+        source: path.join(symlinkPath, "index.ts"),
+        rootDir: symlinkPath,
+        origin: "bundled",
+      },
+    ];
+
+    const registry = loadPluginManifestRegistry({
+      candidates,
+      cache: false,
+    });
+
+    const duplicateWarnings = registry.diagnostics.filter(
+      (d) => d.level === "warn" && d.message?.includes("duplicate plugin id"),
+    );
+    expect(duplicateWarnings.length).toBe(0);
+  });
+
+  it("suppresses duplicate warning when candidates have identical rootDir paths", () => {
+    const dir = makeTempDir();
+    const manifest = { id: "same-path-plugin", configSchema: { type: "object" } };
+    writeManifest(dir, manifest);
+
+    const candidates: PluginCandidate[] = [
+      {
+        idHint: "same-path-plugin",
+        source: path.join(dir, "a.ts"),
+        rootDir: dir,
+        origin: "bundled",
+      },
+      {
+        idHint: "same-path-plugin",
+        source: path.join(dir, "b.ts"),
+        rootDir: dir,
+        origin: "global",
+      },
+    ];
+
+    const registry = loadPluginManifestRegistry({
+      candidates,
+      cache: false,
+    });
+
+    const duplicateWarnings = registry.diagnostics.filter(
+      (d) => d.level === "warn" && d.message?.includes("duplicate plugin id"),
+    );
+    expect(duplicateWarnings.length).toBe(0);
+  });
+});
diff --git a/src/plugins/manifest-registry.ts b/src/plugins/manifest-registry.ts
@@ -138,7 +138,7 @@ export function loadPluginManifestRegistry(params: {
   const diagnostics: PluginDiagnostic[] = [...discovery.diagnostics];
   const candidates: PluginCandidate[] = discovery.candidates;
   const records: PluginManifestRecord[] = [];
-  const seenIds = new Set<string>();
+  const seenIds = new Map<string, PluginCandidate>();
 
   for (const candidate of candidates) {
     const manifestRes = loadPluginManifest(candidate.rootDir);
@@ -161,15 +161,29 @@ export function loadPluginManifestRegistry(params: {
       });
     }
 
-    if (seenIds.has(manifest.id)) {
+    const existingCandidate = seenIds.get(manifest.id);
+    if (existingCandidate) {
+      // Check whether both candidates point to the same physical directory
+      // (e.g. via symlinks or different path representations). If so, this
+      // is a false-positive duplicate and can be silently skipped.
+      let samePlugin = false;
+      try {
+        samePlugin =
+          fs.realpathSync(existingCandidate.rootDir) === fs.realpathSync(candidate.rootDir);
+      } catch {
+        // If either path is inaccessible, fall through to duplicate warning
+      }
+      if (samePlugin) {
+        continue;
+      }
       diagnostics.push({
         level: "warn",
         pluginId: manifest.id,
         source: candidate.source,
         message: `duplicate plugin id detected; later plugin may be overridden (${candidate.source})`,
       });
     } else {
-      seenIds.add(manifest.id);
+      seenIds.set(manifest.id, candidate);
     }
 
     const configSchema = manifest.configSchema;
