@anteros/core 0.0.19 → 0.0.21

package/types/hook.d.ts

@@ -1,7 +1,8 @@
 import type { MongoRest } from "../database/mongodbadapter";
 import type { Server as SocketIO } from "socket.io";
 import type { ActionsApiList } from "./api";
-type metaHook = {
+
+export type HookMeta = {
     action: ActionsApiList;
     collection: string;
     data?: any;
@@ -14,17 +15,19 @@ type metaHook = {
     pipeline?: any[];
     options?: any;
 }
+
+/** Context passed to a collection hook (`define.Hook`). */
+export type HookContext = {
+    rest: MongoRest;
+    action: ActionsApiList;
+    meta: HookMeta;
+    io: SocketIO;
+};
+
+/** A collection hook — `define.Hook(fn)`, used as beforeOperation/afterOperation. */
+export type CollectionHook = (ctx: HookContext) => Promise<void>;
+
 export type HooksCollection = {
-    beforeOperation?: (ctx: {
-        rest: MongoRest;
-        action: ActionsApiList;
-        meta: metaHook;
-        io: SocketIO;
-    }) => Promise<void>;
-    afterOperation?: (ctx: {
-        rest: MongoRest;
-        action: ActionsApiList;
-        meta: metaHook;
-        io: SocketIO;
-    }) => Promise<void>;
+    beforeOperation?: CollectionHook;
+    afterOperation?: CollectionHook;
 }

package/types/mcp.d.ts

@@ -0,0 +1,81 @@
+import type Joi from "joi";
+import type { ContentBlock } from "@modelcontextprotocol/sdk/types.js";
+import type { Context } from "hono";
+import type { useRest } from "../database/rest";
+
+/**
+ * MCP tool result — the Model Context Protocol `CallToolResult` shape.
+ * `exec` must return this (or a Promise of it).
+ */
+export type McpToolResult = {
+    content: ContentBlock[];
+    isError?: boolean;
+    structuredContent?: unknown;
+};
+
+/**
+ * MCP tool definition — auto-loaded from `{tenant.dir}/mcp/tools/**\/*.tool.ts`.
+ * Served over the MCP protocol at `GET/POST /mcp/:tenant_id` (Streamable HTTP).
+ */
+export type McpTool = {
+    _isMcpTool_?: boolean;
+    _tenant_?: string;
+    /** Tool name — unique per tenant (how the LLM calls it) */
+    name: string;
+    /** Short description shown to the LLM */
+    description?: string;
+    enabled?: boolean;
+    /** Joi schema describing the tool arguments (same language as collections — `v`) */
+    inputSchema: Joi.Schema;
+    /** Handler executed when the LLM calls the tool (args are Joi-validated).
+     * Must return the MCP protocol result shape: `{ content: [{ type, text | data… }] }`. */
+    exec: (ctx: {
+        c: Context;
+        rest: InstanceType<typeof useRest>;
+        /** Parsed & validated arguments */
+        args: Record<string, any>;
+    }) => McpToolResult | Promise<McpToolResult>;
+};
+
+/**
+ * MCP resource read result — the protocol `ReadResourceResult` shape.
+ * `contents` is an array of text or blob (base64) content blocks.
+ */
+export type McpResourceResult = {
+    contents: Array<{
+        uri: string;
+        mimeType?: string;
+        text?: string;
+        blob?: string;
+    }>;
+};
+
+/**
+ * MCP resource — read-only data exposed by URI (like a file the LLM can open).
+ * Auto-loaded from `{tenant.dir}/mcp/resources/**\/*.resource.ts`.
+ *
+ * The `uri` can be static (`orders://summary`) or a template
+ * (`users://{id}`) — template params are extracted and passed to `read`.
+ */
+export type McpResource = {
+    _isMcpResource_?: boolean;
+    _tenant_?: string;
+    /** Resource name — unique per tenant */
+    name: string;
+    /** Short description shown to the LLM */
+    description?: string;
+    enabled?: boolean;
+    /** Static URI (e.g. `orders://summary`) or template (e.g. `users://{id}`) */
+    uri: string;
+    /** Content type of the resource (default: application/json) */
+    mimeType?: string;
+    /** Handler called when the LLM reads the resource */
+    read: (ctx: {
+        c: Context;
+        rest: InstanceType<typeof useRest>;
+        /** Params extracted from the URI template (e.g. `{ id: '123' }`) */
+        params: Record<string, string>;
+        /** The exact URI the client requested */
+        uri: string;
+    }) => McpResourceResult | Promise<McpResourceResult>;
+};

package/types/scripts.d.ts

@@ -1,10 +1,23 @@
 import { useRest } from "../database/rest"
+import type { Tenant } from "./tenant"
 
 
 export type Script = {
     _isScript_?: boolean;
     enabled: boolean;
+    /**
+     * Run in a separate Bun process so heavy work (large JSON, long imports…)
+     * never blocks the HTTP server. The subprocess reconnects the tenant DB and
+     * rebuilds collection schemas automatically.
+     */
+    heavy?: boolean;
+    /** Max runtime in ms for heavy scripts (default: no timeout) */
+    timeout?: number;
     exec: (ctx: {
         rest: InstanceType<typeof useRest>
+        /** Report progress — only wired for heavy scripts (sent via IPC to the parent) */
+        progress?: (percent: number, info?: any) => void;
+        /** Tenant this script runs for */
+        tenant?: Tenant;
     }) => void
-}
+}

package/utils/cache.ts

@@ -50,6 +50,25 @@ class Cache {
             }
         })
     }
