auvrynt 1.0.2 → 1.0.5

package/dist/server/tools/core-file-tools-registration.js

@@ -0,0 +1,459 @@
+import { createHash, randomUUID } from "node:crypto";
+import { readFile, rename, unlink, writeFile } from "node:fs/promises";
+import { generateUnifiedPatch } from "@earendil-works/pi-coding-agent";
+import * as z from "zod/v4";
+import { logEvent } from "../../logger.js";
+import { editFileTool, findFilesTool, grepFilesTool, listDirectoryTool, readFileTool, runShellTool, } from "../../pi-tools.js";
+import { executeViewImage } from "../../view-image.js";
+import { registerAppTool } from "../mcp-tool-registrar.js";
+import { countTextLines } from "../workspace-analytics.js";
+import { EDIT_TOOL_ANNOTATIONS, SHELL_TOOL_ANNOTATIONS, VIEW_IMAGE_TOOL_ANNOTATIONS, WRITE_TOOL_ANNOTATIONS, resultOutputSchema, toolWidgetDescriptorMeta, } from "../tool-registration-shared.js";
+const MAX_WRITE_SIZE = 50 * 1024 * 1024;
+async function safeWriteFile(filePath, content) {
+    const tempPath = `${filePath}.tmp.${randomUUID()}`;
+    try {
+        await writeFile(tempPath, content, "utf8");
+        await rename(tempPath, filePath);
+    }
+    catch (error) {
+        await unlink(tempPath).catch(() => undefined);
+        throw error;
+    }
+}
+function contentText(content) {
+    return content.map((block) => block.type === "text" ? block.text : `[${block.mimeType} image]`).join("\n");
+}
+function textBlock(text) {
+    return { type: "text", text };
+}
+function textSummary(content) {
+    return {
+        blocks: content.length,
+        characters: content.filter((block) => block.type === "text")
+            .reduce((total, block) => total + block.text.length, 0),
+        images: content.filter((block) => block.type === "image").length,
+    };
+}
+function contentLineCount(content) {
+    return countTextLines(content);
+}
+async function readExistingTextFile(filePath) {
+    try {
+        return await readFile(filePath, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw error;
+    }
+}
+function countDiffStats(diff) {
+    if (!diff)
+        return { additions: 0, removals: 0 };
+    let additions = 0;
+    let removals = 0;
+    for (const line of diff.split(/\r?\n/)) {
+        if (line.startsWith("+++") || line.startsWith("---"))
+            continue;
+        if (line.startsWith("+"))
+            additions++;
+        if (line.startsWith("-"))
+            removals++;
+    }
+    return { additions, removals };
+}
+function contentLines(content) {
+    if (content.length === 0)
+        return [];
+    const lines = content.replace(/\r\n/g, "\n").split("\n");
+    if (lines.at(-1) === "")
+        lines.pop();
+    return lines;
+}
+function newFilePatch(path, content) {
+    const lines = contentLines(content);
+    const body = lines.map((line) => `+${line}`).join("\n");
+    return `--- /dev/null\n+++ b/${path}\n@@ -0,0 +1,${lines.length} @@\n${body}`;
+}
+export function registerCoreFileTools(server, config, workspaces, reviewCheckpoints, toolNames, workspaceChanges, logToolCall, logFailedToolResponse) {
+    registerAppTool(server, toolNames.read, {
+        title: "Read file",
+        description: [
+            "Read a file inside an open workspace. Use this for file inspection instead of shell commands like cat or sed. Call open_workspace first and pass workspaceId.",
+            "Use this tool to inspect relevant AGENTS.md or CLAUDE.md files listed by open_workspace before working in nested directories.",
+            config.skillsEnabled
+                ? "If available skills were returned and a task matches one, read that skill's path before proceeding. Skill paths may be outside the workspace; only advertised SKILL.md files and files under already-loaded skill directories are readable."
+                : "",
+        ].filter(Boolean).join(" "),
+        inputSchema: {
+            workspaceId: z.string().describe("Workspace identifier returned by open_workspace."),
+            path: z.string().describe(config.skillsEnabled
+                ? "File path to read, relative to the workspace root. May also be an advertised skill path from open_workspace skills."
+                : "File path to read, relative to the workspace root."),
+            offset: z.number().int().positive().optional().describe("1-indexed line number to start reading from."),
+            limit: z.number().int().positive().optional().describe("Maximum number of lines to read."),
+        },
+        outputSchema: resultOutputSchema(),
+        ...toolWidgetDescriptorMeta(config, "read"),
+        annotations: { readOnlyHint: true },
+    }, async ({ workspaceId, ...input }) => {
+        const startedAt = performance.now();
+        const workspace = workspaces.getWorkspace(workspaceId);
+        const readPath = workspaces.resolveReadPath(workspace, input.path);
+        const response = await readFileTool({ ...input, path: readPath.absolutePath }, {
+            cwd: workspace.root,
+            root: workspace.root,
+            readRoots: readPath.readRoots,
+        });
+        if (response.isError) {
+            logFailedToolResponse(config, { tool: toolNames.read, workspaceId, path: input.path }, response.content, startedAt);
+            return response;
+        }
+        workspaces.markReadPathLoaded(workspace, readPath);
+        logToolCall(config, {
+            tool: toolNames.read, workspaceId, path: input.path, success: true,
+            durationMs: Math.round(performance.now() - startedAt),
+        });
+        return {
+            ...response,
+            _meta: {
+                tool: toolNames.read,
+                card: {
+                    workspaceId, path: input.path,
+                    summary: {
+                        ...textSummary(response.content),
+                        lines: contentLineCount(contentText(response.content)),
+                        offset: input.offset ?? 1,
+                        limited: input.limit !== undefined,
+                    },
+                    payload: { content: response.content },
+                },
+            },
+            structuredContent: { result: contentText(response.content) },
+        };
+    });
+    registerAppTool(server, "view_image", {
+        title: "View image",
+        description: "View a local image file (.png, .jpg, .jpeg, .webp, .gif) inside an open workspace as visual MCP image content. Use this when asked to inspect, describe, analyze, or compare images. Call open_workspace first and pass workspaceId.",
+        inputSchema: {
+            workspaceId: z.string().describe("Workspace identifier returned by open_workspace."),
+            path: z.string().describe("Image file path, relative to the workspace root."),
+        },
+        ...toolWidgetDescriptorMeta(config, "read"), annotations: VIEW_IMAGE_TOOL_ANNOTATIONS,
+    }, async ({ workspaceId, path }) => {
+        const startedAt = performance.now();
+        const response = await executeViewImage(workspaces, { workspaceId, path });
+        if (response.isError) {
+            logFailedToolResponse(config, { tool: "view_image", workspaceId, path }, response.content, startedAt);
+            return response;
+        }
+        logToolCall(config, {
+            tool: "view_image", workspaceId, path, success: true,
+            durationMs: Math.round(performance.now() - startedAt),
+        });
+        return response;
+    });
+    registerAppTool(server, toolNames.write, {
+        title: "Write file",
+        description: `Create or completely overwrite a file inside an open workspace. Prefer ${toolNames.edit} for targeted changes to existing files. Call open_workspace first and pass workspaceId.`,
+        inputSchema: {
+            workspaceId: z.string().describe("Workspace identifier returned by open_workspace."),
+            path: z.string().describe("File path to write, relative to the workspace root."),
+            content: z.string().describe("Complete new file content."),
+            expectedVersion: z.string().optional().describe("Expected SHA-256 hash (hex) of the current file content. If provided and the actual file hash differs, the write is rejected to prevent overwriting concurrent changes."),
+        },
+        outputSchema: resultOutputSchema(),
+        ...toolWidgetDescriptorMeta(config, "write"), annotations: WRITE_TOOL_ANNOTATIONS,
+    }, async ({ workspaceId, expectedVersion, ...input }) => {
+        const startedAt = performance.now();
+        const workspace = workspaces.getWorkspace(workspaceId);
+        const absolutePath = workspaces.resolvePath(workspace, input.path);
+        if (input.content.length > MAX_WRITE_SIZE) {
+            throw new Error(`File content exceeds maximum write size of ${MAX_WRITE_SIZE} bytes (${input.content.length} bytes provided).`);
+        }
+        const previousContent = await readExistingTextFile(absolutePath);
+        if (expectedVersion && previousContent !== undefined) {
+            const currentHash = createHash("sha256").update(previousContent).digest("hex");
+            if (currentHash !== expectedVersion) {
+                logEvent(config.logging, "warn", "write_version_mismatch", {
+                    path: input.path, expectedVersion, actualVersion: currentHash,
+                });
+                return {
+                    content: [{ type: "text", text: `Write rejected: file content has changed since last read. Expected version ${expectedVersion.slice(0, 12)}… but actual version is ${currentHash.slice(0, 12)}…. Re-read the file before writing.` }],
+                    isError: true,
+                };
+            }
+        }
+        await safeWriteFile(absolutePath, input.content);
+        const changed = previousContent !== input.content;
+        const patch = !changed
+            ? ""
+            : previousContent === undefined
+                ? newFilePatch(input.path, input.content)
+                : generateUnifiedPatch(input.path, previousContent, input.content);
+        const stats = countDiffStats(patch);
+        if (changed) {
+            workspaceChanges.recordMutation({
+                workspaceId,
+                workspaceRoot: workspace.root,
+                path: input.path,
+                kind: previousContent === undefined ? "created" : "modified",
+                additions: stats.additions,
+                removals: stats.removals,
+            });
+        }
+        const content = [{ type: "text", text: `Wrote ${contentLineCount(input.content)} lines to ${input.path}.` }];
+        logToolCall(config, {
+            tool: toolNames.write, workspaceId, path: input.path, success: true,
+            durationMs: Math.round(performance.now() - startedAt),
+        });
+        return {
+            content,
+            _meta: {
+                tool: toolNames.write,
+                card: {
+                    workspaceId, path: input.path,
+                    summary: { ...stats, lines: contentLineCount(input.content), characters: input.content.length },
+                    payload: { content, patch },
+                },
+            },
+            structuredContent: { result: contentText(content) },
+        };
+    });
+    registerAppTool(server, toolNames.edit, {
+        title: "Edit file",
+        description: `Edit one file inside an open workspace by replacing exact text blocks. Prefer this over ${toolNames.write} for targeted changes. Each oldText must match a unique, non-overlapping region of the original file; merge nearby changes into one edit and keep oldText as small as possible while still unique. Call open_workspace first and pass workspaceId.`,
+        inputSchema: {
+            workspaceId: z.string().describe("Workspace identifier returned by open_workspace."),
+            path: z.string().describe("File path to edit, relative to the workspace root."),
+            edits: z.array(z.object({
+                oldText: z.string().describe("Exact text to replace. Must match uniquely in the original file."),
+                newText: z.string().describe("Replacement text."),
+            })).min(1),
+        },
+        outputSchema: resultOutputSchema({ status: z.literal("applied") }),
+        ...toolWidgetDescriptorMeta(config, "edit"), annotations: EDIT_TOOL_ANNOTATIONS,
+    }, async ({ workspaceId, ...input }) => {
+        const startedAt = performance.now();
+        const workspace = workspaces.getWorkspace(workspaceId);
+        workspaces.resolvePath(workspace, input.path);
+        const response = await editFileTool(input, { cwd: workspace.root, root: workspace.root });
+        if (response.isError) {
+            logFailedToolResponse(config, { tool: toolNames.edit, workspaceId, path: input.path }, response.content, startedAt);
+            return response;
+        }
+        const stats = countDiffStats(response.details?.patch ?? response.details?.diff);
+        const content = [textBlock(`Edited ${input.path} (+${stats.additions} -${stats.removals}).`)];
+        if (stats.additions > 0 || stats.removals > 0) {
+            workspaceChanges.recordMutation({
+                workspaceId,
+                workspaceRoot: workspace.root,
+                path: input.path,
+                kind: "modified",
+                additions: stats.additions,
+                removals: stats.removals,
+            });
+        }
+        logToolCall(config, {
+            tool: toolNames.edit, workspaceId, path: input.path, success: true,
+            durationMs: Math.round(performance.now() - startedAt),
+        });
+        return {
+            content,
+            _meta: {
+                tool: toolNames.edit,
+                card: {
+                    workspaceId, path: input.path, summary: { ...stats, editCount: input.edits.length },
+                    payload: { diff: response.details?.diff, patch: response.details?.patch },
+                },
+            },
+            structuredContent: { status: "applied", result: contentText(content) },
+        };
+    });
+    if (config.widgets === "changes") {
+        registerAppTool(server, "show_changes", {
+            title: "Show changes",
+            description: "Show aggregate file changes in an open workspace since the last shown checkpoint or since the workspace was opened. After you create, edit, or overwrite files, call this once when the related file changes are complete so the user can inspect the combined diff.",
+            inputSchema: {
+                workspaceId: z.string().describe("Workspace identifier returned by open_workspace."),
+                since: z.enum(["last_shown", "workspace_open"]).optional().describe("Defaults to last_shown. Use workspace_open to compare against the initial open_workspace checkpoint."),
+                markReviewed: z.boolean().optional().describe("Defaults to true. When true, advances the last shown checkpoint to the current workspace state."),
+            },
+            outputSchema: resultOutputSchema(),
+            ...toolWidgetDescriptorMeta(config, "show_changes"), annotations: { readOnlyHint: true },
+        }, async ({ workspaceId, since, markReviewed }) => {
+            const startedAt = performance.now();
+            const workspace = workspaces.getWorkspace(workspaceId);
+            const review = await reviewCheckpoints.reviewChanges({
+                workspaceId, root: workspace.root, since: since ?? "last_shown", markReviewed: markReviewed ?? true,
+            });
+            const content = [textBlock(review.result)];
+            logToolCall(config, {
+                tool: "show_changes", workspaceId, success: true,
+                durationMs: Math.round(performance.now() - startedAt),
+            });
+            return {
+                content,
+                _meta: {
+                    tool: "show_changes",
+                    card: { workspaceId, summary: review.summary, files: review.files, payload: { patch: review.patch } },
+                },
+                structuredContent: { result: contentText(content) },
+            };
+        });
+    }
+    if (!config.minimalTools) {
+        registerSearchTools(server, config, workspaces, toolNames, logToolCall, logFailedToolResponse);
+    }
+    registerAppTool(server, toolNames.shell, {
+        title: config.toolNaming === "short" ? "Bash" : "Run shell",
+        description: config.minimalTools
+            ? `Run a shell command inside an open workspace. Use for tests, builds, git inspection, package scripts, search, file discovery, and directory inspection. In minimal tool mode, ${toolNames.grep}, ${toolNames.glob}, and ${toolNames.ls} are disabled; command-line search tools may be used instead. Prefer ${toolNames.read} for direct file reads and the dedicated edit/write tools for source changes. Shell commands execute with the local user's privileges and can modify files or run programs beyond what path-scoped file tools can do, so this tool requires the privileged auvrynt:process scope. Call open_workspace first and pass workspaceId.`
+            : `Run a shell command inside an open workspace for tests, builds, git inspection, package scripts, and commands that genuinely require a shell. Prefer ${toolNames.read}, ${toolNames.grep}, ${toolNames.glob}, and ${toolNames.ls} for inspection and the dedicated edit/write tools for source changes. Shell commands execute with the local user's privileges and can modify files or run programs beyond what path-scoped file tools can do, so this tool requires the privileged auvrynt:process scope. Call open_workspace first and pass workspaceId.`,
+        inputSchema: {
+            workspaceId: z.string().describe("Workspace identifier returned by open_workspace."),
+            command: z.string().describe(`Shell command to run. This executes with local-user privileges; prefer ${toolNames.edit} or ${toolNames.write} for ordinary source-file changes.`),
+            workingDirectory: z.string().optional().describe("Optional working directory relative to the workspace root. Defaults to the workspace root."),
+            timeout: z.number().positive().max(300).optional().describe("Timeout in seconds. Defaults to 30, max 300."),
+        },
+        outputSchema: resultOutputSchema(),
+        ...toolWidgetDescriptorMeta(config, "shell"), annotations: SHELL_TOOL_ANNOTATIONS,
+    }, async ({ workspaceId, workingDirectory, ...input }) => {
+        const startedAt = performance.now();
+        const workspace = workspaces.getWorkspace(workspaceId);
+        const cwd = workspaces.resolveWorkingDirectory(workspace, workingDirectory);
+        const response = await runShellTool(input, { cwd, root: workspace.root });
+        if (response.isError) {
+            logFailedToolResponse(config, {
+                tool: toolNames.shell, workspaceId, workingDirectory: workingDirectory ?? ".",
+                command: input.command, commandLength: input.command.length,
+            }, response.content, startedAt);
+            return response;
+        }
+        logToolCall(config, {
+            tool: toolNames.shell, workspaceId, workingDirectory: workingDirectory ?? ".",
+            command: input.command, commandLength: input.command.length, success: true,
+            durationMs: Math.round(performance.now() - startedAt),
+        });
+        return {
+            ...response,
+            _meta: {
+                tool: toolNames.shell,
+                card: {
+                    workspaceId, path: workingDirectory,
+                    summary: { command: input.command, workingDirectory: workingDirectory ?? ".", ...textSummary(response.content) },
+                    payload: { content: response.content },
+                },
+            },
+            structuredContent: { result: contentText(response.content) },
+        };
+    });
+}
+function registerSearchTools(server, config, workspaces, toolNames, logToolCall, logFailedToolResponse) {
+    registerAppTool(server, toolNames.grep, {
+        title: config.toolNaming === "short" ? "Grep" : "Grep files",
+        description: "Search file contents inside an open workspace. Use this before broad reads when looking for symbols, text, or usage sites. Respects project ignore rules. Call open_workspace first and pass workspaceId.",
+        inputSchema: {
+            workspaceId: z.string().describe("Workspace identifier returned by open_workspace."),
+            pattern: z.string().describe("Search pattern."),
+            path: z.string().optional().describe("Optional path or glob scope relative to the workspace root."),
+            include: z.string().optional().describe("Optional include glob."),
+        },
+        outputSchema: resultOutputSchema(),
+        ...toolWidgetDescriptorMeta(config, "search"), annotations: { readOnlyHint: true },
+    }, async ({ workspaceId, ...input }) => {
+        const startedAt = performance.now();
+        const workspace = workspaces.getWorkspace(workspaceId);
+        if (input.path)
+            workspaces.resolvePath(workspace, input.path);
+        const response = await grepFilesTool(input, { cwd: workspace.root, root: workspace.root });
+        if (response.isError) {
+            logFailedToolResponse(config, { tool: toolNames.grep, workspaceId, path: input.path }, response.content, startedAt);
+            return response;
+        }
+        logToolCall(config, {
+            tool: toolNames.grep, workspaceId, path: input.path, success: true,
+            durationMs: Math.round(performance.now() - startedAt),
+        });
+        return {
+            ...response,
+            _meta: {
+                tool: toolNames.grep,
+                card: {
+                    workspaceId, path: input.path,
+                    summary: { pattern: input.pattern, scope: input.path ?? ".", ...textSummary(response.content) },
+                    payload: { content: response.content },
+                },
+            },
+            structuredContent: { result: contentText(response.content) },
+        };
+    });
+    registerAppTool(server, toolNames.glob, {
+        title: config.toolNaming === "short" ? "Glob" : "Find files",
+        description: "Find files by glob pattern inside an open workspace. Use this to discover filenames or narrow file sets before reading. Respects project ignore rules. Call open_workspace first and pass workspaceId.",
+        inputSchema: {
+            workspaceId: z.string().describe("Workspace identifier returned by open_workspace."),
+            pattern: z.string().describe("File glob pattern."),
+            path: z.string().optional().describe("Optional path scope relative to the workspace root."),
+        },
+        outputSchema: resultOutputSchema(),
+        ...toolWidgetDescriptorMeta(config, "search"), annotations: { readOnlyHint: true },
+    }, async ({ workspaceId, ...input }) => {
+        const startedAt = performance.now();
+        const workspace = workspaces.getWorkspace(workspaceId);
+        if (input.path)
+            workspaces.resolvePath(workspace, input.path);
+        const response = await findFilesTool(input, { cwd: workspace.root, root: workspace.root });
+        if (response.isError) {
+            logFailedToolResponse(config, { tool: toolNames.glob, workspaceId, path: input.path }, response.content, startedAt);
+            return response;
+        }
+        logToolCall(config, {
+            tool: toolNames.glob, workspaceId, path: input.path, success: true,
+            durationMs: Math.round(performance.now() - startedAt),
+        });
+        return {
+            ...response,
+            _meta: {
+                tool: toolNames.glob,
+                card: {
+                    workspaceId, path: input.path,
+                    summary: { pattern: input.pattern, scope: input.path ?? ".", ...textSummary(response.content) },
+                    payload: { content: response.content },
+                },
+            },
+            structuredContent: { result: contentText(response.content) },
+        };
+    });
+    registerAppTool(server, toolNames.ls, {
+        title: config.toolNaming === "short" ? "Ls" : "List directory",
+        description: "List a directory inside an open workspace. Use this for directory inspection before reading files. Call open_workspace first and pass workspaceId.",
+        inputSchema: {
+            workspaceId: z.string().describe("Workspace identifier returned by open_workspace."),
+            path: z.string().describe("Directory path to list, relative to the workspace root."),
+        },
+        outputSchema: resultOutputSchema(),
+        ...toolWidgetDescriptorMeta(config, "directory"), annotations: { readOnlyHint: true },
+    }, async ({ workspaceId, ...input }) => {
+        const startedAt = performance.now();
+        const workspace = workspaces.getWorkspace(workspaceId);
+        workspaces.resolvePath(workspace, input.path);
+        const response = await listDirectoryTool(input, { cwd: workspace.root, root: workspace.root });
+        if (response.isError) {
+            logFailedToolResponse(config, { tool: toolNames.ls, workspaceId, path: input.path }, response.content, startedAt);
+            return response;
+        }
+        logToolCall(config, {
+            tool: toolNames.ls, workspaceId, path: input.path, success: true,
+            durationMs: Math.round(performance.now() - startedAt),
+        });
+        return {
+            ...response,
+            _meta: {
+                tool: toolNames.ls,
+                card: { workspaceId, path: input.path, summary: textSummary(response.content), payload: { content: response.content } },
+            },
+            structuredContent: { result: contentText(response.content) },
+        };
+    });
+}

package/dist/server/tools/dotnet-godot-window-tools-registration.js

@@ -0,0 +1,120 @@
+import * as z from "zod/v4";
+import { dotnetBuild, dotnetFormat, dotnetRestore, dotnetRun, dotnetTest, inspectDotnetProject } from "../../dotnet-tools.js";
+import { detectGodotProject, godotRun, inspectGodotScene } from "../../godot-tools.js";
+import { captureWindow } from "../../window-capture.js";
+import { registerAppTool } from "../mcp-tool-registrar.js";
+import { MUTATING_ANNOTATIONS, PROCESS_ANNOTATIONS, READ_ONLY_ANNOTATIONS, WORKSPACE_ID_SCHEMA, toolWidgetDescriptorMeta, } from "../tool-registration-shared.js";
+function jsonToolResult(action) {
+    return Promise.resolve()
+        .then(action)
+        .then((result) => ({ content: [{ type: "text", text: JSON.stringify(result, null, 2) }] }))
+        .catch((error) => ({
+        content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
+        isError: true,
+    }));
+}
+export function registerDotnetGodotWindowTools(server, config, workspaces, processManager) {
+    registerAppTool(server, "inspect_dotnet_project", {
+        title: "Inspect .NET project",
+        description: "Parse a .csproj or .fsproj file and return SDK style, target frameworks, packages, test framework, and project references.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, projectPath: z.string().describe("Workspace-relative path to .csproj or .fsproj.") },
+        ...toolWidgetDescriptorMeta(config, "read"), annotations: READ_ONLY_ANNOTATIONS,
+    }, ({ workspaceId, projectPath }) => jsonToolResult(() => inspectDotnetProject(workspaces, { workspaceId, projectPath })));
+    registerAppTool(server, "dotnet_restore", {
+        title: "dotnet restore",
+        description: "Run dotnet restore on a .NET project. Returns success, duration, and key output.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, projectPath: z.string().describe("Workspace-relative path to .csproj/.fsproj/.sln.") },
+        ...toolWidgetDescriptorMeta(config, "shell"), annotations: PROCESS_ANNOTATIONS,
+    }, ({ workspaceId, projectPath }) => jsonToolResult(() => dotnetRestore(workspaces, { workspaceId, projectPath })));
+    registerAppTool(server, "dotnet_build", {
+        title: "dotnet build",
+        description: "Build a .NET project. Returns structured errors, warnings, and duration. Does not return raw build output.",
+        inputSchema: {
+            workspaceId: WORKSPACE_ID_SCHEMA,
+            projectPath: z.string().describe("Workspace-relative path to .csproj/.fsproj/.sln."),
+            configuration: z.enum(["Debug", "Release"]).optional().describe("Build configuration."),
+            noRestore: z.boolean().optional().describe("Skip restore step."),
+        },
+        ...toolWidgetDescriptorMeta(config, "shell"), annotations: PROCESS_ANNOTATIONS,
+    }, ({ workspaceId, projectPath, configuration, noRestore }) => jsonToolResult(() => dotnetBuild(workspaces, { workspaceId, projectPath, configuration, noRestore })));
+    registerAppTool(server, "dotnet_test", {
+        title: "dotnet test",
+        description: "Run .NET tests. Returns pass/fail/skip counts, failed test names, and assertion messages.",
+        inputSchema: {
+            workspaceId: WORKSPACE_ID_SCHEMA,
+            projectPath: z.string().describe("Workspace-relative path to test .csproj/.sln."),
+            configuration: z.enum(["Debug", "Release"]).optional(),
+            filter: z.string().optional().describe("Test filter expression."),
+            noBuild: z.boolean().optional(),
+        },
+        ...toolWidgetDescriptorMeta(config, "shell"), annotations: PROCESS_ANNOTATIONS,
+    }, ({ workspaceId, projectPath, configuration, filter, noBuild }) => jsonToolResult(() => dotnetTest(workspaces, { workspaceId, projectPath, configuration, filter, noBuild })));
+    registerAppTool(server, "dotnet_run", {
+        title: "dotnet run",
+        description: "Run a .NET project as a persistent process. Returns a processId. Use get_process_logs to tail output.",
+        inputSchema: {
+            workspaceId: WORKSPACE_ID_SCHEMA,
+            projectPath: z.string().describe("Workspace-relative path to .csproj."),
+            configuration: z.enum(["Debug", "Release"]).optional(),
+            arguments: z.array(z.string()).optional().describe("Arguments to pass to the application."),
+            environment: z.record(z.string(), z.string()).optional().describe("Environment variables."),
+        },
+        ...toolWidgetDescriptorMeta(config, "shell"), annotations: PROCESS_ANNOTATIONS,
+    }, ({ workspaceId, projectPath, configuration, arguments: args, environment }) => jsonToolResult(() => dotnetRun(workspaces, processManager, { workspaceId, projectPath, configuration, arguments: args, environment })));
+    registerAppTool(server, "dotnet_format", {
+        title: "dotnet format",
+        description: "Format a .NET project. Use verifyOnly=true to check without modifying files.",
+        inputSchema: {
+            workspaceId: WORKSPACE_ID_SCHEMA,
+            projectPath: z.string().describe("Workspace-relative path to .csproj/.sln."),
+            verifyOnly: z.boolean().optional().describe("If true, check formatting without modifying files."),
+        },
+        ...toolWidgetDescriptorMeta(config, "shell"), annotations: MUTATING_ANNOTATIONS,
+    }, ({ workspaceId, projectPath, verifyOnly }) => jsonToolResult(() => dotnetFormat(workspaces, { workspaceId, projectPath, verifyOnly })));
+    registerAppTool(server, "detect_godot_project", {
+        title: "Detect Godot project",
+        description: "Detect a Godot 4 project in the workspace. Reads project.godot for name, main scene, renderer, features, autoloads, and input actions.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, path: z.string().optional().describe("Subdirectory to search, relative to workspace root.") },
+        ...toolWidgetDescriptorMeta(config, "read"), annotations: READ_ONLY_ANNOTATIONS,
+    }, ({ workspaceId, path }) => jsonToolResult(() => detectGodotProject(workspaces, { workspaceId, path })));
+    registerAppTool(server, "godot_run", {
+        title: "Run Godot",
+        description: "Launch a Godot 4 game or editor as a persistent process. Returns a processId. Configure Godot executable via GODOT_EXECUTABLE env var.",
+        inputSchema: {
+            workspaceId: WORKSPACE_ID_SCHEMA,
+            projectPath: z.string().describe("Workspace-relative path to the project directory (containing project.godot)."),
+            scenePath: z.string().optional().describe("Workspace-relative scene path to run."),
+            editor: z.boolean().optional().describe("Open Godot editor instead of running game."),
+            debug: z.boolean().optional().describe("Enable debug mode."),
+            additionalArguments: z.array(z.string()).optional().describe("Additional CLI arguments."),
+        },
+        ...toolWidgetDescriptorMeta(config, "shell"), annotations: PROCESS_ANNOTATIONS,
+    }, ({ workspaceId, projectPath, scenePath, editor, debug, additionalArguments }) => jsonToolResult(() => godotRun(workspaces, processManager, { workspaceId, projectPath, scenePath, editor, debug, additionalArguments })));
+    registerAppTool(server, "inspect_godot_scene", {
+        title: "Inspect Godot scene",
+        description: "Parse a Godot .tscn text scene file. Returns node tree, types, external resources, signals, and properties. Binary .scn files are not supported.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, scenePath: z.string().describe("Workspace-relative path to .tscn scene file.") },
+        ...toolWidgetDescriptorMeta(config, "read"), annotations: READ_ONLY_ANNOTATIONS,
+    }, ({ workspaceId, scenePath }) => jsonToolResult(() => inspectGodotScene(workspaces, { workspaceId, scenePath })));
+    registerAppTool(server, "capture_window", {
+        title: "Capture window",
+        description: "Capture a running application window tracked by Auvrynt. Returns the screenshot as MCP image content and saves it in the workspace. Windows only.",
+        inputSchema: {
+            workspaceId: WORKSPACE_ID_SCHEMA,
+            processId: z.string().optional().describe("Process ID from start_process to target."),
+            windowTitle: z.string().optional().describe("Window title substring to target."),
+            outputPath: z.string().describe("Workspace-relative path to save the screenshot PNG."),
+        },
+        ...toolWidgetDescriptorMeta(config, "write"), annotations: MUTATING_ANNOTATIONS,
+    }, ({ workspaceId, processId, windowTitle, outputPath }) => captureWindow(workspaces, processManager, { workspaceId, processId, windowTitle, outputPath }));
+    registerAppTool(server, "godot_capture_game", {
+        title: "Capture Godot game",
+        description: "Capture a screenshot of a running Godot game tracked by an Auvrynt processId. Wraps capture_window.",
+        inputSchema: {
+            workspaceId: WORKSPACE_ID_SCHEMA,
+            processId: z.string().describe("Process ID from godot_run."),
+            outputPath: z.string().describe("Workspace-relative path to save the screenshot PNG."),
+        },
+        ...toolWidgetDescriptorMeta(config, "write"), annotations: MUTATING_ANNOTATIONS,
+    }, ({ workspaceId, processId, outputPath }) => captureWindow(workspaces, processManager, { workspaceId, processId, outputPath }));
+}