@newbase-clawchat/openclaw-clawchat 2026.4.29 → 2026.5.4

package/dist/src/client.js

@@ -0,0 +1,176 @@
+import { createWSClient, } from "@newbase-clawchat/sdk";
+export function createOpenclawClawlingClient(account, overrides = {}) {
+    // Only forward a finite `maxRetries` to the SDK — the SDK's own default
+    // is already unbounded, so omitting the field keeps that behavior. This
+    // avoids forcing the SDK to special-case `Infinity`.
+    const maxRetries = account.reconnect.maxRetries;
+    const reconnect = {
+        enabled: true,
+        initialDelay: account.reconnect.initialDelay,
+        maxDelay: account.reconnect.maxDelay,
+        jitterRatio: account.reconnect.jitterRatio,
+        ...(Number.isFinite(maxRetries) ? { maxRetries } : {}),
+    };
+    const options = {
+        url: account.websocketUrl,
+        token: account.token,
+        reconnect,
+        heartbeat: {
+            enabled: true,
+            interval: account.heartbeat.interval,
+            timeout: account.heartbeat.timeout,
+        },
+        ack: {
+            timeout: account.ack.timeout,
+            autoResendOnTimeout: account.ack.autoResendOnTimeout,
+        },
+        // Buffer outbound sends during the tiny reconnect window so an inbound
+        // message isn't silently dropped while the socket is flapping.
+        queueWhileReconnecting: true,
+        ...(overrides.transport ? { transport: overrides.transport } : {}),
+        ...(overrides.logger ? { logger: overrides.logger } : {}),
+    };
+    return createWSClient(options);
+}
+function normalizeRouting(params) {
+    if (params.routing)
+        return params.routing;
+    if (params.to?.id) {
+        return { chatId: params.to.id, chatType: params.to.type ?? "direct" };
+    }
+    throw new Error("openclaw-clawchat streaming emit requires routing");
+}
+/**
+ * Emit a raw v2 envelope directly over the transport so we can carry top-level
+ * `chat_id` routing without SDK-injected `to` metadata.
+ */
+function emitEnvelope(client, event, payload, routing) {
+    const inner = client;
+    if (!inner.opts?.transport) {
+        inner.emitRaw?.(event, payload, { to: { id: routing.chatId, type: routing.chatType } });
+        return;
+    }
+    const env = {
+        version: "2",
+        event,
+        trace_id: inner.opts.traceIdFactory(),
+        emitted_at: Date.now(),
+        chat_id: routing.chatId,
+        payload,
+    };
+    inner.opts.transport.send(JSON.stringify(env));
+}
+/**
+ * Emit a minimal `message.created` envelope to open a streaming message.
+ *
+ * Payload is intentionally just `{ message_id }`: the message body, context,
+ * sender, and streaming metadata are not transmitted here — they live on the
+ * envelope (`chat_id`, `chat_type`, optional `sender`) and on the subsequent
+ * `message.add` / `message.done` frames.
+ */
+export function emitStreamCreated(client, params) {
+    const routing = normalizeRouting(params);
+    emitEnvelope(client, "message.created", { message_id: params.messageId }, routing);
+}
+/**
+ * Emit a `message.add` frame with a `fragments` array carrying both the
+ * delta (newly appended text) and the full running text ("from the start
+ * up to now"). Clients rendering the stream can use `delta` for animations
+ * and `text` for the current snapshot.
+ *
+ * Shape: `fragments: [{ kind: "text", text: <cumulative>, delta: <new> }]`
+ */
+export function emitStreamAdd(client, params) {
+    const now = Date.now();
+    const routing = normalizeRouting(params);
+    emitEnvelope(client, "message.add", {
+        message_id: params.messageId,
+        sequence: params.sequence,
+        mutation: { type: "append", target_fragment_index: null },
+        fragments: [
+            { kind: "text", text: params.fullText, delta: params.textDelta },
+        ],
+        streaming: {
+            status: "streaming",
+            sequence: params.sequence,
+            mutation_policy: "append_text_only",
+            started_at: null,
+            completed_at: null,
+        },
+        added_at: now,
+    }, routing);
+}
+/**
+ * Emit a `message.done` frame with the final merged text included as a
+ * single-element `fragments` array so clients can settle the streamed
+ * message on the full text without re-accumulating deltas.
+ */
+export function emitStreamDone(client, params) {
+    const now = Date.now();
+    const routing = normalizeRouting(params);
+    emitEnvelope(client, "message.done", {
+        message_id: params.messageId,
+        fragments: [{ kind: "text", text: params.finalText }],
+        streaming: {
+            status: "done",
+            sequence: params.finalSequence,
+            mutation_policy: "append_text_only",
+            started_at: null,
+            completed_at: now,
+        },
+        completed_at: now,
+    }, routing);
+}
+/**
+ * Emit a `message.reply` envelope that finalizes a streamed reply, carrying
+ * the same `payload.message_id` as the preceding `message.created` /
+ * `message.add` / `message.done` frames.
+ *
+ * The SDK's high-level `client.replyMessage()` disallows `payload.message_id`
+ * on outbound replies (the server normally assigns one via ack); for the
+ * streaming-finalize use case the backend expects the correlated id, so we
+ * bypass the SDK validator and write directly to the transport.
+ */
+export function emitFinalStreamReply(client, params) {
+    const routing = normalizeRouting(params);
+    emitEnvelope(client, "message.reply", {
+        message_id: params.messageId,
+        message_mode: "normal",
+        message: {
+            body: params.body,
+            context: {
+                mentions: params.mentions ?? [],
+                reply: {
+                    reply_to_msg_id: params.replyTo.msgId,
+                    reply_preview: {
+                        id: params.replyTo.previewId,
+                        nick_name: params.replyTo.nickName,
+                        fragments: params.replyTo.fragments,
+                    },
+                },
+            },
+        },
+    }, routing);
+}
+export function emitStreamFailed(client, params) {
+    const now = Date.now();
+    const routing = normalizeRouting(params);
+    const reason = params.reason ?? "unknown";
+    const reasonFragment = params.reason?.trim()
+        ? { fragments: [{ kind: "text", text: params.reason.trim() }] }
+        : {};
+    emitEnvelope(client, "message.failed", {
+        message_id: params.messageId,
+        sequence: params.sequence,
+        reason,
+        ...reasonFragment,
+        streaming: {
+            status: "failed",
+            sequence: params.sequence,
+            mutation_policy: "append_text_only",
+            started_at: null,
+            completed_at: now,
+        },
+        completed_at: now,
+    }, routing);
+}

