Files
Netcatty/electron/preload.cjs
T
bincxz d4399cd3d0 Integrates OAuth-based cloud sync and UI refactor
Replaces legacy GitHub Gist sync UI with a modular cloud sync component and introduces OAuth callback support in the bridge layer. Updates the top bar to use a sync status button linked to settings, improving user experience and future extensibility for cloud sync providers.
2025-12-15 00:48:15 +08:00

470 lines
16 KiB
JavaScript

const { ipcRenderer, contextBridge } = require("electron");
const dataListeners = new Map();
const exitListeners = new Map();
const transferProgressListeners = new Map();
const transferCompleteListeners = new Map();
const transferErrorListeners = new Map();
const chainProgressListeners = new Map();
const authFailedListeners = new Map();
// WebAuthn requests from main process
const base64UrlToUint8 = (b64url) => {
if (typeof b64url !== "string") throw new Error("Invalid base64url value");
const b64 = b64url.replace(/-/g, "+").replace(/_/g, "/");
const padded = b64 + "=".repeat((4 - (b64.length % 4)) % 4);
const bin = atob(padded);
const out = new Uint8Array(bin.length);
for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
return out;
};
const uint8ToBase64Url = (bytes) => {
let binary = "";
const chunkSize = 0x8000;
for (let i = 0; i < bytes.length; i += chunkSize) {
binary += String.fromCharCode(...bytes.subarray(i, i + chunkSize));
}
return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
};
ipcRenderer.on("netcatty:webauthn:request", async (_event, payload) => {
const requestId = payload?.requestId;
try {
if (!requestId || typeof requestId !== "string") throw new Error("Missing requestId");
if (!window.PublicKeyCredential) throw new Error("WebAuthn is not supported in this environment");
if (!window.isSecureContext) throw new Error("WebAuthn requires a secure context (HTTPS/localhost)");
const credentialId = payload?.credentialId;
const challenge = payload?.challenge;
const rpId = payload?.rpId;
const userVerification = payload?.userVerification || "preferred";
const timeout = payload?.timeoutMs || 180000;
if (typeof credentialId !== "string" || !credentialId) throw new Error("Missing credentialId");
if (typeof challenge !== "string" || !challenge) throw new Error("Missing challenge");
if (typeof rpId !== "string" || !rpId) throw new Error("Missing rpId");
const idBytes = base64UrlToUint8(credentialId);
const challengeBytes = base64UrlToUint8(challenge);
const credential = await navigator.credentials.get({
publicKey: {
rpId,
challenge: challengeBytes,
allowCredentials: [
{
type: "public-key",
id: idBytes,
},
],
userVerification,
timeout,
},
});
if (!credential) throw new Error("Credential assertion was cancelled");
const assertion = credential;
const response = assertion.response;
const origin = window.location.origin || "";
const authenticatorData = uint8ToBase64Url(new Uint8Array(response.authenticatorData));
const clientDataJSON = uint8ToBase64Url(new Uint8Array(response.clientDataJSON));
const signature = uint8ToBase64Url(new Uint8Array(response.signature));
const userHandle = response.userHandle
? uint8ToBase64Url(new Uint8Array(response.userHandle))
: null;
ipcRenderer.send("netcatty:webauthn:response", {
requestId,
ok: true,
result: {
origin,
authenticatorData,
clientDataJSON,
signature,
userHandle,
},
});
} catch (err) {
ipcRenderer.send("netcatty:webauthn:response", {
requestId,
ok: false,
error: err?.message || String(err),
});
}
});
ipcRenderer.on("netcatty:data", (_event, payload) => {
const set = dataListeners.get(payload.sessionId);
if (!set) return;
set.forEach((cb) => {
try {
cb(payload.data);
} catch (err) {
console.error("Data callback failed", err);
}
});
});
ipcRenderer.on("netcatty:exit", (_event, payload) => {
const set = exitListeners.get(payload.sessionId);
if (set) {
set.forEach((cb) => {
try {
cb(payload);
} catch (err) {
console.error("Exit callback failed", err);
}
});
}
dataListeners.delete(payload.sessionId);
exitListeners.delete(payload.sessionId);
});
// Chain progress events (for jump host connections)
ipcRenderer.on("netcatty:chain:progress", (_event, payload) => {
const { hop, total, label, status } = payload;
// Notify all registered chain progress listeners
chainProgressListeners.forEach((cb) => {
try {
cb(hop, total, label, status);
} catch (err) {
console.error("Chain progress callback failed", err);
}
});
});
// Authentication failed events
ipcRenderer.on("netcatty:auth:failed", (_event, payload) => {
const set = authFailedListeners.get(payload.sessionId);
if (set) {
set.forEach((cb) => {
try {
cb(payload);
} catch (err) {
console.error("Auth failed callback failed", err);
}
});
}
});
// Transfer progress events
ipcRenderer.on("netcatty:transfer:progress", (_event, payload) => {
const cb = transferProgressListeners.get(payload.transferId);
if (cb) {
try {
cb(payload.transferred, payload.totalBytes, payload.speed);
} catch (err) {
console.error("Transfer progress callback failed", err);
}
}
});
ipcRenderer.on("netcatty:transfer:complete", (_event, payload) => {
const cb = transferCompleteListeners.get(payload.transferId);
if (cb) {
try {
cb();
} catch (err) {
console.error("Transfer complete callback failed", err);
}
}
// Cleanup listeners
transferProgressListeners.delete(payload.transferId);
transferCompleteListeners.delete(payload.transferId);
transferErrorListeners.delete(payload.transferId);
});
ipcRenderer.on("netcatty:transfer:error", (_event, payload) => {
const cb = transferErrorListeners.get(payload.transferId);
if (cb) {
try {
cb(payload.error);
} catch (err) {
console.error("Transfer error callback failed", err);
}
}
// Cleanup listeners
transferProgressListeners.delete(payload.transferId);
transferCompleteListeners.delete(payload.transferId);
transferErrorListeners.delete(payload.transferId);
});
ipcRenderer.on("netcatty:transfer:cancelled", (_event, payload) => {
// Just cleanup listeners, the UI already knows it's cancelled
transferProgressListeners.delete(payload.transferId);
transferCompleteListeners.delete(payload.transferId);
transferErrorListeners.delete(payload.transferId);
});
// Upload with progress listeners
const uploadProgressListeners = new Map();
const uploadCompleteListeners = new Map();
const uploadErrorListeners = new Map();
ipcRenderer.on("netcatty:upload:progress", (_event, payload) => {
const cb = uploadProgressListeners.get(payload.transferId);
if (cb) {
try {
cb(payload.transferred, payload.totalBytes, payload.speed);
} catch (err) {
console.error("Upload progress callback failed", err);
}
}
});
ipcRenderer.on("netcatty:upload:complete", (_event, payload) => {
const cb = uploadCompleteListeners.get(payload.transferId);
if (cb) {
try {
cb();
} catch (err) {
console.error("Upload complete callback failed", err);
}
}
// Cleanup listeners
uploadProgressListeners.delete(payload.transferId);
uploadCompleteListeners.delete(payload.transferId);
uploadErrorListeners.delete(payload.transferId);
});
ipcRenderer.on("netcatty:upload:error", (_event, payload) => {
const cb = uploadErrorListeners.get(payload.transferId);
if (cb) {
try {
cb(payload.error);
} catch (err) {
console.error("Upload error callback failed", err);
}
}
// Cleanup listeners
uploadProgressListeners.delete(payload.transferId);
uploadCompleteListeners.delete(payload.transferId);
uploadErrorListeners.delete(payload.transferId);
});
// Port forwarding status listeners
const portForwardStatusListeners = new Map();
ipcRenderer.on("netcatty:portforward:status", (_event, payload) => {
const { tunnelId, status, error } = payload;
const callbacks = portForwardStatusListeners.get(tunnelId);
if (callbacks) {
callbacks.forEach((cb) => {
try {
cb(status, error);
} catch (err) {
console.error("Port forward status callback failed", err);
}
});
}
});
const api = {
startSSHSession: async (options) => {
const result = await ipcRenderer.invoke("netcatty:start", options);
return result.sessionId;
},
startTelnetSession: async (options) => {
const result = await ipcRenderer.invoke("netcatty:telnet:start", options);
return result.sessionId;
},
startMoshSession: async (options) => {
const result = await ipcRenderer.invoke("netcatty:mosh:start", options);
return result.sessionId;
},
startLocalSession: async (options) => {
const result = await ipcRenderer.invoke("netcatty:local:start", options || {});
return result.sessionId;
},
writeToSession: (sessionId, data) => {
ipcRenderer.send("netcatty:write", { sessionId, data });
},
execCommand: async (options) => {
return ipcRenderer.invoke("netcatty:ssh:exec", options);
},
generateKeyPair: async (options) => {
return ipcRenderer.invoke("netcatty:key:generate", options);
},
resizeSession: (sessionId, cols, rows) => {
ipcRenderer.send("netcatty:resize", { sessionId, cols, rows });
},
closeSession: (sessionId) => {
ipcRenderer.send("netcatty:close", { sessionId });
},
onSessionData: (sessionId, cb) => {
if (!dataListeners.has(sessionId)) dataListeners.set(sessionId, new Set());
dataListeners.get(sessionId).add(cb);
return () => dataListeners.get(sessionId)?.delete(cb);
},
onSessionExit: (sessionId, cb) => {
if (!exitListeners.has(sessionId)) exitListeners.set(sessionId, new Set());
exitListeners.get(sessionId).add(cb);
return () => exitListeners.get(sessionId)?.delete(cb);
},
onAuthFailed: (sessionId, cb) => {
if (!authFailedListeners.has(sessionId)) authFailedListeners.set(sessionId, new Set());
authFailedListeners.get(sessionId).add(cb);
return () => authFailedListeners.get(sessionId)?.delete(cb);
},
openSftp: async (options) => {
const result = await ipcRenderer.invoke("netcatty:sftp:open", options);
return result.sftpId;
},
listSftp: async (sftpId, path) => {
return ipcRenderer.invoke("netcatty:sftp:list", { sftpId, path });
},
readSftp: async (sftpId, path) => {
return ipcRenderer.invoke("netcatty:sftp:read", { sftpId, path });
},
writeSftp: async (sftpId, path, content) => {
return ipcRenderer.invoke("netcatty:sftp:write", { sftpId, path, content });
},
closeSftp: async (sftpId) => {
return ipcRenderer.invoke("netcatty:sftp:close", { sftpId });
},
mkdirSftp: async (sftpId, path) => {
return ipcRenderer.invoke("netcatty:sftp:mkdir", { sftpId, path });
},
deleteSftp: async (sftpId, path) => {
return ipcRenderer.invoke("netcatty:sftp:delete", { sftpId, path });
},
renameSftp: async (sftpId, oldPath, newPath) => {
return ipcRenderer.invoke("netcatty:sftp:rename", { sftpId, oldPath, newPath });
},
statSftp: async (sftpId, path) => {
return ipcRenderer.invoke("netcatty:sftp:stat", { sftpId, path });
},
chmodSftp: async (sftpId, path, mode) => {
return ipcRenderer.invoke("netcatty:sftp:chmod", { sftpId, path, mode });
},
// Write binary with real-time progress callback
writeSftpBinaryWithProgress: async (sftpId, path, content, transferId, onProgress, onComplete, onError) => {
// Register callbacks
if (onProgress) uploadProgressListeners.set(transferId, onProgress);
if (onComplete) uploadCompleteListeners.set(transferId, onComplete);
if (onError) uploadErrorListeners.set(transferId, onError);
return ipcRenderer.invoke("netcatty:sftp:writeBinaryWithProgress", {
sftpId,
path,
content,
transferId
});
},
// Local filesystem operations
listLocalDir: async (path) => {
return ipcRenderer.invoke("netcatty:local:list", { path });
},
readLocalFile: async (path) => {
return ipcRenderer.invoke("netcatty:local:read", { path });
},
writeLocalFile: async (path, content) => {
return ipcRenderer.invoke("netcatty:local:write", { path, content });
},
deleteLocalFile: async (path) => {
return ipcRenderer.invoke("netcatty:local:delete", { path });
},
renameLocalFile: async (oldPath, newPath) => {
return ipcRenderer.invoke("netcatty:local:rename", { oldPath, newPath });
},
mkdirLocal: async (path) => {
return ipcRenderer.invoke("netcatty:local:mkdir", { path });
},
statLocal: async (path) => {
return ipcRenderer.invoke("netcatty:local:stat", { path });
},
getHomeDir: async () => {
return ipcRenderer.invoke("netcatty:local:homedir");
},
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);
},
// Streaming transfer with real progress
startStreamTransfer: async (options, onProgress, onComplete, onError) => {
const { transferId } = options;
// Register callbacks
if (onProgress) transferProgressListeners.set(transferId, onProgress);
if (onComplete) transferCompleteListeners.set(transferId, onComplete);
if (onError) transferErrorListeners.set(transferId, onError);
return ipcRenderer.invoke("netcatty:transfer:start", options);
},
cancelTransfer: async (transferId) => {
// Cleanup listeners
transferProgressListeners.delete(transferId);
transferCompleteListeners.delete(transferId);
transferErrorListeners.delete(transferId);
return ipcRenderer.invoke("netcatty:transfer:cancel", { transferId });
},
// 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"),
// Settings window
openSettingsWindow: () => ipcRenderer.invoke("netcatty:settings:open"),
closeSettingsWindow: () => ipcRenderer.invoke("netcatty:settings:close"),
// Open URL in default browser
openExternal: (url) => ipcRenderer.invoke("netcatty:openExternal", url),
// WebAuthn browser fallback (primarily for macOS Touch ID prompt issues)
webauthnCreateCredentialInBrowser: (options) =>
ipcRenderer.invoke("netcatty:webauthn:browser:create", options),
webauthnGetAssertionInBrowser: (options) =>
ipcRenderer.invoke("netcatty:webauthn:browser:get", options),
// 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 });
},
listPortForwards: async () => {
return ipcRenderer.invoke("netcatty:portforward:list");
},
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);
}
};
},
// Chain progress listener for jump host connections
onChainProgress: (cb) => {
const id = Date.now().toString() + Math.random().toString(16).slice(2);
chainProgressListeners.set(id, cb);
return () => {
chainProgressListeners.delete(id);
};
},
// OAuth callback server
startOAuthCallback: (expectedState) => ipcRenderer.invoke("oauth:startCallback", expectedState),
cancelOAuthCallback: () => ipcRenderer.invoke("oauth:cancelCallback"),
};
// Merge with existing netcatty (if any) to avoid stale objects on hot reload
const existing = (typeof window !== "undefined" && window.netcatty) ? window.netcatty : {};
contextBridge.exposeInMainWorld("netcatty", { ...existing, ...api });