@openfn/cli 1.18.6 → 1.20.0

package/dist/process/runner.js

@@ -1,3 +1,9 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
 // src/apollo/handler.ts
 import { WebSocket } from "ws";
 import { readFile, writeFile, mkdir } from "node:fs/promises";
@@ -15,13 +21,13 @@ var urlMap = {
   ["local"]: LOCAL_URL
 };
 var DEFAULT_ENV = "staging";
-var getURL = (options) => {
-  if (options.apolloUrl) {
-    if (options.apolloUrl in urlMap) {
-      return urlMap[options.apolloUrl];
+var getURL = (options6) => {
+  if (options6.apolloUrl) {
+    if (options6.apolloUrl in urlMap) {
+      return urlMap[options6.apolloUrl];
     }
-    if (options.apolloUrl.startsWith("http")) {
-      return options.apolloUrl;
+    if (options6.apolloUrl.startsWith("http")) {
+      return options6.apolloUrl;
     }
     throw new Error(`Unrecognised apollo URL`);
   }
@@ -46,14 +52,14 @@ var outputFiles = (files, logger) => {
 };
 
 // src/apollo/handler.ts
-var apolloHandler = async (options, logger) => {
-  logger.always(`Calling Apollo service: ${options.service}`);
-  const json = await loadPayload(logger, options.payload);
-  const url2 = getURL(options);
+var apolloHandler = async (options6, logger) => {
+  logger.always(`Calling Apollo service: ${options6.service}`);
+  const json = await loadPayload(logger, options6.payload);
+  const url2 = getURL(options6);
   logger.success(`Using apollo server at`, url2);
-  const result = await callApollo(url2, options.service, json, logger);
+  const result = await callApollo(url2, options6.service, json, logger);
   if (result) {
-    await serializeOutput(options, result, logger);
+    await serializeOutput(options6, result, logger);
   } else {
     logger.warn("No output returned from Apollo");
   }
@@ -73,15 +79,15 @@ var write = async (basePath, filePath, content, logger) => {
   await writeFile(dest, content);
   logger.success(`Wrote content to ${dest}`);
 };
-var serializeOutput = async (options, result, logger) => {
-  if (options.outputPath) {
-    if (result.files && !options.outputPath.endsWith(".json")) {
+var serializeOutput = async (options6, result, logger) => {
+  if (options6.outputPath) {
+    if (result.files && !options6.outputPath.endsWith(".json")) {
       for (const p in result.files) {
-        await write(options.outputPath, p, result.files[p], logger);
+        await write(options6.outputPath, p, result.files[p], logger);
       }
     } else {
       await write(
-        options.outputPath,
+        options6.outputPath,
         "",
         JSON.stringify(result, null, 2),
         logger
@@ -127,14 +133,14 @@ var callApollo = async (apolloBaseUrl, serviceName, payload, logger) => {
     });
   });
 };
-var loadPayload = async (logger, path16) => {
-  if (!path16) {
+var loadPayload = async (logger, path15) => {
+  if (!path15) {
     logger.warn("No JSON payload provided");
     logger.warn("Most apollo services require JSON to be uploaded");
     return {};
   }
-  if (path16.endsWith(".json")) {
-    const str = await readFile(path16, "utf8");
+  if (path15.endsWith(".json")) {
+    const str = await readFile(path15, "utf8");
     const json = JSON.parse(str);
     logger.debug("Loaded JSON payload");
     return json;
@@ -158,17 +164,17 @@ var namespaces = {
   [COMPILER]: "CMP",
   [JOB]: "JOB"
 };
-var createLogger2 = (name = "", options) => {
-  const logOptions = options.log || {};
+var createLogger2 = (name = "", options6) => {
+  const logOptions = options6.log || {};
   let json = false;
   let level = logOptions[name] || logOptions.default || "default";
-  if (options.logJson) {
+  if (options6.logJson) {
     json = true;
   }
   return actualCreateLogger(namespaces[name] || name, {
     level,
     json,
-    sanitize: options.sanitize || "none",
+    sanitize: options6.sanitize || "none",
     ...logOptions
   });
 };
@@ -179,8 +185,8 @@ var createNullLogger = () => createLogger2(void 0, { log: { default: "none" } })
 import fs from "node:fs";
 import path2 from "node:path";
 import { rmdir } from "node:fs/promises";
-var getCachePath = async (plan, options, stepId) => {
-  const { baseDir } = options;
+var getCachePath = async (plan, options6, stepId) => {
+  const { baseDir } = options6;
   const { name } = plan.workflow;
   const basePath = `${baseDir}/.cli-cache/${name}`;
   if (stepId) {
@@ -188,10 +194,10 @@ var getCachePath = async (plan, options, stepId) => {
   }
   return path2.resolve(basePath);
 };
-var ensureGitIgnore = (options) => {
-  if (!options._hasGitIgnore) {
+var ensureGitIgnore = (options6) => {
+  if (!options6._hasGitIgnore) {
     const ignorePath = path2.resolve(
-      options.baseDir,
+      options6.baseDir,
       ".cli-cache",
       ".gitignore"
     );
@@ -201,19 +207,19 @@ var ensureGitIgnore = (options) => {
       fs.writeFileSync(ignorePath, "*");
     }
   }
-  options._hasGitIgnore = true;
+  options6._hasGitIgnore = true;
 };
-var saveToCache = async (plan, stepId, output, options, logger) => {
-  if (options.cacheSteps) {
-    const cachePath = await getCachePath(plan, options, stepId);
+var saveToCache = async (plan, stepId, output, options6, logger) => {
+  if (options6.cacheSteps) {
+    const cachePath = await getCachePath(plan, options6, stepId);
     fs.mkdirSync(path2.dirname(cachePath), { recursive: true });
-    ensureGitIgnore(options);
+    ensureGitIgnore(options6);
     logger.info(`Writing ${stepId} output to ${cachePath}`);
     fs.writeFileSync(cachePath, JSON.stringify(output));
   }
 };
-var clearCache = async (plan, options, logger) => {
-  const cacheDir = await getCachePath(plan, options);
+var clearCache = async (plan, options6, logger) => {
+  const cacheDir = await getCachePath(plan, options6);
   try {
     await rmdir(cacheDir, { recursive: true });
     logger.info(`Cleared cache at ${cacheDir}`);
@@ -256,13 +262,13 @@ var execute_default = async (plan, input, opts, logger) => {
 };
 function parseAdaptors(plan) {
   const extractInfo = (specifier) => {
-    const [module, path16] = specifier.split("=");
+    const [module, path15] = specifier.split("=");
     const { name, version } = getNameAndVersion(module);
     const info = {
       name
     };
-    if (path16) {
-      info.path = path16;
+    if (path15) {
+      info.path = path15;
     }
     if (version) {
       info.version = version;
@@ -283,7 +289,7 @@ function parseAdaptors(plan) {
 // src/execute/serialize-output.ts
 import { mkdir as mkdir2, writeFile as writeFile2 } from "node:fs/promises";
 import { dirname } from "node:path";
-var serializeOutput2 = async (options, result, logger) => {
+var serializeOutput2 = async (options6, result, logger) => {
   let output = result;
   if (output && (output.configuration || output.data)) {
     const { configuration, ...rest } = result;
@@ -294,14 +300,14 @@ var serializeOutput2 = async (options, result, logger) => {
   } else {
     output = JSON.stringify(output, void 0, 2);
   }
-  if (options.outputStdout) {
+  if (options6.outputStdout) {
     logger.success(`Result: `);
     logger.always(output);
-  } else if (options.outputPath) {
-    await mkdir2(dirname(options.outputPath), { recursive: true });
-    logger.debug(`Writing output to ${options.outputPath}`);
-    await writeFile2(options.outputPath, output);
-    logger.success(`State written to ${options.outputPath}`);
+  } else if (options6.outputPath) {
+    await mkdir2(dirname(options6.outputPath), { recursive: true });
+    logger.debug(`Writing output to ${options6.outputPath}`);
+    await writeFile2(options6.outputPath, output);
+    logger.success(`State written to ${options6.outputPath}`);
   }
   return output;
 };
@@ -328,16 +334,16 @@ import {
   loadRepoPkg,
   getNameAndVersion as getNameAndVersion2
 } from "@openfn/runtime";
-var install = async (opts, log = defaultLogger) => {
+var install = async (opts, log2 = defaultLogger) => {
   let { packages, adaptors, repoDir } = opts;
   const targets = [].concat(packages ?? [], adaptors ?? []);
   if (targets) {
-    log.timer("install");
-    log.success("Installing packages...");
-    log.debug("repoDir is set to:", repoDir);
-    const result = await rtInstall(targets, repoDir, log);
-    const duration = log.timer("install");
-    log.success(`Installation complete in ${duration}`);
+    log2.timer("install");
+    log2.success("Installing packages...");
+    log2.debug("repoDir is set to:", repoDir);
+    const result = await rtInstall(targets, repoDir, log2);
+    const duration = log2.timer("install");
+    log2.success(`Installation complete in ${duration}`);
     return result;
   }
   return [];
@@ -365,16 +371,16 @@ var removePackage = async (packageSpecifier, repoDir, logger) => {
     logger.warn(`Failed to remove ${aliasedName}: ${error.message}`);
   }
 };
-var clean = async (options, logger) => {
-  if (options.repoDir) {
+var clean = async (options6, logger) => {
+  if (options6.repoDir) {
     const doIt = await logger.confirm(
-      `This will remove everything at ${options.repoDir}. Do you wish to proceed?`,
-      options.force
+      `This will remove everything at ${options6.repoDir}. Do you wish to proceed?`,
+      options6.force
     );
     if (doIt) {
       return new Promise((resolve) => {
-        logger.info(`Cleaning repo at ${options.repoDir} `);
-        exec(`npm exec rimraf ${options.repoDir}`, () => {
+        logger.info(`Cleaning repo at ${options6.repoDir} `);
+        exec(`npm exec rimraf ${options6.repoDir}`, () => {
           logger.success("Repo cleaned");
           resolve();
         });
@@ -385,12 +391,12 @@ var clean = async (options, logger) => {
     logger.error("No repoDir path detected");
   }
 };
-var pwd = async (options, logger) => {
+var pwd = async (options6, logger) => {
   logger.info(`OPENFN_REPO_DIR is set to ${process.env.OPENFN_REPO_DIR}`);
-  logger.success(`Repo working directory is: ${options.repoDir}`);
+  logger.success(`Repo working directory is: ${options6.repoDir}`);
 };
-var getDependencyList = async (options, _logger) => {
-  const pkg = await loadRepoPkg(options.repoDir);
+var getDependencyList = async (options6, _logger) => {
+  const pkg = await loadRepoPkg(options6.repoDir);
   const result = {};
   if (pkg) {
     Object.keys(pkg.dependencies).forEach((key) => {
@@ -403,9 +409,9 @@ var getDependencyList = async (options, _logger) => {
   }
   return result;
 };
-var list = async (options, logger) => {
-  const tree = await getDependencyList(options, logger);
-  await pwd(options, logger);
+var list = async (options6, logger) => {
+  const tree = await getDependencyList(options6, logger);
+  await pwd(options6, logger);
   const output = {};
   Object.keys(tree).forEach((key) => {
     const versions = tree[key];
@@ -463,27 +469,27 @@ var throwAbortableError = (message, help) => {
 };
 
 // src/compile/compile.ts
-async function compile_default(planOrPath, opts, log) {
+async function compile_default(planOrPath, opts, log2) {
   if (typeof planOrPath === "string") {
-    const result = await compileJob(planOrPath, opts, log);
-    log.success(`Compiled expression from ${opts.expressionPath}`);
+    const result = await compileJob(planOrPath, opts, log2);
+    log2.success(`Compiled expression from ${opts.expressionPath}`);
     return result;
   }
   const compiledPlan = await compileWorkflow(
     planOrPath,
     opts,
-    log
+    log2
   );
-  log.success("Compiled all expressions in workflow");
+  log2.success("Compiled all expressions in workflow");
   return compiledPlan;
 }
-var compileJob = async (job, opts, log, jobName) => {
+var compileJob = async (job, opts, log2, jobName) => {
   try {
-    const compilerOptions = await loadTransformOptions(opts, log);
+    const compilerOptions = await loadTransformOptions(opts, log2);
     return compile(job, compilerOptions);
   } catch (e) {
     abort_default(
-      log,
+      log2,
       `Failed to compile job ${jobName ?? ""}`.trim(),
       e,
       "Check the syntax of the job expression:\n\n" + job
@@ -491,7 +497,7 @@ var compileJob = async (job, opts, log, jobName) => {
     return { code: job };
   }
 };
-var compileWorkflow = async (plan, opts, log) => {
+var compileWorkflow = async (plan, opts, log2) => {
   let globalsIgnoreList = getExports(plan.workflow.globals);
   for (const step of plan.workflow.steps) {
     const job = step;
@@ -505,7 +511,7 @@ var compileWorkflow = async (plan, opts, log) => {
       const { code, map } = await compileJob(
         job.expression,
         jobOpts,
-        log,
+        log2,
         job.id
       );
       job.expression = code;
@@ -521,21 +527,21 @@ var stripVersionSpecifier = (specifier) => {
   }
   return specifier;
 };
-var resolveSpecifierPath = async (pattern, repoDir, log) => {
-  const [specifier, path16] = pattern.split("=");
-  if (path16) {
-    log.debug(`Resolved ${specifier} to path: ${path16}`);
-    return path16;
+var resolveSpecifierPath = async (pattern, repoDir, log2) => {
+  const [specifier, path15] = pattern.split("=");
+  if (path15) {
+    log2.debug(`Resolved ${specifier} to path: ${path15}`);
+    return path15;
   }
-  const repoPath = await getModulePath(specifier, repoDir, log);
+  const repoPath = await getModulePath(specifier, repoDir, log2);
   if (repoPath) {
     return repoPath;
   }
   return null;
 };
-var loadTransformOptions = async (opts, log) => {
-  const options = {
-    logger: log || logger_default(COMPILER, opts),
+var loadTransformOptions = async (opts, log2) => {
+  const options6 = {
+    logger: log2 || logger_default(COMPILER, opts),
     trace: opts.trace
   };
   if (opts.adaptors?.length && opts.ignoreImports != true) {
@@ -543,18 +549,18 @@ var loadTransformOptions = async (opts, log) => {
     for (const adaptorInput of opts.adaptors) {
       let exports;
       const [specifier] = adaptorInput.split("=");
-      log.debug(`Trying to preload types for ${specifier}`);
-      const path16 = await resolveSpecifierPath(adaptorInput, opts.repoDir, log);
-      if (path16) {
+      log2.debug(`Trying to preload types for ${specifier}`);
+      const path15 = await resolveSpecifierPath(adaptorInput, opts.repoDir, log2);
+      if (path15) {
         try {
-          exports = await preloadAdaptorExports(path16, log);
+          exports = await preloadAdaptorExports(path15, log2);
         } catch (e) {
-          log.error(`Failed to load adaptor typedefs from path ${path16}`);
-          log.error(e);
+          log2.error(`Failed to load adaptor typedefs from path ${path15}`);
+          log2.error(e);
         }
       }
       if (!exports || exports.length === 0) {
-        log.debug(`No module exports found for ${adaptorInput}`);
+        log2.debug(`No module exports found for ${adaptorInput}`);
       }
       adaptorsConfig.push({
         name: stripVersionSpecifier(specifier),
@@ -562,12 +568,12 @@ var loadTransformOptions = async (opts, log) => {
         exportAll: true
       });
     }
-    options["add-imports"] = {
+    options6["add-imports"] = {
       ignore: opts.ignoreImports,
       adaptors: adaptorsConfig
     };
   }
-  return options;
+  return options6;
 };
 
 // src/util/load-state.ts
@@ -585,72 +591,72 @@ var getUpstreamStepId = (plan, stepId) => {
     return typeof upstreamStep === "string" ? upstreamStep : upstreamStep.id;
   }
 };
-var load_state_default = async (plan, opts, log, start) => {
-  const { stateStdin, statePath } = opts;
-  log.debug("Loading state...");
+var load_state_default = async (plan, opts, log2, start) => {
+  const { stateStdin, statePath: statePath2 } = opts;
+  log2.debug("Loading state...");
   if (stateStdin) {
     try {
       const json = JSON.parse(stateStdin);
-      log.success("Read state from stdin");
-      log.debug("state:", json);
+      log2.success("Read state from stdin");
+      log2.debug("state:", json);
       return json;
     } catch (e) {
-      log.error("Failed to load state from stdin");
-      log.error(stateStdin);
-      log.error(e);
+      log2.error("Failed to load state from stdin");
+      log2.error(stateStdin);
+      log2.error(e);
       process.exit(1);
     }
   }
-  if (statePath) {
+  if (statePath2) {
     try {
-      const str = await fs2.readFile(statePath, "utf8");
+      const str = await fs2.readFile(statePath2, "utf8");
       const json = JSON.parse(str);
-      log.success(`Loaded state from ${statePath}`);
-      log.debug("state:", json);
+      log2.success(`Loaded state from ${statePath2}`);
+      log2.debug("state:", json);
       return json;
     } catch (e) {
-      log.warn(`Error loading state from ${statePath}`);
-      log.warn(e);
+      log2.warn(`Error loading state from ${statePath2}`);
+      log2.warn(e);
     }
   }
   if (start) {
-    log.info(
+    log2.info(
       "No state provided to CLI. Will attempt to load state from cache instead"
     );
-    log.always(
+    log2.always(
       `Attempting to load cached input state for starting step "${start}"`
     );
     try {
       const upstreamStepId = getUpstreamStepId(plan, start);
       if (upstreamStepId) {
-        log.debug(`Input step for "${start}" is "${upstreamStepId}"`);
+        log2.debug(`Input step for "${start}" is "${upstreamStepId}"`);
         const cachedStatePath = await getCachePath(plan, opts, upstreamStepId);
-        log.debug("Loading cached state from", cachedStatePath);
+        log2.debug("Loading cached state from", cachedStatePath);
         try {
           await fs2.access(cachedStatePath);
           const str = await fs2.readFile(cachedStatePath, "utf8");
           const json = JSON.parse(str);
-          log.success(
+          log2.success(
             `Loaded cached state for step "${start}" from ${cachedStatePath}`
           );
-          log.info(`  To force disable the cache, run again with --no-cache`);
+          log2.info(`  To force disable the cache, run again with --no-cache`);
           return json;
         } catch (e) {
-          log.warn(`No cached state found for step "${start}"`);
-          log.warn(
+          log2.warn(`No cached state found for step "${start}"`);
+          log2.warn(
             "Re-run this workflow with --cache to save the output of each step"
           );
-          log.break();
+          log2.break();
         }
       } else {
-        log.warn(`Could not find an input step for step "${start}"`);
+        log2.warn(`Could not find an input step for step "${start}"`);
       }
     } catch (e) {
-      log.warn("Error loading cached state");
-      log.warn(e);
+      log2.warn("Error loading cached state");
+      log2.warn(e);
     }
   }
-  log.info(
+  log2.info(
     "No state provided - using default state { data: {}, configuration: {} }"
   );
   return {
@@ -660,12 +666,12 @@ var load_state_default = async (plan, opts, log, start) => {
 };
 
 // src/util/validate-adaptors.ts
-var validateAdaptors = async (options, logger) => {
-  if (options.skipAdaptorValidation) {
+var validateAdaptors = async (options6, logger) => {
+  if (options6.skipAdaptorValidation) {
     return;
   }
-  const isPlan = options.planPath || options.workflowPath || options.workflow;
-  const hasDeclaredAdaptors = options.adaptors && options.adaptors.length > 0;
+  const isPlan = options6.planPath || options6.workflowPath || options6.workflow;
+  const hasDeclaredAdaptors = options6.adaptors && options6.adaptors.length > 0;
   if (isPlan && hasDeclaredAdaptors) {
     logger.error("ERROR: adaptor and workflow provided");
     logger.error(
@@ -721,43 +727,43 @@ import { readFile as readFile2 } from "node:fs/promises";
 import path3 from "node:path";
 import assert from "node:assert";
 import { getNameAndVersion as getNameAndVersion3 } from "@openfn/runtime";
-var validateMonoRepo = async (repoPath, log) => {
+var validateMonoRepo = async (repoPath, log2) => {
   try {
     const raw = await readFile2(`${repoPath}/package.json`, "utf8");
     const pkg = JSON.parse(raw);
     assert(pkg.name === "adaptors");
   } catch (e) {
-    log.error(`ERROR: Adaptors Monorepo not found at ${repoPath}`);
+    log2.error(`ERROR: Adaptors Monorepo not found at ${repoPath}`);
     process.exit(9);
   }
 };
-var updatePath = (adaptor, repoPath, log) => {
+var updatePath = (adaptor, repoPath, log2) => {
   if (adaptor.match("=")) {
     return adaptor;
   }
   const { name, version } = getNameAndVersion3(adaptor);
   if (version) {
-    log.warn(
+    log2.warn(
       `Warning: Ignoring version specifier on ${adaptor} as loading from the adaptors monorepo`
     );
   }
   const shortName = name.replace("@openfn/language-", "");
   const abspath = path3.resolve(repoPath, "packages", shortName);
-  log.info(`Mapped adaptor ${name} to monorepo: ${abspath}`);
+  log2.info(`Mapped adaptor ${name} to monorepo: ${abspath}`);
   return `${name}=${abspath}`;
 };
-var mapAdaptorsToMonorepo = (monorepoPath = "", input = [], log) => {
+var mapAdaptorsToMonorepo = (monorepoPath = "", input = [], log2) => {
   if (monorepoPath) {
     if (Array.isArray(input)) {
       const adaptors = input;
-      return adaptors.map((a) => updatePath(a, monorepoPath, log));
+      return adaptors.map((a) => updatePath(a, monorepoPath, log2));
     }
     const plan = input;
     Object.values(plan.workflow.steps).forEach((step) => {
       const job = step;
       if (job.adaptors) {
         job.adaptors = job.adaptors.map(
-          (a) => updatePath(a, monorepoPath, log)
+          (a) => updatePath(a, monorepoPath, log2)
         );
       }
     });
@@ -768,47 +774,47 @@ var mapAdaptorsToMonorepo = (monorepoPath = "", input = [], log) => {
 var map_adaptors_to_monorepo_default = mapAdaptorsToMonorepo;
 
 // src/util/load-plan.ts
-var loadPlan = async (options, logger) => {
-  const { workflowPath, planPath, expressionPath } = options;
-  if (options.path && /ya?ml$/.test(options.path)) {
-    const content = await fs3.readFile(path4.resolve(options.path), "utf-8");
-    const workflow = yamlToJson(content);
-    options.baseDir = dirname2(options.path);
-    return loadXPlan({ workflow }, options, logger);
-  }
-  if (options.path && options.workflow) {
-    options.baseDir = options.path;
-    return fromProject(options.path, options.workflow, options, logger);
-  }
-  if (!expressionPath && !workflowPath && !/\.(js|json|yaml)+$/.test(options.path || "") && !options.workflow) {
-    const workflow = options.path;
-    return fromProject(path4.resolve("."), workflow, options, logger);
+var loadPlan = async (options6, logger) => {
+  const { workflowPath, planPath, expressionPath } = options6;
+  if (options6.path && /ya?ml$/.test(options6.path)) {
+    const content = await fs3.readFile(path4.resolve(options6.path), "utf-8");
+    const workflow2 = yamlToJson(content);
+    options6.baseDir = dirname2(options6.path);
+    return loadXPlan({ workflow: workflow2 }, options6, logger);
+  }
+  if (options6.path && options6.workflow) {
+    options6.baseDir = options6.path;
+    return fromProject(options6.path, options6.workflow, options6, logger);
+  }
+  if (!expressionPath && !workflowPath && !/\.(js|json|yaml)+$/.test(options6.path || "") && !options6.workflow) {
+    const workflow2 = options6.path;
+    return fromProject(path4.resolve("."), workflow2, options6, logger);
   }
   if (expressionPath) {
-    return loadExpression(options, logger);
+    return loadExpression(options6, logger);
   }
   const jsonPath = planPath || workflowPath;
-  if (!options.baseDir) {
-    options.baseDir = path4.dirname(jsonPath);
+  if (!options6.baseDir) {
+    options6.baseDir = path4.dirname(jsonPath);
   }
   const json = await loadJson(jsonPath, logger);
   const defaultName = path4.parse(jsonPath).name;
   if (json.workflow) {
-    return loadXPlan(json, options, logger, defaultName);
+    return loadXPlan(json, options6, logger, defaultName);
   } else {
-    return loadOldWorkflow(json, options, logger, defaultName);
+    return loadOldWorkflow(json, options6, logger, defaultName);
   }
 };
 var load_plan_default = loadPlan;
-var fromProject = async (rootDir, workflowName, options, logger) => {
+var fromProject = async (rootDir, workflowName, options6, logger) => {
   logger.debug("Loading Repo from ", path4.resolve(rootDir));
   const project = await Project.from("fs", { root: rootDir });
   logger.debug("Loading workflow ", workflowName);
-  const workflow = project.getWorkflow(workflowName);
-  if (!workflow) {
+  const workflow2 = project.getWorkflow(workflowName);
+  if (!workflow2) {
     throw new Error(`Workflow "${workflowName}" not found`);
   }
-  return loadXPlan({ workflow }, options, logger);
+  return loadXPlan({ workflow: workflow2 }, options6, logger);
 };
 var loadJson = async (workflowPath, logger) => {
   let text;
@@ -843,8 +849,8 @@ var maybeAssign = (a, b, keys) => {
     }
   });
 };
-var loadExpression = async (options, logger) => {
-  const expressionPath = options.expressionPath;
+var loadExpression = async (options6, logger) => {
+  const expressionPath = options6.expressionPath;
   logger.debug(`Loading expression from ${expressionPath}`);
   try {
     const expression = await fs3.readFile(expressionPath, "utf8");
@@ -852,19 +858,19 @@ var loadExpression = async (options, logger) => {
     const step = {
       expression,
       // The adaptor should have been expanded nicely already, so we don't need intervene here
-      adaptors: options.adaptors ?? []
+      adaptors: options6.adaptors ?? []
     };
     const wfOptions = {};
-    maybeAssign(options, wfOptions, ["timeout"]);
+    maybeAssign(options6, wfOptions, ["timeout"]);
     const plan = {
       workflow: {
         name,
         steps: [step],
-        globals: options.globals
+        globals: options6.globals
       },
       options: wfOptions
     };
-    return loadXPlan(plan, options, logger);
+    return loadXPlan(plan, options6, logger);
   } catch (e) {
     abort_default(
       logger,
@@ -875,33 +881,33 @@ var loadExpression = async (options, logger) => {
     return {};
   }
 };
-var loadOldWorkflow = async (workflow, options, logger, defaultName = "") => {
+var loadOldWorkflow = async (workflow2, options6, logger, defaultName = "") => {
   const plan = {
     workflow: {
-      steps: workflow.jobs
+      steps: workflow2.jobs
     },
     options: {
-      start: workflow.start
+      start: workflow2.start
     }
   };
-  if (workflow.id) {
-    plan.id = workflow.id;
+  if (workflow2.id) {
+    plan.id = workflow2.id;
   }
-  const final = await loadXPlan(plan, options, logger, defaultName);
+  const final = await loadXPlan(plan, options6, logger, defaultName);
   logger.warn("Converted workflow into new format:");
   logger.warn(final);
   return final;
 };
-var fetchFile = async (fileInfo, log) => {
+var fetchFile = async (fileInfo, log2) => {
   const { rootDir = "", filePath, name } = fileInfo;
   try {
     const fullPath = filePath.startsWith("~") ? filePath : path4.resolve(rootDir, filePath);
     const result = await fs3.readFile(fullPath, "utf8");
-    log.debug("Loaded file", fullPath);
+    log2.debug("Loaded file", fullPath);
     return result;
   } catch (e) {
     abort_default(
-      log,
+      log2,
       `File not found for ${name}: ${filePath}`,
       void 0,
       `This workflow references a file which cannot be found at ${filePath}
@@ -911,20 +917,20 @@ Paths inside the workflow are relative to the workflow.json`
     return ".";
   }
 };
-var importGlobals = async (plan, rootDir, log) => {
+var importGlobals = async (plan, rootDir, log2) => {
   const fnStr = plan.workflow?.globals;
   if (fnStr) {
     if (isPath(fnStr)) {
       plan.workflow.globals = await fetchFile(
         { name: "globals", rootDir, filePath: fnStr },
-        log
+        log2
       );
     } else {
       plan.workflow.globals = fnStr;
     }
   }
 };
-var importExpressions = async (plan, rootDir, log) => {
+var importExpressions = async (plan, rootDir, log2) => {
   let idx = 0;
   for (const step of plan.workflow.steps) {
     const job = step;
@@ -942,7 +948,7 @@ var importExpressions = async (plan, rootDir, log) => {
           rootDir,
           filePath: expressionStr
         },
-        log
+        log2
       );
     }
     if (configurationStr && isPath(configurationStr)) {
@@ -952,7 +958,7 @@ var importExpressions = async (plan, rootDir, log) => {
           rootDir,
           filePath: configurationStr
         },
-        log
+        log2
       );
       job.configuration = JSON.parse(configString);
     }
@@ -963,7 +969,7 @@ var importExpressions = async (plan, rootDir, log) => {
           rootDir,
           filePath: stateStr
         },
-        log
+        log2
       );
       job.state = JSON.parse(stateString);
     }
@@ -979,7 +985,7 @@ var ensureAdaptors = (plan) => {
     job.adaptors ??= [];
   });
 };
-var loadXPlan = async (plan, options, logger, defaultName = "") => {
+var loadXPlan = async (plan, options6, logger, defaultName = "") => {
   if (!plan.options) {
     plan.options = {};
   }
@@ -987,22 +993,22 @@ var loadXPlan = async (plan, options, logger, defaultName = "") => {
     plan.workflow.name = defaultName;
   }
   ensureAdaptors(plan);
-  if (options.globals)
-    plan.workflow.globals = options.globals;
-  await importGlobals(plan, options.baseDir, logger);
-  await importExpressions(plan, options.baseDir, logger);
-  if (options.expandAdaptors) {
+  if (options6.globals)
+    plan.workflow.globals = options6.globals;
+  await importGlobals(plan, options6.baseDir, logger);
+  await importExpressions(plan, options6.baseDir, logger);
+  if (options6.expandAdaptors) {
     expand_adaptors_default(plan);
   }
-  await map_adaptors_to_monorepo_default(options.monorepoPath, plan, logger);
-  maybeAssign(options, plan.options, ["timeout", "start"]);
+  await map_adaptors_to_monorepo_default(options6.monorepoPath, plan, logger);
+  maybeAssign(options6, plan.options, ["timeout", "start"]);
   logger.info(`Loaded workflow ${plan.workflow.name ?? ""}`);
   return plan;
 };
 
 // src/util/assert-path.ts
-var assert_path_default = (path16) => {
-  if (!path16) {
+var assert_path_default = (path15) => {
+  if (!path15) {
     console.error("ERROR: no path provided!");
     console.error("\nUsage:");
     console.error("  open path/to/job");
@@ -1038,20 +1044,20 @@ var fuzzy_match_step_default = (plan, stepPattern) => {
 
 // src/util/validate-plan.ts
 var assertWorkflowStructure = (plan, logger) => {
-  const { workflow, options } = plan;
-  if (!workflow || typeof workflow !== "object") {
+  const { workflow: workflow2, options: options6 } = plan;
+  if (!workflow2 || typeof workflow2 !== "object") {
     throw new Error(`Missing or invalid "workflow" key in execution plan`);
   }
-  if (!Array.isArray(workflow.steps)) {
+  if (!Array.isArray(workflow2.steps)) {
     throw new Error("The workflow.steps key must be an array");
   }
-  if (workflow.steps.length === 0) {
+  if (workflow2.steps.length === 0) {
     logger.warn("The workflow.steps array is empty");
   }
-  workflow.steps.forEach((step, index) => {
+  workflow2.steps.forEach((step, index) => {
     assertStepStructure(step, index);
   });
-  assertOptionsStructure(options, logger);
+  assertOptionsStructure(options6, logger);
 };
 var assertStepStructure = (step, index) => {
   const allowedKeys = [
@@ -1078,9 +1084,9 @@ var assertStepStructure = (step, index) => {
     );
   }
 };
-var assertOptionsStructure = (options = {}, logger) => {
+var assertOptionsStructure = (options6 = {}, logger) => {
   const allowedKeys = ["timeout", "stepTimeout", "start", "end", "sanitize"];
-  for (const key in options) {
+  for (const key in options6) {
     if (!allowedKeys.includes(key)) {
       logger.warn(`Unrecognized option "${key}" in options object`);
     }
@@ -1136,17 +1142,17 @@ var matchStep = (plan, stepPattern, stepName, logger) => {
   }
   return "";
 };
-var executeHandler = async (options, logger) => {
+var executeHandler = async (options6, logger) => {
   const start = (/* @__PURE__ */ new Date()).getTime();
-  assert_path_default(options.path);
-  await validate_adaptors_default(options, logger);
-  let plan = await load_plan_default(options, logger);
+  assert_path_default(options6.path);
+  await validate_adaptors_default(options6, logger);
+  let plan = await load_plan_default(options6, logger);
   validate_plan_default(plan, logger);
-  if (options.cacheSteps) {
-    await clearCache(plan, options, logger);
+  if (options6.cacheSteps) {
+    await clearCache(plan, options6, logger);
   }
   const moduleResolutions = {};
-  const { repoDir, monorepoPath, autoinstall } = options;
+  const { repoDir, monorepoPath, autoinstall } = options6;
   if (autoinstall) {
     if (monorepoPath) {
       logger.warn("Skipping auto-install as monorepo is being used");
@@ -1154,13 +1160,13 @@ var executeHandler = async (options, logger) => {
       const autoInstallTargets = get_autoinstall_targets_default(plan);
       if (autoInstallTargets.length) {
         logger.info("Auto-installing language adaptors");
-        options.adaptors = await install(
+        options6.adaptors = await install(
           { packages: autoInstallTargets, repoDir },
           logger
         );
-        if (autoInstallTargets.length === options.adaptors.length) {
+        if (autoInstallTargets.length === options6.adaptors.length) {
           for (let i = 0; i < autoInstallTargets.length; i++) {
-            moduleResolutions[autoInstallTargets[i]] = options.adaptors[i];
+            moduleResolutions[autoInstallTargets[i]] = options6.adaptors[i];
           }
         }
       }
@@ -1168,35 +1174,35 @@ var executeHandler = async (options, logger) => {
   }
   let customStart;
   let customEnd;
-  if (options.only) {
-    const step = matchStep(plan, options.only, "only", logger);
+  if (options6.only) {
+    const step = matchStep(plan, options6.only, "only", logger);
     customStart = step;
     customEnd = step;
-    logger.always(`Only running workflow step "${options.start}"`);
+    logger.always(`Only running workflow step "${options6.start}"`);
   } else {
-    if (options.start) {
+    if (options6.start) {
       customStart = matchStep(
         plan,
-        options.start ?? plan.options.start,
+        options6.start ?? plan.options.start,
         "start",
         logger
       );
-      logger.info(`Starting workflow from step "${options.start}"`);
+      logger.info(`Starting workflow from step "${options6.start}"`);
     }
-    if (options.end) {
+    if (options6.end) {
       customEnd = matchStep(
         plan,
-        options.end ?? plan.options.end,
+        options6.end ?? plan.options.end,
         "end",
         logger
       );
-      logger.always(`Ending workflow at step "${options.end}"`);
+      logger.always(`Ending workflow at step "${options6.end}"`);
     }
   }
-  const state = await load_state_default(plan, options, logger, customStart);
+  const state = await load_state_default(plan, options6, logger, customStart);
   plan = override_plan_adaptors_default(plan, moduleResolutions);
-  if (options.compile) {
-    plan = await compile_default(plan, options, logger);
+  if (options6.compile) {
+    plan = await compile_default(plan, options6, logger);
   } else {
     logger.info("Skipping compilation as noCompile is set");
   }
@@ -1210,13 +1216,13 @@ var executeHandler = async (options, logger) => {
     workflow: plan.workflow
   };
   try {
-    const result = await execute_default(finalPlan, state, options, logger);
-    if (options.cacheSteps) {
+    const result = await execute_default(finalPlan, state, options6, logger);
+    if (options6.cacheSteps) {
       logger.success(
         "Cached output written to ./cli-cache (see info logs for details)"
       );
     }
-    await serialize_output_default(options, result, logger);
+    await serialize_output_default(options6, result, logger);
     const duration = printDuration((/* @__PURE__ */ new Date()).getTime() - start);
     if (result?.errors) {
       logger.warn(
@@ -1239,22 +1245,22 @@ var handler_default2 = executeHandler;
 
 // src/compile/handler.ts
 import { writeFile as writeFile3 } from "node:fs/promises";
-var compileHandler = async (options, logger) => {
-  assert_path_default(options.path);
+var compileHandler = async (options6, logger) => {
+  assert_path_default(options6.path);
   let result;
-  if (options.expressionPath) {
-    const { code } = await compile_default(options.expressionPath, options, logger);
+  if (options6.expressionPath) {
+    const { code } = await compile_default(options6.expressionPath, options6, logger);
     result = code;
   } else {
-    const plan = await load_plan_default(options, logger);
-    const compiledPlan = await compile_default(plan, options, logger);
+    const plan = await load_plan_default(options6, logger);
+    const compiledPlan = await compile_default(plan, options6, logger);
     result = JSON.stringify(compiledPlan, null, 2);
   }
-  if (options.outputStdout) {
+  if (options6.outputStdout) {
     logger.success("Result:\n\n" + result);
   } else {
-    await writeFile3(options.outputPath, result);
-    logger.success(`Compiled to ${options.outputPath}`);
+    await writeFile3(options6.outputPath, result);
+    logger.success(`Compiled to ${options6.outputPath}`);
   }
 };
 var handler_default3 = compileHandler;
@@ -1267,27 +1273,27 @@ import { readFile as readFile3, writeFile as writeFile4 } from "node:fs/promises
 import path5 from "node:path";
 import { request } from "undici";
 var DEFAULT_PAGE_SIZE = 1e3;
-var request_default = async (method, options, logger) => {
-  const base = options.lightning || process.env.OPENFN_ENDPOINT || "https://app.openfn.org";
-  const url2 = path5.join(base, "/collections", options.collectionName);
+var request_default = async (method, options6, logger) => {
+  const base = options6.lightning || process.env.OPENFN_ENDPOINT || "https://app.openfn.org";
+  const url2 = path5.join(base, "/collections", options6.collectionName);
   logger.debug("Calling Collections server at ", url2);
   const headers = {
-    Authorization: `Bearer ${options.token}`
+    Authorization: `Bearer ${options6.token}`
   };
   const query = Object.assign(
     {
-      key: options.key,
-      limit: options.pageSize || DEFAULT_PAGE_SIZE
+      key: options6.key,
+      limit: options6.pageSize || DEFAULT_PAGE_SIZE
     },
-    options.query
+    options6.query
   );
   const args = {
     headers,
     method,
     query
   };
-  if (options.data) {
-    args.body = JSON.stringify(options.data);
+  if (options6.data) {
+    args.body = JSON.stringify(options6.data);
     headers["content-type"] = "application/json";
   }
   let result = {};
@@ -1298,11 +1304,11 @@ var request_default = async (method, options, logger) => {
     if (cursor) {
       query.cursor = cursor;
     }
-    if (options.limit) {
-      limit = options.limit;
+    if (options6.limit) {
+      limit = options6.limit;
       query.limit = Math.min(
-        options.pageSize || DEFAULT_PAGE_SIZE,
-        options.limit - count
+        options6.pageSize || DEFAULT_PAGE_SIZE,
+        options6.limit - count
       );
     }
     try {
@@ -1396,7 +1402,7 @@ var ensureToken = (opts, logger) => {
     }
   }
 };
-var buildQuery = (options) => {
+var buildQuery = (options6) => {
   const map = {
     createdBefore: "created_before",
     createdAfter: "created_after",
@@ -1405,34 +1411,34 @@ var buildQuery = (options) => {
   };
   const query = {};
   Object.keys(map).forEach((key) => {
-    if (options[key]) {
-      query[map[key]] = options[key];
+    if (options6[key]) {
+      query[map[key]] = options6[key];
     }
   });
   return query;
 };
-var get = async (options, logger) => {
-  ensureToken(options, logger);
-  const multiMode = options.key.includes("*");
+var get = async (options6, logger) => {
+  ensureToken(options6, logger);
+  const multiMode = options6.key.includes("*");
   if (multiMode) {
     logger.info(
-      `Fetching multiple items from collection "${options.collectionName}" with pattern ${options.key}`
+      `Fetching multiple items from collection "${options6.collectionName}" with pattern ${options6.key}`
     );
   } else {
     logger.info(
-      `Fetching "${options.key}" from collection "${options.collectionName}"`
+      `Fetching "${options6.key}" from collection "${options6.collectionName}"`
     );
   }
   let result = await request_default(
     "GET",
     {
-      lightning: options.lightning,
-      token: options.token,
-      pageSize: options.pageSize,
-      limit: options.limit,
-      key: options.key,
-      collectionName: options.collectionName,
-      query: buildQuery(options)
+      lightning: options6.lightning,
+      token: options6.token,
+      pageSize: options6.pageSize,
+      limit: options6.limit,
+      key: options6.key,
+      collectionName: options6.collectionName,
+      query: buildQuery(options6)
     },
     logger
   );
@@ -1440,32 +1446,32 @@ var get = async (options, logger) => {
     logger.success(`Fetched ${Object.keys(result).length} items!`);
   } else {
     result = Object.values(result)[0];
-    logger.success(`Fetched ${options.key}`);
+    logger.success(`Fetched ${options6.key}`);
   }
-  if (options.outputPath) {
+  if (options6.outputPath) {
     const content = JSON.stringify(
       result,
       null,
-      options.pretty ? 2 : void 0
+      options6.pretty ? 2 : void 0
     );
-    await writeFile4(options.outputPath, content);
-    logger.always(`Wrote items to ${options.outputPath}`);
+    await writeFile4(options6.outputPath, content);
+    logger.always(`Wrote items to ${options6.outputPath}`);
   } else {
     logger.print(result);
   }
 };
-var set = async (options, logger) => {
-  if (options.key && options.items) {
+var set = async (options6, logger) => {
+  if (options6.key && options6.items) {
     throwAbortableError(
       "ARGUMENT_ERROR: arguments for key and items were provided",
       "If upserting multiple items with --items, do not pass a key"
     );
   }
-  ensureToken(options, logger);
-  logger.info(`Upserting items to collection "${options.collectionName}"`);
+  ensureToken(options6, logger);
+  logger.info(`Upserting items to collection "${options6.collectionName}"`);
   const items = [];
-  if (options.items) {
-    const resolvedPath = path6.resolve(options.items);
+  if (options6.items) {
+    const resolvedPath = path6.resolve(options6.items);
     logger.debug("Loading items from ", resolvedPath);
     const data = await readFile3(resolvedPath, "utf8");
     const obj = JSON.parse(data);
@@ -1473,43 +1479,43 @@ var set = async (options, logger) => {
       items.push({ key, value: JSON.stringify(value) });
     });
     logger.info(`Upserting ${items.length} items`);
-  } else if (options.key && options.value) {
-    const resolvedPath = path6.resolve(options.value);
+  } else if (options6.key && options6.value) {
+    const resolvedPath = path6.resolve(options6.value);
     logger.debug("Loading value from ", resolvedPath);
-    const data = await readFile3(path6.resolve(options.value), "utf8");
+    const data = await readFile3(path6.resolve(options6.value), "utf8");
     const value = JSON.stringify(JSON.parse(data));
-    items.push({ key: options.key, value });
-    logger.info(`Upserting data to "${options.key}"`);
+    items.push({ key: options6.key, value });
+    logger.info(`Upserting data to "${options6.key}"`);
   } else {
     throw new Error("INVALID_ARGUMENTS");
   }
   const result = await request_default(
     "POST",
     {
-      lightning: options.lightning,
-      token: options.token,
-      key: options.key,
-      collectionName: options.collectionName,
+      lightning: options6.lightning,
+      token: options6.token,
+      key: options6.key,
+      collectionName: options6.collectionName,
       data: { items }
     },
     logger
   );
   logger.success(`Upserted ${result.upserted} items!`);
 };
-var remove = async (options, logger) => {
-  ensureToken(options, logger);
+var remove = async (options6, logger) => {
+  ensureToken(options6, logger);
   logger.info(
-    `Removing "${options.key}" from collection "${options.collectionName}"`
+    `Removing "${options6.key}" from collection "${options6.collectionName}"`
   );
-  if (options.dryRun) {
+  if (options6.dryRun) {
     logger.info("--dry-run passed: fetching affected items");
     let result = await request_default(
       "GET",
       {
-        lightning: options.lightning,
-        token: options.token,
-        key: options.key,
-        collectionName: options.collectionName
+        lightning: options6.lightning,
+        token: options6.token,
+        key: options6.key,
+        collectionName: options6.collectionName
       },
       logger
     );
@@ -1521,11 +1527,11 @@ var remove = async (options, logger) => {
     let result = await request_default(
       "DELETE",
       {
-        lightning: options.lightning,
-        token: options.token,
-        key: options.key,
-        collectionName: options.collectionName,
-        query: buildQuery(options)
+        lightning: options6.lightning,
+        token: options6.token,
+        key: options6.key,
+        collectionName: options6.collectionName,
+        query: buildQuery(options6)
       },
       logger
     );
@@ -1539,9 +1545,9 @@ var handler_default4 = {
 };
 
 // src/test/handler.ts
-var testHandler = async (options, logger) => {
+var testHandler = async (options6, logger) => {
   logger.log("Running test workflow...");
-  const opts = { ...options };
+  const opts = { ...options6 };
   opts.compile = true;
   opts.adaptors = [];
   const plan = {
@@ -1606,50 +1612,51 @@ import {
 // src/deploy/beta.ts
 import Project2 from "@openfn/project";
 import { deployProject } from "@openfn/deploy";
-async function handler(options, logger) {
+async function handler(options6, logger) {
   const { OPENFN_API_KEY } = process.env;
-  const { endpoint } = options;
-  const config = {
-    apiKey: options.apiKey
+  const { endpoint: endpoint2 } = options6;
+  const config2 = {
+    apiKey: options6.apiKey
   };
-  if (!options.apiKey && OPENFN_API_KEY) {
+  if (!options6.apiKey && OPENFN_API_KEY) {
     logger.info("Using OPENFN_API_KEY environment variable");
-    config.apiKey = OPENFN_API_KEY;
+    config2.apiKey = OPENFN_API_KEY;
   }
-  const project = await Project2.from("fs", { root: options.path || "." });
+  const project = await Project2.from("fs", { root: options6.path || "." });
+  console.log({ openfn: project.openfn });
   const state = project.serialize("state", { format: "json" });
   logger.debug("Converted local project to app state:");
   logger.debug(JSON.stringify(state, null, 2));
-  config.endpoint = endpoint || project.openfn?.endpoint;
+  config2.endpoint = endpoint2 || project.openfn?.endpoint;
   logger.info("Sending project to app...");
-  await deployProject(config, state);
-  logger.success("Updated project at", config.endpoint);
+  await deployProject(config2, state);
+  logger.success("Updated project at", config2.endpoint);
 }
 
 // src/deploy/handler.ts
 var actualDeploy = deploy;
-async function deployHandler(options, logger, deployFn = actualDeploy) {
-  if (options.beta) {
-    return handler(options, logger);
+async function deployHandler(options6, logger, deployFn = actualDeploy) {
+  if (options6.beta) {
+    return handler(options6, logger);
   }
   try {
-    const config = mergeOverrides(await getConfig(options.configPath), options);
-    logger.debug("Deploying with config", JSON.stringify(config, null, 2));
-    if (options.confirm === false) {
-      config.requireConfirmation = options.confirm;
+    const config2 = mergeOverrides(await getConfig(options6.configPath), options6);
+    logger.debug("Deploying with config", JSON.stringify(config2, null, 2));
+    if (options6.confirm === false) {
+      config2.requireConfirmation = options6.confirm;
     }
     if (process.env["OPENFN_API_KEY"]) {
       logger.info("Using OPENFN_API_KEY environment variable");
-      config.apiKey = process.env["OPENFN_API_KEY"];
+      config2.apiKey = process.env["OPENFN_API_KEY"];
     }
     if (process.env["OPENFN_ENDPOINT"]) {
       logger.info("Using OPENFN_ENDPOINT environment variable");
-      config.endpoint = process.env["OPENFN_ENDPOINT"];
+      config2.endpoint = process.env["OPENFN_ENDPOINT"];
     }
-    logger.debug("Deploying with config", config);
+    logger.debug("Deploying with config", config2);
     logger.info(`Deploying`);
-    validateConfig(config);
-    const isOk = await deployFn(config, logger);
+    validateConfig(config2);
+    const isOk = await deployFn(config2, logger);
     process.exitCode = isOk ? 0 : 1;
     return isOk;
   } catch (error) {
@@ -1661,15 +1668,15 @@ async function deployHandler(options, logger, deployFn = actualDeploy) {
     throw error;
   }
 }
-function mergeOverrides(config, options) {
+function mergeOverrides(config2, options6) {
   return {
-    ...config,
-    apiKey: pickFirst(process.env["OPENFN_API_KEY"], config.apiKey),
-    endpoint: pickFirst(process.env["OPENFN_ENDPOINT"], config.endpoint),
-    statePath: pickFirst(options.statePath, config.statePath),
-    specPath: pickFirst(options.projectPath, config.specPath),
-    configPath: options.configPath,
-    requireConfirmation: pickFirst(options.confirm, config.requireConfirmation)
+    ...config2,
+    apiKey: pickFirst(process.env["OPENFN_API_KEY"], config2.apiKey),
+    endpoint: pickFirst(process.env["OPENFN_ENDPOINT"], config2.endpoint),
+    statePath: pickFirst(options6.statePath, config2.statePath),
+    specPath: pickFirst(options6.projectPath, config2.specPath),
+    configPath: options6.configPath,
+    requireConfirmation: pickFirst(options6.confirm, config2.requireConfirmation)
   };
 }
 function pickFirst(...args) {
@@ -1688,20 +1695,20 @@ var RETRY_COUNT = 20;
 var TIMEOUT_MS = 1e3 * 60;
 var actualDocGen = (specifier) => describePackage(specifier, {});
 var ensurePath = (filePath) => mkdirSync(path7.dirname(filePath), { recursive: true });
-var generatePlaceholder = (path16) => {
-  writeFileSync(path16, `{ "loading": true, "timestamp": ${Date.now()}}`);
+var generatePlaceholder = (path15) => {
+  writeFileSync(path15, `{ "loading": true, "timestamp": ${Date.now()}}`);
 };
 var finish = (logger, resultPath) => {
   logger.success("Done! Docs can be found at:\n");
   logger.print(`  ${path7.resolve(resultPath)}`);
 };
-var generateDocs = async (specifier, path16, docgen, logger) => {
+var generateDocs = async (specifier, path15, docgen, logger) => {
   const result = await docgen(specifier);
-  await writeFile5(path16, JSON.stringify(result, null, 2));
-  finish(logger, path16);
-  return path16;
+  await writeFile5(path15, JSON.stringify(result, null, 2));
+  finish(logger, path15);
+  return path15;
 };
-var waitForDocs = async (docs, path16, logger, retryDuration = RETRY_DURATION) => {
+var waitForDocs = async (docs, path15, logger, retryDuration = RETRY_DURATION) => {
   try {
     if (docs.hasOwnProperty("loading")) {
       logger.info("Docs are being loaded by another process. Waiting.");
@@ -1713,27 +1720,27 @@ var waitForDocs = async (docs, path16, logger, retryDuration = RETRY_DURATION) =
             clearInterval(i);
             reject(new Error("Timed out waiting for docs to load"));
           }
-          const updated = JSON.parse(readFileSync(path16, "utf8"));
+          const updated = JSON.parse(readFileSync(path15, "utf8"));
           if (!updated.hasOwnProperty("loading")) {
             logger.info("Docs found!");
             clearInterval(i);
-            resolve(path16);
+            resolve(path15);
           }
           count++;
         }, retryDuration);
       });
     } else {
-      logger.info(`Docs already written to cache at ${path16}`);
-      finish(logger, path16);
-      return path16;
+      logger.info(`Docs already written to cache at ${path15}`);
+      finish(logger, path15);
+      return path15;
     }
   } catch (e) {
     logger.error("Existing doc JSON corrupt. Aborting");
     throw e;
   }
 };
-var docgenHandler = (options, logger, docgen = actualDocGen, retryDuration = RETRY_DURATION) => {
-  const { specifier, repoDir } = options;
+var docgenHandler = (options6, logger, docgen = actualDocGen, retryDuration = RETRY_DURATION) => {
+  const { specifier, repoDir } = options6;
   const { version } = getNameAndVersion4(specifier);
   if (!version) {
     logger.error("Error: No version number detected");
@@ -1742,28 +1749,28 @@ var docgenHandler = (options, logger, docgen = actualDocGen, retryDuration = RET
     process.exit(9);
   }
   logger.success(`Generating docs for ${specifier}`);
-  const path16 = `${repoDir}/docs/${specifier}.json`;
-  ensurePath(path16);
+  const path15 = `${repoDir}/docs/${specifier}.json`;
+  ensurePath(path15);
   const handleError2 = () => {
     logger.info("Removing placeholder");
-    rmSync(path16);
+    rmSync(path15);
   };
   try {
-    const existing = readFileSync(path16, "utf8");
+    const existing = readFileSync(path15, "utf8");
     const json = JSON.parse(existing);
     if (json && json.timeout && Date.now() - json.timeout >= TIMEOUT_MS) {
       logger.info(`Expired placeholder found. Removing.`);
-      rmSync(path16);
+      rmSync(path15);
       throw new Error("TIMEOUT");
     }
-    return waitForDocs(json, path16, logger, retryDuration);
+    return waitForDocs(json, path15, logger, retryDuration);
   } catch (e) {
     if (e.message !== "TIMEOUT") {
-      logger.info(`Docs JSON not found at ${path16}`);
+      logger.info(`Docs JSON not found at ${path15}`);
     }
     logger.debug("Generating placeholder");
-    generatePlaceholder(path16);
-    return generateDocs(specifier, path16, docgen, logger).catch((e2) => {
+    generatePlaceholder(path15);
+    return generateDocs(specifier, path15, docgen, logger).catch((e2) => {
       logger.error("Error generating documentation");
       logger.error(e2);
       handleError2();
@@ -1802,8 +1809,8 @@ ${data.functions.map(
   (fn) => `  ${c.yellow(fn.name)} (${fn.parameters.map((p) => p.name).join(", ")})`
 ).sort().join("\n")}
 `;
-var docsHandler = async (options, logger) => {
-  const { adaptor, operation, repoDir } = options;
+var docsHandler = async (options6, logger) => {
+  const { adaptor, operation, repoDir } = options6;
   const adaptors = expand_adaptors_default([adaptor]);
   const [adaptorName] = adaptors;
   let { name, version } = getNameAndVersion5(adaptorName);
@@ -1814,7 +1821,7 @@ var docsHandler = async (options, logger) => {
     logger.success(`Showing docs for ${adaptorName} v${version}`);
   }
   logger.info("Generating/loading documentation...");
-  const path16 = await handler_default7(
+  const path15 = await handler_default7(
     {
       specifier: `${name}@${version}`,
       repoDir
@@ -1823,8 +1830,8 @@ var docsHandler = async (options, logger) => {
     createNullLogger()
   );
   let didError = false;
-  if (path16) {
-    const source = await readFile4(path16, "utf8");
+  if (path15) {
+    const source = await readFile4(path15, "utf8");
     const data = JSON.parse(source);
     let desc;
     if (operation) {
@@ -1894,8 +1901,8 @@ var sortKeys = (obj) => {
   });
   return newObj;
 };
-var generateKey = (config, adaptor) => {
-  const sorted = sortKeys(config);
+var generateKey = (config2, adaptor) => {
+  const sorted = sortKeys(config2);
   const key = `${JSON.stringify(sorted)}-${adaptor}`;
   return createHash("sha256").update(key).digest("hex");
 };
@@ -2008,8 +2015,8 @@ var getAdaptorPath = async (adaptor, logger, repoDir) => {
   return adaptorPath;
 };
 var shouldAutoinstall = (adaptor) => adaptor?.length > 0 && !adaptor.startsWith("/") && !adaptor.includes("=");
-var metadataHandler = async (options, logger) => {
-  const { repoDir, adaptors, keepUnsupported } = options;
+var metadataHandler = async (options6, logger) => {
+  const { repoDir, adaptors, keepUnsupported } = options6;
   let adaptor = adaptors[0];
   if (await isAdaptorUnsupported(adaptor, repoDir)) {
     logger.info(
@@ -2018,11 +2025,11 @@ var metadataHandler = async (options, logger) => {
     logger.error("No metadata helper found");
     process.exit(1);
   }
-  const state = await load_state_default({}, options, logger);
+  const state = await load_state_default({}, options6, logger);
   logger.success(`Generating metadata`);
   logger.info("config:", state);
-  const config = state.configuration;
-  if (!config || Object.keys(config).length === 0) {
+  const config2 = state.configuration;
+  if (!config2 || Object.keys(config2).length === 0) {
     logger.error("ERROR: Invalid configuration passed");
     process.exit(1);
   }
@@ -2030,8 +2037,8 @@ var metadataHandler = async (options, logger) => {
     logger.success("Done!");
     logger.print(getCachePath2(repoDir, id));
   };
-  const id = generateKey(config, adaptor);
-  if (!options.force) {
+  const id = generateKey(config2, adaptor);
+  if (!options6.force) {
     logger.debug("config hash: ", id);
     const cached = await get2(repoDir, id);
     if (cached) {
@@ -2049,14 +2056,14 @@ var metadataHandler = async (options, logger) => {
       wasAutoInstalled = true;
       adaptor = autoinstallResult[0];
     }
-    const adaptorPath = await getAdaptorPath(adaptor, logger, options.repoDir);
+    const adaptorPath = await getAdaptorPath(adaptor, logger, options6.repoDir);
     if (!adaptorPath) {
       throw new Error(`Could not resolve adaptor path for ${adaptor}`);
     }
     const mod = await import(adaptorPath);
     if (mod.metadata && typeof mod.metadata === "function") {
       logger.info("Metadata function found. Generating metadata...");
-      const result = await mod.metadata(config);
+      const result = await mod.metadata(config2);
       decorateMetadata(result);
       await set2(
         repoDir,
@@ -2091,7 +2098,7 @@ var metadataHandler = async (options, logger) => {
 var handler_default9 = metadataHandler;
 
 // src/pull/handler.ts
-import path10 from "path";
+import path12 from "path";
 import fs5 from "node:fs/promises";
 import {
   getConfig as getConfig2,
@@ -2101,106 +2108,566 @@ import {
   syncRemoteSpec
 } from "@openfn/deploy";
 
-// src/pull/beta.ts
-import { confirm } from "@inquirer/prompts";
-import path9 from "path";
-import fs4 from "node:fs/promises";
-import { getProject } from "@openfn/deploy";
+// src/projects/fetch.ts
+import path10 from "node:path";
 import Project3, { Workspace } from "@openfn/project";
-import { rimraf } from "rimraf";
-async function handler2(options, logger) {
+
+// src/util/command-builders.ts
+import c2 from "chalk";
+var expandYargs = (y) => {
+  if (typeof y === "function") {
+    return y();
+  }
+  return y;
+};
+function build(opts, yargs) {
+  return opts.reduce(
+    (_y, o) => yargs.option(o.name, expandYargs(o.yargs)),
+    yargs
+  );
+}
+var ensure = (command6, opts) => (yargs) => {
+  yargs.command = command6;
+  opts.filter((opt) => opt.ensure).forEach((opt) => {
+    try {
+      opt.ensure(yargs);
+    } catch (e) {
+      console.error(
+        c2.red(`
+Error parsing command arguments: ${command6}.${opt.name}
+`)
+      );
+      console.error(c2.red("Aborting"));
+      console.error();
+      process.exit(9);
+    }
+  });
+};
+var override = (command6, yargs) => {
+  return {
+    ...command6,
+    yargs: {
+      ...command6.yargs || {},
+      ...yargs
+    }
+  };
+};
+
+// src/options.ts
+import nodePath from "node:path";
+
+// src/util/ensure-log-opts.ts
+var defaultLoggerOptions = {
+  default: "default",
+  //  TODO fix to lower case
+  job: "debug"
+};
+var ERROR_MESSAGE_LOG_LEVEL = "Unknown log level. Valid levels are none, debug, info and default.";
+var ERROR_MESSAGE_LOG_COMPONENT = "Unknown log component. Valid components are cli, compiler, runtime and job.";
+var componentShorthands = {
+  cmp: "compiler",
+  rt: "runtime",
+  "r/t": "runtime"
+};
+var ensureLogOpts = (opts) => {
+  const components = {};
+  const outgoingOpts = opts;
+  if (!opts.log && /^(version|test)$/.test(opts.command)) {
+    outgoingOpts.log = { default: "info" };
+    return outgoingOpts;
+  }
+  if (opts.log) {
+    const parts = opts.log.split(",");
+    parts.forEach((l) => {
+      let component = "";
+      let level = "";
+      if (l.match(/=/)) {
+        const parts2 = l.split("=");
+        component = parts2[0].toLowerCase();
+        if (componentShorthands[component]) {
+          component = componentShorthands[component];
+        }
+        level = parts2[1].toLowerCase();
+      } else {
+        component = "default";
+        level = l.toLowerCase();
+        if (level === "none" && !parts.find((p) => p.startsWith("job"))) {
+          components["job"] = "none";
+        }
+      }
+      if (!/^(cli|runtime|compiler|job|default)$/i.test(component)) {
+        throw new Error(ERROR_MESSAGE_LOG_COMPONENT);
+      }
+      level = level.toLowerCase();
+      if (!isValidLogLevel(level)) {
+        throw new Error(ERROR_MESSAGE_LOG_LEVEL);
+      }
+      components[component] = level;
+    });
+  }
+  outgoingOpts.log = {
+    ...defaultLoggerOptions,
+    ...components
+  };
+  return outgoingOpts;
+};
+var ensure_log_opts_default = ensureLogOpts;
+
+// src/util/get-cli-option-object.ts
+function getCLIOptionObject(arg) {
+  if (isObject(arg)) {
+    return arg;
+  } else if (typeof arg === "string") {
+    try {
+      const p = JSON.parse(arg);
+      if (isObject(p))
+        return p;
+    } catch (e) {
+    }
+    return Object.fromEntries(
+      arg.split(",").map((pair) => {
+        const [k, v] = pair.split("=");
+        return [k.trim(), v.trim()];
+      })
+    );
+  }
+}
+function isObject(arg) {
+  return typeof arg === "object" && arg !== null && !Array.isArray(arg);
+}
+
+// src/options.ts
+var setDefaultValue = (opts, key, value) => {
+  const v = opts[key];
+  if (isNaN(v) && !v) {
+    opts[key] = value;
+  }
+};
+var apikey = {
+  name: "apikey",
+  yargs: {
+    alias: ["key", "pat", "token"],
+    description: "[beta only] API Key, Personal Access Token (Pat), or other access token"
+  }
+};
+var configPath = {
+  name: "config",
+  yargs: {
+    alias: ["c", "config-path"],
+    description: "The location of your config file",
+    default: "./.config.json"
+  }
+};
+var endpoint = {
+  name: "endpoint",
+  yargs: {
+    alias: ["lightning"],
+    description: "[beta only] URL to Lightning endpoint"
+  }
+};
+var env = {
+  name: "env",
+  yargs: {
+    description: "[beta only] Environment name (eg staging, prod, branch)"
+  }
+};
+var force = {
+  name: "force",
+  yargs: {
+    alias: ["f"],
+    boolean: true,
+    description: "Force metadata to be regenerated",
+    default: false
+  }
+};
+var getBaseDir = (opts) => {
+  const basePath = opts.path ?? ".";
+  if (/\.(jso?n?|ya?ml)$/.test(basePath)) {
+    return nodePath.dirname(basePath);
+  }
+  return basePath;
+};
+var projectId = {
+  name: "project-id",
+  yargs: {
+    description: "The id or UUID of an openfn project",
+    string: true
+  },
+  ensure: (opts) => {
+    return opts.projectName;
+  }
+};
+var log = {
+  name: "log",
+  yargs: {
+    alias: ["l"],
+    description: "Set the log level",
+    string: true
+  },
+  ensure: (opts) => {
+    ensure_log_opts_default(opts);
+  }
+};
+var logJson = {
+  name: "log-json",
+  yargs: {
+    description: "Output all logs as JSON objects",
+    boolean: true
+  }
+};
+var outputPath = {
+  name: "output-path",
+  yargs: {
+    alias: "o",
+    description: "Path to the output file"
+  },
+  ensure: (opts) => {
+    if (/^(compile|apollo)$/.test(opts.command)) {
+      if (opts.outputPath) {
+        delete opts.outputStdout;
+      }
+    } else {
+      if (opts.outputStdout) {
+        delete opts.outputPath;
+      } else {
+        const base = getBaseDir(opts);
+        setDefaultValue(opts, "outputPath", nodePath.join(base, "output.json"));
+      }
+    }
+    delete opts.o;
+  }
+};
+var snapshots = {
+  name: "snapshots",
+  yargs: {
+    description: "List of snapshot ids to pull",
+    array: true
+  }
+};
+var statePath = {
+  name: "state-path",
+  yargs: {
+    alias: ["s"],
+    description: "Path to the state file"
+  },
+  ensure: (opts) => {
+    delete opts.s;
+  }
+};
+var timeout = {
+  name: "timeout",
+  yargs: {
+    alias: ["t"],
+    number: true,
+    description: "Set the timeout duration (ms). Defaults to 5 minutes.",
+    default: 5 * 60 * 1e3
+  }
+};
+var workflow = {
+  name: "workflow",
+  yargs: {
+    string: true,
+    description: "Name of the workflow to execute"
+  }
+};
+var removeUnmapped = {
+  name: "remove-unmapped",
+  yargs: {
+    boolean: true,
+    description: "Removes all workflows that didn't get mapped from the final project after merge"
+  }
+};
+var workflowMappings = {
+  name: "workflow-mappings",
+  yargs: {
+    type: "string",
+    coerce: getCLIOptionObject,
+    description: "A manual object mapping of which workflows in source and target should be matched for a merge."
+  }
+};
+var workspace = {
+  name: "workspace",
+  yargs: {
+    alias: ["w"],
+    description: "Path to the project workspace (ie, path to openfn.yaml)"
+  },
+  ensure: (opts) => {
+    const ws = opts.workspace ?? process.env.OPENFN_WORKSPACE;
+    if (!ws) {
+      opts.workspace = process.cwd();
+    } else {
+      opts.workspace = nodePath.resolve(ws);
+    }
+  }
+};
+
+// src/projects/util.ts
+import path9 from "node:path";
+import { mkdir as mkdir4, writeFile as writeFile7 } from "node:fs/promises";
+
+// src/errors.ts
+var CLIError = class extends Error {
+  constructor(message) {
+    super(message);
+  }
+};
+
+// src/projects/util.ts
+var loadAppAuthConfig = (options6, logger) => {
   const { OPENFN_API_KEY, OPENFN_ENDPOINT } = process.env;
-  const cfg = {
-    apiKey: options.apiKey,
-    endpoint: options.endpoint
+  const config2 = {
+    apiKey: options6.apiKey,
+    endpoint: options6.endpoint
   };
-  if (!options.apiKey && OPENFN_API_KEY) {
+  if (!options6.apiKey && OPENFN_API_KEY) {
     logger.info("Using OPENFN_API_KEY environment variable");
-    cfg.apiKey = OPENFN_API_KEY;
+    config2.apiKey = OPENFN_API_KEY;
   }
-  if (!options.endpoint && OPENFN_ENDPOINT) {
+  if (!options6.endpoint && OPENFN_ENDPOINT) {
     logger.info("Using OPENFN_ENDPOINT environment variable");
-    cfg.endpoint = OPENFN_ENDPOINT;
+    config2.endpoint = OPENFN_ENDPOINT;
+  }
+  return config2;
+};
+var ensureExt = (filePath, ext) => {
+  if (!filePath.endsWith(ext)) {
+    return `${filePath}.${ext}`;
+  }
+  return filePath;
+};
+var serialize = async (project, outputPath2, formatOverride, dryRun = false) => {
+  const root = path9.dirname(outputPath2);
+  await mkdir4(root, { recursive: true });
+  const format = formatOverride ?? project.config?.formats.project;
+  const output = project?.serialize("project", { format });
+  const maybeWriteFile = (filePath, output2) => {
+    if (!dryRun) {
+      return writeFile7(filePath, output2);
+    }
+  };
+  let finalPath;
+  if (format === "yaml") {
+    finalPath = ensureExt(outputPath2, "yaml");
+    await maybeWriteFile(finalPath, output);
+  } else {
+    finalPath = ensureExt(outputPath2, "json");
+    await maybeWriteFile(finalPath, JSON.stringify(output, null, 2));
   }
-  const outputRoot = path9.resolve(options.path || ".");
-  const workspace = new Workspace(outputRoot);
-  const config = workspace.getConfig();
-  const { data } = await getProject(cfg, options.projectId);
-  const name = options.env || "project";
+  return finalPath;
+};
+var getLightningUrl = (config2, path15 = "", snapshots2) => {
+  const params = new URLSearchParams();
+  snapshots2?.forEach((snapshot) => params.append("snapshots[]", snapshot));
+  return new URL(
+    `/api/provision/${path15}?${params.toString()}`,
+    config2.endpoint
+  );
+};
+async function getProject(logger, config2, projectId2, snapshots2) {
+  const url2 = getLightningUrl(config2, projectId2, snapshots2);
+  logger.info(`Checking ${url2} for existing project`);
+  try {
+    const response = await fetch(url2, {
+      headers: {
+        Authorization: `Bearer ${config2.apiKey}`,
+        Accept: "application/json"
+      }
+    });
+    if (!response.ok) {
+      if (response.status === 401 || response.status === 403) {
+        throw new CLIError(
+          `Failed to authorize request with endpoint ${config2.endpoint}, got ${response.status} ${response.statusText}`
+        );
+      }
+      if (response.status === 404) {
+        throw new CLIError(`Project not found: ${projectId2}`);
+      }
+      throw new CLIError(
+        `Failed to fetch project ${projectId2}: ${response.statusText}`
+      );
+    }
+    logger.info("Project found");
+    return response.json();
+  } catch (error) {
+    handleCommonErrors(config2, error);
+    throw error;
+  }
+}
+function handleCommonErrors(config2, error) {
+  if (error.cause?.code === "ECONNREFUSED") {
+    throw new DeployError2(
+      `Failed to connect to endpoint ${config2.endpoint}, got ECONNREFUSED.`
+    );
+  }
+}
+var DeployError2 = class extends Error {
+  constructor(message) {
+    super(message);
+  }
+};
+
+// src/projects/fetch.ts
+var options = [
+  apikey,
+  configPath,
+  endpoint,
+  env,
+  log,
+  override(outputPath, {
+    description: "Path to output the fetched project to"
+  }),
+  logJson,
+  workspace,
+  snapshots,
+  statePath,
+  override(force, {
+    description: "Overwrite local file contents with the fetched contents"
+  })
+];
+var command = {
+  command: "fetch [projectId]",
+  describe: `Fetch a project's state and spec from a Lightning Instance to the local state file without expanding to the filesystem.`,
+  builder: (yargs) => build(options, yargs).positional("projectId", {
+    describe: "The id of the project that should be fetched, should be a UUID",
+    demandOption: true
+  }).example(
+    "fetch 57862287-23e6-4650-8d79-e1dd88b24b1c",
+    "Fetch an updated copy of a the above spec and state from a Lightning Instance"
+  ),
+  handler: ensure("project-fetch", options)
+};
+var handler2 = async (options6, logger) => {
+  const workspacePath = path10.resolve(options6.workspace ?? process.cwd());
+  const workspace2 = new Workspace(workspacePath);
+  const { projectId: projectId2, outputPath: outputPath2 } = options6;
+  const config2 = loadAppAuthConfig(options6, logger);
+  const { data } = await getProject(logger, config2, projectId2);
   const project = await Project3.from(
     "state",
     data,
     {
-      endpoint: cfg.endpoint,
-      env: name,
-      fetched_at: (/* @__PURE__ */ new Date()).toISOString()
+      endpoint: config2.endpoint,
+      env: options6.env || "project"
     },
-    config
+    workspace2.getConfig()
   );
+  const outputRoot = path10.resolve(outputPath2 || workspacePath);
   const projectFileName = project.getIdentifier();
-  await fs4.mkdir(`${outputRoot}/.projects`, { recursive: true });
-  let stateOutputPath = `${outputRoot}/.projects/${projectFileName}`;
-  const workflowsRoot = path9.resolve(
-    outputRoot,
-    project.config.dirs.workflows ?? "workflows"
+  const projectsDir = project.config.dirs.projects ?? ".projects";
+  const finalOutputPath = outputPath2 ?? `${outputRoot}/${projectsDir}/${projectFileName}`;
+  let format = void 0;
+  if (outputPath2) {
+    const ext = path10.extname(outputPath2).substring(1);
+    if (ext.length) {
+      format = ext;
+    }
+  }
+  const finalOutput = await serialize(
+    project,
+    finalOutputPath,
+    format,
+    true
+    // dry run - this won't trigger an actual write!
   );
-  if (!await confirm({
-    message: `This will remove all files in ${path9.resolve(
-      workflowsRoot
-    )} and rebuild the workflow. Are you sure you wish to proceed?
-`,
-    default: true
-  })) {
-    logger.always("Cancelled");
-    return false;
+  let current = null;
+  try {
+    current = await Project3.from("path", finalOutput);
+  } catch (e) {
+  }
+  const hasAnyHistory = project.workflows.find(
+    (w) => w.workflow.history?.length
+  );
+  const skipVersionCheck = options6.force || // The user forced the checkout
+  !current || // there is no project on disk
+  !hasAnyHistory;
+  if (!skipVersionCheck && !project.canMergeInto(current)) {
+    throw new Error("Error! An incompatible project exists at this location");
   }
-  await rimraf(workflowsRoot);
-  const state = project?.serialize("state");
-  if (project.config.formats.project === "yaml") {
-    await fs4.writeFile(`${stateOutputPath}.yaml`, state);
+  await serialize(project, finalOutputPath, format);
+  logger.success(`Fetched project file to ${finalOutput}`);
+  return project;
+};
+
+// src/projects/checkout.ts
+import Project4, { Workspace as Workspace2 } from "@openfn/project";
+import path11 from "path";
+import fs4 from "fs";
+import { rimraf } from "rimraf";
+var options2 = [projectId, workspace, log];
+var command2 = {
+  command: "checkout <project-id>",
+  describe: "Switch to a different OpenFn project in the same workspace",
+  handler: ensure("project-checkout", options2),
+  builder: (yargs) => build(options2, yargs)
+};
+var handler3 = async (options6, logger) => {
+  const projectId2 = options6.projectId;
+  const workspacePath = options6.workspace ?? process.cwd();
+  const workspace2 = new Workspace2(workspacePath, logger);
+  const { project: _, ...config2 } = workspace2.getConfig();
+  let switchProject;
+  if (/\.(yaml|json)$/.test(projectId2)) {
+    const filePath = projectId2.startsWith("/") ? projectId2 : path11.join(workspacePath, projectId2);
+    logger.debug("Loading project from path ", filePath);
+    switchProject = await Project4.from("path", filePath, config2);
   } else {
-    await fs4.writeFile(
-      `${stateOutputPath}.json`,
-      JSON.stringify(state, null, 2)
-    );
+    switchProject = workspace2.get(projectId2);
+  }
+  if (!switchProject) {
+    throw new Error(`Project with id ${projectId2} not found in the workspace`);
   }
-  logger.success(`Saved project file to ${stateOutputPath}`);
-  const files = project?.serialize("fs");
+  await rimraf(path11.join(workspacePath, config2.workflowRoot ?? "workflows"));
+  const files = switchProject.serialize("fs");
   for (const f in files) {
     if (files[f]) {
-      await fs4.mkdir(path9.join(outputRoot, path9.dirname(f)), {
+      fs4.mkdirSync(path11.join(workspacePath, path11.dirname(f)), {
         recursive: true
       });
-      await fs4.writeFile(path9.join(outputRoot, f), files[f]);
+      fs4.writeFileSync(path11.join(workspacePath, f), files[f]);
     } else {
-      console.log("WARNING! No content for file", f);
+      logger.warn("WARNING! No content for file", f);
     }
   }
-  logger.success(`Expanded project to ${outputRoot}`);
+  logger.success(`Expanded project to ${workspacePath}`);
+};
+
+// src/projects/pull.ts
+async function handler4(options6, logger) {
+  const project = await handler2(options6, logger);
+  logger.success(`Downloaded latest project version`);
+  await handler3(
+    {
+      ...options6,
+      projectId: project.id
+    },
+    logger
+  );
+  logger.success(`Checked out project locally`);
 }
+var pull_default = handler4;
 
 // src/pull/handler.ts
-async function pullHandler(options, logger) {
-  if (options.beta) {
-    return handler2(options, logger);
+async function pullHandler(options6, logger) {
+  if (options6.beta) {
+    return pull_default(options6, logger);
   }
   try {
-    const config = mergeOverrides2(await getConfig2(options.configPath), options);
+    const config2 = mergeOverrides2(await getConfig2(options6.configPath), options6);
     if (process.env["OPENFN_API_KEY"]) {
       logger.info("Using OPENFN_API_KEY environment variable");
-      config.apiKey = process.env["OPENFN_API_KEY"];
+      config2.apiKey = process.env["OPENFN_API_KEY"];
     }
     if (process.env["OPENFN_ENDPOINT"]) {
       logger.info("Using OPENFN_ENDPOINT environment variable");
-      config.endpoint = process.env["OPENFN_ENDPOINT"];
+      config2.endpoint = process.env["OPENFN_ENDPOINT"];
     }
     logger.always(
       "Downloading existing project state (as JSON) from the server."
     );
     const { data: project } = await getProject2(
-      config,
-      options.projectId,
-      options.snapshots
+      config2,
+      options6.projectId,
+      options6.snapshots
     );
     if (!project) {
       logger.error("ERROR: Project not found.");
@@ -2213,18 +2680,18 @@ async function pullHandler(options, logger) {
     const state = getStateFromProjectPayload(project);
     logger.always("Downloading the project spec (as YAML) from the server.");
     const queryParams = new URLSearchParams();
-    queryParams.append("id", options.projectId);
-    options.snapshots?.forEach(
+    queryParams.append("id", options6.projectId);
+    options6.snapshots?.forEach(
       (snapshot) => queryParams.append("snapshots[]", snapshot)
     );
     const url2 = new URL(
       `api/provision/yaml?${queryParams.toString()}`,
-      config.endpoint
+      config2.endpoint
     );
     logger.debug("Fetching project spec from", url2);
     const res = await fetch(url2, {
       headers: {
-        Authorization: `Bearer ${config.apiKey}`,
+        Authorization: `Bearer ${config2.apiKey}`,
         Accept: "application/json"
       }
     });
@@ -2236,16 +2703,16 @@ async function pullHandler(options, logger) {
       process.exitCode = 1;
       process.exit(1);
     }
-    const resolvedPath = path10.resolve(config.specPath);
+    const resolvedPath = path12.resolve(config2.specPath);
     logger.debug("reading spec from", resolvedPath);
     const updatedSpec = await syncRemoteSpec(
       await res.text(),
       state,
-      config,
+      config2,
       logger
     );
     await fs5.writeFile(
-      path10.resolve(config.statePath),
+      path12.resolve(config2.statePath),
       JSON.stringify(state, null, 2)
     );
     await fs5.writeFile(resolvedPath, updatedSpec);
@@ -2263,13 +2730,13 @@ async function pullHandler(options, logger) {
     throw error;
   }
 }
-function mergeOverrides2(config, options) {
+function mergeOverrides2(config2, options6) {
   return {
-    ...config,
-    apiKey: pickFirst2(process.env["OPENFN_API_KEY"], config.apiKey),
-    endpoint: pickFirst2(process.env["OPENFN_ENDPOINT"], config.endpoint),
-    configPath: options.configPath,
-    requireConfirmation: pickFirst2(options.confirm, config.requireConfirmation)
+    ...config2,
+    apiKey: pickFirst2(process.env["OPENFN_API_KEY"], config2.apiKey),
+    endpoint: pickFirst2(process.env["OPENFN_ENDPOINT"], config2.endpoint),
+    configPath: options6.configPath,
+    requireConfirmation: pickFirst2(options6.confirm, config2.requireConfirmation)
   };
 }
 function pickFirst2(...args) {
@@ -2278,18 +2745,36 @@ function pickFirst2(...args) {
 var handler_default10 = pullHandler;
 
 // src/projects/handler.ts
-import { Workspace as Workspace2 } from "@openfn/project";
-import path11 from "path";
-var projectsHandler = async (options, logger) => {
-  const commandPath = path11.resolve(options.projectPath ?? ".");
-  const workspace = new Workspace2(commandPath);
-  if (!workspace.valid) {
-    logger.error("Command was run in an invalid openfn workspace");
-    return;
+var handler_exports = {};
+__export(handler_exports, {
+  checkout: () => handler3,
+  fetch: () => handler2,
+  list: () => handler5,
+  merge: () => handler7,
+  version: () => handler6
+});
+
+// src/projects/list.ts
+import { Workspace as Workspace3 } from "@openfn/project";
+var options3 = [log, workspace];
+var command3 = {
+  command: "list [project-path]",
+  describe: "List all the openfn projects available in the current directory",
+  aliases: ["project", "$0"],
+  handler: ensure("project-list", options3),
+  builder: (yargs) => build(options3, yargs)
+};
+var handler5 = async (options6, logger) => {
+  logger.info("Searching for projects in workspace at:");
+  logger.info(" ", options6.workspace);
+  logger.break();
+  const workspace2 = new Workspace3(options6.workspace);
+  if (!workspace2.valid) {
+    throw new Error("No OpenFn projects found");
   }
-  logger.success(`Available openfn projects
+  logger.always(`Available openfn projects
 
-${workspace.list().map((p) => describeProject(p, p.id === workspace.activeProjectId)).join("\n\n")}
+${workspace2.list().map((p) => describeProject(p, p.id === workspace2.activeProjectId)).join("\n\n")}
     `);
 };
 function describeProject(project, active = false) {
@@ -2299,27 +2784,31 @@ function describeProject(project, active = false) {
   workflows:
 ${project.workflows.map((w) => "    - " + w.id).join("\n")}`;
 }
-var handler_default11 = projectsHandler;
 
-// src/version/handler.ts
-import { Workspace as Workspace3 } from "@openfn/project";
-import path12 from "path";
-var workflowVersionHandler = async (options, logger) => {
-  const commandPath = path12.resolve(options.projectPath ?? ".");
-  const workspace = new Workspace3(commandPath);
-  if (!workspace.valid) {
+// src/projects/version.ts
+import { Workspace as Workspace4 } from "@openfn/project";
+var options4 = [workflow, workspace, workflowMappings];
+var command4 = {
+  command: "version [workflow]",
+  describe: "Returns the version hash of a given workflow in a workspace",
+  handler: ensure("project-version", options4),
+  builder: (yargs) => build(options4, yargs)
+};
+var handler6 = async (options6, logger) => {
+  const workspace2 = new Workspace4(options6.workspace);
+  if (!workspace2.valid) {
     logger.error("Command was run in an invalid openfn workspace");
     return;
   }
   const output = /* @__PURE__ */ new Map();
-  const activeProject = workspace.getActiveProject();
-  if (options.workflow) {
-    const workflow = activeProject?.getWorkflow(options.workflow);
-    if (!workflow) {
-      logger.error(`No workflow found with id ${options.workflow}`);
+  const activeProject = workspace2.getActiveProject();
+  if (options6.workflow) {
+    const workflow2 = activeProject?.getWorkflow(options6.workflow);
+    if (!workflow2) {
+      logger.error(`No workflow found with id ${options6.workflow}`);
       return;
     }
-    output.set(workflow.name || workflow.id, workflow.getVersionHash());
+    output.set(workflow2.name || workflow2.id, workflow2.getVersionHash());
   } else {
     for (const wf of activeProject?.workflows || []) {
       output.set(wf.name || wf.id, wf.getVersionHash());
@@ -2330,7 +2819,7 @@ var workflowVersionHandler = async (options, logger) => {
     return;
   }
   let final;
-  if (options.json) {
+  if (options6.json) {
     final = JSON.stringify(Object.fromEntries(output), void 0, 2);
   } else {
     final = Array.from(output.entries()).map(([key, value]) => key + "\n" + value).join("\n\n");
@@ -2339,68 +2828,56 @@ var workflowVersionHandler = async (options, logger) => {
 
 ${final}`);
 };
-var handler_default12 = workflowVersionHandler;
-
-// src/checkout/handler.ts
-import Project5, { Workspace as Workspace4 } from "@openfn/project";
-import path13 from "path";
-import fs6 from "fs";
-import { rimraf as rimraf2 } from "rimraf";
-var checkoutHandler = async (options, logger) => {
-  const commandPath = path13.resolve(options.projectPath ?? ".");
-  const workspace = new Workspace4(commandPath);
-  if (!workspace.valid) {
-    logger.error("Command was run in an invalid openfn workspace");
-    return;
-  }
-  const { project: _, ...config } = workspace.getConfig();
-  let switchProject;
-  if (/\.(yaml|json)$/.test(options.projectId)) {
-    const filePath = options.projectId.startsWith("/") ? options.projectId : path13.join(commandPath, options.projectId);
-    logger.debug("Loading project from path ", filePath);
-    switchProject = await Project5.from("path", filePath, config);
-  } else {
-    switchProject = workspace.get(options.projectId);
-  }
-  if (!switchProject) {
-    throw new Error(
-      `Project with id ${options.projectId} not found in the workspace`
-    );
-  }
-  await rimraf2(path13.join(commandPath, config.workflowRoot ?? "workflows"));
-  const files = switchProject.serialize("fs");
-  for (const f in files) {
-    if (files[f]) {
-      fs6.mkdirSync(path13.join(commandPath, path13.dirname(f)), {
-        recursive: true
-      });
-      fs6.writeFileSync(path13.join(commandPath, f), files[f]);
-    } else {
-      logger.warn("WARNING! No content for file", f);
-    }
-  }
-  logger.success(`Expanded project to ${commandPath}`);
-};
-var handler_default13 = checkoutHandler;
 
-// src/merge/handler.ts
+// src/projects/merge.ts
 import Project6, { Workspace as Workspace5 } from "@openfn/project";
-import path14 from "path";
-import { promises as fs7 } from "fs";
-var mergeHandler = async (options, logger) => {
-  const commandPath = path14.resolve(options.projectPath ?? ".");
-  const workspace = new Workspace5(commandPath);
-  if (!workspace.valid) {
+import path13 from "node:path";
+import fs6 from "node:fs/promises";
+var options5 = [
+  projectId,
+  removeUnmapped,
+  workflowMappings,
+  log,
+  workspace,
+  // custom output because we don't want defaults or anything
+  {
+    name: "output-path",
+    yargs: {
+      alias: "o",
+      description: "Optionally write the merged project file to a custom location"
+    }
+  },
+  {
+    name: "base",
+    yargs: {
+      alias: "target",
+      description: "Path to the base (target) state file to merge into (ie, what main should be)"
+    }
+  },
+  override(force, {
+    description: "Force a merge even when workflows are incompatible"
+  })
+];
+var command5 = {
+  command: "merge <project-id>",
+  describe: "Merges the specified project into the currently checked out project",
+  handler: ensure("project-merge", options5),
+  builder: (yargs) => build(options5, yargs)
+};
+var handler7 = async (options6, logger) => {
+  const commandPath = options6.workspace;
+  const workspace2 = new Workspace5(commandPath);
+  if (!workspace2.valid) {
     logger.error("Command was run in an invalid openfn workspace");
     return;
   }
   let targetProject;
-  if (options.base) {
-    const basePath = path14.resolve(options.base);
+  if (options6.base) {
+    const basePath = path13.resolve(options6.base);
     logger.debug("Loading target project from path", basePath);
     targetProject = await Project6.from("path", basePath);
   } else {
-    targetProject = workspace.getActiveProject();
+    targetProject = workspace2.getActiveProject();
     if (!targetProject) {
       logger.error(`No project currently checked out`);
       return;
@@ -2408,16 +2885,16 @@ var mergeHandler = async (options, logger) => {
     logger.debug(`Loading target project from workspace (${targetProject.id})`);
   }
   let sourceProject;
-  if (/\.(yaml|json)$/.test(options.projectId)) {
-    const filePath = path14.join(commandPath, options.projectId);
+  if (/\.(yaml|json)$/.test(options6.projectId)) {
+    const filePath = path13.join(commandPath, options6.projectId);
     logger.debug("Loading source project from path ", filePath);
     sourceProject = await Project6.from("path", filePath);
   } else {
-    logger.debug(`Loading source project from workspace ${options.projectId}`);
-    sourceProject = workspace.get(options.projectId);
+    logger.debug(`Loading source project from workspace ${options6.projectId}`);
+    sourceProject = workspace2.get(options6.projectId);
   }
   if (!sourceProject) {
-    logger.error(`Project "${options.projectId}" not found in the workspace`);
+    logger.error(`Project "${options6.projectId}" not found in the workspace`);
     return;
   }
   if (targetProject.id === sourceProject.id) {
@@ -2428,20 +2905,20 @@ var mergeHandler = async (options, logger) => {
     logger.error("The checked out project has no id");
     return;
   }
-  const finalPath = options.outputPath ?? workspace.getProjectPath(targetProject.id);
+  const finalPath = options6.outputPath ?? workspace2.getProjectPath(targetProject.id);
   if (!finalPath) {
     logger.error("Path to checked out project not found.");
     return;
   }
   const final = Project6.merge(sourceProject, targetProject, {
-    removeUnmapped: options.removeUnmapped,
-    workflowMappings: options.workflowMappings,
-    force: options.force
+    removeUnmapped: options6.removeUnmapped,
+    workflowMappings: options6.workflowMappings,
+    force: options6.force
   });
-  let outputFormat = workspace.config.formats.project;
-  if (options.outputPath?.endsWith(".json")) {
+  let outputFormat = workspace2.config.formats.project;
+  if (options6.outputPath?.endsWith(".json")) {
     outputFormat = "json";
-  } else if (options.outputPath?.endsWith(".yaml")) {
+  } else if (options6.outputPath?.endsWith(".yaml")) {
     outputFormat = "yaml";
   }
   let finalState = final.serialize("state", {
@@ -2450,27 +2927,26 @@ var mergeHandler = async (options, logger) => {
   if (outputFormat === "json") {
     finalState = JSON.stringify(finalState, null, 2);
   }
-  await fs7.writeFile(finalPath, finalState);
+  await fs6.writeFile(finalPath, finalState);
   logger.info(`Updated statefile at `, finalPath);
   logger.info("Checking out merged project to filesystem");
-  await handler_default13(
+  await handler3(
     {
-      command: "checkout",
-      projectPath: commandPath,
-      projectId: options.outputPath ? finalPath : final.id,
-      log: options.log
+      command: "project-checkout",
+      workspace: commandPath,
+      projectId: options6.outputPath ? finalPath : final.id,
+      log: options6.log
     },
     logger
   );
   logger.success(
-    `Project ${sourceProject.id} has been merged into Project ${targetProject.id} successfully`
+    `Project ${sourceProject.id} has been merged into Project ${targetProject.id}`
   );
 };
-var handler_default14 = mergeHandler;
 
 // src/util/print-versions.ts
 import { readFileSync as readFileSync2 } from "node:fs";
-import path15 from "node:path";
+import path14 from "node:path";
 import url from "node:url";
 import { getNameAndVersion as getNameAndVersion7 } from "@openfn/runtime";
 import { mainSymbols } from "figures";
@@ -2482,15 +2958,15 @@ var { triangleRightSmall: t } = mainSymbols;
 var loadVersionFromPath = (adaptorPath) => {
   try {
     const pkg = JSON.parse(
-      readFileSync2(path15.resolve(adaptorPath, "package.json"), "utf8")
+      readFileSync2(path14.resolve(adaptorPath, "package.json"), "utf8")
     );
     return pkg.version;
   } catch (e) {
     return "unknown";
   }
 };
-var printVersions = async (logger, options = {}, includeComponents = false) => {
-  const { adaptors, logJson } = options;
+var printVersions = async (logger, options6 = {}, includeComponents = false) => {
+  const { adaptors, logJson: logJson2 } = options6;
   let longestAdaptorName = "";
   const adaptorList = [];
   adaptors?.forEach((adaptor) => {
@@ -2500,7 +2976,7 @@ var printVersions = async (logger, options = {}, includeComponents = false) => {
       const [namePart, pathPart] = adaptor.split("=");
       adaptorVersion = loadVersionFromPath(pathPart);
       adaptorName = getNameAndVersion7(namePart).name;
-    } else if (options.monorepoPath) {
+    } else if (options6.monorepoPath) {
       adaptorName = getNameAndVersion7(adaptor).name;
       adaptorVersion = "monorepo";
     } else {
@@ -2517,13 +2993,13 @@ var printVersions = async (logger, options = {}, includeComponents = false) => {
     ...[NODE, CLI2, RUNTIME2, COMPILER2, longestAdaptorName].map((s) => s.length)
   );
   const prefix = (str) => `         ${t} ${str.padEnd(longest + 4, " ")}`;
-  const dirname3 = path15.dirname(url.fileURLToPath(import.meta.url));
+  const dirname3 = path14.dirname(url.fileURLToPath(import.meta.url));
   const pkg = JSON.parse(readFileSync2(`${dirname3}/../../package.json`, "utf8"));
   const { version, dependencies } = pkg;
   const compilerVersion = dependencies["@openfn/compiler"];
   const runtimeVersion = dependencies["@openfn/runtime"];
   let output;
-  if (logJson) {
+  if (logJson2) {
     output = {
       versions: {
         "node.js": process.version.substring(1),
@@ -2559,6 +3035,25 @@ ${prefix(name)}${version2}`;
 };
 var print_versions_default = printVersions;
 
+// src/env.ts
+import { config } from "dotenv";
+import { expand as expand2 } from "dotenv-expand";
+var env2;
+var report = (logger) => {
+  let envs = [];
+  if (process.env.$DOT_ENV_OVERRIDES) {
+    envs = process.env.$DOT_ENV_OVERRIDES.split(",").map((s) => s.trim());
+  } else {
+    envs = Object.keys(env2?.parsed ?? {});
+  }
+  if (envs.length) {
+    logger?.always(`Imported ${envs.length} env vars from .env file`);
+    logger?.debug("Envs set from .env: ", envs.join(", "));
+  } else if (env2 && env2.error) {
+    logger?.debug(".env not found");
+  }
+};
+
 // src/commands.ts
 var handlers = {
   apollo: handler_default,
@@ -2570,10 +3065,8 @@ var handlers = {
   docs: handler_default8,
   metadata: handler_default9,
   pull: handler_default10,
-  projects: handler_default11,
-  checkout: handler_default13,
-  merge: handler_default14,
-  project: handler_default12,
+  projects: handler_exports,
+  project: handler_exports,
   ["collections-get"]: handler_default4.get,
   ["collections-set"]: handler_default4.set,
   ["collections-remove"]: handler_default4.remove,
@@ -2581,14 +3074,20 @@ var handlers = {
   ["repo-install"]: install,
   ["repo-pwd"]: pwd,
   ["repo-list"]: list,
+  ["project-list"]: handler5,
+  ["project-version"]: handler6,
+  ["project-merge"]: handler7,
+  ["project-checkout"]: handler3,
+  ["project-fetch"]: handler2,
   version: async (opts, logger) => print_versions_default(logger, opts, true)
 };
-var parse = async (options, log) => {
-  const logger = log || logger_default(CLI, options);
-  if (options.command === "execute" || options.command === "test") {
-    await print_versions_default(logger, options);
+var parse = async (options6, log2) => {
+  const logger = log2 || logger_default(CLI, options6);
+  if (options6.command === "execute" || options6.command === "test") {
+    await print_versions_default(logger, options6);
   }
-  const { monorepoPath } = options;
+  report(logger);
+  const { monorepoPath } = options6;
   if (monorepoPath) {
     if (monorepoPath === "ERR") {
       logger.error(
@@ -2599,19 +3098,19 @@ var parse = async (options, log) => {
     }
     await validateMonoRepo(monorepoPath, logger);
     logger.success(`Loading adaptors from monorepo at ${monorepoPath}`);
-    options.adaptors = map_adaptors_to_monorepo_default(
+    options6.adaptors = map_adaptors_to_monorepo_default(
       monorepoPath,
-      options.adaptors,
+      options6.adaptors,
       logger
     );
   }
-  const handler3 = handlers[options.command];
-  if (!handler3) {
-    logger.error(`Unrecognised command: ${options.command}`);
+  const handler8 = handlers[options6.command];
+  if (!handler8) {
+    logger.error(`Unrecognised command: ${options6.command}`);
     process.exit(1);
   }
   try {
-    return await handler3(options, logger);
+    return await handler8(options6, logger);
   } catch (e) {
     if (!process.exitCode) {
       process.exitCode = e.exitCode || 1;
@@ -2625,7 +3124,11 @@ var parse = async (options, log) => {
     } else {
       logger.break();
       logger.error("Command failed!");
-      logger.error(e);
+      if (e instanceof CLIError) {
+        logger.error(e.message);
+      } else {
+        logger.error(e);
+      }
     }
   }
 };