strray-ai 1.22.18 → 1.22.20

package/dist/CHANGELOG.md

@@ -4,6 +4,24 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Conventional Commits](https://www.conventionalcommits.org/).
 
+## [1.22.19] - 2026-04-27
+
+### 🔄 Changes
+
+- Version bump
+
+---
+
+## [1.22.18] - 2026-04-27
+
+### 🔄 Changes
+
+### 🐛 Bug Fixes
+- fix: add validate script and hooks to dist/scripts, include mcps registry in build (fc059458e)
+- fix: add mcps directory to build, fix MCP registry path resolution (c17ca67e9)
+
+---
+
 ## [1.22.18] - 2026-04-27
 
 ### 🔄 Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "strray-ai",
-  "version": "1.22.18",
+  "version": "1.22.20",
   "description": "⚡ 0xRay: Self-Healing AI Governance OS - Enterprise AI orchestration for OpenCode and Hermes",
   "readme": "README.md",
   "license": "MIT",

package/scripts/test/test-cjs-mjs-scripts.cjs

@@ -0,0 +1,413 @@
+#!/usr/bin/env node
+
+/**
+ * StringRay CJS/MJS Scripts Loadability Tests
+ *
+ * Tests that all .cjs and .mjs scripts that ship with the package
+ * can be loaded without errors, and checks for expected exports.
+ *
+ * CJS scripts that are self-invoking are tested via subprocess to
+ * avoid side effects. Library-style CJS scripts are tested with
+ * require() directly.
+ *
+ * Usage: node scripts/test/test-cjs-mjs-scripts.cjs
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+
+const ROOT = path.join(__dirname, '..', '..');
+
+let passed = 0;
+let failed = 0;
+let skipped = 0;
+
+function pass(name) {
+  passed++;
+  console.log(`  PASS: ${name}`);
+}
+
+function fail(name, reason) {
+  failed++;
+  console.log(`  FAIL: ${name} — ${reason}`);
+}
+
+function skip(name, reason) {
+  skipped++;
+  console.log(`  SKIP: ${name} — ${reason}`);
+}
+
+function checkSyntax(filePath) {
+  return new Promise((resolve) => {
+    const child = spawn('node', ['--check', filePath], { stdio: 'pipe' });
+    let stderr = '';
+    child.stderr.on('data', (data) => { stderr += data.toString(); });
+    child.on('close', (code) => {
+      resolve({ valid: code === 0, error: stderr });
+    });
+    child.on('error', (err) => {
+      resolve({ valid: false, error: err.message });
+    });
+  });
+}
+
+function runSubprocess(filePath, timeout = 15000) {
+  return new Promise((resolve) => {
+    const child = spawn('node', [filePath], {
+      stdio: 'pipe',
+      cwd: ROOT,
+      timeout,
+    });
+
+    let stderr = '';
+    child.stderr.on('data', (data) => { stderr += data.toString(); });
+
+    const timer = setTimeout(() => {
+      child.kill('SIGTERM');
+    }, timeout);
+
+    child.on('close', (code) => {
+      clearTimeout(timer);
+      resolve({ code, stderr });
+    });
+
+    child.on('error', (err) => {
+      clearTimeout(timer);
+      resolve({ code: -1, stderr: err.message });
+    });
+  });
+}
+
+const cjsScripts = [
+  {
+    path: path.join(ROOT, 'scripts', 'node', 'postinstall.cjs'),
+    name: 'scripts/node/postinstall.cjs',
+    expectedExports: [],
+    description: 'Post-installation setup script',
+    selfInvoking: true,
+  },
+  {
+    path: path.join(ROOT, 'scripts', 'node', 'setup-dev.cjs'),
+    name: 'scripts/node/setup-dev.cjs',
+    expectedExports: [],
+    description: 'Development environment setup script',
+    selfInvoking: true,
+  },
+  {
+    path: path.join(ROOT, 'scripts', 'node', 'prepare-consumer.cjs'),
+    name: 'scripts/node/prepare-consumer.cjs',
+    expectedExports: [],
+    description: 'Consumer preparation script',
+    selfInvoking: true,
+  },
+  {
+    path: path.join(ROOT, 'scripts', 'node', 'reflection-processor.cjs'),
+    name: 'scripts/node/reflection-processor.cjs',
+    expectedExports: [],
+    description: 'Reflection post-processor',
+    selfInvoking: true,
+  },
+  {
+    path: path.join(ROOT, 'scripts', 'node', 'basic-security-audit.cjs'),
+    name: 'scripts/node/basic-security-audit.cjs',
+    expectedExports: [],
+    description: 'Basic security audit script',
+    selfInvoking: true,
+  },
+  {
+    path: path.join(ROOT, 'scripts', 'node', 'ci-cd-auto-fix.cjs'),
+    name: 'scripts/node/ci-cd-auto-fix.cjs',
+    expectedExports: [],
+    description: 'CI/CD auto-fix script',
+    selfInvoking: true,
+  },
+  {
+    path: path.join(ROOT, 'scripts', 'helpers', 'resolve-config-path.cjs'),
+    name: 'scripts/helpers/resolve-config-path.cjs',
+    expectedExports: ['getConfigDir', 'resolveConfigPath'],
+    description: 'Config path resolver (CJS)',
+    selfInvoking: false,
+  },
+];
+
+const mjsScripts = [
+  {
+    path: path.join(ROOT, 'scripts', 'node', 'enforce-agents-md.mjs'),
+    name: 'scripts/node/enforce-agents-md.mjs',
+    description: 'AGENTS.md enforcement script',
+    selfInvoking: false,
+  },
+  {
+    path: path.join(ROOT, 'scripts', 'node', 'version-manager.mjs'),
+    name: 'scripts/node/version-manager.mjs',
+    description: 'Version manager script',
+    selfInvoking: true,
+  },
+  {
+    path: path.join(ROOT, 'scripts', 'node', 'release.mjs'),
+    name: 'scripts/node/release.mjs',
+    description: 'Release script',
+    selfInvoking: true,
+  },
+  {
+    path: path.join(ROOT, 'scripts', 'node', 'auto-reflection-generator.mjs'),
+    name: 'scripts/node/auto-reflection-generator.mjs',
+    description: 'Auto-reflection generator',
+    selfInvoking: true,
+  },
+  {
+    path: path.join(ROOT, 'scripts', 'node', 'ci-report-generator.mjs'),
+    name: 'scripts/node/ci-report-generator.mjs',
+    description: 'CI report generator',
+    selfInvoking: true,
+  },
+  {
+    path: path.join(ROOT, 'scripts', 'mjs', 'validate-postinstall-config.mjs'),
+    name: 'scripts/mjs/validate-postinstall-config.mjs',
+    description: 'Post-install config validator',
+    selfInvoking: true,
+  },
+];
+
+async function runTests() {
+  console.log('=== CJS/MJS Scripts Loadability Tests ===\n');
+
+  // ── CJS Scripts ──────────────────────────────────────────────
+  console.log('--- CJS Scripts ---\n');
+
+  for (const script of cjsScripts) {
+    console.log(`Testing: ${script.name} (${script.description})`);
+
+    if (!fs.existsSync(script.path)) {
+      fail(`${script.name} exists`, `File not found: ${script.path}`);
+      console.log('');
+      continue;
+    }
+    pass(`${script.name} exists`);
+
+    // Syntax check
+    const syntaxResult = await checkSyntax(script.path);
+    if (syntaxResult.valid) {
+      pass(`${script.name} has valid JS syntax`);
+    } else {
+      fail(`${script.name} has valid JS syntax`, syntaxResult.error.trim());
+      console.log('');
+      continue;
+    }
+
+    if (script.selfInvoking) {
+      // Self-invoking scripts: run in subprocess with timeout
+      // Exit code 0 = ran without crash, anything else = error
+      const runResult = await runSubprocess(script.path, 10000);
+      if (runResult.code === 0 || runResult.code === null) {
+        // code 0 = success; null can happen if timeout killed it (still loadable)
+        pass(`${script.name} runs without fatal errors`);
+      } else {
+        // Non-zero exit might be expected (e.g., security audit returns 1 on findings)
+        // Only fail if there's an uncaught exception or module load error
+        const hasLoadError = runResult.stderr && (
+          runResult.stderr.includes('Cannot find module') ||
+          runResult.stderr.includes('SyntaxError') ||
+          runResult.stderr.includes('MODULE_NOT_FOUND')
+        );
+        if (hasLoadError) {
+          fail(`${script.name} runs without fatal errors`, `Load error detected in stderr`);
+        } else {
+          pass(`${script.name} runs without fatal module errors (exit: ${runResult.code})`);
+        }
+      }
+    } else {
+      // Library-style CJS: require() and check exports
+      try {
+        const mod = require(script.path);
+        pass(`${script.name} can be required without errors`);
+
+        if (script.expectedExports.length > 0) {
+          const exportedKeys = Object.keys(mod || {});
+          for (const expectedExport of script.expectedExports) {
+            if (mod && mod[expectedExport]) {
+              pass(`${script.name} exports "${expectedExport}"`);
+            } else {
+              fail(`${script.name} exports "${expectedExport}"`, `Export not found. Available: [${exportedKeys.join(', ')}]`);
+            }
+          }
+        }
+      } catch (err) {
+        if (err.code === 'ERR_REQUIRE_ESM' || (err.message && err.message.includes('ES Module'))) {
+          skip(`${script.name} require (ESM module)`, err.message);
+        } else if (err.message && (err.message.includes('Cannot find module') || err.code === 'MODULE_NOT_FOUND')) {
+          const missingMatch = err.message.match(/Cannot find module '([^']+)'/);
+          const missingModule = missingMatch ? missingMatch[1] : 'unknown';
+          skip(`${script.name} require`, `Missing dependency: ${missingModule}`);
+        } else {
+          fail(`${script.name} can be required without errors`, err.message);
+        }
+      }
+    }
+
+    console.log('');
+  }
+
+  // ── MJS Scripts ──────────────────────────────────────────────
+  console.log('--- MJS Scripts ---\n');
+
+  for (const script of mjsScripts) {
+    console.log(`Testing: ${script.name} (${script.description})`);
+
+    if (!fs.existsSync(script.path)) {
+      fail(`${script.name} exists`, `File not found: ${script.path}`);
+      console.log('');
+      continue;
+    }
+    pass(`${script.name} exists`);
+
+    // Syntax check (works for .mjs files too)
+    const syntaxResult = await checkSyntax(script.path);
+    if (syntaxResult.valid) {
+      pass(`${script.name} has valid JS syntax`);
+    } else {
+      fail(`${script.name} has valid JS syntax`, syntaxResult.error.trim());
+      console.log('');
+      continue;
+    }
+
+    // Attempt dynamic import or subprocess test
+    if (script.selfInvoking) {
+      // Self-invoking MJS scripts: run in subprocess with timeout
+      const runResult = await runSubprocess(script.path, 10000);
+      if (runResult.code === 0 || runResult.code === null) {
+        pass(`${script.name} runs without fatal errors`);
+      } else {
+        const hasLoadError = runResult.stderr && (
+          runResult.stderr.includes('Cannot find module') ||
+          runResult.stderr.includes('SyntaxError') ||
+          runResult.stderr.includes('MODULE_NOT_FOUND')
+        );
+        if (hasLoadError) {
+          fail(`${script.name} runs without fatal errors`, 'Load error detected in stderr');
+        } else {
+          // Self-invoking scripts often exit with non-zero for expected reasons
+          pass(`${script.name} runs without fatal module errors (exit: ${runResult.code})`);
+        }
+      }
+    } else {
+      // Library-style MJS: test with dynamic import
+      const importResult = await new Promise((resolve) => {
+        const importCheckScript = `
+          import('file://${script.path.replace(/\\/g, '/')}')
+            .then(mod => {
+              const exports = Object.keys(mod);
+              console.log(JSON.stringify({ success: true, exports: exports }));
+              process.exit(0);
+            })
+            .catch(err => {
+              const safeErr = { message: err.message, code: err.code || null };
+              console.log(JSON.stringify({ success: false, error: safeErr }));
+              process.exit(0);
+            });
+        `;
+        const child = spawn('node', ['--input-type=module', '-e', importCheckScript], {
+          stdio: 'pipe',
+          cwd: ROOT,
+        });
+
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', (data) => { stdout += data.toString(); });
+        child.stderr.on('data', (data) => { stderr += data.toString(); });
+
+        const timer = setTimeout(() => {
+          child.kill('SIGTERM');
+        }, 15000);
+
+        child.on('close', (code) => {
+          clearTimeout(timer);
+          try {
+            const lines = stdout.trim().split('\n');
+            const jsonLine = lines.find(l => {
+              try { JSON.parse(l); return true; } catch { return false; }
+            });
+            if (jsonLine) {
+              resolve(JSON.parse(jsonLine));
+            } else {
+              resolve({
+                success: false,
+                error: { message: `No JSON output found. stdout: ${stdout.slice(0, 300)}, stderr: ${stderr.slice(0, 200)}` },
+              });
+            }
+          } catch {
+            resolve({
+              success: false,
+              error: { message: `Parse error. stdout: ${stdout.slice(0, 200)}, stderr: ${stderr.slice(0, 200)}` },
+            });
+          }
+        });
+
+        child.on('error', (err) => {
+          clearTimeout(timer);
+          resolve({ success: false, error: { message: err.message } });
+        });
+      });
+
+      if (importResult.success) {
+        pass(`${script.name} can be imported without errors`);
+        if (importResult.exports && importResult.exports.length > 0) {
+          pass(`${script.name} has exports: [${importResult.exports.slice(0, 5).join(', ')}${importResult.exports.length > 5 ? '...' : ''}]`);
+        } else {
+          pass(`${script.name} loaded (no named exports — likely side-effect script)`);
+        }
+      } else {
+        const errMsg = importResult.error?.message || 'Unknown error';
+        const errCode = importResult.error?.code;
+
+        if (errCode === 'ERR_MODULE_NOT_FOUND' || errMsg.includes('Cannot find module') || errMsg.includes('MODULE_NOT_FOUND')) {
+          const missingMatch = errMsg.match(/Cannot find module '([^']+)'/) || errMsg.match(/Cannot find package '([^']+)'/);
+          const missingModule = missingMatch ? missingMatch[1] : 'unknown';
+          skip(`${script.name} dynamic import`, `Missing dependency: ${missingModule}`);
+        } else if (errMsg.includes('ECONNREFUSED') || errMsg.includes('fetch failed') || errMsg.includes('network')) {
+          skip(`${script.name} dynamic import`, 'Network dependency unavailable');
+        } else {
+          fail(`${script.name} can be imported without errors`, errMsg);
+        }
+      }
+    }
+
+    console.log('');
+  }
+
+  // ── Helper script: resolve-config-path.mjs ────────────────────
+  console.log('--- Helper Scripts (additional) ---\n');
+
+  const helperMjs = path.join(ROOT, 'scripts', 'helpers', 'resolve-config-path.mjs');
+  console.log('Testing: scripts/helpers/resolve-config-path.mjs');
+
+  if (!fs.existsSync(helperMjs)) {
+    skip('scripts/helpers/resolve-config-path.mjs exists', 'File not found');
+  } else {
+    pass('scripts/helpers/resolve-config-path.mjs exists');
+
+    const syntaxResult = await checkSyntax(helperMjs);
+    if (syntaxResult.valid) {
+      pass('scripts/helpers/resolve-config-path.mjs has valid JS syntax');
+    } else {
+      fail('scripts/helpers/resolve-config-path.mjs has valid JS syntax', syntaxResult.error.trim());
+    }
+  }
+
+  console.log('');
+
+  // ── Summary ──────────────────────────────────────────────────
+  console.log('=== Summary ===');
+  console.log(`  Passed:  ${passed}`);
+  console.log(`  Failed:  ${failed}`);
+  console.log(`  Skipped: ${skipped}`);
+  console.log(`  Total:   ${passed + failed + skipped}`);
+
+  process.exit(failed > 0 ? 1 : 0);
+}
+
+runTests().catch((err) => {
+  console.error('Test runner failed:', err);
+  process.exit(2);
+});

package/scripts/test/test-hermes-mcp-integration.cjs

@@ -0,0 +1,229 @@
+#!/usr/bin/env node
+
+/**
+ * StringRay Hermes Agent MCP Plugin Integration Tests
+ *
+ * Tests that the Hermes integration can be loaded, instantiated,
+ * and exports the correct MCP tools and bridge configuration.
+ *
+ * Usage: node scripts/test/test-hermes-mcp-integration.cjs
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+
+const ROOT = path.join(__dirname, '..', '..');
+const DIST_HERMES = path.join(ROOT, 'dist', 'integrations', 'hermes-agent');
+
+let passed = 0;
+let failed = 0;
+let skipped = 0;
+
+function pass(name) {
+  passed++;
+  console.log(`  PASS: ${name}`);
+}
+
+function fail(name, reason) {
+  failed++;
+  console.log(`  FAIL: ${name} — ${reason}`);
+}
+
+function skip(name, reason) {
+  skipped++;
+  console.log(`  SKIP: ${name} — ${reason}`);
+}
+
+async function checkSyntax(filePath) {
+  return new Promise((resolve) => {
+    const child = spawn('node', ['--check', filePath], { stdio: 'pipe' });
+    let stderr = '';
+    child.stderr.on('data', (data) => { stderr += data.toString(); });
+    child.on('close', (code) => {
+      resolve({ valid: code === 0, error: stderr });
+    });
+    child.on('error', (err) => {
+      resolve({ valid: false, error: err.message });
+    });
+  });
+}
+
+async function runTests() {
+  console.log('=== Hermes Agent MCP Plugin Integration Tests ===\n');
+
+  // Test 1: bridge.mjs can be loaded (syntax check)
+  console.log('Test 1: bridge.mjs can be loaded');
+  const bridgePath = path.join(DIST_HERMES, 'bridge.mjs');
+  if (!fs.existsSync(bridgePath)) {
+    fail('bridge.mjs exists', `File not found: ${bridgePath}`);
+  } else {
+    const result = await checkSyntax(bridgePath);
+    if (result.valid) {
+      pass('bridge.mjs has valid JS syntax');
+    } else {
+      fail('bridge.mjs has valid JS syntax', result.error.trim());
+    }
+  }
+
+  // Test 2: plugin.yaml has valid structure
+  console.log('\nTest 2: plugin.yaml has valid structure');
+  const pluginYamlPath = path.join(DIST_HERMES, 'plugin.yaml');
+  if (!fs.existsSync(pluginYamlPath)) {
+    fail('plugin.yaml exists', `File not found: ${pluginYamlPath}`);
+  } else {
+    try {
+      const content = fs.readFileSync(pluginYamlPath, 'utf-8');
+
+      const requiredFields = ['name', 'version', 'description'];
+      for (const field of requiredFields) {
+        if (content.includes(`${field}:`)) {
+          pass(`plugin.yaml has "${field}" field`);
+        } else {
+          fail(`plugin.yaml has "${field}" field`, `Missing "${field}:" key`);
+        }
+      }
+
+      if (content.includes('provides_tools:')) {
+        pass('plugin.yaml has "provides_tools" field');
+      } else {
+        fail('plugin.yaml has "provides_tools" field', 'Missing "provides_tools:" key');
+      }
+
+      if (content.includes('provides_hooks:')) {
+        pass('plugin.yaml has "provides_hooks" field');
+      } else {
+        fail('plugin.yaml has "provides_hooks" field', 'Missing "provides_hooks:" key');
+      }
+    } catch (err) {
+      fail('plugin.yaml is readable', err.message);
+    }
+  }
+
+  // Test 3: plugin.yaml lists correct MCP tool names
+  console.log('\nTest 3: plugin.yaml lists correct MCP tool names');
+  if (fs.existsSync(pluginYamlPath)) {
+    try {
+      const content = fs.readFileSync(pluginYamlPath, 'utf-8');
+      const expectedTools = ['strray_validate', 'strray_codex_check', 'strray_health', 'strray_hooks'];
+      for (const tool of expectedTools) {
+        if (content.includes(tool)) {
+          pass(`plugin.yaml lists tool "${tool}"`);
+        } else {
+          fail(`plugin.yaml lists tool "${tool}"`, `Tool not found in plugin.yaml`);
+        }
+      }
+    } catch (err) {
+      fail('plugin.yaml tools check', err.message);
+    }
+  }
+
+  // Test 4: hermes-agent-integration.js can be instantiated (if it exists in dist)
+  console.log('\nTest 4: HermesAgentIntegration class can be instantiated');
+  const integrationJsPath = path.join(DIST_HERMES, 'hermes-agent-integration.js');
+  const integrationSrcPath = path.join(ROOT, 'src', 'integrations', 'hermes-agent', 'hermes-agent-integration.ts');
+
+  if (fs.existsSync(integrationJsPath)) {
+    try {
+      const mod = require(integrationJsPath);
+      if (mod.HermesAgentIntegration) {
+        const instance = new mod.HermesAgentIntegration();
+        if (instance) {
+          pass('HermesAgentIntegration can be instantiated');
+        } else {
+          fail('HermesAgentIntegration can be instantiated', 'Constructor returned null/undefined');
+        }
+      } else {
+        fail('HermesAgentIntegration is exported', 'Module does not export HermesAgentIntegration');
+      }
+    } catch (err) {
+      if (err.code === 'ERR_REQUIRE_ESM' || err.message?.includes('ES Module')) {
+        skip('HermesAgentIntegration instantiation (ESM module - needs dynamic import)', err.message);
+      } else {
+        fail('HermesAgentIntegration can be instantiated', err.message);
+      }
+    }
+  } else if (fs.existsSync(integrationSrcPath)) {
+    skip('HermesAgentIntegration class instantiation', 'Compiled JS not in dist yet; source TS exists');
+  } else {
+    skip('HermesAgentIntegration class instantiation', 'Integration class not built to dist (Python/MJS bridge)');
+  }
+
+  // Test 5: Python modules exist and are valid (syntax check via python3)
+  console.log('\nTest 5: Python modules exist and are valid');
+  const pythonFiles = ['__init__.py', 'tools.py', 'schemas.py', 'conftest.py'];
+  for (const pyFile of pythonFiles) {
+    const pyPath = path.join(DIST_HERMES, pyFile);
+    if (!fs.existsSync(pyPath)) {
+      skip(`Python module ${pyFile} syntax check`, 'File not found');
+      continue;
+    }
+
+    const hasPython = await new Promise((resolve) => {
+      const child = spawn('python3', ['--version'], { stdio: 'pipe' });
+      child.on('close', (code) => resolve(code === 0));
+      child.on('error', () => resolve(false));
+    });
+
+    if (!hasPython) {
+      skip(`Python module ${pyFile} syntax check`, 'python3 not available');
+      break;
+    }
+
+    const result = await new Promise((resolve) => {
+      const child = spawn('python3', ['-m', 'py_compile', pyPath], { stdio: 'pipe' });
+      let stderr = '';
+      child.stderr.on('data', (data) => { stderr += data.toString(); });
+      child.on('close', (code) => resolve({ valid: code === 0, error: stderr }));
+      child.on('error', (err) => resolve({ valid: false, error: err.message }));
+    });
+
+    if (result.valid) {
+      pass(`Python module ${pyFile} has valid syntax`);
+    } else {
+      fail(`Python module ${pyFile} has valid syntax`, result.error.trim());
+    }
+  }
+
+  // Test 6: after-install.md exists and is non-empty
+  console.log('\nTest 6: after-install.md exists and is non-empty');
+  const afterInstallPath = path.join(DIST_HERMES, 'after-install.md');
+  if (!fs.existsSync(afterInstallPath)) {
+    fail('after-install.md exists', `File not found: ${afterInstallPath}`);
+  } else {
+    const content = fs.readFileSync(afterInstallPath, 'utf-8');
+    if (content.trim().length > 0) {
+      pass('after-install.md is non-empty');
+    } else {
+      fail('after-install.md is non-empty', 'File is empty');
+    }
+  }
+
+  // Test 7: bridge.mjs exports expected command handlers
+  console.log('\nTest 7: bridge.mjs contains expected command handlers');
+  if (fs.existsSync(bridgePath)) {
+    const bridgeContent = fs.readFileSync(bridgePath, 'utf-8');
+    const expectedCommands = ['health', 'pre-process', 'post-process', 'validate', 'codex-check', 'hooks'];
+    for (const cmd of expectedCommands) {
+      if (bridgeContent.includes(`"${cmd}"`) || bridgeContent.includes(`'${cmd}'`)) {
+        pass(`bridge.mjs handles "${cmd}" command`);
+      } else {
+        fail(`bridge.mjs handles "${cmd}" command`, `Command not found in bridge.mjs`);
+      }
+    }
+  }
+
+  // Summary
+  console.log('\n=== Summary ===');
+  console.log(`  Passed:  ${passed}`);
+  console.log(`  Failed:  ${failed}`);
+  console.log(`  Skipped: ${skipped}`);
+  console.log(`  Total:   ${passed + failed + skipped}`);
+
+  process.exit(failed > 0 ? 1 : 0);
+}
+
+runTests().catch((err) => {
+  console.error('Test runner failed:', err);
+  process.exit(2);
+});

package/scripts/test/test-openclaw-integration.cjs

@@ -0,0 +1,240 @@
+#!/usr/bin/env node
+
+/**
+ * StringRay OpenClaw Integration Tests
+ *
+ * Tests that the OpenClaw integration can be loaded, instantiated,
+ * and exports the expected types, client, and hooks.
+ *
+ * Usage: node scripts/test/test-openclaw-integration.cjs
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+
+const ROOT = path.join(__dirname, '..', '..');
+const DIST_OPENCLAW = path.join(ROOT, 'dist', 'integrations', 'openclaw');
+const SRC_OPENCLAW = path.join(ROOT, 'src', 'integrations', 'openclaw');
+
+let passed = 0;
+let failed = 0;
+let skipped = 0;
+
+function pass(name) {
+  passed++;
+  console.log(`  PASS: ${name}`);
+}
+
+function fail(name, reason) {
+  failed++;
+  console.log(`  FAIL: ${name} — ${reason}`);
+}
+
+function skip(name, reason) {
+  skipped++;
+  console.log(`  SKIP: ${name} — ${reason}`);
+}
+
+async function checkSyntax(filePath) {
+  return new Promise((resolve) => {
+    const child = spawn('node', ['--check', filePath], { stdio: 'pipe' });
+    let stderr = '';
+    child.stderr.on('data', (data) => { stderr += data.toString(); });
+    child.on('close', (code) => {
+      resolve({ valid: code === 0, error: stderr });
+    });
+    child.on('error', (err) => {
+      resolve({ valid: false, error: err.message });
+    });
+  });
+}
+
+async function runTests() {
+  console.log('=== OpenClaw Integration Tests ===\n');
+
+  // Test 1: OpenClaw integration source exists
+  console.log('Test 1: OpenClaw integration source exists');
+  const srcIndex = path.join(SRC_OPENCLAW, 'index.ts');
+  if (fs.existsSync(srcIndex)) {
+    pass('OpenClaw source index.ts exists');
+  } else {
+    fail('OpenClaw source index.ts exists', `Not found: ${srcIndex}`);
+  }
+
+  // Test 2: OpenClawIntegration class can be instantiated (via dist or source check)
+  console.log('\nTest 2: OpenClawIntegration class can be instantiated');
+  const distIndex = path.join(DIST_OPENCLAW, 'index.js');
+
+  if (fs.existsSync(distIndex)) {
+    try {
+      const mod = require(distIndex);
+      if (mod.OpenClawIntegration) {
+        const instance = new mod.OpenClawIntegration();
+        if (instance) {
+          pass('OpenClawIntegration can be instantiated from dist');
+        } else {
+          fail('OpenClawIntegration can be instantiated from dist', 'Constructor returned null/undefined');
+        }
+      } else {
+        // Check if module loaded but doesn't export the class directly
+        const exportKeys = Object.keys(mod);
+        if (exportKeys.length > 0) {
+          pass(`OpenClawIntegration dist module loaded (exports: ${exportKeys.slice(0, 5).join(', ')})`);
+        } else {
+          fail('OpenClawIntegration is exported from dist', 'Module has no exports');
+        }
+      }
+    } catch (err) {
+      if (err.code === 'ERR_REQUIRE_ESM' || err.message?.includes('ES Module')) {
+        skip('OpenClawIntegration instantiation from dist', 'ESM module requires dynamic import');
+      } else {
+        fail('OpenClawIntegration instantiation from dist', err.message);
+      }
+    }
+  } else {
+    // Check source file exists with the class definition
+    if (fs.existsSync(srcIndex)) {
+      const content = fs.readFileSync(srcIndex, 'utf-8');
+      if (content.includes('class OpenClawIntegration')) {
+        skip('OpenClawIntegration class instantiation', 'Compiled dist not found; class exists in source');
+      } else {
+        fail('OpenClawIntegration class exists in source', 'Class definition not found in index.ts');
+      }
+    } else {
+      fail('OpenClawIntegration class', 'Neither dist nor source found');
+    }
+  }
+
+  // Test 3: Types module exports expected interfaces
+  console.log('\nTest 3: Types module exports expected interfaces');
+  const srcTypes = path.join(SRC_OPENCLAW, 'types.ts');
+  if (fs.existsSync(srcTypes)) {
+    const content = fs.readFileSync(srcTypes, 'utf-8');
+    const expectedTypes = ['OpenClawIntegrationConfig', 'IntegrationStatistics', 'ClientStatistics'];
+
+    for (const typeName of expectedTypes) {
+      if (content.includes(typeName)) {
+        pass(`Types module exports "${typeName}"`);
+      } else {
+        fail(`Types module exports "${typeName}"`, `Interface not found in types.ts`);
+      }
+    }
+  } else {
+    // Check dist
+    const distTypes = path.join(DIST_OPENCLAW, 'types.js');
+    if (fs.existsSync(distTypes)) {
+      skip('Types module check', 'Only dist JS available; TypeScript interfaces are type-only');
+    } else {
+      fail('Types module exists', 'Neither source nor dist types found');
+    }
+  }
+
+  // Test 4: Client module exists
+  console.log('\nTest 4: Client module exists');
+  const srcClient = path.join(SRC_OPENCLAW, 'client.ts');
+  const distClient = path.join(DIST_OPENCLAW, 'client.js');
+
+  if (fs.existsSync(srcClient)) {
+    const content = fs.readFileSync(srcClient, 'utf-8');
+    if (content.includes('class OpenClawClient') || content.includes('OpenClawClient')) {
+      pass('Client module (source) defines OpenClawClient');
+    } else {
+      fail('Client module defines OpenClawClient', 'Class not found in client.ts');
+    }
+  } else if (fs.existsSync(distClient)) {
+    const result = await checkSyntax(distClient);
+    if (result.valid) {
+      pass('Client module (dist) has valid JS syntax');
+    } else {
+      fail('Client module (dist) has valid JS syntax', result.error.trim());
+    }
+  } else {
+    fail('Client module exists', 'Neither source nor dist client found');
+  }
+
+  // Test 5: API server module exists
+  console.log('\nTest 5: API server module exists');
+  const srcApiServer = path.join(SRC_OPENCLAW, 'api-server.ts');
+  const distApiServer = path.join(DIST_OPENCLAW, 'api-server.js');
+
+  if (fs.existsSync(srcApiServer)) {
+    const content = fs.readFileSync(srcApiServer, 'utf-8');
+    if (content.includes('StringRayAPIServer') || content.includes('class APIServer')) {
+      pass('API server module (source) defines StringRayAPIServer');
+    } else {
+      fail('API server module defines StringRayAPIServer', 'Class not found in api-server.ts');
+    }
+  } else if (fs.existsSync(distApiServer)) {
+    const result = await checkSyntax(distApiServer);
+    if (result.valid) {
+      pass('API server module (dist) has valid JS syntax');
+    } else {
+      fail('API server module (dist) has valid JS syntax', result.error.trim());
+    }
+  } else {
+    // Check if it's referenced in the README
+    const readmePath = path.join(DIST_OPENCLAW, 'README.md');
+    if (fs.existsSync(readmePath)) {
+      const readme = fs.readFileSync(readmePath, 'utf-8');
+      if (readme.includes('api-server') || readme.includes('API Server')) {
+        skip('API server module', 'Source not compiled to dist; documented in README');
+      } else {
+        fail('API server module exists', 'Neither source nor dist found');
+      }
+    } else {
+      fail('API server module exists', 'No source, dist, or documentation found');
+    }
+  }
+
+  // Test 6: Hooks (strray-hooks) can be loaded
+  console.log('\nTest 6: Hooks (strray-hooks) can be loaded');
+  const srcHooks = path.join(SRC_OPENCLAW, 'hooks', 'strray-hooks.ts');
+  const distHooks = path.join(DIST_OPENCLAW, 'hooks', 'strray-hooks.js');
+
+  if (fs.existsSync(srcHooks)) {
+    const content = fs.readFileSync(srcHooks, 'utf-8');
+    if (content.includes('OpenClawHooksManager')) {
+      pass('Hooks module (source) defines OpenClawHooksManager');
+    } else {
+      fail('Hooks module defines OpenClawHooksManager', 'Class not found in strray-hooks.ts');
+    }
+  } else if (fs.existsSync(distHooks)) {
+    const result = await checkSyntax(distHooks);
+    if (result.valid) {
+      pass('Hooks module (dist) has valid JS syntax');
+    } else {
+      fail('Hooks module (dist) has valid JS syntax', result.error.trim());
+    }
+  } else {
+    skip('Hooks module (strray-hooks)', 'Not compiled to dist; source module not found');
+  }
+
+  // Test 7: Config module exists
+  console.log('\nTest 7: Config module exists');
+  const srcConfig = path.join(SRC_OPENCLAW, 'config.ts');
+  if (fs.existsSync(srcConfig)) {
+    const content = fs.readFileSync(srcConfig, 'utf-8');
+    if (content.includes('OpenClawConfigLoader')) {
+      pass('Config module (source) defines OpenClawConfigLoader');
+    } else {
+      fail('Config module defines OpenClawConfigLoader', 'Class not found in config.ts');
+    }
+  } else {
+    skip('Config module', 'Source not found; may not be compiled');
+  }
+
+  // Summary
+  console.log('\n=== Summary ===');
+  console.log(`  Passed:  ${passed}`);
+  console.log(`  Failed:  ${failed}`);
+  console.log(`  Skipped: ${skipped}`);
+  console.log(`  Total:   ${passed + failed + skipped}`);
+
+  process.exit(failed > 0 ? 1 : 0);
+}
+
+runTests().catch((err) => {
+  console.error('Test runner failed:', err);
+  process.exit(2);
+});