@gtkx/mcp 0.21.0 → 1.0.0-rc.1

package/dist/tool.js

@@ -0,0 +1,36 @@
+import { ProtocolError } from "./protocol/errors.js";
+export const textContent = (text) => ({ content: [{ type: "text", text }] });
+export const textError = (text) => ({
+    content: [{ type: "text", text }],
+    isError: true,
+});
+export const imageContent = (data, mimeType) => ({
+    content: [{ type: "image", data, mimeType }],
+});
+const hasStringHint = (data) => typeof data === "object" && data !== null && "hint" in data && typeof data.hint === "string";
+const runTool = async (handler, args) => {
+    try {
+        return await handler(args);
+    }
+    catch (error) {
+        if (error instanceof ProtocolError) {
+            return textError(hasStringHint(error.data) ? `${error.message}\n${error.data.hint}` : error.message);
+        }
+        return textError(error instanceof Error ? error.message : String(error));
+    }
+};
+export const defineTool = (tool) => tool;
+export const registerTool = (server, tool) => {
+    const callback = ((args, _extra) => runTool(tool.handler, args));
+    server.registerTool(tool.name, {
+        description: tool.description,
+        inputSchema: tool.inputSchema,
+        annotations: {
+            title: tool.title,
+            readOnlyHint: tool.kind === "readOnly",
+            destructiveHint: tool.kind === "action",
+            openWorldHint: true,
+        },
+    }, callback);
+};
+//# sourceMappingURL=tool.js.map

package/dist/tool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool.js","sourceRoot":"","sources":["../src/tool.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAErD,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,IAAY,EAAkB,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,CAAC;AAErG,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC,IAAY,EAAkB,EAAE,CAAC,CAAC;IACxD,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;IACjC,OAAO,EAAE,IAAI;CAChB,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,IAAY,EAAE,QAAgB,EAAkB,EAAE,CAAC,CAAC;IAC7E,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;CAC/C,CAAC,CAAC;AAeH,MAAM,aAAa,GAAG,CAAC,IAAa,EAA4B,EAAE,CAC9D,OAAO,IAAI,KAAK,QAAQ,IAAI,IAAI,KAAK,IAAI,IAAI,MAAM,IAAI,IAAI,IAAI,OAAO,IAAI,CAAC,IAAI,KAAK,QAAQ,CAAC;AAEjG,MAAM,OAAO,GAAG,KAAK,EACjB,OAA+E,EAC/E,IAAyC,EAClB,EAAE;IACzB,IAAI,CAAC;QACD,OAAO,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/B,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACb,IAAI,KAAK,YAAY,aAAa,EAAE,CAAC;YACjC,OAAO,SAAS,CAAC,aAAa,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,OAAO,KAAK,KAAK,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QACzG,CAAC;QACD,OAAO,SAAS,CAAC,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;IAC7E,CAAC;AACL,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,UAAU,GAAG,CAA0C,IAAiB,EAAQ,EAAE,CAAC,IAAY,CAAC;AAE7G,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,MAAiB,EAAE,IAAU,EAAQ,EAAE;IAChE,MAAM,QAAQ,GAAG,CAAC,CAAC,IAAyC,EAAE,MAAe,EAAE,EAAE,CAC7E,OAAO,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,CAA4C,CAAC;IAC5E,MAAM,CAAC,YAAY,CACf,IAAI,CAAC,IAAI,EACT;QACI,WAAW,EAAE,IAAI,CAAC,WAAW;QAC7B,WAAW,EAAE,IAAI,CAAC,WAAW;QAC7B,WAAW,EAAE;YACT,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,YAAY,EAAE,IAAI,CAAC,IAAI,KAAK,UAAU;YACtC,eAAe,EAAE,IAAI,CAAC,IAAI,KAAK,QAAQ;YACvC,aAAa,EAAE,IAAI;SACtB;KACJ,EACD,QAAQ,CACX,CAAC;AACN,CAAC,CAAC","sourcesContent":["import type { McpServer, ToolCallback } from \"@modelcontextprotocol/sdk/server/mcp.js\";\nimport type { CallToolResult } from \"@modelcontextprotocol/sdk/types.js\";\nimport type { z } from \"zod\";\nimport { ProtocolError } from \"./protocol/errors.js\";\n\nexport const textContent = (text: string): CallToolResult => ({ content: [{ type: \"text\", text }] });\n\nexport const textError = (text: string): CallToolResult => ({\n    content: [{ type: \"text\", text }],\n    isError: true,\n});\n\nexport const imageContent = (data: string, mimeType: string): CallToolResult => ({\n    content: [{ type: \"image\", data, mimeType }],\n});\n\nexport type ToolArgs<Shape extends Record<string, z.ZodType>> = { [K in keyof Shape]: z.output<Shape[K]> };\n\ntype ToolKind = \"readOnly\" | \"action\";\n\nexport type Tool<Shape extends Record<string, z.ZodType> = Record<string, z.ZodType>> = {\n    name: string;\n    title: string;\n    kind: ToolKind;\n    description: string;\n    inputSchema: Shape;\n    handler: (args: ToolArgs<Shape>) => Promise<CallToolResult>;\n};\n\nconst hasStringHint = (data: unknown): data is { hint: string } =>\n    typeof data === \"object\" && data !== null && \"hint\" in data && typeof data.hint === \"string\";\n\nconst runTool = async (\n    handler: (args: ToolArgs<Record<string, z.ZodType>>) => Promise<CallToolResult>,\n    args: ToolArgs<Record<string, z.ZodType>>,\n): Promise<CallToolResult> => {\n    try {\n        return await handler(args);\n    } catch (error) {\n        if (error instanceof ProtocolError) {\n            return textError(hasStringHint(error.data) ? `${error.message}\\n${error.data.hint}` : error.message);\n        }\n        return textError(error instanceof Error ? error.message : String(error));\n    }\n};\n\nexport const defineTool = <Shape extends Record<string, z.ZodType>>(tool: Tool<Shape>): Tool => tool as Tool;\n\nexport const registerTool = (server: McpServer, tool: Tool): void => {\n    const callback = ((args: ToolArgs<Record<string, z.ZodType>>, _extra: unknown) =>\n        runTool(tool.handler, args)) as ToolCallback<Record<string, z.ZodType>>;\n    server.registerTool(\n        tool.name,\n        {\n            description: tool.description,\n            inputSchema: tool.inputSchema,\n            annotations: {\n                title: tool.title,\n                readOnlyHint: tool.kind === \"readOnly\",\n                destructiveHint: tool.kind === \"action\",\n                openWorldHint: true,\n            },\n        },\n        callback,\n    );\n};\n"]}

