@invarn/cibuild 1.4.0 → 1.4.2

package/dist/src/commands/detect-platform.d.ts

@@ -0,0 +1,13 @@
+export interface DetectPlatformOptions {
+    pipelinePath: string;
+    workflow?: string;
+}
+/**
+ * Detect the target platform / stack / machine type for a workflow in a
+ * YAML pipeline. Mirrors `ci detect-platform <path>`.
+ *
+ * Exits the process on error or cancellation (matches legacy behavior so
+ * exit codes propagate cleanly to the caller).
+ */
+export declare function handleDetectPlatformCommand(opts: DetectPlatformOptions): Promise<void>;
+//# sourceMappingURL=detect-platform.d.ts.map

package/dist/src/commands/detect-platform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detect-platform.d.ts","sourceRoot":"","sources":["../../../src/commands/detect-platform.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,qBAAqB;IACpC,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;GAMG;AACH,wBAAsB,2BAA2B,CAC/C,IAAI,EAAE,qBAAqB,GAC1B,OAAO,CAAC,IAAI,CAAC,CA2Cf"}

package/dist/src/commands/detect-platform.js

@@ -0,0 +1,51 @@
+import { existsSync } from "node:fs";
+import { extname } from "node:path";
+import { loadYAMLPipeline } from "../yaml/parser.js";
+import { detectPlatformInfo } from "../yaml/platform-detector.js";
+import { promptForWorkflow } from "../shared/prompts.js";
+/**
+ * Detect the target platform / stack / machine type for a workflow in a
+ * YAML pipeline. Mirrors `ci detect-platform <path>`.
+ *
+ * Exits the process on error or cancellation (matches legacy behavior so
+ * exit codes propagate cleanly to the caller).
+ */
+export async function handleDetectPlatformCommand(opts) {
+    const { pipelinePath } = opts;
+    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: detect-platform only works with YAML pipeline files (.yml, .yaml)");
+        process.exit(1);
+    }
+    try {
+        const yamlPipeline = loadYAMLPipeline(pipelinePath);
+        let selectedWorkflow = opts.workflow;
+        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);
+    }
+}
+//# sourceMappingURL=detect-platform.js.map

package/dist/src/commands/detect-project.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Print the detected mobile project type (android | ios | kmm) to stdout,
+ * or `unknown` if no mobile project is detected. Exits 0 on success, 1
+ * when nothing matched.
+ */
+export declare function handleDetectProjectCommand(): Promise<void>;
+//# sourceMappingURL=detect-project.d.ts.map

package/dist/src/commands/detect-project.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detect-project.d.ts","sourceRoot":"","sources":["../../../src/commands/detect-project.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,wBAAsB,0BAA0B,IAAI,OAAO,CAAC,IAAI,CAAC,CAIhE"}

package/dist/src/commands/detect-project.js

@@ -0,0 +1,12 @@
+import { detectMobileProjectRoot } from "../shared/detect-project.js";
+/**
+ * Print the detected mobile project type (android | ios | kmm) to stdout,
+ * or `unknown` if no mobile project is detected. Exits 0 on success, 1
+ * when nothing matched.
+ */
+export async function handleDetectProjectCommand() {
+    const projectType = detectMobileProjectRoot(process.cwd());
+    console.log(projectType ?? "unknown");
+    process.exit(projectType ? 0 : 1);
+}
+//# sourceMappingURL=detect-project.js.map

