oysterun 1.5.7-beta.2 → 1.5.7-beta.3

package/README.md

@@ -248,8 +248,9 @@ npm start
 Useful commands:
 
 ```bash
-npm run setup   # first-run direct Host setup
-npm run setup -- --enable-cloud  # optional Cloud registration
+npm run setup   # first-run Managed Tunnel Host setup
+node host-service/setup.mjs   # source-local Direct Host setup
+node bin/oysterun.mjs setup --local   # explicit local-only Direct setup
 npm start       # plain start, no watch mode
 npm run dev     # watch mode for Host JS files
 npm run cli     # local CLI client
@@ -272,7 +273,8 @@ Port notes:
 - direct mode can also store an optional `public_base_url` there for manual client connection
 - fresh Session Setup runtime defaults, including interface style plus Claude/Codex provider defaults, are stored there under `session_defaults`
 - Host Preferences shows the active config path, so `OYSTERUN_CONFIG_DIR` overrides are visible in the UI
-- Host now defaults to direct Host mode unless Cloud registration is explicitly enabled
+- release setup defaults to Oysterun Managed Tunnel
+- source-local setup and `oysterun setup --local` retain explicit Direct mode
 
 ### Optional: start backend + Host together for repo development
 

package/bin/oysterun.mjs

@@ -191,6 +191,9 @@ Product modules:
 
 First run:
   If Host config is missing or incomplete, 'oysterun' enters setup.
+  Release setup uses Oysterun Managed Tunnel by default.
+  Use 'oysterun setup --local' for local-only Direct Host setup.
+  Use '--enable-cloud-direct' only for advanced Direct Cloud registration.
 
 Install contract:
   npm install -g oysterun installs files only. It does not run setup or start

package/dev/client/connectivity/data-channel-adapter.mjs

@@ -0,0 +1,146 @@
+function toUint8Array(value) {
+  if (value instanceof Uint8Array) return value;
+  if (value instanceof ArrayBuffer) return new Uint8Array(value);
+  if (globalThis.Buffer?.isBuffer(value)) {
+    return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+  }
+  throw new Error("DataChannel message must be binary");
+}
+
+export function adaptBrowserDataChannel(channel) {
+  const messageListeners = new Set();
+  const openListeners = new Set();
+  const bufferedLowListeners = new Set();
+  const closeListeners = new Set();
+  const errorListeners = new Set();
+  channel.binaryType = "arraybuffer";
+
+  channel.addEventListener("message", (event) => {
+    try {
+      const bytes = toUint8Array(event.data);
+      for (const listener of messageListeners) listener(bytes);
+    } catch (error) {
+      for (const listener of errorListeners) listener(error);
+    }
+  });
+  channel.addEventListener("open", () => {
+    for (const listener of openListeners) listener();
+  });
+  channel.addEventListener("bufferedamountlow", () => {
+    for (const listener of bufferedLowListeners) listener();
+  });
+  channel.addEventListener("close", () => {
+    for (const listener of closeListeners) listener();
+  });
+  channel.addEventListener("error", (event) => {
+    const error = new Error(event?.error?.message || "Browser DataChannel error");
+    for (const listener of errorListeners) listener(error);
+  });
+
+  return {
+    label: channel.label,
+    isOpen: () => channel.readyState === "open",
+    bufferedAmount: () => channel.bufferedAmount,
+    setBufferedAmountLowThreshold(bytes) {
+      channel.bufferedAmountLowThreshold = bytes;
+    },
+    sendBinary(bytes) {
+      channel.send(bytes);
+      return { buffered: channel.bufferedAmount > 0 };
+    },
+    onMessage(listener) {
+      messageListeners.add(listener);
+      return () => messageListeners.delete(listener);
+    },
+    onOpen(listener) {
+      openListeners.add(listener);
+      return () => openListeners.delete(listener);
+    },
+    onBufferedAmountLow(listener) {
+      bufferedLowListeners.add(listener);
+      return () => bufferedLowListeners.delete(listener);
+    },
+    onClose(listener) {
+      closeListeners.add(listener);
+      return () => closeListeners.delete(listener);
+    },
+    onError(listener) {
+      errorListeners.add(listener);
+      return () => errorListeners.delete(listener);
+    },
+    close() {
+      channel.close();
+    },
+  };
+}
+
+export function adaptNodeDataChannel(channel) {
+  const messageListeners = new Set();
+  const openListeners = new Set();
+  const bufferedLowListeners = new Set();
+  const closeListeners = new Set();
+  const errorListeners = new Set();
+
+  channel.onMessage((message) => {
+    if (typeof message === "string") {
+      for (const listener of errorListeners) {
+        listener(new Error("Oysterun transport rejects text DataChannel frames"));
+      }
+      return;
+    }
+    const bytes = toUint8Array(message);
+    for (const listener of messageListeners) listener(bytes);
+  });
+  channel.onOpen(() => {
+    for (const listener of openListeners) listener();
+  });
+  channel.onBufferedAmountLow(() => {
+    for (const listener of bufferedLowListeners) listener();
+  });
+  channel.onClosed(() => {
+    for (const listener of closeListeners) listener();
+  });
+  channel.onError((message) => {
+    const error = new Error(String(message));
+    for (const listener of errorListeners) listener(error);
+  });
+
+  return {
+    label: channel.getLabel(),
+    isOpen: () => channel.isOpen(),
+    bufferedAmount: () => channel.bufferedAmount(),
+    setBufferedAmountLowThreshold: (bytes) =>
+      channel.setBufferedAmountLowThreshold(bytes),
+    sendBinary(bytes) {
+      // False means the message was accepted into the native send buffer.
+      // Retrying on false duplicates the frame.
+      return {
+        buffered:
+          channel.sendMessageBinary(globalThis.Buffer.from(bytes)) === false,
+      };
+    },
+    onMessage(listener) {
+      messageListeners.add(listener);
+      return () => messageListeners.delete(listener);
+    },
+    onOpen(listener) {
+      openListeners.add(listener);
+      return () => openListeners.delete(listener);
+    },
+    onBufferedAmountLow(listener) {
+      bufferedLowListeners.add(listener);
+      return () => bufferedLowListeners.delete(listener);
+    },
+    onClose(listener) {
+      closeListeners.add(listener);
+      return () => closeListeners.delete(listener);
+    },
+    onError(listener) {
+      errorListeners.add(listener);
+      return () => errorListeners.delete(listener);
+    },
+    close() {
+      channel.close();
+    },
+  };
+}

package/dev/client/connectivity/host-connection-feedback.mjs

@@ -0,0 +1,193 @@
+export const HOST_CONNECTION_RECONNECT_WARNING_DELAY_MS = 1_500;
+export const HOST_CONNECTION_LOST_DELAY_MS = 30_000;
+export const PAGE_REFRESH_PENDING_RESET_MS = 1_500;
+
+function boundedString(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+export function normalizeHostConnectionStatus(status = {}) {
+  const originKind =
+    status.origin_kind === "managed_endpoint"
+      ? "managed_endpoint"
+      : "direct_host";
+  const activePathKind = boundedString(status.active_path_kind);
+  const unavailable =
+    status.closed === true ||
+    status.browser_online === false ||
+    status.managed_host_unavailable === true ||
+    status.last_request_failed === true ||
+    ["closed", "disconnected", "recovering", "unavailable"].includes(
+      status.connection_state
+    );
+  let qualifier = "Direct Host";
+  if (originKind === "managed_endpoint") {
+    qualifier =
+      activePathKind === "webrtc" ? "Managed WebRTC" : "Managed Endpoint";
+  }
+  return {
+    connected: !unavailable,
+    qualifier,
+    origin_kind: originKind,
+    active_path_kind: activePathKind || null,
+  };
+}
+
+export function connectionFeedbackPresentation({
+  signal,
+  disconnectedAt = null,
+  now = Date.now(),
+} = {}) {
+  if (!signal || signal.connected === true) {
+    return {
+      visible: true,
+      state: "connected",
+      label: "Connected",
+      qualifier: signal?.qualifier || "",
+    };
+  }
+  const elapsedMs = Math.max(0, now - (disconnectedAt ?? now));
+  if (elapsedMs < HOST_CONNECTION_RECONNECT_WARNING_DELAY_MS) {
+    return {
+      visible: false,
+      state: "transient",
+      label: "",
+      qualifier: signal.qualifier,
+    };
+  }
+  if (elapsedMs < HOST_CONNECTION_LOST_DELAY_MS) {
+    return {
+      visible: true,
+      state: "reconnecting",
+      label: "Reconnecting...",
+      qualifier: signal.qualifier,
+    };
+  }
+  return {
+    visible: true,
+    state: "lost",
+    label: "Connection Lost. Still retrying.",
+    qualifier: signal.qualifier,
+  };
+}
+
+function presentationKey(presentation) {
+  return JSON.stringify([
+    presentation.visible,
+    presentation.state,
+    presentation.label,
+    presentation.qualifier,
+  ]);
+}
+
+export function createHostConnectionFeedbackController({
+  onPresentation,
+  now = () => Date.now(),
+  setTimeoutImpl = globalThis.setTimeout.bind(globalThis),
+  clearTimeoutImpl = globalThis.clearTimeout.bind(globalThis),
+} = {}) {
+  if (typeof onPresentation !== "function") {
+    throw new Error("Host connection feedback listener is required");
+  }
+  let signal = null;
+  let disconnectedAt = null;
+  let warningTimer = null;
+  let lostTimer = null;
+  let lastPresentationKey = "";
+
+  const emit = () => {
+    const presentation = connectionFeedbackPresentation({
+      signal,
+      disconnectedAt,
+      now: now(),
+    });
+    const nextKey = presentationKey(presentation);
+    if (nextKey === lastPresentationKey) return;
+    lastPresentationKey = nextKey;
+    onPresentation(presentation);
+  };
+
+  const clearTimers = () => {
+    if (warningTimer !== null) clearTimeoutImpl(warningTimer);
+    if (lostTimer !== null) clearTimeoutImpl(lostTimer);
+    warningTimer = null;
+    lostTimer = null;
+  };
+
+  const scheduleThresholds = () => {
+    warningTimer = setTimeoutImpl(() => {
+      warningTimer = null;
+      emit();
+    }, HOST_CONNECTION_RECONNECT_WARNING_DELAY_MS);
+    lostTimer = setTimeoutImpl(() => {
+      lostTimer = null;
+      emit();
+    }, HOST_CONNECTION_LOST_DELAY_MS);
+  };
+
+  return {
+    handleStatus(status) {
+      const nextSignal = normalizeHostConnectionStatus(status);
+      const wasConnected = signal?.connected !== false;
+      signal = nextSignal;
+      if (nextSignal.connected) {
+        disconnectedAt = null;
+        clearTimers();
+        emit();
+        return;
+      }
+      if (wasConnected || disconnectedAt === null) {
+        disconnectedAt = now();
+        clearTimers();
+        scheduleThresholds();
+      }
+      emit();
+    },
+    render() {
+      emit();
+    },
+    close() {
+      clearTimers();
+    },
+  };
+}
+
+export function createPageRefreshController({
+  reload,
+  onPendingChange = () => {},
+  setTimeoutImpl = globalThis.setTimeout.bind(globalThis),
+  clearTimeoutImpl = globalThis.clearTimeout.bind(globalThis),
+  pendingResetMs = PAGE_REFRESH_PENDING_RESET_MS,
+} = {}) {
+  if (typeof reload !== "function") {
+    throw new Error("Page reload callback is required");
+  }
+  let pending = false;
+  let resetTimer = null;
+
+  const setPending = (nextPending) => {
+    pending = nextPending;
+    onPendingChange(pending);
+  };
+
+  return {
+    request() {
+      if (pending) return false;
+      setPending(true);
+      resetTimer = setTimeoutImpl(() => {
+        resetTimer = null;
+        setPending(false);
+      }, pendingResetMs);
+      reload();
+      return true;
+    },
+    isPending() {
+      return pending;
+    },
+    close() {
+      if (resetTimer !== null) clearTimeoutImpl(resetTimer);
+      resetTimer = null;
+      if (pending) setPending(false);
+    },
+  };
+}