+
+    // ─── BentoCache provider API (delegated to the underlying instance) ───
+
+    set(options: any): Promise<boolean> { return this.#cache.set(options); }
+    setForever(options: any): Promise<boolean> { return this.#cache.setForever(options); }
+    get(options: any): Promise<unknown> { return this.#cache.get(options); }
+    getOrSet(options: any): Promise<unknown> { return this.#cache.getOrSet(options); }
+    getOrSetForever(options: any): Promise<unknown> { return this.#cache.getOrSetForever(options); }
+    has(options: any): Promise<boolean> { return this.#cache.has(options); }
+    missing(options: any): Promise<boolean> { return this.#cache.missing(options); }
+    pull(key: string): Promise<unknown> { return this.#cache.pull(key); }
+    delete(options: any): Promise<boolean> { return this.#cache.delete(options); }
+    deleteMany(options: any): Promise<boolean> { return this.#cache.deleteMany(options); }
+    deleteByTag(options: any): Promise<boolean> { return this.#cache.deleteByTag(options); }
+    expire(options: any): Promise<boolean> { return this.#cache.expire(options); }
+    clear(options?: any): Promise<void> { return this.#cache.clear(options); }
+    prune(): Promise<void> { return this.#cache.prune(); }
+    namespace(namespace: string): any { return this.#cache.namespace(namespace); }
+    disconnect(): Promise<void> { return this.#cache.disconnect(); }
 }
 
 
@@ -93,4 +112,4 @@ export {
     useFilesystemCache,
     useMemoryCache,
     useRedisCache
-}
+}

package/utils/crypto.ts

@@ -2,6 +2,20 @@ const IV_LENGTH = 12;
 const TAG_LENGTH = 16;
 const RSA_KEY_SIZE = 256;
 
+/**
+ * Build AES-GCM parameters with optional Additional Authenticated Data.
+ * AAD binds the ciphertext to its context (field/record/tenant) so a valid
+ * ciphertext cannot be swapped into another context (substitution attack).
+ */
+function gcmParams(iv: Uint8Array, aad?: string) {
+    return {
+        name: "AES-GCM" as const,
+        iv,
+        tagLength: TAG_LENGTH * 8,
+        ...(aad ? { additionalData: new TextEncoder().encode(aad) } : {}),
+    };
+}
+
 interface JsonWebKey {
     kty?: string;
     alg?: string;
@@ -43,12 +57,12 @@ class CryptSym {
         return this.#key;
     }
 
-    async encrypt(data: string | object): Promise<string> {
+    async encrypt(data: string | object, aad?: string): Promise<string> {
         const text = typeof data === "object" ? JSON.stringify(data) : data;
         const key = await this.#getKey();
         const iv = crypto.getRandomValues(new Uint8Array(IV_LENGTH));
         const encrypted = await crypto.subtle.encrypt(
-            { name: "AES-GCM", iv, tagLength: TAG_LENGTH * 8 },
+            gcmParams(iv, aad),
             key,
             new TextEncoder().encode(text)
         );
@@ -58,14 +72,17 @@ class CryptSym {
         return Buffer.from(buffer).toString("base64");
     }
 
-    async decrypt<T = string>(cipher: string, parseJson?: boolean): Promise<T> {
+    async decrypt<T = string>(cipher: string, parseJson?: boolean, aad?: string): Promise<T> {
         try {
             const buffer = new Uint8Array(Buffer.from(cipher, "base64"));
+            if (buffer.length < IV_LENGTH + TAG_LENGTH) {
+                throw new Error("ciphertext too short");
+            }
             const iv = buffer.slice(0, IV_LENGTH);
             const data = buffer.slice(IV_LENGTH);
             const key = await this.#getKey();
             const decrypted = await crypto.subtle.decrypt(
-                { name: "AES-GCM", iv, tagLength: TAG_LENGTH * 8 },
+                gcmParams(iv, aad),
                 key,
                 data
             );
@@ -131,7 +148,7 @@ class CryptAsym {
         return this.#keyPair;
     }
 
-    async encrypt(data: string | object, publicKey?: CryptoKey): Promise<string> {
+    async encrypt(data: string | object, publicKey?: CryptoKey, aad?: string): Promise<string> {
         const text = typeof data === "object" ? JSON.stringify(data) : data;
         const rsaKey = publicKey ?? (await this.#getKeyPair()).publicKey;
 
@@ -143,7 +160,7 @@ class CryptAsym {
 
         const iv = crypto.getRandomValues(new Uint8Array(IV_LENGTH));
         const encrypted = await crypto.subtle.encrypt(
-            { name: "AES-GCM", iv, tagLength: TAG_LENGTH * 8 },
+            gcmParams(iv, aad),
             aesKey,
             new TextEncoder().encode(text)
         );
@@ -162,7 +179,7 @@ class CryptAsym {
         return Buffer.from(result).toString("base64");
     }
 
-    async decrypt<T = string>(cipher: string, parseJson?: boolean): Promise<T> {
+    async decrypt<T = string>(cipher: string, parseJson?: boolean, aad?: string): Promise<T> {
         try {
             const buffer = new Uint8Array(Buffer.from(cipher, "base64"));
             if (buffer.length < RSA_KEY_SIZE + IV_LENGTH + TAG_LENGTH) {
@@ -189,7 +206,7 @@ class CryptAsym {
             );
 
             const decrypted = await crypto.subtle.decrypt(
-                { name: "AES-GCM", iv, tagLength: TAG_LENGTH * 8 },
+                gcmParams(iv, aad),
                 aesKey,
                 ciphertext
             );

package/utils/func.ts

@@ -19,15 +19,16 @@ const jwt = {
         audience?: string | string[];
         subject?: string;
     }) => {
-        let SECRET_ = cfg.server.jwt?.secret || Bun.env.JWT_SECRET
+        const SECRET_ = cfg.server.jwt?.secret || Bun.env.JWT_SECRET
         if (!SECRET_) throw new Error('JWT_SECRET is not set');
-        let EXPIRES_IN = cfg.server.jwt?.expiresIn || '1h'
+        // Per-call expiresIn wins over the global config (default: 7d)
+        const EXPIRES_IN = options?.expiresIn || cfg.server.jwt?.expiresIn || '7d'
 
         const secret = new TextEncoder().encode(SECRET_);
         const signer = new Jose.SignJWT(payload)
             .setProtectedHeader({ alg: 'HS256' })
             .setIssuedAt()
-            .setExpirationTime(EXPIRES_IN || '1h')
+            .setExpirationTime(EXPIRES_IN)
 
         if (options?.issuer) signer.setIssuer(options.issuer)
         if (options?.audience) signer.setAudience(options.audience)
@@ -36,7 +37,7 @@ const jwt = {
         const token = await signer.sign(secret);
         return token;
     },
-    verify: async (token: string): Promise<{ value: Record<string, unknown> | null, error: string | null }> => {
+    verify: async (token: string): Promise<{ value: Record<string, unknown> | null, error: string | null, expired: boolean }> => {
         try {
             if (!token) throw new Error('Token is required');
             let SECRET_ = cfg.server.jwt?.secret || Bun.env.JWT_SECRET
@@ -45,12 +46,17 @@ const jwt = {
             const { payload, protectedHeader } = await Jose.jwtVerify(token, secret);
             return {
                 value: payload,
-                error: null
+                error: null,
+                expired: false,
             }
-        } catch (error) {
+        } catch (error: any) {
+            // Reliable expiry detection via jose error code (not string matching)
+            const isExpired = error?.code === 'ERR_JWT_EXPIRED'
+                || /expired|expiration/i.test(error?.message ?? '');
             return {
                 value: null,
-                error: error instanceof Error ? error.message : 'Invalid token'
+                error: error instanceof Error ? error.message : 'Invalid token',
+                expired: isExpired,
             }
         }
     }
@@ -152,6 +158,48 @@ function pick<T extends DeepRecord>(data: T | T[], keys: string[]): Partial<T> |
     return result as Partial<T>;
 }
 
+/**
+ * Convertit la dot-notation MongoDB en structure imbriquée pour la validation Joi.
+ * Ex: { "address.zip": "BP28", "items.0.name": "x" } → { address: { zip }, items: [{ name }] }
+ * Les clés opérateurs ($inc, $push…) sont laissées telles quelles.
+ */
+function unflattenKeys(input: Record<string, unknown>): Record<string, unknown> {
+    const result: Record<string, unknown> = {};
+    for (const [key, value] of Object.entries(input)) {
+        // Opérateurs Mongo → laisser tel quel (interdits dans $set de toute façon)
+        if (key.startsWith('$')) {
+            result[key] = value;
+            continue;
+        }
+        const parts = key.split('.');
+        let target: any = result;
+        for (let i = 0; i < parts.length - 1; i++) {
+            const part = parts[i]!;
+            const nextPart = parts[i + 1]!;
+            const isArrayIndex = /^\d+$/.test(nextPart);
+            if (typeof target[part] !== 'object' || target[part] === null) {
+                target[part] = isArrayIndex ? [] : {};
+            }
+            target = target[part];
+        }
+        const last = parts[parts.length - 1]!;
+        // Fusion si les deux côtés sont des objets (ex. "a.b" + a: { c })
+        if (
+            target[last] &&
+            typeof target[last] === 'object' &&
+            !Array.isArray(target[last]) &&
+            typeof value === 'object' &&
+            value !== null &&
+            !Array.isArray(value)
+        ) {
+            target[last] = { ...(target[last] as object), ...(value as object) };
+        } else {
+            target[last] = value;
+        }
+    }
+    return result;
+}
+
 function toJson<T>(data: any): T {
     if (data === null || data === undefined) return data;
     try {
@@ -254,7 +302,14 @@ function isEpochNumber(value: number): boolean {
 }
 
 function deepCopy<T>(value: T): T {
-    return clone(value);
+    // structuredClone preserves Date / RegExp / Map / Set / typed arrays
+    // (clone() uses toJson, which JSON-serializes and loses those types).
+    // Falls back to clone() for values structuredClone cannot handle.
+    try {
+        return structuredClone(value);
+    } catch {
+        return clone(value);
+    }
 }
 
 type FormatToDateResult<T> = T extends string
@@ -645,12 +700,34 @@ function buildPipeline(p: FindOptions, options?: {
                 status: 400
             });
         }
+        // Faille 13: bound $regex (ReDoS) and $in/$nin (memory DoS)
+        boundMatchOperators(p.$match);
         pipeline.push({
             $match: p.$match
         })
     }
 
-    // $sort
+    // $sort — Faille 14: values must be 1 or -1
+    if (p?.$sort) {
+        for (const [key, dir] of Object.entries(p.$sort)) {
+            if (dir !== 1 && dir !== -1) {
+                throw new AppError(`Invalid $sort direction for '${key}' (expected 1 or -1)`, {
+                    code: 'INVALID_SORT_DIRECTION',
+                    status: 400
+                });
+            }
+        }
+    }
+
+    // $skip — Faille 14: must be a safe non-negative integer
+    if (p?.$skip !== undefined && p?.$skip !== null) {
+        if (!Number.isSafeInteger(p.$skip) || p.$skip < 0) {
+            throw new AppError('Invalid $skip (expected a non-negative integer)', {
+                code: 'INVALID_SKIP',
+                status: 400
+            });
+        }
+    }
     if (!p?.$sort?.createdAt) {
         pipeline.push({
             $sort: {
@@ -664,20 +741,25 @@ function buildPipeline(p: FindOptions, options?: {
         })
     }
 
-    // $skip
+    // $skip (validated above)
     if (p?.$skip) {
         pipeline.push({
             $skip: p.$skip
         })
     }
 
-    // $limit
+    // $limit — Faille 14: must be a safe integer in (0, MAX_LIMIT]; 0 would mean "no limit"
+    const MAX_LIMIT = 1000;
     p.$limit = p?.$limit ?? 100
-    if (p?.$limit > 0) {
-        pipeline.push({
-            $limit: p.$limit
-        })
+    if (!Number.isSafeInteger(p.$limit) || p.$limit <= 0 || p.$limit > MAX_LIMIT) {
+        throw new AppError(`Invalid $limit (expected an integer between 1 and ${MAX_LIMIT})`, {
+            code: 'INVALID_LIMIT',
+            status: 400
+        });
     }
+    pipeline.push({
+        $limit: p.$limit
+    })
 
     // $include
     if (p?.$include && Array.isArray(p?.$include)) {
@@ -742,6 +824,17 @@ function buildPipeline(p: FindOptions, options?: {
 
                 let as = include.as || include.localField
 
+                // Faille 3: never trust client-supplied $lookup sub-pipeline — scan it
+                if (include.pipeline && Array.isArray(include.pipeline)) {
+                    const check = isSafeAggregatePipeline(include.pipeline as Array<Record<string, unknown>>)
+                    if (!check.isSafe) {
+                        throw check.error ?? new AppError('Unauthorized $include pipeline', {
+                            code: 'UNAUTHORIZED_PIPELINE_KEYS',
+                            status: 400
+                        })
+                    }
+                }
+
                 pipeline.push({
                     $lookup: {
                         from: include.from,
@@ -807,6 +900,46 @@ function clone<T>(data: T): T {
     return data_
 }
 
+/**
+ * Faille 13: bounds dangerous $match operators to prevent ReDoS ($regex) and memory DoS ($in).
+ * Walks nested objects/arrays ($and, $or, $nor, dotted fields).
+ */
+const MAX_REGEX_LENGTH = 1000;
+const MAX_IN_ARRAY_SIZE = 10000;
+
+function boundMatchOperators(node: unknown): void {
+    if (node === null || node === undefined) return;
+
+    if (Array.isArray(node)) {
+        for (const item of node) {
+            boundMatchOperators(item);
+        }
+        return;
+    }
+
+    if (typeof node === 'object') {
+        const obj = node as Record<string, unknown>;
+        for (const [key, value] of Object.entries(obj)) {
+            if (key === '$regex' && typeof value === 'string') {
+                if (value.length > MAX_REGEX_LENGTH) {
+                    throw new AppError(`$regex pattern too long (max ${MAX_REGEX_LENGTH} chars)`, {
+                        code: 'REGEX_TOO_LONG',
+                        status: 400
+                    });
+                }
+            } else if ((key === '$in' || key === '$nin') && Array.isArray(value)) {
+                if (value.length > MAX_IN_ARRAY_SIZE) {
+                    throw new AppError(`$in/$nin too large (max ${MAX_IN_ARRAY_SIZE} items)`, {
+                        code: 'ARRAY_OPERATOR_TOO_LARGE',
+                        status: 400
+                    });
+                }
+            }
+            boundMatchOperators(value);
+        }
+    }
+}
+
 
 
 
@@ -1007,14 +1140,18 @@ function countAggregatePipelineStages(pipeline: unknown): number {
 }
 
 
-function isSafeAggregatePipeline(pipeline: Array<Record<string, unknown>>): {
+function isSafeAggregatePipeline(pipeline: Array<Record<string, unknown>>, allowedCollections?: string[]): {
     isSafe: boolean;
     forbiddenKeys: string[];
     error: AppError | null;
 } {
 
-    // Unauthorized pipeline keys
-    const UNAUTHORIZED_PIPELINE_KEYS = ['$out', '$merge', '$function', '$where', '$accumulator'];
+    // Unauthorized pipeline keys — Faille 12: include cross-collection exfiltration stages
+    const UNAUTHORIZED_PIPELINE_KEYS = [
+        '$out', '$merge', '$function', '$where', '$accumulator',
+        '$unionWith', '$collStats', '$indexStats', '$planCacheStats',
+        '$currentOp', '$listLocalSessions', '$listSessions', '$changeStream',
+    ];
     const forbiddenFound = hasUnauthorizedKeys(pipeline, UNAUTHORIZED_PIPELINE_KEYS);
     if (forbiddenFound.length > 0) {
         return {
@@ -1024,6 +1161,28 @@ function isSafeAggregatePipeline(pipeline: Array<Record<string, unknown>>): {
         }
     }
 
+    // Faille 12: restrict $lookup / $graphLookup targets to declared tenant collections
+    if (allowedCollections && allowedCollections.length > 0) {
+        const badTargets: string[] = [];
+        walkAggregatePipeline(pipeline, (stage) => {
+            const lookup = (stage as any).$lookup;
+            if (lookup?.from && !allowedCollections.includes(lookup.from)) {
+                badTargets.push(lookup.from);
+            }
+            const graph = (stage as any).$graphLookup;
+            if (graph?.from && !allowedCollections.includes(graph.from)) {
+                badTargets.push(graph.from);
+            }
+        });
+        if (badTargets.length > 0) {
+            return {
+                isSafe: false,
+                forbiddenKeys: badTargets,
+                error: new AppError('Unauthorized $lookup target collection: ' + [...new Set(badTargets)].join(', '), { code: 'UNAUTHORIZED_LOOKUP_TARGET', status: 400 })
+            };
+        }
+    }
+
     // $project avec renommage : racine + imbriqué ($facet, $lookup.pipeline, …)
     let renameForbiddenKeys: string[] = [];
     let renameError: AppError | null = null;
@@ -1066,6 +1225,7 @@ export {
     reorder,
     omit,
     pick,
+    unflattenKeys,
     toJson,
     stringToBoolean,
     cleanDeep,