@openfn/cli 0.0.30 → 0.0.32

package/dist/chunk-XYZNU5CH.js

@@ -0,0 +1,150 @@
+// src/util/expand-adaptors.ts
+var expand_adaptors_default = (names) => names?.map((name) => {
+  if (typeof name === "string") {
+    const [left] = name.split("=");
+    if (left.match("/") || left.endsWith(".js")) {
+      return name;
+    }
+    return `@openfn/language-${name}`;
+  }
+  return name;
+});
+
+// src/util/logger.ts
+import actualCreateLogger, { printDuration } from "@openfn/logger";
+import { isValidLogLevel, defaultLogger } from "@openfn/logger";
+var CLI = "cli";
+var COMPILER = "compiler";
+var RUNTIME = "runtime";
+var JOB = "job";
+var namespaces = {
+  [CLI]: "CLI",
+  [RUNTIME]: "R/T",
+  [COMPILER]: "CMP",
+  [JOB]: "JOB"
+};
+var createLogger = (name = "", options) => {
+  const logOptions = options.log;
+  let level = logOptions[name] || logOptions.default || "default";
+  if (options.logJson) {
+    logOptions.json = true;
+  }
+  return actualCreateLogger(namespaces[name] || name, {
+    level,
+    ...logOptions
+  });
+};
+var logger_default = createLogger;
+var createNullLogger = () => createLogger(void 0, { log: { default: "none" } });
+
+// src/util/ensure-opts.ts
+import path from "node:path";
+var defaultLoggerOptions = {
+  default: "default",
+  job: "debug"
+};
+var ERROR_MESSAGE_LOG_LEVEL = "Unknown log level. Valid levels are none, debug, info and default.";
+var ERROR_MESSAGE_LOG_COMPONENT = "Unknown log component. Valid components are cli, compiler, runtime and job.";
+var DEFAULT_REPO_DIR = "/tmp/openfn/repo";
+var componentShorthands = {
+  cmp: "compiler",
+  rt: "runtime",
+  "r/t": "runtime"
+};
+var isValidComponent = (v) => /^(cli|runtime|compiler|job|default)$/i.test(v);
+var ensureLogOpts = (opts) => {
+  const components = {};
+  if (!opts.log && /^(version|test)$/.test(opts.command)) {
+    opts.log = { default: "info" };
+    return opts;
+  } else if (opts.log) {
+    opts.log.forEach((l) => {
+      let component = "";
+      let level = "";
+      if (l.match(/=/)) {
+        const parts = l.split("=");
+        component = parts[0].toLowerCase();
+        if (componentShorthands[component]) {
+          component = componentShorthands[component];
+        }
+        level = parts[1].toLowerCase();
+      } else {
+        component = "default";
+        level = l.toLowerCase();
+      }
+      if (!isValidComponent(component)) {
+        throw new Error(ERROR_MESSAGE_LOG_COMPONENT);
+      }
+      level = level.toLowerCase();
+      if (!isValidLogLevel(level)) {
+        throw new Error(ERROR_MESSAGE_LOG_LEVEL);
+      }
+      components[component] = level;
+    });
+  }
+  opts.log = {
+    ...defaultLoggerOptions,
+    ...components
+  };
+  return opts;
+};
+function ensureOpts(basePath = ".", opts) {
+  const newOpts = {
+    adaptor: opts.adaptor,
+    adaptors: opts.adaptors || [],
+    autoinstall: opts.autoinstall,
+    command: opts.command,
+    expandAdaptors: opts.expandAdaptors !== false,
+    force: opts.force || false,
+    immutable: opts.immutable || false,
+    log: opts.log,
+    logJson: typeof opts.logJson == "boolean" ? opts.logJson : Boolean(process.env.OPENFN_LOG_JSON),
+    compile: Boolean(opts.compile),
+    operation: opts.operation,
+    outputStdout: Boolean(opts.outputStdout),
+    packages: opts.packages,
+    repoDir: opts.repoDir || process.env.OPENFN_REPO_DIR || DEFAULT_REPO_DIR,
+    skipAdaptorValidation: opts.skipAdaptorValidation ?? false,
+    specifier: opts.specifier,
+    stateStdin: opts.stateStdin,
+    strictOutput: opts.strictOutput ?? true,
+    timeout: opts.timeout
+  };
+  const set = (key, value) => {
+    newOpts[key] = opts.hasOwnProperty(key) ? opts[key] : value;
+  };
+  if (opts.useAdaptorsMonorepo) {
+    newOpts.monorepoPath = process.env.OPENFN_ADAPTORS_REPO || "ERR";
+  }
+  let baseDir = basePath;
+  if (basePath.endsWith(".js")) {
+    baseDir = path.dirname(basePath);
+    set("jobPath", basePath);
+  } else {
+    set("jobPath", `${baseDir}/job.js`);
+  }
+  set("statePath", `${baseDir}/state.json`);
+  if (!opts.outputStdout) {
+    set(
+      "outputPath",
+      newOpts.command === "compile" ? `${baseDir}/output.js` : `${baseDir}/output.json`
+    );
+  }
+  ensureLogOpts(newOpts);
+  return newOpts;
+}
+
+export {
+  expand_adaptors_default,
+  printDuration,
+  CLI,
+  COMPILER,
+  RUNTIME,
+  JOB,
+  logger_default,
+  createNullLogger,
+  defaultLogger,
+  DEFAULT_REPO_DIR,
+  ensureLogOpts,
+  ensureOpts
+};

