@gtkx/cli 0.20.0 → 1.0.0-rc.1

package/src/mcp-client.ts

@@ -1,518 +0,0 @@
-import * as net from "node:net";
-import { getNativeInterface } from "@gtkx/ffi";
-import * as Gio from "@gtkx/ffi/gio";
-import { Value } from "@gtkx/ffi/gobject";
-import * as Gtk from "@gtkx/ffi/gtk";
-import {
-    DEFAULT_SOCKET_PATH,
-    type IpcMethod,
-    type IpcRequest,
-    IpcRequestSchema,
-    type IpcResponse,
-    IpcResponseSchema,
-    McpError,
-    McpErrorCode,
-    methodNotFoundError,
-    type SerializedWidget,
-    widgetNotFoundError,
-} from "@gtkx/mcp";
-
-const widgetIdMap = new WeakMap<Gtk.Widget, string>();
-let nextWidgetId = 0;
-
-const getWidgetId = (widget: Gtk.Widget): string => {
-    let id = widgetIdMap.get(widget);
-    if (!id) {
-        id = String(nextWidgetId++);
-        widgetIdMap.set(widget, id);
-    }
-    return id;
-};
-
-type TestingModule = typeof import("@gtkx/testing");
-
-let testingModule: TestingModule | null = null;
-let testingLoadError: Error | null = null;
-
-const loadTestingModule = async (): Promise<TestingModule> => {
-    if (testingModule) return testingModule;
-    if (testingLoadError) throw testingLoadError;
-
-    try {
-        testingModule = await import("@gtkx/testing");
-        return testingModule;
-    } catch (cause) {
-        testingLoadError = new Error(
-            "@gtkx/testing is not installed. Install it to enable MCP widget interactions: pnpm add -D @gtkx/testing",
-            { cause },
-        );
-        throw testingLoadError;
-    }
-};
-
-type McpClientOptions = {
-    socketPath?: string;
-    appId: string;
-};
-
-type PendingRequest = {
-    resolve: (result: unknown) => void;
-    reject: (error: Error) => void;
-    timeout: NodeJS.Timeout;
-};
-
-const RECONNECT_DELAY_MS = 2000;
-const REQUEST_TIMEOUT_MS = 30000;
-
-const formatRole = (role: Gtk.AccessibleRole | undefined): string => {
-    if (role === undefined) return "UNKNOWN";
-    return Gtk.AccessibleRole[role] ?? String(role);
-};
-
-const getWidgetText = (widget: Gtk.Widget): string | null => {
-    if ("getLabel" in widget && typeof widget.getLabel === "function") {
-        return widget.getLabel() ?? null;
-    }
-
-    if ("getText" in widget && typeof widget.getText === "function") {
-        return widget.getText() ?? null;
-    }
-
-    if ("getTitle" in widget && typeof widget.getTitle === "function") {
-        return widget.getTitle() ?? null;
-    }
-
-    return getNativeInterface(widget, Gtk.Editable)?.getText() ?? null;
-};
-
-const serializeWidget = (widget: Gtk.Widget): SerializedWidget => {
-    const children: SerializedWidget[] = [];
-    let child = widget.getFirstChild();
-    while (child) {
-        children.push(serializeWidget(child));
-        child = child.getNextSibling();
-    }
-
-    const text = getWidgetText(widget);
-
-    return {
-        id: getWidgetId(widget),
-        type: widget.constructor.name,
-        role: formatRole(widget.getAccessibleRole()),
-        name: widget.getName() || null,
-        label: text,
-        text,
-        sensitive: widget.getSensitive(),
-        visible: widget.getVisible(),
-        cssClasses: widget.getCssClasses() ?? [],
-        children,
-    };
-};
-
-const widgetRegistry = new Map<string, Gtk.Widget>();
-
-const registerWidgets = (widget: Gtk.Widget): void => {
-    const idStr = getWidgetId(widget);
-    widgetRegistry.set(idStr, widget);
-    let child = widget.getFirstChild();
-    while (child) {
-        registerWidgets(child);
-        child = child.getNextSibling();
-    }
-};
-
-const getWidgetById = (id: string): Gtk.Widget | undefined => {
-    return widgetRegistry.get(id);
-};
-
-const refreshWidgetRegistry = (): void => {
-    widgetRegistry.clear();
-    const windows = Gtk.Window.listToplevels();
-    for (const window of windows) {
-        registerWidgets(window);
-    }
-};
-
-class McpClient {
-    private socket: net.Socket | null = null;
-    private buffer = "";
-    private socketPath: string;
-    private appId: string;
-    private reconnectTimer: NodeJS.Timeout | null = null;
-    private hasConnected = false;
-    private isStopping = false;
-    private pendingRequests = new Map<string, PendingRequest>();
-
-    constructor(options: McpClientOptions) {
-        this.socketPath = options.socketPath ?? DEFAULT_SOCKET_PATH;
-        this.appId = options.appId;
-    }
-
-    async connect(): Promise<void> {
-        return new Promise((resolve, reject) => {
-            this.attemptConnect(resolve, reject);
-        });
-    }
-
-    private attemptConnect(onSuccess?: () => void, onError?: (error: Error) => void): void {
-        let settled = false;
-
-        const settle = <T extends unknown[]>(callback: ((...args: T) => void) | undefined, ...args: T) => {
-            if (settled) return;
-            settled = true;
-            callback?.(...args);
-        };
-
-        this.socket = net.createConnection(this.socketPath, () => {
-            console.log(`[gtkx] Connected to MCP server at ${this.socketPath}`);
-            this.hasConnected = true;
-            this.register()
-                .then(() => {
-                    console.log("[gtkx] Registered with MCP server");
-                    settle(onSuccess);
-                })
-                .catch((error) => {
-                    console.error("[gtkx] Failed to register with MCP server:", error.message);
-                    settle(onError, error instanceof Error ? error : new Error(String(error)));
-                });
-        });
-
-        this.socket.on("data", (data: Buffer) => this.handleData(data));
-
-        this.socket.on("close", () => {
-            if (this.hasConnected) {
-                console.log("[gtkx] Disconnected from MCP server");
-                this.hasConnected = false;
-            }
-            this.socket = null;
-            this.rejectPendingRequests(new Error("Connection closed"));
-            this.scheduleReconnect();
-        });
-
-        this.socket.on("error", (error) => {
-            const code = (error as NodeJS.ErrnoException).code;
-            const isDisconnectError =
-                code === "ENOENT" || code === "ECONNREFUSED" || code === "EPIPE" || code === "ECONNRESET";
-            if (isDisconnectError) {
-                this.scheduleReconnect();
-            } else {
-                console.error("[gtkx] Socket error:", error.message);
-            }
-            settle(onError, error);
-        });
-    }
-
-    private scheduleReconnect(): void {
-        if (this.reconnectTimer || this.isStopping) return;
-        this.reconnectTimer = setTimeout(() => {
-            this.reconnectTimer = null;
-            this.attemptConnect();
-        }, RECONNECT_DELAY_MS);
-    }
-
-    disconnect(): void {
-        this.isStopping = true;
-        if (this.reconnectTimer) {
-            clearTimeout(this.reconnectTimer);
-            this.reconnectTimer = null;
-        }
-        this.rejectPendingRequests(new Error("Client disconnected"));
-        if (this.socket) {
-            this.send({ id: crypto.randomUUID(), method: "app.unregister" });
-            this.socket.destroy();
-            this.socket = null;
-        }
-        this.hasConnected = false;
-    }
-
-    private rejectPendingRequests(error: Error): void {
-        for (const pending of this.pendingRequests.values()) {
-            clearTimeout(pending.timeout);
-            pending.reject(error);
-        }
-        this.pendingRequests.clear();
-    }
-
-    private async register(): Promise<void> {
-        await this.sendRequest("app.register", {
-            appId: this.appId,
-            pid: process.pid,
-        });
-    }
-
-    private send(message: IpcRequest | IpcResponse): void {
-        if (!this.socket || !this.socket.writable) return;
-        this.socket.write(`${JSON.stringify(message)}\n`);
-    }
-
-    private sendRequest(method: IpcMethod, params?: unknown): Promise<unknown> {
-        return new Promise((resolve, reject) => {
-            if (!this.socket || !this.socket.writable) {
-                reject(new Error("Socket not connected"));
-                return;
-            }
-
-            const id = crypto.randomUUID();
-            const timeout = setTimeout(() => {
-                this.pendingRequests.delete(id);
-                reject(new Error(`Request timed out: ${method}`));
-            }, REQUEST_TIMEOUT_MS);
-
-            this.pendingRequests.set(id, { resolve, reject, timeout });
-            this.send({ id, method, params });
-        });
-    }
-
-    private handleData(data: Buffer): void {
-        this.buffer += data.toString();
-
-        let newlineIndex = this.buffer.indexOf("\n");
-        while (newlineIndex !== -1) {
-            const line = this.buffer.slice(0, newlineIndex);
-            this.buffer = this.buffer.slice(newlineIndex + 1);
-
-            if (line.trim()) {
-                this.processMessage(line);
-            }
-            newlineIndex = this.buffer.indexOf("\n");
-        }
-    }
-
-    private processMessage(line: string): void {
-        let parsed: unknown;
-        try {
-            parsed = JSON.parse(line);
-        } catch {
-            console.warn("[gtkx] Received invalid JSON from MCP server");
-            return;
-        }
-
-        const responseResult = IpcResponseSchema.safeParse(parsed);
-        if (responseResult.success) {
-            const response = responseResult.data;
-            const pending = this.pendingRequests.get(response.id);
-            if (pending) {
-                clearTimeout(pending.timeout);
-                this.pendingRequests.delete(response.id);
-                if (response.error) {
-                    pending.reject(new Error(response.error.message));
-                } else {
-                    pending.resolve(response.result);
-                }
-                return;
-            }
-        }
-
-        const requestResult = IpcRequestSchema.safeParse(parsed);
-        if (!requestResult.success) {
-            return;
-        }
-
-        this.handleRequest(requestResult.data).catch((error) => {
-            console.error("[gtkx] Error handling request:", error);
-        });
-    }
-
-    private async handleRequest(request: IpcRequest): Promise<void> {
-        const { id, method, params } = request;
-
-        try {
-            const result = await this.executeMethod(method as IpcMethod, params);
-            this.send({ id, result });
-        } catch (error) {
-            if (error instanceof McpError) {
-                this.send({ id, error: error.toIpcError() });
-            } else {
-                const message = error instanceof Error ? error.message : String(error);
-                this.send({
-                    id,
-                    error: {
-                        code: McpErrorCode.INTERNAL_ERROR,
-                        message,
-                    },
-                });
-            }
-        }
-    }
-
-    private async executeMethod(method: IpcMethod, params: unknown): Promise<unknown> {
-        const app = Gio.Application.getDefault() as Gtk.Application | null;
-
-        if (!app) {
-            throw new Error("Application not initialized");
-        }
-
-        refreshWidgetRegistry();
-
-        switch (method) {
-            case "app.getWindows": {
-                const windows = Gtk.Window.listToplevels();
-                return {
-                    windows: windows.map((w) => ({
-                        id: getWidgetId(w),
-                        title: (w as Gtk.Window).getTitle?.() ?? null,
-                    })),
-                };
-            }
-
-            case "widget.getTree": {
-                const testing = await loadTestingModule();
-                return { tree: testing.prettyWidget(app, { includeIds: true, highlight: false }) };
-            }
-
-            case "widget.query": {
-                const testing = await loadTestingModule();
-                const p = params as { queryType: string; value: string | number; options?: Record<string, unknown> };
-                let widgets: Gtk.Widget[] = [];
-
-                switch (p.queryType) {
-                    case "role": {
-                        const roleValue =
-                            typeof p.value === "string"
-                                ? (Gtk.AccessibleRole[p.value as keyof typeof Gtk.AccessibleRole] as Gtk.AccessibleRole)
-                                : (p.value as Gtk.AccessibleRole);
-                        widgets = await testing.findAllByRole(app, roleValue, p.options);
-                        break;
-                    }
-                    case "text":
-                        widgets = await testing.findAllByText(app, String(p.value), p.options);
-                        break;
-                    case "testId":
-                        widgets = await testing.findAllByTestId(app, String(p.value), p.options);
-                        break;
-                    case "labelText":
-                        widgets = await testing.findAllByLabelText(app, String(p.value), p.options);
-                        break;
-                    default:
-                        throw new Error(`Unknown query type: ${p.queryType}`);
-                }
-
-                return { widgets: widgets.map((w) => serializeWidget(w)) };
-            }
-
-            case "widget.getProps": {
-                const p = params as { widgetId: string };
-                const widget = getWidgetById(p.widgetId);
-                if (!widget) {
-                    throw widgetNotFoundError(p.widgetId);
-                }
-                return serializeWidget(widget);
-            }
-
-            case "widget.click": {
-                const testing = await loadTestingModule();
-                const p = params as { widgetId: string };
-                const widget = getWidgetById(p.widgetId);
-                if (!widget) {
-                    throw widgetNotFoundError(p.widgetId);
-                }
-                await testing.userEvent.click(widget);
-                return { success: true };
-            }
-
-            case "widget.type": {
-                const testing = await loadTestingModule();
-                const p = params as { widgetId: string; text: string; clear?: boolean };
-                const widget = getWidgetById(p.widgetId);
-                if (!widget) {
-                    throw widgetNotFoundError(p.widgetId);
-                }
-                if (p.clear) {
-                    await testing.userEvent.clear(widget);
-                }
-                await testing.userEvent.type(widget, p.text);
-                return { success: true };
-            }
-
-            case "widget.fireEvent": {
-                const testing = await loadTestingModule();
-                const p = params as {
-                    widgetId: string;
-                    signal: string;
-                    args?: (unknown | { type: string; value: unknown })[];
-                };
-                const widget = getWidgetById(p.widgetId);
-                if (!widget) {
-                    throw widgetNotFoundError(p.widgetId);
-                }
-                const signalArgs = (p.args ?? []).map((arg) => {
-                    const isTypedArg = typeof arg === "object" && arg !== null && "type" in arg && "value" in arg;
-                    const argType = isTypedArg ? (arg as { type: string }).type : typeof arg;
-                    const argValue = isTypedArg ? (arg as { value: unknown }).value : arg;
-
-                    switch (argType) {
-                        case "boolean":
-                            return Value.newFromBoolean(argValue as boolean);
-                        case "int":
-                            return Value.newFromInt(argValue as number);
-                        case "uint":
-                            return Value.newFromUint(argValue as number);
-                        case "int64":
-                            return Value.newFromInt64(argValue as number);
-                        case "uint64":
-                            return Value.newFromUint64(argValue as number);
-                        case "float":
-                            return Value.newFromFloat(argValue as number);
-                        case "double":
-                        case "number":
-                            return Value.newFromDouble(argValue as number);
-                        case "string":
-                            return Value.newFromString(argValue as string | null);
-                        default:
-                            throw new McpError(McpErrorCode.INVALID_REQUEST, `Unknown argument type: ${argType}`);
-                    }
-                });
-                await testing.fireEvent(widget, p.signal, ...signalArgs);
-                return { success: true };
-            }
-
-            case "widget.screenshot": {
-                const testing = await loadTestingModule();
-                const p = params as { windowId?: string };
-
-                let targetWindow: Gtk.Window;
-
-                if (p.windowId) {
-                    const widget = getWidgetById(p.windowId);
-                    if (!widget) {
-                        throw widgetNotFoundError(p.windowId);
-                    }
-                    targetWindow = widget as Gtk.Window;
-                } else {
-                    const windows = app.getWindows();
-                    if (windows.length === 0) {
-                        throw new Error("No windows available for screenshot");
-                    }
-                    targetWindow = windows[0] as Gtk.Window;
-                }
-
-                const result = await testing.screenshot(targetWindow);
-                return { data: result.data, mimeType: result.mimeType };
-            }
-
-            default:
-                throw methodNotFoundError(method);
-        }
-    }
-}
-
-let globalClient: McpClient | null = null;
-
-export const startMcpClient = async (appId: string): Promise<McpClient> => {
-    if (globalClient) {
-        return globalClient;
-    }
-
-    globalClient = new McpClient({ appId });
-
-    await globalClient.connect().catch(() => {});
-
-    return globalClient;
-};
-
-export const stopMcpClient = (): void => {
-    if (globalClient) {
-        globalClient.disconnect();
-        globalClient = null;
-    }
-};

