auvrynt 1.0.2 → 1.0.5

package/dist/server/mcp-tool-registrar.js

@@ -0,0 +1,182 @@
+import { registerAppTool as registerExtAppTool } from "@modelcontextprotocol/ext-apps/server";
+import { assertBlenderWorkspaceBound } from "../blender-tools.js";
+import { getRequestContext, runWithContext } from "../request-context.js";
+import { enqueueIntegration } from "../integration-queue.js";
+import { registerToolCapability } from "../tool-capabilities.js";
+import { limitToolResultPayload } from "../tool-result-budget.js";
+import { godotToolBelongsToIntegration, godotToolFamily, hasRequiredScopes, isGodotToolName, requiredScopesForToolCall, requiredScopesForToolName, toolIntegrationEnabled, } from "./mcp-policy.js";
+const guards = new WeakMap();
+const registeredTools = new WeakMap();
+const toolInventory = new Map();
+const BLENDER_UNBOUND_TOOL_NAMES = new Set([
+    "blender_ping",
+    "blender_get_current_file",
+    "blender_open_file",
+    "blender_save_file_as",
+    "blender_list_checkpoints",
+]);
+export function integrationKeyForTool(name) {
+    if (name.startsWith("blender_"))
+        return "blender";
+    if (name.startsWith("aseprite_"))
+        return "aseprite";
+    const godotFamily = godotToolFamily(name);
+    if (godotFamily)
+        return godotFamily;
+    if (name.startsWith("serena_"))
+        return "serena";
+    if (name.startsWith("context7_"))
+        return "context7";
+    if (name.startsWith("obsidian_"))
+        return "obsidian";
+    if (name.startsWith("roblox_"))
+        return "roblox";
+    if (name.startsWith("browser_")
+        || ["capture_page_screenshot", "inspect_page", "test_responsive_page"].includes(name))
+        return "playwright";
+    return "core";
+}
+function inventoryKeysForDashboardIntegration(integration) {
+    if (integration === "godotCsharp")
+        return ["godotCsharp", "godotShared", "godot"];
+    if (integration === "godotGdscript")
+        return ["godotGdscript", "godotShared", "godot"];
+    return [integration];
+}
+export function registeredToolNamesForIntegration(integration) {
+    const keys = new Set(inventoryKeysForDashboardIntegration(integration));
+    return Array.from(toolInventory.entries())
+        .filter(([name, key]) => {
+        if (!keys.has(key))
+            return false;
+        if (integration === "godotCsharp" || integration === "godotGdscript") {
+            return godotToolBelongsToIntegration(name, integration) || key === integration;
+        }
+        return true;
+    })
+        .map(([name]) => name);
+}
+export function toolInventoryEnabledCount(integration, config) {
+    return registeredToolNamesForIntegration(integration)
+        .filter((name) => toolIntegrationEnabled(config, name)).length;
+}
+function bumpCount(counts, key, enabled) {
+    const entry = counts[key] ?? { total: 0, enabled: 0 };
+    entry.total += 1;
+    if (enabled)
+        entry.enabled += 1;
+    counts[key] = entry;
+}
+export function integrationToolCounts(config) {
+    const counts = {};
+    for (const [name, key] of toolInventory) {
+        const enabled = toolIntegrationEnabled(config, name);
+        if (key === "godotShared" || key === "godot" || isGodotToolName(name)) {
+            const family = godotToolFamily(name) ?? key;
+            if (family === "godotCsharp")
+                bumpCount(counts, "godotCsharp", enabled);
+            else if (family === "godotGdscript")
+                bumpCount(counts, "godotGdscript", enabled);
+            else {
+                bumpCount(counts, "godotCsharp", enabled);
+                bumpCount(counts, "godotGdscript", enabled);
+            }
+            continue;
+        }
+        bumpCount(counts, key, enabled);
+    }
+    return counts;
+}
+export function configureMcpToolGuard(server, context) {
+    guards.set(server, context);
+    if (!registeredTools.has(server))
+        registeredTools.set(server, new Map());
+}
+export function syncMcpToolAvailability(server, config) {
+    const tools = registeredTools.get(server);
+    if (!tools)
+        return { enabled: 0, disabled: 0 };
+    let enabled = 0;
+    let disabled = 0;
+    for (const [name, tool] of tools) {
+        const shouldEnable = toolIntegrationEnabled(config, name);
+        if (shouldEnable && !tool.enabled) {
+            tool.enable();
+            enabled++;
+        }
+        else if (!shouldEnable && tool.enabled) {
+            tool.disable();
+            disabled++;
+        }
+    }
+    return { enabled, disabled };
+}
+export const registerAppTool = ((server, name, toolConfig, handler) => {
+    registerToolCapability(name);
+    const guard = guards.get(server);
+    const requiredScopes = requiredScopesForToolName(name);
+    if (guard && !hasRequiredScopes(guard.config.oauth.scopes, requiredScopes))
+        return undefined;
+    const guardedHandler = async (...args) => {
+        const input = args[0];
+        const extra = args.at(-1);
+        const requestContext = getRequestContext();
+        const ownerClientId = requestContext?.ownerClientId ?? extra?.authInfo?.clientId;
+        const callScopes = requiredScopesForToolCall(name, input);
+        if (guard && !toolIntegrationEnabled(guard.config, name)) {
+            throw new Error(`Forbidden: ${name} integration is disabled by the local profile`);
+        }
+        if (!extra?.authInfo?.scopes || !hasRequiredScopes(extra.authInfo.scopes, callScopes)) {
+            throw new Error(`Forbidden: ${name} requires ${callScopes.join(" + ")}`);
+        }
+        let workspaceId;
+        if (guard && input && typeof input === "object" && "workspaceId" in input) {
+            const candidate = input.workspaceId;
+            if (typeof candidate === "string") {
+                if (!ownerClientId)
+                    throw new Error("Forbidden: workspace access requires an authenticated OAuth client");
+                guard.rooms.requireWorkspaceAccess(ownerClientId, candidate);
+                guard.workspaces.getWorkspace(candidate);
+                workspaceId = candidate;
+                if (name.startsWith("blender_") && !BLENDER_UNBOUND_TOOL_NAMES.has(name)) {
+                    await assertBlenderWorkspaceBound(guard.workspaces, candidate);
+                }
+            }
+        }
+        const invokeHandler = async () => limitToolResultPayload(await Reflect.apply(handler, undefined, args));
+        const invokeByIntegration = () => {
+            if (name.startsWith("blender_"))
+                return enqueueIntegration("blender", invokeHandler);
+            if (name.startsWith("aseprite_"))
+                return enqueueIntegration("aseprite", invokeHandler);
+            if (name.startsWith("godot_"))
+                return enqueueIntegration("godot", invokeHandler);
+            if (name.startsWith("serena_"))
+                return enqueueIntegration("serena", invokeHandler);
+            if (name.startsWith("roblox_"))
+                return enqueueIntegration("roblox", invokeHandler);
+            return invokeHandler();
+        };
+        if (requestContext && workspaceId) {
+            const room = guard?.rooms.requireWorkspaceAccess(requestContext.ownerClientId, workspaceId);
+            return runWithContext({
+                ...requestContext,
+                workspaceId,
+                roomId: room?.roomId,
+            }, invokeByIntegration);
+        }
+        return invokeByIntegration();
+    };
+    const registered = Reflect.apply(registerExtAppTool, undefined, [server, name, toolConfig, guardedHandler]);
+    if (!registered)
+        return undefined;
+    if (!toolInventory.has(name))
+        toolInventory.set(name, integrationKeyForTool(name));
+    const tools = registeredTools.get(server) ?? new Map();
+    tools.set(name, registered);
+    registeredTools.set(server, tools);
+    if (guard && !toolIntegrationEnabled(guard.config, name)) {
+        registered.disable();
+    }
+    return registered;
+});

