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

package/src/internal/parent-process.ts

@@ -0,0 +1,110 @@
+import { readFileSync } from "node:fs";
+
+type ProcessIdentity = {
+    pid: number;
+    parentId: number;
+    processGroupId: number;
+    startTime: string;
+    state: string;
+};
+
+type ProcessGroupOwner = Pick<ProcessIdentity, "pid" | "startTime">;
+type ProcessGroupOwnerCapture = { isCaptured: true; owner: ProcessGroupOwner | undefined } |
+    { isCaptured: false; error: Error };
+
+const initialParentId = process.ppid;
+const STOPPED_PROCESS_STATES: Set<string> = new Set(["Z", "X", "x"]);
+
+const processIdentity = (pid: number): ProcessIdentity => {
+    const stat = readFileSync(`/proc/${String(pid)}/stat`, "utf8");
+    const fields = stat.slice(stat.lastIndexOf(") ") + 2).split(" ");
+    const state = fields[0];
+    const parentId = Number(fields[1]);
+    const processGroupId = Number(fields[2]);
+    const startTime = fields[19];
+
+    if (
+        state === undefined ||
+        startTime === undefined ||
+        !Number.isSafeInteger(parentId) ||
+        !Number.isSafeInteger(processGroupId)
+    ) {
+        throw new Error(`Failed to identify process ${String(pid)}`);
+    }
+
+    return { pid, parentId, processGroupId, startTime, state };
+};
+
+const ancestorFor = (process: ProcessIdentity, ancestorId: number): ProcessIdentity | undefined => {
+    let current = process;
+
+    while (current.parentId > 1) {
+        const parent = processIdentity(current.parentId);
+
+        if (parent.pid === ancestorId) {
+            return parent;
+        }
+
+        current = parent;
+    }
+
+    return undefined;
+};
+
+const processGroupOwner = (process: ProcessIdentity): ProcessGroupOwner => {
+    if (process.processGroupId !== process.pid || STOPPED_PROCESS_STATES.has(process.state)) {
+        throw new Error(`Failed to identify process group ${String(process.pid)}`);
+    }
+
+    return { pid: process.pid, startTime: process.startTime };
+};
+
+const processGroupOwnerFor = (process: ProcessIdentity): ProcessGroupOwner | undefined => {
+    if (process.processGroupId === process.pid) {
+        return undefined;
+    }
+
+    const groupLeader = processGroupOwner(processIdentity(process.processGroupId));
+    const owner = ancestorFor(process, groupLeader.pid);
+
+    if (owner !== undefined) {
+        return groupLeader;
+    }
+
+    const currentGroupLeader = processGroupOwner(processIdentity(groupLeader.pid));
+
+    if (currentGroupLeader.startTime !== groupLeader.startTime) {
+        throw new Error(`Failed to identify process group ${String(groupLeader.pid)}`);
+    }
+
+    return undefined;
+};
+
+const captureProcessGroupOwner = (): ProcessGroupOwnerCapture => {
+    try {
+        const initialProcess = processIdentity(process.pid);
+
+        if (initialProcess.parentId !== initialParentId) {
+            throw new Error("The process that launched GTKX exited during startup");
+        }
+
+        return { isCaptured: true, owner: processGroupOwnerFor(initialProcess) };
+    } catch (error) {
+        return {
+            isCaptured: false,
+            error: error instanceof Error ? error : new Error("Failed to identify the process that launched GTKX"),
+        };
+    }
+};
+
+const capturedProcessGroupOwner = captureProcessGroupOwner();
+
+const getInitialProcessGroupOwner = (): ProcessGroupOwner | undefined => {
+    if (!capturedProcessGroupOwner.isCaptured) {
+        throw capturedProcessGroupOwner.error;
+    }
+
+    return capturedProcessGroupOwner.owner;
+};
+
+export { getInitialProcessGroupOwner, initialParentId };

package/src/internal/prepare-project.ts

