@elizaos/ui 2.0.0-alpha.85 → 2.0.0-beta.2

package/state/startup-phase-restore.js

@@ -0,0 +1,344 @@
+/**
+ * startup-phase-restore.ts
+ *
+ * Side-effect logic for the "restoring-session" startup phase.
+ * Probes for an existing install/connection and dispatches the result.
+ */
+import { logger } from "@elizaos/core";
+import { getStylePresets, ONBOARDING_PROVIDER_CATALOG } from "@elizaos/shared";
+import { client } from "../api/index.js";
+import { getBackendStartupTimeoutMs, getDesktopRuntimeMode, inspectExistingElizaInstall, invokeDesktopBridgeRequest, isElectrobunRuntime, scanProviderCredentials, } from "../bridge/index.js";
+import { ANDROID_LOCAL_AGENT_API_BASE, ANDROID_LOCAL_AGENT_LABEL, ANDROID_LOCAL_AGENT_SERVER_ID, MOBILE_LOCAL_AGENT_API_BASE, MOBILE_LOCAL_AGENT_LABEL, MOBILE_LOCAL_AGENT_SERVER_ID, readPersistedMobileRuntimeMode, } from "../onboarding/mobile-runtime-mode.js";
+import { isAndroid, isForceFreshOnboardingEnabled, isIOS } from "../platform/index.js";
+import { getElizaApiBase } from "../utils/eliza-globals.js";
+import { detectExistingOnboardingConnection } from "./onboarding-bootstrap.js";
+import { clearPersistedActiveServer, loadPersistedActiveServer, loadPersistedOnboardingComplete, savePersistedActiveServer, savePersistedOnboardingComplete, } from "./persistence.js";
+// Direct elizaCloud API base used to backfill a missing apiBase on a
+// persisted cloud active-server. Mirrors DEFAULT_DIRECT_CLOUD_API_BASE_URL
+// in api/client-cloud.ts; kept inline because that constant is module-private.
+const DIRECT_CLOUD_API_BASE = "https://api.elizacloud.ai";
+/**
+ * If the restored cloud active-server has no apiBase (a broken state from
+ * earlier builds where finishAsCloud silently completed onboarding before
+ * the cloud surface attached a web_ui_url), look the agent up against the
+ * direct cloud API and persist the resolved URL. Returns the up-to-date
+ * active server (with apiBase populated when resolution succeeds) or the
+ * input unchanged when backfill isn't possible.
+ */
+async function backfillCloudApiBase(active) {
+    if (active.kind !== "cloud" || active.apiBase)
+        return active;
+    const agentId = active.id?.startsWith("cloud:")
+        ? active.id.slice("cloud:".length)
+        : null;
+    if (!agentId)
+        return active;
+    const priorBaseUrl = client.getBaseUrl();
+    const priorToken = client.hasToken();
+    client.setBaseUrl(DIRECT_CLOUD_API_BASE);
+    try {
+        if (active.accessToken)
+            client.setToken(active.accessToken);
+        const res = await client.getCloudCompatAgent(agentId);
+        if (!res.success)
+            return active;
+        const data = res.data;
+        const apiBase = data.web_ui_url ?? data.webUiUrl ?? data.bridge_url ?? null;
+        if (!apiBase)
+            return active;
+        const updated = { ...active, apiBase };
+        savePersistedActiveServer(updated);
+        return updated;
+    }
+    catch {
+        return active;
+    }
+    finally {
+        // Restore prior client state — applyRestoredConnection sets the final
+        // baseUrl below based on the (possibly backfilled) active server.
+        client.setBaseUrl(priorBaseUrl || null);
+        if (!priorToken)
+            client.setToken(null);
+    }
+}
+function isMobileLocalAgentApiBase(value) {
+    if (!value)
+        return false;
+    try {
+        const parsed = new URL(value);
+        return (parsed.protocol === "http:" &&
+            parsed.port === "31337" &&
+            (parsed.hostname === "127.0.0.1" ||
+                parsed.hostname === "localhost" ||
+                parsed.hostname === "::1"));
+    }
+    catch {
+        return false;
+    }
+}
+function isMobileLocalActiveServer(server) {
+    return server.kind === "local" || isMobileLocalAgentApiBase(server.apiBase);
+}
+function isLoopbackHostname(hostname) {
+    const h = hostname.toLowerCase();
+    return h === "127.0.0.1" || h === "localhost" || h === "::1";
+}
+// Re-resolve a persisted loopback apiBase against whatever port the
+// dev orchestrator / Electrobun bridge actually bound this run. A
+// previous session may have captured a stale port (e.g. 31337) when
+// the live API has moved (e.g. 31338). Without this, every restore
+// re-applies the dead URL and the renderer 404s on every fetch.
+function reconcilePersistedApiBaseWithLive(apiBase) {
+    if (!apiBase)
+        return apiBase;
+    const live = getElizaApiBase();
+    if (!live || live === apiBase)
+        return apiBase;
+    try {
+        const persisted = new URL(apiBase);
+        if (!isLoopbackHostname(persisted.hostname))
+            return apiBase;
+        const liveUrl = new URL(live);
+        if (!isLoopbackHostname(liveUrl.hostname))
+            return apiBase;
+        return live;
+    }
+    catch {
+        return apiBase;
+    }
+}
+function mobileLoopbackActiveServer() {
+    return {
+        id: isAndroid
+            ? ANDROID_LOCAL_AGENT_SERVER_ID
+            : MOBILE_LOCAL_AGENT_SERVER_ID,
+        kind: "remote",
+        label: isAndroid ? ANDROID_LOCAL_AGENT_LABEL : MOBILE_LOCAL_AGENT_LABEL,
+        apiBase: isAndroid
+            ? ANDROID_LOCAL_AGENT_API_BASE
+            : MOBILE_LOCAL_AGENT_API_BASE,
+    };
+}
+export async function applyRestoredConnection(args) {
+    const { restoredActiveServer, clientRef, startLocalRuntime } = args;
+    if (restoredActiveServer.kind === "local") {
+        // Don't clear an already-set token: "local" means the agent runs
+        // on this machine, not that the dashboard is unauthenticated.
+        clientRef.setBaseUrl(null);
+        if (startLocalRuntime) {
+            await startLocalRuntime();
+        }
+        return;
+    }
+    if (restoredActiveServer.kind === "cloud") {
+        const resolved = await backfillCloudApiBase(restoredActiveServer);
+        clientRef.setBaseUrl(resolved.apiBase ?? null);
+        clientRef.setToken(resolved.accessToken ?? null);
+        return;
+    }
+    const reconciled = reconcilePersistedApiBaseWithLive(restoredActiveServer.apiBase);
+    if (reconciled && reconciled !== restoredActiveServer.apiBase) {
+        savePersistedActiveServer({
+            ...restoredActiveServer,
+            apiBase: reconciled,
+        });
+    }
+    clientRef.setBaseUrl(reconciled ?? null);
+    clientRef.setToken(restoredActiveServer.accessToken ?? null);
+}
+function activeServerToTarget(server) {
+    if (isMobileLocalActiveServer(server))
+        return "embedded-local";
+    switch (server.kind) {
+        case "local":
+            return "embedded-local";
+        case "cloud":
+            return "cloud-managed";
+        case "remote":
+            return "remote-backend";
+    }
+}
+export function canRestoreActiveServer(args) {
+    if (args.server.apiBase) {
+        return true;
+    }
+    if (args.server.kind === "local") {
+        return args.forceLocal || args.isDesktop || args.clientApiAvailable;
+    }
+    return false;
+}
+function preserveCloudAuthTokenForOnboarding(server) {
+    if (server.kind !== "cloud")
+        return;
+    const token = server.accessToken?.trim();
+    if (!token)
+        return;
+    client.setToken(token);
+    if (typeof globalThis !== "undefined") {
+        globalThis.__ELIZA_CLOUD_AUTH_TOKEN__ = token;
+    }
+}
+/**
+ * Runs the restoring-session phase.
+ * Probes the local Eliza install and/or API to detect an existing connection,
+ * then dispatches SESSION_RESTORED or NO_SESSION.
+ *
+ * @param deps - Coordinator dependency bag
+ * @param dispatch - startupReducer dispatch
+ * @param ctxRef - Mutable ref shared with the polling-backend phase
+ * @param cancelled - Ref-flag set true by the cleanup function
+ */
+export async function runRestoringSession(deps, dispatch, ctxRef, cancelled) {
+    deps.setStartupError(null);
+    deps.setAuthRequired(false);
+    deps.setConnected(false);
+    deps.setOnboardingExistingInstallDetected(false);
+    const forceLocal = deps.forceLocalBootstrapRef.current;
+    deps.forceLocalBootstrapRef.current = false;
+    let persistedActiveServer = loadPersistedActiveServer();
+    let hadPrior = loadPersistedOnboardingComplete();
+    const forceFreshOnboarding = isForceFreshOnboardingEnabled();
+    if (forceFreshOnboarding) {
+        clearPersistedActiveServer();
+        savePersistedOnboardingComplete(false);
+        persistedActiveServer = null;
+        hadPrior = false;
+        deps.onboardingCompletionCommittedRef.current = false;
+        client.setBaseUrl(null);
+        client.setToken(null);
+    }
+    if (cancelled.current)
+        return;
+    const desktopInstall = !forceFreshOnboarding && !persistedActiveServer && isElectrobunRuntime()
+        ? await inspectExistingElizaInstall().catch(() => null)
+        : null;
+    if (cancelled.current)
+        return;
+    const isDesktop = forceLocal || isElectrobunRuntime();
+    const _hasExistingEvidence = hadPrior || Boolean(desktopInstall?.detected);
+    // Probe the API when there is evidence of a prior install, or when no
+    // persisted server exists (covers headless/VPS setups where config was
+    // set via files without going through UI onboarding).
+    const probed = !forceFreshOnboarding && !persistedActiveServer
+        ? await detectExistingOnboardingConnection({
+            client,
+            timeoutMs: isDesktop
+                ? Math.min(getBackendStartupTimeoutMs(), 30_000)
+                : Math.min(getBackendStartupTimeoutMs(), 3_500),
+        })
+        : null;
+    if (cancelled.current)
+        return;
+    let restoredActiveServer = persistedActiveServer ?? (probed ? probed.activeServer : null);
+    if ((isAndroid || isIOS) && restoredActiveServer) {
+        const mobileRuntimeMode = readPersistedMobileRuntimeMode();
+        if (isMobileLocalActiveServer(restoredActiveServer) &&
+            mobileRuntimeMode !== "local") {
+            clearPersistedActiveServer();
+            savePersistedOnboardingComplete(false);
+            persistedActiveServer = null;
+            restoredActiveServer = null;
+            hadPrior = false;
+            deps.onboardingCompletionCommittedRef.current = false;
+        }
+        else if (restoredActiveServer.kind === "local") {
+            restoredActiveServer = mobileLoopbackActiveServer();
+            persistedActiveServer = restoredActiveServer;
+            savePersistedActiveServer(restoredActiveServer);
+        }
+        else if (!restoredActiveServer.apiBase) {
+            clearPersistedActiveServer();
+            savePersistedOnboardingComplete(false);
+            persistedActiveServer = null;
+            restoredActiveServer = null;
+            hadPrior = false;
+            deps.onboardingCompletionCommittedRef.current = false;
+        }
+    }
+    if (restoredActiveServer &&
+        !canRestoreActiveServer({
+            server: restoredActiveServer,
+            clientApiAvailable: client.apiAvailable,
+            forceLocal,
+            isDesktop,
+        })) {
+        preserveCloudAuthTokenForOnboarding(restoredActiveServer);
+        clearPersistedActiveServer();
+        savePersistedOnboardingComplete(false);
+        persistedActiveServer = null;
+        restoredActiveServer = null;
+        hadPrior = false;
+        deps.onboardingCompletionCommittedRef.current = false;
+    }
+    const preserveCompleted = hadPrior && !deps.onboardingCompletionCommittedRef.current;
+    deps.setOnboardingExistingInstallDetected(forceFreshOnboarding
+        ? false
+        : Boolean(hadPrior ||
+            desktopInstall?.detected ||
+            probed?.detectedExistingInstall));
+    if (!restoredActiveServer) {
+        // No saved backend found — let the user (re-)onboard.
+        deps.setOnboardingOptions({
+            names: [],
+            styles: getStylePresets(deps.uiLanguage),
+            providers: [
+                ...ONBOARDING_PROVIDER_CATALOG,
+            ],
+            cloudProviders: [],
+            models: {
+                nano: [],
+                small: [],
+                medium: [],
+                large: [],
+                mega: [],
+            },
+            inventoryProviders: [],
+            sharedStyleRules: "",
+        });
+        if (!forceFreshOnboarding) {
+            try {
+                const det = await scanProviderCredentials();
+                if (!cancelled.current && det.length > 0) {
+                    console.log(`[eliza][startup] Keychain scan found ${det.length} provider(s):`, det.map((p) => p.id));
+                    deps.applyDetectedProviders(det);
+                }
+            }
+            catch (scanErr) {
+                console.warn("[eliza][startup] Keychain credential scan failed:", scanErr);
+            }
+        }
+        deps.setOnboardingComplete(false);
+        deps.setOnboardingLoading(false);
+        dispatch({ type: "NO_SESSION", hadPriorOnboarding: hadPrior });
+        return;
+    }
+    await applyRestoredConnection({
+        restoredActiveServer,
+        clientRef: client,
+        startLocalRuntime: async () => {
+            try {
+                const runtimeMode = await getDesktopRuntimeMode().catch(() => null);
+                if (runtimeMode && runtimeMode.mode !== "local") {
+                    return;
+                }
+                await invokeDesktopBridgeRequest({
+                    rpcMethod: "agentStart",
+                    ipcChannel: "agent:start",
+                });
+            }
+            catch (err) {
+                logger.warn(`[startup-phase-restore] desktop agent bridge request failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        },
+    });
+    ctxRef.current = {
+        persistedActiveServer,
+        restoredActiveServer,
+        shouldPreserveCompletedOnboarding: preserveCompleted,
+        hadPriorOnboarding: hadPrior,
+    };
+    dispatch({
+        type: "SESSION_RESTORED",
+        target: activeServerToTarget(restoredActiveServer),
+    });
+}

package/state/startup-phase-runtime.d.ts

@@ -0,0 +1,36 @@
+/**
+ * startup-phase-runtime.ts
+ *
+ * Side-effect logic for the "starting-runtime" startup phase.
+ * Polls the agent status until running, then dispatches AGENT_RUNNING.
+ */
+import { type StartupErrorState } from "./internal";
+import type { StartupEvent } from "./startup-coordinator";
+export interface StartingRuntimeDeps {
+    setAgentStatus: (v: import("../api").AgentStatus | null) => void;
+    setConnected: (v: boolean) => void;
+    setStartupError: (v: StartupErrorState | null) => void;
+    setOnboardingLoading: (v: boolean) => void;
+    setAuthRequired: (v: boolean) => void;
+    setPairingEnabled: (v: boolean) => void;
+    setPairingExpiresAt: (v: number | null) => void;
+    setPendingRestart: (v: boolean | ((prev: boolean) => boolean)) => void;
+    setPendingRestartReasons: (v: string[] | ((prev: string[]) => string[])) => void;
+}
+/**
+ * Runs the starting-runtime phase.
+ * Polls /status until the agent reaches "running", then dispatches AGENT_RUNNING.
+ *
+ * @param deps - Coordinator dependency bag
+ * @param dispatch - startupReducer dispatch
+ * @param effectRunId - The run ID of the calling effect (for stale-close guard)
+ * @param effectRunRef - Shared ref tracking the latest run ID
+ * @param cancelled - Ref-flag set true by the cleanup function
+ * @param tidRef - Mutable ref for the pending setTimeout handle (for cleanup)
+ */
+export declare function runStartingRuntime(deps: StartingRuntimeDeps, dispatch: (event: StartupEvent) => void, effectRunId: number, effectRunRef: React.MutableRefObject<number>, cancelled: {
+    current: boolean;
+}, tidRef: {
+    current: ReturnType<typeof setTimeout> | null;
+}): Promise<void>;
+//# sourceMappingURL=startup-phase-runtime.d.ts.map

package/state/startup-phase-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"startup-phase-runtime.d.ts","sourceRoot":"","sources":["../../../../../src/state/startup-phase-runtime.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAOH,OAAO,EAGL,KAAK,iBAAiB,EACvB,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAE1D,MAAM,WAAW,mBAAmB;IAClC,cAAc,EAAE,CAAC,CAAC,EAAE,OAAO,QAAQ,EAAE,WAAW,GAAG,IAAI,KAAK,IAAI,CAAC;IACjE,YAAY,EAAE,CAAC,CAAC,EAAE,OAAO,KAAK,IAAI,CAAC;IACnC,eAAe,EAAE,CAAC,CAAC,EAAE,iBAAiB,GAAG,IAAI,KAAK,IAAI,CAAC;IACvD,oBAAoB,EAAE,CAAC,CAAC,EAAE,OAAO,KAAK,IAAI,CAAC;IAC3C,eAAe,EAAE,CAAC,CAAC,EAAE,OAAO,KAAK,IAAI,CAAC;IACtC,iBAAiB,EAAE,CAAC,CAAC,EAAE,OAAO,KAAK,IAAI,CAAC;IACxC,mBAAmB,EAAE,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAC;IAChD,iBAAiB,EAAE,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,CAAC,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC,KAAK,IAAI,CAAC;IACvE,wBAAwB,EAAE,CACxB,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,MAAM,EAAE,CAAC,KACzC,IAAI,CAAC;CACX;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,kBAAkB,CACtC,IAAI,EAAE,mBAAmB,EACzB,QAAQ,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,EACvC,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,KAAK,CAAC,gBAAgB,CAAC,MAAM,CAAC,EAC5C,SAAS,EAAE;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,EAC/B,MAAM,EAAE;IAAE,OAAO,EAAE,UAAU,CAAC,OAAO,UAAU,CAAC,GAAG,IAAI,CAAA;CAAE,GACxD,OAAO,CAAC,IAAI,CAAC,CAmJf"}

package/state/startup-phase-runtime.js

@@ -0,0 +1,152 @@
+/**
+ * startup-phase-runtime.ts
+ *
+ * Side-effect logic for the "starting-runtime" startup phase.
+ * Polls the agent status until running, then dispatches AGENT_RUNNING.
+ */
+import { client } from "../api/index.js";
+import { computeAgentDeadlineExtensions, getAgentReadyTimeoutMs, } from "./agent-startup-timing.js";
+import { asApiLikeError, formatStartupErrorDetail, } from "./internal.js";
+/**
+ * Runs the starting-runtime phase.
+ * Polls /status until the agent reaches "running", then dispatches AGENT_RUNNING.
+ *
+ * @param deps - Coordinator dependency bag
+ * @param dispatch - startupReducer dispatch
+ * @param effectRunId - The run ID of the calling effect (for stale-close guard)
+ * @param effectRunRef - Shared ref tracking the latest run ID
+ * @param cancelled - Ref-flag set true by the cleanup function
+ * @param tidRef - Mutable ref for the pending setTimeout handle (for cleanup)
+ */
+export async function runStartingRuntime(deps, dispatch, effectRunId, effectRunRef, cancelled, tidRef) {
+    const describeAgentFailure = (err, timedOut, diag) => {
+        const detail = diag?.lastError ||
+            formatStartupErrorDetail(err) ||
+            "Agent runtime did not report a reason.";
+        if (!timedOut &&
+            /required companion assets could not be loaded|bundled avatar .* could not be loaded/i.test(detail))
+            return {
+                reason: "asset-missing",
+                phase: "initializing-agent",
+                message: "Required companion assets could not be loaded.",
+                detail,
+            };
+        if (timedOut) {
+            const hint = 'First-time startup often downloads a local embedding model (GGUF, hundreds of MB). That can take many minutes on a slow network.\n\nIf logs still show a download in progress, wait for it to finish, then tap Retry. On desktop, the app keeps extending the wait while the agent stays in "starting" (up to 15 minutes total).';
+            const emb = diag?.embeddingDetail ??
+                (diag?.embeddingPhase === "downloading"
+                    ? "Embedding model download in progress."
+                    : undefined);
+            return {
+                reason: "agent-timeout",
+                phase: "initializing-agent",
+                message: "The agent did not become ready in time. This is common while a large embedding model (GGUF) is still downloading on first run.",
+                detail: [detail, emb, hint]
+                    .filter((b) => typeof b === "string" && b.trim().length > 0)
+                    .join("\n\n"),
+            };
+        }
+        return {
+            reason: "agent-error",
+            phase: "initializing-agent",
+            message: "Agent runtime reported a startup error.",
+            detail,
+        };
+    };
+    const started = Date.now();
+    let deadline = started + getAgentReadyTimeoutMs();
+    let lastErr = null;
+    let lastDiag;
+    while (!cancelled.current && effectRunRef.current === effectRunId) {
+        if (Date.now() >= deadline) {
+            deps.setStartupError(describeAgentFailure(lastErr, true, lastDiag));
+            deps.setOnboardingLoading(false);
+            dispatch({ type: "AGENT_TIMEOUT" });
+            return;
+        }
+        try {
+            let status = await client.getStatus();
+            deps.setAgentStatus(status);
+            deps.setConnected(true);
+            lastDiag = status.startup;
+            deadline = computeAgentDeadlineExtensions({
+                agentWaitStartedAt: started,
+                agentDeadlineAt: deadline,
+                state: status.state,
+            });
+            if (status.pendingRestart) {
+                deps.setPendingRestart(true);
+                deps.setPendingRestartReasons(status.pendingRestartReasons ?? []);
+            }
+            if (status.state === "not_started" || status.state === "stopped") {
+                try {
+                    status = await client.startAgent();
+                    deps.setAgentStatus(status);
+                    lastDiag = status.startup;
+                }
+                catch (e) {
+                    lastErr = e;
+                }
+            }
+            if (status.state === "running") {
+                dispatch({ type: "AGENT_RUNNING" });
+                return;
+            }
+            if (status.state === "error") {
+                deps.setStartupError(describeAgentFailure(lastErr, false, status.startup));
+                deps.setOnboardingLoading(false);
+                dispatch({
+                    type: "AGENT_ERROR",
+                    message: status.startup?.lastError ?? "Agent failed to start",
+                });
+                return;
+            }
+        }
+        catch (err) {
+            const ae = asApiLikeError(err);
+            if (ae?.status === 401 && !client.hasToken()) {
+                const auth = await client.getAuthStatus().catch(() => ({
+                    required: true,
+                    pairingEnabled: false,
+                    expiresAt: null,
+                }));
+                deps.setAuthRequired(true);
+                deps.setPairingEnabled(auth.pairingEnabled);
+                deps.setPairingExpiresAt(auth.expiresAt);
+                deps.setOnboardingLoading(false);
+                dispatch({ type: "BACKEND_AUTH_REQUIRED" });
+                return;
+            }
+            if ((ae?.status === 401 || ae?.status === 429) && client.hasToken()) {
+                // 401/429 with a token. Two flavors to distinguish:
+                //   1. Genuine port race / pre-bearer endpoint window — /api/auth/status
+                //      itself isn't reachable yet. Keep retrying.
+                //   2. Bearer-only token (paired but no password session). Server says
+                //      /api/auth/status is fine (authenticated:true) but app endpoints
+                //      like /api/agent/status still 401, or 429 from the auth rate
+                //      limiter on those endpoints. /api/auth/me returns
+                //      reason="remote_auth_required". Advance to ready so the auth gate
+                //      can render LoginView. Hydrating tolerates 401s.
+                try {
+                    const auth = await client.getAuthStatus();
+                    const remotePasswordMissing = auth.required &&
+                        auth.loginRequired &&
+                        auth.passwordConfigured === false;
+                    if (auth.authenticated || remotePasswordMissing) {
+                        deps.setOnboardingLoading(false);
+                        dispatch({ type: "AGENT_RUNNING" });
+                        return;
+                    }
+                }
+                catch {
+                    // /api/auth/status itself unreachable — keep retrying.
+                }
+            }
+            lastErr = err;
+            deps.setConnected(false);
+        }
+        await new Promise((r) => {
+            tidRef.current = setTimeout(r, 500);
+        });
+    }
+}