rol-websocket-channel 1.4.2 → 1.4.8

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

@@ -1,270 +1,309 @@
-import { execFile } from 'node:child_process';
-import path from 'node:path';
-import { promisify } from 'node:util';
-import { pathExists, readJsonFile, writeJsonFile } from '../lib/fs.js';
-import { JsonRpcException, JSON_RPC_ERRORS } from '../jsonrpc.js';
-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';
-export async function installMem9(context) {
-    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, context) {
-    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) {
-    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) {
-    const configPath = path.join(openclawRoot, 'openclaw.json');
-    if (!(await pathExists(configPath))) {
-        throwMem9Error('MEM9_CONFIG_NOT_FOUND', `openclaw.json not found: ${configPath}`);
-    }
-    return await readJsonFile(configPath);
-}
-async function ensureOpenClawCli() {
-    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() {
-    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, cwd, code) {
-    try {
-        await execFileAsync('openclaw', args, { cwd });
-    }
-    catch (error) {
-        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) {
-    await runOpenClawCommand(['plugins', 'install', MEM9_PLUGIN_SPEC], cwd, 'MEM9_PLUGIN_INSTALL_FAILED');
-    return {
-        attempted: true,
-        installed: true
-    };
-}
-async function createMem9Key() {
-    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, apiKey) {
-    const configPath = path.join(openclawRoot, 'openclaw.json');
-    const config = await readJsonFile(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, apiKey) {
-    const configPath = path.join(openclawRoot, 'openclaw.json');
-    const config = await readJsonFile(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) {
-    try {
-        await execFileAsync('systemctl', ['--user', 'restart', GATEWAY_SERVICE], { cwd });
-        return {
-            attempted: true,
-            success: true
-        };
-    }
-    catch (error) {
-        return {
-            attempted: true,
-            success: false,
-            message: error instanceof Error ? error.message : String(error),
-            stderr: typeof error?.stderr === 'string' ? error.stderr : ''
-        };
-    }
-}
-function tryParseJson(raw) {
-    const trimmed = raw.trim();
-    if (!trimmed) {
-        return {};
-    }
-    try {
-        return JSON.parse(trimmed);
-    }
-    catch {
-        return raw;
-    }
-}
-function pickString(value) {
-    if (typeof value !== 'string') {
-        return null;
-    }
-    const trimmed = value.trim();
-    return trimmed.length > 0 ? trimmed : null;
-}
-function isRecord(value) {
-    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
-}
-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));
-    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, message) {
-    throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, message, { code });
-}
+import { execFile } from 'node:child_process';
+import path from 'node:path';
+import { promisify } from 'node:util';
+import { pathExists, readJsonFile, writeJsonFile } from '../lib/fs.js';
+import { JsonRpcException, JSON_RPC_ERRORS } from '../jsonrpc.js';
+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';
+const MEM9_PACKAGE_ROOTS = [
+    path.join('npm', 'node_modules', '@mem9', 'mem9'),
+    path.join('npm', 'node_modules', 'mem9')
+];
+const RUNTIME_ENTRYPOINTS = [
+    path.join('dist', 'index.js'),
+    path.join('dist', 'index.mjs'),
+    path.join('dist', 'index.cjs'),
+    'index.js',
+    'index.mjs',
+    'index.cjs'
+];
+export async function installMem9(context) {
+    const config = await ensureOpenClawConfigExists(context.openclawRoot);
+    await ensureOpenClawCli();
+    await ensureNodeRuntime();
+    const currentState = readMem9State(config);
+    const currentEntrypoint = await findMem9RuntimeEntrypoint(context.openclawRoot);
+    const installResult = currentState.installed && currentEntrypoint
+        ? { attempted: false, installed: true }
+        : await installMem9Plugin(context.projectRoot);
+    const runtimeEntrypoint = await ensureMem9RuntimeEntrypoint(context.openclawRoot);
+    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,
+            runtimeEntrypoint,
+            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,
+        runtimeEntrypoint,
+        apiUrl: MEM9_API_URL,
+        apiKey,
+        updated,
+        restart
+    };
+}
+export async function reconnectMem9(key, context) {
+    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 runtimeEntrypoint = await ensureMem9RuntimeEntrypoint(context.openclawRoot);
+    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,
+        runtimeEntrypoint,
+        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) {
+    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) {
+    const configPath = path.join(openclawRoot, 'openclaw.json');
+    if (!(await pathExists(configPath))) {
+        throwMem9Error('MEM9_CONFIG_NOT_FOUND', `openclaw.json not found: ${configPath}`);
+    }
+    return await readJsonFile(configPath);
+}
+async function ensureOpenClawCli() {
+    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() {
+    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, cwd, code) {
+    try {
+        await execFileAsync('openclaw', args, { cwd });
+    }
+    catch (error) {
+        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) {
+    await runOpenClawCommand(['plugins', 'install', MEM9_PLUGIN_SPEC], cwd, 'MEM9_PLUGIN_INSTALL_FAILED');
+    return {
+        attempted: true,
+        installed: true
+    };
+}
+export async function findMem9RuntimeEntrypoint(openclawRoot) {
+    for (const packageRoot of MEM9_PACKAGE_ROOTS.map((item) => path.join(openclawRoot, item))) {
+        for (const entrypoint of RUNTIME_ENTRYPOINTS.map((item) => path.join(packageRoot, item))) {
+            if (await pathExists(entrypoint)) {
+                return entrypoint;
+            }
+        }
+    }
+    return null;
+}
+async function ensureMem9RuntimeEntrypoint(openclawRoot) {
+    const entrypoint = await findMem9RuntimeEntrypoint(openclawRoot);
+    if (entrypoint) {
+        return entrypoint;
+    }
+    throw new JsonRpcException(JSON_RPC_ERRORS.internalError, 'mem9 plugin is installed but missing compiled runtime output required by OpenClaw 2026.5.6', {
+        code: 'MEM9_RUNTIME_OUTPUT_MISSING',
+        expected: RUNTIME_ENTRYPOINTS.map((item) => `./${item.replace(/\\/g, '/')}`),
+        packageRoots: MEM9_PACKAGE_ROOTS.map((item) => path.join(openclawRoot, item))
+    });
+}
+async function createMem9Key() {
+    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, apiKey) {
+    const configPath = path.join(openclawRoot, 'openclaw.json');
+    const config = await readJsonFile(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, apiKey) {
+    const configPath = path.join(openclawRoot, 'openclaw.json');
+    const config = await readJsonFile(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) {
+    try {
+        await execFileAsync('systemctl', ['--user', 'restart', GATEWAY_SERVICE], { cwd });
+        return {
+            attempted: true,
+            success: true
+        };
+    }
+    catch (error) {
+        return {
+            attempted: true,
+            success: false,
+            message: error instanceof Error ? error.message : String(error),
+            stderr: typeof error?.stderr === 'string' ? error.stderr : ''
+        };
+    }
+}
+function tryParseJson(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed) {
+        return {};
+    }
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return raw;
+    }
+}
+function pickString(value) {
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+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));
+    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, message) {
+    throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, message, { code });
+}

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

@@ -0,0 +1,34 @@
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { findMem9RuntimeEntrypoint } from './mem9.js';
+describe('mem9 runtime compatibility', () => {
+    test('accepts compiled runtime output under the installed package', 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, '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('rejects TypeScript-only mem9 packages before writing memory slot', 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(packageRoot, { recursive: true });
+            await fs.writeFile(path.join(packageRoot, 'index.ts'), 'export default {};\n', 'utf8');
+            const entrypoint = await findMem9RuntimeEntrypoint(path.join(root, '.openclaw'));
+            assert.equal(entrypoint, null);
+        }
+        finally {
+            await fs.rm(root, { recursive: true, force: true });
+        }
+    });
+});