@calimero-network/mero-js 28.1.1 → 29.1.0

package/dist/index.cjs

@@ -34,6 +34,7 @@ __export(index_exports, {
   AgentGateError: () => AgentGateError,
   AppError: () => AppError,
   ArgsTooLarge: () => ArgsTooLarge,
+  BadOrigin: () => BadOrigin,
   CalimeroClient: () => CalimeroClient,
   CalimeroError: () => CalimeroError,
   ConfirmCancelled: () => ConfirmCancelled,
@@ -54,7 +55,10 @@ __export(index_exports, {
   NODE_RELEASE_SIGNER: () => NODE_RELEASE_SIGNER,
   NotFound: () => NotFound,
   ORG_CAPABILITIES: () => ORG_CAPABILITIES,
+  OriginNotRegistered: () => OriginNotRegistered,
+  OriginTaken: () => OriginTaken,
   PRODUCTION_PROFILE: () => PRODUCTION_PROFILE,
+  QuotaExceeded: () => QuotaExceeded,
   RELEASE_VERIFIER: () => RELEASE_VERIFIER,
   ReleaseDeadlineError: () => ReleaseDeadlineError,
   SEALED_CONTENT_TYPE: () => SEALED_CONTENT_TYPE,
@@ -1508,6 +1512,36 @@ var ConsentStale = class extends CalimeroError {
     this.name = "ConsentStale";
   }
 };
+var OriginNotRegistered = class extends CalimeroError {
+  constructor(message, details = {}) {
+    const origin = typeof details.origin === "string" ? details.origin : "";
+    const pkg = typeof details.package === "string" ? details.package : "";
+    const site = origin ? `this site (${origin})` : "this site";
+    super(403, "ORIGIN_NOT_REGISTERED", `${site} is not registered for ${pkg || "any package"}${message ? ` (${message})` : ""}`, details);
+    this.name = "OriginNotRegistered";
+    this.origin = origin;
+    this.package = pkg;
+    this.nodeMessage = message;
+  }
+};
+var BadOrigin = class extends CalimeroError {
+  constructor(code, message, details = {}) {
+    super(400, code, message, details);
+    this.name = "BadOrigin";
+  }
+};
+var OriginTaken = class extends CalimeroError {
+  constructor(message, details = {}) {
+    super(409, "ORIGIN_TAKEN", message, details);
+    this.name = "OriginTaken";
+  }
+};
+var QuotaExceeded = class extends CalimeroError {
+  constructor(message, details = {}) {
+    super(429, "QUOTA_EXCEEDED", message, details);
+    this.name = "QuotaExceeded";
+  }
+};
 var AppError = class extends CalimeroError {
   constructor(message, details = {}) {
     super(422, "APP_ERROR", message, details);
@@ -1567,6 +1601,15 @@ function errorFrom(status, body, retryAfterHeader) {
       return new ReleaseDeadlineError(message, details);
     case "409 CONSENT_STALE":
       return new ConsentStale(message, details);
+    case "403 ORIGIN_NOT_REGISTERED":
+      return new OriginNotRegistered(message, details);
+    case "400 BAD_ORIGIN":
+    case "400 BAD_RP_ID":
+      return new BadOrigin(code, message, details);
+    case "409 ORIGIN_TAKEN":
+      return new OriginTaken(message, details);
+    case "429 QUOTA_EXCEEDED":
+      return new QuotaExceeded(message, details);
     case "412 CONFIRM_REQUIRED":
       return new ConfirmRequired(message, details);
     case "413 ARGS_TOO_LARGE":
@@ -1855,6 +1898,25 @@ var CalimeroClient = class _CalimeroClient {
     this.channels = /* @__PURE__ */ new Map();
     /** Rejections of the underlying `fetch` itself: the node could not be reached or dropped the connection. */
     this.networkFailures = /* @__PURE__ */ new WeakSet();
+    // ---------------------------------------------------------------- package origins
+    /**
+     * The web origins `{package}`'s managers registered so a frontend they host
+     * themselves can sign users in with passkeys ({@link PackageOrigins}).
+     * Adding and removing one is approved with a passkey.
+     */
+    this.packageOrigins = {
+      list: async (pkg) => {
+        const { origins } = await this.get(`package-origins/${seg(pkg)}`);
+        return origins ?? [];
+      },
+      add: (pkg, origin, passkey, options = {}) => this.confirmed(
+        "POST",
+        `package-origins/${seg(pkg)}`,
+        options.rpId === void 0 ? { origin } : { origin, rpId: options.rpId },
+        passkey
+      ),
+      remove: (pkg, origin, passkey) => this.confirmed("DELETE", `package-origins/${seg(pkg)}`, { origin }, passkey)
+    };
     const trim = (url2) => url2.replace(/\/+$/, "");
     this.nodeUrls = [...new Set([options.baseUrl, ...options.nodes ?? []].map(trim))];
     this.policy = options.policy;
@@ -2108,26 +2170,43 @@ var CalimeroClient = class _CalimeroClient {
     return this.json("DELETE", path, body);
   }
   // ---------------------------------------------------------------- identity
-  /** Create an account with a new passkey, and sign in. */
-  async signUp(passkey, name) {
-    const begin = await this.post(
+  /**
+   * Create an account with a new passkey, and sign in. The node then asks the
+   * new passkey to sign the account it creates (`412 CONFIRM_REQUIRED`), so a
+   * sign-up prompts twice: create, then sign. On a page whose origin is not
+   * the cluster's ({@link SignInOptions}), the node makes the passkey for that
+   * origin's relying party (the confirmation's `rpId` is that origin's too)
+   * and binds the session to the package the origin is registered for; an
+   * unregistered origin is refused with {@link OriginNotRegistered}.
+   */
+  async signUp(passkey, name, options = {}) {
+    const origin = this.pageOrigin(options);
+    const begin = await this.begin(
       "auth/passkey/register/begin",
-      { name }
+      origin === void 0 ? { name } : { name, origin },
+      origin
     );
     const registration = await passkey.create(begin.options);
-    const session = await this.post("auth/passkey/register/finish", {
-      challengeId: begin.challengeId,
-      registration
-    });
+    const session = await this.postConfirmed(
+      "auth/passkey/register/finish",
+      { challengeId: begin.challengeId, registration },
+      passkey
+    );
     this.useSession(session);
     return session;
   }
-  /** Sign in with an existing passkey. */
-  async signIn(passkey) {
-    const begin = await this.post(
-      "auth/passkey/login/begin"
-    );
-    const assertion = await passkey.get(fromB64url(begin.options.challenge), begin.options.rpId);
+  /**
+   * Sign in with an existing passkey. On a page whose origin is not the
+   * cluster's ({@link SignInOptions}), the assertion is made for that
+   * origin's relying-party id, as the node answers it, and the session is
+   * bound to the origin's package; an unregistered origin is refused with
+   * {@link OriginNotRegistered}.
+   */
+  async signIn(passkey, options = {}) {
+    const origin = this.pageOrigin(options);
+    const begin = await this.begin("auth/passkey/login/begin", origin === void 0 ? void 0 : { origin }, origin);
+    const rpId = begin.options.rpId ?? begin.options.rp?.id ?? "";
+    const assertion = await passkey.get(fromB64url(begin.options.challenge), rpId);
     const session = await this.post("auth/passkey/login/finish", {
       challengeId: begin.challengeId,
       assertion
@@ -2135,6 +2214,36 @@ var CalimeroClient = class _CalimeroClient {
     this.useSession(session);
     return session;
   }
+  /**
+   * The origin a sign-up or sign-in sends: the one given, or the page's own
+   * when it is not a node's origin; `undefined` for none.
+   */
+  pageOrigin(options) {
+    if (options.origin !== void 0) return options.origin ?? void 0;
+    const page = globalThis.location?.origin;
+    if (!page || page === "null") return void 0;
+    const nodes = new Set(
+      this.nodeUrls.map((url2) => {
+        try {
+          return new URL(url2).origin;
+        } catch {
+          return url2;
+        }
+      })
+    );
+    return nodes.has(page) ? void 0 : page;
+  }
+  /** POST a ceremony's `begin`, naming the page's `origin` in an {@link OriginNotRegistered} the node leaves it out of. */
+  async begin(path, body, origin) {
+    try {
+      return await this.post(path, body);
+    } catch (error) {
+      if (error instanceof OriginNotRegistered && !error.origin && origin !== void 0) {
+        throw new OriginNotRegistered(error.nodeMessage, { ...error.details, origin });
+      }
+      throw error;
+    }
+  }
   /**
    * Swap the refresh token for a new session, on whichever node the client
    * uses: any node of the cluster takes it. A refresh token is used once, so
@@ -2177,6 +2286,7 @@ var CalimeroClient = class _CalimeroClient {
     this.auth = void 0;
     this.current = void 0;
   }
+  /** Who the credential is: the account, how it signed in, and the package (`app`) and `origin` a session is bound to. */
   me() {
     return this.get("auth/me");
   }
@@ -2223,8 +2333,9 @@ var CalimeroClient = class _CalimeroClient {
     const { keys } = await this.get("auth/apikeys");
     return keys;
   }
-  async revokeApiKey(keyId) {
-    await this.delete(`auth/apikeys/${seg(keyId)}`);
+  /** Revoke one of the account's API keys, approved with its `passkey` (`412 CONFIRM_REQUIRED`). */
+  async revokeApiKey(keyId, passkey) {
+    await this.deleteConfirmed(`auth/apikeys/${seg(keyId)}`, passkey);
   }
   /**
    * Create an API key for an agent or server, approved with the account's