@dxos/client-services 0.1.39 → 0.1.40

package/src/packlets/invitations/invitations-handler.ts

@@ -6,31 +6,24 @@ import assert from 'node:assert';
 
 import { PushStream, scheduleTask, sleep, TimeoutError, Trigger } from '@dxos/async';
 import {
+  AuthenticatingInvitationObservable,
   AUTHENTICATION_CODE_LENGTH,
   CancellableInvitationObservable,
   INVITATION_TIMEOUT,
-  ON_CLOSE_DELAY,
-  AuthenticatingInvitationObservable
+  ON_CLOSE_DELAY
 } from '@dxos/client';
 import { Context } from '@dxos/context';
 import { generatePasscode } from '@dxos/credentials';
+import { InvalidInvitationExtensionRoleError } from '@dxos/errors';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { createTeleportProtocolFactory, NetworkManager, StarTopology } from '@dxos/network-manager';
-import { schema, trace } from '@dxos/protocols';
+import { trace } from '@dxos/protocols';
 import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
 import { ProfileDocument } from '@dxos/protocols/proto/dxos/halo/credentials';
-import {
-  AuthenticationRequest,
-  AuthenticationResponse,
-  IntroductionRequest,
-  IntroductionResponse,
-  AdmissionRequest,
-  AdmissionResponse,
-  InvitationHostService
-} from '@dxos/protocols/proto/dxos/halo/invitations';
-import { ExtensionContext, RpcExtension } from '@dxos/teleport';
+import { AuthenticationResponse } from '@dxos/protocols/proto/dxos/halo/invitations';
 
+import { InvitationGuestExtension, InvitationHostExtension } from './invitation-extension';
 import { InvitationProtocol } from './invitation-protocol';
 
 const MAX_OTP_ATTEMPTS = 3;
@@ -219,6 +212,18 @@ export class InvitationsHandler {
               }
             }
           });
+        },
+        onError: (err) => {
+          if (err instanceof InvalidInvitationExtensionRoleError) {
+            return;
+          }
+          if (err instanceof TimeoutError) {
+            log('timeout', { ...protocol.toJSON() });
+            stream.next({ ...invitation, state: Invitation.State.TIMEOUT });
+          } else {
+            log.error('failed', err);
+            stream.error(err);
+          }
         }
       });
       extension._traceParent = this._traceParent;
