@secureci/cli 0.0.0-stage → 0.1.1

package/dist/runner/container-runtime.js

@@ -0,0 +1,374 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONTAINER_EXCHANGE_DIR = exports.CONTAINER_WORKDIR = void 0;
+exports.resolveContainerRuntime = resolveContainerRuntime;
+exports._resetRuntimeCacheForTests = _resetRuntimeCacheForTests;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const util_1 = require("util");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+/** The CLI binary invoked for each runtime. `containerd` has no Docker-CLI-
+ * compatible binary of its own, so `nerdctl` is used as its front-end. */
+const RUNTIME_BINARIES = {
+    docker: 'docker',
+    podman: 'podman',
+    containerd: 'nerdctl'
+};
+exports.CONTAINER_WORKDIR = '/secureci-workspace';
+exports.CONTAINER_EXCHANGE_DIR = '/secureci-exchange';
+/**
+ * Whether a variable can go in an `--env-file` verbatim. Env files are
+ * line-based, and podman strips quotes from and trims values, so anything
+ * multi-line, quote-leading or whitespace-padded is passed another way.
+ */
+function fitsEnvFile(key, value) {
+    return (!/[\s#]/.test(key) &&
+        !/[\r\n]/.test(value) &&
+        !/^["']/.test(value) &&
+        value === value.trim());
+}
+/**
+ * Build the env arguments for `run` / `exec`. Plain values go in an env file
+ * (mode 0600, in a private temp dir) passed with `--env-file`. The rest are
+ * passed as `-e KEY` with the value in the client's environment; only those
+ * keys are added to it, so a `PATH` or `HOME` meant for the container
+ * doesn't change how the client itself runs.
+ */
+function envTransport(env = {}) {
+    const fileLines = [];
+    const viaClient = {};
+    for (const [key, value] of Object.entries(env)) {
+        if (fitsEnvFile(key, value))
+            fileLines.push(`${key}=${value}\n`);
+        else
+            viaClient[key] = value;
+    }
+    const args = [];
+    let dir;
+    if (fileLines.length > 0) {
+        dir = fs.mkdtempSync(path.join(os.tmpdir(), 'secureci-env-'));
+        const file = path.join(dir, 'env');
+        fs.writeFileSync(file, fileLines.join(''), { mode: 0o600 });
+        args.push('--env-file', file);
+    }
+    const clientKeys = Object.keys(viaClient);
+    for (const key of clientKeys)
+        args.push('-e', key);
+    return {
+        args,
+        clientEnv: clientKeys.length > 0 ? { ...process.env, ...viaClient } : undefined,
+        cleanup: () => {
+            if (dir)
+                fs.rmSync(dir, { recursive: true, force: true });
+        }
+    };
+}
+/** Probe timeout for `<bin> version` availability checks. */
+const PROBE_TIMEOUT_MS = 3000;
+class CliContainerRuntime {
+    constructor(name) {
+        this.name = name;
+        this.binary = RUNTIME_BINARIES[name];
+    }
+    async isAvailable() {
+        if (this.availableCache !== undefined)
+            return this.availableCache;
+        try {
+            // Plain `version` (no --format) to stay compatible across engines
+            // (nerdctl's version output format differs from docker/podman's);
+            // we only care whether the daemon responds, not the output.
+            await execAsync(`${this.binary} version`, {
+                timeout: PROBE_TIMEOUT_MS
+            });
+            this.availableCache = true;
+        }
+        catch {
+            this.availableCache = false;
+        }
+        return this.availableCache;
+    }
+    execute(options) {
+        const args = [
+            'run',
+            '--rm',
+            '-w',
+            exports.CONTAINER_WORKDIR,
+            '-v',
+            `${options.workingDir}:${exports.CONTAINER_WORKDIR}`,
+            '-v',
+            `${options.exchangeDir}:${exports.CONTAINER_EXCHANGE_DIR}`
+        ];
+        if (options.networkDisabled === true) {
+            args.push('--network', 'none');
+        }
+        if (options.memoryLimit) {
+            args.push('--memory', options.memoryLimit);
+        }
+        if (options.entrypoint) {
+            args.push('--entrypoint', options.entrypoint);
+        }
+        const env = envTransport(options.env);
+        args.push(...env.args);
+        args.push(options.image);
+        if (options.args) {
+            args.push(...options.args);
+        }
+        else {
+            args.push('sh', '-c', options.command || '');
+        }
+        return this.runCli(args, options.timeoutMs, env);
+    }
+    start(options) {
+        const args = ['run', '-d'];
+        if (options.workingDir) {
+            args.push('-w', exports.CONTAINER_WORKDIR, '-v', `${options.workingDir}:${exports.CONTAINER_WORKDIR}`);
+        }
+        if (options.exchangeDir) {
+            args.push('-v', `${options.exchangeDir}:${exports.CONTAINER_EXCHANGE_DIR}`);
+        }
+        if (options.networkDisabled === true) {
+            args.push('--network', 'none');
+        }
+        else if (options.network) {
+            args.push('--network', options.network);
+            if (options.networkAlias) {
+                args.push('--network-alias', options.networkAlias);
+            }
+        }
+        if (options.memoryLimit) {
+            args.push('--memory', options.memoryLimit);
+        }
+        for (const port of options.ports ?? [])
+            args.push('-p', port);
+        for (const volume of options.volumes ?? [])
+            args.push('-v', volume);
+        args.push(...(options.extraArgs ?? []));
+        const env = envTransport(options.env);
+        args.push(...env.args);
+        if (options.service) {
+            args.push(options.image);
+        }
+        else {
+            // Idle forever; steps are run in it via `exec` and it's removed at
+            // job end. `tail` exists in practically every image (busybox too).
+            args.push('--entrypoint', 'tail', options.image, '-f', '/dev/null');
+        }
+        return this.runCli(args, undefined, env).then((result) => result.success
+            ? { success: true, id: result.stdout.trim() }
+            : {
+                success: false,
+                error: result.stderr.trim() || `exit code ${result.exitCode}`
+            });
+    }
+    exec(id, options) {
+        const env = envTransport(options.env);
+        const args = [
+            'exec',
+            '-w',
+            options.workingDir || exports.CONTAINER_WORKDIR,
+            ...env.args
+        ];
+        if (options.args) {
+            args.push(id, ...options.args);
+        }
+        else {
+            args.push(id, 'sh', '-c', options.command || '');
+        }
+        return this.runCli(args, options.timeoutMs, env);
+    }
+    async createNetwork(name) {
+        return (await this.runCli(['network', 'create', name])).success;
+    }
+    async removeNetwork(name) {
+        await this.runCli(['network', 'rm', name]);
+    }
+    removeNetworkSync(name) {
+        try {
+            (0, child_process_1.execFileSync)(this.binary, ['network', 'rm', name], { stdio: 'ignore' });
+        }
+        catch {
+            // Best effort: the network may already be gone
+        }
+    }
+    async copyFrom(id, containerPath, hostPath) {
+        return (await this.runCli(['cp', `${id}:${containerPath}`, hostPath]))
+            .success;
+    }
+    async copyTo(id, hostPath, containerPath) {
+        return (await this.runCli(['cp', hostPath, `${id}:${containerPath}`]))
+            .success;
+    }
+    async health(id) {
+        const result = await this.runCli([
+            'inspect',
+            '--format',
+            '{{if .State.Health}}{{.State.Health.Status}}{{else}}none{{end}}',
+            id
+        ]);
+        return result.success ? result.stdout.trim() : 'unknown';
+    }
+    async ports(id) {
+        const result = await this.runCli(['port', id]);
+        const ports = {};
+        for (const line of result.stdout.split('\n')) {
+            const match = line.match(/^(\d+)\/\w+\s*->\s*.*:(\d+)\s*$/);
+            if (match && !(match[1] in ports))
+                ports[match[1]] = match[2];
+        }
+        return ports;
+    }
+    async stop(id) {
+        await this.runCli(['rm', '-f', id]);
+    }
+    stopSync(id) {
+        try {
+            (0, child_process_1.execFileSync)(this.binary, ['rm', '-f', id], { stdio: 'ignore' });
+        }
+        catch {
+            // Best effort: the container may already be gone
+        }
+    }
+    runCli(args, timeoutMs, env) {
+        const startTime = Date.now();
+        return new Promise((resolve) => {
+            let child;
+            try {
+                child = (0, child_process_1.spawn)(this.binary, args, { env: env?.clientEnv });
+            }
+            catch (err) {
+                env?.cleanup();
+                throw err;
+            }
+            let stdout = '';
+            let stderr = '';
+            let timedOut = false;
+            const timeout = timeoutMs
+                ? setTimeout(() => {
+                    timedOut = true;
+                    child.kill('SIGKILL');
+                }, timeoutMs)
+                : undefined;
+            child.stdout.on('data', (chunk) => (stdout += chunk.toString()));
+            child.stderr.on('data', (chunk) => (stderr += chunk.toString()));
+            child.on('error', (err) => {
+                if (timeout)
+                    clearTimeout(timeout);
+                env?.cleanup();
+                resolve({
+                    success: false,
+                    stdout,
+                    stderr: stderr || err.message,
+                    exitCode: null,
+                    timedOut,
+                    durationMs: Date.now() - startTime
+                });
+            });
+            child.on('close', (exitCode) => {
+                if (timeout)
+                    clearTimeout(timeout);
+                env?.cleanup();
+                resolve({
+                    success: !timedOut && exitCode === 0,
+                    stdout,
+                    stderr,
+                    exitCode,
+                    timedOut,
+                    durationMs: Date.now() - startTime
+                });
+            });
+        });
+    }
+    async build(contextDir, tag, dockerfile) {
+        const quote = (value) => `'${value.replace(/'/g, "'\\''")}'`;
+        const dockerfileArg = dockerfile && dockerfile !== 'Dockerfile'
+            ? `-f ${quote(dockerfile)} `
+            : '';
+        try {
+            const { stdout, stderr } = await execAsync(`${this.binary} build -t ${quote(tag)} ${dockerfileArg}${quote(contextDir)}`);
+            return { success: true, stdout, stderr };
+        }
+        catch (error) {
+            const err = error;
+            return {
+                success: false,
+                stdout: err.stdout || '',
+                stderr: err.stderr || '',
+                error: err.message
+            };
+        }
+    }
+}
+const runtimeInstances = {
+    docker: new CliContainerRuntime('docker'),
+    podman: new CliContainerRuntime('podman'),
+    containerd: new CliContainerRuntime('containerd')
+};
+const AUTO_DETECT_ORDER = [
+    'docker',
+    'podman',
+    'containerd'
+];
+/**
+ * Resolve a usable container runtime according to preference:
+ * - 'host' → no container: the caller runs steps on the host (opt-in only).
+ * - 'docker' | 'podman' | 'containerd' → that engine specifically, or null
+ *   if unavailable.
+ * - 'auto' → first available of docker, podman, then containerd; null if
+ *   none is installed/running (the caller then refuses to run).
+ */
+async function resolveContainerRuntime(preference = 'auto') {
+    if (preference === 'host')
+        return null;
+    if (preference !== 'auto') {
+        const runtime = runtimeInstances[preference];
+        return (await runtime.isAvailable()) ? runtime : null;
+    }
+    for (const name of AUTO_DETECT_ORDER) {
+        const runtime = runtimeInstances[name];
+        if (await runtime.isAvailable())
+            return runtime;
+    }
+    return null;
+}
+/** Test-only: reset cached availability probes between test cases. */
+function _resetRuntimeCacheForTests() {
+    for (const runtime of Object.values(runtimeInstances)) {
+        runtime['availableCache'] = undefined;
+    }
+}
+//# sourceMappingURL=container-runtime.js.map

package/dist/runner/docker-action.js

@@ -0,0 +1,179 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeDockerAction = executeDockerAction;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
+const logger_1 = require("../utils/logger");
+const expression_1 = require("./expression");
+const container_runtime_1 = require("./container-runtime");
+const runner_env_1 = require("./runner-env");
+const job_runtime_1 = require("./job-runtime");
+const node_action_1 = require("./node-action");
+/**
+ * Execute a Docker-type action (`runs.using: docker`). Unlike `run:` steps,
+ * container isolation is mandatory here (the image *is* the action) - there
+ * is no safe host-execution fallback, so this fails the step (rather than
+ * skip-as-success) if no container runtime is available.
+ */
+async function executeDockerAction(action, actionPath, step, actionInputs, callerEnv, options, runtime, startTime) {
+    // The image is the action, so even with steps on the host (`host`) it
+    // runs in a container, using whichever engine is available.
+    const preference = options.containerRuntime ?? 'auto';
+    const containerRuntime = await (0, container_runtime_1.resolveContainerRuntime)(preference === 'host' ? 'auto' : preference);
+    if (!containerRuntime) {
+        logger_1.logger.error(`Docker action "${step.uses}" needs a container runtime (docker, podman or containerd), but none is available.`);
+        return {
+            step,
+            success: false,
+            error: 'No container runtime (docker, podman or containerd) available for the Docker action',
+            duration: Date.now() - startTime
+        };
+    }
+    const actionDir = path.dirname(actionPath);
+    const rawImage = action.runs.image;
+    if (!rawImage) {
+        return {
+            step,
+            success: false,
+            error: 'No image specified for Docker action',
+            duration: Date.now() - startTime
+        };
+    }
+    let image;
+    if (rawImage.startsWith('docker://')) {
+        image = rawImage.slice('docker://'.length);
+    }
+    else {
+        const dockerfileRelative = rawImage === 'Dockerfile' ? 'Dockerfile' : rawImage;
+        const dockerfilePath = path.join(actionDir, dockerfileRelative);
+        if (!fs.existsSync(dockerfilePath)) {
+            return {
+                step,
+                success: false,
+                error: `Dockerfile not found for action: ${dockerfilePath}`,
+                duration: Date.now() - startTime
+            };
+        }
+        const tag = `secureci-action-${crypto.createHash('sha1').update(actionDir).digest('hex').slice(0, 12)}`;
+        logger_1.logger.info(`Building Docker action image: ${action.name} (${tag})`);
+        const buildResult = await containerRuntime.build(actionDir, tag, dockerfileRelative);
+        if (!buildResult.success) {
+            logger_1.logger.error(`Docker action image build failed: ${buildResult.error}`);
+            if (buildResult.stderr)
+                logger_1.logger.error(buildResult.stderr.trim());
+            return {
+                step,
+                success: false,
+                error: `Docker action image build failed: ${buildResult.error}`,
+                duration: Date.now() - startTime
+            };
+        }
+        image = tag;
+    }
+    // Inputs are passed as INPUT_<NAME> env vars, matching GitHub's own
+    // convention (the same one used for JS actions).
+    const inputEnv = {};
+    for (const [key, value] of Object.entries(actionInputs)) {
+        inputEnv[(0, node_action_1.inputEnvName)(key)] = value;
+    }
+    // `runs.args` may reference ${{ inputs.* }} / ${{ secrets.* }}.
+    const actionCtx = (0, expression_1.createContext)({}, actionInputs, options.secrets);
+    const args = (action.runs.args || []).map((arg) => (0, expression_1.substituteExpressions)(arg, actionCtx));
+    logger_1.logger.info(`Executing Docker action: ${action.name}`);
+    const exchangeDir = fs.mkdtempSync(path.join(os.tmpdir(), 'secureci-exchange-'));
+    const files = (0, runner_env_1.createStepFiles)(exchangeDir);
+    fs.copyFileSync(runtime.eventPath, path.join(exchangeDir, 'event.json'));
+    try {
+        const limit = (0, job_runtime_1.effectiveTimeout)(runtime, options.containerTimeoutMs, true);
+        const result = await containerRuntime.execute({
+            image,
+            args,
+            entrypoint: action.runs.entrypoint,
+            workingDir: process.cwd(),
+            exchangeDir,
+            env: {
+                ...(0, job_runtime_1.containerRunnerEnv)(runtime),
+                ...runtime.actionEnv,
+                ...callerEnv,
+                ...inputEnv,
+                ...(0, job_runtime_1.fileCommandEnv)(files, container_runtime_1.CONTAINER_EXCHANGE_DIR)
+            },
+            timeoutMs: limit.ms,
+            memoryLimit: options.containerMemoryLimit,
+            networkDisabled: options.networkDisabled === true
+        });
+        const { outputs } = (0, job_runtime_1.finishStepOutput)(result.stdout, files, runtime);
+        if (result.stderr) {
+            logger_1.logger[result.success ? 'warn' : 'error'](result.stderr.trim());
+        }
+        if (result.timedOut) {
+            logger_1.logger.error(`${limit.message} (${containerRuntime.name})`);
+            return {
+                step,
+                success: false,
+                error: limit.message,
+                output: result.stdout,
+                outputs,
+                duration: Date.now() - startTime
+            };
+        }
+        if (!result.success) {
+            logger_1.logger.error(`Docker action failed (${containerRuntime.name}, exit code: ${result.exitCode})`);
+            return {
+                step,
+                success: false,
+                error: `Command exited with code ${result.exitCode}`,
+                output: result.stdout,
+                outputs,
+                duration: Date.now() - startTime
+            };
+        }
+        logger_1.logger.success(`Docker action completed: ${action.name}`);
+        return {
+            step,
+            success: true,
+            output: result.stdout,
+            outputs,
+            duration: Date.now() - startTime
+        };
+    }
+    finally {
+        fs.rmSync(exchangeDir, { recursive: true, force: true });
+    }
+}
+//# sourceMappingURL=docker-action.js.map

package/dist/runner/dry-run.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dryRun = dryRun;
+const workflow_parser_1 = require("../parser/workflow-parser");
+const logger_1 = require("../utils/logger");
+const validator_1 = require("../parser/validator");
+/**
+ * Perform a dry run of a workflow or action file
+ * Shows what would be executed without actually running anything
+ */
+function dryRun(filePath) {
+    try {
+        const parsed = (0, workflow_parser_1.parseFile)(filePath);
+        // A file a real run would reject fails the dry run too.
+        const invalid = parsed.type === 'workflow'
+            ? (0, validator_1.workflowExpressionErrors)(parsed.file)
+            : (0, validator_1.actionExpressionErrors)(parsed.file);
+        if (invalid.length > 0) {
+            logger_1.logger.error(`Invalid ${parsed.type} file: ${filePath}`);
+            for (const error of invalid) {
+                logger_1.logger.error(`  ${error.path}: ${error.message}`);
+            }
+            return { success: false, type: parsed.type };
+        }
+        if (parsed.type === 'workflow') {
+            return dryRunWorkflow(parsed);
+        }
+        else {
+            return dryRunAction(parsed);
+        }
+    }
+    catch (error) {
+        logger_1.logger.error(`Failed to perform dry run: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        return {
+            success: false,
+            type: 'workflow'
+        };
+    }
+}
+function dryRunWorkflow(parsed) {
+    const workflow = parsed.file;
+    logger_1.logger.info(`Workflow: ${workflow.name}`);
+    logger_1.logger.info(`Trigger: ${JSON.stringify(workflow.on)}`);
+    const jobs = Object.entries(workflow.jobs).map(([jobId, job]) => {
+        logger_1.logger.step(`Job: ${jobId} (${job.name || jobId})`);
+        // Handle reusable workflow calls
+        if (job.uses) {
+            logger_1.logger.info(`  Uses workflow: ${job.uses}`);
+            if (job.with) {
+                logger_1.logger.info(`  With inputs: ${JSON.stringify(job.with)}`);
+            }
+            return {
+                name: jobId,
+                steps: [`Calls reusable workflow: ${job.uses}`]
+            };
+        }
+        // Handle regular jobs
+        if (job['runs-on']) {
+            logger_1.logger.info(`  Runs on: ${job['runs-on']}`);
+        }
+        const steps = (job.steps || []).map((step, idx) => {
+            const stepInfo = [];
+            stepInfo.push(`  Step ${idx + 1}:`);
+            if (step.name) {
+                stepInfo.push(step.name);
+            }
+            if (step.uses) {
+                stepInfo.push(`uses: ${step.uses}`);
+            }
+            else if (step.run) {
+                stepInfo.push(`run: ${step.run}`);
+            }
+            const stepDesc = stepInfo.join(' ');
+            logger_1.logger.info(stepDesc);
+            return stepDesc;
+        });
+        return {
+            name: jobId,
+            steps
+        };
+    });
+    logger_1.logger.success('Dry run completed successfully');
+    return {
+        success: true,
+        type: 'workflow',
+        jobs
+    };
+}
+function dryRunAction(parsed) {
+    const action = parsed.file;
+    logger_1.logger.info(`Action: ${action.name}`);
+    logger_1.logger.info(`Description: ${action.description}`);
+    const inputs = [];
+    if (action.inputs) {
+        logger_1.logger.step('Inputs:');
+        Object.entries(action.inputs).forEach(([name, input]) => {
+            const required = input.required ? '(required)' : '(optional)';
+            const defaultVal = input.default ? ` [default: ${input.default}]` : '';
+            const inputInfo = `  ${name} ${required}${defaultVal}`;
+            logger_1.logger.info(inputInfo);
+            inputs.push(inputInfo);
+        });
+    }
+    const outputs = [];
+    if (action.outputs) {
+        logger_1.logger.step('Outputs:');
+        Object.keys(action.outputs).forEach((name) => {
+            const outputInfo = `  ${name}`;
+            logger_1.logger.info(outputInfo);
+            outputs.push(outputInfo);
+        });
+    }
+    const steps = [];
+    if (action.runs.steps) {
+        logger_1.logger.step('Steps:');
+        action.runs.steps.forEach((step, idx) => {
+            const stepInfo = [];
+            stepInfo.push(`  Step ${idx + 1}:`);
+            if (step.name) {
+                stepInfo.push(step.name);
+            }
+            if (step.uses) {
+                stepInfo.push(`uses: ${step.uses}`);
+            }
+            else if (step.run) {
+                stepInfo.push(`run: ${step.run}`);
+            }
+            const stepDesc = stepInfo.join(' ');
+            logger_1.logger.info(stepDesc);
+            steps.push(stepDesc);
+        });
+    }
+    logger_1.logger.success('Dry run completed successfully');
+    return {
+        success: true,
+        type: 'action',
+        inputs,
+        outputs,
+        steps
+    };
+}
+//# sourceMappingURL=dry-run.js.map