@agent-native/core-corpus 0.212.1 → 0.213.1

package/corpus/templates/content/app/components/editor/database/github-availability.ts

@@ -0,0 +1,147 @@
+import type { ContentDatabaseSource } from "@shared/api";
+import { GITHUB_SOURCE_TYPE, githubFolderName } from "@shared/github-source";
+
+import { githubRelativeTime } from "./github-source-text";
+import { dbText } from "./text";
+
+/** The collection the Sources panel is about, as GitHub linking needs it. */
+export interface GitHubCollectionPlace {
+  databaseId: string;
+  documentId: string;
+  /** Where a new collection beside this one goes. */
+  spaceId?: string;
+  parentId: string | null;
+  systemRole: string | null;
+  pageCount: number;
+  canEdit: boolean;
+}
+
+export type GitHubBlockedReason =
+  | "files"
+  | "system"
+  | "editors-only"
+  | "other-source"
+  | "has-pages";
+
+/** Whether this collection can take a GitHub folder, and if not, why. */
+export type GitHubAvailability =
+  | { kind: "linked"; source: ContentDatabaseSource }
+  | { kind: "available" }
+  | { kind: "connect" }
+  | {
+      kind: "blocked";
+      reason: GitHubBlockedReason;
+      /** The other app the collection's pages come from. */
+      sourceName?: string;
+    };
+
+/** The app a source's pages come from, as people call it. */
+export function sourceAppName(source: ContentDatabaseSource): string {
+  if (source.sourceType === "builder-cms") return "Builder";
+  if (source.sourceType === "notion-database") return "Notion";
+  return source.sourceName;
+}
+
+/**
+ * Checks the collection before the GitHub connection, so nobody is sent
+ * through GitHub's sign-in for a collection that could never link. The server
+ * checks again when linking, for changes made in between.
+ */
+export function githubAvailability(
+  place: GitHubCollectionPlace,
+  sources: ContentDatabaseSource[],
+  connected: boolean | null | undefined,
+): GitHubAvailability {
+  const linked = sources.find(
+    (source) => source.sourceType === GITHUB_SOURCE_TYPE,
+  );
+  if (linked) return { kind: "linked", source: linked };
+  if (place.systemRole === "files") return { kind: "blocked", reason: "files" };
+  if (place.systemRole) return { kind: "blocked", reason: "system" };
+  if (!place.canEdit) return { kind: "blocked", reason: "editors-only" };
+  const other = sources[0];
+  if (other) {
+    return {
+      kind: "blocked",
+      reason: "other-source",
+      sourceName: sourceAppName(other),
+    };
+  }
+  if (place.pageCount > 0) return { kind: "blocked", reason: "has-pages" };
+  // An unknown connection is left to the dialog, which asks again.
+  return connected === false ? { kind: "connect" } : { kind: "available" };
+}
+
+/** Whether a blocked collection can point to a new one instead. */
+export function githubOffersNewCollection(
+  availability: GitHubAvailability,
+  place: GitHubCollectionPlace,
+): boolean {
+  return (
+    availability.kind === "blocked" &&
+    availability.reason !== "editors-only" &&
+    !!place.spaceId
+  );
+}
+
+/** The line under "GitHub" in Sources, always visible. */
+export function githubRowDescription(
+  availability: GitHubAvailability,
+  now = Date.now(),
+): string {
+  switch (availability.kind) {
+    case "linked": {
+      const status = availability.source.metadata.github;
+      const folder = status
+        ? githubFolderName(status)
+        : availability.source.sourceName;
+      return status?.syncedAt
+        ? dbText("githubRowLinked", {
+            folder,
+            time: githubRelativeTime(status.syncedAt, now),
+          })
+        : dbText("githubRowLinkedNotUpdated", { folder });
+    }
+    case "available":
+      return dbText("githubRowAvailable");
+    case "connect":
+      return dbText("githubRowConnectFirst");
+    case "blocked":
+      switch (availability.reason) {
+        case "files":
+          return dbText("githubRowFiles");
+        case "system":
+          return dbText("githubRowSystem");
+        case "editors-only":
+          return dbText("githubRowEditorsOnly");
+        case "other-source":
+          return dbText("githubRowOtherSource", {
+            source: availability.sourceName ?? "",
+          });
+        case "has-pages":
+          return dbText("githubRowEmptyOnly");
+      }
+  }
+}
+
+/** The full reason a blocked collection can't take a folder. */
+export function githubBlockedExplanation(
+  reason: GitHubBlockedReason,
+  place: GitHubCollectionPlace,
+  sourceName?: string,
+): string {
+  switch (reason) {
+    case "files":
+      return dbText("githubExplainFiles");
+    case "system":
+      return dbText("githubExplainSystem");
+    case "editors-only":
+      return dbText("githubExplainEditorsOnly");
+    case "other-source":
+      return dbText("githubExplainOtherSource", { source: sourceName ?? "" });
+    case "has-pages":
+      return place.pageCount === 1
+        ? dbText("githubExplainHasPagesOne")
+        : dbText("githubExplainHasPages", { count: place.pageCount });
+  }
+}

