syncrbx 1.1.0 → 1.1.1

package/README.md

@@ -1,5 +1,5 @@
 <div align="center">
-  <img src="https://raw.githubusercontent.com/DevManyPB/Verde/main/Logo.png" alt="SyncRbx" width="200" />
+  <img src="https://www.syncrbx.xyz/Logo.png" alt="SyncRbx" width="200" />
 </div>
 
 # SyncRbx CLI

package/converters.js

@@ -382,24 +382,44 @@ function filePathToInstancePath(filePath, projectRoot) {
 // ---------------------------------------------------------------------------
 // Phase 2 - #4: Project config loader
 // ---------------------------------------------------------------------------
+const PROJECT_CONFIG_FILE = 'syncrbx.project.json';
+
+// Keeps only known Roblox services, without duplicates. Returns null when the
+// value is not a list, meaning "not chosen yet".
+function sanitizeServices(services) {
+    if (!Array.isArray(services)) return null;
+    return [...new Set(services.filter(s => typeof s === 'string' && ROOT_SERVICES.includes(s)))];
+}
+
+function readProjectConfigFile(projectRoot) {
+    const configPath = path.join(projectRoot, PROJECT_CONFIG_FILE);
+    if (!fs.existsSync(configPath)) return {};
+    try {
+        return JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    } catch (e) {
+        console.error(`[WARN] Error parsing ${PROJECT_CONFIG_FILE}: ${e.message}`);
+        return {};
+    }
+}
+
 function loadProjectConfig(projectRoot) {
-    const configPath = path.join(projectRoot, 'syncrbx.project.json');
     const defaults = {
         name: path.basename(projectRoot),
         port: 34872,
         ignore: ['*.conflict.bak', 'node_modules', '.git', '.vscode'],
         tree: null, // null = auto-detect from folder names
+        services: null, // null = the user has not chosen which services to sync
     };
+    const config = { ...defaults, ...readProjectConfigFile(projectRoot) };
+    config.services = sanitizeServices(config.services);
+    return config;
+}
 
-    if (fs.existsSync(configPath)) {
-        try {
-            const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-            return { ...defaults, ...config };
-        } catch (e) {
-            console.error(`[WARN] Error parsing syncrbx.project.json: ${e.message}`);
-        }
-    }
-    return defaults;
+// Saves the chosen services, keeping any other settings already in the file.
+function saveProjectServices(projectRoot, services) {
+    const config = readProjectConfigFile(projectRoot);
+    config.services = services;
+    fs.writeFileSync(path.join(projectRoot, PROJECT_CONFIG_FILE), JSON.stringify(config, null, 2) + '\n', 'utf8');
 }
 
 module.exports = {
@@ -420,5 +440,8 @@ module.exports = {
     filePathToInstancePath,
     getMetaProperties,
     loadProjectConfig,
+    saveProjectServices,
+    sanitizeServices,
+    PROJECT_CONFIG_FILE,
     fileChecksum,
 };

package/local-sync.js

@@ -6,6 +6,7 @@ const {
     processDirectory, convertFile, instanceToFile,
     filePathToInstancePath, stripExtension, ROOT_SERVICES,
     buildChecksums, loadProjectConfig, classFromFileName, isInitFile, ANY_CLASS,
+    saveProjectServices, sanitizeServices, STARTER_PLAYER_CHILDREN,
 } = require('./converters');
 
 const app = express();
@@ -17,6 +18,45 @@ const PROJECT_ROOT = process.cwd();
 
 const projectConfig = loadProjectConfig(PROJECT_ROOT);
 const PORT = projectConfig.port || 34872;
+
+// ---------------------------------------------------------------------------
+// Synced services — the user picks them in the Studio plugin the first time a
+// project connects; they are saved in syncrbx.project.json. Nothing outside
+// them is read, written or deleted, in either direction.
+// ---------------------------------------------------------------------------
+function isServiceSynced(serviceName) {
+    // Projects that have not chosen yet keep the previous behaviour (every
+    // known service), so older plugins still work.
+    const services = projectConfig.services || ROOT_SERVICES;
+    return services.includes(serviceName);
+}
+
+// "Workspace/Map/Door" → is Workspace synced?
+function isInstancePathSynced(instancePath) {
+    return isServiceSynced(String(instancePath || '').split('/')[0]);
+}
+
+function isDiskPathSynced(filePath) {
+    const relative = path.relative(PROJECT_ROOT, filePath);
+    if (!relative || relative.startsWith('..') || path.isAbsolute(relative)) return false;
+    return isServiceSynced(relative.split(path.sep)[0]);
+}
+
+// Creates the folder of each synced service that does not exist yet.
+function createServiceFolders(services) {
+    const folders = [...services];
+    if (services.includes('StarterPlayer')) {
+        folders.push(...STARTER_PLAYER_CHILDREN.map(child => `StarterPlayer/${child}`));
+    }
+    for (const folder of folders) {
+        const folderPath = path.join(PROJECT_ROOT, folder);
+        if (!fs.existsSync(folderPath)) {
+            markIgnored(folderPath);
+            fs.mkdirSync(folderPath, { recursive: true });
+            logDisk(`Folder created: ${folder}`);
+        }
+    }
+}
 const HOST = '127.0.0.1';
 const ALLOWED_HOSTS = new Set([`localhost:${PORT}`, `127.0.0.1:${PORT}`, `[::1]:${PORT}`]);
 
@@ -257,30 +297,30 @@ const watcher = chokidar.watch(PROJECT_ROOT, {
 
 watcher
     .on('add', filePath => {
-        if (isIgnored(filePath)) return;
+        if (isIgnored(filePath) || !isDiskPathSynced(filePath)) return;
         logDisk(`File created: ${path.relative(PROJECT_ROOT, filePath)}`);
         getTimestamps(filePath).disk = Date.now();
         pushChange(buildChangePayload('Added', filePath));
     })
     .on('change', filePath => {
-        if (isIgnored(filePath)) return;
+        if (isIgnored(filePath) || !isDiskPathSynced(filePath)) return;
         logDisk(`File modified: ${path.relative(PROJECT_ROOT, filePath)}`);
         getTimestamps(filePath).disk = Date.now();
         pushChange(buildChangePayload('Changed', filePath));
     })
     .on('unlink', filePath => {
-        if (isIgnored(filePath)) return;
+        if (isIgnored(filePath) || !isDiskPathSynced(filePath)) return;
         logDisk(`File deleted: ${path.relative(PROJECT_ROOT, filePath)}`);
         pushChange(buildChangePayload('Removed', filePath));
         lastWriteTimestamps.delete(path.resolve(filePath));
     })
     .on('addDir', dirPath => {
-        if (isIgnored(dirPath)) return;
+        if (isIgnored(dirPath) || !isDiskPathSynced(dirPath)) return;
         logDisk(`Folder created: ${path.relative(PROJECT_ROOT, dirPath)}`);
         pushChange(buildChangePayload('Added', dirPath, true));
     })
     .on('unlinkDir', dirPath => {
-        if (isIgnored(dirPath)) return;
+        if (isIgnored(dirPath) || !isDiskPathSynced(dirPath)) return;
         logDisk(`Folder deleted: ${path.relative(PROJECT_ROOT, dirPath)}`);
         pushChange(buildChangePayload('Removed', dirPath, true));
     });
@@ -294,9 +334,32 @@ app.get('/ping', (req, res) => {
         status: 'ok',
         project: projectConfig.name || path.basename(PROJECT_ROOT),
         version: require('./package.json').version,
+        // false until the user picks the services to sync in the plugin
+        configured: Array.isArray(projectConfig.services),
+        services: projectConfig.services,
+        availableServices: ROOT_SERVICES,
     });
 });
 
+// POST /config — saves the services chosen in the plugin
+app.post('/config', (req, res) => {
+    const requested = req.body && req.body.services;
+    const services = sanitizeServices(requested);
+    if (!services || services.length === 0 || services.length !== requested.length) {
+        return res.status(400).json({ error: 'services must be a non-empty list of Roblox services' });
+    }
+    try {
+        saveProjectServices(PROJECT_ROOT, services);
+        projectConfig.services = services;
+        createServiceFolders(services);
+        logServer(`Synced services: ${services.join(', ')}`);
+        res.json({ success: true, services });
+    } catch (e) {
+        logError(`Could not save the project config: ${e.message}`);
+        res.status(500).json({ error: e.message });
+    }
+});
+
 app.post('/shutdown', (req, res) => {
     res.json({ success: true });
     logServer('Shutdown requested by VS Code extension.');
@@ -310,7 +373,7 @@ app.get('/tree', (req, res) => {
             const rootFolders = fs.readdirSync(PROJECT_ROOT, { withFileTypes: true });
             for (const folder of rootFolders) {
                 // Only service folders are synced; skips node_modules, .git...
-                if (folder.isDirectory() && ROOT_SERVICES.includes(folder.name)) {
+                if (folder.isDirectory() && ROOT_SERVICES.includes(folder.name) && isServiceSynced(folder.name)) {
                     const subTree = processDirectory(path.join(PROJECT_ROOT, folder.name), true);
                     tree.push(subTree);
                 }
@@ -400,6 +463,11 @@ app.post('/studio-change', (req, res) => {
                 continue;
             }
 
+            // Changes outside the synced services never touch the disk
+            if (!isInstancePathSynced(change.path) || (change.oldPath && !isInstancePathSynced(change.oldPath))) {
+                continue;
+            }
+
             logStudio(`${change.type} → ${change.path} (${change.className || '?'})`);
 
             const fileInfo = instanceToFile(change);
@@ -526,31 +594,24 @@ process.on('SIGTERM', () => shutdown('SIGTERM'));
 // Start
 // ---------------------------------------------------------------------------
 function startServer() {
-    const defaultFolders = [
-        ...ROOT_SERVICES,
-        'StarterPlayer/StarterPlayerScripts',
-        'StarterPlayer/StarterCharacterScripts'
-    ];
-    for (const folder of defaultFolders) {
-        const folderPath = path.join(PROJECT_ROOT, folder);
-        if (!fs.existsSync(folderPath)) {
-            try {
-                fs.mkdirSync(folderPath, { recursive: true });
-            } catch (e) {
-                // Ignore permissions/nested errors
-            }
-        }
+    if (projectConfig.services) {
+        createServiceFolders(projectConfig.services);
     }
 
     const server = app.listen(PORT, HOST, () => {
         console.log('');
         console.log(c.bold(c.green('  ╔══════════════════════════════════════════╗')));
-        console.log(c.bold(c.green('  ║           🌿  SYNCRBX v1.0  🌿           ║')));
+        console.log(c.bold(c.green('  ║          🌿  SYNCRBX v' + require('./package.json').version + '  🌿          ║')));
         console.log(c.bold(c.green('  ╚══════════════════════════════════════════╝')));
         console.log('');
         logServer(`Server at ${c.bold(`${HOST}:${PORT}`)}`);
         logServer(`Project: ${c.cyan(projectConfig.name)}`);
         logServer(`Monitoring: ${c.cyan(PROJECT_ROOT)}`);
+        if (projectConfig.services) {
+            logServer(`Syncing: ${c.cyan(projectConfig.services.join(', '))}`);
+        } else {
+            logServer(`No services chosen yet: pick them in the Studio plugin when you connect.`);
+        }
         logServer(`Waiting for connection from Roblox Studio...`);
         console.log('');
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "syncrbx",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "A free tool to sync VS Code with Roblox Studio. Instant bidirectional sync, SyncRbx Cloud, and Auto-Folders.",
   "main": "local-sync.js",
   "bin": {