@xano/sdk 1.0.0

package/dist/local-engine-command-Z3OL7VOD.js

@@ -0,0 +1,766 @@
+import {
+  pinWrittenText
+} from "./chunk-SFLHVCKX.js";
+import {
+  acquireEngine,
+  restartMismatchedEngine
+} from "./chunk-XBKMWY7F.js";
+import {
+  confirm
+} from "./chunk-65HWOMGV.js";
+import {
+  resolveProjectEntry
+} from "./chunk-AOSYVMUS.js";
+import "./chunk-CJHQKJU4.js";
+import "./chunk-3DRXWLJ5.js";
+import "./chunk-X4DVXBFY.js";
+import {
+  cachedEngineEntry,
+  engineVersion,
+  engineVersionToken,
+  findOrphanedEngineProcesses,
+  listEngines,
+  stopAllEngines,
+  stopEngineNamed,
+  stopOrphanedEngineProcesses
+} from "./chunk-BAUZOWGX.js";
+import {
+  diskBytes,
+  listLegacyCacheDirs,
+  listOverrideEntries,
+  listReleaseEntries,
+  readEngineEntry,
+  readPin,
+  writePin
+} from "./chunk-6ELFRN3P.js";
+import "./chunk-NA3PXMEF.js";
+import {
+  ENGINE_RELEASES_URL_ENV,
+  normalizeEngineVersion,
+  resolveEngineRelease,
+  usesCustomReleaseManager
+} from "./chunk-APWXY5SL.js";
+import "./chunk-2TFRR6JV.js";
+import "./chunk-LPECSJ2J.js";
+import {
+  NO_CREDENTIAL,
+  SourceError,
+  resolveSource
+} from "./chunk-QCNYHBL7.js";
+import "./chunk-2ZUEE4EK.js";
+import "./chunk-AN6BL47T.js";
+import "./chunk-SWBF2LTK.js";
+import "./chunk-UZ6QQWJT.js";
+import "./chunk-A3UDOZB6.js";
+import "./chunk-2MNLRIOX.js";
+import {
+  clearEngineRecordsNamed,
+  listEngineRecords
+} from "./chunk-3M4LFYNQ.js";
+import {
+  SUPPORTED_PLATFORMS,
+  engineRunHome,
+  legacyRuntimeDirs,
+  localEngineBinDir,
+  resolveEnginePlatform
+} from "./chunk-AM4FKL4J.js";
+import "./chunk-5QU2P5CA.js";
+import "./chunk-ZYJP6BOO.js";
+import "./chunk-QO6BVGS5.js";
+import "./chunk-JZGVVJSI.js";
+import "./chunk-7G3CTU7I.js";
+import "./chunk-6PBR37LN.js";
+import {
+  yesRerun
+} from "./chunk-T5KELPAR.js";
+import "./chunk-622HUCZT.js";
+import "./chunk-NAQDMEHV.js";
+import "./chunk-5A2PLKZB.js";
+import "./chunk-AHJWCYQO.js";
+import "./chunk-DX4QR4B2.js";
+import "./chunk-6QXLMMT3.js";
+import "./chunk-ZFDZKNGG.js";
+import "./chunk-FWD7AL6N.js";
+import "./chunk-2GNFDZA2.js";
+import "./chunk-JTUKLCXS.js";
+import "./chunk-4KHEMC32.js";
+import "./chunk-ROY4YAEQ.js";
+import "./chunk-TLQE7ZN3.js";
+import "./chunk-WRBKLYSJ.js";
+import "./chunk-3LDULPRE.js";
+import "./chunk-XW6KISBB.js";
+import "./chunk-AWQ7BQTQ.js";
+import "./chunk-EUUUMY7J.js";
+import "./chunk-YLDALTWZ.js";
+import "./chunk-5FBYXK5P.js";
+import "./chunk-LLNZGEFK.js";
+import "./chunk-QXTKSOFI.js";
+import "./chunk-X2NL4KUO.js";
+import "./chunk-UCQ2VUTG.js";
+import "./chunk-DGWHAVRG.js";
+import {
+  UsageError,
+  detail,
+  info,
+  isMachineOutput,
+  link,
+  printHuman,
+  stdoutStyle,
+  success,
+  unknownSubcommand,
+  warn,
+  writeJson
+} from "./chunk-PTHVMXZI.js";
+import "./chunk-LQCMKAJ7.js";
+import "./chunk-H2V3N23D.js";
+import "./chunk-3JDU4VRL.js";
+import {
+  suggest,
+  suggestAll
+} from "./chunk-UTI5G6OJ.js";
+import "./chunk-2EZ3ZJZZ.js";
+import "./chunk-6MR5TI5V.js";
+import "./chunk-5ZSO4T2G.js";
+import "./chunk-XNCP4KYO.js";
+import "./chunk-TFFGOFVZ.js";
+import "./chunk-NZOWWHU5.js";
+import "./chunk-4BW2SG2N.js";
+import "./chunk-CIMQZRRE.js";
+import "./chunk-OHX6MIUZ.js";
+import "./chunk-36JUQZVQ.js";
+import "./chunk-PZ5AY32C.js";
+
+// src/emit/local-engine-command.ts
+import { readdirSync, rmSync } from "fs";
+import { basename, join } from "path";
+async function runLocalEngineCommand(args, opts = {}) {
+  switch (args.subcommand) {
+    case "list":
+      return runList(args, opts);
+    case "token":
+      return runToken(args, opts);
+    case "stop":
+      return runStop(args, opts);
+    case "update":
+      return runUpdate(args, opts);
+    case "cache":
+      return runCache(args, opts);
+    default:
+      throw unknownSubcommand("local-engine", args.subcommand, args.positionals);
+  }
+}
+function cachedEngine(env, exclude = /* @__PURE__ */ new Set()) {
+  return cachedEngineEntry(env, process.cwd(), exclude);
+}
+async function runList(args, opts) {
+  const env = opts.env ?? process.env;
+  const entry = cachedEngine(env);
+  const orphans = findOrphanedEngineProcesses(sweepOptions(opts, env)).map((p) => p.pid);
+  if (entry === void 0) return report([], args, orphans);
+  const running = listEngines({ entry, env, run: opts.run });
+  const byName = new Map(listEngineRecords(env).map((r) => [r.name, r]));
+  let cached;
+  const rows = running.map((engine) => {
+    const record = byName.get(engine.name);
+    const row = {
+      name: engine.name,
+      url: engine.url,
+      workspaceId: engine.workspaceId,
+      startedByXanoSdk: record !== void 0
+    };
+    if (record === void 0) return row;
+    row.project = record.project;
+    if (record.engineDigest !== entry.digest) {
+      cached ??= engineVersionToken(engineVersion({ entry, env, run: opts.run })) ?? "unknown";
+      row.engineMismatch = { startedFrom: startedFrom(record), cached };
+    }
+    return row;
+  });
+  report(rows, args, orphans);
+}
+function startedFrom(record) {
+  return record.engineVersion ?? `engine ${record.engineDigest.slice(0, 12)}`;
+}
+function report(rows, args, orphans = []) {
+  if (orphans.length > 0) {
+    info(
+      `${orphans.length === 1 ? "A process" : `${orphans.length} processes`} a crashed local engine left running (pid ${orphans.join(", ")}) \u2014 \`xanosdk local-engine stop --all\` stops ${orphans.length === 1 ? "it" : "them"}.`
+    );
+  }
+  if (isMachineOutput(args)) {
+    writeJson({ engines: rows, ...orphans.length === 0 ? {} : { orphanedProcesses: orphans } });
+    reportMismatches(rows);
+    return;
+  }
+  const s = stdoutStyle();
+  if (rows.length === 0) {
+    process.stdout.write("No local engine is running\n");
+    return;
+  }
+  const lines = rows.map((row) => {
+    const owner = row.startedByXanoSdk ? s.dim(row.project ?? "") : s.yellow("foreign \u2014 not started by xanosdk");
+    return `  ${s.bold(row.name)}  ${s.cyan(row.url)}  ${owner}`;
+  });
+  printHuman(lines.join("\n") + "\n");
+  reportMismatches(rows);
+}
+function reportMismatches(rows) {
+  for (const row of rows) {
+    if (row.engineMismatch === void 0) continue;
+    const { startedFrom: from, cached } = row.engineMismatch;
+    const running = from.startsWith("engine ") ? from : `engine ${from}`;
+    warn(
+      `${row.name} is running ${running}, but the engine cached here is ${cached}.`,
+      "local-engine.stale",
+      [
+        `Deploy its project again with \`xanosdk deploy --local-engine\` to restart it on that project's pinned engine, or stop it with \`xanosdk local-engine stop ${row.name}\`.`
+      ]
+    );
+  }
+}
+async function runStop(args, opts) {
+  const env = opts.env ?? process.env;
+  const name = args.positionals[0];
+  if (args.all && name !== void 0 && name !== "") {
+    throw new UsageError(
+      `\`xanosdk local-engine stop\` takes a name or \`--all\`, not both \u2014 \`--all\` already covers "${name}". Drop one of them.`,
+      { hintFor: { command: "local-engine", subcommand: "stop" } }
+    );
+  }
+  if (args.all) return runStopAll(args, opts, env);
+  if (name === void 0 || name === "") {
+    throw new UsageError(
+      `\`xanosdk local-engine stop\` needs the name of an engine, or \`--all\` for every engine xanosdk started on this machine, across projects. Run \`xanosdk local-engine list\` to see them.`,
+      { hintFor: { command: "local-engine", subcommand: "stop" } }
+    );
+  }
+  const assignment = /^([A-Za-z_][A-Za-z0-9_]*)=/.exec(name);
+  if (assignment !== null) {
+    throw new UsageError(
+      `"${assignment[1]}=\u2026" is not a local engine name. Run \`xanosdk local-engine list\` to see what is running.`,
+      { hintFor: { command: "local-engine", subcommand: "stop" } }
+    );
+  }
+  return runStopNamed(name, args, opts, env);
+}
+async function runStopNamed(name, args, opts, env) {
+  const entry = cachedEngine(env);
+  const outcome = entry === void 0 ? { name, stopped: false, clearedProjects: clearEngineRecordsNamed(name, env) } : stopEngineNamed(name, { entry, env, run: opts.run });
+  if (!outcome.stopped) {
+    info(`"${name}" is not running \u2014 nothing to stop${clearedSuffix(outcome)}.`);
+    const nearest = entry === void 0 ? void 0 : nearestRunning(name, entry, env, opts);
+    if (nearest !== void 0) detail(`Did you mean \`${nearest}\`? It is running: \`xanosdk local-engine stop ${nearest}\`.`);
+    else detail("Run `xanosdk local-engine list` to see what is running.");
+    if (isMachineOutput(args)) writeJson({ ...outcome, alreadyStopped: true, ...nearest === void 0 ? {} : { suggestion: nearest } });
+    return;
+  }
+  success(`Stopped ${name}${clearedSuffix(outcome)}`);
+  if (isMachineOutput(args)) writeJson({ ...outcome, alreadyStopped: false });
+}
+function nearestRunning(name, entry, env, opts) {
+  try {
+    return suggest(name, listEngines({ entry, env, run: opts.run }).map((e) => e.name));
+  } catch {
+    return void 0;
+  }
+}
+async function runStopAll(args, opts, env) {
+  const entry = cachedEngine(env);
+  if (entry === void 0) {
+    const orphans = stopOrphanedEngineProcesses(sweepOptions(opts, env));
+    return reportStopAll({ stopped: [], foreign: [], orphans }, clearOrphanRecords(env), args);
+  }
+  const outcome = stopAllEngines({ entry, run: opts.run, ...sweepOptions(opts, env) });
+  reportStopAll(outcome, clearOrphanRecords(env), args);
+}
+function sweepOptions(opts, env) {
+  return {
+    env,
+    ...opts.processes === void 0 ? {} : { processes: opts.processes },
+    ...opts.signal === void 0 ? {} : { signal: opts.signal },
+    ...opts.orphanWaitMs === void 0 ? {} : { waitMs: opts.orphanWaitMs }
+  };
+}
+function reportOrphanSweep(orphans) {
+  const n = orphans.stopped.length;
+  if (n > 0) {
+    success(
+      `Stopped ${n} process${n === 1 ? "" : "es"} a crashed local engine left running (pid ${orphans.stopped.join(", ")}).`
+    );
+  }
+  if (orphans.stillRunning.length > 0) {
+    detail(
+      `Still exiting after the wait: pid ${orphans.stillRunning.join(", ")} \u2014 run \`xanosdk local-engine stop --all\` again in a moment.`
+    );
+  }
+}
+function clearOrphanRecords(env) {
+  const cleared = [];
+  for (const name of new Set(listEngineRecords(env).map((r) => r.name))) {
+    cleared.push(...clearEngineRecordsNamed(name, env));
+  }
+  return cleared;
+}
+function reportStopAll(outcome, staleProjects, args) {
+  for (const stop of outcome.stopped) {
+    if (stop.stopped) success(`Stopped ${stop.name}${clearedSuffix(stop)}`);
+    else warn(`${stop.name} was listed as running but did not stop${clearedSuffix(stop)}.`, "local-engine.stop-failed");
+  }
+  if (outcome.foreign.length > 0) {
+    warn(
+      `Left running, not started by xanosdk: ${outcome.foreign.join(", ")}`,
+      "local-engine.foreign",
+      ["Name one explicitly \u2014 `xanosdk local-engine stop <name>` \u2014 to stop it anyway."]
+    );
+  }
+  reportOrphanSweep(outcome.orphans);
+  if (staleProjects.length > 0) {
+    detail(`Cleared ${staleProjects.length} stale record${staleProjects.length === 1 ? "" : "s"}.`);
+  }
+  const swept = outcome.orphans.stopped.length + outcome.orphans.stillRunning.length;
+  if (outcome.stopped.length === 0 && outcome.foreign.length === 0 && swept === 0) {
+    info("No local engine is running \u2014 nothing to stop.");
+  }
+  if (isMachineOutput(args)) {
+    writeJson({ ...outcome, staleProjects, alreadyStopped: outcome.stopped.length === 0 && swept === 0 });
+  }
+}
+function clearedSuffix(outcome) {
+  const n = outcome.clearedProjects.length;
+  if (n === 0) return "";
+  return n === 1 ? " (cleared its local record)" : ` (cleared its record in ${n} projects)`;
+}
+async function runToken(args, opts) {
+  const engine = await targetEngine(args, opts, "read a token from");
+  if (args.json) {
+    writeJson({ name: engine.name, url: engine.url, workspaceId: engine.workspaceId, token: engine.token });
+    return;
+  }
+  process.stdout.write(engine.token + "\n");
+}
+function targetEngine(args, opts, doing) {
+  return resolveLiveEngine(args.positionals[0], opts, doing);
+}
+async function resolveLiveEngine(named, opts, doing) {
+  const env = opts.env ?? process.env;
+  const entry = cachedEngine(env);
+  if (entry === void 0) {
+    throw new SourceError(
+      `No engine is cached on this machine, so there is nothing here to ${doing}.
+Run \`xanosdk deploy --local-engine\` to fetch one if you meant to use a local engine.`,
+      "gone",
+      "local-engine"
+    );
+  }
+  const resolved = await resolveSource(
+    named === void 0 || named === "" ? { kind: "local-engine" } : { kind: "local-engine", name: named },
+    NO_CREDENTIAL,
+    // A lifecycle verb manages the engine itself; "deploy still reaches an
+    // ephemeral" answers a question nobody running it asked.
+    // The name is this verb's bare positional, so a near one is suggested bare.
+    { env, listEngines: () => listEngines({ entry, env, run: opts.run }), deployFallback: false, bareName: true }
+  );
+  if (resolved.backend.kind !== "local") throw new Error("Internal: a local engine resolved to a hosted backend.");
+  return resolved.backend.engine;
+}
+async function runUpdate(args, opts) {
+  const env = opts.env ?? process.env;
+  const dir = process.cwd();
+  if (usesCustomReleaseManager(env)) {
+    throw new Error(
+      `${ENGINE_RELEASES_URL_ENV} names a custom release manager, and its engines are never pinned \u2014 so the pin was left as is.
+Unset it to move the pin, or keep deploying with it set to run that manager's latest.`
+    );
+  }
+  const read = readPin(dir, { warn: (message) => warn(message, "local-engine.pin-unusable") });
+  if (read === void 0 && resolveProjectEntry(dir) === void 0) {
+    throw new Error(
+      `No package.json in ${dir}, and it is not a Xano SDK project, so there is no engine pin to move.
+Run this from the project's root.`
+    );
+  }
+  const current = typeof read === "object" || read === void 0 ? null : read;
+  const fetch = opts.fetch === void 0 ? {} : { fetch: opts.fetch };
+  const target = await requestedEngineVersion(args.engineVersion ?? "latest", opts, env, "update to");
+  if (current === target) {
+    success(`Already on ${target} \u2014 nothing to update.`);
+    if (isMachineOutput(args)) {
+      writeJson({ from: current, to: target, changed: false, pinPath: join(dir, "package.json"), restarted: null });
+    }
+    return;
+  }
+  const acquired = await acquireEngine({
+    spec: { kind: "release", version: target },
+    env,
+    ...fetch,
+    ...opts.platform === void 0 ? {} : { platform: opts.platform },
+    ...opts.arch === void 0 ? {} : { arch: opts.arch }
+  });
+  const pin = writePin(dir, target);
+  const replaced = await restartMismatchedEngine({
+    dir,
+    acquired,
+    env,
+    ...opts.run === void 0 ? {} : { run: opts.run },
+    ...opts.spawn === void 0 ? {} : { spawn: opts.spawn }
+  });
+  const devEnv = replaced === void 0 ? void 0 : await repointDevEnvAfterRestart(dir, replaced);
+  success(`Local engine ${current ?? "(unpinned)"} \u2192 ${target}`);
+  info(pinWrittenText({ path: pin.path, version: target, created: pin.created, moved: current !== null }));
+  if (replaced !== void 0) {
+    info(`Restarted ${replaced.name} on ${target}. It starts empty \u2014 run your deploy to seed it.`);
+    if (replaced.url !== replaced.previousUrl) {
+      info("New local engine URL:");
+      link(replaced.url);
+    }
+    if (devEnv !== void 0) {
+      detail(`Pointed ${devEnv.label} at the restarted engine (${devEnv.variable}) \u2014 restart your dev server to pick it up.`);
+    }
+  } else {
+    detail(`No engine is running for this project; the next \`xanosdk deploy --local-engine\` starts ${target}.`);
+  }
+  if (isMachineOutput(args)) {
+    writeJson({
+      from: current,
+      to: target,
+      changed: true,
+      pinPath: pin.path,
+      restarted: replaced?.name ?? null,
+      url: replaced?.url ?? null
+    });
+  }
+}
+async function repointDevEnvAfterRestart(dir, restarted) {
+  if (restarted.previousUrl === void 0) return void 0;
+  const { repointDevEnv } = await import("./dev-env-sync-HN44K4D5.js");
+  try {
+    return repointDevEnv(dir, restarted.previousUrl, restarted.url);
+  } catch (err) {
+    warn(err instanceof Error ? err.message : String(err), "dev-env.sync-failed");
+    return void 0;
+  }
+}
+async function requestedEngineVersion(requested, opts, env, purpose) {
+  if (requested.trim() !== "latest") {
+    try {
+      return normalizeEngineVersion(requested);
+    } catch (err) {
+      const clearing = purpose === "clear";
+      throw new UsageError(
+        (err instanceof Error ? err.message : String(err)) + (clearing ? " `cache clear` also takes `override`, or an override's `src-\u2026` id from `cache list`." : ""),
+        { hintFor: { command: "local-engine", subcommand: clearing ? "cache" : "update" } }
+      );
+    }
+  }
+  const platform = resolveEnginePlatform(opts.platform ?? process.platform, opts.arch ?? process.arch);
+  if (platform === void 0) {
+    throw new Error(
+      `There is no local engine build for ${opts.platform ?? process.platform} ${opts.arch ?? process.arch} \u2014 it runs on ${SUPPORTED_PLATFORMS.join(", ")} and nothing else, so there is no engine to ${purpose}. \`xanosdk deploy\` reaches an ephemeral from anywhere.`
+    );
+  }
+  const fetch = opts.fetch === void 0 ? {} : { fetch: opts.fetch };
+  return (await resolveEngineRelease({ platform, env, ...fetch })).version;
+}
+var CACHE_ACTIONS = ["list", "clear"];
+async function runCache(args, opts) {
+  const action = args.positionals[0];
+  if (action === "list") {
+    if (args.engineVersion !== void 0) {
+      throw new UsageError(
+        "`xanosdk local-engine cache list` takes no `--version` \u2014 it lists every cached engine. `cache clear --version <v>` is the one that takes it.",
+        { helpFor: { command: "local-engine", subcommand: "cache" } }
+      );
+    }
+    if (args.legacyRuntime) {
+      throw new UsageError(
+        "`xanosdk local-engine cache list` takes no `--legacy-runtime` \u2014 it lists the earlier runtime copy when there is one. `cache clear --legacy-runtime` is the one that takes it.",
+        { helpFor: { command: "local-engine", subcommand: "cache" } }
+      );
+    }
+    return runCacheList(args, opts);
+  }
+  if (action === "clear") return runCacheClear(args, opts);
+  throw new UsageError(
+    `\`xanosdk local-engine cache\`: ${action === void 0 || action === "" ? "no action given" : `unknown action "${action}"`} \u2014 it takes ${CACHE_ACTIONS.join(" or ")}.`,
+    {
+      helpFor: { command: "local-engine", subcommand: "cache" },
+      suggestion: action === void 0 ? void 0 : suggest(action, CACHE_ACTIONS)
+    }
+  );
+}
+function cachedEntries(env) {
+  return [...listReleaseEntries(env), ...listOverrideEntries(env)];
+}
+function enginesByDigest(running, env) {
+  const records = new Map(listEngineRecords(env).map((r) => [r.name, r]));
+  const out = /* @__PURE__ */ new Map();
+  for (const engine of running) {
+    const digest = records.get(engine.name)?.engineDigest;
+    if (digest === void 0) continue;
+    out.set(digest, [...out.get(digest) ?? [], engine.name]);
+  }
+  return out;
+}
+function entryLabel(entry) {
+  return entry.version ?? `override (${basename(entry.dir)})`;
+}
+async function runCacheList(args, opts) {
+  const env = opts.env ?? process.env;
+  const entries = cachedEntries(env);
+  const legacy = listLegacyCacheDirs(env);
+  const runtime = runtimeRows(env);
+  if (entries.length === 0 && legacy.length === 0 && runtime.length === 0) {
+    if (isMachineOutput(args)) writeJson({ entries: [] });
+    else info("No local engine is cached \u2014 `xanosdk deploy --local-engine` fetches one.");
+    return;
+  }
+  let running = [];
+  const binary = cachedEngine(env);
+  if (binary !== void 0) {
+    try {
+      running = listEngines({ entry: binary, env, ...opts.run === void 0 ? {} : { run: opts.run } });
+    } catch (err) {
+      warn(`Could not list running engines, so none are shown: ${err.message.split("\n")[0]}`, "local-engine.list-failed");
+    }
+  }
+  const using = enginesByDigest(running, env);
+  const onRuntime = running.map((e) => e.name);
+  const rows = [
+    ...entries.map((entry) => ({
+      version: entry.version ?? "override",
+      source: entry.source,
+      id: basename(entry.dir),
+      bytes: diskBytes(entry.dir),
+      engines: using.get(entry.digest) ?? []
+    })),
+    ...legacy.map((dir) => ({
+      version: "legacy",
+      source: "legacy",
+      id: basename(dir),
+      bytes: diskBytes(dir),
+      engines: []
+    })),
+    ...runtime.map((row) => row.source === "runtime" ? { ...row, engines: onRuntime } : row)
+  ];
+  if (isMachineOutput(args)) {
+    writeJson({ entries: rows });
+    return;
+  }
+  const s = stdoutStyle();
+  const labels = rows.map(
+    (row, i) => i < entries.length ? entryLabel(entries[i]) : row.source === "runtime" ? "unpacked runtime" : row.source === "legacy-runtime" ? (
+      // Its full path goes LAST: as the label it padded every row to its length.
+      "earlier runtime copy"
+    ) : `old layout (${row.id})`
+  );
+  const sizes = rows.map((row) => formatBytes(row.bytes));
+  const labelWidth = Math.max(0, ...labels.map((l) => l.length));
+  const sizeWidth = Math.max(0, ...sizes.map((z) => z.length));
+  const lines = rows.map((row, i) => {
+    const on = row.engines.length > 0 ? `  ${s.cyan(`running: ${row.engines.join(", ")}`)}` : row.source === "legacy-runtime" ? `  ${s.dim(row.id)}` : "";
+    const size = sizes[i].padStart(sizeWidth);
+    return `  ${s.bold(labels[i].padEnd(labelWidth))}  ${s.dim(size)}${on}`;
+  });
+  printHuman(lines.join("\n") + "\n");
+  if (legacy.length > 0) {
+    detail("Old-layout directories are never run \u2014 `xanosdk local-engine cache clear` removes them.");
+  }
+  if (runtime.some((r) => r.source === "runtime")) {
+    detail("The unpacked runtime is what the engines run from \u2014 `xanosdk local-engine cache clear` removes it with the engines.");
+  }
+  if (runtime.some((r) => r.source === "legacy-runtime")) {
+    detail(
+      "An earlier runtime copy was left in your own cache directory by an earlier version, and nothing runs from it \u2014 `xanosdk local-engine cache clear --legacy-runtime` removes it."
+    );
+  }
+}
+function runtimeRows(env) {
+  const rows = [];
+  const home = engineRunHome(env);
+  const bytes = diskBytes(home);
+  if (bytes > 0) rows.push({ version: "runtime", source: "runtime", id: home, bytes, engines: [] });
+  for (const dir of legacyRuntimeDirs(env)) {
+    rows.push({ version: "legacy-runtime", source: "legacy-runtime", id: dir, bytes: diskBytes(dir), engines: [] });
+  }
+  return rows;
+}
+async function runCacheClear(args, opts) {
+  const env = opts.env ?? process.env;
+  if (args.legacyRuntime) return clearLegacyRuntime(args, env);
+  const bin = localEngineBinDir(env);
+  const requested = args.engineVersion?.trim();
+  const override = requested !== void 0 && (requested === "override" || requested.startsWith("src-"));
+  const version = requested === void 0 || override ? void 0 : await requestedEngineVersion(requested, opts, env, "clear");
+  const label = override ? requested === "override" ? "the override engine" : requested : version;
+  let doomed;
+  let dirs;
+  if (version !== void 0 || override) {
+    const hits = override ? listOverrideEntries(env).filter((e) => requested === "override" || basename(e.dir) === requested) : [readEngineEntry({ version }, env)].filter((e) => e !== void 0);
+    if (hits.length === 0) {
+      const cached = cachedEntries(env).map(entryLabel);
+      const near = requested === "override" ? [] : suggestAll(label ?? requested ?? "", cached.filter((c) => !c.startsWith("override")));
+      const clear = (v) => `\`xanosdk local-engine cache clear --version ${v}\``;
+      info(
+        `${requested === "override" ? "No override engine is cached" : `${label} is not cached`} \u2014 nothing to clear. ` + (cached.length === 0 ? "No engine is cached." : `Cached: ${cached.join(", ")}.`) + (near.length === 0 ? "" : ` Did you mean ${near.join(" or ")}? ${near.map(clear).join(" or ")}.`)
+      );
+      if (isMachineOutput(args)) {
+        writeJson({
+          stopped: [],
+          removed: [],
+          bytesFreed: 0,
+          alreadyGone: true,
+          cached,
+          ...near.length === 0 ? {} : { suggestion: near[0] },
+          ...near.length > 1 ? { suggestions: near } : {}
+        });
+      }
+      return;
+    }
+    doomed = hits;
+    dirs = hits.map((e) => e.dir);
+  } else {
+    doomed = cachedEntries(env);
+    let names = [];
+    try {
+      names = readdirSync(bin);
+    } catch {
+    }
+    dirs = names.map((n) => join(bin, n));
+  }
+  const last = label !== void 0 && cachedEntries(env).every((e) => dirs.includes(e.dir));
+  const runtime = label === void 0 || last ? engineRunHome(env) : void 0;
+  const runtimeBytes = runtime === void 0 ? 0 : diskBytes(runtime);
+  if (dirs.length === 0 && runtimeBytes === 0) {
+    info("Nothing is cached \u2014 nothing to clear.");
+    if (isMachineOutput(args)) writeJson({ stopped: [], removed: [], bytesFreed: 0, alreadyGone: true });
+    return;
+  }
+  const stopped = stopEnginesOn(doomed, label === void 0, env, opts.run);
+  const stillRunning = runtimeBytes === 0 ? [] : enginesStillRunning(env, opts.run);
+  const labelOf = (d) => {
+    const entry = doomed.find((e) => e.dir === d);
+    return entry === void 0 ? basename(d) : entryLabel(entry);
+  };
+  const items = dirs.map((d) => ({ name: labelOf(d), bytes: diskBytes(d) }));
+  for (const d of dirs) rmSync(d, { recursive: true, force: true });
+  const removed = dirs.map((d) => basename(d));
+  const runtimeRemoved = runtime !== void 0 && runtimeBytes > 0 && stillRunning.length === 0;
+  if (runtimeRemoved) {
+    items.push({ name: "unpacked runtime", bytes: diskBytes(runtime) });
+    rmSync(runtime, { recursive: true, force: true });
+  }
+  const bytesFreed = items.reduce((sum, item) => sum + item.bytes, 0);
+  for (const stop of stopped) {
+    if (stop.stopped) success(`Stopped ${stop.name} \u2014 it ran on an engine being removed`);
+    else warn(`${stop.name} was listed as running but did not stop. Stop it with \`xanosdk local-engine stop ${stop.name}\`.`, "local-engine.stop-failed");
+  }
+  const what = [
+    ...removed.length === 0 ? [] : [label ?? `${removed.length} cached engine director${removed.length === 1 ? "y" : "ies"}`],
+    ...runtimeRemoved ? [last ? "the unpacked runtime, since no cached engine is left to run it" : "the unpacked runtime"] : []
+  ];
+  if (what.length > 0) {
+    success(`Removed ${what.join(" and ")} \u2014 freed ${formatBytes(bytesFreed)}`);
+    if (items.length > 1) for (const item of items) detail(`${item.name}: ${formatBytes(item.bytes)}`);
+    if (runtimeRemoved && stopped.some((s) => s.stopped)) {
+      detail(
+        "The runtime also held the stopped engines' own data, which left with them \u2014 so its size here can be smaller than `cache list` showed while they ran."
+      );
+    }
+  }
+  if (runtimeBytes > 0 && !runtimeRemoved) {
+    warn(
+      `Kept the unpacked runtime (${formatBytes(runtimeBytes)}): ${stillRunning.join(", ")} ${stillRunning.length === 1 ? "is" : "are"} still running on it. Stop every engine (\`xanosdk local-engine stop --all\`), then run \`xanosdk local-engine cache clear\` again.`,
+      "local-engine.runtime-kept"
+    );
+  }
+  if (stopped.length > 0) {
+    detail("The next `xanosdk deploy --local-engine` fetches its engine again and restarts it.");
+  }
+  if (isMachineOutput(args)) {
+    writeJson({ stopped: stopped.map((o) => o.name), removed, runtimeRemoved, items, bytesFreed, alreadyGone: false });
+  }
+}
+function enginesStillRunning(env, run) {
+  const binary = cachedEngine(env);
+  if (binary === void 0) return [];
+  try {
+    return listEngines({ entry: binary, env, ...run === void 0 ? {} : { run } }).map((e) => e.name);
+  } catch {
+    return ["an engine that could not be listed"];
+  }
+}
+async function clearLegacyRuntime(args, env) {
+  if (args.engineVersion !== void 0) {
+    throw new UsageError("`--legacy-runtime` clears the earlier runtime copy, not a cached version \u2014 drop `--version`.", {
+      hintFor: { command: "local-engine", subcommand: "cache" }
+    });
+  }
+  const dirs = legacyRuntimeDirs(env);
+  if (dirs.length === 0) {
+    info("No earlier runtime copy is in your cache directory \u2014 nothing to clear.");
+    if (isMachineOutput(args)) writeJson({ stopped: [], removed: [], bytesFreed: 0, alreadyGone: true });
+    return;
+  }
+  const bytes = dirs.reduce((sum, d) => sum + diskBytes(d), 0);
+  if (!args.yes) {
+    const ok = await confirm(`Delete ${dirs.join(", ")} (${formatBytes(bytes)}), the runtime copy an earlier version left?`, {
+      flag: "--yes",
+      refusal: { details: { removed: [], bytesFreed: 0 }, ...yesRerun(args, "local-engine cache clear --legacy-runtime") }
+    });
+    if (!ok) {
+      info("Nothing was deleted.");
+      return;
+    }
+  }
+  for (const d of dirs) rmSync(d, { recursive: true, force: true });
+  if (isMachineOutput(args)) {
+    writeJson({ stopped: [], removed: dirs, bytesFreed: bytes, alreadyGone: false });
+    return;
+  }
+  success(`Removed the earlier runtime copy \u2014 freed ${formatBytes(bytes)}`);
+}
+function stopEnginesOn(doomed, everything, env, run) {
+  const binary = cachedEngine(env, new Set(doomed.map((e) => e.dir))) ?? cachedEngine(env);
+  if (binary === void 0) return [];
+  const seam = { entry: binary, env, ...run === void 0 ? {} : { run } };
+  let running;
+  try {
+    running = listEngines(seam);
+  } catch (err) {
+    warn(
+      `Could not list running engines, so none were stopped: ${err.message.split("\n")[0]}
+  Any engine still running on a removed version keeps running \u2014 stop it with \`xanosdk local-engine stop <name>\`.`,
+      "local-engine.list-failed"
+    );
+    return [];
+  }
+  const records = new Map(listEngineRecords(env).map((r) => [r.name, r]));
+  const digests = new Set(doomed.map((e) => e.digest));
+  return running.filter((engine) => {
+    const record = records.get(engine.name);
+    return record !== void 0 && (everything || digests.has(record.engineDigest));
+  }).map((engine) => {
+    try {
+      return stopEngineNamed(engine.name, seam);
+    } catch {
+      return { name: engine.name, stopped: false, clearedProjects: [] };
+    }
+  });
+}
+function formatBytes(bytes) {
+  const units = ["B", "KB", "MB", "GB"];
+  let n = bytes;
+  let unit = 0;
+  while (n >= 1024 && unit < units.length - 1) {
+    n /= 1024;
+    unit++;
+  }
+  return unit === 0 ? `${n} B` : `${n.toFixed(1)} ${units[unit]}`;
+}
+export {
+  reportOrphanSweep,
+  resolveLiveEngine,
+  runLocalEngineCommand,
+  sweepOptions
+};
+//# sourceMappingURL=local-engine-command-Z3OL7VOD.js.map