Merge main into terminal drag-drop zmodem

This commit is contained in:
bincxz committed 2026-06-12 16:37:01 +08:00
commit 285fcd55a9
88 files changed
+2774 -638

No files matched your search

@@ -0,0 +1,22 @@
const test = require("node:test");
const assert = require("node:assert/strict");
const {
filterExcludedFigSpecs,
isExcludedFigSpec,
} = require("../main/registerBridges.cjs");
test("filters cloud fig specs removed from packaged builds", () => {
assert.equal(isExcludedFigSpec("aws"), true);
assert.equal(isExcludedFigSpec("aws/s3"), true);
assert.equal(isExcludedFigSpec("gcloud"), true);
assert.equal(isExcludedFigSpec("gcloud/compute"), true);
assert.equal(isExcludedFigSpec("az"), true);
assert.equal(isExcludedFigSpec("az/2.53.0"), true);
assert.equal(isExcludedFigSpec("aws-vault"), false);
assert.deepEqual(
filterExcludedFigSpecs(["git", "aws", "aws/s3", "gcloud", "az/2.53.0", "aws-vault"]),
["git", "aws-vault"],
);
});
+1 -1
View File
@@ -16,7 +16,7 @@ const CAPABILITY_SCRIPT_POSIX = [
const PROCESS_LIST_SCRIPT_POSIX = [
"exec sh -c ",
"'",
"ps -eo pid=,ppid=,user=,stat=,pcpu=,pmem=,rss=,vsz=,etime=,args= 2>/dev/null | head -n 200",
"ps -eo pid= -o ppid= -o user= -o stat= -o pcpu= -o pmem= -o rss= -o vsz= -o etime= -o args= 2>/dev/null | head -n 200",
"'",
].join("");
@@ -0,0 +1,48 @@
"use strict";
const test = require("node:test");
const assert = require("node:assert/strict");
const { EventEmitter } = require("node:events");
const { createSystemManagerBridge } = require("./systemManagerBridge.cjs");
function createFakeExecStream(stdout) {
const stream = new EventEmitter();
stream.stderr = new EventEmitter();
process.nextTick(() => {
stream.emit("data", stdout);
stream.emit("close", 0);
});
return stream;
}
test("listProcesses uses a ps format that works on CentOS 7 procps", async () => {
const compatiblePsFormat = "ps -eo pid= -o ppid= -o user= -o stat= -o pcpu= -o pmem= -o rss= -o vsz= -o etime= -o args=";
const badCentos7Output = [
",ppid=,user=,stat=,pcpu=,pmem=,rss=,vsz=,etime=,args=",
" 1",
].join("\n");
const compatibleOutput = [
" 1 0 root Ss 0.0 0.0 4060 191024 2-19:23:42 /usr/lib/systemd/systemd --switched-root --system --deserialize 21",
].join("\n");
const conn = {
exec(command, callback) {
const stdout = command.includes(compatiblePsFormat)
? compatibleOutput
: badCentos7Output;
callback(null, createFakeExecStream(stdout));
},
};
const sessions = new Map([["s1", { conn, type: "ssh" }]]);
const bridge = createSystemManagerBridge({
getSessions: () => sessions,
process,
});
const result = await bridge.listProcesses(null, { sessionId: "s1" });
assert.equal(result.success, true);
assert.equal(result.processes.length, 1);
assert.equal(result.processes[0].pid, 1);
assert.equal(result.processes[0].command, "/usr/lib/systemd/systemd --switched-root --system --deserialize 21");
});
+44 -1
View File
@@ -29,7 +29,7 @@ const { createPtyOutputBuffer } = require("./ptyOutputBuffer.cjs");
const { enableTcpNoDelay } = require("./tcpNoDelay.cjs");
const { releaseConnectionRef } = require("./sshConnectionPool.cjs");
const { normalizeTerminalEncoding, encodeTerminalInput } = require("./terminalEncoding.cjs");
const { sendYmodemCancel, sendYmodemFile } = require("./ymodemTransfer.cjs");
const { receiveYmodemFiles, sendYmodemCancel, sendYmodemFile } = require("./ymodemTransfer.cjs");
const execFileAsync = promisify(execFile);
@@ -784,6 +784,47 @@ async function sendSerialYmodem(_event, payload) {
}
}
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
@@ -950,6 +991,7 @@ function registerHandlers(ipcMain) {
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());
@@ -1116,6 +1158,7 @@ module.exports = {
bundledEtClient,
startSerialSession,
sendSerialYmodem,
receiveSerialYmodem,
listSerialPorts,
writeToSession,
setSessionEncoding,
@@ -1,5 +1,8 @@
const test = require("node:test");
const assert = require("node:assert/strict");
const fs = require("node:fs");
const os = require("node:os");
const path = require("node:path");
const terminalBridge = require("./terminalBridge.cjs");
const { YMODEM } = require("./ymodemTransfer.cjs");
@@ -75,3 +78,67 @@ test("YMODEM send is refused while ZMODEM owns the same serial session", async (
assert.equal(result.success, false);
assert.match(result.error, /file transfer is already in progress/);
});
test("YMODEM receive is refused while ZMODEM owns the same serial session", async () => {
const sessions = new Map();
sessions.set("serial-1", {
type: "serial",
protocol: "serial",
serialPort: makeSerialPort(),
zmodemSentry: {
isActive() {
return true;
},
},
});
terminalBridge.init({ sessions, electronModule: {} });
const result = await terminalBridge.receiveSerialYmodem({ sender: {} }, {
sessionId: "serial-1",
destinationDir: "/tmp",
});
assert.equal(result.success, false);
assert.match(result.error, /file transfer is already in progress/);
});
test("YMODEM receive sends cancel bytes when the receive setup fails", async () => {
const targetDir = fs.mkdtempSync(path.join(os.tmpdir(), "netcatty-ymodem-bridge-"));
try {
const destinationFile = path.join(targetDir, "not-a-directory");
fs.writeFileSync(destinationFile, "not a directory");
const sessions = new Map();
const serialPort = makeSerialPort();
sessions.set("serial-1", {
type: "serial",
protocol: "serial",
serialPort,
});
terminalBridge.init({ sessions, electronModule: {} });
const result = await terminalBridge.receiveSerialYmodem({ sender: {} }, {
sessionId: "serial-1",
destinationDir: destinationFile,
});
assert.equal(result.success, false);
assert.deepEqual(
[...serialPort.writes[0]],
[
YMODEM.CAN,
YMODEM.CAN,
YMODEM.CAN,
YMODEM.CAN,
YMODEM.CAN,
YMODEM.BACKSPACE,
YMODEM.BACKSPACE,
YMODEM.BACKSPACE,
YMODEM.BACKSPACE,
YMODEM.BACKSPACE,
],
);
} finally {
fs.rmSync(targetDir, { recursive: true, force: true });
}
});
-1
View File
@@ -1132,7 +1132,6 @@ function buildAppMenu(Menu, app, isMac, language = currentLanguage) {
label: tMenu(language, "view"),
submenu: [
{ label: tMenu(language, "reload"), click: (_, win) => { if (win) win.reload(); } },
{ role: "forceReload" },
{ role: "toggleDevTools" },
{ type: "separator" },
{ role: "resetZoom" },
@@ -297,6 +297,39 @@ test("buildAppMenu sends Cmd+W to any registered main window renderer", () => {
}
});
test("buildAppMenu keeps app reload click-only so custom reload-like shortcuts reach the renderer", () => {
let capturedTemplate = null;
const Menu = {
buildFromTemplate(template) {
capturedTemplate = template;
return { template };
},
};
buildAppMenu(Menu, { name: "Netcatty" }, false);
const viewMenu = capturedTemplate.find((item) => item.label === "View");
assert.ok(viewMenu);
assert.equal(viewMenu.submenu.some((item) => item.role === "reload"), false);
assert.equal(viewMenu.submenu.some((item) => item.role === "forceReload"), false);
assert.equal(viewMenu.submenu.some((item) => item.accelerator === "CommandOrControl+R"), false);
assert.equal(viewMenu.submenu.some((item) => item.accelerator === "CommandOrControl+Shift+R"), false);
const reloadItem = viewMenu.submenu.find((item) => item.label === "Reload");
assert.ok(reloadItem);
assert.equal(reloadItem.role, undefined);
assert.equal(reloadItem.accelerator, undefined);
const calls = [];
reloadItem.click(null, {
reload() {
calls.push("reload");
},
});
assert.deepEqual(calls, ["reload"]);
});
test("requestWindowCommandClose sends command-close to renderer-capable windows", () => {
const sentChannels = [];
const win = {
@@ -434,6 +467,121 @@ test("main window asks renderer to close tabs from macOS Command+W before-input-
assert.equal(commandCloseRequests.length, 1);
});
test("main window leaves primary-modifier reload-like shortcuts available to renderer handlers", async () => {
let beforeInputHandler = null;
const ignoreMenuShortcutValues = [];
class BrowserWindowStub {
constructor() {
this.webContents = {
id: 1,
on(channel, handler) {
if (channel === "before-input-event") beforeInputHandler = handler;
},
once() {},
isDestroyed() {
return false;
},
isCrashed() {
return false;
},
setIgnoreMenuShortcuts(value) {
ignoreMenuShortcutValues.push(value);
},
setWindowOpenHandler() {},
openDevTools() {},
};
}
on() {}
once() {}
isDestroyed() { return false; }
isMaximized() { return false; }
isFullScreen() { return false; }
getBounds() { return { x: 0, y: 0, width: 1400, height: 900 }; }
setBackgroundColor() {}
setOpacity() {}
async loadURL() {}
close() {}
}
const api = createMainWindowApi({
mainWindow: null,
electronApp: null,
currentTheme: "light",
isQuitting: false,
pendingWindowStateWrite: null,
queuedWindowState: null,
windowStateCloseRequested: false,
DEFAULT_WINDOW_WIDTH: 1400,
DEFAULT_WINDOW_HEIGHT: 900,
MIN_WINDOW_WIDTH: 1100,
MIN_WINDOW_HEIGHT: 640,
V8_CACHE_OPTIONS: "bypassHeatCheck",
THEME_COLORS: { light: { background: "#fff" } },
unhealthyWebContentsIds: new Set(),
rendererReadySeenByWebContentsId: new Set(),
__dirname,
URL,
require,
console,
setTimeout,
clearTimeout,
getGlobalShortcutBridge() {
return { handleWindowClose: () => false };
},
debugLog() {},
resolveFrontendBackgroundColor() { return null; },
loadWindowState() { return null; },
getDevRendererBaseUrl(url) { return url; },
getWindowBoundsState() { return null; },
queueWindowStateSave() {},
saveWindowStateSync() {},
setupDeferredShow() {},
createExternalOnlyWindowOpenHandler() { return {}; },
createAppWindowOpenHandler() { return {}; },
attachOAuthLoadingOverlay() {},
registerWindowHandlers() {},
requestWindowCommandClose() {
return true;
},
shouldCloseWindowFromInput,
applyWindowOpacityToWindow() {},
closeSettingsWindow() {},
hideSettingsWindow() {},
});
await api.createWindow(
{
BrowserWindow: BrowserWindowStub,
nativeTheme: {},
app: {},
screen: {},
shell: {},
ipcMain: {},
},
{
preload: "/tmp/preload.cjs",
devServerUrl: "http://localhost:5173",
isDev: true,
appIcon: null,
isMac: false,
electronDir: __dirname,
},
);
let prevented = false;
beforeInputHandler({ preventDefault: () => { prevented = true; } }, {
type: "keyDown",
control: true,
shift: true,
key: "R",
});
assert.equal(prevented, false);
assert.deepEqual(ignoreMenuShortcutValues, [false]);
});
test("createWindow registers each main window as an independent app window", async () => {
const registered = [];
const unregistered = [];
+309
View File
@@ -93,6 +93,52 @@ function createYmodemEndSessionPacket() {
return createPacket(YMODEM.SOH, 0, Buffer.alloc(YMODEM.PACKET_SIZE_128, 0x00));
}
function sanitizeYmodemFilename(filename) {
const normalized = String(filename || "").replace(/\\/g, "/");
const baseName = path.basename(normalized).replace(/[<>:"/\\|?*\x00-\x1f]/g, "_").trim();
if (!baseName || baseName === "." || baseName === "..") {
return "ymodem-received.bin";
}
return baseName;
}
function parseYmodemFileInfoPayload(payload) {
const separatorIndex = payload.indexOf(0x00);
const rawName = (separatorIndex >= 0 ? payload.subarray(0, separatorIndex) : payload).toString("utf8");
if (!rawName) return null;
const metadata = separatorIndex >= 0
? payload.subarray(separatorIndex + 1).toString("ascii").replace(/\0.*$/u, "").trim()
: "";
const [sizeText] = metadata.split(/\s+/u);
if (!/^\d+$/u.test(sizeText || "")) {
throw new YmodemTransferError("YMODEM file header has an invalid size", "YMODEM_INVALID_SIZE");
}
const parsedSize = Number.parseInt(sizeText, 10);
return {
fileName: sanitizeYmodemFilename(rawName),
totalBytes: Number.isFinite(parsedSize) && parsedSize >= 0 ? parsedSize : 0,
};
}
async function resolveUniqueDestinationPath(destinationDir, fileName) {
const parsed = path.parse(fileName);
for (let attempt = 0; attempt < 10_000; attempt += 1) {
const candidateName = attempt === 0
? fileName
: `${parsed.name} (${attempt})${parsed.ext}`;
const candidatePath = path.join(destinationDir, candidateName);
try {
await fs.promises.access(candidatePath);
} catch (error) {
if (error?.code === "ENOENT") return candidatePath;
throw error;
}
}
throw new YmodemTransferError("Could not choose a destination file name", "YMODEM_DESTINATION_EXISTS");
}
function writeAndDrain(serialPort, buffer) {
return new Promise((resolve, reject) => {
let settled = false;
@@ -229,6 +275,268 @@ async function sendPacketWithRetry({ serialPort, reader, packet, timeoutMs, retr
throw new YmodemTransferError("YMODEM receiver rejected the packet too many times", "YMODEM_RETRY_LIMIT");
}
async function readYmodemFrame(reader, timeoutMs) {
const header = await reader.readByte(timeoutMs);
if (header === YMODEM.CAN) {
const next = await reader.readByte(1_000).catch(() => null);
if (next === YMODEM.CAN) {
throw new YmodemTransferError("YMODEM transfer cancelled by sender", "YMODEM_REMOTE_CANCELLED");
}
if (next !== null) {
reader.unreadByte?.(next);
}
return readYmodemFrame(reader, timeoutMs);
}
if (header === YMODEM.EOT) {
return { type: "eot" };
}
if (header !== YMODEM.SOH && header !== YMODEM.STX) {
throw new YmodemTransferError(`Unexpected YMODEM packet header: 0x${header.toString(16)}`);
}
const payloadSize = header === YMODEM.SOH ? YMODEM.PACKET_SIZE_128 : YMODEM.PACKET_SIZE_1024;
const blockNumber = await reader.readByte(timeoutMs);
const blockComplement = await reader.readByte(timeoutMs);
const payload = Buffer.alloc(payloadSize);
for (let i = 0; i < payloadSize; i += 1) {
payload[i] = await reader.readByte(timeoutMs);
}
const sentCrc = ((await reader.readByte(timeoutMs)) << 8) | await reader.readByte(timeoutMs);
const expectedCrc = crc16Xmodem(payload);
const valid = blockComplement === (0xff - blockNumber) && sentCrc === expectedCrc;
return {
type: "packet",
blockNumber,
payload,
valid,
};
}
async function readYmodemPacketWithRetry({
serialPort,
reader,
expectedBlockNumber,
requestByte,
timeoutMs,
retryLimit,
label,
}) {
for (let attempt = 0; attempt < retryLimit; attempt += 1) {
if (requestByte !== undefined) {
await writeAndDrain(serialPort, Buffer.from([requestByte]));
}
let frame;
try {
frame = await readYmodemFrame(reader, timeoutMs);
} catch (error) {
if (error?.code === "YMODEM_TIMEOUT" && attempt < retryLimit - 1) {
continue;
}
throw error;
}
if (frame.type === "eot") {
return frame;
}
if (frame.valid && frame.blockNumber === expectedBlockNumber) {
return frame;
}
if (frame.valid && frame.blockNumber === ((expectedBlockNumber - 1) & 0xff)) {
await writeAndDrain(serialPort, Buffer.from([YMODEM.ACK]));
continue;
}
await writeAndDrain(serialPort, Buffer.from([YMODEM.NAK]));
}
throw new YmodemTransferError(`YMODEM sender did not provide a valid ${label}`, "YMODEM_RETRY_LIMIT");
}
async function receiveYmodemFileData({
serialPort,
reader,
fileHandle,
totalBytes,
timeoutMs,
retryLimit,
onProgress,
}) {
let expectedBlockNumber = 1;
let writtenBytes = 0;
let rejectedPackets = 0;
for (;;) {
let frame;
try {
frame = await readYmodemFrame(reader, timeoutMs);
} catch (error) {
if (error?.code === "YMODEM_TIMEOUT" && rejectedPackets < retryLimit) {
rejectedPackets += 1;
await writeAndDrain(serialPort, Buffer.from([YMODEM.NAK]));
continue;
}
throw error;
}
if (frame.type === "eot") {
await writeAndDrain(serialPort, Buffer.from([YMODEM.NAK]));
const secondEot = await readYmodemFrame(reader, timeoutMs);
if (secondEot.type !== "eot") {
throw new YmodemTransferError("YMODEM sender did not confirm end of file", "YMODEM_EOT_EXPECTED");
}
await writeAndDrain(serialPort, Buffer.from([YMODEM.ACK]));
if (writtenBytes !== totalBytes) {
throw new YmodemTransferError(
`YMODEM received incomplete file (${writtenBytes}/${totalBytes} bytes)`,
"YMODEM_INCOMPLETE_FILE",
);
}
return writtenBytes;
}
if (!frame.valid) {
rejectedPackets += 1;
if (rejectedPackets > retryLimit) {
throw new YmodemTransferError("YMODEM sender sent too many invalid packets", "YMODEM_RETRY_LIMIT");
}
await writeAndDrain(serialPort, Buffer.from([YMODEM.NAK]));
continue;
}
if (frame.blockNumber === ((expectedBlockNumber - 1) & 0xff)) {
await writeAndDrain(serialPort, Buffer.from([YMODEM.ACK]));
continue;
}
if (frame.blockNumber !== expectedBlockNumber) {
rejectedPackets += 1;
if (rejectedPackets > retryLimit) {
throw new YmodemTransferError("YMODEM sender sent packets out of order", "YMODEM_RETRY_LIMIT");
}
await writeAndDrain(serialPort, Buffer.from([YMODEM.NAK]));
continue;
}
const remainingBytes = Math.max(0, totalBytes - writtenBytes);
const bytesToWrite = Math.min(frame.payload.length, remainingBytes);
if (bytesToWrite > 0) {
await fileHandle.write(frame.payload, 0, bytesToWrite);
writtenBytes += bytesToWrite;
}
rejectedPackets = 0;
expectedBlockNumber = (expectedBlockNumber + 1) & 0xff;
await writeAndDrain(serialPort, Buffer.from([YMODEM.ACK]));
onProgress?.({ transferredBytes: writtenBytes, totalBytes, stage: "data" });
}
}
async function receiveYmodemFiles(serialPort, {
destinationDir,
timeoutMs = DEFAULT_TIMEOUT_MS,
retryLimit = DEFAULT_RETRY_LIMIT,
abortSignal,
onProgress,
} = {}) {
if (!serialPort) {
throw new YmodemTransferError("Serial session is not available", "YMODEM_NO_SERIAL");
}
if (!destinationDir || typeof destinationDir !== "string") {
throw new YmodemTransferError("No destination directory selected", "YMODEM_NO_DESTINATION");
}
const resolvedDestinationDir = path.resolve(destinationDir);
let destinationStat;
try {
destinationStat = await fs.promises.stat(resolvedDestinationDir);
} catch (error) {
throw new YmodemTransferError("Selected destination is not a directory", "YMODEM_DESTINATION_NOT_DIRECTORY");
}
if (!destinationStat.isDirectory()) {
throw new YmodemTransferError("Selected destination is not a directory", "YMODEM_DESTINATION_NOT_DIRECTORY");
}
const reader = createSerialByteReader(serialPort, abortSignal);
const files = [];
try {
for (;;) {
const headerFrame = await readYmodemPacketWithRetry({
serialPort,
reader,
expectedBlockNumber: 0,
requestByte: YMODEM.CRC16,
timeoutMs,
retryLimit,
label: "file header",
});
if (headerFrame.type === "eot") {
await writeAndDrain(serialPort, Buffer.from([YMODEM.ACK]));
continue;
}
const fileInfo = parseYmodemFileInfoPayload(headerFrame.payload);
await writeAndDrain(serialPort, Buffer.from([YMODEM.ACK]));
if (!fileInfo) {
break;
}
await writeAndDrain(serialPort, Buffer.from([YMODEM.CRC16]));
onProgress?.({ transferredBytes: 0, totalBytes: fileInfo.totalBytes, stage: "header" });
const filePath = await resolveUniqueDestinationPath(resolvedDestinationDir, fileInfo.fileName);
let fileHandle;
let closeNeeded = false;
let createdFile = false;
try {
fileHandle = await fs.promises.open(filePath, "wx");
closeNeeded = true;
createdFile = true;
const writtenBytes = await receiveYmodemFileData({
serialPort,
reader,
fileHandle,
totalBytes: fileInfo.totalBytes,
timeoutMs,
retryLimit,
onProgress,
});
await fileHandle.close();
closeNeeded = false;
files.push({
fileName: path.basename(filePath),
filePath,
totalBytes: fileInfo.totalBytes,
writtenBytes,
});
} catch (error) {
if (closeNeeded) {
await fileHandle.close().catch(() => {});
}
if (createdFile) {
await fs.promises.rm(filePath, { force: true }).catch(() => {});
}
throw error;
}
}
const totalBytes = files.reduce((sum, file) => sum + file.totalBytes, 0);
const writtenBytes = files.reduce((sum, file) => sum + file.writtenBytes, 0);
return {
files,
fileCount: files.length,
totalBytes,
writtenBytes,
fileName: files[0]?.fileName,
filePath: files[0]?.filePath,
};
} finally {
reader.cleanup();
}
}
async function sendYmodemBuffer(serialPort, {
filename,
buffer,
@@ -355,6 +663,7 @@ module.exports = {
createYmodemFileInfoPacket,
createYmodemDataPackets,
createYmodemEndSessionPacket,
receiveYmodemFiles,
sendYmodemCancel,
sendYmodemBuffer,
sendYmodemFile,
+135
View File
@@ -1,12 +1,16 @@
const test = require("node:test");
const assert = require("node:assert/strict");
const { EventEmitter } = require("node:events");
const fs = require("node:fs");
const os = require("node:os");
const path = require("node:path");
const {
YMODEM,
createYmodemFileInfoPacket,
createYmodemDataPackets,
createYmodemEndSessionPacket,
receiveYmodemFiles,
sendYmodemCancel,
sendYmodemBuffer,
} = require("./ymodemTransfer.cjs");
@@ -200,6 +204,137 @@ test("sends the Tera Term style cancel sequence", async () => {
);
});
test("receives a YMODEM file into the selected directory", async () => {
const targetDir = fs.mkdtempSync(path.join(os.tmpdir(), "netcatty-ymodem-receive-"));
try {
const serial = new FakeSerialPort();
const transfer = receiveYmodemFiles(serial, {
destinationDir: targetDir,
timeoutMs: 200,
});
await waitForWrites(serial, 1);
assert.deepEqual([...serial.writes[0]], [YMODEM.CRC16]);
serial.emit("data", createYmodemFileInfoPacket({
filename: "device.log",
size: 3,
mtime: 0,
}));
await waitForWrites(serial, 3);
assert.deepEqual([...serial.writes[1]], [YMODEM.ACK]);
assert.deepEqual([...serial.writes[2]], [YMODEM.CRC16]);
serial.emit("data", createYmodemDataPackets(Buffer.from("abc"))[0]);
await waitForWrites(serial, 4);
assert.deepEqual([...serial.writes[3]], [YMODEM.ACK]);
serial.emit("data", Buffer.from([YMODEM.EOT]));
await waitForWrites(serial, 5);
assert.deepEqual([...serial.writes[4]], [YMODEM.NAK]);
serial.emit("data", Buffer.from([YMODEM.EOT]));
await waitForWrites(serial, 7);
assert.deepEqual([...serial.writes[5]], [YMODEM.ACK]);
assert.deepEqual([...serial.writes[6]], [YMODEM.CRC16]);
serial.emit("data", createYmodemEndSessionPacket());
await waitForWrites(serial, 8);
assert.deepEqual([...serial.writes[7]], [YMODEM.ACK]);
const result = await transfer;
assert.deepEqual(result, {
files: [{
fileName: "device.log",
filePath: path.join(targetDir, "device.log"),
totalBytes: 3,
writtenBytes: 3,
}],
fileCount: 1,
totalBytes: 3,
writtenBytes: 3,
fileName: "device.log",
filePath: path.join(targetDir, "device.log"),
});
assert.equal(fs.readFileSync(path.join(targetDir, "device.log"), "utf8"), "abc");
assert.equal(serial.listenerCount("data"), 0);
} finally {
fs.rmSync(targetDir, { recursive: true, force: true });
}
});
test("rejects an incomplete received file and removes the partial file", async () => {
const targetDir = fs.mkdtempSync(path.join(os.tmpdir(), "netcatty-ymodem-short-"));
try {
const serial = new FakeSerialPort();
const transfer = receiveYmodemFiles(serial, {
destinationDir: targetDir,
timeoutMs: 200,
});
const rejectedTransfer = assert.rejects(transfer, /incomplete/i);
await waitForWrites(serial, 1);
serial.emit("data", createYmodemFileInfoPacket({
filename: "short.log",
size: 1500,
mtime: 0,
}));
await waitForWrites(serial, 3);
serial.emit("data", createYmodemDataPackets(Buffer.alloc(1024, 0x61))[0]);
await waitForWrites(serial, 4);
serial.emit("data", Buffer.from([YMODEM.EOT]));
await waitForWrites(serial, 5);
serial.emit("data", Buffer.from([YMODEM.EOT]));
await waitForWrites(serial, 6);
await rejectedTransfer;
assert.equal(fs.existsSync(path.join(targetDir, "short.log")), false);
assert.equal(serial.listenerCount("data"), 0);
} finally {
fs.rmSync(targetDir, { recursive: true, force: true });
}
});
test("does not delete an existing file if creating the receive target fails", async () => {
const targetDir = fs.mkdtempSync(path.join(os.tmpdir(), "netcatty-ymodem-race-"));
const targetPath = path.join(targetDir, "race.log");
const originalOpen = fs.promises.open;
try {
fs.promises.open = async (filePath, flags, ...args) => {
if (filePath === targetPath && flags === "wx") {
fs.writeFileSync(targetPath, "existing");
const error = new Error("file exists");
error.code = "EEXIST";
throw error;
}
return originalOpen.call(fs.promises, filePath, flags, ...args);
};
const serial = new FakeSerialPort();
const transfer = receiveYmodemFiles(serial, {
destinationDir: targetDir,
timeoutMs: 200,
});
const rejectedTransfer = assert.rejects(transfer, /file exists/i);
await waitForWrites(serial, 1);
serial.emit("data", createYmodemFileInfoPacket({
filename: "race.log",
size: 3,
mtime: 0,
}));
await waitForWrites(serial, 3);
await rejectedTransfer;
assert.equal(fs.readFileSync(targetPath, "utf8"), "existing");
} finally {
fs.promises.open = originalOpen;
fs.rmSync(targetDir, { recursive: true, force: true });
}
});
function waitForWrites(serial, count) {
return new Promise((resolve, reject) => {
const startedAt = Date.now();
+11 -3
View File
@@ -277,6 +277,12 @@ function createZmodemSentry(opts) {
}
}
function takeDragDropUpload() {
const upload = dragDropUpload;
dragDropUpload = null;
return upload;
}
function scheduleRemoteInterruptAfterCancel(transferRole) {
if (cancelInterruptTimer) {
clearTimeout(cancelInterruptTimer);
@@ -372,6 +378,7 @@ function createZmodemSentry(opts) {
const transferOpts = {
...opts,
getDragDropUpload: () => dragDropUpload,
takeDragDropUpload,
clearDragDropUpload,
waitForDrain: () => {
if (!_needsDrain) return Promise.resolve();
@@ -542,8 +549,10 @@ function createZmodemSentry(opts) {
if (!Array.isArray(filePaths) || filePaths.length === 0) {
throw new Error("No files to upload");
}
if (dragDropUpload) {
throw new Error("ZMODEM drag-drop upload already pending");
}
clearDragDropUpload();
const uploadCommand = payload.uploadCommand || "rz\r";
dragDropUpload = {
filePaths,
@@ -612,7 +621,7 @@ async function handleUpload(zsession, opts) {
const { BrowserWindow, dialog } = getElectron();
const yieldToIO = () => new Promise((resolve) => setImmediate(resolve));
const dragDrop = opts.getDragDropUpload?.();
const dragDrop = opts.takeDragDropUpload?.() ?? opts.getDragDropUpload?.();
let filePaths;
let allNames;
let dragDropTempPaths = [];
@@ -623,7 +632,6 @@ async function handleUpload(zsession, opts) {
? dragDrop.remoteNames
: filePaths.map((fp) => path.basename(fp));
dragDropTempPaths = dragDrop.tempPaths || [];
opts.clearDragDropUpload?.();
} else {
const win = contents ? BrowserWindow.fromWebContents(contents) : null;
const result = await dialog.showOpenDialog(win || undefined, {
+50 -1
View File
@@ -1,6 +1,9 @@
const test = require("node:test");
const assert = require("node:assert/strict");
const { buildUploadPlan, buildModeRestores } = require("./zmodemHelper.cjs");
const fs = require("node:fs");
const os = require("node:os");
const path = require("node:path");
const { createZmodemSentry, buildUploadPlan, buildModeRestores } = require("./zmodemHelper.cjs");
const never = () => { throw new Error("resolver should not be called"); };
@@ -72,3 +75,49 @@ test("buildModeRestores strips trailing slashes and dedupes duplicate basenames"
[{ path: "/srv/x", mode: "600" }],
);
});
test("queued drag-drop upload keeps temp files until cancel", () => {
const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "netcatty-zmodem-"));
const tempPath = path.join(tempDir, "upload.txt");
fs.writeFileSync(tempPath, "payload");
const sentry = createZmodemSentry({
sessionId: "session-1",
onData: () => {},
writeToRemote: () => true,
getWebContents: () => null,
});
sentry.queueDragDropUpload({
filePaths: [tempPath],
remoteNames: ["upload.txt"],
tempPaths: [tempPath],
});
assert.equal(fs.existsSync(tempPath), true);
sentry.cancel();
assert.equal(fs.existsSync(tempPath), false);
fs.rmSync(tempDir, { recursive: true, force: true });
});
test("queued drag-drop upload rejects a second pending upload", () => {
const sentry = createZmodemSentry({
sessionId: "session-1",
onData: () => {},
writeToRemote: () => true,
getWebContents: () => null,
});
sentry.queueDragDropUpload({
filePaths: ["/tmp/first.txt"],
remoteNames: ["first.txt"],
});
assert.throws(
() => sentry.queueDragDropUpload({
filePaths: ["/tmp/second.txt"],
remoteNames: ["second.txt"],
}),
/already pending/,
);
});
+12 -1
View File
@@ -172,9 +172,20 @@ const devServerUrl = process.env.VITE_DEV_SERVER_URL;
// Never treat a packaged app as "dev" even if the user has VITE_DEV_SERVER_URL set globally.
const isDev = !app.isPackaged && !!devServerUrl;
const effectiveDevServerUrl = isDev ? devServerUrl : undefined;
if (isDev) {
app.setName("Netcatty Dev");
app.setPath("userData", path.join(app.getPath("userData"), "dev"));
}
const preload = path.join(__dirname, "preload.cjs");
const isMac = process.platform === "darwin";
const appIcon = path.join(__dirname, "../public/icon.png");
function resolveAppIconPath() {
const candidates = [
path.join(__dirname, "../dist/icon.png"),
path.join(__dirname, "../public/icon.png"),
];
return candidates.find((candidate) => fs.existsSync(candidate)) || candidates[0];
}
const appIcon = resolveAppIconPath();
const electronDir = __dirname;
const APP_PROTOCOL_HEADERS = {
+13 -2
View File
@@ -4,6 +4,16 @@ let bridgesRegistered = false;
let cloudSyncSessionPassword = null;
const { readClipboardFiles, readClipboardImage } = require("../bridges/clipboardFiles.cjs");
const excludedFigSpecPrefixes = ["aws", "gcloud", "az"];
function isExcludedFigSpec(commandName) {
return excludedFigSpecPrefixes.some((prefix) => commandName === prefix || commandName.startsWith(`${prefix}/`));
}
function filterExcludedFigSpecs(specNames) {
return specNames.filter((name) => !isExcludedFigSpec(name));
}
function createBridgeRegistrar(context) {
const {
electronModule,
@@ -262,7 +272,7 @@ function createBridgeRegistrar(context) {
.filter(f => f.endsWith(".js"))
.map(f => f.slice(0, -3));
} catch { /* no local specs dir */ }
const merged = [...new Set([...figSpecs, ...localNames])];
const merged = filterExcludedFigSpecs([...new Set([...figSpecs, ...localNames])]);
return merged;
} catch (err) {
console.warn("[Main] Failed to load fig spec list:", err?.message || err);
@@ -274,6 +284,7 @@ function createBridgeRegistrar(context) {
// Sanitize: reject absolute paths, path traversal, and non-spec characters
if (!commandName || commandName.startsWith("/") || commandName.startsWith("\\") ||
commandName.includes("..") || !/^[@a-zA-Z0-9._/+-]+$/.test(commandName)) return null;
if (isExcludedFigSpec(commandName)) return null;
const { pathToFileURL } = require("url");
const fs = require("fs");
@@ -858,4 +869,4 @@ function createBridgeRegistrar(context) {
return registerBridges;
}
module.exports = { createBridgeRegistrar };
module.exports = { createBridgeRegistrar, filterExcludedFigSpecs, isExcludedFigSpec };
+3
View File
@@ -45,6 +45,9 @@ function createPreloadApi(ctx) {
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");
},