buildx-cli 1.0.0

package/src/commands/config/setup.ts

@@ -0,0 +1,75 @@
+import { Command } from 'commander';
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { configManager } from '../../config/index';
+
+export const setupCommand = new Command('setup')
+	.description('Configure API endpoint and API key')
+	.option('-e, --endpoint <endpoint>', 'API endpoint URL')
+	.option('-k, --api-key <apiKey>', 'API key')
+	.action(async (options) => {
+		try {
+			let endpoint = options.endpoint;
+			let apiKey = options.apiKey;
+
+			// If not provided via options, prompt interactively
+			if (!endpoint || !apiKey) {
+				console.log(chalk.blue('🔧 BuildX CLI Setup'));
+				console.log(chalk.gray('Configure your API endpoint and API key to get started.\n'));
+
+				const currentConfig = configManager.getApiConfig();
+
+				const answers = await inquirer.prompt([
+					{
+						type: 'input',
+						name: 'endpoint',
+						message: 'Enter your API endpoint URL:',
+						default: currentConfig?.endpoint || 'https://api.buildx.com',
+						validate: (input: string) => {
+							if (!input.trim()) {
+								return 'Endpoint URL is required';
+							}
+							try {
+								new URL(input);
+								return true;
+							} catch {
+								return 'Please enter a valid URL';
+							}
+						}
+					},
+					{
+						type: 'password',
+						name: 'apiKey',
+						message: 'Enter your API key:',
+						default: currentConfig?.apiKey || '',
+						validate: (input: string) => {
+							if (!input.trim()) {
+								return 'API key is required';
+							}
+							return true;
+						}
+					}
+				]);
+
+				endpoint = answers.endpoint;
+				apiKey = answers.apiKey;
+			}
+
+			// Save the configuration
+			configManager.setApiConfig({
+				endpoint: endpoint.trim(),
+				apiKey: apiKey.trim()
+			});
+
+			console.log(chalk.green('✅ Configuration saved successfully!'));
+			console.log(chalk.gray(`Endpoint: ${endpoint}`));
+			console.log(chalk.gray(`API Key: ${'*'.repeat(Math.min(apiKey.length, 8))}...`));
+			console.log(chalk.blue('\nYou can now use the CLI commands. Start with:'));
+			console.log(chalk.cyan('  buildx login'));
+			console.log(chalk.cyan('  buildx projects:list'));
+
+		} catch (error) {
+			console.error(chalk.red('❌ Setup failed:'), error instanceof Error ? error.message : 'Unknown error');
+			process.exit(1);
+		}
+	}); 

package/src/commands/config/show.ts

@@ -0,0 +1,70 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { configManager } from '../../config/index';
+
+export const configShowCommand = new Command('show')
+	.description('Show current configuration')
+	.action(() => {
+		try {
+			const apiConfig = configManager.getApiConfig();
+			const authConfig = configManager.getAuth();
+			const projectsConfig = configManager.getProjects();
+			const syncConfig = configManager.getSyncConfig();
+
+			console.log(chalk.blue('🔧 BuildX CLI Configuration'));
+			console.log(chalk.gray('='.repeat(50)));
+
+			// API Configuration
+			console.log(chalk.yellow('\n📡 API Configuration:'));
+			if (apiConfig) {
+				console.log(chalk.green('  ✅ Configured'));
+				console.log(chalk.gray(`  Endpoint: ${apiConfig.endpoint}`));
+				console.log(chalk.gray(`  API Key: ${'*'.repeat(Math.min(apiConfig.apiKey.length, 8))}...`));
+			} else {
+				console.log(chalk.red('  ❌ Not configured'));
+				console.log(chalk.gray('  Run "buildx setup" to configure'));
+			}
+
+			// Authentication
+			console.log(chalk.yellow('\n🔐 Authentication:'));
+			if (authConfig && configManager.isAuthenticated()) {
+				console.log(chalk.green('  ✅ Authenticated'));
+				console.log(chalk.gray(`  Token: ${authConfig.token.substring(0, 20)}...`));
+				if (authConfig.expiresAt) {
+					console.log(chalk.gray(`  Expires: ${new Date(authConfig.expiresAt).toLocaleString()}`));
+				}
+			} else {
+				console.log(chalk.red('  ❌ Not authenticated'));
+				console.log(chalk.gray('  Run "buildx login" to authenticate'));
+			}
+
+			// Projects
+			console.log(chalk.yellow('\n📁 Projects:'));
+			if (projectsConfig?.list && projectsConfig.list.length > 0) {
+				console.log(chalk.green(`  ✅ ${projectsConfig.list.length} project(s) available`));
+				if (projectsConfig.default) {
+					const defaultProject = projectsConfig.list.find(p => p.id === projectsConfig.default);
+					console.log(chalk.gray(`  Default: ${defaultProject?.name || projectsConfig.default}`));
+				}
+			} else {
+				console.log(chalk.red('  ❌ No projects available'));
+				console.log(chalk.gray('  Run "buildx projects:list" to fetch projects'));
+			}
+
+			// Sync Configuration
+			console.log(chalk.yellow('\n🔄 Sync Configuration:'));
+			if (syncConfig) {
+				console.log(chalk.gray(`  Output Path: ${syncConfig.outputPath}`));
+			} else {
+				console.log(chalk.gray('  Using default sync configuration'));
+			}
+
+			// Configuration file location
+			console.log(chalk.yellow('\n📂 Configuration File:'));
+			console.log(chalk.gray(`  ${configManager.getConfigPath()}`));
+
+		} catch (error) {
+			console.error(chalk.red('❌ Failed to show configuration:'), error instanceof Error ? error.message : 'Unknown error');
+			process.exit(1);
+		}
+	}); 

