Move everything to apps/desktop subdirectory

Some bits will need to be moved back out after the merge

Signed-off-by: Michael Telatynski <7t3chguy@gmail.com>

apps/desktop/scripts/hak/README.md

@@ -0,0 +1,78 @@
+# hak
+
+This tool builds native dependencies for element-desktop. Here follows some very minimal
+documentation for it.
+
+Goals:
+
+- Must build compiled native node modules in a shippable state
+  (ie. only dynamically linked against libraries that will be on the
+  target system, all unnecessary files removed).
+- Must be able to build any native module, no matter what build system
+  it uses (electron-rebuild is supposed to do this job but only works
+  for modules that use gyp).
+
+It's also loosely designed to be a general tool and agnostic to what it's
+actually building. It's used here to build modules for the electron app
+but should work equally well for building modules for normal node.
+
+# Running
+
+Hak is invoked with a command and a dependency, eg. `pnpm run hak fetch matrix-seshat`.
+If no dependencies are given, hak runs the command on all dependencies.
+
+# Files
+
+There are a lot of files involved:
+
+- scripts/hak/... - The tool itself
+- hak/[dependency] - Files provided by the app that tell hak how to build each of its native dependencies.
+  Contains a hak.json file and also some script files, each of which must be referenced in hak.json.
+- .hak/ - Files generated by hak in the course of doing its job. Includes the dependency module itself and
+  any of the native dependency's native dependencies.
+- .hak/[dependency]/build - An extracted copy of the dependency's node module used to build it.
+- .hak/[dependency]/out - Another extracted copy of the dependency, this one contains only what will be shipped.
+
+# Workings
+
+Hak works around native node modules that try to fetch or build their native component in
+the npm 'install' phase - modules that do this will typically end up with native components
+targeted to the build platform and the node that npm/pnpm is using, which is no good for an
+electron app.
+
+It does this by installing it with `--ignore-scripts` and then using `pnpm link` to keep the
+dependency module separate so pnpm doesn't try to run its install / postinstall script
+at other points (eg. whenever you `pnpm add` a random other dependency).
+
+This also means that the dependencies cannot be listed in `dependencies` or
+`devDependencies` in the project, since this would cause pnpm to install them and
+try to fetch their native parts. Instead, they are listed in `hakDependencies` which
+hak reads to install them for you.
+
+Hak will _not_ install dependencies for the copy of the module it links into your
+project, so if your native module has javascript dependencies that are actually needed at
+runtime (and not just to fetch / build the native parts), it won't work.
+
+# Lifecycle
+
+Hak is divided into lifecycle stages, in order:
+
+- fetch - Download and extract the source of the dependency
+- link - Link the copy of the dependency into your node_modules directory
+- build - The Good Stuff. Configure and build any native dependencies, then the module itself.
+- copy - Copy the built artifact from the module build directory to the module output directory.
+
+# hak.json
+
+The scripts section contains scripts used for lifecycle stages that need them (fetch, build).
+It also contains 'prune' and 'copy' which are globs of files to delete from the output module directory
+and copy over from the module build directory to the output module directory, respectively.
+
+# Shortcomings
+
+Hak doesn't know about dependencies between lifecycle stages, ie. it doesn't know that you need to
+'fetch' before you can 'build', etc. You get to run each individually, and remember
+the right order.
+
+There is also a _lot_ of duplication in the command execution: we should abstract away
+some of the boilerplate required to run commands & so forth.

apps/desktop/scripts/hak/build.ts

@@ -0,0 +1,14 @@
+/*
+Copyright 2024 New Vector Ltd.
+Copyright 2020 The Matrix.org Foundation C.I.C.
+
+SPDX-License-Identifier: AGPL-3.0-only OR GPL-3.0-only OR LicenseRef-Element-Commercial
+Please see LICENSE files in the repository root for full details.
+*/
+
+import type { DependencyInfo } from "./dep.js";
+import type HakEnv from "./hakEnv.js";
+
+export default async function build(hakEnv: HakEnv, moduleInfo: DependencyInfo): Promise<void> {
+    await moduleInfo.scripts.build(hakEnv, moduleInfo);
+}

