0xray 3.0.12 → 3.0.14

package/dist/cli/server.js

@@ -0,0 +1,147 @@
+import express from "express";
+import { exec } from "child_process";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import * as fs from "fs";
+import * as crypto from "crypto";
+import { frameworkLogger } from "../core/framework-logger.js";
+import { resolveConfigPath } from "../core/config-paths.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const ROOT_DIR = join(__dirname, "..", "..");
+const PUBLIC_DIR = join(ROOT_DIR, "public");
+// Read version dynamically from package.json
+const packageJsonPath = join(ROOT_DIR, "package.json");
+const { version } = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+const app = express();
+const PORT = 3000;
+const API_KEY = process.env.STRRAY_API_KEY || undefined;
+function timingSafeCompare(a, b) {
+    const aBuf = Buffer.from(a, "utf-8");
+    const bBuf = Buffer.from(b, "utf-8");
+    if (aBuf.length !== bBuf.length)
+        return false;
+    return crypto.timingSafeEqual(aBuf, bBuf);
+}
+function requireAuth(req, res, next) {
+    if (!API_KEY) {
+        frameworkLogger.log("cli-server", "auth-skipped", "warning", {
+            message: "No STRRAY_API_KEY set — API is unauthenticated. Set STRRAY_API_KEY in production.",
+        });
+        return next();
+    }
+    const providedKey = req.headers["x-api-key"];
+    if (typeof providedKey !== "string") {
+        return res.status(401).json({ error: "API key required. Set STRRAY_API_KEY environment variable." });
+    }
+    if (!timingSafeCompare(providedKey, API_KEY)) {
+        return res.status(403).json({ error: "Invalid API key" });
+    }
+    next();
+}
+// Lazy load security headers middleware
+let securityMiddleware = null;
+const getSecurityMiddleware = async () => {
+    if (!securityMiddleware) {
+        try {
+            const { securityHeadersMiddleware } = await import("../security/security-headers");
+            securityMiddleware = securityHeadersMiddleware.getExpressMiddleware();
+        }
+        catch (error) {
+            frameworkLogger.log("cli-server", "security-middleware-unavailable", "warning", {
+                message: "Security middleware not available, continuing without security headers",
+            });
+            securityMiddleware = (req, res, next) => next(); // No-op middleware
+        }
+    }
+    return securityMiddleware;
+};
+// Apply security headers middleware lazily
+app.use(async (req, res, next) => {
+    try {
+        const middleware = await getSecurityMiddleware();
+        middleware(req, res, next);
+    }
+    catch (error) {
+        frameworkLogger.log("cli-server", "security-middleware-load-failed", "warning", {
+            error,
+            message: "Security middleware failed to load, continuing without it",
+        });
+        next();
+    }
+});
+// Serve static files
+app.use(express.static(PUBLIC_DIR));
+// API endpoints
+app.get("/api/status", requireAuth, (req, res) => {
+    // Return framework status
+    res.json({
+        framework: "0xRay",
+        version,
+        status: "active",
+        agents: 8,
+        timestamp: new Date().toISOString(),
+    });
+});
+app.get("/api/agents", requireAuth, (req, res) => {
+    // Return agent configurations
+    res.json({
+        agents: [
+            "architect",
+            "bug-triage-specialist",
+            "code-reviewer",
+            "security-auditor",
+            "refactorer",
+            "testing-lead",
+        ],
+    });
+});
+// Performance monitoring middleware
+app.use((req, res, next) => {
+    const start = process.hrtime.bigint();
+    res.on("finish", () => {
+        const end = process.hrtime.bigint();
+        const duration = Number(end - start) / 1e6; // Convert to milliseconds
+        // HTTP request logging - operational, keep for monitoring
+    });
+    next();
+});
+// Add route for root path
+app.get("/", (req, res) => {
+    res.sendFile(join(PUBLIC_DIR, "index.html"));
+});
+// Add route for refactoring logs
+app.get("/logs", requireAuth, async (req, res) => {
+    const logPath = resolveConfigPath("REFACTORING_LOG.md") || join(__dirname, "..", ".strray", "REFACTORING_LOG.md");
+    // Server debug logging - remove for production
+    try {
+        if (fs.existsSync(logPath)) {
+            const content = fs.readFileSync(logPath, "utf-8");
+            res.setHeader("Content-Type", "text/markdown");
+            res.send(content);
+        }
+        else {
+            res
+                .status(404)
+                .send("Refactoring log not found. The framework may not have generated any logs yet.");
+        }
+    }
+    catch (error) {
+        // File read error - remove debug logging
+        res.status(500).send("Server error reading log file.");
+    }
+});
+// Global error handler (4-param middleware must be registered before listen)
+app.use((err, req, res, _next) => {
+    frameworkLogger.log("cli-server", "unhandled-error", "error", { error: err, path: req.path });
+    res.status(500).send("Internal Server Error");
+});
+app.listen(PORT, () => {
+    // Auto-open browser
+    const start = process.platform === "darwin"
+        ? "open"
+        : process.platform === "win32"
+            ? "start"
+            : "xdg-open";
+    exec(`${start} http://localhost:${PORT}`);
+});

