@lunora/cli 1.0.0-alpha.10 → 1.0.0-alpha.100

package/dist/packem_chunks/handler21.mjs

@@ -1,311 +1,202 @@
-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-BC30oSBW.mjs';
-import { defaultSpawner } from '../packem_shared/createRecordingSpawner-DxI3mebw.mjs';
-import { execFile } from 'node:child_process';
+import { readLinkedProject } from '@lunora/config';
+import { d as defineHandler } from '../packem_shared/command-lYnl4QyF.mjs';
+import { e as execArgsFor, d as detectPackageManager } from '../packem_shared/detect-package-manager-v4hHpQd0.mjs';
+import { defaultSpawner } from '../packem_shared/createRecordingSpawner-WuSn20kb.mjs';
+import { createR2Sql } from '@lunora/bindings/r2sql';
+import { createPipelineLogReader } from '@lunora/runtime';
 
-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 {
+const LOG_LEVELS = /* @__PURE__ */ new Set(["debug", "error", "fatal", "info", "log", "trace", "warn"]);
+const EPOCH_MILLIS_RE = /^\d+$/;
+const parseTimestamp = (value, flag) => {
+  if (value === void 0) {
     return void 0;
   }
-  if (!Array.isArray(parsed)) {
-    return void 0;
+  const trimmed = value.trim();
+  if (EPOCH_MILLIS_RE.test(trimmed)) {
+    return Number(trimmed);
   }
-  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);
+  const parsed = Date.parse(trimmed);
+  if (Number.isNaN(parsed)) {
+    throw new TypeError(`logs: invalid ${flag} "${value}" — pass epoch-millis or an ISO 8601 date`);
   }
-  return map;
+  return parsed;
 };
-const serializeDevVariables = (map) => {
-  const lines = [];
-  for (const entry of map.values()) {
-    lines.push(`${entry.key}="${entry.value}"`);
+const parseLevel = (value, flag) => {
+  if (value === void 0) {
+    return void 0;
   }
-  return `${lines.join("\n")}
-`;
-};
-const redact = (value) => {
-  if (value.length <= 4) {
-    return "****";
+  if (!LOG_LEVELS.has(value)) {
+    throw new TypeError(`logs: invalid ${flag} "${value}" — expected one of trace, debug, log, info, warn, error, fatal`);
   }
-  return `${value.slice(0, 4)}${"*".repeat(Math.min(8, value.length - 4))}`;
+  return value;
 };
-const loadDevVariables = (devVariablesPath) => {
-  if (!existsSync(devVariablesPath)) {
-    return /* @__PURE__ */ new Map();
+const buildQuery = (options) => {
+  const query = {};
+  const sinceTs = parseTimestamp(options.since, "--since");
+  if (sinceTs !== void 0) {
+    query.sinceTs = sinceTs;
   }
-  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: [] };
+  const untilTs = parseTimestamp(options.until, "--until");
+  if (untilTs !== void 0) {
+    query.untilTs = untilTs;
   }
-  for (const entry of map.values()) {
-    context.logger.info(`${entry.key}=${redact(entry.value)}`);
+  const level = parseLevel(options.level, "--level");
+  if (level !== void 0) {
+    query.level = level;
   }
-  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 minLevel = parseLevel(options.minLevel, "--min-level");
+  if (minLevel !== void 0) {
+    query.minLevel = minLevel;
   }
-  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: [] };
+  if (options.functionPrefix !== void 0) {
+    query.functionPathPrefix = options.functionPrefix;
   }
-  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 (options.traceId !== void 0) {
+    query.traceId = options.traceId;
   }
-  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.shardKey !== void 0) {
+    query.shardKey = options.shardKey;
   }
-  if (options.value === void 0) {
-    logger.error("env set requires a value. Usage: lunora env set <KEY> <VALUE>");
-    return { code: 1, descriptors: [] };
+  if (options.userId !== void 0) {
+    query.userId = options.userId;
   }
-  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 (options.limit !== void 0) {
+    const limit = Number(options.limit);
+    if (!Number.isFinite(limit)) {
+      throw new TypeError(`logs: invalid --limit "${options.limit}" — expected a number`);
+    }
+    query.limit = limit;
   }
-  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: [] };
+  if (options.cursor !== void 0) {
+    const cursorTs = Number(options.cursor);
+    if (!Number.isFinite(cursorTs)) {
+      throw new TypeError(`logs: invalid --cursor "${options.cursor}" — expected the epoch-millis ts from a prior page's nextCursor`);
+    }
+    query.cursor = { ts: cursorTs };
   }
-  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: [] };
+  return query;
 };
-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 formatRow = (row) => {
+  const time = new Date(row.ts).toISOString();
+  const level = row.level.toUpperCase().padEnd(5);
+  return `${time}  ${level}  ${row.functionPath}  ${row.message}`;
 };
-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 runDurableLogsCommand = async (options) => {
+  const environment = options.environment ?? process.env;
+  const accountId = environment.R2_SQL_ACCOUNT_ID;
+  const apiToken = environment.R2_SQL_TOKEN;
+  const bucket = environment.R2_SQL_BUCKET;
+  const missing = [];
+  if (accountId === void 0 || accountId.length === 0) {
+    missing.push("R2_SQL_ACCOUNT_ID");
   }
-  const map = loadDevVariables(devVariablesPath);
-  if (map.size === 0) {
-    logger.warn(`${DEV_VARS_FILE}: nothing to push (empty)`);
-    return { code: 0, descriptors: [] };
+  if (apiToken === void 0 || apiToken.length === 0) {
+    missing.push("R2_SQL_TOKEN");
   }
-  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 };
-    }
+  if (bucket === void 0 || bucket.length === 0) {
+    missing.push("R2_SQL_BUCKET");
   }
-  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: [] };
+  if (options.table === void 0 || options.table.length === 0) {
+    missing.push("--table");
   }
-  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}`);
+  if (missing.length > 0) {
+    options.logger.error(
+      `logs --durable: R2 SQL not configured (missing ${missing.join(", ")}). The Pipeline must write to an R2 Data Catalog (Iceberg) table, and you must supply R2_SQL_ACCOUNT_ID / R2_SQL_TOKEN / R2_SQL_BUCKET plus --table — see the observability docs.`
+    );
+    return { code: 1, error: "not configured" };
   }
-  for (const key of remoteOnly) {
-    logger.info(`remote only (in Cloudflare, not ${DEV_VARS_FILE}): ${key}`);
+  let query;
+  try {
+    query = buildQuery(options);
+  } catch (error) {
+    options.logger.error(error instanceof Error ? error.message : String(error));
+    return { code: 1, error: "invalid option" };
+  }
+  const client = createR2Sql({ accountId, apiToken, bucket, fetch: options.fetch });
+  const reader = createPipelineLogReader(client, { namespace: options.namespace, table: options.table });
+  const page = await reader.query(query);
+  for (const row of page.rows) {
+    process.stdout.write(`${options.ndjson === true ? JSON.stringify(row) : formatRow(row)}
+`);
   }
-  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");
+  if (page.rows.length === 0) {
+    options.logger.info("logs --durable: no matching log records");
+  } else if (page.nextCursor !== void 0) {
+    options.logger.info(`logs --durable: more rows available — pass --cursor ${String(page.nextCursor.ts)} for the next page`);
   }
-  return { code: 0, descriptors: [] };
+  return { code: 0, rows: page.rows };
 };
-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 LOG_FORMATS = /* @__PURE__ */ new Set(["json", "pretty"]);
+const runLogsCommand = async (options) => {
+  const cwd = options.cwd ?? process.cwd();
+  if (options.format !== void 0 && !LOG_FORMATS.has(options.format)) {
+    options.logger.error(`logs: unknown --format "${options.format}" — expected pretty | json`);
+    return { code: 1, descriptor: void 0, error: "invalid format" };
   }
-  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 args = ["tail"];
+  if (options.worker !== void 0) {
+    args.push(options.worker);
   }
-  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}`);
+  const env = options.env ?? readLinkedProject(cwd)?.env;
+  if (env !== void 0) {
+    args.push("--env", env);
   }
