@hanzo/rooms 0.1.85 → 0.1.86

package/dist/Orgs.js

@@ -47,7 +47,8 @@ import { matches, refusal, slugify } from './lib/orgname.js';
 import { team as workspace } from './lib/host.js';
 import { checkoutUrl, money } from './lib/pay.js';
 import { cartUrl, charge, priced, usePlan, usePlans } from './lib/plans.js';
-import { createInvitation, inviteLink } from './lib/invite.js';
+import { createInvitation, inviteLink, setOrganizationProfile } from './lib/invite.js';
+import { createOrg, say } from './lib/org.js';
 import { countSignup } from './lib/intent.js';
 import { BAD, mix } from './lib/mix.js';
 import { useRooms } from './host.js';
@@ -647,12 +648,15 @@ function Everyone({ q, skip }) {
  *
  * The slug follows the name the way IAM's onboarding makes it, until it is typed
  * over; a slug typed is IAM's to take as it is, so one IAM would not keep is
- * refused here with the rule, never rewritten. IAM's own onboarding makes it
- * (`POST /v1/iam/onboard`): the organization, the reader as its owner and its
- * first API key, the founder's account untouched. It is sent the name when the
- * name makes the slug, and the slug when the slug was typed, the display name
- * then written on the row (`/v1/iam/organizations/profile`). The token in hand
- * predates it, so it is refreshed before the organization opens.
+ * refused here with the rule, never rewritten. The create is the one every
+ * surface uses, `POST /v1/account/orgs` (lib/org.ts `createOrg`): it files the
+ * organization in IAM and records the reader as its owner through IAM's
+ * membership API, the account untouched. IAM's own `/v1/iam/onboard` is not
+ * reachable from here: the edge answers no app origin's CORS on it, because it
+ * re-keys the session (cloud cors_origin.go `sessionRoutes`). It is sent the
+ * name when the name makes the slug, and the slug when the slug was typed, the
+ * display name then written on the row (lib/invite.ts `setOrganizationProfile`).
+ * The token in hand predates it, so it is refreshed before the organization opens.
  */
 function Found({ onClose, onMade }) {
     const { sdk } = useIam();
@@ -681,29 +685,15 @@ function Found({ onClose, onMade }) {
             return setRefused(wrong);
         setBusy(true);
         setRefused(null);
-        const headers = { Authorization: `Bearer ${bearer() ?? ''}`, 'Content-Type': 'application/json' };
-        const why = async (r) => {
-            const body = (await r.json().catch(() => null));
-            return body?.error || body?.detail || body?.msg || body?.message || `IAM answered ${r.status}.`;
-        };
         try {
             const named = slugify(display) === slug;
-            const r = await fetch(`${api()}/v1/iam/onboard`, { method: 'POST', headers, body: JSON.stringify({ name: named ? display : slug }) });
-            if (!r.ok)
-                throw new Error(await why(r));
-            const made = (await r.json().catch(() => null))?.org;
-            if (!made)
-                throw new Error('IAM made no organization. Try again.');
+            const made = await createOrg(named ? display : slug);
             renew();
             await sdk.refreshAccessToken().catch(() => null);
             if (!named) {
-                const p = await fetch(`${api()}/v1/iam/organizations/profile`, {
-                    method: 'POST',
-                    headers: { ...headers, Authorization: `Bearer ${bearer() ?? ''}` },
-                    body: JSON.stringify({ owner: 'admin', name: made, displayName: display }),
+                await setOrganizationProfile('admin', made, { displayName: display }).catch((err) => {
+                    throw new Error(`${made} is made, and it is still called ${made}: ${say(err)}`);
                 });
-                if (!p.ok)
-                    throw new Error(`${made} is made, and it is still called ${made}: ${await why(p)}`);
             }
             // A token that does not carry it yet is minted on the next load, which opens it.
             if (!claimed().includes(made)) {
@@ -714,7 +704,7 @@ function Found({ onClose, onMade }) {
             onMade(made);
         }
         catch (err) {
-            setRefused(err instanceof Error ? err.message : 'Could not create it.');
+            setRefused(say(err));
             setBusy(false);
         }
     };

package/dist/lib/session.d.ts

@@ -129,10 +129,18 @@ export declare function follow(was: string | undefined, moved: () => void): () =
  */
 export declare const DIRECTORIES: readonly string[];
 /**
- * The organizations this person works in, as the token names them: every org of
- * its `orgs` but a directory, which is a home and nobody's tenant. Empty for an
- * account that has not made one: the SDK's own list falls back to the `owner`
- * claim, which is the application's org and nobody's to work in.
+ * The orgs the platform runs under its own names (hanzoai/authz claims.go
+ * `platformOrgs`): the brands and the estate's own namespaces. One is a tenant
+ * only of the people who run it, its owners and admins, and of a SuperAdmin; a
+ * customer who landed in a brand org as a plain member belongs to none of its
+ * data, and cloud refuses every request scoped to it.
+ */
+export declare const PLATFORM: readonly string[];
+/**
+ * The organizations this person works in: the token's `orgs` its claims open
+ * (`opened`). Empty for an account that has not made one, or that is only a plain
+ * member of a brand org: the SDK's own list falls back to the `owner` claim, which
+ * is the application's org and nobody's to work in.
  */
 export declare function orgs(): string[];
 /** The org of the person's own row: the first entry of the token's `orgs`, a directory or not. */

package/dist/lib/session.js

@@ -14,7 +14,7 @@
  * who was signed in, which reads as a permissions problem rather than a typo.
  * Two derivations of one name never agree; this is the one derivation.
  */
-import { superAdmin as sudo } from '@hanzo/iam/browser';
+import { superAdmin as sudoOf } from '@hanzo/iam/browser';
 import { api } from './api.js';
 import { where } from '../where.js';
 /** The SDK's own keys, `hanzo_iam_`-prefixed. The far side of a boundary. */
@@ -323,13 +323,45 @@ function listed(token) {
     return out;
 }
 /**
- * The organizations this person works in, as the token names them: every org of
- * its `orgs` but a directory, which is a home and nobody's tenant. Empty for an
- * account that has not made one: the SDK's own list falls back to the `owner`
- * claim, which is the application's org and nobody's to work in.
+ * The orgs the platform runs under its own names (hanzoai/authz claims.go
+ * `platformOrgs`): the brands and the estate's own namespaces. One is a tenant
+ * only of the people who run it, its owners and admins, and of a SuperAdmin; a
+ * customer who landed in a brand org as a plain member belongs to none of its
+ * data, and cloud refuses every request scoped to it.
+ */
+export const PLATFORM = [
+    'hanzo', 'lux', 'zoo', 'pars', 'platform', 'hanzoai', 'luxfi', 'zooai', 'hanzo-inc', 'hanzo-apps', 'hanzo-community',
+];
+/**
+ * The orgs a token opens to the person it names, home first, each once:
+ * hanzoai/authz `Claims.opens`, the rule cloud scopes every request by. A
+ * directory opens to no one, `admin` to a SuperAdmin, a platform org to its
+ * owners and admins and a SuperAdmin, and any other org to every member.
+ */
+function opened(token) {
+    const c = claimsOf(token);
+    const sudo = sudoOf(c);
+    const set = c?.orgs;
+    const out = [];
+    for (const ref of Array.isArray(set) ? set : []) {
+        const m = ref;
+        const o = m?.org;
+        if (typeof o !== 'string' || !o || out.includes(o) || DIRECTORIES.includes(o))
+            continue;
+        const runs = typeof m?.role === 'string' && ['owner', 'admin'].includes(m.role.trim().toLowerCase());
+        if (o === 'admin' ? sudo : PLATFORM.includes(o) ? sudo || runs : true)
+            out.push(o);
+    }
+    return out;
+}
+/**
+ * The organizations this person works in: the token's `orgs` its claims open
+ * (`opened`). Empty for an account that has not made one, or that is only a plain
+ * member of a brand org: the SDK's own list falls back to the `owner` claim, which
+ * is the application's org and nobody's to work in.
  */
 export function orgs() {
-    return listed(bearer()).filter((o) => !DIRECTORIES.includes(o));
+    return opened(bearer());
 }
 /** The org of the person's own row: the first entry of the token's `orgs`, a directory or not. */
 export function home() {
@@ -452,7 +484,7 @@ export function choose() {
  * organization and the step into one.
  */
 export function superAdmin() {
-    return sudo(claims());
+    return sudoOf(claims());
 }
 /** The organization a SuperAdmin stepped into through IAM, from the token's `assumed` claim, or null. */
 export function assumed() {
@@ -488,7 +520,7 @@ export async function support(org) {
         throw new Error(body?.msg || `IAM answered ${res.status}.`);
     tokens().setItem(ACCESS, next);
     tokens().setItem(EXPIRES, String(exp * 1000));
-    pick(org ?? listed(next).find((o) => !DIRECTORIES.includes(o)) ?? '');
+    pick(org ?? opened(next)[0] ?? '');
     window.location.reload();
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hanzo/rooms",
-  "version": "0.1.85",
+  "version": "0.1.86",
   "description": "The workspace rooms — Home, Chat, Inbox, Contacts, Meet, Cal, Drive, Board, Work, Bots — and the frame that holds them, once, for every Hanzo surface.",
   "type": "module",
   "main": "./dist/index.js",