package/dist/transport.d.ts

@@ -0,0 +1,41 @@
+import EventEmitter from "node:events";
+import type { Socket } from "node:net";
+import type { Duplex } from "node:stream";
+import { ProtocolError } from "./protocol/errors.js";
+import { type Message, type Request } from "./protocol/schemas.js";
+export type ProtocolConnectionEvents = {
+    request: [Request];
+    invalid: [{
+        id: string;
+        error: ProtocolError;
+    }];
+};
+export declare class ConnectionClosedError extends Error {
+    constructor();
+}
+export declare class ProtocolConnection extends EventEmitter<ProtocolConnectionEvents> {
+    id: string;
+    private buffer;
+    private pending;
+    private writer;
+    constructor(writer: Duplex);
+    feed(data: Buffer | string): void;
+    write(message: Message): void;
+    static fromSocket(socket: Socket, options?: {
+        onClose?: () => void;
+        onError?: (error: Error) => void;
+    }): ProtocolConnection;
+    send<T = unknown>(method: string, params: unknown, timeout: number): Promise<T>;
+    rejectPending(error: Error): void;
+    private processLine;
+    private handleResponse;
+}
+export type AppConnectionEvents = {
+    disconnection: [ProtocolConnection];
+    request: [ProtocolConnection, Request];
+    error: [Error];
+};
+export interface AppConnections extends EventEmitter<AppConnectionEvents> {
+    send(connectionId: string, message: Message): void;
+}
+//# sourceMappingURL=transport.d.ts.map

