@dxos/plugin-client 0.8.4-main.fffef41 → 0.8.4-staging.60fe92afc8

package/src/capabilities/app-graph-builder.ts

@@ -2,114 +2,114 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Atom } from '@effect-atom/atom-react';
-import * as Function from 'effect/Function';
-import * as Option from 'effect/Option';
+import * as Effect from 'effect/Effect';
 
-import { createIntent } from '@dxos/app-framework';
-import { Capabilities, type PluginContext, contributes } from '@dxos/app-framework';
-import { ROOT_ID, atomFromObservable, createExtension } from '@dxos/plugin-graph';
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
+import { Operation } from '@dxos/compute';
+import { CreateAtom, GraphBuilder, Node, NodeMatcher } from '@dxos/plugin-graph';
 import { ConnectionState } from '@dxos/react-client/mesh';
 
-import { meta } from '../meta';
-import { Account, ClientAction } from '../types';
+import { meta } from '#meta';
+import { ClientOperation } from '#operations';
+import { Account, ClientCapabilities } from '#types';
 
-import { ClientCapabilities } from './capabilities';
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    const extensions = yield* GraphBuilder.createExtension({
+      id: 'root',
+      match: NodeMatcher.whenRoot,
+      actions: () =>
+        Effect.succeed([
+          {
+            id: 'openUserAccount',
+            data: () => Operation.invoke(ClientOperation.ShareIdentity),
+            properties: {
+              label: ['open-user-account.label', { ns: meta.id }],
+              icon: 'ph--user--regular',
+              disposition: 'menu',
+              keyBinding: {
+                macos: 'meta+shift+.',
+                // TODO(wittjosiah): Test on windows to see if it behaves the same as linux.
+                windows: 'alt+shift+.',
+                linux: 'alt+shift+>',
+              },
+            },
+          },
+        ]),
+      connector: Effect.fnUntraced(function* (node, get) {
+        const client = yield* Capability.get(ClientCapabilities.Client);
+        const identity = get(CreateAtom.fromObservable(client.halo.identity));
+        const status = get(CreateAtom.fromObservable(client.mesh.networkStatus));
 
-export default (context: PluginContext) =>
-  contributes(
-    Capabilities.AppGraphBuilder,
-    createExtension({
-      id: meta.id,
-      actions: (node) =>
-        Atom.make((get) =>
-          Function.pipe(
-            get(node),
-            Option.flatMap((node) => (node.id === ROOT_ID ? Option.some(node) : Option.none())),
-            Option.map(() => {
-              return [
-                {
-                  id: `${meta.id}/open-user-account`,
-                  data: async () => {
-                    const { dispatchPromise: dispatch } = context.getCapability(Capabilities.IntentDispatcher);
-                    await dispatch(createIntent(ClientAction.ShareIdentity));
-                  },
-                  properties: {
-                    label: ['open user account label', { ns: meta.id }],
-                    icon: 'ph--user--regular',
-                    disposition: 'menu',
-                    keyBinding: {
-                      macos: 'meta+shift+.',
-                      // TODO(wittjosiah): Test on windows to see if it behaves the same as linux.
-                      windows: 'alt+shift+.',
-                      linux: 'alt+shift+>',
-                    },
-                  },
+        return [
+          Node.make({
+            id: Account.id,
+            type: meta.id,
+            properties: {
+              label: ['account.label', { ns: meta.id }],
+              icon: 'ph--user--regular',
+              disposition: 'user-account',
+              testId: 'clientPlugin.account',
+              // NOTE: This currently needs to be the identity key because the fallback is generated from hex.
+              userId: identity?.identityKey.toHex(),
+              hue: identity?.profile?.data?.hue,
+              emoji: identity?.profile?.data?.emoji,
+              status: status.swarm === ConnectionState.OFFLINE ? 'error' : 'active',
+            },
+            nodes: [
+              Node.make({
+                id: Account.Profile,
+                data: Account.Profile,
+                type: meta.id,
+                properties: {
+                  label: ['profile.label', { ns: meta.id }],
+                  icon: 'ph--user--regular',
                 },
-              ];
-            }),
-            Option.getOrElse(() => []),
-          ),
-        ),
-      connector: (node) =>
-        Atom.make((get) =>
-          Function.pipe(
-            get(node),
-            Option.flatMap((node) => (node.id === ROOT_ID ? Option.some(node) : Option.none())),
-            Option.map(() => {
-              const client = context.getCapability(ClientCapabilities.Client);
-              const identity = get(atomFromObservable(client.halo.identity));
-              const status = get(atomFromObservable(client.mesh.networkStatus));
-
-              return [
-                {
-                  id: Account.id,
-                  type: meta.id,
-                  properties: {
-                    label: ['account label', { ns: meta.id }],
-                    icon: 'ph--user--regular',
-                    disposition: 'user-account',
-                    // NOTE: This currently needs to be the identity key because the fallback is generated from hex.
-                    userId: identity?.identityKey.toHex(),
-                    hue: identity?.profile?.data?.hue,
-                    emoji: identity?.profile?.data?.emoji,
-                    status: status.swarm === ConnectionState.OFFLINE ? 'error' : 'active',
-                  },
-                  nodes: [
-                    {
-                      id: Account.Profile,
-                      data: Account.Profile,
-                      type: meta.id,
-                      properties: {
-                        label: ['profile label', { ns: meta.id }],
-                        icon: 'ph--user--regular',
-                      },
-                    },
-                    {
-                      id: Account.Devices,
-                      data: Account.Devices,
-                      type: meta.id,
-                      properties: {
-                        label: ['devices label', { ns: meta.id }],
-                        icon: 'ph--devices--regular',
-                        testId: 'clientPlugin.devices',
-                      },
-                    },
-                    {
-                      id: Account.Security,
-                      data: Account.Security,
-                      type: meta.id,
-                      properties: {
-                        label: ['security label', { ns: meta.id }],
-                        icon: 'ph--key--regular',
-                      },
-                    },
-                  ],
+              }),
+              Node.make({
+                id: Account.Account,
+                data: Account.Account,
+                type: meta.id,
+                properties: {
+                  label: ['account-panel.label', { ns: meta.id }],
+                  icon: 'ph--identification-card--regular',
+                },
+              }),
+              Node.make({
+                id: Account.Devices,
+                data: Account.Devices,
+                type: meta.id,
+                properties: {
+                  label: ['devices.label', { ns: meta.id }],
+                  icon: 'ph--devices--regular',
+                  testId: 'clientPlugin.devices',
+                },
+              }),
+              Node.make({
+                id: Account.Security,
+                data: Account.Security,
+                type: meta.id,
+                properties: {
+                  label: ['security.label', { ns: meta.id }],
+                  icon: 'ph--key--regular',
                 },
-              ];
-            }),
-            Option.getOrElse(() => []),
-          ),
-        ),
-    }),
-  );
+              }),
+              Node.make({
+                id: Account.Invitations,
+                data: Account.Invitations,
+                type: meta.id,
+                properties: {
+                  label: ['invitations-panel.label', { ns: meta.id }],
+                  icon: 'ph--ticket--regular',
+                },
+              }),
+            ],
+          }),
+        ];
+      }),
+    });
+
+    return Capability.contributes(AppCapabilities.AppGraphBuilder, extensions);
+  }),
+);

