@toolplex/client 0.1.18 → 0.1.19

package/dist/src/mcp-server/toolHandlers/initHandler.js

@@ -0,0 +1,185 @@
+import { FileLogger } from "../../shared/fileLogger.js";
+import os from "os";
+import { initServerManagersOnly } from "../utils/initServerManagers.js";
+import Registry from "../registry.js";
+import envPaths from "env-paths";
+import which from "which";
+import { getEnhancedPath } from "../../shared/enhancedPath.js";
+import * as fs from "fs";
+const logger = FileLogger;
+/**
+ * Helper to resolve dependency path with fallback:
+ * 1. Bundled dependency (if available)
+ * 2. System PATH (fallback)
+ * 3. "not available" if neither exists
+ *
+ * Exported for testing purposes.
+ */
+export function resolveDependencyForInit(bundledPath, commandName) {
+    // Check bundled first
+    if (bundledPath && fs.existsSync(bundledPath)) {
+        return bundledPath;
+    }
+    // Fall back to system PATH
+    try {
+        const enhancedPath = getEnhancedPath();
+        const systemPath = which.sync(commandName, {
+            path: enhancedPath,
+            nothrow: true,
+        });
+        if (systemPath) {
+            return `${systemPath} (system)`;
+        }
+    }
+    catch {
+        // Ignore errors, will return "not available"
+    }
+    return "not available";
+}
+export async function handleInitialize(params) {
+    const startTime = Date.now();
+    await logger.info("Initializing ToolPlex");
+    await logger.debug(`Initialization params: ${JSON.stringify(params)}`);
+    const clientContext = Registry.getClientContext();
+    const apiService = Registry.getToolplexApiService();
+    const serverManagerClients = Registry.getServerManagerClients();
+    const telemetryLogger = Registry.getTelemetryLogger();
+    const promptsCache = Registry.getPromptsCache();
+    const serversCache = Registry.getServersCache();
+    const policyEnforcer = Registry.getPolicyEnforcer();
+    await logger.debug(`Server manager clients: ${Object.keys(serverManagerClients).join(", ")}`);
+    const platform = os.platform();
+    const osName = platform === "darwin"
+        ? "macOS"
+        : platform === "win32"
+            ? "Windows"
+            : platform.charAt(0).toUpperCase() + platform.slice(1);
+    const paths = envPaths("ToolPlex", { suffix: "" });
+    // Get bundled dependency information
+    const bundledDeps = Registry.getBundledDependencies();
+    const systemInfo = {
+        os: `${osName} ${os.release()}`,
+        arch: os.arch(),
+        memory: `${Math.round(os.totalmem() / (1024 * 1024 * 1024))}GB`,
+        cpuCores: os.cpus().length,
+        workDir: paths.data,
+        date: new Date().toLocaleDateString("en-US", {
+            weekday: "long",
+            year: "numeric",
+            month: "long",
+            day: "numeric",
+        }),
+        // Resolve dependency paths with bundled > system > not available priority
+        nodePath: resolveDependencyForInit(bundledDeps.node, "node"),
+        pythonPath: resolveDependencyForInit(bundledDeps.python, platform === "win32" ? "python" : "python3"),
+        gitPath: resolveDependencyForInit(bundledDeps.git, "git"),
+        uvxPath: resolveDependencyForInit(bundledDeps.uvx, "uvx"),
+        npxPath: resolveDependencyForInit(bundledDeps.npx, "npx"),
+    };
+    await logger.debug("Initializing server managers and API service");
+    const [serverManagerInitResults, toolplexApiInitResponse] = await Promise.all([
+        initServerManagersOnly(serverManagerClients).catch((err) => {
+            logger.warn(`Server manager init failed: ${err}`);
+            return { succeeded: [], failures: {} };
+        }),
+        apiService.init(),
+    ]);
+    clientContext.isOrgUser = toolplexApiInitResponse.is_org_user;
+    clientContext.sessionId = toolplexApiInitResponse.session_id;
+    clientContext.permissions = toolplexApiInitResponse.permissions;
+    clientContext.flags = toolplexApiInitResponse.flags;
+    // Replace {ARGS.workDir} in all prompts before initializing the cache
+    const processedPrompts = { ...toolplexApiInitResponse.prompts };
+    for (const [key, prompt] of Object.entries(processedPrompts)) {
+        if (typeof prompt === "string") {
+            processedPrompts[key] = prompt.replace(/\{ARGS\.workDir\}/g, paths.data);
+        }
+    }
+    promptsCache.init(processedPrompts);
+    // Init PolicyEnforce after setting permissions and flags
+    policyEnforcer.init(clientContext);
+    const allSucceeded = serverManagerInitResults.succeeded;
+    const allFailures = serverManagerInitResults.failures;
+    // Initialize the serversCache with the succeeded servers
+    serversCache.init(allSucceeded);
+    await logger.debug(`Total successes: ${allSucceeded.length}, Total failures: ${Object.keys(allFailures).length}`);
+    await logger.debug("Building initialization response");
+    // Safe to use prompts after init.
+    const result = {
+        content: [
+            {
+                type: "text",
+                text: promptsCache
+                    .getPrompt("initialization")
+                    .replace("{ARGS.os}", systemInfo.os)
+                    .replace("{ARGS.arch}", systemInfo.arch)
+                    .replace("{ARGS.memory}", systemInfo.memory)
+                    .replace("{ARGS.cpuCores}", systemInfo.cpuCores.toString())
+                    .replace("{ARGS.workDir}", systemInfo.workDir)
+                    .replace("{ARGS.date}", systemInfo.date)
+                    .replace("{ARGS.nodePath}", systemInfo.nodePath)
+                    .replace("{ARGS.pythonPath}", systemInfo.pythonPath)
+                    .replace("{ARGS.gitPath}", systemInfo.gitPath)
+                    .replace("{ARGS.uvxPath}", systemInfo.uvxPath)
+                    .replace("{ARGS.npxPath}", systemInfo.npxPath),
+            },
+        ],
+    };
+    result.content.push({
+        type: "text",
+        text: promptsCache
+            .getPrompt("initialization_results")
+            .replace("{SUCCEEDED}", allSucceeded
+            .map((s) => `${s.server_id} (${s.server_name})`)
+            .join(", ") || "none")
+            .replace("{FAILURES}", Object.entries(allFailures)
+            .map(([serverId, failure]) => `${serverId} (${failure.server_name}): ${failure.error}`)
+            .join(", ") || "none")
+            .replace("{FAILURE_NOTE}", Object.keys(allFailures).length > 0
+            ? "Please note there were failures installing some servers. Inform the user."
+            : ""),
+    });
+    if (clientContext.permissions.allowed_mcp_servers &&
+        clientContext.permissions.allowed_mcp_servers.length > 0) {
+        result.content.push({
+            type: "text",
+            text: promptsCache
+                .getPrompt("allowed_mcp_servers")
+                .replace("{ALLOWED_MCP_SERVERS}", clientContext.permissions.allowed_mcp_servers.join(", ")),
+        });
+    }
+    result.content.push({
+        type: "text",
+        text: "Your Most Recently Used Playbooks:\n" +
+            toolplexApiInitResponse.playbooks.playbooks
+                .map((p) => `- ${p.id}: ${p.description}\n` +
+                `  Used ${p.times_used} times` +
+                (p.days_since_last_used !== null
+                    ? `, last use: ${p.days_since_last_used} ${p.days_since_last_used === 1 ? "day" : "days"} ago`
+                    : ""))
+                .join("\n") +
+            "\n\nMore playbooks are available through the search tool.",
+    });
+    if (toolplexApiInitResponse.announcement) {
+        result.content.push({
+            type: "text",
+            text: `\nToolPlex Platform Announcements: ${toolplexApiInitResponse.announcement}`,
+        });
+    }
+    await telemetryLogger.log("client_initialize_toolplex", {
+        session_id: toolplexApiInitResponse.session_id,
+        success: Object.keys(allFailures).length === 0,
+        log_context: {
+            os_platform: platform,
+            os_arch: systemInfo.arch,
+            cpu_cores: systemInfo.cpuCores,
+            total_memory_gb: Math.round(os.totalmem() / (1024 * 1024 * 1024)),
+            num_succeeded_servers: allSucceeded.length,
+            num_failed_servers: Object.keys(allFailures).length,
+            num_recent_playbooks: toolplexApiInitResponse.playbooks.playbooks.length,
+        },
+        latency_ms: Date.now() - startTime,
+    });
+    await logger.info("ToolPlex initialization completed");
+    return result;
+}

