Files
Netcatty/application/app/useAppStartupEffects.ts
T
de3d679a36 fix(quit): don't freeze the main process when the user keeps unfinished transfers (#3821)
* fix(quit): don't freeze the main process when the user keeps unfinished transfers

Quitting with an unfinished transfer pauses it and asks for confirmation in the
renderer. Declining was reported to main as "dirty editors", so
handleBeforeQuit raised a synchronous "Unsaved changes" message box. That box
blocks the whole main process (IPC, every SFTP transfer) until it is dismissed,
names editors that do not exist, and the paused transfer was never resumed.

The renderer now reports the refusal with reason "transfers" and resumes the
tasks it paused for the prompt; main keeps the quit cancelled but skips the
native editor dialog for that case. Real unsaved editors behave as before.

* fix(quit): report a transfer refusal before resuming

A slow resume could miss the 5s dirty-check timeout and let the app
quit anyway. Reply with reason "transfers" first, then resume only the
rows that were transferring or queued before the prompt paused them.

Co-authored-by: 陈大猫 <binaricat@users.noreply.github.com>

---------

Co-authored-by: campaign <campaign@local>
Co-authored-by: Cursor Agent <cursoragent@cursor.com>
Co-authored-by: 陈大猫 <binaricat@users.noreply.github.com>
2026-10-21 18:45:18 +08:00

608 lines
27 KiB
TypeScript

