@clawling/clawchat-plugin-openclaw 2026.5.12-28

package/dist/src/buffered-stream.js

@@ -0,0 +1,177 @@
+import { emitStreamAdd, emitStreamCreated, emitStreamDone, emitStreamFailed, } from "./client.js";
+/**
+ * Merge two views of the same progressively-revealed text.
+ *
+ * The agent runner may give us either:
+ *   - full snapshots   ("Hel", "Hello", "Hello, world") where each item is
+ *     a superset of the previous; or
+ *   - overlapping slices ("hello ", "world hello ") that don't share a
+ *     prefix but share an overlap at the join.
+ *
+ * This helper returns a longest-sensible combined string. Ported from
+ * `clawling-channel/src/reply-dispatcher.ts`.
+ */
+export function mergeStreamingText(previousText, nextText) {
+    const currentSnapshot = typeof previousText === "string" ? previousText : "";
+    const incomingText = typeof nextText === "string" ? nextText : "";
+    if (!incomingText)
+        return currentSnapshot;
+    if (!currentSnapshot || incomingText === currentSnapshot)
+        return incomingText;
+    if (incomingText.startsWith(currentSnapshot))
+        return incomingText;
+    if (currentSnapshot.startsWith(incomingText))
+        return currentSnapshot;
+    if (incomingText.includes(currentSnapshot))
+        return incomingText;
+    if (currentSnapshot.includes(incomingText))
+        return currentSnapshot;
+    const maxOverlap = Math.min(currentSnapshot.length, incomingText.length);
+    for (let overlap = maxOverlap; overlap > 0; overlap -= 1) {
+        if (currentSnapshot.slice(-overlap) === incomingText.slice(0, overlap)) {
+            return `${currentSnapshot}${incomingText.slice(overlap)}`;
+        }
+    }
+    return `${currentSnapshot}${incomingText}`;
+}
+function resolveRouting(options) {
+    if (options.routing)
+        return options.routing;
+    if (options.to)
+        return { chatId: options.to.id, chatType: options.to.type };
+    throw new Error("openclaw-clawchat buffered stream requires routing");
+}
+/**
+ * Build a streaming session wrapper around message.created/add/done events.
+ *
+ * Usage pattern (matching clawling-channel):
+ *   const session = openBufferedStreamingSession({...});
+ *   await session.queueSnapshot("Hel");
+ *   await session.queueSnapshot("Hello");
+ *   await session.queueDelta(", world");
+ *   await session.done();
+ */
+export function openBufferedStreamingSession(options) {
+    const routing = resolveRouting(options);
+    const emitTyping = options.emitTyping !== false;
+    if (emitTyping)
+        options.client.typing(routing.chatId, true);
+    emitStreamCreated(options.client, {
+        messageId: options.messageId,
+        routing,
+    });
+    let bufferedSnapshot = "";
+    let flushedSnapshot = "";
+    let sequence = -1;
+    let flushTimer = null;
+    let pendingFlush = Promise.resolve();
+    let closed = false;
+    const clearTimer = () => {
+        if (flushTimer) {
+            clearTimeout(flushTimer);
+            flushTimer = null;
+        }
+    };
+    const performFlush = async () => {
+        clearTimer();
+        if (closed)
+            return;
+        if (bufferedSnapshot === flushedSnapshot)
+            return;
+        const snapshot = bufferedSnapshot;
+        const delta = snapshot.slice(flushedSnapshot.length);
+        if (!delta)
+            return;
+        sequence += 1;
+        emitStreamAdd(options.client, {
+            messageId: options.messageId,
+            routing,
+            sequence,
+            fullText: snapshot,
+            textDelta: delta,
+        });
+        flushedSnapshot = snapshot;
+    };
+    const flush = async () => {
+        pendingFlush = pendingFlush.then(performFlush);
+        await pendingFlush;
+    };
+    const scheduleFlush = () => {
+        if (flushTimer || closed)
+            return;
+        flushTimer = setTimeout(() => {
+            flushTimer = null;
+            void flush();
+        }, options.flushIntervalMs);
+    };
+    const queueSnapshot = async (snapshot) => {
+        if (closed || !snapshot)
+            return;
+        const base = bufferedSnapshot.length >= flushedSnapshot.length ? bufferedSnapshot : flushedSnapshot;
+        const merged = mergeStreamingText(base, snapshot);
+        if (merged === bufferedSnapshot)
+            return;
+        bufferedSnapshot = merged;
+        const deltaChars = Math.max(0, bufferedSnapshot.length - flushedSnapshot.length);
+        if (deltaChars >= options.minChunkChars || bufferedSnapshot.length >= options.maxBufferChars) {
+            await flush();
+        }
+        else {
+            scheduleFlush();
+        }
+    };
+    const queueDelta = async (delta) => {
+        if (closed || !delta)
+            return;
+        bufferedSnapshot = `${bufferedSnapshot}${delta}`;
+        const deltaChars = Math.max(0, bufferedSnapshot.length - flushedSnapshot.length);
+        if (deltaChars >= options.minChunkChars || bufferedSnapshot.length >= options.maxBufferChars) {
+            await flush();
+        }
+        else {
+            scheduleFlush();
+        }
+    };
+    const done = async () => {
+        if (closed)
+            return;
+        await flush();
+        closed = true;
+        clearTimer();
+        emitStreamDone(options.client, {
+            messageId: options.messageId,
+            routing,
+            finalSequence: Math.max(sequence, 0),
+            finalText: bufferedSnapshot,
+        });
+        if (emitTyping)
+            options.client.typing(routing.chatId, false);
+    };
+    const fail = async (reason) => {
+        if (closed)
+            return;
+        closed = true;
+        clearTimer();
+        emitStreamFailed(options.client, {
+            messageId: options.messageId,
+            routing,
+            sequence: Math.max(sequence, 0),
+            ...(reason !== undefined ? { reason } : {}),
+        });
+        if (emitTyping)
+            options.client.typing(routing.chatId, false);
+    };
+    return {
+        get currentText() {
+            return bufferedSnapshot;
+        },
+        get flushedText() {
+            return flushedSnapshot;
+        },
+        queueSnapshot,
+        queueDelta,
+        flush,
+        done,
+        fail,
+    };
+}

