@newbase-clawchat/openclaw-clawchat 2026.4.23 → 2026.4.29

package/src/config.ts

@@ -8,10 +8,9 @@ export const CHANNEL_ID = "openclaw-clawchat" as const;
  * login` works out of the box without requiring a prior `openclaw channel
  * setup` call. Operators can still override either one via config.
  *
- * TODO: replace these placeholders with the production URLs.
  */
-export const DEFAULT_BASE_URL = "https://api.clawling.chat" as const;
-export const DEFAULT_WEBSOCKET_URL = "wss://api.clawling.chat/ws" as const;
+export const DEFAULT_BASE_URL = "http://company.newbaselab.com:10086" as const;
+export const DEFAULT_WEBSOCKET_URL = "ws://company.newbaselab.com:10086/ws" as const;
 
 export type ReplyMode = "static" | "stream";
 
@@ -150,6 +149,57 @@ export const openclawClawlingConfigSchema = {
   },
 } as const;
 
+function isOpenclawClawchatToolAllowEntry(entry: unknown): boolean {
+  return entry === CHANNEL_ID || entry === "group:plugins";
+}
+
+function hasOpenclawClawchatToolAllow(cfg: OpenClawConfig): boolean {
+  const currentTools = ((cfg as { tools?: Record<string, unknown> }).tools ?? {}) as Record<
+    string,
+    unknown
+  >;
+  const currentAlsoAllow = Array.isArray(currentTools.alsoAllow) ? currentTools.alsoAllow : [];
+  const currentAllow = Array.isArray(currentTools.allow) ? currentTools.allow : [];
+  return [...currentAllow, ...currentAlsoAllow].some(isOpenclawClawchatToolAllowEntry);
+}
+
+function mergeToolPolicyEntryAllow(
+  cfg: OpenClawConfig,
+  entry: string,
+  isAlreadyCovered: (value: unknown) => boolean,
+): OpenClawConfig {
+  const currentTools = ((cfg as { tools?: Record<string, unknown> }).tools ?? {}) as Record<
+    string,
+    unknown
+  >;
+  const currentAlsoAllow = Array.isArray(currentTools.alsoAllow)
+    ? currentTools.alsoAllow.slice()
+    : [];
+  const currentAllow = Array.isArray(currentTools.allow) ? currentTools.allow.slice() : [];
+  const alreadyAllowed = [...currentAllow, ...currentAlsoAllow].some(isAlreadyCovered);
+  if (currentAllow.length > 0) {
+    return {
+      ...cfg,
+      tools: {
+        ...currentTools,
+        allow: alreadyAllowed ? currentAllow : [...currentAllow, entry],
+      },
+    } as OpenClawConfig;
+  }
+  const alreadyAlsoAllowed = currentAlsoAllow.some(isAlreadyCovered);
+  return {
+    ...cfg,
+    tools: {
+      ...currentTools,
+      alsoAllow: alreadyAlsoAllowed ? currentAlsoAllow : [...currentAlsoAllow, entry],
+    },
+  } as OpenClawConfig;
+}
+
+export function mergeOpenclawClawchatToolAllow(cfg: OpenClawConfig): OpenClawConfig {
+  return mergeToolPolicyEntryAllow(cfg, CHANNEL_ID, isOpenclawClawchatToolAllowEntry);
+}
+
 export type ResolvedOpenclawClawlingAccount = {
   accountId: string;
   name: string;
@@ -274,4 +324,3 @@ export function resolveOpenclawClawlingAccount(
 export function listOpenclawClawlingAccountIds(): string[] {
   return [DEFAULT_ACCOUNT_ID];
 }
-

package/src/inbound.test.ts

@@ -93,7 +93,7 @@ describe("openclaw-clawchat inbound", () => {
       envelope: buildSendEnvelope({ text: "hello there" }),
       cfg: {},
       runtime: {} as never,
-      account: baseAccount(),
+      account: baseAccount({ groupMode: "mention" }),
       ingest,
     });
     expect(ingest).toHaveBeenCalledTimes(1);
@@ -110,7 +110,7 @@ describe("openclaw-clawchat inbound", () => {
       envelope: buildSendEnvelope({ senderType: "direct" }),
       cfg: {},
       runtime: {} as never,
-      account: baseAccount(),
+      account: baseAccount({ groupMode: "mention" }),
       ingest,
     });
     const { wasMentioned } = ingest.mock.calls[0]![0];
@@ -145,7 +145,7 @@ describe("openclaw-clawchat inbound", () => {
       envelope: buildSendEnvelope({ senderType: "group" }),
       cfg: {},
       runtime: {} as never,
-      account: baseAccount(),
+      account: baseAccount({ groupMode: "mention" }),
       ingest,
     });
     expect(ingest).not.toHaveBeenCalled();
@@ -184,7 +184,7 @@ describe("openclaw-clawchat inbound", () => {
     expect(replyCtx).toEqual({
       replyToMessageId: "m-orig",
       replyPreviewSenderId: "user-2",
-      replyPreviewDisplayName: "User Two",
+      replyPreviewNickName: "User Two",
       replyPreviewText: "original text",
     });
   });
@@ -262,7 +262,7 @@ describe("openclaw-clawchat inbound", () => {
     expect(ingest).toHaveBeenCalledTimes(1);
     const call = ingest.mock.calls[0]![0];
     expect(call.senderId).toBe("user-1");
-    expect(call.senderDisplayName).toBe("User One");
+    expect(call.senderNickName).toBe("User One");
     expect(call.peer).toEqual({ kind: "direct", id: "user-1" });
   });
 

package/src/inbound.ts

@@ -52,6 +52,29 @@ const DEDUP_MAX = 256;
 const dedupSeen: string[] = [];
 const dedupSet = new Set<string>();
 
+type SenderLike = {
+  id?: unknown;
+  nick_name?: unknown;
+  sender_id?: unknown;
+  display_name?: unknown;
+  type?: unknown;
+};
+
+function normalizeSender(sender: unknown): { id: string; nickName: string; type?: ChatType } | null {
+  if (!sender || typeof sender !== "object") return null;
+  const s = sender as SenderLike;
+  const id = typeof s.id === "string" ? s.id : typeof s.sender_id === "string" ? s.sender_id : "";
+  if (!id) return null;
+  const type = s.type === "group" || s.type === "direct" ? s.type : undefined;
+  const nickName =
+    typeof s.nick_name === "string"
+      ? s.nick_name
+      : typeof s.display_name === "string"
+        ? s.display_name
+        : id;
+  return { id, nickName, ...(type ? { type } : {}) };
+}
+
 export function _resetDedupForTest(): void {
   dedupSeen.length = 0;
   dedupSet.clear();
@@ -101,20 +124,22 @@ export async function dispatchOpenclawClawlingInbound(
       reply: {
         reply_to_msg_id: string;
         reply_preview: {
-          id: string;
-          nick_name: string;
+          id?: string;
+          nick_name?: string;
+          sender_id?: string;
+          display_name?: string;
           fragments: Array<Record<string, unknown>>;
         };
       } | null;
     };
     /** Legacy fallback: older fixtures carried sender inside payload.message. */
-    sender?: { id: string; nick_name: string };
+    sender?: SenderLike;
   };
 
   // v2 envelopes carry sender on the envelope (RoutingSender); the legacy
   // message.sender shape is accepted as a fallback for older fixtures.
-  const sender = envelope.sender ?? message.sender;
-  if (!sender || typeof sender.id !== "string" || !sender.id) {
+  const sender = normalizeSender(envelope.sender ?? message.sender);
+  if (!sender) {
     log?.info?.(
       `[${account.accountId}] openclaw-clawchat skip: missing sender trace=${envelope.trace_id}`,
     );
@@ -122,7 +147,10 @@ export async function dispatchOpenclawClawlingInbound(
   }
   // `chat_type` is on the envelope in the new protocol. Default to "direct"
   // if the server didn't include it (defensive; shouldn't happen in practice).
-  const chatType: ChatType = envelope.chat_type ?? "direct";
+  const legacyTo = (envelope as Envelope<DownlinkMessageSendPayload> & {
+    to?: { type?: ChatType };
+  }).to;
+  const chatType: ChatType = envelope.chat_type ?? sender.type ?? legacyTo?.type ?? "direct";
   const isGroup = chatType === "group";
   if (payload.message_mode !== "normal") {
     log?.info?.(
@@ -166,8 +194,14 @@ export async function dispatchOpenclawClawlingInbound(
   const replyCtx = message.context.reply
     ? {
         replyToMessageId: message.context.reply.reply_to_msg_id,
-        replyPreviewSenderId: message.context.reply.reply_preview.id,
-        replyPreviewNickName: message.context.reply.reply_preview.nick_name,
+        replyPreviewSenderId:
+          message.context.reply.reply_preview.id ??
+          message.context.reply.reply_preview.sender_id ??
+          "",
+        replyPreviewNickName:
+          message.context.reply.reply_preview.nick_name ??
+          message.context.reply.reply_preview.display_name ??
+          "",
         replyPreviewText: fragmentsToText(message.context.reply.reply_preview.fragments as never),
       }
     : undefined;
@@ -187,7 +221,7 @@ export async function dispatchOpenclawClawlingInbound(
     accountId: account.accountId,
     peer: { kind: isGroup ? "group" : "direct", id: chatId },
     senderId: sender.id,
-    senderNickName: sender.nick_name,
+    senderNickName: sender.nickName,
     rawBody,
     messageId: payload.message_id,
     traceId: envelope.trace_id,

package/src/login.runtime.test.ts

@@ -95,7 +95,7 @@ describe("runOpenclawClawlingLogin", () => {
     });
 
     expect(agentsConnect).toHaveBeenCalledWith({
-      inviteCode: "INV-ABC",
+      code: "INV-ABC",
       platform: "openclaw",
       type: "clawbot",
     });
@@ -112,6 +112,109 @@ describe("runOpenclawClawlingLogin", () => {
     expect(log).toHaveBeenCalledWith(expect.stringContaining("login succeeded"));
   });
 
+  it("preserves other configured channels when persisting ClawChat credentials", async () => {
+    const cfg = {
+      channels: {
+        telegram: {
+          enabled: true,
+          token: "telegram-token",
+        },
+        [CHANNEL_ID]: {
+          baseUrl: "https://api.example.com",
+          websocketUrl: "wss://ws.example.com/v2/client",
+        },
+      },
+    } as unknown as OpenClawConfig;
+    const agentsConnect = vi.fn().mockResolvedValue({
+      agent: { user_id: "agent-123" },
+      access_token: "access-tok",
+      refresh_token: "refresh-tok",
+    });
+    const persistConfig = vi.fn();
+
+    await runOpenclawClawlingLogin({
+      cfg,
+      runtime: { log: vi.fn() },
+      readInviteCode: async () => "INV-ABC",
+      apiClientFactory: () => makeApiClient({ agentsConnect }),
+      persistConfig,
+    });
+
+    const savedCfg = persistConfig.mock.calls[0]![0] as OpenClawConfig;
+    expect(savedCfg.channels?.telegram).toEqual({
+      enabled: true,
+      token: "telegram-token",
+    });
+    expect(savedCfg.channels?.[CHANNEL_ID]).toMatchObject({
+      baseUrl: "https://api.example.com",
+      websocketUrl: "wss://ws.example.com/v2/client",
+      token: "access-tok",
+      userId: "agent-123",
+      refreshToken: "refresh-tok",
+    });
+  });
+
+  it("enables the channel when login fills a pre-activation disabled skeleton", async () => {
+    const cfg = buildCfg({
+      enabled: false,
+      baseUrl: "https://api.example.com",
+    });
+    const agentsConnect = vi.fn().mockResolvedValue({
+      agent: { user_id: "agent-123" },
+      access_token: "access-tok",
+      refresh_token: "refresh-tok",
+    });
+    const persistConfig = vi.fn();
+
+    await runOpenclawClawlingLogin({
+      cfg,
+      runtime: { log: vi.fn() },
+      readInviteCode: async () => "INV-ABC",
+      apiClientFactory: () => makeApiClient({ agentsConnect }),
+      persistConfig,
+    });
+
+    const savedCfg = persistConfig.mock.calls[0]![0] as OpenClawConfig;
+    const section = (savedCfg.channels as Record<string, Record<string, unknown>>)[CHANNEL_ID]!;
+    expect(section.enabled).toBe(true);
+    expect(section.token).toBe("access-tok");
+    expect(section.userId).toBe("agent-123");
+  });
+
+  it("allows openclaw-clawchat plugin tools after successful login without replacing policy", async () => {
+    const cfg = {
+      ...buildCfg({ baseUrl: "https://api.example.com" }),
+      tools: {
+        profile: "coding",
+        allow: [],
+        deny: ["exec"],
+        alsoAllow: ["browser"],
+      },
+    } as unknown as OpenClawConfig;
+    const agentsConnect = vi.fn().mockResolvedValue({
+      agent: { user_id: "agent-123" },
+      access_token: "access-tok",
+      refresh_token: "refresh-tok",
+    });
+    const persistConfig = vi.fn();
+
+    await runOpenclawClawlingLogin({
+      cfg,
+      runtime: { log: vi.fn() },
+      readInviteCode: async () => "INV-ABC",
+      apiClientFactory: () => makeApiClient({ agentsConnect }),
+      persistConfig,
+    });
+
+    const savedCfg = persistConfig.mock.calls[0]![0] as OpenClawConfig;
+    expect(savedCfg.tools).toMatchObject({
+      profile: "coding",
+      allow: [],
+      deny: ["exec"],
+      alsoAllow: ["browser", "openclaw-clawchat"],
+    });
+  });
+
   it("surfaces agents/connect API errors with the kind and message", async () => {
     const cfg = buildCfg({ baseUrl: "https://api.example.com" });
     const agentsConnect = vi.fn().mockRejectedValue(
@@ -219,7 +322,7 @@ describe("runOpenclawClawlingLogin", () => {
       persistConfig: vi.fn(),
     });
     expect(agentsConnect).toHaveBeenCalledWith({
-      inviteCode: "INV-TRIM",
+      code: "INV-TRIM",
       platform: "openclaw",
       type: "clawbot",
     });
@@ -243,7 +346,7 @@ describe("runOpenclawClawlingLogin (non-interactive via readInviteCode)", () =>
       persistConfig,
     });
     expect(agentsConnect).toHaveBeenCalledWith({
-      inviteCode: "INV-PROGRAMMATIC",
+      code: "INV-PROGRAMMATIC",
       platform: "openclaw",
       type: "clawbot",
     });

package/src/login.runtime.ts

@@ -3,7 +3,11 @@ import { writeConfigFile } from "openclaw/plugin-sdk/config-runtime";
 import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
 import { createOpenclawClawlingApiClient } from "./api-client.ts";
 import { ClawlingApiError } from "./api-types.ts";
-import { CHANNEL_ID, resolveOpenclawClawlingAccount } from "./config.ts";
+import {
+  CHANNEL_ID,
+  mergeOpenclawClawchatToolAllow,
+  resolveOpenclawClawlingAccount,
+} from "./config.ts";
 
 /**
  * Platform tag sent to `/v1/agents/connect`. Identifies the host of this
@@ -120,16 +124,17 @@ export async function runOpenclawClawlingLogin(params: LoginParams): Promise<voi
   const existing = (channels[CHANNEL_ID] ?? {}) as Record<string, unknown>;
   const nextSection: Record<string, unknown> = {
     ...existing,
+    enabled: true,
     token: result.access_token,
     userId: result.agent.user_id,
   };
   if (result.refresh_token) {
     nextSection.refreshToken = result.refresh_token;
   }
-  const nextCfg: OpenClawConfig = {
+  const nextCfg: OpenClawConfig = mergeOpenclawClawchatToolAllow({
     ...cfg,
     channels: { ...channels, [CHANNEL_ID]: nextSection },
-  };
+  });
 
   const tokenPreview = redactToken(result.access_token);
   runtime.log(

package/src/manifest.test.ts

@@ -1,11 +1,15 @@
+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[];
   openclaw: {
-    channel: { id: string };
+    extensions: string[];
+    setupEntry?: string;
+    channel?: { id: string; aliases?: string[]; cliAddOptions?: Array<{ flags: string }> };
     install: { npmSpec: string };
   };
 }
@@ -14,9 +18,107 @@ 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("declares supported channel/command activation hints for plugin loading", () => {
+    expect(pluginManifest.activation).toEqual({
+      onChannels: ["openclaw-clawchat"],
+      onCommands: ["clawchat-login"],
+    });
+    expect(pluginManifest.activation).not.toHaveProperty("onStartup");
+    expect(pluginManifest.commandAliases).toEqual([
+      { name: "clawchat-login", kind: "runtime-slash" },
+    ]);
+  });
+
+  it("does not publish setup migration or setup-runtime channel 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(pkg.openclaw.channel).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("keeps the activation skill on channel login without tool or slash-command dispatch", () => {
+    const skill = fs.readFileSync(new URL("../skills/clawchat-activate/SKILL.md", import.meta.url), "utf8");
+    expect(skill).toMatch(/name:\s*clawchat-activate/);
+    expect(skill).not.toMatch(/clawchat_activate/);
+    expect(skill).not.toMatch(/command-dispatch:\s*tool/);
+    expect(skill).not.toMatch(/command-tool:/);
+    expect(skill).not.toMatch(/command-dispatch:/);
+    expect(skill).not.toMatch(/command-command:/);
+    expect(skill).not.toMatch(/command-arg-mode:/);
+    expect(skill).not.toMatch(/user-invocable:/);
+    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 gateway restart/);
+    expect(skill).not.toMatch(/ask the user to send/i);
+    expect(skill).not.toMatch(/give the exact/i);
+    expect(skill).toMatch(/execute[^\n]+openclaw channels login --channel openclaw-clawchat/i);
+    expect(skill).toMatch(/execute[^\n]+openclaw gateway restart/i);
+  });
+
+  it("documents channel login as the natural-language 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).toMatch(/openclaw channels login --channel openclaw-clawchat/i);
+    expect(docs).toMatch(/openclaw channels login --channel openclaw-clawchat/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/);
+    expect(docs).not.toMatch(/clawchat_activate/);
+    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(docs).not.toMatch(/call the tool with the extracted code/i);
+    expect(docs).not.toMatch(/AGT->>PLG: clawchat_activate/);
+    expect(readme).toMatch(/activation skill[^.]+execute/i);
+    expect(docs).toMatch(/natural-language activation requests[^.]+execute/i);
   });
 });

package/src/outbound.test.ts

@@ -64,7 +64,8 @@ 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",
+      chat_type: "direct",
       body: { fragments: [{ kind: "text", text: "hello" }] },
     });
     expect(client.replyMessage).not.toHaveBeenCalled();
@@ -82,16 +83,17 @@ describe("openclaw-clawchat outbound", () => {
       replyCtx: {
         replyToMessageId: "m-orig",
         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: "user-1",
+      chat_type: "direct",
       replyTo: {
         msgId: "m-orig",
         senderId: "user-2",
-        displayName: "Sender",
+        nickName: "Sender",
         fragments: [{ kind: "text", text: "original" }],
       },
       body: { fragments: [{ kind: "text", text: "reply" }] },
@@ -168,7 +170,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/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";
+}

package/src/reply-dispatcher.test.ts

@@ -185,7 +185,8 @@ describe("openclaw-clawchat reply-dispatcher", () => {
 
     expect(client.sendMessage).toHaveBeenCalledWith(
       expect.objectContaining({
-        to: { id: "chat-1", type: "direct" },
+        chat_id: "chat-1",
+        chat_type: "direct",
         body: { fragments: [{ kind: "text", text: "Error: boom" }] },
       }),
     );
@@ -244,7 +245,8 @@ describe("openclaw-clawchat reply-dispatcher", () => {
 
     expect(client.sendMessage).toHaveBeenCalledWith(
       expect.objectContaining({
-        to: { id: "chat-1", type: "direct" },
+        chat_id: "chat-1",
+        chat_type: "direct",
         body: { fragments: [{ kind: "text", text: "Error: boom" }] },
       }),
     );

package/src/runtime.test.ts

@@ -56,15 +56,19 @@ describe("openclaw-clawchat runtime media ingest", () => {
       capturedCtx = ctx;
       return ctx;
     });
+    const resolveAgentRoute = vi.fn(() => ({
+      agentId: "u",
+      accountId: "default",
+      sessionKey: "s",
+    }));
+    const cfg = {
+      session: { store: "/tmp/sessions.json", dmScope: "main" },
+    } as unknown as OpenClawConfig;
 
     const runtime = {
       channel: {
         routing: {
-          resolveAgentRoute: vi.fn(() => ({
-            agentId: "u",
-            accountId: "default",
-            sessionKey: "s",
-          })),
+          resolveAgentRoute,
         },
         session: {
           resolveStorePath: vi.fn(() => "/tmp/sessions.json"),
@@ -108,7 +112,7 @@ describe("openclaw-clawchat runtime media ingest", () => {
     const abortController = new AbortController();
 
     const startPromise = startOpenclawClawlingGateway({
-      cfg: {} as import("openclaw/plugin-sdk/core").OpenClawConfig,
+      cfg,
       account: {
         accountId: "default",
         name: "openclaw-clawchat",
@@ -203,6 +207,18 @@ describe("openclaw-clawchat runtime media ingest", () => {
     expect(capturedCtx?.From).toBe("openclaw-clawchat:chat-1");
     expect(capturedCtx?.ConversationLabel).toBe("chat-1");
     expect(capturedCtx?.SenderId).toBe("user-1");
+    expect(resolveAgentRoute).toHaveBeenCalledWith(
+      expect.objectContaining({
+        cfg: expect.objectContaining({
+          session: expect.objectContaining({
+            dmScope: "per-account-channel-peer",
+            store: "/tmp/sessions.json",
+          }),
+        }),
+        peer: { kind: "direct", id: "chat-1" },
+      }),
+    );
+    expect(cfg.session?.dmScope).toBe("main");
   });
 
   it("uses group chat_id as the canonical conversation identity", async () => {
@@ -494,7 +510,7 @@ describe("openclaw-clawchat runtime reply dispatch lifecycle", () => {
     expect(dispatchReplyFromConfig).toHaveBeenCalledTimes(1);
     expect(markDispatchIdle).toHaveBeenCalledTimes(1);
     expect(logError).toHaveBeenCalledWith(
-      expect.stringContaining("openclaw-clawchat message handler error:"),
+      expect.stringContaining("openclaw-clawchat dispatch failed msg=m-fail"),
     );
   });
 });