@xano/sdk 1.0.0

package/dist/tenant-command-D5HGI2X4.js

@@ -0,0 +1,965 @@
+import {
+  assertNoMergeFlags,
+  reportEnvLanding,
+  reportNotRun
+} from "./chunk-BHACRS6R.js";
+import {
+  OperationError,
+  createOperation,
+  runOperation
+} from "./chunk-TLHIFK4M.js";
+import "./chunk-X677DMZM.js";
+import "./chunk-LRN4ZJCQ.js";
+import "./chunk-RTJRZFFY.js";
+import {
+  assertReleaseIdentitiesFree
+} from "./chunk-WKQLGKCL.js";
+import {
+  passwordHashesWarning,
+  passwordOrigin,
+  readUnanswered
+} from "./chunk-AWEIIR2U.js";
+import "./chunk-FQJ2TTHP.js";
+import "./chunk-K6RXBGUB.js";
+import {
+  confirm
+} from "./chunk-65HWOMGV.js";
+import {
+  forgetLanding,
+  holdsLanding,
+  landingLockPath,
+  recordForeignLanding
+} from "./chunk-CGVQZXYG.js";
+import {
+  CONSTRAINT_FIX,
+  CONSTRAINT_PHRASE,
+  additiveChanges,
+  alteringChanges,
+  assertStorageModesKept,
+  constraintStop,
+  constraintWhere,
+  discloseCanonicalMoves,
+  discloseTableEffects,
+  droppedAndAdded,
+  droppedTableLine,
+  movesClause,
+  namedConstraint,
+  readOnce,
+  releaseCanonicalMoves,
+  releaseTableEffects,
+  stoppingRetypes,
+  tableEffectsPayload,
+  xdoConversionRefusal,
+  xdoConversionRefused
+} from "./chunk-BWPNT55T.js";
+import "./chunk-TPHWJ7UG.js";
+import {
+  countTableRows,
+  listTables,
+  tableRowCounter
+} from "./chunk-C6RIMRU4.js";
+import "./chunk-WQFNASK4.js";
+import {
+  asWorkspaceArchive,
+  passwordSeedColumns
+} from "./chunk-AOSYVMUS.js";
+import {
+  exportWorkspaceBundle
+} from "./chunk-CJHQKJU4.js";
+import {
+  decodeWorkspaceArchive
+} from "./chunk-3DRXWLJ5.js";
+import "./chunk-X4DVXBFY.js";
+import {
+  SettledWriteFailure
+} from "./chunk-A6E77GDW.js";
+import "./chunk-TRJCALW3.js";
+import "./chunk-LIEOKXKD.js";
+import "./chunk-D7VGG3WS.js";
+import "./chunk-2TFRR6JV.js";
+import "./chunk-45UIT5T2.js";
+import "./chunk-HRVBLCVJ.js";
+import "./chunk-YHEFQUQB.js";
+import "./chunk-ETO6LGLD.js";
+import {
+  assertOneName
+} from "./chunk-ZIY7RNUT.js";
+import "./chunk-DAD3ONIS.js";
+import "./chunk-HHN734BU.js";
+import "./chunk-LPECSJ2J.js";
+import "./chunk-6NNTNXN7.js";
+import {
+  SourceError,
+  describeBackend,
+  isUnansweredLookup,
+  resolveSource
+} from "./chunk-QCNYHBL7.js";
+import {
+  downloadRelease,
+  listReleases,
+  promotableReleaseName,
+  untenantDeployableReleasePart
+} from "./chunk-2ZUEE4EK.js";
+import "./chunk-AN6BL47T.js";
+import {
+  getAccessToken
+} from "./chunk-ET4Y4XCB.js";
+import "./chunk-SWBF2LTK.js";
+import {
+  displayNameHint,
+  displayNameOwner,
+  displayNameOwnerOfEither,
+  isShared,
+  sharedDisplayHint
+} from "./chunk-UZ6QQWJT.js";
+import {
+  deleteTenant,
+  deployReleaseToTenant,
+  getTenant,
+  isFailedMicroservice,
+  listTenants,
+  tenantHasWorkspace
+} from "./chunk-A3UDOZB6.js";
+import "./chunk-2MNLRIOX.js";
+import "./chunk-3M4LFYNQ.js";
+import "./chunk-AM4FKL4J.js";
+import "./chunk-Q325JKYB.js";
+import "./chunk-STSFNCY4.js";
+import "./chunk-I4F5TCJH.js";
+import {
+  clearEnvironment,
+  ephemeralStatePath,
+  getEnvironment,
+  readEphemeralState
+} from "./chunk-5QU2P5CA.js";
+import "./chunk-ZYJP6BOO.js";
+import "./chunk-QO6BVGS5.js";
+import "./chunk-JZGVVJSI.js";
+import "./chunk-7G3CTU7I.js";
+import "./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 {
+  shellWord
+} from "./chunk-FWD7AL6N.js";
+import "./chunk-2GNFDZA2.js";
+import "./chunk-JTUKLCXS.js";
+import {
+  describeWrite
+} from "./chunk-4KHEMC32.js";
+import "./chunk-U64O2MXY.js";
+import "./chunk-ROY4YAEQ.js";
+import "./chunk-P2HAGF6H.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 {
+  UNTRUSTED_CERTIFICATE,
+  certificateFailureCode,
+  certificateFailureHost
+} from "./chunk-YLDALTWZ.js";
+import "./chunk-5FBYXK5P.js";
+import "./chunk-LLNZGEFK.js";
+import "./chunk-QXTKSOFI.js";
+import "./chunk-X2NL4KUO.js";
+import "./chunk-3KZCLN4Z.js";
+import "./chunk-FXFV3KU6.js";
+import "./chunk-OPHB5ORL.js";
+import "./chunk-UCQ2VUTG.js";
+import "./chunk-DGWHAVRG.js";
+import "./chunk-27GWNP2I.js";
+import "./chunk-3YW23UFH.js";
+import "./chunk-JGE7CAWB.js";
+import {
+  UsageError,
+  backendDestinationPayload,
+  detail,
+  discloseWriteTarget,
+  displayPath,
+  info,
+  isBackendHandle,
+  isMachineOutput,
+  parseSource,
+  printHuman,
+  safeText,
+  stdoutStyle,
+  step,
+  success,
+  unknownSubcommand,
+  verbBackendName,
+  warn,
+  writeJson,
+  writeTargetPayload
+} from "./chunk-PTHVMXZI.js";
+import "./chunk-MXHSQOC4.js";
+import "./chunk-6IUMKYWI.js";
+import "./chunk-2CMJZDCL.js";
+import "./chunk-CTMO46PK.js";
+import "./chunk-ZDPP6RKB.js";
+import "./chunk-K5BBGTYZ.js";
+import "./chunk-LQCMKAJ7.js";
+import "./chunk-YGZHHAAB.js";
+import "./chunk-XVBGLISP.js";
+import "./chunk-6HO3NCSJ.js";
+import "./chunk-5V5XU32D.js";
+import "./chunk-GSGDWJB5.js";
+import "./chunk-HVRUQXGD.js";
+import "./chunk-ERVIASGL.js";
+import "./chunk-4POWHT2K.js";
+import "./chunk-H2V3N23D.js";
+import "./chunk-3JDU4VRL.js";
+import "./chunk-WTPZRR4I.js";
+import "./chunk-UTI5G6OJ.js";
+import "./chunk-2EZ3ZJZZ.js";
+import "./chunk-6MR5TI5V.js";
+import "./chunk-5ZSO4T2G.js";
+import "./chunk-XNCP4KYO.js";
+import "./chunk-AKNCFVKZ.js";
+import "./chunk-YU4HSQW7.js";
+import "./chunk-TFFGOFVZ.js";
+import "./chunk-EHP3WPEG.js";
+import "./chunk-L5JYN3NM.js";
+import "./chunk-Q7DGTQ5G.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/tenant-command.ts
+async function runTenantCommand(args) {
+  switch (args.subcommand) {
+    case "list":
+      return runList(args);
+    case "get":
+      return runGet(args);
+    case "deploy":
+      return runDeploy(args);
+    case "delete":
+      return runDelete(args);
+    default:
+      throw unknownSubcommand("tenant", args.subcommand, args.positionals);
+  }
+}
+function requireTenant(args, verb, at = 0) {
+  const name = args.positionals[at];
+  if (name === void 0 || name === "") {
+    throw new UsageError(
+      `\`xanosdk tenant ${verb}\` needs a tenant name. Run \`xanosdk tenant list${contextFlags(args)}\` to see them.`,
+      // One line and the pointer: the sentence says what to type.
+      { hintFor: { command: "tenant", subcommand: verb } }
+    );
+  }
+  assertOneName(name, "the tenant name", { args, helpFor: { command: "tenant", subcommand: verb } });
+  return verbBackendName(name, "tenant", { command: "tenant", subcommand: verb }, contextFlags(args));
+}
+function tenantVerbHint(verb, args, lead = "") {
+  return {
+    displayNameOf: displayNameOwner,
+    displayNameFix: (_kind, name, typo) => typo === true ? `run \`xanosdk tenant ${verb} ${shellWord(name)}${lead}${jsonFlag(args)}${contextFlags()}\`.` : `tenant commands take its name: \`xanosdk tenant ${verb} ${shellWord(name)}${lead}${answerFlags(args)}${contextFlags()}\`.`
+  };
+}
+async function swappedDeployArgs(err, auth, first, second, args) {
+  if (!(err instanceof SourceError) || err.liveness !== "gone" || isMalformedName(second)) return void 0;
+  const bare = second.startsWith("tenant:") ? second.slice("tenant:".length) : second;
+  const tenant = await getTenant(auth, { workspaceId: auth.workspaceId, name: bare }).catch(() => null);
+  if (tenant === null) return void 0;
+  const release = first.startsWith("release:") ? first.slice("release:".length) : first;
+  return new SourceError(
+    `No tenant named "${first}", and "${bare}" is a tenant \u2014 \`xanosdk tenant deploy\` takes the tenant first, then the release. Nothing was sent.
+Run \`xanosdk tenant deploy ${shellWord(bare)} ${shellWord(release)}${jsonFlag(args)}${contextFlags()}\`.`,
+    "gone",
+    "tenant",
+    bare
+  );
+}
+function isMalformedName(value) {
+  return /^(?:release|ephemeral|workspace|branch|local):/.test(value);
+}
+function jsonFlag(args) {
+  return args.json === true ? " --json" : "";
+}
+function answerFlags(args) {
+  return `${args.yes ? " --yes" : ""}${args.json === true ? " --json" : ""}`;
+}
+async function runList(args) {
+  const auth = await getAccessToken(args);
+  const rows = await listTenants(auth, { workspaceId: auth.workspaceId }).catch((err) => {
+    throw readUnanswered("tenant", "list tenants", "an empty list", err);
+  });
+  const releases = await releaseNamesById(auth, rows);
+  if (isMachineOutput(args)) {
+    writeJson({
+      tenants: rows.map((t) => ({ ...withDeployFields(t, releases), selector: `tenant:${t.name}`, workspaceId: auth.workspaceId }))
+    });
+    return;
+  }
+  if (rows.length === 0) {
+    info("No tenants under this workspace.");
+    return;
+  }
+  const s = stdoutStyle();
+  for (const t of rows) {
+    const display = t.display !== void 0 && t.display !== t.name ? `  ${s.dim(`(${safeText(t.display)})`)}` : "";
+    printHuman(`${s.bold(safeText(t.name))}${display}  ${safeText(t.state ?? "-")}  ${safeText(t.url ?? "")}
+`);
+    detail(deployedLine(t, releases));
+  }
+}
+function withDeployFields(t, releases) {
+  return {
+    ...t,
+    deployedAt: t.deployedAt ?? null,
+    deployedReleaseId: t.deployedReleaseId ?? null,
+    deployedReleaseName: t.deployedReleaseId === void 0 ? null : releases.get(t.deployedReleaseId) ?? null
+  };
+}
+function deployedLine(t, releases) {
+  if (t.deployedReleaseId === void 0) return "release: none deployed";
+  const name = releases.get(t.deployedReleaseId);
+  const which = name === void 0 ? `#${t.deployedReleaseId} (no longer listed)` : `${safeText(name)} (#${t.deployedReleaseId})`;
+  return `release: ${which}${t.deployedAt === void 0 ? "" : `, deployed ${safeText(t.deployedAt)}`}`;
+}
+async function releaseNamesById(auth, tenants) {
+  if (!tenants.some((t) => t.deployedReleaseId !== void 0)) return /* @__PURE__ */ new Map();
+  const rows = await listReleases(auth, { workspaceId: auth.workspaceId }).catch(() => []);
+  return new Map(rows.flatMap((r) => r.id === void 0 ? [] : [[r.id, r.name]]));
+}
+async function runGet(args) {
+  const name = requireTenant(args, "get");
+  const auth = await getAccessToken(args);
+  let record = null;
+  const resolved = await resolveSource(
+    parseSource(name, ["tenant"], { command: "tenant", subcommand: "get" }),
+    async () => auth,
+    { getTenant: async (a, o) => record = await getTenant(a, o), workspaceless: "any", ...tenantVerbHint("get", args) }
+  );
+  const seen = record;
+  const releases = seen === null ? /* @__PURE__ */ new Map() : await releaseNamesById(auth, [seen]);
+  if (isMachineOutput(args)) {
+    writeJson({
+      id: seen?.id,
+      name,
+      display: seen?.display,
+      type: seen?.type,
+      url: resolved.target.base,
+      state: seen?.state,
+      deployedAt: seen?.deployedAt ?? null,
+      deployedReleaseId: seen?.deployedReleaseId ?? null,
+      deployedReleaseName: seen?.deployedReleaseId === void 0 ? null : releases.get(seen.deployedReleaseId) ?? null,
+      selector: `tenant:${name}`,
+      workspaceId: auth.workspaceId
+    });
+    return;
+  }
+  const s = stdoutStyle();
+  const display = seen?.display !== void 0 && seen.display !== name ? `  ${s.dim(`(${safeText(seen.display)})`)}` : "";
+  printHuman(`${s.bold(safeText(name))}${display}
+`);
+  detail(resolved.target.base);
+  if (seen?.type !== void 0) detail(`type: ${safeText(seen.type)}`);
+  if (seen?.state !== void 0) detail(`state: ${safeText(seen.state)}`);
+  if (seen !== null) detail(deployedLine(seen, releases));
+}
+async function runDeploy(args) {
+  assertNoMergeFlags(args);
+  const tenant = requireTenant(args, "deploy");
+  const releaseArg = args.positionals[1];
+  if (releaseArg === void 0 || releaseArg === "") {
+    throw new UsageError(
+      `\`xanosdk tenant deploy\` needs a release: \`xanosdk tenant deploy ${shellWord(tenant)} <release>${contextFlags(args)}\`. Run \`xanosdk release list${contextFlags(args)}\` to see them.`,
+      { hintFor: { command: "tenant", subcommand: "deploy" } }
+    );
+  }
+  assertOneName(releaseArg, "the release name", { args, helpFor: { command: "tenant", subcommand: "deploy" } });
+  const unlandable = untenantDeployableReleasePart(releaseArg);
+  if (unlandable !== void 0) {
+    throw new UsageError(
+      `Release "${releaseArg}" cannot be landed on a tenant: its name holds \`${unlandable}\`, which the landing route cannot address (\`|\` reads as a filter, and a name holding \`=\` is never found). Nothing was sent.
+Cut it again as \`xanosdk release create ${shellWord(promotableReleaseName(releaseArg))}\` from the source \`xanosdk release show ${shellWord(releaseArg)}${contextFlags(args)}\` names, and land that.`,
+      { hintFor: { command: "tenant", subcommand: "deploy" } }
+    );
+  }
+  if (args.static !== void 0) {
+    throw new UsageError(
+      `\`--static\` publishes a site into the workspace a deploy writes, and a tenant's static hosting is scoped to the tenant. \`xanosdk tenant deploy\` does not publish one.`,
+      { helpFor: { command: "tenant", subcommand: "deploy" } }
+    );
+  }
+  const auth = await getAccessToken(args);
+  let before = null;
+  const target = await resolveSource(
+    parseSource(tenant, ["tenant"], { command: "tenant", subcommand: "deploy" }),
+    async () => auth,
+    {
+      getTenant: async (a, o) => before = await getTenant(a, o),
+      // A tenant with no workspace yet gets one from this landing.
+      workspaceless: "any",
+      ...tenantVerbHint("deploy", args, ` ${shellWord(releaseArg)}`)
+    }
+  ).catch(async (err) => {
+    throw await swappedDeployArgs(err, auth, tenant, releaseArg, args) ?? err;
+  });
+  const release = await resolveSource(
+    parseSource(releaseArg, ["release"], { command: "tenant", subcommand: "deploy" }),
+    async () => auth
+  );
+  const previous = before;
+  const previousDeployedAt = previous?.deployedAt ?? null;
+  const previousDeployedReleaseId = previous?.deployedReleaseId ?? null;
+  let previousReleaseDeleted = false;
+  const previousDeployedReleaseName = previousDeployedReleaseId === null ? null : previousDeployedReleaseId === release.release?.id ? release.release.name : await listReleases(auth, { workspaceId: auth.workspaceId }).then(
+    (rows) => {
+      const hit = rows.find((r) => r.id === previousDeployedReleaseId);
+      previousReleaseDeleted = hit === void 0;
+      return hit?.name ?? null;
+    },
+    () => null
+  );
+  const ephemeral = target.target.tenantType === "ephemeral";
+  const named = `${ephemeral ? "ephemeral" : "tenant"} "${tenant}"`;
+  const display = target.target.display !== void 0 && target.target.display !== "" ? target.target.display : void 0;
+  const destination = {
+    base: auth.instance,
+    workspaceId: auth.workspaceId
+  };
+  step(`Deploying release ${release.target.label} to ${describeBackend(target)}`);
+  discloseWriteTarget(destination);
+  if (previousDeployedReleaseId !== null) {
+    const shown = previousDeployedReleaseName !== null ? `"${previousDeployedReleaseName}"` : `#${previousDeployedReleaseId}${previousReleaseDeleted ? " (deleted since)" : ""}`;
+    detail(
+      `last landed release ${shown}${previousDeployedAt !== null ? ` (deployed ${previousDeployedAt})` : ""}` + (previousDeployedReleaseId === release.release?.id ? " \u2014 this lands it again" : "") + ` \u2014 any \`deploy --to tenant:\` merge since may have changed what it runs`
+    );
+  }
+  let archiveBytes;
+  const releaseBytes = () => {
+    const id = release.release?.id;
+    if (id === void 0) return Promise.reject(new Error("the release carries no id"));
+    archiveBytes ??= downloadRelease(auth, { workspaceId: release.target.workspaceId, id, base: release.target.base }).catch(
+      (err) => {
+        archiveBytes = void 0;
+        throw err;
+      }
+    );
+    return archiveBytes;
+  };
+  const loadArchive = readOnce(
+    async () => release.release?.id === void 0 ? void 0 : decodeWorkspaceArchive(await releaseBytes())
+  );
+  const firstLanding = !ephemeral && !await tenantHasWorkspace(auth, target.target.base);
+  const loadLive = readOnce(
+    () => firstLanding ? Promise.resolve({ payload: {} }) : exportWorkspaceBundle(auth, {
+      base: target.target.base,
+      workspaceId: target.target.workspaceId,
+      label: `reading ${named}`,
+      safeErrors: true
+    })
+  );
+  if (firstLanding) {
+    detail(`${named} has no workspace yet, so this is its first landing: nothing is served there to preview or replace.`);
+  } else {
+    await assertPreLandingReadsAnswered(args, {
+      reads: [
+        ...release.release?.id === void 0 ? [] : [{ what: `release "${release.target.label}"'s archive`, read: releaseBytes }],
+        { what: `what ${named} serves`, read: loadLive }
+      ],
+      command: `tenant deploy ${shellWord(tenant)} ${shellWord(release.target.label)}`,
+      named
+    });
+  }
+  if (!firstLanding) await assertTenantIdentitiesFree(args, auth, {
+    releaseBytes,
+    loadArchive,
+    loadLive,
+    label: release.target.label,
+    tenant: {
+      base: target.target.base,
+      workspaceId: target.target.workspaceId,
+      type: ephemeral ? "ephemeral" : "tenant",
+      name: tenant,
+      ...display === void 0 ? {} : { display }
+    },
+    named
+  });
+  const tables = firstLanding ? void 0 : await releaseTableEffects(loadArchive, loadLive, {
+    mode: "replace",
+    skipTables: new Set((release.release?.seededTables ?? []).map((t) => t.name))
+  });
+  const landingEffects = tables !== void 0 && "effects" in tables ? await withDroppedRows(auth, tables.effects, target.target) : void 0;
+  if (!firstLanding) {
+    reportNotRun(
+      "tenant",
+      landingEffects === void 0 || alteringChanges(landingEffects).length + additiveChanges(landingEffects).length > 0
+    );
+  }
+  await reportEnvLanding(auth, {
+    release: { id: release.release?.id, name: release.target.label },
+    releaseHost: { base: release.target.base, workspaceId: auth.workspaceId },
+    target: target.target,
+    targetLabel: named,
+    // A tenant write asks first and refuses off a terminal without `--yes`; an
+    // ephemeral write does not ask.
+    envSetTo: ephemeral ? ` --to ${shellWord(`ephemeral:${tenant}`)}${contextFlags(args)}` : ` --to ${shellWord(`tenant:${tenant}`)} --yes${contextFlags(args)}`,
+    loadArchive,
+    loadLive
+  });
+  const seedRows = firstLanding ? [] : await seedRowsReplaced(auth, release, target.target, named);
+  if (landingEffects !== void 0) {
+    discloseTableEffects(landingEffects, { subject: "the tenant deploy", additiveWhere: `${named}'s tables` });
+    await assertStorageModesKept(landingEffects.storageChanges, tableRowCounter(auth, target.target), {
+      target: named,
+      subject: "the tenant deploy",
+      mode: "replace"
+    });
+  } else if (tables !== void 0 && "failure" in tables) {
+    warn(
+      `Could not read ${named}'s tables (${tables.failure}), so what the landing does to the columns it keeps \u2014 drops, retypes, removed enum values \u2014 is not checked.`,
+      "plan.target-unreadable"
+    );
+  }
+  const moves = await Promise.all([loadArchive(), loadLive()]).then(
+    ([archive, live]) => releaseCanonicalMoves(archive, live),
+    () => []
+  );
+  discloseCanonicalMoves(moves, { subject: "the tenant deploy" });
+  const passwordHashesUnverifiable = await warnPasswordHashes(auth, release, tenant, named, ephemeral, releaseBytes);
+  const op = createOperation({
+    operation: "tenant deploy",
+    // The one destination shape: `kind` by the target's actual type (a tenant
+    // deploy can name an ephemeral), `label` its bare name, `url` its own URL.
+    destination: backendDestinationPayload(auth, {
+      kind: ephemeral ? "ephemeral" : "tenant",
+      name: tenant,
+      url: target.target.base,
+      ...display === void 0 ? {} : { display }
+    }),
+    release: {
+      instance: release.target.base,
+      workspaceId: release.target.workspaceId,
+      id: release.release?.id,
+      name: release.release?.name ?? release.target.label
+    },
+    branch: null,
+    steps: ["deploy"],
+    extras: {
+      tenant: { name: tenant, url: target.target.base, ...display === void 0 ? {} : { display } },
+      previousDeployedAt,
+      previousDeployedReleaseId,
+      previousDeployedReleaseName,
+      // The text's caveat, for the `--json` reader (E2E pass 30): the previous
+      // release is the last one LANDED, not necessarily what it runs.
+      previousDeployedCaveat: previousDeployedReleaseId === null ? null : "the last landed release; a `deploy --to tenant:` merge since may have changed what it runs",
+      declined: false,
+      firstLanding,
+      landingRecord: null,
+      seedRowsReplaced: seedRows,
+      tableEffects: landingEffects === void 0 ? null : tableEffectsPayload(landingEffects),
+      canonicalMoves: moves.map((m) => ({ ...m })),
+      // The stderr warning's columns, for the `--json` reader who never sees it.
+      ...passwordHashesUnverifiable !== void 0 ? { passwordHashesUnverifiable } : {}
+    }
+  });
+  const resolveWith = `xanosdk tenant get ${shellWord(tenant)} --json${contextFlags(args)}`;
+  const { pipedYes } = await import("./retry-command-AS5EVREX.js");
+  const noRecovery = previousReleaseDeleted ? `The release it last landed (#${previousDeployedReleaseId}) has been deleted, so there is none to put back. Re-cut it from the source it came from and land that, or put this project's code back with \`xanosdk deploy --to ${shellWord(`tenant:${tenant}`)}${pipedYes(args)}${contextFlags(args)}\`.` : "No earlier release is recorded on it to put back.";
+  const recoverWith = previousDeployedReleaseName === null ? null : `xanosdk tenant deploy ${shellWord(tenant)} ${shellWord(previousDeployedReleaseName)} --yes${contextFlags(args)}`;
+  let outcome;
+  let declined = false;
+  try {
+    await runOperation(
+      op,
+      { machine: isMachineOutput(args), resolveWith, what: "the tenant deploy" },
+      async (o) => {
+        if (args.yes !== true) {
+          const { yesRerun } = await import("./retry-command-AS5EVREX.js");
+          const { rerun, note } = yesRerun(args, `tenant deploy ${shellWord(tenant)} ${shellWord(release.target.label)}`);
+          const dropped = landingEffects?.droppedTables ?? [];
+          const droppedColumns = landingEffects?.droppedColumns ?? [];
+          const paired = landingEffects === void 0 ? [] : droppedAndAdded(landingEffects);
+          const stopping = landingEffects === void 0 ? [] : stoppingRetypes(landingEffects);
+          const ok = await confirm(
+            (firstLanding ? `Land release "${release.target.label}" on ${named}? It is the tenant's first landing.` : `Replace what ${named} serves with release "${release.target.label}"? Anything not in the release \u2014 an API an earlier landing or a \`deploy --to tenant:\` merge added \u2014 is removed. Static hosting is kept.`) + (dropped.length === 0 ? "" : ` It DROPS ${dropped.length === 1 ? "table" : "tables"} ${dropped.map(droppedTableLine).join(", ")} with every row \u2014 the release does not carry ${dropped.length === 1 ? "it" : "them"}.`) + (droppedColumns.length === 0 ? "" : ` It DROPS ${droppedColumns.length === 1 ? "column" : "columns"} ${droppedColumns.join(", ")} with every value.`) + (seedRows.length === 0 ? "" : ` It also REPLACES the rows of ${seedRows.map((r) => `${r.table} (${rowsPhrase(r)})`).join(", ")}.`) + (stopping.length === 0 ? "" : ` It can STOP partway on ${stopping.join(", ")} (see above), leaving ${named} partly replaced.`) + movesClause(moves),
+            {
+              flag: "--yes",
+              refusal: {
+                details: {
+                  landed: false,
+                  declined: false,
+                  droppedTables: dropped.map((t) => ({ ...t })),
+                  droppedColumns: [...droppedColumns],
+                  pairedColumns: paired,
+                  canonicalMoves: moves.map((m) => ({ ...m }))
+                },
+                rerun,
+                note
+              }
+            }
+          );
+          if (!ok) {
+            info("Deploy cancelled \u2014 nothing was written.");
+            o.set("declined", true);
+            declined = true;
+            o.finish("deploy", "no");
+            return;
+          }
+        }
+        step(`Landing ${release.target.label} on ${tenant}`);
+        o.begin("deploy");
+        o.sending();
+        outcome = await deployReleaseToTenant(auth, {
+          workspaceId: auth.workspaceId,
+          tenant,
+          release: release.target.label
+        }).catch((err) => {
+          if (xdoConversionRefused(err)) {
+            throw xdoConversionRefusal(named, err, new SettledWriteFailure(err.message, { cause: err }));
+          }
+          const found = constraintStop(err);
+          if (found === void 0) throw err;
+          const stop = namedConstraint(found, landingEffects);
+          o.set("partlyReplaced", true);
+          o.set("constraint", stop);
+          o.set("recoverWith", recoverWith);
+          throw new SettledWriteFailure(err instanceof Error ? err.message : String(err), { cause: err });
+        });
+        o.set("deployedAt", outcome.deployedAt ?? null);
+        o.set("microservices", outcome.microservices);
+        o.finish("deploy");
+        o.set("landingRecord", await recordTenantLanding(auth, args, release, tenant, ephemeral, releaseBytes));
+      }
+    );
+  } catch (err) {
+    if (declined) return;
+    if (err instanceof SettledWriteFailure) {
+      const stop = namedConstraint(constraintStop(err.cause), landingEffects);
+      const conversion = stop.kind === "conversion";
+      warn(
+        `The deploy stopped partway: ${conversion ? "a stored value does not convert to a column type" : `the tenant's data breaks ${CONSTRAINT_PHRASE[stop.kind]}`} release "${release.target.label}" declares${constraintWhere(stop)}` + (stop.notNull === true ? ` \u2014 answered as a NOT NULL violation, though the release makes no field required: the value converts to null, and the column is not nullable. ` : `. `) + `${named} may be partly replaced \u2014 serving some of "${release.target.label}" and some of what it ran before` + (conversion ? `, with the values of the tables it reached already converted for good.` : `.`),
+        "tenant.deploy-partial",
+        recoverWith === null ? [noRecovery, `${CONSTRAINT_FIX[stop.kind]}, then land "${release.target.label}" again.`] : [
+          `Put back what it ran: \`${recoverWith}\``,
+          `Then ${lowerFirst(CONSTRAINT_FIX[stop.kind])}, and land "${release.target.label}" again.`
+        ]
+      );
+    }
+    if (err instanceof OperationError && err.result.completed === "unknown") {
+      warn(
+        `Compare its \`deployedAt\` and \`deployedReleaseId\` with what they were before this deploy (deployedAt ${previousDeployedAt ?? "none"}, deployedReleaseId ${previousDeployedReleaseId ?? "none"}). A redeploy of the same release leaves the id unchanged, so \`deployedAt\` is the one that moves.`,
+        "tenant.deploy-unconfirmed",
+        [
+          `Moved: "${release.target.label}" landed.`,
+          `Unmoved: it did not land, but a deploy that stopped partway can leave ${named} partly replaced` + (recoverWith === null ? `.` : ` \u2014 \`${recoverWith}\` puts back what it ran.`),
+          ...recoverWith === null ? [noRecovery] : []
+        ]
+      );
+    }
+    throw err;
+  }
+  const failed = (outcome?.microservices ?? []).filter(isFailedMicroservice);
+  if (failed.length > 0) {
+    warn(
+      `${failed.length} microservice(s) did not come up on ${named}: ` + failed.map((m) => m.detail === void 0 ? m.name : `${m.name} (${m.detail})`).join("; ") + `. The release landed; these need attention.`,
+      "microservice.failed"
+    );
+  }
+  success(`Landed ${release.target.label} on ${tenant}${firstLanding ? " (its first landing)" : ""}`);
+  detail(target.target.base);
+}
+async function assertPreLandingReadsAnswered(args, ctx) {
+  for (const { what, read } of ctx.reads) {
+    let failure;
+    try {
+      await read();
+      continue;
+    } catch (err) {
+      failure = err;
+    }
+    const { LookupFailedError, isTransportFailure, isUnansweredLookup: isUnansweredLookup2 } = await import("./source-resolve-S2XA3XZF.js");
+    if (!isUnansweredLookup2(failure)) continue;
+    const { retryCommand, withheldNote } = await import("./retry-command-AS5EVREX.js");
+    const retry = retryCommand(args, { command: ctx.command });
+    const certificate = certificateFailureCode(failure);
+    const cause = certificate !== void 0 ? `${UNTRUSTED_CERTIFICATE} (${certificate}) at ${certificateFailureHost(failure)} \u2014 a certificate or proxy configuration problem, not a network blip` : isTransportFailure(failure) ? "a network failure" : "a server error";
+    const refused = new LookupFailedError(
+      `Could not read ${what}, which the checks before a landing compare (${cause}). Nothing was sent and ${ctx.named} is untouched \u2014 a replace does not land with its checks off`,
+      "unreachable",
+      "tenant",
+      `run \`${retry.command}\` again`
+    );
+    refused.message += withheldNote(retry.withheld);
+    throw refused;
+  }
+}
+async function assertTenantIdentitiesFree(args, auth, ctx) {
+  let typed;
+  let bundle;
+  try {
+    typed = asWorkspaceArchive(await ctx.releaseBytes(), ctx.label);
+    bundle = await ctx.loadArchive();
+  } catch {
+    typed = void 0;
+  }
+  let reason;
+  if (typed === void 0 || bundle === void 0) {
+    reason = "the release archive could not be read";
+  } else {
+    const check = await assertReleaseIdentitiesFree(args, auth, {
+      archive: typed,
+      bundle,
+      lockPath: landingLockPath(args),
+      live: await ctx.loadLive().catch(() => void 0),
+      tenant: ctx.tenant,
+      subject: `deploy release "${ctx.label}"`,
+      verb: "tenant deploy",
+      remedySuffix: `A release's names and slugs are fixed when it is cut: make the change in the project, deploy it, cut a new release from it with \`xanosdk release create\`, and deploy that one.`
+    });
+    if (!check.checked) reason = check.reason;
+  }
+  if (reason === void 0) return;
+  warn(
+    `Whether this release's names and pinned public URL slugs are free on ${ctx.named} was not checked \u2014 ${reason}.`,
+    "tenant.identities-unchecked",
+    [
+      `A name the tenant gives to another object lands as a suffixed second object, and the tenant's own is dropped \u2014 a table with its rows.`
+    ]
+  );
+}
+async function recordTenantLanding(auth, args, release, tenant, ephemeral, releaseBytes) {
+  const lockPath = landingLockPath(args);
+  const id = release.release?.id;
+  if (lockPath === void 0 && !ephemeral || id === void 0) return null;
+  let archive;
+  try {
+    archive = decodeWorkspaceArchive(await releaseBytes());
+  } catch {
+    archive = void 0;
+  }
+  return recordForeignLanding({
+    lockPath,
+    instance: auth.instance,
+    dest: { kind: ephemeral ? "ephemeral" : "tenant", name: tenant },
+    // Unreadable: nothing on the tenant is known to be this project's any more.
+    bundle: archive ?? {},
+    mode: "replace",
+    ...archive === void 0 ? { unreadable: true } : {}
+  });
+}
+async function warnPasswordHashes(auth, release, tenant, named, ephemeral, releaseBytes) {
+  const found = release.release;
+  if (found?.id === void 0 || (found.seededTables ?? []).length === 0) return void 0;
+  try {
+    const bytes = await releaseBytes();
+    const columns = passwordSeedColumns(bytes);
+    if (columns.length === 0) return void 0;
+    const origin = await passwordOrigin(auth, found);
+    if (origin?.name === tenant) return void 0;
+    warn(passwordHashesWarning(found.name, columns, named, "the landing", origin?.phrase, ephemeral), "seed.password-hashes");
+    return [...columns];
+  } catch {
+    return void 0;
+  }
+}
+async function withDroppedRows(auth, effects, target) {
+  if (effects.droppedTables.length === 0) return effects;
+  const listed = await listTables(auth, { workspaceId: target.workspaceId, base: target.base }).catch(() => void 0);
+  const droppedTables = [];
+  for (const t of effects.droppedTables) {
+    const here = listed?.find((l) => l.name === t.table);
+    const rows = here === void 0 ? null : await countTableRows(auth, { workspaceId: target.workspaceId, tableId: here.id, base: target.base }).catch(
+      () => void 0
+    ) ?? null;
+    droppedTables.push({ ...t, rows });
+  }
+  return { ...effects, droppedTables };
+}
+function rowsPhrase(r) {
+  const live = r.liveRows === null ? "its rows" : `${r.liveRows} ${r.liveRows === 1 ? "row" : "rows"}`;
+  const seed = r.seedRows === null ? "the release's rows" : `${r.seedRows} seed ${r.seedRows === 1 ? "row" : "rows"}`;
+  return `${live} replaced by ${seed}`;
+}
+async function seedRowsReplaced(auth, release, target, named) {
+  const seeded = release.release?.seededTables ?? [];
+  if (seeded.length === 0) return [];
+  const listed = await listTables(auth, { workspaceId: target.workspaceId, base: target.base }).catch(() => void 0);
+  const out = [];
+  for (const t of seeded) {
+    const here = listed?.find((l) => t.guid !== void 0 && l.guid === t.guid || l.name === t.name);
+    const liveRows = listed === void 0 ? null : here === void 0 ? 0 : await countTableRows(auth, { workspaceId: target.workspaceId, tableId: here.id, base: target.base }).catch(
+      () => void 0
+    ) ?? null;
+    out.push({ table: t.name, liveRows, seedRows: t.count ?? null });
+  }
+  const one = out.length === 1;
+  warn(
+    `"${release.target.label}" was cut with rows, and a tenant deploy REPLACES ${one ? "that table's" : "those tables'"} rows on ${named} with the release's \u2014 every row there now is deleted:`,
+    "tenant.seed-replaces-rows",
+    [
+      ...out.map((r) => `table ${r.table}: ${rowsPhrase(r)}`),
+      `Every other table the release carries keeps its rows. To keep these too, land a release cut without \`--seed\`.`
+    ]
+  );
+  return out;
+}
+function lowerFirst(s) {
+  return s.charAt(0).toLowerCase() + s.slice(1);
+}
+async function runDelete(args) {
+  const name = requireTenant(args, "delete");
+  const auth = await getAccessToken(args);
+  let readFailed = false;
+  const record = await getTenant(auth, { workspaceId: auth.workspaceId, name }).catch(async (err) => {
+    if (isUnansweredLookup(err)) {
+      step(`Deleting tenant "${name}"`);
+      discloseWriteTarget({ base: auth.instance, workspaceId: auth.workspaceId });
+      const { deleteLookupFailed } = await import("./ephemeral-command-CLJJKOFT.js");
+      throw deleteLookupFailed("tenant", name, err);
+    }
+    readFailed = true;
+    return null;
+  });
+  const kind = record?.type === "ephemeral" ? "ephemeral" : "tenant";
+  const display = record?.display !== void 0 && record.display !== name ? record.display : void 0;
+  const named = `${kind} "${name}"${display === void 0 ? "" : ` (${JSON.stringify(display)})`}`;
+  const destination = {
+    ...writeTargetPayload({ base: auth.instance, workspaceId: auth.workspaceId, kind, label: name }),
+    url: record?.url ?? null,
+    display: display ?? null
+  };
+  if (record === null) {
+    const owner = await displayNameOwnerOfEither(auth, name);
+    if (isShared(owner)) {
+      throw new SourceError(
+        `No tenant or ephemeral named "${name}" \u2014 nothing was deleted.
+` + sharedDisplayHint(name, owner, (o) => `\`xanosdk tenant delete ${shellWord(o.name)}${jsonFlag(args)}${contextFlags(args)}\` deletes it, after asking to confirm.`),
+        "gone",
+        "tenant",
+        owner.owners[0].name,
+        owner.owners.map((o) => o.name)
+      );
+    }
+    if (owner !== void 0) {
+      throw new SourceError(
+        `No tenant or ephemeral named "${name}" \u2014 nothing was deleted.
+` + displayNameHint(owner.kind, name, owner.name, `tenant commands take its name: \`xanosdk tenant delete ${shellWord(owner.name)}${answerFlags(args)}${contextFlags(args)}\`.`),
+        "gone",
+        "tenant"
+      );
+    }
+    if (!readFailed) {
+      const { nearForDelete, confirmMissEverywhere } = await import("./ephemeral-command-CLJJKOFT.js");
+      const { nearBackendLines } = await import("./display-name-hint-ABBPVQIR.js");
+      const near = await nearForDelete(auth, ["tenant", "ephemeral"], name, "tenant");
+      const names = near === void 0 ? [] : [...near.names ?? [near.name]];
+      const deleteFix = (n) => `\`xanosdk tenant delete ${shellWord(n)}${jsonFlag(args)}${contextFlags(args)}\` deletes it, after asking to confirm.`;
+      if (!isBackendHandle(name) || names.length > 0) {
+        throw new SourceError(
+          `No tenant or ephemeral named "${name}" \u2014 nothing was deleted. \`xanosdk tenant list${contextFlags(args)}\` shows the tenants that exist.` + (near === void 0 ? "" : nearBackendLines(near, deleteFix)),
+          "gone",
+          "tenant",
+          names[0],
+          names.length > 1 ? names : void 0
+        );
+      }
+      await confirmMissEverywhere(auth, name, "either", "tenant", `xanosdk tenant delete ${shellWord(name)}${answerFlags(args)}${contextFlags(args)}`);
+      const lockPath = landingLockPath(args);
+      const ephemeralLanding = forgetLanding(lockPath, auth.instance, { kind: "ephemeral", name });
+      const tracked = getEnvironment(readEphemeralState(process.cwd()), auth)?.name === name && clearEnvironment(process.cwd(), auth);
+      if (ephemeralLanding !== void 0 || tracked) {
+        info(`Removed this project's record of ephemeral "${name}" from ${displayPath(ephemeralStatePath(process.cwd()))}.`);
+      }
+      const clearedLandingRecord2 = forgetLanding(lockPath, auth.instance, { kind: "tenant", name }) !== void 0 || ephemeralLanding !== void 0 || tracked;
+      warn(
+        `No tenant or ephemeral named "${name}" \u2014 nothing was deleted${clearedLandingRecord2 ? "; this project's landing record for it was stale, so it was cleared" : ""}.`,
+        "tenant.not-found",
+        names.map((n) => `Did you mean ${near.kind} "${safeText(n)}"? \`xanosdk tenant delete ${shellWord(n)}${jsonFlag(args)}${contextFlags(args)}\` deletes it, after asking to confirm.`)
+      );
+      if (isMachineOutput(args)) {
+        writeJson({
+          verb: "delete",
+          destination,
+          name,
+          deleted: false,
+          alreadyGone: true,
+          declined: false,
+          clearedLandingRecord: clearedLandingRecord2,
+          // As every did-you-mean in a document: `suggestion`, and `suggestions` when a tie named several.
+          ...names.length === 0 ? {} : { suggestion: names[0] },
+          ...names.length > 1 ? { suggestions: names } : {}
+        });
+      }
+      return;
+    }
+  }
+  const refusing = args.yes !== true && process.stdin.isTTY !== true;
+  step(`${refusing ? "Would delete" : "Deleting"} ${named}`);
+  discloseWriteTarget({ base: auth.instance, workspaceId: auth.workspaceId });
+  if (args.yes !== true) {
+    const ok = await confirm(`Delete ${named}? This destroys it and everything it serves.`, {
+      flag: "--yes",
+      refusal: {
+        details: { verb: "delete", name, deleted: false, alreadyGone: false, declined: false, clearedLandingRecord: false },
+        rerun: `xanosdk tenant delete ${shellWord(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 } = await describeWrite(
+    { what: `the delete of ${named}`, resolveWith: `xanosdk tenant get ${shellWord(name)}${contextFlags(args)}` },
+    () => deleteTenant(auth, { workspaceId: auth.workspaceId, name })
+  ).catch(async (err) => {
+    const { unknownDeleteOutcome } = await import("./ephemeral-command-CLJJKOFT.js");
+    const recordKept = holdsLanding(landingLockPath(args), auth.instance, { kind, name }) || kind === "ephemeral" && getEnvironment(readEphemeralState(process.cwd()), auth)?.name === name;
+    throw unknownDeleteOutcome(err, named, name, contextFlags(args), kind === "ephemeral" ? "ephemeral" : "tenant", recordKept);
+  });
+  if (alreadyGone && record === null) {
+    const { confirmMissEverywhere } = await import("./ephemeral-command-CLJJKOFT.js");
+    await confirmMissEverywhere(auth, name, "either", "tenant", `xanosdk tenant delete ${shellWord(name)}${answerFlags(args)}${contextFlags(args)}`);
+  }
+  let clearedLandingRecord = false;
+  if (kind === "ephemeral") {
+    clearedLandingRecord = forgetLanding(landingLockPath(args), auth.instance, { kind, name }) !== void 0;
+    const tracked = getEnvironment(readEphemeralState(process.cwd()), auth);
+    if (tracked?.name === name) clearedLandingRecord = clearEnvironment(process.cwd(), auth) || clearedLandingRecord;
+  }
+  const clearedNote = kind === "ephemeral" && clearedLandingRecord ? " (cleared its local record)" : "";
+  if (alreadyGone) {
+    warn(
+      record === null ? `No tenant or ephemeral named "${name}" \u2014 nothing was deleted.` : `${kind === "ephemeral" ? "Ephemeral" : "Tenant"} "${name}" was already gone${clearedNote}.`,
+      "tenant.not-found"
+    );
+  } else success(`Deleted ${named}${clearedNote}`);
+  if (kind !== "ephemeral") {
+    clearedLandingRecord = forgetLanding(landingLockPath(args), auth.instance, { kind, name }) !== void 0;
+  }
+  if (isMachineOutput(args)) {
+    writeJson({ verb: "delete", destination, name, deleted: !alreadyGone, alreadyGone, declined: false, clearedLandingRecord });
+  }
+}
+export {
+  constraintStop,
+  runTenantCommand
+};
+//# sourceMappingURL=tenant-command-D5HGI2X4.js.map