auvrynt 1.0.2 → 1.0.5

package/dist/server/dashboard-routes.js

@@ -0,0 +1,46 @@
+import { randomBytes } from "node:crypto";
+import { isLoopbackRequest } from "../logger.js";
+import { createDashboardToolsView, createDashboardView, dashboardCsp, dashboardHtml, } from "./dashboard.js";
+import { integrationToolCounts } from "./mcp-tool-registrar.js";
+export function registerDashboardRoutes(options) {
+    const { app, config, snapshot, nonce } = options;
+    app.get("/dashboard", async (req, res) => {
+        if (!isLoopbackRequest(req)) {
+            res.status(404).end();
+            return;
+        }
+        const pageNonce = nonce();
+        res.setHeader("Cache-Control", "no-store");
+        res.setHeader("X-Frame-Options", "DENY");
+        res.setHeader("X-Content-Type-Options", "nosniff");
+        res.setHeader("Referrer-Policy", "no-referrer");
+        res.setHeader("Content-Security-Policy", dashboardCsp(pageNonce));
+        const view = await createDashboardView(config, snapshot());
+        res.type("html").send(dashboardHtml(view, pageNonce));
+    });
+    app.get("/dashboard/data", async (req, res) => {
+        res.setHeader("Cache-Control", "no-store");
+        if (!isLoopbackRequest(req)) {
+            res.status(404).end();
+            return;
+        }
+        res.json(await createDashboardView(config, snapshot()));
+    });
+    app.get("/dashboard/tools", (req, res) => {
+        res.setHeader("Cache-Control", "no-store");
+        if (!isLoopbackRequest(req)) {
+            res.status(404).end();
+            return;
+        }
+        const integration = typeof req.query.integration === "string" ? req.query.integration : "";
+        const tools = createDashboardToolsView(config, integration);
+        if (tools === undefined) {
+            res.status(404).json({ error: "Unknown integration." });
+            return;
+        }
+        res.json({ integration, tools, counts: integrationToolCounts(config) });
+    });
+}
+export function randomNonce() {
+    return randomBytes(18).toString("base64url");
+}

package/dist/server/dashboard.js

