geniebox-shared-lib 2.3.0 → 2.4.0

package/dist/mcp.client.d.ts

@@ -0,0 +1,12 @@
+import { OnModuleInit } from "@nestjs/common";
+import { ClientGrpc } from "@nestjs/microservices";
+import { McpServiceClient } from "./mcp.interface";
+export declare class MCPClient implements OnModuleInit {
+    private readonly client;
+    private readonly logger;
+    private mcpClient?;
+    constructor(client: ClientGrpc);
+    onModuleInit(): void;
+    get service(): McpServiceClient;
+    isReady(): boolean;
+}

package/dist/mcp.client.js

@@ -0,0 +1,42 @@
+"use strict";
+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); }
+};
+var MCPClient_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MCPClient = void 0;
+const common_1 = require("@nestjs/common");
+let MCPClient = MCPClient_1 = class MCPClient {
+    constructor(client) {
+        this.client = client;
+        this.logger = new common_1.Logger(MCPClient_1.name);
+    }
+    onModuleInit() {
+        this.mcpClient = this.client.getService("MCPService");
+        this.logger.log("MCPService initialized");
+    }
+    get service() {
+        if (!this.mcpClient) {
+            throw new common_1.InternalServerErrorException("MCPService is not initialized yet");
+        }
+        return this.mcpClient;
+    }
+    isReady() {
+        return !!this.mcpClient;
+    }
+};
+exports.MCPClient = MCPClient;
+exports.MCPClient = MCPClient = MCPClient_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)("MCP_PACKAGE")),
+    __metadata("design:paramtypes", [Object])
+], MCPClient);

package/dist/mcp.interface.d.ts

