@xano/sdk 1.0.0

package/dist/env-var-command-ZIRDCAZA.js

@@ -0,0 +1,427 @@
+import {
+  confirm,
+  readStdin
+} from "./chunk-65HWOMGV.js";
+import {
+  assertOneName
+} from "./chunk-ZIY7RNUT.js";
+import {
+  WORKSPACE_ENV_FILE,
+  defaultWorkspaceEnvPath,
+  workspaceEnvPathIn
+} from "./chunk-DAD3ONIS.js";
+import {
+  memoCredential,
+  refuseProfileForLocal,
+  selectBackend
+} from "./chunk-HHN734BU.js";
+import {
+  isRealDeployment
+} from "./chunk-LPECSJ2J.js";
+import "./chunk-6NNTNXN7.js";
+import {
+  actualKind,
+  describeBackend,
+  resolveSource
+} from "./chunk-QCNYHBL7.js";
+import "./chunk-2ZUEE4EK.js";
+import "./chunk-AN6BL47T.js";
+import {
+  getAccessToken
+} from "./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 {
+  requireBackendSlot
+} from "./chunk-STSFNCY4.js";
+import "./chunk-5QU2P5CA.js";
+import "./chunk-ZYJP6BOO.js";
+import "./chunk-QO6BVGS5.js";
+import "./chunk-JZGVVJSI.js";
+import "./chunk-7G3CTU7I.js";
+import {
+  recordAnswer,
+  writeTransportFailure
+} from "./chunk-6PBR37LN.js";
+import "./chunk-T5KELPAR.js";
+import "./chunk-622HUCZT.js";
+import {
+  contextFlags
+} from "./chunk-NAQDMEHV.js";
+import "./chunk-5A2PLKZB.js";
+import "./chunk-AHJWCYQO.js";
+import "./chunk-DX4QR4B2.js";
+import "./chunk-6QXLMMT3.js";
+import "./chunk-ZFDZKNGG.js";
+import "./chunk-FWD7AL6N.js";
+import "./chunk-2GNFDZA2.js";
+import "./chunk-JTUKLCXS.js";
+import {
+  describeWrite
+} from "./chunk-4KHEMC32.js";
+import "./chunk-ROY4YAEQ.js";
+import "./chunk-TLQE7ZN3.js";
+import "./chunk-WRBKLYSJ.js";
+import "./chunk-3LDULPRE.js";
+import "./chunk-XW6KISBB.js";
+import "./chunk-AWQ7BQTQ.js";
+import "./chunk-EUUUMY7J.js";
+import {
+  SENT_AFTERMATH,
+  certificateFailureCode,
+  explainBindingRefusal,
+  fetchOrExplain,
+  readBodyText,
+  safeHttpFailure,
+  withWriteStatusAftermath
+} from "./chunk-YLDALTWZ.js";
+import "./chunk-5FBYXK5P.js";
+import "./chunk-LLNZGEFK.js";
+import "./chunk-QXTKSOFI.js";
+import "./chunk-X2NL4KUO.js";
+import "./chunk-UCQ2VUTG.js";
+import "./chunk-DGWHAVRG.js";
+import {
+  UsageError,
+  backendDestinationPayload,
+  discloseWriteTarget,
+  info,
+  isMachineOutput,
+  relForwardSlash,
+  success,
+  writeJson,
+  writeTargetPayload
+} from "./chunk-PTHVMXZI.js";
+import {
+  isRepresentableName
+} from "./chunk-GSGDWJB5.js";
+import "./chunk-UTI5G6OJ.js";
+import "./chunk-2EZ3ZJZZ.js";
+import "./chunk-6MR5TI5V.js";
+import {
+  shellQuote
+} from "./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";
+
+// src/emit/env-var-command.ts
+import { existsSync } from "fs";
+import { resolve } from "path";
+
+// src/deploy/workspace-env-var.ts
+var ENV_VAR_TIMEOUT_MS = 3e4;
+var SETTINGS_SCOPE_REMEDY = `This credential may lack permission to change workspace settings, which env vars are part of. An access token needs the workspace settings scope (\`workspace:settings\`); grant it, or use a credential whose role can edit this workspace's settings, then run it again.`;
+var EnvVarRouteMissingError = class extends Error {
+  name = "EnvVarRouteMissingError";
+};
+function endpoint(target) {
+  return `${target.baseUrl.replace(/\/$/, "")}/api:meta/workspace/${target.workspaceId}/xanosdk/env/${encodeURIComponent(target.name)}`;
+}
+async function setWorkspaceEnvVar(auth, opts) {
+  return send(
+    auth,
+    opts,
+    {
+      method: "PUT",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ value: opts.value })
+    },
+    `set env var ${opts.name}`,
+    ["created", "updated"]
+  );
+}
+async function unsetWorkspaceEnvVar(auth, opts) {
+  return send(auth, opts, { method: "DELETE" }, `clear env var ${opts.name}`, ["deleted", "absent"]);
+}
+async function send(auth, target, init, action, expected) {
+  const url = endpoint(target);
+  const res = await fetchOrExplain(
+    url,
+    {
+      signal: AbortSignal.timeout(ENV_VAR_TIMEOUT_MS),
+      ...init,
+      headers: {
+        accept: "application/json",
+        Authorization: `Bearer ${auth.access_token}`,
+        ...init.headers ?? {}
+      }
+    },
+    action,
+    ENV_VAR_TIMEOUT_MS
+  ).catch((err) => {
+    throw writeTransportFailure(err);
+  });
+  const text = await readBodyText(res, action, { url, aftermath: SENT_AFTERMATH });
+  if (!res.ok) {
+    if (res.status === 404 && /unable to locate request/i.test(text)) {
+      throw new EnvVarRouteMissingError(
+        `${action} failed: ${target.baseUrl.replace(/\/$/, "")} does not support ${init.method === "DELETE" ? "clearing" : "setting"} one env var by name yet.`
+      );
+    }
+    const failure = safeHttpFailure(action, res, text, target.binding);
+    if (res.status === 403 && target.binding !== void 0 && explainBindingRefusal(target.binding) === void 0) {
+      throw new Error(`${failure}
+${SETTINGS_SCOPE_REMEDY}`);
+    }
+    throw new Error(withWriteStatusAftermath(failure, res.status));
+  }
+  const answer = recordAnswer(
+    text,
+    action,
+    url,
+    (row) => typeof row.action === "string" && expected.includes(row.action),
+    { safe: true, write: true }
+  );
+  return answer.action;
+}
+
+// src/emit/env-var-command.ts
+async function runEnvVarCommand(args, verb, opts = {}) {
+  const help = { command: "env", subcommand: verb };
+  const name = args.positionals[0] ?? "";
+  if (name.trim() === "") {
+    throw new UsageError(`\`xanosdk env ${verb}\` needs the NAME of the env var.`, { helpFor: help });
+  }
+  assertOneName(name, `the NAME given to \`xanosdk env ${verb}\``, { helpFor: help, echo: false });
+  if (name.includes("=")) {
+    throw new UsageError(
+      verb === "unset" ? `\`xanosdk env unset\` takes only the name (\`xanosdk env unset ${name.slice(0, name.indexOf("=")) || "NAME"}\`), and a name cannot contain "=".` : `\`xanosdk env ${verb}\` takes the name and the value as separate arguments (\`xanosdk env set NAME VALUE\`), and a name cannot contain "=".`,
+      { hintFor: help }
+    );
+  }
+  if (verb === "set" && !isRepresentableName(name)) {
+    throw new UsageError(
+      `\`xanosdk env set\`: the first argument is not a usable env var name (it is not repeated here in case the arguments are swapped). A name is letters, digits and \`_\`, and does not start with a digit (e.g. STRIPE_KEY); the value comes second, or on stdin.`,
+      { hintFor: help }
+    );
+  }
+  if (verb === "set" && ["__proto__", "constructor", "prototype"].includes(name)) {
+    throw new UsageError(
+      `\`xanosdk env set\`: \`${name}\` cannot be an env var name \u2014 \`__proto__\`, \`constructor\` and \`prototype\` are reserved JavaScript object keys, as \`--env-var\` refuses them. Choose another name.`,
+      { hintFor: help }
+    );
+  }
+  const value = verb === "set" ? await readValue(args, name, help, opts) : void 0;
+  const destination = await resolveDestination(args, verb, opts.deps);
+  if (destination.real && args.yes !== true) {
+    info(
+      verb === "set" ? `${name} will be set on ${destination.label}. Every other env var there is left as it is.` : `${name} will be cleared on ${destination.label}. Every other env var there is left as it is.`
+    );
+    discloseWriteTarget(destination.disclosure);
+    const ok = await confirm(verb === "set" ? `Set ${name}?` : `Clear ${name}?`, {
+      flag: "--yes",
+      refusal: {
+        details: { verb, name, action: null, declined: false },
+        rerun: verb === "set" ? `printf %s "$VALUE" | xanosdk env set ${shellQuote(name)} --yes${args.json === true ? " --json" : ""}${sameDestination(args)}` : `xanosdk env ${verb} ${shellQuote(name)} --yes${args.json === true ? " --json" : ""}${sameDestination(args)}`,
+        ...verb === "set" ? { note: " Its value is not reprinted: pipe it in as shown, or pass it as the second argument." } : {}
+      }
+    });
+    if (!ok) {
+      info(`${verb === "set" ? "Set" : "Clear"} cancelled \u2014 nothing was written.`);
+      if (isMachineOutput(args)) {
+        writeJson({ verb, name, action: null, destination: destination.receipt, declined: true });
+      }
+      return;
+    }
+  }
+  const target = {
+    baseUrl: destination.baseUrl,
+    workspaceId: destination.workspaceId,
+    name,
+    binding: destination.binding
+  };
+  let action;
+  try {
+    action = await describeWrite(
+      {
+        what: `the ${verb === "set" ? "set" : "clear"} of ${name}`,
+        check: lostAnswerAftermath(verb, name, args).replace(/^The request was sent, so it may or may not have taken effect\. /, "")
+      },
+      () => value !== void 0 ? setWorkspaceEnvVar(destination.auth, { ...target, value }) : unsetWorkspaceEnvVar(destination.auth, target)
+    );
+  } catch (err) {
+    if (err instanceof EnvVarRouteMissingError) {
+      const cwd = opts.deps?.cwd ?? process.cwd();
+      const { entry, recorded } = await landedEntry(destination, cwd);
+      const envFile = (recorded ? relForwardSlash(cwd, defaultWorkspaceEnvPath(resolve(cwd, entry))) : relForwardSlash(cwd, workspaceEnvPathIn(cwd))) || WORKSPACE_ENV_FILE;
+      throw new Error(
+        `${err.message} ${routeMissingHint(verb, name, destination.kind, envFile, contextFlags(args), entry, args.to)}`,
+        { cause: err }
+      );
+    }
+    if (certificateFailureCode(err) !== void 0) {
+      const { LookupFailedError } = await import("./source-resolve-S2XA3XZF.js");
+      const { command, value: value2, withheld } = await notSentRerun(verb, name, args);
+      const head = err.message.trim().replace(/[.:]$/, "");
+      const refused = new LookupFailedError(head, "unreachable", destination.kind, `run \`${command}\` again${value2}`);
+      refused.message += withheld;
+      refused.cause = err;
+      throw refused;
+    }
+    if (err instanceof Error && err.message.includes(SENT_AFTERMATH)) {
+      err.message = err.message.replace(SENT_AFTERMATH, lostAnswerAftermath(verb, name, args));
+    } else if (err instanceof Error && err.message.endsWith(NOT_SENT_AFTERMATH)) {
+      err.message = err.message.slice(0, -NOT_SENT_AFTERMATH.length) + await notSentAftermath(verb, name, args);
+    }
+    throw err;
+  }
+  if (isMachineOutput(args)) {
+    writeJson({ verb, name, action, destination: destination.receipt, declined: false });
+    success(outcomeLine(name, action, destination.label));
+    return;
+  }
+  success(outcomeLine(name, action, destination.label));
+  if (!destination.real || args.yes === true) discloseWriteTarget(destination.disclosure);
+}
+function routeMissingHint(verb, name, kind, envFile, flags = "", entry, to) {
+  const file = entry === void 0 ? "" : ` ${shellQuote(entry)}`;
+  if (kind === "workspace" || kind === "tenant") {
+    const deploy = to === void 0 ? void 0 : `xanosdk deploy${file} --to ${shellQuote(to)} --env-var ${name}=...${flags}`;
+    return verb === "set" ? `Deploy the value with \`--env-var ${name}=...\` instead${deploy === void 0 ? "" : ` (\`${deploy}\`)`} \u2014 a merge only adds new names; \`--replace\` rewrites every one.` : `A merge deploy never removes a name; only a \`--replace\` deploy, which rewrites every env var from the deploy's own set, clears it.`;
+  }
+  const base = kind === "local-engine" ? "xanosdk deploy --local-engine" : `xanosdk deploy${file}${flags}`;
+  const redeploy = `\`${base}\` (or \`${base} --keep-data --reset\`) \u2014 a replace, which applies the env set it resolves and also replaces the rows with the seed rows; a \`--keep-data\` deploy without \`--reset\` keeps the live value.`;
+  return verb === "set" ? `Put the value in \`${envFile}\`, or pass \`--env-var ${name}=...\`, and redeploy with ${redeploy}` : `Remove ${name} from \`${envFile}\` (and from \`workspaceConfig({ env })\` if it is declared there) and redeploy with ${redeploy}`;
+}
+async function landedEntry(destination, cwd) {
+  const { readEphemeralState } = await import("./ephemeral-state-PYCBSOGX.js");
+  const { resolveProjectEntry } = await import("./deploy-source-3W45CXMP.js");
+  if (destination.kind === "ephemeral" && destination.name !== void 0) {
+    const entry = Object.values(readEphemeralState(cwd).environments).find((r) => r.name === destination.name)?.entry;
+    if (entry !== void 0 && existsSync(resolve(cwd, entry))) return { entry, recorded: true };
+  }
+  return { entry: resolveProjectEntry(cwd), recorded: false };
+}
+var NOT_SENT_AFTERMATH = "Nothing was sent \u2014 retry.";
+async function notSentAftermath(verb, name, args) {
+  const { command, value, withheld } = await notSentRerun(verb, name, args);
+  return `Nothing was sent, so nothing changed \u2014 once it is reachable, run \`${command}\` again${value}.${withheld}`;
+}
+async function notSentRerun(verb, name, args) {
+  let command;
+  let withheld = "";
+  if (args.argv !== void 0) {
+    const { withoutSecretValue } = await import("./cli.js");
+    const { retryCommand, withheldNote } = await import("./deploy-command-JVZPWHMK.js");
+    const retry = retryCommand(verb === "set" ? withoutSecretValue(args) : args);
+    command = retry.command;
+    withheld = withheldNote(retry.withheld);
+  } else {
+    const to = args.to !== void 0 ? ` --to ${shellQuote(args.to)}` : "";
+    command = `xanosdk env ${verb} ${shellQuote(name)}${to}${contextFlags(args)}${args.yes === true ? " --yes" : ""}`;
+  }
+  const value = verb === "set" ? " with its value (not repeated here \u2014 pass it again, or pipe it on stdin)" : "";
+  return { command, value, withheld };
+}
+function lostAnswerAftermath(verb, name, args) {
+  const to = args.to !== void 0 ? ` --to ${shellQuote(args.to)}` : "";
+  const flags = contextFlags(args);
+  const yes = args.yes === true ? " --yes" : "";
+  const again = verb === "set" ? `re-run the same \`xanosdk env set ${shellQuote(name)}${to}${flags}${yes}\` command, with its value (not repeated here)` : `re-run \`xanosdk env unset ${shellQuote(name)}${to}${flags}${yes}\``;
+  return `The request was sent, so it may or may not have taken effect. ${verb === "set" ? "Setting" : "Clearing"} a name is safe to repeat: ${again} and it settles it either way \u2014 or see what the backend holds with \`xanosdk env pull${to === "" ? "" : ` --from ${shellQuote(args.to)}`}${flags}\`.`;
+}
+function outcomeLine(name, action, label) {
+  switch (action) {
+    case "created":
+      return `Created ${name} on ${label}.`;
+    case "updated":
+      return `Replaced the value of ${name} on ${label}.`;
+    case "deleted":
+      return `Cleared ${name} on ${label}.`;
+    case "absent":
+      return `${name} was not set on ${label} \u2014 nothing to clear.`;
+  }
+}
+async function readValue(args, name, help, opts) {
+  let value = args.positionals[1];
+  if (value === void 0) {
+    const piped = await (opts.readStdin ?? readStdin)();
+    if (piped === void 0) {
+      throw new UsageError(
+        `\`xanosdk env set ${name}\` needs a value: pass it as the second argument, or pipe it on stdin (\`printf %s "$VALUE" | xanosdk env set ${name}${sameDestination(args)}\`) to keep it out of shell history.`,
+        { helpFor: help }
+      );
+    }
+    value = piped.replace(/\r?\n$/, "");
+  }
+  if (value === "" && !args.allowEmptyEnv.includes(name)) {
+    throw new UsageError(
+      `The value for ${name} is empty \u2014 usually an unset shell variable rather than an intent. To store an empty value, re-run with \`--allow-empty-env=${name}\`; to remove the variable, use \`xanosdk env unset ${name}${sameDestination(args)}\`.`
+    );
+  }
+  return value;
+}
+function sameDestination(args) {
+  const to = args.to === void 0 ? "" : ` --to ${shellQuote(args.to)}`;
+  return args.to !== void 0 && /^local-engine\b/.test(args.to) ? to : `${to}${contextFlags(args)}`;
+}
+async function resolveDestination(args, verb, deps) {
+  const slot = requireBackendSlot("env", verb, "to");
+  const cwd = deps?.cwd ?? process.cwd();
+  const credential = memoCredential(() => getAccessToken(args));
+  const source = await selectBackend(slot, args.to, { credential, deps: { ...deps, cwd } });
+  if (source.kind === "file") {
+    throw new Error("Internal: `env` resolved a bundle file as a write destination.");
+  }
+  refuseProfileForLocal(args.profile, [source.kind], slot);
+  const resolved = await resolveSource(source, credential, { ...deps, cwd, workspaceless: "write" });
+  const { base, workspaceId } = resolved.target;
+  const real = isRealDeployment(actualKind(resolved));
+  if (resolved.backend.kind === "local") {
+    const disclosure = { kind: "local-engine", url: resolved.backend.engine.url, workspaceId };
+    return {
+      kind: resolved.kind,
+      auth: resolved.bearer,
+      baseUrl: base,
+      workspaceId,
+      label: describeBackend(resolved),
+      disclosure,
+      real,
+      // `kind` for every kind: the local payload's `local: true` answers "is
+      // this hosted", a different question from which kind received the write.
+      receipt: { kind: "local-engine", ...writeTargetPayload(disclosure) }
+    };
+  }
+  const kind = actualKind(resolved);
+  const parent = kind === "workspace" ? void 0 : await credential();
+  const receipt = parent === void 0 || kind === "workspace" ? { kind, ...writeTargetPayload({ base, workspaceId, kind }) } : backendDestinationPayload(parent, {
+    kind,
+    name: resolved.target.label,
+    url: base,
+    // Only when it says something the name does not.
+    ...resolved.target.display !== void 0 && resolved.target.display !== resolved.target.label ? { display: resolved.target.display } : {}
+  });
+  return {
+    receipt,
+    kind,
+    auth: resolved.bearer,
+    baseUrl: base,
+    workspaceId,
+    label: describeBackend(resolved),
+    // No label, for any kind: the line before it (the confirmation's "will be
+    // set on …" or the outcome line) already names the backend, display name
+    // and all — the one location-line format `publish` and `deploy` print.
+    // An ephemeral or tenant by the workspace it lives under, as the receipt
+    // names it: its own internal workspace is always #1 (E2E pass 36).
+    disclosure: { base, workspaceId: parent?.workspaceId ?? workspaceId, kind },
+    real,
+    name: resolved.target.label,
+    binding: resolved.backend.binding
+  };
+}
+export {
+  lostAnswerAftermath,
+  notSentAftermath,
+  runEnvVarCommand
+};
+//# sourceMappingURL=env-var-command-ZIRDCAZA.js.map

