@dxos/plugin-client 0.8.4-main.c4373fc → 0.8.4-main.c85a9c8dae

package/src/capabilities/operation-resolver/operation-resolver.ts

@@ -0,0 +1,247 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { LayoutOperation } from '@dxos/app-toolkit';
+import { PublicKey } from '@dxos/client';
+import { runAndForwardErrors } from '@dxos/effect';
+import { invariant } from '@dxos/invariant';
+import { OperationResolver } from '@dxos/operation';
+import { Operation } from '@dxos/operation';
+import { ObservabilityOperation } from '@dxos/plugin-observability/types';
+import { type JoinPanelProps } from '@dxos/shell/react';
+
+import { JOIN_DIALOG, RECOVERY_CODE_DIALOG, RESET_DIALOG } from '../../constants';
+import { ClientEvents } from '../../types';
+import { Account, ClientCapabilities, ClientOperation } from '../../types';
+
+type OperationResolverOptions = {
+  appName?: string;
+};
+
+const RECOVER_IDENTITY_RPC_TIMEOUT = 20_000;
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* ({ appName = 'Composer' }: OperationResolverOptions = {}) {
+    return Capability.contributes(Capabilities.OperationResolver, [
+      //
+      // CreateIdentity
+      //
+      OperationResolver.make({
+        operation: ClientOperation.CreateIdentity,
+        handler: 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;
+        }),
+      }),
+
+      //
+      // JoinIdentity
+      //
+      OperationResolver.make({
+        operation: ClientOperation.JoinIdentity,
+        handler: Effect.fnUntraced(function* (data) {
+          yield* Operation.invoke(LayoutOperation.UpdateDialog, {
+            subject: JOIN_DIALOG,
+            blockAlign: 'start',
+            props: {
+              initialInvitationCode: data.invitationCode,
+              initialDisposition: 'accept-halo-invitation',
+            },
+          });
+        }),
+      }),
+
+      //
+      // ShareIdentity
+      //
+      OperationResolver.make({
+        operation: ClientOperation.ShareIdentity,
+        handler: Effect.fnUntraced(function* () {
+          yield* Operation.invoke(LayoutOperation.SwitchWorkspace, { subject: Account.id });
+          yield* Operation.invoke(LayoutOperation.Open, { subject: [Account.Profile] });
+          yield* Operation.schedule(ObservabilityOperation.SendEvent, { name: 'identity.share' });
+        }),
+      }),
+
+      //
+      // RecoverIdentity
+      //
+      OperationResolver.make({
+        operation: ClientOperation.RecoverIdentity,
+        handler: Effect.fnUntraced(function* () {
+          yield* Operation.invoke(LayoutOperation.UpdateDialog, {
+            subject: JOIN_DIALOG,
+            blockAlign: 'start',
+            props: {
+              initialDisposition: 'recover-identity',
+            } satisfies Partial<JoinPanelProps>,
+          });
+        }),
+      }),
+
+      //
+      // ResetStorage
+      //
+      OperationResolver.make({
+        operation: ClientOperation.ResetStorage,
+        handler: Effect.fnUntraced(function* (data) {
+          yield* Operation.invoke(LayoutOperation.UpdateDialog, {
+            subject: RESET_DIALOG,
+            blockAlign: 'start',
+            props: {
+              mode: data.mode ?? 'reset storage',
+            },
+          });
+        }),
+      }),
+
+      //
+      // CreateAgent
+      //
+      OperationResolver.make({
+        operation: ClientOperation.CreateAgent,
+        handler: 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 }),
+          );
+        }),
+      }),
+
+      //
+      // CreateRecoveryCode
+      //
+      OperationResolver.make({
+        operation: ClientOperation.CreateRecoveryCode,
+        handler: 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 },
+          });
+        }),
+      }),
+
+      //
+      // CreatePasskey
+      //
+      OperationResolver.make({
+        operation: ClientOperation.CreatePasskey,
+        handler: 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: appName },
+                user: {
+                  id: lookupKey.asUint8Array() as Uint8Array<ArrayBuffer>,
+                  name: identity.did,
+                  displayName: identity.profile?.displayName ?? '',
+                },
+                pubKeyCredParams: [
+                  { type: 'public-key', alg: -8 }, // Ed25519 (not yet supported across all browsers)
+                  { type: 'public-key', alg: -7 }, // ES256
+                ],
+                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,
+              },
+            }),
+          );
+        }),
+      }),
+
+      //
+      // RedeemPasskey
+      //
+      OperationResolver.make({
+        operation: ClientOperation.RedeemPasskey,
+        handler: 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 },
+            ),
+          );
+        }),
+      }),
+
+      //
+      // RedeemToken
+      //
+      OperationResolver.make({
+        operation: ClientOperation.RedeemToken,
+        handler: 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 },
+            ),
+          );
+        }),
+      }),
+    ]);
+  }),
+);

