@dxos/plugin-client 0.7.4 → 0.7.5-labs.071a3e2

package/dist/types/src/types.d.ts

@@ -0,0 +1,98 @@
+import { type PluginsContext } from '@dxos/app-framework';
+import { S } from '@dxos/echo-schema';
+import { type Client, PublicKey, type ClientOptions } from '@dxos/react-client';
+import { type MaybePromise } from '@dxos/util';
+export declare namespace ClientAction {
+    const CreateIdentity_base: S.TaggedClass<CreateIdentity, "dxos.org/plugin/client/action/create-identity", {
+        readonly _tag: S.tag<"dxos.org/plugin/client/action/create-identity">;
+    } & {
+        input: S.Struct<{
+            displayName: S.optional<typeof S.String>;
+        }>;
+        output: S.Struct<{
+            identityKey: S.instanceOf<PublicKey>;
+            spaceKey: S.optional<S.instanceOf<PublicKey>>;
+            profile: S.optional<S.Struct<{
+                displayName: S.optional<typeof S.String>;
+                avatarCid: S.optional<typeof S.String>;
+                data: S.optional<S.Record$<typeof S.String, typeof S.Any>>;
+            }>>;
+        }>;
+    }>;
+    export class CreateIdentity extends CreateIdentity_base {
+    }
+    const JoinIdentity_base: S.TaggedClass<JoinIdentity, "dxos.org/plugin/client/action/join-identity", {
+        readonly _tag: S.tag<"dxos.org/plugin/client/action/join-identity">;
+    } & {
+        input: S.Struct<{
+            invitationCode: typeof S.String;
+        }>;
+        output: typeof S.Void;
+    }>;
+    export class JoinIdentity extends JoinIdentity_base {
+    }
+    const ShareIdentity_base: S.TaggedClass<ShareIdentity, "dxos.org/plugin/client/action/share-identity", {
+        readonly _tag: S.tag<"dxos.org/plugin/client/action/share-identity">;
+    } & {
+        input: typeof S.Void;
+        output: typeof S.Void;
+    }>;
+    export class ShareIdentity extends ShareIdentity_base {
+    }
+    const RecoverIdentity_base: S.TaggedClass<RecoverIdentity, "dxos.org/plugin/client/action/recover-identity", {
+        readonly _tag: S.tag<"dxos.org/plugin/client/action/recover-identity">;
+    } & {
+        input: typeof S.Void;
+        output: typeof S.Void;
+    }>;
+    export class RecoverIdentity extends RecoverIdentity_base {
+    }
+    const ResetStorage_base: S.TaggedClass<ResetStorage, "dxos.org/plugin/client/action/reset-storage", {
+        readonly _tag: S.tag<"dxos.org/plugin/client/action/reset-storage">;
+    } & {
+        input: S.Struct<{
+            target: S.optional<typeof S.String>;
+        }>;
+        output: typeof S.Void;
+    }>;
+    export class ResetStorage extends ResetStorage_base {
+    }
+    const CreateAgent_base: S.TaggedClass<CreateAgent, "dxos.org/plugin/client/action/create-agent", {
+        readonly _tag: S.tag<"dxos.org/plugin/client/action/create-agent">;
+    } & {
+        input: typeof S.Void;
+        output: typeof S.Void;
+    }>;
+    export class CreateAgent extends CreateAgent_base {
+    }
+    const CreateRecoveryCode_base: S.TaggedClass<CreateRecoveryCode, "dxos.org/plugin/client/action/create-recovery-code", {
+        readonly _tag: S.tag<"dxos.org/plugin/client/action/create-recovery-code">;
+    } & {
+        input: typeof S.Void;
+        output: typeof S.Void;
+    }>;
+    export class CreateRecoveryCode extends CreateRecoveryCode_base {
+    }
+    export {};
+}
+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: PluginsContext, client: Client) => MaybePromise<void>;
+    /**
+     * Called when the client is reset.
+     */
+    onReset?: (params: {
+        target?: string;
+    }) => MaybePromise<void>;
+};
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/types.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AACtC,OAAO,EAAE,KAAK,MAAM,EAAE,SAAS,EAAE,KAAK,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAChF,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AAkB/C,yBAAiB,YAAY,CAAC;;;;;;;;;;;;;;;;;IAC5B,MAAM,OAAO,cAAe,SAAQ,mBAKlC;KAAG;;;;;;;;;IAEL,MAAM,OAAO,YAAa,SAAQ,iBAKhC;KAAG;;;;;;;IAEL,MAAM,OAAO,aAAc,SAAQ,kBAGjC;KAAG;;;;;;;IAEL,MAAM,OAAO,eAAgB,SAAQ,oBAGnC;KAAG;;;;;;;;;IAEL,MAAM,OAAO,YAAa,SAAQ,iBAKhC;KAAG;;;;;;;IAEL,MAAM,OAAO,WAAY,SAAQ,gBAG/B;KAAG;;;;;;;IAEL,MAAM,OAAO,kBAAmB,SAAQ,uBAGtC;KAAG;;CACN;AAED,MAAM,MAAM,mBAAmB,GAAG,aAAa,GAAG;IAChD;;OAEG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IAEvB;;OAEG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IAEzB;;OAEG;IACH,mBAAmB,CAAC,EAAE,CAAC,OAAO,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,KAAK,YAAY,CAAC,IAAI,CAAC,CAAC;IAEtF;;OAEG;IACH,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE;QAAE,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,YAAY,CAAC,IAAI,CAAC,CAAC;CAC/D,CAAC"}

