@cifn/runner 0.0.1

package/dist/index.js

@@ -0,0 +1,1117 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/steps/testfn-run.ts
+var testfn_run_exports = {};
+__export(testfn_run_exports, {
+  executeTestFnRun: () => executeTestFnRun,
+  executeTestFnRunAsync: () => executeTestFnRunAsync
+});
+function executeTestFnRun(options) {
+  const {
+    framework = "vitest",
+    testPattern,
+    reporter,
+    outputPath = "./testfn-results.json",
+    workspace,
+    env,
+    parallel,
+    timeout,
+    retries
+  } = options;
+  const lines = [];
+  lines.push(`Running tests with testfn SDK (framework: ${framework})`);
+  try {
+    if (!["vitest", "playwright", "jest"].includes(framework)) {
+      throw new Error(`Unsupported framework: ${framework}. Supported: vitest, playwright, jest`);
+    }
+    const config = {
+      framework,
+      testPattern: testPattern || "./tests/**/*.{test,spec}.{ts,js}",
+      parallel,
+      timeout,
+      retries,
+      env,
+      reporters: reporter === "json" ? [new import_core.JsonReporter((0, import_node_path5.join)(workspace, outputPath))] : void 0
+    };
+    const originalCwd = process.cwd();
+    try {
+      process.chdir(workspace);
+      const runner = new import_core.TestRunner(config);
+      const results = runner.run();
+      process.chdir(originalCwd);
+      if (results && typeof results === "object" && "then" in results) {
+        throw new Error("executeTestFnRun must be called from async context or use sync adapter");
+      }
+      lines.push(`Tests completed: ${results.summary?.total || 0} total`);
+      lines.push(`Passed: ${results.summary?.passed || 0}, Failed: ${results.summary?.failed || 0}`);
+      if (reporter === "json" && outputPath) {
+        const fullPath = (0, import_node_path5.join)(workspace, outputPath);
+        if ((0, import_node_fs5.existsSync)(fullPath)) {
+          lines.push(`JSON report written to ${outputPath}`);
+        }
+      }
+      const hasFailed = results.summary?.failed > 0;
+      if (hasFailed) {
+        return {
+          success: false,
+          exitCode: 1,
+          lines,
+          error: "Tests failed"
+        };
+      }
+      return { success: true, exitCode: 0, lines };
+    } catch (innerErr) {
+      process.chdir(originalCwd);
+      throw innerErr;
+    }
+  } catch (err) {
+    const errorMessage = err instanceof Error ? err.message : String(err);
+    lines.push(`Test execution failed: ${errorMessage}`);
+    return {
+      success: false,
+      exitCode: 1,
+      lines,
+      error: errorMessage
+    };
+  }
+}
+async function executeTestFnRunAsync(options) {
+  const {
+    framework = "vitest",
+    testPattern,
+    reporter,
+    outputPath = "./testfn-results.json",
+    workspace,
+    env,
+    parallel,
+    timeout,
+    retries
+  } = options;
+  const lines = [];
+  lines.push(`Running tests with testfn SDK (framework: ${framework})`);
+  try {
+    if (!["vitest", "playwright", "jest"].includes(framework)) {
+      throw new Error(`Unsupported framework: ${framework}. Supported: vitest, playwright, jest`);
+    }
+    const config = {
+      framework,
+      testPattern: testPattern || "./tests/**/*.{test,spec}.{ts,js}",
+      parallel,
+      timeout,
+      retries,
+      env,
+      reporters: reporter === "json" ? [new import_core.JsonReporter((0, import_node_path5.join)(workspace, outputPath))] : void 0
+    };
+    const originalCwd = process.cwd();
+    try {
+      process.chdir(workspace);
+      const runner = new import_core.TestRunner(config);
+      const results = await runner.run();
+      process.chdir(originalCwd);
+      lines.push(`Tests completed: ${results.summary.total} total`);
+      lines.push(`Passed: ${results.summary.passed}, Failed: ${results.summary.failed}`);
+      if (reporter === "json" && outputPath) {
+        const fullPath = (0, import_node_path5.join)(workspace, outputPath);
+        if ((0, import_node_fs5.existsSync)(fullPath)) {
+          lines.push(`JSON report written to ${outputPath}`);
+        }
+      }
+      if (results.summary.failed > 0) {
+        return {
+          success: false,
+          exitCode: 1,
+          lines,
+          error: "Tests failed"
+        };
+      }
+      return { success: true, exitCode: 0, lines };
+    } catch (innerErr) {
+      process.chdir(originalCwd);
+      throw innerErr;
+    }
+  } catch (err) {
+    const errorMessage = err instanceof Error ? err.message : String(err);
+    lines.push(`Test execution failed: ${errorMessage}`);
+    return {
+      success: false,
+      exitCode: 1,
+      lines,
+      error: errorMessage
+    };
+  }
+}
+var import_core, import_node_path5, import_node_fs5;
+var init_testfn_run = __esm({
+  "src/steps/testfn-run.ts"() {
+    "use strict";
+    import_core = require("@testfn/core");
+    import_node_path5 = require("path");
+    import_node_fs5 = require("fs");
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DockerExecutor: () => DockerExecutor,
+  MemoryLogFnClient: () => MemoryLogFnClient,
+  Runner: () => Runner,
+  executeArtifactDownload: () => executeArtifactDownload,
+  executeArtifactUpload: () => executeArtifactUpload,
+  executeCacheRestore: () => executeCacheRestore,
+  executeCacheSave: () => executeCacheSave,
+  executeCheckout: () => executeCheckout,
+  executeHostFnDeploy: () => executeHostFnDeploy,
+  executeRunStep: () => executeRunStep,
+  executeTestFnRun: () => executeTestFnRun,
+  redactSecrets: () => redactSecrets
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/runner.ts
+var import_node_fs6 = require("fs");
+var import_node_os = require("os");
+var import_node_path6 = require("path");
+var import_cifn = require("cifn");
+
+// src/executor/run-step.ts
+var import_node_child_process = require("child_process");
+function executeRunStep(command, workspacePath, env) {
+  const execEnv = env ? { ...process.env, ...env } : process.env;
+  try {
+    const stdout = (0, import_node_child_process.execSync)(command, {
+      cwd: workspacePath,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 3e5,
+      shell: "/bin/sh",
+      env: execEnv
+    });
+    const lines = stdout.split("\n").filter((l) => l !== "");
+    return { exitCode: 0, stdout, stderr: "", lines };
+  } catch (err) {
+    const error = err;
+    const stdout = typeof error.stdout === "string" ? error.stdout : "";
+    const stderr = typeof error.stderr === "string" ? error.stderr : "";
+    const exitCode = typeof error.status === "number" ? error.status : 1;
+    const lines = [
+      ...stdout.split("\n").filter((l) => l !== ""),
+      ...stderr.split("\n").filter((l) => l !== "")
+    ];
+    return { exitCode, stdout, stderr, lines };
+  }
+}
+
+// src/steps/checkout.ts
+var import_node_child_process2 = require("child_process");
+function executeCheckout(options) {
+  const { repo, ref, workspace, token } = options;
+  const lines = [];
+  const secretsToRedact = [];
+  let cloneUrl = repo;
+  if (token && cloneUrl.startsWith("https://")) {
+    const url = new URL(cloneUrl);
+    url.username = "x-access-token";
+    url.password = token;
+    cloneUrl = url.toString();
+    secretsToRedact.push(token);
+    secretsToRedact.push(cloneUrl);
+  }
+  const redactLine = (line) => {
+    let redacted = line;
+    for (const secret of secretsToRedact) {
+      if (secret.length > 0) {
+        redacted = redacted.split(secret).join("***");
+      }
+    }
+    return redacted;
+  };
+  try {
+    lines.push(`Cloning ${repo} at ref ${ref}`);
+    const cloneCmd = `git clone --depth 1 --branch ${ref} ${cloneUrl} .`;
+    const output = (0, import_node_child_process2.execSync)(cloneCmd, {
+      cwd: workspace,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 12e4
+    });
+    if (output) {
+      lines.push(...output.split("\n").filter((l) => l !== "").map(redactLine));
+    }
+    lines.push(`Checkout complete: ${ref}`);
+    return { success: true, lines };
+  } catch (err) {
+    const error = err;
+    const errMsg = typeof error.stderr === "string" ? redactLine(error.stderr) : error.message ? redactLine(error.message) : "Unknown error";
+    lines.push(`Checkout failed: ${errMsg}`);
+    return { success: false, lines, error: errMsg };
+  }
+}
+
+// src/steps/artifact-upload.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+function collectFiles(dirPath) {
+  const files = [];
+  if (!(0, import_node_fs.existsSync)(dirPath)) return files;
+  const stat = (0, import_node_fs.statSync)(dirPath);
+  if (stat.isFile()) return [dirPath];
+  if (!stat.isDirectory()) return files;
+  for (const entry of (0, import_node_fs.readdirSync)(dirPath, { withFileTypes: true })) {
+    const fullPath = (0, import_node_path.join)(dirPath, entry.name);
+    if (entry.isFile()) {
+      files.push(fullPath);
+    } else if (entry.isDirectory()) {
+      files.push(...collectFiles(fullPath));
+    }
+  }
+  return files;
+}
+async function executeArtifactUpload(options) {
+  const { name, path: artifactPath, workspace, runId, fileFnClient } = options;
+  const lines = [];
+  if (name.length > 256) {
+    const msg = `Artifact name exceeds maximum length of 256 characters (actual: ${name.length})`;
+    lines.push(msg);
+    return { success: false, lines, error: msg };
+  }
+  const fullPath = (0, import_node_path.join)(workspace, artifactPath);
+  if (!(0, import_node_fs.existsSync)(fullPath)) {
+    const msg = `Artifact path not found: ${artifactPath}`;
+    lines.push(msg);
+    return { success: false, lines, error: msg };
+  }
+  try {
+    lines.push(`Uploading artifact "${name}" from ${artifactPath}`);
+    const files = collectFiles(fullPath);
+    const buffers = [];
+    const manifest = [];
+    let offset = 0;
+    for (const file of files) {
+      const data = (0, import_node_fs.readFileSync)(file);
+      const rel = (0, import_node_path.relative)(fullPath, file) || (0, import_node_path.relative)(workspace, file);
+      manifest.push({ relativePath: rel, offset, size: data.length });
+      buffers.push(data);
+      offset += data.length;
+    }
+    const manifestBuf = Buffer.from(JSON.stringify(manifest));
+    const headerBuf = Buffer.alloc(4);
+    headerBuf.writeUInt32BE(manifestBuf.length, 0);
+    const combined = Buffer.concat([headerBuf, manifestBuf, ...buffers]);
+    const namespace = `artifact:${runId}`;
+    const fileId = await fileFnClient.upload(namespace, name, combined);
+    lines.push(`Uploaded ${files.length} file(s), artifact fileId: ${fileId}`);
+    return { success: true, fileId, lines };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    lines.push(`Upload failed: ${msg}`);
+    return { success: false, lines, error: msg };
+  }
+}
+
+// src/steps/artifact-download.ts
+var import_node_fs2 = require("fs");
+var import_node_path2 = require("path");
+async function executeArtifactDownload(options) {
+  const { name, workspace, runId, fileFnClient } = options;
+  const lines = [];
+  try {
+    lines.push(`Downloading artifact "${name}"`);
+    const namespace = `artifact:${runId}`;
+    const data = await fileFnClient.downloadByKey(namespace, name);
+    if (!data) {
+      const msg = `Artifact "${name}" not found`;
+      lines.push(msg);
+      return { success: false, lines, error: msg };
+    }
+    const manifestLen = data.readUInt32BE(0);
+    const manifestJson = data.subarray(4, 4 + manifestLen).toString("utf-8");
+    const manifest = JSON.parse(manifestJson);
+    const dataStart = 4 + manifestLen;
+    for (const entry of manifest) {
+      const fileBuf = data.subarray(dataStart + entry.offset, dataStart + entry.offset + entry.size);
+      const outPath = (0, import_node_path2.join)(workspace, entry.relativePath);
+      (0, import_node_fs2.mkdirSync)((0, import_node_path2.dirname)(outPath), { recursive: true });
+      (0, import_node_fs2.writeFileSync)(outPath, fileBuf);
+    }
+    lines.push(`Downloaded and extracted ${manifest.length} file(s)`);
+    return { success: true, lines };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    lines.push(`Download failed: ${msg}`);
+    return { success: false, lines, error: msg };
+  }
+}
+
+// src/steps/cache-save.ts
+var import_node_fs3 = require("fs");
+var import_node_path3 = require("path");
+function collectFiles2(dirPath, basePath) {
+  const results = [];
+  if (!(0, import_node_fs3.existsSync)(dirPath)) return results;
+  const stat = (0, import_node_fs3.statSync)(dirPath);
+  if (stat.isFile()) {
+    results.push({ relativePath: (0, import_node_path3.relative)(basePath, dirPath), data: (0, import_node_fs3.readFileSync)(dirPath) });
+    return results;
+  }
+  if (!stat.isDirectory()) return results;
+  for (const entry of (0, import_node_fs3.readdirSync)(dirPath, { withFileTypes: true })) {
+    const fullPath = (0, import_node_path3.join)(dirPath, entry.name);
+    if (entry.isFile()) {
+      results.push({ relativePath: (0, import_node_path3.relative)(basePath, fullPath), data: (0, import_node_fs3.readFileSync)(fullPath) });
+    } else if (entry.isDirectory()) {
+      results.push(...collectFiles2(fullPath, basePath));
+    }
+  }
+  return results;
+}
+async function executeCacheSave(options) {
+  const { key, paths, workspace, fileFnClient } = options;
+  const lines = [];
+  const keyByteLength = Buffer.byteLength(key, "utf8");
+  if (keyByteLength > 1024) {
+    const msg = `Cache key exceeds maximum length of 1KB (actual: ${keyByteLength} bytes)`;
+    lines.push(msg);
+    return { success: false, lines, error: msg };
+  }
+  try {
+    lines.push(`Saving cache with key "${key}"`);
+    const allFiles = [];
+    for (const p of paths) {
+      const fullPath = (0, import_node_path3.join)(workspace, p);
+      const files = collectFiles2(fullPath, workspace);
+      allFiles.push(...files);
+    }
+    if (allFiles.length === 0) {
+      lines.push("No files found to cache");
+      return { success: true, lines };
+    }
+    const manifest = [];
+    const buffers = [];
+    let offset = 0;
+    for (const f of allFiles) {
+      manifest.push({ relativePath: f.relativePath, offset, size: f.data.length });
+      buffers.push(f.data);
+      offset += f.data.length;
+    }
+    const manifestBuf = Buffer.from(JSON.stringify(manifest));
+    const headerBuf = Buffer.alloc(4);
+    headerBuf.writeUInt32BE(manifestBuf.length, 0);
+    const combined = Buffer.concat([headerBuf, manifestBuf, ...buffers]);
+    await fileFnClient.upload("cache", key, combined);
+    lines.push(`Cached ${allFiles.length} file(s) under key "${key}"`);
+    return { success: true, lines };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    lines.push(`Cache save failed: ${msg}`);
+    return { success: false, lines, error: msg };
+  }
+}
+
+// src/steps/cache-restore.ts
+var import_node_fs4 = require("fs");
+var import_node_path4 = require("path");
+async function executeCacheRestore(options) {
+  const { key, workspace, fileFnClient } = options;
+  const lines = [];
+  const keyByteLength = Buffer.byteLength(key, "utf8");
+  if (keyByteLength > 1024) {
+    const msg = `Cache key exceeds maximum length of 1KB (actual: ${keyByteLength} bytes)`;
+    lines.push(msg);
+    return { success: false, hit: false, lines, error: msg };
+  }
+  try {
+    lines.push(`Restoring cache with key "${key}"`);
+    const data = await fileFnClient.downloadByKey("cache", key);
+    if (!data) {
+      lines.push(`Cache miss for key "${key}"`);
+      return { success: true, hit: false, lines };
+    }
+    const manifestLen = data.readUInt32BE(0);
+    const manifestJson = data.subarray(4, 4 + manifestLen).toString("utf-8");
+    const manifest = JSON.parse(manifestJson);
+    const dataStart = 4 + manifestLen;
+    for (const entry of manifest) {
+      const fileBuf = data.subarray(dataStart + entry.offset, dataStart + entry.offset + entry.size);
+      const outPath = (0, import_node_path4.join)(workspace, entry.relativePath);
+      (0, import_node_fs4.mkdirSync)((0, import_node_path4.dirname)(outPath), { recursive: true });
+      (0, import_node_fs4.writeFileSync)(outPath, fileBuf);
+    }
+    lines.push(`Cache hit: restored ${manifest.length} file(s)`);
+    return { success: true, hit: true, lines };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    lines.push(`Cache restore failed: ${msg}`);
+    return { success: false, hit: false, lines, error: msg };
+  }
+}
+
+// src/steps/hostfn-deploy.ts
+var import_node_child_process3 = require("child_process");
+function executeHostFnDeploy(options) {
+  const { environment, ci = true, local = false, workspace, env } = options;
+  const lines = [];
+  let command = `hostfn deploy ${environment}`;
+  if (local) command += " --local";
+  if (ci) command += " --ci";
+  lines.push(`Deploying: ${command}`);
+  try {
+    const output = (0, import_node_child_process3.execSync)(command, {
+      cwd: workspace,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 6e5,
+      shell: "/bin/sh",
+      env: env ? { ...process.env, ...env } : process.env
+    });
+    if (output) {
+      lines.push(...output.split("\n").filter((l) => l !== ""));
+    }
+    lines.push("Deploy succeeded");
+    return { success: true, exitCode: 0, lines };
+  } catch (err) {
+    const error = err;
+    const stdout = typeof error.stdout === "string" ? error.stdout : "";
+    const stderr = typeof error.stderr === "string" ? error.stderr : "";
+    const exitCode = typeof error.status === "number" ? error.status : 1;
+    if (stdout) lines.push(...stdout.split("\n").filter((l) => l !== ""));
+    if (stderr) lines.push(...stderr.split("\n").filter((l) => l !== ""));
+    lines.push(`Deploy failed with exit code ${exitCode}`);
+    return { success: false, exitCode, lines, error: `Deploy failed with exit code ${exitCode}` };
+  }
+}
+
+// src/reporting/redact.ts
+function redactSecrets(lines, secretValues) {
+  if (secretValues.length === 0) return lines;
+  return lines.map((line) => {
+    let result = line;
+    for (const secret of secretValues) {
+      if (secret.length > 0) {
+        result = result.split(secret).join("***");
+      }
+    }
+    return result;
+  });
+}
+
+// src/runner.ts
+var Runner = class {
+  constructor(options) {
+    this.store = options.store;
+    this.queue = options.queue;
+    this.logClient = options.logClient;
+    this.pipelineSpecs = options.pipelineSpecs ?? /* @__PURE__ */ new Map();
+    this.queueName = options.queueName ?? import_cifn.DEFAULT_QUEUE_NAME;
+    this.cleanWorkspace = options.cleanWorkspace ?? true;
+    this.fileFnClient = options.fileFnClient;
+    this.artifactStore = options.artifactStore;
+    this.secretValues = options.secretValues ?? /* @__PURE__ */ new Map();
+    this.getSecret = options.getSecret;
+    this.runnerType = options.runnerType ?? "default";
+    this.labels = options.labels && options.labels.length > 0 ? [...new Set(options.labels)] : [this.runnerType];
+    this.dockerExecutor = options.dockerExecutor;
+    this.defaultDockerImage = options.defaultDockerImage ?? "node:20";
+    this.dockerRunOnLabels = new Set(options.dockerRunOnLabels ?? ["docker-ubuntu-22"]);
+    this.dockerForDefault = options.dockerForDefault ?? false;
+  }
+  registerPipelineSpec(runId, spec) {
+    this.pipelineSpecs.set(runId, spec);
+  }
+  registerSecretValues(runId, values) {
+    this.secretValues.set(runId, values);
+  }
+  async processNextJob() {
+    const payload = await this.queue.dequeueMatching(
+      this.queueName,
+      (job) => this.labels.includes(job.jobSpec["runs-on"])
+    );
+    if (!payload) return false;
+    await this.executeJob(payload);
+    return true;
+  }
+  async processAllJobs() {
+    let count = 0;
+    while (await this.processNextJob()) {
+      count++;
+    }
+    return count;
+  }
+  async executeJob(payload) {
+    const { runId, jobKey, jobSpec } = payload;
+    let jobEnv = { ...payload.env };
+    const secretVals = this.secretValues.get(runId) ?? [];
+    if (payload.secretKeys && jobEnv) {
+      for (const key of payload.secretKeys) {
+        const val = jobEnv[key];
+        if (val && !secretVals.includes(val)) {
+          secretVals.push(val);
+        }
+      }
+    }
+    const logLines = (stepKey, lines) => {
+      this.logClient.appendLines(runId, jobKey, stepKey, redactSecrets(lines, secretVals));
+    };
+    const run = this.store.getRun(runId);
+    if (!run) return;
+    const job = run.jobs.find((j) => j.jobKey === jobKey);
+    if (!job) return;
+    const github = run.trigger?.payload?.github ?? {};
+    if (!github.ref && payload.pipelineRef?.ref) github.ref = payload.pipelineRef.ref;
+    if (!github.repository && payload.pipelineRef?.repo) github.repository = payload.pipelineRef.repo;
+    if (!github.event_name && run.trigger?.type) github.event_name = run.trigger.type;
+    if (jobSpec.if !== void 0 && jobSpec.if !== null) {
+      try {
+        const runJob = (0, import_cifn.evaluateConditionSync)(String(jobSpec.if).trim(), { github, stepOutcomes: [] });
+        if (!runJob) {
+          job.status = "skipped";
+          job.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+          logLines("__job__", [`Job "${jobKey}" skipped (if: false)`]);
+          this.enqueueDependentJobs(runId, jobKey);
+          this.checkRunCompletion(runId);
+          return;
+        }
+      } catch {
+        job.status = "failure";
+        job.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+        logLines("__job__", [`Job "${jobKey}" failed (invalid if expression)`]);
+        this.store.updateRunStatus(runId, "failure");
+        return;
+      }
+    }
+    if (run.status === "queued") {
+      this.store.updateRunStatus(runId, "running");
+    }
+    job.status = "running";
+    job.startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    logLines("__job__", [`Job "${jobKey}" started`]);
+    const workspace = (0, import_node_fs6.mkdtempSync)((0, import_node_path6.join)((0, import_node_os.tmpdir)(), `cifn-${runId}-${jobKey}-`));
+    let jobFailed = false;
+    const interpolateContext = {
+      github,
+      getSecret: this.getSecret ? (name) => this.getSecret(runId, name) : void 0,
+      workspaceRoot: workspace,
+      hashFiles: (glob) => Promise.resolve((0, import_cifn.hashFiles)(workspace, glob))
+    };
+    if (jobSpec.env) {
+      for (const [k, v] of Object.entries(jobSpec.env)) {
+        try {
+          const { result, secretValues: sv } = await (0, import_cifn.interpolate)(String(v), interpolateContext);
+          jobEnv[k] = result;
+          secretVals.push(...sv);
+        } catch {
+          jobEnv[k] = String(v);
+        }
+      }
+    }
+    try {
+      for (let i = 0; i < jobSpec.steps.length; i++) {
+        const stepSpec = jobSpec.steps[i];
+        const step = job.steps[i];
+        if (!step) continue;
+        const effectiveIf = "if" in stepSpec && stepSpec.if != null ? String(stepSpec.if).trim() : "success()";
+        const stepOutcomes = job.steps.slice(0, i).map((s) => s.status);
+        try {
+          const runStep = (0, import_cifn.evaluateConditionSync)(effectiveIf, { github, stepOutcomes });
+          if (!runStep) {
+            step.status = "skipped";
+            step.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+            logLines(step.stepKey, [`Step "${step.stepKey}" skipped (if: false)`]);
+            continue;
+          }
+        } catch {
+          step.status = "failure";
+          step.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+          logLines(step.stepKey, [`Step "${step.stepKey}" failed (invalid if expression)`]);
+          jobFailed = true;
+          continue;
+        }
+        if ("uses" in stepSpec) {
+          if (stepSpec.uses === "checkout") {
+            step.status = "running";
+            step.startedAt = (/* @__PURE__ */ new Date()).toISOString();
+            logLines(step.stepKey, [
+              `Step "${step.stepKey}" started: checkout`
+            ]);
+            const repo = stepSpec.with?.repository ?? payload.pipelineRef?.repo ?? "";
+            const ref = stepSpec.with?.ref ?? payload.pipelineRef?.ref ?? "main";
+            const token = stepSpec.with?.token;
+            const checkoutResult = executeCheckout({ repo, ref, workspace, token });
+            logLines(step.stepKey, checkoutResult.lines);
+            if (checkoutResult.success) {
+              step.status = "success";
+              step.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+              logLines(step.stepKey, [
+                `Step "${step.stepKey}" completed successfully`
+              ]);
+            } else {
+              step.status = "failure";
+              step.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+              logLines(step.stepKey, [
+                `Step "${step.stepKey}" failed: ${checkoutResult.error}`
+              ]);
+              jobFailed = true;
+            }
+            continue;
+          }
+          if (stepSpec.uses === "artifact/upload" && this.fileFnClient) {
+            step.status = "running";
+            step.startedAt = (/* @__PURE__ */ new Date()).toISOString();
+            let artName = stepSpec.with?.name ?? "default";
+            let artPath = stepSpec.with?.path ?? ".";
+            try {
+              const nameRes = await (0, import_cifn.interpolate)(artName, interpolateContext);
+              artName = nameRes.result;
+              secretVals.push(...nameRes.secretValues);
+              const pathRes = await (0, import_cifn.interpolate)(artPath, interpolateContext);
+              artPath = pathRes.result;
+              secretVals.push(...pathRes.secretValues);
+            } catch {
+              step.status = "failure";
+              step.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+              logLines(step.stepKey, [`Step "${step.stepKey}" failed: interpolation error`]);
+              jobFailed = true;
+              continue;
+            }
+            logLines(step.stepKey, [
+              `Step "${step.stepKey}" started: artifact/upload "${artName}"`
+            ]);
+            const uploadResult = await executeArtifactUpload({
+              name: artName,
+              path: artPath,
+              workspace,
+              runId,
+              fileFnClient: this.fileFnClient
+            });
+            logLines(step.stepKey, uploadResult.lines);
+            if (uploadResult.success) {
+              if (uploadResult.fileId && this.artifactStore) {
+                this.artifactStore.addArtifact(runId, { name: artName, fileId: uploadResult.fileId });
+              }
+              step.status = "success";
+              step.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+              logLines(step.stepKey, [
+                `Step "${step.stepKey}" completed successfully`
+              ]);
+            } else {
+              step.status = "failure";
+              step.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+              logLines(step.stepKey, [
+                `Step "${step.stepKey}" failed: ${uploadResult.error}`
+              ]);
+              jobFailed = true;
+            }
+            continue;
+          }
+          if (stepSpec.uses === "artifact/download" && this.fileFnClient) {
+            step.status = "running";
+            step.startedAt = (/* @__PURE__ */ new Date()).toISOString();
+            let artName = stepSpec.with?.name ?? "default";
+            try {
+              const nameRes = await (0, import_cifn.interpolate)(artName, interpolateContext);
+              artName = nameRes.result;
+              secretVals.push(...nameRes.secretValues);
+            } catch {
+              step.status = "failure";
+              step.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+              logLines(step.stepKey, [`Step "${step.stepKey}" failed: interpolation error`]);
+              jobFailed = true;
+              continue;
+            }
+            logLines(step.stepKey, [
+              `Step "${step.stepKey}" started: artifact/download "${artName}"`
+            ]);
+            const downloadResult = await executeArtifactDownload({
+              name: artName,
+              workspace,
+              runId,
+              fileFnClient: this.fileFnClient
+            });
+            logLines(step.stepKey, downloadResult.lines);
+            if (downloadResult.success) {
+              step.status = "success";
+              step.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+              logLines(step.stepKey, [
+                `Step "${step.stepKey}" completed successfully`
+              ]);
+            } else {
+              step.status = "failure";
+              step.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+              logLines(step.stepKey, [
+                `Step "${step.stepKey}" failed: ${downloadResult.error}`
+              ]);
+              jobFailed = true;
+            }
+            continue;
+          }
+          if (stepSpec.uses === "cache/save" && this.fileFnClient) {
+            step.status = "running";
+            step.startedAt = (/* @__PURE__ */ new Date()).toISOString();
+            let cacheKey = stepSpec.with?.key ?? "";
+            try {
+              const keyRes = await (0, import_cifn.interpolate)(cacheKey, interpolateContext);
+              cacheKey = keyRes.result;
+              secretVals.push(...keyRes.secretValues);
+            } catch {
+              step.status = "failure";
+              step.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+              logLines(step.stepKey, [`Step "${step.stepKey}" failed: interpolation error`]);
+              jobFailed = true;
+              continue;
+            }
+            const cachePaths = stepSpec.with?.paths ?? [];
+            logLines(step.stepKey, [
+              `Step "${step.stepKey}" started: cache/save "${cacheKey}"`
+            ]);
+            const saveResult = await executeCacheSave({
+              key: cacheKey,
+              paths: cachePaths,
+              workspace,
+              fileFnClient: this.fileFnClient
+            });
+            logLines(step.stepKey, saveResult.lines);
+            step.status = saveResult.success ? "success" : "failure";
+            step.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+            if (!saveResult.success) {
+              logLines(step.stepKey, [
+                `Step "${step.stepKey}" failed: ${saveResult.error}`
+              ]);
+              jobFailed = true;
+            } else {
+              logLines(step.stepKey, [
+                `Step "${step.stepKey}" completed successfully`
+              ]);
+            }
+            continue;
+          }
+          if (stepSpec.uses === "cache/restore" && this.fileFnClient) {
+            step.status = "running";
+            step.startedAt = (/* @__PURE__ */ new Date()).toISOString();
+            let cacheKey = stepSpec.with?.key ?? "";
+            try {
+              const keyRes = await (0, import_cifn.interpolate)(cacheKey, interpolateContext);
+              cacheKey = keyRes.result;
+              secretVals.push(...keyRes.secretValues);
+            } catch {
+              step.status = "failure";
+              step.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+              logLines(step.stepKey, [`Step "${step.stepKey}" failed: interpolation error`]);
+              jobFailed = true;
+              continue;
+            }
+            logLines(step.stepKey, [
+              `Step "${step.stepKey}" started: cache/restore "${cacheKey}"`
+            ]);
+            const restoreResult = await executeCacheRestore({
+              key: cacheKey,
+              workspace,
+              fileFnClient: this.fileFnClient
+            });
+            logLines(step.stepKey, restoreResult.lines);
+            step.status = "success";
+            step.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+            logLines(step.stepKey, [
+              `Step "${step.stepKey}" completed successfully${restoreResult.hit ? " (cache hit)" : " (cache miss)"}`
+            ]);
+            continue;
+          }
+          if (stepSpec.uses === "testfn/run") {
+            step.status = "running";
+            step.startedAt = (/* @__PURE__ */ new Date()).toISOString();
+            const framework = stepSpec.with?.framework;
+            const testPattern = stepSpec.with?.testPattern;
+            const reporter = stepSpec.with?.reporter;
+            const outputPath = stepSpec.with?.outputPath;
+            const parallel = stepSpec.with?.parallel;
+            const timeout = stepSpec.with?.timeout;
+            const retries = stepSpec.with?.retries;
+            logLines(step.stepKey, [
+              `Step "${step.stepKey}" started: testfn/run`
+            ]);
+            const { executeTestFnRunAsync: executeTestFnRunAsync2 } = await Promise.resolve().then(() => (init_testfn_run(), testfn_run_exports));
+            const testResult = await executeTestFnRunAsync2({
+              framework,
+              testPattern,
+              reporter,
+              outputPath,
+              workspace,
+              env: jobEnv,
+              parallel,
+              timeout,
+              retries
+            });
+            logLines(step.stepKey, testResult.lines);
+            if (testResult.success) {
+              step.status = "success";
+              step.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+              logLines(step.stepKey, [
+                `Step "${step.stepKey}" completed successfully`
+              ]);
+            } else {
+              step.status = "failure";
+              step.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+              logLines(step.stepKey, [
+                `Step "${step.stepKey}" failed: ${testResult.error}`
+              ]);
+              jobFailed = true;
+            }
+            continue;
+          }
+          if (stepSpec.uses === "hostfn/deploy") {
+            step.status = "running";
+            step.startedAt = (/* @__PURE__ */ new Date()).toISOString();
+            const environment = stepSpec.with?.environment ?? "";
+            const ci = stepSpec.with?.ci ?? true;
+            const local = typeof stepSpec.with?.local === "boolean" ? stepSpec.with.local : jobSpec["runs-on"] === "hostfn-runner";
+            logLines(step.stepKey, [
+              `Step "${step.stepKey}" started: hostfn/deploy ${environment}`
+            ]);
+            const deployResult = executeHostFnDeploy({
+              environment,
+              ci,
+              local,
+              workspace,
+              env: jobEnv
+            });
+            logLines(step.stepKey, deployResult.lines);
+            if (deployResult.success) {
+              step.status = "success";
+              step.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+              logLines(step.stepKey, [
+                `Step "${step.stepKey}" completed successfully`
+              ]);
+            } else {
+              step.status = "failure";
+              step.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+              logLines(step.stepKey, [
+                `Step "${step.stepKey}" failed: ${deployResult.error}`
+              ]);
+              jobFailed = true;
+            }
+            continue;
+          }
+          step.status = "skipped";
+          logLines(step.stepKey, [
+            `Step "${step.stepKey}" skipped (unsupported uses: ${stepSpec.uses})`
+          ]);
+          continue;
+        }
+        step.status = "running";
+        step.startedAt = (/* @__PURE__ */ new Date()).toISOString();
+        let runCommand = stepSpec.run;
+        try {
+          const runRes = await (0, import_cifn.interpolate)(stepSpec.run, interpolateContext);
+          runCommand = runRes.result;
+          secretVals.push(...runRes.secretValues);
+        } catch {
+          step.status = "failure";
+          step.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+          logLines(step.stepKey, [`Step "${step.stepKey}" failed: interpolation error`]);
+          jobFailed = true;
+          continue;
+        }
+        logLines(step.stepKey, [
+          `Step "${step.stepKey}" started: ${runCommand}`
+        ]);
+        const result = this.executeRunCommand(runCommand, workspace, jobSpec, jobEnv);
+        logLines(step.stepKey, result.lines);
+        if (result.exitCode === 0) {
+          step.status = "success";
+          step.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+          logLines(step.stepKey, [
+            `Step "${step.stepKey}" completed successfully`
+          ]);
+        } else {
+          step.status = "failure";
+          step.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+          logLines(step.stepKey, [
+            `Step "${step.stepKey}" failed with exit code ${result.exitCode}`
+          ]);
+          jobFailed = true;
+        }
+      }
+    } finally {
+      if (this.cleanWorkspace) {
+        try {
+          (0, import_node_fs6.rmSync)(workspace, { recursive: true, force: true });
+        } catch {
+        }
+      }
+    }
+    job.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+    if (jobFailed) {
+      job.status = "failure";
+      logLines("__job__", [`Job "${jobKey}" failed`]);
+      this.store.updateRunStatus(runId, "failure");
+    } else {
+      job.status = "success";
+      logLines("__job__", [`Job "${jobKey}" completed successfully`]);
+      await this.enqueueDependentJobs(runId, jobKey);
+      this.checkRunCompletion(runId);
+    }
+  }
+  executeRunCommand(command, workspace, jobSpec, env) {
+    if (this.shouldUseDocker(jobSpec) && this.dockerExecutor) {
+      return this.dockerExecutor.execute({
+        image: jobSpec.image ?? this.defaultDockerImage,
+        workspace,
+        command,
+        env
+      });
+    }
+    return executeRunStep(command, workspace, env);
+  }
+  shouldUseDocker(jobSpec) {
+    if (!this.dockerExecutor) return false;
+    if (typeof jobSpec.image === "string" && jobSpec.image.length > 0) return true;
+    if (jobSpec["runs-on"] === "default" && this.dockerForDefault) return true;
+    return this.dockerRunOnLabels.has(jobSpec["runs-on"]);
+  }
+  async enqueueDependentJobs(runId, completedJobKey) {
+    const spec = this.pipelineSpecs.get(runId);
+    if (!spec) return;
+    const run = this.store.getRun(runId);
+    if (!run) return;
+    const completedJobs = new Set(
+      run.jobs.filter((j) => j.status === "success" || j.status === "skipped").map((j) => j.jobKey)
+    );
+    const enqueuedJobs = new Set(
+      run.jobs.filter((j) => j.status !== "pending").map((j) => j.jobKey)
+    );
+    const readyJobs = (0, import_cifn.getReadyJobs)(spec, completedJobs, enqueuedJobs);
+    for (const readyJobKey of readyJobs) {
+      const jobSpec = spec.jobs[readyJobKey];
+      if (jobSpec) {
+        await this.queue.enqueue(this.queueName, {
+          runId,
+          jobKey: readyJobKey,
+          jobSpec
+        });
+      }
+    }
+  }
+  checkRunCompletion(runId) {
+    const run = this.store.getRun(runId);
+    if (!run) return;
+    const allDone = run.jobs.every(
+      (j) => j.status === "success" || j.status === "failure" || j.status === "skipped"
+    );
+    if (allDone) {
+      const anyFailure = run.jobs.some((j) => j.status === "failure");
+      this.store.updateRunStatus(runId, anyFailure ? "failure" : "success");
+    }
+  }
+};
+
+// src/reporting/logfn-client.ts
+var MemoryLogFnClient = class {
+  constructor() {
+    this.entries = [];
+  }
+  append(entry) {
+    this.entries.push(entry);
+  }
+  appendLines(runId, jobKey, stepKey, lines) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    for (const line of lines) {
+      this.entries.push({ runId, jobKey, stepKey, line, timestamp: now });
+    }
+  }
+  getLines(runId, jobKey) {
+    return this.entries.filter((e) => e.runId === runId && e.jobKey === jobKey);
+  }
+  getAllLines(runId) {
+    return this.entries.filter((e) => e.runId === runId);
+  }
+};
+
+// src/index.ts
+init_testfn_run();
+
+// src/docker-executor.ts
+var import_node_child_process4 = require("child_process");
+var DefaultDockerCommandRunner = class {
+  run(args, options) {
+    const res = (0, import_node_child_process4.spawnSync)("docker", args, {
+      cwd: options.cwd,
+      encoding: "utf-8",
+      env: options.env ? { ...process.env, ...options.env } : process.env,
+      timeout: 6e5
+    });
+    return {
+      status: res.status,
+      stdout: res.stdout ?? "",
+      stderr: res.stderr ?? "",
+      error: res.error ? String(res.error.message ?? res.error) : void 0
+    };
+  }
+};
+var DockerExecutor = class {
+  constructor(runner) {
+    this.runner = runner ?? new DefaultDockerCommandRunner();
+  }
+  execute(options) {
+    const args = [
+      "run",
+      "--rm",
+      "-v",
+      `${options.workspace}:/workspace`,
+      "-w",
+      "/workspace"
+    ];
+    for (const [key, value] of Object.entries(options.env ?? {})) {
+      args.push("-e", `${key}=${value}`);
+    }
+    args.push(options.image, "sh", "-lc", options.command);
+    const output = this.runner.run(args, { cwd: options.workspace, env: options.env });
+    const stdout = output.stdout ?? "";
+    const stderr = output.stderr ?? "";
+    const lines = [...stdout.split("\n"), ...stderr.split("\n")].filter((line) => line !== "");
+    const exitCode = output.status ?? 1;
+    if (output.error) {
+      lines.push(`docker error: ${output.error}`);
+    }
+    return {
+      exitCode,
+      stdout,
+      stderr,
+      lines
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DockerExecutor,
+  MemoryLogFnClient,
+  Runner,
+  executeArtifactDownload,
+  executeArtifactUpload,
+  executeCacheRestore,
+  executeCacheSave,
+  executeCheckout,
+  executeHostFnDeploy,
+  executeRunStep,
+  executeTestFnRun,
+  redactSecrets
+});
+//# sourceMappingURL=index.js.map