Files
Netcatty/components/terminal/connectionTicker.ts
T
陈大猫andClaude Opus 5.5 fa554888a6 perf(terminal): stop per-second churn while connecting and while idle (#4118)
* perf(terminal): stop per-second churn while connecting and while idle

- Connecting sessions: the 200 ms progress animation and 1 s countdown were
  Terminal state threaded into the TerminalView ctx, so every connecting
  session (hidden tabs and startup restores included) re-rendered Terminal +
  TerminalView up to six times a second. Terminal now only publishes the
  timeout deadline and real progress events; the connection dialog animates
  and counts down locally (connectionTicker.ts). HostConnectionTestDialog
  keeps passing progress/timeLeft as before.
- Monitor runtime: polled every second unconditionally and woke every
  subscriber each time because takenAt always changes. It now polls at 1 s
  only while something is monitored (here or in another window), 10 s
  otherwise, and skips notifying for unchanged idle replies.
- Auto-reconnect progress log: capped at the newest 300 lines (it grew by a
  few lines every 5 s retry for as long as an outage lasted).
- App Lock: report activity at most once a second instead of an IPC per
  keystroke / wheel tick / pointer event.
- Tray/Dock: the renderer resends hosts only when the host list changed, and
  the main process rebuilds the macOS Dock menu (sort + one native item per
  host) only then, not on every session status change.

Real app, profiling build, main -> this change:
  3 SSH sessions connecting (3 s)   14 commits / 35.3 ms -> 8 / 1.7 ms
  idle (10 s)                       13 commits / 3.1 ms  -> 2 / 0.1 ms

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(terminal): update observe-popup reconnect deps assertion for capped progress logs

CI failed because #4118 wrapped setProgressLogs in useCallback to apply
capConnectionProgressLogs and added it to scheduleAutoReconnect deps.
The observe-popup source assertion still expected the old deps list.

The attachExistingSession early-return behavior is unchanged; only the
stale dependency regex needed updating.

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-04 01:11:25 -08:00

56 lines
2.1 KiB
TypeScript

import { useEffect, useRef, useState } from 'react';
import { advanceIndeterminateConnectionProgress } from './connectionProgress';
/**
* Indeterminate connection progress, animated locally by the connection dialog.
*
* The 200 ms animation used to live in Terminal state, which re-rendered the
* whole Terminal + TerminalView (~45 ms) five times a second for every
* connecting session, hidden tabs and startup restores included. Terminal now
* only publishes real progress events (`baseValue`); this hook animates from
* there while `animating` and never moves backwards, except when the base
* itself drops (a new connection attempt restarts the bar).
*/
export function useAnimatedConnectionProgress(baseValue: number, animating: boolean): number {
const [value, setValue] = useState(baseValue);
const lastBaseRef = useRef(baseValue);
useEffect(() => {
const previousBase = lastBaseRef.current;
lastBaseRef.current = baseValue;
setValue((current) => (baseValue < previousBase ? baseValue : Math.max(current, baseValue)));
}, [baseValue]);
useEffect(() => {
if (!animating) return undefined;
const timer = setInterval(() => {
setValue(advanceIndeterminateConnectionProgress);
}, 200);
return () => clearInterval(timer);
}, [animating]);
return value;
}
const secondsUntil = (deadlineAt: number): number =>
Math.max(0, Math.ceil((deadlineAt - Date.now()) / 1000));
/**
* Seconds left until `deadlineAt`, ticking locally once a second. With no
* deadline (timer stopped, e.g. while waiting for user input) the last value
* is kept, matching the countdown that used to stop with its interval.
*/
export function useConnectionCountdownSeconds(deadlineAt: number | null, initialSeconds: number): number {
const [seconds, setSeconds] = useState(() => (deadlineAt == null ? initialSeconds : secondsUntil(deadlineAt)));
useEffect(() => {
if (deadlineAt == null) return undefined;
setSeconds(secondsUntil(deadlineAt));
const timer = setInterval(() => setSeconds(secondsUntil(deadlineAt)), 1000);
return () => clearInterval(timer);
}, [deadlineAt]);
return seconds;
}