@dxos/client-services 0.8.4-main.f9ba587 → 0.8.4-main.fcfe5033a5

package/src/packlets/worker/worker-runtime.ts

@@ -2,6 +2,12 @@
 // Copyright 2022 DXOS.org
 //
 
+import * as Reactivity from '@effect/experimental/Reactivity';
+import type * as SqlClient from '@effect/sql/SqlClient';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as ManagedRuntime from 'effect/ManagedRuntime';
+
 import { Trigger } from '@dxos/async';
 import { DEFAULT_WORKER_BROADCAST_CHANNEL } from '@dxos/client-protocol';
 import { type Config } from '@dxos/config';
@@ -16,16 +22,21 @@ import {
 } from '@dxos/messaging';
 import { RtcTransportProxyFactory } from '@dxos/network-manager';
 import { type RpcPort } from '@dxos/rpc';
+import * as OpfsWorker from '@dxos/sql-sqlite/OpfsWorker';
+import * as SqlExport from '@dxos/sql-sqlite/SqlExport';
+import * as SqliteClient from '@dxos/sql-sqlite/SqliteClient';
+import * as SqlTransaction from '@dxos/sql-sqlite/SqlTransaction';
 import { type MaybePromise } from '@dxos/util';
 
-import { WorkerSession } from './worker-session';
 import { ClientServicesHost } from '../services';
+import { WorkerSession } from './worker-session';
 
 // NOTE: Keep as RpcPorts to avoid dependency on @dxos/rpc-tunnel so we don't depend on browser-specific apis.
