@toolplex/client 0.1.1

package/dist/shared/enhancedPath.js

@@ -0,0 +1,52 @@
+import * as path from 'path';
+import { existsSync } from 'fs';
+import { homedir } from 'os';
+import { glob } from 'glob';
+/**
+ * Returns an enhanced PATH string by prepending common binary directories
+ * across platforms (Linux, macOS, Windows).
+ *
+ * Ensures no duplicates and checks for existence.
+ */
+export function getEnhancedPath() {
+    const home = homedir();
+    const basePaths = (process.env.PATH || '').split(path.delimiter);
+    const extraPaths = getDefaultExtraPaths(home);
+    const seen = new Set(basePaths);
+    const allPaths = [...basePaths];
+    for (const extraPath of extraPaths) {
+        if (extraPath.includes('*')) {
+            const matches = glob.sync(extraPath);
+            for (const match of matches) {
+                if (existsSync(match) && !seen.has(match)) {
+                    seen.add(match);
+                    allPaths.unshift(match);
+                }
+            }
+        }
+        else {
+            if (existsSync(extraPath) && !seen.has(extraPath)) {
+                seen.add(extraPath);
+                allPaths.unshift(extraPath);
+            }
+        }
+    }
+    return allPaths.join(path.delimiter);
+}
+/**
+ * Returns platform-specific extra binary paths.
+ */
+function getDefaultExtraPaths(home) {
+    const isWindows = process.platform === 'win32';
+    return isWindows
+        ? [
+            path.join(home, 'AppData/Local/Programs/Python/Python3*/Scripts'),
+            path.join(home, 'AppData/Roaming/npm'),
+        ]
+        : [
+            path.join(home, '.local/bin'),
+            path.join(home, '.cargo/bin'),
+            '/usr/local/bin',
+            '/opt/homebrew/bin',
+        ];
+}

package/dist/shared/fileLogger.d.ts

@@ -0,0 +1,13 @@
+export declare const logDir: string;
+export declare class FileLogger {
+    private static logger;
+    private static transport;
+    private static processName;
+    static initialize(processName: string): void;
+    private static log;
+    static info(message: string): void;
+    static warn(message: string): void;
+    static error(message: string): void;
+    static debug(message: string): void;
+    static flush(): Promise<void>;
+}

package/dist/shared/fileLogger.js

@@ -0,0 +1,66 @@
+import path from 'path';
+import envPaths from 'env-paths';
+import winston from 'winston';
+import callsite from 'callsite';
+import DailyRotateFile from 'winston-daily-rotate-file';
+const paths = envPaths('ToolPlex', { suffix: '' });
+export const logDir = path.join(paths.log);
+function getCallingModule() {
+    const stack = callsite();
+    for (let i = 2; i < stack.length; i++) {
+        const fileName = stack[i].getFileName();
+        if (fileName &&
+            !fileName.includes('node_modules') &&
+            !fileName.includes('fileLogger') &&
+            !fileName.includes('callsite')) {
+            return path.basename(fileName, path.extname(fileName));
+        }
+    }
+    return 'unknown';
+}
+export class FileLogger {
+    static initialize(processName) {
+        if (this.logger)
+            return;
+        this.processName = processName;
+        const logLevel = process.env.LOG_LEVEL || 'info';
+        this.transport = new DailyRotateFile({
+            dirname: logDir,
+            filename: `ToolPlex-${processName}-%DATE%.log`,
+            datePattern: 'YYYY-MM-DD',
+            maxFiles: '7d',
+            zippedArchive: false,
+            level: logLevel,
+        });
+        this.logger = winston.createLogger({
+            level: logLevel,
+            format: winston.format.combine(winston.format.timestamp(), winston.format.printf(({ level, message, timestamp, module }) => {
+                return `${timestamp} [${level.toUpperCase()}] ${module || 'unknown'} - ${message}`;
+            })),
+            defaultMeta: {},
+            transports: [this.transport],
+        });
+    }
+    static log(level, message) {
+        const module = getCallingModule();
+        this.logger.log({ level, message, module });
+    }
+    static info(message) {
+        this.log('info', message);
+    }
+    static warn(message) {
+        this.log('warn', message);
+    }
+    static error(message) {
+        this.log('error', message);
+    }
+    static debug(message) {
+        this.log('debug', message);
+    }
+    static async flush() {
+        return new Promise((resolve) => {
+            this.transport.on('finish', resolve);
+            this.logger.end();
+        });
+    }
+}

package/dist/shared/mcpServerTypes.d.ts

