homeio

1"use client";
2
3import { useQueryClient } from "@tanstack/react-query";
4import { useEffect, useState } from "react";
5import { reloadBrowserWindow } from "@/lib/desktop/browser-reload";
6import {
7  POWER_ACTION_STATE_CHANGED_EVENT,
8  clearPersistedPowerActionState,
9  readPersistedPowerActionState,
10  writePersistedPowerActionCompletion,
11  type PersistedPowerActionState,
12} from "@/lib/desktop/reboot-state";
13import { queryKeys } from "@/lib/shared/query-keys";
14
15type PowerActionRecoveryPhase = "starting" | "waiting" | "reconnecting";
16
17const RECOVERY_POLL_MS = 2_000;
18const STARTING_PHASE_MS = 4_000;
19const MIN_RESTART_TRANSITION_MS = 12_000;
20
21export function useRebootRecovery() {
22  const queryClient = useQueryClient();
23  const [powerActionState, setPowerActionState] = useState<PersistedPowerActionState | null>(
24    null,
25  );
26  const [phase, setPhase] = useState<PowerActionRecoveryPhase>("starting");
27  const [isHydrated, setIsHydrated] = useState(false);
28
29  useEffect(() => {
30    if (typeof window === "undefined") return;
31
32    const syncPowerActionState = () => {
33      setPowerActionState(readPersistedPowerActionState(window.localStorage));
34    };
35
36    syncPowerActionState();
37    setIsHydrated(true);
38
39    const onStorage = () => {
40      syncPowerActionState();
41    };
42
43    window.addEventListener("storage", onStorage);
44    window.addEventListener(POWER_ACTION_STATE_CHANGED_EVENT, onStorage);
45
46    return () => {
47      window.removeEventListener("storage", onStorage);
48      window.removeEventListener(POWER_ACTION_STATE_CHANGED_EVENT, onStorage);
49    };
50  }, []);
51
52  useEffect(() => {
53    if (!isHydrated || !powerActionState || typeof window === "undefined") return;
54
55    let cancelled = false;
56    let timer: ReturnType<typeof setTimeout> | null = null;
57    let hasObservedUnavailable = false;
58
59    const scheduleNextCheck = () => {
60      if (cancelled) return;
61      timer = setTimeout(() => {
62        void checkRecovery();
63      }, RECOVERY_POLL_MS);
64    };
65
66    const clearState = async (invalidateQueries: boolean, markCompleted = false) => {
67      if (markCompleted && powerActionState.action === "update") {
68        writePersistedPowerActionCompletion(window.localStorage, {
69          action: "update",
70          completedAt: new Date().toISOString(),
71        });
72      }
73
74      clearPersistedPowerActionState(window.localStorage);
75
76      if (invalidateQueries) {
77        await Promise.all([
78          queryClient.invalidateQueries({
79            queryKey: queryKeys.currentUser,
80          }),
81          queryClient.invalidateQueries({
82            queryKey: queryKeys.systemMetrics,
83          }),
84          queryClient.invalidateQueries({
85            queryKey: queryKeys.installedApps,
86          }),
87          queryClient.invalidateQueries({
88            queryKey: queryKeys.powerSchedule,
89          }),
90          queryClient.invalidateQueries({
91            queryKey: queryKeys.systemBackups,
92          }),
93          queryClient.invalidateQueries({
94            queryKey: queryKeys.systemUpdates,
95          }),
96        ]);
97      }
98
99      if (!cancelled) {
100        setPowerActionState(null);
101      }
102
103      if (!cancelled && markCompleted && powerActionState.action === "update") {
104        reloadBrowserWindow();
105      }
106    };
107
108    const checkRecovery = async () => {
109      if (cancelled) return;
110
111      const startedAtMs = Date.parse(powerActionState.startedAt);
112      const elapsedMs = Number.isFinite(startedAtMs)
113        ? Date.now() - startedAtMs
114        : STARTING_PHASE_MS;
115
116      setPhase(elapsedMs < STARTING_PHASE_MS ? "starting" : "waiting");
117
118      try {
119        const healthResponse = await fetch("/api/health", {
120          cache: "no-store",
121        });
122
123        if (!healthResponse.ok) {
124          hasObservedUnavailable = true;
125          scheduleNextCheck();
126          return;
127        }
128
129        if (cancelled) return;
130
131        const canAttemptRecovery =
132          hasObservedUnavailable || elapsedMs >= MIN_RESTART_TRANSITION_MS;
133
134        if (!canAttemptRecovery) {
135          scheduleNextCheck();
136          return;
137        }
138
139        setPhase("reconnecting");
140
141        const authResponse = await fetch("/api/auth/me", {
142          cache: "no-store",
143        });
144
145        if (!authResponse.ok) {
146          if (authResponse.status === 401) {
147            // After a restore, the DB is replaced with a backup copy. The user
148            // may be locked out because the backup's password hash doesn't match
149            // their current password. Set a one-shot flag so the login page can
150            // show a helpful banner explaining why their credentials may not work.
151            if (powerActionState.action === "restore") {
152              try {
153                window.localStorage.setItem("homeio:restore-banner", "1");
154              } catch {
155                // Best-effort only.
156              }
157            }
158            await clearState(false);
159            return;
160          }
161
162          scheduleNextCheck();
163          return;
164        }
165
166        await clearState(true, true);
167      } catch {
168        hasObservedUnavailable = true;
169        scheduleNextCheck();
170      }
171    };
172
173    void checkRecovery();
174
175    return () => {
176      cancelled = true;
177      if (timer) {
178        clearTimeout(timer);
179      }
180    };
181  }, [isHydrated, powerActionState, queryClient]);
182
183  return {
184    isHydrated,
185    isActive: powerActionState !== null,
186    action: powerActionState?.action ?? null,
187    phase,
188    startedAt: powerActionState?.startedAt ?? null,
189  };
190}
191