package/dist/index.js

@@ -1,4 +1,8 @@
 #!/usr/bin/env node
+import {
+  DEFAULT_REPO_DIR,
+  expand_adaptors_default
+} from "./chunk-XYZNU5CH.js";
 
 // src/process/spawn.ts
 import path from "node:path";
@@ -83,92 +87,291 @@ var list = {
   }
 };
 
+// src/util/command-builders.ts
+var build = (opts2, yargs2) => opts2.reduce((_y, o) => yargs2.option(o.name, o.yargs), yargs2);
+var ensure = (command, opts2) => (yargs2) => {
+  yargs2.command = command;
+  opts2.filter((opt) => opt.ensure).forEach((opt) => {
+    opt.ensure(yargs2);
+  });
+};
+var override = (command, yargs2) => {
+  return {
+    ...command,
+    yargs: {
+      ...command.yargs || {},
+      ...yargs2
+    }
+  };
+};
+
+// src/options.ts
+import path2 from "node:path";
+var setDefaultValue = (opts2, key, value) => {
+  const v = opts2[key];
+  if (isNaN(v) && !v) {
+    opts2[key] = value;
+  }
+};
+var adaptors = {
+  name: "adaptors",
+  yargs: {
+    alias: ["a", "adaptor"],
+    description: "A language adaptor to use for the job. Short-form names are allowed. Can include an explicit path to a local adaptor build"
+  },
+  ensure: (opts2) => {
+    if (opts2.adaptors) {
+      if (!Array.isArray(opts2.adaptors)) {
+        opts2.adaptors = [opts2.adaptors];
+      }
+    } else {
+      opts2.adaptors = [];
+    }
+    if (opts2.expandAdaptors) {
+      opts2.adaptors = expand_adaptors_default(opts2.adaptors);
+    }
+    delete opts2.adaptor;
+    delete opts2.a;
+  }
+};
+var autoinstall = {
+  name: "autoinstall",
+  yargs: {
+    alias: ["i"],
+    boolean: true,
+    description: "Auto-install the language adaptor",
+    default: false
+  }
+};
+var compile = {
+  name: "no-compile",
+  yargs: {
+    boolean: true,
+    description: "Disable compilation of the incoming source"
+  },
+  ensure: (opts2) => {
+    setDefaultValue(opts2, "compile", true);
+  }
+};
+var expandAdaptors = {
+  name: "no-expand-adaptors",
+  yargs: {
+    boolean: true,
+    description: "Don't attempt to auto-expand adaptor shorthand names"
+  },
+  ensure: (opts2) => {
+    setDefaultValue(opts2, "expandAdaptors", true);
+  }
+};
+var force = {
+  name: "force",
+  yargs: {
+    alias: ["f"],
+    boolean: true,
+    description: "Force metadata to be regenerated",
+    default: false
+  }
+};
+var immutable = {
+  name: "immutable",
+  yargs: {
+    description: "Enforce immutabilty on state object",
+    boolean: true,
+    default: false
+  }
+};
+var getBaseDir = (opts2) => {
+  const basePath = opts2.path ?? ".";
+  if (basePath.endsWith(".js")) {
+    return path2.dirname(basePath);
+  }
+  return basePath;
+};
+var jobPath = {
+  name: "job-path",
+  yargs: {
+    hidden: true
+  },
+  ensure: (opts2) => {
+    const { path: basePath } = opts2;
+    if (basePath?.endsWith(".js")) {
+      opts2.jobPath = basePath;
+    } else {
+      const base = getBaseDir(opts2);
+      setDefaultValue(opts2, "jobPath", path2.join(base, "job.js"));
+    }
+  }
+};
+var logJson = {
+  name: "log-json",
+  yargs: {
+    description: "Output all logs as JSON objects",
+    boolean: true
+  },
+  ensure: () => {
+  }
+};
+var outputStdout = {
+  name: "output-stdout",
+  yargs: {
+    alias: "O",
+    boolean: true,
+    description: "Print output to stdout (instead of a file)"
+  },
+  ensure: (opts2) => {
+    setDefaultValue(opts2, "outputStdout", false);
+  }
+};
+var outputPath = {
+  name: "output-path",
+  yargs: {
+    alias: "o",
+    description: "Path to the output file"
+  },
+  ensure: (opts2) => {
+    if (opts2.command == "compile") {
+      if (opts2.outputPath) {
+        delete opts2.outputStdout;
+      }
+    } else {
+      if (opts2.outputStdout) {
+        delete opts2.outputPath;
+      } else {
+        const base = getBaseDir(opts2);
+        setDefaultValue(opts2, "outputPath", path2.join(base, "output.json"));
+      }
+    }
+    delete opts2.o;
+  }
+};
+var repoDir = {
+  name: "repo-dir",
+  yargs: {
+    description: "Provide a path to the repo root dir",
+    default: process.env.OPENFN_REPO_DIR || DEFAULT_REPO_DIR
+  }
+};
+var strictOutput = {
+  name: "no-strict-output",
+  yargs: {
+    boolean: true,
+    description: "Allow properties other than data to be returned in the output"
+  },
+  ensure: (opts2) => {
+    setDefaultValue(opts2, "strictOutput", true);
+  }
+};
+var skipAdaptorValidation = {
+  name: "skip-adaptor-validation",
+  yargs: {
+    boolean: true,
+    description: "Suppress warning message for jobs which don't use an adaptor",
+    default: false
+  }
+};
+var statePath = {
+  name: "state-path",
+  yargs: {
+    alias: ["s"],
+    description: "Path to the state file"
+  }
+};
+var stateStdin = {
+  name: "state-stdin",
+  yargs: {
+    alias: ["S"],
+    description: "Read state from stdin (instead of a file)"
+  }
+};
+var timeout = {
+  name: "timeout",
+  yargs: {
+    alias: ["t"],
+    number: true,
+    description: "Set the timeout duration (ms). Defaults to 5 minutes.",
+    default: 5 * 60 * 1e3
+  }
+};
+var useAdaptorsMonorepo = {
+  name: "use-adaptors-monorepo",
+  yargs: {
+    alias: ["m"],
+    boolean: true,
+    description: "Load adaptors from the monorepo. The OPENFN_ADAPTORS_REPO env var must be set to a valid path"
+  },
+  ensure: (opts2) => {
+    if (opts2.useAdaptorsMonorepo) {
+      opts2.monorepoPath = process.env.OPENFN_ADAPTORS_REPO || "ERR";
+    }
+  }
+};
+
 // src/execute/command.ts
