goldsync 0.1.11

package/src/companion.mjs

@@ -0,0 +1,220 @@
+import { randomUUID } from "node:crypto";
+import { access, mkdir, readFile, writeFile } from "node:fs/promises";
+import http from "node:http";
+import path from "node:path";
+import { GoldSyncBroker } from "./broker.mjs";
+import { loadConfig } from "./config.mjs";
+
+export const BROKER_PORT = 34873;
+export const HEARTBEAT_MS = 5000;
+
+function request(method, requestPath, body, port = BROKER_PORT) {
+  return new Promise((resolve, reject) => {
+    const bytes = body === undefined ? undefined : Buffer.from(JSON.stringify(body));
+    const brokerRequest = http.request(
+      {
+        host: "127.0.0.1",
+        port,
+        path: requestPath,
+        method,
+        headers: {
+          "X-GoldSync-Client": "vscode-extension",
+          ...(bytes
+            ? {
+                "Content-Type": "application/json",
+                "Content-Length": bytes.length,
+              }
+            : {}),
+        },
+        timeout: 2000,
+      },
+      (response) => {
+        const chunks = [];
+        response.on("data", (chunk) => chunks.push(chunk));
+        response.on("end", () => {
+          const responseText = Buffer.concat(chunks).toString("utf8");
+          let value = {};
+          if (responseText) {
+            try {
+              value = JSON.parse(responseText);
+            } catch {
+              reject(new Error(`GoldSync returned invalid JSON (HTTP ${response.statusCode})`));
+              return;
+            }
+          }
+          if (response.statusCode < 200 || response.statusCode >= 300) {
+            reject(new Error(value.error ?? `GoldSync request failed (HTTP ${response.statusCode})`));
+            return;
+          }
+          resolve(value);
+        });
+      },
+    );
+    brokerRequest.once("timeout", () => brokerRequest.destroy(new Error("GoldSync broker timed out")));
+    brokerRequest.once("error", reject);
+    if (bytes) {
+      brokerRequest.write(bytes);
+    }
+    brokerRequest.end();
+  });
+}
+
+async function fileExists(file) {
+  try {
+    await access(file);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function findProjectConfig(startDirectory) {
+  const direct = path.join(path.resolve(startDirectory), "goldsync.project.json");
+  if (await fileExists(direct)) {
+    return direct;
+  }
+
+  const { readdir } = await import("node:fs/promises");
+  const matches = [];
+  for (const entry of await readdir(path.resolve(startDirectory), { withFileTypes: true })) {
+    if (!entry.isDirectory() || entry.name.startsWith(".") || entry.name === "node_modules") {
+      continue;
+    }
+    const candidate = path.join(startDirectory, entry.name, "goldsync.project.json");
+    if (await fileExists(candidate)) {
+      matches.push(path.resolve(candidate));
+    }
+  }
+  if (matches.length === 1) {
+    return matches[0];
+  }
+  throw new Error(
+    matches.length === 0
+      ? "No goldsync.project.json was found here or one folder below."
+      : "More than one GoldSync project was found. Run the installer from the intended game folder.",
+  );
+}
+
+export async function readRegistry(registryFile) {
+  try {
+    const value = JSON.parse(await readFile(registryFile, "utf8"));
+    return {
+      version: 1,
+      clientId: typeof value.clientId === "string" ? value.clientId : randomUUID(),
+      projects: Array.isArray(value.projects) ? value.projects : [],
+    };
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+    return { version: 1, clientId: randomUUID(), projects: [] };
+  }
+}
+
+export async function registerProject(registryFile, configPath) {
+  const absoluteConfigPath = path.resolve(configPath);
+  const config = await loadConfig(absoluteConfigPath);
+  const registry = await readRegistry(registryFile);
+  registry.projects = registry.projects.filter(
+    (project) =>
+      project.projectId !== config.projectId &&
+      (typeof project.configPath !== "string" || project.configPath.toLowerCase() !== absoluteConfigPath.toLowerCase()),
+  );
+  registry.projects.push({
+    projectId: config.projectId,
+    name: config.name,
+    configPath: absoluteConfigPath,
+  });
+  await mkdir(path.dirname(registryFile), { recursive: true });
+  await writeFile(registryFile, `${JSON.stringify(registry, null, 2)}\n`);
+  return config;
+}
+
+export class CompanionAgent {
+  constructor(options) {
+    this.registryFile = options.registryFile;
+    this.port = options.port ?? BROKER_PORT;
+    this.heartbeatMs = options.heartbeatMs ?? HEARTBEAT_MS;
+    this.log = options.log ?? (() => {});
+    this.refreshing = false;
+  }
+
+  async brokerHealthy() {
+    try {
+      const health = await request("GET", "/v1/health", undefined, this.port);
+      return health.broker === true;
+    } catch {
+      return false;
+    }
+  }
+
+  async ensureBroker() {
+    if (await this.brokerHealthy()) {
+      return;
+    }
+    if (this.ownedBroker) {
+      await this.ownedBroker.stop();
+      this.ownedBroker = undefined;
+    }
+
+    const broker = new GoldSyncBroker({ port: this.port });
+    try {
+      await broker.start();
+      this.ownedBroker = broker;
+      this.log(`Started broker on 127.0.0.1:${this.port}`);
+      return;
+    } catch (error) {
+      await broker.stop();
+      if (error.code !== "EADDRINUSE") {
+        throw error;
+      }
+    }
+
+    for (let attempt = 0; attempt < 20; attempt += 1) {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      if (await this.brokerHealthy()) {
+        return;
+      }
+    }
+    throw new Error(`port ${this.port} is occupied by another application`);
+  }
+
+  async refresh() {
+    if (this.refreshing) {
+      return;
+    }
+    this.refreshing = true;
+    try {
+      await this.ensureBroker();
+      const registry = await readRegistry(this.registryFile);
+      for (const project of registry.projects) {
+        if (!(await fileExists(project.configPath))) {
+          continue;
+        }
+        await request(
+          "POST",
+          "/v1/workspaces/register",
+          { configPath: project.configPath, clientId: registry.clientId },
+          this.port,
+        );
+      }
+    } finally {
+      this.refreshing = false;
+    }
+  }
+
+  async start() {
+    await this.refresh();
+    this.timer = setInterval(() => {
+      this.refresh().catch((error) => this.log(error.stack ?? error.message));
+    }, this.heartbeatMs);
+  }
+
+  async stop() {
+    clearInterval(this.timer);
+    if (this.ownedBroker) {
+      await this.ownedBroker.stop();
+      this.ownedBroker = undefined;
+    }
+  }
+}

package/src/config.mjs

@@ -0,0 +1,165 @@
+import { createHash } from "node:crypto";
+import { readFile, realpath } from "node:fs/promises";
+import path from "node:path";
+
+const ID_PATTERN = /^[a-z0-9][a-z0-9-]*$/;
+
+function requireString(value, label) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`${label} must be a non-empty string`);
+  }
+  return value;
+}
+
+function resolveInsideProject(projectRoot, file, label) {
+  requireString(file, label);
+  const resolved = path.resolve(projectRoot, file);
+  const relative = path.relative(projectRoot, resolved);
+  if (relative.startsWith("..") || path.isAbsolute(relative)) {
+    throw new Error(`${label} must stay inside the project root`);
+  }
+  return resolved;
+}
+
+function resolveProjectFile(projectRoot, file, label) {
+  requireString(file, label);
+  if (path.extname(file).toLowerCase() !== ".rbxm") {
+    throw new Error(`${label} must point to an .rbxm file`);
+  }
+  return resolveInsideProject(projectRoot, file, label);
+}
+
+function normalizeStudioPath(root, label, maxPathDepth, extraDepth = 0) {
+  if (!Array.isArray(root.studioPath) || root.studioPath.length < 2) {
+    throw new Error(`${label}.studioPath must contain a service and child path`);
+  }
+  const studioPath = root.studioPath.map((segment, segmentIndex) =>
+    requireString(segment, `${label}.studioPath[${segmentIndex}]`),
+  );
+  if (studioPath.length + extraDepth > maxPathDepth) {
+    throw new Error(`${label}.studioPath exceeds maxPathDepth (${maxPathDepth})`);
+  }
+  return studioPath;
+}
+
+async function normalizeRojo(raw, projectRoot) {
+  if (raw !== undefined && (!raw || typeof raw !== "object" || Array.isArray(raw))) {
+    throw new Error("rojo must be an object when specified");
+  }
+
+  const overrides = raw ?? {};
+  let rojoProject = null;
+  if (
+    raw === undefined ||
+    overrides.projectFile !== undefined ||
+    overrides.port === undefined ||
+    overrides.projectName === undefined
+  ) {
+    const projectFile = overrides.projectFile ?? "default.project.json";
+    const absoluteProjectFile = resolveInsideProject(projectRoot, projectFile, "rojo.projectFile");
+    rojoProject = JSON.parse(await readFile(absoluteProjectFile, "utf8"));
+  }
+
+  const port = overrides.port ?? rojoProject?.servePort ?? 34872;
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new Error("rojo.port must be an integer between 1 and 65535");
+  }
+  return {
+    host: "127.0.0.1",
+    port,
+    projectName: requireString(overrides.projectName ?? rojoProject?.name, "rojo.projectName"),
+  };
+}
+
+export async function loadConfig(configPath) {
+  const absoluteConfigPath = path.resolve(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");
+  }
+  const port = raw.port ?? 34873;
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new Error("port must be an integer between 1 and 65535");
+  }
+  if (!Array.isArray(raw.roots) || raw.roots.length === 0) {
+    throw new Error("roots must contain at least one sync root");
+  }
+  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 ids = new Set();
+  const studioPaths = new Set();
+  const files = new Set();
+  const splitRoots = [];
+  const roots = raw.roots.flatMap((root, index) => {
+    const label = `roots[${index}]`;
+    const id = requireString(root.id, `${label}.id`);
+    if (!ID_PATTERN.test(id)) {
+      throw new Error(`${label}.id must contain lowercase letters, numbers, or hyphens`);
+    }
+    if (ids.has(id)) {
+      throw new Error(`duplicate root id: ${id}`);
+    }
+    ids.add(id);
+
+    const splitDepth = root.splitDepth;
+    if (splitDepth !== undefined && (!Number.isInteger(splitDepth) || splitDepth < 1 || splitDepth > 3)) {
+      throw new Error(`${label}.splitDepth must be an integer between 1 and 3`);
+    }
+    const studioPath = normalizeStudioPath(root, label, maxPathDepth, splitDepth ?? 0);
+    const studioPathKey = JSON.stringify(studioPath);
+    if (studioPaths.has(studioPathKey)) {
+      throw new Error(`duplicate Studio path: ${studioPath.join(".")}`);
+    }
+    studioPaths.add(studioPathKey);
+
+    if (splitDepth !== undefined) {
+      const directory = requireString(root.directory, `${label}.directory`);
+      const absoluteDirectory = resolveInsideProject(projectRoot, directory, `${label}.directory`);
+      splitRoots.push({
+        id,
+        studioPath,
+        directory: path.relative(projectRoot, absoluteDirectory).replaceAll(path.sep, "/"),
+        absoluteDirectory,
+        splitDepth,
+      });
+      return [];
+    }
+
+    const absoluteFile = resolveProjectFile(projectRoot, root.file, `${label}.file`);
+    const fileKey = absoluteFile.toLowerCase();
+    if (files.has(fileKey)) {
+      throw new Error(`duplicate output file: ${root.file}`);
+    }
+    files.add(fileKey);
+
+    return [{
+      id,
+      studioPath,
+      file: path.relative(projectRoot, absoluteFile).replaceAll(path.sep, "/"),
+      absoluteFile,
+    }];
+  });
+
+  return {
+    version: 1,
+    name: requireString(raw.name, "name"),
+    projectId: requireString(raw.projectId, "projectId"),
+    workspaceId: createHash("sha256").update(absoluteConfigPath.toLowerCase()).digest("hex").slice(0, 12),
+    rojo: await normalizeRojo(raw.rojo, projectRoot),
+    host: "127.0.0.1",
+    port,
+    pollIntervalMs: Number.isInteger(raw.pollIntervalMs) ? Math.max(raw.pollIntervalMs, 250) : 750,
+    debounceMs: Number.isInteger(raw.debounceMs) ? Math.max(raw.debounceMs, 100) : 600,
+    maxPathDepth,
+    projectRoot,
+    stateDirectory: path.join(projectRoot, ".goldsync"),
+    sessionMarkerFile: path.join(projectRoot, ".goldsync", "rojo-session.model.json"),
+    roots,
+    splitRoots,
+  };
+}

