@openfn/cli 0.0.11 → 0.0.14

package/dist/process/runner.js

@@ -1,364 +1,447 @@
-import fs from 'node:fs/promises';
-import actualCreateLogger, { isValidLogLevel, printDuration } from '@openfn/logger';
-import path from 'node:path';
-import compile$1, { preloadAdaptorExports } from '@openfn/compiler';
-import run from '@openfn/runtime';
-
-// Wrapper around the logger API to load a namespaced logger with the right options
-// All known loggers
-const CLI = 'cli';
-const COMPILER = 'compiler';
-const RUNTIME = 'runtime';
-const JOB = 'job';
-const namespaces = {
-    [CLI]: 'CLI',
-    [RUNTIME]: 'R/T',
-    [COMPILER]: 'CMP',
-    [JOB]: 'JOB'
+// 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"
 };
-const createLogger = (name = '', options) => {
-    const logOptions = options.log || {};
-    let level = logOptions[name] || logOptions.default || 'default';
-    return actualCreateLogger(namespaces[name] || name, {
-        level,
-        ...logOptions,
-    });
+var createLogger = (name = "", options) => {
+  const logOptions = options.log || {};
+  let level = logOptions[name] || logOptions.default || "default";
+  return actualCreateLogger(namespaces[name] || name, {
+    level,
+    ...logOptions
+  });
 };
-const createNullLogger = () => createLogger(undefined, { log: { default: 'none' } });
+var logger_default = createLogger;
+var createNullLogger = () => createLogger(void 0, { log: { default: "none" } });
 
-const defaultLoggerOptions = {
-    default: 'default',
-    //  TODO fix to lower case
-    job: 'debug',
+// src/util/ensure-opts.ts
+import path from "node:path";
+var defaultLoggerOptions = {
+  default: "default",
+  job: "debug"
 };
-const ERROR_MESSAGE_LOG_LEVEL = 'Unknown log level. Valid levels are none, debug, info and default.';
-const ERROR_MESSAGE_LOG_COMPONENT = 'Unknown log component. Valid components are cli, compiler, runtime and job.';
-const componentShorthands = {
-    cmp: 'compiler',
-    rt: 'runtime',
-    'r/t': 'runtime',
+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 componentShorthands = {
+  cmp: "compiler",
+  rt: "runtime",
+  "r/t": "runtime"
 };
-// TODO what about shorthands? 
-const isValidComponent = (v) => /^(cli|runtime|compiler|job|default)$/i.test(v);
-const ensureLogOpts = (opts) => {
-    const components = {};
-    if (opts.log) {
-        // Parse and validate each incoming log argument
-        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)) {
-                // TODO need to think about how the CLI frontend handles these errors
-                // But this is fine for now
-                throw new Error(ERROR_MESSAGE_LOG_LEVEL);
-            }
-            components[component] = level;
-        });
-        // TODO what if other log options are passed? Not really a concern right now
-    }
-    else if (opts.test) {
-        // In test mode, log at info level by default
-        components.default = 'info';
-    }
-    return {
-        ...defaultLoggerOptions,
-        ...components,
-    };
+var isValidComponent = (v) => /^(cli|runtime|compiler|job|default)$/i.test(v);
+var ensureLogOpts = (opts) => {
+  const components = {};
+  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 = {
-        compileOnly: Boolean(opts.compileOnly),
-        modulesHome: opts.modulesHome || process.env.OPENFN_MODULES_HOME,
-        noCompile: Boolean(opts.noCompile),
-        outputStdout: Boolean(opts.outputStdout),
-        stateStdin: opts.stateStdin,
-        test: opts.test,
-    };
-    const set = (key, value) => {
-        // @ts-ignore TODO
-        newOpts[key] = opts.hasOwnProperty(key) ? opts[key] : value;
-    };
-    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.compileOnly ? `${baseDir}/output.js` : `${baseDir}/output.json`);
-    }
-    newOpts.log = ensureLogOpts(opts);
-    // TODO if no adaptor is provided, default to language common
-    // Should we go further and bundle language-common?
-    // But 90% of jobs use something else. Better to use auto loading.
-    if (opts.adaptors) {
-        newOpts.adaptors = opts.adaptors;
-        // newOpts.adaptors = opts.adaptors.map((adaptor) => {
-        //   if (!adaptor.startsWith('@openfn/')) {
-        //     return `@openfn/${adaptor}`
-        //   }
-        //   return adaptor
-        // });
-    }
-    return newOpts;
+function ensureOpts(basePath = ".", opts) {
+  const newOpts = {
+    adaptor: opts.adaptor,
+    adaptors: opts.adaptors,
+    autoinstall: opts.autoinstall,
+    command: opts.command,
+    force: opts.force || false,
+    repoDir: opts.repoDir || process.env.OPENFN_REPO_DIR,
+    noCompile: Boolean(opts.noCompile),
+    expand: Boolean(opts.expand),
+    outputStdout: Boolean(opts.outputStdout),
+    packages: opts.packages,
+    stateStdin: opts.stateStdin,
+    immutable: opts.immutable || false
+  };
+  const set = (key, value) => {
+    newOpts[key] = opts.hasOwnProperty(key) ? opts[key] : value;
+  };
+  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`
+    );
+  }
+  newOpts.log = ensureLogOpts(opts);
+  return newOpts;
 }
 
-// Load and compile a job from a file
-var compile = 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 = createLogger(COMPILER, opts);
-        job = compile$1(opts.jobPath, complilerOptions);
-        log.success(`Compiled job from ${opts.jobPath}`);
+// src/execute/handler.ts
+import { writeFile } from "node:fs/promises";
+
+// src/execute/load-state.ts
+import fs from "node:fs/promises";
+var load_state_default = async (opts, log) => {
+  log.debug("Load state...");
+  if (opts.stateStdin) {
+    try {
+      const json = JSON.parse(opts.stateStdin);
+      log.success("Read state from stdin");
+      log.debug("state:", json);
+      return json;
+    } catch (e) {
+      log.error("Failed to load state from stdin");
+      log.error(opts.stateStdin);
+      log.error(e);
+      process.exit(1);
     }
-    return job;
+  }
+  try {
+    const str = await fs.readFile(opts.statePath, "utf8");
+    const json = JSON.parse(str);
+    log.success(`Loaded state from ${opts.statePath}`);
+    log.debug("state:", json);
+    return json;
+  } catch (e) {
+    log.warn(`Error loading state from ${opts.statePath}`);
+    log.warn(e);
+  }
+  log.warn("Using default state { data: {}, configuration: {}");
+  return {
+    data: {},
+    configuration: {}
+  };
 };
-// TODO this is a bit of a temporary solution
-// Adaptors need a version specifier right now to load type definitions for auto import
-// But that specifier must be excluded in the actual import by the adaptor
-const stripVersionSpecifier = (specifier) => {
-    const idx = specifier.lastIndexOf('@');
-    if (idx > 0) {
-        return specifier.substring(0, idx);
+
+// src/execute/execute.ts
+import run 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: {
+      repo: opts.repoDir,
+      modulePaths: parseAdaptors(opts)
     }
-    return specifier;
+  });
 };
-// Mutate the opts object to write export information for the add-imports transformer
-const loadTransformOptions = async (opts, log) => {
-    const options = {
-        logger: log
-    };
-    // If an adaptor is passed in, we need to look up its declared exports
-    // and pass them along to the compiler
-    if (opts.adaptors) {
-        const [pattern] = opts.adaptors; // TODO add-imports only takes on adaptor, but the cli can take multiple
-        const [specifier, path] = pattern.split('=');
-        // Preload exports from a path, optionally logging errors in case of a failure
-        const doPreload = async (path, logError = true) => {
-            try {
-                const result = await preloadAdaptorExports(path);
-                if (result) {
-                    log.info(`Pre-loaded typedefs for ${specifier} from ${path}`);
-                }
-                return result;
-            }
-            catch (e) {
-                if (logError) {
-                    log.error(`Failed to load adaptor typedefs from path ${path}`);
-                    log.error(e);
-                }
-            }
-        };
-        // TODO need better trace/debug output on this I think
-        // Looking up the adaptor's type definition is complex. In this order, we should use:
-        const exports = 
-        // 1) An explicit file path
-        (path && await doPreload(path)) ||
-            // 2) A module defined in the opts.modulesHome folder
-            (opts.modulesHome && await doPreload(`${opts.modulesHome}/${specifier}`, false)) ||
-            // 3) An npm module specifier
-            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,
-            }
-        };
+function parseAdaptors(opts) {
+  var _a;
+  const adaptors = {};
+  (_a = opts.adaptors) == null ? void 0 : _a.reduce((obj, exp) => {
+    const [module, path2] = exp.split("=");
+    obj[module] = path2;
+    return obj;
+  }, adaptors);
+  return adaptors;
+}
+
+// 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");
     }
-    return options;
+  }
+  return job;
 };
-
-var loadState = async (opts, log) => {
-    log.debug('Load state...');
-    if (opts.stateStdin) {
-        try {
-            const json = JSON.parse(opts.stateStdin);
-            log.success('Read state from stdin');
-            log.debug('state:', json);
-            return json;
-        }
-        catch (e) {
-            log.error("Failed to load state from stdin");
-            log.error(opts.stateStdin);
-            log.error(e);
-            process.exit(1);
+var stripVersionSpecifier = (specifier) => {
+  const idx = specifier.lastIndexOf("@");
+  if (idx > 0) {
+    return specifier.substring(0, idx);
+  }
+  return specifier;
+};
+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);
+  if (repoPath) {
+    log.debug(`Resolved ${specifier} to repo module`);
+    return repoPath;
+  }
+  return null;
+};
+var loadTransformOptions = async (opts, log) => {
+  const options = {
+    logger: log
+  };
+  if (opts.adaptors) {
+    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);
+      }
     }
-    try {
-        const str = await fs.readFile(opts.statePath, 'utf8');
-        const json = JSON.parse(str);
-        log.success(`Loaded state from ${opts.statePath}`);
-        log.debug('state:', json);
-        return json;
+    if (!exports || exports.length === 0) {
+      console.warn(`WARNING: no module exports found for ${pattern}`);
     }
-    catch (e) {
-        log.warn(`Error loading state from ${opts.statePath}`);
-        log.warn(e);
-    }
-    log.warn('Using default state { data: {}, configuration: {}');
-    return {
-        data: {},
-        configuration: {}
+    options["add-imports"] = {
+      adaptor: {
+        name: stripVersionSpecifier(specifier),
+        exports,
+        exportAll: true
+      }
     };
+  }
+  return options;
 };
 
-var execute = (code, state, opts) => {
-    // TODO listen to runtime events and log them
-    // events appeal because we don't have to pass two loggers into the runtime
-    // we can just listen to runtime events and do the logging ourselves here
-    // Then again, maybe that doesn't make sense
-    // Maybe we have to feed a job logger in?
-    return run(code, state, {
-        logger: createLogger(RUNTIME, opts),
-        jobLogger: createLogger(JOB, opts),
-        linker: {
-            modulesHome: opts.modulesHome,
-            modulePaths: parseAdaptors(opts),
-        }
-    });
-};
-// TODO we should throw if the adaptor strings are invalid for any reason
-function parseAdaptors(opts) {
-    const adaptors = {};
-    opts.adaptors?.reduce((obj, exp) => {
-        const [module, path] = exp.split('=');
-        obj[module] = path;
-        return obj;
-    }, adaptors);
-    return adaptors;
-}
+// src/repo/handler.ts
+import { exec } from "node:child_process";
+import treeify from "treeify";
+import { install as rtInstall, loadRepoPkg } from "@openfn/runtime";
 
-// Top level command parser
-const parse = async (basePath, options, log) => {
-    // TODO allow a logger to be passed in for test purposes
-    // I THINK I need this but tbh not sure yet!
-    const opts = ensureOpts(basePath, options);
-    const logger = log || createLogger(CLI, opts);
-    if (opts.test) {
-        return runTest(opts, logger);
-    }
-    assertPath(basePath);
-    if (opts.compileOnly) {
-        return runCompile(opts, logger);
+// 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);
     }
-    return runExecute(opts, logger);
+    await rtInstall(packages, repoDir, log);
+  }
+  const duration = log.timer("install");
+  log.success(`Installation complete in ${duration}`);
 };
-// TODO probably this isn't neccessary and we just use cwd?
-const assertPath = (basePath) => {
-    if (!basePath) {
-        console.error('ERROR: no path provided!');
-        console.error('\nUsage:');
-        console.error('  open path/to/job.js');
-        console.error('\nFor more help do:');
-        console.error('  openfn --help ');
-        process.exit(1);
+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");
+  }
 };
-const runExecute = async (options, logger) => {
-    const start = new Date().getTime();
-    const state = await loadState(options, logger);
-    const code = await compile(options, logger);
-    const result = await execute(code, state, options);
-    if (options.outputStdout) {
-        // TODO Log this even if in silent mode
-        logger.success(`Result: `);
-        logger.success(result);
-    }
-    else {
-        logger.success(`Writing output to ${options.outputPath}`);
-        await fs.writeFile(options.outputPath, JSON.stringify(result, null, 4));
-    }
-    const duration = printDuration(new Date().getTime() - start);
-    logger.success(`Done in ${duration}! ✨`);
+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}`);
 };