package/dist/src/mcp-server/toolplexApi/service.js

@@ -0,0 +1,221 @@
+import fetch from "node-fetch";
+import { FileLogger } from "../../shared/fileLogger.js";
+import os from "os";
+const logger = FileLogger;
+export class ToolplexApiService {
+    constructor(clientContext) {
+        if (!clientContext.apiKey) {
+            throw new Error("API key not set in client context");
+        }
+        if (!clientContext.clientVersion) {
+            throw new Error("Client version not set in client context");
+        }
+        this.clientContext = clientContext;
+        this.baseUrl = this.getBaseUrl(clientContext.dev);
+        this.machineContext = {
+            os: `${os.platform()} ${os.release()}`,
+            arch: os.arch(),
+            memory_gb: Math.round(os.totalmem() / (1024 * 1024 * 1024)),
+            cpu_cores: os.cpus().length.toString(),
+        };
+    }
+    getBaseUrl(dev) {
+        return dev ? "http://localhost:8080" : "https://api.toolplex.ai";
+    }
+    async handleFetchResponse(response) {
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`HTTP ${response.status}: ${error}`);
+        }
+        return response.json();
+    }
+    getBaseHeaders() {
+        return {
+            "Content-Type": "application/json",
+            Accept: "application/json",
+            "x-api-key": this.clientContext.apiKey,
+            "x-client-mode": this.clientContext.clientMode,
+            "x-client-name": this.clientContext.clientName,
+            "x-client-version": this.clientContext.clientVersion,
+        };
+    }
+    getHeadersWithSession() {
+        return {
+            ...this.getBaseHeaders(),
+            "x-session-id": this.clientContext.sessionId,
+        };
+    }
+    async init() {
+        try {
+            const initRequest = {
+                llm_context: this.clientContext.llmContext,
+            };
+            const response = await fetch(`${this.baseUrl}/init`, {
+                method: "POST",
+                headers: this.getBaseHeaders(),
+                body: JSON.stringify(initRequest),
+            });
+            return this.handleFetchResponse(response);
+        }
+        catch (err) {
+            await logger.error(`Error initializing session: ${err}`);
+            throw err;
+        }
+    }
+    async getTools() {
+        try {
+            const response = await fetch(`${this.baseUrl}/tools`, {
+                method: "POST",
+                headers: this.getBaseHeaders(),
+                body: JSON.stringify({}),
+            });
+            return this.handleFetchResponse(response);
+        }
+        catch (err) {
+            await logger.error(`Error fetching tool definitions: ${err}`);
+            throw err;
+        }
+    }
+    async logTelemetryEvents(events) {
+        try {
+            const response = await fetch(`${this.baseUrl}/telemetry/log/batch`, {
+                method: "POST",
+                headers: this.getHeadersWithSession(),
+                body: JSON.stringify(events.map((event) => ({
+                    event_type: event.eventType,
+                    ...event.data,
+                }))),
+            });
+            return this.handleFetchResponse(response);
+        }
+        catch (err) {
+            await logger.error(`Error batch logging telemetry events: ${err}`);
+            return { success: false };
+        }
+    }
+    async lookupEntity(entityType, entityId) {
+        try {
+            const response = await fetch(`${this.baseUrl}/lookup-entity`, {
+                method: "POST",
+                headers: this.getHeadersWithSession(),
+                body: JSON.stringify({
+                    entity_type: entityType,
+                    entity_id: entityId,
+                }),
+            });
+            return this.handleFetchResponse(response);
+        }
+        catch (err) {
+            await logger.error(`Error looking up entity: ${err}`);
+            throw err;
+        }
+    }
+    async search(query, expandedKeywords = [], filter = "all", size = 10, scope = "all") {
+        const requestBody = {
+            query,
+            expanded_keywords: expandedKeywords,
+            filter,
+            size,
+            scope,
+        };
+        await logger.debug(`Searching API at ${this.baseUrl} with query: ${query}`);
+        try {
+            const response = await fetch(`${this.baseUrl}/search`, {
+                method: "POST",
+                headers: this.getHeadersWithSession(),
+                body: JSON.stringify(requestBody),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`HTTP ${response.status}: ${errorText}`);
+            }
+            return (await response.json());
+        }
+        catch (err) {
+            await logger.error(`Error during search request: ${err}`);
+            throw err;
+        }
+    }
+    async createPlaybook(playbook_name, description, actions, domain, keywords, requirements, privacy, sourcePlaybookId, forkReason) {
+        const requestBody = {
+            playbook_name,
+            description,
+            actions,
+            llm_context: this.clientContext.llmContext,
+            domain,
+            keywords,
+            requirements,
+            privacy,
+            source_playbook_id: sourcePlaybookId,
+            fork_reason: forkReason,
+        };
+        try {
+            const response = await fetch(`${this.baseUrl}/playbooks/create`, {
+                method: "POST",
+                headers: this.getHeadersWithSession(),
+                body: JSON.stringify(requestBody),
+            });
+            return this.handleFetchResponse(response);
+        }
+        catch (err) {
+            await logger.error(`Error creating playbook: ${err}`);
+            throw err;
+        }
+    }
+    async logPlaybookUsage(playbookId, success, errorMessage) {
+        const requestBody = {
+            playbook_id: playbookId,
+            success,
+            llm_context: this.clientContext.llmContext,
+            error_message: errorMessage,
+        };
+        try {
+            const response = await fetch(`${this.baseUrl}/playbooks/log-usage`, {
+                method: "POST",
+                headers: this.getHeadersWithSession(),
+                body: JSON.stringify(requestBody),
+            });
+            return this.handleFetchResponse(response);
+        }
+        catch (err) {
+            await logger.error(`Error logging playbook usage: ${err}`);
+            throw err;
+        }
+    }
+    async submitFeedback(targetType, targetId, vote, message, securityAssessment) {
+        const requestBody = {
+            target_type: targetType,
+            target_id: targetId,
+            vote,
+            message,
+            llm_context: this.clientContext.llmContext,
+            machine_context: this.machineContext,
+            security_assessment: securityAssessment,
+        };
+        try {
+            const response = await fetch(`${this.baseUrl}/feedback/submit`, {
+                method: "POST",
+                headers: this.getHeadersWithSession(),
+                body: JSON.stringify(requestBody),
+            });
+            return this.handleFetchResponse(response);
+        }
+        catch (err) {
+            await logger.error(`Error submitting feedback: ${err}`);
+            throw err;
+        }
+    }
+    async getFeedbackSummary() {
+        try {
+            const response = await fetch(`${this.baseUrl}/feedback/summarize`, {
+                method: "GET",
+                headers: this.getHeadersWithSession(),
+            });
+            return this.handleFetchResponse(response);
+        }
+        catch (err) {
+            await logger.error(`Error getting feedback summary: ${err}`);
+            throw err;
+        }
+    }
+}

