@clawpod/openclaw-plugin 0.1.0 → 0.2.0

package/dist/connection.d.ts

@@ -27,6 +27,10 @@ export interface ChannelMessage {
     senderType: string;
     senderName?: string;
     content: string;
+    channelAgents?: {
+        name: string;
+        defaultPrompt?: string;
+    }[];
 }
 export interface ClawPodConnection {
     ws: WebSocket | null;

package/dist/connection.js

@@ -4,10 +4,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createConnection = createConnection;
+const node_child_process_1 = require("node:child_process");
 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 node_util_1 = require("node:util");
 const ws_1 = __importDefault(require("ws"));
+const execAsync = (0, node_util_1.promisify)(node_child_process_1.exec);
 function createConnection(config, handlers) {
     const { logger, workspace } = handlers;
     const conn = {
@@ -110,16 +113,22 @@ function createConnection(config, handlers) {
             }
             case 'message:new': {
                 const msg = event.message;
-                if (!conn.agentId || msg.senderType === 'agent')
+                if (!conn.agentId)
                     break;
+                // Ignore own messages
+                if (msg.senderId === conn.agentId)
+                    break;
+                const channelAgents = event.channelAgents;
+                msg.channelAgents = channelAgents;
                 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`);
+                    logger.info(`[clawpod] @mentioned by ${msg.senderName} (${msg.senderType}) in channel`);
                     conn.onMention(msg);
                 }
-                else if (autoReply) {
+                else if (autoReply && msg.senderType !== 'agent') {
+                    // autoReply only for human messages to avoid echo loops
                     logger.info(`[clawpod] autoReply channel msg from ${msg.senderName}: ${msg.content?.slice(0, 60)}`);
                     conn.onMention({ ...msg, autoReply: true });
                 }
@@ -135,6 +144,10 @@ function createConnection(config, handlers) {
                 handleSkillsList(event, workspace || null, conn);
                 break;
             }
+            case 'agent:add': {
+                handleAgentAdd(event, conn);
+                break;
+            }
         }
     }
     function handleWorkspaceBrowse(event, wsPath, conn) {
@@ -263,6 +276,57 @@ function createConnection(config, handlers) {
             skills,
         }));
     }
+    async function handleAgentAdd(event, conn) {
+        const requestId = event.requestId;
+        const agentName = event.name;
+        const agentWorkspace = event.workspace;
+        const identity = event.identity;
+        try {
+            const wsFlag = agentWorkspace ? ` --workspace ${JSON.stringify(agentWorkspace)}` : '';
+            await execAsync(`openclaw agents add ${JSON.stringify(agentName)}${wsFlag}`);
+            const identityParts = [];
+            if (identity?.name)
+                identityParts.push(`--name ${JSON.stringify(identity.name)}`);
+            if (identity?.emoji)
+                identityParts.push(`--emoji ${JSON.stringify(identity.emoji)}`);
+            if (identity?.avatar)
+                identityParts.push(`--avatar ${JSON.stringify(identity.avatar)}`);
+            if (identityParts.length > 0) {
+                await execAsync(`openclaw agents set-identity --agent ${JSON.stringify(agentName)} ${identityParts.join(' ')}`);
+            }
+            logger.info(`[clawpod] Agent added via CLI: ${agentName}`);
+            conn.ws?.send(JSON.stringify({ type: 'agent:add:result', requestId, success: true }));
+            // Re-register to refresh agent list in ClawPod
+            try {
+                const { stdout } = await execAsync('openclaw agents list --json');
+                const agentsList = JSON.parse(stdout);
+                const mapped = (Array.isArray(agentsList) ? agentsList : []).map((a) => ({
+                    name: a.identity?.name || a.name || a.id || 'Agent',
+                    defaultPrompt: 'OpenClaw Agent',
+                    status: 'online',
+                    model: 'openclaw',
+                }));
+                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: mapped.length > 0 ? mapped : [
+                        { name: config.agentName, defaultPrompt: 'OpenClaw Agent', status: 'online', model: 'openclaw' },
+                    ],
+                }));
+            }
+            catch {
+                logger.info('[clawpod] Could not refresh agent list after add');
+            }
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            logger.error(`[clawpod] agent:add failed: ${msg}`);
+            conn.ws?.send(JSON.stringify({ type: 'agent:add:result', requestId, success: false, error: msg }));
+        }
+    }
     // Public API
     return {
         ...conn,

package/dist/index.js

@@ -12,6 +12,22 @@ const connection_js_1 = require("./connection.js");
 const connections = new Map();
 let _pluginApi = null;
 let pluginRuntime = null;
+const AGENT_REPLY_MAX = 5;
+const AGENT_REPLY_WINDOW_MS = 60_000;
+const agentReplyTracker = new Map();
+function isAgentReplyAllowed(channelId, senderId) {
+    const key = `${channelId}:${senderId}`;
+    const now = Date.now();
+    const entry = agentReplyTracker.get(key);
+    if (!entry || now > entry.resetAt) {
+        agentReplyTracker.set(key, { count: 1, resetAt: now + AGENT_REPLY_WINDOW_MS });
+        return true;
+    }
+    if (entry.count >= AGENT_REPLY_MAX)
+        return false;
+    entry.count++;
+    return true;
+}
 const clawpodChannel = {
     id: 'clawpod',
     meta: {
@@ -157,7 +173,12 @@ const clawpodChannel = {
                     });
                 },
                 onMention: async (msg) => {
-                    logger.info(`[clawpod:${accountId}] @mention by ${msg.senderName}`);
+                    if (msg.senderType === 'agent' &&
+                        !isAgentReplyAllowed(msg.channelId, msg.senderId)) {
+                        logger.info(`[clawpod:${accountId}] Rate limited agent-to-agent reply in ${msg.channelId}`);
+                        return;
+                    }
+                    logger.info(`[clawpod:${accountId}] @mention by ${msg.senderName} (${msg.senderType})`);
                     const clean = msg.content?.replace(`@${config.agentName}`, '').trim();
                     await handleInboundMessage({
                         cfg,
@@ -170,6 +191,7 @@ const clawpodChannel = {
                         messageId: msg.id,
                         isDm: false,
                         channelId: msg.channelId,
+                        channelAgents: msg.channelAgents,
                     });
                 },
                 logger,
@@ -209,8 +231,18 @@ const clawpodChannel = {
     },
 };
 exports.clawpodChannel = clawpodChannel;
+function buildAgentRoster(channelAgents, selfName) {
+    if (!channelAgents?.length)
+        return null;
+    const others = channelAgents.filter((a) => a.name !== selfName);
+    if (!others.length)
+        return null;
+    return others
+        .map((a) => `- @${a.name}: ${a.defaultPrompt || 'No description'}`)
+        .join('\n');
+}
 async function handleInboundMessage(params) {
-    const { cfg, logger, conn, accountId, senderId, senderName, content, messageId, isDm, channelId, } = params;
+    const { cfg, logger, conn, accountId, senderId, senderName, content, messageId, isDm, channelId, channelAgents, } = params;
     // Context for status isolation: dm:<senderId> or channel:<channelId>
     const statusContext = isDm ? `dm:${senderId}` : `channel:${channelId}`;
     try {
@@ -238,11 +270,15 @@ async function handleInboundMessage(params) {
                 logger.info(`[clawpod] Route fallback: ${e instanceof Error ? e.message : String(e)}`);
             }
         }
+        const agentRoster = buildAgentRoster(channelAgents, conn.config.agentName);
+        const bodyWithRoster = agentRoster
+            ? `[Available agents in this channel:\n${agentRoster}\nYou can @mention them to delegate tasks.]\n\n${content}`
+            : content;
         const ctx = {
             SessionKey: route.sessionKey,
             Channel: 'clawpod',
             AccountId: accountId,
-            Body: content,
+            Body: bodyWithRoster,
             SenderName: senderName,
             SenderId: senderId,
             ChatType: isDm ? 'direct' : 'group',
@@ -318,8 +354,11 @@ async function handleInboundMessage(params) {
             // Use openclaw agent CLI via detached spawn
             logger.info('[clawpod] Dispatching via openclaw agent CLI');
             const { spawn: spawnFn } = await import('node:child_process');
+            const cliMessage = agentRoster
+                ? `[Available agents in this channel:\n${agentRoster}\nYou can @mention them to delegate tasks.]\n\n${content}`
+                : content;
             const reply = await new Promise((resolve) => {
-                const proc = spawnFn('openclaw', ['agent', '--message', content, '--session-id', route.sessionKey], {
+                const proc = spawnFn('openclaw', ['agent', '--message', cliMessage, '--session-id', route.sessionKey], {
                     stdio: ['ignore', 'pipe', 'pipe'],
                     timeout: 90000,
                     detached: false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clawpod/openclaw-plugin",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "ClawPod channel plugin for OpenClaw",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -13,7 +13,7 @@
   },
   "openclaw": {
     "extensions": [
-      "./src/index.ts"
+      "./dist/index.js"
     ],
     "channel": {
       "id": "clawpod",
@@ -21,10 +21,7 @@
       "selectionLabel": "ClawPod (Human & Agent Workspace)",
       "docsPath": "/channels/clawpod",
       "blurb": "Connect OpenClaw agents to ClawPod collaborative spaces.",
-      "order": 80,
-      "aliases": [
-        "den"
-      ]
+      "order": 80
     }
   },
   "dependencies": {