Config: centralize known plugin id resolution

yejiming · yejiming · commit a145356ebf95 · 2026-03-29T09:48:31.000+08:00
diff --git a/src/config/config.plugin-validation.test.ts b/src/config/config.plugin-validation.test.ts
@@ -338,6 +338,71 @@ describe("config plugin validation", () => {
     ).toBe(false);
   });
 
+  it.each([
+    {
+      label: "plugins.allow",
+      buildPluginsConfig: (pluginId: string) => ({
+        allow: [pluginId],
+      }),
+      expectedWarningPath: "plugins.allow",
+    },
+    {
+      label: "plugins.entries.*",
+      buildPluginsConfig: (pluginId: string) => ({
+        entries: { [pluginId]: { enabled: true } },
+      }),
+      expectedWarningPath: (pluginId: string) => `plugins.entries.${pluginId}`,
+    },
+    {
+      label: "plugins.slots.memory",
+      buildPluginsConfig: (pluginId: string) => ({
+        slots: { memory: pluginId },
+      }),
+      expectedIssuePath: "plugins.slots.memory",
+    },
+  ])(
+    "keeps severity consistent for known vs unknown ids at $label",
+    ({ buildPluginsConfig, expectedWarningPath, expectedIssuePath }) => {
+      const knownId = "google";
+      const unknownId = "missing-plugin-id";
+      const missingBundledEnv = {
+        ...suiteEnv(),
+        OPENCLAW_BUNDLED_PLUGINS_DIR: path.join(suiteHome, "missing-bundled-plugins"),
+      };
+      const knownResult = validateConfigObjectWithPlugins(
+        { plugins: buildPluginsConfig(knownId) },
+        { env: missingBundledEnv },
+      );
+      expect(knownResult.ok).toBe(true);
+      if (!knownResult.ok) {
+        return;
+      }
+
+      const unknownResult = validateConfigObjectWithPlugins(
+        { plugins: buildPluginsConfig(unknownId) },
+        { env: missingBundledEnv },
+      );
+      expect(unknownResult.ok).toBe(expectedIssuePath === undefined);
+      if (!unknownResult.ok) {
+        expect(
+          unknownResult.issues.some(
+            (issue) => issue.path === expectedIssuePath && issue.message.includes(unknownId),
+          ),
+        ).toBe(true);
+      } else {
+        const warningPath =
+          typeof expectedWarningPath === "function"
+            ? expectedWarningPath(unknownId)
+            : expectedWarningPath;
+        expect(
+          unknownResult.warnings.some(
+            (warning) => warning.path === warningPath && warning.message.includes(unknownId),
+          ),
+        ).toBe(true);
+      }
+    },
+  );
+
   it("does not auto-allow config-loaded overrides of bundled web search plugin ids", async () => {
     const res = validateInSuite({
       plugins: {
diff --git a/src/config/validation.ts b/src/config/validation.ts
@@ -1,15 +1,22 @@
 import path from "node:path";
 import { resolveAgentWorkspaceDir, resolveDefaultAgentId } from "../agents/agent-scope.js";
 import { CHANNEL_IDS, normalizeChatChannelId } from "../channels/registry.js";
-import { BUNDLED_AUTO_ENABLE_PROVIDER_PLUGIN_IDS } from "../plugins/bundled-capability-metadata.js";
+import {
+  BUNDLED_AUTO_ENABLE_PROVIDER_PLUGIN_IDS,
+  BUNDLED_LEGACY_PLUGIN_ID_ALIASES,
+  BUNDLED_PROVIDER_PLUGIN_ID_ALIASES,
+} from "../plugins/bundled-capability-metadata.js";
 import { withBundledPluginAllowlistCompat } from "../plugins/bundled-compat.js";
 import { listBundledWebSearchPluginIds } from "../plugins/bundled-web-search-ids.js";
 import {
   normalizePluginsConfig,
   resolveEffectiveEnableState,
   resolveMemorySlotDecision,
 } from "../plugins/config-state.js";
-import { loadPluginManifestRegistry } from "../plugins/manifest-registry.js";
+import {
+  loadPluginManifestRegistry,
+  type PluginManifestRegistry,
+} from "../plugins/manifest-registry.js";
 import { validateJsonSchemaValue } from "../plugins/schema-validator.js";
 import {
   hasAvatarUriScheme,
@@ -35,6 +42,12 @@ import { OpenClawSchema } from "./zod-schema.js";
 
 const LEGACY_REMOVED_PLUGIN_IDS = new Set(["google-antigravity-auth", "google-gemini-cli-auth"]);
 
+type KnownPluginIdMetadata = {
+  providerAliases: Readonly<Record<string, string>>;
+  legacyAliases: Readonly<Record<string, string>>;
+  autoEnableProviderPluginIds: Readonly<Record<string, string>>;
+};
+
 type UnknownIssueRecord = Record<string, unknown>;
 type ConfigPathSegment = string | number;
 type AllowedValuesCollection = {
@@ -269,6 +282,27 @@ function collectAllowedValuesFromIssueList(
   return { values: collected, incomplete: false, hasValues };
 }
 
+function resolveKnownPluginIds(params: {
+  registry: PluginManifestRegistry;
+  bundledMetadata: KnownPluginIdMetadata;
+}): Set<string> {
+  const knownIds = new Set(params.registry.plugins.map((record) => record.id));
+  // Do not rely on the manifest registry alone: cold-start or missing plugin directories can
+  // temporarily hide bundled manifests, but config validation still needs to recognize bundled
+  // aliases and auto-enable provider ids so startup remains resilient during upgrades/recovery.
+  for (const aliasMap of [
+    params.bundledMetadata.providerAliases,
+    params.bundledMetadata.legacyAliases,
+    params.bundledMetadata.autoEnableProviderPluginIds,
+  ]) {
+    for (const [aliasId, pluginId] of Object.entries(aliasMap)) {
+      knownIds.add(aliasId);
+      knownIds.add(pluginId);
+    }
+  }
+  return knownIds;
+}
+
 function collectAllowedValuesFromUnknownIssue(issue: unknown): unknown[] {
   const collection = collectAllowedValuesFromIssue(issue);
   if (collection.incomplete || !collection.hasValues) {
@@ -585,10 +619,14 @@ function validateConfigObjectWithPluginsBase(
   const ensureKnownIds = (): Set<string> => {
     const info = ensureRegistry();
     if (!info.knownIds) {
-      info.knownIds = new Set([
-        ...info.registry.plugins.map((record) => record.id),
-        ...Object.values(BUNDLED_AUTO_ENABLE_PROVIDER_PLUGIN_IDS),
-      ]);
+      info.knownIds = resolveKnownPluginIds({
+        registry: info.registry,
+        bundledMetadata: {
+          providerAliases: BUNDLED_PROVIDER_PLUGIN_ID_ALIASES,
+          legacyAliases: BUNDLED_LEGACY_PLUGIN_ID_ALIASES,
+          autoEnableProviderPluginIds: BUNDLED_AUTO_ENABLE_PROVIDER_PLUGIN_IDS,
+        },
+      });
     }
     return info.knownIds;
   };
