@openfn/cli 1.11.5 → 1.12.0

package/dist/index.js

@@ -33,7 +33,7 @@ import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
 
 // src/options.ts
-import path2 from "node:path";
+import nodePath from "node:path";
 
 // src/constants.ts
 var DEFAULT_REPO_DIR = "/tmp/openfn/repo";
@@ -171,6 +171,13 @@ var autoinstall = {
     default: true
   }
 };
+var apikey = {
+  name: "apikey",
+  yargs: {
+    alias: ["key", "pat", "token"],
+    description: "[beta only] API Key, Personal Access Token (Pat), or other access token"
+  }
+};
 var apolloUrl = {
   name: "apollo-url",
   yargs: {
@@ -194,6 +201,14 @@ var apolloUrl = {
     });
   }
 };
+var beta = {
+  name: "beta",
+  yargs: {
+    boolean: true,
+    description: "Use the beta alternative of this command: see https://github.com/OpenFn/kit/wiki/Pull-Deploy-Beta",
+    default: false
+  }
+};
 var cacheSteps = {
   name: "cache-steps",
   yargs: {
@@ -254,6 +269,19 @@ var expandAdaptors = {
     setDefaultValue(opts2, "expandAdaptors", true);
   }
 };
+var endpoint = {
+  name: "endpoint",
+  yargs: {
+    alias: ["lightning"],
+    description: "[beta only] URL to Lightning endpoint"
+  }
+};
+var env = {
+  name: "env",
+  yargs: {
+    description: "[beta only] Environment name (eg staging, prod, branch)"
+  }
+};
 var force = {
   name: "force",
   yargs: {
@@ -285,7 +313,7 @@ var ignoreImports = {
 var getBaseDir = (opts2) => {
   const basePath = opts2.path ?? ".";
   if (/\.(jso?n?)$/.test(basePath)) {
-    return path2.dirname(basePath);
+    return nodePath.dirname(basePath);
   }
   return basePath;
 };
@@ -302,7 +330,7 @@ var inputPath = {
       opts2.expressionPath = basePath;
     } else {
       const base = getBaseDir(opts2);
-      setDefaultValue(opts2, "expressionPath", path2.join(base, "job.js"));
+      setDefaultValue(opts2, "expressionPath", nodePath.join(base, "job.js"));
     }
   }
 };
@@ -351,7 +379,7 @@ var outputPath = {
         delete opts2.outputPath;
       } else {
         const base = getBaseDir(opts2);
-        setDefaultValue(opts2, "outputPath", path2.join(base, "output.json"));
+        setDefaultValue(opts2, "outputPath", nodePath.join(base, "output.json"));
       }
     }
     delete opts2.o;
@@ -365,6 +393,12 @@ var projectPath = {
     description: "The location of your project.yaml file"
   }
 };
