0xray 3.4.4 → 3.4.5

package/AGENTS-consumer.md

@@ -2,7 +2,7 @@
 
 Quick reference for the 0xRay AI orchestration framework (shipped to your project on `npm install 0xray`).
 
-**v3.4.4** — 7 MCP servers · 45 skills · 68 codex terms · 4 platform bridges
+**v3.4.5** — 7 MCP servers · 45 skills · 68 codex terms · 4 platform bridges
 
 ## Postinstall (automatic)
 

package/AGENTS.md

@@ -1,6 +1,6 @@
 # xray Agents
 
-Quick reference for the xray AI orchestration framework (**v3.4.4**).
+Quick reference for the xray AI orchestration framework (**v3.4.5**).
 
 **42 agents** · **45 skills** · **7 consumer MCP servers** · **68 codex terms** · **3,226 tests**
 

package/README.md

@@ -1,6 +1,6 @@
 # xray — MCP-Centric AI Governance OS
 
-**v3.4.4** — 42 agents · 45 skills · 7 MCP servers · 68 codex terms · 3,226 tests
+**v3.4.5** — 42 agents · 45 skills · 7 MCP servers · 68 codex terms · 3,226 tests
 
 xray is the pure v2 three-subsystem AI orchestration framework — **MCP-centric**, governed by Dynamo, and autonomous via thinDispatch. Consumer `npm install 0xray` auto-wires all four platform bridges and seven MCP servers with zero manual config.
 

package/SKILLS.md

@@ -1,6 +1,6 @@
 # 0xray Skills
 
-**v3.4.4** — **45 skills** · invoked via `xray-skills` MCP · synced on postinstall
+**v3.4.5** — **45 skills** · invoked via `xray-skills` MCP · synced on postinstall
 
 xray ships 45 knowledge skills (`src/skills/<name>/SKILL.md`) across the full software lifecycle. Lead-dev operating model lives in **`orchestrator`** skill + `multi_agent_orchestration.lead_dev_mode` in features.json. Skills load on demand via the **xray-skills** MCP server (`npx -y 0xray mcp skills`), agent `@mentions`, or platform skill directories after postinstall.
 

package/dist/AGENTS.md

@@ -1,6 +1,6 @@
 # xray Agents
 
-Quick reference for the xray AI orchestration framework (**v3.4.3**).
+Quick reference for the xray AI orchestration framework (**v3.4.5**).
 
 **42 agents** · **45 skills** · **7 consumer MCP servers** · **68 codex terms** · **3,226 tests**
 

package/dist/CHANGELOG.md

