@gtkx/cli 2.0.0-beta.1 → 2.0.0-beta.2

package/src/commands/build.ts

@@ -1,7 +1,8 @@
 import { info } from "@gtkx/utils";
 import { defineCommand } from "citty";
 import { build as buildApp } from "../builder.js";
-import { entryArg } from "../internal/entry-arg.js";
+import { prepareBuildOutDir, resolveBuildOutDir } from "../internal/build-output.js";
+import { configArg, entryArg } from "../internal/entry-arg.js";
 import { prepareProject } from "../internal/prepare-project.js";
 
 const BUILD_MODE = "production";
@@ -13,18 +14,28 @@ const build = defineCommand({
     },
     args: {
         ...entryArg,
+        ...configArg,
+        out: {
+            type: "string",
+            description: "Output directory below the project root (default: dist)",
+        },
     },
     async run({ args }) {
-        const { cwd, entry } = await prepareProject(args, BUILD_MODE);
+        const { cwd, entry, configFile } = await prepareProject(args, BUILD_MODE);
+        const outDir = resolveBuildOutDir(cwd, args.out);
+        using preparedOutput = prepareBuildOutDir(cwd, outDir);
         info(`Building ${entry}`);
 
         const bundlePath = await buildApp({
             entry,
+            configFile,
             vite: {
                 root: cwd,
+                build: { outDir: preparedOutput.path, emptyOutDir: false },
             },
         });
 
+        preparedOutput.commit();
         info(`Build complete: ${bundlePath}`);
     },
 });

package/src/commands/codegen.ts

@@ -2,7 +2,7 @@ import { info } from "@gtkx/utils";
 import { defineCommand } from "citty";
 import { formatCodegenResult } from "../codegen/report.js";
 import { ensureGenerated, isCodegenDisabled, runCodegen } from "../codegen/run-codegen.js";
-import { cwdArg, resolveCwd } from "../internal/entry-arg.js";
+import { configArg, cwdArg, resolveCwd } from "../internal/entry-arg.js";
 
 const FORCED_WHILE_DISABLED_MESSAGE =
     "codegen is disabled for this project, so --force has no store to regenerate here. " +
