@newbase-clawchat/openclaw-clawchat 2026.5.12-2 → 2026.5.12-21

package/src/manifest.test.ts

@@ -2,6 +2,11 @@ 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" };
+import {
+  CLAWCHAT_AGENT_ID_ENV,
+  CLAWCHAT_OWNER_USER_ID_ENV,
+  openclawClawlingConfigSchema,
+} from "./config.ts";
 
 interface PackageJsonWithOpenclaw {
   name: string;
@@ -37,7 +42,7 @@ 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(pluginManifest).not.toHaveProperty("skills");
+    expect(pluginManifest.skills).toEqual(["./skills"]);
     expect(pluginManifest.channelConfigs?.["openclaw-clawchat"]?.label).toBe(
       "Clawling Chat",
     );
@@ -65,8 +70,8 @@ describe("openclaw-clawchat manifest", () => {
     expect(pkg.openclaw.runtimeSetupEntry).toBe("./dist/setup-entry.js");
     expect(pkg.files).toContain("dist");
     expect(pkg.files).toContain("setup-entry.ts");
+    expect(pkg.files).toContain("skills");
     expect(pkg.files).toContain("INSTALL.md");
-    expect(pkg.files).not.toContain("skills");
     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);
@@ -85,7 +90,7 @@ describe("openclaw-clawchat manifest", () => {
       selectionLabel: "Clawling Chat",
       docsPath: "/channels/openclaw-clawchat",
       docsLabel: "openclaw-clawchat",
-      blurb: "Clawling Protocol v2 over WebSocket (chat-sdk).",
+      blurb: "ClawChat Protocol v2 over WebSocket.",
       order: 110,
       cliAddOptions: [
         {
@@ -100,10 +105,10 @@ describe("openclaw-clawchat manifest", () => {
     expect(pluginManifest.activation).toEqual({
       onStartup: true,
       onChannels: ["openclaw-clawchat"],
-      onCommands: ["clawchat-login"],
+      onCommands: ["clawchat-activate"],
     });
     expect(pluginManifest.commandAliases).toEqual([
-      { name: "clawchat-login", kind: "runtime-slash" },
+      { name: "clawchat-activate", kind: "runtime-slash" },
     ]);
   });
 
@@ -111,7 +116,9 @@ describe("openclaw-clawchat manifest", () => {
     expect(pluginManifest.channelEnvVars).toEqual({
       "openclaw-clawchat": [
         "CLAWCHAT_TOKEN",
+        CLAWCHAT_AGENT_ID_ENV,
         "CLAWCHAT_USER_ID",
+        CLAWCHAT_OWNER_USER_ID_ENV,
         "CLAWCHAT_REFRESH_TOKEN",
         "CLAWCHAT_BASE_URL",
         "CLAWCHAT_WEBSOCKET_URL",
@@ -119,6 +126,13 @@ describe("openclaw-clawchat manifest", () => {
     });
   });
 
+  it("keeps host manifest channel schemas aligned with runtime config schema", () => {
+    expect(pluginManifest.configSchema).toEqual(openclawClawlingConfigSchema);
+    expect(pluginManifest.channelConfigs?.["openclaw-clawchat"]?.schema).toEqual(
+      openclawClawlingConfigSchema,
+    );
+  });
+
   it("keeps setup entry on a lightweight setup surface", () => {
     const pkg = packageJson as PackageJsonWithOpenclaw;
     expect(pkg.files).not.toContain("setup-api.ts");
@@ -131,7 +145,7 @@ describe("openclaw-clawchat manifest", () => {
     expect(setupEntry).not.toMatch(/\.\/src\/outbound(?:\.ts)?/);
   });
 
-  it("uses the SDK channel entry helper for registration-mode splitting", () => {
+  it("uses the OpenClaw channel entry helper for registration-mode splitting", () => {
     const entry = fs.readFileSync(new URL("../index.ts", import.meta.url), "utf8");
     expect(entry).toMatch(/defineChannelPluginEntry/);
     expect(entry).toMatch(/registerFull/);
@@ -145,19 +159,55 @@ describe("openclaw-clawchat manifest", () => {
     const docs = fs.readFileSync(new URL("../docs/openclaw-clawchat.md", import.meta.url), "utf8");
     expect(readme).not.toMatch(/clawchat_activate/i);
     expect(docs).not.toMatch(/clawchat_activate/i);
-    expect(readme).toMatch(/\/clawchat-login A1B2C3/i);
-    expect(docs).toMatch(/\/clawchat-login A1B2C3/i);
+    expect(readme).toMatch(/\/clawchat-activate A1B2C3/i);
+    expect(docs).toMatch(/\/clawchat-activate A1B2C3/i);
     expect(readme).toMatch(/OpenClaw 2026\.5\.5/i);
     expect(docs).toMatch(/OpenClaw 2026\.5\.5/i);
     expect(readme).toMatch(/Unknown channel: openclaw-clawchat/i);
     expect(docs).toMatch(/Unknown channel: openclaw-clawchat/i);
   });
 
-  it("does not publish repository-provided skills", () => {
+  it("publishes the repository-provided ClawChat skill", () => {
     const pkg = packageJson as PackageJsonWithOpenclaw;
-    expect(pluginManifest).not.toHaveProperty("skills");
-    expect(pkg.files).not.toContain("skills");
-    expect(fs.existsSync(new URL("../skills/clawchat/SKILL.md", import.meta.url))).toBe(false);
+    expect(pluginManifest.skills).toEqual(["./skills"]);
+    expect(pkg.files).toContain("skills");
+
+    const skillUrl = new URL("../skills/clawchat/SKILL.md", import.meta.url);
+    expect(fs.existsSync(skillUrl)).toBe(true);
+    const skill = fs.readFileSync(skillUrl, "utf8");
+    expect(skill).toMatch(
+      /^---\nname: clawchat\ndescription: Use when a request involves ClawChat profile, friends, user search, moments\/dynamics, comments, reactions, avatar, media, or read-only conversation lookup\.\n---/m,
+    );
+    expect(skill).toMatch(
+      /This skill guides agent behavior for ClawChat-aware tasks\. Use the registered ClawChat tools for profile, friends, user search, moments, comments, reactions, avatar, media, and read-only conversation list\/get operations instead of direct HTTP calls, shell scripts, or handwritten clients\./,
+    );
+    expect(skill).toMatch(/clawchat_get_account_profile/);
+    expect(skill).toMatch(/clawchat_search_users/);
+    expect(skill).toMatch(/clawchat_upload_avatar_image/);
+    expect(skill).toMatch(/clawchat_upload_media_file/);
+    expect(skill).toMatch(/clawchat_list_conversations/);
+    expect(skill).toMatch(/clawchat_get_conversation/);
+    expect(skill).toMatch(/conversations?\/groups?.*read-only/i);
+    expect(skill).not.toMatch(
+      /conversations?\/groups?.*(?:create|update|leave|dissolve|add members|remove members|administer)/i,
+    );
+    expect(skill).not.toMatch(/clawchat_create_group_conversation/);
+    expect(skill).not.toMatch(/clawchat_update_conversation/);
+    expect(skill).not.toMatch(/clawchat_leave_conversation/);
+    expect(skill).not.toMatch(/clawchat_dissolve_conversation/);
+    expect(skill).not.toMatch(/clawchat_add_conversation_member/);
+    expect(skill).not.toMatch(/clawchat_remove_conversation_member/);
+    expect(skill).not.toMatch(/clawchat_list_conversation_users/);
+    expect(skill).toMatch(/## Profile And Identity Sync/);
+    expect(skill).toMatch(/When updating the OpenClaw agent identity file/);
+    expect(skill).toMatch(/display name \/ nickname \| `clawchat_update_account_profile` with `nickname`/);
+    expect(skill).toMatch(/bio \/ self-introduction \| `clawchat_update_account_profile` with `bio`/);
+    expect(skill).toMatch(/local avatar image \| `clawchat_upload_avatar_image`, then `clawchat_update_account_profile` with `avatar_url`/);
+    expect(skill).toMatch(/Do not invent invite codes, tokens, moment ids, comment ids, user ids, emoji reactions, image URLs, or file paths/);
+    expect(skill).not.toMatch(/hermes/i);
+    expect(skill).not.toMatch(/target hermes/i);
+    expect(skill).not.toMatch(/choosing among registered clawchat_\*/);
+    expect(skill).not.toMatch(/\b(?:whe|regis|plu)\s*$/m);
   });
 
   it("declares ownership of registered ClawChat agent tools", () => {
@@ -166,6 +216,8 @@ describe("openclaw-clawchat manifest", () => {
       "clawchat_get_user_profile",
       "clawchat_list_account_friends",
       "clawchat_search_users",
+      "clawchat_list_conversations",
+      "clawchat_get_conversation",
       "clawchat_list_moments",
       "clawchat_create_moment",
       "clawchat_delete_moment",
@@ -176,7 +228,27 @@ describe("openclaw-clawchat manifest", () => {
       "clawchat_update_account_profile",
       "clawchat_upload_avatar_image",
       "clawchat_upload_media_file",
+      "clawchat_memory_read",
+      "clawchat_memory_write",
+      "clawchat_memory_edit",
+      "clawchat_metadata_sync",
+      "clawchat_metadata_update",
+    ]);
+  });
+
+  it("declares exactly the five file-backed memory and metadata tools without old-prefix aliases", () => {
+    const memoryTools = (pluginManifest.contracts?.tools ?? []).filter((name) =>
+      /memory|metadata/.test(name),
+    );
+    expect(memoryTools).toEqual([
+      "clawchat_memory_read",
+      "clawchat_memory_write",
+      "clawchat_memory_edit",
+      "clawchat_metadata_sync",
+      "clawchat_metadata_update",
     ]);
+    expect(pluginManifest.contracts?.tools ?? []).not.toContain("cc_memory_read");
+    expect(pluginManifest.contracts?.tools ?? []).not.toContain("cc_metadata_sync");
   });
 
   it("keeps the optional OpenClaw source checkout local-only", () => {
@@ -214,8 +286,8 @@ describe("openclaw-clawchat manifest", () => {
     expect(docs).toMatch(/Current activation paths/i);
     expect(readme).not.toMatch(/clawchat_activate/i);
     expect(docs).not.toMatch(/clawchat_activate/i);
-    expect(readme).toMatch(/\/clawchat-login A1B2C3/i);
-    expect(docs).toMatch(/\/clawchat-login A1B2C3/i);
+    expect(readme).toMatch(/\/clawchat-activate A1B2C3/i);
+    expect(docs).toMatch(/\/clawchat-activate A1B2C3/i);
     expect(readme).toMatch(/openclaw channels add --channel openclaw-clawchat --token "\$CLAWCHAT_INVITE_CODE"/i);
     expect(docs).toMatch(/openclaw channels add --channel openclaw-clawchat --token "\$CLAWCHAT_INVITE_CODE"/i);
     expect(readme).toMatch(/openclaw channels login --channel openclaw-clawchat/i);

package/src/media-runtime.test.ts

@@ -85,7 +85,9 @@ describe("uploadOutboundMedia", () => {
   function buildApiClient() {
     return {
       uploadMedia: vi.fn().mockResolvedValue({
+        kind: "image",
         url: "https://cdn/uploaded.png",
+        name: "uploaded.png",
         size: 12,
         mime: "image/png",
       }),
@@ -118,14 +120,41 @@ describe("uploadOutboundMedia", () => {
         url: "https://cdn/uploaded.png",
         mime: "image/png",
         size: 12,
-        name: "img.png",
+        name: "uploaded.png",
       },
       {
         kind: "image",
         url: "https://cdn/uploaded.png",
         mime: "image/png",
         size: 12,
-        name: "img.png",
+        name: "uploaded.png",
+      },
+    ]);
+  });
+
+  it("uses server-returned kind and name for uploaded media fragments", async () => {
+    const { runtime } = buildRuntime();
+    const apiClient = buildApiClient();
+    (apiClient.uploadMedia as ReturnType<typeof vi.fn>).mockResolvedValueOnce({
+      kind: "file",
+      url: "https://cdn/server.bin",
+      name: "server.bin",
+      size: 12,
+      mime: "image/png",
+    });
+
+    const fragments = await uploadOutboundMedia(["https://cdn/in.png"], {
+      apiClient,
+      runtime,
+    });
+
+    expect(fragments).toEqual([
+      {
+        kind: "file",
+        url: "https://cdn/server.bin",
+        mime: "image/png",
+        size: 12,
+        name: "server.bin",
       },
     ]);
   });

package/src/media-runtime.ts

@@ -7,15 +7,12 @@ import {
 import type { OpenclawClawlingApiClient } from "./api-client.ts";
 
 /**
- * Local structural superset of the SDK's media fragment narrow types.
+ * Local structural superset of the protocol media fragment narrow types.
  *
- * `@clawling/chat-sdk@^0.2.0` exports each narrow type
- * (`ImageFragment` / `FileFragment` / `AudioFragment` / `VideoFragment`)
- * with a literal `kind` that distinguishes them. Building the wide
- * shape locally avoids per-kind switch statements when constructing
- * outbound fragments; structural compatibility lets a single object
- * satisfy whichever narrow type matches its runtime `kind`. We cast
- * to `Fragment[]` only at the SDK boundary (outbound.ts).
+ * Each media fragment has a literal `kind` that distinguishes it. Building the
+ * wide shape locally avoids per-kind switch statements when constructing
+ * outbound fragments; structural compatibility lets a single object satisfy
+ * whichever narrow type matches its runtime `kind`.
  */
 export interface MediaItem {
   kind: "image" | "file" | "audio" | "video";
@@ -138,12 +135,12 @@ export async function uploadOutboundMedia(
         mime: loaded.contentType,
       });
       const fragment: ClawlingMediaFragment = {
-        kind: inferMediaKindFromMime(uploaded.mime),
+        kind: uploaded.kind,
         url: uploaded.url,
+        name: uploaded.name,
         mime: uploaded.mime,
         size: uploaded.size,
       };
-      if (loaded.fileName) fragment.name = loaded.fileName;
       out.push(fragment);
     } catch (err) {
       ctx.log?.error?.(

package/src/message-mapper.test.ts

@@ -1,4 +1,4 @@
-import type { Fragment } from "@newbase-clawchat/sdk";
+import type { Fragment } from "./protocol-types.ts";
 import { describe, expect, it } from "vitest";
 import { extractMediaFragments, fragmentsToText, textToFragments } from "./message-mapper.ts";
 
@@ -119,7 +119,7 @@ describe("openclaw-clawchat message-mapper", () => {
   });
 
   it("extractMediaFragments skips media fragments without url", () => {
-    // Note: SDK 0.2.0 requires `url` on image fragments — using a partial
+    // Note: the protocol type requires `url` on image fragments — using a partial
     // object here exercises the runtime guard. Casting here is intentional
     // (we want to verify defensive handling of malformed input).
     const fragments: Fragment[] = [

package/src/message-mapper.ts

@@ -1,4 +1,4 @@
-import type { Fragment } from "@newbase-clawchat/sdk";
+import type { Fragment } from "./protocol-types.ts";
 import type { MediaItem } from "./media-runtime.ts";
 
 interface FlattenOptions {
@@ -61,7 +61,7 @@ export function textToFragments(text: string): Fragment[] {
 /**
  * Extract media fragments from a body (image/file/audio/video). Skips
  * entries missing `url`. Preserves all optional metadata fields the
- * SDK passes through (mime/size/width/height/duration/name).
+ * protocol carries through (mime/size/width/height/duration/name).
  */
 export function extractMediaFragments(fragments: Fragment[]): MediaItem[] {
   const out: MediaItem[] = [];

package/src/mock-transport.test.ts

@@ -0,0 +1,35 @@
+import { describe, expect, it, vi } from "vitest";
+import { MockTransport } from "./mock-transport.ts";
+
+describe("MockTransport", () => {
+  it("opens, records sent frames, emits inbound frames, and closes", async () => {
+    const transport = new MockTransport();
+    const onOpen = vi.fn();
+    const onMessage = vi.fn();
+    const onClose = vi.fn();
+    const onError = vi.fn();
+
+    await transport.connect("ws://test", { onOpen, onMessage, onClose, onError });
+    expect(transport.state).toBe("open");
+    expect(onOpen).toHaveBeenCalledTimes(1);
+
+    transport.send("frame-1");
+    expect(transport.sent).toEqual(["frame-1"]);
+
+    transport.emitInbound("frame-2");
+    expect(onMessage).toHaveBeenCalledWith("frame-2");
+
+    const buffer = Buffer.from("frame-3");
+    transport.emitInbound(buffer);
+    expect(onMessage).toHaveBeenCalledWith(buffer);
+
+    const err = new Error("boom");
+    transport.emitError(err);
+    expect(onError).toHaveBeenCalledWith(err);
+
+    transport.close(1000, "done");
+    expect(transport.state).toBe("closed");
+    expect(onClose).toHaveBeenCalledWith(1000, "done");
+    expect(onError).toHaveBeenCalledTimes(1);
+  });
+});

package/src/mock-transport.ts

@@ -0,0 +1,38 @@
+import type { Transport, TransportEvents, TransportState } from "./protocol-types.ts";
+
+export class MockTransport implements Transport {
+  private handlers?: TransportEvents;
+  private currentState: TransportState = "closed";
+  readonly sent: string[] = [];
+
+  get state(): TransportState {
+    return this.currentState;
+  }
+
+  async connect(_url: string, handlers: TransportEvents): Promise<void> {
+    this.handlers = handlers;
+    this.currentState = "open";
+    handlers.onOpen();
+  }
+
+  send(data: string): void {
+    if (this.currentState !== "open") {
+      throw new Error("transport is not open");
+    }
+    this.sent.push(data);
+  }
+
+  close(code = 1000, reason = "client close"): void {
+    if (this.currentState === "closed") return;
+    this.currentState = "closed";
+    this.handlers?.onClose(code, reason);
+  }
+
+  emitInbound(data: string | Buffer): void {
+    this.handlers?.onMessage(data);
+  }
+
+  emitError(err: Error): void {
+    this.handlers?.onError(err);
+  }
+}