@clawpod/openclaw-plugin 0.1.0

package/dist/connection.d.ts

@@ -0,0 +1,58 @@
+import WebSocket from 'ws';
+export interface ClawPodConfig {
+    serverUrl: string;
+    apiKey: string;
+    agentName: string;
+    workspaceExpose: boolean;
+    allowedMembers: string[];
+    accountId: string;
+    enabled: boolean;
+}
+export interface WsEvent {
+    type: string;
+    [key: string]: unknown;
+}
+export interface DmMessage {
+    id: string;
+    senderId: string;
+    senderType: string;
+    senderName?: string;
+    receiverId: string;
+    content: string;
+}
+export interface ChannelMessage {
+    id: string;
+    channelId: string;
+    senderId: string;
+    senderType: string;
+    senderName?: string;
+    content: string;
+}
+export interface ClawPodConnection {
+    ws: WebSocket | null;
+    agentId: string | null;
+    spaceId: string | null;
+    machineId: string | null;
+    config: ClawPodConfig;
+    onMessage: (event: WsEvent) => void;
+    onDm: (dm: DmMessage) => void;
+    onMention: (msg: ChannelMessage) => void;
+}
+export interface ClawPodConnectionApi extends ClawPodConnection {
+    connect: () => void;
+    disconnect: () => void;
+    updateStatus: (status: string, context?: string) => void;
+    sendDmReply: (receiverId: string, receiverType: string, content: string) => void;
+    sendChannelMessage: (channelId: string, content: string) => void;
+    sendProcessed: (messageId: string) => void;
+}
+export declare function createConnection(config: ClawPodConfig, handlers: {
+    onDm: (dm: DmMessage) => void;
+    onMention: (msg: ChannelMessage) => void;
+    onStatusChange?: (status: string) => void;
+    logger: {
+        info: (...args: unknown[]) => void;
+        error: (...args: unknown[]) => void;
+    };
+    workspace?: string;
+}): ClawPodConnectionApi;

package/dist/connection.js