@@ -0,0 +1,240 @@
+import { summarizeNgrokAuthtokens, } from "../infrastructure/ngrok-auth-pool.js";
+import { summarizeContext7Auth, } from "../infrastructure/context7-auth.js";
+import { readConnectedClients } from "../connection-registry.js";
+import { discoverLocalIntegrations, processDetected } from "../integration-discovery.js";
+import { recentLogEntries } from "../infrastructure/logger.js";
+import { getPlaywrightRuntimeStatus } from "../playwright-runtime.js";
+import { getAsepriteBridgeRuntimeStatus } from "../integrations/aseprite/aseprite-live-tools.js";
+import { integrationToolCounts, registeredToolNamesForIntegration } from "./mcp-tool-registrar.js";
+import { toolIntegrationEnabled } from "./mcp-policy.js";
+import { groupToolsByName } from "./tool-groups.js";
+import { dashboardHtml } from "./dashboard-page.js";
+import { formatPathForPrompt, loadWorkspaceSkills } from "../workspace/skills.js";
+export { dashboardHtml };
+const INTEGRATION_LABELS = {
+    godotGdscript: "Godot GDScript",
+    godotCsharp: "Godot C#",
+    blender: "Blender",
+    aseprite: "Aseprite",
+    serena: "Serena",
+    playwright: "Playwright",
+    context7: "Context7",
+    obsidian: "Obsidian",
+    roblox: "Roblox Studio",
+};
+export async function createDashboardView(config, runtime) {
+    const discovered = await discoverLocalIntegrations().catch(() => undefined);
+    const playwright = getPlaywrightRuntimeStatus();
+    const integration = (key, connected, available, connectedDetail, availableDetail, offlineDetail) => {
+        const counts = integrationToolCounts(config);
+        const toolCount = counts[key]?.total ?? 0;
+        const toolEnabledCount = counts[key]?.enabled ?? 0;
+        const enabled = config.integrations[key];
+        if (!enabled) {
+            return {
+                key,
+                label: INTEGRATION_LABELS[key],
+                enabled,
+                state: "disabled",
+                detail: "Not included in the active profile.",
+                toolCount,
+                toolEnabledCount,
+            };
+        }
+        if (connected) {
+            return { key, label: INTEGRATION_LABELS[key], enabled, state: "connected", detail: connectedDetail, toolCount, toolEnabledCount };
+        }
+        if (available) {
+            return { key, label: INTEGRATION_LABELS[key], enabled, state: "available", detail: availableDetail, toolCount, toolEnabledCount };
+        }
+        return { key, label: INTEGRATION_LABELS[key], enabled, state: "offline", detail: offlineDetail, toolCount, toolEnabledCount };
+    };
+    const godotConnected = Boolean(discovered?.ports.auvrynt_godot_bridge);
+    const godotAvailable = Boolean(discovered
+        && (processDetected(discovered, "godot")
+            || discovered.executables.godot
+            || discovered.executables.godotCsharp));
+    const blenderConnected = Boolean(discovered?.ports.auvrynt_blender_bridge || discovered?.ports.blender_lab_mcp);
+    const blenderAvailable = Boolean(discovered && (processDetected(discovered, "blender") || discovered.executables.blender));
+    const asepriteRunning = Boolean(discovered && processDetected(discovered, "aseprite"));
+    const asepriteBridge = asepriteRunning
+        ? await getAsepriteBridgeRuntimeStatus()
+        : undefined;
+    const asepriteConnected = Boolean(asepriteRunning && asepriteBridge?.connected);
+    const asepriteAvailable = Boolean(asepriteRunning || discovered?.executables.aseprite);
+    const asepriteAvailableDetail = asepriteRunning
+        ? asepriteBridge?.installed
+            ? "Aseprite is running, but the Auvrynt live bridge is not responding. Restart Aseprite once after bridge installation, and close modal dialogs that can block extension timers."
+            : "Aseprite is running, but the Auvrynt live bridge is not installed. Native CLI tools remain available."
+        : "Aseprite native CLI is detected and ready on demand; launch Aseprite with the bridge installed for live editor control.";
+    const serenaConnected = Boolean(discovered && processDetected(discovered, "serena"));
+    const serenaAvailable = Boolean(discovered?.executables.serena || config.serena.executable);
+    const agentProvider = runtime.sessions > 0
+        ? readConnectedClients(config.stateDir)[0]?.provider
+        : undefined;
+    const logs = recentLogEntries(250).reverse();
+    const ngrokSummary = summarizeNgrokAuthtokens();
+    const ngrokNotice = createNgrokNotice(config, ngrokSummary, logs);
+    const context7 = summarizeContext7Auth();
+    const agentState = !runtime.ready
+        ? "stopping"
+        : runtime.activeToolCalls > 0
+            ? "working"
+            : runtime.sessions > 0
+                ? "connected"
+                : "waiting";
+    return {
+        ready: runtime.ready,
+        agentState,
+        agentLastSeenAt: runtime.lastMcpActivityAt
+            ? new Date(runtime.lastMcpActivityAt).toISOString()
+            : undefined,
+        activeToolCalls: runtime.activeToolCalls,
+        agentProvider,
+        pid: process.pid,
+        uptimeSeconds: process.uptime(),
+        localMcpUrl: localHttpUrl(config.host, config.port, "/mcp"),
+        publicMcpUrl: `${config.publicBaseUrl.replace(/\/$/, "")}/mcp`,
+        publicBaseUrl: config.publicBaseUrl,
+        tunnelProvider: config.tunnelProvider,
+        allowedRoots: [...config.allowedRoots],
+        sessions: runtime.sessions,
+        maxSessions: config.maxSessions,
+        sessionIdleTimeoutMinutes: Math.round(config.sessionIdleTimeoutMs / 60_000),
+        runningProcesses: runtime.runningProcesses,
+        workspaceChanges: runtime.workspaceChanges,
+        integrations: [
+            integration("godotCsharp", godotConnected, godotAvailable, "Godot bridge is connected.", "Godot is available; waiting for the bridge.", "Godot or its bridge is not detected."),
+            integration("godotGdscript", godotConnected, godotAvailable, "Godot bridge is connected.", "Godot is available; waiting for the bridge.", "Godot or its bridge is not detected."),
+            integration("blender", blenderConnected, blenderAvailable, "Blender MCP bridge is connected.", "Blender is available; waiting for its bridge.", "Blender is not detected."),
+            integration("aseprite", asepriteConnected, asepriteAvailable, `Auvrynt live bridge ${asepriteBridge?.bridgeVersion ?? ""}`.trim() + " is connected to the running Aseprite editor.", asepriteAvailableDetail, "Aseprite is not detected, and its native CLI is unavailable."),
+            integration("serena", serenaConnected, serenaAvailable, "Serena is running.", "Serena is detected and enabled by default.", "Serena is not detected."),
+            integration("playwright", false, playwright.chromiumInstalled, "Playwright browser is active.", "Chromium is installed and starts on demand.", "Playwright Chromium is unavailable."),
+            integration("context7", false, true, "Context7 API is ready.", "Context7 docs tools use the API key from Secrets.", "Add a Context7 API key in Secrets."),
+            integration("obsidian", false, true, "Obsidian vault is configured.", "Point AUVRYNT_OBSIDIAN_VAULT at your vault folder.", "Configure an Obsidian vault path to enable note tools."),
+            integration("roblox", Boolean(discovered && processDetected(discovered, "roblox")), true, "Roblox Studio process detected.", "Official Studio MCP launcher is available for roblox_* tools.", "Install Studio, enable MCP in Assistant settings, then start with auvrynt start roblox."),
+        ],
+        skills: buildDashboardSkills(config),
+        ngrok: {
+            ...ngrokSummary,
+            provider: config.tunnelProvider,
+            ...(ngrokNotice ? { notice: ngrokNotice } : {}),
+        },
+        context7,
+        logs,
+    };
+}
+function createNgrokNotice(config, summary, logs) {
+    if (config.tunnelProvider !== "ngrok")
+        return undefined;
+    const quotaEvent = logs.some((entry) => entry.event === "ngrok_quota_exhausted");
+    const exhausted = summary.tokens.filter((token) => token.quotaExhaustedAt);
+    if (summary.environmentOverride) {
+        if (!quotaEvent)
+            return undefined;
+        return {
+            tone: "error",
+            title: "ngrok request limit reached",
+            message: "The active token comes from AUVRYNT_NGROK_AUTHTOKEN, so automatic failover is blocked. Remove that override and add backup tokens in Secrets.",
+        };
+    }
+    if (exhausted.length === 0)
+        return undefined;
+    const active = summary.tokens.find((token) => token.active);
+    if (active && !active.quotaExhaustedAt && exhausted.length > 0) {
+        return {
+            tone: "warning",
+            title: "ngrok token switched automatically",
+            message: `${exhausted.length} saved token${exhausted.length === 1 ? " has" : "s have"} reached the monthly request limit. Auvrynt is using backup ${active.fingerprint}. Check Connectivity because a random ngrok public URL may have changed.`,
+        };
+    }
+    if (summary.tokens.length === 0) {
+        return {
+            tone: "error",
+            title: "ngrok request limit reached",
+            message: "No managed backup token is available. Add another ngrok authtoken in Secrets to restore the public MCP tunnel.",
+        };
+    }
+    return {
+        tone: "error",
+        title: "All saved ngrok tokens are unavailable",
+        message: `${exhausted.length || summary.tokens.length} saved token${summary.tokens.length === 1 ? " has" : "s have"} reached the monthly request limit. Add a fresh token in Secrets.`,
+    };
+}
+export function createDashboardToolsView(config, integration) {
+    const names = registeredToolNamesForIntegration(integration);
+    if (names.length === 0 && !config.integrations[integration])
+        return undefined;
+    const groups = groupToolsByName(names);
+    const entries = [];
+    for (const [group, toolNames] of groups) {
+        for (const name of toolNames) {
+            entries.push({
+                name,
+                title: toolTitle(name),
+                group,
+                enabled: toolIntegrationEnabled(config, name),
+            });
+        }
+    }
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+    return entries;
+}
+function toolTitle(name) {
+    return name
+        .replace(/^blender_|^aseprite_|^godot_|^serena_|^context7_|^obsidian_/, "")
+        .split("_")
+        .filter(Boolean)
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+        .join(" ");
+}
+export function dashboardCsp(nonce) {
+    return [
+        "default-src 'none'",
+        `style-src 'nonce-${nonce}'`,
+        `script-src 'nonce-${nonce}'`,
+        "img-src 'self'",
+        "connect-src 'self'",
+        "frame-ancestors 'none'",
+        "base-uri 'none'",
+        "form-action 'none'",
+    ].join("; ");
+}
+function localHttpUrl(host, port, path) {
+    const probeHost = host === "0.0.0.0" || host === "::" ? "127.0.0.1" : host;
+    const formattedHost = probeHost.includes(":") && !probeHost.startsWith("[")
+        ? `[${probeHost}]`
+        : probeHost;
+    return `http://${formattedHost}:${port}${path}`;
+}
+function buildDashboardSkills(config) {
+    const workspaceRoot = config.allowedRoots[0];
+    const cwd = workspaceRoot ?? config.agentDir;
+    const loaded = loadWorkspaceSkills(config, cwd);
+    return {
+        enabled: config.skillsEnabled,
+        agentDir: formatPathForPrompt(config.agentDir),
+        skillPaths: config.skillPaths.map((path) => formatPathForPrompt(path)),
+        ...(workspaceRoot ? { workspaceRoot: formatPathForPrompt(workspaceRoot) } : {}),
+        skills: loaded.skills.map((skill) => ({
+            name: skill.name,
+            description: skill.description,
+            path: formatPathForPrompt(skill.filePath),
+            baseDir: formatPathForPrompt(skill.baseDir),
+            scope: skill.sourceInfo.scope,
+            source: skill.sourceInfo.source,
+            origin: skill.sourceInfo.origin,
+            disableModelInvocation: skill.disableModelInvocation,
+            agentAccess: skill.disableModelInvocation
+                ? "Listed for agents, but model auto-invocation is disabled (manual /skill use only)."
+                : "Exposed on open_workspace as an available skill; agents should read the SKILL.md path before using it.",
+        })),
+        diagnostics: loaded.diagnostics.map((diag) => ({
+            type: typeof diag.type === "string" ? diag.type : undefined,
+            message: String(diag.message ?? diag),
+            path: typeof diag.path === "string"
+                ? formatPathForPrompt(diag.path)
+                : undefined,
+        })),
+    };
+}

