import { hostRestrictsExtraSshChannels } from "../../domain/host"; import { useEffect, useRef, useState } from "react"; import { buildHostConnectionTestPlan } from "../../domain/hostConnectionTest"; import { resolveEffectiveTerminalHost } from "../../domain/terminalHostResolution"; import { getEffectiveKnownHosts } from "../../infrastructure/syncHelpers"; import { netcattyBridge } from "../../infrastructure/services/netcattyBridge"; import { useAppLockChrome, useAppSettingsRuntime, useAppVaultRuntime, } from "./appRuntimeBridge"; import { useMonitorPanels } from "./monitorPanelsStorage"; import { monitorActions, getMonitorHistoryCursor, publishMonitorSnapshot, publishMonitorUnavailable, } from "./monitorRuntimeStore"; import type { MonitorPanelDemand } from "../../domain/monitorRuntime"; /** Root lifetime, independent of Vault navigation. No runtime state is persisted. */ export function useMonitorRuntime() { const panels = useMonitorPanels(); const { hosts, keys, identities, groupConfigs, proxyProfiles, knownHosts, isInitialized, } = useAppVaultRuntime(); const { terminalSettings } = useAppSettingsRuntime(); const { locked } = useAppLockChrome(); const [running, setRunning] = useState(() => new Map()); const [retryVersion, setRetryVersion] = useState(0); const epoch = useRef(null); const runtimeId = useRef(null); const credentials = useRef( new Map(), ); useEffect(() => { monitorActions.start = (id) => setRunning((prev) => new Map(prev).set(id, crypto.randomUUID())); monitorActions.stop = (id) => setRunning((prev) => { const next = new Map(prev); next.delete(id); return next; }); monitorActions.stopAll = () => { credentials.current.clear(); setRunning(new Map()); void netcattyBridge.get()?.monitorStopAll?.(); }; monitorActions.retry = (id, override) => { if (override) credentials.current.set(id, override); void netcattyBridge .get() ?.monitorRetry?.(id) .then(() => setRetryVersion((v) => v + 1)); }; const offline = () => monitorActions.stopAll(); window.addEventListener("offline", offline); return () => { window.removeEventListener("offline", offline); void netcattyBridge.get()?.monitorUpdate?.([]); }; }, []); useEffect(() => { if (locked || !isInitialized) { credentials.current.clear(); setRunning(new Map()); } }, [locked, isInitialized]); useEffect(() => { const bridge = netcattyBridge.get(); if (!bridge?.monitorUpdate) { publishMonitorUnavailable(); return; } const demand: MonitorPanelDemand[] = locked || !isInitialized ? [] : panels .filter((p) => running.has(p.id)) .map((panel) => ({ id: panel.id, runId: running.get(panel.id)!, interval: panel.interval, hosts: panel.hostIds.map((id) => { const host = hosts.find((h) => h.id === id); if ( !host || (host.protocol && host.protocol !== "ssh") || hostRestrictsExtraSshChannels(host) ) return { id }; const effective = resolveEffectiveTerminalHost({ host, groupConfigs, proxyProfiles, }); const plan = buildHostConnectionTestPlan({ host, hosts, keys, identities, groupConfigs, proxyProfiles, knownHosts: getEffectiveKnownHosts(knownHosts) ?? [], terminalSettings, sessionId: `monitor-${id}`, bootEpoch: 0, authOverride: credentials.current.has(id) ? { ...credentials.current.get(id), authMethod: "password" } : null, }); if (!plan.ok) return { id, status: "error" as const }; if (plan.needsCredentialReentry) return { id, status: "login" as const }; return { id, options: { ...plan.options, singleChannelSsh: hostRestrictsExtraSshChannels(effective), sshAuthReadyTimeoutMs: 120000, agentForwarding: effective.agentForwarding, }, }; }), })); const activeHostIds = new Set( demand.flatMap((p) => p.hosts.map((h) => h.id)), ); for (const id of credentials.current.keys()) if (!activeHostIds.has(id)) credentials.current.delete(id); void bridge .monitorUpdate(demand) .then(publishMonitorSnapshot) .catch(() => { credentials.current.clear(); setRunning((prev) => (prev.size ? new Map() : prev)); publishMonitorUnavailable(); }); }, [ panels, running, hosts, keys, identities, groupConfigs, proxyProfiles, knownHosts, terminalSettings, locked, isInitialized, retryVersion, ]); useEffect(() => { const bridge = netcattyBridge.get(); let disposed = false; let pending = false; const poll = async () => { if (pending || !bridge?.monitorSnapshot) return; pending = true; try { const snapshot = await bridge.monitorSnapshot(getMonitorHistoryCursor()); if (disposed) return; if ( (epoch.current !== null && epoch.current !== snapshot.epoch) || (runtimeId.current !== null && runtimeId.current !== snapshot.runtimeId) ) { credentials.current.clear(); setRunning(new Map()); } epoch.current = snapshot.epoch; runtimeId.current = snapshot.runtimeId; publishMonitorSnapshot(snapshot); } catch { credentials.current.clear(); setRunning((prev) => (prev.size ? new Map() : prev)); publishMonitorUnavailable(); } finally { pending = false; } }; void poll(); const timer = setInterval(() => { void poll(); }, 1000); return () => { disposed = true; clearInterval(timer); }; }, []); }