@dxos/plugin-client 0.8.4-main.72ec0f3 → 0.8.4-main.7996785055

package/src/operations/create-agent.ts

@@ -0,0 +1,27 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import { invariant } from '@dxos/invariant';
+import { Operation } from '@dxos/operation';
+
+import { CreateAgent } from './definitions';
+
+import { ClientCapabilities } from '../types';
+
+const handler: Operation.WithHandler<typeof CreateAgent> = CreateAgent.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* () {
+      const client = yield* Capability.get(ClientCapabilities.Client);
+      invariant(client.services.services.EdgeAgentService, 'Missing EdgeAgentService');
+      yield* Effect.promise(() =>
+        client.services.services.EdgeAgentService!.createAgent(undefined, { timeout: 10_000 }),
+      );
+    }),
+  ),
+);
+
+export default handler;

package/src/operations/create-identity.ts

@@ -0,0 +1,30 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { runAndForwardErrors } from '@dxos/effect';
+import { Operation } from '@dxos/operation';
+import { ObservabilityOperation } from '@dxos/plugin-observability/operations';
+
+import { CreateIdentity } from './definitions';
+
+import { ClientEvents } from '../types';
+import { ClientCapabilities } from '../types';
+
+const handler: Operation.WithHandler<typeof CreateIdentity> = CreateIdentity.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* (profile) {
+      const manager = yield* Capability.get(Capabilities.PluginManager);
+      const client = yield* Capability.get(ClientCapabilities.Client);
+      const data = yield* Effect.promise(() => client.halo.createIdentity(profile));
+      yield* Effect.promise(() => runAndForwardErrors(manager.activate(ClientEvents.IdentityCreated)));
+      yield* Operation.schedule(ObservabilityOperation.SendEvent, { name: 'identity.create' });
+      return data;
+    }),
+  ),
+);
+
+export default handler;

package/src/operations/create-passkey.ts

@@ -0,0 +1,64 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import { PublicKey } from '@dxos/client';
+import { invariant } from '@dxos/invariant';
+import { Operation } from '@dxos/operation';
+
+import { CreatePasskey } from './definitions';
+
+import { ClientCapabilities } from '../types';
+
+const handler: Operation.WithHandler<typeof CreatePasskey> = CreatePasskey.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* () {
+      const client = yield* Capability.get(ClientCapabilities.Client);
+      const identity = client.halo.identity.get();
+      invariant(identity, 'Identity not available');
+
+      const lookupKey = PublicKey.random();
+      const credential = yield* Effect.promise(() =>
+        navigator.credentials.create({
+          publicKey: {
+            challenge: new Uint8Array(),
+            rp: { id: location.hostname, name: 'Composer' },
+            user: {
+              id: lookupKey.asUint8Array() as Uint8Array<ArrayBuffer>,
+              name: identity.did,
+              displayName: identity.profile?.displayName ?? '',
+            },
+            pubKeyCredParams: [
+              { type: 'public-key', alg: -8 },
+              { type: 'public-key', alg: -7 },
+            ],
+            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';
+
+      invariant(client.services.services.IdentityService, 'IdentityService not available');
+      yield* Effect.promise(() =>
+        client.services.services.IdentityService!.createRecoveryCredential({
+          data: {
+            recoveryKey,
+            algorithm,
+            lookupKey,
+          },
+        }),
+      );
+    }),
+  ),
+);
+
+export default handler;

package/src/operations/create-recovery-code.ts

@@ -0,0 +1,35 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import { LayoutOperation } from '@dxos/app-toolkit';
+import { invariant } from '@dxos/invariant';
+import { Operation } from '@dxos/operation';
+
+import { CreateRecoveryCode } from './definitions';
+
+import { RECOVERY_CODE_DIALOG } from '../constants';
+import { ClientCapabilities } from '../types';
+
+const handler: Operation.WithHandler<typeof CreateRecoveryCode> = CreateRecoveryCode.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* () {
+      const client = yield* Capability.get(ClientCapabilities.Client);
+      invariant(client.services.services.IdentityService, 'IdentityService not available');
+      const { recoveryCode } = yield* Effect.promise(() =>
+        client.services.services.IdentityService!.createRecoveryCredential({}),
+      );
+      yield* Operation.invoke(LayoutOperation.UpdateDialog, {
+        subject: RECOVERY_CODE_DIALOG,
+        blockAlign: 'start',
+        type: 'alert',
+        props: { code: recoveryCode },
+      });
+    }),
+  ),
+);
+
+export default handler;