@@ -0,0 +1,398 @@
+import { z } from 'zod';
+export type ClientMode = 'standard' | 'restricted';
+export type LogLevel = 'error' | 'warn' | 'info' | 'debug';
+export interface ToolplexServerConfig {
+    dev: boolean;
+    apiKey: string;
+    clientMode: ClientMode;
+    logLevel: LogLevel;
+}
+export declare const TransportTypeSchema: z.ZodEnum<["stdio", "sse"]>;
+export type TransportType = z.infer<typeof TransportTypeSchema>;
+export declare const RuntimeSchema: z.ZodEnum<["node", "python", "go", "docker"]>;
+export type Runtime = z.infer<typeof RuntimeSchema>;
+export declare const LLMContextSchema: z.ZodObject<{
+    model_family: z.ZodString;
+    model_name: z.ZodString;
+    model_version: z.ZodString;
+    chat_client: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    model_family: string;
+    model_name: string;
+    model_version: string;
+    chat_client?: string | undefined;
+}, {
+    model_family: string;
+    model_name: string;
+    model_version: string;
+    chat_client?: string | undefined;
+}>;
+export type LLMContext = z.infer<typeof LLMContextSchema>;
+export declare const ServerConfigSchema: z.ZodObject<{
+    server_name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    command: z.ZodOptional<z.ZodString>;
+    args: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    runtime: z.ZodOptional<z.ZodEnum<["node", "python", "go", "docker"]>>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    url: z.ZodOptional<z.ZodString>;
+    transport: z.ZodEnum<["stdio", "sse"]>;
+}, "strip", z.ZodTypeAny, {
+    transport: "stdio" | "sse";
+    server_name?: string | undefined;
+    description?: string | undefined;
+    command?: string | undefined;
+    args?: string[] | undefined;
+    runtime?: "node" | "python" | "go" | "docker" | undefined;
+    env?: Record<string, string> | undefined;
+    url?: string | undefined;
+}, {
+    transport: "stdio" | "sse";
+    server_name?: string | undefined;
+    description?: string | undefined;
+    command?: string | undefined;
+    args?: string[] | undefined;
+    runtime?: "node" | "python" | "go" | "docker" | undefined;
+    env?: Record<string, string> | undefined;
+    url?: string | undefined;
+}>;
+export type ServerConfig = z.infer<typeof ServerConfigSchema>;
+export declare const InitializeToolplexParamsSchema: z.ZodObject<{
+    llm_context: z.ZodObject<{
+        model_family: z.ZodString;
+        model_name: z.ZodString;
+        model_version: z.ZodString;
+        chat_client: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        model_family: string;
+        model_name: string;
+        model_version: string;
+        chat_client?: string | undefined;
+    }, {
+        model_family: string;
+        model_name: string;
+        model_version: string;
+        chat_client?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    llm_context: {
+        model_family: string;
+        model_name: string;
+        model_version: string;
+        chat_client?: string | undefined;
+    };
+}, {
+    llm_context: {
+        model_family: string;
+        model_name: string;
+        model_version: string;
+        chat_client?: string | undefined;
+    };
+}>;
+export type InitializeToolplexParams = z.infer<typeof InitializeToolplexParamsSchema>;
+export declare const SearchParamsSchema: z.ZodObject<{
+    query: z.ZodString;
+    expanded_keywords: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    filter: z.ZodOptional<z.ZodEnum<["all", "servers_only", "playbooks_only"]>>;
+    size: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    query: string;
+    filter?: "all" | "servers_only" | "playbooks_only" | undefined;
+    expanded_keywords?: string[] | undefined;
+    size?: number | undefined;
+}, {
+    query: string;
+    filter?: "all" | "servers_only" | "playbooks_only" | undefined;
+    expanded_keywords?: string[] | undefined;
+    size?: number | undefined;
+}>;
+export type SearchParams = z.infer<typeof SearchParamsSchema>;
+export declare const LookupEntityParamsSchema: z.ZodObject<{
+    entity_type: z.ZodEnum<["server", "playbook", "feedback"]>;
+    entity_id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    entity_type: "server" | "playbook" | "feedback";
+    entity_id: string;
+}, {
+    entity_type: "server" | "playbook" | "feedback";
+    entity_id: string;
+}>;
+export type LookupEntityParams = z.infer<typeof LookupEntityParamsSchema>;
+export declare const InstallParamsSchema: z.ZodObject<{
+    server_id: z.ZodString;
+    server_name: z.ZodString;
+    description: z.ZodString;
+    config: z.ZodObject<{
+        server_name: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        command: z.ZodOptional<z.ZodString>;
+        args: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        runtime: z.ZodOptional<z.ZodEnum<["node", "python", "go", "docker"]>>;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        url: z.ZodOptional<z.ZodString>;
+        transport: z.ZodEnum<["stdio", "sse"]>;
+    }, "strip", z.ZodTypeAny, {
+        transport: "stdio" | "sse";
+        server_name?: string | undefined;
+        description?: string | undefined;
+        command?: string | undefined;
+        args?: string[] | undefined;
+        runtime?: "node" | "python" | "go" | "docker" | undefined;
+        env?: Record<string, string> | undefined;
+        url?: string | undefined;
+    }, {
+        transport: "stdio" | "sse";
+        server_name?: string | undefined;
+        description?: string | undefined;
+        command?: string | undefined;
+        args?: string[] | undefined;
+        runtime?: "node" | "python" | "go" | "docker" | undefined;
+        env?: Record<string, string> | undefined;
+        url?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    server_name: string;
+    description: string;
+    server_id: string;
+    config: {
+        transport: "stdio" | "sse";
+        server_name?: string | undefined;
+        description?: string | undefined;
+        command?: string | undefined;
+        args?: string[] | undefined;
+        runtime?: "node" | "python" | "go" | "docker" | undefined;
+        env?: Record<string, string> | undefined;
+        url?: string | undefined;
+    };
+}, {
+    server_name: string;
+    description: string;
+    server_id: string;
+    config: {
+        transport: "stdio" | "sse";
+        server_name?: string | undefined;
+        description?: string | undefined;
+        command?: string | undefined;
+        args?: string[] | undefined;
+        runtime?: "node" | "python" | "go" | "docker" | undefined;
+        env?: Record<string, string> | undefined;
+        url?: string | undefined;
+    };
+}>;
+export type InstallParams = z.infer<typeof InstallParamsSchema>;
+export declare const ListToolsParamsSchema: z.ZodObject<{
+    server_id: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    server_id?: string | undefined;
+}, {
+    server_id?: string | undefined;
+}>;
+export type ListToolplexToolsParams = z.infer<typeof ListToolsParamsSchema>;
+export declare const GetServerConfigParamsSchema: z.ZodObject<{
+    server_id: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    server_id?: string | undefined;
+}, {
+    server_id?: string | undefined;
+}>;
+export type GetServerConfigParams = z.infer<typeof GetServerConfigParamsSchema>;
+export declare const CallToolParamsSchema: z.ZodObject<{
+    server_id: z.ZodString;
+    tool_name: z.ZodString;
+    arguments: z.ZodRecord<z.ZodString, z.ZodAny>;
+}, "strip", z.ZodTypeAny, {
+    server_id: string;
+    tool_name: string;
+    arguments: Record<string, any>;
+}, {
+    server_id: string;
+    tool_name: string;
+    arguments: Record<string, any>;
+}>;
+export type CallToolParams = z.infer<typeof CallToolParamsSchema>;
+export declare const UninstallParamsSchema: z.ZodObject<{
+    server_id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    server_id: string;
+}, {
+    server_id: string;
+}>;
+export type UninstallParams = z.infer<typeof UninstallParamsSchema>;
+export declare const PlaybookActionSchema: z.ZodObject<{
+    do: z.ZodString;
+    call: z.ZodOptional<z.ZodString>;
+    args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        type: z.ZodEnum<["string", "number", "boolean", "array", "object", "placeholder"]>;
+        example: z.ZodAny;
+    }, "strip", z.ZodTypeAny, {
+        type: "string" | "number" | "boolean" | "object" | "array" | "placeholder";
+        example?: any;
+    }, {
+        type: "string" | "number" | "boolean" | "object" | "array" | "placeholder";
+        example?: any;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    do: string;
+    args?: Record<string, {
+        type: "string" | "number" | "boolean" | "object" | "array" | "placeholder";
+        example?: any;
+    }> | undefined;
+    call?: string | undefined;
+}, {
+    do: string;
+    args?: Record<string, {
+        type: "string" | "number" | "boolean" | "object" | "array" | "placeholder";
+        example?: any;
+    }> | undefined;
+    call?: string | undefined;
+}>;
+export type PlaybookAction = z.infer<typeof PlaybookActionSchema>;
+export declare const SavePlaybookParamsSchema: z.ZodObject<{
+    description: z.ZodString;
+    actions: z.ZodEffects<z.ZodArray<z.ZodObject<{
+        do: z.ZodString;
+        call: z.ZodOptional<z.ZodString>;
+        args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            type: z.ZodEnum<["string", "number", "boolean", "array", "object", "placeholder"]>;
+            example: z.ZodAny;
+        }, "strip", z.ZodTypeAny, {
+            type: "string" | "number" | "boolean" | "object" | "array" | "placeholder";
+            example?: any;
+        }, {
+            type: "string" | "number" | "boolean" | "object" | "array" | "placeholder";
+            example?: any;
+        }>>>;
+    }, "strip", z.ZodTypeAny, {
+        do: string;
+        args?: Record<string, {
+            type: "string" | "number" | "boolean" | "object" | "array" | "placeholder";
+            example?: any;
+        }> | undefined;
+        call?: string | undefined;
+    }, {
+        do: string;
+        args?: Record<string, {
+            type: "string" | "number" | "boolean" | "object" | "array" | "placeholder";
+            example?: any;
+        }> | undefined;
+        call?: string | undefined;
+    }>, "many">, {
+        do: string;
+        args?: Record<string, {
+            type: "string" | "number" | "boolean" | "object" | "array" | "placeholder";
+            example?: any;
+        }> | undefined;
+        call?: string | undefined;
+    }[], {
+        do: string;
+        args?: Record<string, {
+            type: "string" | "number" | "boolean" | "object" | "array" | "placeholder";
+            example?: any;
+        }> | undefined;
+        call?: string | undefined;
+    }[]>;
+    domain: z.ZodOptional<z.ZodString>;
+    keywords: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    requirements: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    source_playbook_id: z.ZodOptional<z.ZodString>;
+    fork_reason: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    description: string;
+    actions: {
+        do: string;
+        args?: Record<string, {
+            type: "string" | "number" | "boolean" | "object" | "array" | "placeholder";
+            example?: any;
+        }> | undefined;
+        call?: string | undefined;
+    }[];
+    domain?: string | undefined;
+    keywords?: string[] | undefined;
+    requirements?: string[] | undefined;
+    source_playbook_id?: string | undefined;
+    fork_reason?: string | undefined;
+}, {
+    description: string;
+    actions: {
+        do: string;
+        args?: Record<string, {
+            type: "string" | "number" | "boolean" | "object" | "array" | "placeholder";
+            example?: any;
+        }> | undefined;
+        call?: string | undefined;
+    }[];
+    domain?: string | undefined;
+    keywords?: string[] | undefined;
+    requirements?: string[] | undefined;
+    source_playbook_id?: string | undefined;
+    fork_reason?: string | undefined;
+}>;
+export type SavePlaybookParams = z.infer<typeof SavePlaybookParamsSchema>;
+export declare const LogPlaybookUsageParamsSchema: z.ZodObject<{
+    playbook_id: z.ZodString;
+    success: z.ZodBoolean;
+    error_message: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    playbook_id: string;
+    success: boolean;
+    error_message?: string | undefined;
+}, {
+    playbook_id: string;
+    success: boolean;
+    error_message?: string | undefined;
+}>;
+export type LogPlaybookUsageParams = z.infer<typeof LogPlaybookUsageParamsSchema>;
+export declare const SubmitFeedbackParamsSchema: z.ZodObject<{
+    target_type: z.ZodEnum<["server", "playbook"]>;
+    target_id: z.ZodString;
+    vote: z.ZodEnum<["up", "down"]>;
+    message: z.ZodOptional<z.ZodString>;
+    security_assessment: z.ZodOptional<z.ZodObject<{
+        security_flags: z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+            custom_flag: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            custom_flag: string;
+        }, {
+            custom_flag: string;
+        }>]>, "many">;
+        risk_assessment: z.ZodString;
+        context_note: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        security_flags: (string | {
+            custom_flag: string;
+        })[];
+        risk_assessment: string;
+        context_note?: string | undefined;
+    }, {
+        security_flags: (string | {
+            custom_flag: string;
+        })[];
+        risk_assessment: string;
+        context_note?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    target_type: "server" | "playbook";
+    target_id: string;
+    vote: "up" | "down";
+    message?: string | undefined;
+    security_assessment?: {
+        security_flags: (string | {
+            custom_flag: string;
+        })[];
+        risk_assessment: string;
+        context_note?: string | undefined;
+    } | undefined;
+}, {
+    target_type: "server" | "playbook";
+    target_id: string;
+    vote: "up" | "down";
+    message?: string | undefined;
+    security_assessment?: {
+        security_flags: (string | {
+            custom_flag: string;
+        })[];
+        risk_assessment: string;
+        context_note?: string | undefined;
+    } | undefined;
+}>;
+export type SubmitFeedbackParams = z.infer<typeof SubmitFeedbackParamsSchema>;

