0xray 3.0.12 → 3.1.0

package/src/mcps/security-scan.server.ts

@@ -4,6 +4,12 @@
  * Automated security vulnerability scanning with dependency and code analysis
  */
 
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
 import { execFileSync } from "child_process";
 import fs from "fs";
 import path from "path";
@@ -13,7 +19,6 @@ import {
   type LanguageConfig,
 } from "../utils/language-detector.js";
 import { frameworkLogger } from "../core/framework-logger.js";
-import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
 
 interface SecurityScanArgs {
   scope?: string;
@@ -34,70 +39,109 @@ interface SecuritySummaryResults {
   summary: string;
 }
 
-class XraySecurityScanServer extends XrayKnowledgeSkillBase {
-  constructor() {
-    super("security-scan", "2.0.1");
+class XraySecurityScanServer {
+  private server: Server;
 
-    this.tools = [
+  constructor() {
+    this.server = new Server(
       {
-        name: "security-scan",
-        description:
-          "Comprehensive security vulnerability scanning with dependency and code analysis",
-        inputSchema: {
-          type: "object",
-          properties: {
-            scope: {
-              type: "string",
-              enum: ["dependencies", "code", "full"],
-              default: "full",
-              description: "Scope of security scan",
-            },
-            auditLevel: {
-              type: "string",
-              enum: ["info", "low", "moderate", "high", "critical"],
-              default: "moderate",
-              description: "Audit level for vulnerability detection",
-            },
-            includeOutdated: {
-              type: "boolean",
-              default: true,
-              description: "Include outdated package analysis",
-            },
-          },
-        },
+        name: "security-scan", version: "1.22.67",
       },
       {
-        name: "dependency-audit",
-        description:
-          "Audit third-party dependencies for security vulnerabilities",
-        inputSchema: {
-          type: "object",
-          properties: {
-            packageManager: {
-              type: "string",
-              enum: ["npm", "yarn", "pnpm", "auto"],
-              default: "auto",
-              description: "Package manager to use",
-            },
-            auditLevel: {
-              type: "string",
-              enum: ["info", "low", "moderate", "high", "critical"],
-              default: "moderate",
-            },
-          },
+        capabilities: {
+          tools: {},
         },
       },
-    ];
-
-    this.handlers = {
-      "security-scan": async (args) => this.handleSecurityScan(args),
-      "dependency-audit": async (args) => this.handleDependencyAudit(args),
-    };
+    );
 
     this.setupToolHandlers();
     frameworkLogger.log("mcps/security-scan", "initialize", "info");
   }
 
+  private setupToolHandlers() {
+    // List available tools
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+      return {
+        tools: [
+          {
+            name: "security-scan",
+            description:
+              "Comprehensive security vulnerability scanning with dependency and code analysis",
+            inputSchema: {
+              type: "object",
+              properties: {
+                scope: {
+                  type: "string",
+                  enum: ["dependencies", "code", "full"],
+                  default: "full",
+                  description: "Scope of security scan",
+                },
+                auditLevel: {
+                  type: "string",
+                  enum: ["info", "low", "moderate", "high", "critical"],
+                  default: "moderate",
+                  description: "Audit level for vulnerability detection",
+                },
+                includeOutdated: {
+                  type: "boolean",
+                  default: true,
+                  description: "Include outdated package analysis",
+                },
+              },
+            },
+          },
+          {
+            name: "dependency-audit",
+            description:
+              "Audit third-party dependencies for security vulnerabilities",
+            inputSchema: {
+              type: "object",
+              properties: {
+                packageManager: {
+                  type: "string",
+                  enum: ["npm", "yarn", "pnpm", "auto"],
+                  default: "auto",
+                  description: "Package manager to use",
+                },
+                auditLevel: {
+                  type: "string",
+                  enum: ["info", "low", "moderate", "high", "critical"],
+                  default: "moderate",
+                },
+              },
+            },
+          },
+        ],
+      };
+    });
+
+    // Handle tool calls
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      const { name, arguments: args } = request.params;
+
+      try {
+        switch (name) {
+          case "security-scan":
+            return await this.handleSecurityScan(args);
+          case "dependency-audit":
+            return await this.handleDependencyAudit(args);
+          default:
+            throw new Error(`Unknown tool: ${name}`);
+        }
+      } catch (error) {
+        frameworkLogger.log("mcps/security-scan", "tool-handler", "error", { tool: name, error: String(error) });
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error executing tool "${name}": ${error instanceof Error ? error.message : String(error)}`,
+            },
+          ],
+        };
+      }
+    });
+  }
+
   private async handleSecurityScan(args: unknown) {
     const { scope, auditLevel, includeOutdated } = args as SecurityScanArgs;
     const scopeValue = scope || "full";
@@ -591,12 +635,17 @@ ${results.recommendations.map((r) => `• ${r}`).join("\n") || "No recommendatio
 - Recommendations: ${recCount}`;
   }
 
+  async run() {
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+    frameworkLogger.log("mcps/security-scan", "start", "info");
+  }
 }
 
 // Start the server if run directly
 if (import.meta.url === `file://${process.argv[1]}`) {
   const server = new XraySecurityScanServer();
-  server.run("security-scan").catch((error) => frameworkLogger.log("mcps/security-scan", "run", "error", { error: String(error) }));
+  server.run().catch((error) => frameworkLogger.log("mcps/security-scan", "run", "error", { error: String(error) }));
 }
 
 export { XraySecurityScanServer };

package/src/mcps/simulation/server-simulations.ts

@@ -92,7 +92,7 @@ export const frameworkHelpSimulations: Record<string, SimulatorFunction> = {
         type: 'text',
         text: `**0xRay Framework Capabilities:**
 
-**41 Specialized Agents:**
+**42 Specialized Agents:**
 - enforcer: Codex compliance & error prevention
 - architect: System design & technical decisions
 - orchestrator: Multi-agent workflow coordination

package/src/mcps/state-manager.server.ts

@@ -4,11 +4,16 @@
  * Advanced state management with persistence, synchronization, and conflict resolution
  */
 
-import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  type CallToolResult,
+} from "@modelcontextprotocol/sdk/types.js";
 import fs from "fs";
 import path from "path";
 import { frameworkLogger, generateJobId } from "../core/framework-logger.js";
-import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
 
 interface GetStateArgs {
   key: string;
@@ -57,130 +62,23 @@ interface ValidationResult {
 
 type StateValue = string | number | boolean | object | null | undefined;
 
-class StrRayStateManagerServer extends XrayKnowledgeSkillBase {
+class StrRayStateManagerServer {
+  private server: Server;
   private state: Map<string, unknown> = new Map();
   private stateFile: string;
   private backups: Map<string, unknown> = new Map();
 
   constructor() {
-    super("state-manager", "2.0.1");
-
-    this.tools = [
-      {
-        name: "get-state",
-        description:
-          "Get state value by key with type safety and validation",
-        inputSchema: {
-          type: "object",
-          properties: {
-            key: { type: "string" },
-            defaultValue: {
-              oneOf: [
-                { type: "string" },
-                { type: "number" },
-                { type: "boolean" },
-                { type: "object" },
-                { type: "array" },
-              ],
-            },
-            validate: { type: "boolean", default: true },
-          },
-          required: ["key"],
-        },
-      },
-      {
-        name: "set-state",
-        description:
-          "Set state value by key with conflict resolution and persistence",
-        inputSchema: {
-          type: "object",
-          properties: {
-            key: { type: "string" },
-            value: {
-              oneOf: [
-                { type: "string" },
-                { type: "number" },
-                { type: "boolean" },
-                { type: "object" },
-                { type: "array" },
-              ],
-            },
-            persist: { type: "boolean", default: true },
-            backup: { type: "boolean", default: false },
-          },
-          required: ["key", "value"],
-        },
-      },
-      {
-        name: "delete-state",
-        description:
-          "Delete state value by key with cleanup and validation",
-        inputSchema: {
-          type: "object",
-          properties: {
-            key: { type: "string" },
-            force: { type: "boolean", default: false },
-          },
-          required: ["key"],
-        },
-      },
-      {
-        name: "list-state",
-        description: "List all state keys with filtering and metadata",
-        inputSchema: {
-          type: "object",
-          properties: {
-            prefix: { type: "string" },
-            includeValues: { type: "boolean", default: false },
-            limit: { type: "number", default: 100 },
-          },
-        },
-      },
-      {
-        name: "backup-state",
-        description: "Create backup of current state or specific keys",
-        inputSchema: {
-          type: "object",
-          properties: {
-            keys: { type: "array", items: { type: "string" } },
-            name: { type: "string" },
-          },
-        },
-      },
+    this.server = new Server(
       {
-        name: "restore-state",
-        description: "Restore state from backup",
-        inputSchema: {
-          type: "object",
-          properties: {
-            name: { type: "string" },
-            keys: { type: "array", items: { type: "string" } },
-          },
-          required: ["name"],
-        },
+        name: "state-manager", version: "1.22.67",
       },
       {
-        name: "validate-state",
-        description: "Validate state integrity and consistency",
-        inputSchema: {
-          type: "object",
-          properties: {
-            deep: { type: "boolean", default: false },
-            repair: { type: "boolean", default: false },
-          },
+        capabilities: {
+          tools: {},
         },
       },
-    ];
-
-    this.handlers = {
-      "get-state": async (args) => this.handleGetState(args as unknown as GetStateArgs),
-      "set-state": async (args) => this.handleSetState(args as unknown as SetStateArgs),
-      "delete-state": async (args) => this.handleDeleteState(args as unknown as DeleteStateArgs),
-      "list-state": async (args) => this.handleListState(args as unknown as ListStateArgs),
-      "backup-state": async (args) => this.handleBackupState(args as unknown as BackupStateArgs),
-      "restore-state": async (args) => this.handleRestoreState(args as unknown as RestoreStateArgs),
-      "validate-state": async (args) => this.handleValidateState(args as unknown as ValidateStateArgs),
-    };
+    );
 
     this.stateFile = path.join(
       process.cwd(),
@@ -253,6 +151,153 @@ class StrRayStateManagerServer extends XrayKnowledgeSkillBase {
     }
   }
 
+  private setupToolHandlers() {
+    // List available tools
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+      return {
+        tools: [
+          {
+            name: "get-state",
+            description:
+              "Get state value by key with type safety and validation",
+            inputSchema: {
+              type: "object",
+              properties: {
+                key: { type: "string" },
+                defaultValue: {
+                  oneOf: [
+                    { type: "string" },
+                    { type: "number" },
+                    { type: "boolean" },
+                    { type: "object" },
+                    { type: "array" },
+                  ],
+                },
+                validate: { type: "boolean", default: true },
+              },
+              required: ["key"],
+            },
+          },
+          {
+            name: "set-state",
+            description:
+              "Set state value by key with conflict resolution and persistence",
+            inputSchema: {
+              type: "object",
+              properties: {
+                key: { type: "string" },
+                value: {
+                  oneOf: [
+                    { type: "string" },
+                    { type: "number" },
+                    { type: "boolean" },
+                    { type: "object" },
+                    { type: "array" },
+                  ],
+                },
+                persist: { type: "boolean", default: true },
+                backup: { type: "boolean", default: false },
+              },
+              required: ["key", "value"],
+            },
+          },
+          {
+            name: "delete-state",
+            description:
+              "Delete state value by key with cleanup and validation",
+            inputSchema: {
+              type: "object",
+              properties: {
+                key: { type: "string" },
+                force: { type: "boolean", default: false },
+              },
+              required: ["key"],
+            },
+          },
+          {
+            name: "list-state",
+            description: "List all state keys with filtering and metadata",
+            inputSchema: {
+              type: "object",
+              properties: {
+                prefix: { type: "string" },
+                includeValues: { type: "boolean", default: false },
+                limit: { type: "number", default: 100 },
+              },
+            },
+          },
+          {
+            name: "backup-state",
+            description: "Create backup of current state or specific keys",
+            inputSchema: {
+              type: "object",
+              properties: {
+                keys: { type: "array", items: { type: "string" } },
+                name: { type: "string" },
+              },
+            },
+          },
+          {
+            name: "restore-state",
+            description: "Restore state from backup",
+            inputSchema: {
+              type: "object",
+              properties: {
+                name: { type: "string" },
+                keys: { type: "array", items: { type: "string" } },
+              },
+              required: ["name"],
+            },
+          },
+          {
+            name: "validate-state",
+            description: "Validate state integrity and consistency",
+            inputSchema: {
+              type: "object",
+              properties: {
+                deep: { type: "boolean", default: false },
+                repair: { type: "boolean", default: false },
+              },
+            },
+          },
+        ],
+      };
+    });
+
+    // Handle tool calls
+    this.server.setRequestHandler(CallToolRequestSchema, async (request): Promise<CallToolResult> => {
+      try {
+        const { name, arguments: args } = request.params;
+
+        switch (name) {
+          case "get-state":
+            return await this.handleGetState(args as unknown as GetStateArgs);
+          case "set-state":
+            return await this.handleSetState(args as unknown as SetStateArgs);
+          case "delete-state":
+            return await this.handleDeleteState(args as unknown as DeleteStateArgs);
+          case "list-state":
+            return await this.handleListState(args as unknown as ListStateArgs);
+          case "backup-state":
+            return await this.handleBackupState(args as unknown as BackupStateArgs);
+          case "restore-state":
+            return await this.handleRestoreState(args as unknown as RestoreStateArgs);
+          case "validate-state":
+            return await this.handleValidateState(args as unknown as ValidateStateArgs);
+          default:
+            throw new Error(`Unknown tool: ${name}`);
+        }
+      } catch (error) {
+        return {
+          content: [{
+            type: "text" as const,
+            text: `Error handling tool '${request.params.name}': ${error instanceof Error ? error.message : String(error)}`,
+          }],
+        };
+      }
+    });
+  }
+
   private async handleGetState(args: GetStateArgs): Promise<CallToolResult> {
     const key = args.key;
     const defaultValue = args.defaultValue;
@@ -708,12 +753,25 @@ ${results.repairedKeys.length > 0 ? `**Repaired Keys:**\n${results.repairedKeys.
     return dependents;
   }
 
+  async run() {
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+    const jobId = generateJobId("mcp-state-manager-start");
+    frameworkLogger.log(
+      "mcps/state-manager",
+      "start",
+      "success",
+      {},
+      undefined,
+      jobId,
+    );
+  }
 }
 
 // Start the server if run directly
 if (import.meta.url === `file://${process.argv[1]}`) {
   const server = new StrRayStateManagerServer();
-  server.run("state-manager").catch((error) => frameworkLogger.log("mcps/state-manager", "run", "error", { error: String(error) }));
+  server.run().catch((error) => frameworkLogger.log("mcps/state-manager", "run", "error", { error: String(error) }));
 }
 
 export { StrRayStateManagerServer };

package/src/opencode/agents/testing-best-practices.yml

@@ -0,0 +1,12 @@
+name: testing-best-practices
+skill: testing-best-practices
+description: "testing best practices specialist"
+version: "1.0.0"
+mode: subagent
+
+capabilities:
+  - domain_specialization
+
+quality:
+  test_coverage: recommended
+  type_safety: strict

package/src/opencode/codex.codex

@@ -1,7 +1,7 @@
 {
-  "version": "3.0.11",
+  "version": "1.22.67",
   "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, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68
+    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, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60
   ],
   "framework": "xray Universal Development Codex",
   "compliance": "99.6% Error Prevention"

package/src/opencode/commands/dependency-audit.md

@@ -69,7 +69,7 @@ Comprehensive dependency analysis and security audit for all project dependencie
   "vulnerabilities": [
     {
       "package": "lodash",
-      "version": "3.0.11",
+      "version": "1.22.67",
       "severity": "high",
       "cve": "CVE-2021-23337",
       "description": "Command injection vulnerability"
@@ -85,14 +85,14 @@ Security-focused format for CI/CD integration:
 
 ```json
 {
-  "version": "3.0.11",
+  "version": "1.22.67",
   "$schema": "https://raw.githubusercontent.com/oasis-tcs/sarif-spec/master/Schemata/sarif-schema-2.1.0.json",
   "runs": [
     {
       "tool": {
         "driver": {
           "name": "Dependency Audit",
-          "version": "3.0.11"
+          "version": "1.22.67"
         }
       },
       "results": [...]

package/src/opencode/enforcer-config.json

@@ -1,6 +1,6 @@
 {
-  "framework": "xray 3.0",
-  "version": "3.0.11",
+  "framework": "xray 2.0",
+  "version": "1.22.67",
   "description": "Codex-compliant framework configuration for Credible UI project",
   "thresholds": {
     "bundleSize": {
@@ -220,7 +220,7 @@
       }
     },
     "codex": {
-      "version": "3.0.11",
+      "version": "1.22.67",
       "terms": [
         1,
         2,