auvrynt 1.0.2 → 1.0.5

package/dist/infrastructure/tool-capabilities.js

@@ -0,0 +1,67 @@
+import { requiredScopesForToolName } from "../server/mcp-policy.js";
+export function toolAccessForName(name) {
+    if (name.startsWith("blender_"))
+        return "write";
+    if (name.startsWith("godot_"))
+        return "write";
+    if (name.startsWith("serena_"))
+        return "write";
+    if (name === "start_process" || name === "stop_process" || name === "bash" || name === "run_shell")
+        return "process";
+    if (name.startsWith("dotnet_") && (name.includes("build") || name.includes("test") || name.includes("run") || name.includes("restore") || name.includes("format")))
+        return "process";
+    if (name === "start_dev_server")
+        return "web-write";
+    if (name === "capture_page_screenshot" || name === "test_responsive_page")
+        return "web-write";
+    if (name === "inspect_page")
+        return "web-read";
+    if (name === "agent_reach_doctor")
+        return "process";
+    if (name.startsWith("agent_reach_"))
+        return "read";
+    if (["write", "write_file", "edit", "edit_file", "split_sprite_sheet", "capture_window", "compare_images"].includes(name))
+        return "write";
+    if (name === "open_workspace" || name === "close_workspace")
+        return "write";
+    if (name === "start_blender" || name === "get_connection_status" || name === "get_process_logs" || name === "list_processes" || name === "inspect_dotnet_project")
+        return "read";
+    return "read";
+}
+export function integrationForTool(name) {
+    if (name.startsWith("blender_"))
+        return "blender";
+    if (name.startsWith("godot_"))
+        return "godot";
+    if (name.startsWith("serena_"))
+        return "serena";
+    if (name === "capture_page_screenshot" || name === "inspect_page" || name === "test_responsive_page")
+        return "playwright";
+    if (name.startsWith("agent_reach_"))
+        return "agent-reach";
+    return undefined;
+}
+export const TOOL_CAPABILITIES = new Map();
+export function registerToolCapability(name) {
+    if (TOOL_CAPABILITIES.has(name))
+        return;
+    const caps = {
+        name,
+        access: toolAccessForName(name),
+        scopes: [], // populated dynamically
+        integration: integrationForTool(name),
+        requiresWorkspace: name !== "open_workspace",
+    };
+    TOOL_CAPABILITIES.set(name, caps);
+}
+export function updateToolScopes() {
+    for (const [name, caps] of TOOL_CAPABILITIES) {
+        caps.scopes = requiredScopesForName(name);
+    }
+}
+function requiredScopesForName(name) {
+    const scopes = requiredScopesForToolName(name);
+    return name === "open_workspace"
+        ? Array.from(new Set([...scopes, "auvrynt:process"]))
+        : scopes;
+}

package/dist/infrastructure/tool-result-budget.js