package/dist/transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.d.ts","sourceRoot":"","sources":["../src/transport.ts"],"names":[],"mappings":"AAAA,OAAO,YAAY,MAAM,aAAa,CAAC;AACvC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AACvC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,EAA+C,aAAa,EAAuB,MAAM,sBAAsB,CAAC;AACvH,OAAO,EAAE,KAAK,OAAO,EAAE,KAAK,OAAO,EAAgD,MAAM,uBAAuB,CAAC;AAEjH,MAAM,MAAM,wBAAwB,GAAG;IACnC,OAAO,EAAE,CAAC,OAAO,CAAC,CAAC;IACnB,OAAO,EAAE,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,aAAa,CAAA;KAAE,CAAC,CAAC;CACnD,CAAC;AAQF,qBAAa,qBAAsB,SAAQ,KAAK;IAC5C,cAGC;CACJ;AAED,qBAAa,kBAAmB,SAAQ,YAAY,CAAC,wBAAwB,CAAC;IAC1E,EAAE,EAAE,MAAM,CAAuB;IACjC,OAAO,CAAC,MAAM,CAAM;IACpB,OAAO,CAAC,OAAO,CAA0C;IACzD,OAAO,CAAC,MAAM,CAAS;IAEvB,YAAY,MAAM,EAAE,MAAM,EAGzB;IAED,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAahC;IAED,KAAK,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAG5B;IAED,MAAM,CAAC,UAAU,CACb,MAAM,EAAE,MAAM,EACd,OAAO,GAAE;QACL,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;QACrB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;KAC/B,GACP,kBAAkB,CAWpB;IAED,IAAI,CAAC,CAAC,GAAG,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,CA0B9E;IAED,aAAa,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAMhC;IAED,OAAO,CAAC,WAAW;IA4BnB,OAAO,CAAC,cAAc;CAgBzB;AAED,MAAM,MAAM,mBAAmB,GAAG;IAC9B,aAAa,EAAE,CAAC,kBAAkB,CAAC,CAAC;IACpC,OAAO,EAAE,CAAC,kBAAkB,EAAE,OAAO,CAAC,CAAC;IACvC,KAAK,EAAE,CAAC,KAAK,CAAC,CAAC;CAClB,CAAC;AAEF,MAAM,WAAW,cAAe,SAAQ,YAAY,CAAC,mBAAmB,CAAC;IACrE,IAAI,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;CACtD"}

package/dist/transport.js

@@ -0,0 +1,121 @@
+import EventEmitter from "node:events";
+import { ErrorCode, invalidRequestError, isErrorCode, ProtocolError, requestTimeoutError } from "./protocol/errors.js";
+import { RequestSchema, ResponseSchema } from "./protocol/schemas.js";
+export class ConnectionClosedError extends Error {
+    constructor() {
+        super("Connection stream is not writable");
+        this.name = "ConnectionClosedError";
+    }
+}
+export class ProtocolConnection extends EventEmitter {
+    id = crypto.randomUUID();
+    buffer = "";
+    pending = new Map();
+    writer;
+    constructor(writer) {
+        super();
+        this.writer = writer;
+    }
+    feed(data) {
+        this.buffer += typeof data === "string" ? data : 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.processLine(line);
+            }
+            newlineIndex = this.buffer.indexOf("\n");
+        }
+    }
+    write(message) {
+        if (!this.writer.writable)
+            return;
+        this.writer.write(`${JSON.stringify(message)}\n`);
+    }
+    static fromSocket(socket, options = {}) {
+        const connection = new ProtocolConnection(socket);
+        socket.on("data", (data) => connection.feed(data));
+        socket.on("close", () => {
+            connection.rejectPending(new Error("Connection closed"));
+            options.onClose?.();
+        });
+        if (options.onError) {
+            socket.on("error", options.onError);
+        }
+        return connection;
+    }
+    send(method, params, timeout) {
+        return new Promise((resolve, reject) => {
+            if (!this.writer.writable) {
+                reject(new ConnectionClosedError());
+                return;
+            }
+            const id = crypto.randomUUID();
+            const timeoutHandle = setTimeout(() => {
+                this.pending.delete(id);
+                reject(requestTimeoutError(timeout));
+            }, timeout);
+            this.pending.set(id, {
+                resolve: resolve,
+                reject,
+                timeout: timeoutHandle,
+            });
+            this.write({ id, method, params });
+            if (!this.writer.writable) {
+                clearTimeout(timeoutHandle);
+                this.pending.delete(id);
+                reject(new ConnectionClosedError());
+            }
+        });
+    }
+    rejectPending(error) {
+        for (const entry of this.pending.values()) {
+            clearTimeout(entry.timeout);
+            entry.reject(error);
+        }
+        this.pending.clear();
+    }
+    processLine(line) {
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            this.emit("invalid", { id: "unknown", error: invalidRequestError("Invalid JSON") });
+            return;
+        }
+        const message = parsed;
+        if (typeof message.method === "string") {
+            const requestResult = RequestSchema.safeParse(parsed);
+            if (requestResult.success) {
+                this.emit("request", requestResult.data);
+                return;
+            }
+        }
+        else {
+            const responseResult = ResponseSchema.safeParse(parsed);
+            if (responseResult.success) {
+                this.handleResponse(responseResult.data);
+                return;
+            }
+        }
+        const id = typeof message.id === "string" ? message.id : "unknown";
+        this.emit("invalid", { id, error: invalidRequestError("Invalid message format") });
+    }
+    handleResponse(response) {
+        const entry = this.pending.get(response.id);
+        if (!entry)
+            return;
+        clearTimeout(entry.timeout);
+        this.pending.delete(response.id);
+        if (response.error) {
+            const err = response.error;
+            entry.reject(new ProtocolError(isErrorCode(err.code) ? err.code : ErrorCode.INTERNAL_ERROR, err.message, err.data));
+        }
+        else {
+            entry.resolve(response.result);
+        }
+    }
+}
+//# sourceMappingURL=transport.js.map

