@clawling/clawchat-plugin-openclaw 2026.5.12-28

package/src/commands.ts

@@ -0,0 +1,41 @@
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import type { OpenclawClawchatMutateConfigFile } from "./login.runtime.ts";
+
+function extractInviteCode(value: unknown): string {
+  const raw = typeof value === "string" ? value.trim() : "";
+  return raw.match(/\b[A-Z0-9]{6}\b/u)?.[0] ?? "";
+}
+
+function errorMessage(err: unknown): string {
+  return err instanceof Error ? err.message : String(err);
+}
+
+export function registerOpenclawClawlingCommands(api: Pick<OpenClawPluginApi, "registerCommand" | "logger" | "runtime">): void {
+  api.registerCommand({
+    name: "clawchat-activate",
+    description: "Activate ClawChat with an invite code, e.g. /clawchat-activate A1B2C3.",
+    acceptsArgs: true,
+    requireAuth: true,
+    async handler(ctx) {
+      const code = extractInviteCode(ctx.args ?? ctx.commandBody);
+      if (!code) {
+        return { text: "ClawChat invite code is required. Usage: /clawchat-activate A1B2C3" };
+      }
+      try {
+        const { runOpenclawClawlingLogin } = await import("./login.runtime.ts");
+        await runOpenclawClawlingLogin({
+          cfg: ctx.config,
+          accountId: ctx.accountId ?? null,
+          runtime: { log: (message: string) => api.logger?.info?.(message) },
+          readInviteCode: async () => code,
+          mutateConfigFile: (api.runtime.config as unknown as {
+            mutateConfigFile: OpenclawClawchatMutateConfigFile;
+          }).mutateConfigFile,
+        });
+        return { text: "✅ ClawChat activated successfully." };
+      } catch (err) {
+        return { text: `❌ ${errorMessage(err)}` };
+      }
+    },
+  });
+}

package/src/config.test.ts

