@cat-factory/app 0.249.0 → 0.250.0

package/app/components/auth/LoginScreen.vue

@@ -3,7 +3,7 @@ import { computed, ref, watch } from 'vue'
 import { apiErrorEnvelope } from '~/composables/api/errors'
 import SecretInput from '~/components/common/SecretInput.vue'
 import type { VcsProvider } from '~/types/domain'
-import { VCS_PROVIDER_ICONS, VCS_PROVIDER_LABELS, VCS_PROVIDER_TOKEN_URLS } from '~/utils/vcs'
+import { VCS_PROVIDER_ICONS, VCS_PROVIDER_LABELS, vcsTokenCreateUrl } from '~/utils/vcs'
 import { SSO_ERROR_MESSAGE_KEYS } from '~/utils/sso'
 
 const auth = useAuthStore()
@@ -21,7 +21,13 @@ type PatProvider = VcsProvider
 const ALL_PROVIDERS: PatProvider[] = ['github', 'gitlab']
 const PROVIDER_LABELS = VCS_PROVIDER_LABELS
 const PROVIDER_ICONS = VCS_PROVIDER_ICONS
-const PROVIDER_TOKEN_URLS = VCS_PROVIDER_TOKEN_URLS
+// Sign-in happens before any workspace is connected, so there is no host to read: these fall
+// back to the provider's public instance. The server's scopes-preselected `setupUrls` win when
+// the deployment supplies them.
+const PROVIDER_TOKEN_URLS: Record<PatProvider, string> = {
+  github: vcsTokenCreateUrl('github'),
+  gitlab: vcsTokenCreateUrl('gitlab'),
+}
 
 const patLoginCfg = computed(() => auth.localMode?.patLogin)
 // Providers whose token the deployment already holds: one-click sign-in. A provider without one

package/app/components/board/nodes/TaskCard.vue

