@dxos/plugin-client 0.8.4-main.84f28bd → 0.8.4-main.9735255

package/src/capabilities/intent-resolver.ts

@@ -1,250 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { pipe } from 'effect';
-
-import {
-  Capabilities,
-  chain,
-  contributes,
-  createIntent,
-  createResolver,
-  LayoutAction,
-  type PluginContext,
-} from '@dxos/app-framework';
-import { invariant } from '@dxos/invariant';
-import { ObservabilityAction } from '@dxos/plugin-observability/types';
-import { PublicKey } from '@dxos/react-client';
-import { type JoinPanelProps } from '@dxos/shell/react';
-
-import { ClientCapabilities } from './capabilities';
-import { JOIN_DIALOG, RECOVERY_CODE_DIALOG, RESET_DIALOG } from '../components';
-import { ClientEvents } from '../events';
-import { Account, ClientAction } from '../types';
-
-type IntentResolverOptions = {
-  context: PluginContext;
-  appName?: string;
-};
-
-const RECOVER_IDENTITY_RPC_TIMEOUT = 20_000;
-
-export default ({ context, appName = 'Composer' }: IntentResolverOptions) =>
-  contributes(Capabilities.IntentResolver, [
-    createResolver({
-      intent: ClientAction.CreateIdentity,
-      resolve: async (profile) => {
-        const manager = context.getCapability(Capabilities.PluginManager);
-        const client = context.getCapability(ClientCapabilities.Client);
-        const data = await client.halo.createIdentity(profile);
-        await manager.activate(ClientEvents.IdentityCreated);
-        return {
-          data,
-          intents: [
-            createIntent(ObservabilityAction.SendEvent, {
-              name: 'identity.create',
-            }),
-          ],
-        };
-      },
-    }),
-    createResolver({
-      intent: ClientAction.JoinIdentity,
-      resolve: async (data) => {
-        return {
-          intents: [
-            createIntent(LayoutAction.UpdateDialog, {
-              part: 'dialog',
-              subject: JOIN_DIALOG,
-              options: {
-                blockAlign: 'start',
-                props: {
-                  initialInvitationCode: data.invitationCode,
-                  initialDisposition: 'accept-halo-invitation',
-                },
-              },
-            }),
-          ],
-        };
-      },
-    }),
-    createResolver({
-      intent: ClientAction.ShareIdentity,
-      resolve: async () => {
-        return {
-          intents: [
-            pipe(
-              createIntent(LayoutAction.SwitchWorkspace, {
-                part: 'workspace',
-                subject: Account.id,
-              }),
-              chain(LayoutAction.Open, {
-                part: 'main',
-                subject: [Account.Profile],
-              }),
-            ),
-            createIntent(ObservabilityAction.SendEvent, {
-              name: 'identity.share',
-            }),
-          ],
-        };
-      },
-    }),
-    createResolver({
-      intent: ClientAction.RecoverIdentity,
-      resolve: async () => {
-        return {
-          intents: [
-            createIntent(LayoutAction.UpdateDialog, {
-              part: 'dialog',
-              subject: JOIN_DIALOG,
-              options: {
-                blockAlign: 'start',
-                props: {
-                  initialDisposition: 'recover-identity',
-                } satisfies Partial<JoinPanelProps>,
-              },
-            }),
-          ],
-        };
-      },
-    }),
-    createResolver({
-      intent: ClientAction.ResetStorage,
-      resolve: async (data) => {
-        return {
-          intents: [
-            createIntent(LayoutAction.UpdateDialog, {
-              part: 'dialog',
-              subject: RESET_DIALOG,
-              options: {
-                blockAlign: 'start',
-                props: {
-                  mode: data.mode ?? 'reset storage',
-                },
-              },
-            }),
-          ],
-        };
-      },
-    }),
-    createResolver({
-      intent: ClientAction.CreateAgent,
-      resolve: async () => {
-        const client = context.getCapability(ClientCapabilities.Client);
-        invariant(client.services.services.EdgeAgentService, 'Missing EdgeAgentService');
-        await client.services.services.EdgeAgentService.createAgent(null as any, { timeout: 10_000 });
-      },
-    }),
-    createResolver({
-      intent: ClientAction.CreateRecoveryCode,
-      resolve: async () => {
-        const client = context.getCapability(ClientCapabilities.Client);
-        invariant(client.services.services.IdentityService, 'IdentityService not available');
-        // TODO(wittjosiah): This needs a proper api.
-        const { recoveryCode } = await client.services.services.IdentityService.createRecoveryCredential({});
-        return {
-          intents: [
-            createIntent(LayoutAction.UpdateDialog, {
-              part: 'dialog',
-              subject: RECOVERY_CODE_DIALOG,
-              options: {
-                blockAlign: 'start',
-                type: 'alert',
-                props: { code: recoveryCode },
-              },
-            }),
-          ],
-        };
-      },
-    }),
-    createResolver({
-      intent: ClientAction.CreatePasskey,
-      resolve: async () => {
-        const client = context.getCapability(ClientCapabilities.Client);
-        const identity = client.halo.identity.get();
-        invariant(identity, 'Identity not available');
-
-        // TODO(wittjosiah): Consider factoring out passkey creation to the halo api.
-        const lookupKey = PublicKey.random();
-        const credential = await navigator.credentials.create({
-          publicKey: {
-            challenge: new Uint8Array(),
-            rp: { id: location.hostname, name: appName },
-            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,
-            },
-          },
-        });
-
-        invariant(credential, 'Credential not available');
-        const recoveryKey = PublicKey.from(new Uint8Array((credential as any).response.getPublicKey()));
-        const algorithm = (credential as any).response.getPublicKeyAlgorithm() === -7 ? 'ES256' : 'ED25519';
-
-        // TODO(wittjosiah): This needs a proper api.
-        invariant(client.services.services.IdentityService, 'IdentityService not available');
-        await client.services.services.IdentityService.createRecoveryCredential({
-          data: {
-            recoveryKey,
-            algorithm,
-            lookupKey,
-          },
-        });
-      },
-    }),
-    createResolver({
-      intent: ClientAction.RedeemPasskey,
-      resolve: async () => {
-        const client = context.getCapability(ClientCapabilities.Client);
-        // TODO(wittjosiah): This needs a proper api.
-        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,
-            userVerification: 'required',
-          },
-        });
-        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),
-            },
-          },
-          { timeout: RECOVER_IDENTITY_RPC_TIMEOUT },
-        );
-      },
-    }),
-    createResolver({
-      intent: ClientAction.RedeemToken,
-      resolve: async (data) => {
-        const client = context.getCapability(ClientCapabilities.Client);
-        // TODO(wittjosiah): This needs a proper api.
-        invariant(client.services.services.IdentityService, 'IdentityService not available');
-        await client.services.services.IdentityService.recoverIdentity(
-          { token: data.token },
-          { timeout: RECOVER_IDENTITY_RPC_TIMEOUT },
-        );
-      },
-    }),
-  ]);

