@lunora/cli 0.0.0 → 1.0.0-alpha.2

package/dist/packem_chunks/planDevCommand.mjs

@@ -0,0 +1,543 @@
+import { spawn } from 'node:child_process';
+import { detectAgentRules, inferLunoraBindings, packageNamesFromBindings, ensureDevVarsExample, ensureDevVariables, createConfirm, isInteractive, DEV_VARS_FILE, DEV_VARS_EXAMPLE_FILE, claimAgentRulesHint, AGENT_RULES_HINT, materializeRemoteWranglerConfig, formatLunoraEvent, resolveRemoteEnabled, readProjectRemotePreference } from '@lunora/config';
+import { p as parseApiSpec } from '../packem_shared/api-spec-CtA6ilu4.mjs';
+import { existsSync, watch, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { runCodegen } from '@lunora/codegen';
+import { d as defineHandler } from '../packem_shared/command-BDXcJCCJ.mjs';
+import { dirname, join as join$1 } from '@visulima/path';
+import { createServer, request } from 'node:http';
+import { connect } from 'node:net';
+import { loadStudioAssets, studioAssetsStamp, renderStudioHtml, resolveAdminToken, SCHEMA_EDIT_ENDPOINT, POLICY_SCAFFOLD_ENDPOINT, SEED_ENDPOINT, serveJsonHandler, handleSchemaEditRequest, handlePolicyScaffoldRequest, handleSeedRequest } from '@lunora/config/studio-host';
+
+const DEFAULT_DEBOUNCE_MS = 100;
+const PATH_SEGMENT_SEPARATOR = /[/\\]/u;
+const runOnce = (projectRoot, lunoraDirectory, apiSpec, logger, reason) => {
+  try {
+    runCodegen({ apiSpec, lunoraDirectory, projectRoot });
+    logger.success(`codegen: wrote ${lunoraDirectory}/_generated (${reason})`);
+  } catch (error) {
+    logger.error(`codegen failed (${reason}): ${error instanceof Error ? error.message : String(error)}`);
+  }
+};
+const startCodegenWatch = (options) => {
+  const lunoraDirectory = options.lunoraDirectory ?? "lunora";
+  const watchDirectory = join(options.projectRoot, lunoraDirectory);
+  const debounceMs = options.debounceMs ?? DEFAULT_DEBOUNCE_MS;
+  const { apiSpec } = options;
+  runOnce(options.projectRoot, lunoraDirectory, apiSpec, options.logger, "startup");
+  let timer;
+  let watcher;
+  if (!existsSync(watchDirectory)) {
+    options.logger.warn(
+      `codegen watch unavailable (no such directory: ${watchDirectory}) — schema edits will NOT auto-regenerate. Run \`lunora codegen\` manually after each edit.`
+    );
+    return {
+      close: () => {
+      },
+      watchAvailable: false
+    };
+  }
+  try {
+    watcher = watch(watchDirectory, { recursive: true }, (_event, filename) => {
+      if (typeof filename === "string" && filename.split(PATH_SEGMENT_SEPARATOR).includes("_generated")) {
+        return;
+      }
+      if (timer) {
+        clearTimeout(timer);
+      }
+      timer = setTimeout(runOnce, debounceMs, options.projectRoot, lunoraDirectory, apiSpec, options.logger, `change: ${filename ?? "?"}`);
+    });
+  } catch (error) {
+    options.logger.warn(
+      `codegen watch unavailable (${error instanceof Error ? error.message : String(error)}) — schema edits will NOT auto-regenerate. Run \`lunora codegen\` manually after each edit.`
+    );
+    return {
+      close: () => {
+      },
+      watchAvailable: false
+    };
+  }
+  const liveWatcher = watcher;
+  return {
+    close: () => {
+      if (timer) {
+        clearTimeout(timer);
+      }
+      liveWatcher.close();
+    },
+    watchAvailable: true
+  };
+};
+
+const FALLBACK = "pnpm";
+const KNOWN_MANAGERS = ["pnpm", "yarn", "npm", "bun"];
+const parseDeclaredManager = (declared) => {
+  if (typeof declared !== "string") {
+    return void 0;
+  }
+  return KNOWN_MANAGERS.find((manager) => declared.startsWith(`${manager}@`));
+};
+const readDeclaredManager = (directory) => {
+  const candidate = join$1(directory, "package.json");
+  if (!existsSync(candidate)) {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(readFileSync(candidate, "utf8"));
+    return parseDeclaredManager(parsed.packageManager);
+  } catch {
+    return void 0;
+  }
+};
+const detectPackageManager = (startDirectory) => {
+  let directory = startDirectory;
+  while (directory && directory !== dirname(directory)) {
+    const declared = readDeclaredManager(directory);
+    if (declared !== void 0) {
+      return declared;
+    }
+    directory = dirname(directory);
+  }
+  return FALLBACK;
+};
+const execArgsFor = (manager, command, args) => {
+  if (manager === "yarn") {
+    return { args: [command, ...args], command: "yarn" };
+  }
+  if (manager === "bun") {
+    return { args: ["x", command, ...args], command: "bun" };
+  }
+  if (manager === "npm") {
+    return { args: ["--", command, ...args], command: "npx" };
+  }
+  return { args: ["exec", command, ...args], command: "pnpm" };
+};
+
+const PROXY_PREFIX = "/_lunora";
+const pathnameOf = (url) => {
+  const queryIndex = url.indexOf("?");
+  return queryIndex === -1 ? url : url.slice(0, queryIndex);
+};
+const LOOPBACK_HOST_NAMES = /* @__PURE__ */ new Set(["127.0.0.1", "::1", "[::1]", "localhost"]);
+const isLoopbackHost = (hostHeader) => {
+  if (hostHeader === void 0 || hostHeader === "") {
+    return false;
+  }
+  const withoutPort = hostHeader.startsWith("[") ? hostHeader.slice(0, hostHeader.indexOf("]") + 1) : hostHeader.split(":")[0] ?? hostHeader;
+  return LOOPBACK_HOST_NAMES.has(withoutPort);
+};
+const proxyHttp = (request$1, response, worker) => {
+  const upstream = request(
+    {
+      headers: { ...request$1.headers, host: worker.host },
+      hostname: worker.hostname,
+      method: request$1.method,
+      path: request$1.url,
+      port: worker.port
+    },
+    (upstreamResponse) => {
+      response.writeHead(upstreamResponse.statusCode ?? 502, upstreamResponse.headers);
+      upstreamResponse.pipe(response);
+    }
+  );
+  upstream.on("error", (error) => {
+    response.statusCode = 502;
+    response.end(`lunora dev: worker unreachable (${error.message})`);
+  });
+  request$1.pipe(upstream);
+};
+const UPGRADE_CONNECT_TIMEOUT_MS = 5e3;
+const proxyUpgrade = (request, clientSocket, head, worker) => {
+  const upstream = connect({ host: worker.hostname, port: Number(worker.port) }, () => {
+    upstream.setTimeout(0);
+    const lines = [`${request.method ?? "GET"} ${request.url ?? "/"} HTTP/1.1`];
+    for (const [key, value] of Object.entries(request.headers)) {
+      if (key === "host") {
+        continue;
+      }
+      for (const item of Array.isArray(value) ? value : [value]) {
+        if (item !== void 0) {
+          lines.push(`${key}: ${item}`);
+        }
+      }
+    }
+    lines.push(`host: ${worker.host}`, "", "");
+    upstream.write(lines.join("\r\n"));
+    if (head.length > 0) {
+      upstream.write(head);
+    }
+    upstream.pipe(clientSocket);
+    clientSocket.pipe(upstream);
+  });
+  upstream.setTimeout(UPGRADE_CONNECT_TIMEOUT_MS, () => upstream.destroy());
+  upstream.on("error", () => clientSocket.destroy());
+  clientSocket.on("error", () => upstream.destroy());
+};
+const startStudioServer = async (options) => {
+  const host = options.host ?? "127.0.0.1";
+  const isLoopback = host === "127.0.0.1" || host === "localhost" || host === "::1";
+  const worker = new URL(options.workerOrigin);
+  let assets = loadStudioAssets(options.logger, import.meta.url);
+  let assetsStamp = studioAssetsStamp(import.meta.url);
+  const html = renderStudioHtml({
+    // The admin token grants full read/write over the local worker. Only embed
+    // it for a loopback bind: a non-loopback (LAN/0.0.0.0) bind would otherwise
+    // hand the token to any network client that GETs `/`.
+    adminToken: isLoopback ? resolveAdminToken(options.cwd) : void 0,
+    basePath: "/",
+    dataEditable: isLoopback,
+    rulesInstalled: detectAgentRules(options.cwd).installed,
+    runAsIdentity: isLoopback,
+    schemaEditable: isLoopback,
+    scriptSrc: "/studio.js",
+    styleHref: "/styles.css"
+  });
+  const sendAsset = (response, body, contentType) => {
+    response.statusCode = 200;
+    response.setHeader("Content-Type", contentType);
+    response.end(body);
+  };
+  const serveLoopbackOnly = (request, response, handle, deniedMessage) => {
+    if (isLoopback) {
+      serveJsonHandler(request, response, handle, options.cwd);
+      return;
+    }
+    response.statusCode = 403;
+    response.setHeader("Content-Type", "text/plain");
+    response.end(deniedMessage);
+  };
+  const serveStaticAsset = (pathname, response) => {
+    if (pathname !== "/studio.js" && pathname !== "/styles.css") {
+      return false;
+    }
+    const stamp = studioAssetsStamp(import.meta.url);
+    if (stamp !== assetsStamp) {
+      assets = loadStudioAssets(options.logger, import.meta.url);
+      assetsStamp = stamp;
+    }
+    if (assets === void 0) {
+      response.statusCode = 501;
+      response.setHeader("Content-Type", "text/plain");
+      response.end("Lunora studio assets not found — install and build @lunora/studio.");
+      return true;
+    }
+    const isScript = pathname === "/studio.js";
+    sendAsset(response, isScript ? assets.script : assets.styles, isScript ? "text/javascript; charset=utf-8" : "text/css; charset=utf-8");
+    return true;
+  };
+  const document = Buffer.from(html);
+  const server = createServer((request, response) => {
+    const pathname = pathnameOf(request.url ?? "/");
+    if (isLoopback && !isLoopbackHost(request.headers.host)) {
+      response.statusCode = 403;
+      response.setHeader("Content-Type", "text/plain");
+      response.end("Lunora studio: refusing a request whose Host is not a loopback literal (DNS-rebinding guard).");
+      return;
+    }
+    if (pathname.startsWith(PROXY_PREFIX)) {
+      if (!isLoopback) {
+        response.statusCode = 403;
+        response.setHeader("Content-Type", "text/plain");
+        response.end("Lunora studio: the worker admin proxy is only available on a loopback bind.");
+        return;
+      }
+      proxyHttp(request, response, worker);
+      return;
+    }
+    if (pathname === SCHEMA_EDIT_ENDPOINT) {
+      serveLoopbackOnly(request, response, handleSchemaEditRequest, "Lunora schema editing is only available on loopback hosts in dev.");
+      return;
+    }
+    if (pathname === POLICY_SCAFFOLD_ENDPOINT) {
+      serveLoopbackOnly(request, response, handlePolicyScaffoldRequest, "Lunora policy scaffolding is only available on loopback hosts in dev.");
+      return;
+    }
+    if (pathname === SEED_ENDPOINT) {
+      serveLoopbackOnly(request, response, handleSeedRequest, "Lunora data seeding is only available on loopback hosts in dev.");
+      return;
+    }
+    if (serveStaticAsset(pathname, response)) {
+      return;
+    }
+    sendAsset(response, document, "text/html; charset=utf-8");
+  });
+  server.on("upgrade", (request, socket, head) => {
+    if (!isLoopback || !isLoopbackHost(request.headers.host)) {
+      socket.destroy();
+      return;
+    }
+    if (pathnameOf(request.url ?? "").startsWith(PROXY_PREFIX)) {
+      proxyUpgrade(request, socket, head, worker);
+    } else {
+      socket.destroy();
+    }
+  });
+  await new Promise((resolve, reject) => {
+    server.once("error", (error) => {
+      if (error.code === "EADDRINUSE") {
+        reject(
+          new Error(`studio port ${String(options.port)} is already in use — pass a different port with --port, or stop the process using it`, {
+            cause: error
+          })
+        );
+      } else {
+        reject(error);
+      }
+    });
+    server.listen(options.port, host, () => {
+      resolve();
+    });
+  });
+  return {
+    close: () => new Promise((resolve) => {
+      server.close(() => {
+        resolve();
+      });
+    }),
+    url: `http://${host === "0.0.0.0" || host === "::" ? "localhost" : host}:${String(options.port)}`
+  };
+};
+
+const DEFAULT_STUDIO_PORT = 6173;
+const DEFAULT_WORKER_PORT = 8787;
+const SIGINT_GRACE_MS = 5e3;
+const resolveRemotePlan = (options, cwd) => {
+  const noopCleanup = () => {
+  };
+  if (!options.remote) {
+    return { args: [], plan: { bindings: [], cleanup: noopCleanup, enabled: false } };
+  }
+  const materialize = options.materializeRemote ?? materializeRemoteWranglerConfig;
+  const result = materialize({ enabled: true, projectRoot: cwd });
+  const bindings = result.remoteBindings.map((binding) => `${binding.binding} (${binding.kind})`);
+  const { cleanup } = result;
+  if (result.configPath === void 0) {
+    return { args: [], plan: { bindings, cleanup, enabled: true, reason: result.reason } };
+  }
+  return { args: ["--config", result.configPath], plan: { bindings, cleanup, enabled: true } };
+};
+const planDevCommand = (options) => {
+  const cwd = options.cwd ?? process.cwd();
+  const workerPort = options.workerPort ?? DEFAULT_WORKER_PORT;
+  const manager = detectPackageManager(cwd);
+  const remote = resolveRemotePlan(options, cwd);
+  const exec = execArgsFor(manager, "wrangler", ["dev", "--port", String(workerPort), "--var", "WORKER_ENV:development", ...remote.args]);
+  return {
+    codegenEnabled: options.codegen !== false,
+    remote: remote.plan,
+    studioEnabled: options.studio !== false,
+    studioPort: options.port ?? DEFAULT_STUDIO_PORT,
+    workerOrigin: `http://localhost:${String(workerPort)}`,
+    workerPort,
+    wrangler: { args: exec.args, command: exec.command, cwd, tag: "wrangler" }
+  };
+};
+const emitChildLine = (line, tag, kind, logger) => {
+  if (line.length === 0) {
+    return;
+  }
+  const formatted = formatLunoraEvent(line);
+  if (formatted) {
+    logger[formatted.level](`[lunora] ${formatted.text}`);
+    return;
+  }
+  const prefixed = `[${tag}] ${line}`;
+  if (kind === "stderr") {
+    logger.warn(prefixed);
+  } else {
+    logger.info(prefixed);
+  }
+};
+const pipeChildOutput = (child, tag, logger) => {
+  const pumpStream = (stream, kind) => {
+    if (!stream) {
+      return;
+    }
+    let buffer = "";
+    stream.on("data", (chunk) => {
+      buffer += chunk.toString("utf8");
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        emitChildLine(line.trimEnd(), tag, kind, logger);
+      }
+    });
+    stream.on("end", () => {
+      emitChildLine(buffer.trimEnd(), tag, kind, logger);
+      buffer = "";
+    });
+  };
+  pumpStream(child.stdout, "stdout");
+  pumpStream(child.stderr, "stderr");
+};
+const defaultWorkerSpawner = (descriptor, logger) => {
+  const child = spawn(descriptor.command, [...descriptor.args], {
+    cwd: descriptor.cwd ?? process.cwd(),
+    env: process.env,
+    stdio: ["inherit", "pipe", "pipe"]
+  });
+  pipeChildOutput(child, descriptor.tag, logger);
+  return {
+    exited: new Promise((resolve) => {
+      child.on("error", (error) => {
+        logger.error(`[${descriptor.tag}] failed to start: ${error.message}`);
+        resolve(1);
+      });
+      child.on("exit", (code) => {
+        resolve(code ?? 0);
+      });
+    }),
+    kill: (signal) => {
+      try {
+        child.kill(signal);
+      } catch {
+      }
+    }
+  };
+};
+const printBanner = (logger, plan, studioUrl) => {
+  logger.info("");
+  logger.success("Lunora dev");
+  logger.info(`  ➜  Worker:     ${plan.workerOrigin}`);
+  if (studioUrl !== void 0) {
+    logger.info(`  ➜  Studio:  ${studioUrl}`);
+  }
+  if (plan.codegenEnabled) {
+    logger.info("  ➜  Codegen:    watching lunora/");
+  }
+  if (plan.remote.enabled) {
+    if (plan.remote.bindings.length > 0) {
+      logger.info(`  ➜  Remote:     ${plan.remote.bindings.join(", ")} → deployed worker`);
+    } else {
+      logger.warn(`  ➜  Remote:     requested but inactive (${plan.remote.reason ?? "no eligible bindings"}) — running fully local`);
+    }
+  }
+  logger.info("");
+};
+const printAgentRulesHint = (logger, cwd) => {
+  if (detectAgentRules(cwd).installed || !claimAgentRulesHint()) {
+    return;
+  }
+  logger.info(`  ⓘ  ${AGENT_RULES_HINT}`);
+  logger.info("");
+};
+const teardown = async (handles) => {
+  handles.codegen?.close();
+  await handles.studio?.close().catch(() => void 0);
+  try {
+    handles.remoteCleanup?.();
+  } catch {
+  }
+};
+const offerDevVariablesScaffold = async (options, cwd) => {
+  try {
+    const bindings = await inferLunoraBindings({ projectRoot: cwd });
+    const packageNames = packageNamesFromBindings(bindings);
+    const addedKeys = (options.ensureExample ?? ensureDevVarsExample)(cwd, packageNames);
+    if (addedKeys.length > 0) {
+      options.logger.info(`Updated .dev.vars.example with secrets for: ${packageNames.join(", ")} (${addedKeys.join(", ")})`);
+    }
+  } catch {
+  }
+  const result = await (options.ensureEnv ?? ensureDevVariables)({
+    confirm: createConfirm(),
+    cwd,
+    info: (message) => {
+      options.logger.info(message);
+    }
+  });
+  if (result.status === "declined" && !isInteractive()) {
+    options.logger.info(
+      `hint: ${DEV_VARS_FILE} was not scaffolded (non-interactive run). Copy ${DEV_VARS_EXAMPLE_FILE} → ${DEV_VARS_FILE} and fill in secrets, or run \`lunora dev\` in an interactive terminal to scaffold automatically.`
+    );
+  }
+};
+const runDevCommand = async (options) => {
+  const plan = planDevCommand(options);
+  const { logger } = options;
+  const cwd = plan.wrangler.cwd ?? process.cwd();
+  const handles = { remoteCleanup: plan.remote.cleanup };
+  try {
+    await offerDevVariablesScaffold(options, cwd);
+    logger.info("starting wrangler dev + studio");
+    if (plan.codegenEnabled) {
+      handles.codegen = (options.startCodegen ?? startCodegenWatch)({ apiSpec: options.apiSpec, logger, projectRoot: cwd });
+    }
+    let studioUrl;
+    if (plan.studioEnabled) {
+      try {
+        handles.studio = await (options.startStudio ?? startStudioServer)({
+          cwd,
+          logger: {
+            warnOnce: (message) => {
+              logger.warn(message);
+            }
+          },
+          port: plan.studioPort,
+          workerOrigin: plan.workerOrigin
+        });
+        studioUrl = handles.studio.url;
+      } catch (error) {
+        logger.warn(`studio server failed to start (${error instanceof Error ? error.message : String(error)}) — continuing without it`);
+      }
+    }
+    const worker = (options.startWorker ?? defaultWorkerSpawner)(plan.wrangler, logger);
+    printBanner(logger, plan, studioUrl);
+    printAgentRulesHint(logger, cwd);
+    let sigintCount = 0;
+    let escalationTimer;
+    const onSigint = () => {
+      sigintCount += 1;
+      if (sigintCount === 1) {
+        logger.info("received SIGINT — shutting down (press Ctrl-C again to force-kill)");
+        worker.kill("SIGTERM");
+        escalationTimer = setTimeout(() => {
+          worker.kill("SIGKILL");
+        }, SIGINT_GRACE_MS);
+        escalationTimer.unref();
+      } else {
+        worker.kill("SIGKILL");
+      }
+    };
+    const onSigterm = () => {
+      worker.kill("SIGTERM");
+    };
+    process.on("SIGINT", onSigint);
+    process.on("SIGTERM", onSigterm);
+    const code = await worker.exited;
+    if (escalationTimer) {
+      clearTimeout(escalationTimer);
+    }
+    process.off("SIGINT", onSigint);
+    process.off("SIGTERM", onSigterm);
+    return { code, plan };
+  } finally {
+    await teardown(handles);
+  }
+};
+const execute = defineHandler(
+  ({ cwd, logger, options }) => runDevCommand({
+    apiSpec: parseApiSpec(options.apiSpec),
+    // cerebro parses `--no-codegen`/`--no-studio` as the negation of the
+    // `codegen`/`studio` booleans (runtime key drops the `no-` prefix), so a
+    // passed flag arrives as `false`, absent as `true` (the option default).
+    codegen: options.codegen === false ? false : void 0,
+    cwd,
+    logger,
+    port: options.port,
+    // Remote-binding mode obeys a clear precedence: an explicit `--remote`
+    // flag wins, then `LUNORA_REMOTE` in the environment, then the `remote`
+    // key in the project's `lunora.json` (a project default). See
+    // `resolveRemoteEnabled` in @lunora/config.
+    remote: resolveRemoteEnabled({
+      configPreference: readProjectRemotePreference(cwd),
+      envValue: process.env["LUNORA_REMOTE"],
+      flag: options.remote
+    }),
+    studio: options.studio === false ? false : void 0,
+    workerPort: options.workerPort
+  })
+);
+
+export { execute, planDevCommand, resolveRemotePlan, runDevCommand };

