@dxos/client-services 0.6.13 → 0.6.14-main.2b6a0f3

package/dist/lib/node-esm/index.mjs

@@ -0,0 +1,691 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  ClientServicesHost,
+  DataSpace,
+  DataSpaceManager,
+  DeviceInvitationProtocol,
+  DevtoolsHostEvents,
+  DevtoolsServiceImpl,
+  EdgeAgentManager,
+  EdgeAgentServiceImpl,
+  EdgeFeedReplicator,
+  Identity,
+  IdentityManager,
+  IdentityServiceImpl,
+  InvitationsHandler,
+  InvitationsManager,
+  InvitationsServiceImpl,
+  Lock,
+  ServiceContext,
+  ServiceRegistry,
+  SpaceInvitationProtocol,
+  SpacesServiceImpl,
+  TrustedKeySetAuthVerifier,
+  createAdmissionKeypair,
+  createAuthProvider,
+  createCollectDiagnosticsBroadcastHandler,
+  createCollectDiagnosticsBroadcastSender,
+  createDiagnostics,
+  createLevel,
+  createStorageObjects,
+  getNetworkPeers,
+  isLocked,
+  subscribeToFeedBlocks,
+  subscribeToFeeds,
+  subscribeToNetworkStatus,
+  subscribeToNetworkTopics,
+  subscribeToSignal,
+  subscribeToSpaces,
+  subscribeToSwarmInfo
+} from "./chunk-A6GS6OOD.mjs";
+
+// packages/sdk/client-services/src/packlets/diagnostics/diagnostics-collector.ts
+import { ClientServicesProviderResource } from "@dxos/client-protocol";
+import { ConfigResource } from "@dxos/config";
+import { GetDiagnosticsRequest } from "@dxos/protocols/proto/dxos/client/services";
+import { TRACE_PROCESSOR } from "@dxos/tracing";
+import { jsonKeyReplacer, nonNullable } from "@dxos/util";
+var GET_DIAGNOSTICS_RPC_TIMEOUT = 1e4;
+var DiagnosticsCollector = class {
+  static {
+    this.broadcastSender = createCollectDiagnosticsBroadcastSender();
+  }
+  static async collect(config = findConfigs(), services = findSystemServiceProvider(), options = {}) {
+    const serviceDiagnostics = await services?.services?.SystemService?.getDiagnostics({
+      keys: options.humanize ? GetDiagnosticsRequest.KEY_OPTION.HUMANIZE : options.truncate ? GetDiagnosticsRequest.KEY_OPTION.TRUNCATE : void 0
+    }, {
+      timeout: GET_DIAGNOSTICS_RPC_TIMEOUT
+    });
+    const clientDiagnostics = {
+      config,
+      trace: TRACE_PROCESSOR.getDiagnostics()
+    };
+    const diagnostics = serviceDiagnostics != null ? {
+      client: clientDiagnostics,
+      services: serviceDiagnostics
+    } : {
+      client: clientDiagnostics,
+      broadcast: await this.broadcastSender.broadcastDiagnosticsRequest()
+    };
+    return JSON.parse(JSON.stringify(diagnostics, jsonKeyReplacer(options)));
+  }
+};
+var findSystemServiceProvider = () => {
+  const serviceProviders = TRACE_PROCESSOR.findResourcesByAnnotation(ClientServicesProviderResource);
+  const providerResource = serviceProviders.find((r) => r.instance.deref()?.services?.SystemService != null);
+  return providerResource?.instance?.deref() ?? null;
+};
+var findConfigs = () => {
+  const configs = TRACE_PROCESSOR.findResourcesByAnnotation(ConfigResource);
+  return configs.map((r) => r.instance.deref()).filter(nonNullable);
+};
+
+// 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";
+import { MapCounter, trace } from "@dxos/tracing";
+function _ts_decorate(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 ClientRpcServer = class {
+  constructor(params) {
+    this._handlerCache = /* @__PURE__ */ new Map();
+    this._callMetrics = new MapCounter();
+    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);
+        this._callMetrics.inc(`${serviceName}.${methodName} request`);
+        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);
+        this._callMetrics.inc(`${serviceName}.${methodName} request stream`);
+        if (this._handleStream) {
+          return Stream.map(Stream.unwrapPromise(this._handleStream(methodName, params2, handler)), (data) => {
+            this._callMetrics.inc(`${serviceName}.${methodName} response stream`);
+            return data;
+          });
+        } else {
+          return handler(methodName, params2);
+        }
+      }
+    });
+  }
+  get _services() {
+    return Object.keys(this._serviceRegistry.services);
+  }
+  async open() {
+    await this._rpcPeer.open();
+  }
+  async close() {
+    await this._rpcPeer.close();
+  }
+  _getServiceHandler(serviceName) {
+    if (!this._handlerCache.has(serviceName)) {
+      const [key, descriptor] = Object.entries(this._serviceRegistry.descriptors).find(([key2, descriptor2]) => descriptor2.name === serviceName) ?? 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);
+  }
+};
+_ts_decorate([
+  trace.metricsCounter()
+], ClientRpcServer.prototype, "_callMetrics", void 0);
+_ts_decorate([
+  trace.info()
+], ClientRpcServer.prototype, "_services", null);
+ClientRpcServer = _ts_decorate([
+  trace.resource()
+], ClientRpcServer);
+
+// packages/sdk/client-services/src/packlets/storage/profile-archive.ts
+import { cbor } from "@dxos/automerge/automerge-repo";
+import { invariant } from "@dxos/invariant";
+import { log } from "@dxos/log";
+import { ProfileArchiveEntryType } from "@dxos/protocols";
+import { arrayToBuffer } from "@dxos/util";
+var __dxlog_file = "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/storage/profile-archive.ts";
+var encodeProfileArchive = (profile) => cbor.encode(profile);
+var decodeProfileArchive = (data) => cbor.decode(data);
+var exportProfileData = async ({ storage, level }) => {
+  const archive = {
+    storage: [],
+    meta: {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+  {
+    const directory = await storage.createDirectory();
+    const files = await directory.list();
+    log.info("begin exporting files", {
+      count: files.length
+    }, {
+      F: __dxlog_file,
+      L: 30,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+    for (const filename of files) {
+      const file = await directory.getOrCreateFile(filename);
+      const { size } = await file.stat();
+      const data = await file.read(0, size);
+      archive.storage.push({
+        type: ProfileArchiveEntryType.FILE,
+        key: filename,
+        value: data
+      });
+    }
+    log.info("done exporting files", {
+      count: files.length
+    }, {
+      F: __dxlog_file,
+      L: 41,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+  }
+  {
+    log.info("begin exporting kv pairs", void 0, {
+      F: __dxlog_file,
+      L: 45,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+    const iter = await level.iterator({
+      keyEncoding: "binary",
+      valueEncoding: "binary"
+    });
+    let count = 0;
+    for await (const [key, value] of iter) {
+      archive.storage.push({
+        type: ProfileArchiveEntryType.KEY_VALUE,
+        key,
+        value
+      });
+      count++;
+    }
+    log.info("done exporting kv pairs", {
+      count
+    }, {
+      F: __dxlog_file,
+      L: 56,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+  }
+  return archive;
+};
+var importProfileData = async ({ storage, level }, archive) => {
+  let batch = level.batch();
+  let count = 0;
+  for (const entry of archive.storage) {
+    switch (entry.type) {
+      case ProfileArchiveEntryType.FILE: {
+        const directory = await storage.createDirectory();
+        invariant(typeof entry.key === "string", "Invalid key type", {
+          F: __dxlog_file,
+          L: 79,
+          S: void 0,
+          A: [
+            "typeof entry.key === 'string'",
+            "'Invalid key type'"
+          ]
+        });
+        const file = await directory.getOrCreateFile(entry.key);
+        invariant(entry.value instanceof Uint8Array, "Invalid value type", {
+          F: __dxlog_file,
+          L: 81,
+          S: void 0,
+          A: [
+            "entry.value instanceof Uint8Array",
+            "'Invalid value type'"
+          ]
+        });
+        await file.write(0, arrayToBuffer(entry.value));
+        await file.close();
+        break;
+      }
+      case ProfileArchiveEntryType.KEY_VALUE: {
+        invariant(entry.key instanceof Uint8Array, "Invalid key type", {
+          F: __dxlog_file,
+          L: 87,
+          S: void 0,
+          A: [
+            "entry.key instanceof Uint8Array",
+            "'Invalid key type'"
+          ]
+        });
+        invariant(entry.value instanceof Uint8Array, "Invalid value type", {
+          F: __dxlog_file,
+          L: 88,
+          S: void 0,
+          A: [
+            "entry.value instanceof Uint8Array",
+            "'Invalid value type'"
+          ]
+        });
+        batch.put(entry.key, entry.value, {
+          keyEncoding: "binary",
+          valueEncoding: "binary"
+        });
+        break;
+      }
+      default:
+        throw new Error(`Invalid entry type: ${entry.type}`);
+    }
+    if (++count % 1e3 === 0) {
+      await batch.write();
+      batch = level.batch();
+      log.info("importing", {
+        count,
+        total: archive.storage.length,
+        progress: `${(count / archive.storage.length * 100).toFixed()}%`
+      }, {
+        F: __dxlog_file,
+        L: 101,
+        S: void 0,
+        C: (f, a) => f(...a)
+      });
+    }
+  }
+  log.info("committing changes..", void 0, {
+    F: __dxlog_file,
+    L: 109,
+    S: void 0,
+    C: (f, a) => f(...a)
+  });
+  await batch.write();
+};
+
+// packages/sdk/client-services/src/packlets/worker/worker-runtime.ts
+import { Trigger as Trigger2 } from "@dxos/async";
+import { DEFAULT_WORKER_BROADCAST_CHANNEL } from "@dxos/client-protocol";
+import { Context } from "@dxos/context";
+import { invariant as invariant3 } from "@dxos/invariant";
+import { log as log3 } from "@dxos/log";
+import { MemorySignalManager, MemorySignalManagerContext, WebsocketSignalManager, setIdentityTags } from "@dxos/messaging";
+import { RtcTransportProxyFactory } from "@dxos/network-manager";
+
+// packages/sdk/client-services/src/packlets/worker/worker-session.ts
+import { asyncTimeout, Trigger } from "@dxos/async";
+import { iframeServiceBundle, PROXY_CONNECTION_TIMEOUT, workerServiceBundle } from "@dxos/client-protocol";
+import { invariant as invariant2 } from "@dxos/invariant";
+import { log as log2, logInfo } from "@dxos/log";
+import { createProtoRpcPeer } from "@dxos/rpc";
+import { Callback } from "@dxos/util";
+function _ts_decorate2(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 __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/worker/worker-session.ts";
+var WorkerSession = class {
+  constructor({ serviceHost, systemPort, appPort, shellPort, readySignal }) {
+    this._startTrigger = new Trigger();
+    this.onClose = new Callback();
+    invariant2(serviceHost, void 0, {
+      F: __dxlog_file2,
+      L: 54,
+      S: this,
+      A: [
+        "serviceHost",
+        ""
+      ]
+    });
+    this._serviceHost = serviceHost;
+    const middleware = {
+      handleCall: async (method, params, handler) => {
+        const error = await readySignal.wait({
+          timeout: PROXY_CONNECTION_TIMEOUT
+        });
+        if (error) {
+          throw error;
+        }
+        return handler(method, params);
+      },
+      handleStream: async (method, params, handler) => {
+        const error = await readySignal.wait({
+          timeout: PROXY_CONNECTION_TIMEOUT
+        });
+        if (error) {
+          throw error;
+        }
+        return handler(method, params);
+      }
+    };
+    this._clientRpc = new ClientRpcServer({
+      serviceRegistry: this._serviceHost.serviceRegistry,
+      port: appPort,
+      ...middleware
+    });
+    this._shellClientRpc = shellPort ? new ClientRpcServer({
+      serviceRegistry: this._serviceHost.serviceRegistry,
+      port: shellPort,
+      ...middleware
+    }) : void 0;
+    this._iframeRpc = createProtoRpcPeer({
+      requested: iframeServiceBundle,
+      exposed: workerServiceBundle,
+      handlers: {
+        WorkerService: {
+          start: async (request) => {
+            this.origin = request.origin;
+            this.lockKey = request.lockKey;
+            this.observabilityGroup = request.observabilityGroup;
+            this.signalTelemetryEnabled = request.signalTelemetryEnabled;
+            this._startTrigger.wake();
+          },
+          stop: async () => {
+            setTimeout(async () => {
+              try {
+                await this.close();
+              } catch (err) {
+                log2.catch(err, void 0, {
+                  F: __dxlog_file2,
+                  L: 108,
+                  S: this,
+                  C: (f, a) => f(...a)
+                });
+              }
+            });
+          }
+        }
+      },
+      port: systemPort,
+      timeout: 1e3
+    });
+    this.bridgeService = this._iframeRpc.rpc.BridgeService;
+  }
+  async open() {
+    log2.info("opening...", void 0, {
+      F: __dxlog_file2,
+      L: 122,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    await Promise.all([
+      this._clientRpc.open(),
+      this._iframeRpc.open(),
+      this._maybeOpenShell()
+    ]);
+    await this._startTrigger.wait({
+      timeout: PROXY_CONNECTION_TIMEOUT
+    });
+    if (this.lockKey) {
+      void this._afterLockReleases(this.lockKey, () => this.close());
+    }
+    log2.info("opened", void 0, {
+      F: __dxlog_file2,
+      L: 133,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+  }
+  async close() {
+    log2.info("closing...", void 0, {
+      F: __dxlog_file2,
+      L: 137,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    try {
+      await this.onClose.callIfSet();
+    } catch (err) {
+      log2.catch(err, void 0, {
+        F: __dxlog_file2,
+        L: 141,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    }
+    await Promise.all([
+      this._clientRpc.close(),
+      this._iframeRpc.close()
+    ]);
+    log2.info("closed", void 0, {
+      F: __dxlog_file2,
+      L: 145,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+  }
+  async _maybeOpenShell() {
+    try {
+      this._shellClientRpc && await asyncTimeout(this._shellClientRpc.open(), 1e3);
+    } catch {
+      log2.info("No shell connected.", void 0, {
+        F: __dxlog_file2,
+        L: 152,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    }
+  }
+  _afterLockReleases(lockKey, callback) {
+    return navigator.locks.request(lockKey, () => {
+    }).then(callback);
+  }
+};
+_ts_decorate2([
+  logInfo
+], WorkerSession.prototype, "origin", void 0);
+_ts_decorate2([
+  logInfo
+], WorkerSession.prototype, "lockKey", void 0);
+
+// packages/sdk/client-services/src/packlets/worker/worker-runtime.ts
+var __dxlog_file3 = "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/worker/worker-runtime.ts";
+var WorkerRuntime = class {
+  constructor({ channel = DEFAULT_WORKER_BROADCAST_CHANNEL, configProvider, acquireLock, releaseLock, onStop }) {
+    this._transportFactory = new RtcTransportProxyFactory();
+    this._ready = new Trigger2();
+    this._sessions = /* @__PURE__ */ new Set();
+    this._signalMetadataTags = {
+      runtime: "worker-runtime"
+    };
+    this._signalTelemetryEnabled = false;
+    this._configProvider = configProvider;
+    this._acquireLock = acquireLock;
+    this._releaseLock = releaseLock;
+    this._onStop = onStop;
+    this._channel = channel;
+    this._clientServices = new ClientServicesHost({
+      callbacks: {
+        onReset: async () => this.stop()
+      }
+    });
+  }
+  get host() {
+    return this._clientServices;
+  }
+  async start() {
+    log3("starting...", void 0, {
+      F: __dxlog_file3,
+      L: 84,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    try {
+      this._broadcastChannel = new BroadcastChannel(this._channel);
+      this._broadcastChannel.postMessage({
+        action: "stop"
+      });
+      this._broadcastChannel.onmessage = async (event) => {
+        if (event.data?.action === "stop") {
+          await this.stop();
+        }
+      };
+      await this._acquireLock();
+      this._config = await this._configProvider();
+      const signals = this._config.get("runtime.services.signaling");
+      this._clientServices.initialize({
+        config: this._config,
+        signalManager: this._config.get("runtime.client.edgeFeatures")?.signaling ? void 0 : signals ? new WebsocketSignalManager(signals, () => this._signalTelemetryEnabled ? this._signalMetadataTags : {}) : new MemorySignalManager(new MemorySignalManagerContext()),
+        transportFactory: this._transportFactory
+      });
+      await this._clientServices.open(new Context(void 0, {
+        F: __dxlog_file3,
+        L: 107
+      }));
+      this._ready.wake(void 0);
+      log3("started", void 0, {
+        F: __dxlog_file3,
+        L: 109,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      setIdentityTags({
+        identityService: this._clientServices.services.IdentityService,
+        devicesService: this._clientServices.services.DevicesService,
+        setTag: (k, v) => {
+          this._signalMetadataTags[k] = v;
+        }
+      });
+    } catch (err) {
+      this._ready.wake(err);
+      log3.error("starting", err, {
+        F: __dxlog_file3,
+        L: 119,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    }
+  }
+  async stop() {
+    this._releaseLock();
+    this._broadcastChannel?.close();
+    this._broadcastChannel = void 0;
+    await this._clientServices.close();
+    await this._onStop?.();
+  }
+  /**
+  * 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);
+      if (this._sessions.size === 0) {
+        await this.stop();
+      } else {
+        this._reconnectWebrtc();
+      }
+    });
+    await session.open();
+    invariant3(!this._signalMetadataTags.origin || this._signalMetadataTags.origin === session.origin, `worker origin changed from ${this._signalMetadataTags.origin} to ${session.origin}?`, {
+      F: __dxlog_file3,
+      L: 157,
+      S: this,
+      A: [
+        "!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();
+  }
+  /**
+  * Selects one of the existing session for WebRTC networking.
+  */
+  _reconnectWebrtc() {
+    log3("reconnecting webrtc...", void 0, {
+      F: __dxlog_file3,
+      L: 175,
+      S: this,
+      C: (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 {
+  ClientRpcServer,
+  ClientServicesHost,
+  DataSpace,
+  DataSpaceManager,
+  DeviceInvitationProtocol,
+  DevtoolsHostEvents,
+  DevtoolsServiceImpl,
+  DiagnosticsCollector,
+  EdgeAgentManager,
+  EdgeAgentServiceImpl,
+  EdgeFeedReplicator,
+  Identity,
+  IdentityManager,
+  IdentityServiceImpl,
+  InvitationsHandler,
+  InvitationsManager,
+  InvitationsServiceImpl,
+  Lock,
+  ServiceContext,
+  ServiceRegistry,
+  SpaceInvitationProtocol,
+  SpacesServiceImpl,
+  TrustedKeySetAuthVerifier,
+  WorkerRuntime,
+  WorkerSession,
+  createAdmissionKeypair,
+  createAuthProvider,
+  createCollectDiagnosticsBroadcastHandler,
+  createCollectDiagnosticsBroadcastSender,
+  createDiagnostics,
+  createLevel,
+  createStorageObjects,
+  decodeProfileArchive,
+  encodeProfileArchive,
+  exportProfileData,
+  getNetworkPeers,
+  importProfileData,
+  isLocked,
+  subscribeToFeedBlocks,
+  subscribeToFeeds,
+  subscribeToNetworkStatus,
+  subscribeToNetworkTopics,
+  subscribeToSignal,
+  subscribeToSpaces,
+  subscribeToSwarmInfo
+};
+//# sourceMappingURL=index.mjs.map