package/src/operations/definitions.ts

@@ -0,0 +1,107 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { Capability } from '@dxos/app-framework';
+import { PublicKey } from '@dxos/client';
+import { Operation } from '@dxos/operation';
+
+import { meta } from '../meta';
+
+const CLIENT_OPERATION = `${meta.id}.operation`;
+
+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 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 const CreateIdentity = Operation.make({
+  meta: { key: `${CLIENT_OPERATION}.create-identity`, name: 'Create Identity' },
+  services: [Capability.Service],
+  input: ProfileSchema,
+  output: IdentitySchema,
+});
+
+export const JoinIdentity = Operation.make({
+  meta: { key: `${CLIENT_OPERATION}.join-identity`, name: 'Join Identity' },
+  services: [Capability.Service],
+  input: Schema.Struct({
+    invitationCode: Schema.optional(Schema.String),
+  }),
+  output: Schema.Void,
+});
+
+export const ShareIdentity = Operation.make({
+  meta: { key: `${CLIENT_OPERATION}.share-identity`, name: 'Share Identity' },
+  services: [Capability.Service],
+  input: Schema.Void,
+  output: Schema.Void,
+});
+
+export const RecoverIdentity = Operation.make({
+  meta: { key: `${CLIENT_OPERATION}.recover-identity`, name: 'Recover Identity' },
+  services: [Capability.Service],
+  input: Schema.Void,
+  output: Schema.Void,
+});
+
+export const ResetStorage = Operation.make({
+  meta: { key: `${CLIENT_OPERATION}.reset-storage`, name: 'Reset Storage' },
+  services: [Capability.Service],
+  input: Schema.Struct({
+    mode: Schema.optional(Schema.String),
+  }),
+  output: Schema.Void,
+});
+
+export const CreateAgent = Operation.make({
+  meta: { key: `${CLIENT_OPERATION}.create-agent`, name: 'Create Agent' },
+  services: [Capability.Service],
+  input: Schema.Void,
+  output: Schema.Void,
+});
+
+export const CreateRecoveryCode = Operation.make({
+  meta: { key: `${CLIENT_OPERATION}.create-recovery-code`, name: 'Create Recovery Code' },
+  services: [Capability.Service],
+  input: Schema.Void,
+  output: Schema.Void,
+});
+
+export const CreatePasskey = Operation.make({
+  meta: { key: `${CLIENT_OPERATION}.create-passkey`, name: 'Create Passkey' },
+  services: [Capability.Service],
+  input: Schema.Void,
+  output: Schema.Void,
+});
+
+export const RedeemPasskey = Operation.make({
+  meta: { key: `${CLIENT_OPERATION}.redeem-passkey`, name: 'Redeem Passkey' },
+  services: [Capability.Service],
+  input: Schema.Void,
+  output: Schema.Void,
+});
+
+export const RedeemToken = Operation.make({
+  meta: { key: `${CLIENT_OPERATION}.redeem-token`, name: 'Redeem Token' },
+  services: [Capability.Service],
+  input: Schema.Struct({
+    token: Schema.String,
+  }),
+  output: Schema.Void,
+});

package/src/operations/index.ts

@@ -0,0 +1,20 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { OperationHandlerSet } from '@dxos/operation';
+
+export * as ClientOperation from './definitions';
+
+export const ClientOperationHandlerSet = OperationHandlerSet.lazy(
+  () => import('./create-agent'),
+  () => import('./create-identity'),
+  () => import('./create-passkey'),
+  () => import('./create-recovery-code'),
+  () => import('./join-identity'),
+  () => import('./recover-identity'),
+  () => import('./redeem-passkey'),
+  () => import('./redeem-token'),
+  () => import('./reset-storage'),
+  () => import('./share-identity'),
+);

