@xanots/sdk 0.0.1

package/dist/deploy-command-4EQ7XX5G.js

@@ -0,0 +1,451 @@
+import {
+  assertBundleInput,
+  loadBundleText
+} from "./chunk-NOO35BQ2.js";
+import {
+  importWorkspaceArchive
+} from "./chunk-5WGEURVI.js";
+import {
+  createEphemeral,
+  getEphemeral,
+  isEphemeralDisabled,
+  isExpired,
+  tenantBaseUrl,
+  waitUntilReady
+} from "./chunk-6DHBYBTO.js";
+import {
+  encodeWorkspaceArchive
+} from "./chunk-ZUTSMMAG.js";
+import {
+  getEnvironment,
+  readEphemeralState,
+  setEnvironment
+} from "./chunk-DGSF2Q5H.js";
+import {
+  openBrowser
+} from "./chunk-VTIL47DT.js";
+import "./chunk-X4DVXBFY.js";
+import {
+  microserviceLine,
+  readyRatio,
+  waitForMicroservices
+} from "./chunk-NDZFBZHC.js";
+import {
+  isMachineOutput,
+  writeJson
+} from "./chunk-NUQCEOKA.js";
+import {
+  fetchOrExplain,
+  httpFailure
+} from "./chunk-3IGNIP6R.js";
+import {
+  getAccessToken
+} from "./chunk-C56BC2FY.js";
+import "./chunk-7REDODS2.js";
+import "./chunk-YGPIY3WT.js";
+import {
+  assertWritableDest
+} from "./chunk-IZW6MK3U.js";
+import {
+  blank,
+  detail,
+  elapsedSuffix,
+  formatExpiration,
+  hostLabel,
+  info,
+  link,
+  spinner,
+  step,
+  success,
+  warn,
+  withSpinner
+} from "./chunk-EZG76F7R.js";
+import "./chunk-3DUAGYGP.js";
+import "./chunk-YYRDLFSJ.js";
+import "./chunk-EMCAWMHC.js";
+import "./chunk-WHOJWOSV.js";
+import "./chunk-LH6Z6KFV.js";
+import "./chunk-HJPTWBLH.js";
+import "./chunk-GNPVYOPB.js";
+import "./chunk-4HT3BNZ7.js";
+
+// src/emit/deploy-command.ts
+import { basename } from "path";
+var EXIT_STATIC_FAILED = 3;
+var EXIT_MICROSERVICE_NOT_READY = 4;
+var EXIT_TESTS_UNREACHABLE = 6;
+var SANDBOX_TIMEOUT_MS = 3e4;
+function microserviceCheck(args) {
+  return { noVerify: args.noVerify, requireReady: args.requireMicroservices };
+}
+function buildStaticEnv(baseUrl, staticEnv) {
+  const env = {};
+  if (baseUrl) env.XANO_HOST = baseUrl;
+  Object.assign(env, staticEnv);
+  return env;
+}
+function deriveDisplay(bundleText, cwd) {
+  try {
+    const parsed = JSON.parse(bundleText);
+    const w = parsed.payload?.workspace;
+    const name = Array.isArray(w) ? w[0]?.name : w?.name;
+    if (typeof name === "string" && name.trim() !== "") return name;
+  } catch {
+  }
+  return basename(cwd) || "xanots-app";
+}
+async function resolveSandboxBaseUrl(auth) {
+  const url = new URL("/api:meta/sandbox/me", auth.instance);
+  const res = await fetchOrExplain(
+    url.href,
+    {
+      headers: { accept: "application/json", Authorization: `Bearer ${auth.access_token}` },
+      signal: AbortSignal.timeout(SANDBOX_TIMEOUT_MS)
+    },
+    "resolve sandbox",
+    SANDBOX_TIMEOUT_MS
+  );
+  const text = await res.text();
+  if (!res.ok) throw new Error(httpFailure("resolve sandbox", res, text));
+  let tenant = {};
+  try {
+    tenant = JSON.parse(text);
+  } catch {
+    throw new Error(`resolve sandbox: could not parse the ${url.pathname} response as JSON:
+${text}`);
+  }
+  return tenantBaseUrl(tenant, auth.instance);
+}
+async function assertNoSeedLeaks(dir, values, allow) {
+  if (values.length === 0) return;
+  const unscannable = [
+    ...new Set(values.filter((v) => v.scannable === false).map((v) => `${v.table}.${v.column}`))
+  ];
+  if (unscannable.length > 0) {
+    warn(
+      `${unscannable.length} non-public seed column(s) hold values the static scan cannot search for \u2014 too short to match on, or not text at all \u2014 so they were NOT checked. Being unsearchable is not being safe: if any of these is a real credential, shorten the exposure rather than the value.`
+    );
+    for (const column of unscannable) detail(column);
+  }
+  const { findSeedLeaks } = await import("./static-host-D6KS7X45.js");
+  const leaks = findSeedLeaks(dir, values);
+  if (leaks.length === 0) return;
+  const lines = leaks.map((l) => `  ${l.file} \u2014 ${l.table}.${l.column}`);
+  if (allow) {
+    warn(`Publishing ${leaks.length} non-public seed value(s) in the static build (--allow-seed-in-static):`);
+    for (const line of lines) detail(line);
+    return;
+  }
+  throw new Error(
+    `Refusing to publish: the static build in "${dir}" contains seed values from columns your schema marks non-public. These would be served at a public URL.
+${lines.join("\n")}
+
+A bundler copied them in \u2014 most often from \`seed: () => import("./seed.json")\`, which does NOT keep seed values out of a frontend build. Use \`seedFile("./seed.json", import.meta.url)\` instead, then rebuild the frontend.
+If the data is deliberately public demo content, pass --allow-seed-in-static.`
+  );
+}
+function deployTarget(auth) {
+  detail(`on ${hostLabel(auth.instance)} \xB7 workspace ${auth.workspaceId}`);
+}
+async function runDeployedTests(auth, dest, summary, args) {
+  try {
+    return await runTestsOrThrow(auth, dest, summary, args);
+  } catch (err) {
+    warn("The deploy stands, but its tests could not be run:");
+    detail(err instanceof Error ? err.message : String(err));
+    process.exitCode = EXIT_TESTS_UNREACHABLE;
+    return void 0;
+  }
+}
+async function runTestsOrThrow(auth, dest, summary, args) {
+  const { runSuite, EXIT_TESTS_FAILED } = await import("./test-command-TSPBQHBM.js");
+  let target;
+  if (dest === "ephemeral") {
+    if (summary.url === void 0) {
+      warn("Skipped --test: the ephemeral reported no base URL to run against.");
+      return void 0;
+    }
+    const name = summary.ephemeral?.name;
+    target = { base: summary.url, workspaceId: 1, label: name ? `ephemeral ${name}` : "the ephemeral", env: name };
+  } else {
+    const { resolveMetaTarget } = await import("./env-target-IFJ5QDHC.js");
+    target = await resolveMetaTarget(auth, { dest: "sandbox" });
+  }
+  const outcomes = await runSuite(auth, target, {
+    kind: args.kind,
+    concurrency: args.concurrency,
+    human: !isMachineOutput(args)
+  });
+  const passed = outcomes.filter((o) => o.status === "pass").length;
+  const failed = outcomes.length - passed;
+  if (!isMachineOutput(args)) {
+    blank();
+    if (outcomes.length === 0) detail("No tests found in the deployed environment.");
+    else if (failed > 0) warn(`${passed} passed, ${failed} failed`);
+    else success(`${passed} passed, 0 failed`);
+  }
+  if (failed > 0) process.exitCode = EXIT_TESTS_FAILED;
+  return {
+    total: outcomes.length,
+    passed,
+    failed,
+    results: outcomes.map((o) => ({
+      kind: o.kind,
+      name: o.name,
+      status: o.status,
+      message: o.message,
+      timing: o.timing
+    }))
+  };
+}
+async function runDeployCommand(args) {
+  assertWritableDest(args.dest, "deploy");
+  const dest = args.dest ?? "ephemeral";
+  const startedAt = Date.now();
+  if (args.reset) info("`--reset` is redundant \u2014 deploy is always a full replace.");
+  assertBundleInput(args, { command: "deploy" });
+  const auth = await getAccessToken(args);
+  const { bundle, source, content, nonPublicSeedValues } = await loadBundleText(
+    args,
+    { command: "deploy" },
+    { withSeed: true }
+  );
+  if (args.static !== void 0) {
+    await assertNoSeedLeaks(args.static, nonPublicSeedValues, args.allowSeedInStatic);
+  }
+  if (content.length > 0) {
+    const rows = content.length === 1 ? "1 seed content file" : `${content.length} seed content files`;
+    detail(`Bundling ${rows} (full replace re-seeds cleanly).`);
+  }
+  const archive = encodeWorkspaceArchive(bundle, content);
+  let staticSummary;
+  const staticDir = args.static;
+  const publishStatic = staticDir === void 0 ? void 0 : async (env) => {
+    const staticEnv = buildStaticEnv(env.baseUrl, args.staticEnv);
+    const explicit = Object.keys(args.staticEnv).length > 0;
+    try {
+      const target = dest === "ephemeral" ? { baseUrl: env.baseUrl, workspaceId: 1, label: env.label } : { baseUrl: auth.instance, workspaceId: auth.workspaceId, label: void 0 };
+      staticSummary = await deployStaticTo(staticDir, auth, target, staticEnv, explicit, args.staticHost, args.noVerify, args.staticRouting);
+    } catch (err) {
+      warn("The static-host upload failed \u2014 the backend deploy stands:");
+      detail(err instanceof Error ? err.message : String(err));
+      detail(
+        `Retry just the static step: xanots deploy --static ${staticDir}` + (args.staticHost ? ` --static-host ${args.staticHost}` : "")
+      );
+      process.exitCode = EXIT_STATIC_FAILED;
+    }
+  };
+  const summary = dest === "sandbox" ? await deploySandbox(auth, archive, source, microserviceCheck(args), startedAt, publishStatic) : await deployEphemeral(auth, { archive, bundle, source, args, startedAt, publishStatic });
+  if (staticSummary !== void 0) summary.static = staticSummary;
+  if (dest === "ephemeral" && summary.created === false && staticSummary?.url !== void 0) {
+    detail("This static URL is new \u2014 a re-deploy replaces the environment's hosting, so the previous one no longer serves.");
+  }
+  if (args.test) summary.tests = await runDeployedTests(auth, dest, summary, args);
+  if (args.open) openDeployed(summary);
+  if (isMachineOutput(args)) writeJson(summary);
+}
+function openDeployed(summary) {
+  const url = summary.static?.url ?? summary.url;
+  if (url === void 0) {
+    warn("--open had no URL to open \u2014 the deploy reported none.");
+    return;
+  }
+  detail(`Opening ${url}`);
+  openBrowser(url);
+}
+async function deploySandbox(auth, archive, source, check, startedAt, publishStatic) {
+  step(`Deploying ${source} \u2192 sandbox (full replace)`);
+  deployTarget(auth);
+  const baseUrl = await resolveSandboxBaseUrl(auth);
+  await publishStatic?.({ baseUrl, label: void 0 });
+  await withSpinner(IMPORTING_LABEL, () => importWorkspaceArchive(auth, { baseUrl, archive }));
+  success(`Backend deployed to sandbox${elapsedSuffix(startedAt)}`);
+  link(baseUrl);
+  const microservices = await verifyMicroservices(auth, baseUrl, check);
+  return { dest: "sandbox", url: baseUrl, ...microservices ? { microservices } : {} };
+}
+var WAITING_LABEL = "Waiting for microservices\u2026";
+var IMPORTING_LABEL = "Uploading and importing the workspace\u2026";
+function waitingLabel(microservices) {
+  const { ready, startable } = readyRatio(microservices);
+  return startable === 0 ? WAITING_LABEL : `${WAITING_LABEL} (${ready}/${startable} ready)`;
+}
+async function verifyMicroservices(auth, baseUrl, opts, waitOpts = {}) {
+  if (opts.noVerify) return void 0;
+  const spin = spinner(WAITING_LABEL);
+  let result;
+  try {
+    result = await waitForMicroservices(auth, { baseUrl, workspaceId: 1 }, {
+      ...waitOpts,
+      onPoll: (rows) => {
+        spin.update(waitingLabel(rows));
+        waitOpts.onPoll?.(rows);
+      }
+    });
+  } catch (err) {
+    warn("Could not read microservice status (the backend deployed fine):");
+    detail(err instanceof Error ? err.message : String(err));
+    return void 0;
+  } finally {
+    spin.stop();
+  }
+  const { microservices, timedOut, hadFailure } = result;
+  if (microservices.length === 0) return void 0;
+  const { ready, startable } = readyRatio(microservices);
+  if (hadFailure) {
+    warn("Some microservices failed to start:");
+    failDeploy();
+  } else if (timedOut) {
+    warn(`Microservices are still starting (${ready}/${startable} ready) \u2014 they should come up shortly:`);
+    if (opts.requireReady) failDeploy();
+  } else if (startable === 0) {
+    info("No microservices to start:");
+  } else {
+    success(`Microservices ready (${ready}/${startable})`);
+  }
+  for (const m of microservices) detail(microserviceLine(m));
+  if (timedOut && !hadFailure) {
+    detail("Re-check with `xanots ephemeral get <env>`, or skip this wait next time with --no-verify.");
+    if (!opts.requireReady) {
+      detail("Fail the deploy on this instead of warning: --require-microservices.");
+    }
+  }
+  return microservices;
+}
+function failDeploy() {
+  if (!process.exitCode) process.exitCode = EXIT_MICROSERVICE_NOT_READY;
+}
+function ephemeralDisabledError(source) {
+  return new Error(
+    `Ephemeral environments are not enabled on this instance, so \`--dest ephemeral\` (the default) has nothing to create.
+Deploy to the sandbox instead: \`xanots deploy --dest sandbox ${source}\`.
+\u26A0 With \`--dest sandbox\`, \`--static\` publishes the frontend to your OWN (parent) workspace \u2014 the sandbox tenant does not serve static hosting \u2014 so it replaces whatever that workspace is hosting.`
+  );
+}
+async function deployEphemeral(auth, ctx) {
+  const { archive, bundle, source, args, startedAt, publishStatic } = ctx;
+  const parentWorkspaceId = auth.workspaceId;
+  const dir = process.cwd();
+  const stored = getEnvironment(readEphemeralState(dir), parentWorkspaceId);
+  let target = null;
+  if (stored) {
+    const existing = await getEphemeral(auth, { parentWorkspaceId, name: stored.name });
+    if (existing && !isExpired(existing.expiresAt)) target = existing;
+  }
+  const created = target === null;
+  if (target === null) {
+    const display = args.name ?? deriveDisplay(bundle, dir);
+    step(`Deploying ${source} \u2192 new ephemeral "${display}"`);
+    deployTarget(auth);
+    const fresh = await createEphemeral(auth, {
+      parentWorkspaceId,
+      display,
+      expiresHours: args.expiresHours
+    }).catch((err) => {
+      if (!isEphemeralDisabled(err)) throw err;
+      throw ephemeralDisabledError(source);
+    });
+    target = await withSpinner(
+      `Waiting for ${fresh.name} to become ready\u2026`,
+      () => waitUntilReady(auth, { parentWorkspaceId, name: fresh.name })
+    );
+  } else {
+    step(`Deploying ${source} \u2192 ephemeral ${target.name} (refresh, full replace)`);
+    deployTarget(auth);
+  }
+  const baseUrl = target.url;
+  if (baseUrl === void 0) {
+    throw new Error(`Ephemeral "${target.name}" has no base URL yet \u2014 try \`xanots deploy\` again.`);
+  }
+  setEnvironment(dir, parentWorkspaceId, {
+    name: target.name,
+    display: target.display ?? args.name ?? target.name,
+    url: baseUrl,
+    expires_at: target.expiresAt
+  });
+  let importFailure;
+  try {
+    await withSpinner(IMPORTING_LABEL, () => importWorkspaceArchive(auth, { baseUrl, archive }));
+  } catch (err) {
+    importFailure = err;
+  }
+  if (importFailure !== void 0) {
+    if (publishStatic !== void 0) {
+      warn("The import failed \u2014 republishing the frontend so the static host keeps serving.");
+      detail("It will run against this environment's PREVIOUS backend until a deploy imports cleanly.");
+      await publishStatic({ baseUrl, label: `ephemeral ${target.name}` });
+    }
+    throw importFailure;
+  }
+  const urlChanged = created || stored !== void 0 && stored.url !== baseUrl;
+  if (urlChanged) {
+    success(`Ephemeral ${target.name} deployed${elapsedSuffix(startedAt)}`);
+    warn("New ephemeral URL:");
+    link(baseUrl);
+  } else {
+    success(`Refreshed ${target.name} (URL unchanged)${elapsedSuffix(startedAt)}`);
+    link(baseUrl);
+  }
+  detail(`Expires ${formatExpiration(target.expiresAt)}`);
+  detail(`Manage with \`xanots ephemeral get ${target.name}\``);
+  detail(`Open the builder with \`xanots ephemeral impersonate ${target.name}\``);
+  await publishStatic?.({ baseUrl, label: `ephemeral ${target.name}` });
+  if (publishStatic !== void 0) {
+    detail(
+      "The frontend URL changes on every ephemeral deploy (the import clears static hosting) and the replace re-seeds the environment. For a stable URL while iterating, deploy with `--dest sandbox` \u2014 its frontend lands on your own workspace, which no import clears."
+    );
+  }
+  const microservices = await verifyMicroservices(auth, baseUrl, microserviceCheck(args));
+  return {
+    dest: "ephemeral",
+    url: baseUrl,
+    ephemeral: { name: target.name, display: target.display, expiresAt: target.expiresAt },
+    created,
+    ...microservices ? { microservices } : {}
+  };
+}
+async function deployStaticTo(dir, auth, target, env, explicit, host, noVerify, routing) {
+  const { deployStaticHost } = await import("./static-host-D6KS7X45.js");
+  const where = target.label && target.label !== "" ? target.label : `workspace #${target.workspaceId}`;
+  step(`Deploying static frontend ${dir} \u2192 ${where}${host ? ` (host: ${host})` : ""}`);
+  const sh = await deployStaticHost({ host, dir, workspaceId: target.workspaceId, baseUrl: target.baseUrl, accessToken: auth.access_token, env, routing });
+  detail(
+    sh.routing === "multipage" ? "Routing: multipage \u2014 routes resolve to their own documents." : "Routing: spa \u2014 every path serves index.html."
+  );
+  const globals = Object.keys(env).map((k) => `window.${k}`);
+  if (globals.length > 0) {
+    const docs = sh.envDocuments === 1 ? "1 document" : `${sh.envDocuments} documents`;
+    if (sh.envInjected) success(`Config injected into ${docs}: ${globals.join(", ")}`);
+    else if (explicit) warn(`Config not injected \u2014 no HTML document with a <head> to anchor to. ${globals.join(", ")} unset.`);
+    else detail(`No HTML document to inject window.XANO_HOST into \u2014 skipped.`);
+    if (sh.envSkipped.length > 0) {
+      warn(`Config not injected into ${sh.envSkipped.join(", ")} \u2014 no <head> to anchor to; those routes run with ${globals.join(", ")} unset.`);
+    }
+  }
+  success("Static host deployed");
+  if (sh.url) link(sh.url);
+  if (noVerify || sh.url === void 0 || sh.canonical === void 0) {
+    return { url: sh.url };
+  }
+  const { verifyRollout } = await import("./verify-rollout-FAVQ6EJY.js");
+  const { url, canonical } = sh;
+  const { live } = await withSpinner("Verifying the frontend is live\u2026", () => verifyRollout(url, canonical));
+  if (live) {
+    success("Frontend is live");
+  } else {
+    warn("Could not confirm the frontend is live within the wait window \u2014 the build uploaded and should come online shortly.");
+    detail(`Re-check by opening ${sh.url}, or skip this wait next time with --no-verify.`);
+  }
+  return { url: sh.url, verified: live };
+}
+export {
+  assertNoSeedLeaks,
+  buildStaticEnv,
+  deployStaticTo,
+  deriveDisplay,
+  ephemeralDisabledError,
+  runDeployCommand,
+  runDeployedTests,
+  verifyMicroservices
+};
+//# sourceMappingURL=deploy-command-4EQ7XX5G.js.map

package/dist/env-target-IFJ5QDHC.js

@@ -0,0 +1,16 @@
+import {
+  resolveMetaTarget
+} from "./chunk-33ND6LKO.js";
+import "./chunk-DGSF2Q5H.js";
+import "./chunk-7DKX2SPN.js";
+import "./chunk-NDZFBZHC.js";
+import "./chunk-NUQCEOKA.js";
+import "./chunk-3IGNIP6R.js";
+import "./chunk-C56BC2FY.js";
+import "./chunk-7REDODS2.js";
+import "./chunk-EZG76F7R.js";
+import "./chunk-GNPVYOPB.js";
+export {
+  resolveMetaTarget
+};
+//# sourceMappingURL=env-target-IFJ5QDHC.js.map