libmodulor 0.18.1 → 0.20.0

package/dist/esm/target/lib/server-node/funcs.js

@@ -0,0 +1,25 @@
+export function listen(server, entrypointsBuilder, logger, settingsManager) {
+    const host = settingsManager.get()('server_binding_host');
+    const port = settingsManager.get()('server_binding_port');
+    server.listen(port, host, () => {
+        logger.info(`Listening on ${entrypointsBuilder.exec().http}`);
+    });
+}
+export async function stop(server) {
+    if (!server?.listening) {
+        return;
+    }
+    // As stated in the docs of `close`, only awaiting `.close` is not enough to make sure all the connections are closed.
+    // Hence the wrapping in a promise, where the callback is called when the 'close' event is emitted.
+    return new Promise((resolve, reject) => {
+        if (!server) {
+            return resolve();
+        }
+        server.close((err) => {
+            if (err) {
+                return reject(err);
+            }
+            resolve();
+        });
+    });
+}

package/dist/esm/target/lib/server-node/types.d.ts

@@ -1,3 +1,5 @@
 import type http from 'node:http';
 import type https from 'node:https';
+import type { ServerManagerSettings } from '../server/ServerManager.js';
 export type Server = http.Server | https.Server;
+export type ListenSettings = Pick<ServerManagerSettings, 'server_binding_host' | 'server_binding_port'>;

package/dist/esm/target/nextjs-server/NextJSServerManager.d.ts

