@peers-app/peers-ui 0.27.3 → 0.27.5

package/src/app-updates/app-updates-settings.test.tsx

@@ -1,109 +0,0 @@
-import type { IAppUpdateStatus } from "@peers-app/peers-sdk";
-import { fireEvent, render, waitFor } from "@testing-library/react";
-import { AppUpdatesSettings } from "./app-updates-settings";
-
-let mockStatus: IAppUpdateStatus | undefined;
-const checkForUpdates = jest.fn();
-
-jest.mock("../components/tooltip", () => ({ Tooltip: () => null }));
-jest.mock("./use-app-update-status", () => ({ useAppUpdateStatus: () => mockStatus }));
-jest.mock("./app-updates-consumer", () => ({
-  ...jest.requireActual("./app-updates-consumer"),
-  getAppUpdatesConsumer: () =>
-    Promise.resolve({ tools: { checkForUpdates: () => checkForUpdates() } }),
-}));
-
-function status(overrides: Partial<IAppUpdateStatus> = {}): IAppUpdateStatus {
-  return {
-    supported: true,
-    canRestart: true,
-    platform: "darwin",
-    currentVersion: "1.0.0",
-    latestVersion: "1.0.0",
-    state: "up-to-date",
-    installOnRestart: true,
-    installOnQuitArmed: false,
-    remoteRestartAllowed: true,
-    ...overrides,
-  };
-}
-
-describe("AppUpdatesSettings", () => {
-  beforeEach(() => {
-    checkForUpdates.mockReset();
-    checkForUpdates.mockResolvedValue(status());
-  });
-
-  it("explains hosts that do not update themselves", () => {
-    mockStatus = status({ supported: false, canRestart: false });
-    const view = render(<AppUpdatesSettings />);
-    expect(view.container).toHaveTextContent("This device does not update itself");
-  });
-
-  it("shows versions, both settings, and checks on demand", async () => {
-    mockStatus = status();
-    const view = render(<AppUpdatesSettings />);
-    expect(view.container).toHaveTextContent("Installed version1.0.0");
-    expect(view.getByLabelText("Install updates automatically when Peers restarts")).toBeTruthy();
-    expect(
-      view.getByLabelText("Allow my other devices to update and restart this device"),
-    ).toBeTruthy();
-    expect(view.getByRole("button", { name: /^Restart$/ })).toBeTruthy();
-
-    fireEvent.click(view.getByRole("button", { name: "Check now" }));
-    await waitFor(() => expect(checkForUpdates).toHaveBeenCalledTimes(1));
-  });
-
-  it("adds no note when the user opts out of a downloaded update", () => {
-    mockStatus = status({
-      state: "downloaded",
-      latestVersion: "1.1.0",
-      downloadedVersion: "1.1.0",
-      installOnRestart: false,
-      installOnQuitArmed: false,
-    });
-    const view = render(<AppUpdatesSettings />);
-    expect(view.container).not.toHaveTextContent("will still install");
-    expect(view.getByRole("button", { name: /Update & restart/ })).toBeTruthy();
-  });
-
-  it("notes when macOS accepted an update for an earlier Update & restart", () => {
-    mockStatus = status({
-      state: "downloaded",
-      latestVersion: "1.1.0",
-      downloadedVersion: "1.1.0",
-      installOnRestart: false,
-      installOnQuitArmed: true,
-    });
-    const view = render(<AppUpdatesSettings />);
-    expect(view.container).toHaveTextContent(
-      "macOS prepared version 1.1.0 for an earlier Update & restart",
-    );
-    expect(view.getByRole("button", { name: /Update & restart/ })).toBeTruthy();
-  });
-
-  it("shows a failed check and lets the user retry", async () => {
-    mockStatus = status();
-    checkForUpdates.mockRejectedValueOnce(new Error("Host disconnected"));
-    const view = render(<AppUpdatesSettings />);
-    fireEvent.click(view.getByRole("button", { name: "Check now" }));
-    expect(await view.findByRole("alert")).toHaveTextContent("Host disconnected");
-    fireEvent.click(view.getByRole("button", { name: "Check now" }));
-    await waitFor(() => expect(checkForUpdates).toHaveBeenCalledTimes(2));
-    expect(view.queryByRole("alert")).toBeNull();
-  });
-
-  it("shows feed errors while a downloaded update remains ready to install", () => {
-    mockStatus = status({
-      state: "downloaded",
-      latestVersion: "1.1.0",
-      downloadedVersion: "1.1.0",
-      error: "Feed unreachable",
-    });
-    const view = render(<AppUpdatesSettings />);
-    expect(view.container).toHaveTextContent(
-      "Version 1.1.0 is ready to install. Update problem: Feed unreachable",
-    );
-    expect(view.getByRole("button", { name: /Update & restart/ })).toBeEnabled();
-  });
-});

