memeloop 0.2.0 → 0.2.2

package/dist/device-network.cjs

@@ -21,9 +21,12 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var device_network_entry_exports = {};
 __export(device_network_entry_exports, {
   ChatSyncEngine: () => ChatSyncEngine,
+  DEVICE_BINDING_SIGNATURE_DOMAIN: () => DEVICE_BINDING_SIGNATURE_DOMAIN,
+  DEVICE_CONNECTION_GRANT_SIGNATURE_DOMAIN: () => DEVICE_CONNECTION_GRANT_SIGNATURE_DOMAIN,
   DEVICE_ORCHESTRATION_PROTOCOL: () => DEVICE_ORCHESTRATION_PROTOCOL,
   DEVICE_PAIRING_INVITE_PROTOCOL: () => DEVICE_PAIRING_INVITE_PROTOCOL,
   DEVICE_PAIRING_INVITE_TTL_MS: () => DEVICE_PAIRING_INVITE_TTL_MS,
+  DEVICE_RELAY_ADMISSION_SIGNATURE_DOMAIN: () => DEVICE_RELAY_ADMISSION_SIGNATURE_DOMAIN,
   DeviceCloudConnectionCoordinator: () => DeviceCloudConnectionCoordinator,
   JsonFrameError: () => JsonFrameError,
   LIBP2P_RPC_REQUEST_TYPE: () => LIBP2P_RPC_REQUEST_TYPE,
@@ -36,6 +39,9 @@ __export(device_network_entry_exports, {
   MemoryDeviceSyncStateStore: () => MemoryDeviceSyncStateStore,
   PeerNodeSyncAdapter: () => PeerNodeSyncAdapter,
   attachmentBlobFromWire: () => attachmentBlobFromWire,
+  buildDeviceBindingMessage: () => buildDeviceBindingMessage,
+  buildDeviceConnectionGrantMessage: () => buildDeviceConnectionGrantMessage,
+  buildDeviceRelayReservationTokenMessage: () => buildDeviceRelayReservationTokenMessage,
   canonicalDevicePairingInviteBytes: () => canonicalDevicePairingInviteBytes,
   computeMissingVersionRanges: () => computeMissingVersionRanges,
   createDeviceOrchestrationStreamHandler: () => createDeviceOrchestrationStreamHandler,
@@ -124,8 +130,12 @@ var DeviceCloudConnectionCoordinator = class {
   async stop() {
     this.started = false;
     this.clearTimer();
-    this.controller.abort(new Error("device cloud coordinator stopped"));
+    const stoppedController = this.controller;
+    stoppedController.abort(new Error("device cloud coordinator stopped"));
     await this.inFlight?.catch(() => void 0);
+    if (this.controller === stoppedController) {
+      this.controller = new AbortController();
+    }
   }
   async setConfiguration(configuration) {
     this.configuration = configuration;
@@ -274,6 +284,43 @@ var DeviceCloudConnectionCoordinator = class {
   }
 };
 
+// src/device-network/deviceGrantMessages.ts
+var DEVICE_BINDING_SIGNATURE_DOMAIN = "memeloop-device-binding-v2";
+var DEVICE_CONNECTION_GRANT_SIGNATURE_DOMAIN = "memeloop-device-connection-grant-v2";
+var DEVICE_RELAY_ADMISSION_SIGNATURE_DOMAIN = "memeloop-device-relay-admission-v2";
+function buildDeviceBindingMessage(input) {
+  return new TextEncoder().encode([
+    DEVICE_BINDING_SIGNATURE_DOMAIN,
+    `accountId=${input.accountId}`,
+    `peerId=${input.peerId}`,
+    `publicKey=${input.publicKeyMultibase}`,
+    `nonce=${input.nonce}`
+  ].join("\n"));
+}
+function buildDeviceConnectionGrantMessage(grant) {
+  return new TextEncoder().encode([
+    DEVICE_CONNECTION_GRANT_SIGNATURE_DOMAIN,
+    `issuer=${grant.issuer}`,
+    `accountId=${grant.accountId}`,
+    `subjectPeerId=${grant.subjectPeerId}`,
+    `allowedPeerIds=${grant.allowedPeerIds.join(",")}`,
+    `issuedAt=${grant.issuedAt}`,
+    `expiresAt=${grant.expiresAt}`
+  ].join("\n"));
+}
+function buildDeviceRelayReservationTokenMessage(token) {
+  return new TextEncoder().encode([
+    DEVICE_RELAY_ADMISSION_SIGNATURE_DOMAIN,
+    `issuer=${token.issuer}`,
+    `accountId=${token.accountId}`,
+    `peerId=${token.peerId}`,
+    `relayMultiaddrs=${token.relayMultiaddrs.join(",")}`,
+    `bootstrapMultiaddrs=${token.bootstrapMultiaddrs.join(",")}`,
+    `issuedAt=${token.issuedAt}`,
+    `expiresAt=${token.expiresAt}`
+  ].join("\n"));
+}
+
 // src/orchestration/errors.ts
 var OrchestrationError = class extends Error {
   code;
@@ -696,39 +743,92 @@ async function readSingleRequest(stream, maxFrameBytes) {
 }
 async function* withWatchBookmarks(source, request, signal) {
   const iterator = source[Symbol.asyncIterator]();
-  let pending = iterator.next();
+  let activity;
+  let activityWaiter;
+  let bookmarkTimer;
+  let readInFlight = false;
+  let lastResourceVersion = watchResourceVersion(request.payload.options) ?? "0";
+  const clearBookmarkTimer = () => {
+    if (bookmarkTimer !== void 0) clearTimeout(bookmarkTimer);
+    bookmarkTimer = void 0;
+  };
+  const publishActivity = (value) => {
+    if (activityWaiter) {
+      const resolve = activityWaiter;
+      activityWaiter = void 0;
+      clearBookmarkTimer();
+      resolve(value);
+      return;
+    }
+    activity = value;
+  };
+  const readNext = () => {
+    if (readInFlight) return;
+    readInFlight = true;
+    void iterator.next().then(
+      (value) => {
+        readInFlight = false;
+        publishActivity({ kind: "value", value });
+      },
+      (error) => {
+        readInFlight = false;
+        publishActivity({ kind: "error", error });
+      }
+    );
+  };
+  const waitForActivity = () => {
+    if (activity) {
+      const value = activity;
+      activity = void 0;
+      return Promise.resolve(value);
+    }
+    if (signal.aborted) return Promise.resolve({ kind: "aborted" });
+    return new Promise((resolve) => {
+      activityWaiter = resolve;
+      bookmarkTimer = setTimeout(() => {
+        bookmarkTimer = void 0;
+        activityWaiter = void 0;
+        resolve({ kind: "bookmark" });
+      }, WATCH_BOOKMARK_INTERVAL_MS);
+    });
+  };
+  const onAbort = () => {
+    publishActivity({ kind: "aborted" });
+  };
+  signal.addEventListener("abort", onAbort, { once: true });
+  readNext();
   try {
     for (; ; ) {
-      const result = await Promise.race([
-        pending.then((value) => ({ kind: "value", value })),
-        new Promise((resolve) => {
-          const timer = setTimeout(() => {
-            resolve({ kind: "bookmark" });
-          }, WATCH_BOOKMARK_INTERVAL_MS);
-          signal.addEventListener("abort", () => {
-            clearTimeout(timer);
-            resolve({ kind: "bookmark" });
-          }, { once: true });
-        })
-      ]);
-      if (signal.aborted) return;
+      const result = await waitForActivity();
+      if (result.kind === "aborted") return;
       if (result.kind === "bookmark") {
         yield {
           protocol: request.protocol,
           requestId: request.requestId,
           ok: true,
-          result: { type: "BOOKMARK", resourceVersion: String(Date.now()) }
+          result: { type: "BOOKMARK", resourceVersion: lastResourceVersion }
         };
         continue;
       }
+      if (result.kind === "error") throw result.error;
       if (result.value.done) return;
-      yield result.value.value;
-      pending = iterator.next();
+      const response = result.value.value;
+      lastResourceVersion = response.ok ? watchResourceVersion(response.result) ?? lastResourceVersion : lastResourceVersion;
+      yield response;
+      readNext();
     }
   } finally {
+    clearBookmarkTimer();
+    activityWaiter = void 0;
+    signal.removeEventListener("abort", onAbort);
     void iterator.return?.();
   }
 }
+function watchResourceVersion(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const resourceVersion = value.resourceVersion;
+  return typeof resourceVersion === "string" && resourceVersion.length > 0 ? resourceVersion : void 0;
+}
 function createDeviceOrchestrationStreamHandler(options) {
   const maxFrameBytes = options.maxFrameBytes ?? DEFAULT_MAX_FRAME_BYTES;
   assertFrameLimit(maxFrameBytes);
@@ -850,6 +950,12 @@ var Libp2pDeviceSyncTransport = class {
   async request(peerId, method, parameters) {
     const grant = await this.grantProvider?.(peerId);
     const stream = await this.deviceNetwork.openStream(peerId, "/memeloop/sync/2.0.0", grant);
+    let aborted = false;
+    const abort = async (error) => {
+      if (aborted) return;
+      aborted = true;
+      await stream.abort(error);
+    };
     const request = {
       type: LIBP2P_SYNC_REQUEST_TYPE,
       id: crypto.randomUUID(),
@@ -864,7 +970,7 @@ var Libp2pDeviceSyncTransport = class {
         maxPayloadBytes: 16 * 1024 * 1024,
         idleTimeoutMs: 15e3,
         totalTimeoutMs: 12e4,
-        abort: async (error) => stream.abort(error)
+        abort
       })) {
         if (response !== void 0) throw new Error("sync_response_multiple");
         response = value;
@@ -874,7 +980,7 @@ var Libp2pDeviceSyncTransport = class {
       if (!response.ok) throw new Error(response.error);
       return response.result;
     } catch (error) {
-      if (error instanceof JsonFrameError) await stream.abort(error);
+      if (error instanceof JsonFrameError) await abort(error);
       throw error;
     } finally {
       await stream.close().catch(() => void 0);
@@ -1492,9 +1598,12 @@ function sameTrustedDevice(left, right) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ChatSyncEngine,
+  DEVICE_BINDING_SIGNATURE_DOMAIN,
+  DEVICE_CONNECTION_GRANT_SIGNATURE_DOMAIN,
   DEVICE_ORCHESTRATION_PROTOCOL,
   DEVICE_PAIRING_INVITE_PROTOCOL,
   DEVICE_PAIRING_INVITE_TTL_MS,
+  DEVICE_RELAY_ADMISSION_SIGNATURE_DOMAIN,
   DeviceCloudConnectionCoordinator,
   JsonFrameError,
   LIBP2P_RPC_REQUEST_TYPE,
@@ -1507,6 +1616,9 @@ function sameTrustedDevice(left, right) {
   MemoryDeviceSyncStateStore,
   PeerNodeSyncAdapter,
   attachmentBlobFromWire,
+  buildDeviceBindingMessage,
+  buildDeviceConnectionGrantMessage,
+  buildDeviceRelayReservationTokenMessage,
   canonicalDevicePairingInviteBytes,
   computeMissingVersionRanges,
   createDeviceOrchestrationStreamHandler,