@@ -0,0 +1,344 @@
+import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/setup";
+import { describe, expect, it } from "vitest";
+import {
+  CHANNEL_ID,
+  DEFAULT_BASE_URL,
+  DEFAULT_WEBSOCKET_URL,
+  effectiveGroupCommandMode,
+  effectiveGroupMode,
+  mergeOpenclawClawchatToolAllow,
+  openclawClawlingConfigSchema,
+  resolveOpenclawClawlingAccount,
+  listOpenclawClawlingAccountIds,
+} from "./config.ts";
+
+describe("clawchat-plugin-openclaw config", () => {
+  it("uses correct channel id", () => {
+    expect(CHANNEL_ID).toBe("clawchat-plugin-openclaw");
+  });
+
+  it("resolves defaults when no config provided", () => {
+    const account = resolveOpenclawClawlingAccount({});
+    expect(account.accountId).toBe(DEFAULT_ACCOUNT_ID);
+    expect(account.enabled).toBe(true);
+    expect(account.configured).toBe(false);
+    expect(account).not.toHaveProperty("replyMode");
+    expect(account.groupMode).toBe("all");
+    expect(account.groupCommandMode).toBe("owner");
+    expect(account.forwardThinking).toBe(true);
+    expect(account.forwardToolCalls).toBe(false);
+    expect(account.richInteractions).toBe(false);
+    expect(account).not.toHaveProperty("stream");
+  });
+
+  it("resolves required fields without reply mode or stream tuning", () => {
+    const cfg = {
+      channels: {
+        "clawchat-plugin-openclaw": {
+          websocketUrl: "wss://chat.example.com/ws",
+          token: "secret",
+          agentId: "agt-1",
+          userId: "agent-1",
+          ownerUserId: "owner-1",
+          forwardThinking: false,
+          forwardToolCalls: true,
+          richInteractions: true,
+        },
+      },
+    };
+    const account = resolveOpenclawClawlingAccount(cfg);
+    expect(account.configured).toBe(true);
+    expect(account.websocketUrl).toBe("wss://chat.example.com/ws");
+    expect(account.token).toBe("secret");
+    expect(account.agentId).toBe("agt-1");
+    expect(account.userId).toBe("agent-1");
+    expect(account.ownerUserId).toBe("owner-1");
+    expect(account).not.toHaveProperty("replyMode");
+    expect(account.forwardThinking).toBe(false);
+    expect(account.forwardToolCalls).toBe(true);
+    expect(account.richInteractions).toBe(true);
+    expect(account).not.toHaveProperty("stream");
+  });
+
+  it("does not use userId as an ownerUserId fallback", () => {
+    const account = resolveOpenclawClawlingAccount({
+      channels: {
+        "clawchat-plugin-openclaw": {
+          token: "secret",
+          userId: "agent-user-id",
+        },
+      },
+    });
+
+    expect(account.userId).toBe("agent-user-id");
+    expect(account.ownerUserId).not.toBe("agent-user-id");
+    expect(account.configured).toBe(false);
+  });
+
+  it("resolves credentials from ClawChat environment variables when config omits them", () => {
+    const account = resolveOpenclawClawlingAccount(
+      {},
+      {
+        CLAWCHAT_TOKEN: "env-token",
+        CLAWCHAT_AGENT_ID: "env-agent",
+        CLAWCHAT_USER_ID: "env-user",
+        CLAWCHAT_OWNER_USER_ID: "env-owner",
+        CLAWCHAT_BASE_URL: "https://api.env.example",
+        CLAWCHAT_WEBSOCKET_URL: "wss://ws.env.example/ws",
+      },
+    );
+
+    expect(account.configured).toBe(true);
+    expect(account.token).toBe("env-token");
+    expect(account.agentId).toBe("env-agent");
+    expect(account.userId).toBe("env-user");
+    expect(account.ownerUserId).toBe("env-owner");
+    expect(account.baseUrl).toBe("https://api.env.example");
+    expect(account.websocketUrl).toBe("wss://ws.env.example/ws");
+  });
+
+  it("prefers explicit channel config over ClawChat environment variables", () => {
+    const account = resolveOpenclawClawlingAccount(
+      {
+        channels: {
+          "clawchat-plugin-openclaw": {
+            token: "config-token",
+            agentId: "config-agent",
+            userId: "config-user",
+            ownerUserId: "config-owner",
+            baseUrl: "https://api.config.example",
+            websocketUrl: "wss://ws.config.example/ws",
+          },
+        },
+      },
+      {
+        CLAWCHAT_TOKEN: "env-token",
+        CLAWCHAT_AGENT_ID: "env-agent",
+        CLAWCHAT_USER_ID: "env-user",
+        CLAWCHAT_OWNER_USER_ID: "env-owner",
+        CLAWCHAT_BASE_URL: "https://api.env.example",
+        CLAWCHAT_WEBSOCKET_URL: "wss://ws.env.example/ws",
+      },
+    );
+
+    expect(account.token).toBe("config-token");
+    expect(account.agentId).toBe("config-agent");
+    expect(account.userId).toBe("config-user");
+    expect(account.ownerUserId).toBe("config-owner");
+    expect(account.baseUrl).toBe("https://api.config.example");
+    expect(account.websocketUrl).toBe("wss://ws.config.example/ws");
+  });
+
+  it("does not publish replyMode in the channel config schema", () => {
+    expect(openclawClawlingConfigSchema.properties).not.toHaveProperty("replyMode");
+  });
+
+  it("does not publish stream tuning in the channel config schema", () => {
+    expect(openclawClawlingConfigSchema.properties).not.toHaveProperty("stream");
+  });
+
+  it("preserves explicit mention groupMode", () => {
+    const cfg = {
+      channels: {
+        "clawchat-plugin-openclaw": {
+          websocketUrl: "w",
+          token: "t",
+          userId: "a",
+          ownerUserId: "o",
+          groupMode: "mention",
+        },
+      },
+    };
+    const account = resolveOpenclawClawlingAccount(cfg);
+    expect(account.groupMode).toBe("mention");
+  });
+
+  it("falls back to all groupMode for unknown values", () => {
+    const cfg = {
+      channels: {
+        "clawchat-plugin-openclaw": {
+          websocketUrl: "w",
+          token: "t",
+          userId: "a",
+          ownerUserId: "o",
+          groupMode: "weird",
+        },
+      },
+    };
+    const account = resolveOpenclawClawlingAccount(cfg);
+    expect(account.groupMode).toBe("all");
+  });
+
+  it("resolves per-group groupMode overrides", () => {
+    const account = resolveOpenclawClawlingAccount({
+      channels: {
+        "clawchat-plugin-openclaw": {
+          groups: {
+            "group-1": { groupMode: "mention" },
+            "*": { groupMode: "all" },
+          },
+        },
+      },
+    });
+
+    expect(account.groups).toEqual({
+      "group-1": { groupMode: "mention", groupCommandMode: "owner" },
+      "*": { groupMode: "all", groupCommandMode: "owner" },
+    });
+    expect(effectiveGroupMode(account, "group-1")).toBe("mention");
+    expect(effectiveGroupMode(account, "group-2")).toBe("all");
+  });
+
+  it("resolves groupCommandMode and per-group overrides", () => {
+    const account = resolveOpenclawClawlingAccount({
+      channels: {
+        "clawchat-plugin-openclaw": {
+          groupCommandMode: "off",
+          groups: {
+            "group-open": { groupCommandMode: "all" },
+            "*": { groupCommandMode: "owner" },
+          },
+        },
+      },
+    });
+
+    expect(account.groupCommandMode).toBe("off");
+    expect(account.groups).toEqual({
+      "group-open": { groupMode: "all", groupCommandMode: "all" },
+      "*": { groupMode: "all", groupCommandMode: "owner" },
+    });
+    expect(effectiveGroupCommandMode(account, "group-open")).toBe("all");
+    expect(effectiveGroupCommandMode(account, "group-other")).toBe("owner");
+  });
+
+  it("normalizes invalid groupCommandMode values to owner", () => {
+    const account = resolveOpenclawClawlingAccount({
+      channels: {
+        "clawchat-plugin-openclaw": {
+          groupCommandMode: "weird",
+          groups: {
+            "group-weird": { groupCommandMode: "weird" },
+          },
+        },
+      },
+    });
+
+    expect(account.groupCommandMode).toBe("owner");
+    expect(account.groups["group-weird"]?.groupCommandMode).toBe("owner");
+    expect(effectiveGroupCommandMode(account, "group-weird")).toBe("owner");
+  });
+
+  it("lets exact per-group groupMode win over wildcard and channel defaults", () => {
+    const account = resolveOpenclawClawlingAccount({
+      channels: {
+        "clawchat-plugin-openclaw": {
+          groupMode: "mention",
+          groups: {
+            "group-open": { groupMode: "all" },
+            "*": { groupMode: "mention" },
+          },
+        },
+      },
+    });
+
+    expect(effectiveGroupMode(account, "group-open")).toBe("all");
+    expect(effectiveGroupMode(account, "group-other")).toBe("mention");
+  });
+
+  it("normalizes invalid per-group groupMode values to all", () => {
+    const account = resolveOpenclawClawlingAccount({
+      channels: {
+        "clawchat-plugin-openclaw": {
+          groupMode: "mention",
+          groups: {
+            "group-weird": { groupMode: "weird" },
+          },
+        },
+      },
+    });
+
+    expect(account.groups["group-weird"]?.groupMode).toBe("all");
+    expect(effectiveGroupMode(account, "group-weird")).toBe("all");
+  });
+
+  it("lists the default account id", () => {
+    expect(listOpenclawClawlingAccountIds()).toEqual([DEFAULT_ACCOUNT_ID]);
+  });
+
+  it("parses baseUrl when provided", () => {
+    const cfg = {
+      channels: {
+        "clawchat-plugin-openclaw": {
+          websocketUrl: "wss://w",
+          token: "t",
+          userId: "u",
+          ownerUserId: "o",
+          baseUrl: "https://api.example.com",
+        },
+      },
+    };
+    const account = resolveOpenclawClawlingAccount(cfg);
+    expect(account.baseUrl).toBe("https://api.example.com");
+  });
+
+  it("falls back to the built-in DEFAULT_BASE_URL when unset", async () => {
+    const account = resolveOpenclawClawlingAccount({});
+    expect(account.baseUrl).toBe(DEFAULT_BASE_URL);
+  });
+
+  it("falls back to the built-in DEFAULT_WEBSOCKET_URL when unset", async () => {
+    const account = resolveOpenclawClawlingAccount({});
+    expect(account.websocketUrl).toBe(DEFAULT_WEBSOCKET_URL);
+  });
+
+  it("uses the production ClawChat service as the built-in fallback endpoint", () => {
+    expect(DEFAULT_BASE_URL).toBe("https://app.clawling.com");
+    expect(DEFAULT_WEBSOCKET_URL).toBe("wss://app.clawling.com/ws");
+  });
+
+  it("does NOT include baseUrl in the configured predicate (channel still works without it)", async () => {
+    const cfg = {
+      channels: {
+        "clawchat-plugin-openclaw": {
+          websocketUrl: "wss://w",
+          token: "t",
+          userId: "u",
+          ownerUserId: "o",
+          // no baseUrl — resolver uses default
+        },
+      },
+    };
+    const account = resolveOpenclawClawlingAccount(cfg);
+    expect(account.configured).toBe(true);
+    expect(account.baseUrl).toBe(DEFAULT_BASE_URL);
+  });
+
+  it("adds the plugin to tools.alsoAllow even when an explicit allowlist is already in use", () => {
+    const cfg = mergeOpenclawClawchatToolAllow({
+      tools: {
+        allow: ["bash"],
+        deny: ["exec"],
+      },
+    } as never) as { tools: Record<string, unknown> };
+
+    expect(cfg.tools.allow).toEqual(["bash"]);
+    expect(cfg.tools.deny).toEqual(["exec"]);
+    expect(cfg.tools.alsoAllow).toEqual(["clawchat-plugin-openclaw"]);
+  });
+
+  it("adds the plugin to tools.alsoAllow when no explicit allowlist is in use", () => {
+    const cfg = mergeOpenclawClawchatToolAllow({
+      tools: {
+        profile: "coding",
+        allow: [],
+      },
+    } as never) as { tools: Record<string, unknown> };
+
+    expect(cfg.tools).toEqual({
+      profile: "coding",
+      allow: [],
+      alsoAllow: ["clawchat-plugin-openclaw"],
+    });
+  });
+
+});