package/corpus/templates/content/app/components/editor/database/github-source-text.ts

@@ -0,0 +1,280 @@
+import { actionErrorMessage } from "@agent-native/core/client/hooks";
+import {
+  GITHUB_SOURCE_MAX_FILES,
+  parseGitHubFolderUrl,
+  type GitHubLinkBlockedReason,
+  type GitHubSourceProblemCode,
+  type GitHubSourceSkipReason,
+} from "@shared/github-source";
+
+import { dbText, type DatabaseMessageKey } from "./text";
+
+const PROBLEM_KEYS: Record<GitHubSourceProblemCode, DatabaseMessageKey> = {
+  connection: "githubProblemConnection",
+  forbidden: "githubProblemForbidden",
+  repository_not_found: "githubProblemRepositoryNotFound",
+  branch_not_found: "githubProblemBranchNotFound",
+  folder_not_found: "githubProblemFolderNotFound",
+  rate_limited: "githubProblemPaused",
+  too_large: "githubProblemTooLarge",
+  unavailable: "githubProblemPaused",
+  sync_failed: "githubProblemPaused",
+  storage_unavailable: "githubProblemStorageUnavailable",
+};
+
+const SKIP_KEYS: Record<GitHubSourceSkipReason, DatabaseMessageKey> = {
+  mdx: "githubSkipMdx",
+  "too-large": "githubSkipTooLarge",
+  "not-text": "githubSkipNotText",
+};
+
+const BLOCKED_KEYS: Record<GitHubLinkBlockedReason, DatabaseMessageKey> = {
+  "collection-has-rows": "githubLinkBlockedHasRows",
+  "already-linked": "githubLinkBlockedLinked",
+  "system-collection": "githubLinkBlockedSystem",
+};
+
+/** Where a linked folder lives, for problem text that names it. */
+export interface GitHubProblemPlace {
+  branch?: string;
+  path?: string;
+}
+
+/** A linked folder's problem, as the status line and update toasts say it. */
+export function githubProblemText(
+  code: GitHubSourceProblemCode,
+  place: GitHubProblemPlace = {},
+): string {
+  return dbText(PROBLEM_KEYS[code] ?? "githubProblemPaused", {
+    branch: place.branch ?? "",
+    folder: lastSegment(place.path ?? ""),
+    max: GITHUB_SOURCE_MAX_FILES.toLocaleString(pageLocale()),
+  });
+}
+
+/** Problems that mean nothing comes in until someone acts. */
+export function githubProblemStopsUpdates(
+  code: GitHubSourceProblemCode,
+): boolean {
+  return (
+    code === "connection" ||
+    code === "forbidden" ||
+    code === "repository_not_found" ||
+    code === "branch_not_found" ||
+    code === "folder_not_found" ||
+    code === "too_large"
+  );
+}
+
+/**
+ * The problem a `GITHUB_<CODE>` action error stands for, so the dialog can say
+ * it in the reader's language. Null for any other error.
+ */
+export function githubProblemFromErrorCode(
+  errorCode: unknown,
+): GitHubSourceProblemCode | null {
+  if (typeof errorCode !== "string" || !errorCode.startsWith("GITHUB_")) {
+    return null;
+  }
+  const code = errorCode.slice("GITHUB_".length).toLowerCase();
+  return code in PROBLEM_KEYS ? (code as GitHubSourceProblemCode) : null;
+}
+
+/** Whether an action error means GitHub needs connecting first. */
+export function githubErrorNeedsConnection(error: unknown): boolean {
+  const code = (error as { errorCode?: unknown } | null)?.errorCode;
+  // A missing or ungranted connection comes from the shared provider runtime
+  // as `connection_required`; a rejected one, from GitHub.
+  return (
+    code === "connection_required" ||
+    githubProblemFromErrorCode(code) === "connection"
+  );
+}
+
+/** The collection-level reason a link was refused, from its action error. */
+export function githubBlockedFromErrorCode(
+  errorCode: unknown,
+): GitHubLinkBlockedReason | null {
+  if (errorCode === "COLLECTION_NOT_EMPTY") return "collection-has-rows";
+  if (errorCode === "SOURCE_ALREADY_LINKED") return "already-linked";
+  if (errorCode === "COLLECTION_NOT_LINKABLE") return "system-collection";
+  return null;
+}
+
+/**
+ * A link-time error in plain words, naming what the person typed: a typo in
+ * the link reads as a typo, not as something that went missing.
+ */
+export function githubLinkErrorText(error: unknown, url: string): string {
+  const errorCode = (error as { errorCode?: unknown } | null)?.errorCode;
+  const blocked = githubBlockedFromErrorCode(errorCode);
+  if (blocked) return githubBlockedText(blocked);
+  const problem = githubProblemFromErrorCode(errorCode);
+  if (!problem) {
+    return (
+      actionErrorMessage(error) ??
+      (error instanceof Error ? error.message : dbText("githubLinkUnavailable"))
+    );
+  }
+  const parsed = parseGitHubFolderUrl(url);
+  const repo = parsed.ok ? parsed.repo : "";
+  const [branch = "", ...folder] = parsed.ok ? parsed.refPath : [];
+  switch (problem) {
+    case "repository_not_found":
+      return dbText("githubLinkRepositoryNotFound", { repo });
+    case "forbidden":
+      return dbText("githubLinkForbidden", { repo });
+    case "branch_not_found":
+      return dbText("githubLinkBranchNotFound", { branch, repo });
+    case "folder_not_found":
+      return dbText("githubLinkFolderNotFound", {
+        folder: folder.join("/"),
+        repo,
+      });
+    case "too_large":
+      return dbText("githubLinkTooLarge", {
+        max: GITHUB_SOURCE_MAX_FILES.toLocaleString(pageLocale()),
+      });
+    default:
+      return dbText("githubLinkUnavailable");
+  }
+}
+
+/** What's wrong with a link before anything is sent, if anything. */
+export function githubUrlProblem(
+  url: string,
+): { text: string; folderUrl: string | null; folder: string | null } | null {
+  const parsed = parseGitHubFolderUrl(url);
+  if (parsed.ok) return null;
+  if (parsed.reason !== "file") {
+    return {
+      text: dbText("githubLinkInvalidUrl"),
+      folderUrl: null,
+      folder: null,
+    };
+  }
+  const folder = fileLinkFolder(url);
+  return {
+    text: dbText("githubLinkFileUrl"),
+    folderUrl: folder?.url ?? null,
+    folder: folder?.name ?? null,
+  };
+}
+
+/**
+ * The folder a file link points into: `…/blob/main/docs/faq.md` becomes
+ * `…/tree/main/docs`, named "docs", or the repository at its root.
+ */
+export function fileLinkFolder(
+  url: string,
+): { url: string; name: string } | null {
+  let parsed: URL;
+  try {
+    parsed = new URL(
+      /^[a-z][a-z0-9+.-]*:\/\//i.test(url) ? url : `https://${url}`,
+    );
+    // coercion-ok: a link that isn't a URL has no folder to offer; the caller shows the invalid-link text.
+  } catch {
+    return null;
+  }
+  const segments = parsed.pathname.split("/").filter(Boolean);
+  const [owner, repo, kind, ...rest] = segments;
+  if (!owner || !repo || kind !== "blob" || rest.length < 2) return null;
+  const folderSegments = rest.slice(0, -1);
+  const folderUrl = `https://github.com/${owner}/${repo}/tree/${folderSegments.join("/")}`;
+  // The first segment is the branch, so a file at the root names the repository.
+  const name =
+    folderSegments.length > 1
+      ? decodeURIComponent(folderSegments[folderSegments.length - 1]!)
+      : decodeURIComponent(repo);
+  return parseGitHubFolderUrl(folderUrl).ok ? { url: folderUrl, name } : null;
+}
+
+export function githubSkipReasonText(reason: GitHubSourceSkipReason): string {
+  return dbText(SKIP_KEYS[reason] ?? "githubSkipNotText");
+}
+
+export function githubBlockedText(reason: GitHubLinkBlockedReason): string {
+  return dbText(BLOCKED_KEYS[reason] ?? "githubLinkBlockedLinked");
+}
+
+/** The seven-character commit name GitHub shows. */
+export function shortCommit(sha: string): string {
+  return sha.slice(0, 7);
+}
+
+function lastSegment(path: string): string {
+  const trimmed = path.replace(/\/+$/, "");
+  return trimmed.slice(trimmed.lastIndexOf("/") + 1);
+}
+
+/** The page's language, for numbers, dates and lists. */
+export function pageLocale(): string {
+  return typeof document === "undefined" || !document.documentElement.lang
+    ? "en-US"
+    : document.documentElement.lang;
+}
+
+// Not in the TypeScript lib this app targets, though every supported
+// browser has it.
+const ListFormat = (
+  Intl as typeof Intl & {
+    ListFormat?: new (
+      locale: string,
+      options: { style: "long"; type: "conjunction" },
+    ) => { format(items: string[]): string };
+  }
+).ListFormat;
+
+/** "API reference, FAQ and Getting started", in the page's language. */
+export function githubList(items: string[]): string {
+  if (!ListFormat) return items.join(", ");
+  return new ListFormat(pageLocale(), {
+    style: "long",
+    type: "conjunction",
+  }).format(items);
+}
+
+const RELATIVE_UNITS: Array<[Intl.RelativeTimeFormatUnit, number]> = [
+  ["year", 365 * 24 * 60 * 60],
+  ["month", 30 * 24 * 60 * 60],
+  ["week", 7 * 24 * 60 * 60],
+  ["day", 24 * 60 * 60],
+  ["hour", 60 * 60],
+  ["minute", 60],
+];
+
+/** "2 minutes ago", "just now" and the like, in the page's language. */
+export function githubRelativeTime(iso: string, now = Date.now()): string {
+  const at = Date.parse(iso);
+  if (!Number.isFinite(at)) return "";
+  const format = new Intl.RelativeTimeFormat(pageLocale(), {
+    numeric: "auto",
+  });
+  const seconds = Math.round((at - now) / 1000);
+  for (const [unit, size] of RELATIVE_UNITS) {
+    if (Math.abs(seconds) >= size) {
+      return format.format(Math.round(seconds / size), unit);
+    }
+  }
+  return dbText("githubJustNow");
+}
+
+/** A frontmatter example the way a writer reads it: "Yes", "Sep 15, 2026". */
+export function githubExampleText(type: string, example: string): string {
+  if (type === "checkbox") {
+    if (example === "true") return dbText("githubYes");
+    if (example === "false") return dbText("githubNo");
+  }
+  if (type === "date") {
+    const at = Date.parse(example);
+    if (Number.isFinite(at)) {
+      return new Intl.DateTimeFormat(pageLocale(), {
+        dateStyle: "medium",
+        // Frontmatter dates are calendar days, so they mustn't shift by zone.
+        timeZone: /^\d{4}-\d{2}-\d{2}$/.test(example) ? "UTC" : undefined,
+      }).format(at);
+    }
+  }
+  return example;
+}

