libmodulor 0.1.0 → 0.3.0

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

@@ -0,0 +1,18 @@
+import type { RequestHandler } from 'express';
+import type { Configurable, SettingsManager, Worker } from '../../../std/index.js';
+import type { UCSec } from '../../../uc/index.js';
+import { PublicApiKeyChecker } from '../../lib/server/PublicApiKeyChecker.js';
+import type { ServerManagerSettings } from '../../lib/server/ServerManager.js';
+interface Input {
+    checkType: UCSec['publicApiKeyCheckType'];
+}
+type Output = RequestHandler;
+type S = Pick<ServerManagerSettings, 'server_public_api_key_header_name'>;
+export declare class PublicApiKeyCheckerMiddlewareBuilder implements Configurable<S>, Worker<Input, Output> {
+    private publicApiKeyChecker;
+    private settingsManager;
+    constructor(publicApiKeyChecker: PublicApiKeyChecker, settingsManager: SettingsManager<S>);
+    s(): S;
+    exec({ checkType }: Input): Output;
+}
+export {};

package/dist/esm/target/node-express-server/middlewares/PublicApiKeyCheckerMiddlewareBuilder.js

@@ -0,0 +1,49 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { inject, injectable } from 'inversify';
+import { PublicApiKeyChecker } from '../../lib/server/PublicApiKeyChecker.js';
+let PublicApiKeyCheckerMiddlewareBuilder = class PublicApiKeyCheckerMiddlewareBuilder {
+    publicApiKeyChecker;
+    settingsManager;
+    constructor(publicApiKeyChecker, settingsManager) {
+        this.publicApiKeyChecker = publicApiKeyChecker;
+        this.settingsManager = settingsManager;
+    }
+    s() {
+        return {
+            server_public_api_key_header_name: this.settingsManager.get()('server_public_api_key_header_name'),
+        };
+    }
+    exec({ checkType }) {
+        return async (req, _res, nextFn) => {
+            try {
+                const value = req.header(this.s().server_public_api_key_header_name);
+                await this.publicApiKeyChecker.exec({
+                    checkType,
+                    value,
+                });
+                nextFn();
+            }
+            catch (err) {
+                nextFn(err);
+            }
+        };
+    }
+};
+PublicApiKeyCheckerMiddlewareBuilder = __decorate([
+    injectable(),
+    __param(0, inject(PublicApiKeyChecker)),
+    __param(1, inject('SettingsManager')),
+    __metadata("design:paramtypes", [PublicApiKeyChecker, Object])
+], PublicApiKeyCheckerMiddlewareBuilder);
+export { PublicApiKeyCheckerMiddlewareBuilder };

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

@@ -0,0 +1,12 @@
+import type { RequestHandler } from 'express';
+import type { Worker } from '../../../std/index.js';
+import { RequestChecker } from '../../lib/server/RequestChecker.js';
+interface Input {
+}
+type Output = RequestHandler;
+export declare class RequestCheckerMiddlewareBuilder implements Worker<Input, Output> {
+    private requestChecker;
+    constructor(requestChecker: RequestChecker);
+    exec(_input: Input): Output;
+}
+export {};

package/dist/esm/target/node-express-server/middlewares/RequestCheckerMiddlewareBuilder.js

@@ -0,0 +1,41 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { inject, injectable } from 'inversify';
+import { RequestChecker } from '../../lib/server/RequestChecker.js';
+let RequestCheckerMiddlewareBuilder = class RequestCheckerMiddlewareBuilder {
+    requestChecker;
+    constructor(requestChecker) {
+        this.requestChecker = requestChecker;
+    }
+    exec(_input) {
+        return (req, _res, nextFn) => {
+            try {
+                this.requestChecker.exec({
+                    secure: req.secure,
+                    url: req.url,
+                    xForwardedProtoHeader: req.get('X-Forwarded-Proto'),
+                });
+                nextFn();
+            }
+            catch (err) {
+                nextFn(err);
+            }
+        };
+    }
+};
+RequestCheckerMiddlewareBuilder = __decorate([
+    injectable(),
+    __param(0, inject(RequestChecker)),
+    __metadata("design:paramtypes", [RequestChecker])
+], RequestCheckerMiddlewareBuilder);
+export { RequestCheckerMiddlewareBuilder };

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

