@opengeni/react 6.5.2-canary.41607687019001 → 6.7.0

package/dist/chunk-MNZG4OHU.js

@@ -0,0 +1,790 @@
+"use client";
+import {
+  GITHUB_RETURN_REFRESH_INTERVAL_MS,
+  REPOSITORY_OPEN_REFRESH_COOLDOWN_MS,
+  markGitHubAccessChanged,
+  returningFromGitHub
+} from "./chunk-FMDOKSHD.js";
+import {
+  buildAdditionalRepositoryResources,
+  isRepositoryResourceForGitHubRepo,
+  repositorySelectionFromResources
+} from "./chunk-ZPW5NFYD.js";
+import {
+  hasWorkspacePermission
+} from "./chunk-H2ALCTWC.js";
+import {
+  toast
+} from "./chunk-O4EA4F3W.js";
+import {
+  useAppContext
+} from "./chunk-JDFDPMKX.js";
+import {
+  ConfirmDialog
+} from "./chunk-SIRLACNZ.js";
+import {
+  userErrorText
+} from "./chunk-O4OOG3D6.js";
+
+// src/app/lib/use-follow-up-repositories.tsx
+import {
+  findSessionRemovedRepository,
+  mergeResourceRefs,
+  normalizeRepositoryTransportUri,
+  repositoryMembershipKey,
+  resourceMountPath,
+  stableJson
+} from "@opengeni/contracts";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { errorMessage } from "@opengeni/contracts/values";
+import { jsx } from "react/jsx-runtime";
+var REMOVAL_FOLDER_COPY = {
+  checking: "The agent loses access and its folder is removed.",
+  clean: "The agent loses access and its folder is removed.",
+  unsaved: "The agent loses access and its folder is removed. It has unsaved changes.",
+  unknown: "The agent loses access and its folder is removed. Couldn't check it for unsaved changes.",
+  kept: "The agent loses access. Files on your computer are left alone."
+};
+var REMOVAL_STATUS_TIMEOUT_MS = 1e4;
+function gitStatusHasUnsavedChanges(status) {
+  if (!status.isRepo) return false;
+  return status.files.length > 0 || status.ahead > 0 || !status.detached && status.head !== null && status.upstream === null;
+}
+function repositoryDisplayName(uri) {
+  const path = uri.replace(/[?#].*$/, "").replace(/\/+$/, "");
+  const name = path.slice(path.lastIndexOf("/") + 1).replace(/\.git$/i, "");
+  return name || uri;
+}
+function RepositoryRemovalDialog(props) {
+  return /* @__PURE__ */ jsx(
+    ConfirmDialog,
+    {
+      open: props.open,
+      onOpenChange: (open) => {
+        if (!open) props.onClose();
+      },
+      title: `Remove ${props.name} from this chat?`,
+      description: REMOVAL_FOLDER_COPY[props.folder],
+      confirmLabel: "Remove",
+      pendingLabel: "Removing\u2026",
+      confirmDisabled: props.folder === "checking",
+      onConfirm: props.onConfirm
+    }
+  );
+}
+function useRepositoryCatalogRefresh(workspaceId, context) {
+  const gate = useRef(
+    null
+  );
+  const canUseGitHub = hasWorkspacePermission(context.accessContext, workspaceId, "github:use");
+  const canManageGitHub = hasWorkspacePermission(
+    context.accessContext,
+    workspaceId,
+    "github:manage"
+  );
+  const canReadPersonal = hasWorkspacePermission(
+    context.accessContext,
+    workspaceId,
+    "connections:read"
+  );
+  const refresh = useCallback(
+    async (explicit) => {
+      const transition = context.captureWorkspaceInvocation(workspaceId);
+      if (!transition || !canUseGitHub && !canReadPersonal) return;
+      const key = JSON.stringify([
+        context.accessContext.subjectId,
+        workspaceId,
+        transition.revision,
+        canUseGitHub,
+        canManageGitHub,
+        canReadPersonal
+      ]);
+      const previous = gate.current;
+      const returning = !explicit && returningFromGitHub(workspaceId);
+      if (previous?.key === key) {
+        if (previous.inFlight) return previous.inFlight;
+        const cooldown = returning ? GITHUB_RETURN_REFRESH_INTERVAL_MS : REPOSITORY_OPEN_REFRESH_COOLDOWN_MS;
+        if (!explicit && Date.now() - previous.attemptedAt < cooldown) return;
+      }
+      if (canUseGitHub && context.repoBusy || canReadPersonal && context.personalGitHubBusy)
+        return;
+      const accepted = { key, attemptedAt: Date.now(), inFlight: null };
+      gate.current = accepted;
+      const request = Promise.all([
+        ...canUseGitHub ? [
+          context.refreshGitHub(workspaceId, void 0, {
+            sync: (explicit || returning) && canManageGitHub,
+            userInitiated: explicit
+          })
+        ] : [],
+        ...canReadPersonal ? [context.refreshPersonalGitHub(workspaceId, void 0, { userInitiated: explicit })] : []
+      ]).then(() => void 0);
+      accepted.inFlight = request;
+      try {
+        await request;
+      } finally {
+        accepted.inFlight = null;
+      }
+    },
+    [context, workspaceId, canUseGitHub, canManageGitHub, canReadPersonal]
+  );
+  const passiveRefresh = useRef(() => refresh(false));
+  passiveRefresh.current = () => refresh(false);
+  useEffect(() => {
+    const onReturn = () => {
+      if (document.visibilityState === "hidden" || !returningFromGitHub(workspaceId)) return;
+      void passiveRefresh.current().catch(() => void 0);
+    };
+    onReturn();
+    window.addEventListener("focus", onReturn);
+    document.addEventListener("visibilitychange", onReturn);
+    return () => {
+      window.removeEventListener("focus", onReturn);
+      document.removeEventListener("visibilitychange", onReturn);
+    };
+  }, [workspaceId]);
+  return {
+    refreshAllowed: canUseGitHub || canReadPersonal,
+    onOpenRefresh: useCallback(() => refresh(false), [refresh]),
+    onRefresh: useCallback(() => refresh(true), [refresh]),
+    onLeaveForGitHub: useCallback(() => markGitHubAccessChanged(workspaceId), [workspaceId])
+  };
+}
+function withoutMounted(pending, mounted) {
+  return new Set([...pending].filter((id) => !mounted.has(id)));
+}
+function manualDraftSignature(draft) {
+  try {
+    const uri = normalizeRepositoryTransportUri(
+      draft.url.includes("://") ? draft.url : `https://${draft.url}`
+    );
+    return `${uri}\0${draft.ref.trim()}\0${draft.expectedCommitSha ?? ""}`;
+  } catch {
+    return null;
+  }
+}
+function manualResourceSignature(resource) {
+  return `${resource.uri}\0${resource.ref}\0${resource.expectedCommitSha ?? ""}`;
+}
+function useFollowUpRepositories(session, onConnectWorkspaceApp) {
+  const context = useAppContext();
+  const catalogRefresh = useRepositoryCatalogRefresh(session.workspaceId, context);
+  const [pendingRepoIds, setPendingRepoIds] = useState(() => /* @__PURE__ */ new Set());
+  const [pendingRepoRefs, setPendingRepoRefs] = useState({});
+  const [pendingPersonalRepoIds, setPendingPersonalRepoIds] = useState(
+    () => /* @__PURE__ */ new Set()
+  );
+  const [pendingPersonalRepoRefs, setPendingPersonalRepoRefs] = useState(
+    {}
+  );
+  const [pendingManualRepos, setPendingManualRepos] = useState([]);
+  const [manualReposOpen, setManualReposOpen] = useState(false);
+  const [optimisticMountedRepos, setOptimisticMountedRepos] = useState([]);
+  const [locallyRemovedKeys, setLocallyRemovedKeys] = useState(
+    () => /* @__PURE__ */ new Set()
+  );
+  const [removal, setRemoval] = useState(null);
+  const removalCheck = useRef(null);
+  const [supersededRemovalIds, setSupersededRemovalIds] = useState({});
+  const removedRecordsRef = useRef(session.removedRepositories ?? []);
+  removedRecordsRef.current = session.removedRepositories ?? [];
+  const nextManualRepoId = useRef(1);
+  const currentSessionId = useRef(session.id);
+  currentSessionId.current = session.id;
+  const canRemoveRepositories = hasWorkspacePermission(
+    context.accessContext,
+    session.workspaceId,
+    "sessions:control"
+  );
+  const mountedResources = useMemo(() => {
+    const removedRecords = session.removedRepositories ?? [];
+    const optimistic = optimisticMountedRepos.filter((resource) => {
+      if (resource.kind !== "repository") return true;
+      const record = findSessionRemovedRepository(removedRecords, resource.uri);
+      const key = repositoryMembershipKey(resource.uri) ?? resource.uri;
+      return record === void 0 || record.id === supersededRemovalIds[key];
+    });
+    return mergeResourceRefs(session.resources, optimistic).filter(
+      (resource) => resource.kind !== "repository" || !locallyRemovedKeys.has(repositoryMembershipKey(resource.uri) ?? resource.uri)
+    );
+  }, [
+    locallyRemovedKeys,
+    optimisticMountedRepos,
+    session.removedRepositories,
+    session.resources,
+    supersededRemovalIds
+  ]);
+  const mountedRepositoryResources = useMemo(
+    () => mountedResources.filter((resource) => resource.kind === "repository"),
+    [mountedResources]
+  );
+  const mountedRepositorySelection = useMemo(
+    () => repositorySelectionFromResources(mountedRepositoryResources, context.githubRepos),
+    [context.githubRepos, mountedRepositoryResources]
+  );
+  const mountedManualRepos = useMemo(
+    () => mountedRepositorySelection.manualRepos.map((repo, index) => ({
+      ...repo,
+      id: -(index + 1)
+    })),
+    [mountedRepositorySelection.manualRepos]
+  );
+  const mountedPersonalRepoIds = useMemo(
+    () => new Set(
+      mountedRepositoryResources.flatMap(
+        (resource) => resource.connectionType === "github_personal" && typeof resource.repositoryId === "string" ? [resource.repositoryId] : []
+      )
+    ),
+    [mountedRepositoryResources]
+  );
+  const selectedPersonalRepoIds = useMemo(
+    () => /* @__PURE__ */ new Set([...mountedPersonalRepoIds, ...pendingPersonalRepoIds]),
+    [mountedPersonalRepoIds, pendingPersonalRepoIds]
+  );
+  const selectedPersonalRepoRefs = useMemo(() => {
+    const mounted = Object.fromEntries(
+      mountedRepositoryResources.flatMap(
+        (resource) => resource.connectionType === "github_personal" ? [[resource.repositoryId, resource.ref]] : []
+      )
+    );
+    return { ...mounted, ...pendingPersonalRepoRefs };
+  }, [mountedRepositoryResources, pendingPersonalRepoRefs]);
+  const lockedManualRepoIds = useMemo(
+    () => new Set(mountedManualRepos.map((repo) => repo.id)),
+    [mountedManualRepos]
+  );
+  const selectedRepoIds = useMemo(
+    () => /* @__PURE__ */ new Set([...mountedRepositorySelection.selectedRepoIds, ...pendingRepoIds]),
+    [mountedRepositorySelection.selectedRepoIds, pendingRepoIds]
+  );
+  const selectedRepoRefs = useMemo(
+    () => ({ ...mountedRepositorySelection.selectedRepoRefs, ...pendingRepoRefs }),
+    [mountedRepositorySelection.selectedRepoRefs, pendingRepoRefs]
+  );
+  const pendingBuild = useMemo(() => {
+    try {
+      return {
+        resources: buildAdditionalRepositoryResources({
+          mountedResources,
+          manualRepos: pendingManualRepos,
+          repositories: context.githubRepos,
+          // A pending pick that became mounted elsewhere (for example from a
+          // conversation card) is already in the chat; never resend or
+          // conflict-check it against its own mount.
+          selectedRepoIds: withoutMounted(
+            pendingRepoIds,
+            mountedRepositorySelection.selectedRepoIds
+          ),
+          selectedRepoRefs: pendingRepoRefs,
+          personalRepositories: context.personalGitHubRepositories,
+          selectedPersonalRepositoryIds: withoutMounted(
+            pendingPersonalRepoIds,
+            mountedPersonalRepoIds
+          ),
+          selectedPersonalRepositoryRefs: pendingPersonalRepoRefs,
+          personalCredentialBindingId: context.personalGitHubSelection?.credentialBindingId
+        }),
+        error: null
+      };
+    } catch (error) {
+      return {
+        resources: [],
+        error: errorMessage(error)
+      };
+    }
+  }, [
+    context.githubRepos,
+    context.personalGitHubRepositories,
+    context.personalGitHubSelection?.credentialBindingId,
+    mountedResources,
+    mountedPersonalRepoIds,
+    mountedRepositorySelection.selectedRepoIds,
+    pendingManualRepos,
+    pendingPersonalRepoIds,
+    pendingPersonalRepoRefs,
+    pendingRepoIds,
+    pendingRepoRefs
+  ]);
+  const pendingResourcesRef = useRef(pendingBuild.resources);
+  pendingResourcesRef.current = pendingBuild.resources;
+  const selectionCount = selectedRepoIds.size + selectedPersonalRepoIds.size + [...mountedManualRepos, ...pendingManualRepos].filter(
+    (repository) => repository.attached !== false && repository.url.trim().length > 0
+  ).length;
+  const togglePendingRepository = useCallback(
+    (repo) => {
+      if (mountedRepositorySelection.selectedRepoIds.has(repo.id)) return;
+      const mountedPersonalConflict = context.personalGitHubRepositories.some(
+        (personalRepo) => mountedPersonalRepoIds.has(personalRepo.repositoryId) && personalRepo.fullName.toLowerCase() === repo.fullName.toLowerCase()
+      );
+      if (mountedPersonalConflict) {
+        toast.info("This repository is already mounted as you");
+        return;
+      }
+      setPendingRepoIds((current) => {
+        const next = new Set(current);
+        if (next.has(repo.id)) next.delete(repo.id);
+        else next.add(repo.id);
+        return next;
+      });
+      setPendingRepoRefs((current) => ({
+        ...current,
+        [repo.id]: current[repo.id] ?? repo.defaultBranch
+      }));
+      const personalConflictIds = new Set(
+        context.personalGitHubRepositories.filter(
+          (personalRepo) => personalRepo.fullName.toLowerCase() === repo.fullName.toLowerCase()
+        ).map((personalRepo) => personalRepo.repositoryId)
+      );
+      setPendingPersonalRepoIds(
+        (current) => new Set([...current].filter((id) => !personalConflictIds.has(id)))
+      );
+    },
+    [
+      context.personalGitHubRepositories,
+      mountedPersonalRepoIds,
+      mountedRepositorySelection.selectedRepoIds
+    ]
+  );
+  const togglePendingPersonalRepository = useCallback(
+    async (repo) => {
+      if (mountedPersonalRepoIds.has(repo.repositoryId)) return;
+      if (pendingPersonalRepoIds.has(repo.repositoryId)) {
+        setPendingPersonalRepoIds((current) => {
+          const next = new Set(current);
+          next.delete(repo.repositoryId);
+          return next;
+        });
+        return;
+      }
+      if (!repo.selectedAccess) return;
+      const mountedWorkspaceConflict = context.githubRepos.some(
+        (workspaceRepo) => mountedRepositorySelection.selectedRepoIds.has(workspaceRepo.id) && workspaceRepo.fullName.toLowerCase() === repo.fullName.toLowerCase()
+      );
+      if (mountedWorkspaceConflict) {
+        toast.info("This repository is already mounted with the workspace GitHub App");
+        return;
+      }
+      if (!await context.ensurePersonalGitHubAuthority(session.workspaceId)) return;
+      const workspaceConflictIds = new Set(
+        context.githubRepos.filter(
+          (workspaceRepo) => workspaceRepo.fullName.toLowerCase() === repo.fullName.toLowerCase()
+        ).map((workspaceRepo) => workspaceRepo.id)
+      );
+      setPendingRepoIds(
+        (current) => new Set([...current].filter((id) => !workspaceConflictIds.has(id)))
+      );
+      setPendingPersonalRepoIds((current) => new Set(current).add(repo.repositoryId));
+      setPendingPersonalRepoRefs((current) => ({
+        ...current,
+        [repo.repositoryId]: current[repo.repositoryId] ?? repo.defaultBranch
+      }));
+    },
+    [
+      context,
+      mountedPersonalRepoIds,
+      mountedRepositorySelection.selectedRepoIds,
+      pendingPersonalRepoIds,
+      session.workspaceId
+    ]
+  );
+  const requestRepositoryRemoval = useCallback(
+    (target) => {
+      const resource = mountedRepositoryResources.find((candidate) => {
+        if (target.kind === "app")
+          return isRepositoryResourceForGitHubRepo(candidate, target.repository);
+        if (target.kind === "personal") {
+          return candidate.connectionType === "github_personal" && candidate.repositoryId === target.repository.repositoryId;
+        }
+        const key = repositoryMembershipKey(target.uri);
+        return key !== null && repositoryMembershipKey(candidate.uri) === key;
+      });
+      if (!resource) return;
+      removalCheck.current?.abort();
+      removalCheck.current = null;
+      const name = target.kind === "uri" ? repositoryDisplayName(target.uri) : target.repository.fullName.split("/").at(-1) ?? target.repository.fullName;
+      if (session.sandboxBackend === "selfhosted") {
+        setRemoval({ open: true, resource, name, folder: "kept" });
+        return;
+      }
+      const check = new AbortController();
+      removalCheck.current = check;
+      const timeout = setTimeout(() => check.abort(), REMOVAL_STATUS_TIMEOUT_MS);
+      setRemoval({ open: true, resource, name, folder: "checking" });
+      const settle = (folder) => {
+        clearTimeout(timeout);
+        if (removalCheck.current !== check) return;
+        removalCheck.current = null;
+        setRemoval(
+          (current) => current?.resource === resource ? { ...current, folder } : current
+        );
+      };
+      context.client.gitStatus(
+        session.workspaceId,
+        session.id,
+        { path: resourceMountPath(resource) },
+        { signal: check.signal }
+      ).then(
+        (status) => settle(gitStatusHasUnsavedChanges(status) ? "unsaved" : "clean"),
+        () => settle("unknown")
+      );
+    },
+    [
+      context.client,
+      mountedRepositoryResources,
+      session.id,
+      session.sandboxBackend,
+      session.workspaceId
+    ]
+  );
+  const closeRepositoryRemoval = useCallback(() => {
+    removalCheck.current?.abort();
+    removalCheck.current = null;
+    setRemoval((current) => current ? { ...current, open: false } : current);
+  }, []);
+  const confirmRepositoryRemoval = useCallback(async () => {
+    if (!removal) return false;
+    const { resource } = removal;
+    const acceptedSessionId = session.id;
+    const acceptedTransition = context.captureWorkspaceInvocation(session.workspaceId);
+    if (!acceptedTransition) return false;
+    let updated;
+    try {
+      updated = await context.client.removeSessionResources(session.workspaceId, session.id, {
+        resources: [{ kind: "repository", uri: resource.uri }]
+      });
+    } catch (error) {
+      toast.error(`Couldn't remove ${removal.name}`, { description: userErrorText(error) });
+      return false;
+    }
+    if (currentSessionId.current !== acceptedSessionId || !context.ownsWorkspaceInvocation(session.workspaceId, acceptedTransition)) {
+      return true;
+    }
+    const key = repositoryMembershipKey(resource.uri) ?? resource.uri;
+    const sameRepository = (candidate) => candidate.kind === "repository" && (repositoryMembershipKey(candidate.uri) ?? candidate.uri) === key;
+    setLocallyRemovedKeys((current) => new Set(current).add(key));
+    setOptimisticMountedRepos(
+      (current) => current.filter((candidate) => !sameRepository(candidate))
+    );
+    if (resource.githubRepositoryId !== void 0) {
+      const repositoryId = resource.githubRepositoryId;
+      setPendingRepoIds((current) => {
+        if (!current.has(repositoryId)) return current;
+        const next = new Set(current);
+        next.delete(repositoryId);
+        return next;
+      });
+    }
+    if (resource.connectionType === "github_personal" && typeof resource.repositoryId === "string") {
+      const repositoryId = resource.repositoryId;
+      setPendingPersonalRepoIds((current) => {
+        if (!current.has(repositoryId)) return current;
+        const next = new Set(current);
+        next.delete(repositoryId);
+        return next;
+      });
+    }
+    context.setSession((current) => {
+      if (!current || current.id !== updated.id) return current;
+      const { removedRepositories: _previous, ...rest } = current;
+      return {
+        ...rest,
+        resources: updated.resources,
+        ...updated.removedRepositories ? { removedRepositories: updated.removedRepositories } : {}
+      };
+    });
+    return true;
+  }, [context, removal, session.id, session.workspaceId]);
+  const removalDialog = /* @__PURE__ */ jsx(
+    RepositoryRemovalDialog,
+    {
+      open: removal?.open === true,
+      name: removal?.name ?? "",
+      folder: removal?.folder ?? "clean",
+      onClose: closeRepositoryRemoval,
+      onConfirm: confirmRepositoryRemoval
+    }
+  );
+  const pickerProps = useCallback(
+    (disabled) => ({
+      setupMode: context.githubStatus?.setupMode ?? (context.clientConfig.productAccessMode === "managed" ? "platform" : "operator"),
+      configured: context.githubStatus?.configured === true,
+      status: context.githubStatus?.status ?? "disabled",
+      installUrl: context.githubStatus?.installUrl ?? null,
+      linkUrl: context.githubStatus?.linkUrl ?? null,
+      installations: context.githubStatus?.installations ?? [],
+      repositories: context.githubRepos,
+      personalGitHubStatus: context.personalGitHubStatus,
+      personalGitHubRepositories: context.personalGitHubRepositories,
+      selectedPersonalGitHubRepoIds: selectedPersonalRepoIds,
+      selectedPersonalGitHubRepoRefs: selectedPersonalRepoRefs,
+      personalGitHubBusy: context.personalGitHubBusy,
+      personalGitHubManageUrl: `/workspaces/${encodeURIComponent(session.workspaceId)}/plugins?open=integration:github&github=personal`,
+      githubSettingsUrl: `/workspaces/${encodeURIComponent(session.workspaceId)}/plugins?open=integration:github`,
+      groups: context.repositoryGroups,
+      selectedRepoIds,
+      selectedRepoRefs,
+      manualRepos: [...mountedManualRepos, ...pendingManualRepos],
+      manualOpen: manualReposOpen,
+      org: context.githubOrg,
+      pending: disabled || context.busy,
+      repoBusy: context.repoBusy,
+      githubLoadFailed: context.githubStatusFailed && !context.githubCatalogReady,
+      githubUpdateFailed: context.githubStatusFailed && context.githubCatalogReady,
+      githubAppBusy: context.githubAppBusy,
+      lockedRepoIds: mountedRepositorySelection.selectedRepoIds,
+      lockedPersonalGitHubRepoIds: mountedPersonalRepoIds,
+      lockedManualRepoIds,
+      unavailableMountedRepositories: mountedRepositoryResources.filter(
+        (resource) => resource.connectionType === "github_personal" && (context.personalGitHubStatus?.connection?.status !== "active" || !context.personalGitHubRepositories.some(
+          (repo) => repo.repositoryId === resource.repositoryId && repo.selectedAccess !== null
+        ))
+      ),
+      validationError: pendingBuild.error,
+      ...canRemoveRepositories ? { onRemoveMountedRepository: requestRepositoryRemoval } : {},
+      ...catalogRefresh,
+      onConnectPersonalGitHub: () => void context.connectPersonalGitHub(session.workspaceId),
+      onTogglePersonalGitHubRepo: (repo) => void togglePendingPersonalRepository(repo),
+      onPersonalGitHubRefChange: (repositoryId, ref) => setPendingPersonalRepoRefs((current) => ({ ...current, [repositoryId]: ref })),
+      onToggleRepo: togglePendingRepository,
+      onRefChange: (repoId, ref) => setPendingRepoRefs((current) => ({ ...current, [repoId]: ref })),
+      onLoadGitHubBranches: async (repository) => {
+        const acceptedTransition = context.captureWorkspaceInvocation(session.workspaceId);
+        const acceptedSessionId = session.id;
+        if (!acceptedTransition) throw new Error("The session changed; refresh and try again.");
+        const { listGitHubRepositoryBranches } = await import("@opengeni/sdk/github-repositories");
+        const response = await listGitHubRepositoryBranches(
+          context.client,
+          session.workspaceId,
+          repository.installationId,
+          repository.id,
+          { limit: 100 }
+        );
+        if (currentSessionId.current !== acceptedSessionId || !context.ownsWorkspaceInvocation(session.workspaceId, acceptedTransition)) {
+          throw new Error("The session changed; refresh and try again.");
+        }
+        return response.branches;
+      },
+      onLoadPersonalGitHubBranches: async (repository) => {
+        const acceptedTransition = context.captureWorkspaceInvocation(session.workspaceId);
+        const acceptedSessionId = session.id;
+        if (!acceptedTransition) throw new Error("The session changed; refresh and try again.");
+        const connectionId = context.personalGitHubStatus?.connection?.id;
+        if (!connectionId) throw new Error("Connect your GitHub identity to load branches.");
+        const { listPersonalGitHubRepositoryBranches } = await import("@opengeni/sdk/github-repositories");
+        const response = await listPersonalGitHubRepositoryBranches(
+          context.client,
+          session.workspaceId,
+          connectionId,
+          repository.repositoryId,
+          { limit: 100 }
+        );
+        if (currentSessionId.current !== acceptedSessionId || !context.ownsWorkspaceInvocation(session.workspaceId, acceptedTransition)) {
+          throw new Error("The session changed; refresh and try again.");
+        }
+        return response.branches;
+      },
+      onManualOpenChange: setManualReposOpen,
+      onManualAdd: () => {
+        const id = nextManualRepoId.current++;
+        setPendingManualRepos((current) => [
+          ...current,
+          { id, url: "", ref: "main", attached: false }
+        ]);
+        setManualReposOpen(true);
+      },
+      onManualUpdate: (id, patch) => setPendingManualRepos(
+        (current) => current.map((repo) => repo.id === id ? { ...repo, ...patch } : repo)
+      ),
+      onManualRemove: (id) => setPendingManualRepos((current) => current.filter((repo) => repo.id !== id)),
+      onManualAttach: async (repository) => {
+        const acceptedTransition = context.captureWorkspaceInvocation(session.workspaceId);
+        const acceptedSessionId = session.id;
+        if (!acceptedTransition) throw new Error("The session changed; try again.");
+        const assertCurrent = () => {
+          if (currentSessionId.current !== acceptedSessionId || !context.ownsWorkspaceInvocation(session.workspaceId, acceptedTransition)) {
+            throw new Error("The session changed; try again.");
+          }
+        };
+        assertCurrent();
+        const { attachManualRepository } = await import("./app/lib/manual-repositories.js");
+        assertCurrent();
+        return await attachManualRepository({
+          repository,
+          workspaceRepositories: context.githubRepos,
+          personalRepositories: context.personalGitHubRepositories,
+          selectWorkspaceRepository: (matched, ref) => {
+            assertCurrent();
+            const mountedPersonalConflict = context.personalGitHubRepositories.some(
+              (candidate) => mountedPersonalRepoIds.has(candidate.repositoryId) && candidate.fullName.toLowerCase() === matched.fullName.toLowerCase()
+            );
+            if (mountedPersonalConflict) {
+              throw new Error("This repository is already mounted as your GitHub identity.");
+            }
+            setPendingRepoIds((current) => new Set(current).add(matched.id));
+            setPendingRepoRefs((current) => ({ ...current, [matched.id]: ref }));
+            setPendingPersonalRepoIds(
+              (current) => new Set(
+                [...current].filter(
+                  (id) => context.personalGitHubRepositories.find((candidate) => candidate.repositoryId === id)?.fullName.toLowerCase() !== matched.fullName.toLowerCase()
+                )
+              )
+            );
+          },
+          selectPersonalRepository: async (matched, ref) => {
+            const mountedWorkspaceConflict = context.githubRepos.some(
+              (candidate) => mountedRepositorySelection.selectedRepoIds.has(candidate.id) && candidate.fullName.toLowerCase() === matched.fullName.toLowerCase()
+            );
+            if (mountedWorkspaceConflict) {
+              throw new Error("This repository is already mounted with the workspace App.");
+            }
+            if (!await context.ensurePersonalGitHubAuthority(session.workspaceId)) {
+              throw new Error("Your GitHub identity could not be authorized for this workspace.");
+            }
+            assertCurrent();
+            setPendingRepoIds(
+              (current) => new Set(
+                [...current].filter(
+                  (id) => context.githubRepos.find((candidate) => candidate.id === id)?.fullName.toLowerCase() !== matched.fullName.toLowerCase()
+                )
+              )
+            );
+            setPendingPersonalRepoIds((current) => new Set(current).add(matched.repositoryId));
+            setPendingPersonalRepoRefs((current) => ({
+              ...current,
+              [matched.repositoryId]: ref
+            }));
+          },
+          verifyPublicGitHubRepository: async (request) => {
+            const { verifyPublicGitHubRepositoryRef } = await import("@opengeni/sdk/github-repositories");
+            const verified = await verifyPublicGitHubRepositoryRef(
+              context.client,
+              session.workspaceId,
+              request
+            );
+            assertCurrent();
+            return verified;
+          },
+          attach: (attached) => {
+            assertCurrent();
+            setPendingManualRepos(
+              (current) => current.map((candidate) => candidate.id === attached.id ? attached : candidate)
+            );
+          },
+          remove: (id) => {
+            assertCurrent();
+            setPendingManualRepos((current) => current.filter((candidate) => candidate.id !== id));
+          }
+        });
+      },
+      newChatUrl: `/workspaces/${session.workspaceId}`,
+      onOrgChange: context.setGithubOrg,
+      onStartGitHubApp: () => void context.startGitHubAppManifestFlow(session.workspaceId),
+      onConnectWorkspaceApp
+    }),
+    [
+      catalogRefresh,
+      canRemoveRepositories,
+      context,
+      onConnectWorkspaceApp,
+      lockedManualRepoIds,
+      manualReposOpen,
+      mountedManualRepos,
+      mountedRepositoryResources,
+      mountedPersonalRepoIds,
+      mountedRepositorySelection.selectedRepoIds,
+      pendingBuild.error,
+      pendingManualRepos,
+      requestRepositoryRemoval,
+      selectedPersonalRepoIds,
+      selectedPersonalRepoRefs,
+      selectedRepoIds,
+      selectedRepoRefs,
+      session.id,
+      session.workspaceId,
+      togglePendingRepository,
+      togglePendingPersonalRepository
+    ]
+  );
+  const commitSent = useCallback((resources) => {
+    const repositories = resources.filter(
+      (resource) => resource.kind === "repository"
+    );
+    if (repositories.length === 0) return;
+    setOptimisticMountedRepos((current) => mergeResourceRefs(current, repositories));
+    const supersededRemovals = Object.fromEntries(
+      repositories.map((resource) => [
+        repositoryMembershipKey(resource.uri) ?? resource.uri,
+        findSessionRemovedRepository(removedRecordsRef.current, resource.uri)?.id ?? null
+      ])
+    );
+    setSupersededRemovalIds((current) => ({ ...current, ...supersededRemovals }));
+    const sentKeys = new Set(
+      repositories.map((resource) => repositoryMembershipKey(resource.uri) ?? resource.uri)
+    );
+    setLocallyRemovedKeys((current) => {
+      if (![...current].some((key) => sentKeys.has(key))) return current;
+      return new Set([...current].filter((key) => !sentKeys.has(key)));
+    });
+    const acceptedKeys = new Set(repositories.map(stableJson));
+    const pendingResources = pendingResourcesRef.current;
+    const acceptedRepoIds = new Set(
+      pendingResources.flatMap(
+        (resource) => resource.kind === "repository" && resource.githubRepositoryId !== void 0 && acceptedKeys.has(stableJson(resource)) ? [resource.githubRepositoryId] : []
+      )
+    );
+    const acceptedPersonalRepoIds = new Set(
+      pendingResources.flatMap(
+        (resource) => resource.kind === "repository" && resource.connectionType === "github_personal" && typeof resource.repositoryId === "string" && acceptedKeys.has(stableJson(resource)) ? [resource.repositoryId] : []
+      )
+    );
+    const acceptedManualDraftKeys = new Set(
+      pendingResources.flatMap((resource) => {
+        if (resource.kind !== "repository" || resource.connectionType === "github_personal" || resource.githubRepositoryId !== void 0 || resource.githubInstallationId !== void 0 || !acceptedKeys.has(stableJson(resource))) {
+          return [];
+        }
+        return [manualResourceSignature(resource)];
+      })
+    );
+    setPendingRepoIds((current) => {
+      const next = new Set([...current].filter((id) => !acceptedRepoIds.has(id)));
+      return next.size === current.size ? current : next;
+    });
+    setPendingRepoRefs((current) => {
+      const next = { ...current };
+      for (const id of acceptedRepoIds) delete next[id];
+      return Object.keys(next).length === Object.keys(current).length ? current : next;
+    });
+    setPendingPersonalRepoIds((current) => {
+      const next = new Set([...current].filter((id) => !acceptedPersonalRepoIds.has(id)));
+      return next.size === current.size ? current : next;
+    });
+    setPendingPersonalRepoRefs((current) => {
+      const next = { ...current };
+      for (const id of acceptedPersonalRepoIds) delete next[id];
+      return Object.keys(next).length === Object.keys(current).length ? current : next;
+    });
+    setPendingManualRepos((current) => {
+      const next = current.filter((draft) => {
+        const signature = manualDraftSignature(draft);
+        return signature === null || !acceptedManualDraftKeys.has(signature);
+      });
+      return next.length === current.length ? current : next;
+    });
+  }, []);
+  return {
+    pendingResources: pendingBuild.resources,
+    error: pendingBuild.error,
+    selectionCount,
+    pickerProps,
+    commitSent,
+    removalDialog
+  };
+}
+
+export {
+  gitStatusHasUnsavedChanges,
+  RepositoryRemovalDialog,
+  useRepositoryCatalogRefresh,
+  useFollowUpRepositories
+};
+//# sourceMappingURL=chunk-MNZG4OHU.js.map