@gtkx/cli 1.4.0 → 1.6.0

package/src/i18n/types.ts

@@ -0,0 +1,154 @@
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import type { SourceMessage } from "./source-messages.js";
+
+type I18nTypesResult = {
+    isWritten: boolean;
+    path: string;
+};
+
+const I18N_TYPES_FILENAME = "i18n.d.ts";
+const INTERPOLATION_PATTERN = /\{\{[^{}]+\}\}/u;
+
+const stringType = (values: string[]): string =>
+    [...new Set(values)].map((value) => JSON.stringify(value)).join(" | ");
+
+const contextField = (context: string | null): string =>
+    context === null ? "" : ` context: ${JSON.stringify(context)};`;
+
+const hasInterpolation = (values: string[]): boolean => values.some((value) => INTERPOLATION_PATTERN.test(value));
+
+const pointVariant = (message: SourceMessage): string => {
+    const isRequired = message.context !== null || hasInterpolation([message.msgid]);
+    const isInterpolated = hasInterpolation([message.msgid]);
+
+    return (
+        `{${contextField(message.context)} interpolated: ${String(isInterpolated)}; kind: "point"; ` +
+        `required: ${String(isRequired)}; value: ${JSON.stringify(message.msgid)} }`
+    );
+};
+
+const defaultVariant = (message: SourceMessage): string => {
+    const values = [message.singular];
+    const isInterpolated = hasInterpolation(values);
+    const isRequired = message.context !== null || isInterpolated;
+
+    return (
+        `{${contextField(message.context)} defaultValue: ${JSON.stringify(message.singular)}; ` +
+        `interpolated: ${String(isInterpolated)}; kind: "default"; required: ${String(isRequired)}; ` +
+        `value: ${stringType(values)} }`
+    );
+};
+
+const requirePlural = (message: SourceMessage): string => {
+    if (message.plural === null) {
+        throw new Error("Plural translation metadata requires a plural source string");
+    }
+
+    return message.plural;
+};
+
+const pluralVariant = (message: SourceMessage): string => {
+    const plural = requirePlural(message);
+    const values = [message.singular, plural];
+    const isInterpolated = hasInterpolation(values);
+
+    return (
+        `{${contextField(message.context)} defaultValue: ${JSON.stringify(plural)}; ` +
+        `interpolated: ${String(isInterpolated)}; kind: "plural"; required: true; ` +
+        `value: ${stringType(values)} }`
+    );
+};
+
+const pluralDefaultsVariant = (message: SourceMessage): string => {
+    const plural = requirePlural(message);
+    const values = [message.singular, plural];
+    const isInterpolated = hasInterpolation(values);
+
+    return (
+        `{${contextField(message.context)} defaultValueOne: ${JSON.stringify(message.singular)}; ` +
+        `defaultValueOther: ${JSON.stringify(plural)}; interpolated: ${String(isInterpolated)}; ` +
+        `kind: "pluralDefaults"; required: true; value: ${stringType(values)} }`
+    );
+};
+
+const variantsFor = (message: SourceMessage): string[] => {
+    if (message.kind === "plural") {
+        return [pluralVariant(message)];
+    }
+
+    if (message.kind === "pluralDefaults") {
+        return [pluralDefaultsVariant(message)];
+    }
+
+    return message.kind === "default" ? [defaultVariant(message)] : [pointVariant(message)];
+};
+
+const renderRegistry = (messages: SourceMessage[]): string[] => {
+    const entries: Map<string, Set<string>> = new Map();
+
+    for (const message of messages) {
+        const variants = entries.get(message.msgid) ?? new Set<string>();
+
+        for (const variant of variantsFor(message)) {
+            variants.add(variant);
+        }
+
+        entries.set(message.msgid, variants);
+    }
+
+    return [...entries]
+        .toSorted(([left], [right]) => left.localeCompare(right))
+        .map(([msgid, variants]) => `        ${JSON.stringify(msgid)}: ${[...variants].join(" | ")};`);
+};
+
+const generatedHeader = (): string[] => [
+    "/**",
+    " * Translation declarations generated by GTKX. Regenerated by",
+    " * `gtkx codegen`, `gtkx dev`, and `gtkx build`; do not edit.",
+    " */",
+];
+
+const renderI18nTypes = (messages: SourceMessage[], isEnabled = true): string => {
+    if (!isEnabled) {
+        return [...generatedHeader(), "export {};", ""].join("\n");
+    }
+
+    return [
+        ...generatedHeader(),
+        'import "@gtkx/i18n";',
+        "",
+        'declare module "@gtkx/i18n" {',
+        "    interface TranslationRegistry {",
+        ...renderRegistry(messages),
+        "    }",
+        "}",
+        "",
+    ].join("\n");
+};
+
+const i18nTypesPath = (root: string): string => join(root, "node_modules", ".gtkx", I18N_TYPES_FILENAME);
+
+const readFileOrNull = (path: string): string | null => {
+    try {
+        return readFileSync(path, "utf8");
+    } catch {
+        return null;
+    }
+};
+
+const emitI18nTypes = (root: string, messages: SourceMessage[], isEnabled = true): I18nTypesResult => {
+    const path = i18nTypesPath(root);
+    const content = renderI18nTypes(messages, isEnabled);
+
+    if (readFileOrNull(path) === content) {
+        return { isWritten: false, path };
+    }
+
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, content);
+
+    return { isWritten: true, path };
+};
+
+export { I18N_TYPES_FILENAME, emitI18nTypes, i18nTypesPath };