package/dist/transport.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.js","sourceRoot":"","sources":["../src/transport.ts"],"names":[],"mappings":"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","sourcesContent":["import EventEmitter from \"node:events\";\nimport type { Socket } from \"node:net\";\nimport type { Duplex } from \"node:stream\";\nimport { ErrorCode, invalidRequestError, isErrorCode, ProtocolError, requestTimeoutError } from \"./protocol/errors.js\";\nimport { type Message, type Request, RequestSchema, type Response, ResponseSchema } from \"./protocol/schemas.js\";\n\nexport type ProtocolConnectionEvents = {\n    request: [Request];\n    invalid: [{ id: string; error: ProtocolError }];\n};\n\ntype PendingRequest = {\n    resolve: (result: unknown) => void;\n    reject: (error: Error) => void;\n    timeout: NodeJS.Timeout;\n};\n\nexport class ConnectionClosedError extends Error {\n    constructor() {\n        super(\"Connection stream is not writable\");\n        this.name = \"ConnectionClosedError\";\n    }\n}\n\nexport class ProtocolConnection extends EventEmitter<ProtocolConnectionEvents> {\n    id: string = crypto.randomUUID();\n    private buffer = \"\";\n    private pending: Map<string, PendingRequest> = new Map();\n    private writer: Duplex;\n\n    constructor(writer: Duplex) {\n        super();\n        this.writer = writer;\n    }\n\n    feed(data: Buffer | string): void {\n        this.buffer += typeof data === \"string\" ? data : data.toString();\n\n        let newlineIndex = this.buffer.indexOf(\"\\n\");\n        while (newlineIndex !== -1) {\n            const line = this.buffer.slice(0, newlineIndex);\n            this.buffer = this.buffer.slice(newlineIndex + 1);\n\n            if (line.trim()) {\n                this.processLine(line);\n            }\n            newlineIndex = this.buffer.indexOf(\"\\n\");\n        }\n    }\n\n    write(message: Message): void {\n        if (!this.writer.writable) return;\n        this.writer.write(`${JSON.stringify(message)}\\n`);\n    }\n\n    static fromSocket(\n        socket: Socket,\n        options: {\n            onClose?: () => void;\n            onError?: (error: Error) => void;\n        } = {},\n    ): ProtocolConnection {\n        const connection = new ProtocolConnection(socket);\n        socket.on(\"data\", (data: Buffer) => connection.feed(data));\n        socket.on(\"close\", () => {\n            connection.rejectPending(new Error(\"Connection closed\"));\n            options.onClose?.();\n        });\n        if (options.onError) {\n            socket.on(\"error\", options.onError);\n        }\n        return connection;\n    }\n\n    send<T = unknown>(method: string, params: unknown, timeout: number): Promise<T> {\n        return new Promise<T>((resolve, reject) => {\n            if (!this.writer.writable) {\n                reject(new ConnectionClosedError());\n                return;\n            }\n\n            const id = crypto.randomUUID();\n            const timeoutHandle = setTimeout(() => {\n                this.pending.delete(id);\n                reject(requestTimeoutError(timeout));\n            }, timeout);\n\n            this.pending.set(id, {\n                resolve: resolve as (result: unknown) => void,\n                reject,\n                timeout: timeoutHandle,\n            });\n\n            this.write({ id, method, params });\n            if (!this.writer.writable) {\n                clearTimeout(timeoutHandle);\n                this.pending.delete(id);\n                reject(new ConnectionClosedError());\n            }\n        });\n    }\n\n    rejectPending(error: Error): void {\n        for (const entry of this.pending.values()) {\n            clearTimeout(entry.timeout);\n            entry.reject(error);\n        }\n        this.pending.clear();\n    }\n\n    private processLine(line: string): void {\n        let parsed: unknown;\n        try {\n            parsed = JSON.parse(line);\n        } catch {\n            this.emit(\"invalid\", { id: \"unknown\", error: invalidRequestError(\"Invalid JSON\") });\n            return;\n        }\n\n        const message = parsed as Record<string, unknown>;\n        if (typeof message.method === \"string\") {\n            const requestResult = RequestSchema.safeParse(parsed);\n            if (requestResult.success) {\n                this.emit(\"request\", requestResult.data);\n                return;\n            }\n        } else {\n            const responseResult = ResponseSchema.safeParse(parsed);\n            if (responseResult.success) {\n                this.handleResponse(responseResult.data);\n                return;\n            }\n        }\n\n        const id = typeof message.id === \"string\" ? message.id : \"unknown\";\n        this.emit(\"invalid\", { id, error: invalidRequestError(\"Invalid message format\") });\n    }\n\n    private handleResponse(response: Response): void {\n        const entry = this.pending.get(response.id);\n        if (!entry) return;\n\n        clearTimeout(entry.timeout);\n        this.pending.delete(response.id);\n\n        if (response.error) {\n            const err = response.error;\n            entry.reject(\n                new ProtocolError(isErrorCode(err.code) ? err.code : ErrorCode.INTERNAL_ERROR, err.message, err.data),\n            );\n        } else {\n            entry.resolve(response.result);\n        }\n    }\n}\n\nexport type AppConnectionEvents = {\n    disconnection: [ProtocolConnection];\n    request: [ProtocolConnection, Request];\n    error: [Error];\n};\n\nexport interface AppConnections extends EventEmitter<AppConnectionEvents> {\n    send(connectionId: string, message: Message): void;\n}\n"]}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gtkx/mcp",
-  "version": "0.21.0",
-  "description": "MCP server for AI-powered interaction with GTKX applications",
+  "version": "1.0.0-rc.1",
+  "description": "Model Context Protocol server that gives an agent the GTKX API reference and control of a running application",
   "keywords": [
     "gtkx",
     "gtk",
@@ -19,7 +19,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/gtkx-org/gtkx.git",
+    "url": "git+https://github.com/gtkx-org/gtkx.git",
     "directory": "packages/mcp"
   },
   "license": "MPL-2.0",
