0xray 2.0.0

package/src/mcps/types/__tests__/types.test.ts

@@ -0,0 +1,341 @@
+/**
+ * MCP Types Tests
+ * 
+ * Type validation tests for MCP types.
+ * Ensures type compatibility and structural correctness.
+ */
+
+import { describe, it, expect } from "vitest";
+import {
+  MCPClientConfig,
+  MCPTool,
+  MCPToolResult,
+  IMcpConnection,
+  IServerConfig,
+  IToolRegistry,
+  IProtocolHandler,
+  ISimulationEngine,
+  IConnectionPool,
+} from "../index.js";
+import {
+  JsonRpcRequest,
+  JsonRpcResponse,
+  JsonRpcError,
+} from "../json-rpc.types.js";
+import {
+  MCP_PROTOCOL_VERSION,
+  JSONRPC_VERSION,
+  MCP_METHODS,
+  DEFAULT_TIMEOUTS,
+  ERROR_CODES,
+} from "../../protocol/protocol-constants.js";
+
+describe("MCP Types", () => {
+  describe("MCPClientConfig", () => {
+    it("should create valid MCPClientConfig with required fields", () => {
+      const config: MCPClientConfig = {
+        serverName: "test-server",
+        command: "node",
+        args: ["server.js"],
+      };
+
+      expect(config.serverName).toBe("test-server");
+      expect(config.command).toBe("node");
+      expect(config.args).toEqual(["server.js"]);
+      expect(config.timeout).toBeUndefined();
+      expect(config.env).toBeUndefined();
+      expect(config.basePath).toBeUndefined();
+    });
+
+    it("should create valid MCPClientConfig with all fields", () => {
+      const config: MCPClientConfig = {
+        serverName: "test-server",
+        command: "node",
+        args: ["server.js"],
+        timeout: 30000,
+        env: { NODE_ENV: "test" },
+        basePath: "/path/to/server",
+      };
+
+      expect(config.timeout).toBe(30000);
+      expect(config.env).toEqual({ NODE_ENV: "test" });
+      expect(config.basePath).toBe("/path/to/server");
+    });
+  });
+
+  describe("MCPTool", () => {
+    it("should create valid MCPTool with required fields", () => {
+      const tool: MCPTool = {
+        name: "test-tool",
+        description: "A test tool",
+        inputSchema: {
+          type: "object",
+        },
+      };
+
+      expect(tool.name).toBe("test-tool");
+      expect(tool.description).toBe("A test tool");
+      expect(tool.inputSchema.type).toBe("object");
+    });
+
+    it("should create valid MCPTool with complete schema", () => {
+      const tool: MCPTool = {
+        name: "test-tool",
+        description: "A test tool",
+        inputSchema: {
+          type: "object",
+          properties: {
+            name: { type: "string" },
+            count: { type: "number" },
+          },
+          required: ["name"],
+        },
+      };
+
+      expect(tool.inputSchema.properties).toBeDefined();
+      expect(tool.inputSchema.required).toEqual(["name"]);
+    });
+  });
+
+  describe("MCPToolResult", () => {
+    it("should create valid MCPToolResult with content", () => {
+      const result: MCPToolResult = {
+        content: [
+          {
+            type: "text",
+            text: "Operation completed successfully",
+          },
+        ],
+      };
+
+      expect(result.content).toHaveLength(1);
+      expect(result.content[0].type).toBe("text");
+      expect(result.content[0].text).toBe("Operation completed successfully");
+      expect(result.isError).toBeUndefined();
+    });
+
+    it("should create valid MCPToolResult with error flag", () => {
+      const result: MCPToolResult = {
+        content: [
+          {
+            type: "text",
+            text: "An error occurred",
+          },
+        ],
+        isError: true,
+      };
+
+      expect(result.isError).toBe(true);
+    });
+
+    it("should create valid MCPToolResult with data", () => {
+      const result: MCPToolResult = {
+        content: [
+          {
+            type: "data",
+            data: { key: "value", count: 42 },
+          },
+        ],
+      };
+
+      expect(result.content[0].type).toBe("data");
+      expect(result.content[0].data).toEqual({ key: "value", count: 42 });
+    });
+  });
+
+  describe("JSON-RPC Types", () => {
+    it("should create valid JsonRpcRequest", () => {
+      const request: JsonRpcRequest = {
+        jsonrpc: "2.0",
+        id: 1,
+        method: "tools/list",
+        params: { filter: "test" },
+      };
+
+      expect(request.jsonrpc).toBe("2.0");
+      expect(request.id).toBe(1);
+      expect(request.method).toBe("tools/list");
+      expect(request.params).toEqual({ filter: "test" });
+    });
+
+    it("should create valid JsonRpcRequest with string id", () => {
+      const request: JsonRpcRequest = {
+        jsonrpc: "2.0",
+        id: "request-123",
+        method: "tools/call",
+      };
+
+      expect(request.id).toBe("request-123");
+      expect(request.params).toBeUndefined();
+    });
+
+    it("should create valid JsonRpcResponse with result", () => {
+      const response: JsonRpcResponse = {
+        jsonrpc: "2.0",
+        id: 1,
+        result: { tools: [] },
+      };
+
+      expect(response.jsonrpc).toBe("2.0");
+      expect(response.id).toBe(1);
+      expect(response.result).toEqual({ tools: [] });
+      expect(response.error).toBeUndefined();
+    });
+
+    it("should create valid JsonRpcResponse with error", () => {
+      const error: JsonRpcError = {
+        code: -32601,
+        message: "Method not found",
+        data: { method: "unknown" },
+      };
+
+      const response: JsonRpcResponse = {
+        jsonrpc: "2.0",
+        id: 1,
+        error,
+      };
+
+      expect(response.error).toBeDefined();
+      expect(response.error?.code).toBe(-32601);
+      expect(response.error?.message).toBe("Method not found");
+      expect(response.error?.data).toEqual({ method: "unknown" });
+    });
+  });
+
+  describe("Protocol Constants", () => {
+    it("should have correct MCP protocol version", () => {
+      expect(MCP_PROTOCOL_VERSION).toBe("2024-11-05");
+    });
+
+    it("should have correct JSON-RPC version", () => {
+      expect(JSONRPC_VERSION).toBe("2.0");
+    });
+
+    it("should have correct MCP method names", () => {
+      expect(MCP_METHODS.INITIALIZE).toBe("initialize");
+      expect(MCP_METHODS.TOOLS_LIST).toBe("tools/list");
+      expect(MCP_METHODS.TOOLS_CALL).toBe("tools/call");
+    });
+
+    it("should have correct timeout values", () => {
+      expect(DEFAULT_TIMEOUTS.CONNECTION).toBe(30000);
+      expect(DEFAULT_TIMEOUTS.REQUEST).toBe(60000);
+      expect(DEFAULT_TIMEOUTS.INITIALIZATION).toBe(10000);
+    });
+
+    it("should have correct error codes", () => {
+      expect(ERROR_CODES.PARSE_ERROR).toBe(-32700);
+      expect(ERROR_CODES.INVALID_REQUEST).toBe(-32600);
+      expect(ERROR_CODES.METHOD_NOT_FOUND).toBe(-32601);
+      expect(ERROR_CODES.INVALID_PARAMS).toBe(-32602);
+      expect(ERROR_CODES.INTERNAL_ERROR).toBe(-32603);
+      expect(ERROR_CODES.SERVER_ERROR).toBe(-32000);
+    });
+  });
+
+  describe("Interface Contracts", () => {
+    it("IMcpConnection interface should be implementable", () => {
+      const mockConnection: IMcpConnection = {
+        serverName: "test",
+        isConnected: true,
+        connect: async () => {},
+        disconnect: async () => {},
+        sendRequest: async () => ({
+          jsonrpc: "2.0",
+          id: 1,
+          result: {},
+        }),
+      };
+
+      expect(mockConnection.serverName).toBe("test");
+      expect(mockConnection.isConnected).toBe(true);
+      expect(typeof mockConnection.connect).toBe("function");
+      expect(typeof mockConnection.disconnect).toBe("function");
+      expect(typeof mockConnection.sendRequest).toBe("function");
+    });
+
+    it("IServerConfig interface should be implementable", () => {
+      const mockConfig: IServerConfig = {
+        serverName: "test",
+        command: "node",
+        args: ["server.js"],
+        timeout: 30000,
+        env: { KEY: "value" },
+        basePath: "/path",
+      };
+
+      expect(mockConfig.timeout).toBe(30000);
+    });
+
+    it("IToolRegistry interface should be implementable", () => {
+      const mockRegistry: IToolRegistry = {
+        register: () => {},
+        getTools: () => [],
+        getTool: () => undefined,
+        hasTool: () => false,
+        clear: () => {},
+      };
+
+      expect(typeof mockRegistry.register).toBe("function");
+      expect(typeof mockRegistry.getTools).toBe("function");
+      expect(mockRegistry.getTool("server", "tool")).toBeUndefined();
+    });
+
+    it("IProtocolHandler interface should be implementable", () => {
+      const mockHandler: IProtocolHandler = {
+        buildInitializeRequest: () => ({
+          jsonrpc: "2.0",
+          id: 1,
+          method: "initialize",
+        }),
+        buildToolListRequest: () => ({
+          jsonrpc: "2.0",
+          id: 1,
+          method: "tools/list",
+        }),
+        buildToolCallRequest: () => ({
+          jsonrpc: "2.0",
+          id: 1,
+          method: "tools/call",
+        }),
+        parseResponse: () => ({
+          jsonrpc: "2.0",
+          id: 1,
+          result: {},
+        }),
+      };
+
+      expect(typeof mockHandler.buildInitializeRequest).toBe("function");
+      expect(typeof mockHandler.parseResponse).toBe("function");
+    });
+
+    it("ISimulationEngine interface should be implementable", () => {
+      const mockEngine: ISimulationEngine = {
+        canSimulate: () => true,
+        simulate: async () => ({
+          content: [{ type: "text", text: "simulated" }],
+        }),
+      };
+
+      expect(mockEngine.canSimulate("server", "tool")).toBe(true);
+    });
+
+    it("IConnectionPool interface should be implementable", async () => {
+      const mockPool: IConnectionPool = {
+        acquire: async () =>
+          ({
+            serverName: "test",
+            isConnected: true,
+            connect: async () => {},
+            disconnect: async () => {},
+            sendRequest: async () => ({ jsonrpc: "2.0", id: 1, result: {} }),
+          }) as IMcpConnection,
+        release: () => {},
+        clear: async () => {},
+      };
+
+      expect(typeof mockPool.acquire).toBe("function");
+      expect(typeof mockPool.release).toBe("function");
+    });
+  });
+});

