@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 382 lines 13.1 KB
Raw
1 import * as pubsub from "@distilled.cloud/gcp/pubsub_v1";
2 import * as we from "@distilled.cloud/gcp/workspaceevents_v1";
3 import { createPhysicalName } from "alchemy/PhysicalName";
4 import { tagRecord } from "alchemy/Tags";
5 import * as Data from "effect/Data";
6 import * as Effect from "effect/Effect";
7 import * as Schedule from "effect/Schedule";
8 import * as Stream from "effect/Stream";
9 import { alchemyLabelKeys, createInternalLabels, sanitizeLabelValue } from "../Labels.ts";
10 import { waitForOperation as waitForGcpOperation } from "../Operation.ts";
11
12 export const SUBSCRIPTION_PREFIX = "subscriptions/";
13 export const TASK_PREFIX = "tasks/";
14 export const CONFIG_COLLECTION = "pushNotificationConfigs";
15 export const MAX_CONFIG_ID_LENGTH = 63;
16 export const MAX_TOPIC_ID_LENGTH = 255;
17 export const MAX_TOKEN_LENGTH = 8000;
18
19 export const WESUB_LABEL_KEYS = {
20 stack: "alchemy-wesub-stack",
21 stage: "alchemy-wesub-stage",
22 id: "alchemy-wesub-id",
23 } as const;
24
25 export const LIST_EVENT_TYPES = [
26 "google.workspace.chat.message.v1.created",
27 "google.workspace.chat.message.v1.updated",
28 "google.workspace.chat.message.v1.deleted",
29 "google.workspace.chat.membership.v1.created",
30 "google.workspace.chat.membership.v1.updated",
31 "google.workspace.chat.membership.v1.deleted",
32 "google.workspace.chat.reaction.v1.created",
33 "google.workspace.chat.reaction.v1.deleted",
34 "google.workspace.chat.space.v1.updated",
35 "google.workspace.chat.space.v1.deleted",
36 "google.workspace.meet.conference.v2.started",
37 "google.workspace.meet.conference.v2.ended",
38 "google.workspace.meet.participant.v2.joined",
39 "google.workspace.meet.participant.v2.left",
40 "google.workspace.meet.recording.v2.fileGenerated",
41 "google.workspace.meet.transcript.v2.fileGenerated",
42 "google.workspace.drive.file.v3.created",
43 "google.workspace.drive.file.v3.updated",
44 "google.workspace.drive.file.v3.deleted",
45 ] as const;
46
47 export class ResourceNotResolved extends Data.TaggedError(
48 "GCP.WorkspaceEvents.ResourceNotResolved",
49 )<{
50 resourceName: string;
51 }> {}
52
53 export class ResourceStillExists extends Data.TaggedError(
54 "GCP.WorkspaceEvents.ResourceStillExists",
55 )<{
56 resourceName: string;
57 }> {}
58
59 export const lastSegment = (value: string) => {
60 const trimmed = value.replace(/\/+$/, "");
61 const parts = trimmed.split("/");
62 return parts[parts.length - 1] || trimmed;
63 };
64
65 export const sameText = (left: string | undefined, right: string | undefined) =>
66 (left ?? "") === (right ?? "");
67
68 export const sameBoolean = (left: boolean | undefined, right: boolean | undefined) =>
69 (left ?? false) === (right ?? false);
70
71 export const jsonEqual = (left: unknown, right: unknown) =>
72 JSON.stringify(left ?? null) === JSON.stringify(right ?? null);
73
74 export const sortedStrings = (values: readonly string[] | undefined) =>
75 [...(values ?? [])].slice().sort();
76
77 export const updateMaskOf = (...fields: Array<string | undefined>) =>
78 fields.filter((field): field is string => field !== undefined).join(",");
79
80 export const rfc1035 = (
81 name: string,
82 fallback = "config",
83 maxLength = MAX_CONFIG_ID_LENGTH,
84 ): string => {
85 let next = name
86 .toLowerCase()
87 .replace(/[^a-z0-9-]/g, "-")
88 .replace(/-+/g, "-")
89 .replace(/^-+/, "")
90 .replace(/-+$/, "");
91 if (!/^[a-z]/.test(next)) next = `w${next}`;
92 next = next.slice(0, maxLength).replace(/-+$/, "");
93 if (next.length === 0) return fallback;
94 if (!/[a-z0-9]$/.test(next)) {
95 next = `${next.slice(0, maxLength - 1)}0`;
96 }
97 return next.slice(0, maxLength);
98 };
99
100 export const toPhysicalId = (
101 id: string,
102 explicit: string | undefined,
103 existing: string | undefined,
104 fallback: string,
105 maxLength: number,
106 ) =>
107 Effect.gen(function* () {
108 if (explicit !== undefined && explicit.length > 0) {
109 return rfc1035(explicit, fallback, maxLength);
110 }
111 if (existing !== undefined && existing.length > 0) {
112 return existing;
113 }
114 return rfc1035(
115 yield* createPhysicalName({
116 id,
117 maxLength,
118 lowercase: true,
119 }),
120 fallback,
121 maxLength,
122 );
123 });
124
125 export const wesubLabels = (id: string) =>
126 Effect.gen(function* () {
127 const internal = yield* createInternalLabels(id);
128 const labels: Record<string, string> = {
129 [WESUB_LABEL_KEYS.stack]: internal[alchemyLabelKeys.stack] ?? sanitizeLabelValue("x"),
130 [WESUB_LABEL_KEYS.stage]: internal[alchemyLabelKeys.stage] ?? sanitizeLabelValue("x"),
131 [WESUB_LABEL_KEYS.id]: internal[alchemyLabelKeys.id] ?? sanitizeLabelValue("x"),
132 };
133 return labels;
134 });
135
136 export const hasWesubLabels = (labels: Record<string, string | undefined> | null | undefined) =>
137 Object.keys(labels ?? {}).some(
138 (key) => key.startsWith("alchemy-wesub-") || key.startsWith("alchemy-"),
139 );
140
141 const prefixMatch = (expected: string, observed: string) =>
142 expected === observed || expected.startsWith(observed) || observed.startsWith(expected);
143
144 export const ownedByWesubLabels = (
145 id: string,
146 labels: Record<string, string | undefined> | null | undefined,
147 ) =>
148 Effect.gen(function* () {
149 const expected = yield* wesubLabels(id);
150 const observed = tagRecord(labels);
151 if (!hasWesubLabels(observed)) return false;
152 const exact =
153 observed[WESUB_LABEL_KEYS.stack] === expected[WESUB_LABEL_KEYS.stack] &&
154 observed[WESUB_LABEL_KEYS.stage] === expected[WESUB_LABEL_KEYS.stage] &&
155 observed[WESUB_LABEL_KEYS.id] === expected[WESUB_LABEL_KEYS.id];
156 if (exact) return true;
157 return (
158 prefixMatch(expected[WESUB_LABEL_KEYS.stack] ?? "", observed[WESUB_LABEL_KEYS.stack] ?? "") &&
159 prefixMatch(expected[WESUB_LABEL_KEYS.stage] ?? "", observed[WESUB_LABEL_KEYS.stage] ?? "") &&
160 prefixMatch(expected[WESUB_LABEL_KEYS.id] ?? "", observed[WESUB_LABEL_KEYS.id] ?? "")
161 );
162 });
163
164 export const toSubscriptionName = (value: string) => {
165 if (value.length === 0) return value;
166 return value.startsWith(SUBSCRIPTION_PREFIX) ? value : `${SUBSCRIPTION_PREFIX}${value}`;
167 };
168
169 export const subscriptionIdOf = (name: string) =>
170 name.startsWith(SUBSCRIPTION_PREFIX) ? name.slice(SUBSCRIPTION_PREFIX.length) : lastSegment(name);
171
172 export const toTaskName = (value: string) => {
173 if (value.length === 0) return value;
174 return value.startsWith(TASK_PREFIX) ? value : `${TASK_PREFIX}${value}`;
175 };
176
177 export const taskIdOf = (name: string) =>
178 name.startsWith(TASK_PREFIX) ? name.slice(TASK_PREFIX.length) : lastSegment(name);
179
180 export const toConfigName = (task: string, configId: string) =>
181 `${toTaskName(task)}/${CONFIG_COLLECTION}/${configId}`;
182
183 export const configIdOf = (name: string) => {
184 const parts = name.split("/").filter((part) => part.length > 0);
185 const at = parts.lastIndexOf(CONFIG_COLLECTION);
186 return at >= 0 && parts[at + 1] ? parts[at + 1]! : lastSegment(name);
187 };
188
189 export const parentOfConfig = (name: string) => {
190 const parts = name.split("/").filter((part) => part.length > 0);
191 const at = parts.lastIndexOf(CONFIG_COLLECTION);
192 return at > 0 ? parts.slice(0, at).join("/") : toTaskName(lastSegment(name));
193 };
194
195 export const expandTopic = (value: string, project: string) => {
196 const trimmed = value.replace(/\/+$/, "");
197 if (trimmed.includes("/topics/")) return trimmed;
198 return `projects/${project}/topics/${lastSegment(trimmed)}`;
199 };
200
201 export const listFilter = (eventTypes: readonly string[], targetResource?: string) => {
202 const events = eventTypes.map((type) => `event_types:"${type}"`).join(" OR ");
203 if (targetResource !== undefined && targetResource.length > 0) {
204 return `(${events}) AND target_resource="${targetResource}"`;
205 }
206 return events;
207 };
208
209 export const catchMissing = <A, E extends { readonly _tag: string }, R>(
210 effect: Effect.Effect<A, E, R>,
211 ) =>
212 effect.pipe(
213 Effect.catchIf(
214 (error): error is E & { readonly _tag: "NotFound" } => error._tag === "NotFound",
215 () => Effect.undefined,
216 ),
217 );
218
219 export const ignoreMissing = <E extends { readonly _tag: string }, R>(
220 effect: Effect.Effect<unknown, E, R>,
221 ) =>
222 effect.pipe(
223 Effect.catchIf(
224 (error): error is E & { readonly _tag: "NotFound" } => error._tag === "NotFound",
225 () => Effect.void,
226 ),
227 );
228
229 export const getSubscription = (name: string) =>
230 name.length === 0
231 ? Effect.undefined
232 : catchMissing(we.getSubscriptions({ name: toSubscriptionName(name) }));
233
234 export const getTopic = (name: string) =>
235 name.length === 0
236 ? Effect.undefined
237 : pubsub
238 .getProjectsTopics({ topic: name })
239 .pipe(Effect.catchTag("NotFound", () => Effect.undefined));
240
241 export const ensureTopic = (name: string, labels: Record<string, string>) =>
242 Effect.gen(function* () {
243 let current = yield* getTopic(name);
244 if (current === undefined) {
245 const created = yield* pubsub
246 .createProjectsTopics({
247 name,
248 body: { labels },
249 })
250 .pipe(Effect.catchTag("Conflict", () => getTopic(name)));
251 current = created ?? undefined;
252 }
253 if (current === undefined) return undefined;
254 const observed = tagRecord(current.labels);
255 const desired = { ...observed, ...labels };
256 const changed = Object.entries(desired).some(([key, value]) => observed[key] !== value);
257 if (!changed) return current;
258 return yield* pubsub
259 .patchProjectsTopics({
260 name,
261 body: {
262 topic: { name, labels: desired },
263 updateMask: "labels",
264 },
265 })
266 .pipe(Effect.catchTag(["NotFound", "Conflict"], () => Effect.succeed(current)));
267 });
268
269 export const stringField = (value: unknown, key: string): string | undefined => {
270 if (value === null || value === undefined || typeof value !== "object") {
271 return undefined;
272 }
273 const field = (value as Record<string, unknown>)[key];
274 return typeof field === "string" && field.length > 0 ? field : undefined;
275 };
276
277 export const operationResourceName = (operation: we.Operation) =>
278 stringField(operation.response, "name") ?? stringField(operation.metadata, "name");
279
280 /**
281 * Wait for a Workspace Events long-running operation (subscription create/update/delete).
282 */
283 export const waitForOperation = (operation: we.Operation) =>
284 Effect.gen(function* () {
285 yield* waitForGcpOperation(operation, (name) => we.getOperations({ name }), {
286 budget: "10 minutes",
287 });
288 // Return the finished operation so callers can read its `response`.
289 if (operation.done === true || !operation.name) return operation;
290 return yield* we.getOperations({ name: operation.name });
291 });
292
293 export const waitUntilExists = <A, E, R>(
294 get: Effect.Effect<A | undefined, E, R>,
295 name: string,
296 ): Effect.Effect<NonNullable<A>, E | ResourceNotResolved, R> =>
297 get.pipe(
298 Effect.filterOrFail(
299 (value): value is NonNullable<A> => value != null,
300 () => new ResourceNotResolved({ resourceName: name }),
301 ),
302 Effect.retry({
303 while: (error) => error instanceof ResourceNotResolved,
304 times: 8,
305 schedule: Schedule.spaced("1 second"),
306 }),
307 );
308
309 export const waitUntilGone = <A, E, R>(
310 get: Effect.Effect<A | undefined, E, R>,
311 name: string,
312 ): Effect.Effect<void, E | ResourceStillExists, R> =>
313 get.pipe(
314 Effect.filterOrFail(
315 (value) => value === undefined,
316 () => new ResourceStillExists({ resourceName: name }),
317 ),
318 Effect.retry({
319 while: (error) => error instanceof ResourceStillExists,
320 times: 8,
321 schedule: Schedule.spaced("2 seconds"),
322 }),
323 Effect.asVoid,
324 );
325
326 export const collectPages = <Page, A, E, R>(
327 pages: Stream.Stream<Page, E, R>,
328 items: (page: Page) => readonly A[] | undefined,
329 ) =>
330 pages.pipe(
331 Stream.flatMap((page) => Stream.fromIterable(items(page) ?? [])),
332 Stream.runCollect,
333 Effect.map((chunk) => Array.from(chunk)),
334 );
335
336 export const listSubscriptions = (filter: string) =>
337 collectPages(
338 we.listSubscriptions.pages({
339 filter,
340 pageSize: 100,
341 }),
342 (page) => page.subscriptions,
343 ).pipe(Effect.catchTag("NotFound", () => Effect.succeed([] as we.Subscription[])));
344
345 export const listOwnedSubscriptions = () =>
346 Effect.gen(function* () {
347 const found = new Map<string, we.Subscription>();
348 const chunkSize = 6;
349 for (let index = 0; index < LIST_EVENT_TYPES.length; index += chunkSize) {
350 const chunk = LIST_EVENT_TYPES.slice(index, index + chunkSize);
351 const page = yield* listSubscriptions(listFilter(chunk));
352 for (const subscription of page) {
353 const name = subscription.name;
354 if (name !== undefined && name.length > 0) {
355 found.set(name, subscription);
356 }
357 }
358 }
359 const owned: we.Subscription[] = [];
360 for (const subscription of found.values()) {
361 const topic = subscription.notificationEndpoint?.pubsubTopic;
362 if (topic === undefined || topic.length === 0) continue;
363 const observed = yield* getTopic(topic);
364 if (hasWesubLabels(observed?.labels)) {
365 owned.push(subscription);
366 }
367 }
368 return owned;
369 });
370
371 export const findSubscription = (
372 name: string,
373 eventTypes: readonly string[],
374 targetResource: string | undefined,
375 ) =>
376 Effect.gen(function* () {
377 const existing = yield* getSubscription(name);
378 if (existing !== undefined) return existing;
379 if (eventTypes.length === 0) return undefined;
380 const listed = yield* listSubscriptions(listFilter(eventTypes, targetResource));
381 return listed[0];
382 });