@@ -260,12 +265,19 @@ export class InvitationsHandler {
 
     const authenticated = new Trigger<string>();
 
+    let currentState: Invitation.State;
     const stream = new PushStream<Invitation>();
+    const setState = (newData: Partial<Invitation>) => {
+      assert(newData.state !== undefined);
+      currentState = newData.state;
+      stream.next({ ...invitation, ...newData });
+    };
+
     const ctx = new Context({
       onError: (err) => {
         if (err instanceof TimeoutError) {
           log('timeout', { ...protocol.toJSON() });
-          stream.next({ ...invitation, state: Invitation.State.TIMEOUT });
+          setState({ state: Invitation.State.TIMEOUT });
         } else {
           log.warn('auth failed', err);
           stream.error(err);
@@ -283,7 +295,14 @@ export class InvitationsHandler {
       let connectionCount = 0;
 
       const extension = new InvitationGuestExtension({
-        onOpen: () => {
+        onOpen: (extensionCtx) => {
+          extensionCtx.onDispose(async () => {
+            log('extension disposed', { currentState });
+            if (currentState !== Invitation.State.SUCCESS) {
+              stream.error(new Error('Remote peer disconnected.'));
+            }
+          });
+
           scheduleTask(ctx, async () => {
             const traceId = PublicKey.random().toHex();
             try {
@@ -299,7 +318,7 @@ export class InvitationsHandler {
               scheduleTask(ctx, () => ctx.raise(new TimeoutError(timeout)), timeout);
 
               log('connected', { ...protocol.toJSON() });
-              stream.next({ ...invitation, state: Invitation.State.CONNECTED });
+              setState({ state: Invitation.State.CONNECTED });
 
               // 1. Introduce guest to host.
               log('introduce', { ...protocol.toJSON() });
@@ -316,11 +335,11 @@ export class InvitationsHandler {
               if (isAuthenticationRequired(invitation)) {
                 for (let attempt = 1; attempt <= MAX_OTP_ATTEMPTS; attempt++) {
                   log('guest waiting for authentication code...');
-                  stream.next({ ...invitation, state: Invitation.State.READY_FOR_AUTHENTICATION });
+                  setState({ state: Invitation.State.READY_FOR_AUTHENTICATION });
                   const authCode = await authenticated.wait({ timeout });
 
                   log('sending authentication request');
-                  stream.next({ ...invitation, state: Invitation.State.AUTHENTICATING });
+                  setState({ state: Invitation.State.AUTHENTICATING });
                   const response = await extension.rpc.InvitationHostService.authenticate({ authCode });
                   if (response.status === undefined || response.status === AuthenticationResponse.Status.OK) {
                     break;
@@ -337,7 +356,7 @@ export class InvitationsHandler {
                 }
               } else {
                 // Notify that introduction is complete even if auth is not required.
-                stream.next({ ...invitation, state: Invitation.State.READY_FOR_AUTHENTICATION });
+                setState({ state: Invitation.State.READY_FOR_AUTHENTICATION });
               }
 
               // 3. Send admission credentials to host (with local space keys).
@@ -350,12 +369,12 @@ export class InvitationsHandler {
 
               // 5. Success.
               log('admitted by host', { ...protocol.toJSON() });
-              stream.next({ ...invitation, ...result, state: Invitation.State.SUCCESS });
+              setState({ ...result, state: Invitation.State.SUCCESS });
               log.trace('dxos.sdk.invitations-handler.guest.onOpen', trace.end({ id: traceId }));
             } catch (err: any) {
               if (err instanceof TimeoutError) {
                 log('timeout', { ...protocol.toJSON() });
-                stream.next({ ...invitation, state: Invitation.State.TIMEOUT });
+                setState({ state: Invitation.State.TIMEOUT });
               } else {
                 log('auth failed', err);
                 stream.error(err);
@@ -365,6 +384,18 @@ export class InvitationsHandler {
               await ctx.dispose();
             }
           });
+        },
+        onError: (err) => {
+          if (err instanceof InvalidInvitationExtensionRoleError) {
+            return;
+          }
+          if (err instanceof TimeoutError) {
+            log('timeout', { ...protocol.toJSON() });
+            setState({ state: Invitation.State.TIMEOUT });
+          } else {
+            log('auth failed', err);
+            stream.error(err);
+          }
         }
       });
 
@@ -384,14 +415,14 @@ export class InvitationsHandler {
       });
       ctx.onDispose(() => swarmConnection.close());
 
-      stream.next({ ...invitation, state: Invitation.State.CONNECTING });
+      setState({ state: Invitation.State.CONNECTING });
     });
 
     const observable = new AuthenticatingInvitationObservable({
       initialInvitation: invitation,
       subscriber: stream.observable,
       onCancel: async () => {
-        stream.next({ ...invitation, state: Invitation.State.CANCELLED });
+        setState({ state: Invitation.State.CANCELLED });
         await ctx.dispose();
       },
       onAuthenticate: async (code: string) => {
@@ -405,103 +436,3 @@ export class InvitationsHandler {
 }
 
 const isAuthenticationRequired = (invitation: Invitation) => invitation.authMethod !== Invitation.AuthMethod.NONE;
-
-type InvitationHostExtensionCallbacks = {
-  // Deliberately not async to not block the extensions opening.
-  onOpen: () => void;
-
-  introduce: (request: IntroductionRequest) => Promise<IntroductionResponse>;
-  authenticate: (request: AuthenticationRequest) => Promise<AuthenticationResponse>;
-  admit: (request: AdmissionRequest) => Promise<AdmissionResponse>;
-};
-
-/**
- * Host's side for a connection to a concrete peer in p2p network during invitation.
- */
-class InvitationHostExtension extends RpcExtension<{}, { InvitationHostService: InvitationHostService }> {
-  /**
-   * @internal
-   */
-  public _traceParent?: string;
-
-  constructor(private readonly _callbacks: InvitationHostExtensionCallbacks) {
-    super({
-      exposed: {
-        InvitationHostService: schema.getService('dxos.halo.invitations.InvitationHostService')
-      }
-    });
-  }
-
-  protected override async getHandlers(): Promise<{ InvitationHostService: InvitationHostService }> {
-    return {
-      // TODO(dmaretskyi): For now this is just forwarding the data to callbacks since we don't have session-specific logic.
-      // Perhaps in the future we will have more complex logic here.
-      InvitationHostService: {
-        introduce: async (request) => {
-          const traceId = PublicKey.random().toHex();
-          log.trace(
-            'dxos.sdk.invitation-handler.host.introduce',
-            trace.begin({ id: traceId, parentId: this._traceParent })
-          );
-          const response = await this._callbacks.introduce(request);
-          log.trace('dxos.sdk.invitation-handler.host.introduce', trace.end({ id: traceId }));
-          return response;
-        },
-
-        authenticate: async (request) => {
-          const traceId = PublicKey.random().toHex();
-          log.trace(
-            'dxos.sdk.invitation-handler.host.authenticate',
-            trace.begin({ id: traceId, parentId: this._traceParent })
-          );
-          const response = await this._callbacks.authenticate(request);
-          log.trace('dxos.sdk.invitation-handler.host.authenticate', trace.end({ id: traceId, data: { ...response } }));
-          return response;
-        },
-
-        admit: async (request) => {
-          const traceId = PublicKey.random().toHex();
-          log.trace(
-            'dxos.sdk.invitation-handler.host.admit',
-            trace.begin({ id: traceId, parentId: this._traceParent })
-          );
-          const response = await this._callbacks.admit(request);
-          log.trace('dxos.sdk.invitation-handler.host.admit', trace.end({ id: traceId }));
-          return response;
-        }
-      }
-    };
-  }
-
-  override async onOpen(context: ExtensionContext) {
-    await super.onOpen(context);
-    this._callbacks.onOpen();
-  }
-}
-
-type InvitationGuestExtensionCallbacks = {
-  // Deliberately not async to not block the extensions opening.
-  onOpen: () => void;
-};
-
-/**
- * Guest's side for a connection to a concrete peer in p2p network during invitation.
- */
-class InvitationGuestExtension extends RpcExtension<{ InvitationHostService: InvitationHostService }, {}> {
-  constructor(private readonly _callbacks: InvitationGuestExtensionCallbacks) {
-    super({
-      requested: {
-        InvitationHostService: schema.getService('dxos.halo.invitations.InvitationHostService')
-      }
-    });
-  }
-
-  protected override async getHandlers() {
-    return {};
-  }
-
-  override async onOpen(context: ExtensionContext) {
-    await super.onOpen(context);
-    this._callbacks.onOpen();
-  }
-}

package/src/packlets/invitations/invitations-service.ts

@@ -4,10 +4,16 @@
 
 import assert from 'node:assert';
 
+import { Event } from '@dxos/async';
 import { AuthenticatingInvitationObservable, CancellableInvitationObservable } from '@dxos/client';
 import { Stream } from '@dxos/codec-protobuf';
 import { log } from '@dxos/log';
-import { AuthenticationRequest, Invitation, InvitationsService } from '@dxos/protocols/proto/dxos/client/services';
+import {
+  AuthenticationRequest,
+  Invitation,
+  InvitationsService,
+  QueryInvitationsResponse
+} from '@dxos/protocols/proto/dxos/client/services';
 
 import { InvitationProtocol } from './invitation-protocol';
 import { InvitationsHandler } from './invitations-handler';
@@ -18,6 +24,10 @@ import { InvitationsHandler } from './invitations-handler';
 export class InvitationsServiceImpl implements InvitationsService {
   private readonly _createInvitations = new Map<string, CancellableInvitationObservable>();
   private readonly _acceptInvitations = new Map<string, AuthenticatingInvitationObservable>();
+  private readonly _invitationCreated = new Event<Invitation>();
+  private readonly _invitationAccepted = new Event<Invitation>();
+  private readonly _removedCreated = new Event<Invitation>();
+  private readonly _removedAccepted = new Event<Invitation>();
 
   constructor(
     private readonly _invitationsHandler: InvitationsHandler,
@@ -31,160 +41,61 @@ export class InvitationsServiceImpl implements InvitationsService {
     };
   }
 
-  createInvitation(invitation: Invitation): Stream<Invitation> {
-    return new Stream<Invitation>(({ next, close }) => {
-      const handler = this._getHandler(invitation);
-      log('stream opened', this.getLoggingContext());
+  createInvitation(options: Invitation): Stream<Invitation> {
+    let invitation: CancellableInvitationObservable;
+
+    const existingInvitation = this._createInvitations.get(options.invitationId);
+    if (existingInvitation) {
+      invitation = existingInvitation;
+    } else {
+      const handler = this._getHandler(options);
+      invitation = this._invitationsHandler.createInvitation(handler, options);
+      this._createInvitations.set(invitation.get().invitationId, invitation);
+      this._invitationCreated.emit(invitation.get());
+    }
 
-      let invitationId: string;
-      const observable = this._invitationsHandler.createInvitation(handler, invitation);
-      observable.subscribe(
+    return new Stream<Invitation>(({ next, close }) => {
+      invitation.subscribe(
         (invitation) => {
-          switch (invitation.state) {
-            case Invitation.State.CONNECTING: {
-              assert(invitation.invitationId);
-              invitationId = invitation.invitationId;
-              this._createInvitations.set(invitation.invitationId, observable);
-              invitation.state = Invitation.State.CONNECTING;
-              next(invitation);
-              break;
-            }
-            case Invitation.State.CONNECTED: {
-              assert(invitation.invitationId);
-              invitation.state = Invitation.State.CONNECTED;
-              next(invitation);
-              break;
-            }
-            case Invitation.State.READY_FOR_AUTHENTICATION: {
-              assert(invitation.invitationId);
-              invitation.state = Invitation.State.READY_FOR_AUTHENTICATION;
-              next(invitation);
-              break;
-            }
-            case Invitation.State.AUTHENTICATING: {
-              assert(invitation.invitationId);
-              invitation.state = Invitation.State.AUTHENTICATING;
-              next(invitation);
-              break;
-            }
-            case Invitation.State.SUCCESS: {
-              assert(invitation.invitationId);
-              invitation.state = Invitation.State.SUCCESS;
-              next(invitation);
-              break;
-            }
-            case Invitation.State.CANCELLED: {
-              assert(invitationId);
-              invitation.invitationId = invitationId;
-              invitation.state = Invitation.State.CANCELLED;
-              next(invitation);
-              break;
-            }
-            case Invitation.State.TIMEOUT: {
-              assert(invitationId);
-              invitation.invitationId = invitationId;
-              invitation.state = Invitation.State.TIMEOUT;
-              next(invitation);
-              break;
-            }
-          }
+          next(invitation);
         },
         (err: Error) => {
           close(err);
         },
         () => {
           close();
+          this._createInvitations.delete(invitation.get().invitationId);
         }
       );
-
-      return (err?: Error) => {
-        const context = this.getLoggingContext();
-        if (err) {
-          log.warn('stream closed', { ...context, err });
-        } else {
-          log('stream closed', context);
-        }
-
-        this._createInvitations.delete(invitation.invitationId!);
-      };
     });
   }
 
-  acceptInvitation(invitation: Invitation): Stream<Invitation> {
-    return new Stream<Invitation>(({ next, close }) => {
-      log('stream opened', this.getLoggingContext());
-      const handler = this._getHandler(invitation);
+  acceptInvitation(options: Invitation): Stream<Invitation> {
+    let invitation: AuthenticatingInvitationObservable;
+
+    const existingInvitation = this._acceptInvitations.get(options.invitationId);
+    if (existingInvitation) {
+      invitation = existingInvitation;
+    } else {
+      const handler = this._getHandler(options);
+      invitation = this._invitationsHandler.acceptInvitation(handler, options);
+      this._acceptInvitations.set(invitation.get().invitationId, invitation);
+      this._invitationAccepted.emit(invitation.get());
+    }
 
-      let invitationId: string;
-      const observable = this._invitationsHandler.acceptInvitation(handler, invitation);
-      observable.subscribe(
+    return new Stream<Invitation>(({ next, close }) => {
+      invitation.subscribe(
         (invitation) => {
-          switch (invitation.state) {
-            case Invitation.State.CONNECTING: {
-              assert(invitation.invitationId);
-              invitationId = invitation.invitationId;
-              this._acceptInvitations.set(invitation.invitationId, observable);
-              invitation.state = Invitation.State.CONNECTING;
-              next(invitation);
-              break;
-            }
-            case Invitation.State.CONNECTED: {
-              assert(invitation.invitationId);
-              invitation.state = Invitation.State.CONNECTED;
-              next(invitation);
-              break;
-            }
-            case Invitation.State.READY_FOR_AUTHENTICATION: {
-              assert(invitation.invitationId);
-              invitation.state = Invitation.State.READY_FOR_AUTHENTICATION;
-              next(invitation);
-              break;
-            }
-            case Invitation.State.AUTHENTICATING: {
-              assert(invitation.invitationId);
-              invitation.state = Invitation.State.AUTHENTICATING;
-              next(invitation);
-              break;
-            }
-            case Invitation.State.SUCCESS: {
-              invitation.state = Invitation.State.SUCCESS;
-              next(invitation);
-              break;
-            }
-            case Invitation.State.CANCELLED: {
-              assert(invitationId);
-              invitation.invitationId = invitationId;
-              invitation.state = Invitation.State.CANCELLED;
-              next(invitation);
-              break;
-            }
-            case Invitation.State.TIMEOUT: {
-              assert(invitationId);
-              invitation.invitationId = invitationId;
-              invitation.state = Invitation.State.TIMEOUT;
-              next(invitation);
-              break;
-            }
-          }
+          next(invitation);
         },
         (err: Error) => {
           close(err);
         },
         () => {
           close();
+          this._acceptInvitations.delete(invitation.get().invitationId);
         }
       );
-
-      return (err?: Error) => {
-        const context = this.getLoggingContext();
-        if (err) {
-          log.warn('stream closed', { ...context, err });
-        } else {
-          log('stream closed', context);
-        }
-
-        this._acceptInvitations.delete(invitation.invitationId!);
-      };
     });
   }
 
@@ -200,13 +111,71 @@ export class InvitationsServiceImpl implements InvitationsService {
   }
 
   async cancelInvitation({ invitationId }: { invitationId: string }): Promise<void> {
-    log('cancelling...');
+    log('deleting...');
     assert(invitationId);
-    const observable = this._createInvitations.get(invitationId) ?? this._acceptInvitations.get(invitationId);
-    if (!observable) {
-      log.warn('invalid invitation', { invitationId });
+    const created = this._createInvitations.get(invitationId);
+    const accepted = this._acceptInvitations.get(invitationId);
+    if (created) {
+      await created.cancel();
+      this._createInvitations.delete(invitationId);
+      this._removedCreated.emit(created.get());
+    } else if (accepted) {
+      await accepted.cancel();
+      this._acceptInvitations.delete(invitationId);
+      this._removedAccepted.emit(accepted.get());
     } else {
-      await observable?.cancel();
+      log.warn('invalid invitation', { invitationId });
     }
   }
+
+  queryInvitations(): Stream<QueryInvitationsResponse> {
+    return new Stream<QueryInvitationsResponse>(({ next, ctx }) => {
+      // Push added invitations to the stream.
+      this._invitationCreated.on(ctx, (invitation) => {
+        next({
+          action: QueryInvitationsResponse.Action.ADDED,
+          type: QueryInvitationsResponse.Type.CREATED,
+          invitations: [invitation]
+        });
+      });
+
+      this._invitationAccepted.on(ctx, (invitation) => {
+        next({
+          action: QueryInvitationsResponse.Action.ADDED,
+          type: QueryInvitationsResponse.Type.ACCEPTED,
+          invitations: [invitation]
+        });
+      });
+
+      // Push removed invitations to the stream.
+      this._removedCreated.on(ctx, (invitation) => {
+        next({
+          action: QueryInvitationsResponse.Action.REMOVED,
+          type: QueryInvitationsResponse.Type.CREATED,
+          invitations: [invitation]
+        });
+      });
+
+      this._removedAccepted.on(ctx, (invitation) => {
+        next({
+          action: QueryInvitationsResponse.Action.REMOVED,
+          type: QueryInvitationsResponse.Type.ACCEPTED,
+          invitations: [invitation]
+        });
+      });
+
+      // Push existing invitations to the stream.
+      next({
+        action: QueryInvitationsResponse.Action.ADDED,
+        type: QueryInvitationsResponse.Type.CREATED,
+        invitations: Array.from(this._createInvitations.values()).map((invitation) => invitation.get())
+      });
+
+      next({
+        action: QueryInvitationsResponse.Action.ADDED,
+        type: QueryInvitationsResponse.Type.ACCEPTED,
+        invitations: Array.from(this._acceptInvitations.values()).map((invitation) => invitation.get())
+      });
+    });
+  }
 }

package/src/packlets/services/utils.ts

@@ -30,11 +30,11 @@ export const fromHost = (config: Config = new Config()): ClientServicesProvider
  */
 // TODO(burdon): Move to client-services and remove dependencies from here.
 const createNetworkManager = (config: Config, options: Partial<NetworkManagerOptions> = {}): NetworkManager => {
-  const signalServer = config.get('runtime.services.signal.server');
-  if (signalServer) {
+  const signals = config.get('runtime.services.signaling');
+  if (signals) {
     const {
       log = true,
-      signalManager = new WebsocketSignalManager([signalServer]),
+      signalManager = new WebsocketSignalManager(signals),
       transportFactory = createWebRTCTransportFactory({
         iceServers: config.get('runtime.services.ice')
       })

package/src/packlets/testing/test-builder.ts

@@ -23,10 +23,12 @@ export const testConfigWithLocalSignal = new Config({
   version: 1,
   runtime: {
     services: {
-      signal: {
-        // TODO(burdon): Port numbers and global consts?
-        server: 'ws://localhost:4000/.well-known/dx/signal'
-      }
+      signaling: [
+        {
+          // TODO(burdon): Port numbers and global consts?
+          server: 'ws://localhost:4000/.well-known/dx/signal'
+        }
+      ]
     }
   }
 });
@@ -56,11 +58,11 @@ export class TestBuilder {
    * Get network manager using local shared memory or remote signal manager.
    */
   get networkManager() {
-    const signalServer = this._config.get('runtime.services.signal.server');
-    if (signalServer) {
+    const signals = this._config.get('runtime.services.signaling');
+    if (signals) {
       return new NetworkManager({
         log: true,
-        signalManager: new WebsocketSignalManager([signalServer]),
+        signalManager: new WebsocketSignalManager(signals),
         transportFactory: createWebRTCTransportFactory({
           iceServers: this._config.get('runtime.services.ice')
         })

package/src/packlets/vault/iframe-host-runtime.ts

@@ -75,14 +75,14 @@ export class IFrameHostRuntime {
     log('starting...');
     try {
       this._config = await getAsyncValue(this._configProvider);
-      const signalServer = this._config.get('runtime.services.signal.server');
+      const signals = this._config.get('runtime.services.signaling');
       this._clientServices = new LocalClientServices({
         lockKey: LOCK_KEY,
         config: this._config,
         networkManager: new NetworkManager({
           log: true,
-          signalManager: signalServer
-            ? new WebsocketSignalManager([signalServer])
+          signalManager: signals
+            ? new WebsocketSignalManager(signals)
             : new MemorySignalManager(new MemorySignalManagerContext()), // TODO(dmaretskyi): Inject this context.
           transportFactory: this._transportFactory
         })

package/src/packlets/vault/iframe-proxy-runtime.ts

@@ -3,6 +3,8 @@
 //
 
 import { iframeServiceBundle, workerServiceBundle, WorkerServiceBundle } from '@dxos/client';
+import { RemoteServiceConnectionError } from '@dxos/errors';
+import { log } from '@dxos/log';
 import { WebRTCTransportService } from '@dxos/network-manager';
 import { BridgeService } from '@dxos/protocols/proto/dxos/mesh/bridge';
 import { createProtoRpcPeer, ProtoRpcPeer, RpcPort } from '@dxos/rpc';
@@ -54,7 +56,7 @@ export class IFrameProxyRuntime {
         }
       },
       port: this._systemPort,
-      timeout: 200
+      timeout: 1000
     });
 
     this._workerAppPort.subscribe((msg) => this._windowAppPort.send(msg));
@@ -70,8 +72,14 @@ export class IFrameProxyRuntime {
   }
 
   async open(origin: string) {
-    await this._systemRpc.open();
-    await this._systemRpc.rpc.WorkerService.start({ origin });
+    try {
+      await this._systemRpc.open();
+      await this._systemRpc.rpc.WorkerService.start({ origin });
+    } catch (err) {
+      log.catch(err);
+      throw new RemoteServiceConnectionError('Failed to connect to worker');
+    }
+
     await this._shellRuntime?.open();
   }