[Init] Initial commit - NetMesh terminal manager

scripts/build-windows-hello-helper.test.cjs

@@ -0,0 +1,154 @@
+const test = require("node:test");
+const assert = require("node:assert/strict");
+const path = require("node:path");
+
+const {
+  buildWindowsHelloHelper,
+  getExpectedPeMachine,
+  normalizeWindowsHelperArch,
+  readPeMachine,
+} = require("./build-windows-hello-helper.cjs");
+
+test("normalizeWindowsHelperArch accepts only packaged Windows architectures", () => {
+  assert.equal(normalizeWindowsHelperArch("x64"), "x64");
+  assert.equal(normalizeWindowsHelperArch("arm64"), "arm64");
+  assert.equal(normalizeWindowsHelperArch(1), "x64");
+  assert.equal(normalizeWindowsHelperArch(3), "arm64");
+  assert.equal(normalizeWindowsHelperArch("ia32"), null);
+  assert.equal(normalizeWindowsHelperArch(""), null);
+});
+
+test("getExpectedPeMachine maps target helper architectures", () => {
+  assert.equal(getExpectedPeMachine("x64"), 0x8664);
+  assert.equal(getExpectedPeMachine("arm64"), 0xaa64);
+  assert.equal(getExpectedPeMachine("ia32"), null);
+});
+
+test("buildWindowsHelloHelper writes target architecture helper into an arch-specific directory", () => {
+  const calls = [];
+  const result = buildWindowsHelloHelper({
+    projectDir: "/repo",
+    platform: "win32",
+    arch: "arm64",
+    env: {},
+    run: (...args) => calls.push(args),
+    mkdir: () => {},
+    readMachine: () => 0xaa64,
+    logger: { warn() {} },
+  });
+
+  assert.equal(result.skipped, false);
+  assert.equal(
+    result.outputPath,
+    path.win32.join("\\repo", "electron", "bridges", "windowsHelloHelper", "build", "arm64", "NetcattyWindowsHello.exe"),
+  );
+  assert.match(
+    calls[0][1].join(" "),
+    /\/Fe:.*windowsHelloHelper.*build.*arm64.*NetcattyWindowsHello\.exe/,
+  );
+  assert.ok(
+    calls[0][1].includes("/D_SILENCE_EXPERIMENTAL_COROUTINE_DEPRECATION_WARNINGS"),
+    "Windows Hello helper compile must tolerate older C++/WinRT headers on newer MSVC",
+  );
+  assert.deepEqual(calls[0][1].slice(-4), ["/link", "/MACHINE:ARM64", "runtimeobject.lib", "windowsapp.lib"]);
+});
+
+test("buildWindowsHelloHelper initializes the Visual Studio developer environment when cl is not already on PATH", () => {
+  const calls = [];
+  const writes = [];
+  const removals = [];
+  const vsDevCmd = "C:\\Program Files\\Microsoft Visual Studio\\2026\\Enterprise\\Common7\\Tools\\VsDevCmd.bat";
+  const result = buildWindowsHelloHelper({
+    projectDir: "D:\\a\\Netcatty\\Netcatty",
+    platform: "win32",
+    arch: "x64",
+    env: {
+      ProgramFiles: "C:\\Program Files",
+      "ProgramFiles(x86)": "C:\\Program Files (x86)",
+    },
+    existsSync: (candidate) => candidate === vsDevCmd,
+    run: (...args) => calls.push(args),
+    writeFile: (...args) => writes.push(args),
+    rm: (...args) => removals.push(args),
+    tmpdir: () => "D:\\a\\_temp",
+    mkdir: () => {},
+    readMachine: () => 0x8664,
+    logger: { warn() {} },
+  });
+
+  assert.equal(result.skipped, false);
+  assert.equal(calls[0][0], "cmd.exe");
+  assert.deepEqual(calls[0][1].slice(0, 3), ["/d", "/c", writes[0][0]]);
+  assert.match(writes[0][0], /build-netcatty-windows-hello-x64\.cmd$/);
+  assert.match(writes[0][1], /call "C:\\Program Files\\Microsoft Visual Studio\\2026\\Enterprise\\Common7\\Tools\\VsDevCmd\.bat"/);
+  assert.match(writes[0][1], /-arch=x64/);
+  assert.match(writes[0][1], /cl\.exe/);
+  assert.match(writes[0][1], /\/MACHINE:X64/);
+  assert.deepEqual(removals[0], [writes[0][0], { force: true }]);
+});
+
+test("buildWindowsHelloHelper uses the current MSVC environment when it is already initialized", () => {
+  const calls = [];
+  const vsDevCmd = "C:\\Program Files\\Microsoft Visual Studio\\18\\Enterprise\\Common7\\Tools\\VsDevCmd.bat";
+  const result = buildWindowsHelloHelper({
+    projectDir: "D:\\a\\Netcatty\\Netcatty",
+    platform: "win32",
+    arch: "x64",
+    env: {
+      VSINSTALLDIR: "C:\\Program Files\\Microsoft Visual Studio\\18\\Enterprise\\",
+      VSCMD_ARG_TGT_ARCH: "x64",
+      VSCMD_VER: "18.0.0",
+    },
+    existsSync: (candidate) => candidate === vsDevCmd,
+    run: (...args) => calls.push(args),
+    mkdir: () => {},
+    readMachine: () => 0x8664,
+    logger: { warn() {} },
+  });
+
+  assert.equal(result.skipped, false);
+  assert.equal(calls[0][0], "cl.exe");
+  assert.match(calls[0][1].join(" "), /\/MACHINE:X64/);
+});
+
+test("buildWindowsHelloHelper rejects unsupported target architectures on Windows", () => {
+  const result = buildWindowsHelloHelper({
+    projectDir: "/repo",
+    platform: "win32",
+    arch: "ia32",
+    mkdir: () => {
+      throw new Error("should not create output dir");
+    },
+    run: () => {
+      throw new Error("should not run compiler");
+    },
+    logger: { warn() {} },
+  });
+
+  assert.deepEqual(result, { skipped: true, reason: "unsupported-arch" });
+});
+
+test("buildWindowsHelloHelper rejects a built helper with the wrong PE machine", () => {
+  const result = buildWindowsHelloHelper({
+    projectDir: "/repo",
+    platform: "win32",
+    arch: "arm64",
+    mkdir: () => {},
+    run: () => {},
+    readMachine: () => 0x8664,
+    logger: { warn() {} },
+  });
+
+  assert.deepEqual(result, { skipped: true, reason: "wrong-arch" });
+});
+
+test("readPeMachine reads the PE COFF machine value", () => {
+  const buffer = Buffer.alloc(0x90);
+  buffer.write("MZ", 0, "ascii");
+  buffer.writeUInt32LE(0x80, 0x3c);
+  buffer.write("PE\0\0", 0x80, "ascii");
+  buffer.writeUInt16LE(0xaa64, 0x84);
+
+  assert.equal(readPeMachine(buffer), 0xaa64);
+  assert.equal(readPeMachine(Buffer.from("not-pe")), null);
+});