@xano/sdk 1.0.0

package/dist/status-command-RUDXTF7I.js

@@ -0,0 +1,554 @@
+import {
+  profileValue,
+  rejectedFixCommand,
+  rejectedRemedy,
+  signedInValue,
+  workspaceValue
+} from "./chunk-UVHDMMIP.js";
+import {
+  reachableInline,
+  reachableWorkspaces
+} from "./chunk-KTSDSD36.js";
+import {
+  readTrackedBackend
+} from "./chunk-HHN734BU.js";
+import {
+  readDeployed
+} from "./chunk-LPECSJ2J.js";
+import {
+  isProjectDir,
+  projectDirFrom
+} from "./chunk-6NNTNXN7.js";
+import {
+  LookupFailedError,
+  lookupEphemeral
+} from "./chunk-QCNYHBL7.js";
+import "./chunk-2ZUEE4EK.js";
+import "./chunk-AN6BL47T.js";
+import {
+  NotSignedInError,
+  StoredCredentialError,
+  getAccessToken
+} from "./chunk-ET4Y4XCB.js";
+import "./chunk-SWBF2LTK.js";
+import "./chunk-UZ6QQWJT.js";
+import "./chunk-A3UDOZB6.js";
+import "./chunk-2MNLRIOX.js";
+import {
+  getEngineRecord
+} from "./chunk-3M4LFYNQ.js";
+import {
+  isLoopbackUrl
+} from "./chunk-AM4FKL4J.js";
+import "./chunk-STSFNCY4.js";
+import {
+  environmentKey,
+  getEnvironment,
+  readEphemeralState,
+  unreadableEphemeralState
+} from "./chunk-5QU2P5CA.js";
+import "./chunk-ZYJP6BOO.js";
+import "./chunk-QO6BVGS5.js";
+import "./chunk-JZGVVJSI.js";
+import {
+  isExpired
+} from "./chunk-7G3CTU7I.js";
+import "./chunk-6PBR37LN.js";
+import {
+  retryCommand
+} from "./chunk-T5KELPAR.js";
+import "./chunk-622HUCZT.js";
+import {
+  ENV_CREDENTIAL_VARS,
+  credentialFileFlagFor,
+  credentialFileOf,
+  recordedByEnvCredential
+} 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 "./chunk-4KHEMC32.js";
+import "./chunk-ROY4YAEQ.js";
+import "./chunk-TLQE7ZN3.js";
+import "./chunk-WRBKLYSJ.js";
+import "./chunk-3LDULPRE.js";
+import {
+  loginCommand,
+  profileAddCommand,
+  recordedCredentialPath,
+  recordedProfileStored
+} from "./chunk-XW6KISBB.js";
+import "./chunk-AWQ7BQTQ.js";
+import "./chunk-EUUUMY7J.js";
+import {
+  fetchOrExplain,
+  httpFailure,
+  parseJsonAnswer
+} from "./chunk-YLDALTWZ.js";
+import "./chunk-5FBYXK5P.js";
+import "./chunk-LLNZGEFK.js";
+import {
+  selectionDocument
+} from "./chunk-QXTKSOFI.js";
+import "./chunk-X2NL4KUO.js";
+import "./chunk-UCQ2VUTG.js";
+import "./chunk-DGWHAVRG.js";
+import {
+  CliError,
+  EXIT_SOURCE_UNRESOLVABLE,
+  displayPath,
+  formatExpiration,
+  formatFields,
+  isMachineOutput,
+  isUsageError,
+  printHuman,
+  stdoutStyle,
+  writeJson
+} from "./chunk-PTHVMXZI.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/status-command.ts
+var TIMEOUT_MS = 3e4;
+function asString(v) {
+  return typeof v === "string" && v !== "" ? v : void 0;
+}
+var NETWORK_HINT = "A connection failure here is usually blocked egress, not a bad credential \u2014 check network access to the instance before running `xanosdk login`, which rotates a single-use refresh token.";
+var StatusReadError = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+  }
+  status;
+};
+async function getJson(url, auth, action) {
+  let res;
+  try {
+    res = await fetchOrExplain(
+      url,
+      {
+        headers: { accept: "application/json", Authorization: `Bearer ${auth.access_token}` },
+        signal: AbortSignal.timeout(TIMEOUT_MS)
+      },
+      action,
+      TIMEOUT_MS
+    );
+  } catch (err) {
+    throw new Error(`${err instanceof Error ? err.message : String(err)}
+${NETWORK_HINT}`, { cause: err });
+  }
+  const text = await res.text();
+  if (!res.ok) throw new StatusReadError(httpFailure(action, res, text), res.status);
+  return parseJsonAnswer(text, action, url);
+}
+async function readWorkspace(auth) {
+  const list = await getJson(`${auth.instance}/api:meta/workspace`, auth, "status (workspace list)");
+  const all = Array.isArray(list) ? list : [];
+  const match = all.find((w) => w.id === auth.workspaceId);
+  if (match === void 0) {
+    return {
+      id: auth.workspaceId,
+      name: null,
+      credential: auth.credentialType,
+      note: `this credential cannot see workspace ${auth.workspaceId}` + (reachableWorkspaces(all).length > 0 ? ` \u2014 the ids it can: ${reachableInline(reachableWorkspaces(all))}` : "")
+    };
+  }
+  return {
+    id: auth.workspaceId,
+    name: asString(match.name) ?? null,
+    credential: auth.credentialType
+  };
+}
+async function readEnvironment(auth, cwd) {
+  const tracked = getEnvironment(readEphemeralState(cwd), auth);
+  if (tracked === void 0) return null;
+  let summary;
+  try {
+    summary = await lookupEphemeral(auth, tracked.name);
+  } catch (err) {
+    if (!(err instanceof LookupFailedError)) throw err;
+    return {
+      name: tracked.name,
+      display: tracked.display,
+      url: tracked.url,
+      state: null,
+      expiresAt: tracked.expires_at,
+      alive: null,
+      note: err.head
+    };
+  }
+  if (summary === null) {
+    return {
+      name: tracked.name,
+      display: tracked.display,
+      url: tracked.url,
+      state: null,
+      expiresAt: tracked.expires_at,
+      alive: false
+    };
+  }
+  return {
+    name: summary.name,
+    display: summary.display,
+    url: summary.url,
+    state: summary.state ?? null,
+    expiresAt: summary.expiresAt,
+    alive: !isExpired(summary.expiresAt)
+  };
+}
+async function readLocalEngine(cwd, deps) {
+  const env = deps.env ?? process.env;
+  const record = getEngineRecord(cwd, env);
+  if (record === void 0) return null;
+  let running;
+  try {
+    running = await (deps.listEngines ?? defaultEnumeration(env, cwd))();
+  } catch {
+    running = void 0;
+  }
+  if (running === void 0) return { name: record.name, url: record.url, liveness: "unknown" };
+  const engine = running.find((e) => e.name === record.name);
+  if (engine === void 0) return { name: record.name, url: record.url, liveness: "not-running" };
+  if (!isLoopbackUrl(engine.url)) return { name: record.name, url: engine.url, liveness: "unreachable" };
+  return { name: record.name, url: engine.url, liveness: "live" };
+}
+function defaultEnumeration(env, cwd) {
+  return async () => {
+    const { cachedEngineEntry, listEngines } = await import("./local-engine-process-EHTE5LLU.js");
+    const entry = cachedEngineEntry(env, cwd);
+    return entry === void 0 ? void 0 : listEngines({ entry, env });
+  };
+}
+function isNamed(args, err) {
+  if (args.profile !== void 0) return true;
+  const source = err.missingProfile?.source;
+  return source === "flag" || source === "pointer" || source === "env";
+}
+function signInCommand(err, args) {
+  const stored = err instanceof NotSignedInError ? err.storedProfiles : [];
+  const flag = readFileFlag(args);
+  if (stored.length === 0) return `xanosdk login${flag}`;
+  return `xanosdk profile set-default ${stored.length === 1 ? stored[0] : "<name>"}${flag}`;
+}
+function readFileFlag(args) {
+  const recorded = credentialFileOf(args);
+  return recorded === void 0 ? "" : credentialFileFlagFor(recorded);
+}
+async function readStatus(args, start = process.cwd(), deps = {}) {
+  const env = deps.env ?? process.env;
+  const project = projectDirFrom(start) ?? null;
+  const cwd = project ?? start;
+  const localEngine = await readLocalEngine(cwd, deps);
+  let auth;
+  try {
+    auth = await getAccessToken(args);
+  } catch (err) {
+    if (isUsageError(err)) throw err;
+    if (err instanceof NotSignedInError && args.profile !== void 0) throw err;
+    if (err instanceof NotSignedInError && isNamed(args, err)) {
+      const missing = err.missingProfile;
+      return {
+        signedIn: false,
+        project,
+        signIn: `xanosdk login --profile ${shellQuote(missing.name)}${readFileFlag(args)}`,
+        rejected: null,
+        credentialFailure: err.message,
+        instance: null,
+        profile: missing,
+        user: null,
+        workspace: null,
+        environment: null,
+        environmentTrackedUnder: null,
+        deployed: deployedHere(cwd, env, void 0),
+        localEngine
+      };
+    }
+    if (!(err instanceof NotSignedInError)) {
+      const stored = err instanceof StoredCredentialError ? err : void 0;
+      return {
+        signedIn: false,
+        project,
+        signIn: stored?.fix ?? null,
+        rejected: null,
+        credentialFailure: err instanceof Error ? err.message : String(err),
+        instance: stored?.instance ?? null,
+        profile: stored?.profile ?? null,
+        user: null,
+        workspace: null,
+        environment: null,
+        environmentTrackedUnder: null,
+        deployed: deployedHere(cwd, env, void 0),
+        localEngine
+      };
+    }
+    const tracked = project === null ? [] : trackedUnderOthers(project, void 0);
+    return {
+      signedIn: false,
+      project,
+      signIn: trackedRemedy(tracked) ?? signInCommand(err, args),
+      rejected: null,
+      credentialFailure: null,
+      instance: null,
+      profile: null,
+      user: null,
+      workspace: null,
+      environment: null,
+      environmentTrackedUnder: tracked.length > 0 ? tracked : null,
+      // No credential: the fallback skips the ephemeral check, as a bare command's does.
+      deployed: deployedHere(cwd, env, void 0),
+      localEngine
+    };
+  }
+  let me;
+  try {
+    me = await getJson(`${auth.instance}/api:meta/auth/me`, auth, "status (signed-in user)");
+  } catch (err) {
+    if (err instanceof StatusReadError && (err.status === 401 || err.status === 403)) {
+      return {
+        signedIn: false,
+        project,
+        signIn: rejectedFixCommand(auth, args),
+        rejected: rejectedRemedy(auth, args),
+        credentialFailure: null,
+        instance: auth.instance,
+        profile: auth.profile ?? null,
+        user: null,
+        // The pin is known without the instance's help: which workspace the
+        // refused credential addresses is half of "which credential".
+        workspace: { id: auth.workspaceId, name: null, credential: auth.credentialType },
+        environment: null,
+        environmentTrackedUnder: null,
+        deployed: deployedHere(cwd, env, auth),
+        localEngine
+      };
+    }
+    throw err;
+  }
+  return {
+    signedIn: true,
+    project,
+    signIn: null,
+    rejected: null,
+    credentialFailure: null,
+    instance: auth.instance,
+    profile: auth.profile ?? null,
+    user: {
+      id: typeof me.id === "number" ? me.id : void 0,
+      name: asString(me.name),
+      email: asString(me.email)
+    },
+    workspace: await readWorkspace(auth),
+    ...await environmentBlock(auth, cwd, project),
+    deployed: deployedHere(cwd, env, auth),
+    localEngine
+  };
+}
+function deployedHere(cwd, env, scope) {
+  const answer = readTrackedBackend({ cwd, env, scope });
+  if (answer.kind !== null || isProjectDir(cwd)) return answer;
+  return {
+    ...answer,
+    // "Inside", not "from a project's root": any subdirectory of one finds it.
+    reason: `No Xano SDK project here (${cwd}) \u2014 run \`xanosdk status\` from inside a Xano SDK project, or \`xanosdk init\` to start one.`
+  };
+}
+async function environmentBlock(auth, cwd, project) {
+  const environment = await readEnvironment(auth, cwd);
+  if (environment !== null || project === null) return { environment, environmentTrackedUnder: null };
+  const unreadable = unreadableEphemeralState(cwd);
+  if (unreadable !== void 0) return { environment, environmentTrackedUnder: null, environmentUnreadable: unreadable };
+  const others = trackedUnderOthers(project, auth);
+  return { environment, environmentTrackedUnder: others.length > 0 ? others : null };
+}
+function trackedUnderOthers(project, auth) {
+  let state;
+  try {
+    state = readEphemeralState(project);
+  } catch {
+    return [];
+  }
+  const mine = auth === void 0 ? void 0 : environmentKey(auth);
+  return Object.entries(state.environments).filter(([key]) => auth === void 0 || key !== mine && key !== String(auth.workspaceId)).map(([key, record]) => {
+    const parts = key.split("/");
+    const profile = parts.length >= 3 ? parts[0] : null;
+    const host = parts.length >= 3 ? parts.slice(1, -1).join("/") : null;
+    const recorded = record.credential_file;
+    if (recordedByEnvCredential(record)) {
+      const workspaceId2 = Number(parts[parts.length - 1]);
+      return {
+        profile: null,
+        workspaceId: Number.isSafeInteger(workspaceId2) && workspaceId2 > 0 ? workspaceId2 : null,
+        host,
+        file: null,
+        command: null,
+        environmentCredential: true
+      };
+    }
+    const file = recordedCredentialPath(recorded);
+    const rawWorkspace = Number(parts[parts.length - 1]);
+    const workspaceId = Number.isSafeInteger(rawWorkspace) && rawWorkspace > 0 ? rawWorkspace : null;
+    const gone = profile !== null && !recordedProfileStored(profile, recorded);
+    const command = profile === null ? null : !gone ? `xanosdk status --profile ${profile}${recorded !== void 0 ? credentialFileFlagFor(recorded) : ""}` : loginCommand(profile, { path: file ?? void 0 });
+    const tokenCommand = gone ? profileAddCommand(profile, {
+      path: file ?? void 0,
+      instance: record.instance ?? (host !== null ? `https://${host}` : void 0),
+      workspaceId: workspaceId ?? void 0
+    }) : void 0;
+    return { profile, workspaceId, host, file, command, ...tokenCommand !== void 0 ? { tokenCommand } : {} };
+  });
+}
+function trackedRemedy(entries) {
+  const status = entries.find((e) => e.file !== null && e.command?.startsWith("xanosdk status ") === true);
+  return status?.command ?? entries.find((e) => e.command?.startsWith("xanosdk login") === true)?.command ?? void 0;
+}
+function trackedUnderText(entries, fromEnv, signedOut = false) {
+  const one = (e) => {
+    const where = `workspace ${e.workspaceId ?? "unknown"}${e.host !== null ? ` on ${e.host}` : ""}`;
+    const who = e.environmentCredential === true ? `the environment credential (${where}` : e.profile !== null ? `profile "${e.profile}" (${where}` : `another credential (${where}`;
+    const file = e.file !== null ? `, credential file ${e.file}` : "";
+    const run = e.command !== null ? e.tokenCommand !== void 0 ? ` \xB7 \`${e.command}\` (OAuth), or \`${e.tokenCommand}\` (meta API token)` : ` \xB7 \`${e.command}\`` : e.environmentCredential === true ? ` \xB7 set ${ENV_CREDENTIAL_VARS} for it` : "";
+    return `${who}${file})${run}`;
+  };
+  const envNote = fromEnv && entries.some((e) => e.command !== null) ? " (run without the environment credential \u2014 it outranks every stored profile)" : "";
+  const lead = signedOut ? "not signed in" : "none under this credential";
+  return `${lead} \xB7 the project's ephemeral is recorded under ${entries.map(one).join("; ")}${envNote}`;
+}
+function trackedRows(status, s) {
+  const rows = [];
+  const d = status.deployed;
+  if (status.project === null && d.kind === null) {
+    rows.push(["Project", `none ${s.dim(`\xB7 ${d.reason}`)}`]);
+  } else {
+    rows.push([
+      "Deployed",
+      // `none` where a kind would be, then why: a bare command has no backend to
+      // go to and refuses with that sentence. Not a bold "refuse" standing in for
+      // a kind, which read as a backend by that name.
+      d.kind === null ? `none ${s.dim(`\xB7 ${d.reason}`)}` : `${d.kind} ${s.dim(`\xB7 ${d.via === "pointer" ? "last deployed" : "recorded"}`)}`
+    ]);
+  }
+  const e = status.localEngine;
+  if (e !== null) {
+    const hint = e.liveness === "not-running" ? " \xB7 not running \xB7 `xanosdk deploy --local-engine` starts it" : e.liveness === "live" ? "" : ` \xB7 ${e.liveness}`;
+    rows.push(["Local engine", `${e.name} ${s.dim(`\xB7 ${e.url}${hint}`)}`]);
+  }
+  return rows;
+}
+function credentialRows(status, s) {
+  const rows = [];
+  if (status.instance !== null) rows.push(["Instance", s.bold(s.cyan(status.instance))]);
+  if (status.workspace !== null) rows.push(["Workspace", workspaceValue(status.workspace, s)]);
+  if (status.profile !== null) rows.push(["Profile", profileValue(status.profile, s)]);
+  return rows;
+}
+function displayLabel(env, s) {
+  return env.display !== void 0 && env.display !== "" && env.display !== env.name ? ` ${s.dim(env.display)}` : "";
+}
+function prettyStatus(status, fileFlag = "", rerun = `xanosdk status${fileFlag}`) {
+  const s = stdoutStyle();
+  if (!status.signedIn) {
+    const rows2 = status.rejected !== null ? [
+      ["Signed in", `${s.bold("no")} ${s.dim("\xB7 the instance rejected the credential")}`],
+      // The same Instance/Profile rows a credential that failed locally
+      // shows: which credential was refused is half the answer.
+      ...credentialRows(status, s),
+      ["", s.dim(status.rejected)]
+    ] : status.credentialFailure !== null ? [
+      ["Signed in", `${s.bold("no")} ${s.dim("\xB7 the credential could not be used")}`],
+      ...credentialRows(status, s),
+      ...status.credentialFailure.split("\n").map((line) => ["", s.dim(line)])
+    ] : [["Signed in", `${s.bold("no")} ${s.dim(`\xB7 run \`${status.signIn ?? "xanosdk login"}\``)}`]];
+    if (status.project !== null && status.environmentTrackedUnder !== null) {
+      rows2.push(["Environment", s.dim(trackedUnderText(status.environmentTrackedUnder, false, true))]);
+    }
+    return `
+${formatFields([...rows2, ...trackedRows(status, s)])}`;
+  }
+  const rows = [
+    ["Signed in", signedInValue(status.user, s)],
+    ["Instance", s.bold(s.cyan(status.instance ?? ""))]
+  ];
+  const ws = status.workspace;
+  if (ws !== null) {
+    rows.push(["Workspace", workspaceValue(ws, s)]);
+    if (ws.note !== void 0) rows.push(["", s.dim(ws.note)]);
+  }
+  rows.push(["Profile", profileValue(status.profile, s)]);
+  const env = status.environment;
+  if (status.project === null) {
+  } else if (env === null && status.environmentUnreadable !== void 0) {
+    rows.push([
+      "Environment",
+      s.dim(`unknown \xB7 ${displayPath(status.environmentUnreadable)} is unreadable \xB7 \`xanosdk ephemeral list${fileFlag}\` finds the ephemeral it recorded`)
+    ]);
+  } else if (env === null && status.environmentTrackedUnder !== null) {
+    rows.push(["Environment", s.dim(trackedUnderText(status.environmentTrackedUnder, status.profile === null))]);
+  } else if (env === null && status.deployed.kind === "local-engine") {
+    rows.push(["Environment", s.dim(`no ephemeral \xB7 \`xanosdk deploy${fileFlag}\` without --local-engine makes one`)]);
+  } else if (env === null && readDeployed(status.project)?.kind === "ephemeral") {
+    rows.push(["Environment", s.dim(`none tracked \xB7 the last one is gone (deleted or expired) \xB7 run \`xanosdk deploy${fileFlag}\` for a fresh one`)]);
+  } else if (env === null) {
+    rows.push(["Environment", s.dim(`none yet \xB7 run \`xanosdk deploy${fileFlag}\``)]);
+  } else if (env.alive === null) {
+    rows.push(["Environment", `${env.name}${displayLabel(env, s)} ${s.dim("\xB7 unknown \u2014 the lookup got no answer")}`]);
+    if (env.note !== void 0) rows.push(["", s.dim(`${env.note}. Run \`${rerun}\` again once it answers.`)]);
+  } else if (!env.alive) {
+    rows.push([
+      "Environment",
+      `${env.name}${displayLabel(env, s)} ${s.dim(`\xB7 gone or expired \xB7 run \`xanosdk deploy${fileFlag}\` for a fresh one`)}`
+    ]);
+  } else {
+    const state = env.state === null ? "" : ` ${s.dim(`\xB7 ${env.state}`)}`;
+    rows.push([
+      "Environment",
+      `${env.name}${displayLabel(env, s)}${state} ${s.dim(`\xB7 expires ${formatExpiration(env.expiresAt)}`)}`
+    ]);
+    if (env.url !== void 0) rows.push(["URL", s.bold(s.cyan(env.url))]);
+  }
+  rows.push(...trackedRows(status, s));
+  return `
+${formatFields(rows)}`;
+}
+async function runStatusCommand(args) {
+  const status = await readStatus(args).catch(async (err) => {
+    const { unansweredRead } = await import("./source-resolve-S2XA3XZF.js");
+    throw unansweredRead(err, "read the status", "workspace");
+  });
+  if (isMachineOutput(args)) {
+    const env = status.environment;
+    const doc = { ...status, profile: selectionDocument(status.profile) };
+    if (env?.alive === null) {
+      const again = `${env.note ?? "The ephemeral lookup got no answer"}. Run \`${retryCommand(args, { command: "status" }).command}\` again once it answers.`;
+      throw new CliError("SDK_ERROR", again, {
+        exitCode: EXIT_SOURCE_UNRESOLVABLE,
+        details: { status: { ...doc, environment: { ...env, note: again } } }
+      });
+    }
+    writeJson(doc);
+  } else {
+    printHuman(prettyStatus(status, readFileFlag(args), retryCommand(args, { command: "status" }).command));
+  }
+  if (status.environment?.alive === null) process.exitCode = EXIT_SOURCE_UNRESOLVABLE;
+}
+export {
+  readStatus,
+  runStatusCommand
+};
+//# sourceMappingURL=status-command-RUDXTF7I.js.map

