@remixhq/core 0.1.5 → 0.1.7

package/dist/api.d.ts

@@ -11,6 +11,7 @@ type MergeRequest = {
     sourceTipCommitId: string | null;
     targetAppId: string;
     targetCommitId: string | null;
+    kind: "merge" | "sync";
     status: MergeRequestStatus;
     title: string | null;
     description: string | null;
@@ -203,6 +204,9 @@ type ReconcilePreflightResponse = {
     targetHeadCommitHash: string;
     warnings: string[];
 };
+type OrganizationMemberRole = "owner" | "admin" | "member" | "viewer";
+type ProjectMemberRole = "owner" | "maintainer" | "editor" | "viewer";
+type AppMemberRole = "owner" | "maintainer" | "editor" | "viewer";
 type AppReconcileResponse = {
     id: string;
     appId: string;
@@ -435,6 +439,18 @@ type ApiClient = {
         role?: string;
         ttlDays?: number;
     }): Promise<Json>;
+    listOrganizationMembers(orgId: string): Promise<Json>;
+    updateOrganizationMember(orgId: string, userId: string, payload: {
+        role: OrganizationMemberRole;
+    }): Promise<Json>;
+    listProjectMembers(projectId: string): Promise<Json>;
+    updateProjectMember(projectId: string, userId: string, payload: {
+        role: ProjectMemberRole;
+    }): Promise<Json>;
+    listAppMembers(appId: string): Promise<Json>;
+    updateAppMember(appId: string, userId: string, payload: {
+        role: AppMemberRole;
+    }): Promise<Json>;
     listOrganizationInvites(orgId: string): Promise<Json>;
     listProjectInvites(projectId: string): Promise<Json>;
     listAppInvites(appId: string): Promise<Json>;

package/dist/api.js

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

package/dist/chunk-4276ARDF.js

@@ -0,0 +1,303 @@
+import {
+  RemixError
+} from "./chunk-YZ34ICNN.js";
+
+// src/api/client.ts
+async function readJsonSafe(res) {
+  const ct = res.headers.get("content-type") ?? "";
+  if (!ct.toLowerCase().includes("application/json")) return null;
+  try {
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
+function createApiClient(config, opts) {
+  const apiKey = (opts?.apiKey ?? "").trim();
+  const tokenProvider = opts?.tokenProvider;
+  const CLIENT_KEY_HEADER = "x-comerge-api-key";
+  async function request(path, init) {
+    if (!tokenProvider) {
+      throw new RemixError("API client is missing a token provider.", {
+        exitCode: 1,
+        hint: "Configure auth before creating the Remix API client."
+      });
+    }
+    const auth = await tokenProvider();
+    const url = new URL(path, config.apiUrl).toString();
+    const doFetch = async (bearer) => fetch(url, {
+      ...init,
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/json",
+        ...init?.headers ?? {},
+        Authorization: `Bearer ${bearer}`,
+        ...apiKey ? { [CLIENT_KEY_HEADER]: apiKey } : {}
+      }
+    });
+    let res = await doFetch(auth.token);
+    if (res.status === 401 && !auth.fromEnv && auth.session?.refresh_token) {
+      const refreshed = await tokenProvider({ forceRefresh: true });
+      res = await doFetch(refreshed.token);
+    }
+    if (!res.ok) {
+      const body = await readJsonSafe(res);
+      const msg = (body && typeof body === "object" && body && "message" in body && typeof body.message === "string" ? body.message : null) ?? `Request failed (status ${res.status})`;
+      throw new RemixError(msg, { exitCode: 1, hint: body ? JSON.stringify(body, null, 2) : null });
+    }
+    const json = await readJsonSafe(res);
+    return json ?? null;
+  }
+  async function requestBinary(path, init) {
+    if (!tokenProvider) {
+      throw new RemixError("API client is missing a token provider.", {
+        exitCode: 1,
+        hint: "Configure auth before creating the Remix API client."
+      });
+    }
+    const auth = await tokenProvider();
+    const url = new URL(path, config.apiUrl).toString();
+    const doFetch = async (bearer) => fetch(url, {
+      ...init,
+      headers: {
+        Accept: "*/*",
+        ...init?.headers ?? {},
+        Authorization: `Bearer ${bearer}`,
+        ...apiKey ? { [CLIENT_KEY_HEADER]: apiKey } : {}
+      }
+    });
+    let res = await doFetch(auth.token);
+    if (res.status === 401 && !auth.fromEnv && auth.session?.refresh_token) {
+      const refreshed = await tokenProvider({ forceRefresh: true });
+      res = await doFetch(refreshed.token);
+    }
+    if (!res.ok) {
+      const body = await readJsonSafe(res);
+      const msg = (body && typeof body === "object" && body && "message" in body && typeof body.message === "string" ? body.message : null) ?? `Request failed (status ${res.status})`;
+      throw new RemixError(msg, { exitCode: 1, hint: body ? JSON.stringify(body, null, 2) : null });
+    }
+    const contentDisposition = res.headers.get("content-disposition") ?? "";
+    const fileNameMatch = contentDisposition.match(/filename=\"([^\"]+)\"/i);
+    return {
+      data: Buffer.from(await res.arrayBuffer()),
+      fileName: fileNameMatch?.[1] ?? null,
+      contentType: res.headers.get("content-type")
+    };
+  }
+  return {
+    getMe: () => request("/v1/me", { method: "GET" }),
+    listOrganizations: () => request("/v1/organizations", { method: "GET" }),
+    getOrganization: (orgId) => request(`/v1/organizations/${encodeURIComponent(orgId)}`, { method: "GET" }),
+    listProjects: (params) => {
+      const qs = new URLSearchParams();
+      if (params?.organizationId) qs.set("organizationId", params.organizationId);
+      if (params?.clientAppId) qs.set("clientAppId", params.clientAppId);
+      const suffix = qs.toString() ? `?${qs.toString()}` : "";
+      return request(`/v1/projects${suffix}`, { method: "GET" });
+    },
+    getProject: (projectId) => request(`/v1/projects/${encodeURIComponent(projectId)}`, { method: "GET" }),
+    resolveProjectBinding: (params) => {
+      const qs = new URLSearchParams();
+      if (params.repoFingerprint) qs.set("repoFingerprint", params.repoFingerprint);
+      if (params.remoteUrl) qs.set("remoteUrl", params.remoteUrl);
+      return request(`/v1/projects/bindings/resolve?${qs.toString()}`, { method: "GET" });
+    },
+    autoEnableDeveloper: () => request("/v1/developer/auto-enable", { method: "POST" }),
+    listClientApps: (params) => {
+      const qs = params?.orgId ? `?orgId=${encodeURIComponent(params.orgId)}` : "";
+      return request(`/v1/developer/client-apps${qs}`, { method: "GET" });
+    },
+    createClientApp: (payload) => request("/v1/developer/client-apps", { method: "POST", body: JSON.stringify(payload) }),
+    createClientAppKey: (clientAppId, payload) => request(`/v1/developer/client-apps/${encodeURIComponent(clientAppId)}/keys`, {
+      method: "POST",
+      body: JSON.stringify(payload ?? {})
+    }),
+    listApps: (params) => {
+      const qs = new URLSearchParams();
+      if (params?.projectId) qs.set("projectId", params.projectId);
+      if (params?.organizationId) qs.set("organizationId", params.organizationId);
+      if (params?.forked) qs.set("forked", params.forked);
+      const suffix = qs.toString() ? `?${qs.toString()}` : "";
+      return request(`/v1/apps${suffix}`, { method: "GET" });
+    },
+    getApp: (appId) => request(`/v1/apps/${encodeURIComponent(appId)}`, { method: "GET" }),
+    getMergeRequest: (mrId) => request(`/v1/merge-requests/${encodeURIComponent(mrId)}`, { method: "GET" }),
+    presignImportUpload: (payload) => request("/v1/apps/import/upload/presign", { method: "POST", body: JSON.stringify(payload) }),
+    importFromUpload: (payload) => request("/v1/apps/import/upload", { method: "POST", body: JSON.stringify(payload) }),
+    presignImportUploadFirstParty: (payload) => request("/v1/apps/import/upload/presign/first-party", { method: "POST", body: JSON.stringify(payload) }),
+    importFromUploadFirstParty: (payload) => request("/v1/apps/import/upload/first-party", { method: "POST", body: JSON.stringify(payload) }),
+    importFromGithubFirstParty: (payload) => request("/v1/apps/import/github/first-party", { method: "POST", body: JSON.stringify(payload) }),
+    forkApp: (appId, payload) => request(`/v1/apps/${encodeURIComponent(appId)}/fork`, { method: "POST", body: JSON.stringify(payload ?? {}) }),
+    downloadAppBundle: (appId) => requestBinary(`/v1/apps/${encodeURIComponent(appId)}/download.bundle`, { method: "GET" }),
+    createChangeStep: (appId, payload) => request(`/v1/apps/${encodeURIComponent(appId)}/change-steps`, {
+      method: "POST",
+      body: JSON.stringify(payload)
+    }),
+    createCollabTurn: (appId, payload) => request(`/v1/apps/${encodeURIComponent(appId)}/collab-turns`, {
+      method: "POST",
+      body: JSON.stringify(payload)
+    }),
+    listCollabTurns: (appId, params) => {
+      const qs = new URLSearchParams();
+      if (params?.limit !== void 0) qs.set("limit", String(params.limit));
+      if (params?.offset !== void 0) qs.set("offset", String(params.offset));
+      if (params?.changeStepId) qs.set("changeStepId", params.changeStepId);
+      if (params?.threadId) qs.set("threadId", params.threadId);
+      if (params?.createdAfter) qs.set("createdAfter", params.createdAfter);
+      if (params?.createdBefore) qs.set("createdBefore", params.createdBefore);
+      const suffix = qs.toString() ? `?${qs.toString()}` : "";
+      return request(`/v1/apps/${encodeURIComponent(appId)}/collab-turns${suffix}`, { method: "GET" });
+    },
+    getCollabTurn: (appId, collabTurnId) => request(`/v1/apps/${encodeURIComponent(appId)}/collab-turns/${encodeURIComponent(collabTurnId)}`, {
+      method: "GET"
+    }),
+    getAgentMemorySummary: (appId) => request(`/v1/apps/${encodeURIComponent(appId)}/agent-memory/summary`, { method: "GET" }),
+    listAgentMemoryTimeline: (appId, params) => {
+      const qs = new URLSearchParams();
+      if (params?.limit !== void 0) qs.set("limit", String(params.limit));
+      if (params?.offset !== void 0) qs.set("offset", String(params.offset));
+      if (params?.createdAfter) qs.set("createdAfter", params.createdAfter);
+      if (params?.createdBefore) qs.set("createdBefore", params.createdBefore);
+      if (params?.kinds?.length) {
+        for (const kind of params.kinds) qs.append("kinds", kind);
+      }
+      const suffix = qs.toString() ? `?${qs.toString()}` : "";
+      return request(`/v1/apps/${encodeURIComponent(appId)}/agent-memory/timeline${suffix}`, { method: "GET" });
+    },
+    searchAgentMemory: (appId, params) => {
+      const qs = new URLSearchParams();
+      qs.set("q", params.q);
+      if (params.limit !== void 0) qs.set("limit", String(params.limit));
+      if (params.offset !== void 0) qs.set("offset", String(params.offset));
+      if (params.createdAfter) qs.set("createdAfter", params.createdAfter);
+      if (params.createdBefore) qs.set("createdBefore", params.createdBefore);
+      if (params.kinds?.length) {
+        for (const kind of params.kinds) qs.append("kinds", kind);
+      }
+      return request(`/v1/apps/${encodeURIComponent(appId)}/agent-memory/search?${qs.toString()}`, { method: "GET" });
+    },
+    getChangeStep: (appId, changeStepId) => request(`/v1/apps/${encodeURIComponent(appId)}/change-steps/${encodeURIComponent(changeStepId)}`, { method: "GET" }),
+    getChangeStepDiff: (appId, changeStepId) => request(`/v1/apps/${encodeURIComponent(appId)}/change-steps/${encodeURIComponent(changeStepId)}/diff`, {
+      method: "GET"
+    }),
+    startChangeStepReplay: (appId, payload) => request(`/v1/apps/${encodeURIComponent(appId)}/change-steps/replays`, {
+      method: "POST",
+      body: JSON.stringify(payload)
+    }),
+    getChangeStepReplay: (appId, replayId) => request(`/v1/apps/${encodeURIComponent(appId)}/change-steps/replays/${encodeURIComponent(replayId)}`, {
+      method: "GET"
+    }),
+    getChangeStepReplayDiff: (appId, replayId) => request(`/v1/apps/${encodeURIComponent(appId)}/change-steps/replays/${encodeURIComponent(replayId)}/diff`, {
+      method: "GET"
+    }),
+    listMergeRequests: (params) => {
+      const qs = new URLSearchParams();
+      if (params?.queue) qs.set("queue", params.queue);
+      if (params?.appId) qs.set("appId", params.appId);
+      if (params?.sourceAppId) qs.set("sourceAppId", params.sourceAppId);
+      if (params?.targetAppId) qs.set("targetAppId", params.targetAppId);
+      if (Array.isArray(params?.status)) {
+        for (const status of params.status) qs.append("status", status);
+      } else if (typeof params?.status === "string") {
+        qs.set("status", params.status);
+      }
+      if (params?.kind) qs.set("kind", params.kind);
+      const suffix = qs.toString() ? `?${qs.toString()}` : "";
+      return request(`/v1/merge-requests${suffix}`, { method: "GET" });
+    },
+    openMergeRequest: (sourceAppId) => request("/v1/merge-requests", { method: "POST", body: JSON.stringify({ sourceAppId }) }),
+    getMergeRequestReview: (mrId) => request(`/v1/merge-requests/${encodeURIComponent(mrId)}/review`, { method: "GET" }),
+    updateMergeRequest: (mrId, payload) => request(`/v1/merge-requests/${encodeURIComponent(mrId)}`, { method: "PATCH", body: JSON.stringify(payload) }),
+    createOrganizationInvite: (orgId, payload) => request(`/v1/organizations/${encodeURIComponent(orgId)}/invitations`, {
+      method: "POST",
+      body: JSON.stringify(payload)
+    }),
+    createProjectInvite: (projectId, payload) => request(`/v1/projects/${encodeURIComponent(projectId)}/invitations`, {
+      method: "POST",
+      body: JSON.stringify(payload)
+    }),
+    createAppInvite: (appId, payload) => request(`/v1/apps/${encodeURIComponent(appId)}/invitations`, {
+      method: "POST",
+      body: JSON.stringify(payload)
+    }),
+    listOrganizationMembers: (orgId) => request(`/v1/organizations/${encodeURIComponent(orgId)}/members`, { method: "GET" }),
+    updateOrganizationMember: (orgId, userId, payload) => request(`/v1/organizations/${encodeURIComponent(orgId)}/members/${encodeURIComponent(userId)}`, {
+      method: "PATCH",
+      body: JSON.stringify(payload)
+    }),
+    listProjectMembers: (projectId) => request(`/v1/projects/${encodeURIComponent(projectId)}/members`, { method: "GET" }),
+    updateProjectMember: (projectId, userId, payload) => request(`/v1/projects/${encodeURIComponent(projectId)}/members/${encodeURIComponent(userId)}`, {
+      method: "PATCH",
+      body: JSON.stringify(payload)
+    }),
+    listAppMembers: (appId) => request(`/v1/apps/${encodeURIComponent(appId)}/members`, { method: "GET" }),
+    updateAppMember: (appId, userId, payload) => request(`/v1/apps/${encodeURIComponent(appId)}/members/${encodeURIComponent(userId)}`, {
+      method: "PATCH",
+      body: JSON.stringify(payload)
+    }),
+    listOrganizationInvites: (orgId) => request(`/v1/organizations/${encodeURIComponent(orgId)}/invitations`, { method: "GET" }),
+    listProjectInvites: (projectId) => request(`/v1/projects/${encodeURIComponent(projectId)}/invitations`, { method: "GET" }),
+    listAppInvites: (appId) => request(`/v1/apps/${encodeURIComponent(appId)}/invitations`, { method: "GET" }),
+    resendOrganizationInvite: (orgId, inviteId, payload) => request(`/v1/organizations/${encodeURIComponent(orgId)}/invitations/${encodeURIComponent(inviteId)}/resend`, {
+      method: "POST",
+      body: JSON.stringify(payload ?? {})
+    }),
+    resendProjectInvite: (projectId, inviteId, payload) => request(`/v1/projects/${encodeURIComponent(projectId)}/invitations/${encodeURIComponent(inviteId)}/resend`, {
+      method: "POST",
+      body: JSON.stringify(payload ?? {})
+    }),
+    resendAppInvite: (appId, inviteId, payload) => request(`/v1/apps/${encodeURIComponent(appId)}/invitations/${encodeURIComponent(inviteId)}/resend`, {
+      method: "POST",
+      body: JSON.stringify(payload ?? {})
+    }),
+    revokeOrganizationInvite: (orgId, inviteId) => request(`/v1/organizations/${encodeURIComponent(orgId)}/invitations/${encodeURIComponent(inviteId)}`, {
+      method: "DELETE"
+    }),
+    revokeProjectInvite: (projectId, inviteId) => request(`/v1/projects/${encodeURIComponent(projectId)}/invitations/${encodeURIComponent(inviteId)}`, {
+      method: "DELETE"
+    }),
+    revokeAppInvite: (appId, inviteId) => request(`/v1/apps/${encodeURIComponent(appId)}/invitations/${encodeURIComponent(inviteId)}`, {
+      method: "DELETE"
+    }),
+    syncUpstreamApp: (appId) => request(`/v1/apps/${encodeURIComponent(appId)}/sync-upstream`, {
+      method: "POST",
+      body: JSON.stringify({})
+    }),
+    preflightAppReconcile: (appId, payload) => request(`/v1/apps/${encodeURIComponent(appId)}/reconcile/preflight`, {
+      method: "POST",
+      body: JSON.stringify(payload)
+    }),
+    startAppReconcile: (appId, payload) => request(`/v1/apps/${encodeURIComponent(appId)}/reconcile/start`, {
+      method: "POST",
+      body: JSON.stringify(payload)
+    }),
+    getAppReconcile: (appId, reconcileId) => request(`/v1/apps/${encodeURIComponent(appId)}/reconcile/${encodeURIComponent(reconcileId)}`, { method: "GET" }),
+    downloadAppReconcileBundle: (appId, reconcileId) => requestBinary(`/v1/apps/${encodeURIComponent(appId)}/reconcile/${encodeURIComponent(reconcileId)}/download.bundle`, {
+      method: "GET"
+    }),
+    syncLocalApp: (appId, payload) => request(`/v1/apps/${encodeURIComponent(appId)}/sync-local`, {
+      method: "POST",
+      body: JSON.stringify(payload)
+    }),
+    initiateBundle: (appId, payload) => request(`/v1/apps/${encodeURIComponent(appId)}/bundles`, { method: "POST", body: JSON.stringify(payload) }),
+    getBundle: (appId, bundleId) => request(`/v1/apps/${encodeURIComponent(appId)}/bundles/${encodeURIComponent(bundleId)}`, { method: "GET" }),
+    getBundleDownloadUrl: (appId, bundleId, options) => request(
+      `/v1/apps/${encodeURIComponent(appId)}/bundles/${encodeURIComponent(bundleId)}/download?redirect=${options?.redirect ?? false}`,
+      { method: "GET" }
+    ),
+    getBundleAssetsDownloadUrl: (appId, bundleId, options) => {
+      const qs = new URLSearchParams({
+        redirect: String(options?.redirect ?? false),
+        kind: options?.kind ?? "metro-assets"
+      });
+      return request(
+        `/v1/apps/${encodeURIComponent(appId)}/bundles/${encodeURIComponent(bundleId)}/assets/download?${qs.toString()}`,
+        { method: "GET" }
+      );
+    }
+  };
+}
+
+export {
+  createApiClient
+};

package/dist/chunk-ZAQZKEH4.js

@@ -0,0 +1,46 @@
+import {
+  RemixError
+} from "./chunk-YZ34ICNN.js";
+
+// src/config/model.ts
+import { z } from "zod";
+var DEFAULT_API_URL = "http://192.168.8.242:8080";
+var DEFAULT_SUPABASE_URL = "https://xtfxwbckjpfmqubnsusu.supabase.co";
+var DEFAULT_SUPABASE_ANON_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Inh0Znh3YmNranBmbXF1Ym5zdXN1Iiwicm9sZSI6ImFub24iLCJpYXQiOjE3NjA2MDEyMzAsImV4cCI6MjA3NjE3NzIzMH0.dzWGAWrK4CvrmHVHzf8w7JlUZohdap0ZPnLZnABMV8s";
+function isValidUrl(value) {
+  try {
+    new URL(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var urlSchema = z.string().min(1).transform((s) => s.trim()).refine((s) => isValidUrl(s), "Invalid URL.").transform((s) => s.replace(/\/+$/, ""));
+var configSchema = z.object({
+  apiUrl: urlSchema,
+  supabaseUrl: urlSchema,
+  supabaseAnonKey: z.string().min(1)
+});
+var cachedConfig = null;
+async function resolveConfig(_opts) {
+  if (cachedConfig) return cachedConfig;
+  const cfgRaw = {
+    apiUrl: DEFAULT_API_URL,
+    supabaseUrl: DEFAULT_SUPABASE_URL,
+    supabaseAnonKey: DEFAULT_SUPABASE_ANON_KEY
+  };
+  const parsedCfg = configSchema.safeParse(cfgRaw);
+  if (!parsedCfg.success) {
+    throw new RemixError("Invalid core configuration.", {
+      exitCode: 1,
+      hint: parsedCfg.error.issues.map((i) => `${i.path.join(".") || "config"}: ${i.message}`).join("; ")
+    });
+  }
+  cachedConfig = parsedCfg.data;
+  return parsedCfg.data;
+}
+
+export {
+  configSchema,
+  resolveConfig
+};

package/dist/collab.d.ts

@@ -8,6 +8,7 @@ type MergeRequest = {
     sourceTipCommitId: string | null;
     targetAppId: string;
     targetCommitId: string | null;
+    kind: "merge" | "sync";
     status: MergeRequestStatus;
     title: string | null;
     description: string | null;
@@ -241,6 +242,38 @@ type CollabTurn = {
     assistantResponse: string | null;
 };
 type InvitationScopeType = "organization" | "project" | "app";
+type MembershipScopeType = InvitationScopeType;
+type OrganizationMemberRole = "owner" | "admin" | "member" | "viewer";
+type ProjectMemberRole = "owner" | "maintainer" | "editor" | "viewer";
+type AppMemberRole = "owner" | "maintainer" | "editor" | "viewer";
+type OrganizationMember = {
+    id: string;
+    userId: string;
+    organizationId: string;
+    role: OrganizationMemberRole;
+    invitedBy: string | null;
+    createdAt: string;
+    updatedAt: string;
+};
+type ProjectMember = {
+    id: string;
+    userId: string;
+    projectId: string;
+    role: ProjectMemberRole;
+    invitedBy: string | null;
+    createdAt: string;
+    updatedAt: string;
+};
+type AppMember = {
+    id: string;
+    userId: string;
+    appId: string;
+    role: AppMemberRole;
+    invitedBy: string | null;
+    createdAt: string;
+    updatedAt: string;
+};
+type CollabMember = OrganizationMember | ProjectMember | AppMember;
 type CollabApiClient = {
     resolveProjectBinding(params: {
         repoFingerprint?: string;
@@ -366,6 +399,18 @@ type CollabApiClient = {
         role?: string;
         ttlDays?: number;
     }): Promise<unknown>;
+    listOrganizationMembers(orgId: string): Promise<unknown>;
+    updateOrganizationMember(orgId: string, userId: string, payload: {
+        role: OrganizationMemberRole;
+    }): Promise<unknown>;
+    listProjectMembers(projectId: string): Promise<unknown>;
+    updateProjectMember(projectId: string, userId: string, payload: {
+        role: ProjectMemberRole;
+    }): Promise<unknown>;
+    listAppMembers(appId: string): Promise<unknown>;
+    updateAppMember(appId: string, userId: string, payload: {
+        role: AppMemberRole;
+    }): Promise<unknown>;
     listOrganizationInvites(orgId: string): Promise<unknown>;
     listProjectInvites(projectId: string): Promise<unknown>;
     listAppInvites(appId: string): Promise<unknown>;
@@ -458,6 +503,20 @@ declare function collabApprove(params: {
     allowBranchMismatch?: boolean;
 }): Promise<CollabApproveResult>;
 
+declare function collabCheckout(params: {
+    api: CollabApiClient;
+    cwd: string;
+    appId?: string | null;
+    outputDir?: string | null;
+}): Promise<{
+    appId: string;
+    dashboardUrl: string;
+    projectId: string;
+    upstreamAppId: string;
+    bindingPath: string;
+    repoRoot: string;
+}>;
+
 declare function collabListMergeRequests(params: {
     api: CollabApiClient;
     queue: MergeRequestQueue;
@@ -471,6 +530,31 @@ declare function collabListMergeRequests(params: {
     mergeRequests: MergeRequest[];
 }>;
 
+declare function getMemberRolesForScope(scope: InvitationScopeType): readonly string[];
+declare function validateMemberRole(scope: InvitationScopeType, role: string): string;
+declare function collabListMembers(params: {
+    api: CollabApiClient;
+    cwd: string;
+    scope: InvitationScopeType;
+    targetId?: string | null;
+}): Promise<{
+    scopeType: InvitationScopeType;
+    targetId: string;
+    members: CollabMember[];
+}>;
+declare function collabUpdateMemberRole(params: {
+    api: CollabApiClient;
+    cwd: string;
+    scope: InvitationScopeType;
+    targetId?: string | null;
+    userId: string;
+    role: string;
+}): Promise<{
+    scopeType: InvitationScopeType;
+    targetId: string;
+    member: CollabMember;
+}>;
+
 declare function collabInit(params: {
     api: CollabApiClient;
     cwd: string;
@@ -482,6 +566,7 @@ declare function collabInit(params: {
     reused: boolean;
     projectId: string;
     appId: string;
+    dashboardUrl: string;
     upstreamAppId: string;
     bindingPath: string;
     repoRoot: string;
@@ -490,6 +575,7 @@ declare function collabInit(params: {
     reused: boolean;
     projectId: string;
     appId: string;
+    dashboardUrl: string;
     upstreamAppId: string;
     bindingPath: string;
     repoRoot: string;
@@ -595,6 +681,7 @@ declare function collabRemix(params: {
     outputDir?: string | null;
 }): Promise<{
     appId: string;
+    dashboardUrl: string;
     projectId: string;
     upstreamAppId: string;
     bindingPath: string;
@@ -710,4 +797,4 @@ declare function collabView(params: {
     mrId: string;
 }): Promise<MergeRequestReview>;
 
-export { type AppReconcileResponse, type CollabApiClient, type CollabApproveMode, type CollabApproveResult, type CollabRecordingPreflight, type CollabRecordingPreflightStatus, type CollabStatus, type CollabStatusBlockedReason, type CollabStatusRecommendedAction, type CollabTurn, type InvitationScopeType, type JsonObject, type MergeRequest, type MergeRequestQueue, type MergeRequestReview, type MergeRequestStatus, type ReconcilePreflightResponse, type SyncLocalResponse, type SyncUpstreamResponse, collabAdd, collabApprove, collabInit, collabInvite, collabList, collabListMergeRequests, collabReconcile, collabRecordTurn, collabRecordingPreflight, collabReject, collabRemix, collabRequestMerge, collabStatus, collabSync, collabSyncUpstream, collabView };
+export { type AppMember, type AppMemberRole, type AppReconcileResponse, type CollabApiClient, type CollabApproveMode, type CollabApproveResult, type CollabMember, type CollabRecordingPreflight, type CollabRecordingPreflightStatus, type CollabStatus, type CollabStatusBlockedReason, type CollabStatusRecommendedAction, type CollabTurn, type InvitationScopeType, type JsonObject, type MembershipScopeType, type MergeRequest, type MergeRequestQueue, type MergeRequestReview, type MergeRequestStatus, type OrganizationMember, type OrganizationMemberRole, type ProjectMember, type ProjectMemberRole, type ReconcilePreflightResponse, type SyncLocalResponse, type SyncUpstreamResponse, collabAdd, collabApprove, collabCheckout, collabInit, collabInvite, collabList, collabListMembers, collabListMergeRequests, collabReconcile, collabRecordTurn, collabRecordingPreflight, collabReject, collabRemix, collabRequestMerge, collabStatus, collabSync, collabSyncUpstream, collabUpdateMemberRole, collabView, getMemberRolesForScope, validateMemberRole };

package/dist/collab.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/package.json

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