@@ -27,9 +27,9 @@
   "type": "module",
   "exports": {
     "./package.json": "./package.json",
-    ".": {
-      "types": "./dist/index.d.ts",
-      "default": "./dist/index.js"
+    "./internal": {
+      "types": "./dist/internal.d.ts",
+      "default": "./dist/internal.js"
     }
   },
   "bin": {
@@ -41,13 +41,19 @@
     "dist",
     "src"
   ],
+  "engines": {
+    "node": ">=24"
+  },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.28.0",
-    "zod": "^4.3.6"
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "zod": "^4.4.3",
+    "@gtkx/codegen": "1.0.0-rc.1",
+    "@gtkx/config": "1.0.0-rc.1",
+    "@gtkx/utils": "1.0.0-rc.1"
   },
   "scripts": {
-    "build": "tsc -b && cp ../../README.md .",
-    "test": "vitest run",
-    "typecheck": "tsc -b --emitDeclarationOnly"
+    "build": "tsc -b tsconfig.lib.json",
+    "typecheck": "tsc -b --emitDeclarationOnly",
+    "release": "tsx ../../scripts/release-package.ts"
   }
 }

package/src/app-router.ts

@@ -0,0 +1,172 @@
+import EventEmitter from "node:events";
+import {
+    appNotFoundError,
+    connectionWriteFailedError,
+    invalidRequestError,
+    methodNotFoundError,
+    noAppConnectedError,
+    type ProtocolError,
+} from "./protocol/errors.js";
+import { type AppInfo, RegisterParamsSchema, type Request, type Response } from "./protocol/schemas.js";
+import { type AppConnections, ConnectionClosedError, type ProtocolConnection } from "./transport.js";
+
+type AppRouterEventMap = {
+    appRegistered: [AppInfo];
+    appUnregistered: [string];
+};
+
+type RegisteredApp = {
+    info: AppInfo;
+    connection: ProtocolConnection;
+};
+
+const DEFAULT_REQUEST_TIMEOUT_MS = 30000;
+
+export class AppRouter extends EventEmitter<AppRouterEventMap> {
+    private static DEFAULT_WAIT_TIMEOUT = 10000;
+
+    private apps: Map<string, RegisteredApp> = new Map();
+    private connectionToApp: Map<string, string> = new Map();
+    private requestTimeout: number;
+    private connections: AppConnections;
+
+    constructor(connections: AppConnections, options: { requestTimeout?: number } = {}) {
+        super();
+        this.connections = connections;
+        this.requestTimeout = options.requestTimeout ?? DEFAULT_REQUEST_TIMEOUT_MS;
+
+        this.connections.on("request", (connection, request) => {
+            this.handleRequest(connection, request);
+        });
+
+        this.connections.on("disconnection", (connection) => {
+            this.removeApp(connection);
+        });
+    }
+
+    getApps(): AppInfo[] {
+        return Array.from(this.apps.values()).map((app) => app.info);
+    }
+
+    hasConnectedApps(): boolean {
+        return this.apps.size > 0;
+    }
+
+    getDefaultApp(): RegisteredApp | undefined {
+        const first = this.apps.values().next();
+        return first.done ? undefined : first.value;
+    }
+
+    getProjectRoot(): string | undefined {
+        return this.getDefaultApp()?.info.projectRoot;
+    }
+
+    waitForApp(timeout: number = AppRouter.DEFAULT_WAIT_TIMEOUT): Promise<AppInfo> {
+        const defaultApp = this.getDefaultApp();
+        if (defaultApp) {
+            return Promise.resolve(defaultApp.info);
+        }
+
+        return new Promise((resolve, reject) => {
+            const timeoutId = setTimeout(() => {
+                this.off("appRegistered", onRegister);
+                reject(
+                    new Error(
+                        `Timeout waiting for app registration after ${timeout}ms. ` +
+                            "Make sure your GTKX app is running with 'gtkx dev'.",
+                    ),
+                );
+            }, timeout);
+
+            const onRegister = (appInfo: AppInfo) => {
+                clearTimeout(timeoutId);
+                this.off("appRegistered", onRegister);
+                resolve(appInfo);
+            };
+
+            this.on("appRegistered", onRegister);
+        });
+    }
+
+    async sendToApp<T>(applicationId: string | undefined, method: string, params?: unknown): Promise<T> {
+        const app = applicationId ? this.apps.get(applicationId) : this.getDefaultApp();
+
+        if (!app) {
+            if (applicationId) {
+                throw appNotFoundError(applicationId);
+            }
+            throw noAppConnectedError();
+        }
+
+        try {
+            return await app.connection.send<T>(method, params, this.requestTimeout);
+        } catch (error) {
+            if (error instanceof ConnectionClosedError) {
+                this.removeApp(app.connection);
+                throw connectionWriteFailedError(app.info.applicationId);
+            }
+            throw error;
+        }
+    }
+
+    private handleRequest(connection: ProtocolConnection, request: Request): void {
+        if (request.method === "app.register") {
+            this.handleRegister(connection, request);
+        } else if (request.method === "app.unregister") {
+            this.handleUnregister(connection, request);
+        } else {
+            this.sendError(connection, request, methodNotFoundError(request.method));
+        }
+    }
+
+    private handleRegister(connection: ProtocolConnection, request: Request): void {
+        const parseResult = RegisterParamsSchema.safeParse(request.params);
+        if (!parseResult.success) {
+            this.sendError(connection, request, invalidRequestError(parseResult.error.message));
+            return;
+        }
+
+        const params = parseResult.data;
+        const appInfo: AppInfo = {
+            applicationId: params.applicationId,
+            pid: params.pid,
+            ...(params.projectRoot === undefined ? {} : { projectRoot: params.projectRoot }),
+        };
+
+        this.apps.set(params.applicationId, { info: appInfo, connection });
+        this.connectionToApp.set(connection.id, params.applicationId);
+
+        this.acknowledge(connection, request);
+
+        this.emit("appRegistered", appInfo);
+    }
+
+    private handleUnregister(connection: ProtocolConnection, request: Request): void {
+        this.removeApp(connection);
+        this.acknowledge(connection, request);
+    }
+
+    private acknowledge(connection: ProtocolConnection, request: Request): void {
+        const response: Response = {
+            id: request.id,
+            result: { success: true },
+        };
+        this.connections.send(connection.id, response);
+    }
+
+    private sendError(connection: ProtocolConnection, request: Request, error: ProtocolError): void {
+        this.connections.send(connection.id, {
+            id: request.id,
+            error: error.toErrorObject(),
+        });
+    }
+
+    private removeApp(connection: ProtocolConnection): void {
+        const applicationId = this.connectionToApp.get(connection.id);
+        this.connectionToApp.delete(connection.id);
+        if (applicationId === undefined) return;
+        if (this.apps.get(applicationId)?.connection !== connection) return;
+        this.apps.delete(applicationId);
+        this.emit("appUnregistered", applicationId);
+    }
+}