package/dist/store-6VNCD4D7.js

@@ -0,0 +1,20 @@
+import {
+  getLockedCanonical,
+  getLockedGuid,
+  isLockSeeded,
+  resetLockOverrides,
+  seedLockOverrides,
+  seededLockSource,
+  tagLockSource
+} from "./chunk-4BW2SG2N.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  getLockedCanonical,
+  getLockedGuid,
+  isLockSeeded,
+  resetLockOverrides,
+  seedLockOverrides,
+  seededLockSource,
+  tagLockSource
+};
+//# sourceMappingURL=store-6VNCD4D7.js.map

package/dist/store-ARM6VMO5.js

@@ -0,0 +1,98 @@
+import {
+  CREDENTIAL_FILE_VERSION,
+  UPGRADE_REMEDY,
+  addGitignoreRule,
+  addProfileHint,
+  assertCredentialFileRemovable,
+  assertCredentialFileWritable,
+  assertCredentialPathUsable,
+  buildTokenCredential,
+  clearCredential,
+  clearCredentialUnderLock,
+  credentialFileFlag,
+  describeProfile,
+  dropProfile,
+  emptyCredentialFile,
+  ensureGitignored,
+  gitSaysIgnored,
+  gitignoreRootFor,
+  globalAuthFilePath,
+  insideGitRepo,
+  isSafeIdText,
+  localAuthFilePath,
+  loginCommand,
+  loginHint,
+  profileAddCommand,
+  profileNames,
+  projectAuthFilePath,
+  readCredential,
+  readCredentialFile,
+  readProfile,
+  recordedCredentialFile,
+  recordedCredentialPath,
+  recordedProfileStored,
+  removeEmptyProjectCacheDir,
+  resolveAuthFilePath,
+  sameOriginAs,
+  withCredentialLock,
+  writeCredentialFile,
+  writeOrRemoveCredentialFile
+} from "./chunk-XW6KISBB.js";
+import "./chunk-AWQ7BQTQ.js";
+import "./chunk-EUUUMY7J.js";
+import "./chunk-YLDALTWZ.js";
+import "./chunk-5FBYXK5P.js";
+import "./chunk-LLNZGEFK.js";
+import {
+  DEFAULT_PROFILE
+} from "./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 {
+  CREDENTIAL_FILE_VERSION,
+  DEFAULT_PROFILE,
+  UPGRADE_REMEDY,
+  addGitignoreRule,
+  addProfileHint,
+  assertCredentialFileRemovable,
+  assertCredentialFileWritable,
+  assertCredentialPathUsable,
+  buildTokenCredential,
+  clearCredential,
+  clearCredentialUnderLock,
+  credentialFileFlag,
+  describeProfile,
+  dropProfile,
+  emptyCredentialFile,
+  ensureGitignored,
+  gitSaysIgnored,
+  gitignoreRootFor,
+  globalAuthFilePath,
+  insideGitRepo,
+  isSafeIdText,
+  localAuthFilePath,
+  loginCommand,
+  loginHint,
+  profileAddCommand,
+  profileNames,
+  projectAuthFilePath,
+  readCredential,
+  readCredentialFile,
+  readProfile,
+  recordedCredentialFile,
+  recordedCredentialPath,
+  recordedProfileStored,
+  removeEmptyProjectCacheDir,
+  resolveAuthFilePath,
+  sameOriginAs,
+  withCredentialLock,
+  writeCredentialFile,
+  writeOrRemoveCredentialFile
+};
+//# sourceMappingURL=store-ARM6VMO5.js.map