auvrynt 1.0.2 → 1.0.5

package/dist/auth/connection-registry.js

@@ -0,0 +1,145 @@
+import { randomBytes } from "node:crypto";
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+const REGISTRY_FILE = "connections.json";
+const MAX_CLIENTS = 32;
+const MAX_PROVIDER_CHARS = 80;
+const MAX_USER_AGENT_CHARS = 160;
+const MAX_REQUEST_COUNT = Number.MAX_SAFE_INTEGER;
+export function connectionRegistryPath(stateDir) {
+    return join(stateDir, REGISTRY_FILE);
+}
+export function identifyProvider(clientName, userAgent) {
+    const value = `${clientName ?? ""} ${userAgent ?? ""}`.trim();
+    const normalized = value.toLowerCase();
+    const knownProviders = [
+        ["grok", "Grok"],
+        ["xai", "Grok / xAI"],
+        ["chatgpt", "ChatGPT"],
+        ["openai", "OpenAI"],
+        ["claude", "Claude"],
+        ["anthropic", "Claude / Anthropic"],
+        ["kimi", "Kimi"],
+        ["cursor", "Cursor"],
+        ["windsurf", "Windsurf"],
+        ["gemini", "Gemini"],
+        ["vscode", "VS Code"],
+        ["visual studio code", "VS Code"],
+        ["codex", "Codex"],
+    ];
+    for (const [marker, provider] of knownProviders) {
+        if (normalized.includes(marker))
+            return provider;
+    }
+    if (clientName?.trim())
+        return sanitizeSingleLine(clientName, MAX_PROVIDER_CHARS) || "Unknown MCP client";
+    if (userAgent?.trim()) {
+        return sanitizeSingleLine(userAgent, MAX_USER_AGENT_CHARS).split(/[\s/]/, 1)[0].slice(0, MAX_PROVIDER_CHARS) || "Unknown MCP client";
+    }
+    return "Unknown MCP client";
+}
+function sanitizeSingleLine(value, maxChars) {
+    return value.replace(/[\u0000-\u001f\u007f]/g, " ").trim().slice(0, maxChars);
+}
+function sanitizeUserAgent(userAgent) {
+    if (!userAgent)
+        return undefined;
+    return sanitizeSingleLine(userAgent, MAX_USER_AGENT_CHARS) || undefined;
+}
+function parseConnectedClient(entry) {
+    if (!entry || typeof entry !== "object")
+        return undefined;
+    const candidate = entry;
+    if (typeof candidate.provider !== "string" || typeof candidate.lastSeen !== "string")
+        return undefined;
+    if (typeof candidate.requestCount !== "number" || !Number.isSafeInteger(candidate.requestCount) || candidate.requestCount < 0)
+        return undefined;
+    const parsedDate = Date.parse(candidate.lastSeen);
+    if (!Number.isFinite(parsedDate))
+        return undefined;
+    const provider = sanitizeSingleLine(candidate.provider, MAX_PROVIDER_CHARS);
+    if (!provider)
+        return undefined;
+    return {
+        provider,
+        userAgent: typeof candidate.userAgent === "string" ? sanitizeUserAgent(candidate.userAgent) : undefined,
+        lastSeen: new Date(parsedDate).toISOString(),
+        requestCount: Math.min(candidate.requestCount, MAX_REQUEST_COUNT),
+    };
+}
+export function readConnectedClients(stateDir) {
+    const path = connectionRegistryPath(stateDir);
+    if (!existsSync(path))
+        return [];
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf8"));
+        if (!Array.isArray(parsed))
+            return [];
+        return parsed
+            .map(parseConnectedClient)
+            .filter((entry) => Boolean(entry))
+            .sort((left, right) => right.lastSeen.localeCompare(left.lastSeen))
+            .slice(0, MAX_CLIENTS);
+    }
+    catch {
+        return [];
+    }
+}
+export function recordConnectedClient(stateDir, input) {
+    mkdirSync(stateDir, { recursive: true, mode: 0o700 });
+    try {
+        chmodSync(stateDir, 0o700);
+    }
+    catch {
+        // Best effort on platforms/filesystems without POSIX modes.
+    }
+    const provider = identifyProvider(input.clientName, input.userAgent);
+    const clients = readConnectedClients(stateDir);
+    const existing = clients.find((client) => client.provider === provider);
+    const now = new Date().toISOString();
+    if (existing) {
+        existing.lastSeen = now;
+        existing.requestCount = Math.min(existing.requestCount + 1, MAX_REQUEST_COUNT);
+        existing.userAgent = sanitizeUserAgent(input.userAgent) ?? existing.userAgent;
+    }
+    else {
+        clients.push({
+            provider,
+            userAgent: sanitizeUserAgent(input.userAgent),
+            lastSeen: now,
+            requestCount: 1,
+        });
+    }
+    clients.sort((left, right) => right.lastSeen.localeCompare(left.lastSeen));
+    writeRegistryAtomically(connectionRegistryPath(stateDir), clients.slice(0, MAX_CLIENTS));
+}
+function writeRegistryAtomically(path, clients) {
+    const directory = dirname(path);
+    const tempPath = join(directory, `.connections.${process.pid}.${randomBytes(6).toString("hex")}.tmp`);
+    try {
+        writeFileSync(tempPath, JSON.stringify(clients, null, 2) + "\n", { mode: 0o600, flag: "wx" });
+        try {
+            chmodSync(tempPath, 0o600);
+        }
+        catch {
+            // Best effort on platforms/filesystems without POSIX modes.
+        }
+        renameSync(tempPath, path);
+        try {
+            chmodSync(path, 0o600);
+        }
+        catch {
+            // Best effort on platforms/filesystems without POSIX modes.
+        }
+    }
+    finally {
+        if (existsSync(tempPath)) {
+            try {
+                unlinkSync(tempPath);
+            }
+            catch {
+                // Cleanup failure must not hide the write failure.
+            }
+        }
+    }
+}