/* eslint-disable @typescript-eslint/no-explicit-any */
import { useEffect, useRef } from 'react';
import { usePortForwardingAutoStart } from '../state/usePortForwardingAutoStart';
import { editorTabStore } from '../state/editorTabStore';
import { netcattyBridge } from '../../infrastructure/services/netcattyBridge';
import { localStorageAdapter } from '../../infrastructure/persistence/localStorageAdapter';
import { toast } from '../../components/ui/toast';
import { sftpTransferCenterStore } from '../state/sftpTransferCenterStore';
import { resumeTransferWithDedicatedSession } from '../state/sftp/dedicatedTransferResume';
import { getSftpTransferResourceKeys, globalSftpTransferScheduler } from '../state/sftp/globalTransferScheduler';
import { hasNewSourceFingerprint } from '../state/sftp/transferProgressMetadata';
import { STORAGE_KEY_SFTP_TRANSFER_CONCURRENCY } from '../../infrastructure/config/storageKeys';
import type { TransferTask } from '../../domain/models';
import { isTerminalBootEpochCurrent } from '../../domain/terminalBootEpoch';
import {
canApplyDedicatedResumeProgress,
createDedicatedResumeChildUpdateBatcher,
createDedicatedResumeProgressBatcher,
} from './dedicatedResumeProgress';
type StartupEffectsContext = Record<string, any>;
type KeyboardInteractiveScope = "terminal" | "external";
type KeyboardInteractiveRequestLike = {
scope?: KeyboardInteractiveScope;
sessionId?: string;
hostId?: string;
requestId?: string;
bootEpoch?: number;
};
type SessionIdLike = { id: string; hostId?: string; hostname?: string; status?: string };
type KeyboardInteractiveQueueItem = { requestId: string };
export function shouldQueueKeyboardInteractiveRequest(
request: KeyboardInteractiveRequestLike,
sessions: SessionIdLike[],
): boolean {
if (request.scope !== "terminal") return true;
if (!request.sessionId) return false;
const session = sessions.find((entry) => entry.id === request.sessionId);
if (!session) return false;
// Status-bar disconnect keeps the tab; do not queue MFA for aborted panes.
if (session.status === "disconnected") return false;
// After disconnect → reconnect the tab is connecting again; reject MFA from
// a superseded SSH start that still shares this sessionId.
if (!isTerminalBootEpochCurrent(request.sessionId, request.bootEpoch)) return false;
return true;
}
export function removeKeyboardInteractiveRequest<T extends KeyboardInteractiveQueueItem>(
queue: T[],
requestId: string,
): T[] {
return queue.filter(request => request.requestId !== requestId);
}
export function useAppStartupEffects(ctx: StartupEffectsContext) {
const {dismissUpdate, enabled = true, groupConfigs, hosts, resumeHosts, identities,
hasRuntimeTunnel, installUpdate, isVaultInitialized, keys, knownHosts, openSettingsWindow, portForwardingRules, proxyProfiles, sessions, setKeyboardInteractiveQueue,
t, terminalSettings, updateState, workspaces,
} = ctx;
// Vault hosts for tray/menu; resumeHosts may include ephemeral quick-connect rows.
const dedicatedResumeHosts = resumeHosts ?? hosts;
const sessionsRef = useRef(sessions);
useEffect(() => {
sessionsRef.current = sessions;
}, [sessions]);
// After app restart (or soft-resume miss), unfinished transfers reconnect via
// a dedicated SFTP session. Prefer resumeHosts (vault + ephemeral) so
// quick-connect transfers can re-auth without "Cannot find host in your vault".
useEffect(() => {
if (!enabled || !isVaultInitialized) {
sftpTransferCenterStore.setDedicatedResumeHandler(null);
return;
}
sftpTransferCenterStore.setDedicatedResumeHandler(async (task) => {
// Keep reconnectRequired true until the first progress/completion so the
// play control stays a spinner during auth + session setup.
sftpTransferCenterStore.patchTask(task.id, {
status: "pending",
error: undefined,
reconnectRequired: true,
speed: 0,
phase: undefined,
});
const children = sftpTransferCenterStore.getSnapshot().tasks.filter(
(row) => row.parentTaskId === task.id,
);
// rAF-coalesce progress so dedicated resume does not flood the global center.
type ProgressSample = {
transferred: number;
total: number;
speed: number;
checkpointBytes?: number;
resumeStage?: TransferTask["resumeStage"];
downloadCheckpointBytes?: number;
uploadCheckpointBytes?: number;
sourceFingerprint?: string;
};
// One rAF coalesce only — main process already time-throttles IPC.
// A second 500ms timer here made dedicated-resume bars jump.
const applyProgress = (progress: ProgressSample) => {
const current = sftpTransferCenterStore.getSnapshot().tasks.find((row) => row.id === task.id);
if (!current || current.status === "cancelled") return;
if (current.status === "pausing" || current.status === "paused") {
if (hasNewSourceFingerprint(current.sourceFingerprint, progress.sourceFingerprint)) {
sftpTransferCenterStore.patchTask(task.id, { sourceFingerprint: progress.sourceFingerprint });
}
return;
}
// The final sample can still be queued in requestAnimationFrame after
// the resume promise settles. Never let it turn a completed/failed row
// back into a permanently "transferring" task.
if (!canApplyDedicatedResumeProgress(current.status)) return;
// Directory parents use file-count progress; single files use bytes.
// Prefer durable contiguous checkpoint when the bridge supplies it.
const durableCheckpoint = task.isDirectory
? progress.transferred
: (progress.checkpointBytes ?? progress.transferred);
// Keep progress monotonic so a late force-checkpoint paint cannot hide
// later bytes, and the bar never freezes at the pre-quit offset.
const nextTransferred = Math.max(current.transferredBytes ?? 0, progress.transferred);
const nextCheckpoint = task.isDirectory
? Math.max(current.checkpointBytes ?? 0, progress.transferred)
: Math.max(current.checkpointBytes ?? 0, durableCheckpoint);
sftpTransferCenterStore.patchTask(task.id, {
status: "transferring",
transferredBytes: nextTransferred,
...(progress.total > 0 ? { totalBytes: progress.total } : {}),
speed: progress.speed,
...(task.isDirectory
? { checkpointBytes: nextCheckpoint, progressMode: "files" as const }
: {
checkpointBytes: nextCheckpoint,
resumeStage: progress.resumeStage,
downloadCheckpointBytes: progress.downloadCheckpointBytes,
uploadCheckpointBytes: progress.uploadCheckpointBytes,
sourceFingerprint: progress.sourceFingerprint,
}),
reconnectRequired: false,
error: undefined,
phase: "transferring",
ownerId: "dedicated-resume",
});
};
const progressBatcher = createDedicatedResumeProgressBatcher<ProgressSample>({
requestFrame: (callback) => window.requestAnimationFrame(callback),
cancelFrame: (handle) => window.cancelAnimationFrame(handle),
canApply: () => {
const current = sftpTransferCenterStore.getSnapshot().tasks.find((row) => row.id === task.id);
return !!current && canApplyDedicatedResumeProgress(current.status);
},
apply: applyProgress,
});
const childUpdateBatcher = createDedicatedResumeChildUpdateBatcher({
// Use the restart snapshot, not repeated linear store lookups. Completed
// rows disappear as batches compact, but later updates for those ids can
// still stay in the same bounded batching path safely.
getTaskCount: () => children.length + 1,
hasTask: (() => {
const retainedChildIds = new Set(children.map((child) => child.id));
return (taskId: string) => retainedChildIds.has(taskId);
})(),
upsertTasks: (updates) => sftpTransferCenterStore.upsertTasks(updates),
});
let acceptsResumeCallbacks = true;
try {
return await resumeTransferWithDedicatedSession(
task,
{
hosts: dedicatedResumeHosts,
keys,
identities,
knownHosts,
terminalSettings,
},
(progress) => {
if (acceptsResumeCallbacks) progressBatcher.push(progress);
},
{
children,
onChildUpdate: (child, observation) => {
if (acceptsResumeCallbacks) {
childUpdateBatcher.push({ ...child, ownerId: "dedicated-resume" }, observation);
return true;
}
},
onChildSuperseded: (taskId) => childUpdateBatcher.discard(taskId),
flushChildUpdates: () => childUpdateBatcher.flush(),
onDirectoryCheckpointUpdate: (checkpoint) => {
if (acceptsResumeCallbacks) {
sftpTransferCenterStore.patchTask(task.id, {
directoryResumeCheckpoint: checkpoint,
});
}
},
shouldAbort: () => {
const current = sftpTransferCenterStore.getSnapshot().tasks.find((row) => row.id === task.id);
// interrupted is the pre-reconnect persisted state — do not abort a
// live dedicated walk just because children/parent still show it.
return !current
|| current.status === "cancelled"
|| current.status === "paused";
},
},
);
} finally {
acceptsResumeCallbacks = false;
progressBatcher.finish();
childUpdateBatcher.flush();
}
});
return () => sftpTransferCenterStore.setDedicatedResumeHandler(null);
}, [dedicatedResumeHosts, enabled, identities, isVaultInitialized, keys, knownHosts, terminalSettings]);
// Show toast notification when update is available (only when auto-download is idle)
const toastedUpdateVersionRef = useRef<string | null>(null);
useEffect(() => {
if (!enabled) return;
// Skip "update available" toast if auto-download has already started or completed
if (updateState.autoDownloadStatus !== 'idle') return;
// Don't show automatic notification when auto-update is disabled
if (localStorageAdapter.readString('netcatty_auto_update_enabled_v1') === 'false') return;
if (updateState.hasUpdate && updateState.latestRelease) {
const version = updateState.latestRelease.version;
if (toastedUpdateVersionRef.current === version) return;
toastedUpdateVersionRef.current = version;
toast.info(
t('update.available.message', { version }),
{
title: t('update.available.title'),
duration: 8000, // Show longer for update notifications
onClick: () => {
void openSettingsWindow();
// Dismiss the update so the toast doesn't re-fire on every render.
// On unsupported platforms (where autoDownloadStatus stays 'idle')
// this is the only way to suppress the notification for this version.
// On supported platforms this toast only shows before auto-download
// starts, and the Settings window's own useUpdateCheck will pick up
// the download state via IPC events independently of the dismiss.
dismissUpdate();
},
actionLabel: t('update.viewInSettings'),
}
);
}
}, [enabled, updateState.hasUpdate, updateState.latestRelease, updateState.autoDownloadStatus, t, openSettingsWindow, dismissUpdate]);
// Track previous autoDownloadStatus so toast effects fire only on actual transitions,
// not when unrelated deps (installUpdate, openSettingsWindow) change their reference.
const prevAutoDownloadStatusRef = useRef(updateState.autoDownloadStatus);
useEffect(() => {
if (!enabled) return;
const prev = prevAutoDownloadStatusRef.current;
prevAutoDownloadStatusRef.current = updateState.autoDownloadStatus;
if (prev === updateState.autoDownloadStatus) return;
if (updateState.autoDownloadStatus === 'ready') {
const version = updateState.latestRelease?.version ?? '';
toast.info(
t('update.readyToInstall.message', { version }),
{
title: t('update.readyToInstall.title'),
duration: 0,
actionLabel: t('update.restartNow'),
onClick: () => installUpdate(),
}
);
} else if (updateState.autoDownloadStatus === 'error') {
toast.error(
t('update.downloadFailed.message'),
{
title: t('update.downloadFailed.title'),
actionLabel: t('update.viewInSettings'),
onClick: () => void openSettingsWindow(),
}
);
}
}, [enabled, updateState.autoDownloadStatus, updateState.latestRelease?.version, t, installUpdate, openSettingsWindow]);
// Auto-start port forwarding rules on app launch
usePortForwardingAutoStart({
enabled,
isVaultInitialized,
hosts,
keys,
identities,
knownHosts,
proxyProfiles,
groupConfigs,
terminalSettings,
});
// Sync tray menu data + handle tray actions
useEffect(() => {
if (!enabled) return;
const bridge = netcattyBridge.get();
if (!bridge?.updateTrayMenuData) return;
let cancelled = false;
const timer = setTimeout(() => {
if (cancelled) return;
const sessionsForTray = sessions.map((s) => {
const ws = s.workspaceId ? workspaces.find((w) => w.id === s.workspaceId) : undefined;
return {
id: s.id,
label: s.hostname,
hostLabel: s.hostLabel,
status: s.status,
workspaceId: s.workspaceId,
workspaceTitle: ws?.title,
aiHidden: s.hiddenFromTabs === true,
};
});
const hostsForSystemMenu = hosts
.filter((host: any) => typeof host?.id === "string" && host.id.length > 0)
.map((host: any) => ({
id: host.id,
label: host.label,
hostname: host.hostname,
group: host.group,
pinned: host.pinned,
lastConnectedAt: host.lastConnectedAt,
protocol: host.protocol,
}));
void bridge.updateTrayMenuData({
sessions: sessionsForTray,
portForwardRules: portForwardingRules.map((rule: any) => ({
...rule,
canStop: hasRuntimeTunnel(rule.id),
})),
hosts: hostsForSystemMenu,
});
}, 250);
return () => {
cancelled = true;
clearTimeout(timer);
};
}, [enabled, hasRuntimeTunnel, hosts, sessions, portForwardingRules, workspaces]);
// Quit guard: block app exit while any editor tab has unsaved changes.
// Main process sends "app:query-dirty-editors"; we respond with the result.
useEffect(() => {
const bridge = netcattyBridge.get();
if (!bridge?.onCheckDirtyEditors) return;
const unsub = bridge.onCheckDirtyEditors(async () => {
// Always report SOMETHING so the main process doesn't time out for
// 5 s on an unhandled exception. If we can't determine the state,
// fail open — losing unsaved work is bad, but stranding the user
// on a slow quit and then quitting anyway after the timeout is
// exactly the same outcome.
let hasDirty = false;
let reason: "editors" | "transfers" | undefined;
// Captured before pause. Only transferring/queued rows were active
// because of this prompt.
let tasksToResume: { id: string }[] = [];
try {
// Pending handoffs retain source contents; accepted handoffs clear them.
hasDirty = editorTabStore.getTabs().some((tab) => tab.content !== tab.baselineContent);
if (hasDirty) {
reason = "editors";
toast.warning(t('sftp.editor.quitBlockedByDirty'), 'SFTP');
}
if (!hasDirty) {
const unfinishedTasks = sftpTransferCenterStore.getSnapshot().tasks.filter((task) => (
!task.parentTaskId && !["completed", "failed", "cancelled"].includes(task.status)
));
if (unfinishedTasks.length > 0) {
const resumable = unfinishedTasks.filter((task) => (
task.status === "transferring" || task.status === "queued"
));
await Promise.allSettled(unfinishedTasks.map((task) => sftpTransferCenterStore.pause(task.id)));
hasDirty = !window.confirm(t('sftp.transferCenter.quitConfirm', { count: unfinishedTasks.length }));
if (hasDirty) {
// The user chose to stay. Main must hear that before any resume:
// resume can outlive the 5s dirty-check timeout, and a late reply
// lets the app quit anyway. The synchronous dialog is also skipped
// because this prompt was already answered.
reason = "transfers";
tasksToResume = resumable;
}
}
}
} catch (err) {
console.error('[App] dirty-editors check failed:', err);
}
try {
bridge.reportDirtyEditorsResult?.(hasDirty, reason);
} catch (err) {
// Reporting itself shouldn't throw, but if the IPC bridge is in a
// bad state we'd rather log than bubble out of the listener and
// disable the quit guard for the rest of the session.
console.error('[App] reportDirtyEditorsResult failed:', err);
}
if (tasksToResume.length > 0) {
void Promise.allSettled(tasksToResume.map((task) => sftpTransferCenterStore.resume(task.id)));
}
});
return unsub;
}, [enabled, t]);
useEffect(() => {
const bridge = netcattyBridge.get();
const unsubscribeEvents = bridge?.onGlobalSftpTransferEvent?.((event) => {
sftpTransferCenterStore.ingestBackgroundEvent(event);
});
const restartBackgroundTransfer = async (taskId: string, fromBeginning: boolean) => {
const task = sftpTransferCenterStore.getSnapshot().tasks.find((candidate) => candidate.id === taskId);
if (!task || !bridge?.openSftpForSession || !bridge.startStreamTransfer) return;
const sessionId = task.direction === "upload" ? task.targetConnectionId : task.sourceConnectionId;
if (!sessionId || sessionId === "agent" || sessionId === "local") {
sftpTransferCenterStore.ingestBackgroundEvent({
type: "failed",
transferId: taskId,
error: "The original server session is unavailable",
endedAt: Date.now(),
});
return;
}
let sftpId: string | undefined;
try {
const checkpointBytes = fromBeginning ? 0 : (task.checkpointBytes ?? task.transferredBytes ?? 0);
sftpTransferCenterStore.ingestBackgroundEvent({ type: "queued", transferId: taskId });
// Admit first so agent resume does not pin session-backed SFTP handles
// while waiting for main-process concurrency.
const result = await globalSftpTransferScheduler.run(
"background-agent",
task.id,
getSftpTransferResourceKeys({
sourceHostId: task.sourceHostId,
targetHostId: task.targetHostId,
}),
() => localStorageAdapter.readNumber(STORAGE_KEY_SFTP_TRANSFER_CONCURRENCY),
async () => {
sftpId = await bridge.openSftpForSession!(sessionId);
return bridge.startStreamTransfer!({
transferId: task.id,
sourcePath: task.sourcePath,
targetPath: task.targetPath,
sourceType: task.direction === "upload" ? "local" : "sftp",
targetType: task.direction === "download" ? "local" : "sftp",
sourceSftpId: task.direction === "download" ? sftpId : undefined,
targetSftpId: task.direction === "upload" ? sftpId : undefined,
// Keep host-scoped path gates across session reopen (Codex P1).
sourceHostId: task.sourceHostId,
targetHostId: task.targetHostId,
totalBytes: task.totalBytes,
resumable: task.resumable !== false,
checkpointBytes,
resumeStage: fromBeginning ? undefined : task.resumeStage,
downloadCheckpointBytes: fromBeginning ? 0 : task.downloadCheckpointBytes,
uploadCheckpointBytes: fromBeginning ? 0 : task.uploadCheckpointBytes,
sourceFingerprint: fromBeginning ? undefined : task.sourceFingerprint,
skipAdmission: true,
});
},
);
// Same-id retry stole ownership; wait for the live owner's terminal
// status instead of treating this invoke as completed (Codex P2).
if (result?.superseded === true) {
// Wait for live owner terminal status only (no fixed deadline).
for (;;) {
const latest = sftpTransferCenterStore.getSnapshot().tasks.find((candidate) => candidate.id === task.id);
const status = latest?.status;
if (status === "completed" || status === "cancelled" || status === "failed") {
if (status === "failed") {
throw new Error(latest?.error || "Transfer failed");
}
if (status === "cancelled") {
sftpTransferCenterStore.ingestBackgroundEvent({
type: "cancelled",
transferId: task.id,
endedAt: Date.now(),
});
}
// completed: events already applied; cancelled handled above.
break;
}
await new Promise((resolve) => setTimeout(resolve, 200));
}
} else if (result?.cancelled || result?.error === "Transfer cancelled") {
sftpTransferCenterStore.ingestBackgroundEvent({ type: "cancelled", transferId: task.id, endedAt: Date.now() });
} else if (result?.error) {
throw new Error(result.error);
} else {
sftpTransferCenterStore.ingestBackgroundEvent({ type: "completed", transferId: task.id, endedAt: Date.now() });
}
} catch (error) {
sftpTransferCenterStore.ingestBackgroundEvent({
type: "failed",
transferId: task.id,
error: error instanceof Error ? error.message : String(error),
endedAt: Date.now(),
});
} finally {
if (sftpId) await bridge.closeSftp?.(sftpId).catch(() => {});
}
};
const unregisterOwner = sftpTransferCenterStore.registerOwner("background-agent", {
pause: async (taskId) => {
const result = await bridge?.pauseTransfer?.(taskId);
if (result?.success) sftpTransferCenterStore.ingestBackgroundEvent({
type: "paused",
transferId: taskId,
checkpointBytes: result.checkpointBytes,
resumeStage: result.resumeStage,
downloadCheckpointBytes: result.downloadCheckpointBytes,
uploadCheckpointBytes: result.uploadCheckpointBytes,
sourceFingerprint: result.sourceFingerprint,
});
},
resume: async (taskId) => {
const result = await bridge?.resumeTransfer?.(taskId);
if (result?.success) {
sftpTransferCenterStore.ingestBackgroundEvent({ type: "resumed", transferId: taskId });
} else {
sftpTransferCenterStore.markReconnectRequired(
taskId,
result?.reason ?? "The original server connection is unavailable",
);
setTimeout(() => { void sftpTransferCenterStore.resume(taskId); }, 0);
}
},
cancel: async (taskId) => {
await bridge?.cancelTransfer?.(taskId);
sftpTransferCenterStore.ingestBackgroundEvent({ type: "cancelled", transferId: taskId, endedAt: Date.now() });
},
retry: async (taskId) => { await restartBackgroundTransfer(taskId, true); },
prioritize: async (taskId) => { await bridge?.prioritizeTransfer?.(taskId); },
dismiss: (taskId, prunedTask) => {
const task = prunedTask
?? sftpTransferCenterStore.getSnapshot().tasks.find((candidate) => candidate.id === taskId);
if (!task) return;
void bridge?.cleanupTransferArtifacts?.({
transferId: task.id,
sourcePath: task.sourcePath,
targetPath: task.targetPath,
stagedTargetPath: task.stagedTargetPath,
});
},
});
return () => {
unsubscribeEvents?.();
unregisterOwner();
};
}, [enabled]);
// Keyboard-interactive authentication (2FA/MFA) event listener
useEffect(() => {
const bridge = netcattyBridge.get();
if (!bridge?.onKeyboardInteractive) return;
const unsubscribe = bridge.onKeyboardInteractive((request) => {
if (!shouldQueueKeyboardInteractiveRequest(request, sessionsRef.current)) {
if (request.scope === "terminal" && request.requestId) {
void bridge.respondKeyboardInteractive?.(request.requestId, [], true);
}
return;
}
console.log('[App] Keyboard-interactive request received:', { sessionId: request.sessionId, scope: request.scope, promptCount: request.prompts?.length });
// Add to queue instead of replacing - supports multiple concurrent sessions
setKeyboardInteractiveQueue(prev => [...prev, {
requestId: request.requestId,
sessionId: request.sessionId,
hostId: request.hostId,
name: request.name,
instructions: request.instructions,
prompts: request.prompts,
hostname: request.hostname,
savedPassword: request.savedPassword,
allowSavePassword: request.allowSavePassword !== false,
...(typeof request.totpUri === "string" && request.totpUri && !request.totpUri.startsWith("enc:v1:")
? { totpUri: request.totpUri }
: {}),
}]);
});
const unsubscribeCancelled = bridge.onKeyboardInteractiveCancelled?.((event) => {
setKeyboardInteractiveQueue(prev => removeKeyboardInteractiveRequest(prev, event.requestId));
});
const onTerminalDisconnected = (event: Event) => {
const sessionId = (event as CustomEvent<{ sessionId?: string }>).detail?.sessionId;
if (!sessionId) return;
setKeyboardInteractiveQueue((prev) => {
const doomed = prev.filter((request) => request.sessionId === sessionId);
for (const request of doomed) {
void bridge.respondKeyboardInteractive?.(request.requestId, [], true);
}
return prev.filter((request) => request.sessionId !== sessionId);
});
};
window.addEventListener("netcatty:terminal-session-disconnected", onTerminalDisconnected);
return () => {
unsubscribe?.();
unsubscribeCancelled?.();
window.removeEventListener("netcatty:terminal-session-disconnected", onTerminalDisconnected);
};
}, [enabled, setKeyboardInteractiveQueue]);
}