@@ -459,7 +459,7 @@ function selectTask() {
           variant="soft"
           size="xs"
           icon="i-lucide-git-pull-request"
-          :title="t('board.task.openPrOnGithub', { pr: prLabel })"
+          :title="t('board.task.openPrLink', { pr: prLabel })"
           @click.stop
         >
           {{ prLabel }}

package/app/components/bootstrap/BootstrapModal.vue

@@ -160,11 +160,13 @@ const providerLabel = computed(() =>
 // must be empty or hold only a prepopulated README/.gitignore/license — the push
 // force-overwrites that boilerplate. The convenience link opens the host's own new-repo page,
 // prefilled, and is ABSENT for any host `~/utils/vcs` can't name (an unresolved provider, or a
-// GitLab whose instance nothing on the wire states); the copy and the button both key off it,
-// so what the intro promises and what renders cannot disagree.
+// deployment whose API base does not invert to a web host); the copy and the button both key off
+// it, so what the intro promises and what renders cannot disagree. The host now comes off the
+// connection (or, before one exists, off the connect option), so a GitLab deployment that states
+// one gets the button back rather than losing it to the provider alone.
 const repoOwner = computed(() => github.connection?.accountLogin ?? '')
 const createRepoUrl = computed(() =>
-  newRepoUrl(hostProvider.value, {
+  newRepoUrl(hostProvider.value, github.surfaceWebUrl, {
     owner: repoOwner.value,
     name: repoName.value.trim(),
     description: description.value.trim(),

package/app/components/github/GitHubPanel.vue

@@ -51,6 +51,39 @@ const CONNECTION_META: Record<VcsProvider, () => string> = {
 }
 const connectionMeta = computed(() => CONNECTION_META[github.provider]())
 
+// GitHub opens PULL requests, GitLab opens MERGE requests, and the panel renders both providers'
+// rows through one component. The vocabulary is therefore a per-provider set of STATIC catalog
+// keys (an exhaustive Record, so a new provider fails the typecheck rather than shipping GitHub's
+// nouns), resolved off the connected provider — the panel only ever lists one connection's repos.
+const PULL_TERMS = {
+  github: {
+    tab: 'vcs.panel.pulls.github.tab',
+    open: 'vcs.panel.pulls.github.open',
+    openSubmit: 'vcs.panel.pulls.github.openSubmit',
+    merge: 'vcs.panel.pulls.github.merge',
+    none: 'vcs.panel.pulls.github.none',
+    opened: 'vcs.panel.pulls.github.opened',
+    mergedToast: 'vcs.panel.pulls.github.mergedToast',
+    openFailed: 'vcs.panel.pulls.github.openFailed',
+  },
+  gitlab: {
+    tab: 'vcs.panel.pulls.gitlab.tab',
+    open: 'vcs.panel.pulls.gitlab.open',
+    openSubmit: 'vcs.panel.pulls.gitlab.openSubmit',
+    merge: 'vcs.panel.pulls.gitlab.merge',
+    none: 'vcs.panel.pulls.gitlab.none',
+    opened: 'vcs.panel.pulls.gitlab.opened',
+    mergedToast: 'vcs.panel.pulls.gitlab.mergedToast',
+    openFailed: 'vcs.panel.pulls.gitlab.openFailed',
+  },
+} as const satisfies Record<VcsProvider, Record<string, string>>
+const pullTerms = computed(() => PULL_TERMS[github.provider])
+
+// What the repo picker can offer, and why a repo might be missing from it, differ by how the
+// workspace authenticates rather than by provider: an App installation is shared across the
+// account and has its own access list, a pasted token reaches exactly what its owner does.
+const isAppConnection = computed(() => github.connection?.method === 'app')
+
 // On open: refresh projections when connected. The not-connected state renders
 // <GitHubConnect>, which discovers and links installations on its own.
 watch(
@@ -111,7 +144,7 @@ type Tab = 'repos' | 'pulls' | 'issues'
 const tab = ref<Tab>('repos')
 const tabs = computed<{ id: Tab; label: string; icon: string }[]>(() => [
   { id: 'repos', label: t('github.panel.tabs.repos'), icon: 'i-lucide-folder-git-2' },
-  { id: 'pulls', label: t('github.panel.tabs.pulls'), icon: 'i-lucide-git-pull-request' },
+  { id: 'pulls', label: t(pullTerms.value.tab), icon: 'i-lucide-git-pull-request' },
   { id: 'issues', label: t('github.panel.tabs.issues'), icon: 'i-lucide-circle-dot' },
 ])
 
@@ -233,9 +266,9 @@ async function openPr() {
     })
     showPrForm.value = false
     prForm.value = { repoGithubId: null, title: '', head: '', base: '' }
-    toast.add({ title: t('github.panel.toast.prOpened'), icon: 'i-lucide-check', color: 'success' })
+    toast.add({ title: t(pullTerms.value.opened), icon: 'i-lucide-check', color: 'success' })
   } catch (e) {
-    notifyError(t('github.panel.errors.openPr'), e)
+    notifyError(t(pullTerms.value.openFailed), e)
   } finally {
     openingPr.value = false
   }
@@ -258,7 +291,7 @@ async function merge(pr: GitHubPullRequest) {
   try {
     await github.mergePullRequest(pr.repoGithubId, pr.number, { method: 'squash' })
     toast.add({
-      title: t('github.panel.toast.prMerged', { number: pr.number }),
+      title: t(pullTerms.value.mergedToast, { number: pr.number }),
       icon: 'i-lucide-git-merge',
       color: 'success',
     })
@@ -378,7 +411,9 @@ async function merge(pr: GitHubPullRequest) {
               class="space-y-2 rounded-md border border-slate-700 bg-slate-900/80 p-3"
             >
               <p class="text-[12px] text-slate-400">
-                {{ t('github.panel.manageHint') }}
+                {{
+                  isAppConnection ? t('vcs.panel.manageHintApp') : t('vcs.panel.manageHintToken')
+                }}
               </p>
               <div
                 v-if="github.loadingAvailable"
@@ -388,7 +423,11 @@ async function merge(pr: GitHubPullRequest) {
                 {{ t('github.panel.loadingRepos') }}
               </div>
               <p v-else-if="!github.availableRepos.length" class="py-2 text-sm text-slate-400">
-                {{ t('github.panel.noAvailableRepos') }}
+                {{
+                  isAppConnection
+                    ? t('vcs.panel.noAvailableReposApp')
+                    : t('vcs.panel.noAvailableReposToken')
+                }}
               </p>
               <div v-else class="max-h-64 space-y-1 overflow-y-auto">
                 <button
@@ -554,7 +593,7 @@ async function merge(pr: GitHubPullRequest) {
                   }
                 "
               >
-                {{ t('github.panel.openPr') }}
+                {{ t(pullTerms.open) }}
               </UButton>
             </div>
 
@@ -599,13 +638,13 @@ async function merge(pr: GitHubPullRequest) {
                   :disabled="!canOpenPr"
                   @click="openPr"
                 >
-                  {{ t('github.panel.openPullRequest') }}
+                  {{ t(pullTerms.openSubmit) }}
                 </UButton>
               </div>
             </div>
 
             <p v-if="!github.pulls.length" class="py-4 text-sm text-slate-400">
-              {{ t('github.panel.noPulls') }}
+              {{ t(pullTerms.none) }}
             </p>
             <div
               v-for="pr in github.pulls"
@@ -634,7 +673,7 @@ async function merge(pr: GitHubPullRequest) {
                   color="neutral"
                   variant="ghost"
                   icon="i-lucide-git-merge"
-                  :aria-label="t('github.panel.mergePr')"
+                  :aria-label="t(pullTerms.merge)"
                   :loading="merging === pr.number"
                   @click="merge(pr)"
                 />

package/app/components/panels/InspectorPanel.vue

@@ -7,6 +7,7 @@ import { inspectorPanels } from '~/modular/panels/inspector.logic'
 import IconButton from '~/components/common/IconButton.vue'
 import AgentFailureCard from '~/components/board/AgentFailureCard.vue'
 import AgentStopButton from '~/components/board/AgentStopButton.vue'
+import { VCS_PROVIDER_ICONS } from '~/utils/vcs'
 
 const board = useBoardStore()
 const pipelines = usePipelinesStore()
@@ -163,19 +164,23 @@ const serviceRepo = computed(() =>
 const serviceRepoUrl = computed(() =>
   serviceRepo.value ? github.repoUrl(serviceRepo.value.githubId) : null,
 )
-
-// A task's work branch on GitHub, once the agent has pushed one (a PR branch is
-// recorded on the block). Repo linkage lives on the owning service frame, not the
-// task, so resolve the repo by walking up to the frame; fall back to deriving the
-// repo base from the PR url when the projection hasn't loaded. Null until a branch
-// exists, so the link only appears after one is created.
+// The repo link wears its own provider's mark, off the projection row rather than the
+// workspace connection, so a row is never labelled with a brand it does not belong to.
+const serviceRepoIcon = computed(() => VCS_PROVIDER_ICONS[serviceRepo.value?.provider ?? 'github'])
+
+// A task's work branch on the connected host, once the agent has pushed one (a PR branch is
+// recorded on the block). Repo linkage lives on the owning service frame, not the task, so
+// resolve the repo by walking up to the frame, and let the store build the branch path for the
+// repo's own provider (GitLab addresses a tree under `/-/`). Null until a branch exists, so the
+// link only appears after one is created, and null while the projection has not loaded: the
+// former fallback sliced `/pull/<n>` off the PR url, which silently yields nothing on a GitLab
+// merge-request url and would need a second provider guess to fix.
 const taskBranchUrl = computed(() => {
   const pr = isTask.value ? block.value?.pullRequest : undefined
   if (!pr?.branch || !block.value) return null
   const frame = board.serviceOf(block.value)
   const repo = frame ? github.repoForBlock(frame.id) : undefined
-  const base = repo ? github.repoUrl(repo.githubId) : pr.url.replace(/\/pull\/\d+$/, '')
-  return base ? `${base}/tree/${pr.branch}` : null
+  return repo ? github.branchUrl(repo.githubId, pr.branch) : null
 })
 
 // The run MODE, shared with the focus view's Run picker so the two surfaces offer (and force)
@@ -470,7 +475,7 @@ const showOriginalDescription = ref(false)
           color="neutral"
           variant="soft"
           size="xs"
-          icon="i-lucide-github"
+          :icon="serviceRepoIcon"
           trailing-icon="i-lucide-external-link"
         >
           {{ serviceRepo!.owner }}/{{ serviceRepo!.name }}

package/app/components/vcs/GitLabConnect.vue

@@ -11,7 +11,7 @@
 // flattened into a generic toast.
 import SecretInput from '~/components/common/SecretInput.vue'
 import { apiErrorEnvelope } from '~/composables/api/errors'
-import { VCS_PROVIDER_TOKEN_URLS } from '~/utils/vcs'
+import { vcsTokenCreateUrl } from '~/utils/vcs'
 
 const { t } = useI18n()
 const github = useGitHubStore()
@@ -21,7 +21,13 @@ const pat = ref('')
 const connecting = ref(false)
 const error = ref<string | null>(null)
 
-const tokenUrl = VCS_PROVIDER_TOKEN_URLS.gitlab
+// The token page on the instance this deployment would connect, not on gitlab.com: a
+// self-managed GitLab's tokens are minted on its own host. The advertised host is null when the
+// deployment's API base does not name one, and only THIS link falls back to the public instance
+// (a wrong settings page costs a click; see `~/utils/vcs`).
+const tokenUrl = computed(() =>
+  vcsTokenCreateUrl('gitlab', github.connectOptions.find((o) => o.provider === 'gitlab')?.webUrl),
+)
 
 async function connect() {
   const token = pat.value.trim()

package/app/composables/usePipelineErrorToast.ts

@@ -333,6 +333,8 @@ const UNAVAILABLE_DESCRIPTION_KEYS: Record<UnavailableReason, string> = {
   binary_generators_unreachable: 'errors.unavailable.description.binary_generators_unreachable',
   foundational_builtins_unreachable:
     'errors.unavailable.description.foundational_builtins_unreachable',
+  connection_credentials_unreadable:
+    'errors.unavailable.description.connection_credentials_unreadable',
 }
 
 /**

package/app/stores/github/vcsConnect.ts

@@ -15,6 +15,7 @@ export interface VcsProviderViews {
   canConnectGitLabPat: ComputedRef<boolean>
   soleConnectProvider: ComputedRef<VcsProvider | null>
   surfaceProvider: ComputedRef<VcsProvider | null>
+  surfaceWebUrl: ComputedRef<string | null>
 }
 
 /** The derived provider questions above, off the probed connection + capability state. */
@@ -53,12 +54,30 @@ export function createVcsProviderViews(ctx: GitHubStoreContext): VcsProviderView
     connection.value !== null ? provider.value : soleConnectProvider.value,
   )
 
+  /**
+   * The browser-facing host of the instance {@link surfaceProvider} names: the connected one's,
+   * or (with nothing bound) the host the deployment advertises for the provider it could
+   * connect. Null when neither is known, which is what a link builder needs to WITHHOLD rather
+   * than fall back to the provider's public instance.
+   *
+   * It has to come off the connect OPTION before a connection exists, because the two surfaces
+   * that need a host that early (the PAT box's token link, bootstrap's create-repository button)
+   * render while the connect box is still on screen.
+   */
+  const surfaceWebUrl = computed<string | null>(() => {
+    if (connection.value !== null) return connection.value.webUrl
+    const sole = soleConnectProvider.value
+    if (!sole) return null
+    return connectOptions.value.find((o) => o.provider === sole)?.webUrl ?? null
+  })
+
   return {
     provider,
     canConnectGitHubApp,
     canConnectGitLabPat,
     soleConnectProvider,
     surfaceProvider,
+    surfaceWebUrl,
   }
 }
 

package/app/stores/github.spec.ts

@@ -1,7 +1,7 @@
 import { describe, it, expect, vi, type Mock } from 'vitest'
 import { useGitHubStore } from '~/stores/github'
 import { useWorkspaceStore } from '~/stores/workspace'
-import type { GitHubConnection, VcsConnectOption } from '~/types/domain'
+import type { GitHubConnection, GitHubRepo, VcsConnectOption } from '~/types/domain'
 
 // The VCS connect surface of the (single, GitHub-shaped) repo store: which connect methods the
 // deployment offers, the per-workspace GitLab PAT connect, and the provider-routed disconnect.
@@ -16,6 +16,7 @@ function connection(overrides: Partial<GitHubConnection> = {}): GitHubConnection
     connectedAt: 1,
     provider: 'github',
     method: 'app',
+    webUrl: 'https://github.com',
     canCreateRepos: false,
     canManageWorkflows: true,
     ...overrides,
@@ -45,7 +46,9 @@ describe('github store — VCS connect capability', () => {
     stubApi({
       getGitHubConnection: vi.fn().mockResolvedValue({ connection: null }),
       listVcsConnectOptions: vi.fn().mockResolvedValue({
-        options: [{ provider: 'gitlab', method: 'pat' }] satisfies VcsConnectOption[],
+        options: [
+          { provider: 'gitlab', method: 'pat', webUrl: 'https://gitlab.acme.dev' },
+        ] satisfies VcsConnectOption[],
       }),
     })
     const github = storeWithWorkspace()
@@ -71,8 +74,8 @@ describe('github store — VCS connect capability', () => {
         .mockResolvedValue({ connection: connection({ provider: 'gitlab', method: 'pat' }) }),
       listVcsConnectOptions: vi.fn().mockResolvedValue({
         options: [
-          { provider: 'github', method: 'app' },
-          { provider: 'gitlab', method: 'pat' },
+          { provider: 'github', method: 'app', webUrl: 'https://github.com' },
+          { provider: 'gitlab', method: 'pat', webUrl: 'https://gitlab.acme.dev' },
         ] satisfies VcsConnectOption[],
       }),
     })
@@ -107,8 +110,8 @@ describe('github store — VCS connect capability', () => {
       getGitHubConnection: vi.fn().mockResolvedValue({ connection: null }),
       listVcsConnectOptions: vi.fn().mockResolvedValue({
         options: [
-          { provider: 'github', method: 'app' },
-          { provider: 'gitlab', method: 'pat' },
+          { provider: 'github', method: 'app', webUrl: 'https://github.com' },
+          { provider: 'gitlab', method: 'pat', webUrl: 'https://gitlab.acme.dev' },
         ] satisfies VcsConnectOption[],
       }),
     })
@@ -174,4 +177,111 @@ describe('github store — VCS connect capability', () => {
     expect(api.disconnectGitHub).toHaveBeenCalledWith('ws-1')
     expect(api.disconnectGitLab).not.toHaveBeenCalled()
   })
+
+  // The host a surface links to, before and after binding. `surfaceProvider` names the brand;
+  // this names the instance, and the two must come from the same place or the copy and the link
+  // disagree (the bootstrap modal renders both).
+  it('takes the host from the connect option before binding, and from the connection after', async () => {
+    stubApi({
+      getGitHubConnection: vi.fn().mockResolvedValue({ connection: null }),
+      listVcsConnectOptions: vi.fn().mockResolvedValue({
+        options: [
+          { provider: 'gitlab', method: 'pat', webUrl: 'https://gitlab.acme.dev' },
+        ] satisfies VcsConnectOption[],
+      }),
+      connectGitLab: vi
+        .fn()
+        .mockResolvedValue(
+          connection({ provider: 'gitlab', method: 'pat', webUrl: 'https://gitlab.acme.dev' }),
+        ),
+    })
+    const github = storeWithWorkspace()
+
+    await github.probe()
+    expect(github.surfaceWebUrl).toBe('https://gitlab.acme.dev')
+
+    await github.connectGitLab('glpat-secret')
+    expect(github.surfaceWebUrl).toBe('https://gitlab.acme.dev')
+  })
+
+  it('has no host to offer when several providers are connectable and none is bound', async () => {
+    stubApi({
+      getGitHubConnection: vi.fn().mockResolvedValue({ connection: null }),
+      listVcsConnectOptions: vi.fn().mockResolvedValue({
+        options: [
+          { provider: 'github', method: 'app', webUrl: 'https://github.com' },
+          { provider: 'gitlab', method: 'pat', webUrl: 'https://gitlab.acme.dev' },
+        ] satisfies VcsConnectOption[],
+      }),
+    })
+    const github = storeWithWorkspace()
+
+    await github.probe()
+
+    expect(github.surfaceWebUrl).toBeNull()
+  })
+})
+
+describe('github store — repo web links', () => {
+  const repo = (over: Partial<GitHubRepo> = {}): GitHubRepo => ({
+    githubId: 1,
+    installationId: 42,
+    owner: 'acme',
+    name: 'api',
+    defaultBranch: 'main',
+    private: false,
+    syncedAt: 0,
+    ...over,
+  })
+
+  async function storeWith(conn: GitHubConnection, repos: GitHubRepo[]) {
+    stubApi({
+      getGitHubConnection: vi.fn().mockResolvedValue({ connection: conn }),
+      listVcsConnectOptions: vi.fn().mockResolvedValue({ options: [] }),
+      listGitHubRepos: vi.fn().mockResolvedValue(repos),
+    })
+    const github = storeWithWorkspace()
+    await github.probe()
+    await github.load()
+    return github
+  }
+
+  // Every one of these used to be hand-built from `https://github.com`, which is right for
+  // exactly one deployment shape. The host now comes off the connection and the path shape off
+  // the repo row's own provider.
+  it('builds links on the connected instance, in the repo provider’s own shape', async () => {
+    const github = await storeWith(
+      connection({ provider: 'gitlab', method: 'pat', webUrl: 'https://gitlab.acme.dev' }),
+      [repo({ provider: 'gitlab', owner: 'acme/platform' })],
+    )
+
+    expect(github.repoUrl(1)).toBe('https://gitlab.acme.dev/acme/platform/api')
+    expect(github.pullUrl({ repoGithubId: 1, number: 7 } as never)).toBe(
+      'https://gitlab.acme.dev/acme/platform/api/-/merge_requests/7',
+    )
+    expect(github.issueUrl({ repoGithubId: 1, number: 3 } as never)).toBe(
+      'https://gitlab.acme.dev/acme/platform/api/-/issues/3',
+    )
+    expect(github.branchUrl(1, 'feat/sso')).toBe(
+      'https://gitlab.acme.dev/acme/platform/api/-/tree/feat/sso',
+    )
+  })
+
+  it('withholds every link when the deployment could not name its host', async () => {
+    const github = await storeWith(connection({ webUrl: null }), [repo()])
+
+    expect(github.repoUrl(1)).toBeNull()
+    expect(github.pullUrl({ repoGithubId: 1, number: 7 } as never)).toBeNull()
+    expect(github.branchUrl(1, 'main')).toBeNull()
+  })
+
+  // A row written before the discriminator existed is GitHub, so its links keep the GitHub shape
+  // rather than falling through to whatever the connection happens to say.
+  it('treats a repo row with no provider as GitHub', async () => {
+    const github = await storeWith(connection(), [repo()])
+
+    expect(github.pullUrl({ repoGithubId: 1, number: 7 } as never)).toBe(
+      'https://github.com/acme/api/pull/7',
+    )
+  })
 })

package/app/stores/github.ts

@@ -10,7 +10,9 @@ import type {
   GitHubRepo,
   RepoTreeEntry,
   VcsConnectOption,
+  VcsProvider,
 } from '~/types/domain'
+import { branchWebUrl, issueWebUrl, pullWebUrl, repoWebUrl } from '~/utils/vcs'
 import { useSingleFlightProbe } from '~/composables/useSingleFlightProbe'
 import { useUpsertList } from '~/composables/useUpsertList'
 import { useWorkspaceStore } from '~/stores/workspace'
@@ -94,18 +96,32 @@ export const useGitHubStore = defineStore('github', () => {
     return issues.value.filter((i) => i.repoGithubId === repoGithubId)
   }
 
-  /** Build the github.com URL for a repo / PR / issue from the projection row. */
+  // Web links for a repo / pull request / issue / branch, built from the connection's own host
+  // (`webUrl`) and the repo row's provider. Every one of these used to be a hand-built
+  // `https://github.com/…`, which is only right for a github.com deployment: a self-managed
+  // GitLab or GitHub Enterprise workspace was linked to whatever the public instance serves at
+  // that path. Null when the deployment could not name its host, so the caller withholds the
+  // link rather than pointing at an instance the repo does not live on.
   function repoUrl(repoGithubId: number): string | null {
     const r = repoFor(repoGithubId)
-    return r ? `https://github.com/${r.owner}/${r.name}` : null
+    return r ? repoWebUrl(connection.value?.webUrl, r) : null
+  }
+  /** The provider a projected row belongs to; a row predating the discriminator is GitHub. */
+  function providerOfRepo(repoGithubId: number): VcsProvider {
+    return repoFor(repoGithubId)?.provider ?? 'github'
   }
   function pullUrl(pr: GitHubPullRequest): string | null {
-    const base = repoUrl(pr.repoGithubId)
-    return base ? `${base}/pull/${pr.number}` : null
+    return pullWebUrl(providerOfRepo(pr.repoGithubId), repoUrl(pr.repoGithubId), pr.number)
   }
   function issueUrl(issue: GitHubIssue): string | null {
-    const base = repoUrl(issue.repoGithubId)
-    return base ? `${base}/issues/${issue.number}` : null
+    return issueWebUrl(
+      providerOfRepo(issue.repoGithubId),
+      repoUrl(issue.repoGithubId),
+      issue.number,
+    )
+  }
+  function branchUrl(repoGithubId: number, branch: string): string | null {
+    return branchWebUrl(providerOfRepo(repoGithubId), repoUrl(repoGithubId), branch)
   }
 
   /**
@@ -246,6 +262,7 @@ export const useGitHubStore = defineStore('github', () => {
     repoUrl,
     pullUrl,
     issueUrl,
+    branchUrl,
     probe,
     ensureProbed,
     load,