@@ -0,0 +1,23 @@
+import type { RequestHandler } from 'express';
+import type { Configurable, SettingsManager, Worker } from '../../../std/index.js';
+import { UCBuilder, type UCInput, type UCOPIBase } from '../../../uc/index.js';
+import type { RequestHandlerInputRaw } from '../../lib/server/RequestHandler.js';
+import type { ServerManagerSettings } from '../../lib/server/ServerManager.js';
+import { AuthCookieCreator } from '../lib/AuthCookieCreator.js';
+type Input<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> = RequestHandlerInputRaw<I, OPI0, OPI1>;
+type Output = RequestHandler;
+type S = Pick<ServerManagerSettings, 'server_cookies_name_auth'>;
+export declare class RequestHandlerMiddlewareBuilder<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> implements Configurable<S>, Worker<Input<I, OPI0, OPI1>, Output> {
+    private authCookieCreator;
+    private settingsManager;
+    private ucBuilder;
+    constructor(authCookieCreator: AuthCookieCreator, settingsManager: SettingsManager<S>, ucBuilder: UCBuilder);
+    s(): S;
+    exec({ appManifest, envelope, ucd, ucManager, }: Input<I, OPI0, OPI1>): Output;
+    private fillUCFromReq;
+    private handleClearAuth;
+    private handleRedirect;
+    private handleSetAuth;
+    private toFile;
+}
+export {};

package/dist/esm/target/node-express-server/middlewares/RequestHandlerMiddlewareBuilder.js

@@ -0,0 +1,151 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { inject, injectable } from 'inversify';
+import { UCBuilder, UCOutputReader, UCOutputSideEffectType, } from '../../../uc/index.js';
+import { AuthCookieCreator } from '../lib/AuthCookieCreator.js';
+import { isReqAuthenticated } from './AuthenticationCheckerMiddlewareBuilder.js';
+let RequestHandlerMiddlewareBuilder = class RequestHandlerMiddlewareBuilder {
+    authCookieCreator;
+    settingsManager;
+    ucBuilder;
+    constructor(authCookieCreator, settingsManager, ucBuilder) {
+        this.authCookieCreator = authCookieCreator;
+        this.settingsManager = settingsManager;
+        this.ucBuilder = ucBuilder;
+    }
+    s() {
+        return {
+            server_cookies_name_auth: this.settingsManager.get()('server_cookies_name_auth'),
+        };
+    }
+    exec({ appManifest, envelope, ucd, ucManager, }) {
+        return async (req, res, nextFn) => {
+            try {
+                const uc = this.ucBuilder.exec({
+                    appManifest,
+                    auth: null,
+                    def: ucd,
+                });
+                if (isReqAuthenticated(req)) {
+                    uc.auth = req.auth;
+                }
+                this.fillUCFromReq(req, envelope, uc);
+                const output = await ucManager.execServer(uc);
+                const { ext, io } = ucd;
+                const sideEffects = io.o?.sideEffects;
+                if (sideEffects) {
+                    const ucor = new UCOutputReader(uc.def, output ?? undefined);
+                    let item;
+                    if (ucor.canItem00()) {
+                        item = ucor.item00().item;
+                    }
+                    for (const se of sideEffects) {
+                        const { type } = se;
+                        switch (type) {
+                            case UCOutputSideEffectType.CLEAR_AUTH:
+                                await this.handleClearAuth(res);
+                                break;
+                            case UCOutputSideEffectType.REDIRECT:
+                                await this.handleRedirect(res, item);
+                                return;
+                            case UCOutputSideEffectType.SET_AUTH:
+                                await this.handleSetAuth(res, item);
+                                break;
+                            default:
+                                ((_) => { })(type);
+                        }
+                    }
+                }
+                if (!output) {
+                    res.status(204).send();
+                    return;
+                }
+                const transform = ext?.http?.transform;
+                res.send(output && transform ? transform(output) : output);
+            }
+            catch (err) {
+                nextFn(err);
+            }
+        };
+    }
+    fillUCFromReq(req, envelope, uc) {
+        switch (envelope) {
+            case 'form-data': {
+                const input = req.body;
+                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);
+                    }
+                }
+                const sanitized = {};
+                for (const [k, v] of Object.entries(input)) {
+                    const sanitizedKey = k.split('[')[0];
+                    if (!sanitizedKey) {
+                        continue;
+                    }
+                    sanitized[sanitizedKey] = v;
+                    if (k.includes('[') && !Array.isArray(v)) {
+                        sanitized[sanitizedKey] = [v];
+                    }
+                }
+                uc.fill(sanitized);
+                break;
+            }
+            case 'json':
+                uc.fill(req.body);
+                break;
+            case 'query-params':
+                uc.fill(req.query);
+                break;
+        }
+    }
+    async handleClearAuth(res) {
+        res.clearCookie(this.s().server_cookies_name_auth);
+    }
+    async handleRedirect(res, item) {
+        if (!item ||
+            !('redirect' in item) ||
+            typeof item['redirect'] !== 'string') {
+            return;
+        }
+        const { redirect } = item;
+        res.redirect(redirect);
+    }
+    async handleSetAuth(res, item) {
+        if (!item || !('jwt' in item) || typeof item['jwt'] !== 'string') {
+            return;
+        }
+        const { jwt } = item;
+        const { name, opts, val } = await this.authCookieCreator.exec({
+            jwt,
+        });
+        res.cookie(name, val, opts);
+    }
+    toFile(f) {
+        return {
+            name: f.name,
+            path: f.tempFilePath,
+            type: f.mimetype,
+        };
+    }
+};
+RequestHandlerMiddlewareBuilder = __decorate([
+    injectable(),
+    __param(0, inject(AuthCookieCreator)),
+    __param(1, inject('SettingsManager')),
+    __param(2, inject(UCBuilder)),
+    __metadata("design:paramtypes", [AuthCookieCreator, Object, UCBuilder])
+], RequestHandlerMiddlewareBuilder);
+export { RequestHandlerMiddlewareBuilder };

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