package/src/templates.ts

@@ -1,26 +0,0 @@
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-import ejs from "ejs";
-import type { TestingOption } from "./create.js";
-
-export type TemplateContext = {
-    name: string;
-    appId: string;
-    title: string;
-    testing: TestingOption;
-};
-
-const getTemplatesDir = (): string => {
-    return join(import.meta.dirname, "..", "templates");
-};
-
-const renderTemplate = (templatePath: string, context: TemplateContext): string => {
-    const templateContent = readFileSync(templatePath, "utf-8");
-    return ejs.render(templateContent, context);
-};
-
-export const renderFile = (templateName: string, context: TemplateContext): string => {
-    const templatesDir = getTemplatesDir();
-    const templatePath = join(templatesDir, templateName);
-    return renderTemplate(templatePath, context);
-};

package/src/vite-plugin-gtkx-assets.ts

@@ -1,69 +0,0 @@
-import { readFileSync } from "node:fs";
-import type { Plugin } from "vite";
-
-const ASSET_RE = /\.(png|jpe?g|gif|svg|webp|webm|mp4|ogg|mp3|wav|flac|aac|woff2?|eot|ttf|otf|ico|avif|data)$/i;
-const CSS_RE = /\.css$/i;
-const VIRTUAL_PREFIX = "\0gtkx:";
-
-/**
- * Vite plugin that resolves static asset imports to filesystem paths
- * and handles CSS imports for GTK applications.
- *
- * **Non-CSS assets:** In dev mode, asset imports resolve to the absolute
- * source file path. In build mode, Vite's built-in asset pipeline handles
- * emission and hashing; the `renderBuiltUrl` config in the builder
- * converts the URL to a filesystem path via `import.meta.url`.
- *
- * **CSS imports (`import "./style.css"`):** Transformed into a module that
- * calls `injectGlobal` from `@gtkx/css` with the file's contents, injecting
- * the styles into the GTK CSS provider at runtime.
- *
- * **CSS URL imports (`import path from "./style.css?url"`):** Handled by
- * Vite's built-in `?url` mechanism, which emits the file as an asset and
- * resolves it to a filesystem path via `renderBuiltUrl`.
- */
-export function gtkxAssets(): Plugin {
-    let isBuild = false;
-
-    return {
-        name: "gtkx:assets",
-        enforce: "pre",
-
-        config() {
-            return {
-                assetsInclude: [ASSET_RE],
-            };
-        },
-
-        configResolved(config) {
-            isBuild = config.command === "build";
-        },
-
-        async resolveId(source, importer, options) {
-            if (!CSS_RE.test(source)) {
-                return;
-            }
-
-            const resolved = await this.resolve(source, importer, { ...options, skipSelf: true });
-            if (!resolved || resolved.external) return;
-
-            return `${VIRTUAL_PREFIX + resolved.id}?inject`;
-        },
-
-        load(id) {
-            if (id.startsWith(VIRTUAL_PREFIX) && id.endsWith("?inject")) {
-                const filePath = id.slice(VIRTUAL_PREFIX.length, -"?inject".length);
-                const content = readFileSync(filePath, "utf-8");
-                return [`import { injectGlobal } from "@gtkx/css";`, `injectGlobal(${JSON.stringify(content)});`].join(
-                    "\n",
-                );
-            }
-
-            if (isBuild || !ASSET_RE.test(id)) {
-                return;
-            }
-
-            return `export default ${JSON.stringify(id)};`;
-        },
-    };
-}

