@9apes/cli 0.1.0

package/src/sourcemap.ts

@@ -0,0 +1,317 @@
+import { Config } from './config.js';
+import { promises as fs } from 'fs';
+import path from 'path';
+import fg from 'fast-glob';
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+import { randomUUID } from 'crypto';
+import pLimit from 'p-limit';
+import { injectDebugIdIntoFile, injectDebugIdIntoMapFile } from './inject.js';
+import { uploadFile, type UploadError } from './upload.js';
+import { createStatusBars } from './status.js';
+
+
+const execFileAsync = promisify(execFile);
+
+/**
+ * Represents a pair of JavaScript file and its corresponding source map file
+ */
+export interface FilePair {
+  jsFile: string;
+  mapFile: string | null;
+}
+
+/**
+ * Validate and resolve a directory path
+ * @param dirPath - Directory path to validate
+ * @returns Resolved absolute path
+ * @throws Error if path doesn't exist, isn't a directory, or lacks permissions
+ */
+export async function validateDirectoryPath(dirPath: string): Promise<string> {
+  // Validate and resolve the directory path
+  const resolvedPath = path.resolve(dirPath);
+  console.log(`🔍 Resolved path: ${resolvedPath}`);
+  
+  // Check if path exists and get stats
+  let stats;
+  try {
+    stats = await fs.stat(resolvedPath);
+  } catch (error) {
+    if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
+      throw new Error(`Directory does not exist: ${resolvedPath}`);
+    }
+    throw error;
+  }
+  
+  // Verify it's a directory
+  if (!stats.isDirectory()) {
+    throw new Error(`Path is not a directory: ${resolvedPath}`);
+  }
+  
+  // Check read and write permissions - Throws an error if the directory is not readable or writable
+  await fs.access(resolvedPath, fs.constants.R_OK | fs.constants.W_OK);
+  
+  console.log(`✅ Directory validated: ${resolvedPath}`);
+  return resolvedPath;
+}
+
+/**
+ * Scan directory for JavaScript files and their corresponding source maps
+ * @param dirPath - Directory path to scan
+ * @returns Tuple containing file pairs with both .js and .js.map files, and JS files without maps
+ */
+export async function scanForJavaScriptFiles(dirPath: string): Promise<FilePair[]> {
+  try {
+    // Find all .js.map files directly
+    const [jsFiles, mapFiles] = await Promise.all([
+      fg('**/*.js', {
+        cwd: dirPath,
+        absolute: true,
+        ignore: ['**/node_modules/**', '**/.git/**', '**/.*/**']
+      }),
+      fg('**/*.js.map', {
+        cwd: dirPath,
+        absolute: true,
+        ignore: ['**/node_modules/**', '**/.git/**', '**/.*/**']
+      })
+    ]);
+    
+    console.log(`🔍 Found ${jsFiles.length} JavaScript files`);
+    
+    // Create a Set for O(1) lookup
+    const mapFileSet = new Set(mapFiles);
+    const results: FilePair[] = [];
+    
+    for (const jsFile of jsFiles) {
+      const mapFile = jsFile + '.map';
+      
+      if (mapFileSet.has(mapFile)) {
+        results.push({ jsFile, mapFile });
+      } else {
+        results.push({ jsFile, mapFile: null });
+        console.warn(`⚠️ ${path.relative(dirPath, jsFile)} has no corresponding .js.map file`);
+      }
+    }
+    
+    console.log(`📊 Total file pairs found: ${results.length}`);
+    return results;
+    
+  } catch (error) {
+    console.error('❌ Error scanning for JavaScript files:', error);
+    throw error;
+  }
+}
+
+/**
+ * Get the current Git commit hash (HEAD)
+ * @param dirPath - Directory path to check for git repository
+ * @returns Git commit hash or undefined if not available
+ */
+export async function getGitCommitHash(dirPath: string): Promise<string | undefined> {
+  try {
+    const { stdout } = await execFileAsync('git', ['rev-parse', 'HEAD'], {
+      cwd: dirPath,
+      encoding: 'utf8',
+      // maxBuffer: 1024 * 1024 // Optional: if you expect large output
+    });
+    
+    const commitHash = stdout.trim();
+    console.log(`📝 Git commit hash: ${commitHash}`);
+    return commitHash;
+  } catch {
+    console.log('ℹ️  No git commit hash available (not a git repository or no commits)');
+    return undefined;
+  }
+}
+
+/**
+ * Generate a unique debug ID using UUID v4
+ * @returns UUID string
+ */
+export function generateDebugId(): string {
+  return randomUUID();
+}
+
+/**
+ * Get the debug ID snippet for the given debug ID
+ * @param debugId - Debug ID to get the snippet for
+ * @returns Debug ID snippet
+ */
+export function getDebugIdSnippet(debugId: string): string {
+  return `;{try{(function(){var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._apesDebugIds=e._apesDebugIds||{},e._apesDebugIds[n]="${debugId}",e._apesDebugIdIdentifier="apes-dbid-${debugId}");})();}catch(e){}};`;
+}
+
+
+
+/**
+ * Inject debug IDs into JavaScript files and their corresponding source maps
+ * @param dirPath - Directory path to process
+ * @param config - Configuration object containing API key
+ * @param projectId - Project ID (required)
+ * @param baseUrl - Base URL for the API
+ * @param releaseVersion - Release version (optional)
+ */
+export async function injectDebugIdsAndUpload(
+  dirPath: string, 
+  config: Config, 
+  projectId: string,
+  baseUrl: string,
+  releaseVersion?: string
+): Promise<void> {
+  try {
+    console.log(`📁 Processing directory: ${dirPath}`);
+    console.log(`🔑 Using API key: ${config.apiKey.substring(0, 8)}...`);
+    console.log(`🔑 Project ID: ${projectId}`);
+    if (releaseVersion) {
+      console.log(`📦 Release version: ${releaseVersion}`);
+    }
+    
+    // Validate and resolve the directory path
+    const resolvedPath = await validateDirectoryPath(dirPath);
+    
+    // Find all JavaScript and source map files, and get git commit hash concurrently
+    const [filePairs, commitHash] = await Promise.all([
+      scanForJavaScriptFiles(resolvedPath),
+      getGitCommitHash(resolvedPath)
+    ]);
+
+    
+    if (filePairs.length === 0) {
+      console.log('ℹ️  No JavaScript files with corresponding source maps found');
+      return;
+    }
+    
+    // Calculate total upload count (JS files + map files)
+    const totalUploadCount = filePairs.reduce((count, pair) => {
+      return count + 1 + (pair.mapFile ? 1 : 0);
+    }, 0);
+    
+    // Create status bars
+    const statusBars = createStatusBars(filePairs.length, totalUploadCount);
+    
+    // Setup concurrency limiters
+    const injectLimiter = pLimit(15);
+    const uploadLimiter = pLimit(10);
+    
+    // Track progress counters
+    let injectCompleted = 0;
+    let injectFailed = 0;
+    let uploadCompleted = 0;
+    let uploadFailed = 0;
+    
+    // Process files with concurrent injection and upload pipeline
+    const uploadPromises: Promise<UploadError[]>[] = [];
+    const allUploadErrors: UploadError[] = [];
+    
+    const injectionPromises = filePairs.map((filePair) => 
+      injectLimiter(async () => {
+        const debugId = generateDebugId();
+        
+        try {
+          // Inject debugId into JavaScript file and source map file concurrently
+          await Promise.all([
+            injectDebugIdIntoFile(filePair.jsFile, getDebugIdSnippet(debugId), debugId),
+            injectDebugIdIntoMapFile(filePair.mapFile, debugId)
+          ]);
+          
+          // Update progress after successful injection
+          injectCompleted++;
+          statusBars.updateInjectProgress(injectCompleted, injectFailed);
+        } catch (error) {
+          // Update progress after failed injection
+          injectFailed++;
+          statusBars.updateInjectProgress(injectCompleted, injectFailed);
+          throw error;
+        }
+        
+        // Immediately queue for upload (don't await here)
+        const uploadPromise = uploadLimiter(async (): Promise<UploadError[]> => {
+          try {
+            const errors = await uploadFile(
+              filePair, 
+              debugId, 
+              config, 
+              projectId,
+              baseUrl,
+              releaseVersion, 
+              commitHash,
+              (success) => {
+                if (success) {
+                  uploadCompleted++;
+                } else {
+                  uploadFailed++;
+                }
+                statusBars.updateUploadProgress(uploadCompleted, uploadFailed);
+              }
+            );
+            return errors;
+          } catch (error) {
+            // Handle unexpected errors - count failed uploads for this file pair
+            const uploadOpsCount = 1 + (filePair.mapFile ? 1 : 0);
+            uploadFailed += uploadOpsCount;
+            statusBars.updateUploadProgress(uploadCompleted, uploadFailed);
+            // Return a structured error for unexpected exceptions
+            return [{
+              fileName: path.basename(filePair.jsFile),
+              errorMessage: error instanceof Error ? error.message : String(error)
+            }];
+          }
+        });
+        
+        uploadPromises.push(uploadPromise);
+      })
+    );
+    
+    try {
+      // Wait for all injections to complete
+      await Promise.all(injectionPromises);
+      
+      // Wait for all uploads to complete and collect errors
+      const uploadResults = await Promise.allSettled(uploadPromises);
+      for (const result of uploadResults) {
+        if (result.status === 'fulfilled') {
+          allUploadErrors.push(...result.value);
+        } else {
+          // Handle case where upload promise itself was rejected
+          allUploadErrors.push({
+            fileName: 'unknown',
+            errorMessage: result.reason instanceof Error ? result.reason.message : String(result.reason)
+          });
+        }
+      }
+      
+      // Stop status bars
+      statusBars.stop();
+      
+      // Print collated errors if any
+      if (allUploadErrors.length > 0) {
+        console.error('\n❌ Server Error Responses:');
+        console.error('═'.repeat(60));
+        for (const error of allUploadErrors) {
+          console.error(`\n📁 File: ${error.fileName}`);
+          if (error.statusCode) {
+            console.error(`   Status Code: ${error.statusCode}`);
+          }
+          if (error.responseData) {
+            console.error(`   Response Data: ${JSON.stringify(error.responseData, null, 2)}`);
+          }
+          console.error(`   Error: ${error.errorMessage}`);
+          console.error('─'.repeat(60));
+        }
+      }
+      
+      if (uploadFailed > 0) {
+        throw new Error(`${uploadFailed} upload${uploadFailed === 1 ? '' : 's'} failed`);
+      } else {
+        console.log('✅ Debug ID injection completed successfully');
+      }
+    } catch (error) {
+      statusBars.stop();
+      throw error;
+    }
+    
+  } catch (error) {
+    console.error('❌ Error during debug ID injection:', error);
+    throw error;
+  }
+}