package/dist/server/http-helpers.js

@@ -0,0 +1,30 @@
+import { realpath } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+export function sendJsonRpcError(res, status, code, message) {
+    res.status(status).json({
+        jsonrpc: "2.0",
+        error: { code, message },
+        id: null,
+    });
+}
+export function requestLogFields(req) {
+    return {
+        userAgent: req.header("user-agent"),
+        contentLength: req.header("content-length"),
+    };
+}
+export function mcpClientName(req) {
+    const headerName = req.header("x-mcp-client-name") ?? req.header("x-client-name");
+    if (headerName)
+        return headerName;
+    const body = req.body;
+    const name = body?.params?.clientInfo?.name;
+    return typeof name === "string" ? name : undefined;
+}
+export async function isMainModule(moduleUrl) {
+    if (!process.argv[1])
+        return false;
+    const modulePath = await realpath(fileURLToPath(moduleUrl));
+    const entrypointPath = await realpath(process.argv[1]);
+    return modulePath === entrypointPath;
+}

package/dist/server/integration-profile-update.js

@@ -0,0 +1,37 @@
+import { oauthScopesForIntegrations, } from "../config.js";
+import { logEvent } from "../logger.js";
+import { syncMcpToolAvailability } from "./mcp-tool-registrar.js";
+export async function applyIntegrationProfileUpdate(input) {
+    const { config, integrations, serenaExecutable, oauthProvider, serenaManager, mcpServers, } = input;
+    Object.assign(config.integrations, integrations);
+    const locallyApprovedScopes = oauthScopesForIntegrations(config.integrations);
+    if (config.oauth.scopes.includes("auvrynt:blender-python")
+        && config.integrations.blender) {
+        locallyApprovedScopes.push("auvrynt:blender-python");
+    }
+    oauthProvider.grantScopesToExistingTokens(locallyApprovedScopes);
+    if (serenaExecutable)
+        config.serena.executable = serenaExecutable;
+    config.serena.enabled = integrations.serena;
+    serenaManager.updateConfig({
+        ...serenaManager.getConfig(),
+        enabled: integrations.serena,
+        executable: serenaExecutable ?? config.serena.executable,
+    });
+    if (!integrations.serena)
+        await serenaManager.stopAllSessions();
+    let enabledTools = 0;
+    let disabledTools = 0;
+    for (const server of mcpServers) {
+        const result = syncMcpToolAvailability(server, config);
+        enabledTools += result.enabled;
+        disabledTools += result.disabled;
+    }
+    if (enabledTools > 0 || disabledTools > 0) {
+        logEvent(config.logging, "info", "mcp_tool_availability_updated", {
+            enabledTools,
+            disabledTools,
+            serenaEnabled: integrations.serena,
+        });
+    }
+}