+var options = [
+  expandAdaptors,
+  adaptors,
+  autoinstall,
+  compile,
+  immutable,
+  jobPath,
+  logJson,
+  outputPath,
+  outputStdout,
+  repoDir,
+  skipAdaptorValidation,
+  statePath,
+  stateStdin,
+  strictOutput,
+  timeout,
+  useAdaptorsMonorepo
+];
 var executeCommand = {
   command: "execute [path]",
   desc: `Run an openfn job. Get more help by running openfn <command> help`,
   aliases: ["$0"],
-  handler: (argv) => {
-    argv.command = "execute";
-  },
-  builder: (yargs2) => {
-    return applyExecuteOptions(yargs2).option("immutable", {
-      boolean: true,
-      description: "Treat state as immutable"
-    }).option("use-adaptors-monorepo", {
-      alias: "m",
-      boolean: true,
-      description: "Load adaptors from the monorepo. The OPENFN_ADAPTORS_REPO env var must be set to a valid path"
-    }).option("autoinstall", {
-      alias: "i",
-      boolean: true,
-      description: "Auto-install the language adaptor"
-    }).option("state-path", {
-      alias: "s",
-      description: "Path to the state file"
-    }).option("state-stdin", {
-      alias: "S",
-      description: "Read state from stdin (instead of a file)"
-    }).option("skip-adaptor-validation", {
-      boolean: true,
-      description: "Skip adaptor validation warnings"
-    }).option("timeout", {
-      alias: "-t",
-      description: "Set the timeout duration in MS"
-    }).option("no-compile", {
-      boolean: true,
-      description: "Skip compilation"
-    }).option("no-strict-output", {
-      boolean: true,
-      description: "Allow properties other than data to be returned in the output"
-    }).example(
-      "openfn foo/job.js",
-      "Reads foo/job.js, looks for state and output in foo"
-    ).example(
-      "openfn job.js -a common",
-      "Run job.js using @openfn/language-common"
-    ).example(
-      "openfn install -a common",
-      "Install the latest version of language-common to the repo"
-    );
-  }
+  handler: ensure("execute", options),
+  builder: (yargs2) => build(options, yargs2).positional("path", {
+    describe: "The path to load the job from (a .js file or a dir containing a job.js file)",
+    demandOption: true
+  }).example(
+    "openfn foo/job.js",
+    "Reads foo/job.js, looks for state and output in foo"
+  ).example(
+    "openfn job.js -a common",
+    "Run job.js using @openfn/language-common"
+  ).example(
+    "openfn install -a common",
+    "Install the latest version of language-common to the repo"
+  )
 };
