| |
| import { beforeAll, beforeEach, describe, expect, it, vi } from "vitest"; |
| import type { ChannelId, ChannelPlugin } from "../channels/plugins/types.public.js"; |
| import type { RuntimeEnv } from "../runtime.js"; |
| import { |
| loadFreshAgentsBindCommandModuleForTest, |
| readConfigFileSnapshotMock, |
| resetAgentsBindTestHarness, |
| runtime, |
| writeConfigFileMock, |
| } from "./agents.bind.test-support.js"; |
| import { baseConfigSnapshot } from "./test-runtime-config-helpers.js"; |
|
|
| const pluginRegistryMocks = vi.hoisted(() => ({ |
| listPluginContributionIds: vi.fn(() => ["external-chat"]), |
| })); |
|
|
| vi.mock("../agents/agent-scope.js", () => ({ |
| listAgentEntries: ( |
| cfg: { |
| agents?: { list?: Array<{ id: string; default?: boolean }> }; |
| } | null, |
| ) => cfg?.agents?.list ?? [], |
| resolveDefaultAgentId: ( |
| cfg: { |
| agents?: { list?: Array<{ id: string; default?: boolean }> }; |
| } | null, |
| ) => cfg?.agents?.list?.find((agent) => agent.default)?.id ?? "main", |
| })); |
|
|
| vi.mock("../config/bindings.js", () => ({ |
| isRouteBinding: (binding: { match?: unknown }) => Boolean(binding.match), |
| listRouteBindings: (cfg: { bindings?: Array<{ match?: unknown }> }) => |
| (cfg.bindings ?? []).filter((binding) => Boolean(binding.match)), |
| })); |
|
|
| vi.mock("../plugins/plugin-registry.js", () => ({ |
| loadPluginManifestRegistryForPluginRegistry: () => ({ diagnostics: [], plugins: [] }), |
| listPluginContributionIds: pluginRegistryMocks.listPluginContributionIds, |
| })); |
|
|
| type BindingResolverTestPlugin = Pick<ChannelPlugin, "id" | "meta" | "capabilities" | "config"> & { |
| setup?: Pick<NonNullable<ChannelPlugin["setup"]>, "resolveBindingAccountId">; |
| setupContract?: Pick<NonNullable<ChannelPlugin["setupContract"]>, "resolveBindingAccountId">; |
| }; |
|
|
| function createBindingResolverTestPlugin(params: { |
| id: ChannelId; |
| config: Partial<ChannelPlugin["config"]>; |
| resolveBindingAccountId?: NonNullable<ChannelPlugin["setup"]>["resolveBindingAccountId"]; |
| contractOnly?: boolean; |
| forceAccountBinding?: boolean; |
| }): BindingResolverTestPlugin { |
| return { |
| id: params.id, |
| meta: { |
| id: params.id, |
| label: params.id, |
| selectionLabel: params.id, |
| docsPath: `/channels/${params.id}`, |
| blurb: "test stub.", |
| ...(params.forceAccountBinding ? { forceAccountBinding: true } : {}), |
| }, |
| capabilities: { chatTypes: ["direct"] }, |
| config: { |
| listAccountIds: () => ["default"], |
| resolveAccount: () => ({}), |
| ...params.config, |
| }, |
| ...(params.resolveBindingAccountId |
| ? { |
| [params.contractOnly ? "setupContract" : "setup"]: { |
| resolveBindingAccountId: params.resolveBindingAccountId, |
| }, |
| } |
| : {}), |
| }; |
| } |
|
|
| vi.mock("../channels/plugins/index.js", () => { |
| return { |
| getLoadedChannelPlugin: () => undefined, |
| }; |
| }); |
|
|
| vi.mock("../channels/plugins/bundled.js", () => { |
| const knownChannels = new Map([ |
| [ |
| "discord", |
| createBindingResolverTestPlugin({ id: "discord", config: { listAccountIds: () => [] } }), |
| ], |
| [ |
| "matrix", |
| createBindingResolverTestPlugin({ |
| id: "matrix", |
| config: { listAccountIds: () => [] }, |
| resolveBindingAccountId: ({ agentId }) => agentId.toLowerCase(), |
| }), |
| ], |
| [ |
| "signal", |
| createBindingResolverTestPlugin({ |
| id: "signal", |
| config: { listAccountIds: () => [] }, |
| resolveBindingAccountId: ({ agentId }) => agentId.toLowerCase(), |
| contractOnly: true, |
| }), |
| ], |
| [ |
| "telegram", |
| createBindingResolverTestPlugin({ id: "telegram", config: { listAccountIds: () => [] } }), |
| ], |
| [ |
| "whatsapp", |
| createBindingResolverTestPlugin({ |
| id: "whatsapp", |
| config: { listAccountIds: () => ["default", "biz"] }, |
| forceAccountBinding: true, |
| }), |
| ], |
| ]); |
| return { |
| getBundledChannelSetupPlugin: (channel: string) => { |
| const normalized = channel.trim().toLowerCase(); |
| return knownChannels.get(normalized); |
| }, |
| }; |
| }); |
|
|
| let agentsBindCommand: typeof import("./agents.commands.bind.js").agentsBindCommand; |
| let agentsBindingsCommand: typeof import("./agents.commands.bind.js").agentsBindingsCommand; |
| let agentsUnbindCommand: typeof import("./agents.commands.bind.js").agentsUnbindCommand; |
|
|
| type JsonTestRuntime = RuntimeEnv & { |
| writeStdout: ReturnType<typeof vi.fn>; |
| writeJson: ReturnType<typeof vi.fn>; |
| }; |
|
|
| function createJsonTestRuntime(): JsonTestRuntime { |
| return { |
| log: vi.fn(), |
| error: vi.fn(), |
| exit: vi.fn(), |
| writeStdout: vi.fn(), |
| writeJson: vi.fn(), |
| }; |
| } |
|
|
| describe("agents bind/unbind commands", () => { |
| beforeAll(async () => { |
| ({ agentsBindCommand, agentsBindingsCommand, agentsUnbindCommand } = |
| await loadFreshAgentsBindCommandModuleForTest()); |
| }); |
|
|
| beforeEach(() => { |
| resetAgentsBindTestHarness(); |
| pluginRegistryMocks.listPluginContributionIds.mockClear(); |
| }); |
|
|
| function firstWrittenConfig(): { bindings?: unknown } { |
| const call = writeConfigFileMock.mock.calls[0]; |
| if (!call) { |
| throw new Error("expected config write"); |
| } |
| return call[0] as { bindings?: unknown }; |
| } |
|
|
| it("lists all bindings by default", async () => { |
| readConfigFileSnapshotMock.mockResolvedValue({ |
| ...baseConfigSnapshot, |
| config: { |
| bindings: [ |
| { agentId: "main", match: { channel: "matrix" } }, |
| { agentId: "ops", match: { channel: "telegram", accountId: "work" } }, |
| ], |
| }, |
| }); |
|
|
| await agentsBindingsCommand({}, runtime); |
|
|
| expect(readConfigFileSnapshotMock).toHaveBeenCalledWith({ skipPluginValidation: true }); |
| expect(runtime.log).toHaveBeenCalledWith( |
| ["Routing bindings:", "- main <- matrix", "- ops <- telegram accountId=work"].join("\n"), |
| ); |
| }); |
|
|
| it("binds routes to default agent when --agent is omitted", async () => { |
| readConfigFileSnapshotMock.mockResolvedValue({ |
| ...baseConfigSnapshot, |
| config: {}, |
| }); |
|
|
| await agentsBindCommand({ bind: ["telegram"] }, runtime); |
|
|
| expect(writeConfigFileMock).toHaveBeenCalledTimes(1); |
| const writtenConfig = firstWrittenConfig(); |
| expect(writtenConfig?.bindings).toStrictEqual([ |
| { type: "route", agentId: "main", match: { channel: "telegram" } }, |
| ]); |
| expect(runtime.exit).not.toHaveBeenCalled(); |
| expect(pluginRegistryMocks.listPluginContributionIds).not.toHaveBeenCalled(); |
| }); |
|
|
| it.each([ |
| { |
| name: "bindings with an unrepresentable agent", |
| command: "bindings", |
| options: { agent: "агент✨", json: true }, |
| message: 'Agent "агент✨" not found. Run openclaw agents list to see configured agents.', |
| }, |
| { |
| name: "bindings with an unknown agent", |
| command: "bindings", |
| options: { agent: "ghost", json: true }, |
| message: 'Agent "ghost" not found. Run openclaw agents list to see configured agents.', |
| }, |
| { |
| name: "bind with an unrepresentable agent", |
| command: "bind", |
| options: { agent: "агент✨", bind: ["telegram"], json: true }, |
| message: 'Agent "агент✨" not found. Run openclaw agents list to see configured agents.', |
| }, |
| { |
| name: "bind with a blank agent", |
| command: "bind", |
| options: { agent: " ", bind: ["telegram"], json: true }, |
| message: 'Agent " " not found. Run openclaw agents list to see configured agents.', |
| }, |
| { |
| name: "bind with an unknown agent before missing bindings", |
| command: "bind", |
| options: { agent: "ghost", json: true }, |
| message: 'Agent "ghost" not found. Run openclaw agents list to see configured agents.', |
| }, |
| { |
| name: "bind without bindings", |
| command: "bind", |
| options: { json: true }, |
| message: "Provide at least one --bind <channel[:accountId]>.", |
| }, |
| { |
| name: "bind with only blank bindings", |
| command: "bind", |
| options: { bind: [" "], json: true }, |
| message: "Provide at least one --bind <channel[:accountId]>.", |
| }, |
| { |
| name: "bind with multiple malformed bindings in input order", |
| command: "bind", |
| options: { bind: ["telegram:", "telegram:work:extra"], json: true }, |
| message: [ |
| 'Invalid binding "telegram:". Account id is empty. Use <channel>:<account>, for example telegram:default.', |
| 'Invalid binding "telegram:work:extra". Account id cannot contain ":". Use <channel>:<account>, for example telegram:default.', |
| ].join("\n"), |
| }, |
| { |
| name: "bind with an unknown channel", |
| command: "bind", |
| options: { bind: ["definitely-not-a-channel"], json: true }, |
| message: |
| 'Unknown channel "definitely-not-a-channel". Run `openclaw channels list --all` to see configured and installable channels.', |
| loadsPluginRegistry: true, |
| }, |
| { |
| name: "unbind with an unrepresentable agent", |
| command: "unbind", |
| options: { agent: "агент✨", all: true, json: true }, |
| message: 'Agent "агент✨" not found. Run openclaw agents list to see configured agents.', |
| }, |
| { |
| name: "unbind with an unknown agent before incompatible options", |
| command: "unbind", |
| options: { agent: "ghost", all: true, bind: ["telegram"], json: true }, |
| message: 'Agent "ghost" not found. Run openclaw agents list to see configured agents.', |
| }, |
| { |
| name: "unbind without bindings", |
| command: "unbind", |
| options: { json: true }, |
| message: "Provide at least one --bind <channel[:accountId]> or use --all.", |
| }, |
| { |
| name: "unbind with only blank bindings", |
| command: "unbind", |
| options: { bind: [" "], json: true }, |
| message: "Provide at least one --bind <channel[:accountId]> or use --all.", |
| }, |
| { |
| name: "unbind with incompatible all and binding options", |
| command: "unbind", |
| options: { all: true, bind: ["telegram"], json: true }, |
| message: "Use either --all or --bind, not both.", |
| }, |
| { |
| name: "unbind with a malformed binding", |
| command: "unbind", |
| options: { bind: ["telegram:work:extra"], json: true }, |
| message: |
| 'Invalid binding "telegram:work:extra". Account id cannot contain ":". Use <channel>:<account>, for example telegram:default.', |
| }, |
| ])( |
| "rejects $name through the root failure owner before mutation", |
| async ({ command, options, message, loadsPluginRegistry }) => { |
| readConfigFileSnapshotMock.mockResolvedValue({ |
| ...baseConfigSnapshot, |
| config: {}, |
| }); |
|
|
| const execution = |
| command === "bindings" |
| ? agentsBindingsCommand(options, runtime) |
| : command === "bind" |
| ? agentsBindCommand(options, runtime) |
| : agentsUnbindCommand(options, runtime); |
|
|
| await expect(execution).rejects.toMatchObject({ |
| name: "ExpectedCliError", |
| message, |
| humanOutput: message, |
| machineOutput: message, |
| }); |
| expect(runtime.error).not.toHaveBeenCalled(); |
| expect(runtime.exit).not.toHaveBeenCalled(); |
| expect(writeConfigFileMock).not.toHaveBeenCalled(); |
| if (!loadsPluginRegistry) { |
| expect(pluginRegistryMocks.listPluginContributionIds).not.toHaveBeenCalled(); |
| } |
| }, |
| ); |
|
|
| it("uses a wildcard account binding for multi-account channels", async () => { |
| readConfigFileSnapshotMock.mockResolvedValue({ |
| ...baseConfigSnapshot, |
| config: {}, |
| }); |
|
|
| await agentsBindCommand({ bind: ["whatsapp"] }, runtime); |
|
|
| expect(writeConfigFileMock).toHaveBeenCalledTimes(1); |
| const writtenConfig = firstWrittenConfig(); |
| expect(writtenConfig?.bindings).toStrictEqual([ |
| { type: "route", agentId: "main", match: { channel: "whatsapp", accountId: "*" } }, |
| ]); |
| expect(runtime.exit).not.toHaveBeenCalled(); |
| }); |
|
|
| it("resolves account bindings from channel-owned setup contracts", async () => { |
| readConfigFileSnapshotMock.mockResolvedValue({ |
| ...baseConfigSnapshot, |
| config: {}, |
| }); |
|
|
| await agentsBindCommand({ bind: ["signal"] }, runtime); |
|
|
| expect(firstWrittenConfig().bindings).toStrictEqual([ |
| { type: "route", agentId: "main", match: { channel: "signal", accountId: "main" } }, |
| ]); |
| expect(runtime.exit).not.toHaveBeenCalled(); |
| }); |
|
|
| it("binds manifest-known external channels without loading plugin runtime", async () => { |
| readConfigFileSnapshotMock.mockResolvedValue({ |
| ...baseConfigSnapshot, |
| config: {}, |
| }); |
|
|
| await agentsBindCommand({ bind: ["external-chat:work", "external-chat:home"] }, runtime); |
|
|
| expect(writeConfigFileMock).toHaveBeenCalledTimes(1); |
| const writtenConfig = firstWrittenConfig(); |
| expect(writtenConfig?.bindings).toStrictEqual([ |
| { |
| type: "route", |
| agentId: "main", |
| match: { channel: "external-chat", accountId: "work" }, |
| }, |
| { |
| type: "route", |
| agentId: "main", |
| match: { channel: "external-chat", accountId: "home" }, |
| }, |
| ]); |
| expect(pluginRegistryMocks.listPluginContributionIds).toHaveBeenCalledOnce(); |
| expect(pluginRegistryMocks.listPluginContributionIds).toHaveBeenCalledWith({ |
| contribution: "channels", |
| includeDisabled: true, |
| config: {}, |
| env: process.env, |
| }); |
| expect(runtime.exit).not.toHaveBeenCalled(); |
| pluginRegistryMocks.listPluginContributionIds.mockReturnValueOnce([]); |
| await expect( |
| agentsBindCommand({ bind: ["external-chat:next"] }, runtime), |
| ).rejects.toMatchObject({ |
| message: expect.stringContaining('Unknown channel "external-chat"'), |
| }); |
| expect(pluginRegistryMocks.listPluginContributionIds).toHaveBeenCalledTimes(2); |
| }); |
|
|
| it("unbinds all routes for an agent", async () => { |
| readConfigFileSnapshotMock.mockResolvedValue({ |
| ...baseConfigSnapshot, |
| config: { |
| agents: { list: [{ id: "ops", workspace: "/tmp/ops" }] }, |
| bindings: [ |
| { agentId: "main", match: { channel: "matrix" } }, |
| { agentId: "ops", match: { channel: "telegram", accountId: "work" } }, |
| ], |
| }, |
| }); |
|
|
| await agentsUnbindCommand({ agent: "ops", all: true }, runtime); |
|
|
| expect(writeConfigFileMock).toHaveBeenCalledTimes(1); |
| const writtenConfig = firstWrittenConfig(); |
| expect(writtenConfig?.bindings).toStrictEqual([ |
| { agentId: "main", match: { channel: "matrix" } }, |
| ]); |
| expect(runtime.exit).not.toHaveBeenCalled(); |
| }); |
|
|
| it("reports empty unbind-all as JSON without text logs", async () => { |
| readConfigFileSnapshotMock.mockResolvedValue({ |
| ...baseConfigSnapshot, |
| config: {}, |
| }); |
| const jsonRuntime = createJsonTestRuntime(); |
|
|
| await agentsUnbindCommand({ agent: "main", all: true, json: true }, jsonRuntime); |
|
|
| expect(writeConfigFileMock).not.toHaveBeenCalled(); |
| expect(jsonRuntime.log).not.toHaveBeenCalled(); |
| expect(jsonRuntime.writeJson.mock.calls[0]?.[0]).toStrictEqual({ |
| agentId: "main", |
| removed: [], |
| missing: [], |
| conflicts: [], |
| }); |
| expect(jsonRuntime.exit).not.toHaveBeenCalled(); |
| }); |
|
|
| it("reports ownership conflicts during unbind and exits 1", async () => { |
| readConfigFileSnapshotMock.mockResolvedValue({ |
| ...baseConfigSnapshot, |
| config: { |
| agents: { list: [{ id: "ops", workspace: "/tmp/ops" }] }, |
| bindings: [{ agentId: "main", match: { channel: "telegram", accountId: "ops" } }], |
| }, |
| }); |
|
|
| await agentsUnbindCommand({ agent: "ops", bind: ["telegram:ops"] }, runtime); |
|
|
| expect(writeConfigFileMock).not.toHaveBeenCalled(); |
| expect(runtime.error).toHaveBeenCalledWith("Bindings are owned by another agent:"); |
| expect(runtime.exit).toHaveBeenCalledWith(1); |
| }); |
|
|
| it.each(["bind", "unbind"])( |
| "preserves the post-decision %s conflict JSON result and exit status", |
| async (command) => { |
| readConfigFileSnapshotMock.mockResolvedValue({ |
| ...baseConfigSnapshot, |
| config: { |
| agents: { list: [{ id: "ops", workspace: "/tmp/ops" }] }, |
| bindings: [{ agentId: "main", match: { channel: "telegram", accountId: "ops" } }], |
| }, |
| }); |
| const jsonRuntime = createJsonTestRuntime(); |
| const options = { agent: "ops", bind: ["telegram:ops"], json: true }; |
|
|
| if (command === "bind") { |
| await agentsBindCommand(options, jsonRuntime); |
| } else { |
| await agentsUnbindCommand(options, jsonRuntime); |
| } |
|
|
| expect(writeConfigFileMock).not.toHaveBeenCalled(); |
| expect(jsonRuntime.writeJson.mock.calls[0]?.[0]).toStrictEqual({ |
| agentId: "ops", |
| ...(command === "bind" |
| ? { added: [], updated: [], skipped: [] } |
| : { removed: [], missing: [] }), |
| conflicts: ["telegram accountId=ops (agent=main)"], |
| }); |
| expect(jsonRuntime.error).not.toHaveBeenCalled(); |
| expect(jsonRuntime.exit).toHaveBeenCalledWith(1); |
| }, |
| ); |
| }); |
|
|
