@newbase-clawchat/openclaw-clawchat 2026.4.24 → 2026.4.30

package/src/manifest.test.ts

@@ -1,12 +1,29 @@
+import fs from "node:fs";
 import { describe, expect, it } from "vitest";
 import pluginManifest from "../openclaw.plugin.json" with { type: "json" };
 import packageJson from "../package.json" with { type: "json" };
 
 interface PackageJsonWithOpenclaw {
   name: string;
+  files: string[];
+  scripts: Record<string, string>;
+  devDependencies: Record<string, string>;
+  peerDependencies: Record<string, string>;
   openclaw: {
-    channel: { id: string };
-    install: { npmSpec: string };
+    extensions: string[];
+    runtimeExtensions?: string[];
+    setupEntry?: string;
+    channel?: {
+      id: string;
+      label: string;
+      selectionLabel?: string;
+      docsPath?: string;
+      docsLabel?: string;
+      blurb: string;
+      order?: number;
+      aliases?: string[];
+    };
+    install: { npmSpec: string; minHostVersion: string };
   };
 }
 
@@ -14,9 +31,170 @@ describe("openclaw-clawchat manifest", () => {
   it("keeps plugin id / channel id / package name aligned", () => {
     expect(pluginManifest.id).toBe("openclaw-clawchat");
     expect(pluginManifest.channels).toContain("openclaw-clawchat");
-    expect(packageJson.name).toBe("openclaw-clawchat");
+    expect(pluginManifest.skills).toContain("./skills");
+    expect(pluginManifest.channelConfigs?.["openclaw-clawchat"]?.label).toBe(
+      "Clawling Chat",
+    );
+    expect(pluginManifest.channelConfigs?.["openclaw-clawchat"]?.schema?.properties).toHaveProperty(
+      "token",
+    );
+    expect(packageJson.name).toBe("@newbase-clawchat/openclaw-clawchat");
     const pkg = packageJson as PackageJsonWithOpenclaw;
-    expect(pkg.openclaw.channel.id).toBe("openclaw-clawchat");
-    expect(pkg.openclaw.install.npmSpec).toBe("openclaw-clawchat");
+    expect(pkg.openclaw.extensions).toContain("./index.ts");
+    expect(pkg.openclaw.install.npmSpec).toBe("@newbase-clawchat/openclaw-clawchat");
+  });
+
+  it("requires an OpenClaw host with runtime config mutation support", () => {
+    const pkg = packageJson as PackageJsonWithOpenclaw;
+    expect(pkg.peerDependencies.openclaw).toBe("^2026.4.29");
+    expect(pkg.devDependencies.openclaw).toBe("2026.4.29");
+    expect(pkg.openclaw.install.minHostVersion).toBe(">=2026.4.29");
+  });
+
+  it("publishes compiled runtime entrypoints for npm plugin installs", () => {
+    const pkg = packageJson as PackageJsonWithOpenclaw;
+    expect(pkg.openclaw.extensions).toEqual(["./index.ts"]);
+    expect(pkg.openclaw.runtimeExtensions).toEqual(["./dist/index.js"]);
+    expect(pkg.files).toContain("dist");
+    expect(pkg.scripts.build).toBe("tsc -p tsconfig.build.json");
+    expect(pkg.scripts.prepack).toBe("npm run build");
+    expect(fs.existsSync(new URL("../tsconfig.build.json", import.meta.url))).toBe(true);
+  });
+
+  it("publishes channel catalog metadata for OpenClaw CLI discovery", () => {
+    const pkg = packageJson as PackageJsonWithOpenclaw;
+    expect(pkg.openclaw.channel).toEqual({
+      id: "openclaw-clawchat",
+      label: "Clawling Chat",
+      selectionLabel: "Clawling Chat",
+      docsPath: "/channels/openclaw-clawchat",
+      docsLabel: "openclaw-clawchat",
+      blurb: "Clawling Protocol v2 over WebSocket (chat-sdk).",
+      order: 110,
+    });
+  });
+
+  it("declares supported channel/command activation hints for plugin loading", () => {
+    expect(pluginManifest.activation).toEqual({
+      onStartup: true,
+      onChannels: ["openclaw-clawchat"],
+      onCommands: ["clawchat-login"],
+    });
+    expect(pluginManifest.commandAliases).toEqual([
+      { name: "clawchat-login", kind: "runtime-slash" },
+    ]);
+  });
+
+  it("does not publish setup migration or setup-runtime entry metadata", () => {
+    const pkg = packageJson as PackageJsonWithOpenclaw;
+    expect(pkg.files).not.toContain("setup-api.ts");
+    expect(pkg.files).not.toContain("setup-entry.ts");
+    expect(pkg.openclaw.setupEntry).toBeUndefined();
+    expect(fs.existsSync(new URL("../setup-api.ts", import.meta.url))).toBe(false);
+    expect(fs.existsSync(new URL("../setup-entry.ts", import.meta.url))).toBe(false);
+  });
+
+  it("does not document channels add as an activation path", () => {
+    const readme = fs.readFileSync(new URL("../README.md", import.meta.url), "utf8");
+    const docs = fs.readFileSync(new URL("../docs/openclaw-clawchat.md", import.meta.url), "utf8");
+    expect(readme).not.toMatch(/channels add --channel openclaw-clawchat/i);
+    expect(docs).not.toMatch(/channels add --channel openclaw-clawchat/i);
+  });
+
+  it("publishes a ClawChat account tools skill for non-activation workflows", () => {
+    const skill = fs.readFileSync(new URL("../skills/clawchat-account-tools/SKILL.md", import.meta.url), "utf8");
+    expect(skill).toMatch(/^---\nname: clawchat-account-tools\n/m);
+    expect(skill).toMatch(/description: .*Use when/i);
+    expect(skill).toMatch(/clawchat_get_account_profile/);
+    expect(skill).toMatch(/clawchat_get_user_profile/);
+    expect(skill).toMatch(/clawchat_list_account_friends/);
+    expect(skill).toMatch(/clawchat_update_account_profile/);
+    expect(skill).toMatch(/clawchat_upload_avatar_image/);
+    expect(skill).toMatch(/clawchat_upload_media_file/);
+    expect(skill).toMatch(/configured ClawChat account/i);
+    expect(skill).not.toMatch(/clawchat_activate/);
+  });
+
+  it("declares ownership of registered ClawChat agent tools", () => {
+    expect(pluginManifest.contracts?.tools).toEqual([
+      "clawchat_activate",
+      "clawchat_get_account_profile",
+      "clawchat_get_user_profile",
+      "clawchat_list_account_friends",
+      "clawchat_update_account_profile",
+      "clawchat_upload_avatar_image",
+      "clawchat_upload_media_file",
+    ]);
+  });
+
+  it("keeps the optional OpenClaw source checkout local-only", () => {
+    expect(fs.existsSync(new URL("../.gitmodules", import.meta.url))).toBe(false);
+
+    const gitignore = fs.readFileSync(new URL("../.gitignore", import.meta.url), "utf8");
+    expect(gitignore).toMatch(/^tmp\/openclaw\/$/m);
+
+    const pkg = packageJson as PackageJsonWithOpenclaw;
+    expect(pkg.scripts["dev:openclaw-source"]).toBe(
+      "test -d tmp/openclaw || git clone --depth=1 https://github.com/openclaw/openclaw.git tmp/openclaw",
+    );
+
+    const readme = fs.readFileSync(new URL("../README.md", import.meta.url), "utf8");
+    expect(readme).toMatch(/npm run dev:openclaw-source/);
+    expect(readme).toMatch(
+      /git clone --depth=1 https:\/\/github\.com\/openclaw\/openclaw\.git tmp\/openclaw/,
+    );
+    expect(readme).toMatch(/local-only/i);
+  });
+
+  it("keeps default Vitest discovery scoped to plugin sources", () => {
+    const configUrl = new URL("../vitest.config.ts", import.meta.url);
+    expect(fs.existsSync(configUrl)).toBe(true);
+    const config = fs.readFileSync(configUrl, "utf8");
+    expect(config).toMatch(/include:\s*\["src\/\*\*\/\*\.test\.ts"\]/);
+    expect(config).toMatch(/"tmp\/\*\*"/);
+    expect(config).toMatch(/"\.e2e\/\*\*"/);
+  });
+
+  it("keeps the activation skill on clawchat_activate with channel-login fallback", () => {
+    const skill = fs.readFileSync(new URL("../skills/clawchat-activate/SKILL.md", import.meta.url), "utf8");
+    expect(skill).toMatch(/name:\s*clawchat-activate/);
+    expect(skill).toMatch(/clawchat_activate/);
+    expect(skill).not.toMatch(/`clawchat\s+A1B2C3`/i);
+    expect(skill).not.toMatch(/`clawchat\s*<code>`/i);
+    expect(skill).not.toMatch(/\/clawchat_activate A1B2C3/);
+    expect(skill).not.toMatch(/\/clawchat-activate A1B2C3/);
+    expect(skill).not.toMatch(/\/clawchat-login A1B2C3/);
+    expect(skill).toMatch(/openclaw channels login --channel openclaw-clawchat/);
+    expect(skill).toMatch(/do not append/i);
+    expect(skill).toMatch(/prompt[^\n]+invite code[^\n]+provide/i);
+    expect(skill).toMatch(/channel login/i);
+    expect(skill).toMatch(/openclaw channels status --probe/);
+    expect(skill).toMatch(/openclaw gateway restart/);
+    expect(skill).not.toMatch(/ask the user to send/i);
+    expect(skill).not.toMatch(/give the exact/i);
+    expect(skill).toMatch(/restart[^\n]+only when/i);
+  });
+
+  it("documents clawchat_activate as the natural-language activation path with CLI fallback", () => {
+    const readme = fs.readFileSync(new URL("../README.md", import.meta.url), "utf8");
+    const docs = fs.readFileSync(new URL("../docs/openclaw-clawchat.md", import.meta.url), "utf8");
+    expect(readme).toMatch(/clawchat_activate/i);
+    expect(docs).toMatch(/clawchat_activate/i);
+    expect(readme).toMatch(/openclaw channels login --channel openclaw-clawchat/i);
+    expect(docs).toMatch(/openclaw channels login --channel openclaw-clawchat/i);
+    expect(readme).toMatch(/openclaw channels status --probe/i);
+    expect(docs).toMatch(/openclaw channels status --probe/i);
+    expect(readme).toMatch(/openclaw gateway restart/i);
+    expect(docs).toMatch(/openclaw gateway restart/i);
+    expect(readme).not.toMatch(/activation skill[^.]+\/clawchat-login/i);
+    expect(docs).not.toMatch(/natural-language activation requests[^.]+\/clawchat-login/i);
+    expect(readme).not.toMatch(/\/clawchat-activate\s+A1B2C3/i);
+    expect(docs).not.toMatch(/\/clawchat-activate\s+A1B2C3/i);
+    expect(readme).not.toMatch(/\/clawchat_activate\s+A1B2C3/i);
+    expect(docs).not.toMatch(/\/clawchat_activate\s+A1B2C3/i);
+    expect(readme).not.toMatch(/direct users to/i);
+    expect(docs).not.toMatch(/direct the\s+user/i);
+    expect(readme).toMatch(/activation skill calls/i);
+    expect(docs).toMatch(/Natural-language activation requests should call `clawchat_activate`/i);
   });
 });