@@ -0,0 +1,175 @@
+const KIB = 1024;
+const MIB = 1024 * KIB;
+export const MAX_TOOL_RESULT_CONTENT_BYTES = 1 * MIB;
+export const MAX_TOOL_RESULT_META_BYTES = 512 * KIB;
+export const MAX_TOOL_RESULT_STRUCTURED_BYTES = 512 * KIB;
+export const MAX_INLINE_BINARY_BYTES = 512 * KIB;
+export const MAX_JSON_STRING_BYTES = 256 * KIB;
+const TRUNCATION_NOTICE = "[Auvrynt truncated this tool result to keep the MCP connection stable. Request a narrower range, fewer items, or a smaller image.]";
+export function inlineImageOrNotice(buffer, label, mimeType) {
+    if (buffer.length <= MAX_INLINE_BINARY_BYTES) {
+        return [{ type: "image", data: buffer.toString("base64"), mimeType }];
+    }
+    return [{
+            type: "text",
+            text: `${label} was saved or inspected, but its ${buffer.length}-byte image was not embedded because it exceeded the stable MCP inline-image limit.`,
+        }];
+}
+export function limitToolResultPayload(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return value;
+    const result = value;
+    const contentBudget = { remaining: MAX_TOOL_RESULT_CONTENT_BYTES, truncated: false };
+    const metaBudget = { remaining: MAX_TOOL_RESULT_META_BYTES, truncated: false };
+    const structuredBudget = { remaining: MAX_TOOL_RESULT_STRUCTURED_BYTES, truncated: false };
+    const content = limitPrimaryContent(result.content, contentBudget);
+    const meta = compactJsonValue(result._meta, metaBudget, "_meta", 0, false);
+    const structuredContent = compactJsonValue(result.structuredContent, structuredBudget, "structuredContent", 0, true);
+    const truncated = contentBudget.truncated || metaBudget.truncated || structuredBudget.truncated;
+    if (!truncated)
+        return value;
+    const next = {
+        ...result,
+        content,
+        _meta: meta,
+        structuredContent,
+    };
+    const contentItems = Array.isArray(next.content) ? [...next.content] : [];
+    if (!contentItems.some((item) => isTextNotice(item))) {
+        contentItems.push({ type: "text", text: TRUNCATION_NOTICE });
+    }
+    next.content = contentItems;
+    return next;
+}
+function limitPrimaryContent(value, budget) {
+    if (!Array.isArray(value))
+        return value;
+    const limited = [];
+    for (const item of value) {
+        if (!item || typeof item !== "object" || Array.isArray(item)) {
+            limited.push(compactJsonValue(item, budget, "content", 0, false));
+            continue;
+        }
+        const block = item;
+        if (block.type === "text" && typeof block.text === "string") {
+            limited.push({ ...block, text: consumeString(block.text, budget, MAX_JSON_STRING_BYTES) });
+            continue;
+        }
+        if ((block.type === "image" || block.type === "audio") && typeof block.data === "string") {
+            const estimatedBinaryBytes = base64DecodedBytes(block.data);
+            const serializedBytes = Buffer.byteLength(block.data, "utf8");
+            if (estimatedBinaryBytes > MAX_INLINE_BINARY_BYTES || serializedBytes > budget.remaining) {
+                budget.truncated = true;
+                limited.push({
+                    type: "text",
+                    text: `[Inline ${String(block.type)} omitted: ${estimatedBinaryBytes} bytes exceeded the stable MCP payload limit.]`,
+                });
+                continue;
+            }
+            budget.remaining -= serializedBytes;
+            limited.push({ ...block });
+            continue;
+        }
+        limited.push(compactJsonValue(block, budget, "content", 0, false));
+    }
+    return limited;
+}
+function compactJsonValue(value, budget, key, depth, preserveShape) {
+    if (value === undefined || value === null || typeof value === "boolean" || typeof value === "number") {
+        return value;
+    }
+    if (typeof value === "string") {
+        if ((key === "data" || key === "blob") && base64DecodedBytes(value) > MAX_INLINE_BINARY_BYTES) {
+            budget.truncated = true;
+            return `[omitted binary payload: ${base64DecodedBytes(value)} bytes]`;
+        }
+        return consumeString(value, budget, MAX_JSON_STRING_BYTES);
+    }
+    if (depth >= 12) {
+        budget.truncated = true;
+        return preserveShape
+            ? schemaSafePlaceholder(value, depth)
+            : "[truncated: maximum nesting depth reached]";
+    }
+    if (Array.isArray(value)) {
+        const result = [];
+        for (let index = 0; index < value.length; index++) {
+            if (budget.remaining <= 0) {
+                budget.truncated = true;
+                if (!preserveShape)
+                    result.push(`[truncated ${value.length - index} remaining items]`);
+                break;
+            }
+            result.push(compactJsonValue(value[index], budget, String(index), depth + 1, preserveShape));
+        }
+        return result;
+    }
+    if (typeof value === "object") {
+        const result = {};
+        for (const [childKey, childValue] of Object.entries(value)) {
+            if (budget.remaining <= 0) {
+                budget.truncated = true;
+                if (preserveShape) {
+                    result[childKey] = schemaSafePlaceholder(childValue, depth + 1);
+                    continue;
+                }
+                result.__auvryntTruncated = true;
+                break;
+            }
+            budget.remaining -= Buffer.byteLength(childKey, "utf8") + 4;
+            result[childKey] = compactJsonValue(childValue, budget, childKey, depth + 1, preserveShape);
+        }
+        return result;
+    }
+    return String(value);
+}
+function schemaSafePlaceholder(value, depth) {
+    if (value === null || value === undefined || typeof value === "boolean" || typeof value === "number") {
+        return value;
+    }
+    if (typeof value === "string")
+        return "[truncated]";
+    if (Array.isArray(value))
+        return [];
+    if (typeof value === "object") {
+        if (depth >= 16)
+            return {};
+        return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, schemaSafePlaceholder(child, depth + 1)]));
+    }
+    return String(value);
+}
+function consumeString(value, budget, fieldLimit) {
+    const available = Math.max(0, Math.min(fieldLimit, budget.remaining));
+    const byteLength = Buffer.byteLength(value, "utf8");
+    if (byteLength <= available) {
+        budget.remaining -= byteLength;
+        return value;
+    }
+    budget.truncated = true;
+    if (available <= 0)
+        return "[truncated]";
+    const suffix = "\n… [truncated]";
+    const suffixBytes = Buffer.byteLength(suffix, "utf8");
+    const prefixBudget = Math.max(0, available - suffixBytes);
+    const prefix = truncateUtf8(value, prefixBudget);
+    budget.remaining = Math.max(0, budget.remaining - Buffer.byteLength(prefix, "utf8") - suffixBytes);
+    return `${prefix}${suffix}`;
+}
+function truncateUtf8(value, maxBytes) {
+    if (maxBytes <= 0)
+        return "";
+    let output = Buffer.from(value, "utf8").subarray(0, maxBytes).toString("utf8");
+    while (output.endsWith("�"))
+        output = output.slice(0, -1);
+    return output;
+}
+function base64DecodedBytes(data) {
+    const padding = data.endsWith("==") ? 2 : data.endsWith("=") ? 1 : 0;
+    return Math.max(0, Math.floor((data.length * 3) / 4) - padding);
+}
+function isTextNotice(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const block = value;
+    return block.type === "text" && block.text === TRUNCATION_NOTICE;
+}

