palz-connector 1.5.2 → 1.5.4

package/openclaw.plugin.json

@@ -1,11 +1,21 @@
 {
   "id": "palz-connector",
   "name": "Palz Connector Channel",
-  "version": "1.5.2",
+  "version": "1.5.4",
   "description": "Palz IM 接入 OpenClaw",
   "channels": [
     "palz-connector"
   ],
+  "channelConfigs": {
+    "palz-connector": {
+      "schema": {
+        "type": "object",
+        "additionalProperties": true
+      },
+      "label": "palz-connector",
+      "description": "palz channel configuration."
+    }
+  },
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "palz-connector",
-  "version": "1.5.2",
+  "version": "1.5.4",
   "type": "module",
   "main": "index.js",
   "description": "Palz IM 接入 OpenClaw — 模块化架构，基于 OpenClaw Runtime 消息管道",

package/palz-connector.dev.config.json

@@ -1,7 +1,7 @@
 {
   "enabled": true,
-  "streamUrl": "wss://claw-server.csaiagent.com/ws/bot",
-  "apiBaseUrl": "https://claw-server.csaiagent.com/api",
+  "streamUrl": "ws://claw-server:8787/ws/bot",
+  "apiBaseUrl": "http://claw-server:8787/api",
   "clawGatewayUrl": "http://claw-gateway:8080",
   "activityReportEnabled": true,
   "sessionTimeout": 1800000,

package/palz-connector.prod.config.json

@@ -1,7 +1,7 @@
 {
   "enabled": true,
-  "streamUrl": "wss://claw-server.csagentai.com/ws/bot",
-  "apiBaseUrl": "https://claw-server.csagentai.com/api",
+  "streamUrl": "ws://claw-server:8787/ws/bot",
+  "apiBaseUrl": "http://claw-server:8787/api",
   "clawGatewayUrl": "http://claw-gateway:8080",
   "activityReportEnabled": true,
   "sessionTimeout": 1800000,

package/palz-connector.staging.config.json

@@ -1,8 +1,8 @@
 {
   "enabled": true,
-  "streamUrl": "wss://claw-server.csjkagent.com/ws/bot",
-  "apiBaseUrl": "https://claw-server.csjkagent.com/api",
-  "clawGatewayUrl": "https://claw-server.csjkagent.com/api",
+  "streamUrl": "ws://claw-server:8787/ws/bot",
+  "apiBaseUrl": "http://claw-server:8787/api",
+  "clawGatewayUrl": "http://claw-gateway:8080",
   "activityReportEnabled": true,
   "sessionTimeout": 1800000,
   "groupContextCache": false,

package/src/activity.js

@@ -30,7 +30,7 @@ export async function reportPalzActivity(params) {
     if (config.activityReportEnabled !== true)
         return;
     const baseUrl = config.clawGatewayUrl?.trim();
-    const releaseName = (process.env.botID || config.botId || "").trim();
+    const releaseName = (config.botId || "").trim();
     if (!baseUrl || !releaseName) {
         const warnKey = `${accountId ?? ""}:${baseUrl ? "hasBaseUrl" : "missingBaseUrl"}:${releaseName ? "hasRelease" : "missingRelease"}`;
         if (!warnedMissingConfig.has(warnKey)) {

package/src/agent-logger.js

@@ -0,0 +1,84 @@
+import fs from "fs";
+import path from "path";
+import os from "os";
+const DEFAULT_OPENCLAW_DIR = path.join(os.homedir(), ".openclaw");
+const LOG_DIR_NAME = "palz-log";
+function todayStr() {
+    const d = new Date();
+    const y = d.getFullYear();
+    const m = String(d.getMonth() + 1).padStart(2, "0");
+    const day = String(d.getDate()).padStart(2, "0");
+    return `${y}-${m}-${day}`;
+}
+function formatTimestamp() {
+    const d = new Date();
+    const offset = -d.getTimezoneOffset();
+    const sign = offset >= 0 ? "+" : "-";
+    const absOff = Math.abs(offset);
+    const hh = String(Math.floor(absOff / 60)).padStart(2, "0");
+    const mm = String(absOff % 60).padStart(2, "0");
+    const pad = (n) => String(n).padStart(2, "0");
+    return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}T${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}${sign}${hh}:${mm}`;
+}
+function argsToString(args) {
+    return args.map((a) => (typeof a === "string" ? a : String(a))).join(" ");
+}
+export function createAgentLogger(agentId, openclawDir) {
+    const baseDir = openclawDir || DEFAULT_OPENCLAW_DIR;
+    const logDir = path.join(baseDir, `workspace-${agentId}`, LOG_DIR_NAME);
+    let currentDate = "";
+    let fd = null;
+    function ensureFd() {
+        const date = todayStr();
+        if (fd !== null && date === currentDate)
+            return fd;
+        if (fd !== null) {
+            try {
+                fs.closeSync(fd);
+            }
+            catch { }
+            fd = null;
+        }
+        try {
+            fs.mkdirSync(logDir, { recursive: true });
+            const filePath = path.join(logDir, `palz-${date}.log`);
+            fd = fs.openSync(filePath, "a");
+            currentDate = date;
+            return fd;
+        }
+        catch {
+            return null;
+        }
+    }
+    function writeLine(level, args) {
+        const fileFd = ensureFd();
+        if (fileFd !== null) {
+            const line = `${formatTimestamp()} [${level}] ${argsToString(args)}\n`;
+            try {
+                fs.writeSync(fileFd, line);
+            }
+            catch { }
+        }
+    }
+    const logger = {
+        log: (...args) => {
+            console.log(...args);
+            writeLine("INFO", args);
+        },
+        error: (...args) => {
+            console.error(...args);
+            writeLine("ERROR", args);
+        },
+        close: () => {
+            if (fd !== null) {
+                try {
+                    fs.closeSync(fd);
+                }
+                catch { }
+                fd = null;
+                currentDate = "";
+            }
+        },
+    };
+    return logger;
+}

package/src/bot.js

@@ -209,7 +209,7 @@ export async function handlePalzMessage(params) {
         span.setAttribute("msg_id", msg.msg_id);
         span.setAttribute("sender_id", msg.sender_id);
         span.setAttribute("conversation_type", msg.conversation_type);
-        span.setAttribute("agent_id", msg.agent_id || "main");
+        span.setAttribute("agent_id", params.agentId);
         span.setAttribute("is_group", msg.conversation_type === "group");
         try {
             await _handlePalzMessageInner(params);
@@ -224,12 +224,12 @@ export async function handlePalzMessage(params) {
     });
 }
 async function _handlePalzMessageInner(params) {
-    const { cfg, msg, runtime, accountId } = params;
+    const { cfg, msg, runtime, accountId, agentId } = params;
     const log = typeof runtime?.log === "function" ? runtime.log : console.log;
     const error = typeof runtime?.error === "function" ? runtime.error : console.error;
     const tag = `palz[${accountId}]`;
     const isGroup = msg.conversation_type === "group";
-    const effectiveAgentId = msg.agent_id || "main";
+    const effectiveAgentId = agentId;
     const step1Filter = `[STEP 1/6 入站过滤] msg_id=${msg.msg_id} sender=${msg.sender_id} conv=${msg.conversation_id} type=${msg.conversation_type} agent=${effectiveAgentId}`;
     log(`${tag}: ${step1Filter}`);
     const span = trace.getActiveSpan();
@@ -325,7 +325,7 @@ async function _handlePalzMessageInner(params) {
             span?.addEvent(waitLog);
         }
         try {
-            await context.with(capturedCtx, () => dispatchPalzMessage({ cfg, msg, runtime, accountId }));
+            await context.with(capturedCtx, () => dispatchPalzMessage({ cfg, msg, runtime, accountId, agentId }));
             const doneLog = `[完成] msg_id=${msg.msg_id} 总耗时=${Date.now() - startMs}ms queueWait=${queueWaitMs}ms`;
             log(`${tag}: ${doneLog}`);
             span?.addEvent(doneLog);
@@ -357,7 +357,7 @@ async function dispatchPalzMessage(params) {
     });
 }
 async function _dispatchPalzMessageInner(params) {
-    const { cfg, msg, runtime, accountId } = params;
+    const { cfg, msg, runtime, accountId, agentId } = params;
     const log = typeof runtime?.log === "function" ? runtime.log : console.log;
     const tag = `palz[${accountId}]`;
     const core = getPalzRuntime();
@@ -403,13 +403,12 @@ async function _dispatchPalzMessageInner(params) {
         accountId,
         peer: { kind: peerKind, id: peerId },
     });
-    // IM 指定 agent_id 时走指定 agent，否则强制走 main
-    const effectiveAgentId = msg.agent_id || "main";
+    const effectiveAgentId = agentId;
     if (route.agentId !== effectiveAgentId) {
         const oldAgentId = route.agentId;
         route.agentId = effectiveAgentId;
         route.sessionKey = route.sessionKey.replace(`agent:${oldAgentId}:`, `agent:${effectiveAgentId}:`);
-        const step5Override = `[STEP 5 覆盖] agentId: ${oldAgentId} -> ${effectiveAgentId}, sessionKey=${route.sessionKey} (${msg.agent_id ? "IM指定" : "默认main"})`;
+        const step5Override = `[STEP 5 覆盖] agentId: ${oldAgentId} -> ${effectiveAgentId}, sessionKey=${route.sessionKey}`;
         log(`${tag}: ${step5Override}`);
         span?.addEvent(step5Override);
     }
@@ -736,3 +735,15 @@ async function _dispatchPalzMessageInner(params) {
         log(`${tag}: [TRACE] 解析 sessionFile 失败: ${String(err)}`);
     }
 }
+export function cleanupAgentCaches(agentIdToClean) {
+    const prefix = `${agentIdToClean}:`;
+    for (const key of chatHistories.keys()) {
+        if (key.startsWith(prefix))
+            chatHistories.delete(key);
+    }
+    for (const key of reasoningActivated.keys()) {
+        if (key.includes(`:agent:${agentIdToClean}:`))
+            reasoningActivated.delete(key);
+    }
+    reasoningScannedAgents.delete(agentIdToClean);
+}

package/src/channel.js

@@ -4,9 +4,11 @@
  * 实现 OpenClaw ChannelPlugin 接口，与飞书插件采用相同的架构模式。
  * 包含 config、messaging、outbound、gateway 等全套适配器。
  */
-import { listPalzAccountIds, resolvePalzAccount, resolveDefaultPalzAccountId, } from "./config.js";
+import { listPalzAccountIds, resolvePalzAccount, resolveDefaultPalzAccountId, resolvePalzConfig, PALZ_MANAGER_ACCOUNT_ID, } from "./config.js";
 import { palzOutbound } from "./outbound.js";
 import { normalizePalzTarget, looksLikePalzId } from "./targets.js";
+import { ConnectionManager } from "./connection-manager.js";
+import { startWorkspaceScanner } from "./workspace-scanner.js";
 export const palzPlugin = {
     id: "palz-connector",
     meta: {
@@ -69,22 +71,53 @@ export const palzPlugin = {
         startAccount: async (ctx) => {
             const log = typeof ctx.runtime?.log === "function" ? ctx.runtime.log : console.log;
             const logInfo = typeof ctx.log?.info === "function" ? ctx.log.info.bind(ctx.log) : log;
+            const error = typeof ctx.runtime?.error === "function" ? ctx.runtime.error : console.error;
             logInfo("palz-gateway: [startAccount] 输入: accountId=" + JSON.stringify(ctx.accountId));
-            const { monitorPalzProvider } = await import("./monitor.js");
-            const account = resolvePalzAccount({ cfg: ctx.cfg, accountId: ctx.accountId });
-            logInfo("palz-gateway: [startAccount] account解析: " + JSON.stringify({ accountId: account.accountId, enabled: account.enabled, configured: account.configured, name: account.name, botId: account.config.botId, streamUrl: account.config.streamUrl }));
-            if (!account.configured) {
-                const errMsg = "Palz account " + JSON.stringify(ctx.accountId) + " not configured (missing botId/streamUrl/apiBaseUrl)";
+            if (ctx.accountId !== PALZ_MANAGER_ACCOUNT_ID) {
+                logInfo("palz-gateway: [startAccount] non-manager account " + JSON.stringify(ctx.accountId) + ", returning abort-pending promise");
+                return new Promise((resolve) => {
+                    if (ctx.abortSignal?.aborted) {
+                        resolve();
+                        return;
+                    }
+                    ctx.abortSignal?.addEventListener("abort", () => resolve(), { once: true });
+                });
+            }
+            const baseConfig = resolvePalzConfig(ctx.cfg);
+            if (!baseConfig.streamUrl || !baseConfig.apiBaseUrl) {
+                const errMsg = "Palz manager not configured (missing streamUrl/apiBaseUrl)";
                 logInfo("palz-gateway: [startAccount] 失败: " + errMsg);
                 throw new Error(errMsg);
             }
-            logInfo("palz-gateway: [startAccount] 启动WebSocket监听 botId=" + account.config.botId + " streamUrl=" + account.config.streamUrl);
-            return monitorPalzProvider({
+            logInfo("palz-gateway: [startAccount] 启动 manager, streamUrl=" + baseConfig.streamUrl);
+            const manager = new ConnectionManager({
                 cfg: ctx.cfg,
-                config: account.config,
+                baseConfig,
                 runtime: ctx.runtime,
-                abortSignal: ctx.abortSignal,
-                accountId: ctx.accountId,
+                log: logInfo,
+                error,
+            });
+            const scanner = startWorkspaceScanner({
+                onSnapshot: (releaseNames) => {
+                    manager.reconcile(releaseNames).catch((err) => {
+                        error("palz-gateway: reconcile error: " + String(err));
+                    });
+                },
+                log: logInfo,
+                error,
+            });
+            return new Promise((resolve) => {
+                const onAbort = () => {
+                    logInfo("palz-gateway: [startAccount] abort received, shutting down manager");
+                    scanner.stop();
+                    manager.shutdown();
+                    resolve();
+                };
+                if (ctx.abortSignal?.aborted) {
+                    onAbort();
+                    return;
+                }
+                ctx.abortSignal?.addEventListener("abort", onAbort, { once: true });
             });
         },
     },

package/src/config.js

@@ -12,7 +12,7 @@ import path from "path";
 import { fileURLToPath } from "url";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
-const DEFAULT_ACCOUNT_ID = "__default__";
+export const PALZ_MANAGER_ACCOUNT_ID = "palz-manager";
 const DEFAULT_SESSION_TIMEOUT = 30 * 60 * 1000;
 const DEFAULT_CONFIG_FILENAME = "palz-connector.config.json";
 let _cachedFileConfig = null;
@@ -55,11 +55,11 @@ function loadConfigFile() {
     _cachedFileConfig = {};
     return _cachedFileConfig;
 }
-export function resolvePalzConfig(_cfg) {
+export function resolvePalzConfig(_cfg, botId) {
     const file = loadConfigFile();
     const config = {
         enabled: file.enabled !== false,
-        botId: process.env.botID || "",
+        botId: botId ?? "",
         streamUrl: file.streamUrl || "",
         apiBaseUrl: file.apiBaseUrl || "",
         clawGatewayUrl: file.clawGatewayUrl || "",
@@ -70,41 +70,46 @@ export function resolvePalzConfig(_cfg) {
     };
     if (!_configLoggedOnce) {
         _configLoggedOnce = true;
-        console.log("palz-config: [resolve] input: env.botID=" + JSON.stringify(process.env.botID) + " configFile=" + JSON.stringify(file));
+        console.log("palz-config: [resolve] input: botId=" + JSON.stringify(botId) + " configFile=" + JSON.stringify(file));
         console.log("palz-config: [resolve] output: " + JSON.stringify(config));
     }
     return config;
 }
 export function listPalzAccountIds(_cfg) {
     const config = resolvePalzConfig();
-    const ids = !config.enabled || !config.botId ? [] : [config.botId];
+    const ids = config.enabled ? [PALZ_MANAGER_ACCOUNT_ID] : [];
     if (!_configAdapterLoggedOnce) {
         console.log("palz-config: [listAccountIds] output: " + JSON.stringify(ids));
     }
     return ids;
 }
 export function resolveDefaultPalzAccountId(_cfg) {
-    const config = resolvePalzConfig();
-    const id = config.botId || DEFAULT_ACCOUNT_ID;
     if (!_configAdapterLoggedOnce) {
-        console.log("palz-config: [defaultAccountId] output: " + JSON.stringify(id));
+        console.log("palz-config: [defaultAccountId] output: " + JSON.stringify(PALZ_MANAGER_ACCOUNT_ID));
     }
-    return id;
+    return PALZ_MANAGER_ACCOUNT_ID;
 }
 export function resolvePalzAccount(params) {
-    const config = resolvePalzConfig();
-    const accountId = params.accountId?.trim() || config.botId || DEFAULT_ACCOUNT_ID;
+    const rawAccountId = params.accountId?.trim() || "";
+    const isManager = !rawAccountId || rawAccountId === PALZ_MANAGER_ACCOUNT_ID;
+    const accountId = isManager ? PALZ_MANAGER_ACCOUNT_ID : rawAccountId;
+    const botId = isManager ? "" : rawAccountId;
+    const config = resolvePalzConfig(params.cfg, botId);
     const result = {
         accountId,
         enabled: config.enabled !== false,
-        configured: Boolean(config.botId && config.streamUrl && config.apiBaseUrl),
-        name: "Palz Connector (" + (config.botId || "unconfigured") + ")",
+        configured: isManager
+            ? Boolean(config.streamUrl && config.apiBaseUrl)
+            : Boolean(botId && config.streamUrl && config.apiBaseUrl),
+        name: isManager
+            ? "Palz Connector (manager)"
+            : "Palz Connector (" + botId + ")",
         config,
     };
     if (!_configAdapterLoggedOnce) {
         _configAdapterLoggedOnce = true;
         console.log("palz-config: [resolveAccount] input: accountId=" + JSON.stringify(params.accountId));
-        console.log("palz-config: [resolveAccount] output: " + JSON.stringify({ accountId: result.accountId, enabled: result.enabled, configured: result.configured, name: result.name }));
+        console.log("palz-config: [resolveAccount] output: " + JSON.stringify({ accountId: result.accountId, enabled: result.enabled, configured: result.configured, name: result.name, botId }));
     }
     return result;
 }

package/src/connection-manager.js

@@ -0,0 +1,135 @@
+import { monitorPalzProvider } from "./monitor.js";
+import { cleanupAgentCaches } from "./bot.js";
+import { createAgentLogger } from "./agent-logger.js";
+const BATCH_SIZE = 10;
+const BATCH_DELAY_MS = 500;
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export class ConnectionManager {
+    connections = new Map();
+    cfg;
+    baseConfig;
+    runtime;
+    log;
+    error;
+    reconciling = false;
+    shutdownCalled = false;
+    constructor(params) {
+        this.cfg = params.cfg;
+        this.baseConfig = params.baseConfig;
+        this.runtime = params.runtime;
+        this.log = params.log ?? console.log;
+        this.error = params.error ?? console.error;
+    }
+    async reconcile(desiredReleaseNames) {
+        if (this.shutdownCalled)
+            return;
+        if (this.reconciling) {
+            this.log("connection-manager: reconcile skipped (already in progress)");
+            return;
+        }
+        this.reconciling = true;
+        try {
+            const desired = new Set(desiredReleaseNames);
+            const current = new Set(this.connections.keys());
+            const toRemove = [...current].filter((name) => !desired.has(name));
+            const toAdd = [...desired].filter((name) => !current.has(name));
+            for (const name of toRemove) {
+                this.removeAgent(name);
+            }
+            for (let i = 0; i < toAdd.length; i++) {
+                if (this.shutdownCalled)
+                    break;
+                this.addAgent(toAdd[i]);
+                if (i > 0 && i % BATCH_SIZE === 0 && i < toAdd.length - 1) {
+                    this.log(`connection-manager: batch pause after ${i} connections`);
+                    await sleep(BATCH_DELAY_MS);
+                }
+            }
+            if (toAdd.length > 0 || toRemove.length > 0) {
+                this.log(`connection-manager: reconcile done, added=${toAdd.length} removed=${toRemove.length} active=${this.connections.size}`);
+            }
+        }
+        catch (err) {
+            this.error(`connection-manager: reconcile error: ${err}`);
+        }
+        finally {
+            this.reconciling = false;
+        }
+    }
+    addAgent(releasename) {
+        if (this.connections.has(releasename))
+            return;
+        if (this.shutdownCalled)
+            return;
+        const abortController = new AbortController();
+        const config = { ...this.baseConfig, botId: releasename };
+        const logger = createAgentLogger(releasename);
+        const agentRuntime = { ...this.runtime, log: logger.log, error: logger.error };
+        this.log(`connection-manager: adding agent "${releasename}"`);
+        const promise = monitorPalzProvider({
+            cfg: this.cfg,
+            config,
+            runtime: agentRuntime,
+            abortSignal: abortController.signal,
+            accountId: releasename,
+            agentId: releasename,
+        });
+        const entry = {
+            releasename,
+            abortController,
+            promise,
+            startedAt: Date.now(),
+            logger,
+        };
+        this.connections.set(releasename, entry);
+        promise
+            .catch((err) => {
+            this.error(`connection-manager: agent "${releasename}" exited with error: ${err}`);
+        })
+            .finally(() => {
+            if (this.connections.get(releasename) === entry) {
+                this.connections.delete(releasename);
+                this.log(`connection-manager: agent "${releasename}" cleaned up from map`);
+            }
+        });
+    }
+    removeAgent(releasename) {
+        const entry = this.connections.get(releasename);
+        if (!entry)
+            return;
+        this.log(`connection-manager: removing agent "${releasename}"`);
+        this.connections.delete(releasename);
+        entry.abortController.abort();
+        entry.logger.close();
+        try {
+            cleanupAgentCaches(releasename);
+        }
+        catch (err) {
+            this.error(`connection-manager: cache cleanup error for "${releasename}": ${err}`);
+        }
+    }
+    getActiveAgents() {
+        return [...this.connections.keys()].sort();
+    }
+    shutdown() {
+        if (this.shutdownCalled)
+            return;
+        this.shutdownCalled = true;
+        this.log(`connection-manager: shutting down ${this.connections.size} connection(s)`);
+        for (const [name, entry] of this.connections) {
+            try {
+                entry.abortController.abort();
+            }
+            catch (err) {
+                this.error(`connection-manager: abort error for "${name}": ${err}`);
+            }
+            try {
+                entry.logger.close();
+            }
+            catch { }
+        }
+        this.connections.clear();
+    }
+}

package/src/monitor.js

@@ -9,10 +9,11 @@ import { handlePalzMessage } from "./bot.js";
 import { reportPalzActivity } from "./activity.js";
 import { tracer, extractTraceparentContext, SpanStatusCode } from "./tracing.js";
 const WS_CONNECT_TIMEOUT_MS = 15_000;
-const WS_PING_INTERVAL_MS = 30_000;
+const WS_PING_INTERVAL_MS = 15_000;
 const WS_PONG_TIMEOUT_MS = 70_000;
 export async function monitorPalzProvider(params) {
-    const { cfg, config, runtime, abortSignal, accountId } = params;
+    const { cfg, config, runtime, abortSignal, accountId, agentId } = params;
+    const effectiveAgentId = agentId || accountId;
     const log = typeof runtime?.log === "function" ? runtime.log : console.log;
     const error = typeof runtime?.error === "function" ? runtime.error : console.error;
     if (!config.botId || !config.streamUrl) {
@@ -183,7 +184,6 @@ export async function monitorPalzProvider(params) {
                         try {
                             lastPingAt = Date.now();
                             ws.ping();
-                            log(`palz[${accountId}]: [WS_HEARTBEAT] ping sent, last_pong_ago=${timeSinceLastPong}ms`);
                         }
                         catch (err) {
                             error(`palz[${accountId}]: [WS_HEARTBEAT] ping failed: ${err.message ?? err}`);
@@ -193,9 +193,11 @@ export async function monitorPalzProvider(params) {
             });
             ws.on("pong", () => {
                 const now = Date.now();
-                const rttMs = lastPingAt > 0 ? now - lastPingAt : null;
+                const rttMs = lastPingAt > 0 ? now - lastPingAt : 0;
                 lastPongAt = now;
-                log(`palz[${accountId}]: [WS_HEARTBEAT] pong received${rttMs === null ? "" : `, rtt=${rttMs}ms`}`);
+                if (rttMs > 1000) {
+                    log(`palz[${accountId}]: [WS_HEARTBEAT] slow pong, rtt=${rttMs}ms`);
+                }
             });
             ws.on("message", (data) => {
                 const receivedAt = new Date();
@@ -227,6 +229,7 @@ export async function monitorPalzProvider(params) {
                                 msg,
                                 runtime,
                                 accountId,
+                                agentId: effectiveAgentId,
                             }).catch((err) => {
                                 error(`palz[${accountId}]: [WS_RECV] handlePalzMessage unhandled error: ${err.message ?? err}`);
                             });

package/src/outbound.js

@@ -4,7 +4,7 @@
  * 实现 ChannelOutboundAdapter 接口，供 OpenClaw Runtime 发送主动消息
  * （如定时任务 cron delivery、跨渠道路由等）。
  */
-import { resolvePalzAccount } from "./config.js";
+import { resolvePalzAccount, PALZ_MANAGER_ACCOUNT_ID } from "./config.js";
 import { sendToPalzIM } from "./send.js";
 import { loadMediaAsOssUrl } from "./media.js";
 import { parsePalzTarget } from "./targets.js";
@@ -25,6 +25,11 @@ export const palzOutbound = {
         const { cfg, to, text, accountId } = ctx;
         const log = typeof ctx.log === "function" ? ctx.log : console.log;
         log(`palz-outbound: [sendText] 输入: to="${to}" accountId="${accountId}" textLen=${text?.length || 0} text="${(text || "").slice(0, 120)}"`);
+        if (accountId === PALZ_MANAGER_ACCOUNT_ID) {
+            const err = new Error("Cannot send messages with manager account " + PALZ_MANAGER_ACCOUNT_ID);
+            log(`palz-outbound: [sendText] 拒绝: ${err.message}`);
+            throw err;
+        }
         const account = resolvePalzAccount({ cfg, accountId });
         const { senderId, lobsterId, conversationId, conversationType } = parsePalzTarget(to);
         log(`palz-outbound: [sendText] 解析: senderId="${senderId}" lobsterId="${lobsterId}" conversationId="${conversationId}" conversationType="${conversationType}" botId=${account.config.botId}`);
@@ -37,6 +42,7 @@ export const palzOutbound = {
             senderId,
             conversationType,
             lobsterId,
+            log,
         });
         const output = { channel: "palz-connector", messageId: Date.now().toString() };
         log(`palz-outbound: [sendText] 输出: ${JSON.stringify(output)} sendResult=${JSON.stringify(result)}`);
@@ -45,6 +51,11 @@ export const palzOutbound = {
     sendMedia: async (ctx) => {
         const { cfg, to, text, mediaUrl, accountId, mediaLocalRoots } = ctx;
         const log = typeof ctx.log === "function" ? ctx.log : console.log;
+        if (accountId === PALZ_MANAGER_ACCOUNT_ID) {
+            const err = new Error("Cannot send media with manager account " + PALZ_MANAGER_ACCOUNT_ID);
+            log(`palz-outbound: [sendMedia] 拒绝: ${err.message}`);
+            throw err;
+        }
         const account = resolvePalzAccount({ cfg, accountId });
         const { senderId, lobsterId, conversationId, conversationType } = parsePalzTarget(to);
         log(`palz-outbound: [sendMedia] 输入: to="${to}" accountId="${accountId}" textLen=${text?.length || 0} mediaUrl="${(mediaUrl || "").slice(0, 200)}"`);
@@ -72,6 +83,7 @@ export const palzOutbound = {
             senderId,
             conversationType,
             lobsterId,
+            log,
         });
         const output = { channel: "palz-connector", messageId: Date.now().toString() };
         log(`palz-outbound: [sendMedia] 输出: ${JSON.stringify(output)} sendResult=${JSON.stringify(result)}`);

package/src/reply-dispatcher.js

@@ -62,6 +62,8 @@ export function createPalzReplyDispatcher(params) {
             palzMsgType,
             toolContent,
             passthrough,
+            log,
+            error,
         });
         log(`${tag}: [DISPATCHER←sendToIM] 输出: ${JSON.stringify(result)}`);
         return result;

package/src/send.js

@@ -36,7 +36,9 @@ function normalizeContent(content) {
     return content;
 }
 async function _sendToPalzIMInner(params) {
-    const { config, conversationId, content: rawContent, conversationType, msgId, senderId, stream, msgType, groupId, lobsterId, palzMsgType, toolContent, passthrough } = params;
+    const { config, conversationId, content: rawContent, conversationType, msgId, senderId, stream, msgType, groupId, lobsterId, palzMsgType, toolContent, passthrough, log: paramLog, error: paramError } = params;
+    const log = paramLog ?? console.log;
+    const error = paramError ?? console.error;
     const content = normalizeContent(rawContent);
     const url = `${config.apiBaseUrl}/bot/send`;
     const resolvedMsgId = msgId || nextMsgId();
@@ -75,7 +77,7 @@ async function _sendToPalzIMInner(params) {
     }
     const reqBodyStr = JSON.stringify(reqBody);
     const reqLog = `[HTTP_REQ] POST ${url} body_length=${reqBodyStr.length}\n  request_body=${reqBodyStr}`;
-    console.log(`palz-send: ${reqLog}`);
+    log(`palz-send: ${reqLog}`);
     span?.addEvent(reqLog);
     // 构建请求 headers，注入 Traceparent
     const headers = { "Content-Type": "application/json" };
@@ -99,7 +101,7 @@ async function _sendToPalzIMInner(params) {
         const elapsedMs = Date.now() - startMs;
         const reason = err?.name === "AbortError" ? `timeout ${SEND_TIMEOUT_MS}ms` : (err?.message ?? String(err));
         const failLog = `[HTTP_RES] ERROR elapsed=${elapsedMs}ms reason=${reason}`;
-        console.error(`palz-send: ${failLog}`);
+        error(`palz-send: ${failLog}`);
         span?.addEvent(failLog);
         throw err?.name === "AbortError"
             ? new Error(`Palz send timeout after ${SEND_TIMEOUT_MS}ms`)
@@ -117,12 +119,12 @@ async function _sendToPalzIMInner(params) {
     catch { }
     if (!response.ok) {
         const failLog = `[HTTP_RES] FAILED status=${response.status} elapsed=${elapsedMs}ms\n  response_headers=${JSON.stringify(Object.fromEntries(response.headers.entries()))}\n  response_body=${rawText.slice(0, 500)}`;
-        console.error(`palz-send: ${failLog}`);
+        error(`palz-send: ${failLog}`);
         span?.addEvent(failLog);
         throw new Error(`Palz send failed: ${response.status} ${rawText}`);
     }
     const okLog = `[HTTP_RES] OK status=${response.status} elapsed=${elapsedMs}ms msg_id=${resolvedMsgId}${traceparent ? ` Traceparent=${traceparent}` : ""}\n  response_body=${rawText.slice(0, 500)}`;
-    console.log(`palz-send: ${okLog}`);
+    log(`palz-send: ${okLog}`);
     span?.addEvent(okLog);
     return body;
 }

package/src/workspace-scanner.js

@@ -0,0 +1,97 @@
+import fs from "fs";
+import path from "path";
+import os from "os";
+const DEFAULT_OPENCLAW_DIR = path.join(os.homedir(), ".openclaw");
+const WORKSPACE_PREFIX = "workspace-";
+const DEFAULT_SCAN_INTERVAL_MS = 5000;
+const VALID_RELEASENAME_RE = /^[a-z0-9][a-z0-9_-]{0,63}$/;
+export function scanWorkspaceReleaseNames(openclawDir) {
+    const dir = openclawDir || DEFAULT_OPENCLAW_DIR;
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const releaseNames = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory()) {
+            if (entry.isSymbolicLink()) {
+                try {
+                    const fullPath = path.join(dir, entry.name);
+                    const stat = fs.statSync(fullPath);
+                    if (!stat.isDirectory())
+                        continue;
+                }
+                catch {
+                    continue;
+                }
+            }
+            else {
+                continue;
+            }
+        }
+        if (!entry.name.startsWith(WORKSPACE_PREFIX))
+            continue;
+        const releasename = entry.name.slice(WORKSPACE_PREFIX.length);
+        if (!releasename)
+            continue;
+        if (!VALID_RELEASENAME_RE.test(releasename))
+            continue;
+        releaseNames.push(releasename);
+    }
+    return releaseNames.sort();
+}
+export function startWorkspaceScanner(opts) {
+    const dir = opts.openclawDir || DEFAULT_OPENCLAW_DIR;
+    const intervalMs = opts.intervalMs ?? DEFAULT_SCAN_INTERVAL_MS;
+    const log = opts.log ?? console.log;
+    const error = opts.error ?? console.error;
+    let stopped = false;
+    let scanning = false;
+    let timer = null;
+    function doScan() {
+        if (stopped)
+            return [];
+        if (scanning)
+            return [];
+        scanning = true;
+        try {
+            const names = scanWorkspaceReleaseNames(dir);
+            try {
+                opts.onSnapshot(names);
+            }
+            catch (err) {
+                error(`workspace-scanner: onSnapshot error: ${err}`);
+            }
+            return names;
+        }
+        catch (err) {
+            error(`workspace-scanner: scan error: ${err}`);
+            return [];
+        }
+        finally {
+            scanning = false;
+        }
+    }
+    log(`workspace-scanner: starting, dir=${dir} interval=${intervalMs}ms`);
+    const initialNames = doScan();
+    log(`workspace-scanner: initial scan found ${initialNames.length} workspace(s): [${initialNames.join(", ")}]`);
+    timer = setInterval(doScan, intervalMs);
+    return {
+        stop() {
+            if (stopped)
+                return;
+            stopped = true;
+            if (timer) {
+                clearInterval(timer);
+                timer = null;
+            }
+            log("workspace-scanner: stopped");
+        },
+        scanNow() {
+            return doScan();
+        },
+    };
+}