@@ -0,0 +1,13 @@
+import type { RequestHandler } from 'express';
+import type { Logger, Worker } from '../../../std/index.js';
+import { RequestLogger } from '../../lib/server/RequestLogger.js';
+interface Input {
+}
+type Output = RequestHandler;
+export declare class RequestLoggerMiddlewareBuilder implements Worker<Input, Output> {
+    private logger;
+    private requestLogger;
+    constructor(logger: Logger, requestLogger: RequestLogger);
+    exec(_input: Input): Output;
+}
+export {};

package/dist/esm/target/node-express-server/middlewares/RequestLoggerMiddlewareBuilder.js

@@ -0,0 +1,45 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { inject, injectable } from 'inversify';
+import { RequestLogger } from '../../lib/server/RequestLogger.js';
+let RequestLoggerMiddlewareBuilder = class RequestLoggerMiddlewareBuilder {
+    logger;
+    requestLogger;
+    constructor(logger, requestLogger) {
+        this.logger = logger;
+        this.requestLogger = requestLogger;
+    }
+    exec(_input) {
+        return (req, _, nextFn) => {
+            try {
+                this.requestLogger.exec({
+                    body: req.body,
+                    method: req.method,
+                    url: req.url,
+                });
+                nextFn();
+            }
+            catch (err) {
+                this.logger.error(err);
+                nextFn();
+            }
+        };
+    }
+};
+RequestLoggerMiddlewareBuilder = __decorate([
+    injectable(),
+    __param(0, inject('Logger')),
+    __param(1, inject(RequestLogger)),
+    __metadata("design:paramtypes", [Object, RequestLogger])
+], RequestLoggerMiddlewareBuilder);
+export { RequestLoggerMiddlewareBuilder };

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

@@ -0,0 +1,32 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import type { AppManifest } from '../../app/index.js';
+import type { DirPath } from '../../dt/index.js';
+import { WordingManager } from '../../i18n/index.js';
+import type { ProductManifest } from '../../product/index.js';
+import type { Configurable, LoggerSettings, SettingsManager } from '../../std/index.js';
+import { UCBuilder, type UCDef, type UCHTTPContract, type UCInput, type UCManager, type UCOPIBase } from '../../uc/index.js';
+import type { ServerManager } from '../lib/server/ServerManager.js';
+type S = Pick<LoggerSettings, 'logger_level'>;
+export declare class NodeLocalStdioMCPServerManager implements Configurable<S>, ServerManager {
+    private productManifest;
+    private settingsManager;
+    private ucBuilder;
+    private ucManager;
+    private wordingManager;
+    protected runtime: Server;
+    private transport;
+    private appManifests;
+    private tools;
+    constructor(productManifest: ProductManifest, settingsManager: SettingsManager<S>, ucBuilder: UCBuilder, ucManager: UCManager, wordingManager: WordingManager);
+    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>;
+    mountStaticDir(_dirPath: DirPath): Promise<void>;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    warmUp(): Promise<void>;
+    private buildInputSchema;
+    private execRequest;
+}
+export {};

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