@@ -2,22 +2,22 @@ import { ensureGeneratedIn } from "../codegen/run-codegen.js";
 import { type CodegenContext, resolveCodegenContext } from "../codegen/store-resolver.js";
 import { resolveCwd, resolveEntry } from "./entry-arg.js";
 
-type ProjectArgs = { entry?: string; cwd?: string };
-type PreparedProject = { cwd: string; entry: string };
+type ProjectArgs = { entry?: string; cwd?: string; config?: string };
+type PreparedProject = { cwd: string; entry: string; configFile: string };
 type ResolvedProject = PreparedProject & { context: CodegenContext };
 
 const resolveProject = async (args: ProjectArgs, mode: string): Promise<ResolvedProject> => {
     const cwd = resolveCwd(args);
-    const context = await resolveCodegenContext(cwd, mode);
+    const context = await resolveCodegenContext(cwd, mode, args.config);
 
-    return { cwd, entry: resolveEntry(cwd, args.entry), context };
+    return { cwd, entry: resolveEntry(cwd, args.entry), configFile: context.configFile, context };
 };
 
 const prepareProject = async (args: ProjectArgs, mode: string): Promise<PreparedProject> => {
     const { cwd, entry, context } = await resolveProject(args, mode);
     await ensureGeneratedIn(context, { shouldAnnounce: true, mode });
 
-    return { cwd, entry };
+    return { cwd, entry, configFile: context.configFile };
 };
 
 export { prepareProject, resolveProject };

package/src/internal/source-imports.ts