package/src/capabilities/react-context/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+
+export const ReactContext = Capability.lazy('ReactContext', () => import('./react-context'));

package/src/capabilities/react-context/react-context.tsx

@@ -0,0 +1,25 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import React from 'react';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { useCapability } from '@dxos/app-framework/ui';
+import { ClientProvider } from '@dxos/react-client';
+
+import { meta } from '../../meta';
+import { ClientCapabilities } from '../../types';
+
+export default Capability.makeModule(() =>
+  Effect.succeed(
+    Capability.contributes(Capabilities.ReactContext, {
+      id: meta.id,
+      context: ({ children }: { children?: React.ReactNode }) => {
+        const client = useCapability(ClientCapabilities.Client);
+        return <ClientProvider client={client}>{children}</ClientProvider>;
+      },
+    }),
+  ),
+);

package/src/capabilities/react-surface/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+
+export const ReactSurface = Capability.lazy('ReactSurface', () => import('./react-surface'));

package/src/capabilities/react-surface/react-surface.tsx

@@ -0,0 +1,74 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import React from 'react';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { Surface } from '@dxos/app-framework/ui';
+import { type JoinPanelProps } from '@dxos/shell/react';
+
+import { JOIN_DIALOG, RECOVERY_CODE_DIALOG, RESET_DIALOG } from '../../constants';
+import {
+  DevicesContainer,
+  JoinDialog,
+  ProfileContainer,
+  RecoveryCodeDialog,
+  type RecoveryCodeDialogProps,
+  RecoveryCredentialsContainer,
+  ResetDialog,
+  type ResetDialogProps,
+} from '../../containers';
+import { Account, type ClientPluginOptions } from '../../types';
+
+type ReactSurfaceOptions = Pick<ClientPluginOptions, 'onReset'> & {
+  createInvitationUrl: (invitationCode: string) => string;
+};
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* ({ createInvitationUrl, onReset }: ReactSurfaceOptions) {
+    const capabilityManager = yield* Capability.Service;
+
+    return Capability.contributes(Capabilities.ReactSurface, [
+      Surface.create({
+        id: Account.Profile,
+        role: 'article',
+        filter: (data): data is any => data.subject === Account.Profile,
+        component: () => <ProfileContainer />,
+      }),
+      Surface.create({
+        id: Account.Devices,
+        role: 'article',
+        filter: (data): data is any => data.subject === Account.Devices,
+        component: () => <DevicesContainer createInvitationUrl={createInvitationUrl} />,
+      }),
+      Surface.create({
+        id: Account.Security,
+        role: 'article',
+        filter: (data): data is any => data.subject === Account.Security,
+        component: () => <RecoveryCredentialsContainer />,
+      }),
+      Surface.create({
+        id: JOIN_DIALOG,
+        role: 'dialog',
+        filter: (data): data is { props: JoinPanelProps } => data.component === JOIN_DIALOG,
+        component: ({ data }: { data: any }) => <JoinDialog {...data.props} />,
+      }),
+      Surface.create({
+        id: RECOVERY_CODE_DIALOG,
+        role: 'dialog',
+        filter: (data): data is { props: RecoveryCodeDialogProps } => data.component === RECOVERY_CODE_DIALOG,
+        component: ({ data }: { data: any }) => <RecoveryCodeDialog {...data.props} />,
+      }),
+      Surface.create({
+        id: RESET_DIALOG,
+        role: 'dialog',
+        filter: (data): data is { props: ResetDialogProps } => data.component === RESET_DIALOG,
+        component: ({ data }: { data: any }) => (
+          <ResetDialog {...data.props} onReset={onReset} capabilityManager={capabilityManager} />
+        ),
+      }),
+    ]);
+  }),
+);