package/src/app-updates/app-updates-settings.tsx

@@ -1,136 +0,0 @@
-import {
-  allowRemoteAppUpdateRestart,
-  type IAppUpdateStatus,
-  installAppUpdatesOnRestart,
-} from "@peers-app/peers-sdk";
-import { useState } from "react";
-import { Checkbox } from "../components/checkbox";
-import { Tooltip } from "../components/tooltip";
-import { UpdateAndRestartButton } from "./app-update-controls";
-import {
-  describeAppUpdateStatus,
-  getAppUpdatesConsumer,
-  hasAppUpdate,
-  isAppRestarting,
-} from "./app-updates-consumer";
-import { useAppUpdateStatus } from "./use-app-update-status";
-
-/**
- * macOS accepted the update for an Update & restart that timed out, and installs it when
- * Peers quits; that cannot be withdrawn.
- */
-function isPreparedDespiteOptOut(status: IAppUpdateStatus): boolean {
-  return status.platform === "darwin" && !status.installOnRestart && status.installOnQuitArmed;
-}
-
-function SettingCheckbox({
-  id,
-  label,
-  checked,
-  help,
-}: {
-  id: string;
-  label: string;
-  checked: typeof installAppUpdatesOnRestart;
-  help: string;
-}) {
-  return (
-    <div className="form-check mb-2">
-      <Checkbox id={id} className="form-check-input" checked={checked} />
-      <label htmlFor={id} className="form-check-label small me-1">
-        {label}
-      </label>
-      <Tooltip markdownContent={help} />
-    </div>
-  );
-}
-
-/**
- * Settings tab for this device's application updates: version, check and install controls,
- * and the two per-device update settings.
- */
-export function AppUpdatesSettings() {
-  const status = useAppUpdateStatus();
-  const [checking, setChecking] = useState(false);
-  const [checkError, setCheckError] = useState<string>();
-
-  if (!status) {
-    return <p className="small text-muted">Loading update status…</p>;
-  }
-  if (!status.canRestart) {
-    return (
-      <p className="small text-muted">
-        This device does not update itself. Browser installs update when the page reloads.
-      </p>
-    );
-  }
-  return (
-    <>
-      <h5 className="mb-3">Updates</h5>
-      <dl className="row small mb-2">
-        <dt className="col-4">Installed version</dt>
-        <dd className="col-8">{status.currentVersion}</dd>
-        {status.latestVersion && (
-          <>
-            <dt className="col-4">Latest version</dt>
-            <dd className="col-8">{status.latestVersion}</dd>
-          </>
-        )}
-        <dt className="col-4">Status</dt>
-        <dd className="col-8">{describeAppUpdateStatus(status)}</dd>
-        {status.lastCheckedAt != null && (
-          <>
-            <dt className="col-4">Last checked</dt>
-            <dd className="col-8">{new Date(status.lastCheckedAt).toLocaleString()}</dd>
-          </>
-        )}
-      </dl>
-      <div className="d-flex gap-2 mb-3">
-        <button
-          type="button"
-          className="btn btn-sm btn-outline-secondary"
-          disabled={!status.supported || checking || isAppRestarting(status)}
-          onClick={() => {
-            setChecking(true);
-            setCheckError(undefined);
-            getAppUpdatesConsumer()
-              .then((appUpdates) => appUpdates.tools.checkForUpdates())
-              .catch((err: unknown) =>
-                setCheckError(err instanceof Error ? err.message : String(err)),
-              )
-              .finally(() => setChecking(false));
-          }}
-        >
-          Check now
-        </button>
-        <UpdateAndRestartButton
-          status={status}
-          className={`btn btn-sm ${hasAppUpdate(status) ? "btn-warning" : "btn-outline-secondary"}`}
-        />
-      </div>
-      {checkError && (
-        <p className="small text-danger" role="alert">
-          {checkError}
-        </p>
-      )}
-      <SettingCheckbox
-        id="installAppUpdatesOnRestart"
-        label="Install updates automatically when Peers restarts"
-        checked={installAppUpdatesOnRestart}
-        help="Updates always download in the background. When this is off, they install only when you choose **Update & restart** here or in the network status menu."
-      />
-      {isPreparedDespiteOptOut(status) && (
-        <p className="small text-muted ms-4">
-          macOS prepared version {status.downloadedVersion} for an earlier Update &amp; restart, so
-          it will still install when Peers quits. Later updates will wait for you.
-        </p>
-      )}
-      <SettingCheckbox
-        id="allowRemoteAppUpdateRestart"
-        label="Allow my other devices to update and restart this device"
-        checked={allowRemoteAppUpdateRestart}
-        help="Lets your other devices, and people you trust as yourself, run **Update & restart** on this device from Identity → Devices or the Network Viewer."
-      />
-    </>
-  );
-}