@@ -33,7 +33,7 @@ const discoverSourceFiles = (dir: string): string[] =>
     sortStringsBy(
         globSync("**/{*,.*}", {
             cwd: dir,
-            exclude: ["**/{build,coverage,dist,node_modules,out-tsc}/**"],
+            exclude: ["**/{build,coverage,dist,node_modules,out-tsc}/**", "**/.gtkx-output-*/**"],
             withFileTypes: true,
         })
             .filter((entry) => entry.isFile())

package/src/mcp/client.ts

@@ -1,10 +1,10 @@
 import * as Gio from "@gtkx/gi/gio";
 import * as Gtk from "@gtkx/gi/gtk";
 import {
-    DEFAULT_SOCKET_PATH,
     isConnectionClosedError,
     type JSONRPCRequest,
     ProtocolConnection,
+    resolveMcpSocketPath,
     type Result,
 } from "@gtkx/mcp/internal";
 import { error, errorMessage, info, normalizeError } from "@gtkx/utils";
@@ -65,7 +65,7 @@ class McpClient {
     private registry = new WidgetRegistry();
 
     constructor(options: McpClientOptions) {
-        this.socketPath = options.socketPath ?? DEFAULT_SOCKET_PATH;
+        this.socketPath = resolveMcpSocketPath(options.socketPath);
         this.applicationId = options.applicationId;
     }
 

package/src/vite-plugins/build-manifest.ts

@@ -21,6 +21,11 @@ type ManifestState = {
     outDir: string;
 };
 
+type BuildConfigIdentity = {
+    configFile: string;
+    configDigest: string;
+};
+
 const PACKAGE_MANIFEST_FILENAME = "package.json";
 const DEFAULT_OUT_DIR = "dist";
 const JSON_INDENT = 4;
@@ -73,7 +78,7 @@ const packagesFor = (outDir: string, ids: string[]): RecordedPackage[] => {
 
 const renderManifest = (manifest: BuildManifest): string => `${JSON.stringify(manifest, null, JSON_INDENT)}\n`;
 
-function gtkxBuildManifest(root: string, collector: BuildManifestCollector): Plugin {
+function gtkxBuildManifest(root: string, collector: BuildManifestCollector, identity: BuildConfigIdentity): Plugin {
     const state: ManifestState = { outDir: join(root, DEFAULT_OUT_DIR) };
 
     return {
@@ -90,6 +95,7 @@ function gtkxBuildManifest(root: string, collector: BuildManifestCollector): Plu
             const manifest: BuildManifest = {
                 generator: BUILD_MANIFEST_GENERATOR,
                 formatVersion: BUILD_MANIFEST_FORMAT_VERSION,
+                ...identity,
                 schemas: collector.schemas,
                 packages: packagesFor(state.outDir, ids),
             };

package/src/vite-plugins/ensure-store.ts

@@ -3,11 +3,11 @@ import { ensureGenerated } from "../codegen/run-codegen.js";
 
 const TEST_MODE = "test";
 
-const gtkxEnsureStore = (): Plugin => ({
+const gtkxEnsureStore = (configFile?: string): Plugin => ({
     name: "gtkx:ensure-store",
 
     async config() {
-        await ensureGenerated(process.cwd(), { shouldAnnounce: true, mode: TEST_MODE });
+        await ensureGenerated(process.cwd(), { shouldAnnounce: true, mode: TEST_MODE, configFile });
     },
 });
 

package/src/vite-plugins/i18n.ts

@@ -1,7 +1,7 @@
 import type { ConfigLoader } from "@gtkx/config";
 import type { Plugin, ResolvedConfig } from "vite";
 import { createConfigLoader } from "@gtkx/config/internal";
-import { toPosixPath } from "@gtkx/utils";
+import { isPathWithin, logger, toPosixPath } from "@gtkx/utils";
 import { existsSync, mkdirSync } from "node:fs";
 import { createRequire } from "node:module";
 import { dirname, join, posix, relative, resolve } from "node:path";
@@ -13,7 +13,8 @@ import {
     synchronizeCatalogs,
 } from "../i18n/catalogs.js";
 import { extractSourceCatalog } from "../i18n/source-messages.js";
-import { discoverSourceFiles } from "../internal/source-imports.js";
+import { emitI18nTypes } from "../i18n/types.js";
+import { discoverSourceFiles, sourceLanguage } from "../internal/source-imports.js";
 import { stripQuery } from "./strip-query.js";
 
 type I18nState = {
@@ -21,6 +22,8 @@ type I18nState = {
     i18nRoot: string;
     outDir: string;
     project: CatalogProject | null;
+    extraction: Promise<void>;
+    hotUpdateTimestamp: number | null;
 };
 
 const BOOTSTRAP_SPECIFIER = "@gtkx/i18n/bootstrap";
@@ -94,6 +97,7 @@ const buildCatalogs = (state: I18nState): void => {
 const extractProjectMessages = async (
     state: I18nState,
     shouldPreserveMetadataMessages: boolean,
+    shouldSynchronizeCatalogs: boolean,
 ): Promise<void> => {
     const project = state.project;
 
@@ -104,7 +108,64 @@ const extractProjectMessages = async (
     const srcDir = join(project.root, "src");
     const sourceFiles = discoverSourceFiles(existsSync(srcDir) ? srcDir : project.root);
     await extractSourceCatalog(project, sourceFiles, shouldPreserveMetadataMessages);
-    synchronizeCatalogs(project);
+
+    if (shouldSynchronizeCatalogs) {
+        synchronizeCatalogs(project);
+    }
+
+    await emitI18nTypes(project.root);
+};
+
+const settleExtraction = async (pending: Promise<void>): Promise<void> => {
+    try {
+        await pending;
+    } catch {
+        return;
+    }
+};
+
+const queueExtraction = (
+    state: I18nState,
+    shouldPreserveMetadataMessages: boolean,
+    shouldSynchronizeCatalogs: boolean,
+): Promise<void> => {
+    const prior = state.extraction;
+    const pending = (async (): Promise<void> => {
+        await settleExtraction(prior);
+        await extractProjectMessages(
+            state,
+            shouldPreserveMetadataMessages,
+            shouldSynchronizeCatalogs,
+        );
+    })();
+
+    state.extraction = pending;
+
+    return pending;
+};
+
+const isProjectSource = (state: I18nState, path: string): boolean => {
+    const project = state.project;
+
+    if (project === null || sourceLanguage(path) === undefined) {
+        return false;
+    }
+
+    const srcDir = join(project.root, "src");
+    const sourceRoot = existsSync(srcDir) ? srcDir : project.root;
+
+    return isPathWithin(sourceRoot, path);
+};
+
+const refreshProjectMessages = async (
+    state: I18nState,
+    shouldPreserveMetadataMessages: boolean,
+): Promise<void> => {
+    try {
+        await queueExtraction(state, shouldPreserveMetadataMessages, false);
+    } catch (error) {
+        logger.error(error instanceof Error ? error.message : String(error));
+    }
 };
 
 const gtkxI18n = (
@@ -112,7 +173,14 @@ const gtkxI18n = (
     loadConfig: ConfigLoader = createConfigLoader(),
     shouldPreserveMetadataMessages = true,
 ): Plugin => {
-    const state: I18nState = { entryPath, i18nRoot: "", outDir: "", project: null };
+    const state: I18nState = {
+        entryPath,
+        extraction: Promise.resolve(),
+        hotUpdateTimestamp: null,
+        i18nRoot: "",
+        outDir: "",
+        project: null,
+    };
 
     return {
         name: "gtkx:i18n",
@@ -120,7 +188,17 @@ const gtkxI18n = (
 
         configResolved: (config) => applyResolvedConfig(state, config, loadConfig),
 
-        buildStart: () => extractProjectMessages(state, shouldPreserveMetadataMessages),
+        buildStart: () => queueExtraction(state, shouldPreserveMetadataMessages, true),
+
+        hotUpdate(options) {
+            if (!isProjectSource(state, options.file) || state.hotUpdateTimestamp === options.timestamp) {
+                return;
+            }
+
+            state.hotUpdateTimestamp = options.timestamp;
+
+            return refreshProjectMessages(state, shouldPreserveMetadataMessages);
+        },
 
         transform(code, id) {
             if (isI18nLocaleModule(state, id)) {

package/src/vite-plugins/index.ts

@@ -13,13 +13,20 @@ import { gtkxSettings } from "./settings.js";
 import { gtkxStoreLinks } from "./store-links.js";
 import { gtkxUndeclaredLibrary } from "./undeclared-library.js";
 
-const gtkxVitePlugins = (
-    mode?: string,
-    entryPath?: string,
-    buildManifest?: BuildManifestCollector,
-    shouldPreserveI18nMetadata = true,
-): Plugin[] => {
-    const loadConfig = createConfigLoader(mode === undefined ? {} : { mode });
+type GtkxVitePluginOptions = {
+    buildManifest?: BuildManifestCollector | undefined;
+    configFile?: string | undefined;
+    entryPath?: string | undefined;
+    mode?: string | undefined;
+    shouldPreserveI18nMetadata?: boolean | undefined;
+};
+
+const gtkxVitePlugins = (options: GtkxVitePluginOptions = {}): Plugin[] => {
+    const { buildManifest, configFile, entryPath, mode, shouldPreserveI18nMetadata = true } = options;
+    const loadConfig = createConfigLoader({
+        ...(mode !== undefined && { mode }),
+        ...(configFile !== undefined && { configFile }),
+    });
 
     return [
         createConfigPlugin({ name: "gtkx:config", loadConfig }),

package/src/vite-plugins/native.ts

@@ -5,7 +5,6 @@ import { arch, platform } from "node:os";
 import { dirname, join } from "node:path";
 import { stripQuery } from "./strip-query.js";
 
-const EMITTED_BINDING_SPECIFIER = "./gtkx.node";
 const BINDING_FILENAME = "gtkx.node";
 
 function resolveBinaryPath(projectRequire: ReturnType<typeof createRequire>, currentArch: string): string {
@@ -97,10 +96,6 @@ function gtkxNative(root: string): Plugin {
             });
         },
 
-        resolveId(id) {
-            return id === EMITTED_BINDING_SPECIFIER ? { id, external: true } : null;
-        },
-
         transform(code, id) {
             return transformLoader(code, id, loaderPath(), bindingReferenceId);
         },