package/dist/src/channel.js

@@ -0,0 +1,66 @@
+import { createChatChannelPlugin } from "openclaw/plugin-sdk/core";
+import { createEmptyChannelDirectoryAdapter } from "openclaw/plugin-sdk/directory-runtime";
+import { CHANNEL_ID, resolveOpenclawClawlingAccount, } from "./config.js";
+import { openclawClawlingOutbound } from "./outbound.js";
+import { getOpenclawClawlingRuntime, startOpenclawClawlingGateway } from "./runtime.js";
+import { openclawClawlingSetupPlugin } from "./channel.setup.js";
+import { getClawChatPlatformPrompt } from "./plugin-prompts.js";
+export const openclawClawlingPlugin = createChatChannelPlugin({
+    base: {
+        ...openclawClawlingSetupPlugin,
+        reload: {
+            configPrefixes: [`channels.${CHANNEL_ID}`],
+        },
+        directory: createEmptyChannelDirectoryAdapter(),
+        auth: {
+            login: async ({ cfg, accountId, runtime }) => {
+                const { runOpenclawClawlingLogin } = await import("./login.runtime.js");
+                await runOpenclawClawlingLogin({
+                    cfg,
+                    accountId: accountId ?? null,
+                    runtime: { log: (message) => runtime.log(message) },
+                    mutateConfigFile: getOpenclawClawlingRuntime().config.mutateConfigFile,
+                });
+            },
+        },
+        gateway: {
+            startAccount: async (ctx) => {
+                const account = ctx.account ?? resolveOpenclawClawlingAccount(ctx.cfg);
+                ctx.log?.info?.(`[${account.accountId}] clawchat-plugin-openclaw lifecycle START_ACCOUNT_CALLED 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}] clawchat-plugin-openclaw lifecycle startAccount refused: websocketUrl/token/userId are required`);
+                    throw new Error("Clawling Chat websocketUrl/token/userId are required");
+                }
+                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}] clawchat-plugin-openclaw lifecycle startAccount completed/stopped`);
+                }
+            },
+        },
+        agentPrompt: {
+            messageToolHints: () => [getClawChatPlatformPrompt()],
+        },
+        messaging: {
+            targetPrefixes: ["cc", "clawchat", CHANNEL_ID],
+            normalizeTarget: (target) => target
+                .trim()
+                .replace(/^clawchat-plugin-openclaw:/i, "")
+                .replace(/^clawchat:/i, "")
+                .replace(/^cc:/i, ""),
+            targetResolver: {
+                looksLikeId: (raw, normalized) => Boolean((normalized ?? raw).trim()),
+                hint: "active-session",
+            },
+        },
+    },
+    outbound: openclawClawlingOutbound,
+});

package/dist/src/channel.setup.js

@@ -0,0 +1,119 @@
+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, 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",
+        "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 setup
+ * write leaves channel config unchanged; `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 }) => cfg,
+    afterAccountConfigWritten: async ({ cfg, input, runtime }) => {
+        runtime.log("[default] clawchat-plugin-openclaw 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] clawchat-plugin-openclaw 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] clawchat-plugin-openclaw setup afterAccountConfigWritten completed");
+    },
+};
+export const openclawClawlingSetupPlugin = {
+    id: CHANNEL_ID,
+    meta: {
+        id: CHANNEL_ID,
+        label: "Clawling Chat",
+        selectionLabel: "Clawling Chat",
+        docsPath: "/channels/clawchat-plugin-openclaw",
+        docsLabel: "clawchat-plugin-openclaw",
+        blurb: "ClawChat Protocol v2 over WebSocket.",
+        order: 110,
+    },
+    capabilities: {
+        chatTypes: ["direct", "group"],
+        media: true,
+        reactions: false,
+        threads: false,
+        polls: false,
+        blockStreaming: true,
+    },
+    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,
+            },
+        }),
+    }),
+};