package/src/git-conflicts.mjs

@@ -0,0 +1,127 @@
+import { createHash } from "node:crypto";
+import { execFile } from "node:child_process";
+import { realpath } from "node:fs/promises";
+import path from "node:path";
+
+const MAX_GIT_OUTPUT_BYTES = 160 * 1024 * 1024;
+const STAGES = { base: 1, ours: 2, theirs: 3 };
+
+function runGit(directory, args) {
+  return new Promise((resolve, reject) => {
+    execFile(
+      "git",
+      ["-C", directory, ...args],
+      { encoding: null, maxBuffer: MAX_GIT_OUTPUT_BYTES, windowsHide: true },
+      (error, stdout, stderr) => {
+        if (error) {
+          error.message = Buffer.from(stderr).toString("utf8").trim() || error.message;
+          reject(error);
+          return;
+        }
+        resolve(Buffer.from(stdout));
+      },
+    );
+  });
+}
+
+export class GitConflictStore {
+  constructor(config) {
+    this.config = config;
+    this.roots = new Map(config.roots.map((root) => [root.id, root]));
+    this.repositoryRoot = null;
+    this.gitPaths = new Map();
+  }
+
+  async initialize() {
+    try {
+      this.repositoryRoot = await realpath(
+        (await runGit(this.config.projectRoot, ["rev-parse", "--show-toplevel"])).toString("utf8").trim(),
+      );
+    } catch {
+      return;
+    }
+
+    this.syncRoots(this.config.roots);
+  }
+
+  syncRoots(roots) {
+    if (!this.repositoryRoot) {
+      return;
+    }
+    for (const root of roots) {
+      const relative = path.relative(this.repositoryRoot, root.absoluteFile);
+      if (!relative.startsWith("..") && !path.isAbsolute(relative)) {
+        this.gitPaths.set(root.id, relative.replaceAll(path.sep, "/"));
+      }
+    }
+  }
+
+  async list() {
+    if (!this.repositoryRoot || this.gitPaths.size === 0) {
+      return new Map();
+    }
+
+    const output = await runGit(this.repositoryRoot, ["ls-files", "-u", "-z", "--", ...this.gitPaths.values()]);
+    const byPath = new Map();
+    for (const entry of output.toString("utf8").split("\0")) {
+      if (!entry) {
+        continue;
+      }
+      const match = /^(\d+) ([0-9a-f]+) ([123])\t(.+)$/.exec(entry);
+      if (!match) {
+        continue;
+      }
+      const [, mode, objectId, stage, file] = match;
+      const stages = byPath.get(file) ?? [];
+      stages.push({ mode, objectId, stage: Number(stage) });
+      byPath.set(file, stages);
+    }
+
+    const conflicts = new Map();
+    for (const [id, file] of this.gitPaths) {
+      const stages = byPath.get(file);
+      if (!stages) {
+        continue;
+      }
+      stages.sort((left, right) => left.stage - right.stage);
+      conflicts.set(id, {
+        id,
+        file,
+        token: createHash("sha256").update(JSON.stringify(stages)).digest("hex"),
+        stages: {
+          base: stages.some((stage) => stage.stage === STAGES.base),
+          ours: stages.some((stage) => stage.stage === STAGES.ours),
+          theirs: stages.some((stage) => stage.stage === STAGES.theirs),
+        },
+      });
+    }
+    return conflicts;
+  }
+
+  async readStage(id, name) {
+    const stage = STAGES[name];
+    if (!stage) {
+      throw new Error(`unknown conflict stage: ${name}`);
+    }
+    const conflict = (await this.list()).get(id);
+    if (!conflict || !conflict.stages[name]) {
+      return null;
+    }
+    return runGit(this.repositoryRoot, ["show", `:${stage}:${conflict.file}`]);
+  }
+
+  async resolve(id, bytes, token, store) {
+    const conflict = (await this.list()).get(id);
+    if (!conflict) {
+      throw new Error("Git conflict no longer exists");
+    }
+    if (conflict.token !== token) {
+      throw new Error("Git conflict changed while the merge workspace was open");
+    }
+
+    const manifest = store.getManifest(id);
+    await store.put(id, bytes, manifest.exists ? manifest.hash : "*");
+    await runGit(this.repositoryRoot, ["add", "--", conflict.file]);
+    return store.getManifest(id);
+  }
+}