package/src/outbound.test.ts

@@ -64,9 +64,10 @@ describe("openclaw-clawchat outbound", () => {
       text: "hello",
     });
     expect((client.sendMessage as ReturnType<typeof vi.fn>).mock.calls[0][0]).toMatchObject({
-      to: { id: "user-1", type: "direct" },
+      chat_id: "user-1",
       body: { fragments: [{ kind: "text", text: "hello" }] },
     });
+    expect((client.sendMessage as ReturnType<typeof vi.fn>).mock.calls[0][0]).not.toHaveProperty("chat_type");
     expect(client.replyMessage).not.toHaveBeenCalled();
     expect(result?.messageId).toBe("server-m1");
     expect(result?.acceptedAt).toBe(1234);
@@ -77,25 +78,27 @@ describe("openclaw-clawchat outbound", () => {
     await sendOpenclawClawlingText({
       client,
       account: baseAccount(),
-      to: { chatId: "user-1", chatType: "direct" },
+      to: { chatId: "chat-1", chatType: "direct" },
       text: "reply",
       replyCtx: {
         replyToMessageId: "m-orig",
+        replyPreviewChatId: "chat-1",
         replyPreviewSenderId: "user-2",
-        replyPreviewDisplayName: "Sender",
+        replyPreviewNickName: "Sender",
         replyPreviewText: "original",
       },
     });
     expect((client.replyMessage as ReturnType<typeof vi.fn>).mock.calls[0][0]).toMatchObject({
-      to: { id: "user-1", type: "direct" },
+      chat_id: "chat-1",
       replyTo: {
         msgId: "m-orig",
-        senderId: "user-2",
-        displayName: "Sender",
+        senderId: "chat-1",
+        nickName: "Sender",
         fragments: [{ kind: "text", text: "original" }],
       },
       body: { fragments: [{ kind: "text", text: "reply" }] },
     });
+    expect((client.replyMessage as ReturnType<typeof vi.fn>).mock.calls[0][0]).not.toHaveProperty("chat_type");
     expect(client.sendMessage).not.toHaveBeenCalled();
   });
 