-var applyExecuteOptions = (yargs2) => yargs2.positional("path", {
-  describe: "The path to load the job from (a .js file or a dir containing a job.js file)",
-  demandOption: true
-}).option("output-path", {
-  alias: "o",
-  description: "Path to the output file"
-}).option("output-stdout", {
-  alias: "O",
-  boolean: true,
-  description: "Print output to stdout (instead of a file)"
-}).option("adaptors", {
-  alias: ["a", "adaptor"],
-  description: "A language adaptor to use for the job. Short-form names are allowed. Can include an explicit path to a local adaptor build",
-  array: true
-}).option("no-expand", {
-  description: "Don	 attempt to auto-expand adaptor shorthand names",
-  boolean: true
-});
 var command_default = executeCommand;
 
 // src/compile/command.ts
+var options2 = [
+  expandAdaptors,
+  adaptors,
+  jobPath,
+  logJson,
+  override(outputStdout, {
+    default: true
+  }),
+  outputPath,
+  useAdaptorsMonorepo
+];
 var compileCommand = {
   command: "compile [path]",
-  desc: "compile a openfn job and print or save the resulting js",
-  handler: (argv) => {
-    argv.command = "compile";
-  },
-  builder: (yargs2) => {
-    return applyExecuteOptions(yargs2).example(
-      "compile foo/job.js -O",
-      "Compiles foo/job.js and prints the result to stdout"
-    ).example(
-      "compile foo/job.js -o foo/job-compiled.js",
-      "Compiles foo/job.js and saves the result to foo/job-compiled.js"
-    );
-  }
+  desc: "Compile an openfn job and print or save the resulting JavaScript.",
+  handler: ensure("compile", options2),
+  builder: (yargs2) => build(options2, yargs2).positional("path", {
+    describe: "The path to load the job from (a .js file or a dir containing a job.js file)",
+    demandOption: true
+  }).example(
+    "compile foo/job.js -O",
+    "Compiles foo/job.js and prints the result to stdout"
+  ).example(
+    "compile foo/job.js -o foo/job-compiled.js",
+    "Compiles foo/job.js and saves the result to foo/job-compiled.js"
+  )
 };
 var command_default2 = compileCommand;
 
@@ -208,8 +411,29 @@ var command_default5 = {
   builder: (yargs2) => yargs2.example("docs common fn", "Print help for the common fn operation")
 };
 
+// src/metadata/command.ts
+var options3 = [
+  expandAdaptors,
+  adaptors,
+  force,
+  logJson,
+  repoDir,
+  statePath,
+  stateStdin,
+  useAdaptorsMonorepo
+];
+var command_default6 = {
+  command: "metadata",
+  desc: "Generate metadata for an adaptor config",
+  handler: ensure("metadata", options3),
+  builder: (yargs2) => build(options3, yargs2).example(
+    "metadata -a salesforce -s tmp/state.json",
+    "Generate salesforce metadata from config in state.json"
+  )
+};
+
 // src/cli.ts
