verde-sync 1.0.0

package/build.js

@@ -0,0 +1,77 @@
+/**
+ * build.js — Compiles the modular OOP plugin (src/) into a single SyncPlugin.lua
+ * 
+ * Usage: node build.js
+ * Output: ../plugin/SyncPlugin.lua (ready to paste into Studio)
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const SRC = path.join(__dirname, '..', 'plugin', 'src');
+const OUT = path.join(__dirname, '..', 'plugin', 'SyncPlugin.lua');
+
+// Read all module files in dependency order
+const modules = {
+    'Utils.Constants': fs.readFileSync(path.join(SRC, 'Utils', 'Constants.lua'), 'utf8'),
+    'Utils.Logger': fs.readFileSync(path.join(SRC, 'Utils', 'Logger.lua'), 'utf8'),
+    'Core.Net': fs.readFileSync(path.join(SRC, 'Core', 'Net.lua'), 'utf8'),
+    'Core.InstanceTracker': fs.readFileSync(path.join(SRC, 'Core', 'InstanceTracker.lua'), 'utf8'),
+    'Core.SyncEngine': fs.readFileSync(path.join(SRC, 'Core', 'SyncEngine.lua'), 'utf8'),
+    'UI.VerdeWidget': fs.readFileSync(path.join(SRC, 'UI', 'VerdeWidget.lua'), 'utf8'),
+};
+
+const mainSource = fs.readFileSync(path.join(SRC, 'Main.server.lua'), 'utf8');
+
+// Build the bundled output
+let output = `--[[\n    Verde Sync Plugin v2.0 — Auto-generated bundle\n    DO NOT EDIT — Edit the source files in plugin/src/ instead.\n    Built: ${new Date().toISOString()}\n--]]\n\n`;
+
+// Create a module loader
+output += `local _modules = {}\nlocal _loaded = {}\n\n`;
+output += `local function _require(name)\n    if _loaded[name] then return _loaded[name] end\n    local loader = _modules[name]\n    if not loader then error("Module not found: " .. name) end\n    _loaded[name] = loader()\n    return _loaded[name]\nend\n\n`;
+
+// Register each module
+for (const [name, source] of Object.entries(modules)) {
+    // Replace require() calls with our bundled _require()
+    let processed = source;
+    
+    // Replace patterns like: require(script.Parent.Parent.Utils.Constants)
+    // with: _require("Utils.Constants")
+    processed = processed.replace(
+        /require\(script\.Parent\.Parent\.([A-Za-z.]+)\)/g,
+        (match, modPath) => `_require("${modPath}")`
+    );
+    processed = processed.replace(
+        /require\(script\.Parent\.([A-Za-z.]+)\)/g,
+        (match, modPath) => {
+            // Determine the parent module's package
+            const parentPkg = name.split('.')[0];
+            return `_require("${parentPkg}.${modPath}")`;
+        }
+    );
+
+    output += `_modules["${name}"] = function()\n`;
+    // Indent the module source
+    const lines = processed.split('\n');
+    for (const line of lines) {
+        // Skip "return X" at the end - we'll handle it
+        output += `    ${line}\n`;
+    }
+    output += `end\n\n`;
+}
+
+// Process Main entry point
+let mainProcessed = mainSource;
+mainProcessed = mainProcessed.replace(
+    /require\(script\.Parent\.([A-Za-z.]+)\)/g,
+    (match, modPath) => `_require("${modPath}")`
+);
+
+output += `-- Main Entry Point\n`;
+output += mainProcessed;
+output += '\n';
+
+fs.writeFileSync(OUT, output, 'utf8');
+console.log(`✅ Built successfully: ${OUT}`);
+console.log(`   Size: ${(fs.statSync(OUT).size / 1024).toFixed(1)} KB`);
+console.log(`   Modules: ${Object.keys(modules).length}`);

package/cli.js

@@ -0,0 +1,283 @@
+#!/usr/bin/env node
+
+const { Command } = require('commander');
+const fs = require('fs');
+const path = require('path');
+const archiver = require('archiver');
+const { createClient } = require('@supabase/supabase-js');
+const { startServer } = require('./local-sync');
+
+const program = new Command();
+
+// Configuración de Supabase (Deben ser las de producción de Verde Sync)
+const SUPABASE_URL = process.env.SUPABASE_URL || 'https://kbwtiamvxsakgkdiqowh.supabase.co';
+const SUPABASE_ANON_KEY = process.env.SUPABASE_ANON_KEY || 'sb_publishable_JJsCW2748RsShs44NSZndQ_Rk2u5-hc';
+const supabase = createClient(SUPABASE_URL, SUPABASE_ANON_KEY);
+
+const CONFIG_PATH = path.join(process.env.HOME || process.env.USERPROFILE, '.verdeconfig.json');
+
+// --- Helper Functions ---
+
+function forceExit(code) {
+    setTimeout(() => {
+        process.exit(code);
+    }, 50);
+}
+
+function getToken() {
+    if (fs.existsSync(CONFIG_PATH)) {
+        try {
+            const config = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
+            return config.access_token;
+        } catch (e) {
+            return null;
+        }
+    }
+    return null;
+}
+
+function saveToken(token) {
+    fs.writeFileSync(CONFIG_PATH, JSON.stringify({ access_token: token }, null, 2));
+}
+
+function getAuthClient(token) {
+    return createClient(SUPABASE_URL, SUPABASE_ANON_KEY, {
+        global: {
+            headers: {
+                Authorization: `Bearer ${token}`
+            }
+        }
+    });
+}
+
+function getProjectConfig() {
+    const localVerde = path.join(process.cwd(), '.verde', 'config.json');
+    if (fs.existsSync(localVerde)) {
+        return JSON.parse(fs.readFileSync(localVerde, 'utf8'));
+    }
+    return null;
+}
+
+// --- Commands ---
+
+program
+  .name('verde')
+  .description('Verde Sync CLI - Bidirectional Sync and Version Control for Roblox')
+  .version('2.0.0');
+
+// Comando: Login
+program
+  .command('login')
+  .description('Autenticarte con tu cuenta de Verde Sync')
+  .option('-t, --token <token>', 'Proporcionar el token directamente')
+  .action(async (options) => {
+    if (options.token) {
+        saveToken(options.token);
+        console.log('✅ Sesión iniciada correctamente con Verde Sync.');
+        return;
+    }
+
+    console.log('🔗 Para autenticarte, ve a https://verdesync.xyz/settings y copia tu Token CLI.');
+    
+    const readline = require('readline').createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+
+    readline.question('Pegue su Token CLI aquí: ', (token) => {
+        if (token && token.trim().length > 0) {
+            saveToken(token.trim());
+            console.log('✅ Sesión iniciada correctamente con Verde Sync.');
+        } else {
+            console.log('❌ Error: No se proporcionó ningún token.');
+        }
+        readline.close();
+        forceExit(0);
+    });
+  });
+
+// Comando: Serve (Sincronización local)
+program
+  .command('serve')
+  .description('Inicia el servidor local de Verde Sync')
+  .action(() => {
+      startServer();
+  });
+
+// Comando: Init
+program
+  .command('init')
+  .description('Inicializa un nuevo repositorio de Verde Sync en la nube')
+  .option('--private', 'Hace el repositorio privado')
+  .option('--public', 'Hace el repositorio público (por defecto)')
+  .action(async (options) => {
+      const token = getToken();
+      if (!token) {
+          console.error('❌ No estás autenticado. Usa "verde login" primero.');
+          forceExit(1);
+          return;
+      }
+
+      const authClient = getAuthClient(token);
+      const { data: { user }, error: userError } = await authClient.auth.getUser(token);
+      
+      if (userError || !user) {
+          console.error('❌ Token inválido o expirado. Vuelve a hacer "verde login".');
+          forceExit(1);
+          return;
+      }
+
+      const srcPath = path.join(process.cwd(), 'src');
+      const rojoConfig = path.join(process.cwd(), 'default.project.json');
+      
+      // Validación y Scaffolding
+      if (!fs.existsSync(srcPath) && !fs.existsSync(rojoConfig)) {
+          console.log('🚧 No se detectó una estructura de Roblox. Creando scaffolding (src/ y config.json)...');
+          fs.mkdirSync(srcPath, { recursive: true });
+          
+          const configJson = {
+              name: path.basename(process.cwd()),
+              version: "1.0.0",
+              engine: "roblox",
+              type: "verde-sync-project"
+          };
+          fs.writeFileSync(path.join(srcPath, 'config.json'), JSON.stringify(configJson, null, 2));
+          console.log('✅ Estructura base creada.');
+      }
+
+      const isPrivate = options.private ? true : false;
+      const projectName = path.basename(process.cwd());
+
+      console.log(`🚀 Inicializando proyecto "${projectName}" como ${isPrivate ? 'Privado' : 'Público'}...`);
+      
+      // Real DB Insert
+      const { data, error } = await authClient
+          .from('verde_projects')
+          .insert([
+              { owner_id: user.id, name: projectName, is_private: isPrivate, description: 'Proyecto sincronizado vía Verde CLI' }
+          ])
+          .select()
+          .single();
+
+      if (error) {
+          if (error.code === '23505') {
+              console.error('❌ Error: Ya tienes un proyecto con este mismo nombre.');
+          } else {
+              console.error(`❌ Error en la base de datos: ${error.message}`);
+          }
+          forceExit(1);
+          return;
+      }
+
+      // Guardar vínculo local
+      const verdeFolder = path.join(process.cwd(), '.verde');
+      if (!fs.existsSync(verdeFolder)) fs.mkdirSync(verdeFolder);
+      
+      fs.writeFileSync(path.join(verdeFolder, 'config.json'), JSON.stringify({ project_id: data.id, owner_id: user.id }, null, 2));
+
+      console.log('✅ Proyecto inicializado con éxito y vinculado a la nube.');
+      forceExit(0);
+  });
+
+// Comando: Push
+program
+  .command('push')
+  .description('Empaqueta tu código y sube un commit a la nube')
+  .argument('<message>', 'Mensaje del commit')
+  .action(async (message) => {
+      const token = getToken();
+      if (!token) {
+          console.error('❌ No estás autenticado. Usa "verde login" primero.');
+          forceExit(1);
+          return;
+      }
+
+      const projectConfig = getProjectConfig();
+      if (!projectConfig || !projectConfig.project_id) {
+          console.error('❌ Este directorio no está vinculado a Verde Cloud. Ejecuta "verde init" primero.');
+          forceExit(1);
+          return;
+      }
+
+      const authClient = getAuthClient(token);
+      const { data: { user }, error: userError } = await authClient.auth.getUser(token);
+      if (userError || !user) {
+          console.error('❌ Token inválido o expirado. Vuelve a hacer "verde login".');
+          forceExit(1);
+          return;
+      }
+      
+      console.log(`📦 Empaquetando código local...`);
+      const zipPath = path.join(process.cwd(), '.verde_build.zip');
+      const output = fs.createWriteStream(zipPath);
+      const archive = archiver('zip', { zlib: { level: 9 } });
+
+      output.on('close', async () => {
+          const stats = fs.statSync(zipPath);
+          const fileSizeInMB = stats.size / (1024 * 1024);
+          
+          if (fileSizeInMB > 10) {
+              console.error(`❌ El archivo empaquetado es demasiado grande (${fileSizeInMB.toFixed(2)} MB). Límite de 10 MB excedido.`);
+              fs.unlinkSync(zipPath);
+              forceExit(1);
+              return;
+          }
+
+          console.log(`✅ Archivo comprimido (${stats.size} bytes).`);
+          console.log(`☁️ Subiendo a Supabase Storage...`);
+          
+          const timestamp = Date.now();
+          const storagePath = `${user.id}/${projectConfig.project_id}/${timestamp}.zip`;
+          
+          const zipBuffer = fs.readFileSync(zipPath);
+          
+          const { error: uploadError } = await authClient.storage
+              .from('verde-repositories')
+              .upload(storagePath, zipBuffer, {
+                  contentType: 'application/zip',
+                  upsert: true
+              });
+
+          if (uploadError) {
+              console.error(`❌ Error al subir al Storage: ${uploadError.message}`);
+              fs.unlinkSync(zipPath);
+              forceExit(1);
+              return;
+          }
+
+          console.log(`📝 Registrando commit: "${message}"`);
+          
+          const { error: dbError } = await authClient
+              .from('verde_commits')
+              .insert([
+                  { 
+                      project_id: projectConfig.project_id, 
+                      author_id: user.id, 
+                      message: message,
+                      storage_path: storagePath
+                  }
+              ]);
+
+          if (dbError) {
+              console.error(`❌ Error al registrar commit: ${dbError.message}`);
+          } else {
+              console.log(`🎉 Push completado con éxito.`);
+          }
+          
+          fs.unlinkSync(zipPath); // Limpiar
+          process.exit(0);
+      });
+
+      archive.on('error', (err) => {
+          throw err;
+      });
+
+      archive.pipe(output);
+      // Solo subir archivos seguros y evitar node_modules y multimedia
+      archive.glob('**/*.{lua,luau,json,txt,md,toml}', {
+          ignore: ['node_modules/**', '.git/**', '.verde/**', '.verde_build.zip']
+      });
+      archive.finalize();
+  });
+
+program.parse(process.argv);

