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

main
ts 355 lines 11.1 KB
Raw
1 import * as cloudidentity from "@distilled.cloud/gcp/cloudidentity_v1";
2 import { Unowned } from "alchemy/AdoptPolicy";
3 import { isResolved } from "alchemy/Diff";
4 import * as Provider from "alchemy/Provider";
5 import { Resource } from "alchemy/Resource";
6 import * as Data from "effect/Data";
7 import * as Effect from "effect/Effect";
8 import type { Providers } from "../Providers.ts";
9 import {
10 expandGroup,
11 getMembership,
12 getMembershipByKey,
13 lastSegment,
14 listMemberships,
15 listOwnedGroups,
16 replaceOnIdentity,
17 sameJson,
18 sameText,
19 } from "./internal.ts";
20 import { resourceNameFromOperation, waitForOperation, waitUntilPresent } from "./operations.ts";
21
22 export type GroupsMembershipRole = {
23 /** Role name: `OWNER`, `MANAGER`, or `MEMBER`. */
24 name?: string;
25 /** Expiry, only valid when `name` is `MEMBER`. */
26 expiryDetail?: {
27 expireTime?: string;
28 };
29 };
30
31 export type GroupsMembershipProps = {
32 /**
33 * Parent group resource name (`groups/{group}`) or group id.
34 * Immutable — changing it replaces the membership.
35 */
36 parent: string;
37 /**
38 * Member entity key id (user or group email). Immutable —
39 * changing it replaces the membership.
40 */
41 memberKeyId: string;
42 /**
43 * Member entity-key namespace for external identities.
44 */
45 memberKeyNamespace?: string;
46 /**
47 * Roles for the membership. Defaults to a single `MEMBER` role.
48 * `MEMBER` cannot be removed; drop `MANAGER` / `OWNER` in place.
49 */
50 roles?: GroupsMembershipRole[];
51 };
52
53 export type GroupsMembership = Resource<
54 "GCP.CloudIdentity.GroupsMembership",
55 GroupsMembershipProps,
56 {
57 /** Resource name `groups/{group}/memberships/{membership}`. */
58 name: string;
59 /** Membership id (last path segment). */
60 membershipId: string;
61 /** Parent group name. */
62 parent: string;
63 /** Member entity key id. */
64 memberKeyId: string;
65 /** Member entity-key namespace, if any. */
66 memberKeyNamespace: string | undefined;
67 /** Membership roles. */
68 roles: GroupsMembershipRole[];
69 /** Member type (`USER`, `GROUP`, …). */
70 type: string | undefined;
71 /** Delivery setting. */
72 deliverySetting: string | undefined;
73 /** RFC3339 creation timestamp. */
74 createTime: string | undefined;
75 /** RFC3339 last-update timestamp. */
76 updateTime: string | undefined;
77 },
78 never,
79 Providers
80 >;
81
82 /**
83 * A Cloud Identity group membership.
84 *
85 * Memberships have no labels or description, so Alchemy lists
86 * memberships of alchemy-owned groups (ownership stamped on the parent
87 * group description) for `list` / nuke. Parent group and member key
88 * are identity; roles update in place via `modifyMembershipRoles`.
89 *
90 * ### Creating a Membership
91 * **Example:** Add a member
92 * ```typescript
93 * const membership = yield* GCP.CloudIdentity.GroupsMembership("Ada", {
94 * parent: group.name,
95 * memberKeyId: "ada@example.com",
96 * });
97 * ```
98 *
99 * **Example:** Manager role
100 * ```typescript
101 * const membership = yield* GCP.CloudIdentity.GroupsMembership("Ada", {
102 * parent: group.name,
103 * memberKeyId: "ada@example.com",
104 * roles: [{ name: "MEMBER" }, { name: "MANAGER" }],
105 * });
106 * ```
107 *
108 * @resource
109 * @category CloudIdentity
110 */
111 export const GroupsMembership = Resource<GroupsMembership>("GCP.CloudIdentity.GroupsMembership");
112
113 export class GroupsMembershipNotResolved extends Data.TaggedError(
114 "GCP.CloudIdentity.GroupsMembershipNotResolved",
115 )<{
116 parent: string;
117 memberKeyId: string;
118 }> {}
119
120 const DEFAULT_ROLES: GroupsMembershipRole[] = [{ name: "MEMBER" }];
121
122 const rolesOf = (roles: cloudidentity.MembershipRoleList | undefined): GroupsMembershipRole[] =>
123 (roles ?? DEFAULT_ROLES).map((role) => ({
124 name: role.name,
125 expiryDetail: role.expiryDetail ? { expireTime: role.expiryDetail.expireTime } : undefined,
126 }));
127
128 const desiredRoles = (roles: GroupsMembershipRole[] | undefined) => {
129 const next = roles !== undefined && roles.length > 0 ? roles : DEFAULT_ROLES;
130 return next.map((role) => ({
131 name: role.name ?? "MEMBER",
132 expiryDetail: role.expiryDetail,
133 }));
134 };
135
136 const roleNames = (roles: GroupsMembershipRole[]) =>
137 [...roles].map((role) => role.name ?? "MEMBER").sort((left, right) => left.localeCompare(right));
138
139 const parentOfName = (name: string) => {
140 const parts = name.split("/").filter((part) => part.length > 0);
141 const index = parts.lastIndexOf("memberships");
142 return index > 0 ? parts.slice(0, index).join("/") : expandGroup(name);
143 };
144
145 const toAttrs = (membership: cloudidentity.Membership, parent: string) => {
146 const name = membership.name ?? "";
147 return {
148 name,
149 membershipId: lastSegment(name),
150 parent: parentOfName(name) || parent,
151 memberKeyId: membership.preferredMemberKey?.id ?? "",
152 memberKeyNamespace: membership.preferredMemberKey?.namespace,
153 roles: rolesOf(membership.roles),
154 type: membership.type,
155 deliverySetting: membership.deliverySetting,
156 createTime: membership.createTime,
157 updateTime: membership.updateTime,
158 };
159 };
160
161 const observeMembership = (input: {
162 name?: string;
163 parent: string;
164 memberKeyId: string;
165 memberKeyNamespace?: string;
166 }) =>
167 Effect.gen(function* () {
168 const byName = yield* getMembership(input.name ?? "");
169 if (byName !== undefined) return byName;
170 return yield* getMembershipByKey(input.parent, input.memberKeyId, input.memberKeyNamespace);
171 });
172
173 const syncRoles = (
174 name: string,
175 current: cloudidentity.Membership,
176 desired: GroupsMembershipRole[],
177 ) =>
178 Effect.gen(function* () {
179 const observed = rolesOf(current.roles);
180 if (sameJson(observed, desired)) return current;
181
182 const currentNames = new Set(roleNames(observed));
183 const desiredNames = new Set(roleNames(desired));
184 const addRoles = desired.filter((role) => !currentNames.has(role.name ?? "MEMBER"));
185 const removeRoles = roleNames(observed).filter(
186 (role) => role !== "MEMBER" && !desiredNames.has(role),
187 );
188
189 let next = current;
190 if (addRoles.length > 0 || removeRoles.length > 0) {
191 const modified = yield* cloudidentity.modifyMembershipRolesGroupsMemberships({
192 name,
193 body: {
194 addRoles: addRoles.length > 0 ? addRoles : undefined,
195 removeRoles: removeRoles.length > 0 ? removeRoles : undefined,
196 },
197 });
198 next = modified.membership ?? next;
199 }
200
201 const memberExpiry = desired.find((role) => role.name === "MEMBER")?.expiryDetail?.expireTime;
202 const observedExpiry = rolesOf(next.roles).find((role) => role.name === "MEMBER")?.expiryDetail
203 ?.expireTime;
204 if (!sameText(memberExpiry, observedExpiry) && memberExpiry !== undefined) {
205 const modified = yield* cloudidentity.modifyMembershipRolesGroupsMemberships({
206 name,
207 body: {
208 updateRolesParams: [
209 {
210 fieldMask: "expiry_detail.expire_time",
211 membershipRole: {
212 name: "MEMBER",
213 expiryDetail: { expireTime: memberExpiry },
214 },
215 },
216 ],
217 },
218 });
219 next = modified.membership ?? next;
220 }
221
222 return next;
223 });
224
225 export const GroupsMembershipProvider = () =>
226 Provider.succeed(GroupsMembership, {
227 stables: ["name", "membershipId", "parent", "memberKeyId", "createTime"],
228
229 diff: Effect.fn(function* ({ news, olds, output }) {
230 if (!isResolved(news)) return undefined;
231 return replaceOnIdentity({
232 previousId: olds?.memberKeyId ?? output?.memberKeyId,
233 nextId: news.memberKeyId,
234 previousParent: olds?.parent ?? output?.parent,
235 nextParent: expandGroup(news.parent),
236 extra:
237 news.memberKeyNamespace !== undefined &&
238 output?.memberKeyNamespace !== undefined &&
239 news.memberKeyNamespace !== output.memberKeyNamespace,
240 });
241 }),
242
243 read: Effect.fn(function* ({ olds, output }) {
244 const parent = expandGroup(olds?.parent ?? output?.parent ?? "");
245 const memberKeyId = olds?.memberKeyId ?? output?.memberKeyId ?? "";
246 const existing = yield* observeMembership({
247 name: output?.name,
248 parent,
249 memberKeyId,
250 memberKeyNamespace: olds?.memberKeyNamespace ?? output?.memberKeyNamespace,
251 });
252 if (existing === undefined) return undefined;
253 const attrs = toAttrs(existing, parent);
254 return output !== undefined ? attrs : Unowned(attrs);
255 }),
256
257 list: () =>
258 Effect.gen(function* () {
259 const groups = yield* listOwnedGroups();
260 const pages = yield* Effect.forEach(
261 groups,
262 (group) =>
263 group.name
264 ? listMemberships(group.name).pipe(
265 Effect.map((memberships) =>
266 memberships.map((membership) => toAttrs(membership, group.name ?? "")),
267 ),
268 )
269 : Effect.succeed([]),
270 { concurrency: 4 },
271 );
272 return pages.flat();
273 }),
274
275 reconcile: Effect.fn(function* ({ news, output }) {
276 const parent = expandGroup(news.parent);
277 const memberKeyId = news.memberKeyId;
278 const memberKeyNamespace = news.memberKeyNamespace;
279 const roles = desiredRoles(news.roles);
280
281 let current = yield* observeMembership({
282 name: output?.name,
283 parent,
284 memberKeyId,
285 memberKeyNamespace,
286 });
287
288 if (current === undefined) {
289 const created = yield* cloudidentity
290 .createGroupsMemberships({
291 parent,
292 body: {
293 preferredMemberKey: {
294 id: memberKeyId,
295 namespace: memberKeyNamespace,
296 },
297 roles,
298 },
299 })
300 .pipe(Effect.catchTag("Conflict", () => Effect.undefined));
301 if (created !== undefined) {
302 yield* waitForOperation(created).pipe(
303 Effect.catchTag("GCP.CloudIdentity.OperationPending", () => Effect.void),
304 );
305 const createdName = resourceNameFromOperation(created);
306 if (createdName !== undefined) {
307 current = yield* getMembership(createdName);
308 }
309 }
310 if (current === undefined) {
311 current = yield* waitUntilPresent(
312 observeMembership({
313 name: output?.name,
314 parent,
315 memberKeyId,
316 memberKeyNamespace,
317 }),
318 memberKeyId,
319 ).pipe(
320 Effect.catchTag("GCP.CloudIdentity.OperationPending", () =>
321 observeMembership({
322 parent,
323 memberKeyId,
324 memberKeyNamespace,
325 }),
326 ),
327 );
328 }
329 }
330
331 if (current === undefined) {
332 return yield* new GroupsMembershipNotResolved({
333 parent,
334 memberKeyId,
335 });
336 }
337
338 const name = current.name ?? output?.name ?? "";
339 if (name.length > 0) {
340 current = yield* syncRoles(name, current, roles);
341 }
342
343 return toAttrs(current, parent);
344 }),
345
346 delete: Effect.fn(function* ({ output }) {
347 if (output.name.length === 0) return;
348 const deleted = yield* cloudidentity
349 .deleteGroupsMemberships({ name: output.name })
350 .pipe(Effect.catchTag("NotFound", () => Effect.undefined));
351 if (deleted !== undefined) {
352 yield* waitForOperation(deleted, { notFoundOk: true });
353 }
354 }),
355 });