@@ -20,29 +20,30 @@ const codegen = defineCommand({
             description: "Wipe the generated store and regenerate unconditionally (recover a corrupted store)",
             default: false,
         },
+        ...configArg,
         ...cwdArg,
     },
     async run({ args }) {
         const cwd = resolveCwd(args);
-        const isDisabled = await isCodegenDisabled(cwd);
+        const isDisabled = await isCodegenDisabled(cwd, undefined, args.config);
         checkForce(isDisabled, args.force);
 
         if (isDisabled) {
-            await runCodegen({ cwd });
+            await runCodegen({ cwd, configFile: args.config });
             info("codegen: disabled for this project; reusing an installed binding store");
 
             return;
         }
 
         if (!args.force) {
-            const isRan = await ensureGenerated(cwd);
+            const isRan = await ensureGenerated(cwd, { configFile: args.config });
             info(isRan ? "codegen: regenerated stale bindings" : "codegen: bindings up to date");
 
             return;
         }
 
         const startedAt = Date.now();
-        const result = await runCodegen({ cwd, isForced: true });
+        const result = await runCodegen({ cwd, configFile: args.config, isForced: true });
         const lines = formatCodegenResult(result, Date.now() - startedAt);
 
         for (const line of lines) {

package/src/commands/deploy.ts

@@ -1,7 +1,7 @@
 import { defineCommand } from "citty";
 import { KNOWN_NAMES } from "../deploy/registry.js";
 import { runDeploy } from "../deploy/run-deploy.js";
-import { entryArg } from "../internal/entry-arg.js";
+import { configArg, entryArg } from "../internal/entry-arg.js";
 import { resolveProject } from "../internal/prepare-project.js";
 
 const DEPLOY_MODE = "production";
@@ -13,6 +13,7 @@ const deploy = defineCommand({
     },
     args: {
         ...entryArg,
+        ...configArg,
         target: {
             type: "string",
             description: `Comma-separated package formats to build (${KNOWN_NAMES})`,
@@ -31,11 +32,12 @@ const deploy = defineCommand({
         },
     },
     async run({ args }) {
-        const { cwd, entry } = await resolveProject(args, DEPLOY_MODE);
+        const { cwd, entry, configFile } = await resolveProject(args, DEPLOY_MODE);
 
         await runDeploy({
             entry,
             cwd,
+            configFile,
             targets: args.target,
             outDir: args.out,
             shouldPrintManifests: args["print-manifests"] === true,

package/src/commands/dev.ts

@@ -1,5 +1,6 @@
 import { defineCommand } from "citty";
 import { resolveConfigWatch } from "../codegen/run-codegen.js";
+import { startHeadlessDevDisplay } from "../dev/headless.js";
 import { type DevWatch, runDevSupervisor } from "../dev/supervisor.js";
 import { splitApplicationArgs } from "../internal/application-args.js";
 import { entryArg } from "../internal/entry-arg.js";
@@ -14,12 +15,30 @@ const dev = defineCommand({
     },
     args: {
         ...entryArg,
+        headless: {
+            type: "boolean",
+            description: "Run on an isolated headless Wayland display",
+        },
+        size: {
+            type: "string",
+            description: "Headless display size as WIDTHxHEIGHT",
+        },
     },
     async run({ args }) {
+        if (args.size !== undefined && !args.headless) {
+            throw new Error("--size requires --headless");
+        }
+
         const { cwd, entry: entryPath } = await prepareProject(args, DEV_MODE);
         const watch: DevWatch | undefined = await resolveConfigWatch(cwd, DEV_MODE);
         const { applicationArgs } = splitApplicationArgs(process.argv.slice(2));
-        await runDevSupervisor({ entryPath, cwd, args: applicationArgs, watch });
+        const stopHeadless = args.headless ? await startHeadlessDevDisplay(args.size) : undefined;
+
+        try {
+            await runDevSupervisor({ entryPath, cwd, args: applicationArgs, watch });
+        } finally {
+            stopHeadless?.();
+        }
     },
 });
 

package/src/deploy/freedesktop/metainfo.ts

@@ -14,6 +14,54 @@ import { element, renderDocument, text, type XmlNode } from "./xml.js";
 
 const COMPONENT_TYPE = "desktop-application";
 const DESKTOP_SUFFIX = ".desktop";
+const COMPONENT_CLOSE = "</component>\n";
+const PROVIDES_CLOSE = "    </provides>\n";
+const PROVIDES_FRAGMENT = /^<provides\s*>([\s\S]*)<\/provides>$/;
+
+const normalizeExtraFragment = (fragment: string, index: number): string => {
+    const normalized = fragment.trim();
+
+    if (normalized.length === 0) {
+        throw new Error(`Cannot render deploy.metainfoExtra entry ${String(index + 1)}: it is empty`);
+    }
+
+    return normalized;
+};
+
+const indentFragment = (fragment: string, depth: number): string => {
+    const indentation = " ".repeat(depth * 4);
+
+    return fragment.split(/\r?\n/).map((line) => `${indentation}${line}`).join("\n");
+};
+
+const appendExtraFragments = (document: string, fragments: string[]): string => {
+    if (fragments.length === 0) {
+        return document;
+    }
+
+    let merged = document;
+    const componentFragments: string[] = [];
+
+    for (const [index, rawFragment] of fragments.entries()) {
+        const fragment = normalizeExtraFragment(rawFragment, index);
+        const provides = PROVIDES_FRAGMENT.exec(fragment)?.[1]?.trim();
+
+        if (provides === undefined) {
+            componentFragments.push(fragment);
+            continue;
+        }
+
+        merged = merged.replace(PROVIDES_CLOSE, () => `${indentFragment(provides, 2)}\n${PROVIDES_CLOSE}`);
+    }
+
+    if (componentFragments.length === 0) {
+        return merged;
+    }
+
+    const extra = componentFragments.map((fragment) => indentFragment(fragment, 1)).join("\n");
+
+    return merged.replace(COMPONENT_CLOSE, () => `${extra}\n${COMPONENT_CLOSE}`);
+};
 
 const launchable = (applicationId: string): XmlNode => ({
     tag: "launchable",
@@ -21,26 +69,30 @@ const launchable = (applicationId: string): XmlNode => ({
     text: `${applicationId}${DESKTOP_SUFFIX}`,
 });
 
-const renderMetainfo = (settings: DeploySettings): string =>
-    renderDocument(
-        element("component", { type: COMPONENT_TYPE }, [
-            text("id", settings.applicationId),
-            text("name", settings.name),
-            text("summary", settings.summary),
-            text("metadata_license", settings.metadataLicense),
-            text("project_license", settings.license),
-            ...developerSection(settings),
-            ...descriptionSection(settings),
-            launchable(settings.applicationId),
-            ...providesSection(settings),
-            ...listSection("categories", "category", settings.categories),
-            ...listSection("keywords", "keyword", settings.keywords),
-            ...urlsSection(settings),
-            ...screenshotsSection(settings),
-            ...releasesSection(settings),
-            ...contentRatingSection(settings),
-            ...brandingSection(settings),
-        ]),
-    );
+const metainfoRoot = (settings: DeploySettings): XmlNode =>
+    element("component", { type: COMPONENT_TYPE }, [
+        text("id", settings.applicationId),
+        text("name", settings.name),
+        text("summary", settings.summary),
+        text("metadata_license", settings.metadataLicense),
+        text("project_license", settings.license),
+        ...developerSection(settings),
+        ...descriptionSection(settings),
+        launchable(settings.applicationId),
+        ...providesSection(settings),
+        ...listSection("categories", "category", settings.categories),
+        ...listSection("keywords", "keyword", settings.keywords),
+        ...urlsSection(settings),
+        ...screenshotsSection(settings),
+        ...releasesSection(settings),
+        ...contentRatingSection(settings),
+        ...brandingSection(settings),
+    ]);
+
+const renderMetainfo = (settings: DeploySettings): string => {
+    const document = renderDocument(metainfoRoot(settings));
+
+    return appendExtraFragments(document, settings.deploy.metainfoExtra ?? []);
+};
 
 export { renderMetainfo };

package/src/deploy/nfpm/config.ts

@@ -1,5 +1,6 @@
 import type { DeployPayload, DeploySettings, StagedFile } from "../types.js";
 import { resolveDepends } from "../depends.js";
+import { glibcMinimumForFiles } from "../node-runtime/elf.js";
 import { groupForCategories, sectionForCategories } from "../settings/categories.js";
 import { nfpmContents } from "./contents.js";
 import { debDescription, rpmDescription } from "./description.js";
@@ -125,7 +126,9 @@ const descriptionFor = (settings: DeploySettings, packager: NfpmPackager): strin
 const renderNfpmConfig = (payload: DeployPayload, packager: NfpmPackager): NfpmConfig => {
     const settings = payload.settings;
     const isRpm = packager === "rpm";
-    const depends = resolveDepends(settings, payload.node?.glibcMinimum ?? null);
+    const staged = stagedFilesFor(payload, packager);
+    const glibcMinimum = glibcMinimumForFiles(staged.map((file) => file.abs));
+    const depends = resolveDepends(settings, glibcMinimum);
 
     return {
         name: packageNameFor(settings, packager),
@@ -146,7 +149,7 @@ const renderNfpmConfig = (payload: DeployPayload, packager: NfpmPackager): NfpmC
         ...relationsFor(settings, packager),
         ...optional("scripts", scriptsFor(settings)),
         [packager]: packagerSettings(settings, packager),
-        contents: nfpmContents(PREFIX, stagedFilesFor(payload, packager), isRpm),
+        contents: nfpmContents(PREFIX, staged, isRpm),
     };
 };
 

package/src/deploy/nfpm/contents.ts

@@ -13,10 +13,16 @@ const FILESYSTEM_OWNED_PREFIXES = new Set([
     "/usr",
     "/usr/bin",
     "/usr/lib",
+    "/usr/lib/systemd",
+    "/usr/lib/systemd/system",
+    "/usr/lib/systemd/user",
+    "/usr/libexec",
     "/usr/share",
     "/usr/share/applications",
     "/usr/share/dbus-1",
     "/usr/share/dbus-1/services",
+    "/usr/share/dbus-1/system-services",
+    "/usr/share/dbus-1/system.d",
     "/usr/share/doc",
     "/usr/share/glib-2.0",
     "/usr/share/glib-2.0/schemas",
@@ -25,6 +31,8 @@ const FILESYSTEM_OWNED_PREFIXES = new Set([
     "/usr/share/metainfo",
     "/usr/share/mime",
     "/usr/share/mime/packages",
+    "/usr/share/polkit-1",
+    "/usr/share/polkit-1/actions",
 ]);
 
 const ICON_THEME_PREFIX = "/usr/share/icons/";

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

@@ -1,4 +1,4 @@
-import { readFileSync } from "node:fs";
+import { closeSync, openSync, readFileSync, readSync } from "node:fs";
 
 type ElfSection = {
     name: string;
@@ -17,6 +17,7 @@ type DynamicEntry = {
 };
 
 const ELF_MAGIC = "ELF";
+const ELF_MAGIC_SIZE = 4;
 const CLASS_64 = 2;
 const LITTLE_ENDIAN = 1;
 const OFFSET_CLASS = 4;
@@ -35,8 +36,11 @@ const DYNAMIC_VALUE_OFFSET = 8;
 const GLIBC_VERSION = /GLIBC_(\d+)\.(\d+)/g;
 const VERSION_RADIX = 1000;
 
+const hasElfMagic = (buffer: Buffer): boolean =>
+    buffer.length >= OFFSET_CLASS && buffer.subarray(0, 4).toString("latin1") === ELF_MAGIC;
+
 const assertElf64 = (buffer: Buffer, path: string): void => {
-    if (buffer.length < OFFSET_SECTION_NAME_INDEX || buffer.subarray(0, 4).toString("latin1") !== ELF_MAGIC) {
+    if (buffer.length < OFFSET_SECTION_NAME_INDEX || !hasElfMagic(buffer)) {
         throw new Error(`Cannot read ${path}: it is not an ELF binary`);
     }
 
@@ -130,8 +134,7 @@ const readGlibcMinimum = (strings: Buffer): string | null => {
 const stringTable = (buffer: Buffer, dynstr: ElfSection | undefined): Buffer =>
     dynstr === undefined ? Buffer.alloc(0) : buffer.subarray(dynstr.offset, dynstr.offset + dynstr.size);
 
-const readElfInfo = (path: string): ElfInfo => {
-    const buffer = readFileSync(path);
+const readElfBuffer = (buffer: Buffer, path: string): ElfInfo => {
     assertElf64(buffer, path);
     const sections = readSections(buffer);
     const strings = stringTable(buffer, sectionFor(sections, ".dynstr"));
@@ -142,4 +145,39 @@ const readElfInfo = (path: string): ElfInfo => {
     };
 };
 
-export { type ElfInfo, readElfInfo };
+const readElfInfo = (path: string): ElfInfo => readElfBuffer(readFileSync(path), path);
+
+const readFilePrefix = (descriptor: number, size: number): Buffer => {
+    const buffer = Buffer.alloc(size);
+    const bytesRead = readSync(descriptor, buffer, 0, size, 0);
+
+    return buffer.subarray(0, bytesRead);
+};
+
+const readOptionalElfInfo = (path: string): ElfInfo | null => {
+    const descriptor = openSync(path, "r");
+
+    try {
+        const prefix = readFilePrefix(descriptor, ELF_MAGIC_SIZE);
+
+        return hasElfMagic(prefix) ? readElfBuffer(readFileSync(descriptor), path) : null;
+    } finally {
+        closeSync(descriptor);
+    }
+};
+
+const glibcMinimumForFiles = (paths: Iterable<string>): string | null => {
+    const versions: number[][] = [];
+
+    for (const path of paths) {
+        const minimum = readOptionalElfInfo(path)?.glibcMinimum;
+
+        if (minimum !== undefined && minimum !== null) {
+            versions.push(minimum.split(".").map(Number));
+        }
+    }
+
+    return formatVersion(highestVersion(versions));
+};
+
+export { type ElfInfo, glibcMinimumForFiles, readElfInfo };

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

@@ -1,4 +1,6 @@
+import { MINIMUM_NODE_VERSION } from "@gtkx/config/internal";
 import { info, tryResolveExecutable } from "@gtkx/utils";
+import { execFileSync } from "node:child_process";
 import { chmodSync, copyFileSync, mkdirSync, statSync } from "node:fs";
 import { join, resolve } from "node:path";
 import type { DeploySettings, NodeRuntime } from "../types.js";
@@ -13,13 +15,92 @@ type StagedRuntime = {
     licenseFile: string | null;
 };
 
+type NodeSource = "download" | "host" | "path";
+
 const BYTES_PER_MIB = 1024 * 1024;
 const EXECUTABLE_MODE = 0o755;
 const NODE_FILENAME = "node";
+const NODE_VERSION_PATTERN = /^v?(\d+)\.(\d+)\.(\d+)$/;
+const VERSION_PROBE_TIMEOUT_MS = 10_000;
+const VERSION_PROBE_MAX_BUFFER = 1024;
+
+const nodeSourceFor = (settings: DeploySettings): NodeSource => settings.deploy.node?.source ?? "download";
+
+const parseNodeVersion = (value: string, subject: string): { parts: number[]; version: string } => {
+    const match = NODE_VERSION_PATTERN.exec(value.trim());
+
+    if (match === null) {
+        throw new Error(`Cannot determine the Node.js version for ${subject}: expected a version such as 26.7.0`);
+    }
+
+    const parts = match.slice(1).map(Number);
+
+    return { parts, version: parts.map(String).join(".") };
+};
+
+const compareVersions = (left: number[], right: number[]): number => {
+    for (let index = 0; index < Math.max(left.length, right.length); index += 1) {
+        const difference = (left[index] ?? 0) - (right[index] ?? 0);
+
+        if (difference !== 0) {
+            return difference;
+        }
+    }
+
+    return 0;
+};
+
+const supportedNodeVersion = (value: string, subject: string): string => {
+    const parsed = parseNodeVersion(value, subject);
+    const minimum = parseNodeVersion(MINIMUM_NODE_VERSION, "GTKX");
+
+    if (compareVersions(parsed.parts, minimum.parts) < 0) {
+        throw new Error(
+            `Cannot bundle Node.js ${parsed.version} for ${subject}: GTKX requires ${MINIMUM_NODE_VERSION} or newer`,
+        );
+    }
+
+    return parsed.version;
+};
+
+const probeNodeVersion = (path: string): string => {
+    try {
+        const output = execFileSync(path, ["--version"], {
+            encoding: "utf8",
+            env: { ...process.env, NODE_OPTIONS: "" },
+            maxBuffer: VERSION_PROBE_MAX_BUFFER,
+            timeout: VERSION_PROBE_TIMEOUT_MS,
+        });
+
+        return supportedNodeVersion(output, path);
+    } catch (error) {
+        if (error instanceof Error && error.message.startsWith("Cannot bundle Node.js")) {
+            throw error;
+        }
+
+        throw new Error(`Cannot determine the Node.js version from ${path}`, { cause: error });
+    }
+};
+
+const assertExpectedVersion = (configured: string | undefined, actual: string, source: NodeSource): string => {
+    if (configured === undefined) {
+        return actual;
+    }
+
+    const expected = parseNodeVersion(configured, `deploy.node.source: "${source}"`).version;
+
+    if (expected !== actual) {
+        throw new Error(
+            `The Node.js runtime from deploy.node.source "${source}" is ${actual}, not the configured ${expected}`,
+        );
+    }
+
+    return actual;
+};
 
 const sourcePathFor = (settings: DeploySettings): string => {
     const node = settings.deploy.node ?? {};
-    const source = node.source ?? "download";
+    const source = nodeSourceFor(settings);
 
     if (source === "host") {
         return process.execPath;
@@ -32,6 +113,21 @@ const sourcePathFor = (settings: DeploySettings): string => {
     return resolve(settings.paths.root, node.path);
 };
 
+const resolveNodeVersion = (settings: DeploySettings): string => {
+    const node = settings.deploy.node ?? {};
+    const source = nodeSourceFor(settings);
+
+    if (source === "download") {
+        return supportedNodeVersion(node.version ?? MINIMUM_NODE_VERSION, 'deploy.node.source: "download"');
+    }
+
+    const actual = source === "host"
+        ? supportedNodeVersion(process.versions.node, 'deploy.node.source: "host"')
+        : probeNodeVersion(sourcePathFor(settings));
+
+    return assertExpectedVersion(node.version, actual, source);
+};
+
 const didStripBinary = (path: string): boolean => {
     if (tryResolveExecutable("strip") === undefined) {
         return false;
@@ -60,7 +156,11 @@ const stageDownloadedNode = async (settings: DeploySettings, version: string): P
     return downloaded;
 };
 
-const stageFromSource = async (settings: DeploySettings, version: string, source: string): Promise<StagedRuntime> => {
+const stageFromSource = async (
+    settings: DeploySettings,
+    version: string,
+    source: NodeSource,
+): Promise<StagedRuntime> => {
     if (source === "download") {
         return stageDownloadedNode(settings, version);
     }
@@ -73,8 +173,8 @@ const stageFromSource = async (settings: DeploySettings, version: string, source
 
 const resolveNodeRuntime = async (settings: DeploySettings): Promise<NodeRuntime> => {
     const node = settings.deploy.node ?? {};
-    const source = node.source ?? "download";
-    const version = node.version ?? process.versions.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);
@@ -83,4 +183,4 @@ const resolveNodeRuntime = async (settings: DeploySettings): Promise<NodeRuntime
     return { ...staged, version, glibcMinimum: elf.glibcMinimum, isStripped };
 };
 
-export { resolveNodeRuntime, sourcePathFor };
+export { resolveNodeRuntime, resolveNodeVersion, sourcePathFor };

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

@@ -1,6 +1,6 @@
 import { warn } from "@gtkx/utils";
 import type { DeploySettings, NodeRuntime, NoticeSection } from "../types.js";
-import { sourcePathFor } from "../node-runtime/index.js";
+import { resolveNodeVersion, sourcePathFor } from "../node-runtime/index.js";
 import { licenseBesideNode } from "../node-runtime/license.js";
 import { NODE_FILENAME } from "../payload/launcher.js";
 import { nodeLicenseDestination } from "../payload/stage.js";
@@ -32,7 +32,7 @@ const MISSING_LICENSE =
 const isSourceMode = (settings: DeploySettings): boolean => settings.deploy.flatpak?.mode === "source";
 
 const versionFor = (settings: DeploySettings, node: NodeRuntime | null): string =>
-    node?.version ?? settings.deploy.node?.version ?? process.versions.node;
+    node?.version ?? resolveNodeVersion(settings);
 
 const licenseFileFor = (settings: DeploySettings, node: NodeRuntime | null): string | null => {
     if (node !== null) {

package/src/deploy/payload/launcher.ts

@@ -2,6 +2,8 @@ import type { DeploySettings } from "../types.js";
 import { BUNDLE_FILENAME } from "../../vite-plugins/esm-extension.js";
 
 const NODE_FILENAME = "node";
+const SHELL_SINGLE_QUOTE = "'";
+const SHELL_SINGLE_QUOTE_ESCAPE = "'\"'\"'";
 
 const compileCacheLines = (binaryName: string): string[] => [
     "cache_home=${XDG_CACHE_HOME:-${HOME:-/tmp}/.cache}",
@@ -9,6 +11,22 @@ const compileCacheLines = (binaryName: string): string[] => [
     "export NODE_COMPILE_CACHE",
 ];
 
+const shellQuote = (value: string): string =>
+    SHELL_SINGLE_QUOTE + value.split(SHELL_SINGLE_QUOTE).join(SHELL_SINGLE_QUOTE_ESCAPE) + SHELL_SINGLE_QUOTE;
+
+const launcherEnvLines = (settings: DeploySettings): string[] =>
+    Object.entries(settings.deploy.launcherEnv ?? {})
+        .toSorted(([left], [right]) => left.localeCompare(right))
+        .map(([name, value]) => `export ${name}=${shellQuote(value)}`);
+
+const launcherCommand = (settings: DeploySettings, libDir: string): string =>
+    [
+        `"${libDir}/${NODE_FILENAME}"`,
+        ...(settings.deploy.nodeFlags ?? []).map((flag) => shellQuote(flag)),
+        `"${libDir}/${BUNDLE_FILENAME}"`,
+        '"$@"',
+    ].join(" ");
+
 const renderLauncher = (settings: DeploySettings): string => {
     const libDir = `$prefix/lib/${settings.binaryName}`;
     const shouldUseCompileCache = settings.deploy.node?.shouldUseCompileCache !== false;
@@ -21,7 +39,8 @@ const renderLauncher = (settings: DeploySettings): string => {
         'GTKX_LOCALE_DIR="$prefix/share/locale"',
         "export GTKX_LOCALE_DIR",
         ...(shouldUseCompileCache ? compileCacheLines(settings.binaryName) : []),
-        `exec "${libDir}/${NODE_FILENAME}" "${libDir}/${BUNDLE_FILENAME}" "$@"`,
+        ...launcherEnvLines(settings),
+        `exec ${launcherCommand(settings, libDir)}`,
         "",
     ].join("\n");
 };

package/src/deploy/payload/stage.ts

@@ -108,10 +108,10 @@ const stagePayload = ({ settings, node, metadata }: StageRequest): StagedFile[]
         ...stageNodeBinary(settings, root, node),
         ...stageRuntimeFiles(settings, root),
         ...stageCatalogs(settings, root),
+        ...stageExtraFiles(settings, root),
         ...stageMetadata(settings, root, metadata),
         ...stageIcons(settings, root),
         ...stageSchemas(settings, root),
-        ...stageExtraFiles(settings, root),
     ]);
 };