@prostgles/app 2.3.6-dev.1788969970

package/dist/server/src/McpHub/DockerSandbox/runContainerWithProxyAccess.d.ts

@@ -0,0 +1,26 @@
+import type { DBS } from "../../index";
+import { createContainer } from "./createContainer";
+import { type ContainerProxyContext } from "./dockerMCPServerProxy/dockerContainerAuthRegistry";
+import type { ProcessLog } from "./executeDockerCommand";
+export declare const DOCKER_MCP_ENDPOINT_ENV_VAR = "DOCKER_MCP_ENDPOINT";
+export declare const runContainerWithProxyAccess: (dbs: DBS, { user_id, requestHandlers, mcpToolsScope, }: {
+    user_id: string;
+} & Pick<ContainerProxyContext, "requestHandlers" | "mcpToolsScope">, args: Parameters<typeof createContainer>[1], onLogs?: (logs: ProcessLog[]) => void) => Promise<import("prostgles-types").JSONB.GetObjectType<{
+    readonly state: {
+        readonly enum: readonly ["finished", "error", "build-error", "timed-out", "aborted"];
+    };
+    readonly name: "string";
+    readonly command: "string";
+    readonly log: {
+        readonly arrayOfType: {
+            readonly type: {
+                readonly enum: readonly ["stdout", "stderr", "error"];
+            };
+            readonly text: "string";
+        };
+    };
+    readonly exitCode: "number";
+    readonly runDuration: "number";
+    readonly buildDuration: "number";
+}>>;
+//# sourceMappingURL=runContainerWithProxyAccess.d.ts.map

package/dist/server/src/McpHub/DockerSandbox/runContainerWithProxyAccess.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runContainerWithProxyAccess.d.ts","sourceRoot":"","sources":["../../../../../src/McpHub/DockerSandbox/runContainerWithProxyAccess.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,YAAY,CAAC;AAEtC,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAEL,KAAK,qBAAqB,EAC3B,MAAM,oDAAoD,CAAC;AAE5D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAEzD,eAAO,MAAM,2BAA2B,wBAAwB,CAAC;AACjE,eAAO,MAAM,2BAA2B,GACtC,KAAK,GAAG,EACR,8CAIG;IACD,OAAO,EAAE,MAAM,CAAC;CACjB,GAAG,IAAI,CAAC,qBAAqB,EAAE,iBAAiB,GAAG,eAAe,CAAC,EACpE,MAAM,UAAU,CAAC,OAAO,eAAe,CAAC,CAAC,CAAC,CAAC,EAC3C,SAAS,CAAC,IAAI,EAAE,UAAU,EAAE,KAAK,IAAI;;;;;;;;;;;;;;;;;GA2EtC,CAAC"}