package/src/commands/projects/current.ts

@@ -0,0 +1,36 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { configManager } from '../../config/index';
+
+export const projectsCurrentCommand = new Command('projects:current')
+  .description('Show current default project')
+  .action(() => {
+    try {
+      const defaultProjectId = configManager.getDefaultProject();
+      
+      if (!defaultProjectId) {
+        console.log(chalk.yellow('No default project set'));
+        console.log(chalk.blue('Use "buildx projects:set-default <project-id>" to set a default project'));
+        return;
+      }
+
+      const project = configManager.getProject(defaultProjectId);
+      
+      if (!project) {
+        console.log(chalk.red('Error: Default project not found in configuration'));
+        console.log(chalk.blue('Project ID:'), defaultProjectId);
+        return;
+      }
+
+      console.log(chalk.green('Current default project:'));
+      console.log(chalk.blue('Name:'), project.name);
+      console.log(chalk.blue('ID:'), project.id);
+      if (project.apiUrl) {
+        console.log(chalk.blue('API URL:'), project.apiUrl);
+      }
+
+    } catch (error) {
+      console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+      process.exit(1);
+    }
+  }); 

package/src/commands/projects/list.ts

@@ -0,0 +1,61 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { configManager } from '../../config/index';
+import { apiService } from '../../services/api';
+
+export const projectsListCommand = new Command('projects:list')
+  .description('List available projects')
+  .action(async () => {
+    try {
+      // Check API configuration
+      if (!apiService.isConfigured()) {
+        console.error(chalk.red('❌ API not configured'));
+        console.log(chalk.yellow('Please configure your API endpoint and API key first:'));
+        console.log(chalk.cyan('  buildx config setup'));
+        process.exit(1);
+      }
+      // Check authentication
+      if (!configManager.isAuthenticated()) {
+        console.error(chalk.red('Error: Not authenticated'));
+        console.log(chalk.yellow('Run "buildx login" to authenticate first'));
+        process.exit(1);
+      }
+
+      const spinner = ora('Fetching projects...').start();
+
+      try {
+        const projects = await apiService.getProjects();
+        spinner.succeed(`Found ${projects.length} projects`);
+
+        if (projects.length === 0) {
+          console.log(chalk.yellow('No projects found'));
+          return;
+        }
+
+        const defaultProject = configManager.getDefaultProject();
+
+        console.log('\n' + chalk.blue.bold('Available Projects:'));
+        projects.forEach(project => {
+          const isDefault = project.id === defaultProject;
+          const prefix = isDefault ? chalk.green('★ ') : '  ';
+          console.log(`${prefix}${chalk.bold(project.name)} (${project.id})`);
+          if (project.apiUrl) {
+            console.log(`    API: ${chalk.gray(project.apiUrl)}`);
+          }
+        });
+
+        if (defaultProject) {
+          console.log(chalk.green('\n★ Default project'));
+        }
+
+      } catch (error) {
+        spinner.fail('Failed to fetch projects');
+        throw error;
+      }
+
+    } catch (error) {
+      console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+      process.exit(1);
+    }
+  }); 