package/dist/infrastructure/user-config.js

@@ -0,0 +1,167 @@
+import { randomBytes } from "node:crypto";
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync, } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, join, resolve } from "node:path";
+import * as z from "zod/v4";
+import { expandHomePath } from "../roots.js";
+const executablesSchema = z.object({
+    serena: z.string().optional(),
+    godot: z.string().optional(),
+    godotCsharp: z.string().optional(),
+    blender: z.string().optional(),
+    aseprite: z.string().optional(),
+    asepriteSource: z.string().optional(),
+}).catchall(z.string());
+const integrationsSchema = z.object({
+    godotGdscript: z.boolean().optional(),
+    godotCsharp: z.boolean().optional(),
+    blender: z.boolean().optional(),
+    aseprite: z.boolean().optional(),
+    serena: z.boolean().optional(),
+    playwright: z.boolean().optional(),
+    context7: z.boolean().optional(),
+    obsidian: z.boolean().optional(),
+    roblox: z.boolean().optional(),
+}).strict();
+const positiveInteger = z.number().int().positive();
+const obsidianSchema = z.object({
+    enabled: z.boolean().optional(),
+    vaultPath: z.string().min(1).max(1024).optional(),
+});
+const serenaSchema = z.object({
+    enabled: z.boolean().optional(),
+    executable: z.string().optional(),
+    backend: z.enum(["LSP", "JetBrains"]).optional(),
+    context: z.string().optional(),
+    startupTimeoutMs: positiveInteger.optional(),
+    requestTimeoutMs: positiveInteger.optional(),
+    idleTimeoutMinutes: positiveInteger.optional(),
+    maxInstances: positiveInteger.optional(),
+}).strict();
+const userConfigSchema = z.object({
+    host: z.string().optional(),
+    port: z.number().int().min(1).max(65535).optional(),
+    allowedRoots: z.array(z.string()).optional(),
+    publicBaseUrl: z.string().nullable().optional(),
+    allowedHosts: z.array(z.string()).optional(),
+    maxSessions: z.number().int().min(1).max(99999).optional(),
+    maxSessionsPerClient: z.number().int().min(1).max(99999).optional(),
+    sessionIdleTimeoutMs: z.number().int().min(60_000).max(7 * 24 * 60 * 60 * 1000).optional(),
+    stateDir: z.string().optional(),
+    worktreeRoot: z.string().optional(),
+    agentDir: z.string().optional(),
+    executables: executablesSchema.optional(),
+    integrations: integrationsSchema.optional(),
+    serena: serenaSchema.optional(),
+    obsidian: obsidianSchema.optional(),
+    tunnelProvider: z.enum(["cloudflare", "ngrok", "custom"]).optional(),
+    ngrokAuthtoken: z.string().optional(),
+    ngrokUrl: z.string().optional(),
+    toolToggles: z.record(z.string(), z.boolean()).optional(),
+}).strict();
+const authConfigSchema = z.object({
+    ownerToken: z.string().optional(),
+    cloudflareTunnelToken: z.string().min(16).max(2048).optional(),
+    ngrokAuthtokens: z.array(z.string().min(16).max(512)).max(20).optional(),
+    ngrokActiveAuthtokenIndex: z.number().int().min(0).optional(),
+    ngrokQuotaExhausted: z.record(z.string(), z.string()).optional(),
+    context7ApiKey: z.string().min(8).max(512).optional(),
+}).strict();
+export function auvryntConfigDir(env = process.env) {
+    return resolve(expandHomePath(env.AUVRYNT_CONFIG_DIR ?? join(homedir(), ".auvrynt")));
+}
+export function auvryntConfigPath(env = process.env) {
+    return join(auvryntConfigDir(env), "config.json");
+}
+export function auvryntAuthPath(env = process.env) {
+    return join(auvryntConfigDir(env), "auth.json");
+}
+export function loadAuvryntFiles(env = process.env) {
+    const dir = auvryntConfigDir(env);
+    const configPath = join(dir, "config.json");
+    const authPath = join(dir, "auth.json");
+    const configExists = existsSync(configPath);
+    const authExists = existsSync(authPath);
+    return {
+        dir,
+        configPath,
+        authPath,
+        configExists,
+        authExists,
+        config: configExists ? readJsonFile(configPath, userConfigSchema) : {},
+        auth: authExists ? readJsonFile(authPath, authConfigSchema) : {},
+    };
+}
+export function writeAuvryntConfig(config, env = process.env) {
+    const validated = userConfigSchema.parse(config);
+    const filePath = auvryntConfigPath(env);
+    ensurePrivateDirectory(auvryntConfigDir(env));
+    writeJsonFile(filePath, validated, 0o600);
+    return filePath;
+}
+export function writeAuvryntAuth(auth, env = process.env) {
+    const validated = authConfigSchema.parse(auth);
+    const filePath = auvryntAuthPath(env);
+    ensurePrivateDirectory(auvryntConfigDir(env));
+    writeJsonFile(filePath, validated, 0o600);
+    return filePath;
+}
+export function generateOwnerToken() {
+    return randomBytes(32).toString("base64url");
+}
+function readJsonFile(filePath, schema) {
+    try {
+        const parsed = JSON.parse(readFileSync(filePath, "utf8"));
+        const result = schema.safeParse(parsed);
+        if (!result.success) {
+            const details = result.error.issues
+                .map((issue) => `${issue.path.join(".") || "<root>"}: ${issue.message}`)
+                .join("; ");
+            throw new Error(`invalid configuration (${details})`);
+        }
+        return result.data;
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new Error(`Unable to read ${filePath}: ${reason}`);
+    }
+}
+function ensurePrivateDirectory(directory) {
+    mkdirSync(directory, { recursive: true, mode: 0o700 });
+    try {
+        chmodSync(directory, 0o700);
+    }
+    catch {
+        // Windows and some network filesystems may not expose POSIX mode bits.
+    }
+}
+function writeJsonFile(filePath, value, mode) {
+    ensurePrivateDirectory(dirname(filePath));
+    const tempPath = join(dirname(filePath), `.${basename(filePath)}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`);
+    try {
+        writeFileSync(tempPath, JSON.stringify(value, null, 2) + "\n", { mode, flag: "wx" });
+        try {
+            chmodSync(tempPath, mode);
+        }
+        catch {
+            // Best effort on platforms without POSIX permissions.
+        }
+        renameSync(tempPath, filePath);
+        try {
+            chmodSync(filePath, mode);
+        }
+        catch {
+            // Best effort on platforms without POSIX permissions.
+        }
+    }
+    finally {
+        if (existsSync(tempPath)) {
+            try {
+                unlinkSync(tempPath);
+            }
+            catch {
+                // A failed cleanup must not hide the original write/rename error.
+            }
+        }
+    }
+}

