@openfn/cli 0.0.12 → 0.0.15

package/README.md

@@ -5,8 +5,8 @@ This package contains a new devtools CLI.
 The CLI allows you to
 
 - Run a job (expression), writing output to disk or stdout
-- ~~Compile a job~~ (coming soon)
-- ~~Validate a job~~ (coming soon)
+- Compile a job
+- Install modules for jobs
 - Use local language adaptors to run the job
 
 The CLI reads a path as its main argument. That path should either point to a .js file or a folder.
@@ -30,15 +30,40 @@ $ openfn --help
 $ openfn path/to/expression.js`
 ```
 
-## legacy Jobs failing?
+## Language Adaptors
 
-If legacy jobs ar failing because adaptor functions aren't found, you need to tell the CLI which adaptor to use. It will then auto-insert import statements for you.
+The old engine used to compile knowlede of langauge adaptors into the job file. We no longer do this.
 
+Generally the new runtime prefers to explictly import all dependencies - although the compiler will auto-insert imports from a given adaptor for you.
+
+You need to pass the name of an adaptor for the runtime to use. It will auto-insert an import statement for you.
+
+```
+$ openfn job.js -a commmon
+```
+
+You can use a short-hand name, like above, but longform names also work:
 ```
 $ openfn job.js -a @openfn/language-commmon
 ```
 