package/src/commands/projects/set-default.ts

@@ -0,0 +1,33 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { configManager } from '../../config/index';
+
+export const projectsSetDefaultCommand = new Command('projects:set-default')
+  .description('Set default project')
+  .argument('<project-id>', 'Project ID to set as default')
+  .action(async (projectId: string) => {
+    try {
+      // Check authentication
+      if (!configManager.isAuthenticated()) {
+        console.error(chalk.red('Error: Not authenticated'));
+        console.log(chalk.yellow('Run "buildx login" to authenticate first'));
+        process.exit(1);
+      }
+
+      // Check if project exists in config
+      const project = configManager.getProject(projectId);
+      if (!project) {
+        console.error(chalk.red('Error: Project not found in configuration'));
+        console.log(chalk.yellow('Run "buildx projects:list" to see available projects'));
+        process.exit(1);
+      }
+
+      configManager.setDefaultProject(projectId);
+      console.log(chalk.green('✓ Default project set to:'), project.name);
+      console.log(chalk.blue('Project ID:'), projectId);
+
+    } catch (error) {
+      console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+      process.exit(1);
+    }
+  }); 

package/src/commands/sync.ts

@@ -0,0 +1,64 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import fs from "fs-extra";
+import path from "path";
+import { configManager } from "../config/index";
+import { apiService } from "../services/api";
+
+export const syncCommand = new Command("sync")
+	.description("Sync schema and generate TypeScript types")
+	.requiredOption("-p, --project-id <project-id>", "Project ID to sync schema from")
+	.option("-o, --output <path>", "Output path for generated types", "./generated/types.ts")
+	.option("-u, --api-url <url>", "Custom API base URL")
+	.option("-f, --force", "Force overwrite existing files")
+	.action(async (options) => {
+		try {
+			// Check API configuration
+			if (!apiService.isConfigured()) {
+				console.error(chalk.red('❌ API not configured'));
+				console.log(chalk.yellow('Please configure your API endpoint and API key first:'));
+				console.log(chalk.cyan('  buildx config setup'));
+				process.exit(1);
+			}
+			// Check authentication
+			if (!configManager.isAuthenticated()) {
+				console.error(chalk.red("Error: Not authenticated"));
+				console.log(chalk.yellow("Run \"buildx login\" to authenticate first"));
+				process.exit(1);
+			}
+
+			const { projectId, output, apiUrl, force } = options;
+
+			// Set custom API URL if provided
+			if (apiUrl) {
+				apiService.setBaseUrl(apiUrl);
+			}
+
+			// Fetch schema
+			const spinner = ora("Fetching TypeScript types...").start();
+
+			try {
+				const typescriptCode = await apiService.getSchema(projectId);
+				spinner.succeed("TypeScript types fetched successfully");
+
+				// Ensure output directory exists
+				const outputDir = path.dirname(output);
+				await fs.ensureDir(outputDir);
+
+				// Write the TypeScript code directly to file
+				await fs.writeFile(output, typescriptCode, "utf8");
+
+				console.log(chalk.green("✓ Types generated at:"), output);
+				console.log(chalk.blue("File size:"), `${(typescriptCode.length / 1024).toFixed(2)} KB`);
+
+			} catch (error) {
+				spinner.fail("Failed to fetch TypeScript types");
+				throw error;
+			}
+
+		} catch (error) {
+			console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+			process.exit(1);
+		}
+	}); 

package/src/config/index.ts

