rol-websocket-channel 1.6.4 → 1.6.9

package/dist/src/admin/lib/openclaw-bin.js

@@ -0,0 +1,3 @@
+export function resolveOpenClawBin() {
+    return process.env.OPENCLAW_BIN || 'openclaw';
+}

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

@@ -2,6 +2,7 @@ import { exec, execFile } from 'node:child_process';
 import path from 'node:path';
 import { promisify } from 'node:util';
 import { pathExists, readJsonFile, writeJsonFile } from '../lib/fs.js';
+import { resolveOpenClawBin } from '../lib/openclaw-bin.js';
 import { JsonRpcException, JSON_RPC_ERRORS } from '../jsonrpc.js';
 const execAsync = promisify(exec);
 const execFileAsync = promisify(execFile);
@@ -14,21 +15,28 @@ const MEM9_PACKAGE_ROOTS = [
     path.join('npm', 'node_modules', '@mem9', 'mem9'),
     path.join('npm', 'node_modules', 'mem9')
 ];
-const RUNTIME_ENTRYPOINTS = [
+const RUNTIME_FILE_EXTENSIONS = new Set(['.js', '.mjs', '.cjs']);
+const FALLBACK_ENTRYPOINTS = [
     path.join('dist', 'index.js'),
     path.join('dist', 'index.mjs'),
     path.join('dist', 'index.cjs'),
     'index.js',
     'index.mjs',
-    'index.cjs'
+    'index.cjs',
+    path.join('lib', 'index.js'),
+    path.join('lib', 'index.mjs'),
+    path.join('lib', 'index.cjs'),
+    path.join('build', 'index.js'),
+    path.join('build', 'index.mjs'),
+    path.join('build', 'index.cjs'),
+    path.join('out', 'index.js'),
+    path.join('out', 'index.mjs'),
+    path.join('out', 'index.cjs'),
+    path.join('dist', 'main.js'),
+    path.join('dist', 'main.mjs'),
+    path.join('dist', 'main.cjs')
 ];
 // ---------------------------------------------------------------------------
-// Resolve openclaw binary path (supports OPENCLAW_BIN env override)
-// ---------------------------------------------------------------------------
-function resolveOpenClawBin() {
-    return process.env.OPENCLAW_BIN || 'openclaw';
-}
-// ---------------------------------------------------------------------------
 // Public API: installMem9 (idempotent, phase-based)
 // ---------------------------------------------------------------------------
 export async function installMem9(context) {
@@ -153,7 +161,7 @@ async function ensureOpenClawCli() {
         await execFileAsync(bin, ['--version']);
     }
     catch (error) {
-        throw new JsonRpcException(JSON_RPC_ERRORS.internalError, `openclaw command is not available (tried: ${bin}). Set OPENCLAW_BIN env to override.`, { code: 'MEM9_OPENCLAW_NOT_FOUND', bin, detail: error instanceof Error ? error.message : String(error) });
+        throw new JsonRpcException(JSON_RPC_ERRORS.internalError, `openclaw command is not available (tried: ${bin}). Configure the OpenClaw binary path for the Gateway service.`, { code: 'MEM9_OPENCLAW_NOT_FOUND', bin, detail: error instanceof Error ? error.message : String(error) });
     }
 }
 async function ensureNodeRuntime() {
@@ -180,7 +188,8 @@ async function installMem9Plugin(cwd) {
 }
 export async function findMem9RuntimeEntrypoint(openclawRoot, config) {
     for (const packageRoot of resolveMem9RuntimePackageRoots(openclawRoot, config)) {
-        for (const entrypoint of RUNTIME_ENTRYPOINTS.map((item) => path.join(packageRoot, item))) {
+        const manifest = await readPluginManifest(packageRoot);
+        for (const entrypoint of collectEntrypointCandidates(packageRoot, manifest)) {
             if (await pathExists(entrypoint)) {
                 return entrypoint;
             }
@@ -195,14 +204,95 @@ async function ensureMem9RuntimeEntrypoint(openclawRoot, config) {
     }
     const installRecord = readMem9InstallRecord(config);
     const checkedPackageRoots = resolveMem9RuntimePackageRoots(openclawRoot, config);
+    const checkedEntrypoints = [];
+    for (const packageRoot of checkedPackageRoots) {
+        const manifest = await readPluginManifest(packageRoot);
+        for (const candidate of collectEntrypointCandidates(packageRoot, manifest)) {
+            if (!checkedEntrypoints.includes(candidate)) {
+                checkedEntrypoints.push(candidate);
+            }
+        }
+    }
     throw new JsonRpcException(JSON_RPC_ERRORS.internalError, 'mem9 plugin is installed but missing compiled runtime output', {
         code: 'MEM9_RUNTIME_OUTPUT_MISSING',
-        expected: RUNTIME_ENTRYPOINTS.map((item) => `./${item.replace(/\\/g, '/')}`),
+        expected: FALLBACK_ENTRYPOINTS.map((item) => `./${item.replace(/\\/g, '/')}`),
         checkedPackageRoots,
-        checkedEntrypoints: checkedPackageRoots.flatMap((packageRoot) => RUNTIME_ENTRYPOINTS.map((item) => path.join(packageRoot, item))),
+        checkedEntrypoints,
         installRecord
     });
 }
+async function readPluginManifest(packageRoot) {
+    const manifestPath = path.join(packageRoot, 'package.json');
+    if (!(await pathExists(manifestPath)))
+        return null;
+    try {
+        return await readJsonFile(manifestPath);
+    }
+    catch {
+        return null;
+    }
+}
+function isRuntimeFile(relPath) {
+    return RUNTIME_FILE_EXTENSIONS.has(path.extname(relPath).toLowerCase());
+}
+function normalizeRelative(value) {
+    return value.replace(/^\.[\\/]+/, '').split(/[\\/]+/).join(path.sep);
+}
+function collectExportsEntries(value) {
+    const out = [];
+    const visit = (node, contextKey) => {
+        if (typeof node === 'string') {
+            out.push(node);
+            return;
+        }
+        if (Array.isArray(node)) {
+            for (const child of node)
+                visit(child, contextKey);
+            return;
+        }
+        if (node && typeof node === 'object') {
+            for (const [key, child] of Object.entries(node)) {
+                if (key.startsWith('.') && key !== '.')
+                    continue;
+                visit(child, key);
+            }
+        }
+    };
+    visit(value, null);
+    return out;
+}
+function collectEntrypointCandidates(packageRoot, manifest) {
+    const seen = new Set();
+    const out = [];
+    const push = (relCandidate) => {
+        if (typeof relCandidate !== 'string')
+            return;
+        const normalized = normalizeRelative(relCandidate);
+        if (!normalized)
+            return;
+        if (!isRuntimeFile(normalized))
+            return;
+        const absolute = path.isAbsolute(normalized) ? normalized : path.join(packageRoot, normalized);
+        if (seen.has(absolute))
+            return;
+        seen.add(absolute);
+        out.push(absolute);
+    };
+    const declaredRuntime = manifest?.openclaw?.runtimeExtensions;
+    if (Array.isArray(declaredRuntime)) {
+        for (const item of declaredRuntime)
+            push(item);
+    }
+    if (manifest?.exports !== undefined) {
+        for (const item of collectExportsEntries(manifest.exports))
+            push(item);
+    }
+    push(manifest?.module);
+    push(manifest?.main);
+    for (const item of FALLBACK_ENTRYPOINTS)
+        push(item);
+    return out;
+}
 function resolveMem9RuntimePackageRoots(openclawRoot, config) {
     const roots = [];
     const installPath = pickString(readMem9InstallRecord(config)?.installPath);

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

@@ -31,4 +31,70 @@ describe('mem9 runtime compatibility', () => {
             await fs.rm(root, { recursive: true, force: true });
         }
     });
+    test('honors package.json main when output lives in a non-standard directory', async () => {
+        const root = await fs.mkdtemp(path.join(os.tmpdir(), 'mem9-runtime-'));
+        try {
+            const packageRoot = path.join(root, '.openclaw', 'npm', 'node_modules', '@mem9', 'mem9');
+            await fs.mkdir(path.join(packageRoot, 'compiled'), { recursive: true });
+            await fs.writeFile(path.join(packageRoot, 'compiled', 'plugin.js'), 'export default {};\n', 'utf8');
+            await fs.writeFile(path.join(packageRoot, 'package.json'), JSON.stringify({ name: '@mem9/mem9', main: './compiled/plugin.js' }), 'utf8');
+            const entrypoint = await findMem9RuntimeEntrypoint(path.join(root, '.openclaw'));
+            assert.equal(entrypoint, path.join(packageRoot, 'compiled', 'plugin.js'));
+        }
+        finally {
+            await fs.rm(root, { recursive: true, force: true });
+        }
+    });
+    test('resolves runtime from package.json exports conditional map', async () => {
+        const root = await fs.mkdtemp(path.join(os.tmpdir(), 'mem9-runtime-'));
+        try {
+            const packageRoot = path.join(root, '.openclaw', 'npm', 'node_modules', 'mem9');
+            await fs.mkdir(path.join(packageRoot, 'dist', 'esm'), { recursive: true });
+            await fs.writeFile(path.join(packageRoot, 'dist', 'esm', 'index.js'), 'export default {};\n', 'utf8');
+            await fs.writeFile(path.join(packageRoot, 'package.json'), JSON.stringify({
+                name: 'mem9',
+                exports: {
+                    '.': {
+                        import: './dist/esm/index.js',
+                        require: './dist/cjs/index.cjs'
+                    }
+                }
+            }), 'utf8');
+            const entrypoint = await findMem9RuntimeEntrypoint(path.join(root, '.openclaw'));
+            assert.equal(entrypoint, path.join(packageRoot, 'dist', 'esm', 'index.js'));
+        }
+        finally {
+            await fs.rm(root, { recursive: true, force: true });
+        }
+    });
+    test('respects openclaw.runtimeExtensions declared by the plugin manifest', async () => {
+        const root = await fs.mkdtemp(path.join(os.tmpdir(), 'mem9-runtime-'));
+        try {
+            const packageRoot = path.join(root, '.openclaw', 'npm', 'node_modules', '@mem9', 'mem9');
+            await fs.mkdir(path.join(packageRoot, 'build'), { recursive: true });
+            await fs.writeFile(path.join(packageRoot, 'build', 'runtime.mjs'), 'export default {};\n', 'utf8');
+            await fs.writeFile(path.join(packageRoot, 'package.json'), JSON.stringify({
+                name: '@mem9/mem9',
+                openclaw: { runtimeExtensions: ['./build/runtime.mjs'] }
+            }), 'utf8');
+            const entrypoint = await findMem9RuntimeEntrypoint(path.join(root, '.openclaw'));
+            assert.equal(entrypoint, path.join(packageRoot, 'build', 'runtime.mjs'));
+        }
+        finally {
+            await fs.rm(root, { recursive: true, force: true });
+        }
+    });
+    test('falls back to lib/index.js when neither manifest nor dist exists', async () => {
+        const root = await fs.mkdtemp(path.join(os.tmpdir(), 'mem9-runtime-'));
+        try {
+            const packageRoot = path.join(root, '.openclaw', 'npm', 'node_modules', 'mem9');
+            await fs.mkdir(path.join(packageRoot, 'lib'), { recursive: true });
+            await fs.writeFile(path.join(packageRoot, 'lib', 'index.js'), 'module.exports = {};\n', 'utf8');
+            const entrypoint = await findMem9RuntimeEntrypoint(path.join(root, '.openclaw'));
+            assert.equal(entrypoint, path.join(packageRoot, 'lib', 'index.js'));
+        }
+        finally {
+            await fs.rm(root, { recursive: true, force: true });
+        }
+    });
 });

package/package.json

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

package/src/admin/lib/openclaw-bin.ts

@@ -0,0 +1,3 @@
+export function resolveOpenClawBin(): string {
+  return process.env.OPENCLAW_BIN || 'openclaw';
+}

package/src/admin/methods/mem9.test.ts

@@ -36,4 +36,90 @@ describe('mem9 runtime compatibility', () => {
       await fs.rm(root, { recursive: true, force: true });
     }
   });
+
+  test('honors package.json main when output lives in a non-standard directory', async () => {
+    const root = await fs.mkdtemp(path.join(os.tmpdir(), 'mem9-runtime-'));
+    try {
+      const packageRoot = path.join(root, '.openclaw', 'npm', 'node_modules', '@mem9', 'mem9');
+      await fs.mkdir(path.join(packageRoot, 'compiled'), { recursive: true });
+      await fs.writeFile(path.join(packageRoot, 'compiled', 'plugin.js'), 'export default {};\n', 'utf8');
+      await fs.writeFile(
+        path.join(packageRoot, 'package.json'),
+        JSON.stringify({ name: '@mem9/mem9', main: './compiled/plugin.js' }),
+        'utf8'
+      );
+
+      const entrypoint = await findMem9RuntimeEntrypoint(path.join(root, '.openclaw'));
+
+      assert.equal(entrypoint, path.join(packageRoot, 'compiled', 'plugin.js'));
+    } finally {
+      await fs.rm(root, { recursive: true, force: true });
+    }
+  });
+
+  test('resolves runtime from package.json exports conditional map', async () => {
+    const root = await fs.mkdtemp(path.join(os.tmpdir(), 'mem9-runtime-'));
+    try {
+      const packageRoot = path.join(root, '.openclaw', 'npm', 'node_modules', 'mem9');
+      await fs.mkdir(path.join(packageRoot, 'dist', 'esm'), { recursive: true });
+      await fs.writeFile(path.join(packageRoot, 'dist', 'esm', 'index.js'), 'export default {};\n', 'utf8');
+      await fs.writeFile(
+        path.join(packageRoot, 'package.json'),
+        JSON.stringify({
+          name: 'mem9',
+          exports: {
+            '.': {
+              import: './dist/esm/index.js',
+              require: './dist/cjs/index.cjs'
+            }
+          }
+        }),
+        'utf8'
+      );
+
+      const entrypoint = await findMem9RuntimeEntrypoint(path.join(root, '.openclaw'));
+
+      assert.equal(entrypoint, path.join(packageRoot, 'dist', 'esm', 'index.js'));
+    } finally {
+      await fs.rm(root, { recursive: true, force: true });
+    }
+  });
+
+  test('respects openclaw.runtimeExtensions declared by the plugin manifest', async () => {
+    const root = await fs.mkdtemp(path.join(os.tmpdir(), 'mem9-runtime-'));
+    try {
+      const packageRoot = path.join(root, '.openclaw', 'npm', 'node_modules', '@mem9', 'mem9');
+      await fs.mkdir(path.join(packageRoot, 'build'), { recursive: true });
+      await fs.writeFile(path.join(packageRoot, 'build', 'runtime.mjs'), 'export default {};\n', 'utf8');
+      await fs.writeFile(
+        path.join(packageRoot, 'package.json'),
+        JSON.stringify({
+          name: '@mem9/mem9',
+          openclaw: { runtimeExtensions: ['./build/runtime.mjs'] }
+        }),
+        'utf8'
+      );
+
+      const entrypoint = await findMem9RuntimeEntrypoint(path.join(root, '.openclaw'));
+
+      assert.equal(entrypoint, path.join(packageRoot, 'build', 'runtime.mjs'));
+    } finally {
+      await fs.rm(root, { recursive: true, force: true });
+    }
+  });
+
+  test('falls back to lib/index.js when neither manifest nor dist exists', async () => {
+    const root = await fs.mkdtemp(path.join(os.tmpdir(), 'mem9-runtime-'));
+    try {
+      const packageRoot = path.join(root, '.openclaw', 'npm', 'node_modules', 'mem9');
+      await fs.mkdir(path.join(packageRoot, 'lib'), { recursive: true });
+      await fs.writeFile(path.join(packageRoot, 'lib', 'index.js'), 'module.exports = {};\n', 'utf8');
+
+      const entrypoint = await findMem9RuntimeEntrypoint(path.join(root, '.openclaw'));
+
+      assert.equal(entrypoint, path.join(packageRoot, 'lib', 'index.js'));
+    } finally {
+      await fs.rm(root, { recursive: true, force: true });
+    }
+  });
 });