package/dist/server/src/McpHub/DockerSandbox/runContainerWithProxyAccess.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runContainerWithProxyAccess = exports.DOCKER_MCP_ENDPOINT_ENV_VAR = void 0;
+const OAuthUtils_1 = require("../../../../common/OAuthUtils");
+const upsertSession_1 = require("../../authConfig/upsertSession");
+const crypto_1 = require("crypto");
+const createContainer_1 = require("./createContainer");
+const dockerContainerAuthRegistry_1 = require("./dockerMCPServerProxy/dockerContainerAuthRegistry");
+const dockerMCPServerProxy_1 = require("./dockerMCPServerProxy/dockerMCPServerProxy");
+exports.DOCKER_MCP_ENDPOINT_ENV_VAR = "DOCKER_MCP_ENDPOINT";
+const runContainerWithProxyAccess = async (dbs, { user_id, requestHandlers, mcpToolsScope, }, args, onLogs) => {
+    const proxy = await (0, dockerMCPServerProxy_1.getOrCreateDockerMCPServerProxy)();
+    const user = await dbs.users.findOne({ id: user_id });
+    if (!user) {
+        throw new Error(`User with id ${user_id} not found`);
+    }
+    const database_config = await dbs.database_configs.findOne({
+        $existsJoined: { connections: { is_state_db: true } },
+    });
+    if (!database_config) {
+        throw new Error("No database_config found for state db connection");
+    }
+    const tokenForMCP = await (0, upsertSession_1.upsertSession)({
+        db: dbs,
+        ip: "127.0.0.1",
+        user,
+        user_agent: OAuthUtils_1.DOCKER_USER_AGENT,
+        database_config,
+    });
+    const sid_token = tokenForMCP.sid;
+    if (!sid_token) {
+        throw new Error("Failed to create session for Docker MCP");
+    }
+    const npmVars = {
+        /** Speed things up */
+        NPM_CONFIG_AUDIT: "false",
+        NPM_CONFIG_UPDATE_NOTIFIER: "false",
+        NPM_CONFIG_FETCH_RETRIES: "0",
+        NPM_CONFIG_FETCH_TIMEOUT: "15000",
+        NO_UPDATE_NOTIFIER: "1",
+        FORCE_COLOR: "1",
+    };
+    const secret = (0, crypto_1.randomBytes)(32).toString("base64url");
+    const containerResult = await dockerContainerAuthRegistry_1.dockerContainerAuthRegistry.runContainerWithAuth({
+        mcpToolsScope,
+        sid_token,
+        requestHandlers,
+        secret,
+        user,
+        timestamp: new Date(),
+    }, (containerName) => {
+        const argsWithEnv = {
+            ...args,
+            environment: {
+                ...npmVars,
+                ...args.environment,
+                [exports.DOCKER_MCP_ENDPOINT_ENV_VAR]: proxy.getBaseUrl(args.networkMode ?? "bridge") +
+                    "/mcp-proxy/" +
+                    secret,
+            },
+            buildEnvironment: npmVars,
+        };
+        return (0, createContainer_1.createContainer)(containerName, argsWithEnv, onLogs);
+    });
+    /** Cleanup pending tool requests */
+    if (mcpToolsScope) {
+        await dbs.mcp_tool_approval_requests.update({
+            chat_id: mcpToolsScope.chat.id,
+            response: null,
+        }, { response: "timed-out", updated: new Date() });
+    }
+    return containerResult;
+};
+exports.runContainerWithProxyAccess = runContainerWithProxyAccess;
+//# sourceMappingURL=runContainerWithProxyAccess.js.map

