auvrynt 1.0.2 → 1.0.5

package/dist/server/tools/godot-csharp-tools-registration.js

@@ -0,0 +1,252 @@
+import * as z from "zod/v4";
+import { registerAppTool } from "../mcp-tool-registrar.js";
+import { MUTATING_ANNOTATIONS, PROCESS_ANNOTATIONS, READ_ONLY_ANNOTATIONS, WORKSPACE_ID_SCHEMA, toolWidgetDescriptorMeta, } from "../tool-registration-shared.js";
+import { inspectGodotDotnetEnvironment } from "../../godot-dotnet-env.js";
+import { inspectGodotDotnetProject, godotBuildSolutions, godotDotnetRestore } from "../../godot-csharp-project.js";
+import { godotDotnetBuild, godotDotnetClean } from "../../godot-csharp-build.js";
+import { godotRunProject, godotRunScene, getGodotRuntimeLogs } from "../../godot-csharp-runner.js";
+import { godotValidateProject, godotImportAssets } from "../../godot-csharp-validate.js";
+import { godotEditorConnect, godotEditorStatus, godotEditorDisconnect, getBridgeClient } from "../../godot-editor-bridge.js";
+import { findCsharpClasses, getCsharpDiagnostics, getExportedProperties, generateCsharpScript } from "../../godot-csharp-semantic.js";
+import { getProjectSettings, getInputMap, getAutoloads, applyPixelArtImportPreset, generateVscodeConfig, listExportPresets, } from "../../godot-project-settings.js";
+import { getRemoteSceneTree, getRuntimeProperty, getPerformanceMonitors, parseCsharpExceptions, pressAction as godotPressAction, releaseAction as godotReleaseAction, mouseClick as godotMouseClick, assertNodeExists as godotAssertNodeExists, assertProperty as godotAssertProperty, runTestSequence as godotRunTestSequence, exportGodotProject, } from "../../godot-runtime-testing.js";
+function toolResult(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 registerGodotCsharpTools(server, config, workspaces, processManager) {
+    registerAppTool(server, "godot_dotnet_environment", {
+        title: "Godot .NET environment",
+        description: "Detect and validate the Godot .NET editor, .NET SDK, architecture, and project target frameworks. Run this before the first C# build.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, projectPath: z.string().optional() },
+        ...toolWidgetDescriptorMeta(config, "read"), annotations: READ_ONLY_ANNOTATIONS,
+    }, ({ workspaceId, projectPath }) => toolResult(() => inspectGodotDotnetEnvironment(workspaces, { workspaceId, projectPath })));
+    registerAppTool(server, "inspect_godot_dotnet_project", {
+        title: "Inspect Godot .NET project",
+        description: "Inspect a Godot 4 C# project: project.godot, .csproj, .sln, target frameworks, Godot.NET.Sdk, autoloads, input actions, C# scripts, and whether solution regeneration is needed.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, projectPath: z.string().optional() },
+        ...toolWidgetDescriptorMeta(config, "read"), annotations: READ_ONLY_ANNOTATIONS,
+    }, ({ workspaceId, projectPath }) => toolResult(() => inspectGodotDotnetProject(workspaces, { workspaceId, projectPath })));
+    registerAppTool(server, "godot_build_solutions", {
+        title: "Godot build solutions",
+        description: "Run Godot --build-solutions to generate or regenerate the .sln and .csproj for a C# project. Run after adding C# files.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, projectPath: z.string() },
+        ...toolWidgetDescriptorMeta(config, "shell"), annotations: PROCESS_ANNOTATIONS,
+    }, ({ workspaceId, projectPath }) => toolResult(() => godotBuildSolutions(workspaces, { workspaceId, projectPath })));
+    registerAppTool(server, "godot_dotnet_restore", {
+        title: "dotnet restore (Godot)",
+        description: "Restore NuGet packages for a Godot C# project. Credentials and secrets are redacted.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, projectPath: z.string(), lockedMode: z.boolean().optional() },
+        ...toolWidgetDescriptorMeta(config, "shell"), annotations: PROCESS_ANNOTATIONS,
+    }, ({ workspaceId, projectPath, lockedMode }) => toolResult(() => godotDotnetRestore(workspaces, { workspaceId, projectPath, lockedMode })));
+    registerAppTool(server, "godot_dotnet_build", {
+        title: "dotnet build (Godot)",
+        description: "Build a Godot C# project. Returns structured C# compiler errors, MSBuild errors, and Godot source-generator issues.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, projectPath: z.string(), configuration: z.enum(["Debug", "Release"]).optional(), noRestore: z.boolean().optional() },
+        ...toolWidgetDescriptorMeta(config, "shell"), annotations: PROCESS_ANNOTATIONS,
+    }, ({ workspaceId, projectPath, configuration, noRestore }) => toolResult(() => godotDotnetBuild(workspaces, { workspaceId, projectPath, configuration, noRestore })));
+    registerAppTool(server, "godot_dotnet_clean", {
+        title: "dotnet clean (Godot)",
+        description: "Remove Godot C# build outputs (bin/ and obj/). Mutating.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, projectPath: z.string(), configuration: z.enum(["Debug", "Release"]).optional() },
+        ...toolWidgetDescriptorMeta(config, "shell"), annotations: MUTATING_ANNOTATIONS,
+    }, ({ workspaceId, projectPath, configuration }) => toolResult(() => godotDotnetClean(workspaces, { workspaceId, projectPath, configuration })));
+    registerAppTool(server, "godot_run_project", {
+        title: "Run Godot project",
+        description: "Run a Godot C# project as a persistent process. Returns a processId. Use godot_get_runtime_logs to inspect output.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, projectPath: z.string(), debug: z.boolean().optional(), windowed: z.boolean().optional(), resolution: z.object({ width: z.number().int(), height: z.number().int() }).optional(), additionalGodotArguments: z.array(z.string()).optional(), userArguments: z.array(z.string()).optional() },
+        ...toolWidgetDescriptorMeta(config, "shell"), annotations: PROCESS_ANNOTATIONS,
+    }, ({ workspaceId, projectPath, debug, windowed, resolution, additionalGodotArguments, userArguments }) => toolResult(() => godotRunProject(workspaces, processManager, { workspaceId, projectPath, debug, windowed, resolution, additionalGodotArguments, userArguments })));
+    registerAppTool(server, "godot_run_scene", {
+        title: "Run Godot scene",
+        description: "Run a single .tscn scene in a Godot C# project as a persistent process.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, projectPath: z.string(), scenePath: z.string(), debug: z.boolean().optional() },
+        ...toolWidgetDescriptorMeta(config, "shell"), annotations: PROCESS_ANNOTATIONS,
+    }, ({ workspaceId, projectPath, scenePath, debug }) => toolResult(() => godotRunScene(workspaces, processManager, { workspaceId, projectPath, scenePath, debug })));
+    registerAppTool(server, "godot_stop", {
+        title: "Stop Godot process",
+        description: "Gracefully stop a Godot process tracked by Auvrynt for this workspace.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, processId: z.string() },
+        ...toolWidgetDescriptorMeta(config, "shell"), annotations: PROCESS_ANNOTATIONS,
+    }, ({ workspaceId, processId }) => toolResult(() => processManager.stopProcess({ workspaceId, processId })));
+    registerAppTool(server, "godot_get_runtime_logs", {
+        title: "Get Godot runtime logs",
+        description: "Get structured and categorized runtime logs from a running Godot C# process. Groups C# exceptions, stack traces, Godot errors, and GD.Print output.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, processId: z.string(), severity: z.array(z.enum(["error", "warning", "info", "print"])).optional(), lines: z.number().int().optional() },
+        ...toolWidgetDescriptorMeta(config, "shell"), annotations: READ_ONLY_ANNOTATIONS,
+    }, ({ workspaceId, processId, severity, lines }) => toolResult(() => getGodotRuntimeLogs(processManager, { workspaceId, processId, severity, lines })));
+    registerAppTool(server, "godot_validate_project", {
+        title: "Validate Godot project",
+        description: "Headless Godot project validation: optionally build C#, detect import errors, missing resources, invalid scripts, and plugin failures.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, projectPath: z.string(), buildCsharpFirst: z.boolean().optional() },
+        ...toolWidgetDescriptorMeta(config, "shell"), annotations: PROCESS_ANNOTATIONS,
+    }, ({ workspaceId, projectPath, buildCsharpFirst }) => toolResult(() => godotValidateProject(workspaces, { workspaceId, projectPath, buildCsharpFirst })));
+    registerAppTool(server, "godot_import_assets", {
+        title: "Godot import assets",
+        description: "Run Godot in headless editor mode to import pending assets.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, projectPath: z.string() },
+        ...toolWidgetDescriptorMeta(config, "shell"), annotations: PROCESS_ANNOTATIONS,
+    }, ({ workspaceId, projectPath }) => toolResult(() => godotImportAssets(workspaces, { workspaceId, projectPath })));
+    registerAppTool(server, "godot_editor_connect", {
+        title: "Connect Godot editor bridge",
+        description: "Connect Auvrynt to the Godot editor bridge plugin. Enables live scene-tree inspection, property editing, node mutation, and UndoRedo.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, projectPath: z.string(), host: z.string().optional(), port: z.number().int().optional(), token: z.string().optional() },
+        ...toolWidgetDescriptorMeta(config, "shell"), annotations: PROCESS_ANNOTATIONS,
+    }, ({ workspaceId, projectPath, host, port, token }) => toolResult(() => godotEditorConnect(workspaces, { workspaceId, projectPath, host, port, token })));
+    registerAppTool(server, "godot_editor_status", {
+        title: "Godot editor bridge status",
+        description: "Return current Godot editor bridge connection status.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA },
+        ...toolWidgetDescriptorMeta(config, "read"), annotations: READ_ONLY_ANNOTATIONS,
+    }, ({ workspaceId }) => toolResult(() => godotEditorStatus({ workspaceId })));
+    registerAppTool(server, "godot_editor_disconnect", {
+        title: "Disconnect Godot editor bridge",
+        description: "Disconnect Auvrynt from the Godot editor bridge. Does not close the editor.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA },
+        ...toolWidgetDescriptorMeta(config, "shell"), annotations: PROCESS_ANNOTATIONS,
+    }, ({ workspaceId }) => toolResult(() => godotEditorDisconnect({ workspaceId })));
+    registerAppTool(server, "godot_get_scene_tree", {
+        title: "Get Godot scene tree",
+        description: "Get the edited or remote runtime scene tree via the Godot editor bridge.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, mode: z.enum(["edited", "remote"]).optional(), maxDepth: z.number().int().optional() },
+        ...toolWidgetDescriptorMeta(config, "read"), annotations: READ_ONLY_ANNOTATIONS,
+    }, ({ workspaceId, mode, maxDepth }) => toolResult(async () => {
+        const client = getBridgeClient(workspaceId);
+        return mode === "remote"
+            ? getRemoteSceneTree({ workspaceId, maxDepth }, client)
+            : client.sendRequest("scene.get_tree", { maxDepth });
+    }));
+    registerAppTool(server, "godot_get_runtime_property", {
+        title: "Get runtime node property",
+        description: "Read a live runtime property from a node in the running Godot game via the editor bridge.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, nodePath: z.string(), property: z.string() },
+        ...toolWidgetDescriptorMeta(config, "read"), annotations: READ_ONLY_ANNOTATIONS,
+    }, ({ workspaceId, nodePath, property }) => toolResult(() => getRuntimeProperty({ workspaceId, nodePath, property }, getBridgeClient(workspaceId))));
+    registerAppTool(server, "godot_get_performance_monitors", {
+        title: "Godot performance monitors",
+        description: "Get FPS, physics time, memory, node count, draw calls, and orphan node count from the running game via the editor bridge.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA },
+        ...toolWidgetDescriptorMeta(config, "read"), annotations: READ_ONLY_ANNOTATIONS,
+    }, ({ workspaceId }) => toolResult(() => getPerformanceMonitors({ workspaceId }, getBridgeClient(workspaceId))));
+    registerAppTool(server, "godot_find_csharp_class", {
+        title: "Find C# class",
+        description: "Locate a C# class in the workspace. Returns file path, base class, partial status, namespace, [Export] properties, [Signal] delegates, and lifecycle overrides.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, className: z.string() },
+        ...toolWidgetDescriptorMeta(config, "search"), annotations: READ_ONLY_ANNOTATIONS,
+    }, ({ workspaceId, className }) => toolResult(() => findCsharpClasses(workspaces, { workspaceId, className })));
+    registerAppTool(server, "godot_get_exported_properties", {
+        title: "Get exported C# properties",
+        description: "List all [Export] properties on a C# script file.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, scriptPath: z.string() },
+        ...toolWidgetDescriptorMeta(config, "read"), annotations: READ_ONLY_ANNOTATIONS,
+    }, ({ workspaceId, scriptPath }) => toolResult(() => getExportedProperties(workspaces, { workspaceId, scriptPath })));
+    registerAppTool(server, "godot_get_csharp_diagnostics", {
+        title: "Get C# diagnostics",
+        description: "Scan C# scripts for known anti-patterns and style issues within the workspace.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, projectPath: z.string() },
+        ...toolWidgetDescriptorMeta(config, "search"), annotations: READ_ONLY_ANNOTATIONS,
+    }, ({ workspaceId, projectPath }) => toolResult(() => getCsharpDiagnostics(workspaces, { workspaceId, projectPath })));
+    registerAppTool(server, "godot_get_project_settings", {
+        title: "Get project settings",
+        description: "Read all settings from project.godot.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, projectPath: z.string() },
+        ...toolWidgetDescriptorMeta(config, "read"), annotations: READ_ONLY_ANNOTATIONS,
+    }, ({ workspaceId, projectPath }) => toolResult(() => getProjectSettings(workspaces, { workspaceId, projectPath })));
+    registerAppTool(server, "godot_get_input_map", {
+        title: "Get input map",
+        description: "Return all input actions from the project.godot input map.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, projectPath: z.string() },
+        ...toolWidgetDescriptorMeta(config, "read"), annotations: READ_ONLY_ANNOTATIONS,
+    }, ({ workspaceId, projectPath }) => toolResult(() => getInputMap(workspaces, { workspaceId, projectPath })));
+    registerAppTool(server, "godot_get_autoloads", {
+        title: "Get autoloads",
+        description: "Return all autoloads from project.godot.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, projectPath: z.string() },
+        ...toolWidgetDescriptorMeta(config, "read"), annotations: READ_ONLY_ANNOTATIONS,
+    }, ({ workspaceId, projectPath }) => toolResult(() => getAutoloads(workspaces, { workspaceId, projectPath })));
+    registerAppTool(server, "godot_apply_pixel_art_import_preset", {
+        title: "Apply pixel art import preset",
+        description: "Apply nearest-neighbour / lossless import settings to specified texture paths. Does not affect unspecified textures.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, paths: z.array(z.string()) },
+        ...toolWidgetDescriptorMeta(config, "write"), annotations: MUTATING_ANNOTATIONS,
+    }, ({ workspaceId, paths }) => toolResult(() => applyPixelArtImportPreset(workspaces, { workspaceId, paths })));
+    registerAppTool(server, "godot_generate_vscode_config", {
+        title: "Generate VS Code config",
+        description: "Generate or update .vscode/tasks.json and .vscode/launch.json for Godot C# development. Preserves existing entries.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, projectPath: z.string(), godotExecutable: z.string().optional() },
+        ...toolWidgetDescriptorMeta(config, "write"), annotations: MUTATING_ANNOTATIONS,
+    }, ({ workspaceId, projectPath, godotExecutable }) => toolResult(() => generateVscodeConfig(workspaces, { workspaceId, projectPath, godotExecutable })));
+    registerAppTool(server, "godot_list_export_presets", {
+        title: "List export presets",
+        description: "List Godot export presets from export_presets.cfg. Never returns secret credentials.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, projectPath: z.string() },
+        ...toolWidgetDescriptorMeta(config, "read"), annotations: READ_ONLY_ANNOTATIONS,
+    }, ({ workspaceId, projectPath }) => toolResult(() => listExportPresets(workspaces, { workspaceId, projectPath })));
+    registerAppTool(server, "godot_export_project", {
+        title: "Export Godot project",
+        description: "Export a Godot project using a named preset. Output must be inside the workspace. Credentials are never exposed.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, projectPath: z.string(), preset: z.string(), outputPath: z.string(), mode: z.enum(["debug", "release"]).optional() },
+        ...toolWidgetDescriptorMeta(config, "write"), annotations: MUTATING_ANNOTATIONS,
+    }, ({ workspaceId, projectPath, preset, outputPath, mode }) => toolResult(() => exportGodotProject(workspaces, { workspaceId, projectPath, preset, outputPath, mode })));
+    registerAppTool(server, "godot_assert_node_exists", {
+        title: "Assert node exists",
+        description: "Assert that a node exists in the remote runtime scene tree via the editor bridge.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, nodePath: z.string() },
+        ...toolWidgetDescriptorMeta(config, "read"), annotations: READ_ONLY_ANNOTATIONS,
+    }, ({ workspaceId, nodePath }) => toolResult(() => godotAssertNodeExists({ workspaceId, nodePath }, getBridgeClient(workspaceId))));
+    registerAppTool(server, "godot_assert_property", {
+        title: "Assert runtime property",
+        description: "Assert a runtime node property satisfies a comparison (eq/neq/gt/lt/approx/contains/exists).",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, nodePath: z.string(), property: z.string(), comparison: z.enum(["eq", "neq", "gt", "lt", "approx", "contains", "exists", "changed"]), expected: z.unknown() },
+        ...toolWidgetDescriptorMeta(config, "read"), annotations: READ_ONLY_ANNOTATIONS,
+    }, ({ workspaceId, nodePath, property, comparison, expected }) => toolResult(() => godotAssertProperty({ workspaceId, nodePath, property, comparison, expected }, getBridgeClient(workspaceId))));
+    registerAppTool(server, "godot_run_test_sequence", {
+        title: "Run Godot test sequence",
+        description: "Execute a bounded sequence of gameplay steps (press_action, wait, screenshot, assert_property, assert_node_exists, assert_no_errors). Max 50 steps, 30s total.",
+        inputSchema: {
+            workspaceId: WORKSPACE_ID_SCHEMA,
+            processId: z.string(),
+            steps: z.array(z.object({
+                type: z.string(), action: z.string().optional(), durationMs: z.number().optional(),
+                outputPath: z.string().optional(), nodePath: z.string().optional(), property: z.string().optional(),
+                comparison: z.string().optional(), expected: z.unknown().optional(),
+            })),
+        },
+        ...toolWidgetDescriptorMeta(config, "shell"), annotations: PROCESS_ANNOTATIONS,
+    }, ({ workspaceId, processId, steps }) => toolResult(() => godotRunTestSequence(workspaces, processManager, { workspaceId, processId, steps: steps }, getBridgeClient(workspaceId))));
+    registerAppTool(server, "godot_press_action", {
+        title: "Press Godot input action",
+        description: "Inject a Godot input action press via the runtime bridge. Only targets Auvrynt-tracked game processes.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, processId: z.string(), action: z.string(), durationMs: z.number().optional() },
+        ...toolWidgetDescriptorMeta(config, "shell"), annotations: PROCESS_ANNOTATIONS,
+    }, ({ workspaceId, processId, action, durationMs }) => toolResult(() => godotPressAction({ workspaceId, processId, action, durationMs }, getBridgeClient(workspaceId))));
+    registerAppTool(server, "godot_release_action", {
+        title: "Release Godot input action",
+        description: "Inject a Godot input action release via the runtime bridge. Only targets Auvrynt-tracked game processes.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, processId: z.string(), action: z.string() },
+        ...toolWidgetDescriptorMeta(config, "shell"), annotations: PROCESS_ANNOTATIONS,
+    }, ({ workspaceId, processId, action }) => toolResult(() => godotReleaseAction({ workspaceId, processId, action }, getBridgeClient(workspaceId))));
+    registerAppTool(server, "godot_mouse_click", {
+        title: "Simulate Godot mouse click",
+        description: "Inject a mouse click event at viewport coordinates via the runtime bridge. Only targets Auvrynt-tracked game processes.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, processId: z.string(), x: z.number(), y: z.number(), button: z.number().optional() },
+        ...toolWidgetDescriptorMeta(config, "shell"), annotations: PROCESS_ANNOTATIONS,
+    }, ({ workspaceId, processId, x, y, button }) => toolResult(() => godotMouseClick({ workspaceId, processId, x, y, button }, getBridgeClient(workspaceId))));
+    registerAppTool(server, "godot_parse_csharp_exceptions", {
+        title: "Parse C# exceptions from runtime logs",
+        description: "Parse Godot runtime log lines and extract structured C# exception data including stack frames, inner exceptions, and repeat counts.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, logLines: z.array(z.string()) },
+        ...toolWidgetDescriptorMeta(config, "read"), annotations: READ_ONLY_ANNOTATIONS,
+    }, ({ logLines }) => toolResult(() => parseCsharpExceptions(logLines)));
+    registerAppTool(server, "godot_generate_csharp_script", {
+        title: "Generate C# script template",
+        description: "Generate a Godot C# script boilerplate for a given class name, base type, and optional namespace.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, className: z.string(), baseType: z.string().optional(), namespace: z.string().optional() },
+        ...toolWidgetDescriptorMeta(config, "read"), annotations: READ_ONLY_ANNOTATIONS,
+    }, ({ className, baseType, namespace }) => toolResult(() => generateCsharpScript({ className, baseType, namespace })));
+}

