mirror of
https://github.com/binaricat/Netcatty.git
synced 2026-11-16 20:11:08 +00:00
Optimize terminal side panel performance, keep process status labels visible, and improve heavy panel loading behavior.
242 lines
9.0 KiB
TypeScript
242 lines
9.0 KiB
TypeScript
import { localStorageAdapter } from '../../infrastructure/persistence/localStorageAdapter';
|
|
import {
|
|
STORAGE_KEY_AI_ACTIVE_SESSION_MAP,
|
|
STORAGE_KEY_AI_SESSIONS,
|
|
} from '../../infrastructure/config/storageKeys';
|
|
import type {
|
|
AIDraft,
|
|
AIPanelView,
|
|
AISession,
|
|
AIPermissionMode,
|
|
AIToolIntegrationMode,
|
|
} from '../../infrastructure/ai/types';
|
|
import {
|
|
bumpDraftMutationVersionState,
|
|
bumpDraftUploadGenerationState,
|
|
getDraftUploadGenerationState,
|
|
} from './aiDraftState';
|
|
import {
|
|
pruneInactiveScopedSessions,
|
|
pruneInactiveScopedTransientState,
|
|
} from './aiScopeCleanup';
|
|
import { emitAIStateChanged } from './aiStateEvents';
|
|
|
|
/** Typed accessor for the Electron IPC bridge exposed on `window.netcatty`. */
|
|
export interface AIBridge {
|
|
aiSdkAgentCleanup?: (chatSessionId: string) => Promise<{ ok: boolean }>;
|
|
aiMcpSetPermissionMode?: (mode: AIPermissionMode) => Promise<unknown> | unknown;
|
|
aiMcpSetToolIntegrationMode?: (mode: AIToolIntegrationMode) => Promise<unknown> | unknown;
|
|
aiMcpSetCommandBlocklist?: (blocklist: string[]) => Promise<unknown> | unknown;
|
|
aiMcpSetCommandTimeout?: (timeout: number) => Promise<unknown> | unknown;
|
|
aiMcpSetMaxIterations?: (maxIterations: number) => Promise<unknown> | unknown;
|
|
}
|
|
|
|
export function getAIBridge() {
|
|
return (window as unknown as { netcatty?: AIBridge }).netcatty;
|
|
}
|
|
|
|
|
|
export const AI_STATE_CHANGED_DRAFTS_BY_SCOPE = 'netcatty:ai-drafts-by-scope';
|
|
export const AI_STATE_CHANGED_PANEL_VIEW_BY_SCOPE = 'netcatty:ai-panel-view-by-scope';
|
|
|
|
export type DraftsByScope = Partial<Record<string, AIDraft>>;
|
|
export type PanelViewByScope = Partial<Record<string, AIPanelView>>;
|
|
|
|
export function cleanupSdkAgentSessions(sessionIds: string[]) {
|
|
const bridge = getAIBridge();
|
|
if (!bridge?.aiSdkAgentCleanup || sessionIds.length === 0) return;
|
|
for (const sessionId of sessionIds) {
|
|
void bridge.aiSdkAgentCleanup(sessionId).catch(() => {});
|
|
}
|
|
}
|
|
|
|
function isScopeKeyActive(scopeKey: string, activeTargetIds: Set<string>) {
|
|
const separatorIndex = scopeKey.indexOf(':');
|
|
if (separatorIndex === -1) return true;
|
|
|
|
const targetId = scopeKey.slice(separatorIndex + 1);
|
|
if (!targetId) return true;
|
|
|
|
return activeTargetIds.has(targetId);
|
|
}
|
|
|
|
export function cleanupOrphanedAISessions(activeTargetIds: Set<string>) {
|
|
const currentSessions = latestAISessionsSnapshot
|
|
?? localStorageAdapter.read<AISession[]>(STORAGE_KEY_AI_SESSIONS)
|
|
?? [];
|
|
|
|
// Sessions shown by a still-live scope must be protected from cleanup
|
|
// even when their own `scope.targetId` points at a closed terminal —
|
|
// history can be resumed into a different terminal and we must not
|
|
// delete it outright while it's actively being used.
|
|
const preCleanupActiveSessionMap = latestAIActiveSessionMapSnapshot
|
|
?? localStorageAdapter.read<Record<string, string | null>>(STORAGE_KEY_AI_ACTIVE_SESSION_MAP)
|
|
?? {};
|
|
const activeSessionIds = new Set<string>();
|
|
for (const [scopeKey, sessionId] of Object.entries(preCleanupActiveSessionMap)) {
|
|
if (!sessionId) continue;
|
|
if (!isScopeKeyActive(scopeKey, activeTargetIds)) continue;
|
|
activeSessionIds.add(sessionId);
|
|
}
|
|
|
|
const nextSessionCleanup = pruneInactiveScopedSessions(
|
|
currentSessions,
|
|
activeTargetIds,
|
|
activeSessionIds,
|
|
);
|
|
|
|
if (nextSessionCleanup.orphanedSessionIds.length > 0) {
|
|
cleanupSdkAgentSessions(nextSessionCleanup.orphanedSessionIds);
|
|
}
|
|
|
|
if (nextSessionCleanup.sessions !== currentSessions) {
|
|
setLatestAISessionsSnapshot(nextSessionCleanup.sessions);
|
|
localStorageAdapter.write(
|
|
STORAGE_KEY_AI_SESSIONS,
|
|
pruneSessionsForStorage(nextSessionCleanup.sessions),
|
|
);
|
|
emitAIStateChanged(STORAGE_KEY_AI_SESSIONS);
|
|
}
|
|
|
|
const activeSessionIdMap = preCleanupActiveSessionMap;
|
|
let activeSessionMapChanged = false;
|
|
const nextActiveSessionIdMap = { ...activeSessionIdMap };
|
|
|
|
for (const scopeKey of Object.keys(activeSessionIdMap)) {
|
|
if (isScopeKeyActive(scopeKey, activeTargetIds)) continue;
|
|
delete nextActiveSessionIdMap[scopeKey];
|
|
activeSessionMapChanged = true;
|
|
}
|
|
|
|
if (activeSessionMapChanged) {
|
|
setLatestAIActiveSessionMapSnapshot(nextActiveSessionIdMap);
|
|
localStorageAdapter.write(STORAGE_KEY_AI_ACTIVE_SESSION_MAP, nextActiveSessionIdMap);
|
|
emitAIStateChanged(STORAGE_KEY_AI_ACTIVE_SESSION_MAP);
|
|
}
|
|
|
|
const currentActiveSessionIdMap = activeSessionMapChanged
|
|
? nextActiveSessionIdMap
|
|
: activeSessionIdMap;
|
|
const currentDraftsByScope = latestAIDraftsByScopeSnapshot ?? {};
|
|
const currentPanelViewByScope = latestAIPanelViewByScopeSnapshot ?? {};
|
|
const prunedScopedTransientState = pruneInactiveScopedTransientState(
|
|
currentActiveSessionIdMap,
|
|
currentDraftsByScope,
|
|
currentPanelViewByScope,
|
|
activeTargetIds,
|
|
);
|
|
|
|
if (prunedScopedTransientState.activeSessionIdMap !== currentActiveSessionIdMap) {
|
|
setLatestAIActiveSessionMapSnapshot(prunedScopedTransientState.activeSessionIdMap);
|
|
localStorageAdapter.write(
|
|
STORAGE_KEY_AI_ACTIVE_SESSION_MAP,
|
|
prunedScopedTransientState.activeSessionIdMap,
|
|
);
|
|
emitAIStateChanged(STORAGE_KEY_AI_ACTIVE_SESSION_MAP);
|
|
}
|
|
|
|
if (prunedScopedTransientState.draftsByScope !== currentDraftsByScope) {
|
|
for (const scopeKey of Object.keys(currentDraftsByScope)) {
|
|
if (scopeKey in prunedScopedTransientState.draftsByScope) continue;
|
|
bumpDraftMutationVersion(scopeKey);
|
|
bumpDraftUploadGeneration(scopeKey);
|
|
}
|
|
setLatestAIDraftsByScopeSnapshot(prunedScopedTransientState.draftsByScope);
|
|
emitAIStateChanged(AI_STATE_CHANGED_DRAFTS_BY_SCOPE);
|
|
}
|
|
|
|
if (prunedScopedTransientState.panelViewByScope !== currentPanelViewByScope) {
|
|
for (const scopeKey of Object.keys(currentPanelViewByScope)) {
|
|
if (scopeKey in prunedScopedTransientState.panelViewByScope) continue;
|
|
bumpDraftMutationVersion(scopeKey);
|
|
}
|
|
setLatestAIPanelViewByScopeSnapshot(prunedScopedTransientState.panelViewByScope);
|
|
emitAIStateChanged(AI_STATE_CHANGED_PANEL_VIEW_BY_SCOPE);
|
|
}
|
|
}
|
|
|
|
|
|
/** Maximum number of sessions to keep in localStorage. */
|
|
const MAX_STORED_SESSIONS = 50;
|
|
/** Maximum number of messages per session when persisting to localStorage. */
|
|
const MAX_SESSION_MESSAGES = 200;
|
|
|
|
/**
|
|
* Prune sessions before writing to localStorage to prevent hitting the
|
|
* ~5-10 MB storage quota. Only affects what is persisted — the in-memory
|
|
* state retains all messages until the session is reloaded.
|
|
*
|
|
* - Keeps only the MAX_STORED_SESSIONS most-recently-updated sessions.
|
|
* - Trims each session's messages to the last MAX_SESSION_MESSAGES.
|
|
*/
|
|
export function pruneSessionsForStorage(sessions: AISession[]): AISession[] {
|
|
// Sort by updatedAt descending so we keep the newest
|
|
const sorted = [...sessions].sort((a, b) => b.updatedAt - a.updatedAt);
|
|
const limited = sorted.slice(0, MAX_STORED_SESSIONS);
|
|
return limited.map(s => {
|
|
if (s.messages.length > MAX_SESSION_MESSAGES) {
|
|
return { ...s, messages: s.messages.slice(-MAX_SESSION_MESSAGES) };
|
|
}
|
|
return s;
|
|
});
|
|
}
|
|
|
|
export let latestAISessionsSnapshot: AISession[] | null = null;
|
|
export let latestAIActiveSessionMapSnapshot: Record<string, string | null> | null = null;
|
|
export let latestAIDraftsByScopeSnapshot: DraftsByScope | null = null;
|
|
export let latestAIPanelViewByScopeSnapshot: PanelViewByScope | null = null;
|
|
let latestAIDraftMutationVersionByScopeSnapshot: Record<string, number> = {};
|
|
let latestAIDraftUploadGenerationByScopeSnapshot: Record<string, number> = {};
|
|
|
|
export function setLatestAISessionsSnapshot(sessions: AISession[]) {
|
|
latestAISessionsSnapshot = sessions;
|
|
}
|
|
|
|
export function setLatestAIActiveSessionMapSnapshot(activeSessionIdMap: Record<string, string | null>) {
|
|
latestAIActiveSessionMapSnapshot = activeSessionIdMap;
|
|
}
|
|
|
|
export function prewarmAIStateStorageSnapshots() {
|
|
try {
|
|
if (latestAISessionsSnapshot === null) {
|
|
latestAISessionsSnapshot =
|
|
localStorageAdapter.read<AISession[]>(STORAGE_KEY_AI_SESSIONS) ?? [];
|
|
}
|
|
if (latestAIActiveSessionMapSnapshot === null) {
|
|
latestAIActiveSessionMapSnapshot =
|
|
localStorageAdapter.read<Record<string, string | null>>(STORAGE_KEY_AI_ACTIVE_SESSION_MAP) ?? {};
|
|
}
|
|
} catch (error) {
|
|
console.warn('[AIState] Failed to prewarm AI state storage snapshots:', error);
|
|
}
|
|
}
|
|
|
|
export function setLatestAIDraftsByScopeSnapshot(draftsByScope: DraftsByScope) {
|
|
latestAIDraftsByScopeSnapshot = draftsByScope;
|
|
}
|
|
|
|
export function setLatestAIPanelViewByScopeSnapshot(panelViewByScope: PanelViewByScope) {
|
|
latestAIPanelViewByScopeSnapshot = panelViewByScope;
|
|
}
|
|
|
|
export function bumpDraftMutationVersion(scopeKey: string) {
|
|
latestAIDraftMutationVersionByScopeSnapshot = bumpDraftMutationVersionState(
|
|
latestAIDraftMutationVersionByScopeSnapshot,
|
|
scopeKey,
|
|
);
|
|
}
|
|
|
|
export function getDraftUploadGeneration(scopeKey: string) {
|
|
return getDraftUploadGenerationState(
|
|
latestAIDraftUploadGenerationByScopeSnapshot,
|
|
scopeKey,
|
|
);
|
|
}
|
|
|
|
export function bumpDraftUploadGeneration(scopeKey: string) {
|
|
latestAIDraftUploadGenerationByScopeSnapshot = bumpDraftUploadGenerationState(
|
|
latestAIDraftUploadGenerationByScopeSnapshot,
|
|
scopeKey,
|
|
);
|
|
}
|