package/dist/server/src/McpHub/DockerSandbox/runContainerWithProxyAccess.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runContainerWithProxyAccess.js","sourceRoot":"","sources":["../../../../../src/McpHub/DockerSandbox/runContainerWithProxyAccess.ts"],"names":[],"mappings":";;;AAAA,mDAAuD;AACvD,iEAA8D;AAE9D,mCAAqC;AACrC,uDAAoD;AACpD,oGAG4D;AAC5D,sFAA8F;AAGjF,QAAA,2BAA2B,GAAG,qBAAqB,CAAC;AAC1D,MAAM,2BAA2B,GAAG,KAAK,EAC9C,GAAQ,EACR,EACE,OAAO,EACP,eAAe,EACf,aAAa,GAGqD,EACpE,IAA2C,EAC3C,MAAqC,EACrC,EAAE;IACF,MAAM,KAAK,GAAG,MAAM,IAAA,sDAA+B,GAAE,CAAC;IACtD,MAAM,IAAI,GAAG,MAAM,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,EAAE,EAAE,OAAO,EAAE,CAAC,CAAC;IACtD,IAAI,CAAC,IAAI,EAAE,CAAC;QACV,MAAM,IAAI,KAAK,CAAC,gBAAgB,OAAO,YAAY,CAAC,CAAC;IACvD,CAAC;IACD,MAAM,eAAe,GAAG,MAAM,GAAG,CAAC,gBAAgB,CAAC,OAAO,CAAC;QACzD,aAAa,EAAE,EAAE,WAAW,EAAE,EAAE,WAAW,EAAE,IAAI,EAAE,EAAE;KACtD,CAAC,CAAC;IACH,IAAI,CAAC,eAAe,EAAE,CAAC;QACrB,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAC;IACtE,CAAC;IACD,MAAM,WAAW,GAAG,MAAM,IAAA,6BAAa,EAAC;QACtC,EAAE,EAAE,GAAG;QACP,EAAE,EAAE,WAAW;QACf,IAAI;QACJ,UAAU,EAAE,8BAAiB;QAC7B,eAAe;KAChB,CAAC,CAAC;IACH,MAAM,SAAS,GAAG,WAAW,CAAC,GAAG,CAAC;IAClC,IAAI,CAAC,SAAS,EAAE,CAAC;QACf,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC;IAC7D,CAAC;IAED,MAAM,OAAO,GAAG;QACd,sBAAsB;QACtB,gBAAgB,EAAE,OAAO;QACzB,0BAA0B,EAAE,OAAO;QACnC,wBAAwB,EAAE,GAAG;QAC7B,wBAAwB,EAAE,OAAO;QACjC,kBAAkB,EAAE,GAAG;QACvB,WAAW,EAAE,GAAG;KACjB,CAAC;IAEF,MAAM,MAAM,GAAG,IAAA,oBAAW,EAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;IACrD,MAAM,eAAe,GACnB,MAAM,yDAA2B,CAAC,oBAAoB,CACpD;QACE,aAAa;QACb,SAAS;QACT,eAAe;QACf,MAAM;QACN,IAAI;QACJ,SAAS,EAAE,IAAI,IAAI,EAAE;KACtB,EACD,CAAC,aAAa,EAAE,EAAE;QAChB,MAAM,WAAW,GAAgB;YAC/B,GAAG,IAAI;YACP,WAAW,EAAE;gBACX,GAAG,OAAO;gBACV,GAAG,IAAI,CAAC,WAAW;gBACnB,CAAC,mCAA2B,CAAC,EAC3B,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,WAAW,IAAI,QAAQ,CAAC;oBAC9C,aAAa;oBACb,MAAM;aACT;YACD,gBAAgB,EAAE,OAAO;SAC1B,CAAC;QACF,OAAO,IAAA,iCAAe,EAAC,aAAa,EAAE,WAAW,EAAE,MAAM,CAAC,CAAC;IAC7D,CAAC,CACF,CAAC;IAEJ,oCAAoC;IACpC,IAAI,aAAa,EAAE,CAAC;QAClB,MAAM,GAAG,CAAC,0BAA0B,CAAC,MAAM,CACzC;YACE,OAAO,EAAE,aAAa,CAAC,IAAI,CAAC,EAAE;YAC9B,QAAQ,EAAE,IAAI;SACf,EACD,EAAE,QAAQ,EAAE,WAAW,EAAE,OAAO,EAAE,IAAI,IAAI,EAAE,EAAE,CAC/C,CAAC;IACJ,CAAC;IAED,OAAO,eAAe,CAAC;AACzB,CAAC,CAAC;AArFW,QAAA,2BAA2B,+BAqFtC"}

package/dist/server/src/McpHub/ProstglesMcpHub/ProstglesMCPServerTypes.d.ts