apps/desktop/scripts/hak/check.ts

@@ -0,0 +1,14 @@
+/*
+Copyright 2024 New Vector Ltd.
+Copyright 2020 The Matrix.org Foundation C.I.C.
+
+SPDX-License-Identifier: AGPL-3.0-only OR GPL-3.0-only OR LicenseRef-Element-Commercial
+Please see LICENSE files in the repository root for full details.
+*/
+
+import type { DependencyInfo } from "./dep.js";
+import type HakEnv from "./hakEnv.js";
+
+export default async function check(hakEnv: HakEnv, moduleInfo: DependencyInfo): Promise<void> {
+    await moduleInfo.scripts.check?.(hakEnv, moduleInfo);
+}

apps/desktop/scripts/hak/clean.ts

@@ -0,0 +1,19 @@
+/*
+Copyright 2024 New Vector Ltd.
+Copyright 2020 The Matrix.org Foundation C.I.C.
+
+SPDX-License-Identifier: AGPL-3.0-only OR GPL-3.0-only OR LicenseRef-Element-Commercial
+Please see LICENSE files in the repository root for full details.
+*/
+
+import path from "node:path";
+import { rimraf } from "rimraf";
+
+import type { DependencyInfo } from "./dep.js";
+import type HakEnv from "./hakEnv.js";
+
+export default async function clean(hakEnv: HakEnv, moduleInfo: DependencyInfo): Promise<void> {
+    await rimraf(moduleInfo.moduleDotHakDir);
+    await rimraf(path.join(hakEnv.dotHakDir, "links", moduleInfo.name));
+    await rimraf(path.join(hakEnv.projectRoot, "node_modules", moduleInfo.name));
+}

apps/desktop/scripts/hak/copy.ts

@@ -0,0 +1,62 @@
+/*
+Copyright 2024 New Vector Ltd.
+Copyright 2020, 2021 The Matrix.org Foundation C.I.C.
+
+SPDX-License-Identifier: AGPL-3.0-only OR GPL-3.0-only OR LicenseRef-Element-Commercial
+Please see LICENSE files in the repository root for full details.
+*/
+
+import path from "node:path";
+import fsProm from "node:fs/promises";
+import childProcess from "node:child_process";
+import { glob } from "glob";
+import { mkdirp } from "mkdirp";
+
+import type HakEnv from "./hakEnv.js";
+import type { DependencyInfo } from "./dep.js";
+
+export default async function copy(hakEnv: HakEnv, moduleInfo: DependencyInfo): Promise<void> {
+    if (moduleInfo.cfg.copy) {
+        // If there are multiple moduleBuildDirs, singular moduleBuildDir
+        // is the same as moduleBuildDirs[0], so we're just listing the contents
+        // of the first one.
+        const files = await glob(moduleInfo.cfg.copy, {
+            cwd: moduleInfo.moduleBuildDir,
+        });
+
+        if (moduleInfo.moduleBuildDirs.length > 1) {
+            if (!hakEnv.isMac()) {
+                console.error(
+                    "You asked me to copy multiple targets but I've only been taught " + "how to do that on macOS.",
+                );
+                throw new Error("Can't copy multiple targets on this platform");
+            }
+
+            for (const f of files) {
+                const components = moduleInfo.moduleBuildDirs.map((dir) => path.join(dir, f));
+                const dst = path.join(moduleInfo.moduleOutDir, f);
+
+                await mkdirp(path.dirname(dst));
+                await new Promise<void>((resolve, reject) => {
+                    childProcess.execFile("lipo", ["-create", "-output", dst, ...components], (err) => {
+                        if (err) {
+                            reject(err);
+                        } else {
+                            resolve();
+                        }
+                    });
+                });
+            }
+        } else {
+            console.log("Copying files from " + moduleInfo.moduleBuildDir + " to " + moduleInfo.moduleOutDir);
+            for (const f of files) {
+                console.log("\t" + f);
+                const src = path.join(moduleInfo.moduleBuildDir, f);
+                const dst = path.join(moduleInfo.moduleOutDir, f);
+
+                await mkdirp(path.dirname(dst));
+                await fsProm.copyFile(src, dst);
+            }
+        }
+    }
+}

