@dxos/react-client 0.7.5-labs.e27f9b9 → 0.7.5-labs.f400bbc

package/src/echo/useSchema.ts

@@ -0,0 +1,39 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { useMemo, useSyncExternalStore } from 'react';
+
+import { type Space } from '@dxos/client/echo';
+import { type EchoSchema } from '@dxos/echo-schema';
+
+/**
+ * Subscribe to and retrieve schema changes from a space's schema registry.
+ */
+export const useSchema = (space: Space | undefined, typename: string | undefined): EchoSchema | undefined => {
+  const { subscribe, getSchema } = useMemo(() => {
+    if (!typename || !space) {
+      return {
+        subscribe: () => () => {},
+        getSchema: () => undefined,
+      };
+    }
+
+    const query = space.db.schemaRegistry.query({ typename });
+    const initialResult = query.runSync()[0];
+    let currentSchema = initialResult;
+
+    return {
+      subscribe: (onStoreChange: () => void) => {
+        const unsubscribe = query.subscribe(() => {
+          currentSchema = query.results[0];
+          onStoreChange();
+        });
+        return unsubscribe;
+      },
+      getSchema: () => currentSchema,
+    };
+  }, [typename, space]);
+
+  return useSyncExternalStore(subscribe, getSchema);
+};

package/src/halo/Passkey.stories.tsx

@@ -8,6 +8,7 @@ import React, { useCallback } from 'react';
 
 import { Config, PublicKey } from '@dxos/client';
 import { invariant } from '@dxos/invariant';
+import { log } from '@dxos/log';
 import { Button } from '@dxos/react-ui';
 import { SyntaxHighlighter } from '@dxos/react-ui-syntax-highlighter';
 import { withTheme } from '@dxos/storybook-utils';
@@ -24,54 +25,80 @@ const Test = () => {
   const identity = useIdentity();
   const credentials = useCredentials();
 
-  const handleCreateIdentity = useCallback(() => client.halo.createIdentity(), [client]);
+  const handleCreateIdentity = useCallback(async () => {
+    await client.halo.createIdentity();
+    invariant(client.services.services.EdgeAgentService, 'Missing EdgeAgentService');
+    await client.services.services.EdgeAgentService.createAgent(null as any, { timeout: 10_000 });
+  }, [client]);
+
   // TODO(wittjosiah): Consider factoring out passkey creation to the halo api.
   const handleCreatePassKey = useCallback(async () => {
     invariant(identity, 'Identity not available');
     const challenge = getNewChallenge();
-    const credential = await navigator.credentials.create({
-      publicKey: {
-        challenge: new TextEncoder().encode(challenge),
-        rp: { id: 'localhost', name: 'Test' },
-        user: {
-          id: new TextEncoder().encode(identity.did),
-          name: identity.did,
-          displayName: identity.profile?.displayName ?? '',
+    const lookupKey = PublicKey.random();
+    // https://developer.mozilla.org/en-US/docs/Web/API/PublicKeyCredentialCreationOptions
+    const credential = await navigator.credentials
+      .create({
+        publicKey: {
+          challenge: new TextEncoder().encode(challenge),
+          rp: { id: location.hostname, name: 'Test' },
+          user: {
+            id: lookupKey.asUint8Array(),
+            name: identity.did,
+            displayName: identity.profile?.displayName ?? '',
+          },
+          pubKeyCredParams: [
+            { type: 'public-key', alg: -8 }, // Ed25519 (not yet supported across all browsers)
+            { type: 'public-key', alg: -7 }, // ES256
+          ],
+          // https://web.dev/articles/webauthn-discoverable-credentials#resident-key
+          authenticatorSelection: {
+            residentKey: 'required',
+            requireResidentKey: true,
+          },
         },
-        pubKeyCredParams: [
-          { type: 'public-key', alg: -8 }, // Ed25519 (not yet supported across all browsers)
-          { type: 'public-key', alg: -7 }, // ES256
-        ],
-      },
-    });
+      })
+      .catch(log.error);
 
     invariant(credential, 'Credential not available');
     const recoveryKey = PublicKey.from(new Uint8Array((credential as any).response.getPublicKey()));
-    const algorithm: number = (credential as any).response.getPublicKeyAlgorithm();
+    const algorithm = (credential as any).response.getPublicKeyAlgorithm() === -7 ? 'ES256' : 'ED25519';
 
     invariant(client.services.services.IdentityService, 'IdentityService not available');
     // TODO(wittjosiah): This needs a proper api.
     await client.services.services.IdentityService.createRecoveryCredential({
       recoveryKey,
       algorithm,
+      lookupKey,
     });
   }, [client, identity]);
 
   const handleAuthenticate = useCallback(async () => {
-    // TODO(wittjosiah): This should come from edge.
-    const challenge = getNewChallenge();
-    const credential = await navigator.credentials.get({
-      publicKey: {
-        challenge: new TextEncoder().encode(challenge),
-        rpId: 'localhost',
-        // NOTE: Don't prompt for password in storybook for test purposes.
-        //   In practice, this should be set to 'required' for identity recovery.
-        userVerification: 'discouraged',
+    invariant(client.services.services.IdentityService, 'IdentityService not available');
+    const { deviceKey, controlFeedKey, challenge } =
+      await client.services.services.IdentityService.requestRecoveryChallenge();
+    const credential = await navigator.credentials
+      .get({
+        publicKey: {
+          challenge: Buffer.from(challenge, 'base64'),
+          rpId: location.hostname,
+          // NOTE: Don't prompt for password in storybook for test purposes.
+          //   In practice, this should be set to 'required' for identity recovery.
+          userVerification: 'discouraged',
+        },
+      })
+      .catch(log.error);
+    const lookupKey = PublicKey.from(new Uint8Array((credential as any).response.userHandle));
+    await client.services.services.IdentityService.recoverIdentity({
+      external: {
+        lookupKey,
+        deviceKey,
+        controlFeedKey,
+        signature: Buffer.from((credential as any).response.signature),
+        clientDataJson: Buffer.from((credential as any).response.clientDataJSON),
+        authenticatorData: Buffer.from((credential as any).response.authenticatorData),
       },
     });
-    const did = new TextDecoder().decode((credential as any).response.userHandle);
-    console.log({ credential, did });
-    // TODO(wittjosiah): Send signature to edge for verification and admission.
   }, []);
 
   return (
@@ -113,9 +140,10 @@ const config = new Config({
     },
     services: {
       edge: {
-        url: 'wss://edge.dxos.workers.dev/',
+        url: 'wss://edge-main.dxos.workers.dev/',
+        // url: 'ws://localhost:8787',
       },
-      iceProviders: [{ urls: 'https://edge.dxos.workers.dev/ice' }],
+      iceProviders: [{ urls: 'https://edge-production.dxos.workers.dev/ice' }],
     },
   },
 });

package/tsconfig.json

@@ -1,13 +1,7 @@
 {
   "extends": "../../../tsconfig.base.json",
   "compilerOptions": {
-    "jsx": "react",
-    "lib": [
-      "DOM",
-      "ESNext"
-    ],
-    "module": "ESNext",
-    "outDir": "./dist/types"
+    "module": "ESNext"
   },
   "include": [
     "playwright",

package/dist/types/src/playwright/playwright.config.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"playwright.config.d.ts","sourceRoot":"","sources":["../../../../src/playwright/playwright.config.ts"],"names":[],"mappings":";AASA,wBAQG"}