package/converters.js

@@ -0,0 +1,375 @@
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+// ---------------------------------------------------------------------------
+// Known Roblox services that map as root containers
+// ---------------------------------------------------------------------------
+const ROOT_SERVICES = [
+    'Workspace', 'Players', 'Lighting', 'MaterialService',
+    'ReplicatedFirst', 'ReplicatedStorage', 'ServerScriptService', 'ServerStorage',
+    'StarterGui', 'StarterPack', 'StarterPlayer',
+    'SoundService', 'Chat', 'TextChatService', 'LocalizationService', 'TestService'
+];
+
+// Sub-services that live inside StarterPlayer (Phase 1 - Bug #2)
+const STARTER_PLAYER_CHILDREN = ['StarterPlayerScripts', 'StarterCharacterScripts'];
+
+// Known file extensions (order matters — longest first so we match greedily)
+const KNOWN_EXTENSIONS = [
+    '.server.lua', '.server.luau',
+    '.client.lua', '.client.luau',
+    '.model.json', '.meta.json',
+    '.lua', '.luau',
+    '.txt', '.json'
+];
+
+// Phase 2 - #5: More instance types via model.json
+const VALUE_CLASSES = {
+    IntValue: 'number',
+    NumberValue: 'number',
+    BoolValue: 'boolean',
+    StringValue: 'string',
+    Color3Value: 'color3',
+};
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function stripExtension(filename) {
+    for (const ext of KNOWN_EXTENSIONS) {
+        if (filename.endsWith(ext)) {
+            return filename.slice(0, -ext.length);
+        }
+    }
+    const lastDot = filename.lastIndexOf('.');
+    return lastDot > 0 ? filename.slice(0, lastDot) : filename;
+}
+
+function getMetaProperties(metaFilePath) {
+    if (fs.existsSync(metaFilePath)) {
+        try {
+            return JSON.parse(fs.readFileSync(metaFilePath, 'utf8'));
+        } catch (e) {
+            console.error(`[WARN] Error parsing meta file ${metaFilePath}:`, e.message);
+        }
+    }
+    return {};
+}
+
+function determineScriptType(filename) {
+    if (filename.endsWith('.server.lua') || filename.endsWith('.server.luau')) return 'Script';
+    if (filename.endsWith('.client.lua') || filename.endsWith('.client.luau')) return 'LocalScript';
+    if (filename.endsWith('.lua') || filename.endsWith('.luau')) return 'ModuleScript';
+    return null;
+}
+
+// Phase 4 - #7: File checksum
+function fileChecksum(filePath) {
+    try {
+        const content = fs.readFileSync(filePath, 'utf8');
+        return crypto.createHash('md5').update(content).digest('hex');
+    } catch {
+        return null;
+    }
+}
+
+// ---------------------------------------------------------------------------
+// JSON → Lua table conversion
+// ---------------------------------------------------------------------------
+function jsonToLuaTable(value, indent) {
+    indent = indent || 0;
+    const pad = '\t'.repeat(indent);
+    const padInner = '\t'.repeat(indent + 1);
+
+    if (value === null || value === undefined) return 'nil';
+    if (typeof value === 'boolean') return value ? 'true' : 'false';
+    if (typeof value === 'number') return String(value);
+    if (typeof value === 'string') {
+        const escaped = value.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n').replace(/\r/g, '\\r');
+        return `"${escaped}"`;
+    }
+    if (Array.isArray(value)) {
+        if (value.length === 0) return '{}';
+        const items = value.map(v => `${padInner}${jsonToLuaTable(v, indent + 1)}`);
+        return `{\n${items.join(',\n')}\n${pad}}`;
+    }
+    if (typeof value === 'object') {
+        const keys = Object.keys(value);
+        if (keys.length === 0) return '{}';
+        const entries = keys.map(k => {
+            const luaKey = /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(k) ? k : `["${k}"]`;
+            return `${padInner}${luaKey} = ${jsonToLuaTable(value[k], indent + 1)}`;
+        });
+        return `{\n${entries.join(',\n')}\n${pad}}`;
+    }
+    return 'nil';
+}
+
+// ---------------------------------------------------------------------------
+// File → Instance conversion
+// ---------------------------------------------------------------------------
+function convertFile(filePath) {
+    const filename = path.basename(filePath);
+    let content;
+    try {
+        content = fs.readFileSync(filePath, 'utf8');
+    } catch (e) {
+        console.error(`[WARN] Could not read file ${filePath}:`, e.message);
+        return null;
+    }
+
+    const name = stripExtension(filename);
+
+    let instance = {
+        Name: name,
+        ClassName: 'Unknown',
+        Properties: {},
+        Children: []
+    };
+
+    if (filename.endsWith('.model.json')) {
+        try {
+            const parsed = JSON.parse(content);
+            instance.ClassName = parsed.ClassName || 'Folder';
+            instance.Properties = parsed.Properties || {};
+            if (parsed.Name) instance.Name = parsed.Name;
+            if (parsed.Children && Array.isArray(parsed.Children)) {
+                instance.Children = parsed.Children;
+            }
+        } catch (e) {
+            console.error(`[WARN] Error parsing model file ${filePath}:`, e.message);
+        }
+    } else if (filename.endsWith('.txt')) {
+        instance.ClassName = 'StringValue';
+        instance.Properties.Value = content;
+    } else if (filename.endsWith('.json') && !filename.endsWith('.meta.json')) {
+        try {
+            const parsed = JSON.parse(content);
+            instance.ClassName = 'ModuleScript';
+            instance.Properties.Source = `return ${jsonToLuaTable(parsed)}`;
+        } catch (e) {
+            console.error(`[WARN] Error parsing JSON data file ${filePath}:`, e.message);
+            instance.ClassName = 'ModuleScript';
+            instance.Properties.Source = `-- ERROR: Could not parse JSON\nreturn nil`;
+        }
+    } else {
+        const scriptType = determineScriptType(filename);
+        if (scriptType) {
+            instance.ClassName = scriptType;
+            instance.Properties.Source = content;
+        }
+    }
+
+    return instance;
+}
+
+// ---------------------------------------------------------------------------
+// Directory → Instance tree (recursive)
+// ---------------------------------------------------------------------------
+function processDirectory(dirPath, isRoot = false) {
+    const dirName = path.basename(dirPath);
+
+    let className = 'Folder';
+    if (isRoot && ROOT_SERVICES.includes(dirName)) {
+        className = dirName;
+    } else if (STARTER_PLAYER_CHILDREN.includes(dirName)) {
+        // Phase 1 - Bug #2: Identify these as their proper class
+        className = dirName;
+    }
+
+    let instance = {
+        Name: dirName,
+        ClassName: className,
+        Properties: {},
+        Children: []
+    };
+
+    let entries;
+    try {
+        entries = fs.readdirSync(dirPath, { withFileTypes: true });
+    } catch (e) {
+        console.error(`[WARN] Could not read directory ${dirPath}:`, e.message);
+        return instance;
+    }
+
+    // Handle init.lua / init.server.lua / init.client.lua
+    const initFile = entries.find(e =>
+        e.isFile() && e.name.startsWith('init.') &&
+        (e.name.endsWith('.lua') || e.name.endsWith('.luau'))
+    );
+    if (initFile) {
+        const scriptType = determineScriptType(initFile.name);
+        if (scriptType && instance.ClassName === 'Folder') {
+            instance.ClassName = scriptType;
+            try {
+                instance.Properties.Source = fs.readFileSync(path.join(dirPath, initFile.name), 'utf8');
+            } catch (e) {
+                console.error(`[WARN] Could not read init file:`, e.message);
+            }
+        }
+    }
+
+    // Handle meta.json inside the folder
+    const metaInside = entries.find(e => e.isFile() && e.name === 'meta.json');
+    if (metaInside) {
+        const metaProps = getMetaProperties(path.join(dirPath, 'meta.json'));
+        instance.Properties = { ...instance.Properties, ...metaProps };
+    }
+
+    // Process children
+    for (const entry of entries) {
+        if (entry.name === 'meta.json' || entry.name.endsWith('.meta.json') || entry.name.startsWith('init.')) {
+            continue;
+        }
+
+        const entryPath = path.join(dirPath, entry.name);
+
+        if (entry.isDirectory()) {
+            const childInstance = processDirectory(entryPath, false);
+            const metaFileOutside = entries.find(e => e.isFile() && e.name === `${entry.name}.meta.json`);
+            if (metaFileOutside) {
+                const metaProps = getMetaProperties(path.join(dirPath, metaFileOutside.name));
+                childInstance.Properties = { ...childInstance.Properties, ...metaProps };
+            }
+            instance.Children.push(childInstance);
+        } else if (entry.isFile()) {
+            const childInstance = convertFile(entryPath);
+            if (childInstance && childInstance.ClassName !== 'Unknown') {
+                const metaFileName = `${entry.name}.meta.json`;
+                const metaFile = entries.find(e => e.isFile() && e.name === metaFileName);
+                if (metaFile) {
+                    const metaProps = getMetaProperties(path.join(dirPath, metaFileName));
+                    childInstance.Properties = { ...childInstance.Properties, ...metaProps };
+                }
+                instance.Children.push(childInstance);
+            }
+        }
+    }
+
+    return instance;
+}
+
+// ---------------------------------------------------------------------------
+// Phase 4 - #7: Build checksums map for the entire project
+// ---------------------------------------------------------------------------
+function buildChecksums(dirPath, prefix = '') {
+    const checksums = {};
+    let entries;
+    try {
+        entries = fs.readdirSync(dirPath, { withFileTypes: true });
+    } catch {
+        return checksums;
+    }
+
+    for (const entry of entries) {
+        if (entry.name.endsWith('.conflict.bak') || entry.name.endsWith('.meta.json')) continue;
+        const entryPath = path.join(dirPath, entry.name);
+        const instancePath = prefix ? `${prefix}/${stripExtension(entry.name)}` : stripExtension(entry.name);
+
+        if (entry.isDirectory()) {
+            Object.assign(checksums, buildChecksums(entryPath, prefix ? `${prefix}/${entry.name}` : entry.name));
+        } else if (entry.isFile()) {
+            const checksum = fileChecksum(entryPath);
+            if (checksum) {
+                checksums[instancePath] = checksum;
+            }
+        }
+    }
+    return checksums;
+}
+
+// ---------------------------------------------------------------------------
+// Instance → File (inverse conversion for Studio → Disk)
+// ---------------------------------------------------------------------------
+function instanceToFile(instanceData) {
+    const name = instanceData.name || instanceData.Name || 'Untitled';
+    const className = instanceData.className || instanceData.ClassName || 'Folder';
+    const source = instanceData.source || (instanceData.Properties && instanceData.Properties.Source) || '';
+    const value = instanceData.value || (instanceData.Properties && instanceData.Properties.Value) || '';
+
+    if (className === 'Folder') {
+        return { fileName: name, content: null, isDirectory: true };
+    }
+    if (className === 'Script') {
+        return { fileName: `${name}.server.lua`, content: source, isDirectory: false };
+    }
+    if (className === 'LocalScript') {
+        return { fileName: `${name}.client.lua`, content: source, isDirectory: false };
+    }
+    if (className === 'ModuleScript') {
+        return { fileName: `${name}.lua`, content: source, isDirectory: false };
+    }
+    if (className === 'StringValue') {
+        return { fileName: `${name}.txt`, content: value, isDirectory: false };
+    }
+
+    // Phase 2 - #5: Value types and other instances → .model.json
+    if (VALUE_CLASSES[className] !== undefined) {
+        const modelData = { ClassName: className, Properties: { Value: value } };
+        return { fileName: `${name}.model.json`, content: JSON.stringify(modelData, null, 2), isDirectory: false };
+    }
+
+    // Generic instance → .model.json
+    const modelData = { ClassName: className, Properties: {} };
+    if (instanceData.Properties) {
+        modelData.Properties = { ...instanceData.Properties };
+    }
+    return { fileName: `${name}.model.json`, content: JSON.stringify(modelData, null, 2), isDirectory: false };
+}
+
+function filePathToInstancePath(filePath, projectRoot) {
+    let relative = path.relative(projectRoot, filePath).replace(/\\/g, '/');
+    const parts = relative.split('/');
+    if (parts.length > 0) {
+        const last = parts[parts.length - 1];
+        if (last.startsWith('init.') && (last.endsWith('.lua') || last.endsWith('.luau'))) {
+            parts.pop();
+        } else {
+            parts[parts.length - 1] = stripExtension(last);
+        }
+    }
+    return parts.join('/');
+}
+
+// ---------------------------------------------------------------------------
+// Phase 2 - #4: Project config loader
+// ---------------------------------------------------------------------------
+function loadProjectConfig(projectRoot) {
+    const configPath = path.join(projectRoot, 'verde.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
+    };
+
+    if (fs.existsSync(configPath)) {
+        try {
+            const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+            return { ...defaults, ...config };
+        } catch (e) {
+            console.error(`[WARN] Error parsing verde.project.json: ${e.message}`);
+        }
+    }
+    return defaults;
+}
+
+module.exports = {
+    ROOT_SERVICES,
+    STARTER_PLAYER_CHILDREN,
+    KNOWN_EXTENSIONS,
+    VALUE_CLASSES,
+    stripExtension,
+    determineScriptType,
+    jsonToLuaTable,
+    convertFile,
+    processDirectory,
+    buildChecksums,
+    instanceToFile,
+    filePathToInstancePath,
+    getMetaProperties,
+    loadProjectConfig,
+    fileChecksum,
+};