package/dist/config/default-agents.js

@@ -14,4 +14,3 @@ export function getDefaultAgents() {
 export function getDefaultAgentByName(name) {
     return DEFAULT_AGENTS.find(agent => agent.name === name);
 }
-//# sourceMappingURL=default-agents.js.map

package/dist/config/routing-mappings.js

@@ -130,4 +130,22 @@ export function queryRoutingMappings(keywords) {
 export function getAllRoutingMappings() {
     return ROUTING_MAPPINGS;
 }
-//# sourceMappingURL=routing-mappings.js.map
+/**
+ * Validate that all agent names in routing mappings exist in the SSOT.
+ * Call at boot to detect drift.
+ */
+export function validateRoutingMappings(validAgents) {
+    const errors = [];
+    const seen = new Set();
+    for (const mapping of ROUTING_MAPPINGS) {
+        if (!validAgents.includes(mapping.agent)) {
+            errors.push(`Routing mapping references unknown agent "${mapping.agent}" (keywords: ${mapping.keywords.slice(0, 2).join(", ")})`);
+        }
+        const key = `${mapping.agent}:${mapping.skill}`;
+        if (seen.has(key)) {
+            errors.push(`Duplicate routing mapping: agent="${mapping.agent}" skill="${mapping.skill}"`);
+        }
+        seen.add(key);
+    }
+    return errors;
+}

package/dist/core/activity-logger.js

@@ -9,8 +9,8 @@
  * - Test results
  *
  * Enable/Disable via:
- *   XRAY_ACTIVITY_LOGGING=true  (enable)
- *   XRAY_ACTIVITY_LOGGING=false (disable, default)
+ *   STRRAY_ACTIVITY_LOGGING=true  (enable)
+ *   STRRAY_ACTIVITY_LOGGING=false (disable, default)
  *
  * @module core/activity-logger
  * @version 1.0.0
@@ -21,7 +21,7 @@ import * as zlib from "zlib";
 import { frameworkLogger } from "./framework-logger.js";
 const MAX_LOG_SIZE_BYTES = 5 * 1024 * 1024; // 5MB before rotation
 // Global state
-let activityLoggerEnabled = process.env.XRAY_ACTIVITY_LOGGING !== "false";
+let activityLoggerEnabled = process.env.STRRAY_ACTIVITY_LOGGING !== "false";
 let activityLogPath;
 let sessionId;
 let sessionStartTime;
@@ -184,7 +184,7 @@ export function logActivity(category, level, action, message, details, options)
     // Write to report JSON
     writeToReportFile(record);
     // Console output for debug mode
-    if (process.env.XRAY_ACTIVITY_CONSOLE === "true") {
+    if (process.env.STRRAY_ACTIVITY_CONSOLE === "true") {
         frameworkLogger.log("activity-logger", "console-output", "info", { message: `[${record.timestamp}] [${record.category}] ${level.toUpperCase()}: ${message}`, details: details || "" });
     }
 }
@@ -258,4 +258,3 @@ process.on("exit", () => {
         duration: Date.now() - sessionStartTime,
     });
 });
-//# sourceMappingURL=activity-logger.js.map

package/dist/core/adaptive-kernel.js

@@ -190,4 +190,3 @@ export function getAdaptiveKernel(config) {
 }
 // Re-export for convenience
 export { patternPerformanceTracker, emergingPatternDetector, patternLearningEngine };
