@gainable.dev/mcp-server 0.1.0

package/dist/collectionSchema.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Inferred field info from sampling actual documents.
+ */
+export interface FieldInfo {
+    name: string;
+    types: string[];
+    /** Sample distinct values for low-cardinality fields (enums). */
+    enumValues?: string[];
+    /** Whether this field appears to reference another collection (ObjectId). */
+    isReference?: boolean;
+}
+export interface CollectionSchemaInfo {
+    collection: string;
+    fields: FieldInfo[];
+    namingConvention: 'camelCase' | 'snake_case' | 'mixed';
+    inferredAt: Date;
+}
+/**
+ * Initialize the schema inference connection.
+ * Call once at startup with the MongoDB URI and database name.
+ */
+export declare function initSchemaInference(mongoUri: string, dbName: string): Promise<void>;
+/**
+ * Pre-warm the schema cache for known collections at startup.
+ * This ensures synchronous cache lookups work from the very first query.
+ */
+export declare function preWarmSchemaCache(appName: string, allowedDatasets: string[]): Promise<void>;
+/**
+ * Infer schema from a collection by sampling documents.
+ * Results are cached for the lifetime of the process.
+ */
+export declare function getCollectionSchema(realCollectionName: string, cleanName: string): Promise<CollectionSchemaInfo | undefined>;
+/**
+ * Synchronous cache-only lookup. Returns the schema if already cached, undefined otherwise.
+ * Use this in code paths that cannot be async (e.g. provider.find returns a cursor, not a promise).
+ */
+export declare function getCachedSchema(realCollectionName: string): CollectionSchemaInfo | undefined;
+/**
+ * Invalidate cached schema for a collection (call after writes).
+ */
+export declare function invalidateSchema(realCollectionName: string): void;
+/**
+ * Format schema info as a hint string to append to tool responses.
+ */
+export declare function formatSchemaHint(schema: CollectionSchemaInfo): string;

package/dist/collectionSchema.js

