@dxos/client-services 0.10.0 → 0.11.0

package/src/packlets/devtools/devtools.ts

@@ -2,12 +2,15 @@
 // Copyright 2022 DXOS.org
 //
 
+import * as Effect from 'effect/Effect';
+import * as EffectStream from 'effect/Stream';
+
 import { Event as AsyncEvent } from '@dxos/async';
 import { Stream } from '@dxos/codec-protobuf/stream';
 import { type Config } from '@dxos/config';
+import { Context } from '@dxos/context';
 import {
   type ClearSnapshotsRequest,
-  type DevtoolsHost, // TODO(burdon): Rename DevtoolsService
   type EnableDebugLoggingRequest,
   type EnableDebugLoggingResponse,
   type Event,
@@ -41,8 +44,10 @@ import {
   type SubscribeToSignalStatusResponse,
   type SubscribeToSpacesRequest,
   type SubscribeToSpacesResponse,
+  type SubscribeToSwarmInfoRequest,
   type SubscribeToSwarmInfoResponse,
 } from '@dxos/protocols/proto/dxos/devtools/host';
+import { type DevtoolsHost } from '@dxos/protocols/rpc';
 
 import { type ServiceContext } from '../services';
 import { subscribeToFeedBlocks, subscribeToFeeds } from './feeds';
@@ -66,134 +71,187 @@ export type DevtoolsServiceProps = {
 /**
  * @deprecated
  */
-export class DevtoolsServiceImpl implements DevtoolsHost {
-  constructor(private readonly params: DevtoolsServiceProps) {}
+export class DevtoolsServiceImpl implements DevtoolsHost.Handlers {
+  'constructor'(private readonly params: DevtoolsServiceProps) {}
 
-  events(_request: void): Stream<Event> {
-    return new Stream<Event>(({ next }) => {
-      this.params.events.ready.on(() => {
-        next({ ready: {} });
+  ['DevtoolsHost.events'](): EffectStream.Stream<Event, Error> {
+    return EffectStream.async<Event, Error>((emit) => {
+      const ctx = Context.default();
+      this.params.events.ready.on(ctx, () => {
+        void emit.single({ ready: {} });
       });
+
+      return Effect.promise(() => ctx.dispose());
     });
   }
 
-  async getConfig(_request: void): Promise<GetConfigResponse> {
-    return { config: JSON.stringify(this.params.config.values) }; // 😨
+  ['DevtoolsHost.getConfig'](): Effect.Effect<GetConfigResponse, Error> {
+    return Effect.sync(() => ({ config: JSON.stringify(this.params.config.values) })); // 😨
   }
 
-  async getStorageInfo(): Promise<StorageInfo> {
-    const navigatorInfo = typeof navigator === 'object' ? await navigator.storage.estimate() : undefined;
+  ['DevtoolsHost.getStorageInfo'](): Effect.Effect<StorageInfo, Error> {
+    return Effect.tryPromise({
+      try: async () => {
+        const navigatorInfo = typeof navigator === 'object' ? await navigator.storage.estimate() : undefined;
 
-    return {
-      type: 'sqlite',
-      storageUsage: navigatorInfo?.usage ?? 0,
-      originUsage: navigatorInfo?.usage ?? 0,
-      usageQuota: navigatorInfo?.quota ?? 0,
-    };
+        return {
+          type: 'sqlite',
+          storageUsage: navigatorInfo?.usage ?? 0,
+          originUsage: navigatorInfo?.usage ?? 0,
+          usageQuota: navigatorInfo?.quota ?? 0,
+        };
+      },
+      catch: (error) => error as Error,
+    });
   }
 
-  async getBlobs(): Promise<GetBlobsResponse> {
-    return {
-      blobs: await this.params.context.blobStore.list(),
-    };
+  ['DevtoolsHost.getBlobs'](): Effect.Effect<GetBlobsResponse, Error> {
+    return Effect.tryPromise({
+      try: async () => ({
+        blobs: await this.params.context.blobStore.list(),
+      }),
+      catch: (error) => error as Error,
+    });
   }
 
-  async getSnapshots(): Promise<GetSnapshotsResponse> {
-    return {
+  ['DevtoolsHost.getSnapshots'](): Effect.Effect<GetSnapshotsResponse, Error> {
+    return Effect.sync(() => ({
       snapshots: [],
-    };
+    }));
   }
 
-  resetStorage(_request: ResetStorageRequest): Promise<void> {
-    throw new Error();
+  ['DevtoolsHost.resetStorage'](_request: ResetStorageRequest): Effect.Effect<void, Error> {
+    return Effect.fail(new Error());
   }
 
-  enableDebugLogging(_request: EnableDebugLoggingRequest): Promise<EnableDebugLoggingResponse> {
-    throw new Error();
+  ['DevtoolsHost.enableDebugLogging'](
+    _request: EnableDebugLoggingRequest,
+  ): Effect.Effect<EnableDebugLoggingResponse, Error> {
+    return Effect.fail(new Error());
   }
 
-  disableDebugLogging(_request: EnableDebugLoggingRequest): Promise<EnableDebugLoggingResponse> {
-    throw new Error();
+  ['DevtoolsHost.disableDebugLogging'](
+    _request: EnableDebugLoggingRequest,
+  ): Effect.Effect<EnableDebugLoggingResponse, Error> {
+    return Effect.fail(new Error());
   }
 
-  subscribeToKeyringKeys(_request: SubscribeToKeyringKeysRequest): Stream<SubscribeToKeyringKeysResponse> {
-    return subscribeToKeyringKeys({ keyring: this.params.context.keyring });
+  ['DevtoolsHost.subscribeToKeyringKeys'](
+    _request: SubscribeToKeyringKeysRequest,
+  ): EffectStream.Stream<SubscribeToKeyringKeysResponse, Error> {
+    return toEffectStream(subscribeToKeyringKeys({ keyring: this.params.context.keyring }));
   }
 
-  subscribeToCredentialMessages(
+  ['DevtoolsHost.subscribeToCredentialMessages'](
     _request: SubscribeToCredentialMessagesRequest,
-  ): Stream<SubscribeToCredentialMessagesResponse> {
-    throw new Error();
+  ): EffectStream.Stream<SubscribeToCredentialMessagesResponse, Error> {
+    return EffectStream.fail(new Error());
   }
 
-  subscribeToSpaces(_request: SubscribeToSpacesRequest): Stream<SubscribeToSpacesResponse> {
-    return subscribeToSpaces(this.params.context, _request);
+  ['DevtoolsHost.subscribeToSpaces'](
+    request: SubscribeToSpacesRequest,
+  ): EffectStream.Stream<SubscribeToSpacesResponse, Error> {
+    return toEffectStream(subscribeToSpaces(this.params.context, request));
   }
 
-  subscribeToItems(_request: SubscribeToItemsRequest): Stream<SubscribeToItemsResponse> {
-    throw new Error();
+  ['DevtoolsHost.subscribeToItems'](
+    _request: SubscribeToItemsRequest,
+  ): EffectStream.Stream<SubscribeToItemsResponse, Error> {
+    return EffectStream.fail(new Error());
   }
 
-  subscribeToFeeds(_request: SubscribeToFeedsRequest): Stream<SubscribeToFeedsResponse> {
-    return subscribeToFeeds(this.params.context, _request);
+  ['DevtoolsHost.subscribeToFeeds'](
+    request: SubscribeToFeedsRequest,
+  ): EffectStream.Stream<SubscribeToFeedsResponse, Error> {
+    return toEffectStream(subscribeToFeeds(this.params.context, request));
   }
 
-  subscribeToFeedBlocks(_request: SubscribeToFeedBlocksRequest): Stream<SubscribeToFeedBlocksResponse> {
-    return subscribeToFeedBlocks({ feedStore: this.params.context.feedStore }, _request);
+  ['DevtoolsHost.subscribeToFeedBlocks'](
+    request: SubscribeToFeedBlocksRequest,
+  ): EffectStream.Stream<SubscribeToFeedBlocksResponse, Error> {
+    return toEffectStream(subscribeToFeedBlocks({ feedStore: this.params.context.feedStore }, request));
   }
 
-  getSpaceSnapshot(_request: GetSpaceSnapshotRequest): Promise<GetSpaceSnapshotResponse> {
-    throw new Error();
+  ['DevtoolsHost.subscribeToMetadata'](): EffectStream.Stream<SubscribeToMetadataResponse, Error> {
+    return toEffectStream(subscribeToMetadata({ context: this.params.context }));
   }
 
-  saveSpaceSnapshot(_request: SaveSpaceSnapshotRequest): Promise<SaveSpaceSnapshotResponse> {
-    throw new Error();
+  ['DevtoolsHost.getSpaceSnapshot'](_request: GetSpaceSnapshotRequest): Effect.Effect<GetSpaceSnapshotResponse, Error> {
+    return Effect.fail(new Error());
   }
 
-  clearSnapshots(_request: ClearSnapshotsRequest): Promise<void> {
-    throw new Error();
+  ['DevtoolsHost.saveSpaceSnapshot'](
+    _request: SaveSpaceSnapshotRequest,
+  ): Effect.Effect<SaveSpaceSnapshotResponse, Error> {
+    return Effect.fail(new Error());
   }
 
-  getNetworkPeers(_request: GetNetworkPeersRequest): Promise<GetNetworkPeersResponse> {
-    throw new Error();
+  ['DevtoolsHost.clearSnapshots'](_request: ClearSnapshotsRequest): Effect.Effect<void, Error> {
+    return Effect.fail(new Error());
   }
 
-  subscribeToNetworkTopics(_request: void): Stream<SubscribeToNetworkTopicsResponse> {
-    throw new Error();
+  ['DevtoolsHost.getNetworkPeers'](_request: GetNetworkPeersRequest): Effect.Effect<GetNetworkPeersResponse, Error> {
+    return Effect.fail(new Error());
   }
 
-  subscribeToSignalStatus(_request: void): Stream<SubscribeToSignalStatusResponse> {
-    return subscribeToNetworkStatus({ signalManager: this.params.context.signalManager });
+  ['DevtoolsHost.subscribeToNetworkTopics'](): EffectStream.Stream<SubscribeToNetworkTopicsResponse, Error> {
+    return EffectStream.fail(new Error());
   }
 
-  subscribeToSignal(): Stream<SignalResponse> {
-    return subscribeToSignal({ signalManager: this.params.context.signalManager });
+  ['DevtoolsHost.subscribeToSignalStatus'](): EffectStream.Stream<SubscribeToSignalStatusResponse, Error> {
+    return toEffectStream(subscribeToNetworkStatus({ signalManager: this.params.context.signalManager }));
   }
 
-  subscribeToSwarmInfo(): Stream<SubscribeToSwarmInfoResponse> {
-    return subscribeToSwarmInfo({ networkManager: this.params.context.networkManager });
+  ['DevtoolsHost.subscribeToSignal'](): EffectStream.Stream<SignalResponse, Error> {
+    return toEffectStream(
+      subscribeToSignal({
+        signalManager: this.params.context.signalManager,
+        networkManager: this.params.context.networkManager,
+      }),
+    );
   }
 
-  subscribeToMetadata(): Stream<SubscribeToMetadataResponse> {
-    return subscribeToMetadata({ context: this.params.context });
+  ['DevtoolsHost.subscribeToSwarmInfo'](
+    _request: SubscribeToSwarmInfoRequest,
+  ): EffectStream.Stream<SubscribeToSwarmInfoResponse, Error> {
+    return toEffectStream(subscribeToSwarmInfo({ networkManager: this.params.context.networkManager }));
   }
 
-  async exportSqliteDatabase(): Promise<ExportSqliteDatabaseResponse> {
-    return {
-      data: await this.params.exportSqliteDatabase(),
-    };
+  ['DevtoolsHost.exportSqliteDatabase'](): Effect.Effect<ExportSqliteDatabaseResponse, Error> {
+    return Effect.tryPromise({
+      try: async () => ({
+        data: await this.params.exportSqliteDatabase(),
+      }),
+      catch: (error) => error as Error,
+    });
   }
 
-  async runSqliteQuery(request: RunSqliteQueryRequest): Promise<RunSqliteQueryResponse> {
-    try {
-      const parsedParams = request.params ? JSON.parse(request.params) : undefined;
-      if (parsedParams !== undefined && !Array.isArray(parsedParams)) {
-        throw new Error('Query params must be a JSON array.');
+  ['DevtoolsHost.runSqliteQuery'](request: RunSqliteQueryRequest): Effect.Effect<RunSqliteQueryResponse, Error> {
+    return Effect.promise(async () => {
+      try {
+        const parsedParams = request.params ? JSON.parse(request.params) : undefined;
+        if (parsedParams !== undefined && !Array.isArray(parsedParams)) {
+          throw new Error('Query params must be a JSON array.');
+        }
+        const rows = await this.params.runSqliteQuery(request.query, parsedParams);
+        return { rows: JSON.stringify(rows) };
+      } catch (err) {
+        return { rows: '[]', error: err instanceof Error ? err.message : String(err) };
       }
-      const rows = await this.params.runSqliteQuery(request.query, parsedParams);
-      return { rows: JSON.stringify(rows) };
-    } catch (err) {
-      return { rows: '[]', error: err instanceof Error ? err.message : String(err) };
-    }
+    });
   }
 }
+
+/**
+ * Bridges a codec-protobuf {@link Stream} into an Effect {@link EffectStream.Stream}.
+ * The underlying stream is closed (disposing its resources) when the Effect stream terminates.
+ */
+const toEffectStream = <T>(stream: Stream<T>): EffectStream.Stream<T, Error> =>
+  EffectStream.async<T, Error>((emit) => {
+    stream.subscribe(
+      (message) => void emit.single(message),
+      (error) => (error ? void emit.fail(error) : void emit.end()),
+    );
+
+    return Effect.promise(() => stream.close());
+  });

package/src/packlets/devtools/feeds.ts

@@ -4,7 +4,6 @@
 
 import { SubscriptionList } from '@dxos/async';
 import { Stream } from '@dxos/codec-protobuf/stream';
-import { type SpaceManager } from '@dxos/echo-host';
 import { FeedIterator, type FeedStore, type FeedWrapper } from '@dxos/feed-store';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
@@ -17,6 +16,8 @@ import {
 import { type FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
 import { ComplexMap } from '@dxos/util';
 
+import { type SpaceManager } from '../space';
+
 type FeedInfo = {
   feed: FeedWrapper<FeedMessage>;
   owner?: SubscribeToFeedsResponse.FeedOwner;

package/src/packlets/devtools/network.ts

@@ -5,7 +5,8 @@
 import { Stream } from '@dxos/codec-protobuf/stream';
 import { Context } from '@dxos/context';
 import { PublicKey } from '@dxos/keys';
-import { type SignalManager } from '@dxos/messaging';
+import { log } from '@dxos/log';
+import { type SignalManager, type UnsubscribeCallback } from '@dxos/messaging';
 import { type SwarmNetworkManager } from '@dxos/network-manager';
 import {
   type GetNetworkPeersRequest,
@@ -31,19 +32,47 @@ export const subscribeToNetworkStatus = ({ signalManager }: { signalManager: Sig
     update();
   });
 
-export const subscribeToSignal = ({ signalManager }: { signalManager: SignalManager }) =>
+export const subscribeToSignal = ({
+  signalManager,
+  networkManager,
+}: {
+  signalManager: SignalManager;
+  networkManager: SwarmNetworkManager;
+}) =>
   new Stream<SignalResponse>(({ next }) => {
     const ctx = new Context();
-    signalManager.onMessage.on(ctx, (message) => {
-      next({
-        message: {
-          author: PublicKey.from(message.author.peerKey).asUint8Array(),
-          recipient: PublicKey.from(message.recipient.peerKey).asUint8Array(),
-          payload: message.payload,
-        },
-        receivedAt: new Date(),
-      });
-    });
+
+    // Observe point-to-point messages delivered to this node's own peer. The subscription owns its
+    // routing and teardown (DX-1125); with no local peer yet there is nothing to observe.
+    let unsubscribe: UnsubscribeCallback | undefined;
+    const peer = networkManager.getPeerInfo();
+    if (peer) {
+      void signalManager
+        .subscribeMessages({
+          peer,
+          onMessage: (message) => {
+            next({
+              message: {
+                author: PublicKey.from(message.author.peerKey).asUint8Array(),
+                recipient: message.recipient
+                  ? PublicKey.from(message.recipient.peerKey).asUint8Array()
+                  : new Uint8Array(),
+                payload: message.payload,
+              },
+              receivedAt: new Date(),
+            });
+          },
+        })
+        .then((unsub) => {
+          if (ctx.disposed) {
+            void unsub();
+          } else {
+            unsubscribe = unsub;
+          }
+        })
+        .catch((err) => log.catch(err));
+    }
+
     signalManager.swarmEvent.on(ctx, (swarmEvent) => {
       next({
         swarmEvent: swarmEvent.peerAvailable
@@ -59,6 +88,7 @@ export const subscribeToSignal = ({ signalManager }: { signalManager: SignalMana
       });
     });
     return () => {
+      void unsubscribe?.();
       return ctx.dispose();
     };
   });

package/src/packlets/devtools/spaces.ts

@@ -3,7 +3,6 @@
 //
 
 import { Stream } from '@dxos/codec-protobuf/stream';
-import { type Space } from '@dxos/echo-host';
 import {
   type SubscribeToSpacesRequest,
   type SubscribeToSpacesResponse,
@@ -11,6 +10,7 @@ import {
 import { type SpaceMetadata } from '@dxos/protocols/proto/dxos/echo/metadata';
 
 import { type ServiceContext } from '../services';
+import { type Space } from '../space';
 
 export const subscribeToSpaces = (context: ServiceContext, { spaceKeys = [] }: SubscribeToSpacesRequest) => {
   return new Stream<SubscribeToSpacesResponse>(({ next }) => {

package/src/packlets/diagnostics/diagnostics-broadcast.ts

@@ -2,7 +2,7 @@
 // Copyright 2024 DXOS.org
 //
 
-import { type SystemService } from '@dxos/protocols/proto/dxos/client/services';
+import { type SystemService } from '@dxos/protocols/rpc';
 
 import {
   type CollectDiagnosticsBroadcastHandler,
@@ -13,7 +13,9 @@ export const createCollectDiagnosticsBroadcastSender = (): CollectDiagnosticsBro
   return { broadcastDiagnosticsRequest: async () => undefined };
 };
 
-export const createCollectDiagnosticsBroadcastHandler = (_: SystemService): CollectDiagnosticsBroadcastHandler => {
+export const createCollectDiagnosticsBroadcastHandler = (
+  _: SystemService.Handlers,
+): CollectDiagnosticsBroadcastHandler => {
   return {
     start: () => {},
     stop: () => {},

package/src/packlets/diagnostics/diagnostics-collector.ts

@@ -2,11 +2,10 @@
 // Copyright 2024 DXOS.org
 //
 
-import { type ClientServicesProvider, ClientServicesProviderResource } from '@dxos/client-protocol';
-import { type Config, ConfigResource } from '@dxos/config';
+import { type ClientServicesProvider } from '@dxos/client-protocol';
+import { type Config } from '@dxos/config';
 import { GetDiagnosticsRequest } from '@dxos/protocols/proto/dxos/client/services';
-import { TRACE_PROCESSOR } from '@dxos/tracing';
-import { type JsonKeyOptions, isNonNullable, jsonKeyReplacer } from '@dxos/util';
+import { type JsonKeyOptions, jsonKeyReplacer } from '@dxos/util';
 
 import { createCollectDiagnosticsBroadcastSender } from './diagnostics-broadcast';
 
@@ -25,8 +24,8 @@ export class DiagnosticsCollector {
   private static broadcastSender = createCollectDiagnosticsBroadcastSender();
 
   public static async collect(
-    config: Config | Config[] = findConfigs(),
-    services: ClientServicesProvider | null = findSystemServiceProvider(),
+    config: Config | Config[] = [],
+    services: ClientServicesProvider | null = null,
     options: JsonKeyOptions = {},
   ): Promise<any> {
     const serviceDiagnostics = await services?.services?.SystemService?.getDiagnostics(
@@ -42,7 +41,6 @@ export class DiagnosticsCollector {
 
     const clientDiagnostics = {
       config,
-      trace: TRACE_PROCESSOR.getDiagnostics(),
     };
 
     const diagnostics =
@@ -56,14 +54,3 @@ export class DiagnosticsCollector {
     return JSON.parse(JSON.stringify(diagnostics, jsonKeyReplacer(options)));
   }
 }
-
-const findSystemServiceProvider = (): ClientServicesProvider | null => {
-  const serviceProviders = TRACE_PROCESSOR.findResourcesByAnnotation(ClientServicesProviderResource);
-  const providerResource = serviceProviders.find((r) => r.instance.deref()?.services?.SystemService != null);
-  return providerResource?.instance?.deref() ?? null;
-};
-
-const findConfigs = (): Config[] => {
-  const configs = TRACE_PROCESSOR.findResourcesByAnnotation(ConfigResource);
-  return configs.map((r) => r.instance.deref()).filter(isNonNullable);
-};

package/src/packlets/diagnostics/diagnostics.ts

@@ -13,7 +13,6 @@ import { STORAGE_VERSION } from '@dxos/protocols';
 import {
   type Device,
   type Identity,
-  type LogEntry,
   type Metrics,
   type NetworkStatus,
   type Platform,
@@ -23,8 +22,6 @@ import {
 import { type SubscribeToFeedsResponse } from '@dxos/protocols/proto/dxos/devtools/host';
 import { type SwarmInfo } from '@dxos/protocols/proto/dxos/devtools/swarm';
 import { type Epoch } from '@dxos/protocols/proto/dxos/halo/credentials';
-import { type Resource } from '@dxos/protocols/proto/dxos/tracing';
-import { TRACE_PROCESSOR } from '@dxos/tracing';
 
 import { DXOS_VERSION } from '../../version';
 import { type ServiceContext } from '../services';
@@ -36,10 +33,8 @@ const DEFAULT_TIMEOUT = 1_000;
 export type Diagnostics = {
   client: {
     config: ConfigProto;
-    trace: TraceDiagnostic;
   };
   services: {
-    trace: TraceDiagnostic;
     created: string;
     platform: Platform;
     config?: ConfigProto;
@@ -60,11 +55,6 @@ export type Diagnostics = {
   };
 };
 
-export type TraceDiagnostic = {
-  resources: Record<string, Resource>;
-  logs: LogEntry[];
-};
-
 // TODO(burdon): Normalize for ECHO/HALO.
 export type SpaceStats = {
   key: PublicKey;
@@ -99,7 +89,6 @@ export const createDiagnostics = async (
         version: STORAGE_VERSION,
       },
     },
-    trace: TRACE_PROCESSOR.getDiagnostics(),
   };
 
   await Promise.all([

package/src/packlets/identity/authenticator.ts

@@ -5,12 +5,13 @@
 import { type Event, Trigger } from '@dxos/async';
 import { Context } from '@dxos/context';
 import { type CredentialSigner, verifyCredential } from '@dxos/credentials';
-import { type AuthProvider, type AuthVerifier } from '@dxos/echo-host';
 import { type PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { schema } from '@dxos/protocols/proto';
 import { type ComplexSet } from '@dxos/util';
 
+import { type AuthProvider, type AuthVerifier } from '../space';
+
 const Credential = schema.getCodecForType('dxos.halo.credentials.Credential');
 
 export const createAuthProvider =

package/src/packlets/identity/contacts-service.ts

@@ -2,62 +2,40 @@
 // Copyright 2024 DXOS.org
 //
 
+import * as Effect from 'effect/Effect';
+import * as EffectStream from 'effect/Stream';
+
 import { SubscriptionList, UpdateScheduler, scheduleTask } from '@dxos/async';
-import { Stream } from '@dxos/codec-protobuf/stream';
+import { Context } from '@dxos/context';
 import { type MemberInfo } from '@dxos/credentials';
-import { type SpaceManager } from '@dxos/echo-host';
 import { PublicKey } from '@dxos/keys';
-import { type Contact, type ContactBook, type ContactsService } from '@dxos/protocols/proto/dxos/client/services';
+import { type Contact, type ContactBook } from '@dxos/protocols/proto/dxos/client/services';
+import { type ContactsService } from '@dxos/protocols/rpc';
 import { ComplexMap, ComplexSet } from '@dxos/util';
 
+import { type SpaceManager } from '../space';
 import { type DataSpaceManager } from '../spaces';
 import { type IdentityManager } from './identity-manager';
 
-export class ContactsServiceImpl implements ContactsService {
-  constructor(
+export class ContactsServiceImpl implements ContactsService.Handlers {
+  'constructor'(
     private readonly _identityManager: IdentityManager,
     private readonly _spaceManager: SpaceManager,
     private readonly _dataSpaceManagerProvider: () => Promise<DataSpaceManager>,
   ) {}
 
-  async getContacts(): Promise<ContactBook> {
-    const identity = this._identityManager.identity;
-    if (identity == null) {
-      return { contacts: [] };
-    }
-    const contacts = [...this._spaceManager.spaces.values()]
-      .flatMap((s) => [...s.spaceState.members.values()].map((m) => [s.key, m]))
-      .reduce((acc, v) => {
-        const [spaceKey, memberInfo] = v as [PublicKey, MemberInfo];
-        if (memberInfo.key.equals(identity.identityKey)) {
-          return acc;
-        }
-        const existing = acc.get(memberInfo.key);
-        if (existing != null) {
-          existing.profile ??= memberInfo.profile;
-          existing.commonSpaces?.push(spaceKey);
-        } else {
-          acc.set(memberInfo.key, {
-            identityKey: memberInfo.key,
-            profile: memberInfo.profile,
-            commonSpaces: [spaceKey],
-          });
-        }
-        return acc;
-      }, new ComplexMap<PublicKey, Contact>(PublicKey.hash));
-    return {
-      contacts: [...contacts.values()],
-    };
+  ['ContactsService.getContacts'](): Effect.Effect<ContactBook, Error> {
+    return Effect.sync(() => this.#getContacts());
   }
 
-  queryContacts(): Stream<ContactBook> {
+  ['ContactsService.queryContacts'](): EffectStream.Stream<ContactBook, Error> {
     const subscribedSpaceKeySet = new ComplexSet(PublicKey.hash);
-    return new Stream<ContactBook>(({ next, ctx }) => {
+    return EffectStream.async<ContactBook, Error>((emit) => {
+      const ctx = Context.default();
       const pushUpdateTask = new UpdateScheduler(
         ctx,
         async () => {
-          const contacts = await this.getContacts();
-          next(contacts);
+          void emit.single(this.#getContacts());
         },
         { maxFrequency: 2 },
       );
@@ -80,6 +58,37 @@ export class ContactsServiceImpl implements ContactsService {
         ctx.onDispose(unsubscribe);
         subscribeToSpaceAndUpdate();
       });
+      return Effect.promise(() => ctx.dispose());
     });
   }
+
+  #getContacts(): ContactBook {
+    const identity = this._identityManager.identity;
+    if (identity == null) {
+      return { contacts: [] };
+    }
+    const contacts = [...this._spaceManager.spaces.values()]
+      .flatMap((s) => [...s.spaceState.members.values()].map((m) => [s.key, m]))
+      .reduce((acc, v) => {
+        const [spaceKey, memberInfo] = v as [PublicKey, MemberInfo];
+        if (memberInfo.key.equals(identity.identityKey)) {
+          return acc;
+        }
+        const existing = acc.get(memberInfo.key);
+        if (existing != null) {
+          existing.profile ??= memberInfo.profile;
+          existing.commonSpaces?.push(spaceKey);
+        } else {
+          acc.set(memberInfo.key, {
+            identityKey: memberInfo.key,
+            profile: memberInfo.profile,
+            commonSpaces: [spaceKey],
+          });
+        }
+        return acc;
+      }, new ComplexMap<PublicKey, Contact>(PublicKey.hash));
+    return {
+      contacts: [...contacts.values()],
+    };
+  }
 }

package/src/packlets/identity/identity-manager.test.ts

@@ -5,7 +5,6 @@
 import { describe, expect, onTestFinished, test } from 'vitest';
 
 import { Context } from '@dxos/context';
-import { AuthStatus, MetadataStore, SpaceManager, valueEncoding } from '@dxos/echo-host';
 import { FeedFactory, FeedStore } from '@dxos/feed-store';
 import { Keyring } from '@dxos/keyring';
 import { MemorySignalManager, MemorySignalManagerContext } from '@dxos/messaging';
@@ -14,6 +13,9 @@ import type { FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
 import { type Storage, StorageType, createStorage } from '@dxos/random-access-storage';
 import { BlobStore } from '@dxos/teleport-extension-object-sync';
 
+import { MetadataStore } from '../metadata';
+import { valueEncoding } from '../pipeline';
+import { AuthStatus, SpaceManager } from '../space';
 import { IdentityManager } from './identity-manager';
 
 describe('identity/identity-manager', () => {