@@ -0,0 +1,319 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createConnection = createConnection;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const ws_1 = __importDefault(require("ws"));
+function createConnection(config, handlers) {
+    const { logger, workspace } = handlers;
+    const conn = {
+        ws: null,
+        agentId: null,
+        spaceId: null,
+        machineId: null,
+        config,
+        onMessage: () => { },
+        onDm: handlers.onDm,
+        onMention: handlers.onMention,
+    };
+    let reconnectTimer = null;
+    let closed = false;
+    function connect() {
+        if (closed) {
+            logger.info(`[clawpod] connect() skipped: closed=true`);
+            return;
+        }
+        logger.info(`[clawpod] Connecting to ${config.serverUrl} (closed=${closed})`);
+        let ws;
+        try {
+            ws = new ws_1.default(config.serverUrl);
+        }
+        catch (e) {
+            logger.error(`[clawpod] WebSocket constructor error: ${e instanceof Error ? e.message : String(e)}`);
+            if (!closed)
+                reconnectTimer = setTimeout(connect, 5000);
+            return;
+        }
+        conn.ws = ws;
+        ws.on('open', () => {
+            logger.info(`[clawpod] WS open, sending auth (apiKey length=${config.apiKey?.length})`);
+            ws.send(JSON.stringify({ type: 'auth', token: config.apiKey, kind: 'machine' }));
+        });
+        ws.on('message', (raw) => {
+            try {
+                const event = JSON.parse(raw.toString());
+                logger.info(`[clawpod] WS recv: ${event.type}`);
+                handleEvent(event);
+            }
+            catch (e) {
+                logger.error(`[clawpod] WS message parse error: ${e instanceof Error ? e.message : String(e)}`);
+            }
+        });
+        ws.on('close', (code, reason) => {
+            logger.info(`[clawpod] WS close: code=${code} reason=${reason?.toString()}`);
+            conn.agentId = null;
+            if (!closed) {
+                logger.info('[clawpod] Disconnected, reconnecting in 5s');
+                reconnectTimer = setTimeout(connect, 5000);
+            }
+        });
+        ws.on('error', (err) => {
+            logger.error(`[clawpod] WS error: ${err.message}`);
+        });
+    }
+    function handleEvent(event) {
+        switch (event.type) {
+            case 'auth:ok':
+                conn.spaceId = event.spaceId;
+                conn.machineId = event.id;
+                logger.info(`[clawpod] Authenticated. Machine: ${event.id}`);
+                conn.ws?.send(JSON.stringify({
+                    type: 'machine:register',
+                    name: `${node_os_1.default.hostname()} (OpenClaw)`,
+                    mode: 'openclaw',
+                    workspacePath: workspace || process.cwd(),
+                    allowedMembers: config.allowedMembers || [],
+                    agents: [
+                        {
+                            name: config.agentName,
+                            defaultPrompt: 'OpenClaw Agent',
+                            status: 'online',
+                            model: 'openclaw',
+                        },
+                    ],
+                }));
+                break;
+            case 'machine:online': {
+                const eventAgents = event.agents;
+                if (eventAgents && !conn.agentId) {
+                    const a = eventAgents.find((a) => a.name === config.agentName);
+                    if (a) {
+                        conn.agentId = a.id;
+                        logger.info(`[clawpod] Agent registered: ${a.id} (${a.name})`);
+                    }
+                }
+                break;
+            }
+            case 'dm:new': {
+                const dm = event.message;
+                if (!conn.agentId ||
+                    dm.senderType === 'agent' ||
+                    dm.receiverId !== conn.agentId)
+                    break;
+                logger.info(`[clawpod] DM from ${dm.senderName}: ${dm.content?.slice(0, 80)}`);
+                conn.onDm(dm);
+                break;
+            }
+            case 'message:new': {
+                const msg = event.message;
+                if (!conn.agentId || msg.senderType === 'agent')
+                    break;
+                const isMentioned = msg.content?.includes(`@${config.agentName}`);
+                const channelMeta = event.channelMeta;
+                const autoReply = channelMeta?.agentAutoReply === true;
+                if (isMentioned) {
+                    logger.info(`[clawpod] @mentioned by ${msg.senderName} in channel`);
+                    conn.onMention(msg);
+                }
+                else if (autoReply) {
+                    logger.info(`[clawpod] autoReply channel msg from ${msg.senderName}: ${msg.content?.slice(0, 60)}`);
+                    conn.onMention({ ...msg, autoReply: true });
+                }
+                break;
+            }
+            case 'workspace:browse': {
+                if (!config.workspaceExpose || !workspace)
+                    break;
+                handleWorkspaceBrowse(event, workspace, conn);
+                break;
+            }
+            case 'skills:list': {
+                handleSkillsList(event, workspace || null, conn);
+                break;
+            }
+        }
+    }
+    function handleWorkspaceBrowse(event, wsPath, conn) {
+        const reqPath = event.path || '/';
+        const fullPath = node_path_1.default.join(wsPath, reqPath);
+        if (!fullPath.startsWith(wsPath)) {
+            conn.ws?.send(JSON.stringify({
+                type: 'workspace:files',
+                requestId: event.requestId,
+                path: reqPath,
+                files: [],
+                error: 'Access denied',
+            }));
+            return;
+        }
+        try {
+            const stat = node_fs_1.default.statSync(fullPath);
+            if (stat.isDirectory()) {
+                const entries = node_fs_1.default
+                    .readdirSync(fullPath, { withFileTypes: true })
+                    .filter((e) => !e.name.startsWith('.') && e.name !== 'node_modules')
+                    .map((e) => {
+                    let size;
+                    try {
+                        if (!e.isDirectory())
+                            size = node_fs_1.default.statSync(node_path_1.default.join(fullPath, e.name)).size;
+                    }
+                    catch { }
+                    return {
+                        name: e.name,
+                        path: node_path_1.default.join(reqPath, e.name),
+                        isDir: e.isDirectory(),
+                        size,
+                    };
+                })
+                    .sort((a, b) => a.isDir === b.isDir
+                    ? a.name.localeCompare(b.name)
+                    : a.isDir
+                        ? -1
+                        : 1);
+                conn.ws?.send(JSON.stringify({
+                    type: 'workspace:files',
+                    requestId: event.requestId,
+                    path: reqPath,
+                    basePath: wsPath,
+                    files: entries,
+                }));
+            }
+            else {
+                const content = node_fs_1.default.readFileSync(fullPath, 'utf-8').slice(0, 50000);
+                conn.ws?.send(JSON.stringify({
+                    type: 'workspace:file-content',
+                    requestId: event.requestId,
+                    path: reqPath,
+                    basePath: wsPath,
+                    content,
+                    size: stat.size,
+                }));
+            }
+        }
+        catch (err) {
+            conn.ws?.send(JSON.stringify({
+                type: 'workspace:files',
+                requestId: event.requestId,
+                path: reqPath,
+                files: [],
+                error: err instanceof Error ? err.message : String(err),
+            }));
+        }
+    }
+    function handleSkillsList(event, wsPath, conn) {
+        const skills = [];
+        const home = node_os_1.default.homedir();
+        const skillsDirs = [];
+        if (wsPath) {
+            skillsDirs.push({ base: node_path_1.default.join(wsPath, 'skills'), source: 'workspace' });
+        }
+        skillsDirs.push({ base: node_path_1.default.join(home, '.cursor', 'skills'), source: 'bundled' }, { base: node_path_1.default.join(home, '.cursor', 'skills-cursor'), source: 'bundled' }, { base: node_path_1.default.join(home, '.codex', 'skills', '.system'), source: 'bundled' }, { base: node_path_1.default.join(home, '.openclaw', 'skills'), source: 'bundled' });
+        try {
+            const ocPath = require.resolve('openclaw/package.json');
+            skillsDirs.push({
+                base: node_path_1.default.join(node_path_1.default.dirname(ocPath), 'skills'),
+                source: 'bundled',
+            });
+        }
+        catch { }
+        const seen = new Set();
+        for (const { base, source } of skillsDirs) {
+            try {
+                if (!node_fs_1.default.existsSync(base))
+                    continue;
+                for (const name of node_fs_1.default.readdirSync(base)) {
+                    if (seen.has(name))
+                        continue;
+                    const skillDir = node_path_1.default.join(base, name);
+                    if (!node_fs_1.default.statSync(skillDir).isDirectory())
+                        continue;
+                    seen.add(name);
+                    const skill = {
+                        name,
+                        source,
+                        path: skillDir,
+                        description: '',
+                        emoji: '',
+                        files: [],
+                    };
+                    const skillMd = node_path_1.default.join(skillDir, 'SKILL.md');
+                    if (node_fs_1.default.existsSync(skillMd)) {
+                        const content = node_fs_1.default.readFileSync(skillMd, 'utf-8');
+                        const descMatch = content.match(/description:\s*["']?(.+?)["']?\s*\n/);
+                        if (descMatch)
+                            skill.description = descMatch[1].slice(0, 120);
+                        skill.skillMdContent = content;
+                    }
+                    skill.files = node_fs_1.default
+                        .readdirSync(skillDir)
+                        .filter((f) => !f.startsWith('.'));
+                    skills.push(skill);
+                }
+            }
+            catch { }
+        }
+        conn.ws?.send(JSON.stringify({
+            type: 'skills:list',
+            requestId: event.requestId,
+            skills,
+        }));
+    }
+    // Public API
+    return {
+        ...conn,
+        connect() {
+            connect();
+        },
+        disconnect() {
+            closed = true;
+            if (reconnectTimer)
+                clearTimeout(reconnectTimer);
+            conn.ws?.close();
+        },
+        updateStatus(status, context) {
+            if (conn.ws?.readyState === ws_1.default.OPEN && conn.agentId) {
+                conn.ws.send(JSON.stringify({
+                    type: 'agent:status',
+                    agentId: conn.agentId,
+                    status,
+                    context: context || undefined,
+                }));
+            }
+        },
+        sendDmReply(receiverId, receiverType, content) {
+            if (conn.ws?.readyState === ws_1.default.OPEN && conn.agentId) {
+                conn.ws.send(JSON.stringify({
+                    type: 'dm:send',
+                    receiverId,
+                    receiverType,
+                    content,
+                    agentId: conn.agentId,
+                }));
+            }
+        },
+        sendChannelMessage(channelId, content) {
+            if (conn.ws?.readyState === ws_1.default.OPEN && conn.agentId) {
+                conn.ws.send(JSON.stringify({
+                    type: 'message:send',
+                    channelId,
+                    content,
+                    agentId: conn.agentId,
+                }));
+            }
+        },
+        sendProcessed(messageId) {
+            if (conn.ws?.readyState === ws_1.default.OPEN && conn.agentId) {
+                conn.ws.send(JSON.stringify({
+                    type: 'dm:processed',
+                    messageId,
+                    agentId: conn.agentId,
+                }));
+            }
+        },
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,170 @@
+/**
+ * @clawpod/channel — ClawPod Channel Plugin for OpenClaw
+ *
+ * Registers ClawPod as a messaging channel. Messages from ClawPod are dispatched
+ * through OpenClaw's standard agent session pipeline. Replies flow back to ClawPod.
+ */
+interface OpenClawPluginApi {
+    runtime: OpenClawRuntime;
+    logger: {
+        info: (...args: unknown[]) => void;
+        error: (...args: unknown[]) => void;
+    };
+    registerChannel: (opts: {
+        plugin: unknown;
+    }) => void;
+    registerTool: (tool: {
+        name: string;
+        description: string;
+        parameters: Record<string, unknown>;
+        handler: (params: Record<string, string>) => Promise<Record<string, unknown>>;
+    }) => void;
+}
+interface OpenClawRuntime {
+    channel?: {
+        reply?: {
+            dispatchReplyFromConfig?: (opts: Record<string, unknown>) => Promise<void>;
+            withReplyDispatcher?: (opts: Record<string, unknown>) => Promise<void>;
+            finalizeInboundContext?: (ctx: Record<string, unknown>, cfg: Record<string, unknown>) => void;
+        };
+        routing?: {
+            resolveAgentRoute?: (opts: Record<string, unknown>) => {
+                sessionKey: string;
+                accountId: string;
+            };
+        };
+    };
+    [key: string]: unknown;
+}
+declare const clawpodChannel: {
+    id: string;
+    meta: {
+        id: string;
+        label: string;
+        selectionLabel: string;
+        docsPath: string;
+        docsLabel: string;
+        blurb: string;
+        aliases: string[];
+        order: number;
+    };
+    reload: {
+        configPrefixes: string[];
+    };
+    configSchema: {
+        schema: {
+            type: string;
+            additionalProperties: boolean;
+            properties: {
+                enabled: {
+                    type: string;
+                };
+                serverUrl: {
+                    type: string;
+                };
+                apiKey: {
+                    type: string;
+                };
+                workspaceExpose: {
+                    type: string;
+                };
+                agentName: {
+                    type: string;
+                    description: string;
+                };
+                allowedMembers: {
+                    type: string;
+                    items: {
+                        type: string;
+                    };
+                    description: string;
+                };
+            };
+        };
+        uiHints: {
+            enabled: {
+                label: string;
+            };
+            serverUrl: {
+                label: string;
+                placeholder: string;
+            };
+            apiKey: {
+                label: string;
+                sensitive: boolean;
+            };
+            workspaceExpose: {
+                label: string;
+            };
+            agentName: {
+                label: string;
+                placeholder: string;
+            };
+            allowedMembers: {
+                label: string;
+                placeholder: string;
+            };
+        };
+    };
+    capabilities: {
+        chatTypes: readonly ["direct", "channel"];
+        polls: boolean;
+        threads: boolean;
+        media: boolean;
+        reactions: boolean;
+        edit: boolean;
+        reply: boolean;
+    };
+    config: {
+        listAccountIds: (cfg: Record<string, unknown>) => string[];
+        resolveAccount: (cfg: Record<string, unknown>, _accountId?: string) => {
+            accountId: string;
+            enabled: boolean;
+            configured: boolean;
+            serverUrl: string | undefined;
+        };
+        isConfigured: (account: Record<string, unknown>) => boolean;
+        describeAccount: (account: Record<string, unknown>) => {
+            accountId: string;
+            enabled: boolean;
+            configured: boolean;
+            serverUrl: string | undefined;
+        };
+    };
+    outbound: {
+        deliveryMode: "direct";
+        sendText: (params: {
+            text: string;
+            to: string;
+        }) => Promise<{
+            ok: boolean;
+            error: string;
+        } | {
+            ok: boolean;
+            error?: undefined;
+        }>;
+    };
+    gateway: {
+        startAccount: (ctx: {
+            cfg: Record<string, unknown>;
+            accountId: string;
+            runtime: Record<string, unknown>;
+            log: Record<string, (...args: unknown[]) => void>;
+            abortSignal?: AbortSignal;
+        }) => Promise<void>;
+    };
+    status: {
+        summary: () => {
+            ok: boolean;
+            label: string;
+        };
+        describeAccount: (_cfg: Record<string, unknown>, _accountId: string, runtime: Record<string, unknown> | undefined) => {
+            accountId: string;
+            running: {};
+            configured: boolean;
+            connected: boolean;
+        };
+    };
+};
+export default function register(api: OpenClawPluginApi): void;
+export { clawpodChannel };

package/dist/index.js

@@ -0,0 +1,410 @@
+"use strict";
+/**
+ * @clawpod/channel — ClawPod Channel Plugin for OpenClaw
+ *
+ * Registers ClawPod as a messaging channel. Messages from ClawPod are dispatched
+ * through OpenClaw's standard agent session pipeline. Replies flow back to ClawPod.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clawpodChannel = void 0;
+exports.default = register;
+const connection_js_1 = require("./connection.js");
+const connections = new Map();
+let _pluginApi = null;
+let pluginRuntime = null;
+const clawpodChannel = {
+    id: 'clawpod',
+    meta: {
+        id: 'clawpod',
+        label: 'ClawPod',
+        selectionLabel: 'ClawPod (Human & Agent Workspace)',
+        docsPath: '/channels/clawpod',
+        docsLabel: 'clawpod',
+        blurb: 'Connect OpenClaw agents to ClawPod collaborative spaces.',
+        aliases: ['den'],
+        order: 80,
+    },
+    reload: { configPrefixes: ['channels.clawpod'] },
+    configSchema: {
+        schema: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                enabled: { type: 'boolean' },
+                serverUrl: { type: 'string' },
+                apiKey: { type: 'string' },
+                workspaceExpose: { type: 'boolean' },
+                agentName: {
+                    type: 'string',
+                    description: 'Agent display name in ClawPod',
+                },
+                allowedMembers: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'ClawPod member IDs allowed to view workspace & skills',
+                },
+            },
+        },
+        uiHints: {
+            enabled: { label: '启用 ClawPod' },
+            serverUrl: { label: '服务器地址', placeholder: 'ws://localhost:4000/ws' },
+            apiKey: { label: 'Machine API Key', sensitive: true },
+            workspaceExpose: { label: '暴露工作区文件' },
+            agentName: { label: 'Agent 显示名称', placeholder: '胡桃 🦊' },
+            allowedMembers: {
+                label: '允许查看工作区/Skills 的成员 ID',
+                placeholder: '["mem_xxx"]',
+            },
+        },
+    },
+    capabilities: {
+        chatTypes: ['direct', 'channel'],
+        polls: false,
+        threads: false,
+        media: false,
+        reactions: false,
+        edit: false,
+        reply: false,
+    },
+    config: {
+        listAccountIds: (cfg) => {
+            const channels = cfg?.channels;
+            return channels?.clawpod?.enabled ? ['default'] : [];
+        },
+        resolveAccount: (cfg, _accountId) => {
+            const channels = cfg?.channels;
+            const ch = channels?.clawpod ?? {};
+            return {
+                accountId: 'default',
+                enabled: ch.enabled ?? false,
+                configured: !!(ch.serverUrl && ch.apiKey),
+                serverUrl: ch.serverUrl,
+                ...ch,
+            };
+        },
+        isConfigured: (account) => !!account?.configured,
+        describeAccount: (account) => ({
+            accountId: account.accountId || 'default',
+            enabled: account.enabled ?? false,
+            configured: account.configured ?? false,
+            serverUrl: account.serverUrl,
+        }),
+    },
+    outbound: {
+        deliveryMode: 'direct',
+        sendText: async (params) => {
+            const { text, to } = params;
+            const conn = connections.get('default');
+            if (!conn?.ws)
+                return { ok: false, error: 'ClawPod not connected' };
+            if (!to)
+                return { ok: false, error: 'No target' };
+            if (to.startsWith('dm:')) {
+                const parts = to.split(':');
+                conn.sendDmReply(parts[1], parts[2] || 'member', text);
+            }
+            else if (to.startsWith('channel:')) {
+                conn.sendChannelMessage(to.replace('channel:', ''), text);
+            }
+            else {
+                conn.sendDmReply(to, 'member', text);
+            }
+            return { ok: true };
+        },
+    },
+    gateway: {
+        startAccount: async (ctx) => {
+            const { cfg, accountId, runtime: _runtime, log, abortSignal } = ctx;
+            const channels = cfg?.channels;
+            const ch = channels?.clawpod;
+            if (!ch?.serverUrl || !ch?.apiKey) {
+                log?.warn?.(`[clawpod] Missing serverUrl or apiKey`);
+                return;
+            }
+            const config = {
+                serverUrl: ch.serverUrl,
+                apiKey: ch.apiKey,
+                agentName: ch.agentName || 'OpenClaw Agent',
+                workspaceExpose: ch.workspaceExpose !== false,
+                allowedMembers: ch.allowedMembers || [],
+                accountId: 'default',
+                enabled: true,
+            };
+            const agentsCfg = cfg?.agents;
+            const workspace = agentsCfg?.defaults?.workspace;
+            const logFn = typeof log?.info === 'function'
+                ? log.info.bind(log)
+                : typeof log === 'function'
+                    ? log
+                    : console.log;
+            const errFn = typeof log?.error === 'function' ? log.error.bind(log) : console.error;
+            const warnFn = typeof log?.warn === 'function' ? log.warn.bind(log) : console.warn;
+            const logger = { info: logFn, error: errFn, warn: warnFn };
+            const conn = (0, connection_js_1.createConnection)(config, {
+                onDm: async (dm) => {
+                    logger.info(`[clawpod:${accountId}] DM from ${dm.senderName}: ${dm.content?.slice(0, 60)}`);
+                    await handleInboundMessage({
+                        cfg,
+                        logger,
+                        conn,
+                        accountId,
+                        senderId: dm.senderId,
+                        senderName: dm.senderName || dm.senderId,
+                        content: dm.content,
+                        messageId: dm.id,
+                        isDm: true,
+                        dmReceiverId: dm.receiverId,
+                    });
+                },
+                onMention: async (msg) => {
+                    logger.info(`[clawpod:${accountId}] @mention by ${msg.senderName}`);
+                    const clean = msg.content?.replace(`@${config.agentName}`, '').trim();
+                    await handleInboundMessage({
+                        cfg,
+                        logger,
+                        conn,
+                        accountId,
+                        senderId: msg.senderId,
+                        senderName: msg.senderName || msg.senderId,
+                        content: clean || msg.content,
+                        messageId: msg.id,
+                        isDm: false,
+                        channelId: msg.channelId,
+                    });
+                },
+                logger,
+                workspace,
+            });
+            connections.set('default', conn);
+            // Connect and keep running until aborted
+            return new Promise((resolve) => {
+                conn.connect();
+                logger.info(`[clawpod] Started, waiting for abort signal...`);
+                if (abortSignal) {
+                    abortSignal.addEventListener('abort', () => {
+                        logger.info('[clawpod] Abort signal received, disconnecting');
+                        conn.disconnect();
+                        connections.delete('default');
+                        resolve();
+                    });
+                }
+            });
+        },
+    },
+    status: {
+        summary: () => {
+            const conn = connections.get('default');
+            const connected = conn?.ws?.readyState === 1;
+            return {
+                ok: connected,
+                label: connected ? 'Connected' : 'Not connected',
+            };
+        },
+        describeAccount: (_cfg, _accountId, runtime) => ({
+            accountId: 'default',
+            running: runtime?.running ?? connections.get('default')?.ws?.readyState === 1,
+            configured: true,
+            connected: connections.get('default')?.ws?.readyState === 1,
+        }),
+    },
+};
+exports.clawpodChannel = clawpodChannel;
+async function handleInboundMessage(params) {
+    const { cfg, logger, conn, accountId, senderId, senderName, content, messageId, isDm, channelId, } = params;
+    // Context for status isolation: dm:<senderId> or channel:<channelId>
+    const statusContext = isDm ? `dm:${senderId}` : `channel:${channelId}`;
+    try {
+        conn.updateStatus('thinking', statusContext);
+        // Log available runtime keys for debugging
+        logger.info(`[clawpod] Runtime keys: ${Object.keys(pluginRuntime || {}).join(', ')}`);
+        if (pluginRuntime?.channel)
+            logger.info(`[clawpod] Runtime.channel keys: ${Object.keys(pluginRuntime.channel).join(', ')}`);
+        // Build a valid session ID (simple, no colons in problematic places)
+        const peerId = isDm ? senderId : channelId;
+        const sessionKey = `clawpod-${isDm ? 'dm' : 'ch'}-${peerId}`;
+        logger.info(`[clawpod] Session: ${sessionKey}`);
+        let route = { sessionKey, accountId };
+        if (pluginRuntime?.channel?.routing?.resolveAgentRoute) {
+            try {
+                route = pluginRuntime.channel.routing.resolveAgentRoute({
+                    cfg,
+                    channel: 'clawpod',
+                    accountId,
+                    peer: { kind: isDm ? 'dm' : 'group', id: peerId },
+                });
+                logger.info(`[clawpod] Resolved route: ${route.sessionKey}`);
+            }
+            catch (e) {
+                logger.info(`[clawpod] Route fallback: ${e instanceof Error ? e.message : String(e)}`);
+            }
+        }
+        const ctx = {
+            SessionKey: route.sessionKey,
+            Channel: 'clawpod',
+            AccountId: accountId,
+            Body: content,
+            SenderName: senderName,
+            SenderId: senderId,
+            ChatType: isDm ? 'direct' : 'group',
+            CommandAuthorized: true,
+        };
+        function extractText(payload) {
+            if (typeof payload === 'string')
+                return payload;
+            if (payload && typeof payload === 'object') {
+                const obj = payload;
+                if (typeof obj.text === 'string')
+                    return obj.text;
+                if (typeof obj.content === 'string')
+                    return obj.content;
+                if (typeof obj.body === 'string')
+                    return obj.body;
+                logger.info(`[clawpod] Unknown reply payload type: ${typeof payload}, keys: ${Object.keys(obj).join(',')}`);
+            }
+            return String(payload ?? '');
+        }
+        // Try the full dispatch pipeline
+        if (pluginRuntime?.channel?.reply?.dispatchReplyFromConfig) {
+            let replied = false;
+            const dispatcher = {
+                sendToolResult: () => false,
+                sendBlockReply: (raw) => {
+                    const text = extractText(raw);
+                    if (text.trim()) {
+                        conn.updateStatus('working', statusContext);
+                        logger.info(`[clawpod] Block reply (${text.length} chars): ${text.slice(0, 80)}`);
+                        if (isDm)
+                            conn.sendDmReply(senderId, 'member', text);
+                        else if (channelId)
+                            conn.sendChannelMessage(channelId, text);
+                        replied = true;
+                    }
+                    return true;
+                },
+                sendFinalReply: (raw) => {
+                    const text = extractText(raw);
+                    logger.info(`[clawpod] Final reply (${text.length} chars, alreadyReplied=${replied}): ${text.slice(0, 80)}`);
+                    if (text.trim() && !replied) {
+                        conn.updateStatus('working', statusContext);
+                        if (isDm)
+                            conn.sendDmReply(senderId, 'member', text);
+                        else if (channelId)
+                            conn.sendChannelMessage(channelId, text);
+                    }
+                    conn.sendProcessed(messageId);
+                    conn.updateStatus('online', statusContext);
+                    return true;
+                },
+                waitForIdle: async () => { },
+                getQueuedCounts: () => ({ tool: 0, block: 0, final: 0 }),
+                markComplete: () => { },
+            };
+            const replyApi = pluginRuntime.channel.reply;
+            if (replyApi.finalizeInboundContext) {
+                replyApi.finalizeInboundContext(ctx, cfg);
+            }
+            await replyApi.withReplyDispatcher({
+                dispatcher,
+                onSettled: () => conn.updateStatus('online', statusContext),
+                run: () => replyApi.dispatchReplyFromConfig({
+                    ctx,
+                    cfg,
+                    dispatcher,
+                    replyOptions: {},
+                }),
+            });
+        }
+        else {
+            // Use openclaw agent CLI via detached spawn
+            logger.info('[clawpod] Dispatching via openclaw agent CLI');
+            const { spawn: spawnFn } = await import('node:child_process');
+            const reply = await new Promise((resolve) => {
+                const proc = spawnFn('openclaw', ['agent', '--message', content, '--session-id', route.sessionKey], {
+                    stdio: ['ignore', 'pipe', 'pipe'],
+                    timeout: 90000,
+                    detached: false,
+                    env: { ...process.env },
+                });
+                let stdout = '';
+                let stderr = '';
+                proc.stdout?.on('data', (d) => {
+                    stdout += d.toString();
+                });
+                proc.stderr?.on('data', (d) => {
+                    stderr += d.toString();
+                });
+                proc.on('close', (code) => {
+                    if (code !== 0) {
+                        logger.error(`[clawpod] Agent CLI exit ${code}: ${stderr.slice(0, 300)}`);
+                    }
+                    const clean = stdout
+                        .split('\n')
+                        .filter((l) => !l.startsWith('[plugins]') && !l.startsWith('[openclaw]'))
+                        .join('\n')
+                        .trim();
+                    logger.info(`[clawpod] Agent CLI output (${clean.length} chars): ${clean.slice(0, 80)}`);
+                    resolve(clean || null);
+                });
+                proc.on('error', (err) => {
+                    logger.error(`[clawpod] Spawn error: ${err.message}`);
+                    resolve(null);
+                });
+            });
+            if (reply) {
+                conn.updateStatus('working', statusContext);
+                if (isDm)
+                    conn.sendDmReply(senderId, 'member', reply);
+                else if (channelId)
+                    conn.sendChannelMessage(channelId, reply);
+                logger.info(`[clawpod] Replied: ${reply.slice(0, 60)}`);
+            }
+            conn.sendProcessed(messageId);
+            conn.updateStatus('online', statusContext);
+        }
+    }
+    catch (err) {
+        logger.error(`[clawpod] Dispatch error: ${err instanceof Error ? err.message : String(err)}`);
+        conn.updateStatus('online', statusContext);
+    }
+}
+// Plugin entry
+function register(api) {
+    _pluginApi = api;
+    pluginRuntime = api.runtime;
+    api.logger.info(`[clawpod] api.runtime keys: ${Object.keys(api.runtime || {}).join(', ')}`);
+    api.registerChannel({ plugin: clawpodChannel });
+    // Register clawpod_send tool
+    api.registerTool({
+        name: 'clawpod_send',
+        description: 'Send a message to a ClawPod channel or DM',
+        parameters: {
+            type: 'object',
+            properties: {
+                target: {
+                    type: 'string',
+                    description: "Target: 'channel:<id>' or 'dm:<userId>:<type>'",
+                },
+                message: { type: 'string', description: 'Message content' },
+                accountId: {
+                    type: 'string',
+                    description: "ClawPod account ID (default: 'default')",
+                },
+            },
+            required: ['target', 'message'],
+        },
+        handler: async (params) => {
+            const conn = connections.get(params.accountId || 'default');
+            if (!conn?.ws)
+                return { error: 'ClawPod not connected' };
+            if (params.target.startsWith('channel:')) {
+                conn.sendChannelMessage(params.target.replace('channel:', ''), params.message);
+            }
+            else if (params.target.startsWith('dm:')) {
+                const [, id, type] = params.target.split(':');
+                conn.sendDmReply(id, type || 'member', params.message);
+            }
+            return { success: true };
+        },
+    });
+    api.logger.info('[clawpod] Channel plugin registered');
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@clawpod/openclaw-plugin",
+  "version": "0.1.0",
+  "description": "ClawPod channel plugin for OpenClaw",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "openclaw": {
+    "extensions": [
+      "./src/index.ts"
+    ],
+    "channel": {
+      "id": "clawpod",
+      "label": "ClawPod",
+      "selectionLabel": "ClawPod (Human & Agent Workspace)",
+      "docsPath": "/channels/clawpod",
+      "blurb": "Connect OpenClaw agents to ClawPod collaborative spaces.",
+      "order": 80,
+      "aliases": [
+        "den"
+      ]
+    }
+  },
+  "dependencies": {
+    "ws": "^8.18.0"
+  },
+  "devDependencies": {
+    "@types/ws": "^8.5.0"
+  }
+}