@gtkx/cli 1.0.0-rc.1 → 1.0.0-rc.2

package/src/internal/banner.ts

@@ -1,9 +1,13 @@
 import type { Rollup } from "vite";
 
-export const prependBanner = (options: Rollup.OutputOptions, banner: string): Rollup.OutputOptions => {
+const prependBanner = (options: Rollup.OutputOptions, banner: string): Rollup.OutputOptions => {
     const existing = options.banner;
+
     if (typeof existing === "function") {
         return { ...options, banner: async (chunk) => `${banner}\n${await existing(chunk)}` };
     }
+
     return { ...options, banner: existing ? `${banner}\n${existing}` : banner };
 };
+
+export { prependBanner };

package/src/internal/data-dir.ts

@@ -1,39 +1,70 @@
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 
-export const DATA_IMPORT_PREFIX = "#data";
+const DATA_IMPORT_PREFIX = "#data";
+const DATA_IMPORT_KEY = `${DATA_IMPORT_PREFIX}/*`;
+const CONDITION_PRIORITY = ["default", "import", "node"] as const;
+const DATA_TARGET_PATTERN = /^\.?\/?(.+?)\/\*$/;
 
-const DATA_IMPORT_KEY: string = `${DATA_IMPORT_PREFIX}/*`;
+const isConditionMap = (entry: unknown): entry is Record<string, unknown> =>
+    entry !== null && typeof entry === "object" && !Array.isArray(entry);
 
-const CONDITION_PRIORITY = ["default", "import", "node"] as const;
+const conditionTarget = (conditions: Record<string, unknown>): string | null => {
+    for (const condition of CONDITION_PRIORITY) {
+        const value = conditions[condition];
 
-const targetString = (entry: unknown): string | null => {
-    if (typeof entry === "string") return entry;
-    if (entry !== null && typeof entry === "object" && !Array.isArray(entry)) {
-        const conditions = entry as Record<string, unknown>;
-        for (const condition of CONDITION_PRIORITY) {
-            const value = conditions[condition];
-            if (typeof value === "string") return value;
+        if (typeof value === "string") {
+            return value;
         }
     }
+
     return null;
 };
 
-const DATA_TARGET_PATTERN = /^\.?\/?(.+?)\/\*$/;
+const targetString = (entry: unknown): string | null => {
+    if (typeof entry === "string") {
+        return entry;
+    }
+
+    if (isConditionMap(entry)) {
+        return conditionTarget(entry);
+    }
+
+    return null;
+};
 
 const directoryFromTarget = (target: string): string | null => {
     const match = DATA_TARGET_PATTERN.exec(target);
+
     return match?.[1] ?? null;
 };
 
-export const resolveDataDir = (root: string): string | null => {
-    let manifest: { imports?: Record<string, unknown> };
+const resolveDataDir = (root: string): string | null => {
+    let manifest: unknown;
+
     try {
-        manifest = JSON.parse(readFileSync(join(root, "package.json"), "utf-8"));
+        manifest = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
     } catch {
         return null;
     }
-    const target = targetString(manifest.imports?.[DATA_IMPORT_KEY]);
-    if (target === null) return null;
+
+    if (!isConditionMap(manifest)) {
+        return null;
+    }
+
+    const imports = manifest.imports;
+
+    if (!isConditionMap(imports)) {
+        return null;
+    }
+
+    const target = targetString(imports[DATA_IMPORT_KEY]);
+
+    if (target === null) {
+        return null;
+    }
+
     return directoryFromTarget(target);
 };
+
+export { DATA_IMPORT_PREFIX, resolveDataDir };

package/src/internal/entry-arg.ts

@@ -1,19 +1,20 @@
+import type { PositionalArgDef, StringArgDef } from "citty";
 import { existsSync } from "node:fs";
 import { resolve } from "node:path";
-import type { PositionalArgDef, StringArgDef } from "citty";
 
 const DEFAULT_ENTRY_BASE = "src/index";
-const DEFAULT_ENTRY_EXTENSIONS = [".tsx", ".jsx", ".ts", ".js"];
+const DEFAULT_ENTRY_EXTENSION = ".tsx";
+const DEFAULT_ENTRY_EXTENSIONS = [DEFAULT_ENTRY_EXTENSION, ".jsx", ".ts", ".js"];
 const DEFAULT_ENTRY = `${DEFAULT_ENTRY_BASE}{${DEFAULT_ENTRY_EXTENSIONS.join(",")}}`;
 
-export const cwdArg: { cwd: StringArgDef } = {
+const cwdArg: { cwd: StringArgDef } = {
     cwd: {
         type: "string",
         description: "Project root (default: current working directory)",
     },
 };
 
-export const entryArg: { entry: PositionalArgDef; cwd: StringArgDef } = {
+const entryArg: { entry: PositionalArgDef; cwd: StringArgDef } = {
     entry: {
         type: "positional",
         description: `Entry file (default: ${DEFAULT_ENTRY})`,
@@ -22,17 +23,24 @@ export const entryArg: { entry: PositionalArgDef; cwd: StringArgDef } = {
     ...cwdArg,
 };
 
-export const resolveCwd = (args: { cwd?: string }): string => (args.cwd ? resolve(args.cwd) : process.cwd());
+const resolveCwd = (args: { cwd?: string }): string => (args.cwd ? resolve(args.cwd) : process.cwd());
 
 const resolveDefaultEntry = (cwd: string): string => {
     for (const extension of DEFAULT_ENTRY_EXTENSIONS) {
         const candidate = resolve(cwd, `${DEFAULT_ENTRY_BASE}${extension}`);
-        if (existsSync(candidate)) return candidate;
+
+        if (existsSync(candidate)) {
+            return candidate;
+        }
     }
-    return resolve(cwd, `${DEFAULT_ENTRY_BASE}${DEFAULT_ENTRY_EXTENSIONS[0]}`);
+
+    return resolve(cwd, `${DEFAULT_ENTRY_BASE}${DEFAULT_ENTRY_EXTENSION}`);
 };
 
-export const resolveEntry = (args: { entry?: string; cwd?: string }): { cwd: string; entry: string } => {
+const resolveEntry = (args: { entry?: string; cwd?: string }): { cwd: string; entry: string } => {
     const cwd = resolveCwd(args);
+
     return { cwd, entry: args.entry ? resolve(cwd, args.entry) : resolveDefaultEntry(cwd) };
 };
+
+export { cwdArg, entryArg, resolveCwd, resolveEntry };

package/src/internal/errors.ts

@@ -1,28 +1,36 @@
-import { logger } from "@gtkx/utils";
 import type { ArgsDef, CommandDef } from "citty";
+import { logger } from "@gtkx/utils";
 
 const ERROR_EXIT_CODE = 1;
 
-export const printError = (cause: unknown): never => {
+const printError = (cause: unknown): never => {
     const message = cause instanceof Error ? cause.message : String(cause);
     logger.error(message);
+
     if (cause instanceof Error && cause.stack !== undefined) {
         logger.debug(cause.stack);
     }
+
     process.exit(ERROR_EXIT_CODE);
 };
 
-export const withErrorBoundary = <T extends ArgsDef>(command: CommandDef<T>): CommandDef<T> => {
+const withErrorBoundary = <T extends ArgsDef>(command: CommandDef<T>): CommandDef<T> => {
     const run = command.run;
-    if (run === undefined) return command;
+
+    if (run === undefined) {
+        return command;
+    }
+
     return {
         ...command,
-        run: async (context) => {
+        run: async (context): Promise<unknown> => {
             try {
                 return await run(context);
-            } catch (cause) {
-                printError(cause);
+            } catch (error) {
+                return printError(error);
             }
         },
     };
 };
+
+export { printError, withErrorBoundary };

package/src/internal/list-files.ts

@@ -1,17 +1,23 @@
 import { existsSync, readdirSync } from "node:fs";
 import { join, relative } from "node:path";
 
-export type ListedFile = {
+type ListedFile = {
     absPath: string;
     rel: string;
 };
 
-export const listFilesRecursive = (dir: string, predicate?: (name: string) => boolean): ListedFile[] => {
-    if (!existsSync(dir)) return [];
+const listFilesRecursive = (dir: string, shouldInclude?: (name: string) => boolean): ListedFile[] => {
+    if (!existsSync(dir)) {
+        return [];
+    }
+
     return readdirSync(dir, { recursive: true, withFileTypes: true })
-        .filter((entry) => entry.isFile() && (predicate === undefined || predicate(entry.name)))
+        .filter((entry) => entry.isFile() && (shouldInclude === undefined || shouldInclude(entry.name)))
         .map((entry) => {
             const absPath = join(entry.parentPath, entry.name);
+
             return { absPath, rel: relative(dir, absPath) };
         });
 };
+
+export { listFilesRecursive, type ListedFile };

package/src/internal/resolve-cli-tool.ts

@@ -1,21 +1,37 @@
 import { existsSync, statSync } from "node:fs";
 import { delimiter, join } from "node:path";
 
-export const resolveCliTool = (() => {
-    const cache = new Map<string, string>();
+const resolveCliTool = (() => {
+    const cache: Map<string, string> = new Map();
 
     return (executable: string): string => {
         const cached = cache.get(executable);
-        if (cached) return cached;
-
-        const dirs = (process.env.PATH ?? "").split(delimiter).filter(Boolean);
-        for (const dir of dirs) {
-            const candidate = join(dir, executable);
-            if (existsSync(candidate) && statSync(candidate).isFile()) {
-                cache.set(executable, candidate);
-                return candidate;
-            }
+
+        if (cached) {
+            return cached;
         }
-        throw new Error(`${executable} not found in PATH`);
+
+        const resolved = findInPath(executable);
+        cache.set(executable, resolved);
+
+        return resolved;
     };
 })();
+
+const isExecutableFile = (candidate: string): boolean => existsSync(candidate) && statSync(candidate).isFile();
+
+const findInPath = (executable: string): string => {
+    const dirs = (process.env.PATH ?? "").split(delimiter).filter(Boolean);
+
+    for (const dir of dirs) {
+        const candidate = join(dir, executable);
+
+        if (isExecutableFile(candidate)) {
+            return candidate;
+        }
+    }
+
+    throw new Error(`${executable} not found in PATH`);
+};
+
+export { resolveCliTool };

package/src/internal/staging-dir.ts

@@ -2,15 +2,18 @@ import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
-export const removeTempDir = (dir: string): void => {
+const removeTempDir = (dir: string): void => {
     rmSync(dir, { recursive: true, force: true, maxRetries: 5 });
 };
 
-export const withStagingDir = <T>(prefix: string, produce: (dir: string) => T): T => {
+const withStagingDir = <T>(prefix: string, produce: (dir: string) => T): T => {
     const dir = mkdtempSync(join(tmpdir(), `gtkx-${prefix}-`));
+
     try {
         return produce(dir);
     } finally {
         removeTempDir(dir);
     }
 };
+
+export { removeTempDir, withStagingDir };

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

@@ -1,7 +1,13 @@
 const XDG_DATA_DIRS_DEFAULT = "/usr/local/share:/usr/share";
 
-export const prependXdgDataDir = (dir: string, existing: string | undefined): string => {
+const prependXdgDataDir = (dir: string, existing: string | undefined): string => {
     const base = existing === undefined || existing.length === 0 ? XDG_DATA_DIRS_DEFAULT : existing;
-    if (base.split(":").includes(dir)) return base;
+
+    if (base.split(":").includes(dir)) {
+        return base;
+    }
+
     return `${dir}:${base}`;
 };
+
+export { prependXdgDataDir };

package/src/mcp/client.ts

@@ -1,20 +1,58 @@
-import * as net from "node:net";
 import * as Gio from "@gtkx/gi/gio";
 import * as Gtk from "@gtkx/gi/gtk";
 import { DEFAULT_SOCKET_PATH, ErrorCode, ProtocolConnection, ProtocolError, type Request } from "@gtkx/mcp/internal";
 import { error, errorMessage, info, normalizeError, warn } from "@gtkx/utils";
+import * as net from "node:net";
 import { dispatch } from "./handlers.js";
 import { WidgetRegistry } from "./widget-registry.js";
 
-export type McpClientOptions = {
+type McpClientOptions = {
     socketPath?: string;
     applicationId: string;
 };
 
+type ConnectCallbacks = {
+    onSuccess?: (() => void) | undefined;
+    onError?: ((error: Error) => void) | undefined;
+};
+
+type ConnectSettler = {
+    succeed: () => void;
+    fail: (error: Error) => void;
+};
+
 const RECONNECT_DELAY_MS = 2000;
-const REGISTER_TIMEOUT_MS = 30000;
+const REGISTER_TIMEOUT_MS = 30_000;
+const DISCONNECT_ERROR_CODES: Set<string> = new Set(["ENOENT", "ECONNREFUSED", "EPIPE", "ECONNRESET"]);
+
+const toResponseError = (error: unknown): { code: number; message: string; data?: unknown } =>
+    error instanceof ProtocolError
+        ? error.toErrorObject()
+        : { code: ErrorCode.INTERNAL_ERROR, message: errorMessage(error) };
+
+const connectSettler = (callbacks: ConnectCallbacks): ConnectSettler => {
+    let isSettled = false;
+
+    const settle = (notify: () => void): void => {
+        if (isSettled) {
+            return;
+        }
+
+        isSettled = true;
+        notify();
+    };
+
+    return {
+        succeed: () => {
+            settle(() => callbacks.onSuccess?.());
+        },
+        fail: (failure) => {
+            settle(() => callbacks.onError?.(failure));
+        },
+    };
+};
 
-export class McpClient {
+class McpClient {
     private socket: net.Socket | null = null;
     private connection: ProtocolConnection | null = null;
     private socketPath: string;
@@ -30,92 +68,61 @@ export class McpClient {
         this.applicationId = options.applicationId;
     }
 
-    async connect(): Promise<void> {
-        return new Promise<void>((resolve, reject) => {
-            this.pendingConnectReject = reject;
-            this.attemptConnect(
-                () => {
-                    this.pendingConnectReject = null;
-                    resolve();
-                },
-                (error) => {
-                    this.pendingConnectReject = null;
-                    reject(error);
-                },
-            );
-        });
+    private handleClose(): void {
+        if (this.hasConnected) {
+            info("Disconnected from MCP server");
+            this.hasConnected = false;
+        }
+
+        this.socket = null;
+        this.connection = null;
+        this.scheduleReconnect();
     }
 
-    disconnect(): void {
-        this.isStopping = true;
-        if (this.pendingConnectReject) {
-            this.pendingConnectReject(new Error("Client disconnected before connection registered"));
-            this.pendingConnectReject = null;
-        }
-        if (this.reconnectTimer) {
-            clearTimeout(this.reconnectTimer);
-            this.reconnectTimer = null;
-        }
-        this.connection?.rejectPending(new Error("Client disconnected"));
-        if (this.socket) {
-            this.connection?.write({ id: crypto.randomUUID(), method: "app.unregister" });
-            this.socket.destroy();
-            this.socket = null;
+    private handleSocketError(socketError: Error): void {
+        const code = (socketError as NodeJS.ErrnoException).code;
+
+        if (code !== undefined && DISCONNECT_ERROR_CODES.has(code)) {
+            this.scheduleReconnect();
+        } else {
+            error("Socket error:", socketError.message);
         }
-        this.connection = null;
-        this.hasConnected = false;
     }
 
-    private attemptConnect(onSuccess?: () => void, onError?: (error: Error) => void): void {
-        let settled = false;
+    private async registerWithServer(settle: ConnectSettler): Promise<void> {
+        try {
+            await this.register();
+            info("Registered with MCP server");
+            settle.succeed();
+        } catch (registerError) {
+            error("Failed to register with MCP server:", errorMessage(registerError));
+            settle.fail(normalizeError(registerError));
+        }
+    }
 
-        const settle = <T extends unknown[]>(callback: ((...args: T) => void) | undefined, ...args: T) => {
-            if (settled) return;
-            settled = true;
-            callback?.(...args);
-        };
+    private attemptConnect(callbacks: ConnectCallbacks = {}): void {
+        const settle = connectSettler(callbacks);
 
         const socket = net.createConnection(this.socketPath, () => {
             info(`Connected to MCP server at ${this.socketPath}`);
             this.hasConnected = true;
-            this.register()
-                .then(() => {
-                    info("Registered with MCP server");
-                    settle(onSuccess);
-                })
-                .catch((cause) => {
-                    error("Failed to register with MCP server:", cause.message);
-                    settle(onError, normalizeError(cause));
-                });
+            void this.registerWithServer(settle);
         });
 
         const connection = ProtocolConnection.fromSocket(socket, {
             onClose: () => {
-                if (this.hasConnected) {
-                    info("Disconnected from MCP server");
-                    this.hasConnected = false;
-                }
-                this.socket = null;
-                this.connection = null;
-                this.scheduleReconnect();
+                this.handleClose();
             },
             onError: (socketError) => {
-                const code = (socketError as NodeJS.ErrnoException).code;
-                const isDisconnectError =
-                    code === "ENOENT" || code === "ECONNREFUSED" || code === "EPIPE" || code === "ECONNRESET";
-                if (isDisconnectError) {
-                    this.scheduleReconnect();
-                } else {
-                    error("Socket error:", socketError.message);
-                }
-                settle(onError, socketError);
+                this.handleSocketError(socketError);
+                settle.fail(socketError);
             },
         });
+
         connection.on("request", (request) => {
-            this.handleRequest(request).catch((cause) => {
-                error("Error handling request:", cause);
-            });
+            void this.handleRequest(request);
         });
+
         connection.on("invalid", ({ error: parseError }) => {
             warn(`Received invalid JSON from MCP server: ${parseError.message}`);
         });
@@ -125,7 +132,10 @@ export class McpClient {
     }
 
     private scheduleReconnect(): void {
-        if (this.reconnectTimer || this.isStopping) return;
+        if (this.reconnectTimer || this.isStopping) {
+            return;
+        }
+
         this.reconnectTimer = setTimeout(() => {
             this.reconnectTimer = null;
             this.attemptConnect();
@@ -136,6 +146,7 @@ export class McpClient {
         if (!this.connection) {
             return Promise.reject(new Error("Connection not initialized"));
         }
+
         return this.connection.send(
             "app.register",
             {
@@ -147,31 +158,78 @@ export class McpClient {
         );
     }
 
-    private async handleRequest(request: Request): Promise<void> {
+    private async respondToRequest(request: Request): Promise<void> {
         const { id, method, params } = request;
         const connection = this.connection;
-        if (!connection) return;
+
+        if (!connection) {
+            return;
+        }
 
         try {
             const defaultApp = Gio.Application.getDefault();
+
             if (!(defaultApp instanceof Gtk.Application)) {
                 throw new TypeError("Application not initialized");
             }
+
             this.registry.refresh();
             const result = await dispatch(method, params, { app: defaultApp, registry: this.registry });
             connection.write({ id, result });
-        } catch (error) {
-            if (error instanceof ProtocolError) {
-                connection.write({ id, error: error.toErrorObject() });
-            } else {
-                connection.write({
-                    id,
-                    error: {
-                        code: ErrorCode.INTERNAL_ERROR,
-                        message: errorMessage(error),
-                    },
-                });
-            }
+        } catch (dispatchError) {
+            connection.write({ id, error: toResponseError(dispatchError) });
         }
     }
+
+    private async handleRequest(request: Request): Promise<void> {
+        try {
+            await this.respondToRequest(request);
+        } catch (requestError) {
+            error("Error handling request:", requestError);
+        }
+    }
+
+    async connect(): Promise<void> {
+        return new Promise<void>((resolve, reject) => {
+            this.pendingConnectReject = reject;
+
+            this.attemptConnect({
+                onSuccess: () => {
+                    this.pendingConnectReject = null;
+                    resolve();
+                },
+                onError: (connectError) => {
+                    this.pendingConnectReject = null;
+                    reject(connectError);
+                },
+            });
+        });
+    }
+
+    disconnect(): void {
+        this.isStopping = true;
+
+        if (this.pendingConnectReject) {
+            this.pendingConnectReject(new Error("Client disconnected before connection registered"));
+            this.pendingConnectReject = null;
+        }
+
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+
+        this.connection?.rejectPending(new Error("Client disconnected"));
+
+        if (this.socket) {
+            this.connection?.write({ id: crypto.randomUUID(), method: "app.unregister" });
+            this.socket.destroy();
+            this.socket = null;
+        }
+
+        this.connection = null;
+        this.hasConnected = false;
+    }
 }
+
+export { McpClient, type McpClientOptions };