package/dist/ephemeral-P7F3PMAD.js

@@ -0,0 +1,54 @@
+import {
+  NotAnEphemeralError,
+  createEphemeral,
+  deleteEphemeral,
+  expiresAtMs,
+  getEphemeral,
+  impersonateEphemeral,
+  isEphemeralDisabled,
+  isExpired,
+  isUnansweredPoll,
+  listAllEphemeral,
+  listEphemeral,
+  namedEphemeral,
+  projectTenant,
+  renameEphemeral,
+  tenantBaseUrl,
+  waitUntilReady
+} from "./chunk-7G3CTU7I.js";
+import "./chunk-6PBR37LN.js";
+import "./chunk-NAQDMEHV.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-5ZSO4T2G.js";
+import "./chunk-TFFGOFVZ.js";
+import "./chunk-36JUQZVQ.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  NotAnEphemeralError,
+  createEphemeral,
+  deleteEphemeral,
+  expiresAtMs,
+  getEphemeral,
+  impersonateEphemeral,
+  isEphemeralDisabled,
+  isExpired,
+  isUnansweredPoll,
+  listAllEphemeral,
+  listEphemeral,
+  namedEphemeral,
+  projectTenant,
+  renameEphemeral,
+  tenantBaseUrl,
+  waitUntilReady
+};
+//# sourceMappingURL=ephemeral-P7F3PMAD.js.map