commet 0.2.1 → 0.4.0

package/dist/index.js

@@ -1,12 +1,11 @@
+#!/usr/bin/env node
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -15,474 +14,695 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 
 // src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  Commet: () => Commet,
-  CommetAPIError: () => CommetAPIError,
-  CommetError: () => CommetError,
-  CommetValidationError: () => CommetValidationError,
-  default: () => index_default,
-  detectEnvironment: () => detectEnvironment,
-  isDevelopment: () => isDevelopment,
-  isProduction: () => isProduction
-});
-module.exports = __toCommonJS(index_exports);
+var import_commander10 = require("commander");
+var import_chalk10 = __toESM(require("chalk"));
 
-// src/resources/customers.ts
-var CustomersResource = class {
-  constructor(httpClient) {
-    this.httpClient = httpClient;
-  }
-  async create(params, options) {
-    return this.httpClient.post("/customers", params, options);
-  }
-  async retrieve(customerId, options) {
-    const params = options?.expand ? { expand: options.expand.join(",") } : void 0;
-    return this.httpClient.get(`/customers/${customerId}`, params);
-  }
-  async update(customerId, params, options) {
-    return this.httpClient.put(`/customers/${customerId}`, params, options);
-  }
-  async list(params) {
-    return this.httpClient.get("/customers", params);
-  }
-  /**
-   * Deactivate a customer (soft delete)
-   */
-  async deactivate(customerId, options) {
-    return this.httpClient.put(
-      `/customers/${customerId}`,
-      { isActive: false },
-      options
-    );
-  }
-};
+// src/commands/login.ts
+var import_commander = require("commander");
+var import_chalk = __toESM(require("chalk"));
+var import_ora = __toESM(require("ora"));
+var import_open = __toESM(require("open"));
 