package/dist/server/mcp-policy.js

@@ -0,0 +1,169 @@
+const PLAYWRIGHT_TOOL_NAMES = new Set([
+    "capture_page_screenshot",
+    "inspect_page",
+    "test_responsive_page",
+    "browser_open",
+    "browser_close",
+    "browser_list_sessions",
+    "browser_navigate",
+    "browser_reload",
+    "browser_go_back",
+    "browser_go_forward",
+    "browser_snapshot",
+    "browser_click",
+    "browser_type",
+    "browser_select_option",
+    "browser_hover",
+    "browser_press_key",
+    "browser_wait_for",
+    "browser_get_text",
+    "browser_get_attribute",
+    "browser_is_visible",
+    "browser_scroll",
+    "browser_console",
+    "browser_network",
+    "browser_evaluate",
+    "browser_screenshot",
+]);
+const GENERIC_GODOT_TOOL_NAMES = new Set(["detect_godot_project", "inspect_godot_scene"]);
+const GODOT_CSHARP_TOOL_MARKERS = ["dotnet", "csharp", "build_solutions", "generate_vscode_config"];
+const GODOT_GDSCRIPT_ONLY_TOOLS = new Set([
+    "godot_get_global_classes",
+    "godot_add_class_name",
+    "godot_remove_class_name",
+    "godot_get_autoload_usage",
+    "godot_inspect_tool_script",
+    "godot_create_editor_plugin",
+]);
+export function isGodotToolName(name) {
+    return name.startsWith("godot_") || GENERIC_GODOT_TOOL_NAMES.has(name);
+}
+export function godotToolFamily(name) {
+    if (!isGodotToolName(name))
+        return undefined;
+    if (GODOT_CSHARP_TOOL_MARKERS.some((marker) => name.includes(marker)))
+        return "godotCsharp";
+    if (name.includes("gdscript") || GODOT_GDSCRIPT_ONLY_TOOLS.has(name))
+        return "godotGdscript";
+    return "godotShared";
+}
+export function godotToolBelongsToIntegration(name, integration) {
+    const family = godotToolFamily(name);
+    if (!family)
+        return false;
+    return family === integration || family === "godotShared";
+}
+export function requiredScopesForToolName(name) {
+    if (name === "open_workspace")
+        return ["auvrynt:read", "auvrynt:write"];
+    if (name === "aseprite_capture_current")
+        return ["auvrynt:aseprite", "auvrynt:process", "auvrynt:write"];
+    if (name === "aseprite_capture_canvas")
+        return ["auvrynt:aseprite", "auvrynt:write"];
+    if (name === "close_workspace")
+        return ["auvrynt:write", "auvrynt:process"];
+    if (name === "blender_execute_python")
+        return ["auvrynt:blender", "auvrynt:blender-python"];
+    if (name.startsWith("blender_"))
+        return ["auvrynt:blender"];
+    if (name.startsWith("aseprite_"))
+        return ["auvrynt:aseprite"];
+    if (name.startsWith("godot_") || GENERIC_GODOT_TOOL_NAMES.has(name))
+        return ["auvrynt:godot"];
+    if (name.startsWith("serena_"))
+        return ["auvrynt:serena"];
+    if (name.startsWith("roblox_"))
+        return ["auvrynt:roblox"];
+    if (name.startsWith("context7_"))
+        return ["auvrynt:read"];
+    if (name === "agent_reach_doctor")
+        return ["auvrynt:process"];
+    if (name.startsWith("agent_reach_"))
+        return ["auvrynt:read"];
+    if (name === "obsidian_write_note")
+        return ["auvrynt:write"];
+    if (name.startsWith("obsidian_"))
+        return ["auvrynt:read"];
+    if (name === "start_dev_server")
+        return ["auvrynt:web", "auvrynt:process"];
+    if (name === "capture_page_screenshot"
+        || name === "test_responsive_page"
+        || name === "browser_screenshot")
+        return ["auvrynt:web", "auvrynt:write"];
+    if (name === "inspect_page"
+        || name.startsWith("browser_"))
+        return ["auvrynt:web"];
+    if (name === "capture_window")
+        return ["auvrynt:process", "auvrynt:write"];
+    if (name === "split_sprite_sheet")
+        return ["auvrynt:write"];
+    if (name === "inspect_dotnet_project")
+        return ["auvrynt:software"];
+    if (["dotnet_restore", "dotnet_build", "dotnet_test", "dotnet_run", "dotnet_format"].includes(name)) {
+        return ["auvrynt:software", "auvrynt:process"];
+    }
+    if (["start_process", "get_process_logs", "list_processes", "stop_process", "run_shell", "bash"].includes(name)) {
+        return ["auvrynt:process"];
+    }
+    if (["write", "write_file", "edit", "edit_file"].includes(name))
+        return ["auvrynt:write"];
+    return ["auvrynt:read"];
+}
+export function requiredScopesForToolCall(name, input) {
+    const required = new Set(requiredScopesForToolName(name));
+    if (name === "open_workspace" && input && typeof input === "object") {
+        if (input.mode === "worktree")
+            required.add("auvrynt:process");
+    }
+    if (name === "compare_images" && input && typeof input === "object" && "diffOutputPath" in input) {
+        if (typeof input.diffOutputPath === "string")
+            required.add("auvrynt:write");
+    }
+    if (name === "dotnet_format" && input && typeof input === "object") {
+        if (input.verifyOnly !== true)
+            required.add("auvrynt:write");
+    }
+    if (name === "aseprite_recovery" && input && typeof input === "object") {
+        const action = input.action;
+        if (action === "open_recovery_ui")
+            required.add("auvrynt:process");
+        if (action === "archive")
+            required.add("auvrynt:write");
+    }
+    return Array.from(required);
+}
+export function hasRequiredScopes(scopes, required) {
+    const available = scopes instanceof Set ? scopes : new Set(scopes);
+    return required.every((scope) => available.has(scope));
+}
+function godotIntegrationEnabled(config, toolName) {
+    const family = godotToolFamily(toolName);
+    if (family === "godotCsharp")
+        return config.integrations.godotCsharp;
+    if (family === "godotGdscript")
+        return config.integrations.godotGdscript;
+    return config.integrations.godotGdscript || config.integrations.godotCsharp;
+}
+export function toolIntegrationEnabled(config, name) {
+    if (config.toolToggles?.[name] === false)
+        return false;
+    if (name.startsWith("blender_"))
+        return config.integrations.blender;
+    if (name.startsWith("aseprite_"))
+        return config.integrations.aseprite;
+    if (isGodotToolName(name))
+        return godotIntegrationEnabled(config, name);
+    if (PLAYWRIGHT_TOOL_NAMES.has(name))
+        return config.integrations.playwright;
+    if (name.startsWith("agent_reach_"))
+        return true;
+    if (name.startsWith("serena_"))
+        return config.integrations.serena && config.serena.enabled;
+    if (name.startsWith("context7_"))
+        return config.integrations.context7;
+    if (name.startsWith("obsidian_"))
+        return config.integrations.obsidian;
+    if (name.startsWith("roblox_"))
+        return config.integrations.roblox;
+    return true;
+}

