agent-planner-mcp 0.5.0 → 0.6.0

package/src/api-client.js

@@ -208,6 +208,21 @@ const nodes = {
    */
   deleteNode: async (planId, nodeId) => {
     await apiClient.delete(`/plans/${planId}/nodes/${nodeId}`);
+  },
+
+  claimTask: async (planId, nodeId, agentId = 'mcp-agent', ttlMinutes = 30) => {
+    const response = await apiClient.post(`/plans/${planId}/nodes/${nodeId}/claim`, { agent_id: agentId, ttl_minutes: ttlMinutes });
+    return response.data;
+  },
+
+  releaseTask: async (planId, nodeId, agentId = 'mcp-agent') => {
+    const response = await apiClient.delete(`/plans/${planId}/nodes/${nodeId}/claim`, { data: { agent_id: agentId } });
+    return response.data;
+  },
+
+  getTaskClaim: async (planId, nodeId) => {
+    const response = await apiClient.get(`/plans/${planId}/nodes/${nodeId}/claim`);
+    return response.data;
   }
 };
 
@@ -555,89 +570,47 @@ const goals = {
   unlinkPlan: async (goalId, planId) => {
     const response = await apiClient.delete(`/goals/${goalId}/plans/${planId}`);
     return response.data;
-  }
-};
+  },
 
