341 lines
11 KiB
JavaScript
341 lines
11 KiB
JavaScript
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")));
|
|
});
|