@dxos/shell 0.4.10-main.93fda5f → 0.4.10-main.94f946a

package/src/panels/IdentityPanel/IdentityPanel.tsx

@@ -1,7 +1,8 @@
 //
 // Copyright 2023 DXOS.org
 //
-import React, { useEffect, useMemo } from 'react';
+import { CopySimple, Plugs, PlugsConnected } from '@phosphor-icons/react';
+import React, { useEffect, useMemo, useState } from 'react';
 
 import { generateName } from '@dxos/display-name';
 import { log } from '@dxos/log';
@@ -9,8 +10,10 @@ import { useClient } from '@dxos/react-client';
 import { type Identity, useIdentity, useDevices, useHaloInvitations } from '@dxos/react-client/halo';
 import { useInvitationStatus } from '@dxos/react-client/invitations';
 import type { CancellableInvitationObservable } from '@dxos/react-client/invitations';
-import { Avatar, DensityProvider, useId, useTranslation } from '@dxos/react-ui';
-import { keyToFallback } from '@dxos/util';
+import { useNetworkStatus, ConnectionState } from '@dxos/react-client/mesh';
+import { Avatar, DensityProvider, Input, Toolbar, Tooltip, useId, useTranslation } from '@dxos/react-ui';
+import { getSize } from '@dxos/react-ui-theme';
+import { hexToEmoji, hexToHue, keyToFallback } from '@dxos/util';
 
 import {
   type IdentityPanelHeadingProps,
@@ -18,24 +21,128 @@ import {
   type IdentityPanelProps,
 } from './IdentityPanelProps';
 import { useIdentityMachine } from './identityMachine';
-import { AgentForm, DeviceManager, IdentityActionChooser, ProfileForm, SignOutChooser } from './steps';
+import { IdentityActionChooser } from './steps';
 import { useAgentHandlers } from './useAgentHandlers';
-import { Viewport, Heading, CloseButton } from '../../components';
-import { InvitationManager } from '../../steps';
+import {
+  Viewport,
+  Heading,
+  CloseButton,
+  EmojiPickerToolbarButton,
+  useClipboardContext,
+  HuePickerToolbarButton,
+} from '../../components';
+import { ConfirmReset, InvitationManager } from '../../steps';
 
 const viewStyles = 'pbs-1 pbe-3 pli-3';
 
-const IdentityHeading = ({ titleId, title, identity, onDone }: IdentityPanelHeadingProps) => {
+// TODO(thure): Factor out?
+const getHueValue = (identity?: Identity) =>
+  identity?.profile?.data?.hue || hexToHue(identity?.identityKey.toHex() ?? '0');
+const getEmojiValue = (identity?: Identity) =>
+  identity?.profile?.data?.emoji || hexToEmoji(identity?.identityKey.toHex() ?? '0');
+
+const IdentityHeading = ({
+  titleId,
+  title,
+  identity,
+  onDone,
+  onUpdateProfile,
+  connectionState,
+  onChangeConnectionState,
+}: IdentityPanelHeadingProps) => {
   const fallbackValue = keyToFallback(identity.identityKey);
+  const { t } = useTranslation('os');
+  const [displayName, setDisplayName] = useState(identity.profile?.displayName ?? '');
+  const [emoji, setEmojiDirectly] = useState<string>(getEmojiValue(identity));
+  const [hue, setHueDirectly] = useState<string>(getHueValue(identity));
+  const { textValue, setTextValue } = useClipboardContext();
+  const identityHex = identity.identityKey.toHex();
+  const copied = textValue === identityHex;
+
+  const handleUpdateProfile = async () => {
+    const nextProfile = {
+      ...(displayName && { displayName }),
+      ...((emoji || hue) && { data: { ...(emoji && { emoji }), ...(hue && { hue }) } }),
+    };
+    return onUpdateProfile?.(nextProfile);
+  };
+
+  const setEmoji = (nextEmoji: string) => {
+    setEmojiDirectly(nextEmoji);
+    void handleUpdateProfile();
+  };
+
+  const setHue = (nextHue: string) => {
+    setHueDirectly(nextHue);
+    void handleUpdateProfile();
+  };
+
+  const isConnected = connectionState === ConnectionState.ONLINE;
+
   return (
     <Heading titleId={titleId} title={title} corner={<CloseButton onDone={onDone} />}>
-      <Avatar.Root size={12} variant='circle' status='active' hue={identity.profile?.data?.hue || fallbackValue.hue}>
-        <Avatar.Frame classNames='block mbs-4 mbe-2 mli-auto chromatic-ignore'>
-          <Avatar.Fallback text={identity.profile?.data?.emoji || fallbackValue.emoji} />
-        </Avatar.Frame>
-        <Avatar.Label classNames='block text-center font-light text-xl' data-testid='identityHeading.displayName'>
+      <Avatar.Root size={16} variant='circle' status={isConnected ? 'active' : 'error'} hue={hue || fallbackValue.hue}>
+        <Toolbar.Root classNames='grid grid-cols-[1fr_var(--rail-action)_min-content_var(--rail-action)_1fr] items-center gap-2'>
+          <Tooltip.Root>
+            <Tooltip.Trigger asChild>
+              <Toolbar.Button
+                classNames='bs-[--rail-action] is-[--rail-action] justify-self-end'
+                onClick={() =>
+                  onChangeConnectionState?.(isConnected ? ConnectionState.OFFLINE : ConnectionState.ONLINE)
+                }
+              >
+                <span className='sr-only'>{t(isConnected ? 'disconnect label' : 'connect label')}</span>
+                {isConnected ? <PlugsConnected className={getSize(5)} /> : <Plugs className={getSize(5)} />}
+              </Toolbar.Button>
+            </Tooltip.Trigger>
+            <Tooltip.Portal>
+              <Tooltip.Content side='bottom' classNames='z-50'>
+                {t(isConnected ? 'disconnect label' : 'connect label')}
+                <Tooltip.Arrow />
+              </Tooltip.Content>
+            </Tooltip.Portal>
+          </Tooltip.Root>
+          <EmojiPickerToolbarButton emoji={emoji} onChangeEmoji={setEmoji} classNames='bs-[--rail-action]' />
+          <Avatar.Frame classNames='relative z-[2] -mli-4 chromatic-ignore'>
+            <Avatar.Fallback text={emoji || fallbackValue.emoji} />
+          </Avatar.Frame>
+          <HuePickerToolbarButton hue={hue} onChangeHue={setHue} classNames='bs-[--rail-action]' />
+          <Tooltip.Root>
+            <Tooltip.Trigger asChild>
+              <Toolbar.Button
+                classNames='bs-[--rail-action] justify-self-start'
+                data-testid='update-profile-form-copy-key'
+                onClick={() => setTextValue(identityHex)}
+              >
+                <span className='sr-only'>{t(copied ? 'copy success label' : 'copy self public key label')}</span>
+                <CopySimple className={getSize(5)} />
+              </Toolbar.Button>
+            </Tooltip.Trigger>
+            <Tooltip.Portal>
+              <Tooltip.Content side='bottom' classNames='z-50'>
+                {t(copied ? 'copy success label' : 'copy self public key label')}
+                <Tooltip.Arrow />
+              </Tooltip.Content>
+            </Tooltip.Portal>
+          </Tooltip.Root>
+        </Toolbar.Root>
+        <Avatar.Label classNames='sr-only' data-testid='identityHeading.displayName'>
           {identity.profile?.displayName ?? generateName(identity.identityKey.toHex())}
         </Avatar.Label>
+        <Input.Root>
+          <Input.Label srOnly>{t('display name input label')}</Input.Label>
+          <Input.TextInput
+            variant='subdued'
+            data-testid='display-name-input'
+            placeholder={t('display name input placeholder')}
+            classNames='mbs-2 text-center font-light text-xl'
+            value={displayName}
+            onChange={({ target: { value } }) => {
+              setDisplayName(value);
+            }}
+            onBlur={handleUpdateProfile}
+          />
+        </Input.Root>
       </Avatar.Root>
     </Heading>
   );
@@ -47,18 +154,18 @@ export const IdentityPanelImpl = (props: IdentityPanelImplProps) => {
     titleId,
     activeView,
     onUpdateProfile,
-    onResetDevice,
+    onResetStorage,
     onJoinNewIdentity,
     IdentityActionChooser: IdentityActionChooserComponent = IdentityActionChooser,
     InvitationManager: InvitationManagerComponent = InvitationManager,
+    connectionState,
+    onChangeConnectionState,
     onDone,
     ...rest
   } = props;
   const { t } = useTranslation('os');
   const title = useMemo(() => {
     switch (activeView) {
-      case 'agent manager':
-        return 'Manage Agent';
       case 'device invitation manager':
         return t('choose add device label');
       default:
@@ -66,9 +173,13 @@ export const IdentityPanelImpl = (props: IdentityPanelImplProps) => {
     }
   }, [activeView, t]);
 
+  const onCancelReset = () => rest.send?.('unchooseAction');
+
   return (
     <DensityProvider density='fine'>
-      <IdentityHeading {...{ identity, titleId, title, onDone }} />
+      <IdentityHeading
+        {...{ identity, titleId, title, onDone, onUpdateProfile, connectionState, onChangeConnectionState }}
+      />
       <Viewport.Root activeView={activeView}>
         <Viewport.Views>
           <Viewport.View id='identity action chooser' classNames={viewStyles}>
@@ -81,28 +192,24 @@ export const IdentityPanelImpl = (props: IdentityPanelImplProps) => {
               invitationUrl={rest.createInvitationUrl(rest.invitationCode!)}
             />
           </Viewport.View>
-          <Viewport.View id='device manager' classNames={viewStyles}>
-            <DeviceManager active={activeView === 'device manager'} {...rest} />
-          </Viewport.View>
-          <Viewport.View classNames={viewStyles} id='update profile form'>
-            <ProfileForm
-              send={rest.send}
-              active={activeView === 'update profile form'}
-              identity={identity}
-              onUpdateProfile={onUpdateProfile}
+          <Viewport.View classNames={viewStyles} id='confirm join new identity'>
+            <ConfirmReset
+              active={activeView === 'confirm join new identity'}
+              {...rest}
+              mode='join new identity'
+              onConfirm={onJoinNewIdentity}
+              onCancel={onCancelReset}
             />
           </Viewport.View>
-          <Viewport.View classNames={viewStyles} id='signing out'>
-            <SignOutChooser
-              send={rest.send}
-              active={activeView === 'signing out'}
-              onResetDevice={onResetDevice}
-              onJoinNewIdentity={onJoinNewIdentity}
+          <Viewport.View classNames={viewStyles} id='confirm reset storage'>
+            <ConfirmReset
+              active={activeView === 'confirm reset storage'}
+              {...rest}
+              mode='reset storage'
+              onConfirm={onResetStorage}
+              onCancel={onCancelReset}
             />
           </Viewport.View>
-          <Viewport.View classNames={viewStyles} id='agent manager'>
-            <AgentForm send={rest.send} active={activeView === 'agent manager'} {...rest} />
-          </Viewport.View>
         </Viewport.Views>
       </Viewport.Root>
     </DensityProvider>
@@ -120,6 +227,7 @@ const IdentityPanelWithInvitationImpl = ({
 export const IdentityPanel = ({
   titleId: propsTitleId,
   createInvitationUrl = (code) => code,
+  initialDisposition = 'default',
   ...props
 }: IdentityPanelProps) => {
   const titleId = useId('identityPanel__heading', propsTitleId);
@@ -132,7 +240,13 @@ export const IdentityPanel = ({
     log.error('IdentityPanel rendered with no active identity.');
     return null;
   }
-  const [identityState, identitySend, identityService] = useIdentityMachine(client);
+  const [identityState, identitySend, identityService] = useIdentityMachine(client, {
+    context: { initialDisposition },
+  });
+
+  const { swarm: connectionState } = useNetworkStatus();
+
+  const handleChangeConnectionState = async (nextState: ConnectionState) => client?.mesh.updateConfig(nextState);
 
   useEffect(() => {
     const subscription = identityService.subscribe((state) => {
@@ -148,14 +262,10 @@ export const IdentityPanel = ({
         return 'identity action chooser';
       case identityState.matches('managingDeviceInvitation'):
         return 'device invitation manager';
-      case identityState.matches('managingDevices'):
-        return 'device manager';
-      case [{ managingProfile: 'idle' }, { managingProfile: 'pending' }].some(identityState.matches):
-        return 'update profile form';
-      case identityState.matches('signingOut'):
-        return 'signing out';
-      case [{ managingAgent: 'idle' }, { managingAgent: 'pending' }].some(identityState.matches):
-        return 'agent manager';
+      case identityState.matches('confirmingResetStorage'):
+        return 'confirm reset storage';
+      case identityState.matches('confirmingJoinNewIdentity'):
+        return 'confirm join new identity';
       default:
         return 'identity action chooser';
     }
@@ -175,6 +285,8 @@ export const IdentityPanel = ({
     titleId,
     createInvitationUrl,
     onUpdateProfile,
+    connectionState,
+    onChangeConnectionState: handleChangeConnectionState,
     ...agentProps,
   } satisfies IdentityPanelImplProps;
 

package/src/panels/IdentityPanel/IdentityPanelProps.ts

@@ -7,33 +7,29 @@ import type { Event, SingleOrArray } from 'xstate';
 
 import type { Device, Identity } from '@dxos/react-client/halo';
 import type { InvitationStatus } from '@dxos/react-client/invitations';
+import type { ConnectionState } from '@dxos/react-client/mesh';
 
 import type { IdentityEvent } from './identityMachine';
+import { type AgentFormProps } from '../../components';
 import type { InvitationManagerProps } from '../../steps';
 
-export type AgentFormProps = {
-  onAgentCreate?: () => Promise<void>;
-  onAgentDestroy?: () => Promise<void>;
-  agentStatus?: string;
-  agentActive?: boolean;
-  agentProviderDisabled?: boolean;
-  validationMessage?: string;
-};
+export type IdentityPanelInitialDisposition = 'default' | 'manage-device-invitation';
 
 export type IdentityPanelImplProps = {
   titleId: string;
   activeView:
-    | 'device manager'
-    | 'agent manager'
-    | 'update profile form'
     | 'device invitation manager'
     | 'identity action chooser'
-    | 'signing out';
+    | 'confirm join new identity'
+    | 'confirm reset storage';
+  initialDisposition?: IdentityPanelInitialDisposition;
   identity: Identity;
   devices: Device[];
+  connectionState?: ConnectionState;
+  onChangeConnectionState?: (nextState: ConnectionState) => Promise<void>;
   onUpdateProfile?: (profile: NonNullable<Identity['profile']>) => Promise<void>;
-  onResetDevice?: () => Promise<void>;
-  onJoinNewIdentity?: () => void;
+  onResetStorage?: () => Promise<void>;
+  onJoinNewIdentity?: () => Promise<void>;
   createInvitationUrl: (invitationCode: string) => string;
   send?: (event: SingleOrArray<Event<IdentityEvent>>) => void;
   onDone?: () => void;
@@ -46,11 +42,15 @@ export type IdentityPanelImplProps = {
 
 export type IdentityPanelProps = Partial<Omit<IdentityPanelImplProps, 'send' | 'activeView' | 'identity'>>;
 
-export type IdentityPanelHeadingProps = Pick<IdentityPanelImplProps, 'titleId' | 'identity' | 'onDone'> & {
+export type IdentityPanelHeadingProps = Pick<
+  IdentityPanelImplProps,
+  'titleId' | 'identity' | 'onDone' | 'onUpdateProfile' | 'connectionState' | 'onChangeConnectionState'
+> & {
   title: string;
 };
 
 export type IdentityPanelStepProps = Pick<IdentityPanelImplProps, 'send' | 'onDone' | 'doneActionParent'> & {
   active?: boolean;
   agentHostingEnabled?: boolean;
+  devices: Device[];
 };

package/src/panels/IdentityPanel/identityMachine.ts

@@ -10,16 +10,18 @@ import { type Client } from '@dxos/react-client';
 import { type Identity } from '@dxos/react-client/halo';
 import { type CancellableInvitationObservable } from '@dxos/react-client/invitations';
 
+import { type IdentityPanelInitialDisposition } from './IdentityPanelProps';
 import { type StepEvent } from '../../steps';
 
 type IdentityMachineContext = {
+  initialDisposition?: IdentityPanelInitialDisposition;
   invitation?: CancellableInvitationObservable;
   identity: Identity | null;
   identitySubscribable: Subscribable<SetIdentityEvent> | null;
 };
 
 type IdentityChooseActionEvent = {
-  type: 'chooseDevices' | 'chooseAgent' | 'chooseProfile' | 'chooseSignOut' | 'sigingOut' | 'unchooseAction';
+  type: 'chooseResetStorage' | 'chooseJoinNewIdentity' | 'unchooseAction';
 };
 
 type IdentitySelectDeviceInvitationEvent = {
@@ -56,40 +58,30 @@ const identityMachine = createMachine<IdentityMachineContext, IdentityEvent>(
       src: (context) => context.identitySubscribable!,
     },
     states: {
+      unknown: {
+        always: [
+          { cond: 'initiallyManagingDeviceInvitation', target: 'managingDeviceInvitation', actions: 'log' },
+          { target: 'choosingAction', actions: 'log' },
+        ],
+      },
       choosingAction: {},
       managingDeviceInvitation: {},
-      managingAgent: {
-        initial: 'idle',
-        states: {
-          idle: {},
-          pending: {},
-        },
-      },
-      managingDevices: {},
-      managingProfile: {
-        initial: 'idle',
-        states: {
-          idle: {},
-          pending: {},
-        },
-        on: {
-          setIdentity: { target: 'choosingAction', actions: ['setIdentity', 'log'] },
-          updateProfile: { target: '.pending', actions: 'log' },
-        },
-      },
-      signingOut: {},
+      confirmingResetStorage: {},
+      confirmingJoinNewIdentity: {},
     },
     on: {
       unchooseAction: { target: '.choosingAction', actions: ['unsetInvitation', 'log'] },
       deselectInvitation: { target: '.choosingAction', actions: ['unsetInvitation', 'log'] },
       selectInvitation: { target: '.managingDeviceInvitation', actions: ['setInvitation', 'log'] },
-      chooseDevices: { target: '.managingDevices', actions: 'log' },
-      chooseProfile: { target: '.managingProfile', actions: 'log' },
-      chooseSignOut: { target: '.signingOut', actions: 'log' },
-      chooseAgent: { target: '.managingAgent', actions: 'log' },
+      chooseJoinNewIdentity: { target: '.confirmingJoinNewIdentity', actions: 'log' },
+      chooseResetStorage: { target: '.confirmingResetStorage', actions: 'log' },
     },
   },
   {
+    guards: {
+      initiallyManagingDeviceInvitation: ({ initialDisposition }, _event) =>
+        initialDisposition === 'manage-device-invitation',
+    },
     actions: {
       setIdentity: assign<IdentityMachineContext, IdentityEvent>({
         identity: (context, event) => (event as SetIdentityEvent)?.identity ?? null,

package/src/panels/IdentityPanel/steps/IdentityActionChooser.tsx

@@ -2,17 +2,14 @@
 // Copyright 2023 DXOS.org
 //
 
-import { CaretRight, Devices, Plus, Power, UserGear, HardDrive } from '@phosphor-icons/react';
 import React, { useCallback } from 'react';
 
 import { log } from '@dxos/log';
 import { useAgentHostingProviderClient, useClient } from '@dxos/react-client';
 import { useHaloInvitations } from '@dxos/react-client/halo';
 import { Invitation, InvitationEncoder } from '@dxos/react-client/invitations';
-import { DensityProvider, useTranslation } from '@dxos/react-ui';
-import { getSize } from '@dxos/react-ui-theme';
 
-import { Action } from '../../../components';
+import { AgentConfig, type AgentFormProps, DeviceList } from '../../../components';
 import { type IdentityPanelStepProps } from '../IdentityPanelProps';
 
 export type IdentityActionChooserProps = IdentityPanelStepProps;
@@ -28,13 +25,10 @@ export const IdentityActionChooser = (props: IdentityPanelStepProps) => {
       log.info(JSON.stringify({ invitationCode, authCode: invitation.authCode }));
     }
   }, []);
-  const createInvitation = (e: React.MouseEvent) => {
-    const testing = e.altKey && e.shiftKey;
+  const createInvitation = () => {
     invitations.forEach((invitation) => invitation.cancel());
     // TODO(nf): allow user to make invitations non-persistent?
-    const invitation = client.halo.share(
-      testing ? { type: Invitation.Type.MULTIUSE, authMethod: Invitation.AuthMethod.NONE } : undefined,
-    );
+    const invitation = client.halo.share();
     // TODO(wittjosiah): Don't depend on NODE_ENV.
     if (process.env.NODE_ENV !== 'production') {
       invitation.subscribe(onInvitationEvent);
@@ -44,74 +38,36 @@ export const IdentityActionChooser = (props: IdentityPanelStepProps) => {
   return (
     <IdentityActionChooserImpl
       {...props}
-      onCreateInvitationClick={(e) => createInvitation(e)}
+      onCreateInvitationClick={createInvitation}
       agentHostingEnabled={!!agentHostingProviderClient}
     />
   );
 };
 
-export type IdentityActionChooserImplProps = IdentityActionChooserProps & {
-  onCreateInvitationClick?: (e: React.MouseEvent) => void;
-};
+export type IdentityActionChooserImplProps = IdentityActionChooserProps &
+  Partial<AgentFormProps> & {
+    onCreateInvitationClick?: () => void;
+  };
 
 export const IdentityActionChooserImpl = ({
-  onCreateInvitationClick,
-  active,
   send,
-  onDone,
-  doneActionParent,
+  onCreateInvitationClick,
+  devices,
+  onAgentDestroy,
+  onAgentCreate,
+  agentStatus,
+  agentActive,
   agentHostingEnabled,
 }: IdentityActionChooserImplProps) => {
-  const { t } = useTranslation('os');
-
-  // const doneAction = (
-  //   <PanelAction aria-label={t('done label')} onClick={onDone} disabled={!active} data-testid='identity-panel-done'>
-  //     <Check weight='light' className={getSize(6)} />
-  //   </PanelAction>
-  // );
   return (
-    <div role='none' className='grow flex flex-col gap-1'>
-      <DensityProvider density='coarse'>
-        <div className='grow justify-center flex flex-col gap-1'>
-          {agentHostingEnabled && (
-            <Action data-testid='manage-agent' onClick={() => send?.({ type: 'chooseAgent' })} classNames='plb-4'>
-              <HardDrive className={getSize(6)} />
-              <span className='grow mli-3'>Manage Agent</span>
-              <CaretRight weight='bold' className={getSize(4)} />
-            </Action>
-          )}
-          <Action
-            disabled={!active}
-            data-testid='devices-panel.create-invitation'
-            onClick={onCreateInvitationClick}
-            classNames='plb-4'
-          >
-            <Plus className={getSize(6)} />
-            <span className='grow mli-3'>{t('choose add device label')}</span>
-            <CaretRight weight='bold' className={getSize(4)} />
-          </Action>
-          <Action data-testid='manage-devices' onClick={() => send?.({ type: 'chooseDevices' })} classNames='plb-4'>
-            <Devices className={getSize(6)} />
-            <span className='grow mli-3'>{t('choose devices label')}</span>
-            <CaretRight weight='bold' className={getSize(4)} />
-          </Action>
-          <Action data-testid='manage-profile' onClick={() => send?.({ type: 'chooseProfile' })} classNames='plb-4'>
-            <UserGear className={getSize(6)} />
-            <span className='grow mli-3'>{t('choose profile label')}</span>
-            <CaretRight weight='bold' className={getSize(4)} />
-          </Action>
-          <Action
-            data-testid='devices-panel.sign-out'
-            onClick={() => send?.({ type: 'chooseSignOut' })}
-            classNames='plb-4'
-          >
-            <Power className={getSize(6)} />
-            <span className='grow mli-3'>{t('choose sign out label')}</span>
-            <CaretRight weight='bold' className={getSize(4)} />
-          </Action>
-        </div>
-      </DensityProvider>
-      {/* <PanelActions>{doneActionParent ? cloneElement(doneActionParent, {}, doneAction) : doneAction}</PanelActions> */}
-    </div>
+    <>
+      <DeviceList
+        devices={devices}
+        onClickAdd={onCreateInvitationClick}
+        onClickJoinExisting={() => send?.({ type: 'chooseJoinNewIdentity' })}
+        onClickReset={() => send?.({ type: 'chooseResetStorage' })}
+      />
+      {agentHostingEnabled && <AgentConfig {...{ agentActive, agentStatus, onAgentDestroy, onAgentCreate }} />}
+    </>
   );
 };

package/src/panels/IdentityPanel/steps/ProfileForm.tsx

@@ -10,11 +10,19 @@ import { type Identity } from '@dxos/react-client/halo';
 import { useTranslation } from '@dxos/react-ui';
 import { hexToEmoji, hexToHue } from '@dxos/util';
 
-import { Action, Actions, StepHeading, Input, useClipboardContext, EmojiPicker, HuePicker } from '../../../components';
+import {
+  Action,
+  Actions,
+  StepHeading,
+  Input,
+  useClipboardContext,
+  EmojiPickerBlock,
+  HuePickerBlock,
+} from '../../../components';
 import { type IdentityPanelStepProps } from '../IdentityPanelProps';
 import { type IdentityEvent } from '../identityMachine';
 
-export interface ProfileFormProps extends Omit<IdentityPanelStepProps, 'send'> {
+export interface ProfileFormProps extends Omit<IdentityPanelStepProps, 'send' | 'devices'> {
   send?: (event: SingleOrArray<Event<IdentityEvent>>) => void;
   onUpdateProfile?: (profile: NonNullable<Identity['profile']>) => Promise<void>;
   identity?: Identity;
@@ -68,13 +76,13 @@ const ProfileFormImpl = (props: ProfileFormImplProps) => {
         />
         <StepHeading className='mbe-2'>{t('emoji and color label')}</StepHeading>
         <div role='none' className='grid grid-cols-[1fr_min-content] gap-y-2'>
-          <EmojiPicker
+          <EmojiPickerBlock
             emoji={emoji}
             onChangeEmoji={setEmoji}
             disabled={disabled}
             onClickClear={() => setEmoji(getEmojiValue(identity))}
           />
-          <HuePicker
+          <HuePickerBlock
             hue={hue}
             onChangeHue={setHue}
             disabled={disabled}
@@ -106,7 +114,12 @@ const ProfileFormImpl = (props: ProfileFormImplProps) => {
         <Action
           variant='primary'
           disabled={disabled}
-          onClick={() => onUpdateProfile?.({ displayName, data: { emoji, hue } })}
+          onClick={() =>
+            onUpdateProfile?.({
+              ...(displayName && { displayName }),
+              ...((emoji || hue) && { data: { ...(emoji && { emoji }), ...(hue && { hue }) } }),
+            })
+          }
           data-testid='update-profile-form-continue'
         >
           {t('done label')}

package/src/panels/IdentityPanel/steps/index.ts

@@ -2,8 +2,5 @@
 // Copyright 2023 DXOS.org
 //
 
-export * from './AgentForm';
-export * from './DeviceManager';
 export * from './IdentityActionChooser';
 export * from './ProfileForm';
-export * from './SignOutChooser';

package/src/panels/IdentityPanel/useAgentHandlers.ts

@@ -67,7 +67,11 @@ export const useAgentHandlers = ({
     invitations.forEach((invitation) => invitation.cancel());
 
     // TODO(nf): do this work in the hosting provider client?
-    const invitation = client.halo.share({ type: Invitation.Type.MULTIUSE, authMethod: Invitation.AuthMethod.NONE });
+    const invitation = client.halo.share({
+      type: Invitation.Type.INTERACTIVE,
+      authMethod: Invitation.AuthMethod.NONE,
+      multiUse: true,
+    });
 
     invitation.subscribe(handleAgentCreate);
   };

package/src/panels/JoinPanel/JoinPanel.stories.tsx

@@ -10,8 +10,9 @@ import { withTheme } from '@dxos/storybook-utils';
 
 import { JoinPanelImpl } from './JoinPanel';
 import { type JoinPanelImplProps } from './JoinPanelProps';
-import { IdentityInputImpl, ResetIdentityImpl } from './steps';
+import { IdentityInputImpl } from './steps';
 import { StorybookDialog } from '../../components/StorybookDialog';
+import { ConfirmResetImpl } from '../../steps';
 
 const noOpProps: JoinPanelImplProps = {
   titleId: 'storybookJoinPanel__title',
@@ -34,7 +35,7 @@ export default {
   parameters: { chromatic: { disableSnapshot: false } },
   args: {
     IdentityInput: IdentityInputImpl,
-    ResetIdentity: ResetIdentityImpl,
+    ResetIdentity: ConfirmResetImpl,
   },
 };