@openfn/cli 1.25.0 → 1.27.0

package/dist/index.js

@@ -51,15 +51,15 @@ import nodePath from "node:path";
 var DEFAULT_REPO_DIR = "/tmp/openfn/repo";
 
 // src/util/expand-adaptors.ts
-var expand2 = (name) => {
-  if (typeof name === "string") {
-    const [left] = name.split("=");
+var expand2 = (name2) => {
+  if (typeof name2 === "string") {
+    const [left] = name2.split("=");
     if (left.match("/") || left.endsWith(".js")) {
-      return name;
+      return name2;
     }
-    return `@openfn/language-${name}`;
+    return `@openfn/language-${name2}`;
   }
-  return name;
+  return name2;
 };
 var expand_adaptors_default = (input) => {
   if (Array.isArray(input)) {
@@ -982,6 +982,21 @@ var workspace = {
     }
   }
 };
+var newProject = {
+  name: "new",
+  yargs: {
+    description: "Create a new project when deploying",
+    default: false,
+    boolean: true
+  }
+};
+var name = {
+  name: "name",
+  yargs: {
+    type: "string",
+    description: "When deploying a new project, set the name"
+  }
+};
 
 // src/deploy/command.ts
 var options3 = [
@@ -1240,17 +1255,18 @@ var command2 = {
 var version_default = command2;
 
 // src/projects/merge.ts
-import Project3, { Workspace as Workspace4 } from "@openfn/project";
+import Project3, { Workspace as Workspace5 } from "@openfn/project";
 
 // src/projects/checkout.ts
-import Project2, { Workspace as Workspace3 } from "@openfn/project";
+import Project2, { Workspace as Workspace4 } from "@openfn/project";
 import { rimraf as rimraf2 } from "rimraf";
 
 // src/projects/util.ts
 import { rimraf } from "rimraf";
+import { versionsEqual } from "@openfn/project";
 
 // src/projects/checkout.ts
-var options11 = [log, workspace, clean];
+var options11 = [log, workspace, clean, force];
 var command3 = {
   command: "checkout <project>",
   describe: "Switch to a different OpenFn project in the same workspace",
@@ -1297,7 +1313,7 @@ var command4 = {
 var merge_default = command4;
 
 // src/projects/fetch.ts
-import Project4, { Workspace as Workspace5 } from "@openfn/project";
+import Project4, { Workspace as Workspace6 } from "@openfn/project";
 var options13 = [
   alias,
   apiKey,
@@ -1328,7 +1344,7 @@ var command5 = {
 var fetch_default = command5;
 
 // src/projects/pull.ts
-import { Workspace as Workspace6 } from "@openfn/project";
+import { Workspace as Workspace7 } from "@openfn/project";
 var options14 = [
   alias,
   env2,
@@ -1357,12 +1373,15 @@ var command6 = {
 };
 
 // src/projects/deploy.ts
-import Project5 from "@openfn/project";
+import Project5, { versionsEqual as versionsEqual2, Workspace as Workspace8 } from "@openfn/project";
 import c2 from "chalk";
 var options15 = [
   env2,
   workspace,
   dryRun2,
+  newProject,
+  name,
+  alias,
   apiKey,
   endpoint,
   log,
@@ -1373,6 +1392,7 @@ var options15 = [
 ];
 var command7 = {
   command: "deploy",
+  aliases: "push",
   describe: `Deploy the checked out project to a Lightning Instance`,
   builder: (yargs2) => build(options15, yargs2).positional("project", {
     describe: "The UUID, local id or local alias of the project to deploy to"

package/dist/process/runner.js

@@ -1,7 +1,7 @@
 var __defProp = Object.defineProperty;
 var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
 };
 
 // src/apollo/handler.ts
@@ -133,14 +133,14 @@ var callApollo = async (apolloBaseUrl, serviceName, payload, logger) => {
     });
   });
 };
-var loadPayload = async (logger, path17) => {
-  if (!path17) {
+var loadPayload = async (logger, path18) => {
+  if (!path18) {
     logger.warn("No JSON payload provided");
     logger.warn("Most apollo services require JSON to be uploaded");
     return {};
   }
-  if (path17.endsWith(".json")) {
-    const str = await readFile(path17, "utf8");
+  if (path18.endsWith(".json")) {
+    const str = await readFile(path18, "utf8");
     const json = JSON.parse(str);
     logger.debug("Loaded JSON payload");
     return json;
@@ -169,14 +169,14 @@ var namespaces = {
   [COMPILER]: "CMP",
   [JOB]: "JOB"
 };
-var createLogger2 = (name = "", options8) => {
+var createLogger2 = (name2 = "", options8) => {
   const logOptions = options8.log || {};
   let json = false;
-  let level = logOptions[name] || logOptions.default || "default";
+  let level = logOptions[name2] || logOptions.default || "default";
   if (options8.logJson) {
     json = true;
   }
-  return actualCreateLogger(namespaces[name] || name, {
+  return actualCreateLogger(namespaces[name2] || name2, {
     level,
     json,
     sanitize: options8.sanitize || "none",
@@ -276,13 +276,13 @@ var execute_default = async (plan, input, opts, logger) => {
 };
 function parseAdaptors(plan) {
   const extractInfo = (specifier) => {
-    const [module, path17] = specifier.split("=");
-    const { name, version } = getNameAndVersion(module);
+    const [module, path18] = specifier.split("=");
+    const { name: name2, version } = getNameAndVersion(module);
     const info = {
-      name
+      name: name2
     };
-    if (path17) {
-      info.path = path17;
+    if (path18) {
+      info.path = path18;
     }
     if (version) {
       info.version = version;
@@ -293,8 +293,8 @@ function parseAdaptors(plan) {
   Object.values(plan.workflow.steps).forEach((step) => {
     const job = step;
     job.adaptors?.forEach((adaptor) => {
-      const { name, ...maybeVersionAndPath } = extractInfo(adaptor);
-      adaptors[name] = maybeVersionAndPath;
+      const { name: name2, ...maybeVersionAndPath } = extractInfo(adaptor);
+      adaptors[name2] = maybeVersionAndPath;
     });
   });
   return adaptors;
@@ -410,12 +410,12 @@ var install = async (opts, log2 = defaultLogger) => {
   return [];
 };
 var removePackage = async (packageSpecifier, repoDir, logger) => {
-  const { name, version } = getNameAndVersion2(packageSpecifier);
+  const { name: name2, version } = getNameAndVersion2(packageSpecifier);
   if (!version) {
     logger.warn(`Cannot remove ${packageSpecifier}: no version specified`);
     return;
   }
-  const aliasedName = `${name}_${version}`;
+  const aliasedName = `${name2}_${version}`;
   logger.info(`Removing package ${aliasedName} from repo...`);
   try {
     await new Promise((resolve, reject) => {
@@ -461,11 +461,11 @@ var getDependencyList = async (options8, _logger) => {
   const result = {};
   if (pkg) {
     Object.keys(pkg.dependencies).forEach((key) => {
-      const [name, version] = key.split("_");
-      if (!result[name]) {
-        result[name] = [];
+      const [name2, version] = key.split("_");
+      if (!result[name2]) {
+        result[name2] = [];
       }
-      result[name].push(version);
+      result[name2].push(version);
     });
   }
   return result;
@@ -592,10 +592,10 @@ var stripVersionSpecifier = (specifier) => {
   return specifier;
 };
 var resolveSpecifierPath = async (pattern, repoDir, log2) => {
-  const [specifier, path17] = pattern.split("=");
-  if (path17) {
-    log2.debug(`Resolved ${specifier} to path: ${path17}`);
-    return path17;
+  const [specifier, path18] = pattern.split("=");
+  if (path18) {
+    log2.debug(`Resolved ${specifier} to path: ${path18}`);
+    return path18;
   }
   const repoPath = await getModulePath(specifier, repoDir, log2);
   if (repoPath) {
@@ -614,12 +614,12 @@ var loadTransformOptions = async (opts, log2) => {
       let exports;
       const [specifier] = adaptorInput.split("=");
       log2.debug(`Trying to preload types for ${specifier}`);
-      const path17 = await resolveSpecifierPath(adaptorInput, opts.repoDir, log2);
-      if (path17) {
+      const path18 = await resolveSpecifierPath(adaptorInput, opts.repoDir, log2);
+      if (path18) {
         try {
-          exports = await preloadAdaptorExports(path17, log2);
+          exports = await preloadAdaptorExports(path18, log2);
         } catch (e) {
-          log2.error(`Failed to load adaptor typedefs from path ${path17}`);
+          log2.error(`Failed to load adaptor typedefs from path ${path18}`);
           log2.error(e);
         }
       }
@@ -765,15 +765,15 @@ import { isPath } from "@openfn/compiler";
 import { Workspace, yamlToJson } from "@openfn/project";
 
 // src/util/expand-adaptors.ts
-var expand = (name) => {
-  if (typeof name === "string") {
-    const [left] = name.split("=");
+var expand = (name2) => {
+  if (typeof name2 === "string") {
+    const [left] = name2.split("=");
     if (left.match("/") || left.endsWith(".js")) {
-      return name;
+      return name2;
     }
-    return `@openfn/language-${name}`;
+    return `@openfn/language-${name2}`;
   }
-  return name;
+  return name2;
 };
 var expand_adaptors_default = (input) => {
   if (Array.isArray(input)) {
@@ -808,16 +808,16 @@ var updatePath = (adaptor, repoPath, log2) => {
   if (adaptor.match("=")) {
     return adaptor;
   }
-  const { name, version } = getNameAndVersion3(adaptor);
+  const { name: name2, version } = getNameAndVersion3(adaptor);
   if (version) {
     log2.warn(
       `Warning: Ignoring version specifier on ${adaptor} as loading from the adaptors monorepo`
     );
   }
-  const shortName = name.replace("@openfn/language-", "");
+  const shortName = name2.replace("@openfn/language-", "");
   const abspath = path3.resolve(repoPath, "packages", shortName);
-  log2.info(`Mapped adaptor ${name} to monorepo: ${abspath}`);
-  return `${name}=${abspath}`;
+  log2.info(`Mapped adaptor ${name2} to monorepo: ${abspath}`);
+  return `${name2}=${abspath}`;
 };
 var mapAdaptorsToMonorepo = (monorepoPath = "", input = [], log2) => {
   if (monorepoPath) {
@@ -843,8 +843,8 @@ var map_adaptors_to_monorepo_default = mapAdaptorsToMonorepo;
 // src/util/resolve-path.ts
 import nodepath from "node:path";
 import os from "node:os";
-var resolve_path_default = (path17, root) => {
-  return path17.startsWith("~") ? path17.replace(`~`, os.homedir) : nodepath.resolve(root ?? "", path17);
+var resolve_path_default = (path18, root) => {
+  return path18.startsWith("~") ? path18.replace(`~`, os.homedir) : nodepath.resolve(root ?? "", path18);
 };
 
 // src/util/load-plan.ts
@@ -858,10 +858,10 @@ var loadPlan = async (options8, logger) => {
     );
     const workspace2 = new Workspace(options8.workspace);
     const proj = await workspace2.getCheckedOutProject();
-    const name = workflowName || options8.workflow;
-    const workflow2 = proj?.getWorkflow(name);
+    const name2 = workflowName || options8.workflow;
+    const workflow2 = proj?.getWorkflow(name2);
     if (!workflow2) {
-      const e = new Error(`Could not find Workflow "${name}"`);
+      const e = new Error(`Could not find Workflow "${name2}"`);
       delete e.stack;
       throw e;
     }
@@ -870,7 +870,7 @@ var loadPlan = async (options8, logger) => {
     };
     options8.credentials ??= workspace2.getConfig().credentials;
     options8.collectionsEndpoint ??= proj.openfn?.endpoint;
-    options8.cachePath ??= workspace2.workflowsPath + `/${name}/${CACHE_DIR}`;
+    options8.cachePath ??= workspace2.workflowsPath + `/${name2}/${CACHE_DIR}`;
   }
   if (options8.path && /ya?ml$/.test(options8.path)) {
     const content = await fs3.readFile(path4.resolve(options8.path), "utf-8");
@@ -945,7 +945,7 @@ var loadExpression = async (options8, logger) => {
   logger.debug(`Loading expression from ${expressionPath}`);
   try {
     const expression = await fs3.readFile(expressionPath, "utf8");
-    const name = path4.parse(expressionPath).name;
+    const name2 = path4.parse(expressionPath).name;
     const step = {
       expression,
       // The adaptor should have been expanded nicely already, so we don't need intervene here
@@ -955,7 +955,7 @@ var loadExpression = async (options8, logger) => {
     maybeAssign(options8, wfOptions, ["timeout"]);
     const plan = {
       workflow: {
-        name,
+        name: name2,
         steps: [step],
         globals: options8.globals
       },
@@ -990,7 +990,7 @@ var loadOldWorkflow = async (workflow2, options8, logger, defaultName = "") => {
   return final;
 };
 var fetchFile = async (fileInfo, log2) => {
-  const { rootDir = "", filePath, name } = fileInfo;
+  const { rootDir = "", filePath, name: name2 } = fileInfo;
   try {
     const fullPath = resolve_path_default(filePath, rootDir);
     const result = await fs3.readFile(fullPath, "utf8");
@@ -999,7 +999,7 @@ var fetchFile = async (fileInfo, log2) => {
   } catch (e) {
     abort_default(
       log2,
-      `File not found for ${name}: ${filePath}`,
+      `File not found for ${name2}: ${filePath}`,
       void 0,
       `This workflow references a file which cannot be found at ${filePath}
 
@@ -1148,8 +1148,8 @@ var loadXPlan = async (plan, options8, logger, defaultName = "") => {
 };
 
 // src/util/assert-path.ts
-var assert_path_default = (path17) => {
-  if (!path17) {
+var assert_path_default = (path18) => {
+  if (!path18) {
     console.error("ERROR: no path provided!");
     console.error("\nUsage:");
     console.error("  open path/to/job");
@@ -1212,7 +1212,8 @@ var assertStepStructure = (step, index) => {
     "state",
     "configuration",
     "linker",
-    "openfn"
+    "openfn",
+    "enabled"
   ];
   for (const key in step) {
     if (!allowedKeys.includes(key)) {
@@ -1781,8 +1782,10 @@ import {
 } from "@openfn/deploy";
 
 // src/projects/deploy.ts
-import Project from "@openfn/project";
+import Project, { versionsEqual as versionsEqual2, Workspace as Workspace3 } from "@openfn/project";
 import c2 from "chalk";
+import { writeFile as writeFile6 } from "node:fs/promises";
+import path10 from "node:path";
 
 // src/util/ensure-log-opts.ts
 var defaultLoggerOptions = {
@@ -2035,6 +2038,21 @@ var workspace = {
     }
   }
 };
+var newProject = {
+  name: "new",
+  yargs: {
+    description: "Create a new project when deploying",
+    default: false,
+    boolean: true
+  }
+};
+var name = {
+  name: "name",
+  yargs: {
+    type: "string",
+    description: "When deploying a new project, set the name"
+  }
+};
 
 // src/projects/util.ts
 import path9 from "node:path";
@@ -2049,11 +2067,12 @@ var CLIError = class extends Error {
 
 // src/projects/util.ts
 import { rimraf } from "rimraf";
+import { versionsEqual } from "@openfn/project";
 var loadAppAuthConfig = (options8, logger) => {
   const { OPENFN_API_KEY, OPENFN_ENDPOINT } = process.env;
   const config2 = {
     apiKey: options8.apiKey,
-    endpoint: options8.endpoint
+    endpoint: options8.endpoint ?? "https://app.openfn.org"
   };
   if (!options8.apiKey && OPENFN_API_KEY) {
     logger.info("Using OPENFN_API_KEY environment variable");
@@ -2063,6 +2082,11 @@ var loadAppAuthConfig = (options8, logger) => {
     logger.info("Using OPENFN_ENDPOINT environment variable");
     config2.endpoint = OPENFN_ENDPOINT;
   }
+  if (!config2.apiKey) {
+    throw new CLIError(
+      "OPENFN_API_KEY is required. Set it in .env, pass --api-key, or set the environment variable."
+    );
+  }
   return config2;
 };
 var ensureExt = (filePath, ext) => {
@@ -2096,10 +2120,15 @@ var serialize = async (project, outputPath2, formatOverride, dryRun2 = false) =>
   }
   return finalPath;
 };
-var getLightningUrl = (endpoint2, path17 = "", snapshots2) => {
+var getLightningUrl = (endpoint2, path18 = "", snapshots2) => {
+  if (!endpoint2) {
+    throw new CLIError(
+      "OPENFN_ENDPOINT is required. Set it in .env, pass --endpoint, or set the environment variable.\nExample: OPENFN_ENDPOINT=https://app.openfn.org"
+    );
+  }
   const params = new URLSearchParams();
   snapshots2?.forEach((snapshot) => params.append("snapshots[]", snapshot));
-  return new URL(`/api/provision/${path17}?${params.toString()}`, endpoint2);
+  return new URL(`/api/provision/${path18}?${params.toString()}`, endpoint2);
 };
 async function fetchProject(endpoint2, apiKey2, projectId, logger, snapshots2) {
   const url2 = getLightningUrl(endpoint2, projectId, snapshots2);
@@ -2143,9 +2172,16 @@ async function deployProject(endpoint2, apiKey2, state, logger) {
       body: JSON.stringify(state)
     });
     if (!response.ok) {
-      const body = await response.json();
+      logger?.error(`Deploy failed with code `, response.status);
       logger?.error("Failed to deploy project:");
-      logger?.error(JSON.stringify(body, null, 2));
+      const contentType = response.headers.get("content-type") ?? "";
+      if (contentType.match("application/json ")) {
+        const body = await response.json();
+        logger?.error(JSON.stringify(body, null, 2));
+      } else {
+        const content = await response.text();
+        logger?.error(content);
+      }
       throw new CLIError(
         `Failed to deploy project ${state.name}: ${response.status}`
       );
@@ -2175,9 +2211,9 @@ async function tidyWorkflowDir(currentProject, incomingProject, dryRun2 = false)
   const currentFiles = currentProject.serialize("fs");
   const newFiles = incomingProject.serialize("fs");
   const toRemove = [];
-  for (const path17 in currentFiles) {
-    if (!newFiles[path17]) {
-      toRemove.push(path17);
+  for (const path18 in currentFiles) {
+    if (!newFiles[path18]) {
+      toRemove.push(path18);
     }
   }
   if (!dryRun2) {
@@ -2185,6 +2221,41 @@ async function tidyWorkflowDir(currentProject, incomingProject, dryRun2 = false)
   }
   return toRemove.sort();
 }
+var updateForkedFrom = (proj) => {
+  proj.cli.forked_from = proj.workflows.reduce((obj, wf) => {
+    if (wf.history.length) {
+      obj[wf.id] = wf.history.at(-1);
+    }
+    return obj;
+  }, {});
+  return proj;
+};
+var findLocallyChangedWorkflows = async (workspace2, project, ifNoForkedFrom = "assume-diverged") => {
+  const { forked_from } = workspace2.activeProject ?? {};
+  if (!forked_from || Object.keys(forked_from).length === 0) {
+    if (ifNoForkedFrom === "assume-ok") {
+      return [];
+    }
+    return project.workflows.map((w) => w.id);
+  }
+  const changedWorkflows = [];
+  for (const workflow2 of project.workflows) {
+    const currentHash = workflow2.getVersionHash();
+    const forkedHash = forked_from[workflow2.id];
+    if (forkedHash === void 0) {
+      changedWorkflows.push(workflow2.id);
+    } else if (!versionsEqual(currentHash, forkedHash)) {
+      changedWorkflows.push(workflow2.id);
+    }
+  }
+  const currentWorkflowIds = new Set(project.workflows.map((w) => w.id));
+  for (const workflowId in forked_from) {
+    if (!currentWorkflowIds.has(workflowId)) {
+      changedWorkflows.push(workflowId);
+    }
+  }
+  return changedWorkflows;
+};
 
 // src/util/command-builders.ts
 import c from "chalk";
@@ -2237,6 +2308,9 @@ var options = [
   env,
   workspace,
   dryRun,
+  newProject,
+  name,
+  alias,
   apiKey,
   endpoint,
   log,
@@ -2248,6 +2322,7 @@ var options = [
 var printProjectName = (project) => `${project.id} (${project.openfn?.uuid || "<no UUID>"})`;
 var command = {
   command: "deploy",
+  aliases: "push",
   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"
@@ -2257,16 +2332,25 @@ var command = {
   ),
   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);
+var hasRemoteDiverged = (local, remote, workflows = []) => {
+  let diverged = null;
+  const refs = local.cli.forked_from ?? {};
+  const filteredWorkflows = workflows.length ? local.workflows.filter((w) => workflows.includes(w.id)) : local.workflows;
+  for (const wf of filteredWorkflows) {
+    if (wf.id in refs) {
+      const forkedVersion = refs[wf.id];
+      const remoteVersion = remote.getWorkflow(wf.id)?.history.at(-1);
+      if (!versionsEqual2(forkedVersion, remoteVersion)) {
+        diverged ??= [];
+        diverged.push(wf.id);
+      }
+    } else {
+    }
+  }
+  return diverged;
+};
+var syncProjects = async (options8, config2, ws, localProject, logger) => {
   logger.info("Attempting to load checked-out project from workspace");
-  const localProject = await Project.from("fs", {
-    root: options8.workspace || "."
-  });
-  logger.success(`Loaded local project ${printProjectName(localProject)}`);
   let remoteProject;
   try {
     const { data } = await fetchProject(
@@ -2289,47 +2373,92 @@ async function handler(options8, logger) {
 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;
+    process.exit(1);
   }
-  const diffs = reportDiff(remoteProject, localProject, logger);
+  const locallyChangedWorkflows = await findLocallyChangedWorkflows(
+    ws,
+    localProject
+  );
+  const diffs = reportDiff(
+    localProject,
+    remoteProject,
+    locallyChangedWorkflows,
+    logger
+  );
   if (!diffs.length) {
     logger.success("Nothing to deploy");
-    return;
+    process.exit(0);
   }
-  const skipVersionTest = localProject.workflows.find((wf) => wf.history.length === 0) || remoteProject.workflows.find((wf) => wf.history.length === 0);
+  const skipVersionTest = remoteProject.workflows.find(
+    (wf) => wf.history.length === 0
+  );
   if (skipVersionTest) {
     logger.warn(
       "Skipping compatibility check as no local version history detected"
     );
-    logger.warn("Pushing these changes may overrite changes made to the app");
-  } else if (!localProject.canMergeInto(remoteProject)) {
-    if (!options8.force) {
-      logger.error(`Error: Projects have diverged!
+    logger.warn("Pushing these changes may overwrite changes made to the app");
+  } else {
+    const divergentWorkflows = hasRemoteDiverged(
+      localProject,
+      remoteProject,
+      locallyChangedWorkflows
+    );
+    if (divergentWorkflows) {
+      logger.warn(
+        `The following workflows have diverged: ${divergentWorkflows}`
+      );
+      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.
+  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;
+  Pass --force to override this error and deploy anyway.`);
+        process.exit(1);
+      } else {
+        logger.warn(
+          "Remote project has diverged from local project! Pushing anyway as -f passed"
+        );
+      }
     } else {
-      logger.warn(
-        "Remote project has not diverged from local project! Pushing anyway as -f passed"
+      logger.info(
+        "Remote project has not diverged from local project - it is safe to deploy \u{1F389}"
       );
     }
-  } 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
+    force: true,
+    onlyUpdated: true
+  });
+  return merged;
+};
+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);
+  const ws = new Workspace3(options8.workspace || ".");
+  const active = ws.getActiveProject();
+  const alias2 = options8.alias ?? active?.alias;
+  const localProject = await Project.from("fs", {
+    root: options8.workspace || ".",
+    alias: alias2,
+    name: options8.name
   });
+  if (options8.new) {
+    localProject.openfn = {
+      endpoint: config2.endpoint
+    };
+  }
+  logger.success(`Loaded local project ${printProjectName(localProject)}`);
+  const merged = options8.new ? localProject : await syncProjects(options8, config2, ws, localProject, logger);
   const state = merged.serialize("state", {
     format: "json"
   });
-  logger.debug("Converted merged local project to app state:");
+  logger.debug("Provisioner state ready to upload:");
   logger.debug(JSON.stringify(state, null, 2));
+  logger.debug();
   config2.endpoint ??= localProject.openfn?.endpoint;
   if (options8.dryRun) {
     logger.always("dryRun option set: skipping upload step");
@@ -2353,18 +2482,25 @@ Pass --force to override this error and deploy anyway.`);
       "state",
       result,
       {
-        endpoint: config2.endpoint
+        endpoint: config2.endpoint,
+        alias: alias2
       },
       merged.config
     );
+    updateForkedFrom(finalProject);
+    const configData = finalProject.generateConfig();
+    await writeFile6(
+      path10.resolve(options8.workspace, configData.path),
+      configData.content
+    );
     const finalOutputPath = getSerializePath(localProject, options8.workspace);
-    logger.debug("Updating local project at ", finalOutputPath);
-    await serialize(finalProject, finalOutputPath);
+    const fullFinalPath = await serialize(finalProject, finalOutputPath);
+    logger.debug("Updated local project at ", fullFinalPath);
+    logger.success("Updated project  at", config2.endpoint);
   }
-  logger.success("Updated project at", config2.endpoint);
 }
-var reportDiff = (local, remote, logger) => {
-  const diffs = remote.diff(local);
+var reportDiff = (local, remote, locallyChangedWorkflows, logger) => {
+  const diffs = remote.diff(local, locallyChangedWorkflows);
   if (diffs.length === 0) {
     logger.info("No workflow changes detected");
     return diffs;
@@ -2451,30 +2587,30 @@ function pickFirst(...args) {
 var handler_default6 = deployHandler;
 
 // src/docgen/handler.ts
-import { writeFile as writeFile6 } from "node:fs/promises";
+import { writeFile as writeFile7 } from "node:fs/promises";
 import { readFileSync, writeFileSync, mkdirSync, rmSync } from "node:fs";
-import path10 from "node:path";
+import path11 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(path10.dirname(filePath), { recursive: true });
-var generatePlaceholder = (path17) => {
-  writeFileSync(path17, `{ "loading": true, "timestamp": ${Date.now()}}`);
+var ensurePath = (filePath) => mkdirSync(path11.dirname(filePath), { recursive: true });
+var generatePlaceholder = (path18) => {
+  writeFileSync(path18, `{ "loading": true, "timestamp": ${Date.now()}}`);
 };
 var finish = (logger, resultPath) => {
   logger.success("Done! Docs can be found at:\n");
-  logger.print(`  ${path10.resolve(resultPath)}`);
+  logger.print(`  ${path11.resolve(resultPath)}`);
 };
-var generateDocs = async (specifier, path17, docgen, logger) => {
+var generateDocs = async (specifier, path18, docgen, logger) => {
   const result = await docgen(specifier);
-  await writeFile6(path17, JSON.stringify(result, null, 2));
-  finish(logger, path17);
-  return path17;
+  await writeFile7(path18, JSON.stringify(result, null, 2));
+  finish(logger, path18);
+  return path18;
 };
-var waitForDocs = async (docs, path17, logger, retryDuration = RETRY_DURATION) => {
+var waitForDocs = async (docs, path18, logger, retryDuration = RETRY_DURATION) => {
   try {
     if (docs.hasOwnProperty("loading")) {
       logger.info("Docs are being loaded by another process. Waiting.");
@@ -2486,19 +2622,19 @@ var waitForDocs = async (docs, path17, logger, retryDuration = RETRY_DURATION) =
             clearInterval(i);
             reject(new Error("Timed out waiting for docs to load"));
           }
-          const updated = JSON.parse(readFileSync(path17, "utf8"));
+          const updated = JSON.parse(readFileSync(path18, "utf8"));
           if (!updated.hasOwnProperty("loading")) {
             logger.info("Docs found!");
             clearInterval(i);
-            resolve(path17);
+            resolve(path18);
           }
           count++;
         }, retryDuration);
       });
     } else {
-      logger.info(`Docs already written to cache at ${path17}`);
-      finish(logger, path17);
-      return path17;
+      logger.info(`Docs already written to cache at ${path18}`);
+      finish(logger, path18);
+      return path18;
     }
   } catch (e) {
     logger.error("Existing doc JSON corrupt. Aborting");
@@ -2515,28 +2651,28 @@ var docgenHandler = (options8, logger, docgen = actualDocGen, retryDuration = RE
     process.exit(9);
   }
   logger.success(`Generating docs for ${specifier}`);
-  const path17 = `${repoDir}/docs/${specifier}.json`;
-  ensurePath(path17);
+  const path18 = `${repoDir}/docs/${specifier}.json`;
+  ensurePath(path18);
   const handleError2 = () => {
     logger.info("Removing placeholder");
-    rmSync(path17);
+    rmSync(path18);
   };
   try {
-    const existing = readFileSync(path17, "utf8");
+    const existing = readFileSync(path18, "utf8");
     const json = JSON.parse(existing);
     if (json && json.timeout && Date.now() - json.timeout >= TIMEOUT_MS) {
       logger.info(`Expired placeholder found. Removing.`);
-      rmSync(path17);
+      rmSync(path18);
       throw new Error("TIMEOUT");
     }
-    return waitForDocs(json, path17, logger, retryDuration);
+    return waitForDocs(json, path18, logger, retryDuration);
   } catch (e) {
     if (e.message !== "TIMEOUT") {
-      logger.info(`Docs JSON not found at ${path17}`);
+      logger.info(`Docs JSON not found at ${path18}`);
     }
     logger.debug("Generating placeholder");
-    generatePlaceholder(path17);
-    return generateDocs(specifier, path17, docgen, logger).catch((e2) => {
+    generatePlaceholder(path18);
+    return generateDocs(specifier, path18, docgen, logger).catch((e2) => {
       logger.error("Error generating documentation");
       logger.error(e2);
       handleError2();
@@ -2551,7 +2687,7 @@ import c3 from "chalk";
 import { getNameAndVersion as getNameAndVersion5, getLatestVersion } from "@openfn/runtime";
 var describeFn = (adaptorName, fn) => [
   c3.green(
-    `## ${fn.name}(${fn.parameters.map(({ name }) => name).join(",")})`
+    `## ${fn.name}(${fn.parameters.map(({ name: name2 }) => name2).join(",")})`
   ),
   `${fn.description}`,
   c3.green("### Usage Examples"),
@@ -2579,46 +2715,46 @@ var docsHandler = async (options8, logger) => {
   const { adaptor, operation, repoDir } = options8;
   const adaptors = expand_adaptors_default([adaptor]);
   const [adaptorName] = adaptors;
-  let { name, version } = getNameAndVersion5(adaptorName);
+  let { name: name2, version } = getNameAndVersion5(adaptorName);
   if (!version) {
     logger.info("No version number provided, looking for latest...");
-    version = await getLatestVersion(name);
+    version = await getLatestVersion(name2);
     logger.info("Found ", version);
     logger.success(`Showing docs for ${adaptorName} v${version}`);
   }
   logger.info("Generating/loading documentation...");
-  const path17 = await handler_default7(
+  const path18 = await handler_default7(
     {
-      specifier: `${name}@${version}`,
+      specifier: `${name2}@${version}`,
       repoDir
     },
     // TODO I'm not sure how to handle logging here - we ought to feedback SOMETHING though
     createNullLogger()
   );
   let didError = false;
-  if (path17) {
-    const source = await readFile5(path17, "utf8");
+  if (path18) {
+    const source = await readFile5(path18, "utf8");
     const data = JSON.parse(source);
     let desc;
     if (operation) {
-      const fn = data.functions.find(({ name: name2 }) => name2 === operation);
+      const fn = data.functions.find(({ name: name3 }) => name3 === operation);
       if (fn) {
         logger.debug("Operation schema:", fn);
         logger.break();
-        desc = describeFn(name, fn);
+        desc = describeFn(name2, fn);
       } else {
-        logger.error(`Failed to find ${operation} in ${name}`);
+        logger.error(`Failed to find ${operation} in ${name2}`);
       }
     } else {
       logger.debug("No operation name provided");
       logger.always("Available functions:\n");
-      desc = describeLib(name, data);
+      desc = describeLib(name2, data);
     }
     logger.print(desc);
     if (!operation) {
       logger.always(`For more details on a specfic functions, use:
     
-    openfn docs ${name} <fn>
+    openfn docs ${name2} <fn>
 `);
     }
     if (didError) {
@@ -2635,13 +2771,13 @@ var handler_default8 = docsHandler;
 // src/metadata/cache.ts
 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 path11 from "node:path";
+import { mkdir as mkdir4, readFile as readFile6, writeFile as writeFile8, readdir, rm } from "node:fs/promises";
+import path12 from "node:path";
 var UNSUPPORTED_FILE_NAME = "unsupported.json";
 var getCachePath2 = (repoDir, key) => {
-  const base = path11.join(repoDir, "meta");
+  const base = path12.join(repoDir, "meta");
   if (key) {
-    return path11.join(base, key.endsWith(".json") ? key : `${key}.json`);
+    return path12.join(base, key.endsWith(".json") ? key : `${key}.json`);
   }
   return base;
 };
@@ -2683,8 +2819,8 @@ var get2 = async (repoPath, key) => {
 };
 var set2 = async (repoPath, key, result) => {
   const p = getCachePath2(repoPath, key);
-  await mkdir4(path11.dirname(p), { recursive: true });
-  await writeFile7(p, JSON.stringify(result));
+  await mkdir4(path12.dirname(p), { recursive: true });
+  await writeFile8(p, JSON.stringify(result));
 };
 var getUnsupportedCachePath = (repoDir) => {
   return getCachePath2(repoDir, UNSUPPORTED_FILE_NAME);
@@ -2708,14 +2844,14 @@ var compareVersions = (version1, version2) => {
   return v1.patch - v2.patch;
 };
 var isAdaptorUnsupported = async (adaptorSpecifier, repoDir) => {
-  const { name, version } = getNameAndVersion6(adaptorSpecifier);
+  const { name: name2, version } = getNameAndVersion6(adaptorSpecifier);
   if (!version)
     return false;
   const cache = await getUnsupportedCache(repoDir);
-  if (!cache || !cache[name]) {
+  if (!cache || !cache[name2]) {
     return false;
   }
-  const cached = cache[name];
+  const cached = cache[name2];
   const currentParsed = parseVersion(version);
   const cachedParsed = parseVersion(cached.lastCheckedVersion);
   if (currentParsed.major > cachedParsed.major || currentParsed.major === cachedParsed.major && currentParsed.minor > cachedParsed.minor) {
@@ -2724,7 +2860,7 @@ var isAdaptorUnsupported = async (adaptorSpecifier, repoDir) => {
   return true;
 };
 var markAdaptorAsUnsupported = async (adaptorSpecifier, repoDir) => {
-  const { name, version } = getNameAndVersion6(adaptorSpecifier);
+  const { name: name2, version } = getNameAndVersion6(adaptorSpecifier);
   if (!version)
     return;
   const cachePath = getUnsupportedCachePath(repoDir);
@@ -2735,15 +2871,15 @@ var markAdaptorAsUnsupported = async (adaptorSpecifier, repoDir) => {
   } catch (error) {
   }
   const parsed = parseVersion(version);
-  const existing = cache[name];
+  const existing = cache[name2];
   if (!existing || compareVersions(version, existing.lastCheckedVersion) > 0) {
-    cache[name] = {
+    cache[name2] = {
       lastCheckedVersion: version,
       majorMinor: parsed.majorMinor,
       timestamp: Date.now()
     };
-    await mkdir4(path11.dirname(cachePath), { recursive: true });
-    await writeFile7(cachePath, JSON.stringify(cache, null, 2));
+    await mkdir4(path12.dirname(cachePath), { recursive: true });
+    await writeFile8(cachePath, JSON.stringify(cache, null, 2));
   }
 };
 
@@ -2864,7 +3000,7 @@ var metadataHandler = async (options8, logger) => {
 var handler_default9 = metadataHandler;
 
 // src/pull/handler.ts
-import path14 from "path";
+import path15 from "path";
 import fs5 from "node:fs/promises";
 import {
   getConfig as getConfig2,
@@ -2875,12 +3011,12 @@ import {
 } from "@openfn/deploy";
 
 // src/projects/pull.ts
-import { Workspace as Workspace4 } from "@openfn/project";
+import { Workspace as Workspace6 } from "@openfn/project";
 
 // src/projects/fetch.ts
-import path12 from "node:path";
-import Project2, { Workspace as Workspace2 } from "@openfn/project";
-import { writeFile as writeFile8 } from "node:fs/promises";
+import path13 from "node:path";
+import Project2, { Workspace as Workspace4 } from "@openfn/project";
+import { writeFile as writeFile9 } from "node:fs/promises";
 var options2 = [
   alias,
   apiKey,
@@ -2912,7 +3048,7 @@ var printProjectName2 = (project) => `${project.qname} (${project.id})`;
 var fetchV1 = async (options8, logger) => {
   const workspacePath = options8.workspace ?? process.cwd();
   logger.debug("Using workspace at", workspacePath);
-  const workspace2 = new Workspace2(workspacePath, logger, false);
+  const workspace2 = new Workspace4(workspacePath, logger, false);
   const localProject = workspace2.get(options8.project);
   if (localProject) {
     logger.debug(
@@ -2938,7 +3074,7 @@ var fetchV1 = async (options8, logger) => {
     options8.outputPath
   );
   logger.success(`Fetched project file to ${finalOutputPath}`);
-  await writeFile8(finalOutputPath, JSON.stringify(data, null, 2));
+  await writeFile9(finalOutputPath, JSON.stringify(data, null, 2));
   return data;
 };
 var handler2 = async (options8, logger) => {
@@ -2950,9 +3086,14 @@ var handler2 = async (options8, logger) => {
 var fetchV2 = async (options8, logger) => {
   const workspacePath = options8.workspace ?? process.cwd();
   logger.debug("Using workspace at", workspacePath);
-  const workspace2 = new Workspace2(workspacePath, logger, false);
+  const workspace2 = new Workspace4(workspacePath, logger, false);
   const { outputPath: outputPath2 } = options8;
   const remoteProject = await fetchRemoteProject(workspace2, options8, logger);
+  if (!options8.alias && remoteProject.sandbox?.parentId) {
+    options8.alias = remoteProject.id;
+    remoteProject.cli.alias = options8.alias;
+    logger.debug("Defaulting alias to sandbox id", options8.alias);
+  }
   if (!options8.force && options8.format !== "state") {
     const localTargetProject = await resolveOutputProject(
       workspace2,
@@ -2968,7 +3109,7 @@ var fetchV2 = async (options8, logger) => {
   );
   let format2 = options8.format;
   if (outputPath2) {
-    const ext = path12.extname(outputPath2).substring(1);
+    const ext = path13.extname(outputPath2).substring(1);
     if (ext.length) {
       format2 = ext;
     }
@@ -3036,7 +3177,7 @@ async function fetchRemoteProject(workspace2, options8, logger) {
     logger.debug(
       `Resolved ${options8.project} to UUID ${projectUUID} from local project ${printProjectName2(
         localProject
-      )}}`
+      )}`
     );
   }
   const projectEndpoint = localProject?.openfn?.endpoint ?? config2.endpoint;
@@ -3090,23 +3231,15 @@ To ignore this error and override the local file, pass --force (-f)
       delete error.stack;
       throw error;
     }
-    const hasAnyHistory = remoteProject.workflows.find(
-      (w) => w.workflow.history?.length
-    );
-    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");
-    }
   }
 }
 
 // src/projects/checkout.ts
-import Project3, { Workspace as Workspace3 } from "@openfn/project";
-import path13 from "path";
+import Project3, { Workspace as Workspace5 } from "@openfn/project";
+import path14 from "path";
 import fs4 from "fs";
 import { rimraf as rimraf2 } from "rimraf";
-var options3 = [log, workspace, clean2];
+var options3 = [log, workspace, clean2, force];
 var command3 = {
   command: "checkout <project>",
   describe: "Switch to a different OpenFn project in the same workspace",
@@ -3119,12 +3252,12 @@ var command3 = {
 var handler3 = async (options8, logger) => {
   const projectIdentifier = options8.project;
   const workspacePath = options8.workspace ?? process.cwd();
-  const workspace2 = new Workspace3(workspacePath, logger);
+  const workspace2 = new Workspace5(workspacePath, logger);
   const { project: _, ...config2 } = workspace2.getConfig();
   const currentProject = workspace2.getActiveProject();
   let switchProject;
   if (/\.(yaml|json)$/.test(projectIdentifier)) {
-    const filePath = projectIdentifier.startsWith("/") ? projectIdentifier : path13.join(workspacePath, projectIdentifier);
+    const filePath = projectIdentifier.startsWith("/") ? projectIdentifier : path14.join(workspacePath, projectIdentifier);
     logger.debug("Loading project from path ", filePath);
     switchProject = await Project3.from("path", filePath, config2);
   } else {
@@ -3135,18 +3268,51 @@ var handler3 = async (options8, logger) => {
       `Project with id ${projectIdentifier} not found in the workspace`
     );
   }
+  try {
+    const localProject = await Project3.from("fs", {
+      root: options8.workspace || "."
+    });
+    logger.success(`Loaded local project ${localProject.alias}`);
+    const changed = await findLocallyChangedWorkflows(
+      workspace2,
+      localProject,
+      "assume-ok"
+    );
+    if (changed.length && !options8.force) {
+      logger.break();
+      logger.warn(
+        "WARNING: detected changes on your currently checked-out project"
+      );
+      logger.warn(
+        `Changes may be lost by checking out ${localProject.alias} right now`
+      );
+      logger.warn(`Pass --force or -f to override this warning and continue`);
+      const e = new Error(
+        `The currently checked out project has diverged! Changes may be lost`
+      );
+      delete e.stack;
+      throw e;
+    }
+  } catch (e) {
+    if (e.message.match("ENOENT")) {
+      logger.debug("No openfn.yaml found locally: skipping divergence test");
+    } else {
+      throw e;
+    }
+  }
   if (options8.clean) {
     await rimraf2(workspace2.workflowsPath);
   } else {
     await tidyWorkflowDir(currentProject, switchProject);
   }
+  updateForkedFrom(switchProject);
   const files = switchProject.serialize("fs");
   for (const f in files) {
     if (files[f]) {
-      fs4.mkdirSync(path13.join(workspacePath, path13.dirname(f)), {
+      fs4.mkdirSync(path14.join(workspacePath, path14.dirname(f)), {
         recursive: true
       });
-      fs4.writeFileSync(path13.join(workspacePath, f), files[f]);
+      fs4.writeFileSync(path14.join(workspacePath, f), files[f]);
     } else {
       logger.warn("WARNING! No content for file", f);
     }
@@ -3193,7 +3359,7 @@ var ensureProjectId = (options8, logger) => {
     logger?.debug(
       "No project ID specified: looking up checked out project in Workspace"
     );
-    const ws = new Workspace4(options8.workspace);
+    const ws = new Workspace6(options8.workspace);
     if (ws.activeProject) {
       options8.project = ws.activeProject.uuid;
       logger?.info(
@@ -3266,7 +3432,7 @@ async function pullHandler(options8, logger) {
       process.exitCode = 1;
       process.exit(1);
     }
-    const resolvedPath = path14.resolve(config2.specPath);
+    const resolvedPath = path15.resolve(config2.specPath);
     logger.debug("reading spec from", resolvedPath);
     const updatedSpec = await syncRemoteSpec(
       await res.text(),
@@ -3275,7 +3441,7 @@ async function pullHandler(options8, logger) {
       logger
     );
     await fs5.writeFile(
-      path14.resolve(config2.statePath),
+      path15.resolve(config2.statePath),
       JSON.stringify(state, null, 2)
     );
     await fs5.writeFile(resolvedPath, updatedSpec);
@@ -3320,7 +3486,7 @@ __export(projects_exports, {
 });
 
 // src/projects/list.ts
-import { Workspace as Workspace5 } from "@openfn/project";
+import { Workspace as Workspace7 } from "@openfn/project";
 var options5 = [log, workspace];
 var command5 = {
   command: "list [project-path]",
@@ -3333,7 +3499,7 @@ var handler5 = async (options8, logger) => {
   logger.info("Searching for projects in workspace at:");
   logger.info(" ", options8.workspace);
   logger.break();
-  const workspace2 = new Workspace5(options8.workspace);
+  const workspace2 = new Workspace7(options8.workspace);
   if (!workspace2.valid) {
     throw new Error("No OpenFn projects found");
   }
@@ -3351,7 +3517,7 @@ ${project.workflows.map((w) => "    - " + w.id).join("\n")}`;
 }
 
 // src/projects/version.ts
-import { Workspace as Workspace6 } from "@openfn/project";
+import { Workspace as Workspace8 } from "@openfn/project";
 var options6 = [workflow, workspace, workflowMappings];
 var command6 = {
   command: "version [workflow]",
@@ -3360,7 +3526,7 @@ var command6 = {
   builder: (yargs) => build(options6, yargs)
 };
 var handler6 = async (options8, logger) => {
-  const workspace2 = new Workspace6(options8.workspace);
+  const workspace2 = new Workspace8(options8.workspace);
   if (!workspace2.valid) {
     logger.error("Command was run in an invalid openfn workspace");
     return;
@@ -3395,8 +3561,8 @@ ${final}`);
 };
 
 // src/projects/merge.ts
-import Project5, { Workspace as Workspace7 } from "@openfn/project";
-import path15 from "node:path";
+import Project5, { Workspace as Workspace9 } from "@openfn/project";
+import path16 from "node:path";
 import fs6 from "node:fs/promises";
 var options7 = [
   removeUnmapped,
@@ -3431,14 +3597,14 @@ var command7 = {
 };
 var handler7 = async (options8, logger) => {
   const workspacePath = options8.workspace;
-  const workspace2 = new Workspace7(workspacePath);
+  const workspace2 = new Workspace9(workspacePath);
   if (!workspace2.valid) {
     logger.error("Command was run in an invalid openfn workspace");
     return;
   }
   let targetProject;
   if (options8.base) {
-    const basePath = path15.resolve(options8.base);
+    const basePath = path16.resolve(options8.base);
     logger.debug("Loading target project from path", basePath);
     targetProject = await Project5.from("path", basePath);
   } else {
@@ -3452,7 +3618,7 @@ var handler7 = async (options8, logger) => {
   const sourceProjectIdentifier = options8.project;
   let sourceProject;
   if (/\.(ya?ml|json)$/.test(sourceProjectIdentifier)) {
-    const filePath = path15.join(workspacePath, sourceProjectIdentifier);
+    const filePath = path16.join(workspacePath, sourceProjectIdentifier);
     logger.debug("Loading source project from path ", filePath);
     sourceProject = await Project5.from("path", filePath);
   } else {
@@ -3515,7 +3681,7 @@ var handler7 = async (options8, logger) => {
 
 // src/util/print-versions.ts
 import { readFileSync as readFileSync2 } from "node:fs";
-import path16 from "node:path";
+import path17 from "node:path";
 import url from "node:url";
 import { getNameAndVersion as getNameAndVersion7 } from "@openfn/runtime";
 import { mainSymbols } from "figures";
@@ -3527,7 +3693,7 @@ var { triangleRightSmall: t } = mainSymbols;
 var loadVersionFromPath = (adaptorPath) => {
   try {
     const pkg = JSON.parse(
-      readFileSync2(path16.resolve(adaptorPath, "package.json"), "utf8")
+      readFileSync2(path17.resolve(adaptorPath, "package.json"), "utf8")
     );
     return pkg.version;
   } catch (e) {
@@ -3549,8 +3715,8 @@ var printVersions = async (logger, options8 = {}, includeComponents = false) =>
       adaptorName = getNameAndVersion7(adaptor).name;
       adaptorVersion = "monorepo";
     } else {
-      const { name, version: version2 } = getNameAndVersion7(adaptor);
-      adaptorName = name;
+      const { name: name2, version: version2 } = getNameAndVersion7(adaptor);
+      adaptorName = name2;
       adaptorVersion = version2 || "latest";
     }
     adaptorList.push([adaptorName, adaptorVersion]);
@@ -3562,7 +3728,7 @@ var printVersions = async (logger, options8 = {}, includeComponents = false) =>
     ...[NODE, CLI2, RUNTIME2, COMPILER2, longestAdaptorName].map((s) => s.length)
   );
   const prefix = (str) => `         ${t} ${str.padEnd(longest + 4, " ")}`;
-  const dirname3 = path16.dirname(url.fileURLToPath(import.meta.url));
+  const dirname3 = path17.dirname(url.fileURLToPath(import.meta.url));
   const pkg = JSON.parse(readFileSync2(`${dirname3}/../../package.json`, "utf8"));
   const { version, dependencies } = pkg;
   const compilerVersion = dependencies["@openfn/compiler"];
@@ -3580,8 +3746,8 @@ var printVersions = async (logger, options8 = {}, includeComponents = false) =>
       output.versions.compiler = compilerVersion;
     }
     if (adaptorList.length) {
-      for (const [name, version2] of adaptorList) {
-        output.versions[name] = version2;
+      for (const [name2, version2] of adaptorList) {
+        output.versions[name2] = version2;
       }
     }
   } else {
@@ -3594,9 +3760,9 @@ ${prefix(RUNTIME2)}${runtimeVersion}
 ${prefix(COMPILER2)}${compilerVersion}`;
     }
     if (adaptorList.length) {
-      for (const [name, version2] of adaptorList) {
+      for (const [name2, version2] of adaptorList) {
         output += `
-${prefix(name)}${version2}`;
+${prefix(name2)}${version2}`;
       }
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openfn/cli",
-  "version": "1.25.0",
+  "version": "1.27.0",
   "description": "CLI devtools for the OpenFn toolchain",
   "engines": {
     "node": ">=18",
@@ -50,13 +50,13 @@
     "undici": "7.12.0",
     "ws": "^8.18.3",
     "yargs": "^17.7.2",
-    "@openfn/describe-package": "0.1.5",
-    "@openfn/lexicon": "^1.4.0",
     "@openfn/compiler": "1.2.2",
     "@openfn/deploy": "0.11.5",
+    "@openfn/lexicon": "^1.4.1",
+    "@openfn/describe-package": "0.1.5",
     "@openfn/logger": "1.1.1",
-    "@openfn/project": "^0.12.1",
-    "@openfn/runtime": "1.8.3"
+    "@openfn/project": "^0.13.1",
+    "@openfn/runtime": "1.8.4"
   },
   "files": [
     "dist",