roport 2.0.0 → 2.0.1

package/dist/index.js

@@ -443,21 +443,21 @@ var require_PathUtils = __commonJS({
     exports2.PathUtils = void 0;
     var PathUtils = class {
       static SEPARATOR = "/";
-      static normalize(path5) {
-        return path5.replace(/\\/g, this.SEPARATOR);
+      static normalize(path10) {
+        return path10.replace(/\\/g, this.SEPARATOR);
       }
       static join(...parts) {
         return parts.map((p) => this.normalize(p)).join(this.SEPARATOR).replace(/\/+/g, this.SEPARATOR);
       }
-      static getParent(path5) {
-        const normalized = this.normalize(path5);
+      static getParent(path10) {
+        const normalized = this.normalize(path10);
         const lastIndex = normalized.lastIndexOf(this.SEPARATOR);
         if (lastIndex === -1)
           return "";
         return normalized.substring(0, lastIndex);
       }
-      static getName(path5) {
-        const normalized = this.normalize(path5);
+      static getName(path10) {
+        const normalized = this.normalize(path10);
         const lastIndex = normalized.lastIndexOf(this.SEPARATOR);
         return normalized.substring(lastIndex + 1);
       }
@@ -494,61 +494,564 @@ var require_dist = __commonJS({
 });
 
 // src/cli/index.ts
-var import_commander3 = require("commander");
+var import_commander4 = require("commander");
 
 // src/cli/build.ts
 var import_commander = require("commander");
-var import_path = __toESM(require("path"));
+var import_path3 = __toESM(require("path"));
+
+// src/build/Builder.ts
+var import_promises2 = __toESM(require("fs/promises"));
+var import_path2 = __toESM(require("path"));
+
+// src/schema/SchemaLoader.ts
+var import_axios = __toESM(require("axios"));
 var import_promises = __toESM(require("fs/promises"));
-var buildCommand = new import_commander.Command("build").description("Build the project into a Roblox Model/Place file").argument("[project]", "Path to project.json file", "default.project.json").option("-o, --output <path>", "Output file path", "game.rbxl").action(async (projectFile, options) => {
+var import_path = __toESM(require("path"));
+var SchemaLoader = class {
+  dumpUrl = "https://raw.githubusercontent.com/CloneTrooper1019/Roblox-Client-Tracker/roblox/API-Dump.json";
+  cachePath;
+  apiDump = null;
+  constructor(cacheDir) {
+    this.cachePath = import_path.default.join(cacheDir, "api-dump.json");
+  }
+  async load() {
+    try {
+      const data = await import_promises.default.readFile(this.cachePath, "utf-8");
+      this.apiDump = JSON.parse(data);
+      console.log("[Roport] Loaded API Dump from cache");
+    } catch (e) {
+      console.log("[Roport] Cache not found, fetching API Dump...");
+      await this.update();
+    }
+  }
+  async update() {
+    try {
+      const response = await import_axios.default.get(this.dumpUrl);
+      this.apiDump = response.data;
+      await import_promises.default.mkdir(import_path.default.dirname(this.cachePath), { recursive: true });
+      await import_promises.default.writeFile(this.cachePath, JSON.stringify(this.apiDump));
+      console.log("[Roport] API Dump updated and cached");
+    } catch (e) {
+      console.error("[Roport] Failed to fetch API Dump", e);
+    }
+  }
+  getDump() {
+    return this.apiDump;
+  }
+  getPropertyType(className, propName) {
+    if (!this.apiDump) return null;
+    let currentClass = className;
+    while (currentClass && currentClass !== "<<ROOT>>") {
+      const classDef = this.apiDump.Classes.find((c) => c.Name === currentClass);
+      if (!classDef) break;
+      const prop = classDef.Members.find((m) => m.Name === propName && m.MemberType === "Property");
+      if (prop) {
+        return prop.ValueType.Name;
+      }
+      currentClass = classDef.Superclass;
+    }
+    return null;
+  }
+  getEnumValue(enumName, itemName) {
+    if (!this.apiDump) return 0;
+    const enumDef = this.apiDump.Enums.find((e) => e.Name === enumName);
+    if (!enumDef) return 0;
+    const item = enumDef.Items.find((i) => i.Name === itemName);
+    return item ? item.Value : 0;
+  }
+};
+
+// src/codecs/Encoder/Vector3.ts
+function encodeVector3(name, val) {
+  const x = val?.v?.[0] ?? 0;
+  const y = val?.v?.[1] ?? 0;
+  const z = val?.v?.[2] ?? 0;
+  return `<Vector3 name="${name}">
+        <X>${x}</X>
+        <Y>${y}</Y>
+        <Z>${z}</Z>
+    </Vector3>`;
+}
+
+// src/codecs/Encoder/Vector2.ts
+function encodeVector2(name, val) {
+  const x = val?.v?.[0] ?? 0;
+  const y = val?.v?.[1] ?? 0;
+  return `<Vector2 name="${name}">
+        <X>${x}</X>
+        <Y>${y}</Y>
+    </Vector2>`;
+}
+
+// src/codecs/Encoder/CFrame.ts
+function encodeCFrame(name, val) {
+  const v = val?.v || [];
+  const x = v[0] ?? 0;
+  const y = v[1] ?? 0;
+  const z = v[2] ?? 0;
+  const r00 = v[3] ?? 1;
+  const r01 = v[4] ?? 0;
+  const r02 = v[5] ?? 0;
+  const r10 = v[6] ?? 0;
+  const r11 = v[7] ?? 1;
+  const r12 = v[8] ?? 0;
+  const r20 = v[9] ?? 0;
+  const r21 = v[10] ?? 0;
+  const r22 = v[11] ?? 1;
+  return `<CoordinateFrame name="${name}">
+        <X>${x}</X>
+        <Y>${y}</Y>
+        <Z>${z}</Z>
+        <R00>${r00}</R00>
+        <R01>${r01}</R01>
+        <R02>${r02}</R02>
+        <R10>${r10}</R10>
+        <R11>${r11}</R11>
+        <R12>${r12}</R12>
+        <R20>${r20}</R20>
+        <R21>${r21}</R21>
+        <R22>${r22}</R22>
+    </CoordinateFrame>`;
+}
+
+// src/codecs/Encoder/Color3.ts
+function encodeColor3(name, val) {
+  const r = val?.v?.[0] ?? 0;
+  const g = val?.v?.[1] ?? 0;
+  const b = val?.v?.[2] ?? 0;
+  return `<Color3 name="${name}">
+        <R>${r}</R>
+        <G>${g}</G>
+        <B>${b}</B>
+    </Color3>`;
+}
+
+// src/codecs/Encoder/UDim.ts
+function encodeUDim(name, val) {
+  const s = val?.v?.[0] ?? 0;
+  const o = val?.v?.[1] ?? 0;
+  return `<UDim name="${name}">
+        <S>${s}</S>
+        <O>${o}</O>
+    </UDim>`;
+}
+function encodeUDim2(name, val) {
+  const xs = val?.v?.[0] ?? 0;
+  const xo = val?.v?.[1] ?? 0;
+  const ys = val?.v?.[2] ?? 0;
+  const yo = val?.v?.[3] ?? 0;
+  return `<UDim2 name="${name}">
+        <XS>${xs}</XS>
+        <XO>${xo}</XO>
+        <YS>${ys}</YS>
+        <YO>${yo}</YO>
+    </UDim2>`;
+}
+
+// src/codecs/Encoder/Rect.ts
+function encodeRect(name, val) {
+  const x0 = val?.v?.[0] ?? 0;
+  const y0 = val?.v?.[1] ?? 0;
+  const x1 = val?.v?.[2] ?? 0;
+  const y1 = val?.v?.[3] ?? 0;
+  return `<Rect2D name="${name}">
+        <min>
+            <X>${x0}</X>
+            <Y>${y0}</Y>
+        </min>
+        <max>
+            <X>${x1}</X>
+            <Y>${y1}</Y>
+        </max>
+    </Rect2D>`;
+}
+
+// src/codecs/Encoder/NumberRange.ts
+function encodeNumberRange(name, val) {
+  const min = val?.v?.[0] ?? 0;
+  const max = val?.v?.[1] ?? 0;
+  return `<NumberRange name="${name}">${min} ${max}</NumberRange>`;
+}
+
+// src/codecs/Encoder/Ray.ts
+function encodeRay(name, val) {
+  const ox = val?.v?.[0] ?? 0;
+  const oy = val?.v?.[1] ?? 0;
+  const oz = val?.v?.[2] ?? 0;
+  const dx = val?.v?.[3] ?? 0;
+  const dy = val?.v?.[4] ?? 0;
+  const dz = val?.v?.[5] ?? 0;
+  return `<Ray name="${name}">
+        <origin>
+            <X>${ox}</X>
+            <Y>${oy}</Y>
+            <Z>${oz}</Z>
+        </origin>
+        <direction>
+            <X>${dx}</X>
+            <Y>${dy}</Y>
+            <Z>${dz}</Z>
+        </direction>
+    </Ray>`;
+}
+
+// src/codecs/Encoder/Enum.ts
+function encodeEnum(name, val, enumValue) {
+  const value = enumValue !== void 0 ? enumValue : 0;
+  return `<token name="${name}">${value}</token>`;
+}
+
+// src/build/Builder.ts
+var Builder = class {
+  constructor(rootPath) {
+    this.rootPath = rootPath;
+    this.schemaLoader = new SchemaLoader(import_path2.default.join(rootPath, ".roport", "cache"));
+  }
+  schemaLoader;
+  async build(outputPath) {
+    console.log(`[Builder] Starting build from ${this.rootPath}...`);
+    await this.schemaLoader.load();
+    const projectPath = import_path2.default.join(this.rootPath, "default.project.json");
+    let projectJson = null;
+    try {
+      const projectContent = await import_promises2.default.readFile(projectPath, "utf-8");
+      projectJson = JSON.parse(projectContent);
+    } catch {
+    }
+    let roots = [];
+    if (projectJson && projectJson.tree) {
+      console.log("[Builder] Found default.project.json");
+      for (const [key, value] of Object.entries(projectJson.tree)) {
+        if (key.startsWith("$")) continue;
+        const nodeDef = value;
+        const nodePath = nodeDef.$path ? import_path2.default.resolve(this.rootPath, nodeDef.$path) : null;
+        const className = nodeDef.$className || key;
+        if (nodePath) {
+          try {
+            const builtNode = await this.buildNode(nodePath);
+            if (builtNode) {
+              builtNode.className = className;
+              builtNode.name = key;
+              roots.push(builtNode);
+            }
+          } catch (e) {
+            console.warn(`[Builder] Missing path for ${key}: ${nodePath}`);
+          }
+        }
+      }
+    } else {
+      console.log("[Builder] using directory scan...");
+      const root = await this.buildNode(this.rootPath);
+      if (root) roots.push(root);
+    }
+    if (roots.length === 0) throw new Error("No buildable content found");
+    let xmlContent = `<roblox xmlns:xmime="http://www.w3.org/2005/05/xmlmime" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://www.roblox.com/roblox.xsd" version="4">
+`;
+    for (const root of roots) {
+      xmlContent += this.generateXmlInner(root, 1);
+    }
+    xmlContent += `</roblox>`;
+    await import_promises2.default.writeFile(outputPath, xmlContent);
+    console.log(`[Builder] Build written to ${outputPath}`);
+  }
+  async buildNode(dirPath) {
+    try {
+      await import_promises2.default.access(dirPath);
+    } catch {
+      return null;
+    }
+    const metaPath = import_path2.default.join(dirPath, "__meta.json");
+    let meta = {};
+    try {
+      const metaContent = await import_promises2.default.readFile(metaPath, "utf-8");
+      meta = JSON.parse(metaContent);
+    } catch (e) {
+      meta = {
+        class: "Folder",
+        name: import_path2.default.basename(dirPath),
+        properties: {}
+      };
+    }
+    const node = {
+      className: meta.class || "Folder",
+      name: meta.name || import_path2.default.basename(dirPath),
+      properties: meta.properties || {},
+      children: []
+    };
+    const entries = await import_promises2.default.readdir(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const entryPath = import_path2.default.join(dirPath, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name === ".roport_trash" || entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist" || entry.name === "out") continue;
+        const childNode = await this.buildNode(entryPath);
+        if (childNode) {
+          node.children.push(childNode);
+        }
+      } else if (entry.isFile()) {
+        if (entry.name.endsWith(".luau")) {
+          const scriptNode = await this.scriptToNode(entryPath);
+          if (scriptNode) node.children.push(scriptNode);
+        }
+      }
+    }
+    return node;
+  }
+  async scriptToNode(filePath) {
+    const name = import_path2.default.basename(filePath, ".luau").replace(/\.(server|client)$/, "");
+    let className = "ModuleScript";
+    if (filePath.endsWith(".server.luau")) className = "Script";
+    else if (filePath.endsWith(".client.luau")) className = "LocalScript";
+    const source = await import_promises2.default.readFile(filePath, "utf-8");
+    return {
+      className,
+      name,
+      properties: {
+        Source: source
+        // Special handling for XML needed
+      },
+      children: []
+    };
+  }
+  generateXml(node, indentLevel = 0) {
+    if (indentLevel === 0) {
+      let xml = `<roblox xmlns:xmime="http://www.w3.org/2005/05/xmlmime" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://www.roblox.com/roblox.xsd" version="4">
+`;
+      xml += this.generateXmlInner(node, 1);
+      xml += `</roblox>`;
+      return xml;
+    }
+    return this.generateXmlInner(node, indentLevel);
+  }
+  generateXmlInner(node, indentLevel) {
+    const indent = "  ".repeat(indentLevel);
+    let xml = `${indent}<Item class="${node.className}" referent="RBX${Math.random().toString(36).substr(2, 9)}">
+`;
+    xml += `${indent}  <Properties>
+`;
+    xml += `${indent}    <string name="Name">${node.name}</string>
+`;
+    for (const [propName, propValue] of Object.entries(node.properties)) {
+      if (propName === "Source") {
+        const safeSource = propValue.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+        xml += `${indent}    <ProtectedString name="Source">${safeSource}</ProtectedString>
+`;
+        continue;
+      }
+      const type = this.schemaLoader.getPropertyType(node.className, propName) || "string";
+      if (type === "Vector3") xml += `${indent}    ${encodeVector3(propName, propValue)}
+`;
+      else if (type === "Vector2") xml += `${indent}    ${encodeVector2(propName, propValue)}
+`;
+      else if (type === "CFrame") xml += `${indent}    ${encodeCFrame(propName, propValue)}
+`;
+      else if (type === "Color3") xml += `${indent}    ${encodeColor3(propName, propValue)}
+`;
+      else if (type === "UDim") xml += `${indent}    ${encodeUDim(propName, propValue)}
+`;
+      else if (type === "UDim2") xml += `${indent}    ${encodeUDim2(propName, propValue)}
+`;
+      else if (type === "Rect") xml += `${indent}    ${encodeRect(propName, propValue)}
+`;
+      else if (type === "NumberRange") xml += `${indent}    ${encodeNumberRange(propName, propValue)}
+`;
+      else if (type === "Ray") xml += `${indent}    ${encodeRay(propName, propValue)}
+`;
+      else if (type === "string") xml += `${indent}    <string name="${propName}">${propValue}</string>
+`;
+      else if (type === "bool") xml += `${indent}    <bool name="${propName}">${propValue}</bool>
+`;
+      else if (type === "double" || type === "float") xml += `${indent}    <float name="${propName}">${propValue}</float>
+`;
+      else if (type === "int" || type === "int64") xml += `${indent}    <int64 name="${propName}">${propValue}</int64>
+`;
+      else {
+        if (typeof propValue === "string" && propValue.startsWith("Enum.")) {
+          const parts = propValue.split(".");
+          if (parts.length === 3) {
+            const val = this.schemaLoader.getEnumValue(parts[1], parts[2]);
+            xml += `${indent}    ${encodeEnum(propName, propValue, val)}
+`;
+          }
+        }
+      }
+    }
+    xml += `${indent}  </Properties>
+`;
+    for (const child of node.children) {
+      xml += this.generateXmlInner(child, indentLevel + 1);
+    }
+    xml += `${indent}</Item>
+`;
+    return xml;
+  }
+};
+
+// src/cli/build.ts
+var buildCommand = new import_commander.Command("build").description("Build the project into a Roblox Model/Place file").argument("[dir]", "Project directory", ".").option("-o, --output <path>", "Output file path", "game.rbxmx").action(async (dir, options) => {
   const cwd = process.cwd();
-  const projectPath = import_path.default.resolve(cwd, projectFile);
-  const outputPath = import_path.default.resolve(cwd, options.output);
-  console.log(`[Roport] Building ${projectPath} to ${outputPath}...`);
+  const rootPath = import_path3.default.resolve(cwd, dir);
+  const outputPath = import_path3.default.resolve(cwd, options.output);
+  console.log(`[Roport] Building from ${rootPath} to ${outputPath}...`);
   try {
-    await import_promises.default.access(projectPath);
-  } catch {
-    console.error(`[Roport] Error: Project file not found at ${projectPath}`);
+    const builder = new Builder(rootPath);
+    await builder.build(outputPath);
+  } catch (e) {
+    console.error("[Roport] Build failed:", e);
     process.exit(1);
   }
-  console.log(`[Roport] Parsing project structure...`);
-  console.log(`[Roport] Compiling scripts...`);
-  console.log(`[Roport] Serializing to XML...`);
-  console.log(`[Roport] Build complete: ${outputPath}`);
 });
 
 // src/cli/serve.ts
 var import_commander2 = require("commander");
-var import_path4 = __toESM(require("path"));
+var import_path8 = __toESM(require("path"));
 
 // src/server/Server.ts
-var import_fs = __toESM(require("fs"));
+var import_path7 = __toESM(require("path"));
+var import_fs2 = __toESM(require("fs"));
 
 // src/net/ConnectionManager.ts
 var import_ws = require("ws");
 var import_events = require("events");
+var import_http = __toESM(require("http"));
+var import_express = __toESM(require("express"));
+var import_cors = __toESM(require("cors"));
+
+// src/ai/TreeSnapshot.ts
+var import_fs = __toESM(require("fs"));
+var import_path4 = __toESM(require("path"));
+var TreeSnapshot = class {
+  constructor(rootPath) {
+    this.rootPath = rootPath;
+  }
+  async generate() {
+    const nodes = [];
+    if (!import_fs.default.existsSync(this.rootPath)) return nodes;
+    const entries = import_fs.default.readdirSync(this.rootPath);
+    for (const entry of entries) {
+      const fullPath = import_path4.default.join(this.rootPath, entry);
+      if (entry.startsWith(".") || entry === "node_modules") continue;
+      if (import_fs.default.statSync(fullPath).isDirectory()) {
+        const node = await this.scanRecursive(fullPath);
+        if (node) {
+          nodes.push(node);
+        }
+      }
+    }
+    return nodes;
+  }
+  async scanRecursive(dirPath) {
+    const metaPath = import_path4.default.join(dirPath, "__meta.json");
+    let meta = {};
+    if (import_fs.default.existsSync(metaPath)) {
+      try {
+        meta = JSON.parse(import_fs.default.readFileSync(metaPath, "utf-8"));
+      } catch (e) {
+        console.warn(`[Roport] Bad meta at ${dirPath}`);
+      }
+    } else {
+      meta = { class: "Folder", name: import_path4.default.basename(dirPath), id: "implicit-" + import_path4.default.basename(dirPath) };
+    }
+    const node = {
+      name: meta.name || import_path4.default.basename(dirPath),
+      className: meta.class || "Folder",
+      id: meta.id || meta.guid || "gen-" + Math.random(),
+      properties: meta.properties,
+      children: [],
+      filePath: dirPath
+    };
+    const entries = import_fs.default.readdirSync(dirPath);
+    for (const entry of entries) {
+      const fullPath = import_path4.default.join(dirPath, entry);
+      if (entry.startsWith(".") || entry === "__meta.json") continue;
+      const stat = import_fs.default.statSync(fullPath);
+      if (stat.isDirectory()) {
+        const child = await this.scanRecursive(fullPath);
+        if (child) {
+          node.children?.push(child);
+        }
+      } else if (entry.endsWith(".luau")) {
+        const name = import_path4.default.basename(entry, ".luau").replace(/\.(server|client)$/, "");
+        let className = "ModuleScript";
+        if (entry.endsWith(".server.luau")) className = "Script";
+        else if (entry.endsWith(".client.luau")) className = "LocalScript";
+        node.children?.push({
+          name,
+          className,
+          id: "script-" + name,
+          // Placeholder ID
+          children: [],
+          filePath: fullPath
+        });
+      }
+    }
+    return node;
+  }
+};
+
+// src/net/ConnectionManager.ts
 var ConnectionManager = class extends import_events.EventEmitter {
   wss;
+  httpServer;
+  app;
   clients = /* @__PURE__ */ new Set();
   port = 34872;
-  constructor() {
+  messageQueue = [];
+  pollWaiters = [];
+  workspacePath;
+  constructor(workspacePath) {
     super();
+    this.workspacePath = workspacePath;
+    this.app = (0, import_express.default)();
+    this.config();
     this.startServer();
   }
+  config() {
+    this.app.use((0, import_cors.default)());
+    this.app.use(import_express.default.json({ limit: "50mb" }));
+    this.app.get("/", (req, res) => {
+      res.send("Roport Sync Server");
+    });
+    this.app.get("/status", (req, res) => {
+      res.json({ status: "running", version: "2.0.0" });
+    });
+    this.app.get("/tree", async (req, res) => {
+      const snapshot = new TreeSnapshot(this.workspacePath);
+      const tree = await snapshot.generate();
+      res.json(tree);
+    });
+    this.app.get("/api/poll", (req, res) => {
+      const messages = this.messageQueue;
+      const sending = [...this.messageQueue];
+      this.messageQueue = [];
+      res.json({ events: sending.map((x) => x.event) });
+    });
+    this.app.post("/api/push", (req, res) => {
+      try {
+        const event = req.body;
+        this.emit("event", event);
+        res.json({ success: true });
+      } catch (e) {
+        console.error(e);
+        res.status(500).json({ error: "Failed to process" });
+      }
+    });
+  }
   startServer() {
-    this.wss = new import_ws.WebSocketServer({ port: this.port });
-    this.wss.on("listening", () => {
-      console.log(`[Roport] WebSocket Server listening on port ${this.port}`);
+    this.httpServer = import_http.default.createServer(this.app);
+    this.wss = new import_ws.WebSocketServer({ server: this.httpServer });
+    this.httpServer.listen(this.port, () => {
+      console.log(`[Roport] Sync Server (HTTP/WS) listening on port ${this.port}`);
     });
     this.wss.on("connection", (ws) => {
-      console.log("[Roport] Client connected");
+      console.log("[Roport] Client connected (WS)");
       this.clients.add(ws);
       this.setupHeartbeat(ws);
       ws.on("message", (message) => {
         this.handleMessage(ws, message);
       });
       ws.on("close", () => {
-        console.log("[Roport] Client disconnected");
+        console.log("[Roport] Client disconnected (WS)");
         this.clients.delete(ws);
       });
       ws.on("error", (err) => {
@@ -581,43 +1084,8 @@ var ConnectionManager = class extends import_events.EventEmitter {
         client.send(payload);
       }
     });
-  }
-};
-
-// src/net/ApiServer.ts
-var import_express = __toESM(require("express"));
-var import_cors = __toESM(require("cors"));
-var ApiServer = class {
-  app;
-  port = 3e3;
-  // API port different from WS
-  constructor() {
-    this.app = (0, import_express.default)();
-    this.config();
-    this.routes();
-    this.start();
-  }
-  config() {
-    this.app.use((0, import_cors.default)());
-    this.app.use(import_express.default.json());
-  }
-  routes() {
-    this.app.get("/status", (req, res) => {
-      res.json({ status: "running", version: "0.1.0" });
-    });
-    this.app.get("/tree", async (req, res) => {
-      res.json([
-        { name: "Workspace", className: "Workspace", id: "workspace-guid", children: [
-          { name: "Baseplate", className: "Part", id: "bp-guid" }
-        ] },
-        { name: "ReplicatedStorage", className: "ReplicatedStorage", id: "rs-guid", children: [] }
-      ]);
-    });
-  }
-  start() {
-    this.app.listen(this.port, () => {
-      console.log(`[Roport] API Server running on http://localhost:${this.port}`);
-    });
+    if (this.messageQueue.length > 1e3) this.messageQueue.shift();
+    this.messageQueue.push({ id: Date.now().toString(), event });
   }
 };
 
@@ -643,7 +1111,7 @@ var FileWatcher = class extends import_events2.EventEmitter {
       persistent: true,
       ignoreInitial: true
     });
-    this.watcher.on("add", (path5) => this.emit("add", path5)).on("change", (path5) => this.emit("change", path5)).on("unlink", (path5) => this.emit("unlink", path5)).on("addDir", (path5) => this.emit("addDir", path5)).on("unlinkDir", (path5) => this.emit("unlinkDir", path5)).on("error", (error) => console.error(`[Roport] Watcher error: ${error}`));
+    this.watcher.on("add", (path10) => this.emit("add", path10)).on("change", (path10) => this.emit("change", path10)).on("unlink", (path10) => this.emit("unlink", path10)).on("addDir", (path10) => this.emit("addDir", path10)).on("unlinkDir", (path10) => this.emit("unlinkDir", path10)).on("error", (error) => console.error(`[Roport] Watcher error: ${error}`));
     console.log(`[Roport] FileWatcher started on ${this.rootPath}`);
   }
   close() {
@@ -655,26 +1123,26 @@ var FileWatcher = class extends import_events2.EventEmitter {
 var PathMapper = class {
   pathToGuid = /* @__PURE__ */ new Map();
   guidToPath = /* @__PURE__ */ new Map();
-  set(path5, guid) {
-    this.pathToGuid.set(path5, guid);
-    this.guidToPath.set(guid, path5);
+  set(path10, guid) {
+    this.pathToGuid.set(path10, guid);
+    this.guidToPath.set(guid, path10);
   }
-  removeByPath(path5) {
-    const guid = this.pathToGuid.get(path5);
+  removeByPath(path10) {
+    const guid = this.pathToGuid.get(path10);
     if (guid) {
-      this.pathToGuid.delete(path5);
+      this.pathToGuid.delete(path10);
       this.guidToPath.delete(guid);
     }
   }
   removeByGuid(guid) {
-    const path5 = this.guidToPath.get(guid);
-    if (path5) {
+    const path10 = this.guidToPath.get(guid);
+    if (path10) {
       this.guidToPath.delete(guid);
-      this.pathToGuid.delete(path5);
+      this.pathToGuid.delete(path10);
     }
   }
-  resolveGuid(path5) {
-    return this.pathToGuid.get(path5);
+  resolveGuid(path10) {
+    return this.pathToGuid.get(path10);
   }
   resolvePath(guid) {
     return this.guidToPath.get(guid);
@@ -684,16 +1152,16 @@ var PathMapper = class {
     await this.scanDir(rootPath);
   }
   async scanDir(dir) {
-    const fs4 = require("fs/promises");
-    const path5 = require("path");
+    const fs7 = require("fs/promises");
+    const path10 = require("path");
     try {
-      const entries = await fs4.readdir(dir, { withFileTypes: true });
+      const entries = await fs7.readdir(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path5.join(dir, entry.name);
-        if (entry.isDirectory()) {
+        const fullPath = path10.join(dir, entry.name);
+        if (entry.isDirectory() && !fullPath.includes("node_modules") && !fullPath.includes(".git") && !fullPath.includes(".roport_trash")) {
           try {
-            const metaPath = path5.join(fullPath, "__meta.json");
-            const metaContent = await fs4.readFile(metaPath, "utf-8");
+            const metaPath = path10.join(fullPath, "__meta.json");
+            const metaContent = await fs7.readFile(metaPath, "utf-8");
             const meta = JSON.parse(metaContent);
             if (meta.id) {
               this.set(fullPath, meta.id);
@@ -711,7 +1179,7 @@ var PathMapper = class {
 
 // src/sync/OpReconciler.ts
 var import_common = __toESM(require_dist());
-var import_path2 = __toESM(require("path"));
+var import_path5 = __toESM(require("path"));
 var OpReconciler = class {
   constructor(pathMapper) {
     this.pathMapper = pathMapper;
@@ -725,11 +1193,12 @@ var OpReconciler = class {
     const existingPath = this.pathMapper.resolvePath(meta.id);
     const isNew = !existingPath;
     if (isNew) {
-      const parentDir = import_path2.default.dirname(import_path2.default.dirname(filePath));
+      const parentDir = import_path5.default.dirname(import_path5.default.dirname(filePath));
       const parentGuid = this.pathMapper.resolveGuid(parentDir) || "NULL";
       ops.push({
         id: `op-${Date.now()}`,
         type: import_common.OpType.CreateInstance,
+        rev: meta.rev,
         payload: {
           guid: meta.id,
           className: meta.class,
@@ -738,11 +1207,12 @@ var OpReconciler = class {
           properties: meta.properties || {}
         }
       });
-      this.pathMapper.set(import_path2.default.dirname(filePath), meta.id);
+      this.pathMapper.set(import_path5.default.dirname(filePath), meta.id);
     } else {
       ops.push({
         id: `op-${Date.now()}`,
         type: import_common.OpType.SetProperties,
+        rev: meta.rev,
         payload: {
           guid: meta.id,
           properties: meta.properties || {}
@@ -751,11 +1221,28 @@ var OpReconciler = class {
     }
     return ops;
   }
+  reconcileScript(filePath, content) {
+    const dirPath = import_path5.default.dirname(filePath);
+    const guid = this.pathMapper.resolveGuid(dirPath);
+    if (!guid) {
+      return [];
+    }
+    return [{
+      id: `op-${Date.now()}`,
+      type: import_common.OpType.SetProperties,
+      payload: {
+        guid,
+        properties: {
+          Source: content
+        }
+      }
+    }];
+  }
 };
 
 // src/sync/Writer.ts
-var import_promises2 = __toESM(require("fs/promises"));
-var import_path3 = __toESM(require("path"));
+var import_promises3 = __toESM(require("fs/promises"));
+var import_path6 = __toESM(require("path"));
 var import_common2 = __toESM(require_dist());
 var Writer = class {
   constructor(rootPath, pathMapper) {
@@ -765,7 +1252,7 @@ var Writer = class {
   async applyOp(op) {
     switch (op.type) {
       case import_common2.OpType.SetProperties:
-        await this.handleSetProperties(op.payload);
+        await this.handleSetProperties(op.payload, op.baseRev);
         break;
       case import_common2.OpType.CreateInstance:
         await this.handleCreate(op.payload);
@@ -778,24 +1265,40 @@ var Writer = class {
         break;
     }
   }
-  async handleSetProperties(payload) {
+  async handleSetProperties(payload, baseRev) {
     const { guid, properties } = payload;
     const filePath = this.pathMapper.resolvePath(guid);
     if (!filePath) {
       console.warn(`[Writer] Unknown GUID ${guid} for SetProperties`);
       return;
     }
-    const metaPath = import_path3.default.join(filePath, "__meta.json");
+    const metaPath = import_path6.default.join(filePath, "__meta.json");
     try {
       let meta = {};
       try {
-        const content = await import_promises2.default.readFile(metaPath, "utf-8");
+        const content = await import_promises3.default.readFile(metaPath, "utf-8");
         meta = JSON.parse(content);
       } catch (e) {
       }
+      if (baseRev !== void 0 && meta.rev !== void 0) {
+        if (baseRev < meta.rev) {
+          console.warn(`[Writer] REJECTED write to ${guid}: Stale revision (Base: ${baseRev}, Curr: ${meta.rev})`);
+          return;
+        }
+      }
+      if ("Source" in properties) {
+        const scriptName = this.getScriptFileName(meta.class);
+        if (scriptName) {
+          const sourcePath = import_path6.default.join(filePath, scriptName);
+          await import_promises3.default.writeFile(sourcePath, properties.Source);
+          console.log(`[Writer] Updated Script Source: ${sourcePath}`);
+          delete properties.Source;
+        }
+      }
       meta.properties = { ...meta.properties, ...properties };
+      meta.rev = (meta.rev || 0) + 1;
       await this.writeMeta(metaPath, meta);
-      console.log(`[Writer] Updated ${metaPath}`);
+      console.log(`[Writer] Updated ${metaPath} (Rev: ${meta.rev})`);
     } catch (e) {
       console.error(`[Writer] Failed to write properties for ${guid}`, e);
     }
@@ -807,31 +1310,64 @@ var Writer = class {
       const resolved = this.pathMapper.resolvePath(parentGuid);
       if (resolved) parentPath = resolved;
     }
-    const dirPath = import_path3.default.join(parentPath, name);
+    const dirPath = import_path6.default.join(parentPath, name);
     try {
-      await import_promises2.default.mkdir(dirPath, { recursive: true });
+      await import_promises3.default.mkdir(dirPath, { recursive: true });
+      let props = properties || {};
+      if ("Source" in props) {
+        const scriptName = this.getScriptFileName(className);
+        if (scriptName) {
+          await import_promises3.default.writeFile(import_path6.default.join(dirPath, scriptName), props.Source);
+          props = { ...props };
+          delete props.Source;
+        }
+      }
       const meta = {
         id: guid,
         class: className,
         name,
-        properties: properties || {}
+        properties: props
       };
-      await this.writeMeta(import_path3.default.join(dirPath, "__meta.json"), meta);
+      await this.writeMeta(import_path6.default.join(dirPath, "__meta.json"), meta);
+      if (parentGuid) {
+        await this.updateParentOrder(parentGuid, guid, "add");
+      }
       this.pathMapper.set(dirPath, guid);
       console.log(`[Writer] Created ${dirPath}`);
     } catch (e) {
       console.error(`[Writer] Failed to create ${dirPath}`, e);
     }
   }
+  getScriptFileName(className) {
+    switch (className) {
+      case "Script":
+        return "source.server.luau";
+      case "LocalScript":
+        return "source.client.luau";
+      case "ModuleScript":
+        return "source.luau";
+      default:
+        return null;
+    }
+  }
   async handleDelete(payload) {
     const { guid } = payload;
     const filePath = this.pathMapper.resolvePath(guid);
     if (!filePath) return;
-    if (import_path3.default.relative(this.rootPath, filePath) === "") return;
+    if (import_path6.default.relative(this.rootPath, filePath) === "") return;
+    const parentDir = import_path6.default.dirname(filePath);
+    const parentGuid = this.pathMapper.resolveGuid(parentDir);
     try {
-      await import_promises2.default.rm(filePath, { recursive: true, force: true });
+      const trashRoot = import_path6.default.join(this.rootPath, ".roport_trash");
+      const trashDir = import_path6.default.join(trashRoot, Date.now().toString());
+      await import_promises3.default.mkdir(trashDir, { recursive: true });
+      const trashPath = import_path6.default.join(trashDir, import_path6.default.basename(filePath));
+      await import_promises3.default.rename(filePath, trashPath);
       this.pathMapper.removeByGuid(guid);
-      console.log(`[Writer] Deleted ${filePath}`);
+      if (parentGuid) {
+        await this.updateParentOrder(parentGuid, guid, "remove");
+      }
+      console.log(`[Writer] Soft deleted ${filePath} -> ${trashPath}`);
     } catch (e) {
       console.error(`[Writer] Failed to delete ${filePath}`, e);
     }
@@ -845,19 +1381,91 @@ var Writer = class {
       if (resolved) newParentPath = resolved;
     }
     if (!oldPath) return;
-    const dirName = import_path3.default.basename(oldPath);
-    const newPath = import_path3.default.join(newParentPath, dirName);
+    const oldParentDir = import_path6.default.dirname(oldPath);
+    const oldParentGuid = this.pathMapper.resolveGuid(oldParentDir);
+    const dirName = import_path6.default.basename(oldPath);
+    const newPath = import_path6.default.join(newParentPath, dirName);
     try {
-      await import_promises2.default.rename(oldPath, newPath);
+      await import_promises3.default.rename(oldPath, newPath);
       this.pathMapper.removeByGuid(guid);
       this.pathMapper.set(newPath, guid);
+      if (oldParentGuid) {
+        await this.updateParentOrder(oldParentGuid, guid, "remove");
+      }
+      if (newParentGuid) {
+        await this.updateParentOrder(newParentGuid, guid, "add");
+      }
       console.log(`[Writer] Moved ${oldPath} -> ${newPath}`);
     } catch (e) {
       console.error(`[Writer] Failed to move`, e);
     }
   }
-  async writeMeta(path5, data) {
-    await import_promises2.default.writeFile(path5, JSON.stringify(data, null, 2));
+  async writeMeta(path10, data) {
+    await import_promises3.default.writeFile(path10, JSON.stringify(data, null, 2));
+  }
+  async updateParentOrder(parentGuid, childGuid, operation) {
+    if (!parentGuid || parentGuid === "game" || parentGuid === "NULL") {
+      return;
+    }
+    const parentPath = this.pathMapper.resolvePath(parentGuid);
+    if (!parentPath) return;
+    const metaPath = import_path6.default.join(parentPath, "__meta.json");
+    try {
+      let meta = {};
+      try {
+        const content = await import_promises3.default.readFile(metaPath, "utf-8");
+        meta = JSON.parse(content);
+      } catch (e) {
+        return;
+      }
+      let order = meta.order || [];
+      if (operation === "add") {
+        if (!order.includes(childGuid)) {
+          order.push(childGuid);
+        }
+      } else if (operation === "remove") {
+        order = order.filter((id) => id !== childGuid);
+      }
+      meta.order = order;
+      meta.rev = (meta.rev || 0) + 1;
+      await this.writeMeta(metaPath, meta);
+    } catch (e) {
+      console.error(`[Writer] Failed to update order for ${parentGuid}`, e);
+    }
+  }
+};
+
+// src/server/ApiServer.ts
+var import_express2 = __toESM(require("express"));
+var import_cors2 = __toESM(require("cors"));
+var ApiServer = class {
+  app;
+  port = 3e3;
+  treeSnapshot;
+  constructor(workspacePath) {
+    this.app = (0, import_express2.default)();
+    this.app.use((0, import_cors2.default)());
+    this.app.use(import_express2.default.json());
+    this.treeSnapshot = new TreeSnapshot(workspacePath);
+    this.setupRoutes();
+  }
+  setupRoutes() {
+    this.app.get("/tree", async (req, res) => {
+      try {
+        const tree = await this.treeSnapshot.generate();
+        res.json(tree);
+      } catch (e) {
+        res.status(500).json({ error: "Failed to generate tree" });
+      }
+    });
+    this.app.get("/health", (req, res) => {
+      res.json({ status: "ok", version: "2.0.0" });
+    });
+  }
+  start() {
+    this.app.listen(this.port, () => {
+      console.log(`[ApiServer] Listening on http://localhost:${this.port}`);
+    });
   }
 };
 
@@ -865,28 +1473,38 @@ var Writer = class {
 var RoportServer = class {
   constructor(workspacePath) {
     this.workspacePath = workspacePath;
-    this.connectionManager = new ConnectionManager();
-    this.apiServer = new ApiServer();
+    this.connectionManager = new ConnectionManager(workspacePath);
     this.pathMapper = new PathMapper();
     this.fileWatcher = new FileWatcher(workspacePath);
     this.opReconciler = new OpReconciler(this.pathMapper);
     this.writer = new Writer(workspacePath, this.pathMapper);
+    this.apiServer = new ApiServer(workspacePath);
   }
   connectionManager;
-  apiServer;
   fileWatcher;
   pathMapper;
   opReconciler;
   writer;
+  apiServer;
   async start() {
     console.log(`[Roport] Starting server in ${this.workspacePath}`);
+    this.apiServer.start();
     console.log("[Roport] Rebuilding index...");
     await this.pathMapper.rebuildIndex(this.workspacePath);
+    this.fileWatcher.on("addDir", (dirPath) => {
+    });
+    this.fileWatcher.on("unlinkDir", (dirPath) => {
+      this.pathMapper.removeByPath(dirPath);
+    });
     this.fileWatcher.on("change", async (filePath) => {
       if (filePath.endsWith("__meta.json")) {
         try {
-          const content = import_fs.default.readFileSync(filePath, "utf-8");
+          const content = import_fs2.default.readFileSync(filePath, "utf-8");
           const meta = JSON.parse(content);
+          const dirPath = import_path7.default.dirname(filePath);
+          if (meta.id) {
+            this.pathMapper.set(dirPath, meta.id);
+          }
           const ops = this.opReconciler.reconcileMeta(filePath, meta);
           ops.forEach((op) => {
             this.connectionManager.broadcast({
@@ -898,6 +1516,20 @@ var RoportServer = class {
         } catch (e) {
           console.error(`[Roport] Failed to process meta change ${filePath}`, e);
         }
+      } else if (filePath.endsWith(".luau")) {
+        try {
+          const content = import_fs2.default.readFileSync(filePath, "utf-8");
+          const ops = this.opReconciler.reconcileScript(filePath, content);
+          ops.forEach((op) => {
+            this.connectionManager.broadcast({
+              channel: "dm",
+              topic: "events",
+              data: op
+            });
+          });
+        } catch (e) {
+          console.error(`[Roport] Failed to process script change ${filePath}`, e);
+        }
       }
     });
     this.connectionManager.on("event", async (event) => {
@@ -919,15 +1551,100 @@ var RoportServer = class {
 
 // src/cli/serve.ts
 var serveCommand = new import_commander2.Command("serve").description("Start the Roport sync server").argument("[dir]", "Project directory", ".").action(async (dir) => {
-  const workspacePath = import_path4.default.resolve(process.cwd(), dir);
+  const workspacePath = import_path8.default.resolve(process.cwd(), dir);
   const server = new RoportServer(workspacePath);
   await server.start();
   process.stdin.resume();
 });
 
+// src/cli/init.ts
+var import_commander3 = require("commander");
+var import_path9 = __toESM(require("path"));
+var import_promises4 = __toESM(require("fs/promises"));
+var initCommand = new import_commander3.Command("init").description("Initialize a new Roport project in the current directory").option("-f, --force", "Overwrite existing files", false).action(async (options) => {
+  const cwd = process.cwd();
+  console.log(`[Roport] Initializing project in ${cwd}...`);
+  const dirs = [
+    "src/Workspace",
+    "src/ReplicatedStorage",
+    "src/ServerScriptService",
+    "src/ServerStorage",
+    "src/StarterGui",
+    "src/StarterPack",
+    "src/StarterPlayer",
+    "src/Lighting",
+    "src/SoundService"
+  ];
+  try {
+    for (const dir of dirs) {
+      const fullPath = import_path9.default.join(cwd, dir);
+      await import_promises4.default.mkdir(fullPath, { recursive: true });
+    }
+    const projectJson = {
+      "name": import_path9.default.basename(cwd),
+      "tree": {
+        "$className": "DataModel",
+        "Workspace": {
+          "$className": "Workspace",
+          "$path": "src/Workspace"
+        },
+        "ReplicatedStorage": {
+          "$className": "ReplicatedStorage",
+          "$path": "src/ReplicatedStorage"
+        },
+        "ServerScriptService": {
+          "$className": "ServerScriptService",
+          "$path": "src/ServerScriptService"
+        },
+        "ServerStorage": {
+          "$className": "ServerStorage",
+          "$path": "src/ServerStorage"
+        },
+        "StarterGui": {
+          "$className": "StarterGui",
+          "$path": "src/StarterGui"
+        },
+        "StarterPack": {
+          "$className": "StarterPack",
+          "$path": "src/StarterPack"
+        },
+        "StarterPlayer": {
+          "$className": "StarterPlayer",
+          "$path": "src/StarterPlayer"
+        },
+        "Lighting": {
+          "$className": "Lighting",
+          "$path": "src/Lighting"
+        },
+        "SoundService": {
+          "$className": "SoundService",
+          "$path": "src/SoundService"
+        }
+      }
+    };
+    await import_promises4.default.writeFile(
+      import_path9.default.join(cwd, "default.project.json"),
+      JSON.stringify(projectJson, null, 2)
+    );
+    const gitignore = `
+node_modules/
+.roport_trash/
+*.rbxl
+*.rbxlx
+            `.trim();
+    await import_promises4.default.writeFile(import_path9.default.join(cwd, ".gitignore"), gitignore);
+    console.log("[Roport] Project initialized successfully!");
+    console.log('Run "roport serve" to start the sync server.');
+  } catch (e) {
+    console.error("[Roport] Failed to initialize project:", e);
+  }
+});
+
 // src/cli/index.ts
-var program = new import_commander3.Command();
-program.name("roport").description("Roport V2 CLI - AI-First Roblox Development").version("0.1.0");
+var program = new import_commander4.Command();
+program.name("roport").description("Roport V2 CLI - AI-First Roblox Development").version("2.0.0");
 program.addCommand(buildCommand);
 program.addCommand(serveCommand);
+program.addCommand(initCommand);
 program.parse(process.argv);
+//# sourceMappingURL=index.js.map