@keplog/cli 0.2.0

package/src/commands/list.ts

@@ -0,0 +1,124 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { ConfigManager } from '../lib/config.js';
+
+interface SourceMap {
+  Filename: string;
+  Size: number;
+  UploadedAt: string;
+}
+
+interface ListResponse {
+  source_maps: SourceMap[];
+  release: string;
+  count: number;
+}
+
+export const listCommand = new Command('list')
+  .description('List uploaded source maps for a specific release')
+  .option('-r, --release <version>', 'Release version to list source maps for')
+  .option('-p, --project-id <id>', 'Project ID (overrides config)')
+  .option('-k, --api-key <key>', 'API key (overrides config)')
+  .option('-u, --api-url <url>', 'API URL (overrides config)')
+  .action(async (options) => {
+    try {
+      // Read config from file (priority: local > global > env)
+      const config = ConfigManager.getConfig();
+
+      const release = options.release || process.env.KEPLOG_RELEASE;
+      const projectId = options.projectId || config.projectId;
+      const apiKey = options.apiKey || config.apiKey;
+      const apiUrl = options.apiUrl || config.apiUrl || 'https://api.keplog.com';
+
+      // Validate required parameters
+      if (!projectId) {
+        console.error(chalk.red('\n✗ Error: Project ID is required\n'));
+        console.log('Options:');
+        console.log('  1. Run: keplog init (recommended)');
+        console.log('  2. Use flag: --project-id=<your-project-id>');
+        console.log('  3. Set env: KEPLOG_PROJECT_ID=<your-project-id>\n');
+        process.exit(1);
+      }
+
+      if (!apiKey) {
+        console.error(chalk.red('\n✗ Error: API key is required\n'));
+        console.log('Options:');
+        console.log('  1. Run: keplog init (recommended)');
+        console.log('  2. Use flag: --api-key=<your-api-key>');
+        console.log('  3. Set env: KEPLOG_API_KEY=<your-api-key>\n');
+        process.exit(1);
+      }
+
+      if (!release) {
+        console.error(chalk.red('\n✗ Error: Release version is required\n'));
+        console.log('Options:');
+        console.log('  1. Use flag: --release=v1.0.0');
+        console.log('  2. Set env: KEPLOG_RELEASE=v1.0.0\n');
+        process.exit(1);
+      }
+
+      console.log(chalk.bold.cyan('\n📁 Keplog Source Maps - List\n'));
+      console.log(`Release: ${chalk.green(release)}`);
+      console.log(`Project ID: ${chalk.gray(projectId)}`);
+      console.log(`API URL: ${chalk.gray(apiUrl)}\n`);
+
+      const spinner = ora('Fetching source maps...').start();
+
+      // Fetch source maps from API
+      const url = `${apiUrl}/api/v1/cli/projects/${projectId}/sourcemaps?release=${encodeURIComponent(release)}`;
+      const response = await fetch(url, {
+        method: 'GET',
+        headers: {
+          'X-API-Key': apiKey,
+        },
+      });
+
+      if (!response.ok) {
+        const error = await response.json() as any;
+        spinner.fail(chalk.red('Failed to fetch source maps'));
+        console.error(chalk.red(`\n✗ Error: ${error.error || 'Unknown error'}\n`));
+        process.exit(1);
+      }
+
+      const data = await response.json() as ListResponse;
+      spinner.succeed(chalk.green('Source maps fetched'));
+
+      // Display results
+      console.log(chalk.bold(`\n📦 Source Maps for ${chalk.cyan(data.release)}`));
+      console.log(chalk.gray(`Found ${data.count} file${data.count !== 1 ? 's' : ''}\n`));
+
+      if (data.count === 0) {
+        console.log(chalk.yellow('No source maps found for this release.\n'));
+        console.log(chalk.gray('Upload source maps using: keplog upload --release=' + release + '\n'));
+        return;
+      }
+
+      // Calculate total size
+      let totalSize = 0;
+      for (const file of data.source_maps) {
+        totalSize += file.Size;
+      }
+
+      // Display files
+      for (const file of data.source_maps) {
+        const size = formatFileSize(file.Size);
+        const date = new Date(file.UploadedAt).toLocaleString();
+        console.log(`${chalk.green('✓')} ${chalk.white(file.Filename.padEnd(40))} ${chalk.gray(size.padEnd(12))} ${chalk.dim(date)}`);
+      }
+
+      console.log(chalk.gray(`\nTotal: ${data.count} files (${formatFileSize(totalSize)})\n`));
+
+    } catch (error: any) {
+      console.error(chalk.red(`\n✗ Error: ${error.message}\n`));
+      process.exit(1);
+    }
+  });
+
+function formatFileSize(bytes: number): string {
+  if (bytes === 0) return '0 B';
+  const k = 1024;
+  const sizes = ['B', 'KB', 'MB', 'GB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${(bytes / Math.pow(k, i)).toFixed(2)} ${sizes[i]}`;
+}

package/src/commands/releases.ts

@@ -0,0 +1,122 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { ConfigManager } from '../lib/config.js';
+
+interface ReleaseInfo {
+  Release: string;
+  FileCount: number;
+  TotalSize: number;
+  LastModified: string;
+}
+
+interface ReleasesResponse {
+  releases: ReleaseInfo[];
+  count: number;
+}
+
+export const releasesCommand = new Command('releases')
+  .description('List all releases with uploaded source maps')
+  .option('-p, --project-id <id>', 'Project ID (overrides config)')
+  .option('-k, --api-key <key>', 'API key (overrides config)')
+  .option('-u, --api-url <url>', 'API URL (overrides config)')
+  .action(async (options) => {
+    try {
+      // Read config from file (priority: local > global > env)
+      const config = ConfigManager.getConfig();
+
+      const projectId = options.projectId || config.projectId;
+      const apiKey = options.apiKey || config.apiKey;
+      const apiUrl = options.apiUrl || config.apiUrl || 'https://api.keplog.com';
+
+      // Validate required parameters
+      if (!projectId) {
+        console.error(chalk.red('\n✗ Error: Project ID is required\n'));
+        console.log('Options:');
+        console.log('  1. Run: keplog init (recommended)');
+        console.log('  2. Use flag: --project-id=<your-project-id>');
+        console.log('  3. Set env: KEPLOG_PROJECT_ID=<your-project-id>\n');
+        process.exit(1);
+      }
+
+      if (!apiKey) {
+        console.error(chalk.red('\n✗ Error: API key is required\n'));
+        console.log('Options:');
+        console.log('  1. Run: keplog init (recommended)');
+        console.log('  2. Use flag: --api-key=<your-api-key>');
+        console.log('  3. Set env: KEPLOG_API_KEY=<your-api-key>\n');
+        process.exit(1);
+      }
+
+      console.log(chalk.bold.cyan('\n📦 Keplog Releases\n'));
+      console.log(`Project ID: ${chalk.gray(projectId)}`);
+      console.log(`API URL: ${chalk.gray(apiUrl)}\n`);
+
+      const spinner = ora('Fetching releases...').start();
+
+      // Fetch releases from API
+      const url = `${apiUrl}/api/v1/cli/projects/${projectId}/sourcemaps/releases`;
+      const response = await fetch(url, {
+        method: 'GET',
+        headers: {
+          'X-API-Key': apiKey,
+        },
+      });
+
+      if (!response.ok) {
+        const error = await response.json() as any;
+        spinner.fail(chalk.red('Failed to fetch releases'));
+        console.error(chalk.red(`\n✗ Error: ${error.error || 'Unknown error'}\n`));
+        process.exit(1);
+      }
+
+      const data = await response.json() as ReleasesResponse;
+      spinner.succeed(chalk.green('Releases fetched'));
+
+      // Display results
+      console.log(chalk.bold(`\n📋 Releases with Source Maps`));
+      console.log(chalk.gray(`Found ${data.count} release${data.count !== 1 ? 's' : ''}\n`));
+
+      if (data.count === 0) {
+        console.log(chalk.yellow('No releases found.\n'));
+        console.log(chalk.gray('Upload source maps using: keplog upload --release=v1.0.0 --files="dist/**/*.map"\n'));
+        return;
+      }
+
+      // Calculate total size across all releases
+      let totalSize = 0;
+      let totalFiles = 0;
+      for (const release of data.releases) {
+        totalSize += release.TotalSize;
+        totalFiles += release.FileCount;
+      }
+
+      // Display releases
+      for (const release of data.releases) {
+        const size = formatFileSize(release.TotalSize);
+        const date = new Date(release.LastModified).toLocaleDateString();
+        const fileText = `${release.FileCount} file${release.FileCount !== 1 ? 's' : ''}`;
+
+        console.log(
+          `${chalk.cyan(release.Release.padEnd(30))} ` +
+          `${chalk.gray(fileText.padEnd(12))} ` +
+          `${chalk.yellow(size.padEnd(12))} ` +
+          `${chalk.dim(date)}`
+        );
+      }
+
+      console.log(chalk.gray(`\nTotal: ${data.count} releases, ${totalFiles} files (${formatFileSize(totalSize)})\n`));
+
+    } catch (error: any) {
+      console.error(chalk.red(`\n✗ Error: ${error.message}\n`));
+      process.exit(1);
+    }
+  });
+
+function formatFileSize(bytes: number): string {
+  if (bytes === 0) return '0 B';
+  const k = 1024;
+  const sizes = ['B', 'KB', 'MB', 'GB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${(bytes / Math.pow(k, i)).toFixed(2)} ${sizes[i]}`;
+}

package/src/commands/upload.ts

@@ -0,0 +1,76 @@
+import { Command } from 'commander';
+import { uploadSourceMaps } from '../lib/uploader';
+import { ConfigManager } from '../lib/config';
+import chalk from 'chalk';
+
+export const uploadCommand = new Command('upload')
+  .description('Upload source maps for a specific release')
+  .option('-r, --release <version>', 'Release version (e.g., v1.0.0)')
+  .option('-f, --files <patterns...>', 'Source map file patterns (supports glob)')
+  .option('-p, --project-id <id>', 'Project ID (overrides config)')
+  .option('-k, --api-key <key>', 'API Key (overrides config)')
+  .option('-u, --api-url <url>', 'API URL (overrides config)')
+  .option('-v, --verbose', 'Verbose output')
+  .action(async (options) => {
+    try {
+      // Read config from file (priority: local > global > env)
+      const config = ConfigManager.getConfig();
+
+      // Validate required options
+      const release = options.release;
+      const files = options.files || [];
+      const projectId = options.projectId || config.projectId;
+      const apiKey = options.apiKey || config.apiKey;
+      const apiUrl = options.apiUrl || config.apiUrl || 'https://api.keplog.com';
+      const verbose = options.verbose || false;
+
+      if (!release) {
+        console.error(chalk.red('❌ Error: --release is required'));
+        console.log(chalk.gray('\nExample:'));
+        console.log(chalk.gray('  keplog upload --release=v1.0.0 --files="dist/**/*.map"'));
+        process.exit(1);
+      }
+
+      if (!files || files.length === 0) {
+        console.error(chalk.red('❌ Error: --files is required'));
+        console.log(chalk.gray('\nExample:'));
+        console.log(chalk.gray('  keplog upload --release=v1.0.0 --files="dist/**/*.map"'));
+        process.exit(1);
+      }
+
+      if (!projectId) {
+        console.error(chalk.red('❌ Error: Project ID is required'));
+        console.log(chalk.gray('\nOptions:'));
+        console.log(chalk.gray('  1. Run: keplog init (recommended)'));
+        console.log(chalk.gray('  2. Use flag: --project-id=<your-project-id>'));
+        console.log(chalk.gray('  3. Set env: KEPLOG_PROJECT_ID=<your-project-id>'));
+        process.exit(1);
+      }
+
+      if (!apiKey) {
+        console.error(chalk.red('❌ Error: API Key is required'));
+        console.log(chalk.gray('\nOptions:'));
+        console.log(chalk.gray('  1. Run: keplog init (recommended)'));
+        console.log(chalk.gray('  2. Use flag: --api-key=<your-api-key>'));
+        console.log(chalk.gray('  3. Set env: KEPLOG_API_KEY=<your-api-key>'));
+        process.exit(1);
+      }
+
+      // Upload source maps
+      await uploadSourceMaps({
+        release,
+        filePatterns: files,
+        projectId,
+        apiKey,
+        apiUrl,
+        verbose,
+      });
+
+    } catch (error: any) {
+      console.error(chalk.red(`\n❌ Error: ${error.message}`));
+      if (error.stack && process.env.DEBUG) {
+        console.error(chalk.gray(error.stack));
+      }
+      process.exit(1);
+    }
+  });

package/src/index.ts

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { initCommand } from './commands/init.js';
+import { uploadCommand } from './commands/upload.js';
+import { listCommand } from './commands/list.js';
+import { deleteCommand } from './commands/delete.js';
+import { releasesCommand } from './commands/releases.js';
+import { issuesCommand } from './commands/issues.js';
+import { config } from 'dotenv';
+
+// Load environment variables from .env file
+config();
+
+const program = new Command();
+
+program
+  .name('keplog')
+  .description('Official Keplog CLI for error tracking and source map management')
+  .version('1.0.0');
+
+// Add commands
+program.addCommand(initCommand);
+program.addCommand(uploadCommand);
+program.addCommand(listCommand);
+program.addCommand(deleteCommand);
+program.addCommand(releasesCommand);
+program.addCommand(issuesCommand);
+
+// Parse command line arguments
+program.parse(process.argv);

package/src/lib/config.ts

@@ -0,0 +1,138 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { homedir } from 'os';
+
+export interface KeplogConfig {
+  projectId?: string;
+  apiKey?: string;
+  apiUrl?: string;
+  projectName?: string;
+}
+
+const CONFIG_FILENAME = '.keplog.json';
+const GLOBAL_CONFIG_PATH = path.join(homedir(), '.keplogrc');
+
+/**
+ * Config Manager for Keplog CLI
+ *
+ * Priority order:
+ * 1. Local .keplog.json (project-specific)
+ * 2. Global ~/.keplogrc (user-level)
+ * 3. Environment variables (KEPLOG_PROJECT_ID, KEPLOG_API_KEY)
+ */
+export class ConfigManager {
+  /**
+   * Find the nearest .keplog.json file by walking up the directory tree
+   */
+  private static findLocalConfigPath(startDir: string = process.cwd()): string | null {
+    let currentDir = startDir;
+    const root = path.parse(currentDir).root;
+
+    while (currentDir !== root) {
+      const configPath = path.join(currentDir, CONFIG_FILENAME);
+      if (fs.existsSync(configPath)) {
+        return configPath;
+      }
+      currentDir = path.dirname(currentDir);
+    }
+
+    return null;
+  }
+
+  /**
+   * Read configuration from local or global config file
+   */
+  static readConfig(): KeplogConfig {
+    // Try local config first
+    const localConfigPath = this.findLocalConfigPath();
+    if (localConfigPath) {
+      try {
+        const content = fs.readFileSync(localConfigPath, 'utf-8');
+        return JSON.parse(content);
+      } catch (error) {
+        console.warn(`Warning: Failed to read config from ${localConfigPath}`);
+      }
+    }
+
+    // Try global config
+    if (fs.existsSync(GLOBAL_CONFIG_PATH)) {
+      try {
+        const content = fs.readFileSync(GLOBAL_CONFIG_PATH, 'utf-8');
+        return JSON.parse(content);
+      } catch (error) {
+        console.warn(`Warning: Failed to read global config from ${GLOBAL_CONFIG_PATH}`);
+      }
+    }
+
+    return {};
+  }
+
+  /**
+   * Write configuration to local .keplog.json file
+   */
+  static writeLocalConfig(config: KeplogConfig, dir: string = process.cwd()): void {
+    const configPath = path.join(dir, CONFIG_FILENAME);
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8');
+  }
+
+  /**
+   * Write configuration to global ~/.keplogrc file
+   */
+  static writeGlobalConfig(config: KeplogConfig): void {
+    fs.writeFileSync(GLOBAL_CONFIG_PATH, JSON.stringify(config, null, 2), 'utf-8');
+  }
+
+  /**
+   * Get configuration with priority: local > global > env vars
+   */
+  static getConfig(): KeplogConfig {
+    const fileConfig = this.readConfig();
+
+    return {
+      projectId: fileConfig.projectId || process.env.KEPLOG_PROJECT_ID,
+      apiKey: fileConfig.apiKey || process.env.KEPLOG_API_KEY,
+      apiUrl: fileConfig.apiUrl || process.env.KEPLOG_API_URL || 'https://api.keplog.com',
+      projectName: fileConfig.projectName,
+    };
+  }
+
+  /**
+   * Check if local config exists in current directory or parent directories
+   */
+  static hasLocalConfig(): boolean {
+    return this.findLocalConfigPath() !== null;
+  }
+
+  /**
+   * Check if global config exists
+   */
+  static hasGlobalConfig(): boolean {
+    return fs.existsSync(GLOBAL_CONFIG_PATH);
+  }
+
+  /**
+   * Get the path of the local config file (if it exists)
+   */
+  static getLocalConfigPath(): string | null {
+    return this.findLocalConfigPath();
+  }
+
+  /**
+   * Delete local config
+   */
+  static deleteLocalConfig(dir: string = process.cwd()): void {
+    const configPath = path.join(dir, CONFIG_FILENAME);
+    if (fs.existsSync(configPath)) {
+      fs.unlinkSync(configPath);
+    }
+  }
+
+  /**
+   * Delete global config
+   */
+  static deleteGlobalConfig(): void {
+    if (fs.existsSync(GLOBAL_CONFIG_PATH)) {
+      fs.unlinkSync(GLOBAL_CONFIG_PATH);
+    }
+  }
+}

package/src/lib/uploader.ts

@@ -0,0 +1,168 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { glob } from 'glob';
+import FormData from 'form-data';
+import axios from 'axios';
+import chalk from 'chalk';
+import ora from 'ora';
+
+interface UploadOptions {
+  release: string;
+  filePatterns: string[];
+  projectId: string;
+  apiKey: string;
+  apiUrl: string;
+  verbose: boolean;
+}
+
+interface UploadResponse {
+  uploaded: string[];
+  errors: string[];
+  release: string;
+  count: number;
+  error?: string;
+}
+
+export async function uploadSourceMaps(options: UploadOptions): Promise<void> {
+  const { release, filePatterns, projectId, apiKey, apiUrl, verbose } = options;
+
+  console.log(chalk.bold.cyan('\n📦 Keplog Source Map Uploader\n'));
+  console.log(chalk.gray(`Release: ${release}`));
+  console.log(chalk.gray(`Project ID: ${projectId}`));
+  console.log(chalk.gray(`API URL: ${apiUrl}\n`));
+
+  // Find all matching files
+  const spinner = ora('Finding source map files...').start();
+  const allFiles: string[] = [];
+
+  for (const pattern of filePatterns) {
+    try {
+      const matches = await glob(pattern, { nodir: true });
+      if (verbose) {
+        spinner.info(`Pattern "${pattern}" matched ${matches.length} file(s)`);
+      }
+      allFiles.push(...matches);
+    } catch (error: any) {
+      spinner.fail(`Invalid glob pattern: ${pattern}`);
+      throw error;
+    }
+  }
+
+  // Remove duplicates
+  const uniqueFiles = [...new Set(allFiles)];
+
+  if (uniqueFiles.length === 0) {
+    spinner.fail('No source map files found');
+    console.log(chalk.yellow('\n⚠️  No files matched the specified patterns'));
+    console.log(chalk.gray('\nTip: Make sure your patterns are correct:'));
+    console.log(chalk.gray('  --files="dist/**/*.map"'));
+    console.log(chalk.gray('  --files="build/*.map"'));
+    process.exit(1);
+  }
+
+  spinner.succeed(`Found ${uniqueFiles.length} source map file(s)`);
+
+  // Filter only .map files
+  const mapFiles = uniqueFiles.filter(file => file.endsWith('.map'));
+
+  if (mapFiles.length === 0) {
+    console.log(chalk.yellow('\n⚠️  No .map files found'));
+    process.exit(1);
+  }
+
+  if (mapFiles.length !== uniqueFiles.length) {
+    console.log(chalk.yellow(`\n⚠️  Skipped ${uniqueFiles.length - mapFiles.length} non-.map file(s)`));
+  }
+
+  // Display files to upload
+  if (verbose) {
+    console.log(chalk.cyan('\n📁 Files to upload:'));
+    mapFiles.forEach((file, index) => {
+      const stats = fs.statSync(file);
+      const size = formatFileSize(stats.size);
+      console.log(chalk.gray(`  ${index + 1}. ${file} (${size})`));
+    });
+    console.log();
+  }
+
+  // Create form data
+  const uploadSpinner = ora(`Uploading ${mapFiles.length} file(s) to Keplog...`).start();
+
+  try {
+    const formData = new FormData();
+    formData.append('release', release);
+
+    // Add all files
+    for (const filePath of mapFiles) {
+      const fileName = path.basename(filePath);
+      const fileStream = fs.createReadStream(filePath);
+      formData.append('files', fileStream, fileName);
+    }
+
+    // Upload to API
+    const url = `${apiUrl}/api/v1/cli/projects/${projectId}/sourcemaps`;
+
+    const response = await axios.post(url, formData, {
+      headers: {
+        'X-API-Key': apiKey,
+        ...formData.getHeaders(),
+      },
+      maxContentLength: Infinity,
+      maxBodyLength: Infinity,
+    });
+
+    const data = response.data as UploadResponse;
+
+    uploadSpinner.succeed('Upload complete!');
+
+    // Display results
+    console.log(chalk.bold.green('\n✅ Upload Complete!\n'));
+    console.log(chalk.gray(`Release: ${data.release}`));
+    console.log(chalk.gray(`Uploaded: ${data.count} file(s)\n`));
+
+    if (data.uploaded && data.uploaded.length > 0) {
+      console.log(chalk.cyan('📁 Successfully uploaded:'));
+      data.uploaded.forEach(filename => {
+        console.log(chalk.green(`   ✓ ${filename}`));
+      });
+    }
+
+    if (data.errors && data.errors.length > 0) {
+      console.log(chalk.yellow('\n⚠️  Errors:'));
+      data.errors.forEach(error => {
+        console.log(chalk.red(`   ✗ ${error}`));
+      });
+      process.exit(1);
+    }
+
+    console.log(chalk.cyan(`\n💡 Source maps will be used automatically when processing errors for release ${data.release}\n`));
+
+  } catch (error: any) {
+    uploadSpinner.fail('Upload failed');
+
+    if (axios.isAxiosError(error)) {
+      if (error.code === 'ENOTFOUND') {
+        throw new Error(`Could not connect to ${apiUrl}. Please check your internet connection.`);
+      } else if (error.code === 'ECONNREFUSED') {
+        throw new Error(`Connection refused to ${apiUrl}. Please check the API URL.`);
+      } else if (error.response) {
+        // Server responded with error
+        const data = error.response.data;
+        throw new Error(data.error || `HTTP ${error.response.status}: ${error.response.statusText}`);
+      } else if (error.request) {
+        // Request made but no response
+        throw new Error(`No response from server. Please check your internet connection.`);
+      }
+    }
+
+    throw error;
+  }
+}
+
+function formatFileSize(bytes: number): string {
+  if (bytes === 0) return '0 B';
+  const k = 1024;
+  const sizes = ['B', 'KB', 'MB', 'GB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${(bytes / Math.pow(k, i)).toFixed(2)} ${sizes[i]}`;
+}