apps/desktop/scripts/hak/dep.ts

@@ -0,0 +1,24 @@
+/*
+Copyright 2024 New Vector Ltd.
+Copyright 2021 The Matrix.org Foundation C.I.C.
+
+SPDX-License-Identifier: AGPL-3.0-only OR GPL-3.0-only OR LicenseRef-Element-Commercial
+Please see LICENSE files in the repository root for full details.
+*/
+
+import type HakEnv from "./hakEnv.js";
+
+export interface DependencyInfo {
+    name: string;
+    version: string;
+    cfg: Record<string, any>;
+    moduleHakDir: string;
+    moduleDotHakDir: string;
+    moduleTargetDotHakDir: string;
+    moduleBuildDir: string;
+    moduleBuildDirs: string[];
+    moduleOutDir: string;
+    nodeModuleBinDir: string;
+    depPrefix: string;
+    scripts: Record<string, (hakEnv: HakEnv, moduleInfo: DependencyInfo) => Promise<void>>;
+}

apps/desktop/scripts/hak/fetch.ts

@@ -0,0 +1,59 @@
+/*
+Copyright 2024 New Vector Ltd.
+Copyright 2020 The Matrix.org Foundation C.I.C.
+
+SPDX-License-Identifier: AGPL-3.0-only OR GPL-3.0-only OR LicenseRef-Element-Commercial
+Please see LICENSE files in the repository root for full details.
+*/
+
+import fsProm from "node:fs/promises";
+import pacote from "pacote";
+import path from "node:path";
+
+import type HakEnv from "./hakEnv.js";
+import type { DependencyInfo } from "./dep.js";
+
+export default async function fetch(hakEnv: HakEnv, moduleInfo: DependencyInfo): Promise<void> {
+    let haveModuleBuildDir;
+    try {
+        const stats = await fsProm.stat(moduleInfo.moduleBuildDir);
+        haveModuleBuildDir = stats.isDirectory();
+    } catch {
+        haveModuleBuildDir = false;
+    }
+
+    if (haveModuleBuildDir) return;
+
+    console.log("Fetching " + moduleInfo.name + "@" + moduleInfo.version);
+
+    const packumentCache = new Map();
+    await pacote.extract(`${moduleInfo.name}@${moduleInfo.version}`, moduleInfo.moduleBuildDir, {
+        packumentCache,
+    });
+
+    // Workaround for us switching to pnpm but matrix-seshat still using yarn classic
+    const packageJsonPath = path.join(moduleInfo.moduleBuildDir, "package.json");
+    const packageJson = await fsProm.readFile(packageJsonPath, "utf-8");
+    const packageJsonData = JSON.parse(packageJson);
+    packageJsonData["packageManager"] = "yarn@1.22.22";
+    await fsProm.writeFile(packageJsonPath, JSON.stringify(packageJsonData, null, 2), "utf-8");
+
+    console.log("Running yarn install in " + moduleInfo.moduleBuildDir);
+    await hakEnv.spawn("yarn", ["install", "--ignore-scripts"], {
+        cwd: moduleInfo.moduleBuildDir,
+    });
+
+    // also extract another copy to the output directory at this point
+    // nb. we do not yarn install in the output copy: we could install in
+    // production mode to get only runtime dependencies and not devDependencies,
+    // but usually native modules come with dependencies that are needed for
+    // building/fetching the native modules (eg. node-pre-gyp) rather than
+    // actually used at runtime: we do not want to bundle these into our app.
+    // We therefore just install no dependencies at all, and accept that any
+    // actual runtime dependencies will have to be added to the main app's
+    // dependencies. We can't tell what dependencies are real runtime deps
+    // and which are just used for native module building.
+    await pacote.extract(`${moduleInfo.name}@${moduleInfo.version}`, moduleInfo.moduleOutDir, {
+        packumentCache,
+    });
+}

