@devries-cameron20 / t3code Mirror · read-only
Fork 0

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

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 04:45 UTC

main
ts 459 lines 12.5 KB
Raw
1 import * as Repos from "@distilled.cloud/github/repos";
2 import { isResolved } from "alchemy/Diff";
3 import * as Provider from "alchemy/Provider";
4 import { Resource } from "alchemy/Resource";
5 import { dedent } from "alchemy/Util/dedent";
6 import * as Effect from "effect/Effect";
7 import * as Option from "effect/Option";
8 import * as Stream from "effect/Stream";
9 import { withBaseUrl, gitHubBaseUrlChanged } from "./BaseUrl.ts";
10 import type * as GitHub from "./Providers.ts";
11
12 export interface ReleaseProps {
13 /**
14 * Repository owner (user or organization).
15 */
16 owner: string;
17
18 /**
19 * Repository name.
20 */
21 repository: string;
22
23 /**
24 * Git tag name for this release. The tag is the release's identity —
25 * changing it replaces the release.
26 */
27 tagName: string;
28
29 /**
30 * Release title/name. If omitted, GitHub uses the tag name.
31 */
32 name?: string;
33
34 /**
35 * Release notes/description (supports GitHub Markdown).
36 *
37 * The body is automatically dedented, so you can use indented template
38 * literals without worrying about leading whitespace. Accepts
39 * `Output<string>` at the call site via `Output.interpolate` to embed
40 * resource attributes that are not yet resolved.
41 */
42 body?: string;
43
44 /**
45 * Whether this is a draft release (not visible to users).
46 * @default false
47 */
48 draft?: boolean;
49
50 /**
51 * Whether this is a prerelease (beta, alpha, etc.).
52 * @default false
53 */
54 prerelease?: boolean;
55
56 /**
57 * Commitish (branch, commit SHA, or tag) to target. If the tag doesn't
58 * exist, the release will create it from this commitish. If omitted,
59 * GitHub defaults to the repository's default branch.
60 */
61 targetCommitish?: string;
62
63 /**
64 * Whether to automatically generate release notes from commits.
65 * @default false
66 */
67 generateReleaseNotes?: boolean;
68
69 /**
70 * Override the GitHub host or API base URL for this resource only (e.g.
71 * `github.example.com` for GitHub Enterprise). Falls back to
72 * `GitHub.providers({ baseUrl })`, then to the host resolved by the auth
73 * provider. Changing it replaces the resource — the same name on a
74 * different GitHub instance is a different physical resource.
75 */
76 baseUrl?: string;
77 }
78
79 export interface Release extends Resource<
80 "GitHub.Release",
81 ReleaseProps,
82 {
83 /**
84 * Numeric release ID.
85 */
86 releaseId: number;
87
88 /**
89 * GraphQL node ID of the release.
90 */
91 nodeId: string;
92
93 /**
94 * The git tag name.
95 */
96 tagName: string;
97
98 /**
99 * The release name/title.
100 */
101 name: string;
102
103 /**
104 * Release notes/description.
105 */
106 body: string;
107
108 /**
109 * Whether this is a draft release.
110 */
111 draft: boolean;
112
113 /**
114 * Whether this is a prerelease.
115 */
116 prerelease: boolean;
117
118 /**
119 * URL to view the release in a browser.
120 */
121 htmlUrl: string;
122
123 /**
124 * URL for uploading release assets.
125 */
126 uploadUrl: string;
127
128 /**
129 * ISO-8601 timestamp of when the release was created.
130 */
131 createdAt: string;
132
133 /**
134 * ISO-8601 timestamp of when the release was published.
135 */
136 publishedAt: string | null;
137 },
138 never,
139 GitHub.Providers
140 > {}
141
142 /**
143 * A GitHub release.
144 *
145 * `Release` manages repository releases (tagged versions with notes,
146 * binaries, etc.). Releases are created on first deploy and updated in place
147 * on subsequent deploys when properties change. Publishing a draft converts it
148 * to a public release.
149 *
150 * Authentication is resolved via the GitHub `Credentials` service supplied by
151 * `GitHub.providers()` (env, stored PAT, `gh` CLI, or OAuth). The token needs
152 * `repo` scope for private repositories or `public_repo` for public ones.
153 * ### Creating Releases
154 * **Example:** Basic Release
155 * ```typescript
156 * const v1 = yield* GitHub.Release("v1", {
157 * owner: "my-org",
158 * repository: "my-repo",
159 * tagName: "v1.0.0",
160 * name: "Version 1.0.0",
161 * body: "First stable release",
162 * });
163 * ```
164 *
165 * **Example:** Prerelease
166 * ```typescript
167 * yield* GitHub.Release("beta", {
168 * owner: "my-org",
169 * repository: "my-repo",
170 * tagName: "v2.0.0-beta.1",
171 * name: "v2.0.0 Beta 1",
172 * body: "Beta release for testing",
173 * prerelease: true,
174 * });
175 * ```
176 *
177 * ### Draft Releases
178 * **Example:** Create Draft and Publish Later
179 * ```typescript
180 * // First deploy: create as draft
181 * const release = yield* GitHub.Release("v1", {
182 * owner: "my-org",
183 * repository: "my-repo",
184 * tagName: "v1.0.0",
185 * name: "Version 1.0.0",
186 * body: "Release notes here",
187 * draft: true,
188 * });
189 *
190 * // Later deploy: publish by setting draft: false
191 * const release = yield* GitHub.Release("v1", {
192 * owner: "my-org",
193 * repository: "my-repo",
194 * tagName: "v1.0.0",
195 * name: "Version 1.0.0",
196 * body: "Release notes here",
197 * draft: false,
198 * });
199 * ```
200 *
201 * ### Auto-Generated Release Notes
202 * **Example:** Generate Notes from Commits
203 * ```typescript
204 * yield* GitHub.Release("v1", {
205 * owner: "my-org",
206 * repository: "my-repo",
207 * tagName: "v1.1.0",
208 * name: "Version 1.1.0",
209 * generateReleaseNotes: true,
210 * });
211 * ```
212 *
213 * ### Targeting Specific Commits
214 * **Example:** Release from Branch or Commit
215 * ```typescript
216 * yield* GitHub.Release("hotfix", {
217 * owner: "my-org",
218 * repository: "my-repo",
219 * tagName: "v1.0.1",
220 * name: "Hotfix 1.0.1",
221 * body: "Critical bug fix",
222 * targetCommitish: "hotfix-branch",
223 * });
224 * ```
225 *
226 * ### Updating Releases
227 * Deploy with the same logical ID and tag to update the existing release.
228 *
229 * **Example:** Update Release Notes
230 * ```typescript
231 * yield* GitHub.Release("v1", {
232 * owner: "my-org",
233 * repository: "my-repo",
234 * tagName: "v1.0.0",
235 * name: "Version 1.0.0",
236 * body: `
237 * # What's New
238 *
239 * - Feature A
240 * - Feature B
241 * - Bug fixes
242 * `,
243 * });
244 * ```
245 *
246 * ### Replacing on Tag Change
247 * Changing the tag creates a new release and deletes the old one.
248 *
249 * **Example:** New Tag = New Release
250 * ```typescript
251 * // First deploy creates v1.0.0
252 * const release = yield* GitHub.Release("latest", {
253 * owner: "my-org",
254 * repository: "my-repo",
255 * tagName: "v1.0.0",
256 * });
257 *
258 * // Later deploy with different tag replaces it
259 * const release = yield* GitHub.Release("latest", {
260 * owner: "my-org",
261 * repository: "my-repo",
262 * tagName: "v1.1.0",
263 * });
264 * ```
265 *
266 * ### Wiring with Other Resources
267 * **Example:** Create Repository with Release
268 * ```typescript
269 * import * as Output from "alchemy/Output";
270 *
271 * const repo = yield* GitHub.Repository("sdk", {
272 * owner: "my-org",
273 * name: "sdk",
274 * autoInit: true,
275 * });
276 *
277 * yield* GitHub.Release("v1", {
278 * owner: "my-org",
279 * repository: Output.map(repo.fullName, (fullName) => fullName.split("/")[1]!),
280 * tagName: "v1.0.0",
281 * name: "Initial Release",
282 * body: "First public version of the SDK",
283 * });
284 * ```
285 *
286 * @resource
287 * @product Release
288 */
289 export const Release = Resource<Release>("GitHub.Release");
290
291 export const ReleaseProvider = () =>
292 Provider.succeed(Release, {
293 stables: ["releaseId", "nodeId"],
294
295 // A release belongs to (host, owner, repository, tagName) — changing any
296 // of these replaces the resource.
297 diff: Effect.fn(function* ({ news, olds }) {
298 if (!isResolved(news)) return;
299 if (olds === undefined) return;
300 if (
301 news.owner !== olds.owner ||
302 news.repository !== olds.repository ||
303 news.tagName !== olds.tagName ||
304 (yield* gitHubBaseUrlChanged(olds, news))
305 ) {
306 return { action: "replace" };
307 }
308 }),
309
310 read: Effect.fn(function* ({ olds, output }) {
311 const observed = yield* findRelease(olds, output?.releaseId);
312 return observed === undefined ? undefined : attrsOf(observed);
313 }),
314
315 reconcile: Effect.fn(
316 function* ({ news, output }) {
317 const body = news.body !== undefined ? dedent(news.body) : undefined;
318 let observed = yield* findRelease(news, output?.releaseId);
319
320 if (observed === undefined) {
321 observed = yield* Repos.createRelease({
322 owner: news.owner,
323 repo: news.repository,
324 tag_name: news.tagName,
325 name: news.name,
326 body,
327 draft: news.draft,
328 prerelease: news.prerelease,
329 target_commitish: news.targetCommitish,
330 generate_release_notes: news.generateReleaseNotes,
331 }).pipe(
332 // A 422 is a create race (the tag already has a release): re-observe.
333 Effect.catchTag("UnprocessableEntity", (error) =>
334 findRelease(news).pipe(
335 Effect.flatMap((release) =>
336 release === undefined ? Effect.fail(error) : Effect.succeed(release),
337 ),
338 ),
339 ),
340 );
341 }
342
343 const desired = {
344 name: news.name ?? news.tagName,
345 body: body ?? (news.generateReleaseNotes ? (observed.body ?? "") : ""),
346 draft: news.draft ?? false,
347 prerelease: news.prerelease ?? false,
348 };
349 if (
350 (observed.name ?? observed.tag_name) === desired.name &&
351 (observed.body ?? "") === desired.body &&
352 observed.draft === desired.draft &&
353 observed.prerelease === desired.prerelease
354 ) {
355 return attrsOf(observed);
356 }
357
358 return attrsOf(
359 yield* Repos.updateRelease({
360 owner: news.owner,
361 repo: news.repository,
362 release_id: observed.id,
363 tag_name: news.tagName,
364 ...desired,
365 }),
366 );
367 },
368 (effect, { news }) => effect.pipe(withBaseUrl(news.baseUrl)),
369 ),
370
371 // Enumerate every release across the repositories the token can see —
372 // releases are keyed by {owner, repository, tagName} with no account-wide
373 // list endpoint, so walk the repos like the Variable provider does.
374 list: Effect.fn(function* () {
375 const repos = yield* Stream.runCollect(
376 Repos.listForAuthenticatedUser.items({ per_page: 100 }),
377 );
378 const perRepo = yield* Effect.forEach(
379 repos,
380 (repo) =>
381 Stream.runCollect(
382 Repos.listReleases.items({
383 owner: repo.owner.login,
384 repo: repo.name,
385 per_page: 100,
386 }),
387 ).pipe(
388 Effect.map((releases) => releases.map(attrsOf)),
389 // Repos where the token lacks release access reject with 403/404 —
390 // skip them rather than failing the whole enumeration.
391 Effect.catchTag(["Forbidden", "NotFound"], () => Effect.succeed([])),
392 ),
393 { concurrency: 10 },
394 );
395 return perRepo.flat();
396 }),
397
398 delete: Effect.fn(
399 function* ({ olds, output }) {
400 yield* Repos.deleteRelease({
401 owner: olds.owner,
402 repo: olds.repository,
403 release_id: output.releaseId,
404 }).pipe(Effect.catchTag("NotFound", () => Effect.void));
405 },
406 (effect, { olds }) => effect.pipe(withBaseUrl(olds.baseUrl)),
407 ),
408 });
409
410 const findRelease = Effect.fn(
411 function* (props: ReleaseProps, releaseId?: number) {
412 const request = { owner: props.owner, repo: props.repository };
413 if (releaseId !== undefined) {
414 const existing = yield* Repos.getRelease({ ...request, release_id: releaseId }).pipe(
415 Effect.catchTag("NotFound", () => Effect.undefined),
416 );
417 if (existing !== undefined && existing.tag_name === props.tagName) return existing;
418 }
419 const published = yield* Repos.getReleaseByTag({ ...request, tag: props.tagName }).pipe(
420 Effect.catchTag("NotFound", () => Effect.undefined),
421 );
422 if (published !== undefined) return published;
423
424 // The tag endpoint excludes drafts, including drafts recovered without state.
425 return yield* Repos.listReleases.items({ ...request, per_page: 100 }).pipe(
426 Stream.filter((release) => release.tag_name === props.tagName),
427 Stream.runHead,
428 Effect.map(Option.getOrUndefined),
429 Effect.catchTag("NotFound", () => Effect.undefined),
430 );
431 },
432 (effect, props: ReleaseProps, _releaseId?: number) => effect.pipe(withBaseUrl(props.baseUrl)),
433 );
434
435 const attrsOf = (data: {
436 id: number;
437 node_id: string;
438 tag_name: string;
439 name: string | null;
440 body?: string | null;
441 draft: boolean;
442 prerelease: boolean;
443 html_url: string;
444 upload_url: string;
445 created_at: string;
446 published_at: string | null;
447 }) => ({
448 releaseId: data.id,
449 nodeId: data.node_id,
450 tagName: data.tag_name,
451 name: data.name ?? data.tag_name,
452 body: data.body ?? "",
453 draft: data.draft,
454 prerelease: data.prerelease,
455 htmlUrl: data.html_url,
456 uploadUrl: data.upload_url,
457 createdAt: data.created_at,
458 publishedAt: data.published_at,
459 });