@dxos/plugin-client 0.7.4-staging.f7e8224 → 0.7.5-feature-compute.4d9d99a

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,15 @@
+//
+// 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`);
+  export const SystemSchema = defineCapability<TypedObject[]>(`${CLIENT_PLUGIN}/capability/system-schema`);
+}

package/src/capabilities/client.ts

@@ -0,0 +1,48 @@
+//
+// 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);
+
+  const systemSchemas = Array.from(new Set(context.requestCapabilities(ClientCapabilities.SystemSchema).flat()));
+  const schemas = Array.from(new Set(context.requestCapabilities(ClientCapabilities.Schema).flat()));
+  client.addTypes(systemSchemas);
+  client.addTypes(schemas);
+
+  // 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,13 @@
+//
+// 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 * from './capabilities';

package/src/capabilities/intent-resolver.ts

@@ -0,0 +1,101 @@
+//
+// 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(ClientAction.CreateIdentity, 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(ClientAction.JoinIdentity, async (data) => {
+      return {
+        intents: [
+          createIntent(LayoutAction.SetLayout, {
+            element: 'dialog',
+            component: JOIN_DIALOG,
+            dialogBlockAlign: 'start',
+            subject: {
+              initialInvitationCode: data.invitationCode,
+              initialDisposition: 'accept-halo-invitation',
+            } satisfies Partial<JoinPanelProps>,
+          }),
+        ],
+      };
+    }),
+    createResolver(ClientAction.ShareIdentity, async () => {
+      return {
+        intents: [
+          createIntent(LayoutAction.SetLayout, {
+            element: 'dialog',
+            component: IDENTITY_DIALOG,
+            dialogBlockAlign: 'start',
+          }),
+          createIntent(ObservabilityAction.SendEvent, { name: 'identity.share' }),
+        ],
+      };
+    }),
+    createResolver(ClientAction.RecoverIdentity, async () => {
+      return {
+        intents: [
+          createIntent(LayoutAction.SetLayout, {
+            element: 'dialog',
+            component: JOIN_DIALOG,
+            dialogBlockAlign: 'start',
+            subject: { initialDisposition: 'recover-identity' } satisfies Partial<JoinPanelProps>,
+          }),
+        ],
+      };
+    }),
+    createResolver(ClientAction.ResetStorage, async (data) => {
+      await onReset?.({ target: data.target });
+      return {};
+    }),
+    createResolver(ClientAction.CreateAgent, 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(ClientAction.CreateRecoveryCode, async () => {
+      const client = context.requestCapability(ClientCapabilities.Client);
+      invariant(client.services.services.IdentityService, 'IdentityService not available');
+      // TODO(wittjosiah): This needs a proper api. Rename property.
+      const { seedphrase } = await client.services.services.IdentityService.createRecoveryPhrase();
+      return {
+        intents: [
+          createIntent(LayoutAction.SetLayout, {
+            element: 'dialog',
+            dialogBlockAlign: 'start',
+            dialogType: 'alert',
+            state: true,
+            component: RECOVER_CODE_DIALOG,
+            subject: { code: seedphrase },
+          }),
+        ],
+      };
+    }),
+  ]);

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 { subject: IdentityPanelProps } => data.component === IDENTITY_DIALOG,
+      component: ({ data }) => <IdentityDialog {...data.subject} createInvitationUrl={createInvitationUrl} />,
+    }),
+    createSurface({
+      id: JOIN_DIALOG,
+      role: 'dialog',
+      filter: (data): data is { subject: JoinPanelProps } => data.component === JOIN_DIALOG,
+      component: ({ data }) => <JoinDialog {...data.subject} />,
+    }),
+    createSurface({
+      id: RECOVER_CODE_DIALOG,
+      role: 'dialog',
+      filter: (data): data is { subject: RecoveryCodeDialogProps } => data.component === RECOVER_CODE_DIALOG,
+      component: ({ data }) => <RecoveryCodeDialog {...data.subject} />,
+    }),
+  ]);

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: {
+      dispatch(
+        createIntent(LayoutAction.SetLayout, {
           element: 'dialog',
           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 (

package/src/components/JoinDialog.tsx

@@ -4,38 +4,32 @@
 
 import React, { useCallback } from 'react';
 
-import { LayoutAction, useIntentDispatcher } from '@dxos/app-framework';
+import { createIntent, LayoutAction, useIntentDispatcher } from '@dxos/app-framework';
+import { ObservabilityAction } from '@dxos/plugin-observability/types';
 import { type InvitationResult } from '@dxos/react-client/invitations';
 import { Dialog } from '@dxos/react-ui';
 import { JoinPanel, type JoinPanelProps } from '@dxos/shell/react';
 
-import { CLIENT_PLUGIN, ClientAction, OBSERVABILITY_ACTION } from '../meta';
+import { CLIENT_PLUGIN } from '../meta';
+import { ClientAction } from '../types';
+
+export const JOIN_DIALOG = `${CLIENT_PLUGIN}/JoinDialog`;
 
 export const JoinDialog = (props: JoinPanelProps) => {
-  const dispatch = useIntentDispatcher();
+  const { dispatchPromise: dispatch } = useIntentDispatcher();
 
-  const handleCancelResetStorage = useCallback(
-    () => dispatch({ plugin: CLIENT_PLUGIN, action: ClientAction.SHARE_IDENTITY }),
-    [dispatch],
-  );
+  const handleCancelResetStorage = useCallback(() => dispatch(createIntent(ClientAction.ShareIdentity)), [dispatch]);
 
   const handleDone = useCallback(
     async (result: InvitationResult | null) => {
       if (result?.identityKey) {
         await Promise.all([
-          dispatch({
-            action: LayoutAction.SET_LAYOUT,
-            data: {
-              element: 'dialog',
-              state: false,
-            },
-          }),
-          dispatch({
-            action: OBSERVABILITY_ACTION,
-            data: {
+          dispatch(createIntent(LayoutAction.SetLayout, { element: 'dialog', state: false })),
+          dispatch(
+            createIntent(ObservabilityAction.SendEvent, {
               name: props.initialDisposition === 'recover-identity' ? 'identity.recover' : 'identity.join',
-            },
-          }),
+            }),
+          ),
         ]);
       }
     },

package/src/components/RecoveryCodeDialog.stories.tsx

@@ -0,0 +1,50 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import '@dxos-theme';
+
+import { type StoryObj, type Meta } from '@storybook/react';
+import React, { useState } from 'react';
+
+import { useClient } from '@dxos/react-client';
+import { withClientProvider } from '@dxos/react-client/testing';
+import { AlertDialog, useAsyncEffect } from '@dxos/react-ui';
+import { withTheme, withLayout } from '@dxos/storybook-utils';
+
+import { RecoveryCodeDialog, type RecoveryCodeDialogProps } from './RecoveryCodeDialog';
+import translations from '../translations';
+
+const Render = () => {
+  const client = useClient();
+  const [seedphrase, setSeedphrase] = useState<string>();
+  useAsyncEffect(async () => {
+    const { seedphrase } = (await client.services.services.IdentityService?.createRecoveryPhrase()) ?? {};
+    setSeedphrase(seedphrase);
+  }, [client]);
+
+  return (
+    <AlertDialog.Root open={!!seedphrase}>
+      <AlertDialog.Overlay>
+        <RecoveryCodeDialog code={seedphrase ?? ''} />
+      </AlertDialog.Overlay>
+    </AlertDialog.Root>
+  );
+};
+
+const meta: Meta<RecoveryCodeDialogProps> = {
+  title: 'plugins/plugin-client/RecoveryCodeDialog',
+  component: RecoveryCodeDialog,
+  render: Render,
+  decorators: [withClientProvider({ createIdentity: true }), withTheme, withLayout({ tooltips: true })],
+  parameters: {
+    layout: 'fullscreen',
+    translations,
+  },
+};
+
+export default meta;
+
+type Story = StoryObj<RecoveryCodeDialogProps>;
+
+export const Default: Story = {};

package/src/components/RecoveryCodeDialog.tsx

@@ -8,6 +8,8 @@ import { AlertDialog, Button, Clipboard, Input, useTranslation } from '@dxos/rea
 
 import { CLIENT_PLUGIN } from '../meta';
 
+export const RECOVER_CODE_DIALOG = `${CLIENT_PLUGIN}/RecoveryCodeDialog`;
+
 export type RecoveryCodeDialogProps = {
   code: string;
 };
@@ -20,12 +22,15 @@ export const RecoveryCodeDialog = ({ code }: RecoveryCodeDialogProps) => {
 
   return (
     <AlertDialog.Content classNames='bs-content min-bs-[15rem] max-bs-full md:max-is-[40rem] overflow-hidden'>
-      <AlertDialog.Title classNames=''>{t('recovery code dialog title')}</AlertDialog.Title>
+      <AlertDialog.Title>{t('recovery code dialog title')}</AlertDialog.Title>
       <p className='py-4'>{t('recovery code dialog description')}</p>
       <Clipboard.Provider>
-        <Code value={code} />
+        <Code code={code} />
       </Clipboard.Provider>
-      <p className='py-4'>{t('recovery code dialog warning')}</p>
+      <div className='flex flex-col py-4 gap-2'>
+        <p>{t('recovery code dialog warning 1')}</p>
+        <p>{t('recovery code dialog warning 2')}</p>
+      </div>
       <div className='flex items-center gap-2 pbe-4'>
         <Input.Root>
           <Input.Checkbox
@@ -47,12 +52,19 @@ export const RecoveryCodeDialog = ({ code }: RecoveryCodeDialogProps) => {
   );
 };
 
-// TODO(wittjosiah): Factor out.
-const Code = ({ value }: { value: string }) => {
+const Code = ({ code }: { code: string }) => {
+  const words = code.split(' ');
   return (
     <div className='relative p-2 border border-separator rounded group'>
-      <Clipboard.IconButton value={value} classNames='absolute top-2 right-2 invisible group-hover:visible' />
-      <code className='whitespace-pre-wrap'>{value}</code>
+      <Clipboard.IconButton value={code} classNames='absolute top-2 right-2 invisible group-hover:visible' />
+      <div className='grid grid-cols-4'>
+        {words.map((word, i) => (
+          <div key={i} className='flex items-center p-2 gap-2 items-center'>
+            <div className='w-4 text-xs text-center text-subdued'>{i + 1}</div>
+            <div className='text-sm'>{word}</div>
+          </div>
+        ))}
+      </div>
     </div>
   );
 };

package/src/events.ts

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

package/src/index.ts

@@ -2,8 +2,8 @@
 // Copyright 2023 DXOS.org
 //
 
-import { ClientPlugin } from './ClientPlugin';
-
-export default ClientPlugin;
-
 export * from './ClientPlugin';
+export * from './meta';
+
+export { ClientCapabilities } from './capabilities';
+export { ClientEvents } from './events';

package/src/meta.ts

@@ -6,21 +6,7 @@ import { type PluginMeta } from '@dxos/app-framework';
 
 export const CLIENT_PLUGIN = 'dxos.org/plugin/client';
 
-export default {
+export const meta = {
   id: CLIENT_PLUGIN,
   name: 'Client',
 } satisfies PluginMeta;
-
-const CLIENT_ACTION = `${CLIENT_PLUGIN}/action`;
-export enum ClientAction {
-  CREATE_IDENTITY = `${CLIENT_ACTION}/CREATE_IDENTITY`,
-  JOIN_IDENTITY = `${CLIENT_ACTION}/JOIN_IDENTITY`,
-  SHARE_IDENTITY = `${CLIENT_ACTION}/SHARE_IDENTITY`,
-  RECOVER_IDENTITY = `${CLIENT_ACTION}/RECOVER_IDENTITY`,
-  RESET_STORAGE = `${CLIENT_ACTION}/RESET_STORAGE`,
-  CREATE_AGENT = `${CLIENT_ACTION}/CREATE_AGENT`,
-  CREATE_RECOVERY_CODE = `${CLIENT_ACTION}/CREATE_RECOVERY_CODE`,
-}
-
-// NOTE: This action is hardcoded to avoid circular dependency with observability plugin.
-export const OBSERVABILITY_ACTION = 'dxos.org/plugin/observability/send-event';

package/src/translations.ts

@@ -9,12 +9,13 @@ export default [
     'en-US': {
       [CLIENT_PLUGIN]: {
         'open shell label': 'Open HALO',
-        'recovery code dialog title': 'Recovery Code',
+        'recovery code dialog title': 'Account Recovery',
         'recovery code dialog description':
           'This is your identity recovery code, store it in a safe place. You can use it to recover your identity if you ever lose access to your devices.',
-        'recovery code dialog warning':
-          'Please note: This code will not be displayed again and cannot be replaced. It is your private key for recovering DXOS data. Anyone with this key will also be able to gain access to your account.',
-        'recovery code confirmation label': 'Confirm the code has been saved',
+        'recovery code dialog warning 1': 'NOTE: This code will not be displayed again.',
+        'recovery code dialog warning 2':
+          'It is your private key for recovering DXOS data. Anyone with this key will be able to gain access to your account.',
+        'recovery code confirmation label': 'Please confirm you have saved the code.',
         'continue label': 'Continue',
       },
     },

package/src/types.ts

@@ -0,0 +1,89 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+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';
+
+import { CLIENT_PLUGIN } from './meta';
+
+// TODO(wittjosiah): Factor out. Generate?
+const IdentitySchema = S.Struct({
+  identityKey: S.instanceOf(PublicKey),
+  spaceKey: S.optional(S.instanceOf(PublicKey)),
+  profile: S.optional(
+    S.Struct({
+      displayName: S.optional(S.String),
+      avatarCid: S.optional(S.String),
+      data: S.optional(S.Record({ key: S.String, value: S.Any })),
+    }),
+  ),
+});
+
+const CLIENT_ACTION = `${CLIENT_PLUGIN}/action`;
+export namespace ClientAction {
+  export class CreateIdentity extends S.TaggedClass<CreateIdentity>()(`${CLIENT_ACTION}/create-identity`, {
+    input: S.Struct({
+      displayName: S.optional(S.String),
+    }),
+    output: IdentitySchema,
+  }) {}
+
+  export class JoinIdentity extends S.TaggedClass<JoinIdentity>()(`${CLIENT_ACTION}/join-identity`, {
+    input: S.Struct({
+      invitationCode: S.String,
+    }),
+    output: S.Void,
+  }) {}
+
+  export class ShareIdentity extends S.TaggedClass<ShareIdentity>()(`${CLIENT_ACTION}/share-identity`, {
+    input: S.Void,
+    output: S.Void,
+  }) {}
+
+  export class RecoverIdentity extends S.TaggedClass<RecoverIdentity>()(`${CLIENT_ACTION}/recover-identity`, {
+    input: S.Void,
+    output: S.Void,
+  }) {}
+
+  export class ResetStorage extends S.TaggedClass<ResetStorage>()(`${CLIENT_ACTION}/reset-storage`, {
+    input: S.Struct({
+      target: S.optional(S.String),
+    }),
+    output: S.Void,
+  }) {}
+
+  export class CreateAgent extends S.TaggedClass<CreateAgent>()(`${CLIENT_ACTION}/create-agent`, {
+    input: S.Void,
+    output: S.Void,
+  }) {}
+
+  export class CreateRecoveryCode extends S.TaggedClass<CreateRecoveryCode>()(`${CLIENT_ACTION}/create-recovery-code`, {
+    input: S.Void,
+    output: S.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: PluginsContext, client: Client) => MaybePromise<void>;
+
+  /**
+   * Called when the client is reset.
+   */
+  onReset?: (params: { target?: string }) => MaybePromise<void>;
+};