@adiholick/nvstudio-mcp 2.3.0 → 2.4.1

package/dist/roblox-bridge.js

@@ -19,6 +19,7 @@ const child_process_1 = require("child_process");
 const task_queue_1 = require("./task-queue");
 const ws_gateway_1 = require("./ws-gateway");
 const roblox_docs_1 = require("./roblox-docs");
+const vfx_database_1 = require("./vfx-database");
 const { version: SERVER_VERSION } = require('../package.json');
 exports.isBridgeHosting = false;
 let resolveBridgeReady;
@@ -502,6 +503,113 @@ function startBridgeServer(port, isDaemon = false) {
             res.status(500).json({ error: err.message });
         }
     });
+    // ── /api/vfx Endpoints (NV-VFX Database Management) ───────────────────────
+    app.get('/api/vfx', (req, res) => {
+        try {
+            const db = (0, vfx_database_1.getVfxDatabase)();
+            const category = req.query.category ? String(req.query.category) : undefined;
+            const query = req.query.query ? String(req.query.query) : undefined;
+            const items = db.listVfx({ category, query });
+            res.json({ success: true, count: items.length, items });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.get('/api/vfx/categories', (req, res) => {
+        try {
+            const db = (0, vfx_database_1.getVfxDatabase)();
+            res.json({ success: true, categories: db.getCategories() });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.get('/api/vfx/:id', (req, res) => {
+        try {
+            const db = (0, vfx_database_1.getVfxDatabase)();
+            const item = db.getVfx(req.params.id);
+            if (!item)
+                return res.status(404).json({ error: 'VFX tidak ditemukan' });
+            res.json({ success: true, item });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.post('/api/vfx', (req, res) => {
+        try {
+            const db = (0, vfx_database_1.getVfxDatabase)();
+            const saved = db.saveVfx(req.body);
+            io.emit('vfx_updated', { action: 'saved', item: saved });
+            res.json({ success: true, item: saved });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.delete('/api/vfx/:id', (req, res) => {
+        try {
+            const db = (0, vfx_database_1.getVfxDatabase)();
+            const ok = db.deleteVfx(req.params.id);
+            if (ok) {
+                io.emit('vfx_updated', { action: 'deleted', id: req.params.id });
+                res.json({ success: true });
+            }
+            else {
+                res.status(404).json({ error: 'VFX tidak ditemukan' });
+            }
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.post('/api/vfx/apply', async (req, res) => {
+        try {
+            const { id, target, scale, enabled, placeId, studioId } = req.body;
+            const db = (0, vfx_database_1.getVfxDatabase)();
+            const item = db.getVfx(id);
+            if (!item)
+                return res.status(404).json({ error: 'VFX tidak ditemukan di database' });
+            const targetPath = target || 'Workspace';
+            const payload = JSON.stringify({ data: item.data, scale: scale || 1, enabled });
+            const result = await (0, task_queue_1.addTaskToQueue)('apply_vfx', targetPath, payload, { placeId, studioId });
+            res.json({ success: true, result });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.post('/api/vfx/scan', async (req, res) => {
+        try {
+            const { target, name, category, tags, placeId, studioId } = req.body;
+            const targetPath = target || 'Workspace';
+            const scanPayload = JSON.stringify({ name, category, tags });
+            const result = await (0, task_queue_1.addTaskToQueue)('scan_vfx', targetPath, scanPayload, { placeId, studioId });
+            if (result && (result.status === 'success' || !result.error)) {
+                const scanned = result.result || result;
+                const db = (0, vfx_database_1.getVfxDatabase)();
+                const saved = db.saveVfx({
+                    name: scanned.name || name || 'Scanned_VFX',
+                    category: scanned.category || category || 'Ambient',
+                    tags: scanned.tags || tags || [],
+                    description: scanned.description,
+                    sourcePlaceId: placeId,
+                    stats: scanned.stats,
+                    nodeCount: scanned.nodeCount,
+                    data: scanned.data,
+                });
+                io.emit('vfx_updated', { action: 'saved', item: saved });
+                res.json({ success: true, item: saved, rawResult: result });
+            }
+            else {
+                res.status(400).json({ error: result?.error || 'Gagal memindai VFX dari Studio' });
+            }
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
     // ── /api/stats ─────────────────────────────────────────────────────────────
     app.get('/api/stats', (req, res) => {
         const activeStudios = getConnectedStudioCount();

package/dist/vfx-database.js

@@ -0,0 +1,507 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VfxDatabase = void 0;
+exports.normalizeVfxCategory = normalizeVfxCategory;
+exports.getVfxDatabase = getVfxDatabase;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const uuid_1 = require("uuid");
+const DATA_DIR = path_1.default.join(process.cwd(), 'data');
+const DB_FILE = path_1.default.join(DATA_DIR, 'vfx-database.json');
+// ── Default Seed Presets ───────────────────────────────────────────────────────
+const DEFAULT_PRESETS = [
+    {
+        id: 'preset-cyan-slash',
+        name: 'Cyan Horizon Slash',
+        category: 'Slash',
+        tags: ['sword', 'cyan', 'combat', 'slash', 'beam'],
+        description: 'High-speed sharp cybernetic slash effect with dual-layer brightness beams.',
+        author: 'NVStudio',
+        createdAt: new Date().toISOString(),
+        nodeCount: 5,
+        stats: { emitters: 0, beams: 2, trails: 0, lights: 0 },
+        data: {
+            version: 1,
+            rootName: 'CyanHorizonSlash',
+            rootClass: 'Folder',
+            nodeCount: 5,
+            stats: { emitters: 0, beams: 2, trails: 0, lights: 0 },
+            nodes: [
+                { class: 'Folder', name: 'CyanHorizonSlash', properties: { Name: 'CyanHorizonSlash' } },
+                {
+                    parent: 1,
+                    class: 'Attachment',
+                    name: 'Att0',
+                    properties: {
+                        Name: 'Att0',
+                        Visible: false,
+                        CFrame: { t: 'CFrame', v: [2, 0.5, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1] },
+                    },
+                },
+                {
+                    parent: 1,
+                    class: 'Attachment',
+                    name: 'Att1',
+                    properties: {
+                        Name: 'Att1',
+                        Visible: false,
+                        CFrame: { t: 'CFrame', v: [-2, -0.5, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1] },
+                    },
+                },
+                {
+                    parent: 1,
+                    class: 'Beam',
+                    name: 'SlashCore',
+                    properties: {
+                        Name: 'SlashCore',
+                        Enabled: true,
+                        Attachment0: { t: 'Ref', v: 2 },
+                        Attachment1: { t: 'Ref', v: 3 },
+                        Brightness: 3000,
+                        LightEmission: 1,
+                        LightInfluence: 0,
+                        Width0: 1.2,
+                        Width1: 0.1,
+                        Texture: 'rbxassetid://85772363699785',
+                        TextureSpeed: 5,
+                        TextureLength: 1,
+                        Color: {
+                            t: 'ColorSequence',
+                            v: [
+                                [0, { t: 'Color3', v: [0, 0.8, 1] }],
+                                [1, { t: 'Color3', v: [0, 1, 0.8] }],
+                            ],
+                        },
+                        Transparency: {
+                            t: 'NumberSequence',
+                            v: [
+                                [0, 0, 0],
+                                [1, 1, 0],
+                            ],
+                        },
+                    },
+                },
+                {
+                    parent: 1,
+                    class: 'Beam',
+                    name: 'SlashGlow',
+                    properties: {
+                        Name: 'SlashGlow',
+                        Enabled: true,
+                        Attachment0: { t: 'Ref', v: 2 },
+                        Attachment1: { t: 'Ref', v: 3 },
+                        Brightness: 1500,
+                        LightEmission: 0.8,
+                        Width0: 2.5,
+                        Width1: 0.5,
+                        TextureSpeed: 3,
+                        Color: {
+                            t: 'ColorSequence',
+                            v: [
+                                [0, { t: 'Color3', v: [0.1, 0.5, 1] }],
+                                [1, { t: 'Color3', v: [0.2, 0.8, 1] }],
+                            ],
+                        },
+                        Transparency: {
+                            t: 'NumberSequence',
+                            v: [
+                                [0, 0.2, 0],
+                                [1, 1, 0],
+                            ],
+                        },
+                    },
+                },
+            ],
+        },
+    },
+    {
+        id: 'preset-solar-burst',
+        name: 'Solar Flare Burst',
+        category: 'Explosion',
+        tags: ['fire', 'orange', 'explosion', 'particles', 'burst'],
+        description: 'Radial fiery shockwave burst with expanding sparks and heat glow.',
+        author: 'NVStudio',
+        createdAt: new Date().toISOString(),
+        nodeCount: 3,
+        stats: { emitters: 2, beams: 0, trails: 0, lights: 1 },
+        data: {
+            version: 1,
+            rootName: 'SolarFlareBurst',
+            rootClass: 'Folder',
+            nodeCount: 3,
+            stats: { emitters: 2, beams: 0, trails: 0, lights: 1 },
+            nodes: [
+                { class: 'Folder', name: 'SolarFlareBurst', properties: { Name: 'SolarFlareBurst' } },
+                {
+                    parent: 1,
+                    class: 'ParticleEmitter',
+                    name: 'Sparks',
+                    properties: {
+                        Name: 'Sparks',
+                        Enabled: true,
+                        Rate: 200,
+                        Speed: { t: 'NumberRange', v: [25, 45] },
+                        SpreadAngle: { t: 'Vector2', v: [180, 180] },
+                        Lifetime: { t: 'NumberRange', v: [0.4, 0.8] },
+                        LightEmission: 1,
+                        LightInfluence: 0,
+                        Brightness: 10,
+                        Size: {
+                            t: 'NumberSequence',
+                            v: [
+                                [0, 1.2, 0],
+                                [0.7, 0.4, 0],
+                                [1, 0, 0],
+                            ],
+                        },
+                        Color: {
+                            t: 'ColorSequence',
+                            v: [
+                                [0, { t: 'Color3', v: [1, 0.9, 0.5] }],
+                                [0.5, { t: 'Color3', v: [1, 0.4, 0] }],
+                                [1, { t: 'Color3', v: [0.8, 0.1, 0] }],
+                            ],
+                        },
+                        Transparency: {
+                            t: 'NumberSequence',
+                            v: [
+                                [0, 0, 0],
+                                [1, 1, 0],
+                            ],
+                        },
+                        Texture: 'rbxassetid://244221448',
+                    },
+                },
+                {
+                    parent: 1,
+                    class: 'PointLight',
+                    name: 'ExplosionLight',
+                    properties: {
+                        Name: 'ExplosionLight',
+                        Enabled: true,
+                        Brightness: 8,
+                        Range: 24,
+                        Color: { t: 'Color3', v: [1, 0.5, 0.1] },
+                        Shadows: true,
+                    },
+                },
+            ],
+        },
+    },
+    {
+        id: 'preset-dragon-aura',
+        name: 'Azure Dragon Aura',
+        category: 'Aura',
+        tags: ['aura', 'magic', 'energy', 'cyan', 'blue'],
+        description: 'Swirling ethereal flame aura for boss phases, charging states, and powerups.',
+        author: 'NVStudio',
+        createdAt: new Date().toISOString(),
+        nodeCount: 2,
+        stats: { emitters: 1, beams: 0, trails: 0, lights: 1 },
+        data: {
+            version: 1,
+            rootName: 'AzureDragonAura',
+            rootClass: 'Folder',
+            nodeCount: 2,
+            stats: { emitters: 1, beams: 0, trails: 0, lights: 1 },
+            nodes: [
+                { class: 'Folder', name: 'AzureDragonAura', properties: { Name: 'AzureDragonAura' } },
+                {
+                    parent: 1,
+                    class: 'ParticleEmitter',
+                    name: 'FlameAura',
+                    properties: {
+                        Name: 'FlameAura',
+                        Enabled: true,
+                        Rate: 35,
+                        Speed: { t: 'NumberRange', v: [2, 5] },
+                        EmissionDirection: { t: 'EnumItem', e: 'NormalId', v: 'Top' },
+                        Lifetime: { t: 'NumberRange', v: [0.8, 1.4] },
+                        LightEmission: 0.9,
+                        LightInfluence: 0,
+                        Brightness: 5,
+                        Drag: 2,
+                        Acceleration: { t: 'Vector3', v: [0, 8, 0] },
+                        Size: {
+                            t: 'NumberSequence',
+                            v: [
+                                [0, 0.5, 0],
+                                [0.5, 2.5, 0],
+                                [1, 0.2, 0],
+                            ],
+                        },
+                        Color: {
+                            t: 'ColorSequence',
+                            v: [
+                                [0, { t: 'Color3', v: [0, 0.7, 1] }],
+                                [0.6, { t: 'Color3', v: [0.2, 0.2, 0.9] }],
+                                [1, { t: 'Color3', v: [0.05, 0, 0.4] }],
+                            ],
+                        },
+                        Transparency: {
+                            t: 'NumberSequence',
+                            v: [
+                                [0, 0.8, 0],
+                                [0.3, 0.2, 0],
+                                [1, 1, 0],
+                            ],
+                        },
+                        Texture: 'rbxassetid://258128463',
+                    },
+                },
+            ],
+        },
+    },
+    {
+        id: 'preset-arcane-rune',
+        name: 'Arcane Summoning Circle',
+        category: 'Magic',
+        tags: ['magic', 'spell', 'circle', 'rune', 'purple'],
+        description: 'Luminous spinning arcane circle with floating magical motes.',
+        author: 'NVStudio',
+        createdAt: new Date().toISOString(),
+        nodeCount: 3,
+        stats: { emitters: 1, beams: 0, trails: 0, lights: 1 },
+        data: {
+            version: 1,
+            rootName: 'ArcaneSummoningCircle',
+            rootClass: 'Folder',
+            nodeCount: 3,
+            stats: { emitters: 1, beams: 0, trails: 0, lights: 1 },
+            nodes: [
+                { class: 'Folder', name: 'ArcaneSummoningCircle', properties: { Name: 'ArcaneSummoningCircle' } },
+                {
+                    parent: 1,
+                    class: 'ParticleEmitter',
+                    name: 'MagicSparks',
+                    properties: {
+                        Name: 'MagicSparks',
+                        Enabled: true,
+                        Rate: 40,
+                        Speed: { t: 'NumberRange', v: [1, 4] },
+                        Lifetime: { t: 'NumberRange', v: [1, 2] },
+                        LightEmission: 1,
+                        Size: {
+                            t: 'NumberSequence',
+                            v: [
+                                [0, 0.2, 0],
+                                [0.5, 0.6, 0],
+                                [1, 0, 0],
+                            ],
+                        },
+                        Color: {
+                            t: 'ColorSequence',
+                            v: [
+                                [0, { t: 'Color3', v: [0.8, 0.2, 1] }],
+                                [1, { t: 'Color3', v: [0.4, 0.8, 1] }],
+                            ],
+                        },
+                        Transparency: {
+                            t: 'NumberSequence',
+                            v: [
+                                [0, 0, 0],
+                                [1, 1, 0],
+                            ],
+                        },
+                        Texture: 'rbxassetid://244221448',
+                    },
+                },
+                {
+                    parent: 1,
+                    class: 'PointLight',
+                    name: 'RuneGlow',
+                    properties: {
+                        Name: 'RuneGlow',
+                        Enabled: true,
+                        Brightness: 4,
+                        Range: 16,
+                        Color: { t: 'Color3', v: [0.7, 0.2, 1] },
+                    },
+                },
+            ],
+        },
+    },
+    {
+        id: 'preset-emerald-beam',
+        name: 'Emerald Laser Beam',
+        category: 'Beam',
+        tags: ['beam', 'laser', 'emerald', 'green', 'energy'],
+        description: 'High-density focused energy beam with glowing outer edge.',
+        author: 'NVStudio',
+        createdAt: new Date().toISOString(),
+        nodeCount: 4,
+        stats: { emitters: 0, beams: 1, trails: 0, lights: 1 },
+        data: {
+            version: 1,
+            rootName: 'EmeraldLaserBeam',
+            rootClass: 'Folder',
+            nodeCount: 4,
+            stats: { emitters: 0, beams: 1, trails: 0, lights: 1 },
+            nodes: [
+                { class: 'Folder', name: 'EmeraldLaserBeam', properties: { Name: 'EmeraldLaserBeam' } },
+                {
+                    parent: 1,
+                    class: 'Attachment',
+                    name: 'Origin',
+                    properties: { Name: 'Origin', CFrame: { t: 'CFrame', v: [0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1] } },
+                },
+                {
+                    parent: 1,
+                    class: 'Attachment',
+                    name: 'Target',
+                    properties: { Name: 'Target', CFrame: { t: 'CFrame', v: [0, 0, -30, 1, 0, 0, 0, 1, 0, 0, 0, 1] } },
+                },
+                {
+                    parent: 1,
+                    class: 'Beam',
+                    name: 'LaserCore',
+                    properties: {
+                        Name: 'LaserCore',
+                        Enabled: true,
+                        Attachment0: { t: 'Ref', v: 2 },
+                        Attachment1: { t: 'Ref', v: 3 },
+                        Brightness: 2500,
+                        LightEmission: 1,
+                        Width0: 1.5,
+                        Width1: 1.5,
+                        TextureSpeed: 8,
+                        Color: {
+                            t: 'ColorSequence',
+                            v: [
+                                [0, { t: 'Color3', v: [0.2, 1, 0.4] }],
+                                [1, { t: 'Color3', v: [0, 0.8, 0.2] }],
+                            ],
+                        },
+                        Transparency: {
+                            t: 'NumberSequence',
+                            v: [
+                                [0, 0.1, 0],
+                                [1, 0.1, 0],
+                            ],
+                        },
+                    },
+                },
+            ],
+        },
+    },
+];
+function normalizeVfxCategory(rawCategory) {
+    if (!rawCategory || typeof rawCategory !== 'string')
+        return 'Ambient';
+    const trimmed = rawCategory.trim();
+    if (!trimmed)
+        return 'Ambient';
+    return trimmed.charAt(0).toUpperCase() + trimmed.slice(1).toLowerCase();
+}
+class VfxDatabase {
+    items = new Map();
+    constructor() {
+        this.ensureDirectory();
+        this.loadDatabase();
+    }
+    ensureDirectory() {
+        if (!fs_1.default.existsSync(DATA_DIR)) {
+            fs_1.default.mkdirSync(DATA_DIR, { recursive: true });
+        }
+    }
+    loadDatabase() {
+        if (fs_1.default.existsSync(DB_FILE)) {
+            try {
+                const raw = fs_1.default.readFileSync(DB_FILE, 'utf-8');
+                const list = JSON.parse(raw);
+                for (const item of list) {
+                    item.category = normalizeVfxCategory(item.category);
+                    this.items.set(item.id, item);
+                }
+            }
+            catch (err) {
+                console.error('[VfxDatabase] Gagal membaca vfx-database.json, menggunakan preset default:', err);
+                this.seedPresets();
+            }
+        }
+        else {
+            this.seedPresets();
+        }
+    }
+    seedPresets() {
+        for (const preset of DEFAULT_PRESETS) {
+            this.items.set(preset.id, preset);
+        }
+        this.saveToFile();
+    }
+    saveToFile() {
+        try {
+            this.ensureDirectory();
+            const list = Array.from(this.items.values());
+            fs_1.default.writeFileSync(DB_FILE, JSON.stringify(list, null, 2), 'utf-8');
+        }
+        catch (err) {
+            console.error('[VfxDatabase] Gagal menyimpan ke vfx-database.json:', err);
+        }
+    }
+    saveVfx(item) {
+        const id = item.id || `vfx-${(0, uuid_1.v4)().slice(0, 8)}`;
+        const createdAt = item.createdAt || new Date().toISOString();
+        const category = normalizeVfxCategory(item.category);
+        const vfxItem = {
+            ...item,
+            id,
+            category,
+            createdAt,
+            tags: Array.isArray(item.tags) ? item.tags : [category.toLowerCase()],
+            nodeCount: item.nodeCount || (item.data?.nodes ? item.data.nodes.length : 1),
+            stats: item.stats || { emitters: 0, beams: 0, trails: 0, lights: 0 },
+        };
+        this.items.set(id, vfxItem);
+        this.saveToFile();
+        return vfxItem;
+    }
+    getVfx(id) {
+        return this.items.get(id);
+    }
+    listVfx(filter) {
+        let result = Array.from(this.items.values());
+        if (filter?.category && filter.category !== 'All' && filter.category !== 'Semua') {
+            const catLower = filter.category.toLowerCase();
+            result = result.filter(item => item.category.toLowerCase() === catLower);
+        }
+        if (filter?.query && filter.query.trim()) {
+            const q = filter.query.toLowerCase().trim();
+            result = result.filter(item => item.name.toLowerCase().includes(q) ||
+                item.category.toLowerCase().includes(q) ||
+                (item.description && item.description.toLowerCase().includes(q)) ||
+                (item.tags && item.tags.some(t => t.toLowerCase().includes(q))));
+        }
+        return result.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+    }
+    deleteVfx(id) {
+        const deleted = this.items.delete(id);
+        if (deleted) {
+            this.saveToFile();
+        }
+        return deleted;
+    }
+    getCategories() {
+        const counts = new Map();
+        for (const item of this.items.values()) {
+            const cat = normalizeVfxCategory(item.category);
+            counts.set(cat, (counts.get(cat) || 0) + 1);
+        }
+        const categories = [];
+        for (const [name, count] of counts.entries()) {
+            categories.push({ name, count });
+        }
+        return categories.sort((a, b) => b.count - a.count);
+    }
+}
+exports.VfxDatabase = VfxDatabase;
+let instance = null;
+function getVfxDatabase() {
+    if (!instance) {
+        instance = new VfxDatabase();
+    }
+    return instance;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@adiholick/nvstudio-mcp",
-  "version": "2.3.0",
-  "description": "Local Bridge Server MCP for Roblox Studio",
+  "version": "2.4.1",
+  "description": "Local Bridge Server MCP for Roblox Studio with Animation, VFX, and Rigging Engines",
   "main": "dist/index.js",
   "bin": {
     "nvstudio-mcp": "dist/index.js"