0xray 4.0.13 → 4.0.14

package/dist/integrations/hermes-agent/tools.py

@@ -0,0 +1,357 @@
+"""Tool handlers — code that runs when the LLM calls each tool.
+
+v2.0: Now uses the Node.js bridge for real framework integration.
+Falls back to CLI (npx 0xray) when bridge is unavailable.
+"""
+
+import json
+import subprocess
+import shutil
+import os
+from pathlib import Path
+from . import schemas
+
+def _bridge_call(command: dict, timeout: int = 10) -> dict:
+    """Call the Hermes bridge via subprocess stdin."""
+    from . import _call_bridge
+    return _call_bridge(command, timeout)
+
+def _run_xray(args: list, timeout: int = 30) -> str:
+    """Fallback: run npx 0xray CLI command."""
+    try:
+        result = subprocess.run(
+            ["npx", "0xray"] + args,
+            capture_output=True, text=True, timeout=timeout,
+        )
+        return result.stdout
+    except FileNotFoundError:
+        return json.dumps({"error": "0xray not found. Run: npm install -g 0xray"})
+    except subprocess.TimeoutExpired:
+        return json.dumps({"error": f"Command timed out after {timeout}s"})
+    except Exception as e:
+        return json.dumps({"error": str(e)})
+
+def _get_project_root() -> str:
+    """Find project root (used in fallback mode)."""
+    from . import PROJECT_ROOT
+    return str(PROJECT_ROOT)
+
+
+# ── Tool: xray_validate ─────────────────────────────────────
+
+def xray_validate(args: dict, **kwargs) -> str:
+    """Run pre-commit validation on files using the framework.
+
+    Uses bridge for real quality gate + processor pipeline.
+    Falls back to CLI if bridge unavailable.
+    """
+    files = args.get("files", [])
+    operation = args.get("operation", "commit")
+
+    if not files:
+        return json.dumps({"error": "No files specified for validation"})
+
+    # Try bridge first (real framework integration)
+    bridge_result = _bridge_call({
+        "command": "validate",
+        "files": files,
+        "operation": operation,
+    }, timeout=30)
+
+    if "error" not in bridge_result:
+        return json.dumps({
+            "status": "passed" if bridge_result.get("passed") else "violations",
+            "operation": operation,
+            "files_checked": len(files),
+            "file_results": bridge_result.get("fileResults", []),
+            "via": "bridge",
+        })
+
+    # Fallback to CLI
+    result = json.loads(_run_xray(["validate"], timeout=30))
+    if "error" in result:
+        return json.dumps(result)
+
+    return json.dumps({
+        "status": "ok" if result.get("status") == "ok" else "validation_issues",
+        "operation": operation,
+        "files_checked": len(files),
+        "output": result.get("output", ""),
+        "via": "cli",
+    })
+
+
+# ── Tool: xray_codex_check ──────────────────────────────────
+
+def xray_codex_check(args: dict, **kwargs) -> str:
+    """Check code against Xray codex rules.
+
+    Uses bridge for real quality gate codex checks.
+    Falls back to CLI if bridge unavailable.
+    """
+    code = args.get("code")
+    operation = args.get("operation", "create")
+    focus_areas = args.get("focus_areas", [])
+
+    # Use 'is not None' to correctly handle empty string
+    if code is not None:
+        # Try bridge for real codex checking
+        bridge_result = _bridge_call({
+            "command": "codex-check",
+            "code": code,
+            "focusAreas": focus_areas,
+        }, timeout=15)
+
+        if "error" not in bridge_result:
+            return json.dumps({
+                "status": "passed" if bridge_result.get("passed") else "violations",
+                "operation": operation,
+                "focus_areas": focus_areas or "all",
+                "code_length": len(code),
+                "violations": bridge_result.get("violations", []),
+                "checks": bridge_result.get("checks", []),
+                "via": "bridge",
+            })
+
+        # Bridge unavailable — fall back to static analysis
+        return json.dumps({
+            "status": "checked",
+            "operation": operation,
+            "focus_areas": focus_areas or "all",
+            "code_length": len(code),
+            "note": "Bridge unavailable — basic analysis only. "
+                   "Full codex validation available via MCP: mcp_xray_enforcer_codex_enforcement",
+            "via": "static",
+        })
+
+    # No code provided — check framework health
+    bridge_result = _bridge_call({"command": "health"}, timeout=10)
+    if "error" not in bridge_result:
+        return json.dumps({
+            "status": "ok",
+            "framework": bridge_result.get("framework"),
+            "version": bridge_result.get("version"),
+            "components": bridge_result.get("components"),
+            "note": "Pass 'code' parameter for actual codex validation",
+            "via": "bridge",
+        })
+
+    result = json.loads(_run_xray(["health"], timeout=15))
+    if "error" in result:
+        return json.dumps(result)
+
+    return json.dumps({
+        "status": "ok",
+        "health_output": result.get("output", ""),
+        "note": "Pass 'code' parameter for actual codex validation",
+        "via": "cli",
+    })
+
+
+# ── Tool: xray_health ───────────────────────────────────────
+
+def xray_health(args: dict, **kwargs) -> str:
+    """Check Xray framework health via bridge.
+
+    Returns framework status, loaded components, version.
+    """
+    bridge_result = _bridge_call({"command": "health"}, timeout=10)
+    if "error" not in bridge_result:
+        return json.dumps({
+            "status": "ok",
+            "framework": bridge_result.get("framework"),
+            "version": bridge_result.get("version"),
+            "project_root": bridge_result.get("projectRoot"),
+            "components": bridge_result.get("components"),
+            "node_version": bridge_result.get("nodeVersion"),
+            "via": "bridge",
+        })
+
+    # Fallback to CLI
+    return _run_xray(["health"], timeout=15)
+
+
+# ── Tool: xray_hooks ───────────────────────────────────────
+
+def xray_hooks(args: dict, **kwargs) -> str:
+    """Manage Xray git hooks.
+
+    Actions: install, uninstall, list, status
+    Uses bridge for hook management when available.
+    Falls back to direct file-based management when bridge unavailable.
+    """
+    action = args.get("action", "list")
+    hooks = args.get("hooks", ["pre-commit", "post-commit", "pre-push", "post-push"])
+
+    # Try bridge first
+    bridge_result = _bridge_call({
+        "command": "hooks",
+        "action": action,
+        "hooks": hooks,
+    }, timeout=15)
+
+    if "error" not in bridge_result:
+        return json.dumps({
+            "status": "ok",
+            "action": action,
+            "hooks": hooks,
+            "result": bridge_result,
+            "via": "bridge",
+        })
+
+    # Fallback: direct file-based hook management
+    git_hooks_dir = Path(_get_project_root()) / ".git" / "hooks"
+    xray_hooks_dir = Path(_get_project_root()) / "hooks"
+
+    if not git_hooks_dir.exists():
+        return json.dumps({"error": "Not a git repository", "via": "fallback"})
+
+    if action in ("list", "status"):
+        result = {"managed": [], "missing": [], "external": [], "stale": []}
+        for hook_name in hooks:
+            git_hook = git_hooks_dir / hook_name
+            xray_hook = xray_hooks_dir / hook_name
+            if not git_hook.exists():
+                result["missing"].append(hook_name)
+            else:
+                try:
+                    content = git_hook.read_text()[:500]
+                    if "Xray" in content or "xray" in content or False or "run-hook.js" in content:
+                        result["managed"].append(hook_name)
+                    else:
+                        result["external"].append(hook_name)
+                except OSError:
+                    result["external"].append(hook_name)
+            if not xray_hook.exists():
+                result["stale"].append(hook_name)
+        return json.dumps({"status": "ok", "action": action, **result, "via": "fallback"})
+
+    if action == "install":
+        installed = []
+        skipped = []
+        for hook_name in hooks:
+            src = xray_hooks_dir / hook_name
+            dst = git_hooks_dir / hook_name
+            if not src.exists():
+                skipped.append(hook_name)
+                continue
+            try:
+                if dst.exists():
+                    try:
+                        content = dst.read_text()[:500]
+                        if "Xray" not in content and "xray" not in content:
+                            dst.rename(dst.with_suffix(".xray-backup"))
+                        else:
+                            dst.unlink()
+                    except OSError:
+                        pass
+                try:
+                    rel = os.path.relpath(str(src), str(git_hooks_dir))
+                    os.symlink(rel, dst)
+                except OSError:
+                    shutil.copy2(src, dst)
+                installed.append(hook_name)
+            except OSError:
+                pass
+        return json.dumps({"status": "ok", "action": "install", "installed": installed, "skipped": skipped, "via": "fallback"})
+
+    if action == "uninstall":
+        removed = []
+        restored = []
+        for hook_name in hooks:
+            dst = git_hooks_dir / hook_name
+            backup = dst.with_suffix(".xray-backup")
+            if not dst.exists():
+                continue
+            try:
+                content = dst.read_text()[:500]
+                is_xray = "Xray" in content or "xray" in content or False or "run-hook.js" in content
+                if is_xray or dst.is_symlink():
+                    dst.unlink()
+                    if backup.exists():
+                        shutil.move(str(backup), str(dst))
+                        restored.append(hook_name)
+                    else:
+                        removed.append(hook_name)
+            except OSError:
+                pass
+        return json.dumps({"status": "ok", "action": "uninstall", "removed": removed, "restored": restored, "via": "fallback"})
+
+    return json.dumps({"error": f"Unknown action: {action}", "via": "fallback"})
+
+
+# ── Tool: xray_skill_install ─────────────────────────────────
+
+def xray_skill_install(args: dict, **kwargs) -> str:
+    """Install skills from registry or git repo via bridge."""
+    source = args.get("source", "")
+
+    if not source:
+        return json.dumps({"error": "No source specified for skill install"})
+
+    bridge_result = _bridge_call({
+        "command": "skill-install",
+        "source": source,
+    }, timeout=120)
+
+    if "error" not in bridge_result:
+        return json.dumps({
+            "status": "ok",
+            "source": source,
+            "output": bridge_result.get("output", ""),
+            "via": "bridge",
+        })
+
+    # Fallback to CLI
+    result = _run_xray(["skill:install", source], timeout=120)
+    try:
+        parsed = json.loads(result)
+        if "error" in parsed:
+            return json.dumps(parsed)
+    except json.JSONDecodeError:
+        pass
+    return json.dumps({
+        "status": "ok",
+        "source": source,
+        "output": result.strip(),
+        "via": "cli",
+    })
+
+
+# ── Tool: xray_skill_registry ───────────────────────────────
+
+def xray_skill_registry(args: dict, **kwargs) -> str:
+    """Manage skill registry sources via bridge."""
+    action = args.get("action", "list")
+    name = args.get("name", "")
+    url = args.get("url", "")
+
+    bridge_args = {"command": "skill-registry", "action": action}
+    if name:
+        bridge_args["source"] = name
+    if url:
+        bridge_args["url"] = url
+
+    bridge_result = _bridge_call(bridge_args, timeout=30)
+
+    if "error" not in bridge_result:
+        return json.dumps({
+            "status": "ok",
+            "action": action,
+            "output": bridge_result.get("output", ""),
+            "via": "bridge",
+        })
+
+    # Fallback to CLI
+    cli_args = ["skill:registry", action]
+    if name:
+        cli_args.extend(["--name", name])
+    if url:
+        cli_args.extend(["--url", url])
+    result = _run_xray(cli_args, timeout=30)
+    return json.dumps({
+        "status": "ok",
+        "action": action,
+        "output": result.strip(),
+        "via": "cli",
+    })

