@xano/sdk 1.0.0

package/dist/chunk-5QU2P5CA.js

@@ -0,0 +1,304 @@
+import {
+  filledAt,
+  withValidFilled
+} from "./chunk-ZYJP6BOO.js";
+import {
+  withFileLockSync
+} from "./chunk-QO6BVGS5.js";
+import {
+  unreadableError
+} from "./chunk-JZGVVJSI.js";
+import {
+  destinationKey,
+  nextLandedRecord
+} from "./chunk-TLQE7ZN3.js";
+import {
+  ensureGitignored
+} from "./chunk-XW6KISBB.js";
+import {
+  atomicWrite
+} from "./chunk-LLNZGEFK.js";
+import {
+  DEFAULT_PROFILE
+} from "./chunk-QXTKSOFI.js";
+
+// src/deploy/ephemeral-state.ts
+import { readFileSync, mkdirSync } from "fs";
+import { dirname, join, resolve } from "path";
+function environmentKey(scope) {
+  return `${scope.profile?.name ?? DEFAULT_PROFILE}/${hostOf(scope.instance)}/${scope.workspaceId}`;
+}
+function hostOf(instance) {
+  try {
+    return new URL(instance).host;
+  } catch {
+    return instance.replace(/\//g, "_");
+  }
+}
+function ephemeralStatePath(dir) {
+  return join(resolve(dir), ".xano", "ephemeral.json");
+}
+function stateLockPath(dir) {
+  return `${ephemeralStatePath(dir)}.lock`;
+}
+function readEphemeralState(dir) {
+  const path = ephemeralStatePath(dir);
+  let text;
+  try {
+    text = readFileSync(path, "utf8");
+  } catch {
+    return { version: 1, environments: {} };
+  }
+  return parseState(text) ?? { version: 1, environments: {} };
+}
+function isAbsent(err) {
+  const code = err?.code;
+  return code === "ENOENT" || code === "ENOTDIR";
+}
+function readStateForWrite(dir) {
+  const path = ephemeralStatePath(dir);
+  try {
+    readFileSync(path);
+  } catch (err) {
+    if (!isAbsent(err) && err.code !== "EISDIR") throw unreadableError(path);
+  }
+  return readEphemeralState(dir);
+}
+function parseState(text) {
+  try {
+    const parsed = JSON.parse(text);
+    const envs = parsed?.environments;
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed) && envs !== null && typeof envs === "object" && !Array.isArray(envs)) {
+      const landed = validLanded(parsed.landed);
+      return { version: 1, environments: { ...envs }, ...landed !== void 0 ? { landed } : {} };
+    }
+  } catch {
+  }
+  return void 0;
+}
+function unreadableEphemeralState(dir) {
+  const path = ephemeralStatePath(dir);
+  let text;
+  try {
+    text = readFileSync(path, "utf8");
+  } catch (err) {
+    return isAbsent(err) ? void 0 : path;
+  }
+  return parseState(text) === void 0 ? path : void 0;
+}
+function getEnvironment(state, scope) {
+  const record = state.environments[keyIn(state, scope)];
+  return record === void 0 ? void 0 : withValidFilled(record);
+}
+function keyIn(state, scope) {
+  const key = environmentKey(scope);
+  if (key in state.environments) return key;
+  const legacy = String(scope.workspaceId);
+  return legacy in state.environments ? legacy : key;
+}
+function adoptsLegacy(state, scope) {
+  return keyIn(state, scope) === String(scope.workspaceId);
+}
+function setEnvironment(dir, scope, record) {
+  withFileLockSync(stateLockPath(dir), () => setEnvironmentLocked(dir, scope, record));
+}
+function setEnvironmentLocked(dir, scope, record) {
+  const state = readStateForWrite(dir);
+  const adopting = adoptsLegacy(state, scope);
+  const replaced = state.environments[keyIn(state, scope)]?.name;
+  if (replaced !== void 0 && replaced !== record.name && state.landed !== void 0) {
+    const { [ephemeralLandingKey(scope.instance, replaced)]: _gone, ...landed } = state.landed;
+    state.landed = landed;
+  }
+  const { credential: _carried, ...rest } = record;
+  state.environments[environmentKey(scope)] = {
+    ...rest,
+    profile: scope.profile?.name ?? DEFAULT_PROFILE,
+    instance: scope.instance,
+    ...scope.profile === void 0 ? { credential: "environment" } : {}
+  };
+  if (adopting) delete state.environments[String(scope.workspaceId)];
+  writeState(dir, state);
+}
+function markEnvironmentFilled(dir, scope, url, landed = {}) {
+  withFileLockSync(stateLockPath(dir), () => markEnvironmentFilledLocked(dir, scope, url, landed));
+}
+function markEnvironmentFilledLocked(dir, scope, url, landed) {
+  const record = getEnvironment(readEphemeralState(dir), scope);
+  if (record === void 0) return;
+  const { release: _release, entry: _entry, ...rest } = record;
+  setEnvironment(dir, scope, {
+    ...rest,
+    filled: filledAt(url),
+    ...landed.release === void 0 ? {} : { release: landed.release },
+    ...landed.entry === void 0 ? {} : { entry: landed.entry }
+  });
+}
+function recordStaticUrl(dir, scope, staticUrl) {
+  withFileLockSync(stateLockPath(dir), () => recordStaticUrlLocked(dir, scope, staticUrl));
+}
+function recordStaticUrlLocked(dir, scope, staticUrl) {
+  const record = getEnvironment(readEphemeralState(dir), scope);
+  if (record === void 0) return;
+  const { static_down: _down, static_unchecked: _unchecked, ...rest } = record;
+  setEnvironment(dir, scope, { ...rest, static_url: staticUrl });
+}
+function clearEnvironment(dir, scope) {
+  return withFileLockSync(stateLockPath(dir), () => clearEnvironmentLocked(dir, scope));
+}
+function clearEnvironmentLocked(dir, scope) {
+  const state = readEphemeralState(dir);
+  const keys = [environmentKey(scope), ...adoptsLegacy(state, scope) ? [String(scope.workspaceId)] : []].filter(
+    (k) => k in state.environments
+  );
+  if (keys.length === 0) return false;
+  const landed = { ...state.landed ?? {} };
+  for (const key of keys) {
+    const name = state.environments[key]?.name;
+    if (name !== void 0) delete landed[ephemeralLandingKey(scope.instance, name)];
+    delete state.environments[key];
+  }
+  writeState(dir, { ...state, landed });
+  return true;
+}
+function clearEnvironmentsNamed(dir, instance, name) {
+  return withFileLockSync(stateLockPath(dir), () => clearEnvironmentsNamedLocked(dir, instance, name));
+}
+function clearEnvironmentsNamedLocked(dir, instance, name) {
+  const state = readEphemeralState(dir);
+  const host = hostOf(instance);
+  const keys = Object.entries(state.environments).filter(
+    ([key, record]) => record.name === name && (record.instance !== void 0 ? hostOf(record.instance) === host : key.split("/")[1] === host)
+  ).map(([key]) => key);
+  if (keys.length === 0) return false;
+  for (const key of keys) delete state.environments[key];
+  const landed = { ...state.landed ?? {} };
+  delete landed[ephemeralLandingKey(instance, name)];
+  writeState(dir, { ...state, landed });
+  return true;
+}
+function ephemeralLandingKey(instance, name) {
+  return destinationKey(instance, { kind: "ephemeral", name });
+}
+function ephemeralLandedOn(dir, destKey) {
+  const record = readEphemeralState(dir).landed?.[destKey];
+  return record === void 0 || Object.keys(record).length === 0 ? void 0 : record;
+}
+function allLandings(dir, lock) {
+  return [...Object.entries(lock.landed ?? {}), ...Object.entries(readEphemeralState(dir).landed ?? {})];
+}
+function recordEphemeralLanding(dir, destKey, update) {
+  return withFileLockSync(stateLockPath(dir), () => recordEphemeralLandingLocked(dir, destKey, update));
+}
+function recordEphemeralLandingLocked(dir, destKey, update) {
+  const state = readStateForWrite(dir);
+  const before = state.landed?.[destKey] ?? {};
+  const next = nextLandedRecord(before, update);
+  const changed = JSON.stringify(sortedRecord(before)) !== JSON.stringify(sortedRecord(next));
+  if (changed) {
+    const landed = { ...state.landed ?? {} };
+    if (Object.keys(next).length > 0) landed[destKey] = next;
+    else delete landed[destKey];
+    writeState(dir, { ...state, landed });
+  }
+  return { changed, recorded: Object.keys(next).length };
+}
+function clearEphemeralLanding(dir, instance, name) {
+  return withFileLockSync(stateLockPath(dir), () => clearEphemeralLandingLocked(dir, instance, name));
+}
+function clearEphemeralLandingLocked(dir, instance, name) {
+  const state = readEphemeralState(dir);
+  const key = ephemeralLandingKey(instance, name);
+  if (state.landed?.[key] === void 0) return false;
+  const { [key]: _dropped, ...landed } = state.landed;
+  writeState(dir, { ...state, landed });
+  return true;
+}
+function sortedRecord(record) {
+  const columns = (e) => e.columns === void 0 ? "" : JSON.stringify(Object.keys(e.columns).sort().map((c) => [c, e.columns[c]]));
+  return Object.keys(record).sort().map((k) => [k, record[k].guid, record[k].type ?? "", columns(record[k])]);
+}
+function validLanded(raw) {
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return void 0;
+  const out = {};
+  for (const [dest, entries] of Object.entries(raw)) {
+    if (!/^[^/\s]+\/ephemeral\/[^/\s]+$/.test(dest)) continue;
+    if (entries === null || typeof entries !== "object" || Array.isArray(entries)) continue;
+    const record = {};
+    for (const [key, e] of Object.entries(entries)) {
+      const { guid, type, columns } = e ?? {};
+      if (typeof guid !== "string" || guid === "" || !/^[a-z_]+:./i.test(key)) continue;
+      record[key] = type === "agent" && key.startsWith("toolset:") ? { guid, type: "agent" } : { guid };
+      const stored = key.startsWith("dbo:") ? validColumns(columns) : void 0;
+      if (stored !== void 0) record[key].columns = stored;
+    }
+    if (Object.keys(record).length > 0) out[dest] = record;
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function validColumns(raw) {
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return void 0;
+  const out = {};
+  for (const [column, type] of Object.entries(raw)) {
+    if (typeof type === "string" && type !== "") out[column] = type;
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+var RECORD_KEY_ORDER = [
+  "name",
+  "display",
+  "url",
+  "expires_at",
+  "profile",
+  "instance",
+  "credential",
+  "credential_file",
+  "filled",
+  "static_url",
+  "static_down",
+  "static_unchecked",
+  "entry",
+  "release"
+];
+function inRecordOrder(record) {
+  const rank = (k) => {
+    const i = RECORD_KEY_ORDER.indexOf(k);
+    return i === -1 ? RECORD_KEY_ORDER.length : i;
+  };
+  const keys = Object.keys(record).sort((a, b) => rank(a) - rank(b) || a.localeCompare(b));
+  return Object.fromEntries(keys.map((k) => [k, record[k]]));
+}
+function writeState(dir, state) {
+  const path = ephemeralStatePath(dir);
+  mkdirSync(dirname(path), { recursive: true });
+  const landed = {};
+  for (const dest of Object.keys(state.landed ?? {}).sort()) {
+    const src = state.landed[dest];
+    if (Object.keys(src).length === 0) continue;
+    landed[dest] = Object.fromEntries(Object.keys(src).sort().map((k) => [k, src[k]]));
+  }
+  const environments = {};
+  for (const key of Object.keys(state.environments)) environments[key] = inRecordOrder(state.environments[key]);
+  const body = Object.keys(landed).length > 0 ? { version: 1, environments, landed } : { version: 1, environments };
+  atomicWrite(path, JSON.stringify(body, null, 2) + "\n");
+  ensureGitignored(path);
+}
+
+export {
+  environmentKey,
+  ephemeralStatePath,
+  readEphemeralState,
+  unreadableEphemeralState,
+  getEnvironment,
+  setEnvironment,
+  markEnvironmentFilled,
+  recordStaticUrl,
+  clearEnvironment,
+  clearEnvironmentsNamed,
+  ephemeralLandingKey,
+  ephemeralLandedOn,
+  allLandings,
+  recordEphemeralLanding,
+  clearEphemeralLanding
+};
+//# sourceMappingURL=chunk-5QU2P5CA.js.map

package/dist/chunk-5V5XU32D.js

@@ -0,0 +1,191 @@
+import {
+  defaultHistory,
+  emptyMiddleware
+} from "./chunk-4POWHT2K.js";
+import {
+  RAW_ENVELOPE,
+  encodeStatement,
+  registerStatement
+} from "./chunk-YU4HSQW7.js";
+import {
+  isTaggedValue
+} from "./chunk-OXA6PSZT.js";
+import {
+  resolveRef
+} from "./chunk-NZOWWHU5.js";
+
+// src/kinds/history.ts
+var CONTAINER_DEFAULT_ENABLED = {
+  query: true,
+  tool: true,
+  message: false
+};
+var WORKSPACE_HISTORY_TYPES = [
+  "query",
+  "function",
+  "task",
+  "tool",
+  "trigger",
+  "middleware",
+  "message",
+  // The MCP primitives. Both default ON, like `tool`. An instance from before
+  // they existed stores neither pair; it reads the absent pair as that default.
+  "prompt",
+  "resource"
+];
+function scalarToEnabledLimit(input) {
+  if (input === false) return { enabled: false, limit: 100 };
+  if (input === true) return { enabled: true, limit: 100 };
+  if (input === "all") return { enabled: true, limit: -1 };
+  if (!Number.isInteger(input) || input < 0) {
+    throw new Error(
+      `history takes true, false, "all" or an integer depth >= 0, got ${JSON.stringify(input)}`
+    );
+  }
+  return { enabled: true, limit: input };
+}
+function encodeHistory(objType, input) {
+  if (input === void 0) return defaultHistory(objType);
+  const { enabled, limit } = scalarToEnabledLimit(input);
+  return { inherit: false, enabled, limit };
+}
+function encodeContainerHistory(prefix, input) {
+  const { inherit, enabled, limit } = input === void 0 ? { inherit: true, enabled: CONTAINER_DEFAULT_ENABLED[prefix], limit: 100 } : { inherit: false, ...scalarToEnabledLimit(input) };
+  return {
+    inherit,
+    [`${prefix}_enabled`]: enabled,
+    [`${prefix}_limit`]: limit
+  };
+}
+function buildWorkspaceHistory(map) {
+  const out = {};
+  for (const t of WORKSPACE_HISTORY_TYPES) {
+    const input = map[t];
+    const { enabled, limit } = input === void 0 ? { enabled: defaultHistory(t).enabled, limit: 100 } : scalarToEnabledLimit(input);
+    out[`${t}_enabled`] = enabled;
+    out[`${t}_limit`] = limit;
+  }
+  return out;
+}
+
+// src/kinds/middleware-attach.ts
+function isRawEntry(entry) {
+  return typeof entry === "object" && entry !== null && entry[RAW_ENVELOPE] !== void 0;
+}
+function parseEntry(entry) {
+  if (typeof entry === "object" && "middleware" in entry) {
+    return { ref: entry.middleware, active: entry.active };
+  }
+  return { ref: entry };
+}
+function middlewareAttachStatement(args) {
+  return {
+    name: "mvp:middleware",
+    context: { middleware: { id: resolveRef("middleware", args.middleware) } },
+    ...args.active === false ? { disabled: true } : {}
+  };
+}
+registerStatement("mvp:middleware", middlewareAttachStatement);
+function encodeMiddlewareEntry(entry) {
+  if (isRawEntry(entry)) return encodeStatement(entry);
+  const { ref, active } = parseEntry(entry);
+  return encodeStatement(middlewareAttachStatement({ middleware: ref, active }));
+}
+function middlewareEntryGuid(entry) {
+  const id = entry?.context?.middleware?.id;
+  return typeof id === "string" ? id : void 0;
+}
+function buildMiddlewareBlock(attach) {
+  if (!attach) return emptyMiddleware();
+  return {
+    pre_customize: attach.pre !== void 0,
+    post_customize: attach.post !== void 0,
+    pre: encodeMiddlewareList(attach.pre),
+    post: encodeMiddlewareList(attach.post)
+  };
+}
+function encodeMiddlewareList(entries) {
+  return (entries ?? []).map(encodeMiddlewareEntry);
+}
+function clear() {
+  return [];
+}
+function stackReferencesAuth(stack) {
+  return (stack ?? []).some(nodeReferencesAuth);
+}
+function nodeReferencesAuth(node) {
+  if (node === null || typeof node !== "object" && typeof node !== "function") return false;
+  if (isTaggedValue(node) && node.tag === "auth") return true;
+  if (Array.isArray(node)) return node.some(nodeReferencesAuth);
+  return Object.values(node).some(nodeReferencesAuth);
+}
+
+// src/kinds/stored-name.ts
+var NAME_MAX = 200;
+var EXTRA = {
+  route: "_-{}/",
+  plain: "_-"
+};
+var PATTERN = {
+  route: /^[A-Za-z0-9_\-{}/]+$/,
+  plain: /^[A-Za-z0-9_-]+$/
+};
+var DESCRIPTION = {
+  route: 'only letters, digits, "_", "-", "/", and the "{}" of a path param',
+  plain: 'only letters, digits, "_" and "-"'
+};
+function assertCanonical(context, canonical) {
+  if (canonical === void 0 || canonical === "") return;
+  if (canonical.length > NAME_MAX) {
+    throw new Error(
+      `${context}: the canonical is ${canonical.length} characters \u2014 the engine stores at most ${NAME_MAX}. Shorten it, or omit it and let \`xanosdk export <entry>\` mint one.`
+    );
+  }
+  if (PATTERN.plain.test(canonical)) return;
+  const bad = [.../* @__PURE__ */ new Set([...canonical])].filter((ch) => !/[A-Za-z0-9_-]/.test(ch));
+  throw new Error(
+    `${context}: the canonical contains ${bad.map((ch) => JSON.stringify(ch)).join(", ")}, which cannot appear in a URL token. A canonical holds ${DESCRIPTION.plain} \u2014 it is the \`<canonical>\` of \`/api:<canonical>\` and of the MCP/realtime stream paths. Unlike a name, the engine does NOT reject or blank it: it stores the value verbatim, the deploy succeeds, and every client then 404s against an address the router cannot match. Omit \`canonical\` to let \`xanosdk export <entry>\` mint one, or supply a token in charset.`
+  );
+}
+function assertStoredName(context, name, shape) {
+  if (name.length > NAME_MAX) {
+    throw new Error(
+      `${context}: the name is ${name.length} characters \u2014 the engine stores at most ${NAME_MAX}, and a longer one is dropped rather than truncated, leaving the object with an empty name. Shorten it.`
+    );
+  }
+  if (PATTERN[shape].test(name)) return;
+  if (!name) throw new Error(`${context}: the name is empty.`);
+  const allowed = /* @__PURE__ */ new Set([...EXTRA[shape]]);
+  const bad = [.../* @__PURE__ */ new Set([...name])].filter(
+    (ch) => !/[A-Za-z0-9]/.test(ch) && !allowed.has(ch)
+  );
+  const list = bad.map((ch) => JSON.stringify(ch)).join(", ");
+  const hint = bad.includes(".") ? ` A "." is the one authors reach for: an endpoint that serves a file wants "export_zip" or "export/zip", not "export.zip" \u2014 the extension belongs in the response headers.` : "";
+  throw new Error(
+    `${context}: the name contains ${list}, which the engine cannot store. This name holds ${DESCRIPTION[shape]}.${hint} Xano does not reject the write \u2014 it saves the object with an EMPTY name, so it deploys clean and then 404s "Unable to locate request." on every request.`
+  );
+}
+function assertNameAsStored(kind, name) {
+  if (typeof name !== "string" || name === "" || name.trim() === name) return;
+  const head = `${kind} ${JSON.stringify(name)}: `;
+  throw new Error(
+    name.trim() === "" ? `${head}the name is empty.` : `${head}the engine stores it trimmed, so it reads back as a rename. Write ${JSON.stringify(name.trim())}.`
+  );
+}
+
+export {
+  WORKSPACE_HISTORY_TYPES,
+  encodeHistory,
+  encodeContainerHistory,
+  buildWorkspaceHistory,
+  encodeMiddlewareEntry,
+  middlewareEntryGuid,
+  buildMiddlewareBlock,
+  encodeMiddlewareList,
+  clear,
+  stackReferencesAuth,
+  assertCanonical,
+  assertStoredName,
+  assertNameAsStored
+};
+//# sourceMappingURL=chunk-5V5XU32D.js.map

package/dist/chunk-5ZSO4T2G.js

@@ -0,0 +1,10 @@
+// src/util/shell-quote.ts
+function shellQuote(value) {
+  if (/^[A-Za-z0-9_./:=@%+-]+$/.test(value)) return value;
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}
+
+export {
+  shellQuote
+};
+//# sourceMappingURL=chunk-5ZSO4T2G.js.map

package/dist/chunk-622HUCZT.js

@@ -0,0 +1,10 @@
+// src/util/and-list.ts
+function andList(items) {
+  if (items.length <= 1) return items.join("");
+  return `${items.slice(0, -1).join(", ")} and ${items[items.length - 1]}`;
+}
+
+export {
+  andList
+};
+//# sourceMappingURL=chunk-622HUCZT.js.map

package/dist/chunk-65HWOMGV.js

@@ -0,0 +1,177 @@
+import {
+  landedStep
+} from "./chunk-4KHEMC32.js";
+import {
+  CliError,
+  UsageError,
+  style,
+  terminalText
+} from "./chunk-PTHVMXZI.js";
+
+// src/emit/prompt.ts
+import { createInterface } from "readline";
+var EXIT_PROMPT_CANCELLED = 130;
+var CANCELLED = /* @__PURE__ */ Symbol("cancelled");
+function promptCancelled() {
+  const landed = landedStep();
+  const after = landed === void 0 ? "Nothing was changed." : landed.ifCancelled ?? landed.said;
+  return new CliError("SDK_ERROR", `Cancelled. ${after}`, { exitCode: EXIT_PROMPT_CANCELLED });
+}
+async function questionOrCancel(rl, text, output = process.stderr) {
+  if (typeof rl.once !== "function" || typeof rl.off !== "function") return rl.question(text);
+  let onInterrupt;
+  const cancelled = new Promise((_, reject) => {
+    onInterrupt = () => {
+      output.write("\n");
+      reject(promptCancelled());
+    };
+    rl.once("SIGINT", onInterrupt);
+  });
+  try {
+    return await Promise.race([rl.question(text), cancelled]);
+  } finally {
+    rl.off("SIGINT", onInterrupt);
+  }
+}
+async function confirm(message, opts) {
+  if (process.stdin.isTTY !== true) throw needsConfirmation(message, opts.refusal);
+  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  try {
+    const onClose = () => settle(null);
+    const onInterrupt = () => settle(CANCELLED);
+    let settle;
+    const answer = await new Promise((resolve) => {
+      settle = resolve;
+      rl.once("close", onClose);
+      rl.once("SIGINT", onInterrupt);
+      rl.question(terminalText(`${style.yellow("?")} ${message} (y/N) `), resolve);
+    }).finally(() => {
+      rl.off("close", onClose);
+      rl.off("SIGINT", onInterrupt);
+    });
+    if (answer === CANCELLED) {
+      process.stderr.write("\n");
+      throw promptCancelled();
+    }
+    if (answer === null) {
+      process.stderr.write("\n");
+      return false;
+    }
+    return /^y(es)?$/i.test(answer.trim());
+  } finally {
+    rl.close();
+  }
+}
+function needsConfirmation(message, refusal, lead = "Cannot ask for confirmation: stdin is not a terminal.") {
+  const text = `${lead} It would have asked: ${message.trim()}
+Re-run as \`${refusal.rerun}\` to answer yes without being asked.${refusal.note ?? ""}`;
+  return new CliError("SDK_USAGE", text, {
+    exitCode: 1,
+    details: { reason: "needs-confirmation", ...refusal.details }
+  });
+}
+var MAX_EMPTY_ANSWERS = 3;
+async function promptLine(message, opts) {
+  if (process.stdin.isTTY !== true) {
+    throw new UsageError(`Cannot prompt: stdin is not a terminal. ${opts.noTtyHint}`);
+  }
+  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  if (opts.mask === true) {
+    const iface = rl;
+    let atPrompt = false;
+    iface._writeToOutput = (chunk) => {
+      if (!atPrompt) {
+        process.stderr.write(chunk);
+        atPrompt = true;
+        return;
+      }
+      if (chunk.includes("\n")) {
+        process.stderr.write("\n");
+        atPrompt = false;
+      }
+    };
+  }
+  try {
+    for (let attempt = 0; attempt < MAX_EMPTY_ANSWERS; attempt++) {
+      const onClose = () => settle(null);
+      const onInterrupt = () => settle(CANCELLED);
+      let settle;
+      const answer = await new Promise((resolve) => {
+        settle = resolve;
+        rl.once("close", onClose);
+        rl.once("SIGINT", onInterrupt);
+        rl.question(terminalText(`${style.yellow("?")} ${message} `), resolve);
+      }).finally(() => {
+        rl.off("close", onClose);
+        rl.off("SIGINT", onInterrupt);
+      });
+      if (answer === CANCELLED) {
+        process.stderr.write("\n");
+        throw promptCancelled();
+      }
+      if (answer === null) throw new UsageError(`Input ended before an answer arrived. ${opts.noTtyHint}`);
+      const trimmed = answer.trim();
+      if (trimmed !== "") return trimmed;
+      process.stderr.write(terminalText(`${style.yellow("!")} A value is required.
+`));
+    }
+    throw new UsageError(`No value entered. ${opts.noTtyHint}`);
+  } finally {
+    rl.close();
+  }
+}
+var STDIN_IDLE_MS = 3e4;
+async function readStdin() {
+  const stdin = process.stdin;
+  if (stdin.isTTY === true) return void 0;
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let timer;
+    const done = () => {
+      clearTimeout(timer);
+      stdin.off("data", onData);
+      stdin.off("end", onEnd);
+      stdin.off("error", onError);
+    };
+    const onIdle = () => {
+      done();
+      stdin.pause();
+      reject(
+        new UsageError(
+          `stdin is not a terminal, and nothing arrived on it for ${STDIN_IDLE_MS / 1e3}s. Pipe the value in (\`printf %s "$VALUE" | xanosdk \u2026\`), or close stdin (\`</dev/null\`) when there is none.`
+        )
+      );
+    };
+    const arm = () => {
+      clearTimeout(timer);
+      timer = setTimeout(onIdle, STDIN_IDLE_MS);
+    };
+    const onData = (chunk) => {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+      arm();
+    };
+    const onEnd = () => {
+      done();
+      resolve(Buffer.concat(chunks).toString("utf8"));
+    };
+    const onError = (err) => {
+      done();
+      reject(err);
+    };
+    stdin.on("data", onData);
+    stdin.once("end", onEnd);
+    stdin.once("error", onError);
+    arm();
+  });
+}
+
+export {
+  promptCancelled,
+  questionOrCancel,
+  confirm,
+  needsConfirmation,
+  promptLine,
+  STDIN_IDLE_MS,
+  readStdin
+};
+//# sourceMappingURL=chunk-65HWOMGV.js.map