0xray 4.0.40 → 4.0.42

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

@@ -139,11 +139,32 @@ function enableMemoryRoutingIfResolves(features, targetDir) {
   };
 }
 
+function isDogfoodXrayPackage(targetDir) {
+  try {
+    const pkgPath = path.join(targetDir, "package.json");
+    if (!fs.existsSync(pkgPath)) return false;
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+    return pkg && pkg.name === "0xray";
+  } catch {
+    return false;
+  }
+}
+
 function resolveGogglesMcp(targetDir) {
-  const candidates = [
-    path.join(targetDir, "node_modules", "0xray", "scripts", "mjs", "run-goggles-mcp.mjs"),
-    path.join(targetDir, "scripts", "mjs", "run-goggles-mcp.mjs"),
-  ];
+  const installed = path.join(
+    targetDir,
+    "node_modules",
+    "0xray",
+    "scripts",
+    "mjs",
+    "run-goggles-mcp.mjs",
+  );
+  const checkout = path.join(targetDir, "scripts", "mjs", "run-goggles-mcp.mjs");
+  // The factory package is not installed into its own node_modules. npm upgrade
+  // removes that folder, and a recorded node_modules path then fails the handshake.
+  const candidates = isDogfoodXrayPackage(targetDir)
+    ? [checkout, installed]
+    : [installed, checkout];
   return candidates.find((file) => fs.existsSync(file)) || null;
 }
 
@@ -315,7 +336,18 @@ function pinnedMcpLaunch(targetDir, mcpCmd) {
  */
 const LIVE_ENV_NAMES = ["PATH", "HOME"];
 
+let launcherPackageRoot = "";
+
+/** Wear sets this so a /tmp checkout is not the path written into a real project. */
+function pinLauncherPackageRoot(packageRoot) {
+  launcherPackageRoot = packageRoot ? path.resolve(packageRoot) : "";
+}
+
 function mcpLauncherPath() {
+  if (launcherPackageRoot) {
+    const candidate = path.join(launcherPackageRoot, "scripts", "node", "mcp-launch.cjs");
+    if (fs.existsSync(candidate)) return candidate;
+  }
   return path.join(__dirname, "mcp-launch.cjs");
 }
 
@@ -837,7 +869,125 @@ function resolveOpenClawPluginDir(packageRoot) {
   ].find((p) => fs.existsSync(path.join(p, "index.js"))) || null;
 }
 