@@ -4,6 +4,13 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Conventional Commits](https://www.conventionalcommits.org/).
 
+## [3.4.5] - 2026-06-18
+
+### ✨ Features
+- **Native bridge MCP wiring** — `bridge-mcp-wiring.cjs` SSOT wires 7 xray MCP servers (+ repertoire auto-detect) into Hermes `mcp_servers`, OpenCode `opencode.json`, and OpenClaw `mcp.servers` via `npx 0xray {hermes,opencode,openclaw} install` and postinstall
+
+---
+
 ## [3.4.4] - 2026-06-18
 
 ### 🐛 Bug Fixes

package/dist/README.md

@@ -1,6 +1,6 @@
 # xray — MCP-Centric AI Governance OS
 
-**v3.4.3** — 42 agents · 45 skills · 7 MCP servers · 68 codex terms · 3,226 tests
+**v3.4.5** — 42 agents · 45 skills · 7 MCP servers · 68 codex terms · 3,226 tests
 
 xray is the pure v2 three-subsystem AI orchestration framework — **MCP-centric**, governed by Dynamo, and autonomous via thinDispatch. Consumer `npm install 0xray` auto-wires all four platform bridges and seven MCP servers with zero manual config.
 

package/dist/SKILLS.md

@@ -1,6 +1,6 @@
 # 0xray Skills
 
-**v3.4.3** — **45 skills** · invoked via `xray-skills` MCP · synced on postinstall
+**v3.4.5** — **45 skills** · invoked via `xray-skills` MCP · synced on postinstall
 
 xray ships 45 knowledge skills (`src/skills/<name>/SKILL.md`) across the full software lifecycle. Lead-dev operating model lives in **`orchestrator`** skill + `multi_agent_orchestration.lead_dev_mode` in features.json. Skills load on demand via the **xray-skills** MCP server (`npx -y 0xray mcp skills`), agent `@mentions`, or platform skill directories after postinstall.
 

package/dist/cli/commands/hermes-install.js

@@ -1,9 +1,12 @@
 import fs from 'fs';
 import path from 'path';
 import { homedir } from 'os';
+import { createRequire } from 'module';
 import { frameworkLogger } from '../../core/framework-logger.js';
 import { syncBuiltinSkills } from './skill-install.js';
 const __dirname = path.dirname(new URL(import.meta.url).pathname);
+const require = createRequire(import.meta.url);
+const wiring = require(path.join(__dirname, '..', '..', '..', 'scripts', 'node', 'bridge-mcp-wiring.cjs'));
 export function registerHermesCommands(hermesCmd) {
     hermesCmd
         .command('install')
@@ -31,40 +34,44 @@ async function installForHermes(options = {}) {
         console.log(`[Hermes] Dry run: Would copy plugin from ${sourceDir} → ${targetPluginDir}`);
         return;
     }
+    const targetDir = process.cwd();
     try {
-        if (fs.existsSync(targetPluginDir) && !options.force) {
+        const pluginExists = fs.existsSync(targetPluginDir);
+        if (pluginExists && !options.force) {
             console.log('[Hermes] xray-hermes plugin is already installed.');
             console.log('Use --force to reinstall.');
-            return;
         }
-        fs.mkdirSync(targetPluginDir, { recursive: true });
-        for (const entry of fs.readdirSync(sourceDir)) {
-            const src = path.join(sourceDir, entry);
-            const dst = path.join(targetPluginDir, entry);
-            if (fs.statSync(src).isDirectory()) {
-                fs.cpSync(src, dst, { recursive: true, force: true });
+        else {
+            fs.mkdirSync(targetPluginDir, { recursive: true });
+            for (const entry of fs.readdirSync(sourceDir)) {
+                const src = path.join(sourceDir, entry);
+                const dst = path.join(targetPluginDir, entry);
+                if (fs.statSync(src).isDirectory()) {
+                    fs.cpSync(src, dst, { recursive: true, force: true });
+                }
+                else {
+                    fs.copyFileSync(src, dst);
+                }
             }
-            else {
-                fs.copyFileSync(src, dst);
+            frameworkLogger.log('hermes-integration', 'plugin-copied', 'info', { destination: targetPluginDir });
+            console.log(`\x1b[32m✓ Copied Hermes plugin to ${targetPluginDir}\x1b[0m`);
+            const hermesSkillsDir = path.join(targetPluginDir, 'skills');
+            const skillsCopied = syncBuiltinSkills(hermesSkillsDir);
+            if (skillsCopied > 0) {
+                console.log(`\x1b[32m✓ Synced ${skillsCopied} builtin skills to Hermes plugin\x1b[0m`);
             }
+            frameworkLogger.log('hermes-integration', 'skills-synced', 'info', { count: skillsCopied });
         }
-        frameworkLogger.log('hermes-integration', 'plugin-copied', 'info', { destination: targetPluginDir });
-        console.log(`\x1b[32m✓ Copied Hermes plugin to ${targetPluginDir}\x1b[0m`);
-        // Sync builtin skills to Hermes plugin skills dir
-        const hermesSkillsDir = path.join(targetPluginDir, 'skills');
-        const skillsCopied = syncBuiltinSkills(hermesSkillsDir);
-        if (skillsCopied > 0) {
-            console.log(`\x1b[32m✓ Synced ${skillsCopied} builtin skills to Hermes plugin\x1b[0m`);
-        }
-        frameworkLogger.log('hermes-integration', 'skills-synced', 'info', { count: skillsCopied });
-        // Write after-install instructions
+        const wired = wiring.wireHermesBridge(targetDir);
+        console.log(`\x1b[32m✓ Wired Hermes mcp_servers (${wired.count} servers)\x1b[0m`);
+        console.log(`\x1b[32m✓ Consumer root → ${targetDir}\x1b[0m`);
         const afterInstallPath = path.join(targetPluginDir, 'after-install.md');
         if (fs.existsSync(afterInstallPath)) {
             console.log(`\nSee ${afterInstallPath} for post-install steps.`);
         }
         console.log('\n✅ 0xRay is now installed as a Hermes Agent plugin!');
-        console.log('Restart Hermes to load the plugin and its tools.');
-        console.log('  Run: /xray status  (to verify)');
+        console.log('Restart Hermes to load the plugin, MCP servers, and tools.');
+        console.log('  Run: hermes mcp list  (to verify)');
     }
     catch (err) {
         frameworkLogger.log('hermes-integration', 'install-error', 'error', { error: err.message });

package/dist/cli/commands/openclaw-install.js

@@ -1,9 +1,13 @@
 import fs from 'fs';
 import path from 'path';
 import { homedir } from 'os';
+import { createRequire } from 'module';
 import { frameworkLogger } from '../../core/framework-logger.js';
 import { syncBuiltinSkills } from './skill-install.js';
 import { OpenClawConfigLoader } from '../../integrations/openclaw/config.js';
+const __dirname = path.dirname(new URL(import.meta.url).pathname);
+const require = createRequire(import.meta.url);
+const wiring = require(path.join(__dirname, '..', '..', '..', 'scripts', 'node', 'bridge-mcp-wiring.cjs'));
 export function registerOpenClawCommands(openclawCmd) {
     openclawCmd
         .command('install')
@@ -21,29 +25,31 @@ async function installForOpenClaw(options = {}) {
         console.log(`[OpenClaw] Dry run: Would create config at ${configPath}`);
         return;
     }
+    const targetDir = process.cwd();
     try {
-        if (fs.existsSync(configPath) && !options.force) {
+        const configExists = fs.existsSync(configPath);
+        if (configExists && !options.force) {
             console.log(`[OpenClaw] Config already exists at ${configPath}.`);
-            console.log('Use --force to overwrite.');
-            return;
+            console.log('Use --force to overwrite sample config.');
+        }
+        else {
+            const loader = new OpenClawConfigLoader(configPath);
+            loader.createSampleConfig();
+            const relative = path.relative(process.cwd(), configPath);
+            console.log(`\x1b[32m✓ Created OpenClaw config at ${relative}\x1b[0m`);
         }
-        const loader = new OpenClawConfigLoader(configPath);
-        loader.createSampleConfig();
-        const relative = path.relative(process.cwd(), configPath);
-        console.log(`\x1b[32m✓ Created OpenClaw config at ${relative}\x1b[0m`);
-        // Sync builtin skills to ~/.openclaw/skills/
         const openclawSkillsDir = path.join(homedir(), '.openclaw', 'skills');
         const skillsCopied = syncBuiltinSkills(openclawSkillsDir);
         if (skillsCopied > 0) {
             console.log(`\x1b[32m✓ Synced ${skillsCopied} builtin skills to ~/.openclaw/skills/\x1b[0m`);
         }
         frameworkLogger.log('openclaw-integration', 'skills-synced', 'info', { count: skillsCopied });
+        const wired = wiring.wireOpenClawBridge(targetDir);
+        console.log(`\x1b[32m✓ Wired OpenClaw MCP servers (${wired.count} via ${wired.method}) → ${wired.path}\x1b[0m`);
+        console.log(`\x1b[32m✓ Consumer root → ${targetDir}\x1b[0m`);
         console.log('\n✅ 0xRay OpenClaw integration configured!');
-        console.log('Edit the config file to set your gateway URL, auth token, and device ID.');
-        console.log('');
-        console.log('To initialize the integration in code:');
-        console.log('  import { initializeOpenClawIntegration } from "0xray";');
-        console.log('  const integration = await initializeOpenClawIntegration();');
+        console.log('Run `openclaw mcp list` to verify MCP servers.');
+        console.log('Edit `.xray/config/openclaw.json` for gateway URL, auth token, and device ID.');
     }
     catch (err) {
         frameworkLogger.log('openclaw-integration', 'install-error', 'error', { error: err.message });

package/dist/cli/commands/opencode-install.js

@@ -1,8 +1,11 @@
 import fs from 'fs';
 import path from 'path';
+import { createRequire } from 'module';
 import { frameworkLogger } from '../../core/framework-logger.js';
 import { syncBuiltinSkills } from './skill-install.js';
 const __dirname = path.dirname(new URL(import.meta.url).pathname);
+const require = createRequire(import.meta.url);
+const wiring = require(path.join(__dirname, '..', '..', '..', 'scripts', 'node', 'bridge-mcp-wiring.cjs'));
 export function registerOpencodeCommands(opencodeCmd) {
     opencodeCmd
         .command('install')
@@ -95,36 +98,44 @@ async function installForOpencode(options = {}) {
             fs.writeFileSync(consumerPkgPath, JSON.stringify(pkg, null, 2) + '\n');
             console.log(`\x1b[32m✓ Created package.json with 0xray dependency\x1b[0m`);
         }
-        if (fs.existsSync(opencodeDest) && !options.force) {
+        const opencodeDestExists = fs.existsSync(opencodeDest);
+        if (opencodeDestExists && !options.force) {
             console.log('[Opencode] .opencode/ directory already exists.');
             console.log('Use --force to reinstall.');
-            return;
-        }
-        copyDir(opencodeSource, opencodeDest);
-        frameworkLogger.log('opencode-integration', 'opencode-copied', 'info', { destination: opencodeDest });
-        // Copy plugin from dist/ to .opencode/plugin/
-        const pluginSource = path.join(__dirname, '..', '..', '..', 'dist', 'plugin', 'xray-codex-injection.js');
-        const pluginDest = path.join(opencodeDest, 'plugin', 'xray-codex-injection.js');
-        if (fs.existsSync(pluginSource)) {
-            const pluginDestDir = path.dirname(pluginDest);
-            if (!fs.existsSync(pluginDestDir))
-                fs.mkdirSync(pluginDestDir, { recursive: true });
-            fs.copyFileSync(pluginSource, pluginDest);
-            console.log(`\x1b[32m✓ Copied plugin to .opencode/plugin/\x1b[0m`);
         }
         else {
-            console.log('ℹ️  Plugin source not found (build may be needed)');
+            copyDir(opencodeSource, opencodeDest);
+            frameworkLogger.log('opencode-integration', 'opencode-copied', 'info', { destination: opencodeDest });
+            const pluginSource = path.join(__dirname, '..', '..', '..', 'dist', 'plugin', 'xray-codex-injection.js');
+            const pluginDest = path.join(opencodeDest, 'plugin', 'xray-codex-injection.js');
+            if (fs.existsSync(pluginSource)) {
+                const pluginDestDir = path.dirname(pluginDest);
+                if (!fs.existsSync(pluginDestDir))
+                    fs.mkdirSync(pluginDestDir, { recursive: true });
+                fs.copyFileSync(pluginSource, pluginDest);
+                console.log(`\x1b[32m✓ Copied plugin to .opencode/plugin/\x1b[0m`);
+            }
+            else {
+                console.log('ℹ️  Plugin source not found (build may be needed)');
+            }
+            const opencodeSkillsDir = path.join(opencodeDest, 'skills');
+            const skillsCopied = syncBuiltinSkills(opencodeSkillsDir);
+            if (skillsCopied > 0) {
+                console.log(`\x1b[32m✓ Synced ${skillsCopied} builtin skills to .opencode/skills/\x1b[0m`);
+            }
+            frameworkLogger.log('opencode-integration', 'skills-synced', 'info', { count: skillsCopied });
+            console.log(`\x1b[32m✓ Copied OpenCode config to .opencode/\x1b[0m`);
         }
-        // Sync builtin skills to .opencode/skills/
-        const opencodeSkillsDir = path.join(opencodeDest, 'skills');
-        const skillsCopied = syncBuiltinSkills(opencodeSkillsDir);
-        if (skillsCopied > 0) {
-            console.log(`\x1b[32m✓ Synced ${skillsCopied} builtin skills to .opencode/skills/\x1b[0m`);
+        const rootOpencode = path.join(__dirname, '..', '..', '..', 'opencode.json');
+        const userOpencode = path.join(process.cwd(), 'opencode.json');
+        if (fs.existsSync(rootOpencode) && !fs.existsSync(userOpencode)) {
+            fs.copyFileSync(rootOpencode, userOpencode);
+            console.log(`\x1b[32m✓ Seeded opencode.json from 0xRay template\x1b[0m`);
         }
-        frameworkLogger.log('opencode-integration', 'skills-synced', 'info', { count: skillsCopied });
-        console.log(`\x1b[32m✓ Copied OpenCode config to .opencode/\x1b[0m`);
+        const mcpCount = wiring.wireOpencodeBridge(process.cwd());
+        console.log(`\x1b[32m✓ Wired opencode.json mcp (${mcpCount} servers)\x1b[0m`);
         console.log('\n✅ 0xRay OpenCode plugin installed!');
-        console.log('Restart OpenCode or run `opencode` to load the plugin.');
+        console.log('Restart OpenCode or run `opencode mcp list` to verify MCP servers.');
     }
     catch (err) {
         frameworkLogger.log('opencode-integration', 'install-error', 'error', { error: err.message });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "0xray",
-  "version": "3.4.4",
+  "version": "3.4.5",
   "description": "Multi-agent orchestration and Codex governance for OpenCode, Hermes, Grok Build, and OpenClaw",
   "readme": "README.md",
   "license": "MIT",

package/scripts/node/bridge-mcp-wiring.cjs

@@ -0,0 +1,310 @@
+#!/usr/bin/env node
+/**
+ * Shared MCP registry wiring for Hermes + OpenCode + OpenClaw bridges.
+ * Used by install-bridges.cjs and platform install commands.
+ */
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const { execSync } = require("child_process");
+
+/** Canonical 7-server MCP surface */
+const XRAY_MCP_SERVERS = [
+  { name: "xray-governance", mcpCmd: "governance", env: { XRAY_FORCE_MCP_GOVERNANCE: "true" } },
+  { name: "xray-skills", mcpCmd: "skills", env: {} },
+  { name: "xray-orchestrator", mcpCmd: "orchestrator", env: {} },
+  { name: "xray-enforcer", mcpCmd: "enforcer", env: {} },
+  { name: "xray-researcher", mcpCmd: "researcher", env: {} },
+  { name: "xray-code-review", mcpCmd: "code-review", env: {} },
+  { name: "xray-architect-tools", mcpCmd: "architect-tools", env: {} },
+];
+
+const HERMES_CONFIG_PATH = path.join(os.homedir(), ".hermes", "config.yaml");
+const HERMES_PLUGIN_DIR = path.join(os.homedir(), ".hermes", "plugins", "xray-hermes");
+const OPENCLAW_CONFIG_PATH = path.join(os.homedir(), ".openclaw", "openclaw.json");
+const OPENCLAW_STATE_DIR = path.join(os.homedir(), ".openclaw");
+
+function detectConsumerExtraMcpServers(targetDir) {
+  const extras = { hermes: {}, opencode: {}, openclaw: {} };
+  try {
+    const pkgPath = path.join(targetDir, "package.json");
+    if (!fs.existsSync(pkgPath)) return extras;
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+    const localRepertoireMcp = path.join(targetDir, "dist", "mcp", "server.js");
+    if (pkg.name === "@0xray/repertoire" && fs.existsSync(localRepertoireMcp)) {
+      extras.hermes.repertoire = {
+        command: "node",
+        args: [localRepertoireMcp],
+        env: { XRAY_ROOT: targetDir },
+      };
+      extras.opencode.repertoire = {
+        type: "local",
+        command: ["node", "dist/mcp/server.js"],
+        enabled: true,
+        cwd: ".",
+      };
+      extras.openclaw.repertoire = {
+        command: "node",
+        args: [localRepertoireMcp],
+        env: { XRAY_ROOT: targetDir },
+      };
+    }
+  } catch {
+    // best-effort
+  }
+  return extras;
+}
+
+function buildStdioMcpServer(mcpCmd, env, targetDir) {
+  return {
+    command: "npx",
+    args: ["-y", "0xray", "mcp", mcpCmd],
+    env: { ...env, XRAY_ROOT: targetDir },
+  };
+}
+
+function buildHermesMcpServers(targetDir) {
+  const servers = {};
+  for (const s of XRAY_MCP_SERVERS) {
+    servers[s.name] = buildStdioMcpServer(s.mcpCmd, s.env, targetDir);
+  }
+  const extras = detectConsumerExtraMcpServers(targetDir);
+  return { ...servers, ...extras.hermes };
+}
+
+function buildOpenClawMcpServers(targetDir) {
+  const servers = {};
+  for (const s of XRAY_MCP_SERVERS) {
+    servers[s.name] = buildStdioMcpServer(s.mcpCmd, s.env, targetDir);
+  }
+  const extras = detectConsumerExtraMcpServers(targetDir);
+  return { ...servers, ...extras.openclaw };
+}
+
+function buildOpencodeMcpEntries(targetDir) {
+  const entries = {};
+  for (const s of XRAY_MCP_SERVERS) {
+    const environment = { ...s.env };
+    entries[s.name] = {
+      type: "local",
+      command: ["npx", "-y", "0xray", "mcp", s.mcpCmd],
+      enabled: true,
+      ...(Object.keys(environment).length > 0 ? { environment } : {}),
+    };
+  }
+  const extras = detectConsumerExtraMcpServers(targetDir);
+  return { ...entries, ...extras.opencode };
+}
+
+function buildPluginMcpJson(targetDir) {
+  const mcpServers = {};
+  for (const s of XRAY_MCP_SERVERS) {
+    mcpServers[s.name] = {
+      command: "npx",
+      args: ["-y", "0xray", "mcp", s.mcpCmd],
+      env: { ...s.env, XRAY_ROOT: targetDir },
+    };
+  }
+  return { mcpServers };
+}
+
+/** Portable .mcp.json for Grok/Cursor — no absolute XRAY_ROOT */
+function buildPortableProjectMcpJson() {
+  const mcpServers = {};
+  for (const s of XRAY_MCP_SERVERS) {
+    mcpServers[s.name] = {
+      command: "npx",
+      args: ["-y", "0xray", "mcp", s.mcpCmd],
+      ...(Object.keys(s.env).length > 0 ? { env: { ...s.env } } : {}),
+    };
+  }
+  return { mcpServers };
+}
+
+function writeHermesPluginArtifacts(targetDir) {
+  if (!fs.existsSync(HERMES_PLUGIN_DIR)) return false;
+  fs.writeFileSync(path.join(HERMES_PLUGIN_DIR, "xray-consumer-root.txt"), `${targetDir}\n`);
+  fs.writeFileSync(
+    path.join(HERMES_PLUGIN_DIR, ".mcp.json"),
+    `${JSON.stringify(buildPluginMcpJson(targetDir), null, 2)}\n`
+  );
+  return true;
+}
+
+function syncHermesMcpRegistry(targetDir) {
+  const servers = buildHermesMcpServers(targetDir);
+  const syncScript = path.join(__dirname, "sync-hermes-mcp-servers.py");
+  if (!fs.existsSync(syncScript)) {
+    throw new Error("sync-hermes-mcp-servers.py missing");
+  }
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "xray-hermes-mcp-"));
+  const serversPath = path.join(tmpDir, "servers.json");
+  try {
+    fs.writeFileSync(serversPath, JSON.stringify(servers));
+    if (!fs.existsSync(path.dirname(HERMES_CONFIG_PATH))) {
+      fs.mkdirSync(path.dirname(HERMES_CONFIG_PATH), { recursive: true });
+    }
+    if (!fs.existsSync(HERMES_CONFIG_PATH)) {
+      fs.writeFileSync(HERMES_CONFIG_PATH, "mcp_servers: {}\n");
+    }
+    const out = execSync(`python3 "${syncScript}" "${HERMES_CONFIG_PATH}" "${serversPath}"`, {
+      encoding: "utf8",
+    });
+    return JSON.parse(out.trim());
+  } finally {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  }
+}
+
+function mergeOpencodeMcpRegistry(targetDir) {
+  const opencodePath = path.join(targetDir, "opencode.json");
+  const entries = buildOpencodeMcpEntries(targetDir);
+  let config = { $schema: "https://opencode.ai/config.json", mcp: {} };
+  if (fs.existsSync(opencodePath)) {
+    try {
+      config = JSON.parse(fs.readFileSync(opencodePath, "utf8"));
+    } catch {
+      config = { $schema: "https://opencode.ai/config.json", mcp: {} };
+    }
+  }
+  config.mcp = { ...(config.mcp || {}), ...entries };
+  fs.writeFileSync(opencodePath, `${JSON.stringify(config, null, 2)}\n`);
+  return Object.keys(entries).length;
+}
+
+function deployPortableProjectMcpJson(targetDir) {
+  const destPath = path.join(targetDir, ".mcp.json");
+  const portable = buildPortableProjectMcpJson();
+  let existing = { mcpServers: {} };
+  if (fs.existsSync(destPath)) {
+    try {
+      existing = JSON.parse(fs.readFileSync(destPath, "utf8"));
+    } catch {
+      existing = { mcpServers: {} };
+    }
+  }
+  const merged = {
+    ...existing,
+    mcpServers: {
+      ...(existing.mcpServers || {}),
+      ...portable.mcpServers,
+    },
+  };
+  fs.writeFileSync(destPath, `${JSON.stringify(merged, null, 2)}\n`);
+}
+
+function enableHermesPluginBestEffort() {
+  try {
+    execSync("hermes plugins enable 0xray-hermes", { stdio: "pipe", encoding: "utf8" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function wireHermesBridge(targetDir) {
+  writeHermesPluginArtifacts(targetDir);
+  const result = syncHermesMcpRegistry(targetDir);
+  enableHermesPluginBestEffort();
+  return result;
+}
+
+function wireOpencodeBridge(targetDir) {
+  return mergeOpencodeMcpRegistry(targetDir);
+}
+
+function resolveOpenClawConfigPath() {
+  if (process.env.OPENCLAW_CONFIG_PATH && fs.existsSync(process.env.OPENCLAW_CONFIG_PATH)) {
+    return process.env.OPENCLAW_CONFIG_PATH;
+  }
+  return OPENCLAW_CONFIG_PATH;
+}
+
+function syncOpenClawMcpRegistryFile(targetDir, configPath) {
+  const servers = buildOpenClawMcpServers(targetDir);
+  if (!fs.existsSync(path.dirname(configPath))) {
+    fs.mkdirSync(path.dirname(configPath), { recursive: true });
+  }
+  let config = {};
+  if (fs.existsSync(configPath)) {
+    try {
+      config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+    } catch {
+      config = {};
+    }
+  }
+  config.mcp = config.mcp || {};
+  config.mcp.servers = { ...(config.mcp.servers || {}), ...servers };
+  fs.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`);
+  return { count: Object.keys(config.mcp.servers).length, path: configPath, method: "file" };
+}
+
+function syncOpenClawMcpRegistryCli(targetDir) {
+  const servers = buildOpenClawMcpServers(targetDir);
+  let wired = 0;
+  for (const [name, serverConfig] of Object.entries(servers)) {
+    const payload = JSON.stringify(serverConfig).replace(/'/g, "'\\''");
+    execSync(`openclaw mcp set ${name} '${payload}'`, { stdio: "pipe", encoding: "utf8" });
+    wired++;
+  }
+  return { count: wired, path: resolveOpenClawConfigPath(), method: "cli" };
+}
+
+function syncOpenClawMcpRegistry(targetDir) {
+  try {
+    execSync("which openclaw", { stdio: "ignore" });
+    return syncOpenClawMcpRegistryCli(targetDir);
+  } catch {
+    return syncOpenClawMcpRegistryFile(targetDir, resolveOpenClawConfigPath());
+  }
+}
+
+function writeOpenClawConsumerArtifacts(targetDir) {
+  if (!fs.existsSync(OPENCLAW_STATE_DIR)) {
+    fs.mkdirSync(OPENCLAW_STATE_DIR, { recursive: true });
+  }
+  fs.writeFileSync(path.join(OPENCLAW_STATE_DIR, "xray-consumer-root.txt"), `${targetDir}\n`);
+
+  const consumerConfigPath = path.join(targetDir, ".xray", "config", "openclaw.json");
+  if (fs.existsSync(consumerConfigPath)) {
+    try {
+      const consumerConfig = JSON.parse(fs.readFileSync(consumerConfigPath, "utf8"));
+      consumerConfig.xrayRoot = targetDir;
+      fs.writeFileSync(consumerConfigPath, `${JSON.stringify(consumerConfig, null, 2)}\n`);
+    } catch {
+      // best-effort
+    }
+  }
+  return true;
+}
+
+function wireOpenClawBridge(targetDir) {
+  writeOpenClawConsumerArtifacts(targetDir);
+  return syncOpenClawMcpRegistry(targetDir);
+}
+
+module.exports = {
+  XRAY_MCP_SERVERS,
+  HERMES_CONFIG_PATH,
+  HERMES_PLUGIN_DIR,
+  OPENCLAW_CONFIG_PATH,
+  OPENCLAW_STATE_DIR,
+  buildHermesMcpServers,
+  buildOpenClawMcpServers,
+  buildOpencodeMcpEntries,
+  buildStdioMcpServer,
+  buildPluginMcpJson,
+  buildPortableProjectMcpJson,
+  writeHermesPluginArtifacts,
+  syncHermesMcpRegistry,
+  mergeOpencodeMcpRegistry,
+  deployPortableProjectMcpJson,
+  enableHermesPluginBestEffort,
+  wireHermesBridge,
+  wireOpencodeBridge,
+  wireOpenClawBridge,
+  syncOpenClawMcpRegistry,
+  writeOpenClawConsumerArtifacts,
+  resolveOpenClawConfigPath,
+  detectConsumerExtraMcpServers,
+};

package/scripts/node/install-bridges.cjs

@@ -8,6 +8,12 @@ const fs = require("fs");
 const path = require("path");
 const os = require("os");
 const { execSync } = require("child_process");
+const {
+  wireHermesBridge,
+  wireOpencodeBridge,
+  wireOpenClawBridge,
+  deployPortableProjectMcpJson,
+} = require("./bridge-mcp-wiring.cjs");
 
 const SKIP_DIRS = new Set(["node_modules", "logs"]);
 const MERGE_FILES = new Set(["enforcer-config.json"]);
@@ -126,44 +132,19 @@ function copyPluginDir(src, dest) {
   return true;
 }
 
-function buildConsumerMcpConfig(targetDir) {
-  const mcpServers = {};
-  for (const s of XRAY_MCP_SERVERS) {
-    mcpServers[s.name] = {
-      command: "npx",
-      args: ["-y", "0xray", "mcp", s.mcpCmd],
-      env: { ...s.env, XRAY_ROOT: targetDir },
-    };
-  }
-  return { mcpServers };
-}
-
-function deployProjectMcpJson(targetDir, log) {
-  const destPath = path.join(targetDir, ".mcp.json");
-  const consumerConfig = buildConsumerMcpConfig(targetDir);
-  let existing = { mcpServers: {} };
-  if (fs.existsSync(destPath)) {
-    try {
-      existing = JSON.parse(fs.readFileSync(destPath, "utf8"));
-    } catch {
-      existing = { mcpServers: {} };
-    }
-  }
-  const merged = {
-    ...existing,
-    mcpServers: { ...(existing.mcpServers || {}), ...consumerConfig.mcpServers },
-  };
-  fs.writeFileSync(destPath, JSON.stringify(merged, null, 2) + "\n");
-  log("mcp-config", "project .mcp.json deployed (7 xray servers)", "info");
-}
-
 function writePluginMcpJson(pluginDir, targetDir, log, label) {
   if (!fs.existsSync(pluginDir)) return;
+  const { buildPluginMcpJson } = require("./bridge-mcp-wiring.cjs");
   const dest = path.join(pluginDir, ".mcp.json");
-  fs.writeFileSync(dest, JSON.stringify(buildConsumerMcpConfig(targetDir), null, 2) + "\n");
+  fs.writeFileSync(dest, JSON.stringify(buildPluginMcpJson(targetDir), null, 2) + "\n");
   log(label, "plugin .mcp.json patched for consumer", "info");
 }
 
+function deployProjectMcpJson(targetDir, log) {
+  deployPortableProjectMcpJson(targetDir);
+  log("mcp-config", "project .mcp.json deployed (7 xray servers, portable)", "info");
+}
+
 function mergeOpencodeJson(targetDir, packageRoot, log) {
   const rootOpencode = path.join(packageRoot, "opencode.json");
   const userOpencode = path.join(targetDir, "opencode.json");
@@ -242,6 +223,13 @@ function installOpencodeBridge(targetDir, packageRoot, log) {
 
   const copied = syncBuiltinSkills(path.join(opencodeDest, "skills"), packageRoot);
   if (copied > 0) log("opencode-bridge", `skills synced (${copied})`, "info", { path: ".opencode/skills/" });
+
+  try {
+    const count = wireOpencodeBridge(targetDir);
+    log("opencode-bridge", `opencode.json mcp wired (${count} servers)`, "info");
+  } catch (e) {
+    log("opencode-bridge", "opencode.json mcp wire failed", "warn", { error: e.message });
+  }
 }
 
 function findGrokPluginSource(packageRoot) {
@@ -358,6 +346,13 @@ function installHermesBridge(targetDir, packageRoot, log) {
   const rootMarker = path.join(targetPluginDir, "xray-consumer-root.txt");
   fs.writeFileSync(rootMarker, targetDir + "\n");
   log("hermes-bridge", "consumer root marker written", "info");
+
+  try {
+    const result = wireHermesBridge(targetDir);
+    log("hermes-bridge", `mcp_servers wired (${result.count} servers)`, "info");
+  } catch (e) {
+    log("hermes-bridge", "mcp_servers wire failed", "warn", { error: e.message });
+  }
 }
 
 function installOpenclawBridge(targetDir, packageRoot, log) {
@@ -395,6 +390,15 @@ function installOpenclawBridge(targetDir, packageRoot, log) {
 
   const copied = syncBuiltinSkills(path.join(os.homedir(), ".openclaw", "skills"), packageRoot);
   if (copied > 0) log("openclaw-bridge", `skills synced (${copied})`, "info", { path: "~/.openclaw/skills/" });
+
+  try {
+    const result = wireOpenClawBridge(targetDir);
+    log("openclaw-bridge", `openclaw.json mcp wired (${result.count} servers)`, "info", {
+      method: result.method,
+    });
+  } catch (e) {
+    log("openclaw-bridge", "openclaw.json mcp wire failed", "warn", { error: e.message });
+  }
 }
 
 const XRAY_CONFIG_FILES = ["codex.json", "features.json", "features.schema.json", "config.json"];

package/scripts/node/sync-hermes-mcp-servers.py

@@ -0,0 +1,31 @@
+#!/usr/bin/env python3
+"""Merge MCP server entries into ~/.hermes/config.yaml mcp_servers."""
+import json
+import sys
+from pathlib import Path
+
+import yaml
+
+
+def main() -> int:
+    if len(sys.argv) != 3:
+        print("usage: sync-hermes-mcp-servers.py <config.yaml> <servers.json>", file=sys.stderr)
+        return 1
+
+    config_path = Path(sys.argv[1])
+    servers = json.loads(Path(sys.argv[2]).read_text())
+
+    config = {}
+    if config_path.exists():
+        config = yaml.safe_load(config_path.read_text()) or {}
+
+    existing = config.get("mcp_servers") or {}
+    existing.update(servers)
+    config["mcp_servers"] = existing
+    config_path.write_text(yaml.safe_dump(config, default_flow_style=False, sort_keys=False))
+    print(json.dumps({"count": len(existing)}))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())