package/dist/src/commands/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @invarn/cibuild/commands — interactive CLI command handlers.
+ *
+ * Public entry point for callers that want to invoke cibuild's commands
+ * programmatically (e.g. the Invarn CLI wrapping these under `invarn
+ * local <cmd>`). Each handler owns its own process-exit semantics to
+ * preserve legacy behavior — wrap with a try/catch + process.exit in the
+ * caller if you need custom error handling.
+ *
+ * For non-interactive library primitives (parser, runner, step registry)
+ * import from `@invarn/cibuild/lib` instead.
+ */
+export { handleInitCommand } from "./init.js";
+export type { InitOptions } from "./init.js";
+export { handleValidateCommand } from "./validate.js";
+export type { ValidateOptions } from "./validate.js";
+export { handleRunCommand } from "./run.js";
+export type { RunOptions } from "./run.js";
+export { handleDetectProjectCommand } from "./detect-project.js";
+export { handleDetectPlatformCommand } from "./detect-platform.js";
+export type { DetectPlatformOptions } from "./detect-platform.js";
+export { handleBuildCommand } from "./build.js";
+export { handleResetCommand } from "./reset.js";
+export { detectMobileProjectRoot } from "../shared/detect-project.js";
+export type { MobileProjectType } from "../shared/detect-project.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/commands/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAC9C,YAAY,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAE7C,OAAO,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AACtD,YAAY,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAErD,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAC5C,YAAY,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAE3C,OAAO,EAAE,0BAA0B,EAAE,MAAM,qBAAqB,CAAC;AAEjE,OAAO,EAAE,2BAA2B,EAAE,MAAM,sBAAsB,CAAC;AACnE,YAAY,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAElE,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAChD,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAGhD,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AACtE,YAAY,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAC"}

package/dist/src/commands/index.js

@@ -0,0 +1,22 @@
+/**
+ * @invarn/cibuild/commands — interactive CLI command handlers.
+ *
+ * Public entry point for callers that want to invoke cibuild's commands
+ * programmatically (e.g. the Invarn CLI wrapping these under `invarn
+ * local <cmd>`). Each handler owns its own process-exit semantics to
+ * preserve legacy behavior — wrap with a try/catch + process.exit in the
+ * caller if you need custom error handling.
+ *
+ * For non-interactive library primitives (parser, runner, step registry)
+ * import from `@invarn/cibuild/lib` instead.
+ */
+export { handleInitCommand } from "./init.js";
+export { handleValidateCommand } from "./validate.js";
+export { handleRunCommand } from "./run.js";
+export { handleDetectProjectCommand } from "./detect-project.js";
+export { handleDetectPlatformCommand } from "./detect-platform.js";
+export { handleBuildCommand } from "./build.js";
+export { handleResetCommand } from "./reset.js";
+// Helpers useful for callers that implement their own variations.
+export { detectMobileProjectRoot } from "../shared/detect-project.js";
+//# sourceMappingURL=index.js.map

package/dist/src/commands/init.d.ts

@@ -0,0 +1,13 @@
+export interface InitOptions {
+    importPath?: string;
+    create?: boolean;
+}
+/**
+ * Check dependencies, then either import an existing YAML pipeline or
+ * scaffold a new one via `handleBuildCommand`. Mirrors `ci init`.
+ *
+ * Exits the process with a non-zero code on any unrecoverable error
+ * (missing deps, unreadable project, cancelled prompts).
+ */
+export declare function handleInitCommand(opts?: InitOptions): Promise<void>;
+//# sourceMappingURL=init.d.ts.map

package/dist/src/commands/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../src/commands/init.ts"],"names":[],"mappings":"AAWA,MAAM,WAAW,WAAW;IAC1B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAUD;;;;;;GAMG;AACH,wBAAsB,iBAAiB,CAAC,IAAI,GAAE,WAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CA0Q7E"}

package/dist/src/commands/init.js

