@remixhq/core 0.1.10 → 0.1.11

package/dist/api.d.ts

@@ -302,6 +302,30 @@ type ApiClient = {
     resolveProjectBinding(params: {
         repoFingerprint?: string;
         remoteUrl?: string;
+        branchName?: string;
+    }): Promise<Json>;
+    resolveProjectLaneBinding(params: {
+        projectId?: string;
+        repoFingerprint?: string;
+        remoteUrl?: string;
+        defaultBranch?: string;
+        branchName: string;
+    }): Promise<Json>;
+    ensureProjectLaneBinding(payload: {
+        projectId?: string;
+        repoFingerprint?: string;
+        remoteUrl?: string;
+        defaultBranch?: string;
+        branchName: string;
+        seedAppId?: string;
+    }): Promise<Json>;
+    bootstrapFreshProjectLane(payload: {
+        projectId?: string;
+        repoFingerprint?: string;
+        remoteUrl?: string;
+        defaultBranch?: string;
+        branchName: string;
+        seedAppId: string;
     }): Promise<Json>;
     autoEnableDeveloper(): Promise<Json>;
     listClientApps(params?: {
@@ -373,6 +397,7 @@ type ApiClient = {
         uploadId: string;
         appName?: string;
         threadId?: string;
+        branch?: string;
         path?: string;
         platform?: string;
         isPublic?: boolean;
@@ -398,6 +423,7 @@ type ApiClient = {
         name?: string;
         platform?: string;
         forkedFromCommitId?: string;
+        branchName?: string;
     }): Promise<Json>;
     downloadAppBundle(appId: string): Promise<{
         data: Buffer;
@@ -406,6 +432,7 @@ type ApiClient = {
     }>;
     createChangeStep(appId: string, payload: {
         threadId?: string;
+        collabLaneId?: string;
         prompt: string;
         assistantResponse?: string;
         diff: string;
@@ -443,6 +470,7 @@ type ApiClient = {
     getChangeStepReplayDiff(appId: string, replayId: string): Promise<Json>;
     createCollabTurn(appId: string, payload: {
         threadId?: string;
+        collabLaneId?: string;
         prompt: string;
         assistantResponse: string;
         actor?: {
@@ -459,6 +487,7 @@ type ApiClient = {
         offset?: number;
         changeStepId?: string;
         threadId?: string;
+        collabLaneId?: string;
         createdAfter?: string;
         createdBefore?: string;
     }): Promise<Json>;

package/dist/api.js

@@ -1,6 +1,6 @@
 import {
   createApiClient
-} from "./chunk-B5S3PUIR.js";
+} from "./chunk-BNKPTE2U.js";
 import "./chunk-YZ34ICNN.js";
 export {
   createApiClient

package/dist/binding.d.ts

@@ -1,16 +1,21 @@
+type BranchBindingMode = "legacy" | "lane";
 type CollabBinding = {
-    schemaVersion: 1;
-    projectId: string;
+    schemaVersion: 3;
+    projectId: string | null;
     currentAppId: string;
     upstreamAppId: string;
     threadId: string | null;
     repoFingerprint: string | null;
     remoteUrl: string | null;
     defaultBranch: string | null;
-    preferredBranch: string | null;
+    laneId: string | null;
+    branchName: string | null;
+    bindingMode: BranchBindingMode;
 };
 declare function getCollabBindingPath(repoRoot: string): string;
 declare function readCollabBinding(repoRoot: string): Promise<CollabBinding | null>;
-declare function writeCollabBinding(repoRoot: string, binding: Omit<CollabBinding, "schemaVersion">): Promise<string>;
+declare function writeCollabBinding(repoRoot: string, binding: Omit<CollabBinding, "schemaVersion" | "branchName"> & {
+    branchName?: string | null;
+}): Promise<string>;
 
 export { type CollabBinding, getCollabBindingPath, readCollabBinding, writeCollabBinding };

package/dist/binding.js

@@ -2,7 +2,9 @@ import {
   getCollabBindingPath,
   readCollabBinding,
   writeCollabBinding
-} from "./chunk-GEHSFPCD.js";
+} from "./chunk-4L3ZBZUQ.js";
+import "./chunk-RREREIGW.js";
+import "./chunk-GC2MOT3U.js";
 import "./chunk-YZ34ICNN.js";
 export {
   getCollabBindingPath,

package/dist/chunk-4L3ZBZUQ.js

@@ -0,0 +1,281 @@
+import {
+  getCurrentBranch
+} from "./chunk-RREREIGW.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
+  };
+}
+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" : "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,
+        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;
+    }
+    if (persist && ("explicitBinding" in file || shouldPersistNormalizedBranchBindings || parsed.schemaVersion === 2)) {
+      try {
+        await writeJsonAtomic(
+          filePath,
+          buildBindingFileV3({
+            repoFingerprint: file.repoFingerprint ?? null,
+            remoteUrl: file.remoteUrl ?? null,
+            defaultBranch: file.defaultBranch ?? null,
+            branchBindings
+          })
+        );
+      } catch {
+      }
+    }
+    const resolvedBranch = currentBranch ?? normalizeBranchName(file.defaultBranch);
+    const fallbackProjectId = deriveFallbackProjectId({
+      branchBindings,
+      currentBranch: resolvedBranch,
+      defaultBranch: normalizeBranchName(file.defaultBranch),
+      legacyProjectId
+    });
+    return {
+      schemaVersion: parsed.schemaVersion,
+      projectId: fallbackProjectId,
+      repoFingerprint: file.repoFingerprint ?? null,
+      remoteUrl: file.remoteUrl ?? null,
+      defaultBranch: file.defaultBranch ?? null,
+      currentBranch,
+      branchBindings,
+      binding: buildResolvedBinding({
+        fallbackProjectId,
+        repoFingerprint: file.repoFingerprint ?? null,
+        remoteUrl: file.remoteUrl ?? null,
+        defaultBranch: file.defaultBranch ?? null,
+        branchName: resolvedBranch,
+        binding: resolvedBranch ? branchBindings[resolvedBranch] ?? null : null
+      })
+    };
+  } 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"
+  };
+  await writeJsonAtomic(
+    filePath,
+    buildBindingFileV3({
+      repoFingerprint: binding.repoFingerprint ?? null,
+      remoteUrl: binding.remoteUrl ?? null,
+      defaultBranch: binding.defaultBranch ?? null,
+      branchBindings
+    })
+  );
+  return filePath;
+}
+
+export {
+  reserveDirectory,
+  reserveAvailableDirPath,
+  getCollabBindingPath,
+  readCollabBindingState,
+  readCollabBinding,
+  writeCollabBinding
+};