@gtkx/cli 2.0.0-beta.7 → 2.0.0-beta.9

package/src/deploy/node-runtime/download.ts

@@ -44,8 +44,8 @@ const downloadNode = async (version: string, arch: string, destDir: string): Pro
         url: `${DIST_BASE_URL}/v${version}/${assetName}`,
         dest: join(dir, assetName),
         label: `Node.js ${version} for linux-${arch}`,
-        sha256: await cachedDigest(request),
-        freshSha256: () => publishedDigest(request),
+        digest: await cachedDigest(request),
+        freshDigest: () => publishedDigest(request),
     });
 
     mkdirSync(destDir, { recursive: true });

package/src/deploy/node-runtime/elf.ts

@@ -7,6 +7,7 @@ type ElfSection = {
 };
 
 type ElfInfo = {
+    machine: number;
     needed: string[];
     glibcMinimum: string | null;
 };
@@ -22,6 +23,7 @@ const CLASS_64 = 2;
 const LITTLE_ENDIAN = 1;
 const OFFSET_CLASS = 4;
 const OFFSET_DATA = 5;
+const OFFSET_MACHINE = 0x12;
 const OFFSET_SECTION_HEADERS = 0x28;
 const OFFSET_SECTION_ENTRY_SIZE = 0x3A;
 const OFFSET_SECTION_COUNT = 0x3C;
