@meetploy/cli 1.7.0 → 1.8.0

package/dist/index.js

@@ -1,19 +1,21 @@
 #!/usr/bin/env node
 import { createRequire } from 'module';
-import { mkdir, writeFile, readFile, access } from 'fs/promises';
+import { mkdir, writeFile, readFile, chmod, access } from 'fs/promises';
 import { join, dirname } from 'path';
 import { existsSync, readFileSync, readFile as readFile$1, mkdirSync, writeFileSync } from 'fs';
 import { promisify } from 'util';
 import { parse } from 'yaml';
 import { build } from 'esbuild';
 import { watch } from 'chokidar';
-import { fileURLToPath } from 'url';
-import { randomUUID, createHash } from 'crypto';
+import { URL, fileURLToPath } from 'url';
+import { randomBytes, randomUUID, createHash } from 'crypto';
 import { serve } from '@hono/node-server';
 import { Hono } from 'hono';
-import { tmpdir } from 'os';
+import { homedir, tmpdir } from 'os';
 import Database from 'better-sqlite3';
-import { spawn } from 'child_process';
+import { spawn, exec } from 'child_process';
+import createClient from 'openapi-fetch';
+import { createServer } from 'http';
 
 createRequire(import.meta.url);
 var __defProp = Object.defineProperty;
@@ -2597,6 +2599,1317 @@ var init_dist2 = __esm({
     init_db_runtime();
   }
 });