package/src/operations/join-identity.ts

@@ -0,0 +1,29 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { LayoutOperation } from '@dxos/app-toolkit';
+import { Operation } from '@dxos/operation';
+
+import { JoinIdentity } from './definitions';
+
+import { JOIN_DIALOG } from '../constants';
+
+const handler: Operation.WithHandler<typeof JoinIdentity> = JoinIdentity.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* (data) {
+      yield* Operation.invoke(LayoutOperation.UpdateDialog, {
+        subject: JOIN_DIALOG,
+        blockAlign: 'start',
+        props: {
+          initialInvitationCode: data.invitationCode,
+          initialDisposition: 'accept-halo-invitation',
+        },
+      });
+    }),
+  ),
+);
+
+export default handler;

package/src/operations/recover-identity.ts

@@ -0,0 +1,29 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { LayoutOperation } from '@dxos/app-toolkit';
+import { Operation } from '@dxos/operation';
+import { type JoinPanelProps } from '@dxos/shell/react';
+
+import { RecoverIdentity } from './definitions';
+
+import { JOIN_DIALOG } from '../constants';
+
+const handler: Operation.WithHandler<typeof RecoverIdentity> = RecoverIdentity.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* () {
+      yield* Operation.invoke(LayoutOperation.UpdateDialog, {
+        subject: JOIN_DIALOG,
+        blockAlign: 'start',
+        props: {
+          initialDisposition: 'recover-identity',
+        } satisfies Partial<JoinPanelProps>,
+      });
+    }),
+  ),
+);
+
+export default handler;

package/src/operations/redeem-passkey.ts

@@ -0,0 +1,55 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import { PublicKey } from '@dxos/client';
+import { invariant } from '@dxos/invariant';
+import { Operation } from '@dxos/operation';
+
+import { RedeemPasskey } from './definitions';
+
+import { ClientCapabilities } from '../types';
+
+const handler: Operation.WithHandler<typeof RedeemPasskey> = RedeemPasskey.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* () {
+      const client = yield* Capability.get(ClientCapabilities.Client);
+      invariant(client.services.services.IdentityService, 'IdentityService not available');
+      const { deviceKey, controlFeedKey, challenge } = yield* Effect.promise(() =>
+        client.services.services.IdentityService!.requestRecoveryChallenge(),
+      );
+      const credential = yield* Effect.promise(() =>
+        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));
+      yield* Effect.promise(() =>
+        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 },
+        ),
+      );
+    }),
+  ),
+);
+
+export default handler;
+
+const RECOVER_IDENTITY_RPC_TIMEOUT = 20_000;

package/src/operations/redeem-token.ts

@@ -0,0 +1,32 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import { invariant } from '@dxos/invariant';
+import { Operation } from '@dxos/operation';
+
+import { RedeemToken } from './definitions';
+
+import { ClientCapabilities } from '../types';
+
+const handler: Operation.WithHandler<typeof RedeemToken> = RedeemToken.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* (data) {
+      const client = yield* Capability.get(ClientCapabilities.Client);
+      invariant(client.services.services.IdentityService, 'IdentityService not available');
+      yield* Effect.promise(() =>
+        client.services.services.IdentityService!.recoverIdentity(
+          { token: data.token },
+          { timeout: RECOVER_IDENTITY_RPC_TIMEOUT },
+        ),
+      );
+    }),
+  ),
+);
+
+export default handler;
+
+const RECOVER_IDENTITY_RPC_TIMEOUT = 20_000;

package/src/operations/reset-storage.ts

@@ -0,0 +1,28 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { LayoutOperation } from '@dxos/app-toolkit';
+import { Operation } from '@dxos/operation';
+
+import { ResetStorage } from './definitions';
+
+import { RESET_DIALOG } from '../constants';
+
+const handler: Operation.WithHandler<typeof ResetStorage> = ResetStorage.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* (data) {
+      yield* Operation.invoke(LayoutOperation.UpdateDialog, {
+        subject: RESET_DIALOG,
+        blockAlign: 'start',
+        props: {
+          mode: data.mode ?? 'reset storage',
+        },
+      });
+    }),
+  ),
+);
+
+export default handler;