package/src/internal/agent-rules.ts

@@ -0,0 +1,135 @@
+import { readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { REFERENCE_PATH } from "../codegen/reference.js";
+
+type AgentRulesResult = {
+    isWritten: boolean;
+    files: string[];
+};
+
+const AGENTS_FILENAME = "AGENTS.md";
+const CLAUDE_FILENAME = "CLAUDE.md";
+const CLAUDE_CONTENTS = `@${AGENTS_FILENAME}\n`;
+const BEGIN_MARKER = "<!-- BEGIN:gtkx-agent-rules -->";
+const END_MARKER = "<!-- END:gtkx-agent-rules -->";
+const BLOCK_PATTERN = /<!-- BEGIN:gtkx-agent-rules -->[\s\S]*?<!-- END:gtkx-agent-rules -->/;
+const TOP_LEVEL_HEADING = /^# /m;
+
+const rulesBody = (heading: string): string[] => [
+    `${heading} GTKX`,
+    "",
+    "This is not the GTK you have seen before. Most GTK code in your training data is C, PyGObject, Vala or " +
+    "GJS, and almost none of it is valid here. Check the rules below against what you are about to write.",
+    "",
+    "- Children are JSX, never `.append()`, `pack_start()`, `set_child()` or `add()`.",
+    '- Signals are props: `onClicked`, not `widget.connect("clicked", ...)`.',
+    "- Props are camelCase: `marginTop`, not `margin-top` or `margin_top`.",
+    "- There is no `Gtk.Template`, no `.ui` XML, and no `GtkBuilder`. The JSX tree is the definition.",
+    "- Elements come from `@gtkx/jsx/<namespace>` and classes, enums and functions from " +
+    "`@gtkx/gi/<namespace>`. Both are generated for this project by `gtkx codegen`, not installed from npm, " +
+    "so they match the GIR libraries this project declares.",
+    "",
+    `Read \`${REFERENCE_PATH}/index.md\` before writing widget code. It is generated from this project's own ` +
+    "GIR libraries and is the authority on which props, signals and methods exist. Do not infer a prop from " +
+    "another toolkit, from a C function name, or from a similar element.",
+    "",
+    "| Command | What it does |",
+    "| --- | --- |",
+    "| `gtkx dev` | Run the app with fast refresh |",
+    "| `gtkx codegen` | Regenerate bindings and this reference |",
+    "| `tsc --noEmit` | Typecheck |",
+    "| `vitest run` | Run the tests |",
+    "",
+    "Never call UI work done without looking at the running app. With `gtkx dev` up, the gtkx MCP server " +
+    "exposes the live widget tree, queries, clicks and screenshots; use them to confirm the change landed.",
+    "",
+    "This block is written by `gtkx codegen`. Anything outside the markers is yours and is left alone, and " +
+    "committing the block with your work keeps the tree clean.",
+];
+
+const renderBlock = (heading: string): string =>
+    [BEGIN_MARKER, "", ...rulesBody(heading), "", END_MARKER].join("\n");
+
+const headingFor = (contents: string): string => (TOP_LEVEL_HEADING.test(contents) ? "##" : "#");
+const withTrailingNewline = (contents: string): string => (contents.endsWith("\n") ? contents : `${contents}\n`);
+
+const appendBlock = (contents: string, block: string): string => {
+    if (contents.trim() === "") {
+        return `${block}\n`;
+    }
+
+    return `${withTrailingNewline(contents)}\n${block}\n`;
+};
+
+const replaceBlock = (contents: string, block: string): string => {
+    const match = BLOCK_PATTERN.exec(contents);
+
+    if (match === null) {
+        return appendBlock(contents, block);
+    }
+
+    return contents.slice(0, match.index) + block + contents.slice(match.index + match[0].length);
+};
+
+const nextContents = (contents: string): string => {
+    const heading = headingFor(contents.replace(BLOCK_PATTERN, ""));
+
+    return replaceBlock(contents, renderBlock(heading));
+};
+
+const errorCode = (error: unknown): string | undefined =>
+    error instanceof Error ? (error as NodeJS.ErrnoException).code : undefined;
+
+const readOrUndefined = (path: string): string | undefined => {
+    try {
+        return readFileSync(path, "utf8");
+    } catch (error) {
+        if (errorCode(error) === "ENOENT") {
+            return undefined;
+        }
+
+        throw error;
+    }
+};
+
+const hasWritten = (path: string, contents: string): boolean => {
+    if (readOrUndefined(path) === contents) {
+        return false;
+    }
+
+    writeFileSync(path, contents);
+
+    return true;
+};
+
+const hasWrittenClaudeImport = (root: string): boolean => {
+    try {
+        writeFileSync(join(root, CLAUDE_FILENAME), CLAUDE_CONTENTS, { flag: "wx" });
+
+        return true;
+    } catch (error) {
+        if (errorCode(error) === "EEXIST") {
+            return false;
+        }
+
+        throw error;
+    }
+};
+
+const upsertAgentRules = (root: string): AgentRulesResult => {
+    const agentsPath = join(root, AGENTS_FILENAME);
+    const existing = readOrUndefined(agentsPath) ?? "";
+    const files: string[] = [];
+
+    if (hasWritten(agentsPath, nextContents(existing))) {
+        files.push(AGENTS_FILENAME);
+    }
+
+    if (hasWrittenClaudeImport(root)) {
+        files.push(CLAUDE_FILENAME);
+    }
+
+    return { isWritten: files.length > 0, files };
+};
+
+export { upsertAgentRules };

package/src/internal/docs-elements.ts

@@ -0,0 +1,21 @@
+import { type ElementProps, type OmittedProps, readBuiltinElements, resolveStore } from "@gtkx/codegen";
+import { existsSync } from "node:fs";
+
+type DocsElements = {
+    props: ElementProps;
+    omittedProps: OmittedProps;
+};
+
+const resolveDocsElements = async (cwd: string): Promise<DocsElements> => {
+    const { gi, reactSubexports } = resolveStore(cwd);
+
+    if (!existsSync(gi.storeDir)) {
+        return { props: {}, omittedProps: {} };
+    }
+
+    const { props, omittedProps } = await readBuiltinElements(reactSubexports, gi.storeDir);
+
+    return { props, omittedProps };
+};
+
+export { resolveDocsElements };

package/src/internal/source-imports.ts

@@ -1,8 +1,8 @@
-import type { ParseResult, ParserOptions } from "vite";
-import { isRecord, sortStringsBy } from "@gtkx/utils";
+import type { ESTree, ParseResult, ParserOptions } from "vite";
+import { sortStringsBy } from "@gtkx/utils";
 import { type Dirent, readdirSync, readFileSync } from "node:fs";
 import { extname, join } from "node:path";
-import { parseSync } from "vite";
+import { parseSync, Visitor } from "vite";
 
 type SourceImport = {
     importer: string;
@@ -24,8 +24,6 @@ const SOURCE_LANGUAGES: Map<string, SourceLanguage> = new Map([
 ]);
 
 const EXCLUDED_DIRECTORIES: Set<string> = new Set([
-    ".git",
-    ".gtkx",
     "build",
     "coverage",
     "dist",
@@ -41,11 +39,13 @@ const sourceLanguage = (path: string): SourceLanguage | 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);
 
     if (entry.isDirectory()) {
-        if (!EXCLUDED_DIRECTORIES.has(entry.name)) {
+        if (isWalkableDirectory(entry.name)) {
             sourceFilesIn(path, found);
         }
 
@@ -71,6 +71,13 @@ const sourceFilesIn = (dir: string, found: string[]): void => {
     }
 };
 
+const discoverSourceFiles = (dir: string): string[] => {
+    const files: string[] = [];
+    sourceFilesIn(dir, files);
+
+    return sortStringsBy(files, (path) => path);
+};
+
 const staticImportSources = (module: ParsedModule): string[] => [
     ...module.staticImports.map((statement) => statement.moduleRequest.value),
     ...module.staticExports.flatMap((statement) =>
@@ -92,65 +99,30 @@ const staticRuntimeImportSources = (module: ParsedModule): string[] => [
     ),
 ];
 
-const templateImportSource = (node: Record<string, unknown>): string | null => {
-    if (!Array.isArray(node.expressions) || node.expressions.length > 0 || !Array.isArray(node.quasis)) {
-        return null;
-    }
-
-    const quasis: unknown[] = node.quasis;
-    const first: unknown = quasis[0];
-
-    if (!isRecord(first) || !isRecord(first.value)) {
-        return null;
-    }
-
-    return typeof first.value.cooked === "string" ? first.value.cooked : null;
-};
-
-const literalImportSource = (node: unknown): string | null => {
-    if (!isRecord(node)) {
-        return null;
-    }
-
-    if (node.type === "Literal") {
-        return typeof node.value === "string" ? node.value : null;
-    }
+const templateImportSource = (node: ESTree.TemplateLiteral): string | null => {
+    const [quasi] = node.quasis;
 
-    return node.type === "TemplateLiteral" ? templateImportSource(node) : null;
-};
-
-const collectDynamicImportArray = (nodes: unknown[], found: string[]): void => {
-    for (const child of nodes) {
-        collectDynamicImportSources(child, found);
-    }
+    return quasi === undefined || node.expressions.length > 0 ? null : quasi.value.cooked;
 };
 
-const collectDynamicImportRecord = (node: Record<string, unknown>, found: string[]): void => {
-    if (node.type === "ImportExpression") {
-        const source = literalImportSource(node.source);
-
-        if (source !== null) {
-            found.push(source);
-        }
-
-        return;
+const literalImportSource = (node: ESTree.Expression): string | null => {
+    if (node.type === "TemplateLiteral") {
+        return templateImportSource(node);
     }
 
-    collectDynamicImportArray(Object.values(node), found);
+    return node.type === "Literal" && typeof node.value === "string" ? node.value : null;
 };
 
-const collectDynamicImportSources = (node: unknown, found: string[]): void => {
-    if (Array.isArray(node)) {
-        collectDynamicImportArray(node, found);
+const collectDynamicImportSources = (program: ESTree.Program, found: string[]): void => {
+    new Visitor({
+        ImportExpression: (node) => {
+            const source = literalImportSource(node.source);
 
-        return;
-    }
-
-    if (!isRecord(node)) {
-        return;
-    }
-
-    collectDynamicImportRecord(node, found);
+            if (source !== null) {
+                found.push(source);
+            }
+        },
+    }).visit(program);
 };
 
 const parseImportsInWith = (
@@ -190,11 +162,10 @@ const importsIn = (path: string): SourceImport[] => parseImportsIn(path) ?? [];
 const importKey = (entry: SourceImport): string => `${entry.importer}\0${entry.source}`;
 
 const discoverSourceImports = (dir: string): SourceImport[] => {
-    const files: string[] = [];
-    sourceFilesIn(dir, files);
+    const files = discoverSourceFiles(dir);
     const imports = files.flatMap((path) => importsIn(path));
 
     return sortStringsBy(imports, importKey);
 };
 
-export { discoverSourceImports, parseRuntimeImportsIn, type SourceImport };
+export { discoverSourceFiles, discoverSourceImports, parseRuntimeImportsIn, type SourceImport, sourceLanguage };

package/src/mcp/client-config.ts

@@ -0,0 +1,130 @@
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+type ClientName = "claude" | "cursor" | "vscode" | "opencode" | "codex";
+type ServerEntry = Record<string, unknown>;
+
+type Client = {
+    name: ClientName;
+    file: string;
+    key: string;
+    entry: ServerEntry;
+};
+
+type ClientResult =
+    | { kind: "written"; path: string; isCreated: boolean } |
+    { kind: "manual"; path: string; snippet: string };
+
+const SERVER_NAME = "gtkx";
+const COMMAND = "npx";
+const ARGS = ["gtkx", "mcp"];
+const CODEX_PATH = "~/.codex/config.toml";
+
+const CODEX_SNIPPET = [
+    `[mcp_servers.${SERVER_NAME}]`,
+    `command = ${JSON.stringify(COMMAND)}`,
+    `args = ${JSON.stringify(ARGS)}`,
+].join("\n");
+
+const CLIENTS: Client[] = [
+    {
+        name: "claude",
+        file: ".mcp.json",
+        key: "mcpServers",
+        entry: { command: COMMAND, args: ARGS },
+    },
+    {
+        name: "cursor",
+        file: join(".cursor", "mcp.json"),
+        key: "mcpServers",
+        entry: { command: COMMAND, args: ARGS },
+    },
+    {
+        name: "vscode",
+        file: join(".vscode", "mcp.json"),
+        key: "servers",
+        entry: { type: "stdio", command: COMMAND, args: ARGS },
+    },
+    {
+        name: "opencode",
+        file: "opencode.json",
+        key: "mcp",
+        entry: { type: "local", command: [COMMAND, ...ARGS], enabled: true },
+    },
+    {
+        name: "codex",
+        file: CODEX_PATH,
+        key: "mcp_servers",
+        entry: {},
+    },
+];
+
+const CLIENT_NAMES: Set<string> = new Set(CLIENTS.map((client) => client.name));
+
+const isClientName = (value: string): value is ClientName => CLIENT_NAMES.has(value);
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+    typeof value === "object" && value !== null && !Array.isArray(value);
+
+const readOrUndefined = (path: string): string | undefined => {
+    try {
+        return readFileSync(path, "utf8");
+    } catch (error) {
+        if (error instanceof Error && (error as NodeJS.ErrnoException).code === "ENOENT") {
+            return undefined;
+        }
+
+        throw error;
+    }
+};
+
+const readJson = (path: string): Record<string, unknown> | undefined => {
+    const source = readOrUndefined(path);
+
+    if (source === undefined) {
+        return undefined;
+    }
+
+    const parsed: unknown = JSON.parse(source);
+
+    if (!isRecord(parsed)) {
+        throw new Error(`Refusing to edit ${path}: its contents are not a JSON object.`);
+    }
+
+    return parsed;
+};
+
+const getSection = (document: Record<string, unknown>, key: string): Record<string, unknown> => {
+    const section = document[key];
+
+    return isRecord(section) ? section : {};
+};
+
+const clientFor = (name: ClientName): Client => {
+    const client = CLIENTS.find((candidate) => candidate.name === name);
+
+    if (client === undefined) {
+        throw new Error(`Unknown MCP client "${name}".`);
+    }
+
+    return client;
+};
+
+const writeClientConfig = (root: string, name: ClientName): ClientResult => {
+    const client = clientFor(name);
+
+    if (name === "codex") {
+        return { kind: "manual", path: CODEX_PATH, snippet: CODEX_SNIPPET };
+    }
+
+    const path = join(root, client.file);
+    const existing = readJson(path);
+    const document = existing ?? {};
+    const section = { ...getSection(document, client.key), [SERVER_NAME]: client.entry };
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, `${JSON.stringify({ ...document, [client.key]: section }, null, 4)}\n`);
+
+    return { kind: "written", path, isCreated: existing === undefined };
+};
+
+export { CLIENTS, isClientName, writeClientConfig, type ClientName, type ClientResult };

package/src/mcp/client.ts

@@ -1,7 +1,13 @@
 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 {
+    DEFAULT_SOCKET_PATH,
+    isConnectionClosedError,
+    type JSONRPCRequest,
+    ProtocolConnection,
+    type Result,
+} from "@gtkx/mcp/internal";
+import { error, errorMessage, info, normalizeError } from "@gtkx/utils";
 import * as net from "node:net";
 import { dispatch } from "./handlers.js";
 import { WidgetRegistry } from "./widget-registry.js";
@@ -25,11 +31,6 @@ const RECONNECT_DELAY_MS = 2000;
 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;
 
@@ -82,7 +83,7 @@ class McpClient {
     private handleSocketError(socketError: Error): void {
         const code = (socketError as NodeJS.ErrnoException).code;
 
-        if (code !== undefined && DISCONNECT_ERROR_CODES.has(code)) {
+        if (isConnectionClosedError(socketError) || (code !== undefined && DISCONNECT_ERROR_CODES.has(code))) {
             this.scheduleReconnect();
         } else {
             error("Socket error:", socketError.message);
@@ -119,14 +120,7 @@ class McpClient {
             },
         });
 
-        connection.on("request", (request) => {
-            void this.handleRequest(request);
-        });
-
-        connection.on("invalid", ({ error: parseError }) => {
-            warn(`Received invalid JSON from MCP server: ${parseError.message}`);
-        });
-
+        connection.fallbackRequestHandler = (request) => this.handleRequest(request);
         this.socket = socket;
         this.connection = connection;
     }
@@ -158,35 +152,16 @@ class McpClient {
         );
     }
 
-    private async respondToRequest(request: Request): Promise<void> {
-        const { id, method, params } = request;
-        const connection = this.connection;
+    private handleRequest(request: JSONRPCRequest): Promise<Result> {
+        const defaultApp = Gio.Application.getDefault();
 
-        if (!connection) {
-            return;
+        if (!(defaultApp instanceof Gtk.Application)) {
+            throw new TypeError("Application not initialized");
         }
 
-        try {
-            const defaultApp = Gio.Application.getDefault();
-
-            if (!(defaultApp instanceof Gtk.Application)) {
-                throw new TypeError("Application not initialized");
-            }
+        this.registry.refresh();
 
-            this.registry.refresh();
-            const result = await dispatch(method, params, { app: defaultApp, registry: this.registry });
-            connection.write({ id, result });
-        } 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);
-        }
+        return dispatch(request.method, request.params, { app: defaultApp, registry: this.registry });
     }
 
     async connect(): Promise<void> {
@@ -219,10 +194,8 @@ class McpClient {
             this.reconnectTimer = null;
         }
 
-        this.connection?.rejectPending(new Error("Client disconnected"));
-
         if (this.socket) {
-            this.connection?.write({ id: crypto.randomUUID(), method: "app.unregister" });
+            void Promise.allSettled([this.connection?.send("app.unregister")]);
             this.socket.destroy();
             this.socket = null;
         }