@unoverse-platform/studio 0.1.56 → 0.1.58

package/src/universes.ts

@@ -1,210 +0,0 @@
-/**
- * The universes this developer can publish to.
- *
- * A UNIVERSE NAMES ITS OWN IDENTITY PROVIDER. Studio hardcodes no issuer and no vendor:
- * it asks a universe at `/.well-known/unoverse-universe` and follows the answer, so
- * Auth0, Okta, Entra and Keycloak all work with no change here. That is the whole reason
- * login lives in Studio (a browser, where OIDC is a redirect) rather than in the CLI.
- *
- * THERE IS NO CENTRAL DIRECTORY, and there cannot be. Every universe is independent with
- * its own database and its own IdP (docs/AUTH_TOKEN_FLOW.md: "OIDC-provider-agnostic").
- * Nothing sits above them to enumerate. So "the universes I can deploy to" means the ones
- * this developer has connected to, held here on their machine. That is the honest answer,
- * not a placeholder for a registry.
- *
- * NO TOKEN IS EVER WRITTEN HERE. Only the URL, a label, and the public config. The access
- * token stays wherever the OIDC library keeps it for the session. Local Studio already
- * holds this line for credentials (`local/keys.ts`: "Studio therefore never WRITES a
- * secret") and connecting to a universe must not be the thing that breaks it.
- *
- * See docs/architecture/LOCAL_STUDIO.md.
- */
-
-/** What a universe publishes about itself. Mirrors `getPublicAuthConfig()` on the server. */
-export interface UniverseConfig {
-  /** False means the universe is not gated at all: do not send anyone to log in. */
-  authEnabled: boolean;
-  issuer: string | null;
-  clientId: string | null;
-  audience: string | null;
-  /** The permission a token needs before this universe accepts a publish. */
-  publishPermission: string;
-}
-
-export interface Universe {
-  /** Origin, normalised. The identity of the entry: one row per universe. */
-  url: string;
-  /** What the developer calls it. Defaults to the host. */
-  label: string;
-  config: UniverseConfig;
-  /** When it was last reachable, ISO. Purely informational. */
-  connectedAt?: string;
-}
-
-const STORAGE_KEY = "studio:universes";
-
-/** The path a universe serves its public config on. */
-export const DISCOVERY_PATH = "/.well-known/unoverse-universe";
-
-/**
- * Turn whatever a developer typed into an origin.
- *
- * People type `localhost:4105`, `example.com/`, and `https://example.com/canvas`. All
- * three mean one universe, and storing them as three entries would let the same universe
- * hold three different logins. So this is the identity function for the list.
- *
- * Bare hosts default to https, EXCEPT localhost and 127.0.0.1, which are overwhelmingly
- * a developer's own machine over http and would otherwise fail confusingly.
- */
-export function normaliseUrl(input: string): string {
-  const trimmed = (input ?? "").trim();
-  if (!trimmed) throw new Error("Enter a universe address");
-
-  const isLocal = /^(https?:\/\/)?(localhost|127\.0\.0\.1)(:|\/|$)/i.test(trimmed);
-  const withScheme = /^https?:\/\//i.test(trimmed) ? trimmed : `${isLocal ? "http" : "https"}://${trimmed}`;
-
-  let parsed: URL;
-  try {
-    parsed = new URL(withScheme);
-  } catch {
-    throw new Error(`"${input}" is not a valid address`);
-  }
-  return parsed.origin;
-}
-
-/** A readable default name: the host, without the port for a real domain. */
-export function defaultLabel(url: string): string {
-  try {
-    return new URL(url).host;
-  } catch {
-    return url;
-  }
-}
-
-/**
- * Ask a universe how to log in.
- *
- * Failure here is the common case, not the exception: wrong address, universe down, a
- * plain website that is not a universe at all. Each gets a message a developer can act
- * on, because "Failed to fetch" tells them nothing about which of the three it was.
- */
-export async function discover(
-  url: string,
-  fetchImpl: typeof fetch = fetch,
-): Promise<UniverseConfig> {
-  let response: Response;
-  try {
-    response = await fetchImpl(`${url}${DISCOVERY_PATH}`, { headers: { accept: "application/json" } });
-  } catch {
-    throw new Error(`Could not reach ${url}. Check the address, and that the universe is running.`);
-  }
-
-  if (response.status === 404) {
-    throw new Error(`Something answered at ${url}, but it is not a universe.`);
-  }
-  if (!response.ok) {
-    throw new Error(`${url} answered with an error (${response.status}).`);
-  }
-
-  let body: unknown;
-  try {
-    body = await response.json();
-  } catch {
-    throw new Error(`${url} answered, but not like a universe. If it is one, it may need restarting.`);
-  }
-
-  const cfg = body as Partial<UniverseConfig>;
-  // authEnabled is the field that decides whether we send someone to log in, so its
-  // absence is a broken response rather than a default worth guessing at.
-  if (typeof cfg?.authEnabled !== "boolean") {
-    throw new Error(`${url} answered, but not like a universe. If it is one, it may need restarting.`);
-  }
-
-  return {
-    authEnabled: cfg.authEnabled,
-    issuer: cfg.issuer ?? null,
-    clientId: cfg.clientId ?? null,
-    audience: cfg.audience ?? null,
-    publishPermission: cfg.publishPermission ?? "marketplace:publish",
-  };
-}
-
-/**
- * Can this universe actually be logged into?
- *
- * A universe can say `authEnabled: true` and still be missing an issuer or a client id,
- * which is a misconfigured universe rather than a Studio problem. Saying so beats
- * redirecting the browser to `undefined`.
- */
-export function loginReady(config: UniverseConfig): { ok: true } | { ok: false; reason: string } {
-  if (!config.authEnabled) return { ok: false, reason: "This universe has authentication switched off." };
-  if (!config.issuer) return { ok: false, reason: "This universe has no identity provider configured." };
-  if (!config.clientId) return { ok: false, reason: "This universe has no client id configured for sign-in." };
-  return { ok: true };
-}
-
-/**
- * Does this token allow publishing here?
- *
- * Checked so Studio can say "signed in, but not allowed to publish" up front, instead of
- * letting someone build for an hour and fail on the push. Namespace-aware for the same
- * reason the server is: an IdP may emit `permissions` under a namespaced claim, and a
- * plain read silently returns nothing (docs/AUTH_TOKEN_FLOW.md).
- */
-export function canPublish(claims: Record<string, unknown> | null | undefined, config: UniverseConfig): boolean {
-  if (!claims) return false;
-  const direct = claims.permissions;
-  const namespacedKey = Object.keys(claims).find(
-    (k) => k.endsWith("/permissions") || k.endsWith("/claims/permissions"),
-  );
-  const list = Array.isArray(direct) ? direct : namespacedKey && Array.isArray(claims[namespacedKey]) ? (claims[namespacedKey] as unknown[]) : [];
-
-  // TRIMMED, because a permission is typed into an identity provider by a person and a
-  // stray space is invisible everywhere it is displayed. One arrived as " marketplace:publish"
-  // and cost a long debugging session: the Auth0 screen showed it assigned, the token
-  // carried it, the label printed it, and the comparison correctly said no. Nothing about
-  // surrounding whitespace is ever meaningful in a permission name.
-  const wanted = String(config.publishPermission).trim();
-  return list.some((p) => String(p).trim() === wanted);
-}
-
-// ── The stored list ───────────────────────────────────────────────────────
-
-type Store = Pick<Storage, "getItem" | "setItem">;
-
-function store(): Store | null {
-  try {
-    return typeof localStorage === "undefined" ? null : localStorage;
-  } catch {
-    return null; // storage blocked (private mode, embedded contexts)
-  }
-}
-
-/** Every universe this developer has connected to. Never throws: a corrupt entry is
- *  dropped rather than taking the whole list, and the app down with it. */
-export function loadUniverses(storage: Store | null = store()): Universe[] {
-  const raw = storage?.getItem(STORAGE_KEY);
-  if (!raw) return [];
-  try {
-    const parsed = JSON.parse(raw);
-    if (!Array.isArray(parsed)) return [];
-    return parsed.filter((u): u is Universe => typeof u?.url === "string" && typeof u?.config?.authEnabled === "boolean");
-  } catch {
-    return [];
-  }
-}
-
-/** Add or update one, keyed on url so reconnecting refreshes rather than duplicates. */
-export function saveUniverse(universe: Universe, storage: Store | null = store()): Universe[] {
-  const next = [...loadUniverses(storage).filter((u) => u.url !== universe.url), universe].sort((a, b) =>
-    a.label.localeCompare(b.label),
-  );
-  storage?.setItem(STORAGE_KEY, JSON.stringify(next));
-  return next;
-}
-
-export function removeUniverse(url: string, storage: Store | null = store()): Universe[] {
-  const next = loadUniverses(storage).filter((u) => u.url !== url);
-  storage?.setItem(STORAGE_KEY, JSON.stringify(next));
-  return next;
-}