The best way to control Claude Code, Codex and more from any computer or phone
| 1 | import type { |
| 2 | PullRequestAction, |
| 3 | PullRequestMergeMethod, |
| 4 | PullRequestStackHead, |
| 5 | } from "@t3tools/contracts"; |
| 6 | import * as Effect from "effect/Effect"; |
| 7 | import * as Clock from "effect/Clock"; |
| 8 | import { GraphQLClient, GraphQLClientError, GraphQLResolver } from "effect/graphql"; |
| 9 | import * as RequestResolver from "effect/RequestResolver"; |
| 10 | import * as Result from "effect/Result"; |
| 11 | import * as Schema from "effect/Schema"; |
| 12 | |
| 13 | import * as GitHubRest from "./GitHubRest.ts"; |
| 14 | import * as GitHubGraphQlClient from "./gitHubGraphQlClient.ts"; |
| 15 | import { decodePullRequestStacksJson, toCanWrite } from "./gitHubPullRequestJson.ts"; |
| 16 | import { cascadeRebaseStack } from "./githubStackRebase.ts"; |
| 17 | import { StackActionsGraphQLGroup } from "./stackActions.graphql.ts"; |
| 18 | |
| 19 | const stackErrorIdentity = { |
| 20 | repository: Schema.String, |
| 21 | number: Schema.Int, |
| 22 | stackNumber: Schema.Int, |
| 23 | }; |
| 24 | |
| 25 | export class GitHubStackChangedError extends Schema.TaggedError<GitHubStackChangedError>()( |
| 26 | "GitHubStackChangedError", |
| 27 | { ...stackErrorIdentity, completed: Schema.Int }, |
| 28 | ) { |
| 29 | override get message(): string { |
| 30 | return this.completed > 0 |
| 31 | ? `The stack changed at PR #${this.number} after ${this.completed} layers. Earlier updates remain on GitHub. Refresh it before trying again.` |
| 32 | : "The stack changed. Refresh it before trying again."; |
| 33 | } |
| 34 | } |
| 35 | |
| 36 | export class GitHubStackUnsupportedError extends Schema.TaggedError<GitHubStackUnsupportedError>()( |
| 37 | "GitHubStackUnsupportedError", |
| 38 | stackErrorIdentity, |
| 39 | ) { |
| 40 | override get message(): string { |
| 41 | return "This operation is not supported for this stack."; |
| 42 | } |
| 43 | } |
| 44 | |
| 45 | export class GitHubStackResponseInvalidError extends Schema.TaggedError<GitHubStackResponseInvalidError>()( |
| 46 | "GitHubStackResponseInvalidError", |
| 47 | { ...stackErrorIdentity, cause: Schema.optional(Schema.Defect()) }, |
| 48 | ) { |
| 49 | override get message(): string { |
| 50 | return "GitHub returned an unreadable stack operation response."; |
| 51 | } |
| 52 | } |
| 53 | |
| 54 | export class GitHubStackMergeRejectedError extends Schema.TaggedError<GitHubStackMergeRejectedError>()( |
| 55 | "GitHubStackMergeRejectedError", |
| 56 | { ...stackErrorIdentity, cause: Schema.Defect() }, |
| 57 | ) { |
| 58 | override get message(): string { |
| 59 | return "GitHub refused the stack merge. Check the stack's branch rules and merge requirements."; |
| 60 | } |
| 61 | } |
| 62 | |
| 63 | export class GitHubStackMergePendingError extends Schema.TaggedError<GitHubStackMergePendingError>()( |
| 64 | "GitHubStackMergePendingError", |
| 65 | stackErrorIdentity, |
| 66 | ) { |
| 67 | override get message(): string { |
| 68 | return "The merge is still running on GitHub. Check its status there before submitting another request."; |
| 69 | } |
| 70 | } |
| 71 | |
| 72 | export class GitHubStackPermissionError extends Schema.TaggedError<GitHubStackPermissionError>()( |
| 73 | "GitHubStackPermissionError", |
| 74 | stackErrorIdentity, |
| 75 | ) { |
| 76 | override get message(): string { |
| 77 | return "You cannot update every branch in this stack. Check write access and fork maintainer permissions before retrying."; |
| 78 | } |
| 79 | } |
| 80 | |
| 81 | export class GitHubStackRebaseFailedError extends Schema.TaggedError<GitHubStackRebaseFailedError>()( |
| 82 | "GitHubStackRebaseFailedError", |
| 83 | { ...stackErrorIdentity, completed: Schema.Int, cause: Schema.Defect() }, |
| 84 | ) { |
| 85 | override get message(): string { |
| 86 | return this.cause instanceof Error && this.cause.message !== "" |
| 87 | ? this.cause.message |
| 88 | : `Stack rebase stopped at PR #${this.number} after ${this.completed} layers. Earlier updates remain on GitHub; resolve the failing layer before retrying.`; |
| 89 | } |
| 90 | } |
| 91 | |
| 92 | export type GitHubStackActionError = |
| 93 | | GitHubStackChangedError |
| 94 | | GitHubStackUnsupportedError |
| 95 | | GitHubStackResponseInvalidError |
| 96 | | GitHubStackMergeRejectedError |
| 97 | | GitHubStackMergePendingError |
| 98 | | GitHubStackPermissionError |
| 99 | | GitHubStackRebaseFailedError; |
| 100 | |
| 101 | const MergeResponse = Schema.Struct({ |
| 102 | status: Schema.Literals(["pending", "merged", "enqueued", "failed"]), |
| 103 | details: Schema.Struct({ |
| 104 | uuid: Schema.optional(Schema.String), |
| 105 | message: Schema.optional(Schema.String), |
| 106 | }), |
| 107 | }); |
| 108 | |
| 109 | const decodeMergeResponse = Schema.decodeEffect(Schema.fromJsonString(MergeResponse)); |
| 110 | |
| 111 | export const runGitHubStackAction = Effect.fn("runGitHubStackAction")(function* (input: { |
| 112 | cwd: string; |
| 113 | repository: string; |
| 114 | host: string; |
| 115 | number: number; |
| 116 | stackNumber: number; |
| 117 | expectedStackHeads?: ReadonlyArray<PullRequestStackHead>; |
| 118 | action: PullRequestAction; |
| 119 | mergeMethod?: PullRequestMergeMethod; |
| 120 | }) { |
| 121 | const api = yield* GitHubRest.GitHubRest; |
| 122 | const identity = { |
| 123 | repository: input.repository, |
| 124 | number: input.number, |
| 125 | stackNumber: input.stackNumber, |
| 126 | }; |
| 127 | if (input.action !== "merge" && input.action !== "update-branch") |
| 128 | return yield* new GitHubStackUnsupportedError({ ...identity }); |
| 129 | const endpoint = `repos/${input.repository}`; |
| 130 | const read = yield* api.rest({ |
| 131 | host: input.host, |
| 132 | operation: "runGitHubStackAction", |
| 133 | path: `${endpoint}/stacks?pull_request=${input.number}`, |
| 134 | }); |
| 135 | const decoded = decodePullRequestStacksJson(read.body); |
| 136 | if (Result.isFailure(decoded)) |
| 137 | return yield* new GitHubStackResponseInvalidError({ ...identity, cause: decoded.failure }); |
| 138 | const stack = decoded.success; |
| 139 | const targetIndex = stack?.layers.findIndex((layer) => layer.number === input.number) ?? -1; |
| 140 | const target = stack?.layers[targetIndex]; |
| 141 | if ( |
| 142 | stack?.number !== input.stackNumber || |
| 143 | target === undefined || |
| 144 | (input.action === "update-branch" && targetIndex !== stack.layers.length - 1) |
| 145 | ) { |
| 146 | return yield* new GitHubStackChangedError({ ...identity, number: input.number, completed: 0 }); |
| 147 | } |
| 148 | const affectedLayers = |
| 149 | input.action === "merge" ? stack.layers.slice(0, targetIndex + 1) : stack.layers; |
| 150 | const open = affectedLayers.filter((layer) => layer.state !== "merged"); |
| 151 | if (input.action === "merge" && target.state !== "open") |
| 152 | return yield* new GitHubStackUnsupportedError({ ...identity }); |
| 153 | if ( |
| 154 | !input.expectedStackHeads || |
| 155 | input.expectedStackHeads.length !== open.length || |
| 156 | new Set(input.expectedStackHeads.map((layer) => layer.number)).size !== open.length || |
| 157 | open.some( |
| 158 | (layer) => |
| 159 | !layer.headSha || |
| 160 | !input.expectedStackHeads?.some( |
| 161 | (expected) => expected.number === layer.number && expected.headSha === layer.headSha, |
| 162 | ), |
| 163 | ) |
| 164 | ) { |
| 165 | return yield* new GitHubStackChangedError({ ...identity, number: input.number, completed: 0 }); |
| 166 | } |
| 167 | if (open.length === 0 || open.some((layer) => layer.state !== "open")) |
| 168 | return yield* new GitHubStackUnsupportedError({ ...identity }); |
| 169 | if (input.action === "update-branch") { |
| 170 | const [owner, name] = input.repository.split("/"); |
| 171 | const client = yield* GraphQLClient.make( |
| 172 | StackActionsGraphQLGroup.middleware(GitHubGraphQlClient.GitHubGraphQlAuth), |
| 173 | ).pipe(Effect.provide(GitHubGraphQlClient.layer)); |
| 174 | const resolver = GraphQLResolver.aliased(client.PullRequestBranchAccess, { |
| 175 | batchKey: GitHubGraphQlClient.batchKey, |
| 176 | }).pipe(RequestResolver.batchN(open.length)); |
| 177 | const access = yield* Effect.forEach( |
| 178 | open, |
| 179 | (layer) => |
| 180 | GraphQLResolver.request({ owner: owner!, name: name!, number: layer.number }, resolver), |
| 181 | { concurrency: "unbounded" }, |
| 182 | ).pipe( |
| 183 | GitHubGraphQlClient.call({ |
| 184 | host: input.host, |
| 185 | operation: "runGitHubStackAction", |
| 186 | allowReserve: true, |
| 187 | }), |
| 188 | Effect.catchIf( |
| 189 | GraphQLClientError.isGraphQLClientError, |
| 190 | (cause) => new GitHubStackResponseInvalidError({ ...identity, cause }), |
| 191 | ), |
| 192 | ); |
| 193 | // Current layers report viewerCanUpdateBranch=false even if restacking could make them stale. |
| 194 | if ( |
| 195 | access.some(({ repository }) => { |
| 196 | const pr = repository?.pullRequest; |
| 197 | return ( |
| 198 | !pr?.headRepository || |
| 199 | (!pr.maintainerCanModify && !toCanWrite(pr.headRepository.viewerPermission)) |
| 200 | ); |
| 201 | }) |
| 202 | ) |
| 203 | return yield* new GitHubStackPermissionError({ ...identity }); |
| 204 | const mergedHeadSha = stack.layers[stack.layers.indexOf(open[0]!) - 1]?.headSha; |
| 205 | // GitHub has no stack-rebase API; per-PR updates replay lower layers' old commits. |
| 206 | yield* cascadeRebaseStack({ |
| 207 | host: input.host, |
| 208 | repository: input.repository, |
| 209 | base: stack.base, |
| 210 | layers: open.map((layer) => ({ |
| 211 | number: layer.number, |
| 212 | headBranch: layer.headBranch, |
| 213 | headSha: layer.headSha!, |
| 214 | })), |
| 215 | ...(mergedHeadSha === undefined ? {} : { mergedHeadSha }), |
| 216 | }).pipe( |
| 217 | Effect.mapError((cause) => |
| 218 | cause._tag === "GitHubStackRebaseConflictError" || |
| 219 | cause._tag === "GitHubStackRebaseGitError" |
| 220 | ? new GitHubStackRebaseFailedError({ |
| 221 | ...identity, |
| 222 | number: cause.number, |
| 223 | completed: cause.completed, |
| 224 | cause, |
| 225 | }) |
| 226 | : cause, |
| 227 | ), |
| 228 | ); |
| 229 | return; |
| 230 | } |
| 231 | if (open.some((layer) => layer.isDraft)) |
| 232 | return yield* new GitHubStackUnsupportedError({ ...identity }); |
| 233 | const decode = (raw: string) => |
| 234 | decodeMergeResponse(raw).pipe( |
| 235 | Effect.mapError((cause) => new GitHubStackResponseInvalidError({ ...identity, cause })), |
| 236 | ); |
| 237 | const request = yield* api.rest({ |
| 238 | host: input.host, |
| 239 | operation: "runGitHubStackAction", |
| 240 | method: "PUT", |
| 241 | path: `${endpoint}/pulls/${input.number}/merge-async`, |
| 242 | body: { |
| 243 | merge_method: input.mergeMethod ?? "merge", |
| 244 | merge_action: "default", |
| 245 | sha: target.headSha, |
| 246 | }, |
| 247 | }); |
| 248 | let result = yield* decode(request.body); |
| 249 | const deadline = (yield* Clock.currentTimeMillis) + 5 * 60_000; |
| 250 | for ( |
| 251 | let attempt = 0; |
| 252 | result.status === "pending" && (yield* Clock.currentTimeMillis) < deadline; |
| 253 | attempt++ |
| 254 | ) { |
| 255 | const uuid = result.details.uuid; |
| 256 | if (!uuid) return yield* new GitHubStackResponseInvalidError({ ...identity }); |
| 257 | yield* Effect.sleep(Math.min(1_000 * 2 ** attempt, 10_000)); |
| 258 | const poll = yield* api.rest({ |
| 259 | host: input.host, |
| 260 | operation: "runGitHubStackAction", |
| 261 | path: `${endpoint}/pulls/${input.number}/merge-async/${encodeURIComponent(uuid)}`, |
| 262 | }); |
| 263 | result = yield* decode(poll.body); |
| 264 | } |
| 265 | if (result.status === "pending") return yield* new GitHubStackMergePendingError({ ...identity }); |
| 266 | if (result.status === "failed") |
| 267 | return yield* new GitHubStackMergeRejectedError({ ...identity, cause: result }); |
| 268 | }); |