-function installOpenClawHostWear(packageRoot) {
+function isCheckoutOpenClawPluginPath(pluginPath) {
+  const normalized = String(pluginPath || "").replace(/\\/g, "/");
+  return (
+    normalized.includes("/src/integrations/openclaw/plugin/xray-pre-tool") &&
+    !normalized.includes("/node_modules/")
+  );
+}
+
+function isInstalledOpenClawPluginPath(pluginPath) {
+  const normalized = String(pluginPath || "").replace(/\\/g, "/");
+  return (
+    normalized.includes("/node_modules/") &&
+    normalized.includes("/integrations/openclaw/plugin/xray-pre-tool")
+  );
+}
+
+/** Installed package first. A checkout src path drops once any installed plugin is present. */
+function settleOpenClawPluginPaths(paths, wornPluginDir) {
+  const list = (Array.isArray(paths) ? paths : []).map((entry) => String(entry));
+  const wornIsInstalled = Boolean(wornPluginDir && isInstalledOpenClawPluginPath(wornPluginDir));
+  const dropCheckout =
+    wornIsInstalled || list.some((entry) => isInstalledOpenClawPluginPath(entry));
+  const next = [];
+  const seen = new Set();
+  const push = (entry) => {
+    if (!entry) return;
+    const resolved = path.resolve(String(entry));
+    if (dropCheckout && isCheckoutOpenClawPluginPath(resolved)) return;
+    if (seen.has(resolved)) return;
+    seen.add(resolved);
+    next.push(resolved);
+  };
+  if (wornIsInstalled) push(wornPluginDir);
+  for (const entry of list) push(entry);
+  return next;
+}
+
+function resolveWornOpenClawPlugin(targetDir, packageRoot) {
+  const candidates = [];
+  if (targetDir) {
+    candidates.push(
+      path.join(targetDir, "node_modules", "0xray", "dist", "integrations", "openclaw", "plugin", "xray-pre-tool"),
+      path.join(targetDir, "node_modules", "0xray", "src", "integrations", "openclaw", "plugin", "xray-pre-tool"),
+    );
+  }
+  const fromPackage = resolveOpenClawPluginDir(packageRoot);
+  if (fromPackage) candidates.push(fromPackage);
+  return candidates.find((dir) => fs.existsSync(path.join(dir, "index.js"))) || null;
+}
+
+function replaceJsonPathsArray(raw, before, next) {
+  const keyAt = raw.indexOf('"paths"');
+  if (keyAt < 0) return null;
+  const bracket = raw.indexOf("[", keyAt);
+  if (bracket < 0) return null;
+  let depth = 0;
+  let end = -1;
+  for (let i = bracket; i < raw.length; i += 1) {
+    const ch = raw[i];
+    if (ch === "[") depth += 1;
+    else if (ch === "]") {
+      depth -= 1;
+      if (depth === 0) {
+        end = i;
+        break;
+      }
+    }
+  }
+  if (end < 0) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(raw.slice(bracket, end + 1));
+  } catch {
+    return null;
+  }
+  if (JSON.stringify(parsed) !== JSON.stringify(before)) return null;
+  const lineStart = raw.lastIndexOf("\n", keyAt) + 1;
+  const indent = (raw.slice(lineStart, keyAt).match(/^\s*/) || [""])[0];
+  const itemIndent = `${indent}  `;
+  const body = next
+    .map((entry) => `${itemIndent}${JSON.stringify(entry)}`)
+    .join(",\n");
+  const array = `[\n${body}\n${indent}]`;
+  return `${raw.slice(0, bracket)}${array}${raw.slice(end + 1)}`;
+}
+
+/** Rewrite plugins.load.paths in place. Leaves the rest of the config file alone. */
+function pinOpenClawPluginLoad(configPath, wornPluginDir) {
+  if (!configPath || !fs.existsSync(configPath)) return null;
+  const raw = fs.readFileSync(configPath, "utf8");
+  const config = JSON.parse(raw);
+  if (!config.plugins || typeof config.plugins !== "object") return null;
+  if (!config.plugins.load || typeof config.plugins.load !== "object") config.plugins.load = {};
+  const before = Array.isArray(config.plugins.load.paths) ? config.plugins.load.paths : [];
+  const next = settleOpenClawPluginPaths(before, wornPluginDir);
+  if (JSON.stringify(before) === JSON.stringify(next)) return next;
+  const replaced = replaceJsonPathsArray(raw, before, next);
+  if (replaced == null) return null;
+  fs.writeFileSync(configPath, replaced);
+  return next;
+}
+
+function recordOpenClawProjectPlugin(targetDir, packageRoot) {
+  const pluginDir = resolveWornOpenClawPlugin(targetDir, packageRoot);
+  if (!pluginDir || !isInstalledOpenClawPluginPath(pluginDir)) return null;
+  const configPath = path.join(targetDir, ".xray", "config", "openclaw.json");
+  if (!fs.existsSync(configPath)) return null;
+  let config;
+  try {
+    config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+  } catch {
+    return null;
+  }
+  config.pluginPath = path.resolve(pluginDir);
+  fs.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`);
+  return config.pluginPath;
+}
+
+function installOpenClawHostWear(packageRoot, targetDir) {
   if (millSuit.isIsolatedHome()) return null;
   const source = resolveOpenClawPreToolHookSource(packageRoot);
   if (!source) return null;
@@ -846,6 +996,11 @@ function installOpenClawHostWear(packageRoot) {
   fs.mkdirSync(hookDir, { recursive: true });
   const dest = path.join(hookDir, "xray-pre-tool.mjs");
   fs.copyFileSync(source, dest);
+  const worn = resolveWornOpenClawPlugin(targetDir, packageRoot);
+  const hookRoot =
+    worn && isInstalledOpenClawPluginPath(worn) && targetDir
+      ? path.join(path.resolve(targetDir), "node_modules", "0xray")
+      : packageRoot;
   fs.writeFileSync(
     path.join(hookDir, "xray-pre-tool.json"),
     `${JSON.stringify(
@@ -855,17 +1010,16 @@ function installOpenClawHostWear(packageRoot) {
         args: [dest],
         stdin: "json",
         blockExitCode: 2,
-        env: { XRAY_AI_PATH: packageRoot },
+        env: { XRAY_AI_PATH: hookRoot },
       },
       null,
       2,
     )}\n`,
   );
 
-  const pluginSrc = resolveOpenClawPluginDir(packageRoot);
-  if (pluginSrc) {
+  if (worn && isInstalledOpenClawPluginPath(worn)) {
     try {
-      execFileSync("openclaw", ["plugins", "install", "-l", pluginSrc], {
+      execFileSync("openclaw", ["plugins", "install", "-l", path.resolve(worn)], {
         stdio: "pipe",
         encoding: "utf8",
         timeout: 60000,
@@ -883,6 +1037,13 @@ function installOpenClawHostWear(packageRoot) {
       /* enable is best-effort */
     }
   }
+  const configPath = resolveOpenClawConfigPath();
+  if (fs.existsSync(configPath)) {
+    pinOpenClawPluginLoad(
+      configPath,
+      worn && isInstalledOpenClawPluginPath(worn) ? worn : null,
+    );
+  }
   return dest;
 }
 
@@ -947,6 +1108,102 @@ function wireOpenClawBridge(targetDir) {
   return syncOpenClawMcpRegistry(targetDir);
 }
 
+function tomlString(value) {
+  return JSON.stringify(String(value));
+}
+
+function suitServerNames() {
+  return new Set(XRAY_MCP_SERVERS.map((server) => server.name));
+}
+
+function isSuitMcpHeader(line, names) {
+  const match = /^\[([^\]]+)\]\s*$/.exec(line.trim());
+  if (!match) return false;
+  const parts = match[1].split(".");
+  return parts[0] === "mcp_servers" && names.has(parts[1]);
+}
+
+function stripSuitMcpBlocks(toml, names) {
+  const kept = [];
+  let skip = false;
+  for (const line of String(toml || "").split(/\r?\n/)) {
+    if (/^\s*\[/.test(line)) skip = isSuitMcpHeader(line, names);
+    if (!skip) kept.push(line);
+  }
+  return kept.join("\n").replace(/\n{3,}/g, "\n\n").trim();
+}
+
+function suitMcpBlock(server, launch) {
+  const args = launch.args.map((arg) => `  ${tomlString(arg)},`).join("\n");
+  const lines = [
+    `[mcp_servers.${server.name}]`,
+    `command = ${tomlString(launch.command)}`,
+    "args = [",
+    args,
+    "]",
+    "enabled = true",
+  ];
+  const env = launch.env && typeof launch.env === "object" ? launch.env : {};
+  const envKeys = Object.keys(env);
+  if (envKeys.length > 0) {
+    lines.push("", `[mcp_servers.${server.name}.env]`);
+    for (const key of envKeys) lines.push(`${key} = ${tomlString(env[key])}`);
+  }
+  return lines.join("\n");
+}
+
+/**
+ * Project `.grok/config.toml` replaces a same-named user server.
+ * The launch is the worn package, not `npx -y 0xray`.
+ */
+function writeProjectSuitMcp(targetDir) {
+  const root = path.resolve(targetDir);
+  const names = suitServerNames();
+  const blocks = XRAY_MCP_SERVERS.map((server) =>
+    suitMcpBlock(server, scopedMcpLaunch(root, server.mcpCmd, server.env)),
+  );
+  const grokDir = path.join(root, ".grok");
+  fs.mkdirSync(grokDir, { recursive: true });
+  const tomlPath = path.join(grokDir, "config.toml");
+  const existing = fs.existsSync(tomlPath) ? fs.readFileSync(tomlPath, "utf8") : "";
+  const kept = stripSuitMcpBlocks(existing, names);
+  const body = [kept, blocks.join("\n\n")].filter((part) => part && part.trim()).join("\n\n");
+  fs.writeFileSync(tomlPath, `${body.trim()}\n`);
+  return tomlPath;
+}
+
+function grokConfigHome(env) {
+  const source = env || process.env;
+  const home = source.HOME || source.USERPROFILE;
+  return home ? path.resolve(home) : os.homedir();
+}
+
+/** Grok 1.0.50 has no --trust flag. An untrusted folder skips project MCP. */
+function trustGrokFolder(targetDir, env) {
+  const home = grokConfigHome(env);
+  const grokDir = path.join(home, ".grok");
+  fs.mkdirSync(grokDir, { recursive: true });
+  const file = path.join(grokDir, "trusted_folders.toml");
+  let text = fs.existsSync(file) ? fs.readFileSync(file, "utf8") : "";
+  const folders = [path.resolve(targetDir)];
+  try {
+    const real = fs.realpathSync(folders[0]);
+    if (real !== folders[0]) folders.push(real);
+  } catch {
+    /* the path is the one Grok will see */
+  }
+  const now = Math.floor(Date.now() / 1000);
+  let added = 0;
+  for (const folder of folders) {
+    const header = `[folders.${tomlString(folder)}]`;
+    if (text.includes(header)) continue;
+    text = `${text.replace(/\s*$/, "")}\n${header}\ntrusted = true\ndecided_at = ${now}\n`;
+    added += 1;
+  }
+  if (added > 0) fs.writeFileSync(file, text.endsWith("\n") ? text : `${text}\n`);
+  return file;
+}
+
 module.exports = {
   XRAY_MCP_SERVERS,
   HERMES_CONFIG_PATH,
@@ -988,9 +1245,16 @@ module.exports = {
   enableMemoryRoutingIfResolves,
   isEphemeralInstallRoot,
   isIsolatedHome,
+  pinLauncherPackageRoot,
   copyHermesHookRuntimes,
   resolveOpenClawPreToolHookSource,
   resolveOpenClawPluginDir,
   installOpenClawHostWear,
+  settleOpenClawPluginPaths,
+  pinOpenClawPluginLoad,
+  recordOpenClawProjectPlugin,
+  resolveWornOpenClawPlugin,
   maybeWriteOpenClawCliBackend,
+  writeProjectSuitMcp,
+  trustGrokFolder,
 };

package/scripts/node/confer-switch.cjs

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+/**
+ * Turn confer on or off in the worn .xray/features.json.
+ * A missing key stays off until this runs. Synthesis stays untouched.
+ */
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+
+function fail(message) {
+  process.stderr.write(`${message}\n`);
+  process.exit(1);
+}
+
+function orchestrationBlock(data) {
+  const current = data.multi_agent_orchestration;
+  if (current && typeof current === "object" && !Array.isArray(current)) return current;
+  const created = {};
+  data.multi_agent_orchestration = created;
+  return created;
+}
+
+function conferBlock(orch) {
+  const current = orch.confer;
+  if (current && typeof current === "object" && !Array.isArray(current)) return current;
+  const created = {};
+  orch.confer = created;
+  return created;
+}
+
+function main() {
+  const state = process.argv[2];
+  if (state !== "on" && state !== "off") fail("confer: say on or off");
+
+  const featuresPath = path.join(process.cwd(), ".xray", "features.json");
+  if (!fs.existsSync(featuresPath)) {
+    fail("confer: .xray/features.json is missing. Run npx 0xray wear first.");
+  }
+
+  let data;
+  try {
+    data = JSON.parse(fs.readFileSync(featuresPath, "utf8"));
+  } catch {
+    fail("confer: .xray/features.json is not valid JSON");
+  }
+  if (!data || typeof data !== "object" || Array.isArray(data)) {
+    fail("confer: .xray/features.json is not valid JSON");
+  }
+
+  const orch = orchestrationBlock(data);
+  const confer = conferBlock(orch);
+  if (state === "on") {
+    confer.enabled = true;
+    if (confer.on_synthesis !== false) confer.on_synthesis = true;
+  } else {
+    confer.enabled = false;
+    confer.on_synthesis = false;
+    orch.confer_on_synthesis = false;
+  }
+
+  fs.writeFileSync(featuresPath, `${JSON.stringify(data, null, 2)}\n`);
+  process.stdout.write(`confer: ${state}\n`);
+}
+
+if (require.main === module) main();