package/src/rojo-session.mjs

@@ -0,0 +1,165 @@
+import { execFile } from "node:child_process";
+import { request } from "node:http";
+import { promisify } from "node:util";
+
+const PROJECT_NAME_KEY = Buffer.from("projectName");
+const SESSION_ID_KEY = Buffer.from("sessionId");
+const executeFile = promisify(execFile);
+const DISCOVERY_CACHE_MS = 2000;
+
+let discoveredPorts = [];
+let discoveryExpiresAt = 0;
+let discoveryPromise;
+
+function readString(buffer, offset) {
+  const prefix = buffer[offset];
+  if (prefix >= 0xa0 && prefix <= 0xbf) {
+    const length = prefix & 0x1f;
+    return buffer.subarray(offset + 1, offset + 1 + length).toString("utf8");
+  }
+  if (prefix === 0xd9) {
+    const length = buffer[offset + 1];
+    return buffer.subarray(offset + 2, offset + 2 + length).toString("utf8");
+  }
+  if (prefix === 0xda) {
+    const length = buffer.readUInt16BE(offset + 1);
+    return buffer.subarray(offset + 3, offset + 3 + length).toString("utf8");
+  }
+  return null;
+}
+
+function readField(buffer, key) {
+  const keyOffset = buffer.indexOf(key);
+  if (keyOffset === -1) {
+    return null;
+  }
+  return readString(buffer, keyOffset + key.length);
+}
+
+export function readRojoSessionInfo(buffer) {
+  const projectName = readField(buffer, PROJECT_NAME_KEY);
+  const sessionId = readField(buffer, SESSION_ID_KEY);
+  return projectName && sessionId ? { projectName, sessionId } : null;
+}
+
+export function readRojoProjectName(buffer) {
+  return readField(buffer, PROJECT_NAME_KEY);
+}
+
+export function parseRojoServePorts(commandLines) {
+  const ports = new Set();
+  for (const line of commandLines.split(/\r?\n/)) {
+    if (!/rojo(?:\.exe)?(?:"|\s)/i.test(line) || !/\bserve\b/i.test(line)) {
+      continue;
+    }
+    for (const match of line.matchAll(/(?:^|\s)--port(?:=|\s+)["']?(\d{1,5})/gi)) {
+      const port = Number(match[1]);
+      if (port >= 1 && port <= 65535) {
+        ports.add(port);
+      }
+    }
+  }
+  return [...ports];
+}
+
+async function readRojoProcessCommands() {
+  if (process.platform === "win32") {
+    const { stdout } = await executeFile(
+      "powershell.exe",
+      [
+        "-NoProfile",
+        "-NonInteractive",
+        "-Command",
+        "Get-CimInstance Win32_Process -Filter \"Name = 'rojo.exe'\" | Select-Object -ExpandProperty CommandLine",
+      ],
+      { timeout: 2000, windowsHide: true },
+    );
+    return stdout;
+  }
+  const { stdout } = await executeFile("ps", ["-ax", "-o", "command="], { timeout: 2000 });
+  return stdout;
+}
+
+export async function discoverRojoServePorts() {
+  if (Date.now() < discoveryExpiresAt) {
+    return discoveredPorts;
+  }
+  if (!discoveryPromise) {
+    discoveryPromise = readRojoProcessCommands()
+      .then(parseRojoServePorts)
+      .catch(() => [])
+      .then((ports) => {
+        discoveredPorts = ports;
+        discoveryExpiresAt = Date.now() + DISCOVERY_CACHE_MS;
+        return ports;
+      })
+      .finally(() => {
+        discoveryPromise = undefined;
+      });
+  }
+  return discoveryPromise;
+}
+
+async function readRojoResponse(rojo) {
+  return new Promise((resolve, reject) => {
+    const rojoRequest = request(
+      { host: rojo.host, port: rojo.port, path: "/api/rojo", method: "GET" },
+      (response) => {
+        const chunks = [];
+        response.on("data", (chunk) => chunks.push(chunk));
+        response.on("end", () => {
+          resolve(response.statusCode >= 200 && response.statusCode < 300 ? Buffer.concat(chunks) : null);
+        });
+      },
+    );
+    rojoRequest.setTimeout(1000, () => rojoRequest.destroy(new Error("Rojo session request timed out")));
+    rojoRequest.once("error", reject);
+    rojoRequest.end();
+  });
+}
+
+export async function getRojoProjectName(rojo, fetchImplementation) {
+  if (fetchImplementation) {
+    const response = await fetchImplementation(`http://${rojo.host}:${rojo.port}/api/rojo`);
+    if (!response.ok) {
+      return null;
+    }
+    return readRojoProjectName(Buffer.from(await response.arrayBuffer()));
+  }
+  const response = await readRojoResponse(rojo);
+  return response ? readRojoProjectName(response) : null;
+}
+
+export async function getRojoSessionInfo(rojo, fetchImplementation) {
+  if (fetchImplementation) {
+    const response = await fetchImplementation(`http://${rojo.host}:${rojo.port}/api/rojo`);
+    if (!response.ok) {
+      return null;
+    }
+    return readRojoSessionInfo(Buffer.from(await response.arrayBuffer()));
+  }
+  const response = await readRojoResponse(rojo);
+  return response ? readRojoSessionInfo(response) : null;
+}
+
+export async function findRojoSession(rojo, options = {}) {
+  const dynamicPorts = options.ports ?? (await discoverRojoServePorts());
+  const ports = [...new Set([...dynamicPorts, rojo.port])];
+  const matches = (
+    await Promise.all(
+      ports.map(async (port) => {
+        try {
+          const session = await getRojoSessionInfo({ ...rojo, port }, options.fetchImplementation);
+          return session?.projectName === rojo.projectName ? { port, sessionId: session.sessionId } : null;
+        } catch {
+          return null;
+        }
+      }),
+    )
+  ).filter((port) => port !== null);
+
+  if (matches.length > 1) {
+    return { ambiguous: true, ports: matches.map((match) => match.port) };
+  }
+  return matches.length === 1 ? { ambiguous: false, ...matches[0] } : null;
+}