package/src/capabilities/client.ts

@@ -2,42 +2,79 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type PluginContext, contributes } from '@dxos/app-framework';
-import { Client } from '@dxos/react-client';
+import * as Effect from 'effect/Effect';
 
-import { ClientEvents } from '../events';
-import { type ClientPluginOptions } from '../types';
+import { Capabilities, Capability, Plugin } from '@dxos/app-framework';
+import { Client, ClientService } from '@dxos/client';
+import { EffectEx } from '@dxos/effect';
+import { log } from '@dxos/log';
 
-import { ClientCapabilities } from './capabilities';
+import { ClientEvents } from '#types';
+import { ClientCapabilities, type ClientPluginOptions } from '#types';
 
-type ClientCapabilityOptions = Omit<ClientPluginOptions, 'appKey' | 'invitationUrl' | 'invitationParam' | 'onReset'> & {
-  context: PluginContext;
-};
+type ClientCapabilityOptions = Omit<
+  ClientPluginOptions,
+  'appKey' | 'shareableLinkOrigin' | 'invitationPath' | 'invitationParam' | 'onReset'
+>;
 
-export default async ({ context, onClientInitialized, onSpacesReady, ...options }: ClientCapabilityOptions) => {
-  const client = new Client(options);
-  await client.initialize();
-  await onClientInitialized?.({ context, client });
+export default Capability.makeModule(
+  Effect.fnUntraced(function* ({ onClientInitialized, onSpacesReady, ...options }: ClientCapabilityOptions) {
+    const capabilityManager = yield* Capability.Service;
+    const pluginManager = yield* Plugin.Service;
 
-  // 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;
+    log('creating client');
+    const client = new Client(options);
+    log('initializing client (calling client.initialize())...');
+    yield* Effect.tryPromise(() => client.initialize());
+    log('client.initialize() returned successfully');
+    if (onClientInitialized) {
+      yield* onClientInitialized({ client }).pipe(
+        Effect.provideService(Capability.Service, capabilityManager),
+        Effect.provideService(Plugin.Service, pluginManager),
+      );
+    }
+    log('called client initialized callback');
+
+    // 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;
+        }
+      });
+    });
+
+    let spacesReadyFired = false;
+    const subscription = client.spaces.subscribe(async () => {
+      if (!spacesReadyFired) {
+        spacesReadyFired = true;
+        await Effect.gen(function* () {
+          yield* Plugin.activate(ClientEvents.SpacesReady);
+          if (onSpacesReady) {
+            yield* onSpacesReady({ client });
+          }
+        }).pipe(
+          Effect.provideService(Capability.Service, capabilityManager),
+          Effect.provideService(Plugin.Service, pluginManager),
+          EffectEx.runAndForwardErrors,
+        );
       }
     });
