@openfn/cli 1.1.4 → 1.2.1

package/README.md

@@ -127,6 +127,46 @@ If no command is specified, execute will run.
 
 To get more information about a command, including usage examples, run `openfn <command> help`, ie, `openfn compile help`.
 
+## Caching step output
+
+The CLI can write the output of every single step to disk (rather than just the final output). To do this, just run a job with the `--cache-steps` flag.
+
+```
+openfn tmp/job.js --cache-steps
+```
+
+The cached output is written to `.cli-cache/<workflow-name>/<step-name>.json`, relative to the input job or workflow file. This folder has a `.gitignore` file and should be ignored from your version control.
+
+So for a workflow at `./tmp/workflow.json` you'll get a cache path something like `./tmp/.cli-cache/workflow/step-1.json.`
+
+The cache is cleared when execution starts, so you know all artefacts in the cache folder relate to the last run.
+
+Step caching is disabled by default, but you can switch it on by setting the `OPENFN_ALWAYS_CACHE_STEPS` env var to `true`. To disable for a single execution, pass the `--no-compile-steps` flag.
+
+## Starting from a custom step
+
+When executing a workflow, the CLI will run from the first step (which is usually the first step in the `steps` array, unless `options.start` is set in the workflow).
+
+You can run from any starting step by passing `--start <step-name>`, like this:
+
+```
+openfn tmp/job.js --start upload-to-salesforce
+```
+
+If you previously cached the steps from this workflow, the CLI will automatically load the correct input state from the cache. Otherwise, you can pass in whatever state you need with `-s ./transformed-state.json`.
+
+You can also pass `--end` to make the workflow end early, or `--only` to only run a single step.
+
+All step names name supports "fuzzy" inputs. If you pass an exact step id, that step will always be the starting step. But you can also pass part of step name or id.
+
+So to match a step called with id `236baf56-e6c7-40f2-80ad-00d5a10b6b64` (such as you might download from Lightning), you can do:
+
+```
+openfn tmp/job.js --start 236b
+```
+
+Any unique continuous sequence of characters on the name or id will match. If there are multiple matches, an error will be thrown.
+
 ## Deploying Workflows
 
 > ⚠️ This feature is still in active development. Expect breaking changes.

package/dist/index.js

@@ -171,6 +171,18 @@ var autoinstall = {
     default: true
   }
 };
