@xano/sdk 1.0.0

package/dist/chunk-EUUUMY7J.js

@@ -0,0 +1,24 @@
+import {
+  readEnvVar
+} from "./chunk-X2NL4KUO.js";
+
+// src/util/home-path.ts
+import { homedir } from "os";
+import { join } from "path";
+function expandHome(path) {
+  if (path === void 0 || !isHomeRelative(path)) return path;
+  return join(homedir(), path.slice(1));
+}
+function isHomeRelative(path) {
+  return /^~(?:$|[\\/])/.test(path);
+}
+function readPathEnvVar(name) {
+  return expandHome(readEnvVar(name));
+}
+
+export {
+  expandHome,
+  isHomeRelative,
+  readPathEnvVar
+};
+//# sourceMappingURL=chunk-EUUUMY7J.js.map

package/dist/chunk-FQJ2TTHP.js

@@ -0,0 +1,218 @@
+import {
+  retryCommand,
+  withheldNote
+} from "./chunk-T5KELPAR.js";
+import {
+  contextFlags
+} from "./chunk-NAQDMEHV.js";
+import {
+  READ_AFTERMATH,
+  SENT_AFTERMATH,
+  closeSentence
+} from "./chunk-YLDALTWZ.js";
+import {
+  UsageError,
+  detail,
+  pastePath,
+  warn
+} from "./chunk-PTHVMXZI.js";
+import {
+  shellQuote
+} from "./chunk-5ZSO4T2G.js";
+
+// src/emit/static-teardown.ts
+async function readStaticTeardown(auth, target, recorded) {
+  const { listServingStaticHosts } = await import("./static-host-B2Y6AG3W.js");
+  try {
+    const serving = await listServingStaticHosts({ ...target, accessToken: auth.access_token });
+    const urls = serving.map((s) => s.url);
+    return { teardown: urls.length > 0 ? { urls, verified: true } : void 0, live: urls };
+  } catch (err) {
+    const error = withoutReadAftermath(err instanceof Error ? err.message : String(err));
+    return {
+      teardown: { urls: recorded === void 0 ? [] : [recorded], verified: false, reason: error },
+      live: void 0,
+      error
+    };
+  }
+}
+async function recheckDoubtedFrontend(read, doubted) {
+  const { teardown, live } = read;
+  if (doubted === void 0 || live === void 0 || teardown === void 0 || !live.includes(doubted)) {
+    return { read, unchecked: false };
+  }
+  const { probeFrontend } = await import("./verify-rollout-DRCK5TDD.js");
+  const state = await probeFrontend(doubted);
+  if (state === "serving") return { read, unchecked: false };
+  if (state === "down") {
+    const urls = teardown.urls.filter((u) => u !== doubted);
+    return {
+      read: { ...read, live: live.filter((u) => u !== doubted), teardown: urls.length > 0 ? { ...teardown, urls } : void 0 },
+      unchecked: false
+    };
+  }
+  const reason = `${doubted} could not be reached to check \u2014 an earlier failed replace may already have taken it down.`;
+  return { read: { ...read, teardown: { ...teardown, verified: false, reason } }, unchecked: true };
+}
+function withoutReadAftermath(message) {
+  return message.split("\n").filter((line) => line !== READ_AFTERMATH).join("\n");
+}
+function warnStaticTeardown(read, where, opts) {
+  const { teardown } = read;
+  if (teardown === void 0) return false;
+  const reason = closeSentence(read.error ?? teardown.reason ?? "The read failed for an unknown reason.");
+  if (teardown.urls.length === 0) {
+    if (opts.publishing) {
+      detail(
+        `Could not read ${where}'s static hosting, so this cannot say whether a frontend serves there; this replace takes down any that does, and \`--static\` publishes the new one after the import.`
+      );
+      detail(reason);
+    } else {
+      warn(
+        `Could not read ${where}'s static hosting, so this cannot say whether a frontend serves there \u2014 this replace takes down any that does.`,
+        "static.teardown-unknown",
+        [
+          reason,
+          `Re-run with \`--static <dir>\` to publish again (the URL may change), or ${opts.keepHint}.`
+        ]
+      );
+    }
+    return true;
+  }
+  const urls = teardown.urls.join(", ");
+  const one = teardown.urls.length === 1;
+  if (opts.publishing) {
+    detail(
+      `This replace clears the frontend${one ? "" : "s"} serving at ${urls}; \`--static\` publishes the new one after the import (the URL may change).`
+    );
+  } else {
+    warn(
+      `This replace takes the frontend${one ? "" : "s"} at ${urls} down \u2014 a replace clears ${where}'s static hosting, and this one publishes none.`,
+      "static.teardown",
+      [`Re-run with \`--static <dir>\` to publish again (the URL may change), or ${opts.keepHint}.`]
+    );
+  }
+  if (!teardown.verified && read.live !== void 0) detail(`Unverified: ${reason}`);
+  else if (!teardown.verified) {
+    detail(
+      `Unverified: ${where}'s static hosting could not be read, so this is this project's record of its last publish there \u2014 it may already be down.`
+    );
+    detail(reason);
+  }
+  return true;
+}
+function staticRemovedField(teardown, republished) {
+  if (teardown === void 0) return {};
+  const urls = teardown.urls.filter((u) => u !== republished);
+  return urls.length === 0 && teardown.verified ? {} : { staticRemoved: { ...teardown, urls } };
+}
+function namedStaticHost(args) {
+  if (args.static === void 0 || args.staticHost === void 0 || args.staticHost === "default") return void 0;
+  return args.staticHost;
+}
+function refuseStaticHostAReplaceClears(args, replaces, command = "deploy") {
+  const host = namedStaticHost(args);
+  if (host === void 0 || !replaces) return;
+  throw new UsageError(
+    `\`--static-host ${shellQuote(host)}\` names a host this replace deletes: a replace clears every static host on its target, and the publish after it re-creates only \`default\`. Nothing was deployed. Drop \`--static-host\` to publish to \`default\`${survivingRemedy(args, command)}`,
+    { hintFor: { command } }
+  );
+}
+function survivingRemedy(args, command) {
+  if (command === "release" || args.replace) return `, or drop \`--replace\` so the host survives.`;
+  const host = shellQuote(namedStaticHost(args) ?? "");
+  if (args.keepData && !args.reset) {
+    return `. A new environment holds only \`default\`: deploy once, create the static host \`${host}\` in the dashboard, then deploy with \`--keep-data --static-host ${host}\`.`;
+  }
+  const merge = retryCommand(args, { add: ["--keep-data"], drop: ["--reset"] });
+  return `, or merge so the host survives \u2014 once the environment has a static host named \`${host}\` (created in the dashboard; a deploy creates only \`default\`): \`${merge.command}\`.${withheldNote(merge.withheld)}`;
+}
+async function assertStaticHostExists(args, auth, target) {
+  const host = namedStaticHost(args);
+  if (host === void 0) return;
+  const { listStaticHostNames, StaticHostNotFoundError } = await import("./static-host-B2Y6AG3W.js");
+  let names;
+  try {
+    names = await listStaticHostNames({ ...target, accessToken: auth.access_token });
+  } catch {
+    return;
+  }
+  if (!names.includes(host)) throw new StaticHostNotFoundError(host, names, "Nothing was deployed or published.");
+}
+function staticRetryHint(dir, to, args, err) {
+  const badHost = err instanceof Error && err.name === "StaticHostNotFoundError";
+  return `Retry just the static step: \`${staticRetryCommand(dir, to, args, err)}\`` + (badHost ? ` (that publishes to \`default\`; add \`--static-host <name>\` for a host the target holds)` : "");
+}
+function staticRetryCommand(dir, to, args, err) {
+  const badHost = err instanceof Error && err.name === "StaticHostNotFoundError";
+  return (
+    // Spelled from where the user typed: a run moved to its project's root
+    // found `dir` from there, and a pasted `publish` resolves it from here.
+    `xanosdk publish ${shellQuote(pastePath(dir))} --to ${shellQuote(to)}` + (args.staticHost && !badHost ? ` --static-host ${shellQuote(args.staticHost)}` : "") + (args.staticRouting ? ` --static-routing ${args.staticRouting}` : "") + Object.entries(args.staticEnv).map(([k, v]) => ` --static-env ${shellQuote(`${k}=${v}`)}`).join("") + contextFlags({ authFile: args.authFile, local: args.local ?? false, profile: args.profile })
+  );
+}
+function noteStaticTakenDown(teardown, unknown = false) {
+  if (teardown === void 0 || teardown.urls.length === 0) return;
+  const one = teardown.urls.length === 1;
+  warn(
+    `The replace took down the frontend${one ? "" : "s"} at ${teardown.urls.join(", ")}, and the publish that was to replace ${one ? "it" : "them"} ` + (unknown ? `may or may not have landed \u2014 at a URL of its own if it did; the retry prints where the frontend serves.` : `failed \u2014 nothing serves there until a publish succeeds.`) + (teardown.verified ? "" : " (Unverified: this project's record of its last publish there.)"),
+    "static.teardown"
+  );
+}
+async function readFrontendsAfterFailure(auth, target, warned) {
+  const { live } = await readStaticTeardown(auth, target, void 0);
+  const { probeFrontend } = await import("./verify-rollout-DRCK5TDD.js");
+  const states = {};
+  for (const url of warned) {
+    states[url] = live !== void 0 && !live.includes(url) ? "down" : await probeFrontend(url);
+  }
+  return states;
+}
+function staticAfterFailedReplace(warned, states, opts) {
+  const again = `ublish again with \`${opts.publish}\`, or re-run the deploy with \`--static <dir>\`.`;
+  const remedy = `P${again}`;
+  const head = opts.unknown ? "The import's outcome is unknown" : "The import was refused";
+  const by = (s) => warned.filter((u) => (states[u] ?? "unknown") === s);
+  const down = by("down");
+  const unasked = by("unknown");
+  const plural = (urls) => urls.length === 1 ? { s: "", it: "it" } : { s: "s", it: "them" };
+  const unaskedText = (lead) => {
+    const p2 = plural(unasked);
+    return `${lead}the frontend${p2.s} at ${unasked.join(", ")} could not be reached to check \u2014 the clear that opens a replace may already have taken ${p2.it} down. Open ${p2.it} to check; if nothing serves there: p${again}`;
+  };
+  if (down.length > 0) {
+    const p2 = plural(down);
+    const text = `${head}, but the clear that opens a replace already took the frontend${p2.s} at ${down.join(", ")} down \u2014 nothing serves there now. ${remedy}` + (unasked.length > 0 ? ` ${unaskedText("And ")}` : "");
+    return { text, down };
+  }
+  if (unasked.length > 0) return { text: unaskedText(`${head}, and `), down };
+  const p = plural(warned);
+  return {
+    text: `${head}, and the frontend${p.s} at ${warned.join(", ")} still serve${p.s === "" ? "s" : ""}.`,
+    down
+  };
+}
+var EXIT_STATIC_FAILED = 3;
+function unknownStaticOutcome(message, unknown) {
+  if (!unknown) return message;
+  const said = "The upload was sent, so it may or may not have published. A publish replaces the host's build, so the retry below settles it either way and prints the URL it serves at.";
+  return message.includes(SENT_AFTERMATH) ? message.replace(SENT_AFTERMATH, said) : `${message}
+${said}`;
+}
+
+export {
+  readStaticTeardown,
+  recheckDoubtedFrontend,
+  warnStaticTeardown,
+  staticRemovedField,
+  refuseStaticHostAReplaceClears,
+  assertStaticHostExists,
+  staticRetryHint,
+  staticRetryCommand,
+  noteStaticTakenDown,
+  readFrontendsAfterFailure,
+  staticAfterFailedReplace,
+  EXIT_STATIC_FAILED,
+  unknownStaticOutcome
+};
+//# sourceMappingURL=chunk-FQJ2TTHP.js.map

