@remixhq/core 0.1.6 → 0.1.8

package/dist/collab.js

@@ -36,7 +36,7 @@ import {
   summarizeUnifiedDiff,
   validateUnifiedDiff,
   writeTempUnifiedDiffBackup
-} from "./chunk-UGKPOCN5.js";
+} from "./chunk-RREREIGW.js";
 import {
   REMIX_ERROR_CODES
 } from "./chunk-GC2MOT3U.js";
@@ -116,6 +116,9 @@ function sanitizeCheckoutDirName(value) {
   const sanitized = value.trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
   return sanitized || "remix-remix";
 }
+function buildDashboardAppUrl(appId) {
+  return `https://dashboard.remix.one/apps/${encodeURIComponent(appId)}`;
+}
 async function pollAppReady(api, appId) {
   const started = Date.now();
   let delay = 2e3;
@@ -1277,6 +1280,163 @@ async function collabApprove(params) {
   };
 }
 
+// src/application/collab/checkoutWorkspace.ts
+import fs4 from "fs/promises";
+import os3 from "os";
+import path4 from "path";
+async function pathExists(targetPath) {
+  try {
+    await fs4.access(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function statIsDirectory(targetPath) {
+  const stats = await fs4.stat(targetPath).catch(() => null);
+  return Boolean(stats?.isDirectory());
+}
+async function findContainingGitRoot(startPath) {
+  let current = path4.resolve(startPath);
+  while (true) {
+    if (await pathExists(path4.join(current, ".git"))) return current;
+    const parent = path4.dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+}
+function isSubpath(parentPath, candidatePath) {
+  const relative = path4.relative(parentPath, candidatePath);
+  return relative === "" || !relative.startsWith("..") && !path4.isAbsolute(relative);
+}
+function buildPreferredCheckoutBranch(appId) {
+  const normalized = appId.trim().replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+  return `remix/remix/${normalized || "app"}`;
+}
+async function resolveCheckoutDestination(params) {
+  if (params.outputDir?.trim()) {
+    const preferredRepoRoot = path4.resolve(params.outputDir.trim());
+    const parentDir2 = path4.dirname(preferredRepoRoot);
+    if (!await statIsDirectory(parentDir2)) {
+      throw new RemixError("Remix output parent directory does not exist.", {
+        exitCode: 2,
+        hint: `Create the directory first: ${parentDir2}`
+      });
+    }
+    return {
+      preferredRepoRoot,
+      parentDir: parentDir2,
+      explicitOutputDir: true
+    };
+  }
+  const parentDir = path4.resolve(params.cwd);
+  if (!await statIsDirectory(parentDir)) {
+    throw new RemixError("Remix output parent directory does not exist.", {
+      exitCode: 2,
+      hint: `Create the directory first: ${parentDir}`
+    });
+  }
+  return {
+    preferredRepoRoot: path4.join(parentDir, params.defaultDirName),
+    parentDir,
+    explicitOutputDir: false
+  };
+}
+async function assertSafeCheckoutDestination(params) {
+  const callerGitRoot = await findContainingGitRoot(params.cwd);
+  if (callerGitRoot && isSubpath(callerGitRoot, params.repoRoot)) {
+    throw new RemixError("Refusing to create a remix checkout inside an existing git repository.", {
+      exitCode: 2,
+      hint: params.explicitOutputDir ? `Choose a destination outside ${callerGitRoot}.` : `Pass --output-dir outside ${callerGitRoot}.`
+    });
+  }
+  const parentGitRoot = await findContainingGitRoot(params.parentDir);
+  if (parentGitRoot && isSubpath(parentGitRoot, params.repoRoot)) {
+    throw new RemixError("Refusing to create a remix checkout inside an existing git repository.", {
+      exitCode: 2,
+      hint: params.explicitOutputDir ? `Choose a destination outside ${parentGitRoot}.` : `Pass --output-dir outside ${parentGitRoot}.`
+    });
+  }
+}
+async function materializeAppCheckout(params) {
+  const destination = await resolveCheckoutDestination({
+    cwd: params.cwd,
+    outputDir: params.outputDir ?? null,
+    defaultDirName: params.defaultDirName
+  });
+  await assertSafeCheckoutDestination({
+    cwd: params.cwd,
+    repoRoot: destination.preferredRepoRoot,
+    parentDir: destination.parentDir,
+    explicitOutputDir: destination.explicitOutputDir
+  });
+  const repoRoot = destination.explicitOutputDir ? await reserveDirectory(destination.preferredRepoRoot) : await reserveAvailableDirPath(destination.preferredRepoRoot);
+  const bundleTempDir = await fs4.mkdtemp(path4.join(os3.tmpdir(), "remix-checkout-"));
+  const bundlePath = path4.join(bundleTempDir, "repository.bundle");
+  try {
+    const bundle = await params.api.downloadAppBundle(params.appId);
+    await fs4.writeFile(bundlePath, bundle.data);
+    await cloneGitBundleToDirectory(bundlePath, repoRoot);
+    await checkoutLocalBranch(repoRoot, buildPreferredCheckoutBranch(params.appId));
+    await ensureGitInfoExcludeEntries(repoRoot, [".remix/"]);
+  } catch (err) {
+    await fs4.rm(repoRoot, { recursive: true, force: true }).catch(() => {
+    });
+    throw err;
+  } finally {
+    await fs4.rm(bundleTempDir, { recursive: true, force: true });
+  }
+  const remoteUrl = normalizeGitRemote(await getRemoteOriginUrl(repoRoot));
+  const defaultBranch = await getDefaultBranch(repoRoot) ?? await getCurrentBranch(repoRoot) ?? null;
+  const preferredBranch = await getCurrentBranch(repoRoot) ?? buildPreferredCheckoutBranch(params.appId);
+  const repoFingerprint = remoteUrl ? await buildRepoFingerprint({ gitRoot: repoRoot, remoteUrl, defaultBranch }) : null;
+  return {
+    repoRoot,
+    remoteUrl,
+    defaultBranch,
+    preferredBranch,
+    repoFingerprint
+  };
+}
+
+// src/application/collab/collabCheckout.ts
+async function collabCheckout(params) {
+  const appId = params.appId?.trim() || null;
+  if (!appId) {
+    throw new RemixError("No app selected.", {
+      exitCode: 2,
+      hint: "Pass the app id to checkout."
+    });
+  }
+  const app = await pollAppReady(params.api, appId);
+  const checkout = await materializeAppCheckout({
+    api: params.api,
+    cwd: params.cwd,
+    appId: String(app.id),
+    outputDir: params.outputDir ?? null,
+    defaultDirName: sanitizeCheckoutDirName(String(app.name || app.id))
+  });
+  const upstreamAppId = String(app.forkedFromAppId ?? app.id);
+  const bindingPath = await writeCollabBinding(checkout.repoRoot, {
+    projectId: String(app.projectId),
+    currentAppId: String(app.id),
+    upstreamAppId,
+    threadId: app.threadId ? String(app.threadId) : null,
+    repoFingerprint: checkout.repoFingerprint,
+    remoteUrl: checkout.remoteUrl,
+    defaultBranch: checkout.defaultBranch,
+    preferredBranch: checkout.preferredBranch
+  });
+  return {
+    appId: String(app.id),
+    dashboardUrl: buildDashboardAppUrl(String(app.id)),
+    projectId: String(app.projectId),
+    upstreamAppId,
+    bindingPath,
+    repoRoot: checkout.repoRoot
+  };
+}
+
 // src/application/collab/collabListMergeRequests.ts
 var APP_SCOPED_QUEUES = /* @__PURE__ */ new Set(["app_reviewable", "app_outgoing", "app_related_visible"]);
 async function resolveQueueAppId(params) {
@@ -1322,17 +1482,81 @@ async function collabListMergeRequests(params) {
   };
 }
 
+// src/application/collab/resolveScopeTarget.ts
+async function resolveScopeTarget(params) {
+  if (params.targetId?.trim()) return params.targetId.trim();
+  const repoRoot = await findGitRoot(params.cwd);
+  const binding = await readCollabBinding(repoRoot);
+  if (!binding) {
+    throw new RemixError("Repository is not bound to Remix and no explicit target id was provided.", { exitCode: 2 });
+  }
+  if (params.scope === "project") return binding.projectId;
+  if (params.scope === "app") return binding.currentAppId;
+  const project = unwrapResponseObject(await params.api.getProject(binding.projectId), "project");
+  const organizationId = typeof project.organizationId === "string" ? project.organizationId : null;
+  if (!organizationId) {
+    throw new RemixError("Could not resolve the organization for the current repository binding.", { exitCode: 2 });
+  }
+  return organizationId;
+}
+
+// src/application/collab/collabMembers.ts
+var ORGANIZATION_MEMBER_ROLES = ["owner", "admin", "member", "viewer"];
+var WORKFLOW_MEMBER_ROLES = ["owner", "maintainer", "editor", "viewer"];
+function getMemberRolesForScope(scope) {
+  return scope === "organization" ? ORGANIZATION_MEMBER_ROLES : WORKFLOW_MEMBER_ROLES;
+}
+function validateMemberRole(scope, role) {
+  const normalized = role.trim().toLowerCase();
+  if (getMemberRolesForScope(scope).includes(normalized)) return normalized;
+  throw new RemixError(`Invalid ${scope} member role.`, {
+    exitCode: 2,
+    hint: `Allowed roles: ${getMemberRolesForScope(scope).join(", ")}`
+  });
+}
+async function collabListMembers(params) {
+  const targetId = await resolveScopeTarget({
+    api: params.api,
+    cwd: params.cwd,
+    scope: params.scope,
+    targetId: params.targetId
+  });
+  const resp = params.scope === "organization" ? await params.api.listOrganizationMembers(targetId) : params.scope === "project" ? await params.api.listProjectMembers(targetId) : await params.api.listAppMembers(targetId);
+  const members = params.scope === "organization" ? unwrapResponseObject(resp, "members") : params.scope === "project" ? unwrapResponseObject(resp, "members") : unwrapResponseObject(resp, "members");
+  return {
+    scopeType: params.scope,
+    targetId,
+    members
+  };
+}
+async function collabUpdateMemberRole(params) {
+  const targetId = await resolveScopeTarget({
+    api: params.api,
+    cwd: params.cwd,
+    scope: params.scope,
+    targetId: params.targetId
+  });
+  const role = validateMemberRole(params.scope, params.role);
+  const resp = params.scope === "organization" ? await params.api.updateOrganizationMember(targetId, params.userId, { role }) : params.scope === "project" ? await params.api.updateProjectMember(targetId, params.userId, { role }) : await params.api.updateAppMember(targetId, params.userId, { role });
+  const member = params.scope === "organization" ? unwrapResponseObject(resp, "member") : params.scope === "project" ? unwrapResponseObject(resp, "member") : unwrapResponseObject(resp, "member");
+  return {
+    scopeType: params.scope,
+    targetId,
+    member
+  };
+}
+
 // src/application/collab/collabInit.ts
-import fs6 from "fs/promises";
-import path4 from "path";
+import fs7 from "fs/promises";
+import path5 from "path";
 
 // src/shared/hash.ts
 import crypto from "crypto";
-import fs4 from "fs";
+import fs5 from "fs";
 async function sha256FileHex(filePath) {
   const hash = crypto.createHash("sha256");
   await new Promise((resolve, reject) => {
-    const stream = fs4.createReadStream(filePath);
+    const stream = fs5.createReadStream(filePath);
     stream.on("data", (chunk) => hash.update(chunk));
     stream.on("error", reject);
     stream.on("end", () => resolve());
@@ -1341,15 +1565,15 @@ async function sha256FileHex(filePath) {
 }
 
 // src/shared/upload.ts
-import fs5 from "fs";
+import fs6 from "fs";
 import { PassThrough } from "stream";
 async function uploadPresigned(params) {
-  const stats = await fs5.promises.stat(params.filePath).catch(() => null);
+  const stats = await fs6.promises.stat(params.filePath).catch(() => null);
   if (!stats || !stats.isFile()) {
     throw new RemixError("Upload file not found.", { exitCode: 2 });
   }
   const totalBytes = stats.size;
-  const fileStream = fs5.createReadStream(params.filePath);
+  const fileStream = fs6.createReadStream(params.filePath);
   const pass = new PassThrough();
   let sentBytes = 0;
   fileStream.on("data", (chunk) => {
@@ -1421,6 +1645,7 @@ async function collabInit(params) {
             reused: true,
             projectId: String(existing.projectId),
             appId: String(existing.appId),
+            dashboardUrl: buildDashboardAppUrl(String(existing.appId)),
             upstreamAppId: String(existing.upstreamAppId ?? existing.appId),
             bindingPath: bindingPath2,
             repoRoot,
@@ -1430,7 +1655,7 @@ async function collabInit(params) {
       }
       const { bundlePath, headCommitHash } = await createGitBundle(repoRoot, "repository.bundle");
       const bundleSha = await sha256FileHex(bundlePath);
-      const bundleSize = (await fs6.stat(bundlePath)).size;
+      const bundleSize = (await fs7.stat(bundlePath)).size;
       const presignResp = await params.api.presignImportUploadFirstParty({
         file: {
           name: "repository.bundle",
@@ -1447,7 +1672,7 @@ async function collabInit(params) {
       });
       const importResp = await params.api.importFromUploadFirstParty({
         uploadId: String(presign.uploadId),
-        appName: params.appName?.trim() || path4.basename(repoRoot),
+        appName: params.appName?.trim() || path5.basename(repoRoot),
         path: params.path?.trim() || void 0,
         platform: "generic",
         isPublic: false,
@@ -1476,6 +1701,7 @@ async function collabInit(params) {
         reused: false,
         projectId: String(app.projectId),
         appId: String(app.id),
+        dashboardUrl: buildDashboardAppUrl(String(app.id)),
         upstreamAppId: String(app.id),
         bindingPath,
         repoRoot,
@@ -1489,22 +1715,6 @@ async function collabInit(params) {
 }
 
 // src/application/collab/collabInvite.ts
-async function resolveScopeTarget(params) {
-  if (params.targetId?.trim()) return params.targetId.trim();
-  const repoRoot = await findGitRoot(params.cwd);
-  const binding = await readCollabBinding(repoRoot);
-  if (!binding) {
-    throw new RemixError("Repository is not bound to Remix and no explicit target id was provided.", { exitCode: 2 });
-  }
-  if (params.scope === "project") return binding.projectId;
-  if (params.scope === "app") return binding.currentAppId;
-  const project = unwrapResponseObject(await params.api.getProject(binding.projectId), "project");
-  const organizationId = typeof project.organizationId === "string" ? project.organizationId : null;
-  if (!organizationId) {
-    throw new RemixError("Could not resolve the organization for the current repository binding.", { exitCode: 2 });
-  }
-  return organizationId;
-}
 async function collabInvite(params) {
   const scope = params.scope ?? "project";
   const targetId = await resolveScopeTarget({
@@ -1535,9 +1745,9 @@ async function collabList(params) {
 }
 
 // src/application/collab/collabReconcile.ts
-import fs7 from "fs/promises";
-import os3 from "os";
-import path5 from "path";
+import fs8 from "fs/promises";
+import os4 from "os";
+import path6 from "path";
 async function collabReconcile(params) {
   const repoRoot = await findGitRoot(params.cwd);
   const binding = await readCollabBinding(repoRoot);
@@ -1608,13 +1818,13 @@ async function collabReconcile(params) {
     return previewResult;
   }
   const { bundlePath, headCommitHash: bundledHeadCommitHash } = await createGitBundle(repoRoot, "reconcile-local.bundle");
-  const bundleTempDir = path5.dirname(bundlePath);
+  const bundleTempDir = path6.dirname(bundlePath);
   try {
-    const bundleStat = await fs7.stat(bundlePath);
+    const bundleStat = await fs8.stat(bundlePath);
     const checksumSha256 = await sha256FileHex(bundlePath);
     const presignResp = await params.api.presignImportUploadFirstParty({
       file: {
-        name: path5.basename(bundlePath),
+        name: path6.basename(bundlePath),
         mimeType: "application/x-git-bundle",
         size: bundleStat.size,
         checksumSha256
@@ -1673,10 +1883,10 @@ async function collabReconcile(params) {
         });
         await hardResetToCommit(lockedRepoRoot, mergeBaseCommitHash, "`remix collab reconcile`");
         const bundleResp = await params.api.downloadAppReconcileBundle(binding.currentAppId, reconcile.id);
-        const resultTempDir = await fs7.mkdtemp(path5.join(os3.tmpdir(), "remix-reconcile-"));
-        const resultBundlePath = path5.join(resultTempDir, bundleResp.fileName ?? "reconcile-result.bundle");
+        const resultTempDir = await fs8.mkdtemp(path6.join(os4.tmpdir(), "remix-reconcile-"));
+        const resultBundlePath = path6.join(resultTempDir, bundleResp.fileName ?? "reconcile-result.bundle");
         try {
-          await fs7.writeFile(resultBundlePath, bundleResp.data);
+          await fs8.writeFile(resultBundlePath, bundleResp.data);
           await importGitBundle(lockedRepoRoot, resultBundlePath, resultBundleRef);
           await ensureCommitExists(lockedRepoRoot, reconciledHeadCommitHash);
           const localCommitHash = await fastForwardToCommit(lockedRepoRoot, reconciledHeadCommitHash);
@@ -1697,12 +1907,12 @@ async function collabReconcile(params) {
             warnings: Array.from(/* @__PURE__ */ new Set([...previewResult.warnings, ...warnings]))
           };
         } finally {
-          await fs7.rm(resultTempDir, { recursive: true, force: true });
+          await fs8.rm(resultTempDir, { recursive: true, force: true });
         }
       }
     );
   } finally {
-    await fs7.rm(bundleTempDir, { recursive: true, force: true });
+    await fs8.rm(bundleTempDir, { recursive: true, force: true });
   }
 }
 
@@ -1713,83 +1923,6 @@ async function collabReject(params) {
 }
 
 // src/application/collab/collabRemix.ts
-import fs8 from "fs/promises";
-import os4 from "os";
-import path6 from "path";
-async function pathExists(targetPath) {
-  try {
-    await fs8.access(targetPath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function statIsDirectory(targetPath) {
-  const stats = await fs8.stat(targetPath).catch(() => null);
-  return Boolean(stats?.isDirectory());
-}
-async function findContainingGitRoot(startPath) {
-  let current = path6.resolve(startPath);
-  while (true) {
-    if (await pathExists(path6.join(current, ".git"))) return current;
-    const parent = path6.dirname(current);
-    if (parent === current) return null;
-    current = parent;
-  }
-}
-function isSubpath(parentPath, candidatePath) {
-  const relative = path6.relative(parentPath, candidatePath);
-  return relative === "" || !relative.startsWith("..") && !path6.isAbsolute(relative);
-}
-function buildPreferredRemixBranch(appId) {
-  const normalized = appId.trim().replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
-  return `remix/remix/${normalized || "app"}`;
-}
-async function resolveRemixDestination(params) {
-  if (params.outputDir?.trim()) {
-    const preferredRepoRoot = path6.resolve(params.outputDir.trim());
-    const parentDir2 = path6.dirname(preferredRepoRoot);
-    if (!await statIsDirectory(parentDir2)) {
-      throw new RemixError("Remix output parent directory does not exist.", {
-        exitCode: 2,
-        hint: `Create the directory first: ${parentDir2}`
-      });
-    }
-    return {
-      preferredRepoRoot,
-      parentDir: parentDir2,
-      explicitOutputDir: true
-    };
-  }
-  const parentDir = path6.resolve(params.cwd);
-  if (!await statIsDirectory(parentDir)) {
-    throw new RemixError("Remix output parent directory does not exist.", {
-      exitCode: 2,
-      hint: `Create the directory first: ${parentDir}`
-    });
-  }
-  return {
-    preferredRepoRoot: path6.join(parentDir, params.defaultDirName),
-    parentDir,
-    explicitOutputDir: false
-  };
-}
-async function assertSafeRemixDestination(params) {
-  const callerGitRoot = await findContainingGitRoot(params.cwd);
-  if (callerGitRoot && isSubpath(callerGitRoot, params.repoRoot)) {
-    throw new RemixError("Refusing to create a remix checkout inside an existing git repository.", {
-      exitCode: 2,
-      hint: params.explicitOutputDir ? `Choose a destination outside ${callerGitRoot}.` : `Pass --output-dir outside ${callerGitRoot}.`
-    });
-  }
-  const parentGitRoot = await findContainingGitRoot(params.parentDir);
-  if (parentGitRoot && isSubpath(parentGitRoot, params.repoRoot)) {
-    throw new RemixError("Refusing to create a remix checkout inside an existing git repository.", {
-      exitCode: 2,
-      hint: params.explicitOutputDir ? `Choose a destination outside ${parentGitRoot}.` : `Pass --output-dir outside ${parentGitRoot}.`
-    });
-  }
-}
 async function collabRemix(params) {
   const sourceAppId = params.appId?.trim() || null;
   if (!sourceAppId) {
@@ -1801,54 +1934,30 @@ async function collabRemix(params) {
   const forkResp = await params.api.forkApp(sourceAppId, { name: params.name?.trim() || void 0, platform: "generic" });
   const forked = unwrapResponseObject(forkResp, "fork");
   const app = await pollAppReady(params.api, String(forked.id));
-  const baseDirName = sanitizeCheckoutDirName(String(params.name?.trim() || app.name || app.id));
-  const destination = await resolveRemixDestination({
+  const checkout = await materializeAppCheckout({
+    api: params.api,
     cwd: params.cwd,
+    appId: String(app.id),
     outputDir: params.outputDir ?? null,
-    defaultDirName: baseDirName
-  });
-  await assertSafeRemixDestination({
-    cwd: params.cwd,
-    repoRoot: destination.preferredRepoRoot,
-    parentDir: destination.parentDir,
-    explicitOutputDir: destination.explicitOutputDir
+    defaultDirName: sanitizeCheckoutDirName(String(params.name?.trim() || app.name || app.id))
   });
-  const repoRoot = destination.explicitOutputDir ? await reserveDirectory(destination.preferredRepoRoot) : await reserveAvailableDirPath(destination.preferredRepoRoot);
-  const bundleTempDir = await fs8.mkdtemp(path6.join(os4.tmpdir(), "remix-remix-"));
-  const bundlePath = path6.join(bundleTempDir, "repository.bundle");
-  try {
-    const bundle = await params.api.downloadAppBundle(String(app.id));
-    await fs8.writeFile(bundlePath, bundle.data);
-    await cloneGitBundleToDirectory(bundlePath, repoRoot);
-    await checkoutLocalBranch(repoRoot, buildPreferredRemixBranch(String(app.id)));
-    await ensureGitInfoExcludeEntries(repoRoot, [".remix/"]);
-  } catch (err) {
-    await fs8.rm(repoRoot, { recursive: true, force: true }).catch(() => {
-    });
-    throw err;
-  } finally {
-    await fs8.rm(bundleTempDir, { recursive: true, force: true });
-  }
-  const remoteUrl = normalizeGitRemote(await getRemoteOriginUrl(repoRoot));
-  const defaultBranch = await getDefaultBranch(repoRoot) ?? await getCurrentBranch(repoRoot) ?? null;
-  const preferredBranch = await getCurrentBranch(repoRoot) ?? buildPreferredRemixBranch(String(app.id));
-  const repoFingerprint = remoteUrl ? await buildRepoFingerprint({ gitRoot: repoRoot, remoteUrl, defaultBranch }) : null;
-  const bindingPath = await writeCollabBinding(repoRoot, {
+  const bindingPath = await writeCollabBinding(checkout.repoRoot, {
     projectId: String(app.projectId),
     currentAppId: String(app.id),
     upstreamAppId: String(app.forkedFromAppId ?? sourceAppId),
     threadId: app.threadId ? String(app.threadId) : null,
-    repoFingerprint,
-    remoteUrl,
-    defaultBranch,
-    preferredBranch
+    repoFingerprint: checkout.repoFingerprint,
+    remoteUrl: checkout.remoteUrl,
+    defaultBranch: checkout.defaultBranch,
+    preferredBranch: checkout.preferredBranch
   });
   return {
     appId: String(app.id),
+    dashboardUrl: buildDashboardAppUrl(String(app.id)),
     projectId: String(app.projectId),
     upstreamAppId: String(app.forkedFromAppId ?? sourceAppId),
     bindingPath,
-    repoRoot
+    repoRoot: checkout.repoRoot
   };
 }
 
@@ -2205,9 +2314,11 @@ async function collabView(params) {
 export {
   collabAdd,
   collabApprove,
+  collabCheckout,
   collabInit,
   collabInvite,
   collabList,
+  collabListMembers,
   collabListMergeRequests,
   collabReconcile,
   collabRecordTurn,
@@ -2218,5 +2329,8 @@ export {
   collabStatus,
   collabSync,
   collabSyncUpstream,
-  collabView
+  collabUpdateMemberRole,
+  collabView,
+  getMemberRolesForScope,
+  validateMemberRole
 };

package/dist/index.js

@@ -1,6 +1,6 @@
 import {
   createApiClient
-} from "./chunk-R44EOUS4.js";
+} from "./chunk-4276ARDF.js";
 import {
   createLocalSessionStore,
   createStoredSessionTokenProvider,

package/dist/repo.js

@@ -27,7 +27,7 @@ import {
   requireCurrentBranch,
   summarizeUnifiedDiff,
   writeTempUnifiedDiffBackup
-} from "./chunk-UGKPOCN5.js";
+} from "./chunk-RREREIGW.js";
 import "./chunk-GC2MOT3U.js";
 import "./chunk-YZ34ICNN.js";
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remixhq/core",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "Remix core library",
   "homepage": "https://github.com/RemixDotOne/remix-core",
   "license": "MIT",