@cat-factory/app 0.249.0 → 0.250.0

package/app/utils/vcs.spec.ts

@@ -1,18 +1,23 @@
 import { describe, it, expect } from 'vitest'
 import {
   appInstallationManageUrl,
+  branchWebUrl,
+  issueWebUrl,
   newRepoUrl,
+  pullWebUrl,
+  repoWebUrl,
   VCS_PROVIDER_ICONS,
   VCS_PROVIDER_LABELS,
-  VCS_PROVIDER_TOKEN_URLS,
+  vcsTokenCreateUrl,
 } from './vcs'
 import type { GitHubConnection, VcsProvider } from '~/types/domain'
 
 /**
- * The one place VCS presentation switches on the provider. What is pinned here is the pair of
+ * The one place VCS presentation switches on the provider. What is pinned here is the set of
  * decisions a component must never make for itself: which affordances belong to a GitHub-App
- * installation (and therefore vanish on a pasted token), and which host page a manual
- * repo-creation link may open, including the hosts it must refuse to guess at.
+ * installation (and therefore vanish on a pasted token), how each provider addresses a merge
+ * request / issue / branch, and which links may fall back to a provider's public instance when
+ * the deployment could not name its own host — one may, the rest must withhold.
  */
 const connection = (over: Partial<GitHubConnection> = {}): GitHubConnection => ({
   installationId: 42,
@@ -21,6 +26,7 @@ const connection = (over: Partial<GitHubConnection> = {}): GitHubConnection => (
   connectedAt: 0,
   provider: 'github',
   method: 'app',
+  webUrl: 'https://github.com',
   canCreateRepos: false,
   canManageWorkflows: true,
   ...over,
@@ -39,6 +45,14 @@ describe('appInstallationManageUrl', () => {
     )
   })
 
+  // A GitHub Enterprise Server installation's settings live on that server, and its installation
+  // id means nothing anywhere else.
+  it('links an Enterprise installation to its own host', () => {
+    expect(appInstallationManageUrl(connection({ webUrl: 'https://ghe.acme.dev' }))).toBe(
+      'https://ghe.acme.dev/settings/installations/42',
+    )
+  })
+
   // The whole point of the helper: a pasted token has no installation, so there is no page to
   // send the user to. Both modals used to build the github.com URL from the connection
   // unconditionally, which put a "Grant the App access" button that 404s in front of every
@@ -52,6 +66,10 @@ describe('appInstallationManageUrl', () => {
     ).toBeUndefined()
   })
 
+  it('has no URL when the deployment could not name the host', () => {
+    expect(appInstallationManageUrl(connection({ webUrl: null }))).toBeUndefined()
+  })
+
   it('has no URL when there is no connection', () => {
     expect(appInstallationManageUrl(null)).toBeUndefined()
   })
@@ -60,7 +78,8 @@ describe('appInstallationManageUrl', () => {
 describe('newRepoUrl', () => {
   it('prefills the GitHub new-repository form with everything the caller knows', () => {
     const url = new URL(
-      newRepoUrl('github', { owner: 'acme', name: 'api', private: true }) ?? 'about:blank',
+      newRepoUrl('github', 'https://github.com', { owner: 'acme', name: 'api', private: true }) ??
+        'about:blank',
     )
     expect(url.origin + url.pathname).toBe('https://github.com/new')
     expect(url.searchParams.get('owner')).toBe('acme')
@@ -69,22 +88,94 @@ describe('newRepoUrl', () => {
   })
 
   it('omits what the caller has not filled in yet, and marks a public repo public', () => {
-    const url = new URL(newRepoUrl('github', { name: '', private: false }) ?? 'about:blank')
+    const url = new URL(
+      newRepoUrl('github', 'https://github.com', { name: '', private: false }) ?? 'about:blank',
+    )
     expect(url.searchParams.has('owner')).toBe(false)
     expect(url.searchParams.has('name')).toBe(false)
     expect(url.searchParams.get('visibility')).toBe('public')
   })
 
-  // A deployment may be bound to any self-hosted GitLab and nothing on the wire names its web
-  // host yet, so there is no page this can honestly open. Withheld rather than guessed at:
-  // gitlab.com would look like it worked, and the user would create the project on a server
-  // the bootstrap run never pushes to.
-  it('withholds a page for GitLab, whose instance the SPA cannot name', () => {
-    expect(newRepoUrl('gitlab', { name: 'api', private: false })).toBeUndefined()
+  // Now that the connection states its host, a self-managed GitLab gets the button back — on its
+  // OWN instance. GitLab's form takes no prefill, so it is the bare page.
+  it('opens the new-project page on the GitLab instance the workspace is bound to', () => {
+    expect(newRepoUrl('gitlab', 'https://gitlab.acme.dev', { name: 'api', private: false })).toBe(
+      'https://gitlab.acme.dev/projects/new',
+    )
+  })
+
+  // Withheld rather than guessed at: the public instance would look like it worked, and the user
+  // would create the project on a server the bootstrap run never pushes to.
+  it('withholds a page when the deployment could not name a host', () => {
+    expect(newRepoUrl('gitlab', null, { name: 'api', private: false })).toBeUndefined()
   })
 
   it('withholds a page when no provider is resolved', () => {
-    expect(newRepoUrl(null, { name: 'api', private: false })).toBeUndefined()
+    expect(
+      newRepoUrl(null, 'https://gitlab.acme.dev', { name: 'api', private: false }),
+    ).toBeUndefined()
+  })
+})
+
+describe('repo / pull / issue / branch links', () => {
+  const repo = { owner: 'acme/platform', name: 'api' }
+
+  // The repo path itself is provider-neutral: `owner` already carries GitLab's full group path,
+  // nested groups included. Only what hangs off it differs.
+  it('builds a repo page under the connection’s own host', () => {
+    expect(repoWebUrl('https://gitlab.acme.dev', repo)).toBe(
+      'https://gitlab.acme.dev/acme/platform/api',
+    )
+    expect(repoWebUrl('https://github.com/', { owner: 'acme', name: 'api' })).toBe(
+      'https://github.com/acme/api',
+    )
+  })
+
+  it('addresses a pull request and a merge request the way each provider does', () => {
+    const base = 'https://gitlab.acme.dev/acme/api'
+    expect(pullWebUrl('gitlab', base, 7)).toBe(`${base}/-/merge_requests/7`)
+    expect(pullWebUrl('github', 'https://github.com/acme/api', 7)).toBe(
+      'https://github.com/acme/api/pull/7',
+    )
+  })
+
+  it('addresses an issue and a branch the way each provider does', () => {
+    const base = 'https://gitlab.acme.dev/acme/api'
+    expect(issueWebUrl('gitlab', base, 3)).toBe(`${base}/-/issues/3`)
+    expect(branchWebUrl('gitlab', base, 'feat/sso')).toBe(`${base}/-/tree/feat/sso`)
+    expect(issueWebUrl('github', 'https://github.com/acme/api', 3)).toBe(
+      'https://github.com/acme/api/issues/3',
+    )
+    expect(branchWebUrl('github', 'https://github.com/acme/api', 'feat/sso')).toBe(
+      'https://github.com/acme/api/tree/feat/sso',
+    )
+  })
+
+  // With no host there is no repo page, and everything built on one goes with it rather than
+  // being rendered against a guessed instance.
+  it('withholds every link when the host is unknown', () => {
+    expect(repoWebUrl(null, repo)).toBeNull()
+    expect(pullWebUrl('gitlab', null, 7)).toBeNull()
+    expect(issueWebUrl('gitlab', null, 3)).toBeNull()
+    expect(branchWebUrl('gitlab', null, 'main')).toBeNull()
+  })
+})
+
+describe('vcsTokenCreateUrl', () => {
+  it('points at the token page on the instance being connected', () => {
+    expect(vcsTokenCreateUrl('gitlab', 'https://gitlab.acme.dev')).toBe(
+      'https://gitlab.acme.dev/-/user_settings/personal_access_tokens',
+    )
+  })
+
+  // The one builder that may fall back: it renders during connect (and on the sign-in screen,
+  // where nothing is connected at all), and a settings page on the wrong instance costs a click
+  // rather than a run.
+  it('falls back to the provider’s public instance when no host is known', () => {
+    expect(vcsTokenCreateUrl('gitlab')).toBe(
+      'https://gitlab.com/-/user_settings/personal_access_tokens',
+    )
+    expect(vcsTokenCreateUrl('github', null)).toBe('https://github.com/settings/tokens/new')
   })
 })
 
@@ -96,6 +187,6 @@ describe('provider presentation maps', () => {
   it.each(providers)('has a label, icon and token URL for %s', (provider) => {
     expect(VCS_PROVIDER_LABELS[provider]).toBeTruthy()
     expect(VCS_PROVIDER_ICONS[provider]).toMatch(/^i-lucide-/)
-    expect(VCS_PROVIDER_TOKEN_URLS[provider]).toMatch(/^https:\/\//)
+    expect(vcsTokenCreateUrl(provider)).toMatch(/^https:\/\//)
   })
 })

package/app/utils/vcs.ts

@@ -11,6 +11,13 @@ import type { GitHubConnection, VcsProvider } from '~/types/domain'
 //
 // Each map is an exhaustive `Record<VcsProvider, …>`: adding a provider to the union fails
 // the typecheck here instead of silently rendering a GitHub icon for it.
+//
+// EVERY link builder here takes the connection's `webUrl` — the browser-facing host the
+// backend derived from the instance the workspace is actually bound to. The SPA used to
+// hand-build `https://github.com/…`, which is right for exactly one deployment shape and sends
+// a self-managed GitLab (or GitHub Enterprise) user to whatever lives at that path on the
+// public instance. A null host means the deployment could not name one, and a builder that
+// needs one answers `undefined` so its caller drops the affordance.
 // ---------------------------------------------------------------------------
 
 /** Brand name, as rendered in titles and buttons. */
@@ -24,30 +31,58 @@ export const VCS_PROVIDER_ICONS: Record<VcsProvider, string> = {
   gitlab: 'i-lucide-gitlab',
 }
 
-/** Where a user creates a personal access token for the provider (the PAT connect flow). */
-export const VCS_PROVIDER_TOKEN_URLS: Record<VcsProvider, string> = {
-  github: 'https://github.com/settings/tokens/new',
-  gitlab: 'https://gitlab.com/-/user_settings/personal_access_tokens',
+/**
+ * The public instance of each provider, used ONLY where no host is known and a wrong link costs
+ * nothing but a click: the token-creation page during connect (see {@link vcsTokenCreateUrl}).
+ * Never for a link to a repo, a project or a namespace, where the public instance may well
+ * serve somebody else's page under the same path.
+ */
+const VCS_PROVIDER_PUBLIC_WEB_URLS: Record<VcsProvider, string> = {
+  github: 'https://github.com',
+  gitlab: 'https://gitlab.com',
+}
+
+/** Where a user creates a personal access token, relative to the instance's web root. */
+const TOKEN_SETTINGS_PATHS: Record<VcsProvider, string> = {
+  github: '/settings/tokens/new',
+  gitlab: '/-/user_settings/personal_access_tokens',
+}
+
+/** Where a user creates a repository/project by hand, relative to the instance's web root. */
+const NEW_REPO_PATHS: Record<VcsProvider, string> = {
+  github: '/new',
+  gitlab: '/projects/new',
+}
+
+/** How each provider addresses a pull/merge request and an issue under a repo's web path. */
+const PULL_PATHS: Record<VcsProvider, (n: number) => string> = {
+  github: (n) => `/pull/${n}`,
+  gitlab: (n) => `/-/merge_requests/${n}`,
+}
+const ISSUE_PATHS: Record<VcsProvider, (n: number) => string> = {
+  github: (n) => `/issues/${n}`,
+  gitlab: (n) => `/-/issues/${n}`,
+}
+const BRANCH_PATHS: Record<VcsProvider, (branch: string) => string> = {
+  github: (branch) => `/tree/${branch}`,
+  gitlab: (branch) => `/-/tree/${branch}`,
+}
+
+/** Strip a trailing slash so a host and a path never join into a double slash. */
+function root(webUrl: string): string {
+  return webUrl.replace(/\/+$/, '')
 }
 
 /**
- * Where a user creates a repository by hand, for the flows that need one to exist before a run
- * can target it, or `null` where the SPA cannot name the instance the workspace is connected
- * to, in which case the affordance is WITHHELD rather than pointed somewhere plausible.
+ * Where a user creates a personal access token on the instance they are connecting.
  *
- * `gitlab` is null for that reason: a deployment may be bound to any self-hosted instance and
- * nothing on the wire carries its web host yet (the connection is the proposed carrier; see
- * the initiative tracker's slice 5). `https://gitlab.com/projects/new` would be a guess about
- * which server the user's projects live on, and the cost of being wrong is not a dead link: a
- * project created on the wrong instance looks like success until the bootstrap push cannot
- * find it. This is the same rule the callers already apply when no provider is resolved at
- * all, so the two cases collapse into {@link newRepoUrl} returning `undefined`.
- *
- * A `Record` rather than a switch so a provider joining the union has to state its answer.
+ * The one builder that FALLS BACK to the provider's public instance when no host is known,
+ * deliberately unlike its repo-facing siblings: this renders during connect, before anything is
+ * bound, and the cost of being wrong is a settings page that isn't theirs — a click, noticed
+ * immediately. A wrong REPOSITORY link is silent and can cost a run, so those withhold instead.
  */
-const NEW_REPO_PAGES: Record<VcsProvider, string | null> = {
-  github: 'https://github.com/new',
-  gitlab: null,
+export function vcsTokenCreateUrl(provider: VcsProvider, webUrl?: string | null): string {
+  return `${root(webUrl || VCS_PROVIDER_PUBLIC_WEB_URLS[provider])}${TOKEN_SETTINGS_PATHS[provider]}`
 }
 
 /**
@@ -58,20 +93,27 @@ const NEW_REPO_PAGES: Record<VcsProvider, string | null> = {
  * token's scope and the user's project membership on the host, so there is nothing to link
  * to and the callers drop the affordance rather than pointing at a URL that 404s. Keyed on the
  * connection's own `method` (see the contract) rather than on `provider`, and asked as
- * `=== 'app'` so anything that is not an App installation withholds the link.
+ * `=== 'app'` so anything that is not an App installation withholds the link — as does an
+ * installation whose host the deployment could not name, since an installation id means nothing
+ * on an instance other than its own.
  */
 export function appInstallationManageUrl(connection: GitHubConnection | null): string | undefined {
-  if (!connection || connection.method !== 'app') return undefined
+  if (!connection || connection.method !== 'app' || !connection.webUrl) return undefined
+  const base = root(connection.webUrl)
   return connection.targetType === 'Organization'
-    ? `https://github.com/organizations/${connection.accountLogin}/settings/installations/${connection.installationId}`
-    : `https://github.com/settings/installations/${connection.installationId}`
+    ? `${base}/organizations/${connection.accountLogin}/settings/installations/${connection.installationId}`
+    : `${base}/settings/installations/${connection.installationId}`
 }
 
 /**
- * The host's new-repository page for a manual create, or `undefined` where there is no page
- * this deployment can honestly send the user to (see {@link NEW_REPO_PAGES}), including a
- * null `provider`, which is what a surface rendering before anything is connected has when
- * the deployment offers several. A caller that gets `undefined` hides the affordance.
+ * The host's new-repository page for a manual create, or `undefined` when the deployment could
+ * not name the instance (a null/absent `webUrl`) or no provider is resolved at all, which is
+ * what a surface rendering before anything is connected has when the deployment offers several.
+ * A caller that gets `undefined` hides the affordance.
+ *
+ * Withholding is the whole point: a project created on the wrong instance looks like success
+ * until the bootstrap push cannot find it, which is a failed run rather than a dead link. Now
+ * that the host is on the wire, a GitLab deployment that HAS one gets the button back.
  *
  * GitHub's form is the only one that takes a prefill, so what the bootstrap flow already
  * knows is carried over and the user creates the right repo in one click. `visibility` is
@@ -79,10 +121,11 @@ export function appInstallationManageUrl(connection: GitHubConnection | null): s
  */
 export function newRepoUrl(
   provider: VcsProvider | null,
+  webUrl: string | null | undefined,
   prefill: { owner?: string; name?: string; description?: string; private: boolean },
 ): string | undefined {
-  const page = provider ? NEW_REPO_PAGES[provider] : null
-  if (page === null) return undefined
+  if (!provider || !webUrl) return undefined
+  const page = `${root(webUrl)}${NEW_REPO_PATHS[provider]}`
   if (provider !== 'github') return page
   const params = new URLSearchParams()
   if (prefill.owner) params.set('owner', prefill.owner)
@@ -91,3 +134,44 @@ export function newRepoUrl(
   params.set('visibility', prefill.private ? 'private' : 'public')
   return `${page}?${params.toString()}`
 }
+
+/**
+ * A repository's page on the instance it lives on, or null when no host is known.
+ *
+ * `owner` is the full namespace on both providers (GitHub's `owner`, GitLab's group path,
+ * nested groups included), so the repo path itself needs no provider switch — only what hangs
+ * off it does.
+ */
+export function repoWebUrl(
+  webUrl: string | null | undefined,
+  repo: { owner: string; name: string },
+): string | null {
+  return webUrl ? `${root(webUrl)}/${repo.owner}/${repo.name}` : null
+}
+
+/** A pull request (GitHub) / merge request (GitLab) under a repo's page. */
+export function pullWebUrl(
+  provider: VcsProvider,
+  repoUrl: string | null,
+  pullNumber: number,
+): string | null {
+  return repoUrl ? `${repoUrl}${PULL_PATHS[provider](pullNumber)}` : null
+}
+
+/** An issue under a repo's page. */
+export function issueWebUrl(
+  provider: VcsProvider,
+  repoUrl: string | null,
+  issueNumber: number,
+): string | null {
+  return repoUrl ? `${repoUrl}${ISSUE_PATHS[provider](issueNumber)}` : null
+}
+
+/** A branch's file listing under a repo's page. */
+export function branchWebUrl(
+  provider: VcsProvider,
+  repoUrl: string | null,
+  branch: string,
+): string | null {
+  return repoUrl ? `${repoUrl}${BRANCH_PATHS[provider](branch)}` : null
+}

package/i18n/locales/de.json

@@ -3050,7 +3050,6 @@
       },
       "pr": "PR",
       "prNumber": "PR #{number}",
-      "openPrOnGithub": "{pr} auf GitHub öffnen",
       "readOutcome": "Ergebnis",
       "readOutcomeHint": "Lies nach, was sich geändert hat, mit den Belegen dafür",
       "review": "Überprüfen",
@@ -3064,7 +3063,8 @@
       "module": "Modul: {name}",
       "buildSteps": "Build-Schritte",
       "reviewAndApprove": "Überprüfen & freigeben",
-      "clickToViewStep": "Klicken, um Schrittdetails & Ausgabe anzuzeigen"
+      "clickToViewStep": "Klicken, um Schrittdetails & Ausgabe anzuzeigen",
+      "openPrLink": "{pr} öffnen"
     },
     "dryRunToast": {
       "title": "Probelauf gestartet",
@@ -3319,14 +3319,11 @@
       "loading": "Wird geladen…",
       "tabs": {
         "repos": "Repositorys",
-        "pulls": "Pull Requests",
         "issues": "Issues"
       },
       "linkedToBoard": "Mit diesem Board verknüpft",
       "manageRepos": "Repos verwalten",
-      "manageHint": "Wählen Sie die Repositorys aus, die dieses Board verfolgen soll. Die GitHub-Verbindung wird über den Account geteilt, und jedes Board verknüpft seine eigenen Repos.",
       "loadingRepos": "Repositorys werden geladen…",
-      "noAvailableRepos": "Die Installation kann noch auf keine Repositorys zugreifen.",
       "private": "privat",
       "saveSelection": "Auswahl speichern",
       "noLinkedRepos": "Noch keine Repositorys verknüpft. Verwenden Sie \"Repos verwalten\", um auszuwählen, welche Repositorys dieses Board verfolgt.",
@@ -3336,15 +3333,11 @@
       "fromSha": "Von SHA",
       "commitShaPlaceholder": "Commit-SHA",
       "createBranch": "Branch erstellen",
-      "openPr": "PR öffnen",
       "repository": "Repository",
       "chooseRepository": "Repository auswählen",
       "prTitle": "Titel",
       "headBranch": "Head-Branch",
       "baseBranch": "Base-Branch",
-      "openPullRequest": "Pull Request öffnen",
-      "noPulls": "Keine Pull Requests synchronisiert.",
-      "mergePr": "Pull Request mergen",
       "noIssues": "Keine Issues synchronisiert.",
       "prState": {
         "open": "offen",
@@ -3358,9 +3351,7 @@
       "toast": {
         "resync": "Neusynchronisierung {status}",
         "reposUpdated": "Verknüpfte Repositorys aktualisiert",
-        "branchCreated": "Branch {name} erstellt",
-        "prOpened": "Pull Request geöffnet",
-        "prMerged": "PR #{number} gemergt"
+        "branchCreated": "Branch {name} erstellt"
       },
       "errors": {
         "disconnect": "Trennen nicht möglich",
@@ -3369,7 +3360,6 @@
         "updateRepos": "Repositorys konnten nicht aktualisiert werden",
         "loadBranches": "Branches konnten nicht geladen werden",
         "createBranch": "Branch konnte nicht erstellt werden",
-        "openPr": "Pull Request konnte nicht geöffnet werden",
         "merge": "Mergen nicht möglich"
       }
     },
@@ -5474,7 +5464,8 @@
     "unavailable": {
       "description": {
         "binary_generators_unreachable": "Die generativen Integrationen dieser Installation konnten gerade nicht gelesen werden, deshalb wurde der Lauf nicht gestartet. Es ist nichts falsch konfiguriert und keine Änderung nötig: versuchen Sie es erneut, sobald die Verbindung wieder steht.",
-        "foundational_builtins_unreachable": "Die integrierten Basisdienste dieser Installation konnten gerade nicht gelesen werden. Es ist nichts falsch konfiguriert und keine Änderung nötig: versuchen Sie es erneut, sobald die Verbindung wieder steht."
+        "foundational_builtins_unreachable": "Die integrierten Basisdienste dieser Installation konnten gerade nicht gelesen werden. Es ist nichts falsch konfiguriert und keine Änderung nötig: versuchen Sie es erneut, sobald die Verbindung wieder steht.",
+        "connection_credentials_unreadable": "Die gespeicherten Zugangsdaten dieser Verbindung konnten nicht gelesen werden. Wenn diese Installation den Dienst mit dem zugehörigen Schlüssel erreicht, verbinden Sie die Quelle neu, um sie zu ersetzen; andernfalls versuchen Sie es erneut, sobald diese Verbindung wiederhergestellt ist."
       }
     },
     "action": {
@@ -5546,7 +5537,7 @@
         "agent_backend_unconfigured": "Es ist kein Runner-Backend verfügbar, um Container-Agenten auszuführen. Registriere einen selbst gehosteten Runner-Pool oder aktiviere Cloudflare Containers in deinem Deployment.",
         "run_not_retryable": "Nur eine fehlgeschlagene oder abgeschlossene Ausführung kann wiederholt werden. Diese Ausführung ist noch aktiv oder in einem Zustand, der keine Wiederholung erlaubt.",
         "no_pr_to_merge": "Diese Ausführung hat noch keinen Pull Request geöffnet, es gibt also nichts zu mergen.",
-        "github_not_connected": "Verbinde diesen Workspace mit GitHub, damit Agenten das Repository klonen, Änderungen pushen und Pull Requests öffnen können.",
+        "github_not_connected": "Verbinden Sie diesen Workspace mit einem Repository-Host, damit Agenten das Repository klonen, Änderungen pushen und Pull Requests öffnen können.",
         "bootstrap_not_retryable": "Dieser Bootstrap-Auftrag kann in seinem aktuellen Zustand nicht wiederholt werden (er läuft noch oder wurde bereits erfolgreich abgeschlossen).",
         "bootstrap_reference_missing": "Das Referenz-Repository, das dieser Bootstrap übernimmt, ist nicht mehr erreichbar. Es wurde gelöscht oder der Zugriff wurde entzogen. Wähle eine andere Referenz oder erstelle von Grund auf neu.",
         "preset_unsatisfiable": "Das Modell eines Inline-Schritts kann in diesem Deployment nicht inline laufen (ein reines Abo-Modell ohne Inline-Unterstützung). Wähle ein inline-fähiges Modell oder Preset.",
@@ -5736,7 +5727,7 @@
       "suffixFixing": "· Fixer bearbeitet Kommentare…",
       "suffixFailing": "· zu bearbeitende Review-Kommentare",
       "suffixAwaiting": "· wartet auf Review",
-      "reviewPr": "Pull Request auf GitHub prüfen",
+      "reviewPr": "Pull Request prüfen",
       "requestFixHeading": "Eine Korrektur anfordern",
       "requestFixDescription": "Beschreibe eine Änderung, die der Fixer jetzt am PR-Branch vornehmen soll (zusätzlich zu etwaigen Review-Kommentaren, die er automatisch bearbeitet).",
       "requestFixPlaceholder": "z. B. benenne den Helfer um und füge einen Unit-Test für den Fall leerer Eingabe hinzu",
@@ -5750,12 +5741,12 @@
     },
     "conflicts": {
       "mergeability": "Zusammenführbarkeit",
-      "viewPr": "Pull Request auf GitHub ansehen"
+      "viewPr": "Pull Request ansehen"
     },
     "docQuality": {
       "findings": "Dokumentprobleme",
       "findingsFallback": "Das Dokument hat die strukturellen Prüfungen bestanden.",
-      "viewPr": "Pull Request auf GitHub ansehen"
+      "viewPr": "Pull Request ansehen"
     },
     "attemptsHeading": "{helper}-Versuche",
     "attempt": "Versuch {number}",
@@ -6906,7 +6897,33 @@
       },
       "toast": {
         "disconnected": "{provider} getrennt"
-      }
+      },
+      "pulls": {
+        "github": {
+          "tab": "Pull Requests",
+          "open": "PR öffnen",
+          "openSubmit": "Pull Request öffnen",
+          "merge": "Diesen Pull Request mergen",
+          "none": "Keine Pull Requests synchronisiert.",
+          "opened": "Pull Request geöffnet",
+          "mergedToast": "PR #{number} gemergt",
+          "openFailed": "Pull Request konnte nicht geöffnet werden"
+        },
+        "gitlab": {
+          "tab": "Merge Requests",
+          "open": "MR öffnen",
+          "openSubmit": "Merge Request öffnen",
+          "merge": "Diesen Merge Request mergen",
+          "none": "Keine Merge Requests synchronisiert.",
+          "opened": "Merge Request geöffnet",
+          "mergedToast": "MR !{number} gemergt",
+          "openFailed": "Merge Request konnte nicht geöffnet werden"
+        }
+      },
+      "manageHintApp": "Wählen Sie die Repositories aus, die dieses Board verfolgen soll. Die App-Installation wird kontoweit geteilt, und jedes Board verknüpft seine eigenen Repositories.",
+      "manageHintToken": "Wählen Sie die Repositories aus, die dieses Board verfolgen soll. Die Liste zeigt, was das verbundene Token erreicht, und jedes Board verknüpft seine eigenen Repositories.",
+      "noAvailableReposApp": "Die App-Installation hat noch auf keine Repositories Zugriff.",
+      "noAvailableReposToken": "Das verbundene Token erreicht noch keine Repositories. Prüfen Sie seinen Scope und Ihren Zugriff darauf."
     },
     "connect": {
       "or": "oder",