package/dist/packem_chunks/runCodegenCommand.mjs

@@ -0,0 +1,52 @@
+import { runCodegen } from '@lunora/codegen';
+import { p as parseApiSpec } from '../packem_shared/api-spec-CtA6ilu4.mjs';
+import { d as defineHandler } from '../packem_shared/command-BDXcJCCJ.mjs';
+import { v as validateOutputFormat, p as printJson, l as loggerForFormat, i as isJsonFormat } from '../packem_shared/output-format-7gyGR3h8.mjs';
+
+const CRON_TRIGGER_LIMIT = 3;
+const runCodegenCommand = (options) => {
+  const projectRoot = options.cwd ?? process.cwd();
+  const json = isJsonFormat(options.format);
+  const logger = loggerForFormat(options.format, options.logger);
+  const formatError = validateOutputFormat("codegen", options.format);
+  if (formatError !== void 0) {
+    options.logger.error(formatError);
+    return { advisories: [], cronTriggers: [], error: formatError, outputDirectory: "" };
+  }
+  const result = runCodegen({ apiSpec: options.apiSpec, projectRoot });
+  const commandResult = {
+    advisories: result.advisories.map((advisory) => {
+      return {
+        detail: advisory.detail,
+        level: advisory.level,
+        name: advisory.name,
+        remediation: advisory.remediation
+      };
+    }),
+    cronTriggers: result.cronTriggers,
+    outputDirectory: result.outputDirectory
+  };
+  logger.success(`codegen wrote dataModel.ts, api.ts, server.ts to ${result.outputDirectory}`);
+  if (result.advisories.length > 0) {
+    const count = result.advisories.length;
+    const lines = result.advisories.map((advisory) => `  [${advisory.level}] ${advisory.name} — ${advisory.detail}
+      ↳ ${advisory.remediation}`);
+    logger.warn(`${count.toString()} schema ${count === 1 ? "advisory" : "advisories"}:
+${lines.join("\n")}`);
+  }
+  if (result.cronTriggers.length > CRON_TRIGGER_LIMIT) {
+    logger.warn(
+      `${result.cronTriggers.length.toString()} distinct cron expressions declared — Cloudflare allows at most ${CRON_TRIGGER_LIMIT.toString()} Cron Triggers per Worker. Consolidate schedules (jobs can share one expression) or move finer-grained work to Durable Object alarms via @lunora/scheduler (runAfter/runAt).`
+    );
+  }
+  if (json) {
+    printJson(commandResult);
+  }
+  return commandResult;
+};
+const execute = defineHandler(({ cwd, logger, options }) => {
+  const result = runCodegenCommand({ apiSpec: parseApiSpec(options.apiSpec), cwd, format: options.format, logger });
+  return { code: result.error === void 0 ? 0 : 1 };
+});
+
+export { execute, runCodegenCommand };