@xano/sdk 1.0.0

package/dist/ephemeral-command-CLJJKOFT.js

@@ -0,0 +1,592 @@
+import {
+  printMicroserviceSection,
+  readMicroservices
+} from "./chunk-FXRQOWTE.js";
+import {
+  readUnanswered
+} from "./chunk-AWEIIR2U.js";
+import {
+  confirm
+} from "./chunk-65HWOMGV.js";
+import {
+  exportWorkspaceBundle
+} from "./chunk-CJHQKJU4.js";
+import "./chunk-3DRXWLJ5.js";
+import "./chunk-X4DVXBFY.js";
+import "./chunk-TRJCALW3.js";
+import {
+  heldElsewhereError,
+  refuseUnreachableWorkspace,
+  whereaboutsOf
+} from "./chunk-KTSDSD36.js";
+import {
+  resolveOutputTarget,
+  secretsPhrase,
+  writeExportFile
+} from "./chunk-SAVJUS2X.js";
+import {
+  secretsCarriedBy,
+  secretsInMultidoc
+} from "./chunk-45UIT5T2.js";
+import "./chunk-HRVBLCVJ.js";
+import "./chunk-YHEFQUQB.js";
+import {
+  assertOneName
+} from "./chunk-ZIY7RNUT.js";
+import "./chunk-DAD3ONIS.js";
+import {
+  projectDirFrom
+} from "./chunk-6NNTNXN7.js";
+import {
+  LookupFailedError,
+  SourceError,
+  isServerError,
+  isUnansweredLookup,
+  lookupFailed,
+  unansweredCause
+} from "./chunk-QCNYHBL7.js";
+import "./chunk-2ZUEE4EK.js";
+import "./chunk-AN6BL47T.js";
+import {
+  getAccessToken
+} from "./chunk-ET4Y4XCB.js";
+import "./chunk-SWBF2LTK.js";
+import {
+  displayNameHint,
+  displayNameOwner,
+  isShared,
+  nearBackendLines,
+  nearBackendName,
+  sharedDisplayHint
+} from "./chunk-UZ6QQWJT.js";
+import "./chunk-A3UDOZB6.js";
+import "./chunk-2MNLRIOX.js";
+import "./chunk-3M4LFYNQ.js";
+import "./chunk-AM4FKL4J.js";
+import {
+  clearEnvironment,
+  clearEnvironmentsNamed,
+  clearEphemeralLanding,
+  getEnvironment,
+  readEphemeralState
+} from "./chunk-5QU2P5CA.js";
+import "./chunk-ZYJP6BOO.js";
+import "./chunk-QO6BVGS5.js";
+import "./chunk-JZGVVJSI.js";
+import {
+  deleteEphemeral,
+  getEphemeral,
+  isExpired,
+  listAllEphemeral,
+  listEphemeral,
+  namedEphemeral
+} from "./chunk-7G3CTU7I.js";
+import {
+  multidocAnswer
+} from "./chunk-6PBR37LN.js";
+import "./chunk-T5KELPAR.js";
+import "./chunk-622HUCZT.js";
+import {
+  contextFlags
+} from "./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 {
+  describeWrite
+} from "./chunk-4KHEMC32.js";
+import "./chunk-ROY4YAEQ.js";
+import "./chunk-TLQE7ZN3.js";
+import "./chunk-WRBKLYSJ.js";
+import "./chunk-3LDULPRE.js";
+import "./chunk-XW6KISBB.js";
+import {
+  writeData
+} from "./chunk-AWQ7BQTQ.js";
+import "./chunk-EUUUMY7J.js";
+import {
+  TransportError,
+  fetchReadOrExplain,
+  httpFailureError
+} from "./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,
+  discloseWriteTarget,
+  formatExpiration,
+  formatFields,
+  info,
+  isBackendHandle,
+  isMachineOutput,
+  printHuman,
+  safeText,
+  stdoutStyle,
+  step,
+  success,
+  unknownSubcommand,
+  verbBackendName,
+  warn,
+  writeJson,
+  writeTargetPayload
+} from "./chunk-PTHVMXZI.js";
+import "./chunk-2CMJZDCL.js";
+import "./chunk-5V5XU32D.js";
+import "./chunk-GSGDWJB5.js";
+import "./chunk-ERVIASGL.js";
+import "./chunk-4POWHT2K.js";
+import "./chunk-H2V3N23D.js";
+import "./chunk-UTI5G6OJ.js";
+import "./chunk-2EZ3ZJZZ.js";
+import "./chunk-6MR5TI5V.js";
+import {
+  shellQuote
+} from "./chunk-5ZSO4T2G.js";
+import "./chunk-XNCP4KYO.js";
+import "./chunk-YU4HSQW7.js";
+import "./chunk-TFFGOFVZ.js";
+import "./chunk-L5JYN3NM.js";
+import "./chunk-G554NZNI.js";
+import "./chunk-N5GKCWE5.js";
+import "./chunk-OXA6PSZT.js";
+import "./chunk-VAX3UZOY.js";
+import "./chunk-NZOWWHU5.js";
+import "./chunk-4BW2SG2N.js";
+import "./chunk-TTEIYD5P.js";
+import "./chunk-CIMQZRRE.js";
+import "./chunk-OHX6MIUZ.js";
+import "./chunk-36JUQZVQ.js";
+import "./chunk-PZ5AY32C.js";
+
+// src/emit/ephemeral-command.ts
+import { basename, join, sep } from "path";
+var TIMEOUT_MS = 12e4;
+function goneError(name, clearedState, liveness = "gone", flags = "") {
+  const tail = clearedState ? " (cleared its local record)" : "";
+  return new SourceError(
+    `Ephemeral "${name}" has expired or no longer exists. Run \`xanosdk deploy${flags}\` to create a fresh one.${tail}`,
+    liveness,
+    "ephemeral"
+  );
+}
+async function resolveLive(auth, parentWorkspaceId, name, flags = "", verb = "get", verbFlags = "") {
+  const summary = await lookup(auth, parentWorkspaceId, name);
+  if (summary === null || isExpired(summary.expiresAt)) {
+    const owner = summary === null ? await displayNameOwner(auth, "ephemeral", name) : void 0;
+    if (owner !== void 0) throw displayNameError(name, owner, "", (n) => `xanosdk ephemeral ${verb} ${shellQuote(n)}${verbFlags}${flags}`);
+    const cleared = summary === null ? await clearMissedRecord(
+      auth,
+      name,
+      (where) => heldElsewhereError(auth, where, name, "no local record was cleared", `xanosdk ephemeral ${verb} ${shellQuote(name)}${verbFlags}${flags}`, {
+        verb,
+        name
+      })
+    ) : clearStaleRecord(auth, name);
+    const err = summary === null && !cleared ? unknownError(name, flags) : goneError(name, cleared, summary === null ? "gone" : "expired", flags);
+    const near = summary === null ? await nearEphemeral(auth, name) : void 0;
+    if (near === void 0) throw err;
+    throw new SourceError(
+      `${err.message}${nearBackendLines(near, (n) => `\`xanosdk ephemeral ${verb} ${shellQuote(n)}${verbFlags}${flags}\`.`)}`,
+      err instanceof SourceError ? err.liveness : "gone",
+      "ephemeral",
+      near.name,
+      near.names
+    );
+  }
+  return summary;
+}
+async function nearEphemeral(auth, name) {
+  return nearBackendName(auth, ["ephemeral"], name).catch(() => void 0);
+}
+async function nearForDelete(auth, kinds, name, noun) {
+  if (!isBackendHandle(name)) return nearBackendName(auth, kinds, name).catch(() => void 0);
+  return nearBackendName(auth, kinds, name, true).catch((err) => {
+    throw isUnansweredLookup(err) ? deleteLookupFailed(noun, name, err) : err;
+  });
+}
+async function clearMissedRecord(auth, name, elsewhere) {
+  await refuseUnreachableWorkspace(auth);
+  const where = await whereaboutsOf(auth, name, "ephemeral");
+  if (where.at === "elsewhere") throw elsewhere(where);
+  return where.at === "nowhere" && clearStaleRecord(auth, name);
+}
+async function confirmMissEverywhere(auth, name, kinds, noun, command) {
+  await refuseUnreachableWorkspace(auth);
+  const where = await whereaboutsOf(auth, name, kinds);
+  const nothing = "nothing was deleted, and no local record was cleared";
+  if (where.at === "elsewhere") {
+    throw heldElsewhereError(auth, where, name, nothing, command, {
+      verb: "delete",
+      name,
+      deleted: false,
+      alreadyGone: false,
+      declined: false,
+      clearedLandingRecord: false
+    });
+  }
+  if (where.at === "unknown") {
+    throw new LookupFailedError(
+      `Could not confirm ${noun} "${name}" is gone from every workspace this credential reaches (${where.detail}) \u2014 ${nothing}`,
+      "unreachable",
+      noun
+    ).withRerun(command);
+  }
+}
+async function lookup(auth, parentWorkspaceId, name, deleting = false) {
+  try {
+    return await getEphemeral(auth, { parentWorkspaceId, name });
+  } catch (err) {
+    if (isUnansweredLookup(err)) throw (deleting ? deleteLookupFailed : lookupFailed)("ephemeral", name, err);
+    throw err;
+  }
+}
+function deleteLookupFailed(kind, name, err) {
+  return asDeleteLookupFailure(lookupFailed(kind, name, err));
+}
+function asDeleteLookupFailure(err) {
+  if (!(err instanceof LookupFailedError)) return err;
+  return new LookupFailedError(
+    err.head.replace(/nothing was created or changed$/, "nothing was deleted"),
+    err.liveness,
+    err.kind
+  );
+}
+function unknownError(name, flags = "") {
+  return new SourceError(
+    `No ephemeral named "${name}". \`xanosdk ephemeral list${flags}\` shows the ones that exist.`,
+    "gone",
+    "ephemeral"
+  );
+}
+function displayNameError(name, owner, tail, rerun) {
+  if (isShared(owner)) {
+    const names = owner.owners.map((o) => o.name);
+    return new SourceError(
+      `No ephemeral named "${name}"${tail}.
+${sharedDisplayHint(name, owner, (o) => `\`${rerun(o.name)}\`.`)}`,
+      "gone",
+      "ephemeral",
+      names[0],
+      names
+    );
+  }
+  return new SourceError(
+    `No ephemeral named "${name}"${tail}.
+${displayNameHint("ephemeral", name, owner, `run \`${rerun(owner)}\`.`)}`,
+    "gone",
+    "ephemeral",
+    owner
+  );
+}
+function clearStaleRecord(auth, name, deleted = false) {
+  const tracked = getEnvironment(readEphemeralState(process.cwd()), auth);
+  const landing = clearEphemeralLanding(process.cwd(), auth.instance, name);
+  const own = tracked?.name === name && clearEnvironment(process.cwd(), auth);
+  const any = deleted && clearEnvironmentsNamed(process.cwd(), auth.instance, name);
+  return own || any || landing;
+}
+async function runEphemeralCommand(args) {
+  switch (args.subcommand) {
+    case "list":
+      return runList(args);
+    case "get":
+      return runGet(args);
+    case "delete":
+      return runDelete(args);
+    case "export":
+      return runExport(args);
+    default:
+      throw unknownSubcommand("ephemeral", args.subcommand, args.positionals);
+  }
+}
+async function runList(args) {
+  const auth = await getAccessToken(args);
+  const rows = await (args.allWorkspaces ? listAllEphemeral(auth) : listEphemeral(auth, { parentWorkspaceId: auth.workspaceId })).catch((err) => {
+    throw readUnanswered("ephemeral", "list ephemerals", "an empty list", err);
+  });
+  if (isMachineOutput(args)) {
+    writeJson({
+      ephemerals: rows.map((r) => ({ ...r, selector: `ephemeral:${r.name}`, workspaceId: r.workspaceId ?? auth.workspaceId }))
+    });
+    return;
+  }
+  const s = stdoutStyle();
+  if (rows.length === 0) {
+    process.stdout.write("No ephemeral tenants found\n");
+    return;
+  }
+  const lines = rows.map((r) => {
+    const exp = formatExpiration(r.expiresAt);
+    const expTxt = exp === "expired" ? s.red("expired") : s.dim(`expires ${exp}`);
+    const state = r.state ? s.dim(`[${safeText(r.state)}]`) : "";
+    const ws = args.allWorkspaces && r.workspaceId ? s.dim(` (workspace ${r.workspaceId})`) : "";
+    const label = r.display && r.display !== r.name ? ` ${s.dim(safeText(r.display))}` : "";
+    return `  ${s.bold(safeText(r.name))}${label} ${state} ${expTxt}${ws}`;
+  });
+  printHuman(lines.join("\n") + "\n");
+}
+async function runGet(args) {
+  const name = requireName(args, "get");
+  const auth = await getAccessToken(args);
+  const parentWorkspaceId = auth.workspaceId;
+  const summary = await resolveLive(auth, parentWorkspaceId, name, contextFlags(args), "get", args.json === true ? " --json" : "");
+  const microservices = summary.url === void 0 ? [] : await readMicroservices(auth, summary.url);
+  if (isMachineOutput(args)) {
+    writeJson({ ...summary, microservices, selector: `ephemeral:${summary.name}`, workspaceId: parentWorkspaceId });
+    return;
+  }
+  const s = stdoutStyle();
+  const rows = [];
+  if (summary.url) rows.push(["Base URL", s.bold(s.cyan(summary.url))]);
+  const label = summary.display && summary.display !== summary.name ? ` ${s.dim(summary.display)}` : "";
+  rows.push(["Tenant", `${s.bold(summary.name)}${label}`]);
+  if (summary.state) rows.push(["State", summary.state]);
+  rows.push(["Expires", s.dim(formatExpiration(summary.expiresAt))]);
+  printHuman("\n" + formatFields(rows));
+  printMicroserviceSection(microservices);
+}
+async function runDelete(args) {
+  const name = requireName(args, "delete");
+  const auth = await getAccessToken(args);
+  const parentWorkspaceId = auth.workspaceId;
+  const found = await lookup(auth, parentWorkspaceId, name, true);
+  const jsonFlag = args.json === true ? " --json" : "";
+  if (found === null) {
+    const owner = await displayNameOwner(auth, "ephemeral", name);
+    if (owner !== void 0) {
+      const yes = args.yes && !isShared(owner) ? " --yes" : "";
+      throw displayNameError(name, owner, " \u2014 nothing was deleted", (n) => `xanosdk ephemeral delete ${shellQuote(n)}${jsonFlag}${contextFlags(args)}${yes}`);
+    }
+  }
+  const near = found === null ? await nearForDelete(auth, ["ephemeral"], name, "ephemeral") : void 0;
+  if (found === null && (!isBackendHandle(name) || near !== void 0)) {
+    const meant = near === void 0 ? "" : nearBackendLines(near, deleteFix(args, jsonFlag));
+    throw new SourceError(
+      `No ephemeral named "${name}" \u2014 nothing was deleted. \`xanosdk ephemeral list${contextFlags(args)}\` shows the ones that exist.${meant}`,
+      "gone",
+      "ephemeral",
+      near?.name,
+      near?.names
+    );
+  }
+  if (found === null) {
+    const yes = args.yes ? " --yes" : "";
+    await confirmMissEverywhere(auth, name, "ephemeral", "ephemeral", `xanosdk ephemeral delete ${shellQuote(name)}${yes}${jsonFlag}${contextFlags(args)}`);
+  }
+  const named = found === null ? `ephemeral "${name}"` : namedEphemeral(found);
+  const refusing = !args.yes && found !== null && process.stdin.isTTY !== true;
+  if (found !== null) {
+    step(`${refusing ? "Would delete" : "Deleting"} ${named}`);
+    discloseWriteTarget({ base: auth.instance, workspaceId: auth.workspaceId });
+  }
+  const display = found?.display !== void 0 && found.display !== name ? found.display : void 0;
+  const destination = {
+    ...writeTargetPayload({ base: auth.instance, workspaceId: auth.workspaceId, kind: "ephemeral", label: name }),
+    url: found?.url ?? null,
+    display: display ?? null
+  };
+  if (!args.yes && found !== null) {
+    const ok = await confirm(`Delete ${named}? This destroys it and everything it serves.`, {
+      flag: "--yes",
+      // As `tenant delete` refuses off a terminal: the details, and this delete with `--yes`.
+      refusal: {
+        details: { verb: "delete", name, deleted: false, alreadyGone: false, declined: false, clearedLandingRecord: false },
+        rerun: `xanosdk ephemeral delete ${shellQuote(name)} --yes${args.json === true ? " --json" : ""}${contextFlags(args)}`
+      }
+    });
+    if (!ok) {
+      info("Deletion cancelled \u2014 nothing was deleted.");
+      if (isMachineOutput(args)) {
+        writeJson({ verb: "delete", destination, name, deleted: false, alreadyGone: false, declined: true, clearedLandingRecord: false });
+      }
+      return;
+    }
+  }
+  const { alreadyGone } = found === null ? { alreadyGone: true } : await describeWrite(
+    { what: `the delete of ${named}`, resolveWith: `xanosdk ephemeral get ${shellQuote(name)}${contextFlags(args)}` },
+    () => deleteEphemeral(auth, { parentWorkspaceId, name, verified: found.type === "ephemeral" })
+  ).catch((err) => {
+    const recordKept = getEnvironment(readEphemeralState(process.cwd()), auth)?.name === name;
+    throw unknownDeleteOutcome(err, named, name, contextFlags(args), "ephemeral", recordKept);
+  });
+  const cleared = clearStaleRecord(auth, name, found !== null);
+  if (alreadyGone) {
+    const meant = near === void 0 ? "" : nearBackendLines(near, deleteFix(args, jsonFlag)).replace(/\n/g, " ");
+    warn(
+      found === null && !cleared ? `No ephemeral named "${name}" \u2014 nothing was deleted.${meant}` : `Ephemeral "${name}" was already gone${cleared ? " (cleared its local record)" : ""}.${meant}`,
+      "ephemeral.not-found"
+    );
+  } else {
+    success(`Deleted ${named}${cleared ? " (cleared its local record)" : ""}`);
+  }
+  if (isMachineOutput(args)) {
+    writeJson({
+      verb: "delete",
+      destination,
+      name,
+      deleted: !alreadyGone,
+      alreadyGone,
+      declined: false,
+      clearedLandingRecord: cleared,
+      ...near === void 0 ? {} : { suggestion: near.name }
+    });
+  }
+}
+function unknownDeleteOutcome(err, named, name, flags, noun = "ephemeral", recordKept = noun !== "release") {
+  if (!(err instanceof Error)) return err;
+  const head = err.message.split("\n")[0];
+  if (/\nNothing was sent — retry\.$/.test(err.message)) {
+    const again = `xanosdk ${noun} delete ${shellQuote(name)}${flags} --yes`;
+    return new Error(`${head}
+Nothing was sent \u2014 nothing was deleted. Once it is reachable, run \`${again}\` again.`, {
+      cause: err
+    });
+  }
+  if (!/may or may not have taken effect/.test(err.message)) return err;
+  const check = `xanosdk ${noun} ${noun === "release" ? "show" : "get"} ${shellQuote(name)}${flags}`;
+  return new Error(
+    `${head}
+${named.charAt(0).toUpperCase()}${named.slice(1)} may or may not have been deleted \u2014 check with \`${check}\` before retrying.${recordKept ? " Its local record was kept." : ""}`,
+    { cause: err }
+  );
+}
+async function runExport(args) {
+  const typed = args.positionals[0] === void 0 ? void 0 : requireName(args, "export");
+  const format = args.format ?? "json";
+  const ext = format === "multidoc" ? "xs" : "json";
+  const path = args.path ?? defaultExportDir();
+  const provisional = resolveOutputTarget({ path, name: args.name ?? typed ?? "ephemeral", ext });
+  refuseIgnoredName(args, provisional, ext);
+  const auth = await getAccessToken(args);
+  const { resolveEphemeralName } = await import("./env-target-O4HRKTGZ.js");
+  const name = typed ?? await resolveEphemeralName(auth, void 0);
+  const target = typed !== void 0 || args.name !== void 0 ? provisional : resolveOutputTarget({ path, name, ext });
+  const parentWorkspaceId = auth.workspaceId;
+  const exportFlags = (args.path !== void 0 ? ` --path ${shellQuote(args.path)}` : "") + (args.format !== void 0 ? ` --format ${shellQuote(args.format)}` : "") + (args.name !== void 0 ? ` --name ${shellQuote(args.name)}` : "") + (args.json === true ? " --json" : "");
+  const summary = await resolveLive(auth, parentWorkspaceId, name, contextFlags(args), "export", exportFlags);
+  let content;
+  let secrets;
+  if (format === "multidoc") {
+    content = await fetchEphemeralMultidoc(auth, parentWorkspaceId, name);
+    secrets = secretsInMultidoc(content);
+  } else {
+    const bundle = await fetchEphemeralBundle(auth, summary, name);
+    content = JSON.stringify(bundle, null, 2);
+    secrets = secretsCarriedBy(bundle);
+  }
+  if (target.kind === "stdout") {
+    writeData(process.stdout, content + "\n");
+    if (secrets.length > 0) {
+      warn(
+        `The export carries ${secretsPhrase(secrets)} in cleartext \u2014 written to stdout, where no file permission protects it; do not commit or log it.`,
+        "secrets.cleartext-stdout"
+      );
+    }
+    return;
+  }
+  writeExportFile(target.path, content + "\n", secrets);
+  if (isMachineOutput(args)) writeJson({ path: target.path, format });
+  success(`Exported ephemeral ${name}${format === "multidoc" ? " (multidoc)" : ""} \u2192 ${target.path}`);
+}
+function defaultExportDir(cwd = process.cwd()) {
+  return join(projectDirFrom(cwd) ?? cwd, ".xano", "exports") + sep;
+}
+function refuseIgnoredName(args, target, ext) {
+  if (args.name === void 0) return;
+  if (target.kind === "stdout") {
+    throw new UsageError(
+      "`--name` names the exported file, and `--path -` writes the export to stdout instead of a file. Drop one: `--path -` to pipe it, or `--name` (with or without a `--path` directory) to write a file.",
+      { hintFor: { command: "ephemeral", subcommand: "export" } }
+    );
+  }
+  if (basename(target.path) !== `${args.name}.${ext}`) {
+    throw new UsageError(
+      `\`--name\` names the exported file, and \`--path ${args.path}\` already names one. Drop one: \`--path <file>\` alone, or \`--name\` with a \`--path\` directory (or none, for the current one).`,
+      { hintFor: { command: "ephemeral", subcommand: "export" } }
+    );
+  }
+}
+async function fetchEphemeralMultidoc(auth, parentWorkspaceId, name) {
+  const action = "ephemeral export";
+  const url = new URL(`/api:meta/workspace/${parentWorkspaceId}/tenant/${encodeURIComponent(name)}/multidoc`, auth.instance);
+  try {
+    const res = await fetchReadOrExplain(
+      url.href,
+      {
+        headers: { accept: "text/x-xanoscript", Authorization: `Bearer ${auth.access_token}` },
+        signal: AbortSignal.timeout(TIMEOUT_MS)
+      },
+      action,
+      TIMEOUT_MS
+    );
+    const text = await res.text();
+    if (!res.ok) throw Object.assign(httpFailureError(action, res, text), { status: res.status });
+    return multidocAnswer(text, action, url.href);
+  } catch (err) {
+    if (!(err instanceof TransportError) && !isServerError(err)) throw err;
+    throw unansweredExport(err);
+  }
+}
+async function fetchEphemeralBundle(auth, summary, name) {
+  if (summary.url === void 0) throw goneError(name, false);
+  try {
+    return await exportWorkspaceBundle(auth, {
+      base: summary.url,
+      workspaceId: 1,
+      label: "ephemeral export"
+    });
+  } catch (err) {
+    if (!(err instanceof TransportError) && !isServerError(err)) throw err;
+    const again = await getEphemeral(auth, { parentWorkspaceId: auth.workspaceId, name }).then(
+      (s) => s === null || isExpired(s.expiresAt) ? "gone" : "live",
+      () => "unknown"
+    );
+    if (again === "gone") throw goneError(name, false);
+    throw unansweredExport(err, again === "live" ? namedEphemeral(summary) : void 0);
+  }
+}
+function unansweredExport(err, stillThere) {
+  const head = ((err instanceof Error ? err.message : String(err)).split("\n")[0] ?? "").trim().replace(/[.:]$/, "");
+  const what = err instanceof TransportError ? err.timeout ? "The export timed out" : "The connection dropped during the export" : `${unansweredCause(err)}, not a missing ephemeral`;
+  return new LookupFailedError(
+    `${head}.
+${what}${stillThere === void 0 ? "" : ` \u2014 ${stillThere} is still there`}; nothing was written`,
+    "unreachable",
+    "ephemeral"
+  );
+}
+function requireName(args, verb) {
+  const name = args.positionals[0]?.trim();
+  if (name === void 0 || name === "") {
+    throw new UsageError(
+      `\`xanosdk ephemeral ${verb}\` needs an ephemeral name. \`xanosdk ephemeral list${contextFlags(args)}\` shows the ones that exist.`,
+      { hintFor: { command: "ephemeral", subcommand: verb } }
+    );
+  }
+  assertOneName(args.positionals[0], "the ephemeral name", { args, helpFor: { command: "ephemeral", subcommand: verb } });
+  return verbBackendName(name, "ephemeral", { command: "ephemeral", subcommand: verb }, contextFlags(args));
+}
+function deleteFix(args, jsonFlag) {
+  return (n) => `\`xanosdk ephemeral delete ${shellQuote(n)}${jsonFlag}${contextFlags(args)}\` deletes it, after asking to confirm.`;
+}
+export {
+  asDeleteLookupFailure,
+  confirmMissEverywhere,
+  defaultExportDir,
+  deleteLookupFailed,
+  fetchEphemeralBundle,
+  nearForDelete,
+  resolveLive,
+  runEphemeralCommand,
+  unknownDeleteOutcome
+};
+//# sourceMappingURL=ephemeral-command-CLJJKOFT.js.map