-  for (const key of placeholders) {
-    logger.error(`unset: ${key} still has a placeholder value`);
+  if (options.format !== void 0) {
+    args.push("--format", options.format);
   }
-  for (const key of extra) {
-    logger.info(`extra: ${key} is set locally but not listed in ${DEV_VARS_EXAMPLE_FILE}`);
+  if (options.status !== void 0) {
+    args.push("--status", options.status);
   }
-  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: [] };
+  if (options.search !== void 0) {
+    args.push("--search", options.search);
   }
-  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: [] };
-    }
+  if (options.temporary) {
+    args.push("--temporary");
   }
+  const exec = execArgsFor(detectPackageManager(cwd), "wrangler", args);
+  const descriptor = {
+    args: exec.args,
+    command: exec.command,
+    cwd
+  };
+  options.logger.info(`tailing logs via ${descriptor.command} ${descriptor.args.join(" ")}`);
+  const spawner = options.spawner ?? defaultSpawner;
+  const result = await spawner(descriptor);
+  return {
+    code: result.code,
+    descriptor
+  };
 };
-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({
+  if (options.durable === true) {
+    return runDurableLogsCommand({
+      cursor: options.cursor,
+      functionPrefix: options.functionPrefix,
+      level: options.level,
+      limit: options.limit,
+      logger,
+      minLevel: options.minLevel,
+      namespace: options.namespace,
+      ndjson: options.ndjson === true,
+      shardKey: options.shardKey,
+      since: options.since,
+      table: options.table,
+      traceId: options.traceId,
+      until: options.until,
+      userId: options.userId
+    });
+  }
+  return runLogsCommand({
     cwd,
-    key: argument[1],
+    env: options.env,
+    format: options.format,
     logger,
-    prod: options.prod === true,
-    subcommand: sub,
+    search: options.search,
+    status: options.status,
     temporary: options.temporary === true,
-    value: argument[2],
-    yes: options.yes === true
+    worker: argument[0]
   });
 });
 
