rol-websocket-channel 1.0.5 → 1.0.7

package/index.ts

@@ -441,7 +441,7 @@ async function handleIncomingMessage(
     };
 
     const targetAgentId: string | null = innerData.agentId ?? innerData.agent_id ?? null;
-    const targetSessionId: string | null = innerData.sessionId ?? innerData.session_id ?? null;
+    const targetSessionId: string | null = innerData.sessionKey ?? innerData.session_key ?? null;
 
     log?.info(
       `[rol-websocket-channel] 📨 Received: "${normalizedMessage.text}" from ${normalizedMessage.senderId}` +
@@ -684,6 +684,68 @@ function registerAdminBridgeCli(api: any) {
             }
           },
         );
+
+      const mem9 = root
+        .command("mem9")
+        .description("Mem9 installer and reconnect utilities");
+
+      mem9
+        .command("install")
+        .description("Install mem9 plugin, create cloud key, write config, and restart gateway")
+        .action(async () => {
+          try {
+            const { installMem9 } = await import("./src/admin/methods/mem9.js");
+            const result = await installMem9(getContext());
+            process.stdout.write(
+              JSON.stringify({ ok: true, result }, null, 2) + "\n",
+            );
+          } catch (error) {
+            process.exitCode = 1;
+            process.stderr.write(
+              JSON.stringify(
+                {
+                  ok: false,
+                  error: {
+                    message:
+                      error instanceof Error ? error.message : String(error),
+                    code: (error as any)?.data?.code,
+                  },
+                },
+                null,
+                2,
+              ) + "\n",
+            );
+          }
+        });
+
+      mem9
+        .command("reconnect <key>")
+        .description("Replace mem9 apiKey, update config, and restart gateway")
+        .action(async (key: string) => {
+          try {
+            const { reconnectMem9 } = await import("./src/admin/methods/mem9.js");
+            const result = await reconnectMem9(key, getContext());
+            process.stdout.write(
+              JSON.stringify({ ok: true, result }, null, 2) + "\n",
+            );
+          } catch (error) {
+            process.exitCode = 1;
+            process.stderr.write(
+              JSON.stringify(
+                {
+                  ok: false,
+                  error: {
+                    message:
+                      error instanceof Error ? error.message : String(error),
+                    code: (error as any)?.data?.code,
+                  },
+                },
+                null,
+                2,
+              ) + "\n",
+            );
+          }
+        });
     },
     {
       descriptors: [

package/message-handler.ts

@@ -35,6 +35,7 @@ import {
   createMemoryBackupRecord,
   importMemoryZip,
 } from './src/admin/methods/memory.js';
+import { getMem9Config, installMem9, reconnectMem9 } from './src/admin/methods/mem9.js';
 import { restart, stop, doctorFix, logs } from './src/admin/methods/system.js';
 
 export class MessageHandler {
@@ -356,6 +357,28 @@ export class MessageHandler {
     });
   }
 
+  async mem9Install(_data: any): Promise<any> {
+    return wrapAdminCall(async () => {
+      const context = getContext();
+      return await installMem9(context);
+    });
+  }
+
+  async mem9GetConfig(_data: any): Promise<any> {
+    return wrapAdminCall(async () => {
+      const context = getContext();
+      return await getMem9Config(context);
+    });
+  }
+
+  async mem9Reconnect(data: any): Promise<any> {
+    return wrapAdminCall(async () => {
+      const context = getContext();
+      const key = typeof data?.key === 'string' ? data.key : '';
+      return await reconnectMem9(key, context);
+    });
+  }
+
   /**
    * 重启 OpenClaw Gateway
    */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rol-websocket-channel",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "Unified OpenClaw plugin: MQTT Channel + Admin Bridge for remote management",
   "license": "MIT",
   "author": "nixgnehc",

package/readme.md

@@ -30,4 +30,9 @@ announcement/tester
 npm login
 npm publish
 
-```
+```
+
+```
+openclaw admin-bridge mem9 install
+openclaw admin-bridge mem9 reconnect <key>
+```

package/src/admin/methods/index.ts

@@ -11,6 +11,7 @@ import {
   importMemoryZip,
   listMemoryFiles
 } from './memory.ts';
+import { getMem9Config, installMem9, reconnectMem9 } from './mem9.ts';
 import { getModels } from './models.ts';
 import { setModel, updateModels } from './models-extended.ts';
 import { listSessions } from './sessions.ts';
@@ -85,7 +86,12 @@ const methods = new Map<string, MethodHandler>([
   ['memory.exportZip', exportMemoryZip],
   ['memory.getPresignedPost', getMemoryPresignedPost],
   ['memory.createBackupRecord', createMemoryBackupRecord],
-  ['memory.importZip', importMemoryZip]
+  ['memory.importZip', importMemoryZip],
+
+  // Mem9
+  ['mem9.install', installMem9],
+  ['mem9.getConfig', getMem9Config],
+  ['mem9.reconnect', reconnectMem9]
 ]);
 
 export function getMethod(methodName: string): MethodHandler {

package/src/admin/methods/mem9.ts

@@ -0,0 +1,341 @@
+import { execFile } from 'node:child_process';
+import path from 'node:path';
+import { promisify } from 'node:util';
+
+import { pathExists, readJsonFile, writeJsonFile } from '../lib/fs.ts';
+import { JsonRpcException, JSON_RPC_ERRORS } from '../jsonrpc.ts';
+import type { JsonValue, MethodContext } from '../types.ts';
+
+const execFileAsync = promisify(execFile);
+
+const MEM9_PLUGIN_SPEC = '@mem9/mem9';
+const MEM9_PLUGIN_ID = 'mem9';
+const MEM9_API_URL = 'https://api.mem9.ai';
+const MEM9_CREATE_URL = `${MEM9_API_URL}/v1alpha1/mem9s`;
+const GATEWAY_SERVICE = 'openclaw-gateway.service';
+
+interface OpenClawConfig {
+  plugins?: {
+    entries?: Record<string, any>;
+    slots?: Record<string, any>;
+    installs?: Record<string, any>;
+    [key: string]: any;
+  };
+  [key: string]: any;
+}
+
+export async function installMem9(context: MethodContext): Promise<JsonValue> {
+  const config = await ensureOpenClawConfigExists(context.openclawRoot);
+  await ensureOpenClawCli();
+  await ensureNodeRuntime();
+
+  const currentState = readMem9State(config);
+  const installResult = currentState.installed
+    ? { attempted: false, installed: true }
+    : await installMem9Plugin(context.projectRoot);
+
+  if (currentState.configured && currentState.apiKey) {
+    const updated = await ensureMem9SlotConfig(context.openclawRoot, currentState.apiKey);
+    const restart = await restartGateway(context.projectRoot);
+
+    return {
+      ok: true,
+      installed: true,
+      alreadyInstalled: installResult.installed,
+      alreadyConfigured: true,
+      createdNewKey: false,
+      reusedExistingKey: true,
+      plugin: MEM9_PLUGIN_ID,
+      apiUrl: MEM9_API_URL,
+      apiKey: currentState.apiKey,
+      updated,
+      restart
+    };
+  }
+
+  const apiKey = await createMem9Key();
+  const updated = await writeMem9Config(context.openclawRoot, apiKey);
+  const restart = await restartGateway(context.projectRoot);
+
+  return {
+    ok: true,
+    installed: true,
+    alreadyInstalled: installResult.installed,
+    alreadyConfigured: false,
+    createdNewKey: true,
+    reusedExistingKey: false,
+    plugin: MEM9_PLUGIN_ID,
+    apiUrl: MEM9_API_URL,
+    apiKey,
+    updated,
+    restart
+  };
+}
+
+export async function reconnectMem9(key: string, context: MethodContext): Promise<JsonValue> {
+  const apiKey = key.trim();
+  if (!apiKey) {
+    throwMem9Error('MEM9_KEY_REQUIRED', 'mem9 key is required');
+  }
+
+  const config = await ensureOpenClawConfigExists(context.openclawRoot);
+  const previousState = readMem9State(config);
+  const updated = await writeMem9Config(context.openclawRoot, apiKey);
+  const restart = await restartGateway(context.projectRoot);
+
+  return {
+    ok: true,
+    reconnected: true,
+    replacedExistingKey: Boolean(previousState.apiKey && previousState.apiKey !== apiKey),
+    plugin: MEM9_PLUGIN_ID,
+    apiUrl: MEM9_API_URL,
+    apiKey,
+    updated: ['plugins.entries.mem9.config.apiKey', ...updated.filter((item) => item !== 'plugins.entries.mem9' && item !== 'plugins.slots.memory')],
+    restart
+  };
+}
+
+export async function getMem9Config(context: MethodContext): Promise<JsonValue> {
+  const config = await ensureOpenClawConfigExists(context.openclawRoot);
+  const state = readMem9State(config);
+  const entry = isRecord(config.plugins?.entries?.[MEM9_PLUGIN_ID]) ? config.plugins?.entries?.[MEM9_PLUGIN_ID] : {};
+  const pluginConfig = isRecord(entry.config) ? entry.config : {};
+
+  return {
+    ok: true,
+    installed: state.installed,
+    configured: state.configured,
+    plugin: MEM9_PLUGIN_ID,
+    enabled: entry.enabled === true,
+    apiUrl: pickString(pluginConfig.apiUrl) ?? MEM9_API_URL,
+    apiKey: state.apiKey,
+    slot: config.plugins?.slots?.memory ?? null
+  };
+}
+
+async function ensureOpenClawConfigExists(openclawRoot: string): Promise<OpenClawConfig> {
+  const configPath = path.join(openclawRoot, 'openclaw.json');
+  if (!(await pathExists(configPath))) {
+    throwMem9Error('MEM9_CONFIG_NOT_FOUND', `openclaw.json not found: ${configPath}`);
+  }
+
+  return await readJsonFile<OpenClawConfig>(configPath);
+}
+
+async function ensureOpenClawCli(): Promise<void> {
+  try {
+    await execFileAsync('openclaw', ['--version']);
+  } catch (error) {
+    throw new JsonRpcException(
+      JSON_RPC_ERRORS.internalError,
+      'openclaw command is not available',
+      { code: 'MEM9_OPENCLAW_NOT_FOUND', detail: error instanceof Error ? error.message : String(error) }
+    );
+  }
+}
+
+async function ensureNodeRuntime(): Promise<void> {
+  try {
+    await execFileAsync('node', ['--version']);
+    await execFileAsync('npm', ['--version']);
+  } catch (error) {
+    throw new JsonRpcException(
+      JSON_RPC_ERRORS.internalError,
+      'node or npm command is not available',
+      { code: 'MEM9_NODE_NOT_FOUND', detail: error instanceof Error ? error.message : String(error) }
+    );
+  }
+}
+
+async function runOpenClawCommand(args: string[], cwd: string, code: string): Promise<void> {
+  try {
+    await execFileAsync('openclaw', args, { cwd });
+  } catch (error: any) {
+    throw new JsonRpcException(
+      JSON_RPC_ERRORS.internalError,
+      `openclaw ${args.join(' ')} failed`,
+      {
+        code,
+        stdout: typeof error?.stdout === 'string' ? error.stdout : '',
+        stderr: typeof error?.stderr === 'string' ? error.stderr : ''
+      }
+    );
+  }
+}
+
+async function installMem9Plugin(cwd: string): Promise<{ attempted: boolean; installed: boolean }> {
+  await runOpenClawCommand(['plugins', 'install', MEM9_PLUGIN_SPEC], cwd, 'MEM9_PLUGIN_INSTALL_FAILED');
+  return {
+    attempted: true,
+    installed: true
+  };
+}
+
+async function createMem9Key(): Promise<string> {
+  const response = await fetch(MEM9_CREATE_URL, {
+    method: 'POST',
+    headers: {
+      accept: 'application/json',
+      'content-type': 'application/json'
+    },
+    body: JSON.stringify({})
+  });
+
+  const rawText = await response.text();
+  const payload = tryParseJson(rawText);
+  if (!response.ok) {
+    throw new JsonRpcException(
+      JSON_RPC_ERRORS.internalError,
+      `mem9 key create failed: ${response.status}`,
+      {
+        code: 'MEM9_KEY_CREATE_FAILED',
+        status: response.status,
+        payload
+      }
+    );
+  }
+
+  const root = isRecord(payload) && isRecord(payload.data) ? payload.data : isRecord(payload) ? payload : null;
+  const key = pickString(root?.id) ?? pickString(root?.value) ?? pickString(root?.apiKey);
+  if (!key) {
+    throwMem9Error('MEM9_KEY_CREATE_FAILED', 'mem9 create response missing id');
+  }
+
+  return key;
+}
+
+async function writeMem9Config(openclawRoot: string, apiKey: string): Promise<string[]> {
+  const configPath = path.join(openclawRoot, 'openclaw.json');
+  const config = await readJsonFile<OpenClawConfig>(configPath);
+
+  if (!config.plugins) config.plugins = {};
+  if (!config.plugins.entries || typeof config.plugins.entries !== 'object') {
+    config.plugins.entries = {};
+  }
+  if (!config.plugins.slots || typeof config.plugins.slots !== 'object') {
+    config.plugins.slots = {};
+  }
+
+  const existingEntry = isRecord(config.plugins.entries[MEM9_PLUGIN_ID]) ? config.plugins.entries[MEM9_PLUGIN_ID] : {};
+  const existingPluginConfig = isRecord(existingEntry.config) ? existingEntry.config : {};
+  const hadExistingKey = typeof existingPluginConfig.apiKey === 'string' && existingPluginConfig.apiKey.trim().length > 0;
+
+  config.plugins.entries[MEM9_PLUGIN_ID] = {
+    ...existingEntry,
+    enabled: true,
+    config: {
+      ...existingPluginConfig,
+      apiUrl: MEM9_API_URL,
+      apiKey
+    }
+  };
+
+  config.plugins.slots.memory = MEM9_PLUGIN_ID;
+  await writeJsonFile(configPath, config);
+
+  return [
+    hadExistingKey ? 'plugins.entries.mem9.config.apiKey (replaced)' : 'plugins.entries.mem9',
+    'plugins.slots.memory'
+  ];
+}
+
+async function ensureMem9SlotConfig(openclawRoot: string, apiKey: string): Promise<string[]> {
+  const configPath = path.join(openclawRoot, 'openclaw.json');
+  const config = await readJsonFile<OpenClawConfig>(configPath);
+
+  if (!config.plugins) config.plugins = {};
+  if (!config.plugins.entries || typeof config.plugins.entries !== 'object') {
+    config.plugins.entries = {};
+  }
+  if (!config.plugins.slots || typeof config.plugins.slots !== 'object') {
+    config.plugins.slots = {};
+  }
+
+  const existingEntry = isRecord(config.plugins.entries[MEM9_PLUGIN_ID]) ? config.plugins.entries[MEM9_PLUGIN_ID] : {};
+  const existingPluginConfig = isRecord(existingEntry.config) ? existingEntry.config : {};
+
+  config.plugins.entries[MEM9_PLUGIN_ID] = {
+    ...existingEntry,
+    enabled: true,
+    config: {
+      ...existingPluginConfig,
+      apiUrl: MEM9_API_URL,
+      apiKey
+    }
+  };
+
+  config.plugins.slots.memory = MEM9_PLUGIN_ID;
+  await writeJsonFile(configPath, config);
+
+  return [
+    'plugins.entries.mem9',
+    'plugins.slots.memory'
+  ];
+}
+
+async function restartGateway(cwd: string): Promise<JsonValue> {
+  try {
+    await execFileAsync('systemctl', ['--user', 'restart', GATEWAY_SERVICE], { cwd });
+    return {
+      attempted: true,
+      success: true
+    };
+  } catch (error: any) {
+    return {
+      attempted: true,
+      success: false,
+      message: error instanceof Error ? error.message : String(error),
+      stderr: typeof error?.stderr === 'string' ? error.stderr : ''
+    };
+  }
+}
+
+function tryParseJson(raw: string): unknown {
+  const trimmed = raw.trim();
+  if (!trimmed) {
+    return {};
+  }
+
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return raw;
+  }
+}
+
+function pickString(value: unknown): string | null {
+  if (typeof value !== 'string') {
+    return null;
+  }
+
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
+function isRecord(value: unknown): value is Record<string, any> {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+function readMem9State(config: OpenClawConfig): {
+  installed: boolean;
+  configured: boolean;
+  apiKey: string | null;
+} {
+  const installed = Boolean(
+    (config.plugins?.installs && typeof config.plugins.installs === 'object' && MEM9_PLUGIN_ID in config.plugins.installs)
+      || (config.plugins?.entries && typeof config.plugins.entries === 'object' && MEM9_PLUGIN_ID in config.plugins.entries)
+  );
+  const entry = isRecord(config.plugins?.entries?.[MEM9_PLUGIN_ID]) ? config.plugins?.entries?.[MEM9_PLUGIN_ID] : {};
+  const pluginConfig = isRecord(entry.config) ? entry.config : {};
+  const apiKey = pickString(pluginConfig.apiKey);
+
+  return {
+    installed,
+    configured: Boolean(apiKey),
+    apiKey
+  };
+}
+
+function throwMem9Error(code: string, message: string): never {
+  throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, message, { code });
+}

package/src/admin/methods/pairing.ts

@@ -1,11 +1,16 @@
+import { execFile } from 'node:child_process';
 import path from 'node:path';
+import { promisify } from 'node:util';
 
 import { pathExists, readJsonFile, writeJsonFile } from '../lib/fs.ts';
 import { JsonRpcException, JSON_RPC_ERRORS } from '../jsonrpc.ts';
 import type { JsonValue, MethodContext } from '../types.ts';
 
+const execFileAsync = promisify(execFile);
+
 const DEFAULT_PLUGIN_ID = 'rol-websocket-channel';
 const DEFAULT_PAIR_ENDPOINT = 'http://api.deotaland.local/api-core-bot/front/agent/agent/key/query';
+const GATEWAY_SERVICE = 'openclaw-gateway.service';
 
 interface PairingCommandOptions {
   key: string;
@@ -57,6 +62,7 @@ export async function pairWithKey(
   const payload = await exchangePairKey(key, options.endpoint, options.auth, existingMqttUrl);
   applyPairingConfig(config, key, payload);
   await writeJsonFile(configPath, config);
+  const restart = await restartGateway(context.projectRoot);
 
   return {
     ok: true,
@@ -69,7 +75,7 @@ export async function pairWithKey(
       `channels.${payload.pluginId}`
     ],
     channel: payload.channel,
-    next: 'restart-openclaw-gateway'
+    restart
   };
 }
 
@@ -285,6 +291,23 @@ function resolveExistingMqttUrl(config: OpenClawConfig): string | null {
   return pickString(channelConfig.mqttUrl);
 }
 
+async function restartGateway(cwd: string): Promise<JsonValue> {
+  try {
+    await execFileAsync('systemctl', ['--user', 'restart', GATEWAY_SERVICE], { cwd });
+    return {
+      attempted: true,
+      success: true
+    };
+  } catch (error: any) {
+    return {
+      attempted: true,
+      success: false,
+      message: error instanceof Error ? error.message : String(error),
+      stderr: typeof error?.stderr === 'string' ? error.stderr : ''
+    };
+  }
+}
+
 function normalizeGroupPolicy(value: string): 'pairing' | 'allowlist' | 'open' | 'disabled' {
   if (value === 'pairing' || value === 'allowlist' || value === 'open' || value === 'disabled') {
     return value;

package/src/mqtt/connection-manager.ts

@@ -63,12 +63,11 @@ export function parseUsernameFromTopic(topic: string): string {
  */
 export function getSubscribeTopic(topic: string): string {
   const username = parseUsernameFromTopic(topic);
-  if (username !== "default_name") {
-    return `announcement/${username}/#`;
-  }
-  if (topic.endsWith("#")) return topic;
-  if (topic.endsWith("/")) return `${topic}#`;
-  return `${topic}/#`;
+  // if (username !== "default_name") {
+  //   return `announcement/${username}/#`;
+  // }
+  // if (topic.endsWith("#")) return topic;
+  return topic;
 }
 
 /**