@openfn/cli 1.22.0 → 1.24.0

package/dist/process/runner.js

@@ -21,13 +21,13 @@ var urlMap = {
   ["local"]: LOCAL_URL
 };
 var DEFAULT_ENV = "staging";
-var getURL = (options7) => {
-  if (options7.apolloUrl) {
-    if (options7.apolloUrl in urlMap) {
-      return urlMap[options7.apolloUrl];
+var getURL = (options8) => {
+  if (options8.apolloUrl) {
+    if (options8.apolloUrl in urlMap) {
+      return urlMap[options8.apolloUrl];
     }
-    if (options7.apolloUrl.startsWith("http")) {
-      return options7.apolloUrl;
+    if (options8.apolloUrl.startsWith("http")) {
+      return options8.apolloUrl;
     }
     throw new Error(`Unrecognised apollo URL`);
   }
@@ -52,14 +52,14 @@ var outputFiles = (files, logger) => {
 };
 
 // src/apollo/handler.ts
-var apolloHandler = async (options7, logger) => {
-  logger.always(`Calling Apollo service: ${options7.service}`);
-  const json = await loadPayload(logger, options7.payload);
-  const url2 = getURL(options7);
+var apolloHandler = async (options8, logger) => {
+  logger.always(`Calling Apollo service: ${options8.service}`);
+  const json = await loadPayload(logger, options8.payload);
+  const url2 = getURL(options8);
   logger.success(`Using apollo server at`, url2);
-  const result = await callApollo(url2, options7.service, json, logger);
+  const result = await callApollo(url2, options8.service, json, logger);
   if (result) {
-    await serializeOutput(options7, result, logger);
+    await serializeOutput(options8, result, logger);
   } else {
     logger.warn("No output returned from Apollo");
   }
@@ -79,15 +79,15 @@ var write = async (basePath, filePath, content, logger) => {
   await writeFile(dest, content);
   logger.success(`Wrote content to ${dest}`);
 };
-var serializeOutput = async (options7, result, logger) => {
-  if (options7.outputPath) {
-    if (result.files && !options7.outputPath.endsWith(".json")) {
+var serializeOutput = async (options8, result, logger) => {
+  if (options8.outputPath) {
+    if (result.files && !options8.outputPath.endsWith(".json")) {
       for (const p in result.files) {
-        await write(options7.outputPath, p, result.files[p], logger);
+        await write(options8.outputPath, p, result.files[p], logger);
       }
     } else {
       await write(
-        options7.outputPath,
+        options8.outputPath,
         "",
         JSON.stringify(result, null, 2),
         logger
@@ -169,17 +169,17 @@ var namespaces = {
   [COMPILER]: "CMP",
   [JOB]: "JOB"
 };
-var createLogger2 = (name = "", options7) => {
-  const logOptions = options7.log || {};
+var createLogger2 = (name = "", options8) => {
+  const logOptions = options8.log || {};
   let json = false;
   let level = logOptions[name] || logOptions.default || "default";
-  if (options7.logJson) {
+  if (options8.logJson) {
     json = true;
   }
   return actualCreateLogger(namespaces[name] || name, {
     level,
     json,
-    sanitize: options7.sanitize || "none",
+    sanitize: options8.sanitize || "none",
     ...logOptions
   });
 };
@@ -190,8 +190,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, options7, stepId) => {
-  const { baseDir } = options7;
+var getCachePath = async (plan, options8, stepId) => {
+  const { baseDir } = options8;
   const { name } = plan.workflow;
   const basePath = `${baseDir}/.cli-cache/${name}`;
   if (stepId) {
@@ -199,10 +199,10 @@ var getCachePath = async (plan, options7, stepId) => {
   }
   return path2.resolve(basePath);
 };
-var ensureGitIgnore = (options7) => {
-  if (!options7._hasGitIgnore) {
+var ensureGitIgnore = (options8) => {
+  if (!options8._hasGitIgnore) {
     const ignorePath = path2.resolve(
-      options7.baseDir,
+      options8.baseDir,
       ".cli-cache",
       ".gitignore"
     );
@@ -212,19 +212,19 @@ var ensureGitIgnore = (options7) => {
       fs.writeFileSync(ignorePath, "*");
     }
   }
-  options7._hasGitIgnore = true;
+  options8._hasGitIgnore = true;
 };
-var saveToCache = async (plan, stepId, output, options7, logger) => {
-  if (options7.cacheSteps) {
-    const cachePath = await getCachePath(plan, options7, stepId);
+var saveToCache = async (plan, stepId, output, options8, logger) => {
+  if (options8.cacheSteps) {
+    const cachePath = await getCachePath(plan, options8, stepId);
     fs.mkdirSync(path2.dirname(cachePath), { recursive: true });
-    ensureGitIgnore(options7);
+    ensureGitIgnore(options8);
     logger.info(`Writing ${stepId} output to ${cachePath}`);
     fs.writeFileSync(cachePath, JSON.stringify(output));
   }
 };
-var clearCache = async (plan, options7, logger) => {
-  const cacheDir = await getCachePath(plan, options7);
+var clearCache = async (plan, options8, logger) => {
+  const cacheDir = await getCachePath(plan, options8);
   try {
     await rmdir(cacheDir, { recursive: true });
     logger.info(`Cleared cache at ${cacheDir}`);
@@ -294,7 +294,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 (options7, result, logger) => {
+var serializeOutput2 = async (options8, result, logger) => {
   let output = result;
   if (output && (output.configuration || output.data)) {
     const { configuration, ...rest } = result;
@@ -305,14 +305,14 @@ var serializeOutput2 = async (options7, result, logger) => {
   } else {
     output = JSON.stringify(output, void 0, 2);
   }
-  if (options7.outputStdout) {
+  if (options8.outputStdout) {
     logger.success(`Result: `);
     logger.always(output);
-  } else if (options7.outputPath) {
-    await mkdir2(dirname(options7.outputPath), { recursive: true });
-    logger.debug(`Writing output to ${options7.outputPath}`);
-    await writeFile2(options7.outputPath, output);
-    logger.success(`State written to ${options7.outputPath}`);
+  } else if (options8.outputPath) {
+    await mkdir2(dirname(options8.outputPath), { recursive: true });
+    logger.debug(`Writing output to ${options8.outputPath}`);
+    await writeFile2(options8.outputPath, output);
+    logger.success(`State written to ${options8.outputPath}`);
   }
   return output;
 };
@@ -332,20 +332,34 @@ var getAutoinstallTargets = (plan) => {
 var get_autoinstall_targets_default = getAutoinstallTargets;
 
 // src/execute/apply-credential-map.ts
+var CREDENTIALS_KEY = "$CREDENTIALS$";
 var applyCredentialMap = (plan, map = {}, logger) => {
   const stepsWithCredentialIds = plan.workflow.steps.filter(
-    (step) => typeof step.configuration === "string" && !step.configuration.endsWith(".json")
+    (step) => typeof step.configuration === "string" && !step.configuration.endsWith(".json") || step.configuration?.[CREDENTIALS_KEY]
   );
   const unmapped = {};
   for (const step of stepsWithCredentialIds) {
-    if (map[step.configuration]) {
-      logger?.debug(
-        `Applying credential ${step.configuration} to "${step.name ?? step.id}"`
-      );
-      step.configuration = map[step.configuration];
+    if (typeof step.configuration === "string") {
+      const configId = step.configuration;
+      if (configId in map) {
+        step.configuration = map[configId];
+      } else {
+        unmapped[configId] = true;
+        delete step.configuration;
+      }
     } else {
-      unmapped[step.configuration] = true;
-      delete step.configuration;
+      const configId = step.configuration[CREDENTIALS_KEY];
+      delete step.configuration[CREDENTIALS_KEY];
+      if (configId in map) {
+        Object.assign(step.configuration, map[configId]);
+      } else {
+        unmapped[configId] = true;
+      }
+      if (!(configId in unmapped)) {
+        logger?.debug(
+          `Applied credential ${configId} to "${step.name ?? step.id}"`
+        );
+      }
     }
   }
   if (Object.keys(unmapped).length) {
@@ -409,16 +423,16 @@ var removePackage = async (packageSpecifier, repoDir, logger) => {
     logger.warn(`Failed to remove ${aliasedName}: ${error.message}`);
   }
 };
-var clean = async (options7, logger) => {
-  if (options7.repoDir) {
+var clean = async (options8, logger) => {
+  if (options8.repoDir) {
     const doIt = await logger.confirm(
-      `This will remove everything at ${options7.repoDir}. Do you wish to proceed?`,
-      options7.force
+      `This will remove everything at ${options8.repoDir}. Do you wish to proceed?`,
+      options8.force
     );
     if (doIt) {
       return new Promise((resolve) => {
-        logger.info(`Cleaning repo at ${options7.repoDir} `);
-        exec(`npm exec rimraf ${options7.repoDir}`, () => {
+        logger.info(`Cleaning repo at ${options8.repoDir} `);
+        exec(`npm exec rimraf ${options8.repoDir}`, () => {
           logger.success("Repo cleaned");
           resolve();
         });
@@ -429,12 +443,12 @@ var clean = async (options7, logger) => {
     logger.error("No repoDir path detected");
   }
 };
-var pwd = async (options7, logger) => {
+var pwd = async (options8, logger) => {
   logger.info(`OPENFN_REPO_DIR is set to ${process.env.OPENFN_REPO_DIR}`);
-  logger.success(`Repo working directory is: ${options7.repoDir}`);
+  logger.success(`Repo working directory is: ${options8.repoDir}`);
 };
-var getDependencyList = async (options7, _logger) => {
-  const pkg = await loadRepoPkg(options7.repoDir);
+var getDependencyList = async (options8, _logger) => {
+  const pkg = await loadRepoPkg(options8.repoDir);
   const result = {};
   if (pkg) {
     Object.keys(pkg.dependencies).forEach((key) => {
@@ -447,9 +461,9 @@ var getDependencyList = async (options7, _logger) => {
   }
   return result;
 };
-var list = async (options7, logger) => {
-  const tree = await getDependencyList(options7, logger);
-  await pwd(options7, logger);
+var list = async (options8, logger) => {
+  const tree = await getDependencyList(options8, logger);
+  await pwd(options8, logger);
   const output = {};
   Object.keys(tree).forEach((key) => {
     const versions = tree[key];
@@ -581,7 +595,7 @@ var resolveSpecifierPath = async (pattern, repoDir, log2) => {
   return null;
 };
 var loadTransformOptions = async (opts, log2) => {
-  const options7 = {
+  const options8 = {
     logger: log2 || logger_default(COMPILER, opts),
     trace: opts.trace
   };
@@ -609,12 +623,12 @@ var loadTransformOptions = async (opts, log2) => {
         exportAll: true
       });
     }
-    options7["add-imports"] = {
+    options8["add-imports"] = {
       ignore: opts.ignoreImports,
       adaptors: adaptorsConfig
     };
   }
-  return options7;
+  return options8;
 };
 
 // src/util/load-state.ts
@@ -707,20 +721,19 @@ var load_state_default = async (plan, opts, log2, start) => {
 };
 
 // src/util/validate-adaptors.ts
-var validateAdaptors = async (options7, logger) => {
-  if (options7.skipAdaptorValidation) {
+var validateAdaptors = async (options8, logger) => {
+  if (options8.skipAdaptorValidation) {
     return;
   }
-  const isPlan = options7.planPath || options7.workflowPath || options7.workflow;
-  const hasDeclaredAdaptors = options7.adaptors && options7.adaptors.length > 0;
-  if (isPlan && hasDeclaredAdaptors) {
+  const hasDeclaredAdaptors = options8.adaptors && options8.adaptors.length > 0;
+  if (!options8.expressionPath && hasDeclaredAdaptors) {
     logger.error("ERROR: adaptor and workflow provided");
     logger.error(
       "This is probably not what you meant to do. A workflow should declare an adaptor for each job."
     );
     throw new Error("adaptor and workflow provided");
   }
-  if (!isPlan && !hasDeclaredAdaptors) {
+  if (options8.expressionPath && !hasDeclaredAdaptors) {
     logger.warn("WARNING: No adaptor provided!");
     logger.warn(
       "This job will probably fail. Pass an adaptor with the -a flag, eg:"
@@ -736,7 +749,7 @@ var validate_adaptors_default = validateAdaptors;
 import fs3 from "node:fs/promises";
 import path4, { dirname as dirname2 } from "node:path";
 import { isPath } from "@openfn/compiler";
-import Project, { yamlToJson } from "@openfn/project";
+import { Workspace, yamlToJson } from "@openfn/project";
 
 // src/util/expand-adaptors.ts
 var expand = (name) => {
@@ -822,48 +835,61 @@ var resolve_path_default = (path17, root) => {
 };
 
 // src/util/load-plan.ts
-var loadPlan = async (options7, logger) => {
-  const { workflowPath, planPath, expressionPath } = options7;
-  if (options7.path && /ya?ml$/.test(options7.path)) {
-    const content = await fs3.readFile(path4.resolve(options7.path), "utf-8");
-    const workflow2 = yamlToJson(content);
-    options7.baseDir = dirname2(options7.path);
-    return loadXPlan({ workflow: workflow2 }, options7, logger);
-  }
-  if (options7.path && options7.workflow) {
-    options7.baseDir = options7.path;
-    return fromProject(options7.path, options7.workflow, options7, logger);
+var loadPlan = async (options8, logger) => {
+  const { workflowPath, planPath, expressionPath, workflowName } = options8;
+  let workflowObj;
+  if (workflowName || options8.workflow) {
+    logger.debug(
+      "Loading workflow from active project in workspace at ",
+      options8.workspace
+    );
+    const workspace2 = new Workspace(options8.workspace);
+    const proj = await workspace2.getCheckedOutProject();
+    const name = workflowName || options8.workflow;
+    const workflow2 = proj?.getWorkflow(name);
+    if (!workflow2) {
+      const e = new Error(`Could not find Workflow "${name}"`);
+      delete e.stack;
+      throw e;
+    }
+    workflowObj = {
+      workflow: workflow2.toJSON()
+    };
+    options8.credentials ??= workspace2.getConfig().credentials;
+    options8.collectionsEndpoint ??= proj.openfn?.endpoint;
   }
-  if (!expressionPath && !workflowPath && !/\.(js|json|yaml)+$/.test(options7.path || "") && !options7.workflow) {
-    const workflow2 = options7.path;
-    return fromProject(path4.resolve("."), workflow2, options7, logger);
+  if (options8.path && /ya?ml$/.test(options8.path)) {
+    const content = await fs3.readFile(path4.resolve(options8.path), "utf-8");
+    options8.baseDir = dirname2(options8.path);
+    workflowObj = yamlToJson(content);
+    const { options: o, ...rest } = workflowObj;
+    if (!workflowObj.workflow && workflowObj.options) {
+      workflowObj = { workflow: rest, options: o };
+    }
   }
-  if (expressionPath) {
-    return loadExpression(options7, logger);
+  if (!workflowObj && expressionPath) {
+    return loadExpression(options8, logger);
   }
   const jsonPath = planPath || workflowPath;
-  if (!options7.baseDir) {
-    options7.baseDir = path4.dirname(jsonPath);
-  }
-  const json = await loadJson(jsonPath, logger);
-  const defaultName = path4.parse(jsonPath).name;
-  if (json.workflow) {
-    return loadXPlan(json, options7, logger, defaultName);
+  if (jsonPath && !options8.baseDir) {
+    options8.baseDir = path4.dirname(jsonPath);
+  }
+  workflowObj = workflowObj ?? await loadJson(jsonPath, logger);
+  const defaultName = workflowObj.name || path4.parse(jsonPath ?? "").name;
+  if (workflowObj.jobs) {
+    return loadOldWorkflow(workflowObj, options8, logger, defaultName);
+  } else if (workflowObj.workflow) {
+    return loadXPlan(
+      workflowObj,
+      Object.assign({}, workflowObj.options, options8),
+      logger,
+      defaultName
+    );
   } else {
-    return loadOldWorkflow(json, options7, logger, defaultName);
+    return loadXPlan({ workflow: workflowObj }, options8, logger, defaultName);
   }
 };
 var load_plan_default = loadPlan;
-var fromProject = async (rootDir, workflowName, options7, logger) => {
-  logger.debug("Loading Repo from ", path4.resolve(rootDir));
-  const project = await Project.from("fs", { root: rootDir });
-  logger.debug("Loading workflow ", workflowName);
-  const workflow2 = project.getWorkflow(workflowName);
-  if (!workflow2) {
-    throw new Error(`Workflow "${workflowName}" not found`);
-  }
-  return loadXPlan({ workflow: workflow2 }, options7, logger);
-};
 var loadJson = async (workflowPath, logger) => {
   let text;
   try {
@@ -897,8 +923,8 @@ var maybeAssign = (a, b, keys) => {
     }
   });
 };
-var loadExpression = async (options7, logger) => {
-  const expressionPath = options7.expressionPath;
+var loadExpression = async (options8, logger) => {
+  const expressionPath = options8.expressionPath;
   logger.debug(`Loading expression from ${expressionPath}`);
   try {
     const expression = await fs3.readFile(expressionPath, "utf8");
@@ -906,19 +932,19 @@ var loadExpression = async (options7, logger) => {
     const step = {
       expression,
       // The adaptor should have been expanded nicely already, so we don't need intervene here
-      adaptors: options7.adaptors ?? []
+      adaptors: options8.adaptors ?? []
     };
     const wfOptions = {};
-    maybeAssign(options7, wfOptions, ["timeout"]);
+    maybeAssign(options8, wfOptions, ["timeout"]);
     const plan = {
       workflow: {
         name,
         steps: [step],
-        globals: options7.globals
+        globals: options8.globals
       },
       options: wfOptions
     };
-    return loadXPlan(plan, options7, logger);
+    return loadXPlan(plan, options8, logger);
   } catch (e) {
     abort_default(
       logger,
@@ -929,7 +955,7 @@ var loadExpression = async (options7, logger) => {
     return {};
   }
 };
-var loadOldWorkflow = async (workflow2, options7, logger, defaultName = "") => {
+var loadOldWorkflow = async (workflow2, options8, logger, defaultName = "") => {
   const plan = {
     workflow: {
       steps: workflow2.jobs
@@ -941,7 +967,7 @@ var loadOldWorkflow = async (workflow2, options7, logger, defaultName = "") => {
   if (workflow2.id) {
     plan.id = workflow2.id;
   }
-  const final = await loadXPlan(plan, options7, logger, defaultName);
+  const final = await loadXPlan(plan, options8, logger, defaultName);
   logger.warn("Converted workflow into new format:");
   logger.warn(final);
   return final;
@@ -1034,11 +1060,12 @@ var ensureAdaptors = (plan) => {
   });
 };
 var ensureCollections = (plan, {
-  endpoint: endpoint2 = "https://app.openfn.org",
+  endpoint: endpoint2,
   version = "latest",
   apiKey: apiKey2 = "null"
 } = {}, logger) => {
   let collectionsFound = false;
+  endpoint2 ??= plan.options?.collectionsEndpoint ?? "https://app.openfn.org";
   Object.values(plan.workflow.steps).filter((step) => step.expression?.match(/(collections\.)/)).forEach((step) => {
     const job = step;
     if (!job.adaptors?.find(
@@ -1049,6 +1076,11 @@ var ensureCollections = (plan, {
       job.adaptors.push(
         `@openfn/language-collections@${version || "latest"}`
       );
+      if (typeof job.configuration === "string") {
+        job.configuration = {
+          [CREDENTIALS_KEY]: job.configuration
+        };
+      }
       job.configuration = Object.assign({}, job.configuration, {
         collections_endpoint: `${endpoint2}/collections`,
         collections_token: apiKey2
@@ -1068,7 +1100,7 @@ var ensureCollections = (plan, {
     );
   }
 };
-var loadXPlan = async (plan, options7, logger, defaultName = "") => {
+var loadXPlan = async (plan, options8, logger, defaultName = "") => {
   if (!plan.options) {
     plan.options = {};
   }
@@ -1079,21 +1111,21 @@ var loadXPlan = async (plan, options7, logger, defaultName = "") => {
   ensureCollections(
     plan,
     {
-      version: options7.collectionsVersion,
-      apiKey: options7.apiKey,
-      endpoint: options7.collectionsEndpoint
+      version: options8.collectionsVersion,
+      apiKey: options8.apiKey,
+      endpoint: options8.collectionsEndpoint
     },
     logger
   );
-  if (options7.globals)
-    plan.workflow.globals = options7.globals;
-  await importGlobals(plan, options7.baseDir, logger);
-  await importExpressions(plan, options7.baseDir, logger);
-  if (options7.expandAdaptors) {
+  if (options8.globals)
+    plan.workflow.globals = options8.globals;
+  await importGlobals(plan, options8.baseDir, logger);
+  await importExpressions(plan, options8.baseDir, logger);
+  if (options8.expandAdaptors) {
     expand_adaptors_default(plan);
   }
-  await map_adaptors_to_monorepo_default(options7.monorepoPath, plan, logger);
-  maybeAssign(options7, plan.options, ["timeout", "start"]);
+  await map_adaptors_to_monorepo_default(options8.monorepoPath, plan, logger);
+  maybeAssign(options8, plan.options, ["timeout", "start"]);
   logger.info(`Loaded workflow ${plan.workflow.name ?? ""}`);
   return plan;
 };
@@ -1136,7 +1168,7 @@ var fuzzy_match_step_default = (plan, stepPattern) => {
 
 // src/util/validate-plan.ts
 var assertWorkflowStructure = (plan, logger) => {
-  const { workflow: workflow2, options: options7 } = plan;
+  const { workflow: workflow2, options: options8 } = plan;
   if (!workflow2 || typeof workflow2 !== "object") {
     throw new Error(`Missing or invalid "workflow" key in execution plan`);
   }
@@ -1149,7 +1181,7 @@ var assertWorkflowStructure = (plan, logger) => {
   workflow2.steps.forEach((step, index) => {
     assertStepStructure(step, index);
   });
-  assertOptionsStructure(options7, logger);
+  assertOptionsStructure(options8, logger);
 };
 var assertStepStructure = (step, index) => {
   const allowedKeys = [
@@ -1176,9 +1208,9 @@ var assertStepStructure = (step, index) => {
     );
   }
 };
-var assertOptionsStructure = (options7 = {}, logger) => {
+var assertOptionsStructure = (options8 = {}, logger) => {
   const allowedKeys = ["timeout", "stepTimeout", "start", "end", "sanitize"];
-  for (const key in options7) {
+  for (const key in options8) {
     if (!allowedKeys.includes(key)) {
       logger.warn(`Unrecognized option "${key}" in options object`);
     }
@@ -1234,41 +1266,44 @@ var matchStep = (plan, stepPattern, stepName, logger) => {
   }
   return "";
 };
-var loadAndApplyCredentialMap = async (plan, options7, logger) => {
+var loadAndApplyCredentialMap = async (plan, options8, logger) => {
   let creds = {};
-  if (options7.credentials) {
+  if (options8.credentials) {
     try {
       const credsRaw = await readFile3(
-        path5.resolve(options7.credentials),
+        path5.resolve(options8.workspace, options8.credentials),
         "utf8"
       );
-      if (options7.credentials.endsWith(".json")) {
+      if (options8.credentials.endsWith(".json")) {
         creds = JSON.parse(credsRaw);
       } else {
         creds = yamlToJson2(credsRaw);
       }
+      logger.info("Credential map loaded ");
     } catch (e) {
-      logger.error("Error processing credential map:");
-      logger.error(e);
-      process.exitCode = 1;
-      return;
+      if (e?.message?.match(/ENOENT/)) {
+        logger.debug("Credential map not found at", options8.credentials);
+      } else {
+        logger.error("Error processing credential map:");
+        process.exitCode = 1;
+        throw e;
+      }
     }
-    logger.info("Credential map loaded ");
   }
   return apply_credential_map_default(plan, creds, logger);
 };
-var executeHandler = async (options7, logger) => {
+var executeHandler = async (options8, logger) => {
   const start = (/* @__PURE__ */ new Date()).getTime();
-  assert_path_default(options7.path);
-  await validate_adaptors_default(options7, logger);
-  let plan = await load_plan_default(options7, logger);
+  assert_path_default(options8.path);
+  await validate_adaptors_default(options8, logger);
+  let plan = await load_plan_default(options8, logger);
   validate_plan_default(plan, logger);
-  await loadAndApplyCredentialMap(plan, options7, logger);
-  if (options7.cacheSteps) {
-    await clearCache(plan, options7, logger);
+  await loadAndApplyCredentialMap(plan, options8, logger);
+  if (options8.cacheSteps) {
+    await clearCache(plan, options8, logger);
   }
   const moduleResolutions = {};
-  const { repoDir, monorepoPath, autoinstall } = options7;
+  const { repoDir, monorepoPath, autoinstall } = options8;
   if (autoinstall) {
     if (monorepoPath) {
       logger.warn("Skipping auto-install as monorepo is being used");
@@ -1276,13 +1311,13 @@ var executeHandler = async (options7, logger) => {
       const autoInstallTargets = get_autoinstall_targets_default(plan);
       if (autoInstallTargets.length) {
         logger.info("Auto-installing language adaptors");
-        options7.adaptors = await install(
+        options8.adaptors = await install(
           { packages: autoInstallTargets, repoDir },
           logger
         );
-        if (autoInstallTargets.length === options7.adaptors.length) {
+        if (autoInstallTargets.length === options8.adaptors.length) {
           for (let i = 0; i < autoInstallTargets.length; i++) {
-            moduleResolutions[autoInstallTargets[i]] = options7.adaptors[i];
+            moduleResolutions[autoInstallTargets[i]] = options8.adaptors[i];
           }
         }
       }
@@ -1290,35 +1325,35 @@ var executeHandler = async (options7, logger) => {
   }
   let customStart;
   let customEnd;
-  if (options7.only) {
-    const step = matchStep(plan, options7.only, "only", logger);
+  if (options8.only) {
+    const step = matchStep(plan, options8.only, "only", logger);
     customStart = step;
     customEnd = step;
-    logger.always(`Only running workflow step "${options7.start}"`);
+    logger.always(`Only running workflow step "${options8.start}"`);
   } else {
-    if (options7.start) {
+    if (options8.start) {
       customStart = matchStep(
         plan,
-        options7.start ?? plan.options.start,
+        options8.start ?? plan.options.start,
         "start",
         logger
       );
-      logger.info(`Starting workflow from step "${options7.start}"`);
+      logger.info(`Starting workflow from step "${options8.start}"`);
     }
-    if (options7.end) {
+    if (options8.end) {
       customEnd = matchStep(
         plan,
-        options7.end ?? plan.options.end,
+        options8.end ?? plan.options.end,
         "end",
         logger
       );
-      logger.always(`Ending workflow at step "${options7.end}"`);
+      logger.always(`Ending workflow at step "${options8.end}"`);
     }
   }
-  const state = await load_state_default(plan, options7, logger, customStart);
+  const state = await load_state_default(plan, options8, logger, customStart);
   plan = override_plan_adaptors_default(plan, moduleResolutions);
-  if (options7.compile) {
-    plan = await compile_default(plan, options7, logger);
+  if (options8.compile) {
+    plan = await compile_default(plan, options8, logger);
   } else {
     logger.info("Skipping compilation as noCompile is set");
   }
@@ -1332,13 +1367,13 @@ var executeHandler = async (options7, logger) => {
     workflow: plan.workflow
   };
   try {
-    const result = await execute_default(finalPlan, state, options7, logger);
-    if (options7.cacheSteps) {
+    const result = await execute_default(finalPlan, state, options8, logger);
+    if (options8.cacheSteps) {
       logger.success(
         "Cached output written to ./cli-cache (see info logs for details)"
       );
     }
-    await serialize_output_default(options7, result, logger);
+    await serialize_output_default(options8, result, logger);
     const duration = printDuration((/* @__PURE__ */ new Date()).getTime() - start);
     if (result?.errors) {
       logger.warn(
@@ -1361,22 +1396,22 @@ var handler_default2 = executeHandler;
 
 // src/compile/handler.ts
 import { writeFile as writeFile3 } from "node:fs/promises";
-var compileHandler = async (options7, logger) => {
-  assert_path_default(options7.path);
+var compileHandler = async (options8, logger) => {
+  assert_path_default(options8.path);
   let result;
-  if (options7.expressionPath) {
-    const { code } = await compile_default(options7.expressionPath, options7, logger);
+  if (options8.expressionPath) {
+    const { code } = await compile_default(options8.expressionPath, options8, logger);
     result = code;
   } else {
-    const plan = await load_plan_default(options7, logger);
-    const compiledPlan = await compile_default(plan, options7, logger);
+    const plan = await load_plan_default(options8, logger);
+    const compiledPlan = await compile_default(plan, options8, logger);
     result = JSON.stringify(compiledPlan, null, 2);
   }
-  if (options7.outputStdout) {
+  if (options8.outputStdout) {
     logger.success("Result:\n\n" + result);
   } else {
-    await writeFile3(options7.outputPath, result);
-    logger.success(`Compiled to ${options7.outputPath}`);
+    await writeFile3(options8.outputPath, result);
+    logger.success(`Compiled to ${options8.outputPath}`);
   }
 };
 var handler_default3 = compileHandler;
@@ -1389,27 +1424,27 @@ import { readFile as readFile4, writeFile as writeFile4 } from "node:fs/promises
 import path6 from "node:path";
 import { request } from "undici";
 var DEFAULT_PAGE_SIZE = 1e3;
-var request_default = async (method, options7, logger) => {
-  const base = options7.lightning || process.env.OPENFN_ENDPOINT || "https://app.openfn.org";
-  const url2 = path6.join(base, "/collections", options7.collectionName);
+var request_default = async (method, options8, logger) => {
+  const base = options8.lightning || process.env.OPENFN_ENDPOINT || "https://app.openfn.org";
+  const url2 = path6.join(base, "/collections", options8.collectionName);
   logger.debug("Calling Collections server at ", url2);
   const headers = {
-    Authorization: `Bearer ${options7.token}`
+    Authorization: `Bearer ${options8.token}`
   };
   const query = Object.assign(
     {
-      key: options7.key,
-      limit: options7.pageSize || DEFAULT_PAGE_SIZE
+      key: options8.key,
+      limit: options8.pageSize || DEFAULT_PAGE_SIZE
     },
-    options7.query
+    options8.query
   );
   const args = {
     headers,
     method,
     query
   };
-  if (options7.data) {
-    args.body = JSON.stringify(options7.data);
+  if (options8.data) {
+    args.body = JSON.stringify(options8.data);
     headers["content-type"] = "application/json";
   }
   let result = {};
@@ -1420,11 +1455,11 @@ var request_default = async (method, options7, logger) => {
     if (cursor) {
       query.cursor = cursor;
     }
-    if (options7.limit) {
-      limit = options7.limit;
+    if (options8.limit) {
+      limit = options8.limit;
       query.limit = Math.min(
-        options7.pageSize || DEFAULT_PAGE_SIZE,
-        options7.limit - count
+        options8.pageSize || DEFAULT_PAGE_SIZE,
+        options8.limit - count
       );
     }
     try {
@@ -1518,7 +1553,7 @@ var ensureToken = (opts, logger) => {
     }
   }
 };
-var buildQuery = (options7) => {
+var buildQuery = (options8) => {
   const map = {
     createdBefore: "created_before",
     createdAfter: "created_after",
@@ -1527,34 +1562,34 @@ var buildQuery = (options7) => {
   };
   const query = {};
   Object.keys(map).forEach((key) => {
-    if (options7[key]) {
-      query[map[key]] = options7[key];
+    if (options8[key]) {
+      query[map[key]] = options8[key];
     }
   });
   return query;
 };
-var get = async (options7, logger) => {
-  ensureToken(options7, logger);
-  const multiMode = options7.key.includes("*");
+var get = async (options8, logger) => {
+  ensureToken(options8, logger);
+  const multiMode = options8.key.includes("*");
   if (multiMode) {
     logger.info(
-      `Fetching multiple items from collection "${options7.collectionName}" with pattern ${options7.key}`
+      `Fetching multiple items from collection "${options8.collectionName}" with pattern ${options8.key}`
     );
   } else {
     logger.info(
-      `Fetching "${options7.key}" from collection "${options7.collectionName}"`
+      `Fetching "${options8.key}" from collection "${options8.collectionName}"`
     );
   }
   let result = await request_default(
     "GET",
     {
-      lightning: options7.endpoint,
-      token: options7.token,
-      pageSize: options7.pageSize,
-      limit: options7.limit,
-      key: options7.key,
-      collectionName: options7.collectionName,
-      query: buildQuery(options7)
+      lightning: options8.endpoint,
+      token: options8.token,
+      pageSize: options8.pageSize,
+      limit: options8.limit,
+      key: options8.key,
+      collectionName: options8.collectionName,
+      query: buildQuery(options8)
     },
     logger
   );
@@ -1562,32 +1597,32 @@ var get = async (options7, logger) => {
     logger.success(`Fetched ${Object.keys(result).length} items!`);
   } else {
     result = Object.values(result)[0];
-    logger.success(`Fetched ${options7.key}`);
+    logger.success(`Fetched ${options8.key}`);
   }
-  if (options7.outputPath) {
+  if (options8.outputPath) {
     const content = JSON.stringify(
       result,
       null,
-      options7.pretty ? 2 : void 0
+      options8.pretty ? 2 : void 0
     );
-    await writeFile4(options7.outputPath, content);
-    logger.always(`Wrote items to ${options7.outputPath}`);
+    await writeFile4(options8.outputPath, content);
+    logger.always(`Wrote items to ${options8.outputPath}`);
   } else {
     logger.print(result);
   }
 };
-var set = async (options7, logger) => {
-  if (options7.key && options7.items) {
+var set = async (options8, logger) => {
+  if (options8.key && options8.items) {
     throwAbortableError(
       "ARGUMENT_ERROR: arguments for key and items were provided",
       "If upserting multiple items with --items, do not pass a key"
     );
   }
-  ensureToken(options7, logger);
-  logger.info(`Upserting items to collection "${options7.collectionName}"`);
+  ensureToken(options8, logger);
+  logger.info(`Upserting items to collection "${options8.collectionName}"`);
   const items = [];
-  if (options7.items) {
-    const resolvedPath = path7.resolve(options7.items);
+  if (options8.items) {
+    const resolvedPath = path7.resolve(options8.items);
     logger.debug("Loading items from ", resolvedPath);
     const data = await readFile4(resolvedPath, "utf8");
     const obj = JSON.parse(data);
@@ -1595,43 +1630,43 @@ var set = async (options7, logger) => {
       items.push({ key, value: JSON.stringify(value) });
     });
     logger.info(`Upserting ${items.length} items`);
-  } else if (options7.key && options7.value) {
-    const resolvedPath = path7.resolve(options7.value);
+  } else if (options8.key && options8.value) {
+    const resolvedPath = path7.resolve(options8.value);
     logger.debug("Loading value from ", resolvedPath);
-    const data = await readFile4(path7.resolve(options7.value), "utf8");
+    const data = await readFile4(path7.resolve(options8.value), "utf8");
     const value = JSON.stringify(JSON.parse(data));
-    items.push({ key: options7.key, value });
-    logger.info(`Upserting data to "${options7.key}"`);
+    items.push({ key: options8.key, value });
+    logger.info(`Upserting data to "${options8.key}"`);
   } else {
     throw new Error("INVALID_ARGUMENTS");
   }
   const result = await request_default(
     "POST",
     {
-      lightning: options7.endpoint,
-      token: options7.token,
-      key: options7.key,
-      collectionName: options7.collectionName,
+      lightning: options8.endpoint,
+      token: options8.token,
+      key: options8.key,
+      collectionName: options8.collectionName,
       data: { items }
     },
     logger
   );
   logger.success(`Upserted ${result.upserted} items!`);
 };
-var remove = async (options7, logger) => {
-  ensureToken(options7, logger);
+var remove = async (options8, logger) => {
+  ensureToken(options8, logger);
   logger.info(
-    `Removing "${options7.key}" from collection "${options7.collectionName}"`
+    `Removing "${options8.key}" from collection "${options8.collectionName}"`
   );
-  if (options7.dryRun) {
+  if (options8.dryRun) {
     logger.info("--dry-run passed: fetching affected items");
     let result = await request_default(
       "GET",
       {
-        lightning: options7.endpoint,
-        token: options7.token,
-        key: options7.key,
-        collectionName: options7.collectionName
+        lightning: options8.endpoint,
+        token: options8.token,
+        key: options8.key,
+        collectionName: options8.collectionName
       },
       logger
     );
@@ -1643,11 +1678,11 @@ var remove = async (options7, logger) => {
     let result = await request_default(
       "DELETE",
       {
-        lightning: options7.endpoint,
-        token: options7.token,
-        key: options7.key,
-        collectionName: options7.collectionName,
-        query: buildQuery(options7)
+        lightning: options8.endpoint,
+        token: options8.token,
+        key: options8.key,
+        collectionName: options8.collectionName,
+        query: buildQuery(options8)
       },
       logger
     );
@@ -1661,9 +1696,9 @@ var handler_default4 = {
 };
 
 // src/test/handler.ts
-var testHandler = async (options7, logger) => {
+var testHandler = async (options8, logger) => {
   logger.log("Running test workflow...");
-  const opts = { ...options7 };
+  const opts = { ...options8 };
   opts.compile = true;
   opts.adaptors = [];
   const plan = {
@@ -1725,12 +1760,249 @@ import {
   validateConfig
 } from "@openfn/deploy";
 
-// src/deploy/beta.ts
-import Project2 from "@openfn/project";
-import { deployProject } from "@openfn/deploy";
+// src/projects/deploy.ts
+import Project from "@openfn/project";
+import c2 from "chalk";
+
+// 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/options.ts
+var setDefaultValue = (opts, key, value) => {
+  const v = opts[key];
+  if (isNaN(v) && !v) {
+    opts[key] = value;
+  }
+};
+var apiKey = {
+  name: "apikey",
+  yargs: {
+    alias: ["pat", "token", "api-key"],
+    description: "API Key, Personal Access Token (PAT), or other access token from Lightning"
+  },
+  ensure: (opts) => {
+    if (!opts.apikey) {
+      opts.apiKey = process.env.OPENFN_API_KEY;
+    }
+  }
+};
+var confirm = {
+  name: "confirm",
+  yargs: {
+    alias: ["y"],
+    boolean: true,
+    description: "Skip confirmation prompts (e.g. 'Are you sure?')"
+  },
+  ensure: (opts) => {
+    if (opts.y) {
+      opts.confirm = false;
+    }
+    setDefaultValue(opts, "confirm", true);
+  }
+};
+var endpoint = {
+  name: "endpoint",
+  yargs: {
+    alias: ["lightning"],
+    description: "[beta only] URL to Lightning endpoint"
+  }
+};
+var force = {
+  name: "force",
+  yargs: {
+    alias: ["f"],
+    boolean: true,
+    description: "Force metadata to be regenerated",
+    default: false
+  }
+};
+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 path8 = {
+  name: "path",
+  yargs: {
+    description: "Path"
+  }
+};
+var snapshots = {
+  name: "snapshots",
+  yargs: {
+    description: "List of snapshot ids to pull",
+    array: true
+  }
+};
+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"
+  }
+};
+
+// 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/projects/options.ts
+var env = {
+  name: "env",
+  yargs: {
+    description: "Environment name (eg staging, prod, branch)",
+    hidden: true
+  }
+};
+var alias = {
+  name: "alias",
+  yargs: {
+    alias: ["env"],
+    description: "Environment name (eg staging, prod, branch)"
+  }
+};
+var dryRun = {
+  name: "dryRun",
+  yargs: {
+    description: "Runs the command but does not commit any changes to disk or app"
+  }
+};
+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 outputPath = {
+  name: "output-path",
+  yargs: {
+    alias: ["o", "output"],
+    type: "string",
+    description: "Path to output the fetched project to"
+  }
+};
+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 = resolve_path_default(ws);
+    }
+  }
+};
 
 // src/projects/util.ts
-import path8 from "node:path";
+import path9 from "node:path";
 import { mkdir as mkdir3, writeFile as writeFile5 } from "node:fs/promises";
 
 // src/errors.ts
@@ -1741,17 +2013,17 @@ var CLIError = class extends Error {
 };
 
 // src/projects/util.ts
-var loadAppAuthConfig = (options7, logger) => {
+var loadAppAuthConfig = (options8, logger) => {
   const { OPENFN_API_KEY, OPENFN_ENDPOINT } = process.env;
   const config2 = {
-    apiKey: options7.apiKey,
-    endpoint: options7.endpoint
+    apiKey: options8.apiKey,
+    endpoint: options8.endpoint
   };
-  if (!options7.apiKey && OPENFN_API_KEY) {
+  if (!options8.apiKey && OPENFN_API_KEY) {
     logger.info("Using OPENFN_API_KEY environment variable");
     config2.apiKey = OPENFN_API_KEY;
   }
-  if (!options7.endpoint && OPENFN_ENDPOINT) {
+  if (!options8.endpoint && OPENFN_ENDPOINT) {
     logger.info("Using OPENFN_ENDPOINT environment variable");
     config2.endpoint = OPENFN_ENDPOINT;
   }
@@ -1763,13 +2035,18 @@ var ensureExt = (filePath, ext) => {
   }
   return filePath;
 };
-var serialize = async (project, outputPath2, formatOverride, dryRun = false) => {
-  const root = path8.dirname(outputPath2);
+var getSerializePath = (project, workspacePath, outputPath2) => {
+  const outputRoot = resolve_path_default(outputPath2 || workspacePath);
+  const projectsDir = project?.config.dirs.projects ?? ".projects";
+  return outputPath2 ?? `${outputRoot}/${projectsDir}/${project.qname}`;
+};
+var serialize = async (project, outputPath2, formatOverride, dryRun2 = false) => {
+  const root = path9.dirname(outputPath2);
   await mkdir3(root, { recursive: true });
   const format = formatOverride ?? project.config?.formats.project;
   const output = project?.serialize("project", { format });
   const maybeWriteFile = (filePath, output2) => {
-    if (!dryRun) {
+    if (!dryRun2) {
       return writeFile5(filePath, output2);
     }
   };
@@ -1818,45 +2095,262 @@ async function fetchProject(endpoint2, apiKey2, projectId, logger, snapshots2) {
     throw error;
   }
 }
-function handleCommonErrors(config2, error) {
-  if (error.cause?.code === "ECONNREFUSED") {
-    throw new DeployError(
-      `Failed to connect to endpoint ${config2.endpoint}, got ECONNREFUSED.`
-    );
-  }
-}
+async function deployProject(endpoint2, apiKey2, state, logger) {
+  try {
+    const url2 = getLightningUrl(endpoint2);
+    const response = await fetch(url2, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${apiKey2}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(state)
+    });
+    if (!response.ok) {
+      const body = await response.json();
+      logger?.error("Failed to deploy project:");
+      logger?.error(JSON.stringify(body, null, 2));
+      throw new CLIError(
+        `Failed to deploy project ${state.name}: ${response.status}`
+      );
+    }
+    return await response.json();
+  } catch (error) {
+    handleCommonErrors({ endpoint: endpoint2, apiKey: apiKey2 }, error);
+    throw error;
+  }
+}
+function handleCommonErrors(config2, error) {
+  if (error.cause?.code === "ECONNREFUSED") {
+    throw new DeployError(
+      `Failed to connect to endpoint ${config2.endpoint}, got ECONNREFUSED.`
+    );
+  }
+}
 var DeployError = class extends Error {
   constructor(message) {
     super(message);
   }
 };
 
-// src/deploy/beta.ts
-async function handler(options7, logger) {
-  const config2 = loadAppAuthConfig(options7, logger);
-  const project = await Project2.from("fs", {
-    root: options7.workspace || "."
+// src/util/command-builders.ts
+import c from "chalk";
+var expandYargs = (y) => {
+  if (typeof y === "function") {
+    return y();
+  }
+  return y;
+};
+function build(opts, yargs) {
+  return opts.reduce((_y, o) => {
+    if (!o?.name) {
+      console.error(`ERROR: INVALID COMMAND OPTION PASSED`, o);
+      console.error("Check the options passed to the command builder");
+      throw new Error("Invalid command");
+    }
+    return yargs.option(o.name, expandYargs(o.yargs));
+  }, yargs);
+}
+var ensure = (command8, opts) => (yargs) => {
+  yargs.command = command8;
+  opts.filter((opt) => opt.ensure).forEach((opt) => {
+    try {
+      opt.ensure(yargs);
+    } catch (e) {
+      console.log(e);
+      console.error(
+        c.red(`
+Error parsing command arguments: ${command8}.${opt.name}
+`)
+      );
+      console.error(c.red("Aborting"));
+      console.error();
+      process.exit(9);
+    }
+  });
+};
+var override = (command8, yargs) => {
+  return {
+    ...command8,
+    yargs: {
+      ...command8.yargs || {},
+      ...yargs
+    }
+  };
+};
+
+// src/projects/deploy.ts
+var options = [
+  env,
+  workspace,
+  dryRun,
+  apiKey,
+  endpoint,
+  log,
+  logJson,
+  snapshots,
+  force,
+  confirm
+];
+var printProjectName = (project) => `${project.id} (${project.openfn?.uuid || "<no UUID>"})`;
+var command = {
+  command: "deploy",
+  describe: `Deploy the checked out project to a Lightning Instance`,
+  builder: (yargs) => build(options, yargs).positional("project", {
+    describe: "The UUID, local id or local alias of the project to deploy to"
+  }).example(
+    "deploy",
+    "Deploy the checkout project to the connected instance"
+  ),
+  handler: ensure("project-deploy", options)
+};
+async function handler(options8, logger) {
+  logger.warn(
+    "WARNING: the project deploy command is in BETA and may not be stable. Use cautiously on production projects."
+  );
+  const config2 = loadAppAuthConfig(options8, logger);
+  logger.info("Attempting to load checked-out project from workspace");
+  const localProject = await Project.from("fs", {
+    root: options8.workspace || "."
   });
-  const state = project.serialize("state", { format: "json" });
-  logger.debug("Converted local project to app state:");
+  logger.success(`Loaded local project ${printProjectName(localProject)}`);
+  let remoteProject;
+  try {
+    const { data } = await fetchProject(
+      config2.endpoint,
+      config2.apiKey,
+      localProject.uuid ?? localProject.id,
+      logger
+    );
+    remoteProject = await Project.from("state", data, {
+      endpoint: config2.endpoint
+    });
+    logger.success("Downloaded latest version of project at ", config2.endpoint);
+  } catch (e) {
+    console.log(e);
+    throw e;
+  }
+  if (!options8.force && localProject.uuid !== remoteProject.uuid) {
+    logger.error(`UUID conflict!
+
+Your local project (${localProject.uuid}) has a different UUID to the remote project (${remoteProject.uuid}).
+
+Pass --force to override this error and deploy anyway.`);
+    return false;
+  }
+  const diffs = reportDiff(remoteProject, localProject, logger);
+  if (!diffs.length) {
+    logger.success("Nothing to deploy");
+    return;
+  }
+  if (!localProject.canMergeInto(remoteProject)) {
+    if (!options8.force) {
+      logger.error(`Error: Projects have diverged!
+
+The remote project has been edited since the local project was branched. Changes may be lost.
+
+Pass --force to override this error and deploy anyway.`);
+      return;
+    } else {
+      logger.warn(
+        "Remote project has not diverged from local project! Pushing anyway as -f passed"
+      );
+    }
+  } else {
+    logger.info(
+      "Remote project has not diverged from local project - it is safe to deploy \u{1F389}"
+    );
+  }
+  logger.info("Merging changes into remote project");
+  const merged = Project.merge(localProject, remoteProject, {
+    mode: "replace",
+    force: true
+  });
+  const state = merged.serialize("state", {
+    format: "json"
+  });
+  logger.debug("Converted merged local project to app state:");
   logger.debug(JSON.stringify(state, null, 2));
-  config2.endpoint ??= project.openfn?.endpoint;
-  logger.info("Sending project to app...");
-  await deployProject(config2, state);
+  config2.endpoint ??= localProject.openfn?.endpoint;
+  if (options8.dryRun) {
+    logger.always("dryRun option set: skipping upload step");
+  } else {
+    if (options8.confirm) {
+      if (!await logger.confirm(
+        `Ready to deploy changes to ${config2.endpoint}?`
+      )) {
+        logger.always("Cancelled deployment");
+        return false;
+      }
+    }
+    logger.info("Sending project to app...");
+    const { data: result } = await deployProject(
+      config2.endpoint,
+      config2.apiKey,
+      state,
+      logger
+    );
+    const finalProject = await Project.from(
+      "state",
+      result,
+      {
+        endpoint: config2.endpoint
+      },
+      merged.config
+    );
+    const finalOutputPath = getSerializePath(localProject, options8.workspace);
+    logger.debug("Updating local project at ", finalOutputPath);
+    await serialize(finalProject, finalOutputPath);
+  }
   logger.success("Updated project at", config2.endpoint);
 }
+var reportDiff = (local, remote, logger) => {
+  const diffs = remote.diff(local);
+  if (diffs.length === 0) {
+    logger.info("No workflow changes detected");
+    return diffs;
+  }
+  const added = diffs.filter((d) => d.type === "added");
+  const changed = diffs.filter((d) => d.type === "changed");
+  const removed = diffs.filter((d) => d.type === "removed");
+  if (added.length > 0) {
+    logger.break();
+    logger.always(c2.green("Workflows added:"));
+    for (const diff of added) {
+      logger.always(c2.green(`  - ${diff.id}`));
+    }
+    logger.break();
+  }
+  if (changed.length > 0) {
+    logger.break();
+    logger.always(c2.yellow("Workflows modified:"));
+    for (const diff of changed) {
+      logger.always(c2.yellow(`  - ${diff.id}`));
+    }
+    logger.break();
+  }
+  if (removed.length > 0) {
+    logger.break();
+    logger.always(c2.red("Workflows removed:"));
+    for (const diff of removed) {
+      logger.always(c2.red(`  - ${diff.id}`));
+    }
+    logger.break();
+  }
+  return diffs;
+};
 
 // src/deploy/handler.ts
 var actualDeploy = deploy;
-async function deployHandler(options7, logger, deployFn = actualDeploy) {
-  if (options7.beta) {
-    return handler(options7, logger);
+async function deployHandler(options8, logger, deployFn = actualDeploy) {
+  if (options8.beta) {
+    return handler(options8, logger);
   }
   try {
-    const config2 = mergeOverrides(await getConfig(options7.configPath), options7);
+    const config2 = mergeOverrides(await getConfig(options8.configPath), options8);
     logger.debug("Deploying with config", JSON.stringify(config2, null, 2));
-    if (options7.confirm === false) {
-      config2.requireConfirmation = options7.confirm;
+    if (options8.confirm === false) {
+      config2.requireConfirmation = options8.confirm;
     }
     if (process.env["OPENFN_API_KEY"]) {
       logger.info("Using OPENFN_API_KEY environment variable");
@@ -1881,15 +2375,15 @@ async function deployHandler(options7, logger, deployFn = actualDeploy) {
     throw error;
   }
 }
-function mergeOverrides(config2, options7) {
+function mergeOverrides(config2, options8) {
   return {
     ...config2,
     apiKey: pickFirst(process.env["OPENFN_API_KEY"], config2.apiKey),
     endpoint: pickFirst(process.env["OPENFN_ENDPOINT"], config2.endpoint),
-    statePath: pickFirst(options7.statePath, config2.statePath),
-    specPath: pickFirst(options7.projectPath, config2.specPath),
-    configPath: options7.configPath,
-    requireConfirmation: pickFirst(options7.confirm, config2.requireConfirmation)
+    statePath: pickFirst(options8.statePath, config2.statePath),
+    specPath: pickFirst(options8.projectPath, config2.specPath),
+    configPath: options8.configPath,
+    requireConfirmation: pickFirst(options8.confirm, config2.requireConfirmation)
   };
 }
 function pickFirst(...args) {
@@ -1900,20 +2394,20 @@ var handler_default6 = deployHandler;
 // src/docgen/handler.ts
 import { writeFile as writeFile6 } from "node:fs/promises";
 import { readFileSync, writeFileSync, mkdirSync, rmSync } from "node:fs";
-import path9 from "node:path";
+import path10 from "node:path";
 import { describePackage } from "@openfn/describe-package";
 import { getNameAndVersion as getNameAndVersion4 } from "@openfn/runtime";
 var RETRY_DURATION = 500;
 var RETRY_COUNT = 20;
 var TIMEOUT_MS = 1e3 * 60;
 var actualDocGen = (specifier) => describePackage(specifier, {});
-var ensurePath = (filePath) => mkdirSync(path9.dirname(filePath), { recursive: true });
+var ensurePath = (filePath) => mkdirSync(path10.dirname(filePath), { recursive: true });
 var generatePlaceholder = (path17) => {
   writeFileSync(path17, `{ "loading": true, "timestamp": ${Date.now()}}`);
 };
 var finish = (logger, resultPath) => {
   logger.success("Done! Docs can be found at:\n");
-  logger.print(`  ${path9.resolve(resultPath)}`);
+  logger.print(`  ${path10.resolve(resultPath)}`);
 };
 var generateDocs = async (specifier, path17, docgen, logger) => {
   const result = await docgen(specifier);
@@ -1952,8 +2446,8 @@ var waitForDocs = async (docs, path17, logger, retryDuration = RETRY_DURATION) =
     throw e;
   }
 };
-var docgenHandler = (options7, logger, docgen = actualDocGen, retryDuration = RETRY_DURATION) => {
-  const { specifier, repoDir } = options7;
+var docgenHandler = (options8, logger, docgen = actualDocGen, retryDuration = RETRY_DURATION) => {
+  const { specifier, repoDir } = options8;
   const { version } = getNameAndVersion4(specifier);
   if (!version) {
     logger.error("Error: No version number detected");
@@ -1994,14 +2488,14 @@ var handler_default7 = docgenHandler;
 
 // src/docs/handler.ts
 import { readFile as readFile5 } from "node:fs/promises";
-import c from "chalk";
+import c3 from "chalk";
 import { getNameAndVersion as getNameAndVersion5, getLatestVersion } from "@openfn/runtime";
 var describeFn = (adaptorName, fn) => [
-  c.green(
+  c3.green(
     `## ${fn.name}(${fn.parameters.map(({ name }) => name).join(",")})`
   ),
   `${fn.description}`,
-  c.green("### Usage Examples"),
+  c3.green("### Usage Examples"),
   fn.examples.length ? fn.examples.map(({ code, caption }) => {
     if (caption) {
       return `${caption}:
@@ -2009,21 +2503,21 @@ ${code}`;
     }
     return code;
   }).join("\n\n") : "None",
-  c.green("### API Reference"),
+  c3.green("### API Reference"),
   `https://docs.openfn.org/adaptors/packages/${adaptorName.replace(
     "@openfn/language-",
     ""
   )}-docs#${fn.name}
 `
 ].join("\n\n");
-var describeLib = (adaptorName, data) => c.green(`## ${adaptorName} ${data.version}`) + `
+var describeLib = (adaptorName, data) => c3.green(`## ${adaptorName} ${data.version}`) + `
 
 ${data.functions.map(
-  (fn) => `  ${c.yellow(fn.name)} (${fn.parameters.map((p) => p.name).join(", ")})`
+  (fn) => `  ${c3.yellow(fn.name)} (${fn.parameters.map((p) => p.name).join(", ")})`
 ).sort().join("\n")}
 `;
-var docsHandler = async (options7, logger) => {
-  const { adaptor, operation, repoDir } = options7;
+var docsHandler = async (options8, logger) => {
+  const { adaptor, operation, repoDir } = options8;
   const adaptors = expand_adaptors_default([adaptor]);
   const [adaptorName] = adaptors;
   let { name, version } = getNameAndVersion5(adaptorName);
@@ -2083,12 +2577,12 @@ var handler_default8 = docsHandler;
 import { getNameAndVersion as getNameAndVersion6 } from "@openfn/runtime";
 import { createHash } from "node:crypto";
 import { mkdir as mkdir4, readFile as readFile6, writeFile as writeFile7, readdir, rm } from "node:fs/promises";
-import path10 from "node:path";
+import path11 from "node:path";
 var UNSUPPORTED_FILE_NAME = "unsupported.json";
 var getCachePath2 = (repoDir, key) => {
-  const base = path10.join(repoDir, "meta");
+  const base = path11.join(repoDir, "meta");
   if (key) {
-    return path10.join(base, key.endsWith(".json") ? key : `${key}.json`);
+    return path11.join(base, key.endsWith(".json") ? key : `${key}.json`);
   }
   return base;
 };
@@ -2130,7 +2624,7 @@ var get2 = async (repoPath, key) => {
 };
 var set2 = async (repoPath, key, result) => {
   const p = getCachePath2(repoPath, key);
-  await mkdir4(path10.dirname(p), { recursive: true });
+  await mkdir4(path11.dirname(p), { recursive: true });
   await writeFile7(p, JSON.stringify(result));
 };
 var getUnsupportedCachePath = (repoDir) => {
@@ -2189,7 +2683,7 @@ var markAdaptorAsUnsupported = async (adaptorSpecifier, repoDir) => {
       majorMinor: parsed.majorMinor,
       timestamp: Date.now()
     };
-    await mkdir4(path10.dirname(cachePath), { recursive: true });
+    await mkdir4(path11.dirname(cachePath), { recursive: true });
     await writeFile7(cachePath, JSON.stringify(cache, null, 2));
   }
 };
@@ -2228,8 +2722,8 @@ var getAdaptorPath = async (adaptor, logger, repoDir) => {
   return adaptorPath;
 };
 var shouldAutoinstall = (adaptor) => adaptor?.length > 0 && !adaptor.startsWith("/") && !adaptor.includes("=");
-var metadataHandler = async (options7, logger) => {
-  const { repoDir, adaptors, keepUnsupported } = options7;
+var metadataHandler = async (options8, logger) => {
+  const { repoDir, adaptors, keepUnsupported } = options8;
   let adaptor = adaptors[0];
   if (await isAdaptorUnsupported(adaptor, repoDir)) {
     logger.info(
@@ -2238,7 +2732,7 @@ var metadataHandler = async (options7, logger) => {
     logger.error("No metadata helper found");
     process.exit(1);
   }
-  const state = await load_state_default({}, options7, logger);
+  const state = await load_state_default({}, options8, logger);
   logger.success(`Generating metadata`);
   logger.info("config:", state);
   const config2 = state.configuration;
@@ -2251,7 +2745,7 @@ var metadataHandler = async (options7, logger) => {
     logger.print(getCachePath2(repoDir, id));
   };
   const id = generateKey(config2, adaptor);
-  if (!options7.force) {
+  if (!options8.force) {
     logger.debug("config hash: ", id);
     const cached = await get2(repoDir, id);
     if (cached) {
@@ -2269,7 +2763,7 @@ var metadataHandler = async (options7, logger) => {
       wasAutoInstalled = true;
       adaptor = autoinstallResult[0];
     }
-    const adaptorPath = await getAdaptorPath(adaptor, logger, options7.repoDir);
+    const adaptorPath = await getAdaptorPath(adaptor, logger, options8.repoDir);
     if (!adaptorPath) {
       throw new Error(`Could not resolve adaptor path for ${adaptor}`);
     }
@@ -2321,276 +2815,10 @@ import {
   syncRemoteSpec
 } from "@openfn/deploy";
 
-// 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) => {
-    if (!o?.name) {
-      console.error(`ERROR: INVALID COMMAND OPTION PASSED`, o);
-      console.error("Check the options passed to the command builder");
-      throw new Error("Invalid command");
-    }
-    return yargs.option(o.name, expandYargs(o.yargs));
-  }, yargs);
-}
-var ensure = (command7, opts) => (yargs) => {
-  yargs.command = command7;
-  opts.filter((opt) => opt.ensure).forEach((opt) => {
-    try {
-      opt.ensure(yargs);
-    } catch (e) {
-      console.log(e);
-      console.error(
-        c2.red(`
-Error parsing command arguments: ${command7}.${opt.name}
-`)
-      );
-      console.error(c2.red("Aborting"));
-      console.error();
-      process.exit(9);
-    }
-  });
-};
-var override = (command7, yargs) => {
-  return {
-    ...command7,
-    yargs: {
-      ...command7.yargs || {},
-      ...yargs
-    }
-  };
-};
-
 // src/projects/fetch.ts
 import path12 from "node:path";
-import Project3, { Workspace } from "@openfn/project";
-
-// 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/options.ts
-var apiKey = {
-  name: "apikey",
-  yargs: {
-    alias: ["pat", "token", "api-key"],
-    description: "API Key, Personal Access Token (PAT), or other access token from Lightning"
-  },
-  ensure: (opts) => {
-    if (!opts.apikey) {
-      opts.apiKey = process.env.OPENFN_API_KEY;
-    }
-  }
-};
-var endpoint = {
-  name: "endpoint",
-  yargs: {
-    alias: ["lightning"],
-    description: "[beta only] URL to Lightning endpoint"
-  }
-};
-var force = {
-  name: "force",
-  yargs: {
-    alias: ["f"],
-    boolean: true,
-    description: "Force metadata to be regenerated",
-    default: false
-  }
-};
-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 projectPath = {
-  name: "project-path",
-  yargs: {
-    string: true,
-    alias: ["p"],
-    description: "The location of your project.yaml file"
-  }
-};
-var path11 = {
-  name: "path",
-  yargs: {
-    description: "Path"
-  }
-};
-var snapshots = {
-  name: "snapshots",
-  yargs: {
-    description: "List of snapshot ids to pull",
-    array: true
-  }
-};
-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"
-  }
-};
-
-// 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/projects/options.ts
-var env = {
-  name: "env",
-  yargs: {
-    description: "Environment name (eg staging, prod, branch)",
-    hidden: true
-  }
-};
-var alias = {
-  name: "alias",
-  yargs: {
-    description: "Environment name (eg staging, prod, branch)"
-  }
-};
-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 outputPath = {
-  name: "output-path",
-  yargs: {
-    alias: ["output"],
-    type: "string",
-    description: "Path to output the fetched project to"
-  }
-};
-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 = resolve_path_default(ws);
-    }
-  }
-};
-
-// src/projects/fetch.ts
-var options = [
+import Project2, { Workspace as Workspace2 } from "@openfn/project";
+var options2 = [
   alias,
   apiKey,
   endpoint,
@@ -2605,42 +2833,44 @@ var options = [
   env,
   workspace
 ];
-var command = {
+var command2 = {
   command: "fetch [project]",
   describe: `Download the latest version of a project from a lightning server (does not expand the project, use checkout)`,
-  builder: (yargs) => build(options, yargs).positional("project", {
+  builder: (yargs) => build(options2, yargs).positional("project", {
     describe: "The id, alias or UUID of the project to fetch. If not set, will default to the active project"
   }).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)
+  handler: ensure("project-fetch", options2)
 };
-var printProjectName = (project) => `${project.qname} (${project.id})`;
-var handler2 = async (options7, logger) => {
-  const workspacePath = options7.workspace ?? process.cwd();
+var printProjectName2 = (project) => `${project.qname} (${project.id})`;
+var handler2 = async (options8, logger) => {
+  const workspacePath = options8.workspace ?? process.cwd();
   logger.debug("Using workspace at", workspacePath);
-  const workspace2 = new Workspace(workspacePath, logger, false);
-  const { outputPath: outputPath2 } = options7;
+  const workspace2 = new Workspace2(workspacePath, logger, false);
+  const { outputPath: outputPath2 } = options8;
   const localTargetProject = await resolveOutputProject(
     workspace2,
-    options7,
+    options8,
     logger
   );
-  const remoteProject = await fetchRemoteProject(workspace2, options7, logger);
-  ensureTargetCompatible(options7, remoteProject, localTargetProject);
-  const outputRoot = resolve_path_default(outputPath2 || workspacePath);
-  const projectsDir = remoteProject?.config.dirs.projects ?? ".projects";
-  const finalOutputPath = outputPath2 ?? `${outputRoot}/${projectsDir}/${remoteProject.qname}`;
+  const remoteProject = await fetchRemoteProject(workspace2, options8, logger);
+  ensureTargetCompatible(options8, remoteProject, localTargetProject);
+  const finalOutputPath = getSerializePath(
+    remoteProject,
+    workspacePath,
+    outputPath2
+  );
   let format = void 0;
   if (outputPath2) {
     const ext = path12.extname(outputPath2).substring(1);
     if (ext.length) {
       format = ext;
     }
-    if (options7.alias) {
+    if (options8.alias) {
       logger.warn(
-        `WARNING: alias "${options7.alias}" was set, but will be ignored as output path was provided`
+        `WARNING: alias "${options8.alias}" was set, but will be ignored as output path was provided`
       );
     }
   }
@@ -2650,55 +2880,55 @@ var handler2 = async (options7, logger) => {
   );
   return remoteProject;
 };
-async function resolveOutputProject(workspace2, options7, logger) {
+async function resolveOutputProject(workspace2, options8, logger) {
   logger.debug("Checking for local copy of project...");
-  if (options7.outputPath) {
+  if (options8.outputPath) {
     try {
-      const customProject = await Project3.from("path", options7.outputPath);
+      const customProject = await Project2.from("path", options8.outputPath);
       logger.debug(
-        `Found existing local project ${printProjectName(customProject)} at`,
-        options7.outputPath
+        `Found existing local project ${printProjectName2(customProject)} at`,
+        options8.outputPath
       );
       return customProject;
     } catch (e) {
-      logger.debug("No project found at", options7.outputPath);
+      logger.debug("No project found at", options8.outputPath);
     }
   }
-  if (options7.alias) {
-    const aliasProject = workspace2.get(options7.alias);
+  if (options8.alias) {
+    const aliasProject = workspace2.get(options8.alias);
     if (aliasProject) {
       logger.debug(
         `Found local project from alias:`,
-        printProjectName(aliasProject)
+        printProjectName2(aliasProject)
       );
       return aliasProject;
     } else {
-      logger.debug(`No local project found with alias ${options7.alias}`);
+      logger.debug(`No local project found with alias ${options8.alias}`);
     }
   }
-  const project = workspace2.get(options7.project);
+  const project = workspace2.get(options8.project);
   if (project) {
     logger.debug(
       `Found local project from identifier:`,
-      printProjectName(project)
+      printProjectName2(project)
     );
     return project;
   } else {
     logger.debug(
       `No local project found matching identifier: `,
-      options7.project
+      options8.project
     );
   }
 }
-async function fetchRemoteProject(workspace2, options7, logger) {
+async function fetchRemoteProject(workspace2, options8, logger) {
   logger.debug(`Fetching latest project data from app`);
-  const config2 = loadAppAuthConfig(options7, logger);
-  let projectUUID = options7.project;
-  const localProject = workspace2.get(options7.project);
-  if (localProject?.openfn?.uuid && localProject.openfn.uuid !== options7.project) {
+  const config2 = loadAppAuthConfig(options8, logger);
+  let projectUUID = options8.project;
+  const localProject = workspace2.get(options8.project);
+  if (localProject?.openfn?.uuid && localProject.openfn.uuid !== options8.project) {
     projectUUID = localProject.openfn.uuid;
     logger.debug(
-      `Resolved ${options7.project} to UUID ${projectUUID} from local project ${printProjectName(
+      `Resolved ${options8.project} to UUID ${projectUUID} from local project ${printProjectName2(
         localProject
       )}}`
     );
@@ -2710,7 +2940,7 @@ async function fetchRemoteProject(workspace2, options7, logger) {
     projectUUID,
     logger
   );
-  const project = await Project3.from(
+  const project = await Project2.from(
     "state",
     data,
     {
@@ -2718,7 +2948,7 @@ async function fetchRemoteProject(workspace2, options7, logger) {
     },
     {
       ...workspace2.getConfig(),
-      alias: options7.alias ?? localProject?.alias ?? "main"
+      alias: options8.alias ?? localProject?.alias ?? "main"
     }
   );
   logger.debug(
@@ -2726,20 +2956,20 @@ async function fetchRemoteProject(workspace2, options7, logger) {
   );
   return project;
 }
-function ensureTargetCompatible(options7, remoteProject, localProject) {
+function ensureTargetCompatible(options8, remoteProject, localProject) {
   if (localProject) {
-    if (!options7.force && localProject.uuid != remoteProject.uuid) {
+    if (!options8.force && localProject.uuid != remoteProject.uuid) {
       const error = new Error("PROJECT_EXISTS");
       error.message = "A project with a different UUID exists at this location";
       error.fix = `You have tried to fetch a remote project into a local project with a different UUID
 
 Try adding an alias to rename the new project:
 
-      openfn fetch ${options7.project} --alias ${remoteProject.id}
+      openfn fetch ${options8.project} --alias ${remoteProject.id}
 
 To ignore this error and override the local file, pass --force (-f)
 
-    openfn fetch ${options7.project} --force
+    openfn fetch ${options8.project} --force
 `;
       error.fetched_project = {
         uuid: remoteProject.uuid,
@@ -2757,7 +2987,7 @@ To ignore this error and override the local file, pass --force (-f)
     const hasAnyHistory = remoteProject.workflows.find(
       (w) => w.workflow.history?.length
     );
-    const skipVersionCheck = options7.force || // The user forced the checkout
+    const skipVersionCheck = options8.force || // The user forced the checkout
     !hasAnyHistory;
     if (!skipVersionCheck && !remoteProject.canMergeInto(localProject)) {
       throw new Error("Error! An incompatible project exists at this location");
@@ -2766,30 +2996,30 @@ To ignore this error and override the local file, pass --force (-f)
 }
 
 // src/projects/checkout.ts
-import Project4, { Workspace as Workspace2 } from "@openfn/project";
+import Project3, { Workspace as Workspace3 } from "@openfn/project";
 import path13 from "path";
 import fs4 from "fs";
 import { rimraf } from "rimraf";
-var options2 = [log, workspace];
-var command2 = {
+var options3 = [log, workspace];
+var command3 = {
   command: "checkout <project>",
   describe: "Switch to a different OpenFn project in the same workspace",
-  handler: ensure("project-checkout", options2),
-  builder: (yargs) => build(options2, yargs).positional("project", {
+  handler: ensure("project-checkout", options3),
+  builder: (yargs) => build(options3, yargs).positional("project", {
     describe: "The id, alias or UUID of the project to chcekout",
     demandOption: true
   })
 };
-var handler3 = async (options7, logger) => {
-  const projectIdentifier = options7.project;
-  const workspacePath = options7.workspace ?? process.cwd();
-  const workspace2 = new Workspace2(workspacePath, logger);
+var handler3 = async (options8, logger) => {
+  const projectIdentifier = options8.project;
+  const workspacePath = options8.workspace ?? process.cwd();
+  const workspace2 = new Workspace3(workspacePath, logger);
   const { project: _, ...config2 } = workspace2.getConfig();
   let switchProject;
   if (/\.(yaml|json)$/.test(projectIdentifier)) {
     const filePath = projectIdentifier.startsWith("/") ? projectIdentifier : path13.join(workspacePath, projectIdentifier);
     logger.debug("Loading project from path ", filePath);
-    switchProject = await Project4.from("path", filePath, config2);
+    switchProject = await Project3.from("path", filePath, config2);
   } else {
     switchProject = workspace2.get(projectIdentifier);
   }
@@ -2814,48 +3044,48 @@ var handler3 = async (options7, logger) => {
 };
 
 // src/projects/pull.ts
-var options3 = [
+var options4 = [
   alias,
   env,
   workspace,
   apiKey,
   endpoint,
   log,
-  override(path11, {
+  override(path8, {
     description: "path to output the project to"
   }),
   logJson,
-  projectPath,
   snapshots,
-  path11,
+  path8,
   force
 ];
-var command3 = {
+var command4 = {
   command: "pull [project]",
   describe: `Pull a project from a Lightning Instance and expand to the file system (ie fetch + checkout)`,
-  builder: (yargs) => build(options3, yargs).positional("project", {
+  builder: (yargs) => build(options4, yargs).positional("project", {
     describe: "The UUID, local id or local alias of the project to pull"
   }).example(
     "pull 57862287-23e6-4650-8d79-e1dd88b24b1c",
     "Pull project with a UUID from a lightning instance"
   ),
-  handler: ensure("project-pull", options3)
+  handler: ensure("project-pull", options4)
 };
-async function handler4(options7, logger) {
-  await handler2(options7, logger);
+async function handler4(options8, logger) {
+  await handler2(options8, logger);
   logger.success(`Downloaded latest project version`);
-  await handler3(options7, logger);
+  await handler3(options8, logger);
   logger.success(`Checked out project locally`);
 }
 var pull_default = handler4;
 
 // src/pull/handler.ts
-async function pullHandler(options7, logger) {
-  if (options7.beta) {
-    return pull_default(options7, logger);
+async function pullHandler(options8, logger) {
+  if (options8.beta) {
+    options8.project = options8.projectId;
+    return pull_default(options8, logger);
   }
   try {
-    const config2 = mergeOverrides2(await getConfig2(options7.configPath), options7);
+    const config2 = mergeOverrides2(await getConfig2(options8.configPath), options8);
     if (process.env["OPENFN_API_KEY"]) {
       logger.info("Using OPENFN_API_KEY environment variable");
       config2.apiKey = process.env["OPENFN_API_KEY"];
@@ -2869,8 +3099,8 @@ async function pullHandler(options7, logger) {
     );
     const { data: project } = await getProject(
       config2,
-      options7.projectId,
-      options7.snapshots
+      options8.projectId,
+      options8.snapshots
     );
     if (!project) {
       logger.error("ERROR: Project not found.");
@@ -2883,8 +3113,8 @@ async function pullHandler(options7, logger) {
     const state = getStateFromProjectPayload(project);
     logger.always("Downloading the project spec (as YAML) from the server.");
     const queryParams = new URLSearchParams();
-    queryParams.append("id", options7.projectId);
-    options7.snapshots?.forEach(
+    queryParams.append("id", options8.projectId);
+    options8.snapshots?.forEach(
       (snapshot) => queryParams.append("snapshots[]", snapshot)
     );
     const url2 = new URL(
@@ -2933,13 +3163,13 @@ async function pullHandler(options7, logger) {
     throw error;
   }
 }
-function mergeOverrides2(config2, options7) {
+function mergeOverrides2(config2, options8) {
   return {
     ...config2,
     apiKey: pickFirst2(process.env["OPENFN_API_KEY"], config2.apiKey),
     endpoint: pickFirst2(process.env["OPENFN_ENDPOINT"], config2.endpoint),
-    configPath: options7.configPath,
-    requireConfirmation: pickFirst2(options7.confirm, config2.requireConfirmation)
+    configPath: options8.configPath,
+    requireConfirmation: pickFirst2(options8.confirm, config2.requireConfirmation)
   };
 }
 function pickFirst2(...args) {
@@ -2947,10 +3177,11 @@ function pickFirst2(...args) {
 }
 var handler_default10 = pullHandler;
 
-// src/projects/handler.ts
-var handler_exports = {};
-__export(handler_exports, {
+// src/projects/index.ts
+var projects_exports = {};
+__export(projects_exports, {
   checkout: () => handler3,
+  deploy: () => handler,
   fetch: () => handler2,
   list: () => handler5,
   merge: () => handler7,
@@ -2959,20 +3190,20 @@ __export(handler_exports, {
 });
 
 // src/projects/list.ts
-import { Workspace as Workspace3 } from "@openfn/project";
-var options4 = [log, workspace];
-var command4 = {
+import { Workspace as Workspace4 } from "@openfn/project";
+var options5 = [log, workspace];
+var command5 = {
   command: "list [project-path]",
   describe: "List all the openfn projects available in the current directory",
   aliases: ["project", "$0"],
-  handler: ensure("project-list", options4),
-  builder: (yargs) => build(options4, yargs)
+  handler: ensure("project-list", options5),
+  builder: (yargs) => build(options5, yargs)
 };
-var handler5 = async (options7, logger) => {
+var handler5 = async (options8, logger) => {
   logger.info("Searching for projects in workspace at:");
-  logger.info(" ", options7.workspace);
+  logger.info(" ", options8.workspace);
   logger.break();
-  const workspace2 = new Workspace3(options7.workspace);
+  const workspace2 = new Workspace4(options8.workspace);
   if (!workspace2.valid) {
     throw new Error("No OpenFn projects found");
   }
@@ -2990,26 +3221,26 @@ ${project.workflows.map((w) => "    - " + w.id).join("\n")}`;
 }
 
 // src/projects/version.ts
-import { Workspace as Workspace4 } from "@openfn/project";
-var options5 = [workflow, workspace, workflowMappings];
-var command5 = {
+import { Workspace as Workspace5 } from "@openfn/project";
+var options6 = [workflow, workspace, workflowMappings];
+var command6 = {
   command: "version [workflow]",
   describe: "Returns the version hash of a given workflow in a workspace",
-  handler: ensure("project-version", options5),
-  builder: (yargs) => build(options5, yargs)
+  handler: ensure("project-version", options6),
+  builder: (yargs) => build(options6, yargs)
 };
-var handler6 = async (options7, logger) => {
-  const workspace2 = new Workspace4(options7.workspace);
+var handler6 = async (options8, logger) => {
+  const workspace2 = new Workspace5(options8.workspace);
   if (!workspace2.valid) {
     logger.error("Command was run in an invalid openfn workspace");
     return;
   }
   const output = /* @__PURE__ */ new Map();
   const activeProject = workspace2.getActiveProject();
-  if (options7.workflow) {
-    const workflow2 = activeProject?.getWorkflow(options7.workflow);
+  if (options8.workflow) {
+    const workflow2 = activeProject?.getWorkflow(options8.workflow);
     if (!workflow2) {
-      logger.error(`No workflow found with id ${options7.workflow}`);
+      logger.error(`No workflow found with id ${options8.workflow}`);
       return;
     }
     output.set(workflow2.name || workflow2.id, workflow2.getVersionHash());
@@ -3023,7 +3254,7 @@ var handler6 = async (options7, logger) => {
     return;
   }
   let final;
-  if (options7.json) {
+  if (options8.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");
@@ -3034,10 +3265,10 @@ ${final}`);
 };
 
 // src/projects/merge.ts
-import Project6, { Workspace as Workspace5 } from "@openfn/project";
+import Project5, { Workspace as Workspace6 } from "@openfn/project";
 import path15 from "node:path";
 import fs6 from "node:fs/promises";
-var options6 = [
+var options7 = [
   removeUnmapped,
   workflowMappings,
   workspace,
@@ -3062,24 +3293,24 @@ var options6 = [
     description: "Force a merge even when workflows are incompatible"
   })
 ];
-var command6 = {
+var command7 = {
   command: "merge <project>",
   describe: "Merges the specified project (by UUID, id or alias) into the currently checked out project",
-  handler: ensure("project-merge", options6),
-  builder: (yargs) => build(options6, yargs)
+  handler: ensure("project-merge", options7),
+  builder: (yargs) => build(options7, yargs)
 };
-var handler7 = async (options7, logger) => {
-  const workspacePath = options7.workspace;
-  const workspace2 = new Workspace5(workspacePath);
+var handler7 = async (options8, logger) => {
+  const workspacePath = options8.workspace;
+  const workspace2 = new Workspace6(workspacePath);
   if (!workspace2.valid) {
     logger.error("Command was run in an invalid openfn workspace");
     return;
   }
   let targetProject;
-  if (options7.base) {
-    const basePath = path15.resolve(options7.base);
+  if (options8.base) {
+    const basePath = path15.resolve(options8.base);
     logger.debug("Loading target project from path", basePath);
-    targetProject = await Project6.from("path", basePath);
+    targetProject = await Project5.from("path", basePath);
   } else {
     targetProject = workspace2.getActiveProject();
     if (!targetProject) {
@@ -3088,12 +3319,12 @@ var handler7 = async (options7, logger) => {
     }
     logger.debug(`Loading target project from workspace (${targetProject.id})`);
   }
-  const sourceProjectIdentifier = options7.project;
+  const sourceProjectIdentifier = options8.project;
   let sourceProject;
   if (/\.(ya?ml|json)$/.test(sourceProjectIdentifier)) {
     const filePath = path15.join(workspacePath, sourceProjectIdentifier);
     logger.debug("Loading source project from path ", filePath);
-    sourceProject = await Project6.from("path", filePath);
+    sourceProject = await Project5.from("path", filePath);
   } else {
     logger.debug(
       `Loading source project from workspace ${sourceProjectIdentifier}`
@@ -3114,20 +3345,20 @@ var handler7 = async (options7, logger) => {
     logger.error("The checked out project has no id");
     return;
   }
-  const finalPath = options7.outputPath ?? workspace2.getProjectPath(targetProject.id);
+  const finalPath = options8.outputPath ?? workspace2.getProjectPath(targetProject.id);
   if (!finalPath) {
     logger.error("Path to checked out project not found.");
     return;
   }
-  const final = Project6.merge(sourceProject, targetProject, {
-    removeUnmapped: options7.removeUnmapped,
-    workflowMappings: options7.workflowMappings,
-    force: options7.force
+  const final = Project5.merge(sourceProject, targetProject, {
+    removeUnmapped: options8.removeUnmapped,
+    workflowMappings: options8.workflowMappings,
+    force: options8.force
   });
   let outputFormat = workspace2.config.formats.project;
-  if (options7.outputPath?.endsWith(".json")) {
+  if (options8.outputPath?.endsWith(".json")) {
     outputFormat = "json";
-  } else if (options7.outputPath?.endsWith(".yaml")) {
+  } else if (options8.outputPath?.endsWith(".yaml")) {
     outputFormat = "yaml";
   }
   let finalState = final.serialize("state", {
@@ -3142,8 +3373,8 @@ var handler7 = async (options7, logger) => {
   await handler3(
     {
       workspace: workspacePath,
-      project: options7.outputPath ? finalPath : final.id,
-      log: options7.log
+      project: options8.outputPath ? finalPath : final.id,
+      log: options8.log
     },
     logger
   );
@@ -3173,8 +3404,8 @@ var loadVersionFromPath = (adaptorPath) => {
     return "unknown";
   }
 };
-var printVersions = async (logger, options7 = {}, includeComponents = false) => {
-  const { adaptors, logJson: logJson2 } = options7;
+var printVersions = async (logger, options8 = {}, includeComponents = false) => {
+  const { adaptors, logJson: logJson2 } = options8;
   let longestAdaptorName = "";
   const adaptorList = [];
   adaptors?.forEach((adaptor) => {
@@ -3184,7 +3415,7 @@ var printVersions = async (logger, options7 = {}, includeComponents = false) =>
       const [namePart, pathPart] = adaptor.split("=");
       adaptorVersion = loadVersionFromPath(pathPart);
       adaptorName = getNameAndVersion7(namePart).name;
-    } else if (options7.monorepoPath) {
+    } else if (options8.monorepoPath) {
       adaptorName = getNameAndVersion7(adaptor).name;
       adaptorVersion = "monorepo";
     } else {
@@ -3273,8 +3504,8 @@ var handlers = {
   docs: handler_default8,
   metadata: handler_default9,
   pull: handler_default10,
-  projects: handler_exports,
-  project: handler_exports,
+  projects: projects_exports,
+  project: projects_exports,
   ["collections-get"]: handler_default4.get,
   ["collections-set"]: handler_default4.set,
   ["collections-remove"]: handler_default4.remove,
@@ -3282,6 +3513,7 @@ var handlers = {
   ["repo-install"]: install,
   ["repo-pwd"]: pwd,
   ["repo-list"]: list,
+  ["project-deploy"]: handler,
   ["project-pull"]: handler4,
   ["project-list"]: handler5,
   ["project-version"]: handler6,
@@ -3290,13 +3522,13 @@ var handlers = {
   ["project-fetch"]: handler2,
   version: async (opts, logger) => print_versions_default(logger, opts, true)
 };
-var parse = async (options7, log2) => {
-  const logger = log2 || logger_default(CLI, options7);
-  if (options7.command === "execute" || options7.command === "test") {
-    await print_versions_default(logger, options7);
+var parse = async (options8, log2) => {
+  const logger = log2 || logger_default(CLI, options8);
+  if (options8.command === "execute" || options8.command === "test") {
+    await print_versions_default(logger, options8);
   }
   report(logger);
-  const { monorepoPath } = options7;
+  const { monorepoPath } = options8;
   if (monorepoPath) {
     if (monorepoPath === "ERR") {
       logger.error(
@@ -3307,19 +3539,19 @@ var parse = async (options7, log2) => {
     }
     await validateMonoRepo(monorepoPath, logger);
     logger.success(`Loading adaptors from monorepo at ${monorepoPath}`);
-    options7.adaptors = map_adaptors_to_monorepo_default(
+    options8.adaptors = map_adaptors_to_monorepo_default(
       monorepoPath,
-      options7.adaptors,
+      options8.adaptors,
       logger
     );
   }
-  const handler8 = handlers[options7.command];
+  const handler8 = handlers[options8.command];
   if (!handler8) {
-    logger.error(`Unrecognised command: ${options7.command}`);
+    logger.error(`Unrecognised command: ${options8.command}`);
     process.exit(1);
   }
   try {
-    return await handler8(options7, logger);
+    return await handler8(options8, logger);
   } catch (e) {
     if (!process.exitCode) {
       process.exitCode = e.exitCode || 1;