@@ -0,0 +1,154 @@
+import Conf from "conf";
+import { GlobalConfig, AuthConfig, ProjectsConfig, SyncConfig, ApiConfig } from "../types/index";
+
+export class ConfigManager {
+  private config: Conf<GlobalConfig>;
+
+  constructor() {
+    this.config = new Conf<GlobalConfig>({
+      projectName: "buildx-cli",
+      schema: {
+        api: {
+          type: "object",
+          properties: {
+            endpoint: { type: "string" },
+            apiKey: { type: "string" }
+          }
+        },
+        auth: {
+          type: "object",
+          properties: {
+            token: { type: "string" },
+            expiresAt: { type: "string" }
+          }
+        },
+        projects: {
+          type: "object",
+          properties: {
+            default: { type: "string" },
+            list: { type: "array" }
+          }
+        },
+        sync: {
+          type: "object",
+          properties: {
+            outputPath: { type: "string" }
+          }
+        }
+      },
+      defaults: {
+        sync: {
+          outputPath: "./generated/types.ts"
+        }
+      }
+    });
+  }
+
+  // API configuration methods
+  getApiConfig(): ApiConfig | undefined {
+    return this.config.get("api");
+  }
+
+  setApiConfig(api: ApiConfig): void {
+    this.config.set("api", api);
+  }
+
+  clearApiConfig(): void {
+    this.config.delete("api");
+  }
+
+  isApiConfigured(): boolean {
+    const api = this.getApiConfig();
+    return !!(api?.endpoint && api?.apiKey);
+  }
+
+  // Auth methods
+  getAuth(): AuthConfig | undefined {
+    return this.config.get("auth");
+  }
+
+  setAuth(auth: AuthConfig): void {
+    this.config.set("auth", auth);
+  }
+
+  clearAuth(): void {
+    this.config.delete("auth");
+  }
+
+  isAuthenticated(): boolean {
+    const auth = this.getAuth();
+    if (!auth || !auth.token) {
+      return false;
+    }
+
+    // Check if token is expired
+    if (auth.expiresAt) {
+      const expiresAt = new Date(auth.expiresAt);
+      if (expiresAt < new Date()) {
+        this.clearAuth();
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  // Projects methods
+  getProjects(): ProjectsConfig | undefined {
+    return this.config.get("projects");
+  }
+
+  setProjects(projects: ProjectsConfig): void {
+    this.config.set("projects", projects);
+  }
+
+  getDefaultProject(): string | undefined {
+    const projects = this.getProjects();
+    return projects?.default;
+  }
+
+  setDefaultProject(projectId: string): void {
+    const projects = this.getProjects() || { list: [] };
+    projects.default = projectId;
+    this.setProjects(projects);
+  }
+
+  addProject(project: { id: string; name: string; apiUrl?: string }): void {
+    const projects = this.getProjects() || { list: [] };
+    const existingIndex = projects.list.findIndex(p => p.id === project.id);
+
+    if (existingIndex >= 0) {
+      projects.list[existingIndex] = project;
+    } else {
+      projects.list.push(project);
+    }
+
+    this.setProjects(projects);
+  }
+
+  getProject(projectId: string): { id: string; name: string; apiUrl?: string } | undefined {
+    const projects = this.getProjects();
+    return projects?.list.find(p => p.id === projectId);
+  }
+
+  // Sync methods
+  getSyncConfig(): SyncConfig | undefined {
+    return this.config.get("sync");
+  }
+
+  setSyncConfig(sync: SyncConfig): void {
+    this.config.set("sync", sync);
+  }
+
+  // Utility methods
+  getConfigPath(): string {
+    return this.config.path;
+  }
+
+  clear(): void {
+    this.config.clear();
+  }
+}
+
+// Export singleton instance
+export const configManager = new ConfigManager(); 

package/src/index.ts

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import fs from 'fs';
+
+// Import commands
+import { loginCommand } from './commands/auth/login';
+import { logoutCommand } from './commands/auth/logout';
+import { authStatusCommand } from './commands/auth/status';
+import { syncCommand } from './commands/sync';
+import { projectsListCommand } from './commands/projects/list';
+import { projectsSetDefaultCommand } from './commands/projects/set-default';
+import { projectsCurrentCommand } from './commands/projects/current';
+import { configCommand } from './commands/config/index';
+
+const program = new Command();
+const packageJson = JSON.parse(fs.readFileSync('./package.json', 'utf8'));
+const version = packageJson.version;
+
+// Set up the CLI
+program
+  .name('buildx')
+  .description('BuildX CLI - API authentication and schema synchronization tool')
+  .version(version, '-v, --version');
+
+// Add commands
+program.addCommand(loginCommand);
+program.addCommand(logoutCommand);
+program.addCommand(authStatusCommand);
+program.addCommand(syncCommand);
+program.addCommand(projectsListCommand);
+program.addCommand(projectsSetDefaultCommand);
+program.addCommand(projectsCurrentCommand);
+program.addCommand(configCommand);
+
+// Global error handler
+program.exitOverride();
+
+try {
+  program.parse();
+} catch (err) {
+  if (err instanceof Error) {
+    console.error(chalk.red('Error:'), err.message);
+  } else {
+    console.error(chalk.red('An unexpected error occurred'));
+  }
+  process.exit(1);
+} 

package/src/services/api.ts

@@ -0,0 +1,132 @@
+import axios, { AxiosInstance, AxiosRequestConfig, InternalAxiosRequestConfig } from "axios";
+import { configManager } from "../config/index";
+import { ApiResponse, LoginCredentials, LoginResponse } from "../types/index";
+
+export class ApiService {
+  private client: AxiosInstance;
+
+  constructor() {
+    this.client = axios.create({
+      timeout: 30000,
+      headers: {
+        "Content-Type": "application/json",
+        "User-Agent": "buildx-cli/1.0.0"
+      }
+    });
+
+    // Add request interceptor to include auth token and API key
+    this.client.interceptors.request.use((config: InternalAxiosRequestConfig) => {
+      // Ensure client is initialized with current config before each request
+      this.initializeClient();
+
+      // Add API key from configuration
+      const apiConfig = configManager.getApiConfig();
+      if (apiConfig?.apiKey) {
+        config.headers["X-API-Key"] = apiConfig.apiKey;
+      }
+
+      // Add auth token
+      const auth = configManager.getAuth();
+      if (auth?.token) {
+        config.headers.Authorization = `Bearer ${auth.token}`;
+      }
+      return config;
+    });
+
+    // Add response interceptor for error handling
+    this.client.interceptors.response.use(
+      (response) => response,
+      (error: any) => {
+        if (error.response?.status === 401) {
+          configManager.clearAuth();
+          throw new Error("Authentication failed. Please login again.");
+        }
+        throw error;
+      }
+    );
+  }
+
+  private initializeClient(): void {
+    const apiConfig = configManager.getApiConfig();
+    if (apiConfig?.endpoint) {
+      this.client.defaults.baseURL = apiConfig.endpoint;
+      console.log(`Debug: Setting base URL to ${apiConfig.endpoint}`);
+    } else {
+      throw new Error("API endpoint not configured. Please run 'buildx config setup' first.");
+    }
+  }
+
+  private async request<T>(config: AxiosRequestConfig): Promise<ApiResponse<T>> {
+    // Always set baseURL from config before making the request
+    const apiConfig = configManager.getApiConfig();
+    if (!apiConfig?.endpoint) {
+      throw new Error("API endpoint not configured. Please run 'buildx config setup' first.");
+    }
+    config.baseURL = apiConfig.endpoint;
+    try {
+      const response = await this.client.request(config);
+      return {
+        data: response.data,
+        status: response.status,
+        message: response.statusText
+      };
+    } catch (error: any) {
+      if (error.response) {
+        throw new Error(`API Error: ${error.response.status} - ${error.response.data?.message || error.response.statusText}`);
+      } else if (error.request) {
+        throw new Error("Network error: Unable to connect to the API");
+      } else {
+        throw new Error(`Request error: ${error.message}`);
+      }
+    }
+  }
+
+  async login(credentials: LoginCredentials): Promise<LoginResponse> {
+    const response = await this.request<LoginResponse>({
+      method: "POST",
+      url: "/auth/login",
+      data: credentials
+    });
+    return response.data;
+  }
+
+  async getProjects(): Promise<{ id: string; name: string; apiUrl?: string }[]> {
+    const response = await this.request<{ projects: { id: string; name: string; apiUrl?: string }[] }>({
+      method: "GET",
+      url: "/projects"
+    });
+    return response.data.projects;
+  }
+
+  async getSchema(projectId: string): Promise<string> {
+    const response = await this.request<string>({
+      method: "GET",
+      url: `/project/${projectId}/collections/schema`
+    });
+
+    return response.data;
+  }
+
+  async getMe(): Promise<{ username: string;[key: string]: any }> {
+    const response = await this.request<{ username: string;[key: string]: any }>({
+      method: "GET",
+      url: "/auth/me"
+    });
+    return response.data;
+  }
+
+  setBaseUrl(baseUrl: string): void {
+    this.client.defaults.baseURL = baseUrl;
+  }
+
+  getBaseUrl(): string {
+    return this.client.defaults.baseURL || '';
+  }
+
+  isConfigured(): boolean {
+    return configManager.isApiConfigured();
+  }
+}
+
+// Export singleton instance
+export const apiService = new ApiService();