package/src/admin/methods/mem9.ts

@@ -3,6 +3,7 @@ import path from 'node:path';
 import { promisify } from 'node:util';
 
 import { pathExists, readJsonFile, writeJsonFile } from '../lib/fs.js';
+import { resolveOpenClawBin } from '../lib/openclaw-bin.js';
 import { JsonRpcException, JSON_RPC_ERRORS } from '../jsonrpc.js';
 import type { JsonValue, MethodContext } from '../types.js';
 
@@ -18,15 +19,38 @@ const MEM9_PACKAGE_ROOTS = [
   path.join('npm', 'node_modules', '@mem9', 'mem9'),
   path.join('npm', 'node_modules', 'mem9')
 ];
-const RUNTIME_ENTRYPOINTS = [
+const RUNTIME_FILE_EXTENSIONS = new Set(['.js', '.mjs', '.cjs']);
+const FALLBACK_ENTRYPOINTS = [
   path.join('dist', 'index.js'),
   path.join('dist', 'index.mjs'),
   path.join('dist', 'index.cjs'),
   'index.js',
   'index.mjs',
-  'index.cjs'
+  'index.cjs',
+  path.join('lib', 'index.js'),
+  path.join('lib', 'index.mjs'),
+  path.join('lib', 'index.cjs'),
+  path.join('build', 'index.js'),
+  path.join('build', 'index.mjs'),
+  path.join('build', 'index.cjs'),
+  path.join('out', 'index.js'),
+  path.join('out', 'index.mjs'),
+  path.join('out', 'index.cjs'),
+  path.join('dist', 'main.js'),
+  path.join('dist', 'main.mjs'),
+  path.join('dist', 'main.cjs')
 ];
 
+interface PluginManifest {
+  main?: unknown;
+  module?: unknown;
+  exports?: unknown;
+  openclaw?: {
+    runtimeExtensions?: unknown;
+    extensions?: unknown;
+  };
+}
+
 interface OpenClawConfig {
   plugins?: {
     allow?: string[];
@@ -38,14 +62,6 @@ interface OpenClawConfig {
   [key: string]: any;
 }
 
-// ---------------------------------------------------------------------------
-// Resolve openclaw binary path (supports OPENCLAW_BIN env override)
-// ---------------------------------------------------------------------------
-
-function resolveOpenClawBin(): string {
-  return process.env.OPENCLAW_BIN || 'openclaw';
-}
-
 // ---------------------------------------------------------------------------
 // Public API: installMem9 (idempotent, phase-based)
 // ---------------------------------------------------------------------------
@@ -189,7 +205,7 @@ async function ensureOpenClawCli(): Promise<void> {
   } catch (error) {
     throw new JsonRpcException(
       JSON_RPC_ERRORS.internalError,
-      `openclaw command is not available (tried: ${bin}). Set OPENCLAW_BIN env to override.`,
+      `openclaw command is not available (tried: ${bin}). Configure the OpenClaw binary path for the Gateway service.`,
       { code: 'MEM9_OPENCLAW_NOT_FOUND', bin, detail: error instanceof Error ? error.message : String(error) }
     );
   }
@@ -227,7 +243,8 @@ async function installMem9Plugin(cwd: string): Promise<void> {
 
 export async function findMem9RuntimeEntrypoint(openclawRoot: string, config?: OpenClawConfig): Promise<string | null> {
   for (const packageRoot of resolveMem9RuntimePackageRoots(openclawRoot, config)) {
-    for (const entrypoint of RUNTIME_ENTRYPOINTS.map((item) => path.join(packageRoot, item))) {
+    const manifest = await readPluginManifest(packageRoot);
+    for (const entrypoint of collectEntrypointCandidates(packageRoot, manifest)) {
       if (await pathExists(entrypoint)) {
         return entrypoint;
       }
@@ -243,19 +260,97 @@ async function ensureMem9RuntimeEntrypoint(openclawRoot: string, config?: OpenCl
   }
   const installRecord = readMem9InstallRecord(config);
   const checkedPackageRoots = resolveMem9RuntimePackageRoots(openclawRoot, config);
+  const checkedEntrypoints: string[] = [];
+  for (const packageRoot of checkedPackageRoots) {
+    const manifest = await readPluginManifest(packageRoot);
+    for (const candidate of collectEntrypointCandidates(packageRoot, manifest)) {
+      if (!checkedEntrypoints.includes(candidate)) {
+        checkedEntrypoints.push(candidate);
+      }
+    }
+  }
   throw new JsonRpcException(
     JSON_RPC_ERRORS.internalError,
     'mem9 plugin is installed but missing compiled runtime output',
     {
       code: 'MEM9_RUNTIME_OUTPUT_MISSING',
-      expected: RUNTIME_ENTRYPOINTS.map((item) => `./${item.replace(/\\/g, '/')}`),
+      expected: FALLBACK_ENTRYPOINTS.map((item) => `./${item.replace(/\\/g, '/')}`),
       checkedPackageRoots,
-      checkedEntrypoints: checkedPackageRoots.flatMap((packageRoot) => RUNTIME_ENTRYPOINTS.map((item) => path.join(packageRoot, item))),
+      checkedEntrypoints,
       installRecord
     }
   );
 }
 
+async function readPluginManifest(packageRoot: string): Promise<PluginManifest | null> {
+  const manifestPath = path.join(packageRoot, 'package.json');
+  if (!(await pathExists(manifestPath))) return null;
+  try {
+    return await readJsonFile<PluginManifest>(manifestPath);
+  } catch {
+    return null;
+  }
+}
+
+function isRuntimeFile(relPath: string): boolean {
+  return RUNTIME_FILE_EXTENSIONS.has(path.extname(relPath).toLowerCase());
+}
+
+function normalizeRelative(value: string): string {
+  return value.replace(/^\.[\\/]+/, '').split(/[\\/]+/).join(path.sep);
+}
+
+function collectExportsEntries(value: unknown): string[] {
+  const out: string[] = [];
+  const visit = (node: unknown, contextKey: string | null): void => {
+    if (typeof node === 'string') {
+      out.push(node);
+      return;
+    }
+    if (Array.isArray(node)) {
+      for (const child of node) visit(child, contextKey);
+      return;
+    }
+    if (node && typeof node === 'object') {
+      for (const [key, child] of Object.entries(node as Record<string, unknown>)) {
+        if (key.startsWith('.') && key !== '.') continue;
+        visit(child, key);
+      }
+    }
+  };
+  visit(value, null);
+  return out;
+}
+
+function collectEntrypointCandidates(packageRoot: string, manifest: PluginManifest | null): string[] {
+  const seen = new Set<string>();
+  const out: string[] = [];
+  const push = (relCandidate: unknown): void => {
+    if (typeof relCandidate !== 'string') return;
+    const normalized = normalizeRelative(relCandidate);
+    if (!normalized) return;
+    if (!isRuntimeFile(normalized)) return;
+    const absolute = path.isAbsolute(normalized) ? normalized : path.join(packageRoot, normalized);
+    if (seen.has(absolute)) return;
+    seen.add(absolute);
+    out.push(absolute);
+  };
+
+  const declaredRuntime = manifest?.openclaw?.runtimeExtensions;
+  if (Array.isArray(declaredRuntime)) {
+    for (const item of declaredRuntime) push(item);
+  }
+  if (manifest?.exports !== undefined) {
+    for (const item of collectExportsEntries(manifest.exports)) push(item);
+  }
+  push(manifest?.module);
+  push(manifest?.main);
+
+  for (const item of FALLBACK_ENTRYPOINTS) push(item);
+
+  return out;
+}
+
 function resolveMem9RuntimePackageRoots(openclawRoot: string, config?: OpenClawConfig): string[] {
   const roots: string[] = [];
   const installPath = pickString(readMem9InstallRecord(config)?.installPath);