@dxos/client-services 0.1.49 → 0.1.50-next.1bfebf8

package/dist/lib/browser/index.mjs

@@ -6,27 +6,22 @@ import {
   DeviceInvitationProtocol,
   DevtoolsHostEvents,
   DevtoolsServiceImpl,
-  IFrameHostRuntime,
-  IFrameProxyRuntime,
   Identity,
   IdentityManager,
   IdentityServiceImpl,
   InvitationsHandler,
   InvitationsServiceImpl,
   LocalClientServices,
-  MemoryShellRuntime,
+  Lock,
   ServiceContext,
   ServiceRegistry,
-  ShellRuntimeImpl,
   SpaceInvitationProtocol,
   SpacesServiceImpl,
   TrustedKeySetAuthVerifier,
-  VaultResourceLock,
-  WorkerRuntime,
-  WorkerSession,
   createAuthProvider,
   createStorageObjects,
   getNetworkPeers,
+  isLocked,
   subscribeToFeedBlocks,
   subscribeToFeeds,
   subscribeToNetworkStatus,
@@ -34,7 +29,603 @@ import {
   subscribeToSignal,
   subscribeToSpaces,
   subscribeToSwarmInfo
-} from "./chunk-YLH4UYUT.mjs";
+} from "./chunk-UL74TKNZ.mjs";
+
+// packages/sdk/client-services/src/packlets/vault/iframe-host-runtime.ts
+import { Trigger } from "@dxos/async";
+import { PROXY_CONNECTION_TIMEOUT } from "@dxos/client-protocol";
+import { log, logInfo } from "@dxos/log";
+import { MemorySignalManager, MemorySignalManagerContext, WebsocketSignalManager } from "@dxos/messaging";
+import { createWebRTCTransportFactory } from "@dxos/network-manager";
+import { getAsyncValue } from "@dxos/util";
+
+// packages/sdk/client-services/src/packlets/services/client-rpc-server.ts
+import { Stream } from "@dxos/codec-protobuf";
+import { raise } from "@dxos/debug";
+import { parseMethodName, RpcPeer } from "@dxos/rpc";
+var ClientRpcServer = class {
+  constructor(params) {
+    this._handlerCache = /* @__PURE__ */ new Map();
+    const { serviceRegistry, handleCall, handleStream, ...rpcOptions } = params;
+    this._handleCall = handleCall;
+    this._handleStream = handleStream;
+    this._serviceRegistry = serviceRegistry;
+    this._rpcPeer = new RpcPeer({
+      ...rpcOptions,
+      callHandler: (method, params2) => {
+        const [serviceName, methodName] = parseMethodName(method);
+        const handler = (method2, params3) => this._getServiceHandler(serviceName).call(method2, params3);
+        if (this._handleCall) {
+          return this._handleCall(methodName, params2, handler);
+        } else {
+          return handler(methodName, params2);
+        }
+      },
+      streamHandler: (method, params2) => {
+        const [serviceName, methodName] = parseMethodName(method);
+        const handler = (method2, params3) => this._getServiceHandler(serviceName).callStream(method2, params3);
+        if (this._handleStream) {
+          return Stream.unwrapPromise(this._handleStream(methodName, params2, handler));
+        } else {
+          return handler(methodName, params2);
+        }
+      }
+    });
+  }
+  async open() {
+    await this._rpcPeer.open();
+  }
+  async close() {
+    await this._rpcPeer.close();
+  }
+  _getServiceHandler(serviceName) {
+    var _a;
+    if (!this._handlerCache.has(serviceName)) {
+      const [key, descriptor] = (_a = Object.entries(this._serviceRegistry.descriptors).find(([key2, descriptor2]) => descriptor2.name === serviceName)) != null ? _a : raise(new Error(`Service not available: ${serviceName}`));
+      const service = this._serviceRegistry.services[key];
+      if (!service) {
+        throw new Error(`Service not available: ${serviceName}`);
+      }
+      this._handlerCache.set(serviceName, descriptor.createServer(service));
+    }
+    return this._handlerCache.get(serviceName);
+  }
+};
+
+// packages/sdk/client-services/src/packlets/vault/shell-runtime.ts
+import assert from "@dxos/node-std/assert";
+import { Event } from "@dxos/async";
+import { appServiceBundle, shellServiceBundle } from "@dxos/client-protocol";
+import { ShellLayout } from "@dxos/protocols/proto/dxos/iframe";
+import { createProtoRpcPeer } from "@dxos/rpc";
+var ShellRuntimeImpl = class {
+  constructor(_port) {
+    this._port = _port;
+    this.layoutUpdate = new Event();
+    this._layout = ShellLayout.DEFAULT;
+  }
+  get layout() {
+    return this._layout;
+  }
+  get invitationCode() {
+    return this._invitationCode;
+  }
+  get spaceKey() {
+    return this._spaceKey;
+  }
+  setLayout(layout, options = {}) {
+    this._layout = layout;
+    this._invitationCode = options.invitationCode;
+    this._spaceKey = options.spaceKey;
+    this.layoutUpdate.emit({
+      layout,
+      ...options
+    });
+  }
+  async setAppContext(context) {
+    assert(this._appRpc, "runtime not open");
+    await this._appRpc.rpc.AppService.setContext(context);
+  }
+  async open() {
+    this._appRpc = createProtoRpcPeer({
+      requested: appServiceBundle,
+      exposed: shellServiceBundle,
+      handlers: {
+        ShellService: {
+          setLayout: async (request) => {
+            this._layout = request.layout;
+            this._invitationCode = request.invitationCode;
+            this._spaceKey = request.spaceKey;
+            this.layoutUpdate.emit(request);
+          }
+        }
+      },
+      port: this._port
+    });
+    await this._appRpc.open();
+  }
+  async close() {
+    var _a;
+    await ((_a = this._appRpc) == null ? void 0 : _a.close());
+    this._appRpc = void 0;
+  }
+};
+var MemoryShellRuntime = class {
+  constructor({ layout, invitationCode, spaceKey } = {}) {
+    this.layoutUpdate = new Event();
+    this.contextUpdate = new Event();
+    this._layout = layout != null ? layout : ShellLayout.DEFAULT;
+    this._invitationCode = invitationCode;
+    this._spaceKey = spaceKey;
+  }
+  get layout() {
+    return this._layout;
+  }
+  get invitationCode() {
+    return this._invitationCode;
+  }
+  get spaceKey() {
+    return this._spaceKey;
+  }
+  setLayout(layout, options = {}) {
+    this._layout = layout;
+    this._invitationCode = options.invitationCode;
+    this._spaceKey = options.spaceKey;
+    this.layoutUpdate.emit({
+      layout,
+      ...options
+    });
+  }
+  async setAppContext(context) {
+    this.contextUpdate.emit(context);
+  }
+};
+
+// packages/sdk/client-services/src/packlets/vault/iframe-host-runtime.ts
+var __decorate = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var LOCK_KEY = "DXOS_RESOURCE_LOCK";
+var IFrameHostRuntime = class {
+  constructor({ config, origin, appPort, shellPort }) {
+    this._ready = new Trigger();
+    this._configProvider = config;
+    this.origin = origin;
+    this._appPort = appPort;
+    this._shellPort = shellPort;
+    if (this._shellPort) {
+      this._shellRuntime = new ShellRuntimeImpl(this._shellPort);
+    }
+  }
+  get services() {
+    return this._clientServices;
+  }
+  get shell() {
+    return this._shellRuntime;
+  }
+  async start() {
+    var _a;
+    log("starting...", {}, {
+      file: "iframe-host-runtime.ts",
+      line: 70,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    try {
+      this._config = await getAsyncValue(this._configProvider);
+      this._transportFactory = createWebRTCTransportFactory({
+        iceServers: this._config.get("runtime.services.ice")
+      });
+      const signals = this._config.get("runtime.services.signaling");
+      this._clientServices = new LocalClientServices({
+        lockKey: LOCK_KEY,
+        config: this._config,
+        signalManager: signals ? new WebsocketSignalManager(signals) : new MemorySignalManager(new MemorySignalManagerContext()),
+        transportFactory: this._transportFactory
+      });
+      const middleware = {
+        handleCall: async (method, params, handler) => {
+          const error = await this._ready.wait({
+            timeout: PROXY_CONNECTION_TIMEOUT
+          });
+          if (error) {
+            throw error;
+          }
+          return handler(method, params);
+        },
+        handleStream: async (method, params, handler) => {
+          const error = await this._ready.wait({
+            timeout: PROXY_CONNECTION_TIMEOUT
+          });
+          if (error) {
+            throw error;
+          }
+          return handler(method, params);
+        }
+      };
+      this._clientRpc = new ClientRpcServer({
+        serviceRegistry: this._clientServices.host.serviceRegistry,
+        port: this._appPort,
+        ...middleware
+      });
+      await Promise.all([
+        this._clientServices.open(),
+        this._clientRpc.open(),
+        (_a = this._shellRuntime) == null ? void 0 : _a.open()
+      ]);
+      this._ready.wake(void 0);
+      log("started", {}, {
+        file: "iframe-host-runtime.ts",
+        line: 113,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+    } catch (err) {
+      this._ready.wake(err);
+      log.catch(err, {}, {
+        file: "iframe-host-runtime.ts",
+        line: 116,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+    }
+  }
+  async stop() {
+    var _a;
+    log("stopping...", {}, {
+      file: "iframe-host-runtime.ts",
+      line: 121,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    await this._clientRpc.close();
+    await this._clientServices.close();
+    await ((_a = this._shellRuntime) == null ? void 0 : _a.close());
+    log("stopped", {}, {
+      file: "iframe-host-runtime.ts",
+      line: 125,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+  }
+};
+__decorate([
+  logInfo
+], IFrameHostRuntime.prototype, "origin", void 0);
+
+// packages/sdk/client-services/src/packlets/vault/iframe-proxy-runtime.ts
+import { Trigger as Trigger2 } from "@dxos/async";
+import { iframeServiceBundle, workerServiceBundle } from "@dxos/client-protocol";
+import { RemoteServiceConnectionError } from "@dxos/errors";
+import { log as log2 } from "@dxos/log";
+import { WebRTCTransportService } from "@dxos/network-manager";
+import { createProtoRpcPeer as createProtoRpcPeer2 } from "@dxos/rpc";
+import { getAsyncValue as getAsyncValue2 } from "@dxos/util";
+var IFrameProxyRuntime = class {
+  constructor({ config, systemPort, shellPort }) {
+    this._id = String(Math.floor(Math.random() * 1e6));
+    this._release = new Trigger2();
+    this._configProvider = config;
+    this._systemPort = systemPort;
+    this._shellPort = shellPort;
+    if (this._shellPort) {
+      this._shellRuntime = new ShellRuntimeImpl(this._shellPort);
+    }
+  }
+  get shell() {
+    return this._shellRuntime;
+  }
+  async open(origin) {
+    var _a;
+    this._config = await getAsyncValue2(this._configProvider);
+    this._transportService = new WebRTCTransportService({
+      iceServers: this._config.get("runtime.services.ice")
+    });
+    this._systemRpc = createProtoRpcPeer2({
+      requested: workerServiceBundle,
+      exposed: iframeServiceBundle,
+      handlers: {
+        BridgeService: this._transportService
+      },
+      port: this._systemPort,
+      timeout: 200
+    });
+    let lockKey;
+    if (typeof navigator !== "undefined") {
+      lockKey = this._lockKey(origin);
+      this._release = new Trigger2();
+      const ready = new Trigger2();
+      void navigator.locks.request(lockKey, async () => {
+        ready.wake();
+        await this._release.wait();
+      });
+      await ready.wait();
+    }
+    try {
+      await this._systemRpc.open();
+      await this._systemRpc.rpc.WorkerService.start({
+        origin,
+        lockKey
+      });
+    } catch (err) {
+      log2.catch(err, {}, {
+        file: "iframe-proxy-runtime.ts",
+        line: 85,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+      throw new RemoteServiceConnectionError("Failed to connect to worker");
+    }
+    await ((_a = this._shellRuntime) == null ? void 0 : _a.open());
+  }
+  async close() {
+    var _a;
+    this._release.wake();
+    await ((_a = this._shellRuntime) == null ? void 0 : _a.close());
+    await this._systemRpc.rpc.WorkerService.stop();
+    await this._systemRpc.close();
+  }
+  _lockKey(origin) {
+    return `${origin}-${this._id}`;
+  }
+};
+
+// packages/sdk/client-services/src/packlets/vault/worker-runtime.ts
+import { Trigger as Trigger4 } from "@dxos/async";
+import { log as log4 } from "@dxos/log";
+import { MemorySignalManager as MemorySignalManager2, MemorySignalManagerContext as MemorySignalManagerContext2, WebsocketSignalManager as WebsocketSignalManager2 } from "@dxos/messaging";
+import { WebRTCTransportProxyFactory } from "@dxos/network-manager";
+
+// packages/sdk/client-services/src/packlets/vault/worker-session.ts
+import assert2 from "@dxos/node-std/assert";
+import { asyncTimeout, Trigger as Trigger3 } from "@dxos/async";
+import { iframeServiceBundle as iframeServiceBundle2, PROXY_CONNECTION_TIMEOUT as PROXY_CONNECTION_TIMEOUT2, workerServiceBundle as workerServiceBundle2 } from "@dxos/client-protocol";
+import { log as log3, logInfo as logInfo2 } from "@dxos/log";
+import { createProtoRpcPeer as createProtoRpcPeer3 } from "@dxos/rpc";
+import { Callback } from "@dxos/util";
+var __decorate2 = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var WorkerSession = class {
+  constructor({ serviceHost, systemPort, appPort, shellPort, readySignal }) {
+    this._startTrigger = new Trigger3();
+    this.onClose = new Callback();
+    assert2(serviceHost);
+    this._serviceHost = serviceHost;
+    const middleware = {
+      handleCall: async (method, params, handler) => {
+        const error = await readySignal.wait({
+          timeout: PROXY_CONNECTION_TIMEOUT2
+        });
+        if (error) {
+          throw error;
+        }
+        return handler(method, params);
+      },
+      handleStream: async (method, params, handler) => {
+        const error = await readySignal.wait({
+          timeout: PROXY_CONNECTION_TIMEOUT2
+        });
+        if (error) {
+          throw error;
+        }
+        return handler(method, params);
+      }
+    };
+    this._clientRpc = new ClientRpcServer({
+      serviceRegistry: this._serviceHost.serviceRegistry,
+      port: appPort,
+      ...middleware
+    });
+    this._shellClientRpc = new ClientRpcServer({
+      serviceRegistry: this._serviceHost.serviceRegistry,
+      port: shellPort,
+      ...middleware
+    });
+    this._iframeRpc = createProtoRpcPeer3({
+      requested: iframeServiceBundle2,
+      exposed: workerServiceBundle2,
+      handlers: {
+        WorkerService: {
+          start: async (request) => {
+            this.origin = request.origin;
+            this.lockKey = request.lockKey;
+            this._startTrigger.wake();
+          },
+          stop: async () => {
+            setTimeout(async () => {
+              try {
+                await this.close();
+              } catch (err) {
+                log3.catch(err, {}, {
+                  file: "worker-session.ts",
+                  line: 100,
+                  scope: this,
+                  callSite: (f, a) => f(...a)
+                });
+              }
+            });
+          }
+        }
+      },
+      port: systemPort,
+      timeout: 1e3
+    });
+    this.bridgeService = this._iframeRpc.rpc.BridgeService;
+  }
+  async open() {
+    log3.info("opening..", {}, {
+      file: "worker-session.ts",
+      line: 114,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    await Promise.all([
+      this._clientRpc.open(),
+      this._iframeRpc.open(),
+      this._maybeOpenShell()
+    ]);
+    await this._startTrigger.wait({
+      timeout: PROXY_CONNECTION_TIMEOUT2
+    });
+    if (this.lockKey) {
+      void this._afterLockReleases(this.lockKey, () => this.close());
+    }
+  }
+  async close() {
+    log3.info("closing..", {}, {
+      file: "worker-session.ts",
+      line: 124,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    try {
+      await this.onClose.callIfSet();
+    } catch (err) {
+      log3.catch(err, {}, {
+        file: "worker-session.ts",
+        line: 128,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+    }
+    await Promise.all([
+      this._clientRpc.close(),
+      this._iframeRpc.close()
+    ]);
+  }
+  async _maybeOpenShell() {
+    try {
+      await asyncTimeout(this._shellClientRpc.open(), 1e3);
+    } catch (e) {
+      log3.info("No shell connected.", {}, {
+        file: "worker-session.ts",
+        line: 138,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+    }
+  }
+  _afterLockReleases(lockKey, callback) {
+    return navigator.locks.request(lockKey, () => {
+    }).then(callback);
+  }
+};
+__decorate2([
+  logInfo2
+], WorkerSession.prototype, "origin", void 0);
+__decorate2([
+  logInfo2
+], WorkerSession.prototype, "lockKey", void 0);
+
+// packages/sdk/client-services/src/packlets/vault/worker-runtime.ts
+var WorkerRuntime = class {
+  // prettier-ignore
+  constructor(_configProvider) {
+    this._configProvider = _configProvider;
+    this._transportFactory = new WebRTCTransportProxyFactory();
+    this._ready = new Trigger4();
+    this.sessions = /* @__PURE__ */ new Set();
+    this._clientServices = new ClientServicesHost();
+  }
+  get host() {
+    return this._clientServices;
+  }
+  async start() {
+    log4("starting...", {}, {
+      file: "worker-runtime.ts",
+      line: 48,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    try {
+      this._config = await this._configProvider();
+      const signals = this._config.get("runtime.services.signaling");
+      this._clientServices.initialize({
+        config: this._config,
+        signalManager: signals ? new WebsocketSignalManager2(signals) : new MemorySignalManager2(new MemorySignalManagerContext2()),
+        transportFactory: this._transportFactory
+      });
+      await this._clientServices.open();
+      this._ready.wake(void 0);
+      log4("started", {}, {
+        file: "worker-runtime.ts",
+        line: 62,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+    } catch (err) {
+      this._ready.wake(err);
+      log4.catch(err, {}, {
+        file: "worker-runtime.ts",
+        line: 65,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+    }
+  }
+  async stop() {
+    await this._clientServices.close();
+  }
+  /**
+  * Create a new session.
+  */
+  async createSession({ appPort, systemPort, shellPort }) {
+    const session = new WorkerSession({
+      serviceHost: this._clientServices,
+      appPort,
+      systemPort,
+      shellPort,
+      readySignal: this._ready
+    });
+    session.onClose.set(async () => {
+      this.sessions.delete(session);
+      this._reconnectWebrtc();
+    });
+    await session.open();
+    this.sessions.add(session);
+    this._reconnectWebrtc();
+  }
+  /**
+  * Selects one of the existing session fro WebRTC networking.
+  */
+  _reconnectWebrtc() {
+    log4("reconnecting webrtc...", {}, {
+      file: "worker-runtime.ts",
+      line: 102,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    if (this._sessionForNetworking) {
+      if (!this.sessions.has(this._sessionForNetworking)) {
+        this._sessionForNetworking = void 0;
+      }
+    }
+    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(void 0);
+      }
+    }
+  }
+};
 export {
   ClientServicesHost,
   DataSpace,
@@ -50,6 +641,7 @@ export {
   InvitationsHandler,
   InvitationsServiceImpl,
   LocalClientServices,
+  Lock,
   MemoryShellRuntime,
   ServiceContext,
   ServiceRegistry,
@@ -57,12 +649,12 @@ export {
   SpaceInvitationProtocol,
   SpacesServiceImpl,
   TrustedKeySetAuthVerifier,
-  VaultResourceLock,
   WorkerRuntime,
   WorkerSession,
   createAuthProvider,
   createStorageObjects,
   getNetworkPeers,
+  isLocked,
   subscribeToFeedBlocks,
   subscribeToFeeds,
   subscribeToNetworkStatus,