package/dist/server/openai-session-hint.js

@@ -0,0 +1,14 @@
+export function openAiLogicalSessionId(messages) {
+    for (const message of messages) {
+        if (!message || typeof message !== "object")
+            continue;
+        const rpc = message;
+        const value = rpc.params?._meta?.["openai/session"] ?? rpc._meta?.["openai/session"];
+        if (typeof value !== "string")
+            continue;
+        const normalized = value.trim();
+        if (normalized && normalized.length <= 256)
+            return normalized;
+    }
+    return undefined;
+}

package/dist/server/tool-groups.js

@@ -0,0 +1,29 @@
+const GROUP_KEYWORDS = [
+    { group: "Model", keywords: ["create_", "add_", "primitive", "cube", "sphere", "cylinder", "cone", "plane", "circle", "torus", "grid", "monkey", "curve", "text", "empty", "metaball", "mesh", "extrude", "bevel", "loop", "subdivide", "merge", "knife", "dissolve", "inset", "triangulate", "smooth", "shade", "edge", "face", "vertex", "modifier", "boolean", "solidify", "array", "mirror_modifier", "skin", "lattice", "geometry_nodes", "convex_hull", "decimate", "remesh"] },
+    { group: "Animation", keywords: ["animation", "keyframe", "key_frame", "armature", "bone", "rig", "action", "timeline", "play", "frame", "pose", "bone_constraint", "driver", "fcurve", "shape_key", "shapekey", "lattice_animate"] },
+    { group: "Materials & Shading", keywords: ["material", "shader", "shading", "texture", "node", "bsdf", "principled", "uv", "lightmap", "image_texture", "color_ramp", "mix"] },
+    { group: "Geometry Nodes", keywords: ["geometry_nodes", "gn_", "geo_node", "node_group"] },
+    { group: "Viewport & Camera", keywords: ["viewport", "camera", "view", "orbit", "pan", "zoom", "frame_selected", "frame_all", "shading_mode", "xray", "overlay", "local_view", "look", "pov"] },
+    { group: "Scene & File", keywords: ["scene", "file", "open", "save", "checkpoint", "collection", "layer", "world", "current_file"] },
+    { group: "Selection", keywords: ["select", "deselect", "invert", "select_all"] },
+    { group: "Rendering", keywords: ["render", "cycles", "eevee", "resolution", "output", "image", "compositor"] },
+    { group: "Export & Import", keywords: ["export", "import", "glb", "fbx", "obj", "stl", "ply", "usd", "dae", "alembic"] },
+    { group: "Utilities", keywords: ["ping", "inspect", "audit", "console", "status", "execute", "python", "purge", "cleanup", "recovery", "context", "info", "list", "get_", "set_"] },
+];
+export function groupForTool(name) {
+    for (const { group, keywords } of GROUP_KEYWORDS) {
+        if (keywords.some((keyword) => name.includes(keyword)))
+            return group;
+    }
+    return "Other";
+}
+export function groupToolsByName(names) {
+    const groups = new Map();
+    for (const name of names) {
+        const group = groupForTool(name);
+        const list = groups.get(group) ?? [];
+        list.push(name);
+        groups.set(group, list);
+    }
+    return groups;
+}