package/dist/types/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"version":"5.7.3"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/plugin-client",
-  "version": "0.7.4",
+  "version": "0.7.5-labs.071a3e2",
   "description": "DXOS Surface plugin for DXOS Client",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -13,17 +13,17 @@
       "browser": "./dist/lib/browser/index.mjs",
       "node": "./dist/lib/node-esm/index.mjs"
     },
-    "./meta": {
-      "types": "./dist/types/src/meta.d.ts",
-      "browser": "./dist/lib/browser/meta.mjs",
-      "node": "./dist/lib/node-esm/meta.mjs"
+    "./types": {
+      "types": "./dist/types/src/types.d.ts",
+      "browser": "./dist/lib/browser/types.mjs",
+      "node": "./dist/lib/node-esm/types.mjs"
     }
   },
   "types": "dist/types/src/index.d.ts",
   "typesVersions": {
     "*": {
-      "meta": [
-        "dist/types/src/meta.d.ts"
+      "types": [
+        "dist/types/src/types.d.ts"
       ]
     }
   },
@@ -32,26 +32,29 @@
     "src"
   ],
   "dependencies": {
-    "@phosphor-icons/react": "^2.1.5",
-    "@dxos/config": "0.7.4",
-    "@dxos/echo-schema": "0.7.4",
-    "@dxos/echo-signals": "0.7.4",
-    "@dxos/app-framework": "0.7.4",
-    "@dxos/local-storage": "0.7.4",
-    "@dxos/log": "0.7.4",
-    "@dxos/invariant": "0.7.4",
-    "@dxos/plugin-graph": "0.7.4",
-    "@dxos/react-client": "0.7.4",
-    "@dxos/react-ui": "0.7.4",
-    "@dxos/shell": "0.7.4"
+    "@preact/signals-core": "^1.6.0",
+    "@dxos/app-framework": "0.7.5-labs.071a3e2",
+    "@dxos/config": "0.7.5-labs.071a3e2",
+    "@dxos/invariant": "0.7.5-labs.071a3e2",
+    "@dxos/echo-signals": "0.7.5-labs.071a3e2",
+    "@dxos/local-storage": "0.7.5-labs.071a3e2",
+    "@dxos/echo-schema": "0.7.5-labs.071a3e2",
+    "@dxos/log": "0.7.5-labs.071a3e2",
+    "@dxos/plugin-graph": "0.7.5-labs.071a3e2",
+    "@dxos/plugin-observability": "0.7.5-labs.071a3e2",
+    "@dxos/react-ui": "0.7.5-labs.071a3e2",
+    "@dxos/react-client": "0.7.5-labs.071a3e2",
+    "@dxos/shell": "0.7.5-labs.071a3e2",
+    "@dxos/util": "0.7.5-labs.071a3e2"
   },
   "devDependencies": {
+    "@phosphor-icons/react": "^2.1.5",
     "@types/react": "~18.2.0",
     "@types/react-dom": "~18.2.0",
     "react": "~18.2.0",
     "react-dom": "~18.2.0",
     "vite": "5.4.7",
-    "@dxos/storybook-utils": "0.7.4"
+    "@dxos/storybook-utils": "0.7.5-labs.071a3e2"
   },
   "peerDependencies": {
     "@phosphor-icons/react": "^2.1.5",

package/src/ClientPlugin.ts

@@ -0,0 +1,64 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capabilities, contributes, defineModule, definePlugin, Events, oneOf } from '@dxos/app-framework';
+
+import { Client, AppGraphBuilder, IntentResolver, ReactContext, ReactSurface, Schema } from './capabilities';
+import { ClientEvents } from './events';
+import { meta } from './meta';
+import translations from './translations';
+import { type ClientPluginOptions } from './types';
+
+export const ClientPlugin = ({
+  invitationUrl = window.location.origin,
+  invitationParam = 'deviceInvitationCode',
+  onReset,
+  ...options
+}: ClientPluginOptions) => {
+  const createInvitationUrl = (invitationCode: string) => {
+    const baseUrl = new URL(invitationUrl);
+    baseUrl.searchParams.set(invitationParam, invitationCode);
+    return baseUrl.toString();
+  };
+
+  return definePlugin(meta, [
+    defineModule({
+      id: `${meta.id}/module/client`,
+      activatesOn: oneOf(Events.Startup, Events.SetupAppGraph),
+      activatesAfter: [ClientEvents.ClientReady],
+      activate: (context) => Client({ ...options, context }),
+    }),
+    defineModule({
+      id: `${meta.id}/module/schema`,
+      activatesOn: ClientEvents.ClientReady,
+      activatesBefore: [ClientEvents.SetupSchema],
+      activate: Schema,
+    }),
+    defineModule({
+      id: `${meta.id}/module/react-context`,
+      activatesOn: Events.Startup,
+      activate: ReactContext,
+    }),
+    defineModule({
+      id: `${meta.id}/module/react-surface`,
+      activatesOn: Events.SetupSurfaces,
+      activate: () => ReactSurface({ createInvitationUrl }),
+    }),
+    defineModule({
+      id: `${meta.id}/module/app-graph-builder`,
+      activatesOn: Events.SetupAppGraph,
+      activate: AppGraphBuilder,
+    }),
+    defineModule({
+      id: `${meta.id}/module/intent-resolver`,
+      activatesOn: Events.SetupIntents,
+      activate: (context) => IntentResolver({ context, onReset }),
+    }),
+    defineModule({
+      id: `${meta.id}/module/translations`,
+      activatesOn: Events.SetupTranslations,
+      activate: () => contributes(Capabilities.Translations, translations),
+    }),
+  ]);
+};

