@newbase-clawchat/openclaw-clawchat 2026.4.30 → 2026.5.4-1

package/README.md

@@ -10,7 +10,7 @@ OpenClaw channel plugin that connects an agent to ClawChat over the ClawChat Pro
 - Outbound text replies in `static` or `stream` mode, with a consolidated final `message.reply`
 - Typing indicators and filtered forwarding for thinking / tool-call content
 - Media fragments (image / file / audio / video) in either direction
-- Invite-code onboarding via `clawchat_activate` or channel login, plus always-registered `clawchat_*` account/media tools
+- Invite-code onboarding via `clawchat_activate` or `/clawchat-login`, plus always-registered `clawchat_*` account/media tools
 
 ## Install
 
@@ -19,7 +19,7 @@ OpenClaw channel plugin that connects an agent to ClawChat over the ClawChat Pro
 npm i @newbase-clawchat/openclaw-clawchat
 ```
 
-Requires `openclaw >= 2026.4.29` as a peer host.
+Requires `openclaw >= 2026.5.4` as a peer host.
 
 For the OpenClaw plugin install/update flow, see [`INSTALL.md`](./INSTALL.md).
 
@@ -38,15 +38,31 @@ activate ClawChat with invite code A1B2C3
 ```
 
 If the plugin is already loaded by the Gateway, the activation skill calls the
-`clawchat_activate` tool and OpenClaw hot-reloads the updated `channels.*`
-credentials. If the tool is not available yet, use channel login as the CLI
-fallback:
+`clawchat_activate` tool and persists credentials. If you are activating from
+Telegram or another chat platform and the agent does not call the tool, send the
+runtime slash command in that chat:
+
+```text
+/clawchat-login A1B2C3
+```
+
+The slash command is provided by the loaded plugin. It is not a shell command,
+so `openclaw clawchat-login` is expected to fail.
+
+On OpenClaw hosts where the CLI channel catalog includes `openclaw-clawchat`,
+terminal activation can also use:
 
 ```bash
-openclaw channels login --channel openclaw-clawchat
+CLAWCHAT_INVITE_CODE="A1B2C3"
+openclaw channels add --channel openclaw-clawchat --token "$CLAWCHAT_INVITE_CODE"
 openclaw channels status --probe
 ```
 
+OpenClaw 2026.5.5 can load an npm-installed third-party channel while still
+omitting it from the `channels add` CLI catalog. If `channels add` fails with
+`Unknown channel: openclaw-clawchat`, use `clawchat_activate` or
+`/clawchat-login A1B2C3` after a real Gateway restart.
+
 Restart the Gateway after installing/updating the plugin, when config reload is
 disabled, or when the channel probe does not become healthy:
 
