lael-labs/t3code

apps/server/src/sourceControl/AzureDevOpsCli.test.ts+288−0

@@ -0,0 +1,288 @@
	1	import * as NodeServices from "@effect/platform-node/NodeServices";
	2	import { assert, it, afterEach, describe, expect, vi } from "@effect/vitest";
	3	import { Effect, FileSystem, Layer, Option } from "effect";
	4	import { ChildProcessSpawner } from "effect/unstable/process";
	5	import type { VcsError } from "@t3tools/contracts";
	6
	7	import * as VcsProcess from "../vcs/VcsProcess.ts";
	8	import * as AzureDevOpsCli from "./AzureDevOpsCli.ts";
	9
	10	const processOutput = (stdout: string): VcsProcess.VcsProcessOutput => ({
	11	exitCode: ChildProcessSpawner.ExitCode(0),
	12	stdout,
	13	stderr: "",
	14	stdoutTruncated: false,
	15	stderrTruncated: false,
	16	});
	17
	18	const mockRun = vi.fn<VcsProcess.VcsProcessShape["run"]>();
	19
	20	const supportLayer = Layer.mergeAll(
	21	Layer.mock(VcsProcess.VcsProcess)({
	22	run: mockRun,
	23	}),
	24	NodeServices.layer,
	25	);
	26	const layer = Layer.mergeAll(AzureDevOpsCli.layer.pipe(Layer.provide(supportLayer)), supportLayer);
	27
	28	afterEach(() => {
	29	mockRun.mockReset();
	30	});
	31
	32	describe("AzureDevOpsCli.layer", () => {
	33	it.effect("parses pull request view output", () =>
	34	Effect.gen(function* () {
	35	mockRun.mockReturnValueOnce(
	36	Effect.succeed(
	37	processOutput(
	38	JSON.stringify({
	39	pullRequestId: 42,
	40	title: "Add Azure provider",
	41	sourceRefName: "refs/heads/feature/source-control",
	42	targetRefName: "refs/heads/main",
	43	status: "active",
	44	creationDate: "2026-01-02T00:00:00.000Z",
	45	closedDate: null,
	46	_links: {
	47	web: {
	48	href: "https://dev.azure.com/acme/project/_git/repo/pullrequest/42",
	49	},
	50	},
	51	}),
	52	),
	53	),
	54	);
	55
	56	const az = yield* AzureDevOpsCli.AzureDevOpsCli;
	57	const result = yield* az.getPullRequest({
	58	cwd: "/repo",
	59	reference: "#42",
	60	});
	61
	62	assert.strictEqual(result.number, 42);
	63	assert.strictEqual(result.title, "Add Azure provider");
	64	assert.strictEqual(result.baseRefName, "main");
	65	assert.strictEqual(result.headRefName, "feature/source-control");
	66	assert.strictEqual(result.state, "open");
	67	assert.deepStrictEqual(result.updatedAt._tag, Option.some(1)._tag);
	68	assert.deepStrictEqual(mockRun.mock.calls.at(-1)?.[0], {
	69	operation: "AzureDevOpsCli.execute",
	70	command: "az",
	71	args: [
	72	"repos",
	73	"pr",
	74	"show",
	75	"--detect",
	76	"true",
	77	"--id",
	78	"42",
	79	"--only-show-errors",
	80	"--output",
	81	"json",
	82	],
	83	cwd: "/repo",
	84	timeoutMs: 30_000,
	85	});
	86	}).pipe(Effect.provide(layer)),
	87	);
	88
	89	it.effect("lists pull requests with Azure status and source branch arguments", () =>
	90	Effect.gen(function* () {
	91	mockRun.mockReturnValueOnce(
	92	Effect.succeed(
	93	processOutput(
	94	JSON.stringify([
	95	{
	96	pullRequestId: 7,
	97	title: "Merged work",
	98	sourceRefName: "refs/heads/feature/merged",
	99	targetRefName: "refs/heads/main",
	100	status: "completed",
	101	closedDate: "2026-01-03T00:00:00.000Z",
	102	_links: {
	103	web: {
	104	href: "https://dev.azure.com/acme/project/_git/repo/pullrequest/7",
	105	},
	106	},
	107	},
	108	]),
	109	),
	110	),
	111	);
	112
	113	const az = yield* AzureDevOpsCli.AzureDevOpsCli;
	114	const result = yield* az.listPullRequests({
	115	cwd: "/repo",
	116	headSelector: "origin:feature/merged",
	117	state: "merged",
	118	limit: 10,
	119	});
	120
	121	assert.strictEqual(result[0]?.state, "merged");
	122	expect(mockRun).toHaveBeenCalledWith({
	123	operation: "AzureDevOpsCli.execute",
	124	command: "az",
	125	args: [
	126	"repos",
	127	"pr",
	128	"list",
	129	"--detect",
	130	"true",
	131	"--source-branch",
	132	"feature/merged",
	133	"--status",
	134	"completed",
	135	"--top",
	136	"10",
	137	"--only-show-errors",
	138	"--output",
	139	"json",
	140	],
	141	cwd: "/repo",
	142	timeoutMs: 30_000,
	143	});
	144	}).pipe(Effect.provide(layer)),
	145	);
	146
	147	it.effect("reads repository clone URLs", () =>
	148	Effect.gen(function* () {
	149	mockRun.mockReturnValueOnce(
	150	Effect.succeed(
	151	processOutput(
	152	JSON.stringify({
	153	name: "repo",
	154	webUrl: "https://dev.azure.com/acme/project/_git/repo",
	155	remoteUrl: "https://dev.azure.com/acme/project/_git/repo",
	156	sshUrl: "git@ssh.dev.azure.com:v3/acme/project/repo",
	157	project: {
	158	name: "project",
	159	},
	160	}),
	161	),
	162	),
	163	);
	164
	165	const az = yield* AzureDevOpsCli.AzureDevOpsCli;
	166	const result = yield* az.getRepositoryCloneUrls({
	167	cwd: "/repo",
	168	repository: "repo",
	169	});
	170
	171	assert.deepStrictEqual(result, {
	172	nameWithOwner: "project/repo",
	173	url: "https://dev.azure.com/acme/project/_git/repo",
	174	sshUrl: "git@ssh.dev.azure.com:v3/acme/project/repo",
	175	});
	176	}).pipe(Effect.provide(layer)),
	177	);
	178
	179	it.effect("creates repositories through Azure Repos", () =>
	180	Effect.gen(function* () {
	181	mockRun.mockReturnValueOnce(
	182	Effect.succeed(
	183	processOutput(
	184	JSON.stringify({
	185	name: "repo",
	186	webUrl: "https://dev.azure.com/acme/project/_git/repo",
	187	remoteUrl: "https://dev.azure.com/acme/project/_git/repo",
	188	sshUrl: "git@ssh.dev.azure.com:v3/acme/project/repo",
	189	project: {
	190	name: "project",
	191	},
	192	}),
	193	),
	194	),
	195	);
	196
	197	const az = yield* AzureDevOpsCli.AzureDevOpsCli;
	198	const result = yield* az.createRepository({
	199	cwd: "/repo",
	200	repository: "project/repo",
	201	visibility: "private",
	202	});
	203
	204	assert.deepStrictEqual(result, {
	205	nameWithOwner: "project/repo",
	206	url: "https://dev.azure.com/acme/project/_git/repo",
	207	sshUrl: "git@ssh.dev.azure.com:v3/acme/project/repo",
	208	});
	209	expect(mockRun).toHaveBeenCalledWith({
	210	operation: "AzureDevOpsCli.execute",
	211	command: "az",
	212	args: [
	213	"repos",
	214	"create",
	215	"--detect",
	216	"true",
	217	"--name",
	218	"repo",
	219	"--project",
	220	"project",
	221	"--only-show-errors",
	222	"--output",
	223	"json",
	224	],
	225	cwd: "/repo",
	226	timeoutMs: 30_000,
	227	});
	228	}).pipe(Effect.provide(layer)),
	229	);
	230
	231	it.effect("creates pull requests using the body file as the Azure description", () =>
	232	Effect.gen(function* () {
	233	const fileSystem = yield* FileSystem.FileSystem;
	234	const bodyFile = `/tmp/t3code-azure-devops-cli-${Date.now()}.md`;
	235	yield* fileSystem.writeFileString(bodyFile, "Generated body");
	236	mockRun.mockReturnValueOnce(Effect.succeed(processOutput("{}")));
	237
	238	const az = yield* AzureDevOpsCli.AzureDevOpsCli;
	239	yield* az.createPullRequest({
	240	cwd: "/repo",
	241	baseBranch: "main",
	242	headSelector: "feature/provider",
	243	title: "Provider PR",
	244	bodyFile,
	245	});
	246
	247	expect(mockRun).toHaveBeenCalledWith(
	248	expect.objectContaining({
	249	command: "az",
	250	cwd: "/repo",
	251	args: expect.arrayContaining(["--description", `@${bodyFile}`]),
	252	}),
	253	);
	254	expect(mockRun.mock.calls[0]?.[0].args).not.toContain("--output");
	255	}).pipe(Effect.provide(layer)),
	256	);
	257
	258	it.effect("does not force JSON output on checkout side-effect commands", () =>
	259	Effect.gen(function* () {
	260	mockRun.mockReturnValueOnce(Effect.succeed(processOutput("")));
	261
	262	const az = yield* AzureDevOpsCli.AzureDevOpsCli;
	263	yield* az.checkoutPullRequest({
	264	cwd: "/repo",
	265	reference: "42",
	266	});
	267
	268	expect(mockRun).toHaveBeenCalledWith({
	269	operation: "AzureDevOpsCli.execute",
	270	command: "az",
	271	args: [
	272	"repos",
	273	"pr",
	274	"checkout",
	275	"--only-show-errors",
	276	"--detect",
	277	"true",
	278	"--id",
	279	"42",
	280	"--remote-name",
	281	"origin",
	282	],
	283	cwd: "/repo",
	284	timeoutMs: 30_000,
	285	});
	286	}).pipe(Effect.provide(layer)),
	287	);
	288	});

apps/server/src/sourceControl/AzureDevOpsCli.ts+429−0

