[Init] Initial commit - NetMesh terminal manager

scripts/afterPackMacUuid.test.cjs

@@ -0,0 +1,340 @@
+const test = require("node:test");
+const assert = require("node:assert/strict");
+
+const {
+  adHocSignAppBundle,
+  deriveUuid,
+  patchMachOBuffer,
+  pruneAsarHeaderEntries,
+  pruneCursorSdkPlatformPackages,
+  readAsarHeader,
+} = require("./afterPackMacUuid.cjs");
+
+const LC_UUID = 0x1b;
+const LC_OTHER = 0x19;
+const MH_MAGIC_64 = 0xfeedfacf;
+
+function align4(value) {
+  return value + ((4 - (value % 4)) % 4);
+}
+
+function writeFakeAsar(asarPath, header, payload = Buffer.from("packed-payload")) {
+  const headerString = JSON.stringify(header);
+  const headerStringLength = Buffer.byteLength(headerString);
+  const headerPayloadSize = 4 + align4(headerStringLength);
+  const headerSize = 4 + headerPayloadSize;
+  const sizeBuf = Buffer.alloc(8);
+  const headerBuf = Buffer.alloc(headerSize);
+
+  sizeBuf.writeUInt32LE(4, 0);
+  sizeBuf.writeUInt32LE(headerSize, 4);
+  headerBuf.writeUInt32LE(headerPayloadSize, 0);
+  headerBuf.writeInt32LE(headerStringLength, 4);
+  headerBuf.write(headerString, 8, headerStringLength, "utf8");
+
+  require("node:fs").writeFileSync(asarPath, Buffer.concat([sizeBuf, headerBuf, payload]));
+  return headerSize;
+}
+
+// Build a minimal thin little-endian 64-bit Mach-O with two load commands:
+// one dummy command and one LC_UUID carrying `uuidBytes`.
+function buildThinMachO(uuidBytes) {
+  const header = Buffer.alloc(32);
+  header.writeUInt32LE(MH_MAGIC_64, 0); // magic
+  header.writeUInt32LE(0x0100000c, 4); // cputype arm64 (value irrelevant)
+  header.writeUInt32LE(0, 8); // cpusubtype
+  header.writeUInt32LE(2, 12); // filetype
+  header.writeUInt32LE(2, 16); // ncmds
+  header.writeUInt32LE(16 + 24, 20); // sizeofcmds
+  header.writeUInt32LE(0, 24); // flags
+  header.writeUInt32LE(0, 28); // reserved
+
+  const dummy = Buffer.alloc(16);
+  dummy.writeUInt32LE(LC_OTHER, 0); // cmd
+  dummy.writeUInt32LE(16, 4); // cmdsize
+  dummy.fill(0xab, 8); // payload sentinel
+
+  const uuidCmd = Buffer.alloc(24);
+  uuidCmd.writeUInt32LE(LC_UUID, 0); // cmd
+  uuidCmd.writeUInt32LE(24, 4); // cmdsize
+  uuidBytes.copy(uuidCmd, 8);
+
+  return Buffer.concat([header, dummy, uuidCmd]);
+}
+
+// Wrap one or more thin slices in a big-endian 32-bit fat binary.
+function buildFatMachO(slices) {
+  const headerSize = 8 + slices.length * 20;
+  const header = Buffer.alloc(headerSize);
+  header.writeUInt32BE(0xcafebabe, 0); // FAT_MAGIC
+  header.writeUInt32BE(slices.length, 4);
+
+  let offset = headerSize;
+  const offsets = [];
+  for (let i = 0; i < slices.length; i += 1) {
+    const archOff = 8 + i * 20;
+    header.writeUInt32BE(0x0100000c, archOff); // cputype
+    header.writeUInt32BE(0, archOff + 4); // cpusubtype
+    header.writeUInt32BE(offset, archOff + 8); // offset
+    header.writeUInt32BE(slices[i].length, archOff + 12); // size
+    header.writeUInt32BE(0, archOff + 16); // align
+    offsets.push(offset);
+    offset += slices[i].length;
+  }
+
+  return Buffer.concat([header, ...slices]);
+}
+
+test("deriveUuid is deterministic and 16 bytes", () => {
+  const a = deriveUuid("com.netcatty.app");
+  const b = deriveUuid("com.netcatty.app");
+  assert.equal(a.length, 16);
+  assert.ok(a.equals(b));
+});
+
+test("deriveUuid differs per appId and sets version/variant bits", () => {
+  const a = deriveUuid("com.netcatty.app");
+  const b = deriveUuid("com.example.other");
+  assert.ok(!a.equals(b));
+  assert.equal(a[6] & 0xf0, 0x50); // version 5
+  assert.equal(a[8] & 0xc0, 0x80); // RFC 4122 variant
+});
+
+test("patchMachOBuffer rewrites LC_UUID in a thin Mach-O and leaves the rest intact", () => {
+  const original = Buffer.alloc(16, 0x11);
+  const buf = buildThinMachO(original);
+  const uuid = deriveUuid("com.netcatty.app");
+
+  const { patched, oldUuids } = patchMachOBuffer(buf, uuid);
+
+  assert.equal(patched, 1);
+  assert.equal(oldUuids[0], original.toString("hex"));
+  // LC_UUID payload is now our derived uuid (uuid command starts at byte 48).
+  assert.ok(buf.subarray(48 + 8, 48 + 24).equals(uuid));
+  // Header magic + the dummy command's payload are untouched.
+  assert.equal(buf.readUInt32LE(0), MH_MAGIC_64);
+  assert.equal(buf.readUInt32LE(32), LC_OTHER);
+  assert.ok(buf.subarray(32 + 8, 32 + 16).equals(Buffer.alloc(8, 0xab)));
+});
+
+test("patchMachOBuffer patches every slice of a fat binary", () => {
+  const slice1 = buildThinMachO(Buffer.alloc(16, 0x22));
+  const slice2 = buildThinMachO(Buffer.alloc(16, 0x33));
+  const fat = buildFatMachO([slice1, slice2]);
+  const uuid = deriveUuid("com.netcatty.app");
+
+  const { patched } = patchMachOBuffer(fat, uuid);
+
+  assert.equal(patched, 2);
+});
+
+test("patchMachOBuffer reports zero when there is no LC_UUID", () => {
+  // A thin Mach-O whose single command is not LC_UUID.
+  const header = Buffer.alloc(32);
+  header.writeUInt32LE(MH_MAGIC_64, 0);
+  header.writeUInt32LE(1, 16); // ncmds
+  const cmd = Buffer.alloc(16);
+  cmd.writeUInt32LE(LC_OTHER, 0);
+  cmd.writeUInt32LE(16, 4);
+  const buf = Buffer.concat([header, cmd]);
+
+  const { patched } = patchMachOBuffer(buf, deriveUuid("com.netcatty.app"));
+  assert.equal(patched, 0);
+});
+
+test("adHocSignAppBundle signs the full app bundle on macOS hosts", () => {
+  const calls = [];
+
+  const didSign = adHocSignAppBundle("/tmp/Netcatty.app", {
+    hostPlatform: "darwin",
+    execFileSync: (bin, args, options) => {
+      calls.push({ bin, args, options });
+    },
+  });
+
+  assert.equal(didSign, true);
+  assert.deepEqual(calls, [
+    {
+      bin: "codesign",
+      args: [
+        "--force",
+        "--deep",
+        "--sign",
+        "-",
+        "--timestamp=none",
+        "/tmp/Netcatty.app",
+      ],
+      options: { stdio: ["ignore", "pipe", "pipe"] },
+    },
+  ]);
+});
+
+test("adHocSignAppBundle skips non-macOS hosts", () => {
+  let called = false;
+
+  const didSign = adHocSignAppBundle("/tmp/Netcatty.app", {
+    hostPlatform: "linux",
+    execFileSync: () => {
+      called = true;
+    },
+  });
+
+  assert.equal(didSign, false);
+  assert.equal(called, false);
+});
+
+test("pruneAsarHeaderEntries removes package records without moving packed payload", (t) => {
+  const fs = require("node:fs");
+  const os = require("node:os");
+  const path = require("node:path");
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "netcatty-prune-asar-"));
+  t.after(() => fs.rmSync(tempDir, { recursive: true, force: true }));
+
+  const asarPath = path.join(tempDir, "app.asar");
+  const payload = Buffer.from("packed-payload");
+  const headerSize = writeFakeAsar(
+    asarPath,
+    {
+      files: {
+        node_modules: {
+          files: {
+            "@cursor": {
+              files: {
+                "sdk-darwin-arm64": {
+                  files: {
+                    "package.json": { size: 2, unpacked: true },
+                  },
+                },
+                "sdk-darwin-x64": {
+                  files: {
+                    "package.json": { size: 2, unpacked: true },
+                  },
+                },
+              },
+            },
+          },
+        },
+        "packed.txt": { size: payload.length, offset: "0" },
+      },
+    },
+    payload,
+  );
+
+  const removed = pruneAsarHeaderEntries(asarPath, ["node_modules/@cursor/sdk-darwin-x64"]);
+  const { header, headerSize: updatedHeaderSize } = readAsarHeader(asarPath);
+  const packedPayload = fs.readFileSync(asarPath).subarray(8 + headerSize);
+
+  assert.deepEqual(removed, ["node_modules/@cursor/sdk-darwin-x64"]);
+  assert.equal(updatedHeaderSize, headerSize);
+  assert.ok(header.files.node_modules.files["@cursor"].files["sdk-darwin-arm64"]);
+  assert.equal(header.files.node_modules.files["@cursor"].files["sdk-darwin-x64"], undefined);
+  assert.equal(packedPayload.toString("utf8"), payload.toString("utf8"));
+});
+
+test("pruneCursorSdkPlatformPackages keeps only the target macOS arch package", (t) => {
+  const fs = require("node:fs");
+  const os = require("node:os");
+  const path = require("node:path");
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "netcatty-prune-cursor-"));
+  t.after(() => fs.rmSync(tempDir, { recursive: true, force: true }));
+  const cursorRoot = path.join(
+    tempDir,
+    "Netcatty.app",
+    "Contents",
+    "Resources",
+    "app.asar.unpacked",
+    "node_modules",
+    "@cursor",
+  );
+  fs.mkdirSync(path.join(cursorRoot, "sdk-darwin-arm64"), { recursive: true });
+  fs.mkdirSync(path.join(cursorRoot, "sdk-darwin-x64"), { recursive: true });
+  writeFakeAsar(path.join(tempDir, "Netcatty.app", "Contents", "Resources", "app.asar"), {
+    files: {
+      node_modules: {
+        files: {
+          "@cursor": {
+            files: {
+              "sdk-darwin-arm64": { files: { "package.json": { size: 2, unpacked: true } } },
+              "sdk-darwin-x64": { files: { "package.json": { size: 2, unpacked: true } } },
+            },
+          },
+        },
+      },
+    },
+  });
+
+  const removed = pruneCursorSdkPlatformPackages({
+    electronPlatformName: "darwin",
+    arch: 3,
+    appOutDir: tempDir,
+    packager: { appInfo: { productFilename: "Netcatty" } },
+  });
+
+  assert.deepEqual(removed, ["sdk-darwin-x64"]);
+  assert.ok(fs.existsSync(path.join(cursorRoot, "sdk-darwin-arm64")));
+  assert.ok(!fs.existsSync(path.join(cursorRoot, "sdk-darwin-x64")));
+
+  const { header } = readAsarHeader(
+    path.join(tempDir, "Netcatty.app", "Contents", "Resources", "app.asar"),
+  );
+  assert.ok(header.files.node_modules.files["@cursor"].files["sdk-darwin-arm64"]);
+  assert.equal(header.files.node_modules.files["@cursor"].files["sdk-darwin-x64"], undefined);
+});
+
+test("pruneCursorSdkPlatformPackages keeps both macOS packages for universal builds", (t) => {
+  const fs = require("node:fs");
+  const os = require("node:os");
+  const path = require("node:path");
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "netcatty-prune-cursor-"));
+  t.after(() => fs.rmSync(tempDir, { recursive: true, force: true }));
+  const cursorRoot = path.join(
+    tempDir,
+    "Netcatty.app",
+    "Contents",
+    "Resources",
+    "app.asar.unpacked",
+    "node_modules",
+    "@cursor",
+  );
+  fs.mkdirSync(path.join(cursorRoot, "sdk-darwin-arm64"), { recursive: true });
+  fs.mkdirSync(path.join(cursorRoot, "sdk-darwin-x64"), { recursive: true });
+
+  const removed = pruneCursorSdkPlatformPackages({
+    electronPlatformName: "darwin",
+    arch: 4,
+    appOutDir: tempDir,
+    packager: { appInfo: { productFilename: "Netcatty" } },
+  });
+
+  assert.deepEqual(removed, []);
+  assert.ok(fs.existsSync(path.join(cursorRoot, "sdk-darwin-arm64")));
+  assert.ok(fs.existsSync(path.join(cursorRoot, "sdk-darwin-x64")));
+});
+
+test("pruneCursorSdkPlatformPackages keeps only the target Linux arch package", (t) => {
+  const fs = require("node:fs");
+  const os = require("node:os");
+  const path = require("node:path");
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "netcatty-prune-cursor-"));
+  t.after(() => fs.rmSync(tempDir, { recursive: true, force: true }));
+  const cursorRoot = path.join(
+    tempDir,
+    "resources",
+    "app.asar.unpacked",
+    "node_modules",
+    "@cursor",
+  );
+  fs.mkdirSync(path.join(cursorRoot, "sdk-linux-arm64"), { recursive: true });
+  fs.mkdirSync(path.join(cursorRoot, "sdk-linux-x64"), { recursive: true });
+
+  const removed = pruneCursorSdkPlatformPackages({
+    electronPlatformName: "linux",
+    arch: 1,
+    appOutDir: tempDir,
+    packager: { appInfo: { productFilename: "netcatty" } },
+  });
+
+  assert.deepEqual(removed, ["sdk-linux-arm64"]);
+  assert.ok(!fs.existsSync(path.join(cursorRoot, "sdk-linux-arm64")));
+  assert.ok(fs.existsSync(path.join(cursorRoot, "sdk-linux-x64")));
+});