+var path2 = {
+  name: "path",
+  yargs: {
+    description: "Path"
+  }
+};
 var repoDir = {
   name: "repo-dir",
   yargs: () => ({
@@ -475,6 +509,13 @@ var sanitize = {
     throw new Error(err);
   }
 };
+var workflow = {
+  name: "workflow",
+  yargs: {
+    string: true,
+    description: "Name of the workflow to execute"
+  }
+};
 
 // src/util/command-builders.ts
 import c from "chalk";
@@ -752,7 +793,8 @@ var options2 = [
   }),
   outputPath,
   repoDir,
-  useAdaptorsMonorepo
+  useAdaptorsMonorepo,
+  workflow
 ];
 var compileCommand = {
   command: "compile [path]",
@@ -773,6 +815,7 @@ var command_default3 = compileCommand;
 
 // src/deploy/command.ts
 var options3 = [
+  beta,
   configPath,
   confirm,
   describe,
@@ -841,7 +884,7 @@ var options5 = [
   useAdaptorsMonorepo
 ];
 var executeCommand = {
-  command: "execute [path]",
+  command: "execute <path> [workflow]",
   describe: `Run an openfn expression or workflow. Get more help by running openfn <command> help.
   
 Execute will run a expression/workflow at the path and write the output state to disk (to ./state.json unless otherwise specified)
@@ -892,16 +935,25 @@ var command_default8 = {
 
 // src/pull/command.ts
 var options7 = [
-  statePath,
-  projectPath,
+  apikey,
+  beta,
+  beta,
   configPath,
+  endpoint,
+  env,
   log,
+  override(path2, {
+    description: "path to output the project to"
+  }),
   logJson,
-  snapshots
+  projectPath,
+  snapshots,
+  statePath,
+  path2
 ];
 var pullCommand = {
   command: "pull [projectId]",
-  describe: "Pull a project's state and spec from a Lightning Instance to the local directory",
+  describe: `Pull a project's state and spec from a Lightning Instance to the local directory. Pass --beta to use the experimental new pull command. See https://github.com/OpenFn/kit/wiki/Pull-Deploy-Beta for docs`,
   builder: (yargs2) => build(options7, yargs2).positional("projectId", {
     describe: "The id of the project that should be pulled shouled be a UUID",
     demandOption: true

package/dist/process/runner.js

@@ -124,14 +124,14 @@ var callApollo = async (apolloBaseUrl, serviceName, payload, logger) => {
     });
   });
 };
-var loadPayload = async (logger, path11) => {
-  if (!path11) {
+var loadPayload = async (logger, path12) => {
+  if (!path12) {
     logger.warn("No JSON payload provided");
     logger.warn("Most apollo services require JSON to be uploaded");
     return {};
   }
-  if (path11.endsWith(".json")) {
-    const str = await readFile(path11, "utf8");
+  if (path12.endsWith(".json")) {
+    const str = await readFile(path12, "utf8");
     const json = JSON.parse(str);
     logger.debug("Loaded JSON payload");
     return json;
@@ -253,13 +253,13 @@ var execute_default = async (plan, input, opts, logger) => {
 };
 function parseAdaptors(plan) {
   const extractInfo = (specifier) => {
-    const [module, path11] = specifier.split("=");
+    const [module, path12] = specifier.split("=");
     const { name, version } = getNameAndVersion(module);
     const info = {
       name
     };
-    if (path11) {
-      info.path = path11;
+    if (path12) {
+      info.path = path12;
     }
     if (version) {
       info.version = version;
@@ -278,7 +278,8 @@ function parseAdaptors(plan) {
 }
 
 // src/execute/serialize-output.ts
-import { writeFile as writeFile2 } from "node:fs/promises";
+import { mkdir as mkdir2, writeFile as writeFile2 } from "node:fs/promises";
+import { dirname } from "node:path";
 var serializeOutput2 = async (options, result, logger) => {
   let output = result;
   if (output && (output.configuration || output.data)) {
@@ -294,6 +295,7 @@ var serializeOutput2 = async (options, result, logger) => {
     logger.success(`Result: `);
     logger.always(output);
   } else if (options.outputPath) {
+    await mkdir2(dirname(options.outputPath), { recursive: true });
     logger.debug(`Writing output to ${options.outputPath}`);
     await writeFile2(options.outputPath, output);
     logger.success(`State written to ${options.outputPath}`);
@@ -484,10 +486,10 @@ var stripVersionSpecifier = (specifier) => {
   return specifier;
 };
 var resolveSpecifierPath = async (pattern, repoDir, log) => {
-  const [specifier, path11] = pattern.split("=");
-  if (path11) {
-    log.debug(`Resolved ${specifier} to path: ${path11}`);
-    return path11;
+  const [specifier, path12] = pattern.split("=");
+  if (path12) {
+    log.debug(`Resolved ${specifier} to path: ${path12}`);
+    return path12;
   }
   const repoPath = await getModulePath(specifier, repoDir, log);
   if (repoPath) {
@@ -505,12 +507,12 @@ var loadTransformOptions = async (opts, log) => {
       let exports;
       const [specifier] = adaptorInput.split("=");
       log.debug(`Trying to preload types for ${specifier}`);
-      const path11 = await resolveSpecifierPath(adaptorInput, opts.repoDir, log);
-      if (path11) {
+      const path12 = await resolveSpecifierPath(adaptorInput, opts.repoDir, log);
+      if (path12) {
         try {
-          exports = await preloadAdaptorExports(path11, log);
+          exports = await preloadAdaptorExports(path12, log);
         } catch (e) {
-          log.error(`Failed to load adaptor typedefs from path ${path11}`);
+          log.error(`Failed to load adaptor typedefs from path ${path12}`);
           log.error(e);
         }
       }
@@ -625,7 +627,7 @@ var validateAdaptors = async (options, logger) => {
   if (options.skipAdaptorValidation) {
     return;
   }
-  const isPlan = options.planPath || options.workflowPath;
+  const isPlan = options.planPath || options.workflowPath || options.workflow;
   const hasDeclaredAdaptors = options.adaptors && options.adaptors.length > 0;
   if (isPlan && hasDeclaredAdaptors) {
     logger.error("ERROR: adaptor and workflow provided");
@@ -648,8 +650,9 @@ var validate_adaptors_default = validateAdaptors;
 
 // src/util/load-plan.ts
 import fs3 from "node:fs/promises";
-import path4 from "node:path";
+import path4, { dirname as dirname2 } from "node:path";
 import { isPath } from "@openfn/compiler";
+import Project, { yamlToJson } from "@openfn/project";
 
 // src/util/expand-adaptors.ts
 var expand = (name) => {
@@ -730,6 +733,20 @@ var map_adaptors_to_monorepo_default = mapAdaptorsToMonorepo;
 // src/util/load-plan.ts
 var loadPlan = async (options, logger) => {
   const { workflowPath, planPath, expressionPath } = options;
+  if (options.path && /ya?ml$/.test(options.path)) {
+    const content = await fs3.readFile(path4.resolve(options.path), "utf-8");
+    const workflow = yamlToJson(content);
+    options.baseDir = dirname2(options.path);
+    return loadXPlan({ workflow }, options, logger);
+  }
+  if (options.path && options.workflow) {
+    options.baseDir = options.path;
+    return fromProject(options.path, options.workflow, options, logger);
+  }
+  if (!expressionPath && !workflowPath && !/\.(js|json|yaml)+$/.test(options.path || "") && !options.workflow) {
+    const workflow = options.path;
+    return fromProject(path4.resolve("."), workflow, options, logger);
+  }
   if (expressionPath) {
     return loadExpression(options, logger);
   }
@@ -746,6 +763,16 @@ var loadPlan = async (options, logger) => {
   }
 };
 var load_plan_default = loadPlan;
+var fromProject = async (rootDir, workflowName, options, logger) => {
+  logger.debug("Loading Repo from ", path4.resolve(rootDir));
+  const project = await Project.from("fs", { root: rootDir });
+  logger.debug("Loading workflow ", workflowName);
+  const workflow = project.getWorkflow(workflowName);
+  if (!workflow) {
+    throw new Error(`Workflow "${workflowName}" not found`);
+  }
+  return loadXPlan({ workflow }, options, logger);
+};
 var loadJson = async (workflowPath, logger) => {
   let text;
   try {
@@ -913,8 +940,8 @@ var loadXPlan = async (plan, options, logger, defaultName = "") => {
 };
 
 // src/util/assert-path.ts
-var assert_path_default = (path11) => {
-  if (!path11) {
+var assert_path_default = (path12) => {
+  if (!path12) {
     console.error("ERROR: no path provided!");
     console.error("\nUsage:");
     console.error("  open path/to/job");
@@ -975,7 +1002,8 @@ var assertStepStructure = (step, index) => {
     "expression",
     "state",
     "configuration",
-    "linker"
+    "linker",
+    "openfn"
   ];
   for (const key in step) {
     if (!allowedKeys.includes(key)) {
@@ -1512,8 +1540,36 @@ import {
   getConfig,
   validateConfig
 } from "@openfn/deploy";
+
+// src/deploy/beta.ts
+import Project2 from "@openfn/project";
+import { deployProject } from "@openfn/deploy";
+async function handler(options, logger) {
+  const { OPENFN_API_KEY } = process.env;
+  const { endpoint } = options;
+  const config = {
+    apiKey: options.apiKey
+  };
+  if (!options.apiKey && OPENFN_API_KEY) {
+    logger.info("Using OPENFN_API_KEY environment variable");
+    config.apiKey = OPENFN_API_KEY;
+  }
+  const project = await Project2.from("fs", { root: options.path || "." });
+  const state = project.serialize("state", { format: "json" });
+  logger.debug("Converted local project to app state:");
+  logger.debug(JSON.stringify(state, null, 2));
+  config.endpoint = endpoint || project.openfn?.endpoint;
+  logger.info("Sending project to app...");
+  await deployProject(config, state);
+  logger.success("Updated project at", config.endpoint);
+}
+
+// src/deploy/handler.ts
 var actualDeploy = deploy;
 async function deployHandler(options, logger, deployFn = actualDeploy) {
+  if (options.beta) {
+    return handler(options, logger);
+  }
   try {
     const config = mergeOverrides(await getConfig(options.configPath), options);
     logger.debug("Deploying with config", JSON.stringify(config, null, 2));
@@ -1570,20 +1626,20 @@ var RETRY_COUNT = 20;
 var TIMEOUT_MS = 1e3 * 60;
 var actualDocGen = (specifier) => describePackage(specifier, {});
 var ensurePath = (filePath) => mkdirSync(path7.dirname(filePath), { recursive: true });
-var generatePlaceholder = (path11) => {
-  writeFileSync(path11, `{ "loading": true, "timestamp": ${Date.now()}}`);
+var generatePlaceholder = (path12) => {
+  writeFileSync(path12, `{ "loading": true, "timestamp": ${Date.now()}}`);
 };
 var finish = (logger, resultPath) => {
   logger.success("Done! Docs can be found at:\n");
   logger.print(`  ${path7.resolve(resultPath)}`);
 };
-var generateDocs = async (specifier, path11, docgen, logger) => {
+var generateDocs = async (specifier, path12, docgen, logger) => {
   const result = await docgen(specifier);
-  await writeFile5(path11, JSON.stringify(result, null, 2));
-  finish(logger, path11);
-  return path11;
+  await writeFile5(path12, JSON.stringify(result, null, 2));
+  finish(logger, path12);
+  return path12;
 };
-var waitForDocs = async (docs, path11, logger, retryDuration = RETRY_DURATION) => {
+var waitForDocs = async (docs, path12, logger, retryDuration = RETRY_DURATION) => {
   try {
     if (docs.hasOwnProperty("loading")) {
       logger.info("Docs are being loaded by another process. Waiting.");
@@ -1595,19 +1651,19 @@ var waitForDocs = async (docs, path11, logger, retryDuration = RETRY_DURATION) =
             clearInterval(i);
             reject(new Error("Timed out waiting for docs to load"));
           }
-          const updated = JSON.parse(readFileSync(path11, "utf8"));
+          const updated = JSON.parse(readFileSync(path12, "utf8"));
           if (!updated.hasOwnProperty("loading")) {
             logger.info("Docs found!");
             clearInterval(i);
-            resolve(path11);
+            resolve(path12);
           }
           count++;
         }, retryDuration);
       });
     } else {
-      logger.info(`Docs already written to cache at ${path11}`);
-      finish(logger, path11);
-      return path11;
+      logger.info(`Docs already written to cache at ${path12}`);
+      finish(logger, path12);
+      return path12;
     }
   } catch (e) {
     logger.error("Existing doc JSON corrupt. Aborting");
@@ -1624,28 +1680,28 @@ var docgenHandler = (options, logger, docgen = actualDocGen, retryDuration = RET
     process.exit(9);
   }
   logger.success(`Generating docs for ${specifier}`);
-  const path11 = `${repoDir}/docs/${specifier}.json`;
-  ensurePath(path11);
+  const path12 = `${repoDir}/docs/${specifier}.json`;
+  ensurePath(path12);
   const handleError2 = () => {
     logger.info("Removing placeholder");
-    rmSync(path11);
+    rmSync(path12);
   };
   try {
-    const existing = readFileSync(path11, "utf8");
+    const existing = readFileSync(path12, "utf8");
     const json = JSON.parse(existing);
     if (json && json.timeout && Date.now() - json.timeout >= TIMEOUT_MS) {
       logger.info(`Expired placeholder found. Removing.`);
-      rmSync(path11);
+      rmSync(path12);
       throw new Error("TIMEOUT");
     }
-    return waitForDocs(json, path11, logger, retryDuration);
+    return waitForDocs(json, path12, logger, retryDuration);
   } catch (e) {
     if (e.message !== "TIMEOUT") {
-      logger.info(`Docs JSON not found at ${path11}`);
+      logger.info(`Docs JSON not found at ${path12}`);
     }
     logger.debug("Generating placeholder");
-    generatePlaceholder(path11);
-    return generateDocs(specifier, path11, docgen, logger).catch((e2) => {
+    generatePlaceholder(path12);
+    return generateDocs(specifier, path12, docgen, logger).catch((e2) => {
       logger.error("Error generating documentation");
       logger.error(e2);
       handleError2();
@@ -1696,7 +1752,7 @@ var docsHandler = async (options, logger) => {
     logger.success(`Showing docs for ${adaptorName} v${version}`);
   }
   logger.info("Generating/loading documentation...");
-  const path11 = await handler_default7(
+  const path12 = await handler_default7(
     {
       specifier: `${name}@${version}`,
       repoDir
@@ -1705,8 +1761,8 @@ var docsHandler = async (options, logger) => {
     createNullLogger()
   );
   let didError = false;
-  if (path11) {
-    const source = await readFile4(path11, "utf8");
+  if (path12) {
+    const source = await readFile4(path12, "utf8");
     const data = JSON.parse(source);
     let desc;
     if (operation) {
@@ -1745,7 +1801,7 @@ var handler_default8 = docsHandler;
 import { createHash } from "node:crypto";
 import { readFileSync as readFileSync2 } from "node:fs";
 import path8 from "node:path";
-import { writeFile as writeFile6, mkdir as mkdir2 } from "node:fs/promises";
+import { writeFile as writeFile6, mkdir as mkdir3 } from "node:fs/promises";
 var getPath = (repoDir, key) => `${repoDir}/meta/${key}.json`;
 var sortKeys = (obj) => {
   const newObj = {};
@@ -1775,7 +1831,7 @@ var get2 = (repoPath, key) => {
 };
 var set2 = async (repoPath, key, data) => {
   const fullPath = getPath(repoPath, key);
-  await mkdir2(path8.dirname(fullPath), { recursive: true });
+  await mkdir3(path8.dirname(fullPath), { recursive: true });
   await writeFile6(fullPath, JSON.stringify(data));
 };
 var cache_default = { get: get2, set: set2, generateKey, getPath, sortKeys };
@@ -1863,16 +1919,92 @@ var metadataHandler = async (options, logger) => {
 var handler_default9 = metadataHandler;
 
 // src/pull/handler.ts
-import path9 from "path";
-import fs4 from "node:fs/promises";
+import path10 from "path";
+import fs5 from "node:fs/promises";
 import {
   getConfig as getConfig2,
-  getProject,
+  getProject as getProject2,
   getSpec,
   getStateFromProjectPayload,
   syncRemoteSpec
 } from "@openfn/deploy";
+
+// src/pull/beta.ts
+import { confirm } from "@inquirer/prompts";
+import path9 from "path";
+import fs4 from "node:fs/promises";
+import { getProject } from "@openfn/deploy";
+import Project3 from "@openfn/project";
+import { rimraf } from "rimraf";
+async function handler2(options, logger) {
+  const { OPENFN_API_KEY, OPENFN_ENDPOINT } = process.env;
+  const config = {
+    apiKey: options.apiKey,
+    endpoint: options.endpoint
+  };
+  if (!options.apiKey && OPENFN_API_KEY) {
+    logger.info("Using OPENFN_API_KEY environment variable");
+    config.apiKey = OPENFN_API_KEY;
+  }
+  if (!options.endpoint && OPENFN_ENDPOINT) {
+    logger.info("Using OPENFN_ENDPOINT environment variable");
+    config.endpoint = OPENFN_ENDPOINT;
+  }
+  const { data } = await getProject(config, options.projectId);
+  const name = options.env || "project";
+  const project = Project3.from("state", data, {
+    endpoint: config.endpoint,
+    env: name,
+    fetched_at: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  const outputRoot = path9.resolve(options.path || ".");
+  const projectFileName = project.getIdentifier();
+  await fs4.mkdir(`${outputRoot}/.projects`, { recursive: true });
+  let stateOutputPath = `${outputRoot}/.projects/${projectFileName}`;
+  const workflowsRoot = path9.resolve(
+    outputRoot,
+    project.repo?.workflowRoot ?? "workflows"
+  );
+  if (!await confirm({
+    message: `This will remove all files in ${path9.resolve(
+      workflowsRoot
+    )} and rebuild the workflow. Are you sure you wish to proceed?
+`,
+    default: true
+  })) {
+    logger.always("Cancelled");
+    return false;
+  }
+  await rimraf(workflowsRoot);
+  const state = project?.serialize("state");
+  if (project.repo?.formats.project === "yaml") {
+    await fs4.writeFile(`${stateOutputPath}.yaml`, state);
+  } else {
+    await fs4.writeFile(
+      `${stateOutputPath}.json`,
+      JSON.stringify(state, null, 2)
+    );
+  }
+  logger.success(`Saved project file to ${stateOutputPath}`);
+  const files = project?.serialize("fs");
+  for (const f in files) {
+    if (files[f]) {
+      await fs4.mkdir(path9.join(outputRoot, path9.dirname(f)), {
+        recursive: true
+      });
+      await fs4.writeFile(path9.join(outputRoot, f), files[f]);
+    } else {
+      console.log("WARNING! No content for file", f);
+    }
+  }
+  logger.success(`Expanded project to ${outputRoot}`);
+}
+
+// src/pull/handler.ts
 async function pullHandler(options, logger) {
+  if (options.beta) {
+    return handler2(options, logger);
+  }
   try {
     const config = mergeOverrides2(await getConfig2(options.configPath), options);
     if (process.env["OPENFN_API_KEY"]) {
@@ -1886,7 +2018,7 @@ async function pullHandler(options, logger) {
     logger.always(
       "Downloading existing project state (as JSON) from the server."
     );
-    const { data: project } = await getProject(
+    const { data: project } = await getProject2(
       config,
       options.projectId,
       options.snapshots
@@ -1925,7 +2057,7 @@ async function pullHandler(options, logger) {
       process.exitCode = 1;
       process.exit(1);
     }
-    const resolvedPath = path9.resolve(config.specPath);
+    const resolvedPath = path10.resolve(config.specPath);
     logger.debug("reading spec from", resolvedPath);
     const updatedSpec = await syncRemoteSpec(
       await res.text(),
@@ -1933,11 +2065,11 @@ async function pullHandler(options, logger) {
       config,
       logger
     );
-    await fs4.writeFile(
-      path9.resolve(config.statePath),
+    await fs5.writeFile(
+      path10.resolve(config.statePath),
       JSON.stringify(state, null, 2)
     );
-    await fs4.writeFile(resolvedPath, updatedSpec);
+    await fs5.writeFile(resolvedPath, updatedSpec);
     const spec = await getSpec(resolvedPath);
     if (spec.errors.length > 0) {
       logger.error("ERROR: invalid spec");
@@ -1968,7 +2100,7 @@ var handler_default10 = pullHandler;
 
 // src/util/print-versions.ts
 import { readFileSync as readFileSync3 } from "node:fs";
-import path10 from "node:path";
+import path11 from "node:path";
 import url from "node:url";
 import { getNameAndVersion as getNameAndVersion5 } from "@openfn/runtime";
 import { mainSymbols } from "figures";
@@ -1980,7 +2112,7 @@ var { triangleRightSmall: t } = mainSymbols;
 var loadVersionFromPath = (adaptorPath) => {
   try {
     const pkg = JSON.parse(
-      readFileSync3(path10.resolve(adaptorPath, "package.json"), "utf8")
+      readFileSync3(path11.resolve(adaptorPath, "package.json"), "utf8")
     );
     return pkg.version;
   } catch (e) {
@@ -2015,8 +2147,8 @@ var printVersions = async (logger, options = {}, includeComponents = false) => {
     ...[NODE, CLI2, RUNTIME2, COMPILER2, longestAdaptorName].map((s) => s.length)
   );
   const prefix = (str) => `         ${t} ${str.padEnd(longest + 4, " ")}`;
-  const dirname = path10.dirname(url.fileURLToPath(import.meta.url));
-  const pkg = JSON.parse(readFileSync3(`${dirname}/../../package.json`, "utf8"));
+  const dirname3 = path11.dirname(url.fileURLToPath(import.meta.url));
+  const pkg = JSON.parse(readFileSync3(`${dirname3}/../../package.json`, "utf8"));
   const { version, dependencies } = pkg;
   const compilerVersion = dependencies["@openfn/compiler"];
   const runtimeVersion = dependencies["@openfn/runtime"];
@@ -2099,13 +2231,13 @@ var parse = async (options, log) => {
       logger
     );
   }
-  const handler = handlers[options.command];
-  if (!handler) {
+  const handler3 = handlers[options.command];
+  if (!handler3) {
     logger.error(`Unrecognised command: ${options.command}`);
     process.exit(1);
   }
   try {
-    return await handler(options, logger);
+    return await handler3(options, logger);
   } catch (e) {
     if (!process.exitCode) {
       process.exitCode = e.exitCode || 1;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openfn/cli",
-  "version": "1.11.5",
+  "version": "1.12.0",
   "description": "CLI devtools for the openfn toolchain.",
   "engines": {
     "node": ">=18",
@@ -42,15 +42,16 @@
     "@inquirer/prompts": "^1.1.4",
     "chalk": "^5.1.2",
     "figures": "^5.0.0",
-    "rimraf": "^3.0.2",
+    "rimraf": "^6.0.1",
     "treeify": "^1.1.0",
     "undici": "^7.1.0",
     "ws": "^8.18.0",
     "yargs": "^17.7.2",
-    "@openfn/lexicon": "^1.2.1",
-    "@openfn/compiler": "1.0.3",
-    "@openfn/deploy": "0.11.1",
+    "@openfn/compiler": "1.0.4",
     "@openfn/describe-package": "0.1.4",
+    "@openfn/deploy": "0.11.1",
+    "@openfn/lexicon": "^1.2.2",
+    "@openfn/project": "^0.1.0",
     "@openfn/logger": "1.0.5",
     "@openfn/runtime": "1.6.4"
   },