@xano/sdk 1.0.0

package/dist/login-command-QPYRWOXZ.js

@@ -0,0 +1,538 @@
+import {
+  revocableRecord,
+  revokeProfileSession,
+  warnRevokeFailed
+} from "./chunk-ELP2HMXC.js";
+import {
+  loopbackRedirectUri,
+  openBrowser,
+  startCallbackServer
+} from "./chunk-FQOF7E2E.js";
+import {
+  promptLine
+} from "./chunk-65HWOMGV.js";
+import {
+  ensureGitignoredOrWarn
+} from "./chunk-YHEFQUQB.js";
+import "./chunk-DAD3ONIS.js";
+import {
+  describeRefreshAnswer,
+  environmentCredentialVars
+} from "./chunk-ET4Y4XCB.js";
+import "./chunk-5QU2P5CA.js";
+import "./chunk-ZYJP6BOO.js";
+import "./chunk-QO6BVGS5.js";
+import "./chunk-JZGVVJSI.js";
+import "./chunk-T5KELPAR.js";
+import "./chunk-622HUCZT.js";
+import "./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 "./chunk-4KHEMC32.js";
+import "./chunk-ROY4YAEQ.js";
+import "./chunk-TLQE7ZN3.js";
+import "./chunk-WRBKLYSJ.js";
+import "./chunk-3LDULPRE.js";
+import {
+  CALLBACK_PATH,
+  DEFAULT_PORT,
+  OpenIdProvider,
+  assertCredentialFileWritable,
+  assertSignInOrigin,
+  credentialFileFlag,
+  decodeAudience,
+  envOrigin,
+  globalAuthFilePath,
+  loginCommand,
+  oauthErrorCode,
+  oauthErrorResponse,
+  profileNames,
+  readCredentialFile,
+  readProfile,
+  resolveAuthFilePath,
+  resolveAuthHost,
+  resolveOAuthErrorCode,
+  resolveScope,
+  withCredentialLock,
+  writeCredentialFile
+} from "./chunk-XW6KISBB.js";
+import "./chunk-AWQ7BQTQ.js";
+import "./chunk-EUUUMY7J.js";
+import {
+  describeTransportFailure,
+  isTimeoutError
+} from "./chunk-YLDALTWZ.js";
+import {
+  resolveProjectProfile
+} from "./chunk-5FBYXK5P.js";
+import "./chunk-LLNZGEFK.js";
+import {
+  resolveActiveProfile
+} from "./chunk-QXTKSOFI.js";
+import {
+  envFlagSet
+} from "./chunk-X2NL4KUO.js";
+import "./chunk-UCQ2VUTG.js";
+import "./chunk-DGWHAVRG.js";
+import {
+  UsageError,
+  blank,
+  detail,
+  hostLabel,
+  info,
+  isMachineOutput,
+  step,
+  success,
+  warn,
+  writeJson
+} from "./chunk-PTHVMXZI.js";
+import "./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/login-command.ts
+import { homedir } from "os";
+import { dirname, join } from "path";
+import * as client from "openid-client";
+
+// src/auth/paste.ts
+var EXAMPLE = "Paste either the full URL from your browser's address bar (http://127.0.0.1:\u2026/oauth/callback?code=\u2026) or just the code=\u2026 value from it.";
+function normalizePastedCallback(input, ctx) {
+  const trimmed = input.trim();
+  if (trimmed === "") throw new Error(`Nothing was pasted. ${EXAMPLE}`);
+  const params = extractParams(trimmed, ctx);
+  const error = params.get("error");
+  if (error) {
+    const description = params.get("error_description");
+    const authError = new Error(
+      `Authorization server returned error: ${error}${description ? ` (${description})` : ""}`
+    );
+    authError.error = error;
+    throw authError;
+  }
+  if (!params.get("code")) {
+    throw new Error(`That paste carries no \`code\` value. ${EXAMPLE}`);
+  }
+  for (const key of ["code", "state", "iss"]) {
+    if (params.getAll(key).length > 1) {
+      throw new Error(`That paste carries \`${key}\` more than once, so it is not one redirect. ${EXAMPLE}`);
+    }
+  }
+  const state = params.get("state");
+  if (state && state !== ctx.state) {
+    throw new Error(
+      "That URL is from a different sign-in attempt \u2014 its `state` does not match this one. Finish signing in with the link printed above and paste the URL that one lands on."
+    );
+  }
+  const iss = params.get("iss");
+  if (iss && iss !== ctx.issuer) {
+    throw new Error(
+      `That URL was issued by ${iss}, not by ${ctx.issuer}, which this sign-in is talking to. Finish signing in with the link printed above and paste the URL that one lands on.`
+    );
+  }
+  if (!state) params.set("state", ctx.state);
+  if (!iss) params.set("iss", ctx.issuer);
+  return `${ctx.redirectUri}?${params.toString()}`;
+}
+function extractParams(trimmed, ctx) {
+  const url = parseUrl(trimmed);
+  if (url) return url.searchParams;
+  const queryStart = trimmed.indexOf("?");
+  if (queryStart !== -1 && isRecognizedQuery(trimmed.slice(queryStart + 1))) {
+    return new URLSearchParams(trimmed.slice(queryStart + 1));
+  }
+  if (isRecognizedQuery(trimmed)) return new URLSearchParams(trimmed);
+  return new URLSearchParams({ code: trimmed, state: ctx.state, iss: ctx.issuer });
+}
+function isRecognizedQuery(value) {
+  return /(^|&)(code|error)=/.test(value);
+}
+function parseUrl(value) {
+  try {
+    const url = new URL(value);
+    return url.protocol === "http:" || url.protocol === "https:" ? url : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/emit/login-command.ts
+async function runLoginCommand(args) {
+  const authHost = resolveAuthHost(args);
+  const scope = resolveScope(args);
+  const port = args.port ?? DEFAULT_PORT;
+  try {
+    assertSignInOrigin(authHost, args.authHost === void 0 && envOrigin() !== void 0 ? "XANO_ORIGIN" : "--origin");
+  } catch (err) {
+    throw new UsageError(err instanceof Error ? err.message : String(err), { hintFor: { command: "login" } });
+  }
+  if (args.paste && port === 0) {
+    throw new UsageError(
+      "`--port 0` asks for an ephemeral port, which --paste cannot use: nothing is bound, so the port is only part of the redirect URL's identity. Drop --port to use the default.",
+      { hintFor: { command: "login" } }
+    );
+  }
+  const targetPath = resolveAuthFilePath(args, "write");
+  const profile = resolveLoginProfile(args, targetPath);
+  assertCredentialFileWritable(targetPath);
+  if (!args.force && reportAlreadySignedIn(args, targetPath, profile)) return;
+  if (args.paste && process.stdin.isTTY !== true) {
+    throw new UsageError(
+      `\`--paste\` reads the authorization code back from you, so it needs a terminal. For automation, set XANO_INSTANCE_URL / XANO_WORKSPACE_ID / XANO_META_TOKEN, or store a meta API token with \`xanosdk profile add ${args.profile !== void 0 ? shellQuote(profile) : "<name>"}${credentialFileFlag(targetPath)} --instance <url> --workspace-id <id>\`.`,
+      { hintFor: { command: "login" } }
+    );
+  }
+  step(`Signing in to ${hostLabel(authHost)}`);
+  const again = loginCommand(profile, { path: targetPath, origin: authHost }, [
+    ...args.paste ? ["--paste"] : [],
+    ...args.port !== void 0 ? [`--port ${args.port}`] : [],
+    ...args.force ? ["--force"] : []
+  ]);
+  let record;
+  try {
+    record = await attemptLogin({ authHost, scope, port, paste: args.paste, again, profile });
+  } catch (err) {
+    if (oauthErrorCode(err) !== "invalid_client") throw err;
+    warn("The registered client was rejected \u2014 re-registering and retrying once.", "login.client-reregistered");
+    record = await attemptLogin({ authHost, scope, port, paste: args.paste, again, profile, retry: true });
+  }
+  const authFilePath = targetPath;
+  let becameDefault = false;
+  let isDefault = false;
+  let replaced;
+  try {
+    await withCredentialLock(authFilePath, (file) => {
+      replaced = revocableRecord(file, profile, authFilePath);
+      becameDefault = profileNames(file).length === 0;
+      file.profiles[profile] = record;
+      if (becameDefault) file.default = profile;
+      isDefault = file.default === profile;
+      writeCredentialFile(authFilePath, file);
+    });
+  } catch (err) {
+    await revokeProfileSession(args, record, profile, "minted");
+    throw err;
+  }
+  if (replaced !== void 0 && replaced.refresh_token !== record.refresh_token) {
+    step(`Revoking the session that profile "${profile}" held\u2026`);
+    await revokeProfileSession(args, replaced, profile, "replace");
+  }
+  blank();
+  success(`Signed in to ${hostLabel(record.instance)} as profile "${profile}"`);
+  detail(`Workspace ${record.workspace_id} (pinned \u2014 every command acts on this one)`);
+  detail(`Credentials saved to ${authFilePath}`);
+  const machineFile = authFilePath === globalAuthFilePath();
+  const defaultOf = machineFile ? "this machine's default" : `the default profile in ${authFilePath}`;
+  if (becameDefault) {
+    detail(machineFile ? `It is this machine's default profile.` : `It is ${defaultOf}.`);
+  } else if (isDefault) {
+    detail(machineFile ? `It is still this machine's default profile.` : `It is still ${defaultOf}.`);
+  } else {
+    const fileFlag = credentialFileFlag(authFilePath);
+    info(
+      `"${profile}" is not ${defaultOf} \u2014 select it with \`--profile ${profile}${fileFlag}\`, or pin this project to it with \`xanosdk profile use ${profile}${fileFlag}\`.`
+    );
+  }
+  const env = environmentCredentialVars();
+  if (env.vars.length > 0) {
+    const them = env.vars.length === 1 ? "it" : "them";
+    warn(
+      `${env.vars.join(", ")} ${env.vars.length === 1 ? "is" : "are"} set in this environment, outranking this credential \u2014 ` + (env.complete ? `commands will keep using ${them}. ` : `it is an incomplete credential, so commands will fail on ${them} rather than use this one. `) + `Unset ${them} to act as the account you just signed in as.`,
+      "credential.env-outranks"
+    );
+  }
+  if (machineFile) {
+    const shared = authFilePath === join(homedir(), ".xanosdk", "auth.json") ? "~/.xanosdk" : dirname(authFilePath);
+    detail(`Using the shared ${shared} cache \u2014 available from any project directory.`);
+  } else if (args.local) {
+    const root = dirname(dirname(authFilePath));
+    detail(
+      root === process.cwd() ? "Using the project-local .xano cache \u2014 scoped to this project." : `Using the project-local .xano cache at the project root ${root} \u2014 scoped to this project, and read from any directory in it.`
+    );
+  }
+  const gitignored = ensureGitignoredOrWarn(authFilePath);
+  if (!record.refresh_token) {
+    warn(
+      "No refresh token was issued (offline_access not granted); push will require re-login once the access token expires.",
+      "login.no-refresh-token"
+    );
+  }
+  if (isMachineOutput(args)) {
+    writeLoginDocument({
+      profile,
+      path: authFilePath,
+      signedIn: true,
+      changed: true,
+      gitignored,
+      instance: record.instance,
+      workspaceId: record.workspace_id,
+      credential: "oauth",
+      isDefault
+    });
+  }
+}
+function resolveLoginProfile(args, authFilePath) {
+  let fileDefault;
+  try {
+    fileDefault = readCredentialFile(authFilePath)?.default;
+  } catch {
+  }
+  return resolveActiveProfile({
+    flag: args.profile,
+    fileDefault,
+    readPointer: () => resolveProjectProfile(process.cwd())
+  }).name;
+}
+function reportAlreadySignedIn(args, authFilePath, profile) {
+  let existing;
+  let isDefault = false;
+  try {
+    const file = readCredentialFile(authFilePath);
+    existing = file === null ? null : readProfile(file, profile, authFilePath);
+    isDefault = file?.default === profile;
+  } catch {
+    return false;
+  }
+  if (!existing) return false;
+  if (existing.type === "oauth" && !existing.refresh_token && Date.now() >= existing.expires_at) return false;
+  const target = existing.type === "token" ? `${hostLabel(existing.instance_base_url)} with a meta API token profile (from \`profile add\`)` : hostLabel(existing.instance);
+  info(`Profile "${profile}" is already signed in to ${target}, workspace ${existing.workspace_id}.`);
+  detail(`Credential: ${authFilePath}`);
+  const asked = args.authHost === void 0 ? void 0 : originOf(resolveAuthHost(args));
+  const stored = existing.type === "oauth" ? originOf(existing.auth_host) : void 0;
+  const origin = asked === void 0 ? "" : ` --origin ${shellQuote(asked)}`;
+  const forced = `xanosdk login --profile ${shellQuote(profile)}${credentialFileFlag(authFilePath)}${origin} --force`;
+  const hint = asked !== void 0 && asked !== stored ? `\`--origin ${asked}\` was not used: this profile signed in through ${stored ?? "a meta API token, with no sign-in server"}. Run \`${forced}\` to sign in through ${asked} and replace it.` : existing.type === "token" ? (
+    // `login --force` would REPLACE a token profile with an OAuth sign-in;
+    // refreshing its token is `profile add --force`, which keeps the kind.
+    `To replace its meta API token, run \`xanosdk profile add ${shellQuote(profile)}${credentialFileFlag(authFilePath)} --instance ${existing.instance_base_url} --workspace-id ${existing.workspace_id} --force\` (\`${forced}\` would replace it with an OAuth sign-in instead).`
+  ) : `Run \`${forced}\` to sign in again.`;
+  detail(hint);
+  const gitignored = ensureGitignoredOrWarn(authFilePath);
+  if (isMachineOutput(args)) {
+    writeLoginDocument({
+      profile,
+      path: authFilePath,
+      signedIn: true,
+      changed: false,
+      gitignored,
+      isDefault,
+      instance: existing.type === "token" ? existing.instance_base_url : existing.instance,
+      workspaceId: existing.workspace_id,
+      credential: existing.type,
+      hint
+    });
+  }
+  return true;
+}
+function originOf(url) {
+  try {
+    return new URL(url).origin;
+  } catch {
+    return url;
+  }
+}
+function writeLoginDocument(doc) {
+  const { hint, ...rest } = doc;
+  writeJson({ verb: "login", ...rest, ...doc.changed ? {} : { hint: hint ?? "Re-run with --force to sign in again." } });
+}
+async function attemptLogin(p) {
+  const verifier = client.randomPKCECodeVerifier();
+  const state = client.randomState();
+  const { callbackUrl, provider } = p.paste ? await acquireByPaste({ ...p, verifier, state }) : await acquireByLoopback({ ...p, verifier, state });
+  let tokens;
+  try {
+    tokens = await provider.exchange(callbackUrl, { verifier, state });
+  } catch (err) {
+    if (oauthErrorCode(err) === "invalid_client") {
+      await provider.reset();
+      throw err;
+    }
+    throw await explainRefusedCode(err, p.again) ?? explainRejectedResponse(err, p.paste, p.again);
+  }
+  const boundInstance = decodeAudience(tokens.access_token);
+  if (!boundInstance) {
+    await revokeMinted(provider, tokens.refresh_token, p.authHost, p.profile);
+    throw new Error(
+      `Could not determine the instance from the issued token (no readable \`aud\` claim). This is unexpected \u2014 please report it.`
+    );
+  }
+  const { resolveScopedWorkspaceId } = await import("./workspace-2CLHU2LK.js");
+  detail("Resolving the workspace this token is scoped to\u2026");
+  let workspaceId;
+  try {
+    workspaceId = await resolveScopedWorkspaceId(
+      { access_token: tokens.access_token, instance: boundInstance },
+      { again: p.again }
+    );
+  } catch (err) {
+    await revokeMinted(provider, tokens.refresh_token, p.authHost, p.profile);
+    throw err;
+  }
+  return {
+    type: "oauth",
+    access_token: tokens.access_token,
+    refresh_token: tokens.refresh_token,
+    expires_at: Date.now() + (tokens.expires_in ?? 0) * 1e3,
+    scope: tokens.scope ?? p.scope,
+    instance: boundInstance,
+    workspace_id: workspaceId,
+    auth_host: p.authHost,
+    // Record exactly which client minted the token — required to refresh/revoke
+    // it later. Resolved already (buildAuthUrl awaited the config).
+    client_id: provider.clientId()
+  };
+}
+async function revokeMinted(provider, refreshToken, authHost, profile) {
+  if (refreshToken === void 0) return;
+  try {
+    await provider.revoke(refreshToken);
+  } catch (err) {
+    await warnRevokeFailed(`the session this sign-in minted for profile "${profile}"`, authHost, err, "minted");
+  }
+}
+function explainRejectedResponse(err, paste, again) {
+  if (err?.code !== "OAUTH_INVALID_RESPONSE") return err;
+  const cause = err.cause;
+  const reason = cause instanceof Error ? cause.message : typeof cause === "string" ? cause : void 0;
+  return new Error(
+    `The sign-in response was rejected${reason === void 0 ? "" : `: ${reason}`}. ` + (paste ? "Paste the full URL your browser lands on after finishing THIS sign-in (or just its code=\u2026 value). " : "") + `Run \`${again}\` again to start over.`,
+    { cause: err }
+  );
+}
+async function explainRefusedCode(err, command) {
+  const res = oauthErrorResponse(err);
+  const code = await resolveOAuthErrorCode(err);
+  const again = `run \`${command}\` again`;
+  if (res === void 0 && code === void 0) {
+    if (!isTransportFailure(err)) return void 0;
+    return new Error(
+      `Sign-in failed: could not reach the authorization server to exchange the code (${describeTransportFailure(err)}). This is a network error, not an auth problem \u2014 ${again}.`,
+      { cause: err }
+    );
+  }
+  if (code === void 0 && res !== void 0 && res.status >= 500) {
+    const answer = await describeRefreshAnswer(err) ?? `HTTP ${res.status}`;
+    return new Error(
+      `Sign-in failed while exchanging the code: the authorization server answered ${answer}. This is a server-side error, not an auth problem \u2014 ${again}. If it persists, the sign-in server is having trouble.`,
+      { cause: err }
+    );
+  }
+  const why = [res === void 0 ? void 0 : `HTTP ${res.status}`, code].filter((p) => p !== void 0);
+  return new Error(
+    `The authorization server refused the sign-in code${why.length === 0 ? "" : ` (${why.join(" \u2014 ")})`}. A code is single-use and expires within minutes, so one that was already used, has expired, or belongs to another sign-in is refused. Run \`${command}\` again for a fresh one.`,
+    { cause: err }
+  );
+}
+function isTransportFailure(err) {
+  if (isTimeoutError(err)) return true;
+  return err instanceof TypeError && /fetch failed/i.test(err.message);
+}
+var MAX_PASTE_ATTEMPTS = 3;
+async function acquireByLoopback(p) {
+  let listener;
+  try {
+    listener = await startCallbackServer({ callbackPath: CALLBACK_PATH, expectedState: p.state, port: p.port });
+  } catch (err) {
+    throw loopbackListenRefusal(err, p.port);
+  }
+  const provider = new OpenIdProvider({ authHost: p.authHost, redirectUri: listener.redirectUri, scope: p.scope });
+  let authorizeUrl;
+  try {
+    authorizeUrl = await provider.buildAuthUrl({ verifier: p.verifier, state: p.state });
+  } catch (err) {
+    listener.close();
+    throw err;
+  }
+  if (envFlagSet("XANO_NO_BROWSER")) {
+    detail("Open this URL in your browser to authorize \u2014 waiting for you to finish:");
+  } else {
+    detail("Opening your browser to authorize \u2014 waiting for you to finish\u2026");
+    detail("If it doesn't open, paste this URL into your browser:");
+  }
+  detail(authorizeUrl);
+  openBrowser(authorizeUrl);
+  try {
+    const { callbackUrl } = await listener.waitForCallback;
+    return { callbackUrl, provider };
+  } catch (err) {
+    listener.close();
+    if (oauthErrorCode(err) === "invalid_client") await provider.reset();
+    throw err;
+  }
+}
+function loopbackListenRefusal(err, port) {
+  const code = err?.code;
+  const fix = `Pass another with \`--port <n>\`, or drop \`--port\` for the default ${DEFAULT_PORT}.`;
+  const hint = { hintFor: { command: "login" } };
+  if (code === "EADDRINUSE") {
+    return new UsageError(`Loopback port ${port} is in use. ${fix}`, hint);
+  }
+  if (code === "EACCES") {
+    return new UsageError(
+      `Loopback port ${port} needs elevated privileges to listen on (EACCES) \u2014 ports below 1024 usually do. Pass one of 1024 or above with \`--port <n>\`, or drop \`--port\` for the default ${DEFAULT_PORT}.`,
+      hint
+    );
+  }
+  const why = err instanceof Error ? err.message : String(err);
+  return new UsageError(`Could not listen on loopback port ${port} (${why}). ${fix}`, hint);
+}
+async function acquireByPaste(p) {
+  const redirectUri = loopbackRedirectUri(p.port, CALLBACK_PATH);
+  const provider = new OpenIdProvider({ authHost: p.authHost, redirectUri, scope: p.scope });
+  const authorizeUrl = await provider.buildAuthUrl({ verifier: p.verifier, state: p.state });
+  blank();
+  if (p.retry) detail("Starting over with a freshly registered client \u2014 this is a NEW link and a NEW code.");
+  detail("Open this URL in any browser and finish signing in:");
+  detail(authorizeUrl);
+  blank();
+  detail(
+    `Your browser will then fail to load ${redirectUri} \u2014 that is expected, nothing is listening here. The address bar is what you want.`
+  );
+  openBrowser(authorizeUrl);
+  for (let attempt = 0; ; attempt++) {
+    const pasted = await promptLine("Paste that URL (or just the code from it):", {
+      noTtyHint: "--paste has to read the code from you, so it needs a terminal. For automation, set XANO_INSTANCE_URL / XANO_WORKSPACE_ID / XANO_META_TOKEN, or store a meta API token with `xanosdk profile add <name>`."
+    });
+    try {
+      const callbackUrl = normalizePastedCallback(pasted, {
+        redirectUri,
+        state: p.state,
+        issuer: provider.issuer()
+      });
+      return { callbackUrl, provider };
+    } catch (err) {
+      if (oauthErrorCode(err) === "invalid_client") await provider.reset();
+      const unreadable = oauthErrorCode(err) === void 0;
+      if (!unreadable || attempt + 1 >= MAX_PASTE_ATTEMPTS) throw err;
+      warn(
+        `${err instanceof Error ? err.message : String(err)}`,
+        "login.paste-failed",
+        ["The link above is still valid \u2014 try pasting again."]
+      );
+    }
+  }
+}
+export {
+  loopbackListenRefusal,
+  runLoginCommand
+};
+//# sourceMappingURL=login-command-QPYRWOXZ.js.map

package/dist/logout-command-WOIQLDP6.js

@@ -0,0 +1,56 @@
+import {
+  combineRevokes,
+  confirmDanglingRemoval,
+  revocableRecord,
+  revokeFields,
+  revokeProfileSession,
+  runLogoutCommand,
+  salvageRevocable,
+  signInAgain,
+  warnRevokeFailed
+} from "./chunk-ELP2HMXC.js";
+import "./chunk-65HWOMGV.js";
+import "./chunk-ET4Y4XCB.js";
+import "./chunk-5QU2P5CA.js";
+import "./chunk-ZYJP6BOO.js";
+import "./chunk-QO6BVGS5.js";
+import "./chunk-JZGVVJSI.js";
+import "./chunk-T5KELPAR.js";
+import "./chunk-622HUCZT.js";
+import "./chunk-NAQDMEHV.js";
+import "./chunk-FWD7AL6N.js";
+import "./chunk-4KHEMC32.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 {
+  combineRevokes,
+  confirmDanglingRemoval,
+  revocableRecord,
+  revokeFields,
+  revokeProfileSession,
+  runLogoutCommand,
+  salvageRevocable,
+  signInAgain,
+  warnRevokeFailed
+};
+//# sourceMappingURL=logout-command-WOIQLDP6.js.map