@dxos/plugin-client 0.8.4-main.f9ba587 → 0.8.4-main.fcc0d83b33

package/src/capabilities/index.ts

@@ -2,14 +2,18 @@
 // Copyright 2025 DXOS.org
 //
 
-import { lazy } from '@dxos/app-framework';
+import { Capability } from '@dxos/app-framework';
+import { OperationHandlerSet } from '@dxos/compute';
 
-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 Migrations = lazy(async () => import('./migrations'));
-export const ReactContext = lazy(async () => import('./react-context'));
-export const ReactSurface = lazy(async () => import('./react-surface'));
-export const SchemaDefs = lazy(async () => import('./schema-defs'));
-
-export * from './capabilities';
+export const AppGraphBuilder = Capability.lazy('AppGraphBuilder', () => import('./app-graph-builder'));
+export const Client = Capability.lazy('Client', () => import('./client'));
+export const Migrations = Capability.lazy('Migrations', () => import('./migrations'));
+export { NavigationHandler } from './navigation-handler';
+export type { NavigationHandlerOptions } from './navigation-handler';
+export const OperationHandler = Capability.lazy<OperationHandlerSet.OperationHandlerSet>(
+  'OperationHandler',
+  () => import('./operation-handler'),
+);
+export const ReactContext = Capability.lazy('ReactContext', () => import('./react-context'));
+export const ReactSurface = Capability.lazy('ReactSurface', () => import('./react-surface'));
+export const SchemaDefs = Capability.lazy('SchemaDefs', () => import('./schema-defs'));

package/src/capabilities/migrations.ts

@@ -2,24 +2,29 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Capabilities, contributes, type PluginContext } from '@dxos/app-framework';
+import * as Effect from 'effect/Effect';
 
-import { ClientCapabilities } from './capabilities';
+import { Capabilities, Capability } from '@dxos/app-framework';
 
-export default (context: PluginContext) => {
-  const registry = context.getCapability(Capabilities.RxRegistry);
-  const client = context.getCapability(ClientCapabilities.Client);
+import { ClientCapabilities } from '#types';
 
-  // NOTE: Migrations are currently unidirectional and idempotent.
-  const cancel = registry.subscribe(
-    context.capabilities(ClientCapabilities.Migration),
-    (_migrations) => {
-      const migrations = Array.from(new Set(_migrations.flat()));
-      const spaces = client.spaces.get();
-      void Promise.all(spaces.map((space) => space.db.runMigrations(migrations)));
-    },
-    { immediate: true },
-  );
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    const registry = yield* Capability.get(Capabilities.AtomRegistry);
+    const client = yield* Capability.get(ClientCapabilities.Client);
+    const migrationsAtom = yield* Capability.atom(ClientCapabilities.Migration);
 
-  return contributes(Capabilities.Null, null, () => cancel());
-};
+    // NOTE: Migrations are currently unidirectional and idempotent.
+    const cancel = registry.subscribe(
+      migrationsAtom,
+      (_migrations: any[]) => {
+        const migrations = Array.from(new Set(_migrations.flat()));
+        const spaces = client.spaces.get();
+        void Promise.all(spaces.map((space: any) => space.internal.db.runMigrations(migrations)));
+      },
+      { immediate: true },
+    );
+
+    return Capability.contributes(Capabilities.Null, null, () => Effect.sync(() => cancel()));
+  }),
+);

package/src/capabilities/navigation-handler/index.ts

@@ -0,0 +1,9 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+
+export type { NavigationHandlerOptions } from './navigation-handler';
+
+export const NavigationHandler = Capability.lazy('NavigationHandler', () => import('./navigation-handler'));

package/src/capabilities/navigation-handler/navigation-handler.ts

