@orcapt/cli 1.0.0

package/src/commands/ui.js

@@ -0,0 +1,286 @@
+/**
+ * Orca UI Commands
+ * Manage Orca UI installation and execution
+ */
+
+const chalk = require('chalk');
+const ora = require('ora');
+const spawn = require('cross-spawn');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { ensurePortAvailable } = require('../utils');
+
+// Track UI installation status
+const UI_CONFIG_FILE = path.join(os.homedir(), '.orca', 'ui-config.json');
+
+/**
+ * Check if npx is available (we'll use npx instead of global install to avoid conflicts)
+ */
+function isNpxAvailable() {
+  try {
+    const result = spawn.sync('npx', ['--version'], {
+      encoding: 'utf8',
+      stdio: 'pipe'
+    });
+    
+    return result.status === 0;
+  } catch (error) {
+    return false;
+  }
+}
+
+/**
+ * Check if UI package is cached locally
+ */
+function isUICached() {
+  try {
+    const result = spawn.sync('npm', ['list', '@orcapt/ui', '--depth=0'], {
+      encoding: 'utf8',
+      stdio: 'pipe',
+      cwd: os.homedir()
+    });
+    
+    return result.stdout.includes('@orcapt/ui');
+  } catch (error) {
+    return false;
+  }
+}
+
+/**
+ * Save UI installation status
+ */
+function saveUIConfig(installed = true) {
+  try {
+    const configDir = path.dirname(UI_CONFIG_FILE);
+    if (!fs.existsSync(configDir)) {
+      fs.mkdirSync(configDir, { recursive: true });
+    }
+
+    const config = {
+      installed,
+      timestamp: new Date().toISOString(),
+      version: installed ? 'latest' : null
+    };
+
+    fs.writeFileSync(UI_CONFIG_FILE, JSON.stringify(config, null, 2));
+    return true;
+  } catch (error) {
+    console.error(chalk.red('Failed to save UI config:', error.message));
+    return false;
+  }
+}
+
+/**
+ * Check if UI is installed globally
+ */
+function isUIInstalled() {
+  try {
+    const result = spawn.sync('npm', ['list', '-g', '@orcapt/ui', '--depth=0'], {
+      encoding: 'utf8',
+      stdio: 'pipe'
+    });
+    
+    return result.status === 0 && result.stdout.includes('@orcapt/ui');
+  } catch (error) {
+    return false;
+  }
+}
+
+/**
+ * UI Init Command - Install Orca UI globally
+ */
+async function uiInit() {
+  console.log(chalk.cyan('\n============================================================'));
+  console.log(chalk.cyan('📦 Orca UI - Global Installation'));
+  console.log(chalk.cyan('============================================================\n'));
+
+  // Check if already installed
+  if (isUIInstalled()) {
+    console.log(chalk.yellow('⚠ Orca UI is already installed globally'));
+    console.log(chalk.cyan('\nTo reinstall, run:'), chalk.white('orca ui remove'), chalk.cyan('first\n'));
+    return;
+  }
+
+  const spinner = ora('Installing @orcapt/ui globally...').start();
+
+  try {
+    const result = spawn.sync('npm', ['install', '-g', '@orcapt/ui'], {
+      encoding: 'utf8',
+      stdio: 'inherit'
+    });
+
+    if (result.status === 0) {
+      spinner.succeed(chalk.green('Orca UI installed successfully!'));
+      saveUIConfig(true);
+      
+      console.log(chalk.cyan('\n============================================================'));
+      console.log(chalk.green('✓ Installation Complete'));
+      console.log(chalk.cyan('============================================================'));
+      console.log(chalk.white('\n📦 Package:'), chalk.yellow('@orcapt/ui'));
+      console.log(chalk.white('📁 Type:'), chalk.white('React component library with built UI'));
+      console.log(chalk.white('\nYou can now run:'));
+      console.log(chalk.yellow('  • orca ui start --port 3000 --agent-port 5001'));
+      console.log(chalk.cyan('============================================================\n'));
+    } else {
+      spinner.fail(chalk.red('Installation failed'));
+      console.log(chalk.red('\n✗ Failed to install @orcapt/ui'));
+      console.log(chalk.yellow('\nTry running manually:'), chalk.white('npm install -g @orcapt/ui\n'));
+      process.exit(1);
+    }
+  } catch (error) {
+    spinner.fail(chalk.red('Installation error'));
+    console.log(chalk.red(`Error: ${error.message}\n`));
+    process.exit(1);
+  }
+}
+
+/**
+ * UI Start Command - Run the Orca UI
+ */
+async function uiStart(options) {
+  const port = options.port || '3000';
+  const agentPort = options.agentPort || '5001';
+
+  console.log(chalk.cyan('\n============================================================'));
+  console.log(chalk.cyan('🚀 Starting Orca UI'));
+  console.log(chalk.cyan('============================================================\n'));
+
+  const isInstalled = isUIInstalled();
+  
+  if (!isInstalled && !isNpxAvailable()) {
+    console.log(chalk.red('✗ Orca UI is not installed and npx is not available'));
+    console.log(chalk.yellow('\nPlease run:'), chalk.white('orca ui init'), chalk.yellow('to install\n'));
+    process.exit(1);
+  }
+
+  console.log(chalk.white('Frontend:'), chalk.yellow(`http://localhost:${port}`));
+  console.log(chalk.white('Backend: '), chalk.yellow(`http://localhost:${agentPort}`));
+  console.log(chalk.green('\n✓ Serving @orcapt/ui from global installation'));
+  console.log(chalk.gray(`   Configure your agent endpoint in the UI settings`));
+  
+  console.log(chalk.cyan('\n⚠ Press Ctrl+C to stop the UI\n'));
+  console.log(chalk.cyan('============================================================\n'));
+
+  try {
+    // Ensure port is available before starting
+    await ensurePortAvailable(parseInt(port), 'UI');
+    
+    let uiProcess;
+    
+    // Find the path to the installed @orcapt/ui package
+    let uiDistPath;
+    
+    if (isInstalled) {
+      // Get the global node_modules path
+      const result = spawn.sync('npm', ['root', '-g'], {
+        encoding: 'utf8',
+        stdio: 'pipe'
+      });
+      
+      if (result.status === 0) {
+        const globalModulesPath = result.stdout.trim();
+        uiDistPath = path.join(globalModulesPath, '@orca', 'ui', 'dist');
+        
+        if (!fs.existsSync(uiDistPath)) {
+          console.log(chalk.red(`\n✗ @orcapt/ui is installed but dist folder not found at: ${uiDistPath}`));
+          console.log(chalk.yellow('\nTry reinstalling:'), chalk.white('orca ui remove && orca ui init\n'));
+          process.exit(1);
+        }
+      }
+    }
+    
+    if (!uiDistPath) {
+      console.log(chalk.red('\n✗ Could not find @orcapt/ui installation'));
+      console.log(chalk.yellow('\nPlease run:'), chalk.white('orca ui init\n'));
+      process.exit(1);
+    }
+    
+    console.log(chalk.gray(`Serving UI from: ${uiDistPath}\n`));
+    
+    // Serve the dist folder using http-server
+    uiProcess = spawn(
+      'npx',
+      ['-y', 'http-server', uiDistPath, '-p', port, '--cors', '-o'],
+      {
+        stdio: 'inherit'
+      }
+    );
+
+    uiProcess.on('error', (error) => {
+      console.log(chalk.red(`\n✗ ${error.message}\n`));
+      process.exit(1);
+    });
+
+    uiProcess.on('exit', (code) => {
+      if (code !== 0 && code !== null) {
+        console.log(chalk.yellow(`\n⚠ UI stopped (exit code ${code})\n`));
+      }
+    });
+
+    // Handle Ctrl+C gracefully
+    process.on('SIGINT', () => {
+      console.log(chalk.cyan('\n\n============================================================'));
+      console.log(chalk.yellow('⚠ Stopping Orca UI...'));
+      console.log(chalk.cyan('============================================================\n'));
+      uiProcess.kill('SIGINT');
+      process.exit(0);
+    });
+
+  } catch (error) {
+    console.log(chalk.red(`\n✗ Error starting UI: ${error.message}\n`));
+    process.exit(1);
+  }
+}
+
+/**
+ * UI Remove Command - Uninstall Orca UI
+ */
+async function uiRemove() {
+  console.log(chalk.cyan('\n============================================================'));
+  console.log(chalk.cyan('🗑️  Removing Orca UI'));
+  console.log(chalk.cyan('============================================================\n'));
+
+  // Check if installed
+  if (!isUIInstalled()) {
+    console.log(chalk.yellow('⚠ Orca UI is not installed globally\n'));
+    return;
+  }
+
+  const spinner = ora('Uninstalling @orcapt/ui...').start();
+
+  try {
+    const result = spawn.sync('npm', ['uninstall', '-g', '@orcapt/ui'], {
+      encoding: 'utf8',
+      stdio: 'inherit'
+    });
+
+    if (result.status === 0) {
+      spinner.succeed(chalk.green('Orca UI removed successfully!'));
+      saveUIConfig(false);
+      
+      console.log(chalk.cyan('\n============================================================'));
+      console.log(chalk.green('✓ Uninstallation Complete'));
+      console.log(chalk.cyan('============================================================'));
+      console.log(chalk.white('\n@orcapt/ui package has been removed.'));
+      console.log(chalk.white('\nTo reinstall, run:'), chalk.yellow('orca ui init'));
+      console.log(chalk.cyan('============================================================\n'));
+    } else {
+      spinner.fail(chalk.red('Uninstallation failed'));
+      console.log(chalk.red('\n✗ Failed to remove @orcapt/ui'));
+      console.log(chalk.yellow('\nTry running manually:'), chalk.white('npm uninstall -g @orcapt/ui\n'));
+      process.exit(1);
+    }
+  } catch (error) {
+    spinner.fail(chalk.red('Uninstallation error'));
+    console.log(chalk.red(`Error: ${error.message}\n`));
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  uiInit,
+  uiStart,
+  uiRemove
+};
+

package/src/config.js

@@ -0,0 +1,62 @@
+/**
+ * Orca CLI Configuration
+ * Centralized configuration for all API endpoints and URLs
+ */
+
+// Main Orca Deploy API
+// Can be overridden with ORCA_API_URL environment variable
+const API_BASE_URL = process.env.ORCA_API_URL  || 'https://deploy-stage-api.orcapt.com' ||'https://deploy-api.orcapt.com';
+
+// API Endpoints
+const API_ENDPOINTS = {
+  // Authentication
+  AUTH: '/api/v1/auth',
+  
+  // Database
+  DB_CREATE: '/api/v1/db/create',
+  DB_LIST: '/api/v1/db/list',
+  DB_DELETE: '/api/v1/db/delete-schema',
+  
+  // Storage
+  STORAGE_BUCKET_CREATE: '/api/v1/storage/bucket/create',
+  STORAGE_BUCKET_LIST: '/api/v1/storage/bucket/list',
+  STORAGE_BUCKET_INFO: '/api/v1/storage/bucket/{bucketName}',
+  STORAGE_BUCKET_DELETE: '/api/v1/storage/bucket/{bucketName}',
+  STORAGE_UPLOAD: '/api/v1/storage/{bucketName}/upload',
+  STORAGE_DOWNLOAD: '/api/v1/storage/{bucketName}/download/{fileKey}',
+  STORAGE_FILE_LIST: '/api/v1/storage/{bucketName}/files',
+  STORAGE_FILE_DELETE: '/api/v1/storage/{bucketName}/file/{fileKey}',
+  STORAGE_PERMISSION_ADD: '/api/v1/storage/{bucketName}/permission/add',
+  STORAGE_PERMISSION_LIST: '/api/v1/storage/{bucketName}/permissions',
+  STORAGE_PERMISSION_DELETE: '/api/v1/storage/permission/{permissionId}',
+  
+  // Lambda
+  LAMBDA_DEPLOY: '/api/v1/lambda/deploy',
+  LAMBDA_LIST: '/api/v1/lambda/list',
+  LAMBDA_INFO: '/api/v1/lambda/{functionName}',
+  LAMBDA_DELETE: '/api/v1/lambda/{functionName}',
+  LAMBDA_INVOKE: '/api/v1/lambda/{functionName}/invoke',
+  LAMBDA_LOGS: '/api/v1/lambda/{functionName}/logs',
+  LAMBDA_START: '/api/v1/lambda',
+  LAMBDA_STOP: '/api/v1/lambda'
+};
+
+// GitHub Repository URLs
+const GITHUB_REPOS = {
+  PYTHON_STARTER: 'https://github.com/Orcapt/orca-starter-kit-python-v1',
+  NODE_STARTER: 'https://github.com/Orcapt/orca-starter-kit-node-v1'
+};
+
+// Documentation URLs
+const DOCS_URLS = {
+  PYTHON: 'https://raw.githubusercontent.com/Orcapt/orca-pip/refs/heads/orca/docs/guides/DEVELOPER_GUIDE.md',
+  NODEJS: 'https://raw.githubusercontent.com/Orcapt/orca-npm/refs/heads/main/QUICKSTART.md'
+};
+
+module.exports = {
+  API_BASE_URL,
+  API_ENDPOINTS,
+  GITHUB_REPOS,
+  DOCS_URLS
+};
+

package/src/utils/docker-helper.js

@@ -0,0 +1,357 @@
+/**
+ * Docker Helper Utilities
+ * Helper functions for Docker operations (check, tag, push)
+ */
+
+const { spawn, exec } = require('child_process');
+const ora = require('ora');
+const chalk = require('chalk');
+
+/**
+ * Check if Docker is installed and running
+ */
+async function checkDockerInstalled() {
+  return new Promise((resolve, reject) => {
+    exec('docker --version', (error, stdout, stderr) => {
+      if (error) {
+        reject(new Error('Docker is not installed or not running'));
+      } else {
+        resolve(true);
+      }
+    });
+  });
+}
+
+/**
+ * Check if Docker image exists locally
+ */
+async function checkDockerImage(imageName) {
+  return new Promise((resolve, reject) => {
+    exec(`docker images -q ${imageName}`, (error, stdout, stderr) => {
+      if (error) {
+        reject(error);
+      } else {
+        resolve(stdout.trim().length > 0);
+      }
+    });
+  });
+}
+
+/**
+ * Get Docker image size
+ */
+async function getImageSize(imageName) {
+  return new Promise((resolve, reject) => {
+    exec(`docker images ${imageName} --format "{{.Size}}"`, (error, stdout, stderr) => {
+      if (error) {
+        reject(error);
+      } else {
+        resolve(stdout.trim());
+      }
+    });
+  });
+}
+
+/**
+ * Login to Docker registry (ECR or Docker Hub) with timeout and retry
+ */
+async function dockerLogin(registry, username, password, retries = 3) {
+  const TIMEOUT_MS = 60000; // 60 seconds timeout
+  
+  for (let attempt = 1; attempt <= retries; attempt++) {
+    try {
+      return await new Promise((resolve, reject) => {
+        const loginProcess = spawn('sh', ['-c', `echo "${password}" | docker login -u ${username} --password-stdin ${registry}`]);
+        
+        let output = '';
+        let errorOutput = '';
+        let timeoutId;
+
+        // Set timeout
+        timeoutId = setTimeout(() => {
+          loginProcess.kill();
+          reject(new Error(`Docker login timed out after ${TIMEOUT_MS / 1000} seconds`));
+        }, TIMEOUT_MS);
+
+        loginProcess.stdout.on('data', (data) => {
+          output += data.toString();
+        });
+
+        loginProcess.stderr.on('data', (data) => {
+          errorOutput += data.toString();
+        });
+
+        loginProcess.on('close', (code) => {
+          clearTimeout(timeoutId);
+          if (code === 0) {
+            resolve(output);
+          } else {
+            reject(new Error(`Docker login failed: ${errorOutput}`));
+          }
+        });
+
+        loginProcess.on('error', (error) => {
+          clearTimeout(timeoutId);
+          reject(error);
+        });
+      });
+    } catch (error) {
+      if (attempt === retries) {
+        throw error;
+      }
+      // Wait before retry (exponential backoff)
+      const waitTime = Math.min(1000 * Math.pow(2, attempt - 1), 5000);
+      await new Promise(resolve => setTimeout(resolve, waitTime));
+    }
+  }
+}
+
+/**
+ * Tag Docker image for registry
+ */
+async function dockerTag(sourceImage, targetImage) {
+  return new Promise((resolve, reject) => {
+    exec(`docker tag ${sourceImage} ${targetImage}`, (error, stdout, stderr) => {
+      if (error) {
+        reject(new Error(`Failed to tag image: ${stderr || error.message}`));
+      } else {
+        resolve(true);
+      }
+    });
+  });
+}
+
+/**
+ * Push Docker image to registry with progress tracking
+ */
+async function dockerPush(imageName, onProgress) {
+  return new Promise((resolve, reject) => {
+    const pushProcess = spawn('docker', ['push', imageName], {
+      stdio: ['ignore', 'pipe', 'pipe']
+    });
+    
+    let layers = {};
+    let totalLayers = 0;
+    let completedLayers = 0;
+    let lastOutput = Date.now();
+    let hasError = false;
+    let errorMessage = '';
+    let initialScanDone = false;
+
+    // Timeout after 10 minutes of no output
+    const timeoutCheck = setInterval(() => {
+      const timeSinceLastOutput = Date.now() - lastOutput;
+      if (timeSinceLastOutput > 600000) { // 10 minutes
+        clearInterval(timeoutCheck);
+        pushProcess.kill();
+        reject(new Error('Push timed out - no output for 10 minutes'));
+      }
+    }, 5000);
+
+    pushProcess.stdout.on('data', (data) => {
+      lastOutput = Date.now();
+      const output = data.toString();
+      const lines = output.split('\n');
+      
+      lines.forEach(line => {
+        // Detect all layers first (from "Preparing" or "Waiting" status)
+        const preparingMatch = line.match(/([a-f0-9]{12}):\s+(Preparing|Waiting|Layer already exists)/);
+        if (preparingMatch && !initialScanDone) {
+          const layerId = preparingMatch[1];
+          if (!layers[layerId]) {
+            layers[layerId] = { total: 0, current: 0, completed: false, status: 'preparing' };
+            totalLayers++;
+          }
+        }
+        
+        // Layer pushing with progress: "abc123: Pushing [==>  ] 10MB/50MB"
+        const pushingMatch = line.match(/([a-f0-9]{12}):\s+Pushing\s+\[([=>\s]+)\]\s+([\d.]+)([KMG]B)\/([\d.]+)([KMG]B)/);
+        if (pushingMatch) {
+          const layerId = pushingMatch[1];
+          const currentSize = parseFloat(pushingMatch[3]);
+          const currentUnit = pushingMatch[4];
+          const totalSize = parseFloat(pushingMatch[5]);
+          const totalUnit = pushingMatch[6];
+          
+          // Convert to bytes for accurate calculation
+          const currentBytes = convertToBytes(currentSize, currentUnit);
+          const totalBytes = convertToBytes(totalSize, totalUnit);
+          
+          if (!layers[layerId]) {
+            layers[layerId] = { total: totalBytes, current: currentBytes, completed: false, status: 'pushing' };
+            totalLayers++;
+          } else {
+            layers[layerId].total = totalBytes;
+            layers[layerId].current = currentBytes;
+            layers[layerId].status = 'pushing';
+          }
+        }
+        
+        // Layer completed: "abc123: Pushed"
+        const pushedMatch = line.match(/([a-f0-9]{12}):\s+(Pushed|Layer already exists)/);
+        if (pushedMatch) {
+          const layerId = pushedMatch[1];
+          const isAlreadyExists = pushedMatch[2] === 'Layer already exists';
+          
+          if (!layers[layerId]) {
+            layers[layerId] = { total: 0, current: 0, completed: true, status: 'complete' };
+            totalLayers++;
+            completedLayers++;
+          } else if (!layers[layerId].completed) {
+            layers[layerId].completed = true;
+            layers[layerId].status = 'complete';
+            // If it was pushing, mark as fully uploaded
+            if (layers[layerId].total > 0) {
+              layers[layerId].current = layers[layerId].total;
+            }
+            completedLayers++;
+          }
+        }
+        
+        // Calculate overall progress
+        if (totalLayers > 0 && onProgress) {
+          let totalBytes = 0;
+          let uploadedBytes = 0;
+          let layersWithSize = 0;
+          
+          Object.values(layers).forEach(layer => {
+            if (layer.total > 0) {
+              totalBytes += layer.total;
+              uploadedBytes += layer.current || 0;
+              layersWithSize++;
+            }
+          });
+          
+          let overallPercent = 0;
+          
+          if (totalBytes > 0) {
+            // محاسبه بر اساس bytes واقعی
+            overallPercent = Math.round((uploadedBytes / totalBytes) * 100);
+          } else if (totalLayers > 0) {
+            // اگر هنوز size نداریم، بر اساس تعداد layer های complete شده
+            overallPercent = Math.round((completedLayers / totalLayers) * 100);
+          }
+          
+          onProgress(overallPercent, completedLayers, totalLayers);
+        }
+      });
+    });
+
+    pushProcess.stderr.on('data', (data) => {
+      lastOutput = Date.now();
+      const output = data.toString();
+      
+      // Check for errors
+      if (output.toLowerCase().includes('error') || 
+          output.toLowerCase().includes('denied') ||
+          output.toLowerCase().includes('unauthorized')) {
+        hasError = true;
+        errorMessage += output;
+      }
+    });
+
+    pushProcess.on('close', (code) => {
+      clearInterval(timeoutCheck);
+      
+      if (code === 0) {
+        // آخرین بار progress را 100% کن
+        if (onProgress && totalLayers > 0) {
+          onProgress(100, totalLayers, totalLayers);
+        }
+        resolve(true);
+      } else {
+        const error = hasError && errorMessage 
+          ? `Push failed: ${errorMessage}` 
+          : 'Failed to push image to registry';
+        reject(new Error(error));
+      }
+    });
+
+    pushProcess.on('error', (error) => {
+      clearInterval(timeoutCheck);
+      reject(error);
+    });
+  });
+}
+
+/**
+ * Convert size with unit to bytes
+ */
+function convertToBytes(size, unit) {
+  const units = {
+    'B': 1,
+    'KB': 1024,
+    'MB': 1024 * 1024,
+    'GB': 1024 * 1024 * 1024
+  };
+  return size * (units[unit] || 1);
+}
+
+/**
+ * Complete flow: Login, Tag, and Push image to ECR
+ */
+async function pushImageToECR(localImage, ecrUrl, username, password, repositoryUri) {
+  const spinner = ora('Preparing to push image...').start();
+
+  try {
+    // Step 1: Login to ECR (with retry logic)
+    spinner.text = 'Logging in to ECR (may take up to 60s)...';
+    try {
+      await dockerLogin(ecrUrl, username, password, 3); // 3 retries
+      spinner.succeed(chalk.green('✓ Logged in to ECR'));
+    } catch (loginError) {
+      spinner.fail(chalk.red('✗ Failed to login to ECR'));
+      console.log(chalk.yellow('\n⚠️  Troubleshooting tips:'));
+      console.log(chalk.white('  1. Check your internet connection'));
+      console.log(chalk.white('  2. Verify Docker is running: docker info'));
+      console.log(chalk.white('  3. Try restarting Docker'));
+      console.log(chalk.white('  4. Check if you can reach ECR:'));
+      console.log(chalk.cyan(`     curl -I ${ecrUrl}/v2/`));
+      console.log();
+      throw loginError;
+    }
+
+    // Step 2: Tag image for ECR
+    spinner.start('Tagging image for ECR...');
+    const remoteTag = `${repositoryUri}:latest`;
+    await dockerTag(localImage, remoteTag);
+    spinner.succeed(chalk.green(`✓ Tagged: ${localImage} → ${remoteTag}`));
+
+    // Step 3: Push image to ECR with progress
+    spinner.start('Pushing image to ECR...');
+    
+    let lastPercent = 0;
+    await dockerPush(remoteTag, (percent, completed, total) => {
+      if (percent > lastPercent || percent === 100) {
+        lastPercent = percent;
+        
+        // Create progress bar
+        const barLength = 30;
+        const filledLength = Math.floor((percent / 100) * barLength);
+        const progressBar = '█'.repeat(filledLength) + '░'.repeat(barLength - filledLength);
+        
+        // Update spinner text with progress
+        const layerInfo = total > 0 ? ` (${completed}/${total} layers)` : '';
+        spinner.text = `Pushing image to ECR... [${progressBar}] ${percent}%${layerInfo}`;
+      }
+    });
+
+    spinner.succeed(chalk.green('✓ Image pushed to ECR successfully!'));
+    return remoteTag;
+
+  } catch (error) {
+    spinner.fail(chalk.red('✗ Failed to push image'));
+    throw error;
+  }
+}
+
+module.exports = {
+  checkDockerInstalled,
+  checkDockerImage,
+  getImageSize,
+  dockerLogin,
+  dockerTag,
+  dockerPush,
+  pushImageToECR
+};
+