package/src/mcps/types/index.ts

@@ -0,0 +1,17 @@
+/**
+ * MCP Types Barrel Export
+ * 
+ * Centralized export for all MCP-related types.
+ * Import from this file to access all MCP types.
+ * 
+ * @example
+ * ```typescript
+ * import { MCPClientConfig, MCPTool, JsonRpcRequest } from './types/index.js';
+ * ```
+ */
+
+// MCP Core Types
+export * from './mcp.types.js';
+
+// JSON-RPC Protocol Types
+export * from './json-rpc.types.js';

package/src/mcps/types/json-rpc.types.ts

@@ -0,0 +1,38 @@
+/**
+ * JSON-RPC Types
+ * 
+ * TypeScript interfaces for JSON-RPC 2.0 protocol messages.
+ * Used for MCP server communication.
+ */
+
+/**
+ * JSON-RPC Request
+ * Standard JSON-RPC 2.0 request format
+ */
+export interface JsonRpcRequest {
+  jsonrpc: '2.0';
+  id: number | string;
+  method: string;
+  params?: unknown;
+}
+
+/**
+ * JSON-RPC Response
+ * Standard JSON-RPC 2.0 response format
+ */
+export interface JsonRpcResponse {
+  jsonrpc: '2.0';
+  id: number | string;
+  result?: unknown;
+  error?: JsonRpcError;
+}
+
+/**
+ * JSON-RPC Error
+ * Standard JSON-RPC 2.0 error format
+ */
+export interface JsonRpcError {
+  code: number;
+  message: string;
+  data?: unknown;
+}

