Files
Netcatty/electron/preload/api.cjs
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

2267 lines
101 KiB
JavaScript

const {
clearTerminalDataSession,
hasPluginPipelineIngressMarker,
} = require("./terminalDataBacklog.cjs");
const { randomUUID } = require("node:crypto");
const fs = require("node:fs");
const { stageRendererFileToTemp } = require("./stageUploadFile.cjs");
function createPreloadApi(ctx) {
const terminalDataBacklog = ctx.terminalDataBacklog || null;
const displayDataListeners = ctx.displayDataListeners || new Map();
const closedTerminalDataSessions = ctx.closedTerminalDataSessions || null;
const globalSftpTransferListeners = ctx.globalSftpTransferListeners || new Set();
const pluginContributionsChangedListeners = ctx.pluginContributionsChangedListeners || new Set();
const uploadStageControllers = new Map();
const hostBrowserPanelListeners = new Set();
const pendingHostBrowserPanels = [];
// TerminalLayer mounts lazily; retain incoming requests until it subscribes.
ctx.ipcRenderer?.on?.("netcatty:host-browser:request-panel", (_event, request) => {
if (!hostBrowserPanelListeners.size) {
pendingHostBrowserPanels.push(request);
return;
}
for (const listener of hostBrowserPanelListeners) listener(request);
});
// Lightweight test contexts may omit this map; default so closeSession never throws.
if (!ctx.moshSessionReadyListeners) {
ctx.moshSessionReadyListeners = new Map();
}
const markTerminalDataSessionOpen = (sessionId) => {
if (!sessionId) return;
closedTerminalDataSessions?.delete?.(sessionId);
};
const markRequestedTerminalDataSessionOpen = (options) => {
markTerminalDataSessionOpen(options?.sessionId);
};
const markTerminalDataSessionClosed = (sessionId) => {
if (!sessionId) return;
closedTerminalDataSessions?.add?.(sessionId);
ctx.clearTerminalOutputSessionState?.(sessionId);
clearTerminalDataSession({
dataListeners: ctx.dataListeners,
displayDataListeners,
terminalDataBacklog,
}, sessionId);
ctx.terminalOutputPorts?.closeSession?.(sessionId);
};
const removeSessionListener = (listeners, sessionId, cb) => {
const set = listeners?.get?.(sessionId);
set?.delete(cb);
if (set?.size === 0) listeners.delete(sessionId);
};
const clearSessionScopedTerminalListeners = (sessionId) => {
ctx.telnetAutoLoginCompleteListeners?.delete?.(sessionId);
ctx.telnetAutoLoginCancelledListeners?.delete?.(sessionId);
ctx.moshSessionReadyListeners?.delete?.(sessionId);
ctx.telnetEchoModeListeners?.delete?.(sessionId);
ctx.authFailedListeners?.delete?.(sessionId);
};
const sanitizeInterruptTrace = (trace) => {
if (!trace || typeof trace !== "object") return undefined;
const priority = trace.rendererPriority && typeof trace.rendererPriority === "object"
? {
sessionId: typeof trace.rendererPriority.sessionId === "string" ? trace.rendererPriority.sessionId : null,
backlogBytes: Number(trace.rendererPriority.backlogBytes) || 0,
writeQueueDepth: Number(trace.rendererPriority.writeQueueDepth) || 0,
deferredAckBytes: Number(trace.rendererPriority.deferredAckBytes) || 0,
ackAfterInputBytes: Number(trace.rendererPriority.ackAfterInputBytes) || 0,
scheduledBackendResume: Boolean(trace.rendererPriority.scheduledBackendResume),
skippedReason: typeof trace.rendererPriority.skippedReason === "string" ? trace.rendererPriority.skippedReason : undefined,
}
: undefined;
return {
debug: trace.debug === true,
traceId: typeof trace.traceId === "string" ? trace.traceId.slice(0, 128) : undefined,
source: typeof trace.source === "string" ? trace.source.slice(0, 80) : undefined,
sessionId: typeof trace.sessionId === "string" ? trace.sessionId : undefined,
rendererKeyAt: Number.isFinite(trace.rendererKeyAt) ? trace.rendererKeyAt : undefined,
rendererSendAt: Number.isFinite(trace.rendererSendAt) ? trace.rendererSendAt : undefined,
rendererStatus: typeof trace.rendererStatus === "string" ? trace.rendererStatus.slice(0, 40) : undefined,
rendererHasSelection: trace.rendererHasSelection === true,
rendererPriority: priority,
};
};
const sanitizeKittyKeyboardModeState = (value) => {
if (!value || typeof value !== "object") return undefined;
const flags = (input) => Number.isFinite(input) ? Math.max(0, Math.floor(input)) & 31 : 0;
const stack = (input) => Array.isArray(input)
? input.slice(-32).map(flags)
: [];
return {
mainFlags: flags(value.mainFlags),
alternateFlags: flags(value.alternateFlags),
mainStack: stack(value.mainStack),
alternateStack: stack(value.alternateStack),
alternateScreenActive: value.alternateScreenActive === true,
};
};
with (ctx) {
return {
getPluginRuntimeStatus: () => ipcRenderer.invoke("netcatty:plugins:status"),
listPlugins: () => ipcRenderer.invoke("netcatty:plugins:list"),
installPluginPackage: (archivePath, options) => ipcRenderer.invoke("netcatty:plugins:install", {
archivePath,
enable: options?.enable === true,
}),
setPluginEnabled: (pluginId, enabled) => ipcRenderer.invoke("netcatty:plugins:set-enabled", {
pluginId,
enabled: enabled === true,
}),
restartPlugin: (pluginId) => ipcRenderer.invoke("netcatty:plugins:restart", { pluginId }),
uninstallPlugin: (pluginId) => ipcRenderer.invoke("netcatty:plugins:uninstall", { pluginId }),
getPluginContributions: (options) => ipcRenderer.invoke("netcatty:plugins:contributions", options ?? {}),
getPluginContributionIcon: (pluginId, icon) => ipcRenderer.invoke("netcatty:plugins:contribution-icon", { pluginId, icon }),
executePluginCommand: (command, args, context) => ipcRenderer.invoke("netcatty:plugins:execute-command", {
command,
...(args === undefined ? {} : { args }),
...(context === undefined ? {} : { context }),
}),
updatePluginSetting: (pluginId, settingId, value, scopeId) => ipcRenderer.invoke(
"netcatty:plugins:update-setting",
{ pluginId, settingId, value, ...(scopeId === undefined ? {} : { scopeId }) },
),
resetPluginSetting: (pluginId, settingId, scopeId) => ipcRenderer.invoke(
"netcatty:plugins:reset-setting",
{ pluginId, settingId, ...(scopeId === undefined ? {} : { scopeId }) },
),
setPluginEnvironment: (environment) => ipcRenderer.invoke("netcatty:plugins:set-environment", environment),
listPluginTerminalProviders: (options) => ipcRenderer.invoke("netcatty:plugins:terminal-providers", options ?? {}),
providePluginTerminal: (request) => ipcRenderer.invoke("netcatty:plugins:terminal-provide", request),
cancelPluginTerminalRequest: (requestId) => ipcRenderer.invoke("netcatty:plugins:terminal-cancel", { requestId }),
publishPluginTerminalSessionEvent: (event) => ipcRenderer.invoke("netcatty:plugins:terminal-session-event", event),
listPluginExtensionProviders: (options) => ipcRenderer.invoke("netcatty:plugins:extension-providers", options ?? {}),
updatePluginCredentialCatalog: (entries) => ipcRenderer.invoke(
"netcatty:plugins:credential-catalog-update",
{ entries },
),
invokePluginExtensionProvider: (request) => ipcRenderer.invoke("netcatty:plugins:extension-invoke", {
requestId: request?.requestId ?? randomUUID(),
...request,
}),
cancelPluginExtensionRequest: (requestId) => ipcRenderer.invoke("netcatty:plugins:extension-cancel", { requestId }),
pluginSyncConnect: (request) => {
const requestId = typeof request?.requestId === "string" && request.requestId
? request.requestId
: randomUUID();
return ipcRenderer.invoke("netcatty:plugins:sync-connect", { ...request, requestId });
},
pluginSyncDisconnect: (request) => {
const requestId = typeof request?.requestId === "string" && request.requestId
? request.requestId
: randomUUID();
return ipcRenderer.invoke("netcatty:plugins:sync-disconnect", { ...request, requestId });
},
pluginSyncGetAccount: (request) => {
const requestId = typeof request?.requestId === "string" && request.requestId
? request.requestId
: randomUUID();
return ipcRenderer.invoke("netcatty:plugins:sync-get-account", { ...request, requestId });
},
pluginSyncGetCapabilities: (request) => {
const requestId = typeof request?.requestId === "string" && request.requestId
? request.requestId
: randomUUID();
return ipcRenderer.invoke("netcatty:plugins:sync-get-capabilities", { ...request, requestId });
},
pluginSyncReadObject: (request) => {
const requestId = typeof request?.requestId === "string" && request.requestId
? request.requestId
: randomUUID();
return ipcRenderer.invoke("netcatty:plugins:sync-read-object", { ...request, requestId });
},
pluginSyncReadChunk: (request) => ipcRenderer.invoke("netcatty:plugins:sync-read-chunk", request),
pluginSyncWriteObject: (request) => {
const requestId = typeof request?.requestId === "string" && request.requestId
? request.requestId
: randomUUID();
return ipcRenderer.invoke("netcatty:plugins:sync-write-object", { ...request, requestId });
},
pluginSyncWriteBegin: (request) => {
const requestId = typeof request?.requestId === "string" && request.requestId
? request.requestId
: randomUUID();
return ipcRenderer.invoke("netcatty:plugins:sync-write-begin", { ...request, requestId });
},
pluginSyncWriteChunk: (request) => ipcRenderer.invoke("netcatty:plugins:sync-write-chunk", request),
pluginSyncWriteCommit: (request) => ipcRenderer.invoke("netcatty:plugins:sync-write-commit", request),
pluginSyncDeleteObject: (request) => {
const requestId = typeof request?.requestId === "string" && request.requestId
? request.requestId
: randomUUID();
return ipcRenderer.invoke("netcatty:plugins:sync-delete-object", { ...request, requestId });
},
pluginSyncPutSecret: (request) => ipcRenderer.invoke("netcatty:plugins:sync-put-secret", request ?? {}),
pluginSyncDeleteSecrets: (request) => ipcRenderer.invoke("netcatty:plugins:sync-delete-secrets", request ?? {}),
pluginSyncRestoreSecrets: (request) => ipcRenderer.invoke("netcatty:plugins:sync-restore-secrets", request ?? {}),
collectPluginSyncSidecars: () => ipcRenderer.invoke("netcatty:plugins:sync-sidecars-collect", {}),
applyPluginSyncSidecars: (bundle) => ipcRenderer.invoke("netcatty:plugins:sync-sidecars-apply", bundle ?? { version: 1, entries: [] }),
/** True only when the main-process plugin host wired a sidecar service. */
pluginHostReady: () => {
try {
return ipcRenderer.sendSync("netcatty:plugins:host-available-sync") === true;
} catch {
return false;
}
},
startPluginConnection: async (request) => {
markRequestedTerminalDataSessionOpen(request);
const result = await ipcRenderer.invoke("netcatty:plugins:connection-start", {
requestId: request?.requestId ?? randomUUID(),
...request,
});
markTerminalDataSessionOpen(result?.sessionId);
return result;
},
writePluginConnection: (sessionId, data) => ipcRenderer.invoke("netcatty:plugins:connection-write", { sessionId, data }),
controlPluginConnection: (sessionId, operation, payload) => ipcRenderer.invoke(
"netcatty:plugins:connection-control",
{ sessionId, operation, payload: payload ?? {} },
),
detectPluginImporter: (request) => ipcRenderer.invoke("netcatty:plugins:importer-detect", {
requestId: request?.requestId ?? randomUUID(),
...request,
}),
selectPluginImporterFile: () => ipcRenderer.invoke("netcatty:plugins:importer-select-file", {}),
releasePluginImporterFile: (selectionToken) => ipcRenderer.invoke(
"netcatty:plugins:importer-release-file",
{ selectionToken },
),
parsePluginImporterFile: (request) => ipcRenderer.invoke("netcatty:plugins:importer-parse-file", {
requestId: request?.requestId ?? randomUUID(),
...request,
}),
onPluginImporterProgress: (callback) => {
const listener = (_event, payload) => callback(payload);
ipcRenderer.on("netcatty:plugins:importer-progress", listener);
return () => ipcRenderer.removeListener("netcatty:plugins:importer-progress", listener);
},
respondPluginAuthenticationChallenge: (response) => ipcRenderer.invoke(
"netcatty:plugins:authentication-respond",
response,
),
onPluginAuthenticationChallenge: (callback) => {
const listener = (_event, payload) => callback(payload);
ipcRenderer.on("netcatty:plugins:authentication-challenge", listener);
return () => ipcRenderer.removeListener("netcatty:plugins:authentication-challenge", listener);
},
onPluginConnectionData: (callback) => {
const listener = (_event, payload) => callback(payload);
ipcRenderer.on("netcatty:plugins:connection-data", listener);
return () => ipcRenderer.removeListener("netcatty:plugins:connection-data", listener);
},
onPluginConnectionClosed: (callback) => {
const listener = (_event, payload) => callback(payload);
ipcRenderer.on("netcatty:plugins:connection-closed", listener);
return () => ipcRenderer.removeListener("netcatty:plugins:connection-closed", listener);
},
openPluginView: (payload) => ipcRenderer.invoke("netcatty:plugins:open-view", payload),
closePluginView: (instanceId) => ipcRenderer.invoke("netcatty:plugins:close-view", { instanceId }),
setPluginViewBounds: (instanceId, bounds) => ipcRenderer.invoke("netcatty:plugins:set-view-bounds", { instanceId, bounds }),
setPluginViewVisibility: (instanceId, visible) => ipcRenderer.invoke("netcatty:plugins:set-view-visibility", {
instanceId,
visible: visible === true,
}),
postPluginViewMessage: (instanceId, message) => ipcRenderer.invoke("netcatty:plugins:view-message", { instanceId, message }),
onPluginContributionsChanged: (callback) => {
pluginContributionsChangedListeners.add(callback);
return () => pluginContributionsChangedListeners.delete(callback);
},
onPluginViewMessage: (callback) => {
const listener = (_event, payload) => callback(payload);
ipcRenderer.on("netcatty:plugins:view-message-posted", listener);
return () => ipcRenderer.removeListener("netcatty:plugins:view-message-posted", listener);
},
onPluginViewClosed: (callback) => {
const listener = (_event, payload) => callback(payload);
ipcRenderer.on("netcatty:plugins:view-closed", listener);
return () => ipcRenderer.removeListener("netcatty:plugins:view-closed", listener);
},
getPluginScopeCatalog: () => ipcRenderer.invoke("netcatty:plugins:get-scope-catalog"),
setPluginScopeCatalog: (catalog) => ipcRenderer.invoke("netcatty:plugins:set-scope-catalog", catalog),
onPluginScopeCatalogChanged: (callback) => {
const listener = (_event, payload) => callback(payload);
ipcRenderer.on("netcatty:plugins:scope-catalog-changed", listener);
return () => ipcRenderer.removeListener("netcatty:plugins:scope-catalog-changed", listener);
},
getWindowsPtyInfo: () => {
if (process.platform !== "win32") {
return null;
}
const releaseParts = os.release().split(".");
const buildNumber = Number.parseInt(releaseParts[2] || "", 10);
const hasBuildNumber = Number.isFinite(buildNumber);
const backend =
hasBuildNumber && buildNumber < 18309 ? "winpty" : "conpty";
return hasBuildNumber ? { backend, buildNumber } : { backend };
},
startSSHSession: async (options) => {
markRequestedTerminalDataSessionOpen(options);
const result = await ipcRenderer.invoke("netcatty:start", options);
markTerminalDataSessionOpen(result?.sessionId);
return result.sessionId;
},
monitorUpdate: (panels) => ipcRenderer.invoke("netcatty:monitor:update", panels),
monitorSnapshot: (cursor) => ipcRenderer.invoke("netcatty:monitor:snapshot", cursor),
monitorStopAll: () => ipcRenderer.invoke("netcatty:monitor:stop-all"),
monitorRetry: (hostId) => ipcRenderer.invoke("netcatty:monitor:retry", hostId),
testConnection: async (options) => {
const result = await ipcRenderer.invoke("netcatty:test-connection", options);
return result.sessionId;
},
cancelTestConnection: async (sessionId) => {
return ipcRenderer.invoke("netcatty:test-connection:cancel", sessionId);
},
startTelnetSession: async (options) => {
markRequestedTerminalDataSessionOpen(options);
const result = await ipcRenderer.invoke("netcatty:telnet:start", options);
markTerminalDataSessionOpen(result?.sessionId);
return result.sessionId;
},
startMoshSession: async (options) => {
markRequestedTerminalDataSessionOpen(options);
const result = await ipcRenderer.invoke("netcatty:mosh:start", options);
markTerminalDataSessionOpen(result?.sessionId);
return result.sessionId;
},
startEtSession: async (options) => {
markRequestedTerminalDataSessionOpen(options);
const result = await ipcRenderer.invoke("netcatty:et:start", options);
markTerminalDataSessionOpen(result?.sessionId);
return result.sessionId;
},
startLocalSession: async (options) => {
markRequestedTerminalDataSessionOpen(options);
const result = await ipcRenderer.invoke("netcatty:local:start", options || {});
markTerminalDataSessionOpen(result?.sessionId);
return result.sessionId;
},
startSerialSession: async (options) => {
markRequestedTerminalDataSessionOpen(options);
const result = await ipcRenderer.invoke("netcatty:serial:start", options);
markTerminalDataSessionOpen(result?.sessionId);
return result.sessionId;
},
listSerialPorts: async () => {
return ipcRenderer.invoke("netcatty:serial:list");
},
sendSerialYmodem: async (sessionId, filePath) => {
return ipcRenderer.invoke("netcatty:serial:ymodem-send", { sessionId, filePath });
},
receiveSerialYmodem: async (sessionId, destinationDir) => {
return ipcRenderer.invoke("netcatty:serial:ymodem-receive", { sessionId, destinationDir });
},
getDefaultShell: async () => {
return ipcRenderer.invoke("netcatty:local:defaultShell");
},
discoverShells: () => ipcRenderer.invoke("netcatty:shells:discover"),
validatePath: async (path, type) => {
return ipcRenderer.invoke("netcatty:local:validatePath", { path, type });
},
writeToSession: (sessionId, data, options) => {
const lineDelayMs = Number(options?.lineDelayMs);
ipcRenderer.send("netcatty:write", {
sessionId,
data,
automated: Boolean(options?.automated),
pasteRequestId: typeof options?.pasteRequestId === "string" ? options.pasteRequestId : undefined,
sensitive: options?.sensitive === true,
serialEraseChar: typeof options?.serialEraseChar === "string" ? options.serialEraseChar : undefined,
lineDelayMs: Number.isFinite(lineDelayMs) && lineDelayMs > 0 ? lineDelayMs : undefined,
logRewrite: options?.logRewrite && typeof options.logRewrite === "object"
? {
sentCommand: String(options.logRewrite.sentCommand ?? ""),
displayCommand: String(options.logRewrite.displayCommand ?? ""),
}
: undefined,
});
},
notifySessionUserInput: (sessionId) => {
ipcRenderer.send("netcatty:terminal:user-input", { sessionId });
},
onTerminalPasteWrite: (cb) => {
const listener = (_event, payload) => cb(payload);
ipcRenderer.on("netcatty:paste-write", listener);
return () => ipcRenderer.removeListener("netcatty:paste-write", listener);
},
interruptSession: (sessionId, trace, options) => {
const sanitizedTrace = sanitizeInterruptTrace(trace);
if (options?.cancelPendingWritesOnly === true) {
ipcRenderer.send("netcatty:interrupt", { sessionId, trace: sanitizedTrace, cancelPendingWritesOnly: true });
return;
}
if (ctx.terminalUrgentInputPorts?.postInterrupt?.(sessionId, sanitizedTrace)) {
return;
}
ipcRenderer.send("netcatty:interrupt", { sessionId, trace: sanitizedTrace });
},
execCommand: async (options) => {
return ipcRenderer.invoke("netcatty:ssh:exec", options);
},
getSessionPwd: async (sessionId, options) => {
return ipcRenderer.invoke("netcatty:ssh:pwd", {
sessionId,
allowHomeFallback: options?.allowHomeFallback,
allowLoginShellFallback: options?.allowLoginShellFallback,
timeoutMs: options?.timeoutMs,
});
},
getSessionRemoteInfo: async (sessionId) => {
return ipcRenderer.invoke("netcatty:ssh:remoteInfo", { sessionId });
},
getSessionDistroInfo: async (sessionId) => {
return ipcRenderer.invoke("netcatty:ssh:distroInfo", { sessionId });
},
getServerStats: async (sessionId) => {
return ipcRenderer.invoke("netcatty:ssh:stats", { sessionId });
},
probeSystemCapabilities: async (sessionId) => {
return ipcRenderer.invoke("netcatty:system:probeCapabilities", { sessionId });
},
listSystemProcesses: async (sessionId) => {
return ipcRenderer.invoke("netcatty:system:listProcesses", { sessionId });
},
signalSystemProcess: async (options) => {
return ipcRenderer.invoke("netcatty:system:signalProcess", options);
},
setupOsc7Tracking: async (sessionId, command) => {
return ipcRenderer.invoke("netcatty:system:setupOsc7Tracking", { sessionId, command });
},
listTmuxSessions: async (sessionId) => {
return ipcRenderer.invoke("netcatty:system:listTmuxSessions", { sessionId });
},
createTmuxSession: async (options) => {
return ipcRenderer.invoke("netcatty:system:createTmuxSession", options);
},
listTmuxWindows: async (options) => {
return ipcRenderer.invoke("netcatty:system:listTmuxWindows", options);
},
listTmuxPanes: async (options) => {
return ipcRenderer.invoke("netcatty:system:listTmuxPanes", options);
},
listTmuxClients: async (options) => {
return ipcRenderer.invoke("netcatty:system:listTmuxClients", options);
},
tmuxAction: async (options) => {
return ipcRenderer.invoke("netcatty:system:tmuxAction", options);
},
listDockerContainers: async (sessionId, runtime) => {
return ipcRenderer.invoke("netcatty:system:listDockerContainers", { sessionId, runtime });
},
listDockerImages: async (sessionId, runtime) => {
return ipcRenderer.invoke("netcatty:system:listDockerImages", { sessionId, runtime });
},
getDockerStats: async (options) => {
return ipcRenderer.invoke("netcatty:system:dockerStats", options);
},
listAccelerators: async (sessionId) => {
return ipcRenderer.invoke("netcatty:system:listAccelerators", { sessionId });
},
listListeningPorts: async (sessionId) => {
return ipcRenderer.invoke("netcatty:system:listListeningPorts", { sessionId });
},
listSystemServices: async (sessionId) => {
return ipcRenderer.invoke("netcatty:system:listSystemServices", { sessionId });
},
systemServiceAction: async (options) => {
return ipcRenderer.invoke("netcatty:system:systemServiceAction", options);
},
dockerInspect: async (options) => {
return ipcRenderer.invoke("netcatty:system:dockerInspect", options);
},
dockerImageInspect: async (options) => {
return ipcRenderer.invoke("netcatty:system:dockerImageInspect", options);
},
dockerAction: async (options) => {
return ipcRenderer.invoke("netcatty:system:dockerAction", options);
},
dockerImageAction: async (options) => {
return ipcRenderer.invoke("netcatty:system:dockerImageAction", options);
},
kubectl: async (options) => {
return ipcRenderer.invoke("netcatty:system:kubectl", options);
},
openTerminalPopup: async (payload) => {
return ipcRenderer.invoke("netcatty:window:openTerminalPopup", payload);
},
logDiagnostic: async (payload) => {
return ipcRenderer.invoke("netcatty:diagnostics:log", payload);
},
onTerminalPopupConfig: (cb) => {
terminalPopupConfigState.listeners.add(cb);
const replay = terminalPopupConfigState.pending ?? terminalPopupConfigState.lastPayload;
if (replay) {
// Drain the one-shot pending slot once a live subscriber exists, but keep
// lastPayload so remounts (AppLockGate delay, StrictMode) can resubscribe
// and still receive the one-shot main post-loadURL payload.
terminalPopupConfigState.pending = null;
queueMicrotask(() => {
try {
cb(replay);
} catch (err) {
console.error("Terminal popup config callback failed", err);
}
});
}
return () => terminalPopupConfigState.listeners.delete(cb);
},
readRemoteHistory: async (sessionId, limit) => {
return ipcRenderer.invoke("netcatty:ssh:readRemoteHistory", { sessionId, limit });
},
generateKeyPair: async (options) => {
return ipcRenderer.invoke("netcatty:key:generate", options);
},
checkSshAgent: async (options) => {
return ipcRenderer.invoke("netcatty:ssh:check-agent", options);
},
getDefaultKeys: async () => {
return ipcRenderer.invoke("netcatty:ssh:get-default-keys");
},
resizeSession: (sessionId, cols, rows) => {
ipcRenderer.send("netcatty:resize", { sessionId, cols, rows });
},
clearSessionPtyBuffer: (sessionId) => {
if (!sessionId) return;
ipcRenderer.send("netcatty:pty:clear", { sessionId });
},
setSessionFlowPaused: (sessionId, paused) => {
ipcRenderer.send("netcatty:flow", { sessionId, paused: Boolean(paused) });
},
setSessionFlowPausedAndWait: (sessionId, paused) =>
ipcRenderer.invoke("netcatty:terminal:setFlowPausedAndWait", {
sessionId,
paused: Boolean(paused),
}),
acquireSessionFlowPauseLease: (sessionId) =>
ipcRenderer.invoke("netcatty:terminal:acquireFlowPauseLease", { sessionId }),
waitSessionFlowPauseLease: (sessionId, leaseId) =>
ipcRenderer.invoke("netcatty:terminal:waitFlowPauseLease", { sessionId, leaseId }),
releaseSessionFlowPauseLease: (sessionId, leaseId, options) =>
ipcRenderer.invoke("netcatty:terminal:releaseFlowPauseLease", {
sessionId,
leaseId,
keepPaused: options?.keepPaused === true,
}),
onTerminalOutputDrainRequest: (sessionId, cb) => {
const listeners = ctx.terminalOutputDrainListeners;
if (!listeners.has(sessionId)) listeners.set(sessionId, new Set());
listeners.get(sessionId).add(cb);
return () => {
const set = listeners.get(sessionId);
set?.delete(cb);
if (set?.size === 0) listeners.delete(sessionId);
};
},
respondTerminalOutputDrain: (requestId) => {
ipcRenderer.send("netcatty:terminal:output-drain-response", { requestId });
},
notifyTerminalSessionDisplayReady: (sessionId) => {
ipcRenderer.send("netcatty:terminal:display-ready", { sessionId });
},
ackSessionFlow: (sessionId, bytes) => {
if (!sessionId || !Number.isFinite(bytes) || bytes <= 0) return;
ipcRenderer.send("netcatty:flow:ack", { sessionId, bytes });
},
closeSession: async (sessionId, options) => {
const payload = {
sessionId,
...(Number.isFinite(options?.bootEpoch) ? { bootEpoch: Number(options.bootEpoch) } : {}),
...(options?.retainOwnership === true ? { retainOwnership: true } : {}),
};
const epochScoped = Number.isFinite(options?.bootEpoch);
// Unscoped closes keep the historical sync listener teardown so reconnect
// paths that fire-and-forget closeSession still drop stale handlers.
// Epoch-scoped closes are only used to dispose a superseded backend owner;
// they must never clear preload listeners for the shared sessionId, because
// a replacement boot may already have registered readiness/auto-login hooks.
if (!epochScoped) {
markTerminalDataSessionClosed(sessionId);
clearSessionScopedTerminalListeners(sessionId);
}
try {
await ipcRenderer.invoke("netcatty:close:await", payload);
} catch {
ipcRenderer.send("netcatty:close", payload);
}
},
rebindTerminalSessionOutput: (sessionId, authorization) =>
ipcRenderer.invoke("netcatty:terminal:rebindOutput", { sessionId, authorization }),
restoreTerminalSessionOutput: (sessionId, webContentsId, authorization) =>
ipcRenderer.invoke("netcatty:terminal:restoreOutput", { sessionId, webContentsId, authorization }),
requestTerminalSessionSnapshot: (sessionId, authorization) =>
ipcRenderer.invoke("netcatty:terminal:requestSnapshot", { sessionId, authorization }),
onTerminalSessionSnapshotRequest: (cb) => {
const handler = (_event, payload) => {
try {
cb?.(payload);
} catch {
// Provider failures must not break the main process request.
}
};
ipcRenderer.on("netcatty:terminal:snapshot-request", handler);
return () => ipcRenderer.removeListener("netcatty:terminal:snapshot-request", handler);
},
respondTerminalSessionSnapshot: (
requestId,
snapshot,
kittyKeyboardModeState,
kittyKeyboardProtocolEnabled,
passwordPromptActive,
cwd,
title,
) => {
ipcRenderer.send("netcatty:terminal:snapshot-response", {
requestId,
snapshot: typeof snapshot === "string" ? snapshot : "",
kittyKeyboardModeState: sanitizeKittyKeyboardModeState(kittyKeyboardModeState),
kittyKeyboardProtocolEnabled: typeof kittyKeyboardProtocolEnabled === "boolean"
? kittyKeyboardProtocolEnabled
: undefined,
passwordPromptActive: typeof passwordPromptActive === "boolean"
? passwordPromptActive
: undefined,
cwd: cwd === null ? null : typeof cwd === "string" ? cwd : undefined,
title: title === null ? null : typeof title === "string" ? title : undefined,
});
},
applyTerminalSessionSnapshot: (sessionId, snapshot, context, authorization) =>
ipcRenderer.invoke("netcatty:terminal:applySnapshot", {
sessionId,
snapshot: typeof snapshot === "string" ? snapshot : "",
contextSnapshot: typeof context?.contextSnapshot === "string" ? context.contextSnapshot : "",
contextViewportSnapshot: typeof context?.contextViewportSnapshot === "string"
? context.contextViewportSnapshot
: "",
contextScrollbackSnapshot: typeof context?.contextScrollbackSnapshot === "string"
? context.contextScrollbackSnapshot
: "",
alternateScreen: context?.alternateScreen === true,
kittyKeyboardModeState: sanitizeKittyKeyboardModeState(context?.kittyKeyboardModeState),
kittyKeyboardProtocolEnabled: typeof context?.kittyKeyboardProtocolEnabled === "boolean"
? context.kittyKeyboardProtocolEnabled
: undefined,
passwordPromptActive: typeof context?.passwordPromptActive === "boolean"
? context.passwordPromptActive
: undefined,
cwd: context?.cwd === null ? null : typeof context?.cwd === "string" ? context.cwd : undefined,
title: context?.title === null ? null : typeof context?.title === "string" ? context.title : undefined,
authorization,
}),
markAttachPopupClosePrepared: (sessionId, authorization) =>
ipcRenderer.invoke("netcatty:terminal:markAttachClosePrepared", { sessionId, authorization }),
onTerminalPopupPrepareClose: (cb) => {
const handler = (_event, payload) => cb?.(payload);
ipcRenderer.on("netcatty:terminal-popup:prepare-close", handler);
return () => ipcRenderer.removeListener("netcatty:terminal-popup:prepare-close", handler);
},
onTerminalSessionApplySnapshot: (cb) => {
const handler = (_event, payload) => {
Promise.resolve().then(() => cb?.(payload)).then(
(handled) => {
if (handled !== true) return;
ipcRenderer.send("netcatty:terminal:apply-snapshot-response", {
requestId: payload?.requestId,
success: true,
});
},
(err) => ipcRenderer.send("netcatty:terminal:apply-snapshot-response", {
requestId: payload?.requestId,
success: false,
error: err?.message || String(err),
}),
);
};
ipcRenderer.on("netcatty:terminal:apply-snapshot", handler);
return () => ipcRenderer.removeListener("netcatty:terminal:apply-snapshot", handler);
},
setSessionEncoding: async (sessionId, encoding) => {
// Try the SSH handler first; it returns { ok: false } for non-SSH
// sessions (no session.stream). Telnet and serial sessions fall
// through to terminalBridge's handler.
const ssh = await ipcRenderer.invoke("netcatty:ssh:setEncoding", { sessionId, encoding });
if (ssh?.ok) return ssh;
return ipcRenderer.invoke("netcatty:terminal:setEncoding", { sessionId, encoding });
},
onZmodemEvent: (sessionId, cb) => {
if (!zmodemListeners.has(sessionId)) zmodemListeners.set(sessionId, new Set());
zmodemListeners.get(sessionId).add(cb);
return () => {
const set = zmodemListeners.get(sessionId);
if (!set) return;
set.delete(cb);
if (set.size === 0) zmodemListeners.delete(sessionId);
};
},
cancelZmodem: (sessionId, options) => {
ipcRenderer.send("netcatty:zmodem:cancel", { sessionId, options });
},
startZmodemDragDropUpload: (sessionId, files, uploadCommand) => {
return ipcRenderer.invoke("netcatty:zmodem:drag-drop-upload", {
sessionId,
files,
uploadCommand,
});
},
onZmodemOverwriteRequest: (sessionId, cb) => {
if (!zmodemOverwriteListeners.has(sessionId)) zmodemOverwriteListeners.set(sessionId, new Set());
zmodemOverwriteListeners.get(sessionId).add(cb);
return () => {
const set = zmodemOverwriteListeners.get(sessionId);
if (!set) return;
set.delete(cb);
if (set.size === 0) zmodemOverwriteListeners.delete(sessionId);
};
},
respondZmodemOverwrite: (payload) => {
ipcRenderer.send("netcatty:zmodem:overwrite-response", payload);
},
onSessionData: (sessionId, cb, options) => {
const replayBacklog = options?.replayBacklog === true;
if (!dataListeners.has(sessionId)) dataListeners.set(sessionId, new Set());
dataListeners.get(sessionId).add(cb);
if (replayBacklog) {
if (!displayDataListeners.has(sessionId)) displayDataListeners.set(sessionId, new Set());
displayDataListeners.get(sessionId).add(cb);
const pendingEntry = terminalDataBacklog?.takeEntry?.(sessionId)
?? { data: terminalDataBacklog?.take?.(sessionId) || "", meta: undefined };
if (pendingEntry.data || hasPluginPipelineIngressMarker(pendingEntry.meta)) {
try {
cb(pendingEntry.data, pendingEntry.meta);
} catch (err) {
console.error("Data callback failed", err);
}
}
}
return () => {
const dataSet = dataListeners.get(sessionId);
dataSet?.delete(cb);
if (dataSet?.size === 0) dataListeners.delete(sessionId);
if (!replayBacklog) return;
const displaySet = displayDataListeners.get(sessionId);
displaySet?.delete(cb);
if (displaySet?.size === 0) displayDataListeners.delete(sessionId);
};
},
onSessionExit: (sessionId, cb) => {
if (!exitListeners.has(sessionId)) exitListeners.set(sessionId, new Set());
exitListeners.get(sessionId).add(cb);
return () => {
const set = exitListeners.get(sessionId);
set?.delete(cb);
if (set?.size === 0) exitListeners.delete(sessionId);
};
},
onTelnetAutoLoginComplete: (sessionId, cb) => {
if (!telnetAutoLoginCompleteListeners.has(sessionId)) {
telnetAutoLoginCompleteListeners.set(sessionId, new Set());
}
telnetAutoLoginCompleteListeners.get(sessionId).add(cb);
return () => removeSessionListener(telnetAutoLoginCompleteListeners, sessionId, cb);
},
onTelnetAutoLoginCancelled: (sessionId, cb) => {
if (!telnetAutoLoginCancelledListeners.has(sessionId)) {
telnetAutoLoginCancelledListeners.set(sessionId, new Set());
}
telnetAutoLoginCancelledListeners.get(sessionId).add(cb);
return () => removeSessionListener(telnetAutoLoginCancelledListeners, sessionId, cb);
},
onMoshSessionReady: (sessionId, cb) => {
if (!moshSessionReadyListeners.has(sessionId)) {
moshSessionReadyListeners.set(sessionId, new Set());
}
moshSessionReadyListeners.get(sessionId).add(cb);
return () => removeSessionListener(moshSessionReadyListeners, sessionId, cb);
},
onTelnetEchoMode: (sessionId, cb) => {
if (!telnetEchoModeListeners.has(sessionId)) {
telnetEchoModeListeners.set(sessionId, new Set());
}
telnetEchoModeListeners.get(sessionId).add(cb);
return () => removeSessionListener(telnetEchoModeListeners, sessionId, cb);
},
getTelnetEchoMode: (sessionId) =>
ipcRenderer.invoke("netcatty:telnet:getEchoMode", { sessionId }),
onAuthFailed: (sessionId, cb) => {
if (!authFailedListeners.has(sessionId)) authFailedListeners.set(sessionId, new Set());
authFailedListeners.get(sessionId).add(cb);
return () => removeSessionListener(authFailedListeners, sessionId, cb);
},
// Keyboard-interactive authentication (2FA/MFA)
onKeyboardInteractive: (cb) => {
keyboardInteractiveListeners.add(cb);
return () => keyboardInteractiveListeners.delete(cb);
},
onKeyboardInteractiveCancelled: (cb) => {
keyboardInteractiveCancelledListeners.add(cb);
return () => keyboardInteractiveCancelledListeners.delete(cb);
},
respondKeyboardInteractive: async (requestId, responses, cancelled = false) => {
return ipcRenderer.invoke("netcatty:keyboard-interactive:respond", {
requestId,
responses,
cancelled,
});
},
onHostKeyVerification: (cb) => {
hostKeyVerificationListeners.add(cb);
return () => hostKeyVerificationListeners.delete(cb);
},
respondHostKeyVerification: async (requestId, accept, addToKnownHosts = false) => {
return ipcRenderer.invoke("netcatty:host-key:respond", {
requestId,
accept,
addToKnownHosts,
});
},
// Passphrase request for encrypted SSH keys
onPassphraseRequest: (cb) => {
passphraseListeners.add(cb);
return () => passphraseListeners.delete(cb);
},
respondPassphrase: async (requestId, passphrase, cancelled = false) => {
return ipcRenderer.invoke("netcatty:passphrase:respond", {
requestId,
passphrase,
cancelled,
});
},
respondPassphraseSkip: async (requestId) => {
return ipcRenderer.invoke("netcatty:passphrase:respond", {
requestId,
passphrase: '',
skipped: true,
});
},
onPassphraseTimeout: (cb) => {
passphraseTimeoutListeners.add(cb);
return () => passphraseTimeoutListeners.delete(cb);
},
onPassphraseCancelled: (cb) => {
passphraseCancelledListeners.add(cb);
return () => passphraseCancelledListeners.delete(cb);
},
onPassphraseAuthFailed: (cb) => {
passphraseAuthFailedListeners.add(cb);
return () => passphraseAuthFailedListeners.delete(cb);
},
// FIDO2 PIN / touch presence prompts
onFidoPromptRequest: (cb) => {
fidoPromptListeners.add(cb);
return () => fidoPromptListeners.delete(cb);
},
respondFidoPrompt: async (requestId, response, cancelled = false) => {
return ipcRenderer.invoke("netcatty:fido-prompt:respond", {
requestId,
response,
cancelled,
});
},
onFidoPromptTimeout: (cb) => {
fidoPromptTimeoutListeners.add(cb);
return () => fidoPromptTimeoutListeners.delete(cb);
},
onFidoPromptCancelled: (cb) => {
fidoPromptCancelledListeners.add(cb);
return () => fidoPromptCancelledListeners.delete(cb);
},
openSftp: async (options) => {
const result = await ipcRenderer.invoke("netcatty:sftp:open", options);
return result.sftpId;
},
openSftpForSession: async (sessionId, options) => {
const result = await ipcRenderer.invoke("netcatty:sftp:openForSession", {
...(options || {}),
sessionId,
expectedEndpoint: options,
});
if (
options?.requireExactSourceSession === true
&& result.sourceSessionId !== sessionId
) {
if (result.sftpId) {
try {
await ipcRenderer.invoke("netcatty:sftp:close", { sftpId: result.sftpId });
} catch {
// Best-effort cleanup before rejecting an invalid strict binding.
}
}
throw new Error("The requested terminal connection is no longer available");
}
return result.sftpId;
},
listSftp: async (sftpId, path, encoding) => {
return ipcRenderer.invoke("netcatty:sftp:list", { sftpId, path, encoding });
},
realpathSftp: async (sftpId, path, encoding) => {
return ipcRenderer.invoke("netcatty:sftp:realpath", { sftpId, path, encoding });
},
readSftp: async (sftpId, path, encoding) => {
return ipcRenderer.invoke("netcatty:sftp:read", { sftpId, path, encoding });
},
readSftpBinary: async (sftpId, path, encoding) => {
return ipcRenderer.invoke("netcatty:sftp:readBinary", { sftpId, path, encoding });
},
writeSftp: async (sftpId, path, content, encoding) => {
return ipcRenderer.invoke("netcatty:sftp:write", { sftpId, path, content, encoding });
},
writeSftpBinary: async (sftpId, path, content, encoding) => {
return ipcRenderer.invoke("netcatty:sftp:writeBinary", { sftpId, path, content, encoding });
},
closeSftp: async (sftpId) => {
return ipcRenderer.invoke("netcatty:sftp:close", { sftpId });
},
retainSftpTransferSession: async (sftpId, leaseId) => {
return ipcRenderer.invoke("netcatty:transfer:retain-sftp-session", { sftpId, leaseId });
},
releaseSftpTransferSession: async (sftpId, leaseId) => {
return ipcRenderer.invoke("netcatty:transfer:release-sftp-session", { sftpId, leaseId });
},
mkdirSftp: async (sftpId, path, encoding) => {
return ipcRenderer.invoke("netcatty:sftp:mkdir", { sftpId, path, encoding });
},
deleteSftp: async (sftpId, path, encoding, expectedType) => {
return ipcRenderer.invoke("netcatty:sftp:delete", { sftpId, path, encoding, expectedType });
},
renameSftp: async (sftpId, oldPath, newPath, encoding) => {
return ipcRenderer.invoke("netcatty:sftp:rename", { sftpId, oldPath, newPath, encoding });
},
statSftp: async (sftpId, path, encoding) => {
return ipcRenderer.invoke("netcatty:sftp:stat", { sftpId, path, encoding });
},
lstatSftp: async (sftpId, path, encoding) => {
return ipcRenderer.invoke("netcatty:sftp:lstat", { sftpId, path, encoding });
},
chmodSftp: async (sftpId, path, mode, encoding) => {
return ipcRenderer.invoke("netcatty:sftp:chmod", { sftpId, path, mode, encoding });
},
extractSftpArchive: async (sftpId, path, encoding) => {
return ipcRenderer.invoke("netcatty:sftp:extract", { sftpId, path, encoding });
},
getSftpHomeDir: async (sftpId, encoding) => {
return ipcRenderer.invoke("netcatty:sftp:homeDir", { sftpId, encoding });
},
// Local filesystem operations
listLocalDir: async (path) => {
return ipcRenderer.invoke("netcatty:local:list", { path });
},
readLocalFile: async (path, options) => {
return ipcRenderer.invoke("netcatty:local:read", {
path,
maxBytes: options?.maxBytes,
});
},
writeLocalFile: async (path, content) => {
return ipcRenderer.invoke("netcatty:local:write", { path, content });
},
deleteLocalFile: async (path, expectedType) => {
return ipcRenderer.invoke("netcatty:local:delete", { path, expectedType });
},
renameLocalFile: async (oldPath, newPath) => {
return ipcRenderer.invoke("netcatty:local:rename", { oldPath, newPath });
},
extractLocalArchive: async (path) => {
return ipcRenderer.invoke("netcatty:local:extract", { path });
},
mkdirLocal: async (path) => {
return ipcRenderer.invoke("netcatty:local:mkdir", { path });
},
statLocal: async (path) => {
return ipcRenderer.invoke("netcatty:local:stat", { path });
},
lstatLocal: async (path) => {
return ipcRenderer.invoke("netcatty:local:lstat", { path });
},
realpathLocal: async (path) => {
return ipcRenderer.invoke("netcatty:local:realpath", { path });
},
listLocalTree: async (path, options = {}) => {
const onProgress = typeof options?.onProgress === "function" ? options.onProgress : null;
const onEntries = typeof options?.onEntries === "function" ? options.onEntries : null;
const token = typeof options?.scanId === "string" && options.scanId
? options.scanId
: `${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
const progressChannel = onProgress
? `netcatty:local:tree-progress:${token}`
: undefined;
const entriesChannel = onEntries
? `netcatty:local:tree-entries:${token}`
: undefined;
const cancelChannel = `netcatty:local:tree-cancel:${token}`;
const progressHandler = onProgress && progressChannel
? (_event, stats) => {
try {
onProgress(stats);
} catch {
// Ignore renderer progress handler errors so the scan can finish.
}
}
: null;
// Entry batches arrive on a different channel than the invoke reply. If we
// tear down the listener when invoke resolves, nested-folder batches that
// are still in the IPC queue are dropped (top-level files look fine).
let settleEntriesStream = null;
const entriesStreamDone = onEntries && entriesChannel
? new Promise((resolve) => {
settleEntriesStream = resolve;
})
: null;
const entriesHandler = onEntries && entriesChannel
? (_event, payload) => {
if (payload && typeof payload === "object" && !Array.isArray(payload) && payload.type === "tree-end") {
settleEntriesStream?.();
return;
}
try {
if (Array.isArray(payload)) onEntries(payload);
} catch {
// Ignore batch handler errors so the scan can finish.
}
}
: null;
if (progressHandler && progressChannel) {
ipcRenderer.on(progressChannel, progressHandler);
}
if (entriesHandler && entriesChannel) {
ipcRenderer.on(entriesChannel, entriesHandler);
}
try {
const result = await ipcRenderer.invoke("netcatty:local:tree", {
path,
progressChannel,
entriesChannel,
cancelChannel,
limits: options?.limits,
});
if (entriesStreamDone) {
// Wait for the main-process end marker so late nested batches are not
// lost. Fail the scan if the marker never arrives (do not pretend a
// partial tree is complete).
let timedOut = false;
await Promise.race([
entriesStreamDone,
new Promise((resolve) => {
setTimeout(() => {
timedOut = true;
resolve();
}, 5_000);
}),
]);
if (timedOut) {
throw new Error("Local tree scan ended without a completion marker");
}
}
return result;
} finally {
settleEntriesStream?.();
if (progressHandler && progressChannel) {
ipcRenderer.removeListener(progressChannel, progressHandler);
}
if (entriesHandler && entriesChannel) {
ipcRenderer.removeListener(entriesChannel, entriesHandler);
}
}
},
cancelLocalTreeScan: async (scanId) => {
if (typeof scanId === "string" && scanId) {
ipcRenderer.send(`netcatty:local:tree-cancel:${scanId}`);
}
},
getHomeDir: async () => {
return ipcRenderer.invoke("netcatty:local:homedir");
},
listDrives: async () => {
return ipcRenderer.invoke("netcatty:local:drives");
},
getSystemInfo: async () => {
return ipcRenderer.invoke("netcatty:system:info");
},
// Read system known_hosts file
readKnownHosts: async () => {
return ipcRenderer.invoke("netcatty:known-hosts:read");
},
setTheme: async (theme) => {
return ipcRenderer.invoke("netcatty:setTheme", theme);
},
setBackgroundColor: async (color) => {
return ipcRenderer.invoke("netcatty:setBackgroundColor", color);
},
setWindowOpacity: async (opacity) => {
return ipcRenderer.invoke("netcatty:setWindowOpacity", opacity);
},
setAppIconVariant: async (variant) => {
return ipcRenderer.invoke("netcatty:setAppIconVariant", variant);
},
setLanguage: async (language) => {
return ipcRenderer.invoke("netcatty:setLanguage", language);
},
onLanguageChanged: (cb) => {
languageChangeListeners.add(cb);
return () => languageChangeListeners.delete(cb);
},
// Transfer state is delivered only through onGlobalSftpTransferEvent.
startStreamTransfer: async (options) => ipcRenderer.invoke("netcatty:transfer:start", options),
cancelTransfer: async (transferId) => {
return ipcRenderer.invoke("netcatty:transfer:cancel", { transferId });
},
clearPendingTransferCancel: async (transferId) => {
return ipcRenderer.invoke("netcatty:transfer:clear-pending-cancel", { transferId });
},
pauseTransfer: async (transferId) => {
return ipcRenderer.invoke("netcatty:transfer:pause", { transferId });
},
resumeTransfer: async (transferId) => {
return ipcRenderer.invoke("netcatty:transfer:resume", { transferId });
},
prioritizeTransfer: async (transferId) => {
return ipcRenderer.invoke("netcatty:transfer:prioritize", { transferId });
},
setGlobalTransferConcurrency: async (limit) => {
return ipcRenderer.invoke("netcatty:transfer:set-concurrency", { limit });
},
cleanupTransferArtifacts: async (payload) => {
return ipcRenderer.invoke("netcatty:transfer:cleanup", payload);
},
onGlobalSftpTransferEvent: (callback) => {
globalSftpTransferListeners.add(callback);
return () => globalSftpTransferListeners.delete(callback);
},
sameHostCopyDirectory: async (sftpId, sourcePath, targetPath, encoding, transferId) => {
return ipcRenderer.invoke("netcatty:transfer:same-host-copy-dir", { sftpId, sourcePath, targetPath, encoding, transferId });
},
// Compressed folder upload
startCompressedUpload: async (options) => {
return ipcRenderer.invoke("netcatty:compress:start", options);
},
cancelCompressedUpload: async (compressionId) => {
return ipcRenderer.invoke("netcatty:compress:cancel", { compressionId });
},
pauseCompressedUpload: async (compressionId) => {
return ipcRenderer.invoke("netcatty:compress:pause", { compressionId });
},
resumeCompressedUpload: async (compressionId) => {
return ipcRenderer.invoke("netcatty:compress:resume", { compressionId });
},
checkCompressedUploadSupport: async (sftpId) => {
return ipcRenderer.invoke("netcatty:compress:checkSupport", { sftpId });
},
// Window controls for custom title bar
windowMinimize: () => ipcRenderer.invoke("netcatty:window:minimize"),
windowMaximize: () => ipcRenderer.invoke("netcatty:window:maximize"),
windowClose: () => ipcRenderer.invoke("netcatty:window:close"),
windowIsMaximized: () => ipcRenderer.invoke("netcatty:window:isMaximized"),
windowIsFullscreen: () => ipcRenderer.invoke("netcatty:window:isFullscreen"),
windowFocus: () => ipcRenderer.invoke("netcatty:window:focus"),
setTerminalKeyboardFocus: (focused) => ipcRenderer.send(
"netcatty:window:set-terminal-keyboard-focus",
{ focused: focused === true },
),
setWindowTitle: (title) => ipcRenderer.invoke("netcatty:window:setTitle", title),
openSessionInNewWindow: (payload) => ipcRenderer.invoke("netcatty:window:openSession", payload),
openEditorWindow: (payload) => ipcRenderer.invoke("netcatty:window:openEditor", payload),
focusEditorWindow: (editorId) => ipcRenderer.invoke("netcatty:window:focusEditor", { editorId }),
closeEditorWindowTabs: (payload) => ipcRenderer.invoke("netcatty:window:closeEditorTabs", payload),
saveEditorWindowTab: (payload) => ipcRenderer.invoke("netcatty:editorWindow:save", payload),
dockEditorWindowTab: (payload) => ipcRenderer.invoke("netcatty:editorWindow:dock", payload),
reportEditorWindowDirty: (payload) => ipcRenderer.send("netcatty:editorWindow:dirty", payload),
reportEditorWindowTabsClosed: (payload) => ipcRenderer.send("netcatty:editorWindow:tabsClosed", payload),
remapEditorWindowSession: (payload) => ipcRenderer.send("netcatty:editorWindow:remapSession", payload),
onEditorWindowOpenTab: (cb) => {
const editorOpenTabState = ctx.editorOpenTabState || { pending: [], listeners: new Set() };
const receive = (payload) => {
try {
cb(payload);
ipcRenderer.send("netcatty:window:editorOpenTabResult", { requestId: payload.requestId, ok: true });
} catch (err) {
ipcRenderer.send("netcatty:window:editorOpenTabResult", {
requestId: payload.requestId,
ok: false,
error: err?.message || "Failed to open editor tab",
});
}
};
editorOpenTabState.listeners.add(receive);
// Drain only to the currently mounted receiver. Deferring this would let
// StrictMode cleanup leave a stale callback holding the transfer.
for (const payload of editorOpenTabState.pending.splice(0)) receive(payload);
ipcRenderer.send("netcatty:window:editorReady");
return () => editorOpenTabState.listeners.delete(receive);
},
onEditorWindowActivateTab: (cb) => {
const handler = (_event, payload) => cb(payload);
ipcRenderer.on("netcatty:window:editorActivateTab", handler);
return () => ipcRenderer.removeListener("netcatty:window:editorActivateTab", handler);
},
onEditorWindowCloseTabs: (cb) => {
const handler = (_event, payload) => cb(payload);
ipcRenderer.on("netcatty:window:editorCloseTabs", handler);
return () => ipcRenderer.removeListener("netcatty:window:editorCloseTabs", handler);
},
reportEditorWindowCloseTabsResult: (payload) => {
ipcRenderer.send("netcatty:window:editorCloseTabsResult", payload);
},
onEditorWindowRemapSession: (cb) => {
const handler = (_event, payload) => cb(payload);
ipcRenderer.on("netcatty:window:editorRemapSession", handler);
return () => ipcRenderer.removeListener("netcatty:window:editorRemapSession", handler);
},
onEditorWindowSaveRequest: (cb) => {
const handler = (_event, payload) => cb(payload);
ipcRenderer.on("netcatty:window:editorSaveRequest", handler);
return () => ipcRenderer.removeListener("netcatty:window:editorSaveRequest", handler);
},
reportEditorWindowSaveResult: (payload) => {
ipcRenderer.send("netcatty:window:editorSaveResult", payload);
},
onEditorWindowDockRequest: (cb) => {
const handler = (_event, payload) => cb(payload);
ipcRenderer.on("netcatty:window:editorDockRequest", handler);
return () => ipcRenderer.removeListener("netcatty:window:editorDockRequest", handler);
},
reportEditorWindowDockResult: (payload) => {
ipcRenderer.send("netcatty:window:editorDockResult", payload);
},
onEditorWindowDirtyChanged: (cb) => {
const handler = (_event, payload) => cb(payload);
ipcRenderer.on("netcatty:window:editorDirtyChanged", handler);
return () => ipcRenderer.removeListener("netcatty:window:editorDirtyChanged", handler);
},
onEditorWindowTabsClosed: (cb) => {
const handler = (_event, payload) => cb(payload);
ipcRenderer.on("netcatty:window:editorTabsClosed", handler);
return () => ipcRenderer.removeListener("netcatty:window:editorTabsClosed", handler);
},
onOpenSessionInNewWindow: (cb) => {
const handler = (_event, payload) => cb(payload);
ipcRenderer.on("netcatty:window:openSession", handler);
return () => ipcRenderer.removeListener("netcatty:window:openSession", handler);
},
onWindowCommandCloseRequested: (cb) => {
const handler = () => cb();
ipcRenderer.on("netcatty:window:command-close", handler);
return () => ipcRenderer.removeListener("netcatty:window:command-close", handler);
},
onWindowFullScreenChanged: (cb) => {
fullscreenChangeListeners.add(cb);
return () => fullscreenChangeListeners.delete(cb);
},
onWindowShown: (cb) => {
windowShownListeners.add(cb);
return () => windowShownListeners.delete(cb);
},
onWindowFocusRequested: (cb) => {
windowFocusRequestedListeners.add(cb);
return () => windowFocusRequestedListeners.delete(cb);
},
onWindowWillHide: (cb) => {
windowWillHideListeners.add(cb);
return () => windowWillHideListeners.delete(cb);
},
// Settings window
openSettingsWindow: () => ipcRenderer.invoke("netcatty:settings:open"),
closeSettingsWindow: () => ipcRenderer.invoke("netcatty:settings:close"),
// Cross-window settings sync
notifySettingsChanged: (payload) => ipcRenderer.send("netcatty:settings:changed", payload),
onSettingsChanged: (callback) => {
const handler = (_event, payload) => callback(payload);
ipcRenderer.on("netcatty:settings:changed", handler);
return () => ipcRenderer.removeListener("netcatty:settings:changed", handler);
},
getAppLockRuntimeState: () => ipcRenderer.invoke("netcatty:appLock:getRuntimeState"),
getAppLockSettings: () => ipcRenderer.invoke("netcatty:appLock:getSettings"),
setAppLockTimeoutMinutes: (timeoutMinutes) =>
ipcRenderer.invoke("netcatty:appLock:setTimeoutMinutes", timeoutMinutes),
requestAppLockEnable: () => ipcRenderer.invoke("netcatty:appLock:requestEnable"),
requestAppLockDisable: (currentPassword) =>
ipcRenderer.invoke("netcatty:appLock:requestDisable", currentPassword),
requestAppLockReset: (currentPassword) =>
ipcRenderer.invoke("netcatty:appLock:requestReset", currentPassword),
requestAppLockPasswordChange: (input) =>
ipcRenderer.invoke("netcatty:appLock:requestPasswordChange", input),
setAppLockRuntimeLocked: (reason) =>
ipcRenderer.invoke("netcatty:appLock:setLocked", reason),
requestAppLockUnlock: (password) =>
ipcRenderer.invoke("netcatty:appLock:requestUnlock", password),
getAppLockSystemUnlockStatus: () =>
ipcRenderer.invoke("netcatty:appLock:getSystemUnlockStatus"),
setAppLockSystemUnlockEnabled: (input) =>
ipcRenderer.invoke("netcatty:appLock:setSystemUnlockEnabled", input),
requestAppLockSystemUnlock: () =>
ipcRenderer.invoke("netcatty:appLock:requestSystemUnlock"),
reportAppLockActivity: () =>
ipcRenderer.invoke("netcatty:appLock:reportActivity"),
onAppLockSettingsChanged: (callback) => {
const handler = (_event, payload) => callback(payload);
ipcRenderer.on("netcatty:appLock:settingsChanged", handler);
return () => ipcRenderer.removeListener("netcatty:appLock:settingsChanged", handler);
},
onAppLockRuntimeStateChanged: (callback) => {
const handler = (_event, payload) => callback(payload);
ipcRenderer.on("netcatty:appLock:runtimeStateChanged", handler);
return () => ipcRenderer.removeListener("netcatty:appLock:runtimeStateChanged", handler);
},
getSshDebugLogInfo: () => ipcRenderer.invoke("netcatty:sshDebugLog:info"),
openSshDebugLogDir: () => ipcRenderer.invoke("netcatty:sshDebugLog:openDir"),
// Cloud sync session (in-memory only, shared across windows)
cloudSyncSetSessionPassword: (password) =>
ipcRenderer.invoke("netcatty:cloudSync:session:setPassword", password),
onCloudSyncSessionPasswordAvailable: (callback) => {
const handler = () => callback();
ipcRenderer.on("netcatty:cloudSync:session:passwordAvailable", handler);
return () => ipcRenderer.removeListener("netcatty:cloudSync:session:passwordAvailable", handler);
},
cloudSyncGetSessionPassword: () =>
ipcRenderer.invoke("netcatty:cloudSync:session:getPassword"),
cloudSyncClearSessionPassword: () =>
ipcRenderer.invoke("netcatty:cloudSync:session:clearPassword"),
// Cloud sync network operations (proxied via main process)
cloudSyncWebdavInitialize: (config) =>
ipcRenderer.invoke("netcatty:cloudSync:webdav:initialize", { config }),
cloudSyncWebdavUpload: (config, syncedFile) =>
ipcRenderer.invoke("netcatty:cloudSync:webdav:upload", { config, syncedFile }),
cloudSyncWebdavDownload: (config) =>
ipcRenderer.invoke("netcatty:cloudSync:webdav:download", { config }),
cloudSyncWebdavDelete: (config) =>
ipcRenderer.invoke("netcatty:cloudSync:webdav:delete", { config }),
cloudSyncS3Initialize: (config) =>
ipcRenderer.invoke("netcatty:cloudSync:s3:initialize", { config }),
cloudSyncS3Upload: (config, syncedFile) =>
ipcRenderer.invoke("netcatty:cloudSync:s3:upload", { config, syncedFile }),
cloudSyncS3Download: (config) =>
ipcRenderer.invoke("netcatty:cloudSync:s3:download", { config }),
cloudSyncS3Delete: (config) =>
ipcRenderer.invoke("netcatty:cloudSync:s3:delete", { config }),
// Open URL in default browser
openExternal: (url) => ipcRenderer.invoke("netcatty:openExternal", url),
focusHostBrowser: (hostId) => ipcRenderer.invoke("netcatty:host-browser:focus", hostId),
setHostBrowserPanelLayout: (options) => ipcRenderer.invoke("netcatty:host-browser:panel-layout", options),
closeHostBrowserPanel: (browserId) => ipcRenderer.invoke("netcatty:host-browser:panel-close", browserId),
getHostBrowserPanelState: (browserId) => ipcRenderer.invoke("netcatty:host-browser:snapshot", browserId),
commandHostBrowserPanel: (browserId, command) => ipcRenderer.invoke("netcatty:host-browser:command", command, browserId),
listHostBrowserPanelBookmarks: (browserId) => ipcRenderer.invoke("netcatty:host-browser:bookmarks:list", browserId),
saveHostBrowserPanelBookmark: (browserId, bookmark) => ipcRenderer.invoke("netcatty:host-browser:bookmarks:upsert", bookmark, browserId),
removeHostBrowserPanelBookmark: (browserId, id) => ipcRenderer.invoke("netcatty:host-browser:bookmarks:remove", id, browserId),
listHostBrowserPanelDownloads: (browserId) => ipcRenderer.invoke("netcatty:host-browser:downloads:list", browserId),
commandHostBrowserPanelDownload: (browserId, command) => ipcRenderer.invoke("netcatty:host-browser:downloads:command", command, browserId),
onHostBrowserPanelEvent: (callback) => {
const listener = (_event, value) => callback(value);
ipcRenderer.on("netcatty:host-browser:panel-event", listener);
return () => ipcRenderer.removeListener("netcatty:host-browser:panel-event", listener);
},
openHostBrowserUrl: (options) => ipcRenderer.invoke("netcatty:host-browser:panel-url", options),
requestHostBrowserPanel: (request) => ipcRenderer.invoke("netcatty:host-browser:request-panel", request),
onHostBrowserPanelRequest: (callback) => {
hostBrowserPanelListeners.add(callback);
for (const request of pendingHostBrowserPanels.splice(0)) callback(request);
return () => hostBrowserPanelListeners.delete(callback);
},
openHostBrowser: (options) => ipcRenderer.invoke("netcatty:host-browser:open", options),
getHostBrowserBookmarks: () => ipcRenderer.invoke("netcatty:host-browser:bookmarks:get-all"),
applyHostBrowserBookmarks: (items) => ipcRenderer.invoke("netcatty:host-browser:bookmarks:apply", items),
onHostBrowserBookmarksChanged: (callback) => {
const listener = () => callback();
ipcRenderer.on("netcatty:host-browser:bookmarks-changed", listener);
return () => ipcRenderer.removeListener("netcatty:host-browser:bookmarks-changed", listener);
},
openPath: (path) => ipcRenderer.invoke("netcatty:openPath", path),
// App info
getAppInfo: () => ipcRenderer.invoke("netcatty:app:getInfo"),
ptyGetChildProcesses: (sessionId) =>
ipcRenderer.invoke("netcatty:pty:childProcesses", sessionId),
confirmCloseBusy: (payload) =>
ipcRenderer.invoke("netcatty:dialog:confirmCloseBusy", payload),
getVaultBackupCapabilities: () =>
ipcRenderer.invoke("netcatty:vaultBackups:capabilities"),
createVaultBackup: (payload) =>
ipcRenderer.invoke("netcatty:vaultBackups:create", payload),
listVaultBackups: () =>
ipcRenderer.invoke("netcatty:vaultBackups:list"),
readVaultBackup: (payload) =>
ipcRenderer.invoke("netcatty:vaultBackups:read", payload),
trimVaultBackups: (payload) =>
ipcRenderer.invoke("netcatty:vaultBackups:trim", payload),
clearVaultBackups: () =>
ipcRenderer.invoke("netcatty:vaultBackups:clear"),
openVaultBackupDir: () =>
ipcRenderer.invoke("netcatty:vaultBackups:openDir"),
// Subscribe to cross-window "backups changed" events emitted by the
// main process whenever a create/trim actually mutated the on-disk
// set. Returns an unsubscribe function so React-style consumers can
// release the listener on unmount without leaking IPC handlers.
onVaultBackupsChanged: (handler) => {
if (typeof handler !== "function") return () => {};
const listener = () => {
try { handler(); } catch (error) {
console.warn("[preload] onVaultBackupsChanged handler threw:", error);
}
};
ipcRenderer.on("netcatty:vaultBackups:changed", listener);
return () => {
try { ipcRenderer.removeListener("netcatty:vaultBackups:changed", listener); }
catch { /* ignore */ }
};
},
// Tell main process the renderer has mounted/painted (used to avoid initial blank screen).
rendererReady: () => ipcRenderer.send("netcatty:renderer:ready"),
onSshDeepLink: (callback) => {
const handler = (_event, payload) => callback(payload);
ipcRenderer.on("netcatty:deepLink:ssh", handler);
return () => ipcRenderer.removeListener("netcatty:deepLink:ssh", handler);
},
onTelnetDeepLink: (callback) => {
const handler = (_event, payload) => callback(payload);
ipcRenderer.on("netcatty:deepLink:telnet", handler);
return () => ipcRenderer.removeListener("netcatty:deepLink:telnet", handler);
},
onOpenTerminalPath: (callback) => {
const handler = (_event, payload) => callback(payload);
ipcRenderer.on("netcatty:openTerminalPath", handler);
return () => ipcRenderer.removeListener("netcatty:openTerminalPath", handler);
},
onColdStartIntentsSettled: (callback) => {
const handler = () => callback();
ipcRenderer.on("netcatty:startup:coldStartIntentsSettled", handler);
return () => ipcRenderer.removeListener("netcatty:startup:coldStartIntentsSettled", handler);
},
setSshDeepLinkEnabled: (enabled) =>
ipcRenderer.invoke("netcatty:deepLink:ssh:setEnabled", { enabled }),
getSshDeepLinkEnabled: () =>
ipcRenderer.invoke("netcatty:deepLink:ssh:getEnabled"),
onJmsDeepLink: (callback) => {
const handler = (_event, payload) => callback(payload);
ipcRenderer.on("netcatty:deepLink:jms", handler);
return () => ipcRenderer.removeListener("netcatty:deepLink:jms", handler);
},
setJmsDeepLinkEnabled: (enabled) =>
ipcRenderer.invoke("netcatty:deepLink:jms:setEnabled", { enabled }),
getJmsDeepLinkEnabled: () =>
ipcRenderer.invoke("netcatty:deepLink:jms:getEnabled"),
setExplorerContextMenuEnabled: (enabled) =>
ipcRenderer.invoke("netcatty:explorerContextMenu:setEnabled", { enabled }),
getExplorerContextMenuEnabled: () =>
ipcRenderer.invoke("netcatty:explorerContextMenu:getEnabled"),
// Quit guard: main process asks whether any editor tabs have unsaved changes.
// Returns an unsubscribe function so React effects can clean up on unmount.
onCheckDirtyEditors: (listener) => {
const handler = () => listener();
ipcRenderer.on("app:query-dirty-editors", handler);
return () => ipcRenderer.removeListener("app:query-dirty-editors", handler);
},
// Renderer reports the dirty-check result back to the main process.
reportDirtyEditorsResult: (hasDirty, reason) => ipcRenderer.send("app:dirty-editors-result", { hasDirty, reason }),
// Port Forwarding API
startPortForward: async (options) => {
return ipcRenderer.invoke("netcatty:portforward:start", options);
},
stopPortForward: async (tunnelId) => {
return ipcRenderer.invoke("netcatty:portforward:stop", { tunnelId });
},
getPortForwardStatus: async (tunnelId) => {
return ipcRenderer.invoke("netcatty:portforward:status", { tunnelId });
},
subscribePortForward: async (tunnelId) => {
return ipcRenderer.invoke("netcatty:portforward:subscribe", { tunnelId });
},
listPortForwards: async () => {
return ipcRenderer.invoke("netcatty:portforward:list");
},
getPortForwardSnapshot: async () => {
return ipcRenderer.invoke("netcatty:portforward:snapshot");
},
subscribePortForwardRuntime: async () => {
return ipcRenderer.invoke("netcatty:portforward:subscribeRuntime");
},
unsubscribePortForwardRuntime: async () => {
return ipcRenderer.invoke("netcatty:portforward:unsubscribeRuntime");
},
stopAllPortForwards: async () => {
return ipcRenderer.invoke("netcatty:portforward:stopAll");
},
stopPortForwardByRuleId: async (ruleId) => {
return ipcRenderer.invoke("netcatty:portforward:stopByRuleId", { ruleId });
},
onPortForwardStatus: (tunnelId, cb) => {
if (!portForwardStatusListeners.has(tunnelId)) {
portForwardStatusListeners.set(tunnelId, new Set());
}
portForwardStatusListeners.get(tunnelId).add(cb);
return () => {
portForwardStatusListeners.get(tunnelId)?.delete(cb);
if (portForwardStatusListeners.get(tunnelId)?.size === 0) {
portForwardStatusListeners.delete(tunnelId);
}
};
},
onPortForwardRuntime: (cb) => {
portForwardRuntimeListeners.add(cb);
return () => {
portForwardRuntimeListeners.delete(cb);
};
},
// Chain progress listener for jump host connections
onChainProgress: (cb) => {
const id = randomUUID();
chainProgressListeners.set(id, cb);
return () => {
chainProgressListeners.delete(id);
};
},
onConnectionReuseFallback: (cb) => {
connectionReuseFallbackListeners.add(cb);
return () => {
connectionReuseFallbackListeners.delete(cb);
};
},
// SFTP connection progress listener (auth method logs)
onSftpConnectionProgress: (cb) => {
sftpConnectionProgressListeners.add(cb);
return () => {
sftpConnectionProgressListeners.delete(cb);
};
},
// OAuth callback server — two-step so the renderer can learn the bound
// port (which may differ from the preferred 45678 if it was in use) and
// embed it into the provider's redirect_uri before opening the browser.
prepareOAuthCallback: () => ipcRenderer.invoke("oauth:prepareCallback"),
awaitOAuthCallback: (expectedState, sessionId) =>
ipcRenderer.invoke("oauth:awaitCallback", expectedState, sessionId),
cancelOAuthCallback: (sessionId) => ipcRenderer.invoke("oauth:cancelCallback", sessionId),
// GitHub Device Flow (proxied via main process to avoid CORS)
githubStartDeviceFlow: (options) => ipcRenderer.invoke("netcatty:github:deviceFlow:start", options),
githubPollDeviceFlowToken: (options) => ipcRenderer.invoke("netcatty:github:deviceFlow:poll", options),
githubCancelDeviceFlowPoll: (pollId) => ipcRenderer.invoke("netcatty:github:deviceFlow:cancelPoll", pollId),
githubDownloadGistRawContent: (options) => ipcRenderer.invoke("netcatty:github:gistRawContent", options),
// Google OAuth (proxied via main process to avoid CORS)
googleExchangeCodeForTokens: (options) =>
ipcRenderer.invoke("netcatty:google:oauth:exchange", options),
googleRefreshAccessToken: (options) =>
ipcRenderer.invoke("netcatty:google:oauth:refresh", options),
googleGetUserInfo: (options) =>
ipcRenderer.invoke("netcatty:google:oauth:userinfo", options),
// Google Drive API (proxied via main process to avoid CORS/COEP issues in renderer)
googleDriveFindSyncFile: (options) =>
ipcRenderer.invoke("netcatty:google:drive:findSyncFile", options),
googleDriveCreateSyncFile: (options) =>
ipcRenderer.invoke("netcatty:google:drive:createSyncFile", options),
googleDriveUpdateSyncFile: (options) =>
ipcRenderer.invoke("netcatty:google:drive:updateSyncFile", options),
googleDriveDownloadSyncFile: (options) =>
ipcRenderer.invoke("netcatty:google:drive:downloadSyncFile", options),
googleDriveDeleteSyncFile: (options) =>
ipcRenderer.invoke("netcatty:google:drive:deleteSyncFile", options),
// OneDrive OAuth + Graph (proxied via main process to avoid CORS)
onedriveExchangeCodeForTokens: (options) =>
ipcRenderer.invoke("netcatty:onedrive:oauth:exchange", options),
onedriveRefreshAccessToken: (options) =>
ipcRenderer.invoke("netcatty:onedrive:oauth:refresh", options),
onedriveGetUserInfo: (options) =>
ipcRenderer.invoke("netcatty:onedrive:oauth:userinfo", options),
onedriveFindSyncFile: (options) =>
ipcRenderer.invoke("netcatty:onedrive:drive:findSyncFile", options),
onedriveUploadSyncFile: (options) =>
ipcRenderer.invoke("netcatty:onedrive:drive:uploadSyncFile", options),
onedriveDownloadSyncFile: (options) =>
ipcRenderer.invoke("netcatty:onedrive:drive:downloadSyncFile", options),
onedriveDeleteSyncFile: (options) =>
ipcRenderer.invoke("netcatty:onedrive:drive:deleteSyncFile", options),
// File opener helpers (for "Open With" feature)
selectApplication: () =>
ipcRenderer.invoke("netcatty:selectApplication"),
openWithApplication: (filePath, appPath) =>
ipcRenderer.invoke("netcatty:openWithApplication", { filePath, appPath }),
openWithSystemDefault: (filePath) =>
ipcRenderer.invoke("netcatty:openWithSystemDefault", { filePath }),
downloadSftpToTempWithProgress: (sftpId, remotePath, fileName, encoding, transferId) =>
ipcRenderer.invoke("netcatty:sftp:downloadToTempWithProgress", {
sftpId,
remotePath,
fileName,
encoding,
transferId,
}),
// Save dialog for file downloads
showSaveDialog: (defaultPath, filters) =>
ipcRenderer.invoke("netcatty:showSaveDialog", { defaultPath, filters }),
selectDirectory: (title, defaultPath) =>
ipcRenderer.invoke("netcatty:selectDirectory", { title, defaultPath }),
selectFile: (title, defaultPath, filters) =>
ipcRenderer.invoke("netcatty:selectFile", { title, defaultPath, filters }),
// File watcher for auto-sync feature
startFileWatch: (localPath, remotePath, sftpId, encoding) =>
ipcRenderer.invoke("netcatty:filewatch:start", { localPath, remotePath, sftpId, encoding }),
stopFileWatch: (watchId, cleanupTempFile = false) =>
ipcRenderer.invoke("netcatty:filewatch:stop", { watchId, cleanupTempFile }),
listFileWatches: () =>
ipcRenderer.invoke("netcatty:filewatch:list"),
registerTempFile: (sftpId, localPath) =>
ipcRenderer.invoke("netcatty:filewatch:registerTempFile", { sftpId, localPath }),
unregisterTempFile: (sftpId, localPath) =>
ipcRenderer.invoke("netcatty:filewatch:unregisterTempFile", { sftpId, localPath }),
onFileWatchSynced: (cb) => {
fileWatchSyncedListeners.add(cb);
return () => fileWatchSyncedListeners.delete(cb);
},
onFileWatchError: (cb) => {
fileWatchErrorListeners.add(cb);
return () => fileWatchErrorListeners.delete(cb);
},
onFileWatchStopped: (cb) => {
fileWatchStoppedListeners.add(cb);
return () => fileWatchStoppedListeners.delete(cb);
},
// Temp file cleanup
deleteTempFile: (filePath) =>
ipcRenderer.invoke("netcatty:deleteTempFile", { filePath }),
// Temp directory management
getTempDirInfo: () =>
ipcRenderer.invoke("netcatty:tempdir:getInfo"),
clearTempDir: () =>
ipcRenderer.invoke("netcatty:tempdir:clear"),
getTempDirPath: () =>
ipcRenderer.invoke("netcatty:tempdir:getPath"),
openTempDir: () =>
ipcRenderer.invoke("netcatty:tempdir:open"),
getToolOutputPersistenceStatus: () =>
ipcRenderer.invoke("netcatty:tempdir:toolOutputPersistenceStatus"),
writeToolOutputTemp: (record, content) =>
ipcRenderer.invoke("netcatty:tempdir:toolOutputWrite", { record, content }),
restoreToolOutputTemp: (handleId, chatSessionId) =>
ipcRenderer.invoke("netcatty:tempdir:toolOutputRestore", { handleId, chatSessionId }),
readToolOutputTemp: (filePath, request) =>
ipcRenderer.invoke("netcatty:tempdir:toolOutputRead", { path: filePath, request }),
deleteToolOutputTemp: (filePath) =>
ipcRenderer.invoke("netcatty:tempdir:toolOutputDelete", { path: filePath }),
deleteChatToolOutputsTemp: (chatSessionId) =>
ipcRenderer.invoke("netcatty:tempdir:toolOutputDeleteSession", { chatSessionId }),
deleteTerminalToolOutputsTemp: (chatSessionId, terminalSessionId) =>
ipcRenderer.invoke("netcatty:tempdir:toolOutputDeleteTerminalSession", { chatSessionId, terminalSessionId }),
deleteTerminalToolOutputsEverywhereTemp: (terminalSessionId) =>
ipcRenderer.invoke("netcatty:tempdir:toolOutputDeleteTerminal", { terminalSessionId }),
// Session Logs
exportSessionLog: (payload) =>
ipcRenderer.invoke("netcatty:sessionLogs:export", payload),
selectSessionLogsDir: () =>
ipcRenderer.invoke("netcatty:sessionLogs:selectDir"),
autoSaveSessionLog: (payload) =>
ipcRenderer.invoke("netcatty:sessionLogs:autoSave", payload),
openSessionLogsDir: (directory) =>
ipcRenderer.invoke("netcatty:sessionLogs:openDir", { directory }),
clearSessionLogsDir: (directory) =>
ipcRenderer.invoke("netcatty:sessionLogs:clear", { directory }),
chooseManualSessionLogPath: (payload) =>
ipcRenderer.invoke("netcatty:sessionLog:manualChoosePath", payload),
startManualSessionLog: (payload) =>
ipcRenderer.invoke("netcatty:sessionLog:manualStart", payload),
stopManualSessionLog: (payload) =>
ipcRenderer.invoke("netcatty:sessionLog:manualStop", payload),
getManualSessionLogStatus: (payload) =>
ipcRenderer.invoke("netcatty:sessionLog:manualStatus", payload),
// Crash Logs
getCrashLogs: () =>
ipcRenderer.invoke("netcatty:crashLogs:list"),
readCrashLog: (fileName) =>
ipcRenderer.invoke("netcatty:crashLogs:read", { fileName }),
clearCrashLogs: () =>
ipcRenderer.invoke("netcatty:crashLogs:clear"),
openCrashLogsDir: () =>
ipcRenderer.invoke("netcatty:crashLogs:openDir"),
// Global Toggle Hotkey (Quake Mode)
registerGlobalHotkey: (hotkey) =>
ipcRenderer.invoke("netcatty:globalHotkey:register", { hotkey }),
unregisterGlobalHotkey: () =>
ipcRenderer.invoke("netcatty:globalHotkey:unregister"),
getGlobalHotkeyStatus: () =>
ipcRenderer.invoke("netcatty:globalHotkey:status"),
// System Tray / Close to Tray
setCloseToTray: (enabled) =>
ipcRenderer.invoke("netcatty:tray:setCloseToTray", { enabled }),
isCloseToTray: () =>
ipcRenderer.invoke("netcatty:tray:isCloseToTray"),
setShowTrayIcon: (enabled) =>
ipcRenderer.invoke("netcatty:tray:setShowTrayIcon", { enabled }),
isShowTrayIcon: () =>
ipcRenderer.invoke("netcatty:tray:isShowTrayIcon"),
// Auto Launch at system login (hidden to tray)
getAutoLaunch: () =>
ipcRenderer.invoke("netcatty:autoLaunch:get"),
setAutoLaunch: (enabled) =>
ipcRenderer.invoke("netcatty:autoLaunch:set", { enabled }),
// App-level HTTP(S) network proxy (cloud sync / AI providers)
setHttpNetworkProxy: (settings) =>
ipcRenderer.invoke("netcatty:networkProxy:set", settings),
getHttpNetworkProxy: () =>
ipcRenderer.invoke("netcatty:networkProxy:get"),
updateTrayMenuData: (data) =>
ipcRenderer.invoke("netcatty:tray:updateMenuData", data),
onAppLockReopen: (callback) => {
const handler = () => callback();
ipcRenderer.on("netcatty:app-lock:reopen", handler);
return () => ipcRenderer.removeListener("netcatty:app-lock:reopen", handler);
},
// Listen for tray menu actions
onTrayFocusSession: (callback) => {
const handler = (_event, sessionId) => callback(sessionId);
ipcRenderer.on("netcatty:tray:focusSession", handler);
return () => ipcRenderer.removeListener("netcatty:tray:focusSession", handler);
},
onTrayTogglePortForward: (callback) => {
const handler = (_event, ruleId, start) => callback(ruleId, start);
const startHandler = (_event, ruleId) => callback(ruleId, true);
ipcRenderer.on("netcatty:tray:togglePortForward", handler);
ipcRenderer.on("netcatty:trayPanel:startPortForward", startHandler);
return () => {
ipcRenderer.removeListener("netcatty:tray:togglePortForward", handler);
ipcRenderer.removeListener("netcatty:trayPanel:startPortForward", startHandler);
};
},
// Tray panel actions forwarded to main window
onTrayPanelJumpToSession: (callback) => {
const handler = (_event, sessionId) => callback(sessionId);
ipcRenderer.on("netcatty:trayPanel:jumpToSession", handler);
return () => ipcRenderer.removeListener("netcatty:trayPanel:jumpToSession", handler);
},
onTrayPanelConnectToHost: (callback) => {
const handler = (_event, hostId) => callback(hostId);
ipcRenderer.on("netcatty:trayPanel:connectToHost", handler);
return () => ipcRenderer.removeListener("netcatty:trayPanel:connectToHost", handler);
},
onTrayPanelCloseSession: (callback) => {
const handler = (_event, sessionId) => callback(sessionId);
ipcRenderer.on("netcatty:trayPanel:closeSession", handler);
return () => ipcRenderer.removeListener("netcatty:trayPanel:closeSession", handler);
},
// Tray panel window
hideTrayPanel: () => ipcRenderer.invoke("netcatty:trayPanel:hide"),
openMainWindow: () => ipcRenderer.invoke("netcatty:trayPanel:openMainWindow"),
quitApp: () => ipcRenderer.invoke("netcatty:trayPanel:quitApp"),
jumpToSessionFromTrayPanel: (sessionId) =>
ipcRenderer.invoke("netcatty:trayPanel:jumpToSession", sessionId),
connectToHostFromTrayPanel: (hostId) =>
ipcRenderer.invoke("netcatty:trayPanel:connectToHost", hostId),
startPortForwardFromTrayPanel: (ruleId) =>
ipcRenderer.invoke("netcatty:trayPanel:startPortForward", ruleId),
closeSessionFromTrayPanel: (sessionId) =>
ipcRenderer.invoke("netcatty:trayPanel:closeSession", sessionId),
onTrayPanelCloseRequest: (callback) => {
const handler = () => callback();
ipcRenderer.on("netcatty:trayPanel:closeRequest", handler);
return () => ipcRenderer.removeListener("netcatty:trayPanel:closeRequest", handler);
},
onTrayPanelRefresh: (callback) => {
const handler = () => callback();
ipcRenderer.on("netcatty:trayPanel:refresh", handler);
return () => ipcRenderer.removeListener("netcatty:trayPanel:refresh", handler);
},
onTrayPanelMenuData: (callback) => {
// Replay buffered data so late subscribers (e.g. after React lazy-mount) don't miss
// the initial payload that was sent before the useEffect listener was registered.
if (_lastTrayMenuData) {
queueMicrotask(() => callback(_lastTrayMenuData));
}
const handler = (_event, data) => {
_lastTrayMenuData = data;
callback(data);
};
ipcRenderer.on("netcatty:trayPanel:setMenuData", handler);
return () => ipcRenderer.removeListener("netcatty:trayPanel:setMenuData", handler);
},
// Get file path from File object (for drag-and-drop)
startLocalFileDrag: (payload) => ipcRenderer.invoke("netcatty:local:drag-start", payload),
cancelLocalFileDrag: (requestId) => ipcRenderer.send("netcatty:local:drag-cancel", { requestId }),
getPathForFile: (file) => {
try {
return webUtils.getPathForFile(file);
} catch {
return undefined;
}
},
stageUploadFile: async (file, transferId) => {
uploadStageControllers.get(transferId)?.abort(new Error("Upload staging superseded"));
const controller = new AbortController();
uploadStageControllers.set(transferId, controller);
let localPath = null;
try {
localPath = await ipcRenderer.invoke("netcatty:tempdir:createUploadPath", {
transferId: `${transferId}-${randomUUID()}`,
fileName: file?.name || "upload.bin",
});
return await stageRendererFileToTemp(file, localPath, fs, controller.signal);
} catch (error) {
if (localPath) {
await ipcRenderer.invoke("netcatty:deleteTempFile", { filePath: localPath }).catch(() => {});
}
throw error;
} finally {
if (uploadStageControllers.get(transferId) === controller) {
uploadStageControllers.delete(transferId);
}
}
},
cancelStagedUploadFile: async (transferId) => {
const controller = uploadStageControllers.get(transferId);
if (!controller) return { success: false };
controller.abort(new Error("Upload staging cancelled"));
return { success: true };
},
showSystemNotification: async (payload) => {
return ipcRenderer.invoke("netcatty:notification:show", payload ?? {});
},
setExternalMcpApprovalAlertMode: async (payload) => {
return ipcRenderer.invoke("netcatty:mcp:approval-alert-mode", payload ?? {});
},
// Clipboard fallback helpers
readClipboardText: async () => {
return ipcRenderer.invoke("netcatty:clipboard:readText");
},
writeClipboardText: async (text) => {
return ipcRenderer.invoke("netcatty:clipboard:writeText", text);
},
readClipboardFiles: async () => {
return ipcRenderer.invoke("netcatty:clipboard:readFiles");
},
readClipboardImage: async () => {
return ipcRenderer.invoke("netcatty:clipboard:readImage");
},
hasClipboardImage: async () => {
return ipcRenderer.invoke("netcatty:clipboard:hasImage");
},
// Credential encryption (field-level safeStorage)
credentialsAvailable: () => ipcRenderer.invoke("netcatty:credentials:available"),
credentialsEncrypt: (plaintext) => ipcRenderer.invoke("netcatty:credentials:encrypt", plaintext),
credentialsDecrypt: (value) => ipcRenderer.invoke("netcatty:credentials:decrypt", value),
previewTotp: (payload) => ipcRenderer.invoke("netcatty:totp:preview", payload),
scanTotpQrFromScreen: () => ipcRenderer.invoke("netcatty:totp:scan-screen"),
// Auto-update
checkForUpdate: () => ipcRenderer.invoke("netcatty:update:check"),
downloadUpdate: () => ipcRenderer.invoke("netcatty:update:download"),
installUpdate: () => ipcRenderer.invoke("netcatty:update:install"),
getUpdateStatus: () => ipcRenderer.invoke("netcatty:update:getStatus"),
setAutoUpdate: (enabled) => ipcRenderer.invoke("netcatty:update:setAutoUpdate", { enabled }),
getAutoUpdate: () => ipcRenderer.invoke("netcatty:update:getAutoUpdate"),
onUpdateAvailable: (cb) => {
updateAvailableListeners.add(cb);
return () => updateAvailableListeners.delete(cb);
},
onUpdateNotAvailable: (cb) => {
updateNotAvailableListeners.add(cb);
return () => updateNotAvailableListeners.delete(cb);
},
onUpdateDownloadProgress: (cb) => {
updateDownloadProgressListeners.add(cb);
return () => updateDownloadProgressListeners.delete(cb);
},
onUpdateDownloaded: (cb) => {
updateDownloadedListeners.add(cb);
return () => updateDownloadedListeners.delete(cb);
},
onUpdateError: (cb) => {
updateErrorListeners.add(cb);
return () => updateErrorListeners.delete(cb);
},
onUpdateNeedsSave: (cb) => {
updateNeedsSaveListeners.add(cb);
return () => updateNeedsSaveListeners.delete(cb);
},
// ── AI Bridge ──
aiSyncProviders: async (providers) => {
return ipcRenderer.invoke("netcatty:ai:sync-providers", { providers });
},
aiSyncWebSearch: async (apiHost, apiKey) => {
return ipcRenderer.invoke("netcatty:ai:sync-web-search", { apiHost, apiKey });
},
aiChatStream: async (requestId, url, headers, body, providerId, idleTimeoutMs) => {
return ipcRenderer.invoke("netcatty:ai:chat:stream", {
requestId,
url,
headers,
body,
providerId,
idleTimeoutMs,
});
},
aiChatCancel: async (requestId) => {
return ipcRenderer.invoke("netcatty:ai:chat:cancel", { requestId });
},
aiFetch: async (url, method, headers, body, providerId, skipHostCheck, followRedirects, skipTLSVerify) => {
return ipcRenderer.invoke("netcatty:ai:fetch", { url, method, headers, body, providerId, skipHostCheck, followRedirects, skipTLSVerify });
},
aiAllowlistAddHost: async (baseURL) => {
return ipcRenderer.invoke("netcatty:ai:allowlist:add-host", { baseURL });
},
aiExec: async (sessionId, command, chatSessionId) => {
return ipcRenderer.invoke("netcatty:ai:exec", { sessionId, command, chatSessionId });
},
aiCattyCancelExec: async (chatSessionId) => {
return ipcRenderer.invoke("netcatty:ai:catty:cancel", { chatSessionId });
},
aiSetChatSessionCancelled: async (chatSessionId, cancelled = true) => {
return ipcRenderer.invoke("netcatty:ai:chat-session:set-cancelled", { chatSessionId, cancelled });
},
aiCapability: async (rpcMethod, params, chatSessionId) => {
return ipcRenderer.invoke("netcatty:ai:capability", { rpcMethod, params, chatSessionId });
},
aiDiscoverAgents: async (options) => {
return ipcRenderer.invoke("netcatty:ai:agents:discover", options);
},
aiPrewarmShellEnv: async () => {
return ipcRenderer.invoke("netcatty:ai:shell-env:prewarm");
},
aiResolveCli: async (params) => {
return ipcRenderer.invoke("netcatty:ai:resolve-cli", params);
},
aiCodexGetIntegration: async (options) => {
return ipcRenderer.invoke("netcatty:ai:codex:get-integration", options);
},
aiCodexStartLogin: async (options) => {
return ipcRenderer.invoke("netcatty:ai:codex:start-login", options);
},
aiCodexGetLoginSession: async (sessionId) => {
return ipcRenderer.invoke("netcatty:ai:codex:get-login-session", { sessionId });
},
aiCodexCancelLogin: async (sessionId) => {
return ipcRenderer.invoke("netcatty:ai:codex:cancel-login", { sessionId });
},
aiCodexLogout: async (options) => {
return ipcRenderer.invoke("netcatty:ai:codex:logout", options);
},
// External MCP (productized catalog MCP for Codex / Claude Code / Cursor / Grok)
externalMcpGetStatus: async () => {
return ipcRenderer.invoke("netcatty:external-mcp:get-status");
},
externalMcpSetEnabled: async (enabled) => {
return ipcRenderer.invoke("netcatty:external-mcp:set-enabled", { enabled });
},
externalMcpSetConfig: async (config) => {
return ipcRenderer.invoke("netcatty:external-mcp:set-config", config || {});
},
externalMcpGetUniversalSetupPrompt: async () => {
return ipcRenderer.invoke("netcatty:external-mcp:get-universal-setup-prompt");
},
externalMcpCodexGetStatus: async () => {
return ipcRenderer.invoke("netcatty:external-mcp:codex:get-status");
},
externalMcpCodexAdd: async () => {
return ipcRenderer.invoke("netcatty:external-mcp:codex:add");
},
externalMcpClaudeGetStatus: async () => {
return ipcRenderer.invoke("netcatty:external-mcp:claude:get-status");
},
externalMcpClaudeAdd: async () => {
return ipcRenderer.invoke("netcatty:external-mcp:claude:add");
},
externalMcpGrokGetStatus: async () => {
return ipcRenderer.invoke("netcatty:external-mcp:grok:get-status");
},
externalMcpGrokAdd: async () => {
return ipcRenderer.invoke("netcatty:external-mcp:grok:add");
},
// MCP Server session metadata
aiPrivacyStatus: async () => ipcRenderer.invoke("netcatty:ai:privacy:status"),
aiPrivacyTransform: async (request) => ipcRenderer.invoke("netcatty:ai:privacy:transform", request),
aiPrivacyClearSession: async (chatSessionId) => ipcRenderer.invoke("netcatty:ai:privacy:clear", chatSessionId),
aiMcpUpdateSessions: async (sessions, chatSessionId) => {
return ipcRenderer.invoke("netcatty:ai:mcp:update-sessions", { sessions, chatSessionId });
},
aiMcpUpdateLiveSessions: async (sessions) => {
return ipcRenderer.invoke("netcatty:ai:mcp:update-live-sessions", { sessions });
},
aiMcpMergeSessions: async (sessions, chatSessionId) => {
return ipcRenderer.invoke("netcatty:ai:mcp:merge-sessions", { sessions, chatSessionId });
},
aiMcpUpdateAttachments: async (attachments, chatSessionId) => {
return ipcRenderer.invoke("netcatty:ai:mcp:update-attachments", { attachments, chatSessionId });
},
aiMcpSetCommandBlocklist: async (blocklist) => {
return ipcRenderer.invoke("netcatty:ai:mcp:set-command-blocklist", { blocklist });
},
aiMcpSetCommandTimeout: async (timeout) => {
return ipcRenderer.invoke("netcatty:ai:mcp:set-command-timeout", { timeout });
},
aiMcpSetMaxIterations: async (maxIterations) => {
return ipcRenderer.invoke("netcatty:ai:mcp:set-max-iterations", { maxIterations });
},
aiMcpSetPermissionMode: async (mode) => {
return ipcRenderer.invoke("netcatty:ai:mcp:set-permission-mode", { mode });
},
aiMcpSetToolIntegrationMode: async (mode) => {
return ipcRenderer.invoke("netcatty:ai:mcp:set-tool-integration-mode", { mode });
},
aiMcpSyncPermissionGrants: async (grants) => {
return ipcRenderer.invoke("netcatty:ai:mcp:sync-permission-grants", { grants });
},
aiUserSkillsGetStatus: async () => {
return ipcRenderer.invoke("netcatty:ai:user-skills:status");
},
aiUserSkillsOpenFolder: async () => {
return ipcRenderer.invoke("netcatty:ai:user-skills:open");
},
aiUserSkillsBuildContext: async (prompt, selectedSkillSlugs) => {
return ipcRenderer.invoke("netcatty:ai:user-skills:build-context", { prompt, selectedSkillSlugs });
},
aiSkillsCliGetInvocation: async () => {
return ipcRenderer.invoke("netcatty:ai:skills-cli:invocation");
},
// MCP approval gate: renderer receives approval requests from main process
onMcpApprovalRequest: (cb) => {
const handler = (_event, payload) => cb(payload);
ipcRenderer.on("netcatty:ai:mcp:approval-request", handler);
return () => ipcRenderer.removeListener("netcatty:ai:mcp:approval-request", handler);
},
respondMcpApproval: async (approvalId, approved, scope) => {
return ipcRenderer.invoke("netcatty:ai:mcp:approval-response", { approvalId, approved, scope });
},
cancelMcpApprovalTimeout: async (approvalId) => {
return ipcRenderer.invoke("netcatty:ai:mcp:approval-cancel-timeout", { approvalId });
},
// MCP approval cleared: main process timed out or cancelled an approval
onMcpApprovalCleared: (cb) => {
const handler = (_event, payload) => cb(payload);
ipcRenderer.on("netcatty:ai:mcp:approval-cleared", handler);
return () => ipcRenderer.removeListener("netcatty:ai:mcp:approval-cleared", handler);
},
onVaultAgentRequest: (cb) => {
const handler = (_event, payload) => cb(payload);
ipcRenderer.on("netcatty:ai:vault-agent:request", handler);
return () => ipcRenderer.removeListener("netcatty:ai:vault-agent:request", handler);
},
respondVaultAgent: async (requestId, result) => {
return ipcRenderer.invoke("netcatty:ai:vault-agent:response", { requestId, result });
},
// SDK external agent streaming
aiSdkAgentStream: async (requestId, chatSessionId, sdkBackend, prompt, cwd, providerId, model, existingSessionId, historyMessages, images, toolIntegrationMode, defaultTargetSession, userSkillsContext, agentEnv, agentCommand, codexRuntime, permissionMode, codebuddyOptions) => {
const advanced = codebuddyOptions && typeof codebuddyOptions === "object"
? {
effort: codebuddyOptions.effort,
maxTurns: codebuddyOptions.maxTurns,
maxBudgetUsd: codebuddyOptions.maxBudgetUsd,
fallbackModel: codebuddyOptions.fallbackModel,
sandbox: codebuddyOptions.sandbox,
enableFileCheckpointing: codebuddyOptions.enableFileCheckpointing,
persistSession: codebuddyOptions.persistSession,
}
: {};
return ipcRenderer.invoke("netcatty:ai:sdk-agent:stream", {
requestId,
chatSessionId,
sdkBackend,
prompt,
cwd,
providerId,
model,
existingSessionId,
historyMessages,
images,
toolIntegrationMode,
defaultTargetSession,
userSkillsContext,
agentEnv,
agentCommand,
codexRuntime,
permissionMode,
...advanced,
});
},
aiSdkAgentSteer: async (requestId, chatSessionId, prompt, images, clientUserMessageId) => {
return ipcRenderer.invoke("netcatty:ai:sdk-agent:steer", {
requestId,
chatSessionId,
prompt,
images,
clientUserMessageId,
});
},
aiSdkAgentListModels: async (sdkBackend, cwd, providerId, chatSessionId, agentEnv, agentCommand, codexRuntime) => {
return ipcRenderer.invoke("netcatty:ai:sdk-agent:list-models", { sdkBackend, cwd, providerId, chatSessionId, agentEnv, agentCommand, codexRuntime });
},
codexAppServerGetStatus: async (agentCommand, agentEnv) => {
return ipcRenderer.invoke("netcatty:ai:codex-app-server:status", { agentCommand, agentEnv });
},
onCodexAppServerInteractionRequest: (cb) => {
const handler = (_event, payload) => cb(payload);
ipcRenderer.on("netcatty:ai:codex-app-server:interaction-request", handler);
return () => ipcRenderer.removeListener("netcatty:ai:codex-app-server:interaction-request", handler);
},
onCodexAppServerInteractionCleared: (cb) => {
const handler = (_event, payload) => cb(payload);
ipcRenderer.on("netcatty:ai:codex-app-server:interaction-cleared", handler);
return () => ipcRenderer.removeListener("netcatty:ai:codex-app-server:interaction-cleared", handler);
},
respondCodexAppServerInteraction: async (payload) => {
return ipcRenderer.invoke("netcatty:ai:codex-app-server:interaction-response", payload);
},
cancelCodexAppServerInteractionTimeout: async (interactionId) => {
return ipcRenderer.invoke("netcatty:ai:codex-app-server:interaction-cancel-timeout", { interactionId });
},
aiSdkAgentCancel: async (requestId, chatSessionId) => {
return ipcRenderer.invoke("netcatty:ai:sdk-agent:cancel", { requestId, chatSessionId });
},
aiSdkAgentCleanup: async (chatSessionId) => {
return ipcRenderer.invoke("netcatty:ai:sdk-agent:cleanup", { chatSessionId });
},
aiSdkAgentElicitationResponse: async (elicitationId, action, content) => {
return ipcRenderer.invoke("netcatty:ai:sdk-agent:elicitation-response", { elicitationId, action, content });
},
aiSdkAgentMcpStatus: async (agentEnv, agentCommand) => {
return ipcRenderer.invoke("netcatty:ai:sdk-agent:mcp-status", { agentEnv, agentCommand });
},
aiSdkAgentAccountInfo: async (agentEnv, agentCommand) => {
return ipcRenderer.invoke("netcatty:ai:sdk-agent:account-info", { agentEnv, agentCommand });
},
aiSdkAgentPluginInstall: async (options) => {
return ipcRenderer.invoke("netcatty:ai:sdk-agent:plugin-install", { options });
},
aiSdkAgentPluginEnable: async (name, marketplace) => {
return ipcRenderer.invoke("netcatty:ai:sdk-agent:plugin-enable", { name, marketplace });
},
aiSdkAgentPluginDisable: async (name, marketplace) => {
return ipcRenderer.invoke("netcatty:ai:sdk-agent:plugin-disable", { name, marketplace });
},
aiSdkAgentMarketplaceInstall: async (options) => {
return ipcRenderer.invoke("netcatty:ai:sdk-agent:marketplace-install", { options });
},
aiSdkAgentMarketplaceRemove: async (options) => {
return ipcRenderer.invoke("netcatty:ai:sdk-agent:marketplace-remove", { options });
},
onAiSdkAgentEvent: (requestId, cb) => {
const handler = (_event, payload) => {
if (payload.requestId === requestId) cb(payload.event);
};
ipcRenderer.on("netcatty:ai:sdk-agent:event", handler);
return () => ipcRenderer.removeListener("netcatty:ai:sdk-agent:event", handler);
},
onAiSdkAgentDone: (requestId, cb) => {
const handler = (_event, payload) => {
if (payload.requestId === requestId) cb();
};
ipcRenderer.on("netcatty:ai:sdk-agent:done", handler);
return () => ipcRenderer.removeListener("netcatty:ai:sdk-agent:done", handler);
},
onAiSdkAgentError: (requestId, cb) => {
const handler = (_event, payload) => {
if (payload.requestId === requestId) cb(payload.error);
};
ipcRenderer.on("netcatty:ai:sdk-agent:error", handler);
return () => ipcRenderer.removeListener("netcatty:ai:sdk-agent:error", handler);
},
onAiStreamData: (requestId, cb) => {
const handler = (_event, payload) => {
if (payload.requestId === requestId) cb(payload.data);
};
ipcRenderer.on("netcatty:ai:stream:data", handler);
return () => ipcRenderer.removeListener("netcatty:ai:stream:data", handler);
},
onAiStreamEnd: (requestId, cb) => {
const handler = (_event, payload) => {
if (payload.requestId === requestId) cb();
};
ipcRenderer.on("netcatty:ai:stream:end", handler);
return () => ipcRenderer.removeListener("netcatty:ai:stream:end", handler);
},
onAiStreamError: (requestId, cb) => {
const handler = (_event, payload) => {
if (payload.requestId === requestId) cb(payload.error);
};
ipcRenderer.on("netcatty:ai:stream:error", handler);
return () => ipcRenderer.removeListener("netcatty:ai:stream:error", handler);
},
onAiAgentStdout: (agentId, cb) => {
const handler = (_event, payload) => {
if (payload.agentId === agentId) cb(payload.data);
};
ipcRenderer.on("netcatty:ai:agent:stdout", handler);
return () => ipcRenderer.removeListener("netcatty:ai:agent:stdout", handler);
},
onAiAgentStderr: (agentId, cb) => {
const handler = (_event, payload) => {
if (payload.agentId === agentId) cb(payload.data);
};
ipcRenderer.on("netcatty:ai:agent:stderr", handler);
return () => ipcRenderer.removeListener("netcatty:ai:agent:stderr", handler);
},
onAiAgentExit: (agentId, cb) => {
const handler = (_event, payload) => {
if (payload.agentId === agentId) cb(payload.code);
};
ipcRenderer.on("netcatty:ai:agent:exit", handler);
return () => ipcRenderer.removeListener("netcatty:ai:agent:exit", handler);
},
scriptRun: async (params) => ipcRenderer.invoke("netcatty:script:run", params),
scriptStop: async (runId) => ipcRenderer.invoke("netcatty:script:stop", { runId }),
scriptPause: async (runId) => ipcRenderer.invoke("netcatty:script:pause", { runId }),
scriptResume: async (runId) => ipcRenderer.invoke("netcatty:script:resume", { runId }),
scriptGetRuns: async (sessionId) => ipcRenderer.invoke("netcatty:script:get-runs", sessionId ? { sessionId } : {}),
scriptDialogResponse: async (requestId, value, cancelled) =>
ipcRenderer.invoke("netcatty:script:dialog-response", { requestId, value, cancelled }),
scriptScreenSnapshotResponse: async (requestId, snapshot) =>
ipcRenderer.invoke("netcatty:script:screen-snapshot-response", { requestId, snapshot }),
scriptRecordingStart: async (sessionId) => ipcRenderer.invoke("netcatty:script:recording:start", { sessionId }),
scriptRecordingStop: async (sessionId) => ipcRenderer.invoke("netcatty:script:recording:stop", { sessionId }),
scriptRecordingAppendStep: async (sessionId, step) =>
ipcRenderer.invoke("netcatty:script:recording:append-step", { sessionId, step }),
onScriptRunsUpdated: (cb) => {
const handler = (_event, payload) => cb(payload);
ipcRenderer.on("netcatty:script:runs-updated", handler);
return () => ipcRenderer.removeListener("netcatty:script:runs-updated", handler);
},
onScriptDialogRequest: (cb) => {
const handler = (_event, payload) => cb(payload);
ipcRenderer.on("netcatty:script:dialog-request", handler);
return () => ipcRenderer.removeListener("netcatty:script:dialog-request", handler);
},
onScriptScreenSnapshotRequest: (cb) => {
const handler = (_event, payload) => cb(payload);
ipcRenderer.on("netcatty:script:screen-snapshot-request", handler);
return () => ipcRenderer.removeListener("netcatty:script:screen-snapshot-request", handler);
},
onScriptSessionInput: (cb) => {
const handler = (_event, payload) => cb(payload);
ipcRenderer.on("netcatty:script:session-input", handler);
return () => ipcRenderer.removeListener("netcatty:script:session-input", handler);
},
};
}
}
module.exports = { createPreloadApi };