package/src/app-updates/remote-app-update-panel.test.tsx

@@ -1,205 +0,0 @@
-import type { IAppUpdateStatus } from "@peers-app/peers-sdk";
-import { act, fireEvent, render, waitFor } from "@testing-library/react";
-import { REMOTE_UPDATE_POLL_MS, RemoteAppUpdatePanel } from "./remote-app-update-panel";
-
-const getDeviceUpdateStatus = jest.fn();
-const installUpdateAndRestartOnDevice = jest.fn();
-
-jest.mock("./app-updates-consumer", () => ({
-  ...jest.requireActual("./app-updates-consumer"),
-  getAppUpdatesConsumer: () =>
-    Promise.resolve({
-      tools: {
-        getDeviceUpdateStatus: (...args: unknown[]) => getDeviceUpdateStatus(...args),
-        installUpdateAndRestartOnDevice: (...args: unknown[]) =>
-          installUpdateAndRestartOnDevice(...args),
-      },
-    }),
-}));
-
-function remoteStatus(overrides: Partial<IAppUpdateStatus> = {}): IAppUpdateStatus {
-  return {
-    supported: true,
-    canRestart: true,
-    platform: "win32",
-    currentVersion: "1.0.0",
-    latestVersion: "1.1.0",
-    downloadedVersion: "1.1.0",
-    state: "downloaded",
-    installOnRestart: true,
-    installOnQuitArmed: true,
-    remoteRestartAllowed: true,
-    ...overrides,
-  };
-}
-
-describe("RemoteAppUpdatePanel", () => {
-  beforeEach(() => {
-    getDeviceUpdateStatus.mockReset();
-    installUpdateAndRestartOnDevice.mockReset();
-    installUpdateAndRestartOnDevice.mockResolvedValue({ action: "installing" });
-    jest.spyOn(window, "confirm").mockReturnValue(true);
-  });
-
-  afterEach(() => {
-    jest.restoreAllMocks();
-  });
-
-  it("updates the other device after confirmation", async () => {
-    getDeviceUpdateStatus.mockResolvedValue(remoteStatus());
-    const view = render(<RemoteAppUpdatePanel deviceId="desktop" deviceName="Desktop" />);
-
-    const button = await view.findByRole("button", { name: /Update & restart/ });
-    expect(view.getByTestId("remote-app-update")).toHaveTextContent(
-      "Version 1.0.0 · Version 1.1.0 is ready to install",
-    );
-    expect(getDeviceUpdateStatus).toHaveBeenCalledWith({ deviceId: "desktop" });
-
-    fireEvent.click(button);
-    expect(window.confirm).toHaveBeenCalledWith("Update Desktop to 1.1.0 and restart it?");
-    await waitFor(() =>
-      expect(installUpdateAndRestartOnDevice).toHaveBeenCalledWith({ deviceId: "desktop" }),
-    );
-    await view.findByText("Request sent");
-  });
-
-  it("offers a plain restart when the device is up to date", async () => {
-    getDeviceUpdateStatus.mockResolvedValue(remoteStatus({ state: "up-to-date" }));
-    const view = render(<RemoteAppUpdatePanel deviceId="desktop" />);
-    fireEvent.click(await view.findByRole("button", { name: /^Restart$/ }));
-    expect(window.confirm).toHaveBeenCalledWith(
-      "Restart desktop? It will check for an update first.",
-    );
-    await waitFor(() => expect(installUpdateAndRestartOnDevice).toHaveBeenCalled());
-  });
-
-  it("does nothing when the confirmation is declined", async () => {
-    (window.confirm as jest.Mock).mockReturnValue(false);
-    getDeviceUpdateStatus.mockResolvedValue(remoteStatus());
-    const view = render(<RemoteAppUpdatePanel deviceId="desktop" />);
-    fireEvent.click(await view.findByRole("button", { name: /Update & restart/ }));
-    expect(installUpdateAndRestartOnDevice).not.toHaveBeenCalled();
-  });
-
-  it("explains why the action is disabled", async () => {
-    getDeviceUpdateStatus.mockResolvedValue(remoteStatus({ remoteRestartAllowed: false }));
-    const view = render(<RemoteAppUpdatePanel deviceId="desktop" />);
-    expect(await view.findByRole("button", { name: /Update & restart/ })).toBeDisabled();
-    expect(view.getByTestId("remote-app-update")).toHaveTextContent(
-      "does not allow remote restarts",
-    );
-
-    getDeviceUpdateStatus.mockResolvedValue(remoteStatus({ installNeedsElevation: true }));
-    const elevated = render(<RemoteAppUpdatePanel deviceId="linux-box" />);
-    await waitFor(() =>
-      expect(elevated.getAllByRole("button", { name: /Update & restart/ })[1]).toBeDisabled(),
-    );
-    expect(elevated.getAllByTestId("remote-app-update")[1]).toHaveTextContent(
-      "administrator password",
-    );
-  });
-
-  it.each([
-    [
-      "a device that cannot restart itself",
-      () => Promise.resolve(remoteStatus({ canRestart: false })),
-    ],
-    [
-      "a device that does not trust this user",
-      () =>
-        Promise.reject(new Error("Permission denied: tool 'getUpdateStatus'.run on contract x")),
-    ],
-    [
-      "a build without App Updates",
-      () => Promise.reject(new Error("No contract provider registered for x v1")),
-    ],
-  ])("renders nothing for %s", async (_label, result) => {
-    getDeviceUpdateStatus.mockImplementation(result);
-    const view = render(<RemoteAppUpdatePanel deviceId="desktop" />);
-    await waitFor(() => expect(view.queryByTestId("remote-app-update")).toBeNull());
-  });
-
-  it("reports an unreachable device", async () => {
-    getDeviceUpdateStatus.mockRejectedValue(new Error("Device desktop is not connected"));
-    const view = render(<RemoteAppUpdatePanel deviceId="desktop" />);
-    await view.findByText("Not reachable: Device desktop is not connected");
-    getDeviceUpdateStatus.mockResolvedValue(remoteStatus());
-    fireEvent.click(view.getByRole("button", { name: "Retry" }));
-    await view.findByRole("button", { name: /Update & restart/ });
-  });
-
-  it("clears the previous device's action while a new target loads", async () => {
-    getDeviceUpdateStatus.mockResolvedValueOnce(remoteStatus());
-    const view = render(<RemoteAppUpdatePanel deviceId="desktop" />);
-    await view.findByRole("button", { name: /Update & restart/ });
-    let finish!: (status: IAppUpdateStatus) => void;
-    getDeviceUpdateStatus.mockImplementationOnce(
-      () =>
-        new Promise<IAppUpdateStatus>((resolve) => {
-          finish = resolve;
-        }),
-    );
-    view.rerender(<RemoteAppUpdatePanel deviceId="another-desktop" />);
-    expect(view.queryByRole("button", { name: /Update & restart/ })).toBeNull();
-    expect(view.getByText("Checking this device…")).toBeTruthy();
-    await act(async () => {
-      await Promise.resolve();
-      finish(remoteStatus({ remoteRestartAllowed: false }));
-    });
-    expect(view.getByRole("button", { name: /Update & restart/ })).toBeDisabled();
-  });
-
-  it("accepts slow poll responses without overlapping requests and cleans up timers", async () => {
-    jest.useFakeTimers();
-    try {
-      getDeviceUpdateStatus.mockResolvedValue(remoteStatus());
-      const view = render(<RemoteAppUpdatePanel deviceId="desktop" />);
-      await act(async () => {});
-      let finish!: (status: IAppUpdateStatus) => void;
-      getDeviceUpdateStatus.mockImplementationOnce(
-        () =>
-          new Promise<IAppUpdateStatus>((resolve) => {
-            finish = resolve;
-          }),
-      );
-      fireEvent.click(view.getByRole("button", { name: /Update & restart/ }));
-      await act(async () => {});
-      await act(async () => {
-        jest.advanceTimersByTime(REMOTE_UPDATE_POLL_MS * 3);
-      });
-      expect(getDeviceUpdateStatus).toHaveBeenCalledTimes(2);
-      await act(async () => {
-        finish(remoteStatus({ currentVersion: "1.1.0", state: "up-to-date" }));
-      });
-      expect(view.getByText("Version 1.1.0 · Up to date")).toBeTruthy();
-      await act(async () => {
-        jest.advanceTimersByTime(REMOTE_UPDATE_POLL_MS);
-      });
-      expect(getDeviceUpdateStatus).toHaveBeenCalledTimes(3);
-      view.unmount();
-      expect(jest.getTimerCount()).toBe(0);
-    } finally {
-      jest.useRealTimers();
-    }
-  });
-
-  it("confirms the newer downloading version instead of the older cached version", async () => {
-    getDeviceUpdateStatus.mockResolvedValue(
-      remoteStatus({ state: "downloading", latestVersion: "1.2.0", downloadedVersion: "1.1.0" }),
-    );
-    const view = render(<RemoteAppUpdatePanel deviceId="desktop" deviceName="Desktop" />);
-    fireEvent.click(await view.findByRole("button", { name: /Update & restart/ }));
-    expect(window.confirm).toHaveBeenCalledWith("Update Desktop to 1.2.0 and restart it?");
-    await view.findByText("Request sent");
-  });
-
-  it("shows a failed request", async () => {
-    getDeviceUpdateStatus.mockResolvedValue(remoteStatus());
-    installUpdateAndRestartOnDevice.mockRejectedValue(
-      new Error("Permission denied: this device does not allow other devices to update"),
-    );
-    const view = render(<RemoteAppUpdatePanel deviceId="desktop" />);
-    fireEvent.click(await view.findByRole("button", { name: /Update & restart/ }));
-    await view.findByText(/does not allow other devices to update/);
-  });
-});