-const runCompile = async (options, logger) => {
-    const code = await compile(options, logger);
-    if (options.outputStdout) {
-        // TODO log this even if in silent mode
-        logger.success('Compiled code:');
-        console.log(code);
-    }
-    else {
-        await fs.writeFile(options.outputPath, code);
-        logger.success(`Compiled to ${options.outputPath}`);
+var getDependencyList = async (options, _logger) => {
+  const pkg = await loadRepoPkg(options.repoDir);
+  const result = {};
+  Object.keys(pkg.dependencies).forEach((key) => {
+    const [name, version] = key.split("_");
+    if (!result[name]) {
+      result[name] = [];
     }
+    result[name].push(version);
+  });
+  return result;
 };
-const runTest = async (options, logger) => {
-    logger.log('Running test job...');
-    // This is a bit weird but it'll actually work!
-    options.jobPath = `const fn = () => state => state * 2; fn()`;
-    if (!options.stateStdin) {
-        logger.warn('No state detected: pass -S <number> to provide some state');
-        options.stateStdin = "21";
-    }
-    const silentLogger = createNullLogger();
-    const state = await loadState(options, silentLogger);
-    const code = await compile(options, logger);
-    logger.break();
-    logger.info('Compiled job:', '\n', code); // TODO there's an ugly intend here
-    logger.break();
-    logger.info('Running job...');
-    const result = await execute(code, state, options);
-    logger.success(`Result: ${result}`);
-    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));
 };