@@ -0,0 +1,75 @@
+import type { DBSSchema } from "../../../../common/publishUtils";
+import { type DBS } from "../../index";
+import type { AuthClientRequest } from "prostgles-server/dist/Auth/AuthTypes";
+import { type JSONB } from "prostgles-types";
+import type { McpTool } from "../AnthropicMcpHub/McpTypes";
+export type LocalConfigSchema = JSONB.ObjectType["type"];
+export type ProstglesMcpServerDefinition = {
+    icon_path: string;
+    label: string;
+    description: string;
+    config_schema: LocalConfigSchema | undefined;
+    tools: Record<string, {
+        description: string;
+        schema: JSONB.FieldTypeObj | undefined;
+        outputSchema: JSONB.FieldType | undefined;
+        icon?: string;
+        mode?: DBSSchema["mcp_server_tools"]["mode"];
+    }>;
+};
+export type JSONBTypeIfDefined<Schema extends JSONB.FieldType | undefined> = Schema extends JSONB.FieldType ? JSONB.GetType<Schema> : undefined;
+export type JSONBObjectTypeIfDefined<Schema extends LocalConfigSchema | undefined> = Schema extends LocalConfigSchema ? JSONB.GetType<{
+    type: Schema;
+}> : undefined;
+type MaybePromise<T> = T | Promise<T>;
+export type McpCallContext = {
+    chat: DBSSchema["llm_chats"];
+    connection_id: string;
+    user_id: DBSSchema["users"]["id"];
+    clientReq: AuthClientRequest;
+    dbs: DBS;
+    toolUseId: string | undefined;
+    messageId: DBSSchema["llm_messages"]["id"];
+} & Pick<DBSSchema["llm_chats_allowed_mcp_tools"], "tool_id" | "server_config_id">;
+export type McpCallContextFetchTools = {
+    mcpTools: {
+        name: string;
+        server_name: string;
+        description: string;
+        inputSchema: Record<string, unknown>;
+        outputSchema: Record<string, unknown> | null;
+    }[];
+    toolsAllowed: {
+        tool_id: number;
+        tool_name: string;
+    }[];
+};
+export type ProstglesMcpServerHandler = {
+    start: (dbs: DBS) => MaybePromise<ProstglesMcpServerHandlerInstance>;
+};
+export type ProstglesMcpServerHandlerInstance = {
+    stop: () => MaybePromise<void>;
+    fetchTools: (dbs: DBS, context: McpCallContextFetchTools) => MaybePromise<Record<string, undefined | {
+        name: string;
+        description: string;
+        inputSchema: McpTool["inputSchema"];
+    }>>;
+    tools: Record<string, (toolArguments: unknown, context: McpCallContext, config: unknown) => MaybePromise<unknown>>;
+};
+export type ProstglesMcpServerHandlerTypedFetchTools<Tools extends ProstglesMcpServerDefinition["tools"]> = (dbs: DBS, context: McpCallContextFetchTools) => MaybePromise<Record<keyof Tools, {
+    name: string;
+    description: string;
+    inputSchema: McpTool["inputSchema"];
+} | undefined>>;
+export type ProstglesMcpServerHandlerTyped<ServerDefinition extends Omit<ProstglesMcpServerDefinition, "handler"> = ProstglesMcpServerDefinition> = {
+    start: (dbs: DBS) => MaybePromise<{
+        stop: () => MaybePromise<void>;
+        fetchTools: ProstglesMcpServerHandlerTypedFetchTools<ServerDefinition["tools"]>;
+        tools: {
+            [ToolName in keyof ServerDefinition["tools"]]: (toolArguments: JSONBTypeIfDefined<ServerDefinition["tools"][ToolName]["schema"]>, context: McpCallContext, config: JSONBObjectTypeIfDefined<ServerDefinition["config_schema"]>) => MaybePromise<JSONBTypeIfDefined<ServerDefinition["tools"][ToolName]["outputSchema"]>>;
+        };
+    }>;
+};
+export type ProstglesMcpServerTool<ServerDefinition extends ProstglesMcpServerDefinition, ToolName extends keyof ServerDefinition["tools"]> = (toolArguments: JSONBTypeIfDefined<ServerDefinition["tools"][ToolName]["schema"]>, context: McpCallContext) => MaybePromise<unknown>;
+export {};
+//# sourceMappingURL=ProstglesMCPServerTypes.d.ts.map

package/dist/server/src/McpHub/ProstglesMcpHub/ProstglesMCPServerTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProstglesMCPServerTypes.d.ts","sourceRoot":"","sources":["../../../../../src/McpHub/ProstglesMcpHub/ProstglesMCPServerTypes.ts"],"names":[],"mappings":"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"}

package/dist/server/src/McpHub/ProstglesMcpHub/ProstglesMCPServerTypes.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ProstglesMCPServerTypes.js.map

package/dist/server/src/McpHub/ProstglesMcpHub/ProstglesMCPServerTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProstglesMCPServerTypes.js","sourceRoot":"","sources":["../../../../../src/McpHub/ProstglesMcpHub/ProstglesMCPServerTypes.ts"],"names":[],"mappings":""}

package/dist/server/src/McpHub/ProstglesMcpHub/ProstglesMCPServers/Db.mcp.d.ts