package/dist/src/mcp-server/toolplexApi/types.js

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

package/dist/src/mcp-server/utils/initServerManagers.js

@@ -0,0 +1,31 @@
+import { InitializeResultSchema, } from "../../shared/serverManagerTypes.js";
+import { FileLogger } from "../../shared/fileLogger.js";
+const logger = FileLogger;
+export async function initServerManagersOnly(serverManagerClients) {
+    await logger.info("Pre-warming server manager clients");
+    const initPromises = Object.entries(serverManagerClients).map(async ([runtime, client]) => {
+        try {
+            const response = await client.sendRequest("initialize", {});
+            if ("error" in response)
+                throw new Error(response.error.message);
+            const parsed = InitializeResultSchema.safeParse(response);
+            if (!parsed.success)
+                throw new Error(parsed.error.message);
+            return { runtime, result: parsed.data };
+        }
+        catch (err) {
+            await logger.error(`Warmup error for ${runtime}: ${err}`);
+            return { runtime, result: { succeeded: [], failures: {} } };
+        }
+    });
+    const results = await Promise.all(initPromises);
+    const allSucceeded = [];
+    const allFailures = {};
+    for (const { runtime, result } of results) {
+        allSucceeded.push(...(result.succeeded || []));
+        Object.assign(allFailures, result.failures || {});
+        await logger.debug(`Warmup result for ${runtime}: ${JSON.stringify(result)}`);
+    }
+    await logger.debug(`Warmup completed: ${allSucceeded.length} successes, ${Object.keys(allFailures).length} failures`);
+    return { succeeded: allSucceeded, failures: allFailures };
+}