package/src/capabilities/migrations.ts

@@ -1,25 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Capabilities, contributes, type PluginContext } from '@dxos/app-framework';
-
-import { ClientCapabilities } from './capabilities';
-
-export default (context: PluginContext) => {
-  const registry = context.getCapability(Capabilities.RxRegistry);
-  const client = context.getCapability(ClientCapabilities.Client);
-
-  // NOTE: Migrations are currently unidirectional and idempotent.
-  const cancel = registry.subscribe(
-    context.capabilities(ClientCapabilities.Migration),
-    (_migrations) => {
-      const migrations = Array.from(new Set(_migrations.flat()));
-      const spaces = client.spaces.get();
-      void Promise.all(spaces.map((space) => space.db.runMigrations(migrations)));
-    },
-    { immediate: true },
-  );
-
-  return contributes(Capabilities.Null, null, () => cancel());
-};

package/src/capabilities/react-context.tsx

@@ -1,20 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import React from 'react';
-
-import { Capabilities, contributes, useCapability } from '@dxos/app-framework';
-import { ClientProvider } from '@dxos/react-client';
-
-import { ClientCapabilities } from './capabilities';
-import { CLIENT_PLUGIN } from '../meta';
-
-export default () =>
-  contributes(Capabilities.ReactContext, {
-    id: CLIENT_PLUGIN,
-    context: ({ children }) => {
-      const client = useCapability(ClientCapabilities.Client);
-      return <ClientProvider client={client}>{children}</ClientProvider>;
-    },
-  });

package/src/capabilities/react-surface.tsx