-//# sourceMappingURL=adaptive-kernel.js.map

package/dist/core/agent-spawn-gate.js

@@ -1,7 +1,7 @@
 /**
  * Agent Spawn Gate — Singleton (provider-agnostic)
  *
- * CENTRALIZED CONTROL for all agent process spawning across Xray
+ * CENTRALIZED CONTROL for all agent process spawning across StringRay
  * (OpenCode, Hermes, or any other MCP-compatible host).
  *
  * Purpose:
@@ -118,4 +118,3 @@ class AgentSpawnGate {
 /** Singleton export — use this everywhere (provider-agnostic) */
 export const spawnGate = AgentSpawnGate.getInstance();
 export default spawnGate;
-//# sourceMappingURL=agent-spawn-gate.js.map

package/dist/core/boot-orchestrator.js

@@ -1,14 +1,15 @@
 /**
- * Boot Orchestrator (consumer runtime compat; primary XRAY_ env + .xray fallbacks).
+ * Boot Orchestrator (min documented consumer runtime compat shim from prior StringRay releases; primary Xray* paths + XRAY_||STRRAY_ env + .strray fallbacks only; 1-line per Scope Rule).
  */
-import { XrayContextLoader } from "./context-loader.js";
-import { XrayStateManager } from "../state/state-manager.js";
+import { StringRayContextLoader } from "./context-loader.js";
+import { StringRayStateManager } from "../state/state-manager.js";
 import { ProcessorManager } from "../processors/processor-manager.js";
+import { pathResolver } from "../utils/path-resolver.js";
 import * as fs from "fs";
 import * as path from "path";
 const { existsSync, readFileSync } = fs;
 // Path configuration - can be overridden by environment or use path resolver
-const AGENTS_BASE_PATH = process.env.XRAY_AGENTS_PATH || "../agents";
+const AGENTS_BASE_PATH = process.env.STRRAY_AGENTS_PATH || "../agents";
 import { createAgentDelegator, createSessionCoordinator, } from "../delegation/index.js";
 import { createSessionCleanupManager } from "../session/session-cleanup-manager.js";
 import { createSessionMonitor } from "../session/session-monitor.js";
@@ -19,7 +20,7 @@ import { frameworkLogger } from "../core/framework-logger.js";
 import { featuresConfigLoader } from "../core/features-config.js";
 import { memoryMonitor } from "../monitoring/memory-monitor.js";
 import { advancedProfiler } from "../monitoring/advanced-profiler.js";
-import { xrayConfigLoader } from "./config-loader.js";
+import { strRayConfigLoader } from "./config-loader.js";
 import { PluginRegistry } from "../integrations/plugins/index.js";
 import { PluginServerConfigRegistry } from "../mcps/config/index.js";
 import { initializeGovernanceIntegration } from "../integrations/governance/index.js";
