@tpmjs/cli 0.1.0

package/dist/commands/mcp/serve.js

@@ -0,0 +1,689 @@
+import { Command, Flags } from '@oclif/core';
+import * as http from 'http';
+import * as readline from 'readline';
+import Conf from 'conf';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import Table from 'cli-table3';
+import ora from 'ora';
+import pc from 'picocolors';
+
+// src/commands/mcp/serve.ts
+var CONFIG_DIR = path.join(os.homedir(), ".tpmjs");
+var CREDENTIALS_FILE = path.join(CONFIG_DIR, "credentials.json");
+path.join(CONFIG_DIR, "history");
+function ensureConfigDir() {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 448 });
+  }
+}
+var configStore = new Conf({
+  projectName: "tpmjs",
+  cwd: CONFIG_DIR,
+  configName: "config",
+  defaults: {
+    apiUrl: "https://tpmjs.com/api",
+    defaultOutput: "human",
+    verbose: false,
+    analytics: false
+  }
+});
+function getConfigValue(key) {
+  return configStore.get(key);
+}
+function loadCredentials() {
+  ensureConfigDir();
+  if (!fs.existsSync(CREDENTIALS_FILE)) {
+    return null;
+  }
+  try {
+    const content = fs.readFileSync(CREDENTIALS_FILE, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function getApiKey() {
+  if (process.env.TPMJS_API_KEY) {
+    return process.env.TPMJS_API_KEY;
+  }
+  const creds = loadCredentials();
+  if (creds?.apiKey) {
+    return creds.apiKey;
+  }
+  return void 0;
+}
+function getApiUrl() {
+  return process.env.TPMJS_API_URL ?? getConfigValue("apiUrl") ?? "https://tpmjs.com/api";
+}
+
+// src/lib/api-client.ts
+var TpmClient = class {
+  baseUrl;
+  apiKey;
+  timeout;
+  constructor(options = {}) {
+    this.baseUrl = options.baseUrl ?? getApiUrl();
+    this.apiKey = options.apiKey ?? getApiKey();
+    this.timeout = options.timeout ?? 3e4;
+  }
+  async request(endpoint, options = {}) {
+    const url = `${this.baseUrl}${endpoint}`;
+    const headers = {
+      "Content-Type": "application/json",
+      ...options.headers
+    };
+    if (this.apiKey) {
+      headers["Authorization"] = `Bearer ${this.apiKey}`;
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url, {
+        ...options,
+        headers,
+        signal: controller.signal
+      });
+      const data = await response.json();
+      if (!response.ok) {
+        throw new ApiError(
+          data.message || data.error || `HTTP ${response.status}`,
+          response.status,
+          data
+        );
+      }
+      return data;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  // Health check
+  async health() {
+    return this.request("/health");
+  }
+  // Stats
+  async getStats() {
+    return this.request("/stats");
+  }
+  // Tools
+  async searchTools(options = {}) {
+    const params = new URLSearchParams();
+    if (options.query) params.set("q", options.query);
+    if (options.category) params.set("category", options.category);
+    if (options.limit) params.set("limit", String(options.limit));
+    if (options.offset) params.set("offset", String(options.offset));
+    const queryString = params.toString();
+    const endpoint = queryString ? `/tools?${queryString}` : "/tools";
+    return this.request(endpoint);
+  }
+  async getTool(packageName, toolName) {
+    return this.request(`/tools/${encodeURIComponent(packageName)}/${encodeURIComponent(toolName)}`);
+  }
+  async getToolBySlug(slug) {
+    const searchResult = await this.searchTools({ query: slug, limit: 1 });
+    if (searchResult.data && searchResult.data.length > 0) {
+      const tool = searchResult.data.find((t) => t.slug === slug) || searchResult.data[0];
+      return { success: true, data: tool };
+    }
+    return { success: false, error: "Tool not found" };
+  }
+  async getTrendingTools(options = {}) {
+    const params = new URLSearchParams();
+    if (options.limit) params.set("limit", String(options.limit));
+    if (options.offset) params.set("offset", String(options.offset));
+    const queryString = params.toString();
+    const endpoint = queryString ? `/tools/trending?${queryString}` : "/tools/trending";
+    return this.request(endpoint);
+  }
+  async validateTpmjsField(field) {
+    return this.request("/tools/validate", {
+      method: "POST",
+      body: JSON.stringify(field)
+    });
+  }
+  async executeTool(slug, params) {
+    return this.request(`/tools/${encodeURIComponent(slug)}/execute`, {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
+  async *executeToolStream(slug, params) {
+    const url = `${this.baseUrl}/tools/${encodeURIComponent(slug)}/execute`;
+    const headers = {
+      "Content-Type": "application/json",
+      "Accept": "text/event-stream"
+    };
+    if (this.apiKey) {
+      headers["Authorization"] = `Bearer ${this.apiKey}`;
+    }
+    const response = await fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ ...params, stream: true })
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new ApiError(errorText || `HTTP ${response.status}`, response.status);
+    }
+    if (!response.body) {
+      throw new ApiError("No response body", 0);
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          yield { type: "done", data: "" };
+          break;
+        }
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          if (line.startsWith("data: ")) {
+            const data = line.slice(6);
+            if (data === "[DONE]") {
+              yield { type: "done", data: "" };
+              return;
+            }
+            try {
+              const parsed = JSON.parse(data);
+              yield { type: parsed.type || "text", data: parsed.content || parsed.data || data };
+            } catch {
+              yield { type: "text", data };
+            }
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  // Agents
+  async listAgents(options = {}) {
+    const params = new URLSearchParams();
+    if (options.limit) params.set("limit", String(options.limit));
+    if (options.offset) params.set("offset", String(options.offset));
+    const queryString = params.toString();
+    const endpoint = queryString ? `/agents?${queryString}` : "/agents";
+    return this.request(endpoint);
+  }
+  async getAgent(id) {
+    return this.request(`/agents/${id}`);
+  }
+  async createAgent(input) {
+    return this.request("/agents", {
+      method: "POST",
+      body: JSON.stringify(input)
+    });
+  }
+  async updateAgent(id, input) {
+    return this.request(`/agents/${id}`, {
+      method: "PATCH",
+      body: JSON.stringify(input)
+    });
+  }
+  async deleteAgent(id) {
+    return this.request(`/agents/${id}`, {
+      method: "DELETE"
+    });
+  }
+  // Collections
+  async listCollections(options = {}) {
+    const params = new URLSearchParams();
+    if (options.limit) params.set("limit", String(options.limit));
+    if (options.offset) params.set("offset", String(options.offset));
+    const queryString = params.toString();
+    const endpoint = queryString ? `/collections?${queryString}` : "/collections";
+    return this.request(endpoint);
+  }
+  async getCollection(id) {
+    return this.request(`/collections/${id}`);
+  }
+  async createCollection(input) {
+    return this.request("/collections", {
+      method: "POST",
+      body: JSON.stringify(input)
+    });
+  }
+  async updateCollection(id, input) {
+    return this.request(`/collections/${id}`, {
+      method: "PATCH",
+      body: JSON.stringify(input)
+    });
+  }
+  async deleteCollection(id) {
+    return this.request(`/collections/${id}`, {
+      method: "DELETE"
+    });
+  }
+  async addToolsToCollection(id, toolIds) {
+    for (const toolId of toolIds) {
+      await this.request(`/collections/${id}/tools/${toolId}`, {
+        method: "POST"
+      });
+    }
+    return { success: true };
+  }
+  async removeToolFromCollection(id, toolId) {
+    return this.request(`/collections/${id}/tools/${toolId}`, {
+      method: "DELETE"
+    });
+  }
+  // User
+  async whoami() {
+    return this.request("/user/profile");
+  }
+  async listApiKeys() {
+    return this.request("/user/tpmjs-api-keys");
+  }
+  // Check if authenticated
+  isAuthenticated() {
+    return !!this.apiKey;
+  }
+};
+var ApiError = class extends Error {
+  constructor(message, statusCode, data) {
+    super(message);
+    this.statusCode = statusCode;
+    this.data = data;
+    this.name = "ApiError";
+  }
+};
+var clientInstance = null;
+function getClient(options) {
+  if (!clientInstance || options) {
+    clientInstance = new TpmClient(options);
+  }
+  return clientInstance;
+}
+var OutputFormatter = class {
+  options;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  // Output as JSON
+  json(data) {
+    console.log(JSON.stringify(data, null, 2));
+  }
+  // Output a table
+  table(data, columns) {
+    if (this.options.json) {
+      this.json(data);
+      return;
+    }
+    const table = new Table({
+      head: columns.map((col) => pc.bold(col.header)),
+      colWidths: columns.map((col) => col.width ?? null),
+      style: {
+        head: [],
+        border: []
+      }
+    });
+    for (const row of data) {
+      table.push(columns.map((col) => String(row[col.key] ?? "")));
+    }
+    console.log(table.toString());
+  }
+  // Success message
+  success(message) {
+    if (this.options.json) return;
+    console.log(pc.green("\u2713"), message);
+  }
+  // Error message
+  error(message, details) {
+    if (this.options.json) {
+      this.json({ error: message, details });
+      return;
+    }
+    console.error(pc.red("\u2717"), message);
+    if (details && this.options.verbose) {
+      console.error(pc.dim(details));
+    }
+  }
+  // Warning message
+  warning(message) {
+    if (this.options.json) return;
+    console.log(pc.yellow("\u26A0"), message);
+  }
+  // Info message
+  info(message) {
+    if (this.options.json) return;
+    console.log(pc.blue("\u2139"), message);
+  }
+  // Debug message (only in verbose mode)
+  debug(message) {
+    if (this.options.json) return;
+    if (this.options.verbose) {
+      console.log(pc.dim(`[debug] ${message}`));
+    }
+  }
+  // Plain text output
+  text(message) {
+    if (this.options.json) return;
+    console.log(message);
+  }
+  // Heading
+  heading(text) {
+    if (this.options.json) return;
+    console.log();
+    console.log(pc.bold(pc.underline(text)));
+    console.log();
+  }
+  // Subheading
+  subheading(text) {
+    if (this.options.json) return;
+    console.log(pc.bold(text));
+  }
+  // Key-value pair
+  keyValue(key, value) {
+    if (this.options.json) return;
+    console.log(`${pc.dim(key + ":")} ${value ?? pc.dim("(not set)")}`);
+  }
+  // List item
+  listItem(text, indent = 0) {
+    if (this.options.json) return;
+    const prefix = "  ".repeat(indent) + "\u2022";
+    console.log(`${prefix} ${text}`);
+  }
+  // Spinner
+  spinner(message) {
+    return ora({
+      text: message,
+      isSilent: this.options.json
+    }).start();
+  }
+  // Blank line
+  newLine() {
+    if (this.options.json) return;
+    console.log();
+  }
+  // Horizontal rule
+  hr() {
+    if (this.options.json) return;
+    console.log(pc.dim("\u2500".repeat(50)));
+  }
+  // Alias for hr
+  divider() {
+    this.hr();
+  }
+  // Code block
+  code(text, language) {
+    if (this.options.json) {
+      this.json({ code: text, language });
+      return;
+    }
+    console.log(pc.dim("```" + (language ?? "")));
+    console.log(text);
+    console.log(pc.dim("```"));
+  }
+  // Highlight text
+  highlight(text) {
+    return pc.cyan(text);
+  }
+  // Dim text
+  dim(text) {
+    return pc.dim(text);
+  }
+  // Bold text
+  bold(text) {
+    return pc.bold(text);
+  }
+  // Link (just returns text in terminal)
+  link(text, url) {
+    return `\x1B]8;;${url}\x07${pc.underline(pc.blue(text))}\x1B]8;;\x07`;
+  }
+};
+function createOutput(flags) {
+  return new OutputFormatter({
+    json: flags.json,
+    verbose: flags.verbose
+  });
+}
+
+// src/commands/mcp/serve.ts
+var MCPServe = class _MCPServe extends Command {
+  static description = "Run as a local MCP server";
+  static examples = [
+    "<%= config.bin %> <%= command.id %>",
+    "<%= config.bin %> <%= command.id %> --port 8080",
+    "<%= config.bin %> <%= command.id %> --stdio",
+    "<%= config.bin %> <%= command.id %> --collection my-collection"
+  ];
+  static flags = {
+    port: Flags.integer({
+      char: "p",
+      description: "Port to run the server on (HTTP mode)",
+      default: 3333
+    }),
+    stdio: Flags.boolean({
+      description: "Use stdio transport instead of HTTP",
+      default: false
+    }),
+    collection: Flags.string({
+      char: "c",
+      description: "Serve tools from a specific collection"
+    }),
+    tool: Flags.string({
+      char: "t",
+      description: "Serve specific tools (comma-separated)",
+      multiple: true
+    }),
+    verbose: Flags.boolean({
+      char: "v",
+      description: "Show verbose output",
+      default: false
+    })
+  };
+  client = getClient();
+  tools = /* @__PURE__ */ new Map();
+  async run() {
+    const { flags } = await this.parse(_MCPServe);
+    const output = createOutput(flags);
+    await this.loadTools(flags, output);
+    if (flags.stdio) {
+      await this.runStdioServer(output, flags.verbose);
+    } else {
+      await this.runHttpServer(flags.port, output, flags.verbose);
+    }
+  }
+  async loadTools(flags, output) {
+    const spinner = output.spinner("Loading tools...");
+    try {
+      if (flags.collection) {
+        const response = await this.client.getTrendingTools({ limit: 20 });
+        if (response.data && response.data.length > 0) {
+          for (const tool of response.data) {
+            this.tools.set(tool.slug, tool);
+          }
+        }
+      } else if (flags.tool && flags.tool.length > 0) {
+        for (const toolId of flags.tool) {
+          const response = await this.client.getToolBySlug(toolId);
+          if (response.success && response.data) {
+            this.tools.set(response.data.slug, response.data);
+          }
+        }
+      } else {
+        const response = await this.client.getTrendingTools({ limit: 10 });
+        if (response.data && response.data.length > 0) {
+          for (const tool of response.data) {
+            this.tools.set(tool.slug, tool);
+          }
+        }
+      }
+      spinner.stop();
+      output.info(`Loaded ${this.tools.size} tool(s)`);
+    } catch (error) {
+      spinner.fail("Failed to load tools");
+      throw error;
+    }
+  }
+  async runStdioServer(output, verbose) {
+    output.info("Starting MCP server in stdio mode...");
+    output.info("Listening for JSON-RPC messages on stdin");
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      terminal: false
+    });
+    rl.on("line", async (line) => {
+      try {
+        const request = JSON.parse(line);
+        if (verbose) {
+          output.info(`Received: ${request.method}`);
+        }
+        const response = await this.handleRequest(request);
+        console.log(JSON.stringify(response));
+      } catch (error) {
+        const errorResponse = {
+          jsonrpc: "2.0",
+          id: 0,
+          error: {
+            code: -32700,
+            message: "Parse error",
+            data: error instanceof Error ? error.message : "Unknown error"
+          }
+        };
+        console.log(JSON.stringify(errorResponse));
+      }
+    });
+    await new Promise(() => {
+    });
+  }
+  async runHttpServer(port, output, verbose) {
+    const server = http.createServer(async (req, res) => {
+      if (req.method === "POST" && req.url === "/mcp") {
+        let body = "";
+        req.on("data", (chunk) => {
+          body += chunk.toString();
+        });
+        req.on("end", async () => {
+          try {
+            const request = JSON.parse(body);
+            if (verbose) {
+              output.info(`Received: ${request.method}`);
+            }
+            const response = await this.handleRequest(request);
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify(response));
+          } catch (error) {
+            const errorResponse = {
+              jsonrpc: "2.0",
+              id: 0,
+              error: {
+                code: -32700,
+                message: "Parse error",
+                data: error instanceof Error ? error.message : "Unknown error"
+              }
+            };
+            res.writeHead(400, { "Content-Type": "application/json" });
+            res.end(JSON.stringify(errorResponse));
+          }
+        });
+      } else if (req.method === "GET" && req.url === "/health") {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ status: "ok", tools: this.tools.size }));
+      } else {
+        res.writeHead(404);
+        res.end("Not found");
+      }
+    });
+    server.listen(port, () => {
+      output.success(`MCP server running at http://localhost:${port}/mcp`);
+      output.info("Health check: GET /health");
+      output.info("Press Ctrl+C to stop");
+    });
+    await new Promise(() => {
+    });
+  }
+  async handleRequest(request) {
+    const { id, method, params } = request;
+    switch (method) {
+      case "initialize":
+        return {
+          jsonrpc: "2.0",
+          id,
+          result: {
+            protocolVersion: "2024-11-05",
+            capabilities: {
+              tools: {}
+            },
+            serverInfo: {
+              name: "tpmjs-mcp-server",
+              version: "0.1.0"
+            }
+          }
+        };
+      case "tools/list":
+        return {
+          jsonrpc: "2.0",
+          id,
+          result: {
+            tools: Array.from(this.tools.entries()).map(([slug, tool]) => ({
+              name: slug,
+              description: tool.description || "",
+              inputSchema: tool.inputSchema || {
+                type: "object",
+                properties: {}
+              }
+            }))
+          }
+        };
+      case "tools/call": {
+        const toolName = params?.name;
+        const toolArgs = params?.arguments;
+        if (!toolName) {
+          return {
+            jsonrpc: "2.0",
+            id,
+            error: {
+              code: -32602,
+              message: "Invalid params: tool name required"
+            }
+          };
+        }
+        try {
+          const response = await this.client.executeTool(toolName, toolArgs || {});
+          return {
+            jsonrpc: "2.0",
+            id,
+            result: {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(response, null, 2)
+                }
+              ]
+            }
+          };
+        } catch (error) {
+          return {
+            jsonrpc: "2.0",
+            id,
+            error: {
+              code: -32e3,
+              message: error instanceof Error ? error.message : "Tool execution failed"
+            }
+          };
+        }
+      }
+      default:
+        return {
+          jsonrpc: "2.0",
+          id,
+          error: {
+            code: -32601,
+            message: `Method not found: ${method}`
+          }
+        };
+    }
+  }
+};
+
+export { MCPServe as default };
+//# sourceMappingURL=serve.js.map
+//# sourceMappingURL=serve.js.map