package/src/app-updates/remote-app-update-panel.tsx

@@ -1,210 +0,0 @@
-import type { IAppUpdateStatus } from "@peers-app/peers-sdk";
-import { useEffect, useState } from "react";
-import { APP_UPDATE_ICON_CLASS } from "./app-update-controls";
-import {
-  classifyAppUpdatesError,
-  describeAppUpdateStatus,
-  getAppUpdatesConsumer,
-  getAppUpdateVersion,
-  hasAppUpdate,
-  isAppRestarting,
-} from "./app-updates-consumer";
-
-/** How often the panel refreshes the target's status after an update or restart request. */
-export const REMOTE_UPDATE_POLL_MS = 5_000;
-/** How long the panel keeps refreshing after a request. */
-export const REMOTE_UPDATE_POLL_DURATION_MS = 3 * 60_000;
-
-type RemoteUpdateState =
-  | { kind: "loading" }
-  | { kind: "hidden" }
-  | { kind: "unreachable"; message: string }
-  | { kind: "error"; message: string }
-  | { kind: "ready"; status: IAppUpdateStatus };
-
-function errorMessage(error: unknown): string {
-  return error instanceof Error ? error.message : String(error);
-}
-
-function disabledReason(status: IAppUpdateStatus): string | undefined {
-  if (!status.remoteRestartAllowed) {
-    return "This device does not allow remote restarts. Turn on “Allow my other devices to update and restart this device” in its Settings → Updates.";
-  }
-  if (status.installNeedsElevation) {
-    return "Installing updates on this device needs an administrator password, so update it at the device.";
-  }
-  return undefined;
-}
-
-/**
- * Card showing another device's app version with an **Update & restart** action.
- *
- * The local host relays both calls to the target, which requires that it trusts this user
- * as `Self` and allows remote restarts. Renders nothing when the target cannot update or
- * restart itself, runs a build without App Updates, or does not trust this user.
- *
- * @param props.deviceId - Target device.
- * @param props.deviceName - Name used in the confirmation prompt.
- */
-export function RemoteAppUpdatePanel({
-  deviceId,
-  deviceName,
-}: {
-  deviceId: string;
-  deviceName?: string;
-}) {
-  // Route changes must not keep another device's status, consent switch, or pending request.
-  return <DeviceAppUpdatePanel key={deviceId} deviceId={deviceId} deviceName={deviceName} />;
-}
-
-function DeviceAppUpdatePanel({ deviceId, deviceName }: { deviceId: string; deviceName?: string }) {
-  const [state, setState] = useState<RemoteUpdateState>({ kind: "loading" });
-  const [refreshKey, setRefreshKey] = useState(0);
-  const [requestedAt, setRequestedAt] = useState<number>();
-  const [requestError, setRequestError] = useState<string>();
-  const [sending, setSending] = useState(false);
-
-  useEffect(() => {
-    let active = true;
-    let poll: ReturnType<typeof setTimeout> | undefined;
-    const load = () => {
-      void getAppUpdatesConsumer()
-        .then((appUpdates) => appUpdates.tools.getDeviceUpdateStatus({ deviceId }))
-        .then((status) => {
-          if (active) {
-            setState(status.canRestart ? { kind: "ready", status } : { kind: "hidden" });
-          }
-        })
-        .catch((error: unknown) => {
-          if (!active) return;
-          const kind = classifyAppUpdatesError(error);
-          if (kind === "unavailable" || kind === "denied") {
-            setState({ kind: "hidden" });
-          } else {
-            setState({
-              kind: kind === "unreachable" ? "unreachable" : "error",
-              message: errorMessage(error),
-            });
-          }
-        })
-        .finally(() => {
-          // Wait for the preceding RPC: a slow target can take up to 30s to answer.
-          // An interval would overlap calls and discard every response as stale.
-          if (
-            active &&
-            requestedAt !== undefined &&
-            Date.now() - requestedAt < REMOTE_UPDATE_POLL_DURATION_MS
-          ) {
-            poll = setTimeout(load, REMOTE_UPDATE_POLL_MS);
-          }
-        });
-    };
-    load();
-    return () => {
-      active = false;
-      if (poll) clearTimeout(poll);
-    };
-  }, [deviceId, refreshKey, requestedAt]);
-
-  useEffect(() => {
-    if (requestedAt === undefined) return;
-    const stop = setTimeout(() => setRequestedAt(undefined), REMOTE_UPDATE_POLL_DURATION_MS);
-    return () => {
-      clearTimeout(stop);
-    };
-  }, [requestedAt]);
-
-  if (state.kind === "hidden") {
-    return null;
-  }
-
-  const requestUpdate = (status: IAppUpdateStatus) => {
-    const name = deviceName || deviceId;
-    const prompt = hasAppUpdate(status)
-      ? `Update ${name} to ${getAppUpdateVersion(status)} and restart it?`
-      : `Restart ${name}? It will check for an update first.`;
-    if (!confirm(prompt)) return;
-    setSending(true);
-    setRequestError(undefined);
-    getAppUpdatesConsumer()
-      .then((appUpdates) => appUpdates.tools.installUpdateAndRestartOnDevice({ deviceId }))
-      .then(() => {
-        setRequestedAt(Date.now());
-        setRefreshKey((key) => key + 1);
-      })
-      .catch((error: unknown) => setRequestError(errorMessage(error)))
-      .finally(() => setSending(false));
-  };
-
-  return (
-    <div className="card mt-3" data-testid="remote-app-update">
-      <div className="card-body py-2 px-3 small">
-        <div className="fw-semibold mb-1">App version</div>
-        {state.kind === "loading" && <div className="text-muted">Checking this device…</div>}
-        {state.kind === "unreachable" && (
-          <div className="text-muted">
-            {requestedAt !== undefined ? "Restarting…" : `Not reachable: ${state.message}`}
-          </div>
-        )}
-        {state.kind === "error" && <div className="text-danger">{state.message}</div>}
-        {(state.kind === "unreachable" || state.kind === "error") && (
-          <button
-            type="button"
-            className="btn btn-sm btn-outline-secondary mt-2"
-            onClick={() => {
-              setState({ kind: "loading" });
-              setRefreshKey((key) => key + 1);
-            }}
-          >
-            Retry
-          </button>
-        )}
-        {state.kind === "ready" && (
-          <RemoteStatus
-            status={state.status}
-            sending={sending}
-            requested={requestedAt !== undefined}
-            onRequest={() => requestUpdate(state.status)}
-          />
-        )}
-        {requestError && <div className="text-danger mt-1">{requestError}</div>}
-      </div>
-    </div>
-  );
-}
-
-function RemoteStatus({
-  status,
-  sending,
-  requested,
-  onRequest,
-}: {
-  status: IAppUpdateStatus;
-  sending: boolean;
-  requested: boolean;
-  onRequest: () => void;
-}) {
-  const reason = disabledReason(status);
-  const update = hasAppUpdate(status);
-  return (
-    <>
-      <div className="mb-2">
-        {status.currentVersion ? `Version ${status.currentVersion} · ` : ""}
-        {describeAppUpdateStatus(status)}
-      </div>
-      <button
-        type="button"
-        className={`btn btn-sm ${update ? "btn-warning" : "btn-outline-secondary"}`}
-        disabled={Boolean(reason) || sending || isAppRestarting(status)}
-        onClick={onRequest}
-      >
-        <i className={`bi ${APP_UPDATE_ICON_CLASS} me-1`} aria-hidden="true" />
-        {update ? "Update & restart" : "Restart"}
-      </button>
-      {requested && !isAppRestarting(status) && (
-        <span className="text-muted ms-2">Request sent</span>
-      )}
-      {reason && <div className="text-muted mt-1">{reason}</div>}
-    </>
-  );
-}

package/src/app-updates/use-app-update-status.ts

@@ -1,16 +0,0 @@
-import type { IAppUpdateStatus } from "@peers-app/peers-sdk";
-import { useObservable } from "../hooks";
-import { useHostContract } from "../hooks/use-host-contract";
-import { appUpdatesContract } from "./app-updates-consumer";
-
-/**
- * Subscribe to the local host's application update status.
- *
- * @returns The live status, or `undefined` while the host transport is down. Hosts that
- *   cannot update themselves (PWA, headless) report `supported: false`.
- */
-export function useAppUpdateStatus(): IAppUpdateStatus | undefined {
-  const { consumer } = useHostContract(appUpdatesContract);
-  const [status] = useObservable<IAppUpdateStatus | undefined>(consumer?.observables.status);
-  return status;
-}