goldsync 0.1.16 → 0.1.31

package/bin/install-companion.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
-import { spawn } from "node:child_process";
-import { access, copyFile, cp, mkdir, readFile, writeFile } from "node:fs/promises";
+import { execFile, spawn } from "node:child_process";
+import { access, copyFile, cp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import path from "node:path";
 import process from "node:process";
 import { fileURLToPath } from "node:url";
@@ -38,6 +38,33 @@ const configPath = configIndex === -1
 
 const dataDirectory = path.join(process.env.LOCALAPPDATA, "GoldSync");
 const runtimeDirectory = path.join(dataDirectory, "runtime");
+const installedAgent = path.join(runtimeDirectory, "bin", "goldsync-agent.mjs");
+const pidFile = path.join(dataDirectory, "agent.pid");
+let installedPid;
+try {
+  installedPid = Number(await readFile(pidFile, "utf8"));
+} catch (error) {
+  if (error.code !== "ENOENT") throw error;
+}
+if (Number.isInteger(installedPid) && installedPid > 0) {
+  const stopCommand = `
+$ErrorActionPreference = 'Stop'
+$agentProcess = Get-CimInstance Win32_Process -Filter "ProcessId = $env:GOLDSYNC_AGENT_PID"
+if ($agentProcess) {
+  if ((Split-Path -Parent $agentProcess.ExecutablePath) -ine $env:GOLDSYNC_RUNTIME_DIR -or $agentProcess.CommandLine.IndexOf($env:GOLDSYNC_AGENT_SCRIPT, [StringComparison]::OrdinalIgnoreCase) -lt 0) {
+    throw 'The recorded GoldSync process does not match the installed agent. No process was stopped.'
+  }
+  Stop-Process -Id $agentProcess.ProcessId
+}
+`;
+  await new Promise((resolve, reject) => {
+    execFile("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", stopCommand], {
+      windowsHide: true,
+      env: { ...process.env, GOLDSYNC_AGENT_PID: String(installedPid), GOLDSYNC_AGENT_SCRIPT: installedAgent, GOLDSYNC_RUNTIME_DIR: runtimeDirectory },
+    }, (error) => error ? reject(error) : resolve());
+  });
+  await rm(pidFile, { force: true });
+}
 await mkdir(path.join(runtimeDirectory, "bin"), { recursive: true });
 await cp(path.join(packageDirectory, "src"), path.join(runtimeDirectory, "src"), {
   recursive: true,
@@ -69,7 +96,6 @@ try {
 }
 
 const config = await registerProject(path.join(dataDirectory, "projects.json"), configPath);
-const installedAgent = path.join(runtimeDirectory, "bin", "goldsync-agent.mjs");
 const startupCommand = `"${runtimeNode}" "${installedAgent}"`;
 const vbsString = `"${startupCommand.replaceAll('"', '""')}"`;
 const startupFile = path.join(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "goldsync",
-  "version": "0.1.16",
+  "version": "0.1.31",
   "description": "Automatic native Roblox asset synchronization for Rojo projects.",
   "author": "tay",
   "license": "SEE LICENSE IN LICENSE.txt",
@@ -13,7 +13,7 @@
     "bin/goldsync-agent.mjs",
     "bin/install-companion.mjs",
     "LICENSE.txt",
-    "media/icon.png",
+    "media",
     "src",
     "README.md"
   ],

package/src/companion.mjs

@@ -26,7 +26,7 @@ function request(method, requestPath, body, port = BROKER_PORT) {
               }
             : {}),
         },
