agent-planner-mcp 0.3.1 → 0.5.1

package/src/session-manager.js

@@ -0,0 +1,223 @@
+/**
+ * Session Manager for MCP HTTP Server
+ *
+ * Manages client sessions for the Streamable HTTP transport.
+ * Each session tracks:
+ * - Unique session ID (Mcp-Session-Id header)
+ * - Initialization state
+ * - Client capabilities
+ * - Creation and last activity timestamps
+ */
+
+const { randomUUID } = require('crypto');
+
+class SessionManager {
+  constructor(options = {}) {
+    // In-memory session storage
+    this.sessions = new Map();
+
+    // Configuration
+    this.sessionTimeout = options.sessionTimeout || 30 * 60 * 1000; // 30 minutes default
+    this.cleanupInterval = options.cleanupInterval || 5 * 60 * 1000; // 5 minutes default
+
+    // Start periodic cleanup
+    this.startCleanup();
+
+    console.error('SessionManager initialized');
+  }
+
+  /**
+   * Create a new session
+   * @returns {string} Session ID
+   */
+  createSession() {
+    const sessionId = randomUUID();
+
+    const session = {
+      id: sessionId,
+      initialized: false,
+      clientCapabilities: null,
+      createdAt: Date.now(),
+      lastActivityAt: Date.now()
+    };
+
+    this.sessions.set(sessionId, session);
+
+    console.error(`Session created: ${sessionId}`);
+    return sessionId;
+  }
+
+  /**
+   * Get a session by ID
+   * @param {string} sessionId - Session ID
+   * @returns {Object|null} Session object or null if not found
+   */
+  getSession(sessionId) {
+    if (!sessionId) {
+      return null;
+    }
+
+    const session = this.sessions.get(sessionId);
+
+    if (!session) {
+      return null;
+    }
+
+    // Update last activity
+    session.lastActivityAt = Date.now();
+
+    return session;
+  }
+
+  /**
+   * Mark a session as initialized
+   * @param {string} sessionId - Session ID
+   * @param {Object} clientCapabilities - Client capabilities from initialize request
+   */
+  initializeSession(sessionId, clientCapabilities) {
+    const session = this.sessions.get(sessionId);
+
+    if (!session) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+
+    session.initialized = true;
+    session.clientCapabilities = clientCapabilities;
+    session.lastActivityAt = Date.now();
+
+    console.error(`Session initialized: ${sessionId}`);
+  }
+
+  /**
+   * Store a per-session API client
+   * @param {string} sessionId - Session ID
+   * @param {Object} apiClient - API client instance bound to user's token
+   */
+  setApiClient(sessionId, apiClient) {
+    const session = this.sessions.get(sessionId);
+    if (session) {
+      session.apiClient = apiClient;
+    }
+  }
+
+  /**
+   * Get the per-session API client
+   * @param {string} sessionId - Session ID
+   * @returns {Object|null} API client or null
+   */
+  getApiClient(sessionId) {
+    const session = this.sessions.get(sessionId);
+    return session?.apiClient || null;
+  }
+
+  /**
+   * Check if a session is initialized
+   * @param {string} sessionId - Session ID
+   * @returns {boolean} True if initialized
+   */
+  isInitialized(sessionId) {
+    const session = this.sessions.get(sessionId);
+    return session && session.initialized;
+  }
+
+  /**
+   * Delete a session
+   * @param {string} sessionId - Session ID
+   * @returns {boolean} True if session was deleted
+   */
+  deleteSession(sessionId) {
+    const deleted = this.sessions.delete(sessionId);
+
+    if (deleted) {
+      console.error(`Session deleted: ${sessionId}`);
+    }
+
+    return deleted;
+  }
+
+  /**
+   * Clean up expired sessions
+   */
+  cleanupExpiredSessions() {
+    const now = Date.now();
+    let cleanedCount = 0;
+
+    for (const [sessionId, session] of this.sessions.entries()) {
+      const age = now - session.lastActivityAt;
+
+      if (age > this.sessionTimeout) {
+        this.sessions.delete(sessionId);
+        cleanedCount++;
+        console.error(`Session expired: ${sessionId} (inactive for ${Math.round(age / 1000)}s)`);
+      }
+    }
+
+    if (cleanedCount > 0) {
+      console.error(`Cleaned up ${cleanedCount} expired sessions`);
+    }
+  }
+
+  /**
+   * Start periodic cleanup of expired sessions
+   */
+  startCleanup() {
+    this.cleanupTimer = setInterval(() => {
+      this.cleanupExpiredSessions();
+    }, this.cleanupInterval);
+
+    // Prevent the timer from keeping the process alive
+    this.cleanupTimer.unref();
+  }
+
+  /**
+   * Stop periodic cleanup
+   */
+  stopCleanup() {
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = null;
+    }
+  }
+
+  /**
+   * Get session statistics
+   * @returns {Object} Statistics object
+   */
+  getStats() {
+    const now = Date.now();
+    const stats = {
+      total: this.sessions.size,
+      initialized: 0,
+      uninitialized: 0,
+      sessions: []
+    };
+
+    for (const [sessionId, session] of this.sessions.entries()) {
+      if (session.initialized) {
+        stats.initialized++;
+      } else {
+        stats.uninitialized++;
+      }
+
+      stats.sessions.push({
+        id: sessionId,
+        initialized: session.initialized,
+        age: Math.round((now - session.createdAt) / 1000),
+        idleTime: Math.round((now - session.lastActivityAt) / 1000)
+      });
+    }
+
+    return stats;
+  }
+
+  /**
+   * Destroy the session manager
+   */
+  destroy() {
+    this.stopCleanup();
+    this.sessions.clear();
+    console.error('SessionManager destroyed');
+  }
+}
+
+module.exports = { SessionManager };

package/src/setup.js

@@ -124,7 +124,7 @@ function createEnvFile(config) {
 API_URL=${config.apiUrl}
 USER_API_TOKEN=${config.token}
 MCP_SERVER_NAME=planning-system
-MCP_SERVER_VERSION=0.2.0
+MCP_SERVER_VERSION=${require('../package.json').version}
 NODE_ENV=production
 `;
 

package/src/tools/search-wrapper.js

@@ -136,7 +136,7 @@ async function globalSearch(query) {
     }
     
     // Check if response has categorized results (plans, nodes, etc.)
-    const categories = ['plans', 'nodes', 'comments', 'logs', 'artifacts'];
+    const categories = ['plans', 'nodes', 'comments', 'logs'];
     const allResults = [];
     
     categories.forEach(category => {
@@ -156,9 +156,11 @@ async function globalSearch(query) {
       return allResults;
     }
     
-    // Generic handler for any object with arrays
-    Object.keys(response).forEach(key => {
-      if (Array.isArray(response[key]) && key !== 'results') {
+    // Generic handler for any object with arrays - log warning about unexpected format
+    const unknownKeys = Object.keys(response).filter(key => Array.isArray(response[key]) && key !== 'results');
+    if (unknownKeys.length > 0) {
+      console.error(`[search-wrapper] Warning: Unexpected response format with keys: ${unknownKeys.join(', ')}. Normalizing results.`);
+      unknownKeys.forEach(key => {
         response[key].forEach(item => {
           allResults.push({
             ...item,
@@ -167,8 +169,12 @@ async function globalSearch(query) {
             source: 'global_search'
           });
         });
-      }
-    });
+      });
+    }
+    
+    if (allResults.length === 0 && Object.keys(response).length > 0) {
+      console.error(`[search-wrapper] Warning: Could not extract results from response. Keys: ${Object.keys(response).join(', ')}`);
+    }
     
     return allResults;
   } catch (error) {