@@ -1,67 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import React from 'react';
-
-import { createSurface, Capabilities, contributes } from '@dxos/app-framework';
-import { type JoinPanelProps } from '@dxos/shell/react';
-
-import {
-  DevicesContainer,
-  JOIN_DIALOG,
-  JoinDialog,
-  ProfileContainer,
-  RECOVERY_CODE_DIALOG,
-  RecoveryCodeDialog,
-  RecoveryCredentialsContainer,
-  RESET_DIALOG,
-  ResetDialog,
-  type ResetDialogProps,
-  type RecoveryCodeDialogProps,
-} from '../components';
-import { Account, type ClientPluginOptions } from '../types';
-
-type ReactSurfaceOptions = Pick<ClientPluginOptions, 'onReset'> & {
-  createInvitationUrl: (invitationCode: string) => string;
-};
-
-export default ({ createInvitationUrl, onReset }: ReactSurfaceOptions) =>
-  contributes(Capabilities.ReactSurface, [
-    createSurface({
-      id: Account.Profile,
-      role: 'article',
-      filter: (data): data is any => data.subject === Account.Profile,
-      component: () => <ProfileContainer />,
-    }),
-    createSurface({
-      id: Account.Devices,
-      role: 'article',
-      filter: (data): data is any => data.subject === Account.Devices,
-      component: ({ data }) => <DevicesContainer createInvitationUrl={createInvitationUrl} />,
-    }),
-    createSurface({
-      id: Account.Security,
-      role: 'article',
-      filter: (data): data is any => data.subject === Account.Security,
-      component: () => <RecoveryCredentialsContainer />,
-    }),
-    createSurface({
-      id: JOIN_DIALOG,
-      role: 'dialog',
-      filter: (data): data is { props: JoinPanelProps } => data.component === JOIN_DIALOG,
-      component: ({ data }) => <JoinDialog {...data.props} />,
-    }),
-    createSurface({
-      id: RECOVERY_CODE_DIALOG,
-      role: 'dialog',
-      filter: (data): data is { props: RecoveryCodeDialogProps } => data.component === RECOVERY_CODE_DIALOG,
-      component: ({ data }) => <RecoveryCodeDialog {...data.props} />,
-    }),
-    createSurface({
-      id: RESET_DIALOG,
-      role: 'dialog',
-      filter: (data): data is { props: ResetDialogProps } => data.component === RESET_DIALOG,
-      component: ({ data }) => <ResetDialog {...data.props} onReset={onReset} />,
-    }),
-  ]);

package/src/capabilities/schema-defs.ts

@@ -1,29 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Capabilities, contributes, type PluginContext } from '@dxos/app-framework';
-import { type TypedObject } from '@dxos/echo-schema';
-
-import { ClientCapabilities } from './capabilities';
-
-export default (context: PluginContext) => {
-  const registry = context.getCapability(Capabilities.RxRegistry);
-  const client = context.getCapability(ClientCapabilities.Client);
-
-  // TODO(wittjosiah): Unregister schemas when they are disabled.
-  let previous: TypedObject[] = [];
-  const cancel = registry.subscribe(
-    context.capabilities(ClientCapabilities.Schema),
-    (_schemas) => {
-      const schemas = Array.from(new Set(_schemas.flat()));
-      // TODO(wittjosiah): Filter out schemas which the client has already registered.
-      const newSchemas = schemas.filter((schema) => !previous.includes(schema));
-      previous = schemas;
-      client.addTypes(newSchemas);
-    },
-    { immediate: true },
-  );
-
-  return contributes(Capabilities.Null, null, () => cancel());
-};

package/src/events.ts

@@ -1,15 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { defineEvent } from '@dxos/app-framework';
-
-import { CLIENT_PLUGIN } from './meta';
-
-export namespace ClientEvents {
-  export const ClientReady = defineEvent(`${CLIENT_PLUGIN}/event/client-ready`);
-  export const SetupSchema = defineEvent(`${CLIENT_PLUGIN}/event/setup-schema`);
-  export const SetupMigration = defineEvent(`${CLIENT_PLUGIN}/event/setup-migration`);
-  export const IdentityCreated = defineEvent(`${CLIENT_PLUGIN}/event/identity-created`);
-  export const SpacesReady = defineEvent(`${CLIENT_PLUGIN}/event/spaces-ready`);
-}

package/src/types.ts

