rol-websocket-channel 1.0.0

package/message-handler.ts

@@ -0,0 +1,415 @@
+/**
+ * 消息处理器类
+ * 根据消息类型调用对应的 admin 方法
+ */
+
+import { getContext } from './src/shared/context.js';
+import { wrapAdminCall } from './src/shared/wrapper.js';
+import { getAgents, getConfig } from './src/admin/methods/admin.js';
+import { createAgent, deleteAgent, listAgents, updateAgent } from './src/admin/methods/agents-extended.js';
+import { listSessions } from './src/admin/methods/sessions.js';
+import { getSession, prepareMessage, attachSkill } from './src/admin/methods/sessions-extended.js';
+import { getModels } from './src/admin/methods/models.js';
+import { updateModels } from './src/admin/methods/models-extended.js';
+import {
+  getUsagePageSummary,
+  getUsageTimeseries,
+  getUsageBreakdown,
+  getUsageSummary,
+} from './src/admin/methods/usage.js';
+import {
+  listInstalledSkills,
+  installSkillFromNpm,
+  searchClawHubSkills,
+  installSkillFromClawHub,
+  updateSkillFromClawHub
+} from './src/admin/methods/skills.js';
+import { uninstallSkill } from './src/admin/methods/skills-extended.js';
+import { toggleSkill } from './src/admin/methods/skills-toggle.js';
+import {
+  listMemoryFiles,
+  getMemoryFile,
+  backupMemory,
+  exportMemoryZip,
+  getMemoryPresignedPost,
+  createMemoryBackupRecord,
+  importMemoryZip,
+} from './src/admin/methods/memory.js';
+import { restart, stop, doctorFix, logs } from './src/admin/methods/system.js';
+
+export class MessageHandler {
+  /**
+   * 示例方法：处理 ping 类型的消息
+   * @param data - 消息数据
+   * @returns 处理结果
+   */
+  async ping(data: any): Promise<any> {
+    return {
+      message: "pong",
+      timestamp: Date.now(),
+      received: data,
+    };
+  }
+
+  /**
+   * 获取 agents 配置
+   */
+  async agentsGet(data: any): Promise<any> {
+    return wrapAdminCall(async () => {
+      const context = getContext();
+      return await getAgents(data, context);
+    });
+  }
+
+  async agentsList(data: any): Promise<any> {
+    return wrapAdminCall(async () => {
+      const context = getContext();
+      return await listAgents(data, context);
+    });
+  }
+
+  async agentsCreate(data: any): Promise<any> {
+    return wrapAdminCall(async () => {
+      const context = getContext();
+      return await createAgent(data, context);
+    });
+  }
+
+  async agentsDelete(data: any): Promise<any> {
+    return wrapAdminCall(async () => {
+      const context = getContext();
+      return await deleteAgent(data, context);
+    });
+  }
+
+  /**
+   * 更新 agent 配置
+   */
+  async agentsUpdate(data: any): Promise<any> {
+    return wrapAdminCall(async () => {
+      const context = getContext();
+      return await updateAgent(data, context);
+    });
+  }
+
+  /**
+   * 获取配置
+   */
+  async configGet(data: any): Promise<any> {
+    return wrapAdminCall(async () => {
+      const context = getContext();
+      return await getConfig(data, context);
+    });
+  }
+
+  /**
+   * 列出 sessions
+   */
+  async sessionsList(data: any): Promise<any> {
+    return wrapAdminCall(async () => {
+      const context = getContext();
+      return await listSessions(data, context);
+    });
+  }
+
+  /**
+   * 获取单个 session 详情和消息记录
+   */
+  async sessionsGet(data: any): Promise<any> {
+    return wrapAdminCall(async () => {
+      const context = getContext();
+      return await getSession(data, context);
+    });
+  }
+
+  /**
+   * 准备向 session 发送的消息
+   * 注意：这只是准备消息数据，实际发送需要通过 MQTT sender 消息
+   */
+  async sessionsPrepareMessage(data: any): Promise<any> {
+    return wrapAdminCall(async () => {
+      const context = getContext();
+      return await prepareMessage(data, context);
+    });
+  }
+
+  /**
+   * 附加 skill 到消息
+   */
+  async sessionsAttachSkill(data: any): Promise<any> {
+    return wrapAdminCall(async () => {
+      const context = getContext();
+      return await attachSkill(data, context);
+    });
+  }
+
+  /**
+   * 获取 models 配置
+   */
+  async modelsGet(data: any): Promise<any> {
+    return wrapAdminCall(async () => {
+      const context = getContext();
+      return await getModels(data, context);
+    });
+  }
+
+  /**
+   * 更新 models 配置
+   */
+  async modelsUpdate(data: any): Promise<any> {
+    return wrapAdminCall(async () => {
+      const context = getContext();
+      return await updateModels(data, context);
+    });
+  }
+
+  /**
+   * 获取 usage summary
+   */
+  async usageSummary(data: any): Promise<any> {
+    return wrapAdminCall(async () => {
+      const context = getContext();
+      return await getUsageSummary(data, context);
+    });
+  }
+
+  /**
+   * 获取 usage page summary
+   */
+  async usagePageSummary(data: any): Promise<any> {
+    return wrapAdminCall(async () => {
+      const context = getContext();
+      return await getUsagePageSummary(data, context);
+    });
+  }
+
+  /**
+   * 获取 usage timeseries
+   */
+  async usageTimeseries(data: any): Promise<any> {
+    return wrapAdminCall(async () => {
+      const context = getContext();
+      return await getUsageTimeseries(data, context);
+    });
+  }
+
+  /**
+   * 获取 usage breakdown
+   */
+  async usageBreakdown(data: any): Promise<any> {
+    return wrapAdminCall(async () => {
+      const context = getContext();
+      return await getUsageBreakdown(data, context);
+    });
+  }
+
+  /**
+   * 列出已安装的 skills
+   */
+  async skillsListInstalled(data: any): Promise<any> {
+    return wrapAdminCall(async () => {
+      const context = getContext();
+      return await listInstalledSkills(data, context);
+    });
+  }
+
+  /**
+   * 从 npm 安装 skill
+   */
+  async skillsInstallFromNpm(data: any): Promise<any> {
+    return wrapAdminCall(async () => {
+      const context = getContext();
+      return await installSkillFromNpm(data, context);
+    });
+  }
+
+  async skillsSearchClawHub(data: any): Promise<any> {
+    return wrapAdminCall(async () => {
+      const context = getContext();
+      return await searchClawHubSkills(data, context);
+    });
+  }
+
+  async skillsInstallFromClawHub(data: any): Promise<any> {
+    return wrapAdminCall(async () => {
+      const context = getContext();
+      return await installSkillFromClawHub(data, context);
+    });
+  }
+
+  async skillsUpdateFromClawHub(data: any): Promise<any> {
+    return wrapAdminCall(async () => {
+      const context = getContext();
+      return await updateSkillFromClawHub(data, context);
+    });
+  }
+
+  /**
+   * 获取已安装 skill 详情
+   */
+  async skillsGetInstalled(data: any): Promise<any> {
+    return wrapAdminCall(async () => {
+      const context = getContext();
+      const slug = typeof data?.slug === 'string' ? data.slug : null;
+      if (!slug) {
+        throw new Error('Missing required parameter: slug');
+      }
+
+      const result = await listInstalledSkills({}, context) as any;
+      const items = Array.isArray(result?.items) ? result.items : [];
+      const skill = items.find((item: any) => item && typeof item === 'object' && item.slug === slug);
+      if (!skill) {
+        throw new Error(`Skill not installed: ${slug}`);
+      }
+      return skill;
+    });
+  }
+
+  /**
+   * 卸载 skill
+   */
+  async skillsUninstall(data: any): Promise<any> {
+    return wrapAdminCall(async () => {
+      const context = getContext();
+      return await uninstallSkill(data, context);
+    });
+  }
+
+  /**
+   * 启用或停用 skill
+   */
+  async skillsToggle(data: any): Promise<any> {
+    return wrapAdminCall(async () => {
+      const context = getContext();
+      return await toggleSkill(data, context);
+    });
+  }
+
+  /**
+   * 列出 memory 文件
+   */
+  async memoryListFiles(data: any): Promise<any> {
+    return wrapAdminCall(async () => {
+      const context = getContext();
+      return await listMemoryFiles(data, context);
+    });
+  }
+
+  /**
+   * 获取 memory 文件内容
+   */
+  async memoryGetFile(data: any): Promise<any> {
+    return wrapAdminCall(async () => {
+      const context = getContext();
+      return await getMemoryFile(data, context);
+    });
+  }
+
+  /**
+   * 备份 memory
+   */
+  async memoryBackup(data: any): Promise<any> {
+    return wrapAdminCall(async () => {
+      const context = getContext();
+      return await backupMemory(data, context);
+    });
+  }
+
+  /**
+   * 导出 memory zip
+   */
+  async memoryExportZip(data: any): Promise<any> {
+    return wrapAdminCall(async () => {
+      const context = getContext();
+      return await exportMemoryZip(data, context);
+    });
+  }
+
+  async memoryGetPresignedPost(data: any): Promise<any> {
+    return wrapAdminCall(async () => {
+      const context = getContext();
+      return await getMemoryPresignedPost(data, context);
+    });
+  }
+
+  async memoryCreateBackupRecord(data: any): Promise<any> {
+    return wrapAdminCall(async () => {
+      const context = getContext();
+      return await createMemoryBackupRecord(data, context);
+    });
+  }
+
+  /**
+   * 导入 memory zip
+   */
+  async memoryImportZip(data: any): Promise<any> {
+    return wrapAdminCall(async () => {
+      const context = getContext();
+      return await importMemoryZip(data, context);
+    });
+  }
+
+  /**
+   * 重启 OpenClaw Gateway
+   */
+  async systemRestart(data: any): Promise<any> {
+    return wrapAdminCall(async () => {
+      const context = getContext();
+      return await restart(data, context);
+    });
+  }
+
+  /**
+   * 停止 OpenClaw Gateway
+   */
+  async systemStop(data: any): Promise<any> {
+    return wrapAdminCall(async () => {
+      const context = getContext();
+      return await stop(data, context);
+    });
+  }
+
+  /**
+   * 运行诊断并自动修复
+   */
+  async systemDoctorFix(data: any): Promise<any> {
+    return wrapAdminCall(async () => {
+      const context = getContext();
+      return await doctorFix(data, context);
+    });
+  }
+
+  /**
+   * 获取最近100条日志
+   */
+  async systemLogs(data: any): Promise<any> {
+    return wrapAdminCall(async () => {
+      const context = getContext();
+      return await logs(data, context);
+    });
+  }
+
+  /**
+   * 示例方法：处理 status 类型的消息
+   */
+  async status(data: any): Promise<any> {
+    return {
+      status: "running",
+      uptime: process.uptime(),
+      memory: process.memoryUsage(),
+    };
+  }
+
+  /**
+   * 示例方法：处理 echo 类型的消息
+   */
+  async echo(data: any): Promise<any> {
+    return {
+      echoed: true,
+      data: data,
+    };
+  }
+}
+
+// 导出单例实例
+export const messageHandler = new MessageHandler();