@@ -0,0 +1,399 @@
+import type { ProstglesMcpServerHandler } from "../ProstglesMCPServerTypes";
+export declare const DbMcpServer: {
+    definition: {
+        readonly icon_path: "DatabaseOutline";
+        readonly label: "Database";
+        readonly description: "Tools to interact with your database";
+        readonly tools: {
+            readonly get_existing_tables_schema: {
+                readonly icon: "DatabaseEyeOutline";
+                readonly description: string;
+                readonly schema: {
+                    readonly type: {
+                        readonly tableNames: {
+                            readonly optional: true;
+                            readonly type: "string[]";
+                        };
+                        readonly tableNameRegex: {
+                            readonly optional: true;
+                            readonly type: "string";
+                            readonly description: "Regular expression to match table names. For example, 'user' will match tables with names like 'user', 'users', 'app_user', etc.";
+                        };
+                    };
+                };
+                readonly outputSchema: {
+                    readonly type: "string";
+                };
+            };
+            readonly execute_readonly_sql: {
+                readonly icon: "DatabaseSearchOutline";
+                readonly annotations: {
+                    readonly readOnlyHint: true;
+                };
+                readonly description: "Executes a SQL query on the connected database in readonly mode (no data can be changed, the transaction is rolled back at the end).";
+                readonly schema: {
+                    readonly type: {
+                        readonly sql: {
+                            readonly type: "string";
+                            readonly description: "SQL query to execute";
+                        };
+                        readonly query_timeout: {
+                            readonly type: "number";
+                            readonly optional: true;
+                            readonly description: "Maximum time in milliseconds the query will be allowed to run. Defaults to 30000.";
+                        };
+                        readonly query_params: {
+                            readonly optional: true;
+                            readonly description: "Query parameters to use in the SQL query. Must satisfy the query schema. Supports index based ($1, $2, etc.) and named parameters (${paramName}).";
+                            readonly oneOf: readonly ["any[]", {
+                                readonly record: {
+                                    readonly values: "any";
+                                };
+                            }];
+                        };
+                    };
+                };
+                readonly outputSchema: {
+                    readonly arrayOf: {
+                        readonly record: {
+                            readonly values: "any";
+                        };
+                    };
+                };
+            };
+            readonly execute_sql: {
+                readonly icon: "DatabaseEditOutline";
+                readonly annotations: {
+                    readonly readOnlyHint: false;
+                    readonly destructiveHint: true;
+                };
+                readonly description: "Executes a SQL query on the connected database in commit mode (data can be changed, the transaction committed at the end).";
+                readonly schema: {
+                    readonly type: {
+                        readonly sql: {
+                            readonly type: "string";
+                            readonly description: "SQL query to execute";
+                        };
+                        readonly query_timeout: {
+                            readonly type: "number";
+                            readonly optional: true;
+                            readonly description: "Maximum time in milliseconds the query will be allowed to run. Defaults to 30000.";
+                        };
+                        readonly query_params: {
+                            readonly optional: true;
+                            readonly description: "Query parameters to use in the SQL query. Must satisfy the query schema. Supports index based ($1, $2, etc.) and named parameters (${paramName}).";
+                            readonly oneOf: readonly ["any[]", {
+                                readonly record: {
+                                    readonly values: "any";
+                                };
+                            }];
+                        };
+                    };
+                };
+                readonly outputSchema: {
+                    readonly arrayOf: {
+                        readonly record: {
+                            readonly values: "any";
+                        };
+                    };
+                };
+            };
+            readonly count: {
+                readonly icon: "DatabaseEyeOutline";
+                readonly description: "Counts rows in a table that satisfy a filter.";
+                readonly annotations: {
+                    readonly readOnlyHint: true;
+                };
+                readonly schema: {
+                    readonly type: {
+                        readonly tableName: "string";
+                        readonly filter: {
+                            readonly optional: true;
+                            readonly description: "Row filter. Must satisfy the table schema. Example filters: { $or: [{ id: 1 }, { name: { $in: ['John'] } }] }";
+                            readonly record: {
+                                readonly values: "any";
+                            };
+                        };
+                    };
+                };
+                readonly outputSchema: "number";
+            };
+            readonly find: {
+                readonly icon: "TableSearch";
+                readonly description: "Selects rows from a table.";
+                readonly annotations: {
+                    readonly readOnlyHint: true;
+                };
+                readonly schema: {
+                    readonly type: {
+                        readonly tableName: "string";
+                        readonly filter: {
+                            readonly description: "Row filter. Must satisfy the table schema. Example filters: { $or: [{ id: 1 }, { name: { $in: ['John'] } }] }";
+                            readonly record: {
+                                readonly values: "any";
+                            };
+                            readonly optional: true;
+                        };
+                        readonly select: {
+                            readonly optional: true;
+                            readonly oneOf: readonly [{
+                                readonly enum: readonly ["*"];
+                            }, {
+                                readonly description: "Fields to select. Must satisfy the table schema. Example: { id: 1, name: 1 } or { password: 0 }";
+                                readonly record: {
+                                    readonly values: {
+                                        readonly enum: readonly [1, 0];
+                                    };
+                                };
+                            }];
+                        };
+                        readonly orderBy: {
+                            readonly optional: true;
+                            readonly oneOf: readonly [{
+                                readonly arrayOfType: {
+                                    readonly key: "string";
+                                    readonly asc: {
+                                        readonly enum: readonly [true, false];
+                                    };
+                                    readonly nulls: {
+                                        readonly enum: readonly ["first", "last"];
+                                        readonly optional: true;
+                                    };
+                                };
+                            }, {
+                                readonly type: {
+                                    readonly key: "string";
+                                    readonly asc: {
+                                        readonly enum: readonly [true, false];
+                                    };
+                                    readonly nulls: {
+                                        readonly enum: readonly ["first", "last"];
+                                        readonly optional: true;
+                                    };
+                                };
+                            }];
+                        };
+                        readonly limit: {
+                            readonly optional: true;
+                            readonly description: "Defaults to 10";
+                            readonly type: "integer";
+                        };
+                        readonly offset: {
+                            readonly optional: true;
+                            readonly type: "integer";
+                        };
+                    };
+                };
+                readonly outputSchema: {
+                    readonly arrayOf: {
+                        readonly record: {
+                            readonly values: "any";
+                        };
+                    };
+                };
+            };
+            readonly insert: {
+                readonly icon: "TablePlus";
+                readonly description: "Inserts a row into a table.";
+                readonly annotations: {
+                    readonly readOnlyHint: false;
+                };
+                readonly schema: {
+                    readonly type: {
+                        readonly tableName: "string";
+                        readonly data: {
+                            readonly description: "Data to insert into the table. Must satisfy the table schema.";
+                            readonly record: {
+                                readonly values: "any";
+                            };
+                        };
+                        readonly onConflict: {
+                            readonly enum: readonly ["DoNothing", "DoUpdate"];
+                            readonly optional: true;
+                            readonly description: string;
+                        };
+                        readonly returning: {
+                            readonly optional: true;
+                            readonly oneOf: readonly [{
+                                readonly enum: readonly ["*"];
+                            }, {
+                                readonly description: "Fields to select. Must satisfy the table schema. Example: { id: 1, name: 1 } or { password: 0 }";
+                                readonly record: {
+                                    readonly values: {
+                                        readonly enum: readonly [1, 0];
+                                    };
+                                };
+                            }];
+                            readonly description: "Fields to return for newly inserted data. Nothing will be returned otherwise";
+                        };
+                    };
+                };
+                readonly outputSchema: {
+                    readonly optional: true;
+                    readonly description: "Inserted row returned based on the returning fields. Nothing will be returned if returning is not provided.";
+                    readonly record: {
+                        readonly values: "any";
+                    };
+                };
+            };
+            readonly insertMany: {
+                readonly icon: "TablePlus";
+                readonly description: "Inserts rows into a table.";
+                readonly annotations: {
+                    readonly readOnlyHint: false;
+                };
+                readonly schema: {
+                    readonly type: {
+                        readonly tableName: "string";
+                        readonly data: {
+                            readonly description: "Data to insert into the table. Must satisfy the table schema.";
+                            readonly arrayOf: {
+                                readonly record: {
+                                    readonly values: "any";
+                                };
+                            };
+                        };
+                        readonly onConflict: {
+                            readonly enum: readonly ["DoNothing", "DoUpdate"];
+                            readonly optional: true;
+                            readonly description: string;
+                        };
+                        readonly returning: {
+                            readonly optional: true;
+                            readonly oneOf: readonly [{
+                                readonly enum: readonly ["*"];
+                            }, {
+                                readonly description: "Fields to select. Must satisfy the table schema. Example: { id: 1, name: 1 } or { password: 0 }";
+                                readonly record: {
+                                    readonly values: {
+                                        readonly enum: readonly [1, 0];
+                                    };
+                                };
+                            }];
+                            readonly description: "Fields to return for newly inserted data. Nothing will be returned otherwise";
+                        };
+                    };
+                };
+                readonly outputSchema: {
+                    readonly arrayOf: {
+                        readonly record: {
+                            readonly values: "any";
+                        };
+                    };
+                    readonly optional: true;
+                    readonly description: "Inserted rows returned based on the returning fields. Nothing will be returned if returning is not provided.";
+                };
+            };
+            readonly update: {
+                readonly icon: "TableEdit";
+                readonly description: "Updates rows in a table.";
+                readonly annotations: {
+                    readonly destructiveHint: true;
+                    readonly readOnlyHint: false;
+                };
+                readonly schema: {
+                    readonly type: {
+                        readonly data: {
+                            readonly description: "Data to insert into the table. Must satisfy the table schema.";
+                            readonly record: {
+                                readonly values: "any";
+                            };
+                        };
+                        readonly removeDisallowedFields: {
+                            readonly type: "boolean";
+                            readonly optional: true;
+                            readonly description: "Whether to remove fields that are not allowed to be updated instead of throwing an error.";
+                        };
+                        readonly multi: {
+                            readonly description: "true by default. When set to false the update will throw an error if more than one row is updated (but the update will commit).";
+                            readonly type: "boolean";
+                            readonly optional: true;
+                        };
+                        readonly returning: {
+                            readonly optional: true;
+                            readonly oneOf: readonly [{
+                                readonly enum: readonly ["*"];
+                            }, {
+                                readonly description: "Fields to select. Must satisfy the table schema. Example: { id: 1, name: 1 } or { password: 0 }";
+                                readonly record: {
+                                    readonly values: {
+                                        readonly enum: readonly [1, 0];
+                                    };
+                                };
+                            }];
+                            readonly description: "Fields to return for updated data. Nothing will be returned otherwise";
+                        };
+                        readonly filter: {
+                            readonly description: "Row filter. Must satisfy the table schema. Example filters: { $or: [{ id: 1 }, { name: { $in: ['John'] } }] }";
+                            readonly record: {
+                                readonly values: "any";
+                            };
+                        };
+                        readonly tableName: "string";
+                    };
+                };
+                readonly outputSchema: {
+                    readonly optional: true;
+                    readonly oneOf: readonly [{
+                        readonly record: {
+                            readonly values: "any";
+                        };
+                    }, {
+                        readonly arrayOf: {
+                            readonly record: {
+                                readonly values: "any";
+                            };
+                        };
+                    }];
+                };
+            };
+            readonly delete: {
+                readonly icon: "TableRemove";
+                readonly annotations: {
+                    readonly destructiveHint: true;
+                    readonly readOnlyHint: false;
+                };
+                readonly description: "Deletes rows from a table.";
+                readonly schema: {
+                    readonly type: {
+                        readonly returning: {
+                            readonly optional: true;
+                            readonly oneOf: readonly [{
+                                readonly enum: readonly ["*"];
+                            }, {
+                                readonly description: "Fields to select. Must satisfy the table schema. Example: { id: 1, name: 1 } or { password: 0 }";
+                                readonly record: {
+                                    readonly values: {
+                                        readonly enum: readonly [1, 0];
+                                    };
+                                };
+                            }];
+                            readonly description: "Fields to return for the deleted rows. Nothing will be returned otherwise";
+                        };
+                        readonly filter: {
+                            readonly description: "Row filter. Must satisfy the table schema. Example filters: { $or: [{ id: 1 }, { name: { $in: ['John'] } }] }";
+                            readonly record: {
+                                readonly values: "any";
+                            };
+                        };
+                        readonly tableName: "string";
+                    };
+                };
+                readonly outputSchema: {
+                    readonly oneOf: readonly [{
+                        readonly arrayOf: {
+                            readonly record: {
+                                readonly values: "any";
+                            };
+                        };
+                    }, {
+                        readonly enum: readonly [undefined];
+                    }];
+                };
+            };
+        };
+        readonly config_schema: undefined;
+    };
+    handler: ProstglesMcpServerHandler;
+};
+//# sourceMappingURL=Db.mcp.d.ts.map

package/dist/server/src/McpHub/ProstglesMcpHub/ProstglesMCPServers/Db.mcp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Db.mcp.d.ts","sourceRoot":"","sources":["../../../../../../src/McpHub/ProstglesMcpHub/ProstglesMCPServers/Db.mcp.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAGV,yBAAyB,EAE1B,MAAM,4BAA4B,CAAC;AAoQpC,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAEF,yBAAyB;CAC9C,CAAC"}