@invarn/cibuild 1.3.15 → 1.3.17

package/dist/src/cli.js

@@ -0,0 +1,987 @@
+#!/usr/bin/env node
+import { resolve, extname } from "node:path";
+import { pathToFileURL } from "node:url";
+import { existsSync, readdirSync, mkdirSync, copyFileSync, readFileSync, writeFileSync, appendFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { execSync } from "node:child_process";
+import prompts from "prompts";
+import { PipelineRunner } from "./runner.js";
+import { loadConfig } from "./config.js";
+import { loadYAMLPipeline } from "./yaml/parser.js";
+import { convertYAMLWithSecrets } from "./yaml/pipeline-with-secrets.js";
+import { detectPlatformInfo } from "./yaml/platform-detector.js";
+import { StepValidator, formatValidationResult } from "./yaml/step-validator.js";
+import { SecretsManager } from "./yaml/secrets-manager.js";
+import { MissingEnvHandler } from "./yaml/missing-env-handler.js";
+import { MissingEnvironmentVariableError } from "./yaml/env-resolver.js";
+import "./yaml/steps/index.js"; // Initialize step registry
+import { handleBuildCommand } from "./commands/build.js";
+import { handleEditCommand } from "./commands/edit.js";
+import { handleSecretsUploadCommand } from "./commands/secrets-upload.js";
+import { handleSecretsSyncWorkflowCommand } from "./commands/secrets-sync-workflow.js";
+import { handleResetCommand } from "./commands/reset.js";
+import { generateGitHubActionsWorkflow } from "./commands/github-workflow.js";
+/**
+ * Detects whether the current directory is the root of an Android or iOS project.
+ * Returns the detected project type, or null if neither is found.
+ */
+function detectMobileProjectRoot(dir) {
+    // Android: must have build.gradle or build.gradle.kts at root
+    const androidIndicators = [
+        "build.gradle",
+        "build.gradle.kts",
+        "settings.gradle",
+        "settings.gradle.kts",
+        "gradlew",
+    ];
+    const hasAndroidIndicator = androidIndicators.some((f) => existsSync(resolve(dir, f)));
+    if (hasAndroidIndicator) {
+        return "android";
+    }
+    // iOS: must have a .xcodeproj or .xcworkspace directory, or a Podfile
+    const iosFileIndicators = ["Podfile"];
+    const hasIosFile = iosFileIndicators.some((f) => existsSync(resolve(dir, f)));
+    if (!hasIosFile) {
+        // Check for .xcodeproj / .xcworkspace directories
+        try {
+            const entries = readdirSync(dir);
+            const hasXcodeDir = entries.some((e) => e.endsWith(".xcodeproj") || e.endsWith(".xcworkspace"));
+            if (hasXcodeDir) {
+                return "ios";
+            }
+        }
+        catch {
+            // If we can't read the directory, fall through
+        }
+    }
+    else {
+        return "ios";
+    }
+    return null;
+}
+/**
+ * Ensures CI Build runtime files are listed in .gitignore.
+ * Safe to call multiple times — only appends entries that are missing.
+ */
+function ensureCiBuildGitignoreEntries(cwd) {
+    const gitignorePath = resolve(cwd, ".gitignore");
+    const gitignoreEntries = [".cibuild-secrets.json", ".ci/.envstore.json", ".ci/keys/", "build/"];
+    if (existsSync(gitignorePath)) {
+        const contents = readFileSync(gitignorePath, "utf-8");
+        const lines = contents.split("\n").map((l) => l.trim());
+        const toAdd = gitignoreEntries.filter((e) => !lines.includes(e));
+        if (toAdd.length > 0) {
+            appendFileSync(gitignorePath, `\n${toAdd.join("\n")}\n`);
+            for (const entry of toAdd) {
+                console.log(`✅ Added ${entry} to .gitignore`);
+            }
+        }
+    }
+    else {
+        writeFileSync(gitignorePath, `${gitignoreEntries.join("\n")}\n`);
+        console.log(`✅ Created .gitignore with CI Build entries`);
+    }
+}
+async function handleInitCommand(opts = {}) {
+    const cwd = process.cwd();
+    // Verify we are inside a mobile project root before doing anything
+    const projectType = detectMobileProjectRoot(cwd);
+    if (!projectType) {
+        console.error("Error: Not a mobile project root.");
+        console.error("ci init must be run from the root folder of an Android or iOS project.");
+        console.error("\nAndroid projects must contain one of:");
+        console.error("  build.gradle, build.gradle.kts, settings.gradle, settings.gradle.kts, gradlew");
+        console.error("\niOS projects must contain one of:");
+        console.error("  *.xcodeproj, *.xcworkspace, Podfile");
+        process.exit(1);
+    }
+    // Bail out early if .ci already exists and has content
+    const ciDir = resolve(cwd, ".ci");
+    if (existsSync(ciDir)) {
+        const entries = readdirSync(ciDir);
+        if (entries.length > 0) {
+            console.error("Already initialised. Run 'ci run' to execute your pipeline.");
+            process.exit(1);
+        }
+    }
+    console.log(`\nDetected project type: ${projectType === "android" ? "Android" : "iOS"}`);
+    console.log(`
+╔══════════════════════════════════════════════════════════════╗
+║                 CI Build - Dependency Check                  ║
+╚══════════════════════════════════════════════════════════════╝
+`);
+    const commonDependencies = [
+        {
+            name: "Git",
+            command: "git --version",
+            required: true,
+            installInstructions: "Download from https://git-scm.com/"
+        }
+    ];
+    const androidDependencies = [
+        {
+            name: "Java (JDK)",
+            command: "java -version 2>&1 | head -1",
+            required: true,
+            installInstructions: "Download from https://adoptium.net/ or install via brew: brew install --cask temurin"
+        },
+        {
+            name: "Android SDK",
+            customCheck: () => {
+                const fromEnv = process.env.ANDROID_HOME;
+                if (fromEnv && existsSync(fromEnv)) {
+                    return { found: true, message: `${fromEnv} (via ANDROID_HOME)` };
+                }
+                const commonPaths = [
+                    `${homedir()}/Library/Android/sdk`, // macOS
+                    `${homedir()}/Android/Sdk`, // Linux
+                    "/usr/local/android-sdk",
+                ];
+                const detected = commonPaths.find((p) => existsSync(p));
+                if (detected) {
+                    return { found: true, message: `${detected} (auto-detected)` };
+                }
+                return { found: false, message: "Android SDK not found" };
+            },
+            required: true,
+            installInstructions: "Install Android Studio from https://developer.android.com/studio or set ANDROID_HOME manually"
+        }
+    ];
+    const iosDependencies = [
+        {
+            name: "Xcode",
+            command: "xcodebuild -version 2>&1 | head -1",
+            required: true,
+            installInstructions: "Install Xcode from the Mac App Store"
+        },
+        {
+            name: "CocoaPods",
+            command: "pod --version",
+            required: false,
+            installInstructions: "Run: sudo gem install cocoapods"
+        }
+    ];
+    const dependencies = [
+        ...commonDependencies,
+        ...(projectType === "android" ? androidDependencies : iosDependencies),
+    ];
+    let allRequired = true;
+    let missingOptional = false;
+    for (const dep of dependencies) {
+        if (dep.customCheck) {
+            const result = dep.customCheck();
+            if (result.found) {
+                console.log(`✅ ${dep.name.padEnd(20)} ${result.message}`);
+            }
+            else if (dep.required) {
+                console.log(`❌ ${dep.name.padEnd(20)} Not found (REQUIRED)`);
+                console.log(`   Install: ${dep.installInstructions}`);
+                allRequired = false;
+            }
+            else {
+                console.log(`⚠️  ${dep.name.padEnd(20)} Not found (optional)`);
+                console.log(`   Install: ${dep.installInstructions}`);
+                missingOptional = true;
+            }
+            continue;
+        }
+        try {
+            const output = execSync(dep.command, {
+                encoding: "utf-8",
+                stdio: ["pipe", "pipe", "pipe"],
+                shell: "/bin/sh",
+            }).trim();
+            console.log(`✅ ${dep.name.padEnd(20)} ${output}`);
+        }
+        catch {
+            if (dep.required) {
+                console.log(`❌ ${dep.name.padEnd(20)} Not found (REQUIRED)`);
+                console.log(`   Install: ${dep.installInstructions}`);
+                allRequired = false;
+            }
+            else {
+                console.log(`⚠️  ${dep.name.padEnd(20)} Not found (optional)`);
+                console.log(`   Install: ${dep.installInstructions}`);
+                missingOptional = true;
+            }
+        }
+    }
+    console.log();
+    if (allRequired && !missingOptional) {
+        console.log("✨ All dependencies are installed and ready!");
+    }
+    else if (allRequired) {
+        console.log("✅ All required dependencies are installed!");
+        console.log("⚠️  Some optional dependencies are missing but you can still use CI Build.");
+    }
+    else {
+        console.log("❌ Please install the missing required dependencies above.");
+        process.exit(1);
+    }
+    console.log();
+    // Determine action: non-interactive flags take priority over interactive prompts
+    let action;
+    if (opts.importPath) {
+        action = "import";
+    }
+    else if (opts.create) {
+        action = "create";
+    }
+    else {
+        // Interactive mode — ask the user
+        const response = await prompts({
+            type: "select",
+            name: "action",
+            message: "How would you like to set up your pipeline?",
+            choices: [
+                { title: "Import an existing YAML pipeline", value: "import" },
+                { title: "Create a new pipeline", value: "create" },
+            ],
+        });
+        action = response.action;
+    }
+    if (!action) {
+        console.log("\nCancelled.");
+        process.exit(0);
+    }
+    // Add CI Build runtime files to .gitignore (both create and import flows)
+    ensureCiBuildGitignoreEntries(cwd);
+    if (action === "create") {
+        await handleBuildCommand(detectMobileProjectRoot, { createPipelinesDir: true, nonInteractive: true });
+        process.exit(0);
+    }
+    // Import flow
+    let resolvedYaml;
+    if (opts.importPath) {
+        // Non-interactive: validate the provided path
+        const trimmed = opts.importPath.trim();
+        if (!existsSync(trimmed)) {
+            console.error(`Error: File not found: ${trimmed}`);
+            process.exit(1);
+        }
+        const ext = trimmed.split(".").pop()?.toLowerCase();
+        if (ext !== "yml" && ext !== "yaml") {
+            console.error("Error: File must be a .yml or .yaml file");
+            process.exit(1);
+        }
+        resolvedYaml = trimmed;
+    }
+    else {
+        // Interactive: ask for the path
+        const { yamlPath } = await prompts({
+            type: "text",
+            name: "yamlPath",
+            message: "Enter the absolute path to your YAML pipeline file:",
+            validate: (value) => {
+                if (!value.trim())
+                    return "Path is required";
+                if (!existsSync(value.trim()))
+                    return `File not found: ${value.trim()}`;
+                const ext = value.trim().split(".").pop()?.toLowerCase();
+                if (ext !== "yml" && ext !== "yaml")
+                    return "File must be a .yml or .yaml file";
+                return true;
+            },
+        });
+        if (!yamlPath) {
+            console.log("\nCancelled.");
+            process.exit(0);
+        }
+        resolvedYaml = yamlPath.trim();
+    }
+    const fileName = resolvedYaml.split("/").pop();
+    const pipelinesDir = resolve(ciDir, "pipelines");
+    const destPath = resolve(pipelinesDir, fileName);
+    mkdirSync(pipelinesDir, { recursive: true });
+    copyFileSync(resolvedYaml, destPath);
+    console.log(`\n✅ Created .ci/pipelines/`);
+    console.log(`✅ Copied pipeline: ${fileName}`);
+    // Generate GitHub Actions workflow — detect platform from imported YAML if possible
+    let importedPlatform = null;
+    try {
+        const yamlPipeline = loadYAMLPipeline(destPath);
+        const meta = yamlPipeline.meta?.["cibuild.io"];
+        if (meta?.platform === "ios" || meta?.platform === "android") {
+            importedPlatform = meta.platform;
+        }
+    }
+    catch { /* ignore parse errors — default to macos-latest */ }
+    generateGitHubActionsWorkflow({ platform: importedPlatform, cwd });
+    const hasSecrets = existsSync(resolve(cwd, ".cibuild-secrets.json"));
+    const hasWorkflow = existsSync(resolve(cwd, ".github", "workflows", "ci.yml"));
+    console.log("\nNext steps:");
+    console.log("  ci run .ci/pipelines/cibuild.yml -w primary   # Run locally");
+    if (hasWorkflow) {
+        if (hasSecrets) {
+            console.log("  ci secrets upload                               # Upload secrets to GitHub");
+        }
+        console.log("  git add . && git push                          # Push to GitHub - CI runs automatically");
+    }
+    console.log("");
+}
+/**
+ * Shows an interactive workflow picker
+ * @param workflows Available workflow names
+ * @param pipelinePath Pipeline file path
+ * @returns Selected workflow name or undefined if cancelled
+ */
+async function promptForWorkflow(workflows) {
+    if (workflows.length === 0) {
+        console.error("Error: No workflows found in pipeline file");
+        return undefined;
+    }
+    if (workflows.length === 1) {
+        // Only one workflow, use it automatically
+        console.log(`Using workflow: ${workflows[0]}\n`);
+        return workflows[0];
+    }
+    // Multiple workflows, show interactive picker
+    const response = await prompts({
+        type: 'select',
+        name: 'workflow',
+        message: 'Select a workflow to run:',
+        choices: workflows.map((name) => ({ title: name, value: name })),
+        initial: 0,
+    });
+    if (!response.workflow) {
+        // User cancelled (Ctrl+C)
+        console.log('\nWorkflow selection cancelled');
+        return undefined;
+    }
+    console.log(); // Add blank line after selection
+    return response.workflow;
+}
+/**
+ * Runs pre-execution validation, separates issues into user-fillable (missing env vars)
+ * vs hard-blocking (missing commands, bad config), and collects all missing values
+ * upfront in a single form-like pass before execution begins.
+ *
+ * @returns true if it's safe to proceed, false if the user cancelled or hard errors exist
+ */
+async function promptForMissingVariables(yamlPipeline, workflowName, config, yamlFilePath) {
+    console.log(`\n🔍 Running pre-execution validation...`);
+    const validator = new StepValidator(yamlPipeline, workflowName, config, yamlFilePath);
+    const result = await validator.validateWorkflow();
+    const errorIssues = result.issues.filter((i) => i.requirement.severity === "error" && i.result && !i.result.passed);
+    const fillable = errorIssues.filter((i) => i.requirement.timing === "pre-execution" &&
+        (i.requirement.category === "environment" || i.requirement.category === "input"));
+    const blocking = errorIssues.filter((i) => !(i.requirement.timing === "pre-execution" &&
+        (i.requirement.category === "environment" || i.requirement.category === "input")));
+    // Hard errors that the user can't fix interactively (missing commands, etc.)
+    if (blocking.length > 0) {
+        console.log(formatValidationResult(result));
+        return false;
+    }
+    // Warnings and info only — nothing missing
+    if (fillable.length === 0) {
+        if (result.counts.warnings > 0 || result.counts.info > 0) {
+            console.log(formatValidationResult(result));
+        }
+        else {
+            console.log("✅ Pre-execution validation passed\n");
+        }
+        return true;
+    }
+    // Show all missing variables upfront
+    console.log(`\n${fillable.length} required value(s) missing — provide them to continue:\n`);
+    for (const issue of fillable) {
+        const stepInfo = issue.stepName ? `  needed by: ${issue.stepName}` : "";
+        console.log(`  • ${issue.requirement.name.padEnd(30)}${stepInfo}`);
+    }
+    console.log();
+    const handler = new MissingEnvHandler({
+        interactive: true,
+        workflow: workflowName,
+    });
+    for (let i = 0; i < fillable.length; i++) {
+        const issue = fillable[i];
+        const error = new MissingEnvironmentVariableError(issue.requirement.name, issue.stepName, issue.requirement.hint);
+        // Patch the counter into the box header label
+        const original = console.log;
+        const label = `(${i + 1} of ${fillable.length})`;
+        let patched = false;
+        console.log = (...args) => {
+            if (!patched && typeof args[0] === "string" && args[0].includes("MISSING REQUIRED")) {
+                original(`║  MISSING REQUIRED ENVIRONMENT VARIABLE ${label.padEnd(28)}║`);
+                patched = true;
+                return;
+            }
+            original(...args);
+        };
+        const handleResult = await handler.handleMissingVariable(error);
+        console.log = original;
+        if (handleResult.cancelled) {
+            return false;
+        }
+    }
+    handler.close();
+    return true;
+}
+async function main() {
+    const args = process.argv.slice(2);
+    if (args[0] === "--version" || args[0] === "-v") {
+        console.log(CIBUILD_VERSION);
+        process.exit(0);
+    }
+    if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
+        console.log(`
+CI Build - Lightweight CI/CD Pipeline Runner
+
+Usage:
+  ci init                                         Check dependencies + set up pipeline (interactive)
+  ci init --create                                 Check dependencies + create pipeline (non-interactive)
+  ci init --import <path>                          Check dependencies + import YAML pipeline (non-interactive)
+  ci build                                        Generate a standard pipeline for the current project
+  ci run <path> [-w <name>]                       Run locally (development mode)
+  ci run <path> [-w <name>] --production          Run on remote runner (production)
+  ci run <path> [-w <name>] --validate-only       Validate only, don't execute
+  ci run <path> [-w <name>] --skip-validation     Skip validation, run with interactive prompts
+  ci validate <path> [-w <name>]                  Validate pipeline (alias for --validate-only)
+  ci detect-platform <path> [-w <name>]           Detect platform from YAML pipeline
+  ci reset [--force]                              Remove all cibuild files and folders
+  ci edit <path> [-w <name>]                      View pipeline and edit step inputs
+  ci secrets add <var_name> <path> [-w <name>]              Add a secret (prompted interactively)
+  ci secrets add <var_name> <path> --file <file> [-w <name>] Add a secret from a file
+  ci secrets upload [--env <name>] [--repo <owner/repo>] [--dry-run]  Upload secrets to GitHub environment
+  ci --version                                      Show version
+  ci --help                                       Show this help
+
+Options:
+  --workflow, -w <name>        Workflow name (YAML only, defaults to first workflow)
+  --production                 Execute on remote runner after validation (vs local)
+  --validate-only              Run validation only, don't execute pipeline
+  --skip-validation            Skip pre-execution validation (for development)
+  --help, -h                   Show this help message
+
+Supported Formats:
+  .ts                          TypeScript pipeline files
+  .yml, .yaml                  YAML pipeline files
+
+Examples:
+  ci init                                        # Interactive setup
+  ci init --create                               # Non-interactive: create pipeline
+  ci init --import pipeline.yml                  # Non-interactive: import YAML
+  ci build                                       # Generate standard pipeline
+  ci run examples/android-build.yml -w pull-request-java-17
+  ci run build.pipeline.ts
+  ci run ios-build.yml
+  ci run android.yml --workflow qa
+  ci run multi-platform.yaml -w ios-build
+  ci run android.yml --production                # Run on remote runner
+  ci validate ios-build.yml                      # Validate only
+  ci detect-platform ios-build.yml
+  ci secrets add SLACK_CHANNEL bitrise.yml              # Add secret (prompted)
+  ci secrets add GOOGLE_SERVICES_JSON bitrise.yml --file app/google-services.json
+  ci detect-platform multi-platform.yaml -w android
+  ci edit android-build.yml                      # View + edit step inputs
+  ci edit android-build.yml -w debug             # Edit specific workflow
+    `);
+        process.exit(0);
+    }
+    // Handle envman subcommand — delegates to envman CLI
+    if (args[0] === "envman") {
+        // Re-write process.argv so envman sees its own args
+        process.argv = [process.argv[0], "envman", ...args.slice(1)];
+        await import("./envman/cli.js");
+        return;
+    }
+    // Handle init command
+    if (args[0] === "init") {
+        const importIdx = args.indexOf("--import");
+        const importPath = importIdx !== -1 ? args[importIdx + 1] : undefined;
+        const createFlag = args.includes("--create");
+        await handleInitCommand({ importPath, create: createFlag });
+        process.exit(0);
+    }
+    // Handle reset command
+    if (args[0] === "reset") {
+        const force = args.includes("--force") || args.includes("-f");
+        await handleResetCommand({ force });
+        process.exit(0);
+    }
+    // Handle build command
+    if (args[0] === "build") {
+        await handleBuildCommand(detectMobileProjectRoot);
+        process.exit(0);
+    }
+    // Handle secrets command
+    if (args[0] === "secrets") {
+        const subCommand = args[1];
+        if (subCommand === "upload") {
+            const envFlagIdx = args.findIndex((a) => a === '--env' || a === '-e');
+            const envName = envFlagIdx !== -1 ? args[envFlagIdx + 1] : 'cibuild';
+            const repoFlagIdx = args.findIndex((a) => a === '--repo' || a === '-r');
+            const repo = repoFlagIdx !== -1 ? args[repoFlagIdx + 1] : undefined;
+            const dryRun = args.includes('--dry-run');
+            await handleSecretsUploadCommand({ envName, repo, dryRun });
+            process.exit(0);
+        }
+        if (subCommand === "sync-workflow") {
+            const pathFlagIdx = args.findIndex((a) => a === '--path' || a === '-p');
+            let workflowPath = pathFlagIdx !== -1 ? args[pathFlagIdx + 1] : undefined;
+            if (!workflowPath) {
+                // Auto-discover workflow files
+                const ghWorkflowDir = resolve(process.cwd(), '.github', 'workflows');
+                const discoveredFiles = [];
+                if (existsSync(ghWorkflowDir)) {
+                    try {
+                        const entries = readdirSync(ghWorkflowDir);
+                        for (const entry of entries) {
+                            if (entry.endsWith('.yml') || entry.endsWith('.yaml')) {
+                                discoveredFiles.push(`.github/workflows/${entry}`);
+                            }
+                        }
+                    }
+                    catch { /* ignore read errors */ }
+                }
+                const choices = discoveredFiles.map((f) => ({
+                    title: f,
+                    value: f,
+                }));
+                choices.push({ title: 'Enter path manually…', value: '__manual__' });
+                if (choices.length === 1) {
+                    // Only the manual option — no files found
+                    console.log('No workflow files found in .github/workflows/\n');
+                }
+                const { selected } = await prompts({
+                    type: 'select',
+                    name: 'selected',
+                    message: 'Select a workflow file to sync secrets into:',
+                    choices,
+                });
+                if (!selected) {
+                    process.exit(0);
+                }
+                if (selected === '__manual__') {
+                    const { manualPath } = await prompts({
+                        type: 'text',
+                        name: 'manualPath',
+                        message: 'Enter the path to the workflow YAML file:',
+                        validate: (v) => v.trim() ? true : 'Path is required',
+                    });
+                    if (!manualPath) {
+                        process.exit(0);
+                    }
+                    workflowPath = manualPath;
+                }
+                else {
+                    workflowPath = selected;
+                }
+            }
+            const dryRun = args.includes('--dry-run');
+            await handleSecretsSyncWorkflowCommand({ workflowPath: resolve(process.cwd(), workflowPath), dryRun });
+            process.exit(0);
+        }
+        if (subCommand !== "add") {
+            console.error("Error: Unknown secrets subcommand. Available: add, upload, sync-workflow");
+            console.error("Usage: ci secrets add <var_name> <pipeline_path> [--file <file>] [--workflow <name>]");
+            console.error("       ci secrets upload [--env <name>] [--repo <owner/repo>] [--dry-run]");
+            console.error("       ci secrets sync-workflow --path <workflow.yml> [--dry-run]");
+            process.exit(1);
+        }
+        // ci secrets add <var_name> <pipeline_path> [--file <file>] [--workflow <name>]
+        const varName = args[2];
+        const pipelinePath = args[3];
+        if (!varName || !pipelinePath) {
+            console.error("Error: Variable name and pipeline path are required");
+            console.error("Usage: ci secrets add <var_name> <pipeline_path> [--file <file>] [-w <workflow>]");
+            console.error("\nExamples:");
+            console.error("  ci secrets add SLACK_CHANNEL bitrise.yml                              # prompted interactively");
+            console.error("  ci secrets add GOOGLE_SERVICES_JSON bitrise.yml --file google-services.json  # read from file");
+            process.exit(1);
+        }
+        const resolvedPath = resolve(process.cwd(), pipelinePath);
+        if (!existsSync(resolvedPath)) {
+            console.error(`Error: Pipeline file not found: ${resolvedPath}`);
+            process.exit(1);
+        }
+        // Only works with YAML files
+        const fileExt = extname(resolvedPath).toLowerCase();
+        const isYAML = fileExt === '.yml' || fileExt === '.yaml';
+        if (!isYAML) {
+            console.error("Error: secrets command only works with YAML pipeline files (.yml, .yaml)");
+            process.exit(1);
+        }
+        // Parse --file / -f flag
+        const fileFlagIdx = args.findIndex((a) => a === '--file' || a === '-f');
+        const secretFilePath = fileFlagIdx !== -1 ? args[fileFlagIdx + 1] : undefined;
+        // Parse -w / --workflow flag
+        const workflowFlagIdx = args.findIndex((a) => a === '-w' || a === '--workflow');
+        const workflowArg = workflowFlagIdx !== -1 ? args[workflowFlagIdx + 1] : undefined;
+        try {
+            const secretsManager = new SecretsManager();
+            console.log('\n╔═══════════════════════════════════════════════════════════════════╗');
+            console.log('║  ADD SECRET                                                       ║');
+            console.log('╚═══════════════════════════════════════════════════════════════════╝\n');
+            console.log(`Variable: ${varName}`);
+            console.log(`Location: ${secretsManager.getSecretsFilePath()}`);
+            // Check if this variable already exists
+            const existingSecretId = secretsManager.getSecretIdByName(varName);
+            if (existingSecretId) {
+                console.log(`\nℹ️  This variable already exists in your secrets file.`);
+                const confirmResponse = await prompts({
+                    type: 'confirm',
+                    name: 'value',
+                    message: 'Update existing value?',
+                    initial: true,
+                });
+                if (!confirmResponse.value) {
+                    console.log('\n❌ Cancelled');
+                    process.exit(0);
+                }
+            }
+            let secretValue;
+            if (secretFilePath) {
+                // Read value from file
+                const resolvedFilePath = resolve(process.cwd(), secretFilePath);
+                if (!existsSync(resolvedFilePath)) {
+                    console.error(`\nError: File not found: ${resolvedFilePath}`);
+                    process.exit(1);
+                }
+                secretValue = readFileSync(resolvedFilePath, 'utf-8');
+                console.log(`\nReading value from: ${secretFilePath}`);
+            }
+            else {
+                // Collect value interactively via readline (handles multiline paste cleanly)
+                const { createInterface } = await import('node:readline');
+                console.log(`\n  Enter value for ${varName}`);
+                console.log('  Paste content, then type . on its own line and press Enter:\n');
+                if (process.stdin.isTTY) {
+                    try {
+                        process.stdin.setRawMode(false);
+                    }
+                    catch { /* ignore */ }
+                }
+                process.stdin.resume();
+                secretValue = await new Promise((res) => {
+                    const rl = createInterface({ input: process.stdin, terminal: false });
+                    const lines = [];
+                    rl.on('line', (line) => {
+                        if (line.trim() === '.') {
+                            rl.close();
+                            return;
+                        }
+                        lines.push(line);
+                    });
+                    rl.once('close', () => { process.stdin.pause(); res(lines.join('\n')); });
+                    rl.on('SIGINT', () => { rl.close(); res(''); });
+                });
+                if (!secretValue.trim()) {
+                    console.log('\n❌ Cancelled');
+                    process.exit(0);
+                }
+            }
+            secretsManager.storeSecret(varName, secretValue, workflowArg);
+            console.log(`\n✅ Secret stored: ${varName}${workflowArg ? ` (workflow: ${workflowArg})` : ' (global)'}`);
+            console.log(`   Location: ${secretsManager.getSecretsFilePath()}`);
+            console.log(`\n💡 This value will be loaded automatically when you run the pipeline.\n`);
+            process.exit(0);
+        }
+        catch (error) {
+            console.error("\n✗ Failed to add secret:");
+            console.error(error instanceof Error ? error.message : String(error));
+            process.exit(1);
+        }
+    }
+    // Handle edit command
+    if (args[0] === "edit") {
+        const pipelineIndex = args.findIndex((arg) => arg === "--pipeline" || arg === "-p");
+        let pipelinePath;
+        if (pipelineIndex !== -1 && args[pipelineIndex + 1]) {
+            pipelinePath = resolve(process.cwd(), args[pipelineIndex + 1]);
+        }
+        else if (args[1] && !args[1].startsWith("-")) {
+            pipelinePath = resolve(process.cwd(), args[1]);
+        }
+        else {
+            console.error("Error: Pipeline path is required");
+            console.error("Usage: ci edit <path> [-w <name>]");
+            process.exit(1);
+        }
+        const workflowIndex = args.findIndex((arg) => arg === "--workflow" || arg === "-w");
+        const workflowName = workflowIndex !== -1 && args[workflowIndex + 1]
+            ? args[workflowIndex + 1]
+            : undefined;
+        if (!existsSync(pipelinePath)) {
+            console.error(`Error: Pipeline file not found: ${pipelinePath}`);
+            process.exit(1);
+        }
+        const fileExt = extname(pipelinePath).toLowerCase();
+        if (fileExt !== ".yml" && fileExt !== ".yaml") {
+            console.error("Error: edit only works with YAML pipeline files (.yml, .yaml)");
+            process.exit(1);
+        }
+        try {
+            await handleEditCommand(pipelinePath, workflowName);
+            process.exit(0);
+        }
+        catch (error) {
+            console.error("\n✗ Edit failed:");
+            console.error(error instanceof Error ? error.message : String(error));
+            process.exit(1);
+        }
+    }
+    // Check for validate command or --validate-only flag
+    const isValidateCommand = args[0] === "validate";
+    const hasValidateOnlyFlag = args.includes("--validate-only");
+    if (isValidateCommand || (args[0] === "run" && hasValidateOnlyFlag)) {
+        // Support both: ci validate <path> and ci validate --pipeline <path>
+        const pipelineIndex = args.findIndex((arg) => arg === "--pipeline" || arg === "-p");
+        let pipelinePath;
+        if (pipelineIndex !== -1 && args[pipelineIndex + 1]) {
+            pipelinePath = resolve(process.cwd(), args[pipelineIndex + 1]);
+        }
+        else if (args[1] && !args[1].startsWith("-")) {
+            // Second argument is the path (e.g., ci validate <path>)
+            pipelinePath = resolve(process.cwd(), args[1]);
+        }
+        else {
+            console.error("Error: Pipeline path is required");
+            console.error("Usage: ci validate <path> [--workflow <name>]");
+            console.error("   or: ci validate --pipeline <path> [--workflow <name>]");
+            process.exit(1);
+        }
+        const workflowIndex = args.findIndex((arg) => arg === "--workflow" || arg === "-w");
+        const workflowName = workflowIndex !== -1 && args[workflowIndex + 1]
+            ? args[workflowIndex + 1]
+            : undefined;
+        if (!existsSync(pipelinePath)) {
+            console.error(`Error: Pipeline file not found: ${pipelinePath}`);
+            process.exit(1);
+        }
+        const fileExt = extname(pipelinePath).toLowerCase();
+        const isYAML = fileExt === '.yml' || fileExt === '.yaml';
+        if (!isYAML) {
+            console.error("Error: validate only works with YAML pipeline files (.yml, .yaml)");
+            process.exit(1);
+        }
+        try {
+            const config = loadConfig();
+            const yamlPipeline = loadYAMLPipeline(pipelinePath);
+            // Prompt for workflow if not specified
+            let selectedWorkflow = workflowName;
+            if (!selectedWorkflow) {
+                const workflows = Object.keys(yamlPipeline.workflows);
+                selectedWorkflow = await promptForWorkflow(workflows);
+                if (!selectedWorkflow) {
+                    process.exit(1);
+                }
+            }
+            console.log(`🔍 Validating workflow: ${selectedWorkflow}`);
+            console.log(`   Pipeline: ${pipelinePath}\n`);
+            const validator = new StepValidator(yamlPipeline, selectedWorkflow, config, pipelinePath);
+            const result = await validator.validateWorkflow();
+            console.log(formatValidationResult(result));
+            process.exit(result.valid ? 0 : 1);
+        }
+        catch (error) {
+            console.error("\n✗ Validation failed:");
+            console.error(error instanceof Error ? error.message : String(error));
+            process.exit(1);
+        }
+    }
+    if (args[0] === "detect-platform") {
+        // Support both: ci detect-platform <path> and ci detect-platform --pipeline <path>
+        const pipelineIndex = args.findIndex((arg) => arg === "--pipeline" || arg === "-p");
+        let pipelinePath;
+        if (pipelineIndex !== -1 && args[pipelineIndex + 1]) {
+            pipelinePath = resolve(process.cwd(), args[pipelineIndex + 1]);
+        }
+        else if (args[1] && !args[1].startsWith("-")) {
+            // Second argument is the path (e.g., ci detect-platform <path>)
+            pipelinePath = resolve(process.cwd(), args[1]);
+        }
+        else {
+            console.error("Error: Pipeline path is required");
+            console.error("Usage: ci detect-platform <path> [--workflow <name>]");
+            console.error("   or: ci detect-platform --pipeline <path> [--workflow <name>]");
+            process.exit(1);
+        }
+        // Check for --workflow parameter (optional)
+        const workflowIndex = args.findIndex((arg) => arg === "--workflow" || arg === "-w");
+        const workflowName = workflowIndex !== -1 && args[workflowIndex + 1]
+            ? args[workflowIndex + 1]
+            : undefined;
+        if (!existsSync(pipelinePath)) {
+            console.error(`Error: Pipeline file not found: ${pipelinePath}`);
+            process.exit(1);
+        }
+        // Only works with YAML files
+        const fileExt = extname(pipelinePath).toLowerCase();
+        const isYAML = fileExt === '.yml' || fileExt === '.yaml';
+        if (!isYAML) {
+            console.error("Error: detect-platform only works with YAML pipeline files (.yml, .yaml)");
+            process.exit(1);
+        }
+        try {
+            const yamlPipeline = loadYAMLPipeline(pipelinePath);
+            // Prompt for workflow if not specified
+            let selectedWorkflow = workflowName;
+            if (!selectedWorkflow) {
+                const workflows = Object.keys(yamlPipeline.workflows);
+                selectedWorkflow = await promptForWorkflow(workflows);
+                if (!selectedWorkflow) {
+                    process.exit(1);
+                }
+            }
+            const platformInfo = detectPlatformInfo(yamlPipeline, selectedWorkflow);
+            console.log(`\nPlatform Detection Results:`);
+            console.log(`─────────────────────────────`);
+            console.log(`Pipeline:      ${pipelinePath}`);
+            console.log(`Workflow:      ${selectedWorkflow}`);
+            console.log(`Platform:      ${platformInfo.platform}`);
+            console.log(`Stack:         ${platformInfo.stack || 'N/A'}`);
+            console.log(`Machine Type:  ${platformInfo.machineType || 'N/A'}`);
+            console.log();
+            process.exit(0);
+        }
+        catch (error) {
+            console.error("\n✗ Platform detection failed:");
+            console.error(error instanceof Error ? error.message : String(error));
+            process.exit(1);
+        }
+    }
+    else if (args[0] === "run") {
+        // Support both: ci run <path> and ci run --pipeline <path>
+        const pipelineIndex = args.findIndex((arg) => arg === "--pipeline" || arg === "-p");
+        let pipelinePath;
+        if (pipelineIndex !== -1 && args[pipelineIndex + 1]) {
+            pipelinePath = resolve(process.cwd(), args[pipelineIndex + 1]);
+        }
+        else if (args[1] && !args[1].startsWith("-")) {
+            // Second argument is the path (e.g., ci run <path>)
+            pipelinePath = resolve(process.cwd(), args[1]);
+        }
+        else {
+            // No path given — check for .ci/pipelines/
+            const pipelinesDir = resolve(process.cwd(), ".ci", "pipelines");
+            if (!existsSync(pipelinesDir)) {
+                console.error("Project not initialised. Run 'ci init' first.");
+                process.exit(1);
+            }
+            const yamlFiles = readdirSync(pipelinesDir).filter((f) => f.endsWith(".yml") || f.endsWith(".yaml"));
+            if (yamlFiles.length === 0) {
+                console.error("No pipelines found in .ci/pipelines/. Run 'ci init' to import one.");
+                process.exit(1);
+            }
+            if (yamlFiles.length === 1) {
+                pipelinePath = resolve(pipelinesDir, yamlFiles[0]);
+                console.log(`Using pipeline: ${yamlFiles[0]}`);
+            }
+            else {
+                const { selected } = await prompts({
+                    type: "select",
+                    name: "selected",
+                    message: "Select a pipeline to run:",
+                    choices: yamlFiles.map((f) => ({ title: f, value: resolve(pipelinesDir, f) })),
+                });
+                if (!selected) {
+                    console.log("Cancelled.");
+                    process.exit(0);
+                }
+                pipelinePath = selected;
+            }
+        }
+        // Check for --workflow parameter (optional, only used for YAML)
+        const workflowIndex = args.findIndex((arg) => arg === "--workflow" || arg === "-w");
+        const workflowName = workflowIndex !== -1 && args[workflowIndex + 1]
+            ? args[workflowIndex + 1]
+            : undefined;
+        // Check for --production, --skip-validation, and --local flags
+        const isProduction = args.includes("--production");
+        const skipValidation = args.includes("--skip-validation");
+        const isLocal = args.includes("--local");
+        if (!existsSync(pipelinePath)) {
+            console.error(`Error: Pipeline file not found: ${pipelinePath}`);
+            process.exit(1);
+        }
+        try {
+            const config = loadConfig();
+            config.local = isLocal;
+            const runner = new PipelineRunner(config);
+            // Detect file type based on extension
+            const fileExt = extname(pipelinePath).toLowerCase();
+            const isYAML = fileExt === '.yml' || fileExt === '.yaml';
+            const isJavaScriptModule = fileExt === '.ts' || fileExt === '.js';
+            let pipeline;
+            if (isYAML) {
+                // Load YAML pipeline
+                console.log(`Loading YAML pipeline: ${pipelinePath}`);
+                const yamlPipeline = loadYAMLPipeline(pipelinePath);
+                // Prompt for workflow if not specified
+                let selectedWorkflow = workflowName;
+                if (!selectedWorkflow) {
+                    const workflows = Object.keys(yamlPipeline.workflows);
+                    selectedWorkflow = await promptForWorkflow(workflows);
+                    if (!selectedWorkflow) {
+                        process.exit(1);
+                    }
+                }
+                else {
+                    console.log(`Using workflow: ${workflowName}`);
+                }
+                // Run pre-execution validation and collect missing variables (unless skipped)
+                if (skipValidation) {
+                    console.log(`\n⏭️  Skipping validation (--skip-validation flag set)\n`);
+                }
+                else {
+                    const canProceed = await promptForMissingVariables(yamlPipeline, selectedWorkflow, config, pipelinePath);
+                    if (!canProceed) {
+                        console.error("\n✗ Pipeline cannot run. Fix the errors above before continuing.");
+                        process.exit(1);
+                    }
+                }
+                // Check if production mode
+                if (isProduction) {
+                    console.log("═".repeat(60));
+                    console.log("🚀 PRODUCTION MODE");
+                    console.log("═".repeat(60));
+                    console.log("\nValidation passed. Pipeline would be dispatched to remote runner.");
+                    console.log("(Remote runner integration not yet implemented)\n");
+                    console.log("For now, use without --production flag to run locally.\n");
+                    process.exit(0);
+                }
+                // Convert and run locally (development mode)
+                const conversionResult = await convertYAMLWithSecrets(yamlPipeline, {
+                    config,
+                    workflowName: selectedWorkflow,
+                    yamlFilePath: pipelinePath,
+                    interactive: true,
+                });
+                pipeline = conversionResult.pipeline;
+                // Run pipeline with warnings
+                await runner.runPipeline(pipeline, conversionResult.warnings, conversionResult.skippedSteps);
+            }
+            else if (isJavaScriptModule) {
+                // Load TypeScript/JavaScript pipeline module
+                console.log(`Loading pipeline: ${pipelinePath}`);
+                const pipelineUrl = pathToFileURL(pipelinePath).href;
+                const pipelineModule = await import(pipelineUrl);
+                pipeline = pipelineModule.default;
+                if (!pipeline || typeof pipeline !== "object") {
+                    throw new Error("Pipeline file must export a default PipelineDef object");
+                }
+                // Run pipeline without warnings (TypeScript pipelines don't have warnings)
+                await runner.runPipeline(pipeline);
+            }
+            else {
+                throw new Error(`Unsupported pipeline file format: ${fileExt}\n` +
+                    `Supported formats: .yml, .yaml, .ts, .js`);
+            }
+            console.log("\n✓ All steps completed successfully!\n");
+            process.exit(0);
+        }
+        catch (error) {
+            console.error("\n✗ Pipeline failed:");
+            console.error(error instanceof Error ? error.message : String(error));
+            process.exit(1);
+        }
+    }
+    else {
+        console.error(`Unknown command: ${args[0]}`);
+        console.error("Run 'ci --help' for usage information");
+        process.exit(1);
+    }
+}
+main();
+//# sourceMappingURL=cli.js.map