Skip to content

Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.

fix(pull-requests): route self-hosted GitLab remotes (#6061)

Guilherme Vieiraf5fce74169a5
diff --git a/apps/server/src/pullRequest/PullRequestService.test.ts b/apps/server/src/pullRequest/PullRequestService.test.ts
index c46808aa2..77a7118d9 100644
--- a/apps/server/src/pullRequest/PullRequestService.test.ts
+++ b/apps/server/src/pullRequest/PullRequestService.test.ts
@@ -10,6 +10,7 @@ import type {
} from "@t3tools/contracts";
import * as ProjectionSnapshotQuery from "../orchestration/Services/ProjectionSnapshotQuery.ts";
+import * as SourceControlProviderRegistry from "../sourceControl/SourceControlProviderRegistry.ts";
import {
PullRequestProviderError,
type ProviderChangeRequest,
@@ -144,11 +145,16 @@ function fakeProvider(
function makeService(input: {
readonly projects: ReadonlyArray<OrchestrationProjectShell>;
readonly providers: ReadonlyArray<PullRequestProviderApi>;
+ readonly resolveHandle?: SourceControlProviderRegistry.SourceControlProviderRegistry["Service"]["resolveHandle"];
}) {
return PullRequestService.make.pipe(
Effect.provide(
Layer.mergeAll(
Layer.succeed(PullRequestProviderRegistry, fromProviders(input.providers)),
+ Layer.mock(SourceControlProviderRegistry.SourceControlProviderRegistry)({
+ resolveHandle:
+ input.resolveHandle ?? (() => Effect.die("Unexpected provider refinement")),
+ }),
Layer.mock(ProjectionSnapshotQuery.ProjectionSnapshotQuery)({
getShellSnapshot: () =>
Effect.succeed({
@@ -163,6 +169,110 @@ function makeService(input: {
);
}
+it.effect("refines unknown self-hosted GitLab projects before listing merge requests", () =>
+ Effect.gen(function* () {
+ let refinementCalls = 0;
+ const selfHosted = project({
+ id: "p1",
+ title: "self-hosted",
+ workspaceRoot: "/gitlab",
+ repository: "group/project",
+ provider: "unknown",
+ host: "code.example.test",
+ });
+ const service = yield* makeService({
+ projects: [
+ selfHosted,
+ { ...selfHosted, id: "p2" as ProjectId, workspaceRoot: "/gitlab-worktree" },
+ ],
+ providers: [fakeProvider("gitlab")],
+ resolveHandle: ({ context }) => {
+ refinementCalls += 1;
+ assert.strictEqual(context?.remoteUrl, "https://code.example.test/group/project.git");
+ return Effect.succeed({
+ context: { ...context!, provider: { ...context!.provider, kind: "gitlab" } },
+ provider: undefined as never,
+ });
+ },
+ });
+
+ const result = yield* service.list({ state: "open" });
+
+ assert.strictEqual(refinementCalls, 1);
+ assert.strictEqual(result.providers[0]?.host, "code.example.test");
+ assert.strictEqual(result.providers[0]?.kind, "gitlab");
+ }),
+);
+
+it.effect("derives a legacy repository host after refining its provider", () =>
+ Effect.gen(function* () {
+ const current = project({
+ id: "p1",
+ title: "legacy self-hosted",
+ workspaceRoot: "/gitlab",
+ repository: "group/project",
+ provider: "unknown",
+ host: "code.example.test",
+ });
+ const identity = current.repositoryIdentity!;
+ // Persisted identities from before canonicalKey existed are still accepted at runtime.
+ const legacy = {
+ ...current,
+ repositoryIdentity: {
+ locator: identity.locator,
+ provider: identity.provider,
+ displayName: identity.displayName,
+ },
+ } as unknown as OrchestrationProjectShell;
+ const service = yield* makeService({
+ projects: [legacy],
+ providers: [fakeProvider("gitlab")],
+ resolveHandle: ({ context }) =>
+ Effect.succeed({
+ context: { ...context!, provider: { ...context!.provider, kind: "gitlab" } },
+ provider: undefined as never,
+ }),
+ });
+
+ const result = yield* service.list({ state: "open", host: "gitlab" });
+
+ assert.strictEqual(result.providers[0]?.host, "gitlab");
+ assert.strictEqual(result.providers[0]?.kind, "gitlab");
+ }),
+);
+
+it.effect("tries another checkout when provider refinement remains unknown", () =>
+ Effect.gen(function* () {
+ const asked: string[] = [];
+ const selfHosted = project({
+ id: "p1",
+ title: "self-hosted",
+ workspaceRoot: "/gone",
+ repository: "group/project",
+ provider: "unknown",
+ host: "code.example.test",
+ });
+ const service = yield* makeService({
+ projects: [selfHosted, { ...selfHosted, id: "p2" as ProjectId, workspaceRoot: "/healthy" }],
+ providers: [fakeProvider("gitlab")],
+ resolveHandle: ({ cwd, context }) => {
+ asked.push(cwd);
+ return cwd === "/gone"
+ ? Effect.succeed({ context: context!, provider: undefined as never })
+ : Effect.succeed({
+ context: { ...context!, provider: { ...context!.provider, kind: "gitlab" } },
+ provider: undefined as never,
+ });
+ },
+ });
+
+ const result = yield* service.list({ state: "open" });
+
+ assert.deepStrictEqual(asked, ["/gone", "/healthy"]);
+ assert.strictEqual(result.providers[0]?.kind, "gitlab");
+ }),
+);
+
/** A row as a host that reads several repositories at once hands it over. */
function batchedChangeRequest(number: number, repository: string, updatedAt: string) {
return { ...changeRequest(number, updatedAt), repository };
diff --git a/apps/server/src/pullRequest/PullRequestService.ts b/apps/server/src/pullRequest/PullRequestService.ts
index 8652e4b9c..adff1f837 100644
--- a/apps/server/src/pullRequest/PullRequestService.ts
+++ b/apps/server/src/pullRequest/PullRequestService.ts
@@ -36,10 +36,13 @@ import {
type PullRequestSubmitReviewInput,
type PullRequestThreadReplyInput,
type PullRequestThreadResolutionInput,
+ type SourceControlProviderInfo,
type SourceControlProviderKind,
} from "@t3tools/contracts";
+import { detectSourceControlProviderFromRemoteUrl } from "@t3tools/shared/sourceControl";
import * as ProjectionSnapshotQuery from "../orchestration/Services/ProjectionSnapshotQuery.ts";
+import * as SourceControlProviderRegistry from "../sourceControl/SourceControlProviderRegistry.ts";
import {
type ProviderChangeRequest,
type ProviderListCursor,
@@ -360,6 +363,65 @@ function repositoryIdentityOf(project: OrchestrationProjectShell): string | null
export const make = Effect.gen(function* () {
const registry = yield* PullRequestProviderRegistry;
const projections = yield* ProjectionSnapshotQuery.ProjectionSnapshotQuery;
+ const sourceControlProviders = yield* SourceControlProviderRegistry.SourceControlProviderRegistry;
+
+ const refineUnknownProjectKinds = (
+ projects: ReadonlyArray<OrchestrationProjectShell>,
+ filter: Pick<PullRequestListInput, "projectId" | "host">,
+ ) => {
+ type RefinementCandidate = {
+ readonly project: OrchestrationProjectShell;
+ readonly provider: SourceControlProviderInfo;
+ readonly remoteName: string;
+ readonly remoteUrl: string;
+ };
+ const refinements = new Map<string, RefinementCandidate[]>();
+ for (const project of projects) {
+ if (filter.projectId !== undefined && project.id !== filter.projectId) continue;
+ const identity = project.repositoryIdentity;
+ if (identity?.provider !== "unknown" || repositoryIdentityOf(project) === null) continue;
+ const host = pullRequestHostOf(identity, "unknown");
+ // A legacy identity has no canonical host until its provider is refined, so it must reach
+ // the refinement before a host filter can decide whether it belongs in the result.
+ if (filter.host !== undefined && host !== "unknown" && host !== filter.host.toLowerCase()) {
+ continue;
+ }
+ const { remoteName, remoteUrl } = identity.locator;
+ const provider = detectSourceControlProviderFromRemoteUrl(remoteUrl);
+ if (provider !== null) {
+ const candidates = refinements.get(provider.baseUrl);
+ const candidate = { project, provider, remoteName, remoteUrl };
+ if (candidates === undefined) refinements.set(provider.baseUrl, [candidate]);
+ else candidates.push(candidate);
+ }
+ }
+
+ return Effect.forEach(
+ refinements,
+ ([baseUrl, candidates]) =>
+ Effect.firstSuccessOf(
+ candidates.map(({ project, provider, remoteName, remoteUrl }) =>
+ Effect.suspend(() =>
+ sourceControlProviders.resolveHandle({
+ cwd: project.workspaceRoot,
+ context: { provider, remoteName, remoteUrl },
+ }),
+ ).pipe(
+ Effect.flatMap((handle) => {
+ const kind = handle.context?.provider.kind;
+ return kind === undefined || kind === "unknown"
+ ? Effect.fail(undefined)
+ : Effect.succeed(kind);
+ }),
+ ),
+ ),
+ ).pipe(
+ Effect.map((kind) => [baseUrl, kind] as const),
+ Effect.orElseSucceed(() => [baseUrl, "unknown"] as const),
+ ),
+ { concurrency: REPOSITORY_CONCURRENCY },
+ ).pipe(Effect.map((resolved) => new Map(resolved)));
+ };
const listWorkspaceProjects = (
filter: Pick<PullRequestListInput, "projectId" | "host">,
@@ -373,7 +435,12 @@ export const make = Effect.gen(function* () {
cause: error,
}),
),
- Effect.map((snapshot) => {
+ Effect.flatMap((snapshot) =>
+ refineUnknownProjectKinds(snapshot.projects, filter).pipe(
+ Effect.map((refinedKinds) => ({ refinedKinds, snapshot })),
+ ),
+ ),
+ Effect.map(({ refinedKinds, snapshot }) => {
const supported: SupportedProject[] = [];
const unimplemented = new Map<
string,
@@ -383,15 +450,18 @@ export const make = Effect.gen(function* () {
const seen = new Set<string>();
for (const project of snapshot.projects) {
if (filter.projectId !== undefined && project.id !== filter.projectId) continue;
- const kind = project.repositoryIdentity?.provider as
- | SourceControlProviderKind
- | undefined;
+ const identity = project.repositoryIdentity;
+ let kind = identity?.provider as SourceControlProviderKind | undefined;
const repository = repositoryIdentityOf(project);
- if (kind === undefined || repository === null) continue;
+ if (!identity || kind === undefined || repository === null) continue;
// Worktrees of one repository are separate projects; reading the remote once keeps
// the page from repeating every change request per local checkout. The host is part
// of the key, so the same `owner/repo` on two hosts stays two repositories.
- const host = pullRequestHostOf(project.repositoryIdentity, kind);
+ if (kind === "unknown") {
+ const provider = detectSourceControlProviderFromRemoteUrl(identity.locator.remoteUrl);
+ kind = provider === null ? kind : (refinedKinds.get(provider.baseUrl) ?? kind);
+ }
+ const host = pullRequestHostOf(identity, kind);
if (filter.host !== undefined && host !== filter.host.toLowerCase()) continue;
const api = registry.get(kind);
// Recorded before the de-duplication below, so the viewer lookup keeps the alternates
diff --git a/apps/server/src/server.ts b/apps/server/src/server.ts
index 8d4f8bb61..32bcaaa8b 100644
--- a/apps/server/src/server.ts
+++ b/apps/server/src/server.ts
@@ -435,6 +435,7 @@ const commandReadinessLayer = HttpRouter.middleware(
const PullRequestServiceLive = PullRequestService.layer.pipe(
// One registry entry per supported host; the service only knows the registry.
Layer.provide(PullRequestProviderRegistry.layer),
+ Layer.provide(SourceControlProviderRegistryLayerLive),
Layer.provide(VcsProcess.layer),
);
diff --git a/apps/server/src/sourceControl/SourceControlProviderRegistry.test.ts b/apps/server/src/sourceControl/SourceControlProviderRegistry.test.ts
index 5c4d27e46..54038502b 100644
--- a/apps/server/src/sourceControl/SourceControlProviderRegistry.test.ts
+++ b/apps/server/src/sourceControl/SourceControlProviderRegistry.test.ts
@@ -203,6 +203,38 @@ self-hosted.example.test
}),
);
+it.effect("refines the caller-selected remote instead of choosing another configured remote", () =>
+ Effect.gen(function* () {
+ const registry = yield* makeRegistry({
+ remotes: [{ name: "origin", url: "[email protected]:fork/project.git" }],
+ process: {
+ run: () =>
+ Effect.succeed(
+ processOutput(`self-hosted.example.test
+ ✓ Logged in to self-hosted.example.test as gitlab-user
+`),
+ ),
+ },
+ });
+
+ const handle = yield* registry.resolveHandle({
+ cwd: "/repo",
+ context: {
+ provider: {
+ kind: "unknown",
+ name: "self-hosted.example.test",
+ baseUrl: "https://self-hosted.example.test",
+ },
+ remoteName: "upstream",
+ remoteUrl: "https://self-hosted.example.test/group/project.git",
+ },
+ });
+
+ assert.strictEqual(handle.context?.provider.kind, "gitlab");
+ assert.strictEqual(handle.context?.remoteName, "upstream");
+ }),
+);
+
it.effect("routes authenticated self-hosted GitLab remotes on non-standard ports", () =>
Effect.gen(function* () {
const registry = yield* makeRegistry({
diff --git a/apps/server/src/sourceControl/SourceControlProviderRegistry.ts b/apps/server/src/sourceControl/SourceControlProviderRegistry.ts
index fb70d677e..9fe089a41 100644
--- a/apps/server/src/sourceControl/SourceControlProviderRegistry.ts
+++ b/apps/server/src/sourceControl/SourceControlProviderRegistry.ts
@@ -50,6 +50,7 @@ export class SourceControlProviderRegistry extends Context.Service<
>;
readonly resolveHandle: (input: {
readonly cwd: string;
+ readonly context?: SourceControlProvider.SourceControlProviderContext;
}) => Effect.Effect<SourceControlProviderHandle, SourceControlProviderError>;
readonly resolve: (input: {
readonly cwd: string;
@@ -254,7 +255,15 @@ export const makeWithProviders = Effect.fn("makeSourceControlProviderRegistryWit
});
const resolveHandle: SourceControlProviderRegistry["Service"]["resolveHandle"] = (input) =>
- Cache.get(providerContextCache, input.cwd).pipe(
+ (input.context === undefined
+ ? Cache.get(providerContextCache, input.cwd)
+ : refineUnknownRemoteProvider({
+ specs: discoverySpecs,
+ process,
+ cwd: input.cwd,
+ context: input.context,
+ })
+ ).pipe(
Effect.map((context) => {
const kind = context?.provider.kind ?? "unknown";
const provider = providers.get(kind) ?? unsupportedProvider(kind);