@@ -0,0 +1,155 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+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 { WordingManager } from '../../i18n/index.js';
+import { UCBuilder, ucMountingPoint, ucifIsMandatory, } from '../../uc/index.js';
+import { propertyType, resError, resObj } from './funcs.js';
+let NodeLocalStdioMCPServerManager = class NodeLocalStdioMCPServerManager {
+    productManifest;
+    settingsManager;
+    ucBuilder;
+    ucManager;
+    wordingManager;
+    runtime;
+    transport;
+    appManifests;
+    tools;
+    constructor(productManifest, settingsManager, ucBuilder, ucManager, wordingManager) {
+        this.productManifest = productManifest;
+        this.settingsManager = settingsManager;
+        this.ucBuilder = ucBuilder;
+        this.ucManager = ucManager;
+        this.wordingManager = wordingManager;
+        this.appManifests = new Map();
+        this.tools = new Map();
+    }
+    s() {
+        return {
+            logger_level: this.settingsManager.get()('logger_level'),
+        };
+    }
+    overrideUCManager(ucManager) {
+        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)';
+            console.error(new Error(message));
+        }
+    }
+    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 = { name: mountingPoint, inputSchema };
+        this.tools.set(mountingPoint, { appName: appManifest.name, tool, ucd });
+    }
+    async mountStaticDir(_dirPath) {
+        throw new Error('Method not implemented.');
+    }
+    async start() {
+        this.transport = new StdioServerTransport();
+        await this.runtime.connect(this.transport);
+    }
+    async stop() {
+        await this.runtime.close();
+        await this.transport.close();
+    }
+    async warmUp() {
+        this.runtime.setRequestHandler(ListToolsRequestSchema, async () => {
+            return {
+                tools: [...this.tools.values().map((v) => v.tool)],
+            };
+        });
+        this.runtime.setRequestHandler(CallToolRequestSchema, async (request) => this.execRequest(request));
+    }
+    buildInputSchema(uc) {
+        const res = {
+            type: 'object',
+        };
+        if (uc.inputFields.length > 0) {
+            const properties = {};
+            for (const f of uc.inputFields) {
+                const { def, key } = f;
+                const { desc } = this.wordingManager.ucif(f);
+                properties[key] = {
+                    ...propertyType(def),
+                    description: desc,
+                    required: ucifIsMandatory(def),
+                };
+            }
+            res.properties = properties;
+        }
+        return res;
+    }
+    async execRequest(request) {
+        const { name, arguments: args } = request.params;
+        const auth = null;
+        try {
+            const route = this.tools.get(name);
+            if (!route) {
+                throw new Error(`Unrecognized use case : ${name}`);
+            }
+            const { appName, ucd } = route;
+            const appManifest = this.appManifests.get(appName);
+            if (!appManifest) {
+                throw new Error(`Unrecognized app : ${appName}`);
+            }
+            const uc = this.ucBuilder.exec({
+                appManifest,
+                auth,
+                def: ucd,
+            });
+            if (args) {
+                uc.fill(args);
+            }
+            const confirmed = await this.ucManager.confirmClient(uc);
+            if (!confirmed) {
+                throw new Error('Ask for the user to confirm');
+            }
+            const ucor = await this.ucManager.execClient(uc);
+            return resObj(ucor);
+        }
+        catch (err) {
+            return resError(err);
+        }
+    }
+};
+NodeLocalStdioMCPServerManager = __decorate([
+    injectable(),
+    __param(0, inject('ProductManifest')),
+    __param(1, inject('SettingsManager')),
+    __param(2, inject(UCBuilder)),
+    __param(3, inject('UCManager')),
+    __param(4, inject(WordingManager)),
+    __metadata("design:paramtypes", [Object, Object, UCBuilder, Object, WordingManager])
+], NodeLocalStdioMCPServerManager);
+export { NodeLocalStdioMCPServerManager };

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

@@ -0,0 +1,7 @@
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import { type DataType } from '../../dt/index.js';
+import { type UCInputFieldDef } from '../../uc/index.js';
+import type { PropertyType } from './types.js';
+export declare function propertyType<T extends DataType>(def: UCInputFieldDef<T>): PropertyType;
+export declare function resError(err: Error): CallToolResult;
+export declare function resObj<T>(obj: T): CallToolResult;

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