@@ -55,17 +71,20 @@ openclaw gateway restart
 ```
 
 If you run the gateway manually instead of as a service and it is not already
-running, start it after login:
+running, start it after activation:
 
 ```bash
 openclaw gateway run
 ```
 
-The invite code is not a token; token fields are written only after login. The
-plugin registers `clawchat_activate` and the six account/media tools at plugin
-load time so they stay visible before activation. Before login, account/media
+The `--token` value above is the ClawChat invite code for OpenClaw's generic
+`channels add` CLI surface on hosts that expose this plugin in the channel
+catalog; persisted token fields are written only after the invite code exchange
+succeeds. The plugin registers `clawchat_activate` and the six account/media tools at plugin
+load time so they stay visible before activation. Before activation, account/media
 tools return a config error instead of disappearing; after activation/login, the
-channel is enabled and the same tools read the hot-reloaded token/userId.
+channel is enabled and the same tools read the persisted token/userId after the
+Gateway restarts.
 
 After activation/login, the channel section is enabled and has credentials:
 

package/dist/index.js

@@ -1,27 +1,18 @@
+import { defineChannelPluginEntry } from "openclaw/plugin-sdk/channel-core";
 import { openclawClawlingPlugin } from "./src/channel.js";
 import { registerOpenclawClawlingCommands } from "./src/commands.js";
+import { openclawClawlingConfigSchema } from "./src/config.js";
 import { setOpenclawClawlingRuntime } from "./src/runtime.js";
 import { registerOpenclawClawlingTools } from "./src/tools.js";
-import { openclawClawlingConfigSchema } from "./src/config.js";
-export default {
+export default defineChannelPluginEntry({
     id: "openclaw-clawchat",
     name: "Clawling Chat",
     description: "Clawling Chat Protocol v2 channel plugin (chat-sdk)",
-    configSchema: openclawClawlingConfigSchema,
-    register(api) {
-        setOpenclawClawlingRuntime(api.runtime);
-        api.registerChannel({ plugin: openclawClawlingPlugin });
+    plugin: openclawClawlingPlugin,
+    configSchema: { schema: openclawClawlingConfigSchema },
+    setRuntime: setOpenclawClawlingRuntime,
+    registerFull(api) {
         registerOpenclawClawlingCommands(api);
         registerOpenclawClawlingTools(api);
-    }
-};
-// export default defineChannelPluginEntry({
-//   id: "openclaw-clawchat",
-//   name: "Clawling Chat",
-//   description: "Clawling Chat Protocol v2 channel plugin (chat-sdk)",
-//   plugin: openclawClawlingPlugin,
-//   setRuntime: setOpenclawClawlingRuntime,
-//   registerFull(api) {
-//     registerOpenclawClawlingTools(api);
-//   },
-// });
+    },
+});

package/dist/setup-entry.js

@@ -0,0 +1,3 @@
+import { defineSetupPluginEntry } from "openclaw/plugin-sdk/channel-core";
+import { openclawClawlingSetupPlugin } from "./src/channel.setup.js";
+export default defineSetupPluginEntry(openclawClawlingSetupPlugin);

package/dist/src/channel.js

@@ -1,145 +1,15 @@
-import { createTopLevelChannelConfigAdapter } from "openclaw/plugin-sdk/channel-config-helpers";
-import { createChatChannelPlugin, } from "openclaw/plugin-sdk/core";
+import { createChatChannelPlugin } from "openclaw/plugin-sdk/core";
 import { createEmptyChannelDirectoryAdapter } from "openclaw/plugin-sdk/directory-runtime";
-import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/setup";
-import { createComputedAccountStatusAdapter, createDefaultChannelRuntimeState, } from "openclaw/plugin-sdk/status-helpers";
-import { CHANNEL_ID, listOpenclawClawlingAccountIds, mergeOpenclawClawchatToolAllow, openclawClawlingConfigSchema, resolveOpenclawClawlingAccount, } from "./config.js";
+import { resolveOpenclawClawlingAccount, } from "./config.js";
 import { openclawClawlingOutbound } from "./outbound.js";
 import { getOpenclawClawlingRuntime, startOpenclawClawlingGateway } from "./runtime.js";
-const configAdapter = createTopLevelChannelConfigAdapter({
-    sectionKey: CHANNEL_ID,
-    resolveAccount: (cfg) => resolveOpenclawClawlingAccount(cfg),
-    listAccountIds: () => listOpenclawClawlingAccountIds(),
-    defaultAccountId: () => DEFAULT_ACCOUNT_ID,
-    deleteMode: "clear-fields",
-    clearBaseFields: [
-        "websocketUrl",
-        "baseUrl",
-        "token",
-        "userId",
-        "replyMode",
-        "forwardThinking",
-        "forwardToolCalls",
-        "richInteractions",
-        "enabled",
-    ],
-    resolveAllowFrom: (account) => account.allowFrom,
-    formatAllowFrom: () => [],
-});
-/**
- * Invite-code setup adapter used by OpenClaw setup surfaces that already have
- * a concrete plugin instance. This plugin does not advertise catalog-driven
- * one-shot setup metadata because current hosts do not discover channels from
- * `plugins.load.paths`.
- *
- * Setup takes exactly ONE input: `code` (an invite code). URL + token +
- * userId come from the login flow which is triggered automatically in
- * `afterAccountConfigWritten`.
- *
- * `applyAccountConfig` itself only marks the section `enabled: true`;
- * credentials are written by `runOpenclawClawlingLogin` via the runtime config
- * mutator after the `/v1/agents/connect` response lands.
- */
-const setupAdapter = {
-    resolveAccountId: () => DEFAULT_ACCOUNT_ID,
-    validateInput: ({ input }) => {
-        if (!input.code?.trim()) {
-            return "ClawChat invite code is required.";
-        }
-        return null;
-    },
-    applyAccountConfig: ({ cfg, }) => {
-        // Base config: just enable the channel. Credentials arrive via
-        // `afterAccountConfigWritten` → `runOpenclawClawlingLogin`.
-        const channels = (cfg.channels ?? {});
-        const current = (channels[CHANNEL_ID] ?? {});
-        return mergeOpenclawClawchatToolAllow({
-            ...cfg,
-            channels: {
-                ...channels,
-                [CHANNEL_ID]: { ...current, enabled: true },
-            },
-        });
-    },
-    afterAccountConfigWritten: async ({ cfg, input, runtime, }) => {
-        const code = input.code?.trim();
-        if (!code)
-            return;
-        // Lazy-import the login runtime to keep @clack/prompts / readline /
-        // config-runtime off the plugin's cold-start path. `readInviteCode`
-        // feeds the fixed code so the stdin prompt is skipped entirely.
-        const { runOpenclawClawlingLogin } = await import("./login.runtime.js");
-        await runOpenclawClawlingLogin({
-            cfg,
-            accountId: null,
-            runtime: { log: (message) => runtime.log(message) },
-            readInviteCode: async () => code,
-            mutateConfigFile: getOpenclawClawlingRuntime().config.mutateConfigFile,
-        });
-    },
-};
+import { openclawClawlingSetupPlugin } from "./channel.setup.js";
 export const openclawClawlingPlugin = createChatChannelPlugin({
     base: {
-        id: CHANNEL_ID,
-        meta: {
-            id: CHANNEL_ID,
-            label: "Clawling Chat",
-            selectionLabel: "Clawling Chat",
-            docsPath: "/channels/openclaw-clawchat",
-            docsLabel: "openclaw-clawchat",
-            blurb: "Clawling Protocol v2 over WebSocket (chat-sdk).",
-            order: 110,
-        },
-        capabilities: {
-            chatTypes: ["direct", "group"],
-            media: true,
-            reactions: false,
-            threads: false,
-            polls: false,
-            blockStreaming: true,
-        },
-        reload: {
-            configPrefixes: [`channels.${CHANNEL_ID}`],
-        },
-        configSchema: {
-            schema: openclawClawlingConfigSchema,
-        },
-        config: {
-            ...configAdapter,
-            isConfigured: (account) => account.configured,
-            describeAccount: (account) => ({
-                accountId: account.accountId,
-                name: account.name,
-                enabled: account.enabled,
-                configured: account.configured,
-            }),
-        },
+        ...openclawClawlingSetupPlugin,
         directory: createEmptyChannelDirectoryAdapter(),
-        setup: setupAdapter,
-        status: createComputedAccountStatusAdapter({
-            defaultRuntime: createDefaultChannelRuntimeState(DEFAULT_ACCOUNT_ID, {
-                connected: false,
-                lastInboundAt: null,
-                lastOutboundAt: null,
-            }),
-            resolveAccountSnapshot: ({ account }) => ({
-                accountId: account.accountId,
-                name: account.name,
-                enabled: account.enabled,
-                configured: account.configured,
-                extra: {
-                    websocketUrl: account.websocketUrl || null,
-                    baseUrl: account.baseUrl || null,
-                    userId: account.userId || null,
-                },
-            }),
-        }),
         auth: {
             login: async ({ cfg, accountId, runtime }) => {
-                // Lazy-load login.runtime: it pulls in @clack/prompts and other
-                // heavy modules that have no business loading on every plugin
-                // boot. Only the rare `openclaw channels login --channel
-                // openclaw-clawchat` invocation pays the import cost.
                 const { runOpenclawClawlingLogin } = await import("./login.runtime.js");
                 await runOpenclawClawlingLogin({
                     cfg,
@@ -152,17 +22,24 @@ export const openclawClawlingPlugin = createChatChannelPlugin({
         gateway: {
             startAccount: async (ctx) => {
                 const account = ctx.account ?? resolveOpenclawClawlingAccount(ctx.cfg);
+                ctx.log?.info?.(`[${account.accountId}] openclaw-clawchat lifecycle startAccount invoked 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}] openclaw-clawchat lifecycle startAccount refused: websocketUrl/token/userId are required`);
                     throw new Error("Clawling Chat websocketUrl/token/userId are required");
                 }
-                return await startOpenclawClawlingGateway({
-                    cfg: ctx.cfg,
-                    account,
-                    abortSignal: ctx.abortSignal,
-                    setStatus: ctx.setStatus,
-                    getStatus: ctx.getStatus,
-                    log: ctx.log,
-                });
+                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}] openclaw-clawchat lifecycle startAccount completed/stopped`);
+                }
             },
         },
         agentPrompt: {

package/dist/src/channel.setup.js

@@ -0,0 +1,133 @@
+import { createTopLevelChannelConfigAdapter } from "openclaw/plugin-sdk/channel-config-helpers";
+import { mutateConfigFile } from "openclaw/plugin-sdk/config-mutation";
+import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/setup";
+import { createComputedAccountStatusAdapter, createDefaultChannelRuntimeState, } from "openclaw/plugin-sdk/status-helpers";
+import { CHANNEL_ID, listOpenclawClawlingAccountIds, mergeOpenclawClawchatToolAllow, openclawClawlingConfigSchema, resolveOpenclawClawlingAccount, } from "./config.js";
+const configAdapter = createTopLevelChannelConfigAdapter({
+    sectionKey: CHANNEL_ID,
+    resolveAccount: (cfg) => resolveOpenclawClawlingAccount(cfg),
+    listAccountIds: () => listOpenclawClawlingAccountIds(),
+    defaultAccountId: () => DEFAULT_ACCOUNT_ID,
+    deleteMode: "clear-fields",
+    clearBaseFields: [
+        "websocketUrl",
+        "baseUrl",
+        "token",
+        "userId",
+        "replyMode",
+        "forwardThinking",
+        "forwardToolCalls",
+        "richInteractions",
+        "enabled",
+    ],
+    resolveAllowFrom: (account) => account.allowFrom,
+    formatAllowFrom: () => [],
+});
+/**
+ * Invite-code setup adapter used by OpenClaw setup surfaces.
+ *
+ * `channels add --token` passes the invite code as setup input. The first
+ * config write only enables the channel; `afterAccountConfigWritten` exchanges
+ * the invite code and persists token/userId through the host runtime mutator.
+ */
+const setupAdapter = {
+    resolveAccountId: () => DEFAULT_ACCOUNT_ID,
+    validateInput: ({ input }) => {
+        const inviteCode = typeof input.code === "string" && input.code.trim()
+            ? input.code.trim()
+            : typeof input.token === "string"
+                ? input.token.trim()
+                : "";
+        if (!inviteCode) {
+            return "ClawChat invite code is required.";
+        }
+        return null;
+    },
+    applyAccountConfig: ({ cfg }) => {
+        const channels = (cfg.channels ?? {});
+        const current = (channels[CHANNEL_ID] ?? {});
+        return mergeOpenclawClawchatToolAllow({
+            ...cfg,
+            channels: {
+                ...channels,
+                [CHANNEL_ID]: { ...current, enabled: true },
+            },
+        });
+    },
+    afterAccountConfigWritten: async ({ cfg, input, runtime }) => {
+        runtime.log("[default] openclaw-clawchat setup afterAccountConfigWritten invoked");
+        const code = typeof input.code === "string" && input.code.trim()
+            ? input.code.trim()
+            : typeof input.token === "string"
+                ? input.token.trim()
+                : "";
+        if (!code) {
+            runtime.log("[default] openclaw-clawchat setup afterAccountConfigWritten skipped: empty invite code");
+            return;
+        }
+        const { runOpenclawClawlingLogin } = await import("./login.runtime.js");
+        await runOpenclawClawlingLogin({
+            cfg,
+            accountId: null,
+            runtime: { log: (message) => runtime.log(message) },
+            readInviteCode: async () => code,
+            mutateConfigFile: mutateConfigFile,
+        });
+        runtime.log("[default] openclaw-clawchat setup afterAccountConfigWritten completed");
+    },
+};
+export const openclawClawlingSetupPlugin = {
+    id: CHANNEL_ID,
+    meta: {
+        id: CHANNEL_ID,
+        label: "Clawling Chat",
+        selectionLabel: "Clawling Chat",
+        docsPath: "/channels/openclaw-clawchat",
+        docsLabel: "openclaw-clawchat",
+        blurb: "Clawling Protocol v2 over WebSocket (chat-sdk).",
+        order: 110,
+    },
+    capabilities: {
+        chatTypes: ["direct", "group"],
+        media: true,
+        reactions: false,
+        threads: false,
+        polls: false,
+        blockStreaming: true,
+    },
+    reload: {
+        configPrefixes: [`channels.${CHANNEL_ID}`],
+    },
+    configSchema: {
+        schema: openclawClawlingConfigSchema,
+    },
+    config: {
+        ...configAdapter,
+        isConfigured: (account) => account.configured,
+        describeAccount: (account) => ({
+            accountId: account.accountId,
+            name: account.name,
+            enabled: account.enabled,
+            configured: account.configured,
+        }),
+    },
+    setup: setupAdapter,
+    status: createComputedAccountStatusAdapter({
+        defaultRuntime: createDefaultChannelRuntimeState(DEFAULT_ACCOUNT_ID, {
+            connected: false,
+            lastInboundAt: null,
+            lastOutboundAt: null,
+        }),
+        resolveAccountSnapshot: ({ account }) => ({
+            accountId: account.accountId,
+            name: account.name,
+            enabled: account.enabled,
+            configured: account.configured,
+            extra: {
+                websocketUrl: account.websocketUrl || null,
+                baseUrl: account.baseUrl || null,
+                userId: account.userId || null,
+            },
+        }),
+    }),
+};

package/dist/src/config.js

@@ -1,5 +1,10 @@
 import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/setup";
 export const CHANNEL_ID = "openclaw-clawchat";
+export const CLAWCHAT_TOKEN_ENV = "CLAWCHAT_TOKEN";
+export const CLAWCHAT_USER_ID_ENV = "CLAWCHAT_USER_ID";
+export const CLAWCHAT_REFRESH_TOKEN_ENV = "CLAWCHAT_REFRESH_TOKEN";
+export const CLAWCHAT_BASE_URL_ENV = "CLAWCHAT_BASE_URL";
+export const CLAWCHAT_WEBSOCKET_URL_ENV = "CLAWCHAT_WEBSOCKET_URL";
 /**
  * Built-in defaults for the Clawling Chat endpoints so `openclaw channel
  * login` works out of the box without requiring a prior `openclaw channel
@@ -134,6 +139,9 @@ function readChannelSection(cfg) {
 function readOptionalString(value) {
     return typeof value === "string" ? value.trim() : "";
 }
+function readEnvString(env, key) {
+    return readOptionalString(env[key]);
+}
 function readReplyMode(value) {
     return value === "stream" ? "stream" : "static";
 }
@@ -175,13 +183,17 @@ function readAck(raw) {
             : DEFAULT_ACK.autoResendOnTimeout,
     };
 }
-export function resolveOpenclawClawlingAccount(cfg) {
+export function resolveOpenclawClawlingAccount(cfg, env = process.env) {
     const channel = readChannelSection(cfg);
     // Apply built-in defaults so login/gateway work without prior setup.
-    const websocketUrl = readOptionalString(channel.websocketUrl) || DEFAULT_WEBSOCKET_URL;
-    const baseUrl = readOptionalString(channel.baseUrl) || DEFAULT_BASE_URL;
-    const token = readOptionalString(channel.token);
-    const userId = readOptionalString(channel.userId);
+    const websocketUrl = readOptionalString(channel.websocketUrl) ||
+        readEnvString(env, CLAWCHAT_WEBSOCKET_URL_ENV) ||
+        DEFAULT_WEBSOCKET_URL;
+    const baseUrl = readOptionalString(channel.baseUrl) ||
+        readEnvString(env, CLAWCHAT_BASE_URL_ENV) ||
+        DEFAULT_BASE_URL;
+    const token = readOptionalString(channel.token) || readEnvString(env, CLAWCHAT_TOKEN_ENV);
+    const userId = readOptionalString(channel.userId) || readEnvString(env, CLAWCHAT_USER_ID_ENV);
     const enabled = typeof channel.enabled === "boolean" ? channel.enabled : true;
     const replyMode = readReplyMode(channel.replyMode);
     const groupMode = readGroupMode(channel.groupMode);

package/dist/src/login.runtime.js

@@ -54,22 +54,31 @@ function buildLoginConfig(cfg, result) {
 }
 async function persistLoginConfig(params, result) {
     if (params.mutateConfigFile) {
+        params.runtime.log(`Persisting ClawChat credentials for userId=${result.agent.user_id} with Gateway restart intent.`);
         await params.mutateConfigFile({
-            afterWrite: { mode: "auto" },
+            afterWrite: {
+                mode: "restart",
+                reason: "openclaw-clawchat credentials changed",
+            },
             mutate(draft) {
                 Object.assign(draft, buildLoginConfig(draft, result));
             },
         });
+        params.runtime.log(`ClawChat credentials persisted for userId=${result.agent.user_id}.`);
         return;
     }
     if (params.persistConfig) {
+        params.runtime.log(`Persisting ClawChat credentials for userId=${result.agent.user_id}.`);
         await params.persistConfig(buildLoginConfig(params.cfg, result));
+        params.runtime.log(`ClawChat credentials persisted for userId=${result.agent.user_id}.`);
         return;
     }
     throw new Error("openclaw-clawchat: mutateConfigFile is required to persist login credentials");
 }
 /**
- * Run the `openclaw channels login --channel openclaw-clawchat` flow:
+ * Run the invite-code credential exchange used by `clawchat_activate`,
+ * `openclaw channels add --channel openclaw-clawchat --token <invite-code>`,
+ * and `openclaw channels login --channel openclaw-clawchat`:
  *   1. Read the existing channel section; require `baseUrl` to be set so we
  *      know which server to hit.
  *   2. Prompt the user for an invite code on stdin.

package/dist/src/runtime.js

@@ -76,9 +76,11 @@ export async function startOpenclawClawlingGateway(params) {
     // Obtain PluginRuntime from the stored runtime set via setOpenclawClawlingRuntime.
     const runtime = getOpenclawClawlingRuntime();
     const accountId = account.accountId;
+    log?.info?.(`[${accountId}] openclaw-clawchat runtime start entered configured=${account.configured} enabled=${account.enabled} hasToken=${Boolean(account.token)} hasUserId=${Boolean(account.userId)} websocketUrl=${account.websocketUrl || "(empty)"}`);
     const client = createOpenclawClawlingClient(account, {
         ...(params.transport ? { transport: params.transport } : {}),
     });
+    log?.info?.(`[${accountId}] openclaw-clawchat runtime client created`);
     client.on("state", ({ from, to }) => {
         log?.info?.(`[${accountId}] openclaw-clawchat state ${from} -> ${to}`);
         const next = { ...getStatus(), ...mapClawlingStateToStatus(to) };
@@ -250,7 +252,9 @@ export async function startOpenclawClawlingGateway(params) {
     // return without throwing (which would make the gateway supervisor
     // restart us immediately in a tight loop).
     try {
+        log?.info?.(`[${accountId}] openclaw-clawchat runtime calling client.connect()`);
         await client.connect();
+        log?.info?.(`[${accountId}] openclaw-clawchat runtime client.connect() resolved`);
     }
     catch (err) {
         const classified = classifyClawlingClientError(err);
@@ -265,6 +269,7 @@ export async function startOpenclawClawlingGateway(params) {
         return;
     }
     activeClients.set(accountId, client);
+    log?.info?.(`[${accountId}] openclaw-clawchat runtime active client registered`);
     setStatus({
         ...getStatus(),
         connected: true,
@@ -273,6 +278,7 @@ export async function startOpenclawClawlingGateway(params) {
     });
     log?.info?.(`[${accountId}] openclaw-clawchat connected`);
     await waitUntilAbort(abortSignal, async () => {
+        log?.info?.(`[${accountId}] openclaw-clawchat runtime abort received; closing client`);
         activeClients.delete(accountId);
         client.close();
         setStatus({

package/dist/src/tools.js

@@ -118,8 +118,8 @@ export function registerOpenclawClawlingTools(api) {
     function buildClient() {
         const acct = resolveCurrent();
         // `baseUrl` always resolves via the built-in default in config.ts, so we
-        // only need to gate on `token` here (which is populated by `openclaw
-        // channel login`).
+        // only need to gate on `token` here (which is populated by ClawChat
+        // activation/login).
         if (!acct.token) {
             return { ok: false, error: configError("openclaw-clawchat: token is required") };
         }

package/index.ts

@@ -1,31 +1,19 @@
-// import { defineChannelPluginEntry } from "openclaw/plugin-sdk/core";
-import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import { defineChannelPluginEntry } from "openclaw/plugin-sdk/channel-core";
 import { openclawClawlingPlugin } from "./src/channel.ts";
 import { registerOpenclawClawlingCommands } from "./src/commands.ts";
+import { openclawClawlingConfigSchema } from "./src/config.ts";
 import { setOpenclawClawlingRuntime } from "./src/runtime.ts";
 import { registerOpenclawClawlingTools } from "./src/tools.ts";
-import { openclawClawlingConfigSchema } from "./src/config.ts";
 
-export default {
+export default defineChannelPluginEntry({
   id: "openclaw-clawchat",
   name: "Clawling Chat",
   description: "Clawling Chat Protocol v2 channel plugin (chat-sdk)",
-  configSchema: openclawClawlingConfigSchema,
-  register(api: OpenClawPluginApi) {
-    setOpenclawClawlingRuntime(api.runtime);
-    api.registerChannel({ plugin: openclawClawlingPlugin });
+  plugin: openclawClawlingPlugin,
+  configSchema: { schema: openclawClawlingConfigSchema },
+  setRuntime: setOpenclawClawlingRuntime,
+  registerFull(api) {
     registerOpenclawClawlingCommands(api);
     registerOpenclawClawlingTools(api);
-  }
-}
-
-// export default defineChannelPluginEntry({
-//   id: "openclaw-clawchat",
-//   name: "Clawling Chat",
-//   description: "Clawling Chat Protocol v2 channel plugin (chat-sdk)",
-//   plugin: openclawClawlingPlugin,
-//   setRuntime: setOpenclawClawlingRuntime,
-//   registerFull(api) {
-//     registerOpenclawClawlingTools(api);
-//   },
-// });
+  },
+});

package/openclaw.plugin.json

@@ -1,5 +1,6 @@
 {
   "id": "openclaw-clawchat",
+  "kind": "channel",
   "channels": ["openclaw-clawchat"],
   "skills": ["./skills"],
   "activation": {
@@ -7,6 +8,15 @@
     "onChannels": ["openclaw-clawchat"],
     "onCommands": ["clawchat-login"]
   },
+  "channelEnvVars": {
+    "openclaw-clawchat": [
+      "CLAWCHAT_TOKEN",
+      "CLAWCHAT_USER_ID",
+      "CLAWCHAT_REFRESH_TOKEN",
+      "CLAWCHAT_BASE_URL",
+      "CLAWCHAT_WEBSOCKET_URL"
+    ]
+  },
   "commandAliases": [
     { "name": "clawchat-login", "kind": "runtime-slash" }
   ],