-/**
- * Knowledge Store API functions
- */
-const knowledge = {
-  /**
-   * List knowledge entries with optional filters
-   * GET /knowledge
-   */
-  listEntries: async (storeIdOrFilters, filters = {}) => {
-    const params = new URLSearchParams();
-    // Support both (storeId, filters) and (filters) calling patterns
-    if (typeof storeIdOrFilters === 'string') {
-      params.append('scopeId', storeIdOrFilters);
-      if (filters.entry_type) params.append('entryType', filters.entry_type);
-      if (filters.tags) params.append('tags', filters.tags);
-      if (filters.limit) params.append('limit', filters.limit);
-      if (filters.offset) params.append('offset', filters.offset);
-    } else if (typeof storeIdOrFilters === 'object') {
-      const f = storeIdOrFilters;
-      if (f.scope) params.append('scope', f.scope);
-      if (f.scope_id) params.append('scopeId', f.scope_id);
-      if (f.entry_type) params.append('entryType', f.entry_type);
-      if (f.limit) params.append('limit', f.limit);
-      if (f.offset) params.append('offset', f.offset);
-    }
-    const response = await apiClient.get(`/knowledge?${params.toString()}`);
+  // v2 goal-dependency endpoints
+  getPath: async (goalId, maxDepth) => {
+    const params = maxDepth ? `?max_depth=${maxDepth}` : '';
+    const response = await apiClient.get(`/goals/v2/${goalId}/path${params}`);
     return response.data;
   },
 
-  /**
-   * Alias for listEntries — used by get_context and understand_context tools
-   */
-  getEntries: async (filters = {}) => {
-    return knowledge.listEntries(filters);
+  getProgress: async (goalId) => {
+    const response = await apiClient.get(`/goals/v2/${goalId}/progress`);
+    return response.data;
   },
 
-  /**
-   * Get a single knowledge entry
-   * GET /knowledge/:id
-   */
-  getEntry: async (entryId) => {
-    const response = await apiClient.get(`/knowledge/${entryId}`);
+  listAchievers: async (goalId) => {
+    const response = await apiClient.get(`/goals/v2/${goalId}/achievers`);
     return response.data;
   },
 
-  /**
-   * Create a knowledge entry
-   * POST /knowledge
-   */
-  createEntry: async (data) => {
-    const response = await apiClient.post('/knowledge', data);
+  addAchiever: async (goalId, sourceNodeId, weight) => {
+    const response = await apiClient.post(`/goals/v2/${goalId}/achievers`, {
+      source_node_id: sourceNodeId,
+      weight: weight ?? 1,
+    });
     return response.data;
   },
 
-  /**
-   * Update a knowledge entry
-   * PUT /knowledge/:id
-   */
-  updateEntry: async (entryId, data) => {
-    const response = await apiClient.put(`/knowledge/${entryId}`, data);
+  removeAchiever: async (goalId, depId) => {
+    const response = await apiClient.delete(`/goals/v2/${goalId}/achievers/${depId}`);
     return response.data;
   },
 
-  /**
-   * Delete a knowledge entry
-   * DELETE /knowledge/:id
-   */
-  deleteEntry: async (entryId) => {
-    const response = await apiClient.delete(`/knowledge/${entryId}`);
+  getKnowledgeGaps: async (goalId) => {
+    const response = await apiClient.get(`/goals/v2/${goalId}/knowledge-gaps`);
     return response.data;
   },
 
-  /**
-   * Semantic search across knowledge entries
-   * POST /knowledge/search
-   */
-  search: async (data) => {
-    const response = await apiClient.post('/knowledge/search', data);
+  getDashboard: async () => {
+    const response = await apiClient.get('/goals/v2/dashboard');
     return response.data;
-  }
+  },
 };
 
 /**
@@ -679,6 +652,263 @@ const context = {
   }
 };
 
+/**
+ * Graphiti Knowledge Graph API functions (proxied through AgentPlanner API)
+ */
+const graphiti = {
+  /**
+   * Get Graphiti status
+   * GET /knowledge/graphiti/status
+   */
+  getStatus: async () => {
+    const response = await apiClient.get('/knowledge/graphiti/status');
+    return response.data;
+  },
+
+  /**
+   * Add a knowledge episode to Graphiti
+   * POST /knowledge/episodes
+   */
+  addEpisode: async (data) => {
+    const response = await apiClient.post('/knowledge/episodes', data);
+    return response.data;
+  },
+
+  /**
+   * Search knowledge in Graphiti temporal graph
+   * POST /knowledge/graph-search
+   */
+  graphSearch: async (data) => {
+    const response = await apiClient.post('/knowledge/graph-search', data);
+    return response.data;
+  },
+
+  /**
+   * Search entities in Graphiti
+   * POST /knowledge/entities
+   */
+  searchEntities: async (data) => {
+    const response = await apiClient.post('/knowledge/entities', data);
+    return response.data;
+  },
+
+  /**
+   * Detect contradictions in knowledge
+   * POST /knowledge/contradictions
+   */
+  detectContradictions: async (data) => {
+    const response = await apiClient.post('/knowledge/contradictions', data);
+    return response.data;
+  },
+
+  /**
+   * Get recent episodes from Graphiti
+   * GET /knowledge/episodes
+   */
+  getEpisodes: async ({ max_episodes = 20 } = {}) => {
+    const response = await apiClient.get('/knowledge/episodes', { params: { max_episodes } });
+    return response.data;
+  },
+
+  /**
+   * Delete an episode from Graphiti
+   * DELETE /knowledge/episodes/:episodeId
+   */
+  deleteEpisode: async (episodeId) => {
+    const response = await apiClient.delete(`/knowledge/episodes/${episodeId}`);
+    return response.data;
+  }
+};
+
+// ─── Dependencies (cross-plan & external) ─────────────────────
+const dependencies = {
+  /**
+   * Create a cross-plan dependency edge
+   * POST /dependencies/cross-plan
+   */
+  createCrossPlan: async (data) => {
+    const response = await apiClient.post('/dependencies/cross-plan', data);
+    return response.data;
+  },
+
+  /**
+   * List cross-plan dependency edges between plans
+   * GET /dependencies/cross-plan?plan_ids=id1,id2
+   */
+  listCrossPlan: async (planIds) => {
+    const response = await apiClient.get('/dependencies/cross-plan', {
+      params: { plan_ids: planIds.join(',') },
+    });
+    return response.data;
+  },
+
+  /**
+   * Create an external dependency node (and optionally a blocking edge)
+   * POST /dependencies/external
+   */
+  createExternal: async (data) => {
+    const response = await apiClient.post('/dependencies/external', data);
+    return response.data;
+  },
+};
+
+/**
+ * Create an API client bound to a specific token.
+ * Used by the HTTP MCP server to create per-session clients.
+ * @param {string} token - API token or JWT
+ * @returns {Object} - API client modules (plans, nodes, etc.)
+ */
+function createApiClient(token) {
+  const scheme = getAuthScheme(token);
+  const client = axios.create({
+    baseURL: process.env.API_URL || 'http://localhost:3000',
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': token ? `${scheme} ${token}` : undefined
+    }
+  });
+
+  // Reuse the same interceptors
+  if (process.env.NODE_ENV === 'development') {
+    client.interceptors.request.use(request => {
+      console.error(`API Request: ${request.method.toUpperCase()} ${request.url}`);
+      return request;
+    });
+  }
+  client.interceptors.response.use(
+    response => response,
+    error => {
+      if (error.response && error.response.status === 401) {
+        console.error('API Error: Authentication failed (401).');
+      }
+      return Promise.reject(error);
+    }
+  );
+
+  // Build the same module structure using the per-session client
+  return {
+    plans: {
+      getPlans: async () => (await client.get('/plans')).data,
+      getPlan: async (planId) => (await client.get(`/plans/${planId}`)).data,
+      createPlan: async (planData) => (await client.post('/plans', planData)).data,
+      updatePlan: async (planId, planData) => (await client.put(`/plans/${planId}`, planData)).data,
+      deletePlan: async (planId) => await client.delete(`/plans/${planId}`),
+      updateVisibility: async (planId, data) => (await client.put(`/plans/${planId}/visibility`, data)).data,
+      getPublicPlan: async (planId) => (await client.get(`/plans/${planId}/public`)).data,
+    },
+    nodes: {
+      getNodes: async (planId, options = {}) => {
+        const params = new URLSearchParams();
+        if (options.include_details) params.append('include_details', 'true');
+        const qs = params.toString() ? `?${params.toString()}` : '';
+        return (await client.get(`/plans/${planId}/nodes${qs}`)).data;
+      },
+      getNode: async (planId, nodeId) => (await client.get(`/plans/${planId}/nodes/${nodeId}`)).data,
+      createNode: async (planId, nodeData) => (await client.post(`/plans/${planId}/nodes`, nodeData)).data,
+      updateNode: async (planId, nodeId, nodeData) => (await client.put(`/plans/${planId}/nodes/${nodeId}`, nodeData)).data,
+      updateNodeStatus: async (planId, nodeId, status) => (await client.put(`/plans/${planId}/nodes/${nodeId}/status`, { status })).data,
+      deleteNode: async (planId, nodeId) => await client.delete(`/plans/${planId}/nodes/${nodeId}`),
+      claimTask: async (planId, nodeId, agentId = 'mcp-agent', ttlMinutes = 30) => (await client.post(`/plans/${planId}/nodes/${nodeId}/claim`, { agent_id: agentId, ttl_minutes: ttlMinutes })).data,
+      releaseTask: async (planId, nodeId, agentId = 'mcp-agent') => (await client.delete(`/plans/${planId}/nodes/${nodeId}/claim`, { data: { agent_id: agentId } })).data,
+      getTaskClaim: async (planId, nodeId) => (await client.get(`/plans/${planId}/nodes/${nodeId}/claim`)).data,
+    },
+    comments: {
+      getComments: async (planId, nodeId) => (await client.get(`/plans/${planId}/nodes/${nodeId}/comments`)).data,
+      addComment: async (planId, nodeId, data) => (await client.post(`/plans/${planId}/nodes/${nodeId}/comments`, data)).data,
+    },
+    logs: {
+      getLogs: async (planId, nodeId) => (await client.get(`/plans/${planId}/nodes/${nodeId}/logs`)).data,
+      addLogEntry: async (planId, nodeId, data) => (await client.post(`/plans/${planId}/nodes/${nodeId}/log`, data)).data,
+    },
+    activity: {
+      getPlanActivity: async (planId) => (await client.get(`/activity/plans/${planId}/activity`)).data,
+      getGlobalActivity: async () => (await client.get('/activity/feed')).data,
+    },
+    search: {
+      searchPlan: async (planId, query) => {
+        try {
+          return (await client.get(`/search/plan/${planId}`, { params: { query } })).data;
+        } catch (error) {
+          return { results: [], count: 0, query };
+        }
+      },
+      globalSearch: async (query) => {
+        try {
+          return (await client.get('/search', { params: { query } })).data;
+        } catch (error) {
+          return { results: [], count: 0, query };
+        }
+      },
+    },
+    tokens: {
+      getTokens: async () => (await client.get('/auth/token')).data,
+      createToken: async (data) => (await client.post('/auth/token', data)).data,
+      revokeToken: async (tokenId) => await client.delete(`/auth/token/${tokenId}`),
+    },
+    organizations: {
+      list: async () => { const r = await client.get('/organizations'); return r.data.organizations || r.data; },
+      get: async (orgId) => (await client.get(`/organizations/${orgId}`)).data,
+      create: async (data) => (await client.post('/organizations', data)).data,
+      update: async (orgId, data) => (await client.put(`/organizations/${orgId}`, data)).data,
+      delete: async (orgId) => (await client.delete(`/organizations/${orgId}`)).data,
+      listMembers: async (orgId) => { const r = await client.get(`/organizations/${orgId}/members`); return r.data.members || r.data; },
+      addMember: async (orgId, data) => (await client.post(`/organizations/${orgId}/members`, data)).data,
+      removeMember: async (orgId, memberId) => (await client.delete(`/organizations/${orgId}/members/${memberId}`)).data,
+    },
+    goals: {
+      list: async (filters = {}) => {
+        const params = new URLSearchParams();
+        if (filters.organization_id) params.append('organization_id', filters.organization_id);
+        if (filters.status) params.append('status', filters.status);
+        const r = await client.get(`/goals?${params.toString()}`);
+        return r.data.goals || r.data;
+      },
+      get: async (goalId) => (await client.get(`/goals/${goalId}`)).data,
+      create: async (data) => (await client.post('/goals', data)).data,
+      update: async (goalId, data) => (await client.put(`/goals/${goalId}`, data)).data,
+      updateMetrics: async (goalId, metrics) => (await client.put(`/goals/${goalId}/metrics`, { metrics })).data,
+      delete: async (goalId) => (await client.delete(`/goals/${goalId}`)).data,
+      linkPlan: async (goalId, planId) => (await client.post(`/goals/${goalId}/plans/${planId}`)).data,
+      unlinkPlan: async (goalId, planId) => (await client.delete(`/goals/${goalId}/plans/${planId}`)).data,
+      getPath: async (goalId, maxDepth) => { const p = maxDepth ? `?max_depth=${maxDepth}` : ''; return (await client.get(`/goals/v2/${goalId}/path${p}`)).data; },
+      getProgress: async (goalId) => (await client.get(`/goals/v2/${goalId}/progress`)).data,
+      listAchievers: async (goalId) => (await client.get(`/goals/v2/${goalId}/achievers`)).data,
+      addAchiever: async (goalId, sourceNodeId, weight) => (await client.post(`/goals/v2/${goalId}/achievers`, { source_node_id: sourceNodeId, weight: weight ?? 1 })).data,
+      removeAchiever: async (goalId, depId) => (await client.delete(`/goals/v2/${goalId}/achievers/${depId}`)).data,
+      getKnowledgeGaps: async (goalId) => (await client.get(`/goals/v2/${goalId}/knowledge-gaps`)).data,
+      getDashboard: async () => (await client.get('/goals/v2/dashboard')).data,
+    },
+    context: {
+      getNodeContext: async (nodeId, options = {}) => {
+        const params = new URLSearchParams({ node_id: nodeId });
+        if (options.include_knowledge !== undefined) params.append('include_knowledge', options.include_knowledge);
+        if (options.include_siblings !== undefined) params.append('include_siblings', options.include_siblings);
+        return (await client.get(`/context?${params.toString()}`)).data;
+      },
+      getPlanContext: async (planId, options = {}) => {
+        const params = new URLSearchParams({ plan_id: planId });
+        if (options.include_knowledge !== undefined) params.append('include_knowledge', options.include_knowledge);
+        return (await client.get(`/context/plan?${params.toString()}`)).data;
+      },
+    },
+    graphiti: {
+      getStatus: async () => (await client.get('/knowledge/graphiti/status')).data,
+      addEpisode: async (data) => (await client.post('/knowledge/episodes', data)).data,
+      graphSearch: async (data) => (await client.post('/knowledge/graph-search', data)).data,
+      searchEntities: async (data) => (await client.post('/knowledge/entities', data)).data,
+      detectContradictions: async (data) => (await client.post('/knowledge/contradictions', data)).data,
+      getEpisodes: async ({ max_episodes = 20 } = {}) => (await client.get('/knowledge/episodes', { params: { max_episodes } })).data,
+      deleteEpisode: async (episodeId) => (await client.delete(`/knowledge/episodes/${episodeId}`)).data,
+    },
+    dependencies: {
+      createCrossPlan: async (data) => (await client.post('/dependencies/cross-plan', data)).data,
+      listCrossPlan: async (planIds) => (await client.get('/dependencies/cross-plan', { params: { plan_ids: planIds.join(',') } })).data,
+      createExternal: async (data) => (await client.post('/dependencies/external', data)).data,
+    },
+    axiosInstance: client,
+  };
+}
+
 // Export API client functions
 // Export the axios instance for direct use
 const axiosInstance = apiClient;
@@ -693,7 +923,9 @@ module.exports = {
   tokens,
   organizations,
   goals,
-  knowledge,
   context,
-  axiosInstance  // Export for direct API calls
+  graphiti,
+  dependencies,
+  axiosInstance,  // Export for direct API calls
+  createApiClient  // Factory for per-session clients (HTTP mode)
 };

package/src/index.js

@@ -3,6 +3,7 @@ const { Server } = require('@modelcontextprotocol/sdk/server/index.js');
 const { StdioServerTransport } = require('@modelcontextprotocol/sdk/server/stdio.js');
 const { MCPHTTPServer } = require('./server-http');
 const { setupTools } = require('./tools');
+const { version } = require('../package.json');
 require('dotenv').config();
 
 /**
@@ -39,7 +40,7 @@ async function main() {
     const userApiToken = process.env.USER_API_TOKEN || process.env.API_TOKEN;
     console.error(`User API Token: ${userApiToken ? '***' + userApiToken.slice(-4) : 'NOT SET'}`);
     console.error(`MCP Server Name: ${process.env.MCP_SERVER_NAME || 'planning-system-mcp'}`);
-    console.error(`MCP Server Version: ${process.env.MCP_SERVER_VERSION || '0.3.1'}`);
+    console.error(`MCP Server Version: ${process.env.MCP_SERVER_VERSION || version}`);
 
     // Validate required environment variables
     if (!userApiToken) {
@@ -71,7 +72,7 @@ async function main() {
       // Stdio transport mode (default)
       const server = new Server({
         name: process.env.MCP_SERVER_NAME || "planning-system-mcp",
-        version: process.env.MCP_SERVER_VERSION || "0.3.1"
+        version: process.env.MCP_SERVER_VERSION || version
       }, {
         capabilities: {
           tools: {}

package/src/server-http.js

@@ -15,7 +15,9 @@
 const express = require('express');
 const { SessionManager } = require('./session-manager');
 const { setupTools } = require('./tools');
+const { createApiClient } = require('./api-client');
 const { Server } = require('@modelcontextprotocol/sdk/server/index.js');
+const { version } = require('../package.json');
 require('dotenv').config();
 
 // MCP Protocol Version
@@ -60,8 +62,8 @@ class MCPHTTPServer {
 
     // Protocol version validation
     this.app.use((req, res, next) => {
-      // Skip version check for health endpoint
-      if (req.path === '/health') {
+      // Skip version check for health and discovery endpoints
+      if (req.path === '/health' || req.path === '/.well-known/mcp.json') {
         return next();
       }
 
@@ -77,26 +79,55 @@ class MCPHTTPServer {
       next();
     });
 
+    // Authentication — require Authorization header on /mcp
+    this.app.use((req, res, next) => {
+      if (req.path === '/health' || req.path === '/.well-known/mcp.json') return next();
+
+      const authHeader = req.get('Authorization');
+      if (!authHeader) {
+        return res.status(401).json({
+          jsonrpc: '2.0',
+          error: { code: -32000, message: 'Authorization header required. Use "Authorization: Bearer <token>" or "Authorization: ApiKey <token>".' }
+        });
+      }
+
+      const parts = authHeader.split(' ');
+      if (parts.length !== 2 || !['Bearer', 'ApiKey'].includes(parts[0])) {
+        return res.status(401).json({
+          jsonrpc: '2.0',
+          error: { code: -32000, message: 'Invalid Authorization format. Use "Bearer <token>" or "ApiKey <token>".' }
+        });
+      }
+
+      // Store the raw token for per-session API client creation
+      req.userToken = parts[1];
+      next();
+    });
+
     // Origin validation for security (DNS rebinding protection)
     this.app.use((req, res, next) => {
-      // Skip origin check for health endpoint
-      if (req.path === '/health') {
+      // Skip origin check for health and discovery endpoints
+      if (req.path === '/health' || req.path === '/.well-known/mcp.json') {
         return next();
       }
 
+      // Skip origin check when running on 0.0.0.0 (production container behind nginx)
+      // Origin validation is DNS rebinding protection, not relevant for server-to-server MCP
+      if (this.host === '0.0.0.0') return next();
+
       const origin = req.get('Origin');
 
       // If Origin header is present, validate it
       if (origin) {
-        // For localhost binding, accept localhost origins
+        // Accept localhost and production origins
         const allowedOrigins = [
           'http://localhost',
           'http://127.0.0.1',
           `http://localhost:${this.port}`,
-          `http://127.0.0.1:${this.port}`
+          `http://127.0.0.1:${this.port}`,
+          'https://agentplanner.io'
         ];
 
-        const originUrl = new URL(origin);
         const isAllowed = allowedOrigins.some(allowed => origin.startsWith(allowed));
 
         if (!isAllowed) {
@@ -119,6 +150,25 @@ class MCPHTTPServer {
    * Setup Express routes
    */
   setupRoutes() {
+    // MCP discovery endpoint (no auth required)
+    this.app.get('/.well-known/mcp.json', (req, res) => {
+      res.json({
+        mcp_version: '2025-03-26',
+        server: {
+          name: 'agent-planner-mcp',
+          version,
+          description: 'AI agent orchestration with planning, dependencies, knowledge graphs, and human oversight'
+        },
+        endpoints: { mcp: '/mcp' },
+        authentication: {
+          type: 'api_key',
+          header: 'Authorization',
+          format: 'ApiKey <token>'
+        },
+        capabilities: { tools: true }
+      });
+    });
+
     // Health check endpoint
     this.app.get('/health', (req, res) => {
       const stats = this.sessionManager.getStats();
@@ -127,7 +177,7 @@ class MCPHTTPServer {
         version: MCP_PROTOCOL_VERSION,
         server: {
           name: process.env.MCP_SERVER_NAME || 'planning-tools',
-          version: process.env.MCP_SERVER_VERSION || '0.3.1'
+          version: process.env.MCP_SERVER_VERSION || version
         },
         sessions: {
           total: stats.total,
@@ -213,17 +263,21 @@ class MCPHTTPServer {
 
       if (isRequest) {
         // Handle JSON-RPC request
-        const response = await this.handleRequest(message, session, sessionId);
+        const response = await this.handleRequest(message, session, sessionId, req.userToken);
 
         // If this is an initialize request, create session and include session ID
         if (message.method === 'initialize' && response.result) {
           sessionId = this.sessionManager.createSession();
           this.sessionManager.initializeSession(sessionId, message.params?.capabilities);
 
+          // Create a per-session API client bound to this user's token
+          const sessionApiClient = createApiClient(req.userToken);
+          this.sessionManager.setApiClient(sessionId, sessionApiClient);
+
           // Set session ID header in response
           res.setHeader('Mcp-Session-Id', sessionId);
 
-          console.error(`Session initialized: ${sessionId}`);
+          console.error(`Session initialized: ${sessionId} (per-user token)`);
         }
 
         // Check if we should stream the response via SSE
@@ -377,19 +431,24 @@ class MCPHTTPServer {
   /**
    * Handle JSON-RPC request
    */
-  async handleRequest(message, session, sessionId) {
+  async handleRequest(message, session, sessionId, userToken) {
     // Create MCP server instance for this request
     const mcpServer = new Server({
       name: process.env.MCP_SERVER_NAME || 'planning-tools',
-      version: process.env.MCP_SERVER_VERSION || '0.3.1'
+      version: process.env.MCP_SERVER_VERSION || version
     }, {
       capabilities: {
         tools: {}
       }
     });
 
-    // Setup tools on the server
-    setupTools(mcpServer);
+    // Get per-session API client (bound to user's token), or create one for initialize requests
+    const sessionApiClient = session
+      ? this.sessionManager.getApiClient(sessionId)
+      : (userToken ? createApiClient(userToken) : null);
+
+    // Setup tools with the per-session API client
+    setupTools(mcpServer, sessionApiClient);
 
     // Process the request through MCP server
     try {

package/src/session-manager.js

@@ -88,6 +88,28 @@ class SessionManager {
     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

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
 `;