0xray 2.1.1 → 2.1.3

package/dist/mcps/security-scan.server.js

@@ -3,106 +3,69 @@
  *
  * 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";
 import { detectProjectLanguage, LANGUAGE_CONFIGS, } from "../utils/language-detector.js";
 import { frameworkLogger } from "../core/framework-logger.js";
-class XraySecurityScanServer {
-    server;
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
+class XraySecurityScanServer extends XrayKnowledgeSkillBase {
     constructor() {
-        this.server = new Server({
-            name: "security-scan", version: "2.0.1",
-        }, {
-            capabilities: {
-                tools: {},
-            },
-        });
-        this.setupToolHandlers();
-        frameworkLogger.log("mcps/security-scan", "initialize", "info");
-    }
-    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",
-                                },
-                            },
+        super("security-scan", "2.0.1");
+        this.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",
                         },
-                    },
-                    {
-                        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",
-                                },
-                            },
+                        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",
                         },
                     },
-                ],
-            };
-        });
-        // 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)}`,
+                },
+            },
+            {
+                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",
+                        },
+                    },
+                },
+            },
+        ];
+        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");
     }
     async handleSecurityScan(args) {
         const { scope, auditLevel, includeOutdated } = args;
@@ -517,15 +480,10 @@ ${results.recommendations.map((r) => `• ${r}`).join("\n") || "No recommendatio
 - Threats: ${threatCount}
 - 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().catch((error) => frameworkLogger.log("mcps/security-scan", "run", "error", { error: String(error) }));
+    server.run("security-scan").catch((error) => frameworkLogger.log("mcps/security-scan", "run", "error", { error: String(error) }));
 }
 export { XraySecurityScanServer };

package/dist/mcps/shared/knowledge-skill-base.d.ts

@@ -0,0 +1,14 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+export interface ToolDefinition {
+    name: string;
+    description: string;
+    inputSchema: object;
+}
+export declare class XrayKnowledgeSkillBase {
+    protected tools: ToolDefinition[];
+    protected handlers: Record<string, (args: unknown) => Promise<any>>;
+    protected server: Server;
+    constructor(serverName: string, version?: string);
+    protected setupToolHandlers(): void;
+    run(serverName: string): Promise<void>;
+}

package/dist/mcps/shared/knowledge-skill-base.js

@@ -0,0 +1,45 @@
+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 { frameworkLogger } from "../../core/framework-logger.js";
+import { createGracefulShutdown } from "../../utils/shutdown-handler.js";
+export class XrayKnowledgeSkillBase {
+    tools = [];
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    handlers = {};
+    server;
+    constructor(serverName, version = "2.0.1") {
+        this.server = new Server({ name: serverName, version }, { capabilities: { tools: {} } });
+    }
+    setupToolHandlers() {
+        this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
+            tools: this.tools.map((t) => ({
+                name: t.name,
+                description: t.description,
+                inputSchema: t.inputSchema,
+            })),
+        }));
+        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            const { name, arguments: args } = request.params;
+            const handler = this.handlers[name];
+            if (!handler) {
+                throw new Error(`Unknown tool: ${name}`);
+            }
+            try {
+                return await handler(args);
+            }
+            catch (error) {
+                return {
+                    content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+                    isError: true,
+                };
+            }
+        });
+    }
+    async run(serverName) {
+        const transport = new StdioServerTransport();
+        await this.server.connect(transport);
+        createGracefulShutdown({ serverName, server: this.server });
+        await frameworkLogger.log(serverName, "server-started", "success");
+    }
+}

package/dist/{security → mcps/shared}/security-scanner.js

@@ -6,7 +6,7 @@
  */
 import { exec } from "child_process";
 import { promises as fs } from "fs";
-import { frameworkLogger } from "../core/framework-logger.js";
+import { frameworkLogger } from "../../core/framework-logger.js";
 import { promisify } from "util";
 import { promptSecurityValidator, } from "./prompt-security-validator.js";
 const execAsync = promisify(exec);

package/dist/mcps/state-manager.server.d.ts

@@ -3,8 +3,8 @@
  *
  * Advanced state management with persistence, synchronization, and conflict resolution
  */