apps/desktop/scripts/hak/hakEnv.ts

@@ -0,0 +1,130 @@
+/*
+Copyright 2024 New Vector Ltd.
+Copyright 2020, 2021 The Matrix.org Foundation C.I.C.
+
+SPDX-License-Identifier: AGPL-3.0-only OR GPL-3.0-only OR LicenseRef-Element-Commercial
+Please see LICENSE files in the repository root for full details.
+*/
+
+import path from "node:path";
+import os from "node:os";
+import { getElectronVersionFromInstalled } from "app-builder-lib/out/electron/electronVersion.js";
+import childProcess, { type SpawnOptions } from "node:child_process";
+
+import { type Arch, type Target, TARGETS, getHost, isHostId, type TargetId } from "./target.js";
+
+async function getRuntimeVersion(projectRoot: string): Promise<string> {
+    const electronVersion = await getElectronVersionFromInstalled(projectRoot);
+    if (!electronVersion) {
+        throw new Error("Can't determine Electron version");
+    }
+    return electronVersion;
+}
+
+export type Tool = [cmd: string, ...args: string[]];
+
+export default class HakEnv {
+    public readonly target: Target;
+    public runtime: string = "electron";
+    public runtimeVersion?: string;
+    public dotHakDir: string;
+
+    public constructor(
+        public readonly projectRoot: string,
+        targetId: TargetId | null,
+    ) {
+        const target = targetId ? TARGETS[targetId] : getHost();
+
+        if (!target) {
+            throw new Error(`Unknown target ${targetId}!`);
+        }
+        this.target = target;
+        this.dotHakDir = path.join(this.projectRoot, ".hak");
+    }
+
+    public async init(): Promise<void> {
+        this.runtimeVersion = await getRuntimeVersion(this.projectRoot);
+    }
+
+    public getTargetId(): TargetId {
+        return this.target.id;
+    }
+
+    public isWin(): boolean {
+        return this.target.platform === "win32";
+    }
+
+    public isMac(): boolean {
+        return this.target.platform === "darwin";
+    }
+
+    public isLinux(): boolean {
+        return this.target.platform === "linux";
+    }
+
+    public isFreeBSD(): boolean {
+        return this.target.platform === "freebsd";
+    }
+
+    public getTargetArch(): Arch {
+        return this.target.arch;
+    }
+
+    public isHost(): boolean {
+        return isHostId(this.target.id);
+    }
+
+    public makeGypEnv(): Record<string, string | undefined> {
+        return {
+            ...process.env,
+            npm_config_arch: this.target.arch,
+            npm_config_target_arch: this.target.arch,
+            npm_config_disturl: "https://electronjs.org/headers",
+            npm_config_runtime: this.runtime,
+            npm_config_target: this.runtimeVersion,
+            npm_config_build_from_source: "true",
+            npm_config_devdir: path.join(os.homedir(), ".electron-gyp"),
+        };
+    }
+
+    public wantsStaticSqlCipher(): boolean {
+        return !(this.isLinux() || this.isFreeBSD()) || process.env.SQLCIPHER_BUNDLED == "1";
+    }
+
+    public spawn(
+        cmd: string,
+        args: string[],
+        { ignoreWinCmdlet, ...options }: SpawnOptions & { ignoreWinCmdlet?: boolean } = {},
+    ): Promise<void> {
+        return new Promise((resolve, reject) => {
+            const proc = childProcess.spawn(cmd + (!ignoreWinCmdlet && this.isWin() ? ".cmd" : ""), args, {
+                stdio: "inherit",
+                // We need shell mode on Windows to be able to launch `.cmd` executables
+                // See https://nodejs.org/en/blog/vulnerability/april-2024-security-releases-2
+                shell: this.isWin(),
+                ...options,
+            });
+            proc.on("exit", (code) => {
+                if (code) {
+                    reject(code);
+                } else {
+                    resolve();
+                }
+            });
+        });
+    }
+
+    public async checkTools(tools: Tool[]): Promise<void> {
+        for (const [tool, ...args] of tools) {
+            try {
+                await this.spawn(tool, args, {
+                    ignoreWinCmdlet: true,
+                    stdio: ["ignore"],
+                    shell: false,
+                });
+            } catch {
+                throw new Error(`Can't find ${tool}`);
+            }
+        }
+    }
+}

