@toolplex/client 0.1.1

package/dist/mcp-server/toolHandlers/submitFeedbackHandler.js

@@ -0,0 +1,70 @@
+import { FileLogger } from '../../shared/fileLogger.js';
+import Registry from '../registry.js';
+const logger = FileLogger;
+export async function handleSubmitFeedback(params) {
+    const startTime = Date.now();
+    await logger.info('Handling submit feedback request');
+    await logger.debug(`Feedback params: ${JSON.stringify(params)}`);
+    const { target_type, target_id, vote, message, security_assessment } = params;
+    const apiService = Registry.getToolplexApiService();
+    const telemetryLogger = Registry.getTelemetryLogger();
+    const promptsCache = Registry.getPromptsCache();
+    const policyEnforcer = Registry.getPolicyEnforcer();
+    const clientContext = Registry.getClientContext();
+    try {
+        // Check if the client is in restricted mode
+        if (clientContext.clientMode === 'restricted') {
+            throw new Error('Feedback functionality is disabled in restricted mode.');
+        }
+        // Check if read-only mode is enabled
+        if (clientContext.permissions.enable_read_only_mode) {
+            throw new Error('Saving playbooks is disabled in read-only mode');
+        }
+        // Enforce feedback policy before submitting
+        policyEnforcer.enforceFeedbackPolicy(params);
+        const response = await apiService.submitFeedback(target_type, target_id, vote, message, security_assessment);
+        await logger.info(`Feedback submitted successfully for ${target_type} ${target_id}`);
+        await telemetryLogger.log('client_submit_feedback', {
+            success: true,
+            log_context: {
+                target_type,
+                target_id,
+                feedback_id: response.id,
+            },
+            latency_ms: Date.now() - startTime,
+        });
+        return {
+            role: 'system',
+            content: [
+                {
+                    type: 'text',
+                    text: promptsCache
+                        .getPrompt('submit_feedback_success')
+                        .replace('{FEEDBACK_ID}', response.id),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        await logger.error(`Failed to submit feedback: ${errorMessage}`);
+        await telemetryLogger.log('client_submit_feedback', {
+            success: false,
+            log_context: {
+                target_type,
+                target_id,
+            },
+            pii_sanitized_error_message: errorMessage,
+            latency_ms: Date.now() - startTime,
+        });
+        return {
+            role: 'system',
+            content: [
+                {
+                    type: 'text',
+                    text: promptsCache.getPrompt('unexpected_error').replace('{ERROR}', errorMessage),
+                },
+            ],
+        };
+    }
+}

package/dist/mcp-server/toolHandlers/uninstallServerHandler.d.ts

@@ -0,0 +1,3 @@
+import { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import { UninstallParams } from '../../shared/mcpServerTypes.js';
+export declare function handleUninstallServer(params: UninstallParams): Promise<CallToolResult>;

package/dist/mcp-server/toolHandlers/uninstallServerHandler.js

@@ -0,0 +1,83 @@
+import { findServerManagerClient } from './serverManagerUtils.js';
+import { ServerUninstallResultSchema } from '../../shared/serverManagerTypes.js';
+import { FileLogger } from '../../shared/fileLogger.js';
+import Registry from '../registry.js';
+const logger = FileLogger;
+export async function handleUninstallServer(params) {
+    const startTime = Date.now();
+    const serverManagerClients = Registry.getServerManagerClients();
+    const telemetryLogger = Registry.getTelemetryLogger();
+    const promptsCache = Registry.getPromptsCache();
+    const serversCache = Registry.getServersCache();
+    const clientContext = Registry.getClientContext();
+    const policyEnforcer = Registry.getPolicyEnforcer();
+    const installObserver = policyEnforcer.getInstallObserver();
+    let errorMessage;
+    try {
+        // Check if the client is in restricted mode
+        if (clientContext.clientMode === 'restricted') {
+            throw new Error('Uninstall functionality is disabled in restricted mode.');
+        }
+        const server_id = params.server_id;
+        await logger.info(`Handling uninstall request for server ${server_id}`);
+        const client = await findServerManagerClient(server_id, serverManagerClients);
+        const response = await client.sendRequest('uninstall', { server_id });
+        if ('error' in response) {
+            errorMessage = `Failed to uninstall server_id: ${server_id}, error message: ${response.error.message}`;
+            throw new Error(errorMessage);
+        }
+        const parsed = ServerUninstallResultSchema.safeParse(response);
+        if (!parsed.success) {
+            throw new Error(`Invalid uninstall response: ${parsed.error}`);
+        }
+        // Refresh the servers cache after successful uninstall
+        await serversCache.refreshCache(serverManagerClients);
+        await logger.info(`Successfully uninstalled server ${server_id}`);
+        await telemetryLogger.log('client_uninstall', {
+            success: true,
+            log_context: {
+                server_id: parsed.data.server_id,
+            },
+            latency_ms: Date.now() - startTime,
+        });
+        return {
+            role: 'system',
+            content: [
+                {
+                    type: 'text',
+                    text: promptsCache
+                        .getPrompt('uninstall_success')
+                        .replace('{SERVER_ID}', parsed.data.server_id)
+                        .replace('{SERVER_NAME}', parsed.data.server_name),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            errorMessage = error.message;
+        }
+        else {
+            errorMessage = promptsCache.getPrompt('unexpected_error');
+        }
+        await logger.error(`Failed to uninstall server: ${errorMessage}`);
+        await telemetryLogger.log('client_uninstall', {
+            success: false,
+            pii_sanitized_error_message: errorMessage,
+            latency_ms: Date.now() - startTime,
+        });
+        return {
+            role: 'system',
+            content: [
+                {
+                    type: 'text',
+                    text: promptsCache.getPrompt('uninstall_failure').replace('{ERROR}', errorMessage),
+                },
+            ],
+        };
+    }
+    finally {
+        // Record the uninstall action regardless of success or failure
+        installObserver.recordUninstall(params.server_id);
+    }
+}

package/dist/mcp-server/toolplexApi/service.d.ts

@@ -0,0 +1,32 @@
+import { CreatePlaybookResponse, LogPlaybookUsageResponse, SubmitFeedbackResponse, SecurityAssessment, FeedbackSummaryResponse, LogTelemetryRequest, LogTelemetryBatchResponse, InitResponse } from './types.js';
+import { ClientContext } from '../clientContext.js';
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { PlaybookAction } from '../../shared/mcpServerTypes.js';
+export declare class ToolplexApiService {
+    private readonly baseUrl;
+    private readonly clientContext;
+    private readonly machineContext;
+    constructor(clientContext: ClientContext);
+    private getBaseUrl;
+    private handleFetchResponse;
+    private getBaseHeaders;
+    private getHeadersWithSession;
+    init(): Promise<InitResponse>;
+    getTools(): Promise<{
+        _version: string;
+        tools: Tool[];
+    }>;
+    logTelemetryEvents(events: Array<{
+        eventType: LogTelemetryRequest['event_type'];
+        data: Partial<Omit<LogTelemetryRequest, 'event_type'>>;
+    }>): Promise<LogTelemetryBatchResponse>;
+    lookupEntity(entityType: 'server' | 'playbook' | 'feedback', entityId: string): Promise<any>;
+    search(query: string, expandedKeywords?: string[], filter?: string, size?: number): Promise<{
+        mcp_servers?: any[];
+        playbooks?: any[];
+    }>;
+    createPlaybook(description: string, actions: Array<PlaybookAction>, domain?: string, keywords?: string[], requirements?: string[], sourcePlaybookId?: string, forkReason?: string): Promise<CreatePlaybookResponse>;
+    logPlaybookUsage(playbookId: string, success: boolean, errorMessage?: string): Promise<LogPlaybookUsageResponse>;
+    submitFeedback(targetType: 'server' | 'playbook', targetId: string, vote: 'up' | 'down', message?: string, securityAssessment?: SecurityAssessment): Promise<SubmitFeedbackResponse>;
+    getFeedbackSummary(): Promise<FeedbackSummaryResponse>;
+}

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

@@ -0,0 +1,222 @@
+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-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
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    ) {
+        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
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    ) {
+        const requestBody = {
+            query,
+            expanded_keywords: expandedKeywords,
+            filter,
+            size,
+        };
+        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}`);
+            }
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            return (await response.json());
+        }
+        catch (err) {
+            await logger.error(`Error during search request: ${err}`);
+            throw err;
+        }
+    }
+    async createPlaybook(description, actions, domain, keywords, requirements, sourcePlaybookId, forkReason) {
+        const requestBody = {
+            description,
+            actions,
+            llm_context: this.clientContext.llmContext,
+            domain,
+            keywords,
+            requirements,
+            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/mcp-server/toolplexApi/types.d.ts

@@ -0,0 +1,124 @@
+export interface InitRequest {
+    llm_context: LlmContext;
+}
+export interface ClientPermissions {
+    use_desktop_commander: boolean;
+    enable_read_only_mode: boolean;
+    allowed_mcp_servers?: string[];
+}
+export interface ClientFlags {
+    desktop_commander_server_id: string;
+    blocked_mcp_servers: string[];
+}
+export interface InitResponse {
+    session_id: string;
+    playbooks: {
+        playbooks: Array<{
+            id: string;
+            description: string;
+            times_used: number;
+            days_since_last_used: number | null;
+        }>;
+    };
+    is_org_user: boolean;
+    prompts: Record<string, string>;
+    permissions: ClientPermissions;
+    flags: ClientFlags;
+}
+export type SecurityFlag = string;
+export type RiskLevel = string;
+export interface CustomSecurityFlag {
+    custom_flag: string;
+}
+export interface SecurityAssessment {
+    security_flags: Array<SecurityFlag | CustomSecurityFlag>;
+    risk_assessment: RiskLevel;
+    context_note?: string;
+}
+export interface LlmContext {
+    model_family: string;
+    model_name: string;
+    model_version: string;
+    chat_client?: string;
+}
+export interface CreatePlaybookRequest {
+    description: string;
+    actions: Array<{
+        do: string;
+        call?: string;
+    }>;
+    llm_context: LlmContext;
+    domain?: string;
+    keywords?: string[];
+    requirements?: string[];
+    source_playbook_id?: string;
+    fork_reason?: string;
+}
+export interface CreatePlaybookResponse {
+    id: string;
+    success: boolean;
+}
+export interface LogPlaybookUsageRequest {
+    playbook_id: string;
+    success: boolean;
+    llm_context: LlmContext;
+    error_message?: string;
+}
+export interface LogPlaybookUsageResponse {
+    success: boolean;
+}
+export interface SubmitFeedbackRequest {
+    target_type: 'server' | 'playbook';
+    target_id: string;
+    vote: 'up' | 'down';
+    message?: string;
+    llm_context: LlmContext;
+    machine_context: {
+        os: string;
+        arch: string;
+        memory_gb: number;
+        cpu_cores: string;
+    };
+    security_assessment?: SecurityAssessment;
+}
+export interface SubmitFeedbackResponse {
+    id: string;
+    success: boolean;
+}
+export interface FeedbackSummaryResponse {
+    servers: Array<{
+        server_id: string;
+        upvotes: number;
+        downvotes: number;
+        feedback_ids: string[];
+    }>;
+    playbooks: Array<{
+        playbook_id: string;
+        upvotes: number;
+        downvotes: number;
+    }>;
+}
+export interface LogTelemetryRequest {
+    client_version: string;
+    event_type: string;
+    session_id?: string;
+    agent_id?: string;
+    agent_type?: 'user' | 'system' | 'external';
+    success?: boolean;
+    pii_sanitized_error_message?: string;
+    log_context?: {
+        [key: string]: any;
+    };
+    latency_ms: number;
+    llm_context: {
+        model: string;
+        provider: string;
+    };
+}
+export interface LogTelemetryBatchResponse {
+    success: boolean;
+}
+export interface SearchResponse {
+    mcp_servers?: any[];
+    playbooks?: any[];
+}

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

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

package/dist/mcp-server/toolplexServer.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { ToolplexServerConfig } from '../shared/mcpServerTypes.js';
+export declare function serve(config: ToolplexServerConfig): Promise<void>;