@clawling/clawchat-plugin-openclaw 2026.5.12-28

package/src/channel.test.ts

@@ -0,0 +1,262 @@
+import { describe, expect, it, vi } from "vitest";
+import { openclawClawlingSetupPlugin } from "./channel.setup.ts";
+import { openclawClawlingPlugin } from "./channel.ts";
+import { parseOpenclawRecipient } from "./outbound.ts";
+import { getClawChatPlatformPrompt } from "./plugin-prompts.ts";
+
+describe("clawchat-plugin-openclaw plugin", () => {
+  it("publishes clawchat-plugin-openclaw channel metadata", () => {
+    expect(openclawClawlingPlugin.meta.id).toBe("clawchat-plugin-openclaw");
+    expect(openclawClawlingPlugin.meta.label).toBe("Clawling Chat");
+    expect(openclawClawlingPlugin.capabilities.blockStreaming).toBe(true);
+  });
+
+  it("reloads on channel config changes", () => {
+    expect(openclawClawlingPlugin.reload?.configPrefixes).toContain("channels.clawchat-plugin-openclaw");
+  });
+
+  it("does not let the setup-only entry claim channel hot reloads", () => {
+    expect(openclawClawlingSetupPlugin.reload?.configPrefixes ?? []).not.toContain(
+      "channels.clawchat-plugin-openclaw",
+    );
+  });
+
+  it("declares media capability", () => {
+    expect(openclawClawlingPlugin.capabilities.media).toBe(true);
+  });
+
+  it("logs a grep-friendly gateway startAccount marker before config validation", async () => {
+    const info = vi.fn();
+    const error = vi.fn();
+
+    await expect(
+      openclawClawlingPlugin.gateway?.startAccount?.({
+        cfg: {},
+        account: {
+          accountId: "default",
+          configured: false,
+          enabled: true,
+          token: "",
+          userId: "",
+          websocketUrl: "",
+        },
+        log: { info, error },
+      } as never),
+    ).rejects.toThrow(/websocketUrl\/token\/userId are required/);
+
+    expect(info).toHaveBeenCalledWith(expect.stringContaining("START_ACCOUNT_CALLED"));
+  });
+
+  it("setup.validateInput requires an invite code", () => {
+    const validate = openclawClawlingPlugin.setup?.validateInput as
+      | ((args: { cfg: unknown; accountId: string; input: Record<string, unknown> }) => string | null)
+      | undefined;
+    expect(validate).toBeDefined();
+    expect(validate!({ cfg: {}, accountId: "default", input: {} })).toMatch(
+      /invite code is required/i,
+    );
+    expect(
+      validate!({ cfg: {}, accountId: "default", input: { code: "  " } }),
+    ).toMatch(/invite code is required/i);
+    expect(
+      validate!({ cfg: {}, accountId: "default", input: { token: "  " } }),
+    ).toMatch(/invite code is required/i);
+  });
+
+  it("setup.validateInput passes when code or token is present", () => {
+    const validate = openclawClawlingPlugin.setup?.validateInput as (args: {
+      cfg: unknown;
+      accountId: string;
+      input: Record<string, unknown>;
+    }) => string | null;
+    expect(
+      validate({ cfg: {}, accountId: "default", input: { code: "INV-XXXX" } }),
+    ).toBeNull();
+    expect(
+      validate({ cfg: {}, accountId: "default", input: { token: "INV-XXXX" } }),
+    ).toBeNull();
+  });
+
+  it("setup.applyAccountConfig defers channel writes until credential persistence", () => {
+    const apply = openclawClawlingPlugin.setup?.applyAccountConfig as (args: {
+      cfg: unknown;
+      accountId: string;
+      input: Record<string, unknown>;
+    }) => Record<string, unknown>;
+    const cfg = {};
+    const next = apply({
+      cfg,
+      accountId: "default",
+      input: { code: "INV-XXXX" },
+    });
+
+    expect(next).toEqual(cfg);
+    expect(next).not.toHaveProperty("channels");
+  });
+
+  it("setup.applyAccountConfig leaves existing channel settings untouched", () => {
+    const apply = openclawClawlingPlugin.setup?.applyAccountConfig as (args: {
+      cfg: unknown;
+      accountId: string;
+      input: Record<string, unknown>;
+    }) => Record<string, unknown>;
+    const cfg = {
+      channels: {
+        "clawchat-plugin-openclaw": {
+          enabled: false,
+          groupMode: "mention",
+          baseUrl: "https://api.example.com",
+        },
+      },
+    };
+    const next = apply({
+      cfg,
+      accountId: "default",
+      input: { code: "INV-XXXX" },
+    });
+
+    expect(next).toEqual(cfg);
+  });
+
+  it("setup config deletion clears current ClawChat fields", () => {
+    const deleteAccount = openclawClawlingSetupPlugin.config?.deleteAccount as (args: {
+      cfg: Record<string, unknown>;
+      accountId: string;
+    }) => Record<string, unknown>;
+    const next = deleteAccount({
+      cfg: {
+        channels: {
+          "clawchat-plugin-openclaw": {
+            websocketUrl: "wss://chat.example.com/ws",
+            token: "secret",
+            userId: "agent-1",
+            groupMode: "mention",
+          },
+        },
+      },
+      accountId: "default",
+    }) as {
+      channels: {
+        "clawchat-plugin-openclaw": Record<string, unknown>;
+      };
+    };
+
+    expect(next.channels["clawchat-plugin-openclaw"]).toEqual({
+      groupMode: "mention",
+    });
+  });
+
+  it("setup.applyAccountConfig preserves existing plugin config without activating the runtime plugin", () => {
+    const apply = openclawClawlingPlugin.setup?.applyAccountConfig as (args: {
+      cfg: unknown;
+      accountId: string;
+      input: Record<string, unknown>;
+    }) => Record<string, unknown>;
+    const next = apply({
+      cfg: {
+        plugins: {
+          allow: ["browser"],
+          entries: {
+            "clawchat-plugin-openclaw": {
+              enabled: false,
+              config: { keep: true },
+              hooks: { allowConversationAccess: true },
+            },
+          },
+        },
+      },
+      accountId: "default",
+      input: { code: "INV-XXXX" },
+    }) as { plugins: { allow?: string[]; entries: Record<string, Record<string, unknown>> } };
+
+    expect(next.plugins.allow).toEqual(["browser"]);
+    expect(next.plugins.entries["clawchat-plugin-openclaw"]).toEqual({
+      enabled: false,
+      config: { keep: true },
+      hooks: { allowConversationAccess: true },
+    });
+  });
+
+  it("setup.applyAccountConfig preserves tool policy without enabling plugin tools", () => {
+    const apply = openclawClawlingPlugin.setup?.applyAccountConfig as (args: {
+      cfg: unknown;
+      accountId: string;
+      input: Record<string, unknown>;
+    }) => Record<string, unknown>;
+    const next = apply({
+      cfg: {
+        tools: {
+          profile: "coding",
+          allow: [],
+          deny: ["exec"],
+          alsoAllow: ["browser"],
+        },
+      },
+      accountId: "default",
+      input: { code: "INV-XXXX" },
+    }) as { tools: Record<string, unknown> };
+
+    expect(next.tools.profile).toBe("coding");
+    expect(next.tools.allow).toEqual([]);
+    expect(next.tools.deny).toEqual(["exec"]);
+    expect(next.tools.alsoAllow).toEqual(["browser"]);
+  });
+
+  it("publishes clawchat-specific agentPrompt hints", () => {
+    const hints = openclawClawlingPlugin.agentPrompt?.messageToolHints?.({
+      cfg: {} as never,
+      accountId: "default",
+    });
+    expect(hints).toEqual([getClawChatPlatformPrompt()]);
+    const joined = hints!.join("\n");
+    expect(joined).toContain("ClawChat is a social messaging platform");
+    expect(joined).toContain("[message]");
+    expect(joined).not.toMatch(/message tool/i);
+    expect(joined).not.toMatch(/\bmedia\b/i);
+    expect(joined).not.toMatch(/clawchat_get_account_profile/);
+    expect(joined).not.toMatch(/clawchat_get_user_profile/);
+    expect(joined).not.toMatch(/clawchat_list_account_friends/);
+    expect(joined).not.toMatch(/clawchat_upload_media_file/);
+    expect(joined).not.toMatch(/clawchat_upload_avatar_image/);
+    expect(joined).not.toMatch(/stream mode/i);
+    expect(joined).not.toMatch(/websocket/i);
+    expect(joined).not.toMatch(/clawchat:/);
+    expect(joined).not.toMatch(/specify 'to'/);
+  });
+
+  it("normalizes clawchat-plugin-openclaw targets for host resolution", () => {
+    const normalized = openclawClawlingPlugin.messaging?.normalizeTarget?.(
+      "clawchat-plugin-openclaw:usr_01KPN6SQFQEGM9HR11CHRHPMMT",
+    );
+    expect(normalized).toBe("usr_01KPN6SQFQEGM9HR11CHRHPMMT");
+  });
+
+  it("declares ClawChat target prefixes for OpenClaw channel selection", () => {
+    expect(openclawClawlingPlugin.messaging?.targetPrefixes).toEqual([
+      "cc",
+      "clawchat",
+      "clawchat-plugin-openclaw",
+    ]);
+  });
+
+  it("parses clawchat-plugin-openclaw target prefix as a direct recipient", () => {
+    expect(parseOpenclawRecipient("clawchat-plugin-openclaw:usr_01KPN6SQFQEGM9HR11CHRHPMMT")).toEqual({
+      chatId: "usr_01KPN6SQFQEGM9HR11CHRHPMMT",
+      chatType: "direct",
+    });
+  });
+
+  it("parses host-normalized group targets as group recipients", () => {
+    expect(parseOpenclawRecipient("group:cnv_01KR2NBGTKEQ0S0CAYCEQP3YPW")).toEqual({
+      chatId: "cnv_01KR2NBGTKEQ0S0CAYCEQP3YPW",
+      chatType: "group",
+    });
+  });
+
+  it("parses host-normalized direct targets as direct recipients", () => {
+    expect(parseOpenclawRecipient("direct:cnv_01KR2NBGTKEQ0S0CAYCEQP3YPW")).toEqual({
+      chatId: "cnv_01KR2NBGTKEQ0S0CAYCEQP3YPW",
+      chatType: "direct",
+    });
+  });
+});

