@loop_ouroboros/mcp-hub-lite 1.0.1 → 1.1.0

package/dist/server/src/models/system-tools.constants.js

@@ -4,24 +4,20 @@
  */
 // Individual system tool name constants
 export const LIST_SERVERS_TOOL = 'list_servers';
-export const FIND_SERVERS_TOOL = 'find_servers';
-export const LIST_ALL_TOOLS_IN_SERVER_TOOL = 'list_all_tools_in_server';
-export const FIND_TOOLS_IN_SERVER_TOOL = 'find_tools_in_server';
+export const LIST_TOOLS_IN_SERVER_TOOL = 'list_tools_in_server';
 export const GET_TOOL_TOOL = 'get_tool';
 export const CALL_TOOL_TOOL = 'call_tool';
-export const FIND_TOOLS_TOOL = 'find_tools';
+export const UPDATE_SERVER_DESCRIPTION_TOOL = 'update_server_description';
 /**
  * List of all system tool names
  * This array is used to identify system tools across the application
  */
 export const SYSTEM_TOOL_NAMES = [
     LIST_SERVERS_TOOL,
-    FIND_SERVERS_TOOL,
-    LIST_ALL_TOOLS_IN_SERVER_TOOL,
-    FIND_TOOLS_IN_SERVER_TOOL,
+    LIST_TOOLS_IN_SERVER_TOOL,
     GET_TOOL_TOOL,
     CALL_TOOL_TOOL,
-    FIND_TOOLS_TOOL
+    UPDATE_SERVER_DESCRIPTION_TOOL
 ];
 // Individual gateway server name constant
 /**

package/dist/server/src/pid/manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"manager.d.ts","sourceRoot":"","sources":["../../../../src/pid/manager.ts"],"names":[],"mappings":"AA2BA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD,qBAAa,UAAU;IACrB;;;;;;;;;;;;;;;;;;OAkBG;WACW,QAAQ,CAAC,OAAO,CAAC,EAAE,cAAc,GAAG,IAAI;IAmBtD;;;;;;;;;;;;;;;;OAgBG;WACW,SAAS,CAAC,OAAO,CAAC,EAAE,cAAc,GAAG,IAAI;IAIvD;;;;;;;;;;;;;;;OAeG;WACW,MAAM,CAAC,OAAO,CAAC,EAAE,cAAc,GAAG,MAAM,GAAG,IAAI;IAI7D;;;;;;;;;;;;;;;;OAgBG;WACW,SAAS,CAAC,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO;IAa1D;;;;;;;;;;;;;;;;;;;OAmBG;WACW,aAAa,CAAC,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO;CAG/D"}
+{"version":3,"file":"manager.d.ts","sourceRoot":"","sources":["../../../../src/pid/manager.ts"],"names":[],"mappings":"AA4BA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD,qBAAa,UAAU;IACrB;;;;;;;;;;;;;;;;;;OAkBG;WACW,QAAQ,CAAC,OAAO,CAAC,EAAE,cAAc,GAAG,IAAI;IAmBtD;;;;;;;;;;;;;;;;OAgBG;WACW,SAAS,CAAC,OAAO,CAAC,EAAE,cAAc,GAAG,IAAI;IAIvD;;;;;;;;;;;;;;;OAeG;WACW,MAAM,CAAC,OAAO,CAAC,EAAE,cAAc,GAAG,MAAM,GAAG,IAAI;IAI7D;;;;;;;;;;;;;;;;OAgBG;WACW,SAAS,CAAC,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO;IAa1D;;;;;;;;;;;;;;;;;;;OAmBG;WACW,aAAa,CAAC,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO;CAG/D"}

package/dist/server/src/pid/manager.js

@@ -24,6 +24,7 @@
  * PidManager.removePid();
  */
 import { logger } from '../utils/logger.js';
