auvrynt 1.0.2 → 1.0.5

package/dist/integrations/roblox/roblox-helpers.js

@@ -0,0 +1,381 @@
+import { callRobloxStudioTool } from "./roblox-studio-client.js";
+function jsonForLuau(value) {
+    return JSON.stringify(value);
+}
+/** Resolve a dotted path like Workspace.Part or game.Workspace.Part in Luau. */
+const RESOLVE_PATH_FN = `
+local function resolvePath(path)
+  if typeof(path) ~= "string" or path == "" then
+    error("path must be a non-empty string")
+  end
+  local parts = string.split(path, ".")
+  local i = 1
+  if parts[1] == "game" then
+    i = 2
+  end
+  local cur = game
+  if parts[i] == "Place1" or parts[i] == "game" then
+    i = i + 1
+  end
+  while i <= #parts do
+    local name = parts[i]
+    if name == "" then
+      error("empty path segment in " .. path)
+    end
+    local nextInst = cur:FindFirstChild(name)
+    if not nextInst then
+      -- services are often direct children of DataModel via GetService
+      local ok, svc = pcall(function()
+        return game:GetService(name)
+      end)
+      if ok and svc and (cur == game or cur == game:GetService("Workspace") and false) then
+        nextInst = svc
+      end
+    end
+    if not nextInst and cur == game then
+      local ok, svc = pcall(function()
+        return game:GetService(name)
+      end)
+      if ok then nextInst = svc end
+    end
+    if not nextInst then
+      error("could not resolve '" .. name .. "' under " .. cur:GetFullName() .. " (from " .. path .. ")")
+    end
+    cur = nextInst
+    i = i + 1
+  end
+  return cur
+end
+`;
+const APPLY_PROPS_FN = `
+local function parseColor3(v)
+  if typeof(v) == "table" then
+    if v.R ~= nil then return Color3.new(v.R, v.G or 0, v.B or 0) end
+    if v[1] ~= nil then return Color3.fromRGB(v[1], v[2] or 0, v[3] or 0) end
+  end
+  if typeof(v) == "string" then
+    local r, g, b = string.match(v, "^(%d+)%s*,%s*(%d+)%s*,%s*(%d+)$")
+    if r then return Color3.fromRGB(tonumber(r), tonumber(g), tonumber(b)) end
+  end
+  return nil
+end
+
+local function parseVector3(v)
+  if typeof(v) == "table" then
+    if v.X ~= nil then return Vector3.new(v.X, v.Y or 0, v.Z or 0) end
+    if v[1] ~= nil then return Vector3.new(v[1], v[2] or 0, v[3] or 0) end
+  end
+  return nil
+end
+
+local function applyProps(inst, props)
+  if typeof(props) ~= "table" then return end
+  for key, value in pairs(props) do
+    if key == "Parent" then
+      -- ignore Parent here; use set_parent helper
+    elseif typeof(value) == "table" and value.__enum ~= nil then
+      local enumName, itemName = string.match(tostring(value.__enum), "([^%.]+)%.(.+)")
+      if not enumName then
+        enumName = value.__enum
+        itemName = value.item or value.name
+      end
+      local ok, enumType = pcall(function() return Enum[enumName] end)
+      if ok and enumType and itemName then
+        inst[key] = enumType[itemName]
+      end
+    elseif key == "Color" or key == "Color3" or key == "BackgroundColor3" or key == "TextColor3" or key == "ImageColor3" or key == "Ambient" or key == "OutdoorAmbient" or key == "FogColor" then
+      local c = parseColor3(value)
+      if c then inst[key] = c end
+    elseif key == "Size" or key == "Position" or key == "Orientation" then
+      local vec = parseVector3(value)
+      if vec then
+        if key == "Position" and inst:IsA("BasePart") then
+          inst.Position = vec
+        elseif key == "Size" and inst:IsA("BasePart") then
+          inst.Size = vec
+        elseif key == "Orientation" and inst:IsA("BasePart") then
+          inst.Orientation = vec
+        else
+          pcall(function() inst[key] = vec end)
+        end
+      elseif typeof(value) ~= "table" then
+        pcall(function() inst[key] = value end)
+      end
+    elseif key == "CFrame" and typeof(value) == "table" then
+      local p = parseVector3(value.Position or value.position or value)
+      if p and (value.Position or value.position) then
+        inst.CFrame = CFrame.new(p)
+      elseif value[1] then
+        inst.CFrame = CFrame.new(value[1], value[2] or 0, value[3] or 0)
+      end
+    else
+      pcall(function() inst[key] = value end)
+    end
+  end
+end
+`;
+async function runLuau(code, datamodelType = "Edit") {
+    return callRobloxStudioTool("execute_luau", {
+        code,
+        datamodel_type: datamodelType,
+    });
+}
+export async function robloxCreateInstance(opts) {
+    const name = opts.name ?? opts.className;
+    const props = opts.properties ?? {};
+    const code = `
+${RESOLVE_PATH_FN}
+${APPLY_PROPS_FN}
+local parent = resolvePath(${jsonForLuau(opts.parentPath)})
+local inst = Instance.new(${jsonForLuau(opts.className)})
+inst.Name = ${jsonForLuau(name)}
+applyProps(inst, game.HttpService:JSONDecode(${jsonForLuau(JSON.stringify(props))}))
+inst.Parent = parent
+return { ok = true, path = inst:GetFullName(), className = inst.ClassName, name = inst.Name }
+`;
+    return runLuau(code, opts.datamodelType ?? "Edit");
+}
+export async function robloxDestroyInstance(opts) {
+    const code = `
+${RESOLVE_PATH_FN}
+local inst = resolvePath(${jsonForLuau(opts.path)})
+local full = inst:GetFullName()
+inst:Destroy()
+return { ok = true, destroyed = full }
+`;
+    return runLuau(code, opts.datamodelType ?? "Edit");
+}
+export async function robloxCloneInstance(opts) {
+    const code = `
+${RESOLVE_PATH_FN}
+local src = resolvePath(${jsonForLuau(opts.path)})
+local clone = src:Clone()
+${opts.name ? `clone.Name = ${jsonForLuau(opts.name)}` : ""}
+local parent = ${opts.parentPath ? `resolvePath(${jsonForLuau(opts.parentPath)})` : "src.Parent"}
+clone.Parent = parent
+return { ok = true, path = clone:GetFullName(), name = clone.Name, className = clone.ClassName }
+`;
+    return runLuau(code, opts.datamodelType ?? "Edit");
+}
+export async function robloxSetParent(opts) {
+    const code = `
+${RESOLVE_PATH_FN}
+local inst = resolvePath(${jsonForLuau(opts.path)})
+local parent = resolvePath(${jsonForLuau(opts.parentPath)})
+inst.Parent = parent
+return { ok = true, path = inst:GetFullName(), parent = parent:GetFullName() }
+`;
+    return runLuau(code, opts.datamodelType ?? "Edit");
+}
+export async function robloxRenameInstance(opts) {
+    const code = `
+${RESOLVE_PATH_FN}
+local inst = resolvePath(${jsonForLuau(opts.path)})
+inst.Name = ${jsonForLuau(opts.name)}
+return { ok = true, path = inst:GetFullName(), name = inst.Name }
+`;
+    return runLuau(code, opts.datamodelType ?? "Edit");
+}
+export async function robloxSetProperties(opts) {
+    const code = `
+${RESOLVE_PATH_FN}
+${APPLY_PROPS_FN}
+local inst = resolvePath(${jsonForLuau(opts.path)})
+applyProps(inst, game.HttpService:JSONDecode(${jsonForLuau(JSON.stringify(opts.properties))}))
+return { ok = true, path = inst:GetFullName() }
+`;
+    return runLuau(code, opts.datamodelType ?? "Edit");
+}
+export async function robloxSetAttribute(opts) {
+    const code = `
+${RESOLVE_PATH_FN}
+local inst = resolvePath(${jsonForLuau(opts.path)})
+local value = game.HttpService:JSONDecode(${jsonForLuau(JSON.stringify({ v: opts.value }))}).v
+inst:SetAttribute(${jsonForLuau(opts.key)}, value)
+return { ok = true, path = inst:GetFullName(), key = ${jsonForLuau(opts.key)} }
+`;
+    return runLuau(code, opts.datamodelType ?? "Edit");
+}
+export async function robloxSetLighting(opts) {
+    const code = `
+${APPLY_PROPS_FN}
+local lighting = game:GetService("Lighting")
+applyProps(lighting, game.HttpService:JSONDecode(${jsonForLuau(JSON.stringify(opts.properties))}))
+return { ok = true, path = lighting:GetFullName() }
+`;
+    return runLuau(code, opts.datamodelType ?? "Edit");
+}
+export async function robloxFillTerrainRegion(opts) {
+    const material = opts.material ?? "Grass";
+    const resolution = opts.resolution ?? 4;
+    const code = `
+local terrain = workspace.Terrain
+local mat = Enum.Material[${jsonForLuau(material)}]
+local cf = CFrame.new(${opts.x}, ${opts.y}, ${opts.z})
+local size = Vector3.new(${opts.sizeX}, ${opts.sizeY}, ${opts.sizeZ})
+terrain:FillBlock(cf, size, mat)
+return { ok = true, material = ${jsonForLuau(material)}, center = {${opts.x}, ${opts.y}, ${opts.z}}, size = {${opts.sizeX}, ${opts.sizeY}, ${opts.sizeZ}} }
+`;
+    return runLuau(code, opts.datamodelType ?? "Edit");
+}
+export async function robloxClearTerrain(opts = {}) {
+    const code = `
+workspace.Terrain:Clear()
+return { ok = true }
+`;
+    return runLuau(code, opts.datamodelType ?? "Edit");
+}
+export async function robloxCreateScreenGui(opts) {
+    const name = opts.name ?? "ScreenGui";
+    const parentPath = opts.parentPath ?? "StarterGui";
+    const resetOnSpawn = opts.resetOnSpawn !== false;
+    const code = `
+${RESOLVE_PATH_FN}
+local parent = resolvePath(${jsonForLuau(parentPath)})
+local gui = Instance.new("ScreenGui")
+gui.Name = ${jsonForLuau(name)}
+gui.ResetOnSpawn = ${resetOnSpawn ? "true" : "false"}
+gui.ZIndexBehavior = Enum.ZIndexBehavior.Sibling
+gui.Parent = parent
+return { ok = true, path = gui:GetFullName() }
+`;
+    return runLuau(code, opts.datamodelType ?? "Edit");
+}
+export async function robloxEnsurePostEffect(opts) {
+    const name = opts.name ?? opts.className;
+    const props = opts.properties ?? {};
+    const code = `
+${APPLY_PROPS_FN}
+local lighting = game:GetService("Lighting")
+local effect = lighting:FindFirstChild(${jsonForLuau(name)})
+if not effect or effect.ClassName ~= ${jsonForLuau(opts.className)} then
+  if effect then effect:Destroy() end
+  effect = Instance.new(${jsonForLuau(opts.className)})
+  effect.Name = ${jsonForLuau(name)}
+  effect.Parent = lighting
+end
+applyProps(effect, game.HttpService:JSONDecode(${jsonForLuau(JSON.stringify(props))}))
+return { ok = true, path = effect:GetFullName(), className = effect.ClassName }
+`;
+    return runLuau(code, opts.datamodelType ?? "Edit");
+}
+export async function robloxCreateGuiObject(opts) {
+    return robloxCreateInstance({
+        className: opts.className,
+        parentPath: opts.parentPath,
+        name: opts.name,
+        properties: opts.properties,
+        datamodelType: opts.datamodelType,
+    });
+}
+export async function robloxCreateSound(opts) {
+    const props = { ...(opts.properties ?? {}) };
+    if (opts.soundId)
+        props.SoundId = opts.soundId.startsWith("rbxassetid://") ? opts.soundId : `rbxassetid://${opts.soundId}`;
+    return robloxCreateInstance({
+        className: "Sound",
+        parentPath: opts.parentPath,
+        name: opts.name ?? "Sound",
+        properties: props,
+        datamodelType: opts.datamodelType,
+    });
+}
+export async function robloxCreateConstraint(opts) {
+    const name = opts.name ?? opts.className;
+    const props = opts.properties ?? {};
+    const code = `
+${RESOLVE_PATH_FN}
+${APPLY_PROPS_FN}
+local parent = resolvePath(${jsonForLuau(opts.parentPath)})
+local c = Instance.new(${jsonForLuau(opts.className)})
+c.Name = ${jsonForLuau(name)}
+applyProps(c, game.HttpService:JSONDecode(${jsonForLuau(JSON.stringify(props))}))
+${opts.attachment0Path ? `c.Attachment0 = resolvePath(${jsonForLuau(opts.attachment0Path)})` : ""}
+${opts.attachment1Path ? `c.Attachment1 = resolvePath(${jsonForLuau(opts.attachment1Path)})` : ""}
+${opts.part0Path ? `pcall(function() c.Part0 = resolvePath(${jsonForLuau(opts.part0Path)}) end)` : ""}
+${opts.part1Path ? `pcall(function() c.Part1 = resolvePath(${jsonForLuau(opts.part1Path)}) end)` : ""}
+c.Parent = parent
+return { ok = true, path = c:GetFullName(), className = c.ClassName }
+`;
+    return runLuau(code, opts.datamodelType ?? "Edit");
+}
+export async function robloxSetCollisionGroup(opts) {
+    const code = `
+${RESOLVE_PATH_FN}
+local inst = resolvePath(${jsonForLuau(opts.path)})
+local ps = game:GetService("PhysicsService")
+local group = ${jsonForLuau(opts.groupName)}
+local ok = pcall(function()
+  ps:RegisterCollisionGroup(group)
+end)
+if inst:IsA("BasePart") then
+  inst.CollisionGroup = group
+else
+  error("path must be a BasePart")
+end
+return { ok = true, path = inst:GetFullName(), collisionGroup = group }
+`;
+    return runLuau(code, opts.datamodelType ?? "Edit");
+}
+export async function robloxSetCollisionGroupCollidable(opts) {
+    const code = `
+local ps = game:GetService("PhysicsService")
+pcall(function() ps:RegisterCollisionGroup(${jsonForLuau(opts.groupA)}) end)
+pcall(function() ps:RegisterCollisionGroup(${jsonForLuau(opts.groupB)}) end)
+ps:CollisionGroupSetCollidable(${jsonForLuau(opts.groupA)}, ${jsonForLuau(opts.groupB)}, ${opts.collidable ? "true" : "false"})
+return { ok = true, groupA = ${jsonForLuau(opts.groupA)}, groupB = ${jsonForLuau(opts.groupB)}, collidable = ${opts.collidable ? "true" : "false"} }
+`;
+    return runLuau(code, opts.datamodelType ?? "Edit");
+}
+export async function robloxFillTerrainBall(opts) {
+    const material = opts.material ?? "Grass";
+    const code = `
+local mat = Enum.Material[${jsonForLuau(material)}]
+workspace.Terrain:FillBall(Vector3.new(${opts.x}, ${opts.y}, ${opts.z}), ${opts.radius}, mat)
+return { ok = true, shape = "ball", material = ${jsonForLuau(material)} }
+`;
+    return runLuau(code, opts.datamodelType ?? "Edit");
+}
+export async function robloxSetWorkspaceGravity(opts) {
+    const code = `
+workspace.Gravity = ${opts.gravity}
+return { ok = true, gravity = workspace.Gravity }
+`;
+    return runLuau(code, opts.datamodelType ?? "Edit");
+}
+export async function robloxCreateRemoteEvent(opts) {
+    return robloxCreateInstance({
+        className: "RemoteEvent",
+        parentPath: opts.parentPath ?? "ReplicatedStorage",
+        name: opts.name,
+        datamodelType: opts.datamodelType,
+    });
+}
+export async function robloxCreateRemoteFunction(opts) {
+    return robloxCreateInstance({
+        className: "RemoteFunction",
+        parentPath: opts.parentPath ?? "ReplicatedStorage",
+        name: opts.name,
+        datamodelType: opts.datamodelType,
+    });
+}
+export async function robloxCreateModuleScript(opts) {
+    const source = opts.source ?? "local module = {}\n\nreturn module\n";
+    const code = `
+${RESOLVE_PATH_FN}
+local parent = resolvePath(${jsonForLuau(opts.parentPath)})
+local existing = parent:FindFirstChild(${jsonForLuau(opts.name)})
+local mod
+if existing and existing:IsA("ModuleScript") then
+  mod = existing
+else
+  if existing then existing:Destroy() end
+  mod = Instance.new("ModuleScript")
+  mod.Name = ${jsonForLuau(opts.name)}
+  mod.Parent = parent
+end
+mod.Source = ${jsonForLuau(source)}
+return { ok = true, path = mod:GetFullName() }
+`;
+    return runLuau(code, opts.datamodelType ?? "Edit");
+}