@@ -0,0 +1,203 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import type { handleUnaryCall, Metadata, UntypedServiceImplementation } from "@grpc/grpc-js";
+import { Observable } from "rxjs";
+import { Empty } from "./google/protobuf/empty.interface";
+export declare const protobufPackage = "mcp";
+export interface McpServer {
+    id: string;
+    name: string;
+    /** JSON string */
+    config: string;
+    enabled: boolean;
+    userId: string;
+    visibility: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface McpServerCustomization {
+    id: string;
+    userId: string;
+    mcpServerId: string;
+    prompt: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface McpToolCustomization {
+    id: string;
+    userId: string;
+    toolName: string;
+    mcpServerId: string;
+    prompt: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface McpOAuthSession {
+    id: string;
+    mcpServerId: string;
+    serverUrl: string;
+    /** JSON */
+    clientInfo: string;
+    /** JSON */
+    tokens: string;
+    codeVerifier: string;
+    state: string;
+    createdAt: string;
+    updatedAt: string;
+}
+/** Requests */
+export interface CreateMcpServerRequest {
+    userId: string;
+    name: string;
+    config: string;
+    enabled: boolean;
+    visibility: string;
+}
+export interface UpdateMcpServerRequest {
+    id: string;
+    userId: string;
+    name?: string | undefined;
+    config?: string | undefined;
+    enabled?: boolean | undefined;
+    visibility?: string | undefined;
+}
+export interface GetMcpServerRequest {
+    id: string;
+    userId: string;
+}
+export interface ListMcpServersRequest {
+    userId: string;
+    limit: number;
+    offset: number;
+}
+export interface DeleteMcpServerRequest {
+    id: string;
+    userId: string;
+}
+/** Customizations */
+export interface SetServerCustomizationRequest {
+    userId: string;
+    mcpServerId: string;
+    prompt: string;
+}
+export interface SetToolCustomizationRequest {
+    userId: string;
+    mcpServerId: string;
+    toolName: string;
+    prompt: string;
+}
+export interface McpServersResponse {
+    servers: McpServer[];
+    total: number;
+}
+export declare const MCP_PACKAGE_NAME = "mcp";
+export declare const McpServer: MessageFns<McpServer>;
+export declare const McpServerCustomization: MessageFns<McpServerCustomization>;
+export declare const McpToolCustomization: MessageFns<McpToolCustomization>;
+export declare const McpOAuthSession: MessageFns<McpOAuthSession>;
+export declare const CreateMcpServerRequest: MessageFns<CreateMcpServerRequest>;
+export declare const UpdateMcpServerRequest: MessageFns<UpdateMcpServerRequest>;
+export declare const GetMcpServerRequest: MessageFns<GetMcpServerRequest>;
+export declare const ListMcpServersRequest: MessageFns<ListMcpServersRequest>;
+export declare const DeleteMcpServerRequest: MessageFns<DeleteMcpServerRequest>;
+export declare const SetServerCustomizationRequest: MessageFns<SetServerCustomizationRequest>;
+export declare const SetToolCustomizationRequest: MessageFns<SetToolCustomizationRequest>;
+export declare const McpServersResponse: MessageFns<McpServersResponse>;
+export interface McpServiceClient {
+    createServer(request: CreateMcpServerRequest, metadata?: Metadata): Observable<McpServer>;
+    getServer(request: GetMcpServerRequest, metadata?: Metadata): Observable<McpServer>;
+    updateServer(request: UpdateMcpServerRequest, metadata?: Metadata): Observable<McpServer>;
+    deleteServer(request: DeleteMcpServerRequest, metadata?: Metadata): Observable<Empty>;
+    listServers(request: ListMcpServersRequest, metadata?: Metadata): Observable<McpServersResponse>;
+    setServerCustomization(request: SetServerCustomizationRequest, metadata?: Metadata): Observable<McpServerCustomization>;
+    setToolCustomization(request: SetToolCustomizationRequest, metadata?: Metadata): Observable<McpToolCustomization>;
+}
+export interface McpServiceController {
+    createServer(request: CreateMcpServerRequest, metadata?: Metadata): Promise<McpServer> | Observable<McpServer> | McpServer;
+    getServer(request: GetMcpServerRequest, metadata?: Metadata): Promise<McpServer> | Observable<McpServer> | McpServer;
+    updateServer(request: UpdateMcpServerRequest, metadata?: Metadata): Promise<McpServer> | Observable<McpServer> | McpServer;
+    deleteServer(request: DeleteMcpServerRequest, metadata?: Metadata): void;
+    listServers(request: ListMcpServersRequest, metadata?: Metadata): Promise<McpServersResponse> | Observable<McpServersResponse> | McpServersResponse;
+    setServerCustomization(request: SetServerCustomizationRequest, metadata?: Metadata): Promise<McpServerCustomization> | Observable<McpServerCustomization> | McpServerCustomization;
+    setToolCustomization(request: SetToolCustomizationRequest, metadata?: Metadata): Promise<McpToolCustomization> | Observable<McpToolCustomization> | McpToolCustomization;
+}
+export declare function McpServiceControllerMethods(): (constructor: Function) => void;
+export declare const MCP_SERVICE_NAME = "McpService";
+export type McpServiceService = typeof McpServiceService;
+export declare const McpServiceService: {
+    readonly createServer: {
+        readonly path: "/mcp.McpService/createServer";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: CreateMcpServerRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => CreateMcpServerRequest;
+        readonly responseSerialize: (value: McpServer) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => McpServer;
+    };
+    readonly getServer: {
+        readonly path: "/mcp.McpService/getServer";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GetMcpServerRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => GetMcpServerRequest;
+        readonly responseSerialize: (value: McpServer) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => McpServer;
+    };
+    readonly updateServer: {
+        readonly path: "/mcp.McpService/updateServer";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: UpdateMcpServerRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => UpdateMcpServerRequest;
+        readonly responseSerialize: (value: McpServer) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => McpServer;
+    };
+    readonly deleteServer: {
+        readonly path: "/mcp.McpService/deleteServer";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: DeleteMcpServerRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => DeleteMcpServerRequest;
+        readonly responseSerialize: (value: Empty) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => Empty;
+    };
+    readonly listServers: {
+        readonly path: "/mcp.McpService/listServers";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: ListMcpServersRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => ListMcpServersRequest;
+        readonly responseSerialize: (value: McpServersResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => McpServersResponse;
+    };
+    readonly setServerCustomization: {
+        readonly path: "/mcp.McpService/setServerCustomization";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: SetServerCustomizationRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => SetServerCustomizationRequest;
+        readonly responseSerialize: (value: McpServerCustomization) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => McpServerCustomization;
+    };
+    readonly setToolCustomization: {
+        readonly path: "/mcp.McpService/setToolCustomization";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: SetToolCustomizationRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => SetToolCustomizationRequest;
+        readonly responseSerialize: (value: McpToolCustomization) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => McpToolCustomization;
+    };
+};
+export interface McpServiceServer extends UntypedServiceImplementation {
+    createServer: handleUnaryCall<CreateMcpServerRequest, McpServer>;
+    getServer: handleUnaryCall<GetMcpServerRequest, McpServer>;
+    updateServer: handleUnaryCall<UpdateMcpServerRequest, McpServer>;
+    deleteServer: handleUnaryCall<DeleteMcpServerRequest, Empty>;
+    listServers: handleUnaryCall<ListMcpServersRequest, McpServersResponse>;
+    setServerCustomization: handleUnaryCall<SetServerCustomizationRequest, McpServerCustomization>;
+    setToolCustomization: handleUnaryCall<SetToolCustomizationRequest, McpToolCustomization>;
+}
+export interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+}