package/src/vite-plugin-gtkx-native.ts

@@ -1,64 +0,0 @@
-import { readFileSync } from "node:fs";
-import { createRequire } from "node:module";
-import { arch, platform } from "node:os";
-import { join } from "node:path";
-import type { Plugin } from "vite";
-
-const LOAD_NATIVE_BINDING_RE = /function loadNativeBinding\(\) \{[\s\S]*?\n\}/;
-const NODE_OS_IMPORT_RE = /import\s*\{[^}]*\}\s*from\s*["']node:os["'];?\n?/;
-
-/**
- * Vite plugin that embeds the native `.node` binary into the build output.
- *
- * During production builds, resolves the platform-specific `.node` binary,
- * copies it into the output directory as `gtkx.node`, and transforms the
- * `loadNativeBinding` function in `@gtkx/native` to load `./gtkx.node`
- * directly. This makes the bundle self-contained with no `node_modules`
- * dependency at runtime.
- *
- * @param root - Project root directory used to resolve native packages
- */
-export function gtkxNative(root: string): Plugin {
-    const projectRequire = createRequire(join(root, "package.json"));
-    let nativeIndexPath: string;
-
-    return {
-        name: "gtkx:native",
-        enforce: "pre",
-
-        buildStart() {
-            const currentPlatform = platform();
-            const currentArch = arch();
-            const packageName = `@gtkx/native-linux-${currentArch}`;
-
-            if (currentPlatform !== "linux") {
-                throw new Error(`Unsupported build platform: ${currentPlatform}. Only Linux is supported.`);
-            }
-
-            if (currentArch !== "x64" && currentArch !== "arm64") {
-                throw new Error(`Unsupported build architecture: ${currentArch}. Only x64 and arm64 are supported.`);
-            }
-
-            nativeIndexPath = projectRequire.resolve("@gtkx/native");
-
-            const nodePath = projectRequire.resolve(`${packageName}/index.node`);
-            const source = readFileSync(nodePath);
-
-            this.emitFile({
-                type: "asset",
-                fileName: "gtkx.node",
-                source,
-            });
-        },
-
-        transform(code, id) {
-            if (id !== nativeIndexPath) {
-                return;
-            }
-
-            return code
-                .replace(NODE_OS_IMPORT_RE, "")
-                .replace(LOAD_NATIVE_BINDING_RE, 'function loadNativeBinding() { return require("./gtkx.node"); }');
-        },
-    };
-}