import {
WS_METHODS,
PullRequestRef,
PullRequestInvalidateInput,
PullRequestState,
type EnvironmentId,
type PullRequestRoutingResult,
type PullRequestRoutingIdentityResult,
} from "@t3tools/contracts";
import * as Effect from "effect/Effect";
import * as Cause from "effect/Cause";
import * as Deferred from "effect/Deferred";
import * as Exit from "effect/Exit";
import * as Option from "effect/Option";
import * as Schema from "effect/Schema";
import * as SubscriptionRef from "effect/SubscriptionRef";
import * as EnvironmentRegistry from "../connection/registry.ts";
import * as EnvironmentSupervisor from "../connection/supervisor.ts";
import {
PullRequestRoutingPermissions,
pullRequestRoutingConnectionKey,
} from "../connection/pullRequestRoutingPermissions.ts";
import type { ConnectionCatalogEntry } from "../connection/catalog.ts";
import * as ConnectionProfileStore from "../connection/profileStore.ts";
import type { RpcSession } from "../rpc/session.ts";
import {
requestGuarded as request,
EnvironmentRpcUnavailableError,
type EnvironmentRpcInput,
type EnvironmentUnaryRpcTag,
} from "../rpc/client.ts";
const reads = new Set<string>([
WS_METHODS.pullRequestsSummary,
WS_METHODS.pullRequestsStack,
WS_METHODS.pullRequestsDetail,
WS_METHODS.pullRequestsPreview,
WS_METHODS.pullRequestsChecks,
WS_METHODS.pullRequestsActivity,
WS_METHODS.pullRequestsThreadComments,
WS_METHODS.pullRequestsDiffFileContents,
WS_METHODS.pullRequestsFilesViewed,
WS_METHODS.pullRequestsChangeBreakdown,
WS_METHODS.pullRequestsReviewerCandidates,
WS_METHODS.pullRequestsLabelCandidates,
]);
// Review guides are not routed: each server keeps its own, so another server answering would
// report none, or start a run nobody on the pull request's own server can see.
const writes = new Set<string>([
WS_METHODS.pullRequestsSetFilesViewed,
WS_METHODS.pullRequestsRunAction,
WS_METHODS.pullRequestsUpdate,
WS_METHODS.pullRequestsComment,
WS_METHODS.pullRequestsUpdateComment,
WS_METHODS.pullRequestsSubmitReview,
WS_METHODS.pullRequestsReplyToThread,
WS_METHODS.pullRequestsSetReaction,
WS_METHODS.pullRequestsSetThreadResolution,
WS_METHODS.pullRequestsRequestReviewers,
WS_METHODS.pullRequestsSetLabels,
]);
const isRef = Schema.is(PullRequestRef);
const hasState = Schema.is(
Schema.Struct({ state: PullRequestState, isDraft: Schema.optional(Schema.Boolean) }),
);
const isInvalidation = Schema.is(PullRequestInvalidateInput);
const readTimeout = (environmentId: EnvironmentId) =>
Effect.timeoutOrElse({
duration: "30 seconds",
orElse: () =>
Effect.fail(
new EnvironmentRpcUnavailableError({
environmentId,
message: "The environment did not respond to the PR request.",
}),
),
});
interface RoutedRead {
origin: EnvironmentId;
reference: PullRequestRef;
targets: Set<EnvironmentId>;
}
const routedReads = new WeakMap<
EnvironmentRegistry.EnvironmentRegistry["Service"],
Map<string, RoutedRead>
>();
const isUnregistered = Schema.is(EnvironmentRegistry.EnvironmentNotRegisteredError);
const encodeKey = Schema.encodeSync(
Schema.fromJsonString(Schema.Array(Schema.NullOr(Schema.String))),
);
type PendingMetadata<A> = WeakMap<RpcSession, Map<string, Deferred.Deferred<Exit.Exit<A>>>>;
const pendingRouting: PendingMetadata<PullRequestRoutingResult | null> = new WeakMap();
const pendingIdentities: PendingMetadata<PullRequestRoutingIdentityResult | null> = new WeakMap();
function shareMetadataRead<A, R>(
pending: PendingMetadata<A>,
key: string,
probe: Effect.Effect<A, never, R>,
): Effect.Effect<A, never, R | EnvironmentSupervisor.EnvironmentSupervisor> {
return Effect.uninterruptibleMask((restore) =>
Effect.gen(function* () {
const supervisor = yield* EnvironmentSupervisor.EnvironmentSupervisor;
const session = yield* SubscriptionRef.get(supervisor.session);
if (Option.isNone(session)) return yield* restore(probe);
const entries =
pending.get(session.value) ?? new Map<string, Deferred.Deferred<Exit.Exit<A>>>();
pending.set(session.value, entries);
const existing = entries.get(key);
if (existing !== undefined) {
const result = yield* restore(Deferred.await(existing));
// A cancelled first reader must not cancel the other readers waiting on its probe.
return yield* restore(
Exit.hasInterrupts(result) ? shareMetadataRead(pending, key, probe) : result,
);
}
const result = Deferred.makeUnsafe<Exit.Exit<A>>();
entries.set(key, result);
return yield* restore(probe).pipe(
Effect.onExit((exit) =>
Effect.sync(() => entries.delete(key)).pipe(
Effect.andThen(Deferred.succeed(result, exit)),
),
),
);
}),
);
}
function isLocal(entry: ConnectionCatalogEntry): boolean {
const url =
entry.target._tag === "PrimaryConnectionTarget"
? entry.target.httpBaseUrl
: Option.isSome(entry.profile) && entry.profile.value._tag === "BearerConnectionProfile"
? entry.profile.value.httpBaseUrl
: undefined;
if (url === undefined) return false;
try {
return ["localhost", "127.0.0.1", "[::1]"].includes(new URL(url).hostname);
} catch {
return false;
}
}
function rejectedBeforeDispatch(error: unknown): boolean {
return (
typeof error === "object" &&
error !== null &&
"_tag" in error &&
(error._tag === "EnvironmentRpcUnavailableError" ||
error._tag === "EnvironmentNotRegisteredError" ||
(error._tag === "PullRequestOperationError" &&
"operation" in error &&
error.operation === "routeIdentity"))
);
}
const routingAllowed = Effect.fn("PullRequestRouting.allowed")(function* (
registry: EnvironmentRegistry.EnvironmentRegistry["Service"],
originId: EnvironmentId,
destinationId: EnvironmentId,
write: boolean,
) {
const entries = yield* SubscriptionRef.get(registry.entries);
const origin = entries.get(originId);
const destination = entries.get(destinationId);
if (
!origin?.enabled ||
!destination?.enabled ||
origin.unsupportedReason !== undefined ||
destination.unsupportedReason !== undefined
)
return false;
const permissions = yield* PullRequestRoutingPermissions;
const source = yield* permissions.get(origin);
const target = yield* permissions.get(destination);
const allowed = write
? source === "read-write" && target === "read-write"
: source !== "off" && target !== "off";
if (!allowed) return false;
for (const entry of [origin, destination]) {
if (entry.target._tag !== "SshConnectionTarget") continue;
const profiles = yield* Effect.serviceOption(ConnectionProfileStore.ConnectionProfileStore);
if (Option.isNone(profiles)) return false;
const profile = yield* profiles.value
.get(entry.target.connectionId)
.pipe(Effect.orElseSucceed(() => Option.none()));
const key = pullRequestRoutingConnectionKey(entry);
if (key === null || key !== pullRequestRoutingConnectionKey({ ...entry, profile }))
return false;
}
return true;
});
function matchesReference(reference: PullRequestRef, filter: PullRequestRef): boolean {
return (
reference.projectId === filter.projectId &&
reference.repository.toLowerCase() === filter.repository.toLowerCase() &&
reference.number === filter.number &&
(filter.host === undefined || reference.host?.toLowerCase() === filter.host.toLowerCase())
);
}
const invalidateTarget = Effect.fn("PullRequestRouting.invalidateTarget")(function* (
registry: EnvironmentRegistry.EnvironmentRegistry["Service"],
origin: EnvironmentId,
target: EnvironmentId,
inputs: ReadonlyArray<PullRequestInvalidateInput>,
) {
if (target !== origin && !(yield* routingAllowed(registry, origin, target, false))) return;
yield* Effect.forEach(
inputs,
(input) =>
registry.run(target, request(WS_METHODS.pullRequestsInvalidate, input)).pipe(
// A stalled reader must not delay the write's answer.
Effect.timeoutOption("1 second"),
Effect.orElseSucceed(() => undefined),
),
{ concurrency: 3, discard: true },
);
});
/**
* The origin owns the threads linked to this pull request, but a routed read never reaches it.
* Tell it which state the read saw so it checks again.
*/
const reportState = (
{ allowStale: _allowStale, expectedAccountId: _expectedAccountId, ...reference }: PullRequestRef,
status: { readonly state: PullRequestState; readonly isDraft?: boolean | undefined },
) =>
request(WS_METHODS.pullRequestsReportState, {
reference,
state: status.state,
...(status.isDraft === undefined ? {} : { isDraft: status.isDraft }),
}).pipe(Effect.timeoutOption("5 seconds"), Effect.ignore, Effect.forkDetach, Effect.asVoid);
/** Credentials stay on their environments. Only a verified host and account cross the wire. */
export function createPullRequestRouter() {
const routedRequest = Effect.fn("PullRequestRouting.request")(function* <
T extends EnvironmentUnaryRpcTag,
>(tag: T, input: EnvironmentRpcInput<T>, sourceRead?: ReturnType<typeof request<T>>) {
const source = sourceRead ?? request(tag, input);
if (tag === WS_METHODS.pullRequestsInvalidate && isInvalidation(input)) {
const result = yield* request(tag, input);
const origin = yield* EnvironmentSupervisor.EnvironmentSupervisor;
const registry = yield* EnvironmentRegistry.EnvironmentRegistry;
const used = routedReads.get(registry);
const targets = new Map<EnvironmentId, PullRequestRef>();
for (const entry of used?.values() ?? []) {
if (entry.origin !== origin.target.environmentId) continue;
const ref = input.reference;
if (ref !== undefined && !matchesReference(entry.reference, ref)) continue;
for (const target of entry.targets) targets.set(target, entry.reference);
if (input.reference !== undefined)
targets.set(origin.target.environmentId, entry.reference);
}
yield* Effect.forEach(
targets,
([target, reference]) =>
invalidateTarget(registry, origin.target.environmentId, target, [
{ ...input, ...(input.reference === undefined ? {} : { reference }) },
]),
{ concurrency: 4, discard: true },
);
return result;
}
if ((!reads.has(tag) && !writes.has(tag)) || !isRef(input)) {
return yield* request(tag, input);
}
const ref = input;
const origin = yield* EnvironmentSupervisor.EnvironmentSupervisor;
const registry = yield* EnvironmentRegistry.EnvironmentRegistry;
const entries = yield* SubscriptionRef.get(registry.entries);
const sourceEntry = entries.get(origin.target.environmentId);
const used = routedReads.get(registry) ?? new Map<string, RoutedRead>();
routedReads.set(registry, used);
const refKey = encodeKey([
origin.target.environmentId,
ref.projectId,
ref.host?.toLowerCase() ?? null,
ref.repository.toLowerCase(),
String(ref.number),
]);
const invalidateReaders = Effect.suspend(() => {
if (!writes.has(tag) || used.size === 0) return Effect.void;
const targets = new Map<EnvironmentId, PullRequestRef[]>([
[origin.target.environmentId, [ref]],
]);
for (const entry of used.values()) {
if (entry.origin !== origin.target.environmentId || !matchesReference(entry.reference, ref))
continue;
for (const target of [...entry.targets, origin.target.environmentId]) {
const refs = targets.get(target) ?? [];
if (!refs.some((existing) => existing.host === entry.reference.host))
refs.push(entry.reference);
targets.set(target, refs);
}
}
return Effect.forEach(
targets,
([target, refs]) =>
invalidateTarget(registry, origin.target.environmentId, target, [
...refs.map((reference) => ({
reference,
...(tag === WS_METHODS.pullRequestsSetFilesViewed ? { filesViewedOnly: true } : {}),
})),
...(tag === WS_METHODS.pullRequestsSetFilesViewed ? [] : [{}]),
]),
{ concurrency: 4, discard: true },
);
});
// A failed viewed-files batch may have applied some paths. Other writes invalidate on success.
const finish = (operation: ReturnType<typeof request<T>>) =>
tag === WS_METHODS.pullRequestsSetFilesViewed
? operation.pipe(Effect.ensuring(invalidateReaders))
: operation.pipe(Effect.tap(() => invalidateReaders));
const alternatives = [];
for (const [id, entry] of entries) {
if (id === origin.target.environmentId) continue;
if (!(yield* routingAllowed(registry, origin.target.environmentId, id, writes.has(tag))))
continue;
const connected = yield* registry
.run(
id,
EnvironmentSupervisor.EnvironmentSupervisor.pipe(
Effect.flatMap((s) => SubscriptionRef.get(s.session)),
),
)
.pipe(Effect.orElseSucceed(() => Option.none()));
if (Option.isNone(connected)) continue;
if (tag === WS_METHODS.pullRequestsChecks) {
const supported = yield* connected.value.initialConfig.pipe(
Effect.map((config) => config.environment.capabilities.pullRequestChecks === true),
Effect.timeout("2 seconds"),
Effect.catchCause((cause) =>
Cause.hasInterrupts(cause) ? Effect.interrupt : Effect.succeed(false),
),
);
if (!supported) continue;
}
alternatives.push({ id, local: isLocal(entry) });
}
if (alternatives.length === 0) return yield* finish(source);
const identityProbe = request(WS_METHODS.pullRequestsRouting, ref).pipe(
Effect.timeout("2 seconds"),
Effect.catchCause((cause) =>
Cause.hasInterrupts(cause) ? Effect.interrupt : Effect.succeed(null),
),
);
const identity = yield* reads.has(tag)
? shareMetadataRead(
pendingRouting,
encodeKey([ref.projectId, ref.host?.toLowerCase() ?? null, ref.repository.toLowerCase()]),
identityProbe,
)
: identityProbe;
// The source server answers only for a host whose account it can verify.
if (identity === null) return yield* finish(source);
const routedInput = {
...input,
host: identity.host,
expectedAccountId: identity.accountId,
};
const guardedSource = sourceRead ?? (yield* Effect.cached(request(tag, routedInput)));
const local = alternatives.filter((entry) => entry.local);
const remote = alternatives.filter((entry) => !entry.local);
const sourceLocal = sourceEntry !== undefined && isLocal(sourceEntry);
const candidates = [
...(sourceLocal && writes.has(tag) ? [origin.target.environmentId] : []),
...local.map((entry) => entry.id),
...(!sourceLocal && writes.has(tag) ? [origin.target.environmentId] : []),
...remote.map((entry) => entry.id),
...(reads.has(tag) ? [origin.target.environmentId] : []),
];
const run = (id: EnvironmentId): ReturnType<typeof request<T>> =>
(id === origin.target.environmentId
? guardedSource
: registry.run(id, request(tag, routedInput))
).pipe(
Effect.tap((result) =>
id !== origin.target.environmentId && hasState(result)
? reportState(ref, result)
: Effect.void,
),
Effect.tap(() =>
Effect.sync(() => {
const entry = used.get(refKey) ?? {
origin: origin.target.environmentId,
reference: { ...ref, host: identity.host },
targets: new Set<EnvironmentId>(),
};
entry.targets.add(id);
if (used.size >= 256 && !used.has(refKey)) {
const oldest = used.keys().next().value;
if (oldest !== undefined) used.delete(oldest);
}
used.set(refKey, entry);
}),
),
Effect.mapError((error) =>
isUnregistered(error)
? new EnvironmentRpcUnavailableError({
environmentId: id,
message: "The environment was removed.",
})
: error,
),
);
const visit = (index: number): ReturnType<typeof request<T>> => {
const id = candidates[index];
if (id === undefined) return guardedSource;
return Effect.gen(function* () {
if (id !== origin.target.environmentId) {
if (!(yield* routingAllowed(registry, origin.target.environmentId, id, writes.has(tag))))
return yield* visit(index + 1);
// An older server would discard expectedAccountId. Verify it implements the guard first.
const alternateProbe = request(WS_METHODS.pullRequestsRoutingIdentity, {
host: identity.host,
}).pipe(
Effect.timeout("2 seconds"),
Effect.catchCause((cause) =>
Cause.hasInterrupts(cause) ? Effect.interrupt : Effect.succeed(null),
),
);
const alternate = yield* registry
.run(
id,
reads.has(tag)
? shareMetadataRead(pendingIdentities, identity.host.toLowerCase(), alternateProbe)
: alternateProbe,
)
.pipe(
Effect.timeout("2 seconds"),
Effect.catchCause((cause) =>
Cause.hasInterrupts(cause) ? Effect.interrupt : Effect.succeed(null),
),
);
if (
alternate === null ||
alternate.provider !== identity.provider ||
alternate.host.toLowerCase() !== identity.host.toLowerCase() ||
alternate.accountId !== identity.accountId
) {
return yield* visit(index + 1);
}
if (!(yield* routingAllowed(registry, origin.target.environmentId, id, writes.has(tag))))
return yield* visit(index + 1);
}
const operation = run(id);
return yield* (reads.has(tag) ? operation.pipe(readTimeout(id)) : operation).pipe(
Effect.catchIf(
(error) =>
(reads.has(tag) || rejectedBeforeDispatch(error)) && index + 1 < candidates.length,
() => visit(index + 1),
),
Effect.map((result) =>
typeof result === "object" && result !== null && "projectId" in result
? {
...result,
projectId: ref.projectId,
...(tag === WS_METHODS.pullRequestsDetail
? { projectTitle: identity.projectTitle, workspaceRoot: identity.workspaceRoot }
: {}),
}
: result,
),
);
});
};
return yield* finish(visit(0));
});
return Effect.fn("PullRequestRouting.readOrWrite")(function* <T extends EnvironmentUnaryRpcTag>(
tag: T,
input: EnvironmentRpcInput<T>,
) {
if (!reads.has(tag) || !isRef(input)) return yield* routedRequest(tag, input);
const registry = yield* EnvironmentRegistry.EnvironmentRegistry;
const entries = yield* SubscriptionRef.get(registry.entries);
if (entries.size < 2) return yield* request(tag, input);
const origin = yield* EnvironmentSupervisor.EnvironmentSupervisor;
let allowed = false;
for (const id of entries.keys()) {
if (
id !== origin.target.environmentId &&
(yield* routingAllowed(registry, origin.target.environmentId, id, false))
) {
allowed = true;
break;
}
}
if (!allowed) return yield* request(tag, input);
const strictInput = { ...input, allowStale: false };
const source = yield* Effect.cached(
request(tag, strictInput).pipe(readTimeout(origin.target.environmentId)),
);
const sourceEntry = entries.get(origin.target.environmentId);
const routed = routedRequest(tag, strictInput, source);
return yield* (
sourceEntry !== undefined && isLocal(sourceEntry)
? source.pipe(Effect.catch(() => routed))
: routed
).pipe(
Effect.catch((error) =>
input.allowStale !== false &&
(tag === WS_METHODS.pullRequestsSummary || tag === WS_METHODS.pullRequestsDetail)
? request(tag, input)
: Effect.fail(error),
),
);
});
}