@@ -0,0 +1,262 @@
+import { execSync } from "node:child_process";
+import { copyFileSync, existsSync, mkdirSync, readdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { resolve } from "node:path";
+import prompts from "prompts";
+import { detectMobileProjectRoot } from "../shared/detect-project.js";
+import { ensureCiBuildGitignoreEntries } from "../shared/gitignore.js";
+import { loadYAMLPipeline } from "../yaml/parser.js";
+import { handleBuildCommand } from "./build.js";
+import { generateGitHubActionsWorkflow } from "./github-workflow.js";
+/**
+ * Check dependencies, then either import an existing YAML pipeline or
+ * scaffold a new one via `handleBuildCommand`. Mirrors `ci init`.
+ *
+ * Exits the process with a non-zero code on any unrecoverable error
+ * (missing deps, unreadable project, cancelled prompts).
+ */
+export async function handleInitCommand(opts = {}) {
+    const cwd = process.cwd();
+    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);
+    }
+    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`,
+                    `${homedir()}/Android/Sdk`,
+                    "/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();
+    let action;
+    if (opts.importPath) {
+        action = "import";
+    }
+    else if (opts.create) {
+        action = "create";
+    }
+    else {
+        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);
+    }
+    ensureCiBuildGitignoreEntries(cwd);
+    if (action === "create") {
+        await handleBuildCommand(detectMobileProjectRoot, {
+            createPipelinesDir: true,
+            nonInteractive: true,
+        });
+        process.exit(0);
+    }
+    // Import flow
+    let resolvedYaml;
+    if (opts.importPath) {
+        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 {
+        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}`);
+    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 in generator.
+    }
+    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("");
+}
+//# sourceMappingURL=init.js.map

package/dist/src/commands/run.d.ts

@@ -0,0 +1,22 @@
+export interface RunOptions {
+    /**
+     * Absolute path to the pipeline file. If omitted, the handler looks
+     * inside `./.ci/pipelines/` and prompts when multiple files exist.
+     */
+    pipelinePath?: string;
+    workflow?: string;
+    validateOnly?: boolean;
+    production?: boolean;
+    skipValidation?: boolean;
+    local?: boolean;
+}
+/**
+ * Run a pipeline locally. Mirrors `ci run <path>`.
+ *
+ * - `.yml` / `.yaml` → parse, validate, optionally prompt for missing
+ *   env vars, then execute via `PipelineRunner`.
+ * - `.ts` / `.js`    → dynamic-import the module, use its default export
+ *   as the `PipelineDef`, then execute.
+ */
+export declare function handleRunCommand(opts?: RunOptions): Promise<void>;
+//# sourceMappingURL=run.d.ts.map

package/dist/src/commands/run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../../src/commands/run.ts"],"names":[],"mappings":"AAcA,MAAM,WAAW,UAAU;IACzB;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;;;;;;GAOG;AACH,wBAAsB,gBAAgB,CAAC,IAAI,GAAE,UAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAuI3E"}

package/dist/src/commands/run.js

@@ -0,0 +1,131 @@
+import { existsSync, readdirSync } from "node:fs";
+import { extname, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+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 { promptForWorkflow, promptForMissingVariables, } from "../shared/prompts.js";
+/**
+ * Run a pipeline locally. Mirrors `ci run <path>`.
+ *
+ * - `.yml` / `.yaml` → parse, validate, optionally prompt for missing
+ *   env vars, then execute via `PipelineRunner`.
+ * - `.ts` / `.js`    → dynamic-import the module, use its default export
+ *   as the `PipelineDef`, then execute.
+ */
+export async function handleRunCommand(opts = {}) {
+    const cwd = process.cwd();
+    // Resolve the pipeline path, optionally discovering from .ci/pipelines/.
+    let pipelinePath;
+    if (opts.pipelinePath) {
+        pipelinePath = resolve(cwd, opts.pipelinePath);
+    }
+    else {
+        const pipelinesDir = resolve(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;
+        }
+    }
+    if (!existsSync(pipelinePath)) {
+        console.error(`Error: Pipeline file not found: ${pipelinePath}`);
+        process.exit(1);
+    }
+    try {
+        const config = loadConfig();
+        config.local = opts.local ?? false;
+        const runner = new PipelineRunner(config);
+        const fileExt = extname(pipelinePath).toLowerCase();
+        const isYAML = fileExt === ".yml" || fileExt === ".yaml";
+        const isJavaScriptModule = fileExt === ".ts" || fileExt === ".js";
+        let pipeline;
+        if (isYAML) {
+            console.log(`Loading YAML pipeline: ${pipelinePath}`);
+            const yamlPipeline = loadYAMLPipeline(pipelinePath);
+            let selectedWorkflow = opts.workflow;
+            if (!selectedWorkflow) {
+                const workflows = Object.keys(yamlPipeline.workflows);
+                selectedWorkflow = await promptForWorkflow(workflows);
+                if (!selectedWorkflow) {
+                    process.exit(1);
+                }
+            }
+            else {
+                console.log(`Using workflow: ${selectedWorkflow}`);
+            }
+            if (opts.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);
+                }
+            }
+            if (opts.production) {
+                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);
+            }
+            const conversionResult = await convertYAMLWithSecrets(yamlPipeline, {
+                config,
+                workflowName: selectedWorkflow,
+                yamlFilePath: pipelinePath,
+                interactive: true,
+            });
+            pipeline = conversionResult.pipeline;
+            await runner.runPipeline(pipeline, conversionResult.warnings, conversionResult.skippedSteps);
+        }
+        else if (isJavaScriptModule) {
+            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");
+            }
+            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);
+    }
+}
+//# sourceMappingURL=run.js.map

