@toolplex/client 0.1.6 → 0.1.8

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

@@ -2,7 +2,71 @@ import { FileLogger } from "../../shared/fileLogger.js";
 import { ServerInstallResultSchema, ListToolsResultSchema, } from "../../shared/serverManagerTypes.js";
 import Registry from "../registry.js";
 import { RuntimeCheck } from "../utils/runtimeCheck.js";
+import { isAbsolute, parse } from "path";
 const logger = FileLogger;
+/**
+ * Sanitizes ServerConfig for telemetry logging by extracting aggregate patterns
+ * while avoiding PII exposure. This function extracts useful installation patterns
+ * without logging sensitive data like file paths, API keys, or user-specific values.
+ *
+ * SECURITY: This function only logs metadata patterns, never actual values:
+ * - Command names (not paths): "npx" vs "/Users/john/bin/tool"
+ * - Argument flags (not values): "--port" vs actual port numbers
+ * - Environment variable names (not values): "API_KEY" vs actual keys
+ * - Path types for portability analysis: "absolute" vs "package_manager"
+ */
+function sanitizeServerConfig(config) {
+    // Extract command executable name without sensitive path information
+    const extractCommandType = (command) => {
+        if (!command)
+            return "none";
+        // For absolute paths, extract only the executable name (e.g., "/usr/bin/node" -> "node")
+        if (isAbsolute(command)) {
+            return parse(command).name;
+        }
+        // For relative commands, get the base command (e.g., "npx" from "npx --version")
+        return (command
+            .split(/[\s/\\]/)
+            .pop()
+            ?.split(".")[0] || "unknown");
+    };
+    // Categorize path types for portability analysis - helps identify installation reliability patterns
+    const detectPathType = (command, args) => {
+        if (!command)
+            return "system_command";
+        // Absolute paths indicate potential portability issues
+        if (isAbsolute(command) || args?.some((arg) => isAbsolute(arg))) {
+            return "absolute";
+        }
+        // Package managers are typically more reliable across systems
+        if (["npx", "uvx", "pip", "yarn", "pnpm"].includes(command)) {
+            return "package_manager";
+        }
+        return "system_command";
+    };
+    // Extract common argument flags and patterns (not values) for usage analysis
+    const extractArgPatterns = (args) => {
+        return (args?.filter((arg) => arg.startsWith("-") || // Command flags like --port, --config
+            ["stdio", "mcp", "start", "latest", "@latest"].includes(arg)) || []);
+    };
+    // Extract environment variable names (not values) to understand integration patterns
+    // SAFE: Only logs key names like "API_KEY", "DATABASE_URL" - never the actual values
+    const extractEnvKeys = (env) => {
+        if (!env)
+            return [];
+        return Object.keys(env).sort();
+    };
+    return {
+        runtime: config.runtime || "node",
+        transport: config.transport,
+        command_type: extractCommandType(config.command),
+        path_type: detectPathType(config.command, config.args),
+        arg_patterns: extractArgPatterns(config.args),
+        arg_count: config.args?.length || 0,
+        env_keys: extractEnvKeys(config.env),
+        env_count: config.env ? Object.keys(config.env).length : 0,
+    };
+}
 async function installServer(serverId, serverName, description, serverManagerClient, serverConfig) {
     await logger.info(`Starting installation of tool ${serverId}: ${serverName}`);
     await logger.debug(`Server config: ${JSON.stringify(serverConfig)}, Server ID: ${serverId}`);
@@ -91,6 +155,7 @@ export async function handleInstallServer(params) {
             success: true,
             log_context: {
                 server_id: installResult.server_id,
+                sanitized_config: sanitizeServerConfig(config),
             },
             latency_ms: Date.now() - startTime,
         });

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