apps/desktop/scripts/hak/index.ts

@@ -0,0 +1,147 @@
+/*
+Copyright 2024 New Vector Ltd.
+Copyright 2020, 2021 The Matrix.org Foundation C.I.C.
+
+SPDX-License-Identifier: AGPL-3.0-only OR GPL-3.0-only OR LicenseRef-Element-Commercial
+Please see LICENSE files in the repository root for full details.
+*/
+
+import path, { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import HakEnv from "./hakEnv.js";
+import type { TargetId } from "./target.js";
+import type { DependencyInfo } from "./dep.js";
+import { loadJsonFile } from "../../src/utils.js";
+import packageJson from "../../package.json";
+
+// These can only be run on specific modules
+const MODULECOMMANDS = ["check", "fetch", "link", "build", "copy", "clean"];
+
+// Shortcuts for multiple commands at once (useful for building universal binaries
+// because you can run the fetch/build for each arch and then copy/link once)
+const METACOMMANDS: Record<string, string[]> = {
+    fetchandbuild: ["check", "fetch", "build"],
+    copyandlink: ["copy", "link"],
+};
+
+// Scripts valid in a hak.json 'scripts' section
+const HAKSCRIPTS = ["check", "fetch", "build"];
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+async function main(): Promise<void> {
+    const prefix = path.join(__dirname, "..", "..");
+
+    const targetIds: TargetId[] = [];
+    // Apply `--target <target>` option if specified
+    // Can be specified multiple times for the copy command to bundle
+    // multiple arches into a single universal output module)
+    for (;;) {
+        // eslint-disable-line no-constant-condition
+        const targetIndex = process.argv.indexOf("--target");
+        if (targetIndex === -1) break;
+
+        if (targetIndex + 1 >= process.argv.length) {
+            console.error("--target option specified without a target");
+            process.exit(1);
+        }
+        // Extract target ID and remove from args
+        targetIds.push(process.argv.splice(targetIndex, 2)[1] as TargetId);
+    }
+
+    const hakEnvs = targetIds.map((tid) => new HakEnv(prefix, tid));
+    if (hakEnvs.length == 0) hakEnvs.push(new HakEnv(prefix, null));
+    for (const h of hakEnvs) {
+        await h.init();
+    }
+    const hakEnv = hakEnvs[0];
+
+    const deps: Record<string, DependencyInfo> = {};
+
+    const hakDepsCfg = packageJson.hakDependencies || {};
+
+    for (const dep in hakDepsCfg) {
+        const hakJsonPath = path.join(prefix, "hak", dep, "hak.json");
+        let hakJson: Record<string, any>;
+        try {
+            hakJson = loadJsonFile(hakJsonPath);
+        } catch {
+            console.error("No hak.json found for " + dep + ".");
+            console.log("Expecting " + hakJsonPath);
+            process.exit(1);
+        }
+        deps[dep] = {
+            name: dep,
+            version: hakDepsCfg[dep as keyof typeof hakDepsCfg],
+            cfg: hakJson,
+            moduleHakDir: path.join(prefix, "hak", dep),
+            moduleDotHakDir: path.join(hakEnv.dotHakDir, dep),
+            moduleTargetDotHakDir: path.join(hakEnv.dotHakDir, dep, hakEnv.getTargetId()),
+            moduleBuildDir: path.join(hakEnv.dotHakDir, dep, hakEnv.getTargetId(), "build"),
+            moduleBuildDirs: hakEnvs.map((h) => path.join(h.dotHakDir, dep, h.getTargetId(), "build")),
+            moduleOutDir: path.join(hakEnv.dotHakDir, "hakModules", dep),
+            nodeModuleBinDir: path.join(hakEnv.dotHakDir, dep, hakEnv.getTargetId(), "build", "node_modules", ".bin"),
+            depPrefix: path.join(hakEnv.dotHakDir, dep, hakEnv.getTargetId(), "opt"),
+            scripts: {},
+        };
+
+        for (const s of HAKSCRIPTS) {
+            if (hakJson.scripts?.[s]) {
+                // Shockingly, using path.join and backslashes here doesn't work on Windows
+                const scriptModule = await import(`../../hak/${dep}/${hakJson.scripts[s]}`);
+                if (scriptModule.default) {
+                    deps[dep].scripts[s] = scriptModule.default;
+                } else {
+                    deps[dep].scripts[s] = scriptModule;
+                }
+            }
+        }
+    }
+
+    let cmds: string[];
+    if (process.argv.length < 3) {
+        cmds = ["check", "fetch", "build", "copy", "link"];
+    } else if (METACOMMANDS[process.argv[2]]) {
+        cmds = METACOMMANDS[process.argv[2]];
+    } else {
+        cmds = [process.argv[2]];
+    }
+
+    if (hakEnvs.length > 1 && cmds.some((c) => !["copy", "link"].includes(c))) {
+        // We allow link here too for convenience because it's completely arch independent
+        console.error("Multiple targets only supported with the copy command");
+        return;
+    }
+
+    let modules = process.argv.slice(3);
+    if (modules.length === 0) modules = Object.keys(deps);
+
+    for (const cmd of cmds) {
+        if (!MODULECOMMANDS.includes(cmd)) {
+            console.error("Unknown command: " + cmd);
+            console.log("Commands I know about:");
+            for (const cmd of MODULECOMMANDS) {
+                console.log("\t" + cmd);
+            }
+            process.exit(1);
+        }
+
+        const cmdFunc = (await import("./" + cmd)).default;
+
+        for (const mod of modules) {
+            const depInfo = deps[mod];
+            if (depInfo === undefined) {
+                console.log("Module " + mod + " not found - is it in hakDependencies " + "in your package.json?");
+                process.exit(1);
+            }
+            console.log("hak " + cmd + ": " + mod);
+            await cmdFunc(hakEnv, depInfo);
+        }
+    }
+}
+
+main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

apps/desktop/scripts/hak/link.ts

@@ -0,0 +1,16 @@
+/*
+Copyright 2024 New Vector Ltd.
+Copyright 2020 The Matrix.org Foundation C.I.C.
+
+SPDX-License-Identifier: AGPL-3.0-only OR GPL-3.0-only OR LicenseRef-Element-Commercial
+Please see LICENSE files in the repository root for full details.
+*/
+
+import type HakEnv from "./hakEnv.js";
+import { type DependencyInfo } from "./dep.js";
+
+export default async function link(hakEnv: HakEnv, moduleInfo: DependencyInfo): Promise<void> {
+    await hakEnv.spawn("pnpm", ["link", moduleInfo.moduleOutDir], {
+        cwd: hakEnv.projectRoot,
+    });
+}

apps/desktop/scripts/hak/target.ts

@@ -0,0 +1,217 @@
+/*
+Copyright 2024 New Vector Ltd.
+Copyright 2021 The Matrix.org Foundation C.I.C.
+
+SPDX-License-Identifier: AGPL-3.0-only OR GPL-3.0-only OR LicenseRef-Element-Commercial
+Please see LICENSE files in the repository root for full details.
+*/
+
+import { GLIBC, MUSL, familySync as processLibC } from "detect-libc";
+
+// We borrow Rust's target naming scheme as a way of expressing all target
+// details in a single string.
+// See https://doc.rust-lang.org/rustc/platform-support.html.
+export type TargetId =
+    | "aarch64-apple-darwin"
+    | "x86_64-apple-darwin"
+    | "universal-apple-darwin"
+    | "i686-pc-windows-msvc"
+    | "x86_64-pc-windows-msvc"
+    | "aarch64-pc-windows-msvc"
+    | "i686-unknown-freebsd"
+    | "x86_64-unknown-freebsd"
+    | "aarch64-unknown-freebsd"
+    | "i686-unknown-linux-musl"
+    | "i686-unknown-linux-gnu"
+    | "x86_64-unknown-linux-musl"
+    | "x86_64-unknown-linux-gnu"
+    | "aarch64-unknown-linux-musl"
+    | "aarch64-unknown-linux-gnu"
+    | "powerpc64le-unknown-linux-musl"
+    | "powerpc64le-unknown-linux-gnu";
+
+// Values are expected to match those used in `process.platform`.
+export type Platform = "darwin" | "freebsd" | "linux" | "win32";
+
+// Values are expected to match those used in `process.arch`.
+export type Arch = "arm64" | "ia32" | "x64" | "ppc64" | "universal";
+
+// Values are expected to match those used by Visual Studio's `vcvarsall.bat`.
+// See https://docs.microsoft.com/cpp/build/building-on-the-command-line?view=msvc-160#vcvarsall-syntax
+export type VcVarsArch = "amd64" | "arm64" | "x86";
+
+export type Target = {
+    id: TargetId;
+    platform: Platform;
+    arch: Arch;
+};
+
+export type WindowsTarget = Target & {
+    platform: "win32";
+    vcVarsArch: VcVarsArch;
+};
+
+export type LinuxTarget = Target & {
+    platform: "linux";
+    libC: typeof GLIBC | typeof MUSL;
+};
+
+export type UniversalTarget = Target & {
+    arch: "universal";
+    subtargets: Target[];
+};
+
+const aarch64AppleDarwin: Target = {
+    id: "aarch64-apple-darwin",
+    platform: "darwin",
+    arch: "arm64",
+};
+
+const x8664AppleDarwin: Target = {
+    id: "x86_64-apple-darwin",
+    platform: "darwin",
+    arch: "x64",
+};
+
+const universalAppleDarwin: UniversalTarget = {
+    id: "universal-apple-darwin",
+    platform: "darwin",
+    arch: "universal",
+    subtargets: [aarch64AppleDarwin, x8664AppleDarwin],
+};
+
+const i686PcWindowsMsvc: WindowsTarget = {
+    id: "i686-pc-windows-msvc",
+    platform: "win32",
+    arch: "ia32",
+    vcVarsArch: "x86",
+};
+
+const x8664PcWindowsMsvc: WindowsTarget = {
+    id: "x86_64-pc-windows-msvc",
+    platform: "win32",
+    arch: "x64",
+    vcVarsArch: "amd64",
+};
+
+const aarch64WindowsMsvc: WindowsTarget = {
+    id: "aarch64-pc-windows-msvc",
+    platform: "win32",
+    arch: "arm64",
+    vcVarsArch: "arm64",
+};
+
+const i686UnknownFreebsd: Target = {
+    id: "i686-unknown-freebsd",
+    platform: "freebsd",
+    arch: "ia32",
+};
+
+const x8664UnknownFreebsd: Target = {
+    id: "x86_64-unknown-freebsd",
+    platform: "freebsd",
+    arch: "x64",
+};
+
+const aarch64UnknownFreebsd: Target = {
+    id: "aarch64-unknown-freebsd",
+    platform: "freebsd",
+    arch: "arm64",
+};
+
+const x8664UnknownLinuxGnu: LinuxTarget = {
+    id: "x86_64-unknown-linux-gnu",
+    platform: "linux",
+    arch: "x64",
+    libC: GLIBC,
+};
+
+const x8664UnknownLinuxMusl: LinuxTarget = {
+    id: "x86_64-unknown-linux-musl",
+    platform: "linux",
+    arch: "x64",
+    libC: MUSL,
+};
+
+const i686UnknownLinuxGnu: LinuxTarget = {
+    id: "i686-unknown-linux-gnu",
+    platform: "linux",
+    arch: "ia32",
+    libC: GLIBC,
+};
+
+const i686UnknownLinuxMusl: LinuxTarget = {
+    id: "i686-unknown-linux-musl",
+    platform: "linux",
+    arch: "ia32",
+    libC: MUSL,
+};
+
+const aarch64UnknownLinuxGnu: LinuxTarget = {
+    id: "aarch64-unknown-linux-gnu",
+    platform: "linux",
+    arch: "arm64",
+    libC: GLIBC,
+};
+
+const aarch64UnknownLinuxMusl: LinuxTarget = {
+    id: "aarch64-unknown-linux-musl",
+    platform: "linux",
+    arch: "arm64",
+    libC: MUSL,
+};
+
+const powerpc64leUnknownLinuxGnu: LinuxTarget = {
+    id: "powerpc64le-unknown-linux-gnu",
+    platform: "linux",
+    arch: "ppc64",
+    libC: GLIBC,
+};
+
+const powerpc64leUnknownLinuxMusl: LinuxTarget = {
+    id: "powerpc64le-unknown-linux-musl",
+    platform: "linux",
+    arch: "ppc64",
+    libC: MUSL,
+};
+
+export const TARGETS: Record<TargetId, Target> = {
+    // macOS
+    "aarch64-apple-darwin": aarch64AppleDarwin,
+    "x86_64-apple-darwin": x8664AppleDarwin,
+    "universal-apple-darwin": universalAppleDarwin,
+    // Windows
+    "i686-pc-windows-msvc": i686PcWindowsMsvc,
+    "x86_64-pc-windows-msvc": x8664PcWindowsMsvc,
+    "aarch64-pc-windows-msvc": aarch64WindowsMsvc,
+    // FreeBSD
+    "i686-unknown-freebsd": i686UnknownFreebsd,
+    "x86_64-unknown-freebsd": x8664UnknownFreebsd,
+    "aarch64-unknown-freebsd": aarch64UnknownFreebsd,
+    // Linux
+    "i686-unknown-linux-musl": i686UnknownLinuxMusl,
+    "i686-unknown-linux-gnu": i686UnknownLinuxGnu,
+    "x86_64-unknown-linux-musl": x8664UnknownLinuxMusl,
+    "x86_64-unknown-linux-gnu": x8664UnknownLinuxGnu,
+    "aarch64-unknown-linux-musl": aarch64UnknownLinuxMusl,
+    "aarch64-unknown-linux-gnu": aarch64UnknownLinuxGnu,
+    "powerpc64le-unknown-linux-musl": powerpc64leUnknownLinuxMusl,
+    "powerpc64le-unknown-linux-gnu": powerpc64leUnknownLinuxGnu,
+};
+
+export function getHost(): Target | undefined {
+    return Object.values(TARGETS).find(
+        (target) =>
+            target.platform === process.platform &&
+            target.arch === process.arch &&
+            (process.platform !== "linux" || (target as LinuxTarget).libC === processLibC()),
+    );
+}
+
+export function isHostId(id: TargetId): boolean {
+    return getHost()?.id === id;
+}
+
+export function isHost(target: Target): boolean {
+    return getHost()?.id === target.id;
+}