package/dist/auth/connection-status.js

@@ -0,0 +1,176 @@
+import { getBlenderClient } from "../blender-client.js";
+import { godotEditorStatus } from "../godot-editor-bridge.js";
+import { discoverLocalIntegrations, processDetected } from "../integration-discovery.js";
+import { getPlaywrightRuntimeStatus } from "../playwright-runtime.js";
+function checkedAt() {
+    return new Date().toISOString();
+}
+function unavailableByPolicy(provider, enabled, authorized, timestamp) {
+    if (!enabled) {
+        return {
+            state: "disabled",
+            provider,
+            detail: "This integration is disabled in Auvrynt configuration.",
+            checkedAt: timestamp,
+        };
+    }
+    if (!authorized) {
+        return {
+            state: "unauthorized",
+            provider,
+            detail: "The current OAuth token was not granted this integration scope.",
+            checkedAt: timestamp,
+        };
+    }
+    return undefined;
+}
+function browserStatus(config, authorized, timestamp) {
+    const policy = unavailableByPolicy("Playwright", config.integrations.playwright, authorized, timestamp);
+    if (policy)
+        return policy;
+    const status = getPlaywrightRuntimeStatus();
+    if (status.chromiumInstalled) {
+        return {
+            state: "available",
+            provider: "Playwright",
+            detail: `Browser support is ready${status.source ? ` (${status.source})` : ""} and will launch on demand.`,
+            checkedAt: timestamp,
+        };
+    }
+    return {
+        state: status.packageInstalled ? "unavailable" : "not_configured",
+        provider: "Playwright",
+        detail: status.packageInstalled
+            ? "Playwright is installed but Chromium is missing. Run `auvrynt start` to repair it automatically."
+            : "Playwright is not installed. Run `auvrynt start` to install managed browser support automatically.",
+        checkedAt: timestamp,
+    };
+}
+export async function getConnectionStatus(registry, processManager, config, scopes, workspaceId) {
+    const workspace = registry.getWorkspace(workspaceId);
+    const timestamp = checkedAt();
+    const scopeSet = new Set(scopes);
+    const local = await discoverLocalIntegrations();
+    const blenderPolicy = unavailableByPolicy("Blender Lab MCP", config.integrations.blender, scopeSet.has("auvrynt:blender"), timestamp);
+    let blender;
+    let blenderLabMcp;
+    if (blenderPolicy) {
+        blender = blenderPolicy;
+        blenderLabMcp = { ...blenderPolicy, provider: "Blender Lab MCP" };
+    }
+    else {
+        blender = {
+            state: "disconnected",
+            provider: "Blender Lab MCP",
+            endpoint: `127.0.0.1:${process.env.AUVRYNT_BLENDER_MCP_PORT ?? "9876"}`,
+            detail: "No response from Blender Lab MCP.",
+            checkedAt: timestamp,
+        };
+        try {
+            const response = await getBlenderClient(workspaceId).sendExecute("import bpy\nresult = {'version': bpy.app.version_string}\n");
+            blender.state = "connected";
+            blender.detail = "Blender Lab MCP responded. Scene inspection and workspace-bound Blender tools are ready.";
+            blender.metadata = response;
+        }
+        catch (error) {
+            blender.detail = error instanceof Error ? error.message : String(error);
+        }
+        blenderLabMcp = { ...blender };
+    }
+    const godotEnabled = config.integrations.godotGdscript || config.integrations.godotCsharp;
+    const godotPolicy = unavailableByPolicy("Auvrynt Godot editor bridge", godotEnabled, scopeSet.has("auvrynt:godot"), timestamp);
+    let godot;
+    let godotMcp;
+    if (godotPolicy) {
+        godot = godotPolicy;
+        godotMcp = { ...godotPolicy, provider: "Godot / Codex MCP" };
+    }
+    else {
+        try {
+            const response = await godotEditorStatus({ workspaceId });
+            godot = {
+                state: response.connected ? "connected" : "disconnected",
+                provider: "Auvrynt Godot editor bridge",
+                endpoint: "127.0.0.1:49322",
+                detail: response.connected ? "Godot editor bridge responded for this workspace." : "Godot editor bridge is not connected.",
+                checkedAt: timestamp,
+                metadata: response.connected ? response : undefined,
+            };
+        }
+        catch (error) {
+            godot = {
+                state: "error",
+                provider: "Auvrynt Godot editor bridge",
+                endpoint: "127.0.0.1:49322",
+                detail: error instanceof Error ? error.message : String(error),
+                checkedAt: timestamp,
+            };
+        }
+        godotMcp = {
+            state: local.ports.auvrynt_godot_bridge ? "connected" : processDetected(local, "godot") ? "available" : "disconnected",
+            provider: "Godot / Codex MCP",
+            endpoint: "local process or 127.0.0.1:49322",
+            detail: local.ports.auvrynt_godot_bridge
+                ? "Auvrynt Godot bridge is reachable."
+                : processDetected(local, "godot")
+                    ? "Godot is running, but no reachable Auvrynt bridge was found. Enable the bridge or Codex Godot MCP."
+                    : "Godot is not detected. Start Godot with the Auvrynt bridge or Codex Godot MCP enabled.",
+            checkedAt: timestamp,
+        };
+    }
+    const cloudflare = {
+        state: processDetected(local, "cloudflare_tunnel") ? "connected" : local.executables.cloudflared ? "available" : "unavailable",
+        provider: "Cloudflare Tunnel",
+        detail: processDetected(local, "cloudflare_tunnel")
+            ? "cloudflared is running."
+            : local.executables.cloudflared
+                ? "cloudflared is installed, but no tunnel process is running."
+                : "cloudflared is not installed.",
+        checkedAt: timestamp,
+    };
+    const serenaPolicy = unavailableByPolicy("Serena", config.integrations.serena && config.serena.enabled, scopeSet.has("auvrynt:serena"), timestamp);
+    const serena = serenaPolicy ?? {
+        state: processDetected(local, "serena") ? "connected" : local.executables.serena ? "available" : "unavailable",
+        provider: "Serena",
+        detail: processDetected(local, "serena")
+            ? "Serena process detected."
+            : local.executables.serena
+                ? "Serena is installed and available on demand."
+                : "Serena is not installed or not available on PATH.",
+        checkedAt: timestamp,
+    };
+    const webAuthorized = scopeSet.has("auvrynt:web");
+    return {
+        checkedAt: timestamp,
+        workspace: { id: workspace.id, root: workspace.root, mode: workspace.mode },
+        connections: {
+            mcp: {
+                state: "connected",
+                provider: "Auvrynt MCP server",
+                detail: "This status request was received through the authenticated MCP connection.",
+                checkedAt: timestamp,
+            },
+            blender,
+            blender_lab_mcp: blenderLabMcp,
+            godot,
+            godot_mcp: godotMcp,
+            cloudflare_tunnel: cloudflare,
+            serena,
+            browser: browserStatus(config, webAuthorized, timestamp),
+            chrome_mcp: webAuthorized
+                ? {
+                    state: "not_configured",
+                    provider: "Chrome MCP",
+                    detail: "No Chrome MCP adapter is registered in this Auvrynt build.",
+                    checkedAt: timestamp,
+                }
+                : {
+                    state: "unauthorized",
+                    provider: "Chrome MCP",
+                    detail: "The current OAuth token was not granted web access.",
+                    checkedAt: timestamp,
+                },
+        },
+        processes: scopeSet.has("auvrynt:process") ? processManager.listProcesses({ workspaceId }) : [],
+    };
+}