-var cmd = yargs(hideBin(process.argv)).command(command_default).command(command_default2).command(install).command(repo).command(command_default3).command(command_default5).command(command_default4).option("log", {
+var cmd = yargs(hideBin(process.argv)).command(command_default).command(command_default2).command(install).command(repo).command(command_default3).command(command_default5).command(command_default6).command(command_default4).option("log", {
   alias: ["l"],
   description: "Set the default log level to none, default, info or debug",
   array: true

package/dist/process/runner.js

@@ -1,124 +1,19 @@
-// src/util/logger.ts
-import actualCreateLogger, { printDuration } from "@openfn/logger";
-import { isValidLogLevel, defaultLogger } from "@openfn/logger";
-var CLI = "cli";
-var COMPILER = "compiler";
-var RUNTIME = "runtime";
-var JOB = "job";
-var namespaces = {
-  [CLI]: "CLI",
-  [RUNTIME]: "R/T",
-  [COMPILER]: "CMP",
-  [JOB]: "JOB"
-};
-var createLogger = (name = "", options) => {
-  const logOptions = options.log || { json: true };
-  let level = logOptions[name] || logOptions.default || "default";
-  if (options.logJson) {
-    logOptions.json = true;
-  }
-  return actualCreateLogger(namespaces[name] || name, {
-    level,
-    ...logOptions
-  });
-};
-var logger_default = createLogger;
-var createNullLogger = () => createLogger(void 0, { log: { default: "none" } });
+import {
+  CLI,
+  COMPILER,
+  JOB,
+  RUNTIME,
+  createNullLogger,
+  defaultLogger,
+  ensureLogOpts,
+  ensureOpts,
+  expand_adaptors_default,
+  logger_default,
+  printDuration
+} from "../chunk-XYZNU5CH.js";
 
-// src/util/ensure-opts.ts
-import path from "node:path";
-var defaultLoggerOptions = {
-  default: "default",
-  job: "debug"
-};
-var ERROR_MESSAGE_LOG_LEVEL = "Unknown log level. Valid levels are none, debug, info and default.";
-var ERROR_MESSAGE_LOG_COMPONENT = "Unknown log component. Valid components are cli, compiler, runtime and job.";
-var DEFAULT_REPO_DIR = "/tmp/openfn/repo";
-var componentShorthands = {
-  cmp: "compiler",
-  rt: "runtime",
-  "r/t": "runtime"
-};
-var isValidComponent = (v) => /^(cli|runtime|compiler|job|default)$/i.test(v);
-var ensureLogOpts = (opts) => {
-  const components = {};
-  if (opts.command === "version" || opts.command === "test" && !opts.log) {
-    return { default: "info" };
-  }
-  if (opts.log) {
-    opts.log.forEach((l) => {
-      let component = "";
-      let level = "";
-      if (l.match(/=/)) {
-        const parts = l.split("=");
-        component = parts[0].toLowerCase();
-        if (componentShorthands[component]) {
-          component = componentShorthands[component];
-        }
-        level = parts[1].toLowerCase();
-      } else {
-        component = "default";
-        level = l.toLowerCase();
-      }
-      if (!isValidComponent(component)) {
-        throw new Error(ERROR_MESSAGE_LOG_COMPONENT);
-      }
-      level = level.toLowerCase();
-      if (!isValidLogLevel(level)) {
-        throw new Error(ERROR_MESSAGE_LOG_LEVEL);
-      }
-      components[component] = level;
-    });
-  }
-  return {
-    ...defaultLoggerOptions,
-    ...components
-  };
-};
-function ensureOpts(basePath = ".", opts) {
-  const newOpts = {
-    adaptor: opts.adaptor,
-    adaptors: opts.adaptors || [],
-    autoinstall: opts.autoinstall,
-    command: opts.command,
-    expand: opts.expand !== false,
-    force: opts.force || false,
-    immutable: opts.immutable || false,
-    logJson: typeof opts.logJson == "boolean" ? opts.logJson : Boolean(process.env.OPENFN_LOG_JSON),
-    noCompile: Boolean(opts.noCompile),
-    operation: opts.operation,
-    outputStdout: Boolean(opts.outputStdout),
-    packages: opts.packages,
-    repoDir: opts.repoDir || process.env.OPENFN_REPO_DIR || DEFAULT_REPO_DIR,
-    skipAdaptorValidation: opts.skipAdaptorValidation ?? false,
-    specifier: opts.specifier,
-    stateStdin: opts.stateStdin,
-    strictOutput: opts.strictOutput ?? true,
-    statePath: opts.statePath,
-    timeout: opts.timeout
-  };
-  const set = (key, value) => {
-    newOpts[key] = opts.hasOwnProperty(key) ? opts[key] : value;
-  };
-  if (opts.useAdaptorsMonorepo) {
-    newOpts.monorepoPath = process.env.OPENFN_ADAPTORS_REPO || "ERR";
-  }
-  let baseDir = basePath;
-  if (basePath.endsWith(".js")) {
-    baseDir = path.dirname(basePath);
-    set("jobPath", basePath);
-  } else {
-    set("jobPath", `${baseDir}/job.js`);
-  }
-  if (!opts.outputStdout) {
-    set(
-      "outputPath",
-      newOpts.command === "compile" ? `${baseDir}/output.js` : `${baseDir}/output.json`
-    );
-  }
-  newOpts.log = ensureLogOpts(opts);
-  return newOpts;
-}
+// src/execute/handler.ts
+import { readFile } from "node:fs/promises";
 
 // src/execute/load-state.ts
 import fs from "node:fs/promises";
@@ -150,7 +45,9 @@ var load_state_default = async (opts, log) => {
       log.warn(e);
     }
   }
-  log.info("No state provided - using default state { data: {}, configuration: {}");
+  log.info(
+    "No state provided - using default state { data: {}, configuration: {}"
+  );
   return {
     data: {},
     configuration: {}
@@ -190,25 +87,17 @@ function parseAdaptors(opts) {
 }
 
 // src/compile/compile.ts
-import fs2 from "node:fs/promises";
 import compile, { preloadAdaptorExports } from "@openfn/compiler";
 import { getModulePath } from "@openfn/runtime";
 var compile_default = async (opts, log) => {
   log.debug("Loading job...");
-  let job;
-  if (opts.noCompile) {
-    log.info("Skipping compilation as noCompile is set");
-    job = fs2.readFile(opts.jobPath, "utf8");
-    log.success(`Loaded job from ${opts.jobPath} (no compilation)`);
+  const compilerOptions = await loadTransformOptions(opts, log);
+  compilerOptions.logger = logger_default(COMPILER, opts);
+  const job = compile(opts.jobSource || opts.jobPath, compilerOptions);
+  if (opts.jobPath) {
+    log.success(`Compiled job from ${opts.jobPath}`);
   } else {
-    const complilerOptions = await loadTransformOptions(opts, log);
-    complilerOptions.logger = logger_default(COMPILER, opts);
-    job = compile(opts.jobSource || opts.jobPath, complilerOptions);
-    if (opts.jobPath) {
-      log.success(`Compiled job from ${opts.jobPath}`);
-    } else {
-      log.success("Compiled job");
-    }
+    log.success("Compiled job");
   }
   return job;
 };
@@ -302,19 +191,6 @@ var serialize_output_default = serializeOutput;
 import { exec } from "node:child_process";
 import treeify from "treeify";
 import { install as rtInstall, loadRepoPkg } from "@openfn/runtime";
-
-// src/util/expand-adaptors.ts
-var nullLogger = createNullLogger();
-var expand_adaptors_default = (names, log = nullLogger) => names?.map((name) => {
-  if (name.startsWith("@openfn/language-")) {
-    return name;
-  }
-  const expanded = `@openfn/language-${name}`;
-  log.debug(`Expanded adaptor ${name} to ${expanded}`);
-  return expanded;
-});
-
-// src/repo/handler.ts
 var install = async (opts, log = defaultLogger) => {
   let { packages, adaptor, repoDir } = opts;
   if (packages) {
@@ -322,7 +198,7 @@ var install = async (opts, log = defaultLogger) => {
     log.success("Installing packages...");
     log.debug("repoDir is set to:", repoDir);
     if (adaptor) {
-      packages = expand_adaptors_default(packages, log);
+      packages = expand_adaptors_default(packages);
     }
     await rtInstall(packages, repoDir, log);
     const duration = log.timer("install");
@@ -421,7 +297,16 @@ var executeHandler = async (options, logger) => {
     }
   }
   const state = await load_state_default(options, logger);
-  const code = await compile_default(options, logger);
+  let code = "";
+  if (options.compile) {
+    code = await compile_default(options, logger);
+  } else {
+    logger.info("Skipping compilation as noCompile is set");
+    if (options.jobPath) {
+      code = await readFile(options.jobPath, "utf8");
+      logger.success(`Loaded job from ${options.jobPath} (no compilation)`);
+    }
+  }
   try {
     const result = await execute_default(code, state, options);
     await serialize_output_default(options, result, logger);
@@ -454,6 +339,7 @@ var handler_default2 = compileHandler;
 var sillyMessage = "Calculating the answer to life, the universe, and everything...";
 var testHandler = async (options, logger) => {
   logger.log("Running test job...");
+  options.compile = true;
   options.jobSource = `const fn = () => state => { console.log('${sillyMessage}'); return state * 2; } ; fn()`;
   delete options.jobPath;
   if (!options.stateStdin) {
@@ -472,20 +358,20 @@ var handler_default3 = testHandler;
 // src/docgen/handler.ts
 import { writeFile as writeFile3 } from "node:fs/promises";
 import { readFileSync, writeFileSync, mkdirSync, rmSync } from "node:fs";
-import path2 from "node:path";
+import path from "node:path";
 import { describePackage } from "@openfn/describe-package";
 import { getNameAndVersion as getNameAndVersion2 } 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(path2.dirname(filePath), { recursive: true });
+var ensurePath = (filePath) => mkdirSync(path.dirname(filePath), { recursive: true });
 var generatePlaceholder = (path5) => {
   writeFileSync(path5, `{ "loading": true, "timestamp": ${Date.now()}}`);
 };
 var finish = (logger, resultPath) => {
   logger.success("Done! Docs can be found at:\n");
-  logger.print(`  ${path2.resolve(resultPath)}`);
+  logger.print(`  ${path.resolve(resultPath)}`);
 };
 var generateDocs = async (specifier, path5, docgen, logger) => {
   const result = await docgen(specifier);
@@ -565,7 +451,7 @@ var docgenHandler = (options, logger, docgen = actualDocGen, retryDuration = RET
 var handler_default4 = docgenHandler;
 
 // src/docs/handler.ts
-import { readFile } from "node:fs/promises";
+import { readFile as readFile2 } from "node:fs/promises";
 import { getNameAndVersion as getNameAndVersion3, getLatestVersion } from "@openfn/runtime";
 var describeFn = (adaptorName, fn) => `## ${fn.name}(${fn.parameters.map(({ name }) => name).join(",")})
 
@@ -611,7 +497,7 @@ var docsHandler = async (options, logger) => {
     createNullLogger()
   );
   if (path5) {
-    const source = await readFile(path5, "utf8");
+    const source = await readFile2(path5, "utf8");
     const data = JSON.parse(source);
     let desc;
     if (operation) {
@@ -632,14 +518,115 @@ var docsHandler = async (options, logger) => {
 };
 var handler_default5 = docsHandler;
 
+// src/metadata/cache.ts
+import { createHash } from "node:crypto";
+import { readFileSync as readFileSync2 } from "node:fs";
+import path2 from "node:path";
+import { writeFile as writeFile4, mkdir } from "node:fs/promises";
+var getPath = (repoDir, key) => `${repoDir}/meta/${key}.json`;
+var generateKey = (config) => createHash("sha256").update(JSON.stringify(config)).digest("hex");
+var get = (repoPath, key) => {
+  try {
+    const data = readFileSync2(getPath(repoPath, key));
+    const json = JSON.parse(data);
+    return json;
+  } catch (e) {
+    return null;
+  }
+};
+var set = async (repoPath, key, data) => {
+  const fullPath = getPath(repoPath, key);
+  await mkdir(path2.dirname(fullPath), { recursive: true });
+  await writeFile4(fullPath, JSON.stringify(data));
+};
+var cache_default = { get, set, generateKey, getPath };
+
+// src/metadata/handler.ts
+import { getModuleEntryPoint } from "@openfn/runtime";
+var decorateMetadata = (metadata) => {
+  metadata.created = new Date().toISOString();
+};
+var getAdaptorPath = async (adaptor, logger, repoDir) => {
+  let adaptorPath;
+  let adaptorSpecifier;
+  if (adaptor.match("=")) {
+    const parts = adaptor.split("=");
+    adaptorSpecifier = parts[0];
+    adaptorPath = parts[1];
+  } else {
+    if (adaptor.endsWith(".js")) {
+      return adaptor;
+    }
+    adaptorSpecifier = adaptor;
+    if (adaptor.startsWith("/")) {
+      adaptorPath = adaptor;
+    }
+  }
+  if (!adaptorPath || !adaptorPath.endsWith("js")) {
+    const entry = await getModuleEntryPoint(
+      adaptorSpecifier,
+      adaptorPath,
+      repoDir,
+      logger
+    );
+    adaptorPath = entry?.path;
+  }
+  logger.debug("loading adaptor from", adaptorPath);
+  return adaptorPath;
+};
+var metadataHandler = async (options, logger) => {
+  const { repoDir, adaptors } = options;
+  const adaptor = adaptors[0];
+  const state = await load_state_default(options, logger);
+  logger.success(`Generating metadata`);
+  const config = state.configuration;
+  logger.info("config:", config);
+  if (!config || Object.keys(config).length === 0) {
+    logger.error("ERROR: Invalid configuration passed");
+    process.exit(1);
+  }
+  const finish2 = () => {
+    logger.success("Done!");
+    logger.print(cache_default.getPath(repoDir, id));
+  };
+  const id = cache_default.generateKey(config);
+  if (!options.force) {
+    logger.debug("config hash: ", id);
+    const cached = await cache_default.get(repoDir, id);
+    if (cached) {
+      logger.success("Returning metadata from cache");
+      return finish2();
+    }
+  }
+  try {
+    const adaptorPath = await getAdaptorPath(adaptor, logger, options.repoDir);
+    const mod = await import(adaptorPath);
+    if (mod.metadata) {
+      logger.info("Metadata function found. Generating metadata...");
+      const result = await mod.metadata(config);
+      decorateMetadata(result);
+      await cache_default.set(repoDir, id, result);
+      finish2();
+    } else {
+      logger.error("No metadata helper found");
+      process.exit(1);
+    }
+  } catch (e) {
+    logger.error("Exception while generating metadata");
+    logger.error(e);
+    process.exit(1);
+  }
+};
+var handler_default6 = metadataHandler;
+
 // src/util/use-adaptors-repo.ts
-import { readFile as readFile2 } from "node:fs/promises";
+import { readFile as readFile3 } from "node:fs/promises";
 import path3 from "node:path";
 import assert from "node:assert";
 import { getNameAndVersion as getNameAndVersion4 } from "@openfn/runtime";
 var validateMonoRepo = async (repoPath, log) => {
   try {
-    const raw = await readFile2(`${repoPath}/package.json`, "utf8");
+    const raw = await readFile3(`${repoPath}/package.json`, "utf8");
     const pkg = JSON.parse(raw);
     assert(pkg.name === "adaptors");
   } catch (e) {
@@ -674,7 +661,7 @@ var useAdaptorsRepo = async (adaptors, repoPath, log) => {
 var use_adaptors_repo_default = useAdaptorsRepo;
 
 // src/util/print-versions.ts
-import { readFileSync as readFileSync2 } from "node:fs";
+import { readFileSync as readFileSync3 } from "node:fs";
 import path4 from "node:path";
 import { getNameAndVersion as getNameAndVersion5 } from "@openfn/runtime";
 import { mainSymbols } from "figures";
@@ -685,7 +672,7 @@ var COMPILER2 = "compiler";
 var { triangleRightSmall: t } = mainSymbols;
 var loadVersionFromPath = (adaptorPath) => {
   try {
-    const pkg = JSON.parse(readFileSync2(path4.resolve(adaptorPath, "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync3(path4.resolve(adaptorPath, "package.json"), "utf8"));
     return pkg.version;
   } catch (e) {
     return "unknown";
@@ -755,14 +742,16 @@ var handlers = {
   test: handler_default3,
   docgen: handler_default4,
   docs: handler_default5,
+  metadata: handler_default6,
   ["repo-clean"]: clean,
   ["repo-install"]: install,
   ["repo-pwd"]: pwd,
   ["repo-list"]: list,
   version: async (opts, logger) => print_versions_default(logger, opts)
 };
+var maybeEnsureOpts = (basePath, options) => /^(execute|compile)$/.test(options.command) ? ensureLogOpts(options) : ensureOpts(basePath, options);
 var parse = async (basePath, options, log) => {
-  const opts = ensureOpts(basePath, options);
+  const opts = maybeEnsureOpts(basePath, options);
   const logger = log || logger_default(CLI, opts);
   if (opts.command === "execute" || opts.command === "test") {
     await print_versions_default(logger, opts);
@@ -780,8 +769,8 @@ var parse = async (basePath, options, log) => {
       opts.monorepoPath,
       logger
     );
-  } else if (opts.adaptors && opts.expand) {
-    opts.adaptors = expand_adaptors_default(opts.adaptors, logger);
+  } else if (opts.adaptors && opts.expandAdaptors) {
+    opts.adaptors = expand_adaptors_default(opts.adaptors);
   }
   if (/^(test|version)$/.test(opts.command) && !opts.repoDir) {
     logger.warn(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openfn/cli",
-  "version": "0.0.30",
+  "version": "0.0.32",
   "description": "CLI devtools for the openfn toolchain.",
   "engines": {
     "node": ">=18",
@@ -41,10 +41,10 @@
     "rimraf": "^3.0.2",
     "treeify": "^1.1.0",
     "yargs": "^17.5.1",
-    "@openfn/compiler": "0.0.25",
+    "@openfn/compiler": "0.0.26",
     "@openfn/describe-package": "0.0.14",
-    "@openfn/runtime": "0.0.19",
-    "@openfn/logger": "0.0.10"
+    "@openfn/logger": "0.0.11",
+    "@openfn/runtime": "0.0.20"
   },
   "files": [
     "dist",