@tpmjs/cli 0.1.0

package/dist/commands/playground.js

@@ -0,0 +1,666 @@
+import { Command, Flags } from '@oclif/core';
+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/playground.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/playground.ts
+var Playground = class _Playground extends Command {
+  static description = "Interactive playground for testing tools";
+  static examples = [
+    "<%= config.bin %> <%= command.id %>",
+    "<%= config.bin %> <%= command.id %> --tool firecrawl-scrape",
+    "<%= config.bin %> <%= command.id %> --web"
+  ];
+  static flags = {
+    tool: Flags.string({
+      char: "t",
+      description: "Start with a specific tool selected"
+    }),
+    web: Flags.boolean({
+      char: "w",
+      description: "Open the web playground instead",
+      default: false
+    }),
+    verbose: Flags.boolean({
+      char: "v",
+      description: "Show verbose output",
+      default: false
+    })
+  };
+  rl;
+  client = getClient();
+  selectedTool;
+  async run() {
+    const { flags } = await this.parse(_Playground);
+    const output = createOutput(flags);
+    if (flags.web) {
+      output.info("Opening web playground...");
+      const open = (await import('open')).default;
+      await open("https://tpmjs.com/playground");
+      return;
+    }
+    this.selectedTool = flags.tool;
+    this.rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    output.heading("TPMJS Playground");
+    output.text("");
+    output.text("Commands:");
+    output.listItem(".help      - Show this help");
+    output.listItem(".tools     - List available tools");
+    output.listItem(".select    - Select a tool to use");
+    output.listItem(".info      - Show info about selected tool");
+    output.listItem(".clear     - Clear the screen");
+    output.listItem(".exit      - Exit the playground");
+    output.text("");
+    if (this.selectedTool) {
+      output.info(`Selected tool: ${this.selectedTool}`);
+    } else {
+      output.text("No tool selected. Use .select to choose a tool.");
+    }
+    output.text("");
+    output.text("Enter JSON input to execute the selected tool.");
+    output.divider();
+    await this.repl(output, flags.verbose);
+  }
+  async repl(output, verbose) {
+    const prompt = () => {
+      const prefix = this.selectedTool ? `[${this.selectedTool}]` : "[no tool]";
+      this.rl?.question(`${prefix} > `, async (input) => {
+        const trimmed = input.trim();
+        if (!trimmed) {
+          prompt();
+          return;
+        }
+        if (trimmed.startsWith(".")) {
+          await this.handleCommand(trimmed, output, verbose);
+          if (trimmed !== ".exit") {
+            prompt();
+          }
+          return;
+        }
+        if (!this.selectedTool) {
+          output.warning("No tool selected. Use .select to choose a tool first.");
+          prompt();
+          return;
+        }
+        try {
+          const params = JSON.parse(trimmed);
+          await this.executeTool(params, output, verbose);
+        } catch {
+          output.error("Invalid JSON input. Enter valid JSON or use a command (.help)");
+        }
+        prompt();
+      });
+    };
+    prompt();
+    await new Promise((resolve) => {
+      this.rl?.on("close", resolve);
+    });
+  }
+  async handleCommand(command, output, verbose) {
+    const [cmd, ...args] = command.split(/\s+/);
+    switch (cmd) {
+      case ".help":
+        output.text("");
+        output.text("Commands:");
+        output.listItem(".help           - Show this help");
+        output.listItem(".tools          - List available tools");
+        output.listItem(".select <tool>  - Select a tool to use");
+        output.listItem(".info           - Show info about selected tool");
+        output.listItem(".clear          - Clear the screen");
+        output.listItem(".exit           - Exit the playground");
+        output.text("");
+        output.text("To execute a tool, enter JSON input:");
+        output.text('  {"url": "https://example.com"}');
+        output.text("");
+        break;
+      case ".tools":
+        await this.listTools(output);
+        break;
+      case ".select":
+        if (args.length === 0) {
+          output.warning("Usage: .select <tool-slug>");
+        } else {
+          this.selectedTool = args[0];
+          output.success(`Selected: ${this.selectedTool}`);
+        }
+        break;
+      case ".info":
+        await this.showToolInfo(output, verbose);
+        break;
+      case ".clear":
+        console.clear();
+        break;
+      case ".exit":
+        output.info("Goodbye!");
+        this.rl?.close();
+        break;
+      default:
+        output.warning(`Unknown command: ${cmd}. Type .help for available commands.`);
+    }
+  }
+  async listTools(output) {
+    const spinner = output.spinner("Loading tools...");
+    try {
+      const response = await this.client.getTrendingTools({ limit: 20 });
+      spinner.stop();
+      if (!response.data || response.data.length === 0) {
+        output.error("No tools found");
+        return;
+      }
+      output.text("");
+      output.text("Available tools:");
+      for (const tool of response.data) {
+        output.listItem(`${tool.slug} - ${tool.name}`);
+      }
+      output.text("");
+      output.text("Use .select <slug> to select a tool");
+    } catch {
+      spinner.fail("Failed to load tools");
+    }
+  }
+  async showToolInfo(output, verbose) {
+    if (!this.selectedTool) {
+      output.warning("No tool selected");
+      return;
+    }
+    const spinner = output.spinner("Loading tool info...");
+    try {
+      const response = await this.client.getToolBySlug(this.selectedTool);
+      spinner.stop();
+      if (!response.success || !response.data) {
+        output.error("Tool not found");
+        return;
+      }
+      const tool = response.data;
+      output.text("");
+      output.heading(tool.name);
+      output.text(`Slug: ${tool.slug}`);
+      output.text(`Category: ${tool.category}`);
+      output.text(`Version: ${tool.npmVersion}`);
+      output.text("");
+      output.text("Description:");
+      output.text(`  ${tool.description || "(none)"}`);
+      if (tool.inputSchema) {
+        output.text("");
+        output.text("Input Schema:");
+        output.text(JSON.stringify(tool.inputSchema, null, 2));
+      }
+      if (verbose && tool.tools && tool.tools.length > 0) {
+        output.text("");
+        output.text("Available operations:");
+        for (const t of tool.tools) {
+          output.listItem(`${t.name}: ${t.description || ""}`);
+        }
+      }
+      output.text("");
+    } catch {
+      spinner.fail("Failed to load tool info");
+    }
+  }
+  async executeTool(params, output, verbose) {
+    if (!this.selectedTool) {
+      output.warning("No tool selected");
+      return;
+    }
+    const spinner = output.spinner("Executing...");
+    try {
+      const result = await this.client.executeTool(this.selectedTool, params);
+      spinner.stop();
+      output.success("Result:");
+      output.text(JSON.stringify(result, null, 2));
+    } catch (error) {
+      spinner.fail("Execution failed");
+      output.error(
+        error instanceof Error ? error.message : "Unknown error",
+        verbose ? String(error) : void 0
+      );
+    }
+  }
+};
+
+export { Playground as default };
+//# sourceMappingURL=playground.js.map
+//# sourceMappingURL=playground.js.map