@xano/sdk 1.0.0

package/dist/upgrade-command-QHNFWM7O.js

@@ -0,0 +1,531 @@
+import {
+  assertProjectDir
+} from "./chunk-3XI5CTUE.js";
+import {
+  checkForUpgrade,
+  detectInstallMode,
+  registryUrl,
+  runFromPackageRunner,
+  suppressUpdateNotice
+} from "./chunk-LIEOKXKD.js";
+import {
+  installedSdk,
+  projectSdkVersion
+} from "./chunk-D7VGG3WS.js";
+import "./chunk-2TFRR6JV.js";
+import {
+  readVersion
+} from "./chunk-ETO6LGLD.js";
+import "./chunk-ZIY7RNUT.js";
+import "./chunk-DAD3ONIS.js";
+import "./chunk-HHN734BU.js";
+import "./chunk-LPECSJ2J.js";
+import "./chunk-6NNTNXN7.js";
+import "./chunk-QCNYHBL7.js";
+import "./chunk-2ZUEE4EK.js";
+import "./chunk-AN6BL47T.js";
+import "./chunk-ET4Y4XCB.js";
+import "./chunk-SWBF2LTK.js";
+import "./chunk-UZ6QQWJT.js";
+import "./chunk-A3UDOZB6.js";
+import "./chunk-2MNLRIOX.js";
+import "./chunk-3M4LFYNQ.js";
+import "./chunk-AM4FKL4J.js";
+import {
+  refreshAgentFiles
+} from "./chunk-Q325JKYB.js";
+import "./chunk-STSFNCY4.js";
+import "./chunk-I4F5TCJH.js";
+import "./chunk-5QU2P5CA.js";
+import "./chunk-ZYJP6BOO.js";
+import "./chunk-QO6BVGS5.js";
+import "./chunk-JZGVVJSI.js";
+import "./chunk-7G3CTU7I.js";
+import "./chunk-6PBR37LN.js";
+import {
+  retryCommand
+} from "./chunk-T5KELPAR.js";
+import "./chunk-622HUCZT.js";
+import "./chunk-NAQDMEHV.js";
+import "./chunk-5A2PLKZB.js";
+import "./chunk-AHJWCYQO.js";
+import "./chunk-DX4QR4B2.js";
+import {
+  prepareInstallSite,
+  refusePlugAndPlay
+} from "./chunk-6QXLMMT3.js";
+import {
+  runNpmQuiet,
+  runNpmStreaming
+} from "./chunk-ZFDZKNGG.js";
+import "./chunk-FWD7AL6N.js";
+import "./chunk-2GNFDZA2.js";
+import "./chunk-JTUKLCXS.js";
+import {
+  trackLocalWrite
+} from "./chunk-4KHEMC32.js";
+import "./chunk-U64O2MXY.js";
+import "./chunk-ROY4YAEQ.js";
+import "./chunk-P2HAGF6H.js";
+import "./chunk-TLQE7ZN3.js";
+import {
+  detectPackageManager
+} from "./chunk-WRBKLYSJ.js";
+import "./chunk-3LDULPRE.js";
+import "./chunk-XW6KISBB.js";
+import "./chunk-AWQ7BQTQ.js";
+import "./chunk-EUUUMY7J.js";
+import "./chunk-YLDALTWZ.js";
+import "./chunk-5FBYXK5P.js";
+import "./chunk-LLNZGEFK.js";
+import "./chunk-QXTKSOFI.js";
+import {
+  readEnvVar
+} from "./chunk-X2NL4KUO.js";
+import {
+  sdkDep
+} from "./chunk-OPHB5ORL.js";
+import "./chunk-UCQ2VUTG.js";
+import "./chunk-DGWHAVRG.js";
+import "./chunk-JGE7CAWB.js";
+import {
+  CliError,
+  EXIT_SOURCE_UNRESOLVABLE,
+  blank,
+  detail,
+  isMachineOutput,
+  step,
+  style,
+  success,
+  terminalText,
+  warn,
+  writeJson
+} 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-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/upgrade-command.ts
+import { spawnSync } from "child_process";
+import { existsSync, readFileSync, realpathSync, writeFileSync } from "fs";
+import { createRequire } from "module";
+import { dirname, join, relative, sep } from "path";
+var EXIT_UPGRADE_AVAILABLE = 7;
+var PACKAGE = "@xano/sdk";
+async function runUpgradeCommand(args) {
+  suppressUpdateNotice();
+  if (process.env[RECONCILE_ENV] === "1") {
+    writeJson({ status: "reconciled", reconciled: await reconcileDerived(process.cwd(), readVersion()) });
+    return;
+  }
+  const mode = detectInstallMode();
+  const dir = mode === "local" ? sdkProjectDir(process.cwd()) : process.cwd();
+  const runner = readEnvVar("XANOSDK_INSTALL_MODE")?.trim() ? void 0 : runFromPackageRunner();
+  if (runner !== void 0 && !(mode === "local" && declaresSdk(dir))) {
+    reportRunnerCopy(args, runner);
+    return;
+  }
+  const installed = mode === "local" ? projectSdkVersion(dir) : void 0;
+  const result = await checkForUpgrade(installed === void 0 ? void 0 : { current: installed });
+  if (result.status === "unknown") {
+    const message = explainUnknown(result, retryCommand(args, { command: "upgrade" }).command);
+    if (result.reason === "registry" && result.refused === void 0) {
+      throw new CliError("SDK_ERROR", message, { exitCode: EXIT_SOURCE_UNRESOLVABLE });
+    }
+    throw new Error(message);
+  }
+  if (result.status === "current") {
+    const ownRange = mode === "local" && !args.check && installed !== void 0 && existsSync(join(dir, "package.json"));
+    const reconciled = [
+      ...ownRange ? restoreSdkRangeSafely(dir, installed) : [],
+      ...ownRange && installed === readVersion() ? [...syncLockToManifest(dir), ...await reconcileDerived(dir, installed)] : []
+    ].filter((path, at, all) => all.indexOf(path) === at);
+    success(`@xano/sdk ${style.bold(result.current)} is the latest published version.`);
+    for (const path of reconciled) detail(`reconciled ${path}`);
+    if (isMachineOutput(args)) {
+      writeJson({ status: "current", current: result.current, latest: result.latest, installMode: mode, reconciled });
+    }
+    return;
+  }
+  if (result.status === "ahead") {
+    success(
+      `@xano/sdk ${style.bold(result.current)} is ahead of the latest published version (${result.latest}) \u2014 nothing to upgrade.`
+    );
+    if (isMachineOutput(args)) {
+      writeJson({ status: "ahead", current: result.current, latest: result.latest, installMode: mode });
+    }
+    return;
+  }
+  if (args.check) {
+    warn(
+      `A new @xano/sdk is available: ${style.dim(result.current)} \u2192 ${style.green(result.latest)}`,
+      "update.available",
+      [`run \`xanosdk upgrade\`, or: ${suggestedCommand(dir, mode, result.latest)}`]
+    );
+    if (isMachineOutput(args)) {
+      writeJson({
+        status: "available",
+        current: result.current,
+        latest: result.latest,
+        installMode: mode,
+        command: suggestedCommand(dir, mode, result.latest)
+      });
+    }
+    process.exitCode = EXIT_UPGRADE_AVAILABLE;
+    return;
+  }
+  await applyUpgrade(args, dir, result.current, result.latest, mode);
+}
+function reportRunnerCopy(args, runner) {
+  const current = readVersion();
+  success(`Nothing to upgrade: @xano/sdk ${style.bold(current)} is a temporary copy a package runner (${runner}) fetched, not an install.`);
+  detail(
+    `\`${runner} @xano/sdk@latest <command>\` runs the newest release; \`${runner} @xano/sdk@<version> <command>\` pins one.
+In a project, run \`xanosdk upgrade\` there. A global CLI upgrades with \`npm i -g ${PACKAGE}@latest\`.`
+  );
+  if (isMachineOutput(args)) writeJson({ status: "not-installed", current, installMode: "runner" });
+}
+function suggestedCommand(dir, mode, latest) {
+  if (mode === "global") return `npm i -g ${PACKAGE}@${latest}`;
+  const manager = detectPackageManager(dir);
+  const dev = saveFlagFor(dir) === "--save-dev";
+  if (manager === "npm") return `npm i ${saveFlagFor(dir)} ${PACKAGE}@${latest}`;
+  return `${manager} add ${dev ? manager === "pnpm" ? "--save-dev " : "--dev " : ""}${PACKAGE}@${latest}`;
+}
+function explainUnknown(result, rerun) {
+  if (result.reason === "registry-url") {
+    return `XANOSDK_UPDATE_REGISTRY is ${JSON.stringify(registryUrl())}, which is not an http(s) URL, so no registry was asked.
+Set it to a registry's http(s) URL for @xano/sdk's latest manifest, or unset it to use the npm registry.`;
+  }
+  if (result.reason === "registry" && result.refused !== void 0) {
+    return `The npm registry at ${registryUrl()} refused ${result.refused === "credential" ? "the credential your npm config holds for it" : "an unauthenticated read"} (${result.answered}).
+` + (result.refused === "credential" ? `Renew the \`//<registry host>/:_authToken\` (or \`_auth\`) line in your .npmrc \u2014 \`npm view @xano/sdk version\` reads with the same one.` : `Add a \`//<registry host>/:_authToken=\u2026\` line for it to your .npmrc (or \`npm login --registry <url>\`), as npm itself needs.`);
+  }
+  if (result.reason === "registry" && result.answered !== void 0) {
+    return `The npm registry at ${registryUrl()} answered with ${result.answered}, so there is no latest version to compare against.
+Run \`${rerun}\` again later, or point XANOSDK_UPDATE_REGISTRY at a working mirror.`;
+  }
+  return result.reason === "registry" ? `Could not reach the npm registry at ${registryUrl()}.
+Check your connection and run \`${rerun}\` again, or point XANOSDK_UPDATE_REGISTRY at a reachable mirror.` : `Could not resolve the installed @xano/sdk version, so there is nothing to compare against.
+This is expected for a git build or a linked checkout \u2014 upgrade with npm directly.`;
+}
+async function applyUpgrade(args, dir, current, latest, mode) {
+  if (mode === "local") {
+    assertProjectDir(dir, {
+      what: "`xanosdk upgrade` installs into a Xano SDK project",
+      remedy: "cd into your project first, or set XANOSDK_INSTALL_MODE=global to upgrade the global CLI."
+    });
+  }
+  let scope = [];
+  let cwd = dir;
+  if (mode === "local") {
+    refusePlugAndPlay(dir, retryCommand(args, { command: "upgrade" }).command);
+    const { site, link } = await prepareInstallSite(dir);
+    if (link !== null && link.status !== 0) {
+      process.stderr.write(terminalText(link.output.trimEnd()) + "\n");
+      throw new Error(`Nothing was upgraded: this project could not be linked into its npm workspace (exit ${link.status}).`);
+    }
+    scope = site.scope;
+    cwd = site.cwd;
+  }
+  step(`Upgrading ${style.bold(PACKAGE)} ${style.dim(current)} \u2192 ${style.green(latest)}`);
+  const manager = mode === "local" ? detectPackageManager(dir) : "npm";
+  const ls = manager === "npm" ? `\`npm ls${mode === "global" ? " -g" : ""} ${PACKAGE}\`` : `the ${PACKAGE} entry in package.json`;
+  const check = `Check ${ls}, then run \`${retryCommand(args, { command: "upgrade" }).command}\` again \u2014 it finishes what the install left.`;
+  await trackLocalWrite(
+    { what: `the upgrade to ${PACKAGE} ${latest}`, check },
+    () => installAndReconcile(args, dir, current, latest, mode, manager, scope, cwd)
+  );
+}
+async function installAndReconcile(args, dir, current, latest, mode, manager, scope, cwd) {
+  let undo = () => {
+  };
+  let ran;
+  if (manager === "npm") {
+    const flag = mode === "global" ? "-g" : saveFlagFor(dir);
+    const spec = `${PACKAGE}@${latest}`;
+    ran = ["npm", "i", flag, spec, ...scope].join(" ");
+    const status = await runNpmStreaming(["i", flag, spec, "--prefer-online", ...scope], cwd, { stdout: "stderr" });
+    if (status !== 0) {
+      throw new Error(`${ran} failed (exit ${status}).`);
+    }
+  } else {
+    ran = [manager, "install", ...scope].join(" ");
+    undo = await installWithManager(manager, dir, latest, scope);
+  }
+  const installed = (mode === "local" ? installedSdk(dir)?.version : void 0) ?? latest;
+  if (installed === current && current !== latest) {
+    undo();
+    throw new Error(
+      `\`${ran}\` exited 0, but this project still has ${PACKAGE} ${current} \u2014 ${latest} was not installed` + (manager === "npm" ? "." : `, and package.json is back as it was.`) + ` What ${manager} printed above says why.`
+    );
+  }
+  const reconciled = mode === "local" ? reconcileProject(dir, installed, manager) : [];
+  blank();
+  success(`Upgraded to @xano/sdk ${style.bold(installed)}.`);
+  for (const path of reconciled) detail(`reconciled ${path}`);
+  if (isMachineOutput(args)) {
+    writeJson({ status: "upgraded", current, latest, installed, installMode: mode, reconciled });
+  }
+}
+async function installWithManager(manager, dir, latest, scope) {
+  const manifest = join(dir, "package.json");
+  const raw = readFileSync(manifest, "utf8");
+  const pkg = JSON.parse(raw);
+  const block = sdkBlock(pkg) ?? "devDependencies";
+  const deps = typeof pkg[block] === "object" && pkg[block] !== null ? pkg[block] : pkg[block] = {};
+  deps[PACKAGE] = sdkDep(latest);
+  writeFileSync(manifest, JSON.stringify(pkg, null, indentOf(raw)) + (raw.endsWith("\n") ? "\n" : ""));
+  const status = await runNpmStreaming(["install", ...scope], dir, { stdout: "stderr", manager });
+  if (status !== 0) {
+    writeFileSync(manifest, raw);
+    throw new Error(`\`${[manager, "install", ...scope].join(" ")}\` failed (exit ${status}) after package.json asked for ${PACKAGE} ${sdkDep(latest)}; package.json is back as it was.`);
+  }
+  return () => writeFileSync(manifest, raw);
+}
+function reconcileProject(dir, version, manager) {
+  const changed = [];
+  try {
+    if (manager === "npm") changed.push(...restoreSdkRange(dir, version));
+  } catch (err) {
+    warn(`Could not restore the ${PACKAGE} range in package.json: ${messageOf(err)}`, "upgrade.partial");
+  }
+  changed.push(...reconcileWithInstalled(dir));
+  return changed;
+}
+function restoreSdkRangeSafely(dir, version) {
+  try {
+    const pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+    const block = sdkBlock(pkg);
+    const range = block === void 0 ? void 0 : pkg[block][PACKAGE];
+    if (typeof range !== "string" || !/^\^?\d+\.\d+\.\d+$/.test(range)) return [];
+    return restoreSdkRange(dir, version);
+  } catch (err) {
+    warn(`Could not restore the ${PACKAGE} range in package.json: ${messageOf(err)}`, "upgrade.partial");
+    return [];
+  }
+}
+var RECONCILE_ENV = "XANOSDK_UPGRADE_RECONCILE";
+function reconcileWithInstalled(dir) {
+  const again = "Run `xanosdk upgrade` once more \u2014 the new CLI then refreshes AGENTS.md, the .env.example template and the route table (`npm run xano:routes`); commit what changes.";
+  const bin = installedBin(dir);
+  if (bin === void 0) {
+    warn(`Could not find the installed ${PACKAGE} CLI to refresh what it renders.`, "upgrade.partial", [again]);
+    return [];
+  }
+  const res = spawnSync(process.execPath, [bin, "upgrade", "--json"], {
+    cwd: dir,
+    encoding: "utf8",
+    env: { ...process.env, [RECONCILE_ENV]: "1" },
+    stdio: ["ignore", "pipe", "inherit"],
+    timeout: 12e4
+  });
+  try {
+    const doc = JSON.parse(res.stdout);
+    if (res.status === 0 && doc.status === "reconciled" && Array.isArray(doc.reconciled)) {
+      return doc.reconciled.filter((p) => typeof p === "string");
+    }
+  } catch {
+  }
+  warn(`The installed ${PACKAGE} CLI did not refresh what it renders (exit ${res.status ?? "none"}).`, "upgrade.partial", [again]);
+  return [];
+}
+function installedBin(dir) {
+  try {
+    const found = installedSdk(dir);
+    const linked = found === void 0 ? void 0 : join(found.root, "node_modules", ...PACKAGE.split("/"), "package.json");
+    const manifest = linked !== void 0 && existsSync(linked) ? realpathSync(linked) : createRequire(join(dir, "package.json")).resolve(`${PACKAGE}/package.json`);
+    const pkg = JSON.parse(readFileSync(manifest, "utf8"));
+    const rel = typeof pkg.bin === "string" ? pkg.bin : pkg.bin?.xanosdk;
+    if (typeof rel !== "string") return void 0;
+    const bin = join(dirname(manifest), rel);
+    return existsSync(bin) ? bin : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function reconcileDerived(dir, version) {
+  const changed = [];
+  try {
+    changed.push(...refreshAgentFiles({ projectDir: dir, sdkVersion: version, explicit: true }));
+  } catch (err) {
+    warn(`Could not refresh the agent guidance blocks: ${messageOf(err)}`, "upgrade.partial");
+  }
+  try {
+    const { reconcileLambdaConfig } = await import("./lambda-config-reconcile-OUZ4OYAB.js");
+    const lambdas = reconcileLambdaConfig(dir);
+    changed.push(...lambdas.changed);
+    if (lambdas.manual.length > 0) {
+      warn(
+        "The lambda modules in xano/lambdas type-check under their own tsconfig, which loads the lambda runtime's globals \u2014 finish the steps this upgrade left to you:",
+        "upgrade.partial",
+        lambdas.manual
+      );
+    }
+  } catch (err) {
+    warn(`Could not set up the xano/lambdas type-check: ${messageOf(err)}`, "upgrade.partial");
+  }
+  try {
+    changed.push(...await rerenderEnvTemplate(dir));
+  } catch (err) {
+    warn(`Could not re-render the .env.example template: ${messageOf(err)}`, "upgrade.partial");
+  }
+  changed.push(...await regenerateRoutes(dir));
+  return changed;
+}
+async function rerenderEnvTemplate(dir) {
+  const { backendDirIn } = await import("./backend-dir-2U53CIAL.js");
+  const { rerenderEnvExample } = await import("./env-example-refresh-ET5HMMDW.js");
+  const path = join(backendDirIn(dir), ".env.example");
+  if (!existsSync(path)) return [];
+  const current = readFileSync(path, "utf8");
+  const names = [...current.matchAll(/^# ([A-Za-z_][A-Za-z0-9_]*)=$/gm)].map((m) => m[1]);
+  const next = rerenderEnvExample(current, names);
+  if (next === void 0 || next === current) return [];
+  writeFileSync(path, next);
+  return [relative(dir, path).split(sep).join("/")];
+}
+async function regenerateRoutes(dir) {
+  let script;
+  try {
+    script = JSON.parse(readFileSync(join(dir, "package.json"), "utf8")).scripts?.["xano:routes"];
+  } catch {
+    return [];
+  }
+  if (typeof script !== "string") return [];
+  const target = /--emit[= ](\S+)/.exec(script)?.[1] ?? "xano/routes.gen.ts";
+  const path = join(dir, target);
+  const before = existsSync(path) ? readFileSync(path, "utf8") : void 0;
+  const { status, output } = await runNpmQuiet(["run", "--silent", "xano:routes"], dir);
+  if (status !== 0) {
+    if (output.trim() !== "") process.stderr.write(terminalText(output.endsWith("\n") ? output : `${output}
+`));
+    warn(`\`npm run xano:routes\` failed (exit ${status}), so ${target} was not regenerated.`, "upgrade.partial", [
+      "Fix what it printed, then run `npm run xano:routes` and commit the result."
+    ]);
+    return [];
+  }
+  const after = existsSync(path) ? readFileSync(path, "utf8") : void 0;
+  return after !== before ? [target] : [];
+}
+function restoreSdkRange(dir, version) {
+  const manifest = join(dir, "package.json");
+  const raw = readFileSync(manifest, "utf8");
+  const pkg = JSON.parse(raw);
+  const block = sdkBlock(pkg);
+  if (block === void 0) return [];
+  const deps = pkg[block];
+  const want = sdkDep(version);
+  const changed = [];
+  if (deps[PACKAGE] !== want) {
+    deps[PACKAGE] = want;
+    writeFileSync(manifest, JSON.stringify(pkg, null, indentOf(raw)) + (raw.endsWith("\n") ? "\n" : ""));
+    changed.push("package.json");
+  }
+  if (restoreLockRange(dir, block, want)) changed.push("package-lock.json");
+  return changed;
+}
+function syncLockToManifest(dir) {
+  try {
+    const pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+    const block = sdkBlock(pkg);
+    if (block === void 0) return [];
+    const range = pkg[block][PACKAGE];
+    return typeof range === "string" && restoreLockRange(dir, block, range) ? ["package-lock.json"] : [];
+  } catch (err) {
+    warn(`Could not bring package-lock.json's ${PACKAGE} range to package.json's: ${messageOf(err)}`, "upgrade.partial");
+    return [];
+  }
+}
+function restoreLockRange(dir, block, want) {
+  const lockPath = join(dir, "package-lock.json");
+  if (!existsSync(lockPath)) return false;
+  const raw = readFileSync(lockPath, "utf8");
+  const lock = JSON.parse(raw);
+  const root = lock.packages?.[""];
+  const deps = root?.[block];
+  if (deps === void 0 || !(PACKAGE in deps) || deps[PACKAGE] === want) return false;
+  deps[PACKAGE] = want;
+  writeFileSync(lockPath, JSON.stringify(lock, null, indentOf(raw)) + (raw.endsWith("\n") ? "\n" : ""));
+  return true;
+}
+function declaresSdk(dir) {
+  try {
+    return sdkBlock(JSON.parse(readFileSync(join(dir, "package.json"), "utf8"))) !== void 0;
+  } catch {
+    return false;
+  }
+}
+function sdkBlock(pkg) {
+  return ["devDependencies", "dependencies"].find((key) => {
+    const deps = pkg[key];
+    return typeof deps === "object" && deps !== null && PACKAGE in deps;
+  });
+}
+function saveFlagFor(dir) {
+  try {
+    const pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+    return sdkBlock(pkg) === "dependencies" ? "--save-prod" : "--save-dev";
+  } catch {
+    return "--save-dev";
+  }
+}
+function indentOf(raw) {
+  return /^(\t+)"/m.exec(raw)?.[1] ?? /^( +)"/m.exec(raw)?.[1]?.length ?? 2;
+}
+function sdkProjectDir(start) {
+  let nearest;
+  for (let dir = start; ; dir = dirname(dir)) {
+    if (existsSync(join(dir, "package.json"))) {
+      nearest ??= dir;
+      try {
+        if (sdkBlock(JSON.parse(readFileSync(join(dir, "package.json"), "utf8"))) !== void 0) return dir;
+      } catch {
+        return dir;
+      }
+    }
+    if (dirname(dir) === dir) return nearest ?? start;
+  }
+}
+function messageOf(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+export {
+  reconcileWithInstalled,
+  runUpgradeCommand
+};
+//# sourceMappingURL=upgrade-command-QHNFWM7O.js.map

package/dist/verify-rollout-DRCK5TDD.js

@@ -0,0 +1,61 @@
+import "./chunk-PZ5AY32C.js";
+
+// src/deploy/verify-rollout.ts
+var CANONICAL_HEADER = "X-Xano-Canonical";
+var FAST_POLL_MS = 1e3;
+var FAST_PHASE_MS = 3e4;
+var SLOW_POLL_MS = 2e3;
+var REQUEST_TIMEOUT_MS = 1e4;
+function cacheBust(url, nonce) {
+  try {
+    const u = new URL(url);
+    u.searchParams.set("_xc", String(nonce));
+    return u.toString();
+  } catch {
+    return `${url}${url.includes("?") ? "&" : "?"}_xc=${nonce}`;
+  }
+}
+async function verifyRollout(url, canonical, opts = {}) {
+  const fetchFn = opts.fetchFn ?? fetch;
+  const now = opts.now ?? Date.now;
+  const sleep = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const totalDeadlineMs = opts.totalDeadlineMs ?? 12e4;
+  if (url === "" || canonical === "") return { live: false };
+  const start = now();
+  for (; ; ) {
+    try {
+      const res = await fetchFn(cacheBust(url, now()), {
+        method: "GET",
+        signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+      });
+      if (res.headers.get(CANONICAL_HEADER) === canonical) return { live: true };
+    } catch {
+    }
+    const elapsed = now() - start;
+    if (elapsed >= totalDeadlineMs) return { live: false };
+    await sleep(elapsed < FAST_PHASE_MS ? FAST_POLL_MS : SLOW_POLL_MS);
+  }
+}
+async function probeFrontend(url, opts = {}) {
+  const fetchFn = opts.fetchFn ?? fetch;
+  const sleep = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const attempts = opts.attempts ?? 3;
+  let last = "unknown";
+  for (let i = 0; i < attempts; i++) {
+    if (i > 0) await sleep(FAST_POLL_MS);
+    try {
+      const res = await fetchFn(cacheBust(url, Date.now()), { method: "GET", signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS) });
+      await res.body?.cancel().catch(() => void 0);
+      if (res.ok) return "serving";
+      last = "down";
+      if (res.status < 500) return "down";
+    } catch {
+    }
+  }
+  return last;
+}
+export {
+  probeFrontend,
+  verifyRollout
+};
+//# sourceMappingURL=verify-rollout-DRCK5TDD.js.map

package/dist/whoami-command-STGINTXH.js

@@ -0,0 +1,51 @@
+import {
+  asRejectedCredential,
+  fetchProfile,
+  profileValue,
+  rejectedFixCommand,
+  rejectedRemedy,
+  runWhoamiCommand,
+  signedInValue,
+  workspaceValue
+} from "./chunk-UVHDMMIP.js";
+import "./chunk-KTSDSD36.js";
+import "./chunk-ET4Y4XCB.js";
+import "./chunk-5QU2P5CA.js";
+import "./chunk-ZYJP6BOO.js";
+import "./chunk-QO6BVGS5.js";
+import "./chunk-JZGVVJSI.js";
+import "./chunk-NAQDMEHV.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 {
+  asRejectedCredential,
+  fetchProfile,
+  profileValue,
+  rejectedFixCommand,
+  rejectedRemedy,
+  runWhoamiCommand,
+  signedInValue,
+  workspaceValue
+};
+//# sourceMappingURL=whoami-command-STGINTXH.js.map