@@ -5,7 +5,9 @@ import type { ServerManager } from '../lib/server/ServerManager.js';
 export declare class NextJSServerManager implements ServerManager {
     overrideUCManager(_ucManager: UCManager): void;
     init(): Promise<void>;
+    initSync(): void;
     mount<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(_appManifest: AppManifest, _ucd: UCDef<I, OPI0, OPI1>, _contract: UCHTTPContract): Promise<void>;
+    mountSync<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(_appManifest: AppManifest, _ucd: UCDef<I, OPI0, OPI1>, _contract: UCHTTPContract): void;
     mountStaticDir(_dirPath: DirPath): Promise<void>;
     start(): Promise<void>;
     stop(): Promise<void>;

package/dist/esm/target/nextjs-server/NextJSServerManager.js

@@ -12,9 +12,15 @@ let NextJSServerManager = class NextJSServerManager {
     async init() {
         // Nothing to do
     }
+    initSync() {
+        // Nothing to do
+    }
     async mount(_appManifest, _ucd, _contract) {
         // Nothing to do
     }
+    mountSync(_appManifest, _ucd, _contract) {
+        // Nothing to do
+    }
     async mountStaticDir(_dirPath) {
         // Nothing to do
     }

package/dist/esm/target/node-core-cli/NodeCoreCLIManager.d.ts

@@ -1,12 +1,14 @@
 import { WordingManager } from '../../i18n/index.js';
 import { ProductUCsLoader } from '../../product/index.js';
+import type { I18nManager } from '../../std/index.js';
 import type { CLIManager, Input, Output } from '../lib/cli/CLIManager.js';
 import { CommandExecutor } from '../lib/cli/CommandExecutor.js';
 export declare class NodeCoreCLIManager implements CLIManager {
     private commandExecutor;
+    private i18nManager;
     private productUCsLoader;
     private wordingManager;
-    constructor(commandExecutor: CommandExecutor, productUCsLoader: ProductUCsLoader, wordingManager: WordingManager);
+    constructor(commandExecutor: CommandExecutor, i18nManager: I18nManager, productUCsLoader: ProductUCsLoader, wordingManager: WordingManager);
     handleCommand({ appsRootPath, srcImporter, }: Input): Promise<Output>;
     private parseArgsConfig;
 }

package/dist/esm/target/node-core-cli/NodeCoreCLIManager.js

@@ -21,14 +21,17 @@ import { print } from '../lib/cli/renderer.js';
 import { showHelp } from './commands.js';
 let NodeCoreCLIManager = class NodeCoreCLIManager {
     commandExecutor;
+    i18nManager;
     productUCsLoader;
     wordingManager;
-    constructor(commandExecutor, productUCsLoader, wordingManager) {
+    constructor(commandExecutor, i18nManager, productUCsLoader, wordingManager) {
         this.commandExecutor = commandExecutor;
+        this.i18nManager = i18nManager;
         this.productUCsLoader = productUCsLoader;
         this.wordingManager = wordingManager;
     }
     async handleCommand({ appsRootPath, srcImporter, }) {
+        await this.i18nManager.init();
         const command = process.argv[2] ?? '';
         const ucs = await this.productUCsLoader.exec({
             appsRootPath,
@@ -84,10 +87,10 @@ let NodeCoreCLIManager = class NodeCoreCLIManager {
 NodeCoreCLIManager = __decorate([
     injectable(),
     __param(0, inject(CommandExecutor)),
-    __param(1, inject(ProductUCsLoader)),
-    __param(2, inject(WordingManager)),
-    __metadata("design:paramtypes", [CommandExecutor,
-        ProductUCsLoader,
+    __param(1, inject('I18nManager')),
+    __param(2, inject(ProductUCsLoader)),
+    __param(3, inject(WordingManager)),
+    __metadata("design:paramtypes", [CommandExecutor, Object, ProductUCsLoader,
         WordingManager])
 ], NodeCoreCLIManager);
 export { NodeCoreCLIManager };

package/dist/esm/target/node-express-server/NodeExpressServerManager.d.ts

@@ -7,8 +7,9 @@ import { EntrypointsBuilder } from '../lib/server/EntrypointsBuilder.js';
 import type { ServerManager, ServerManagerSettings } from '../lib/server/ServerManager.js';
 import { ServerRequestHandler } from '../lib/server/ServerRequestHandler.js';
 import { ServerSSLCertLoader } from '../lib/server/ServerSSLCertLoader.js';
-import { HelmetMiddlewareBuilder } from './middlewares/HelmetMiddlewareBuilder.js';
-type S = Pick<LoggerSettings, 'logger_level'> & Pick<ServerManagerSettings, 'server_binding_host' | 'server_binding_port' | 'server_tmp_path'>;
+import { HelmetMiddlewareBuilder } from '../lib/server-express/HelmetMiddlewareBuilder.js';
+import type { ListenSettings } from '../lib/server-node/types.js';
+type S = ListenSettings & Pick<LoggerSettings, 'logger_level'> & Pick<ServerManagerSettings, 'server_tmp_path'>;
 export declare class NodeExpressServerManager implements Configurable<S>, ServerManager {
     private entrypointsBuilder;
     protected environmentManager: EnvironmentManager;
@@ -25,14 +26,14 @@ export declare class NodeExpressServerManager implements Configurable<S>, Server
     getRuntime(): Express;
     overrideUCManager(ucManager: UCManager): void;
     init(): Promise<void>;
+    initSync(): void;
     mount<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(appManifest: AppManifest, ucd: UCDef<I, OPI0, OPI1>, contract: UCHTTPContract): Promise<void>;
+    mountSync<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(appManifest: AppManifest, ucd: UCDef<I, OPI0, OPI1>, contract: UCHTTPContract): void;
     mountStaticDir(dirPath: DirPath): Promise<void>;
     start(): Promise<void>;
     stop(): Promise<void>;
     warmUp(): Promise<void>;
     private createServer;
-    private toFile;
-    private toReq;
-    private toRes;
+    private mountCommon;
 }
 export {};

package/dist/esm/target/node-express-server/NodeExpressServerManager.js

@@ -12,15 +12,15 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 import http from 'node:http';
 import https from 'node:https';
-import cookieParser from 'cookie-parser';
 import express, {} from 'express';
-import fileUpload from 'express-fileupload';
 import { inject, injectable } from 'inversify';
+import { NotCallableError } from '../../error/index.js';
 import { EntrypointsBuilder } from '../lib/server/EntrypointsBuilder.js';
-import { ServerRequestHandler, } from '../lib/server/ServerRequestHandler.js';
+import { ServerRequestHandler } from '../lib/server/ServerRequestHandler.js';
 import { ServerSSLCertLoader } from '../lib/server/ServerSSLCertLoader.js';
-import { stop } from '../lib/server-node/stop.js';
-import { HelmetMiddlewareBuilder } from './middlewares/HelmetMiddlewareBuilder.js';
+import { buildHandler, init, mountHandler, } from '../lib/server-express/funcs.js';
+import { HelmetMiddlewareBuilder } from '../lib/server-express/HelmetMiddlewareBuilder.js';
+import { listen, stop } from '../lib/server-node/funcs.js';
 let NodeExpressServerManager = class NodeExpressServerManager {
     entrypointsBuilder;
     environmentManager;
@@ -60,53 +60,23 @@ let NodeExpressServerManager = class NodeExpressServerManager {
         this.ucManager = ucManager;
     }
     async init() {
-        this.runtime = express();
-        this.runtime.use(this.helmetMB.exec({}));
-        // TODO : Add FileStorageManager (Local, S3, FSBucket)
-        // Right now, the files are only stored locally. We need more flexibility. Maybe we can also install https://imgproxy.net.
-        this.runtime.use(fileUpload({
-            createParentPath: true,
-            debug: this.s().logger_level === 'trace',
-            tempFileDir: this.s().server_tmp_path,
-            useTempFiles: true,
-        }));
-        this.runtime.use(express.json());
-        this.runtime.use(express.urlencoded({ extended: true }));
-        this.runtime.use(cookieParser());
+        this.runtime = init(this.helmetMB, this.s().logger_level, this.s().server_tmp_path);
         await this.createServer();
     }
+    initSync() {
+        throw new NotCallableError('initSync', 'init', 'async-only');
+    }
     async mount(appManifest, ucd, contract) {
-        const { envelope, method, path, pathAliases } = contract;
-        const httpMethod = method.toLowerCase();
-        const handler = async (req, res) => {
-            const { body, status } = await this.serverRequestHandler.exec({
-                appManifest,
-                envelope,
-                req: this.toReq(req),
-                res: this.toRes(res),
-                ucd,
-                ucManager: this.ucManager,
-            });
-            if (!body) {
-                res.status(status).send();
-                return;
-            }
-            res.status(status).send(body);
-        };
-        this.runtime[httpMethod](path, handler);
-        for (const pathAlias of pathAliases) {
-            this.runtime[httpMethod](pathAlias, handler);
-        }
+        this.mountCommon(appManifest, ucd, contract);
+    }
+    mountSync(appManifest, ucd, contract) {
+        this.mountCommon(appManifest, ucd, contract);
     }
     async mountStaticDir(dirPath) {
         this.runtime.use(express.static(dirPath));
     }
     async start() {
-        const host = this.s().server_binding_host;
-        const port = this.s().server_binding_port;
-        this.server.listen(port, host, () => {
-            this.logger.info(`Listening on ${this.entrypointsBuilder.exec().http}`);
-        });
+        listen(this.server, this.entrypointsBuilder, this.logger, this.settingsManager);
     }
     async stop() {
         await stop(this.server);
@@ -125,65 +95,8 @@ let NodeExpressServerManager = class NodeExpressServerManager {
         const credentials = await this.serverSSLCertLoader.exec(undefined);
         this.server = https.createServer(credentials, this.runtime);
     }
-    toFile(f) {
-        return {
-            name: f.name,
-            path: f.tempFilePath,
-            type: f.mimetype,
-        };
-    }
-    toReq(req) {
-        return {
-            bodyFromFormData: async () => {
-                // Since express v5, if the request contains only a file, the `req.body` returns `undefined`
-                const input = req.body ?? {};
-                // files is present when using express-fileupload
-                if ('files' in req && req.files) {
-                    for (const [field, value] of Object.entries(req.files)) {
-                        input[field] = Array.isArray(value)
-                            ? value.map(this.toFile)
-                            : this.toFile(value);
-                    }
-                }
-                for (const [k, v] of Object.entries(input)) {
-                    const isMultiple = k.endsWith('[]'); // e.g. 'tags[]': 'Electronic'
-                    const key = isMultiple ? k.replaceAll('[]', '') : k;
-                    if (isMultiple) {
-                        input[key] = Array.isArray(v) ? v : [v];
-                    }
-                    else {
-                        input[key] = v;
-                    }
-                }
-                return input;
-            },
-            bodyFromJSON: async () => req.body,
-            bodyFromQueryParams: async () => req.query,
-            bodyRaw: req.body,
-            cookie: (name) => req.cookies[name],
-            header: async (name) => {
-                const h = req.headers[name.toLowerCase()];
-                if (Array.isArray(h)) {
-                    this.logger.warn(`Multiple headers found for ${name}. Returning the first one.`);
-                    return h[0];
-                }
-                return h;
-            },
-            method: req.method,
-            secure: req.secure,
-            url: req.url,
-        };
-    }
-    toRes(res) {
-        return {
-            clearCookie: async (name) => {
-                res.clearCookie(name);
-            },
-            redirect: async (location) => res.redirect(location),
-            setCookie: async ({ name, opts, val }) => {
-                res.cookie(name, val, opts);
-            },
-        };
+    mountCommon(appManifest, ucd, contract) {
+        mountHandler(contract, this.runtime, buildHandler(appManifest, ucd, contract, this.serverRequestHandler, this.ucManager));
     }
 };
 NodeExpressServerManager = __decorate([

package/dist/esm/target/node-hono-server/NodeHonoServerManager.d.ts

@@ -1,13 +1,14 @@
-import { Hono } from 'hono';
+import type { Hono } from 'hono';
 import type { AppManifest } from '../../app/index.js';
 import type { DirPath } from '../../dt/index.js';
 import type { Configurable, EnvironmentManager, Logger, SettingsManager } from '../../std/index.js';
 import type { UCDef, UCHTTPContract, UCInput, UCManager, UCOPIBase } from '../../uc/index.js';
 import { EntrypointsBuilder } from '../lib/server/EntrypointsBuilder.js';
-import type { ServerManager, ServerManagerSettings } from '../lib/server/ServerManager.js';
+import type { ServerManager } from '../lib/server/ServerManager.js';
 import { ServerRequestHandler } from '../lib/server/ServerRequestHandler.js';
 import { ServerSSLCertLoader } from '../lib/server/ServerSSLCertLoader.js';
-type S = Pick<ServerManagerSettings, 'server_binding_host' | 'server_binding_port'>;
+import type { ListenSettings } from '../lib/server-node/types.js';
+type S = ListenSettings;
 export declare class NodeHonoServerManager implements Configurable<S>, ServerManager {
     private entrypointsBuilder;
     protected environmentManager: EnvironmentManager;
@@ -23,13 +24,14 @@ export declare class NodeHonoServerManager implements Configurable<S>, ServerMan
     getRuntime(): Hono;
     overrideUCManager(ucManager: UCManager): void;
     init(): Promise<void>;
+    initSync(): void;
     mount<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(appManifest: AppManifest, ucd: UCDef<I, OPI0, OPI1>, contract: UCHTTPContract): Promise<void>;
+    mountSync<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(appManifest: AppManifest, ucd: UCDef<I, OPI0, OPI1>, contract: UCHTTPContract): void;
     mountStaticDir(dirPath: DirPath): Promise<void>;
     start(): Promise<void>;
     stop(): Promise<void>;
     warmUp(): Promise<void>;
     private createServer;
-    private toReq;
-    private toRes;
+    mountCommon<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(appManifest: AppManifest, ucd: UCDef<I, OPI0, OPI1>, contract: UCHTTPContract): void;
 }
 export {};

package/dist/esm/target/node-hono-server/NodeHonoServerManager.js

@@ -12,18 +12,15 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 import http from 'node:http';
 import https from 'node:https';
-import { createAdaptorServer, } from '@hono/node-server';
+import { createAdaptorServer } from '@hono/node-server';
 import { serveStatic } from '@hono/node-server/serve-static';
-import { Hono } from 'hono';
-import { deleteCookie, getCookie, setCookie } from 'hono/cookie';
-import { logger } from 'hono/logger';
-import { secureHeaders } from 'hono/secure-headers';
 import { inject, injectable } from 'inversify';
-import { fromFormData } from '../../utils/index.js';
+import { NotCallableError } from '../../error/index.js';
 import { EntrypointsBuilder } from '../lib/server/EntrypointsBuilder.js';
-import { ServerRequestHandler, } from '../lib/server/ServerRequestHandler.js';
+import { ServerRequestHandler } from '../lib/server/ServerRequestHandler.js';
 import { ServerSSLCertLoader } from '../lib/server/ServerSSLCertLoader.js';
-import { stop } from '../lib/server-node/stop.js';
+import { buildHandler, init, mountHandler } from '../lib/server-hono/funcs.js';
+import { listen, stop } from '../lib/server-node/funcs.js';
 let NodeHonoServerManager = class NodeHonoServerManager {
     entrypointsBuilder;
     environmentManager;
@@ -59,50 +56,23 @@ let NodeHonoServerManager = class NodeHonoServerManager {
         this.ucManager = ucManager;
     }
     async init() {
-        this.runtime = new Hono();
-        this.runtime.use(secureHeaders());
-        this.runtime.use(logger());
-        this.runtime.notFound((c) => {
-            return c.json({}, 404);
-        });
+        this.runtime = init();
         await this.createServer();
     }
+    initSync() {
+        throw new NotCallableError('initSync', 'init', 'async-only');
+    }
     async mount(appManifest, ucd, contract) {
-        const { envelope, method, path, pathAliases } = contract;
-        const httpMethod = method.toLowerCase();
-        if (httpMethod === 'connect' ||
-            httpMethod === 'head' ||
-            httpMethod === 'trace') {
-            throw new Error(`Unsupported HTTP method : ${httpMethod}`);
-        }
-        const handler = async (c) => {
-            const { body, status } = await this.serverRequestHandler.exec({
-                appManifest,
-                envelope,
-                req: this.toReq(c),
-                res: this.toRes(c),
-                ucd,
-                ucManager: this.ucManager,
-            });
-            if (!body) {
-                return c.newResponse(null, status);
-            }
-            return c.json(body, status);
-        };
-        this.runtime[httpMethod](path, handler);
-        for (const pathAlias of pathAliases) {
-            this.runtime[httpMethod](pathAlias, handler);
-        }
+        this.mountCommon(appManifest, ucd, contract);
+    }
+    mountSync(appManifest, ucd, contract) {
+        this.mountCommon(appManifest, ucd, contract);
     }
     async mountStaticDir(dirPath) {
         this.runtime.use(serveStatic({ root: dirPath }));
     }
     async start() {
-        const host = this.s().server_binding_host;
-        const port = this.s().server_binding_port;
-        this.server.listen(port, host, () => {
-            this.logger.info(`Listening on ${this.entrypointsBuilder.exec().http}`);
-        });
+        listen(this.server, this.entrypointsBuilder, this.logger, this.settingsManager);
     }
     async stop() {
         await stop(this.server);
@@ -129,29 +99,8 @@ let NodeHonoServerManager = class NodeHonoServerManager {
         opts.serverOptions = await this.serverSSLCertLoader.exec(undefined);
         this.server = createAdaptorServer(opts);
     }
-    toReq(c) {
-        return {
-            bodyFromFormData: async () => fromFormData(await c.req.formData()),
-            bodyFromJSON: () => c.req.json(),
-            bodyFromQueryParams: async () => c.req.queries(),
-            bodyRaw: c.req.raw,
-            cookie: async (name) => getCookie(c, name),
-            header: async (name) => c.req.header(name),
-            method: c.req.method,
-            secure: c.req.url.startsWith('https://'),
-            url: c.req.url,
-        };
-    }
-    toRes(c) {
-        return {
-            clearCookie: async (name) => {
-                deleteCookie(c, name);
-            },
-            redirect: async (location) => {
-                c.redirect(location);
-            },
-            setCookie: async ({ name, opts, val }) => setCookie(c, name, val, opts),
-        };
+    mountCommon(appManifest, ucd, contract) {
+        mountHandler(contract, this.runtime, buildHandler(appManifest, ucd, contract, this.serverRequestHandler, this.ucManager));
     }
 };
 NodeHonoServerManager = __decorate([

package/dist/esm/target/node-mcp-server/NodeLocalStdioMCPServerManager.d.ts

@@ -31,12 +31,16 @@ export declare class NodeLocalStdioMCPServerManager implements Configurable<S>,
     s(): S;
     overrideUCManager(ucManager: UCManager): void;
     init(): Promise<void>;
-    mount<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(appManifest: AppManifest, ucd: UCDef<I, OPI0, OPI1>, _contract: UCHTTPContract): Promise<void>;
+    initSync(): void;
+    mount<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(appManifest: AppManifest, ucd: UCDef<I, OPI0, OPI1>, contract: UCHTTPContract): Promise<void>;
+    mountSync<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(appManifest: AppManifest, ucd: UCDef<I, OPI0, OPI1>, contract: UCHTTPContract): void;
     mountStaticDir(_dirPath: DirPath): Promise<void>;
     start(): Promise<void>;
     stop(): Promise<void>;
     warmUp(): Promise<void>;
     private buildInputSchema;
     private execRequest;
+    private initCommon;
+    mountCommon<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(appManifest: AppManifest, ucd: UCDef<I, OPI0, OPI1>, _contract: UCHTTPContract): void;
 }
 export {};

package/dist/esm/target/node-mcp-server/NodeLocalStdioMCPServerManager.js

@@ -14,6 +14,7 @@ import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
 import { inject, injectable } from 'inversify';
+import { NotAvailableError } from '../../error/index.js';
 import { WordingManager } from '../../i18n/index.js';
 import { UCBuilder, ucifIsMandatory, ucMountingPoint, } from '../../uc/index.js';
 import { propertyType, resError, resObj } from './funcs.js';
@@ -55,38 +56,19 @@ let NodeLocalStdioMCPServerManager = class NodeLocalStdioMCPServerManager {
         this.ucManager = ucManager;
     }
     async init() {
-        this.runtime = new Server({
-            name: this.productManifest.name,
-            version: '0.1.0',
-        }, {
-            capabilities: {
-                tools: {},
-            },
-        });
-        if (this.s().logger_level !== 'error') {
-            const message = 'Set the logging_level to "error" as MCP does not want the server to log to stdout (see https://modelcontextprotocol.io/docs/tools/debugging#implementing-logging)';
-            // Depending on the `Logger` implementation, this.logger.error() might not write to stderr (e.g. can write to a file).
-            // That's why we explicitly write to stdout by calling console.error().
-            // biome-ignore lint/suspicious/noConsole: we want it
-            console.error(new Error(message));
-        }
+        this.initCommon();
     }
-    async mount(appManifest, ucd, _contract) {
-        const uc = this.ucBuilder.exec({
-            appManifest,
-            auth: null,
-            def: ucd,
-        });
-        if (!this.appManifests.has(appManifest.name)) {
-            this.appManifests.set(appManifest.name, appManifest);
-        }
-        const inputSchema = this.buildInputSchema(uc);
-        const mountingPoint = uc.def.ext?.cmd?.mountAt ?? ucMountingPoint(uc);
-        const tool = { inputSchema, name: mountingPoint };
-        this.tools.set(mountingPoint, { appName: appManifest.name, tool, ucd });
+    initSync() {
+        this.initCommon();
+    }
+    async mount(appManifest, ucd, contract) {
+        this.mountCommon(appManifest, ucd, contract);
+    }
+    mountSync(appManifest, ucd, contract) {
+        this.mountCommon(appManifest, ucd, contract);
     }
     async mountStaticDir(_dirPath) {
-        throw new Error('Method not implemented.');
+        throw new NotAvailableError('mountStaticDir');
     }
     async start() {
         this.transport = new StdioServerTransport();
@@ -156,6 +138,37 @@ let NodeLocalStdioMCPServerManager = class NodeLocalStdioMCPServerManager {
             return resError(err);
         }
     }
+    initCommon() {
+        this.runtime = new Server({
+            name: this.productManifest.name,
+            version: '0.1.0',
+        }, {
+            capabilities: {
+                tools: {},
+            },
+        });
+        if (this.s().logger_level !== 'error') {
+            const message = 'Set the logging_level to "error" as MCP does not want the server to log to stdout (see https://modelcontextprotocol.io/docs/tools/debugging#implementing-logging)';
+            // Depending on the `Logger` implementation, this.logger.error() might not write to stderr (e.g. can write to a file).
+            // That's why we explicitly write to stdout by calling console.error().
+            // biome-ignore lint/suspicious/noConsole: we want it
+            console.error(new Error(message));
+        }
+    }
+    mountCommon(appManifest, ucd, _contract) {
+        const uc = this.ucBuilder.exec({
+            appManifest,
+            auth: null,
+            def: ucd,
+        });
+        if (!this.appManifests.has(appManifest.name)) {
+            this.appManifests.set(appManifest.name, appManifest);
+        }
+        const inputSchema = this.buildInputSchema(uc);
+        const mountingPoint = uc.def.ext?.cmd?.mountAt ?? ucMountingPoint(uc);
+        const tool = { inputSchema, name: mountingPoint };
+        this.tools.set(mountingPoint, { appName: appManifest.name, tool, ucd });
+    }
 };
 NodeLocalStdioMCPServerManager = __decorate([
     injectable(),

package/dist/esm/testing/AppTester.d.ts

@@ -1,7 +1,7 @@
 import type { FilePath } from '../dt/index.js';
 import type { ServerClientManagerSettings } from '../target/lib/client/ServerClientManager.js';
 import type { ServerManager } from '../target/lib/server/ServerManager.js';
-import { type UCAuth, UCBuilder, type UCDef, type UCInput, type UCOPIBase } from '../uc/index.js';
+import { type UCAuth, UCBuilder, type UCDef, type UCInput, type UCName, type UCOPIBase } from '../uc/index.js';
 import type { SrcImporter } from '../utils/index.js';
 import type { AppTesterConfigurator } from './AppTesterConfigurator.js';
 import type { AppTesterCtx, AppTesterUCDRef } from './ctx.js';
@@ -50,6 +50,7 @@ export declare class AppTester {
      * This can happen in case of circular dependencies for example.
      */
     private safeSrcImporter;
+    private ucds;
     private testResults;
     private testSummary;
     private ucDefSourcesCheckerOutput;
@@ -59,13 +60,15 @@ export declare class AppTester {
     checkAppIndex(): Promise<void>;
     checkAppManifest(): Promise<void>;
     checkUCDSources(): Promise<void>;
-    checkUC(ucdRef: AppTesterUCDRef): Promise<UCDef>;
+    checkUC(ucdRef: AppTesterUCDRef): Promise<void>;
     execFlow(flow: AppTesterFlow): Promise<AppTesterFlowExecOutput>;
     execMonkeyTest<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(ucd: UCDef<I, OPI0, OPI1>, input: I): Promise<UCExecutorExecOutput<I, OPI0, OPI1>>;
     execUC<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(input: Omit<UCExecutorInput<I, OPI0, OPI1>, 'appManifest'>, flow?: AppTesterFlow): Promise<AppTestSuiteTestResult<I, OPI0, OPI1>>;
     finalize(): Promise<void>;
     getCtx(): AppTesterCtx;
+    getUCD<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(ucName: UCName): UCDef<I, OPI0, OPI1>;
     init({ appPath, configurator, serverClientSettings, srcImporter, }: AppTesterInitArgs): Promise<void>;
+    initForUCExec(): Promise<void>;
     ucTestData(ucdRef: AppTesterUCDRef): Promise<AppTesterUCTestData[]>;
     private bindI18n;
     private bindServerClientSettings;