+import { LOG_MODULES } from '../utils/logger/log-modules.js';
 import { writePidFile, readPidFile, removePidFile, pidFileExists } from './file.js';
 export class PidManager {
     /**
@@ -60,7 +61,7 @@ export class PidManager {
             });
         }
         catch (error) {
-            logger.error('Failed to write PID file:', error);
+            logger.error('Failed to write PID file:', error, LOG_MODULES.PID_MANAGER);
         }
     }
     /**

package/dist/server/src/server/dev-server.js

@@ -1,5 +1,6 @@
 import { buildApp } from '../app.js';
 import { configManager } from '../config/config-manager.js';
+import { resolveInstanceConfig } from '../config/config-migrator.js';
 import { logger, LOG_MODULES } from '../utils/logger.js';
 import { mcpConnectionManager } from '../services/mcp-connection-manager.js';
 import { PidManager } from '../pid/manager.js';
@@ -70,31 +71,44 @@ async function startDevServer() {
         logger.info('Initializing server connections...', LOG_MODULES.DEV_SERVER);
         const serverConfigs = configManager.getServers();
         for (const { name: serverName, config: serverConfig } of serverConfigs) {
-            if (serverConfig.enabled) {
-                // Check if there are existing instances
-                const existingInstances = configManager.getServerInstanceByName(serverName);
-                if (existingInstances.length === 0) {
-                    // Auto-create instance for enabled servers
-                    try {
-                        const newInstance = await configManager.addServerInstance(serverName, {});
-                        // Connect the new instance
-                        mcpConnectionManager.connect({ ...serverConfig, ...newInstance }).catch((err) => {
+            // Check if there are existing instances
+            const existingInstances = configManager.getServerInstancesByName(serverName);
+            if (existingInstances.length === 0) {
+                // Auto-create instance for enabled servers
+                try {
+                    const newInstance = await configManager.addServerInstance(serverName, {});
+                    // Connect the new instance
+                    const resolvedConfig = resolveInstanceConfig(serverConfig, newInstance.id);
+                    if (resolvedConfig && resolvedConfig.enabled !== false) {
+                        mcpConnectionManager
+                            .connect(serverName, newInstance.index ?? 0, {
+                            ...resolvedConfig,
+                            id: newInstance.id
+                        })
+                            .catch((err) => {
                             logger.error(`Failed to auto-connect to ${serverName}:`, err, LOG_MODULES.DEV_SERVER);
                         });
                     }
-                    catch (err) {
-                        logger.error(`Failed to create instance for ${serverName}:`, err, LOG_MODULES.DEV_SERVER);
-                    }
                 }
-                else {
-                    // Connect existing instances
-                    existingInstances.forEach((instance) => {
-                        mcpConnectionManager.connect({ ...serverConfig, ...instance }).catch((err) => {
-                            logger.error(`Failed to auto-connect to ${serverName}:`, err, LOG_MODULES.DEV_SERVER);
-                        });
-                    });
+                catch (err) {
+                    logger.error(`Failed to create instance for ${serverName}:`, err, LOG_MODULES.DEV_SERVER);
                 }
             }
+            else {
+                // Connect existing instances
+                existingInstances.forEach((instance) => {
+                    if (instance.enabled !== false) {
+                        const resolvedConfig = resolveInstanceConfig(serverConfig, instance.id);
+                        if (resolvedConfig) {
+                            mcpConnectionManager
+                                .connect(serverName, instance.index ?? 0, { ...resolvedConfig, id: instance.id })
+                                .catch((err) => {
+                                logger.error(`Failed to auto-connect to ${serverName}:`, err, LOG_MODULES.DEV_SERVER);
+                            });
+                        }
+                    }
+                });
+            }
         }
         // Listen on configured port
         await app.listen({
@@ -165,7 +179,7 @@ process.on('uncaughtException', (err) => {
 });
 // Handle unhandled promise rejections
 process.on('unhandledRejection', (reason, promise) => {
-    logger.error('Unhandled Rejection at:', promise, 'reason:', reason, LOG_MODULES.DEV_SERVER);
+    logger.error('Unhandled Rejection:', { promise, reason }, LOG_MODULES.DEV_SERVER);
     process.exit(1);
 });
 startDevServer();

package/dist/server/src/server/runner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../../../src/server/runner.ts"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,wBAAsB,SAAS,CAAC,OAAO,GAAE;IAAE,KAAK,CAAC,EAAE,OAAO,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAO,iBA2G9F"}
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../../../src/server/runner.ts"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,wBAAsB,SAAS,CAAC,OAAO,GAAE;IAAE,KAAK,CAAC,EAAE,OAAO,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAO,iBAuI9F"}

package/dist/server/src/server/runner.js

@@ -1,6 +1,8 @@
 import { buildApp } from '../app.js';
 import { configManager } from '../config/config-manager.js';
-import { logger, LOG_MODULES } from '../utils/logger.js';
+import { resolveInstanceConfig } from '../config/config-migrator.js';
+import { logger } from '../utils/logger.js';
+import { LOG_MODULES } from '../utils/logger/log-modules.js';
 import { setJsonPrettyConfigGetter } from '../utils/json-utils.js';
 import { mcpConnectionManager } from '../services/mcp-connection-manager.js';
 import { gateway } from '../services/gateway.service.js';
@@ -77,18 +79,18 @@ export async function runServer(options = {}) {
             if (portCheck.inUse) {
                 if (portCheck.isSelfProject) {
                     // This project is already running
-                    logger.error(`MCP Hub Lite is already running on port ${port} (PID: ${portCheck.pid})`);
-                    logger.error(`Use 'npm run stop' or 'mcp-hub-lite stop' to stop the running instance.`);
+                    logger.error(`MCP Hub Lite is already running on port ${port} (PID: ${portCheck.pid})`, LOG_MODULES.SERVER);
+                    logger.error(`Use 'npm run stop' or 'mcp-hub-lite stop' to stop the running instance.`, LOG_MODULES.SERVER);
                     process.exit(1);
                 }
                 else {
                     // Port is occupied by another application
-                    logger.error(`Port ${port} is already in use by another application:`);
-                    logger.error(`  Process: ${portCheck.processName} (PID: ${portCheck.pid})`);
+                    logger.error(`Port ${port} is already in use by another application:`, LOG_MODULES.SERVER);
+                    logger.error(`  Process: ${portCheck.processName} (PID: ${portCheck.pid})`, LOG_MODULES.SERVER);
                     if (portCheck.commandLine) {
-                        logger.error(`  Command: ${portCheck.commandLine}`);
+                        logger.error(`  Command: ${portCheck.commandLine}`, LOG_MODULES.SERVER);
                     }
-                    logger.error(`Please stop the conflicting application or use a different port.`);
+                    logger.error(`Please stop the conflicting application or use a different port.`, LOG_MODULES.SERVER);
                     process.exit(1);
                 }
             }
@@ -97,31 +99,44 @@ export async function runServer(options = {}) {
         logger.info('Initializing server connections...', LOG_MODULES.SERVER);
         const serverConfigs = configManager.getServers();
         for (const { name: serverName, config: serverConfig } of serverConfigs) {
-            if (serverConfig.enabled) {
-                // Check if there are existing instances
-                const existingInstances = configManager.getServerInstanceByName(serverName);
-                if (existingInstances.length === 0) {
-                    // Auto-create instance for enabled servers
-                    try {
-                        const newInstance = await configManager.addServerInstance(serverName, {});
-                        // Connect the new instance
-                        mcpConnectionManager.connect({ ...serverConfig, ...newInstance }).catch((err) => {
+            // Check if there are existing instances
+            const existingInstances = configManager.getServerInstancesByName(serverName);
+            if (existingInstances.length === 0) {
+                // Auto-create instance for enabled servers
+                try {
+                    const newInstance = await configManager.addServerInstance(serverName, {});
+                    // Connect the new instance
+                    const resolvedConfig = resolveInstanceConfig(serverConfig, newInstance.id);
+                    if (resolvedConfig && resolvedConfig.enabled !== false) {
+                        mcpConnectionManager
+                            .connect(serverName, newInstance.index ?? 0, {
+                            ...resolvedConfig,
+                            id: newInstance.id
+                        })
+                            .catch((err) => {
                             logger.error(`Failed to auto-connect to ${serverName}:`, err, LOG_MODULES.SERVER);
                         });
                     }
-                    catch (err) {
-                        logger.error(`Failed to create instance for ${serverName}:`, err, LOG_MODULES.SERVER);
-                    }
                 }
-                else {
-                    // Connect existing instances
-                    existingInstances.forEach((instance) => {
-                        mcpConnectionManager.connect({ ...serverConfig, ...instance }).catch((err) => {
-                            logger.error(`Failed to auto-connect to ${serverName}:`, err, LOG_MODULES.SERVER);
-                        });
-                    });
+                catch (err) {
+                    logger.error(`Failed to create instance for ${serverName}:`, err, LOG_MODULES.SERVER);
                 }
             }
+            else {
+                // Connect existing instances
+                existingInstances.forEach((instance) => {
+                    if (instance.enabled !== false) {
+                        const resolvedConfig = resolveInstanceConfig(serverConfig, instance.id);
+                        if (resolvedConfig) {
+                            mcpConnectionManager
+                                .connect(serverName, instance.index ?? 0, { ...resolvedConfig, id: instance.id })
+                                .catch((err) => {
+                                logger.error(`Failed to auto-connect to ${serverName}:`, err, LOG_MODULES.SERVER);
+                            });
+                        }
+                    }
+                });
+            }
         }
         // Setup signal handlers for graceful shutdown
         const shutdown = async (signal) => {

package/dist/server/src/services/client-tracker.service.d.ts

@@ -1,132 +1,7 @@
-import type { ClientContext, ClientInfo, ClientRoot } from '../../shared/types/client.types.js';
 /**
- * Client tracking service that manages client connections and their metadata.
+ * @deprecated This file is deprecated. Please import from './session-tracker.service.js' instead.
  *
- * This service maintains a registry of connected clients (typically IDEs or other
- * MCP clients) and tracks their connection state, metadata, and workspace roots.
- * It provides automatic cleanup of stale clients after a timeout period and
- * publishes connection/disconnection events via the event bus.
- *
- * The service is primarily used by the MCP session manager to track which clients
- * are connected and maintain their context information for proper session management.
- *
- * @example
- * // Update client information when a new connection is established
- * clientTrackerService.updateClient({
- *   sessionId: 'session-123',
- *   clientName: 'VS Code',
- *   clientVersion: '1.85.0',
- *   cwd: '/home/user/project'
- * });
- *
- * // Get all currently connected clients
- * const clients = clientTrackerService.getClients();
+ * Client Tracker Service (Deprecated - maintained for backward compatibility)
  */
-declare class ClientTrackerService {
-    private clients;
-    private get TIMEOUT_MS();
-    /**
-     * Creates a new client tracker service instance.
-     *
-     * Initializes the service with automatic periodic cleanup of stale clients
-     * every 60 seconds to prevent memory leaks from disconnected clients.
-     */
-    constructor();
-    /**
-     * Updates or creates a client entry with the provided context information.
-     *
-     * This method is called whenever a client sends a request with context information.
-     * It preserves existing client metadata that isn't provided in the new context,
-     * ensuring that clients don't lose their previously established information.
-     *
-     * If this is a new client (not previously tracked), it publishes a 'client-connected'
-     * event to notify other services about the new connection.
-     *
-     * @param context - The client context containing session ID and optional metadata
-     * @param context.sessionId - Unique identifier for the client session
-     * @param context.clientName - Optional name of the client application
-     * @param context.clientVersion - Optional version of the client application
-     * @param context.protocolVersion - Optional MCP protocol version
-     * @param context.project - Optional project identifier
-     * @param context.cwd - Optional current working directory
-     * @param context.userAgent - Optional user agent string
-     * @param context.ip - Optional client IP address
-     *
-     * @example
-     * clientTrackerService.updateClient({
-     *   sessionId: 'session-123',
-     *   clientName: 'VS Code',
-     *   clientVersion: '1.85.0',
-     *   cwd: '/home/user/project'
-     * });
-     */
-    updateClient(context: ClientContext): void;
-    /**
-     * Updates the workspace roots for a specific client session.
-     *
-     * This method is typically called when a client provides its workspace root
-     * directories, which helps determine the client's working directory context.
-     * If the client doesn't have a current working directory (cwd) set, it will
-     * attempt to infer one from the first root URI in the list.
-     *
-     * For file:// URIs, it converts them to local file paths using Node.js's
-     * fileURLToPath utility. For other URI schemes, it uses the URI directly.
-     *
-     * @param sessionId - The unique session identifier for the client
-     * @param roots - Array of client root objects containing URI information
-     *
-     * @example
-     * clientTrackerService.updateClientRoots('session-123', [
-     *   { uri: 'file:///home/user/project' },
-     *   { uri: 'file:///home/user/other-project' }
-     * ]);
-     */
-    updateClientRoots(sessionId: string, roots: ClientRoot[]): void;
-    /**
-     * Retrieves all currently tracked client information.
-     *
-     * Returns an array of all active client info objects, including their metadata
-     * and connection state. This is useful for monitoring all connected clients
-     * or displaying client information in administrative interfaces.
-     *
-     * @returns Array of ClientInfo objects representing all tracked clients
-     *
-     * @example
-     * const allClients = clientTrackerService.getClients();
-     * console.log(`Currently tracking ${allClients.length} clients`);
-     */
-    getClients(): ClientInfo[];
-    /**
-     * Retrieves client information for a specific session ID.
-     *
-     * Returns the complete client info object for the given session ID, or undefined
-     * if no client with that session ID is currently being tracked.
-     *
-     * @param sessionId - The unique session identifier to look up
-     * @returns ClientInfo object if found, undefined otherwise
-     *
-     * @example
-     * const client = clientTrackerService.getClient('session-123');
-     * if (client) {
-     *   console.log(`Client ${client.clientName} is connected`);
-     * }
-     */
-    getClient(sessionId: string): ClientInfo | undefined;
-    /**
-     * Cleans up stale client entries that haven't been seen recently.
-     *
-     * This private method is called periodically to remove clients that haven't
-     * sent any requests within the timeout period (5 minutes by default). When
-     * a client is removed, it publishes a 'client-disconnected' event to notify
-     * other services about the disconnection.
-     *
-     * This prevents memory leaks from accumulating disconnected clients and ensures
-     * that the client registry only contains active connections.
-     *
-     * @private
-     */
-    private cleanup;
-}
-export declare const clientTrackerService: ClientTrackerService;
-export {};
+export { sessionTrackerService, sessionTrackerService as clientTrackerService, type SessionTrackerService } from './session-tracker.service.js';
 //# sourceMappingURL=client-tracker.service.d.ts.map

package/dist/server/src/services/client-tracker.service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client-tracker.service.d.ts","sourceRoot":"","sources":["../../../../src/services/client-tracker.service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAO3F;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,cAAM,oBAAoB;IACxB,OAAO,CAAC,OAAO,CAAsC;IAErD,OAAO,KAAK,UAAU,GAErB;IAED;;;;;OAKG;;IAMH;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACI,YAAY,CAAC,OAAO,EAAE,aAAa;IA2B1C;;;;;;;;;;;;;;;;;;;OAmBG;IACI,iBAAiB,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE;IAwB/D;;;;;;;;;;;;OAYG;IACI,UAAU,IAAI,UAAU,EAAE;IAIjC;;;;;;;;;;;;;;OAcG;IACI,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS;IAI3D;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,OAAO;CAiBhB;AAED,eAAO,MAAM,oBAAoB,sBAA6B,CAAC"}
+{"version":3,"file":"client-tracker.service.d.ts","sourceRoot":"","sources":["../../../../src/services/client-tracker.service.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EACL,qBAAqB,EACrB,qBAAqB,IAAI,oBAAoB,EAC7C,KAAK,qBAAqB,EAC3B,MAAM,8BAA8B,CAAC"}

package/dist/server/src/services/client-tracker.service.js

@@ -1,203 +1,7 @@
-import { logger } from '../utils/logger.js';
-import { eventBus } from './event-bus.service.js';
-import { fileURLToPath } from 'node:url';
-import { configManager } from '../config/config-manager.js';
-import { formatDuration } from '../utils/format-utils.js';
 /**
- * Client tracking service that manages client connections and their metadata.
+ * @deprecated This file is deprecated. Please import from './session-tracker.service.js' instead.
  *
- * This service maintains a registry of connected clients (typically IDEs or other
- * MCP clients) and tracks their connection state, metadata, and workspace roots.
- * It provides automatic cleanup of stale clients after a timeout period and
- * publishes connection/disconnection events via the event bus.
- *
- * The service is primarily used by the MCP session manager to track which clients
- * are connected and maintain their context information for proper session management.
- *
- * @example
- * // Update client information when a new connection is established
- * clientTrackerService.updateClient({
- *   sessionId: 'session-123',
- *   clientName: 'VS Code',
- *   clientVersion: '1.85.0',
- *   cwd: '/home/user/project'
- * });
- *
- * // Get all currently connected clients
- * const clients = clientTrackerService.getClients();
+ * Client Tracker Service (Deprecated - maintained for backward compatibility)
  */
-class ClientTrackerService {
-    clients = new Map();
-    // Use the same timeout as session manager (default 30 minutes)
-    get TIMEOUT_MS() {
-        return configManager.getConfig().security.sessionTimeout;
-    }
-    /**
-     * Creates a new client tracker service instance.
-     *
-     * Initializes the service with automatic periodic cleanup of stale clients
-     * every 60 seconds to prevent memory leaks from disconnected clients.
-     */
-    constructor() {
-        // Periodic cleanup
-        setInterval(() => this.cleanup(), 60000);
-    }
-    /**
-     * Updates or creates a client entry with the provided context information.
-     *
-     * This method is called whenever a client sends a request with context information.
-     * It preserves existing client metadata that isn't provided in the new context,
-     * ensuring that clients don't lose their previously established information.
-     *
-     * If this is a new client (not previously tracked), it publishes a 'client-connected'
-     * event to notify other services about the new connection.
-     *
-     * @param context - The client context containing session ID and optional metadata
-     * @param context.sessionId - Unique identifier for the client session
-     * @param context.clientName - Optional name of the client application
-     * @param context.clientVersion - Optional version of the client application
-     * @param context.protocolVersion - Optional MCP protocol version
-     * @param context.project - Optional project identifier
-     * @param context.cwd - Optional current working directory
-     * @param context.userAgent - Optional user agent string
-     * @param context.ip - Optional client IP address
-     *
-     * @example
-     * clientTrackerService.updateClient({
-     *   sessionId: 'session-123',
-     *   clientName: 'VS Code',
-     *   clientVersion: '1.85.0',
-     *   cwd: '/home/user/project'
-     * });
-     */
-    updateClient(context) {
-        const existing = this.clients.get(context.sessionId);
-        const clientInfo = {
-            ...context,
-            // Preserve existing info if not provided in new request
-            clientName: context.clientName || existing?.clientName,
-            clientVersion: context.clientVersion || existing?.clientVersion,
-            protocolVersion: context.protocolVersion || existing?.protocolVersion,
-            project: context.project || existing?.project,
-            cwd: context.cwd || existing?.cwd, // Preserve CWD if not provided in new request (e.g. inferred from roots)
-            userAgent: context.userAgent || existing?.userAgent,
-            ip: context.ip || existing?.ip,
-            lastSeen: Date.now(),
-            roots: existing?.roots // Preserve roots if already fetched
-        };
-        this.clients.set(context.sessionId, clientInfo);
-        // If it's a new client, publish connection event
-        if (!existing) {
-            eventBus.publish('client-connected', {
-                timestamp: Date.now(),
-                client: clientInfo
-            });
-        }
-    }
-    /**
-     * Updates the workspace roots for a specific client session.
-     *
-     * This method is typically called when a client provides its workspace root
-     * directories, which helps determine the client's working directory context.
-     * If the client doesn't have a current working directory (cwd) set, it will
-     * attempt to infer one from the first root URI in the list.
-     *
-     * For file:// URIs, it converts them to local file paths using Node.js's
-     * fileURLToPath utility. For other URI schemes, it uses the URI directly.
-     *
-     * @param sessionId - The unique session identifier for the client
-     * @param roots - Array of client root objects containing URI information
-     *
-     * @example
-     * clientTrackerService.updateClientRoots('session-123', [
-     *   { uri: 'file:///home/user/project' },
-     *   { uri: 'file:///home/user/other-project' }
-     * ]);
-     */
-    updateClientRoots(sessionId, roots) {
-        const client = this.clients.get(sessionId);
-        if (client) {
-            client.roots = roots;
-            client.lastSeen = Date.now();
-            // If CWD is missing, try to infer from roots
-            if (!client.cwd && roots.length > 0) {
-                // Convert file:// uri to path if possible, or just use URI
-                const root = roots[0];
-                if (root.uri.startsWith('file://')) {
-                    try {
-                        client.cwd = fileURLToPath(root.uri);
-                    }
-                    catch {
-                        client.cwd = root.uri;
-                    }
-                }
-                else {
-                    client.cwd = root.uri;
-                }
-                logger.debug(`Inferred CWD for session ${sessionId} from roots: ${client.cwd}`);
-            }
-        }
-    }
-    /**
-     * Retrieves all currently tracked client information.
-     *
-     * Returns an array of all active client info objects, including their metadata
-     * and connection state. This is useful for monitoring all connected clients
-     * or displaying client information in administrative interfaces.
-     *
-     * @returns Array of ClientInfo objects representing all tracked clients
-     *
-     * @example
-     * const allClients = clientTrackerService.getClients();
-     * console.log(`Currently tracking ${allClients.length} clients`);
-     */
-    getClients() {
-        return Array.from(this.clients.values());
-    }
-    /**
-     * Retrieves client information for a specific session ID.
-     *
-     * Returns the complete client info object for the given session ID, or undefined
-     * if no client with that session ID is currently being tracked.
-     *
-     * @param sessionId - The unique session identifier to look up
-     * @returns ClientInfo object if found, undefined otherwise
-     *
-     * @example
-     * const client = clientTrackerService.getClient('session-123');
-     * if (client) {
-     *   console.log(`Client ${client.clientName} is connected`);
-     * }
-     */
-    getClient(sessionId) {
-        return this.clients.get(sessionId);
-    }
-    /**
-     * Cleans up stale client entries that haven't been seen recently.
-     *
-     * This private method is called periodically to remove clients that haven't
-     * sent any requests within the timeout period (5 minutes by default). When
-     * a client is removed, it publishes a 'client-disconnected' event to notify
-     * other services about the disconnection.
-     *
-     * This prevents memory leaks from accumulating disconnected clients and ensures
-     * that the client registry only contains active connections.
-     *
-     * @private
-     */
-    cleanup() {
-        const now = Date.now();
-        for (const [id, info] of this.clients.entries()) {
-            if (now - info.lastSeen > this.TIMEOUT_MS) {
-                logger.debug(`Removing stale client: ${id}. Last seen ${formatDuration(now - info.lastSeen)} ago, timeout ${formatDuration(this.TIMEOUT_MS)}`);
-                this.clients.delete(id);
-                eventBus.publish('client-disconnected', {
-                    timestamp: Date.now(),
-                    clientId: id,
-                    client: info
-                });
-            }
-        }
-    }
-}
-export const clientTrackerService = new ClientTrackerService();
+// Re-export from new service with backward-compatible aliases
+export { sessionTrackerService, sessionTrackerService as clientTrackerService } from './session-tracker.service.js';