package/dist/integrations/hooks/confer-hook-runtime.mjs

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+/**
+ * Lazy-load confer SSOT for Grok session-boot hints.
+ */
+import { createRequire } from 'node:module';
+import { existsSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+function resolvePackageRoot() {
+  let dir = __dirname;
+  for (let i = 0; i < 10; i++) {
+    const pkg = join(dir, 'package.json');
+    if (existsSync(pkg)) {
+      try {
+        const require = createRequire(join(dir, 'package.json'));
+        if (require('./package.json').name === '0xray') return dir;
+      } catch {
+        /* continue */
+      }
+    }
+    const nm = join(dir, 'node_modules', '0xray', 'package.json');
+    if (existsSync(nm)) return dirname(nm);
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return resolve(__dirname, '../../..');
+}
+
+function loadConfer() {
+  const root = resolvePackageRoot();
+  const candidates = [
+    join(__dirname, '../../nucleus/confer.js'),
+    join(root, 'dist/nucleus/confer.js'),
+    join(process.cwd(), 'node_modules/0xray/dist/nucleus/confer.js'),
+  ];
+  const found = candidates.find((p) => existsSync(p));
+  if (!found) return null;
+  return createRequire(import.meta.url)(found);
+}
+
+export function isConferPendingForSession(projectRoot, sessionId = null) {
+  const mod = loadConfer();
+  if (!mod?.isConferPending) return false;
+  return mod.isConferPending(projectRoot, sessionId);
+}

package/dist/integrations/hooks/delegation-gate-runtime.mjs

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+/**
+ * Load compiled delegation-gate SSOT from consumer or package dist.
+ * Used by Grok hooks, Hermes bridge, and verify fixtures.
+ */
+import { createRequire } from 'node:module';
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+/** 0xray package root — never use consumer workspace env (GROK_WORKSPACE_ROOT / XRAY_ROOT). */
+function resolvePackageRoot() {
+  let dir = __dirname;
+  for (let i = 0; i < 10; i++) {
+    const pkg = join(dir, 'package.json');
+    if (existsSync(pkg)) {
+      try {
+        const require = createRequire(join(dir, 'package.json'));
+        const name = require('./package.json').name;
+        if (name === '0xray') return dir;
+      } catch {
+        /* continue */
+      }
+    }
+    const nm = join(dir, 'node_modules', '0xray', 'package.json');
+    if (existsSync(nm)) {
+      return dirname(nm);
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return resolve(__dirname, '../../..');
+}
+
+function markedRoots() {
+  const files = [
+    join(homedir(), '.hermes', 'plugins', 'xray-hermes', 'xray-consumer-root.txt'),
+    join(homedir(), '.openclaw', 'xray-consumer-root.txt'),
+  ];
+  const roots = [];
+  for (const file of files) {
+    if (!existsSync(file)) continue;
+    try {
+      const marked = readFileSync(file, 'utf8').trim();
+      if (marked) {
+        roots.push(marked, join(marked, 'node_modules', '0xray'));
+      }
+    } catch {
+      /* ignore unreadable marker */
+    }
+  }
+  return roots;
+}
+
+function loadDelegationGate() {
+  const root = resolvePackageRoot();
+  const envRoot = process.env.XRAY_AI_PATH || '';
+  const candidates = [
+    join(__dirname, '../../nucleus/delegation-gate.js'),
+    join(root, 'dist/nucleus/delegation-gate.js'),
+    envRoot ? join(envRoot, 'dist/nucleus/delegation-gate.js') : '',
+    ...markedRoots().map((r) => join(r, 'dist/nucleus/delegation-gate.js')),
+    join(process.cwd(), 'node_modules/0xray/dist/nucleus/delegation-gate.js'),
+  ].filter(Boolean);
+  const found = candidates.find((p) => existsSync(p));
+  if (!found) {
+    throw new Error(
+      'delegation-gate.js missing — run npm run build in 0xray or npm install 0xray',
+    );
+  }
+  return createRequire(import.meta.url)(found);
+}
+
+const gate = loadDelegationGate();
+
+export const writeSuitSessionBoot = gate.writeSuitSessionBoot;
+export const maybeHeatHostStation = gate.maybeHeatHostStation;
+
+export const {
+  loadDelegationGateFeatures,
+  normalizeHostToolInput,
+  evaluatePreToolGate,
+  evaluatePendingDelegationGate,
+  evaluateSpawnPlanGate,
+  evaluatePostToolSpawn,
+  checkPendingDelegationGate,
+  checkSubagentGate,
+  satisfyDelegationsFromToolInput,
+  isSubagentTool,
+  isOrchestrateToolEvent,
+  isReadOnlyTool,
+  isWriteTool,
+  isShellTool,
+  getActivePendingDelegations,
+  validateSpawnMatchesTodo,
+  updatePlanTodoStatus,
+  updatePlanTodoStatusInPlace,
+  writeSynthesisConsultReceipt,
+  hasValidSynthesisConsultReceipt,
+  tryRecordSynthesisConsultReceipt,
+  buildReceiptFromConsultOutput,
+  parseConsultVerdictFromText,
+  isSynthesisConsultTodoId,
+  archiveStaleLeadDevPlan,
+  findRecentStalePlanArchive,
+} = gate;