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

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,28 @@ 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; configDependencies: 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,
+        configDependencies: context.configDependencies,
+        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, configDependencies: context.configDependencies };
 };
 
 export { prepareProject, resolveProject };

package/src/internal/react-compiler-cache.ts

@@ -0,0 +1,246 @@
+import type { ResolvedReactCompilerOptions } from "@gtkx/config/internal";
+import { isRecord } from "@gtkx/utils";
+import { createHash } from "node:crypto";
+import { mkdirSync, readdirSync, readFileSync, rmSync, statSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import packageManifest from "../../package.json" with { type: "json" };
+import { moduleHash } from "./module-hash.js";
+import { isStagingOwnerRunning, STAGING_SUFFIX, writeAtomically } from "./staging-file.js";
+
+type CompilerOutput = { code: string; map?: string };
+
+type ReactCompilerCache = {
+    keyFor: (code: string, id: string) => string;
+    read: (key: string) => CompilerOutput | undefined;
+    write: (key: string, output: CompilerOutput) => void;
+};
+
+type ToolchainWalk = {
+    identities: Set<string>;
+    queue: [string, string][];
+    visited: Set<string>;
+};
+
+const CACHE_NAME = "gtkx-react-compiler";
+const CACHE_VERSION = "1";
+const ENTRY_SUFFIX = ".json";
+const GENERATION_LENGTH = 16;
+const MAX_ENTRIES = 2048;
+const TOOLCHAIN_PACKAGES = ["@babel/core", "@babel/preset-typescript", "babel-plugin-react-compiler"];
+const PLUGIN_MODULE = ["..", "vite-plugins", "react-compiler"];
+const toolchain: { value: string | undefined } = { value: undefined };
+
+const readText = (path: string): string | undefined => {
+    try {
+        return readFileSync(path, "utf8");
+    } catch {
+        return undefined;
+    }
+};
+
+const readManifest = (path: string): unknown => {
+    const contents = readText(path);
+
+    if (contents === undefined) {
+        return undefined;
+    }
+
+    try {
+        return JSON.parse(contents) as unknown;
+    } catch {
+        return undefined;
+    }
+};
+
+const manifestIdentity = (value: unknown): string | undefined =>
+    isRecord(value) && typeof value.name === "string" && typeof value.version === "string"
+        ? `${value.name}@${value.version}`
+        : undefined;
+
+const tryResolve = (resolver: NodeJS.Require, specifier: string): string | undefined => {
+    try {
+        return resolver.resolve(specifier);
+    } catch {
+        return undefined;
+    }
+};
+
+const manifestNear = (entry: string, name: string): string | undefined => {
+    for (let dir = dirname(entry); dir !== dirname(dir); dir = dirname(dir)) {
+        const candidate = join(dir, "package.json");
+
+        if (manifestIdentity(readManifest(candidate))?.startsWith(`${name}@`) === true) {
+            return candidate;
+        }
+    }
+
+    return undefined;
+};
+
+const manifestPathFor = (name: string, from: string): string | undefined => {
+    const resolver = createRequire(from);
+    const direct = tryResolve(resolver, `${name}/package.json`);
+
+    if (direct !== undefined) {
+        return direct;
+    }
+
+    const entry = tryResolve(resolver, name);
+
+    return entry === undefined ? undefined : manifestNear(entry, name);
+};
+
+const visitPackage = (name: string, from: string, walk: ToolchainWalk): void => {
+    const path = manifestPathFor(name, from);
+
+    if (path === undefined || walk.visited.has(path)) {
+        return;
+    }
+
+    walk.visited.add(path);
+    const manifest = readManifest(path);
+    const identity = manifestIdentity(manifest);
+
+    if (identity !== undefined) {
+        walk.identities.add(identity);
+    }
+
+    if (isRecord(manifest) && isRecord(manifest.dependencies)) {
+        const dependencies = Object.keys(manifest.dependencies);
+        walk.queue.push(...dependencies.map((dependency): [string, string] => [dependency, path]));
+    }
+};
+
+const computeToolchainKey = (): string => {
+    const walk: ToolchainWalk = {
+        identities: new Set(),
+        queue: TOOLCHAIN_PACKAGES.map((name): [string, string] => [name, import.meta.filename]),
+        visited: new Set(),
+    };
+
+    for (const [name, from] of walk.queue) {
+        visitPackage(name, from, walk);
+    }
+
+    const identities = [...walk.identities].toSorted((left, right) => left.localeCompare(right));
+
+    return createHash("sha256").update(identities.join(",")).digest("hex");
+};
+
+const toolchainKey = (): string => (toolchain.value ??= computeToolchainKey());
+
+const entryTime = (path: string): number => {
+    try {
+        return statSync(path).mtimeMs;
+    } catch {
+        return 0;
+    }
+};
+
+const pruneEntries = (dir: string, names: string[]): void => {
+    const keys = names.filter((name) => name.endsWith(ENTRY_SUFFIX)).map((name) => name.slice(0, -ENTRY_SUFFIX.length));
+
+    if (keys.length <= MAX_ENTRIES) {
+        return;
+    }
+
+    const ordered = keys
+        .map((key) => ({ key, time: entryTime(join(dir, `${key}${ENTRY_SUFFIX}`)) }))
+        .toSorted((left, right) => left.time - right.time);
+    const expired = ordered.slice(0, keys.length - MAX_ENTRIES / 2);
+
+    for (const entry of expired) {
+        rmSync(join(dir, `${entry.key}${ENTRY_SUFFIX}`), { force: true });
+    }
+};
+
+const pruneGenerations = (root: string, generation: string): void => {
+    const names = readdirSync(root);
+
+    for (const name of names) {
+        if (name !== generation) {
+            rmSync(join(root, name), { force: true, recursive: true });
+        }
+    }
+};
+
+const isRetained = (name: string): boolean =>
+    name.endsWith(ENTRY_SUFFIX) || (name.endsWith(STAGING_SUFFIX) && isStagingOwnerRunning(name));
+
+const pruneStaging = (dir: string, names: string[]): void => {
+    for (const name of names) {
+        if (!isRetained(name)) {
+            rmSync(join(dir, name), { force: true });
+        }
+    }
+};
+
+const prepareCacheDir = (root: string, generation: string): string | null => {
+    const dir = join(root, generation);
+
+    try {
+        mkdirSync(dir, { recursive: true });
+        pruneGenerations(root, generation);
+        const names = readdirSync(dir);
+        pruneStaging(dir, names);
+        pruneEntries(dir, names);
+
+        return dir;
+    } catch {
+        return null;
+    }
+};
+
+const compilerOutput = (value: unknown): CompilerOutput | undefined => {
+    if (!isRecord(value) || typeof value.code !== "string") {
+        return undefined;
+    }
+
+    return typeof value.map === "string" ? { code: value.code, map: value.map } : { code: value.code };
+};
+
+const readEntry = (dir: string, key: string): CompilerOutput | undefined =>
+    compilerOutput(readManifest(join(dir, `${key}${ENTRY_SUFFIX}`)));
+
+const writeEntry = (dir: string, key: string, output: CompilerOutput): void => {
+    writeAtomically(join(dir, `${key}${ENTRY_SUFFIX}`), JSON.stringify(output));
+};
+
+const pluginHash = (): string => moduleHash(join(import.meta.dirname, ...PLUGIN_MODULE));
+
+const cacheIdentity = (options: ResolvedReactCompilerOptions, generation: string): string =>
+    [
+        CACHE_VERSION,
+        packageManifest.version,
+        pluginHash(),
+        generation,
+        JSON.stringify(options),
+        String(process.env.NODE_ENV),
+    ].join("\0");
+
+const createReactCompilerCache = (
+    cacheDir: string,
+    options: ResolvedReactCompilerOptions,
+): ReactCompilerCache | null => {
+    const root = join(cacheDir, CACHE_NAME);
+    const generation = toolchainKey().slice(0, GENERATION_LENGTH);
+    const dir = prepareCacheDir(root, generation);
+
+    if (dir === null) {
+        return null;
+    }
+
+    const identity = cacheIdentity(options, generation);
+
+    return {
+        keyFor: (code, id) =>
+            createHash("sha256").update(identity).update("\0").update(id).update("\0").update(code).digest("hex"),
+        read: (key) => readEntry(dir, key),
+        write: (key, output) => {
+            writeEntry(dir, key, output);
+        },
+    };
+};
+
+export { type CompilerOutput, createReactCompilerCache, type ReactCompilerCache };

package/src/internal/source-imports.ts

@@ -1,6 +1,6 @@
 import type { ESTree, ParseResult, ParserOptions } from "vite";
 import { sortStringsBy } from "@gtkx/utils";
-import { globSync, readFileSync } from "node:fs";
+import { existsSync, globSync, readFileSync } from "node:fs";
 import { extname, join } from "node:path";
 import { parseSync, Visitor } from "vite";
 
@@ -21,6 +21,8 @@ const SOURCE_LANGUAGES: Map<string, SourceLanguage> = new Map([
     [".tsx", "tsx"],
 ]);
 
+const SOURCE_ID_RE = /\.[cm]?[jt]sx?(?:\?.*)?$/i;
+
 const sourceLanguage = (path: string): SourceLanguage | undefined => {
     if (path.endsWith(".d.ts") || path.endsWith(".d.mts")) {
         return undefined;
@@ -29,11 +31,19 @@ const sourceLanguage = (path: string): SourceLanguage | undefined => {
     return SOURCE_LANGUAGES.get(extname(path).toLowerCase());
 };
 
+const SOURCE_DIR = "src";
+
+const sourceDirFor = (root: string): string => {
+    const sourceDir = join(root, SOURCE_DIR);
+
+    return existsSync(sourceDir) ? sourceDir : root;
+};
+
 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-*/**", "**/.git/**"],
             withFileTypes: true,
         })
             .filter((entry) => entry.isFile())
@@ -89,8 +99,9 @@ const collectDynamicImportSources = (program: ESTree.Program, found: string[]):
     }).visit(program);
 };
 
-const parseImportsInWith = (
+const parseSourceWith = (
     path: string,
+    code: string,
     staticSources: (module: ParsedModule) => string[],
 ): SourceImport[] | null => {
     const lang = sourceLanguage(path);
@@ -102,7 +113,7 @@ const parseImportsInWith = (
     let parsed: ParseResult;
 
     try {
-        parsed = parseSync(path, readFileSync(path, "utf8"), { lang });
+        parsed = parseSync(path, code, { lang });
     } catch {
         return null;
     }
@@ -112,24 +123,58 @@ const parseImportsInWith = (
     }
 
     const sources = staticSources(parsed.module);
-    collectDynamicImportSources(parsed.program, sources);
+
+    if (parsed.module.dynamicImports.length > 0) {
+        collectDynamicImportSources(parsed.program, sources);
+    }
 
     return [...new Set(sources)].map((source) => ({ importer: path, source }));
 };
 
+const readSource = (path: string): string | null => {
+    try {
+        return readFileSync(path, "utf8");
+    } catch {
+        return null;
+    }
+};
+
+const parseImportsInWith = (
+    path: string,
+    staticSources: (module: ParsedModule) => string[],
+): SourceImport[] | null => {
+    if (sourceLanguage(path) === undefined) {
+        return [];
+    }
+
+    const code = readSource(path);
+
+    return code === null ? null : parseSourceWith(path, code, staticSources);
+};
+
 const parseImportsIn = (path: string): SourceImport[] | null => parseImportsInWith(path, staticImportSources);
 
 const parseRuntimeImportsIn = (path: string): SourceImport[] | null =>
     parseImportsInWith(path, staticRuntimeImportSources);
 
 const importsIn = (path: string): SourceImport[] => parseImportsIn(path) ?? [];
-const importKey = (entry: SourceImport): string => `${entry.importer}\0${entry.source}`;
 
-const discoverSourceImports = (dir: string): SourceImport[] => {
-    const files = discoverSourceFiles(dir);
-    const imports = files.flatMap((path) => importsIn(path));
+const importSourcesIn = (path: string, code: string): string[] | null =>
+    parseSourceWith(path, code, staticImportSources)?.map((entry) => entry.source) ?? null;
 
-    return sortStringsBy(imports, importKey);
-};
+const importKey = (entry: SourceImport): string => `${entry.importer}\0${entry.source}`;
 
-export { discoverSourceFiles, discoverSourceImports, parseRuntimeImportsIn, type SourceImport, sourceLanguage };
+const sortSourceImports = (imports: SourceImport[]): SourceImport[] => sortStringsBy(imports, importKey);
+
+export {
+    discoverSourceFiles,
+    importSourcesIn,
+    importsIn,
+    parseRuntimeImportsIn,
+    readSource,
+    SOURCE_ID_RE,
+    sortSourceImports,
+    sourceDirFor,
+    sourceLanguage,
+    type SourceImport,
+};

package/src/internal/staging-file.ts

@@ -0,0 +1,42 @@
+import { errorCode } from "@gtkx/utils";
+import { renameSync, rmSync, writeFileSync } from "node:fs";
+
+const STAGING_SUFFIX = ".tmp";
+const STAGING_OWNER_RE = /\.(\d+)\.\d+\.tmp$/;
+const FOREIGN_OWNER_CODE = "EPERM";
+const staging = { count: 0 };
+
+const stagingPath = (path: string): string => {
+    staging.count += 1;
+
+    return `${path}.${String(process.pid)}.${String(staging.count)}${STAGING_SUFFIX}`;
+};
+
+const isStagingOwnerRunning = (name: string): boolean => {
+    const owner = STAGING_OWNER_RE.exec(name);
+
+    if (owner === null) {
+        return false;
+    }
+
+    try {
+        process.kill(Number(owner[1]), 0);
+
+        return true;
+    } catch (error) {
+        return errorCode(error) === FOREIGN_OWNER_CODE;
+    }
+};
+
+const writeAtomically = (path: string, contents: string): void => {
+    const temporary = stagingPath(path);
+
+    try {
+        writeFileSync(temporary, contents);
+        renameSync(temporary, path);
+    } catch {
+        rmSync(temporary, { force: true });
+    }
+};
+
+export { isStagingOwnerRunning, STAGING_SUFFIX, writeAtomically };

package/src/internal/xdg-banner.ts

@@ -0,0 +1,13 @@
+import type { Rollup } from "vite";
+import { outputRootUrlExpression } from "./banner.js";
+import { XDG_DATA_DIRS_DEFAULT } from "./xdg-data-dirs.js";
+
+const xdgDataDirsBanner = (chunk: Rollup.RenderedChunk): string => [
+    "globalThis.process.env.XDG_DATA_DIRS = (() => {",
+    `    const root = ${outputRootUrlExpression(chunk)};`,
+    `    const dirs = globalThis.process.env.XDG_DATA_DIRS || ${JSON.stringify(XDG_DATA_DIRS_DEFAULT)};`,
+    "    return dirs.split(\":\").includes(root) ? dirs : `${root}:${dirs}`;",
+    "})();",
+].join("\n");
+
+export { xdgDataDirsBanner };

package/src/internal/xdg-data-dirs.ts

@@ -10,4 +10,4 @@ const prependXdgDataDir = (dir: string, existing: string | undefined): string =>
     return `${dir}:${base}`;
 };
 
-export { prependXdgDataDir };
+export { prependXdgDataDir, XDG_DATA_DIRS_DEFAULT };

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/settings/schema.ts

@@ -11,8 +11,9 @@ import {
 } from "node:fs";
 import { tmpdir } from "node:os";
 import { basename, dirname, join, relative, resolve } from "node:path";
+import type { SourceImport } from "../internal/source-imports.js";
 import { I18N_TYPES_FILENAME, i18nTypesPath } from "../i18n/types.js";
-import { discoverSourceImports, type SourceImport } from "../internal/source-imports.js";
+import { discoverProjectImports } from "../internal/import-scan.js";
 import { removeTempDir } from "../internal/staging-dir.js";
 import {
     isBareRelativeAsset,
@@ -30,7 +31,6 @@ type SchemaEnvResult = {
 
 const SCHEMA_SUFFIX = ".gschema.xml";
 const STAGED_NAME_LENGTH = 16;
-const SOURCE_DIR = "src";
 const RESOURCE_QUERY = "?resource=";
 const ICON_QUERY = "?icon=";
 
@@ -69,12 +69,6 @@ const projectRelativeSchemaPath = (root: string, filePath: string): string | nul
 
 const getRelativeModuleSpecifier = (filePath: string): string => `*/${basename(filePath)}`;
 
-const sourceDirFor = (root: string): string => {
-    const sourceDir = join(root, SOURCE_DIR);
-
-    return existsSync(sourceDir) ? sourceDir : root;
-};
-
 const isRelativeImport = (source: string): boolean => source.startsWith("./") || source.startsWith("../");
 
 const schemaFileFor = ({ importer, source }: SourceImport): string | null =>
@@ -184,7 +178,7 @@ const assertUniqueSchemaBasenames = (schemaFiles: string[]): void => {
 };
 
 const stageAndCompileProjectSchemas = (root: string): string | null => {
-    const imports = discoverSourceImports(sourceDirFor(root));
+    const imports = discoverProjectImports(root);
     const schemaFiles = findImportedSchemaFiles(imports);
     assertUniqueSchemaBasenames(schemaFiles);
 
@@ -257,7 +251,7 @@ const didWriteChanges = (path: string, content: string): boolean => {
 };
 
 const emitSchemaEnv = (rootDir: string): SchemaEnvResult => {
-    const imports = discoverSourceImports(sourceDirFor(rootDir));
+    const imports = discoverProjectImports(rootDir);
     const importedFiles = findImportedSchemaFiles(imports);
     assertUniqueSchemaBasenames(importedFiles);
     const imported = parseProjectSchemas(importedFiles, getRelativeModuleSpecifier);

package/src/vite-plugins/asset-extensions.ts

@@ -18,6 +18,8 @@ const ASSET_EXTENSIONS = [
     "eot",
     "ttf",
     "otf",
+    "ttc",
+    "otc",
     "ico",
     "avif",
     "data",