package/dist/integrations/roblox/roblox-studio-client.js

@@ -0,0 +1,112 @@
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+let client;
+let transport;
+let connectPromise;
+let cachedTools;
+export function resolveRobloxStudioMcpLaunch() {
+    if (process.platform === "win32") {
+        const bat = join(process.env.LOCALAPPDATA ?? join(homedir(), "AppData", "Local"), "Roblox", "mcp.bat");
+        return {
+            command: "cmd.exe",
+            args: ["/c", bat],
+            pathExists: existsSync(bat),
+            platform: process.platform,
+            hint: bat,
+        };
+    }
+    if (process.platform === "darwin") {
+        const bin = "/Applications/RobloxStudio.app/Contents/MacOS/StudioMCP";
+        return {
+            command: bin,
+            args: [],
+            pathExists: existsSync(bin),
+            platform: process.platform,
+            hint: bin,
+        };
+    }
+    // Linux / other: Studio MCP is not officially documented; surface a clear status.
+    const bat = join(homedir(), ".local", "share", "Roblox", "mcp.bat");
+    return {
+        command: bat,
+        args: [],
+        pathExists: existsSync(bat),
+        platform: process.platform,
+        hint: "Official Roblox Studio MCP is documented for Windows and macOS only.",
+    };
+}
+export async function getRobloxStudioClient() {
+    if (client)
+        return client;
+    if (connectPromise)
+        return connectPromise;
+    connectPromise = (async () => {
+        const launch = resolveRobloxStudioMcpLaunch();
+        if (!launch.pathExists) {
+            throw new Error(`Roblox Studio MCP launcher not found at ${launch.hint}. Install the latest Roblox Studio, enable Assistant → Manage MCP Servers → Enable Studio as MCP server, then retry.`);
+        }
+        const nextTransport = new StdioClientTransport({
+            command: launch.command,
+            args: launch.args,
+            stderr: "pipe",
+        });
+        const nextClient = new Client({ name: "auvrynt-roblox-proxy", version: "1.0.0" }, { capabilities: {} });
+        nextTransport.onclose = () => {
+            client = undefined;
+            transport = undefined;
+            cachedTools = undefined;
+            connectPromise = undefined;
+        };
+        await nextClient.connect(nextTransport);
+        client = nextClient;
+        transport = nextTransport;
+        return nextClient;
+    })();
+    try {
+        return await connectPromise;
+    }
+    catch (error) {
+        connectPromise = undefined;
+        client = undefined;
+        transport = undefined;
+        throw error;
+    }
+}
+export async function disconnectRobloxStudioClient() {
+    const current = transport;
+    client = undefined;
+    transport = undefined;
+    cachedTools = undefined;
+    connectPromise = undefined;
+    if (current) {
+        try {
+            await current.close();
+        }
+        catch {
+            // ignore close errors
+        }
+    }
+}
+export async function listRobloxStudioTools(forceRefresh = false) {
+    if (cachedTools && !forceRefresh)
+        return cachedTools;
+    const c = await getRobloxStudioClient();
+    const result = await c.listTools();
+    cachedTools = (result.tools ?? []).map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        inputSchema: tool.inputSchema,
+    }));
+    return cachedTools;
+}
+export async function callRobloxStudioTool(name, args = {}) {
+    const c = await getRobloxStudioClient();
+    const result = await c.callTool({ name, arguments: args });
+    return result;
+}
+export function robloxStudioClientConnected() {
+    return Boolean(client);
+}

