| |
| import fs from "node:fs"; |
| import os from "node:os"; |
| import path from "node:path"; |
| import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"; |
| import type { PluginChannelCatalogEntry } from "../../plugins/channel-catalog-registry.js"; |
| import { createPluginCache, withPluginCache } from "../../plugins/plugin-cache.js"; |
| import { clearPluginMetadataLifecycleCaches } from "../../plugins/plugin-metadata-lifecycle.js"; |
| import { findBundledChannelCatalogMetadata } from "../bundled-channel-catalog-read.js"; |
| import { normalizeChatChannelId } from "../ids.js"; |
|
|
| const listChannelCatalogEntriesMock = vi.hoisted(() => |
| vi.fn<() => PluginChannelCatalogEntry[]>(() => []), |
| ); |
|
|
| vi.mock("../../plugins/channel-catalog-registry.js", () => ({ |
| listChannelCatalogEntries: listChannelCatalogEntriesMock, |
| })); |
|
|
| vi.mock("../../plugins/bundled-dir.js", async (importOriginal) => ({ |
| ...(await importOriginal<typeof import("../../plugins/bundled-dir.js")>()), |
| resolveBundledPluginsDir: () => undefined, |
| })); |
|
|
| import { getChannelPluginCatalogEntry } from "./catalog.js"; |
|
|
| const tempDirs: string[] = []; |
|
|
| beforeEach(() => { |
| clearPluginMetadataLifecycleCaches(); |
| listChannelCatalogEntriesMock.mockReset().mockReturnValue([]); |
| }); |
|
|
| afterEach(() => { |
| vi.restoreAllMocks(); |
| for (const tempDir of tempDirs.splice(0)) { |
| fs.rmSync(tempDir, { recursive: true, force: true }); |
| } |
| }); |
|
|
| function writeChannelCatalog( |
| catalogPath: string, |
| id: string, |
| label: string, |
| defaultChoice?: string, |
| ): void { |
| fs.mkdirSync(path.dirname(catalogPath), { recursive: true }); |
| fs.writeFileSync( |
| catalogPath, |
| JSON.stringify({ |
| entries: [ |
| { |
| name: `@example/${id}`, |
| openclaw: { |
| channel: { id, label, selectionLabel: label, docsPath: `/channels/${id}`, blurb: id }, |
| install: { npmSpec: `@example/${id}`, ...(defaultChoice ? { defaultChoice } : {}) }, |
| }, |
| }, |
| ], |
| }), |
| ); |
| } |
|
|
| describe("channel plugin catalog", () => { |
| it("keeps catalog-only channel IDs in the selected metadata owner", () => { |
| const root = fs.mkdtempSync(path.join(os.tmpdir(), "openclaw-channel-catalog-ids-")); |
| tempDirs.push(root); |
| fs.writeFileSync(path.join(root, "package.json"), JSON.stringify({ name: "openclaw" })); |
| vi.spyOn(process, "cwd").mockReturnValue(root); |
| const catalogPath = path.join(root, "dist", "channel-catalog.json"); |
| writeChannelCatalog(catalogPath, "catalog-original", "Original catalog"); |
| expect(normalizeChatChannelId("catalog-original")).toBe("catalog-original"); |
|
|
| writeChannelCatalog(catalogPath, "catalog-updated", "Updated catalog"); |
| expect( |
| withPluginCache(createPluginCache(), () => normalizeChatChannelId("catalog-updated")), |
| ).toBe("catalog-updated"); |
| expect(normalizeChatChannelId("catalog-original")).toBe("catalog-original"); |
| expect(normalizeChatChannelId("catalog-updated")).toBeNull(); |
|
|
| clearPluginMetadataLifecycleCaches(); |
| expect(normalizeChatChannelId("catalog-updated")).toBe("catalog-updated"); |
| expect(normalizeChatChannelId("catalog-original")).toBeNull(); |
| }); |
|
|
| it.each(["present", "missing"] as const)( |
| "shares %s generated catalog facts across consumers until the owner changes", |
| (initialState) => { |
| const root = fs.mkdtempSync(path.join(os.tmpdir(), "openclaw-shared-channel-catalog-")); |
| tempDirs.push(root); |
| fs.writeFileSync(path.join(root, "package.json"), JSON.stringify({ name: "openclaw" })); |
| vi.spyOn(process, "cwd").mockReturnValue(root); |
| const catalogPath = path.join(root, "dist", "channel-catalog.json"); |
| const options = { catalogPaths: [path.join(root, "external.json")], env: {} }; |
| if (initialState === "present") { |
| writeChannelCatalog(catalogPath, "shared-catalog", "Original catalog"); |
| } |
| const originalLabel = initialState === "present" ? "Original catalog" : undefined; |
| expect(getChannelPluginCatalogEntry("shared-catalog", options)?.meta.label).toBe( |
| originalLabel, |
| ); |
|
|
| writeChannelCatalog(catalogPath, "shared-catalog", "Updated catalog"); |
| expect(findBundledChannelCatalogMetadata("shared-catalog")?.label).toBe(originalLabel); |
| expect( |
| withPluginCache( |
| createPluginCache(), |
| () => getChannelPluginCatalogEntry("shared-catalog", options)?.meta.label, |
| ), |
| ).toBe("Updated catalog"); |
| expect(getChannelPluginCatalogEntry("shared-catalog", options)?.meta.label).toBe( |
| originalLabel, |
| ); |
|
|
| clearPluginMetadataLifecycleCaches(); |
| expect(getChannelPluginCatalogEntry("shared-catalog", options)?.meta.label).toBe( |
| "Updated catalog", |
| ); |
| expect(findBundledChannelCatalogMetadata("shared-catalog")?.label).toBe("Updated catalog"); |
| }, |
| ); |
|
|
| it.each([ |
| ["omitted", undefined, undefined], |
| ["empty", "", ""], |
| ["spaced", " See docs: ", " See docs: "], |
| ] as const)("preserves %s selection docs prefixes", (_label, prefix, expected) => { |
| listChannelCatalogEntriesMock.mockReturnValue([ |
| { |
| pluginId: "workspace-chat", |
| origin: "workspace", |
| rootDir: "/tmp/workspace-chat", |
| packageName: "@workspace/chat", |
| channel: { |
| id: "custom-chat", |
| label: "Custom Chat", |
| selectionLabel: "Custom Chat", |
| docsPath: "/channels/custom-chat", |
| blurb: "workspace", |
| ...(prefix !== undefined ? { selectionDocsPrefix: prefix } : {}), |
| }, |
| install: { localPath: "/tmp/workspace-chat" }, |
| }, |
| ] satisfies PluginChannelCatalogEntry[]); |
|
|
| const entry = getChannelPluginCatalogEntry("custom-chat", { |
| workspaceDir: "/tmp", |
| }); |
|
|
| expect(entry?.meta.selectionDocsPrefix).toBe(expected); |
| }); |
|
|
| it("keeps third-party channel ids mapped with catalog install trust", () => { |
| const options = { |
| workspaceDir: "/tmp/openclaw-channel-catalog-empty-workspace", |
| env: {}, |
| }; |
|
|
| const wecom = getChannelPluginCatalogEntry("wecom", options); |
| expect(wecom?.id).toBe("wecom"); |
| expect(wecom?.pluginId).toBe("wecom-openclaw-plugin"); |
| expect(wecom?.trustedSourceLinkedOfficialInstall).toBe(true); |
| expect(wecom?.install?.npmSpec).toBe("@wecom/wecom-openclaw-plugin@2026.7.2"); |
|
|
| const yuanbao = getChannelPluginCatalogEntry("yuanbao", options); |
| expect(yuanbao?.id).toBe("yuanbao"); |
| expect(yuanbao?.pluginId).toBe("openclaw-plugin-yuanbao"); |
| expect(yuanbao?.trustedSourceLinkedOfficialInstall).toBe(true); |
| expect(yuanbao?.install?.npmSpec).toBe("openclaw-plugin-yuanbao@2.18.2"); |
| }); |
|
|
| it("excludes only the rejected origin/plugin pair when resolving fallback copies", () => { |
| listChannelCatalogEntriesMock.mockReturnValue([ |
| { |
| pluginId: "telegram", |
| origin: "config", |
| rootDir: "/tmp/config-telegram", |
| packageName: "telegram-shadow", |
| channel: { |
| id: "telegram", |
| label: "Telegram Shadow", |
| selectionLabel: "Telegram Shadow", |
| docsPath: "/channels/telegram", |
| blurb: "shadow", |
| }, |
| install: { localPath: "/tmp/config-telegram" }, |
| }, |
| { |
| pluginId: "telegram", |
| origin: "bundled", |
| rootDir: "/tmp/bundled-telegram", |
| packageName: "@openclaw/telegram", |
| channel: { |
| id: "telegram", |
| label: "Telegram", |
| selectionLabel: "Telegram", |
| docsPath: "/channels/telegram", |
| blurb: "bundled", |
| }, |
| install: { npmSpec: "@openclaw/telegram@1.0.0" }, |
| }, |
| ] satisfies PluginChannelCatalogEntry[]); |
|
|
| expect( |
| getChannelPluginCatalogEntry("telegram", { |
| excludePluginRefs: [{ pluginId: "telegram", origin: "config" }], |
| })?.origin, |
| ).toBe("bundled"); |
| }); |
|
|
| it.each(["__proto__", "constructor", "toString"])( |
| "rejects inherited install default choice %s from external catalog input", |
| (defaultChoice) => { |
| const root = fs.mkdtempSync(path.join(os.tmpdir(), "openclaw-channel-catalog-choice-")); |
| tempDirs.push(root); |
| const catalogPath = path.join(root, "catalog.json"); |
| writeChannelCatalog(catalogPath, "unsafe-choice", "Unsafe Choice", defaultChoice); |
|
|
| const entry = getChannelPluginCatalogEntry("unsafe-choice", { |
| catalogPaths: [catalogPath], |
| workspaceDir: root, |
| env: {}, |
| }); |
| expect(entry?.install.defaultChoice).toBe("npm"); |
| }, |
| ); |
|
|
| it("reloads external catalog entries after the explicit plugin metadata lifecycle reset", () => { |
| const root = fs.mkdtempSync(path.join(os.tmpdir(), "openclaw-channel-external-catalog-")); |
| tempDirs.push(root); |
| const catalogPath = path.join(root, "catalog.json"); |
| const options = { catalogPaths: [catalogPath], workspaceDir: root, env: {} }; |
|
|
| expect(getChannelPluginCatalogEntry("lifecycle-external", options)).toBeUndefined(); |
| writeChannelCatalog(catalogPath, "lifecycle-external", "After external install"); |
| clearPluginMetadataLifecycleCaches(); |
|
|
| expect(getChannelPluginCatalogEntry("lifecycle-external", options)?.meta.label).toBe( |
| "After external install", |
| ); |
| }); |
|
|
| it("reloads official generated catalog entries after the explicit plugin metadata lifecycle reset", () => { |
| const root = fs.mkdtempSync(path.join(os.tmpdir(), "openclaw-channel-official-catalog-")); |
| tempDirs.push(root); |
| fs.writeFileSync(path.join(root, "package.json"), JSON.stringify({ name: "openclaw" })); |
| vi.spyOn(process, "cwd").mockReturnValue(root); |
| const catalogPath = path.join(root, "dist", "channel-catalog.json"); |
| const options = { catalogPaths: [path.join(root, "external.json")], env: {} }; |
|
|
| expect(getChannelPluginCatalogEntry("lifecycle-official", options)).toBeUndefined(); |
| writeChannelCatalog(catalogPath, "lifecycle-official", "After official update"); |
| clearPluginMetadataLifecycleCaches(); |
|
|
| expect(getChannelPluginCatalogEntry("lifecycle-official", options)?.meta.label).toBe( |
| "After official update", |
| ); |
| }); |
| it.each([ |
| { name: "bundled", origin: "bundled", trusted: false, expected: "/channels/fixture" }, |
| { name: "official npm global", origin: "global", trusted: true, expected: "/channels/fixture" }, |
| { name: "official config", origin: "config", trusted: true, expected: "/channels/fixture" }, |
| { name: "untracked official identity", origin: "global", trusted: false }, |
| { name: "workspace shadow", origin: "workspace", trusted: true }, |
| { |
| name: "third-party package shadow", |
| origin: "global", |
| trusted: true, |
| packageName: "@vendor/fixture", |
| }, |
| { name: "different plugin owner", origin: "global", trusted: true, pluginId: "other-owner" }, |
| ] as const)("binds docs to official metadata for $name", (scenario) => { |
| const root = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), "openclaw-catalog-docs-"))); |
| tempDirs.push(root); |
| const officialPath = path.join(root, "official.json"); |
| writeChannelCatalog(officialPath, "fixture", "Fixture"); |
| listChannelCatalogEntriesMock.mockReturnValue([ |
| { |
| pluginId: ("pluginId" in scenario ? scenario.pluginId : undefined) ?? "fixture", |
| origin: scenario.origin, |
| rootDir: root, |
| packageName: "packageName" in scenario ? scenario.packageName : "@example/fixture", |
| trustedOfficialInstall: scenario.trusted, |
| channel: { |
| id: "fixture", |
| label: "Installed Fixture", |
| docsPath: |
| scenario.origin === "bundled" ? "/channels/fixture" : "/unverified-installed-guide", |
| blurb: "fixture", |
| }, |
| install: { npmSpec: "@example/fixture" }, |
| }, |
| ]); |
| const entry = getChannelPluginCatalogEntry("fixture", { |
| officialCatalogPaths: [officialPath], |
| catalogPaths: [path.join(root, "none.json")], |
| env: {}, |
| }); |
| expect(entry?.officialDocsPath).toBe("expected" in scenario ? scenario.expected : undefined); |
| expect(entry?.trustedSourceLinkedOfficialInstall).toBeUndefined(); |
| }); |
|
|
| it.each([ |
| "https://attacker.example/setup", |
| "//attacker.example/setup", |
| "/x/..//attacker.example/setup", |
| "/\\attacker.example/setup", |
| "relative/path", |
| ])("omits unsafe official docs path %s", (docsPath) => { |
| listChannelCatalogEntriesMock.mockReturnValue([ |
| { |
| pluginId: "fixture", |
| origin: "bundled", |
| rootDir: "/tmp/fixture", |
| packageName: "@example/fixture", |
| channel: { id: "fixture", label: "Fixture", docsPath, blurb: "fixture" }, |
| install: { npmSpec: "@example/fixture" }, |
| }, |
| ]); |
| expect(getChannelPluginCatalogEntry("fixture", { env: {} })?.officialDocsPath).toBeUndefined(); |
| }); |
| }); |
|
|
