0xray 3.0.11 → 3.0.14

package/src/mcps/config/__tests__/config-loader.test.ts

@@ -206,7 +206,7 @@ describe('ConfigLoader', () => {
       fs.writeFileSync(testConfigPath, JSON.stringify(testConfigs));
       loader.addConfigPath(testConfigPath);
       
-      loader.clearConfigPaths();
+      loader.resetConfigPaths();
       
       const result = await loader.load();
       expect(result.success).toBe(true);
@@ -266,20 +266,16 @@ describe('ConfigLoader', () => {
 
   describe('hasConfigFile', () => {
     it('should return false when no config file exists', () => {
-      const emptyLoader = new ConfigLoader();
-      emptyLoader.clearConfigPaths();
-      expect(emptyLoader.hasConfigFile()).toBe(false);
+      expect(loader.hasConfigFile()).toBe(false);
     });
 
     it('should return true when default config file exists', () => {
       const testConfigs = [{ serverName: 'test', command: 'node', args: ['test.js'], timeout: 30000 }];
-      const tmpConfig = '.test-mcp-default.json';
-      fs.writeFileSync(tmpConfig, JSON.stringify(testConfigs));
-      loader.addConfigPath(tmpConfig);
+      fs.writeFileSync('.mcp.json', JSON.stringify(testConfigs));
       
       expect(loader.hasConfigFile()).toBe(true);
       
-      fs.unlinkSync(tmpConfig);
+      fs.unlinkSync('.mcp.json');
     });
 
     it('should return true when added config file exists', () => {

package/src/mcps/config/__tests__/server-config-registry.test.ts

@@ -164,38 +164,38 @@ describe('ServerConfigRegistry', () => {
       expect(config.timeout).toBe(30000);
     });
 
-    it('should use XRAY_DEV_PATH env var in dynamic config', () => {
-      const originalXrayEnv = process.env.XRAY_DEV_PATH;
-      process.env.XRAY_DEV_PATH = 'custom-dist';
-
+    it('should use STRRAY_DEV_PATH env var in dynamic config', () => {
+      const originalEnv = process.env.STRRAY_DEV_PATH;
+      process.env.STRRAY_DEV_PATH = 'custom-dist';
+      
       const config = registry.createDynamicConfig('test-server');
       expect(config.args[0]).toContain('custom-dist');
-
-      process.env.XRAY_DEV_PATH = originalXrayEnv;
+      
+      process.env.STRRAY_DEV_PATH = originalEnv;
     });
   });
 
   describe('environment path handling', () => {
-    it('should use resolved framework path when XRAY_DEV_PATH is not set', () => {
-      const originalXrayEnv = process.env.XRAY_DEV_PATH;
-      delete process.env.XRAY_DEV_PATH;
-
+    it('should use resolved framework path when STRRAY_DEV_PATH is not set', () => {
+      const originalEnv = process.env.STRRAY_DEV_PATH;
+      delete process.env.STRRAY_DEV_PATH;
+      
       const freshRegistry = new ServerConfigRegistry();
       const config = freshRegistry.get('code-review');
       expect(config?.args[0]).toContain('.server.js');
-
-      process.env.XRAY_DEV_PATH = originalXrayEnv;
+      
+      process.env.STRRAY_DEV_PATH = originalEnv;
     });
 
-    it('should use XRAY_DEV_PATH when set', () => {
-      const originalXrayEnv = process.env.XRAY_DEV_PATH;
-      process.env.XRAY_DEV_PATH = 'dist';
-
+    it('should use STRRAY_DEV_PATH when set', () => {
+      const originalEnv = process.env.STRRAY_DEV_PATH;
+      process.env.STRRAY_DEV_PATH = 'dist';
+      
       const freshRegistry = new ServerConfigRegistry();
       const config = freshRegistry.get('code-review');
       expect(config?.args[0]).toContain('dist/');
-
-      process.env.XRAY_DEV_PATH = originalXrayEnv;
+      
+      process.env.STRRAY_DEV_PATH = originalEnv;
     });
   });
 

package/src/mcps/config/config-loader.ts

@@ -24,16 +24,11 @@ export interface ConfigLoadResult {
  * Loads MCP server configurations from files
  */
 export class ConfigLoader {
-  private defaultPaths: string[] = [
+  private configPaths: string[] = [
     '.mcp.json',
     '.opencode/mcp.json',
     'mcp.config.json',
   ];
-  private customPaths: string[] = [];
-
-  private get configPaths(): string[] {
-    return [...this.customPaths, ...this.defaultPaths];
-  }
 
   /**
    * Load configurations from available config files
@@ -66,10 +61,10 @@ export class ConfigLoader {
   }
 
   /**
-   * Add a custom config path to search before defaults
+   * Add a custom config path to search
    */
   addConfigPath(configPath: string): void {
-    this.customPaths.push(configPath);
+    this.configPaths.push(configPath);
   }
 
   /**
@@ -80,18 +75,14 @@ export class ConfigLoader {
   }
 
   /**
-   * Reset config paths to defaults, clearing custom paths
+   * Reset config paths to defaults
    */
   resetConfigPaths(): void {
-    this.customPaths = [];
-  }
-
-  /**
-   * Clear all config paths (both default and custom)
-   */
-  clearConfigPaths(): void {
-    this.customPaths = [];
-    this.defaultPaths = [];
+    this.configPaths = [
+      '.mcp.json',
+      '.opencode/mcp.json',
+      'mcp.config.json',
+    ];
   }
 
   /**

package/src/mcps/config/server-config-registry.ts

@@ -20,21 +20,21 @@ import fs from 'fs';
 /**
  * Resolve the correct framework root and MCP servers path.
  * Priority:
- *   1. XRAY_DEV_PATH env var (explicit dev override)
- *   2. The "xray" field in the nearest package.json that declares it (works in both source tree and installed package)
+ *   1. STRRAY_DEV_PATH env var (explicit dev override)
+ *   2. The "strray" field in the nearest package.json that declares it (works in both source tree and installed package)
  *   3. Safe fallback to node_modules/0xray/dist
  */
 function resolveFrameworkPaths(): { frameworkRoot: string; mcpServersPath: string } {
   // Highest priority: explicit environment override
-  if (process.env.XRAY_DEV_PATH) {
-    const devPath: string = process.env.XRAY_DEV_PATH || "";
+  if (process.env.STRRAY_DEV_PATH) {
+    const devPath = process.env.STRRAY_DEV_PATH;
     return {
       frameworkRoot: devPath,
       mcpServersPath: join(devPath, 'mcps'),
     };
   }
 
-  // Walk upward from this module to find the package that owns the "xray" config
+  // Walk upward from this module to find the package that owns the "strray" config
   let currentDir = dirname(fileURLToPath(import.meta.url));
 
   // Safety limit to avoid walking the entire filesystem
@@ -44,10 +44,10 @@ function resolveFrameworkPaths(): { frameworkRoot: string; mcpServersPath: strin
     if (fs.existsSync(pkgPath)) {
       try {
         const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
-        if (pkg.name === '0xray' && pkg.xray) {
-          const xrayCfg = pkg.xray as Record<string, string>;
+        if (pkg.name === '0xray' && pkg.strray) {
+          const strrayCfg = pkg.strray as Record<string, string>;
           const frameworkRoot = currentDir;
-          const declaredMcp = xrayCfg.mcpServersPath || (xrayCfg.dist ? join(xrayCfg.dist, 'mcps') : 'dist/mcps');
+          const declaredMcp = strrayCfg.mcpServersPath || (strrayCfg.dist ? join(strrayCfg.dist, 'mcps') : 'dist/mcps');
           return {
             frameworkRoot,
             mcpServersPath: join(frameworkRoot, declaredMcp),
@@ -65,7 +65,7 @@ function resolveFrameworkPaths(): { frameworkRoot: string; mcpServersPath: strin
   // Final fallback (should almost never be reached)
   const fallback = 'node_modules/0xray/dist';
   frameworkLogger.log('server-config-registry', 'using-fallback-path', 'warning', {
-    reason: 'Could not locate xray package.json with "xray" field',
+    reason: 'Could not locate strray package.json with "strray" field',
     fallback,
   });
   return {
@@ -180,7 +180,7 @@ export class ServerConfigRegistry {
     this.register({
       serverName: 'orchestrator',
       command: 'node',
-      args: [`${basePath}/orchestrator/server.js`],
+      args: [`${basePath}/orchestrator.server.js`],
       timeout: 60000,
     });
 
@@ -367,7 +367,7 @@ export class ServerConfigRegistry {
   /**
    * Create a dynamic configuration for an unknown server
    * Uses the knowledge-skills directory as default location.
-    * Now respects the "xray" field declared in package.json.
+   * Now respects the "strray" field declared in package.json.
    */
   createDynamicConfig(serverName: string): IServerConfig {
     // Validate serverName against path traversal attacks

package/src/mcps/connection/connection-manager.ts

@@ -0,0 +1,91 @@
+import { IMcpConnection, IServerConfig } from '../types/index.js';
+import { McpConnection } from './mcp-connection.js';
+import { frameworkLogger } from '../../core/framework-logger.js';
+
+/**
+ * Connection Manager
+ * Manages MCP connection lifecycle and provides centralized access to connections
+ */
+export class ConnectionManager {
+  private connections: Map<string, IMcpConnection> = new Map();
+
+  /**
+   * Get or create a connection for a server
+   * @param config - Server configuration
+   * @returns Promise resolving to an MCP connection
+   */
+  async getConnection(config: IServerConfig): Promise<IMcpConnection> {
+    const existingConnection = this.connections.get(config.serverName);
+    if (existingConnection && existingConnection.isConnected) {
+      return existingConnection;
+    }
+
+    // If existing connection is disconnected, remove it
+    if (existingConnection) {
+      await existingConnection.disconnect();
+      this.connections.delete(config.serverName);
+    }
+
+    // Create new connection
+    const connection = new McpConnection(config);
+    await connection.connect();
+    this.connections.set(config.serverName, connection);
+    return connection;
+  }
+
+  /**
+   * Disconnect a specific server
+   * @param serverName - Name of the server to disconnect
+   */
+  async disconnect(serverName: string): Promise<void> {
+    const connection = this.connections.get(serverName);
+    if (connection) {
+      await connection.disconnect();
+      this.connections.delete(serverName);
+    }
+  }
+
+  /**
+   * Disconnect all managed connections
+   */
+  async disconnectAll(): Promise<void> {
+    const disconnectPromises: Promise<void>[] = [];
+    for (const [serverName, connection] of this.connections) {
+      disconnectPromises.push(
+        connection.disconnect().catch((error) => {
+          frameworkLogger.log("connection-manager", "disconnect-error", "error", { serverName, error });
+        })
+      );
+    }
+    await Promise.all(disconnectPromises);
+    this.connections.clear();
+  }
+
+  /**
+   * Check if a connection exists for a server
+   * @param serverName - Name of the server
+   * @returns True if connection exists and is connected
+   */
+  hasConnection(serverName: string): boolean {
+    const connection = this.connections.get(serverName);
+    return connection !== undefined && connection.isConnected;
+  }
+
+  /**
+   * Get all connected server names
+   * @returns Array of server names
+   */
+  getConnectedServers(): string[] {
+    return Array.from(this.connections.entries())
+      .filter(([, connection]) => connection.isConnected)
+      .map(([name]) => name);
+  }
+
+  /**
+   * Get the number of active connections
+   * @returns Number of connections
+   */
+  getConnectionCount(): number {
+    return this.getConnectedServers().length;
+  }
+}

package/src/mcps/connection/mcp-connection.ts

@@ -77,7 +77,7 @@ export class McpConnection extends EventEmitter implements IMcpConnection {
           protocolVersion: MCP_PROTOCOL_VERSION,
           capabilities: {},
           clientInfo: {
-            name: 'xray-mcp-client',
+            name: 'strray-mcp-client',
             version: '1.7.5',
           },
         },