goldsync 0.1.16 → 0.1.34

package/bin/install-companion.mjs

@@ -1,15 +1,15 @@
 #!/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";
-import { findProjectConfig, registerProject } from "../src/companion.mjs";
+import { findProjectConfig, registerProject, restoreStudio } from "../src/companion.mjs";
 
 const command = process.argv[2];
 if (command === "--help" || command === "-h") {
-  console.log("Run 'goldsync install' from a repository containing goldsync.project.json.");
+  console.log("goldsync install\ngoldsync restore-studio --yes\nRun from your project folder. restore-studio replaces configured Studio roots with local files and discards their unsaved Studio changes.");
   process.exit(0);
 }
 if (command === "--version" || command === "-v") {
@@ -17,7 +17,7 @@ if (command === "--version" || command === "-v") {
   console.log(packageJson.version);
   process.exit(0);
 }
-if (command && command !== "install" && !command.startsWith("--")) {
+if (command && command !== "install" && command !== "restore-studio" && !command.startsWith("--")) {
   throw new Error(`Unknown GoldSync command: ${command}`);
 }
 
@@ -36,8 +36,41 @@ const configPath = configIndex === -1
   ? await findProjectConfig(projectDirectory)
   : path.resolve(process.argv[configIndex + 1]);
 
+if (command === "restore-studio") {
+  if (!process.argv.includes("--yes")) throw new Error("This replaces configured Studio roots and discards their unsaved changes. Run restore-studio --yes to proceed.");
+  await restoreStudio(configPath);
+  process.exit(0);
+}
+
 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 +102,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.34",
   "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/broker.mjs

@@ -237,7 +237,23 @@ export class GoldSyncBroker {
 
   async handle(request, response) {
     const url = new URL(request.url, `http://${this.host}:${this.port}`);
-    const managementRequest = MANAGEMENT_CLIENTS.has(request.headers["x-goldsync-client"]);
+    const managementRequest = request.headers.origin === undefined && MANAGEMENT_CLIENTS.has(request.headers["x-goldsync-client"]);
+    if (managementRequest && url.pathname === "/v1/workspaces/restore-studio") {
+      const body = request.method === "POST" ? await readJson(request) : null;
+      const runtime = this.workspaces.get(body?.workspaceId ?? url.searchParams.get("workspaceId"));
+      if (!runtime) { sendJson(response, 404, { error: "GoldSync project is not registered" }); return; }
+      if (request.method === "POST") {
+        if (body.confirm !== true) { sendJson(response, 400, { error: "restore-studio requires --yes" }); return; }
+        sendJson(response, 200, await runtime.server.beginRestore());
+      } else if (request.method === "GET") {
+        const status = runtime.server.restoreStatus();
+        if (!status || status.id !== url.searchParams.get("id")) { sendJson(response, 404, { error: "Restore operation no longer exists" }); return; }
+        sendJson(response, 200, status);
+      } else {
+        sendJson(response, 405, { error: "Method not allowed" });
+      }
+      return;
+    }
     if (managementRequest && request.method === "GET" && url.pathname === "/v1/health") {
       sendJson(response, 200, {
         version: 1,

package/src/companion.mjs

@@ -4,6 +4,7 @@ import http from "node:http";
 import path from "node:path";
 import { GoldSyncBroker } from "./broker.mjs";
 import { loadConfig } from "./config.mjs";
+import { setTimeout as delay } from "node:timers/promises";
 
 export const BROKER_PORT = 34873;
 export const HEARTBEAT_MS = 5000;
@@ -26,7 +27,7 @@ function request(method, requestPath, body, port = BROKER_PORT) {
               }
             : {}),
         },
-        timeout: 2000,
+        timeout: requestPath === "/v1/workspaces/register" || (method === "POST" && requestPath === "/v1/workspaces/restore-studio") ? 120000 : 2000,
       },
       (response) => {
         const chunks = [];
@@ -59,6 +60,20 @@ function request(method, requestPath, body, port = BROKER_PORT) {
   });
 }
 
+export async function restoreStudio(configPath) {
+  const workspace = await request("POST", "/v1/workspaces/register", { configPath, clientId: randomUUID() });
+  let job = await request("POST", "/v1/workspaces/restore-studio", { workspaceId: workspace.workspaceId, confirm: true });
+  console.log("Replacing configured Studio roots with local assets. Unsaved Studio changes in those roots will be removed.");
+  const deadline = Date.now() + 330000;
+  while (["pending", "running", "preparing"].includes(job.status)) {
+    if (Date.now() > deadline) throw new Error("Restore did not finish. Check Studio before retrying.");
+    await delay(500);
+    job = await request("GET", `/v1/workspaces/restore-studio?workspaceId=${encodeURIComponent(workspace.workspaceId)}&id=${encodeURIComponent(job.id)}`);
+  }
+  if (job.status !== "completed") throw new Error(job.error ?? "Studio restore failed");
+  console.log("Studio now matches the local asset files. Stale instances and previous sync state were removed.");
+}
+
 async function fileExists(file) {
   try {
     await access(file);

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/restore.mjs

@@ -0,0 +1,34 @@
+import { stat } from "node:fs/promises";
+import { SnapshotStore } from "./store.mjs";
+import { GitConflictStore } from "./git-conflicts.mjs";
+
+export async function prepareRestore(config) {
+  if (config.version !== 2 || !config.treeRoots?.length || config.roots.length || config.splitRoots?.length) {
+    throw new Error("restore-studio requires a project containing only version 2 tree roots");
+  }
+  for (const tree of config.treeRoots) {
+    if (!(await stat(tree.absoluteDirectory)).isDirectory()) throw new Error(`Missing asset directory: ${tree.directory}`);
+  }
+  const store = new SnapshotStore(config);
+  await store.initialize();
+  const conflicts = new GitConflictStore(config);
+  await conflicts.initialize();
+  conflicts.syncRoots(store.getRoots());
+  if ((await conflicts.list()).size) throw new Error("Resolve asset Git conflicts before restoring Studio");
+  const roots = store.getManifests();
+  roots.sort((left, right) => left.studioPath.length - right.studioPath.length || left.id.localeCompare(right.id));
+  const chunks = [];
+  let size = 0;
+  for (const root of roots) {
+    const snapshot = await store.get(root.id);
+    if (root.exists && (!snapshot || snapshot.hash !== root.hash)) throw new Error(`File changed during restore preparation: ${root.file}`);
+    root.size = snapshot?.bytes.length ?? 0;
+    if (snapshot) chunks.push(snapshot.bytes);
+    size += root.size;
+    if (size > 128 * 1024 * 1024) throw new Error("Restore exceeds the 128 MiB limit");
+  }
+  const header = Buffer.from(JSON.stringify({ roots, trees: config.treeRoots.map(({ id, studioPath }) => ({ id, studioPath })) }));
+  const length = Buffer.alloc(4);
+  length.writeUInt32LE(header.length);
+  return { store, packet: Buffer.concat([length, header, ...chunks]) };
+}

package/src/server.mjs

@@ -1,16 +1,25 @@
 import { watch } from "node:fs";
+import { createHash, randomUUID } from "node:crypto";
 import { createServer } from "node:http";
 import path from "node:path";
 import { ConflictError } from "./store.mjs";
+import { prepareRestore } from "./restore.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);
 }
@@ -58,9 +67,50 @@ export class GoldSyncServer {
   }
 
   setSessionToken(token) {
+    if (token !== this.sessionToken && this.restoreJob) {
+      this.restoreJob.status = "failed";
+      this.restoreJob.error = "Rojo session changed; run restore-studio again";
+      this.restoreJob.packet = null;
+      this.restoreJob.store = null;
+    }
+    if (token !== this.sessionToken) this.lastRestoreClient = null;
     this.sessionToken = token;
   }
 
+  restoreStatus() {
+    const job = this.restoreJob;
+    if (!job) return null;
+    if ((job.status === "pending" && Date.now() - job.createdAt > 15000)
+      || (job.status === "running" && Date.now() - job.createdAt > 300000)) {
+      job.status = "failed";
+      job.error = "Studio restore timed out. Check Studio, update the plugin and reconnect before retrying.";
+      job.packet = null;
+      job.store = null;
+    }
+    return { id: job.id, status: job.status, error: job.error };
+  }
+
+  async beginRestore() {
+    if (!this.syncEnabled || !this.sessionToken) throw new Error("Connect Studio through Rojo before restoring");
+    if (!this.lastRestoreClient || Date.now() - this.lastRestoreClient > 10000) throw new Error("Open Studio with GoldSync 0.1.34 or newer and connect Rojo first");
+    if (this.store.boundaryChange || ["preparing", "pending", "running"].includes(this.restoreStatus()?.status)) throw new Error("A sync operation is already running");
+    const job = { id: randomUUID(), status: "preparing", createdAt: Date.now() };
+    this.restoreJob = job;
+    try {
+      Object.assign(job, await prepareRestore(this.config));
+      if (job.status !== "preparing") throw new Error("Rojo session changed while preparing restore");
+      job.status = "pending";
+      job.createdAt = Date.now();
+    } catch (error) {
+      job.status = "failed";
+      job.error = error.message;
+      job.packet = null;
+      job.store = null;
+      throw error;
+    }
+    return this.restoreStatus();
+  }
+
   async start(options = {}) {
     if (options.listen !== false) {
       await new Promise((resolve, reject) => {
@@ -79,20 +129,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 +194,91 @@ 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 (request.headers["x-goldsync-restore"] === "1") this.lastRestoreClient = Date.now();
+    const restoreMatch = /^\/v1\/restore\/([a-f0-9-]+)\/(claim|commit|result)$/.exec(url.pathname);
+    if (request.method === "POST" && restoreMatch) {
+      const job = this.restoreJob;
+      const status = this.restoreStatus();
+      if (job?.id === restoreMatch[1] && restoreMatch[2] === "result" && ["completed", "failed"].includes(status.status)) {
+        sendJson(response, 200, status); return;
+      }
+      if (!this.syncEnabled || !job || job.id !== restoreMatch[1] || !["pending", "running"].includes(status.status)) {
+        sendJson(response, 409, { error: "Restore is no longer active" }); return;
+      }
+      if (restoreMatch[2] === "claim") {
+        if (job.status !== "pending") { sendJson(response, 409, { error: "Restore was already claimed" }); return; }
+        job.status = "running";
+        job.createdAt = Date.now();
+        response.writeHead(200, { "Content-Type": "application/octet-stream", "Content-Length": job.packet.length });
+        response.end(job.packet);
+        return;
+      }
+      if (job.status !== "running") { sendJson(response, 409, { error: "Claim the restore first" }); return; }
+      if (restoreMatch[2] === "result") {
+        const result = JSON.parse((await readBody(request)).toString("utf8"));
+        if (typeof result.success !== "boolean") { sendJson(response, 400, { error: "Expected restore result" }); return; }
+        job.status = result.success ? "completed" : "failed";
+        job.error = result.success ? undefined : String(result.error ?? "Studio restore failed").slice(0, 2000);
+        if (result.success) {
+          this.store = job.store;
+          this.store.treeScanNeeded = true;
+          this.gitConflicts?.syncRoots(this.store.getRoots());
+        }
+        job.packet = null;
+        job.store = null;
+      }
+      sendJson(response, 200, this.restoreStatus());
+      return;
+    }
+    const restore = this.restoreStatus();
+    if (["preparing", "pending", "running"].includes(restore?.status) && url.pathname !== "/v1/config") {
+      sendJson(response, 409, { error: "Authoritative Studio restore in progress" }); return;
+    }
+    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 +286,8 @@ export class GoldSyncServer {
         pollIntervalMs: this.config.pollIntervalMs,
         debounceMs: this.config.debounceMs,
         rojoConnected: this.syncEnabled,
+        restore,
+        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 +303,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 +430,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 });