@@ -20,7 +20,7 @@ export async function handleLookupEntityTool(params) {
         if (params.entity_type === "server") {
             policyEnforcer.enforceUseServerPolicy(params.entity_id);
         }
-        let lookupResponse = await apiService.lookupEntity(params.entity_type, params.entity_id);
+        const lookupResponse = await apiService.lookupEntity(params.entity_type, params.entity_id);
         // Annotate installed server using resultAnnotators
         if (params.entity_type === "server" &&
             lookupResponse &&

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

@@ -21,8 +21,8 @@ export async function handleSavePlaybook(params) {
         }
         // Enforce playbook policy before saving
         policyEnforcer.enforceSavePlaybookPolicy(params);
-        const { description, actions, domain, keywords, requirements, privacy, source_playbook_id, fork_reason, } = params;
-        const response = await apiService.createPlaybook(description, actions, domain, keywords, requirements, privacy, source_playbook_id, fork_reason);
+        const { playbook_name, description, actions, domain, keywords, requirements, privacy, source_playbook_id, fork_reason, } = params;
+        const response = await apiService.createPlaybook(playbook_name, description, actions, domain, keywords, requirements, privacy, source_playbook_id, fork_reason);
         await logger.info(`Playbook created successfully with ID: ${response.id}`);
         await telemetryLogger.log("client_save_playbook", {
             success: true,

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

@@ -25,7 +25,7 @@ export declare class ToolplexApiService {
         mcp_servers?: any[];
         playbooks?: any[];
     }>;
-    createPlaybook(description: string, actions: Array<PlaybookAction>, domain?: string, keywords?: string[], requirements?: string[], privacy?: "public" | "private", sourcePlaybookId?: string, forkReason?: string): Promise<CreatePlaybookResponse>;
+    createPlaybook(playbook_name: string, description: string, actions: Array<PlaybookAction>, domain?: string, keywords?: string[], requirements?: string[], privacy?: "public" | "private", 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

@@ -136,8 +136,9 @@ export class ToolplexApiService {
             throw err;
         }
     }
-    async createPlaybook(description, actions, domain, keywords, requirements, privacy, sourcePlaybookId, forkReason) {
+    async createPlaybook(playbook_name, description, actions, domain, keywords, requirements, privacy, sourcePlaybookId, forkReason) {
         const requestBody = {
+            playbook_name,
             description,
             actions,
             llm_context: this.clientContext.llmContext,

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

@@ -43,6 +43,7 @@ export interface LlmContext {
     chat_client?: string;
 }
 export interface CreatePlaybookRequest {
+    playbook_name: string;
     description: string;
     actions: Array<{
         do: string;

package/dist/shared/mcpServerTypes.d.ts

@@ -252,6 +252,7 @@ export declare const PlaybookActionSchema: z.ZodObject<{
 }>;
 export type PlaybookAction = z.infer<typeof PlaybookActionSchema>;
 export declare const SavePlaybookParamsSchema: z.ZodObject<{
+    playbook_name: z.ZodString;
     description: z.ZodString;
     actions: z.ZodEffects<z.ZodArray<z.ZodObject<{
         do: z.ZodString;
@@ -303,6 +304,7 @@ export declare const SavePlaybookParamsSchema: z.ZodObject<{
     fork_reason: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     description: string;
+    playbook_name: string;
     actions: {
         do: string;
         args?: Record<string, {
@@ -319,6 +321,7 @@ export declare const SavePlaybookParamsSchema: z.ZodObject<{
     fork_reason?: string | undefined;
 }, {
     description: string;
+    playbook_name: string;
     actions: {
         do: string;
         args?: Record<string, {

package/dist/shared/mcpServerTypes.js

@@ -111,6 +111,7 @@ export const PlaybookActionSchema = z.object({
 // SavePlaybookParams
 // --------------------
 export const SavePlaybookParamsSchema = z.object({
+    playbook_name: z.string(),
     description: z.string(),
     // Requires at least one action to have a "call" property
     actions: z

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "0.1.6";
+export declare const version = "0.1.8";

package/dist/version.js

@@ -1 +1 @@
-export const version = '0.1.6';
+export const version = '0.1.8';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toolplex/client",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "author": "ToolPlex LLC",
   "license": "SEE LICENSE IN LICENSE",
   "description": "The official ToolPlex client for AI agent tool discovery and execution",