mirror of
https://github.com/binaricat/Netcatty.git
synced 2026-11-17 13:01:24 +00:00
1614 lines
57 KiB
JavaScript
1614 lines
57 KiB
JavaScript
/**
|
|
* Terminal Bridge - Handles local shell, telnet/mosh, and serial port sessions
|
|
* Extracted from main.cjs for single responsibility
|
|
*/
|
|
|
|
const os = require("node:os");
|
|
const fs = require("node:fs");
|
|
const net = require("node:net");
|
|
const { randomUUID } = require("node:crypto");
|
|
const { execFile, execFileSync } = require("node:child_process");
|
|
const path = require("node:path");
|
|
const { promisify } = require("node:util");
|
|
const { StringDecoder } = require("node:string_decoder");
|
|
const { ensureNodePtySpawnHelperExecutable } = require("./nodePtySpawnHelperPermissions.cjs");
|
|
|
|
ensureNodePtySpawnHelperExecutable();
|
|
|
|
const pty = require("node-pty");
|
|
const { SerialPort } = require("serialport");
|
|
const {
|
|
configureTerminalSessionDataEmitter,
|
|
emitTerminalSessionData,
|
|
} = require("./emitTerminalSessionData.cjs");
|
|
const {
|
|
getRecentInterruptTrace,
|
|
getSessionSnapshot,
|
|
logTerminalFlowAckSample,
|
|
logTerminalFlowPauseSample,
|
|
logTerminalInterruptDebug,
|
|
normalizeTrace,
|
|
rememberInterruptTrace,
|
|
resetTerminalFlowAckSample,
|
|
} = require("./terminalInterruptDiagnostics.cjs");
|
|
const {
|
|
clearSessionFlowState,
|
|
setBufferedOutputBytes,
|
|
setRendererFlowPaused,
|
|
shouldAcceptSessionOutput,
|
|
shouldProcessSessionOutput,
|
|
trackAck,
|
|
} = require("./terminalFlowAck.cjs");
|
|
const {
|
|
armTerminalInterruptOutputGate,
|
|
disarmTerminalInterruptOutputGate,
|
|
filterTerminalInterruptOutput,
|
|
shouldArmTerminalInterruptOutputGate,
|
|
stashPendingInterruptOutputMeta,
|
|
takePendingInterruptOutputMeta,
|
|
} = require("./terminalInterruptOutputGate.cjs");
|
|
const iconv = require("iconv-lite");
|
|
const ptyProcessTree = require("./ptyProcessTree.cjs");
|
|
|
|
const sessionLogStreamManager = require("./sessionLogStreamManager.cjs");
|
|
const { detectShellKind } = require("./ai/ptyExec.cjs");
|
|
const { stripAnsi, trackSessionIdlePrompt } = require("./ai/shellUtils.cjs");
|
|
const { createZmodemSentry } = require("./zmodemHelper.cjs");
|
|
const { discoverShells } = require("./shellDiscovery.cjs");
|
|
const moshHandshake = require("./moshHandshake.cjs");
|
|
const tempDirBridge = require("./tempDirBridge.cjs");
|
|
const { createTelnetAutoLogin } = require("./telnetAutoLogin.cjs");
|
|
const telnetProtocol = require("./telnetProtocol.cjs");
|
|
const { createPtyOutputBuffer } = require("./ptyOutputBuffer.cjs");
|
|
const { enableTcpNoDelay } = require("./tcpNoDelay.cjs");
|
|
const { releaseConnectionRef } = require("./sshConnectionPool.cjs");
|
|
const { normalizeTerminalEncoding, encodeTerminalInput } = require("./terminalEncoding.cjs");
|
|
const { receiveYmodemFiles, sendYmodemCancel, sendYmodemFile } = require("./ymodemTransfer.cjs");
|
|
const {
|
|
getNativeOpenSshAgentSocket,
|
|
prepareSystemSshAgentForAuth,
|
|
} = require("./sshAuthHelper.cjs");
|
|
|
|
const execFileAsync = promisify(execFile);
|
|
|
|
// Shared references
|
|
let sessions = null;
|
|
let electronModule = null;
|
|
let terminalOutputChannel = null;
|
|
let selectZmodemUploadFiles = null;
|
|
let selectZmodemDownloadDirectory = null;
|
|
|
|
const DEFAULT_UTF8_LOCALE = "en_US.UTF-8";
|
|
const LOGIN_SHELLS = new Set(["bash", "zsh", "fish", "ksh"]);
|
|
const POWERSHELL_SHELLS = new Set(["powershell", "powershell.exe", "pwsh", "pwsh.exe"]);
|
|
|
|
function expandHomePath(targetPath) {
|
|
if (!targetPath) return targetPath;
|
|
if (targetPath === "~") return os.homedir();
|
|
if (targetPath.startsWith("~/")) return path.join(os.homedir(), targetPath.slice(2));
|
|
return targetPath;
|
|
}
|
|
|
|
function normalizeExecutablePath(targetPath) {
|
|
const expanded = expandHomePath(targetPath);
|
|
if (!expanded) return expanded;
|
|
if (expanded.includes(path.sep) || expanded.startsWith(".")) {
|
|
return path.resolve(expanded);
|
|
}
|
|
return expanded;
|
|
}
|
|
|
|
const getLoginShellArgs = (shellPath) => {
|
|
if (!shellPath || process.platform === "win32") return [];
|
|
const shellName = path.basename(shellPath);
|
|
return LOGIN_SHELLS.has(shellName) ? ["-l"] : [];
|
|
};
|
|
|
|
/**
|
|
* Initialize the terminal bridge with dependencies
|
|
*/
|
|
function init(deps) {
|
|
sessions = deps.sessions;
|
|
electronModule = deps.electronModule;
|
|
terminalOutputChannel = deps.terminalOutputChannel || null;
|
|
selectZmodemUploadFiles = deps.selectZmodemUploadFiles || null;
|
|
selectZmodemDownloadDirectory = deps.selectZmodemDownloadDirectory || null;
|
|
configureTerminalSessionDataEmitter({
|
|
getSession: (sessionId) => sessions?.get(sessionId),
|
|
outputChannel: terminalOutputChannel,
|
|
});
|
|
cleanupStaleEtTempDirs();
|
|
}
|
|
|
|
function openTerminalOutputSession(sessionId, webContents) {
|
|
terminalOutputChannel?.openSession?.(sessionId, webContents);
|
|
}
|
|
|
|
function closeTerminalOutputSession(sessionId) {
|
|
terminalOutputChannel?.closeSession?.(sessionId);
|
|
}
|
|
|
|
/**
|
|
* Locate an executable on POSIX systems by name.
|
|
*
|
|
* macOS GUI Electron apps inherit launchd's minimal PATH
|
|
* (`/usr/bin:/bin:/usr/sbin:/sbin`), missing Homebrew and other common
|
|
* package-manager directories. `pty.spawn(name)` then either fails
|
|
* synchronously with ENOENT or spawns a child that immediately exits
|
|
* with no useful error surfaced to the renderer (see issue #842 for the
|
|
* Mosh case).
|
|
*
|
|
* Returns the absolute path on success, or null when the binary cannot
|
|
* be located anywhere we know to look. Win32 callers should keep using
|
|
* findExecutable() which handles `where.exe` + Windows-specific paths.
|
|
*/
|
|
const POSIX_EXTRA_PATH_DIRS = [
|
|
"/opt/homebrew/bin",
|
|
"/opt/homebrew/sbin",
|
|
"/usr/local/bin",
|
|
"/usr/local/sbin",
|
|
"/opt/local/bin",
|
|
"/opt/local/sbin",
|
|
"/usr/bin",
|
|
"/bin",
|
|
"/usr/sbin",
|
|
"/sbin",
|
|
];
|
|
|
|
function isExecutableFile(candidate) {
|
|
try {
|
|
const st = fs.statSync(candidate);
|
|
if (!st.isFile()) return false;
|
|
// Windows has no POSIX execute bit — Node returns mode 0o100666 even for
|
|
// .exe / .bat / .cmd files, so 0o111 is unreliable there. Treat any
|
|
// regular file as executable on Win32 and let spawn-time PATHEXT /
|
|
// extension handling reject non-executables.
|
|
if (process.platform === "win32") return true;
|
|
return (st.mode & 0o111) !== 0;
|
|
} catch {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function resolvePosixExecutable(name, opts = {}) {
|
|
if (process.platform === "win32") return null;
|
|
if (!name || typeof name !== "string") return null;
|
|
|
|
// Already an absolute or relative path: validate as-is.
|
|
if (name.includes("/")) {
|
|
return isExecutableFile(name) ? name : null;
|
|
}
|
|
if (!/^[a-zA-Z0-9._+-]+$/.test(name)) return null;
|
|
|
|
const seen = new Set();
|
|
const dirs = [];
|
|
|
|
// 1. Honor the caller-supplied PATH first so callers that have already
|
|
// merged a host-level environmentVariables.PATH override don't see the
|
|
// fallback decline a binary that the spawned process would have found.
|
|
// Falls back to the main process PATH when no override is provided.
|
|
const pathOverride = Object.prototype.hasOwnProperty.call(opts, "pathOverride")
|
|
? opts.pathOverride
|
|
: process.env.PATH;
|
|
for (const dir of (pathOverride || "").split(":")) {
|
|
if (dir && !seen.has(dir)) {
|
|
seen.add(dir);
|
|
dirs.push(dir);
|
|
}
|
|
}
|
|
|
|
// 2. Add directories the GUI launcher's PATH typically misses on macOS/Linux.
|
|
for (const dir of POSIX_EXTRA_PATH_DIRS) {
|
|
if (!seen.has(dir)) {
|
|
seen.add(dir);
|
|
dirs.push(dir);
|
|
}
|
|
}
|
|
|
|
// 3. User-scoped install locations (nix-profile, cargo, ~/.local).
|
|
const home = process.env.HOME;
|
|
if (home) {
|
|
for (const sub of [".nix-profile/bin", ".cargo/bin", ".local/bin"]) {
|
|
const dir = path.join(home, sub);
|
|
if (!seen.has(dir)) {
|
|
seen.add(dir);
|
|
dirs.push(dir);
|
|
}
|
|
}
|
|
}
|
|
|
|
for (const dir of dirs) {
|
|
const candidate = path.join(dir, name);
|
|
if (isExecutableFile(candidate)) return candidate;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Find executable path on Windows
|
|
*/
|
|
function isWindowsAppExecutionAlias(filePath) {
|
|
if (!filePath || process.platform !== "win32") return false;
|
|
|
|
const normalizedPath = path.normalize(filePath).toLowerCase();
|
|
const windowsAppsDir = path.join(
|
|
process.env.LOCALAPPDATA || "",
|
|
"Microsoft",
|
|
"WindowsApps",
|
|
).toLowerCase();
|
|
|
|
return !!windowsAppsDir && normalizedPath.startsWith(`${windowsAppsDir}${path.sep}`);
|
|
}
|
|
|
|
function findExecutable(name, opts = {}) {
|
|
if (process.platform !== "win32") return name;
|
|
|
|
const { execFileSync } = require("child_process");
|
|
try {
|
|
const pathOverride = Object.prototype.hasOwnProperty.call(opts, "pathOverride")
|
|
? opts.pathOverride
|
|
: process.env.PATH;
|
|
const env = { ...process.env, PATH: pathOverride || "" };
|
|
const whereExe = path.join(process.env.SystemRoot || "C:\\Windows", "System32", "where.exe");
|
|
const result = execFileSync(fs.existsSync(whereExe) ? whereExe : "where.exe", [name], { encoding: "utf8", env });
|
|
const candidates = result
|
|
.split(/\r?\n/)
|
|
.map((line) => line.trim())
|
|
.filter(Boolean);
|
|
|
|
for (const candidate of candidates) {
|
|
if (!fs.existsSync(candidate)) continue;
|
|
if (name === "pwsh" && isWindowsAppExecutionAlias(candidate)) continue;
|
|
return candidate;
|
|
}
|
|
} catch (err) {
|
|
console.warn(`Could not find ${name} via where.exe:`, err.message);
|
|
}
|
|
|
|
if (!/^[a-zA-Z0-9._-]+$/.test(name)) return name;
|
|
|
|
const commonPaths = [];
|
|
|
|
if (name === "pwsh") {
|
|
commonPaths.push(
|
|
path.join(process.env.ProgramFiles || "C:\\Program Files", "PowerShell", "7", "pwsh.exe"),
|
|
path.join(process.env.ProgramW6432 || "C:\\Program Files", "PowerShell", "7", "pwsh.exe"),
|
|
);
|
|
}
|
|
|
|
if (name === "powershell") {
|
|
commonPaths.push(
|
|
path.join(
|
|
process.env.SystemRoot || "C:\\Windows",
|
|
"System32",
|
|
"WindowsPowerShell",
|
|
"v1.0",
|
|
"powershell.exe",
|
|
),
|
|
);
|
|
}
|
|
|
|
commonPaths.push(
|
|
path.join(process.env.SystemRoot || "C:\\Windows", "System32", "OpenSSH", `${name}.exe`),
|
|
path.join(process.env.ProgramFiles || "C:\\Program Files", "Git", "usr", "bin", `${name}.exe`),
|
|
path.join(process.env.ProgramFiles || "C:\\Program Files", "OpenSSH", `${name}.exe`),
|
|
);
|
|
|
|
for (const p of commonPaths) {
|
|
if (fs.existsSync(p)) return p;
|
|
}
|
|
|
|
return name;
|
|
}
|
|
|
|
function getDefaultLocalShell() {
|
|
if (process.platform !== "win32") {
|
|
return process.env.SHELL || "/bin/bash";
|
|
}
|
|
|
|
const pwsh = findExecutable("pwsh");
|
|
if (pwsh && pwsh.toLowerCase() !== "pwsh") {
|
|
return pwsh;
|
|
}
|
|
|
|
const powershell = findExecutable("powershell");
|
|
if (powershell && powershell.toLowerCase() !== "powershell") {
|
|
return powershell;
|
|
}
|
|
|
|
return "powershell.exe";
|
|
}
|
|
|
|
function getLocalShellArgs(shellPath) {
|
|
if (!shellPath) return [];
|
|
|
|
if (process.platform !== "win32") {
|
|
return getLoginShellArgs(shellPath);
|
|
}
|
|
|
|
const shellName = path.basename(shellPath).toLowerCase();
|
|
if (POWERSHELL_SHELLS.has(shellName)) {
|
|
return ["-NoLogo"];
|
|
}
|
|
|
|
return [];
|
|
}
|
|
|
|
const isUtf8Locale = (value) => typeof value === "string" && /utf-?8/i.test(value);
|
|
|
|
const isEmptyLocale = (value) => {
|
|
if (value === undefined || value === null) return true;
|
|
const trimmed = String(value).trim();
|
|
if (!trimmed) return true;
|
|
return trimmed === "C" || trimmed === "POSIX";
|
|
};
|
|
|
|
const applyLocaleDefaults = (env) => {
|
|
const hasUtf8 =
|
|
isUtf8Locale(env.LC_ALL) || isUtf8Locale(env.LC_CTYPE) || isUtf8Locale(env.LANG);
|
|
if (hasUtf8) return env;
|
|
|
|
const hasAnyLocale =
|
|
!isEmptyLocale(env.LC_ALL) || !isEmptyLocale(env.LC_CTYPE) || !isEmptyLocale(env.LANG);
|
|
if (hasAnyLocale) return env;
|
|
|
|
return {
|
|
...env,
|
|
LANG: DEFAULT_UTF8_LOCALE,
|
|
LC_CTYPE: DEFAULT_UTF8_LOCALE,
|
|
LC_ALL: DEFAULT_UTF8_LOCALE,
|
|
};
|
|
};
|
|
|
|
/**
|
|
* Start a local terminal session
|
|
*/
|
|
function startLocalSession(event, payload) {
|
|
const sessionId = payload?.sessionId || randomUUID();
|
|
const defaultShell = getDefaultLocalShell();
|
|
// payload.shell may be a discovered shell ID (e.g., "wsl-ubuntu") — resolve it
|
|
let resolvedShell = payload?.shell;
|
|
let resolvedArgs = payload?.shellArgs;
|
|
if (resolvedShell && !/[/\\]/.test(resolvedShell)) {
|
|
// Looks like a shell ID, not a path — try to resolve from discovery cache
|
|
const shells = discoverShells();
|
|
const match = shells.find((s) => s.id === resolvedShell);
|
|
if (match) {
|
|
resolvedShell = match.command;
|
|
resolvedArgs = resolvedArgs ?? match.args;
|
|
}
|
|
}
|
|
const shell = normalizeExecutablePath(resolvedShell) || defaultShell;
|
|
const shellArgs = resolvedArgs ?? getLocalShellArgs(shell);
|
|
const shellKind = detectShellKind(shell);
|
|
const { buildTerminalProcessEnv } = require("./httpNetworkProxyBridge.cjs");
|
|
const env = applyLocaleDefaults({
|
|
...buildTerminalProcessEnv(process.env),
|
|
...(payload?.env || {}),
|
|
TERM: "xterm-256color",
|
|
COLORTERM: "truecolor",
|
|
});
|
|
|
|
// Determine the starting directory
|
|
// Default to home directory if not specified or if specified path is invalid
|
|
const defaultCwd = os.homedir();
|
|
let cwd = defaultCwd;
|
|
|
|
if (payload?.cwd) {
|
|
try {
|
|
// Resolve to absolute path and check if it exists and is a directory
|
|
const resolvedPath = path.resolve(expandHomePath(payload.cwd));
|
|
if (fs.existsSync(resolvedPath) && fs.statSync(resolvedPath).isDirectory()) {
|
|
cwd = resolvedPath;
|
|
} else {
|
|
console.warn(`[Terminal] Specified cwd "${payload.cwd}" is not a valid directory, using home directory`);
|
|
}
|
|
} catch (err) {
|
|
console.warn(`[Terminal] Error validating cwd "${payload.cwd}":`, err.message);
|
|
}
|
|
}
|
|
|
|
const proc = pty.spawn(shell, shellArgs, {
|
|
name: env.TERM || "xterm-256color",
|
|
cols: payload?.cols || 80,
|
|
rows: payload?.rows || 24,
|
|
env,
|
|
cwd,
|
|
encoding: null, // Return Buffer for ZMODEM binary support
|
|
});
|
|
|
|
const session = {
|
|
proc,
|
|
pty: proc,
|
|
type: "local",
|
|
protocol: "local",
|
|
webContentsId: event.sender.id,
|
|
hostname: "localhost",
|
|
username: (() => {
|
|
try {
|
|
return os.userInfo().username || "local";
|
|
} catch {
|
|
return "local";
|
|
}
|
|
})(),
|
|
label: "Local Terminal",
|
|
shellExecutable: shell,
|
|
shellKind,
|
|
flushPendingData: null,
|
|
lastIdlePrompt: "",
|
|
lastIdlePromptAt: 0,
|
|
_promptTrackTail: "",
|
|
};
|
|
sessions.set(sessionId, session);
|
|
openTerminalOutputSession(sessionId, event.sender);
|
|
ptyProcessTree.registerPid(sessionId, proc.pid);
|
|
|
|
// Start real-time session log stream if configured. The token returned
|
|
// by startStream is captured so the corresponding stopStream below only
|
|
// tears down THIS stream — a stale exit event from a previous session
|
|
// that reused this sessionId would no-op instead of killing a freshly
|
|
// started stream after a "Restart" reconnect (issue #916).
|
|
let logStreamToken = null;
|
|
if (payload?.sessionLog?.enabled && payload?.sessionLog?.directory) {
|
|
logStreamToken = sessionLogStreamManager.startStream(sessionId, {
|
|
hostLabel: "Local",
|
|
hostname: "localhost",
|
|
directory: payload.sessionLog.directory,
|
|
format: payload.sessionLog.format || "txt",
|
|
timestampsEnabled: Boolean(payload.sessionLog.timestampsEnabled),
|
|
startTime: Date.now(),
|
|
});
|
|
}
|
|
|
|
const {
|
|
bufferData: bufferLocalData,
|
|
flushPaced: flushLocalPaced,
|
|
takePendingEntry: takePendingLocal,
|
|
discard: discardLocal,
|
|
} = createPtyOutputBuffer((data, meta) => {
|
|
const contents = electronModule.webContents.fromId(session.webContentsId);
|
|
emitTerminalSessionData(contents, sessionId, data, {
|
|
cols: session.cols,
|
|
rows: session.rows,
|
|
meta,
|
|
});
|
|
}, {
|
|
onPendingBytesChange: (bytes) => setBufferedOutputBytes(session, bytes),
|
|
shouldAcceptOutput: () => shouldAcceptSessionOutput(session),
|
|
});
|
|
session.flushPendingData = flushLocalPaced;
|
|
session.takePendingData = takePendingLocal;
|
|
session.discardPendingData = discardLocal;
|
|
|
|
// On Windows, node-pty ignores encoding: null and still emits UTF-8
|
|
// strings, making raw-byte ZMODEM impossible for local PTY sessions.
|
|
// Only wire up the sentry on platforms where encoding: null works.
|
|
if (process.platform !== "win32") {
|
|
const localDecoder = new StringDecoder("utf8");
|
|
const zmodemSentry = createZmodemSentry({
|
|
sessionId,
|
|
onData(buf) {
|
|
const str = localDecoder.write(buf);
|
|
if (!str) return;
|
|
trackSessionIdlePrompt(session, str);
|
|
bufferLocalData(str);
|
|
sessionLogStreamManager.appendData(sessionId, str);
|
|
},
|
|
writeToRemote(buf) {
|
|
try { return proc.write(buf); } catch { return true; }
|
|
},
|
|
getWebContents() {
|
|
return electronModule.webContents.fromId(session.webContentsId);
|
|
},
|
|
selectUploadFiles: selectZmodemUploadFiles
|
|
? () => selectZmodemUploadFiles(session.webContentsId)
|
|
: undefined,
|
|
selectDownloadDirectory: selectZmodemDownloadDirectory
|
|
? () => selectZmodemDownloadDirectory(session.webContentsId)
|
|
: undefined,
|
|
label: "Local",
|
|
});
|
|
session.zmodemSentry = zmodemSentry;
|
|
|
|
proc.onData((data) => {
|
|
if (!shouldProcessSessionOutput(session, zmodemSentry)) return;
|
|
zmodemSentry.consume(data);
|
|
});
|
|
} else {
|
|
proc.onData((data) => {
|
|
if (!shouldProcessSessionOutput(session)) return;
|
|
trackSessionIdlePrompt(session, data);
|
|
bufferLocalData(data);
|
|
sessionLogStreamManager.appendData(sessionId, data);
|
|
});
|
|
}
|
|
|
|
let localExitFinalized = false;
|
|
proc.onExit((evt) => {
|
|
const finalizeExit = () => {
|
|
if (localExitFinalized) return;
|
|
localExitFinalized = true;
|
|
sessionLogStreamManager.stopStream(sessionId, logStreamToken);
|
|
ptyProcessTree.unregisterPid(sessionId);
|
|
sessions.delete(sessionId);
|
|
const contents = electronModule.webContents.fromId(session.webContentsId);
|
|
// Signal present = killed externally (show disconnected UI).
|
|
// No signal = process exited normally, even with non-zero code
|
|
// (e.g. user typed `exit` after a failed command), so auto-close.
|
|
const reason = evt.signal ? "error" : "exited";
|
|
contents?.send("netcatty:exit", { sessionId, ...evt, reason });
|
|
};
|
|
flushLocalPaced(finalizeExit);
|
|
});
|
|
|
|
return { sessionId };
|
|
}
|
|
|
|
/**
|
|
* Start a Telnet session using native Node.js net module
|
|
*/
|
|
const { createTelnetSessionApi } = require("./terminalBridge/telnetSession.cjs");
|
|
const telnetSessionApi = createTelnetSessionApi({
|
|
get sessions() { return sessions; },
|
|
get electronModule() { return electronModule; },
|
|
net, randomUUID, StringDecoder, iconv, Buffer, console, setTimeout, clearTimeout,
|
|
normalizeTerminalEncoding, encodeTerminalInput, createTelnetAutoLogin, telnetProtocol,
|
|
createPtyOutputBuffer, sessionLogStreamManager, createZmodemSentry, ptyProcessTree,
|
|
enableTcpNoDelay, trackSessionIdlePrompt, stripAnsi, clearPendingAutomatedWrites,
|
|
openTerminalOutputSession, closeTerminalOutputSession,
|
|
get selectZmodemUploadFiles() { return selectZmodemUploadFiles; },
|
|
get selectZmodemDownloadDirectory() { return selectZmodemDownloadDirectory; },
|
|
});
|
|
const { startTelnetSession } = telnetSessionApi;
|
|
|
|
/**
|
|
* Resolve Netcatty's bundled bare `mosh-client` binary.
|
|
*
|
|
* Returns the absolute path or null.
|
|
*/
|
|
const { createMoshSessionApi } = require("./terminalBridge/moshSession.cjs");
|
|
const moshSessionApi = createMoshSessionApi({
|
|
get sessions() { return sessions; },
|
|
get electronModule() { return electronModule; },
|
|
os, fs, net, path, pty, iconv, Buffer, StringDecoder, process, console,
|
|
setTimeout, clearTimeout, setInterval, clearInterval,
|
|
randomUUID, execFileAsync, ptyProcessTree, sessionLogStreamManager,
|
|
stripAnsi, trackSessionIdlePrompt, createZmodemSentry, moshHandshake, tempDirBridge,
|
|
createPtyOutputBuffer, enableTcpNoDelay, normalizeTerminalEncoding,
|
|
resolvePosixExecutable, findExecutable, isExecutableFile,
|
|
openTerminalOutputSession, closeTerminalOutputSession,
|
|
get selectZmodemUploadFiles() { return selectZmodemUploadFiles; },
|
|
get selectZmodemDownloadDirectory() { return selectZmodemDownloadDirectory; },
|
|
ensureMoshStatsConnection: (...args) => require("./sshBridge.cjs").ensureMoshStatsConnection(...args),
|
|
getAvailableAgentSocket: getNativeOpenSshAgentSocket,
|
|
prepareSystemSshAgentForAuth,
|
|
bundledMoshClient: (...args) => bundledMoshClient(...args),
|
|
});
|
|
const {
|
|
resolveBareMoshClient,
|
|
addBundledMoshRuntimeEnv,
|
|
createMoshUtf8Decoder,
|
|
buildMoshSshAuthArgs,
|
|
cleanupMoshAuthTempFiles,
|
|
startMoshSessionViaHandshake,
|
|
swapToMoshClient,
|
|
resolveLangFromCharsetForMosh,
|
|
startMoshSession,
|
|
} = moshSessionApi;
|
|
|
|
/**
|
|
* EternalTerminal session API. `et` is a self-contained client that performs
|
|
* its own SSH bootstrap + ET protocol handshake, so Netcatty just spawns the
|
|
* bundled `et` binary as a PTY (no Node handshake wrapper like Mosh needs).
|
|
*/
|
|
const { createEtSessionApi } = require("./terminalBridge/etSession.cjs");
|
|
const etSessionApi = createEtSessionApi({
|
|
get sessions() { return sessions; },
|
|
get electronModule() { return electronModule; },
|
|
os, fs, path, pty, process, console,
|
|
randomUUID, execFile, execFileSync, StringDecoder,
|
|
sessionLogStreamManager, tempDirBridge,
|
|
createZmodemSentry, trackSessionIdlePrompt, createPtyOutputBuffer,
|
|
findExecutable,
|
|
openTerminalOutputSession, closeTerminalOutputSession,
|
|
getAvailableAgentSocket: getNativeOpenSshAgentSocket,
|
|
prepareSystemSshAgentForAuth,
|
|
get selectZmodemUploadFiles() { return selectZmodemUploadFiles; },
|
|
get selectZmodemDownloadDirectory() { return selectZmodemDownloadDirectory; },
|
|
bundledEtClient: (...args) => bundledEtClient(...args),
|
|
});
|
|
const {
|
|
startEtSession,
|
|
execOnEtSession,
|
|
cleanupStaleEtTempDirs,
|
|
cleanupSessionExternalAuthArtifacts,
|
|
} = etSessionApi;
|
|
|
|
/**
|
|
* List available serial ports (hardware only)
|
|
*/
|
|
async function listSerialPorts() {
|
|
try {
|
|
const ports = await SerialPort.list();
|
|
return ports.map(port => ({
|
|
path: port.path,
|
|
manufacturer: port.manufacturer || '',
|
|
serialNumber: port.serialNumber || '',
|
|
vendorId: port.vendorId || '',
|
|
productId: port.productId || '',
|
|
pnpId: port.pnpId || '',
|
|
type: 'hardware',
|
|
}));
|
|
} catch (err) {
|
|
console.error("[Serial] Failed to list ports:", err.message);
|
|
return [];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Start a serial port session (supports both hardware serial ports and PTY devices)
|
|
* Note: SerialPort library can open PTY devices directly, they just won't appear in list()
|
|
*/
|
|
async function startSerialSession(event, options) {
|
|
const sessionId = options.sessionId || randomUUID();
|
|
|
|
const portPath = options.path;
|
|
const baudRate = options.baudRate || 115200;
|
|
const dataBits = options.dataBits || 8;
|
|
const stopBits = options.stopBits || 1;
|
|
const parity = options.parity || 'none';
|
|
const flowControl = options.flowControl || 'none';
|
|
|
|
console.log(`[Serial] Starting connection to ${portPath} at ${baudRate} baud`);
|
|
|
|
return new Promise((resolve, reject) => {
|
|
// Token for the log stream we open on this connection. Captured here so
|
|
// the close/error handlers can pass it to stopStream and avoid
|
|
// tearing down a freshly started stream after a "Restart" reconnect on
|
|
// the same sessionId (issue #916).
|
|
let logStreamToken = null;
|
|
try {
|
|
const serialPort = new SerialPort({
|
|
path: portPath,
|
|
baudRate: baudRate,
|
|
dataBits: dataBits,
|
|
stopBits: stopBits,
|
|
parity: parity,
|
|
rtscts: flowControl === 'rts/cts',
|
|
xon: flowControl === 'xon/xoff',
|
|
xoff: flowControl === 'xon/xoff',
|
|
autoOpen: false,
|
|
});
|
|
|
|
serialPort.open((err) => {
|
|
if (err) {
|
|
console.error(`[Serial] Failed to open port ${portPath}:`, err.message);
|
|
reject(new Error(`Failed to open serial port: ${err.message}`));
|
|
return;
|
|
}
|
|
|
|
console.log(`[Serial] Connected to ${portPath}`);
|
|
|
|
const initialSerialEncoding = normalizeTerminalEncoding(options.charset);
|
|
const serialDecoderRef = { current: iconv.getDecoder(initialSerialEncoding) };
|
|
|
|
const session = {
|
|
serialPort,
|
|
type: 'serial',
|
|
protocol: 'serial',
|
|
shellKind: 'raw',
|
|
encoding: initialSerialEncoding,
|
|
// Kept for backward compatibility with aiBridge / mcpServerBridge
|
|
// which read session.serialEncoding for exec calls.
|
|
serialEncoding: initialSerialEncoding,
|
|
decoderRef: serialDecoderRef,
|
|
webContentsId: event.sender.id,
|
|
};
|
|
sessions.set(sessionId, session);
|
|
openTerminalOutputSession(sessionId, event.sender);
|
|
|
|
// Start real-time session log stream if configured
|
|
if (options.sessionLog?.enabled && options.sessionLog?.directory) {
|
|
logStreamToken = sessionLogStreamManager.startStream(sessionId, {
|
|
hostLabel: options.label || portPath,
|
|
hostname: portPath,
|
|
directory: options.sessionLog.directory,
|
|
format: options.sessionLog.format || "txt",
|
|
timestampsEnabled: Boolean(options.sessionLog.timestampsEnabled),
|
|
startTime: Date.now(),
|
|
});
|
|
}
|
|
|
|
const serialZmodemSentry = createZmodemSentry({
|
|
sessionId,
|
|
onData(buf) {
|
|
const decoded = serialDecoderRef.current.write(buf);
|
|
if (!decoded) return;
|
|
const contents = electronModule.webContents.fromId(session.webContentsId);
|
|
emitTerminalSessionData(contents, sessionId, decoded, {
|
|
cols: session.cols,
|
|
rows: session.rows,
|
|
});
|
|
sessionLogStreamManager.appendData(sessionId, decoded);
|
|
},
|
|
writeToRemote(buf) {
|
|
try { return serialPort.write(buf); } catch { return true; }
|
|
},
|
|
getWebContents() {
|
|
return electronModule.webContents.fromId(session.webContentsId);
|
|
},
|
|
selectUploadFiles: selectZmodemUploadFiles
|
|
? () => selectZmodemUploadFiles(session.webContentsId)
|
|
: undefined,
|
|
selectDownloadDirectory: selectZmodemDownloadDirectory
|
|
? () => selectZmodemDownloadDirectory(session.webContentsId)
|
|
: undefined,
|
|
label: "Serial",
|
|
});
|
|
session.zmodemSentry = serialZmodemSentry;
|
|
|
|
serialPort.on('data', (data) => {
|
|
if (session.ymodemActive) return;
|
|
if (!shouldProcessSessionOutput(session, serialZmodemSentry)) return;
|
|
// data is already Buffer from serialport — feed to sentry
|
|
serialZmodemSentry.consume(data);
|
|
});
|
|
|
|
serialPort.on('error', (err) => {
|
|
console.error(`[Serial] Port error: ${err.message}`);
|
|
session.zmodemSentry?.cancel();
|
|
session.ymodemAbortController?.abort();
|
|
sessionLogStreamManager.stopStream(sessionId, logStreamToken);
|
|
const contents = electronModule.webContents.fromId(session.webContentsId);
|
|
contents?.send("netcatty:exit", { sessionId, exitCode: 1, error: err.message, reason: "error" });
|
|
ptyProcessTree.unregisterPid(sessionId);
|
|
sessions.delete(sessionId);
|
|
});
|
|
|
|
serialPort.on('close', () => {
|
|
console.log(`[Serial] Port closed`);
|
|
session.zmodemSentry?.cancel();
|
|
session.ymodemAbortController?.abort();
|
|
sessionLogStreamManager.stopStream(sessionId, logStreamToken);
|
|
const contents = electronModule.webContents.fromId(session.webContentsId);
|
|
contents?.send("netcatty:exit", { sessionId, exitCode: 0, reason: "closed" });
|
|
ptyProcessTree.unregisterPid(sessionId);
|
|
sessions.delete(sessionId);
|
|
});
|
|
|
|
resolve({ sessionId });
|
|
});
|
|
} catch (err) {
|
|
console.error("[Serial] Failed to start serial session:", err.message);
|
|
reject(err);
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Write data to a session
|
|
*/
|
|
function cancelActiveYmodemSession(session) {
|
|
if (!session?.ymodemActive) return;
|
|
void sendYmodemCancel(session.serialPort);
|
|
session.ymodemAbortController?.abort();
|
|
}
|
|
|
|
function pauseSshOutputForInterrupt(session, trace) {
|
|
const stream = session?.stream;
|
|
if (!stream || typeof stream.pause !== "function") return false;
|
|
const flowState = session.flowState;
|
|
let alreadyPaused = Boolean(flowState?.appliedPause || flowState?.rendererPaused);
|
|
try {
|
|
if (typeof stream.isPaused === "function") {
|
|
alreadyPaused = alreadyPaused || stream.isPaused();
|
|
}
|
|
} catch {
|
|
// Treat unreadable pause state as not paused; a best-effort pause is fine.
|
|
}
|
|
if (alreadyPaused) return false;
|
|
logTerminalInterruptDebug("interrupt-output-pause-before-write-start", {
|
|
session: getSessionSnapshot(session),
|
|
}, trace);
|
|
try {
|
|
stream.pause();
|
|
logTerminalInterruptDebug("interrupt-output-pause-before-write-done", {
|
|
session: getSessionSnapshot(session),
|
|
}, trace);
|
|
return true;
|
|
} catch (err) {
|
|
logTerminalInterruptDebug("interrupt-output-pause-before-write-failed", {
|
|
error: err?.message || String(err),
|
|
code: err?.code,
|
|
session: getSessionSnapshot(session),
|
|
}, trace);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function clearPendingAutomatedWrites(session) {
|
|
const timers = session?.pendingAutomatedWriteTimers;
|
|
if (!Array.isArray(timers) || timers.length === 0) return;
|
|
for (const timer of timers) clearTimeout(timer);
|
|
session.pendingAutomatedWriteTimers = [];
|
|
}
|
|
|
|
// Terminal-originated automatic replies (cursor position reports, device
|
|
// attributes, focus in/out, etc.) travel through the same write path as user
|
|
// keystrokes but must NOT be treated as "the user started typing". A terminal
|
|
// routinely emits such a reply right after the first line runs; counting it as
|
|
// manual input would clear the pending automated line-by-line writes and only
|
|
// the first line would ever be sent (multi-line compose-bar input bug).
|
|
function isTerminalReportSequence(data) {
|
|
if (typeof data !== "string" || data.length === 0) return false;
|
|
// Focus in/out reports: ESC [ I / ESC [ O
|
|
if (data === "\x1b[I" || data === "\x1b[O") return true;
|
|
// CPR / DECXCPR / DA1 / DA2 / DSR: ESC [ (?|>)? digits/semicolons (R|c|n)
|
|
if (/^\x1b\[[?>]?[0-9;]*[Rcn]$/.test(data)) return true;
|
|
// Kitty keyboard mode query reply: ESC [ ? digits u
|
|
if (/^\x1b\[\?[0-9]+u$/.test(data)) return true;
|
|
// DCS replies (XTGETTCAP / DECRQSS, etc.): ESC P ... ESC \
|
|
if (/^\x1bP[\s\S]*\x1b\\$/.test(data)) return true;
|
|
return false;
|
|
}
|
|
|
|
function splitTerminalInputIntoLineWrites(data) {
|
|
if (typeof data !== "string") return [data];
|
|
const chunks = [];
|
|
let line = "";
|
|
|
|
for (let index = 0; index < data.length; index += 1) {
|
|
const char = data[index];
|
|
if (char === "\r" || char === "\n") {
|
|
if (char === "\r" && data[index + 1] === "\n") index += 1;
|
|
chunks.push(`${line}\r`);
|
|
line = "";
|
|
continue;
|
|
}
|
|
line += char;
|
|
}
|
|
|
|
if (line.length > 0) chunks.push(line);
|
|
return chunks.length > 0 ? chunks : [data];
|
|
}
|
|
|
|
function getAutomatedLineDelayMs(payload) {
|
|
if (!payload?.automated) return 0;
|
|
const lineDelayMs = Number(payload.lineDelayMs);
|
|
return Number.isFinite(lineDelayMs) && lineDelayMs > 0 ? Math.min(lineDelayMs, 2000) : 0;
|
|
}
|
|
|
|
function shouldBlockSessionInput(session, data) {
|
|
if (session.ymodemActive) {
|
|
if (data === '\x03') {
|
|
cancelActiveYmodemSession(session);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// During ZMODEM transfer, block terminal input (Ctrl+C cancels the transfer)
|
|
if (session.zmodemSentry?.isActive()) {
|
|
if (data === '\x03') {
|
|
session.zmodemSentry.cancel();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
function writeToSessionNow(payload, data, logRewrite = payload.logRewrite) {
|
|
const session = sessions.get(payload.sessionId);
|
|
const trace = payload.interruptTrace || null;
|
|
if (!session) {
|
|
logTerminalInterruptDebug("write-session-missing", {
|
|
sessionId: payload.sessionId,
|
|
dataCode: data === "\x03" ? "ETX" : undefined,
|
|
}, trace);
|
|
return;
|
|
}
|
|
if (shouldBlockSessionInput(session, data)) {
|
|
logTerminalInterruptDebug("write-session-blocked-by-transfer", {
|
|
sessionId: payload.sessionId,
|
|
dataCode: data === "\x03" ? "ETX" : undefined,
|
|
session: getSessionSnapshot(session),
|
|
}, trace);
|
|
return;
|
|
}
|
|
if (data !== "\x03" && !payload.automated && !isTerminalReportSequence(data)) {
|
|
disarmTerminalInterruptOutputGate(session);
|
|
}
|
|
|
|
try {
|
|
if (session.type === 'telnet-native' && !payload.automated) {
|
|
session.autoLogin?.handleUserInput();
|
|
}
|
|
|
|
// Encode keystrokes with the SAME charset the output path decodes with so
|
|
// input and output stay symmetric on non-UTF-8 devices (issue #1216).
|
|
// session.encoding is the normalized iconv identifier; it is only set on
|
|
// sessions whose output is iconv-decoded (SSH / telnet / serial). Mosh and
|
|
// local PTY leave it unset, so encodeTerminalInput returns the original
|
|
// UTF-8 string for them. For UTF-8 it also returns the string unchanged, so
|
|
// the transport's native string serialization keeps handling that case.
|
|
sessionLogStreamManager.registerSudoAutofillInput(payload.sessionId, data);
|
|
sessionLogStreamManager.registerProgrammaticCommandLogRewrite(payload.sessionId, logRewrite);
|
|
const inputData = session.type === 'telnet-native'
|
|
? telnetProtocol.normalizeNvtNewlines(data)
|
|
: data;
|
|
const outgoing = encodeTerminalInput(inputData, session.encoding);
|
|
|
|
if (session.stream) {
|
|
const shouldLogInterruptWrite = data === "\x03" || trace;
|
|
if (shouldLogInterruptWrite) {
|
|
logTerminalInterruptDebug("ssh-stream-write-start", {
|
|
outgoingBytes: Buffer.isBuffer(outgoing) ? outgoing.length : Buffer.byteLength(String(outgoing)),
|
|
dataCode: data === "\x03" ? "ETX" : undefined,
|
|
session: getSessionSnapshot(session),
|
|
}, trace);
|
|
}
|
|
const writeResult = session.stream.write(outgoing);
|
|
if (shouldLogInterruptWrite) {
|
|
logTerminalInterruptDebug("ssh-stream-write-done", {
|
|
writeResult,
|
|
session: getSessionSnapshot(session),
|
|
}, trace);
|
|
}
|
|
} else if (session.proc) {
|
|
session.proc.write(outgoing);
|
|
} else if (session.socket) {
|
|
// Telnet only: any 0xFF byte going out the wire must be doubled, or
|
|
// the peer will treat it as the start of an IAC command sequence and
|
|
// eat the next byte (RFC 854 §"Data Stream"). UTF-8 keyboard input
|
|
// never produces 0xFF, but paste of binary content and some legacy
|
|
// encodings do. Cheap no-op when there is no 0xFF.
|
|
let wireData = outgoing;
|
|
if (session.type === 'telnet-native' && session.telnetProtocolActive) {
|
|
if (typeof wireData === 'string') {
|
|
wireData = Buffer.from(wireData, 'utf8');
|
|
}
|
|
wireData = telnetProtocol.escapeIacForWire(wireData);
|
|
}
|
|
session.socket.write(wireData);
|
|
} else if (session.serialPort) {
|
|
session.serialPort.write(outgoing);
|
|
}
|
|
} catch (err) {
|
|
logTerminalInterruptDebug("write-session-error", {
|
|
sessionId: payload.sessionId,
|
|
error: err?.message || String(err),
|
|
code: err?.code,
|
|
session: getSessionSnapshot(session),
|
|
}, trace);
|
|
if (err.code !== 'EPIPE' && err.code !== 'ERR_STREAM_DESTROYED') {
|
|
console.warn("Write failed", err);
|
|
}
|
|
}
|
|
}
|
|
|
|
function writeToSession(event, payload) {
|
|
const session = sessions.get(payload.sessionId);
|
|
if (!session) return;
|
|
|
|
if (!payload.automated && !isTerminalReportSequence(payload.data)) {
|
|
clearPendingAutomatedWrites(session);
|
|
}
|
|
if (shouldBlockSessionInput(session, payload.data)) {
|
|
return;
|
|
}
|
|
|
|
const lineDelayMs = getAutomatedLineDelayMs(payload);
|
|
const lineChunks = lineDelayMs > 0 ? splitTerminalInputIntoLineWrites(payload.data) : [payload.data];
|
|
if (lineDelayMs > 0 && lineChunks.length > 1) {
|
|
clearPendingAutomatedWrites(session);
|
|
session.pendingAutomatedWriteTimers = [];
|
|
lineChunks.forEach((chunk, index) => {
|
|
const sendChunk = () => {
|
|
const current = sessions.get(payload.sessionId);
|
|
if (!current) return;
|
|
writeToSessionNow(
|
|
{ ...payload, lineDelayMs: undefined },
|
|
chunk,
|
|
index === 0 ? payload.logRewrite : undefined,
|
|
);
|
|
};
|
|
if (index === 0) {
|
|
sendChunk();
|
|
return;
|
|
}
|
|
const timer = setTimeout(sendChunk, index * lineDelayMs);
|
|
session.pendingAutomatedWriteTimers.push(timer);
|
|
});
|
|
return;
|
|
}
|
|
|
|
writeToSessionNow(payload, payload.data);
|
|
}
|
|
|
|
function drainPendingOutputForInterrupt(sessionId, session, trace) {
|
|
if (typeof session?.takePendingData !== "function") return;
|
|
const pendingEntry = session.takePendingData();
|
|
const pending = typeof pendingEntry === "string" ? pendingEntry : pendingEntry?.data;
|
|
const pendingMeta = typeof pendingEntry === "string" ? undefined : pendingEntry?.meta;
|
|
if (!pending) return;
|
|
const output = filterTerminalInterruptOutput(session, pending);
|
|
if (!output.accepted || output.droppedBytes > 0) {
|
|
logTerminalInterruptDebug("interrupt-pending-output-filtered", {
|
|
session: getSessionSnapshot(session),
|
|
droppedBytes: output.droppedBytes,
|
|
reason: output.reason,
|
|
accepted: output.accepted,
|
|
}, trace);
|
|
}
|
|
if (!output.accepted || !output.data) {
|
|
stashPendingInterruptOutputMeta(session, pendingMeta);
|
|
return;
|
|
}
|
|
const outputMeta = takePendingInterruptOutputMeta(session, pendingMeta);
|
|
const contents = electronModule.webContents.fromId(session.webContentsId);
|
|
emitTerminalSessionData(contents, sessionId, output.data, {
|
|
cols: session.cols,
|
|
rows: session.rows,
|
|
meta: outputMeta,
|
|
});
|
|
}
|
|
|
|
function interruptSession(event, payload) {
|
|
const session = sessions.get(payload.sessionId);
|
|
const trace = normalizeTrace(payload);
|
|
if (!session) {
|
|
logTerminalInterruptDebug("interrupt-session-missing", {
|
|
sessionId: payload.sessionId,
|
|
senderId: event?.sender?.id,
|
|
}, trace);
|
|
return;
|
|
}
|
|
rememberInterruptTrace(session, trace);
|
|
resetTerminalFlowAckSample(session);
|
|
logTerminalInterruptDebug("interrupt-session-received", {
|
|
sessionId: payload.sessionId,
|
|
senderId: event?.sender?.id,
|
|
rendererPriority: trace?.rendererPriority,
|
|
session: getSessionSnapshot(session),
|
|
}, trace);
|
|
|
|
clearPendingAutomatedWrites(session);
|
|
const shouldDrainOldOutput = shouldArmTerminalInterruptOutputGate(session);
|
|
const pausedForInterrupt = shouldDrainOldOutput
|
|
? pauseSshOutputForInterrupt(session, trace)
|
|
: false;
|
|
if (shouldDrainOldOutput) {
|
|
armTerminalInterruptOutputGate(session);
|
|
logTerminalInterruptDebug("interrupt-output-drain-armed", {
|
|
session: getSessionSnapshot(session),
|
|
}, trace);
|
|
drainPendingOutputForInterrupt(payload.sessionId, session, trace);
|
|
}
|
|
logTerminalInterruptDebug("interrupt-clear-flow-start", {
|
|
session: getSessionSnapshot(session),
|
|
}, trace);
|
|
clearSessionFlowState(session, { resume: !shouldDrainOldOutput });
|
|
logTerminalInterruptDebug("interrupt-clear-flow-done", {
|
|
session: getSessionSnapshot(session),
|
|
}, trace);
|
|
writeToSessionNow({ sessionId: payload.sessionId, interruptTrace: trace }, "\x03");
|
|
if (shouldDrainOldOutput || pausedForInterrupt) {
|
|
queueMicrotask(() => {
|
|
if (sessions.get(payload.sessionId) !== session) return;
|
|
try {
|
|
session.stream?.resume?.();
|
|
logTerminalInterruptDebug("interrupt-output-resumed-after-write", {
|
|
session: getSessionSnapshot(session),
|
|
}, trace);
|
|
} catch (err) {
|
|
logTerminalInterruptDebug("interrupt-output-resume-after-write-failed", {
|
|
error: err?.message || String(err),
|
|
code: err?.code,
|
|
session: getSessionSnapshot(session),
|
|
}, trace);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
async function sendSerialYmodem(_event, payload) {
|
|
const session = sessions.get(payload?.sessionId);
|
|
if (!session || !session.serialPort || session.type !== 'serial') {
|
|
return { success: false, error: "YMODEM send requires an active serial session" };
|
|
}
|
|
if (session.ymodemActive) {
|
|
return { success: false, error: "A YMODEM transfer is already in progress" };
|
|
}
|
|
if (session.zmodemSentry?.isActive()) {
|
|
return { success: false, error: "Another serial file transfer is already in progress" };
|
|
}
|
|
if (!payload?.filePath || typeof payload.filePath !== "string") {
|
|
return { success: false, error: "No file selected" };
|
|
}
|
|
|
|
const abortController = new AbortController();
|
|
session.ymodemActive = true;
|
|
session.ymodemAbortController = abortController;
|
|
|
|
try {
|
|
const result = await sendYmodemFile(session.serialPort, payload.filePath, {
|
|
abortSignal: abortController.signal,
|
|
timeoutMs: Number.isFinite(payload.timeoutMs) ? payload.timeoutMs : undefined,
|
|
});
|
|
return { success: true, ...result };
|
|
} catch (error) {
|
|
return {
|
|
success: false,
|
|
error: error instanceof Error ? error.message : String(error),
|
|
code: error?.code,
|
|
};
|
|
} finally {
|
|
session.ymodemActive = false;
|
|
session.ymodemAbortController = null;
|
|
}
|
|
}
|
|
|
|
async function receiveSerialYmodem(_event, payload) {
|
|
const session = sessions.get(payload?.sessionId);
|
|
if (!session || !session.serialPort || session.type !== 'serial') {
|
|
return { success: false, error: "YMODEM receive requires an active serial session" };
|
|
}
|
|
if (session.ymodemActive) {
|
|
return { success: false, error: "A YMODEM transfer is already in progress" };
|
|
}
|
|
if (session.zmodemSentry?.isActive()) {
|
|
return { success: false, error: "Another serial file transfer is already in progress" };
|
|
}
|
|
if (!payload?.destinationDir || typeof payload.destinationDir !== "string") {
|
|
return { success: false, error: "No destination directory selected" };
|
|
}
|
|
|
|
const abortController = new AbortController();
|
|
session.ymodemActive = true;
|
|
session.ymodemAbortController = abortController;
|
|
|
|
try {
|
|
const result = await receiveYmodemFiles(session.serialPort, {
|
|
destinationDir: payload.destinationDir,
|
|
abortSignal: abortController.signal,
|
|
timeoutMs: Number.isFinite(payload.timeoutMs) ? payload.timeoutMs : undefined,
|
|
});
|
|
return { success: true, ...result };
|
|
} catch (error) {
|
|
if (error?.code !== "YMODEM_CANCELLED" && error?.code !== "YMODEM_REMOTE_CANCELLED") {
|
|
await sendYmodemCancel(session.serialPort);
|
|
}
|
|
return {
|
|
success: false,
|
|
error: error instanceof Error ? error.message : String(error),
|
|
code: error?.code,
|
|
};
|
|
} finally {
|
|
session.ymodemActive = false;
|
|
session.ymodemAbortController = null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Pause or resume a session's source stream for output back-pressure.
|
|
* The renderer asks for this when its write backlog crosses a watermark, so a
|
|
* flooding source can't outrun the terminal renderer. Works across session
|
|
* kinds: ssh2 channel (stream), node-pty (proc), telnet socket, serial port —
|
|
* all expose pause()/resume().
|
|
*/
|
|
function setSessionFlowPaused(event, payload) {
|
|
const session = sessions.get(payload.sessionId);
|
|
if (!session) {
|
|
logTerminalInterruptDebug("flow-paused-session-missing", {
|
|
sessionId: payload.sessionId,
|
|
paused: Boolean(payload.paused),
|
|
senderId: event?.sender?.id,
|
|
}, normalizeTrace(payload));
|
|
return;
|
|
}
|
|
const trace = getRecentInterruptTrace(session);
|
|
setRendererFlowPaused(session, payload.paused);
|
|
if (!payload.paused) {
|
|
session.flushPendingData?.();
|
|
}
|
|
if (trace) {
|
|
logTerminalFlowPauseSample(session, {
|
|
sessionId: payload.sessionId,
|
|
paused: Boolean(payload.paused),
|
|
senderId: event?.sender?.id,
|
|
});
|
|
}
|
|
}
|
|
|
|
function ackSessionFlow(event, payload) {
|
|
const session = sessions.get(payload.sessionId);
|
|
if (!session) return;
|
|
logTerminalFlowAckSample(session, {
|
|
sessionId: payload.sessionId,
|
|
bytes: Number(payload.bytes),
|
|
senderId: event?.sender?.id,
|
|
});
|
|
trackAck(session, Number(payload.bytes), payload.sessionId);
|
|
session.flushPendingData?.();
|
|
}
|
|
|
|
/**
|
|
* Resize a session terminal
|
|
*/
|
|
function resizeSession(event, payload) {
|
|
const session = sessions.get(payload.sessionId);
|
|
if (!session) return;
|
|
if (Number.isFinite(payload.cols)) session.cols = payload.cols;
|
|
if (Number.isFinite(payload.rows)) session.rows = payload.rows;
|
|
|
|
try {
|
|
if (session.stream) {
|
|
session.stream.setWindow(payload.rows, payload.cols, 0, 0);
|
|
} else if (session.proc) {
|
|
session.proc.resize(payload.cols, payload.rows);
|
|
} else if (session.socket && session.type === 'telnet-native') {
|
|
session.cols = payload.cols;
|
|
session.rows = payload.rows;
|
|
// Only push a NAWS update once Telnet is active and the peer has enabled
|
|
// NAWS with DO NAWS; partial console wrappers may leak SB payload bytes.
|
|
if (session.telnetProtocolActive) {
|
|
session.sendTelnetWindowSize?.();
|
|
}
|
|
}
|
|
} catch (err) {
|
|
if (err.code !== 'EPIPE' && err.code !== 'ERR_STREAM_DESTROYED') {
|
|
console.warn("Resize failed", err);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Close a session
|
|
*/
|
|
function closeSession(event, payload) {
|
|
const session = sessions.get(payload.sessionId);
|
|
if (!session) return;
|
|
session.closed = true;
|
|
closeTerminalOutputSession(payload.sessionId);
|
|
|
|
try {
|
|
clearSessionFlowState(session, { resume: false });
|
|
cancelActiveYmodemSession(session);
|
|
clearPendingAutomatedWrites(session);
|
|
session.zmodemSentry?.cancel();
|
|
session.discardPendingData?.();
|
|
cleanupSessionExternalAuthArtifacts(session);
|
|
session.releaseTelnetGeneration?.();
|
|
if (session.stream) {
|
|
// Snapshot multiplexing state *before* closing the channel: closing the
|
|
// stream can synchronously fire its "close" handler, which nulls
|
|
// session.connRef (and may already release the shared connection). Reading
|
|
// session.connRef afterwards would then wrongly fall into the legacy path
|
|
// and end the shared connection a second time.
|
|
const isMultiplexed = !!session.connRef;
|
|
// Always close this session's own shell channel.
|
|
session.stream.close();
|
|
if (isMultiplexed) {
|
|
// Multiplexed SSH shell (issue #1204): several tabs may share one
|
|
// authenticated connection. Closing this tab must only tear the shared
|
|
// transport (and jump-host chain) down once the last channel is gone,
|
|
// so route teardown through the reference-counted descriptor instead of
|
|
// ending the connection directly. releaseConnectionRef is idempotent and
|
|
// ends the chain connections itself when the count reaches zero — so it
|
|
// is safe even if the stream "close" handler above already released.
|
|
releaseConnectionRef(session);
|
|
} else {
|
|
// Legacy / non-multiplexed path: this session owns its connection.
|
|
session.conn?.end();
|
|
if (session.chainConnections) {
|
|
for (const c of session.chainConnections) {
|
|
try { c.end(); } catch {}
|
|
}
|
|
}
|
|
}
|
|
} else if (session.proc) {
|
|
session.proc.kill();
|
|
// Mosh sessions may also carry a companion ssh2 connection opened
|
|
// lazily for host-info stats (issue #1198). ET can use the same pattern.
|
|
// Close companions here to avoid leaking them.
|
|
try { session.moshStatsConn?.end(); } catch { /* ignore */ }
|
|
try { session.etStatsConn?.end(); } catch { /* ignore */ }
|
|
} else if (session.socket) {
|
|
session.socket.destroy();
|
|
} else if (session.serialPort) {
|
|
session.serialPort.close();
|
|
} else if (session.chainConnections) {
|
|
// Non-stream session still carrying a jump-host chain (defensive).
|
|
for (const c of session.chainConnections) {
|
|
try { c.end(); } catch {}
|
|
}
|
|
}
|
|
} catch (err) {
|
|
console.warn("Close failed", err);
|
|
} finally {
|
|
cleanupMoshAuthTempFiles(session.moshAuthTempFiles);
|
|
}
|
|
ptyProcessTree.unregisterPid(payload.sessionId);
|
|
sessions.delete(payload.sessionId);
|
|
}
|
|
|
|
/**
|
|
* Set terminal decoder encoding for an active telnet or serial session.
|
|
* SSH sessions are handled by sshBridge's own setEncoding IPC — this one
|
|
* only responds to sessions that carry a decoderRef (telnet + serial).
|
|
*/
|
|
function setSessionEncoding(_event, { sessionId, encoding }) {
|
|
const session = sessions?.get(sessionId);
|
|
if (!session || !session.decoderRef) {
|
|
return { ok: false, encoding: encoding || 'utf-8' };
|
|
}
|
|
const enc = normalizeTerminalEncoding(encoding);
|
|
if (!iconv.encodingExists(enc)) {
|
|
return { ok: false, encoding: enc };
|
|
}
|
|
session.encoding = enc;
|
|
// Keep serialEncoding mirror in sync so aiBridge / mcpServerBridge exec
|
|
// calls pick up the new encoding too.
|
|
if (session.type === 'serial') {
|
|
session.serialEncoding = enc;
|
|
}
|
|
// iconv stateful decoders carry partial-byte state from the previous
|
|
// encoding, so swap in a fresh decoder rather than reconfiguring.
|
|
session.decoderRef.current = iconv.getDecoder(enc);
|
|
return { ok: true, encoding: enc };
|
|
}
|
|
|
|
/**
|
|
* Register IPC handlers for terminal operations
|
|
*/
|
|
function registerWorkerHandle(ipcMain, terminalWorkerManager, channel) {
|
|
ipcMain.handle(channel, (event, payload) => {
|
|
return terminalWorkerManager.request(channel, payload, {
|
|
webContentsId: event?.sender?.id,
|
|
});
|
|
});
|
|
}
|
|
|
|
function registerWorkerSend(ipcMain, terminalWorkerManager, channel) {
|
|
ipcMain.on(channel, (event, payload) => {
|
|
terminalWorkerManager.send(channel, payload, {
|
|
webContentsId: event?.sender?.id,
|
|
});
|
|
});
|
|
}
|
|
|
|
function registerHandlers(ipcMain, options = {}) {
|
|
const terminalWorkerManager = options.terminalWorkerManager || null;
|
|
if (terminalWorkerManager) {
|
|
[
|
|
"netcatty:local:start",
|
|
"netcatty:telnet:start",
|
|
"netcatty:mosh:start",
|
|
"netcatty:et:start",
|
|
"netcatty:serial:start",
|
|
"netcatty:serial:list",
|
|
"netcatty:serial:ymodem-send",
|
|
"netcatty:serial:ymodem-receive",
|
|
"netcatty:local:defaultShell",
|
|
"netcatty:local:validatePath",
|
|
"netcatty:shells:discover",
|
|
"netcatty:terminal:setEncoding",
|
|
].forEach((channel) => registerWorkerHandle(ipcMain, terminalWorkerManager, channel));
|
|
ipcMain.on("netcatty:write", (event, payload) => {
|
|
// Session log streams started in the main process (manual/script logs)
|
|
// sanitize sudo-autofill markers and programmatic command echoes based
|
|
// on the *input* that produced them. In worker mode the real write
|
|
// handler runs in the utilityProcess, so mirror the rewrite
|
|
// registrations into the main-process stream manager before
|
|
// forwarding. Both calls are no-ops without an active main-process
|
|
// stream for the session.
|
|
sessionLogStreamManager.registerSudoAutofillInput(payload?.sessionId, payload?.data);
|
|
sessionLogStreamManager.registerProgrammaticCommandLogRewrite(payload?.sessionId, payload?.logRewrite);
|
|
terminalWorkerManager.send("netcatty:write", payload, {
|
|
webContentsId: event?.sender?.id,
|
|
});
|
|
});
|
|
[
|
|
"netcatty:interrupt",
|
|
"netcatty:resize",
|
|
"netcatty:flow",
|
|
"netcatty:flow:ack",
|
|
"netcatty:close",
|
|
].forEach((channel) => registerWorkerSend(ipcMain, terminalWorkerManager, channel));
|
|
return;
|
|
}
|
|
ipcMain.handle("netcatty:local:start", startLocalSession);
|
|
ipcMain.handle("netcatty:telnet:start", startTelnetSession);
|
|
ipcMain.handle("netcatty:mosh:start", startMoshSession);
|
|
ipcMain.handle("netcatty:et:start", startEtSession);
|
|
ipcMain.handle("netcatty:serial:start", startSerialSession);
|
|
ipcMain.handle("netcatty:serial:list", listSerialPorts);
|
|
ipcMain.handle("netcatty:serial:ymodem-send", sendSerialYmodem);
|
|
ipcMain.handle("netcatty:serial:ymodem-receive", receiveSerialYmodem);
|
|
ipcMain.handle("netcatty:local:defaultShell", getDefaultShell);
|
|
ipcMain.handle("netcatty:local:validatePath", validatePath);
|
|
ipcMain.handle("netcatty:shells:discover", () => discoverShells());
|
|
ipcMain.handle("netcatty:terminal:setEncoding", setSessionEncoding);
|
|
ipcMain.on("netcatty:write", writeToSession);
|
|
ipcMain.on("netcatty:interrupt", interruptSession);
|
|
ipcMain.on("netcatty:resize", resizeSession);
|
|
ipcMain.on("netcatty:flow", setSessionFlowPaused);
|
|
ipcMain.on("netcatty:flow:ack", ackSessionFlow);
|
|
ipcMain.on("netcatty:close", closeSession);
|
|
}
|
|
|
|
/**
|
|
* Get the default shell for the current platform
|
|
*/
|
|
const { createPathValidationApi } = require("./terminalBridge/pathValidation.cjs");
|
|
const pathValidationApi = createPathValidationApi({
|
|
getDefaultLocalShell, expandHomePath, path, fs, process, console, findExecutable,
|
|
});
|
|
const { getDefaultShell, validatePath } = pathValidationApi;
|
|
|
|
/**
|
|
* Locate the mosh-client binary bundled by electron-builder via
|
|
* `extraResources` (see electron-builder.config.cjs and
|
|
* binaricat/MoshCatty releases).
|
|
*
|
|
* Returns an absolute path when the binary is on disk, otherwise null.
|
|
* In dev / non-packaged runs the path is computed against the project
|
|
* root so the helper is testable without packaging the app.
|
|
*
|
|
* Note this returns the network-protocol `mosh-client`, not the `mosh`
|
|
* wrapper script. Netcatty drives the SSH bootstrap itself and then
|
|
* launches this bundled client directly.
|
|
*/
|
|
function bundledMoshClient(opts = {}) {
|
|
const isWin = (opts.platform || process.platform) === "win32";
|
|
const basename = isWin ? "mosh-client.exe" : "mosh-client";
|
|
|
|
// Packaged: <Resources>/mosh/mosh-client[.exe]
|
|
const resourcesPath = opts.resourcesPath || process.resourcesPath;
|
|
if (resourcesPath) {
|
|
const packaged = path.join(resourcesPath, "mosh", basename);
|
|
if (fs.existsSync(packaged) && isExecutableFile(packaged)) return packaged;
|
|
}
|
|
|
|
// Dev fallback: resources/mosh/<platform-arch>/mosh-client[.exe] under
|
|
// the project root. Useful for `npm run start` after running
|
|
// `npm run fetch:mosh` locally.
|
|
const projectRoot = opts.projectRoot || path.resolve(__dirname, "..", "..");
|
|
const platform = opts.platform || process.platform;
|
|
const arch = opts.arch || process.arch;
|
|
const candidates = [];
|
|
if (platform === "darwin") {
|
|
candidates.push(path.join(projectRoot, "resources", "mosh", "darwin-universal", basename));
|
|
} else {
|
|
candidates.push(path.join(projectRoot, "resources", "mosh", `${platform}-${arch}`, basename));
|
|
}
|
|
for (const c of candidates) {
|
|
if (fs.existsSync(c) && isExecutableFile(c)) return c;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Locate the EternalTerminal `et` client bundled by electron-builder via
|
|
* `extraResources` (see electron-builder.config.cjs and
|
|
* .github/workflows/build-et-binaries.yml).
|
|
*
|
|
* Returns an absolute path when the binary is on disk, otherwise null. In
|
|
* dev / non-packaged runs the path is computed against the project root so
|
|
* the helper is testable without packaging the app.
|
|
*
|
|
* `et` is a self-contained client that performs its own SSH bootstrap and
|
|
* EternalTerminal protocol handshake; Netcatty just spawns it as a PTY.
|
|
*/
|
|
function bundledEtClient(opts = {}) {
|
|
const isWin = (opts.platform || process.platform) === "win32";
|
|
const basename = isWin ? "et.exe" : "et";
|
|
|
|
// Packaged: <Resources>/et/et[.exe]
|
|
const resourcesPath = opts.resourcesPath || process.resourcesPath;
|
|
if (resourcesPath) {
|
|
const packaged = path.join(resourcesPath, "et", basename);
|
|
if (fs.existsSync(packaged) && isExecutableFile(packaged)) return packaged;
|
|
}
|
|
|
|
// Dev fallback: resources/et/<platform-arch>/et[.exe] under the project
|
|
// root. Useful for `npm run start` after running `npm run fetch:et` locally.
|
|
const projectRoot = opts.projectRoot || path.resolve(__dirname, "..", "..");
|
|
const platform = opts.platform || process.platform;
|
|
const arch = opts.arch || process.arch;
|
|
const candidates = [];
|
|
if (platform === "darwin") {
|
|
candidates.push(path.join(projectRoot, "resources", "et", "darwin-universal", basename));
|
|
} else {
|
|
candidates.push(path.join(projectRoot, "resources", "et", `${platform}-${arch}`, basename));
|
|
}
|
|
for (const c of candidates) {
|
|
if (fs.existsSync(c) && isExecutableFile(c)) return c;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Cleanup all sessions - call before app quit
|
|
*/
|
|
function cleanupAllSessions() {
|
|
console.log(`[Terminal] Cleaning up ${sessions.size} sessions before quit`);
|
|
for (const [sessionId, session] of sessions) {
|
|
try {
|
|
session.zmodemSentry?.cancel();
|
|
cancelActiveYmodemSession(session);
|
|
clearPendingAutomatedWrites(session);
|
|
clearSessionFlowState(session, { resume: false });
|
|
session.discardPendingData?.();
|
|
closeTerminalOutputSession(sessionId);
|
|
cleanupSessionExternalAuthArtifacts(session);
|
|
session.releaseTelnetGeneration?.();
|
|
if (session.stream) {
|
|
session.stream.close();
|
|
session.conn?.end();
|
|
} else if (session.proc) {
|
|
// For node-pty on Windows, we need to kill more gracefully
|
|
try {
|
|
session.proc.kill();
|
|
} catch (e) {
|
|
// Ignore errors during cleanup
|
|
}
|
|
// Tear down a Mosh stats companion ssh2 connection if one was opened
|
|
// (issue #1198), and the equivalent ET companion when present.
|
|
try { session.moshStatsConn?.end(); } catch (e) { /* ignore */ }
|
|
try { session.etStatsConn?.end(); } catch (e) { /* ignore */ }
|
|
} else if (session.socket) {
|
|
session.socket.destroy();
|
|
} else if (session.serialPort) {
|
|
try {
|
|
session.serialPort.close();
|
|
} catch (e) {
|
|
// Ignore errors during cleanup
|
|
}
|
|
}
|
|
if (session.chainConnections) {
|
|
for (const c of session.chainConnections) {
|
|
try { c.end(); } catch {}
|
|
}
|
|
}
|
|
} catch (err) {
|
|
// Ignore cleanup errors
|
|
}
|
|
}
|
|
for (const [sessionId] of sessions) {
|
|
ptyProcessTree.unregisterPid(sessionId);
|
|
}
|
|
sessions.clear();
|
|
terminalOutputChannel?.closeAll?.();
|
|
}
|
|
|
|
module.exports = {
|
|
init,
|
|
registerHandlers,
|
|
findExecutable,
|
|
startLocalSession,
|
|
startTelnetSession,
|
|
startMoshSession,
|
|
bundledMoshClient,
|
|
resolveBareMoshClient,
|
|
addBundledMoshRuntimeEnv,
|
|
createMoshUtf8Decoder,
|
|
startEtSession,
|
|
execOnEtSession,
|
|
bundledEtClient,
|
|
startSerialSession,
|
|
sendSerialYmodem,
|
|
receiveSerialYmodem,
|
|
listSerialPorts,
|
|
writeToSession,
|
|
setSessionEncoding,
|
|
resizeSession,
|
|
setSessionFlowPaused,
|
|
ackSessionFlow,
|
|
closeSession,
|
|
interruptSession,
|
|
cleanupAllSessions,
|
|
getDefaultShell,
|
|
validatePath,
|
|
};
|