@@ -29,10 +30,10 @@ import { initializeGovernanceIntegration } from "../integrations/governance/inde
  */
 function setupGracefulShutdown() {
     // Prevent duplicate listeners
-    if (process._xrayShutdownSetup) {
+    if (process._strrayShutdownSetup) {
         return;
     }
-    process._xrayShutdownSetup = true;
+    process._strrayShutdownSetup = true;
     let isShuttingDown = false;
     process.on("SIGINT", async () => {
         if (isShuttingDown) {
@@ -46,7 +47,7 @@ function setupGracefulShutdown() {
         }
         catch (error) {
             // Suppress error output in CLI mode to avoid breaking interface
-            if (process.env.XRAY_CLI_MODE !== "true" &&
+            if (process.env.STRRAY_CLI_MODE !== "true" &&
                 process.env.OPENCODE_CLI !== "true") {
                 frameworkLogger.log("boot-orchestrator", "shutdown-error", "error", { error, message: "Error during graceful shutdown" });
             }
@@ -68,7 +69,7 @@ function setupGracefulShutdown() {
     // Handle uncaught exceptions that might cause JSON parsing errors
     process.on("uncaughtException", (error) => {
         // Suppress error output in CLI mode to avoid breaking interface
-        if ((process.env.XRAY_CLI_MODE) !== "true" &&
+        if (process.env.STRRAY_CLI_MODE !== "true" &&
             process.env.OPENCODE_CLI !== "true") {
             frameworkLogger.log("boot-orchestrator", "uncaught-exception", "error", { error, message: "Uncaught Exception" });
         }
@@ -78,7 +79,7 @@ function setupGracefulShutdown() {
     });
     process.on("unhandledRejection", (reason, promise) => {
         // Suppress error output in CLI mode to avoid breaking interface
-        if ((process.env.XRAY_CLI_MODE) !== "true" &&
+        if (process.env.STRRAY_CLI_MODE !== "true" &&
             process.env.OPENCODE_CLI !== "true") {
             frameworkLogger.log("boot-orchestrator", "unhandled-rejection", "error", { promise, reason, message: "Unhandled Rejection" });
         }
@@ -97,8 +98,8 @@ export class BootOrchestrator {
     shutdownInitialized = false;
     constructor(config = {}, stateManager) {
         // Initialize components first for state management
-        this.contextLoader = XrayContextLoader.getInstance();
-        this.stateManager = stateManager || new XrayStateManager();
+        this.contextLoader = StringRayContextLoader.getInstance();
+        this.stateManager = stateManager || new StringRayStateManager();
         this.processorManager = new ProcessorManager(this.stateManager);
         this.config = {
             enableEnforcement: true,
@@ -114,7 +115,7 @@ export class BootOrchestrator {
      */
     async initializeDelegationSystem() {
         try {
-            const agentDelegator = createAgentDelegator(this.stateManager, xrayConfigLoader);
+            const agentDelegator = createAgentDelegator(this.stateManager, strRayConfigLoader);
             this.stateManager.set("delegation:agent_delegator", agentDelegator);
             const sessionCoordinator = createSessionCoordinator(this.stateManager);
             this.stateManager.set("delegation:session_coordinator", sessionCoordinator);
@@ -130,8 +131,8 @@ export class BootOrchestrator {
     loadProcessorsConfig() {
         try {
             const configPaths = [
-                path.join(process.cwd(), ".xray", "features.json"),
-                path.join(process.cwd(), ".opencode", "xray", "features.json"),
+                path.join(process.cwd(), ".strray", "features.json"),
+                path.join(process.cwd(), ".opencode", "strray", "features.json"),
             ];
             for (const configPath of configPaths) {
                 if (existsSync(configPath)) {
@@ -151,7 +152,7 @@ export class BootOrchestrator {
     async initializePluginSystem(jobId) {
         try {
             frameworkLogger.log("boot-orchestrator", "initializing plugin system", "info", { jobId });
-            const pluginsDir = path.join(process.cwd(), ".xray", "plugins");
+            const pluginsDir = path.join(process.cwd(), ".strray", "plugins");
             this.pluginRegistry = new PluginRegistry({
                 pluginsDir,
                 autoStart: true,
@@ -188,7 +189,7 @@ export class BootOrchestrator {
                 });
                 return false;
             }
-            const orchestratorInstance = orchestratorModule.xrayOrchestrator || orchestratorModule.strRayOrchestrator;
+            const orchestratorInstance = orchestratorModule.strRayOrchestrator;
             if (!orchestratorInstance) {
                 frameworkLogger.log("boot-orchestrator", "orchestrator-not-found", "error", { message: "Orchestrator instance not found in module" });
                 return false;
@@ -424,9 +425,23 @@ export class BootOrchestrator {
         }
     }
     async runInitialSecurityAudit() {
-        // Consolidated to MCP security-audit.server.ts + shared; initial audit now handled via governance/MCP path
-        frameworkLogger.log("boot-orchestrator", "initial-security-audit-skipped", "info", { message: "Security auditor consolidated to MCP layer (see security-audit.server.ts); boot uses hardener/headers only" });
-        return { score: 100, issues: [] };
+        try {
+            const securityAuditorPath = pathResolver.resolveModulePath("security/security-auditor");
+            const { SecurityAuditor } = await import(securityAuditorPath);
+            const auditor = new SecurityAuditor();
+            const result = await auditor.auditProject(process.cwd());
+            if (result.score < 80) {
+                frameworkLogger.log("boot-orchestrator", "low-security-score", "warning", {
+                    score: result.score,
+                    message: `Initial security score: ${result.score}/100 (target: 80+)`,
+                });
+            }
+            return result;
+        }
+        catch (error) {
+            frameworkLogger.log("boot-orchestrator", "security-audit-failed", "error", { error, message: "Failed to run initial security audit" });
+            return { score: 0, issues: [] };
+        }
     }
     /**
      * Validate processor health during boot
@@ -581,8 +596,8 @@ export class BootOrchestrator {
         };
         try {
             frameworkLogger.log("boot-orchestrator", "loading xray configuration", "info", { jobId });
-            // Consumer runtime compat (XRAY_ env + .xray fallbacks)
-            await this.loadXrayConfiguration(jobId);
+            // Consumer runtime compat shim from prior StringRay releases (1-line min per Scope Rule; primary xray paths + XRAY_||STRRAY_ env + .strray fallbacks)
+            await this.loadStringRayConfiguration(jobId);
             frameworkLogger.log("boot-orchestrator", "xray configuration loaded", "success", { jobId });
             // Phase 1: Initialize core systems
             frameworkLogger.log("boot-orchestrator", "initializing core systems", "info", { jobId });
@@ -712,14 +727,14 @@ export class BootOrchestrator {
         this.stateManager.set("boot:errors", result.errors);
         return result;
     }
-    // Consumer runtime compat (XRAY_ env + .xray fallbacks)
-    async loadXrayConfiguration(jobId) {
+    // Consumer runtime compat shim from prior StringRay releases (1-line min per Scope Rule; primary xray paths + XRAY_||STRRAY_ env + .strray fallbacks)
+    async loadStringRayConfiguration(jobId) {
         try {
-            // Consumer runtime compat (XRAY_ env + .xray fallbacks)
-            const xrayConfig = {
-                version: "3.0.11",
+            // Consumer runtime compat shim from prior StringRay releases (1-line min per Scope Rule; primary xray paths + XRAY_||STRRAY_ env + .strray fallbacks)
+            const stringRayConfig = {
+                version: "1.22.67",
                 codex_enabled: true,
-                codex_version: "v3.0.10",
+                codex_version: "v1.7.5",
                 codex_terms: [
                     1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
                     21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
@@ -778,13 +793,13 @@ export class BootOrchestrator {
                 },
             };
             // Store configuration in state manager for use by other components
-            this.stateManager.set("xray:config", xrayConfig);
-            this.stateManager.set("xray:version", xrayConfig.version);
-            this.stateManager.set("xray:codex_enabled", xrayConfig.codex_enabled);
-            this.stateManager.set("xray:codex_terms", xrayConfig.codex_terms);
-            this.stateManager.set("xray:monitoring_metrics", xrayConfig.monitoring_metrics);
-            this.stateManager.set("xray:monitoring_alerts", xrayConfig.monitoring_alerts);
-            this.stateManager.set("xray:agent_capabilities", xrayConfig.agent_capabilities);
+            this.stateManager.set("strray:config", stringRayConfig);
+            this.stateManager.set("strray:version", stringRayConfig.version);
+            this.stateManager.set("strray:codex_enabled", stringRayConfig.codex_enabled);
+            this.stateManager.set("strray:codex_terms", stringRayConfig.codex_terms);
+            this.stateManager.set("strray:monitoring_metrics", stringRayConfig.monitoring_metrics);
+            this.stateManager.set("strray:monitoring_alerts", stringRayConfig.monitoring_alerts);
+            this.stateManager.set("strray:agent_capabilities", stringRayConfig.agent_capabilities);
             await frameworkLogger.log("boot-orchestrator", "configuration-loaded", "success", { jobId });
         }
         catch (error) {
@@ -795,4 +810,3 @@ export class BootOrchestrator {
 }
 // Export singleton instance
 export const bootOrchestrator = new BootOrchestrator();
-//# sourceMappingURL=boot-orchestrator.js.map

package/dist/core/bridge.mjs

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 
 /**
- * Xray Universal Bridge
+ * StringRay Universal Bridge
  *
- * Standalone bridge that provides Xray framework capabilities
+ * Standalone bridge that provides StringRay framework capabilities
  * to ANY consumer — no OpenCode dependency.
  *
  * Supports three transport modes:
@@ -69,7 +69,7 @@ let frameworkLoadAttempted = false;
 // ============================================================================
 
 function findProjectRoot() {
-  const envHome = process.env.XRAY_HOME;
+  const envHome = process.env.STRRAY_HOME;
   if (envHome && existsSync(join(envHome, "package.json"))) return envHome;
 
   const candidates = [
@@ -84,7 +84,7 @@ function findProjectRoot() {
       const pkgPath = join(dir, "package.json");
       if (existsSync(pkgPath)) {
         const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-        if (pkg.name === "0xray" || pkg.dependencies?.["0xray"]) {
+        if (pkg.name === "strray-ai" || pkg.dependencies?.["strray-ai"] || pkg.name === "0xray" || pkg.dependencies?.["0xray"]) {
           return dir;
         }
       }
@@ -219,11 +219,11 @@ async function handleHealth(input) {
  */
 /** Codex candidate paths — single source of truth for both loadCodexFromFs and handleGetConfig */
 function getCodexCandidates(projectRoot) {
-  const envDir = process.env.XRAY_CONFIG_DIR;
+  const envDir = process.env.STRRAY_CONFIG_DIR;
   const candidates = [];
   if (envDir) candidates.push(join(projectRoot, envDir, "codex.json"));
-  candidates.push(join(projectRoot, ".xray", "codex.json"));
-  candidates.push(join(projectRoot, ".opencode", "xray", "codex.json"));
+  candidates.push(join(projectRoot, ".strray", "codex.json"));
+  candidates.push(join(projectRoot, ".opencode", "strray", "codex.json"));
   candidates.push(join(projectRoot, "codex.json"));
   return candidates;
 }
@@ -281,7 +281,7 @@ async function handleGetCodexPrompt(input, projectRoot, logDir) {
     terms.sort((a, b) => (severityOrder[a.severity] || 3) - (severityOrder[b.severity] || 3));
     if (maxTerms) terms = terms.slice(0, maxTerms);
 
-    const lines = [`## Xray Universal Development Codex v${termsSource.version}`];
+    const lines = [`## StringRay Universal Development Codex v${termsSource.version}`];
     const emojis = { blocking: "🔴", high: "🟡", medium: "🟢" };
     const labels = { blocking: "BLOCKING", high: "HIGH PRIORITY", medium: "MEDIUM" };
 
@@ -348,8 +348,8 @@ async function handleGetConfig(input, projectRoot, logDir) {
   // Load features.json
   const featurePaths = [];
   if (envDir) featurePaths.push(join(projectRoot, envDir, "features.json"));
-  featurePaths.push(join(projectRoot, ".xray", "features.json"));
-  featurePaths.push(join(projectRoot, ".opencode", "xray", "features.json"));
+  featurePaths.push(join(projectRoot, ".strray", "features.json"));
+  featurePaths.push(join(projectRoot, ".opencode", "strray", "features.json"));
 
   let featurePath = null;
   for (const p of featurePaths) {
@@ -604,7 +604,7 @@ function handleHooks(input, projectRoot) {
   const { action, hooks } = input;
   const hookTypes = hooks || ["pre-commit", "post-commit", "pre-push", "post-push"];
   const gitHooksDir = join(projectRoot, ".git", "hooks");
-  const xrayHooksDir = join(projectRoot, "hooks");
+  const strrayHooksDir = join(projectRoot, "hooks");
 
   if (!existsSync(gitHooksDir)) {
     return { error: "Not a git repository — no .git/hooks directory" };
@@ -616,14 +616,14 @@ function handleHooks(input, projectRoot) {
   if (action === "list" || action === "status") {
     for (const hookName of hookTypes) {
       const gitHook = join(gitHooksDir, hookName);
-      const xrayHook = join(xrayHooksDir, hookName);
+      const strrayHook = join(strrayHooksDir, hookName);
 
       if (!existsSync(gitHook)) {
         result.missing.push(hookName);
       } else {
         try {
           const content = readFileSync(gitHook, "utf-8");
-          if (content.includes("Xray") || content.includes("StringRay") || content.includes("xray") || content.includes("strray") || content.includes("run-hook.js")) {
+          if (content.includes("StringRay") || content.includes("strray") || content.includes("run-hook.js")) {
             result.managed.push(hookName);
           } else {
             result.external.push(hookName);
@@ -633,8 +633,8 @@ function handleHooks(input, projectRoot) {
         }
       }
 
-      // Check if xray source hook exists
-      if (!existsSync(xrayHook)) {
+      // Check if strray source hook exists
+      if (!existsSync(strrayHook)) {
         result.stale.push(hookName);
       }
     }
@@ -644,7 +644,7 @@ function handleHooks(input, projectRoot) {
       action,
       hooks: result,
       gitHooksDir,
-      xrayHooksDir,
+      strrayHooksDir,
     };
   }
 
@@ -655,7 +655,7 @@ function handleHooks(input, projectRoot) {
     const errors = [];
 
     for (const hookName of hookTypes) {
-      const src = join(xrayHooksDir, hookName);
+      const src = join(strrayHooksDir, hookName);
       const dst = join(gitHooksDir, hookName);
 
       if (!existsSync(src)) {
@@ -664,11 +664,11 @@ function handleHooks(input, projectRoot) {
       }
 
       try {
-        // Backup existing non-xray hooks
+        // Backup existing non-strray hooks
         if (existsSync(dst)) {
           const content = readFileSync(dst, "utf-8");
-          if (!content.includes("Xray") && !content.includes("StringRay") && !content.includes("xray") && !content.includes("strray") && !content.includes("run-hook.js")) {
-            renameSync(dst, `${dst}.xray-backup`);
+          if (!content.includes("StringRay") && !content.includes("strray") && !content.includes("run-hook.js")) {
+            renameSync(dst, `${dst}.strray-backup`);
           } else {
             unlinkSync(dst);
           }
@@ -699,15 +699,15 @@ function handleHooks(input, projectRoot) {
 
     for (const hookName of hookTypes) {
       const dst = join(gitHooksDir, hookName);
-      const backup = `${dst}.xray-backup`;
+      const backup = `${dst}.strray-backup`;
 
       if (!existsSync(dst)) continue;
 
       try {
         const content = readFileSync(dst, "utf-8");
-        const isXray = content.includes("Xray") || content.includes("StringRay") || content.includes("xray") || content.includes("strray") || content.includes("run-hook.js");
+        const isStrray = content.includes("StringRay") || content.includes("strray") || content.includes("run-hook.js");
 
-        if (isXray || lstatSync(dst).isSymbolicLink()) {
+        if (isStrray || lstatSync(dst).isSymbolicLink()) {
           unlinkSync(dst);
 
           // Restore backup if exists
@@ -748,7 +748,7 @@ function startHttpServer(port, projectRoot) {
   return new Promise((resolve, reject) => {
     const server = createServer(async (req, res) => {
       // CORS headers (wildcard — restrict via STRRAY_HTTP_CORS_ORIGIN env var in production)
-      const corsOrigin = "*";
+      const corsOrigin = process.env.STRRAY_HTTP_CORS_ORIGIN || "*";
       res.setHeader("Content-Type", "application/json");
       res.setHeader("Access-Control-Allow-Origin", corsOrigin);
       res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");

package/dist/core/codex-formatter.js

@@ -84,13 +84,13 @@ export const BUILTIN_CODEX = {
  */
 export function findCodexPath(projectRoot) {
     const root = projectRoot || process.cwd();
-    const envDir = process.env.XRAY_CONFIG_DIR;
+    const envDir = process.env.STRRAY_CONFIG_DIR;
     const candidates = [];
     if (envDir) {
         candidates.push(resolve(root, envDir, "codex.json"));
     }
-    candidates.push(join(root, ".xray", "codex.json"));
-    candidates.push(join(root, "xray", "codex.json"));
+    candidates.push(join(root, ".strray", "codex.json"));
+    candidates.push(join(root, ".opencode", "strray", "codex.json"));
     // Additional fallback locations (for standalone usage)
     candidates.push(join(root, "codex.json"));
     candidates.push(join(root, "src", "codex.json"));
@@ -218,4 +218,3 @@ export function formatMinimalCodexPrompt(options = {}) {
         includeConfigPath: false,
     });
 }
-//# sourceMappingURL=codex-formatter.js.map