-export { execute, runEnvCommand };
+export { execute, runLogsCommand };

package/dist/packem_chunks/handler3.mjs

@@ -1,10 +1,11 @@
 import { existsSync } from 'node:fs';
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
+import { LunoraError } from '@lunora/errors';
 import { r as resolveAdminBaseUrl } from '../packem_shared/admin-url-4UzT-CI4.mjs';
-import { d as defineHandler } from '../packem_shared/command-BC30oSBW.mjs';
+import { d as defineHandler } from '../packem_shared/command-lYnl4QyF.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';
+import { runExportCommand, runImportCommand } from '../packem_shared/DEFAULT_IMPORT_BATCH_SIZE-D0VOTerB.mjs';
 
 const DEFAULT_BACKUP_DIR = ".lunora-backups";
 const MANIFEST_FILE = "manifest.json";
@@ -22,7 +23,9 @@ const readManifest = async (directory) => {
     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 });
+    throw new LunoraError("INTERNAL", `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`);
@@ -86,7 +89,8 @@ const runBackupRestore = async (options, directory) => {
     logger: options.logger,
     prod: options.prod,
     token: options.token,
-    url: options.url
+    url: options.url,
+    yes: options.yes
   });
   return { code: result.code };
 };

package/dist/packem_chunks/handler4.mjs

@@ -1,5 +1,5 @@
-import { p as parseApiSpec } from '../packem_shared/api-spec-CtA6ilu4.mjs';
-import { d as defineHandler } from '../packem_shared/command-BC30oSBW.mjs';
+import { p as parseApiSpec } from '../packem_shared/api-spec-Bx0iKbxA.mjs';
+import { d as defineHandler } from '../packem_shared/command-lYnl4QyF.mjs';
 import { runDeployCommand } from './runDeployCommand.mjs';
 
 const DEFAULT_OUT_DIR = ".lunora/build";

package/dist/packem_chunks/handler5.mjs

@@ -1,6 +1,7 @@
-import { d as defineHandler } from '../packem_shared/command-BC30oSBW.mjs';
+import { d as defineHandler } from '../packem_shared/command-lYnl4QyF.mjs';
+import { e as execArgsFor, d as detectPackageManager } from '../packem_shared/detect-package-manager-v4hHpQd0.mjs';
 import { i as isDockerAvailable } from '../packem_shared/docker-hMQ97KSQ.mjs';
-import { defaultSpawner } from '../packem_shared/createRecordingSpawner-DxI3mebw.mjs';
+import { defaultSpawner } from '../packem_shared/createRecordingSpawner-WuSn20kb.mjs';
 
 const SUBCOMMANDS = /* @__PURE__ */ new Set(["build", "delete", "images", "info", "list", "push"]);
 const NEEDS_DOCKER = /* @__PURE__ */ new Set(["build", "push"]);
@@ -18,7 +19,7 @@ const runContainersCommand = async (options) => {
     );
     return { code: 1 };
   }
