@calimero-network/mero-js 29.7.6 → 29.8.0

package/dist/index.cjs

@@ -1725,11 +1725,18 @@ function cancelled(message) {
   error.name = "NotAllowedError";
   return error;
 }
-async function ask(method, options) {
+async function ask(method, options, signal, what) {
   const container = navigator.credentials;
   const own = globalThis.CredentialsContainer?.prototype?.[method];
   const call = own ?? container[method];
-  return call.call(container, options);
+  try {
+    return await call.call(container, signal ? { ...options, signal } : options);
+  } catch (error) {
+    if (signal?.aborted || error?.name === "AbortError") {
+      throw Object.assign(cancelled(`${what} was cancelled`), { cause: error });
+    }
+    throw error;
+  }
 }
 function es256First(params) {
   const es256 = params.filter((p) => p.alg === -7);
@@ -1737,7 +1744,7 @@ function es256First(params) {
 }
 function browserPasskey() {
   return {
-    async create(options) {
+    async create(options, createOptions) {
       const o = options;
       const cred = await ask("create", {
         publicKey: {
@@ -1753,7 +1760,7 @@ function browserPasskey() {
           attestation: "none",
           timeout: o.timeout
         }
-      });
+      }, createOptions?.signal, "passkey creation");
       if (!cred) throw cancelled("passkey creation was cancelled");
       const r = cred.response;
       return {
@@ -1772,7 +1779,7 @@ function browserPasskey() {
             id: buf(fromB64url(id))
           }))
         }
-      });
+      }, options?.signal, "passkey sign-in");
       if (!cred) throw cancelled("passkey sign-in was cancelled");
       const r = cred.response;
       return {
@@ -2377,14 +2384,16 @@ var CalimeroClient = class _CalimeroClient {
       origin === void 0 ? { name, ...invite } : { name, origin, ...invite },
       origin
     );
-    const registration = await passkey.create(begin.options);
+    const signal = options.signal;
+    const registration = await (signal ? passkey.create(begin.options, { signal }) : passkey.create(begin.options));
     const session = await this.confirmed(
       "POST",
       "auth/passkey/register/finish",
       { challengeId: begin.challengeId, registration, ...invite },
       passkey,
       void 0,
-      "preferred"
+      "preferred",
+      signal
     );
     this.useSession(session);
     return session;
@@ -2405,7 +2414,8 @@ var CalimeroClient = class _CalimeroClient {
     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 challenge = fromB64url(begin.options.challenge);
+    const assertion = await (options.signal ? passkey.get(challenge, rpId, void 0, { signal: options.signal }) : passkey.get(challenge, rpId));
     const session = await this.post("auth/passkey/login/finish", {
       challengeId: begin.challengeId,
       assertion
@@ -2474,16 +2484,31 @@ var CalimeroClient = class _CalimeroClient {
     if (this.current === current) this.useSession(session);
     return session;
   }
+  /**
+   * End this session. The client is signed out whether or not the node
+   * answers: the revoke (`POST /auth/logout`) is attempted, and its failure
+   * (the node unreachable, say) is thrown after the session is dropped, so a
+   * caller can say the server may still hold it, but no request after this
+   * one carries its token.
+   */
   async signOut() {
-    await this.post("auth/logout");
-    this.auth = void 0;
-    this.current = void 0;
+    await this.signingOut("auth/logout");
   }
-  /** End every session of the signed-in account, on every device, this one too. */
+  /**
+   * End every session of the signed-in account, on every device, this one
+   * too. Like {@link signOut}, this client is signed out even when the
+   * request fails, and the failure is thrown.
+   */
   async signOutEverywhere() {
-    await this.post("auth/logout-all");
-    this.auth = void 0;
-    this.current = void 0;
+    await this.signingOut("auth/logout-all");
+  }
+  async signingOut(path) {
+    try {
+      await this.post(path);
+    } finally {
+      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() {
@@ -2775,7 +2800,7 @@ var CalimeroClient = class _CalimeroClient {
   deleteConfirmed(path, passkey, body = {}) {
     return this.confirmed("DELETE", path, body, passkey);
   }
-  async confirmed(method, path, body, passkey, send = (b) => this.json(method, path, b), userVerification = "required") {
+  async confirmed(method, path, body, passkey, send = (b) => this.json(method, path, b), userVerification = "required", signal) {
     try {
       return await send(body);
     } catch (error) {
@@ -2784,7 +2809,8 @@ var CalimeroClient = class _CalimeroClient {
       let assertion;
       try {
         assertion = await passkey.get(fromB64url(d.challenge), d.rpId, d.allowCredentials, {
-          userVerification: userVerificationOf(d.userVerification, userVerification)
+          userVerification: userVerificationOf(d.userVerification, userVerification),
+          ...signal ? { signal } : {}
         });
       } catch (declined) {
         throw promptFailure(declined);
@@ -3171,16 +3197,33 @@ var CalimeroClient = class _CalimeroClient {
   }
   /**
    * Set capability bits ({@link ORG_CAPABILITIES}): for a member (`account`),
-   * for a member of one team (`account` and `team`), or the organization's
-   * default (neither). Approved with the caller's `passkey`.
+   * for a member of one team (`account` and `team`), a team's default
+   * (`team` alone, {@link setTeamDefaultCapabilities}), or the
+   * organization's default (neither). Approved with the caller's `passkey`.
    */
   async setCapabilities(org, capabilities, passkey, at = {}) {
     await this.postConfirmed(`orgs/${seg(org)}/capabilities`, { capabilities, ...at }, passkey);
   }
+  /**
+   * Set the capability bits everyone in `team` holds there on top of their
+   * own, unless their row sets its own (`POST /orgs/{org}/capabilities` with
+   * `team` and no `account`): `ORG_CAPABILITIES.INVITE_MEMBERS` is "members
+   * may invite others to this app". The team's managers, or whoever holds
+   * `MANAGE_MEMBERS` on it; approved with the caller's `passkey`
+   * (`__set_default_capabilities { team, capabilities }`).
+   */
+  async setTeamDefaultCapabilities(org, team, capabilities, passkey) {
+    await this.postConfirmed(`orgs/${seg(org)}/capabilities`, { team, capabilities }, passkey);
+  }
   async createTeam(org, name, join, parent) {
     const { teamId } = await this.post(`orgs/${seg(org)}/teams`, { name, join, parent });
     return teamId;
   }
+  /**
+   * A team the caller sees: its rows (each with its effective capabilities),
+   * children, apps, the package it is the app team of and its default
+   * capabilities.
+   */
   getTeam(org, team) {
     return this.get(`orgs/${seg(org)}/teams/${seg(team)}`);
   }
@@ -3222,6 +3265,48 @@ var CalimeroClient = class _CalimeroClient {
   redeemInvite(token) {
     return this.post(`invites/${seg(token)}/redeem`);
   }
+  /**
+   * The organization's pending invites the caller may see (never a token):
+   * every one for an owner or admin, their own, and those naming only teams
+   * they manage. Expired ones are listed (`expired: true`) until revoked. A
+   * caller outside the organization: {@link NotFound}.
+   */
+  async listInvites(org) {
+    const { invites } = await this.get(`orgs/${seg(org)}/invites`);
+    return invites;
+  }
+  /**
+   * Withdraw an invite by its key ({@link listInvites}), approved with the
+   * caller's `passkey` (`__revoke_invite { inviteKey }`). One the caller may
+   * not see: {@link NotFound}.
+   */
+  async revokeInvite(org, inviteKey, passkey) {
+    await this.deleteConfirmed(`orgs/${seg(org)}/invites/${seg(inviteKey)}`, passkey);
+  }
+  // ---------------------------------------------------------------- app teams
+  /**
+   * The organization's mode and its app teams (one per package), for any
+   * member; a guest sees only those they are in. A caller outside the
+   * organization: {@link NotFound}.
+   */
+  listAppTeams(org) {
+    return this.get(`orgs/${seg(org)}/app-teams`);
+  }
+  /**
+   * Give apps their own access lists in one step (owner or admin): find or
+   * make each package's app team, add everyone who reaches its instances now,
+   * and move those instances onto it; with `shared`, close every app team.
+   * Idempotent per package. Approved with the caller's `passkey`
+   * (`__scope_apps { apps, shared }`); a refusal is `400 REJECTED` with the
+   * node's reason. For a fresh standalone install pass
+   * `{ apps: [{ package, name, instances: [] }] }`.
+   */
+  scopeApps(org, passkey, options = {}) {
+    const body = {};
+    if (options.apps !== void 0) body.apps = options.apps;
+    if (options.shared !== void 0) body.shared = options.shared;
+    return this.postConfirmed(`orgs/${seg(org)}/app-teams`, body, passkey);
+  }
   // ---------------------------------------------------------------- deployers
   /**
    * Let an account or organization install apps where the cluster's