package/src/mcps/types/mcp.types.ts

@@ -0,0 +1,115 @@
+/**
+ * MCP Types
+ * 
+ * Core TypeScript interfaces and types for the MCP Client system.
+ * Extracted from mcp-client.ts as part of Phase 1 refactoring.
+ */
+
+import type { JsonRpcRequest, JsonRpcResponse } from './json-rpc.types.js';
+
+/**
+ * MCP Client Configuration
+ * Defines the configuration for connecting to an MCP server
+ */
+export interface MCPClientConfig {
+  serverName: string;
+  command: string;
+  args: string[];
+  timeout?: number;
+  env?: Record<string, string>;
+  basePath?: string;
+}
+
+/**
+ * MCP Tool Definition
+ * Represents a tool available on an MCP server
+ */
+export interface MCPTool {
+  name: string;
+  description: string;
+  inputSchema: {
+    type: string;
+    properties?: Record<string, unknown>;
+    required?: string[];
+  };
+}
+
+/**
+ * MCP Tool Result
+ * Represents the result of calling an MCP tool
+ */
+export interface MCPToolResult {
+  content: Array<{
+    type: string;
+    text?: string;
+    data?: unknown;
+  }>;
+  isError?: boolean;
+}
+
+/**
+ * MCP Connection Interface
+ * Defines the contract for MCP server connections
+ */
+export interface IMcpConnection {
+  readonly serverName: string;
+  readonly isConnected: boolean;
+  connect(): Promise<void>;
+  disconnect(): Promise<void>;
+  sendRequest(request: JsonRpcRequest): Promise<JsonRpcResponse>;
+}
+
+/**
+ * Server Configuration Interface
+ * Abstraction over raw MCPClientConfig for dependency injection
+ */
+export interface IServerConfig {
+  serverName: string;
+  command: string;
+  args: string[];
+  timeout: number;
+  env?: Record<string, string>;
+  basePath?: string;
+}
+
+/**
+ * Tool Registry Interface
+ * Manages tool registration and lookup across servers
+ */
+export interface IToolRegistry {
+  register(serverName: string, tools: MCPTool[]): void;
+  getTools(serverName: string): MCPTool[];
+  getTool(serverName: string, toolName: string): MCPTool | undefined;
+  hasTool(serverName: string, toolName: string): boolean;
+  clear(): void;
+}
+
+/**
+ * Protocol Handler Interface
+ * Handles JSON-RPC protocol building and parsing
+ */
+export interface IProtocolHandler {
+  buildInitializeRequest(): JsonRpcRequest;
+  buildToolListRequest(): JsonRpcRequest;
+  buildToolCallRequest(toolName: string, args: unknown): JsonRpcRequest;
+  parseResponse(data: string): JsonRpcResponse;
+}
+
+/**
+ * Simulation Engine Interface
+ * Provides fallback simulation for MCP tools
+ */
+export interface ISimulationEngine {
+  canSimulate(serverName: string, toolName: string): boolean;
+  simulate(serverName: string, toolName: string, args: unknown): Promise<MCPToolResult>;
+}
+
+/**
+ * Connection Pool Interface
+ * Manages MCP connection lifecycle and reuse
+ */
+export interface IConnectionPool {
+  acquire(serverName: string): Promise<IMcpConnection>;
+  release(connection: IMcpConnection): void;
+  clear(): Promise<void>;
+}