package/corpus/templates/content/app/components/layout/Layout.tsx

@@ -26,6 +26,7 @@ import {
 import { useLocation, useNavigation } from "react-router";
 import { toast } from "sonner";
 
+import { GitHubLinkDialogHost } from "@/components/editor/database/GitHubLinkDialog";
 import { DocumentEditor } from "@/components/editor/DocumentEditor";
 import { DocumentEditorSkeleton } from "@/components/editor/DocumentEditorSkeleton";
 import { DocumentSidebar } from "@/components/sidebar/DocumentSidebar";
@@ -497,6 +498,7 @@ export function Layout({ children }: LayoutProps) {
           </>
         )}
       </div>
+      <GitHubLinkDialogHost />
     </HeaderActionsProvider>
   );
 }

package/corpus/templates/content/app/hooks/content-action-refresh.ts

@@ -30,12 +30,14 @@ const DOCUMENT_MUTATIONS = new Set([
   "delete-document",
   "delete-document-property",
   "delete-content-database",
+  "disconnect-content-database-source",
   "execute-content-trash-purge",
   "permanently-delete-document",
   "duplicate-document-property",
   "edit-document",
   "execute-builder-source-batch",
   "execute-builder-source-execution",
+  "create-github-collection",
   "import-content-source",
   "link-github-folder",
   "migrate-content-database-rows",
@@ -72,12 +74,14 @@ const DATABASE_RESULT_MUTATIONS = new Set([
   "delete-content-database",
   "delete-document",
   "delete-document-property",
+  "disconnect-content-database-source",
   "duplicate-database-item",
   "duplicate-database-items",
   "duplicate-document-property",
   "edit-document",
   "execute-builder-source-batch",
   "execute-builder-source-execution",
+  "create-github-collection",
   "import-content-source",
   "link-github-folder",
   "migrate-content-database-rows",
@@ -103,6 +107,7 @@ const DATABASE_PRESENTATION_MUTATIONS = new Set([
 ]);
 
 const DATABASE_LIFECYCLE_MUTATIONS = new Set([
+  "create-github-collection",
   "delete-content-database",
   "execute-content-trash-purge",
   "permanently-delete-document",
@@ -115,6 +120,7 @@ const DATABASE_LIFECYCLE_MUTATIONS = new Set([
 
 const DOCUMENT_DISCOVERY_MUTATIONS = new Set([
   "create-document",
+  "create-github-collection",
   "import-content",
   "link-github-folder",
   "refresh-content-database-source",

package/corpus/templates/content/app/hooks/use-content-database.ts

@@ -1837,7 +1837,9 @@ export function useRefreshContentDatabaseSource(documentId: string) {
     RefreshContentDatabaseSourceRequest
   >("refresh-content-database-source", {
     skipActionQueryInvalidation: true,
-    onSuccess: () => {
+    // A GitHub refresh that fails stores the problem on the source first, so
+    // the status line rereads after a failure too.
+    onSettled: () => {
       invalidateContentDatabaseSourceRefreshQueries(queryClient, documentId);
     },
   });

package/corpus/templates/content/app/hooks/use-github-folder.ts

@@ -0,0 +1,199 @@
+import {
+  useActionMutation,
+  useActionQuery,
+} from "@agent-native/core/client/hooks";
+import type { ContentDatabase, ContentDatabaseSource } from "@shared/api";
+import type {
+  GitHubFolderPreview,
+  GitHubLinkBlockedReason,
+  GitHubSourceProblemCode,
+} from "@shared/github-source";
+import { useQueryClient } from "@tanstack/react-query";
+import { useLocation } from "react-router";
+
+import { documentQueryFilter } from "../lib/document-query";
+import {
+  contentPlacementTargets,
+  contentSpaceFilesDatabaseId,
+  invalidateContentQueries,
+} from "./use-content-action-mutation";
+import { contentSyncInvalidatePredicate } from "./use-db-sync";
+
+type GitHubFolderAction = "link-github-folder" | "sync-github-folder";
+
+/** What a sync did, as the link and sync actions report it. */
+export interface GitHubFolderSyncSummary {
+  state: "unchanged" | "synced" | "partial" | "busy" | "error";
+  commitSha: string | null;
+  created: number;
+  updated: number;
+  renamed: number;
+  trashed: number;
+  remaining: number;
+  problem: { code: GitHubSourceProblemCode; message: string } | null;
+}
+
+export interface LinkGitHubFolderRequest {
+  databaseId: string;
+  url: string;
+  dryRun?: boolean;
+}
+
+export type LinkGitHubFolderResponse =
+  | {
+      dryRun: true;
+      database: ContentDatabase;
+      preview: GitHubFolderPreview;
+      canLink: boolean;
+      blocked: string | null;
+      blockedReason: GitHubLinkBlockedReason | null;
+      summary: string;
+    }
+  | {
+      dryRun: false;
+      database: ContentDatabase;
+      preview: GitHubFolderPreview;
+      sync: GitHubFolderSyncSummary;
+      source: ContentDatabaseSource | null;
+      summary: string;
+    };
+
+export interface CreateGitHubCollectionRequest {
+  url: string;
+  spaceId: string;
+  parentId?: string | null;
+  dryRun?: boolean;
+  idempotencyKey?: string;
+}
+
+export type CreateGitHubCollectionResponse =
+  | {
+      dryRun: true;
+      preview: GitHubFolderPreview;
+      title: string;
+      summary: string;
+    }
+  | {
+      dryRun: false;
+      database: ContentDatabase;
+      preview: GitHubFolderPreview;
+      title: string;
+      sync: GitHubFolderSyncSummary;
+      source: ContentDatabaseSource | null;
+      summary: string;
+    };
+
+export interface SyncGitHubFolderResponse {
+  database: ContentDatabase;
+  sync: GitHubFolderSyncSummary;
+  source: ContentDatabaseSource | null;
+  summary: string;
+}
+
+/**
+ * Linking or syncing a folder changes rows, Page lists and Trash. Other tabs
+ * refresh from the action's change event, but a tab ignores its own events,
+ * so this tab refreshes the same queries that event would.
+ */
+export function useRefreshAfterGitHubFolder() {
+  const queryClient = useQueryClient();
+  const { pathname } = useLocation();
+  return (actionName: GitHubFolderAction) => {
+    const spoiled = contentSyncInvalidatePredicate(queryClient, pathname);
+    const events = [{ source: "action", key: actionName }];
+    void queryClient.invalidateQueries({
+      predicate: (query) => spoiled(query, events),
+    });
+  };
+}
+
+/**
+ * Refreshes this tab after a folder action that changes rows, after a failure
+ * too: a link can be saved before its first sync fails.
+ */
+function useGitHubFolderMutation<TData, TVariables>(
+  actionName: GitHubFolderAction,
+  changesRows: (variables: TVariables) => boolean,
+) {
+  const refresh = useRefreshAfterGitHubFolder();
+  return useActionMutation<TData, TVariables>(actionName, {
+    skipActionQueryInvalidation: true,
+    onSettled: (_data, _error, variables) => {
+      if (changesRows(variables as TVariables)) refresh(actionName);
+    },
+  });
+}
+
+export function useLinkGitHubFolder() {
+  return useGitHubFolderMutation<
+    LinkGitHubFolderResponse,
+    LinkGitHubFolderRequest
+  >("link-github-folder", (variables) => !variables.dryRun);
+}
+
+export function useSyncGitHubFolder() {
+  return useGitHubFolderMutation<
+    SyncGitHubFolderResponse,
+    { databaseId: string }
+  >("sync-github-folder", () => true);
+}
+
+/**
+ * Makes a collection from a GitHub folder. The new collection shows in the
+ * sidebar and under its parent, so those lists refresh as a new collection's
+ * would, and its rows refresh like a link's.
+ */
+export function useCreateGitHubCollection() {
+  const queryClient = useQueryClient();
+  const { pathname } = useLocation();
+  return useActionMutation<
+    CreateGitHubCollectionResponse,
+    CreateGitHubCollectionRequest
+  >("create-github-collection", {
+    skipActionQueryInvalidation: true,
+    onSuccess: (data, variables) => {
+      if (data.dryRun) return;
+      const parentId = variables.parentId ?? null;
+      void queryClient.invalidateQueries(
+        documentQueryFilter(data.database.documentId),
+      );
+      invalidateContentQueries(queryClient, [
+        ...contentPlacementTargets(queryClient, {
+          documentIds: [data.database.documentId],
+          parentIds: [parentId],
+          databaseId: parentId
+            ? undefined
+            : contentSpaceFilesDatabaseId(queryClient, variables.spaceId),
+        }),
+        ["action", "list-documents"],
+        ["action", "list-content-databases"],
+      ]);
+      const spoiled = contentSyncInvalidatePredicate(queryClient, pathname);
+      const events = [{ source: "action", key: "create-github-collection" }];
+      void queryClient.invalidateQueries({
+        predicate: (query) => spoiled(query, events),
+      });
+    },
+  });
+}
+
+/** How long a connection answer holds before the Sources panel asks again. */
+const CONNECTION_STALE_MS = 60_000;
+
+/**
+ * Whether the person has a GitHub connection Content can read through, so a
+ * Collection's Sources can say "Connect your GitHub account first" before any
+ * typing. `connected` is null when GitHub couldn't be asked.
+ */
+export function useGitHubConnection(enabled: boolean) {
+  return useActionQuery<{ connected: boolean | null }>(
+    "check-github-connection",
+    {},
+    {
+      enabled,
+      retry: false,
+      staleTime: CONNECTION_STALE_MS,
+      resources: [],
+    },
+  );
+}