+var cacheSteps = {
+  name: "cache-steps",
+  yargs: {
+    boolean: true,
+    description: "Cache the output of steps to ./.cache/<workflow-name>/<step-name>.json"
+  },
+  ensure: (opts2) => {
+    if (process.env.OPENFN_ALWAYS_CACHE_STEPS && !opts2.hasOwnProperty("cacheSteps")) {
+      opts2.cacheSteps = process.env.OPENFN_ALWAYS_CACHE_STEPS === "true";
+    }
+  }
+};
 var compile = {
   name: "no-compile",
   yargs: {
@@ -341,7 +353,21 @@ var start = {
   name: "start",
   yargs: {
     string: true,
-    description: "Specifiy the start node in a workflow"
+    description: "Specifiy the start step in a workflow"
+  }
+};
+var end = {
+  name: "end",
+  yargs: {
+    string: true,
+    description: "Specifiy the end step in a workflow"
+  }
+};
+var only = {
+  name: "only",
+  yargs: {
+    string: true,
+    description: "Specifiy to only run one step in a workflow"
   }
 };
 var skipAdaptorValidation = {
@@ -531,17 +557,20 @@ var options4 = [
   expandAdaptors,
   adaptors,
   autoinstall,
+  cacheSteps,
   compile,
-  immutable,
+  end,
   ignoreImports,
+  immutable,
   inputPath,
   log,
   logJson,
+  only,
   outputPath,
   outputStdout,
   repoDir,
-  skipAdaptorValidation,
   sanitize,
+  skipAdaptorValidation,
   start,
   statePath,
   stateStdin,

package/dist/process/runner.js

@@ -1,5 +1,5 @@
 // src/execute/execute.ts
-import run, { getNameAndVersion } from "@openfn/runtime";
+import run, { NOTIFY_JOB_COMPLETE, getNameAndVersion } from "@openfn/runtime";
 
 // src/util/logger.ts
 import actualCreateLogger, { printDuration } from "@openfn/logger";
@@ -31,8 +31,59 @@ var createLogger = (name = "", options) => {
 var logger_default = createLogger;
 var createNullLogger = () => createLogger(void 0, { log: { default: "none" } });
 
+// src/util/cache.ts
+import fs from "node:fs";
+import path from "node:path";
+import { rmdir } from "node:fs/promises";
+var getCachePath = async (plan, options, stepId) => {
+  const { baseDir } = options;
+  const { name } = plan.workflow;
+  const basePath = `${baseDir}/.cli-cache/${name}`;
+  if (stepId) {
+    return path.resolve(`${basePath}/${stepId.replace(/ /, "-")}.json`);
+  }
+  return path.resolve(basePath);
+};
+var ensureGitIgnore = (options) => {
+  if (!options._hasGitIgnore) {
+    const ignorePath = path.resolve(
+      options.baseDir,
+      ".cli-cache",
+      ".gitignore"
+    );
+    try {
+      fs.accessSync(ignorePath);
+    } catch (e) {
+      fs.writeFileSync(ignorePath, "*");
+    }
+  }
+  options._hasGitIgnore = true;
+};
+var saveToCache = async (plan, stepId, output, options, logger) => {
+  if (options.cacheSteps) {
+    const cachePath = await getCachePath(plan, options, stepId);
+    fs.mkdirSync(path.dirname(cachePath), { recursive: true });
+    ensureGitIgnore(options);
+    logger.info(`Writing ${stepId} output to ${cachePath}`);
+    fs.writeFileSync(cachePath, JSON.stringify(output));
+  }
+};
+var clearCache = async (plan, options, logger) => {
+  const cacheDir = await getCachePath(plan, options);
+  try {
+    await rmdir(cacheDir, { recursive: true });
+    logger.info(`Cleared cache at ${cacheDir}`);
+  } catch (e) {
+    if (e.code === "ENOENT") {
+    } else {
+      logger.error(`Error while clearing cache at ${cacheDir}`);
+      logger.error(e);
+    }
+  }
+};
+
 // src/execute/execute.ts
-var execute_default = async (plan, input, opts) => {
+var execute_default = async (plan, input, opts, logger) => {
   try {
     const result = await run(plan, input, {
       immutableState: opts.immutable,
@@ -41,6 +92,14 @@ var execute_default = async (plan, input, opts) => {
       linker: {
         repo: opts.repoDir,
         modules: parseAdaptors(plan)
+      },
+      callbacks: {
+        notify: async (eventName, payload) => {
+          if (eventName === NOTIFY_JOB_COMPLETE) {
+            const { state, jobId } = payload;
+            await saveToCache(plan, jobId, state, opts, logger);
+          }
+        }
       }
     });
     return result;
@@ -51,13 +110,13 @@ var execute_default = async (plan, input, opts) => {
 };
 function parseAdaptors(plan) {
   const extractInfo = (specifier) => {
-    const [module, path7] = specifier.split("=");
+    const [module, path8] = specifier.split("=");
     const { name, version } = getNameAndVersion(module);
     const info = {
       name
     };
-    if (path7) {
-      info.path = path7;
+    if (path8) {
+      info.path = path8;
     }
     if (version) {
       info.version = version;
@@ -196,6 +255,7 @@ var AbortError = class extends Error {
 };
 var abort_default = (logger, reason, error, help) => {
   const e = new AbortError(reason);
+  logger.break();
   logger.error(reason);
   if (error) {
     logger.error(error.message);
@@ -205,6 +265,7 @@ var abort_default = (logger, reason, error, help) => {
   }
   logger.break();
   logger.error("Critical error: aborting command");
+  process.exitCode = 1;
   throw e;
 };
 
@@ -261,10 +322,10 @@ var stripVersionSpecifier = (specifier) => {
   return specifier;
 };
 var resolveSpecifierPath = async (pattern, repoDir, log) => {
-  const [specifier, path7] = pattern.split("=");
-  if (path7) {
-    log.debug(`Resolved ${specifier} to path: ${path7}`);
-    return path7;
+  const [specifier, path8] = pattern.split("=");
+  if (path8) {
+    log.debug(`Resolved ${specifier} to path: ${path8}`);
+    return path8;
   }
   const repoPath = await getModulePath(specifier, repoDir, log);
   if (repoPath) {
@@ -281,16 +342,16 @@ var loadTransformOptions = async (opts, log) => {
     const [pattern] = opts.adaptors;
     const [specifier] = pattern.split("=");
     log.debug(`Trying to preload types for ${specifier}`);
-    const path7 = await resolveSpecifierPath(pattern, opts.repoDir, log);
-    if (path7) {
+    const path8 = await resolveSpecifierPath(pattern, opts.repoDir, log);
+    if (path8) {
       try {
         exports = await preloadAdaptorExports(
-          path7,
+          path8,
           opts.useAdaptorsMonorepo,
           log
         );
       } catch (e) {
-        log.error(`Failed to load adaptor typedefs from path ${path7}`);
+        log.error(`Failed to load adaptor typedefs from path ${path8}`);
         log.error(e);
       }
     }
@@ -310,8 +371,21 @@ var loadTransformOptions = async (opts, log) => {
 };
 
 // src/util/load-state.ts
-import fs from "node:fs/promises";
-var load_state_default = async (opts, log) => {
+import fs2 from "node:fs/promises";
+var getUpstreamStepId = (plan, stepId) => {
+  const upstreamStep = plan.workflow.steps.find((step) => {
+    if (step.next) {
+      if (typeof step.next === "string") {
+        return step.next === stepId;
+      }
+      return stepId in step.next;
+    }
+  });
+  if (upstreamStep) {
+    return typeof upstreamStep === "string" ? upstreamStep : upstreamStep.id;
+  }
+};
+var load_state_default = async (plan, opts, log, start) => {
   const { stateStdin, statePath } = opts;
   log.debug("Loading state...");
   if (stateStdin) {
@@ -329,7 +403,7 @@ var load_state_default = async (opts, log) => {
   }
   if (statePath) {
     try {
-      const str = await fs.readFile(statePath, "utf8");
+      const str = await fs2.readFile(statePath, "utf8");
       const json = JSON.parse(str);
       log.success(`Loaded state from ${statePath}`);
       log.debug("state:", json);
@@ -339,6 +413,43 @@ var load_state_default = async (opts, log) => {
       log.warn(e);
     }
   }
+  if (start) {
+    log.info(
+      "No state provided to CLI. Will attempt to load state from cache instead"
+    );
+    log.always(
+      `Attempting to load cached input state for starting step "${start}"`
+    );
+    try {
+      const upstreamStepId = getUpstreamStepId(plan, start);
+      if (upstreamStepId) {
+        log.debug(`Input step for "${start}" is "${upstreamStepId}"`);
+        const cachedStatePath = await getCachePath(plan, opts, upstreamStepId);
+        log.debug("Loading cached state from", cachedStatePath);
+        try {
+          await fs2.access(cachedStatePath);
+          const str = await fs2.readFile(cachedStatePath, "utf8");
+          const json = JSON.parse(str);
+          log.success(
+            `Loaded cached state for step "${start}" from ${cachedStatePath}`
+          );
+          log.info(`  To force disable the cache, run again with --no-cache`);
+          return json;
+        } catch (e) {
+          log.warn(`No cached state found for step "${start}"`);
+          log.warn(
+            "Re-run this workflow with --cache to save the output of each step"
+          );
+          log.break();
+        }
+      } else {
+        log.warn(`Could not find an input step for step "${start}"`);
+      }
+    } catch (e) {
+      log.warn("Error loading cached state");
+      log.warn(e);
+    }
+  }
   log.info(
     "No state provided - using default state { data: {}, configuration: {} }"
   );
@@ -375,8 +486,8 @@ var validateAdaptors = async (options, logger) => {
 var validate_adaptors_default = validateAdaptors;
 
 // src/util/load-plan.ts
-import fs2 from "node:fs/promises";
-import path2 from "node:path";
+import fs3 from "node:fs/promises";
+import path3 from "node:path";
 import { isPath } from "@openfn/compiler";
 
 // src/util/expand-adaptors.ts
@@ -406,7 +517,7 @@ var expand_adaptors_default = (input) => {
 
 // src/util/map-adaptors-to-monorepo.ts
 import { readFile } from "node:fs/promises";
-import path from "node:path";
+import path2 from "node:path";
 import assert from "node:assert";
 import { getNameAndVersion as getNameAndVersion2 } from "@openfn/runtime";
 var validateMonoRepo = async (repoPath, log) => {
@@ -430,7 +541,7 @@ var updatePath = (adaptor, repoPath, log) => {
     );
   }
   const shortName = name.replace("@openfn/language-", "");
-  const abspath = path.resolve(repoPath, "packages", shortName);
+  const abspath = path2.resolve(repoPath, "packages", shortName);
   log.info(`Mapped adaptor ${name} to monorepo: ${abspath}`);
   return `${name}=${abspath}`;
 };
@@ -461,10 +572,10 @@ var loadPlan = async (options, logger) => {
   }
   const jsonPath = planPath || workflowPath;
   if (!options.baseDir) {
-    options.baseDir = path2.dirname(jsonPath);
+    options.baseDir = path3.dirname(jsonPath);
   }
   const json = await loadJson(jsonPath, logger);
-  const defaultName = path2.parse(jsonPath).name;
+  const defaultName = path3.parse(jsonPath).name;
   if (json.workflow) {
     return loadXPlan(json, options, logger, defaultName);
   } else {
@@ -475,7 +586,7 @@ var load_plan_default = loadPlan;
 var loadJson = async (workflowPath, logger) => {
   let text;
   try {
-    text = await fs2.readFile(workflowPath, "utf8");
+    text = await fs3.readFile(workflowPath, "utf8");
     logger.debug("Loaded workflow from", workflowPath);
   } catch (e) {
     return abort_default(
@@ -509,8 +620,8 @@ var loadExpression = async (options, logger) => {
   const expressionPath = options.expressionPath;
   logger.debug(`Loading expression from ${expressionPath}`);
   try {
-    const expression = await fs2.readFile(expressionPath, "utf8");
-    const name = path2.parse(expressionPath).name;
+    const expression = await fs3.readFile(expressionPath, "utf8");
+    const name = path3.parse(expressionPath).name;
     const step = { expression };
     if (options.adaptors) {
       const [adaptor] = options.adaptors;
@@ -557,8 +668,8 @@ var loadOldWorkflow = async (workflow, options, logger, defaultName = "") => {
 };
 var fetchFile = async (jobId, rootDir = "", filePath, log) => {
   try {
-    const fullPath = filePath.startsWith("~") ? filePath : path2.resolve(rootDir, filePath);
-    const result = await fs2.readFile(fullPath, "utf8");
+    const fullPath = filePath.startsWith("~") ? filePath : path3.resolve(rootDir, filePath);
+    const result = await fs3.readFile(fullPath, "utf8");
     log.debug("Loaded file", fullPath);
     return result;
   } catch (e) {
@@ -620,8 +731,8 @@ var loadXPlan = async (plan, options, logger, defaultName = "") => {
 };
 
 // src/util/assert-path.ts
-var assert_path_default = (path7) => {
-  if (!path7) {
+var assert_path_default = (path8) => {
+  if (!path8) {
     console.error("ERROR: no path provided!");
     console.error("\nUsage:");
     console.error("  open path/to/job");
@@ -631,12 +742,58 @@ var assert_path_default = (path7) => {
   }
 };
 
+// src/util/fuzzy-match-step.ts
+var fuzzy_match_step_default = (plan, stepPattern) => {
+  if (stepPattern) {
+    const { steps } = plan.workflow;
+    const exact = steps.find((step) => step.id === stepPattern);
+    if (exact)
+      return exact.id;
+    const matches = {};
+    steps.forEach((step) => {
+      if (step.id?.includes(stepPattern) || step.name?.includes(stepPattern)) {
+        matches[step.id] = true;
+      }
+    });
+    const results = Object.keys(matches);
+    if (results.length === 1) {
+      return results[0];
+    }
+    if (results.length > 1) {
+      throw new Error("AMBIGUOUS_INPUT");
+    }
+    throw new Error("NOT_FOUND");
+  }
+};
+
 // src/execute/handler.ts
+var matchStep = (plan, stepPattern, stepName, logger) => {
+  try {
+    return fuzzy_match_step_default(plan, stepPattern) ?? stepPattern;
+  } catch (err) {
+    let message;
+    let help;
+    if (err.message === "AMBIGUOUS_INPUT") {
+      message = `${stepName} pattern matched multiple steps`;
+      help = `The ${stepName} option can contain an exact match of a step id, or a partial match if a name or id so long as it is unique.`;
+    } else if (err.message === "NOT_FOUND") {
+      message = `${stepName} step not found`;
+      help = `The step "${stepPattern}" could not be be found in the workflow`;
+    } else {
+      message = `Error parsing ${stepName} option`;
+    }
+    abort_default(logger, `Error: ${message}`, void 0, help);
+  }
+  return "";
+};
 var executeHandler = async (options, logger) => {
   const start = (/* @__PURE__ */ new Date()).getTime();
   assert_path_default(options.path);
   await validate_adaptors_default(options, logger);
   let plan = await load_plan_default(options, logger);
+  if (options.cacheSteps) {
+    await clearCache(plan, options, logger);
+  }
   const { repoDir, monorepoPath, autoinstall } = options;
   if (autoinstall) {
     if (monorepoPath) {
@@ -649,14 +806,55 @@ var executeHandler = async (options, logger) => {
       }
     }
   }
-  const state = await load_state_default(options, logger);
+  let customStart;
+  let customEnd;
+  if (options.only) {
+    const step = matchStep(plan, options.only, "only", logger);
+    customStart = step;
+    customEnd = step;
+    logger.always(`Only running workflow step "${options.start}"`);
+  } else {
+    if (options.start) {
+      customStart = matchStep(
+        plan,
+        options.start ?? plan.options.start,
+        "start",
+        logger
+      );
+      logger.info(`Starting workflow from step "${options.start}"`);
+    }
+    if (options.end) {
+      customEnd = matchStep(
+        plan,
+        options.end ?? plan.options.end,
+        "end",
+        logger
+      );
+      logger.always(`Ending workflow at step "${options.end}"`);
+    }
+  }
+  const state = await load_state_default(plan, options, logger, customStart);
   if (options.compile) {
     plan = await compile_default(plan, options, logger);
   } else {
     logger.info("Skipping compilation as noCompile is set");
   }
+  const finalPlan = {
+    ...plan,
+    options: {
+      ...plan.options,
+      start: customStart || plan.options.start,
+      end: customEnd
+    },
+    workflow: plan.workflow
+  };
   try {
-    const result = await execute_default(plan, state, options);
+    const result = await execute_default(finalPlan, state, options, logger);
+    if (options.cacheSteps) {
+      logger.success(
+        "Cached output written to ./cli-cache (see info logs for details)"
+      );
+    }
     await serialize_output_default(options, result, logger);
     const duration = printDuration((/* @__PURE__ */ new Date()).getTime() - start);
     if (result?.errors) {
@@ -743,9 +941,9 @@ var testHandler = async (options, logger) => {
     );
     logger.debug('eg: -S "{ "data": { "answer": 33 }  }"');
   }
-  const state = await load_state_default(opts, createNullLogger());
+  const state = await load_state_default(plan, opts, createNullLogger());
   const compiledPlan = await compile_default(plan, opts, logger);
-  const result = await execute_default(compiledPlan, state, opts);
+  const result = await execute_default(compiledPlan, state, opts, logger);
   logger.success(`Result: ${result.data.answer}`);
   return result;
 };
@@ -807,28 +1005,28 @@ var handler_default4 = deployHandler;
 // src/docgen/handler.ts
 import { writeFile as writeFile3 } from "node:fs/promises";
 import { readFileSync, writeFileSync, mkdirSync, rmSync } from "node:fs";
-import path3 from "node:path";
+import path4 from "node:path";
 import { describePackage } from "@openfn/describe-package";
 import { getNameAndVersion as getNameAndVersion3 } 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(path3.dirname(filePath), { recursive: true });
-var generatePlaceholder = (path7) => {
-  writeFileSync(path7, `{ "loading": true, "timestamp": ${Date.now()}}`);
+var ensurePath = (filePath) => mkdirSync(path4.dirname(filePath), { recursive: true });
+var generatePlaceholder = (path8) => {
+  writeFileSync(path8, `{ "loading": true, "timestamp": ${Date.now()}}`);
 };
 var finish = (logger, resultPath) => {
   logger.success("Done! Docs can be found at:\n");
-  logger.print(`  ${path3.resolve(resultPath)}`);
+  logger.print(`  ${path4.resolve(resultPath)}`);
 };
-var generateDocs = async (specifier, path7, docgen, logger) => {
+var generateDocs = async (specifier, path8, docgen, logger) => {
   const result = await docgen(specifier);
-  await writeFile3(path7, JSON.stringify(result, null, 2));
-  finish(logger, path7);
-  return path7;
+  await writeFile3(path8, JSON.stringify(result, null, 2));
+  finish(logger, path8);
+  return path8;
 };
-var waitForDocs = async (docs, path7, logger, retryDuration = RETRY_DURATION) => {
+var waitForDocs = async (docs, path8, logger, retryDuration = RETRY_DURATION) => {
   try {
     if (docs.hasOwnProperty("loading")) {
       logger.info("Docs are being loaded by another process. Waiting.");
@@ -840,19 +1038,19 @@ var waitForDocs = async (docs, path7, logger, retryDuration = RETRY_DURATION) =>
             clearInterval(i);
             reject(new Error("Timed out waiting for docs to load"));
           }
-          const updated = JSON.parse(readFileSync(path7, "utf8"));
+          const updated = JSON.parse(readFileSync(path8, "utf8"));
           if (!updated.hasOwnProperty("loading")) {
             logger.info("Docs found!");
             clearInterval(i);
-            resolve(path7);
+            resolve(path8);
           }
           count++;
         }, retryDuration);
       });
     } else {
-      logger.info(`Docs already written to cache at ${path7}`);
-      finish(logger, path7);
-      return path7;
+      logger.info(`Docs already written to cache at ${path8}`);
+      finish(logger, path8);
+      return path8;
     }
   } catch (e) {
     logger.error("Existing doc JSON corrupt. Aborting");
@@ -869,28 +1067,28 @@ var docgenHandler = (options, logger, docgen = actualDocGen, retryDuration = RET
     process.exit(9);
   }
   logger.success(`Generating docs for ${specifier}`);
-  const path7 = `${repoDir}/docs/${specifier}.json`;
-  ensurePath(path7);
+  const path8 = `${repoDir}/docs/${specifier}.json`;
+  ensurePath(path8);
   const handleError = () => {
     logger.info("Removing placeholder");
-    rmSync(path7);
+    rmSync(path8);
   };
   try {
-    const existing = readFileSync(path7, "utf8");
+    const existing = readFileSync(path8, "utf8");
     const json = JSON.parse(existing);
     if (json && json.timeout && Date.now() - json.timeout >= TIMEOUT_MS) {
       logger.info(`Expired placeholder found. Removing.`);
-      rmSync(path7);
+      rmSync(path8);
       throw new Error("TIMEOUT");
     }
-    return waitForDocs(json, path7, logger, retryDuration);
+    return waitForDocs(json, path8, logger, retryDuration);
   } catch (e) {
     if (e.message !== "TIMEOUT") {
-      logger.info(`Docs JSON not found at ${path7}`);
+      logger.info(`Docs JSON not found at ${path8}`);
     }
     logger.debug("Generating placeholder");
-    generatePlaceholder(path7);
-    return generateDocs(specifier, path7, docgen, logger).catch((e2) => {
+    generatePlaceholder(path8);
+    return generateDocs(specifier, path8, docgen, logger).catch((e2) => {
       logger.error("Error generating documentation");
       logger.error(e2);
       handleError();
@@ -937,7 +1135,7 @@ var docsHandler = async (options, logger) => {
     logger.success(`Showing docs for ${adaptorName} v${version}`);
   }
   logger.info("Generating/loading documentation...");
-  const path7 = await handler_default5(
+  const path8 = await handler_default5(
     {
       specifier: `${name}@${version}`,
       repoDir
@@ -946,8 +1144,8 @@ var docsHandler = async (options, logger) => {
     createNullLogger()
   );
   let didError = false;
-  if (path7) {
-    const source = await readFile2(path7, "utf8");
+  if (path8) {
+    const source = await readFile2(path8, "utf8");
     const data = JSON.parse(source);
     let desc;
     if (operation) {
@@ -985,7 +1183,7 @@ var handler_default6 = docsHandler;
 // src/metadata/cache.ts
 import { createHash } from "node:crypto";
 import { readFileSync as readFileSync2 } from "node:fs";
-import path4 from "node:path";
+import path5 from "node:path";
 import { writeFile as writeFile4, mkdir } from "node:fs/promises";
 var getPath = (repoDir, key) => `${repoDir}/meta/${key}.json`;
 var sortKeys = (obj) => {
@@ -1016,7 +1214,7 @@ var get = (repoPath, key) => {
 };
 var set = async (repoPath, key, data) => {
   const fullPath = getPath(repoPath, key);
-  await mkdir(path4.dirname(fullPath), { recursive: true });
+  await mkdir(path5.dirname(fullPath), { recursive: true });
   await writeFile4(fullPath, JSON.stringify(data));
 };
 var cache_default = { get, set, generateKey, getPath, sortKeys };
@@ -1057,7 +1255,7 @@ var getAdaptorPath = async (adaptor, logger, repoDir) => {
 var metadataHandler = async (options, logger) => {
   const { repoDir, adaptors } = options;
   const adaptor = adaptors[0];
-  const state = await load_state_default(options, logger);
+  const state = await load_state_default({}, options, logger);
   logger.success(`Generating metadata`);
   logger.info("config:", state);
   const config = state.configuration;
@@ -1100,8 +1298,8 @@ var metadataHandler = async (options, logger) => {
 var handler_default7 = metadataHandler;
 
 // src/pull/handler.ts
-import path5 from "path";
-import fs3 from "node:fs/promises";
+import path6 from "path";
+import fs4 from "node:fs/promises";
 import {
   getConfig as getConfig2,
   getProject,
@@ -1123,8 +1321,8 @@ async function pullHandler(options, logger) {
       process.exit(1);
     }
     const state = getStateFromProjectPayload(project);
-    await fs3.writeFile(
-      path5.resolve(config.statePath),
+    await fs4.writeFile(
+      path6.resolve(config.statePath),
       JSON.stringify(state, null, 2)
     );
     logger.always(
@@ -1149,9 +1347,9 @@ async function pullHandler(options, logger) {
       process.exitCode = 1;
       process.exit(1);
     }
-    const resolvedPath = path5.resolve(config.specPath);
+    const resolvedPath = path6.resolve(config.specPath);
     logger.debug("reading spec from", resolvedPath);
-    await fs3.writeFile(resolvedPath, res.body);
+    await fs4.writeFile(resolvedPath, res.body);
     const spec = await getSpec(resolvedPath);
     if (spec.errors.length > 0) {
       logger.error("ERROR: invalid spec");
@@ -1182,7 +1380,7 @@ var handler_default8 = pullHandler;
 
 // src/util/print-versions.ts
 import { readFileSync as readFileSync3 } from "node:fs";
-import path6 from "node:path";
+import path7 from "node:path";
 import url from "node:url";
 import { getNameAndVersion as getNameAndVersion5 } from "@openfn/runtime";
 import { mainSymbols } from "figures";
@@ -1194,7 +1392,7 @@ var { triangleRightSmall: t } = mainSymbols;
 var loadVersionFromPath = (adaptorPath) => {
   try {
     const pkg = JSON.parse(
-      readFileSync3(path6.resolve(adaptorPath, "package.json"), "utf8")
+      readFileSync3(path7.resolve(adaptorPath, "package.json"), "utf8")
     );
     return pkg.version;
   } catch (e) {
@@ -1227,7 +1425,7 @@ var printVersions = async (logger, options = {}, includeComponents = false) => {
     ...[NODE, CLI2, RUNTIME2, COMPILER2, adaptorName].map((s) => s.length)
   );
   const prefix = (str) => `         ${t} ${str.padEnd(longest + 4, " ")}`;
-  const dirname = path6.dirname(url.fileURLToPath(import.meta.url));
+  const dirname = path7.dirname(url.fileURLToPath(import.meta.url));
   const pkg = JSON.parse(readFileSync3(`${dirname}/../../package.json`, "utf8"));
   const { version, dependencies } = pkg;
   const compilerVersion = dependencies["@openfn/compiler"];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openfn/cli",
-  "version": "1.1.4",
+  "version": "1.2.1",
   "description": "CLI devtools for the openfn toolchain.",
   "engines": {
     "node": ">=18",
@@ -45,11 +45,11 @@
     "rimraf": "^3.0.2",
     "treeify": "^1.1.0",
     "yargs": "^17.7.2",
-    "@openfn/compiler": "0.1.1",
     "@openfn/deploy": "0.4.4",
-    "@openfn/describe-package": "0.0.18",
-    "@openfn/runtime": "1.1.1",
-    "@openfn/logger": "1.0.1"
+    "@openfn/compiler": "0.1.2",
+    "@openfn/describe-package": "0.0.19",
+    "@openfn/logger": "1.0.1",
+    "@openfn/runtime": "1.1.2"
   },
   "files": [
     "dist",