@gtkx/cli 1.6.0 → 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 { type Dirent, readdirSync, readFileSync } from "node:fs";
+import { existsSync, globSync, readFileSync } from "node:fs";
 import { extname, join } from "node:path";
 import { parseSync, Visitor } from "vite";
 
@@ -13,8 +13,6 @@ type SourceLanguage = NonNullable<ParserOptions["lang"]>;
 type ParsedModule = ParseResult["module"];
 
 const SOURCE_LANGUAGES: Map<string, SourceLanguage> = new Map([
-    [".cjs", "jsx"],
-    [".cts", "ts"],
     [".js", "jsx"],
     [".jsx", "jsx"],
     [".mjs", "jsx"],
@@ -23,60 +21,36 @@ const SOURCE_LANGUAGES: Map<string, SourceLanguage> = new Map([
     [".tsx", "tsx"],
 ]);
 
-const EXCLUDED_DIRECTORIES: Set<string> = new Set([
-    "build",
-    "coverage",
-    "dist",
-    "node_modules",
-    "out-tsc",
-]);
+const SOURCE_ID_RE = /\.[cm]?[jt]sx?(?:\?.*)?$/i;
 
 const sourceLanguage = (path: string): SourceLanguage | undefined => {
-    if (path.endsWith(".d.ts") || path.endsWith(".d.cts") || path.endsWith(".d.mts")) {
+    if (path.endsWith(".d.ts") || path.endsWith(".d.mts")) {
         return undefined;
     }
 
     return SOURCE_LANGUAGES.get(extname(path).toLowerCase());
 };
 
-const isWalkableDirectory = (name: string): boolean => !name.startsWith(".") && !EXCLUDED_DIRECTORIES.has(name);
-
-const collectSourceEntry = (dir: string, entry: Dirent, found: string[]): void => {
-    const path = join(dir, entry.name);
+const SOURCE_DIR = "src";
 
-    if (entry.isDirectory()) {
-        if (isWalkableDirectory(entry.name)) {
-            sourceFilesIn(path, found);
-        }
+const sourceDirFor = (root: string): string => {
+    const sourceDir = join(root, SOURCE_DIR);
 
-        return;
-    }
-
-    if (entry.isFile() && sourceLanguage(path) !== undefined) {
-        found.push(path);
-    }
+    return existsSync(sourceDir) ? sourceDir : root;
 };
 
-const sourceFilesIn = (dir: string, found: string[]): void => {
-    let entries: Dirent[];
-
-    try {
-        entries = readdirSync(dir, { withFileTypes: true });
-    } catch {
-        return;
-    }
-
-    for (const entry of entries) {
-        collectSourceEntry(dir, entry, found);
-    }
-};
-
-const discoverSourceFiles = (dir: string): string[] => {
-    const files: string[] = [];
-    sourceFilesIn(dir, files);
-
-    return sortStringsBy(files, (path) => path);
-};
+const discoverSourceFiles = (dir: string): string[] =>
+    sortStringsBy(
+        globSync("**/{*,.*}", {
+            cwd: dir,
+            exclude: ["**/{build,coverage,dist,node_modules,out-tsc}/**", "**/.gtkx-output-*/**", "**/.git/**"],
+            withFileTypes: true,
+        })
+            .filter((entry) => entry.isFile())
+            .map((entry) => join(entry.parentPath, entry.name))
+            .filter((path) => sourceLanguage(path) !== undefined),
+        (path) => path,
+    );
 
 const staticImportSources = (module: ParsedModule): string[] => [
     ...module.staticImports.map((statement) => statement.moduleRequest.value),
@@ -125,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);
@@ -138,7 +113,7 @@ const parseImportsInWith = (
     let parsed: ParseResult;
 
     try {
-        parsed = parseSync(path, readFileSync(path, "utf8"), { lang });
+        parsed = parseSync(path, code, { lang });
     } catch {
         return null;
     }
@@ -148,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;
     }