@gainable.dev/mcp-server 0.2.0 → 0.2.1

package/dist/collectionSchema.js

@@ -33,27 +33,34 @@ export async function preWarmSchemaCache(appName, allowedDatasets) {
         return;
     try {
         const collections = await schemaDb.listCollections().toArray();
+        const sizeBefore = schemaCache.size;
+        let matched = 0;
         for (const col of collections) {
             const name = col.name;
             // App's custom collections
             if (name.startsWith(`${appName}_`)) {
                 const cleanName = name.slice(appName.length + 1);
                 await getCollectionSchema(name, cleanName);
+                matched++;
                 continue;
             }
             // Allowed data collections
             for (const datasetId of allowedDatasets) {
                 if (name === `data_${datasetId}`) {
                     await getCollectionSchema(name, datasetId);
+                    matched++;
                     break;
                 }
             }
             // Core collections (e.g. users)
             if (CORE_COLLECTIONS.includes(name)) {
                 await getCollectionSchema(name, name);
+                matched++;
             }
         }
-        console.log(`[Schema] Pre-warmed cache for ${schemaCache.size} collections`);
+        const cached = schemaCache.size - sizeBefore;
+        const skipped = matched - cached;
+        console.log(`[Schema] Pre-warmed schema for ${cached} collections${skipped > 0 ? ` (${skipped} empty collection${skipped > 1 ? 's' : ''} skipped)` : ''}`);
     }
     catch (err) {
         console.warn('[Schema] Pre-warm failed:', err);
@@ -64,10 +71,11 @@ export async function preWarmSchemaCache(appName, allowedDatasets) {
  * Called from createServerForRequest() so schemas are ready before the first query.
  */
 export async function ensureSchemaCacheWarmed(appName, allowedDatasets) {
-    if (warmedApps.has(appName))
+    const key = `${appName}:${allowedDatasets.sort().join(',')}`;
+    if (warmedApps.has(key))
         return;
     await preWarmSchemaCache(appName, allowedDatasets);
-    warmedApps.add(appName);
+    warmedApps.add(key);
 }
 /**
  * Infer schema from a collection by sampling documents.

package/dist/gainableHttpRunner.d.ts

@@ -4,22 +4,18 @@ import type { BaseConfig } from './config.js';
  * Extends StreamableHttpRunner for per-account MCP.
  *
  * Each request includes `?app={appName}&agent={agentId}` — both required.
- * The runner auto-discovers datasets from the account DB and builds
- * per-request scoping config.
+ * Attached data collections are read from `app_config` in the account DB per request.
  */
 export declare class GainableHttpRunner extends StreamableHttpRunner {
     private baseConfig;
     private scopeClient;
-    /** Cached datasets per account (auto-discovered from datamodels collection). TTL 60s. */
-    private datasetsCache;
-    private static readonly DATASETS_TTL_MS;
     constructor(config: ConstructorParameters<typeof StreamableHttpRunner>[0], baseConfig: BaseConfig);
     private getClient;
     /**
-     * Auto-discover allowed datasets from the datamodels collection.
-     * Cached for 60s per process (all apps in an account share the same datasets).
+     * Look up attached data collections for an app from the app_config collection.
+     * Returns array of collection IDs (e.g. ["col_xxx", "col_yyy"]).
      */
-    private discoverDatasets;
+    private getAppDatasets;
     /**
      * Look up an agent's scopes from MongoDB.
      * Returns the scopes array if the agent has restrictions, or undefined if unrestricted.

package/dist/gainableHttpRunner.js

@@ -6,15 +6,11 @@ import { ensureSchemaCacheWarmed } from './collectionSchema.js';
  * Extends StreamableHttpRunner for per-account MCP.
  *
  * Each request includes `?app={appName}&agent={agentId}` — both required.
- * The runner auto-discovers datasets from the account DB and builds
- * per-request scoping config.
+ * Attached data collections are read from `app_config` in the account DB per request.
  */
 export class GainableHttpRunner extends StreamableHttpRunner {
     baseConfig;
     scopeClient = null;
-    /** Cached datasets per account (auto-discovered from datamodels collection). TTL 60s. */
-    datasetsCache = null;
-    static DATASETS_TTL_MS = 60_000;
     constructor(config, baseConfig) {
         super(config);
         this.baseConfig = baseConfig;
@@ -27,26 +23,14 @@ export class GainableHttpRunner extends StreamableHttpRunner {
         return this.scopeClient;
     }
     /**
-     * Auto-discover allowed datasets from the datamodels collection.
-     * Cached for 60s per process (all apps in an account share the same datasets).
+     * Look up attached data collections for an app from the app_config collection.
+     * Returns array of collection IDs (e.g. ["col_xxx", "col_yyy"]).
      */
-    async discoverDatasets() {
-        if (this.datasetsCache && Date.now() - this.datasetsCache.fetchedAt < GainableHttpRunner.DATASETS_TTL_MS) {
-            return this.datasetsCache.datasets;
-        }
-        try {
-            const client = await this.getClient();
-            const db = client.db(this.baseConfig.accountId);
-            const models = await db.collection('datamodels').find({}, { projection: { modelId: 1 } }).toArray();
-            const datasets = models.map(m => m.modelId).filter(Boolean);
-            this.datasetsCache = { datasets, fetchedAt: Date.now() };
-            console.log(`[MCP] Discovered ${datasets.length} datasets for account ${this.baseConfig.accountId}`);
-            return datasets;
-        }
-        catch (err) {
-            console.warn('[MCP] Failed to discover datasets:', err);
-            return this.datasetsCache?.datasets ?? [];
-        }
+    async getAppDatasets(appName) {
+        const client = await this.getClient();
+        const db = client.db(this.baseConfig.accountId);
+        const config = await db.collection('app_config').findOne({ appId: appName }, { projection: { attachedCollections: 1 } });
+        return config?.attachedCollections || [];
     }
     /**
      * Look up an agent's scopes from MongoDB.
@@ -72,14 +56,13 @@ export class GainableHttpRunner extends StreamableHttpRunner {
         if (!agentId) {
             throw new Error('Missing required query parameter: agent');
         }
-        // Auto-discover datasets and look up agent scopes in parallel
-        const [allowedDatasets, agentCollections] = await Promise.all([
-            this.discoverDatasets(),
-            this.getAgentScopes(appName, agentId),
-        ]);
+        // Look up attached collections from app_config in account DB
+        const allowedDatasets = await this.getAppDatasets(appName);
+        // Look up agent scopes
+        const agentCollections = await this.getAgentScopes(appName, agentId);
         // Lazy schema warming for this app
         await ensureSchemaCacheWarmed(appName, allowedDatasets);
-        console.log(`[MCP Session] app=${appName} | agent=${agentId} | datasets=${allowedDatasets.length} | scoped=${agentCollections ? 'yes' : 'no'}${agentCollections ? ` | collections=${JSON.stringify(agentCollections)}` : ''}`);
+        console.log(`[MCP Session] app=${appName} | agent=${agentId} | datasets=${allowedDatasets.length > 0 ? allowedDatasets.join(',') : '(none)'} | scoped=${agentCollections ? 'yes' : 'no'}${agentCollections ? ` | collections=${JSON.stringify(agentCollections)}` : ''}`);
         // Build per-request scoping config
         const scopingConfig = {
             ...this.baseConfig,

package/dist/scopedProvider.js

@@ -123,8 +123,9 @@ function filterAndRenameCollections(collections, appName, allowedDatasets, agent
         // Everything else is hidden
     }
     // Agent-level restriction: filter to only allowed collections
+    // Core collections (users, userfieldmetadatas) are always included
     if (agentCollections) {
-        return results.filter(col => agentCollections.includes(col.name));
+        return results.filter(col => col.type === 'core' || agentCollections.includes(col.name));
     }
     return results;
 }

package/dist/scoping/resolveCollection.js

@@ -1,26 +1,27 @@
 export const CORE_EXPOSED = ['users', 'userfieldmetadatas'];
 const BLOCKED = ['agents', 'connections', 'emailtemplates', 'emaillogs', 'datamodels'];
 export function resolveCollection(cleanName, appName, allowedDatasets, agentCollections) {
-    // 0. Agent-level restriction: if agent has a scoped list, check it first
-    if (agentCollections && !agentCollections.includes(cleanName)) {
-        throw new Error(`Collection '${cleanName}' is not accessible`);
-    }
-    // 1. Core collections — name stays as-is
+    // 1. Core collections — always accessible regardless of agent scoping
     if (CORE_EXPOSED.includes(cleanName)) {
         return { realName: cleanName, type: 'core', writable: true };
     }
-    // 2. Data collections — check allowed datasets
+    // 2. Agent-level restriction: if agent has a scoped list, check it
+    //    (core collections above are always allowed)
+    if (agentCollections && !agentCollections.includes(cleanName)) {
+        throw new Error(`Collection '${cleanName}' is not accessible`);
+    }
+    // 3. Data collections — check allowed datasets
     for (const datasetId of allowedDatasets) {
         const realName = `data_${datasetId}`;
         if (cleanName === realName || cleanName === datasetId) {
             return { realName, type: 'data', writable: false };
         }
     }
-    // 3. Blocked core/system collections
+    // 4. Blocked core/system collections
     if (BLOCKED.includes(cleanName)) {
         throw new Error(`Collection '${cleanName}' is not accessible`);
     }
-    // 4. Custom collections — add app prefix
+    // 5. Custom collections — add app prefix
     const prefixed = `${appName}_${cleanName}`;
     return { realName: prefixed, type: 'custom', writable: true };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gainable.dev/mcp-server",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Scoped MCP server for Gainable in-app copilot agents — wraps mongodb-mcp-server with per-app data isolation",
   "type": "module",
   "main": "dist/index.js",