The best way to control Claude Code, Codex and more from any computer or phone

main
ts 269 lines 9.37 KB
Raw
1 import { sourceControlClients } from "@t3tools/client-runtime/source-control-clients";
2 import {
3 PULL_REQUEST_LIST_PROJECT_LIMIT,
4 type EnvironmentId,
5 type EnvironmentMachineKind,
6 type ProjectId,
7 type PullRequestProviderSummary,
8 type RepositoryIdentity,
9 type SourceControlProviderKind,
10 } from "@t3tools/contracts";
11
12 export interface AssignableProject {
13 readonly id: ProjectId;
14 readonly environmentId: EnvironmentId;
15 readonly repositoryIdentity?:
16 | Partial<Pick<RepositoryIdentity, "canonicalKey" | "provider" | "locator">>
17 | null
18 | undefined;
19 }
20
21 export type PullRequestHostAvailability = ReadonlyMap<
22 EnvironmentId,
23 Pick<PullRequestHostRead, "hosts" | "projectHosts">
24 >;
25
26 export type PullRequestHostRead = {
27 readonly observedAt: number;
28 readonly resetAt?: number;
29 readonly hosts: ReadonlyMap<
30 string,
31 { readonly configured: boolean; readonly observedAt: number }
32 >;
33 readonly projectHosts: ReadonlyMap<
34 ProjectId,
35 { readonly host: string; readonly observedAt: number }
36 >;
37 };
38
39 export function resetPullRequestHosts(
40 previous: ReadonlyMap<EnvironmentId, PullRequestHostRead>,
41 ): ReadonlyMap<EnvironmentId, PullRequestHostRead> {
42 return new Map(
43 [...previous].map(([id, read]) => [
44 id,
45 { ...read, resetAt: read.observedAt, hosts: new Map(), projectHosts: new Map() },
46 ]),
47 );
48 }
49
50 export function rememberPullRequestHosts(
51 previous: ReadonlyMap<EnvironmentId, PullRequestHostRead>,
52 observations: ReadonlyArray<
53 readonly [
54 EnvironmentId,
55 { readonly providers: ReadonlyArray<PullRequestProviderSummary> },
56 number,
57 ]
58 >,
59 ): ReadonlyMap<EnvironmentId, PullRequestHostRead> {
60 const activeHosts = new Map<
61 EnvironmentId,
62 Map<string, { configured: boolean; observedAt: number }>
63 >();
64 for (const [environmentId, { providers }, observedAt] of observations) {
65 if (observedAt <= (previous.get(environmentId)?.resetAt ?? -Infinity)) continue;
66 let hosts = activeHosts.get(environmentId);
67 if (hosts === undefined) {
68 hosts = new Map();
69 activeHosts.set(environmentId, hosts);
70 }
71 for (const provider of providers) {
72 const host = provider.host.toLowerCase();
73 const held = hosts.get(host);
74 hosts.set(host, {
75 configured: provider.configured || held?.configured === true,
76 observedAt: Math.max(observedAt, held?.observedAt ?? -Infinity),
77 });
78 }
79 }
80 let next = previous;
81 for (const [environmentId, { providers }, observedAt] of observations) {
82 const before = next.get(environmentId);
83 if (observedAt <= (before?.resetAt ?? -Infinity)) continue;
84 const hosts = new Map(before?.hosts);
85 const projectHosts = new Map(before?.projectHosts);
86 let changed = false;
87 let latestObservedAt = observedAt;
88 for (const provider of providers) {
89 const host = provider.host.toLowerCase();
90 const active = activeHosts.get(environmentId)!.get(host)!;
91 const held = hosts.get(host);
92 if (
93 active.observedAt > (held?.observedAt ?? -Infinity) ||
94 (active.observedAt === held?.observedAt && active.configured && !held.configured)
95 ) {
96 hosts.set(host, active);
97 latestObservedAt = Math.max(latestObservedAt, active.observedAt);
98 changed = true;
99 }
100 for (const projectId of provider.projectIds ?? []) {
101 if (observedAt > (projectHosts.get(projectId)?.observedAt ?? -Infinity)) {
102 projectHosts.set(projectId, { host, observedAt });
103 changed = true;
104 }
105 }
106 }
107 if (!changed) continue;
108 next = new Map(next).set(environmentId, {
109 ...before,
110 observedAt: Math.max(before?.observedAt ?? -Infinity, latestObservedAt),
111 hosts,
112 projectHosts,
113 });
114 }
115 return next;
116 }
117
118 function repositoryKey(project: AssignableProject): string | undefined {
119 return project.repositoryIdentity?.canonicalKey?.toLowerCase();
120 }
121
122 export function assignProjectsToEnvironments(
123 projects: ReadonlyArray<AssignableProject>,
124 environmentIds: ReadonlyArray<EnvironmentId>,
125 preferredEnvironmentId?: EnvironmentId | null,
126 hostAvailability?: PullRequestHostAvailability,
127 unreachableEnvironmentIds: ReadonlySet<EnvironmentId> = new Set(),
128 ): Map<EnvironmentId, ProjectId[]> {
129 const rank = new Map(environmentIds.map((id, index) => [id, index] as const));
130 const owner = new Map<string, AssignableProject>();
131 const unreadable = (project: AssignableProject) => {
132 const availability = hostAvailability?.get(project.environmentId);
133 const host =
134 availability?.projectHosts.get(project.id)?.host ??
135 sourceControlClients.changeRequestHost(
136 project.repositoryIdentity,
137 (project.repositoryIdentity?.provider ?? "unknown") as SourceControlProviderKind,
138 );
139 return availability?.hosts.get(host)?.configured === false;
140 };
141 const cost = (project: AssignableProject) =>
142 (unreachableEnvironmentIds.has(project.environmentId) ? 2 : 0) + (unreadable(project) ? 1 : 0);
143 for (const project of projects) {
144 const key = repositoryKey(project);
145 if (!key) continue;
146 const environmentRank = rank.get(project.environmentId);
147 if (environmentRank === undefined) continue;
148 const current = owner.get(key);
149 if (current === undefined) {
150 owner.set(key, project);
151 continue;
152 }
153 const currentCost = cost(current);
154 const candidateCost = cost(project);
155 if (currentCost !== candidateCost) {
156 if (candidateCost < currentCost) owner.set(key, project);
157 continue;
158 }
159 if (current.environmentId === preferredEnvironmentId) continue;
160 if (
161 project.environmentId === preferredEnvironmentId ||
162 environmentRank < (rank.get(current.environmentId) ?? Number.MAX_SAFE_INTEGER)
163 ) {
164 owner.set(key, project);
165 }
166 }
167 const assignment = new Map<EnvironmentId, ProjectId[]>();
168 for (const project of projects) {
169 if (!rank.has(project.environmentId)) continue;
170 const key = repositoryKey(project);
171 if (key && owner.get(key)?.environmentId !== project.environmentId) continue;
172 const listed = assignment.get(project.environmentId);
173 if (listed === undefined) assignment.set(project.environmentId, [project.id]);
174 else listed.push(project.id);
175 }
176 return assignment;
177 }
178
179 export function pullRequestProjectQueries(
180 projects: ReadonlyArray<AssignableProject>,
181 environmentIds: ReadonlyArray<EnvironmentId>,
182 hostAvailability?: PullRequestHostAvailability,
183 unreachableEnvironmentIds?: ReadonlySet<EnvironmentId>,
184 ): ReadonlyArray<{
185 readonly environmentId: EnvironmentId;
186 readonly projectIds?: ReadonlyArray<ProjectId>;
187 }> {
188 const assignment = assignProjectsToEnvironments(
189 projects,
190 environmentIds,
191 environmentIds[0],
192 hostAvailability,
193 unreachableEnvironmentIds,
194 );
195 const totals = new Map<EnvironmentId, number>();
196 for (const project of projects)
197 totals.set(project.environmentId, (totals.get(project.environmentId) ?? 0) + 1);
198 return environmentIds.flatMap((environmentId) => {
199 const projectIds = assignment.get(environmentId);
200 if (projectIds === undefined) return [];
201 if (projectIds.length === totals.get(environmentId)) return [{ environmentId }];
202 const queries: Array<{ environmentId: EnvironmentId; projectIds: ReadonlyArray<ProjectId> }> =
203 [];
204 for (let offset = 0; offset < projectIds.length; offset += PULL_REQUEST_LIST_PROJECT_LIMIT) {
205 queries.push({
206 environmentId,
207 projectIds: projectIds.slice(offset, offset + PULL_REQUEST_LIST_PROJECT_LIMIT),
208 });
209 }
210 return queries;
211 });
212 }
213
214 export interface PickableEnvironment {
215 readonly environmentId: EnvironmentId;
216 readonly projectId: ProjectId;
217 readonly workspaceRoot: string;
218 readonly label: string;
219 readonly machine?: EnvironmentMachineKind;
220 }
221
222 export function resolvePickableEnvironments(
223 current: { readonly environmentId: EnvironmentId; readonly projectId: ProjectId },
224 projects: ReadonlyArray<AssignableProject & { readonly workspaceRoot: string }>,
225 environments: ReadonlyArray<{
226 readonly environmentId: EnvironmentId;
227 readonly label: string;
228 readonly machine?: EnvironmentMachineKind;
229 }>,
230 ): ReadonlyArray<PickableEnvironment> {
231 const own = projects.find(
232 (project) =>
233 project.environmentId === current.environmentId && project.id === current.projectId,
234 );
235 const key = own === undefined ? undefined : repositoryKey(own);
236 const ownEnvironment = environments.find(
237 (environment) => environment.environmentId === current.environmentId,
238 );
239 if (own === undefined || !key || ownEnvironment === undefined) return [];
240 const others = environments.flatMap((environment) => {
241 if (environment.environmentId === current.environmentId) return [];
242 const copy = projects.find(
243 (project) =>
244 project.environmentId === environment.environmentId && repositoryKey(project) === key,
245 );
246 return copy === undefined
247 ? []
248 : [
249 {
250 environmentId: environment.environmentId,
251 projectId: copy.id,
252 workspaceRoot: copy.workspaceRoot,
253 label: environment.label,
254 ...(environment.machine === undefined ? {} : { machine: environment.machine }),
255 },
256 ];
257 });
258 if (others.length === 0) return [];
259 return [
260 {
261 environmentId: current.environmentId,
262 projectId: own.id,
263 workspaceRoot: own.workspaceRoot,
264 label: ownEnvironment.label,
265 ...(ownEnvironment.machine === undefined ? {} : { machine: ownEnvironment.machine }),
266 },
267 ...others,
268 ];
269 }