package/src/capabilities/schema-defs/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+
+export const SchemaDefs = Capability.lazy('SchemaDefs', () => import('./schema-defs'));

package/src/capabilities/schema-defs/schema-defs.ts

@@ -0,0 +1,36 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
+import { type Type } from '@dxos/echo';
+
+import { ClientCapabilities } from '../../types';
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    const registry = yield* Capability.get(Capabilities.AtomRegistry);
+    const client = yield* Capability.get(ClientCapabilities.Client);
+    const schemasAtom = yield* Capability.atom(AppCapabilities.Schema);
+
+    // TODO(wittjosiah): Unregister schemas when they are disabled.
+    let previous: Type.AnyEntity[] = [];
+    const cancel = registry.subscribe(
+      schemasAtom,
+      async (_schemas: any[]) => {
+        // TODO(wittjosiah): This doesn't seem to de-dupe schemas as expected.
+        const schemas = Array.from(new Set(_schemas.flat())) as Type.AnyEntity[];
+        // TODO(wittjosiah): Filter out schemas which the client has already registered.
+        const newSchemas = schemas.filter((schema) => !previous.includes(schema));
+        previous = schemas;
+        await client.addTypes(newSchemas);
+      },
+      { immediate: true },
+    );
+
+    return Capability.contributes(Capabilities.Null, null, () => Effect.sync(() => cancel()));
+  }),
+);

package/src/cli/commands/config/index.ts

@@ -0,0 +1,12 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Command from '@effect/cli/Command';
+
+import { view } from './view';
+
+export const config = Command.make('config').pipe(
+  Command.withDescription('Config commands.'),
+  Command.withSubcommands([view]),
+);

package/src/cli/commands/config/view.ts

@@ -0,0 +1,26 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Command from '@effect/cli/Command';
+import * as Console from 'effect/Console';
+import * as Effect from 'effect/Effect';
+import * as Yaml from 'yaml';
+
+import { CommandConfig } from '@dxos/cli-util';
+import { ConfigService } from '@dxos/client';
+
+export const view = Command.make(
+  'view',
+  {},
+  Effect.fnUntraced(function* () {
+    const config = yield* ConfigService;
+    const { json } = yield* CommandConfig;
+
+    if (json) {
+      yield* Console.log(JSON.stringify(config.values, null, 2));
+    } else {
+      yield* Console.log(Yaml.stringify(config.values));
+    }
+  }),
+);

package/src/cli/commands/device/index.ts

@@ -0,0 +1,14 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Command from '@effect/cli/Command';
+
+import { info } from './info';
+import { list } from './list';
+import { update } from './update';
+
+export const device = Command.make('device').pipe(
+  Command.withDescription('Manage HALO devices.'),
+  Command.withSubcommands([info, list, update]),
+);

package/src/cli/commands/device/info/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './info';

package/src/cli/commands/device/info/info.test.ts

@@ -0,0 +1,29 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { describe, expect, it } from '@effect/vitest';
+import * as Effect from 'effect/Effect';
+
+import { TestConsole, TestLayer } from '@dxos/cli-util/testing';
+import { ClientService } from '@dxos/client';
+import { runAndForwardErrors } from '@dxos/effect';
+
+import { handler } from './info';
+
+describe('device info', () => {
+  it('should show device info', () =>
+    Effect.gen(function* () {
+      const client = yield* ClientService;
+      yield* Effect.tryPromise(() => client.halo.createIdentity());
+      yield* Effect.tryPromise(() => client.spaces.waitUntilReady());
+      yield* handler();
+      const logger = yield* TestConsole.TestConsole;
+      const logs = logger.logs;
+      expect(logs).toHaveLength(1);
+      const parsed = TestConsole.parseJson<{ deviceKey: string; profile: unknown }>(logs[0]);
+      expect(parsed).toHaveProperty('deviceKey');
+      expect(parsed).toHaveProperty('profile');
+      expect(parsed.deviceKey).toBe(client.halo.device?.deviceKey.toHex());
+    }).pipe(Effect.provide(TestLayer), Effect.scoped, runAndForwardErrors));
+});