@@ -0,0 +1,45 @@
+import { TBoolean, TEmbeddedObject, TInt, TNumber, } from '../../dt/index.js';
+import { ucifRepeatability } from '../../uc/index.js';
+export function propertyType(def) {
+    const { cardinality, type } = def;
+    let primitive = 'string';
+    if (type instanceof TBoolean) {
+        primitive = 'boolean';
+    }
+    else if (type instanceof TInt) {
+        primitive = 'integer';
+    }
+    else if (type instanceof TNumber) {
+        primitive = 'number';
+    }
+    else if (type instanceof TEmbeddedObject) {
+        primitive = 'object';
+    }
+    const [isRepeatable] = ucifRepeatability(def);
+    const maxItems = cardinality?.max;
+    const minItems = cardinality?.min;
+    return isRepeatable
+        ? { items: { type: primitive }, maxItems, minItems, type: 'array' }
+        : { type: primitive };
+}
+export function resError(err) {
+    return {
+        isError: true,
+        content: [
+            {
+                text: err.message,
+                type: 'text',
+            },
+        ],
+    };
+}
+export function resObj(obj) {
+    return {
+        content: [
+            {
+                text: JSON.stringify(obj),
+                type: 'text',
+            },
+        ],
+    };
+}

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

@@ -0,0 +1,19 @@
+import type { ListToolsResult } from '@modelcontextprotocol/sdk/types.js';
+import type { UIntQuantity } from '../../dt/index.js';
+export type PropertyPrimitiveType = 'boolean' | 'integer' | 'number' | 'object' | 'string';
+export type PropertyArrayType<T extends PropertyPrimitiveType> = {
+    items: {
+        type: T;
+    };
+    maxItems?: UIntQuantity | undefined;
+    minItems?: UIntQuantity | undefined;
+    type: 'array';
+};
+export type PropertyType<T extends PropertyPrimitiveType = PropertyPrimitiveType> = {
+    type: T;
+} | PropertyArrayType<T>;
+export type Property<T extends PropertyPrimitiveType = PropertyPrimitiveType> = PropertyType<T> & {
+    description: string | null;
+    required: boolean;
+};
+export type Tool = ListToolsResult['tools'][0];

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

@@ -0,0 +1 @@
+export {};

package/dist/esm/target/react-web-pure/UCAutoExecLoader.d.ts

@@ -0,0 +1,2 @@
+import { type ReactElement } from 'react';
+export declare function UCAutoExecLoader(): ReactElement;

package/dist/esm/target/react-web-pure/UCAutoExecLoader.js

@@ -0,0 +1,4 @@
+import React, {} from 'react';
+export function UCAutoExecLoader() {
+    return React.createElement("div", null, "...");
+}

package/dist/esm/target/react-web-pure/UCEntrypointTouchable.d.ts

@@ -0,0 +1,4 @@
+import { type ReactElement } from 'react';
+import type { UCEntrypointTouchableProps } from '../../index.react.js';
+import type { UCInput, UCOPIBase } from '../../uc/index.js';
+export declare function UCEntrypointTouchable<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>({ path, wording }: UCEntrypointTouchableProps<I, OPI0, OPI1>): ReactElement;

package/dist/esm/target/react-web-pure/UCEntrypointTouchable.js

@@ -0,0 +1,4 @@
+import React, {} from 'react';
+export function UCEntrypointTouchable({ path, wording }) {
+    return (React.createElement("a", { href: path, title: wording.desc ?? undefined }, wording.label));
+}

package/dist/esm/target/react-web-pure/UCExecTouchable.d.ts

@@ -0,0 +1,4 @@
+import { type ReactElement } from 'react';
+import { type UCExecTouchableProps } from '../../index.react.js';
+import type { UCInput, UCOPIBase } from '../../uc/index.js';
+export declare function UCExecTouchable<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>({ disabled, execState, onSubmit, uc, }: UCExecTouchableProps<I, OPI0, OPI1>): ReactElement;

package/dist/esm/target/react-web-pure/UCExecTouchable.js

@@ -0,0 +1,7 @@
+import React, {} from 'react';
+import { useDIContext } from '../../index.react.js';
+export function UCExecTouchable({ disabled, execState, onSubmit, uc, }) {
+    const { wordingManager } = useDIContext();
+    const label = wordingManager.ucISubmit(uc.def, execState);
+    return (React.createElement("button", { disabled: disabled, onClick: onSubmit, type: "button" }, label));
+}