package/src/opencode/agents/api-design.yml

@@ -0,0 +1,31 @@
+name: api-design
+skill: api-design
+description: "RESTful API design and validation specialist"
+version: "1.0.0"
+mode: subagent
+
+# CODEX COMPLIANCE
+# - Term 12: No Code Without Tests - all API endpoints require test coverage
+# - Term 17: Type Safety Required - use TypeScript interfaces for all data contracts
+
+# Core Capabilities
+capabilities:
+  - rest_api_design
+  - graphql_api_design
+  - api_validation
+  - openapi_spec_generation
+  - api_documentation
+
+# State Management
+state_management:
+  enabled: true
+  namespaces:
+    - api_specs
+    - endpoint_contracts
+    - validation_rules
+
+# Quality Requirements
+quality:
+  test_coverage: required
+  type_safety: strict
+  documentation: required

package/src/opencode/agents/architect.yml

@@ -0,0 +1,15 @@
+name: architect
+skill: architect-tools
+description: "System design and technical architecture tools specialist"
+version: "1.0.0"
+mode: subagent
+
+capabilities:
+  - system_design
+  - architecture_analysis
+  - technical_documentation
+  - pattern_selection
+
+quality:
+  test_coverage: recommended
+  type_safety: strict

package/src/opencode/agents/architecture-patterns.yml