package/src/status.ts

@@ -0,0 +1,94 @@
+import cliProgress from 'cli-progress';
+
+interface StatusBars {
+  injectBar: cliProgress.SingleBar;
+  uploadBar: cliProgress.SingleBar;
+  updateInjectProgress: (completed: number, failed: number) => void;
+  updateUploadProgress: (completed: number, failed: number) => void;
+  stop: () => void;
+}
+
+/**
+ * Create status bars for inject and upload operations
+ * @param injectTotal - Total number of file pairs to inject
+ * @param uploadTotal - Total number of files to upload
+ * @returns Object with update functions and stop function
+ */
+export function createStatusBars(
+  injectTotal: number,
+  uploadTotal: number
+): StatusBars {
+  // Use MultiBar to display multiple progress bars simultaneously
+  const multiBar = new cliProgress.MultiBar(
+    {
+      clearOnComplete: false,
+      hideCursor: true,
+      format: '{label} [{bar}] {percentage}% | Completed: {completed}/{total} | Failed: {failed}',
+      barCompleteChar: '\u2588',
+      barIncompleteChar: '\u2591',
+    },
+    cliProgress.Presets.shades_classic
+  );
+
+  const injectBar = multiBar.create(injectTotal, 0, {
+    label: 'Inject ',
+    completed: 0,
+    failed: 0,
+    total: injectTotal,
+  });
+
+  const uploadBar = multiBar.create(uploadTotal, 0, {
+    label: 'Upload ',
+    completed: 0,
+    failed: 0,
+    total: uploadTotal,
+  });
+
+  let injectCompleted = 0;
+  let injectFailed = 0;
+  let uploadCompleted = 0;
+  let uploadFailed = 0;
+
+  function updateInjectProgress(completed: number, failed: number): void {
+    injectCompleted = completed;
+    injectFailed = failed;
+    injectBar.update(completed + failed, {
+      completed,
+      failed,
+      total: injectTotal,
+    });
+  }
+
+  function updateUploadProgress(completed: number, failed: number): void {
+    uploadCompleted = completed;
+    uploadFailed = failed;
+    uploadBar.update(completed + failed, {
+      completed,
+      failed,
+      total: uploadTotal,
+    });
+  }
+
+  function stop(): void {
+    injectBar.update(injectTotal, {
+      completed: injectCompleted,
+      failed: injectFailed,
+      total: injectTotal,
+    });
+    uploadBar.update(uploadTotal, {
+      completed: uploadCompleted,
+      failed: uploadFailed,
+      total: uploadTotal,
+    });
+    multiBar.stop();
+  }
+
+  return {
+    injectBar,
+    uploadBar,
+    updateInjectProgress,
+    updateUploadProgress,
+    stop,
+  };
+}
+