package/src/operations/share-identity.ts

@@ -0,0 +1,27 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { LayoutOperation, getSpacePath } from '@dxos/app-toolkit';
+import { Operation } from '@dxos/operation';
+import { ObservabilityOperation } from '@dxos/plugin-observability/operations';
+
+import { ShareIdentity } from './definitions';
+
+import { Account } from '../types';
+
+const handler: Operation.WithHandler<typeof ShareIdentity> = ShareIdentity.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* () {
+      yield* Operation.invoke(LayoutOperation.SwitchWorkspace, { subject: getSpacePath(Account.id) });
+      yield* Operation.invoke(LayoutOperation.Open, {
+        subject: [`${getSpacePath(Account.id)}/${Account.Profile}`],
+      });
+      yield* Operation.schedule(ObservabilityOperation.SendEvent, { name: 'identity.share' });
+    }),
+  ),
+);
+
+export default handler;

package/src/testing/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export { initializeIdentity } from './initializeIdentity';

package/src/testing/initializeIdentity.ts

@@ -0,0 +1,24 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { PERSONAL_SPACE_TAG } from '@dxos/app-toolkit';
+import { type Client } from '@dxos/client';
+import { type Space } from '@dxos/client-protocol';
+import { type Identity } from '@dxos/protocols/proto/dxos/client/services';
+
+/**
+ * Create an identity and a personal space.
+ * Returns the identity and space for further setup.
+ */
+export const initializeIdentity = (
+  client: Client,
+): Effect.Effect<{ identity: Identity; personalSpace: Space }, never, never> =>
+  Effect.gen(function* () {
+    const identity = yield* Effect.promise(() => client.halo.createIdentity());
+    const personalSpace = yield* Effect.promise(() => client.spaces.create({}, { tags: [PERSONAL_SPACE_TAG] }));
+    yield* Effect.promise(() => personalSpace.waitUntilReady());
+    return { identity, personalSpace };
+  });

package/src/translations.ts

@@ -3,14 +3,15 @@
 //
 
 import { type Resource } from '@dxos/react-ui';
+import { translations as shellTranslations } from '@dxos/shell/react';
 
 import { meta } from './meta';
 
-export const translations = [
+const pluginTranslations = [
   {
     'en-US': {
       [meta.id]: {
-        'account label': 'User Account',
+        'account label': 'User profile',
         'profile label': 'Profile',
         'profile description': 'You can adjust how your user settings here.',
         'devices label': 'Devices',
@@ -35,7 +36,7 @@ export const translations = [
         'display name description': 'Your name as it appears in the app.',
         'display name input placeholder': 'Enter a name',
         'icon label': 'Avatar',
-        'icon description': 'The emoji used to represent you in the app.',
+        'icon description': 'The emoji used to represent the user.',
         'hue label': 'Color',
         'hue description':
           'The color used to represent you in the app, including as your avatar’s background, your cursor as it appears to others, and the messages you send in group threads.',
@@ -68,3 +69,5 @@ export const translations = [
     },
   },
 ] as const satisfies Resource[];
+
+export const translations: Resource[] = [...pluginTranslations, ...shellTranslations];

package/src/types/capabilities.ts

@@ -0,0 +1,16 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+import { type Client } from '@dxos/client';
+import { type ObjectMigration } from '@dxos/client/echo';
+import { type Type } from '@dxos/echo';
+
+import { meta } from '../meta';
+
+export namespace ClientCapabilities {
+  export const Client = Capability.make<Client>(`${meta.id}.capability.client`);
+  export const Schema = Capability.make<Type.AnyEntity[]>(`${meta.id}.capability.schema`);
+  export const Migration = Capability.make<ObjectMigration[]>(`${meta.id}.capability.migration`);
+}

package/src/types/events.ts

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

package/src/types/index.ts

@@ -2,4 +2,6 @@
 // Copyright 2025 DXOS.org
 //
 
+export * from './capabilities';
+export * from './events';
 export * from './schema';