package/dist/shared/mcpServerTypes.js

@@ -0,0 +1,148 @@
+// src/types/types.ts
+import { z } from 'zod';
+// --------------------
+// Enums
+// --------------------
+export const TransportTypeSchema = z.enum(['stdio', 'sse']);
+export const RuntimeSchema = z.enum(['node', 'python', 'go', 'docker']);
+// --------------------
+// LLMContext
+// --------------------
+export const LLMContextSchema = z
+    .object({
+    model_family: z.string(),
+    model_name: z.string().min(1),
+    model_version: z.string(),
+    chat_client: z.string().optional(),
+})
+    .strict();
+// --------------------
+// ServerConfig
+// --------------------
+export const ServerConfigSchema = z.object({
+    server_name: z.string().optional(),
+    description: z.string().optional(),
+    command: z.string().optional(),
+    args: z.array(z.string()).optional(),
+    runtime: RuntimeSchema.optional(),
+    env: z.record(z.string()).optional(),
+    url: z.string().optional(),
+    transport: TransportTypeSchema,
+});
+// --------------------
+// InitializeToolplexParams
+// --------------------
+export const InitializeToolplexParamsSchema = z.object({
+    llm_context: LLMContextSchema,
+});
+// --------------------
+// SearchParams
+// --------------------
+export const SearchParamsSchema = z.object({
+    query: z.string(),
+    expanded_keywords: z.array(z.string()).optional(),
+    filter: z.enum(['all', 'servers_only', 'playbooks_only']).optional(),
+    size: z.number().int().min(1).max(25).optional(),
+});
+// --------------------
+// LookupEntityParams
+// --------------------
+export const LookupEntityParamsSchema = z.object({
+    entity_type: z.enum(['server', 'playbook', 'feedback']),
+    entity_id: z.string(),
+});
+// --------------------
+// InstallParams
+// --------------------
+export const InstallParamsSchema = z.object({
+    server_id: z.string(),
+    server_name: z.string(),
+    description: z.string(),
+    config: ServerConfigSchema,
+});
+// --------------------
+// ListToolsParams
+// --------------------
+export const ListToolsParamsSchema = z.object({
+    server_id: z.string().optional(),
+});
+// --------------------
+// GetServerConfigParams
+// --------------------
+export const GetServerConfigParamsSchema = z.object({
+    server_id: z.string().optional(),
+});
+// --------------------
+// CallToolParams
+// --------------------
+export const CallToolParamsSchema = z.object({
+    server_id: z.string(),
+    tool_name: z.string(),
+    arguments: z.record(z.any()),
+});
+// --------------------
+// UninstallParams
+// --------------------
+export const UninstallParamsSchema = z.object({
+    server_id: z.string(),
+});
+// --------------------
+// PlaybookAction (shared type for actions)
+// --------------------
+export const PlaybookActionSchema = z.object({
+    do: z.string(),
+    call: z.string().optional(),
+    args: z
+        .record(z.object({
+        type: z.enum(['string', 'number', 'boolean', 'array', 'object', 'placeholder']),
+        example: z.any(),
+    }))
+        .optional(),
+});
+// --------------------
+// SavePlaybookParams
+// --------------------
+export const SavePlaybookParamsSchema = z.object({
+    description: z.string(),
+    // Requires at least one action to have a "call" property
+    actions: z
+        .array(PlaybookActionSchema)
+        .refine((actions) => actions.some((action) => typeof action.call === 'string' && action.call.length > 0), {
+        message: 'At least one action must include a "call" property',
+        path: ['actions'],
+    }),
+    domain: z.string().optional(),
+    keywords: z.array(z.string()).optional(),
+    requirements: z.array(z.string()).optional(),
+    source_playbook_id: z.string().optional(),
+    fork_reason: z.string().optional(),
+});
+// --------------------
+// LogPlaybookUsageParams
+// --------------------
+export const LogPlaybookUsageParamsSchema = z.object({
+    playbook_id: z.string(),
+    success: z.boolean(),
+    error_message: z.string().optional(),
+});
+// --------------------
+// SubmitFeedbackParams
+// --------------------
+export const SubmitFeedbackParamsSchema = z.object({
+    target_type: z.enum(['server', 'playbook']),
+    target_id: z.string(),
+    vote: z.enum(['up', 'down']),
+    message: z.string().optional(),
+    security_assessment: z
+        .object({
+        security_flags: z.array(z.union([
+            z.string(),
+            z.object({
+                custom_flag: z.string(),
+            }),
+        ])),
+        risk_assessment: z.string(),
+        context_note: z.string().optional(),
+    })
+        .optional(),
+});