-  });
 
-  // TODO(burdon): The callback isn't called?
-  const subscription = client.spaces.isReady.subscribe(async (ready) => {
-    if (ready) {
-      await context.activatePromise(ClientEvents.SpacesReady);
-      await onSpacesReady?.({ context, client });
-    }
-  });
+    log('client capability ready');
 
-  return contributes(ClientCapabilities.Client, client, async () => {
-    subscription.unsubscribe();
-    await client.destroy();
-  });
-};
+    return [
+      // TODO(wittjosiah): Try to remove and prefer layer?
+      //  Perhaps move to using layer has source of truth and add a getter capability for the client.
+      Capability.contributes(ClientCapabilities.Client, client, () =>
+        Effect.gen(function* () {
+          log.info('client capability: destroying client');
+          // TODO(dmaretskyi): use scope for destroy.
+          subscription.unsubscribe();
+          yield* Effect.tryPromise(() => client.destroy());
+        }),
+      ),
+      Capability.contributes(Capabilities.Layer, ClientService.fromClient(client)),
+    ];
+  }),
+);

package/src/capabilities/hub-http-client.ts

@@ -0,0 +1,21 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import { HubHttpClient } from '@dxos/edge-client';
+
+import { ClientCapabilities } from '#types';
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    const client = yield* Capability.get(ClientCapabilities.Client);
+    const hubUrl = client.config.values?.runtime?.app?.env?.DX_HUB_URL;
+    if (!hubUrl) {
+      return [];
+    }
+    return Capability.contributes(ClientCapabilities.HubHttpClient, new HubHttpClient(hubUrl));
+  }),
+);

package/src/capabilities/index.ts

@@ -2,14 +2,21 @@
 // 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 AccountCache = Capability.lazy('AccountCache', () => import('./account-cache'));
+export const AppGraphBuilder = Capability.lazy('AppGraphBuilder', () => import('./app-graph-builder'));
+export const HubHttpClient = Capability.lazy('HubHttpClient', () => import('./hub-http-client'));
+export const Client = Capability.lazy('Client', () => import('./client'));
+export const LayerSpecs = Capability.lazy<void, Capability.Any[]>('LayerSpecs', () => import('./layer-specs'));
+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/layer-specs.ts