-export type CreateSessionParams = {
+export type CreateSessionProps = {
   appPort: RpcPort;
   systemPort: RpcPort;
   shellPort?: RpcPort;
+  onClose?: () => Promise<void>;
 };
 
 export type WorkerRuntimeOptions = {
@@ -34,10 +45,20 @@ export type WorkerRuntimeOptions = {
   acquireLock: () => Promise<void>;
   releaseLock: () => void;
   onStop?: () => Promise<void>;
+  /**
+   * @default true
+   */
+  automaticallyConnectWebrtc?: boolean;
+
+  /**
+   * Optional SQLite layer for Effect. Defaults to LocalSqliteOpfsLayer.
+   * For testing in Node.js, use `sqliteLayerMemory` from `@dxos/sql-sqlite/platform`.
+   */
+  sqliteLayer?: Layer.Layer<SqlClient.SqlClient | SqlExport.SqlExport, unknown>;
 };
 
 /**
- * Runtime for the shared worker.
+ * Runtime for the shared and dedciated worker.
  * Manages connections from proxies (in tabs).
  * Tabs make requests to the `ClientServicesHost`, and provide a WebRTC gateway.
  */
@@ -51,11 +72,17 @@ export class WorkerRuntime {
   private readonly _sessions = new Set<WorkerSession>();
   private readonly _clientServices!: ClientServicesHost;
   private readonly _channel: string;
+  private readonly _automaticallyConnectWebrtc: boolean;
+  private readonly _livenessLock = new WebLockWrapper(`@dxos/client-services/WorkerRuntime/${crypto.randomUUID()}`);
   private _broadcastChannel?: BroadcastChannel;
   private _sessionForNetworking?: WorkerSession; // TODO(burdon): Expose to client QueryStatusResponse.
   private _config!: Config;
   private _signalMetadataTags: any = { runtime: 'worker-runtime' };
   private _signalTelemetryEnabled: boolean = false;
+  private _runtime!: ManagedRuntime.ManagedRuntime<
+    SqlTransaction.SqlTransaction | SqlClient.SqlClient | SqlExport.SqlExport,
+    never
+  >;
 
   constructor({
     channel = DEFAULT_WORKER_BROADCAST_CHANNEL,
@@ -63,26 +90,49 @@ export class WorkerRuntime {
     acquireLock,
     releaseLock,
     onStop,
+    automaticallyConnectWebrtc = true,
+    sqliteLayer,
   }: WorkerRuntimeOptions) {
     this._configProvider = configProvider;
     this._acquireLock = acquireLock;
     this._releaseLock = releaseLock;
     this._onStop = onStop;
     this._channel = channel;
+    if (sqliteLayer) {
+      log.warn('Using testing SQLite layer');
+    }
+    this._runtime = ManagedRuntime.make(
+      SqlTransaction.layer
+        .pipe(Layer.provideMerge(sqliteLayer ?? LocalSqliteOpfsLayer), Layer.provideMerge(Reactivity.layer))
+        .pipe(Layer.orDie),
+    );
     this._clientServices = new ClientServicesHost({
       callbacks: {
         onReset: async () => this.stop(),
       },
+      runtime: this._runtime.runtimeEffect,
+      runtimeProps: {
+        // Auto-activate spaces that were previously active after leader changeover.
+        autoActivateSpaces: true,
+      },
     });
+    this._automaticallyConnectWebrtc = automaticallyConnectWebrtc;
   }
 
   get host() {
     return this._clientServices;
   }
 
+  get livenessLockKey(): string {
+    return this._livenessLock.key;
+  }
+
   async start(): Promise<void> {
     log('starting...');
     try {
+      void this._livenessLock.acquire();
+
+      // Steal the lock from the other worker.
       this._broadcastChannel = new BroadcastChannel(this._channel);
       this._broadcastChannel.postMessage({ action: 'stop' });
       this._broadcastChannel.onmessage = async (event) => {
@@ -93,6 +143,11 @@ export class WorkerRuntime {
 
       await this._acquireLock();
       this._config = await this._configProvider();
+      this._signalTelemetryEnabled = this._config.get('runtime.client.signalTelemetryEnabled') ?? false;
+      const observabilityGroup = this._config.get('runtime.client.observabilityGroup');
+      if (observabilityGroup) {
+        this._signalMetadataTags.group = observabilityGroup;
+      }
       const signals = this._config.get('runtime.services.signaling');
       this._clientServices.initialize({
         config: this._config,
@@ -125,14 +180,40 @@ export class WorkerRuntime {
     this._releaseLock();
     this._broadcastChannel?.close();
     this._broadcastChannel = undefined;
-    await this._clientServices.close();
+    await this._clientServices.close(Context.default());
+    await this._runtime.dispose();
     await this._onStop?.();
+    await this._livenessLock.release();
+  }
+
+  /**
+   * Update signaling telemetry tags from a client-supplied config overlay.
+   *
+   * The worker services outlive individual client connections, so the first client seeds the
+   * worker's core config (storage, signaling, edge features). For fields that can legitimately
+   * differ per tab — `observabilityGroup` and `signalTelemetryEnabled` — this method lets later
+   * connections refresh the signal metadata the worker attaches to its signaling requests
+   * (last-writer-wins, matching the pre-DX-930 per-session RPC behaviour).
+   */
+  updateSignalMetadata(config: Config): void {
+    const observabilityGroup = config.get('runtime.client.observabilityGroup');
+    if (observabilityGroup) {
+      this._signalMetadataTags.group = observabilityGroup;
+    } else {
+      // Clear stale group so a later config that removes observabilityGroup stops attributing
+      // telemetry to the previous client's group (last-writer-wins).
+      delete this._signalMetadataTags.group;
+    }
+    const signalTelemetryEnabled = config.get('runtime.client.signalTelemetryEnabled');
+    if (signalTelemetryEnabled !== undefined) {
+      this._signalTelemetryEnabled = signalTelemetryEnabled;
+    }
   }
 
   /**
    * Create a new session.
    */
-  async createSession({ appPort, systemPort, shellPort }: CreateSessionParams): Promise<void> {
+  async createSession({ appPort, systemPort, shellPort, onClose }: CreateSessionProps): Promise<WorkerSession> {
     const session = new WorkerSession({
       serviceHost: this._clientServices,
       appPort,
@@ -148,8 +229,11 @@ export class WorkerRuntime {
         // Terminate the worker when all sessions are closed.
         await this.stop();
       } else {
-        this._reconnectWebrtc();
+        if (this._automaticallyConnectWebrtc) {
+          this._reconnectWebrtc();
+        }
       }
+      await onClose?.();
     });
 
     await session.open();
@@ -158,14 +242,27 @@ export class WorkerRuntime {
       !this._signalMetadataTags.origin || this._signalMetadataTags.origin === session.origin,
       `worker origin changed from ${this._signalMetadataTags.origin} to ${session.origin}?`,
     );
-    if (session.observabilityGroup) {
-      this._signalMetadataTags.group = session.observabilityGroup;
-    }
-    this._signalTelemetryEnabled = session.signalTelemetryEnabled ?? false;
     this._signalMetadataTags.origin = session.origin;
     this._sessions.add(session);
 
-    this._reconnectWebrtc();
+    if (this._automaticallyConnectWebrtc) {
+      this._reconnectWebrtc();
+    }
+
+    return session;
+  }
+
+  /**
+   * Connects the WebRTC bridge to the specified session.
+   * If no session is provided, disconnects the WebRTC bridge.
+   *
+   * Called automatically if `automaticallyConnectWebrtc` is true.
+   *
+   * @param session The session to connect the WebRTC bridge to.
+   */
+  connectWebrtcBridge(session: WorkerSession | undefined): void {
+    this._sessionForNetworking = session;
+    this._transportFactory.setBridgeService(session?.bridgeService);
   }
 
   /**
@@ -183,12 +280,78 @@ export class WorkerRuntime {
     // Select existing session.
     if (!this._sessionForNetworking) {
       const selected = Array.from(this._sessions).find((session) => session.bridgeService);
-      if (selected) {
-        this._sessionForNetworking = selected;
-        this._transportFactory.setBridgeService(selected.bridgeService);
-      } else {
-        this._transportFactory.setBridgeService(undefined);
-      }
+      this.connectWebrtcBridge(selected);
     }
   }
 }
+
+const DB_NAME = 'DXOS';
+
+/**
+ * SqlExport layer that wraps SqliteClient to provide export functionality.
+ */
+const SqlExportLayer: Layer.Layer<SqlExport.SqlExport, never, SqliteClient.SqliteClient> = Layer.effect(
+  SqlExport.SqlExport,
+  Effect.gen(function* () {
+    const sql = yield* SqliteClient.SqliteClient;
+    return {
+      export: sql.export,
+    } satisfies SqlExport.Service;
+  }),
+);
+
+/**
+ * Local SQLite layer for the worker.
+ * Uses OPFS sync API as an FS backend.
+ * Does NOT spawn a new worker.
+ * NOTE: Only usable within a worker.
+ * TODO(mykola): This does not work right now. Fix.
+ */
+const LocalSqliteOpfsLayer = Layer.unwrapScoped(
+  Effect.gen(function* () {
+    const { port1: clientPort, port2: serverPort } = new MessageChannel();
+    clientPort.start();
+    serverPort.start();
+    yield* Effect.addFinalizer(() =>
+      Effect.sync(() => {
+        clientPort.close();
+        serverPort.close();
+      }),
+    );
+
+    yield* Effect.forkScoped(OpfsWorker.run({ port: serverPort, dbName: DB_NAME }));
+    return SqlExportLayer.pipe(Layer.provideMerge(SqliteClient.layer({ worker: Effect.succeed(clientPort) })));
+  }),
+);
+
+// TODO(wittjosiah): Factor out to a separate module.
+class WebLockWrapper {
+  readonly #key: string;
+  #release?: () => void;
+
+  constructor(key: string) {
+    this.#key = key;
+  }
+
+  get key(): string {
+    return this.#key;
+  }
+
+  acquire(options: LockOptions = {}) {
+    return navigator.locks.request(this.#key, options, async () => {
+      await new Promise<void>((resolve) => {
+        this.#release = resolve;
+      }); // Blocks for the duration of the worker's lifetime.
+      this.#release = undefined;
+    });
+  }
+
+  release() {
+    this.#release?.();
+    this.#release = undefined;
+  }
+
+  [Symbol.dispose]() {
+    this.release();
+  }
+}

package/src/packlets/worker/worker-session.ts

@@ -2,22 +2,22 @@
 // Copyright 2022 DXOS.org
 //
 
-import { asyncTimeout, Trigger } from '@dxos/async';
+import { Trigger, asyncTimeout } from '@dxos/async';
 import {
-  iframeServiceBundle,
   type IframeServiceBundle,
   PROXY_CONNECTION_TIMEOUT,
+  iframeServiceBundle,
   workerServiceBundle,
 } from '@dxos/client-protocol';
 import { invariant } from '@dxos/invariant';
 import { log, logInfo } from '@dxos/log';
 import { type BridgeService } from '@dxos/protocols/proto/dxos/mesh/bridge';
-import { createProtoRpcPeer, type ProtoRpcPeer, type RpcPort } from '@dxos/rpc';
+import { type ProtoRpcPeer, type RpcPort, createProtoRpcPeer } from '@dxos/rpc';
 import { Callback, type MaybePromise } from '@dxos/util';
 
-import { type ClientServicesHost, ClientRpcServer, type ClientRpcServerParams } from '../services';
+import { ClientRpcServer, type ClientRpcServerProps, type ClientServicesHost } from '../services';
 
-export type WorkerSessionParams = {
+export type WorkerSessionProps = {
   serviceHost: ClientServicesHost;
   systemPort: RpcPort;
   appPort: RpcPort;
@@ -41,35 +41,31 @@ export class WorkerSession {
   @logInfo
   public origin?: string;
 
-  // TODO(nf): factor out?
-  public observabilityGroup?: string;
-  public signalTelemetryEnabled?: boolean;
-
   @logInfo
   public lockKey?: string;
 
   public bridgeService?: BridgeService;
 
-  constructor({ serviceHost, systemPort, appPort, shellPort, readySignal }: WorkerSessionParams) {
+  constructor({ serviceHost, systemPort, appPort, shellPort, readySignal }: WorkerSessionProps) {
     invariant(serviceHost);
     this._serviceHost = serviceHost;
 
-    const middleware: Pick<ClientRpcServerParams, 'handleCall' | 'handleStream'> = {
-      handleCall: async (method, params, handler) => {
+    const middleware: Pick<ClientRpcServerProps, 'handleCall' | 'handleStream'> = {
+      handleCall: async (method, params, handler, options) => {
         const error = await readySignal.wait({ timeout: PROXY_CONNECTION_TIMEOUT });
         if (error) {
           throw error;
         }
 
-        return handler(method, params);
+        return handler(method, params, options);
       },
-      handleStream: async (method, params, handler) => {
+      handleStream: async (method, params, handler, options) => {
         const error = await readySignal.wait({ timeout: PROXY_CONNECTION_TIMEOUT });
         if (error) {
           throw error;
         }
 
-        return handler(method, params);
+        return handler(method, params, options);
       },
     };
 
@@ -95,8 +91,6 @@ export class WorkerSession {
           start: async (request) => {
             this.origin = request.origin;
             this.lockKey = request.lockKey;
-            this.observabilityGroup = request.observabilityGroup;
-            this.signalTelemetryEnabled = request.signalTelemetryEnabled;
             this._startTrigger.wake();
           },
 
@@ -119,7 +113,7 @@ export class WorkerSession {
   }
 
   async open(): Promise<void> {
-    log.info('opening...');
+    log('opening...');
     await Promise.all([this._clientRpc.open(), this._iframeRpc.open(), this._maybeOpenShell()]);
 
     // Wait until the worker's RPC service has started.
@@ -130,11 +124,11 @@ export class WorkerSession {
       void this._afterLockReleases(this.lockKey, () => this.close());
     }
 
-    log.info('opened');
+    log('opened');
   }
 
   async close(): Promise<void> {
-    log.info('closing...');
+    log.debug('closing...');
     try {
       await this.onClose.callIfSet();
     } catch (err: any) {
@@ -142,7 +136,7 @@ export class WorkerSession {
     }
 
     await Promise.all([this._clientRpc.close(), this._iframeRpc.close()]);
-    log.info('closed');
+    log.debug('closed');
   }
 
   private async _maybeOpenShell(): Promise<void> {

package/src/version.ts

@@ -1 +1 @@
-export const DXOS_VERSION = "0.8.4-main.f9ba587";
+export const DXOS_VERSION = "0.8.4-main.fcfe5033a5";