package/dist/ephemeral-state-PYCBSOGX.js

@@ -0,0 +1,61 @@
+import {
+  allLandings,
+  clearEnvironment,
+  clearEnvironmentsNamed,
+  clearEphemeralLanding,
+  environmentKey,
+  ephemeralLandedOn,
+  ephemeralLandingKey,
+  ephemeralStatePath,
+  getEnvironment,
+  markEnvironmentFilled,
+  readEphemeralState,
+  recordEphemeralLanding,
+  recordStaticUrl,
+  setEnvironment,
+  unreadableEphemeralState
+} from "./chunk-5QU2P5CA.js";
+import "./chunk-ZYJP6BOO.js";
+import "./chunk-QO6BVGS5.js";
+import "./chunk-JZGVVJSI.js";
+import "./chunk-FWD7AL6N.js";
+import "./chunk-TLQE7ZN3.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-PTHVMXZI.js";
+import "./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";
+export {
+  allLandings,
+  clearEnvironment,
+  clearEnvironmentsNamed,
+  clearEphemeralLanding,
+  environmentKey,
+  ephemeralLandedOn,
+  ephemeralLandingKey,
+  ephemeralStatePath,
+  getEnvironment,
+  markEnvironmentFilled,
+  readEphemeralState,
+  recordEphemeralLanding,
+  recordStaticUrl,
+  setEnvironment,
+  unreadableEphemeralState
+};
+//# sourceMappingURL=ephemeral-state-PYCBSOGX.js.map

package/dist/file-lock-PT74GWYW.js

@@ -0,0 +1,10 @@
+import {
+  tryLock,
+  withFileLockSync
+} from "./chunk-QO6BVGS5.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  tryLock,
+  withFileLockSync
+};
+//# sourceMappingURL=file-lock-PT74GWYW.js.map