ejar-gitlab-pipeline-automator 1.0.0

package/pipeline_automation.js

@@ -0,0 +1,731 @@
+#!/usr/bin/env node
+
+import { spawn } from "child_process";
+import { program } from "commander";
+import { accessSync } from "fs";
+import fs from "fs/promises";
+import { createConnection } from "net";
+import os from "os";
+import path from "path";
+import { chromium, firefox } from "playwright";
+
+class GitLabPipelineAutomator {
+  constructor(config = {}) {
+    this.browser = null;
+    this.page = null;
+    this.pipelineId = null;
+    this.chromeProcess = null;
+    this.config = {
+      scriptsPath: config.scriptsPath || process.env.SCRIPTS_PATH || "/Users/mahadasif/Desktop/wareef-scripts",
+      gitlabBaseUrl: config.gitlabBaseUrl || process.env.GITLAB_BASE_URL || "https://devops.nhc.sa",
+      gitlabProjectPath: config.gitlabProjectPath || process.env.GITLAB_PROJECT_PATH || "/ejar3/devs/ejar3-run-script-tool",
+      cdpPort: config.cdpPort || parseInt(process.env.CDP_PORT) || 9222,
+      chromeUserDataDir: config.chromeUserDataDir || process.env.CHROME_USER_DATA_DIR || null,
+      chromeProfileDir: config.chromeProfileDir || process.env.CHROME_PROFILE_DIR || "Default",
+      ...config
+    };
+  }
+
+  getChromePath() {
+    const platform = os.platform();
+    switch (platform) {
+      case "darwin": // macOS
+        return "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome";
+      case "win32": // Windows
+        return [
+          process.env.LOCALAPPDATA + "\\Google\\Chrome\\Application\\chrome.exe",
+          process.env.PROGRAMFILES + "\\Google\\Chrome\\Application\\chrome.exe",
+          process.env["PROGRAMFILES(X86)"] + "\\Google\\Chrome\\Application\\chrome.exe"
+        ].find(p => {
+          try {
+            accessSync(p);
+            return true;
+          } catch {
+            return false;
+          }
+        });
+      case "linux": // Linux
+        return [
+          "/usr/bin/google-chrome",
+          "/usr/bin/google-chrome-stable",
+          "/usr/bin/chromium",
+          "/usr/bin/chromium-browser"
+        ].find(p => {
+          try {
+            accessSync(p);
+            return true;
+          } catch {
+            return false;
+          }
+        });
+      default:
+        return null;
+    }
+  }
+
+  async isPortAvailable(port) {
+    return new Promise((resolve) => {
+      const server = createConnection({ port }, () => {
+        server.end();
+        resolve(false); // Port is in use
+      });
+      server.on('error', () => {
+        resolve(true); // Port is available
+      });
+      server.setTimeout(1000, () => {
+        server.destroy();
+        resolve(true); // Timeout means port is likely available
+      });
+    });
+  }
+
+  async checkPortConnection(port) {
+    return new Promise((resolve) => {
+      const client = createConnection({ port }, () => {
+        client.end();
+        resolve(true); // Port is open and accepting connections
+      });
+      client.on('error', () => {
+        resolve(false); // Port is not accepting connections
+      });
+      client.setTimeout(1000, () => {
+        client.destroy();
+        resolve(false);
+      });
+    });
+  }
+
+  async tryConnectToPort(port, retries = 2) {
+    for (let i = 0; i < retries; i++) {
+      try {
+        const browser = await chromium.connectOverCDP(`http://127.0.0.1:${port}`, {
+          timeout: 3000
+        });
+        return browser;
+      } catch (err) {
+        if (i < retries - 1) {
+          await new Promise(resolve => setTimeout(resolve, 1000));
+        }
+      }
+    }
+    return null;
+  }
+
+  getDefaultChromeUserDataDir() {
+    const platform = os.platform();
+    const homeDir = os.homedir();
+    
+    switch (platform) {
+      case "darwin": // macOS
+        return path.join(homeDir, "Library", "Application Support", "Google", "Chrome");
+      case "win32": // Windows
+        return path.join(process.env.LOCALAPPDATA || "", "Google", "Chrome", "User Data");
+      case "linux": // Linux
+        return path.join(homeDir, ".config", "google-chrome");
+      default:
+        return null;
+    }
+  }
+
+  getAutomationChromeUserDataDir() {
+    const platform = os.platform();
+    const homeDir = os.homedir();
+    const appName = "gitlab-pipeline-automator";
+    
+    switch (platform) {
+      case "darwin": // macOS
+        return path.join(homeDir, ".config", appName, "chrome-profile");
+      case "win32": // Windows
+        return path.join(process.env.APPDATA || process.env.LOCALAPPDATA || "", appName, "chrome-profile");
+      case "linux": // Linux
+        return path.join(homeDir, ".config", appName, "chrome-profile");
+      default:
+        return path.join(homeDir, ".config", appName, "chrome-profile");
+    }
+  }
+
+  getDefaultChromeProfileLocation() {
+    return this.getAutomationChromeUserDataDir();
+  }
+
+  async ensureChromeUserDataDir() {
+    // If user specified a directory, use it
+    if (this.config.chromeUserDataDir) {
+      try {
+        await fs.mkdir(this.config.chromeUserDataDir, { recursive: true });
+        console.log(`📁 Using custom Chrome profile: ${this.config.chromeUserDataDir}`);
+        return this.config.chromeUserDataDir;
+      } catch (err) {
+        console.log(`⚠️ Warning: Could not create/access user data directory: ${err.message}`);
+        throw err;
+      }
+    }
+    
+    // Otherwise, create and use a default automation profile directory
+    const defaultDir = this.getAutomationChromeUserDataDir();
+    try {
+      await fs.mkdir(defaultDir, { recursive: true });
+      console.log(`📁 Chrome profile location: ${defaultDir}`);
+      console.log(`   (This profile will persist your login credentials)`);
+      console.log(`   (Location: ${defaultDir})`);
+      return defaultDir;
+    } catch (err) {
+      console.log(`⚠️ Warning: Could not create automation profile directory: ${err.message}`);
+      console.log(`   Continuing without persistent profile...`);
+      return null;
+    }
+  }
+
+  async launchChromeWithDebugging() {
+    const chromePath = this.getChromePath();
+    if (!chromePath) {
+      throw new Error("Chrome not found. Please install Google Chrome.");
+    }
+
+    console.log("🚀 Starting Chrome with remote debugging in the background...");
+    const args = [
+      `--remote-debugging-port=${this.config.cdpPort}`,
+      "--no-first-run",
+      "--no-default-browser-check",
+      "--disable-default-apps"
+    ];
+
+    // Ensure user data directory exists (creates default if not specified)
+    try {
+      const userDataDir = await this.ensureChromeUserDataDir();
+      
+      if (userDataDir) {
+        args.push(`--user-data-dir=${userDataDir}`);
+        
+        // Add profile directory if specified (not "Default")
+        if (this.config.chromeProfileDir && this.config.chromeProfileDir !== "Default") {
+          args.push(`--profile-directory=${this.config.chromeProfileDir}`);
+          console.log(`👤 Using profile directory: ${this.config.chromeProfileDir}`);
+        }
+      } else {
+        // Fallback: use system default Chrome profile
+        const defaultUserDataDir = this.getDefaultChromeUserDataDir();
+        if (defaultUserDataDir) {
+          try {
+            accessSync(defaultUserDataDir);
+            // Don't add --user-data-dir, let Chrome use its default
+            console.log("📁 Using system default Chrome profile");
+          } catch {
+            // Default directory doesn't exist, Chrome will create it
+            console.log("📁 Chrome will use its default profile location");
+          }
+        }
+      }
+    } catch (err) {
+      console.log(`⚠️ Warning: Could not set up Chrome profile: ${err.message}`);
+      console.log("   Continuing without persistent profile...");
+    }
+
+    // Launch Chrome in background (detached process)
+    // This ensures Chrome runs independently and doesn't block the script
+    const platform = os.platform();
+    
+    if (platform === "win32") {
+      // Windows: use CREATE_NEW_PROCESS_GROUP and DETACHED_PROCESS
+      this.chromeProcess = spawn(chromePath, args, {
+        detached: true,
+        stdio: "ignore",
+        windowsVerbatimArguments: false,
+        shell: false
+      });
+    } else {
+      // macOS/Linux: use setsid equivalent
+      this.chromeProcess = spawn(chromePath, args, {
+        detached: true,
+        stdio: "ignore"
+      });
+    }
+
+    // Unref the process so it runs independently
+    this.chromeProcess.unref();
+    
+    // Don't wait for the process to exit
+    this.chromeProcess.on('error', (err) => {
+      console.log(`⚠️ Chrome process error: ${err.message}`);
+    });
+
+    console.log("⏳ Waiting for Chrome to start...");
+    
+    // Wait for Chrome to be ready (check if port becomes available)
+    const maxWaitTime = 10000; // 10 seconds max
+    const checkInterval = 500; // Check every 500ms
+    const startTime = Date.now();
+    
+    while (Date.now() - startTime < maxWaitTime) {
+      const browser = await this.tryConnectToPort(this.config.cdpPort, 1);
+      if (browser) {
+        await browser.close();
+        console.log("✅ Chrome started successfully with remote debugging");
+        return;
+      }
+      await new Promise(resolve => setTimeout(resolve, checkInterval));
+    }
+    
+    console.log("⚠️ Chrome may still be starting. Continuing...");
+  }
+
+  async connectToExistingChrome() {
+    // First, try to connect to existing Chrome
+    console.log(`🔍 Checking for existing Chrome on port ${this.config.cdpPort}...`);
+    
+    // Try to connect to the configured port
+    this.browser = await this.tryConnectToPort(this.config.cdpPort);
+    
+    if (this.browser) {
+      try {
+        const contexts = this.browser.contexts();
+        
+        if (contexts.length > 0) {
+          this.page = await contexts[0].newPage();
+          console.log("✅ Connected to existing Chrome session (new tab opened)");
+          return true;
+        } else {
+          // Browser connected but no contexts, create a new one
+          this.page = await this.browser.newPage();
+          console.log("✅ Connected to existing Chrome session (new page created)");
+          return true;
+        }
+      } catch (err) {
+        console.log(`⚠️ Connected to Chrome but error accessing contexts: ${err.message}`);
+        // Try to create a new page anyway
+        try {
+          this.page = await this.browser.newPage();
+          console.log("✅ Connected to existing Chrome session (new page created)");
+          return true;
+        } catch (pageErr) {
+          console.log(`❌ Error creating page: ${pageErr.message}`);
+        }
+      }
+    }
+    
+    // No connection on configured port, check if port is in use
+    const portInUse = await this.checkPortConnection(this.config.cdpPort);
+    
+    if (portInUse) {
+      console.log(`⚠️ Port ${this.config.cdpPort} is in use but connection failed.`);
+      console.log(`   Chrome might be running without remote debugging enabled.`);
+      console.log(`   To use existing Chrome, restart it with:`);
+      console.log(`   /Applications/Google\\ Chrome.app/Contents/MacOS/Google\\ Chrome --remote-debugging-port=${this.config.cdpPort}`);
+    } else {
+      console.log(`⚠️ No Chrome found on port ${this.config.cdpPort}`);
+    }
+    
+    // Try common alternative ports
+    const commonPorts = [9223, 9224, 9225, 9226];
+    console.log(`🔍 Trying common alternative ports...`);
+    
+    for (const port of commonPorts) {
+      const browser = await this.tryConnectToPort(port, 1);
+      if (browser) {
+        this.browser = browser;
+        try {
+          const contexts = this.browser.contexts();
+          this.page = contexts.length > 0 
+            ? await contexts[0].newPage() 
+            : await this.browser.newPage();
+          console.log(`✅ Connected to existing Chrome on port ${port} (new tab opened)`);
+          return true;
+        } catch (err) {
+          console.log(`⚠️ Connected to port ${port} but error: ${err.message}`);
+        }
+      }
+    }
+    
+    // No existing Chrome found, automatically launch a new one in background
+    console.log("🚀 No existing Chrome with remote debugging found.");
+    console.log("   Automatically starting Chrome in the background...");
+    
+    try {
+      // Launch Chrome in background - this method handles waiting for it to be ready
+      await this.launchChromeWithDebugging();
+      
+      // Connect to the newly launched Chrome
+      console.log("🔗 Connecting to Chrome...");
+      this.browser = await this.tryConnectToPort(this.config.cdpPort, 5);
+      
+      if (!this.browser) {
+        // Give it a bit more time if first attempt fails
+        console.log("⏳ Chrome is still starting, waiting a bit more...");
+        await new Promise(resolve => setTimeout(resolve, 3000));
+        this.browser = await this.tryConnectToPort(this.config.cdpPort, 3);
+      }
+      
+      if (!this.browser) {
+        throw new Error("Could not connect to Chrome after launching. Please check if Chrome started successfully.");
+      }
+      
+      const contexts = this.browser.contexts();
+      this.page = contexts.length > 0 
+        ? await contexts[0].newPage() 
+        : await this.browser.newPage();
+      
+      console.log("✅ Connected to Chrome (running in background, new tab opened)");
+      return true;
+    } catch (launchErr) {
+      console.log("❌ Could not launch or connect to Chrome:", launchErr.message);
+      console.log("\n💡 Troubleshooting tips:");
+      console.log("   1. Make sure Chrome is installed");
+      console.log("   2. Check if another process is using port " + this.config.cdpPort);
+      console.log("   3. Try closing all Chrome instances and run again");
+      console.log("   4. Or manually start Chrome with:");
+      const chromePath = this.getChromePath();
+      if (chromePath) {
+        console.log(`   ${chromePath} --remote-debugging-port=${this.config.cdpPort}`);
+      }
+      return false;
+    }
+  }
+
+  async connectToFirefox() {
+    try {
+      this.browser = await firefox.launch({ headless: false });
+      this.page = await this.browser.newPage();
+      console.log("✅ Connected to Firefox browser");
+      return true;
+    } catch (err) {
+      console.log("❌ Could not connect to Firefox:", err);
+      return false;
+    }
+  }
+
+  async retry(fn, maxAttempts = 3, delayMs = 5000) {
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        return await fn();
+      } catch (err) {
+        console.log(`⚠️ Attempt ${attempt} failed: ${err.message || err}`);
+        if (attempt < maxAttempts) {
+          console.log(`🔄 Retrying in ${delayMs / 1000}s...`);
+          await this.page.waitForTimeout(delayMs);
+        } else {
+          throw err;
+        }
+      }
+    }
+  }
+
+  async navigateToGitlabPipeline() {
+    const targetUrl = `${this.config.gitlabBaseUrl}${this.config.gitlabProjectPath}/-/pipelines/new`;
+    await this.page.goto(targetUrl, { waitUntil: "domcontentloaded" });
+    console.log("✅ GitLab pipeline page opened");
+  }
+
+  async selectBranch(branchName = "production") {
+    console.log(`Selecting branch: ${branchName}`);
+    await this.page.reload();
+    await this.page.click(".ref-selector #dropdown-toggle-btn-37");
+    await this.page.waitForSelector("#base-dropdown-38 ul");
+
+    const liElements = await this.page.$$("#base-dropdown-38 ul li");
+    let index = { development: 5, production: 7, test: 8, uat: 1 }[
+      branchName.toLowerCase()
+    ];
+    if (index === undefined) throw new Error(`Invalid branch: ${branchName}`);
+
+    await liElements[index].click();
+    console.log(`✅ Branch '${branchName}' selected`);
+  }
+
+  async readScript(scriptName) {
+    const scriptPath = path.join(this.config.scriptsPath, `${scriptName}.rb`);
+    return await fs.readFile(scriptPath, "utf8");
+  }
+
+  fetchTicketDescriptionFromScript(scriptContent) {
+    const pattern = /task\s+([a-zA-Z0-9_]+)\s*:\s*:environment\s+do/;
+    const match = scriptContent.match(pattern);
+    if (match) {
+      console.log(`✓ Extracted task name from script: ${match[1]}`);
+      return match[1];
+    }
+    console.log("⚠️ No task name found in script");
+    return null;
+  }
+
+  async processCiVariables(ticketDescription, scriptContent, ejarService) {
+    if (
+      ejarService.toLowerCase().includes("sec") ||
+      ejarService.toLowerCase().includes("security-deposit")
+    ) {
+      const extracted = this.fetchTicketDescriptionFromScript(scriptContent);
+      if (extracted) {
+        console.log(
+          `🔄 Replacing ticket description '${ticketDescription}' with extracted '${extracted}'`
+        );
+        ticketDescription = extracted;
+      }
+    }
+
+    await this.page.waitForSelector(
+      'div[data-testid="ci-variable-row-container"]',
+      { timeout: 15000 }
+    );
+    const containers = await this.page.$$(
+      'div[data-testid="ci-variable-row-container"]'
+    );
+    if (!containers.length) throw new Error("No CI variable containers found");
+
+    // 1. Ticket description
+    const textarea1 = await containers[0].$(
+      '[data-testid="pipeline-form-ci-variable-value-field"]'
+    );
+    await textarea1.fill(ticketDescription);
+
+    // 2. Service dropdown
+    const dropdownBtn = await containers[1].$(
+      '[data-testid="pipeline-form-ci-variable-value-dropdown"]'
+    );
+    await dropdownBtn.click();
+    await this.page.waitForSelector("#base-dropdown-54 #listbox-52");
+    const options = await this.page.$$("#base-dropdown-54 #listbox-52 li");
+    let matched = false;
+    for (const opt of options) {
+      const text = await opt.getAttribute("data-testid");
+      if (text?.toLowerCase().includes(ejarService.toLowerCase())) {
+        await opt.click();
+        matched = true;
+        break;
+      }
+    }
+    if (!matched) await options[4].click();
+
+    // 3. Script content
+    const scriptArea = await containers[2].$(
+      '[data-testid="pipeline-form-ci-variable-value-field"]'
+    );
+    await scriptArea.fill(scriptContent);
+
+    await this.page.click('[data-testid="run-pipeline-button"]');
+    console.log("✅ CI variables set and pipeline started");
+  }
+
+  async waitForPipelinePage() {
+    await this.page.waitForURL(/\/pipelines\/\d+$/, { timeout: 30000 });
+    this.pipelineId = this.page.url().split("/").pop();
+    console.log(`✅ Pipeline page loaded (ID: ${this.pipelineId})`);
+  }
+
+  async approvePipelineStage() {
+    return this.retry(
+      async () => {
+        console.log("⏳ Waiting for approve stage...");
+        const maxAttempts = 20;
+        for (let attempt = 0; attempt < maxAttempts; attempt++) {
+          try {
+            const badge = this.page.locator("#ci-badge-approve_prod");
+            await badge.waitFor({ timeout: 15000 });
+
+            const ciIcon = badge.getByTestId("ci-icon");
+            const aria = await ciIcon.getAttribute("aria-label");
+
+            console.log("aria value: ", aria);
+
+            // const ciIcon = badge.locator('[data-testid="ci-icon"]');
+            const iconClass = await ciIcon.getAttribute("class");
+            const neutral = iconClass?.includes("ci-icon-variant-neutral");
+            const success = iconClass?.includes("ci-icon-variant-success");
+
+            console.log("iconClass: ", iconClass);
+
+            if (success) {
+              console.log("✅ Approve stage already completed");
+              return true;
+            }
+
+            if (neutral) {
+              console.log("🔘 Approve button available, clicking...");
+              const approveButton = badge.locator(
+                '[data-testid="ci-action-button"]'
+              );
+              await approveButton.scrollIntoViewIfNeeded();
+              await approveButton.click();
+              await this.page.waitForTimeout(2000);
+
+              const updatedClass = await ciIcon.getAttribute("class");
+              console.log("updated class: ", updatedClass);
+              if (updatedClass?.includes("ci-icon-variant-success")) {
+                console.log("✅ Successfully approved pipeline");
+                return true;
+              }
+            } else {
+              console.log("⏳ Approve stage in progress...");
+            }
+          } catch (err) {
+            console.log(`⚠️ Error while approving: ${err}`);
+          }
+
+          await this.page.reload();
+          console.log(`Retrying... (attempt ${attempt + 1}/${maxAttempts})`);
+          await this.page.waitForTimeout(5000);
+        }
+        throw new Error("❌ Approve stage did not complete in time");
+      },
+      2,
+      10000
+    );
+  }
+
+  async runPipelineStage() {
+    try {
+      console.log("Looking for run pipeline badge...");
+      const badge = this.page.locator("#ci-badge-runscript_prod");
+      await badge.waitFor({ timeout: 10000 });
+      console.log("✓ Found run pipeline badge");
+
+      await badge.click();
+      console.log("✓ Redirected to pipeline execution page");
+    } catch (err) {
+      console.log(`✗ Could not click run pipeline badge: ${err}`);
+      return false;
+    }
+
+    await this.page.waitForTimeout(15000);
+
+    try {
+      console.log("Monitor the pipeline execution until completion");
+      const maxAttempts = 60;
+      for (let attempt = 0; attempt < maxAttempts; attempt++) {
+        try {
+          const ciIcon = this.page.locator(
+            '.build-job a[data-testid="ci-icon"]'
+          );
+          await ciIcon.waitFor({ timeout: 5000 });
+
+          const ariaLabel = await ciIcon.getAttribute("aria-label");
+          if (ariaLabel?.includes("Status: Passed")) {
+            console.log(
+              `✅ Pipeline execution passed with pipeline_id: ${this.pipelineId}`
+            );
+            return true;
+          }
+          if (ariaLabel?.includes("Status: Failed")) {
+            console.log("❌ Pipeline execution failed");
+            return false;
+          }
+        } catch (err) {
+          console.log(`⚠️ Could not find pipeline-status-link: ${err}`);
+        }
+
+        console.log(`⏳ Checking... (attempt ${attempt + 1}/${maxAttempts})`);
+        await this.page.reload();
+        await this.page.waitForTimeout(10000);
+      }
+
+      console.log("⚠️ Pipeline monitoring timed out");
+      return false;
+    } catch (err) {
+      console.log(`💥 Error monitoring pipeline: ${err}`);
+      return false;
+    }
+  }
+
+  async close() {
+    if (this.browser) {
+      await this.browser.close();
+      console.log("Browser closed");
+    }
+    // Note: We don't kill the Chrome process as it may be used by the user
+  }
+}
+
+// Export the class for use as a module
+export default GitLabPipelineAutomator;
+export { GitLabPipelineAutomator };
+
+// Setup commander program
+program
+  .name("gitlab-pipeline-automator")
+  .description("Automate GitLab pipeline creation, approval, and monitoring")
+  .version("1.0.0")
+  .requiredOption("-t, --ticket <ticket>", "Ticket description")
+  .requiredOption("-s, --script <script>", "Ruby script filename without .rb")
+  .requiredOption("-e, --ejar-service <service>", "Ejar3 service name")
+  .option("-b, --branch <branch>", "Git branch to use", "production")
+  .option("--scripts-path <path>", "Path to scripts directory", process.env.SCRIPTS_PATH)
+  .option("--gitlab-url <url>", "GitLab base URL", process.env.GITLAB_BASE_URL)
+  .option("--project-path <path>", "GitLab project path", process.env.GITLAB_PROJECT_PATH)
+  .option("--cdp-port <port>", "Chrome DevTools Protocol port", "9222")
+  .option("--chrome-user-data-dir <path>", "Chrome user data directory (for saved credentials/login)", process.env.CHROME_USER_DATA_DIR)
+  .option("--chrome-profile-dir <name>", "Chrome profile directory name (default: 'Default')", process.env.CHROME_PROFILE_DIR || "Default");
+
+// Only run CLI if this file is executed directly
+// Check if this is the main module by comparing the resolved paths
+const isMainModule = (() => {
+  if (import.meta.url.startsWith('file://')) {
+    const currentFile = import.meta.url.replace('file://', '');
+    const executedFile = process.argv[1];
+    if (!executedFile) return false;
+    
+    try {
+      const currentPath = path.resolve(currentFile);
+      const executedPath = path.resolve(executedFile);
+      return currentPath === executedPath || 
+             executedPath.includes('pipeline_automation.js') ||
+             executedPath.includes('gitlab-pipeline-automator');
+    } catch {
+      return executedFile.includes('pipeline_automation.js') || 
+             executedFile.includes('gitlab-pipeline-automator');
+    }
+  }
+  return process.argv[1]?.includes('pipeline_automation.js') || 
+         process.argv[1]?.includes('gitlab-pipeline-automator');
+})();
+
+if (isMainModule) {
+  (async () => {
+    // Parse arguments - this will handle --help and --version automatically
+    program.parse();
+    const args = program.opts();
+    const config = {
+      // Only set config if CLI args are provided, otherwise let constructor use env vars or defaults
+      ...(args.scriptsPath && { scriptsPath: args.scriptsPath }),
+      ...(args.gitlabUrl && { gitlabBaseUrl: args.gitlabUrl }),
+      ...(args.projectPath && { gitlabProjectPath: args.projectPath }),
+      ...(args.cdpPort && { cdpPort: parseInt(args.cdpPort) }),
+      ...(args.chromeUserDataDir && { chromeUserDataDir: args.chromeUserDataDir }),
+      ...(args.chromeProfileDir && { chromeProfileDir: args.chromeProfileDir })
+    };
+    const automator = new GitLabPipelineAutomator(config);
+
+  try {
+    if (!(await automator.connectToExistingChrome())) {
+      await automator.connectToFirefox();
+    }
+
+    // Wrap the whole core flow in retry
+    await automator.retry(
+      async () => {
+        await automator.navigateToGitlabPipeline();
+        await automator.selectBranch(args.branch);
+        const script = await automator.readScript(args.script);
+        await automator.processCiVariables(
+          args.ticket,
+          script,
+          args.ejarService
+        );
+        await automator.waitForPipelinePage();
+      },
+      3,
+      1000
+    );
+
+    console.log("✅ Pipeline page loaded");
+    console.log("⏳ Waiting for approve stage...");
+    await automator.approvePipelineStage();
+
+    console.log("🎉 Pipeline approved successfully");
+
+    await automator.runPipelineStage();
+  } catch (err) {
+    console.error("💥 Automation failed:", err);
+    process.exit(1);
+  } finally {
+    await automator.close();
+  }
+})();
+}