@toolplex/client 0.1.18 → 0.1.20

package/dist/src/shared/mcpServerTypes.js

@@ -0,0 +1,158 @@
+// 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(),
+    scope: z.enum(["all", "public_only", "private_only"]).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({
+    playbook_name: z.string(),
+    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(),
+    privacy: z.enum(["public", "private"]).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(),
+});

package/dist/src/shared/serverManagerTypes.js

@@ -0,0 +1,73 @@
+import { z } from "zod";
+// --------------------
+// initialize
+// --------------------
+export const InitializeResultSchema = z.object({
+    succeeded: z.array(z.object({
+        server_id: z.string(),
+        server_name: z.string(),
+        description: z.string(),
+    })),
+    failures: z.record(z.object({
+        server_id: z.string(),
+        server_name: z.string(),
+        error: z.string(),
+    })),
+});
+// --------------------
+// Install
+// --------------------
+export const ServerInstallResultSchema = z.object({
+    server_id: z.string(),
+    server_name: z.string(),
+});
+// --------------------
+// Uninstall
+// --------------------
+export const ServerUninstallResultSchema = z.object({
+    server_id: z.string(),
+    server_name: z.string(),
+});
+// --------------------
+// list_servers
+// --------------------
+export const ListServersResultSchema = z.object({
+    servers: z.array(z.object({
+        server_id: z.string(),
+        server_name: z.string(),
+        description: z.string(),
+        tool_count: z.number(),
+    })),
+});
+// --------------------
+// list_tools
+// --------------------
+export const ListToolsResultSchema = z.object({
+    server_id: z.string(),
+    server_name: z.string(),
+    tools: z.array(z.object({
+        name: z.string(),
+        description: z.string().optional(),
+        inputSchema: z.any(),
+    })),
+});
+// --------------------
+// list_all_tools
+// --------------------
+export const ListAllToolsResultSchema = z.object({
+    tools: z.record(z.array(z.object({
+        name: z.string(),
+        description: z.string().optional(),
+        inputSchema: z.any(),
+    }))),
+});
+// --------------------
+// call_tool
+// --------------------
+export const CallToolResultSchema = z.object({
+    result: z.any(),
+});
+// --------------------
+// cleanup
+// --------------------
+export const CleanupResultSchema = z.object({});

package/dist/src/shared/stdioServerManagerClient.js

@@ -0,0 +1,98 @@
+import { spawn } from "child_process";
+export class StdioServerManagerClient {
+    constructor(command, args, env) {
+        this.serverProcess = null;
+        this.messageHandlers = new Map();
+        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"],
+            env: this.env,
+        });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        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");
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.serverProcess.stderr.on("data", (data) => {
+            process.stderr.write(data);
+        });
+        this.serverProcess.stdout.on("data", (data) => {
+            this.messageBuffer += data.toString();
+            const lines = this.messageBuffer.split("\n");
+            this.messageBuffer = lines.pop() || "";
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                try {
+                    const message = JSON.parse(line.trim());
+                    const handler = this.messageHandlers.get(message.id);
+                    if (handler) {
+                        handler(message);
+                        this.messageHandlers.delete(message.id);
+                    }
+                }
+                catch (e) {
+                    process.stderr.write(`Raw line: ${line}\n`);
+                    process.stderr.write(`Parse error: ${e}\n`);
+                }
+            }
+        });
+        this.serverProcess.on("exit", () => {
+            for (const [, h] of this.messageHandlers)
+                h({ __error__: { message: "Subprocess exited" } });
+            this.messageHandlers.clear();
+            this.serverProcess = null;
+            this.messageBuffer = "";
+        });
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async sendRequest(method, params) {
+        return new Promise((resolve, reject) => {
+            const id = Date.now();
+            if (!this.serverProcess?.stdin) {
+                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";
+                        reject(new Error(msg));
+                    }
+                    else {
+                        resolve(frame.result);
+                    }
+                });
+                this.serverProcess.stdin.write(JSON.stringify({
+                    jsonrpc: "2.0",
+                    method,
+                    params,
+                    id,
+                }) + "\n");
+            }
+            setTimeout(() => {
+                if (this.messageHandlers.has(id)) {
+                    this.messageHandlers.delete(id);
+                    reject(new Error(`Request timed out: ${method}`));
+                }
+            }, 60000);
+        });
+    }
+    async stop() {
+        if (this.serverProcess) {
+            this.serverProcess.kill();
+            this.serverProcess = null;
+            this.messageHandlers.clear();
+            this.messageBuffer = "";
+        }
+    }
+}

package/dist/tests/unit/bundledDependencies.test.js