@@ -0,0 +1,429 @@
	1	import { Context, Effect, Layer, Result, Schema, SchemaIssue } from "effect";
	2	import {
	3	TrimmedNonEmptyString,
	4	type SourceControlRepositoryVisibility,
	5	type VcsError,
	6	} from "@t3tools/contracts";
	7
	8	import * as VcsProcess from "../vcs/VcsProcess.ts";
	9	import * as AzureDevOpsPullRequests from "./azureDevOpsPullRequests.ts";
	10	import * as SourceControlProvider from "./SourceControlProvider.ts";
	11
	12	const DEFAULT_TIMEOUT_MS = 30_000;
	13
	14	export class AzureDevOpsCliError extends Schema.TaggedErrorClass<AzureDevOpsCliError>()(
	15	"AzureDevOpsCliError",
	16	{
	17	operation: Schema.String,
	18	detail: Schema.String,
	19	cause: Schema.optional(Schema.Defect),
	20	},
	21	) {
	22	override get message(): string {
	23	return `Azure DevOps CLI failed in ${this.operation}: ${this.detail}`;
	24	}
	25	}
	26
	27	export interface AzureDevOpsRepositoryCloneUrls {
	28	readonly nameWithOwner: string;
	29	readonly url: string;
	30	readonly sshUrl: string;
	31	}
	32
	33	export interface AzureDevOpsCliShape {
	34	readonly execute: (input: {
	35	readonly cwd: string;
	36	readonly args: ReadonlyArray<string>;
	37	readonly timeoutMs?: number;
	38	}) => Effect.Effect<VcsProcess.VcsProcessOutput, AzureDevOpsCliError>;
	39
	40	readonly listPullRequests: (input: {
	41	readonly cwd: string;
	42	readonly headSelector: string;
	43	readonly source?: SourceControlProvider.SourceControlRefSelector;
	44	readonly state: "open" \| "closed" \| "merged" \| "all";
	45	readonly limit?: number;
	46	}) => Effect.Effect<
	47	ReadonlyArray<AzureDevOpsPullRequests.NormalizedAzureDevOpsPullRequestRecord>,
	48	AzureDevOpsCliError
	49	>;
	50
	51	readonly getPullRequest: (input: {
	52	readonly cwd: string;
	53	readonly reference: string;
	54	}) => Effect.Effect<
	55	AzureDevOpsPullRequests.NormalizedAzureDevOpsPullRequestRecord,
	56	AzureDevOpsCliError
	57	>;
	58
	59	readonly getRepositoryCloneUrls: (input: {
	60	readonly cwd: string;
	61	readonly repository: string;
	62	}) => Effect.Effect<AzureDevOpsRepositoryCloneUrls, AzureDevOpsCliError>;
	63
	64	readonly createRepository: (input: {
	65	readonly cwd: string;
	66	readonly repository: string;
	67	readonly visibility: SourceControlRepositoryVisibility;
	68	}) => Effect.Effect<AzureDevOpsRepositoryCloneUrls, AzureDevOpsCliError>;
	69
	70	readonly createPullRequest: (input: {
	71	readonly cwd: string;
	72	readonly baseBranch: string;
	73	readonly headSelector: string;
	74	readonly source?: SourceControlProvider.SourceControlRefSelector;
	75	readonly target?: SourceControlProvider.SourceControlRefSelector;
	76	readonly title: string;
	77	readonly bodyFile: string;
	78	}) => Effect.Effect<void, AzureDevOpsCliError>;
	79
	80	readonly getDefaultBranch: (input: {
	81	readonly cwd: string;
	82	}) => Effect.Effect<string \| null, AzureDevOpsCliError>;
	83
	84	readonly checkoutPullRequest: (input: {
	85	readonly cwd: string;
	86	readonly reference: string;
	87	readonly remoteName?: string;
	88	}) => Effect.Effect<void, AzureDevOpsCliError>;
	89	}
	90
	91	export class AzureDevOpsCli extends Context.Service<AzureDevOpsCli, AzureDevOpsCliShape>()(
	92	"t3/source-control/AzureDevOpsCli",
	93	) {}
	94
	95	function errorText(error: VcsError \| unknown): string {
	96	if (typeof error === "object" && error !== null) {
	97	const tag = "_tag" in error && typeof error._tag === "string" ? error._tag : "";
	98	const detail = "detail" in error && typeof error.detail === "string" ? error.detail : "";
	99	const message = "message" in error && typeof error.message === "string" ? error.message : "";
	100	return [tag, detail, message].filter(Boolean).join("\n");
	101	}
	102
	103	return String(error);
	104	}
	105
	106	function normalizeAzureDevOpsCliError(
	107	operation: "execute",
	108	error: VcsError \| unknown,
	109	): AzureDevOpsCliError {
	110	const text = errorText(error);
	111	const lower = text.toLowerCase();
	112
	113	if (lower.includes("command not found: az") \|\| lower.includes("enoent")) {
	114	return new AzureDevOpsCliError({
	115	operation,
	116	detail:
	117	"Azure CLI (`az`) with the Azure DevOps extension is required but not available on PATH.",
	118	cause: error,
	119	});
	120	}
	121
	122	if (
	123	lower.includes("az devops login") \|\|
	124	lower.includes("please run az login") \|\|
	125	lower.includes("not logged in") \|\|
	126	lower.includes("authentication failed") \|\|
	127	lower.includes("unauthorized")
	128	) {
	129	return new AzureDevOpsCliError({
	130	operation,
	131	detail: "Azure DevOps CLI is not authenticated. Run `az devops login` and retry.",
	132	cause: error,
	133	});
	134	}
	135
	136	if (
	137	lower.includes("pull request") &&
	138	(lower.includes("not found") \|\| lower.includes("does not exist"))
	139	) {
	140	return new AzureDevOpsCliError({
	141	operation,
	142	detail: "Pull request not found. Check the PR number or URL and try again.",
	143	cause: error,
	144	});
	145	}
	146
	147	return new AzureDevOpsCliError({
	148	operation,
	149	detail: text,
	150	cause: error,
	151	});
	152	}
	153
	154	function normalizeChangeRequestId(reference: string): string {
	155	const trimmed = reference.trim().replace(/^#/, "");
	156	const urlMatch = /(?:pullrequest\|pull-request\|pull\|_pulls?)\/(\d+)(?:\D.*)?$/i.exec(trimmed);
	157	return urlMatch?.[1] ?? trimmed;
	158	}
	159
	160	function toAzureStatus(state: "open" \| "closed" \| "merged" \| "all"): string {
	161	switch (state) {
	162	case "open":
	163	return "active";
	164	case "closed":
	165	return "abandoned";
	166	case "merged":
	167	return "completed";
	168	case "all":
	169	return "all";
	170	}
	171	}
	172
	173	const RawAzureDevOpsRepositorySchema = Schema.Struct({
	174	name: TrimmedNonEmptyString,
	175	webUrl: TrimmedNonEmptyString,
	176	remoteUrl: TrimmedNonEmptyString,
	177	sshUrl: TrimmedNonEmptyString,
	178	project: Schema.optional(
	179	Schema.Struct({
	180	name: TrimmedNonEmptyString,
	181	}),
	182	),
	183	defaultBranch: Schema.optional(Schema.NullOr(Schema.String)),
	184	});
	185
	186	function normalizeDefaultBranch(value: string \| null \| undefined): string \| null {
	187	const trimmed = value?.trim().replace(/^refs\/heads\//, "") ?? "";
	188	return trimmed.length > 0 ? trimmed : null;
	189	}
	190
	191	function normalizeRepositoryCloneUrls(
	192	raw: Schema.Schema.Type<typeof RawAzureDevOpsRepositorySchema>,
	193	): AzureDevOpsRepositoryCloneUrls {
	194	const projectName = raw.project?.name.trim();
	195	return {
	196	nameWithOwner: projectName ? `${projectName}/${raw.name}` : raw.name,
	197	url: raw.remoteUrl,
	198	sshUrl: raw.sshUrl,
	199	};
	200	}
	201
	202	function parseRepositorySpecifier(repository: string): {
	203	readonly project: string \| null;
	204	readonly name: string;
	205	} {
	206	const parts = repository
	207	.split("/")
	208	.map((part) => part.trim())
	209	.filter((part) => part.length > 0);
	210	return {
	211	project: parts.length > 1 ? (parts.at(-2) ?? null) : null,
	212	name: parts.at(-1) ?? repository.trim(),
	213	};
	214	}
	215
	216	function decodeAzureDevOpsJson<S extends Schema.Top>(
	217	raw: string,
	218	schema: S,
	219	operation: "getRepositoryCloneUrls" \| "getDefaultBranch" \| "createRepository",
	220	invalidDetail: string,
	221	): Effect.Effect<S["Type"], AzureDevOpsCliError, S["DecodingServices"]> {
	222	return Schema.decodeEffect(Schema.fromJsonString(schema))(raw).pipe(
	223	Effect.mapError(
	224	(error) =>
	225	new AzureDevOpsCliError({
	226	operation,
	227	detail: `${invalidDetail}: ${SchemaIssue.makeFormatterDefault()(error.issue)}`,
	228	cause: error,
	229	}),
	230	),
	231	);
	232	}
	233
	234	export const make = Effect.fn("makeAzureDevOpsCli")(function* () {
	235	const process = yield* VcsProcess.VcsProcess;
	236
	237	const execute: AzureDevOpsCliShape["execute"] = (input) =>
	238	process
	239	.run({
	240	operation: "AzureDevOpsCli.execute",
	241	command: "az",
	242	args: input.args,
	243	cwd: input.cwd,
	244	timeoutMs: input.timeoutMs ?? DEFAULT_TIMEOUT_MS,
	245	})
	246	.pipe(Effect.mapError((error) => normalizeAzureDevOpsCliError("execute", error)));
	247
	248	const executeJson = (input: Parameters<AzureDevOpsCliShape["execute"]>[0]) =>
	249	execute({
	250	...input,
	251	args: [...input.args, "--only-show-errors", "--output", "json"],
	252	});
	253
	254	return AzureDevOpsCli.of({
	255	execute,
	256	listPullRequests: (input) =>
	257	executeJson({
	258	cwd: input.cwd,
	259	args: [
	260	"repos",
	261	"pr",
	262	"list",
	263	"--detect",
	264	"true",
	265	"--source-branch",
	266	SourceControlProvider.sourceBranch(input),
	267	"--status",
	268	toAzureStatus(input.state),
	269	"--top",
	270	String(input.limit ?? 20),
	271	],
	272	}).pipe(
	273	Effect.map((result) => result.stdout.trim()),
	274	Effect.flatMap((raw) =>
	275	raw.length === 0
	276	? Effect.succeed([])
	277	: Effect.sync(() =>
	278	AzureDevOpsPullRequests.decodeAzureDevOpsPullRequestListJson(raw),
	279	).pipe(
	280	Effect.flatMap((decoded) => {
	281	if (!Result.isSuccess(decoded)) {
	282	return Effect.fail(
	283	new AzureDevOpsCliError({
	284	operation: "listPullRequests",
	285	detail: `Azure DevOps CLI returned invalid PR list JSON: ${AzureDevOpsPullRequests.formatAzureDevOpsJsonDecodeError(decoded.failure)}`,
	286	cause: decoded.failure,
	287	}),
	288	);
	289	}
	290
	291	return Effect.succeed(decoded.success);
	292	}),
	293	),
	294	),
	295	),
	296	getPullRequest: (input) =>
	297	executeJson({
	298	cwd: input.cwd,
	299	args: [
	300	"repos",
	301	"pr",
	302	"show",
	303	"--detect",
	304	"true",
	305	"--id",
	306	normalizeChangeRequestId(input.reference),
	307	],
	308	}).pipe(
	309	Effect.map((result) => result.stdout.trim()),
	310	Effect.flatMap((raw) =>
	311	Effect.sync(() => AzureDevOpsPullRequests.decodeAzureDevOpsPullRequestJson(raw)).pipe(
	312	Effect.flatMap((decoded) => {
	313	if (!Result.isSuccess(decoded)) {
	314	return Effect.fail(
	315	new AzureDevOpsCliError({
	316	operation: "getPullRequest",
	317	detail: `Azure DevOps CLI returned invalid pull request JSON: ${AzureDevOpsPullRequests.formatAzureDevOpsJsonDecodeError(decoded.failure)}`,
	318	cause: decoded.failure,
	319	}),
	320	);
	321	}
	322
	323	return Effect.succeed(decoded.success);
	324	}),
	325	),
	326	),
	327	),
	328	getRepositoryCloneUrls: (input) =>
	329	executeJson({
	330	cwd: input.cwd,
	331	args: ["repos", "show", "--detect", "true", "--repository", input.repository],
	332	}).pipe(
	333	Effect.map((result) => result.stdout.trim()),
	334	Effect.flatMap((raw) =>
	335	decodeAzureDevOpsJson(
	336	raw,
	337	RawAzureDevOpsRepositorySchema,
	338	"getRepositoryCloneUrls",
	339	"Azure DevOps CLI returned invalid repository JSON.",
	340	),
	341	),
	342	Effect.map(normalizeRepositoryCloneUrls),
	343	),
	344	createRepository: (input) => {
	345	const repository = parseRepositorySpecifier(input.repository);
	346	// Azure Repos access is governed by project/organization permissions.
	347	// `az repos create` does not expose a per-repository visibility flag, so
	348	// the generic source-control visibility input is intentionally not
	349	// translated into CLI args for this provider.
	350	return executeJson({
	351	cwd: input.cwd,
	352	args: [
	353	"repos",
	354	"create",
	355	"--detect",
	356	"true",
	357	"--name",
	358	repository.name,
	359	...(repository.project ? ["--project", repository.project] : []),
	360	],
	361	}).pipe(
	362	Effect.map((result) => result.stdout.trim()),
	363	Effect.flatMap((raw) =>
	364	decodeAzureDevOpsJson(
	365	raw,
	366	RawAzureDevOpsRepositorySchema,
	367	"createRepository",
	368	"Azure DevOps CLI returned invalid repository JSON.",
	369	),
	370	),
	371	Effect.map(normalizeRepositoryCloneUrls),
	372	);
	373	},
	374	createPullRequest: (input) =>
	375	execute({
	376	cwd: input.cwd,
	377	args: [
	378	"repos",
	379	"pr",
	380	"create",
	381	"--only-show-errors",
	382	"--detect",
	383	"true",
	384	"--target-branch",
	385	input.target?.refName ?? input.baseBranch,
	386	"--source-branch",
	387	SourceControlProvider.sourceBranch(input),
	388	"--title",
	389	input.title,
	390	"--description",
	391	`@${input.bodyFile}`,
	392	],
	393	}).pipe(Effect.asVoid),
	394	getDefaultBranch: (input) =>
	395	executeJson({
	396	cwd: input.cwd,
	397	args: ["repos", "show", "--detect", "true"],
	398	}).pipe(
	399	Effect.map((result) => result.stdout.trim()),
	400	Effect.flatMap((raw) =>
	401	decodeAzureDevOpsJson(
	402	raw,
	403	RawAzureDevOpsRepositorySchema,
	404	"getDefaultBranch",
	405	"Azure DevOps CLI returned invalid repository JSON.",
	406	),
	407	),
	408	Effect.map((repo) => normalizeDefaultBranch(repo.defaultBranch)),
	409	),
	410	checkoutPullRequest: (input) =>
	411	execute({
	412	cwd: input.cwd,
	413	args: [
	414	"repos",
	415	"pr",
	416	"checkout",
	417	"--only-show-errors",
	418	"--detect",
	419	"true",
	420	"--id",
	421	normalizeChangeRequestId(input.reference),
	422	"--remote-name",
	423	input.remoteName ?? "origin",
	424	],
	425	}).pipe(Effect.asVoid),
	426	});
	427	});
	428
	429	export const layer = Layer.effect(AzureDevOpsCli, make());

apps/server/src/sourceControl/AzureDevOpsSourceControlProvider.test.ts+91−0

@@ -0,0 +1,91 @@
	1	import { assert, it } from "@effect/vitest";
	2	import { Effect, Layer, Option } from "effect";
	3
	4	import * as AzureDevOpsCli from "./AzureDevOpsCli.ts";
	5	import * as AzureDevOpsSourceControlProvider from "./AzureDevOpsSourceControlProvider.ts";
	6
	7	function makeProvider(azure: Partial<AzureDevOpsCli.AzureDevOpsCliShape>) {
	8	return AzureDevOpsSourceControlProvider.make().pipe(
	9	Effect.provide(Layer.mock(AzureDevOpsCli.AzureDevOpsCli)(azure)),
	10	);
	11	}
	12
	13	it.effect("maps Azure DevOps PR summaries into provider-neutral change requests", () =>
	14	Effect.gen(function* () {
	15	const provider = yield* makeProvider({
	16	getPullRequest: () =>
	17	Effect.succeed({
	18	number: 42,
	19	title: "Add Azure provider",
	20	url: "https://dev.azure.com/acme/project/_git/repo/pullrequest/42",
	21	baseRefName: "main",
	22	headRefName: "feature/source-control",
	23	state: "open",
	24	updatedAt: Option.none(),
	25	}),
	26	});
	27
	28	const changeRequest = yield* provider.getChangeRequest({
	29	cwd: "/repo",
	30	reference: "42",
	31	});
	32
	33	assert.deepStrictEqual(changeRequest, {
	34	provider: "azure-devops",
	35	number: 42,
	36	title: "Add Azure provider",
	37	url: "https://dev.azure.com/acme/project/_git/repo/pullrequest/42",
	38	baseRefName: "main",
	39	headRefName: "feature/source-control",
	40	state: "open",
	41	updatedAt: Option.none(),
	42	isCrossRepository: false,
	43	});
	44	}),
	45	);
	46
	47	it.effect("creates Azure DevOps PRs through provider-neutral input names", () =>
	48	Effect.gen(function* () {
	49	let createInput: Parameters<AzureDevOpsCli.AzureDevOpsCliShape["createPullRequest"]>[0] \| null =
	50	null;
	51	const provider = yield* makeProvider({
	52	createPullRequest: (input) => {
	53	createInput = input;
	54	return Effect.void;
	55	},
	56	});
	57
	58	yield* provider.createChangeRequest({
	59	cwd: "/repo",
	60	baseRefName: "main",
	61	headSelector: "feature/provider",
	62	title: "Provider PR",
	63	bodyFile: "/tmp/body.md",
	64	});
	65
	66	assert.deepStrictEqual(createInput, {
	67	cwd: "/repo",
	68	baseBranch: "main",
	69	headSelector: "feature/provider",
	70	title: "Provider PR",
	71	bodyFile: "/tmp/body.md",
	72	});
	73	}),
	74	);
	75
	76	it.effect("uses Azure CLI repository detection for default branch lookup", () =>
	77	Effect.gen(function* () {
	78	let cwdInput: string \| null = null;
	79	const provider = yield* makeProvider({
	80	getDefaultBranch: (input) => {
	81	cwdInput = input.cwd;
	82	return Effect.succeed("main");
	83	},
	84	});
	85
	86	const defaultBranch = yield* provider.getDefaultBranch({ cwd: "/repo" });
	87
	88	assert.strictEqual(defaultBranch, "main");
	89	assert.strictEqual(cwdInput, "/repo");
	90	}),
	91	);

apps/server/src/sourceControl/AzureDevOpsSourceControlProvider.ts+144−0

@@ -0,0 +1,144 @@
	1	import { Effect, Layer } from "effect";
	2	import { SourceControlProviderError, type ChangeRequest } from "@t3tools/contracts";
	3
	4	import * as AzureDevOpsCli from "./AzureDevOpsCli.ts";
	5	import * as SourceControlProvider from "./SourceControlProvider.ts";
	6	import * as SourceControlProviderDiscovery from "./SourceControlProviderDiscovery.ts";
	7
	8	function providerError(
	9	operation: string,
	10	cause: AzureDevOpsCli.AzureDevOpsCliError,
	11	): SourceControlProviderError {
	12	return new SourceControlProviderError({
	13	provider: "azure-devops",
	14	operation,
	15	detail: cause.detail,
	16	cause,
	17	});
	18	}
	19
	20	function parseAzureAuth(input: SourceControlProviderDiscovery.SourceControlAuthProbeInput) {
	21	const account = input.stdout.trim().split(/\r?\n/)[0]?.trim();
	22
	23	if (input.exitCode !== 0) {
	24	return SourceControlProviderDiscovery.providerAuth({
	25	status: "unauthenticated",
	26	detail:
	27	SourceControlProviderDiscovery.firstSafeAuthLine(
	28	SourceControlProviderDiscovery.combinedAuthOutput(input),
	29	) ?? "Run `az login` to authenticate Azure CLI.",
	30	});
	31	}
	32
	33	if (account && account.length > 0) {
	34	return SourceControlProviderDiscovery.providerAuth({
	35	status: "authenticated",
	36	account,
	37	host: "dev.azure.com",
	38	});
	39	}
	40
	41	return SourceControlProviderDiscovery.providerAuth({
	42	status: "unknown",
	43	host: "dev.azure.com",
	44	detail: "Azure CLI account status could not be parsed.",
	45	});
	46	}
	47
	48	export const discovery = {
	49	type: "cli",
	50	kind: "azure-devops",
	51	label: "Azure DevOps",
	52	executable: "az",
	53	versionArgs: ["--version"],
	54	authArgs: ["account", "show", "--query", "user.name", "-o", "tsv"],
	55	parseAuth: parseAzureAuth,
	56	installHint:
	57	"Install the Azure command-line tools (`az`), then enable Azure DevOps support with `az extension add --name azure-devops`.",
	58	} satisfies SourceControlProviderDiscovery.SourceControlCliDiscoverySpec;
	59
	60	function toChangeRequest(summary: {
	61	readonly number: number;
	62	readonly title: string;
	63	readonly url: string;
	64	readonly baseRefName: string;
	65	readonly headRefName: string;
	66	readonly state: "open" \| "closed" \| "merged";
	67	readonly updatedAt: ChangeRequest["updatedAt"];
	68	}): ChangeRequest {
	69	return {
	70	provider: "azure-devops",
	71	number: summary.number,
	72	title: summary.title,
	73	url: summary.url,
	74	baseRefName: summary.baseRefName,
	75	headRefName: summary.headRefName,
	76	state: summary.state,
	77	updatedAt: summary.updatedAt,
	78	isCrossRepository: false,
	79	};
	80	}
	81
	82	export const make = Effect.fn("makeAzureDevOpsSourceControlProvider")(function* () {
	83	const azure = yield* AzureDevOpsCli.AzureDevOpsCli;
	84
	85	return SourceControlProvider.SourceControlProvider.of({
	86	kind: "azure-devops",
	87	listChangeRequests: (input) => {
	88	const source = SourceControlProvider.sourceControlRefFromInput(input);
	89	return azure
	90	.listPullRequests({
	91	cwd: input.cwd,
	92	headSelector: input.headSelector,
	93	...(source ? { source } : {}),
	94	state: input.state,
	95	...(input.limit !== undefined ? { limit: input.limit } : {}),
	96	})
	97	.pipe(
	98	Effect.map((items) => items.map(toChangeRequest)),
	99	Effect.mapError((error) => providerError("listChangeRequests", error)),
	100	);
	101	},
	102	getChangeRequest: (input) =>
	103	azure.getPullRequest(input).pipe(
	104	Effect.map(toChangeRequest),
	105	Effect.mapError((error) => providerError("getChangeRequest", error)),
	106	),
	107	createChangeRequest: (input) => {
	108	const source = SourceControlProvider.sourceControlRefFromInput(input);
	109	return azure
	110	.createPullRequest({
	111	cwd: input.cwd,
	112	baseBranch: input.baseRefName,
	113	headSelector: input.headSelector,
	114	...(source ? { source } : {}),
	115	...(input.target ? { target: input.target } : {}),
	116	title: input.title,
	117	bodyFile: input.bodyFile,
	118	})
	119	.pipe(Effect.mapError((error) => providerError("createChangeRequest", error)));
	120	},
	121	getRepositoryCloneUrls: (input) =>
	122	azure
	123	.getRepositoryCloneUrls(input)
	124	.pipe(Effect.mapError((error) => providerError("getRepositoryCloneUrls", error))),
	125	createRepository: (input) =>
	126	azure
	127	.createRepository(input)
	128	.pipe(Effect.mapError((error) => providerError("createRepository", error))),
	129	getDefaultBranch: (input) =>
	130	azure
	131	.getDefaultBranch({ cwd: input.cwd })
	132	.pipe(Effect.mapError((error) => providerError("getDefaultBranch", error))),
	133	checkoutChangeRequest: (input) =>
	134	azure
	135	.checkoutPullRequest({
	136	cwd: input.cwd,
	137	reference: input.reference,
	138	...(input.context ? { remoteName: input.context.remoteName } : {}),
	139	})
	140	.pipe(Effect.mapError((error) => providerError("checkoutChangeRequest", error))),
	141	});
	142	});
	143
	144	export const layer = Layer.effect(SourceControlProvider.SourceControlProvider, make());

apps/server/src/sourceControl/BitbucketApi.test.ts+513−0

@@ -0,0 +1,513 @@
	1	import { assert, it, vi } from "@effect/vitest";
	2	import * as NodeServices from "@effect/platform-node/NodeServices";
	3	import { ConfigProvider, DateTime, Effect, FileSystem, Layer, Option } from "effect";
	4	import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
	5
	6	import * as BitbucketApi from "./BitbucketApi.ts";
	7	import * as GitVcsDriver from "../vcs/GitVcsDriver.ts";
	8	import * as VcsDriverRegistry from "../vcs/VcsDriverRegistry.ts";
	9	import type * as VcsDriver from "../vcs/VcsDriver.ts";
	10
	11	const bitbucketPullRequest = {
	12	id: 42,
	13	title: "Add Bitbucket provider",
	14	state: "OPEN",
	15	updated_on: "2026-01-02T00:00:00.000Z",
	16	links: {
	17	html: {
	18	href: "https://bitbucket.org/pingdotgg/t3code/pull-requests/42",
	19	},
	20	},
	21	source: {
	22	branch: { name: "feature/source-control" },
	23	repository: {
	24	full_name: "octocat/t3code",
	25	workspace: { slug: "octocat" },
	26	},
	27	},
	28	destination: {
	29	branch: { name: "main" },
	30	repository: {
	31	full_name: "pingdotgg/t3code",
	32	workspace: { slug: "pingdotgg" },
	33	},
	34	},
	35	};
	36
	37	const repositoryJson = {
	38	full_name: "pingdotgg/t3code",
	39	links: {
	40	html: { href: "https://bitbucket.org/pingdotgg/t3code" },
	41	clone: [
	42	{ name: "https", href: "https://bitbucket.org/pingdotgg/t3code.git" },
	43	{ name: "ssh", href: "git@bitbucket.org:pingdotgg/t3code.git" },
	44	],
	45	},
	46	mainbranch: { name: "main" },
	47	};
	48
	49	function makeLayer(input: {
	50	readonly response: (request: HttpClientRequest.HttpClientRequest) => Response;
	51	readonly git?: Partial<GitVcsDriver.GitVcsDriverShape>;
	52	}) {
	53	const execute = vi.fn((request: HttpClientRequest.HttpClientRequest) =>
	54	Effect.succeed(HttpClientResponse.fromWeb(request, input.response(request))),
	55	);
	56	const gitMock = {
	57	readConfigValue: vi.fn<GitVcsDriver.GitVcsDriverShape["readConfigValue"]>(() =>
	58	Effect.succeed<string \| null>("git@bitbucket.org:pingdotgg/t3code.git"),
	59	),
	60	resolvePrimaryRemoteName: vi.fn<GitVcsDriver.GitVcsDriverShape["resolvePrimaryRemoteName"]>(
	61	() => Effect.succeed("origin"),
	62	),
	63	ensureRemote: vi.fn<GitVcsDriver.GitVcsDriverShape["ensureRemote"]>(() =>
	64	Effect.succeed("octocat"),
	65	),
	66	fetchRemoteBranch: vi.fn<GitVcsDriver.GitVcsDriverShape["fetchRemoteBranch"]>(
	67	() => Effect.void,
	68	),
	69	fetchRemoteTrackingBranch: vi.fn<GitVcsDriver.GitVcsDriverShape["fetchRemoteTrackingBranch"]>(
	70	() => Effect.void,
	71	),
	72	setBranchUpstream: vi.fn<GitVcsDriver.GitVcsDriverShape["setBranchUpstream"]>(
	73	() => Effect.void,
	74	),
	75	switchRef: vi.fn<GitVcsDriver.GitVcsDriverShape["switchRef"]>((request) =>
	76	Effect.succeed({ refName: request.refName }),
	77	),
	78	listLocalBranchNames: vi.fn<GitVcsDriver.GitVcsDriverShape["listLocalBranchNames"]>(() =>
	79	Effect.succeed([]),
	80	),
	81	};
	82	const git = {
	83	...gitMock,
	84	...input.git,
	85	} satisfies Partial<GitVcsDriver.GitVcsDriverShape>;
	86
	87	const driver = {
	88	listRemotes: () =>
	89	Effect.succeed({
	90	remotes: [
	91	{
	92	name: "origin",
	93	url: "git@bitbucket.org:pingdotgg/t3code.git",
	94	pushUrl: Option.none(),
	95	isPrimary: true,
	96	},
	97	],
	98	freshness: {
	99	source: "live-local" as const,
	100	observedAt: DateTime.makeUnsafe("1970-01-01T00:00:00.000Z"),
	101	expiresAt: Option.none(),
	102	},
	103	}),
	104	} satisfies Partial<VcsDriver.VcsDriverShape>;
	105
	106	const layer = BitbucketApi.layer.pipe(
	107	Layer.provide(
	108	Layer.succeed(
	109	HttpClient.HttpClient,
	110	HttpClient.make((request) => execute(request)),
	111	),
	112	),
	113	Layer.provide(
	114	Layer.mock(VcsDriverRegistry.VcsDriverRegistry)({
	115	resolve: () =>
	116	Effect.succeed({
	117	kind: "git",
	118	repository: {
	119	kind: "git",
	120	rootPath: "/repo",
	121	metadataPath: null,
	122	freshness: {
	123	source: "live-local" as const,
	124	observedAt: DateTime.makeUnsafe("1970-01-01T00:00:00.000Z"),
	125	expiresAt: Option.none(),
	126	},
	127	},
	128	driver: driver as unknown as VcsDriver.VcsDriverShape,
	129	}),
	130	}),
	131	),
	132	Layer.provide(Layer.mock(GitVcsDriver.GitVcsDriver)(git)),
	133	Layer.provide(
	134	ConfigProvider.layer(
	135	ConfigProvider.fromEnv({
	136	env: {
	137	T3CODE_BITBUCKET_API_BASE_URL: "https://api.test.local/2.0",
	138	T3CODE_BITBUCKET_EMAIL: "user@example.com",
	139	T3CODE_BITBUCKET_API_TOKEN: "token",
	140	},
	141	}),
	142	),
	143	),
	144	Layer.provideMerge(NodeServices.layer),
	145	);
	146
	147	return { execute, git: gitMock, layer };
	148	}
	149
	150	it.effect("parses pull request responses from the Bitbucket REST API", () => {
	151	const { execute, layer } = makeLayer({
	152	response: () =>
	153	Response.json({
	154	...bitbucketPullRequest,
	155	}),
	156	});
	157
	158	return Effect.gen(function* () {
	159	const bitbucket = yield* BitbucketApi.BitbucketApi;
	160	const result = yield* bitbucket.getPullRequest({
	161	cwd: "/repo",
	162	reference: "#42",
	163	});
	164
	165	assert.deepStrictEqual(result, {
	166	number: 42,
	167	title: "Add Bitbucket provider",
	168	url: "https://bitbucket.org/pingdotgg/t3code/pull-requests/42",
	169	baseRefName: "main",
	170	headRefName: "feature/source-control",
	171	state: "open",
	172	updatedAt: Option.some(DateTime.makeUnsafe("2026-01-02T00:00:00.000Z")),
	173	isCrossRepository: true,
	174	headRepositoryNameWithOwner: "octocat/t3code",
	175	headRepositoryOwnerLogin: "octocat",
	176	});
	177	assert.strictEqual(
	178	execute.mock.calls[0]?.[0].url,
	179	"https://api.test.local/2.0/repositories/pingdotgg/t3code/pullrequests/42",
	180	);
	181	}).pipe(Effect.provide(layer));
	182	});
	183
	184	it.effect("lists pull requests with Bitbucket state and source branch query params", () => {
	185	const { execute, layer } = makeLayer({
	186	response: () =>
	187	Response.json({
	188	values: [
	189	{
	190	...bitbucketPullRequest,
	191	id: 7,
	192	state: "MERGED",
	193	source: {
	194	branch: { name: "feature/merged" },
	195	repository: { full_name: "pingdotgg/t3code" },
	196	},
	197	},
	198	],
	199	}),
	200	});
	201
	202	return Effect.gen(function* () {
	203	const bitbucket = yield* BitbucketApi.BitbucketApi;
	204	const result = yield* bitbucket.listPullRequests({
	205	cwd: "/repo",
	206	headSelector: "origin:feature/merged",
	207	state: "merged",
	208	limit: 10,
	209	});
	210
	211	assert.strictEqual(result[0]?.state, "merged");
	212	const request = execute.mock.calls[0]?.[0];
	213	assert.strictEqual(
	214	request?.url,
	215	"https://api.test.local/2.0/repositories/pingdotgg/t3code/pullrequests",
	216	);
	217	assert.deepStrictEqual(request?.urlParams.params, [
	218	["pagelen", "10"],
	219	["sort", "-updated_on"],
	220	["q", 'source.branch.name = "feature/merged" AND state = "MERGED"'],
	221	["state", "MERGED"],
	222	]);
	223	}).pipe(Effect.provide(layer));
	224	});
	225
	226	it.effect("lists closed pull requests with both closed Bitbucket states", () => {
	227	const { execute, layer } = makeLayer({
	228	response: () =>
	229	Response.json({
	230	values: [],
	231	}),
	232	});
	233
	234	return Effect.gen(function* () {
	235	const bitbucket = yield* BitbucketApi.BitbucketApi;
	236	yield* bitbucket.listPullRequests({
	237	cwd: "/repo",
	238	headSelector: "feature/closed",
	239	state: "closed",
	240	limit: 10,
	241	});
	242
	243	assert.deepStrictEqual(execute.mock.calls[0]?.[0].urlParams.params, [
	244	["pagelen", "10"],
	245	["sort", "-updated_on"],
	246	[
	247	"q",
	248	'source.branch.name = "feature/closed" AND (state = "DECLINED" OR state = "SUPERSEDED")',
	249	],
	250	["state", "DECLINED"],
	251	["state", "SUPERSEDED"],
	252	]);
	253	}).pipe(Effect.provide(layer));
	254	});
	255
	256	it.effect("expands all-state pull request listing instead of relying on Bitbucket defaults", () => {
	257	const { execute, layer } = makeLayer({
	258	response: () =>
	259	Response.json({
	260	values: [],
	261	}),
	262	});
	263
	264	return Effect.gen(function* () {
	265	const bitbucket = yield* BitbucketApi.BitbucketApi;
	266	yield* bitbucket.listPullRequests({
	267	cwd: "/repo",
	268	headSelector: "feature/all",
	269	state: "all",
	270	limit: 10,
	271	});
	272
	273	assert.deepStrictEqual(execute.mock.calls[0]?.[0].urlParams.params, [
	274	["pagelen", "10"],
	275	["sort", "-updated_on"],
	276	[
	277	"q",
	278	'source.branch.name = "feature/all" AND (state = "OPEN" OR state = "MERGED" OR state = "DECLINED" OR state = "SUPERSEDED")',
	279	],
	280	["state", "OPEN"],
	281	["state", "MERGED"],
	282	["state", "DECLINED"],
	283	["state", "SUPERSEDED"],
	284	]);
	285	}).pipe(Effect.provide(layer));
	286	});
	287
	288	it.effect("reads repository clone URLs and default branch", () => {
	289	const { layer } = makeLayer({
	290	response: () => Response.json(repositoryJson),
	291	});
	292
	293	return Effect.gen(function* () {
	294	const bitbucket = yield* BitbucketApi.BitbucketApi;
	295	const cloneUrls = yield* bitbucket.getRepositoryCloneUrls({
	296	cwd: "/repo",
	297	repository: "pingdotgg/t3code",
	298	});
	299	const defaultBranch = yield* bitbucket.getDefaultBranch({ cwd: "/repo" });
	300
	301	assert.deepStrictEqual(cloneUrls, {
	302	nameWithOwner: "pingdotgg/t3code",
	303	url: "https://bitbucket.org/pingdotgg/t3code.git",
	304	sshUrl: "git@bitbucket.org:pingdotgg/t3code.git",
	305	});
	306	assert.strictEqual(defaultBranch, "main");
	307	}).pipe(Effect.provide(layer));
	308	});
	309
	310	it.effect("creates repositories through the Bitbucket REST API", () => {
	311	const { execute, layer } = makeLayer({
	312	response: () => Response.json(repositoryJson),
	313	});
	314
	315	return Effect.gen(function* () {
	316	const bitbucket = yield* BitbucketApi.BitbucketApi;
	317	const cloneUrls = yield* bitbucket.createRepository({
	318	cwd: "/repo",
	319	repository: "pingdotgg/t3code",
	320	visibility: "private",
	321	});
	322
	323	assert.deepStrictEqual(cloneUrls, {
	324	nameWithOwner: "pingdotgg/t3code",
	325	url: "https://bitbucket.org/pingdotgg/t3code.git",
	326	sshUrl: "git@bitbucket.org:pingdotgg/t3code.git",
	327	});
	328
	329	const request = execute.mock.calls[0]?.[0];
	330	assert.strictEqual(request?.url, "https://api.test.local/2.0/repositories/pingdotgg/t3code");
	331	assert.strictEqual(request?.method, "POST");
	332	assert.ok(request);
	333	const rawBody = (request.body as { readonly body?: Uint8Array }).body;
	334	assert.ok(rawBody);
	335	assert.deepStrictEqual(JSON.parse(new TextDecoder().decode(rawBody)), {
	336	scm: "git",
	337	is_private: true,
	338	});
	339	}).pipe(Effect.provide(layer));
	340	});
	341
	342	it.effect("creates pull requests using the official REST payload shape", () => {
	343	const { execute, layer } = makeLayer({
	344	response: () => Response.json(bitbucketPullRequest),
	345	});
	346
	347	return Effect.gen(function* () {
	348	const fileSystem = yield* FileSystem.FileSystem;
	349	const bodyFile = yield* fileSystem.makeTempFileScoped({ prefix: "bitbucket-pr-body-" });
	350	yield* fileSystem.writeFileString(bodyFile, "PR body");
	351
	352	const bitbucket = yield* BitbucketApi.BitbucketApi;
	353	yield* bitbucket.createPullRequest({
	354	cwd: "/repo",
	355	baseBranch: "main",
	356	headSelector: "owner:feature/provider",
	357	title: "Provider PR",
	358	bodyFile,
	359	});
	360
	361	const request = execute.mock.calls[0]?.[0];
	362	assert.strictEqual(
	363	request?.url,
	364	"https://api.test.local/2.0/repositories/pingdotgg/t3code/pullrequests",
	365	);
	366	assert.strictEqual(request?.method, "POST");
	367	assert.ok(request);
	368	const rawBody = (request.body as { readonly body?: Uint8Array }).body;
	369	assert.ok(rawBody);
	370	assert.deepStrictEqual(JSON.parse(new TextDecoder().decode(rawBody)), {
	371	title: "Provider PR",
	372	description: "PR body",
	373	source: {
	374	branch: { name: "feature/provider" },
	375	repository: { full_name: "owner/t3code" },
	376	},
	377	destination: {
	378	branch: { name: "main" },
	379	},
	380	});
	381	}).pipe(Effect.provide(layer), Effect.scoped);
	382	});
	383
	384	it.effect("reports auth status through the Bitbucket REST /user endpoint", () => {
	385	const { layer } = makeLayer({
	386	response: () => Response.json({ username: "bitbucket-user" }),
	387	});
	388
	389	return Effect.gen(function* () {
	390	const bitbucket = yield* BitbucketApi.BitbucketApi;
	391	const auth = yield* bitbucket.probeAuth;
	392
	393	assert.deepStrictEqual(auth, {
	394	status: "authenticated",
	395	account: Option.some("bitbucket-user"),
	396	host: Option.some("bitbucket.org"),
	397	detail: Option.none(),
	398	});
	399	}).pipe(Effect.provide(layer));
	400	});
	401
	402	it.effect("checks out same-repository pull requests with the existing Bitbucket remote", () => {
	403	const { git, layer } = makeLayer({
	404	response: () =>
	405	Response.json({
	406	...bitbucketPullRequest,
	407	source: {
	408	branch: { name: "feature/source-control" },
	409	repository: {
	410	full_name: "pingdotgg/t3code",
	411	workspace: { slug: "pingdotgg" },
	412	},
	413	},
	414	}),
	415	});
	416
	417	return Effect.gen(function* () {
	418	const bitbucket = yield* BitbucketApi.BitbucketApi;
	419	yield* bitbucket.checkoutPullRequest({
	420	cwd: "/repo",
	421	context: {
	422	provider: {
	423	kind: "bitbucket",
	424	name: "Bitbucket",
	425	baseUrl: "https://bitbucket.org",
	426	},
	427	remoteName: "origin",
	428	remoteUrl: "git@bitbucket.org:pingdotgg/t3code.git",
	429	},
	430	reference: "42",
	431	force: true,
	432	});
	433
	434	assert.strictEqual(git.ensureRemote.mock.calls.length, 0);
	435	assert.deepStrictEqual(git.fetchRemoteBranch.mock.calls[0]?.[0], {
	436	cwd: "/repo",
	437	remoteName: "origin",
	438	remoteBranch: "feature/source-control",
	439	localBranch: "feature/source-control",
	440	});
	441	assert.deepStrictEqual(git.setBranchUpstream.mock.calls[0]?.[0], {
	442	cwd: "/repo",
	443	branch: "feature/source-control",
	444	remoteName: "origin",
	445	remoteBranch: "feature/source-control",
	446	});
	447	assert.deepStrictEqual(git.switchRef.mock.calls[0]?.[0], {
	448	cwd: "/repo",
	449	refName: "feature/source-control",
	450	});
	451	}).pipe(Effect.provide(layer));
	452	});
	453
	454	it.effect("checks out fork pull requests through an ensured fork remote", () => {
	455	const { git, layer } = makeLayer({
	456	response: (request) => {
	457	if (request.url.endsWith("/repositories/octocat/t3code")) {
	458	return Response.json({
	459	...repositoryJson,
	460	full_name: "octocat/t3code",
	461	links: {
	462	html: { href: "https://bitbucket.org/octocat/t3code" },
	463	clone: [
	464	{ name: "https", href: "https://bitbucket.org/octocat/t3code.git" },
	465	{ name: "ssh", href: "git@bitbucket.org:octocat/t3code.git" },
	466	],
	467	},
	468	});
	469	}
	470	return Response.json({
	471	...bitbucketPullRequest,
	472	source: {
	473	branch: { name: "main" },
	474	repository: {
	475	full_name: "octocat/t3code",
	476	workspace: { slug: "octocat" },
	477	},
	478	},
	479	});
	480	},
	481	});
	482
	483	return Effect.gen(function* () {
	484	const bitbucket = yield* BitbucketApi.BitbucketApi;
	485	yield* bitbucket.checkoutPullRequest({
	486	cwd: "/repo",
	487	reference: "42",
	488	force: true,
	489	});
	490
	491	assert.deepStrictEqual(git.ensureRemote.mock.calls[0]?.[0], {
	492	cwd: "/repo",
	493	preferredName: "octocat",
	494	url: "git@bitbucket.org:octocat/t3code.git",
	495	});
	496	assert.deepStrictEqual(git.fetchRemoteBranch.mock.calls[0]?.[0], {
	497	cwd: "/repo",
	498	remoteName: "octocat",
	499	remoteBranch: "main",
	500	localBranch: "t3code/pr-42/main",
	501	});
	502	assert.deepStrictEqual(git.setBranchUpstream.mock.calls[0]?.[0], {
	503	cwd: "/repo",
	504	branch: "t3code/pr-42/main",
	505	remoteName: "octocat",
	506	remoteBranch: "main",
	507	});
	508	assert.deepStrictEqual(git.switchRef.mock.calls[0]?.[0], {
	509	cwd: "/repo",
	510	refName: "t3code/pr-42/main",
	511	});
	512	}).pipe(Effect.provide(layer));
	513	});

apps/server/src/sourceControl/BitbucketApi.ts+703−0

@@ -0,0 +1,703 @@
	1	import { Config, Context, Effect, FileSystem, Layer, Option, Schema } from "effect";
	2	import {
	3	TrimmedNonEmptyString,
	4	type SourceControlProviderAuth,
	5	type SourceControlRepositoryCloneUrls,
	6	type SourceControlRepositoryVisibility,
	7	} from "@t3tools/contracts";
	8	import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
	9	import { sanitizeBranchFragment } from "@t3tools/shared/git";
	10	import { detectSourceControlProviderFromRemoteUrl } from "@t3tools/shared/sourceControl";
	11
	12	import * as BitbucketPullRequests from "./bitbucketPullRequests.ts";
	13	import * as SourceControlProvider from "./SourceControlProvider.ts";
	14	import * as GitVcsDriver from "../vcs/GitVcsDriver.ts";
	15	import * as VcsDriverRegistry from "../vcs/VcsDriverRegistry.ts";
	16
	17	const DEFAULT_API_BASE_URL = "https://api.bitbucket.org/2.0";
	18
	19	const BitbucketApiEnvConfig = Config.all({
	20	baseUrl: Config.string("T3CODE_BITBUCKET_API_BASE_URL").pipe(
	21	Config.withDefault(DEFAULT_API_BASE_URL),
	22	),
	23	accessToken: Config.string("T3CODE_BITBUCKET_ACCESS_TOKEN").pipe(Config.option),
	24	email: Config.string("T3CODE_BITBUCKET_EMAIL").pipe(Config.option),
	25	apiToken: Config.string("T3CODE_BITBUCKET_API_TOKEN").pipe(Config.option),
	26	});
	27
	28	export class BitbucketApiError extends Schema.TaggedErrorClass<BitbucketApiError>()(
	29	"BitbucketApiError",
	30	{
	31	operation: Schema.String,
	32	detail: Schema.String,
	33	status: Schema.optional(Schema.Number),
	34	cause: Schema.optional(Schema.Defect),
	35	},
	36	) {
	37	override get message(): string {
	38	return `Bitbucket API failed in ${this.operation}: ${this.detail}`;
	39	}
	40	}
	41
	42	const RawBitbucketRepositorySchema = Schema.Struct({
	43	full_name: TrimmedNonEmptyString,
	44	links: Schema.Struct({
	45	html: Schema.optional(
	46	Schema.Struct({
	47	href: TrimmedNonEmptyString,
	48	}),
	49	),
	50	clone: Schema.optional(
	51	Schema.Array(
	52	Schema.Struct({
	53	name: TrimmedNonEmptyString,
	54	href: TrimmedNonEmptyString,
	55	}),
	56	),
	57	),
	58	}),
	59	mainbranch: Schema.optional(
	60	Schema.NullOr(
	61	Schema.Struct({
	62	name: TrimmedNonEmptyString,
	63	}),
	64	),
	65	),
	66	});
	67
	68	const BitbucketUserSchema = Schema.Struct({
	69	username: Schema.optional(TrimmedNonEmptyString),
	70	display_name: Schema.optional(TrimmedNonEmptyString),
	71	account_id: Schema.optional(TrimmedNonEmptyString),
	72	});
	73
	74	export interface BitbucketRepositoryLocator {
	75	readonly workspace: string;
	76	readonly repoSlug: string;
	77	}
	78
	79	export interface BitbucketApiShape {
	80	readonly probeAuth: Effect.Effect<SourceControlProviderAuth, never>;
	81	readonly listPullRequests: (input: {
	82	readonly cwd: string;
	83	readonly context?: SourceControlProvider.SourceControlProviderContext;
	84	readonly headSelector: string;
	85	readonly source?: SourceControlProvider.SourceControlRefSelector;
	86	readonly state: "open" \| "closed" \| "merged" \| "all";
	87	readonly limit?: number;
	88	}) => Effect.Effect<
	89	ReadonlyArray<BitbucketPullRequests.NormalizedBitbucketPullRequestRecord>,
	90	BitbucketApiError
	91	>;
	92	readonly getPullRequest: (input: {
	93	readonly cwd: string;
	94	readonly context?: SourceControlProvider.SourceControlProviderContext;
	95	readonly reference: string;
	96	}) => Effect.Effect<
	97	BitbucketPullRequests.NormalizedBitbucketPullRequestRecord,
	98	BitbucketApiError
	99	>;
	100	readonly getRepositoryCloneUrls: (input: {
	101	readonly cwd: string;
	102	readonly context?: SourceControlProvider.SourceControlProviderContext;
	103	readonly repository: string;
	104	}) => Effect.Effect<SourceControlRepositoryCloneUrls, BitbucketApiError>;
	105	readonly createRepository: (input: {
	106	readonly cwd: string;
	107	readonly repository: string;
	108	readonly visibility: SourceControlRepositoryVisibility;
	109	}) => Effect.Effect<SourceControlRepositoryCloneUrls, BitbucketApiError>;
	110	readonly createPullRequest: (input: {
	111	readonly cwd: string;
	112	readonly context?: SourceControlProvider.SourceControlProviderContext;
	113	readonly baseBranch: string;
	114	readonly headSelector: string;
	115	readonly source?: SourceControlProvider.SourceControlRefSelector;
	116	readonly target?: SourceControlProvider.SourceControlRefSelector;
	117	readonly title: string;
	118	readonly bodyFile: string;
	119	}) => Effect.Effect<void, BitbucketApiError>;
	120	readonly getDefaultBranch: (input: {
	121	readonly cwd: string;
	122	readonly context?: SourceControlProvider.SourceControlProviderContext;
	123	}) => Effect.Effect<string \| null, BitbucketApiError>;
	124	readonly checkoutPullRequest: (input: {
	125	readonly cwd: string;
	126	readonly context?: SourceControlProvider.SourceControlProviderContext;
	127	readonly reference: string;
	128	readonly force?: boolean;
	129	}) => Effect.Effect<void, BitbucketApiError>;
	130	}
	131
	132	export class BitbucketApi extends Context.Service<BitbucketApi, BitbucketApiShape>()(
	133	"t3/source-control/BitbucketApi",
	134	) {}
	135
	136	function nonEmpty(value: string \| undefined): Option.Option<string> {
	137	const trimmed = value?.trim();
	138	return trimmed === undefined \|\| trimmed.length === 0 ? Option.none() : Option.some(trimmed);
	139	}
	140
	141	function normalizeChangeRequestId(reference: string): string {
	142	const trimmed = reference.trim().replace(/^#/, "");
	143	const urlMatch = /(?:pull-requests\|pullrequests\|pull-request\|pull\|pr)\/(\d+)(?:\D.*)?$/i.exec(
	144	trimmed,
	145	);
	146	return urlMatch?.[1] ?? trimmed;
	147	}
	148
	149	function sourceWorkspace(input: {
	150	readonly headSelector: string;
	151	readonly source?: SourceControlProvider.SourceControlRefSelector;
	152	}): string \| undefined {
	153	if (input.source?.owner) return input.source.owner;
	154	return SourceControlProvider.parseSourceControlOwnerRef(input.headSelector)?.owner;
	155	}
	156
	157	function toBitbucketStates(state: "open" \| "closed" \| "merged" \| "all"): ReadonlyArray<string> {
	158	switch (state) {
	159	case "open":
	160	return ["OPEN"];
	161	case "closed":
	162	return ["DECLINED", "SUPERSEDED"];
	163	case "merged":
	164	return ["MERGED"];
	165	case "all":
	166	return ["OPEN", "MERGED", "DECLINED", "SUPERSEDED"];
	167	}
	168	}
	169
	170	function bitbucketQueryString(filters: ReadonlyArray<string>): string {
	171	return filters.join(" AND ");
	172	}
	173
	174	function bitbucketStateFilter(states: ReadonlyArray<string>): string {
	175	return states.length === 1
	176	? `state = "${states[0]}"`
	177	: `(${states.map((state) => `state = "${state}"`).join(" OR ")})`;
	178	}
	179
	180	function parseBitbucketRepositorySlug(value: string): BitbucketRepositoryLocator \| null {
	181	const normalized = value.trim().replace(/\.git$/u, "");
	182	const parts = normalized.split("/").filter((part) => part.length > 0);
	183	if (parts.length < 2) return null;
	184	const workspace = parts.at(-2);
	185	const repoSlug = parts.at(-1);
	186	return workspace && repoSlug ? { workspace, repoSlug } : null;
	187	}
	188
	189	function requireRepositoryLocator(
	190	operation: string,
	191	repository: string,
	192	): Effect.Effect<BitbucketRepositoryLocator, BitbucketApiError> {
	193	const locator = parseBitbucketRepositorySlug(repository);
	194	return locator
	195	? Effect.succeed(locator)
	196	: Effect.fail(
	197	new BitbucketApiError({
	198	operation,
	199	detail: "Bitbucket repositories must be specified as workspace/repository.",
	200	}),
	201	);
	202	}
	203
	204	function parseBitbucketRemoteUrl(remoteUrl: string): BitbucketRepositoryLocator \| null {
	205	const trimmed = remoteUrl.trim();
	206	if (trimmed.startsWith("git@")) {
	207	const pathStart = trimmed.indexOf(":");
	208	return pathStart < 0 ? null : parseBitbucketRepositorySlug(trimmed.slice(pathStart + 1));
	209	}
	210
	211	try {
	212	return parseBitbucketRepositorySlug(new URL(trimmed).pathname);
	213	} catch {
	214	return null;
	215	}
	216	}
	217
	218	function normalizeRepositoryCloneUrls(
	219	raw: Schema.Schema.Type<typeof RawBitbucketRepositorySchema>,
	220	): SourceControlRepositoryCloneUrls {
	221	const httpClone =
	222	raw.links.clone?.find((entry) => entry.name.toLowerCase() === "https")?.href ??
	223	raw.links.html?.href;
	224	const sshClone = raw.links.clone?.find((entry) => entry.name.toLowerCase() === "ssh")?.href;
	225
	226	return {
	227	nameWithOwner: raw.full_name,
	228	url: httpClone ?? raw.links.html?.href ?? raw.full_name,
	229	sshUrl: sshClone ?? httpClone ?? raw.full_name,
	230	};
	231	}
	232
	233	function shouldPreferSshRemote(originRemoteUrl: string \| null): boolean {
	234	const trimmed = originRemoteUrl?.trim() ?? "";
	235	return trimmed.startsWith("git@") \|\| trimmed.startsWith("ssh://");
	236	}
	237
	238	function selectCloneUrl(input: {
	239	readonly cloneUrls: SourceControlRepositoryCloneUrls;
	240	readonly originRemoteUrl: string \| null;
	241	}): string {
	242	return shouldPreferSshRemote(input.originRemoteUrl)
	243	? input.cloneUrls.sshUrl
	244	: input.cloneUrls.url;
	245	}
	246
	247	function checkoutBranchName(input: {
	248	readonly pullRequestId: number;
	249	readonly headBranch: string;
	250	readonly isCrossRepository: boolean;
	251	}): string {
	252	if (!input.isCrossRepository) {
	253	return input.headBranch;
	254	}
	255
	256	return `t3code/pr-${input.pullRequestId}/${sanitizeBranchFragment(input.headBranch)}`;
	257	}
	258
	259	function repositoryNameWithOwner(
	260	repository: Schema.Schema.Type<
	261	typeof BitbucketPullRequests.BitbucketPullRequestSchema
	262	>["source"]["repository"],
	263	): string \| null {
	264	const fullName = repository?.full_name?.trim() ?? "";
	265	return fullName.length > 0 ? fullName : null;
	266	}
	267
	268	function repositoryOwnerName(repositoryName: string): string {
	269	return repositoryName.split("/")[0]?.trim() \|\| "bitbucket";
	270	}
	271
	272	function authFromConfig(
	273	config: Config.Success<typeof BitbucketApiEnvConfig>,
	274	): SourceControlProviderAuth {
	275	if (Option.isSome(config.accessToken)) {
	276	return {
	277	status: "unknown",
	278	account: Option.none(),
	279	host: Option.some("bitbucket.org"),
	280	detail: Option.some("Bitbucket access token is configured."),
	281	};
	282	}
	283
	284	if (Option.isSome(config.email) && Option.isSome(config.apiToken)) {
	285	return {
	286	status: "unknown",
	287	account: config.email,
	288	host: Option.some("bitbucket.org"),
	289	detail: Option.some("Bitbucket API token is configured."),
	290	};
	291	}
	292
	293	return {
	294	status: "unauthenticated",
	295	account: Option.none(),
	296	host: Option.some("bitbucket.org"),
	297	detail: Option.some(
	298	"Set T3CODE_BITBUCKET_EMAIL and T3CODE_BITBUCKET_API_TOKEN, or T3CODE_BITBUCKET_ACCESS_TOKEN.",
	299	),
	300	};
	301	}
	302
	303	function requestError(operation: string, cause: unknown): BitbucketApiError {
	304	return new BitbucketApiError({
	305	operation,
	306	detail: cause instanceof Error ? cause.message : String(cause),
	307	cause,
	308	});
	309	}
	310
	311	function isBitbucketApiError(cause: unknown): cause is BitbucketApiError {
	312	return Schema.is(BitbucketApiError)(cause);
	313	}
	314
	315	function responseError(
	316	operation: string,
	317	response: HttpClientResponse.HttpClientResponse,
	318	): Effect.Effect<never, BitbucketApiError> {
	319	return response.text.pipe(
	320	Effect.catch(() => Effect.succeed("")),
	321	Effect.flatMap((body) =>
	322	Effect.fail(
	323	new BitbucketApiError({
	324	operation,
	325	status: response.status,
	326	detail:
	327	body.trim().length > 0
	328	? `Bitbucket returned HTTP ${response.status}: ${body.trim()}`
	329	: `Bitbucket returned HTTP ${response.status}.`,
	330	}),
	331	),
	332	),
	333	);
	334	}
	335
	336	export const make = Effect.fn("makeBitbucketApi")(function* () {
	337	const config = yield* BitbucketApiEnvConfig;
	338	const httpClient = yield* HttpClient.HttpClient;
	339	const fileSystem = yield* FileSystem.FileSystem;
	340	const git = yield* GitVcsDriver.GitVcsDriver;
	341	const vcsRegistry = yield* VcsDriverRegistry.VcsDriverRegistry;
	342
	343	const apiUrl = (path: string) => `${config.baseUrl.replace(/\/+$/u, "")}${path}`;
	344
	345	const withAuth = (request: HttpClientRequest.HttpClientRequest) => {
	346	if (Option.isSome(config.accessToken)) {
	347	return request.pipe(HttpClientRequest.bearerToken(config.accessToken.value));
	348	}
	349	if (Option.isSome(config.email) && Option.isSome(config.apiToken)) {
	350	return request.pipe(HttpClientRequest.basicAuth(config.email.value, config.apiToken.value));
	351	}
	352	return request;
	353	};
	354
	355	const decodeResponse = <S extends Schema.Top>(
	356	operation: string,
	357	schema: S,
	358	response: HttpClientResponse.HttpClientResponse,
	359	): Effect.Effect<S["Type"], BitbucketApiError, S["DecodingServices"]> =>
	360	HttpClientResponse.matchStatus({
	361	"2xx": (success) =>
	362	HttpClientResponse.schemaBodyJson(schema)(success).pipe(
	363	Effect.mapError(
	364	(cause) =>
	365	new BitbucketApiError({
	366	operation,
	367	detail: "Bitbucket returned invalid JSON for the requested resource.",
	368	cause,
	369	}),
	370	),
	371	),
	372	orElse: (failed) => responseError(operation, failed),
	373	})(response);
	374
	375	const executeJson = <S extends Schema.Top>(
	376	operation: string,
	377	request: HttpClientRequest.HttpClientRequest,
	378	schema: S,
	379	): Effect.Effect<S["Type"], BitbucketApiError, S["DecodingServices"]> =>
	380	httpClient.execute(withAuth(request.pipe(HttpClientRequest.acceptJson))).pipe(
	381	Effect.mapError((cause) => requestError(operation, cause)),
	382	Effect.flatMap((response) => decodeResponse(operation, schema, response)),
	383	);
	384
	385	const resolveRepository = Effect.fn("BitbucketApi.resolveRepository")(function* (input: {
	386	readonly cwd: string;
	387	readonly context?: SourceControlProvider.SourceControlProviderContext;
	388	readonly repository?: string;
	389	}) {
	390	const fromRepository =
	391	input.repository !== undefined ? parseBitbucketRepositorySlug(input.repository) : null;
	392	if (fromRepository) return fromRepository;
	393
	394	const fromContext =
	395	input.context?.provider.kind === "bitbucket"
	396	? parseBitbucketRemoteUrl(input.context.remoteUrl)
	397	: null;
	398	if (fromContext) return fromContext;
	399
	400	const handle = yield* vcsRegistry.resolve({ cwd: input.cwd }).pipe(
	401	Effect.mapError(
	402	(cause) =>
	403	new BitbucketApiError({
	404	operation: "resolveRepository",
	405	detail: `Failed to resolve VCS repository for ${input.cwd}.`,
	406	cause,
	407	}),
	408	),
	409	);
	410	const remotes = yield* handle.driver.listRemotes(input.cwd).pipe(
	411	Effect.mapError(
	412	(cause) =>
	413	new BitbucketApiError({
	414	operation: "resolveRepository",
	415	detail: `Failed to list remotes for ${input.cwd}.`,
	416	cause,
	417	}),
	418	),
	419	);
	420
	421	for (const remote of remotes.remotes) {
	422	if (detectSourceControlProviderFromRemoteUrl(remote.url)?.kind !== "bitbucket") continue;
	423	const parsed = parseBitbucketRemoteUrl(remote.url);
	424	if (parsed) return parsed;
	425	}
	426
	427	return yield* new BitbucketApiError({
	428	operation: "resolveRepository",
	429	detail: `No Bitbucket repository remote was detected for ${input.cwd}.`,
	430	});
	431	});
	432
	433	const getRepository = (input: {
	434	readonly cwd: string;
	435	readonly context?: SourceControlProvider.SourceControlProviderContext;
	436	readonly repository?: string;
	437	}) =>
	438	resolveRepository(input).pipe(
	439	Effect.flatMap((repository) =>
	440	executeJson(
	441	"getRepository",
	442	HttpClientRequest.get(
	443	apiUrl(
	444	`/repositories/${encodeURIComponent(repository.workspace)}/${encodeURIComponent(repository.repoSlug)}`,
	445	),
	446	),
	447	RawBitbucketRepositorySchema,
	448	),
	449	),
	450	);
	451
	452	const getRawPullRequestFromRepository = (
	453	repository: BitbucketRepositoryLocator,
	454	reference: string,
	455	) =>
	456	executeJson(
	457	"getPullRequest",
	458	HttpClientRequest.get(
	459	apiUrl(
	460	`/repositories/${encodeURIComponent(repository.workspace)}/${encodeURIComponent(repository.repoSlug)}/pullrequests/${encodeURIComponent(normalizeChangeRequestId(reference))}`,
	461	),
	462	),
	463	BitbucketPullRequests.BitbucketPullRequestSchema,
	464	);
	465
	466	const getRawPullRequest = (input: {
	467	readonly cwd: string;
	468	readonly context?: SourceControlProvider.SourceControlProviderContext;
	469	readonly reference: string;
	470	}) =>
	471	resolveRepository(input).pipe(
	472	Effect.flatMap((repository) => getRawPullRequestFromRepository(repository, input.reference)),
	473	);
	474
	475	const readConfigValueNullable = (cwd: string, key: string) =>
	476	git.readConfigValue(cwd, key).pipe(Effect.catch(() => Effect.succeed(null)));
	477
	478	const resolveCheckoutRemote = Effect.fn("BitbucketApi.resolveCheckoutRemote")(function* (input: {
	479	readonly cwd: string;
	480	readonly context?: SourceControlProvider.SourceControlProviderContext;
	481	readonly destinationRepository: BitbucketRepositoryLocator;
	482	readonly sourceRepositoryName: string;
	483	readonly isCrossRepository: boolean;
	484	}) {
	485	if (
	486	input.context?.provider.kind === "bitbucket" &&
	487	!input.isCrossRepository &&
	488	parseBitbucketRemoteUrl(input.context.remoteUrl) !== null
	489	) {
	490	return input.context.remoteName;
	491	}
	492
	493	if (!input.isCrossRepository) {
	494	const remoteName = yield* git
	495	.resolvePrimaryRemoteName(input.cwd)
	496	.pipe(Effect.catch(() => Effect.succeed(null)));
	497	if (remoteName) return remoteName;
	498	}
	499
	500	const cloneUrls = yield* getRepository({
	501	cwd: input.cwd,
	502	repository: input.sourceRepositoryName,
	503	...(input.context ? { context: input.context } : {}),
	504	}).pipe(Effect.map(normalizeRepositoryCloneUrls));
	505	const originRemoteUrl = yield* readConfigValueNullable(input.cwd, "remote.origin.url");
	506	return yield* git.ensureRemote({
	507	cwd: input.cwd,
	508	preferredName: input.isCrossRepository
	509	? repositoryOwnerName(input.sourceRepositoryName)
	510	: input.destinationRepository.workspace,
	511	url: selectCloneUrl({ cloneUrls, originRemoteUrl }),
	512	});
	513	});
	514
	515	return BitbucketApi.of({
	516	probeAuth: executeJson(
	517	"probeAuth",
	518	HttpClientRequest.get(apiUrl("/user")),
	519	BitbucketUserSchema,
	520	).pipe(
	521	Effect.map((user) => ({
	522	status: "authenticated" as const,
	523	account: nonEmpty(user.username ?? user.display_name ?? user.account_id),
	524	host: Option.some("bitbucket.org"),
	525	detail: Option.none<string>(),
	526	})),
	527	Effect.catch(() => Effect.succeed(authFromConfig(config))),
	528	),
	529	listPullRequests: (input) =>
	530	resolveRepository(input).pipe(
	531	Effect.flatMap((repository) => {
	532	const states = toBitbucketStates(input.state);
	533	const query: Record<string, string \| ReadonlyArray<string>> = {
	534	pagelen: String(Math.max(1, Math.min(input.limit ?? 20, 50))),
	535	sort: "-updated_on",
	536	q: bitbucketQueryString([
	537	`source.branch.name = "${SourceControlProvider.sourceBranch(input).replaceAll('"', '\\"')}"`,
	538	bitbucketStateFilter(states),
	539	]),
	540	state: states,
	541	};
	542
	543	return executeJson(
	544	"listPullRequests",
	545	HttpClientRequest.get(
	546	apiUrl(
	547	`/repositories/${encodeURIComponent(repository.workspace)}/${encodeURIComponent(repository.repoSlug)}/pullrequests`,
	548	),
	549	{ urlParams: query },
	550	),
	551	BitbucketPullRequests.BitbucketPullRequestListSchema,
	552	);
	553	}),
	554	Effect.map((list) =>
	555	list.values.map(BitbucketPullRequests.normalizeBitbucketPullRequestRecord),
	556	),
	557	),
	558	getPullRequest: (input) =>
	559	getRawPullRequest(input).pipe(
	560	Effect.map(BitbucketPullRequests.normalizeBitbucketPullRequestRecord),
	561	),
	562	getRepositoryCloneUrls: (input) =>
	563	getRepository(input).pipe(Effect.map(normalizeRepositoryCloneUrls)),
	564	createRepository: (input) =>
	565	requireRepositoryLocator("createRepository", input.repository).pipe(
	566	Effect.flatMap((repository) =>
	567	executeJson(
	568	"createRepository",
	569	HttpClientRequest.post(
	570	apiUrl(
	571	`/repositories/${encodeURIComponent(repository.workspace)}/${encodeURIComponent(repository.repoSlug)}`,
	572	),
	573	).pipe(
	574	HttpClientRequest.bodyJsonUnsafe({
	575	scm: "git",
	576	is_private: input.visibility === "private",
	577	}),
	578	),
	579	RawBitbucketRepositorySchema,
	580	),
	581	),
	582	Effect.map(normalizeRepositoryCloneUrls),
	583	),
	584	createPullRequest: (input) =>
	585	Effect.gen(function* () {
	586	const repository = yield* resolveRepository(input);
	587	const description = yield* fileSystem.readFileString(input.bodyFile).pipe(
	588	Effect.mapError(
	589	(cause) =>
	590	new BitbucketApiError({
	591	operation: "createPullRequest",
	592	detail: `Failed to read pull request body file ${input.bodyFile}.`,
	593	cause,
	594	}),
	595	),
	596	);
	597	const sourceOwner = sourceWorkspace(input);
	598	const body = {
	599	title: input.title,
	600	description,
	601	source: {
	602	branch: {
	603	name: SourceControlProvider.sourceBranch(input),
	604	},
	605	...(sourceOwner
	606	? {
	607	repository: {
	608	full_name: `${sourceOwner}/${input.source?.repository ?? repository.repoSlug}`,
	609	},
	610	}
	611	: {}),
	612	},
	613	destination: {
	614	branch: {
	615	name: input.target?.refName ?? input.baseBranch,
	616	},
	617	},
	618	};
	619
	620	yield* executeJson(
	621	"createPullRequest",
	622	HttpClientRequest.post(
	623	apiUrl(
	624	`/repositories/${encodeURIComponent(repository.workspace)}/${encodeURIComponent(repository.repoSlug)}/pullrequests`,
	625	),
	626	).pipe(HttpClientRequest.bodyJsonUnsafe(body)),
	627	BitbucketPullRequests.BitbucketPullRequestSchema,
	628	);
	629	}),
	630	getDefaultBranch: (input) =>
	631	getRepository(input).pipe(Effect.map((repository) => repository.mainbranch?.name ?? null)),
	632	// Bitbucket Cloud pull requests are Git-backed and Bitbucket does not provide
	633	// an official checkout CLI. This provider-local path uses GitVcsDriver as a
	634	// narrow escape hatch to materialize Bitbucket PR refs. Do not generalize this
	635	// as the source-control provider model: if we support non-Git-compatible
	636	// hosting providers or native JJ/Sapling checkout flows, move this into a
	637	// VCS-specific change-request checkout capability.
	638	checkoutPullRequest: (input) =>
	639	Effect.gen(function* () {
	640	const destinationRepository = yield* resolveRepository(input);
	641	const pullRequest = yield* getRawPullRequestFromRepository(
	642	destinationRepository,
	643	input.reference,
	644	);
	645	const destinationRepositoryName =
	646	repositoryNameWithOwner(pullRequest.destination.repository) ??
	647	`${destinationRepository.workspace}/${destinationRepository.repoSlug}`;
	648	const sourceRepositoryName =
	649	repositoryNameWithOwner(pullRequest.source.repository) ?? destinationRepositoryName;
	650	const isCrossRepository = sourceRepositoryName !== destinationRepositoryName;
	651	const remoteName = yield* resolveCheckoutRemote({
	652	cwd: input.cwd,
	653	destinationRepository,
	654	sourceRepositoryName,
	655	isCrossRepository,
	656	...(input.context ? { context: input.context } : {}),
	657	});
	658	const remoteBranch = pullRequest.source.branch.name;
	659	const localBranch = checkoutBranchName({
	660	pullRequestId: pullRequest.id,
	661	headBranch: remoteBranch,
	662	isCrossRepository,
	663	});
	664	const localBranchNames = yield* git.listLocalBranchNames(input.cwd);
	665	const localBranchExists = localBranchNames.includes(localBranch);
	666
	667	if (input.force === true \|\| !localBranchExists) {
	668	yield* git.fetchRemoteBranch({
	669	cwd: input.cwd,
	670	remoteName,
	671	remoteBranch,
	672	localBranch,
	673	});
	674	} else {
	675	yield* git.fetchRemoteTrackingBranch({
	676	cwd: input.cwd,
	677	remoteName,
	678	remoteBranch,
	679	});
	680	}
	681
	682	yield* git.setBranchUpstream({
	683	cwd: input.cwd,
	684	branch: localBranch,
	685	remoteName,
	686	remoteBranch,
	687	});
	688	yield* Effect.scoped(git.switchRef({ cwd: input.cwd, refName: localBranch }));
	689	}).pipe(
	690	Effect.mapError((cause) =>
	691	isBitbucketApiError(cause)
	692	? cause
	693	: new BitbucketApiError({
	694	operation: "checkoutPullRequest",
	695	detail: cause instanceof Error ? cause.message : String(cause),
	696	cause,
	697	}),
	698	),
	699	),
	700	});
	701	});
	702
	703	export const layer = Layer.effect(BitbucketApi, make());

apps/server/src/sourceControl/BitbucketSourceControlProvider.test.ts+126−0

@@ -0,0 +1,126 @@
	1	import { assert, it } from "@effect/vitest";
	2	import { Effect, Layer, Option } from "effect";
	3
	4	import * as BitbucketApi from "./BitbucketApi.ts";
	5	import * as BitbucketSourceControlProvider from "./BitbucketSourceControlProvider.ts";
	6
	7	function makeProvider(bitbucket: Partial<BitbucketApi.BitbucketApiShape>) {
	8	return BitbucketSourceControlProvider.make().pipe(
	9	Effect.provide(Layer.mock(BitbucketApi.BitbucketApi)(bitbucket)),
	10	);
	11	}
	12
	13	it.effect("maps Bitbucket PR summaries into provider-neutral change requests", () =>
	14	Effect.gen(function* () {
	15	const provider = yield* makeProvider({
	16	getPullRequest: () =>
	17	Effect.succeed({
	18	number: 42,
	19	title: "Add Bitbucket provider",
	20	url: "https://bitbucket.org/pingdotgg/t3code/pull-requests/42",
	21	baseRefName: "main",
	22	headRefName: "feature/source-control",
	23	state: "open",
	24	updatedAt: Option.none(),
	25	isCrossRepository: true,
	26	headRepositoryNameWithOwner: "fork/t3code",
	27	headRepositoryOwnerLogin: "fork",
	28	}),
	29	});
	30
	31	const changeRequest = yield* provider.getChangeRequest({
	32	cwd: "/repo",
	33	reference: "42",
	34	});
	35
	36	assert.deepStrictEqual(changeRequest, {
	37	provider: "bitbucket",
	38	number: 42,
	39	title: "Add Bitbucket provider",
	40	url: "https://bitbucket.org/pingdotgg/t3code/pull-requests/42",
	41	baseRefName: "main",
	42	headRefName: "feature/source-control",
	43	state: "open",
	44	updatedAt: Option.none(),
	45	isCrossRepository: true,
	46	headRepositoryNameWithOwner: "fork/t3code",
	47	headRepositoryOwnerLogin: "fork",
	48	});
	49	}),
	50	);
	51
	52	it.effect("lists Bitbucket PRs through provider-neutral input names", () =>
	53	Effect.gen(function* () {
	54	let listInput: Parameters<BitbucketApi.BitbucketApiShape["listPullRequests"]>[0] \| null = null;
	55	const provider = yield* makeProvider({
	56	listPullRequests: (input) => {
	57	listInput = input;
	58	return Effect.succeed([]);
	59	},
	60	});
	61
	62	yield* provider.listChangeRequests({
	63	cwd: "/repo",
	64	headSelector: "feature/provider",
	65	state: "all",
	66	limit: 10,
	67	});
	68
	69	assert.deepStrictEqual(listInput, {
	70	cwd: "/repo",
	71	headSelector: "feature/provider",
	72	state: "all",
	73	limit: 10,
	74	});
	75	}),
	76	);
	77
	78	it.effect("creates Bitbucket PRs through provider-neutral input names", () =>
	79	Effect.gen(function* () {
	80	let createInput: Parameters<BitbucketApi.BitbucketApiShape["createPullRequest"]>[0] \| null =
	81	null;
	82	const provider = yield* makeProvider({
	83	createPullRequest: (input) => {
	84	createInput = input;
	85	return Effect.void;
	86	},
	87	});
	88
	89	yield* provider.createChangeRequest({
	90	cwd: "/repo",
	91	baseRefName: "main",
	92	headSelector: "owner:feature/provider",
	93	title: "Provider PR",
	94	bodyFile: "/tmp/body.md",
	95	});
	96
	97	assert.deepStrictEqual(createInput, {
	98	cwd: "/repo",
	99	baseBranch: "main",
	100	headSelector: "owner:feature/provider",
	101	source: {
	102	owner: "owner",
	103	refName: "feature/provider",
	104	},
	105	title: "Provider PR",
	106	bodyFile: "/tmp/body.md",
	107	});
	108	}),
	109	);
	110
	111	it.effect("uses Bitbucket API repository detection for default branch lookup", () =>
	112	Effect.gen(function* () {
	113	let cwdInput: string \| null = null;
	114	const provider = yield* makeProvider({
	115	getDefaultBranch: (input) => {
	116	cwdInput = input.cwd;
	117	return Effect.succeed("main");
	118	},
	119	});
	120
	121	const defaultBranch = yield* provider.getDefaultBranch({ cwd: "/repo" });
	122
	123	assert.strictEqual(defaultBranch, "main");
	124	assert.strictEqual(cwdInput, "/repo");
	125	}),
	126	);

apps/server/src/sourceControl/BitbucketSourceControlProvider.ts+126−0

@@ -0,0 +1,126 @@
	1	import { Effect, Layer, Option } from "effect";
	2	import { SourceControlProviderError, type ChangeRequest } from "@t3tools/contracts";
	3
	4	import * as BitbucketApi from "./BitbucketApi.ts";
	5	import * as BitbucketPullRequests from "./bitbucketPullRequests.ts";
	6	import * as SourceControlProvider from "./SourceControlProvider.ts";
	7	import type * as SourceControlProviderDiscovery from "./SourceControlProviderDiscovery.ts";
	8
	9	function providerError(
	10	operation: string,
	11	cause: BitbucketApi.BitbucketApiError,
	12	): SourceControlProviderError {
	13	return new SourceControlProviderError({
	14	provider: "bitbucket",
	15	operation,
	16	detail: cause.detail,
	17	cause,
	18	});
	19	}
	20
	21	function toChangeRequest(
	22	summary: BitbucketPullRequests.NormalizedBitbucketPullRequestRecord,
	23	): ChangeRequest {
	24	return {
	25	provider: "bitbucket",
	26	number: summary.number,
	27	title: summary.title,
	28	url: summary.url,
	29	baseRefName: summary.baseRefName,
	30	headRefName: summary.headRefName,
	31	state: summary.state,
	32	updatedAt: summary.updatedAt ?? Option.none(),
	33	...(summary.isCrossRepository !== undefined
	34	? { isCrossRepository: summary.isCrossRepository }
	35	: {}),
	36	...(summary.headRepositoryNameWithOwner !== undefined
	37	? { headRepositoryNameWithOwner: summary.headRepositoryNameWithOwner }
	38	: {}),
	39	...(summary.headRepositoryOwnerLogin !== undefined
	40	? { headRepositoryOwnerLogin: summary.headRepositoryOwnerLogin }
	41	: {}),
	42	};
	43	}
	44
	45	export const make = Effect.fn("makeBitbucketSourceControlProvider")(function* () {
	46	const bitbucket = yield* BitbucketApi.BitbucketApi;
	47
	48	return SourceControlProvider.SourceControlProvider.of({
	49	kind: "bitbucket",
	50	listChangeRequests: (input) => {
	51	const source = SourceControlProvider.sourceControlRefFromInput(input);
	52	return bitbucket
	53	.listPullRequests({
	54	cwd: input.cwd,
	55	...(input.context ? { context: input.context } : {}),
	56	headSelector: input.headSelector,
	57	...(source ? { source } : {}),
	58	state: input.state,
	59	...(input.limit !== undefined ? { limit: input.limit } : {}),
	60	})
	61	.pipe(
	62	Effect.map((items) => items.map(toChangeRequest)),
	63	Effect.mapError((error) => providerError("listChangeRequests", error)),
	64	);
	65	},
	66	getChangeRequest: (input) =>
	67	bitbucket.getPullRequest(input).pipe(
	68	Effect.map(toChangeRequest),
	69	Effect.mapError((error) => providerError("getChangeRequest", error)),
	70	),
	71	createChangeRequest: (input) => {
	72	const source = SourceControlProvider.sourceControlRefFromInput(input);
	73	return bitbucket
	74	.createPullRequest({
	75	cwd: input.cwd,
	76	...(input.context ? { context: input.context } : {}),
	77	baseBranch: input.baseRefName,
	78	headSelector: input.headSelector,
	79	...(source ? { source } : {}),
	80	...(input.target ? { target: input.target } : {}),
	81	title: input.title,
	82	bodyFile: input.bodyFile,
	83	})
	84	.pipe(Effect.mapError((error) => providerError("createChangeRequest", error)));
	85	},
	86	getRepositoryCloneUrls: (input) =>
	87	bitbucket
	88	.getRepositoryCloneUrls(input)
	89	.pipe(Effect.mapError((error) => providerError("getRepositoryCloneUrls", error))),
	90	createRepository: (input) =>
	91	bitbucket
	92	.createRepository(input)
	93	.pipe(Effect.mapError((error) => providerError("createRepository", error))),
	94	getDefaultBranch: (input) =>
	95	bitbucket
	96	.getDefaultBranch({
	97	cwd: input.cwd,
	98	...(input.context ? { context: input.context } : {}),
	99	})
	100	.pipe(Effect.mapError((error) => providerError("getDefaultBranch", error))),
	101	checkoutChangeRequest: (input) =>
	102	bitbucket
	103	.checkoutPullRequest({
	104	cwd: input.cwd,
	105	...(input.context ? { context: input.context } : {}),
	106	reference: input.reference,
	107	...(input.force !== undefined ? { force: input.force } : {}),
	108	})
	109	.pipe(Effect.mapError((error) => providerError("checkoutChangeRequest", error))),
	110	});
	111	});
	112
	113	export const layer = Layer.effect(SourceControlProvider.SourceControlProvider, make());
	114
	115	export const makeDiscovery = Effect.fn("makeBitbucketSourceControlProviderDiscovery")(function* () {
	116	const bitbucket = yield* BitbucketApi.BitbucketApi;
	117
	118	return {
	119	type: "api",
	120	kind: "bitbucket",
	121	label: "Bitbucket",
	122	installHint:
	123	"Set T3CODE_BITBUCKET_EMAIL and T3CODE_BITBUCKET_API_TOKEN on the server (use a Bitbucket API token with pull request and repository scopes).",
	124	probeAuth: bitbucket.probeAuth,
	125	} satisfies SourceControlProviderDiscovery.SourceControlApiDiscoverySpec;
	126	});

apps/server/src/sourceControl/GitHubCli.test.ts+5−6

-import { assert, it } from "@effect/vitest";
+import { assert, it, afterEach, describe, expect, vi } from "@effect/vitest";
 import { Effect, Layer } from "effect";
 import { ChildProcessSpawner } from "effect/unstable/process";
 import { VcsProcessExitError, type VcsError } from "@t3tools/contracts";
-import { afterEach, describe, expect, vi } from "vitest";
-import { VcsProcess, type VcsProcessInput, type VcsProcessOutput } from "../vcs/VcsProcess.ts";
+import * as VcsProcess from "../vcs/VcsProcess.ts";
 import * as GitHubCli from "./GitHubCli.ts";
-const processOutput = (stdout: string): VcsProcessOutput => ({
+const processOutput = (stdout: string): VcsProcess.VcsProcessOutput => ({
   exitCode: ChildProcessSpawner.ExitCode(0),
   stdout,
   stderr: "",
   stderrTruncated: false,
 });
-const mockRun = vi.fn<(input: VcsProcessInput) => Effect.Effect<VcsProcessOutput, VcsError>>();
+const mockRun = vi.fn<VcsProcess.VcsProcessShape["run"]>();
 const layer = GitHubCli.layer.pipe(
   Layer.provide(
-    Layer.mock(VcsProcess)({
+    Layer.mock(VcsProcess.VcsProcess)({
       run: mockRun,
     }),
   ),

apps/server/src/sourceControl/GitHubCli.ts+8−12

   type VcsError,
 } from "@t3tools/contracts";
-import { VcsProcess, type VcsProcessOutput } from "../vcs/VcsProcess.ts";
+import * as VcsProcess from "../vcs/VcsProcess.ts";
-import {
+import * as GitHubPullRequests from "./gitHubPullRequests.ts";
-  decodeGitHubPullRequestJson,
-  decodeGitHubPullRequestListJson,
-  formatGitHubJsonDecodeError,
-} from "./gitHubPullRequests.ts";
 const DEFAULT_TIMEOUT_MS = 30_000;
     readonly cwd: string;
     readonly args: ReadonlyArray<string>;
     readonly timeoutMs?: number;
-  }) => Effect.Effect<VcsProcessOutput, GitHubCliError>;
+  }) => Effect.Effect<VcsProcess.VcsProcessOutput, GitHubCliError>;
   readonly listOpenPullRequests: (input: {
     readonly cwd: string;
 }
 export const make = Effect.fn("makeGitHubCli")(function* () {
-  const process = yield* VcsProcess;
+  const process = yield* VcsProcess.VcsProcess;
   const execute: GitHubCliShape["execute"] = (input) =>
     process
         Effect.flatMap((raw) =>
           raw.length === 0
             ? Effect.succeed([])
-            : Effect.sync(() => decodeGitHubPullRequestListJson(raw)).pipe(
+            : Effect.sync(() => GitHubPullRequests.decodeGitHubPullRequestListJson(raw)).pipe(
                 Effect.flatMap((decoded) => {
                   if (!Result.isSuccess(decoded)) {
                     return Effect.fail(
                       new GitHubCliError({
                         operation: "listOpenPullRequests",
-                        detail: `GitHub CLI returned invalid PR list JSON: ${formatGitHubJsonDecodeError(decoded.failure)}`,
+                        detail: `GitHub CLI returned invalid PR list JSON: ${GitHubPullRequests.formatGitHubJsonDecodeError(decoded.failure)}`,
                         cause: decoded.failure,
                       }),
                     );
       }).pipe(
         Effect.map((result) => result.stdout.trim()),
         Effect.flatMap((raw) =>
-          Effect.sync(() => decodeGitHubPullRequestJson(raw)).pipe(
+          Effect.sync(() => GitHubPullRequests.decodeGitHubPullRequestJson(raw)).pipe(
             Effect.flatMap((decoded) => {
               if (!Result.isSuccess(decoded)) {
                 return Effect.fail(
                   new GitHubCliError({
                     operation: "getPullRequest",
-                    detail: `GitHub CLI returned invalid pull request JSON: ${formatGitHubJsonDecodeError(decoded.failure)}`,
+                    detail: `GitHub CLI returned invalid pull request JSON: ${GitHubPullRequests.formatGitHubJsonDecodeError(decoded.failure)}`,
                     cause: decoded.failure,
                   }),
                 );

apps/server/src/sourceControl/GitHubSourceControlProvider.test.ts+8−6

 import { DateTime, Effect, Layer, Option } from "effect";
 import { ChildProcessSpawner } from "effect/unstable/process";
-import { GitHubCli, type GitHubCliShape } from "./GitHubCli.ts";
+import * as VcsProcess from "../vcs/VcsProcess.ts";
-import type { VcsProcessOutput } from "../vcs/VcsProcess.ts";
+import * as GitHubCli from "./GitHubCli.ts";
 import * as GitHubSourceControlProvider from "./GitHubSourceControlProvider.ts";
-const processResult = (stdout: string): VcsProcessOutput => ({
+const processResult = (stdout: string): VcsProcess.VcsProcessOutput => ({
   exitCode: ChildProcessSpawner.ExitCode(0),
   stdout,
   stderr: "",
   stderrTruncated: false,
 });
-function makeProvider(github: Partial<GitHubCliShape>) {
+function makeProvider(github: Partial<GitHubCli.GitHubCliShape>) {
-  return GitHubSourceControlProvider.make().pipe(Effect.provide(Layer.mock(GitHubCli)(github)));
+  return GitHubSourceControlProvider.make().pipe(
+    Effect.provide(Layer.mock(GitHubCli.GitHubCli)(github)),
+  );
 }
 it.effect("maps GitHub PR summaries into provider-neutral change requests", () =>
 it.effect("creates GitHub PRs through provider-neutral input names", () =>
   Effect.gen(function* () {
-    let createInput: Parameters<GitHubCliShape["createPullRequest"]>[0] | null = null;
+    let createInput: Parameters<GitHubCli.GitHubCliShape["createPullRequest"]>[0] | null = null;
     const provider = yield* makeProvider({
       createPullRequest: (input) => {
         createInput = input;

apps/server/src/sourceControl/GitHubSourceControlProvider.ts+115−67

@@ -5,11 +5,15 @@ import { · 4 unmodified lines
5	type ChangeRequestState,	5	type ChangeRequestState,
6	} from "@t3tools/contracts";	6	} from "@t3tools/contracts";
7		7
8	import { GitHubCli, type GitHubCliError, type GitHubPullRequestSummary } from "./GitHubCli.ts";	8	import * as GitHubCli from "./GitHubCli.ts";
9	import { decodeGitHubPullRequestListJson } from "./gitHubPullRequests.ts";	9	import * as GitHubPullRequests from "./gitHubPullRequests.ts";
10	import { SourceControlProvider, type SourceControlProviderShape } from "./SourceControlProvider.ts";	10	import * as SourceControlProvider from "./SourceControlProvider.ts";
		11	import * as SourceControlProviderDiscovery from "./SourceControlProviderDiscovery.ts";
11		12
12	function providerError(operation: string, cause: GitHubCliError): SourceControlProviderError {	13	function providerError(
		14	operation: string,
		15	cause: GitHubCli.GitHubCliError,
		16	): SourceControlProviderError {
13	return new SourceControlProviderError({	17	return new SourceControlProviderError({
14	provider: "github",	18	provider: "github",
15	operation,	19	operation,
@@ -18,7 +22,7 @@ function providerError(operation: string, cause: GitHubCliError): SourceControlP · 2 unmodified lines
18	});	22	});
19	}	23	}
20		24
21	function toChangeRequest(summary: GitHubPullRequestSummary): ChangeRequest {	25	function toChangeRequest(summary: GitHubCli.GitHubPullRequestSummary): ChangeRequest {
22	return {	26	return {
23	provider: "github",	27	provider: "github",
24	number: summary.number,	28	number: summary.number,
@@ -40,75 +44,119 @@ function toChangeRequest(summary: GitHubPullRequestSummary): ChangeRequest { · 15 unmodified lines
40	};	44	};
41	}	45	}
42		46
		47	function parseGitHubAuth(input: SourceControlProviderDiscovery.SourceControlAuthProbeInput) {
		48	const output = SourceControlProviderDiscovery.combinedAuthOutput(input);
		49	const account = SourceControlProviderDiscovery.matchFirst(output, [
		50	/Logged in to .* account\s+([^\s(]+)/iu,
		51	/Logged in to .* as\s+([^\s(]+)/iu,
		52	]);
		53	const host = SourceControlProviderDiscovery.parseCliHost(output);
		54
		55	if (input.exitCode !== 0) {
		56	return SourceControlProviderDiscovery.providerAuth({
		57	status: "unauthenticated",
		58	host,
		59	detail:
		60	SourceControlProviderDiscovery.firstSafeAuthLine(output) ??
		61	"Run `gh auth login` to authenticate GitHub CLI.",
		62	});
		63	}
		64
		65	if (account) {
		66	return SourceControlProviderDiscovery.providerAuth({ status: "authenticated", account, host });
		67	}
		68
		69	return SourceControlProviderDiscovery.providerAuth({
		70	status: "unknown",
		71	host,
		72	detail:
		73	SourceControlProviderDiscovery.firstSafeAuthLine(output) ??
		74	"GitHub CLI auth status could not be parsed.",
		75	});
		76	}
		77
		78	export const discovery = {
		79	type: "cli",
		80	kind: "github",
		81	label: "GitHub",
		82	executable: "gh",
		83	versionArgs: ["--version"],
		84	authArgs: ["auth", "status"],
		85	parseAuth: parseGitHubAuth,
		86	installHint:
		87	"Install the GitHub command-line tool (`gh`) via https://cli.github.com/ or your package manager (for example `brew install gh`).",
		88	} satisfies SourceControlProviderDiscovery.SourceControlCliDiscoverySpec;
		89
43	export const make = Effect.fn("makeGitHubSourceControlProvider")(function* () {	90	export const make = Effect.fn("makeGitHubSourceControlProvider")(function* () {
44	const github = yield* GitHubCli;	91	const github = yield* GitHubCli.GitHubCli;
45		92
46	const listChangeRequests: SourceControlProviderShape["listChangeRequests"] = (input) => {	93	const listChangeRequests: SourceControlProvider.SourceControlProviderShape["listChangeRequests"] =
47	if (input.state === "open") {	94	(input) => {
		95	if (input.state === "open") {
		96	return github
		97	.listOpenPullRequests({
		98	cwd: input.cwd,
		99	headSelector: input.headSelector,
		100	...(input.limit !== undefined ? { limit: input.limit } : {}),
		101	})
		102	.pipe(
		103	Effect.map((items) => items.map(toChangeRequest)),
		104	Effect.mapError((error) => providerError("listChangeRequests", error)),
		105	);
		106	}
		107
		108	const stateArg: ChangeRequestState \| "all" = input.state;
48	return github	109	return github
49	.listOpenPullRequests({	110	.execute({
50	cwd: input.cwd,	111	cwd: input.cwd,
51	headSelector: input.headSelector,	112	args: [
52	...(input.limit !== undefined ? { limit: input.limit } : {}),	113	"pr",
		114	"list",
		115	"--head",
		116	input.headSelector,
		117	"--state",
		118	stateArg,
		119	"--limit",
		120	String(input.limit ?? 20),
		121	"--json",
		122	"number,title,url,baseRefName,headRefName,state,mergedAt,updatedAt,isCrossRepository,headRepository,headRepositoryOwner",
		123	],
53	})	124	})
54	.pipe(	125	.pipe(
55	Effect.map((items) => items.map(toChangeRequest)),	126	Effect.flatMap((result) => {
56	Effect.mapError((error) => providerError("listChangeRequests", error)),	127	const raw = result.stdout.trim();
		128	if (raw.length === 0) {
		129	return Effect.succeed([]);
		130	}
		131	return Effect.sync(() => GitHubPullRequests.decodeGitHubPullRequestListJson(raw)).pipe(
		132	Effect.flatMap((decoded) =>
		133	Result.isSuccess(decoded)
		134	? Effect.succeed(
		135	decoded.success.map((item) => ({
		136	...toChangeRequest(item),
		137	updatedAt: item.updatedAt,
		138	})),
		139	)
		140	: Effect.fail(
		141	new SourceControlProviderError({
		142	provider: "github",
		143	operation: "listChangeRequests",
		144	detail: "GitHub CLI returned invalid change request JSON.",
		145	cause: decoded.failure,
		146	}),
		147	),
		148	),
		149	);
		150	}),
		151	Effect.mapError((error) =>
		152	Schema.is(SourceControlProviderError)(error)
		153	? error
		154	: providerError("listChangeRequests", error),
		155	),
57	);	156	);
58	}	157	};
59
60	const stateArg: ChangeRequestState \| "all" = input.state;
61	return github
62	.execute({
63	cwd: input.cwd,
64	args: [
65	"pr",
66	"list",
67	"--head",
68	input.headSelector,
69	"--state",
70	stateArg,
71	"--limit",
72	String(input.limit ?? 20),
73	"--json",
74	"number,title,url,baseRefName,headRefName,state,mergedAt,updatedAt,isCrossRepository,headRepository,headRepositoryOwner",
75	],
76	})
77	.pipe(
78	Effect.flatMap((result) => {
79	const raw = result.stdout.trim();
80	if (raw.length === 0) {
81	return Effect.succeed([]);
82	}
83	return Effect.sync(() => decodeGitHubPullRequestListJson(raw)).pipe(
84	Effect.flatMap((decoded) =>
85	Result.isSuccess(decoded)
86	? Effect.succeed(
87	decoded.success.map((item) => ({
88	...toChangeRequest(item),
89	updatedAt: item.updatedAt,
90	})),
91	)
92	: Effect.fail(
93	new SourceControlProviderError({
94	provider: "github",
95	operation: "listChangeRequests",
96	detail: "GitHub CLI returned invalid change request JSON.",
97	cause: decoded.failure,
98	}),
99	),
100	),
101	);
102	}),
103	Effect.mapError((error) =>
104	Schema.is(SourceControlProviderError)(error)
105	? error
106	: providerError("listChangeRequests", error),
107	),
108	);
109	};
110		158
111	return SourceControlProvider.of({	159	return SourceControlProvider.SourceControlProvider.of({
112	kind: "github",	160	kind: "github",
113	listChangeRequests,	161	listChangeRequests,
114	getChangeRequest: (input) =>	162	getChangeRequest: (input) =>
@@ -145,4 +193,4 @@ export const make = Effect.fn("makeGitHubSourceControlProvider")(function* () { · 30 unmodified lines
145	});	193	});
146	});	194	});
147		195
148	export const layer = Layer.effect(SourceControlProvider, make());	196	export const layer = Layer.effect(SourceControlProvider.SourceControlProvider, make());

apps/server/src/sourceControl/GitLabCli.test.ts+5−6

-import { assert, it } from "@effect/vitest";
+import { assert, it, afterEach, expect, vi } from "@effect/vitest";
 import { Effect, Layer } from "effect";
 import { ChildProcessSpawner } from "effect/unstable/process";
-import { afterEach, expect, vi } from "vitest";
 import { VcsProcessExitError } from "@t3tools/contracts";
-import { VcsProcess, type VcsProcessOutput, type VcsProcessShape } from "../vcs/VcsProcess.ts";
+import * as VcsProcess from "../vcs/VcsProcess.ts";
 import * as GitLabCli from "./GitLabCli.ts";
-const mockedRun = vi.fn<VcsProcessShape["run"]>();
+const mockedRun = vi.fn<VcsProcess.VcsProcessShape["run"]>();
 const layer = it.layer(
   GitLabCli.layer.pipe(
     Layer.provide(
-      Layer.mock(VcsProcess)({
+      Layer.mock(VcsProcess.VcsProcess)({
         run: mockedRun,
       }),
     ),
   ),
 );
-function processOutput(stdout: string): VcsProcessOutput {
+function processOutput(stdout: string): VcsProcess.VcsProcessOutput {
   return {
     exitCode: ChildProcessSpawner.ExitCode(0),
     stdout,

apps/server/src/sourceControl/GitLabCli.ts+16−18

 import { TrimmedNonEmptyString, type SourceControlRepositoryVisibility } from "@t3tools/contracts";
-import {
+import * as VcsProcess from "../vcs/VcsProcess.ts";
-  decodeGitLabMergeRequestJson,
+import * as GitLabMergeRequests from "./gitLabMergeRequests.ts";
-  decodeGitLabMergeRequestListJson,
+import type * as SourceControlProvider from "./SourceControlProvider.ts";
-  formatGitLabJsonDecodeError,
-} from "./gitLabMergeRequests.ts";
-import { VcsProcess, type VcsProcessOutput } from "../vcs/VcsProcess.ts";
-import type { SourceControlRefSelector } from "./SourceControlProvider.ts";
 const DEFAULT_TIMEOUT_MS = 30_000;
     readonly cwd: string;
     readonly args: ReadonlyArray<string>;
     readonly timeoutMs?: number;
-  }) => Effect.Effect<VcsProcessOutput, GitLabCliError>;
+  }) => Effect.Effect<VcsProcess.VcsProcessOutput, GitLabCliError>;
   readonly listMergeRequests: (input: {
     readonly cwd: string;
     readonly headSelector: string;
-    readonly source?: SourceControlRefSelector;
+    readonly source?: SourceControlProvider.SourceControlRefSelector;
     readonly state: "open" | "closed" | "merged" | "all";
     readonly limit?: number;
   }) => Effect.Effect<ReadonlyArray<GitLabMergeRequestSummary>, GitLabCliError>;
     readonly cwd: string;
     readonly baseBranch: string;
     readonly headSelector: string;
-    readonly source?: SourceControlRefSelector;
+    readonly source?: SourceControlProvider.SourceControlRefSelector;
-    readonly target?: SourceControlRefSelector;
+    readonly target?: SourceControlProvider.SourceControlRefSelector;
     readonly title: string;
     readonly bodyFile: string;
   }) => Effect.Effect<void, GitLabCliError>;
 function sourceRefName(input: {
   readonly headSelector: string;
-  readonly source?: SourceControlRefSelector;
+  readonly source?: SourceControlProvider.SourceControlRefSelector;
 }): string {
   return input.source?.refName ?? normalizeHeadSelector(input.headSelector);
 }
-function sourceProjectIdentifier(source: SourceControlRefSelector | undefined): string | null {
+function sourceProjectIdentifier(
+  source: SourceControlProvider.SourceControlRefSelector | undefined,
+): string | null {
   return source?.repository ?? source?.owner ?? null;
 }
 }
 export const make = Effect.fn("makeGitLabCli")(function* () {
-  const process = yield* VcsProcess;
+  const process = yield* VcsProcess.VcsProcess;
   const execute: GitLabCliShape["execute"] = (input) =>
     process
         Effect.flatMap((raw) =>
           raw.length === 0
             ? Effect.succeed([])
-            : Effect.sync(() => decodeGitLabMergeRequestListJson(raw)).pipe(
+            : Effect.sync(() => GitLabMergeRequests.decodeGitLabMergeRequestListJson(raw)).pipe(
                 Effect.flatMap((decoded) => {
                   if (!Result.isSuccess(decoded)) {
                     return Effect.fail(
                       new GitLabCliError({
                         operation: "listMergeRequests",
-                        detail: `GitLab CLI returned invalid MR list JSON: ${formatGitLabJsonDecodeError(decoded.failure)}`,
+                        detail: `GitLab CLI returned invalid MR list JSON: ${GitLabMergeRequests.formatGitLabJsonDecodeError(decoded.failure)}`,
                         cause: decoded.failure,
                       }),
                     );
       }).pipe(
         Effect.map((result) => result.stdout.trim()),
         Effect.flatMap((raw) =>
-          Effect.sync(() => decodeGitLabMergeRequestJson(raw)).pipe(
+          Effect.sync(() => GitLabMergeRequests.decodeGitLabMergeRequestJson(raw)).pipe(
             Effect.flatMap((decoded) => {
               if (!Result.isSuccess(decoded)) {
                 return Effect.fail(
                   new GitLabCliError({
                     operation: "getMergeRequest",
-                    detail: `GitLab CLI returned invalid merge request JSON: ${formatGitLabJsonDecodeError(decoded.failure)}`,
+                    detail: `GitLab CLI returned invalid merge request JSON: ${GitLabMergeRequests.formatGitLabJsonDecodeError(decoded.failure)}`,
                     cause: decoded.failure,
                   }),
                 );

apps/server/src/sourceControl/GitLabSourceControlProvider.test.ts+7−5

 import { assert, it } from "@effect/vitest";
 import { Effect, Layer, Option } from "effect";
-import { GitLabCli, type GitLabCliShape } from "./GitLabCli.ts";
+import * as GitLabCli from "./GitLabCli.ts";
 import * as GitLabSourceControlProvider from "./GitLabSourceControlProvider.ts";
-function makeProvider(gitlab: Partial<GitLabCliShape>) {
+function makeProvider(gitlab: Partial<GitLabCli.GitLabCliShape>) {
-  return GitLabSourceControlProvider.make().pipe(Effect.provide(Layer.mock(GitLabCli)(gitlab)));
+  return GitLabSourceControlProvider.make().pipe(
+    Effect.provide(Layer.mock(GitLabCli.GitLabCli)(gitlab)),
+  );
 }
 it.effect("maps GitLab MR summaries into provider-neutral change requests", () =>
 it.effect("lists GitLab MRs through provider-neutral input names", () =>
   Effect.gen(function* () {
-    let listInput: Parameters<GitLabCliShape["listMergeRequests"]>[0] | null = null;
+    let listInput: Parameters<GitLabCli.GitLabCliShape["listMergeRequests"]>[0] | null = null;
     const provider = yield* makeProvider({
       listMergeRequests: (input) => {
         listInput = input;
 it.effect("creates GitLab MRs through provider-neutral input names", () =>
   Effect.gen(function* () {
-    let createInput: Parameters<GitLabCliShape["createMergeRequest"]>[0] | null = null;
+    let createInput: Parameters<GitLabCli.GitLabCliShape["createMergeRequest"]>[0] | null = null;
     const provider = yield* makeProvider({
       createMergeRequest: (input) => {
         createInput = input;

apps/server/src/sourceControl/GitLabSourceControlProvider.ts+53−19

 import { Effect, Layer, Option } from "effect";
 import { SourceControlProviderError, type ChangeRequest } from "@t3tools/contracts";
-import { GitLabCli, type GitLabCliError, type GitLabMergeRequestSummary } from "./GitLabCli.ts";
+import * as GitLabCli from "./GitLabCli.ts";
-import { SourceControlProvider, type SourceControlRefSelector } from "./SourceControlProvider.ts";
+import * as SourceControlProvider from "./SourceControlProvider.ts";
+import * as SourceControlProviderDiscovery from "./SourceControlProviderDiscovery.ts";
-function providerError(operation: string, cause: GitLabCliError): SourceControlProviderError {
+function providerError(
+  operation: string,
+  cause: GitLabCli.GitLabCliError,
+): SourceControlProviderError {
   return new SourceControlProviderError({
     provider: "gitlab",
     operation,
   });
 }
-function toChangeRequest(summary: GitLabMergeRequestSummary): ChangeRequest {
+function toChangeRequest(summary: GitLabCli.GitLabMergeRequestSummary): ChangeRequest {
   return {
     provider: "gitlab",
     number: summary.number,
   };
 }
-function sourceFromInput(input: {
+function parseGitLabAuth(input: SourceControlProviderDiscovery.SourceControlAuthProbeInput) {
-  readonly headSelector: string;
+  const output = SourceControlProviderDiscovery.combinedAuthOutput(input);
-  readonly source?: SourceControlRefSelector;
+  const account = SourceControlProviderDiscovery.matchFirst(output, [
-}): SourceControlRefSelector | undefined {
+    /Logged in to .* as\s+([^\s(]+)/iu,
-  if (input.source) {
+    /Logged in to .* account\s+([^\s(]+)/iu,
-    return input.source;
+    /account:\s*([^\s(]+)/iu,
+  ]);
+  const host = SourceControlProviderDiscovery.parseCliHost(output);
+  if (input.exitCode !== 0) {
+    return SourceControlProviderDiscovery.providerAuth({
+      status: "unauthenticated",
+      host,
+      detail:
+        SourceControlProviderDiscovery.firstSafeAuthLine(output) ??
+        "Run `glab auth login` to authenticate GitLab CLI.",
+    });
+  }
+  if (account) {
+    return SourceControlProviderDiscovery.providerAuth({ status: "authenticated", account, host });
   }
-  const match = /^([^:/\s]+):(.+)$/u.exec(input.headSelector.trim());
+  return SourceControlProviderDiscovery.providerAuth({
-  const owner = match?.[1]?.trim();
+    status: "unknown",
-  const refName = match?.[2]?.trim();
+    host,
-  return owner && refName ? { owner, refName } : undefined;
+    detail:
+      SourceControlProviderDiscovery.firstSafeAuthLine(output) ??
+      "GitLab CLI auth status could not be parsed.",
+  });
 }
+export const discovery = {
+  type: "cli",
+  kind: "gitlab",
+  label: "GitLab",
+  executable: "glab",
+  versionArgs: ["--version"],
+  authArgs: ["auth", "status"],
+  parseAuth: parseGitLabAuth,
+  installHint:
+    "Install the GitLab command-line tool (`glab`) from https://gitlab.com/gitlab-org/cli or your package manager (for example `brew install glab`).",
+} satisfies SourceControlProviderDiscovery.SourceControlCliDiscoverySpec;
 export const make = Effect.fn("makeGitLabSourceControlProvider")(function* () {
-  const gitlab = yield* GitLabCli;
+  const gitlab = yield* GitLabCli.GitLabCli;
-  return SourceControlProvider.of({
+  return SourceControlProvider.SourceControlProvider.of({
     kind: "gitlab",
     listChangeRequests: (input) => {
-      const source = sourceFromInput(input);
+      const source = SourceControlProvider.sourceControlRefFromInput(input);
       return gitlab
         .listMergeRequests({
           cwd: input.cwd,
         Effect.mapError((error) => providerError("getChangeRequest", error)),
       ),
     createChangeRequest: (input) => {
-      const source = sourceFromInput(input);
+      const source = SourceControlProvider.sourceControlRefFromInput(input);
       return gitlab
         .createMergeRequest({
           cwd: input.cwd,
   });
 });
-export const layer = Layer.effect(SourceControlProvider, make());
+export const layer = Layer.effect(SourceControlProvider.SourceControlProvider, make());

apps/server/src/sourceControl/SourceControlDiscovery.test.ts+122−82

 import { VcsProcessSpawnError } from "@t3tools/contracts";
 import { ServerConfig } from "../config.ts";
+import * as VcsDriverRegistry from "../vcs/VcsDriverRegistry.ts";
 import * as VcsProcess from "../vcs/VcsProcess.ts";
-import { SourceControlDiscovery, layer } from "./SourceControlDiscovery.ts";
+import * as AzureDevOpsCli from "./AzureDevOpsCli.ts";
+import * as BitbucketApi from "./BitbucketApi.ts";
+import * as GitHubCli from "./GitHubCli.ts";
+import * as GitLabCli from "./GitLabCli.ts";
+import * as SourceControlDiscovery from "./SourceControlDiscovery.ts";
+import * as SourceControlProviderRegistry from "./SourceControlProviderRegistry.ts";
+const sourceControlProviderRegistryTestLayer = (input: {
+  readonly bitbucket: Partial<BitbucketApi.BitbucketApiShape>;
+  readonly process: Partial<VcsProcess.VcsProcessShape>;
+}) =>
+  SourceControlProviderRegistry.layer.pipe(
+    Layer.provide(
+      Layer.mergeAll(
+        ServerConfig.layerTest(process.cwd(), { prefix: "t3-source-control-registry-test-" }).pipe(
+          Layer.provide(NodeServices.layer),
+        ),
+        Layer.mock(AzureDevOpsCli.AzureDevOpsCli)({}),
+        Layer.mock(BitbucketApi.BitbucketApi)(input.bitbucket),
+        Layer.mock(GitHubCli.GitHubCli)({}),
+        Layer.mock(GitLabCli.GitLabCli)({}),
+        Layer.mock(VcsDriverRegistry.VcsDriverRegistry)({}),
+        Layer.mock(VcsProcess.VcsProcess)(input.process),
+      ),
+    ),
+  );
 const processOutput = (
   stdout: string,
   stderrTruncated: false,
 });
-it.effect("reports implemented tools separately from locally available CLIs", () => {
+it.effect("reports implemented tools separately from locally available executables", () => {
-  const testLayer = layer.pipe(
+  const processMock = {
-    Layer.provide(
+    run: (input: VcsProcess.VcsProcessInput) => {
-      ServerConfig.layerTest(process.cwd(), { prefix: "t3-source-control-discovery-" }),
+      if (input.command === "git") {
-    ),
+        return Effect.succeed(processOutput("git version 2.51.0\n"));
-    Layer.provide(
+      }
-      Layer.mock(VcsProcess.VcsProcess)({
+      if (input.command === "gh" && input.args[0] === "--version") {
-        run: (input) => {
+        return Effect.succeed(processOutput("gh version 2.83.0\n"));
-          if (input.command === "git") {
+      }
-            return Effect.succeed(processOutput("git version 2.51.0\n"));
+      if (input.command === "gh" && input.args.join(" ") === "auth status") {
-          }
+        return Effect.succeed(
-          if (input.command === "gh" && input.args[0] === "--version") {
+          processOutput(`github.com
-            return Effect.succeed(processOutput("gh version 2.83.0\n"));
-          }
-          if (input.command === "gh" && input.args.join(" ") === "auth status") {
-            return Effect.succeed(
-              processOutput(`github.com
 Logged in to github.com account juliusmarminge (keyring)
 - Active account: true
 - Git operations protocol: ssh
 - Token: gho_************************************
 - Token scopes: 'admin:public_key', 'gist', 'read:org', 'repo'
 `),
-            );
+        );
-          }
+      }
-          return Effect.fail(
+      return Effect.fail(
-            new VcsProcessSpawnError({
+        new VcsProcessSpawnError({
-              operation: input.operation,
+          operation: input.operation,
-              command: input.command,
+          command: input.command,
-              cwd: input.cwd,
+          cwd: input.cwd,
-              cause: new Error(`${input.command} not found`),
+          cause: new Error(`${input.command} not found`),
-            }),
+        }),
-          );
+      );
+    },
+  } satisfies Partial<VcsProcess.VcsProcessShape>;
+  const testLayer = SourceControlDiscovery.layer.pipe(
+    Layer.provide(
+      ServerConfig.layerTest(process.cwd(), { prefix: "t3-source-control-discovery-" }),
+    ),
+    Layer.provide(Layer.mock(VcsProcess.VcsProcess)(processMock)),
+    Layer.provide(
+      sourceControlProviderRegistryTestLayer({
+        process: processMock,
+        bitbucket: {
+          probeAuth: Effect.succeed({
+            status: "unauthenticated",
+            account: Option.none(),
+            host: Option.some("bitbucket.org"),
+            detail: Option.some(
+              "Set T3CODE_BITBUCKET_EMAIL and T3CODE_BITBUCKET_API_TOKEN, or T3CODE_BITBUCKET_ACCESS_TOKEN.",
+            ),
+          }),
         },
       }),
     ),
   );
   return Effect.gen(function* () {
-    const discovery = yield* SourceControlDiscovery;
+    const discovery = yield* SourceControlDiscovery.SourceControlDiscovery;
     const result = yield* discovery.discover;
     assert.deepStrictEqual(
     assert.deepStrictEqual(
       result.sourceControlProviders.map((item) => ({
         kind: item.kind,
-        implemented: item.implemented,
         status: item.status,
         auth: item.auth.status,
         account: item.auth.account,
       [
         {
           kind: "github",
-          implemented: true,
           status: "available",
           auth: "authenticated",
           account: Option.some("juliusmarminge"),
         },
         {
           kind: "gitlab",
-          implemented: true,
           status: "missing",
           auth: "unknown",
           account: Option.none(),
         },
         {
           kind: "azure-devops",
-          implemented: false,
           status: "missing",
           auth: "unknown",
           account: Option.none(),
         },
         {
           kind: "bitbucket",
-          implemented: false,
+          status: "available",
-          status: "missing",
+          auth: "unauthenticated",
-          auth: "unknown",
           account: Option.none(),
         },
       ],
     );
     const bitbucket = result.sourceControlProviders.find((item) => item.kind === "bitbucket");
     assert.ok(bitbucket);
-    assert.strictEqual("executable" in bitbucket, false);
+    assert.strictEqual(bitbucket.executable, undefined);
   }).pipe(Effect.provide(testLayer));
 });
 it.effect("probes provider authentication without exposing token details", () => {
-  const testLayer = layer.pipe(
+  const processMock = {
-    Layer.provide(
+    run: (input: VcsProcess.VcsProcessInput) => {
-      ServerConfig.layerTest(process.cwd(), { prefix: "t3-source-control-auth-discovery-" }),
+      if (input.args[0] === "--version") {
-    ),
+        return Effect.succeed(processOutput(`${input.command} version test\n`));
-    Layer.provide(
+      }
-      Layer.mock(VcsProcess.VcsProcess)({
+      if (input.command === "gh" && input.args.join(" ") === "auth status") {
-        run: (input) => {
+        return Effect.succeed(
-          if (input.args[0] === "--version") {
+          processOutput(`github.com
-            return Effect.succeed(processOutput(`${input.command} version test\n`));
-          }
-          if (input.command === "gh" && input.args.join(" ") === "auth status") {
-            return Effect.succeed(
-              processOutput(`github.com
 Logged in to github.com account octocat (keyring)
 - Token: gho_************************************
 - Token scopes: 'repo'
 `),
-            );
+        );
-          }
+      }
-          if (input.command === "glab" && input.args.join(" ") === "auth status") {
+      if (input.command === "glab" && input.args.join(" ") === "auth status") {
-            return Effect.succeed(
+        return Effect.succeed(
-              processOutput(`gitlab.com
+          processOutput(`gitlab.com
 Logged in to gitlab.com as gitlab-user
 `),
-            );
+        );
-          }
+      }
-          if (
+      if (
-            input.command === "az" &&
+        input.command === "az" &&
-            input.args.join(" ") === "account show --query user.name -o tsv"
+        input.args.join(" ") === "account show --query user.name -o tsv"
-          ) {
+      ) {
-            return Effect.succeed(processOutput("azure-user@example.com\n"));
+        return Effect.succeed(processOutput("azure-user@example.com\n"));
-          }
+      }
-          if (input.command === "bb" && input.args.join(" ") === "auth status") {
+      return Effect.fail(
-            return Effect.succeed(
+        new VcsProcessSpawnError({
-              processOutput(`bitbucket.org
+          operation: input.operation,
-Logged in as bitbucket-user
+          command: input.command,
-`),
+          cwd: input.cwd,
-            );
+          cause: new Error(`${input.command} not found`),
-          }
+        }),
-          return Effect.fail(
+      );
-            new VcsProcessSpawnError({
+    },
-              operation: input.operation,
+  } satisfies Partial<VcsProcess.VcsProcessShape>;
-              command: input.command,
+  const testLayer = SourceControlDiscovery.layer.pipe(
-              cwd: input.cwd,
+    Layer.provide(
-              cause: new Error(`${input.command} not found`),
+      ServerConfig.layerTest(process.cwd(), { prefix: "t3-source-control-auth-discovery-" }),
-            }),
+    ),
-          );
+    Layer.provide(Layer.mock(VcsProcess.VcsProcess)(processMock)),
+    Layer.provide(
+      sourceControlProviderRegistryTestLayer({
+        process: processMock,
+        bitbucket: {
+          probeAuth: Effect.succeed({
+            status: "authenticated",
+            account: Option.some("bitbucket-user"),
+            host: Option.some("bitbucket.org"),
+            detail: Option.none(),
+          }),
         },
       }),
     ),
   );
   return Effect.gen(function* () {
-    const discovery = yield* SourceControlDiscovery;
+    const discovery = yield* SourceControlDiscovery.SourceControlDiscovery;
     const result = yield* discovery.discover;
     assert.deepStrictEqual(
         },
         {
           kind: "bitbucket",
-          auth: "unknown",
+          auth: "authenticated",
-          account: Option.none(),
+          account: Option.some("bitbucket-user"),
-          detail: Option.some("Bitbucket provider support is not available yet."),
+          detail: Option.none(),
         },
       ],
     );

apps/server/src/sourceControl/SourceControlDiscovery.ts+10−272

@@ -1,8 +1,5 @@
1	import {	1	import {
2	type SourceControlProviderAuth,
3	type SourceControlDiscoveryResult,	2	type SourceControlDiscoveryResult,
4	type SourceControlProviderDiscoveryItem,
5	type SourceControlProviderKind,
6	type VcsDiscoveryItem,	3	type VcsDiscoveryItem,
7	type VcsDriverKind,	4	type VcsDriverKind,
8	} from "@t3tools/contracts";	5	} from "@t3tools/contracts";
@@ -10,6 +7,8 @@ import { Context, Effect, Layer, Option } from "effect"; · 1 unmodified line
10		7
11	import { ServerConfig } from "../config.ts";	8	import { ServerConfig } from "../config.ts";
12	import * as VcsProcess from "../vcs/VcsProcess.ts";	9	import * as VcsProcess from "../vcs/VcsProcess.ts";
		10	import * as SourceControlProviderDiscovery from "./SourceControlProviderDiscovery.ts";
		11	import * as SourceControlProviderRegistry from "./SourceControlProviderRegistry.ts";
13		12
14	interface DiscoveryProbe {	13	interface DiscoveryProbe {
15	readonly label: string;	14	readonly label: string;
@@ -25,18 +24,6 @@ type VcsProbe = DiscoveryProbe & { · 9 unmodified lines
25	readonly versionArgs: ReadonlyArray<string>;	24	readonly versionArgs: ReadonlyArray<string>;
26	};	25	};
27		26
28	type ProviderProbe = DiscoveryProbe & {
29	readonly kind: SourceControlProviderKind;
30	readonly authArgs?: ReadonlyArray<string>;
31	readonly parseAuth?: (input: AuthProbeInput) => SourceControlProviderAuth;
32	};
33
34	interface AuthProbeInput {
35	readonly stdout: string;
36	readonly stderr: string;
37	readonly exitCode: VcsProcess.VcsProcessOutput["exitCode"];
38	}
39
40	interface DiscoveryProbeResult<Kind extends string> {	27	interface DiscoveryProbeResult<Kind extends string> {
41	readonly kind: Kind;	28	readonly kind: Kind;
42	readonly label: string;	29	readonly label: string;
@@ -67,203 +54,6 @@ const VCS_PROBES: ReadonlyArray<VcsProbe> = [ · 24 unmodified lines
67	},	54	},
68	];	55	];
69		56
70	const SOURCE_CONTROL_PROVIDER_PROBES: ReadonlyArray<ProviderProbe> = [
71	{
72	kind: "github",
73	label: "GitHub",
74	executable: "gh",
75	versionArgs: ["--version"],
76	authArgs: ["auth", "status"],
77	parseAuth: parseGitHubAuth,
78	implemented: true,
79	installHint: "Install GitHub CLI with `brew install gh` or from https://cli.github.com/.",
80	},
81	{
82	kind: "gitlab",
83	label: "GitLab",
84	executable: "glab",
85	versionArgs: ["--version"],
86	authArgs: ["auth", "status"],
87	parseAuth: parseGitLabAuth,
88	implemented: true,
89	installHint:
90	"Install GitLab CLI with `brew install glab` or from https://gitlab.com/gitlab-org/cli.",
91	},
92	{
93	kind: "azure-devops",
94	label: "Azure DevOps",
95	executable: "az",
96	versionArgs: ["--version"],
97	authArgs: ["account", "show", "--query", "user.name", "-o", "tsv"],
98	parseAuth: parseAzureAuth,
99	implemented: false,
100	installHint:
101	"Install Azure CLI with `brew install azure-cli`, then add Azure DevOps support with `az extension add --name azure-devops`.",
102	},
103	{
104	kind: "bitbucket",
105	label: "Bitbucket",
106	implemented: false,
107	installHint: "Bitbucket provider support is not available yet.",
108	},
109	];
110
111	function firstNonEmptyLine(text: string): Option.Option<string> {
112	const line = text
113	.split(/\r?\n/)
114	.map((entry) => entry.trim())
115	.find((entry) => entry.length > 0);
116	return line === undefined ? Option.none() : Option.some(line);
117	}
118
119	function detailFromCause(cause: unknown): Option.Option<string> {
120	if (cause instanceof Error && cause.message.trim().length > 0) {
121	return Option.some(cause.message.trim());
122	}
123	return Option.none();
124	}
125
126	function authAccount(account: string \| undefined): Option.Option<string> {
127	const trimmed = account?.trim();
128	return trimmed === undefined \|\| trimmed.length === 0 ? Option.none() : Option.some(trimmed);
129	}
130
131	function authHost(host: string \| undefined): Option.Option<string> {
132	const trimmed = host?.trim();
133	return trimmed === undefined \|\| trimmed.length === 0 ? Option.none() : Option.some(trimmed);
134	}
135
136	function authDetail(detail: string \| undefined): Option.Option<string> {
137	const trimmed = detail?.trim();
138	return trimmed === undefined \|\| trimmed.length === 0 ? Option.none() : Option.some(trimmed);
139	}
140
141	function providerAuth(input: {
142	readonly status: SourceControlProviderAuth["status"];
143	readonly account?: string \| undefined;
144	readonly host?: string \| undefined;
145	readonly detail?: string \| undefined;
146	}): SourceControlProviderAuth {
147	return {
148	status: input.status,
149	account: authAccount(input.account),
150	host: authHost(input.host),
151	detail: authDetail(input.detail),
152	};
153	}
154
155	function unknownAuth(detail?: string): SourceControlProviderAuth {
156	return providerAuth({ status: "unknown", detail });
157	}
158
159	function combinedAuthOutput(input: AuthProbeInput): string {
160	return [input.stdout, input.stderr].filter((entry) => entry.trim().length > 0).join("\n");
161	}
162
163	function sanitizedAuthLines(text: string): ReadonlyArray<string> {
164	return text
165	.split(/\r?\n/)
166	.map((entry) => entry.trim())
167	.filter((entry) => entry.length > 0)
168	.filter((entry) => !/^[-\s]*token(?:\s+scopes?)?:/iu.test(entry));
169	}
170
171	function firstSafeAuthLine(text: string): string \| undefined {
172	return sanitizedAuthLines(text)[0];
173	}
174
175	function parseCliHost(text: string): string \| undefined {
176	return sanitizedAuthLines(text)
177	.map((line) => line.replace(/^[^a-z0-9]+/iu, ""))
178	.find((line) => /^[a-z0-9][a-z0-9.-]*(?::\d+)?$/iu.test(line));
179	}
180
181	function matchFirst(text: string, patterns: ReadonlyArray<RegExp>): string \| undefined {
182	for (const pattern of patterns) {
183	const match = pattern.exec(text);
184	const value = match?.[1]?.trim();
185	if (value && value.length > 0) return value;
186	}
187	return undefined;
188	}
189
190	function parseGitHubAuth(input: AuthProbeInput): SourceControlProviderAuth {
191	const output = combinedAuthOutput(input);
192	const account = matchFirst(output, [
193	/Logged in to .* account\s+([^\s(]+)/iu,
194	/Logged in to .* as\s+([^\s(]+)/iu,
195	]);
196	const host = parseCliHost(output);
197
198	if (input.exitCode !== 0) {
199	return providerAuth({
200	status: "unauthenticated",
201	host,
202	detail: firstSafeAuthLine(output) ?? "Run `gh auth login` to authenticate GitHub CLI.",
203	});
204	}
205
206	if (account) {
207	return providerAuth({ status: "authenticated", account, host });
208	}
209
210	return providerAuth({
211	status: "unknown",
212	host,
213	detail: firstSafeAuthLine(output) ?? "GitHub CLI auth status could not be parsed.",
214	});
215	}
216
217	function parseGitLabAuth(input: AuthProbeInput): SourceControlProviderAuth {
218	const output = combinedAuthOutput(input);
219	const account = matchFirst(output, [
220	/Logged in to .* as\s+([^\s(]+)/iu,
221	/Logged in to .* account\s+([^\s(]+)/iu,
222	/account:\s*([^\s(]+)/iu,
223	]);
224	const host = parseCliHost(output);
225
226	if (input.exitCode !== 0) {
227	return providerAuth({
228	status: "unauthenticated",
229	host,
230	detail: firstSafeAuthLine(output) ?? "Run `glab auth login` to authenticate GitLab CLI.",
231	});
232	}
233
234	if (account) {
235	return providerAuth({ status: "authenticated", account, host });
236	}
237
238	return providerAuth({
239	status: "unknown",
240	host,
241	detail: firstSafeAuthLine(output) ?? "GitLab CLI auth status could not be parsed.",
242	});
243	}
244
245	function parseAzureAuth(input: AuthProbeInput): SourceControlProviderAuth {
246	const account = input.stdout.trim().split(/\r?\n/)[0]?.trim();
247
248	if (input.exitCode !== 0) {
249	return providerAuth({
250	status: "unauthenticated",
251	detail:
252	firstSafeAuthLine(combinedAuthOutput(input)) ?? "Run `az login` to authenticate Azure CLI.",
253	});
254	}
255
256	if (account && account.length > 0) {
257	return providerAuth({ status: "authenticated", account, host: "dev.azure.com" });
258	}
259
260	return providerAuth({
261	status: "unknown",
262	host: "dev.azure.com",
263	detail: "Azure CLI account status could not be parsed.",
264	});
265	}
266
267	export interface SourceControlDiscoveryShape {	57	export interface SourceControlDiscoveryShape {
268	readonly discover: Effect.Effect<SourceControlDiscoveryResult>;	58	readonly discover: Effect.Effect<SourceControlDiscoveryResult>;
269	}	59	}
@@ -278,8 +68,10 @@ export const layer = Layer.effect( · 8 unmodified lines
278	Effect.gen(function* () {	68	Effect.gen(function* () {
279	const config = yield* ServerConfig;	69	const config = yield* ServerConfig;
280	const process = yield* VcsProcess.VcsProcess;	70	const process = yield* VcsProcess.VcsProcess;
		71	const sourceControlProviders =
		72	yield* SourceControlProviderRegistry.SourceControlProviderRegistry;
281		73
282	const probe = <Kind extends VcsDriverKind \| SourceControlProviderKind>(	74	const probe = <Kind extends VcsDriverKind>(
283	input: DiscoveryProbe & { readonly kind: Kind },	75	input: DiscoveryProbe & { readonly kind: Kind },
284	): Effect.Effect<DiscoveryProbeResult<Kind>> => {	76	): Effect.Effect<DiscoveryProbeResult<Kind>> => {
285	const executable = input.executable;	77	const executable = input.executable;
@@ -316,8 +108,9 @@ export const layer = Layer.effect( · 30 unmodified lines
316	executable,	108	executable,
317	implemented: input.implemented,	109	implemented: input.implemented,
318	status: "available" as const,	110	status: "available" as const,
319	version: Option.orElse(firstNonEmptyLine(result.stdout), () =>	111	version: Option.orElse(
320	firstNonEmptyLine(result.stderr),	112	SourceControlProviderDiscovery.firstNonEmptyLine(result.stdout),
		113	() => SourceControlProviderDiscovery.firstNonEmptyLine(result.stderr),
321	),	114	),
322	installHint: input.installHint,	115	installHint: input.installHint,
323	detail: Option.none<string>(),	116	detail: Option.none<string>(),
@@ -332,74 +125,19 @@ export const layer = Layer.effect( · 8 unmodified lines
332	status: "missing" as const,	125	status: "missing" as const,
333	version: Option.none<string>(),	126	version: Option.none<string>(),
334	installHint: input.installHint,	127	installHint: input.installHint,
335	detail: detailFromCause(cause),	128	detail: SourceControlProviderDiscovery.detailFromCause(cause),
336	} satisfies DiscoveryProbeResult<Kind>),	129	} satisfies DiscoveryProbeResult<Kind>),
337	),	130	),
338	);	131	);
339	};	132	};
340		133
341	const probeProvider = (input: ProviderProbe) =>
342	probe(input).pipe(
343	Effect.flatMap((item) => {
344	const executable = input.executable;
345	const authArgs = input.authArgs;
346	const parseAuth = input.parseAuth;
347
348	if (!executable \|\| !authArgs \|\| !parseAuth) {
349	return Effect.succeed({
350	...item,
351	auth: unknownAuth(input.installHint),
352	} satisfies SourceControlProviderDiscoveryItem);
353	}
354
355	if (item.status !== "available") {
356	return Effect.succeed({
357	...item,
358	auth: unknownAuth("CLI is not installed."),
359	} satisfies SourceControlProviderDiscoveryItem);
360	}
361
362	return process
363	.run({
364	operation: "source-control.discovery.auth",
365	command: executable,
366	args: authArgs,
367	cwd: config.cwd,
368	allowNonZeroExit: true,
369	timeoutMs: 5_000,
370	maxOutputBytes: 8_000,
371	truncateOutputAtMaxBytes: true,
372	})
373	.pipe(
374	Effect.map(
375	(result) =>
376	({
377	...item,
378	auth: parseAuth(result),
379	}) satisfies SourceControlProviderDiscoveryItem,
380	),
381	Effect.catch((cause) =>
382	Effect.succeed({
383	...item,
384	auth: unknownAuth(Option.getOrUndefined(detailFromCause(cause))),
385	} satisfies SourceControlProviderDiscoveryItem),
386	),
387	);
388	}),
389	);
390
391	return SourceControlDiscovery.of({	134	return SourceControlDiscovery.of({
392	discover: Effect.all({	135	discover: Effect.all({
393	versionControlSystems: Effect.all(	136	versionControlSystems: Effect.all(
394	VCS_PROBES.map((entry) => probe(entry)) as ReadonlyArray<Effect.Effect<VcsDiscoveryItem>>,	137	VCS_PROBES.map((entry) => probe(entry)) as ReadonlyArray<Effect.Effect<VcsDiscoveryItem>>,
395	{ concurrency: "unbounded" },	138	{ concurrency: "unbounded" },
396	),	139	),
397	sourceControlProviders: Effect.all(	140	sourceControlProviders: sourceControlProviders.discover,
398	SOURCE_CONTROL_PROVIDER_PROBES.map((entry) => probeProvider(entry)) as ReadonlyArray<
399	Effect.Effect<SourceControlProviderDiscoveryItem>
400	>,
401	{ concurrency: "unbounded" },
402	),
403	}),	141	}),
404	});	142	});
405	}),	143	}),

apps/server/src/sourceControl/SourceControlProvider.ts+27−0

@@ -21,6 +21,33 @@ export interface SourceControlRefSelector { · 20 unmodified lines
21	readonly repository?: string;	21	readonly repository?: string;
22	}	22	}
23		23
		24	export function parseSourceControlOwnerRef(
		25	headSelector: string,
		26	): SourceControlRefSelector \| undefined {
		27	const match = /^([^:/\s]+):(.+)$/u.exec(headSelector.trim());
		28	const owner = match?.[1]?.trim();
		29	const refName = match?.[2]?.trim();
		30	return owner && refName ? { owner, refName } : undefined;
		31	}
		32
		33	export function normalizeSourceBranch(headSelector: string): string {
		34	return parseSourceControlOwnerRef(headSelector)?.refName ?? headSelector.trim();
		35	}
		36
		37	export function sourceBranch(input: {
		38	readonly headSelector: string;
		39	readonly source?: SourceControlRefSelector;
		40	}): string {
		41	return input.source?.refName ?? normalizeSourceBranch(input.headSelector);
		42	}
		43
		44	export function sourceControlRefFromInput(input: {
		45	readonly headSelector: string;
		46	readonly source?: SourceControlRefSelector;
		47	}): SourceControlRefSelector \| undefined {
		48	return input.source ?? parseSourceControlOwnerRef(input.headSelector);
		49	}
		50
24	export interface SourceControlProviderShape {	51	export interface SourceControlProviderShape {
25	readonly kind: SourceControlProviderKind;	52	readonly kind: SourceControlProviderKind;
26	readonly listChangeRequests: (input: {	53	readonly listChangeRequests: (input: {

apps/server/src/sourceControl/SourceControlProviderDiscovery.ts+237−0

@@ -0,0 +1,237 @@
	1	import type {
	2	SourceControlProviderAuth,
	3	SourceControlProviderDiscoveryItem,
	4	SourceControlProviderKind,
	5	} from "@t3tools/contracts";
	6	import { Effect, Option } from "effect";
	7
	8	import type * as VcsProcess from "../vcs/VcsProcess.ts";
	9
	10	export interface SourceControlAuthProbeInput {
	11	readonly stdout: string;
	12	readonly stderr: string;
	13	readonly exitCode: VcsProcess.VcsProcessOutput["exitCode"];
	14	}
	15
	16	interface SourceControlDiscoverySpecBase {
	17	readonly kind: SourceControlProviderKind;
	18	readonly label: string;
	19	readonly installHint: string;
	20	}
	21
	22	export type SourceControlCliDiscoverySpec = SourceControlDiscoverySpecBase & {
	23	readonly type: "cli";
	24	readonly executable: string;
	25	readonly versionArgs: ReadonlyArray<string>;
	26	readonly authArgs: ReadonlyArray<string>;
	27	readonly parseAuth: (input: SourceControlAuthProbeInput) => SourceControlProviderAuth;
	28	};
	29
	30	export type SourceControlApiDiscoverySpec = SourceControlDiscoverySpecBase & {
	31	readonly type: "api";
	32	readonly probeAuth: Effect.Effect<SourceControlProviderAuth, never>;
	33	};
	34
	35	export type SourceControlProviderDiscoverySpec =
	36	\| SourceControlCliDiscoverySpec
	37	\| SourceControlApiDiscoverySpec;
	38
	39	interface DiscoveryProbeResult {
	40	readonly kind: SourceControlProviderKind;
	41	readonly label: string;
	42	readonly executable: string;
	43	readonly status: "available" \| "missing";
	44	readonly version: Option.Option<string>;
	45	readonly installHint: string;
	46	readonly detail: Option.Option<string>;
	47	}
	48
	49	export function firstNonEmptyLine(text: string): Option.Option<string> {
	50	const line = text
	51	.split(/\r?\n/)
	52	.map((entry) => entry.trim())
	53	.find((entry) => entry.length > 0);
	54	return line === undefined ? Option.none() : Option.some(line);
	55	}
	56
	57	export function detailFromCause(cause: unknown): Option.Option<string> {
	58	if (cause instanceof Error && cause.message.trim().length > 0) {
	59	return Option.some(cause.message.trim());
	60	}
	61	return Option.none();
	62	}
	63
	64	function authAccount(account: string \| undefined): Option.Option<string> {
	65	const trimmed = account?.trim();
	66	return trimmed === undefined \|\| trimmed.length === 0 ? Option.none() : Option.some(trimmed);
	67	}
	68
	69	function authHost(host: string \| undefined): Option.Option<string> {
	70	const trimmed = host?.trim();
	71	return trimmed === undefined \|\| trimmed.length === 0 ? Option.none() : Option.some(trimmed);
	72	}
	73
	74	function authDetail(detail: string \| undefined): Option.Option<string> {
	75	const trimmed = detail?.trim();
	76	return trimmed === undefined \|\| trimmed.length === 0 ? Option.none() : Option.some(trimmed);
	77	}
	78
	79	export function providerAuth(input: {
	80	readonly status: SourceControlProviderAuth["status"];
	81	readonly account?: string \| undefined;
	82	readonly host?: string \| undefined;
	83	readonly detail?: string \| undefined;
	84	}): SourceControlProviderAuth {
	85	return {
	86	status: input.status,
	87	account: authAccount(input.account),
	88	host: authHost(input.host),
	89	detail: authDetail(input.detail),
	90	};
	91	}
	92
	93	export function unknownAuth(detail?: string): SourceControlProviderAuth {
	94	return providerAuth({ status: "unknown", detail });
	95	}
	96
	97	export function combinedAuthOutput(input: SourceControlAuthProbeInput): string {
	98	return [input.stdout, input.stderr].filter((entry) => entry.trim().length > 0).join("\n");
	99	}
	100
	101	function sanitizedAuthLines(text: string): ReadonlyArray<string> {
	102	return text
	103	.split(/\r?\n/)
	104	.map((entry) => entry.trim())
	105	.filter((entry) => entry.length > 0)
	106	.filter((entry) => !/^[-\s]*token(?:\s+scopes?)?:/iu.test(entry));
	107	}
	108
	109	export function firstSafeAuthLine(text: string): string \| undefined {
	110	return sanitizedAuthLines(text)[0];
	111	}
	112
	113	export function parseCliHost(text: string): string \| undefined {
	114	return sanitizedAuthLines(text)
	115	.map((line) => line.replace(/^[^a-z0-9]+/iu, ""))
	116	.find((line) => /^[a-z0-9][a-z0-9.-]*(?::\d+)?$/iu.test(line));
	117	}
	118
	119	export function matchFirst(text: string, patterns: ReadonlyArray<RegExp>): string \| undefined {
	120	for (const pattern of patterns) {
	121	const match = pattern.exec(text);
	122	const value = match?.[1]?.trim();
	123	if (value && value.length > 0) return value;
	124	}
	125	return undefined;
	126	}
	127
	128	function probeCli(input: {
	129	readonly spec: SourceControlCliDiscoverySpec;
	130	readonly process: VcsProcess.VcsProcessShape;
	131	readonly cwd: string;
	132	}): Effect.Effect<DiscoveryProbeResult> {
	133	return input.process
	134	.run({
	135	operation: "source-control.discovery.probe",
	136	command: input.spec.executable,
	137	args: input.spec.versionArgs,
	138	cwd: input.cwd,
	139	timeoutMs: 5_000,
	140	maxOutputBytes: 8_000,
	141	truncateOutputAtMaxBytes: true,
	142	})
	143	.pipe(
	144	Effect.map(
	145	(result) =>
	146	({
	147	kind: input.spec.kind,
	148	label: input.spec.label,
	149	executable: input.spec.executable,
	150	status: "available" as const,
	151	version: Option.orElse(firstNonEmptyLine(result.stdout), () =>
	152	firstNonEmptyLine(result.stderr),
	153	),
	154	installHint: input.spec.installHint,
	155	detail: Option.none<string>(),
	156	}) satisfies DiscoveryProbeResult,
	157	),
	158	Effect.catch((cause) =>
	159	Effect.succeed({
	160	kind: input.spec.kind,
	161	label: input.spec.label,
	162	executable: input.spec.executable,
	163	status: "missing" as const,
	164	version: Option.none<string>(),
	165	installHint: input.spec.installHint,
	166	detail: detailFromCause(cause),
	167	} satisfies DiscoveryProbeResult),
	168	),
	169	);
	170	}
	171
	172	export function probeSourceControlProvider(input: {
	173	readonly spec: SourceControlProviderDiscoverySpec;
	174	readonly process: VcsProcess.VcsProcessShape;
	175	readonly cwd: string;
	176	}): Effect.Effect<SourceControlProviderDiscoveryItem> {
	177	if (input.spec.type === "api") {
	178	return input.spec.probeAuth.pipe(
	179	Effect.map(
	180	(auth) =>
	181	({
	182	kind: input.spec.kind,
	183	label: input.spec.label,
	184	status: "available" as const,
	185	version: Option.none<string>(),
	186	installHint: input.spec.installHint,
	187	detail: Option.none<string>(),
	188	auth,
	189	}) satisfies SourceControlProviderDiscoveryItem,
	190	),
	191	);
	192	}
	193
	194	const spec = input.spec;
	195
	196	return probeCli({
	197	spec,
	198	process: input.process,
	199	cwd: input.cwd,
	200	}).pipe(
	201	Effect.flatMap((item) => {
	202	if (item.status !== "available") {
	203	return Effect.succeed({
	204	...item,
	205	auth: unknownAuth("Hosting integration command was not found on the server PATH."),
	206	} satisfies SourceControlProviderDiscoveryItem);
	207	}
	208
	209	return input.process
	210	.run({
	211	operation: "source-control.discovery.auth",
	212	command: spec.executable,
	213	args: spec.authArgs,
	214	cwd: input.cwd,
	215	allowNonZeroExit: true,
	216	timeoutMs: 5_000,
	217	maxOutputBytes: 8_000,
	218	truncateOutputAtMaxBytes: true,
	219	})
	220	.pipe(
	221	Effect.map(
	222	(result) =>
	223	({
	224	...item,
	225	auth: spec.parseAuth(result),
	226	}) satisfies SourceControlProviderDiscoveryItem,
	227	),
	228	Effect.catch((cause) =>
	229	Effect.succeed({
	230	...item,
	231	auth: unknownAuth(Option.getOrUndefined(detailFromCause(cause))),
	232	} satisfies SourceControlProviderDiscoveryItem),
	233	),
	234	);
	235	}),
	236	);
	237	}

apps/server/src/sourceControl/SourceControlProviderRegistry.test.ts+48−9

@@ -1,11 +1,16 @@
1	import { assert, it } from "@effect/vitest";	1	import { assert, it } from "@effect/vitest";
		2	import * as NodeServices from "@effect/platform-node/NodeServices";
2	import { DateTime, Effect, Layer, Option } from "effect";	3	import { DateTime, Effect, Layer, Option } from "effect";
3		4
4	import { GitHubCli } from "./GitHubCli.ts";	5	import { ServerConfig } from "../config.ts";
5	import { GitLabCli } from "./GitLabCli.ts";	6	import type * as VcsDriver from "../vcs/VcsDriver.ts";
		7	import * as VcsDriverRegistry from "../vcs/VcsDriverRegistry.ts";
		8	import * as VcsProcess from "../vcs/VcsProcess.ts";
		9	import * as AzureDevOpsCli from "./AzureDevOpsCli.ts";
		10	import * as BitbucketApi from "./BitbucketApi.ts";
		11	import * as GitHubCli from "./GitHubCli.ts";
		12	import * as GitLabCli from "./GitLabCli.ts";
6	import * as SourceControlProviderRegistry from "./SourceControlProviderRegistry.ts";	13	import * as SourceControlProviderRegistry from "./SourceControlProviderRegistry.ts";
7	import { VcsDriverRegistry } from "../vcs/VcsDriverRegistry.ts";
8	import type { VcsDriverShape } from "../vcs/VcsDriver.ts";
9		14
10	const TEST_EPOCH = DateTime.makeUnsafe("1970-01-01T00:00:00.000Z");	15	const TEST_EPOCH = DateTime.makeUnsafe("1970-01-01T00:00:00.000Z");
11		16
@@ -29,10 +34,10 @@ function makeRegistry(input: { · 17 unmodified lines
29	expiresAt: Option.none(),	34	expiresAt: Option.none(),
30	},	35	},
31	}),	36	}),
32	} satisfies Partial<VcsDriverShape>;	37	} satisfies Partial<VcsDriver.VcsDriverShape>;
33		38
34	const registryLayer = Layer.mock(VcsDriverRegistry)({	39	const registryLayer = Layer.mock(VcsDriverRegistry.VcsDriverRegistry)({
35	get: () => Effect.succeed(driver as unknown as VcsDriverShape),	40	get: () => Effect.succeed(driver as unknown as VcsDriver.VcsDriverShape),
36	resolve: () =>	41	resolve: () =>
37	Effect.succeed({	42	Effect.succeed({
38	kind: "git",	43	kind: "git",
@@ -46,13 +51,23 @@ function makeRegistry(input: { · 7 unmodified lines
46	expiresAt: Option.none(),	51	expiresAt: Option.none(),
47	},	52	},
48	},	53	},
49	driver: driver as unknown as VcsDriverShape,	54	driver: driver as unknown as VcsDriver.VcsDriverShape,
50	}),	55	}),
51	});	56	});
52		57
53	return SourceControlProviderRegistry.make().pipe(	58	return SourceControlProviderRegistry.make().pipe(
54	Effect.provide(	59	Effect.provide(
55	Layer.mergeAll(registryLayer, Layer.mock(GitHubCli)({}), Layer.mock(GitLabCli)({})),	60	Layer.mergeAll(
		61	registryLayer,
		62	Layer.mock(AzureDevOpsCli.AzureDevOpsCli)({}),
		63	Layer.mock(BitbucketApi.BitbucketApi)({}),
		64	Layer.mock(GitHubCli.GitHubCli)({}),
		65	Layer.mock(GitLabCli.GitLabCli)({}),
		66	Layer.mock(VcsProcess.VcsProcess)({}),
		67	ServerConfig.layerTest(process.cwd(), { prefix: "t3-source-control-registry-test-" }).pipe(
		68	Layer.provide(NodeServices.layer),
		69	),
		70	),
56	),	71	),
57	);	72	);
58	}	73	}
@@ -93,6 +108,30 @@ it.effect("routes GitLab remotes to the GitLab provider", () => · 34 unmodified lines
93	}),	108	}),
94	);	109	);
95		110
		111	it.effect("routes Bitbucket remotes to the Bitbucket provider", () =>
		112	Effect.gen(function* () {
		113	const registry = yield* makeRegistry({
		114	remotes: [{ name: "origin", url: "git@bitbucket.org:pingdotgg/t3code.git" }],
		115	});
		116
		117	const provider = yield* registry.resolve({ cwd: "/repo" });
		118
		119	assert.strictEqual(provider.kind, "bitbucket");
		120	}),
		121	);
		122
		123	it.effect("routes Azure DevOps remotes to the Azure DevOps provider", () =>
		124	Effect.gen(function* () {
		125	const registry = yield* makeRegistry({
		126	remotes: [{ name: "origin", url: "https://dev.azure.com/acme/project/_git/repo" }],
		127	});
		128
		129	const provider = yield* registry.resolve({ cwd: "/repo" });
		130
		131	assert.strictEqual(provider.kind, "azure-devops");
		132	}),
		133	);
		134
96	it.effect("falls back to a non-origin remote when origin is not configured", () =>	135	it.effect("falls back to a non-origin remote when origin is not configured", () =>
97	Effect.gen(function* () {	136	Effect.gen(function* () {
98	const registry = yield* makeRegistry({	137	const registry = yield* makeRegistry({

apps/server/src/sourceControl/SourceControlProviderRegistry.ts+104−22

 import { Cache, Context, Duration, Effect, Exit, Layer } from "effect";
-import { SourceControlProviderError } from "@t3tools/contracts";
+import {
+  SourceControlProviderError,
+  type SourceControlProviderDiscoveryItem,
+} from "@t3tools/contracts";
 import type { SourceControlProviderKind } from "@t3tools/contracts";
 import { detectSourceControlProviderFromRemoteUrl } from "@t3tools/shared/sourceControl";
-import {
+import * as AzureDevOpsSourceControlProvider from "./AzureDevOpsSourceControlProvider.ts";
-  SourceControlProvider,
+import * as BitbucketSourceControlProvider from "./BitbucketSourceControlProvider.ts";
-  type SourceControlProviderContext,
-  type SourceControlProviderShape,
-} from "./SourceControlProvider.ts";
 import * as GitHubSourceControlProvider from "./GitHubSourceControlProvider.ts";
 import * as GitLabSourceControlProvider from "./GitLabSourceControlProvider.ts";
-import { VcsDriverRegistry } from "../vcs/VcsDriverRegistry.ts";
+import * as SourceControlProvider from "./SourceControlProvider.ts";
+import * as SourceControlProviderDiscovery from "./SourceControlProviderDiscovery.ts";
+import { ServerConfig } from "../config.ts";
+import * as VcsDriverRegistry from "../vcs/VcsDriverRegistry.ts";
+import * as VcsProcess from "../vcs/VcsProcess.ts";
 const PROVIDER_DETECTION_CACHE_CAPACITY = 2_048;
 const PROVIDER_DETECTION_CACHE_TTL = Duration.seconds(5);
 export interface SourceControlProviderRegistration {
   readonly kind: SourceControlProviderKind;
-  readonly provider: SourceControlProviderShape;
+  readonly provider: SourceControlProvider.SourceControlProviderShape;
+  readonly discovery: SourceControlProviderDiscovery.SourceControlProviderDiscoverySpec;
 }
 export interface SourceControlProviderHandle {
-  readonly provider: SourceControlProviderShape;
+  readonly provider: SourceControlProvider.SourceControlProviderShape;
-  readonly context: SourceControlProviderContext | null;
+  readonly context: SourceControlProvider.SourceControlProviderContext | null;
 }
 export interface SourceControlProviderRegistryShape {
   readonly get: (
     kind: SourceControlProviderKind,
-  ) => Effect.Effect<SourceControlProviderShape, SourceControlProviderError>;
+  ) => Effect.Effect<SourceControlProvider.SourceControlProviderShape, SourceControlProviderError>;
   readonly resolveHandle: (input: {
     readonly cwd: string;
   }) => Effect.Effect<SourceControlProviderHandle, SourceControlProviderError>;
   readonly resolve: (input: {
     readonly cwd: string;
-  }) => Effect.Effect<SourceControlProviderShape, SourceControlProviderError>;
+  }) => Effect.Effect<SourceControlProvider.SourceControlProviderShape, SourceControlProviderError>;
+  readonly discover: Effect.Effect<ReadonlyArray<SourceControlProviderDiscoveryItem>>;
 }
 export class SourceControlProviderRegistry extends Context.Service<
   SourceControlProviderRegistryShape
 >()("t3/source-control/SourceControlProviderRegistry") {}
-function unsupportedProvider(kind: SourceControlProviderKind): SourceControlProviderShape {
+function unsupportedProvider(
+  kind: SourceControlProviderKind,
+): SourceControlProvider.SourceControlProviderShape {
   const unsupported = (operation: string) =>
     Effect.fail(
       new SourceControlProviderError({
       }),
     );
-  return SourceControlProvider.of({
+  return SourceControlProvider.SourceControlProvider.of({
     kind,
     listChangeRequests: () => unsupported("listChangeRequests"),
     getChangeRequest: () => unsupported("getChangeRequest"),
     readonly name: string;
     readonly url: string;
   }>,
-): SourceControlProviderContext | null {
+): SourceControlProvider.SourceControlProviderContext | null {
   const candidates = remotes
     .map((remote) => {
       const provider = detectSourceControlProviderFromRemoteUrl(remote.url);
           }
         : null;
     })
-    .filter((value): value is SourceControlProviderContext => value !== null);
+    .filter((value): value is SourceControlProvider.SourceControlProviderContext => value !== null);
   return (
     candidates.find((candidate) => candidate.remoteName === "origin") ??
   );
 }
+function bindProviderContext(
+  provider: SourceControlProvider.SourceControlProviderShape,
+  context: SourceControlProvider.SourceControlProviderContext | null,
+): SourceControlProvider.SourceControlProviderShape {
+  if (context === null) {
+    return provider;
+  }
+  return SourceControlProvider.SourceControlProvider.of({
+    kind: provider.kind,
+    listChangeRequests: (input) =>
+      provider.listChangeRequests({
+        ...input,
+        context: input.context ?? context,
+      }),
+    getChangeRequest: (input) =>
+      provider.getChangeRequest({
+        ...input,
+        context: input.context ?? context,
+      }),
+    createChangeRequest: (input) =>
+      provider.createChangeRequest({
+        ...input,
+        context: input.context ?? context,
+      }),
+    getRepositoryCloneUrls: (input) =>
+      provider.getRepositoryCloneUrls({
+        ...input,
+        context: input.context ?? context,
+      }),
+    createRepository: (input) => provider.createRepository(input),
+    getDefaultBranch: (input) =>
+      provider.getDefaultBranch({
+        ...input,
+        context: input.context ?? context,
+      }),
+    checkoutChangeRequest: (input) =>
+      provider.checkoutChangeRequest({
+        ...input,
+        context: input.context ?? context,
+      }),
+  });
+}
 export const makeWithProviders = Effect.fn("makeSourceControlProviderRegistryWithProviders")(
   function* (registrations: ReadonlyArray<SourceControlProviderRegistration>) {
-    const vcsRegistry = yield* VcsDriverRegistry;
+    const config = yield* ServerConfig;
-    const providers = new Map<SourceControlProviderKind, SourceControlProviderShape>(
+    const process = yield* VcsProcess.VcsProcess;
-      registrations.map((registration) => [registration.kind, registration.provider]),
+    const vcsRegistry = yield* VcsDriverRegistry.VcsDriverRegistry;
-    );
+    const providers = new Map<
+      SourceControlProviderKind,
+      SourceControlProvider.SourceControlProviderShape
+    >(registrations.map((registration) => [registration.kind, registration.provider]));
+    const discoverySpecs = registrations.map((registration) => registration.discovery);
     const get: SourceControlProviderRegistryShape["get"] = (kind) =>
       Effect.succeed(providers.get(kind) ?? unsupportedProvider(kind));
     const providerContextCache = yield* Cache.makeWith<
       string,
-      SourceControlProviderContext | null,
+      SourceControlProvider.SourceControlProviderContext | null,
       SourceControlProviderError
     >(detectProviderContext, {
       capacity: PROVIDER_DETECTION_CACHE_CAPACITY,
       Cache.get(providerContextCache, input.cwd).pipe(
         Effect.map((context) => {
           const kind = context?.provider.kind ?? "unknown";
+          const provider = providers.get(kind) ?? unsupportedProvider(kind);
           return {
-            provider: providers.get(kind) ?? unsupportedProvider(kind),
+            provider: bindProviderContext(provider, context),
             context,
           } satisfies SourceControlProviderHandle;
         }),
       get,
       resolveHandle,
       resolve: (input) => resolveHandle(input).pipe(Effect.map((handle) => handle.provider)),
+      discover: Effect.all(
+        discoverySpecs.map((spec) =>
+          SourceControlProviderDiscovery.probeSourceControlProvider({
+            spec,
+            process,
+            cwd: config.cwd,
+          }),
+        ),
+        { concurrency: "unbounded" },
+      ),
     });
   },
 );
 export const make = Effect.fn("makeSourceControlProviderRegistry")(function* () {
   const github = yield* GitHubSourceControlProvider.make();
   const gitlab = yield* GitLabSourceControlProvider.make();
+  const bitbucket = yield* BitbucketSourceControlProvider.make();
+  const bitbucketDiscovery = yield* BitbucketSourceControlProvider.makeDiscovery();
+  const azureDevOps = yield* AzureDevOpsSourceControlProvider.make();
   return yield* makeWithProviders([
     {
       kind: "github",
       provider: github,
+      discovery: GitHubSourceControlProvider.discovery,
     },
     {
       kind: "gitlab",
       provider: gitlab,
+      discovery: GitLabSourceControlProvider.discovery,
+    },
+    {
+      kind: "azure-devops",
+      provider: azureDevOps,
+      discovery: AzureDevOpsSourceControlProvider.discovery,
+    },
+    {
+      kind: "bitbucket",
+      provider: bitbucket,
+      discovery: bitbucketDiscovery,
     },
   ]);
 });

apps/server/src/sourceControl/SourceControlRepositoryService.test.ts+17−21

 import { GitCommandError, type SourceControlProviderError } from "@t3tools/contracts";
 import { ServerConfig } from "../config.ts";
-import {
+import * as GitVcsDriver from "../vcs/GitVcsDriver.ts";
-  GitVcsDriver,
+import type * as SourceControlProvider from "./SourceControlProvider.ts";
-  type ExecuteGitResult,
+import * as SourceControlProviderRegistry from "./SourceControlProviderRegistry.ts";
-  type GitVcsDriverShape,
+import * as SourceControlRepositoryService from "./SourceControlRepositoryService.ts";
-} from "../vcs/GitVcsDriver.ts";
-import { SourceControlProviderRegistry } from "./SourceControlProviderRegistry.ts";
-import type { SourceControlProviderShape } from "./SourceControlProvider.ts";
-import { SourceControlRepositoryService, layer } from "./SourceControlRepositoryService.ts";
 const CLONE_URLS = {
   nameWithOwner: "octocat/t3code",
 };
 function makeProvider(
-  overrides: Partial<SourceControlProviderShape> = {},
+  overrides: Partial<SourceControlProvider.SourceControlProviderShape> = {},
-): SourceControlProviderShape {
+): SourceControlProvider.SourceControlProviderShape {
   const unsupported = (operation: string) =>
     Effect.die(`unexpected provider operation ${operation}`) as Effect.Effect<
       never,
   };
 }
-function processOutput(): ExecuteGitResult {
+function processOutput(): GitVcsDriver.ExecuteGitResult {
   return {
     exitCode: ChildProcessSpawner.ExitCode(0),
     stdout: "",
 }
 function makeLayer(input: {
-  readonly provider?: SourceControlProviderShape;
+  readonly provider?: SourceControlProvider.SourceControlProviderShape;
-  readonly git?: Partial<GitVcsDriverShape>;
+  readonly git?: Partial<GitVcsDriver.GitVcsDriverShape>;
 }) {
-  return layer.pipe(
+  return SourceControlRepositoryService.layer.pipe(
     Layer.provide(
-      Layer.mock(SourceControlProviderRegistry)({
+      Layer.mock(SourceControlProviderRegistry.SourceControlProviderRegistry)({
         get: () => Effect.succeed(input.provider ?? makeProvider()),
       }),
     ),
     Layer.provide(
-      Layer.mock(GitVcsDriver)({
+      Layer.mock(GitVcsDriver.GitVcsDriver)({
         execute: () => Effect.succeed(processOutput()),
         ensureRemote: () => Effect.succeed("origin"),
         pushCurrentBranch: () =>
   });
   return Effect.gen(function* () {
-    const service = yield* SourceControlRepositoryService;
+    const service = yield* SourceControlRepositoryService.SourceControlRepositoryService;
     const result = yield* service.lookupRepository({
       provider: "github",
       repository: "octocat/t3code",
     const cloneCalls: Array<{ cwd: string; args: ReadonlyArray<string> }> = [];
     yield* Effect.gen(function* () {
-      const service = yield* SourceControlRepositoryService;
+      const service = yield* SourceControlRepositoryService.SourceControlRepositoryService;
       const result = yield* service.cloneRepository({
         provider: "github",
         repository: "octocat/t3code",
   });
   return Effect.gen(function* () {
-    const service = yield* SourceControlRepositoryService;
+    const service = yield* SourceControlRepositoryService.SourceControlRepositoryService;
     const result = yield* service.publishRepository({
       cwd: "/workspace",
       provider: "github",
   const pushCalls: Array<{ cwd: string; remoteName: string | null | undefined }> = [];
   return Effect.gen(function* () {
-    const service = yield* SourceControlRepositoryService;
+    const service = yield* SourceControlRepositoryService.SourceControlRepositoryService;
     const result = yield* service.publishRepository({
       cwd: "/workspace",
       provider: "github",
 it.effect("publish succeeds with status remote_added when the local repo has no commits", () => {
   let pushCalls = 0;
   return Effect.gen(function* () {
-    const service = yield* SourceControlRepositoryService;
+    const service = yield* SourceControlRepositoryService.SourceControlRepositoryService;
     const result = yield* service.publishRepository({
       cwd: "/workspace",
       provider: "github",

apps/server/src/sourceControl/SourceControlRepositoryService.ts+7−7

@@ -1,4 +1,4 @@
1	import OS from "node:os";	1	import * as NodeOS from "node:os";
2	import { Context, Effect, FileSystem, Layer, Path, Schema } from "effect";	2	import { Context, Effect, FileSystem, Layer, Path, Schema } from "effect";
3		3
4	import {	4	import {
@@ -15,8 +15,8 @@ import { · 10 unmodified lines
15	} from "@t3tools/contracts";	15	} from "@t3tools/contracts";
16		16
17	import { ServerConfig } from "../config.ts";	17	import { ServerConfig } from "../config.ts";
18	import { GitVcsDriver } from "../vcs/GitVcsDriver.ts";	18	import * as GitVcsDriver from "../vcs/GitVcsDriver.ts";
19	import { SourceControlProviderRegistry } from "./SourceControlProviderRegistry.ts";	19	import * as SourceControlProviderRegistry from "./SourceControlProviderRegistry.ts";
20		20
21	export interface SourceControlRepositoryServiceShape {	21	export interface SourceControlRepositoryServiceShape {
22	readonly lookupRepository: (	22	readonly lookupRepository: (
@@ -102,10 +102,10 @@ function selectRemoteUrl( · 79 unmodified lines
102		102
103	function expandHomePath(input: string, path: Path.Path): string {	103	function expandHomePath(input: string, path: Path.Path): string {
104	if (input === "~") {	104	if (input === "~") {
105	return OS.homedir();	105	return NodeOS.homedir();
106	}	106	}
107	if (input.startsWith("~/") \|\| input.startsWith("~\\")) {	107	if (input.startsWith("~/") \|\| input.startsWith("~\\")) {
108	return path.join(OS.homedir(), input.slice(2));	108	return path.join(NodeOS.homedir(), input.slice(2));
109	}	109	}
110	return input;	110	return input;
111	}	111	}
@@ -113,9 +113,9 @@ function expandHomePath(input: string, path: Path.Path): string { · 1 unmodified line
113	export const make = Effect.fn("makeSourceControlRepositoryService")(function* () {	113	export const make = Effect.fn("makeSourceControlRepositoryService")(function* () {
114	const config = yield* ServerConfig;	114	const config = yield* ServerConfig;
115	const fileSystem = yield* FileSystem.FileSystem;	115	const fileSystem = yield* FileSystem.FileSystem;
116	const git = yield* GitVcsDriver;	116	const git = yield* GitVcsDriver.GitVcsDriver;
117	const path = yield* Path.Path;	117	const path = yield* Path.Path;
118	const providers = yield* SourceControlProviderRegistry;	118	const providers = yield* SourceControlProviderRegistry.SourceControlProviderRegistry;
119		119
120	const ensureConcreteProvider = (input: {	120	const ensureConcreteProvider = (input: {
121	readonly operation: string;	121	readonly operation: string;

apps/server/src/sourceControl/azureDevOpsPullRequests.ts+106−0

@@ -0,0 +1,106 @@
	1	import { Cause, DateTime, Exit, Option, Result, Schema } from "effect";
	2	import { PositiveInt, TrimmedNonEmptyString } from "@t3tools/contracts";
	3	import { decodeJsonResult, formatSchemaError } from "@t3tools/shared/schemaJson";
	4
	5	export interface NormalizedAzureDevOpsPullRequestRecord {
	6	readonly number: number;
	7	readonly title: string;
	8	readonly url: string;
	9	readonly baseRefName: string;
	10	readonly headRefName: string;
	11	readonly state: "open" \| "closed" \| "merged";
	12	readonly updatedAt: Option.Option<DateTime.Utc>;
	13	}
	14
	15	const AzureDevOpsPullRequestSchema = Schema.Struct({
	16	pullRequestId: PositiveInt,
	17	title: TrimmedNonEmptyString,
	18	url: Schema.optional(Schema.String),
	19	sourceRefName: TrimmedNonEmptyString,
	20	targetRefName: TrimmedNonEmptyString,
	21	status: Schema.String,
	22	creationDate: Schema.optional(Schema.OptionFromNullOr(Schema.DateTimeUtcFromString)),
	23	closedDate: Schema.optional(Schema.OptionFromNullOr(Schema.DateTimeUtcFromString)),
	24	_links: Schema.optional(
	25	Schema.Struct({
	26	web: Schema.optional(
	27	Schema.Struct({
	28	href: Schema.String,
	29	}),
	30	),
	31	}),
	32	),
	33	});
	34
	35	function trimOptionalString(value: string \| null \| undefined): string \| null {
	36	const trimmed = value?.trim() ?? "";
	37	return trimmed.length > 0 ? trimmed : null;
	38	}
	39
	40	function normalizeRefName(refName: string): string {
	41	return refName.trim().replace(/^refs\/heads\//, "");
	42	}
	43
	44	function normalizeAzureDevOpsPullRequestState(status: string): "open" \| "closed" \| "merged" {
	45	switch (status.trim().toLowerCase()) {
	46	case "completed":
	47	return "merged";
	48	case "abandoned":
	49	return "closed";
	50	default:
	51	return "open";
	52	}
	53	}
	54
	55	function normalizeAzureDevOpsPullRequestRecord(
	56	raw: Schema.Schema.Type<typeof AzureDevOpsPullRequestSchema>,
	57	): NormalizedAzureDevOpsPullRequestRecord {
	58	return {
	59	number: raw.pullRequestId,
	60	title: raw.title,
	61	url: trimOptionalString(raw._links?.web?.href) ?? trimOptionalString(raw.url) ?? "",
	62	baseRefName: normalizeRefName(raw.targetRefName),
	63	headRefName: normalizeRefName(raw.sourceRefName),
	64	state: normalizeAzureDevOpsPullRequestState(raw.status),
	65	updatedAt: (raw.closedDate ?? Option.none()).pipe(
	66	Option.orElse(() => raw.creationDate ?? Option.none()),
	67	),
	68	};
	69	}
	70
	71	const decodeAzureDevOpsPullRequestList = decodeJsonResult(Schema.Array(Schema.Unknown));
	72	const decodeAzureDevOpsPullRequest = decodeJsonResult(AzureDevOpsPullRequestSchema);
	73	const decodeAzureDevOpsPullRequestEntry = Schema.decodeUnknownExit(AzureDevOpsPullRequestSchema);
	74
	75	export const formatAzureDevOpsJsonDecodeError = formatSchemaError;
	76
	77	export function decodeAzureDevOpsPullRequestListJson(
	78	raw: string,
	79	): Result.Result<
	80	ReadonlyArray<NormalizedAzureDevOpsPullRequestRecord>,
	81	Cause.Cause<Schema.SchemaError>
	82	> {
	83	const result = decodeAzureDevOpsPullRequestList(raw);
	84	if (Result.isSuccess(result)) {
	85	const pullRequests: NormalizedAzureDevOpsPullRequestRecord[] = [];
	86	for (const entry of result.success) {
	87	const decodedEntry = decodeAzureDevOpsPullRequestEntry(entry);
	88	if (Exit.isFailure(decodedEntry)) {
	89	continue;
	90	}
	91	pullRequests.push(normalizeAzureDevOpsPullRequestRecord(decodedEntry.value));
	92	}
	93	return Result.succeed(pullRequests);
	94	}
	95	return Result.fail(result.failure);
	96	}
	97
	98	export function decodeAzureDevOpsPullRequestJson(
	99	raw: string,
	100	): Result.Result<NormalizedAzureDevOpsPullRequestRecord, Cause.Cause<Schema.SchemaError>> {
	101	const result = decodeAzureDevOpsPullRequest(raw);
	102	if (Result.isSuccess(result)) {
	103	return Result.succeed(normalizeAzureDevOpsPullRequestRecord(result.success));
	104	}
	105	return Result.fail(result.failure);
	106	}

apps/server/src/sourceControl/bitbucketPullRequests.ts+104−0

@@ -0,0 +1,104 @@
	1	import { DateTime, Option, Schema } from "effect";
	2	import { PositiveInt, TrimmedNonEmptyString } from "@t3tools/contracts";
	3
	4	export interface NormalizedBitbucketPullRequestRecord {
	5	readonly number: number;
	6	readonly title: string;
	7	readonly url: string;
	8	readonly baseRefName: string;
	9	readonly headRefName: string;
	10	readonly state: "open" \| "closed" \| "merged";
	11	readonly updatedAt: Option.Option<DateTime.Utc>;
	12	readonly isCrossRepository?: boolean;
	13	readonly headRepositoryNameWithOwner?: string \| null;
	14	readonly headRepositoryOwnerLogin?: string \| null;
	15	}
	16
	17	export const BitbucketRepositoryRefSchema = Schema.Struct({
	18	full_name: Schema.optional(Schema.NullOr(TrimmedNonEmptyString)),
	19	workspace: Schema.optional(
	20	Schema.NullOr(
	21	Schema.Struct({
	22	slug: Schema.optional(Schema.NullOr(TrimmedNonEmptyString)),
	23	}),
	24	),
	25	),
	26	});
	27
	28	export const BitbucketPullRequestBranchSchema = Schema.Struct({
	29	repository: Schema.optional(Schema.NullOr(BitbucketRepositoryRefSchema)),
	30	branch: Schema.Struct({
	31	name: TrimmedNonEmptyString,
	32	}),
	33	});
	34
	35	export const BitbucketPullRequestSchema = Schema.Struct({
	36	id: PositiveInt,
	37	title: TrimmedNonEmptyString,
	38	state: Schema.optional(Schema.NullOr(Schema.String)),
	39	updated_on: Schema.optional(Schema.OptionFromNullOr(Schema.DateTimeUtcFromString)),
	40	links: Schema.Struct({
	41	html: Schema.Struct({
	42	href: TrimmedNonEmptyString,
	43	}),
	44	}),
	45	source: BitbucketPullRequestBranchSchema,
	46	destination: BitbucketPullRequestBranchSchema,
	47	});
	48
	49	export const BitbucketPullRequestListSchema = Schema.Struct({
	50	values: Schema.Array(BitbucketPullRequestSchema),
	51	next: Schema.optional(TrimmedNonEmptyString),
	52	});
	53
	54	function trimOptionalString(value: string \| null \| undefined): string \| null {
	55	const trimmed = value?.trim() ?? "";
	56	return trimmed.length > 0 ? trimmed : null;
	57	}
	58
	59	function repositoryOwner(repository: Schema.Schema.Type<typeof BitbucketRepositoryRefSchema>) {
	60	return (
	61	trimOptionalString(repository.workspace?.slug) ??
	62	(repository.full_name?.includes("/") ? (repository.full_name.split("/")[0] ?? null) : null)
	63	);
	64	}
	65
	66	function normalizeBitbucketPullRequestState(state: string \| null \| undefined) {
	67	switch (state?.trim().toUpperCase()) {
	68	case "MERGED":
	69	return "merged" as const;
	70	case "DECLINED":
	71	case "SUPERSEDED":
	72	return "closed" as const;
	73	case "OPEN":
	74	default:
	75	return "open" as const;
	76	}
	77	}
	78
	79	export function normalizeBitbucketPullRequestRecord(
	80	raw: Schema.Schema.Type<typeof BitbucketPullRequestSchema>,
	81	): NormalizedBitbucketPullRequestRecord {
	82	const headRepositoryNameWithOwner = trimOptionalString(raw.source.repository?.full_name);
	83	const baseRepositoryNameWithOwner = trimOptionalString(raw.destination.repository?.full_name);
	84	const headRepositoryOwnerLogin = raw.source.repository
	85	? repositoryOwner(raw.source.repository)
	86	: null;
	87	const isCrossRepository =
	88	headRepositoryNameWithOwner !== null &&
	89	baseRepositoryNameWithOwner !== null &&
	90	headRepositoryNameWithOwner !== baseRepositoryNameWithOwner;
	91
	92	return {
	93	number: raw.id,
	94	title: raw.title,
	95	url: raw.links.html.href,
	96	baseRefName: raw.destination.branch.name,
	97	headRefName: raw.source.branch.name,
	98	state: normalizeBitbucketPullRequestState(raw.state),
	99	updatedAt: raw.updated_on ?? Option.none(),
	100	...(isCrossRepository ? { isCrossRepository: true } : {}),
	101	...(headRepositoryNameWithOwner ? { headRepositoryNameWithOwner } : {}),
	102	...(headRepositoryOwnerLogin ? { headRepositoryOwnerLogin } : {}),
	103	};
	104	}

feat(source-control): add Bitbucket & Azure Devops providers (#2473)

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code