@@ -0,0 +1,64 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
+import { Operation } from '@dxos/compute';
+import { log } from '@dxos/log';
+
+import { ClientOperation } from '../../operations';
+
+export type NavigationHandlerOptions = {
+  invitationProp?: string;
+  tokenProp?: string;
+  tokenTypeProp?: string;
+};
+
+/**
+ * NavigationHandler for auth-related URL params.
+ * Handles login tokens and device invitation codes.
+ */
+export default Capability.makeModule(
+  Effect.fnUntraced(function* ({
+    invitationProp = 'deviceInvitationCode',
+    tokenProp = 'token',
+    tokenTypeProp = 'type',
+  }: NavigationHandlerOptions = {}) {
+    const capabilities = yield* Capability.Service;
+    const operationService = yield* Capability.get(Capabilities.OperationInvoker);
+
+    const handler: AppCapabilities.NavigationHandler = (url: URL) =>
+      Effect.gen(function* () {
+        const token = url.searchParams.get(tokenProp);
+        const tokenType = url.searchParams.get(tokenTypeProp);
+        const invitationCode = url.searchParams.get(invitationProp);
+
+        if (token && tokenType === 'login') {
+          log('login token received via navigation');
+          removeQueryParam(tokenProp);
+          removeQueryParam(tokenTypeProp);
+          yield* Operation.invoke(ClientOperation.RedeemToken, { token });
+        } else if (invitationCode) {
+          log('device invitation received via navigation');
+          removeQueryParam(invitationProp);
+          yield* Operation.invoke(ClientOperation.JoinIdentity, { invitationCode });
+        }
+      }).pipe(
+        Effect.provideService(Capability.Service, capabilities),
+        Effect.provideService(Operation.Service, operationService),
+        Effect.orDie,
+      );
+
+    return Capability.contributes(AppCapabilities.NavigationHandler, handler);
+  }),
+);
+
+/** Remove a query param from the current browser URL. */
+const removeQueryParam = (key: string) => {
+  const current = new URL(window.location.href);
+  current.searchParams.delete(key);
+  history.replaceState(null, '', current.pathname + current.search);
+};

package/src/capabilities/node.ts

@@ -0,0 +1,13 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+import { OperationHandlerSet } from '@dxos/compute';
+
+export const Client = Capability.lazy('Client', () => import('./client'));
+export const OperationHandler = Capability.lazy<OperationHandlerSet.OperationHandlerSet>(
+  'OperationHandler',
+  () => import('./operation-handler'),
+);
+export const SchemaDefs = Capability.lazy('SchemaDefs', () => import('./schema-defs'));

package/src/capabilities/operation-handler.ts

@@ -0,0 +1,16 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import type { OperationHandlerSet } from '@dxos/compute';
+
+import { ClientOperationHandlerSet } from '#operations';
+
+export default Capability.makeModule<OperationHandlerSet.OperationHandlerSet>(
+  Effect.fnUntraced(function* () {
+    return Capability.contributes(Capabilities.OperationHandler, ClientOperationHandlerSet);
+  }),
+);

package/src/capabilities/react-context.tsx

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

package/src/capabilities/react-surface.tsx

@@ -2,66 +2,69 @@
 // Copyright 2025 DXOS.org
 //
 
-import React from 'react';
+import * as Effect from 'effect/Effect';
+import React, { type ComponentProps } from 'react';
 
-import { createSurface, Capabilities, contributes } from '@dxos/app-framework';
-import { type JoinPanelProps } from '@dxos/shell/react';
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { Surface } from '@dxos/app-framework/ui';
+import { AppSurface } from '@dxos/app-toolkit/ui';
 
 import {
   DevicesContainer,
-  JOIN_DIALOG,
   JoinDialog,
   ProfileContainer,
-  RECOVERY_CODE_DIALOG,
   RecoveryCodeDialog,
   RecoveryCredentialsContainer,
-  RESET_DIALOG,
   ResetDialog,
-  type ResetDialogProps,
-  type RecoveryCodeDialogProps,
-} from '../components';
-import { Account, type ClientPluginOptions } from '../types';
+} from '#containers';
+import { Account, type ClientPluginOptions } from '#types';
+
+import { JOIN_DIALOG, RECOVERY_CODE_DIALOG, RESET_DIALOG } from '../constants';
 
 type ReactSurfaceOptions = Pick<ClientPluginOptions, 'onReset'> & {
   createInvitationUrl: (invitationCode: string) => string;
 };
 