package/dist/chunk-FQOF7E2E.js

@@ -0,0 +1,133 @@
+import {
+  envFlagSet
+} from "./chunk-X2NL4KUO.js";
+
+// src/auth/loopback.ts
+import { createServer } from "http";
+import { spawn } from "child_process";
+var DEFAULT_TIMEOUT_MS = 5 * 60 * 1e3;
+function loopbackRedirectUri(port, callbackPath) {
+  return `http://127.0.0.1:${port}${callbackPath}`;
+}
+function formatDuration(ms) {
+  const seconds = Math.round(ms / 1e3);
+  if (seconds < 60) return `${seconds} second${seconds === 1 ? "" : "s"}`;
+  const minutes = Math.round(seconds / 60);
+  return `${minutes} minute${minutes === 1 ? "" : "s"}`;
+}
+var CLOSE_TAB_HTML = '<!doctype html><meta charset=utf-8><title>xanosdk</title><body style="font-family:system-ui;padding:3rem;text-align:center"><h1>Authentication complete</h1><p>You can close this tab and return to the terminal.</p></body>';
+function startCallbackServer(opts) {
+  const { callbackPath, expectedState, port, timeoutMs = DEFAULT_TIMEOUT_MS } = opts;
+  return new Promise((resolveListener, rejectListener) => {
+    let resolveResult;
+    let rejectResult;
+    const waitForCallback = new Promise((res, rej) => {
+      resolveResult = res;
+      rejectResult = rej;
+    });
+    waitForCallback.catch(() => {
+    });
+    let redirectUri = "";
+    const server = createServer((req, res) => {
+      const url = new URL(req.url ?? "/", "http://127.0.0.1");
+      if (url.pathname !== callbackPath) {
+        respond(res, 404, "Not found");
+        return;
+      }
+      const state = url.searchParams.get("state");
+      if (state !== expectedState) {
+        respond(res, 400, "Unexpected or missing state \u2014 ignoring this request.");
+        return;
+      }
+      const error = url.searchParams.get("error");
+      if (error) {
+        const authError = new Error(
+          `Authorization server returned error: ${error}`
+        );
+        authError.error = error;
+        respond(res, 400, "Authorization failed. Check the terminal for details.", () => finish(authError));
+        return;
+      }
+      const code = url.searchParams.get("code");
+      if (!code) {
+        respond(
+          res,
+          400,
+          "Missing authorization code.",
+          () => finish(new Error("Callback carried no authorization code."))
+        );
+        return;
+      }
+      res.writeHead(200, { "Content-Type": "text/html", Connection: "close" }).end(CLOSE_TAB_HTML, () => {
+        finish(void 0, { code, callbackUrl: `${redirectUri}?${url.searchParams.toString()}` });
+      });
+    });
+    const sockets = /* @__PURE__ */ new Set();
+    server.on("connection", (socket) => {
+      sockets.add(socket);
+      socket.on("close", () => sockets.delete(socket));
+      socket.on("error", () => {
+      });
+    });
+    const timer = setTimeout(() => {
+      finish(new Error(`Timed out after ${formatDuration(timeoutMs)} waiting for the browser redirect.`));
+    }, timeoutMs);
+    timer.unref?.();
+    let settled = false;
+    function finish(err, result) {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      server.close();
+      for (const socket of sockets) socket.destroy();
+      if (err) rejectResult(err);
+      else resolveResult(result);
+    }
+    server.on("error", (err) => {
+      if (!settled) rejectListener(err);
+    });
+    server.listen(port ?? 0, "127.0.0.1", () => {
+      const boundPort = server.address().port;
+      redirectUri = loopbackRedirectUri(boundPort, callbackPath);
+      resolveListener({
+        redirectUri,
+        waitForCallback,
+        close: () => finish(new Error("Login cancelled."))
+      });
+    });
+  });
+}
+function respond(res, status, message, onFlush) {
+  res.writeHead(status, { "Content-Type": "text/html", Connection: "close" }).end(
+    `<!doctype html><meta charset=utf-8><body style="font-family:system-ui;padding:3rem;text-align:center">${message}</body>`,
+    onFlush
+  );
+}
+function browserCommand(platform, url) {
+  switch (platform) {
+    case "darwin":
+      return { cmd: "open", args: [url] };
+    case "win32":
+      return { cmd: "cmd", args: ["/c", "start", "", url.replace(/&/g, "^&")] };
+    default:
+      return { cmd: "xdg-open", args: [url] };
+  }
+}
+function openBrowser(url) {
+  if (envFlagSet("XANO_NO_BROWSER")) return;
+  const { cmd, args } = browserCommand(process.platform, url);
+  try {
+    const child = spawn(cmd, args, { stdio: "ignore", detached: true });
+    child.on("error", () => {
+    });
+    child.unref();
+  } catch {
+  }
+}
+
+export {
+  loopbackRedirectUri,
+  startCallbackServer,
+  openBrowser
+};
+//# sourceMappingURL=chunk-FQOF7E2E.js.map

