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

package/src/codegen/run-codegen.ts

@@ -86,6 +86,7 @@ const codegenOptions = ({ store, libraries, girPath, elements }: CodegenOptionsI
         storeDir: store.giStoreDir,
         linkDir: store.giLinkDir,
         version: store.runtimeVersion,
+        owner: store.owner,
     },
     jsx:
         store.react === null
@@ -94,6 +95,7 @@ const codegenOptions = ({ store, libraries, girPath, elements }: CodegenOptionsI
                     storeDir: store.jsxStoreDir,
                     linkDir: store.jsxLinkDir,
                     version: store.react.version,
+                    owner: store.owner,
                 },
     userComponents: resolveElementComponents(elements),
     userProps: resolveElementProps(elements),
@@ -111,14 +113,6 @@ const disabledCodegenResult = (configFile: string): RunCodegenResult => ({
     libraries: [],
 });
 
-const clearGeneratedStores = (store: CodegenStore): void => {
-    removeStores(
-        store.react === null
-            ? [store.giStoreDir, store.giLinkDir]
-            : [store.giStoreDir, store.giLinkDir, store.jsxStoreDir, store.jsxLinkDir],
-    );
-};
-
 const prepareCodegen = (options: RunCodegenOptions, cwd: string, config: Config): PreparedCodegen => {
     const { girPath, libraries, store } = options.inputs ?? resolveCodegenInputs(cwd, config);
 
@@ -148,10 +142,6 @@ const runCodegen = async (options: RunCodegenOptions = {}): Promise<RunCodegenRe
 
     const { girPath, libraries, store, isForced } = prepareCodegen(options, cwd, config);
 
-    if (options.isForced) {
-        clearGeneratedStores(store);
-    }
-
     const result = await runCodegenCore({
         ...codegenOptions({ store, libraries, girPath, elements: config.elements }),
         isForced,

package/src/codegen/store-resolver.ts

@@ -1,6 +1,6 @@
 import { resolveStore } from "@gtkx/codegen";
 import { type Config, loadConfig } from "@gtkx/config";
-import { existsSync } from "node:fs";
+import { existsSync, realpathSync } from "node:fs";
 import { createRequire } from "node:module";
 import { dirname, join } from "node:path";
 import { pathToFileURL } from "node:url";
@@ -11,6 +11,7 @@ type CodegenStore = {
     jsxStoreDir: string;
     jsxLinkDir: string;
     runtimeVersion: string;
+    owner: string;
     react: CodegenReactPackage | null;
 };
 
@@ -54,6 +55,7 @@ const resolveCodegenStore = (dir: string): CodegenStore => {
         jsxStoreDir: store.jsx?.storeDir ?? siblingStore(store.gi.storeDir),
         jsxLinkDir: store.jsx?.linkDir ?? siblingStore(store.gi.linkDir),
         runtimeVersion: store.gi.version,
+        owner: store.gi.owner ?? realpathSync(dir),
         react:
             hasReactRuntime && store.jsx !== null
                 ? { version: store.jsx.version }

package/src/commands/dev.ts

@@ -1,9 +1,11 @@
+import { armParentDeath } from "@gtkx/native/internal";
 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 +17,7 @@ const dev = defineCommand({
     },
     args: {
         ...entryArg,
+        ...configArg,
         headless: {
             type: "boolean",
             description: "Run on an isolated headless Wayland display",
@@ -25,17 +28,29 @@ const dev = defineCommand({
         },
     },
     async run({ args }) {
+        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 } = await prepareProject(args, DEV_MODE);
+        const watch: DevWatch | undefined = await resolveConfigWatch(cwd, DEV_MODE, configFile);
         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`",
@@ -64,11 +66,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 +84,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 +123,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/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);
 };
 

package/src/dev/supervisor.ts

@@ -3,7 +3,7 @@ import { fork as nodeFork } from "node:child_process";
 import { type FSWatcher, watch as watchFs } from "node:fs";
 import { basename, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
-import { DEV_ENTRY_ENV } from "./entry-env.js";
+import { DEV_CONFIG_ENV, DEV_ENTRY_ENV } from "./entry-env.js";
 
 type SupervisedChild = {
     killed: boolean;
@@ -24,6 +24,7 @@ type DevWatch = {
 type SupervisorState = {
     runnerPath: string;
     entryPath: string;
+    configFile: string;
     cwd: string;
     args: string[];
     watch: DevWatch | undefined;
@@ -37,6 +38,7 @@ type SupervisorState = {
 
 type DevSupervisorOptions = {
     entryPath: string;
+    configFile: string;
     cwd: string;
     args?: string[] | undefined;
     watch?: DevWatch | undefined;
@@ -128,7 +130,7 @@ const launch = (state: SupervisorState): void => {
     const child = state.fork(
         state.runnerPath,
         state.args,
-        { ...process.env, [DEV_ENTRY_ENV]: state.entryPath },
+        { ...process.env, [DEV_CONFIG_ENV]: state.configFile, [DEV_ENTRY_ENV]: state.entryPath },
         state.cwd,
     );
 
@@ -286,11 +288,12 @@ const installShutdown = (state: SupervisorState): void => {
 };
 
 const runDevSupervisor = async (options: DevSupervisorOptions): Promise<never> => {
-    const { entryPath, cwd, args = [], watch, fork = defaultForkRunner } = options;
+    const { entryPath, configFile, cwd, args = [], watch, fork = defaultForkRunner } = options;
 
     const state: SupervisorState = {
         runnerPath: fileURLToPath(DEV_RUNNER_URL),
         entryPath,
+        configFile,
         cwd,
         args,
         watch,

package/src/i18n/catalogs.ts

@@ -133,6 +133,7 @@ const initializeCatalog = (catalog: Catalog, template: string, output: string):
             `--input=${template}`,
             `--output-file=${output}`,
         ],
+        options: { stdio: "pipe" },
         target: catalog.path,
     });
 };