package/dist/server/tools/godot-gdscript-tools-registration.js

@@ -0,0 +1,189 @@
+import * as z from "zod/v4";
+import { registerAppTool } from "../mcp-tool-registrar.js";
+import { MUTATING_ANNOTATIONS, PROCESS_ANNOTATIONS, READ_ONLY_ANNOTATIONS, WORKSPACE_ID_SCHEMA, toolWidgetDescriptorMeta, } from "../tool-registration-shared.js";
+import { inspectGodotGdscriptEnvironment, getGdscriptDiagnostics, inspectGdscript, createGdscript, attachGdscript, detachGdscript, createGdscriptSignal, createGdscriptSignalHandler, getGlobalClasses, addClassName, removeClassName, addGdscriptAutoload, getAutoloadUsage, inspectToolScript, createEditorPlugin, getGdscriptDependencies, findCyclicScriptDependencies, getGdscriptNodeReferences, getGdscriptLifecycleMethods, inspectGdscriptAwaitUsage, analyzeGdscriptTyping, formatGdscript, detectGdscriptTests, runGdscriptTests, reloadGdscript, setBreakpoint as gdscriptSetBreakpoint, removeBreakpoint as gdscriptRemoveBreakpoint, lspFindSymbol as gdscriptLspFindSymbol, lspGetDefinition as gdscriptLspGetDefinition, } from "../../godot-gdscript.js";
+function toolResult(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 registerGodotGdscriptTools(server, config, workspaces) {
+    registerAppTool(server, "godot_gdscript_environment", {
+        title: "Godot GDScript environment",
+        description: "Inspect the GDScript project configuration, Godot executable, and project warnings.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, projectPath: z.string().optional() },
+        ...toolWidgetDescriptorMeta(config, "read"), annotations: READ_ONLY_ANNOTATIONS,
+    }, ({ workspaceId, projectPath }) => toolResult(() => inspectGodotGdscriptEnvironment(workspaces, { workspaceId, projectPath })));
+    registerAppTool(server, "godot_get_gdscript_diagnostics", {
+        title: "Get GDScript diagnostics",
+        description: "Return static-analysis and parser diagnostics for GDScript files.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, projectPath: z.string(), scriptPath: z.string().optional(), includeWarnings: z.boolean().optional() },
+        ...toolWidgetDescriptorMeta(config, "read"), annotations: READ_ONLY_ANNOTATIONS,
+    }, ({ workspaceId, projectPath, scriptPath, includeWarnings }) => toolResult(() => getGdscriptDiagnostics(workspaces, { workspaceId, projectPath, scriptPath, includeWarnings })));
+    registerAppTool(server, "godot_inspect_gdscript", {
+        title: "Inspect GDScript source",
+        description: "Inspect class name, base extends, exported properties, methods, signals, node paths, and preloads.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, scriptPath: z.string() },
+        ...toolWidgetDescriptorMeta(config, "read"), annotations: READ_ONLY_ANNOTATIONS,
+    }, ({ workspaceId, scriptPath }) => toolResult(() => inspectGdscript(workspaces, { workspaceId, scriptPath })));
+    registerAppTool(server, "godot_create_gdscript", {
+        title: "Create GDScript",
+        description: "Create a new GDScript file using empty, node, resource, or plugin templates.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, outputPath: z.string(), baseType: z.string(), className: z.string().optional(), toolScript: z.boolean().optional(), template: z.enum(["empty", "node", "resource", "editor_plugin"]).optional() },
+        ...toolWidgetDescriptorMeta(config, "write"), annotations: MUTATING_ANNOTATIONS,
+    }, ({ workspaceId, outputPath, baseType, className, toolScript, template }) => toolResult(() => createGdscript(workspaces, { workspaceId, outputPath, baseType, className, toolScript, template })));
+    registerAppTool(server, "godot_attach_gdscript", {
+        title: "Attach GDScript to node",
+        description: "Attach a GDScript script path to a node in the edited scene tree.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, nodePath: z.string(), scriptPath: z.string() },
+        ...toolWidgetDescriptorMeta(config, "write"), annotations: MUTATING_ANNOTATIONS,
+    }, ({ workspaceId, nodePath, scriptPath }) => toolResult(() => attachGdscript(workspaces, { workspaceId, nodePath, scriptPath })));
+    registerAppTool(server, "godot_detach_gdscript", {
+        title: "Detach GDScript from node",
+        description: "Detach script from a node in the edited scene tree.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, nodePath: z.string() },
+        ...toolWidgetDescriptorMeta(config, "write"), annotations: MUTATING_ANNOTATIONS,
+    }, ({ workspaceId, nodePath }) => toolResult(() => detachGdscript(workspaces, { workspaceId, nodePath })));
+    registerAppTool(server, "godot_create_gdscript_signal", {
+        title: "Create GDScript signal",
+        description: "Declare a new signal in a GDScript file.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, scriptPath: z.string(), signalName: z.string(), parameters: z.array(z.object({ name: z.string(), type: z.string().optional() })).optional() },
+        ...toolWidgetDescriptorMeta(config, "write"), annotations: MUTATING_ANNOTATIONS,
+    }, ({ workspaceId, scriptPath, signalName, parameters }) => toolResult(() => createGdscriptSignal(workspaces, { workspaceId, scriptPath, signalName, parameters })));
+    registerAppTool(server, "godot_create_gdscript_signal_handler", {
+        title: "Create signal handler stub",
+        description: "Create a callback method stub for handling connected signals.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, scriptPath: z.string(), methodName: z.string(), parameters: z.array(z.object({ name: z.string(), type: z.string().optional() })).optional() },
+        ...toolWidgetDescriptorMeta(config, "write"), annotations: MUTATING_ANNOTATIONS,
+    }, ({ workspaceId, scriptPath, methodName, parameters }) => toolResult(() => createGdscriptSignalHandler(workspaces, { workspaceId, scriptPath, methodName, parameters })));
+    registerAppTool(server, "godot_get_global_classes", {
+        title: "Get global classes",
+        description: "List all global script classes defined with class_name.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA },
+        ...toolWidgetDescriptorMeta(config, "read"), annotations: READ_ONLY_ANNOTATIONS,
+    }, ({ workspaceId }) => toolResult(() => getGlobalClasses(workspaces, { workspaceId })));
+    registerAppTool(server, "godot_add_class_name", {
+        title: "Add class_name to script",
+        description: "Declare a new global class_name at the top of a GDScript.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, scriptPath: z.string(), className: z.string() },
+        ...toolWidgetDescriptorMeta(config, "write"), annotations: MUTATING_ANNOTATIONS,
+    }, ({ workspaceId, scriptPath, className }) => toolResult(() => addClassName(workspaces, { workspaceId, scriptPath, className })));
+    registerAppTool(server, "godot_remove_class_name", {
+        title: "Remove class_name from script",
+        description: "Remove the global class_name declaration from a GDScript.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, scriptPath: z.string() },
+        ...toolWidgetDescriptorMeta(config, "write"), annotations: MUTATING_ANNOTATIONS,
+    }, ({ workspaceId, scriptPath }) => toolResult(() => removeClassName(workspaces, { workspaceId, scriptPath })));
+    registerAppTool(server, "godot_add_gdscript_autoload", {
+        title: "Add GDScript autoload singleton",
+        description: "Register a script as a global autoload singleton in project.godot.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, scriptPath: z.string(), singletonName: z.string() },
+        ...toolWidgetDescriptorMeta(config, "write"), annotations: MUTATING_ANNOTATIONS,
+    }, ({ workspaceId, scriptPath, singletonName }) => toolResult(() => addGdscriptAutoload(workspaces, { workspaceId, scriptPath, singletonName })));
+    registerAppTool(server, "godot_get_autoload_usage", {
+        title: "Find autoload references",
+        description: "Search for script/code occurrences referencing an autoload singleton name.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, singletonName: z.string() },
+        ...toolWidgetDescriptorMeta(config, "read"), annotations: READ_ONLY_ANNOTATIONS,
+    }, ({ workspaceId, singletonName }) => toolResult(() => getAutoloadUsage(workspaces, { workspaceId, singletonName })));
+    registerAppTool(server, "godot_inspect_tool_script", {
+        title: "Inspect @tool script",
+        description: "Check if a script is annotated with @tool and list editor methods.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, scriptPath: z.string() },
+        ...toolWidgetDescriptorMeta(config, "read"), annotations: READ_ONLY_ANNOTATIONS,
+    }, ({ workspaceId, scriptPath }) => toolResult(() => inspectToolScript(workspaces, { workspaceId, scriptPath })));
+    registerAppTool(server, "godot_create_editor_plugin", {
+        title: "Create editor plugin",
+        description: "Scaffold a new editor plugin addon folder with cfg and gd scripts.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, pluginName: z.string(), description: z.string().optional(), author: z.string().optional(), version: z.string().optional() },
+        ...toolWidgetDescriptorMeta(config, "write"), annotations: MUTATING_ANNOTATIONS,
+    }, ({ workspaceId, pluginName, description, author, version }) => toolResult(() => createEditorPlugin(workspaces, { workspaceId, pluginName, description, author, version })));
+    registerAppTool(server, "godot_get_gdscript_dependencies", {
+        title: "Get GDScript load dependencies",
+        description: "List preload/load file dependencies from a script.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, scriptPath: z.string() },
+        ...toolWidgetDescriptorMeta(config, "read"), annotations: READ_ONLY_ANNOTATIONS,
+    }, ({ workspaceId, scriptPath }) => toolResult(() => getGdscriptDependencies(workspaces, { workspaceId, scriptPath })));
+    registerAppTool(server, "godot_find_cyclic_script_dependencies", {
+        title: "Find cyclic preload dependencies",
+        description: "List cyclic script preload dependencies that might crash the editor or build.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA },
+        ...toolWidgetDescriptorMeta(config, "read"), annotations: READ_ONLY_ANNOTATIONS,
+    }, ({ workspaceId }) => toolResult(() => findCyclicScriptDependencies(workspaces, { workspaceId })));
+    registerAppTool(server, "godot_get_gdscript_node_references", {
+        title: "Get script node path references",
+        description: "Scan code for $Node path strings and unique names references.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, scriptPath: z.string() },
+        ...toolWidgetDescriptorMeta(config, "read"), annotations: READ_ONLY_ANNOTATIONS,
+    }, ({ workspaceId, scriptPath }) => toolResult(() => getGdscriptNodeReferences(workspaces, { workspaceId, scriptPath })));
+    registerAppTool(server, "godot_get_gdscript_lifecycle_methods", {
+        title: "Get lifecycle methods",
+        description: "List lifecycle function overrides (_ready, _process) with helper alerts.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, scriptPath: z.string() },
+        ...toolWidgetDescriptorMeta(config, "read"), annotations: READ_ONLY_ANNOTATIONS,
+    }, ({ workspaceId, scriptPath }) => toolResult(() => getGdscriptLifecycleMethods(workspaces, { workspaceId, scriptPath })));
+    registerAppTool(server, "godot_inspect_gdscript_await_usage", {
+        title: "Inspect await statements",
+        description: "Scan code for awaits and list timer/callable safety checks.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, scriptPath: z.string() },
+        ...toolWidgetDescriptorMeta(config, "read"), annotations: READ_ONLY_ANNOTATIONS,
+    }, ({ workspaceId, scriptPath }) => toolResult(() => inspectGdscriptAwaitUsage(workspaces, { workspaceId, scriptPath })));
+    registerAppTool(server, "godot_analyze_gdscript_typing", {
+        title: "Analyze typing coverage",
+        description: "Compute return, variable, and parameter explicit typing coverage percentages.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, scriptPath: z.string() },
+        ...toolWidgetDescriptorMeta(config, "read"), annotations: READ_ONLY_ANNOTATIONS,
+    }, ({ workspaceId, scriptPath }) => toolResult(() => analyzeGdscriptTyping(workspaces, { workspaceId, scriptPath })));
+    registerAppTool(server, "godot_format_gdscript", {
+        title: "Format GDScript",
+        description: "Run formatting layout fixes using gdformat. Use verifyOnly=true for pass/fail audits.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, scriptPath: z.string().optional(), verifyOnly: z.boolean().optional() },
+        ...toolWidgetDescriptorMeta(config, "write"), annotations: MUTATING_ANNOTATIONS,
+    }, ({ workspaceId, scriptPath, verifyOnly }) => toolResult(() => formatGdscript(workspaces, { workspaceId, scriptPath, verifyOnly })));
+    registerAppTool(server, "godot_detect_gdscript_tests", {
+        title: "Detect test configuration",
+        description: "Inspect folder structure for GUT (Godot Unit Test) framework and script files.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, projectPath: z.string() },
+        ...toolWidgetDescriptorMeta(config, "read"), annotations: READ_ONLY_ANNOTATIONS,
+    }, ({ workspaceId, projectPath }) => toolResult(() => detectGdscriptTests(workspaces, { workspaceId, projectPath })));
+    registerAppTool(server, "godot_run_gdscript_tests", {
+        title: "Run GDScript tests",
+        description: "Run unit/integration tests and return passing, failing, and skipped logs.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, projectPath: z.string(), testPath: z.string().optional(), filter: z.string().optional() },
+        ...toolWidgetDescriptorMeta(config, "shell"), annotations: PROCESS_ANNOTATIONS,
+    }, ({ workspaceId, projectPath, testPath, filter }) => toolResult(() => runGdscriptTests(workspaces, { workspaceId, projectPath, testPath, filter })));
+    registerAppTool(server, "godot_reload_gdscript", {
+        title: "Reload scripts in editor",
+        description: "Trigger live reload of updated GDScript files inside the active editor bridge.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, scriptPath: z.string().optional() },
+        ...toolWidgetDescriptorMeta(config, "write"), annotations: MUTATING_ANNOTATIONS,
+    }, ({ workspaceId, scriptPath }) => toolResult(() => reloadGdscript(workspaces, { workspaceId, scriptPath })));
+    registerAppTool(server, "godot_gdscript_set_breakpoint", {
+        title: "Set breakpoint",
+        description: "Declare a breakpoint at a script path line.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, scriptPath: z.string(), line: z.number() },
+        ...toolWidgetDescriptorMeta(config, "write"), annotations: MUTATING_ANNOTATIONS,
+    }, ({ workspaceId, scriptPath, line }) => toolResult(() => gdscriptSetBreakpoint(workspaces, { workspaceId, scriptPath, line })));
+    registerAppTool(server, "godot_gdscript_remove_breakpoint", {
+        title: "Remove breakpoint",
+        description: "Clear a breakpoint from a script line.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, scriptPath: z.string(), line: z.number() },
+        ...toolWidgetDescriptorMeta(config, "write"), annotations: MUTATING_ANNOTATIONS,
+    }, ({ workspaceId, scriptPath, line }) => toolResult(() => gdscriptRemoveBreakpoint(workspaces, { workspaceId, scriptPath, line })));
+    registerAppTool(server, "godot_gdscript_lsp_find_symbol", {
+        title: "LSP find GDScript symbol",
+        description: "Find a symbol definition across all GDScript files via the Godot editor LSP bridge.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, symbol: z.string() },
+        ...toolWidgetDescriptorMeta(config, "search"), annotations: READ_ONLY_ANNOTATIONS,
+    }, ({ workspaceId, symbol }) => toolResult(() => gdscriptLspFindSymbol(workspaces, { workspaceId, symbol })));
+    registerAppTool(server, "godot_gdscript_lsp_get_definition", {
+        title: "LSP get GDScript definition",
+        description: "Get the definition location of a symbol at a specific line/character in a GDScript file via the Godot editor LSP bridge.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, scriptPath: z.string(), line: z.number(), character: z.number() },
+        ...toolWidgetDescriptorMeta(config, "search"), annotations: READ_ONLY_ANNOTATIONS,
+    }, ({ workspaceId, scriptPath, line, character }) => toolResult(() => gdscriptLspGetDefinition(workspaces, { workspaceId, scriptPath, line, character })));
+}

package/dist/server/tools/process-project-tools-registration.js

@@ -0,0 +1,155 @@
+import * as z from "zod/v4";
+import { getConnectionStatus } from "../../connection-status.js";
+import { globFiles, inspectProject, searchText } from "../../search-discovery.js";
+import { getRequestContext } from "../../request-context.js";
+import { registerAppTool } from "../mcp-tool-registrar.js";
+import { PROCESS_ANNOTATIONS, READ_ONLY_ANNOTATIONS, WORKSPACE_ID_SCHEMA, toolWidgetDescriptorMeta, } from "../tool-registration-shared.js";
+function errorResult(prefix, error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { content: [{ type: "text", text: `${prefix}: ${message}` }], isError: true };
+}
+export function registerProcessProjectTools(server, config, workspaces, processManager, logToolCall) {
+    registerAppTool(server, "get_connection_status", {
+        title: "Connection status",
+        description: "Automatically check which local integrations are connected for this workspace: MCP, Blender, Godot, browser support, Chrome MCP availability, and tracked processes.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA },
+        ...toolWidgetDescriptorMeta(config, "read"), annotations: READ_ONLY_ANNOTATIONS,
+    }, async ({ workspaceId }, extra) => {
+        try {
+            const result = await getConnectionStatus(workspaces, processManager, config, extra.authInfo?.scopes ?? [], workspaceId);
+            return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (error) {
+            return errorResult("get_connection_status failed", error);
+        }
+    });
+    registerAppTool(server, "start_process", {
+        title: "Start process",
+        description: "Start a persistent background process (server, app, game) inside an open workspace. Returns a processId. Use get_process_logs to tail output. Do not use run_shell for long-running processes.",
+        inputSchema: {
+            workspaceId: WORKSPACE_ID_SCHEMA,
+            command: z.string().describe("Shell command to run."),
+            workingDirectory: z.string().optional().describe("Working directory relative to workspace root."),
+            environment: z.record(z.string(), z.string()).optional().describe("Additional environment variables (secrets will be redacted in responses)."),
+        },
+        ...toolWidgetDescriptorMeta(config, "shell"), annotations: PROCESS_ANNOTATIONS,
+    }, async ({ workspaceId, command, workingDirectory, environment }) => {
+        const startedAt = performance.now();
+        const ctx = getRequestContext();
+        try {
+            const result = processManager.startProcess({ workspaceId, ownerClientId: ctx?.ownerClientId, command, workingDirectory, environment });
+            logToolCall(config, { tool: "start_process", workspaceId, command, success: true, durationMs: Math.round(performance.now() - startedAt) });
+            return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            logToolCall(config, { tool: "start_process", workspaceId, command, success: false, durationMs: Math.round(performance.now() - startedAt), error: message });
+            return errorResult("start_process failed", error);
+        }
+    });
+    registerAppTool(server, "get_process_logs", {
+        title: "Get process logs",
+        description: "Retrieve recent stdout/stderr from a running or exited process started by start_process.",
+        inputSchema: {
+            workspaceId: WORKSPACE_ID_SCHEMA,
+            processId: z.string().describe("Process ID returned by start_process."),
+            lines: z.number().int().optional().describe("Number of recent lines to return (default 100, max 500)."),
+            stream: z.enum(["stdout", "stderr", "both"]).optional().describe("Which stream to return."),
+        },
+        ...toolWidgetDescriptorMeta(config, "shell"), annotations: READ_ONLY_ANNOTATIONS,
+    }, async ({ workspaceId, processId, lines, stream }) => {
+        try {
+            const result = processManager.getProcessLogs({ workspaceId, processId, lines, stream, ownerClientId: getRequestContext()?.ownerClientId });
+            return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (error) {
+            return errorResult("get_process_logs failed", error);
+        }
+    });
+    registerAppTool(server, "list_processes", {
+        title: "List processes",
+        description: "List all tracked processes for the current workspace.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA },
+        ...toolWidgetDescriptorMeta(config, "shell"), annotations: READ_ONLY_ANNOTATIONS,
+    }, async ({ workspaceId }) => {
+        try {
+            const result = processManager.listProcesses({ workspaceId, ownerClientId: getRequestContext()?.ownerClientId });
+            return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (error) {
+            return errorResult("list_processes failed", error);
+        }
+    });
+    registerAppTool(server, "stop_process", {
+        title: "Stop process",
+        description: "Stop a tracked process gracefully. Set force=true to kill the process tree immediately.",
+        inputSchema: {
+            workspaceId: WORKSPACE_ID_SCHEMA,
+            processId: z.string().describe("Process ID returned by start_process."),
+            force: z.boolean().optional().describe("If true, forcibly kill the process tree."),
+        },
+        ...toolWidgetDescriptorMeta(config, "shell"), annotations: PROCESS_ANNOTATIONS,
+    }, async ({ workspaceId, processId, force }) => {
+        try {
+            const result = await processManager.stopProcess({ workspaceId, processId, force, ownerClientId: getRequestContext()?.ownerClientId });
+            return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (error) {
+            return errorResult("stop_process failed", error);
+        }
+    });
+    registerAppTool(server, "glob_files", {
+        title: "Glob files",
+        description: "Find files by glob pattern within the workspace. Respects common ignore directories. Returns workspace-relative paths.",
+        inputSchema: {
+            workspaceId: WORKSPACE_ID_SCHEMA,
+            pattern: z.string().describe("Glob pattern such as *.ts or src/**/*.json."),
+            basePath: z.string().optional().describe("Base directory relative to workspace root to search in."),
+            maxResults: z.number().int().optional().describe("Maximum results (default 100, max 1000)."),
+        },
+        ...toolWidgetDescriptorMeta(config, "search"), annotations: READ_ONLY_ANNOTATIONS,
+    }, async ({ workspaceId, pattern, basePath, maxResults }) => {
+        try {
+            const result = await globFiles(workspaces, { workspaceId, pattern, basePath, maxResults });
+            return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (error) {
+            return errorResult("glob_files failed", error);
+        }
+    });
+    registerAppTool(server, "search_text", {
+        title: "Search text",
+        description: "Search for text across workspace files. Returns file path, line, column, match snippet, and context lines.",
+        inputSchema: {
+            workspaceId: WORKSPACE_ID_SCHEMA,
+            query: z.string().describe("Text or pattern to search for."),
+            paths: z.array(z.string()).optional().describe("Limit search to these workspace-relative paths."),
+            filePattern: z.string().optional().describe("Filter by file extension pattern, e.g. *.ts."),
+            caseSensitive: z.boolean().optional().describe("Default false."),
+            maxResults: z.number().int().optional().describe("Max matches (default 50, max 500)."),
+        },
+        ...toolWidgetDescriptorMeta(config, "search"), annotations: READ_ONLY_ANNOTATIONS,
+    }, async ({ workspaceId, query, paths, filePattern, caseSensitive, maxResults }) => {
+        try {
+            const result = await searchText(workspaces, { workspaceId, query, paths, filePattern, caseSensitive, maxResults });
+            return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (error) {
+            return errorResult("search_text failed", error);
+        }
+    });
+    registerAppTool(server, "inspect_project", {
+        title: "Inspect project",
+        description: "Detect project type, package managers, frameworks, and recommended build/run/test commands. Supports Node.js, TypeScript, .NET, Godot, Python, and Git.",
+        inputSchema: { workspaceId: WORKSPACE_ID_SCHEMA, path: z.string().optional().describe("Subdirectory to inspect, relative to workspace root.") },
+        ...toolWidgetDescriptorMeta(config, "search"), annotations: READ_ONLY_ANNOTATIONS,
+    }, async ({ workspaceId, path }) => {
+        try {
+            const result = await inspectProject(workspaces, { workspaceId, path });
+            return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (error) {
+            return errorResult("inspect_project failed", error);
+        }
+    });
+}