package/local-sync.js

@@ -0,0 +1,411 @@
+const express = require('express');
+const chokidar = require('chokidar');
+const path = require('path');
+const fs = require('fs');
+const {
+    processDirectory, convertFile, instanceToFile,
+    filePathToInstancePath, stripExtension, ROOT_SERVICES,
+    buildChecksums, loadProjectConfig,
+} = require('./converters');
+
+const app = express();
+
+// ---------------------------------------------------------------------------
+// Project root & config (Phase 2 - #4)
+// ---------------------------------------------------------------------------
+const targetDirArg = process.argv[2]
+    ? path.resolve(process.argv[2])
+    : path.join(__dirname, '..', 'test_project');
+const PROJECT_ROOT = targetDirArg;
+
+const projectConfig = loadProjectConfig(PROJECT_ROOT);
+const PORT = projectConfig.port || 34872;
+
+app.use(express.json({ limit: '50mb' }));
+
+// ---------------------------------------------------------------------------
+// ANSI color helpers
+// ---------------------------------------------------------------------------
+const c = {
+    green:   (t) => `\x1b[32m${t}\x1b[0m`,
+    red:     (t) => `\x1b[31m${t}\x1b[0m`,
+    yellow:  (t) => `\x1b[33m${t}\x1b[0m`,
+    cyan:    (t) => `\x1b[36m${t}\x1b[0m`,
+    magenta: (t) => `\x1b[35m${t}\x1b[0m`,
+    dim:     (t) => `\x1b[2m${t}\x1b[0m`,
+    bold:    (t) => `\x1b[1m${t}\x1b[0m`,
+};
+
+function logDisk(msg)    { console.log(`${c.cyan('[Disco]')}   ${msg}`); }
+function logStudio(msg)  { console.log(`${c.magenta('[Studio]')}  ${msg}`); }
+function logServer(msg)  { console.log(`${c.green('[Verde]')}   ${msg}`); }
+function logWarn(msg)    { console.log(`${c.yellow('[WARN]')}    ${msg}`); }
+function logError(msg)   { console.log(`${c.red('[ERROR]')}   ${msg}`); }
+function logConflict(msg){ console.log(`${c.red(c.bold('[CONFLICT]'))} ${msg}`); }
+
+// ---------------------------------------------------------------------------
+// Echo-Loop Prevention
+// ---------------------------------------------------------------------------
+const ignoreSet = new Set();
+const IGNORE_TTL_MS = 3000;
+
+function markIgnored(filePath) {
+    const normalized = path.resolve(filePath);
+    ignoreSet.add(normalized);
+    setTimeout(() => ignoreSet.delete(normalized), IGNORE_TTL_MS);
+}
+
+function isIgnored(filePath) {
+    return ignoreSet.has(path.resolve(filePath));
+}
+
+// ---------------------------------------------------------------------------
+// Conflict detection
+// ---------------------------------------------------------------------------
+const lastWriteTimestamps = new Map();
+
+function getTimestamps(filePath) {
+    const key = path.resolve(filePath);
+    if (!lastWriteTimestamps.has(key)) {
+        lastWriteTimestamps.set(key, { disk: 0, studio: 0 });
+    }
+    return lastWriteTimestamps.get(key);
+}
+
+function createConflictBackup(filePath) {
+    if (!fs.existsSync(filePath)) return;
+    const backupPath = filePath + '.conflict.bak';
+    try {
+        fs.copyFileSync(filePath, backupPath);
+        logConflict(`Backup guardado: ${path.basename(backupPath)}`);
+    } catch (e) {
+        logError(`No se pudo crear backup de conflicto: ${e.message}`);
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Long-polling state
+// ---------------------------------------------------------------------------
+let pendingChanges = [];
+let waitingClients = [];
+
+function pushChange(change) {
+    change.timestamp = Date.now();
+    pendingChanges.push(change);
+
+    while (waitingClients.length > 0) {
+        const clientRes = waitingClients.shift();
+        try {
+            clientRes.json([...pendingChanges]);
+        } catch { /* client may have disconnected */ }
+    }
+    pendingChanges = [];
+}
+
+// ---------------------------------------------------------------------------
+// Incremental sync — enrich disk changes with instance data
+// ---------------------------------------------------------------------------
+function buildChangePayload(type, filePath) {
+    const instancePath = filePathToInstancePath(filePath, PROJECT_ROOT);
+
+    if (type === 'Removed') {
+        return { type: 'Removed', instancePath, timestamp: Date.now() };
+    }
+
+    let data = null;
+    try {
+        const stat = fs.statSync(filePath);
+        if (stat.isDirectory()) {
+            data = processDirectory(filePath, ROOT_SERVICES.includes(path.basename(filePath)));
+        } else {
+            data = convertFile(filePath);
+        }
+    } catch (e) {
+        logWarn(`Could not read ${filePath}: ${e.message}`);
+    }
+
+    return { type, instancePath, data, timestamp: Date.now() };
+}
+
+// ---------------------------------------------------------------------------
+// Chokidar file watcher (Phase 2 - #4: uses project config ignore patterns)
+// ---------------------------------------------------------------------------
+const ignorePatterns = [
+    /(^|[\/\\])\../,           // dotfiles
+    /\.conflict\.bak$/,         // conflict backups
+    /node_modules/,
+];
+
+// Add user-defined ignore patterns from config
+if (projectConfig.ignore) {
+    for (const pattern of projectConfig.ignore) {
+        if (pattern.startsWith('*.')) {
+            const ext = pattern.slice(1).replace('.', '\\.');
+            ignorePatterns.push(new RegExp(`${ext}$`));
+        }
+    }
+}
+
+const watcher = chokidar.watch(PROJECT_ROOT, {
+    ignored: ignorePatterns,
+    persistent: true,
+    ignoreInitial: true,
+    awaitWriteFinish: {
+        stabilityThreshold: 300,
+        pollInterval: 100,
+    },
+});
+
+watcher
+    .on('add', filePath => {
+        if (isIgnored(filePath)) return;
+        logDisk(`Archivo creado: ${path.relative(PROJECT_ROOT, filePath)}`);
+        getTimestamps(filePath).disk = Date.now();
+        pushChange(buildChangePayload('Added', filePath));
+    })
+    .on('change', filePath => {
+        if (isIgnored(filePath)) return;
+        logDisk(`Archivo modificado: ${path.relative(PROJECT_ROOT, filePath)}`);
+        getTimestamps(filePath).disk = Date.now();
+        pushChange(buildChangePayload('Changed', filePath));
+    })
+    .on('unlink', filePath => {
+        if (isIgnored(filePath)) return;
+        logDisk(`Archivo eliminado: ${path.relative(PROJECT_ROOT, filePath)}`);
+        pushChange(buildChangePayload('Removed', filePath));
+        lastWriteTimestamps.delete(path.resolve(filePath));
+    })
+    .on('addDir', dirPath => {
+        if (isIgnored(dirPath)) return;
+        logDisk(`Carpeta creada: ${path.relative(PROJECT_ROOT, dirPath)}`);
+        pushChange(buildChangePayload('Added', dirPath));
+    })
+    .on('unlinkDir', dirPath => {
+        if (isIgnored(dirPath)) return;
+        logDisk(`Carpeta eliminada: ${path.relative(PROJECT_ROOT, dirPath)}`);
+        pushChange(buildChangePayload('Removed', dirPath));
+    });
+
+// ---------------------------------------------------------------------------
+// API Endpoints
+// ---------------------------------------------------------------------------
+
+app.get('/ping', (req, res) => {
+    res.json({
+        status: 'ok',
+        project: projectConfig.name || path.basename(PROJECT_ROOT),
+        version: '2.0.0',
+    });
+});
+
+app.get('/tree', (req, res) => {
+    try {
+        const tree = [];
+        if (fs.existsSync(PROJECT_ROOT)) {
+            const rootFolders = fs.readdirSync(PROJECT_ROOT, { withFileTypes: true });
+            for (const folder of rootFolders) {
+                if (folder.isDirectory()) {
+                    const subTree = processDirectory(path.join(PROJECT_ROOT, folder.name), true);
+                    tree.push(subTree);
+                }
+            }
+        }
+        logServer(`Árbol enviado (${tree.length} servicios)`);
+        res.json(tree);
+    } catch (err) {
+        logError(`Failed to generate tree: ${err.message}`);
+        res.status(500).json({ error: err.message });
+    }
+});
+
+app.get('/changes', (req, res) => {
+    if (pendingChanges.length > 0) {
+        const changesToSend = [...pendingChanges];
+        pendingChanges = [];
+        return res.json(changesToSend);
+    }
+
+    waitingClients.push(res);
+
+    const timeout = setTimeout(() => {
+        const index = waitingClients.indexOf(res);
+        if (index !== -1) {
+            waitingClients.splice(index, 1);
+            res.json([]);
+        }
+    }, 30000);
+
+    res.on('close', () => {
+        clearTimeout(timeout);
+        const index = waitingClients.indexOf(res);
+        if (index !== -1) {
+            waitingClients.splice(index, 1);
+        }
+    });
+});
+
+// Phase 4 - #7: Checksums endpoint for incremental diff
+app.get('/checksums', (req, res) => {
+    try {
+        const checksums = buildChecksums(PROJECT_ROOT);
+        res.json(checksums);
+    } catch (err) {
+        logError(`Failed to build checksums: ${err.message}`);
+        res.status(500).json({ error: err.message });
+    }
+});
+
+// ---------------------------------------------------------------------------
+// Sanitize filename helper
+// ---------------------------------------------------------------------------
+function sanitizeFileName(name) {
+    return name.replace(/[<>:"\/\\|?*\x00-\x1f]+/g, '_');
+}
+
+// ---------------------------------------------------------------------------
+// POST /studio-change — Studio reports changes to write to disk
+// ---------------------------------------------------------------------------
+app.post('/studio-change', (req, res) => {
+    const changes = req.body;
+
+    try {
+        if (!Array.isArray(changes)) {
+            return res.status(400).json({ error: 'Expected an array of changes' });
+        }
+
+        for (const change of changes) {
+            const pathParts = (change.path || '').split('/').filter(Boolean);
+            if (pathParts.length < 1) {
+                logWarn('Received change with empty path, skipping.');
+                continue;
+            }
+
+            logStudio(`${change.type} → ${change.path} (${change.className || '?'})`);
+
+            const fileInfo = instanceToFile(change);
+            const sanitizedParts = pathParts.map(sanitizeFileName);
+            const ancestorParts = sanitizedParts.slice(0, -1);
+            const parentDir = path.join(PROJECT_ROOT, ...ancestorParts);
+
+            let targetPath;
+            if (fileInfo.isDirectory) {
+                targetPath = path.join(parentDir, sanitizeFileName(fileInfo.fileName));
+            } else {
+                targetPath = path.join(parentDir, sanitizeFileName(fileInfo.fileName));
+            }
+
+            // Conflict detection
+            if ((change.type === 'Added' || change.type === 'Changed') && !fileInfo.isDirectory) {
+                const timestamps = getTimestamps(targetPath);
+                const now = Date.now();
+                if (timestamps.disk > 0 && (now - timestamps.disk) < 5000 && fs.existsSync(targetPath)) {
+                    logConflict(`${path.basename(targetPath)} editado en ambos lados.`);
+                    createConflictBackup(targetPath);
+                }
+                timestamps.studio = now;
+            }
+
+            // Execute the write
+            if (change.type === 'Added' || change.type === 'Changed') {
+                if (!fs.existsSync(parentDir)) {
+                    fs.mkdirSync(parentDir, { recursive: true });
+                }
+
+                if (fileInfo.isDirectory) {
+                    if (!fs.existsSync(targetPath)) {
+                        fs.mkdirSync(targetPath, { recursive: true });
+                    }
+                    logDisk(`Carpeta creada: ${path.relative(PROJECT_ROOT, targetPath)}`);
+                } else {
+                    markIgnored(targetPath);
+                    fs.writeFileSync(targetPath, fileInfo.content || '', 'utf8');
+                    logDisk(`Escrito: ${path.relative(PROJECT_ROOT, targetPath)}`);
+                }
+            } else if (change.type === 'Removed') {
+                let pathsToTry = [targetPath];
+                if (!fs.existsSync(targetPath)) {
+                    const baseName = sanitizeFileName(change.name || pathParts[pathParts.length - 1]);
+                    if (fs.existsSync(parentDir)) {
+                        const siblings = fs.readdirSync(parentDir);
+                        for (const sibling of siblings) {
+                            if (stripExtension(sibling) === baseName) {
+                                pathsToTry.push(path.join(parentDir, sibling));
+                            }
+                        }
+                    }
+                }
+
+                for (const p of pathsToTry) {
+                    if (fs.existsSync(p)) {
+                        markIgnored(p);
+                        fs.rmSync(p, { recursive: true, force: true });
+                        logDisk(`Eliminado: ${path.relative(PROJECT_ROOT, p)}`);
+                        break;
+                    }
+                }
+            } else if (change.type === 'Renamed') {
+                const oldParts = (change.oldPath || '').split('/').filter(Boolean).map(sanitizeFileName);
+                if (oldParts.length > 0) {
+                    const oldDir = path.join(PROJECT_ROOT, ...oldParts.slice(0, -1));
+                    const oldName = oldParts[oldParts.length - 1];
+                    if (fs.existsSync(oldDir)) {
+                        const siblings = fs.readdirSync(oldDir);
+                        for (const sibling of siblings) {
+                            if (stripExtension(sibling) === oldName) {
+                                const oldPath = path.join(oldDir, sibling);
+                                markIgnored(oldPath);
+                                markIgnored(targetPath);
+                                try {
+                                    fs.renameSync(oldPath, targetPath);
+                                    logDisk(`Renombrado: ${sibling} → ${fileInfo.fileName}`);
+                                } catch (e) {
+                                    logError(`Rename failed: ${e.message}`);
+                                }
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        res.json({ success: true });
+    } catch (e) {
+        logError(`Processing studio changes: ${e.message}`);
+        res.status(500).json({ error: e.message });
+    }
+});
+
+// ---------------------------------------------------------------------------
+// Graceful shutdown
+// ---------------------------------------------------------------------------
+function shutdown(signal) {
+    logServer(`${signal} recibido. Cerrando Verde...`);
+    watcher.close().then(() => {
+        logServer('File watcher cerrado.');
+        process.exit(0);
+    });
+}
+
+process.on('SIGINT', () => shutdown('SIGINT'));
+process.on('SIGTERM', () => shutdown('SIGTERM'));
+
+// ---------------------------------------------------------------------------
+// Start
+// ---------------------------------------------------------------------------
+function startServer() {
+    app.listen(PORT, () => {
+        console.log('');
+        console.log(c.bold(c.green('  ╔══════════════════════════════════════════╗')));
+        console.log(c.bold(c.green('  ║         🌿  VERDE SYNC v2.0  🌿        ║')));
+        console.log(c.bold(c.green('  ╚══════════════════════════════════════════╝')));
+        console.log('');
+        logServer(`Servidor en ${c.bold(`localhost:${PORT}`)}`);
+        logServer(`Proyecto: ${c.cyan(projectConfig.name)}`);
+        logServer(`Monitoreando: ${c.cyan(PROJECT_ROOT)}`);
+        logServer(`Esperando conexión de Roblox Studio...`);
+        console.log('');
+    });
+}
+
+module.exports = { startServer };

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "verde-sync",
+  "version": "1.0.0",
+  "description": "Bidirectional sync tool between PC and Roblox Studio",
+  "main": "local-sync.js",
+  "bin": {
+    "verde": "cli.js"
+  },
+  "scripts": {
+    "start": "node cli.js serve",
+    "test": "node test.js"
+  },
+  "dependencies": {
+    "@supabase/supabase-js": "^2.110.2",
+    "archiver": "^7.0.1",
+    "chokidar": "^3.6.0",
+    "commander": "^15.0.0",
+    "express": "^4.22.2"
+  }
+}

package/test.js

@@ -0,0 +1,28 @@
+const fs = require('fs');
+const path = require('path');
+const { processDirectory } = require('./converters');
+
+const TEST_DIR = path.join(__dirname, '..', 'test_project');
+
+function buildProjectTree() {
+    console.log(`Starting Phase 1 Test on ${TEST_DIR}...`);
+    
+    if (!fs.existsSync(TEST_DIR)) {
+        console.error("Test directory not found!");
+        return;
+    }
+
+    const projectTree = [];
+    const rootFolders = fs.readdirSync(TEST_DIR, { withFileTypes: true });
+
+    for (const folder of rootFolders) {
+        if (folder.isDirectory()) {
+            const tree = processDirectory(path.join(TEST_DIR, folder.name), true);
+            projectTree.push(tree);
+        }
+    }
+
+    console.log(JSON.stringify(projectTree, null, 2));
+}
+
+buildProjectTree();