@@ -1,131 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { Schema } from 'effect';
-
-import { type PluginContext } from '@dxos/app-framework';
-import { type Client, PublicKey, type ClientOptions } from '@dxos/react-client';
-import { type MaybePromise } from '@dxos/util';
-
-import { CLIENT_PLUGIN } from './meta';
-
-// TODO(wittjosiah): Factor out. Generate?
-const IdentitySchema = Schema.Struct({
-  identityKey: Schema.instanceOf(PublicKey),
-  spaceKey: Schema.optional(Schema.instanceOf(PublicKey)),
-  profile: Schema.optional(
-    Schema.Struct({
-      displayName: Schema.optional(Schema.String),
-      avatarCid: Schema.optional(Schema.String),
-      data: Schema.optional(Schema.Record({ key: Schema.String, value: Schema.Any })),
-    }),
-  ),
-});
-
-const CLIENT_ACTION = `${CLIENT_PLUGIN}/action`;
-export namespace ClientAction {
-  const ProfileSchema = Schema.Struct({
-    displayName: Schema.optional(Schema.String),
-    avatarCid: Schema.optional(Schema.String),
-    data: Schema.optional(Schema.Record({ key: Schema.String, value: Schema.Any })),
-  });
-
-  export class CreateIdentity extends Schema.TaggedClass<CreateIdentity>()(`${CLIENT_ACTION}/create-identity`, {
-    input: ProfileSchema,
-    output: IdentitySchema,
-  }) {}
-
-  export class JoinIdentity extends Schema.TaggedClass<JoinIdentity>()(`${CLIENT_ACTION}/join-identity`, {
-    input: Schema.Struct({
-      invitationCode: Schema.optional(Schema.String),
-    }),
-    output: Schema.Void,
-  }) {}
-
-  export class ShareIdentity extends Schema.TaggedClass<ShareIdentity>()(`${CLIENT_ACTION}/share-identity`, {
-    input: Schema.Void,
-    output: Schema.Void,
-  }) {}
-
-  export class RecoverIdentity extends Schema.TaggedClass<RecoverIdentity>()(`${CLIENT_ACTION}/recover-identity`, {
-    input: Schema.Void,
-    output: Schema.Void,
-  }) {}
-
-  export class ResetStorage extends Schema.TaggedClass<ResetStorage>()(`${CLIENT_ACTION}/reset-storage`, {
-    input: Schema.Struct({
-      mode: Schema.optional(Schema.String),
-    }),
-    output: Schema.Void,
-  }) {}
-
-  export class CreateAgent extends Schema.TaggedClass<CreateAgent>()(`${CLIENT_ACTION}/create-agent`, {
-    input: Schema.Void,
-    output: Schema.Void,
-  }) {}
-
-  export class CreateRecoveryCode extends Schema.TaggedClass<CreateRecoveryCode>()(
-    `${CLIENT_ACTION}/create-recovery-code`,
-    {
-      input: Schema.Void,
-      output: Schema.Void,
-    },
-  ) {}
-
-  export class CreatePasskey extends Schema.TaggedClass<CreatePasskey>()(`${CLIENT_ACTION}/create-passkey`, {
-    input: Schema.Void,
-    output: Schema.Void,
-  }) {}
-
-  export class RedeemPasskey extends Schema.TaggedClass<RedeemPasskey>()(`${CLIENT_ACTION}/redeem-passkey`, {
-    input: Schema.Void,
-    output: Schema.Void,
-  }) {}
-
-  export class RedeemToken extends Schema.TaggedClass<RedeemToken>()(`${CLIENT_ACTION}/redeem-token`, {
-    input: Schema.Struct({
-      token: Schema.String,
-    }),
-    output: Schema.Void,
-  }) {}
-}
-
-export type ClientPluginOptions = ClientOptions & {
-  /**
-   * Base URL for the invitation link.
-   */
-  invitationUrl?: string;
-
-  /**
-   * Query parameter for the invitation code.
-   */
-  invitationParam?: string;
-
-  /**
-   * Run after the client has been initialized.
-   */
-  onClientInitialized?: (context: PluginContext, client: Client) => MaybePromise<void>;
-
-  /**
-   * Called when spaces are ready.
-   */
-  onSpacesReady?: (context: PluginContext, client: Client) => MaybePromise<void>;
-
-  /**
-   * Called when the client is reset.
-   */
-  onReset?: (params: { target?: string }) => MaybePromise<void>;
-};
-
-export namespace Account {
-  // TODO(wittjosiah): Cannot use slashes in ids until we have a router which decouples ids from url paths.
-  const _id = 'dxos.org.plugin.client.account';
-  // TODO(wittjosiah): This is a hack to prevent the previous deck from being set for pinned items.
-  //  Ideally this should be worked into the data model in a generic way.
-  export const id = `!${_id}`;
-
-  export const Profile = `${_id}.profile`;
-  export const Devices = `${_id}.devices`;
-  export const Security = `${_id}.security`;
-}