package/dist/chunk-FWD7AL6N.js

@@ -0,0 +1,21 @@
+// src/emit/command-line.ts
+function shellWord(word) {
+  if (/^[A-Za-z0-9._:@/=+-]+$/.test(word)) return word;
+  if (CONTROL.test(word)) return `$'${word.replace(/[\\']/g, "\\$&").replace(CONTROLS, ansiEscape)}'`;
+  return `'${word.replace(/'/g, `'\\''`)}'`;
+}
+var CONTROL = /[\x00-\x1f\x7f-\x9f]/;
+var CONTROLS = new RegExp(CONTROL.source, "g");
+var ANSI_NAMED = { "\n": "\\n", "\r": "\\r", "	": "\\t" };
+function ansiEscape(c) {
+  return ANSI_NAMED[c] ?? [...Buffer.from(c, "utf8")].map((b) => `\\x${b.toString(16).padStart(2, "0")}`).join("");
+}
+function credentialFlags(args) {
+  return (args.profile === void 0 ? "" : ` --profile ${shellWord(args.profile)}`) + (args.authFile === void 0 ? "" : ` --config ${shellWord(args.authFile)}`);
+}
+
+export {
+  shellWord,
+  credentialFlags
+};
+//# sourceMappingURL=chunk-FWD7AL6N.js.map

package/dist/chunk-FXFV3KU6.js

@@ -0,0 +1,138 @@
+import {
+  rawResponse
+} from "./chunk-AKNCFVKZ.js";
+import {
+  RAW_ENVELOPE
+} from "./chunk-YU4HSQW7.js";
+import {
+  RAW_FIELD
+} from "./chunk-TTEIYD5P.js";
+import {
+  describeEntry
+} from "./chunk-CIMQZRRE.js";
+import {
+  __export
+} from "./chunk-PZ5AY32C.js";
+
+// src/codegen-entry.ts
+var codegen_entry_exports = {};
+__export(codegen_entry_exports, {
+  raw: () => raw,
+  rawField: () => rawField,
+  rawResponse: () => rawResponse,
+  rawValue: () => rawValue
+});
+
+// src/statements/special/raw.ts
+var CANONICAL_KEYS = [
+  "as",
+  "name",
+  "_xsid",
+  "addon",
+  "input",
+  "mocks",
+  "output",
+  "context",
+  "runtime",
+  "disabled",
+  "description",
+  "settings_registry"
+];
+function raw(envelope) {
+  if (envelope == null || typeof envelope !== "object" || Array.isArray(envelope)) {
+    throw new Error(
+      'raw() expects a stored statement envelope object \u2014 at minimum `{ name: "mvp:\u2026", context: {\u2026} }` \u2014 but received ' + (envelope === null ? "null" : Array.isArray(envelope) ? "an array" : typeof envelope)
+    );
+  }
+  const name = envelope.name;
+  if (typeof name !== "string" || name === "") {
+    throw new Error(
+      'raw() envelope is missing a `name`. A stored statement envelope must carry its `mvp:` name, e.g. `{ name: "mvp:set_var", context: {\u2026} }`.'
+    );
+  }
+  const stored = {};
+  for (const key of CANONICAL_KEYS) {
+    if (key in envelope) stored[key] = envelope[key];
+  }
+  for (const key of Object.keys(envelope)) {
+    if (!(key in stored)) stored[key] = envelope[key];
+  }
+  return {
+    name,
+    context: stored.context,
+    [RAW_ENVELOPE]: stored
+  };
+}
+
+// src/values/raw-value.ts
+function rawValue(v) {
+  if (typeof v !== "object" || v === null || Array.isArray(v) || typeof v.tag !== "string") {
+    throw new Error(
+      `rawValue() takes a stored tagged value \u2014 { value, tag, filters? } \u2014 got ${describeEntry(v)}.`
+    );
+  }
+  if (v.filters !== void 0 && v.filters !== null && !Array.isArray(v.filters)) {
+    throw new Error(`rawValue(): \`filters\` must be a list of stored filters \u2014 got ${describeEntry(v.filters)}.`);
+  }
+  return { value: v.value, tag: v.tag, filters: [...v.filters ?? []] };
+}
+
+// src/fields/raw-field.ts
+var CANONICAL_KEYS2 = [
+  "name",
+  "type",
+  "_xsid",
+  "description",
+  "nullable",
+  "default",
+  "merge",
+  "hidden",
+  "override",
+  "customize",
+  "required",
+  "values",
+  "mode",
+  "format",
+  "sensitive",
+  "list",
+  "vector",
+  "access",
+  "style",
+  "children",
+  "methods",
+  "market_item",
+  "is_settings_registry"
+];
+function rawField(envelope) {
+  if (envelope == null || typeof envelope !== "object" || Array.isArray(envelope)) {
+    throw new Error(
+      'rawField() expects a stored field envelope object \u2014 at minimum `{ name: "\u2026", type: "text" }` \u2014 but received ' + (envelope === null ? "null" : Array.isArray(envelope) ? "an array" : typeof envelope)
+    );
+  }
+  const { name, type } = envelope;
+  if (typeof name !== "string" || name === "") {
+    throw new Error('rawField() envelope is missing a `name`, e.g. `{ name: "email", type: "email" }`.');
+  }
+  if (typeof type !== "string" || type === "") {
+    throw new Error(`rawField() envelope for "${name}" is missing a \`type\`, e.g. "text" or "int".`);
+  }
+  const stored = {};
+  for (const key of CANONICAL_KEYS2) {
+    if (Object.hasOwn(envelope, key)) stored[key] = envelope[key];
+  }
+  for (const key of Object.keys(envelope)) {
+    if (!Object.hasOwn(stored, key)) stored[key] = envelope[key];
+  }
+  return {
+    type,
+    options: { [RAW_FIELD]: stored }
+  };
+}
+
+export {
+  raw,
+  rawValue,
+  rawField,
+  codegen_entry_exports
+};
+//# sourceMappingURL=chunk-FXFV3KU6.js.map