@xanots/sdk 0.0.1

package/dist/ephemeral-command-3X3I4ULC.js

@@ -0,0 +1,242 @@
+import {
+  confirm
+} from "./chunk-5YTBTF25.js";
+import {
+  resolveOutputTarget
+} from "./chunk-XQ22GLYS.js";
+import {
+  exportWorkspaceBundle
+} from "./chunk-QTNO2WD6.js";
+import {
+  deleteEphemeral,
+  getEphemeral,
+  impersonateEphemeral,
+  isExpired,
+  listAllEphemeral,
+  listEphemeral
+} from "./chunk-6DHBYBTO.js";
+import "./chunk-ZUTSMMAG.js";
+import {
+  clearEnvironment,
+  getEnvironment,
+  readEphemeralState
+} from "./chunk-DGSF2Q5H.js";
+import {
+  openBrowser
+} from "./chunk-VTIL47DT.js";
+import "./chunk-X4DVXBFY.js";
+import "./chunk-7DKX2SPN.js";
+import {
+  printMicroserviceSection,
+  readMicroservices
+} from "./chunk-NDZFBZHC.js";
+import {
+  isMachineOutput,
+  writeJson
+} from "./chunk-NUQCEOKA.js";
+import "./chunk-3IGNIP6R.js";
+import {
+  getAccessToken
+} from "./chunk-C56BC2FY.js";
+import "./chunk-7REDODS2.js";
+import {
+  unknownSubcommand
+} from "./chunk-IZW6MK3U.js";
+import {
+  detail,
+  formatExpiration,
+  formatFields,
+  info,
+  stdoutStyle,
+  step,
+  success,
+  warn
+} from "./chunk-EZG76F7R.js";
+import "./chunk-YYRDLFSJ.js";
+import "./chunk-GNPVYOPB.js";
+
+// src/emit/ephemeral-command.ts
+import { writeFileSync } from "fs";
+var TIMEOUT_MS = 12e4;
+function goneError(name, clearedState) {
+  const tail = clearedState ? " (cleared its local record)" : "";
+  return new Error(
+    `Ephemeral "${name}" has expired or no longer exists. Run \`xanots deploy\` to create a fresh one.${tail}`
+  );
+}
+async function resolveLive(auth, parentWorkspaceId, name) {
+  const summary = await getEphemeral(auth, { parentWorkspaceId, name });
+  if (summary === null || isExpired(summary.expiresAt)) {
+    const cleared = clearStaleRecord(parentWorkspaceId, name);
+    throw goneError(name, cleared);
+  }
+  return summary;
+}
+function clearStaleRecord(parentWorkspaceId, name) {
+  const tracked = getEnvironment(readEphemeralState(process.cwd()), parentWorkspaceId);
+  if (tracked?.name === name) return clearEnvironment(process.cwd(), parentWorkspaceId);
+  return false;
+}
+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);
+    case "impersonate":
+      return runImpersonate(args);
+    case "codegen": {
+      const { runCodegenCommand } = await import("./codegen-command-OOKK6AZK.js");
+      return runCodegenCommand(args, { kind: "ephemeral" });
+    }
+    default:
+      throw unknownSubcommand("ephemeral", args.subcommand);
+  }
+}
+async function runList(args) {
+  const auth = await getAccessToken(args);
+  const rows = args.allWorkspaces ? await listAllEphemeral(auth) : await listEphemeral(auth, { parentWorkspaceId: auth.workspaceId });
+  if (isMachineOutput(args)) {
+    writeJson(rows);
+    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(`[${r.state}]`) : "";
+    const ws = args.allWorkspaces && r.workspaceId ? s.dim(` (workspace ${r.workspaceId})`) : "";
+    const label = r.display && r.display !== r.name ? ` ${s.dim(r.display)}` : "";
+    return `  ${s.bold(r.name)}${label} ${state} ${expTxt}${ws}`;
+  });
+  process.stdout.write(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);
+  const microservices = summary.url === void 0 ? [] : await readMicroservices(auth, summary.url);
+  if (isMachineOutput(args)) {
+    writeJson({ ...summary, microservices });
+    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))]);
+  process.stdout.write("\n" + formatFields(rows));
+  printMicroserviceSection(microservices);
+}
+async function runDelete(args) {
+  const name = requireName(args, "delete");
+  const auth = await getAccessToken(args);
+  const parentWorkspaceId = auth.workspaceId;
+  if (!args.yes && !args.force) {
+    const ok = await confirm(`Delete ephemeral "${name}"? This destroys it permanently.`, {
+      flag: "--yes",
+      helpFor: { command: "ephemeral", subcommand: "delete" }
+    });
+    if (!ok) {
+      info("Deletion cancelled.");
+      return;
+    }
+  }
+  const { alreadyGone } = await deleteEphemeral(auth, { parentWorkspaceId, name });
+  const cleared = clearStaleRecord(parentWorkspaceId, name);
+  if (alreadyGone) {
+    warn(`Ephemeral "${name}" was already gone${cleared ? " (cleared its local record)" : ""}.`);
+  } else {
+    success(`Deleted ephemeral ${name}${cleared ? " (cleared its local record)" : ""}`);
+  }
+}
+async function runExport(args) {
+  const name = requireName(args, "export");
+  const format = args.format ?? "json";
+  const auth = await getAccessToken(args);
+  const parentWorkspaceId = auth.workspaceId;
+  const summary = await resolveLive(auth, parentWorkspaceId, name);
+  const { content, ext } = format === "multidoc" ? { content: await fetchEphemeralMultidoc(auth, parentWorkspaceId, name), ext: "xs" } : { content: await fetchEphemeralJson(auth, summary, name), ext: "json" };
+  const target = resolveOutputTarget({ path: args.path, name, ext });
+  if (target.kind === "stdout") {
+    process.stdout.write(content + "\n");
+    return;
+  }
+  writeFileSync(target.path, content + "\n", "utf8");
+  step(`Exported ${format} \u2192 ${target.path}`);
+  success(`Wrote ${target.path}`);
+}
+async function fetchEphemeralMultidoc(auth, parentWorkspaceId, name) {
+  const url = new URL(`/api:meta/workspace/${parentWorkspaceId}/tenant/${name}/multidoc`, auth.instance);
+  const res = await fetch(url.href, {
+    headers: { accept: "text/x-xanoscript", Authorization: `Bearer ${auth.access_token}` },
+    signal: AbortSignal.timeout(TIMEOUT_MS)
+  });
+  const text = await res.text();
+  if (!res.ok) throw new Error(`ephemeral export (multidoc) failed (${res.status} ${res.statusText}):
+${text}`);
+  return text;
+}
+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 (workspace export)"
+    });
+  } catch (err) {
+    if (err instanceof Error && /failed \(\d/.test(err.message)) throw err;
+    detail(err instanceof Error ? err.message : String(err));
+    throw goneError(name, false);
+  }
+}
+async function fetchEphemeralJson(auth, summary, name) {
+  return JSON.stringify(await fetchEphemeralBundle(auth, summary, name), null, 2);
+}
+async function runImpersonate(args) {
+  const name = requireName(args, "impersonate");
+  const auth = await getAccessToken(args);
+  const parentWorkspaceId = auth.workspaceId;
+  await resolveLive(auth, parentWorkspaceId, name);
+  const { _ti } = await impersonateEphemeral(auth, { parentWorkspaceId, name, guest: args.guest });
+  const url = new URL("/impersonate", auth.instance);
+  url.searchParams.set("_ti", _ti);
+  const dashboardUrl = url.href;
+  if (isMachineOutput(args)) {
+    writeJson({ _ti, url: dashboardUrl });
+    return;
+  }
+  if (args.urlOnly) {
+    process.stdout.write(dashboardUrl + "\n");
+    return;
+  }
+  step("Opening the Xano builder\u2026");
+  detail(dashboardUrl);
+  openBrowser(dashboardUrl);
+  success(`Impersonation session opened for ${name}${args.guest ? " (read-only guest)" : ""}`);
+}
+function requireName(args, verb) {
+  const name = args.positionals[0];
+  if (name === void 0 || name === "") {
+    throw new Error(`\`xanots ephemeral ${verb}\` needs a tenant name. Run \`xanots ephemeral list\` to see them.`);
+  }
+  return name;
+}
+export {
+  fetchEphemeralBundle,
+  resolveLive,
+  runEphemeralCommand
+};
+//# sourceMappingURL=ephemeral-command-3X3I4ULC.js.map