@@ -0,0 +1,92 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { ClientService } from '@dxos/client';
+import { Credential, LayerSpec } from '@dxos/compute';
+import { Database, Feed } from '@dxos/echo';
+import { createFeedServiceLayer } from '@dxos/echo-client';
+import { credentialsLayerFromDatabase } from '@dxos/functions';
+import { invariant } from '@dxos/invariant';
+
+import { ClientCapabilities } from '#types';
+
+//
+// Capability Module
+//
+// Contributes the core client/space service layer specs:
+//   - {@link ClientService} (application affinity).
+//   - {@link Database.Service}, {@link Feed.FeedService},
+//     {@link Credential.CredentialsService} (space affinity).
+//
+// Specs are declared at module level and resolve the underlying
+// {@link ClientCapabilities.Client} through the Effect layer graph (via
+// {@link Capability.Service}) rather than capturing it from an outer scope.
+//
+
+/**
+ * Provides the Effect-level {@link ClientService} backed by the
+ * {@link ClientCapabilities.Client} capability contributed by the plugin
+ * runtime.
+ */
+const ClientLayerSpec = LayerSpec.make(
+  {
+    affinity: 'application',
+    requires: [Capability.Service],
+    provides: [ClientService],
+  },
+  () =>
+    Layer.unwrapEffect(
+      Effect.gen(function* () {
+        const client = yield* Capability.get(ClientCapabilities.Client);
+        return ClientService.fromClient(client);
+      }).pipe(Effect.orDie),
+    ),
+);
+
+/**
+ * Space-scoped database/feed services resolved from the `Client`'s space
+ * registry. One spec for both so the `client.spaces.get` / `waitUntilReady`
+ * round-trip only happens once per space slice. Fails hard if the context is
+ * missing a `space` id or the client cannot resolve it — both indicate a
+ * configuration bug in the layer graph.
+ */
+const DatabaseLayerSpec = LayerSpec.make(
+  {
+    affinity: 'space',
+    requires: [ClientService],
+    provides: [Database.Service, Feed.FeedService],
+  },
+  (context) =>
+    Layer.unwrapEffect(
+      Effect.gen(function* () {
+        invariant(context.space, 'space context required for Database layer');
+        const client = yield* ClientService;
+        const space = client.spaces.get(context.space);
+        invariant(space, `space not found on client: ${context.space}`);
+        yield* Effect.promise(() => space.waitUntilReady());
+        return Layer.mergeAll(Database.layer(space.db), createFeedServiceLayer(space.queues));
+      }),
+    ),
+);
+
+const CredentialsLayerSpec = LayerSpec.make(
+  {
+    affinity: 'space',
+    requires: [Database.Service],
+    provides: [Credential.CredentialsService],
+  },
+  () => credentialsLayerFromDatabase(),
+);
+
+export default Capability.makeModule(() =>
+  Effect.succeed([
+    Capability.contributes(Capabilities.LayerSpec, ClientLayerSpec),
+    Capability.contributes(Capabilities.LayerSpec, DatabaseLayerSpec),
+    Capability.contributes(Capabilities.LayerSpec, CredentialsLayerSpec),
+  ]),
+);

package/src/capabilities/migrations.ts

@@ -2,24 +2,29 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Capabilities, type PluginContext, contributes } 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.AtomRegistry);
-  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,21 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+import { OperationHandlerSet } from '@dxos/compute';
+
+export const AppGraphBuilder = Capability.lazy('AppGraphBuilder', () => import('./app-graph-builder'));
+export const Client = Capability.lazy('Client', () => import('./client'));
+export const LayerSpecs = Capability.lazy<void, Capability.Any[]>('LayerSpecs', () => import('./layer-specs'));
+export const Migrations = Capability.lazy('Migrations', () => import('./migrations'));
+export const NavigationHandler = Capability.lazy(
+  'NavigationHandler',
+  () => import('./navigation-handler/navigation-handler'),
+);
+export type { NavigationHandlerOptions } from './navigation-handler';
+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);
+  }),
+);