oysterun 1.5.7-beta.9 → 1.5.7

package/bin/oysterun.mjs

@@ -29,6 +29,11 @@ const serviceCommands = new Map([
   ["service:start", "start"],
   ["service:stop", "stop"],
   ["service:restart", "restart"],
+  ["service:update", "update"],
+  ["service:complete-update", "complete-update"],
+  ["service:repair", "repair"],
+  ["service:restore", "restore"],
+  ["service:lifecycle-status", "lifecycle-status"],
   ["service:status", "status"],
   ["service:logs", "logs"],
   ["service:uninstall", "uninstall"],
@@ -55,7 +60,21 @@ function runSetup(args = []) {
 }
 
 function runService(command, args = []) {
-  run(releaseServiceScript, [command, ...args]);
+  const result = spawnSync(releaseServiceScript, [command, ...args], {
+    cwd: repoRoot,
+    env: {
+      ...process.env,
+      OYSTERUN_BOOTSTRAP_NODE_BIN: process.execPath,
+    },
+    stdio: "inherit",
+  });
+  if (result.error) {
+    console.error(
+      `oysterun: failed to run ${releaseServiceScript}: ${result.error.message}`
+    );
+    process.exit(1);
+  }
+  process.exit(result.status ?? 0);
 }
 
 function parseUninstallArgs(args = []) {
@@ -181,6 +200,11 @@ Usage:
   oysterun service:start
   oysterun service:stop
   oysterun service:restart [--restore-sessions]
+  oysterun service:update --channel latest|beta
+  oysterun service:complete-update
+  oysterun service:repair
+  oysterun service:restore
+  oysterun service:lifecycle-status
   oysterun service:status
   oysterun service:logs [--follow]
   oysterun service:uninstall [--stack production|staging|all]

package/dev/client/connectivity/managed-host-browser.mjs

@@ -11,6 +11,7 @@ const REQUIRED_CHANNELS = Object.freeze(["control", "events", "bulk"]);
 const SUPPORTED_TRANSPORT_PROTOCOL_VERSIONS = Object.freeze([1]);
 const MANAGED_TRANSPORT_CONTRACT = "oysterun.managed_webrtc.v1";
 const SIGNALING_TIMEOUT_MS = 20_000;
+const MANAGED_ICE_CANDIDATE_SETTLE_MS = 100;
 const BOOTSTRAP_SAFE_REQUEST_TIMEOUT_MS = 12_000;
 const BOOTSTRAP_MATRIX_SYNC_TIMEOUT_MS = 45_000;
 const PRESENCE_WAIT_SECONDS = 55;
@@ -553,20 +554,161 @@ function fingerprintFromSdp(sdp) {
   return compact;
 }
 
-function waitForIceGatheringComplete(peer) {
-  if (peer.iceGatheringState === "complete") return Promise.resolve();
-  return withTimeout(
-    new Promise((resolve) => {
-      const handleChange = () => {
-        if (peer.iceGatheringState !== "complete") return;
-        peer.removeEventListener("icegatheringstatechange", handleChange);
-        resolve();
-      };
-      peer.addEventListener("icegatheringstatechange", handleChange);
-    }),
-    SIGNALING_TIMEOUT_MS,
-    "Browser ICE candidate gathering timed out"
-  );
+function managedWebRtcAttemptError(code, message) {
+  const error = new Error(message);
+  error.code = code;
+  return error;
+}
+
+function signalingCandidateToJson(candidate) {
+  if (
+    !candidate ||
+    typeof candidate.candidate !== "string" ||
+    !candidate.candidate.trim()
+  ) {
+    return null;
+  }
+  return candidateToJson(candidate);
+}
+
+function createManagedIceCandidateReadiness(
+  peer,
+  {
+    assertCurrentAttempt,
+    settleMs = MANAGED_ICE_CANDIDATE_SETTLE_MS,
+    timeoutMs = SIGNALING_TIMEOUT_MS,
+  } = {}
+) {
+  if (typeof assertCurrentAttempt !== "function") {
+    throw new Error("Managed ICE readiness requires an attempt owner");
+  }
+  const candidates = [];
+  const readiness = deferred();
+  let waitStarted = false;
+  let settled = false;
+  let settleTimer = null;
+  let timeoutTimer = null;
+
+  // A candidate or peer-close callback can reject between setLocalDescription
+  // and wait(). Keep that attempt-owned rejection observed until the caller
+  // reaches the browser_ice_gathering stage.
+  void readiness.promise.catch(() => {});
+
+  const cleanup = () => {
+    if (settleTimer !== null) {
+      clearTimeout(settleTimer);
+      settleTimer = null;
+    }
+    if (timeoutTimer !== null) {
+      clearTimeout(timeoutTimer);
+      timeoutTimer = null;
+    }
+    peer.removeEventListener("icecandidate", handleCandidate);
+    peer.removeEventListener("icegatheringstatechange", handleGatheringChange);
+    peer.removeEventListener("connectionstatechange", handleConnectionChange);
+  };
+  const reject = (error) => {
+    if (settled) return false;
+    settled = true;
+    cleanup();
+    readiness.reject(error);
+    return true;
+  };
+  const resolve = () => {
+    if (settled) return false;
+    try {
+      assertCurrentAttempt(peer);
+    } catch (error) {
+      return reject(error);
+    }
+    if (candidates.length === 0) return false;
+    settled = true;
+    cleanup();
+    readiness.resolve(candidates);
+    return true;
+  };
+  const startSettle = () => {
+    if (settled || settleTimer !== null) return;
+    settleTimer = setTimeout(resolve, settleMs);
+  };
+  function handleCandidate(event) {
+    if (settled) return;
+    try {
+      assertCurrentAttempt(peer);
+    } catch (error) {
+      reject(error);
+      return;
+    }
+    const candidate = signalingCandidateToJson(event.candidate);
+    if (!candidate) return;
+    candidates.push(candidate);
+    if (peer.iceGatheringState === "complete") {
+      resolve();
+      return;
+    }
+    startSettle();
+  }
+  function handleGatheringChange() {
+    if (settled || peer.iceGatheringState !== "complete") return;
+    resolve();
+  }
+  function handleConnectionChange() {
+    if (settled || peer.connectionState !== "closed") return;
+    reject(
+      managedWebRtcAttemptError(
+        "managed_webrtc_attempt_cancelled",
+        "Managed WebRTC connect attempt was cancelled"
+      )
+    );
+  }
+
+  peer.addEventListener("icecandidate", handleCandidate);
+  peer.addEventListener("icegatheringstatechange", handleGatheringChange);
+  peer.addEventListener("connectionstatechange", handleConnectionChange);
+
+  return {
+    peer,
+    candidates,
+    wait() {
+      if (!waitStarted) {
+        waitStarted = true;
+        try {
+          assertCurrentAttempt(peer);
+        } catch (error) {
+          reject(error);
+          return readiness.promise;
+        }
+        if (peer.iceGatheringState === "complete" && candidates.length > 0) {
+          resolve();
+        } else if (!settled) {
+          timeoutTimer = setTimeout(
+            () =>
+              reject(
+                new Error("Browser ICE candidate gathering timed out")
+              ),
+            timeoutMs
+          );
+        }
+      }
+      return readiness.promise;
+    },
+    cancel(error) {
+      reject(
+        error ||
+          managedWebRtcAttemptError(
+            "managed_webrtc_attempt_cancelled",
+            "Managed WebRTC connect attempt was cancelled"
+          )
+      );
+    },
+    dispose() {
+      if (!settled) {
+        this.cancel();
+      } else {
+        cleanup();
+      }
+    },
+  };
 }
 
 function waitForPeerReady(peer, channels) {
@@ -971,6 +1113,7 @@ export class ManagedHostBrowserConnection {
     });
     this.peer = null;
     this.connectingPeer = null;
+    this.pendingIceCandidateReadiness = null;
     this.webRtcTransport = null;
     this.activeConnection = null;
     this.iceTransportPolicy = "all";
@@ -1310,6 +1453,15 @@ export class ManagedHostBrowserConnection {
     reconciliationEpoch = this.reconciliationOwner.status().epoch,
     lifecycleReason = "initial_start",
   } = {}) {
+    if (this.pendingIceCandidateReadiness) {
+      this.pendingIceCandidateReadiness.cancel(
+        managedWebRtcAttemptError(
+          "managed_webrtc_stale_connect_attempt",
+          "Managed WebRTC connect attempt was replaced"
+        )
+      );
+      this.pendingIceCandidateReadiness = null;
+    }
     const connectionGeneration = ++this.connectionGeneration;
     const connectionAttemptId = createConnectivityRandomId();
     const attempt = {
@@ -1364,6 +1516,7 @@ export class ManagedHostBrowserConnection {
       iceTransportPolicy,
     });
     this.connectingPeer = peer;
+    let iceCandidateReadiness = null;
     try {
       const channels = Object.fromEntries(
         REQUIRED_CHANNELS.map((name) => [
@@ -1374,19 +1527,20 @@ export class ManagedHostBrowserConnection {
       for (const channel of Object.values(channels)) {
         channel.binaryType = "arraybuffer";
       }
-      const localCandidates = [];
-      peer.addEventListener("icecandidate", (event) => {
-        if (event.candidate) {
-          localCandidates.push(candidateToJson(event.candidate));
-        }
+      iceCandidateReadiness = createManagedIceCandidateReadiness(peer, {
+        assertCurrentAttempt,
       });
+      this.pendingIceCandidateReadiness = iceCandidateReadiness;
       await this.runConnectionStage("browser_offer", attempt, async () => {
         const offer = await peer.createOffer();
         await peer.setLocalDescription(offer);
       });
       await this.runConnectionStage("browser_ice_gathering", attempt, () =>
-        waitForIceGatheringComplete(peer)
+        iceCandidateReadiness.wait()
       );
+      if (this.pendingIceCandidateReadiness === iceCandidateReadiness) {
+        this.pendingIceCandidateReadiness = null;
+      }
       assertCurrentAttempt(peer);
       const localDescription = peer.localDescription;
       if (!localDescription) {
@@ -1415,6 +1569,7 @@ export class ManagedHostBrowserConnection {
                 client_authority_kind: "host_owner_browser",
               }
       );
+      assertCurrentAttempt(peer);
       if (
         !ticket ||
         typeof ticket.credential !== "string" ||
@@ -1439,7 +1594,7 @@ export class ManagedHostBrowserConnection {
               type: localDescription.type,
               sdp: localDescription.sdp,
             },
-            candidates: localCandidates,
+            candidates: iceCandidateReadiness.candidates,
           })
       );
       assertCurrentAttempt(peer);
@@ -1517,6 +1672,11 @@ export class ManagedHostBrowserConnection {
       if (this.connectingPeer === peer) this.connectingPeer = null;
       peer.close();
       throw error;
+    } finally {
+      if (this.pendingIceCandidateReadiness === iceCandidateReadiness) {
+        this.pendingIceCandidateReadiness = null;
+      }
+      iceCandidateReadiness?.dispose();
     }
   }
 
@@ -1650,6 +1810,15 @@ export class ManagedHostBrowserConnection {
     this.connectionGeneration += 1;
     const connectingPeer = this.connectingPeer;
     this.connectingPeer = null;
+    if (this.pendingIceCandidateReadiness?.peer === connectingPeer) {
+      this.pendingIceCandidateReadiness.cancel(
+        managedWebRtcAttemptError(
+          "managed_webrtc_stale_connect_attempt",
+          "Managed WebRTC connect attempt was replaced"
+        )
+      );
+      this.pendingIceCandidateReadiness = null;
+    }
     connectingPeer?.close();
     const peer = this.peer;
     const connection = this.activeConnection;