@tpmjs/cli 0.1.0

package/dist/commands/auth/login.js

@@ -0,0 +1,603 @@
+import { Command, Flags, Args } from '@oclif/core';
+import open from 'open';
+import { createServer } from 'http';
+import { URL } from 'url';
+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/auth/login.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 saveCredentials(credentials) {
+  ensureConfigDir();
+  const content = JSON.stringify(credentials, null, 2);
+  fs.writeFileSync(CREDENTIALS_FILE, content, { mode: 384 });
+}
+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 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/auth/login.ts
+var Login = class _Login extends Command {
+  static description = "Authenticate with TPMJS";
+  static examples = [
+    "<%= config.bin %> <%= command.id %> --api-key tpm_xxxxx",
+    "<%= config.bin %> <%= command.id %> --browser"
+  ];
+  static flags = {
+    "api-key": Flags.string({
+      char: "k",
+      description: "API key (or set TPMJS_API_KEY environment variable)"
+    }),
+    browser: Flags.boolean({
+      char: "b",
+      description: "Open browser for OAuth authentication",
+      default: false
+    }),
+    json: Flags.boolean({
+      description: "Output in JSON format",
+      default: false
+    }),
+    verbose: Flags.boolean({
+      char: "v",
+      description: "Show verbose output",
+      default: false
+    })
+  };
+  static args = {
+    key: Args.string({
+      description: "API key (alternative to --api-key flag)",
+      required: false
+    })
+  };
+  async run() {
+    const { args, flags } = await this.parse(_Login);
+    const output = createOutput(flags);
+    const apiKey = flags["api-key"] ?? args.key;
+    if (apiKey) {
+      await this.loginWithApiKey(apiKey, output, flags);
+    } else if (flags.browser) {
+      await this.loginWithBrowser(output, flags);
+    } else {
+      output.info("No API key provided. Use --api-key or --browser flag.");
+      output.newLine();
+      output.text("Options:");
+      output.listItem("tpm auth login --api-key <your-api-key>");
+      output.listItem("tpm auth login --browser (opens browser for OAuth)");
+      output.newLine();
+      output.text(`Get your API key at: ${output.link("tpmjs.com/dashboard/settings/tpmjs-api-keys", "https://tpmjs.com/dashboard/settings/tpmjs-api-keys")}`);
+    }
+  }
+  async loginWithApiKey(apiKey, output, flags) {
+    const spinner = output.spinner("Validating API key...");
+    try {
+      const client = new TpmClient({ apiKey });
+      const response = await client.whoami();
+      if (!response.success || !response.data) {
+        spinner.fail("Invalid API key");
+        return;
+      }
+      saveCredentials({ apiKey });
+      spinner.succeed("Logged in successfully");
+      if (flags.json) {
+        output.json({
+          success: true,
+          user: response.data
+        });
+      } else {
+        output.newLine();
+        output.keyValue("Email", response.data.email);
+        if (response.data.username) {
+          output.keyValue("Username", response.data.username);
+        }
+        if (response.data.name) {
+          output.keyValue("Name", response.data.name);
+        }
+      }
+    } catch (error) {
+      spinner.fail("Authentication failed");
+      output.error(
+        error instanceof Error ? error.message : "Unknown error",
+        flags.verbose ? String(error) : void 0
+      );
+    }
+  }
+  async loginWithBrowser(output, flags) {
+    const port = 9876;
+    const callbackUrl = `http://localhost:${port}/callback`;
+    const state = crypto.randomUUID();
+    output.info("Opening browser for authentication...");
+    return new Promise((resolve) => {
+      const server = createServer(async (req, res) => {
+        const url = new URL(req.url ?? "/", `http://localhost:${port}`);
+        if (url.pathname === "/callback") {
+          const receivedState = url.searchParams.get("state");
+          const apiKey = url.searchParams.get("key");
+          const error = url.searchParams.get("error");
+          if (error) {
+            res.writeHead(200, { "Content-Type": "text/html" });
+            res.end("<html><body><h1>Authentication Failed</h1><p>You can close this window.</p></body></html>");
+            server.close();
+            output.error(`Authentication failed: ${error}`);
+            resolve();
+            return;
+          }
+          if (receivedState !== state) {
+            res.writeHead(200, { "Content-Type": "text/html" });
+            res.end("<html><body><h1>Invalid State</h1><p>Authentication failed due to invalid state.</p></body></html>");
+            server.close();
+            output.error("Authentication failed: Invalid state parameter");
+            resolve();
+            return;
+          }
+          if (apiKey) {
+            saveCredentials({ apiKey });
+            res.writeHead(200, { "Content-Type": "text/html" });
+            res.end("<html><body><h1>Success!</h1><p>You are now logged in. You can close this window.</p></body></html>");
+            server.close();
+            output.success("Logged in successfully via browser");
+            if (flags.json) {
+              output.json({ success: true });
+            }
+            resolve();
+          } else {
+            res.writeHead(200, { "Content-Type": "text/html" });
+            res.end("<html><body><h1>Error</h1><p>No API key received.</p></body></html>");
+            server.close();
+            output.error("No API key received from authentication");
+            resolve();
+          }
+        } else {
+          res.writeHead(404);
+          res.end("Not found");
+        }
+      });
+      server.listen(port, async () => {
+        const authUrl = `${getApiUrl().replace("/api", "")}/cli/auth?state=${state}&callback=${encodeURIComponent(callbackUrl)}`;
+        output.debug(`Auth URL: ${authUrl}`);
+        output.text("Waiting for authentication...");
+        try {
+          await open(authUrl);
+        } catch {
+          output.warning("Could not open browser automatically.");
+          output.text(`Please open this URL manually: ${authUrl}`);
+        }
+      });
+      setTimeout(() => {
+        server.close();
+        output.error("Authentication timed out");
+        resolve();
+      }, 5 * 60 * 1e3);
+    });
+  }
+};
+
+export { Login as default };
+//# sourceMappingURL=login.js.map
+//# sourceMappingURL=login.js.map