@infersec/conduit 1.94.0 → 1.96.0

package/dist/commands/toolOptions.d.ts

@@ -1,8 +1,18 @@
-import type { ToolConfigurationOverrides } from "../toolConnection/configuration.js";
+import { type ToolConfigurationOverrides } from "../toolConnection/configuration.js";
 export interface ToolConnectCommandOptions {
+    allow?: string;
     apiUrl?: string;
+    database?: string;
+    host?: string;
     key?: string;
+    maxRows?: string;
+    password?: string;
     path?: string;
+    poolMax?: string;
+    port?: string;
+    queryTimeoutMs?: string;
     readOnly?: boolean;
+    url?: string;
+    user?: string;
 }
 export declare function buildToolConfigurationOverrides(toolID: string, options: ToolConnectCommandOptions): ToolConfigurationOverrides;

package/dist/constants.d.ts

@@ -0,0 +1 @@
+export declare const SERVED_MODEL_NAME = "default";

package/dist/modelManagement/ModelManager.d.ts

@@ -20,6 +20,7 @@ export declare class ModelManager extends EventEmitter<ModelManagerEvents> {
     protected readonly logger: Logger;
     private engineProcess;
     private healthPollInterval;
+    private lastEngineError;
     private lifecycleState;
     private stopRequested;
     protected readonly modelsDirectory: string;
@@ -51,6 +52,7 @@ export declare class ModelManager extends EventEmitter<ModelManagerEvents> {
     private get lockFilePath();
     private acquireDownloadLock;
     private getLockAge;
+    private recordEngineError;
     private releaseDownloadLock;
     private waitForDownloadLock;
     private bindEngineProcessEvents;

package/dist/modelManagement/normalizeEngineError.d.ts

@@ -0,0 +1 @@
+export declare function normalizeEngineError(input: string): string;

package/dist/toolConnection/ToolConnection.d.ts

@@ -1,9 +1,13 @@
 import type { ULID } from "@infersec/definitions";
 import type { Logger } from "@infersec/logger";
+import type { MysqlConnectionConfig } from "./configuration.js";
 export interface ToolConnectionOptions {
     apiKey: string;
     apiURL: string;
     logger: Logger;
+    maxRows: number;
+    mysql: MysqlConnectionConfig | null;
+    mysqlAllow: string[];
     readOnly: boolean;
     rootPath: string;
     toolID: ULID;
@@ -16,5 +20,7 @@ export declare class ToolConnection {
     private options;
     constructor(options: ToolConnectionOptions);
     start(): Promise<void>;
+    private createToolServer;
+    private createMysqlToolServer;
     stop(): Promise<void>;
 }

package/dist/toolConnection/configuration.d.ts

@@ -1,7 +1,20 @@
 import { ULID } from "@infersec/definitions";
+export interface MysqlConnectionConfig {
+    connectionLimit: number;
+    database?: string;
+    host?: string;
+    password?: string;
+    port?: number;
+    queryTimeoutMs: number;
+    url?: string;
+    user?: string;
+}
 export interface ToolConfiguration {
     apiKey: string;
     apiURL: string;
+    maxRows: number;
+    mysql: MysqlConnectionConfig | null;
+    mysqlAllow: string[];
     readOnly: boolean;
     rootPath: string;
     toolID: ULID;
@@ -9,10 +22,14 @@ export interface ToolConfiguration {
 export interface ToolConfigurationOverrides {
     apiKey?: string;
     apiURL?: string;
+    maxRows?: number;
+    mysql?: MysqlConnectionConfig;
+    mysqlAllow?: string[];
     readOnly?: boolean;
     rootPath?: string;
     toolID?: ULID;
 }
+export declare function parseAllowList(raw: string): string[];
 export declare function getToolConfiguration({ overrides }?: {
     overrides?: ToolConfigurationOverrides;
 }): ToolConfiguration;

package/dist/toolConnection/mcp/createLocalToolServer.d.ts

@@ -0,0 +1,37 @@
+import { Logger } from "@infersec/logger";
+import { z } from "zod";
+import type { MCPContent } from "./shared.js";
+interface JSONRPCRequest {
+    id?: number;
+    jsonrpc: "2.0";
+    method: string;
+    params?: Record<string, unknown>;
+}
+interface JSONRPCResponse {
+    error?: {
+        code: number;
+        message: string;
+    };
+    id: number | null;
+    jsonrpc: "2.0";
+    result?: unknown;
+}
+export interface LocalToolServer {
+    close: () => Promise<void>;
+    handleRequest: (request: JSONRPCRequest) => Promise<JSONRPCResponse>;
+}
+export interface LocalOperation<Context> {
+    handler: (args: Record<string, unknown>, ctx: Context) => Promise<MCPContent>;
+    inputSchema: z.ZodRawShape;
+    metadata: {
+        description: string;
+        name: string;
+    };
+}
+export declare function createLocalToolServer<Context>({ context, logger, name, operations }: {
+    context: Context;
+    logger: Logger;
+    name: string;
+    operations: Array<LocalOperation<Context>>;
+}): LocalToolServer;
+export {};

package/dist/toolConnection/mcp/filesystem/operations.d.ts

@@ -1,11 +1,5 @@
 import { z } from "zod";
-export type MCPContent = {
-    content: Array<{
-        text: string;
-        type: "text";
-    }>;
-    isError?: boolean;
-};
+import { type MCPContent } from "../shared.js";
 export interface OperationContext {
     basePath: string;
 }

package/dist/toolConnection/mcp/server.d.ts

@@ -1,26 +1,8 @@
 import { Logger } from "@infersec/logger";
-interface JSONRPCRequest {
-    id?: number;
-    jsonrpc: "2.0";
-    method: string;
-    params?: Record<string, unknown>;
-}
-interface JSONRPCResponse {
-    error?: {
-        code: number;
-        message: string;
-    };
-    id: number | null;
-    jsonrpc: "2.0";
-    result?: unknown;
-}
-export interface LocalToolServer {
-    close: () => Promise<void>;
-    handleRequest: (request: JSONRPCRequest) => Promise<JSONRPCResponse>;
-}
+import { type LocalToolServer } from "./createLocalToolServer.js";
+export type { LocalToolServer } from "./createLocalToolServer.js";
 export declare function createFilesystemToolServer({ basePath, logger, readOnly }: {
     basePath: string;
     logger: Logger;
     readOnly: boolean;
 }): LocalToolServer;
-export {};

package/dist/toolConnection/mcp/shared.d.ts

@@ -0,0 +1,9 @@
+export type MCPContent = {
+    content: Array<{
+        text: string;
+        type: "text";
+    }>;
+    isError?: boolean;
+};
+export declare function textResult(text: string, isError?: boolean): MCPContent;
+export declare function jsonResult(data: unknown, isError?: boolean): MCPContent;

package/dist/toolConnection/mcp/sql/adapters/mysql.d.ts

@@ -0,0 +1,12 @@
+import type { SqlAdapter } from "../types.js";
+export interface MysqlAdapterConfig {
+    connectionLimit: number;
+    database?: string;
+    host?: string;
+    password?: string;
+    port?: number;
+    queryTimeoutMs: number;
+    url?: string;
+    user?: string;
+}
+export declare function createMysqlAdapter(config: MysqlAdapterConfig): Promise<SqlAdapter>;

package/dist/toolConnection/mcp/sql/operations.d.ts

@@ -0,0 +1,66 @@
+import { z } from "zod";
+import { type MCPContent } from "../shared.js";
+import type { SqlAdapter } from "./types.js";
+export interface OperationContext {
+    adapter: SqlAdapter;
+    maxRows: number;
+}
+export type OperationHandler = (args: Record<string, unknown>, ctx: OperationContext) => Promise<MCPContent>;
+export interface SqlOperationDefinition {
+    handler: OperationHandler;
+    inputSchema: z.ZodRawShape;
+    isWrite: boolean;
+    metadata: {
+        description: string;
+        name: string;
+    };
+}
+export declare const getTablesSchema: {
+    database: z.ZodOptional<z.ZodString>;
+};
+export declare const getTableSchemaSchema: {
+    database: z.ZodOptional<z.ZodString>;
+    table: z.ZodString;
+};
+export declare const selectSchema: {
+    columns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    database: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    order: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        column: z.ZodString;
+        direction: z.ZodOptional<z.ZodEnum<{
+            asc: "asc";
+            desc: "desc";
+        }>>;
+    }, z.core.$strip>>>;
+    table: z.ZodString;
+    where: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+};
+export declare const insertSchema: {
+    database: z.ZodOptional<z.ZodString>;
+    table: z.ZodString;
+    values: z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>]>;
+};
+export declare const updateSchema: {
+    database: z.ZodOptional<z.ZodString>;
+    set: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    table: z.ZodString;
+    where: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+};
+export declare const deleteSchema: {
+    database: z.ZodOptional<z.ZodString>;
+    table: z.ZodString;
+    where: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+};
+export declare const truncateSchema: {
+    database: z.ZodOptional<z.ZodString>;
+    table: z.ZodString;
+};
+export declare const sqlSchema: {
+    params: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    query: z.ZodString;
+};
+export declare const SQL_OPERATIONS: Array<SqlOperationDefinition>;
+export declare const WRITE_OPERATION_NAMES: string[];
+export declare function resolveAllowedOperations(allow: string[] | undefined): string[];
+export declare function selectExposedOperations(allowed: string[]): Array<SqlOperationDefinition>;

package/dist/toolConnection/mcp/sql/server.d.ts

@@ -0,0 +1,11 @@
+import { Logger } from "@infersec/logger";
+import { type LocalToolServer } from "../createLocalToolServer.js";
+import type { SqlAdapter } from "./types.js";
+export interface SqlToolServerOptions {
+    adapter: SqlAdapter;
+    allow: string[];
+    logger: Logger;
+    maxRows: number;
+    name: string;
+}
+export declare function createSqlToolServer({ adapter, allow, logger, maxRows, name }: SqlToolServerOptions): LocalToolServer;

package/dist/toolConnection/mcp/sql/types.d.ts

@@ -0,0 +1,22 @@
+export interface ColumnInfo {
+    defaultValue: string | null;
+    extra: string;
+    key: string;
+    name: string;
+    nullable: boolean;
+    type: string;
+}
+export interface QueryResult {
+    affectedRows: number;
+    insertId: number | string | null;
+    rows: Array<Record<string, unknown>>;
+}
+export interface SqlAdapter {
+    readonly name: string;
+    close(): Promise<void>;
+    describeTable(database: string | undefined, table: string): Promise<ColumnInfo[]>;
+    listTables(database?: string): Promise<string[]>;
+    query(sql: string, params?: unknown[]): Promise<QueryResult>;
+    quoteIdentifier(name: string): string;
+}
+export declare function validateIdentifier(name: string): string;

package/dist/toolConnection/mcp/sql/where.d.ts

@@ -0,0 +1,19 @@
+export type Primitive = boolean | null | number | string;
+export interface ConditionOperators {
+    eq?: Primitive;
+    gt?: Primitive;
+    gte?: Primitive;
+    in?: Primitive[];
+    isNull?: boolean;
+    like?: string;
+    lt?: Primitive;
+    lte?: Primitive;
+    ne?: Primitive;
+}
+export type Condition = ConditionOperators | Primitive;
+export type WhereInput = Record<string, Condition>;
+export interface BuiltClause {
+    clause: string;
+    params: unknown[];
+}
+export declare function buildWhereClause(quote: (name: string) => string, where: WhereInput | undefined): BuiltClause;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@infersec/conduit",
   "description": "End user conduit agent for connecting local LLMs to the cloud.",
-  "version": "1.94.0",
+  "version": "1.96.0",
   "bin": {
     "infersec-conduit": "./dist/cli.js"
   },
@@ -67,6 +67,7 @@
     "express": "^4.21.2",
     "express-promise-router": "^4.1.1",
     "glob": "^11.0.3",
+    "mysql2": "^3.23.3",
     "supertest": "^7.1.4",
     "systeminformation": "^5.30.3",
     "undici": "^7.13.0",