+var CONFIG_DIR = join(homedir(), ".ploy");
+var CONFIG_FILE = join(CONFIG_DIR, "config.json");
+function getConfigFile() {
+  return CONFIG_FILE;
+}
+async function ensureConfigDir() {
+  if (!existsSync(CONFIG_DIR)) {
+    await mkdir(CONFIG_DIR, { recursive: true });
+  }
+}
+async function readConfig() {
+  try {
+    if (!existsSync(CONFIG_FILE)) {
+      return {};
+    }
+    const content = await readFile(CONFIG_FILE, "utf-8");
+    return JSON.parse(content);
+  } catch (error2) {
+    console.warn(`Warning: Could not read config file: ${error2}`);
+    return {};
+  }
+}
+async function writeConfig(config) {
+  await ensureConfigDir();
+  await writeFile(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  await chmod(CONFIG_FILE, 384);
+}
+async function updateConfig(updates) {
+  const config = await readConfig();
+  const newConfig = { ...config, ...updates };
+  await writeConfig(newConfig);
+  return newConfig;
+}
+async function getAuthToken() {
+  const envToken = process.env.PLOY_API_TOKEN || process.env.PLOY_API_KEY;
+  if (envToken) {
+    return envToken;
+  }
+  const config = await readConfig();
+  if (config.auth?.accessToken) {
+    if (config.auth.expiresAt) {
+      const expiresAt = new Date(config.auth.expiresAt);
+      if (expiresAt <= /* @__PURE__ */ new Date()) {
+        console.warn(
+          "Warning: Stored access token has expired. Please run 'ploy auth login' again."
+        );
+        await clearAuthToken();
+        return void 0;
+      }
+    }
+    return config.auth.accessToken;
+  }
+  return void 0;
+}
+async function setAuthToken(accessToken, expiresInSeconds) {
+  const auth = {
+    accessToken
+  };
+  if (expiresInSeconds) {
+    const expiresAt = new Date(Date.now() + expiresInSeconds * 1e3);
+    auth.expiresAt = expiresAt.toISOString();
+  }
+  await updateConfig({ auth });
+}
+async function clearAuthToken() {
+  const config = await readConfig();
+  delete config.auth;
+  await writeConfig(config);
+}
+async function getApiUrl() {
+  if (process.env.PLOY_API_URL) {
+    return process.env.PLOY_API_URL;
+  }
+  const config = await readConfig();
+  if (config.apiUrl) {
+    return config.apiUrl;
+  }
+  return "https://api.meetploy.com";
+}
+
+// src/lib/api-client.ts
+var ApiClientError = class extends Error {
+  constructor(message, status, code) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.name = "ApiClientError";
+  }
+};
+async function requireAuthToken() {
+  const token = await getAuthToken();
+  if (!token) {
+    console.error("Error: Authentication required");
+    console.error("");
+    console.error("Please authenticate using one of the following methods:");
+    console.error("");
+    console.error("  1. Run 'ploy auth login' to authenticate via browser");
+    console.error("");
+    console.error("  2. Set an environment variable:");
+    console.error("     PLOY_API_TOKEN - Your Ploy API token");
+    console.error("     PLOY_API_KEY   - Your Ploy API key");
+    console.error("");
+    process.exit(1);
+  }
+  return token;
+}
+var clientInstance = null;
+async function getClient() {
+  if (!clientInstance) {
+    const baseUrl = await getApiUrl();
+    const token = await requireAuthToken();
+    clientInstance = createClient({
+      baseUrl,
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "User-Agent": "ploy-cli/1.0.0"
+      }
+    });
+  }
+  return clientInstance;
+}
+async function getApiClient() {
+  return await getClient();
+}
+
+// src/commands/api/db.ts
+function printDbHelp() {
+  console.log("Usage: ploy api db <action> [options]");
+  console.log("");
+  console.log("Database operations via the Ploy API");
+  console.log("");
+  console.log("Actions:");
+  console.log("  tables <database>      List tables in a database");
+  console.log("  analytics <database>   View database analytics");
+  console.log("  list                   List all databases (requires --org)");
+  console.log("");
+  console.log("Options:");
+  console.log(
+    "  --org <id>             Organization ID (required for most actions)"
+  );
+  console.log("  --project <id>         Project ID (optional filter for list)");
+  console.log(
+    "  --period <period>      Analytics period: 24h, 7d, 30d (default: 24h)"
+  );
+  console.log("  --limit <n>            Limit number of results (default: 20)");
+  console.log(
+    "  --schema               Show table schema details (for tables action)"
+  );
+  console.log("  -h, --help             Show this help message");
+  console.log("");
+  console.log("Examples:");
+  console.log("  ploy api db tables my-database --org org123");
+  console.log("  ploy api db tables my-database --org org123 --schema");
+  console.log("  ploy api db analytics my-database --org org123");
+  console.log("  ploy api db analytics my-database --org org123 --period 7d");
+  console.log("  ploy api db list --org org123");
+}
+function parseDbArgs(args2) {
+  const options = {};
+  if (args2.length === 0 || args2[0] === "-h" || args2[0] === "--help") {
+    printDbHelp();
+    process.exit(0);
+  }
+  options.action = args2[0];
+  if (args2[1] && !args2[1].startsWith("-")) {
+    options.databaseName = args2[1];
+  }
+  for (let i = 1; i < args2.length; i++) {
+    const arg = args2[i];
+    if (arg === "--org") {
+      const nextArg = args2[i + 1];
+      if (!nextArg || nextArg.startsWith("-")) {
+        console.error("Error: --org requires a value");
+        process.exit(1);
+      }
+      options.orgId = nextArg;
+      i++;
+    } else if (arg === "--project") {
+      const nextArg = args2[i + 1];
+      if (!nextArg || nextArg.startsWith("-")) {
+        console.error("Error: --project requires a value");
+        process.exit(1);
+      }
+      options.projectId = nextArg;
+      i++;
+    } else if (arg === "--period") {
+      const nextArg = args2[i + 1];
+      if (!nextArg || nextArg.startsWith("-")) {
+        console.error("Error: --period requires a value");
+        process.exit(1);
+      }
+      const validPeriods = ["24h", "7d", "30d"];
+      if (!validPeriods.includes(nextArg)) {
+        console.error(
+          `Error: Invalid period. Valid options: ${validPeriods.join(", ")}`
+        );
+        process.exit(1);
+      }
+      options.period = nextArg;
+      i++;
+    } else if (arg === "--limit") {
+      const nextArg = args2[i + 1];
+      if (!nextArg || nextArg.startsWith("-")) {
+        console.error("Error: --limit requires a number");
+        process.exit(1);
+      }
+      const limit = parseInt(nextArg, 10);
+      if (Number.isNaN(limit)) {
+        console.error("Error: --limit must be a valid number");
+        process.exit(1);
+      }
+      options.limit = limit;
+      i++;
+    } else if (arg === "--schema") {
+      options.showSchema = true;
+    } else if (arg === "-h" || arg === "--help") {
+      printDbHelp();
+      process.exit(0);
+    }
+  }
+  return options;
+}
+async function listTables(options) {
+  const { databaseName, orgId, showSchema } = options;
+  if (!databaseName) {
+    console.error("Error: Database name/ID is required");
+    console.error("");
+    console.error("Usage: ploy api db tables <database>");
+    process.exit(1);
+  }
+  if (!orgId) {
+    console.error("Error: --org is required for database operations");
+    console.error("");
+    console.error("Usage: ploy api db tables <database> --org <org-id>");
+    process.exit(1);
+  }
+  console.log(`Fetching tables for database: ${databaseName}...`);
+  console.log("");
+  try {
+    const client = await getApiClient();
+    const { data, error: error2, response } = await client.GET(
+      "/projects/org/{orgId}/db/{databaseId}/tables",
+      {
+        params: { path: { orgId, databaseId: databaseName } }
+      }
+    );
+    if (error2 || !data) {
+      throw new ApiClientError(
+        error2?.message || "Failed to fetch tables",
+        response?.status || 500
+      );
+    }
+    const tablesResult = data;
+    if (!tablesResult.tables || tablesResult.tables.length === 0) {
+      console.log("No tables found in this database.");
+      return;
+    }
+    console.log("Tables");
+    console.log("======");
+    console.log("");
+    if (showSchema) {
+      const {
+        data: schemaData,
+        error: schemaError,
+        response: schemaResponse
+      } = await client.GET("/projects/org/{orgId}/db/{databaseId}/schema", {
+        params: { path: { orgId, databaseId: databaseName } }
+      });
+      if (schemaError || !schemaData) {
+        throw new ApiClientError(
+          schemaError?.message || "Failed to fetch schema",
+          schemaResponse?.status || 500
+        );
+      }
+      const schemaResult = schemaData;
+      for (const table of schemaResult.tables) {
+        console.log(`Table: ${table.name}`);
+        console.log("-".repeat(40));
+        console.log(
+          "  " + "COLUMN".padEnd(20) + "TYPE".padEnd(15) + "NULLABLE".padEnd(10) + "PK"
+        );
+        console.log("  " + "-".repeat(50));
+        for (const col of table.columns) {
+          const nullable = col.notNull ? "NO" : "YES";
+          const pk = col.primaryKey ? "YES" : "";
+          console.log(
+            "  " + col.name.padEnd(20) + col.type.padEnd(15) + nullable.padEnd(10) + pk
+          );
+        }
+        console.log("");
+      }
+    } else {
+      console.log("NAME".padEnd(30) + "ROWS".padEnd(12) + "SIZE");
+      console.log("-".repeat(55));
+      for (const table of tablesResult.tables) {
+        console.log(table.name.padEnd(30) + "-".padEnd(12) + "-");
+      }
+    }
+    console.log("");
+  } catch (error2) {
+    if (error2 instanceof ApiClientError) {
+      console.error(`Error: ${error2.message}`);
+      if (error2.status === 404) {
+        console.error(
+          "The database was not found. Check the database name/ID."
+        );
+      }
+    } else {
+      throw error2;
+    }
+    process.exit(1);
+  }
+}
+async function viewAnalytics(options) {
+  const { databaseName, orgId, period = "24h", limit = 10 } = options;
+  if (!databaseName) {
+    console.error("Error: Database name/ID is required");
+    console.error("");
+    console.error("Usage: ploy api db analytics <database>");
+    process.exit(1);
+  }
+  if (!orgId) {
+    console.error("Error: --org is required for database operations");
+    console.error("");
+    console.error("Usage: ploy api db analytics <database> --org <org-id>");
+    process.exit(1);
+  }
+  console.log(
+    `Fetching analytics for database: ${databaseName} (${period})...`
+  );
+  console.log("");
+  try {
+    const client = await getApiClient();
+    const { data, error: error2, response } = await client.GET(
+      "/projects/org/{orgId}/db/{databaseId}/insights",
+      {
+        params: {
+          path: { orgId, databaseId: databaseName },
+          query: {
+            timeRange: period,
+            limit: limit.toString()
+          }
+        }
+      }
+    );
+    if (error2 || !data) {
+      throw new ApiClientError(
+        error2?.message || "Failed to fetch analytics",
+        response?.status || 500
+      );
+    }
+    const insightsResult = data;
+    console.log("Database Analytics");
+    console.log("==================");
+    console.log("");
+    console.log(`  Period:            ${insightsResult.timeRange}`);
+    console.log(
+      `  Total Queries:     ${insightsResult.summary.totalQueries.toLocaleString()}`
+    );
+    console.log(
+      `  Total Rows Read:   ${insightsResult.summary.totalRowsRead.toLocaleString()}`
+    );
+    console.log(
+      `  Total Rows Written: ${insightsResult.summary.totalRowsWritten.toLocaleString()}`
+    );
+    const avgDuration = insightsResult.summary.totalQueries > 0 ? insightsResult.summary.totalDurationMs / insightsResult.summary.totalQueries : 0;
+    console.log(`  Avg Query Duration: ${avgDuration.toFixed(2)}ms`);
+    console.log("");
+    if (insightsResult.topQueries && insightsResult.topQueries.length > 0) {
+      console.log("Top Queries by Total Duration");
+      console.log("-----------------------------");
+      console.log("");
+      for (let i = 0; i < insightsResult.topQueries.length; i++) {
+        const insight = insightsResult.topQueries[i];
+        console.log(`${i + 1}. ${truncateQuery(insight.queryText, 60)}`);
+        console.log(`   Calls: ${insight.totalCalls.toLocaleString()}`);
+        console.log(`   Avg Duration: ${insight.avgDurationMs.toFixed(2)}ms`);
+        console.log(
+          `   Total Duration: ${insight.totalDurationMs.toFixed(2)}ms`
+        );
+        console.log(`   Rows Read: ${insight.totalRowsRead.toLocaleString()}`);
+        console.log(
+          `   Rows Written: ${insight.totalRowsWritten.toLocaleString()}`
+        );
+        console.log("");
+      }
+    }
+  } catch (error2) {
+    if (error2 instanceof ApiClientError) {
+      console.error(`Error: ${error2.message}`);
+      if (error2.status === 404) {
+        console.error(
+          "The database was not found. Check the database name/ID."
+        );
+      }
+    } else {
+      throw error2;
+    }
+    process.exit(1);
+  }
+}
+async function listDatabases(options) {
+  if (!options.orgId) {
+    console.error("Error: --org is required for listing databases");
+    console.error("");
+    console.error("Usage: ploy api db list --org <org-id>");
+    process.exit(1);
+  }
+  try {
+    const client = await getApiClient();
+    const { data, error: error2, response } = await client.GET(
+      "/orgs/{id}/databases",
+      {
+        params: {
+          path: { id: options.orgId },
+          query: options.projectId ? { projectId: options.projectId } : void 0
+        }
+      }
+    );
+    if (error2 || !data) {
+      throw new ApiClientError(
+        error2?.message || "Failed to list databases",
+        response?.status || 500
+      );
+    }
+    const databases = data.databases;
+    if (!databases || databases.length === 0) {
+      console.log("No databases found.");
+      return;
+    }
+    console.log("");
+    console.log("Databases");
+    console.log("=========");
+    console.log("");
+    console.log(
+      "ID".padEnd(26) + "NAME".padEnd(25) + "REGION".padEnd(15) + "CREATED"
+    );
+    console.log("-".repeat(80));
+    for (const db of databases) {
+      const id = db.id.substring(0, Math.min(24, db.id.length));
+      const name = db.name.substring(0, Math.min(23, db.name.length)).padEnd(25);
+      const region = (db.region || "-").padEnd(15);
+      const created = db.createdAt ? new Date(db.createdAt).toLocaleDateString() : "-";
+      console.log(`${id}  ${name}${region}${created}`);
+    }
+    console.log("");
+  } catch (error2) {
+    if (error2 instanceof ApiClientError) {
+      console.error(`Error: ${error2.message}`);
+    } else {
+      throw error2;
+    }
+    process.exit(1);
+  }
+}
+function truncateQuery(query, maxLength) {
+  const normalized = query.replace(/\s+/g, " ").trim();
+  if (normalized.length <= maxLength) {
+    return normalized;
+  }
+  return normalized.substring(0, maxLength - 3) + "...";
+}
+async function dbCommand(options) {
+  const { action } = options;
+  if (!action) {
+    printDbHelp();
+    process.exit(1);
+  }
+  switch (action) {
+    case "tables":
+      await listTables(options);
+      break;
+    case "analytics":
+      await viewAnalytics(options);
+      break;
+    case "list":
+      await listDatabases(options);
+      break;
+    case "-h":
+    case "--help":
+      printDbHelp();
+      process.exit(0);
+      break;
+    default:
+      console.error(`Unknown action: ${action}`);
+      console.error("");
+      console.error("Available actions: tables, analytics, list");
+      console.error("");
+      console.error("Run 'ploy api db --help' for more information");
+      process.exit(1);
+  }
+}
+
+// src/commands/api/deployment.ts
+function printDeploymentHelp() {
+  console.log("Usage: ploy api deployment <action> [options]");
+  console.log("");
+  console.log("Manage deployments via the Ploy API");
+  console.log("");
+  console.log("Actions:");
+  console.log("  retry <id>   Retry a failed deployment");
+  console.log("  logs <id>    View deployment build logs");
+  console.log("  view <id>    View deployment details");
+  console.log("  list         List deployments (requires --project)");
+  console.log("");
+  console.log("Options:");
+  console.log("  --branch <name>     Filter by branch name (for view/list)");
+  console.log("  --commit <sha>      Filter by commit SHA (for view)");
+  console.log("  --project <id>      Project ID (required for list)");
+  console.log("  --limit <n>         Limit number of results (default: 20)");
+  console.log("  -h, --help          Show this help message");
+  console.log("");
+  console.log("Examples:");
+  console.log("  ploy api deployment retry abc123");
+  console.log("  ploy api deployment logs abc123");
+  console.log("  ploy api deployment view abc123");
+  console.log("  ploy api deployment view abc123 --branch main");
+  console.log("  ploy api deployment list --project proj123");
+}
+function parseDeploymentArgs(args2) {
+  const options = {};
+  if (args2.length === 0 || args2[0] === "-h" || args2[0] === "--help") {
+    printDeploymentHelp();
+    process.exit(0);
+  }
+  options.action = args2[0];
+  if (args2[1] && !args2[1].startsWith("-")) {
+    options.deploymentId = args2[1];
+  }
+  for (let i = 1; i < args2.length; i++) {
+    const arg = args2[i];
+    if (arg === "--branch") {
+      const nextArg = args2[i + 1];
+      if (!nextArg || nextArg.startsWith("-")) {
+        console.error("Error: --branch requires a value");
+        process.exit(1);
+      }
+      options.branch = nextArg;
+      i++;
+    } else if (arg === "--commit") {
+      const nextArg = args2[i + 1];
+      if (!nextArg || nextArg.startsWith("-")) {
+        console.error("Error: --commit requires a value");
+        process.exit(1);
+      }
+      options.commitSha = nextArg;
+      i++;
+    } else if (arg === "--project") {
+      const nextArg = args2[i + 1];
+      if (!nextArg || nextArg.startsWith("-")) {
+        console.error("Error: --project requires a value");
+        process.exit(1);
+      }
+      options.projectId = nextArg;
+      i++;
+    } else if (arg === "--limit") {
+      const nextArg = args2[i + 1];
+      if (!nextArg || nextArg.startsWith("-")) {
+        console.error("Error: --limit requires a number");
+        process.exit(1);
+      }
+      const limit = parseInt(nextArg, 10);
+      if (Number.isNaN(limit)) {
+        console.error("Error: --limit requires a valid number");
+        process.exit(1);
+      }
+      options.limit = limit;
+      i++;
+    } else if (arg === "-f" || arg === "--follow") {
+      options.follow = true;
+    } else if (arg === "-h" || arg === "--help") {
+      printDeploymentHelp();
+      process.exit(0);
+    }
+  }
+  return options;
+}
+async function retryDeployment(deploymentId) {
+  console.log(`Retrying deployment ${deploymentId}...`);
+  try {
+    const client = await getApiClient();
+    const { data, error: error2, response } = await client.POST(
+      "/deployments/{deploymentId}/retry",
+      {
+        params: { path: { deploymentId } }
+      }
+    );
+    if (error2 || !data) {
+      throw new ApiClientError(
+        error2?.message || "Failed to retry deployment",
+        response?.status || 500
+      );
+    }
+    const retryResult = data;
+    console.log("");
+    console.log("Deployment retry initiated successfully");
+    console.log("");
+    console.log(`  New Deployment ID: ${retryResult.newDeploymentId}`);
+    console.log(`  Message: ${retryResult.message}`);
+  } catch (error2) {
+    if (error2 instanceof ApiClientError) {
+      console.error(`Error: ${error2.message}`);
+      if (error2.status === 404) {
+        console.error("The deployment was not found. Check the deployment ID.");
+      } else if (error2.status === 400) {
+        console.error(
+          "The deployment cannot be retried (may not be in a failed state)."
+        );
+      }
+    } else {
+      throw error2;
+    }
+    process.exit(1);
+  }
+}
+async function viewDeploymentLogs(deploymentId, _options) {
+  console.log(`Fetching logs for deployment ${deploymentId}...`);
+  console.log("");
+  try {
+    const client = await getApiClient();
+    const { data, error: error2, response } = await client.GET(
+      "/deployments/{deploymentId}/logs",
+      {
+        params: { path: { deploymentId } }
+      }
+    );
+    if (error2 || !data) {
+      throw new ApiClientError(
+        error2?.message || "Failed to fetch logs",
+        response?.status || 500
+      );
+    }
+    const logsResult = data;
+    if (!logsResult.logs || logsResult.logs.length === 0) {
+      console.log("No logs available for this deployment.");
+      return;
+    }
+    for (const log2 of logsResult.logs) {
+      const timestamp2 = new Date(log2.createdAt).toLocaleTimeString();
+      const level = log2.level.toUpperCase().padEnd(5);
+      const prefix = log2.command ? `[${log2.command}] ` : "";
+      console.log(`${timestamp2} ${level} ${prefix}${log2.message}`);
+    }
+  } catch (error2) {
+    if (error2 instanceof ApiClientError) {
+      console.error(`Error: ${error2.message}`);
+      if (error2.status === 404) {
+        console.error("The deployment was not found. Check the deployment ID.");
+      }
+    } else {
+      throw error2;
+    }
+    process.exit(1);
+  }
+}
+async function viewDeployment(deploymentId, _options) {
+  try {
+    const client = await getApiClient();
+    const { data, error: error2, response } = await client.GET(
+      "/deployments/{deploymentId}",
+      {
+        params: { path: { deploymentId } }
+      }
+    );
+    if (error2 || !data) {
+      throw new ApiClientError(
+        error2?.message || "Failed to fetch deployment",
+        response?.status || 500
+      );
+    }
+    const deployment = data.deployment;
+    console.log("");
+    console.log("Deployment Details");
+    console.log("==================");
+    console.log("");
+    console.log(`  ID:          ${deployment.id}`);
+    console.log(`  Status:      ${formatStatus(deployment.status)}`);
+    if (deployment.project) {
+      console.log(`  Project:     ${deployment.project.name}`);
+    }
+    if (deployment.repository) {
+      console.log(`  Repository:  ${deployment.repository.fullName}`);
+    }
+    if (deployment.branch) {
+      console.log(`  Branch:      ${deployment.branch}`);
+    }
+    if (deployment.commitSha) {
+      const commitDisplay = deployment.commitSha.length >= 8 ? deployment.commitSha.substring(0, 8) : deployment.commitSha;
+      console.log(`  Commit:      ${commitDisplay}`);
+    }
+    if (deployment.commitMessage) {
+      console.log(`  Message:     ${deployment.commitMessage}`);
+    }
+    if (deployment.url) {
+      console.log(`  URL:         ${deployment.url}`);
+    }
+    console.log(
+      `  Created:     ${new Date(deployment.createdAt).toLocaleString()}`
+    );
+    console.log(
+      `  Updated:     ${new Date(deployment.updatedAt).toLocaleString()}`
+    );
+    console.log("");
+  } catch (error2) {
+    if (error2 instanceof ApiClientError) {
+      console.error(`Error: ${error2.message}`);
+      if (error2.status === 404) {
+        console.error("The deployment was not found. Check the deployment ID.");
+      }
+    } else {
+      throw error2;
+    }
+    process.exit(1);
+  }
+}
+async function listDeployments(options) {
+  if (!options.projectId) {
+    console.error("Error: --project is required for listing deployments");
+    console.error("");
+    console.error("Usage: ploy api deployment list --project <project-id>");
+    process.exit(1);
+  }
+  try {
+    const client = await getApiClient();
+    const { data, error: error2, response } = await client.GET("/deployments", {
+      params: {
+        query: {
+          projectId: options.projectId,
+          branch: options.branch,
+          limit: options.limit?.toString() || "20"
+        }
+      }
+    });
+    if (error2 || !data) {
+      throw new ApiClientError(
+        error2?.message || "Failed to list deployments",
+        response?.status || 500
+      );
+    }
+    const deployments = data.deployments;
+    if (!deployments || deployments.length === 0) {
+      console.log("No deployments found.");
+      return;
+    }
+    console.log("");
+    console.log("Deployments");
+    console.log("===========");
+    console.log("");
+    console.log(
+      "ID".padEnd(12) + "STATUS".padEnd(12) + "BRANCH".padEnd(20) + "COMMIT".padEnd(10) + "CREATED"
+    );
+    console.log("-".repeat(70));
+    for (const d of deployments) {
+      const id = d.id.substring(0, Math.min(10, d.id.length));
+      const status = d.status.padEnd(10);
+      const branchSource = d.branch || "-";
+      const branch = branchSource.substring(0, Math.min(18, branchSource.length)).padEnd(20);
+      const commit = d.commitSha ? d.commitSha.substring(0, Math.min(8, d.commitSha.length)) : "-";
+      const created = new Date(d.createdAt).toLocaleDateString();
+      console.log(`${id}  ${status}  ${branch}${commit.padEnd(10)}${created}`);
+    }
+    console.log("");
+  } catch (error2) {
+    if (error2 instanceof ApiClientError) {
+      console.error(`Error: ${error2.message}`);
+    } else {
+      throw error2;
+    }
+    process.exit(1);
+  }
+}
+function formatStatus(status) {
+  if (!process.stdout.isTTY) {
+    return status;
+  }
+  const statusColors = {
+    success: "\x1B[32msuccess\x1B[0m",
+    // green
+    failure: "\x1B[31mfailure\x1B[0m",
+    // red
+    pending: "\x1B[33mpending\x1B[0m",
+    // yellow
+    building: "\x1B[34mbuilding\x1B[0m",
+    // blue
+    syncing: "\x1B[36msyncing\x1B[0m",
+    // cyan
+    uploading: "\x1B[36muploading\x1B[0m",
+    // cyan
+    timeout: "\x1B[31mtimeout\x1B[0m"
+    // red
+  };
+  return statusColors[status] || status;
+}
+async function deploymentCommand(options) {
+  const { action, deploymentId } = options;
+  if (!action) {
+    printDeploymentHelp();
+    process.exit(1);
+  }
+  switch (action) {
+    case "retry":
+      if (!deploymentId) {
+        console.error("Error: Deployment ID is required");
+        console.error("");
+        console.error("Usage: ploy api deployment retry <deployment-id>");
+        process.exit(1);
+      }
+      await retryDeployment(deploymentId);
+      break;
+    case "logs":
+      if (!deploymentId) {
+        console.error("Error: Deployment ID is required");
+        console.error("");
+        console.error("Usage: ploy api deployment logs <deployment-id>");
+        process.exit(1);
+      }
+      await viewDeploymentLogs(deploymentId);
+      break;
+    case "view":
+      if (!deploymentId) {
+        console.error("Error: Deployment ID is required");
+        console.error("");
+        console.error("Usage: ploy api deployment view <deployment-id>");
+        process.exit(1);
+      }
+      await viewDeployment(deploymentId);
+      break;
+    case "list":
+      await listDeployments(options);
+      break;
+    case "-h":
+    case "--help":
+      printDeploymentHelp();
+      process.exit(0);
+      break;
+    default:
+      console.error(`Unknown action: ${action}`);
+      console.error("");
+      console.error("Available actions: retry, logs, view, list");
+      console.error("");
+      console.error("Run 'ploy api deployment --help' for more information");
+      process.exit(1);
+  }
+}
+
+// src/commands/api/index.ts
+function printApiHelp() {
+  console.log("Usage: ploy api <subcommand> [options]");
+  console.log("");
+  console.log("Interact with the Ploy API from the command line");
+  console.log("");
+  console.log("Subcommands:");
+  console.log("  deployment  Manage deployments (retry, logs, view)");
+  console.log("  db          Database operations (tables, analytics)");
+  console.log("");
+  console.log("Options:");
+  console.log("  -h, --help  Show this help message");
+  console.log("");
+  console.log("Authentication:");
+  console.log(
+    "  Run 'ploy auth login' to authenticate via browser (recommended)"
+  );
+  console.log("");
+  console.log("  Or set environment variables:");
+  console.log("    PLOY_API_TOKEN  Your Ploy API token");
+  console.log(
+    "    PLOY_API_URL    API base URL (default: https://api.meetploy.com)"
+  );
+  console.log("");
+  console.log("Examples:");
+  console.log("  ploy api deployment retry abc123");
+  console.log("  ploy api deployment logs abc123");
+  console.log("  ploy api deployment view abc123 --branch main");
+  console.log("  ploy api db tables my-database");
+  console.log("  ploy api db analytics my-database");
+  console.log("");
+  console.log(
+    "Run 'ploy api <subcommand> --help' for subcommand-specific help"
+  );
+}
+function parseApiArgs(args2) {
+  const options = {
+    subArgs: []
+  };
+  if (args2.length === 0 || args2[0] === "-h" || args2[0] === "--help") {
+    printApiHelp();
+    process.exit(0);
+  }
+  options.subcommand = args2[0];
+  options.subArgs = args2.slice(1);
+  return options;
+}
+async function apiCommand(options) {
+  const { subcommand, subArgs } = options;
+  if (!subcommand) {
+    printApiHelp();
+    process.exit(1);
+  }
+  switch (subcommand) {
+    case "deployment":
+    case "deploy": {
+      const deploymentOptions = parseDeploymentArgs(subArgs);
+      await deploymentCommand(deploymentOptions);
+      break;
+    }
+    case "db":
+    case "database": {
+      const dbOptions = parseDbArgs(subArgs);
+      await dbCommand(dbOptions);
+      break;
+    }
+    case "-h":
+    case "--help":
+      printApiHelp();
+      process.exit(0);
+      break;
+    default:
+      console.error(`Unknown subcommand: ${subcommand}`);
+      console.error("");
+      console.error("Available subcommands:");
+      console.error("  deployment  Manage deployments");
+      console.error("  db          Database operations");
+      console.error("");
+      console.error("Run 'ploy api --help' for more information");
+      process.exit(1);
+  }
+}
+var OAUTH_CLIENT_ID = "ploy-cli";
+var CALLBACK_PORT = 9876;
+var CALLBACK_HOST = "127.0.0.1";
+function printLoginHelp() {
+  console.log("Usage: ploy login [options]");
+  console.log("");
+  console.log("Authenticate with the Ploy API via browser");
+  console.log("");
+  console.log("Options:");
+  console.log(
+    "  --api-url <url>  API base URL (default: https://api.meetploy.com)"
+  );
+  console.log("  -h, --help       Show this help message");
+  console.log("");
+  console.log("This command will:");
+  console.log("  1. Open your browser to authenticate");
+  console.log("  2. Store the access token in ~/.ploy/config.json");
+  console.log("");
+  console.log("Environment Variables:");
+  console.log("  PLOY_API_URL     API base URL (alternative to --api-url)");
+}
+function parseLoginArgs(args2) {
+  const options = {};
+  for (let i = 0; i < args2.length; i++) {
+    const arg = args2[i];
+    if (arg === "--api-url") {
+      const nextArg = args2[i + 1];
+      if (!nextArg || nextArg.startsWith("-")) {
+        console.error("Error: --api-url requires a value");
+        process.exit(1);
+      }
+      options.apiUrl = nextArg;
+      i++;
+    } else if (arg === "-h" || arg === "--help") {
+      printLoginHelp();
+      process.exit(0);
+    }
+  }
+  return options;
+}
+function openBrowser(url) {
+  const platform = process.platform;
+  let command2;
+  if (platform === "darwin") {
+    command2 = `open "${url}"`;
+  } else if (platform === "win32") {
+    command2 = `start "" "${url}"`;
+  } else {
+    command2 = `xdg-open "${url}"`;
+  }
+  exec(command2, (error2) => {
+    if (error2) {
+      console.log("");
+      console.log("Could not open browser automatically.");
+      console.log("Please open the following URL manually:");
+      console.log("");
+      console.log(`  ${url}`);
+      console.log("");
+    }
+  });
+}
+function generateState() {
+  return randomBytes(16).toString("hex");
+}
+async function exchangeCodeForToken(apiUrl, code, redirectUri) {
+  const tokenUrl = `${apiUrl}/oauth/token`;
+  const response = await fetch(tokenUrl, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      grant_type: "authorization_code",
+      code,
+      redirect_uri: redirectUri,
+      client_id: OAUTH_CLIENT_ID
+      // Note: client_secret may not be needed for public clients
+    })
+  });
+  if (!response.ok) {
+    const errorBody = await response.text();
+    throw new Error(`Token exchange failed: ${response.status} - ${errorBody}`);
+  }
+  return await response.json();
+}
+function createCallbackServer(expectedState, apiUrl) {
+  let server = null;
+  let resolveListening;
+  let rejectListening;
+  const waitForListening = new Promise((resolve, reject) => {
+    resolveListening = resolve;
+    rejectListening = reject;
+  });
+  const tokenPromise = new Promise((resolve, reject) => {
+    const timeout = setTimeout(
+      () => {
+        if (server) {
+          server.close();
+        }
+        reject(
+          new Error("Login timeout - no response received within 5 minutes")
+        );
+      },
+      5 * 60 * 1e3
+    );
+    server = createServer(async (req, res) => {
+      const reqUrl = new URL(
+        req.url || "/",
+        `http://${CALLBACK_HOST}:${CALLBACK_PORT}`
+      );
+      if (reqUrl.pathname !== "/callback") {
+        res.writeHead(404);
+        res.end("Not found");
+        return;
+      }
+      const code = reqUrl.searchParams.get("code");
+      const state = reqUrl.searchParams.get("state");
+      const error2 = reqUrl.searchParams.get("error");
+      const errorDescription = reqUrl.searchParams.get("error_description");
+      if (error2) {
+        clearTimeout(timeout);
+        res.writeHead(400, { "Content-Type": "text/html" });
+        res.end(`
+					<!DOCTYPE html>
+					<html>
+						<head><title>Login Failed</title></head>
+						<body style="font-family: system-ui; padding: 40px; text-align: center;">
+							<h1>Login Failed</h1>
+							<p>Error: ${error2}</p>
+							<p>${errorDescription || ""}</p>
+							<p>You can close this window.</p>
+						</body>
+					</html>
+				`);
+        server?.close();
+        reject(new Error(`OAuth error: ${error2} - ${errorDescription || ""}`));
+        return;
+      }
+      if (!code) {
+        clearTimeout(timeout);
+        res.writeHead(400, { "Content-Type": "text/html" });
+        res.end(`
+					<!DOCTYPE html>
+					<html>
+						<head><title>Login Failed</title></head>
+						<body style="font-family: system-ui; padding: 40px; text-align: center;">
+							<h1>Login Failed</h1>
+							<p>No authorization code received.</p>
+							<p>You can close this window.</p>
+						</body>
+					</html>
+				`);
+        server?.close();
+        reject(new Error("No authorization code received"));
+        return;
+      }
+      if (state !== expectedState) {
+        clearTimeout(timeout);
+        res.writeHead(400, { "Content-Type": "text/html" });
+        res.end(`
+					<!DOCTYPE html>
+					<html>
+						<head><title>Login Failed</title></head>
+						<body style="font-family: system-ui; padding: 40px; text-align: center;">
+							<h1>Login Failed</h1>
+							<p>State mismatch - possible CSRF attack.</p>
+							<p>You can close this window.</p>
+						</body>
+					</html>
+				`);
+        server?.close();
+        reject(new Error("State mismatch - possible CSRF attack"));
+        return;
+      }
+      try {
+        const redirectUri = `http://${CALLBACK_HOST}:${CALLBACK_PORT}/callback`;
+        const tokenResponse = await exchangeCodeForToken(
+          apiUrl,
+          code,
+          redirectUri
+        );
+        clearTimeout(timeout);
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(`
+					<!DOCTYPE html>
+					<html>
+						<head><title>Login Successful</title></head>
+						<body style="font-family: system-ui; padding: 40px; text-align: center;">
+							<h1>Login Successful!</h1>
+							<p>You have been authenticated with Ploy.</p>
+							<p>You can close this window and return to your terminal.</p>
+						</body>
+					</html>
+				`);
+        server?.close();
+        resolve(tokenResponse);
+      } catch (err) {
+        clearTimeout(timeout);
+        res.writeHead(500, { "Content-Type": "text/html" });
+        res.end(`
+					<!DOCTYPE html>
+					<html>
+						<head><title>Login Failed</title></head>
+						<body style="font-family: system-ui; padding: 40px; text-align: center;">
+							<h1>Login Failed</h1>
+							<p>Failed to exchange authorization code for token.</p>
+							<p>${err instanceof Error ? err.message : "Unknown error"}</p>
+							<p>You can close this window.</p>
+						</body>
+					</html>
+				`);
+        server?.close();
+        reject(err);
+      }
+    });
+    server.on("error", (err) => {
+      clearTimeout(timeout);
+      if (err.code === "EADDRINUSE") {
+        const portError = new Error(
+          `Port ${CALLBACK_PORT} is already in use. Please close any other process using this port and try again.`
+        );
+        reject(portError);
+        rejectListening(portError);
+      } else {
+        const serverError = new Error(
+          `Failed to start callback server: ${err.message}`
+        );
+        reject(serverError);
+        rejectListening(serverError);
+      }
+    });
+    server.listen(CALLBACK_PORT, CALLBACK_HOST, () => {
+      resolveListening();
+    });
+  });
+  return { tokenPromise, waitForListening };
+}
+async function loginCommand(options = {}) {
+  const apiUrl = options.apiUrl || await getApiUrl();
+  const state = generateState();
+  const redirectUri = `http://${CALLBACK_HOST}:${CALLBACK_PORT}/callback`;
+  console.log("Starting login flow...");
+  console.log("");
+  const authUrl = new URL(`${apiUrl}/oauth/authorize`);
+  authUrl.searchParams.set("response_type", "code");
+  authUrl.searchParams.set("client_id", OAUTH_CLIENT_ID);
+  authUrl.searchParams.set("redirect_uri", redirectUri);
+  authUrl.searchParams.set("state", state);
+  authUrl.searchParams.set("scope", "openid profile email");
+  const { tokenPromise, waitForListening } = createCallbackServer(
+    state,
+    apiUrl
+  );
+  try {
+    await waitForListening;
+  } catch (error2) {
+    console.error(
+      `Error: ${error2 instanceof Error ? error2.message : "Failed to start server"}`
+    );
+    process.exit(1);
+  }
+  console.log("Opening browser for authentication...");
+  openBrowser(authUrl.toString());
+  console.log("");
+  console.log("Waiting for authentication...");
+  console.log("(Press Ctrl+C to cancel)");
+  console.log("");
+  try {
+    const tokenResponse = await tokenPromise;
+    await setAuthToken(tokenResponse.access_token, tokenResponse.expires_in);
+    console.log("Login successful!");
+    console.log("");
+    console.log(`Credentials saved to: ${getConfigFile()}`);
+    console.log("");
+    console.log("You can now use 'ploy api' commands.");
+    process.exit(0);
+  } catch (error2) {
+    console.error("");
+    console.error(
+      `Login failed: ${error2 instanceof Error ? error2.message : "Unknown error"}`
+    );
+    process.exit(1);
+  }
+}
+
+// src/commands/auth/logout.ts
+function printLogoutHelp() {
+  console.log("Usage: ploy logout [options]");
+  console.log("");
+  console.log("Log out from the Ploy API");
+  console.log("");
+  console.log("Options:");
+  console.log("  -h, --help  Show this help message");
+  console.log("");
+  console.log(
+    "This command removes stored credentials from ~/.ploy/config.json"
+  );
+}
+function parseLogoutArgs(args2) {
+  for (const arg of args2) {
+    if (arg === "-h" || arg === "--help") {
+      printLogoutHelp();
+      process.exit(0);
+    }
+  }
+}
+async function logoutCommand() {
+  const config = await readConfig();
+  if (!config.auth?.accessToken) {
+    console.log("You are not logged in.");
+    return;
+  }
+  await clearAuthToken();
+  console.log("Logged out successfully.");
+  console.log("");
+  console.log(`Credentials removed from: ${getConfigFile()}`);
+}
+
+// src/commands/auth/index.ts
+function printAuthHelp() {
+  console.log("Usage: ploy auth <subcommand> [options]");
+  console.log("");
+  console.log("Manage authentication with Ploy");
+  console.log("");
+  console.log("Subcommands:");
+  console.log("  login   Authenticate with Ploy via browser");
+  console.log("  logout  Clear stored credentials");
+  console.log("");
+  console.log("Options:");
+  console.log("  -h, --help  Show this help message");
+  console.log("");
+  console.log("Examples:");
+  console.log("  ploy auth login");
+  console.log("  ploy auth logout");
+  console.log("");
+  console.log(
+    "Run 'ploy auth <subcommand> --help' for subcommand-specific help"
+  );
+}
+function parseAuthArgs(args2) {
+  const options = {
+    subArgs: []
+  };
+  if (args2.length === 0 || args2[0] === "-h" || args2[0] === "--help") {
+    printAuthHelp();
+    process.exit(0);
+  }
+  options.subcommand = args2[0];
+  options.subArgs = args2.slice(1);
+  return options;
+}
+async function authCommand(options) {
+  const { subcommand, subArgs } = options;
+  if (!subcommand) {
+    printAuthHelp();
+    process.exit(1);
+  }
+  switch (subcommand) {
+    case "login": {
+      const loginOptions = parseLoginArgs(subArgs);
+      await loginCommand(loginOptions);
+      break;
+    }
+    case "logout": {
+      parseLogoutArgs(subArgs);
+      await logoutCommand();
+      break;
+    }
+    case "-h":
+    case "--help":
+      printAuthHelp();
+      process.exit(0);
+      break;
+    default:
+      console.error(`Unknown subcommand: ${subcommand}`);
+      console.error("");
+      console.error("Available subcommands:");
+      console.error("  login   Authenticate with Ploy");
+      console.error("  logout  Clear stored credentials");
+      console.error("");
+      console.error("Run 'ploy auth --help' for more information");
+      process.exit(1);
+  }
+}
 
 // src/commands/build.ts
 init_cli();
