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

package/src/commands/dev.ts

@@ -1,9 +1,12 @@
+import { armParentDeath } from "@gtkx/native/internal";
+import { reapStaleHeadlessDisplays } from "@gtkx/vitest/headless";
 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";
+import { configArg, entryArg } from "../internal/entry-arg.js";
+import { getInitialProcessGroupOwner, initialParentId } from "../internal/parent-process.js";
 import { prepareProject } from "../internal/prepare-project.js";
 
 const DEV_MODE = "development";
@@ -15,6 +18,7 @@ const dev = defineCommand({
     },
     args: {
         ...entryArg,
+        ...configArg,
         headless: {
             type: "boolean",
             description: "Run on an isolated headless Wayland display",
@@ -25,17 +29,35 @@ const dev = defineCommand({
         },
     },
     async run({ args }) {
+        reapStaleHeadlessDisplays();
+        const initialProcessGroupOwner = getInitialProcessGroupOwner();
+
+        if (
+            !armParentDeath(
+                initialParentId,
+                initialProcessGroupOwner?.pid,
+                initialProcessGroupOwner?.startTime,
+            )
+        ) {
+            throw new Error("The process that launched gtkx dev exited during startup");
+        }
+
         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 { cwd, entry: entryPath, configFile, configDependencies } = await prepareProject(args, DEV_MODE);
+        const watch: DevWatch | undefined = await resolveConfigWatch(
+            cwd,
+            DEV_MODE,
+            configFile,
+            configDependencies,
+        );
         const { applicationArgs } = splitApplicationArgs(process.argv.slice(2));
         const stopHeadless = args.headless ? await startHeadlessDevDisplay(args.size) : undefined;
 
         try {
-            await runDevSupervisor({ entryPath, cwd, args: applicationArgs, watch });
+            await runDevSupervisor({ entryPath, cwd, configFile, args: applicationArgs, watch });
         } finally {
             stopHeadless?.();
         }

package/src/commands/docs.ts

@@ -68,6 +68,7 @@ const docs = defineCommand({
             outDir,
             basePath: args["base-path"],
             props: builtin.props,
+            acceptedChildTypes: builtin.acceptedChildTypes,
             omittedProps: mergeOmittedProps(builtin.omittedProps, resolveOmittedProps(config.elements)),
             isForced: args.force,
         });

package/src/deploy/freedesktop/validate.ts

@@ -12,6 +12,7 @@ type MetainfoResult = {
     status: number;
     errors: string[];
     warnings: string[];
+    rules: string[];
     areWarningsFatal: boolean;
 };
 
@@ -25,6 +26,7 @@ const DIAGNOSTIC = /^(?<severity>[EIPW]): \S+ (?<rule>[\w-]+)/;
 const ERROR_SEVERITY = "E";
 const WARNING_SEVERITY = "W";
 const INFO_SEVERITY = "I";
+const FATAL_WARNING_RULES: Set<string> = new Set(["unknown-tag"]);
 
 const REMEDY_FOR_RULE: Record<string, string> = {
     "component-summary-missing": "set `deploy.summary`",
@@ -33,6 +35,7 @@ const REMEDY_FOR_RULE: Record<string, string> = {
     "metainfo-legacy-path": "this file is generated; report it as a gtkx bug",
     "summary-has-dot-suffix": "drop the trailing period from `deploy.summary`",
     "summary-too-long": "shorten `deploy.summary`",
+    "unknown-tag": "remove the unsupported `deploy.metainfoExtra` element or use a `<custom>` value",
     "url-homepage-missing": "set `deploy.homepage`, or `homepage` in package.json",
 };
 
@@ -64,11 +67,15 @@ const remedyLines = (rules: string[]): string[] => {
 const invalid = (subject: string, output: string, rules: string[]): Error =>
     new Error([`${subject} is not valid:`, output.length > 0 ? output : "no output", ...remedyLines(rules)].join("\n"));
 
-const isFatalResult = ({ status, errors, warnings, areWarningsFatal }: MetainfoResult): boolean => {
+const isFatalResult = ({ status, errors, warnings, rules, areWarningsFatal }: MetainfoResult): boolean => {
     if (errors.length > 0) {
         return true;
     }
 
+    if (rules.some((rule) => FATAL_WARNING_RULES.has(rule))) {
+        return true;
+    }
+
     if (areWarningsFatal && warnings.length > 0) {
         return true;
     }
@@ -78,7 +85,7 @@ const isFatalResult = ({ status, errors, warnings, areWarningsFatal }: MetainfoR
 
 const assertNotFatal = (result: MetainfoResult): void => {
     if (isFatalResult(result)) {
-        throw invalid(result.subject, result.output, [...result.errors, ...result.warnings]);
+        throw invalid(result.subject, result.output, result.rules);
     }
 };
 
@@ -117,8 +124,10 @@ const validateMetainfo = (path: string, areWarningsFatal: boolean): void => {
 
     const errors = rulesIn(output, [ERROR_SEVERITY]);
     const warnings = rulesIn(output, [WARNING_SEVERITY]);
-    assertNotFatal({ subject, output, status, errors, warnings, areWarningsFatal });
-    reportDiagnostics(subject, [...warnings, ...rulesIn(output, [INFO_SEVERITY])]);
+    const infos = rulesIn(output, [INFO_SEVERITY]);
+    const rules = [...errors, ...warnings, ...infos];
+    assertNotFatal({ subject, output, status, errors, warnings, rules, areWarningsFatal });
+    reportDiagnostics(subject, [...warnings, ...infos]);
 };
 
 export { validateDesktopEntry, validateMetainfo };

package/src/deploy/nfpm/config.ts

@@ -114,6 +114,9 @@ const stagedFilesFor = (payload: DeployPayload, packager: NfpmPackager): StagedF
     ...payload.overlays[packager],
 ];
 
+const glibcMinimumForPackage = (payload: DeployPayload, packager: NfpmPackager): string | null =>
+    glibcMinimumForFiles(stagedFilesFor(payload, packager).map((file) => file.abs));
+
 const packagerSettings = (settings: DeploySettings, packager: NfpmPackager): NfpmConfig =>
     packager === "rpm" ? rpmSettings(settings) : debSettings(settings);
 
@@ -123,11 +126,14 @@ const releaseFor = (settings: DeploySettings, packager: NfpmPackager): string =>
 const descriptionFor = (settings: DeploySettings, packager: NfpmPackager): string =>
     packager === "rpm" ? rpmDescription(settings) : debDescription(settings);
 
-const renderNfpmConfig = (payload: DeployPayload, packager: NfpmPackager): NfpmConfig => {
+const renderNfpmConfig = (
+    payload: DeployPayload,
+    packager: NfpmPackager,
+    glibcMinimum: string | null,
+): NfpmConfig => {
     const settings = payload.settings;
     const isRpm = packager === "rpm";
     const staged = stagedFilesFor(payload, packager);
-    const glibcMinimum = glibcMinimumForFiles(staged.map((file) => file.abs));
     const depends = resolveDepends(settings, glibcMinimum);
 
     return {
@@ -153,4 +159,4 @@ const renderNfpmConfig = (payload: DeployPayload, packager: NfpmPackager): NfpmC
     };
 };
 
-export { type NfpmPackager, packageNameFor, renderNfpmConfig };
+export { glibcMinimumForPackage, type NfpmPackager, packageNameFor, renderNfpmConfig };

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

@@ -178,7 +178,8 @@ const resolveNodeRuntime = async (settings: DeploySettings): Promise<NodeRuntime
     const staged = await stageFromSource(settings, version, source);
     const isStripped = node.shouldStrip === false ? false : didStripBinary(staged.path);
     const elf = readElfInfo(staged.path);
-    info(`Bundled Node.js v${version} (${megabytes(staged.path)} MiB, glibc >= ${elf.glibcMinimum ?? "unknown"})`);
+    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 };
 };

package/src/deploy/payload/stage.ts

@@ -1,4 +1,4 @@
-import { sortStringsBy } from "@gtkx/utils";
+import { sortStringsBy, warn } from "@gtkx/utils";
 import { existsSync, rmSync } from "node:fs";
 import { join, resolve } from "node:path";
 import type { DeploySettings, DeployTargetName, NodeRuntime, NoticeSection, StagedFile } from "../types.js";
@@ -82,9 +82,48 @@ const stageMetadata = (settings: DeploySettings, root: string, metadata: StagedM
         : [writeInto(root, join(SHARE_MIME_PACKAGES, `${settings.applicationId}.xml`), metadata.mimePackage)]),
 ];
 
-const stageExtraFiles = (settings: DeploySettings, root: string): StagedFile[] =>
+const generatedMetadataKind = (
+    settings: DeploySettings,
+    metadata: StagedMetadata,
+    destination: string,
+): string | null => {
+    if (destination === join(SHARE_APPLICATIONS, `${settings.applicationId}.desktop`)) {
+        return "desktop entry";
+    }
+
+    if (destination === join(SHARE_METAINFO, `${settings.applicationId}.metainfo.xml`)) {
+        return "metainfo";
+    }
+
+    if (
+        metadata.mimePackage !== null &&
+        destination === join(SHARE_MIME_PACKAGES, `${settings.applicationId}.xml`)
+    ) {
+        return "MIME package";
+    }
+
+    return null;
+};
+
+const warnMetadataCollision = (
+    settings: DeploySettings,
+    metadata: StagedMetadata,
+    file: DeploySettings["extraFiles"][number],
+): void => {
+    const kind = generatedMetadataKind(settings, metadata, file.destination);
+
+    if (kind !== null) {
+        warn(
+            `extraFiles source "${file.source}" targeting "${file.destination}" is overridden by the ` +
+            `GTKX-generated ${kind}`,
+        );
+    }
+};
+
+const stageExtraFiles = (settings: DeploySettings, root: string, metadata: StagedMetadata): StagedFile[] =>
     settings.extraFiles.map((file) => {
         const source = resolve(settings.paths.root, file.source);
+        warnMetadataCollision(settings, metadata, file);
 
         return copyInto(root, file.destination, source, file.mode ?? executableModeFor(source));
     });
@@ -108,7 +147,7 @@ const stagePayload = ({ settings, node, metadata }: StageRequest): StagedFile[]
         ...stageNodeBinary(settings, root, node),
         ...stageRuntimeFiles(settings, root),
         ...stageCatalogs(settings, root),
-        ...stageExtraFiles(settings, root),
+        ...stageExtraFiles(settings, root, metadata),
         ...stageMetadata(settings, root, metadata),
         ...stageIcons(settings, root),
         ...stageSchemas(settings, root),

package/src/deploy/settings/extra-files.ts

@@ -1,5 +1,5 @@
 import { statSync } from "node:fs";
-import { resolve } from "node:path";
+import { normalize, resolve } from "node:path";
 import type { DeployConfig, DeployExtraFile } from "../types.js";
 
 type ExtraFiles = NonNullable<DeployConfig["extraFiles"]>;
@@ -22,13 +22,15 @@ const assertSourceFile = (root: string, file: DeployExtraFile): void => {
 };
 
 const resolveExtraFile = (destination: string, entry: ExtraFileEntry): DeployExtraFile => {
+    const normalizedDestination = normalize(destination);
+
     if (typeof entry === "string") {
-        return { destination, source: entry, mode: null };
+        return { destination: normalizedDestination, source: entry, mode: null };
     }
 
     const mode = entry.mode === undefined ? null : Number.parseInt(entry.mode, OCTAL_RADIX);
 
-    return { destination, source: entry.source, mode };
+    return { destination: normalizedDestination, source: entry.source, mode };
 };
 
 const resolveExtraFiles = (root: string, deploy: DeployConfig): DeployExtraFile[] => {

package/src/deploy/targets/nfpm-target.ts

@@ -1,7 +1,8 @@
+import { info } from "@gtkx/utils";
 import { join } from "node:path";
 import { stringify } from "yaml";
 import type { DeployArtifact, DeployManifest, DeployPayload, DeployTarget } from "../types.js";
-import { type NfpmPackager, renderNfpmConfig } from "../nfpm/config.js";
+import { glibcMinimumForPackage, type NfpmPackager, renderNfpmConfig } from "../nfpm/config.js";
 import { packWithNfpm } from "../nfpm/pack.js";
 import { TAR } from "../tools.js";
 
@@ -11,12 +12,18 @@ const PREFIX = "/usr";
 const manifestPathFor = (payload: DeployPayload, packager: NfpmPackager): string =>
     join(payload.settings.paths.targets, packager, MANIFEST_FILENAME);
 
-const renderManifests = (payload: DeployPayload, packager: NfpmPackager): DeployManifest[] => [
-    {
+const renderManifests = (payload: DeployPayload, packager: NfpmPackager): DeployManifest[] => {
+    const glibcMinimum = glibcMinimumForPackage(payload, packager);
+
+    if (glibcMinimum !== null) {
+        info(`${packager} package requires glibc >= ${glibcMinimum}`);
+    }
+
+    return [{
         path: manifestPathFor(payload, packager),
-        contents: stringify(renderNfpmConfig(payload, packager), { lineWidth: 0 }),
-    },
-];
+        contents: stringify(renderNfpmConfig(payload, packager, glibcMinimum), { lineWidth: 0 }),
+    }];
+};
 
 const packPackage = async (payload: DeployPayload, packager: NfpmPackager): Promise<DeployArtifact[]> => [
     await packWithNfpm(payload, packager, manifestPathFor(payload, packager)),

package/src/dev/entry-env.ts

@@ -1,3 +1,4 @@
 const DEV_ENTRY_ENV = "GTKX_DEV_ENTRY";
+const DEV_CONFIG_ENV = "GTKX_DEV_CONFIG";
 
-export { DEV_ENTRY_ENV };
+export { DEV_CONFIG_ENV, DEV_ENTRY_ENV };

package/src/dev/runner-deps.ts

@@ -43,11 +43,11 @@ const waitForApplicationId = async (timeoutMs: number, shouldKeepWaiting: () =>
 
 const readFileRevision = (path: string): Promise<string> => readFile(path, "utf8");
 
-const defaultDevRunnerDeps = (): DevRunnerDeps => ({
+const defaultDevRunnerDeps = (configFile: string): DevRunnerDeps => ({
     createServer,
     waitForApplicationId,
     getConfiguredApplicationId: async (root: string) => {
-        const loaded = await loadConfig(root, { mode: DEV_MODE });
+        const loaded = await loadConfig(root, { mode: DEV_MODE, configFile });
 
         return loaded.config.applicationId;
     },
@@ -87,7 +87,7 @@ const defaultDevRunnerDeps = (): DevRunnerDeps => ({
     staleExportName,
     readFileRevision,
     plugins: (entryPath) => [
-        ...gtkxVitePlugins({ mode: DEV_MODE, entryPath }),
+        ...gtkxVitePlugins({ mode: DEV_MODE, entryPath, configFile }),
         ...gtkxFastRefresh(),
         gtkxReactDomPrebundle(),
     ],

package/src/dev/runner-main.ts

@@ -1,7 +1,7 @@
 import { loadConfig } from "@gtkx/config";
 import { error } from "@gtkx/utils";
 import { resolve } from "node:path";
-import { DEV_ENTRY_ENV } from "./entry-env.js";
+import { DEV_CONFIG_ENV, DEV_ENTRY_ENV } from "./entry-env.js";
 import { prepareDevIconDir } from "./icon-dir.js";
 import { prepareDevLocaleDir } from "./locale-dir.js";
 import { createDevRunner } from "./runner.js";
@@ -22,13 +22,20 @@ const main = async (): Promise<void> => {
         process.exit(1);
     }
 
-    const { config, root } = await loadConfig(cwd, { mode: "development" });
+    const configFile = process.env[DEV_CONFIG_ENV];
+
+    if (!configFile) {
+        error(`Missing ${DEV_CONFIG_ENV}`);
+        process.exit(1);
+    }
+
+    const { config, root } = await loadConfig(cwd, { mode: "development", configFile });
     prepareDevLocaleDir(root, config.applicationId);
     prepareDevSchemaDir(root);
     prepareDevIconDir(root, config.applicationId, config.applicationIcon);
     const entryPath = resolve(cwd, entryArg);
     const { defaultDevRunnerDeps } = await import("./runner-deps.js");
-    const runner = createDevRunner(defaultDevRunnerDeps());
+    const runner = createDevRunner(defaultDevRunnerDeps(configFile));
     await runner.run(entryPath);
 };