goldsync 0.1.11

package/bin/goldsync-agent.mjs

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+
+import { appendFile, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import process from "node:process";
+import { CompanionAgent } from "../src/companion.mjs";
+
+const dataDirectory = process.env.GOLDSYNC_DATA_DIRECTORY
+  ? path.resolve(process.env.GOLDSYNC_DATA_DIRECTORY)
+  : path.join(process.env.LOCALAPPDATA, "GoldSync");
+const pidFile = path.join(dataDirectory, "agent.pid");
+const logFile = path.join(dataDirectory, "agent.log");
+
+await mkdir(dataDirectory, { recursive: true });
+try {
+  const existingPid = Number(await readFile(pidFile, "utf8"));
+  if (Number.isInteger(existingPid)) {
+    process.kill(existingPid, 0);
+    process.exit(0);
+  }
+} catch {
+  // The previous agent is not running.
+}
+await writeFile(pidFile, String(process.pid));
+
+function log(message) {
+  appendFile(logFile, `[${new Date().toISOString()}] ${message}\n`).catch(() => {});
+}
+
+const agent = new CompanionAgent({
+  registryFile: path.join(dataDirectory, "projects.json"),
+  log,
+});
+try {
+  await agent.start();
+} catch (error) {
+  log(error.stack ?? error.message);
+  await rm(pidFile, { force: true });
+  throw error;
+}
+log("GoldSync companion started");
+
+let stopping = false;
+async function stop() {
+  if (stopping) {
+    return;
+  }
+  stopping = true;
+  await agent.stop();
+  await rm(pidFile, { force: true });
+}
+
+process.once("SIGINT", () => stop().then(() => process.exit(0)));
+process.once("SIGTERM", () => stop().then(() => process.exit(0)));

package/bin/install-companion.mjs

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+
+import { spawn } from "node:child_process";
+import { access, copyFile, cp, mkdir, readFile, 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";
+
+const command = process.argv[2];
+if (command === "--help" || command === "-h") {
+  console.log("Run 'goldsync install' from a repository containing goldsync.project.json.");
+  process.exit(0);
+}
+if (command === "--version" || command === "-v") {
+  const packageJson = JSON.parse(await readFile(new URL("../package.json", import.meta.url), "utf8"));
+  console.log(packageJson.version);
+  process.exit(0);
+}
+if (command && command !== "install" && !command.startsWith("--")) {
+  throw new Error(`Unknown GoldSync command: ${command}`);
+}
+
+if (process.platform !== "win32") {
+  throw new Error("The automatic GoldSync companion installer currently supports Windows only.");
+}
+if (!process.env.LOCALAPPDATA || !process.env.APPDATA) {
+  throw new Error("Windows application-data folders are unavailable.");
+}
+
+const packageDirectory = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const configIndex = process.argv.indexOf("--config");
+const projectIndex = process.argv.indexOf("--project");
+const projectDirectory = projectIndex === -1 ? process.cwd() : path.resolve(process.argv[projectIndex + 1]);
+const configPath = configIndex === -1
+  ? await findProjectConfig(projectDirectory)
+  : path.resolve(process.argv[configIndex + 1]);
+
+const dataDirectory = path.join(process.env.LOCALAPPDATA, "GoldSync");
+const runtimeDirectory = path.join(dataDirectory, "runtime");
+await mkdir(path.join(runtimeDirectory, "bin"), { recursive: true });
+await cp(path.join(packageDirectory, "src"), path.join(runtimeDirectory, "src"), {
+  recursive: true,
+  force: true,
+});
+await copyFile(path.join(packageDirectory, "bin", "goldsync-agent.mjs"), path.join(runtimeDirectory, "bin", "goldsync-agent.mjs"));
+await copyFile(path.join(packageDirectory, "package.json"), path.join(runtimeDirectory, "package.json"));
+const runtimeNode = path.join(runtimeDirectory, `node-${process.versions.node}.exe`);
+try {
+  await access(runtimeNode);
+} catch (error) {
+  if (error.code !== "ENOENT") {
+    throw error;
+  }
+  await copyFile(process.execPath, runtimeNode);
+}
+
+const pluginSource = path.join(packageDirectory, "assets", "GoldSync.rbxmx");
+const developmentPluginSource = path.join(packageDirectory, "extension", "assets", "GoldSync.rbxmx");
+const pluginDirectory = path.join(process.env.LOCALAPPDATA, "Roblox", "Plugins");
+await mkdir(pluginDirectory, { recursive: true });
+try {
+  await copyFile(pluginSource, path.join(pluginDirectory, "GoldSync.rbxmx"));
+} catch (error) {
+  if (error.code !== "ENOENT") {
+    throw error;
+  }
+  await copyFile(developmentPluginSource, path.join(pluginDirectory, "GoldSync.rbxmx"));
+}
+
+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(
+  process.env.APPDATA,
+  "Microsoft",
+  "Windows",
+  "Start Menu",
+  "Programs",
+  "Startup",
+  "GoldSync.vbs",
+);
+await mkdir(path.dirname(startupFile), { recursive: true });
+await writeFile(
+  startupFile,
+  `Set GoldSyncShell = CreateObject("WScript.Shell")\r\nGoldSyncShell.Run ${vbsString}, 0, False\r\n`,
+);
+
+spawn(runtimeNode, [installedAgent], {
+  detached: true,
+  stdio: "ignore",
+  windowsHide: true,
+}).unref();
+
+console.log(`GoldSync is installed for ${config.name}. Restart Roblox Studio once.`);

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "goldsync",
+  "version": "0.1.11",
+  "description": "Automatic native Roblox asset synchronization for Rojo projects.",
+  "author": "tay",
+  "license": "SEE LICENSE IN LICENSE.txt",
+  "type": "module",
+  "bin": {
+    "goldsync": "bin/install-companion.mjs"
+  },
+  "files": [
+    "assets/GoldSync.rbxmx",
+    "bin/goldsync-agent.mjs",
+    "bin/install-companion.mjs",
+    "LICENSE.txt",
+    "src",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "node --test",
+    "package:companion": "node scripts/package-companion.mjs",
+    "prepack": "node scripts/prepare-npm-package.mjs",
+    "postpack": "node scripts/cleanup-npm-package.mjs"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "os": [
+    "win32"
+  ],
+  "keywords": [
+    "roblox",
+    "rojo",
+    "rbxm",
+    "sync",
+    "zed",
+    "cursor"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/broker.mjs

@@ -0,0 +1,306 @@
+import { createServer } from "node:http";
+import { stat } from "node:fs/promises";
+import { loadConfig } from "./config.mjs";
+import { GitConflictStore } from "./git-conflicts.mjs";
+import { findRojoSession } from "./rojo-session.mjs";
+import { GoldSyncServer } from "./server.mjs";
+import { readSessionMarker, writeSessionMarker } from "./session-marker.mjs";
+import { SnapshotStore } from "./store.mjs";
+
+const MAX_MANAGEMENT_BODY_BYTES = 64 * 1024;
+const MANAGEMENT_CLIENTS = new Set(["vscode-extension", "goldsync-companion"]);
+
+function sendJson(response, status, value) {
+  const body = Buffer.from(JSON.stringify(value));
+  response.writeHead(status, {
+    "Content-Type": "application/json",
+    "Content-Length": body.length,
+    "Cache-Control": "no-store",
+  });
+  response.end(body);
+}
+
+async function readJson(request) {
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of request) {
+    size += chunk.length;
+    if (size > MAX_MANAGEMENT_BODY_BYTES) {
+      const error = new Error("management request is too large");
+      error.statusCode = 413;
+      throw error;
+    }
+    chunks.push(chunk);
+  }
+  return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+}
+
+class WorkspaceRuntime {
+  constructor(config, configPath, modifiedAt) {
+    this.config = config;
+    this.configPath = configPath;
+    this.modifiedAt = modifiedAt;
+    this.clients = new Map();
+    this.rojoConnected = false;
+    this.rojoPort = null;
+    this.rojoError = null;
+    this.checkingRojo = false;
+    this.conflictPinnedBy = null;
+  }
+
+  async start() {
+    this.sessionToken = await readSessionMarker(this.config.sessionMarkerFile);
+    if (this.sessionToken === null) {
+      await writeSessionMarker(this.config.sessionMarkerFile, "");
+    }
+    this.store = new SnapshotStore(this.config);
+    await this.store.initialize();
+    this.gitConflicts = new GitConflictStore(this.config);
+    await this.gitConflicts.initialize();
+    this.gitConflicts.syncRoots(this.store.getRoots());
+    this.server = new GoldSyncServer(this.config, this.store, this.gitConflicts);
+    this.server.setSessionToken(this.sessionToken);
+    this.server.setSyncEnabled(false);
+    await this.server.start({ listen: false });
+    await this.checkRojo();
+    this.rojoTimer = setInterval(() => this.checkRojo(), 750);
+  }
+
+  async checkRojo() {
+    if (this.checkingRojo) {
+      return;
+    }
+    this.checkingRojo = true;
+    try {
+      const session = await findRojoSession(this.config.rojo);
+      this.rojoConnected = session !== null && !session.ambiguous;
+      this.rojoPort = this.rojoConnected ? session.port : null;
+      this.rojoError = session?.ambiguous
+        ? `multiple Rojo sessions for ${this.config.rojo.projectName} are active on ports ${session.ports.join(", ")}`
+        : null;
+      if (this.rojoConnected) {
+        const sessionToken = `${this.config.projectId}:${session.sessionId}`;
+        if (sessionToken !== this.sessionToken) {
+          await writeSessionMarker(this.config.sessionMarkerFile, sessionToken);
+          this.sessionToken = sessionToken;
+          this.server.setSessionToken(sessionToken);
+        }
+      }
+    } catch (error) {
+      this.rojoConnected = false;
+      this.rojoPort = null;
+      this.rojoError = error.message;
+    }
+    this.server.setSyncEnabled(this.rojoConnected);
+    this.checkingRojo = false;
+  }
+
+  touch(clientId) {
+    this.clients.set(clientId, Date.now());
+  }
+
+  removeExpiredClients(cutoff) {
+    for (const [clientId, lastSeen] of this.clients) {
+      if (lastSeen < cutoff) {
+        this.clients.delete(clientId);
+      }
+    }
+  }
+
+  async stop() {
+    clearInterval(this.rojoTimer);
+    await this.server.stop();
+  }
+
+  async summary() {
+    const conflicts = [...(await this.gitConflicts.list()).values()].map((conflict) => ({
+      id: conflict.id,
+      file: conflict.file,
+      token: conflict.token,
+    }));
+    if (conflicts.length === 0) {
+      this.conflictPinnedBy = null;
+    }
+    return {
+      name: this.config.name,
+      projectId: this.config.projectId,
+      workspaceId: this.config.workspaceId,
+      configPath: this.configPath,
+      rojoConnected: this.rojoConnected,
+      rojoPort: this.rojoPort,
+      rojoError: this.rojoError,
+      conflictPinned: this.conflictPinnedBy !== null && this.clients.has(this.conflictPinnedBy),
+      conflicts,
+      clients: this.clients.size,
+    };
+  }
+
+  async pinConflicts(clientId) {
+    if (!this.clients.has(clientId)) {
+      const error = new Error("the requesting editor workspace is no longer registered");
+      error.statusCode = 403;
+      throw error;
+    }
+    if ((await this.gitConflicts.list()).size === 0) {
+      const error = new Error("this workspace no longer has GoldSync merge conflicts");
+      error.statusCode = 409;
+      throw error;
+    }
+    this.conflictPinnedBy = clientId;
+  }
+
+  isConflictPinned() {
+    return this.conflictPinnedBy !== null && this.clients.has(this.conflictPinnedBy);
+  }
+}
+
+export class GoldSyncBroker {
+  constructor(options = {}) {
+    this.host = options.host ?? "127.0.0.1";
+    this.port = options.port ?? 34873;
+    this.leaseMs = options.leaseMs ?? 15000;
+    this.workspaces = new Map();
+    this.server = createServer((request, response) => {
+      this.handle(request, response).catch((error) => {
+        sendJson(response, error.statusCode ?? 500, { error: error.message });
+      });
+    });
+  }
+
+  async start() {
+    await new Promise((resolve, reject) => {
+      this.server.once("error", reject);
+      this.server.listen(this.port, this.host, () => {
+        this.server.off("error", reject);
+        resolve();
+      });
+    });
+    this.reaper = setInterval(() => this.reap(), 5000);
+  }
+
+  async register(configPath, clientId) {
+    if (typeof configPath !== "string" || configPath.length === 0) {
+      throw new Error("configPath is required");
+    }
+    if (typeof clientId !== "string" || clientId.length === 0 || clientId.length > 128) {
+      throw new Error("clientId is required");
+    }
+
+    const modifiedAt = (await stat(configPath)).mtimeMs;
+    let runtime = [...this.workspaces.values()].find(
+      (candidate) => candidate.configPath.toLowerCase() === configPath.toLowerCase(),
+    );
+    if (runtime && runtime.modifiedAt === modifiedAt) {
+      runtime.touch(clientId);
+      this.lastRegistration = Date.now();
+      return runtime.summary();
+    }
+
+    const config = await loadConfig(configPath);
+    runtime = this.workspaces.get(config.workspaceId);
+    if (!runtime || runtime.modifiedAt !== modifiedAt) {
+      if (runtime) {
+        await runtime.stop();
+      }
+      runtime = new WorkspaceRuntime(config, configPath, modifiedAt);
+      await runtime.start();
+      this.workspaces.set(config.workspaceId, runtime);
+      console.log(`[GoldSync] registered ${config.name} (${config.workspaceId})`);
+    }
+    runtime.touch(clientId);
+    this.lastRegistration = Date.now();
+    return runtime.summary();
+  }
+
+  async reap() {
+    const cutoff = Date.now() - this.leaseMs;
+    for (const [workspaceId, runtime] of this.workspaces) {
+      runtime.removeExpiredClients(cutoff);
+      if (runtime.clients.size === 0) {
+        await runtime.stop();
+        this.workspaces.delete(workspaceId);
+        console.log(`[GoldSync] released ${runtime.config.name} (${workspaceId})`);
+      }
+    }
+  }
+
+  async stop() {
+    clearInterval(this.reaper);
+    for (const runtime of this.workspaces.values()) {
+      await runtime.stop();
+    }
+    this.workspaces.clear();
+    if (this.server.listening) {
+      await new Promise((resolve) => this.server.close(resolve));
+    }
+  }
+
+  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"]);
+    if (managementRequest && request.method === "GET" && url.pathname === "/v1/health") {
+      sendJson(response, 200, {
+        version: 1,
+        broker: true,
+        workspaces: await Promise.all([...this.workspaces.values()].map((runtime) => runtime.summary())),
+      });
+      return;
+    }
+    if (managementRequest && request.method === "POST" && url.pathname === "/v1/workspaces/register") {
+      const body = await readJson(request);
+      sendJson(response, 200, await this.register(body.configPath, body.clientId));
+      return;
+    }
+    if (managementRequest && request.method === "POST" && url.pathname === "/v1/workspaces/pin-conflicts") {
+      const body = await readJson(request);
+      const runtime = this.workspaces.get(body.workspaceId);
+      if (!runtime) {
+        sendJson(response, 404, { error: "GoldSync workspace is no longer open" });
+        return;
+      }
+      await runtime.pinConflicts(body.clientId);
+      for (const candidate of this.workspaces.values()) {
+        if (candidate !== runtime) {
+          candidate.conflictPinnedBy = null;
+        }
+      }
+      sendJson(response, 200, await runtime.summary());
+      return;
+    }
+
+    if (request.headers["x-goldsync-client"] !== "studio-plugin") {
+      sendJson(response, 403, { error: "request was not sent by GoldSync" });
+      return;
+    }
+
+    const candidates = [...this.workspaces.values()];
+    const sessionToken = request.headers["x-goldsync-session"];
+    if (typeof sessionToken !== "string" || sessionToken.length === 0) {
+      sendJson(response, 409, {
+        error: "this Studio place is not connected to a GoldSync-enabled Rojo session",
+      });
+      return;
+    }
+    const matching = candidates.filter((runtime) => runtime.sessionToken === sessionToken);
+    const connected = matching.filter((runtime) => runtime.rojoConnected);
+    const pinned = matching.filter((runtime) => runtime.isConflictPinned());
+    const ambiguous = matching.find((runtime) => runtime.rojoError);
+    const selected = connected.length === 1 ? connected[0] : connected.length === 0 && pinned.length === 1 ? pinned[0] : null;
+    if (!selected) {
+      sendJson(response, candidates.length === 0 ? 404 : 409, {
+        error:
+          candidates.length === 0
+            ? "no GoldSync project is registered on this computer"
+            : matching.length === 0
+              ? "this Studio place belongs to a different or expired Rojo session"
+            : connected.length > 1
+              ? "multiple GoldSync workspaces claim the same Rojo session"
+              : ambiguous
+                ? ambiguous.rojoError
+              : "Rojo is offline; open the GoldSync conflict viewer from a supported editor",
+      });
+      return;
+    }
+    await selected.server.handle(request, response);
+  }
+}