memeloop 0.2.8 → 0.2.9

package/dist/device-network.cjs

@@ -42,6 +42,7 @@ __export(device_network_entry_exports, {
   DEVICE_HEARTBEAT_DEFAULT_MAX_CLOCK_SKEW_MS: () => DEVICE_HEARTBEAT_DEFAULT_MAX_CLOCK_SKEW_MS,
   DEVICE_HEARTBEAT_LIMITS: () => DEVICE_HEARTBEAT_LIMITS,
   DEVICE_HEARTBEAT_SIGNATURE_DOMAIN: () => DEVICE_HEARTBEAT_SIGNATURE_DOMAIN,
+  DEVICE_ORCHESTRATION_FRAME_LIMITS: () => DEVICE_ORCHESTRATION_FRAME_LIMITS,
   DEVICE_ORCHESTRATION_PROTOCOL: () => DEVICE_ORCHESTRATION_PROTOCOL,
   DEVICE_PAIRING_INVITE_MAX_CLOCK_SKEW_MS: () => DEVICE_PAIRING_INVITE_MAX_CLOCK_SKEW_MS,
   DEVICE_PAIRING_INVITE_PROTOCOL: () => DEVICE_PAIRING_INVITE_PROTOCOL,
@@ -4640,14 +4641,28 @@ var MemoryDeviceCloudTokenStorage = class {
   loadConnectionGrant(input) {
     return this.grants.get(connectionGrantCacheKey(input));
   }
-  saveConnectionGrant(input, grant) {
-    this.grants.set(connectionGrantCacheKey(input), grant);
+  saveConnectionGrant(input, grant, fence) {
+    const write = () => {
+      this.grants.set(connectionGrantCacheKey(input), grant);
+    };
+    if (!fence) {
+      write();
+      return;
+    }
+    if (!fence.commitSynchronous(write)) fence.throwIfStale();
   }
   loadRelayReservation(peerId) {
     return this.relayReservations.get(peerId);
   }
-  saveRelayReservation(peerId, token) {
-    this.relayReservations.set(peerId, token);
+  saveRelayReservation(peerId, token, fence) {
+    const write = () => {
+      this.relayReservations.set(peerId, token);
+    };
+    if (!fence) {
+      write();
+      return;
+    }
+    if (!fence.commitSynchronous(write)) fence.throwIfStale();
   }
   clear() {
     this.grants.clear();
@@ -4762,13 +4777,16 @@ var CloudDeviceFetchClient = class {
     }
     return { issuer: value.issuer, publicKeyMultibase: value.publicKeyMultibase };
   }
-  async createConnectionGrant(input, signal) {
+  async createConnectionGrant(input, signal, fence) {
+    assertFenceSignal(signal, fence);
+    fence?.throwIfStale();
     if (!isCanonicalConnectionGrantRequest(input)) {
       throw new TypeError("invalid_connection_grant_scope");
     }
     const cacheInput = normalizedConnectionGrantRequest(input);
     const cached = await this.loadCachedGrant(cacheInput);
     throwIfAborted(signal);
+    fence?.throwIfStale();
     if (isUsableConnectionGrant(cached, cacheInput, this.now() + this.tokenSafetyMarginMs)) {
       return cached;
     }
@@ -4777,12 +4795,17 @@ var CloudDeviceFetchClient = class {
       body: JSON.stringify(input)
     }, signal);
     if (!isUsableConnectionGrant(value, cacheInput, this.now())) throw invalidShape();
-    await this.saveCachedGrant(cacheInput, value);
+    fence?.throwIfStale();
+    await this.saveCachedGrant(cacheInput, value, fence);
+    fence?.throwIfStale();
     return value;
   }
-  async createRelayReservation(input, signal) {
+  async createRelayReservation(input, signal, fence) {
+    assertFenceSignal(signal, fence);
+    fence?.throwIfStale();
     const cached = await this.loadCachedRelayReservation(input.peerId);
     throwIfAborted(signal);
+    fence?.throwIfStale();
     if (isUsableRelayReservation(cached, input.peerId, this.now() + this.tokenSafetyMarginMs)) {
       return cached;
     }
@@ -4791,7 +4814,9 @@ var CloudDeviceFetchClient = class {
       body: JSON.stringify(input)
     }, signal);
     if (!isUsableRelayReservation(value, input.peerId, this.now())) throw invalidShape();
-    await this.saveCachedRelayReservation(input.peerId, value);
+    fence?.throwIfStale();
+    await this.saveCachedRelayReservation(input.peerId, value, fence);
+    fence?.throwIfStale();
     return value;
   }
   async heartbeat(input, signal) {
@@ -4865,10 +4890,11 @@ var CloudDeviceFetchClient = class {
       return void 0;
     }
   }
-  async saveCachedGrant(input, grant) {
+  async saveCachedGrant(input, grant, fence) {
     try {
-      await this.tokenStorage.saveConnectionGrant(input, grant);
+      await this.tokenStorage.saveConnectionGrant(input, grant, fence);
     } catch (error) {
+      if (fence && !fence.isCurrent()) fence.throwIfStale();
       this.options.onTokenStorageError?.("save", error);
     }
   }
@@ -4880,14 +4906,20 @@ var CloudDeviceFetchClient = class {
       return void 0;
     }
   }
-  async saveCachedRelayReservation(peerId, token) {
+  async saveCachedRelayReservation(peerId, token, fence) {
     try {
-      await this.tokenStorage.saveRelayReservation(peerId, token);
+      await this.tokenStorage.saveRelayReservation(peerId, token, fence);
     } catch (error) {
+      if (fence && !fence.isCurrent()) fence.throwIfStale();
       this.options.onTokenStorageError?.("save", error);
     }
   }
 };
+function assertFenceSignal(signal, fence) {
+  if (fence && signal && fence.signal !== signal) {
+    throw new TypeError("device_cloud_generation_signal_mismatch");
+  }
+}
 function normalizeCloudDeviceBaseUrl(value) {
   const baseUrl = value.trim();
   if (!baseUrl || baseUrl.length > CLOUD_URL_MAX_CHARACTERS) throw new Error("invalid_cloud_url");
@@ -5314,16 +5346,16 @@ var DeviceCloudConnectionCoordinator = class {
     try {
       if (this.snapshotValue.components.authorizer !== "ready") {
         activeComponent = "authorizer";
-        await this.runStep(activeComponent, generation, signal, () => this.options.adapter.ensureAuthorizer(configuration, signal));
+        await this.runStep(activeComponent, generation, signal, (fence) => this.options.adapter.ensureAuthorizer(configuration, signal, fence));
       }
       if (this.snapshotValue.components.registration !== "ready") {
         activeComponent = "registration";
-        await this.runStep(activeComponent, generation, signal, () => this.options.adapter.registerDevice(configuration, signal));
+        await this.runStep(activeComponent, generation, signal, (fence) => this.options.adapter.registerDevice(configuration, signal, fence));
       }
       let relayFailure;
       try {
         activeComponent = "relay";
-        await this.runStep(activeComponent, generation, signal, () => this.options.adapter.ensureRelay(configuration, signal));
+        await this.runStep(activeComponent, generation, signal, (fence) => this.options.adapter.ensureRelay(configuration, signal, fence));
       } catch (error) {
         const classification = this.classify(error);
         if (classification === "registration-invalid") throw error;
@@ -5331,11 +5363,11 @@ var DeviceCloudConnectionCoordinator = class {
         this.warn("Device Cloud relay maintenance failed", relayFailure);
       }
       activeComponent = "heartbeat";
-      await this.runStep(activeComponent, generation, signal, () => this.options.adapter.heartbeat(configuration, signal));
+      await this.runStep(activeComponent, generation, signal, (fence) => this.options.adapter.heartbeat(configuration, signal, fence));
       let directoryFailure;
       try {
         activeComponent = "directory";
-        await this.runStep(activeComponent, generation, signal, () => this.options.adapter.syncDirectory(configuration, signal));
+        await this.runStep(activeComponent, generation, signal, (fence) => this.options.adapter.syncDirectory(configuration, signal, fence));
       } catch (error) {
         const classification = this.classify(error);
         if (classification === "registration-invalid") throw error;
@@ -5375,9 +5407,9 @@ var DeviceCloudConnectionCoordinator = class {
     if (!this.isCurrent(generation, signal)) return;
     await this.setComponent(component, "pending", generation);
     try {
-      const result = await operation();
-      if (!this.isCurrent(generation, signal)) return;
       const fence = this.createCommitFence(generation, signal);
+      const result = await operation(fence);
+      if (!this.isCurrent(generation, signal)) return;
       await result?.commit?.(fence);
       if (!this.isCurrent(generation, signal)) return;
       await this.setComponent(component, "ready", generation);
@@ -6105,11 +6137,18 @@ function createJsonFrameReader(source, options) {
 
 // src/device-network/deviceOrchestrationTransport.ts
 var DEVICE_ORCHESTRATION_PROTOCOL = "/memeloop/orchestration/2.0.0";
-var DEFAULT_MAX_FRAME_BYTES = 1024 * 1024;
-var REQUEST_IDLE_TIMEOUT_MS = 1e4;
-var REQUEST_TOTAL_TIMEOUT_MS = 3e4;
-var WATCH_IDLE_TIMEOUT_MS = 9e4;
-var WATCH_BOOKMARK_INTERVAL_MS = 3e4;
+var DEVICE_ORCHESTRATION_FRAME_LIMITS = Object.freeze({
+  maxPayloadBytes: 1024 * 1024,
+  requestIdleTimeoutMs: 1e4,
+  requestTotalTimeoutMs: 3e4,
+  watchIdleTimeoutMs: 9e4,
+  watchBookmarkIntervalMs: 3e4
+});
+var DEFAULT_MAX_FRAME_BYTES = DEVICE_ORCHESTRATION_FRAME_LIMITS.maxPayloadBytes;
+var REQUEST_IDLE_TIMEOUT_MS = DEVICE_ORCHESTRATION_FRAME_LIMITS.requestIdleTimeoutMs;
+var REQUEST_TOTAL_TIMEOUT_MS = DEVICE_ORCHESTRATION_FRAME_LIMITS.requestTotalTimeoutMs;
+var WATCH_IDLE_TIMEOUT_MS = DEVICE_ORCHESTRATION_FRAME_LIMITS.watchIdleTimeoutMs;
+var WATCH_BOOKMARK_INTERVAL_MS = DEVICE_ORCHESTRATION_FRAME_LIMITS.watchBookmarkIntervalMs;
 function orchestrationTransportError(code, message) {
   return new OrchestrationError({
     code,
@@ -6390,6 +6429,13 @@ function createDeviceOrchestrationStreamHandler(options) {
   assertFrameLimit(maxFrameBytes);
   return async ({ remotePeerId, stream, authorize }) => {
     const abort = new AbortController();
+    const abortFromStream = () => {
+      if (!abort.signal.aborted) {
+        abort.abort(stream.signal?.reason ?? new Error("device orchestration stream closed"));
+      }
+    };
+    stream.signal?.addEventListener("abort", abortFromStream, { once: true });
+    if (stream.signal?.aborted) abortFromStream();
     try {
       const envelope = await readSingleRequest(stream, maxFrameBytes);
       if (authorize && !await authorize(envelope.grant)) {
@@ -6413,7 +6459,8 @@ function createDeviceOrchestrationStreamHandler(options) {
         await stream.sink(encodeJsonFrames([response], maxFrameBytes));
       }
     } finally {
-      abort.abort();
+      stream.signal?.removeEventListener("abort", abortFromStream);
+      if (!abort.signal.aborted) abort.abort();
       await stream.close().catch(() => void 0);
     }
   };
@@ -6948,6 +6995,23 @@ function sameTrustedDevice(left, right) {
 
 // src/device-network/standardDeviceCloudConnectionAdapter.ts
 var DEFAULT_RELAY_TOKEN_SAFETY_MARGIN_MS = 2 * 6e4;
+var REGISTRATION_INVALID_ERROR_CODES = /* @__PURE__ */ new Set([
+  "device_not_found",
+  "device_registration_invalid",
+  "device_registration_not_found",
+  "invalid_device_registration",
+  "registration_invalid"
+]);
+var DeviceCloudRegistrationInvalidError = class extends Error {
+  code = "DEVICE_CLOUD_REGISTRATION_INVALID";
+  constructor(cause) {
+    super(
+      "cloud device heartbeat rejected",
+      cause === void 0 ? void 0 : { cause }
+    );
+    this.name = "DeviceCloudRegistrationInvalidError";
+  }
+};
 var StandardDeviceCloudConnectionAdapter = class {
   constructor(options) {
     this.options = options;
@@ -6967,9 +7031,9 @@ var StandardDeviceCloudConnectionAdapter = class {
   }
   relayRequiredForOnline(_configuration) {
     const addresses = this.options.network.getMultiaddrs();
-    return this.options.relayRequiredForOnline?.(addresses) ?? !hasValidDirectCloudDeviceAddress(addresses);
+    return this.options.relayRequiredForOnline?.(addresses) ?? !hasValidDirectCloudDeviceAddress(addresses, this.options.identity.peerId);
   }
-  async ensureAuthorizer(client, signal) {
+  async ensureAuthorizer(client, signal, _fence) {
     const publicKey = await client.getConnectionGrantPublicKey(signal);
     return {
       commit: async (fence) => {
@@ -6979,7 +7043,7 @@ var StandardDeviceCloudConnectionAdapter = class {
       }
     };
   }
-  async registerDevice(client, signal) {
+  async registerDevice(client, signal, _fence) {
     const nonce = await client.createBindingNonce(signal);
     throwIfAborted3(signal);
     const signature = await this.options.signDeviceBinding({
@@ -7007,27 +7071,28 @@ var StandardDeviceCloudConnectionAdapter = class {
     }
     return void 0;
   }
-  async ensureRelay(client, signal) {
+  async ensureRelay(client, signal, fence) {
     if (this.relayReservationClient === client && this.relayReservation && this.relayReservation.expiresAt > this.now() + this.relayTokenSafetyMarginMs) {
       return void 0;
     }
     const relayReservation = await client.createRelayReservation(
       { peerId: this.options.identity.peerId },
-      signal
+      signal,
+      fence
     );
     return {
-      commit: async (fence) => {
-        fence.throwIfStale();
-        await this.options.network.configureRelayReservation(relayReservation, signal, fence);
-        fence.throwIfStale();
-        fence.commitSynchronous(() => {
+      commit: async (fence2) => {
+        fence2.throwIfStale();
+        await this.options.network.configureRelayReservation(relayReservation, signal, fence2);
+        fence2.throwIfStale();
+        fence2.commitSynchronous(() => {
           this.relayReservation = relayReservation;
           this.relayReservationClient = client;
         });
       }
     };
   }
-  async heartbeat(client, signal) {
+  async heartbeat(client, signal, _fence) {
     throwIfAborted3(signal);
     const capabilities = await this.options.capabilities();
     throwIfAborted3(signal);
@@ -7045,8 +7110,16 @@ var StandardDeviceCloudConnectionAdapter = class {
     if (!boundedProofSignature(heartbeat.signature)) {
       throw new Error("invalid device heartbeat signature");
     }
-    const result = await client.heartbeat(heartbeat, signal);
-    if (!result.ok) throw new Error("cloud device heartbeat rejected");
+    let result;
+    try {
+      result = await client.heartbeat(heartbeat, signal);
+    } catch (error) {
+      if (isHeartbeatRegistrationInvalid(error)) {
+        throw new DeviceCloudRegistrationInvalidError(error);
+      }
+      throw error;
+    }
+    if (!result.ok) throw new DeviceCloudRegistrationInvalidError();
     return void 0;
   }
   async dispose(client, signal) {
@@ -7082,7 +7155,7 @@ var StandardDeviceCloudConnectionAdapter = class {
       throw new AggregateError(errors, "device cloud generation cleanup failed");
     }
   }
-  async syncDirectory(client, signal) {
+  async syncDirectory(client, signal, _fence) {
     const cloudDevices = await client.listDevices(signal);
     return {
       commit: async (fence) => {
@@ -7110,6 +7183,7 @@ var StandardDeviceCloudConnectionAdapter = class {
     return this.options.syncDevice(client, peerId, signal);
   }
   classifyError(error) {
+    if (error instanceof DeviceCloudRegistrationInvalidError) return "registration-invalid";
     if (error instanceof CloudDeviceFetchError) {
       return error.code === "cloud_request_failed" ? "offline" : "error";
     }
@@ -7120,6 +7194,35 @@ var StandardDeviceCloudConnectionAdapter = class {
     return active.length > 0 ? [...active] : [...this.relayReservation?.relayMultiaddrs ?? []];
   }
 };
+function isHeartbeatRegistrationInvalid(error) {
+  if (!(error instanceof CloudDeviceFetchError) || error.code !== "cloud_http_error") {
+    return false;
+  }
+  if (error.status === 404) return true;
+  return error.status === 401 && hasExplicitRegistrationInvalidCode(error.responseBody);
+}
+function hasExplicitRegistrationInvalidCode(responseBody) {
+  const body = responseBody?.trim();
+  if (!body) return false;
+  let value;
+  try {
+    value = JSON.parse(body);
+  } catch {
+    return REGISTRATION_INVALID_ERROR_CODES.has(normalizeErrorCode(body));
+  }
+  return registrationInvalidCodeFromValue(value);
+}
+function registrationInvalidCodeFromValue(value) {
+  if (typeof value === "string") {
+    return REGISTRATION_INVALID_ERROR_CODES.has(normalizeErrorCode(value));
+  }
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const record = value;
+  return registrationInvalidCodeFromValue(record.code) || registrationInvalidCodeFromValue(record.errorCode) || registrationInvalidCodeFromValue(record.error);
+}
+function normalizeErrorCode(value) {
+  return value.trim().toLowerCase().replaceAll("-", "_");
+}
 function toPublicDeviceIdentity(identity) {
   return {
     peerId: identity.peerId,
@@ -7129,21 +7232,42 @@ function toPublicDeviceIdentity(identity) {
     platform: identity.platform
   };
 }
-function hasValidDirectCloudDeviceAddress(addresses) {
-  return addresses.some((address) => {
-    if (address.includes("/p2p-circuit")) return false;
-    const parts = address.split("/");
-    const protocolIndex = parts.findIndex(
-      (part) => part === "ip4" || part === "ip6" || part === "dns" || part === "dns4" || part === "dns6"
-    );
-    if (protocolIndex < 0) return false;
-    const host = parts[protocolIndex + 1]?.toLowerCase();
-    if (!host) return false;
-    const protocol = parts[protocolIndex];
-    if (protocol === "ip4") return isPublicIpv4(host);
-    if (protocol === "ip6") return isPublicIpv6(host);
-    return isPlausiblePublicDnsHost(host);
-  });
+function hasValidDirectCloudDeviceAddress(addresses, expectedPeerId) {
+  return addresses.some((address) => isDialableDirectMultiaddr(address, expectedPeerId));
+}
+function isDialableDirectMultiaddr(address, expectedPeerId) {
+  if (address.length === 0 || address.length > 4096 || address !== address.trim() || !address.startsWith("/") || address.endsWith("/") || address.includes("//") || address.includes("/p2p-circuit")) return false;
+  const parts = address.split("/").slice(1);
+  if (parts.some((part) => part.length === 0 || containsAsciiControlOrSpace3(part))) return false;
+  const hostProtocol = parts[0];
+  const host = parts[1]?.toLowerCase();
+  if (host === void 0 || hostProtocol !== "ip4" && hostProtocol !== "ip6" && hostProtocol !== "dns" && hostProtocol !== "dns4" && hostProtocol !== "dns6") return false;
+  const publicHost = hostProtocol === "ip4" ? isPublicIpv4(host) : hostProtocol === "ip6" ? isPublicIpv6(host) : isPlausiblePublicDnsHost(host);
+  if (!publicHost) return false;
+  const transport = parts[2];
+  const port = parsePort(parts[3]);
+  if (transport !== "tcp" || port === void 0) return false;
+  let index = 4;
+  if (parts[index] === "ws" || parts[index] === "wss") index += 1;
+  if (parts[index] === "p2p") {
+    const peerId = parts[index + 1];
+    if (!peerId || containsAsciiControlOrSpace3(peerId)) return false;
+    if (expectedPeerId !== void 0 && peerId !== expectedPeerId) return false;
+    index += 2;
+  }
+  return index === parts.length;
+}
+function parsePort(value) {
+  if (value === void 0 || !/^\d{1,5}$/u.test(value)) return void 0;
+  const port = Number(value);
+  return port >= 1 && port <= 65535 ? port : void 0;
+}
+function containsAsciiControlOrSpace3(value) {
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code <= 32 || code === 127) return true;
+  }
+  return false;
 }
 function isPublicIpv4(host) {
   const octets = host.split(".").map((part) => Number(part));
@@ -7183,7 +7307,17 @@ function isPlausiblePublicDnsHost(host) {
   const normalized = host.endsWith(".") ? host.slice(0, -1) : host;
   if (isIpv4Syntax(normalized)) return isPublicIpv4(normalized);
   if (normalized.includes(":")) return isPublicIpv6(normalized);
-  if (normalized === "localhost" || normalized.endsWith(".localhost") || normalized.endsWith(".local") || normalized.endsWith(".internal")) return false;
+  const specialUseSuffixes = [
+    "example",
+    "home.arpa",
+    "internal",
+    "invalid",
+    "local",
+    "localhost",
+    "onion",
+    "test"
+  ];
+  if (specialUseSuffixes.some((suffix) => normalized === suffix || normalized.endsWith(`.${suffix}`))) return false;
   const labels = normalized.split(".");
   return labels.length > 1 && labels.every(
     (label) => label.length > 0 && label.length <= 63 && /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/u.test(label)
@@ -8345,6 +8479,7 @@ function sameTrustedDevice2(left, right) {
   DEVICE_HEARTBEAT_DEFAULT_MAX_CLOCK_SKEW_MS,
   DEVICE_HEARTBEAT_LIMITS,
   DEVICE_HEARTBEAT_SIGNATURE_DOMAIN,
+  DEVICE_ORCHESTRATION_FRAME_LIMITS,
   DEVICE_ORCHESTRATION_PROTOCOL,
   DEVICE_PAIRING_INVITE_MAX_CLOCK_SKEW_MS,
   DEVICE_PAIRING_INVITE_PROTOCOL,