@toolplex/client 0.1.1 → 0.1.2

package/dist/server-manager/stdioServer.js

@@ -1,8 +1,8 @@
 // stdioServer.ts
-import { ServerManager } from './serverManager.js';
-import { StdioTransport, } from './stdioTransportProtocol.js';
-import { FileLogger } from '../shared/fileLogger.js';
-import { CallToolParamsSchema, InstallParamsSchema, ListToolsParamsSchema, UninstallParamsSchema, } from '../shared/mcpServerTypes.js';
+import { ServerManager } from "./serverManager.js";
+import { StdioTransport, } from "./stdioTransportProtocol.js";
+import { FileLogger } from "../shared/fileLogger.js";
+import { CallToolParamsSchema, InstallParamsSchema, ListToolsParamsSchema, UninstallParamsSchema, } from "../shared/mcpServerTypes.js";
 const logger = FileLogger;
 export class ServerManagerProtocol {
     constructor() {
@@ -10,28 +10,28 @@ export class ServerManagerProtocol {
         this.transport = new StdioTransport();
         this.transport.setOnMessage(this.handleMessage.bind(this));
         // Clean up on process exit
-        process.on('exit', async () => {
-            await logger.info('Process exit - cleaning up server manager');
+        process.on("exit", async () => {
+            await logger.info("Process exit - cleaning up server manager");
             await logger.flush();
             await this.serverManager.cleanup();
         });
-        process.on('SIGINT', async () => {
-            await logger.warn('SIGINT received - cleaning up server manager');
+        process.on("SIGINT", async () => {
+            await logger.warn("SIGINT received - cleaning up server manager");
             await logger.flush();
             await this.serverManager.cleanup();
             process.exit();
         });
-        process.on('SIGTERM', async () => {
-            await logger.warn('SIGTERM received - cleaning up server manager');
+        process.on("SIGTERM", async () => {
+            await logger.warn("SIGTERM received - cleaning up server manager");
             await logger.flush();
             await this.serverManager.cleanup();
             process.exit();
         });
     }
     async start() {
-        await logger.info('Starting ServerManagerProtocol transport');
+        await logger.info("Starting ServerManagerProtocol transport");
         await this.transport.start();
-        await logger.info('ServerManagerProtocol transport started successfully');
+        await logger.info("ServerManagerProtocol transport started successfully");
     }
     async safeSend(msg) {
         try {
@@ -43,10 +43,10 @@ export class ServerManagerProtocol {
     }
     async handleMessage(message) {
         try {
-            if (!('id' in message) || !('method' in message)) {
+            if (!("id" in message) || !("method" in message)) {
                 await this.safeSend({
-                    jsonrpc: '2.0',
-                    error: { code: -1001, message: 'Invalid Request' },
+                    jsonrpc: "2.0",
+                    error: { code: -1001, message: "Invalid Request" },
                     id: null,
                 });
                 return;
@@ -57,15 +57,18 @@ export class ServerManagerProtocol {
                 result = await this.callMethod(req.method, req.params ?? {});
             }
             catch (err) {
-                await logger.error(`callMethod failed (${req.method}): ${err instanceof Error ? err.message : 'Unknown error'}`);
+                await logger.error(`callMethod failed (${req.method}): ${err instanceof Error ? err.message : "Unknown error"}`);
                 await this.safeSend({
-                    jsonrpc: '2.0',
-                    error: { code: -1000, message: err instanceof Error ? err.message : 'Server error' },
+                    jsonrpc: "2.0",
+                    error: {
+                        code: -1000,
+                        message: err instanceof Error ? err.message : "Server error",
+                    },
                     id: req.id,
                 });
                 return;
             }
-            await this.safeSend({ jsonrpc: '2.0', result, id: req.id });
+            await this.safeSend({ jsonrpc: "2.0", result, id: req.id });
         }
         catch (fatal) {
             process.stderr.write(`handleMessage fatal: ${String(fatal)}\n`);
@@ -74,57 +77,56 @@ export class ServerManagerProtocol {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     async callMethod(method, params) {
         switch (method) {
-            case 'initialize': {
-                await logger.info('Calling ServerManager.initialize()');
+            case "initialize": {
+                await logger.info("Calling ServerManager.initialize()");
                 const { succeeded, failures } = await this.serverManager.initialize();
                 return { succeeded, failures };
             }
-            case 'install': {
+            case "install": {
                 const install_params = InstallParamsSchema.parse(params);
                 await logger.info(`Installing server ${install_params.server_id}`);
                 await this.serverManager.install(install_params.server_id, install_params.server_name, install_params.description, install_params.config);
                 const server_name = await this.serverManager.getServerName(install_params.server_id);
                 return { server_id: install_params.server_id, server_name };
             }
-            case 'list_servers': {
-                await logger.debug('Listing servers');
+            case "list_servers": {
+                await logger.debug("Listing servers");
                 const servers = await this.serverManager.listServers();
                 return { servers };
             }
-            case 'list_tools': {
+            case "list_tools": {
                 const list_tools_params = ListToolsParamsSchema.parse(params);
                 if (!list_tools_params.server_id)
-                    throw new Error('Missing server_id');
+                    throw new Error("Missing server_id");
                 await logger.debug(`Listing tools for server ${list_tools_params.server_id}`);
                 const tools = await this.serverManager.listTools(list_tools_params.server_id);
                 const server_name = await this.serverManager.getServerName(list_tools_params.server_id);
                 return { server_id: list_tools_params.server_id, server_name, tools };
             }
-            case 'get_server_config': {
-                if (!params || typeof params.server_id !== 'string') {
-                    throw new Error('Missing or invalid server_id');
+            case "get_server_config": {
+                if (!params || typeof params.server_id !== "string") {
+                    throw new Error("Missing or invalid server_id");
                 }
                 await logger.debug(`Getting config for server ${params.server_id}`);
                 // Just return the config directly
                 const config = await this.serverManager.getServerConfig(params.server_id);
                 return config;
             }
-            case 'call_tool': {
+            case "call_tool": {
                 const call_tool_params = CallToolParamsSchema.parse(params);
                 await logger.debug(`Calling tool ${call_tool_params.tool_name} on server ${call_tool_params.server_id}`);
-                const result = await this.serverManager.callTool(call_tool_params.server_id, call_tool_params.tool_name, call_tool_params.arguments, 60000 // 60s timeout
-                );
+                const result = await this.serverManager.callTool(call_tool_params.server_id, call_tool_params.tool_name, call_tool_params.arguments, 60000);
                 return { result };
             }
-            case 'uninstall': {
+            case "uninstall": {
                 const uninstall_params = UninstallParamsSchema.parse(params);
                 await logger.info(`Uninstalling server ${uninstall_params.server_id}`);
                 const server_name = await this.serverManager.getServerName(uninstall_params.server_id);
                 await this.serverManager.uninstall(uninstall_params.server_id);
                 return { server_id: uninstall_params.server_id, server_name };
             }
-            case 'cleanup': {
-                await logger.info('Cleaning up server manager');
+            case "cleanup": {
+                await logger.info("Cleaning up server manager");
                 await this.serverManager.cleanup();
                 return {};
             }

package/dist/server-manager/stdioTransportProtocol.d.ts

@@ -1,6 +1,6 @@
-import { Readable, Writable } from 'node:stream';
+import { Readable, Writable } from "node:stream";
 export interface JSONRPCMessage {
-    jsonrpc: '2.0';
+    jsonrpc: "2.0";
     error?: {
         code: number;
         message: string;

package/dist/server-manager/stdioTransportProtocol.js

@@ -1,4 +1,4 @@
-import * as readline from 'readline';
+import * as readline from "readline";
 export class StdioTransport {
     constructor(_stdin = process.stdin, _stdout = process.stdout) {
         this._stdin = _stdin;
@@ -21,14 +21,14 @@ export class StdioTransport {
             return; // Prevent double initialization
         }
         this.isStarted = true;
-        this._stdin.on('data', this.dataHandler);
+        this._stdin.on("data", this.dataHandler);
     }
     processBuffer() {
         // Join all chunks and split by lines - more efficient than string concatenation
-        const fullBuffer = this.bufferChunks.join('');
-        const lines = fullBuffer.split('\n');
+        const fullBuffer = this.bufferChunks.join("");
+        const lines = fullBuffer.split("\n");
         // Keep the last line in buffer if it's incomplete
-        const incompleteLine = lines.pop() || '';
+        const incompleteLine = lines.pop() || "";
         // Clear chunks and store incomplete line
         this.bufferChunks = incompleteLine ? [incompleteLine] : [];
         for (const line of lines) {
@@ -49,12 +49,12 @@ export class StdioTransport {
         }
     }
     async send(message) {
-        const messageStr = JSON.stringify(message) + '\n';
+        const messageStr = JSON.stringify(message) + "\n";
         this._stdout.write(messageStr);
     }
     async close() {
         if (this.isStarted) {
-            this._stdin.removeListener('data', this.dataHandler);
+            this._stdin.removeListener("data", this.dataHandler);
             this.isStarted = false;
         }
         this.bufferChunks = [];

package/dist/shared/enhancedPath.js

@@ -1,7 +1,7 @@
-import * as path from 'path';
-import { existsSync } from 'fs';
-import { homedir } from 'os';
-import { glob } from 'glob';
+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).
@@ -10,12 +10,12 @@ import { glob } from 'glob';
  */
 export function getEnhancedPath() {
     const home = homedir();
-    const basePaths = (process.env.PATH || '').split(path.delimiter);
+    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('*')) {
+        if (extraPath.includes("*")) {
             const matches = glob.sync(extraPath);
             for (const match of matches) {
                 if (existsSync(match) && !seen.has(match)) {
@@ -37,16 +37,16 @@ export function getEnhancedPath() {
  * Returns platform-specific extra binary paths.
  */
 function getDefaultExtraPaths(home) {
-    const isWindows = process.platform === 'win32';
+    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, "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',
+            path.join(home, ".local/bin"),
+            path.join(home, ".cargo/bin"),
+            "/usr/local/bin",
+            "/opt/homebrew/bin",
         ];
 }

package/dist/shared/fileLogger.js

@@ -1,41 +1,41 @@
-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: '' });
+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')) {
+            !fileName.includes("node_modules") &&
+            !fileName.includes("fileLogger") &&
+            !fileName.includes("callsite")) {
             return path.basename(fileName, path.extname(fileName));
         }
     }
-    return 'unknown';
+    return "unknown";
 }
 export class FileLogger {
     static initialize(processName) {
         if (this.logger)
             return;
         this.processName = processName;
-        const logLevel = process.env.LOG_LEVEL || 'info';
+        const logLevel = process.env.LOG_LEVEL || "info";
         this.transport = new DailyRotateFile({
             dirname: logDir,
             filename: `ToolPlex-${processName}-%DATE%.log`,
-            datePattern: 'YYYY-MM-DD',
-            maxFiles: '7d',
+            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}`;
+                return `${timestamp} [${level.toUpperCase()}] ${module || "unknown"} - ${message}`;
             })),
             defaultMeta: {},
             transports: [this.transport],
@@ -46,20 +46,20 @@ export class FileLogger {
         this.logger.log({ level, message, module });
     }
     static info(message) {
-        this.log('info', message);
+        this.log("info", message);
     }
     static warn(message) {
-        this.log('warn', message);
+        this.log("warn", message);
     }
     static error(message) {
-        this.log('error', message);
+        this.log("error", message);
     }
     static debug(message) {
-        this.log('debug', message);
+        this.log("debug", message);
     }
     static async flush() {
         return new Promise((resolve) => {
-            this.transport.on('finish', resolve);
+            this.transport.on("finish", resolve);
             this.logger.end();
         });
     }

package/dist/shared/mcpServerTypes.d.ts

@@ -1,10 +1,11 @@
-import { z } from 'zod';
-export type ClientMode = 'standard' | 'restricted';
-export type LogLevel = 'error' | 'warn' | 'info' | 'debug';
+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;
+    clientName: string;
     logLevel: LogLevel;
 }
 export declare const TransportTypeSchema: z.ZodEnum<["stdio", "sse"]>;

package/dist/shared/mcpServerTypes.js

@@ -1,10 +1,10 @@
 // src/types/types.ts
-import { z } from 'zod';
+import { z } from "zod";
 // --------------------
 // Enums
 // --------------------
-export const TransportTypeSchema = z.enum(['stdio', 'sse']);
-export const RuntimeSchema = z.enum(['node', 'python', 'go', 'docker']);
+export const TransportTypeSchema = z.enum(["stdio", "sse"]);
+export const RuntimeSchema = z.enum(["node", "python", "go", "docker"]);
 // --------------------
 // LLMContext
 // --------------------
@@ -41,14 +41,14 @@ export const InitializeToolplexParamsSchema = z.object({
 export const SearchParamsSchema = z.object({
     query: z.string(),
     expanded_keywords: z.array(z.string()).optional(),
-    filter: z.enum(['all', 'servers_only', 'playbooks_only']).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_type: z.enum(["server", "playbook", "feedback"]),
     entity_id: z.string(),
 });
 // --------------------
@@ -94,7 +94,14 @@ export const PlaybookActionSchema = z.object({
     call: z.string().optional(),
     args: z
         .record(z.object({
-        type: z.enum(['string', 'number', 'boolean', 'array', 'object', 'placeholder']),
+        type: z.enum([
+            "string",
+            "number",
+            "boolean",
+            "array",
+            "object",
+            "placeholder",
+        ]),
         example: z.any(),
     }))
         .optional(),
@@ -107,9 +114,9 @@ export const SavePlaybookParamsSchema = z.object({
     // 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), {
+        .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'],
+        path: ["actions"],
     }),
     domain: z.string().optional(),
     keywords: z.array(z.string()).optional(),
@@ -129,9 +136,9 @@ export const LogPlaybookUsageParamsSchema = z.object({
 // SubmitFeedbackParams
 // --------------------
 export const SubmitFeedbackParamsSchema = z.object({
-    target_type: z.enum(['server', 'playbook']),
+    target_type: z.enum(["server", "playbook"]),
     target_id: z.string(),
-    vote: z.enum(['up', 'down']),
+    vote: z.enum(["up", "down"]),
     message: z.string().optional(),
     security_assessment: z
         .object({

package/dist/shared/serverManagerTypes.d.ts

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import { z } from "zod";
 export declare const InitializeResultSchema: z.ZodObject<{
     succeeded: z.ZodArray<z.ZodObject<{
         server_id: z.ZodString;

package/dist/shared/serverManagerTypes.js

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import { z } from "zod";
 // --------------------
 // initialize
 // --------------------

package/dist/shared/stdioServerManagerClient.js

@@ -1,33 +1,35 @@
-import { spawn } from 'child_process';
+import { spawn } from "child_process";
 export class StdioServerManagerClient {
     constructor(command, args, env) {
         this.serverProcess = null;
         this.messageHandlers = new Map();
-        this.messageBuffer = '';
+        this.messageBuffer = "";
         this.command = command;
         this.args = args;
         this.env = env ? { ...process.env, ...env } : process.env;
     }
     async start() {
         this.serverProcess = spawn(this.command, this.args, {
-            stdio: ['pipe', 'pipe', 'pipe'],
+            stdio: ["pipe", "pipe", "pipe"],
             env: this.env,
         });
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        this.serverProcess.on('error', (err) => {
+        this.serverProcess.on("error", (err) => {
             process.stderr.write(`Server process error: ${err}\n`);
         });
-        if (!this.serverProcess.stderr || !this.serverProcess.stdout || !this.serverProcess.stdin) {
-            throw new Error('Server process streams not available');
+        if (!this.serverProcess.stderr ||
+            !this.serverProcess.stdout ||
+            !this.serverProcess.stdin) {
+            throw new Error("Server process streams not available");
         }
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        this.serverProcess.stderr.on('data', (data) => {
+        this.serverProcess.stderr.on("data", (data) => {
             process.stderr.write(data);
         });
-        this.serverProcess.stdout.on('data', (data) => {
+        this.serverProcess.stdout.on("data", (data) => {
             this.messageBuffer += data.toString();
-            const lines = this.messageBuffer.split('\n');
-            this.messageBuffer = lines.pop() || '';
+            const lines = this.messageBuffer.split("\n");
+            this.messageBuffer = lines.pop() || "";
             for (const line of lines) {
                 if (!line.trim())
                     continue;
@@ -45,12 +47,12 @@ export class StdioServerManagerClient {
                 }
             }
         });
-        this.serverProcess.on('exit', () => {
+        this.serverProcess.on("exit", () => {
             for (const [, h] of this.messageHandlers)
-                h({ __error__: { message: 'Subprocess exited' } });
+                h({ __error__: { message: "Subprocess exited" } });
             this.messageHandlers.clear();
             this.serverProcess = null;
-            this.messageBuffer = '';
+            this.messageBuffer = "";
         });
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -58,12 +60,12 @@ export class StdioServerManagerClient {
         return new Promise((resolve, reject) => {
             const id = Date.now();
             if (!this.serverProcess?.stdin) {
-                reject(Error('Server process not started'));
+                reject(Error("Server process not started"));
             }
             else {
                 this.messageHandlers.set(id, (frame) => {
                     if (frame.error || frame.__error__) {
-                        const msg = frame.error?.message ?? frame.__error__?.message ?? 'MCP error';
+                        const msg = frame.error?.message ?? frame.__error__?.message ?? "MCP error";
                         reject(new Error(msg));
                     }
                     else {
@@ -71,11 +73,11 @@ export class StdioServerManagerClient {
                     }
                 });
                 this.serverProcess.stdin.write(JSON.stringify({
-                    jsonrpc: '2.0',
+                    jsonrpc: "2.0",
                     method,
                     params,
                     id,
-                }) + '\n');
+                }) + "\n");
             }
             setTimeout(() => {
                 if (this.messageHandlers.has(id)) {
@@ -90,7 +92,7 @@ export class StdioServerManagerClient {
             this.serverProcess.kill();
             this.serverProcess = null;
             this.messageHandlers.clear();
-            this.messageBuffer = '';
+            this.messageBuffer = "";
         }
     }
 }

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "1.0.8";
+export declare const version = "0.1.1";

package/dist/version.js

@@ -1 +1 @@
-export const version = '1.0.8';
+export const version = '0.1.1';

package/package.json

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