@@ -140,6 +142,7 @@ const readElfBuffer = (buffer: Buffer, path: string): ElfInfo => {
     const strings = stringTable(buffer, sectionFor(sections, ".dynstr"));
 
     return {
+        machine: buffer.readUInt16LE(OFFSET_MACHINE),
         needed: readNeeded(buffer, sectionFor(sections, ".dynamic"), strings),
         glibcMinimum: readGlibcMinimum(strings),
     };
@@ -180,4 +183,4 @@ const glibcMinimumForFiles = (paths: Iterable<string>): string | null => {
     return formatVersion(highestVersion(versions));
 };
 
-export { type ElfInfo, glibcMinimumForFiles, readElfInfo };
+export { type ElfInfo, glibcMinimumForFiles, readElfInfo, readOptionalElfInfo };

package/src/deploy/node-runtime/guard.ts

@@ -1,19 +1,16 @@
 import type { ElfInfo } from "./elf.js";
+import { RUNTIME_SONAMES } from "./sonames.js";
 
-const PORTABLE_LIBRARIES = new Set([
-    "ld-linux-aarch64.so.1",
-    "ld-linux-x86-64.so.2",
-    "libc.so.6",
-    "libdl.so.2",
-    "libgcc_s.so.1",
-    "libm.so.6",
-    "libpthread.so.0",
-    "librt.so.1",
-    "libstdc++.so.6",
-]);
+const DOWNLOAD_REMEDY =
+    "The packages GTKX generates declare the libraries an official release links against, and this release " +
+    "links against more. Report it to GTKX, and pin `deploy.node.version` to a release it already packages.";
+
+const SOURCE_REMEDY = 'Use `deploy.node.source: "download"` to fetch an official self-contained build instead.';
+
+const remedyFor = (source: string): string => (source === "download" ? DOWNLOAD_REMEDY : SOURCE_REMEDY);
 
 const assertPortableNode = (info: ElfInfo, source: string): void => {
-    const foreign = info.needed.filter((library) => !PORTABLE_LIBRARIES.has(library));
+    const foreign = info.needed.filter((library) => !RUNTIME_SONAMES.has(library));
 
     if (foreign.length === 0) {
         return;
@@ -21,8 +18,7 @@ const assertPortableNode = (info: ElfInfo, source: string): void => {
 
     throw new Error(
         `Cannot bundle this Node.js binary: \`deploy.node.source: "${source}"\` picked one linked against ` +
-        `${foreign.join(", ")}, which the target machine will not have. ` +
-        'Use `deploy.node.source: "download"` to fetch an official self-contained build instead.',
+        `${foreign.join(", ")}, which the packages GTKX generates do not require. ${remedyFor(source)}`,
     );
 };
 

package/src/deploy/node-runtime/index.ts

@@ -1,12 +1,13 @@
 import { MINIMUM_NODE_VERSION } from "@gtkx/config/internal";
-import { info, tryResolveExecutable } from "@gtkx/utils";
+import { info, tryResolveExecutable, warn } from "@gtkx/utils";
 import { execFileSync } from "node:child_process";
-import { chmodSync, copyFileSync, mkdirSync, statSync } from "node:fs";
+import { chmodSync, copyFileSync, existsSync, mkdirSync, statSync } from "node:fs";
 import { join, resolve } from "node:path";
-import type { DeploySettings, NodeRuntime } from "../types.js";
+import type { DeployConfig, DeploySettings, NodeRuntime } from "../types.js";
 import { runCliTool } from "../../internal/run-cli-tool.js";
+import { elfMachineFor, hostArchName } from "../settings/arch.js";
 import { downloadNode } from "./download.js";
-import { readElfInfo } from "./elf.js";
+import { type ElfInfo, readElfInfo, readOptionalElfInfo } from "./elf.js";
 import { assertPortableNode } from "./guard.js";
 import { licenseBesideNode } from "./license.js";
 
@@ -113,6 +114,21 @@ const sourcePathFor = (settings: DeploySettings): string => {
     return resolve(settings.paths.root, node.path);
 };
 
+const assertPortableRuntimeSource = (settings: DeploySettings): void => {
+    const source = nodeSourceFor(settings);
+
+    if (source === "download") {
+        return;
+    }
+
+    const sourcePath = sourcePathFor(settings);
+    const elf = existsSync(sourcePath) ? readOptionalElfInfo(sourcePath) : null;
+
+    if (elf !== null) {
+        assertPortableNode(elf, source);
+    }
+};
+
 const resolveNodeVersion = (settings: DeploySettings): string => {
     const node = settings.deploy.node ?? {};
     const source = nodeSourceFor(settings);
@@ -166,22 +182,41 @@ const stageFromSource = async (
     }
 
     const sourcePath = sourcePathFor(settings);
-    assertPortableNode(readElfInfo(sourcePath), source);
 
     return { path: stageNode(settings, sourcePath), licenseFile: licenseBesideNode(sourcePath) };
 };
 
+type DeployNodeConfig = NonNullable<DeployConfig["node"]>;
+
+const shouldStripRuntime = (settings: DeploySettings, node: DeployNodeConfig, elf: ElfInfo): boolean => {
+    if (node.shouldStrip === false) {
+        return false;
+    }
+
+    if (elf.machine === elfMachineFor(hostArchName())) {
+        return true;
+    }
+
+    warn(
+        `Skipping \`strip\` on the bundled Node.js: it was built for ${settings.arch.node} and \`strip\` reads ` +
+        `only ${hostArchName()}. The ${settings.arch.node} packages carry an unstripped runtime.`,
+    );
+
+    return false;
+};
+
 const resolveNodeRuntime = async (settings: DeploySettings): Promise<NodeRuntime> => {
     const node = settings.deploy.node ?? {};
     const source = nodeSourceFor(settings);
     const version = resolveNodeVersion(settings);
     const staged = await stageFromSource(settings, version, source);
-    const isStripped = node.shouldStrip === false ? false : didStripBinary(staged.path);
     const elf = readElfInfo(staged.path);
+    assertPortableNode(elf, source);
+    const isStripped = shouldStripRuntime(settings, node, elf) && didStripBinary(staged.path);
     const glibcMinimum = elf.glibcMinimum ?? "unknown";
     info(`Bundled Node.js v${version} (${megabytes(staged.path)} MiB, runtime glibc >= ${glibcMinimum})`);
 
     return { ...staged, version, glibcMinimum: elf.glibcMinimum, isStripped };
 };
 
-export { resolveNodeRuntime, resolveNodeVersion, sourcePathFor };
+export { assertPortableRuntimeSource, resolveNodeRuntime, resolveNodeVersion, sourcePathFor };

package/src/deploy/node-runtime/sonames.ts

@@ -0,0 +1,17 @@
+const GLIBC_SONAMES = [
+    "ld-linux-aarch64.so.1",
+    "ld-linux-x86-64.so.2",
+    "libc.so.6",
+    "libdl.so.2",
+    "libm.so.6",
+    "libpthread.so.0",
+    "librt.so.1",
+] as const;
+
+const PACKAGED_SONAMES = ["libatomic.so.1", "libgcc_s.so.1", "libstdc++.so.6"] as const;
+
+type PackagedSoname = (typeof PACKAGED_SONAMES)[number];
+
+const RUNTIME_SONAMES: Set<string> = new Set([...GLIBC_SONAMES, ...PACKAGED_SONAMES]);
+
+export { PACKAGED_SONAMES, type PackagedSoname, RUNTIME_SONAMES };

package/src/deploy/payload/stage.ts

@@ -8,7 +8,10 @@ import { listFilesRecursive } from "../../internal/list-files.js";
 import { BUNDLE_FILENAME } from "../../vite-plugins/esm-extension.js";
 import { renderCopyright } from "../freedesktop/copyright.js";
 import { renderDbusService } from "../freedesktop/dbus-service.js";
+import { BINDING_FILENAME } from "../native-addon.js";
+import { readOptionalElfInfo } from "../node-runtime/elf.js";
 import { renderNotices } from "../notices/render.js";
+import { elfMachineFor } from "../settings/arch.js";
 import { copyInto, EXECUTABLE_MODE, executableModeFor, writeInto } from "./copy-tree.js";
 import { stageIcons } from "./icons.js";
 import { NODE_FILENAME, renderLauncher } from "./launcher.js";
@@ -17,6 +20,7 @@ import { stageSchemas } from "./schemas.js";
 type StageRequest = {
     settings: DeploySettings;
     node: NodeRuntime | null;
+    addon: string | null;
     metadata: StagedMetadata;
 };
 
@@ -67,6 +71,29 @@ const stageRuntimeFiles = (settings: DeploySettings, root: string): StagedFile[]
         .map((file) => copyInto(root, join(libDirFor(settings), file.rel), file.absPath));
 };
 
+const stageAddon = (settings: DeploySettings, root: string, addon: string | null): StagedFile[] =>
+    addon === null ? [] : [copyInto(root, join(libDirFor(settings), BINDING_FILENAME), addon)];
+
+const architectureMismatch = (settings: DeploySettings, file: StagedFile): Error =>
+    new Error(
+        `Cannot deploy ${file.rel} for ${settings.arch.node}: it was built for another architecture. ` +
+        "Run `gtkx build` again, or drop --skip-build.",
+    );
+
+const assertStagedArchitecture = (settings: DeploySettings, staged: StagedFile[]): void => {
+    const expected = elfMachineFor(settings.arch.node);
+    const lib = libDirFor(settings);
+    const checked = new Set([join(lib, BINDING_FILENAME), join(lib, NODE_FILENAME)]);
+
+    const binaries = staged.filter((entry) => checked.has(entry.rel));
+
+    for (const file of binaries) {
+        if (readOptionalElfInfo(file.abs)?.machine !== expected) {
+            throw architectureMismatch(settings, file);
+        }
+    }
+};
+
 const stageCatalogs = (settings: DeploySettings, root: string): StagedFile[] =>
     listFilesRecursive(join(settings.paths.dist, LOCALE_DIRNAME))
         .map((file) => copyInto(root, join(SHARE_LOCALE, file.rel), file.absPath));
@@ -138,20 +165,25 @@ const byRelativePath = (files: StagedFile[]): StagedFile[] => {
     return sortStringsBy(latest.values(), (file) => file.rel);
 };
 
-const stagePayload = ({ settings, node, metadata }: StageRequest): StagedFile[] => {
+const stagePayload = ({ settings, node, addon, metadata }: StageRequest): StagedFile[] => {
     const root = settings.paths.stage;
     rmSync(root, { recursive: true, force: true, maxRetries: 5 });
 
-    return byRelativePath([
+    const staged = byRelativePath([
         writeInto(root, join("bin", settings.binaryName), renderLauncher(settings), EXECUTABLE_MODE),
         ...stageNodeBinary(settings, root, node),
         ...stageRuntimeFiles(settings, root),
+        ...stageAddon(settings, root, addon),
         ...stageCatalogs(settings, root),
         ...stageExtraFiles(settings, root, metadata),
         ...stageMetadata(settings, root, metadata),
         ...stageIcons(settings, root),
         ...stageSchemas(settings, root),
     ]);
+
+    assertStagedArchitecture(settings, staged);
+
+    return staged;
 };
 
 const withoutDbusActivation = (desktopEntry: string): string =>