package/src/capabilities/app-graph-builder.ts

@@ -0,0 +1,39 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { createIntent } from '@dxos/app-framework';
+import { Capabilities, contributes, type PluginsContext } from '@dxos/app-framework';
+import { createExtension, type Node } from '@dxos/plugin-graph';
+
+import { CLIENT_PLUGIN } from '../meta';
+import { ClientAction } from '../types';
+
+export default (context: PluginsContext) =>
+  contributes(
+    Capabilities.AppGraphBuilder,
+    createExtension({
+      id: CLIENT_PLUGIN,
+      filter: (node): node is Node<null> => node.id === 'root',
+      actions: () => [
+        {
+          id: `${CLIENT_PLUGIN}/open-shell`,
+          data: async () => {
+            const { dispatchPromise: dispatch } = context.requestCapability(Capabilities.IntentDispatcher);
+            await dispatch(createIntent(ClientAction.ShareIdentity));
+          },
+          properties: {
+            label: ['open shell label', { ns: CLIENT_PLUGIN }],
+            icon: 'ph--address-book--regular',
+            keyBinding: {
+              macos: 'meta+shift+.',
+              // TODO(wittjosiah): Test on windows to see if it behaves the same as linux.
+              windows: 'alt+shift+.',
+              linux: 'alt+shift+>',
+            },
+            testId: 'clientPlugin.openShell',
+          },
+        },
+      ],
+    }),
+  );

package/src/capabilities/capabilities.ts

@@ -0,0 +1,16 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { defineCapability } from '@dxos/app-framework';
+import { type TypedObject } from '@dxos/echo-schema';
+import { type Client } from '@dxos/react-client';
+
+import { CLIENT_PLUGIN } from '../meta';
+
+export namespace ClientCapabilities {
+  export const Client = defineCapability<Client>(`${CLIENT_PLUGIN}/capability/client`);
+  export const Schema = defineCapability<TypedObject[]>(`${CLIENT_PLUGIN}/capability/schema`);
+  // TODO(wittjosiah): Rename this. Reserve "system" nomenclature for internal use.
+  export const SystemSchema = defineCapability<TypedObject[]>(`${CLIENT_PLUGIN}/capability/system-schema`);
+}

package/src/capabilities/client.ts