-        timeout: 2000,
+        timeout: requestPath === "/v1/workspaces/register" ? 120000 : 2000,
       },
       (response) => {
         const chunks = [];

package/src/config.mjs

@@ -76,8 +76,8 @@ export async function loadConfig(configPath) {
   const projectRoot = await realpath(path.dirname(absoluteConfigPath));
   const raw = JSON.parse(await readFile(absoluteConfigPath, "utf8"));
 
-  if (raw.version !== 1) {
-    throw new Error("goldsync.project.json must use version 1");
+  if (raw.version !== 1 && raw.version !== 2) {
+    throw new Error("goldsync.project.json must use version 1 or 2");
   }
   const port = raw.port ?? 34873;
   if (!Number.isInteger(port) || port < 1 || port > 65535) {
@@ -90,15 +90,16 @@ export async function loadConfig(configPath) {
     || raw.discoveryRoots.some((root) => !root || root.splitDepth === undefined))) {
     throw new Error("discoveryRoots must contain directory roots with splitDepth");
   }
-  const maxPathDepth = raw.maxPathDepth ?? 3;
-  if (!Number.isInteger(maxPathDepth) || maxPathDepth < 2 || maxPathDepth > 10) {
-    throw new Error("maxPathDepth must be an integer between 2 and 10");
+  const maxPathDepth = raw.maxPathDepth ?? (raw.version === 2 ? 32 : 3);
+  if (!Number.isInteger(maxPathDepth) || maxPathDepth < 2 || maxPathDepth > (raw.version === 2 ? 32 : 10)) {
+    throw new Error(`maxPathDepth must be an integer between 2 and ${raw.version === 2 ? 32 : 10}`);
   }
 
   const ids = new Set();
   const studioPaths = new Set();
   const files = new Set();
   const splitRoots = [];
+  const treeRoots = [];
   const roots = [...raw.roots, ...(raw.discoveryRoots ?? [])].flatMap((root, index) => {
     const label = index < raw.roots.length ? `roots[${index}]` : `discoveryRoots[${index - raw.roots.length}]`;
     const id = requireString(root.id, `${label}.id`);
@@ -121,6 +122,22 @@ export async function loadConfig(configPath) {
     }
     studioPaths.add(studioPathKey);
 
+    if (root.mode === "tree") {
+      if (raw.version !== 2 || root.file !== undefined || splitDepth !== undefined) {
+        throw new Error(`${label}: tree roots require version 2 and cannot specify file or splitDepth`);
+      }
+      const absoluteDirectory = resolveInsideProject(projectRoot, root.directory, `${label}.directory`);
+      if (root.containers !== undefined) throw new Error(`${label}: tree roots split Folders automatically; remove containers`);
+      treeRoots.push({
+        id, studioPath, absoluteDirectory,
+        directory: path.relative(projectRoot, absoluteDirectory).replaceAll(path.sep, "/"),
+      });
+      return [];
+    }
+    if (root.mode !== undefined) {
+      throw new Error(`${label}.mode must be tree when specified`);
+    }
+
     if (splitDepth !== undefined) {
       const directory = requireString(root.directory, `${label}.directory`);
       const absoluteDirectory = resolveInsideProject(projectRoot, directory, `${label}.directory`);
@@ -150,6 +167,21 @@ export async function loadConfig(configPath) {
   });
 
   const configuredRoots = [...roots, ...splitRoots];
+  for (const tree of treeRoots) {
+    for (const other of [...configuredRoots, ...treeRoots]) {
+      if (other === tree) continue;
+      const common = Math.min(tree.studioPath.length, other.studioPath.length);
+      if (tree.studioPath.slice(0, common).every((segment, index) => segment === other.studioPath[index])) {
+        throw new Error(`tree root ${tree.id} overlaps ${other.id}`);
+      }
+      const otherDirectory = other.absoluteDirectory ?? path.dirname(other.absoluteFile);
+      const relative = path.relative(tree.absoluteDirectory, otherDirectory);
+      const reverse = path.relative(otherDirectory, tree.absoluteDirectory);
+      if ((!relative.startsWith("..") && !path.isAbsolute(relative)) || (!reverse.startsWith("..") && !path.isAbsolute(reverse))) {
+        throw new Error(`tree directory ${tree.id} overlaps ${other.id}`);
+      }
+    }
+  }
   for (const root of roots) {
     if (configuredRoots.some((other) => other !== root
       && other.studioPath.length > root.studioPath.length
@@ -166,7 +198,7 @@ export async function loadConfig(configPath) {
   }
 
   return {
-    version: 1,
+    version: raw.version,
     name: requireString(raw.name, "name"),
     projectId: requireString(raw.projectId, "projectId"),
     workspaceId: createHash("sha256").update(absoluteConfigPath.toLowerCase()).digest("hex").slice(0, 12),
@@ -181,5 +213,6 @@ export async function loadConfig(configPath) {
     sessionMarkerFile: path.join(projectRoot, ".goldsync", "rojo-session.model.json"),
     roots,
     splitRoots,
+    treeRoots,
   };
 }

package/src/git-conflicts.mjs

@@ -61,7 +61,7 @@ export class GitConflictStore {
       return new Map();
     }
 
-    const output = await runGit(this.repositoryRoot, ["ls-files", "-u", "-z", "--", ...this.gitPaths.values()]);
+    const output = await runGit(this.repositoryRoot, ["ls-files", "-u", "-z"]);
     const byPath = new Map();
     for (const entry of output.toString("utf8").split("\0")) {
       if (!entry) {

package/src/server.mjs

@@ -1,16 +1,24 @@
 import { watch } from "node:fs";
+import { createHash } from "node:crypto";
 import { createServer } from "node:http";
 import path from "node:path";
 import { ConflictError } from "./store.mjs";
 
 const MAX_SNAPSHOT_BYTES = 128 * 1024 * 1024;
 
-function sendJson(response, status, value) {
+function sendJson(response, status, value, request) {
   const body = Buffer.from(JSON.stringify(value));
+  const etag = request ? `"${createHash("sha256").update(body).digest("hex")}"` : null;
+  if (etag && request.headers["if-none-match"] === etag) {
+    response.writeHead(304, { ETag: etag, "Cache-Control": "no-store" });
+    response.end();
+    return;
+  }
   response.writeHead(status, {
     "Content-Type": "application/json",
     "Content-Length": body.length,
     "Cache-Control": "no-store",
+    ...(etag ? { ETag: etag } : {}),
   });
   response.end(body);
 }
@@ -79,20 +87,21 @@ export class GoldSyncServer {
     for (const splitRoot of this.config.splitRoots ?? []) {
       watchedDirectories.set(splitRoot.absoluteDirectory, true);
     }
+    for (const treeRoot of this.config.treeRoots ?? []) {
+      watchedDirectories.set(treeRoot.absoluteDirectory, true);
+    }
     for (const [directory, recursive] of watchedDirectories) {
-      const watcher = watch(directory, { recursive }, (_event, filename) => {
+      const watcher = watch(directory, { recursive }, (event, filename) => {
+        if (recursive && (event === "rename" || !filename)) this.store.treeScanNeeded = true;
         if (!filename) {
           return;
         }
         const changedFile = path.join(directory, filename.toString()).toLowerCase();
-        let matched = false;
-        for (const root of this.store.getRoots()) {
-          if (root.absoluteFile.toLowerCase() === changedFile) {
-            matched = true;
-            this.scheduleRefresh(root.id);
-          }
-        }
-        if (!matched && recursive && path.extname(changedFile) === ".rbxm") {
+        const root = this.store.rootsByFile.get(changedFile);
+        if (root) this.scheduleRefresh(root.id);
+        if (!root && recursive && path.extname(changedFile) === ".rbxm") {
+          this.store.treeScanNeeded = true;
+          if ((this.config.treeRoots ?? []).length > 0) return;
           this.store
             .refreshSplitRoots()
             .then(() => this.gitConflicts?.syncRoots?.(this.store.getRoots()))
@@ -143,13 +152,51 @@ export class GoldSyncServer {
       sendJson(response, 409, { error: "this Studio place is not bound to the current Rojo session" });
       return;
     }
+    if (this.config.version === 2 && request.headers["x-goldsync-tree-roots"] !== "4") {
+      sendJson(response, 409, { error: "This project requires GoldSync 0.1.29 or newer. Update GoldSync and restart Studio." });
+      return;
+    }
     const url = new URL(request.url, `http://${this.config.host}:${this.config.port}`);
+    if (this.store.boundaryChange) {
+      sendJson(response, 409, { error: "Boundary conversion in progress; retry after it finishes" });
+      return;
+    }
+    const boundaryMatch = /^\/v1\/roots\/([a-z0-9-]+)\/boundary$/.exec(url.pathname);
+    if (request.method === "PUT" && boundaryMatch) {
+      if (!this.syncEnabled) { sendJson(response, 409, { error: "Connect Rojo before converting a boundary" }); return; }
+      const bytes = await readBody(request);
+      if (bytes.length < 4) throw new Error("Invalid boundary packet");
+      const headerLength = bytes.readUInt32LE();
+      if (headerLength > bytes.length - 4) throw new Error("Invalid boundary header");
+      const payload = JSON.parse(bytes.subarray(4, 4 + headerLength));
+      if (!Array.isArray(payload.entries) || payload.entries.length > 10000) throw new Error("Invalid boundary entries");
+      const conflicts = this.gitConflicts ? await this.gitConflicts.list() : new Map();
+      if (Object.keys(payload.expected ?? {}).some((id) => conflicts.has(id))) {
+        sendJson(response, 409, { error: "Resolve Git conflicts before converting the boundary" }); return;
+      }
+      let offset = 4 + headerLength;
+      for (const entry of payload.entries) {
+        if (!Number.isSafeInteger(entry.size) || entry.size < 0 || offset + entry.size > bytes.length) throw new Error("Invalid snapshot length");
+        entry.bytes = bytes.subarray(offset, offset + entry.size);
+        offset += entry.size;
+      }
+      if (offset !== bytes.length) throw new Error("Unexpected boundary packet data");
+      try {
+        const roots = await this.store.replaceBoundary(boundaryMatch[1], payload.entries, payload.expected);
+        this.gitConflicts?.syncRoots?.(this.store.getRoots());
+        sendJson(response, 200, { roots });
+      } catch (error) {
+        if (error instanceof ConflictError) { sendJson(response, 409, { error: "Files changed; refresh before converting" }); return; }
+        throw error;
+      }
+      return;
+    }
     if (request.method === "GET" && url.pathname === "/v1/config") {
       await this.store.refreshSplitRoots();
       this.gitConflicts?.syncRoots?.(this.store.getRoots());
       const conflicts = this.gitConflicts ? await this.gitConflicts.list() : new Map();
       sendJson(response, 200, {
-        version: 1,
+        version: this.config.version ?? 1,
         name: this.config.name,
         projectId: this.config.projectId,
         workspaceId: this.config.workspaceId,
@@ -157,6 +204,7 @@ export class GoldSyncServer {
         pollIntervalMs: this.config.pollIntervalMs,
         debounceMs: this.config.debounceMs,
         rojoConnected: this.syncEnabled,
+        treeRoots: (this.config.treeRoots ?? []).map((root) => ({ id: root.id, studioPath: root.studioPath })),
         splitRoots: (this.config.splitRoots ?? []).map((root) => ({
           id: root.id,
           studioPath: root.studioPath,
@@ -172,11 +220,58 @@ export class GoldSyncServer {
             conflictStages: conflict?.stages ?? null,
           };
         }),
-      });
+      }, request);
+      return;
+    }
+
+    if (request.method === "POST" && url.pathname === "/v1/snapshots") {
+      if (!this.syncEnabled) {
+        sendJson(response, 409, { error: "Snapshot downloads are paused until Rojo is connected" });
+        return;
+      }
+      const ids = JSON.parse((await readBody(request)).toString("utf8"));
+      if (!Array.isArray(ids) || ids.length > 50 || ids.some((id) => typeof id !== "string")) {
+        sendJson(response, 400, { error: "Expected at most 50 snapshot IDs" });
+        return;
+      }
+      const conflicts = this.gitConflicts ? await this.gitConflicts.list() : new Map();
+      const chunks = [];
+      let size = 0;
+      for (const id of ids) {
+        const manifest = this.store.getManifest(id);
+        if (conflicts.has(id) || !manifest.exists || manifest.size + size > 8 * 1024 * 1024) continue;
+        const snapshot = await this.store.get(id);
+        if (!snapshot || snapshot.bytes.length + size > 8 * 1024 * 1024) continue;
+        const header = Buffer.from(JSON.stringify({ id, hash: snapshot.hash, size: snapshot.bytes.length }));
+        if (size + snapshot.bytes.length + header.length + 4 > 8 * 1024 * 1024) continue;
+        const length = Buffer.alloc(4);
+        length.writeUInt32LE(header.length);
+        chunks.push(length, header, snapshot.bytes);
+        size += snapshot.bytes.length + header.length + 4;
+      }
+      const body = Buffer.concat(chunks);
+      response.writeHead(200, { "Content-Type": "application/octet-stream", "Content-Length": body.length, "Cache-Control": "no-store" });
+      response.end(body);
       return;
     }
 
     const splitMatch = /^\/v1\/splits\/([a-z0-9-]+)\/discover$/.exec(url.pathname);
+    const treeMatch = /^\/v1\/trees\/([a-z0-9-]+)\/discover$/.exec(url.pathname);
+    if (request.method === "POST" && treeMatch) {
+      if (!this.syncEnabled) {
+        sendJson(response, 409, { error: "Tree discovery is paused until Rojo is connected" });
+        return;
+      }
+      const payload = JSON.parse((await readBody(request)).toString("utf8"));
+      if (!Array.isArray(payload.entries) || payload.entries.length > 10000 || payload.entries.some((entry) => !entry || typeof entry !== "object")) {
+        sendJson(response, 400, { error: "entries must be an array with at most 10000 tree entries" });
+        return;
+      }
+      await this.store.discoverTreePaths(treeMatch[1], payload.entries);
+      this.gitConflicts?.syncRoots?.(this.store.getRoots());
+      sendJson(response, 200, { discovered: payload.entries.length });
+      return;
+    }
     if (request.method === "POST" && splitMatch) {
       const payload = JSON.parse((await readBody(request)).toString("utf8"));
       if (!Array.isArray(payload.paths) || payload.paths.length > 10000) {
@@ -252,7 +347,7 @@ export class GoldSyncServer {
       }
       const expectedHash = expectedHashHeader.replace(/^"|"$/g, "");
       try {
-        sendJson(response, 200, await this.store.delete(id, expectedHash));
+        sendJson(response, 200, await this.store.delete(id, expectedHash, request.headers["x-goldsync-plain-folder"] === "1"));
       } catch (error) {
         if (error instanceof ConflictError) {
           sendJson(response, 409, { error: error.message, current: error.current });