-There's more detail in this further down in the readme.
+You can pass an explicit version number too:
+
+```
+$ openfn job.js -a commmon@1.7.3
+```
+
+The adaptor also needs to be installed in the CLI's module repo. You can do this manually:
+
+```
+$ openfn install commmon
+```
+If no version is provided, the latest will be installed. Again, long and short-form names can be used.
+
+Alternatively, pass the -i flag when running a job (it's safe to do this redundantly):
+```
+$ openfn job.js -i -a @openfn/language-commmon
+```
 
 ## Usage from this repo
 
@@ -61,36 +86,20 @@ $ npm install -g .
 
 Note that this will install the built source from `dist`
 
-## Current state
-
-For legacy jobs (ie, jobs without explicit imports), the new runtime is only compatible with language adaptors with type definitions.
-
-Right now, that means @openfn/language-common@2.0.0-rc3.
-
-## Getting Started
+## Repo Directory
 
-Here's how I recommend getting set up:
+The CLI will save and load adaptors from an arbitrary folder on your system.
 
-- Create a folder for next-gen language adaptors somewhere on your machine
-
-```
-$ mkdir -p ~/adaptors/@openfn
-```
-
-- Clone `language-common` into that folder
-
-```
-git clone https://github.com/OpenFn/language-common.git ~/adaptors/@openfn --branch 2.0.0-pre
-```
-
-- Set your `OPENFN_MODULES_HOME` environment variable to point to the next-gen adaptors folder. This will tell the CLI to load adaptors from this folder by default.
+You should set the OPENFN_REPO_DIR env var to something sensible.
 
 ```
 # In ~/.bashc or whatever
-export OPENFN_MODULES_HOME=~/adaptors/@openfn
+export OPENFN_REPO_DIR=~/adaptors/@openfn
 ```
 
-This will improve in future, as we implement automatic module loading and add type definitions to the published adaptor packages.
+At the time of writing, teh env var name is about to change. Soon you will be able to pass the repo dir into the command line, but the env var is a much easier way to work.
+
+Monorepo support is coming soon.
 
 ## Automatic Imports
 
@@ -106,21 +115,3 @@ $ openfn job.js --adaptors @openfn/language-http=path/to/adaptor
 If a path is passed (relative to the working directory), that path will be used to load a local version of the adaptor (both at runtime and for import generation)
 
 If no path is passed, the currently deployed npm package will be used.
-
-## Notes on Module Resolution
-
-Any import statements inside a job have to resolve to a node module.
-
-A module can be resolved:
-
-- Relative to the env var OPENFN_MODULE_HOME
-- Relative to CLI's node_modules
-- Relative to global node_modules
-
-Basically, to work with adaptors, you should:
-
-- Save your adaptors globally
-
-Or
-
-- Save adaptors to a folder somewhere (~/openfn) and set OPENFN_MODULE_HOME=~/openfn

package/dist/index.js

@@ -24,27 +24,100 @@ function spawn_default(basePath, opts2) {
 // src/cli.ts
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
-var cmd = yargs(hideBin(process.argv)).command("[path]", "Run the job at the path").command("--test", "Run a trivial test job with no disk I/O").example("openfn path/to/dir", "Looks for job.js, state.json in path/to/dir").example(
-  "openfn foo/job.js",
-  "Reads foo/job.js, looks for state and output in foo"
-).example(
-  "openfn job.js -adaptor @openfn/language-common",
-  "Run job.js with automatic imports from the commmon language adaptor"
-).example(
-  "openfn job.js -adaptor @openfn/language-common=repo/openfn/language-common",
-  "Run job.js with a local implementation of the common language adaptor"
-).example("openfn foo/job.js -c", "Compile a job to foo/output/js").example("openfn foo/job.js -cO", "Compile a job to stdout").example(
-  "openfn foo/job.js --log debug",
-  "Run a job with debug-level logging"
-).example(
-  "openfn foo/job.js --log compiler=debug",
-  "Use debug logging in the compiler only"
-).positional("path", {
+
+// src/repo/command.ts
+var repo = {
+  command: "repo [subcommand]",
+  desc: "Run commands on the module repo (install|clean)",
+  builder: (yargs2) => yargs2.command(clean).command(install).command(pwd).command(list).example("repo install -a http", "Install @openfn/language-http").example("repo clean", "Remove everything from the repo working dir").example("repo pwd", "Print the current repo working dir")
+};
+var install = {
+  command: "install [packages...]",
+  desc: "install one or more packages to the runtime repo",
+  handler: (argv) => {
+    argv.command = "repo-install";
+  },
+  builder: (yargs2) => {
+    return yargs2.option("adaptor", {
+      alias: ["a"],
+      description: "Install an adaptor by passing a shortened version of the name",
+      boolean: true
+    }).example("install axios", "Install the axios npm package to the repo").example(
+      "install -a http",
+      "Install @openfn/language-http adaptor to the repo"
+    ).example(
+      "install @openfn/language-http",
+      "Install the language-http adaptor to the repo"
+    );
+  }
+};
+var clean = {
+  command: "clean",
+  desc: "Removes all modules from the runtime module repo",
+  handler: (argv) => {
+    argv.command = "repo-clean";
+  },
+  builder: (yargs2) => yargs2.option("force", {
+    alias: ["f"],
+    description: "Skip the prompt and force deletion",
+    boolean: true
+  })
+};
+var pwd = {
+  command: "pwd",
+  desc: "Print repo's current working directory",
+  handler: (argv) => {
+    argv.command = "repo-pwd";
+  }
+};
+var list = {
+  command: "list",
+  desc: "Show a report on what is installed in the repo",
+  handler: (argv) => {
+    argv.command = "repo-list";
+  }
+};
+
+// src/execute/command.ts
+var executeCommand = {
+  command: "execute [path]",
+  desc: "Run an openfn job",
+  aliases: ["$0"],
+  handler: (argv) => {
+    argv.command = "execute";
+  },
+  builder: (yargs2) => {
+    return applyExecuteOptions(yargs2).option("immutable", {
+      boolean: true,
+      description: "Treat state as immutable"
+    }).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("no-compile", {
+      boolean: true,
+      description: "Skip compilation"
+    }).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("test", {
-  description: "Run a test job to exercise the installation. Pass a number via -S to multiply by 2.",
-  boolean: true
 }).option("output-path", {
   alias: "o",
   description: "Path to the output file"
@@ -52,39 +125,55 @@ var cmd = yargs(hideBin(process.argv)).command("[path]", "Run the job at the pat
   alias: "O",
   boolean: true,
   description: "Print output to stdout (intead of a file)"
-}).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("no-validation", {
-  boolean: true,
-  description: "Skip validation"
-}).option("compile-only", {
-  alias: "c",
-  boolean: true,
-  description: "Compile the job but don't execute it. State is written to output.js or returned to console if -O is set."
-}).option("no-compile", {
-  boolean: true,
-  description: "Skip compilation"
-}).option("immutable", {
-  boolean: true,
-  description: "Treat state as immutable"
 }).option("adaptors", {
   alias: ["a", "adaptor"],
-  description: "Pass one or more adaptors in the form name=path/to/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("trace-linker", {
-  alias: ["t", "trace"],
-  description: "Trace module resolution output in the linker",
+}).option("no-expand", {
+  description: "Don	 attempt to auto-expand adaptor shorthand names",
   boolean: true
-}).option("log", {
+});
+var command_default = executeCommand;
+
+// src/compile/command.ts
+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"
+    );
+  }
+};
+var command_default2 = compileCommand;
+
+// src/test/command.ts
+var command_default3 = {
+  command: "test",
+  desc: "Compiles and runs a test job, printing the result to stdout",
+  handler: (argv) => {
+    argv.command = "test";
+  },
+  builder: (yargs2) => yargs2.option("state-stdin", {
+    alias: "S",
+    description: "Read state from stdin (instead of a file)"
+  }).example("test", "run the test script").example("test -S 42", "run the test script with state 42")
+};
+
+// src/cli.ts
+var cmd = yargs(hideBin(process.argv)).command(command_default).command(command_default2).command(install).command(repo).command(command_default3).option("log", {
   alias: ["l"],
-  description: "Set the default log level to none, trace, info or default",
+  description: "Set the default log level to none, default, info or debug",
   array: true
-}).alias("v", "version");
+}).alias("v", "version").help();
 
 // src/index.ts
 var opts = cmd.parse();
-spawn_default(opts._[0], opts);
+spawn_default(opts.path, opts);

package/dist/process/runner.js

@@ -1,8 +1,6 @@
-// src/commands.ts
-import fs3 from "node:fs/promises";
-
 // 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";
@@ -26,13 +24,13 @@ var createNullLogger = () => createLogger(void 0, { log: { default: "none" } });
 
 // src/util/ensure-opts.ts
 import path from "node:path";
-import { isValidLogLevel } from "@openfn/logger";
 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",
@@ -65,8 +63,6 @@ var ensureLogOpts = (opts) => {
       }
       components[component] = level;
     });
