@invarn/cibuild 1.4.1 → 1.4.2

package/dist/src/cli.js

@@ -1,439 +1,20 @@
 #!/usr/bin/env node
 import { resolve, extname } from "node:path";
-import { pathToFileURL } from "node:url";
-import { existsSync, readdirSync, mkdirSync, copyFileSync, readFileSync, writeFileSync, appendFileSync, statSync } from "node:fs";
-import { homedir } from "node:os";
-import { execSync } from "node:child_process";
+import { existsSync, readdirSync, readFileSync } from "node:fs";
 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/KMM: 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)));
-    // KMM: Gradle project with an iosApp/ directory or shared/ multiplatform module
-    // Must check before plain Android since KMM also has Gradle files
-    if (hasAndroidIndicator) {
-        const kmmIndicators = ["iosApp", "shared", "composeApp"];
-        const hasKmmIndicator = kmmIndicators.some((d) => {
-            const fullPath = resolve(dir, d);
-            try {
-                return existsSync(fullPath) && statSync(fullPath).isDirectory();
-            }
-            catch {
-                return false;
-            }
-        });
-        if (hasKmmIndicator) {
-            return "kmm";
-        }
-        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, iOS, or KMM project.");
-        console.error("\nAndroid/KMM projects must contain one of:");
-        console.error("  build.gradle, build.gradle.kts, settings.gradle, settings.gradle.kts, gradlew");
-        console.error("\nKMM projects additionally need: iosApp/, shared/, or composeApp/ directory");
-        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);
-        }
-    }
-    const projectTypeLabel = projectType === "kmm" ? "KMM (Kotlin Multiplatform)" : projectType === "android" ? "Android" : "iOS";
-    console.log(`\nDetected project type: ${projectTypeLabel}`);
-    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 : projectType === "kmm" ? [...androidDependencies, ...iosDependencies] : 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" || meta?.platform === "kmm") {
-            importedPlatform = meta.platform === "kmm" ? "ios" : 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;
-}
+import { handleInitCommand } from "./commands/init.js";
+import { handleValidateCommand } from "./commands/validate.js";
+import { handleRunCommand } from "./commands/run.js";
+import { handleDetectProjectCommand } from "./commands/detect-project.js";
+import { handleDetectPlatformCommand } from "./commands/detect-platform.js";
+import { detectMobileProjectRoot } from "./shared/detect-project.js";
 async function main() {
     const args = process.argv.slice(2);
     if (args[0] === "--version" || args[0] === "-v") {
@@ -505,9 +86,8 @@ Examples:
     }
     // Handle detect-project command
     if (args[0] === "detect-project") {
-        const projectType = detectMobileProjectRoot(process.cwd());
-        console.log(projectType ?? "unknown");
-        process.exit(projectType ? 0 : 1);
+        await handleDetectProjectCommand();
+        return;
     }
     // Handle init command
     if (args[0] === "init") {
@@ -745,267 +325,65 @@ Examples:
             process.exit(1);
         }
     }
-    // Check for validate command or --validate-only flag
+    // Resolve --pipeline / -p flag OR a positional path (ci <cmd> <path>).
+    const resolvePipelinePath = (usage) => {
+        const flagIdx = args.findIndex((a) => a === "--pipeline" || a === "-p");
+        if (flagIdx !== -1 && args[flagIdx + 1]) {
+            return resolve(process.cwd(), args[flagIdx + 1]);
+        }
+        if (args[1] && !args[1].startsWith("-")) {
+            return resolve(process.cwd(), args[1]);
+        }
+        console.error("Error: Pipeline path is required");
+        for (const line of usage)
+            console.error(line);
+        process.exit(1);
+    };
+    const resolveWorkflowFlag = () => {
+        const idx = args.findIndex((a) => a === "--workflow" || a === "-w");
+        return idx !== -1 && args[idx + 1] ? args[idx + 1] : undefined;
+    };
+    // Handle validate command (and legacy `ci run <path> --validate-only`).
     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);
-        }
+        const pipelinePath = resolvePipelinePath([
+            "Usage: ci validate <path> [--workflow <name>]",
+            "   or: ci validate --pipeline <path> [--workflow <name>]",
+        ]);
+        await handleValidateCommand({ pipelinePath, workflow: resolveWorkflowFlag() });
+        return;
     }
     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);
-        }
+        const pipelinePath = resolvePipelinePath([
+            "Usage: ci detect-platform <path> [--workflow <name>]",
+            "   or: ci detect-platform --pipeline <path> [--workflow <name>]",
+        ]);
+        await handleDetectPlatformCommand({ pipelinePath, workflow: resolveWorkflowFlag() });
+        return;
     }
-    else if (args[0] === "run") {
-        // Support both: ci run <path> and ci run --pipeline <path>
-        const pipelineIndex = args.findIndex((arg) => arg === "--pipeline" || arg === "-p");
+    if (args[0] === "run") {
+        // Path is optional for `ci run` — handler discovers from .ci/pipelines/.
+        const flagIdx = args.findIndex((a) => a === "--pipeline" || a === "-p");
         let pipelinePath;
-        if (pipelineIndex !== -1 && args[pipelineIndex + 1]) {
-            pipelinePath = resolve(process.cwd(), args[pipelineIndex + 1]);
+        if (flagIdx !== -1 && args[flagIdx + 1]) {
+            pipelinePath = resolve(process.cwd(), args[flagIdx + 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);
+        await handleRunCommand({
+            pipelinePath,
+            workflow: resolveWorkflowFlag(),
+            production: args.includes("--production"),
+            skipValidation: args.includes("--skip-validation"),
+            local: args.includes("--local"),
+        });
+        return;
     }
+    console.error(`Unknown command: ${args[0]}`);
+    console.error("Run 'ci --help' for usage information");
+    process.exit(1);
 }
 main();
 //# sourceMappingURL=cli.js.map