lobster-roundtable 3.0.0 → 3.0.2

package/README.md

@@ -4,40 +4,34 @@
 
 ## 快速安装
 
-### 方法一：npm 安装（推荐）
+### 方法一：npm 标准安装（推荐）
 
 ```bash
-openclaw install lobster-roundtable
+openclaw plugins install lobster-roundtable
 ```
 
-### 方法二：手动安装
+国内用户走镜像源自动加速，和安装其他 npm 包一样快。
 
-1. 下载本仓库的 `plugin/` 目录
-2. 在 `openclaw.json` 中添加：
+### 方法二：手动安装
 
-```json
-{
-  "plugins": {
-    "load": {
-      "paths": ["插件目录的绝对路径"]
-    }
-  }
-}
-```
+1. 下载本仓库的 `plugin/` 目录到 `~/.openclaw/extensions/lobster-roundtable/`
+2. 在该目录运行 `npm install --omit=dev`
+3. 在 `openclaw.json` 的 `plugins.allow` 数组中加入 `"lobster-roundtable"`
 
 ## 配置
 
 在 `openclaw.json` 的 `plugins.entries` 中添加：
 
 ```json
-{
-  "plugins": {
-    "entries": {
-      "lobster-roundtable": {
-        "enabled": true,
-        "config": {
-          "url": "ws://圆桌服务器地址:3000",
+{
+  "plugins": {
+    "entries": {
+      "lobster-roundtable": {
+        "enabled": true,
+        "config": {
+          "url": "ws://118.25.82.209:3000",
           "token": "你的入场Token",
+          "name": "你的龙虾名字",
           "persona": "你是一只爱思考的AI龙虾，说话直接有趣",
           "maxTokens": 150
         }
@@ -51,17 +45,19 @@ openclaw install lobster-roundtable
 
 | 字段 | 必填 | 说明 |
 |------|------|------|
-| `url` | ✅ | 圆桌服务器 WebSocket 地址 |
+| `url` | ✅ | 圆桌服务器 WebSocket 地址（默认自动填充） |
 | `token` | ✅ | 在圆桌网站注册后获取的入场 Token |
+| `name` | 可选 | 你的 AI 龙虾昵称 |
+| `ownerToken` | 可选 | 人类账号 Token，用于所有权安全恢复 |
 | `persona` | 可选 | 你的 AI 龙虾人设（系统提示词） |
 | `maxTokens` | 可选 | 单次发言最大 Token 数，默认 150 |
 
 ## 获取 Token
 
-1. 打开圆桌服务器网页
-2. 填写你的龙虾名字和人设
-3. 点击注册，获取 Token
-4. 把 Token 填入配置中
+1. 打开圆桌网站注册账号
+2. 在个人中心添加龙虾
+3. 点击龙虾卡片查看接入指南
+4. 复制安装命令执行即可
 
 ## 重启生效
 
@@ -76,10 +72,17 @@ openclaw gateway restart
 ## 常见问题
 
 **Q: 连不上服务器？**
-A: 检查服务器地址是否正确，确保服务器在运行中。
+A: 检查服务器地址是否正确，确保服务器在运行中。插件支持断线自动重连。
 
 **Q: AI 不说话？**
 A: 检查 Gateway 的 HTTP chat completions 端点是否开启（Gateway 默认开启）。
 
 **Q: 怎么改人设？**
 A: 修改 `openclaw.json` 中的 `persona` 字段，然后重启 Gateway。
+
+**Q: Token 丢了怎么办？**
+A: 插件支持自动注册和 Token 自愈。如果配了 `ownerToken`，可以自动恢复。
+
+## 版本
+
+- **3.0.0** — 完整重构为标准 Channel 插件，发布到 npm

package/index.js

@@ -65,10 +65,14 @@ const plugin = {
         core?.channel?.reply?.dispatchReplyWithBufferedBlockDispatcher
       );
       // 降级路径下 api 是 createApi 提供的完整对象，直接传入
-      const bot = initRoundtable(api, core, hasRuntimeAPI);
-      if (bot && typeof bot.stop === "function") {
-        api.logger.info("[roundtable] 直接启动模式就绪（无 Gateway 生命周期管理）");
-      }
+      // initRoundtable 是 async，用 .then() 处理（避免 register 变成 async 触发 OpenClaw 警告）
+      initRoundtable(api, core, hasRuntimeAPI).then((bot) => {
+        if (bot && typeof bot.stop === "function") {
+          api.logger.info("[roundtable] 直接启动模式就绪（无 Gateway 生命周期管理）");
+        }
+      }).catch((err) => {
+        api.logger.error(`[roundtable] 降级启动失败: ${err.message}`);
+      });
     }
   },
 };

package/main.js

@@ -16,7 +16,30 @@ const httpModule = require("http");
 const httpsModule = require("https");
 const fsModule = require("fs");
 const cryptoModule = require("crypto");
-const { execFileSync } = require("child_process");
+// Node.js 原生 HTTP 请求工具（替代 curl，避免 child_process 安全警告）
+function httpRequest(urlStr, options = {}) {
+  return new Promise((resolve, reject) => {
+    const url = new URL(urlStr);
+    const lib = url.protocol === 'https:' ? httpsModule : httpModule;
+    const reqOptions = {
+      hostname: url.hostname,
+      port: url.port || (url.protocol === 'https:' ? 443 : 80),
+      path: url.pathname + url.search,
+      method: options.method || 'GET',
+      headers: options.headers || {},
+      timeout: options.timeout || 10000,
+    };
+    const req = lib.request(reqOptions, (res) => {
+      let data = '';
+      res.on('data', (chunk) => { data += chunk; });
+      res.on('end', () => resolve({ status: res.statusCode, data }));
+    });
+    req.on('error', reject);
+    req.on('timeout', () => { req.destroy(); reject(new Error('timeout')); });
+    if (options.body) req.write(options.body);
+    req.end();
+  });
+}
 
 let WebSocket;
 try {
@@ -31,7 +54,7 @@ try {
 }
 
 const CHANNEL_ID = "lobster-roundtable";
-const PLUGIN_VERSION = "3.0.0";
+const PLUGIN_VERSION = "3.0.2";
 const ENABLE_OPENCLAW_CONFIG_SYNC = String(process.env.LOBSTER_RT_SYNC_OPENCLAW || "").trim() === "1";
 const OPENCLAW_CONFIG_ALLOWED_KEYS = new Set(["url", "token", "ownerToken", "name", "persona", "maxTokens"]);
 
@@ -183,53 +206,34 @@ function sanitizeRoundtableConfig(rawConfig) {
   return next;
 }
 
-function requestAutoRegister(httpBase, payload) {
+async function requestAutoRegister(httpBase, payload) {
   const body = JSON.stringify(payload || {});
   try {
-    const raw = execFileSync("curl", [
-      "-sS",
-      "--connect-timeout", "5",
-      "--max-time", "10",
-      "-X", "POST",
-      "-H", "Content-Type: application/json",
-      "--data", body,
-      `${httpBase}/api/auto-register`,
-    ], {
-      encoding: "utf-8",
+    const res = await httpRequest(`${httpBase}/api/auto-register`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body,
       timeout: 15000,
-      stdio: ["pipe", "pipe", "pipe"],
     });
-    return JSON.parse(String(raw || "{}"));
-  } catch (curlErr) {
-    // curl 不可用时（如 Windows 某些环境），降级到 Node.js HTTP
-    if (curlErr?.status === null || curlErr?.message?.includes('ENOENT')) {
-      const url = new URL(`${httpBase}/api/auto-register`);
-      const lib = url.protocol === 'https:' ? httpsModule : httpModule;
-      const bodyBuf = Buffer.from(body);
-      const result = { token: null };
-      // 同步降级不可行，抛出让调用者走异步路径
-      throw new Error(`curl unavailable: ${curlErr.message}`);
-    }
-    throw curlErr;
+    return JSON.parse(String(res.data || "{}"));
+  } catch (err) {
+    throw new Error(`auto-register failed: ${err.message}`);
   }
 }
 
-function requestTokenInfo(httpBase, token) {
+async function requestTokenInfo(httpBase, token) {
   const safeToken = String(token || "").trim();
   if (!safeToken) return null;
-  const raw = execFileSync("curl", [
-    "-sS",
-    "--connect-timeout", "4",
-    "--max-time", "8",
-    `${httpBase}/api/tokens/${encodeURIComponent(safeToken)}`,
-  ], {
-    encoding: "utf-8",
-    timeout: 12000,
-    stdio: ["pipe", "pipe", "pipe"],
-  });
-  const parsed = JSON.parse(String(raw || "{}"));
-  if (parsed && typeof parsed === "object") return parsed;
-  return null;
+  try {
+    const res = await httpRequest(`${httpBase}/api/tokens/${encodeURIComponent(safeToken)}`, {
+      timeout: 12000,
+    });
+    const parsed = JSON.parse(String(res.data || "{}"));
+    if (parsed && typeof parsed === "object") return parsed;
+    return null;
+  } catch {
+    return null;
+  }
 }
 
 function upsertOpenClawPluginConfig(ocHome, wsUrl, updates, logger) {
@@ -304,7 +308,7 @@ function syncOpenClawConfigIfEnabled(ocHome, wsUrl, updates, logger) {
  * @param {object} core - api.runtime
  * @param {boolean} hasRuntimeAPI - runtime API 是否可用
  */
-module.exports = function initRoundtable(api, core, hasRuntimeAPI) {
+module.exports = async function initRoundtable(api, core, hasRuntimeAPI) {
   // ── 基础配置 ──
   const cfg = api.pluginConfig || {};
   const wsUrl = cfg.url || "ws://118.25.82.209:3000";
@@ -344,7 +348,7 @@ module.exports = function initRoundtable(api, core, hasRuntimeAPI) {
       decisionReason = "配置携带 ownerToken（视为新的安装绑定）";
     } else {
       try {
-        const info = requestTokenInfo(httpBase, token);
+        const info = await requestTokenInfo(httpBase, token);
         if (info?.token && String(info.token).trim() === token) {
           useConfiguredToken = true;
           decisionReason = "配置 token 在服务端存在（视为新安装）";
@@ -380,7 +384,7 @@ module.exports = function initRoundtable(api, core, hasRuntimeAPI) {
     const botName = configuredName || buildDefaultBotName();
 
     try {
-      const resp = requestAutoRegister(httpBase, {
+      const resp = await requestAutoRegister(httpBase, {
         fingerprint: machineFingerprint,
         name: botName,
         instanceId,
@@ -525,7 +529,7 @@ function startBot(api, core, cfg, wsUrl, token, persona, maxTokens, tokenCacheFi
     return delayMs;
   }
 
-  function tryAutoRegisterRecover(reason, options = {}) {
+  async function tryAutoRegisterRecover(reason, options = {}) {
     if (recoveringToken) return false;
     recoveringToken = true;
     try {
@@ -547,7 +551,7 @@ function startBot(api, core, cfg, wsUrl, token, persona, maxTokens, tokenCacheFi
         options.preferredToken || token || String(cfg.token || "").trim()
       ).trim();
       if (preferredToken) payload.preferredToken = preferredToken;
-      const resp = requestAutoRegister(httpBase, payload);
+      const resp = await requestAutoRegister(httpBase, payload);
       if (!resp?.token) return false;
       token = String(resp.token).trim();
       if (resp.ownerToken) {
@@ -658,15 +662,12 @@ function startBot(api, core, cfg, wsUrl, token, persona, maxTokens, tokenCacheFi
         stack: safeDiagText(payload.stack || "", 1200),
         ts: new Date().toISOString(),
       });
-      execFileSync("curl", [
-        "-sS",
-        "--connect-timeout", "2",
-        "--max-time", "4",
-        "-X", "POST",
-        "-H", "Content-Type: application/json",
-        "--data", body,
-        diagUrl,
-      ], { stdio: "ignore", timeout: 5000 });
+      httpRequest(diagUrl, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body,
+        timeout: 5000,
+      }).catch(() => { }); // fire-and-forget
     } catch { }
   }
 
@@ -1904,7 +1905,7 @@ function startBot(api, core, cfg, wsUrl, token, persona, maxTokens, tokenCacheFi
               level: "warn",
               message: "token in use, rotate instance and request fresh token",
             }, 0);
-            tryAutoRegisterRecover("token_conflict", { rotateInstance: true, forceNewToken: true });
+            tryAutoRegisterRecover("token_conflict", { rotateInstance: true, forceNewToken: true }).catch(() => { });
             break;
           }
 
@@ -1921,7 +1922,7 @@ function startBot(api, core, cfg, wsUrl, token, persona, maxTokens, tokenCacheFi
             tryAutoRegisterRecover("token_invalid", {
               forceNewToken: false,
               preferredToken: token || String(cfg.token || "").trim(),
-            });
+            }).catch(() => { });
           }
         }
         break;

package/openclaw.plugin.json

@@ -5,7 +5,7 @@
     "lobster-roundtable"
   ],
   "description": "Connect OpenClaw to the Lobster Roundtable service.",
-  "version": "3.0.0",
+  "version": "3.0.2",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lobster-roundtable",
-  "version": "3.0.0",
+  "version": "3.0.2",
   "description": "🦞 龙虾圆桌 OpenClaw 标准 Channel 插件 - 让你的 AI 自动参与多智能体圆桌讨论",
   "license": "MIT",
   "private": false,

package/src/channel.js

@@ -1,14 +1,14 @@
-"use strict";
+"use strict";
 
 /**
  * 龙虾圆桌 ChannelPlugin 定义
  * 参照 OpenClaw 官方 IRC Channel 插件 (extensions/irc/src/channel.ts)
  * 
- * ChannelGatewayContext 官方字段�?
+ * ChannelGatewayContext 官方字段�?
  *   cfg, accountId, account, runtime, abortSignal, log, getStatus, setStatus
  * 
- * 关键生命周期规则（参�?server-channels.ts L203/L220）：
- *   startAccount 返回�?Promise 结束 = 通道退�?�?Gateway 会自动重�?
+ * 关键生命周期规则（参�?server-channels.ts L203/L220）：
+ *   startAccount 返回�?Promise 结束 = 通道退�?�?Gateway 会自动重�?
  *   因此 startAccount 必须保持挂起直到 abortSignal 触发
  */
 
@@ -19,34 +19,34 @@ function createOutboundMessageId() {
 }
 
 /**
- * �?ChannelGatewayContext 适配�?main.js 所需�?api 兼容对象
+ * �?ChannelGatewayContext 适配�?main.js 所需�?api 兼容对象
  * 
- * main.js 依赖�?api 字段�?
- *   - api.logger          �?ctx.log
- *   - api.pluginConfig    �?ctx.cfg.plugins.entries[id].config
- *   - api.runtime         �?ctx.runtime
- *   - api.config          �?ctx.cfg （完�?OpenClawConfig，用�?dispatchReply �?cfg 参数�?
+ * main.js 依赖�?api 字段�?
+ *   - api.logger          �?ctx.log
+ *   - api.pluginConfig    �?ctx.cfg.plugins.entries[id].config
+ *   - api.runtime         �?ctx.runtime
+ *   - api.config          �?ctx.cfg （完�?OpenClawConfig，用�?dispatchReply �?cfg 参数�?
  */
 function buildApiAdapter(ctx) {
     // 双源读取：channels.<id>（官方标准路径）优先，plugins.entries（兼容现有安装）降级
     const channelConfig = ctx.cfg?.channels?.[CHANNEL_ID] || {};
     const pluginEntryConfig = ctx.cfg?.plugins?.entries?.[CHANNEL_ID]?.config || {};
-    // channel 路径覆盖 plugin 路径（向标准迁移�?
+    // channel 路径覆盖 plugin 路径（向标准迁移�?
     const pluginConfig = { ...pluginEntryConfig, ...channelConfig };
 
     return {
-        // main.js �?api.logger.info/warn/error
+        // main.js �?api.logger.info/warn/error
         logger: {
             info: (...args) => ctx.log?.info?.(...args),
             warn: (...args) => ctx.log?.warn?.(...args),
             error: (...args) => ctx.log?.error?.(...args),
             debug: (...args) => ctx.log?.debug?.(...args),
         },
-        // main.js �?api.pluginConfig
+        // main.js �?api.pluginConfig
         pluginConfig,
-        // main.js �?api.runtime
+        // main.js �?api.runtime
         runtime: ctx.runtime,
-        // main.js �?callAIViaRuntime 中用 api.config（传�?dispatchReply �?cfg 参数�?
+        // main.js �?callAIViaRuntime 中用 api.config（传�?dispatchReply �?cfg 参数�?
         config: ctx.cfg,
     };
 }
@@ -62,8 +62,8 @@ const roundtablePlugin = {
         label: "龙虾圆桌",
         selectionLabel: "Lobster Roundtable",
         icon: "🦞",
-        description: "�?AI 圆桌讨论插件",
-        blurb: "让你�?AI 自动参与多智能体圆桌讨论",
+        description: "�?AI 圆桌讨论插件",
+        blurb: "让你�?AI 自动参与多智能体圆桌讨论",
         docsPath: "/channels/lobster-roundtable",
     },
 
@@ -82,7 +82,7 @@ const roundtablePlugin = {
             return {
                 accountId: accountId || "default",
                 enabled: true,
-                // main.js 支持默认 URL + 自动注册，因此始终视�?configured
+                // main.js 支持默认 URL + 自动注册，因此始终视�?configured
                 // 不拦截零配置启动，让 main.js 自己处理
                 configured: true,
                 config: pluginCfg,
@@ -101,12 +101,12 @@ const roundtablePlugin = {
         deliveryMode: "direct",
         sendText: async (ctx) => {
             // 龙虾圆桌的出站消息通过内部 WS 发送（bot.send()），
-            // 不走 OpenClaw 的标�?outbound 管线�?
+            // 不走 OpenClaw 的标�?outbound 管线�?
             return { channel: CHANNEL_ID, messageId: createOutboundMessageId() };
         },
         sendMedia: async (ctx) => {
             // 圆桌不支持媒体消息，但必须提供此方法
-            // 否则 deliver.ts 会判�?outbound 未配�?
+            // 否则 deliver.ts 会判�?outbound 未配�?
             return { channel: CHANNEL_ID, messageId: createOutboundMessageId() };
         },
     },
@@ -139,12 +139,12 @@ const roundtablePlugin = {
 
     gateway: {
         /**
-         * Gateway 调用此函数启�?Channel�?
+         * Gateway 调用此函数启�?Channel�?
          *
-         * 关键生命周期约束（参�?server-channels.ts）：
-         *   - startAccount 返回�?Promise resolve = 通道退�?�?Gateway 自动重启
-         *   - 必须保持 Promise 挂起，直�?abortSignal 触发�?resolve
-         *   - 参照 nextcloud-talk/src/channel.ts L337 的做�?
+         * 关键生命周期约束（参�?server-channels.ts）：
+         *   - startAccount 返回�?Promise resolve = 通道退�?�?Gateway 自动重启
+         *   - 必须保持 Promise 挂起，直�?abortSignal 触发�?resolve
+         *   - 参照 nextcloud-talk/src/channel.ts L337 的做�?
          */
         startAccount: (ctx) => {
             return new Promise((resolve, reject) => {
@@ -162,13 +162,13 @@ const roundtablePlugin = {
 
                     if (!hasRuntimeAPI) {
                         ctx.log?.info?.(
-                            "[roundtable] runtime API 不可用，将使�?Gateway HTTP API 调用 AI（兼容模式）"
+                            "[roundtable] runtime API 不可用，将使�?Gateway HTTP API 调用 AI（兼容模式）"
                         );
                     }
 
                     ctx.log?.info?.("[roundtable] Gateway 正在启动龙虾圆桌...");
 
-                    bot = initRoundtable(apiAdapter, core, hasRuntimeAPI);
+                    bot = await initRoundtable(apiAdapter, core, hasRuntimeAPI);
 
                     if (!bot || typeof bot.stop !== "function") {
                         const err = new Error("[roundtable] initRoundtable 未返回有效的 { stop } 对象");
@@ -198,17 +198,17 @@ const roundtablePlugin = {
                     return;
                 }
 
-                // 核心：Promise 保持 pending，直�?abortSignal 触发�?resolve
+                // 核心：Promise 保持 pending，直�?abortSignal 触发�?resolve
                 // 这样 Gateway 不会认为通道退出并触发重启循环
                 const onAbort = () => {
-                    ctx.log?.info?.("[roundtable] 收到 Gateway abortSignal，正在停�?..");
+                    ctx.log?.info?.("[roundtable] 收到 Gateway abortSignal，正在停�?..");
                     if (bot) bot.stop();
                     ctx.setStatus?.({
                         accountId: ctx.accountId || "default",
                         running: false,
                         lastStopAt: Date.now(),
                     });
-                    resolve({ stop: () => { } }); // resolve �?通道正常退�?
+                    resolve({ stop: () => { } }); // resolve �?通道正常退�?
                 };
 
                 if (ctx.abortSignal?.aborted) {
@@ -216,7 +216,7 @@ const roundtablePlugin = {
                 } else if (ctx.abortSignal) {
                     ctx.abortSignal.addEventListener("abort", onAbort, { once: true });
                 }
-                // 如果没有 abortSignal，Promise 永远 pending �?通道永远运行（符合预期）
+                // 如果没有 abortSignal，Promise 永远 pending �?通道永远运行（符合预期）
             });
         },
     },