rol-websocket-channel 1.6.7 → 1.7.0

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

@@ -1,6 +1,7 @@
 import { exec, execFile } from 'node:child_process';
 import path from 'node:path';
 import { promisify } from 'node:util';
+import fs from 'node:fs';
 import { pathExists, readJsonFile, writeJsonFile } from '../lib/fs.js';
 import { resolveOpenClawBin } from '../lib/openclaw-bin.js';
 import { JsonRpcException, JSON_RPC_ERRORS } from '../jsonrpc.js';
@@ -15,13 +16,26 @@ 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')
 ];
 // ---------------------------------------------------------------------------
 // Public API: installMem9 (idempotent, phase-based)
@@ -30,26 +44,48 @@ export async function installMem9(context) {
     const config = await ensureOpenClawConfigExists(context.openclawRoot);
     const currentState = readMem9State(config);
     const currentEntrypoint = await findMem9RuntimeEntrypoint(context.openclawRoot, config);
-    // Phase A: Plugin not installed → install only, then restart
+    // Phase A: Plugin not installed → install only, then write backend key if available, and restart
     if (!currentState.installed && !currentEntrypoint) {
         await ensureOpenClawCli();
         await ensureNodeRuntime();
         await installMem9Plugin(context.projectRoot);
+        const backendConfig = await fetchMem9KeyFromBackend(context.openclawRoot);
+        let updatedConfigs = [];
+        if (backendConfig) {
+            updatedConfigs = await writeMem9Config(context.openclawRoot, backendConfig.apiKey, backendConfig.apiUrl);
+        }
         const restart = await restartGateway(context.projectRoot);
         return {
             ok: true,
-            phase: 'installed',
+            phase: backendConfig ? 'configured' : 'installed',
             needsRestart: true,
             plugin: MEM9_PLUGIN_ID,
-            message: 'mem9 plugin installed. Gateway is restarting. Send mem9Install again to complete setup.',
+            apiKey: backendConfig?.apiKey ?? null,
+            apiUrl: backendConfig?.apiUrl ?? MEM9_API_URL,
+            updated: updatedConfigs.length > 0 ? updatedConfigs : null,
+            message: backendConfig
+                ? 'mem9 plugin installed and configured with backend key. Gateway is restarting.'
+                : 'mem9 plugin installed. Gateway is restarting. Send mem9Install again to complete setup.',
             restart
         };
     }
-    // Phase B: Installed but no key → create key, write config, restart
+    // Phase B: Installed but no key → fetch key from backend, fallback to creating a key, write config, restart
     if (!currentState.configured || !currentState.apiKey) {
         const runtimeEntrypoint = await ensureMem9RuntimeEntrypoint(context.openclawRoot, config);
-        const apiKey = await createMem9Key();
-        const updated = await writeMem9Config(context.openclawRoot, apiKey);
+        const backendConfig = await fetchMem9KeyFromBackend(context.openclawRoot);
+        let apiKey = backendConfig?.apiKey ?? null;
+        let apiUrl = backendConfig?.apiUrl ?? null;
+        let createdNewKey = false;
+        let reusedExistingKey = false;
+        if (!apiKey) {
+            apiKey = await createMem9Key();
+            apiUrl = MEM9_API_URL;
+            createdNewKey = true;
+        }
+        else {
+            reusedExistingKey = true;
+        }
+        const updated = await writeMem9Config(context.openclawRoot, apiKey, apiUrl);
         const restart = await restartGateway(context.projectRoot);
         return {
             ok: true,
@@ -57,11 +93,11 @@ export async function installMem9(context) {
             installed: true,
             alreadyInstalled: true,
             alreadyConfigured: false,
-            createdNewKey: true,
-            reusedExistingKey: false,
+            createdNewKey,
+            reusedExistingKey,
             plugin: MEM9_PLUGIN_ID,
             runtimeEntrypoint,
-            apiUrl: MEM9_API_URL,
+            apiUrl: apiUrl || MEM9_API_URL,
             apiKey,
             updated,
             restart
@@ -81,7 +117,7 @@ export async function installMem9(context) {
         reusedExistingKey: true,
         plugin: MEM9_PLUGIN_ID,
         runtimeEntrypoint,
-        apiUrl: MEM9_API_URL,
+        apiUrl: pickString(isRecord(config.plugins?.entries?.[MEM9_PLUGIN_ID]?.config) ? config.plugins.entries[MEM9_PLUGIN_ID].config.apiUrl : null) ?? MEM9_API_URL,
         apiKey: currentState.apiKey,
         updated,
         restart
@@ -145,7 +181,7 @@ async function ensureOpenClawConfigExists(openclawRoot) {
 async function ensureOpenClawCli() {
     const bin = resolveOpenClawBin();
     try {
-        await execFileAsync(bin, ['--version']);
+        await execAsync(`"${bin}" --version`);
     }
     catch (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) });
@@ -153,8 +189,8 @@ async function ensureOpenClawCli() {
 }
 async function ensureNodeRuntime() {
     try {
-        await execFileAsync('node', ['--version']);
-        await execFileAsync('npm', ['--version']);
+        await execAsync('node --version');
+        await execAsync('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) });
@@ -163,7 +199,7 @@ async function ensureNodeRuntime() {
 async function installMem9Plugin(cwd) {
     const bin = resolveOpenClawBin();
     try {
-        await execFileAsync(bin, ['plugins', 'install', MEM9_PLUGIN_SPEC], { cwd });
+        await execAsync(`"${bin}" plugins install ${MEM9_PLUGIN_SPEC} --force`, { cwd });
     }
     catch (error) {
         throw new JsonRpcException(JSON_RPC_ERRORS.internalError, `${bin} plugins install ${MEM9_PLUGIN_SPEC} failed`, {
@@ -175,7 +211,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;
             }
@@ -190,25 +227,134 @@ async function ensureMem9RuntimeEntrypoint(openclawRoot, config) {
     }
     const installRecord = readMem9InstallRecord(config);
     const checkedPackageRoots = resolveMem9RuntimePackageRoots(openclawRoot, config);
-    throw new JsonRpcException(JSON_RPC_ERRORS.internalError, 'mem9 plugin is installed but missing compiled runtime output', {
+    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 runtime not found; config exists but compiled plugin output is missing', {
         code: 'MEM9_RUNTIME_OUTPUT_MISSING',
-        expected: RUNTIME_ENTRYPOINTS.map((item) => `./${item.replace(/\\/g, '/')}`),
+        diagnosis: 'CONFIG_PRESENT_RUNTIME_MISSING',
+        summary: 'Mem9 is configured in openclaw.json, but no compiled JavaScript runtime was found under OpenClaw install paths.',
+        expected: FALLBACK_ENTRYPOINTS.map((item) => `./${item.replace(/\\/g, '/')}`),
         checkedPackageRoots,
-        checkedEntrypoints: checkedPackageRoots.flatMap((packageRoot) => RUNTIME_ENTRYPOINTS.map((item) => path.join(packageRoot, item))),
-        installRecord
+        checkedEntrypoints,
+        installRecord,
+        installState: describeMem9InstallState(openclawRoot, config),
+        suggestions: [
+            'Ensure OpenClaw has extensions/mem9 pointing to the installed @mem9/mem9 package.',
+            'If extensions/mem9 is missing or broken, run: openclaw plugins install @mem9/mem9 --force',
+            'If plugins.entries.mem9 exists but no runtime path exists, treat it as stale config residue rather than a complete install.'
+        ]
     });
 }
+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 pushRoot = (root) => {
+        if (!roots.includes(root))
+            roots.push(root);
+    };
     const installPath = pickString(readMem9InstallRecord(config)?.installPath);
     if (installPath) {
-        roots.push(path.isAbsolute(installPath) ? installPath : path.resolve(openclawRoot, installPath));
+        pushRoot(path.isAbsolute(installPath) ? installPath : path.resolve(openclawRoot, installPath));
     }
-    for (const fallbackRoot of MEM9_PACKAGE_ROOTS.map((item) => path.join(openclawRoot, item))) {
-        if (!roots.includes(fallbackRoot)) {
-            roots.push(fallbackRoot);
+    pushRoot(path.join(openclawRoot, 'extensions', MEM9_PLUGIN_ID));
+    const projectsDir = path.join(openclawRoot, 'npm', 'projects');
+    try {
+        if (fs.existsSync(projectsDir)) {
+            const projects = fs.readdirSync(projectsDir);
+            for (const project of projects) {
+                const candidate1 = path.join(projectsDir, project, 'node_modules', '@mem9', 'mem9');
+                const candidate2 = path.join(projectsDir, project, 'node_modules', 'mem9');
+                if (fs.existsSync(candidate1))
+                    pushRoot(candidate1);
+                if (fs.existsSync(candidate2))
+                    pushRoot(candidate2);
+            }
         }
     }
+    catch (err) {
+        console.warn('[Mem9] Failed to scan npm/projects:', err);
+    }
+    for (const fallbackRoot of MEM9_PACKAGE_ROOTS.map((item) => path.join(openclawRoot, item))) {
+        pushRoot(fallbackRoot);
+    }
     return roots;
 }
 async function createMem9Key() {
@@ -238,7 +384,79 @@ async function createMem9Key() {
 // ---------------------------------------------------------------------------
 // Config writers
 // ---------------------------------------------------------------------------
-async function writeMem9Config(openclawRoot, apiKey) {
+async function resolveApiCoreBotEndpoint(openclawRoot, overrideBaseUrl, overrideAuthToken) {
+    const config = await readJsonFile(path.join(openclawRoot, 'openclaw.json'));
+    const pluginConfig = config.plugins?.entries?.['rol-websocket-channel']?.config?.apiCoreBot ?? {};
+    const baseUrl = (overrideBaseUrl && overrideBaseUrl.trim()) || pluginConfig.baseUrl;
+    if (!baseUrl || !baseUrl.trim()) {
+        throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, 'apiCoreBot.baseUrl is not configured');
+    }
+    const authToken = (overrideAuthToken && overrideAuthToken.trim()) || pluginConfig.authToken;
+    return {
+        baseUrl: baseUrl.replace(/\/+$/, ''),
+        authToken
+    };
+}
+async function postJson(url, body, authToken) {
+    const headers = {
+        'Content-Type': 'application/json'
+    };
+    if (authToken && authToken.trim()) {
+        headers.Authorization = `Bearer ${authToken.trim()}`;
+    }
+    const response = await fetch(url, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify(body)
+    });
+    const payload = await response.json().catch(async () => await response.text());
+    if (!response.ok) {
+        throw new JsonRpcException(JSON_RPC_ERRORS.internalError, `Request failed: ${response.status}`, {
+            url,
+            status: response.status,
+            payload
+        });
+    }
+    return payload;
+}
+async function fetchMem9KeyFromBackend(openclawRoot) {
+    try {
+        const endpointConfig = await resolveApiCoreBotEndpoint(openclawRoot);
+        if (!endpointConfig.baseUrl) {
+            return null;
+        }
+        const response = await postJson(`${endpointConfig.baseUrl}/api-core-bot/front/mem9/key`, {}, endpointConfig.authToken);
+        const responseRecord = response;
+        const root = isRecord(responseRecord.data) ? responseRecord.data : responseRecord;
+        // Check nested structures (e.g. plugins.entries.mem9.config.apiKey)
+        let key = null;
+        let apiUrl = null;
+        if (isRecord(root.plugins?.entries?.mem9?.config)) {
+            key = pickString(root.plugins.entries.mem9.config.apiKey);
+            apiUrl = pickString(root.plugins.entries.mem9.config.apiUrl);
+        }
+        else if (isRecord(root.config)) {
+            key = pickString(root.config.apiKey);
+            apiUrl = pickString(root.config.apiUrl);
+        }
+        // Fallback to direct properties
+        if (!key) {
+            key = pickString(root.apiKey) ?? pickString(root.key) ?? pickString(root.id);
+        }
+        if (!apiUrl) {
+            apiUrl = pickString(root.apiUrl) ?? pickString(root.url);
+        }
+        if (!key) {
+            return null;
+        }
+        return { apiKey: key, apiUrl };
+    }
+    catch (error) {
+        console.warn('[Mem9] Failed to fetch key from apiCoreBot backend, will fallback to Mem9 official API:', error instanceof Error ? error.message : String(error));
+        return null;
+    }
+}
+async function writeMem9Config(openclawRoot, apiKey, apiUrl) {
     const configPath = path.join(openclawRoot, 'openclaw.json');
     const config = await readJsonFile(configPath);
     if (!config.plugins)
@@ -259,7 +477,7 @@ async function writeMem9Config(openclawRoot, apiKey) {
         },
         config: {
             ...existingPluginConfig,
-            apiUrl: MEM9_API_URL,
+            apiUrl: apiUrl || pickString(existingPluginConfig.apiUrl) || MEM9_API_URL,
             apiKey
         }
     };
@@ -318,7 +536,7 @@ function ensurePluginsAllow(config) {
 async function restartGateway(cwd) {
     const attempts = [];
     const bin = resolveOpenClawBin();
-    const restartCmd = `${bin} gateway restart`;
+    const restartCmd = `"${bin}" gateway restart`;
     try {
         const { stdout, stderr } = await execAsync(restartCmd, { cwd });
         return {
@@ -384,6 +602,25 @@ function readMem9InstallRecord(config) {
     const record = config?.plugins?.installs?.[MEM9_PLUGIN_ID];
     return isRecord(record) ? record : null;
 }
+function describeMem9InstallState(openclawRoot, config) {
+    const installRecord = readMem9InstallRecord(config);
+    const entry = isRecord(config?.plugins?.entries?.[MEM9_PLUGIN_ID]) ? config?.plugins?.entries?.[MEM9_PLUGIN_ID] : {};
+    const pluginConfig = isRecord(entry.config) ? entry.config : {};
+    const allow = config?.plugins?.allow;
+    const extensionsMem9Path = path.join(openclawRoot, 'extensions', MEM9_PLUGIN_ID);
+    return {
+        hasInstallRecord: Boolean(installRecord),
+        installPath: pickString(installRecord?.installPath),
+        hasEntry: isRecord(config?.plugins?.entries?.[MEM9_PLUGIN_ID]),
+        entryEnabled: entry.enabled === true,
+        hasApiKey: Boolean(pickString(pluginConfig.apiKey)),
+        apiUrl: pickString(pluginConfig.apiUrl),
+        allowContainsMem9: Array.isArray(allow) && allow.includes(MEM9_PLUGIN_ID),
+        memorySlot: typeof config?.plugins?.slots?.memory === 'string' ? config.plugins.slots.memory : null,
+        extensionsMem9Path,
+        extensionsMem9Exists: fs.existsSync(extensionsMem9Path)
+    };
+}
 function readMem9State(config) {
     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));

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

@@ -1,10 +1,63 @@
 import { describe, test } from 'node:test';
 import assert from 'node:assert/strict';
 import fs from 'node:fs/promises';
+import http from 'node:http';
 import os from 'node:os';
 import path from 'node:path';
-import { findMem9RuntimeEntrypoint } from './mem9.js';
+import { findMem9RuntimeEntrypoint, installMem9 } from './mem9.js';
 describe('mem9 runtime compatibility', () => {
+    test('runs Windows OpenClaw command shims from paths containing spaces during install', { skip: process.platform !== 'win32' }, async () => {
+        const originalOpenClawBin = process.env.OPENCLAW_BIN;
+        const originalCallsPath = process.env.FAKE_OPENCLAW_CALLS;
+        const root = await fs.mkdtemp(path.join(os.tmpdir(), 'mem9 cli shim '));
+        const backend = await createMem9Backend();
+        try {
+            const openclawRoot = path.join(root, '.openclaw');
+            await fs.mkdir(openclawRoot, { recursive: true });
+            await fs.writeFile(path.join(openclawRoot, 'openclaw.json'), JSON.stringify({
+                plugins: {
+                    entries: {
+                        'rol-websocket-channel': {
+                            config: {
+                                apiCoreBot: {
+                                    baseUrl: backend.url
+                                }
+                            }
+                        }
+                    }
+                }
+            }), 'utf8');
+            const callsPath = path.join(root, 'openclaw-calls.ndjson');
+            process.env.FAKE_OPENCLAW_CALLS = callsPath;
+            process.env.OPENCLAW_BIN = await createFakeOpenClawCmd(root);
+            const result = await installMem9({ projectRoot: root, openclawRoot });
+            const calls = await readCalls(callsPath);
+            assert.equal(result.ok, true);
+            assert.equal(result.phase, 'configured');
+            assert.equal(result.restart.success, true);
+            assert.deepEqual(calls, [
+                ['openclaw', '--version'],
+                ['openclaw', 'plugins', 'install', '@mem9/mem9', '--force'],
+                ['openclaw', 'gateway', 'restart']
+            ]);
+        }
+        finally {
+            if (originalOpenClawBin === undefined) {
+                delete process.env.OPENCLAW_BIN;
+            }
+            else {
+                process.env.OPENCLAW_BIN = originalOpenClawBin;
+            }
+            if (originalCallsPath === undefined) {
+                delete process.env.FAKE_OPENCLAW_CALLS;
+            }
+            else {
+                process.env.FAKE_OPENCLAW_CALLS = originalCallsPath;
+            }
+            await backend.close();
+            await fs.rm(root, { recursive: true, force: true });
+        }
+    });
     test('accepts compiled runtime output under the installed package', async () => {
         const root = await fs.mkdtemp(path.join(os.tmpdir(), 'mem9-runtime-'));
         try {
@@ -18,6 +71,64 @@ describe('mem9 runtime compatibility', () => {
             await fs.rm(root, { recursive: true, force: true });
         }
     });
+    test('resolves runtime from OpenClaw extensions/mem9', async () => {
+        const root = await fs.mkdtemp(path.join(os.tmpdir(), 'mem9-runtime-'));
+        try {
+            const packageRoot = path.join(root, '.openclaw', 'extensions', 'mem9');
+            await fs.mkdir(path.join(packageRoot, 'dist'), { recursive: true });
+            await fs.writeFile(path.join(packageRoot, 'dist', 'index.js'), 'export default {};\n', 'utf8');
+            const entrypoint = await findMem9RuntimeEntrypoint(path.join(root, '.openclaw'));
+            assert.equal(entrypoint, path.join(packageRoot, 'dist', 'index.js'));
+        }
+        finally {
+            await fs.rm(root, { recursive: true, force: true });
+        }
+    });
+    test('explains missing runtime when mem9 config exists without install output', async () => {
+        const root = await fs.mkdtemp(path.join(os.tmpdir(), 'mem9-runtime-'));
+        try {
+            const openclawRoot = path.join(root, '.openclaw');
+            await fs.mkdir(openclawRoot, { recursive: true });
+            await fs.writeFile(path.join(openclawRoot, 'openclaw.json'), JSON.stringify({
+                plugins: {
+                    allow: ['mem9'],
+                    entries: {
+                        mem9: {
+                            enabled: true,
+                            config: {
+                                apiUrl: 'https://api.mem9.ai',
+                                apiKey: 'test-key'
+                            },
+                            hooks: {
+                                allowConversationAccess: true
+                            }
+                        }
+                    },
+                    slots: {
+                        memory: 'mem9'
+                    }
+                }
+            }), 'utf8');
+            await assert.rejects(() => installMem9({ projectRoot: root, openclawRoot }), (error) => {
+                assert.equal(error.message, 'mem9 runtime not found; config exists but compiled plugin output is missing');
+                assert.equal(error.data?.code, 'MEM9_RUNTIME_OUTPUT_MISSING');
+                assert.equal(error.data?.diagnosis, 'CONFIG_PRESENT_RUNTIME_MISSING');
+                assert.equal(error.data?.installState?.hasInstallRecord, false);
+                assert.equal(error.data?.installState?.hasEntry, true);
+                assert.equal(error.data?.installState?.entryEnabled, true);
+                assert.equal(error.data?.installState?.hasApiKey, true);
+                assert.equal(error.data?.installState?.allowContainsMem9, true);
+                assert.equal(error.data?.installState?.memorySlot, 'mem9');
+                assert.equal(error.data?.installState?.extensionsMem9Exists, false);
+                assert.ok(error.data?.checkedPackageRoots.includes(path.join(openclawRoot, 'extensions', 'mem9')));
+                assert.ok(error.data?.suggestions.includes('Ensure OpenClaw has extensions/mem9 pointing to the installed @mem9/mem9 package.'));
+                return true;
+            });
+        }
+        finally {
+            await fs.rm(root, { recursive: true, force: true });
+        }
+    });
     test('rejects TypeScript-only mem9 packages before writing memory slot', async () => {
         const root = await fs.mkdtemp(path.join(os.tmpdir(), 'mem9-runtime-'));
         try {
@@ -31,4 +142,118 @@ 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 });
+        }
+    });
 });
+async function createMem9Backend() {
+    const server = http.createServer(async (request, response) => {
+        if (request.method !== 'POST' || request.url !== '/api-core-bot/front/mem9/key') {
+            response.writeHead(404).end();
+            return;
+        }
+        for await (const _chunk of request) {
+            // Drain the request body so Node can close the connection cleanly.
+        }
+        response.writeHead(200, { 'Content-Type': 'application/json' });
+        response.end(JSON.stringify({
+            data: {
+                apiKey: 'backend-mem9-key',
+                apiUrl: 'https://api.mem9.test'
+            }
+        }));
+    });
+    await new Promise((resolve) => {
+        server.listen(0, '127.0.0.1', resolve);
+    });
+    const address = server.address();
+    assert.ok(address && typeof address === 'object');
+    return {
+        url: `http://127.0.0.1:${address.port}`,
+        close: () => new Promise((resolve, reject) => {
+            server.close((error) => error ? reject(error) : resolve());
+        })
+    };
+}
+async function createFakeOpenClawCmd(root) {
+    const scriptPath = path.join(root, 'fake openclaw.cmd');
+    await fs.writeFile(scriptPath, [
+        '@echo off',
+        'node "%~dp0fake-openclaw.js" %*'
+    ].join('\r\n'), 'utf8');
+    await fs.writeFile(path.join(root, 'fake-openclaw.js'), [
+        "import fs from 'node:fs';",
+        'const file = process.env.FAKE_OPENCLAW_CALLS;',
+        'if (!file) { throw new Error("FAKE_OPENCLAW_CALLS is required"); }',
+        'fs.appendFileSync(file, `${JSON.stringify(["openclaw", ...process.argv.slice(2)])}\\n`);',
+        'console.log("OpenClaw 2026.6.1 (2e08f0f)");'
+    ].join('\n'), 'utf8');
+    return scriptPath;
+}
+async function readCalls(callsPath) {
+    const content = await fs.readFile(callsPath, 'utf8');
+    return content.trim().split(/\r?\n/).filter(Boolean).map((line) => JSON.parse(line));
+}