@openfn/cli 1.24.1 → 1.25.0

package/dist/index.js

@@ -368,7 +368,7 @@ var ignoreImports = {
   }
 };
 var getBaseDir = (opts2) => {
-  const basePath = opts2.path ?? ".";
+  const basePath = opts2.path ?? opts2.workspace ?? ".";
   if (/\.(jso?n?|ya?ml)$/.test(basePath)) {
     return nodePath.dirname(basePath);
   }
@@ -923,12 +923,27 @@ var alias = {
     description: "Environment name (eg staging, prod, branch)"
   }
 };
+var clean = {
+  name: "clean",
+  yargs: {
+    description: "Clean the working dir before checking out the new project",
+    default: false,
+    boolean: true
+  }
+};
 var dryRun2 = {
   name: "dryRun",
   yargs: {
     description: "Runs the command but does not commit any changes to disk or app"
   }
 };
+var format = {
+  name: "format",
+  yargs: {
+    hidden: true,
+    description: "The format to save the project as - state, yaml or json. Use this to download raw state files."
+  }
+};
 var removeUnmapped = {
   name: "remove-unmapped",
   yargs: {
@@ -1138,7 +1153,7 @@ var command_default9 = pullCommand;
 var repo = {
   command: "repo [subcommand]",
   describe: "Run commands on the module repo (install|clean)",
-  builder: (yargs2) => yargs2.command(clean).command(install).command(list).example("repo install -a http", "Install @openfn/language-http").example("repo clean", "Remove everything from the repo working dir")
+  builder: (yargs2) => yargs2.command(clean2).command(install).command(list).example("repo install -a http", "Install @openfn/language-http").example("repo clean", "Remove everything from the repo working dir")
 };
 var installOptions = [
   log,
@@ -1177,7 +1192,7 @@ var cleanOptions = [
     }
   }
 ];
-var clean = {
+var clean2 = {
   command: "clean",
   describe: "Removes all modules from the runtime module repo",
   handler: ensure("repo-clean", cleanOptions),
@@ -1229,14 +1244,19 @@ import Project3, { Workspace as Workspace4 } from "@openfn/project";
 
 // src/projects/checkout.ts
 import Project2, { Workspace as Workspace3 } from "@openfn/project";
+import { rimraf as rimraf2 } from "rimraf";
+
+// src/projects/util.ts
 import { rimraf } from "rimraf";
-var options11 = [log, workspace];
+
+// src/projects/checkout.ts
+var options11 = [log, workspace, clean];
 var command3 = {
   command: "checkout <project>",
   describe: "Switch to a different OpenFn project in the same workspace",
   handler: ensure("project-checkout", options11),
   builder: (yargs2) => build(options11, yargs2).positional("project", {
-    describe: "The id, alias or UUID of the project to chcekout",
+    describe: "The id, alias or UUID of the project to checkout",
     demandOption: true
   })
 };
@@ -1291,7 +1311,8 @@ var options13 = [
   }),
   outputPath2,
   env2,
-  workspace
+  workspace,
+  format
 ];
 var command5 = {
   command: "fetch [project]",
@@ -1307,6 +1328,7 @@ var command5 = {
 var fetch_default = command5;
 
 // src/projects/pull.ts
+import { Workspace as Workspace6 } from "@openfn/project";
 var options14 = [
   alias,
   env2,

package/dist/process/runner.js

@@ -190,22 +190,31 @@ 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, options8, stepId) => {
-  const { baseDir } = options8;
-  const { name } = plan.workflow;
-  const basePath = `${baseDir}/.cli-cache/${name}`;
+var CACHE_DIR = ".cli-cache";
+var getCachePath = (options8, workflowName, stepId) => {
+  const { baseDir, cachePath } = options8;
+  if (cachePath) {
+    if (stepId) {
+      return path2.resolve(cachePath, `${stepId.replace(/ /, "-")}.json`);
+    }
+    return path2.resolve(cachePath);
+  }
+  const basePath = path2.resolve(
+    baseDir ?? process.cwd(),
+    `${CACHE_DIR}/${workflowName}`
+  );
   if (stepId) {
-    return path2.resolve(`${basePath}/${stepId.replace(/ /, "-")}.json`);
+    return `${basePath}/${stepId.replace(/ /, "-")}.json`;
   }
-  return path2.resolve(basePath);
+  return basePath;
 };
-var ensureGitIgnore = (options8) => {
+var ensureGitIgnore = (options8, cachePath) => {
   if (!options8._hasGitIgnore) {
-    const ignorePath = path2.resolve(
-      options8.baseDir,
-      ".cli-cache",
-      ".gitignore"
-    );
+    let root = cachePath;
+    while (root.length > 1 && !root.endsWith(CACHE_DIR)) {
+      root = path2.dirname(root);
+    }
+    const ignorePath = path2.resolve(root, ".gitignore");
     try {
       fs.accessSync(ignorePath);
     } catch (e) {
@@ -216,15 +225,15 @@ var ensureGitIgnore = (options8) => {
 };
 var saveToCache = async (plan, stepId, output, options8, logger) => {
   if (options8.cacheSteps) {
-    const cachePath = await getCachePath(plan, options8, stepId);
+    const cachePath = await getCachePath(options8, plan.workflow.name, stepId);
     fs.mkdirSync(path2.dirname(cachePath), { recursive: true });
-    ensureGitIgnore(options8);
+    ensureGitIgnore(options8, path2.dirname(cachePath));
     logger.info(`Writing ${stepId} output to ${cachePath}`);
     fs.writeFileSync(cachePath, JSON.stringify(output));
   }
 };
 var clearCache = async (plan, options8, logger) => {
-  const cacheDir = await getCachePath(plan, options8);
+  const cacheDir = await getCachePath(options8, plan.workflow?.name);
   try {
     await rmdir(cacheDir, { recursive: true });
     logger.info(`Cleared cache at ${cacheDir}`);
@@ -685,7 +694,11 @@ var load_state_default = async (plan, opts, log2, start) => {
       const upstreamStepId = getUpstreamStepId(plan, start);
       if (upstreamStepId) {
         log2.debug(`Input step for "${start}" is "${upstreamStepId}"`);
-        const cachedStatePath = await getCachePath(plan, opts, upstreamStepId);
+        const cachedStatePath = await getCachePath(
+          opts,
+          plan.workflow.name,
+          upstreamStepId
+        );
         log2.debug("Loading cached state from", cachedStatePath);
         try {
           await fs2.access(cachedStatePath);
@@ -857,6 +870,7 @@ var loadPlan = async (options8, logger) => {
     };
     options8.credentials ??= workspace2.getConfig().credentials;
     options8.collectionsEndpoint ??= proj.openfn?.endpoint;
+    options8.cachePath ??= workspace2.workflowsPath + `/${name}/${CACHE_DIR}`;
   }
   if (options8.path && /ya?ml$/.test(options8.path)) {
     const content = await fs3.readFile(path4.resolve(options8.path), "utf-8");
@@ -886,7 +900,10 @@ var loadPlan = async (options8, logger) => {
       defaultName
     );
   } else {
-    return loadXPlan({ workflow: workflowObj }, options8, logger, defaultName);
+    const { id, start, options: o, ...w } = workflowObj;
+    const opts = { ...o, start };
+    const plan = { id, workflow: w, options: opts };
+    return loadXPlan(plan, options8, logger, defaultName);
   }
 };
 var load_plan_default = loadPlan;
@@ -1370,7 +1387,10 @@ var executeHandler = async (options8, logger) => {
     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)"
+        `Cached output written to ${getCachePath(
+          options8,
+          plan.workflow.name
+        )} (see info logs for details)`
       );
     }
     await serialize_output_default(options8, result, logger);
@@ -1956,12 +1976,27 @@ var alias = {
     description: "Environment name (eg staging, prod, branch)"
   }
 };
+var clean2 = {
+  name: "clean",
+  yargs: {
+    description: "Clean the working dir before checking out the new project",
+    default: false,
+    boolean: true
+  }
+};
 var dryRun = {
   name: "dryRun",
   yargs: {
     description: "Runs the command but does not commit any changes to disk or app"
   }
 };
+var format = {
+  name: "format",
+  yargs: {
+    hidden: true,
+    description: "The format to save the project as - state, yaml or json. Use this to download raw state files."
+  }
+};
 var removeUnmapped = {
   name: "remove-unmapped",
   yargs: {
@@ -2013,6 +2048,7 @@ var CLIError = class extends Error {
 };
 
 // src/projects/util.ts
+import { rimraf } from "rimraf";
 var loadAppAuthConfig = (options8, logger) => {
   const { OPENFN_API_KEY, OPENFN_ENDPOINT } = process.env;
   const config2 = {
@@ -2036,22 +2072,22 @@ var ensureExt = (filePath, ext) => {
   return filePath;
 };
 var getSerializePath = (project, workspacePath, outputPath2) => {
-  const outputRoot = resolve_path_default(outputPath2 || workspacePath);
+  const outputRoot = resolve_path_default(outputPath2 || workspacePath || ".");
   const projectsDir = project?.config.dirs.projects ?? ".projects";
-  return outputPath2 ?? `${outputRoot}/${projectsDir}/${project.qname}`;
+  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 format2 = formatOverride ?? project.config?.formats.project;
+  const output = format2 === "state" ? project?.serialize("state", { format: "json" }) : project?.serialize("project", { format: format2 });
   const maybeWriteFile = (filePath, output2) => {
     if (!dryRun2) {
       return writeFile5(filePath, output2);
     }
   };
   let finalPath;
-  if (format === "yaml") {
+  if (format2 === "yaml") {
     finalPath = ensureExt(outputPath2, "yaml");
     await maybeWriteFile(finalPath, output);
   } else {
@@ -2132,6 +2168,23 @@ var DeployError = class extends Error {
     super(message);
   }
 };
+async function tidyWorkflowDir(currentProject, incomingProject, dryRun2 = false) {
+  if (!currentProject || !incomingProject) {
+    return [];
+  }
+  const currentFiles = currentProject.serialize("fs");
+  const newFiles = incomingProject.serialize("fs");
+  const toRemove = [];
+  for (const path17 in currentFiles) {
+    if (!newFiles[path17]) {
+      toRemove.push(path17);
+    }
+  }
+  if (!dryRun2) {
+    await rimraf(toRemove);
+  }
+  return toRemove.sort();
+}
 
 // src/util/command-builders.ts
 import c from "chalk";
@@ -2243,7 +2296,13 @@ Pass --force to override this error and deploy anyway.`);
     logger.success("Nothing to deploy");
     return;
   }
-  if (!localProject.canMergeInto(remoteProject)) {
+  const skipVersionTest = localProject.workflows.find((wf) => wf.history.length === 0) || 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!
 
@@ -2815,9 +2874,13 @@ import {
   syncRemoteSpec
 } from "@openfn/deploy";
 
+// src/projects/pull.ts
+import { Workspace as Workspace4 } 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";
 var options2 = [
   alias,
   apiKey,
@@ -2831,7 +2894,8 @@ var options2 = [
   }),
   outputPath,
   env,
-  workspace
+  workspace,
+  format
 ];
 var command2 = {
   command: "fetch [project]",
@@ -2845,28 +2909,68 @@ var command2 = {
   handler: ensure("project-fetch", options2)
 };
 var printProjectName2 = (project) => `${project.qname} (${project.id})`;
-var handler2 = async (options8, logger) => {
+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 { outputPath: outputPath2 } = options8;
-  const localTargetProject = await resolveOutputProject(
-    workspace2,
-    options8,
+  const localProject = workspace2.get(options8.project);
+  if (localProject) {
+    logger.debug(
+      `Resolved "${options8.project}" to local project ${printProjectName2(
+        localProject
+      )}`
+    );
+  } else {
+    logger.debug(
+      `Failed to resolve "${options8.project}" to local project. Will send request to app anyway.`
+    );
+  }
+  const config2 = loadAppAuthConfig(options8, logger);
+  const { data } = await fetchProject(
+    options8.endpoint ?? localProject?.openfn?.endpoint,
+    config2.apiKey,
+    localProject?.uuid ?? options8.project,
     logger
   );
+  const finalOutputPath = getSerializePath(
+    localProject,
+    options8.workspace,
+    options8.outputPath
+  );
+  logger.success(`Fetched project file to ${finalOutputPath}`);
+  await writeFile8(finalOutputPath, JSON.stringify(data, null, 2));
+  return data;
+};
+var handler2 = async (options8, logger) => {
+  if (options8.format === "state") {
+    return fetchV1(options8, logger);
+  }
+  return fetchV2(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 { outputPath: outputPath2 } = options8;
   const remoteProject = await fetchRemoteProject(workspace2, options8, logger);
-  ensureTargetCompatible(options8, remoteProject, localTargetProject);
+  if (!options8.force && options8.format !== "state") {
+    const localTargetProject = await resolveOutputProject(
+      workspace2,
+      options8,
+      logger
+    );
+    ensureTargetCompatible(options8, remoteProject, localTargetProject);
+  }
   const finalOutputPath = getSerializePath(
     remoteProject,
     workspacePath,
     outputPath2
   );
-  let format = void 0;
+  let format2 = options8.format;
   if (outputPath2) {
     const ext = path12.extname(outputPath2).substring(1);
     if (ext.length) {
-      format = ext;
+      format2 = ext;
     }
     if (options8.alias) {
       logger.warn(
@@ -2874,10 +2978,12 @@ var handler2 = async (options8, logger) => {
       );
     }
   }
-  await serialize(remoteProject, finalOutputPath, format);
-  logger.success(
-    `Fetched project file to ${finalOutputPath}.${format ?? "yaml"}`
+  const finalPathWithExt = await serialize(
+    remoteProject,
+    finalOutputPath,
+    format2
   );
+  logger.success(`Fetched project file to ${finalPathWithExt}`);
   return remoteProject;
 };
 async function resolveOutputProject(workspace2, options8, logger) {
@@ -2999,14 +3105,14 @@ To ignore this error and override the local file, pass --force (-f)
 import Project3, { Workspace as Workspace3 } from "@openfn/project";
 import path13 from "path";
 import fs4 from "fs";
-import { rimraf } from "rimraf";
-var options3 = [log, workspace];
+import { rimraf as rimraf2 } from "rimraf";
+var options3 = [log, workspace, clean2];
 var command3 = {
   command: "checkout <project>",
   describe: "Switch to a different OpenFn project in the same workspace",
   handler: ensure("project-checkout", options3),
   builder: (yargs) => build(options3, yargs).positional("project", {
-    describe: "The id, alias or UUID of the project to chcekout",
+    describe: "The id, alias or UUID of the project to checkout",
     demandOption: true
   })
 };
@@ -3015,6 +3121,7 @@ var handler3 = async (options8, logger) => {
   const workspacePath = options8.workspace ?? process.cwd();
   const workspace2 = new Workspace3(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);
@@ -3028,7 +3135,11 @@ var handler3 = async (options8, logger) => {
       `Project with id ${projectIdentifier} not found in the workspace`
     );
   }
-  await rimraf(path13.join(workspacePath, config2.workflowRoot ?? "workflows"));
+  if (options8.clean) {
+    await rimraf2(workspace2.workflowsPath);
+  } else {
+    await tidyWorkflowDir(currentProject, switchProject);
+  }
   const files = switchProject.serialize("fs");
   for (const f in files) {
     if (files[f]) {
@@ -3071,11 +3182,30 @@ var command4 = {
   handler: ensure("project-pull", options4)
 };
 async function handler4(options8, logger) {
+  ensureProjectId(options8, logger);
   await handler2(options8, logger);
   logger.success(`Downloaded latest project version`);
   await handler3(options8, logger);
   logger.success(`Checked out project locally`);
 }
+var ensureProjectId = (options8, logger) => {
+  if (!options8.project) {
+    logger?.debug(
+      "No project ID specified: looking up checked out project in Workspace"
+    );
+    const ws = new Workspace4(options8.workspace);
+    if (ws.activeProject) {
+      options8.project = ws.activeProject.uuid;
+      logger?.info(
+        `Project id not provided: will default to ${options8.project}`
+      );
+    } else {
+      throw new Error(
+        "Project not provided: specify a project UUID, id or alias"
+      );
+    }
+  }
+};
 var pull_default = handler4;
 
 // src/pull/handler.ts
@@ -3190,7 +3320,7 @@ __export(projects_exports, {
 });
 
 // src/projects/list.ts
-import { Workspace as Workspace4 } from "@openfn/project";
+import { Workspace as Workspace5 } from "@openfn/project";
 var options5 = [log, workspace];
 var command5 = {
   command: "list [project-path]",
@@ -3203,7 +3333,7 @@ var handler5 = async (options8, logger) => {
   logger.info("Searching for projects in workspace at:");
   logger.info(" ", options8.workspace);
   logger.break();
-  const workspace2 = new Workspace4(options8.workspace);
+  const workspace2 = new Workspace5(options8.workspace);
   if (!workspace2.valid) {
     throw new Error("No OpenFn projects found");
   }
@@ -3221,7 +3351,7 @@ ${project.workflows.map((w) => "    - " + w.id).join("\n")}`;
 }
 
 // src/projects/version.ts
-import { Workspace as Workspace5 } from "@openfn/project";
+import { Workspace as Workspace6 } from "@openfn/project";
 var options6 = [workflow, workspace, workflowMappings];
 var command6 = {
   command: "version [workflow]",
@@ -3230,7 +3360,7 @@ var command6 = {
   builder: (yargs) => build(options6, yargs)
 };
 var handler6 = async (options8, logger) => {
-  const workspace2 = new Workspace5(options8.workspace);
+  const workspace2 = new Workspace6(options8.workspace);
   if (!workspace2.valid) {
     logger.error("Command was run in an invalid openfn workspace");
     return;
@@ -3265,7 +3395,7 @@ ${final}`);
 };
 
 // src/projects/merge.ts
-import Project5, { Workspace as Workspace6 } from "@openfn/project";
+import Project5, { Workspace as Workspace7 } from "@openfn/project";
 import path15 from "node:path";
 import fs6 from "node:fs/promises";
 var options7 = [
@@ -3301,7 +3431,7 @@ var command7 = {
 };
 var handler7 = async (options8, logger) => {
   const workspacePath = options8.workspace;
-  const workspace2 = new Workspace6(workspacePath);
+  const workspace2 = new Workspace7(workspacePath);
   if (!workspace2.valid) {
     logger.error("Command was run in an invalid openfn workspace");
     return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openfn/cli",
-  "version": "1.24.1",
+  "version": "1.25.0",
   "description": "CLI devtools for the OpenFn toolchain",
   "engines": {
     "node": ">=18",
@@ -33,6 +33,7 @@
     "@types/ws": "^8.18.1",
     "@types/yargs": "^17.0.33",
     "ava": "5.3.1",
+    "lodash-es": "^4.17.21",
     "mock-fs": "^5.5.0",
     "tslib": "^2.8.1",
     "tsup": "^7.2.0",
@@ -52,10 +53,10 @@
     "@openfn/describe-package": "0.1.5",
     "@openfn/lexicon": "^1.4.0",
     "@openfn/compiler": "1.2.2",
-    "@openfn/logger": "1.1.1",
     "@openfn/deploy": "0.11.5",
-    "@openfn/project": "^0.12.0",
-    "@openfn/runtime": "1.8.2"
+    "@openfn/logger": "1.1.1",
+    "@openfn/project": "^0.12.1",
+    "@openfn/runtime": "1.8.3"
   },
   "files": [
     "dist",