@tpmjs/cli 0.1.0

package/dist/commands/doctor.js

@@ -0,0 +1,592 @@
+import { Command, Flags } from '@oclif/core';
+import * as fs from 'fs';
+import * as os from 'os';
+import Conf from 'conf';
+import * as path from 'path';
+import Table from 'cli-table3';
+import ora from 'ora';
+import pc from 'picocolors';
+
+// src/commands/doctor.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 getConfig() {
+  return configStore.store;
+}
+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 hasCredentials() {
+  const creds = loadCredentials();
+  return creds !== null && !!creds.apiKey;
+}
+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";
+}
+function getConfigDir() {
+  ensureConfigDir();
+  return CONFIG_DIR;
+}
+
+// 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 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/doctor.ts
+var Doctor = class _Doctor extends Command {
+  static description = "Run diagnostic checks for TPMJS CLI";
+  static examples = ["<%= config.bin %> <%= command.id %>"];
+  static flags = {
+    json: Flags.boolean({
+      description: "Output in JSON format",
+      default: false
+    }),
+    verbose: Flags.boolean({
+      char: "v",
+      description: "Show verbose output",
+      default: false
+    })
+  };
+  async run() {
+    const { flags } = await this.parse(_Doctor);
+    const output = createOutput(flags);
+    const checks = [];
+    output.heading("TPMJS CLI Diagnostics");
+    const nodeVersion = process.version;
+    const nodeVersionNum = parseInt(nodeVersion.slice(1).split(".")[0] ?? "0", 10);
+    checks.push({
+      name: "Node.js Version",
+      status: nodeVersionNum >= 18 ? "ok" : "error",
+      message: nodeVersion,
+      details: nodeVersionNum < 18 ? "Node.js 18+ is required" : void 0
+    });
+    const configDir = getConfigDir();
+    const configExists = fs.existsSync(configDir);
+    checks.push({
+      name: "Config Directory",
+      status: configExists ? "ok" : "warning",
+      message: configDir,
+      details: configExists ? void 0 : "Config directory will be created on first use"
+    });
+    const hasAuth = hasCredentials() || !!process.env.TPMJS_API_KEY;
+    const authSource = process.env.TPMJS_API_KEY ? "environment" : hasCredentials() ? "config file" : "none";
+    checks.push({
+      name: "Authentication",
+      status: hasAuth ? "ok" : "warning",
+      message: hasAuth ? `Configured via ${authSource}` : "Not configured",
+      details: hasAuth ? void 0 : "Run `tpm auth login` to authenticate"
+    });
+    const apiUrl = getApiUrl();
+    try {
+      const client = new TpmClient();
+      const healthResponse = await client.health();
+      checks.push({
+        name: "API Connectivity",
+        status: "ok",
+        message: `Connected to ${apiUrl}`,
+        details: `Server status: ${healthResponse.status}`
+      });
+    } catch (error) {
+      checks.push({
+        name: "API Connectivity",
+        status: "error",
+        message: `Cannot connect to ${apiUrl}`,
+        details: error instanceof Error ? error.message : "Unknown error"
+      });
+    }
+    if (hasAuth) {
+      const apiKey = getApiKey();
+      if (apiKey) {
+        try {
+          const client = new TpmClient({ apiKey });
+          const whoamiResponse = await client.whoami();
+          if (whoamiResponse.success && whoamiResponse.data) {
+            checks.push({
+              name: "API Authentication",
+              status: "ok",
+              message: `Authenticated as ${whoamiResponse.data.email}`
+            });
+          } else {
+            checks.push({
+              name: "API Authentication",
+              status: "error",
+              message: "API key is invalid",
+              details: "Run `tpm auth login` to re-authenticate"
+            });
+          }
+        } catch (error) {
+          checks.push({
+            name: "API Authentication",
+            status: "error",
+            message: "Failed to verify API key",
+            details: error instanceof Error ? error.message : "Unknown error"
+          });
+        }
+      }
+    }
+    const config = getConfig();
+    checks.push({
+      name: "Configuration",
+      status: "ok",
+      message: "Loaded",
+      details: flags.verbose ? JSON.stringify(config, null, 2) : void 0
+    });
+    try {
+      const homeDir = os.homedir();
+      const stats = fs.statfsSync(homeDir);
+      const freeSpaceBytes = stats.bavail * stats.bsize;
+      const freeSpaceMB = Math.floor(freeSpaceBytes / (1024 * 1024));
+      checks.push({
+        name: "Disk Space",
+        status: freeSpaceMB > 100 ? "ok" : "warning",
+        message: `${freeSpaceMB} MB available`,
+        details: freeSpaceMB <= 100 ? "Low disk space may cause issues" : void 0
+      });
+    } catch {
+    }
+    if (flags.json) {
+      const summary = {
+        ok: checks.filter((c) => c.status === "ok").length,
+        warnings: checks.filter((c) => c.status === "warning").length,
+        errors: checks.filter((c) => c.status === "error").length
+      };
+      output.json({ checks, summary });
+      return;
+    }
+    for (const check of checks) {
+      const icon = check.status === "ok" ? "\u2713" : check.status === "warning" ? "\u26A0" : "\u2717";
+      output.text(`${icon} ${output.bold(check.name)}: ${check.message}`);
+      if (check.details && (flags.verbose || check.status !== "ok")) {
+        output.text(`  ${output.dim(check.details)}`);
+      }
+    }
+    output.newLine();
+    const errorCount = checks.filter((c) => c.status === "error").length;
+    const warningCount = checks.filter((c) => c.status === "warning").length;
+    if (errorCount > 0) {
+      output.error(`${errorCount} error(s) found`);
+    } else if (warningCount > 0) {
+      output.warning(`${warningCount} warning(s) found`);
+    } else {
+      output.success("All checks passed");
+    }
+  }
+};
+
+export { Doctor as default };
+//# sourceMappingURL=doctor.js.map
+//# sourceMappingURL=doctor.js.map