@@ -0,0 +1,42 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { contributes, type PluginsContext } from '@dxos/app-framework';
+import { Config, Defaults, Envs, Local, Storage } from '@dxos/config';
+import { Client } from '@dxos/react-client';
+
+import { ClientCapabilities } from './capabilities';
+import { ClientEvents } from '../events';
+import { type ClientPluginOptions } from '../types';
+
+type ClientCapabilityOptions = Omit<ClientPluginOptions, 'appKey' | 'invitationUrl' | 'invitationParam' | 'onReset'> & {
+  context: PluginsContext;
+};
+
+export default async ({ context, onClientInitialized, ...options }: ClientCapabilityOptions) => {
+  const config = new Config(await Storage(), Envs(), Local(), Defaults());
+  const client = new Client({ config, ...options });
+  await client.initialize();
+  await onClientInitialized?.(context, client);
+
+  // TODO(wittjosiah): Remove. This is a hack to get the app to boot with the new identity after a reset.
+  client.reloaded.on(() => {
+    client.halo.identity.subscribe(async (identity) => {
+      if (identity) {
+        window.location.href = window.location.origin;
+      }
+    });
+  });
+
+  const subscription = client.spaces.isReady.subscribe(async (ready) => {
+    if (ready) {
+      await context.activate(ClientEvents.SpacesReady);
+    }
+  });
+
+  return contributes(ClientCapabilities.Client, client, async () => {
+    subscription.unsubscribe();
+    await client.destroy();
+  });
+};

package/src/capabilities/index.ts

@@ -0,0 +1,14 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { lazy } from '@dxos/app-framework';
+
+export const AppGraphBuilder = lazy(async () => import('./app-graph-builder'));
+export const Client = lazy(async () => import('./client'));
+export const IntentResolver = lazy(async () => import('./intent-resolver'));
+export const ReactContext = lazy(async () => import('./react-context'));
+export const ReactSurface = lazy(async () => import('./react-surface'));
+export const Schema = lazy(async () => import('./schema'));
+
+export * from './capabilities';

package/src/capabilities/intent-resolver.ts

@@ -0,0 +1,130 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import {
+  Capabilities,
+  contributes,
+  createIntent,
+  createResolver,
+  LayoutAction,
+  type PluginsContext,
+} from '@dxos/app-framework';
+import { invariant } from '@dxos/invariant';
+import { ObservabilityAction } from '@dxos/plugin-observability/types';
+import { type JoinPanelProps } from '@dxos/shell/react';
+
+import { ClientCapabilities } from './capabilities';
+import { IDENTITY_DIALOG, JOIN_DIALOG, RECOVER_CODE_DIALOG } from '../components';
+import { ClientEvents } from '../events';
+import { ClientAction, type ClientPluginOptions } from '../types';
+
+type IntentResolverOptions = Pick<ClientPluginOptions, 'onReset'> & {
+  context: PluginsContext;
+};
+
+export default ({ context, onReset }: IntentResolverOptions) =>
+  contributes(Capabilities.IntentResolver, [
+    createResolver({
+      intent: ClientAction.CreateIdentity,
+      resolve: async () => {
+        const manager = context.requestCapability(Capabilities.PluginManager);
+        const client = context.requestCapability(ClientCapabilities.Client);
+        const data = await client.halo.createIdentity();
+        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: [
+            createIntent(LayoutAction.UpdateDialog, {
+              part: 'dialog',
+              subject: IDENTITY_DIALOG,
+              options: {
+                blockAlign: 'start',
+              },
+            }),
+            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) => {
+        await onReset?.({ target: data.target });
+      },
+    }),
+    createResolver({
+      intent: ClientAction.CreateAgent,
+      resolve: async () => {
+        const client = context.requestCapability(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.requestCapability(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: RECOVER_CODE_DIALOG,
+              options: {
+                blockAlign: 'start',
+                type: 'alert',
+                props: { code: recoveryCode },
+              },
+            }),
+          ],
+        };
+      },
+    }),
+  ]);

package/src/capabilities/react-context.tsx

@@ -0,0 +1,20 @@
+//
+// 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

