oysterun 1.6.0-beta.2 → 1.6.0-beta.20

package/bin/oysterun.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-import { existsSync, readFileSync, rmSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { spawnSync } from "node:child_process";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -13,9 +13,12 @@ import {
   runProductCli,
 } from "../host-service/cli/product-cli.mjs";
 
+import { preflightCompleteUninstall, executeCompleteUninstall } from "../host-service/complete-cli-uninstall.mjs";
+
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const repoRoot = resolve(__dirname, "..");
 const setupScript = join(repoRoot, "host-service", "setup.mjs");
+const onboardScript = join(repoRoot, "host-service", "onboard.mjs");
 const releaseServiceScript = join(
   repoRoot,
   "tool_scripts",
@@ -39,11 +42,11 @@ const serviceCommands = new Map([
   ["service:uninstall", "uninstall"],
 ]);
 
-function run(command, args) {
+function run(command, args, { setupInput = false } = {}) {
   const result = spawnSync(command, args, {
     cwd: repoRoot,
     env: process.env,
-    stdio: "inherit",
+    stdio: setupInput && process.env.OYSTERUN_SETUP_INPUT_FD !== undefined ? ["inherit", "inherit", "inherit", 3, 4] : "inherit",
   });
   if (result.error) {
     console.error(`oysterun: failed to run ${command}: ${result.error.message}`);
@@ -96,13 +99,16 @@ function parseUninstallArgs(args = []) {
       options.keepConfig = true;
     } else if (arg === "--confirm") {
       const value = args[index + 1];
-      if (!value) {
+      if (!value || value.startsWith("--")) {
         throw new Error("--confirm requires a value");
       }
+      if (value !== "DELETE") throw new Error("config deletion requires --confirm DELETE exactly");
       options.confirm = value;
       index += 1;
     } else if (arg.startsWith("--confirm=")) {
-      options.confirm = arg.slice("--confirm=".length);
+      const value = arg.slice("--confirm=".length);
+      if (value !== "DELETE") throw new Error("config deletion requires --confirm DELETE exactly");
+      options.confirm = value;
     } else if (arg === "--stack") {
       const value = args[index + 1];
       if (!value) {
@@ -195,6 +201,7 @@ Usage:
   oysterun
   oysterun --version
   oysterun setup [options]
+  oysterun onboard [--package-changed] [--channel latest|beta]
   oysterun show-qr
   oysterun uninstall [--confirm DELETE] [--keep-config] [--dry-run]
   oysterun service:start
@@ -213,6 +220,20 @@ Usage:
 Product modules:
   auth, sessions, chat, scheduler, mail, notifications, website, telegram
 
+Chat transcript reads:
+  chat recent|messages|messages-around|search [--session-id <exact_id>]
+  A verified live Agent can read its Agent's stopped/history target without
+  starting it. History names are unsupported; use an exact retained Session ID.
+  chat messages --session-id <history_id> [--limit 20] [--next-batch <opaque>]
+  History page limits are 1..100; live messages retain --after-seq.
+  History read authority does not authorize send, loop, profile or lifecycle.
+
+Session tags:
+  sessions start|resume|branch-resume [--tags 'first,second' | --clear-tags]
+  sessions profile update [--tags 'first,second' | --clear-tags]
+  --clear-tags creates or saves an untagged Session; empty --tags is invalid.
+  Omitted start tags inside a Session copy the authenticated parent's name.
+
 First run:
   If Host config is missing or incomplete, 'oysterun' enters setup.
   Release setup uses Oysterun Managed Tunnel by default.
@@ -236,8 +257,13 @@ Behavior:
   - Stops/removes managed Oysterun service state where available.
   - Preserves the config directory unless --confirm DELETE is supplied exactly.
   - Does not delete the Default Browse Root or agent folders.
-  - Does not remove the global npm package; run npm uninstall -g oysterun after
-    service/config cleanup if you want to remove the CLI itself.
+  - Exact --confirm DELETE also removes the same global CLI package that launched
+    this command using its matching Node/npm and explicit prefix.
+  - Without DELETE (including --keep-config), preserves config and CLI package.
+  - --keep-config and --confirm DELETE cannot be combined.
+  - --dry-run prints the selected services/config and exact CLI/npm/prefix plan.
+  - --stack all removes production and staging services, but only the selected
+    config directory and the launching CLI package.
 `);
 }
 
@@ -273,6 +299,31 @@ function runUninstall(args = []) {
   const configDir = dirname(configPath);
   const defaultBrowsePath = readConfiguredDefaultBrowsePath();
   const deleteConfig = options.confirm === "DELETE";
+  if (deleteConfig) {
+    try {
+      const plan = preflightCompleteUninstall({
+        cliPath: fileURLToPath(import.meta.url), configDir,
+        stack: options.stack || process.env.OYSTERUN_RELEASE_STACK || "production",
+      });
+      console.log("Oysterun complete uninstall plan:");
+      console.log(`  Services: ${plan.services.map(t => `${t.name} (${t.label}, port ${t.port || "unconfigured"})`).join(", ")}`);
+      console.log(`  Config directory: delete ${plan.config}`);
+      console.log(`  CLI package: remove ${plan.root}`);
+      console.log(`  npm: ${plan.identity.node_path} ${plan.identity.npm_cli_path} uninstall ${plan.npmArgs.join(" ")} oysterun`);
+      console.log(`  Prefix: ${plan.prefix}; OS user: ${plan.user.name} (uid ${plan.user.uid})`);
+      console.log("  Default Browse Root and agent folders are never deleted by this command.");
+      if (options.dryRun) {
+        console.log("Dry run complete: no service, config or CLI changes were made.");
+        return;
+      }
+      process.exitCode = executeCompleteUninstall(plan).exitCode;
+    } catch (error) {
+      console.error(`oysterun uninstall preflight: ${error.message}`);
+      console.error("No service, config or CLI changes were made.");
+      process.exitCode = 1;
+    }
+    return;
+  }
   const serviceArgs = ["uninstall"];
   if (options.stack) {
     serviceArgs.push("--stack", options.stack);
@@ -290,7 +341,7 @@ function runUninstall(args = []) {
       defaultBrowsePath ? ` ${defaultBrowsePath}` : ""
     }`
   );
-  console.log("  Global CLI package: preserve");
+  console.log(`  Global CLI package: preserve ${repoRoot} (npm/prefix removal not requested)`);
   console.log("");
 
   if (!deleteConfig) {
@@ -301,9 +352,7 @@ function runUninstall(args = []) {
   console.log(
     "Default Browse Root and agent folders are never deleted by this command; remove them manually only if intended."
   );
-  console.log(
-    "To remove the global CLI after cleanup, run: npm uninstall -g oysterun"
-  );
+  console.log("To remove service, config and this installed CLI together, run: oysterun uninstall --confirm DELETE");
 
   if (options.dryRun) {
     console.log("Dry run complete: no service or config changes were made.");
@@ -325,12 +374,7 @@ function runUninstall(args = []) {
     process.exit(result.status ?? 1);
   }
 
-  if (deleteConfig) {
-    rmSync(configDir, { recursive: true, force: true });
-    console.log(`Deleted config directory: ${configDir}`);
-  } else {
-    console.log(`Preserved config directory: ${configDir}`);
-  }
+  console.log(`Preserved config directory: ${configDir}`);
 }
 
 function printConfiguredStatus(status) {
@@ -382,6 +426,9 @@ switch (command) {
   case "setup":
     runSetup(rest);
     break;
+  case "onboard":
+    run(process.execPath, [onboardScript, ...rest], { setupInput: true });
+    break;
   case "show-qr":
     run(process.execPath, [setupScript, "--show-qr", ...rest]);
     break;

package/dev/client/connectivity/completed-message-neighbor-click.mjs

@@ -0,0 +1,78 @@
+// @ts-check
+
+/**
+ * Owns the lifetime of one completed-message navigation request at a time.
+ * Timeline movement is deliberately absent from this API: only click() reads.
+ *
+ * @template TResponse
+ * @param {{ readNeighbors: (request: { roomId: string, anchorEventId?: string, anchorPosition?: "latest" }) => Promise<TResponse>, selectTarget: (response: TResponse, direction: "previous" | "next") => string | undefined }} options
+ */
+export function createCompletedMessageNeighborClickCoordinator(options) {
+  /** @type {string | null} */
+  let scope = null;
+  let generation = 0;
+  /** @type {{ generation: number, scope: string } | null} */
+  let active = null;
+  let disposed = false;
+
+  /** @param {string} nextScope */
+  function setScope(nextScope) {
+    if (scope === nextScope) return;
+    scope = nextScope;
+    generation += 1;
+    active = null;
+  }
+
+  return {
+    setScope,
+    dispose() {
+      disposed = true;
+      generation += 1;
+      active = null;
+    },
+    isLoading() {
+      return active !== null;
+    },
+    /**
+     * @param {{ scope: string, roomId: string, direction: "previous" | "next", anchorEventId?: string, anchorPosition?: "latest" }} request
+     */
+    async click(request) {
+      if (disposed || request.scope !== scope) return { status: "stale" };
+      if (active !== null) return { status: "busy" };
+
+      const transaction = { generation, scope: request.scope };
+      active = transaction;
+      try {
+        const response = await options.readNeighbors({
+          roomId: request.roomId,
+          anchorEventId: request.anchorEventId,
+          anchorPosition: request.anchorPosition,
+        });
+        if (
+          disposed ||
+          active !== transaction ||
+          generation !== transaction.generation ||
+          scope !== transaction.scope
+        ) {
+          return { status: "stale" };
+        }
+        const targetEventId = options.selectTarget(response, request.direction);
+        return targetEventId
+          ? { status: "target", response, targetEventId }
+          : { status: "no_target", response };
+      } catch (error) {
+        if (
+          disposed ||
+          active !== transaction ||
+          generation !== transaction.generation ||
+          scope !== transaction.scope
+        ) {
+          return { status: "stale" };
+        }
+        return { status: "error", error };
+      } finally {
+        if (active === transaction) active = null;
+      }
+    },
+  };
+}

package/dev/client/connectivity/completed-message-neighbor-contract.mjs

@@ -0,0 +1,205 @@
+// @ts-check
+
+export const COMPLETED_MESSAGE_NEIGHBOR_SCHEMA_VERSION =
+  "routec.p206_completed_turn_final_message_neighbors.v1";
+
+/** @typedef {{ event_id: string, routec_stream_seq: number, origin_server_ts: number | null, provider_turn_id: string }} CompletedMessageNeighborEvent */
+/** @typedef {{ anchor_position: "event", event_id: string, routec_stream_seq: number } | { anchor_position: "latest", event_id: null, routec_stream_seq: number | null }} CompletedMessageNeighborAnchor */
+/** @typedef {{ schema_version: typeof COMPLETED_MESSAGE_NEIGHBOR_SCHEMA_VERSION, lookup_source: string, lookup_strategy: string, order_by: "final_candidate_stream_seq", candidate_predicate: "complete_message_notification_candidate", completion_predicate: "complete_message_notification_completion", navigation_index_version: number | null, navigation_index_names: string[], raw_event_scan_limit: null, raw_event_payload_returned: false, message_body_returned: false }} CompletedMessageNeighborProof */
+/** @typedef {{ status: "ok", session_id: string, matrix_room_id: string, anchor: CompletedMessageNeighborAnchor, previous: CompletedMessageNeighborEvent | null, next: CompletedMessageNeighborEvent | null, boundaries: { no_completed_turns: boolean, at_first_completed_message: boolean, at_latest_completed_message: boolean }, proof: CompletedMessageNeighborProof, committed_transcript_truth?: "matrix_room_timeline", routec_completed_message_neighbor_endpoint?: true, completed_message_truth_source?: "complete_message_notification_candidate_and_completion_predicates", raw_event_payload_returned: false, message_body_returned: false }} CompletedMessageNeighborsResponse */
+/** @typedef {{ sessionId?: string, matrixRoomId?: string, anchorEventId?: string | null, anchorPosition?: "latest" | null }} CompletedMessageNeighborExpectedIdentity */
+
+/**
+ * @param {unknown} value
+ * @returns {value is Record<string, unknown>}
+ */
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+/**
+ * @param {unknown} value
+ * @returns {value is string}
+ */
+function nonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+
+/**
+ * @param {unknown} value
+ * @returns {value is number}
+ */
+function isNonnegativeSafeInteger(value) {
+  return Number.isSafeInteger(value) && Number(value) >= 0;
+}
+
+/**
+ * @param {unknown} value
+ * @returns {value is CompletedMessageNeighborEvent}
+ */
+function isNeighbor(value) {
+  return (
+    isRecord(value) &&
+    nonEmptyString(value.event_id) &&
+    isNonnegativeSafeInteger(value.routec_stream_seq) &&
+    (typeof value.origin_server_ts === "number" ||
+      value.origin_server_ts === null) &&
+    nonEmptyString(value.provider_turn_id)
+  );
+}
+
+/**
+ * @param {CompletedMessageNeighborsResponse} value
+ * @param {CompletedMessageNeighborExpectedIdentity} expected
+ */
+function assertRequestIdentity(value, expected) {
+  if (expected.sessionId && value.session_id !== expected.sessionId) {
+    throw new Error("Completed-message neighbor Session identity mismatch.");
+  }
+  if (expected.matrixRoomId && value.matrix_room_id !== expected.matrixRoomId) {
+    throw new Error("Completed-message neighbor room identity mismatch.");
+  }
+  if (expected.anchorEventId) {
+    if (
+      value.anchor.anchor_position !== "event" ||
+      value.anchor.event_id !== expected.anchorEventId
+    ) {
+      throw new Error("Completed-message neighbor anchor identity mismatch.");
+    }
+  } else if (expected.anchorPosition === "latest") {
+    if (
+      value.anchor.anchor_position !== "latest" ||
+      value.anchor.event_id !== null
+    ) {
+      throw new Error("Completed-message neighbor latest anchor mismatch.");
+    }
+  }
+}
+
+/**
+ * @param {unknown} value
+ * @param {CompletedMessageNeighborExpectedIdentity} [expected]
+ * @returns {CompletedMessageNeighborsResponse}
+ */
+export function assertCompletedMessageNeighborsResponse(value, expected = {}) {
+  if (!isRecord(value)) {
+    throw new Error("Completed-message neighbor response must be an object.");
+  }
+  const anchor = value.anchor;
+  const boundaries = value.boundaries;
+  const proof = value.proof;
+  const validAnchor =
+    isRecord(anchor) &&
+    (anchor.anchor_position === "event" ||
+      anchor.anchor_position === "latest") &&
+    (typeof anchor.event_id === "string" || anchor.event_id === null) &&
+    (isNonnegativeSafeInteger(anchor.routec_stream_seq) ||
+      anchor.routec_stream_seq === null) &&
+    (anchor.anchor_position === "event"
+      ? nonEmptyString(anchor.event_id) &&
+        isNonnegativeSafeInteger(anchor.routec_stream_seq)
+      : anchor.event_id === null);
+  const indexNames = isRecord(proof) ? proof.navigation_index_names : null;
+  const indexVersion = isRecord(proof)
+    ? proof.navigation_index_version
+    : undefined;
+  const validIndexDiagnostics =
+    Array.isArray(indexNames) &&
+    indexNames.every(nonEmptyString) &&
+    new Set(indexNames).size === indexNames.length &&
+    (Number.isSafeInteger(indexVersion) || indexVersion === null) &&
+    ((indexVersion === null && indexNames.length === 0) ||
+      (Number.isSafeInteger(indexVersion) && indexNames.length > 0));
+  const validProof =
+    isRecord(proof) &&
+    proof.schema_version === COMPLETED_MESSAGE_NEIGHBOR_SCHEMA_VERSION &&
+    nonEmptyString(proof.lookup_source) &&
+    nonEmptyString(proof.lookup_strategy) &&
+    proof.order_by === "final_candidate_stream_seq" &&
+    proof.candidate_predicate === "complete_message_notification_candidate" &&
+    proof.completion_predicate === "complete_message_notification_completion" &&
+    validIndexDiagnostics &&
+    proof.raw_event_scan_limit === null &&
+    proof.raw_event_payload_returned === false &&
+    proof.message_body_returned === false;
+  if (
+    value.status !== "ok" ||
+    !nonEmptyString(value.session_id) ||
+    !nonEmptyString(value.matrix_room_id) ||
+    !validAnchor ||
+    !(value.previous === null || isNeighbor(value.previous)) ||
+    !(value.next === null || isNeighbor(value.next)) ||
+    !isRecord(boundaries) ||
+    typeof boundaries.no_completed_turns !== "boolean" ||
+    typeof boundaries.at_first_completed_message !== "boolean" ||
+    typeof boundaries.at_latest_completed_message !== "boolean" ||
+    !validProof ||
+    !(
+      value.committed_transcript_truth === undefined ||
+      value.committed_transcript_truth === "matrix_room_timeline"
+    ) ||
+    !(
+      value.routec_completed_message_neighbor_endpoint === undefined ||
+      value.routec_completed_message_neighbor_endpoint === true
+    ) ||
+    !(
+      value.completed_message_truth_source === undefined ||
+      value.completed_message_truth_source ===
+        "complete_message_notification_candidate_and_completion_predicates"
+    ) ||
+    value.raw_event_payload_returned !== false ||
+    value.message_body_returned !== false
+  ) {
+    throw new Error("Completed-message neighbor response failed validation.");
+  }
+  const validated = /** @type {CompletedMessageNeighborsResponse} */ (value);
+  if (
+    validated.boundaries.at_first_completed_message !==
+      (validated.previous === null) ||
+    validated.boundaries.at_latest_completed_message !==
+      (validated.next === null) ||
+    (boundaries.no_completed_turns &&
+      (validated.previous !== null ||
+        validated.next !== null ||
+        !boundaries.at_first_completed_message ||
+        !boundaries.at_latest_completed_message))
+  ) {
+    throw new Error("Completed-message neighbor boundaries are inconsistent.");
+  }
+  if (validated.anchor.anchor_position === "event") {
+    if (
+      (validated.previous &&
+        validated.previous.routec_stream_seq >=
+          validated.anchor.routec_stream_seq) ||
+      (validated.next &&
+        validated.next.routec_stream_seq <= validated.anchor.routec_stream_seq)
+    ) {
+      throw new Error("Completed-message neighbor ordering is inconsistent.");
+    }
+  }
+  assertRequestIdentity(validated, expected);
+  return validated;
+}
+
+/**
+ * @param {Omit<CompletedMessageNeighborsResponse, "status" | "raw_event_payload_returned" | "message_body_returned">} input
+ * @returns {CompletedMessageNeighborsResponse}
+ */
+export function buildCompletedMessageNeighborsResponse(input) {
+  return assertCompletedMessageNeighborsResponse(
+    {
+      status: "ok",
+      ...input,
+      raw_event_payload_returned: false,
+      message_body_returned: false,
+    },
+    {
+      sessionId: input.session_id,
+      matrixRoomId: input.matrix_room_id,
+      anchorEventId:
+        input.anchor.anchor_position === "event" ? input.anchor.event_id : null,
+      anchorPosition:
+        input.anchor.anchor_position === "latest" ? "latest" : null,
+    }
+  );
+}

package/dev/client/connectivity/completed-message-visibility.d.mts

@@ -19,12 +19,12 @@ export function evaluateCompletedMessageVisibilityAcknowledgement(input: {
   currentMatrixRoomId?: string;
   targetMatrixRoomId?: string;
   latestCompletedEventId?: string | null;
-  renderedEventId?: string | null;
+  latestTimelineLoaded?: boolean;
   hasUnreadCompletedMessage?: boolean;
   documentVisibilityState?: string;
   documentHasFocus?: boolean;
-  elementConnected?: boolean;
-  elementHidden?: boolean;
-  elementRect?: VisibilityRect | DOMRect;
+  visibleMessageConnected?: boolean;
+  visibleMessageHidden?: boolean;
+  visibleMessageRect?: VisibilityRect | DOMRect;
   viewportRect?: VisibilityRect | DOMRect;
 }): { qualified: boolean; reason: string };

package/dev/client/connectivity/completed-message-visibility.mjs

@@ -30,13 +30,13 @@ export function evaluateCompletedMessageVisibilityAcknowledgement({
   currentMatrixRoomId,
   targetMatrixRoomId,
   latestCompletedEventId,
-  renderedEventId,
+  latestTimelineLoaded,
   hasUnreadCompletedMessage,
   documentVisibilityState,
   documentHasFocus,
-  elementConnected,
-  elementHidden,
-  elementRect,
+  visibleMessageConnected,
+  visibleMessageHidden,
+  visibleMessageRect,
   viewportRect,
 }) {
   if (routeCChatShell !== true)
@@ -49,19 +49,22 @@ export function evaluateCompletedMessageVisibilityAcknowledgement({
   }
   if (hasUnreadCompletedMessage !== true)
     return { qualified: false, reason: "not_unread" };
-  if (!latestCompletedEventId || latestCompletedEventId !== renderedEventId) {
-    return { qualified: false, reason: "stale_or_unrendered_event" };
+  if (!latestCompletedEventId || latestTimelineLoaded !== true) {
+    return { qualified: false, reason: "latest_timeline_not_ready" };
   }
   if (documentVisibilityState !== "visible") {
     return { qualified: false, reason: "hidden_document" };
   }
   if (documentHasFocus !== true)
     return { qualified: false, reason: "unfocused_document" };
-  if (elementConnected !== true || elementHidden === true) {
-    return { qualified: false, reason: "event_not_materially_rendered" };
+  if (visibleMessageConnected !== true || visibleMessageHidden === true) {
+    return { qualified: false, reason: "no_visible_materialized_message" };
   }
-  if (!isCompletedMessageViewportVisible({ elementRect, viewportRect })) {
-    return { qualified: false, reason: "event_outside_viewport" };
+  if (!isCompletedMessageViewportVisible({
+    elementRect: visibleMessageRect,
+    viewportRect,
+  })) {
+    return { qualified: false, reason: "no_visible_materialized_message" };
   }
-  return { qualified: true, reason: "visible_latest_successful_final" };
+  return { qualified: true, reason: "visible_focused_latest_timeline" };
 }

package/dev/client/connectivity/desktop-chat-sidebar-preference.mjs

@@ -0,0 +1,57 @@
+export const DESKTOP_CHAT_SIDEBAR_PREFERENCE_KEY =
+  "oysterun.desktop_chat_sidebar_expanded.v1";
+
+const readStorage = (windowTarget) => {
+  try {
+    return windowTarget?.localStorage;
+  } catch {
+    return undefined;
+  }
+};
+
+export function readDesktopChatSidebarPreference(windowTarget = globalThis) {
+  try {
+    const stored = readStorage(windowTarget)?.getItem(
+      DESKTOP_CHAT_SIDEBAR_PREFERENCE_KEY
+    );
+    if (stored === "false") return false;
+    if (stored === "true") return true;
+  } catch {
+    // Browser privacy modes may expose localStorage while rejecting reads.
+  }
+  return true;
+}
+
+export function writeDesktopChatSidebarPreference(
+  expanded,
+  windowTarget = globalThis
+) {
+  try {
+    const storage = readStorage(windowTarget);
+    if (typeof storage?.setItem !== "function") return false;
+    storage.setItem(
+      DESKTOP_CHAT_SIDEBAR_PREFERENCE_KEY,
+      expanded === true ? "true" : "false"
+    );
+    return true;
+  } catch {
+    // Preference persistence must never make Chat unavailable.
+    return false;
+  }
+}
+
+export function subscribeDesktopChatSidebarPreference(
+  listener,
+  windowTarget = globalThis
+) {
+  if (typeof listener !== "function") {
+    throw new TypeError("Desktop Chat sidebar preference listener is required");
+  }
+  if (typeof windowTarget?.addEventListener !== "function") return () => {};
+  const onStorage = (event) => {
+    if (event?.key !== DESKTOP_CHAT_SIDEBAR_PREFERENCE_KEY) return;
+    listener(readDesktopChatSidebarPreference(windowTarget));
+  };
+  windowTarget.addEventListener("storage", onStorage);
+  return () => windowTarget.removeEventListener("storage", onStorage);
+}

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

@@ -2671,6 +2671,16 @@ export function startManagedHostConnection() {
   return getManagedHostBrowserConnection().start();
 }
 
+// A WebRTC connection is authenticated with the dashboard token used to open
+// it. Keep the Host's connection-bound authorization policy: a new login must
+// retire that connection rather than send a new bearer through the old peer.
+export async function refreshManagedHostAuthentication() {
+  const connection = getManagedHostBrowserConnection();
+  if (connection instanceof ManagedHostBrowserConnection) {
+    await connection.restartWebRtc("dashboard_login", { initiator: "browser" });
+  }
+}
+
 export function managedHostFetch(input, init) {
   return getManagedHostBrowserConnection().fetch(input, init);
 }