Open source Loom alternative. Beautiful, shareable screen recordings.
Rust appcapcossloommacnextjsnextjs15open-sourceossreactrecordrustscreen-capturescreen-recorderscreenshotsolidjstauritauri-apptypescriptvite
import assert from "node:assert/strict";
import { spawnSync } from "node:child_process";
import {
mkdir,
mkdtemp,
readdir,
readFile,
rm,
stat,
writeFile,
} from "node:fs/promises";
import { tmpdir } from "node:os";
import path from "node:path";
import { test } from "node:test";
import { runCommand } from "./finalize-linux-appimage.mjs";
import {
convertDiskImage,
finalizeMacosPackages,
recompressUpdaterArchive,
} from "./finalize-macos-packages.mjs";
const available = (command) =>
spawnSync("sh", ["-c", `command -v ${command}`]).status === 0;
const zopfli = available("pigz") && available("shasum");
async function workspace(t) {
const root = await mkdtemp(path.join(tmpdir(), "cap-macos-packages-"));
t.after(() => rm(root, { recursive: true, force: true }));
return root;
}
async function updaterArchive(root) {
const app = path.join(root, "app/Cap.app/Contents/MacOS");
await mkdir(app, { recursive: true });
const line = "Cap records your screen, camera and microphone.\n";
await writeFile(path.join(app, "Cap"), line.repeat(20_000), { mode: 0o755 });
const archive = path.join(root, "Cap.app.tar.gz");
runCommand("bash", [
"-c",
'tar -C "$1" -cf - Cap.app | gzip -1 > "$2"',
"bash",
path.join(root, "app"),
archive,
]);
await writeFile(`${archive}.sig`, "original signature");
return archive;
}
const tarBytes = (archive) =>
spawnSync("bash", ["-c", 'gzip -dc "$1"', "bash", archive]).stdout;
test(
"the updater archive is recompressed with identical contents and signed again",
{ skip: !zopfli },
async (t) => {
const root = await workspace(t);
const archive = await updaterArchive(root);
const original = tarBytes(archive);
const before = (await stat(archive)).size;
const signed = [];
const result = await recompressUpdaterArchive(archive, {
env: { ...process.env, TAURI_SIGNING_PRIVATE_KEY: "key" },
run: async (command, args, options) => {
if (command !== "bun") return runCommand(command, args, options);
assert.deepEqual(args.slice(0, 4), ["run", "tauri", "signer", "sign"]);
signed.push(await readFile(args[4]));
await writeFile(`${args[4]}.sig`, "zopfli signature");
return {};
},
});
assert.ok(result.after < before, `${result.after} >= ${before}`);
assert.equal((await stat(archive)).size, result.after);
assert.deepEqual(tarBytes(archive), original);
assert.deepEqual(signed, [await readFile(archive)]);
assert.equal(await readFile(`${archive}.sig`, "utf8"), "zopfli signature");
},
);
test("an updater archive whose contents change is left untouched", async (t) => {
const root = await workspace(t);
const archive = path.join(root, "Cap.app.tar.gz");
await writeFile(archive, "original");
await writeFile(`${archive}.sig`, "original signature");
let digests = 0;
await assert.rejects(
recompressUpdaterArchive(archive, {
env: { TAURI_SIGNING_PRIVATE_KEY: "key" },
run: async (command, args) => {
assert.equal(command, "bash");
if (args[1].includes("pigz -11")) {
await writeFile(args[4], "smaller");
return {};
}
digests += 1;
return { stdout: `${String(digests).repeat(64)} -\n` };
},
}),
/changed its contents/,
);
assert.equal(await readFile(archive, "utf8"), "original");
assert.equal(await readFile(`${archive}.sig`, "utf8"), "original signature");
});
function diskImageHarness({ convertedSize, failAt = new Set() }) {
const calls = [];
let codesignFailures = failAt.has("codesign") ? 1 : 0;
const run = async (command, args) => {
calls.push([command, args[0]]);
if (failAt.has(`${command} ${args[0]}`)) {
throw new Error(`${command} ${args[0]} failed`);
}
if (command === "hdiutil" && args[0] === "convert") {
assert.deepEqual(args.slice(2, 4), ["-format", "ULMO"]);
await writeFile(args[5], Buffer.alloc(convertedSize, 1));
}
if (command === "codesign" && args[0] === "--force") {
if (codesignFailures > 0) {
codesignFailures -= 1;
throw new Error("The timestamp service is not available.");
}
assert.deepEqual(args.slice(0, 5), [
"--force",
"--timestamp",
"--sign",
"Developer ID Application: Cap",
"--keychain",
]);
}
return {};
};
return { calls, run };
}
for (const scenario of [
{ name: "smaller", convertedSize: 10, replaced: true },
{ name: "larger", convertedSize: 400, replaced: false },
{
name: "failed",
convertedSize: 10,
failAt: new Set(["hdiutil verify"]),
replaced: false,
},
{
name: "retried",
convertedSize: 10,
failAt: new Set(["codesign"]),
replaced: true,
},
]) {
test(`a ${scenario.name} LZMA disk image ${scenario.replaced ? "replaces" : "keeps"} the original`, async (t) => {
const root = await workspace(t);
const dmg = path.join(root, "Cap_0.6.1_aarch64.dmg");
await writeFile(dmg, Buffer.alloc(100, 7));
const { calls, run } = diskImageHarness(scenario);
const delays = [];
const warnings = [];
const result = await convertDiskImage(dmg, {
env: {
APPLE_SIGNING_IDENTITY: "Developer ID Application: Cap",
APPLE_KEYCHAIN: "/tmp/build.keychain",
},
run,
delay: async (milliseconds) => delays.push(milliseconds),
warn: (message) => warnings.push(message),
});
const contents = await readFile(dmg);
if (scenario.replaced) {
assert.deepEqual(contents, Buffer.alloc(10, 1));
assert.deepEqual(result, { before: 100, after: 10 });
} else {
assert.deepEqual(contents, Buffer.alloc(100, 7));
}
if (scenario.name === "failed") {
assert.equal(result, null);
assert.match(warnings[0], /Keeping the zlib disk image/);
}
if (scenario.name === "retried") assert.deepEqual(delays, [15_000]);
assert.deepEqual(calls[0], ["hdiutil", "convert"]);
assert.ok(
!(await readdir(root)).some((file) => file.startsWith(".cap-dmg-")),
);
});
}
test("disk image conversion needs a signing identity before touching the image", async (t) => {
const root = await workspace(t);
const dmg = path.join(root, "Cap.dmg");
await writeFile(dmg, "original");
await assert.rejects(
convertDiskImage(dmg, {
env: {},
run: () => assert.fail("no command should run"),
}),
/APPLE_SIGNING_IDENTITY/,
);
assert.equal(await readFile(dmg, "utf8"), "original");
});
test("only the updater signer sees the updater signing key", async (t) => {
const root = await workspace(t);
await mkdir(path.join(root, "macos"));
await mkdir(path.join(root, "dmg"));
await writeFile(path.join(root, "macos/Cap.app.tar.gz"), "original archive");
await writeFile(path.join(root, "dmg/Cap.dmg"), Buffer.alloc(100, 7));
const calls = [];
const result = await finalizeMacosPackages(root, {
env: {
PATH: "/usr/bin",
APPLE_SIGNING_IDENTITY: "Developer ID Application: Cap",
TAURI_SIGNING_PRIVATE_KEY: "key",
TAURI_SIGNING_PRIVATE_KEY_PASSWORD: "password",
},
run: async (command, args, options) => {
calls.push({ command, env: options.env });
if (command === "bash" && args[1].includes("pigz -11")) {
await writeFile(args[4], "smaller");
} else if (command === "bash") {
return { stdout: `${"a".repeat(64)} -\n` };
} else if (command === "bun") {
await writeFile(`${args[4]}.sig`, "signature");
} else if (command === "hdiutil" && args[0] === "convert") {
await writeFile(args[5], Buffer.alloc(10, 1));
}
return {};
},
});
assert.deepEqual(result, {
archive: { before: 16, after: 7 },
dmg: { before: 100, after: 10 },
});
const tools = calls.filter((call) => call.command !== "bun");
assert.deepEqual(
[...new Set(tools.map((call) => call.command))],
["bash", "hdiutil", "codesign"],
);
for (const call of tools) {
assert.equal(call.env.PATH, "/usr/bin");
for (const name of [
"TAURI_SIGNING_PRIVATE_KEY",
"TAURI_SIGNING_PRIVATE_KEY_PASSWORD",
"TAURI_PRIVATE_KEY",
"TAURI_PRIVATE_KEY_PASSWORD",
]) {
assert.equal(call.env[name], undefined, `${call.command} saw ${name}`);
}
}
const signer = calls.filter((call) => call.command === "bun");
assert.equal(signer.length, 1);
assert.equal(signer[0].env.TAURI_PRIVATE_KEY, "key");
assert.equal(signer[0].env.TAURI_PRIVATE_KEY_PASSWORD, "password");
});
test("macOS packages are located once each inside the bundle", async (t) => {
const root = await workspace(t);
await mkdir(path.join(root, "macos"));
await mkdir(path.join(root, "dmg"));
await writeFile(path.join(root, "dmg/Cap_0.6.1_aarch64.dmg"), "dmg");
await assert.rejects(
finalizeMacosPackages(root, { env: {}, run: () => assert.fail() }),
/Expected one \.app\.tar\.gz/,
);
});