@lunora/cli 0.0.0 → 1.0.0-alpha.2

package/dist/packem_chunks/handler21.mjs

@@ -0,0 +1,311 @@
+import { writeFileSync, existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { DEV_VARS_FILE, DEV_VARS_KEY_PATTERN, DEV_VARS_EXAMPLE_FILE, parseDevVariableEntries, isPlaceholderValue } from '@lunora/config';
+import { d as defineHandler } from '../packem_shared/command-BDXcJCCJ.mjs';
+import { defaultSpawner } from '../packem_shared/defaultSpawner-DxI3mebw.mjs';
+import { execFile } from 'node:child_process';
+
+const execCode = (error) => {
+  if (!error) {
+    return 0;
+  }
+  return typeof error.code === "number" ? error.code : 1;
+};
+const defaultRunner = (command, args, cwd) => new Promise((resolve) => {
+  execFile(command, [...args], { cwd }, (error, stdout, stderr) => {
+    resolve({ code: execCode(error), stderr, stdout });
+  });
+});
+const parseSecretNames = (stdout) => {
+  let parsed;
+  try {
+    parsed = JSON.parse(stdout);
+  } catch {
+    return void 0;
+  }
+  if (!Array.isArray(parsed)) {
+    return void 0;
+  }
+  const names = parsed.map((entry) => entry !== null && typeof entry === "object" ? entry.name : void 0).filter((name) => typeof name === "string" && name.length > 0);
+  return [...names].toSorted((a, b) => a.localeCompare(b));
+};
+const listRemoteSecrets = async (inputs) => {
+  const args = ["exec", "wrangler", "secret", "list", "--format", "json"];
+  if (inputs.env !== void 0) {
+    args.push("--env", inputs.env);
+  }
+  if (inputs.temporary) {
+    args.push("--temporary");
+  }
+  const runner = inputs.runner ?? defaultRunner;
+  const result = await runner("pnpm", args, inputs.cwd);
+  if (result.code !== 0) {
+    return { error: result.stderr.trim() || `wrangler secret list exited ${String(result.code)}`, names: [], ok: false };
+  }
+  const names = parseSecretNames(result.stdout);
+  if (names === void 0) {
+    return { error: "could not parse `wrangler secret list --format json` output", names: [], ok: false };
+  }
+  return { names, ok: true };
+};
+
+const NEWLINE_PRESENT = /[\r\n]/u;
+const UNREPRESENTABLE_PRESENT = /["\\]/u;
+const parseDevVariables = (content) => {
+  const map = /* @__PURE__ */ new Map();
+  for (const entry of parseDevVariableEntries(content)) {
+    map.set(entry.key, entry);
+  }
+  return map;
+};
+const serializeDevVariables = (map) => {
+  const lines = [];
+  for (const entry of map.values()) {
+    lines.push(`${entry.key}="${entry.value}"`);
+  }
+  return `${lines.join("\n")}
+`;
+};
+const redact = (value) => {
+  if (value.length <= 4) {
+    return "****";
+  }
+  return `${value.slice(0, 4)}${"*".repeat(Math.min(8, value.length - 4))}`;
+};
+const loadDevVariables = (devVariablesPath) => {
+  if (!existsSync(devVariablesPath)) {
+    return /* @__PURE__ */ new Map();
+  }
+  return parseDevVariables(readFileSync(devVariablesPath, "utf8"));
+};
+const runEnvList = (context) => {
+  const map = loadDevVariables(context.devVariablesPath);
+  if (map.size === 0) {
+    context.logger.info(`${DEV_VARS_FILE}: (empty)`);
+    return { code: 0, descriptors: [] };
+  }
+  for (const entry of map.values()) {
+    context.logger.info(`${entry.key}=${redact(entry.value)}`);
+  }
+  return { code: 0, descriptors: [] };
+};
+const runEnvGet = (context) => {
+  const { devVariablesPath, logger, options } = context;
+  if (!options.key) {
+    logger.error("env get requires a key. Usage: lunora env get <KEY>");
+    return { code: 1, descriptors: [] };
+  }
+  const entry = loadDevVariables(devVariablesPath).get(options.key);
+  if (!entry) {
+    logger.error(`env: ${options.key} is not set in ${DEV_VARS_FILE}`);
+    return { code: 1, descriptors: [] };
+  }
+  process.stdout.write(`${entry.value}
+`);
+  return { code: 0, descriptors: [] };
+};
+const runEnvSet = (context) => {
+  const { devVariablesPath, logger, options } = context;
+  if (!options.key) {
+    logger.error("env set requires a key. Usage: lunora env set <KEY> <VALUE>");
+    return { code: 1, descriptors: [] };
+  }
+  if (!DEV_VARS_KEY_PATTERN.test(options.key)) {
+    logger.error(`env: invalid key "${options.key}" — must match [A-Za-z_][A-Za-z0-9_]*`);
+    return { code: 1, descriptors: [] };
+  }
+  if (options.value === void 0) {
+    logger.error("env set requires a value. Usage: lunora env set <KEY> <VALUE>");
+    return { code: 1, descriptors: [] };
+  }
+  if (NEWLINE_PRESENT.test(options.value)) {
+    logger.error(`env: value for "${options.key}" contains a newline, which .dev.vars cannot represent`);
+    return { code: 1, descriptors: [] };
+  }
+  if (UNREPRESENTABLE_PRESENT.test(options.value)) {
+    logger.error(`env: value for "${options.key}" contains a double-quote or backslash, which .dev.vars cannot round-trip`);
+    return { code: 1, descriptors: [] };
+  }
+  const map = loadDevVariables(devVariablesPath);
+  map.set(options.key, { key: options.key, value: options.value });
+  writeFileSync(devVariablesPath, serializeDevVariables(map), "utf8");
+  logger.success(`env: set ${options.key} (${redact(options.value)}) in ${DEV_VARS_FILE}`);
+  return { code: 0, descriptors: [] };
+};
+const runEnvUnset = (context) => {
+  const { devVariablesPath, logger, options } = context;
+  if (!options.key) {
+    logger.error("env unset requires a key. Usage: lunora env unset <KEY>");
+    return { code: 1, descriptors: [] };
+  }
+  const map = loadDevVariables(devVariablesPath);
+  if (!map.delete(options.key)) {
+    logger.warn(`env: ${options.key} was not set in ${DEV_VARS_FILE}`);
+    return { code: 0, descriptors: [] };
+  }
+  writeFileSync(devVariablesPath, serializeDevVariables(map), "utf8");
+  logger.success(`env: unset ${options.key} in ${DEV_VARS_FILE}`);
+  return { code: 0, descriptors: [] };
+};
+const runEnvPush = async (context) => {
+  const { devVariablesPath, logger, options } = context;
+  if (!options.yes) {
+    logger.error("env push uploads secrets to Cloudflare. Re-run with --yes to confirm.");
+    return { code: 1, descriptors: [] };
+  }
+  const map = loadDevVariables(devVariablesPath);
+  if (map.size === 0) {
+    logger.warn(`${DEV_VARS_FILE}: nothing to push (empty)`);
+    return { code: 0, descriptors: [] };
+  }
+  const spawner = options.spawner ?? defaultSpawner;
+  const descriptors = [];
+  for (const entry of map.values()) {
+    const args = ["exec", "wrangler", "secret", "put", entry.key];
+    if (options.prod) {
+      args.push("--env", "production");
+    }
+    if (options.temporary) {
+      args.push("--temporary");
+    }
+    const descriptor = {
+      args,
+      command: "pnpm",
+      cwd: options.cwd ?? process.cwd(),
+      // `wrangler secret put <name>` reads the value from stdin. We
+      // pipe it through the spawner's `input` channel so the secret
+      // never lands on the command line, in env, or in shell history.
+      input: entry.value
+    };
+    descriptors.push(descriptor);
+    logger.info(`pushing ${entry.key} -> wrangler secret${options.prod ? " (production)" : ""}`);
+    const result = await spawner(descriptor);
+    if (result.code !== 0) {
+      logger.error(`env push: failed at ${entry.key} (exit ${String(result.code)})`);
+      return { code: result.code, descriptors };
+    }
+  }
+  logger.success(`env: pushed ${String(map.size)} secret(s)`);
+  return { code: 0, descriptors };
+};
+const fetchRemoteSecretNames = (context) => {
+  const lister = context.options.secretLister ?? listRemoteSecrets;
+  return lister({
+    cwd: context.cwd,
+    env: context.options.prod ? "production" : void 0,
+    temporary: context.options.temporary
+  });
+};
+const runEnvDiff = async (context) => {
+  const { devVariablesPath, logger } = context;
+  const remote = await fetchRemoteSecretNames(context);
+  if (!remote.ok) {
+    logger.error(`env diff: ${remote.error ?? "failed to list remote secrets"}`);
+    return { code: 1, descriptors: [] };
+  }
+  const localKeys = new Set(loadDevVariables(devVariablesPath).keys());
+  const remoteKeys = new Set(remote.names);
+  const localOnly = [...localKeys].filter((key) => !remoteKeys.has(key)).toSorted((a, b) => a.localeCompare(b));
+  const remoteOnly = remote.names.filter((name) => !localKeys.has(name));
+  const both = [...localKeys].filter((key) => remoteKeys.has(key)).toSorted((a, b) => a.localeCompare(b));
+  for (const key of localOnly) {
+    logger.info(`local only (run \`lunora env push\`): ${key}`);
+  }
+  for (const key of remoteOnly) {
+    logger.info(`remote only (in Cloudflare, not ${DEV_VARS_FILE}): ${key}`);
+  }
+  logger.info(`in both: ${String(both.length)} secret(s)`);
+  if (localOnly.length === 0 && remoteOnly.length === 0) {
+    logger.success("env diff: local and remote secret names match");
+  }
+  return { code: 0, descriptors: [] };
+};
+const runEnvDoctor = (context) => {
+  const { cwd, devVariablesPath, logger } = context;
+  const examplePath = join(cwd, DEV_VARS_EXAMPLE_FILE);
+  if (!existsSync(examplePath)) {
+    logger.info(`env doctor: no ${DEV_VARS_EXAMPLE_FILE} to check against — nothing to validate.`);
+    return { code: 0, descriptors: [] };
+  }
+  const exampleKeys = parseDevVariableEntries(readFileSync(examplePath, "utf8")).map((entry) => entry.key);
+  const current = loadDevVariables(devVariablesPath);
+  if (!existsSync(devVariablesPath)) {
+    logger.error(`env doctor: ${DEV_VARS_FILE} is missing. Run \`lunora dev\` to scaffold it, or \`lunora env set <KEY> <VALUE>\`.`);
+    logger.info(`expected (from ${DEV_VARS_EXAMPLE_FILE}): ${exampleKeys.join(", ")}`);
+    return { code: 1, descriptors: [] };
+  }
+  const missing = exampleKeys.filter((key) => !current.has(key));
+  const placeholders = [...current.values()].filter((entry) => isPlaceholderValue(entry.value)).map((entry) => entry.key);
+  const exampleKeySet = new Set(exampleKeys);
+  const extra = [...current.keys()].filter((key) => !exampleKeySet.has(key));
+  for (const key of missing) {
+    logger.error(`missing: ${key} is in ${DEV_VARS_EXAMPLE_FILE} but not ${DEV_VARS_FILE}`);
+  }
+  for (const key of placeholders) {
+    logger.error(`unset: ${key} still has a placeholder value`);
+  }
+  for (const key of extra) {
+    logger.info(`extra: ${key} is set locally but not listed in ${DEV_VARS_EXAMPLE_FILE}`);
+  }
+  if (missing.length === 0 && placeholders.length === 0) {
+    logger.success(`env doctor: ${DEV_VARS_FILE} looks good (${String(current.size)} var(s)).`);
+    return { code: 0, descriptors: [] };
+  }
+  return { code: 1, descriptors: [] };
+};
+const runEnvCommand = async (options) => {
+  const cwd = options.cwd ?? process.cwd();
+  const context = {
+    cwd,
+    devVariablesPath: join(cwd, DEV_VARS_FILE),
+    logger: options.logger,
+    options
+  };
+  switch (options.subcommand) {
+    case "diff": {
+      return runEnvDiff(context);
+    }
+    case "doctor": {
+      return runEnvDoctor(context);
+    }
+    case "get": {
+      return runEnvGet(context);
+    }
+    case "list": {
+      return runEnvList(context);
+    }
+    case "push": {
+      return runEnvPush(context);
+    }
+    case "set": {
+      return runEnvSet(context);
+    }
+    case "unset": {
+      return runEnvUnset(context);
+    }
+    default: {
+      options.logger.error(`env: unknown subcommand "${options.subcommand}"`);
+      return { code: 1, descriptors: [] };
+    }
+  }
+};
+const isEnvSubcommand = (value) => value === "list" || value === "get" || value === "set" || value === "unset" || value === "push" || value === "diff" || value === "doctor";
+const execute = defineHandler(({ argument, cwd, logger, options }) => {
+  const sub = argument[0];
+  if (!isEnvSubcommand(sub)) {
+    logger.error(`env: unknown subcommand "${sub ?? ""}" — expected list | get | set | unset | push | diff | doctor`);
+    return { code: 1 };
+  }
+  return runEnvCommand({
+    cwd,
+    key: argument[1],
+    logger,
+    prod: options.prod === true,
+    subcommand: sub,
+    temporary: options.temporary === true,
+    value: argument[2],
+    yes: options.yes === true
+  });
+});
+
+export { execute, runEnvCommand };

package/dist/packem_chunks/handler3.mjs

@@ -0,0 +1,204 @@
+import { existsSync } from 'node:fs';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { r as resolveAdminBaseUrl } from '../packem_shared/admin-url-4UzT-CI4.mjs';
+import { d as defineHandler } from '../packem_shared/command-BDXcJCCJ.mjs';
+import { a as resolveProductionWorkerUrl } from '../packem_shared/resolve-target-qbsJ_5sF.mjs';
+import { runExportCommand, runImportCommand } from '../packem_shared/DEFAULT_IMPORT_BATCH_SIZE-Ck-2bU08.mjs';
+
+const DEFAULT_BACKUP_DIR = ".lunora-backups";
+const MANIFEST_FILE = "manifest.json";
+const PITR_ENDPOINT_PATH = "/_lunora/admin/pitr";
+const GET_PITR_BOOKMARK_OP = "__lunora_admin__:getPitrBookmark";
+const PITR_RESTORE_OP = "__lunora_admin__:pitrRestore";
+const isManifestEntry = (value) => typeof value === "object" && value !== null && typeof value.id === "string" && typeof value.file === "string";
+const readManifest = async (directory) => {
+  const path = join(directory, MANIFEST_FILE);
+  if (!existsSync(path)) {
+    return [];
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(await readFile(path, "utf8"));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`backup: ${path} exists but is not valid JSON (${message}) — refusing to overwrite it; fix or remove it manually`, { cause: error });
+  }
+  if (!Array.isArray(parsed)) {
+    throw new TypeError(`backup: ${path} exists but is not a JSON array — refusing to overwrite it; fix or remove it manually`);
+  }
+  return parsed.filter(isManifestEntry);
+};
+const writeManifest = async (directory, entries) => {
+  await writeFile(join(directory, MANIFEST_FILE), `${JSON.stringify(entries, void 0, 2)}
+`, "utf8");
+};
+const runBackupCreate = async (options, directory) => {
+  await mkdir(directory, { recursive: true });
+  const timestamp = (options.now ?? (() => /* @__PURE__ */ new Date()))().toISOString();
+  const file = `lunora-backup-${timestamp.replaceAll(/[.:]/gu, "-")}.ndjson`;
+  const result = await runExportCommand({
+    fetchImpl: options.fetchImpl,
+    logger: options.logger,
+    out: join(directory, file),
+    prod: options.prod,
+    tables: options.tables,
+    token: options.token,
+    url: options.url
+  });
+  if (result.code !== 0) {
+    return { code: result.code };
+  }
+  const entry = { bytes: result.bytes, createdAt: timestamp, file, id: timestamp, rows: result.rows, tables: options.tables };
+  const manifest = await readManifest(directory);
+  manifest.push(entry);
+  await writeManifest(directory, manifest);
+  options.logger.success(`backup created: ${file} (${result.rows.toString()} rows, ${result.bytes.toString()} bytes)`);
+  return { code: 0, entry };
+};
+const runBackupList = async (options, directory) => {
+  const manifest = await readManifest(directory);
+  if (manifest.length === 0) {
+    options.logger.info(`no backups found in ${directory}`);
+    return { code: 0 };
+  }
+  for (const entry of manifest) {
+    options.logger.info(`${entry.id}  ${entry.rows.toString()} rows  ${entry.bytes.toString()} bytes  ${entry.file}`);
+  }
+  return { code: 0 };
+};
+const runBackupRestore = async (options, directory) => {
+  const { target } = options;
+  if (target === void 0 || target.length === 0) {
+    options.logger.error("restore requires a backup id or file path. Usage: lunora backup restore <id|file>");
+    return { code: 1 };
+  }
+  const manifest = await readManifest(directory);
+  const matched = manifest.find((entry) => entry.id === target);
+  const file = matched ? join(directory, matched.file) : target;
+  if (!existsSync(file)) {
+    options.logger.error(`backup not found: ${target}`);
+    return { code: 1 };
+  }
+  const result = await runImportCommand({
+    fetchImpl: options.fetchImpl,
+    file,
+    logger: options.logger,
+    prod: options.prod,
+    token: options.token,
+    url: options.url
+  });
+  return { code: result.code };
+};
+const resolvePitrRequest = (options) => {
+  const token = options.token ?? process.env.LUNORA_ADMIN_TOKEN;
+  if (!token) {
+    options.logger.error("admin token required — pass --token or set LUNORA_ADMIN_TOKEN");
+    return void 0;
+  }
+  if (options.prod && options.url === void 0) {
+    options.logger.error("--prod requires an explicit --url (refusing to target the implicit localhost worker)");
+    return void 0;
+  }
+  if (options.restore === true && options.at === void 0 && options.bookmark === void 0) {
+    options.logger.error("pitr --restore requires --at <time> or --bookmark <bookmark>");
+    return void 0;
+  }
+  if (options.restore === true && options.prod === true && options.yes !== true) {
+    options.logger.error("pitr --restore --prod restores production data in place. Re-run with --yes to confirm.");
+    return void 0;
+  }
+  const baseUrl = resolveAdminBaseUrl(options.url, options.logger);
+  if (baseUrl === void 0) {
+    return void 0;
+  }
+  const fetchImpl = options.pitrFetch ?? globalThis.fetch;
+  if (typeof fetchImpl !== "function") {
+    throw new TypeError("no fetch implementation available — pass pitrFetch or run on Node >= 18");
+  }
+  return { fetchImpl, requestUrl: `${baseUrl}${PITR_ENDPOINT_PATH}`, token };
+};
+const buildPitrArgs = (options, isRestore) => {
+  const args = {};
+  if (options.at !== void 0) {
+    args.time = options.at;
+  }
+  if (isRestore && options.bookmark !== void 0) {
+    args.bookmark = options.bookmark;
+  }
+  if (isRestore && options.restart === true) {
+    args.restart = true;
+  }
+  return args;
+};
+const runBackupPitr = async (options) => {
+  const request = resolvePitrRequest(options);
+  if (request === void 0) {
+    return { code: 1 };
+  }
+  const isRestore = options.restore === true;
+  const functionPath = isRestore ? PITR_RESTORE_OP : GET_PITR_BOOKMARK_OP;
+  const args = buildPitrArgs(options, isRestore);
+  const action = isRestore ? "restore" : "bookmark";
+  options.logger.info(`POST ${request.requestUrl} -> pitr ${action}${options.shard === void 0 ? "" : ` (shard "${options.shard}")`}`);
+  const response = await request.fetchImpl(request.requestUrl, {
+    body: JSON.stringify({ args, functionPath, shardKey: options.shard }),
+    headers: { authorization: `Bearer ${request.token}`, "content-type": "application/json" },
+    method: "POST"
+  });
+  const text = await response.text();
+  let body;
+  try {
+    body = JSON.parse(text);
+  } catch {
+    body = text;
+  }
+  options.logger.info(JSON.stringify(body, void 0, 2));
+  return { code: response.ok ? 0 : 1 };
+};
+const runBackupCommand = async (options) => {
+  const cwd = options.cwd ?? process.cwd();
+  const directory = join(cwd, options.dir ?? DEFAULT_BACKUP_DIR);
+  try {
+    if (options.subcommand === "create") {
+      return await runBackupCreate(options, directory);
+    }
+    if (options.subcommand === "list") {
+      return await runBackupList(options, directory);
+    }
+    if (options.subcommand === "pitr") {
+      return await runBackupPitr(options);
+    }
+    return await runBackupRestore(options, directory);
+  } catch (error) {
+    options.logger.error(error instanceof Error ? error.message : String(error));
+    return { code: 1 };
+  }
+};
+const isBackupSubcommand = (value) => value === "create" || value === "list" || value === "pitr" || value === "restore";
+const execute = defineHandler(({ argument, cwd, logger, options }) => {
+  const sub = argument[0];
+  if (!isBackupSubcommand(sub)) {
+    logger.error(`backup: unknown subcommand "${sub ?? ""}" — expected create | list | restore | pitr`);
+    return { code: 1 };
+  }
+  return runBackupCommand({
+    at: options.at,
+    bookmark: options.bookmark,
+    cwd,
+    dir: options.dir,
+    logger,
+    prod: options.prod === true,
+    restart: options.restart === true,
+    restore: options.restore === true,
+    shard: options.shard,
+    subcommand: sub,
+    tables: options.tables,
+    target: argument[1],
+    token: options.token,
+    url: resolveProductionWorkerUrl({ cwd, prod: options.prod === true, url: options.url }),
+    yes: options.yes === true
+  });
+});
+
+export { execute, runBackupCommand };

package/dist/packem_chunks/handler4.mjs

@@ -0,0 +1,33 @@
+import { p as parseApiSpec } from '../packem_shared/api-spec-CtA6ilu4.mjs';
+import { d as defineHandler } from '../packem_shared/command-BDXcJCCJ.mjs';
+import { runDeployCommand } from './runDeployCommand.mjs';
+
+const DEFAULT_OUT_DIR = ".lunora/build";
+const runBuildCommand = async (options) => {
+  const outDirectory = options.outDir ?? DEFAULT_OUT_DIR;
+  const result = await runDeployCommand({
+    apiSpec: options.apiSpec,
+    cwd: options.cwd,
+    dryRun: true,
+    format: options.format,
+    logger: options.logger,
+    outDir: outDirectory,
+    spawner: options.spawner
+  });
+  if (result.code === 0) {
+    options.logger.success(`build complete — bundle written to ${outDirectory}`);
+  }
+  return result;
+};
+const execute = defineHandler(async ({ cwd, logger, options }) => {
+  const result = await runBuildCommand({
+    apiSpec: parseApiSpec(options.apiSpec),
+    cwd,
+    format: options.format,
+    logger,
+    outDir: options.outDir
+  });
+  return { code: result.code };
+});
+
+export { execute, runBuildCommand };

package/dist/packem_chunks/handler5.mjs

@@ -0,0 +1,49 @@
+import { d as defineHandler } from '../packem_shared/command-BDXcJCCJ.mjs';
+import { i as isDockerAvailable } from '../packem_shared/docker-hMQ97KSQ.mjs';
+import { defaultSpawner } from '../packem_shared/defaultSpawner-DxI3mebw.mjs';
+
+const SUBCOMMANDS = /* @__PURE__ */ new Set(["build", "delete", "images", "info", "list", "push"]);
+const NEEDS_DOCKER = /* @__PURE__ */ new Set(["build", "push"]);
+const runContainersCommand = async (options) => {
+  const [subcommand, ...rest] = options.argument;
+  if (subcommand === void 0 || !SUBCOMMANDS.has(subcommand)) {
+    options.logger.error(
+      `lunora containers requires a subcommand: ${[...SUBCOMMANDS].toSorted((a, b) => a.localeCompare(b)).join(" | ")}. Example: lunora containers build ./containers/app --tag app:v1 --push`
+    );
+    return { code: 1 };
+  }
+  if (NEEDS_DOCKER.has(subcommand) && !(options.dockerAvailable ?? isDockerAvailable)()) {
+    options.logger.error(
+      `containers ${subcommand} needs a running Docker-compatible engine (it builds/pushes images locally). Start Docker or Colima and retry. Note: container images must target linux/amd64.`
+    );
+    return { code: 1 };
+  }
+  const args = ["exec", "wrangler", "containers", subcommand, ...rest];
+  if (options.tag !== void 0) {
+    args.push("--tag", options.tag);
+  }
+  if (options.push === true) {
+    args.push("--push");
+  }
+  if (options.env !== void 0) {
+    args.push("--env", options.env);
+  }
+  const descriptor = { args, command: "pnpm", cwd: options.cwd ?? process.cwd() };
+  options.logger.info(`running ${descriptor.command} ${descriptor.args.join(" ")}`);
+  const spawner = options.spawner ?? defaultSpawner;
+  const result = await spawner(descriptor);
+  return { code: result.code, descriptor };
+};
+const execute = defineHandler(async ({ argument, cwd, logger, options }) => {
+  const result = await runContainersCommand({
+    argument,
+    cwd,
+    env: options.env,
+    logger,
+    push: options.push === true,
+    tag: options.tag
+  });
+  return { code: result.code };
+});
+
+export { execute, runContainersCommand };

package/dist/packem_chunks/handler6.mjs

@@ -0,0 +1,91 @@
+import { d as defineHandler } from '../packem_shared/command-BDXcJCCJ.mjs';
+import { defaultSpawner } from '../packem_shared/defaultSpawner-DxI3mebw.mjs';
+
+const withEnv = (args, env) => {
+  if (env !== void 0) {
+    args.push("--env", env);
+  }
+  return args;
+};
+const buildListArgs = (options) => {
+  const args = withEnv(["exec", "wrangler", "deployments", "list"], options.env);
+  if (options.json) {
+    args.push("--json");
+  }
+  return args;
+};
+const buildArgs = (options) => {
+  switch (options.subcommand) {
+    case "inspect": {
+      if (options.versionId === void 0) {
+        return { error: "deployments inspect requires a version id. Usage: lunora deployments inspect <version-id>" };
+      }
+      return { args: withEnv(["exec", "wrangler", "versions", "view", options.versionId], options.env) };
+    }
+    case "list": {
+      return { args: buildListArgs(options) };
+    }
+    case "promote": {
+      if (options.versionId === void 0) {
+        return { error: "deployments promote requires a version id. Usage: lunora deployments promote <version-id> --yes" };
+      }
+      if (!options.yes) {
+        return { error: "deployments promote shifts 100% of live traffic. Re-run with --yes to confirm." };
+      }
+      const args = withEnv(["exec", "wrangler", "versions", "deploy", `${options.versionId}@100%`, "--yes"], options.env);
+      if (options.message !== void 0) {
+        args.push("--message", options.message);
+      }
+      return { args };
+    }
+    case "rollback": {
+      if (!options.yes) {
+        return { error: "deployments rollback changes the live version. Re-run with --yes to confirm." };
+      }
+      const args = withEnv(["exec", "wrangler", "rollback"], options.env);
+      if (options.versionId !== void 0) {
+        args.push(options.versionId);
+      }
+      args.push("--yes");
+      if (options.message !== void 0) {
+        args.push("--message", options.message);
+      }
+      return { args };
+    }
+    default: {
+      return { error: `deployments: unknown subcommand "${options.subcommand}"` };
+    }
+  }
+};
+const runDeploymentsCommand = async (options) => {
+  const { args, error } = buildArgs(options);
+  if (error !== void 0 || args === void 0) {
+    options.logger.error(error ?? "deployments: nothing to run");
+    return { code: 1, descriptor: void 0, error };
+  }
+  const descriptor = { args, command: "pnpm", cwd: options.cwd ?? process.cwd() };
+  options.logger.info(`${descriptor.command} ${descriptor.args.join(" ")}`);
+  const spawner = options.spawner ?? defaultSpawner;
+  const result = await spawner(descriptor);
+  return { code: result.code, descriptor };
+};
+const isDeploymentsSubcommand = (value) => value === "list" || value === "inspect" || value === "rollback" || value === "promote";
+const execute = defineHandler(({ argument, cwd, logger, options }) => {
+  const sub = argument[0];
+  if (!isDeploymentsSubcommand(sub)) {
+    logger.error(`deployments: unknown subcommand "${sub ?? ""}" — expected list | inspect | rollback | promote`);
+    return { code: 1 };
+  }
+  return runDeploymentsCommand({
+    cwd,
+    env: options.env,
+    json: options.json === true,
+    logger,
+    message: options.message,
+    subcommand: sub,
+    versionId: argument[1],
+    yes: options.yes === true
+  });
+});
+
+export { execute, runDeploymentsCommand };