@@ -0,0 +1,14 @@
+name: architecture-patterns
+skill: architecture-patterns
+description: "Software architecture patterns and best practices specialist"
+version: "1.0.0"
+mode: subagent
+
+capabilities:
+  - pattern_analysis
+  - architecture_review
+  - design_evaluation
+
+quality:
+  test_coverage: recommended
+  type_safety: strict

package/src/opencode/agents/auto-format.yml

@@ -0,0 +1,14 @@
+name: auto-format
+skill: auto-format
+description: "Automated code formatting and style consistency specialist"
+version: "1.0.0"
+mode: subagent
+
+capabilities:
+  - code_formatting
+  - style_enforcement
+  - lint_integration
+
+quality:
+  test_coverage: recommended
+  type_safety: strict

package/src/opencode/agents/backend-engineer.yml

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

package/src/opencode/agents/boot-orchestrator.yml

@@ -0,0 +1,14 @@
+name: boot-orchestrator
+skill: boot-orchestrator
+description: "Framework initialization and boot orchestration specialist"
+version: "1.0.0"
+mode: subagent
+
+capabilities:
+  - framework_boot
+  - processor_initialization
+  - system_startup
+
+quality:
+  test_coverage: required
+  type_safety: strict

package/src/opencode/agents/bug-triage-specialist.yml

@@ -0,0 +1,15 @@
+name: bug-triage-specialist
+skill: bug-triage
+description: "Bug triage, debugging analysis, and issue prioritization specialist"
+version: "1.0.0"
+mode: subagent
+
+capabilities:
+  - bug_analysis
+  - debugging
+  - issue_prioritization
+  - root_cause_analysis
+
+quality:
+  test_coverage: required
+  type_safety: strict

package/src/opencode/agents/code-analyzer.yml

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

package/src/opencode/agents/code-reviewer.yml

@@ -0,0 +1,14 @@
+name: code-reviewer
+skill: code-review
+description: "Comprehensive code quality assessment and improvement suggestions specialist"
+version: "1.0.0"
+mode: subagent
+
+capabilities:
+  - code_review
+  - quality_assessment
+  - improvement_suggestions
+
+quality:
+  test_coverage: required
+  type_safety: strict

package/src/opencode/agents/content-creator.yml

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

package/src/opencode/agents/database-engineer.yml

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