package/dist/server/tool-logging.js

@@ -0,0 +1,33 @@
+import { commandPreview, logEvent } from "../logger.js";
+import { redactProcessText } from "../processes.js";
+export function logToolCall(config, fields) {
+    if (!config.logging.toolCalls)
+        return;
+    const { command, ...safeFields } = fields;
+    logEvent(config.logging, fields.success ? "info" : "warn", "tool_call", {
+        ...safeFields,
+        commandPreview: config.logging.shellCommands && command
+            ? commandPreview(redactProcessText(command))
+            : undefined,
+    });
+}
+export function logFailedToolResponse(config, fields, content, startedAt) {
+    logToolCall(config, {
+        ...fields,
+        success: false,
+        durationMs: Math.round(performance.now() - startedAt),
+        error: toolErrorPreview(content),
+    });
+}
+function toolErrorPreview(content) {
+    const text = redactProcessText(contentText(content)).replace(/\s+/g, " ").trim();
+    if (!text)
+        return undefined;
+    return text.length > 240 ? `${text.slice(0, 237)}...` : text;
+}
+function contentText(content) {
+    return content
+        .filter((item) => item.type === "text")
+        .map((item) => item.text)
+        .join("\n");
+}

package/dist/server/tool-registration-shared.js

@@ -0,0 +1,59 @@
+import * as z from "zod/v4";
+export const WORKSPACE_ID_SCHEMA = z.string().describe("Workspace identifier returned by open_workspace.");
+export const VIEW_IMAGE_TOOL_ANNOTATIONS = {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+};
+export const READ_ONLY_ANNOTATIONS = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+export const PROCESS_ANNOTATIONS = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
+export const MUTATING_ANNOTATIONS = { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false };
+export const WEB_READ_ANNOTATIONS = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true };
+export const WEB_WRITE_ANNOTATIONS = { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true };
+export const WRITE_TOOL_ANNOTATIONS = MUTATING_ANNOTATIONS;
+export const EDIT_TOOL_ANNOTATIONS = MUTATING_ANNOTATIONS;
+export const SHELL_TOOL_ANNOTATIONS = { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true };
+export const WORKSPACE_APP_URI = "ui://auvrynt/workspace-app-v3.html";
+function shouldAttachWidget(mode, kind) {
+    switch (mode) {
+        case "off":
+            return false;
+        case "changes":
+            return kind === "workspace" || kind === "show_changes";
+        case "full":
+            return true;
+    }
+}
+const TOOL_INVOCATION_COPY = {
+    workspace: { invoking: "Opening workspace…", invoked: "Workspace ready" },
+    read: { invoking: "Reading…", invoked: "Read complete" },
+    write: { invoking: "Writing…", invoked: "Write complete" },
+    edit: { invoking: "Applying edit…", invoked: "Edit applied" },
+    search: { invoking: "Searching…", invoked: "Search complete" },
+    directory: { invoking: "Listing files…", invoked: "Files ready" },
+    shell: { invoking: "Running command…", invoked: "Command complete" },
+    show_changes: { invoking: "Reviewing changes…", invoked: "Changes ready" },
+};
+export function toolWidgetDescriptorMeta(config, kind) {
+    if (!shouldAttachWidget(config.widgets, kind))
+        return { _meta: {} };
+    const invocation = TOOL_INVOCATION_COPY[kind];
+    return {
+        _meta: {
+            ui: {
+                resourceUri: WORKSPACE_APP_URI,
+                visibility: ["model", "app"],
+            },
+            "openai/outputTemplate": WORKSPACE_APP_URI,
+            "openai/toolInvocation/invoking": invocation.invoking,
+            "openai/toolInvocation/invoked": invocation.invoked,
+        },
+    };
+}
+export function resultOutputSchema(extra = {}) {
+    return {
+        result: z.string().describe("Model-readable result text for follow-up reasoning and plain MCP hosts."),
+        ...extra,
+    };
+}