package/src/upload.ts

@@ -0,0 +1,190 @@
+import path from 'path';
+import { promises as fs } from 'fs';
+import axios, { AxiosInstance, AxiosError } from 'axios';
+import { Agent } from 'http';
+import FormData from 'form-data';
+import { Config } from './config.js';
+import type { FilePair } from './sourcemap.js';
+
+/**
+ * Structured error information from server responses
+ */
+export interface UploadError {
+  fileName: string;
+  statusCode?: number;
+  responseData?: any;
+  errorMessage: string;
+}
+
+/**
+ * Create axios instance with connection pooling and configurable base URL
+ */
+function createHttpClient(baseUrl: string): AxiosInstance {
+  return axios.create({
+    baseURL: baseUrl,
+    timeout: 30000,
+    httpAgent: new Agent({ 
+      keepAlive: true,
+      maxSockets: 20,
+      maxFreeSockets: 5
+    })
+  });
+}
+
+/**
+ * Upload a single file with retry logic
+ * @param filePath - Path to the file to upload
+ * @param fileName - Name of the file for logging
+ * @param debugId - Debug ID associated with the file
+ * @param config - Configuration object containing API key
+ * @param projectId - Project ID
+ * @param httpClient - Axios instance to use for HTTP requests
+ * @param releaseVersion - Optional release version
+ * @param commitHash - Optional git commit hash
+ * @param maxRetries - Maximum number of retry attempts
+ * @param onProgress - Optional callback called on success or failure
+ * @returns UploadError if all retries failed, undefined on success
+ */
+async function uploadSingleFile(
+  filePath: string,
+  fileName: string,
+  debugId: string,
+  config: Config,
+  projectId: string,
+  httpClient: AxiosInstance,
+  releaseVersion?: string,
+  commitHash?: string,
+  maxRetries: number = 3,
+  onProgress?: (success: boolean) => void
+): Promise<UploadError | undefined> {
+  let lastError: UploadError | null = null;
+  
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    try {
+      // Read file as buffer
+      const fileBuffer = await fs.readFile(filePath);
+      
+      // Create FormData
+      const formData = new FormData();
+      formData.append('file', fileBuffer, fileName);
+      formData.append('project_id', projectId);
+      formData.append('debug_id', debugId);
+      
+      if (releaseVersion) {
+        formData.append('release_version', releaseVersion);
+      }
+      
+      if (commitHash) {
+        formData.append('commit_hash', commitHash);
+      }
+      
+      // Make the request
+      await httpClient.post('/sourcemaps/upload', formData, {
+        headers: {
+          ...formData.getHeaders(),
+          'X-API-Key': config.apiKey
+        }
+      });
+      
+      onProgress?.(true);
+      return undefined; // Success, exit retry loop
+      
+    } catch (error) {
+      // Extract structured error information from axios error
+      if (axios.isAxiosError(error)) {
+        const axiosError = error as AxiosError;
+        lastError = {
+          fileName,
+          statusCode: axiosError.response?.status,
+          responseData: axiosError.response?.data,
+          errorMessage: axiosError.message
+        };
+      } else {
+        lastError = {
+          fileName,
+          errorMessage: error instanceof Error ? error.message : String(error)
+        };
+      }
+      
+      if (attempt < maxRetries) {
+        // Wait a bit before retrying (simple delay, no exponential backoff as requested)
+        await new Promise(resolve => setTimeout(resolve, 1000));
+      }
+    }
+  }
+  
+  // If we get here, all retries failed
+  onProgress?.(false);
+  return lastError!;
+}
+
+/**
+ * Upload file via HTTP
+ * @param filePair - File pair containing JavaScript file and optional source map file
+ * @param debugId - Debug ID associated with the files
+ * @param config - Configuration object containing API key
+ * @param projectId - Project ID
+ * @param baseUrl - Base URL for the API
+ * @param releaseVersion - Optional release version
+ * @param commitHash - Optional git commit hash
+ * @param onProgress - Optional callback called on success or failure for each file
+ * @returns Array of UploadError objects for failed uploads
+ */
+export async function uploadFile(
+  filePair: FilePair,
+  debugId: string,
+  config: Config,
+  projectId: string,
+  baseUrl: string,
+  releaseVersion?: string,
+  commitHash?: string,
+  onProgress?: (success: boolean) => void
+): Promise<UploadError[]> {
+  const httpClient = createHttpClient(baseUrl);
+  const uploadPromises: Promise<UploadError | undefined>[] = [];
+  const errors: UploadError[] = [];
+  
+  // Upload JS file
+  uploadPromises.push(
+    uploadSingleFile(
+      filePair.jsFile,
+      path.basename(filePair.jsFile),
+      debugId,
+      config,
+      projectId,
+      httpClient,
+      releaseVersion,
+      commitHash,
+      3,
+      onProgress
+    )
+  );
+  
+  // Upload map file if it exists
+  if (filePair.mapFile) {
+    uploadPromises.push(
+      uploadSingleFile(
+        filePair.mapFile,
+        path.basename(filePair.mapFile),
+        debugId,
+        config,
+        projectId,
+        httpClient,
+        releaseVersion,
+        commitHash,
+        3,
+        onProgress
+      )
+    );
+  }
+  
+  // Wait for both uploads to complete and collect errors
+  const results = await Promise.allSettled(uploadPromises);
+  for (const result of results) {
+    if (result.status === 'fulfilled' && result.value !== undefined) {
+      errors.push(result.value);
+    }
+  }
+  
+  return errors;
+}