-export default ({ createInvitationUrl, onReset }: ReactSurfaceOptions) =>
-  contributes(Capabilities.ReactSurface, [
-    createSurface({
-      id: Account.Profile,
-      role: 'article',
-      filter: (data): data is any => data.subject === Account.Profile,
-      component: () => <ProfileContainer />,
-    }),
-    createSurface({
-      id: Account.Devices,
-      role: 'article',
-      filter: (data): data is any => data.subject === Account.Devices,
-      component: ({ data }) => <DevicesContainer createInvitationUrl={createInvitationUrl} />,
-    }),
-    createSurface({
-      id: Account.Security,
-      role: 'article',
-      filter: (data): data is any => data.subject === Account.Security,
-      component: () => <RecoveryCredentialsContainer />,
-    }),
-    createSurface({
-      id: JOIN_DIALOG,
-      role: 'dialog',
-      filter: (data): data is { props: JoinPanelProps } => data.component === JOIN_DIALOG,
-      component: ({ data }) => <JoinDialog {...data.props} />,
-    }),
-    createSurface({
-      id: RECOVERY_CODE_DIALOG,
-      role: 'dialog',
-      filter: (data): data is { props: RecoveryCodeDialogProps } => data.component === RECOVERY_CODE_DIALOG,
-      component: ({ data }) => <RecoveryCodeDialog {...data.props} />,
-    }),
-    createSurface({
-      id: RESET_DIALOG,
-      role: 'dialog',
-      filter: (data): data is { props: ResetDialogProps } => data.component === RESET_DIALOG,
-      component: ({ data }) => <ResetDialog {...data.props} onReset={onReset} />,
-    }),
-  ]);
+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,
+        filter: AppSurface.literal(AppSurface.Article, Account.Profile),
+        component: () => <ProfileContainer />,
+      }),
+      Surface.create({
+        id: Account.Devices,
+        filter: AppSurface.literal(AppSurface.Article, Account.Devices),
+        component: () => <DevicesContainer createInvitationUrl={createInvitationUrl} />,
+      }),
+      Surface.create({
+        id: Account.Security,
+        filter: AppSurface.literal(AppSurface.Article, Account.Security),
+        component: () => <RecoveryCredentialsContainer />,
+      }),
+      Surface.create({
+        id: JOIN_DIALOG,
+        filter: AppSurface.component<ComponentProps<typeof JoinDialog>>(AppSurface.Dialog, JOIN_DIALOG),
+        component: ({ data }) => <JoinDialog {...data.props} />,
+      }),
+      Surface.create({
+        id: RECOVERY_CODE_DIALOG,
+        filter: AppSurface.component<ComponentProps<typeof RecoveryCodeDialog>>(
+          AppSurface.Dialog,
+          RECOVERY_CODE_DIALOG,
+        ),
+        component: ({ data }) => <RecoveryCodeDialog {...data.props} />,
+      }),
+      Surface.create({
+        id: RESET_DIALOG,
+        filter: AppSurface.component<Pick<ComponentProps<typeof ResetDialog>, 'mode'>>(AppSurface.Dialog, RESET_DIALOG),
+        component: ({ data }) => (
+          <ResetDialog {...data.props} onReset={onReset} capabilityManager={capabilityManager} />
+        ),
+      }),
+    ]);
+  }),
+);

package/src/capabilities/schema-defs.ts

@@ -2,28 +2,35 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Capabilities, contributes, type PluginContext } from '@dxos/app-framework';
-import { type TypedObject } from '@dxos/echo-schema';
+import * as Effect from 'effect/Effect';
 
-import { ClientCapabilities } from './capabilities';
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
+import { type Type } from '@dxos/echo';
 
-export default (context: PluginContext) => {
-  const registry = context.getCapability(Capabilities.RxRegistry);
-  const client = context.getCapability(ClientCapabilities.Client);
+import { ClientCapabilities } from '#types';
 
-  // TODO(wittjosiah): Unregister schemas when they are disabled.
-  let previous: TypedObject[] = [];
-  const cancel = registry.subscribe(
-    context.capabilities(ClientCapabilities.Schema),
-    (_schemas) => {
-      const schemas = Array.from(new Set(_schemas.flat()));
-      // TODO(wittjosiah): Filter out schemas which the client has already registered.
-      const newSchemas = schemas.filter((schema) => !previous.includes(schema));
-      previous = schemas;
-      client.addTypes(newSchemas);
-    },
-    { immediate: true },
-  );
+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);
 
-  return contributes(Capabilities.Null, null, () => cancel());
-};
+    // 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,29 @@
+//
+// 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';
+import { DX_CONFIG, getProfileConfigPath } from '@dxos/client-protocol';
+
+export const view = Command.make(
+  'view',
+  {},
+  Effect.fnUntraced(function* () {
+    const config = yield* ConfigService;
+    const { json, profile } = yield* CommandConfig;
+    const configPath = getProfileConfigPath(DX_CONFIG, profile);
+
+    if (json) {
+      yield* Console.log(JSON.stringify(config.values, null, 2));
+    } else {
+      yield* Console.log(`Path: ${configPath}`);
+      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,28 @@
+//
+// 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* 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,48 @@
+//
+// 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;
+  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,30 @@
+//
+// 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* 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,28 @@
+//
+// 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;
+  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';