-  } else if (opts.test) {
-    components.default = "info";
   }
   return {
     ...defaultLoggerOptions,
@@ -75,12 +71,17 @@ var ensureLogOpts = (opts) => {
 };
 function ensureOpts(basePath = ".", opts) {
   const newOpts = {
-    compileOnly: Boolean(opts.compileOnly),
-    modulesHome: opts.modulesHome || process.env.OPENFN_MODULES_HOME,
+    adaptor: opts.adaptor,
+    adaptors: opts.adaptors || [],
+    autoinstall: opts.autoinstall,
+    command: opts.command,
+    force: opts.force || false,
+    repoDir: opts.repoDir || process.env.OPENFN_REPO_DIR || DEFAULT_REPO_DIR,
     noCompile: Boolean(opts.noCompile),
+    expand: opts.expand !== false,
     outputStdout: Boolean(opts.outputStdout),
+    packages: opts.packages,
     stateStdin: opts.stateStdin,
-    test: opts.test,
     immutable: opts.immutable || false
   };
   const set = (key, value) => {
@@ -97,80 +98,18 @@ function ensureOpts(basePath = ".", opts) {
   if (!opts.outputStdout) {
     set(
       "outputPath",
-      newOpts.compileOnly ? `${baseDir}/output.js` : `${baseDir}/output.json`
+      newOpts.command === "compile" ? `${baseDir}/output.js` : `${baseDir}/output.json`
     );
   }
   newOpts.log = ensureLogOpts(opts);
-  if (opts.adaptors) {
-    newOpts.adaptors = opts.adaptors;
-  }
   return newOpts;
 }
 
-// src/compile/compile.ts
-import fs from "node:fs/promises";
-import compile, { preloadAdaptorExports } from "@openfn/compiler";
-var compile_default = async (opts, log) => {
-  log.debug("Loading job...");
-  let job;
-  if (opts.noCompile) {
-    log.info("Skipping compilation as noCompile is set");
-    job = fs.readFile(opts.jobPath, "utf8");
-    log.success(`Loaded job from ${opts.jobPath} (no compilation)`);
-  } else {
-    const complilerOptions = await loadTransformOptions(opts, log);
-    complilerOptions.logger = logger_default(COMPILER, opts);
-    job = compile(opts.jobPath, complilerOptions);
-    log.success(`Compiled job from ${opts.jobPath}`);
-  }
-  return job;
-};
-var stripVersionSpecifier = (specifier) => {
-  const idx = specifier.lastIndexOf("@");
-  if (idx > 0) {
-    return specifier.substring(0, idx);
-  }
-  return specifier;
-};
-var loadTransformOptions = async (opts, log) => {
-  const options = {
-    logger: log
-  };
-  if (opts.adaptors) {
-    const [pattern] = opts.adaptors;
-    const [specifier, path2] = pattern.split("=");
-    const doPreload = async (path3, logError = true) => {
-      try {
-        const result = await preloadAdaptorExports(path3);
-        if (result) {
-          log.info(`Pre-loaded typedefs for ${specifier} from ${path3}`);
-        }
-        return result;
-      } catch (e) {
-        if (logError) {
-          log.error(`Failed to load adaptor typedefs from path ${path3}`);
-          log.error(e);
-        }
-      }
-    };
-    const exports = path2 && await doPreload(path2) || opts.modulesHome && await doPreload(`${opts.modulesHome}/${specifier}`, false) || await doPreload(specifier) || [];
-    if (exports.length === 0) {
-      console.warn(`WARNING: no module exports loaded for ${pattern}`);
-      console.log("         automatic imports will be skipped");
-    }
-    options["add-imports"] = {
-      adaptor: {
-        name: stripVersionSpecifier(specifier),
-        exports,
-        exportAll: true
-      }
-    };
-  }
-  return options;
-};
+// src/execute/handler.ts
+import { writeFile } from "node:fs/promises";
 
 // src/execute/load-state.ts
-import fs2 from "node:fs/promises";
+import fs from "node:fs/promises";
 var load_state_default = async (opts, log) => {
   log.debug("Load state...");
   if (opts.stateStdin) {
@@ -187,7 +126,7 @@ var load_state_default = async (opts, log) => {
     }
   }
   try {
-    const str = await fs2.readFile(opts.statePath, "utf8");
+    const str = await fs.readFile(opts.statePath, "utf8");
     const json = JSON.parse(str);
     log.success(`Loaded state from ${opts.statePath}`);
     log.debug("state:", json);
@@ -204,55 +143,205 @@ var load_state_default = async (opts, log) => {
 };
 
 // src/execute/execute.ts
-import run from "@openfn/runtime";
+import run, { getNameAndVersion } from "@openfn/runtime";
 var execute_default = (code, state, opts) => {
   return run(code, state, {
     immutableState: opts.immutable,
     logger: logger_default(RUNTIME, opts),
     jobLogger: logger_default(JOB, opts),
     linker: {
-      modulesHome: opts.modulesHome,
-      modulePaths: parseAdaptors(opts)
+      repo: opts.repoDir,
+      modules: parseAdaptors(opts)
     }
   });
 };
 function parseAdaptors(opts) {
-  var _a;
   const adaptors = {};
-  (_a = opts.adaptors) == null ? void 0 : _a.reduce((obj, exp) => {
+  opts.adaptors.reduce((obj, exp) => {
     const [module, path2] = exp.split("=");
-    obj[module] = path2;
+    const { name, version } = getNameAndVersion(module);
+    const info = {};
+    if (path2) {
+      info.path = path2;
+    }
+    if (version) {
+      info.version = version;
+    }
+    obj[name] = info;
     return obj;
   }, adaptors);
   return adaptors;
 }
 
-// src/commands.ts
-var parse = async (basePath, options, log) => {
-  const opts = ensureOpts(basePath, options);
-  const logger = log || logger_default(CLI, opts);
-  if (opts.test) {
-    return runTest(opts, logger);
+// 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)`);
+  } else {
+    const complilerOptions = await loadTransformOptions(opts, log);
+    complilerOptions.logger = logger_default(COMPILER, opts);
+    job = compile(opts.jobPath, complilerOptions);
+    if (opts.jobPath) {
+      log.success(`Compiled job from ${opts.jobPath}`);
+    } else {
+      log.success("Compiled job");
+    }
   }
-  assertPath(basePath);
-  if (opts.compileOnly) {
-    return runCompile(opts, logger);
+  return job;
+};
+var stripVersionSpecifier = (specifier) => {
+  const idx = specifier.lastIndexOf("@");
+  if (idx > 0) {
+    return specifier.substring(0, idx);
   }
-  return runExecute(opts, logger);
+  return specifier;
 };
-var commands_default = parse;
-var assertPath = (basePath) => {
-  if (!basePath) {
-    console.error("ERROR: no path provided!");
-    console.error("\nUsage:");
-    console.error("  open path/to/job");
-    console.error("\nFor more help do:");
-    console.error("  openfn --help ");
-    process.exit(1);
+var resolveSpecifierPath = async (pattern, repoDir, log) => {
+  const [specifier, path2] = pattern.split("=");
+  if (path2) {
+    log.debug(`Resolved ${specifier} to path: ${path2}`);
+    return path2;
+  }
+  const repoPath = await getModulePath(specifier, repoDir, log);
+  if (repoPath) {
+    return repoPath;
+  }
+  return null;
+};
+var loadTransformOptions = async (opts, log) => {
+  var _a;
+  const options = {
+    logger: log
+  };
+  if ((_a = opts.adaptors) == null ? void 0 : _a.length) {
+    let exports;
+    const [pattern] = opts.adaptors;
+    const [specifier] = pattern.split("=");
+    log.debug(`Attempting to preload typedefs for ${specifier}`);
+    const path2 = await resolveSpecifierPath(pattern, opts.repoDir, log);
+    if (path2) {
+      try {
+        exports = await preloadAdaptorExports(path2);
+        if (exports) {
+          log.info(`Loaded typedefs for ${specifier}`);
+        }
+      } catch (e) {
+        log.error(`Failed to load adaptor typedefs from path ${path2}`);
+        log.error(e);
+      }
+    }
+    if (!exports || exports.length === 0) {
+      log.debug(`No module exports found for ${pattern}`);
+    }
+    options["add-imports"] = {
+      adaptor: {
+        name: stripVersionSpecifier(specifier),
+        exports,
+        exportAll: true
+      }
+    };
   }
+  return options;
+};
+
+// src/repo/handler.ts
+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 == null ? void 0 : names.map((name) => {
+  if (name.startsWith("@openfn/language-")) {
+    return name;
+  }
+  const expanded = `@openfn/language-${name}`;
+  log.info(`Expanded adaptor ${name} to ${expanded}`);
+  return expanded;
+});
+
+// src/repo/handler.ts
+var install = async (opts, log = defaultLogger) => {
+  log.timer("install");
+  let { packages, adaptor, repoDir } = opts;
+  log.success("Installing packages...");
+  if (packages) {
+    log.debug("repoDir is set to:", repoDir);
+    if (adaptor) {
+      packages = expand_adaptors_default(packages, log);
+    }
+    await rtInstall(packages, repoDir, log);
+  }
+  const duration = log.timer("install");
+  log.success(`Installation complete in ${duration}`);
 };
-var runExecute = async (options, logger) => {
+var clean = async (options, logger) => {
+  if (options.repoDir) {
+    const doIt = await logger.confirm(
+      `This will remove everything at ${options.repoDir}. Do you wish to proceed?`,
+      options.force
+    );
+    if (doIt) {
+      return new Promise((resolve) => {
+        logger.info(`Cleaning repo at ${options.repoDir} `);
+        exec(`npm exec rimraf ${options.repoDir}`, () => {
+          logger.success("Repo cleaned");
+          resolve();
+        });
+      });
+    }
+  } else {
+    logger.error("Clean failed");
+    logger.error("No repoDir path detected");
+  }
+};
+var pwd = async (options, logger) => {
+  logger.info(`OPENFN_REPO_DIR is set to ${process.env.OPENFN_REPO_DIR}`);
+  logger.success(`Repo working directory is: ${options.repoDir}`);
+};
+var getDependencyList = async (options, _logger) => {
+  const pkg = await loadRepoPkg(options.repoDir);
+  const result = {};
+  if (pkg) {
+    Object.keys(pkg.dependencies).forEach((key) => {
+      const [name, version] = key.split("_");
+      if (!result[name]) {
+        result[name] = [];
+      }
+      result[name].push(version);
+    });
+  }
+  return result;
+};
+var list = async (options, logger) => {
+  const tree = await getDependencyList(options, logger);
+  await pwd(options, logger);
+  const output = {};
+  Object.keys(tree).forEach((key) => {
+    const versions = tree[key];
+    output[key] = {};
+    versions.forEach((v) => {
+      output[key][v] = null;
+    });
+  });
+  logger.success("Installed packages:\n\n" + treeify.asTree(output));
+};
+
+// src/execute/handler.ts
+var executeHandler = async (options, logger) => {
   const start = new Date().getTime();
+  if (options.autoinstall) {
+    const { repoDir } = options;
+    logger.info("Auto-installing language adaptors");
+    await install({ packages: options.adaptors, repoDir }, logger);
+  }
   const state = await load_state_default(options, logger);
   const code = await compile_default(options, logger);
   const result = await execute_default(code, state, options);
@@ -261,22 +350,29 @@ var runExecute = async (options, logger) => {
     logger.success(result);
   } else {
     logger.success(`Writing output to ${options.outputPath}`);
-    await fs3.writeFile(options.outputPath, JSON.stringify(result, null, 4));
+    await writeFile(options.outputPath, JSON.stringify(result, null, 4));
   }
   const duration = printDuration(new Date().getTime() - start);
   logger.success(`Done in ${duration}! \u2728`);
 };
-var runCompile = async (options, logger) => {
+var handler_default = executeHandler;
+
+// src/compile/handler.ts
+import { writeFile as writeFile2 } from "node:fs/promises";
+var compileHandler = async (options, logger) => {
   const code = await compile_default(options, logger);
   if (options.outputStdout) {
     logger.success("Compiled code:");
-    console.log(code);
+    logger.success("\n" + code);
   } else {
-    await fs3.writeFile(options.outputPath, code);
+    await writeFile2(options.outputPath, code);
     logger.success(`Compiled to ${options.outputPath}`);
   }
 };
-var runTest = async (options, logger) => {
+var handler_default2 = compileHandler;
+
+// src/test/handler.ts
+var testHandler = async (options, logger) => {
   logger.log("Running test job...");
   options.jobPath = `const fn = () => state => state * 2; fn()`;
   if (!options.stateStdin) {
@@ -294,6 +390,62 @@ var runTest = async (options, logger) => {
   logger.success(`Result: ${result}`);
   return result;
 };
+var handler_default3 = testHandler;
+
+// src/commands.ts
+var parse = async (basePath, options, log) => {
+  const opts = ensureOpts(basePath, options);
+  const logger = log || logger_default(CLI, opts);
+  if (opts.adaptors && opts.expand) {
+    opts.adaptors = expand_adaptors_default(opts.adaptors, logger);
+  }
+  if (opts.command == "test" && !opts.repoDir) {
+    logger.warn(
+      "WARNING: no repo module dir found! Using the default (/tmp/repo)"
+    );
+    logger.warn(
+      "You should set OPENFN_REPO_DIR or pass --repoDir=some/path in to the CLI"
+    );
+  }
+  let handler = () => null;
+  switch (options.command) {
+    case "repo-install":
+      handler = install;
+      break;
+    case "repo-clean":
+      handler = clean;
+      break;
+    case "repo-pwd":
+      handler = pwd;
+      break;
+    case "repo-list":
+      handler = list;
+      break;
+    case "compile":
+      assertPath(basePath);
+      handler = handler_default2;
+      break;
+    case "test":
+      handler = handler_default3;
+      break;
+    case "execute":
+    default:
+      assertPath(basePath);
+      handler = handler_default;
+  }
+  return handler(opts, logger);
+};
+var commands_default = parse;
+var assertPath = (basePath) => {
+  if (!basePath) {
+    console.error("ERROR: no path provided!");
+    console.error("\nUsage:");
+    console.error("  open path/to/job");
+    console.error("\nFor more help do:");
+    console.error("  openfn --help ");
+    process.exit(1);
+  }
+};
 
 // src/process/runner.ts
 process.on("message", ({ init, basePath, opts }) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openfn/cli",
-  "version": "0.0.12",
+  "version": "0.0.15",
   "description": "CLI devtools for the openfn toolchain.",
   "engines": {
     "node": ">=16",
@@ -36,9 +36,11 @@
     "typescript": "^4.7.4"
   },
   "dependencies": {
-    "@openfn/compiler": "^0.0.11",
-    "@openfn/runtime": "^0.0.9",
-    "@openfn/logger": "^0.0.4",
+    "@openfn/compiler": "^0.0.14",
+    "@openfn/logger": "^0.0.6",
+    "@openfn/runtime": "^0.0.11",
+    "rimraf": "^3.0.2",
+    "treeify": "^1.1.0",
     "yargs": "^17.5.1"
   },
   "files": [