mirror of
https://github.com/binaricat/Netcatty.git
synced 2026-11-20 07:04:53 +00:00
Merge main into terminal drag-drop zmodem
This commit is contained in:
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"],
|
||||
);
|
||||
});
|
||||
@@ -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");
|
||||
});
|
||||
@@ -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 });
|
||||
}
|
||||
});
|
||||
@@ -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 = [];
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -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, {
|
||||
|
||||
@@ -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
@@ -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 = {
|
||||
|
||||
@@ -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 };
|
||||
@@ -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");
|
||||
},
|
||||
|
||||
Reference in new issue
Block a user