[Init] Initial commit - NetMesh terminal manager

electron/bridges/terminalBridge.inputEncoding.test.cjs

@@ -0,0 +1,274 @@
+const test = require("node:test");
+const assert = require("node:assert/strict");
+const net = require("node:net");
+const iconv = require("iconv-lite");
+
+const terminalBridge = require("./terminalBridge.cjs");
+
+function listen(server) {
+  return new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      server.off("error", reject);
+      resolve(server.address().port);
+    });
+  });
+}
+
+function waitFor(predicate, timeoutMs = 1000) {
+  const startedAt = Date.now();
+  return new Promise((resolve, reject) => {
+    const tick = () => {
+      if (predicate()) {
+        resolve();
+        return;
+      }
+      if (Date.now() - startedAt > timeoutMs) {
+        reject(new Error("Timed out waiting for telnet input bytes"));
+        return;
+      }
+      setTimeout(tick, 10);
+    };
+    tick();
+  });
+}
+
+// These tests drive the real terminalBridge.writeToSession path over a raw TCP
+// "device" that never speaks the Telnet protocol (no IAC bytes), so the bytes
+// captured server-side are exactly what the input path serialized — proving
+// the keystroke encoding without IAC-escaping noise. They guard issue #1216:
+// input must use the SAME charset the output decoder uses.
+
+function initBridge(sessions) {
+  terminalBridge.init({
+    sessions,
+    electronModule: {
+      webContents: {
+        fromId: () => ({ send() {} }),
+      },
+    },
+  });
+}
+
+test("Telnet input is encoded with the session's GB18030 charset", async () => {
+  const chunks = [];
+  const sockets = new Set();
+  let serverSocket = null;
+  const server = net.createServer((socket) => {
+    serverSocket = socket;
+    sockets.add(socket);
+    socket.on("error", () => {});
+    socket.on("close", () => sockets.delete(socket));
+    socket.on("data", (buf) => chunks.push(buf));
+  });
+
+  const port = await listen(server);
+  const sessions = new Map();
+  initBridge(sessions);
+
+  try {
+    await terminalBridge.startTelnetSession(
+      { sender: { id: 1 } },
+      {
+        sessionId: "telnet-gb18030-input",
+        hostname: "127.0.0.1",
+        port,
+        // No saved credentials → auto-login stays idle and does not inject bytes.
+        charset: "GB18030",
+      },
+    );
+    await waitFor(() => serverSocket);
+
+    terminalBridge.writeToSession(
+      {},
+      { sessionId: "telnet-gb18030-input", data: "你好\r" },
+    );
+
+    await waitFor(() => Buffer.concat(chunks).length >= 6);
+    const received = Buffer.concat(chunks);
+    assert.deepEqual([...received], [...iconv.encode("你好\r\n", "gb18030")]);
+    // It must NOT be the UTF-8 serialization that the old code always sent.
+    assert.notDeepEqual([...received], [...Buffer.from("你好\r", "utf8")]);
+  } finally {
+    terminalBridge.cleanupAllSessions();
+    for (const socket of sockets) socket.destroy();
+    await new Promise((resolve) => server.close(resolve));
+  }
+});
+
+test("Telnet input stays UTF-8 when no charset is configured", async () => {
+  const chunks = [];
+  const sockets = new Set();
+  let serverSocket = null;
+  const server = net.createServer((socket) => {
+    serverSocket = socket;
+    sockets.add(socket);
+    socket.on("error", () => {});
+    socket.on("close", () => sockets.delete(socket));
+    socket.on("data", (buf) => chunks.push(buf));
+  });
+
+  const port = await listen(server);
+  const sessions = new Map();
+  initBridge(sessions);
+
+  try {
+    await terminalBridge.startTelnetSession(
+      { sender: { id: 1 } },
+      {
+        sessionId: "telnet-utf8-input",
+        hostname: "127.0.0.1",
+        port,
+      },
+    );
+    await waitFor(() => serverSocket);
+
+    terminalBridge.writeToSession(
+      {},
+      { sessionId: "telnet-utf8-input", data: "你好\r" },
+    );
+
+    await waitFor(() => Buffer.concat(chunks).length >= 8);
+    const received = Buffer.concat(chunks);
+    assert.deepEqual([...received], [...Buffer.from("你好\r\n", "utf8")]);
+  } finally {
+    terminalBridge.cleanupAllSessions();
+    for (const socket of sockets) socket.destroy();
+    await new Promise((resolve) => server.close(resolve));
+  }
+});
+
+test("Telnet Enter is sent as CRLF so RT-Thread shells submit the command", async () => {
+  const chunks = [];
+  const sockets = new Set();
+  let serverSocket = null;
+  const server = net.createServer((socket) => {
+    serverSocket = socket;
+    sockets.add(socket);
+    socket.on("error", () => {});
+    socket.on("close", () => sockets.delete(socket));
+    socket.on("data", (buf) => chunks.push(buf));
+  });
+
+  const port = await listen(server);
+  const sessions = new Map();
+  initBridge(sessions);
+
+  try {
+    await terminalBridge.startTelnetSession(
+      { sender: { id: 1 } },
+      {
+        sessionId: "telnet-rtthread-enter",
+        hostname: "127.0.0.1",
+        port,
+      },
+    );
+    await waitFor(() => serverSocket);
+
+    terminalBridge.writeToSession(
+      {},
+      { sessionId: "telnet-rtthread-enter", data: "ps\r" },
+    );
+
+    await waitFor(() => Buffer.concat(chunks).length >= 3);
+    const received = Buffer.concat(chunks);
+    assert.deepEqual([...received], [...Buffer.from("ps\r\n", "utf8")]);
+  } finally {
+    terminalBridge.cleanupAllSessions();
+    for (const socket of sockets) socket.destroy();
+    await new Promise((resolve) => server.close(resolve));
+  }
+});
+
+test("Telnet input preserves existing CRLF and CR NUL while normalizing bare LF", async () => {
+  const chunks = [];
+  const sockets = new Set();
+  let serverSocket = null;
+  const server = net.createServer((socket) => {
+    serverSocket = socket;
+    sockets.add(socket);
+    socket.on("error", () => {});
+    socket.on("close", () => sockets.delete(socket));
+    socket.on("data", (buf) => chunks.push(buf));
+  });
+
+  const port = await listen(server);
+  const sessions = new Map();
+  initBridge(sessions);
+
+  try {
+    await terminalBridge.startTelnetSession(
+      { sender: { id: 1 } },
+      {
+        sessionId: "telnet-rfc-newlines",
+        hostname: "127.0.0.1",
+        port,
+      },
+    );
+    await waitFor(() => serverSocket);
+
+    terminalBridge.writeToSession(
+      {},
+      { sessionId: "telnet-rfc-newlines", data: "one\r\ntwo\nthree\r\0" },
+    );
+
+    await waitFor(() => Buffer.concat(chunks).length >= 17);
+    const received = Buffer.concat(chunks);
+    assert.deepEqual([...received], [...Buffer.from("one\r\ntwo\r\nthree\r\0", "utf8")]);
+  } finally {
+    terminalBridge.cleanupAllSessions();
+    for (const socket of sockets) socket.destroy();
+    await new Promise((resolve) => server.close(resolve));
+  }
+});
+
+test("setSessionEncoding switches the Telnet input charset at runtime", async () => {
+  const chunks = [];
+  const sockets = new Set();
+  let serverSocket = null;
+  const server = net.createServer((socket) => {
+    serverSocket = socket;
+    sockets.add(socket);
+    socket.on("error", () => {});
+    socket.on("close", () => sockets.delete(socket));
+    socket.on("data", (buf) => chunks.push(buf));
+  });
+
+  const port = await listen(server);
+  const sessions = new Map();
+  initBridge(sessions);
+
+  try {
+    await terminalBridge.startTelnetSession(
+      { sender: { id: 1 } },
+      {
+        sessionId: "telnet-switch-input",
+        hostname: "127.0.0.1",
+        port,
+      },
+    );
+    await waitFor(() => serverSocket);
+
+    const switchResult = terminalBridge.setSessionEncoding(
+      {},
+      { sessionId: "telnet-switch-input", encoding: "gbk" },
+    );
+    // "gbk" normalizes onto the gb18030 superset and is mirrored to
+    // session.encoding so the input path picks it up immediately.
+    assert.deepEqual(switchResult, { ok: true, encoding: "gb18030" });
+    assert.equal(sessions.get("telnet-switch-input").encoding, "gb18030");
+
+    terminalBridge.writeToSession(
+      {},
+      { sessionId: "telnet-switch-input", data: "测试\r" },
+    );
+
+    await waitFor(() => Buffer.concat(chunks).length >= 6);
+    const received = Buffer.concat(chunks);
+    assert.deepEqual([...received], [...iconv.encode("测试\r\n", "gb18030")]);
+  } finally {
+    terminalBridge.cleanupAllSessions();
+    for (const socket of sockets) socket.destroy();
+    await new Promise((resolve) => server.close(resolve));
+  }
+});