-// This is disabled for now because
-// 1) Resolving paths relative to the install location of the module is tricky
-// 2) yargs does a pretty good job of reporting the CLI's version
-// export const version = async (options: Opts) => {
-//   // Note that this should ignore silent
-//   const logger = options.logger || console;
-//   const src = await fs.readFile(path.resolve('package.json'), 'utf8')
-//   const pkg = JSON.parse(src);
-//   logger.log(`@openfn/cli ${pkg.version}`)
-//   for (const d in pkg.dependencies) {
-//     if (d.startsWith('@openfn')) {
-//       const pkgpath = path.resolve(`node_modules/${d}/package.json`)
-//       const s = await fs.readFile(pkgpath, 'utf8')
-//       const p = JSON.parse(s);
-//       logger.log(` - ${d} ${p.version}`)
-//     }
-//   }
-// }
 
-// When receiving a message as a child process, we pull out the args and run
-process.on('message', ({ init, basePath, opts }) => {
-    if (init) {
-        parse(basePath, opts).then(() => {
-            process.send({ done: true });
-        });
-    }
+// 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);
+  if (options.outputStdout) {
+    logger.success(`Result: `);
+    logger.success(result);
+  } else {
+    logger.success(`Writing output to ${options.outputPath}`);
+    await writeFile(options.outputPath, JSON.stringify(result, null, 4));
+  }
+  const duration = printDuration(new Date().getTime() - start);
+  logger.success(`Done in ${duration}! \u2728`);
+};
+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:");
+    logger.success("\n" + code);
+  } else {
+    await writeFile2(options.outputPath, code);
+    logger.success(`Compiled to ${options.outputPath}`);
+  }
+};
+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) {
+    logger.warn("No state detected: pass -S <number> to provide some state");
+    options.stateStdin = "21";
+  }
+  const silentLogger = createNullLogger();
+  const state = await load_state_default(options, silentLogger);
+  const code = await compile_default(options, logger);
+  logger.break();
+  logger.info("Compiled job:", "\n", code);
+  logger.break();
+  logger.info("Running job...");
+  const result = await execute_default(code, state, options);
+  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 }) => {
+  if (init) {
+    commands_default(basePath, opts).then(() => {
+      process.send({ done: true });
+    });
+  }
 });
-//# sourceMappingURL=runner.js.map