package/dist/src/commands/validate.d.ts

@@ -0,0 +1,10 @@
+export interface ValidateOptions {
+    pipelinePath: string;
+    workflow?: string;
+}
+/**
+ * Validate a pipeline YAML's workflow against the step-validator rules.
+ * Mirrors `ci validate <path>`. Exits 0 when valid, 1 otherwise.
+ */
+export declare function handleValidateCommand(opts: ValidateOptions): Promise<void>;
+//# sourceMappingURL=validate.d.ts.map

package/dist/src/commands/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../../src/commands/validate.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,eAAe;IAC9B,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;GAGG;AACH,wBAAsB,qBAAqB,CAAC,IAAI,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAwChF"}

package/dist/src/commands/validate.js

@@ -0,0 +1,46 @@
+import { existsSync } from "node:fs";
+import { extname } from "node:path";
+import { loadConfig } from "../config.js";
+import { loadYAMLPipeline } from "../yaml/parser.js";
+import { StepValidator, formatValidationResult } from "../yaml/step-validator.js";
+import { promptForWorkflow } from "../shared/prompts.js";
+/**
+ * Validate a pipeline YAML's workflow against the step-validator rules.
+ * Mirrors `ci validate <path>`. Exits 0 when valid, 1 otherwise.
+ */
+export async function handleValidateCommand(opts) {
+    const { pipelinePath } = opts;
+    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: validate only works with YAML pipeline files (.yml, .yaml)");
+        process.exit(1);
+    }
+    try {
+        const config = loadConfig();
+        const yamlPipeline = loadYAMLPipeline(pipelinePath);
+        let selectedWorkflow = opts.workflow;
+        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);
+    }
+}
+//# sourceMappingURL=validate.js.map

package/dist/src/shared/detect-project.d.ts

@@ -0,0 +1,11 @@
+export type MobileProjectType = "android" | "ios" | "kmm";
+/**
+ * Detects whether the given directory is the root of an Android, iOS, or
+ * KMM project. Returns the detected project type, or null if none match.
+ *
+ * KMM is checked before Android because both have Gradle files; KMM is
+ * distinguished by the presence of an `iosApp/`, `shared/`, or
+ * `composeApp/` directory alongside the Gradle files.
+ */
+export declare function detectMobileProjectRoot(dir: string): MobileProjectType | null;
+//# sourceMappingURL=detect-project.d.ts.map

package/dist/src/shared/detect-project.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detect-project.d.ts","sourceRoot":"","sources":["../../../src/shared/detect-project.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,iBAAiB,GAAG,SAAS,GAAG,KAAK,GAAG,KAAK,CAAC;AAE1D;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,MAAM,GAAG,iBAAiB,GAAG,IAAI,CA0C7E"}