@@ -168,7 +171,7 @@ describe("openclaw-clawchat outbound", () => {
       replyCtx: {
         replyToMessageId: "m-orig",
         replyPreviewSenderId: "user-2",
-        replyPreviewDisplayName: "Sender",
+        replyPreviewNickName: "Sender",
         replyPreviewText: "original",
       },
       mediaFragments: [{ kind: "image", url: "https://cdn/x.png" }],

package/src/outbound.ts

@@ -22,6 +22,7 @@ export interface OutboundTarget {
 
 export interface OutboundReplyCtx {
   replyToMessageId: string;
+  replyPreviewChatId?: string;
   replyPreviewSenderId: string;
   replyPreviewNickName: string;
   replyPreviewText: string;
@@ -38,6 +39,7 @@ export interface SendParams {
   to: OutboundTarget;
   text: string;
   replyCtx?: OutboundReplyCtx;
+  richFragments?: Fragment[];
   mediaFragments?: ClawlingMediaFragment[];
   mentions?: string[];
   log?: LogSink;
@@ -92,8 +94,9 @@ export function parseOpenclawRecipient(to: string): { chatId: string; chatType:
 
 export async function sendOpenclawClawlingText(params: SendParams): Promise<SendResult | null> {
   const text = (params.text ?? "").trim();
+  const richFragments = params.richFragments ?? [];
   const mediaFragments = params.mediaFragments ?? [];
-  if (!text && mediaFragments.length === 0) {
+  if (!text && richFragments.length === 0 && mediaFragments.length === 0) {
     params.log?.info?.(
       `[${params.account.accountId}] openclaw-clawchat outbound suppressed: empty text and no media`,
     );
@@ -106,7 +109,7 @@ export async function sendOpenclawClawlingText(params: SendParams): Promise<Send
   // with one of the SDK's narrow Fragment members (ImageFragment / FileFragment /
   // AudioFragment / VideoFragment) based on its runtime `kind`. The wide local
   // shape lets us build a single uniform array without a per-kind switch.
-  const fragments = [...textFragments, ...mediaFragments] as Fragment[];
+  const fragments = [...textFragments, ...richFragments, ...mediaFragments] as Fragment[];
 
   const useReply = params.replyCtx && mediaFragments.length === 0;
   if (params.replyCtx && mediaFragments.length > 0) {
@@ -121,26 +124,24 @@ export async function sendOpenclawClawlingText(params: SendParams): Promise<Send
     mode = "reply";
     ack = await params.client.replyMessage({
       chat_id: params.to.chatId,
-      chat_type: params.to.chatType,
       mode: "normal",
       replyTo: {
         msgId: params.replyCtx.replyToMessageId,
-        senderId: params.replyCtx.replyPreviewSenderId,
+        senderId: params.replyCtx.replyPreviewChatId ?? params.replyCtx.replyPreviewSenderId,
         nickName: params.replyCtx.replyPreviewNickName,
         fragments: [{ kind: "text", text: params.replyCtx.replyPreviewText }],
       },
       body: { fragments },
       context: { mentions },
-    });
+    } as Parameters<ClawlingChatClient["replyMessage"]>[0]);
   } else {
     mode = "send";
     ack = await params.client.sendMessage({
       chat_id: params.to.chatId,
-      chat_type: params.to.chatType,
       mode: "normal",
       body: { fragments },
       context: { mentions, reply: null },
-    });
+    } as Parameters<ClawlingChatClient["sendMessage"]>[0]);
   }
   params.log?.info?.(
     `[${params.account.accountId}] openclaw-clawchat outbound mode=${mode} msg=${ack.payload.message_id} text_len=${text.length} media=${mediaFragments.length} trace=${ack.trace_id}`,

package/src/plugin-entry.test.ts

@@ -0,0 +1,27 @@
+import { describe, expect, it, vi } from "vitest";
+import pluginEntry from "../index.ts";
+
+describe("openclaw-clawchat plugin entry", () => {
+  it("registers the channel/tools and native activation command without bootstrap migration", () => {
+    const api = {
+      config: {},
+      runtime: {},
+      logger: { debug: vi.fn(), info: vi.fn(), error: vi.fn() },
+      registerChannel: vi.fn(),
+      registerCommand: vi.fn(),
+      registerConfigMigration: vi.fn(),
+      registerTool: vi.fn(),
+    } as never;
+
+    pluginEntry.register(api);
+
+    expect(api.registerChannel).toHaveBeenCalledTimes(1);
+    expect(api.registerConfigMigration).not.toHaveBeenCalled();
+    expect(api.registerCommand).toHaveBeenCalledTimes(1);
+    expect(api.registerCommand).toHaveBeenCalledWith(
+      expect.objectContaining({
+        name: "clawchat-login",
+      }),
+    );
+  });
+});

package/src/protocol.ts

@@ -40,3 +40,8 @@ export function hasRenderableText(message: {
           (f as { url: string }).url.trim().length > 0)),
   );
 }
+
+export function isGroupSender(sender: unknown): boolean {
+  if (!sender || typeof sender !== "object") return false;
+  return (sender as { type?: unknown }).type === "group";
+}