@@ -0,0 +1,44 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React from 'react';
+
+import { createSurface, Capabilities, contributes } from '@dxos/app-framework';
+import { type IdentityPanelProps, type JoinPanelProps } from '@dxos/shell/react';
+
+import {
+  IDENTITY_DIALOG,
+  IdentityDialog,
+  JOIN_DIALOG,
+  JoinDialog,
+  RECOVER_CODE_DIALOG,
+  RecoveryCodeDialog,
+  type RecoveryCodeDialogProps,
+} from '../components';
+
+type ReactSurfaceOptions = {
+  createInvitationUrl: (invitationCode: string) => string;
+};
+
+export default ({ createInvitationUrl }: ReactSurfaceOptions) =>
+  contributes(Capabilities.ReactSurface, [
+    createSurface({
+      id: IDENTITY_DIALOG,
+      role: 'dialog',
+      filter: (data): data is { props: IdentityPanelProps } => data.component === IDENTITY_DIALOG,
+      component: ({ data }) => <IdentityDialog {...data.props} createInvitationUrl={createInvitationUrl} />,
+    }),
+    createSurface({
+      id: JOIN_DIALOG,
+      role: 'dialog',
+      filter: (data): data is { props: JoinPanelProps } => data.component === JOIN_DIALOG,
+      component: ({ data }) => <JoinDialog {...data.props} />,
+    }),
+    createSurface({
+      id: RECOVER_CODE_DIALOG,
+      role: 'dialog',
+      filter: (data): data is { props: RecoveryCodeDialogProps } => data.component === RECOVER_CODE_DIALOG,
+      component: ({ data }) => <RecoveryCodeDialog {...data.props} />,
+    }),
+  ]);

package/src/capabilities/schema.ts

@@ -0,0 +1,36 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { effect } from '@preact/signals-core';
+
+import { Capabilities, contributes, type PluginsContext } from '@dxos/app-framework';
+import { type TypedObject } from '@dxos/echo-schema';
+
+import { ClientCapabilities } from './capabilities';
+
+// TODO(wittjosiah): Remove types?
+export default (context: PluginsContext) => {
+  const client = context.requestCapability(ClientCapabilities.Client);
+
+  let previousSystem: TypedObject[] = [];
+  const unsubscribeSystem = effect(() => {
+    const systemSchemas = Array.from(new Set(context.requestCapabilities(ClientCapabilities.SystemSchema).flat()));
+    const newSchemas = systemSchemas.filter((schema) => !previousSystem.includes(schema));
+    previousSystem = systemSchemas;
+    client.addTypes(newSchemas);
+  });
+
+  let previous: TypedObject[] = [];
+  const unsubscribe = effect(() => {
+    const schemas = Array.from(new Set(context.requestCapabilities(ClientCapabilities.Schema).flat()));
+    const newSchemas = schemas.filter((schema) => !previous.includes(schema));
+    previous = schemas;
+    client.addTypes(newSchemas);
+  });
+
+  return contributes(Capabilities.Null, null, () => {
+    unsubscribeSystem();
+    unsubscribe();
+  });
+};

package/src/components/IdentityDialog.tsx

@@ -4,42 +4,44 @@
 
 import React, { useCallback } from 'react';
 
-import { LayoutAction, useIntentDispatcher } from '@dxos/app-framework';
+import { createIntent, LayoutAction, useIntentDispatcher } from '@dxos/app-framework';
 import { useClient } from '@dxos/react-client';
 import { Clipboard, Dialog } from '@dxos/react-ui';
 import { IdentityPanel, type IdentityPanelProps } from '@dxos/shell/react';
 
-import { ClientAction } from '../meta';
+import { CLIENT_PLUGIN } from '../meta';
+import { ClientAction } from '../types';
+
+export const IDENTITY_DIALOG = `${CLIENT_PLUGIN}/IdentityDialog`;
 
 export const IdentityDialog = (props: IdentityPanelProps) => {
-  const dispatch = useIntentDispatcher();
+  const { dispatchPromise: dispatch } = useIntentDispatcher();
   const client = useClient();
 
   const handleDone = useCallback(
     () =>
-      dispatch({
-        action: LayoutAction.SET_LAYOUT,
-        data: {
-          element: 'dialog',
-          state: false,
-        },
-      }),
+      dispatch(
+        createIntent(LayoutAction.UpdateDialog, {
+          part: 'dialog',
+          options: { state: false },
+        }),
+      ),
     [dispatch],
   );
 
   const handleResetStorage = useCallback(async () => {
     await client.reset();
-    await dispatch({ action: ClientAction.RESET_STORAGE });
+    await dispatch(createIntent(ClientAction.ResetStorage));
   }, [dispatch]);
 
   const handleRecover = useCallback(async () => {
     await client.reset();
-    await dispatch({ action: ClientAction.RESET_STORAGE, data: { target: 'recoverIdentity' } });
+    await dispatch(createIntent(ClientAction.ResetStorage, { target: 'recoverIdentity' }));
   }, [dispatch]);
 
   const handleJoinNewIdentity = useCallback(async () => {
     await client.reset();
-    await dispatch({ action: ClientAction.RESET_STORAGE, data: { target: 'deviceInvitation' } });
+    await dispatch(createIntent(ClientAction.ResetStorage, { target: 'deviceInvitation' }));
   }, [dispatch]);
 
   return (