@@ -0,0 +1,221 @@
+import { MongoClient } from 'mongodb';
+import { CORE_EXPOSED as CORE_COLLECTIONS } from './scoping/index.js';
+/**
+ * Cache of inferred schemas keyed by real collection name.
+ */
+const schemaCache = new Map();
+/**
+ * Singleton DB connection for schema inference.
+ */
+let schemaDb;
+let schemaClient;
+/**
+ * Initialize the schema inference connection.
+ * Call once at startup with the MongoDB URI and database name.
+ */
+export async function initSchemaInference(mongoUri, dbName) {
+    if (schemaDb)
+        return;
+    schemaClient = new MongoClient(mongoUri);
+    await schemaClient.connect();
+    schemaDb = schemaClient.db(dbName);
+}
+/**
+ * Pre-warm the schema cache for known collections at startup.
+ * This ensures synchronous cache lookups work from the very first query.
+ */
+export async function preWarmSchemaCache(appName, allowedDatasets) {
+    if (!schemaDb)
+        return;
+    try {
+        const collections = await schemaDb.listCollections().toArray();
+        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);
+                continue;
+            }
+            // Allowed data collections
+            for (const datasetId of allowedDatasets) {
+                if (name === `data_${datasetId}`) {
+                    await getCollectionSchema(name, datasetId);
+                    break;
+                }
+            }
+            // Core collections (e.g. users)
+            if (CORE_COLLECTIONS.includes(name)) {
+                await getCollectionSchema(name, name);
+            }
+        }
+        console.log(`[Schema] Pre-warmed cache for ${schemaCache.size} collections`);
+    }
+    catch (err) {
+        console.warn('[Schema] Pre-warm failed:', err);
+    }
+}
+/**
+ * Infer schema from a collection by sampling documents.
+ * Results are cached for the lifetime of the process.
+ */
+export async function getCollectionSchema(realCollectionName, cleanName) {
+    if (!schemaDb)
+        return undefined;
+    const cached = schemaCache.get(realCollectionName);
+    if (cached)
+        return cached;
+    try {
+        const docs = await schemaDb.collection(realCollectionName)
+            .find({})
+            .limit(50)
+            .toArray();
+        if (docs.length === 0)
+            return undefined;
+        const schema = inferSchema(cleanName, docs);
+        schemaCache.set(realCollectionName, schema);
+        return schema;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Synchronous cache-only lookup. Returns the schema if already cached, undefined otherwise.
+ * Use this in code paths that cannot be async (e.g. provider.find returns a cursor, not a promise).
+ */
+export function getCachedSchema(realCollectionName) {
+    return schemaCache.get(realCollectionName);
+}
+/**
+ * Invalidate cached schema for a collection (call after writes).
+ */
+export function invalidateSchema(realCollectionName) {
+    schemaCache.delete(realCollectionName);
+}
+function inferSchema(cleanName, docs) {
+    const fieldMap = new Map();
+    for (const doc of docs) {
+        for (const [key, value] of Object.entries(doc)) {
+            if (key === '_id' || key === '__v' || key === 'createdAt' || key === 'updatedAt')
+                continue;
+            let entry = fieldMap.get(key);
+            if (!entry) {
+                entry = { types: new Set(), values: new Set(), count: 0 };
+                fieldMap.set(key, entry);
+            }
+            entry.count++;
+            const typeName = getTypeName(value);
+            entry.types.add(typeName);
+            // Track values for potential enums (strings only, low cardinality)
+            if (typeof value === 'string' && value.length < 50) {
+                entry.values.add(value);
+            }
+        }
+    }
+    const fields = [];
+    // Filter out outlier fields that appear in less than 20% of documents.
+    // These are likely from bad inserts and shouldn't be part of the canonical schema.
+    const minFieldCount = Math.max(1, Math.floor(docs.length * 0.2));
+    for (const [name, entry] of fieldMap) {
+        if (docs.length > 3 && entry.count < minFieldCount)
+            continue;
+        const field = {
+            name,
+            types: [...entry.types],
+        };
+        // If a string field has very few distinct values relative to docs, it's likely an enum.
+        // Require at least 3x more docs than distinct values to avoid treating open-ended
+        // fields (like customer names) as enums.
+        if (entry.types.has('string') &&
+            entry.values.size > 0 &&
+            entry.values.size <= 10 &&
+            entry.count >= entry.values.size * 3) {
+            field.enumValues = [...entry.values].sort();
+        }
+        // ObjectId fields that aren't the doc's own _id are likely references
+        if (entry.types.has('ObjectId')) {
+            field.isReference = true;
+        }
+        fields.push(field);
+    }
+    const namingConvention = detectNamingConvention(fields.map(f => f.name));
+    return {
+        collection: cleanName,
+        fields,
+        namingConvention,
+        inferredAt: new Date(),
+    };
+}
+function getTypeName(value) {
+    if (value === null || value === undefined)
+        return 'null';
+    if (typeof value === 'string')
+        return 'string';
+    if (typeof value === 'number')
+        return 'number';
+    if (typeof value === 'boolean')
+        return 'boolean';
+    if (value instanceof Date)
+        return 'ISODate';
+    if (Array.isArray(value))
+        return 'array';
+    // Check for BSON types
+    if (value._bsontype === 'ObjectId' || value._bsontype === 'ObjectID')
+        return 'ObjectId';
+    if (value._bsontype === 'Decimal128')
+        return 'Decimal128';
+    // MongoDB driver ObjectId
+    if (typeof value.toHexString === 'function' && String(value).length === 24)
+        return 'ObjectId';
+    // Dates that come through as objects
+    if (value instanceof Object && value.constructor?.name === 'Date')
+        return 'ISODate';
+    return 'object';
+}
+function detectNamingConvention(fieldNames) {
+    let camelCount = 0;
+    let snakeCount = 0;
+    for (const name of fieldNames) {
+        if (name.includes('_'))
+            snakeCount++;
+        else if (/[a-z][A-Z]/.test(name))
+            camelCount++;
+    }
+    if (camelCount > 0 && snakeCount === 0)
+        return 'camelCase';
+    if (snakeCount > 0 && camelCount === 0)
+        return 'snake_case';
+    return 'mixed';
+}
+/**
+ * Format schema info as a hint string to append to tool responses.
+ */
+export function formatSchemaHint(schema) {
+    const hasReferences = schema.fields.some(f => f.isReference);
+    const lines = [`SCHEMA for "${schema.collection}":`];
+    for (const field of schema.fields) {
+        let desc = `  ${field.name}: ${field.types.join('|')}`;
+        if (field.isReference) {
+            desc += ' (reference - when the user gives a name, automatically look it up in the related collection to get the _id. Never ask the user for an ID. When writing, use EJSON format: {"$oid": "the_id_here"})';
+        }
+        if (field.enumValues && field.enumValues.length > 0) {
+            desc += ` [valid values: ${field.enumValues.map(v => `"${v}"`).join(', ')}]`;
+        }
+        lines.push(desc);
+    }
+    if (schema.namingConvention !== 'mixed') {
+        lines.push(`Field naming convention: ${schema.namingConvention}. Use this convention for all writes.`);
+    }
+    lines.push('IMPORTANT UX RULES:');
+    lines.push('- Never show ObjectIds, internal field names, or technical database details to the user.');
+    lines.push('- Ask for fields using friendly names (e.g. "Customer" not "customer: string", "Assigned to" not "assignedTo: ObjectId").');
+    if (hasReferences) {
+        lines.push('- For reference fields: accept human-readable names from the user (e.g. a person name), then silently look up the _id in the appropriate collection (e.g. users) using the find tool. Never ask the user for an ID or ObjectId.');
+    }
+    lines.push('- For date fields: accept any common format from the user. When writing, use EJSON format: {"$date": "2025-05-05T00:00:00Z"}.');
+    lines.push('- For enum fields: if the user gives the wrong casing, silently correct it.');
+    lines.push('- BEFORE QUERYING: Always use the collection-schema tool first to discover the correct field names. Never guess field names.');
+    lines.push('- VERIFY WRITES: After inserting or updating, query the document back to confirm it was saved correctly. Show the user a friendly summary, not raw data.');
+    return lines.join('\n');
+}

package/dist/config.d.ts

@@ -0,0 +1,11 @@
+export type AgentScopes = Record<string, string[]>;
+export interface ScopingConfig {
+    appName: string;
+    accountId: string;
+    allowedDatasets: string[];
+    mongodbUri: string;
+    agentScopes: AgentScopes;
+    /** Per-session field: which collections this agent can access. undefined = unrestricted. */
+    agentCollections?: string[];
+}
+export declare function loadConfig(): ScopingConfig;

package/dist/config.js

@@ -0,0 +1,31 @@
+export function loadConfig() {
+    const appName = process.env.APP_NAME;
+    const accountId = process.env.ACCOUNT_ID;
+    const mongodbUri = process.env.MONGODB_URI;
+    if (!appName)
+        throw new Error('APP_NAME is required');
+    if (!accountId)
+        throw new Error('ACCOUNT_ID is required');
+    if (!mongodbUri)
+        throw new Error('MONGODB_URI is required');
+    const allowedDatasets = (process.env.ALLOWED_DATASETS || '')
+        .split(',')
+        .map(s => s.trim())
+        .filter(Boolean);
+    const agentScopes = parseAgentScopes(process.env.AGENT_SCOPES);
+    return { appName, accountId, allowedDatasets, mongodbUri, agentScopes };
+}
+function parseAgentScopes(raw) {
+    if (!raw)
+        return {};
+    try {
+        const parsed = JSON.parse(raw);
+        if (typeof parsed !== 'object' || parsed === null)
+            return {};
+        return parsed;
+    }
+    catch {
+        console.warn('AGENT_SCOPES is not valid JSON, ignoring.');
+        return {};
+    }
+}

package/dist/gainableHttpRunner.d.ts

@@ -0,0 +1,123 @@
+import { StreamableHttpRunner } from 'mongodb-mcp-server';
+import type { ScopingConfig } from './config.js';
+/**
+ * Extends StreamableHttpRunner to support per-agent collection scoping.
+ *
+ * Each Weavy agent connects with a URL like `/mcp?agent=marketing-agent`.
+ * The agent ID is extracted from the query parameter and used to look up
+ * which collections that agent is allowed to access (from AGENT_SCOPES env var).
+ */
+export declare class GainableHttpRunner extends StreamableHttpRunner {
+    private baseConfig;
+    constructor(config: ConstructorParameters<typeof StreamableHttpRunner>[0], scopingConfig: ScopingConfig);
+    protected createServerForRequest({ request, serverOptions, sessionOptions, }: Parameters<StreamableHttpRunner['createServerForRequest']>[0]): Promise<import("mongodb-mcp-server").Server<{
+        apiBaseUrl: string;
+        assistantBaseUrl: string;
+        loggers: ("mcp" | "disk" | "stderr")[];
+        logPath: string;
+        disabledTools: string[];
+        confirmationRequiredTools: string[];
+        readOnly: boolean;
+        indexCheck: boolean;
+        telemetry: "enabled" | "disabled";
+        transport: "stdio" | "http";
+        httpPort: number;
+        httpHost: string;
+        httpHeaders: {
+            [x: string]: unknown;
+        };
+        httpBodyLimit: number;
+        idleTimeoutMs: number;
+        notificationTimeoutMs: number;
+        maxBytesPerQuery: number;
+        maxDocumentsPerQuery: number;
+        exportsPath: string;
+        exportTimeoutMs: number;
+        exportCleanupIntervalMs: number;
+        atlasTemporaryDatabaseUserLifetimeMs: number;
+        voyageApiKey: string;
+        embeddingsValidation: boolean;
+        vectorSearchDimensions: number;
+        vectorSearchSimilarityFunction: "cosine" | "euclidean" | "dotProduct";
+        previewFeatures: ("search" | "mcpUI")[];
+        allowRequestOverrides: boolean;
+        dryRun: boolean;
+        externallyManagedSessions: boolean;
+        httpResponseType: "json" | "sse";
+        apiClientId?: string | undefined;
+        apiClientSecret?: string | undefined;
+        connectionString?: string | undefined;
+        healthCheckPort?: number | undefined;
+        healthCheckHost?: string | undefined;
+        gssapiHostName?: string | undefined;
+        sslFIPSMode?: boolean | undefined;
+        ssl?: boolean | undefined;
+        sslAllowInvalidCertificates?: boolean | undefined;
+        sslAllowInvalidHostnames?: boolean | undefined;
+        sslPEMKeyFile?: string | undefined;
+        sslPEMKeyPassword?: string | undefined;
+        sslCAFile?: string | undefined;
+        sslCertificateSelector?: string | undefined;
+        sslCRLFile?: string | undefined;
+        sslDisabledProtocols?: string | undefined;
+        apiVersion?: string | undefined;
+        authenticationDatabase?: string | undefined;
+        authenticationMechanism?: string | undefined;
+        awsAccessKeyId?: string | undefined;
+        awsIamSessionToken?: string | undefined;
+        awsSecretAccessKey?: string | undefined;
+        awsSessionToken?: string | undefined;
+        csfleLibraryPath?: string | undefined;
+        cryptSharedLibPath?: string | undefined;
+        deepInspect?: boolean | undefined;
+        db?: string | undefined;
+        gssapiServiceName?: string | undefined;
+        sspiHostnameCanonicalization?: string | undefined;
+        sspiRealmOverride?: string | undefined;
+        jsContext?: "repl" | "plain-vm" | "auto" | undefined;
+        host?: string | undefined;
+        keyVaultNamespace?: string | undefined;
+        kmsURL?: string | undefined;
+        locale?: string | undefined;
+        oidcFlows?: string | undefined;
+        oidcRedirectUri?: string | undefined;
+        password?: string | undefined;
+        port?: string | undefined;
+        username?: string | undefined;
+        tlsCAFile?: string | undefined;
+        tlsCertificateKeyFile?: string | undefined;
+        tlsCertificateKeyFilePassword?: string | undefined;
+        tlsCertificateSelector?: string | undefined;
+        tlsCRLFile?: string | undefined;
+        tlsDisabledProtocols?: string | undefined;
+        apiDeprecationErrors?: boolean | undefined;
+        apiStrict?: boolean | undefined;
+        buildInfo?: boolean | undefined;
+        exposeAsyncRewriter?: boolean | undefined;
+        help?: boolean | undefined;
+        ipv6?: boolean | undefined;
+        nodb?: boolean | undefined;
+        norc?: boolean | undefined;
+        oidcTrustedEndpoint?: boolean | undefined;
+        oidcIdTokenAsAccessToken?: boolean | undefined;
+        oidcNoNonce?: boolean | undefined;
+        quiet?: boolean | undefined;
+        retryWrites?: boolean | undefined;
+        shell?: boolean | undefined;
+        skipStartupWarnings?: boolean | undefined;
+        verbose?: boolean | undefined;
+        version?: boolean | undefined;
+        smokeTests?: boolean | undefined;
+        perfTests?: boolean | undefined;
+        tls?: boolean | undefined;
+        tlsAllowInvalidCertificates?: boolean | undefined;
+        tlsAllowInvalidHostnames?: boolean | undefined;
+        tlsFIPSMode?: boolean | undefined;
+        tlsUseSystemCA?: boolean | undefined;
+        eval?: string[] | undefined;
+        file?: string[] | undefined;
+        json?: boolean | "relaxed" | "canonical" | undefined;
+        oidcDumpTokens?: boolean | "redacted" | "include-secrets" | undefined;
+        browser?: string | false | undefined;
+    }, unknown>>;
+}

package/dist/gainableHttpRunner.js

@@ -0,0 +1,54 @@
+import { StreamableHttpRunner } from 'mongodb-mcp-server';
+import { createScopedConnectionManagerFactory } from './scopedConnectionManager.js';
+/**
+ * Extends StreamableHttpRunner to support per-agent collection scoping.
+ *
+ * Each Weavy agent connects with a URL like `/mcp?agent=marketing-agent`.
+ * The agent ID is extracted from the query parameter and used to look up
+ * which collections that agent is allowed to access (from AGENT_SCOPES env var).
+ */
+export class GainableHttpRunner extends StreamableHttpRunner {
+    baseConfig;
+    constructor(config, scopingConfig) {
+        super(config);
+        this.baseConfig = scopingConfig;
+    }
+    async createServerForRequest({ request, serverOptions, sessionOptions, }) {
+        const agentId = extractAgentId(request);
+        console.log(`[MCP Session] agent=${agentId ?? '(none)'} | scoped=${agentId && this.baseConfig.agentScopes[agentId] ? 'yes' : 'no'}`);
+        const agentCollections = agentId
+            ? this.baseConfig.agentScopes[agentId]
+            : undefined;
+        // Build per-agent scoping config
+        const agentConfig = {
+            ...this.baseConfig,
+            agentCollections,
+        };
+        // Create a per-session connection manager with agent-specific scoping
+        const connectionManager = await createScopedConnectionManagerFactory(agentConfig)({
+            logger: this.logger,
+            deviceId: this.deviceId,
+            userConfig: this.userConfig,
+        });
+        return this.createServer({
+            userConfig: this.userConfig,
+            logger: undefined,
+            serverOptions: {
+                tools: this.tools,
+                ...serverOptions,
+            },
+            sessionOptions: {
+                ...sessionOptions,
+                connectionManager,
+            },
+        });
+    }
+}
+function extractAgentId(request) {
+    const agent = request?.query?.agent;
+    if (typeof agent === 'string')
+        return agent;
+    if (Array.isArray(agent))
+        return agent[0];
+    return undefined;
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+import 'dotenv/config';

package/dist/index.js

@@ -0,0 +1,49 @@
+import 'dotenv/config';
+import { UserConfigSchema } from 'mongodb-mcp-server';
+import { FindTool, AggregateTool, CountTool, ExportTool, InsertManyTool, UpdateManyTool, DeleteManyTool, ListCollectionsTool, CollectionSchemaTool, CollectionIndexesTool, ExplainTool, } from 'mongodb-mcp-server/tools';
+import { loadConfig } from './config.js';
+import { GainableHttpRunner } from './gainableHttpRunner.js';
+import { unwrapTools, setToolContext } from './stripUntrustedTags.js';
+import { initSchemaInference, preWarmSchemaCache } from './collectionSchema.js';
+const config = loadConfig();
+// Initialize schema inference connection (used for validation + response hints)
+await initSchemaInference(config.mongodbUri, config.accountId);
+await preWarmSchemaCache(config.appName, config.allowedDatasets);
+// Set tool context so response wrappers can resolve collection names
+setToolContext(config.appName, config.allowedDatasets);
+const userConfig = UserConfigSchema.parse({
+    transport: 'http',
+    httpPort: parseInt(process.env.HTTP_PORT || '3099', 10),
+    httpHost: '127.0.0.1',
+    connectionString: config.mongodbUri,
+    telemetry: 'disabled',
+    disabledTools: [
+        'drop-database', 'drop-collection', 'create-collection',
+        'list-databases', 'rename-collection', 'drop-index',
+    ],
+});
+const tools = unwrapTools([
+    FindTool,
+    AggregateTool,
+    CountTool,
+    ExportTool,
+    InsertManyTool,
+    UpdateManyTool,
+    DeleteManyTool,
+    ListCollectionsTool,
+    CollectionSchemaTool,
+    CollectionIndexesTool,
+    ExplainTool,
+]);
+const runner = new GainableHttpRunner({ userConfig, tools }, config);
+await runner.start({
+    serverOptions: {
+        toolContext: {
+            appName: config.appName,
+            accountId: config.accountId,
+            allowedDatasets: config.allowedDatasets,
+        },
+    },
+});
+console.log(`Gainable MCP Server running on http://127.0.0.1:${process.env.HTTP_PORT || '3099'}/mcp`);
+console.log(`App: ${config.appName} | DB: ${config.accountId}`);

package/dist/scopedConnectionManager.d.ts

@@ -0,0 +1,7 @@
+import { type ConnectionManagerFactoryFn } from 'mongodb-mcp-server';
+import type { ScopingConfig } from './config.js';
+/**
+ * Factory function that creates a ScopedConnectionManager wrapping the default one.
+ * Pass this to StdioRunner via sessionOptions.connectionManager.
+ */
+export declare function createScopedConnectionManagerFactory(scopingConfig: ScopingConfig): ConnectionManagerFactoryFn;

package/dist/scopedConnectionManager.js

@@ -0,0 +1,57 @@
+import { ConnectionManager, ConnectionStateConnected, defaultCreateConnectionManager, } from 'mongodb-mcp-server';
+import { createScopedProvider } from './scopedProvider.js';
+/**
+ * A ConnectionManager that wraps the default one and replaces the
+ * serviceProvider with a scoped proxy on successful connection.
+ *
+ * This ensures ALL tools that call ensureConnected() get the scoped
+ * provider — collection resolution, filter injection, and pipeline
+ * sanitization happen transparently.
+ */
+class ScopedConnectionManager extends ConnectionManager {
+    inner;
+    scopingConfig;
+    constructor(inner, scopingConfig) {
+        super();
+        this.inner = inner;
+        this.scopingConfig = scopingConfig;
+        // Forward connection events from inner manager
+        this.inner.events.on('connection-success', (state) => {
+            // Wrap the provider with our scoped proxy
+            const scopedProvider = createScopedProvider(state.serviceProvider, this.scopingConfig);
+            const scopedState = new ConnectionStateConnected(scopedProvider, state.connectionStringInfo, state.connectedAtlasCluster);
+            this.changeState('connection-success', scopedState);
+        });
+        this.inner.events.on('connection-error', (state) => {
+            this.changeState('connection-error', state);
+        });
+        this.inner.events.on('connection-close', (state) => {
+            this.changeState('connection-close', state);
+        });
+    }
+    async connect(settings) {
+        const result = await this.inner.connect(settings);
+        // If the inner manager connected successfully, wrap the provider
+        if (result.tag === 'connected') {
+            const scopedProvider = createScopedProvider(result.serviceProvider, this.scopingConfig);
+            return this.changeState('connection-success', new ConnectionStateConnected(scopedProvider, result.connectionStringInfo, result.connectedAtlasCluster));
+        }
+        return result;
+    }
+    async disconnect() {
+        return this.inner.disconnect();
+    }
+    async close() {
+        return this.inner.close();
+    }
+}
+/**
+ * Factory function that creates a ScopedConnectionManager wrapping the default one.
+ * Pass this to StdioRunner via sessionOptions.connectionManager.
+ */
+export function createScopedConnectionManagerFactory(scopingConfig) {
+    return async ({ logger, deviceId, userConfig }) => {
+        const inner = await defaultCreateConnectionManager({ logger, deviceId, userConfig });
+        return new ScopedConnectionManager(inner, scopingConfig);
+    };
+}

package/dist/scopedProvider.d.ts

@@ -0,0 +1,2 @@
+import type { ScopingConfig } from './config.js';
+export declare function createScopedProvider(realProvider: any, config: ScopingConfig): any;

package/dist/scopedProvider.js

@@ -0,0 +1,130 @@
+import { resolveCollection, injectScope, injectScopeIntoDoc, sanitizePipeline, CORE_EXPOSED, } from './scoping/index.js';
+import { getCollectionSchema, getCachedSchema, invalidateSchema } from './collectionSchema.js';
+import { validateDocument, validateUpdate, validateFilter } from './writeValidation.js';
+export function createScopedProvider(realProvider, config) {
+    const { appName, accountId, allowedDatasets, agentCollections } = config;
+    const resolve = (collection) => resolveCollection(collection, appName, allowedDatasets, agentCollections);
+    return new Proxy(realProvider, {
+        get(target, prop) {
+            const original = target[prop];
+            if (typeof original !== 'function')
+                return original;
+            switch (prop) {
+                case 'find':
+                    return (_database, collection, filter, options) => {
+                        const resolved = resolve(collection);
+                        // Validate filter field names against cached schema (sync — find must return a cursor, not a promise)
+                        const findSchema = getCachedSchema(resolved.realName);
+                        if (findSchema && filter)
+                            validateFilter(filter, findSchema);
+                        const scopedFilter = injectScope(filter || {}, resolved.type, appName, accountId);
+                        return target.find(accountId, resolved.realName, scopedFilter, options);
+                    };
+                case 'aggregate':
+                    return (_database, collection, pipeline, options) => {
+                        const resolved = resolve(collection);
+                        const sanitized = sanitizePipeline(pipeline, resolved.type, appName, accountId, allowedDatasets);
+                        return target.aggregate(accountId, resolved.realName, sanitized, options);
+                    };
+                case 'insertMany':
+                    return async (_database, collection, documents) => {
+                        const resolved = resolve(collection);
+                        if (resolved.type === 'data')
+                            throw new Error('Data collections are read-only');
+                        // Validate against inferred schema
+                        const insertSchema = await getCollectionSchema(resolved.realName, collection);
+                        if (insertSchema) {
+                            for (const doc of documents)
+                                validateDocument(doc, insertSchema);
+                        }
+                        const scopedDocs = documents.map(doc => injectScopeIntoDoc(doc, resolved.type, appName));
+                        const result = await target.insertMany(accountId, resolved.realName, scopedDocs);
+                        invalidateSchema(resolved.realName);
+                        return result;
+                    };
+                case 'updateMany':
+                    return async (_database, collection, filter, update, options) => {
+                        const resolved = resolve(collection);
+                        if (resolved.type === 'data')
+                            throw new Error('Data collections are read-only');
+                        // Validate against inferred schema
+                        const updateSchema = await getCollectionSchema(resolved.realName, collection);
+                        if (updateSchema)
+                            validateUpdate(update, updateSchema);
+                        const scopedFilter = injectScope(filter || {}, resolved.type, appName, accountId);
+                        const result = await target.updateMany(accountId, resolved.realName, scopedFilter, update, options);
+                        invalidateSchema(resolved.realName);
+                        return result;
+                    };
+                case 'deleteMany':
+                    return (_database, collection, filter) => {
+                        const resolved = resolve(collection);
+                        if (resolved.type === 'data')
+                            throw new Error('Data collections are read-only');
+                        const scopedFilter = injectScope(filter || {}, resolved.type, appName, accountId);
+                        return target.deleteMany(accountId, resolved.realName, scopedFilter);
+                    };
+                case 'countDocuments':
+                    return (_database, collection, query, options) => {
+                        const resolved = resolve(collection);
+                        // Validate query field names against cached schema
+                        const countSchema = getCachedSchema(resolved.realName);
+                        if (countSchema && query)
+                            validateFilter(query, countSchema);
+                        const scopedQuery = injectScope(query || {}, resolved.type, appName, accountId);
+                        return target.countDocuments(accountId, resolved.realName, scopedQuery, options);
+                    };
+                case 'listCollections':
+                    return async (_database, filter, options) => {
+                        const collections = await target.listCollections(accountId, filter, options);
+                        return filterAndRenameCollections(collections, appName, allowedDatasets, agentCollections);
+                    };
+                case 'listDatabases':
+                    return () => {
+                        throw new Error('listDatabases is not available in scoped mode');
+                    };
+                default:
+                    return original.bind(target);
+            }
+        },
+    });
+}
+function filterAndRenameCollections(collections, appName, allowedDatasets, agentCollections) {
+    const results = [];
+    for (const col of collections) {
+        const name = col.name;
+        // Core exposed
+        if (CORE_EXPOSED.includes(name)) {
+            results.push({ ...col, type: 'core', writable: true });
+            continue;
+        }
+        // App's custom collections — strip prefix for clean name
+        if (name.startsWith(`${appName}_`)) {
+            results.push({
+                ...col,
+                name: name.slice(appName.length + 1),
+                type: 'custom',
+                writable: true,
+            });
+            continue;
+        }
+        // Allowed data collections
+        for (const datasetId of allowedDatasets) {
+            if (name === `data_${datasetId}`) {
+                results.push({
+                    ...col,
+                    name: datasetId,
+                    type: 'data',
+                    writable: false,
+                });
+                break;
+            }
+        }
+        // Everything else is hidden
+    }
+    // Agent-level restriction: filter to only allowed collections
+    if (agentCollections) {
+        return results.filter(col => agentCollections.includes(col.name));
+    }
+    return results;
+}

package/dist/scoping/index.d.ts

@@ -0,0 +1,4 @@
+export { resolveCollection, CORE_EXPOSED } from './resolveCollection.js';
+export type { ResolvedCollection, CollectionType } from './resolveCollection.js';
+export { injectScope, injectScopeIntoDoc, stripScopeFields } from './injectScope.js';
+export { sanitizePipeline } from './sanitizePipeline.js';

package/dist/scoping/index.js

@@ -0,0 +1,3 @@
+export { resolveCollection, CORE_EXPOSED } from './resolveCollection.js';
+export { injectScope, injectScopeIntoDoc, stripScopeFields } from './injectScope.js';
+export { sanitizePipeline } from './sanitizePipeline.js';

package/dist/scoping/injectScope.d.ts

@@ -0,0 +1,4 @@
+import type { CollectionType } from './resolveCollection.js';
+export declare function injectScope(filter: Record<string, any>, type: CollectionType, appName: string, accountId: string): Record<string, any>;
+export declare function stripScopeFields(filter: any): any;
+export declare function injectScopeIntoDoc(doc: Record<string, any>, type: CollectionType, appName: string): Record<string, any>;

package/dist/scoping/injectScope.js

@@ -0,0 +1,77 @@
+export function injectScope(filter, type, appName, accountId) {
+    const clean = makeCaseInsensitive(stripScopeFields(filter));
+    switch (type) {
+        case 'core':
+            return { ...clean, appId: appName };
+        case 'data':
+            return { ...clean, accountId: accountId };
+        case 'custom':
+            return clean;
+    }
+}
+export function stripScopeFields(filter) {
+    if (!filter || typeof filter !== 'object')
+        return filter;
+    const result = { ...filter };
+    delete result.appId;
+    delete result.accountId;
+    for (const op of ['$and', '$or', '$nor']) {
+        if (Array.isArray(result[op])) {
+            result[op] = result[op].map(stripScopeFields);
+        }
+    }
+    return result;
+}
+/**
+ * Convert string equality values in a filter to case-insensitive regex.
+ * e.g. { status: "won" } → { status: { $regex: "^won$", $options: "i" } }
+ */
+function makeCaseInsensitive(filter) {
+    if (!filter || typeof filter !== 'object')
+        return filter;
+    const result = {};
+    for (const [key, value] of Object.entries(filter)) {
+        if (key.startsWith('$')) {
+            // Recurse into $and/$or/$nor arrays
+            if (Array.isArray(value)) {
+                result[key] = value.map(makeCaseInsensitive);
+            }
+            else if (key === '$in' && Array.isArray(value)) {
+                result[key] = value;
+            }
+            else {
+                result[key] = value;
+            }
+        }
+        else if (typeof value === 'string') {
+            // Escape regex special chars and wrap in anchored case-insensitive match
+            const escaped = value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            result[key] = { $regex: `^${escaped}$`, $options: 'i' };
+        }
+        else if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+            // Handle operator objects like { $in: ["won", "lost"] }
+            const obj = value;
+            if (obj.$in && Array.isArray(obj.$in)) {
+                result[key] = {
+                    ...obj,
+                    $in: obj.$in.map((v) => typeof v === 'string' ? new RegExp(`^${v.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}$`, 'i') : v),
+                };
+            }
+            else {
+                result[key] = value;
+            }
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+export function injectScopeIntoDoc(doc, type, appName) {
+    switch (type) {
+        case 'core':
+            return { ...doc, appId: appName };
+        default:
+            return doc;
+    }
+}

package/dist/scoping/resolveCollection.d.ts

@@ -0,0 +1,8 @@
+export declare const CORE_EXPOSED: readonly ["users", "userfieldmetadatas"];
+export type CollectionType = 'core' | 'custom' | 'data';
+export interface ResolvedCollection {
+    realName: string;
+    type: CollectionType;
+    writable: boolean;
+}
+export declare function resolveCollection(cleanName: string, appName: string, allowedDatasets: string[], agentCollections?: string[]): ResolvedCollection;

package/dist/scoping/resolveCollection.js

@@ -0,0 +1,26 @@
+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
+    if (CORE_EXPOSED.includes(cleanName)) {
+        return { realName: cleanName, type: 'core', writable: true };
+    }
+    // 2. 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
+    if (BLOCKED.includes(cleanName)) {
+        throw new Error(`Collection '${cleanName}' is not accessible`);
+    }
+    // 4. Custom collections — add app prefix
+    const prefixed = `${appName}_${cleanName}`;
+    return { realName: prefixed, type: 'custom', writable: true };
+}

package/dist/scoping/sanitizePipeline.d.ts

@@ -0,0 +1,2 @@
+import type { CollectionType } from './resolveCollection.js';
+export declare function sanitizePipeline(pipeline: Record<string, any>[], type: CollectionType, appName: string, accountId: string, allowedDatasets: string[]): Record<string, any>[];

package/dist/scoping/sanitizePipeline.js

@@ -0,0 +1,30 @@
+import { resolveCollection } from './resolveCollection.js';
+const BLOCKED_STAGES = ['$out', '$merge', '$where', '$function'];
+export function sanitizePipeline(pipeline, type, appName, accountId, allowedDatasets) {
+    // 1. Prepend scope $match
+    const scopeMatch = type === 'core'
+        ? { $match: { appId: appName } }
+        : type === 'data'
+            ? { $match: { accountId } }
+            : null;
+    const sanitized = scopeMatch ? [scopeMatch, ...pipeline] : [...pipeline];
+    // 2. Validate all stages
+    for (const stage of sanitized) {
+        for (const blocked of BLOCKED_STAGES) {
+            if (blocked in stage) {
+                throw new Error(`${blocked} is not allowed`);
+            }
+        }
+        // 3. Validate $lookup targets
+        if ('$lookup' in stage) {
+            const from = stage.$lookup.from;
+            try {
+                resolveCollection(from, appName, allowedDatasets);
+            }
+            catch {
+                throw new Error(`$lookup to collection '${from}' is not allowed`);
+            }
+        }
+    }
+    return sanitized;
+}

package/dist/stripUntrustedTags.d.ts

@@ -0,0 +1,19 @@
+import type { ToolClass } from 'mongodb-mcp-server/tools';
+export declare function setToolContext(appName: string, allowedDatasets: string[]): void;
+/**
+ * Strips the `<untrusted-user-data-UUID>` wrapper and security warnings
+ * from tool response text content.
+ *
+ * The official mongodb-mcp-server wraps all query results in these tags
+ * as a prompt injection defense. In our case the data is already scoped
+ * and the copilot (Weavy/OpenAI) needs to read the actual values —
+ * the tags cause models to ignore or hallucinate over the real data.
+ *
+ * This creates a new tool class that extends the original and post-processes
+ * the invoke() result to remove the wrapping.
+ */
+export declare function unwrapTool<T extends ToolClass>(ToolCtor: T): T;
+/**
+ * Convenience: wrap an array of tool classes.
+ */
+export declare function unwrapTools<T extends ToolClass>(tools: T[]): T[];

package/dist/stripUntrustedTags.js

@@ -0,0 +1,96 @@
+import { getCollectionSchema, formatSchemaHint } from './collectionSchema.js';
+import { resolveCollection } from './scoping/index.js';
+/** Set by index.ts at startup so tool wrappers can resolve collection names. */
+let _appName = '';
+let _allowedDatasets = [];
+export function setToolContext(appName, allowedDatasets) {
+    _appName = appName;
+    _allowedDatasets = allowedDatasets;
+}
+/**
+ * Strips the `<untrusted-user-data-UUID>` wrapper and security warnings
+ * from tool response text content.
+ *
+ * The official mongodb-mcp-server wraps all query results in these tags
+ * as a prompt injection defense. In our case the data is already scoped
+ * and the copilot (Weavy/OpenAI) needs to read the actual values —
+ * the tags cause models to ignore or hallucinate over the real data.
+ *
+ * This creates a new tool class that extends the original and post-processes
+ * the invoke() result to remove the wrapping.
+ */
+export function unwrapTool(ToolCtor) {
+    // Create a subclass that overrides invoke to strip tags
+    const Wrapped = class extends ToolCtor {
+        async invoke(...args) {
+            let result;
+            try {
+                result = await super.invoke(...args);
+            }
+            catch (err) {
+                // Return validation/scoping errors as tool responses instead of crashing
+                return { content: [{ type: 'text', text: err?.message || String(err) }] };
+            }
+            if (result?.content && Array.isArray(result.content)) {
+                // Strip untrusted wrappers and collect all text into one item.
+                // Weavy/OpenAI only reads the first content item, so we must
+                // merge everything into a single text entry.
+                const textParts = [];
+                const nonTextItems = [];
+                for (const item of result.content) {
+                    if (item?.type === 'text' && typeof item.text === 'string') {
+                        const cleaned = stripUntrustedWrapper(item.text);
+                        if (cleaned)
+                            textParts.push(cleaned);
+                    }
+                    else {
+                        nonTextItems.push(item);
+                    }
+                }
+                // Append schema hint for the target collection so the agent
+                // knows the correct field names, types, and valid values.
+                const collection = args[0]?.collection;
+                if (collection && _appName) {
+                    try {
+                        const resolved = resolveCollection(collection, _appName, _allowedDatasets);
+                        const schema = await getCollectionSchema(resolved.realName, collection);
+                        if (schema) {
+                            textParts.push(formatSchemaHint(schema));
+                        }
+                    }
+                    catch {
+                        // Schema hints are best-effort, don't break the response
+                    }
+                }
+                result.content = [
+                    ...(textParts.length > 0
+                        ? [{ type: 'text', text: textParts.join('\n\n') }]
+                        : []),
+                    ...nonTextItems,
+                ];
+            }
+            return result;
+        }
+    };
+    // Preserve static properties that the server uses for registration
+    Wrapped.toolName = ToolCtor.toolName;
+    Wrapped.category = ToolCtor.category;
+    Wrapped.operationType = ToolCtor.operationType;
+    return Wrapped;
+}
+/**
+ * Strips the untrusted-user-data wrapper from a text string.
+ */
+function stripUntrustedWrapper(text) {
+    const regex = /^[ \t]*<untrusted-user-data-[0-9a-f\-]*>(?<data>.*)^[ \t]*<\/untrusted-user-data-[0-9a-f\-]*>/gms;
+    const match = regex.exec(text);
+    if (!match?.groups?.data)
+        return text;
+    return match.groups.data.trim();
+}
+/**
+ * Convenience: wrap an array of tool classes.
+ */
+export function unwrapTools(tools) {
+    return tools.map(unwrapTool);
+}

package/dist/writeValidation.d.ts

@@ -0,0 +1,19 @@
+import type { CollectionSchemaInfo } from './collectionSchema.js';
+/**
+ * Generic write validation based on inferred collection schema.
+ * Throws descriptive errors so the AI agent can self-correct.
+ */
+/**
+ * Validate filter/query fields against the inferred schema.
+ * Rejects queries using non-existent field names so the agent self-corrects
+ * instead of returning 0 results silently.
+ */
+export declare function validateFilter(filter: Record<string, any>, schema: CollectionSchemaInfo): void;
+/**
+ * Validate a document being inserted against the inferred schema.
+ */
+export declare function validateDocument(doc: Record<string, any>, schema: CollectionSchemaInfo): void;
+/**
+ * Validate fields in an update operation against the inferred schema.
+ */
+export declare function validateUpdate(update: Record<string, any>, schema: CollectionSchemaInfo): void;

package/dist/writeValidation.js

@@ -0,0 +1,151 @@
+/**
+ * Generic write validation based on inferred collection schema.
+ * Throws descriptive errors so the AI agent can self-correct.
+ */
+/**
+ * Validate filter/query fields against the inferred schema.
+ * Rejects queries using non-existent field names so the agent self-corrects
+ * instead of returning 0 results silently.
+ */
+export function validateFilter(filter, schema) {
+    const knownFields = new Set(schema.fields.map(f => f.name));
+    const knownFieldNames = schema.fields.map(f => f.name).join(', ');
+    for (const key of Object.keys(filter)) {
+        // Skip MongoDB operators, internal fields, and scope fields
+        if (key.startsWith('$') || key === '_id' || key === '__v' || key === 'app')
+            continue;
+        if (knownFields.has(key))
+            continue;
+        // Look for a case-insensitive match
+        const match = schema.fields.find(f => f.name.toLowerCase() === key.toLowerCase());
+        if (match) {
+            throw new Error(`Unknown filter field "${key}". Did you mean "${match.name}"? Known fields: ${knownFieldNames}. Use the collection-schema tool to discover correct field names before querying.`);
+        }
+        // Check for snake_case vs camelCase
+        if (key.includes('_')) {
+            const camelVersion = snakeToCamel(key);
+            const camelMatch = schema.fields.find(f => f.name.toLowerCase() === camelVersion.toLowerCase());
+            if (camelMatch) {
+                throw new Error(`Unknown filter field "${key}". Did you mean "${camelMatch.name}"? Known fields: ${knownFieldNames}. Use the collection-schema tool to discover correct field names before querying.`);
+            }
+        }
+        if (/[a-z][A-Z]/.test(key)) {
+            const snakeVersion = camelToSnake(key);
+            const snakeMatch = schema.fields.find(f => f.name.toLowerCase() === snakeVersion.toLowerCase());
+            if (snakeMatch) {
+                throw new Error(`Unknown filter field "${key}". Did you mean "${snakeMatch.name}"? Known fields: ${knownFieldNames}. Use the collection-schema tool to discover correct field names before querying.`);
+            }
+        }
+        // Reject completely unknown fields
+        throw new Error(`Unknown filter field "${key}". This collection only has these fields: ${knownFieldNames}. Use the collection-schema tool to discover correct field names before querying.`);
+    }
+}
+/**
+ * Validate a document being inserted against the inferred schema.
+ */
+export function validateDocument(doc, schema) {
+    validateFieldNaming(doc, schema);
+    validateEnumValues(doc, schema);
+    validateReferences(doc, schema);
+}
+/**
+ * Validate fields in an update operation against the inferred schema.
+ */
+export function validateUpdate(update, schema) {
+    if (update.$set && typeof update.$set === 'object') {
+        validateFieldNaming(update.$set, schema);
+        validateEnumValues(update.$set, schema);
+        validateReferences(update.$set, schema);
+    }
+    if (update.$unset && typeof update.$unset === 'object') {
+        validateFieldNaming(update.$unset, schema);
+    }
+    // Replacement-style updates (no $ operators)
+    const hasOperators = Object.keys(update).some(k => k.startsWith('$'));
+    if (!hasOperators) {
+        validateFieldNaming(update, schema);
+        validateEnumValues(update, schema);
+        validateReferences(update, schema);
+    }
+}
+/**
+ * Reject fields that violate the collection's naming convention.
+ * e.g. snake_case fields in a camelCase collection.
+ */
+function validateFieldNaming(fields, schema) {
+    const knownFields = new Set(schema.fields.map(f => f.name));
+    const knownFieldNames = schema.fields.map(f => f.name).join(', ');
+    for (const key of Object.keys(fields)) {
+        if (key.startsWith('$') || key === '_id' || key === '__v')
+            continue;
+        if (knownFields.has(key))
+            continue;
+        // Look for a case-insensitive match to suggest the right name
+        const match = schema.fields.find(f => f.name.toLowerCase() === key.toLowerCase());
+        if (match) {
+            throw new Error(`Invalid field name "${key}". Use "${match.name}" instead (exact casing required). Known fields: ${knownFieldNames}.`);
+        }
+        // Check for snake_case vs camelCase conversion match
+        if (key.includes('_')) {
+            const camelVersion = snakeToCamel(key);
+            const camelMatch = schema.fields.find(f => f.name.toLowerCase() === camelVersion.toLowerCase());
+            if (camelMatch) {
+                throw new Error(`Invalid field name "${key}". Use "${camelMatch.name}" instead. Known fields: ${knownFieldNames}.`);
+            }
+        }
+        if (/[a-z][A-Z]/.test(key)) {
+            const snakeVersion = camelToSnake(key);
+            const snakeMatch = schema.fields.find(f => f.name.toLowerCase() === snakeVersion.toLowerCase());
+            if (snakeMatch) {
+                throw new Error(`Invalid field name "${key}". Use "${snakeMatch.name}" instead. Known fields: ${knownFieldNames}.`);
+            }
+        }
+        // Reject completely unknown fields
+        throw new Error(`Unknown field "${key}". This collection only has these fields: ${knownFieldNames}. Use the collection-schema tool to check the correct field names before writing.`);
+    }
+}
+/**
+ * Validate that enum-like fields use valid values (case-sensitive).
+ */
+function validateEnumValues(fields, schema) {
+    for (const [key, value] of Object.entries(fields)) {
+        if (typeof value !== 'string')
+            continue;
+        const fieldSchema = schema.fields.find(f => f.name === key);
+        if (!fieldSchema?.enumValues || fieldSchema.enumValues.length === 0)
+            continue;
+        if (!fieldSchema.enumValues.includes(value)) {
+            // Check for case mismatch
+            const caseMatch = fieldSchema.enumValues.find(v => v.toLowerCase() === value.toLowerCase());
+            if (caseMatch) {
+                throw new Error(`Invalid value "${value}" for field "${key}". Use "${caseMatch}" (exact casing required). Valid values: ${fieldSchema.enumValues.map(v => `"${v}"`).join(', ')}.`);
+            }
+            else {
+                throw new Error(`Invalid value "${value}" for field "${key}". Valid values: ${fieldSchema.enumValues.map(v => `"${v}"`).join(', ')}.`);
+            }
+        }
+    }
+}
+/**
+ * Validate that reference fields contain valid ObjectId strings, not names.
+ */
+function validateReferences(fields, schema) {
+    for (const [key, value] of Object.entries(fields)) {
+        if (typeof value !== 'string')
+            continue;
+        const fieldSchema = schema.fields.find(f => f.name === key);
+        if (!fieldSchema?.isReference)
+            continue;
+        // ObjectId hex strings are exactly 24 characters
+        if (!/^[0-9a-f]{24}$/i.test(value)) {
+            throw new Error(`Field "${key}" is a reference (ObjectId). Got "${value}" which is not a valid ObjectId. ` +
+                `Query the related collection first to find the correct _id value.`);
+        }
+    }
+}
+function snakeToCamel(s) {
+    return s.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+}
+function camelToSnake(s) {
+    return s.replace(/[A-Z]/g, c => `_${c.toLowerCase()}`);
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@gainable.dev/mcp-server",
+  "version": "0.1.0",
+  "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",
+  "bin": {
+    "gainable-mcp-server": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "dev": "tsx src/index.ts",
+    "start": "node dist/index.js",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "dependencies": {
+    "dotenv": "^17.3.1",
+    "mongodb-mcp-server": "^1.8.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0"
+  }
+}