-// src/resources/seats.ts
-var SeatsResource = class {
-  constructor(httpClient) {
-    this.httpClient = httpClient;
-  }
-  async add(customerId, seatType, count, options) {
-    return this.httpClient.post(
-      `/customers/${customerId}/seats/${seatType}/add`,
-      { count },
-      options
-    );
-  }
-  async remove(customerId, seatType, count, options) {
-    return this.httpClient.post(
-      `/customers/${customerId}/seats/${seatType}/remove`,
-      { count },
-      options
-    );
-  }
-  async set(customerId, seatType, count, options) {
-    return this.httpClient.post(
-      `/customers/${customerId}/seats/${seatType}/set`,
-      { count },
-      options
-    );
-  }
-  async bulkUpdate(customerId, seats, options) {
-    return this.httpClient.post(
-      `/customers/${customerId}/seats/bulk-update`,
-      { seats },
-      options
-    );
-  }
-  async getBalance(customerId, seatType) {
-    return this.httpClient.get(
-      `/customers/${customerId}/seats/${seatType}/balance`
-    );
+// src/utils/config.ts
+var fs = __toESM(require("fs"));
+var os = __toESM(require("os"));
+var path = __toESM(require("path"));
+function getAuthPath() {
+  return path.join(os.homedir(), ".commet", "auth.json");
+}
+function getProjectConfigPath() {
+  return path.join(process.cwd(), ".commet");
+}
+function authExists() {
+  return fs.existsSync(getAuthPath());
+}
+function loadAuth() {
+  try {
+    const authPath = getAuthPath();
+    if (!fs.existsSync(authPath)) {
+      return null;
+    }
+    const data = fs.readFileSync(authPath, "utf8");
+    return JSON.parse(data);
+  } catch {
+    return null;
   }
-  async getAllBalances(customerId) {
-    return this.httpClient.get(`/customers/${customerId}/seats/balances`);
+}
+function saveAuth(data) {
+  const authPath = getAuthPath();
+  fs.mkdirSync(path.dirname(authPath), { recursive: true });
+  fs.writeFileSync(authPath, JSON.stringify(data, null, 2), "utf8");
+}
+function clearAuth() {
+  const authPath = getAuthPath();
+  if (fs.existsSync(authPath)) {
+    fs.unlinkSync(authPath);
   }
-  async getHistory(customerId, seatType, params) {
-    const queryParams = {
-      ...params,
-      customerId,
-      seatType
-    };
-    return this.httpClient.get(
-      `/customers/${customerId}/seats/history`,
-      queryParams
-    );
+}
+function projectConfigExists() {
+  return fs.existsSync(getProjectConfigPath());
+}
+function loadProjectConfig() {
+  try {
+    const configPath = getProjectConfigPath();
+    if (!fs.existsSync(configPath)) {
+      return null;
+    }
+    const data = fs.readFileSync(configPath, "utf8");
+    return JSON.parse(data);
+  } catch {
+    return null;
   }
-  async listEvents(params) {
-    return this.httpClient.get("/seats/events", params);
+}
+function saveProjectConfig(data) {
+  const configPath = getProjectConfigPath();
+  fs.writeFileSync(configPath, JSON.stringify(data, null, 2), "utf8");
+}
+function clearProjectConfig() {
+  const configPath = getProjectConfigPath();
+  if (fs.existsSync(configPath)) {
+    fs.unlinkSync(configPath);
   }
-};
+}
 
-// src/resources/usage.ts
-var UsageEventsResource = class {
-  constructor(httpClient) {
-    this.httpClient = httpClient;
-  }
-  async create(params, options) {
-    const eventData = {
-      ...params,
-      ts: params.timestamp || (/* @__PURE__ */ new Date()).toISOString()
-    };
-    return this.httpClient.post("/usage/events", eventData, options);
-  }
-  async createBatch(params, options) {
-    return this.httpClient.post("/usage/events/batch", params, options);
-  }
-  async retrieve(eventId) {
-    return this.httpClient.get(`/usage/events/${eventId}`);
-  }
-  async list(params) {
-    return this.httpClient.get("/usage/events", params);
-  }
-  async delete(eventId, options) {
-    return this.httpClient.delete(`/usage/events/${eventId}`, options);
-  }
-};
-var UsageMetricsResource = class {
-  constructor(httpClient) {
-    this.httpClient = httpClient;
+// src/utils/api.ts
+function getBaseURL(environment) {
+  if (environment === "production") {
+    return "https://billing.commet.co";
   }
-  async list() {
-    return this.httpClient.get("/usage/metrics");
-  }
-  async retrieve(metricId) {
-    return this.httpClient.get(`/usage/metrics/${metricId}`);
-  }
-};
-var UsageResource = class {
-  constructor(httpClient) {
-    this.events = new UsageEventsResource(httpClient);
-    this.metrics = new UsageMetricsResource(httpClient);
+  return "https://billing.commet.co";
+}
+async function apiRequest(endpoint, options = {}) {
+  const auth = loadAuth();
+  if (!auth) {
+    return { error: "Not authenticated. Run `commet login` first." };
   }
-};
-
-// src/utils/environment.ts
-function detectEnvironment() {
   try {
-    if (typeof process !== "undefined" && process.env?.NODE_ENV) {
-      if (process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test") {
-        return "development";
-      }
-    }
-    if (typeof window !== "undefined" && window.location) {
-      const hostname = window.location.hostname;
-      if (hostname === "localhost" || hostname === "127.0.0.1" || hostname.startsWith("192.168.") || hostname.startsWith("10.") || hostname.endsWith(".local")) {
-        return "development";
+    const response = await fetch(endpoint, {
+      ...options,
+      headers: {
+        ...options.headers,
+        Authorization: `Bearer ${auth.token}`,
+        "Content-Type": "application/json"
       }
+    });
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({}));
+      return {
+        error: errorData.message || errorData.error || `Request failed with status ${response.status}`
+      };
     }
+    const data = await response.json();
+    return { data };
   } catch (error) {
+    return {
+      error: error instanceof Error ? error.message : "Unknown error occurred"
+    };
   }
-  return "production";
-}
-function isDevelopment(environment) {
-  return environment === "development";
-}
-function isProduction(environment) {
-  return environment === "production";
 }
 
-// src/types/common.ts
-var CommetError = class extends Error {
-  constructor(message, code, statusCode, details) {
-    super(message);
-    this.code = code;
-    this.statusCode = statusCode;
-    this.details = details;
-    this.name = "CommetError";
-  }
-};
-var CommetAPIError = class extends CommetError {
-  constructor(message, statusCode, code, details) {
-    super(message, code, statusCode, details);
-    this.statusCode = statusCode;
-    this.code = code;
-    this.details = details;
-    this.name = "CommetAPIError";
-  }
-};
-var CommetValidationError = class extends CommetError {
-  constructor(message, validationErrors) {
-    super(message);
-    this.validationErrors = validationErrors;
-    this.name = "CommetValidationError";
-  }
-};
-
-// src/utils/http.ts
-var DEFAULT_RETRY_CONFIG = {
-  maxRetries: 3,
-  baseDelay: 1e3,
-  // 1s
-  maxDelay: 8e3,
-  // 8s
-  retryableStatusCodes: [408, 429, 500, 502, 503, 504]
-};
-var CommetHTTPClient = class {
-  constructor(config, environment) {
-    this.config = config;
-    this.environment = environment;
-    this.retryConfig = {
-      ...DEFAULT_RETRY_CONFIG,
-      maxRetries: config.retries ?? DEFAULT_RETRY_CONFIG.maxRetries
-    };
-  }
-  async get(endpoint, params, options) {
-    return this.request("GET", endpoint, void 0, options, params);
-  }
-  async post(endpoint, data, options) {
-    return this.request("POST", endpoint, data, options);
-  }
-  async put(endpoint, data, options) {
-    return this.request("PUT", endpoint, data, options);
-  }
-  async delete(endpoint, options) {
-    return this.request("DELETE", endpoint, void 0, options);
+// src/commands/login.ts
+var loginCommand = new import_commander.Command("login").description("Authenticate with Commet").action(async () => {
+  if (authExists()) {
+    const auth = loadAuth();
+    console.log(import_chalk.default.yellow("\u26A0 You are already logged in."));
+    console.log(
+      import_chalk.default.dim("Run `commet logout` first if you want to login with a different account.")
+    );
+    return;
   }
-  /**
-   * Core request method with retry logic and dev mode support
-   */
-  async request(method, endpoint, data, options, params) {
-    const url = this.buildURL(endpoint, params);
-    if (isDevelopment(this.environment)) {
-      return this.logDevRequest(method, url, data);
-    }
-    return this.executeRequest(method, url, data, options);
-  }
-  /**
-   * Log request in development mode instead of sending to API
-   */
-  logDevRequest(method, url, data) {
-    console.log("[Commet SDK] Dev mode");
-    console.log(`Method: ${method}`);
-    console.log(`Endpoint: ${url}`);
-    if (data) {
-      console.log("Data:", JSON.stringify(data, null, 2));
-    }
-    console.log("Request logged, not sent to server");
-    if (this.config.debug) {
-      console.log("Base URL:", "https://api.commet.co/api");
-      console.log("Debug mode enabled");
-    }
-    return Promise.resolve({
-      success: true,
-      devMode: true,
-      data: { id: `dev_${Date.now()}` }
+  const spinner = (0, import_ora.default)("Initiating login flow...").start();
+  const baseURL = getBaseURL("sandbox");
+  try {
+    const deviceResponse = await fetch(`${baseURL}/api/auth/device/code`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        client_id: "commet-cli",
+        scope: "openid profile email"
+      })
     });
-  }
-  /**
-   * Execute real API request with retry logic
-   */
-  async executeRequest(method, url, data, options, attempt = 1) {
+    if (!deviceResponse.ok) {
+      spinner.fail("Failed to initiate login");
+      console.error(import_chalk.default.red("Error:"), await deviceResponse.text());
+      return;
+    }
+    const deviceData = await deviceResponse.json();
+    const {
+      device_code,
+      user_code,
+      verification_uri_complete,
+      interval = 5
+    } = deviceData;
+    spinner.stop();
+    console.log(import_chalk.default.bold("\n\u{1F510} Commet CLI Login\n"));
+    console.log("Visit the following URL in your browser:");
+    console.log(import_chalk.default.cyan.underline(verification_uri_complete));
+    console.log("\nOr enter this code manually:");
+    console.log(import_chalk.default.bold.green(`  ${user_code}`));
+    console.log(import_chalk.default.dim("\nOpening browser...\n"));
     try {
-      const headers = {
-        "x-api-key": this.config.apiKey,
-        "Content-Type": "application/json",
-        "User-Agent": "commet/0.1.0"
-      };
-      if (options?.idempotencyKey) {
-        headers["Idempotency-Key"] = options.idempotencyKey;
-      } else if (method === "POST" && data) {
-        headers["Idempotency-Key"] = this.generateIdempotencyKey();
-      }
-      const requestConfig = {
-        method,
-        headers,
-        signal: AbortSignal.timeout(
-          options?.timeout ?? this.config.timeout ?? 3e4
-        )
-      };
-      if (data) {
-        requestConfig.body = JSON.stringify(data);
-      }
-      if (this.config.debug) {
-        console.log(`[Commet SDK] ${method} ${url}`);
-        if (data) {
-          console.log("Request data:", JSON.stringify(data, null, 2));
-        }
-      }
-      const response = await fetch(url, requestConfig);
-      if (this.config.debug) {
-        console.log(
-          `[Commet SDK] Response status: ${response.status} ${response.statusText}`
-        );
+      await (0, import_open.default)(verification_uri_complete);
+    } catch {
+      console.log(import_chalk.default.yellow("\u26A0 Could not open browser automatically."));
+    }
+    const pollSpinner = (0, import_ora.default)("Waiting for authorization...").start();
+    let pollingInterval = interval;
+    let attempts = 0;
+    const maxAttempts = 180 / pollingInterval;
+    const poll = async () => {
+      if (attempts >= maxAttempts) {
+        pollSpinner.fail("Login timed out");
+        console.log(import_chalk.default.red("Authorization timed out. Please try again."));
+        return;
       }
-      let responseData;
-      let responseText;
+      attempts++;
       try {
-        const responseClone = response.clone();
-        responseData = await response.json();
-        responseText = "";
-      } catch (jsonError) {
-        try {
-          responseText = await response.text();
-        } catch (textError) {
-          responseText = "Failed to read response body";
-        }
-        if (this.config.debug) {
-          console.log(
-            "[Commet SDK] Failed to parse JSON response:",
-            responseText
-          );
-        }
-        throw new CommetAPIError(
-          `Invalid JSON response: ${response.status} ${response.statusText}`,
-          response.status,
-          "INVALID_JSON",
-          { responseText }
-        );
-      }
-      if (!response.ok) {
-        if (attempt <= this.retryConfig.maxRetries && this.retryConfig.retryableStatusCodes.includes(response.status)) {
-          const delay = Math.min(
-            this.retryConfig.baseDelay * 2 ** (attempt - 1),
-            this.retryConfig.maxDelay
-          );
-          if (this.config.debug) {
-            console.log(
-              `[Commet SDK] Retrying in ${delay}ms (attempt ${attempt}/${this.retryConfig.maxRetries})`
-            );
+        const tokenResponse = await fetch(`${baseURL}/api/auth/device/token`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+            device_code,
+            client_id: "commet-cli"
+          })
+        });
+        const tokenData = await tokenResponse.json();
+        if (tokenData.access_token) {
+          const authConfig = {
+            token: tokenData.access_token
+          };
+          if (tokenData.refresh_token) {
+            authConfig.refreshToken = tokenData.refresh_token;
           }
-          await this.sleep(delay);
-          return this.executeRequest(method, url, data, options, attempt + 1);
-        }
-        if (this.config.debug) {
+          if (tokenData.expires_in) {
+            authConfig.expiresAt = Date.now() + tokenData.expires_in * 1e3;
+          }
+          saveAuth(authConfig);
+          pollSpinner.succeed("Successfully logged in!");
+          console.log(import_chalk.default.green("\n\u2713 Authentication complete"));
           console.log(
-            "[Commet SDK] Error response:",
-            JSON.stringify(responseData, null, 2)
+            import_chalk.default.dim("\nNext steps:\n  1. Run `commet link` to connect a project\n  2. Run `commet pull` to generate types\n")
           );
+          return;
         }
-        const isErrorResponse = (data2) => {
-          return typeof data2 === "object" && data2 !== null;
-        };
-        const errorData = isErrorResponse(responseData) ? responseData : {};
-        if (response.status === 400 && errorData.errors) {
-          throw new CommetValidationError(
-            errorData.message || "Validation failed",
-            errorData.errors
+        if (tokenData.error === "authorization_pending") {
+          setTimeout(() => poll(), pollingInterval * 1e3);
+        } else if (tokenData.error === "slow_down") {
+          pollingInterval += 5;
+          setTimeout(() => poll(), pollingInterval * 1e3);
+        } else if (tokenData.error === "access_denied") {
+          pollSpinner.fail("Authorization denied");
+          console.log(
+            import_chalk.default.red("\n\u2717 You denied the authorization request.")
           );
+          return;
+        } else if (tokenData.error === "expired_token") {
+          pollSpinner.fail("Code expired");
+          console.log(import_chalk.default.red("\n\u2717 The authorization code expired. Please try again."));
+          return;
+        } else {
+          pollSpinner.fail("Authorization failed");
+          console.log(import_chalk.default.red("\n\u2717 Error:"), tokenData.error || "Unknown error");
+          return;
         }
-        throw new CommetAPIError(
-          errorData.message || `Request failed with status ${response.status}`,
-          response.status,
-          errorData.code,
-          errorData.details
+      } catch (error) {
+        pollSpinner.fail("Network error");
+        console.error(
+          import_chalk.default.red("Error:"),
+          error instanceof Error ? error.message : "Unknown error"
         );
       }
-      if (this.config.debug) {
-        console.log("[Commet SDK] Response:", responseData);
-      }
-      return responseData;
-    } catch (error) {
-      if (error instanceof TypeError && error.message.includes("fetch")) {
-        if (attempt <= this.retryConfig.maxRetries) {
-          const delay = Math.min(
-            this.retryConfig.baseDelay * 2 ** (attempt - 1),
-            this.retryConfig.maxDelay
-          );
-          if (this.config.debug) {
-            console.log(`[Commet SDK] Network error, retrying in ${delay}ms`);
-          }
-          await this.sleep(delay);
-          return this.executeRequest(method, url, data, options, attempt + 1);
-        }
-      }
-      throw error;
+    };
+    poll();
+  } catch (error) {
+    spinner.fail("Login failed");
+    console.error(
+      import_chalk.default.red("Error:"),
+      error instanceof Error ? error.message : "Unknown error"
+    );
+  }
+});
+
+// src/commands/logout.ts
+var import_commander2 = require("commander");
+var import_chalk2 = __toESM(require("chalk"));
+var logoutCommand = new import_commander2.Command("logout").description("Log out of Commet").action(async () => {
+  if (!authExists()) {
+    console.log(import_chalk2.default.yellow("\u26A0 You are not logged in."));
+    return;
+  }
+  clearAuth();
+  console.log(import_chalk2.default.green("\u2713 Successfully logged out"));
+});
+
+// src/commands/whoami.ts
+var import_commander3 = require("commander");
+var import_chalk3 = __toESM(require("chalk"));
+var whoamiCommand = new import_commander3.Command("whoami").description("Display current authentication and project status").action(async () => {
+  if (!authExists()) {
+    console.log(import_chalk3.default.yellow("\u26A0 Not logged in"));
+    console.log(import_chalk3.default.dim("Run `commet login` to authenticate"));
+    return;
+  }
+  console.log(import_chalk3.default.green("\u2713 Logged in"));
+  const projectConfig = loadProjectConfig();
+  if (projectConfig) {
+    console.log(import_chalk3.default.bold("\nProject:"));
+    console.log(import_chalk3.default.dim("Organization:"), projectConfig.orgName);
+    console.log(import_chalk3.default.dim("Environment:"), projectConfig.environment);
+  } else {
+    console.log(import_chalk3.default.yellow("\n\u26A0 No project linked"));
+    console.log(import_chalk3.default.dim("Run `commet link` to connect this directory to an organization"));
+  }
+});
+
+// src/commands/link.ts
+var import_commander4 = require("commander");
+var import_chalk4 = __toESM(require("chalk"));
+var import_inquirer = __toESM(require("inquirer"));
+var import_ora2 = __toESM(require("ora"));
+var linkCommand = new import_commander4.Command("link").description("Link this project to a Commet organization").action(async () => {
+  if (!authExists()) {
+    console.log(import_chalk4.default.red("\u2717 Not authenticated"));
+    console.log(import_chalk4.default.dim("Run `commet login` first"));
+    return;
+  }
+  if (projectConfigExists()) {
+    const config = loadProjectConfig();
+    console.log(import_chalk4.default.yellow("\u26A0 This project is already linked"));
+    console.log(
+      import_chalk4.default.dim(`Organization: ${config?.orgName} (${config?.environment})`)
+    );
+    console.log(
+      import_chalk4.default.dim("\nRun `commet unlink` first if you want to change the organization")
+    );
+    return;
+  }
+  const spinner = (0, import_ora2.default)("Fetching organizations...").start();
+  const baseURL = getBaseURL("sandbox");
+  const result = await apiRequest(
+    `${baseURL}/api/cli/organizations`
+  );
+  if (result.error || !result.data) {
+    spinner.fail("Failed to fetch organizations");
+    console.error(import_chalk4.default.red("Error:"), result.error);
+    return;
+  }
+  const { organizations } = result.data;
+  if (organizations.length === 0) {
+    spinner.stop();
+    console.log(import_chalk4.default.yellow("\u26A0 No organizations found"));
+    console.log(
+      import_chalk4.default.dim("Create an organization at https://billing.commet.co first")
+    );
+    return;
+  }
+  spinner.stop();
+  const answers = await import_inquirer.default.prompt([
+    {
+      type: "list",
+      name: "orgId",
+      message: "Select organization:",
+      choices: organizations.map((org) => ({
+        name: `${org.name} (${org.slug})`,
+        value: org.id
+      }))
+    },
+    {
+      type: "list",
+      name: "environment",
+      message: "Select environment:",
+      choices: [
+        { name: "Sandbox (Development)", value: "sandbox" },
+        { name: "Production", value: "production" }
+      ],
+      default: "sandbox"
+    }
+  ]);
+  const selectedOrg = organizations.find((org) => org.id === answers.orgId);
+  if (!selectedOrg) {
+    console.log(import_chalk4.default.red("\u2717 Organization not found"));
+    return;
+  }
+  saveProjectConfig({
+    orgId: selectedOrg.id,
+    orgName: selectedOrg.name,
+    environment: answers.environment
+  });
+  console.log(import_chalk4.default.green("\n\u2713 Project linked successfully!"));
+  console.log(import_chalk4.default.dim("\nProject configuration:"));
+  console.log(import_chalk4.default.dim(`  Organization: ${selectedOrg.name}`));
+  console.log(import_chalk4.default.dim(`  Environment: ${answers.environment}`));
+  console.log(
+    import_chalk4.default.dim("\nNext step:\n  Run `commet pull` to generate TypeScript types")
+  );
+});
+
+// src/commands/unlink.ts
+var import_commander5 = require("commander");
+var import_chalk5 = __toESM(require("chalk"));
+var unlinkCommand = new import_commander5.Command("unlink").description("Unlink this project from Commet").action(async () => {
+  if (!projectConfigExists()) {
+    console.log(import_chalk5.default.yellow("\u26A0 This project is not linked to any organization"));
+    return;
+  }
+  clearProjectConfig();
+  console.log(import_chalk5.default.green("\u2713 Project unlinked successfully"));
+  console.log(import_chalk5.default.dim("Run `commet link` to connect to an organization"));
+});
+
+// src/commands/switch.ts
+var import_commander6 = require("commander");
+var import_chalk6 = __toESM(require("chalk"));
+var import_inquirer2 = __toESM(require("inquirer"));
+var import_ora3 = __toESM(require("ora"));
+var switchCommand = new import_commander6.Command("switch").description("Switch to a different organization").action(async () => {
+  if (!authExists()) {
+    console.log(import_chalk6.default.red("\u2717 Not authenticated"));
+    console.log(import_chalk6.default.dim("Run `commet login` first"));
+    return;
+  }
+  if (!projectConfigExists()) {
+    console.log(import_chalk6.default.yellow("\u26A0 Project not linked"));
+    console.log(
+      import_chalk6.default.dim("Run `commet link` first to connect to an organization")
+    );
+    return;
+  }
+  const spinner = (0, import_ora3.default)("Fetching organizations...").start();
+  const baseURL = getBaseURL("sandbox");
+  const result = await apiRequest(
+    `${baseURL}/api/cli/organizations`
+  );
+  if (result.error || !result.data) {
+    spinner.fail("Failed to fetch organizations");
+    console.error(import_chalk6.default.red("Error:"), result.error);
+    return;
+  }
+  const { organizations } = result.data;
+  if (organizations.length === 0) {
+    spinner.stop();
+    console.log(import_chalk6.default.yellow("\u26A0 No organizations found"));
+    return;
+  }
+  spinner.stop();
+  const answers = await import_inquirer2.default.prompt([
+    {
+      type: "list",
+      name: "orgId",
+      message: "Select organization:",
+      choices: organizations.map((org) => ({
+        name: `${org.name} (${org.slug})`,
+        value: org.id
+      }))
+    },
+    {
+      type: "list",
+      name: "environment",
+      message: "Select environment:",
+      choices: [
+        { name: "Sandbox (Development)", value: "sandbox" },
+        { name: "Production", value: "production" }
+      ],
+      default: "sandbox"
     }
+  ]);
+  const selectedOrg = organizations.find((org) => org.id === answers.orgId);
+  if (!selectedOrg) {
+    console.log(import_chalk6.default.red("\u2717 Organization not found"));
+    return;
+  }
+  saveProjectConfig({
+    orgId: selectedOrg.id,
+    orgName: selectedOrg.name,
+    environment: answers.environment
+  });
+  console.log(import_chalk6.default.green("\n\u2713 Switched organization successfully!"));
+  console.log(import_chalk6.default.dim("\nNew configuration:"));
+  console.log(import_chalk6.default.dim(`  Organization: ${selectedOrg.name}`));
+  console.log(import_chalk6.default.dim(`  Environment: ${answers.environment}`));
+  console.log(
+    import_chalk6.default.dim("\nRun `commet pull` to update TypeScript types for this organization")
+  );
+});
+
+// src/commands/pull.ts
+var fs2 = __toESM(require("fs"));
+var path2 = __toESM(require("path"));
+var import_commander7 = require("commander");
+var import_chalk7 = __toESM(require("chalk"));
+var import_ora4 = __toESM(require("ora"));
+
+// src/utils/generator.ts
+function generateTypes(eventTypes, seatTypes) {
+  const eventTypeUnion = eventTypes.length > 0 ? eventTypes.map((e) => `"${e.code}"`).join(" | ") : "string";
+  const seatTypeUnion = seatTypes.length > 0 ? seatTypes.map((s) => `"${s.code}"`).join(" | ") : "string";
+  const eventComments = eventTypes.map((e) => ` * - "${e.code}": ${e.name}${e.description ? ` - ${e.description}` : ""}`).join("\n");
+  const seatComments = seatTypes.map(
+    (s) => ` * - "${s.code}": ${s.name}${s.description ? ` - ${s.description}` : ""} ${s.isFree ? "(Free)" : ""}`
+  ).join("\n");
+  return `// Auto-generated by Commet CLI
+// Do not edit this file manually - run 'commet pull' to update
+
+/**
+ * Event types available in your organization
+${eventComments}
+ */
+export type CommetEventType = ${eventTypeUnion};
+
+/**
+ * Seat types available in your organization
+${seatComments}
+ */
+export type CommetSeatType = ${seatTypeUnion};
+
+/**
+ * Use these types with the Commet SDK for type-safe event and seat tracking
+ * 
+ * @example
+ * import { Commet } from 'commet';
+ * import type { CommetEventType, CommetSeatType } from './.commet';
+ * 
+ * const commet = new Commet({ apiKey: 'your-api-key' });
+ * 
+ * // Type-safe event tracking
+ * await commet.usage.sendEvent<CommetEventType>({
+ *   customerId: 'cust_123',
+ *   eventType: 'api_call', // Autocomplete works!
+ *   timestamp: new Date(),
+ * });
+ * 
+ * // Type-safe seat management
+ * await commet.seats.updateSeats<CommetSeatType>({
+ *   customerId: 'cust_123',
+ *   seatType: 'admin_seat', // Autocomplete works!
+ *   totalSeats: 5,
+ * });
+ */
+`;
+}
+
+// src/commands/pull.ts
+var pullCommand = new import_commander7.Command("pull").description("Pull type definitions from Commet").option(
+  "-o, --output <file>",
+  "Output file path",
+  ".commet.d.ts"
+).action(async (options) => {
+  if (!authExists()) {
+    console.log(import_chalk7.default.red("\u2717 Not authenticated"));
+    console.log(import_chalk7.default.dim("Run `commet login` first"));
+    return;
+  }
+  if (!projectConfigExists()) {
+    console.log(import_chalk7.default.red("\u2717 Project not linked"));
+    console.log(import_chalk7.default.dim("Run `commet link` first to connect to an organization"));
+    return;
+  }
+  const projectConfig = loadProjectConfig();
+  if (!projectConfig) {
+    console.log(import_chalk7.default.red("\u2717 Invalid project configuration"));
+    return;
+  }
+  const spinner = (0, import_ora4.default)("Fetching type definitions...").start();
+  const baseURL = getBaseURL(projectConfig.environment);
+  const result = await apiRequest(
+    `${baseURL}/api/cli/types?orgId=${projectConfig.orgId}`
+  );
+  if (result.error || !result.data) {
+    spinner.fail("Failed to fetch types");
+    console.error(import_chalk7.default.red("Error:"), result.error);
+    return;
+  }
+  const { eventTypes, seatTypes } = result.data;
+  const typeDefinitions = generateTypes(eventTypes, seatTypes);
+  const outputPath = path2.resolve(process.cwd(), options.output);
+  fs2.writeFileSync(outputPath, typeDefinitions, "utf8");
+  spinner.succeed("Type definitions generated!");
+  console.log(import_chalk7.default.green("\n\u2713 Success"));
+  console.log(import_chalk7.default.dim("\nGenerated types:"));
+  console.log(
+    import_chalk7.default.dim(`  Event types: ${eventTypes.length > 0 ? eventTypes.map((e) => e.code).join(", ") : "none"}`)
+  );
+  console.log(
+    import_chalk7.default.dim(`  Seat types: ${seatTypes.length > 0 ? seatTypes.map((s) => s.code).join(", ") : "none"}`)
+  );
+  console.log(import_chalk7.default.dim(`
+Output file: ${outputPath}`));
+  if (eventTypes.length === 0 && seatTypes.length === 0) {
+    console.log(
+      import_chalk7.default.yellow("\n\u26A0 No types found. Create event types and seat types in your Commet dashboard.")
+    );
   }
-  /**
-   * Build full URL from endpoint and params
-   */
-  buildURL(endpoint, params) {
-    const baseURL = "https://api.commet.co";
-    const fullPath = `/api${endpoint.startsWith("/") ? endpoint : `/${endpoint}`}`;
-    if (this.config.debug) {
+});
+
+// src/commands/list.ts
+var import_commander8 = require("commander");
+var import_chalk8 = __toESM(require("chalk"));
+var import_ora5 = __toESM(require("ora"));
+var listCommand = new import_commander8.Command("list").description("List event types or seat types").argument("<type>", "Type to list (events or seats)").action(async (type) => {
+  if (type !== "events" && type !== "seats") {
+    console.log(import_chalk8.default.red('\u2717 Invalid type. Use "events" or "seats"'));
+    console.log(import_chalk8.default.dim("\nExamples:"));
+    console.log(import_chalk8.default.dim("  commet list events"));
+    console.log(import_chalk8.default.dim("  commet list seats"));
+    return;
+  }
+  if (!authExists()) {
+    console.log(import_chalk8.default.red("\u2717 Not authenticated"));
+    console.log(import_chalk8.default.dim("Run `commet login` first"));
+    return;
+  }
+  if (!projectConfigExists()) {
+    console.log(import_chalk8.default.red("\u2717 Project not linked"));
+    console.log(import_chalk8.default.dim("Run `commet link` first to connect to an organization"));
+    return;
+  }
+  const projectConfig = loadProjectConfig();
+  if (!projectConfig) {
+    console.log(import_chalk8.default.red("\u2717 Invalid project configuration"));
+    return;
+  }
+  const spinner = (0, import_ora5.default)(`Fetching ${type}...`).start();
+  const baseURL = getBaseURL(projectConfig.environment);
+  const result = await apiRequest(
+    `${baseURL}/api/cli/types?orgId=${projectConfig.orgId}`
+  );
+  if (result.error || !result.data) {
+    spinner.fail(`Failed to fetch ${type}`);
+    console.error(import_chalk8.default.red("Error:"), result.error);
+    return;
+  }
+  spinner.stop();
+  if (type === "events") {
+    const { eventTypes } = result.data;
+    if (eventTypes.length === 0) {
+      console.log(import_chalk8.default.yellow("\u26A0 No event types found"));
       console.log(
-        `[Commet SDK] Building URL - baseURL: ${baseURL}, endpoint: ${endpoint}, fullPath: ${fullPath}`
+        import_chalk8.default.dim("Create event types in your Commet dashboard first")
       );
+      return;
     }
-    const url = new URL(fullPath, baseURL);
-    if (params) {
-      for (const [key, value] of Object.entries(params)) {
-        if (value !== void 0 && value !== null) {
-          url.searchParams.append(key, String(value));
-        }
+    console.log(import_chalk8.default.bold(`
+\u{1F4CA} Event Types (${eventTypes.length})
+`));
+    for (const eventType of eventTypes) {
+      console.log(import_chalk8.default.green(`\u2022 ${eventType.code}`));
+      console.log(import_chalk8.default.dim(`  ${eventType.name}`));
+      if (eventType.description) {
+        console.log(import_chalk8.default.dim(`  ${eventType.description}`));
       }
+      console.log("");
     }
-    const finalUrl = url.toString();
-    if (this.config.debug) {
-      console.log(`[Commet SDK] Final URL: ${finalUrl}`);
-    }
-    return finalUrl;
-  }
-  /**
-   * Generate idempotency key
-   */
-  generateIdempotencyKey() {
-    return `sdk_${Date.now()}_${Math.random().toString(36).substring(2)}`;
-  }
-  /**
-   * Sleep for specified milliseconds
-   */
-  sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-  }
-};
-
-// src/client.ts
-var Commet = class {
-  constructor(config) {
-    if (!config.apiKey) {
-      throw new Error("Commet SDK: API key is required");
-    }
-    if (!config.apiKey.startsWith("ck_")) {
-      throw new Error(
-        "Commet SDK: Invalid API key format. Expected format: ck_xxx..."
+  } else {
+    const { seatTypes } = result.data;
+    if (seatTypes.length === 0) {
+      console.log(import_chalk8.default.yellow("\u26A0 No seat types found"));
+      console.log(
+        import_chalk8.default.dim("Create seat types in your Commet dashboard first")
       );
+      return;
     }
-    this.environment = config.environment === "auto" ? detectEnvironment() : config.environment || detectEnvironment();
-    this.httpClient = new CommetHTTPClient(config, this.environment);
-    this.customers = new CustomersResource(this.httpClient);
-    this.usage = new UsageResource(this.httpClient);
-    this.seats = new SeatsResource(this.httpClient);
-    if (this.environment === "development" || config.debug) {
-      console.log(`[Commet SDK] Initialized in ${this.environment} mode`);
-      if (config.debug) {
-        console.log("API Key:", `${config.apiKey.substring(0, 12)}...`);
-        console.log("Base URL:", "https://api.commet.co");
-        if (this.environment === "development") {
-          console.log(
-            "Dev mode: Events will be logged to console, not sent to server"
-          );
-        }
+    console.log(import_chalk8.default.bold(`
+\u{1F4BA} Seat Types (${seatTypes.length})
+`));
+    for (const seatType of seatTypes) {
+      console.log(
+        import_chalk8.default.green(`\u2022 ${seatType.code}${seatType.isFree ? " (Free)" : ""}`)
+      );
+      console.log(import_chalk8.default.dim(`  ${seatType.name}`));
+      if (seatType.description) {
+        console.log(import_chalk8.default.dim(`  ${seatType.description}`));
       }
+      console.log("");
     }
   }
-  getEnvironment() {
-    return this.environment;
-  }
-  isDevelopment() {
-    return this.environment === "development";
-  }
-  isProduction() {
-    return this.environment === "production";
-  }
-};
+});
 
-// src/index.ts
-var index_default = Commet;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Commet,
-  CommetAPIError,
-  CommetError,
-  CommetValidationError,
-  detectEnvironment,
-  isDevelopment,
-  isProduction
+// src/commands/info.ts
+var import_commander9 = require("commander");
+var import_chalk9 = __toESM(require("chalk"));
+var infoCommand = new import_commander9.Command("info").description("Display information about the current project").action(async () => {
+  console.log(import_chalk9.default.bold("\n\u{1F4E6} Project Information\n"));
+  if (!authExists()) {
+    console.log(import_chalk9.default.yellow("Authentication: Not logged in"));
+    console.log(import_chalk9.default.dim("Run `commet login` to authenticate\n"));
+    return;
+  }
+  console.log(import_chalk9.default.green("Authentication: Logged in \u2713"));
+  if (!projectConfigExists()) {
+    console.log(import_chalk9.default.yellow("\nProject: Not linked"));
+    console.log(import_chalk9.default.dim("Run `commet link` to connect to an organization\n"));
+    return;
+  }
+  const projectConfig = loadProjectConfig();
+  if (!projectConfig) {
+    console.log(import_chalk9.default.red("\nProject: Invalid configuration"));
+    return;
+  }
+  console.log(import_chalk9.default.green("\nProject: Linked \u2713"));
+  console.log(import_chalk9.default.dim("  Organization:"), projectConfig.orgName);
+  console.log(import_chalk9.default.dim("  Organization ID:"), projectConfig.orgId);
+  console.log(import_chalk9.default.dim("  Environment:"), projectConfig.environment);
+  console.log(
+    import_chalk9.default.dim("\nRun `commet pull` to generate type definitions\n")
+  );
 });
-//# sourceMappingURL=index.js.map
+
+// src/index.ts
+var program = new import_commander10.Command();
+program.name("commet").description("Commet CLI - Manage your billing platform from the command line").version("0.3.0");
+program.addCommand(loginCommand);
+program.addCommand(logoutCommand);
+program.addCommand(whoamiCommand);
+program.addCommand(linkCommand);
+program.addCommand(unlinkCommand);
+program.addCommand(switchCommand);
+program.addCommand(infoCommand);
+program.addCommand(pullCommand);
+program.addCommand(listCommand);
+program.exitOverride();
+try {
+  program.parse(process.argv);
+} catch (error) {
+  if (error instanceof Error) {
+    if (error.message.includes("outputHelp")) {
+      process.exit(0);
+    }
+    console.error(import_chalk10.default.red("Error:"), error.message);
+  }
+  process.exit(1);
+}
+if (!process.argv.slice(2).length) {
+  program.outputHelp();
+}