package/src/connection-registry.ts

@@ -0,0 +1,42 @@
+import EventEmitter from "node:events";
+import type { Socket } from "node:net";
+import type { Message } from "./protocol/schemas.js";
+import { type AppConnectionEvents, type AppConnections, ProtocolConnection } from "./transport.js";
+
+export class ConnectionRegistry extends EventEmitter<AppConnectionEvents> implements AppConnections {
+    private connections: Map<string, ProtocolConnection> = new Map();
+    private sockets: Map<string, Socket> = new Map();
+
+    register(socket: Socket): ProtocolConnection {
+        const connection = ProtocolConnection.fromSocket(socket, {
+            onClose: () => {
+                this.connections.delete(connection.id);
+                this.sockets.delete(connection.id);
+                this.emit("disconnection", connection);
+            },
+            onError: (error) => this.emit("error", error),
+        });
+        this.connections.set(connection.id, connection);
+        this.sockets.set(connection.id, socket);
+        connection.on("request", (request) => this.emit("request", connection, request));
+        connection.on("invalid", ({ id: badId, error }) => {
+            connection.write({ id: badId, error: error.toErrorObject() });
+        });
+        return connection;
+    }
+
+    send(connectionId: string, message: Message): void {
+        const connection = this.connections.get(connectionId);
+        if (!connection) return;
+        connection.write(message);
+    }
+
+    dispose(reason: string): void {
+        for (const connection of this.connections.values()) {
+            connection.rejectPending(new Error(reason));
+        }
+        for (const socket of this.sockets.values()) {
+            socket.destroy();
+        }
+    }
+}

package/src/internal.ts

@@ -0,0 +1,17 @@
+export {
+    ErrorCode,
+    invalidRequestError,
+    methodNotFoundError,
+    ProtocolError,
+    widgetNotFoundError,
+} from "./protocol/errors.js";
+export {
+    DEFAULT_SOCKET_PATH,
+    type ParamsSchema,
+    type Request,
+    type SerializedWidget,
+    type ServerInitiatedMethod,
+    type ServerRequestParams,
+    ServerRequestParamsSchemas,
+} from "./protocol/schemas.js";
+export { ProtocolConnection } from "./transport.js";