package/dist/src/commands.js

@@ -0,0 +1,35 @@
+function extractInviteCode(value) {
+    const raw = typeof value === "string" ? value.trim() : "";
+    return raw.match(/\b[A-Z0-9]{6}\b/u)?.[0] ?? "";
+}
+function errorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+export function registerOpenclawClawlingCommands(api) {
+    api.registerCommand({
+        name: "clawchat-login",
+        description: "Activate ClawChat with an invite code, e.g. /clawchat-login 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-login A1B2C3" };
+            }
+            try {
+                const { runOpenclawClawlingLogin } = await import("./login.runtime.js");
+                await runOpenclawClawlingLogin({
+                    cfg: ctx.config,
+                    accountId: ctx.accountId ?? null,
+                    runtime: { log: (message) => api.logger?.info?.(message) },
+                    readInviteCode: async () => code,
+                    mutateConfigFile: api.runtime.config.mutateConfigFile,
+                });
+                return { text: "✅ ClawChat activated successfully." };
+            }
+            catch (err) {
+                return { text: `❌ ${errorMessage(err)}` };
+            }
+        },
+    });
+}

package/dist/src/config.js

@@ -0,0 +1,226 @@
+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
+ * setup` call. Operators can still override either one via config.
+ *
+ */
+export const DEFAULT_BASE_URL = "http://company.newbaselab.com:10086";
+export const DEFAULT_WEBSOCKET_URL = "ws://company.newbaselab.com:10086/ws";
+export const DEFAULT_STREAM = {
+    flushIntervalMs: 250,
+    minChunkChars: 40,
+    maxBufferChars: 2000,
+};
+export const DEFAULT_RECONNECT = {
+    // Snappier first retry on transient drops (vs. 1_000).
+    initialDelay: 500,
+    // Cap exponential backoff at 15s — a background gateway reconnecting
+    // every 30s feels unresponsive; 15s is the common IM chat bar.
+    maxDelay: 15_000,
+    // Standard jitter ratio to avoid thundering herd on server restart.
+    jitterRatio: 0.3,
+    // Never give up — the gateway is a long-lived background process.
+    maxRetries: Number.POSITIVE_INFINITY,
+};
+export const DEFAULT_HEARTBEAT = {
+    // 20s keeps NAT/firewall state warm without wasting bandwidth.
+    interval: 20_000,
+    // Pong must arrive within 10s or we tear down and reconnect.
+    timeout: 10_000,
+};
+export const DEFAULT_ACK = {
+    // 15s tolerates a slow server + one retry without false timeouts.
+    timeout: 15_000,
+    // Keep false: auto-resend on timeout risks duplicate messages; the
+    // reconnect path re-queues via `queueWhileReconnecting` instead.
+    autoResendOnTimeout: false,
+};
+export const openclawClawlingConfigSchema = {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+        enabled: { type: "boolean" },
+        websocketUrl: { type: "string" },
+        baseUrl: { type: "string" },
+        token: { type: "string" },
+        refreshToken: { type: "string" },
+        userId: { type: "string" },
+        replyMode: { type: "string", enum: ["static", "stream"] },
+        groupMode: { type: "string", enum: ["mention", "all"] },
+        forwardThinking: { type: "boolean" },
+        forwardToolCalls: { type: "boolean" },
+        richInteractions: { type: "boolean" },
+        stream: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                flushIntervalMs: { type: "integer", minimum: 10 },
+                minChunkChars: { type: "integer", minimum: 1 },
+                maxBufferChars: { type: "integer", minimum: 1 },
+            },
+        },
+        reconnect: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                initialDelay: { type: "integer", minimum: 100 },
+                maxDelay: { type: "integer", minimum: 100 },
+                jitterRatio: { type: "number", minimum: 0 },
+                maxRetries: { type: "integer", minimum: 0 },
+            },
+        },
+        heartbeat: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                interval: { type: "integer", minimum: 1000 },
+                timeout: { type: "integer", minimum: 1000 },
+            },
+        },
+        ack: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                timeout: { type: "integer", minimum: 100 },
+                autoResendOnTimeout: { type: "boolean" },
+            },
+        },
+    },
+};
+function isOpenclawClawchatToolAllowEntry(entry) {
+    return entry === CHANNEL_ID || entry === "group:plugins";
+}
+function hasOpenclawClawchatToolAllow(cfg) {
+    const currentTools = (cfg.tools ?? {});
+    const currentAlsoAllow = Array.isArray(currentTools.alsoAllow) ? currentTools.alsoAllow : [];
+    const currentAllow = Array.isArray(currentTools.allow) ? currentTools.allow : [];
+    return [...currentAllow, ...currentAlsoAllow].some(isOpenclawClawchatToolAllowEntry);
+}
+function mergeToolPolicyEntryAllow(cfg, entry, isAlreadyCovered) {
+    const currentTools = (cfg.tools ?? {});
+    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],
+            },
+        };
+    }
+    const alreadyAlsoAllowed = currentAlsoAllow.some(isAlreadyCovered);
+    return {
+        ...cfg,
+        tools: {
+            ...currentTools,
+            alsoAllow: alreadyAlsoAllowed ? currentAlsoAllow : [...currentAlsoAllow, entry],
+        },
+    };
+}
+export function mergeOpenclawClawchatToolAllow(cfg) {
+    return mergeToolPolicyEntryAllow(cfg, CHANNEL_ID, isOpenclawClawchatToolAllowEntry);
+}
+function readChannelSection(cfg) {
+    const channels = (cfg.channels ?? {});
+    const channel = channels[CHANNEL_ID];
+    return channel && typeof channel === "object" ? channel : {};
+}
+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";
+}
+function readGroupMode(value) {
+    return value === "all" ? "all" : "mention";
+}
+function readStream(raw) {
+    const s = raw && typeof raw === "object" ? raw : {};
+    return {
+        flushIntervalMs: typeof s.flushIntervalMs === "number" ? s.flushIntervalMs : DEFAULT_STREAM.flushIntervalMs,
+        minChunkChars: typeof s.minChunkChars === "number" ? s.minChunkChars : DEFAULT_STREAM.minChunkChars,
+        maxBufferChars: typeof s.maxBufferChars === "number" ? s.maxBufferChars : DEFAULT_STREAM.maxBufferChars,
+    };
+}
+function readReconnect(raw) {
+    const s = raw && typeof raw === "object" ? raw : {};
+    return {
+        initialDelay: typeof s.initialDelay === "number" ? s.initialDelay : DEFAULT_RECONNECT.initialDelay,
+        maxDelay: typeof s.maxDelay === "number" ? s.maxDelay : DEFAULT_RECONNECT.maxDelay,
+        jitterRatio: typeof s.jitterRatio === "number" ? s.jitterRatio : DEFAULT_RECONNECT.jitterRatio,
+        maxRetries: typeof s.maxRetries === "number" && Number.isFinite(s.maxRetries)
+            ? s.maxRetries
+            : DEFAULT_RECONNECT.maxRetries,
+    };
+}
+function readHeartbeat(raw) {
+    const s = raw && typeof raw === "object" ? raw : {};
+    return {
+        interval: typeof s.interval === "number" ? s.interval : DEFAULT_HEARTBEAT.interval,
+        timeout: typeof s.timeout === "number" ? s.timeout : DEFAULT_HEARTBEAT.timeout,
+    };
+}
+function readAck(raw) {
+    const s = raw && typeof raw === "object" ? raw : {};
+    return {
+        timeout: typeof s.timeout === "number" ? s.timeout : DEFAULT_ACK.timeout,
+        autoResendOnTimeout: typeof s.autoResendOnTimeout === "boolean"
+            ? s.autoResendOnTimeout
+            : DEFAULT_ACK.autoResendOnTimeout,
+    };
+}
+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) ||
+        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);
+    const forwardThinking = typeof channel.forwardThinking === "boolean" ? channel.forwardThinking : true;
+    const forwardToolCalls = typeof channel.forwardToolCalls === "boolean" ? channel.forwardToolCalls : false;
+    const richInteractions = typeof channel.richInteractions === "boolean" ? channel.richInteractions : false;
+    return {
+        accountId: DEFAULT_ACCOUNT_ID,
+        name: CHANNEL_ID,
+        enabled,
+        configured: Boolean(websocketUrl && token && userId),
+        websocketUrl,
+        baseUrl,
+        token,
+        userId,
+        replyMode,
+        groupMode,
+        forwardThinking,
+        forwardToolCalls,
+        richInteractions,
+        allowFrom: [],
+        stream: readStream(channel.stream),
+        reconnect: readReconnect(channel.reconnect),
+        heartbeat: readHeartbeat(channel.heartbeat),
+        ack: readAck(channel.ack),
+    };
+}
+export function listOpenclawClawlingAccountIds() {
+    return [DEFAULT_ACCOUNT_ID];
+}

package/dist/src/inbound.js

@@ -0,0 +1,133 @@
+import { EVENT, } from "@newbase-clawchat/sdk";
+import { extractMediaFragments, fragmentsToText } from "./message-mapper.js";
+import { hasRenderableText, isInboundMessagePayload } from "./protocol.js";
+const DEDUP_MAX = 256;
+const dedupSeen = [];
+const dedupSet = new Set();
+function normalizeSender(sender) {
+    if (!sender || typeof sender !== "object")
+        return null;
+    const s = sender;
+    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() {
+    dedupSeen.length = 0;
+    dedupSet.clear();
+}
+function rememberAndCheck(messageId) {
+    if (dedupSet.has(messageId))
+        return true;
+    dedupSet.add(messageId);
+    dedupSeen.push(messageId);
+    if (dedupSeen.length > DEDUP_MAX) {
+        const evict = dedupSeen.shift();
+        if (evict)
+            dedupSet.delete(evict);
+    }
+    return false;
+}
+/**
+ * Exported for direct unit testing. Group-sender messages currently never
+ * reach this function (filtered in dispatchOpenclawClawlingInbound), but the
+ * `mentions` branch is exercised by tests now so the group-enable change is
+ * a one-line filter removal later.
+ */
+export function detectMention(params) {
+    if (params.senderType === "direct")
+        return true;
+    return params.mentions.includes(params.userId);
+}
+export async function dispatchOpenclawClawlingInbound(params) {
+    const { envelope, account, log } = params;
+    if (!isInboundMessagePayload(envelope.payload)) {
+        log?.info?.(`[${account.accountId}] openclaw-clawchat skip: invalid payload trace=${envelope.trace_id}`);
+        return;
+    }
+    const payload = envelope.payload;
+    const message = payload.message;
+    // v2 envelopes carry sender on the envelope (RoutingSender); the legacy
+    // message.sender shape is accepted as a fallback for older fixtures.
+    const sender = normalizeSender(envelope.sender ?? message.sender);
+    if (!sender) {
+        log?.info?.(`[${account.accountId}] openclaw-clawchat skip: missing sender trace=${envelope.trace_id}`);
+        return;
+    }
+    // `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 legacyTo = envelope.to;
+    const chatType = envelope.chat_type ?? sender.type ?? legacyTo?.type ?? "direct";
+    const isGroup = chatType === "group";
+    if (payload.message_mode !== "normal") {
+        log?.info?.(`[${account.accountId}] openclaw-clawchat skip non-normal mode=${payload.message_mode}`);
+        return;
+    }
+    if (!hasRenderableText(message)) {
+        log?.info?.(`[${account.accountId}] openclaw-clawchat skip empty msg=${payload.message_id}`);
+        return;
+    }
+    if (rememberAndCheck(payload.message_id)) {
+        log?.info?.(`[${account.accountId}] openclaw-clawchat skip duplicate msg=${payload.message_id}`);
+        return;
+    }
+    const rawBody = fragmentsToText(message.body.fragments, {
+        mentionFallbackIds: message.context.mentions,
+    });
+    const mediaItems = extractMediaFragments(message.body.fragments);
+    const wasMentioned = detectMention({
+        mentions: message.context.mentions,
+        senderType: chatType,
+        userId: account.userId,
+    });
+    // Group trigger policy: in "mention" mode we only handle group messages
+    // that @-mention us; "all" listens open and processes every group msg.
+    // Direct chats are unaffected (detectMention returns true).
+    if (isGroup && account.groupMode === "mention" && !wasMentioned) {
+        log?.info?.(`[${account.accountId}] openclaw-clawchat skip group (no mention) msg=${payload.message_id}`);
+        return;
+    }
+    log?.info?.(`[${account.accountId}] openclaw-clawchat inbound event=${envelope.event === EVENT.MESSAGE_REPLY ? "reply" : "send"} msg=${payload.message_id} from=${sender.id} text_len=${rawBody.length} mentioned=${wasMentioned}`);
+    // New protocol: `chat_id` is the routing primary; `to` is deprecated.
+    // Fall back to sender.id if neither is present (defensive).
+    const chatId = envelope.chat_id ??
+        sender.id;
+    const replyCtx = message.context.reply
+        ? {
+            replyToMessageId: message.context.reply.reply_to_msg_id,
+            replyPreviewChatId: chatId,
+            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),
+        }
+        : undefined;
+    await params.ingest({
+        channel: "openclaw-clawchat",
+        accountId: account.accountId,
+        peer: { kind: isGroup ? "group" : "direct", id: chatId },
+        senderId: sender.id,
+        senderNickName: sender.nickName,
+        rawBody,
+        messageId: payload.message_id,
+        traceId: envelope.trace_id,
+        timestamp: envelope.emitted_at,
+        wasMentioned,
+        mediaItems,
+        ...(replyCtx ? { replyCtx } : {}),
+        cfg: params.cfg,
+        runtime: params.runtime,
+        account,
+        envelope,
+    });
+}