mirror of
https://github.com/binaricat/Netcatty.git
synced 2026-11-17 04:50:52 +00:00
* fix(terminal): soft-hide the tab that just left when hibernate keep is full Evict the oldest soft-hidden session to a full snapshot, and keep the session the user just left on hideRuntimeOnly. Disconnected sessions, alternate screen, and inline images keep their existing branches. Wake replay order is unchanged. Co-authored-by: 陈大猫 <binaricat@users.noreply.github.com> * fix(terminal): full-hibernate when keep-count eviction is refused A soft-hidden session with inline images consumes the eviction request and stays mounted. Soft-hiding the tab that just left anyway let that protected session pin the oldest slot, so every later tab was retained too. Walk oldest-first, keep the leaving tab soft-hidden only after one victim actually leaves the set, and full-hibernate it when none can. Co-authored-by: 陈大猫 <binaricat@users.noreply.github.com> * fix(terminal): retain a leaving tab only after eviction hibernates Waking a soft-hidden victim clears its marker before fullHibernateRuntime finishes. Treating that as success soft-hid the tab that just left even when drain, snapshot, or alternate-screen failure restored the victim. Await hibernate completion outside the pure keep-count helper, and put a failed victim back in the soft-hidden set so it stays a candidate. Co-authored-by: 陈大猫 <binaricat@users.noreply.github.com> * fix(terminal): reserve hibernate slots outside domain policy Keep the keep-count decision pure. The application walk reserves the leaving tab before awaiting a victim, rechecks that slot before soft-hide, and does not restore a victim that became visible or had hibernate turned off while the upgrade was in flight. Co-authored-by: 陈大猫 <binaricat@users.noreply.github.com> --------- Co-authored-by: Cursor Agent <cursoragent@cursor.com> Co-authored-by: 陈大猫 <binaricat@users.noreply.github.com>
159 lines
5.3 KiB
TypeScript
159 lines
5.3 KiB
TypeScript
type Listener = () => void;
|
|
|
|
const softHiddenSessions = new Map<string, number>();
|
|
const listeners = new Set<Listener>();
|
|
let evictionRequestSessionId: string | null = null;
|
|
/** Leaving tabs that have claimed a keep slot while a victim hibernate is in flight. */
|
|
const reservedLeavingSlots = new Map<string, number>();
|
|
let reservationToken = 0;
|
|
|
|
function reservedLeavingCount(): number {
|
|
let extra = 0;
|
|
for (const sessionId of reservedLeavingSlots.keys()) {
|
|
if (!softHiddenSessions.has(sessionId)) extra += 1;
|
|
}
|
|
return extra;
|
|
}
|
|
|
|
type EvictionWaiter = {
|
|
promise: Promise<boolean>;
|
|
resolve: (completed: boolean) => void;
|
|
settled: boolean;
|
|
};
|
|
|
|
const evictionWaiters = new Map<string, EvictionWaiter>();
|
|
|
|
function finishEviction(sessionId: string, completed: boolean): void {
|
|
const waiter = evictionWaiters.get(sessionId);
|
|
if (!waiter || waiter.settled) return;
|
|
waiter.settled = true;
|
|
evictionWaiters.delete(sessionId);
|
|
if (evictionRequestSessionId === sessionId) evictionRequestSessionId = null;
|
|
waiter.resolve(completed);
|
|
}
|
|
|
|
function emit(): void {
|
|
listeners.forEach((listener) => listener());
|
|
}
|
|
|
|
function listSoftHiddenOldestFirst(): string[] {
|
|
return [...softHiddenSessions.entries()]
|
|
.sort((left, right) => left[1] - right[1])
|
|
.map(([sessionId]) => sessionId);
|
|
}
|
|
|
|
export const terminalHiddenRendererStore = {
|
|
getSoftHiddenCount: () => softHiddenSessions.size,
|
|
|
|
/**
|
|
* Soft-hidden markers plus leaving tabs that reserved a slot and are not
|
|
* yet in the marker set. Keep-count decisions use this so a second timer
|
|
* cannot take the slot a pending eviction already claimed.
|
|
*/
|
|
getSoftHiddenOccupancy: () => softHiddenSessions.size + reservedLeavingCount(),
|
|
|
|
/**
|
|
* Claim one keep slot for a leaving tab before awaiting eviction.
|
|
* A session already in the marker set is not counted twice. A later claim
|
|
* for the same id replaces the token; only that token can release it.
|
|
*/
|
|
reserveLeavingSlot: (sessionId: string): number => {
|
|
const token = ++reservationToken;
|
|
if (sessionId && !softHiddenSessions.has(sessionId)) {
|
|
reservedLeavingSlots.set(sessionId, token);
|
|
}
|
|
return token;
|
|
},
|
|
|
|
releaseLeavingSlot: (sessionId: string, token: number) => {
|
|
if (reservedLeavingSlots.get(sessionId) === token) {
|
|
reservedLeavingSlots.delete(sessionId);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* True when retaining this leaving tab would stay within keepCount.
|
|
* Its own reservation is not counted against the slots held by others.
|
|
*/
|
|
leavingSlotStillFits: (sessionId: string, keepCount: number): boolean => {
|
|
if (!(keepCount > 0)) return false;
|
|
const reservedHere = reservedLeavingSlots.has(sessionId) && !softHiddenSessions.has(sessionId);
|
|
const others = softHiddenSessions.size + reservedLeavingCount() - (reservedHere ? 1 : 0);
|
|
return others < keepCount;
|
|
},
|
|
|
|
isSoftHidden: (sessionId: string) => softHiddenSessions.has(sessionId),
|
|
|
|
markSoftHidden: (sessionId: string) => {
|
|
softHiddenSessions.set(sessionId, Date.now());
|
|
emit();
|
|
},
|
|
|
|
clearSoftHidden: (sessionId: string) => {
|
|
if (!softHiddenSessions.delete(sessionId)) return;
|
|
emit();
|
|
},
|
|
|
|
listSoftHiddenOldestFirst: (): string[] => listSoftHiddenOldestFirst(),
|
|
|
|
/** Returns the oldest soft-hidden session id when over the keep limit. */
|
|
pickEvictionCandidate: (keepCount: number): string | null => {
|
|
if (softHiddenSessions.size < keepCount) return null;
|
|
return listSoftHiddenOldestFirst()[0] ?? null;
|
|
},
|
|
|
|
requestEviction: (sessionId: string) => {
|
|
evictionRequestSessionId = sessionId;
|
|
emit();
|
|
},
|
|
|
|
/** True while this session's hibernate has been requested and not settled. */
|
|
hasPendingEviction: (sessionId: string): boolean => {
|
|
const waiter = evictionWaiters.get(sessionId);
|
|
return waiter != null && !waiter.settled;
|
|
},
|
|
|
|
/**
|
|
* Ask one soft-hidden session to upgrade. Resolves true only when
|
|
* settleEviction reports that hibernation finished. Clearing the marker
|
|
* during wake is not success: drain, snapshot, or alternate-screen failure
|
|
* can still restore that renderer. A synchronous refusal (marker still
|
|
* present, including inline images) resolves false and drops an unconsumed
|
|
* request so a later emit cannot upgrade it.
|
|
*/
|
|
evictSoftHidden: (sessionId: string): Promise<boolean> => {
|
|
const existing = evictionWaiters.get(sessionId);
|
|
if (existing) return existing.promise;
|
|
if (!softHiddenSessions.has(sessionId)) return Promise.resolve(false);
|
|
|
|
let resolvePromise!: (completed: boolean) => void;
|
|
const promise = new Promise<boolean>((resolve) => {
|
|
resolvePromise = resolve;
|
|
});
|
|
const waiter: EvictionWaiter = { promise, resolve: resolvePromise, settled: false };
|
|
evictionWaiters.set(sessionId, waiter);
|
|
evictionRequestSessionId = sessionId;
|
|
emit();
|
|
if (!waiter.settled && softHiddenSessions.has(sessionId)) {
|
|
finishEviction(sessionId, false);
|
|
}
|
|
return promise;
|
|
},
|
|
|
|
/** Record whether the in-flight eviction's hibernate actually completed. */
|
|
settleEviction: (sessionId: string, completed: boolean) => {
|
|
finishEviction(sessionId, completed);
|
|
},
|
|
|
|
consumeEvictionRequest: (sessionId: string): boolean => {
|
|
if (evictionRequestSessionId !== sessionId) return false;
|
|
evictionRequestSessionId = null;
|
|
return true;
|
|
},
|
|
|
|
subscribe: (listener: Listener) => {
|
|
listeners.add(listener);
|
|
return () => listeners.delete(listener);
|
|
},
|
|
};
|