package/src/cli/commands/device/info/info.ts

@@ -0,0 +1,50 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Command from '@effect/cli/Command';
+import * as Console from 'effect/Console';
+import * as Effect from 'effect/Effect';
+
+import { CommandConfig } from '@dxos/cli-util';
+import { print } from '@dxos/cli-util';
+import { ClientService } from '@dxos/client';
+import { DeviceType } from '@dxos/protocols/proto/dxos/halo/credentials';
+
+import { printDevice } from '../util';
+
+export const handler = Effect.fn(function* () {
+  const { json } = yield* CommandConfig;
+  const client = yield* ClientService;
+  yield* Effect.tryPromise(() => client.spaces.waitUntilReady());
+
+  const device = client.halo.device;
+  if (!device) {
+    if (json) {
+      yield* Console.log(JSON.stringify({ error: 'No device found' }, null, 2));
+    } else {
+      yield* Console.log('No device found.');
+    }
+    return;
+  }
+
+  if (json) {
+    yield* Console.log(
+      JSON.stringify(
+        {
+          deviceKey: device.deviceKey.toHex(),
+          profile: {
+            ...device.profile,
+            type: device.profile?.type ? DeviceType[device.profile?.type] : 'UNKNOWN',
+          },
+        },
+        null,
+        2,
+      ),
+    );
+  } else {
+    yield* Console.log(print(printDevice(device)));
+  }
+});
+
+export const info = Command.make('info', {}, handler).pipe(Command.withDescription('Show device info.'));

package/src/cli/commands/device/list/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './list';

package/src/cli/commands/device/list/list.test.ts

@@ -0,0 +1,31 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { describe, expect, it } from '@effect/vitest';
+import * as Effect from 'effect/Effect';
+
+import { TestConsole, TestLayer } from '@dxos/cli-util/testing';
+import { ClientService } from '@dxos/client';
+import { runAndForwardErrors } from '@dxos/effect';
+
+import { handler } from './list';
+
+describe('device list', () => {
+  it('should list devices', () =>
+    Effect.gen(function* () {
+      const client = yield* ClientService;
+      yield* Effect.tryPromise(() => client.halo.createIdentity());
+      yield* Effect.tryPromise(() => client.spaces.waitUntilReady());
+      yield* handler();
+      const logger = yield* TestConsole.TestConsole;
+      const logs = logger.logs;
+      expect(logs).toHaveLength(1);
+      const parsed = TestConsole.parseJson<Array<{ key: string; type: string; kind: string }>>(logs[0]);
+      expect(Array.isArray(parsed)).toBe(true);
+      expect(parsed.length).toBeGreaterThan(0);
+      expect(parsed[0]).toHaveProperty('key');
+      expect(parsed[0]).toHaveProperty('type');
+      expect(parsed[0]).toHaveProperty('kind');
+    }).pipe(Effect.provide(TestLayer), Effect.scoped, runAndForwardErrors));
+});

package/src/cli/commands/device/list/list.ts

@@ -0,0 +1,30 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Command from '@effect/cli/Command';
+import * as Console from 'effect/Console';
+import * as Effect from 'effect/Effect';
+
+import { CommandConfig } from '@dxos/cli-util';
+import { printList } from '@dxos/cli-util';
+import { ClientService } from '@dxos/client';
+
+import { mapDevices, printDevices } from '../util';
+
+export const handler = Effect.fn(function* () {
+  const { json } = yield* CommandConfig;
+  const client = yield* ClientService;
+  yield* Effect.tryPromise(() => client.spaces.waitUntilReady());
+
+  const devices = client.halo.devices.get();
+
+  if (json) {
+    yield* Console.log(JSON.stringify(mapDevices(devices), null, 2));
+  } else {
+    const formatted = printDevices(devices);
+    yield* Console.log(printList(formatted));
+  }
+});
+
+export const list = Command.make('list', {}, handler).pipe(Command.withDescription('List devices.'));

package/src/cli/commands/device/update/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './update';