-  const args = ["exec", "wrangler", "containers", subcommand, ...rest];
+  const args = ["containers", subcommand, ...rest];
   if (options.tag !== void 0) {
     args.push("--tag", options.tag);
   }
@@ -28,7 +29,9 @@ const runContainersCommand = async (options) => {
   if (options.env !== void 0) {
     args.push("--env", options.env);
   }
-  const descriptor = { args, command: "pnpm", cwd: options.cwd ?? process.cwd() };
+  const cwd = options.cwd ?? process.cwd();
+  const exec = execArgsFor(detectPackageManager(cwd), "wrangler", args);
+  const descriptor = { args: exec.args, command: exec.command, cwd };
   options.logger.info(`running ${descriptor.command} ${descriptor.args.join(" ")}`);
   const spawner = options.spawner ?? defaultSpawner;
   const result = await spawner(descriptor);

package/dist/packem_chunks/handler6.mjs

@@ -1,5 +1,6 @@
-import { d as defineHandler } from '../packem_shared/command-BC30oSBW.mjs';
-import { defaultSpawner } from '../packem_shared/createRecordingSpawner-DxI3mebw.mjs';
+import { d as defineHandler } from '../packem_shared/command-lYnl4QyF.mjs';
+import { e as execArgsFor, d as detectPackageManager } from '../packem_shared/detect-package-manager-v4hHpQd0.mjs';
+import { defaultSpawner } from '../packem_shared/createRecordingSpawner-WuSn20kb.mjs';
 
 const withEnv = (args, env) => {
   if (env !== void 0) {
@@ -8,7 +9,7 @@ const withEnv = (args, env) => {
   return args;
 };
 const buildListArgs = (options) => {
-  const args = withEnv(["exec", "wrangler", "deployments", "list"], options.env);
+  const args = withEnv(["deployments", "list"], options.env);
   if (options.json) {
     args.push("--json");
   }
@@ -20,7 +21,7 @@ const buildArgs = (options) => {
       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) };
+      return { args: withEnv(["versions", "view", options.versionId], options.env) };
     }
     case "list": {
       return { args: buildListArgs(options) };
@@ -32,7 +33,7 @@ const buildArgs = (options) => {
       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);
+      const args = withEnv(["versions", "deploy", `${options.versionId}@100%`, "--yes"], options.env);
       if (options.message !== void 0) {
         args.push("--message", options.message);
       }
@@ -42,7 +43,7 @@ const buildArgs = (options) => {
       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);
+      const args = withEnv(["rollback"], options.env);
       if (options.versionId !== void 0) {
         args.push(options.versionId);
       }
@@ -63,7 +64,9 @@ const runDeploymentsCommand = async (options) => {
     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() };
+  const cwd = options.cwd ?? process.cwd();
+  const exec = execArgsFor(detectPackageManager(cwd), "wrangler", args);
+  const descriptor = { args: exec.args, command: exec.command, cwd };
   options.logger.info(`${descriptor.command} ${descriptor.args.join(" ")}`);
   const spawner = options.spawner ?? defaultSpawner;
   const result = await spawner(descriptor);

package/dist/packem_chunks/handler7.mjs

@@ -1,5 +1,5 @@
-import { d as defineHandler } from '../packem_shared/command-BC30oSBW.mjs';
-import { o as openUrl } from '../packem_shared/open-url-Dfq6fAyT.mjs';
+import { d as defineHandler } from '../packem_shared/command-lYnl4QyF.mjs';
+import { o as openUrl } from '../packem_shared/open-url-4PBLY9X0.mjs';
 
 const DEFAULT_DOCS_URL = "https://lunora.anolilab.dev/docs";
 const trimSlashes = (value) => {

package/dist/packem_chunks/handler8.mjs

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { findWranglerFile, readWranglerJsonc, validateWranglerConfig, isPlaceholderValue, DEV_VARS_FILE, parseDevVariableEntries, inferLunoraBindings } from '@lunora/config';
-import { d as defineHandler } from '../packem_shared/command-BC30oSBW.mjs';
+import { d as defineHandler } from '../packem_shared/command-lYnl4QyF.mjs';
 
 const SECRET_KEY_PATTERN = /(?:KEY|PASSWORD|SECRET|TOKEN)$/u;
 const isD1PlaceholderId = (databaseId) => {