@@ -0,0 +1,152 @@
+/**
+ * Unit tests for Bundled Dependencies feature
+ *
+ * Tests both RuntimeCheck.resolveDependency() and initHandler.resolveDependencyForInit()
+ * which implement the bundled > system > error priority logic.
+ *
+ * Note: These tests use the real fs and which modules but control the test environment
+ * through Registry state and test file fixtures.
+ */
+import { describe, it, beforeEach } from "node:test";
+import assert from "node:assert";
+import { RuntimeCheck } from "../../src/mcp-server/utils/runtimeCheck.js";
+import { resolveDependencyForInit } from "../../src/mcp-server/toolHandlers/initHandler.js";
+import Registry from "../../src/mcp-server/registry.js";
+describe("Bundled Dependencies", () => {
+    beforeEach(() => {
+        // Reset Registry before each test
+        Registry.reset();
+    });
+    describe("RuntimeCheck.resolveDependency", () => {
+        describe("Priority 2: System PATH Fallback (using real system)", () => {
+            it("should resolve node from system PATH when no bundled deps", () => {
+                Registry.setBundledDependencies({});
+                // node should be available in system PATH
+                const resolved = RuntimeCheck.resolveDependency("node");
+                assert.ok(resolved.includes("node"));
+                assert.ok(resolved.length > 0);
+            });
+            it("should handle non-bundled dependencies", () => {
+                Registry.setBundledDependencies({ node: "/bundled/node" });
+                // git should fallback to system PATH (assuming git is installed)
+                try {
+                    const resolved = RuntimeCheck.resolveDependency("git");
+                    assert.ok(resolved.includes("git"));
+                }
+                catch (err) {
+                    // If git is not installed, that's okay - this test just verifies the logic
+                    assert.ok(err.message.includes("git"));
+                }
+            });
+        });
+        describe("Priority 3: Error When Neither Available", () => {
+            it("should throw error with hints for unknown commands", () => {
+                Registry.setBundledDependencies({});
+                assert.throws(() => RuntimeCheck.resolveDependency("definitely_not_a_real_command_12345"), /Command.*not found/);
+            });
+            it("should include install hints for known commands", () => {
+                Registry.setBundledDependencies({});
+                try {
+                    // Try to resolve uvx which likely doesn't exist
+                    RuntimeCheck.resolveDependency("uvx");
+                }
+                catch (err) {
+                    // If it throws, it should have a helpful message
+                    assert.ok(err.message.includes("uvx") ||
+                        err.message.includes("Install") ||
+                        err.message.includes("not found"));
+                }
+            });
+        });
+    });
+    describe("resolveDependencyForInit", () => {
+        describe("Priority 2: System PATH Fallback (using real system)", () => {
+            it("should return system path when bundled not available", () => {
+                const result = resolveDependencyForInit(undefined, "node");
+                // Should find node in system PATH and mark it as (system)
+                assert.ok(result.includes("(system)"));
+                assert.ok(result.includes("node"));
+            });
+            it("should handle undefined bundled path", () => {
+                const result = resolveDependencyForInit(undefined, "node");
+                // Should fallback gracefully
+                assert.ok(typeof result === "string");
+                assert.ok(result.length > 0);
+            });
+        });
+        describe("Priority 3: Not Available", () => {
+            it("should return 'not available' for non-existent commands", () => {
+                const result = resolveDependencyForInit(undefined, "definitely_not_a_real_command_12345");
+                assert.strictEqual(result, "not available");
+            });
+            it("should return 'not available' for non-existent bundled path", () => {
+                const result = resolveDependencyForInit("/this/path/definitely/does/not/exist/node", "node");
+                // Since bundled path doesn't exist, should either find system or return not available
+                assert.ok(result.includes("(system)") || result === "not available");
+            });
+        });
+    });
+    describe("RuntimeCheck Utilities", () => {
+        describe("extractCommandName", () => {
+            it("should extract first word as command name", () => {
+                assert.strictEqual(RuntimeCheck.extractCommandName("node"), "node");
+                assert.strictEqual(RuntimeCheck.extractCommandName("node --version"), "node");
+                assert.strictEqual(RuntimeCheck.extractCommandName("npx -y @some/package"), "npx");
+            });
+            it("should handle leading/trailing spaces", () => {
+                assert.strictEqual(RuntimeCheck.extractCommandName("  node  "), "node");
+                assert.strictEqual(RuntimeCheck.extractCommandName(" python3 -m module "), "python3");
+            });
+            it("should handle empty strings", () => {
+                assert.strictEqual(RuntimeCheck.extractCommandName(""), "");
+            });
+        });
+        describe("validateCommandOrThrow", () => {
+            it("should not throw for available commands like node", () => {
+                // node should be available in system PATH
+                assert.doesNotThrow(() => {
+                    RuntimeCheck.validateCommandOrThrow("node");
+                });
+            });
+            it("should throw for unavailable commands", () => {
+                assert.throws(() => {
+                    RuntimeCheck.validateCommandOrThrow("definitely_not_a_real_command_12345");
+                });
+            });
+            it("should extract command name from full command string", () => {
+                // Should extract 'node' and validate it exists
+                assert.doesNotThrow(() => {
+                    RuntimeCheck.validateCommandOrThrow("node --version");
+                });
+            });
+        });
+    });
+    describe("Registry Integration", () => {
+        it("should return copy of bundled dependencies", () => {
+            const deps = {
+                node: "/bundled/node",
+                python: "/bundled/python3",
+            };
+            Registry.setBundledDependencies(deps);
+            const retrieved = Registry.getBundledDependencies();
+            // Should be equal but not the same reference
+            assert.deepStrictEqual(retrieved, deps);
+            assert.notStrictEqual(retrieved, deps);
+        });
+        it("should handle bundled dependency path lookups", () => {
+            Registry.setBundledDependencies({
+                node: "/bundled/node",
+                python: "/bundled/python3",
+            });
+            assert.strictEqual(Registry.getBundledDependencyPath("node"), "/bundled/node");
+            assert.strictEqual(Registry.getBundledDependencyPath("python"), "/bundled/python3");
+            assert.strictEqual(Registry.getBundledDependencyPath("git"), undefined);
+        });
+        it("should reset bundled dependencies", () => {
+            Registry.setBundledDependencies({ node: "/bundled/node" });
+            Registry.reset();
+            const deps = Registry.getBundledDependencies();
+            assert.deepStrictEqual(deps, {});
+        });
+    });
+});