-declare class StrRayStateManagerServer {
-    private server;
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
+declare class StrRayStateManagerServer extends XrayKnowledgeSkillBase {
     private state;
     private stateFile;
     private backups;
@@ -12,7 +12,6 @@ declare class StrRayStateManagerServer {
     private ensureStateDirectory;
     private loadState;
     private saveState;
-    private setupToolHandlers;
     private handleGetState;
     private handleSetState;
     private handleDeleteState;
@@ -23,6 +22,5 @@ declare class StrRayStateManagerServer {
     private validateStateValue;
     private repairStateValue;
     private findDependentKeys;
-    run(): Promise<void>;
 }
 export { StrRayStateManagerServer };

package/dist/mcps/state-manager.server.js

@@ -3,25 +3,128 @@
  *
  * Advanced state management with persistence, synchronization, and conflict resolution
  */
-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 fs from "fs";
 import path from "path";
 import { frameworkLogger, generateJobId } from "../core/framework-logger.js";
-class StrRayStateManagerServer {
-    server;
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
+class StrRayStateManagerServer extends XrayKnowledgeSkillBase {
     state = new Map();
     stateFile;
     backups = new Map();
     constructor() {
-        this.server = new Server({
-            name: "state-manager", version: "2.0.1",
-        }, {
-            capabilities: {
-                tools: {},
+        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" },
+                    },
+                },
+            },
+            {
+                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 },
+                    },
+                },
+            },
+        ];
+        this.handlers = {
+            "get-state": async (args) => this.handleGetState(args),
+            "set-state": async (args) => this.handleSetState(args),
+            "delete-state": async (args) => this.handleDeleteState(args),
+            "list-state": async (args) => this.handleListState(args),
+            "backup-state": async (args) => this.handleBackupState(args),
+            "restore-state": async (args) => this.handleRestoreState(args),
+            "validate-state": async (args) => this.handleValidateState(args),
+        };
         this.stateFile = path.join(process.cwd(), ".opencode", "state", "mcp-state.json");
         this.ensureStateDirectory();
         this.loadState();
@@ -61,148 +164,6 @@ class StrRayStateManagerServer {
             throw error;
         }
     }
-    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) => {
-            try {
-                const { name, arguments: args } = request.params;
-                switch (name) {
-                    case "get-state":
-                        return await this.handleGetState(args);
-                    case "set-state":
-                        return await this.handleSetState(args);
-                    case "delete-state":
-                        return await this.handleDeleteState(args);
-                    case "list-state":
-                        return await this.handleListState(args);
-                    case "backup-state":
-                        return await this.handleBackupState(args);
-                    case "restore-state":
-                        return await this.handleRestoreState(args);
-                    case "validate-state":
-                        return await this.handleValidateState(args);
-                    default:
-                        throw new Error(`Unknown tool: ${name}`);
-                }
-            }
-            catch (error) {
-                return {
-                    content: [{
-                            type: "text",
-                            text: `Error handling tool '${request.params.name}': ${error instanceof Error ? error.message : String(error)}`,
-                        }],
-                };
-            }
-        });
-    }
     async handleGetState(args) {
         const key = args.key;
         const defaultValue = args.defaultValue;
@@ -622,16 +583,10 @@ ${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().catch((error) => frameworkLogger.log("mcps/state-manager", "run", "error", { error: String(error) }));
+    server.run("state-manager").catch((error) => frameworkLogger.log("mcps/state-manager", "run", "error", { error: String(error) }));
 }
 export { StrRayStateManagerServer };

package/dist/orchestrator/orchestrator.d.ts

@@ -140,4 +140,4 @@ export declare class XrayOrchestrator {
     };
 }
 export declare const xrayOrchestrator: XrayOrchestrator;
-export { xrayOrchestrator as strRayOrchestrator, XrayOrchestrator as StringRayOrchestrator };
+export { xrayOrchestrator as strRayOrchestrator };

package/dist/orchestrator/orchestrator.js

@@ -656,4 +656,4 @@ export class XrayOrchestrator {
 // Export singleton instance
 export const xrayOrchestrator = new XrayOrchestrator();
 // Backward compat alias
-export { xrayOrchestrator as strRayOrchestrator, XrayOrchestrator as StringRayOrchestrator };
+export { xrayOrchestrator as strRayOrchestrator };

package/dist/orchestrator/universal-registry-bridge.js

@@ -114,7 +114,7 @@ export class UniversalRegistryBridge {
                 currentAgent = {
                     name: nameMatch[1].trim(),
                     description: "",
-                    version: "2.0.1",
+                    version: "2.1.1",
                 };
                 inAgent = true;
                 continue;

package/dist/plugin/xray-codex-injection.d.ts

@@ -1,5 +1,5 @@
 /**
- * Consumer runtime compat shim from prior StringRay releases (1-line min per Scope Rule; xray codex injection + XRAY_||STRRAY_ env + .xray fallbacks).
+ * Consumer runtime compat (xray codex injection + XRAY_ env + .xray fallbacks).
  */
 interface ToolExecuteAfterInput {
     tool: string;

package/dist/plugin/xray-codex-injection.js

@@ -1,5 +1,5 @@
 /**
- * Consumer runtime compat shim from prior StringRay releases (1-line min per Scope Rule; xray codex injection + XRAY_||STRRAY_ env + .xray fallbacks).
+ * Consumer runtime compat (xray codex injection + XRAY_ env + .xray fallbacks).
  */
 import * as fs from "fs";
 import * as path from "path";