package/dist/integrations/roblox/roblox-tools.js

@@ -0,0 +1,106 @@
+import { callRobloxStudioTool, disconnectRobloxStudioClient, listRobloxStudioTools, resolveRobloxStudioMcpLaunch, robloxStudioClientConnected, } from "./roblox-studio-client.js";
+/** Official Studio MCP tools documented by Roblox (names as exposed by Studio). */
+export const ROBLOX_OFFICIAL_TOOL_NAMES = [
+    "script_read",
+    "multi_edit",
+    "script_search",
+    "script_grep",
+    "generate_mesh",
+    "generate_material",
+    "generate_procedural_model",
+    "wait_job_finished",
+    "search_asset",
+    "insert_asset",
+    "upload_image",
+    "store_image",
+    "subagent",
+    "search_game_tree",
+    "inspect_instance",
+    "execute_luau",
+    "get_studio_state",
+    "start_stop_play",
+    "get_console_output",
+    "screen_capture",
+    "character_navigation",
+    "user_keyboard_input",
+    "user_mouse_input",
+    "http_get",
+    "skill",
+    "list_roblox_studios",
+    "set_active_studio",
+];
+export function auvryntRobloxToolName(remoteName) {
+    return remoteName.startsWith("roblox_") ? remoteName : `roblox_${remoteName}`;
+}
+export function remoteRobloxToolName(auvryntName) {
+    return auvryntName.startsWith("roblox_") ? auvryntName.slice("roblox_".length) : auvryntName;
+}
+export async function robloxStatus() {
+    const launch = resolveRobloxStudioMcpLaunch();
+    const base = {
+        integration: "roblox",
+        mode: "official-studio-mcp",
+        platform: launch.platform,
+        launcher: {
+            command: launch.command,
+            args: launch.args,
+            path: launch.hint,
+            exists: launch.pathExists,
+        },
+        connected: robloxStudioClientConnected(),
+        setup: [
+            "Open Roblox Studio",
+            "Assistant → … → Manage MCP Servers → Enable Studio as MCP server",
+            "Start Auvrynt with: auvrynt start roblox",
+            "Keep Studio open while using roblox_* tools",
+        ],
+        docs: "https://create.roblox.com/docs/studio/mcp",
+    };
+    if (!launch.pathExists) {
+        return {
+            ...base,
+            ok: false,
+            error: `Studio MCP launcher not found at ${launch.hint}`,
+        };
+    }
+    try {
+        const tools = await listRobloxStudioTools(true);
+        return {
+            ...base,
+            ok: true,
+            connected: true,
+            toolCount: tools.length,
+            tools: tools.map((t) => t.name),
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            ...base,
+            ok: false,
+            connected: false,
+            error: message,
+        };
+    }
+}
+export async function robloxListTools(forceRefresh = false) {
+    const tools = await listRobloxStudioTools(forceRefresh);
+    return {
+        ok: true,
+        count: tools.length,
+        tools: tools.map((tool) => ({
+            remoteName: tool.name,
+            auvryntName: auvryntRobloxToolName(tool.name),
+            description: tool.description,
+            inputSchema: tool.inputSchema,
+        })),
+    };
+}
+export async function robloxCall(toolName, args = {}) {
+    const remote = remoteRobloxToolName(toolName);
+    return callRobloxStudioTool(remote, args);
+}
+export async function robloxDisconnect() {
+    await disconnectRobloxStudioClient();
+    return { ok: true };
+}