rol-websocket-channel 1.0.0

package/dist/message-handler.js

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

package/dist/src/admin/cli.js

@@ -0,0 +1,43 @@
+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';
+async function main() {
+    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() {
+    const chunks = [];
+    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) {
+    return value ?? null;
+}
+function toErrorResponse(id, error) {
+    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/dist/src/admin/jsonrpc.js

@@ -0,0 +1,60 @@
+export const JSON_RPC_VERSION = '2.0';
+export const JSON_RPC_ERRORS = {
+    parseError: -32700,
+    invalidRequest: -32600,
+    methodNotFound: -32601,
+    invalidParams: -32602,
+    internalError: -32603
+};
+export class JsonRpcException extends Error {
+    constructor(code, message, data) {
+        super(message);
+        this.code = code;
+        this.data = data;
+    }
+}
+export function parseRequest(raw) {
+    let parsed;
+    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, result) {
+    return {
+        jsonrpc: JSON_RPC_VERSION,
+        id,
+        result: result
+    };
+}
+export function failure(id, code, message, data) {
+    return {
+        jsonrpc: JSON_RPC_VERSION,
+        id,
+        error: {
+            code,
+            message,
+            ...(data === undefined ? {} : { data: data })
+        }
+    };
+}
+export function serialize(response) {
+    return `${JSON.stringify(response, null, 2)}\n`;
+}
+function isRequest(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const candidate = value;
+    return (candidate.jsonrpc === JSON_RPC_VERSION &&
+        typeof candidate.method === 'string' &&
+        candidate.method.length > 0);
+}

package/dist/src/admin/lib/fs.js

@@ -0,0 +1,30 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+export async function readJsonFile(filePath) {
+    const raw = await fs.readFile(filePath, 'utf8');
+    return JSON.parse(raw);
+}
+export async function writeJsonFile(filePath, data) {
+    const json = JSON.stringify(data, null, 2);
+    await fs.writeFile(filePath, json, 'utf8');
+}
+export async function pathExists(targetPath) {
+    try {
+        await fs.access(targetPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function ensureDir(targetDir) {
+    await fs.mkdir(targetDir, { recursive: true });
+}
+export async function copyIfExists(sourcePath, destPath) {
+    if (!(await pathExists(sourcePath))) {
+        return false;
+    }
+    await ensureDir(path.dirname(destPath));
+    await fs.copyFile(sourcePath, destPath);
+    return true;
+}

package/dist/src/admin/lib/paths.js

@@ -0,0 +1,46 @@
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { JsonRpcException, JSON_RPC_ERRORS } from '../jsonrpc.ts';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export function getProjectRoot() {
+    // __dirname 是 /path/to/rol-websocket-channel/src/admin/lib
+    // 需要返回 /path/to/rol-websocket-channel
+    const root = path.resolve(__dirname, '..', '..', '..');
+    console.log('[paths] __dirname:', __dirname);
+    console.log('[paths] getProjectRoot:', root);
+    return root;
+}
+export function getOpenClawRoot() {
+    if (process.env.OPENCLAW_HOME) {
+        console.log('[paths] getOpenClawRoot from env:', process.env.OPENCLAW_HOME);
+        return path.resolve(process.env.OPENCLAW_HOME);
+    }
+    // 插件在 ~/.openclaw/extensions/rol-websocket-channel
+    // 需要返回 ~/.openclaw
+    const projectRoot = getProjectRoot();
+    const parentDir = path.dirname(projectRoot);
+    const parentName = path.basename(parentDir);
+    console.log('[paths] projectRoot:', projectRoot);
+    console.log('[paths] parentDir:', parentDir);
+    console.log('[paths] parentName:', parentName);
+    if (parentName === 'extensions') {
+        // parentDir 是 ~/.openclaw/extensions
+        // 返回 ~/.openclaw
+        const openclawRoot = path.dirname(parentDir);
+        console.log('[paths] getOpenClawRoot (extensions):', openclawRoot);
+        return openclawRoot;
+    }
+    // 兜底：假设插件在 openclaw 根目录的子目录
+    const fallbackRoot = path.resolve(projectRoot, '..');
+    console.log('[paths] getOpenClawRoot (fallback):', fallbackRoot);
+    return fallbackRoot;
+}
+export function ensureInside(parentDir, targetPath) {
+    const parent = path.resolve(parentDir);
+    const target = path.resolve(targetPath);
+    if (target !== parent && !target.startsWith(`${parent}${path.sep}`)) {
+        throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, 'Path escapes allowed directory', { parent, target });
+    }
+    return target;
+}

package/dist/src/admin/methods/admin.js

@@ -0,0 +1,60 @@
+import path from 'node:path';
+import { readJsonFile } from '../lib/fs.ts';
+export const getAgents = async (_params, context) => {
+    const configPath = path.join(context.openclawRoot, 'openclaw.json');
+    const config = await readJsonFile(configPath);
+    return {
+        sourceConfigFile: configPath,
+        defaultAgentConfig: config.agents?.defaults ?? {},
+        namedAgents: config.agents?.list ?? [],
+        activeToolProfile: config.tools?.profile ?? null
+    };
+};
+export const getConfig = async (params, context) => {
+    const configPath = path.join(context.openclawRoot, 'openclaw.json');
+    const config = await readJsonFile(configPath);
+    const objectParams = isObject(params) ? params : {};
+    const section = typeof objectParams.section === 'string' ? objectParams.section : null;
+    if (!section) {
+        return {
+            sourceConfigFile: configPath,
+            config: redactSecrets(config)
+        };
+    }
+    const value = config[section];
+    return {
+        sourceConfigFile: configPath,
+        section,
+        sectionValue: value === undefined ? null : redactSecrets(value)
+    };
+};
+function isObject(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function redactSecrets(value) {
+    if (Array.isArray(value)) {
+        return value.map(redactSecrets);
+    }
+    if (!value || typeof value !== 'object') {
+        return value;
+    }
+    const result = {};
+    for (const [key, nestedValue] of Object.entries(value)) {
+        if (isSecretKey(key) && typeof nestedValue === 'string') {
+            result[key] = redactString(nestedValue);
+            continue;
+        }
+        result[key] = redactSecrets(nestedValue);
+    }
+    return result;
+}
+function isSecretKey(key) {
+    const normalized = key.toLowerCase();
+    return normalized.includes('apikey') || normalized.includes('token') || normalized.includes('secret');
+}
+function redactString(value) {
+    if (value.length <= 8) {
+        return '********';
+    }
+    return `${value.slice(0, 4)}***${value.slice(-4)}`;
+}