package/src/channel.ts

@@ -0,0 +1,81 @@
+import { createChatChannelPlugin, type ChannelPlugin } from "openclaw/plugin-sdk/core";
+import { createEmptyChannelDirectoryAdapter } from "openclaw/plugin-sdk/directory-runtime";
+import {
+  CHANNEL_ID,
+  resolveOpenclawClawlingAccount,
+  type ResolvedOpenclawClawlingAccount,
+} from "./config.ts";
+import type { OpenclawClawchatMutateConfigFile } from "./login.runtime.ts";
+import { openclawClawlingOutbound } from "./outbound.ts";
+import { getOpenclawClawlingRuntime, startOpenclawClawlingGateway } from "./runtime.ts";
+import { openclawClawlingSetupPlugin } from "./channel.setup.ts";
+import { getClawChatPlatformPrompt } from "./plugin-prompts.ts";
+
+export const openclawClawlingPlugin: ChannelPlugin<ResolvedOpenclawClawlingAccount> =
+  createChatChannelPlugin({
+    base: {
+      ...openclawClawlingSetupPlugin,
+      reload: {
+        configPrefixes: [`channels.${CHANNEL_ID}`],
+      },
+      directory: createEmptyChannelDirectoryAdapter(),
+      auth: {
+        login: async ({ cfg, accountId, runtime }) => {
+          const { runOpenclawClawlingLogin } = await import("./login.runtime.ts");
+          await runOpenclawClawlingLogin({
+            cfg,
+            accountId: accountId ?? null,
+            runtime: { log: (message: string) => runtime.log(message) },
+            mutateConfigFile: (getOpenclawClawlingRuntime().config as unknown as {
+              mutateConfigFile: OpenclawClawchatMutateConfigFile;
+            }).mutateConfigFile,
+          });
+        },
+      },
+      gateway: {
+        startAccount: async (ctx) => {
+          const account = ctx.account ?? resolveOpenclawClawlingAccount(ctx.cfg);
+          ctx.log?.info?.(
+            `[${account.accountId}] clawchat-plugin-openclaw lifecycle START_ACCOUNT_CALLED configured=${account.configured} enabled=${account.enabled} hasToken=${Boolean(account.token)} hasUserId=${Boolean(account.userId)} websocketUrl=${account.websocketUrl || "(empty)"}`,
+          );
+          if (!account.configured) {
+            ctx.log?.error?.(
+              `[${account.accountId}] clawchat-plugin-openclaw lifecycle startAccount refused: websocketUrl/token/userId are required`,
+            );
+            throw new Error("Clawling Chat websocketUrl/token/userId are required");
+          }
+          try {
+            await startOpenclawClawlingGateway({
+              cfg: ctx.cfg,
+              account,
+              abortSignal: ctx.abortSignal,
+              setStatus: ctx.setStatus,
+              getStatus: ctx.getStatus,
+              log: ctx.log,
+            });
+          } finally {
+            ctx.log?.info?.(
+              `[${account.accountId}] clawchat-plugin-openclaw lifecycle startAccount completed/stopped`,
+            );
+          }
+        },
+      },
+      agentPrompt: {
+        messageToolHints: () => [getClawChatPlatformPrompt()],
+      },
+      messaging: {
+        targetPrefixes: ["cc", "clawchat", CHANNEL_ID],
+        normalizeTarget: (target) =>
+          target
+            .trim()
+            .replace(/^clawchat-plugin-openclaw:/i, "")
+            .replace(/^clawchat:/i, "")
+            .replace(/^cc:/i, ""),
+        targetResolver: {
+          looksLikeId: (raw, normalized) => Boolean((normalized ?? raw).trim()),
+          hint: "active-session",
+        },
+      },
+    },
+    outbound: openclawClawlingOutbound,
+  });