package/dist/src/mcp-server/utils/runtimeCheck.js

@@ -0,0 +1,94 @@
+import { getEnhancedPath } from "../../shared/enhancedPath.js";
+import which from "which";
+import Registry from "../registry.js";
+import * as fs from "fs";
+const INSTALL_HINTS = {
+    uvx: "Install uvx: https://docs.astral.sh/uv/getting-started/installation/",
+    uv: "Install uv: https://docs.astral.sh/uv/getting-started/installation/",
+    python: "Install Python: https://www.python.org/downloads/. Or check if you have `python3` installed.",
+    python3: "Install Python: https://www.python.org/downloads/. Or check if you have `python` installed.",
+    node: "Install Node.js: https://nodejs.org/en/download/",
+    npx: "Install npx (comes with Node.js): https://nodejs.org/en/download/",
+    git: "Install Git: https://git-scm.com/downloads",
+};
+// Commands that should use bundled dependencies (required)
+const BUNDLED_DEPENDENCY_COMMANDS = [
+    "node",
+    "python",
+    "python3",
+    "git",
+    "npx",
+    "uvx",
+];
+export class RuntimeCheck {
+    /**
+     * Resolve a dependency path with priority order:
+     * 1. Bundled dependencies (if provided by host application like ToolPlex Desktop)
+     * 2. System PATH (fallback for standalone @client usage)
+     * 3. Error if neither available
+     *
+     * This allows ToolPlex Desktop to provide reliable bundled dependencies while
+     * still supporting standalone users who have system dependencies installed.
+     *
+     * @param commandName - The command to resolve
+     * @returns The full path to the command executable
+     * @throws Error if the command is not available in bundled deps or system PATH
+     */
+    static resolveDependency(commandName) {
+        // Check if this is a known bundled dependency type
+        const isBundledDep = BUNDLED_DEPENDENCY_COMMANDS.includes(commandName);
+        if (isBundledDep) {
+            // Priority 1: Try bundled dependency first (preferred for ToolPlex Desktop)
+            const bundledPath = Registry.getBundledDependencyPath(commandName);
+            if (bundledPath && fs.existsSync(bundledPath)) {
+                return bundledPath;
+            }
+            // Handle python3 -> python mapping for bundled deps
+            if (commandName === "python3") {
+                const pythonPath = Registry.getBundledDependencyPath("python");
+                if (pythonPath && fs.existsSync(pythonPath)) {
+                    return pythonPath;
+                }
+            }
+            // Priority 2: Fall back to system PATH (for standalone @client usage)
+            const enhancedPath = getEnhancedPath();
+            const resolved = which.sync(commandName, {
+                path: enhancedPath,
+                nothrow: true,
+            });
+            if (resolved) {
+                return resolved;
+            }
+            // Priority 3: Neither bundled nor system available - error
+            const hint = INSTALL_HINTS[commandName];
+            throw new Error(`Missing required command: '${commandName}'.\n` +
+                `This command is not available in bundled dependencies or system PATH.\n` +
+                (hint ? `👉 ${hint}` : ""));
+        }
+        // For non-bundled dependencies, only check system PATH
+        const enhancedPath = getEnhancedPath();
+        const resolved = which.sync(commandName, {
+            path: enhancedPath,
+            nothrow: true,
+        });
+        if (!resolved) {
+            const hint = INSTALL_HINTS[commandName];
+            if (hint) {
+                throw new Error(`Missing required command: '${commandName}'.\n👉 ${hint}`);
+            }
+            throw new Error(`Command '${commandName}' not found in enhanced PATH. Please install it manually or check your config.`);
+        }
+        return resolved;
+    }
+    /**
+     * Validate that a command is available (either bundled or in system PATH).
+     * Throws an error if the command is not found.
+     */
+    static validateCommandOrThrow(rawCommand) {
+        const command = this.extractCommandName(rawCommand);
+        this.resolveDependency(command);
+    }
+    static extractCommandName(command) {
+        return command.trim().split(/\s+/)[0];
+    }
+}

package/dist/src/shared/enhancedPath.js

@@ -0,0 +1,52 @@
+import * as path from "path";
+import * as fs 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 (fs.existsSync(match) && !seen.has(match)) {
+                    seen.add(match);
+                    allPaths.unshift(match);
+                }
+            }
+        }
+        else {
+            if (fs.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/src/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();
+        });
+    }
+}