@remixhq/core 0.1.12 → 0.1.14

package/dist/chunk-YCFLOHJV.js

@@ -0,0 +1,343 @@
+import {
+  getCurrentBranch
+} from "./chunk-WT6VRLXU.js";
+import {
+  RemixError
+} from "./chunk-YZ34ICNN.js";
+
+// src/infrastructure/binding/collabBindingStore.ts
+import fs2 from "fs/promises";
+import path2 from "path";
+
+// src/shared/fs.ts
+import fs from "fs/promises";
+import path from "path";
+async function reserveDirectory(targetDir) {
+  try {
+    await fs.mkdir(targetDir);
+    return targetDir;
+  } catch (error) {
+    if (error?.code === "EEXIST") {
+      throw new RemixError("Output directory already exists.", {
+        exitCode: 2,
+        hint: `Choose an empty destination path: ${targetDir}`
+      });
+    }
+    throw error;
+  }
+}
+async function reserveAvailableDirPath(preferredDir) {
+  const parent = path.dirname(preferredDir);
+  const base = path.basename(preferredDir);
+  for (let i = 1; i <= 1e3; i += 1) {
+    const candidate = i === 1 ? preferredDir : path.join(parent, `${base}-${i}`);
+    try {
+      await fs.mkdir(candidate);
+      return candidate;
+    } catch (error) {
+      if (error?.code === "EEXIST") continue;
+      throw error;
+    }
+  }
+  throw new RemixError("No available output directory name.", {
+    exitCode: 2,
+    hint: `Tried ${base} through ${base}-1000 under ${parent}.`
+  });
+}
+async function writeJsonAtomic(filePath, value) {
+  const dir = path.dirname(filePath);
+  await fs.mkdir(dir, { recursive: true });
+  const tmp = `${filePath}.tmp-${Date.now()}`;
+  await fs.writeFile(tmp, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+  await fs.rename(tmp, filePath);
+}
+
+// src/infrastructure/binding/collabBindingStore.ts
+function getCollabBindingPath(repoRoot) {
+  return path2.join(repoRoot, ".remix", "config.json");
+}
+function buildBindingFileV3(params) {
+  return {
+    schemaVersion: 3,
+    repoFingerprint: params.repoFingerprint,
+    remoteUrl: params.remoteUrl,
+    defaultBranch: params.defaultBranch,
+    branchBindings: params.branchBindings,
+    ...params.explicitRootBinding ? { explicitRootBinding: params.explicitRootBinding } : {}
+  };
+}
+function normalizeBranchName(value) {
+  const normalized = String(value ?? "").trim();
+  return normalized || null;
+}
+function normalizeProjectId(value) {
+  const normalized = String(value ?? "").trim();
+  return normalized || null;
+}
+function normalizeBranchBinding(value) {
+  if (!value?.currentAppId || !value?.upstreamAppId) return null;
+  return {
+    projectId: normalizeProjectId(value.projectId),
+    currentAppId: value.currentAppId,
+    upstreamAppId: value.upstreamAppId,
+    threadId: value.threadId ?? null,
+    laneId: value.laneId ?? null,
+    bindingMode: value.bindingMode === "legacy" ? "legacy" : value.bindingMode === "explicit_root" ? "explicit_root" : "lane"
+  };
+}
+function buildResolvedBinding(params) {
+  if (!params.binding) return null;
+  return {
+    schemaVersion: 3,
+    projectId: params.binding.projectId ?? params.fallbackProjectId,
+    currentAppId: params.binding.currentAppId,
+    upstreamAppId: params.binding.upstreamAppId,
+    threadId: params.binding.threadId,
+    repoFingerprint: params.repoFingerprint,
+    remoteUrl: params.remoteUrl,
+    defaultBranch: params.defaultBranch,
+    laneId: params.binding.laneId,
+    branchName: params.branchName,
+    bindingMode: params.binding.bindingMode
+  };
+}
+function deriveFallbackProjectId(params) {
+  const candidates = [
+    params.currentBranch ? params.branchBindings[params.currentBranch]?.projectId ?? null : null,
+    params.defaultBranch ? params.branchBindings[params.defaultBranch]?.projectId ?? null : null,
+    ...Object.values(params.branchBindings).map((binding) => binding.projectId),
+    params.legacyProjectId
+  ];
+  for (const candidate of candidates) {
+    if (candidate) return candidate;
+  }
+  return null;
+}
+async function readCollabBindingState(repoRoot, options) {
+  try {
+    const persist = options?.persist === true;
+    const filePath = getCollabBindingPath(repoRoot);
+    const raw = await fs2.readFile(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") return null;
+    const currentBranch = normalizeBranchName(await getCurrentBranch(repoRoot).catch(() => null));
+    if (parsed.schemaVersion === 1) {
+      if (!parsed.currentAppId || !parsed.upstreamAppId) return null;
+      const projectId = normalizeProjectId(parsed.projectId);
+      const preferredBranch = normalizeBranchName(parsed.preferredBranch ?? parsed.defaultBranch ?? null);
+      const branchKey = preferredBranch ?? currentBranch ?? null;
+      const branchBindings2 = branchKey ? {
+        [branchKey]: {
+          projectId,
+          currentAppId: parsed.currentAppId,
+          upstreamAppId: parsed.upstreamAppId,
+          threadId: parsed.threadId ?? null,
+          laneId: null,
+          bindingMode: "legacy"
+        }
+      } : {};
+      const migratedFile = buildBindingFileV3({
+        repoFingerprint: parsed.repoFingerprint ?? null,
+        remoteUrl: parsed.remoteUrl ?? null,
+        defaultBranch: parsed.defaultBranch ?? null,
+        branchBindings: branchBindings2
+      });
+      if (persist) {
+        try {
+          await writeJsonAtomic(filePath, migratedFile);
+        } catch {
+        }
+      }
+      return {
+        schemaVersion: 3,
+        projectId,
+        repoFingerprint: migratedFile.repoFingerprint,
+        remoteUrl: migratedFile.remoteUrl,
+        defaultBranch: migratedFile.defaultBranch,
+        currentBranch,
+        branchBindings: migratedFile.branchBindings,
+        explicitRootBinding: null,
+        binding: buildResolvedBinding({
+          fallbackProjectId: projectId,
+          repoFingerprint: migratedFile.repoFingerprint,
+          remoteUrl: migratedFile.remoteUrl,
+          defaultBranch: migratedFile.defaultBranch,
+          branchName: branchKey,
+          binding: branchKey ? migratedFile.branchBindings[branchKey] : null
+        })
+      };
+    }
+    if (parsed.schemaVersion !== 2 && parsed.schemaVersion !== 3) return null;
+    const file = parsed;
+    let shouldPersistNormalizedBranchBindings = false;
+    const legacyProjectId = normalizeProjectId(file.projectId);
+    const branchBindings = Object.fromEntries(
+      Object.entries(file.branchBindings ?? {}).map(([branchName, branchBinding]) => {
+        const normalized = normalizeBranchBinding(branchBinding);
+        const rawProjectId = branchBinding && typeof branchBinding === "object" && "projectId" in branchBinding ? normalizeProjectId(branchBinding.projectId) : null;
+        const rawBindingMode = branchBinding && typeof branchBinding === "object" && "bindingMode" in branchBinding ? branchBinding.bindingMode : null;
+        const hasLegacyPreferredBranch = Boolean(branchBinding) && typeof branchBinding === "object" && "preferredBranch" in branchBinding;
+        let normalizedWithProject = normalized;
+        if (normalizedWithProject && !normalizedWithProject.projectId && legacyProjectId) {
+          normalizedWithProject = {
+            ...normalizedWithProject,
+            projectId: legacyProjectId
+          };
+        }
+        if (normalizedWithProject && (rawBindingMode !== normalizedWithProject.bindingMode || hasLegacyPreferredBranch || rawProjectId !== normalizedWithProject.projectId)) {
+          shouldPersistNormalizedBranchBindings = true;
+        }
+        return [branchName, normalizedWithProject];
+      }).filter((entry) => Boolean(entry[1]))
+    );
+    const legacyExplicitBinding = normalizeBranchBinding(file.explicitBinding ?? null);
+    const legacyExplicitBranch = currentBranch ?? normalizeBranchName(file.defaultBranch);
+    if (legacyExplicitBinding && legacyExplicitBranch) {
+      branchBindings[legacyExplicitBranch] = {
+        ...legacyExplicitBinding,
+        projectId: legacyExplicitBinding.projectId ?? branchBindings[legacyExplicitBranch]?.projectId ?? legacyProjectId,
+        bindingMode: "lane"
+      };
+      shouldPersistNormalizedBranchBindings = true;
+    }
+    let explicitRootBinding = normalizeBranchBinding(file.explicitRootBinding ?? null);
+    if (explicitRootBinding && !explicitRootBinding.projectId && legacyProjectId) {
+      explicitRootBinding = {
+        ...explicitRootBinding,
+        projectId: legacyProjectId
+      };
+      shouldPersistNormalizedBranchBindings = true;
+    }
+    if (explicitRootBinding && explicitRootBinding.bindingMode !== "explicit_root") {
+      explicitRootBinding = {
+        ...explicitRootBinding,
+        bindingMode: "explicit_root"
+      };
+      shouldPersistNormalizedBranchBindings = true;
+    }
+    if (persist && ("explicitBinding" in file || "explicitRootBinding" in file || shouldPersistNormalizedBranchBindings || parsed.schemaVersion === 2)) {
+      try {
+        await writeJsonAtomic(
+          filePath,
+          buildBindingFileV3({
+            repoFingerprint: file.repoFingerprint ?? null,
+            remoteUrl: file.remoteUrl ?? null,
+            defaultBranch: file.defaultBranch ?? null,
+            branchBindings,
+            explicitRootBinding
+          })
+        );
+      } catch {
+      }
+    }
+    const resolvedBranch = currentBranch ?? normalizeBranchName(file.defaultBranch);
+    const fallbackProjectId = deriveFallbackProjectId({
+      branchBindings,
+      currentBranch: resolvedBranch,
+      defaultBranch: normalizeBranchName(file.defaultBranch),
+      legacyProjectId: explicitRootBinding?.projectId ?? legacyProjectId
+    });
+    const resolvedBinding = buildResolvedBinding({
+      fallbackProjectId,
+      repoFingerprint: file.repoFingerprint ?? null,
+      remoteUrl: file.remoteUrl ?? null,
+      defaultBranch: file.defaultBranch ?? null,
+      branchName: resolvedBranch,
+      binding: resolvedBranch ? branchBindings[resolvedBranch] ?? null : null
+    }) ?? (resolvedBranch && resolvedBranch === normalizeBranchName(file.defaultBranch) && explicitRootBinding ? buildResolvedBinding({
+      fallbackProjectId,
+      repoFingerprint: file.repoFingerprint ?? null,
+      remoteUrl: file.remoteUrl ?? null,
+      defaultBranch: file.defaultBranch ?? null,
+      branchName: normalizeBranchName(file.defaultBranch),
+      binding: explicitRootBinding
+    }) : null);
+    return {
+      schemaVersion: parsed.schemaVersion,
+      projectId: fallbackProjectId,
+      repoFingerprint: file.repoFingerprint ?? null,
+      remoteUrl: file.remoteUrl ?? null,
+      defaultBranch: file.defaultBranch ?? null,
+      currentBranch,
+      branchBindings,
+      explicitRootBinding: buildResolvedBinding({
+        fallbackProjectId,
+        repoFingerprint: file.repoFingerprint ?? null,
+        remoteUrl: file.remoteUrl ?? null,
+        defaultBranch: file.defaultBranch ?? null,
+        branchName: normalizeBranchName(file.defaultBranch),
+        binding: explicitRootBinding
+      }),
+      binding: resolvedBinding
+    };
+  } catch {
+    return null;
+  }
+}
+async function readCollabBinding(repoRoot) {
+  const state = await readCollabBindingState(repoRoot);
+  return state?.binding ?? null;
+}
+async function writeCollabBinding(repoRoot, binding) {
+  const filePath = getCollabBindingPath(repoRoot);
+  const currentBranch = normalizeBranchName(await getCurrentBranch(repoRoot).catch(() => null));
+  const branchName = normalizeBranchName(binding.branchName) ?? currentBranch ?? binding.defaultBranch ?? "main";
+  const existing = await readCollabBindingState(repoRoot, { persist: true });
+  const branchBindings = { ...existing?.branchBindings ?? {} };
+  branchBindings[branchName] = {
+    projectId: normalizeProjectId(binding.projectId) ?? branchBindings[branchName]?.projectId ?? existing?.projectId ?? null,
+    currentAppId: binding.currentAppId,
+    upstreamAppId: binding.upstreamAppId,
+    threadId: binding.threadId ?? null,
+    laneId: binding.laneId ?? null,
+    bindingMode: binding.bindingMode ?? "lane"
+  };
+  const explicitRootBinding = binding.bindingMode === "explicit_root" ? {
+    ...branchBindings[branchName],
+    bindingMode: "explicit_root"
+  } : existing?.explicitRootBinding ? {
+    projectId: existing.explicitRootBinding.projectId,
+    currentAppId: existing.explicitRootBinding.currentAppId,
+    upstreamAppId: existing.explicitRootBinding.upstreamAppId,
+    threadId: existing.explicitRootBinding.threadId,
+    laneId: existing.explicitRootBinding.laneId,
+    bindingMode: "explicit_root"
+  } : null;
+  await writeJsonAtomic(
+    filePath,
+    buildBindingFileV3({
+      repoFingerprint: binding.repoFingerprint ?? null,
+      remoteUrl: binding.remoteUrl ?? null,
+      defaultBranch: binding.defaultBranch ?? null,
+      branchBindings,
+      explicitRootBinding
+    })
+  );
+  return filePath;
+}
+async function writeCollabBindingSnapshot(params) {
+  const filePath = getCollabBindingPath(params.repoRoot);
+  await writeJsonAtomic(
+    filePath,
+    buildBindingFileV3({
+      repoFingerprint: params.repoFingerprint,
+      remoteUrl: params.remoteUrl,
+      defaultBranch: params.defaultBranch,
+      branchBindings: params.branchBindings,
+      explicitRootBinding: params.explicitRootBinding ?? null
+    })
+  );
+  return filePath;
+}
+
+export {
+  reserveDirectory,
+  reserveAvailableDirPath,
+  writeJsonAtomic,
+  getCollabBindingPath,
+  readCollabBindingState,
+  readCollabBinding,
+  writeCollabBinding,
+  writeCollabBindingSnapshot
+};