package/dist/server/mcp-server-factory.js

@@ -0,0 +1,127 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { registerAppResource, RESOURCE_MIME_TYPE, } from "@modelcontextprotocol/ext-apps/server";
+import { registerSerenaTools } from "../serena-tools.js";
+import { updateToolScopes } from "../tool-capabilities.js";
+import { configureMcpToolGuard } from "./mcp-tool-registrar.js";
+import { WORKSPACE_APP_URI } from "./tool-registration-shared.js";
+import { appCsp, assertWorkspaceAppAssets, packageVersion, workspaceAppHtml, } from "./ui-assets.js";
+import { logFailedToolResponse, logToolCall } from "./tool-logging.js";
+import { registerWorkspaceLifecycleTools } from "./tools/workspace-lifecycle-tools-registration.js";
+import { registerCoreFileTools } from "./tools/core-file-tools-registration.js";
+import { registerProcessProjectTools } from "./tools/process-project-tools-registration.js";
+import { registerWebImageTools } from "./tools/web-image-tools-registration.js";
+import { registerDotnetGodotWindowTools } from "./tools/dotnet-godot-window-tools-registration.js";
+import { registerGodotCsharpTools } from "./tools/godot-csharp-tools-registration.js";
+import { registerGodotGdscriptTools } from "./tools/godot-gdscript-tools-registration.js";
+import { registerBlenderTools } from "./tools/blender-tools-registration.js";
+import { registerAsepriteTools } from "./tools/aseprite-tools-registration.js";
+import { registerContext7Tools } from "../integrations/context7/context7-tools.js";
+import { registerObsidianTools } from "../integrations/obsidian/obsidian-tools.js";
+import { registerAgentReachTools } from "../integrations/agent-reach/agent-reach-tools.js";
+import { registerRobloxTools } from "./tools/roblox-tools-registration.js";
+export function createMcpServer(config, workspaces, reviewCheckpoints, serenaManager, processManager, roomRegistry, sessionRegistry, workspaceChanges) {
+    const toolNames = toolNamesFor(config);
+    const server = new McpServer({
+        name: "auvrynt",
+        title: "Auvrynt",
+        version: packageVersion(),
+        description: "Secure local coding workspace for MCP clients. Provides workspace-scoped file, search, edit, write, and shell tools.",
+    }, { instructions: serverInstructions(config, toolNames) });
+    configureMcpToolGuard(server, { config, workspaces, rooms: roomRegistry });
+    const widgetCsp = appCsp(config);
+    const widgetMeta = {
+        ui: {
+            csp: widgetCsp,
+            prefersBorder: false,
+        },
+        "openai/widgetDescription": "Compact Auvrynt tool result card showing the action, target path, result count, and expandable output.",
+        "openai/widgetPrefersBorder": false,
+        "openai/widgetCSP": {
+            connect_domains: widgetCsp.connectDomains,
+            resource_domains: widgetCsp.resourceDomains,
+        },
+    };
+    registerAppResource(server, "Auvrynt Tool Card", WORKSPACE_APP_URI, {
+        description: "Interactive Auvrynt card for workspace tool results.",
+        _meta: widgetMeta,
+    }, async () => {
+        await assertWorkspaceAppAssets();
+        return {
+            contents: [
+                {
+                    uri: WORKSPACE_APP_URI,
+                    mimeType: RESOURCE_MIME_TYPE,
+                    text: workspaceAppHtml(config),
+                    _meta: widgetMeta,
+                },
+            ],
+        };
+    });
+    registerWorkspaceLifecycleTools(server, config, workspaces, reviewCheckpoints, processManager, roomRegistry, sessionRegistry, workspaceChanges, logToolCall);
+    registerCoreFileTools(server, config, workspaces, reviewCheckpoints, toolNames, workspaceChanges, logToolCall, logFailedToolResponse);
+    registerProcessProjectTools(server, config, workspaces, processManager, logToolCall);
+    registerWebImageTools(server, config, workspaces, processManager);
+    registerDotnetGodotWindowTools(server, config, workspaces, processManager);
+    registerGodotCsharpTools(server, config, workspaces, processManager);
+    registerGodotGdscriptTools(server, config, workspaces);
+    registerBlenderTools(server, config, workspaces);
+    registerAsepriteTools(server, config, workspaces, processManager);
+    registerRobloxTools(server, config);
+    if (config.oauth.scopes.includes("auvrynt:serena")) {
+        registerSerenaTools(server, config, serenaManager, workspaces);
+        registerContext7Tools(server);
+        registerObsidianTools(server, config);
+        registerAgentReachTools(server);
+    }
+    updateToolScopes();
+    return server;
+}
+function toolNamesFor(config) {
+    return config.toolNaming === "short"
+        ? {
+            openWorkspace: "open_workspace",
+            read: "read",
+            write: "write",
+            edit: "edit",
+            grep: "grep",
+            glob: "glob",
+            ls: "ls",
+            shell: "bash",
+        }
+        : {
+            openWorkspace: "open_workspace",
+            read: "read_file",
+            write: "write_file",
+            edit: "edit_file",
+            grep: "grep_files",
+            glob: "find_files",
+            ls: "list_directory",
+            shell: "run_shell",
+        };
+}
+function serverInstructions(config, toolNames) {
+    const inspection = config.minimalTools
+        ? `In minimal tool mode, ${toolNames.grep}, ${toolNames.glob}, and ${toolNames.ls} are disabled; use ${toolNames.shell} with command-line tools such as grep, rg, find, ls, and tree for search and directory inspection. `
+        : `Prefer ${toolNames.read}, ${toolNames.grep}, ${toolNames.glob}, and ${toolNames.ls} for file inspection. `;
+    const skills = config.skillsEnabled
+        ? `When ${toolNames.openWorkspace} returns available skills and a task matches a skill, use ${toolNames.read} to read that skill's path before proceeding. Skill paths may be outside the workspace, but ${toolNames.read} only permits advertised SKILL.md files and files under already-loaded skill directories. `
+        : "";
+    const agentsMd = `Follow instructions returned by ${toolNames.openWorkspace}. Before working under a path listed in availableAgentsFiles, use ${toolNames.read} to inspect that instruction file and follow it. `;
+    const viewImageInstruction = `Use view_image when asked to inspect, describe, analyze, or compare a local image. Call ${toolNames.openWorkspace} first, pass the returned workspaceId, and use a workspace-relative path. Do not use ${toolNames.read} for binary image files. `;
+    const showChanges = config.widgets === "changes"
+        ? " After creating, editing, or overwriting files, call show_changes once after the related file changes are complete so the user can see the aggregate diff."
+        : "";
+    const devTools = `
+Process management: Use start_process for long-running servers, apps, and games that must stay running. Use get_process_logs to tail output. Use stop_process when done. Do not use ${toolNames.shell} for commands that block indefinitely.
+Web development: Use start_dev_server to launch a dev server (auto-detects npm run dev), capture_page_screenshot to capture pages with Playwright, inspect_page for structured DOM/accessibility info, test_responsive_page for multi-viewport testing. Requires Playwright; see docs/DEVELOPMENT_TOOLS.md.
+Generated artifacts: Screenshots, image diffs, sprite frames, application captures, Godot exports, Blender exports, and Blender checkpoints are stored under the workspace's auvrynt-logs directory. Output path arguments are organized into tool-specific subdirectories there. Ordinary source-file edits and generated project source code remain at their requested project paths.
+Project discovery: Use inspect_project to detect project type, package manager, and recommended commands. Use glob_files and search_text for structured file search across the workspace.
+Image tools: Use inspect_image for dimensions/format/palette. Use compare_images for pixel-level diff. Use inspect_sprite and split_sprite_sheet for sprite sheets. Do not use view_image for analysis—use inspect_image.
+.NET tools: Use inspect_dotnet_project to read project structure, dotnet_restore/dotnet_build/dotnet_test for CLI operations, dotnet_run to start a .NET app as a persistent process, dotnet_format for formatting.
+Godot tools: Use detect_godot_project when a workspace contains project.godot. Use godot_run to start the game or editor as a persistent process. Use inspect_godot_scene to read .tscn scene trees. Configure the Godot executable via GODOT_EXECUTABLE environment variable.
+Roblox Studio tools: Use roblox_status then roblox_list_tools / roblox_call (or roblox_* aliases) to proxy the official Studio MCP (Enable Studio as MCP server). Requires auvrynt start roblox and an open Studio session.
+Aseprite tools: Use aseprite_detect to verify the configured source build, aseprite_inspect_file for layers/frames/tags, aseprite_set_pixels or aseprite_draw_shapes for exact pixel edits, and the export/convert tools for workspace-bound outputs. Aseprite files and output paths must stay inside the open workspace.
+Window capture: Use capture_window to screenshot a running application tracked by Auvrynt. Use godot_capture_game specifically for Godot game processes.
+Security: All paths must be workspace-relative. Never access files outside the opened workspace. Do not claim a screenshot or comparison succeeded unless the tool returned successfully.`;
+    return `Use Auvrynt as a local coding workspace. Call ${toolNames.openWorkspace} once per project folder or worktree to obtain a workspaceId. Reuse that same workspaceId for all later file, search, edit, write, show-changes, view-image, and shell tools in that folder; do not call ${toolNames.openWorkspace} again unless switching folders/worktrees, changing checkout/worktree mode, the workspaceId is rejected as unknown, or the user explicitly asks to reopen. ${agentsMd}${skills}${inspection}${viewImageInstruction}Prefer ${toolNames.edit} for targeted source-file modifications and ${toolNames.write} only for new files or complete rewrites. Use ${toolNames.shell} for tests, builds, git inspection, package scripts, and commands that genuinely require a shell. The shell/process tools execute with the local user's privileges and are not a filesystem sandbox; only invoke them when the granted auvrynt:process scope and requested task justify local command execution.${showChanges}${devTools}`;
+}