package/dist/integration-discovery.js

@@ -1,98 +1 @@
-import { createConnection } from "node:net";
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-import { loadConfig } from "./config.js";
-const execFileAsync = promisify(execFile);
-const PROCESS_MARKERS = {
-    blender: ["blender.exe", "blender"],
-    godot: ["godot.exe", "godot4.exe", "godot"],
-    cloudflare_tunnel: ["cloudflared.exe", "cloudflared"],
-    serena: ["serena.exe", "serena"],
-};
-function probePort(host, port, timeoutMs = 350) {
-    return new Promise((resolve) => {
-        const socket = createConnection({ host, port });
-        const finish = (available) => {
-            socket.destroy();
-            resolve(available);
-        };
-        const timeout = setTimeout(() => finish(false), timeoutMs);
-        socket.once("connect", () => {
-            clearTimeout(timeout);
-            finish(true);
-        });
-        socket.once("error", () => {
-            clearTimeout(timeout);
-            finish(false);
-        });
-    });
-}
-async function runningProcessNames() {
-    if (process.platform !== "win32")
-        return [];
-    try {
-        const { stdout } = await execFileAsync("tasklist.exe", ["/FO", "CSV", "/NH"], { timeout: 5_000 });
-        return stdout
-            .split(/\r?\n/)
-            .map((line) => line.match(/^"([^"]+)"/)?.[1]?.toLowerCase())
-            .filter((name) => Boolean(name));
-    }
-    catch {
-        return [];
-    }
-}
-async function findExecutable(command) {
-    if (process.platform !== "win32")
-        return undefined;
-    try {
-        const { stdout } = await execFileAsync("where.exe", [command], { timeout: 5_000 });
-        return stdout.split(/\r?\n/).map((line) => line.trim()).find(Boolean);
-    }
-    catch {
-        return undefined;
-    }
-}
-function hasProcess(processes, markers) {
-    return processes.some((processName) => markers.some((marker) => processName === marker || processName.includes(marker)));
-}
-export async function discoverLocalIntegrations() {
-    let configExecs = {};
-    try {
-        const config = loadConfig();
-        configExecs = config.executables;
-    }
-    catch { }
-    const blenderMcpPort = Number(process.env.AUVRYNT_BLENDER_MCP_PORT ?? 9876);
-    const [processes, cloudflaredSys, serenaSys, godotSys, blenderSys, blenderLabMcp, auvryntBlenderBridge, auvryntGodotBridge] = await Promise.all([
-        runningProcessNames(),
-        findExecutable("cloudflared"),
-        findExecutable("serena"),
-        findExecutable("godot"),
-        findExecutable("blender"),
-        probePort("127.0.0.1", blenderMcpPort),
-        probePort("127.0.0.1", 49323),
-        probePort("127.0.0.1", 49322),
-    ]);
-    const serena = configExecs.serena || serenaSys;
-    const godot = configExecs.godot || godotSys;
-    const godotCsharp = configExecs.godotCsharp;
-    const blender = configExecs.blender || blenderSys;
-    return {
-        processes,
-        executables: {
-            cloudflared: cloudflaredSys,
-            serena,
-            godot,
-            godotCsharp,
-            blender,
-        },
-        ports: {
-            blender_lab_mcp: blenderLabMcp,
-            auvrynt_blender_bridge: auvryntBlenderBridge,
-            auvrynt_godot_bridge: auvryntGodotBridge,
-        },
-    };
-}
-export function processDetected(discovery, integration) {
-    return hasProcess(discovery.processes, PROCESS_MARKERS[integration]);
-}
+export * from "./integrations/integration-discovery.js";

package/dist/integration-queue.js

@@ -0,0 +1 @@
+export * from "./infrastructure/integration-queue.js";