@@ -2842,9 +4155,11 @@ var command = args[0];
 if (!command) {
   console.error("Usage: ploy <command>");
   console.error("\nAvailable commands:");
-  console.error("  build  Build your Ploy project");
-  console.error("  dev    Start development server");
-  console.error("  types  Generate TypeScript types from ploy.yaml");
+  console.error("  api     Interact with the Ploy API");
+  console.error("  auth    Manage authentication (login, logout)");
+  console.error("  build   Build your Ploy project");
+  console.error("  dev     Start development server");
+  console.error("  types   Generate TypeScript types from ploy.yaml");
   process.exit(1);
 }
 function parseDevArgs(args2) {
@@ -2999,11 +4314,19 @@ if (command === "dev") {
 } else if (command === "build") {
   const options = parseBuildArgs(args.slice(1));
   await buildCommand(options);
+} else if (command === "api") {
+  const options = parseApiArgs(args.slice(1));
+  await apiCommand(options);
+} else if (command === "auth") {
+  const options = parseAuthArgs(args.slice(1));
+  await authCommand(options);
 } else {
   console.error(`Unknown command: ${command}`);
   console.error("\nAvailable commands:");
-  console.error("  build  Build your Ploy project");
-  console.error("  dev    Start development server");
-  console.error("  types  Generate TypeScript types from ploy.yaml");
+  console.error("  api     Interact with the Ploy API");
+  console.error("  auth    Manage authentication (login, logout)");
+  console.error("  build   Build your Ploy project");
+  console.error("  dev     Start development server");
+  console.error("  types   Generate TypeScript types from ploy.yaml");
   process.exit(1);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@meetploy/cli",
-	"version": "1.7.0",
+	"version": "1.8.0",
 	"private": false,
 	"repository": {
 		"type": "git",
@@ -28,9 +28,10 @@
 		"dist/"
 	],
 	"scripts": {
-		"build": "tsup",
+		"build": "tsc --noEmit && tsup",
 		"dev": "tsup --watch",
 		"format": "eslint --fix . && prettier --write .",
+		"generate": "openapi-typescript ../../apps/api/openapi.json -o ./src/lib/api/v1.ts",
 		"lint": "eslint . && prettier --check ."
 	},
 	"dependencies": {
@@ -39,6 +40,7 @@
 		"chokidar": "^4.0.0",
 		"esbuild": "^0.24.0",
 		"hono": "^4.7.0",
+		"openapi-fetch": "0.14.0",
 		"workerd": "1.20260103.0",
 		"yaml": "2.8.1"
 	},
@@ -46,6 +48,7 @@
 		"@meetploy/emulator": "*",
 		"@meetploy/tools": "*",
 		"@types/better-sqlite3": "^7.6.12",
+		"openapi-typescript": "7.8.0",
 		"tsup": "^8.0.0"
 	}
 }