package/openclaw.plugin.json

@@ -0,0 +1,84 @@
+{
+  "id": "rol-websocket-channel",
+  "name": "WebSocket Channel",
+  "version": "1.0.0",
+  "description": "Unified plugin providing MQTT Channel and Admin Bridge capabilities for OpenClaw management",
+  "channels": ["rol-websocket-channel"],
+  "cli": ["admin-bridge"],
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {
+      "channels": {
+        "type": "object",
+        "additionalProperties": false,
+        "properties": {
+          "rol-websocket-channel": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+              "enabled": {
+                "type": "boolean"
+              },
+              "config": {
+                "type": "object",
+                "additionalProperties": false,
+                "properties": {
+                  "enabled": {
+                    "type": "boolean"
+                  },
+                  "mqttUrl": {
+                    "type": "string"
+                  },
+                  "mqttTopic": {
+                    "type": "string"
+                  },
+                  "groupPolicy": {
+                    "type": "string",
+                    "enum": ["pairing", "allowlist", "open", "disabled"]
+                  }
+                },
+                "required": ["mqttUrl"]
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+
+  "uiHints": {
+    "channels": {
+      "label": "Channels"
+    },
+    "channels.rol-websocket-channel": {
+      "label": "WebSocket Channel"
+    },
+    "channels.rol-websocket-channel.enabled": {
+      "label": "Enabled",
+      "description": "Enable MQTT Channel"
+    },
+    "channels.rol-websocket-channel.config": {
+      "label": "Configuration",
+      "description": "MQTT/WebSocket connection configuration"
+    },
+    "channels.rol-websocket-channel.config.enabled": {
+      "label": "Enabled",
+      "description": "Enable this configuration"
+    },
+    "channels.rol-websocket-channel.config.mqttUrl": {
+      "label": "MQTT Broker URL",
+      "placeholder": "ws://192.168.1.23:8083/mqtt",
+      "help": "MQTT broker WebSocket URL (e.g., ws://192.168.1.23:8083/mqtt)"
+    },
+    "channels.rol-websocket-channel.config.mqttTopic": {
+      "label": "MQTT Topic",
+      "placeholder": "announcement/tester",
+      "help": "MQTT topic to subscribe/publish"
+    },
+    "channels.rol-websocket-channel.config.groupPolicy": {
+      "label": "Group Policy",
+      "description": "Message policy for group chats"
+    }
+  }
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "rol-websocket-channel",
+  "version": "1.0.0",
+  "description": "Unified OpenClaw plugin: MQTT Channel + Admin Bridge for remote management",
+  "license": "MIT",
+  "author": "nixgnehc",
+  "type": "module",
+  "keywords": [
+    "openclaw",
+    "mqtt",
+    "websocket",
+    "admin-bridge",
+    "plugin",
+    "channel"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx watch index.ts"
+  },
+  "dependencies": {
+    "mqtt": "^5.0.3"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.0.0"
+  },
+  "openclaw": {
+    "extensions": [
+      "./index.ts"
+    ]
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/readme.md

@@ -0,0 +1,32 @@
+
+
+```
+openclaw plugins install "c:\Users\admin\Desktop\openclaw-demo\rol-websocket-channel" --force
+
+topic
+announcement/tester
+
+# 发送
+# receiver/sender/*
+{
+ "type":"echo",
+ "trace_id":"11233",
+  "source": "default",
+  "data": {
+    "content": "你好c",
+    "attachments": []
+  }
+}
+
+# 接收
+{"type":"receiver","trace_id":"11233","source":"system","success":true,"timestamp":1776152983607,"data":{"echoed":true,"data":{"content":"你好c","attachments":[]}}}
+
+```
+
+
+
+```
+npm login
+npm publish
+
+```

package/src/admin/cli.ts

@@ -0,0 +1,60 @@
+import { getOpenClawRoot, getProjectRoot } from './lib/paths.ts';
+import { getMethod } from './methods/index.ts';
+import {
+  failure,
+  JsonRpcException,
+  JSON_RPC_ERRORS,
+  parseRequest,
+  serialize,
+  success
+} from './jsonrpc.ts';
+import type { JsonRpcId } from './types.ts';
+
+async function main(): Promise<void> {
+  const raw = await readStdin();
+  const request = parseRequest(raw);
+  const context = {
+    projectRoot: getProjectRoot(),
+    openclawRoot: getOpenClawRoot()
+  };
+
+  try {
+    const handler = getMethod(request.method);
+    const result = await handler(request.params, context);
+    process.stdout.write(serialize(success(normalizeId(request.id), result)));
+  } catch (error) {
+    process.stdout.write(serialize(toErrorResponse(normalizeId(request.id), error)));
+    process.exitCode = 1;
+  }
+}
+
+async function readStdin(): Promise<string> {
+  const chunks: Buffer[] = [];
+
+  for await (const chunk of process.stdin) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+
+  const raw = Buffer.concat(chunks).toString('utf8').trim();
+  if (!raw) {
+    throw new JsonRpcException(JSON_RPC_ERRORS.invalidRequest, 'Request body is empty');
+  }
+
+  return raw;
+}
+
+function normalizeId(value: JsonRpcId | undefined): JsonRpcId {
+  return value ?? null;
+}
+
+function toErrorResponse(id: JsonRpcId, error: unknown) {
+  if (error instanceof JsonRpcException) {
+    return failure(id, error.code, error.message, error.data);
+  }
+
+  return failure(id, JSON_RPC_ERRORS.internalError, 'Internal error', {
+    detail: error instanceof Error ? error.message : String(error)
+  });
+}
+
+await main();

package/src/admin/jsonrpc.ts

@@ -0,0 +1,88 @@
+import type {
+  JsonRpcFailure,
+  JsonRpcId,
+  JsonRpcRequest,
+  JsonRpcResponse,
+  JsonRpcSuccess
+} from './types.ts';
+
+export const JSON_RPC_VERSION = '2.0';
+
+export const JSON_RPC_ERRORS = {
+  parseError: -32700,
+  invalidRequest: -32600,
+  methodNotFound: -32601,
+  invalidParams: -32602,
+  internalError: -32603
+} as const;
+
+export class JsonRpcException extends Error {
+  code: number;
+  data?: unknown;
+
+  constructor(code: number, message: string, data?: unknown) {
+    super(message);
+    this.code = code;
+    this.data = data;
+  }
+}
+
+export function parseRequest(raw: string): JsonRpcRequest {
+  let parsed: unknown;
+
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    throw new JsonRpcException(JSON_RPC_ERRORS.parseError, 'Parse error', {
+      detail: error instanceof Error ? error.message : String(error)
+    });
+  }
+
+  if (!isRequest(parsed)) {
+    throw new JsonRpcException(JSON_RPC_ERRORS.invalidRequest, 'Invalid Request');
+  }
+
+  return parsed;
+}
+
+export function success(id: JsonRpcId, result: unknown): JsonRpcSuccess {
+  return {
+    jsonrpc: JSON_RPC_VERSION,
+    id,
+    result: result as JsonRpcSuccess['result']
+  };
+}
+
+export function failure(
+  id: JsonRpcId,
+  code: number,
+  message: string,
+  data?: unknown
+): JsonRpcFailure {
+  return {
+    jsonrpc: JSON_RPC_VERSION,
+    id,
+    error: {
+      code,
+      message,
+      ...(data === undefined ? {} : { data: data as JsonRpcFailure['error']['data'] })
+    }
+  };
+}
+
+export function serialize(response: JsonRpcResponse): string {
+  return `${JSON.stringify(response, null, 2)}\n`;
+}
+
+function isRequest(value: unknown): value is JsonRpcRequest {
+  if (!value || typeof value !== 'object') {
+    return false;
+  }
+
+  const candidate = value as Record<string, unknown>;
+  return (
+    candidate.jsonrpc === JSON_RPC_VERSION &&
+    typeof candidate.method === 'string' &&
+    candidate.method.length > 0
+  );
+}