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

main
ts 306 lines 9.81 KB
Raw
1 import * as compute from "@distilled.cloud/gcp/compute_v1";
2 import { Unowned } from "alchemy/AdoptPolicy";
3 import { isResolved } from "alchemy/Diff";
4 import { createPhysicalName } from "alchemy/PhysicalName";
5 import * as Provider from "alchemy/Provider";
6 import { Resource } from "alchemy/Resource";
7 import * as Data from "effect/Data";
8 import * as Effect from "effect/Effect";
9 import * as Schedule from "effect/Schedule";
10 import * as Stream from "effect/Stream";
11 import { GcpEnvironment } from "../Environment.ts";
12 import { alchemyLabelKeys, createInternalLabels, hasAlchemyLabels } from "../Labels.ts";
13 import type { Providers } from "../Providers.ts";
14 import { waitGlobalOperation } from "./operations.ts";
15
16 export type CrossSiteNetworkProps = {
17 /**
18 * Cross-site network name (RFC1035, 1-63 chars). If omitted, a unique
19 * name is generated from the stack, stage, and logical id. Changing it
20 * replaces the resource.
21 */
22 crossSiteNetworkName?: string;
23 /**
24 * Optional description. Compute CrossSiteNetwork has no labels field —
25 * Alchemy ownership is stored in a `[alchemy …]` prefix for `list` /
26 * nuke.
27 */
28 description?: string;
29 };
30
31 export type CrossSiteNetwork = Resource<
32 "GCP.Compute.CrossSiteNetwork",
33 CrossSiteNetworkProps,
34 {
35 /** Cross-site network name. */
36 crossSiteNetworkName: string;
37 /** Project id. */
38 project: string;
39 /** User description with the Alchemy ownership prefix stripped. */
40 description: string | undefined;
41 /** Server-assigned numeric id. */
42 crossSiteNetworkId: string | undefined;
43 /** Server-defined URL. */
44 selfLink: string | undefined;
45 /** RFC3339 creation timestamp. */
46 creationTimestamp: string | undefined;
47 /** Resource kind. */
48 kind: string | undefined;
49 },
50 never,
51 Providers
52 >;
53
54 /**
55 * A global Compute Engine cross-site network.
56 *
57 * Cross-site networks group Wire Groups that connect on-premises and
58 * cloud sites through Cross-Cloud Interconnect. The resource itself is a
59 * named container — Wire Groups attach later. Compute has no labels
60 * field, so Alchemy stamps ownership into the description.
61 *
62 * ### Creating a Cross-Site Network
63 * **Example:** Generated name
64 * ```typescript
65 * const network = yield* GCP.Compute.CrossSiteNetwork("backbone", {});
66 * ```
67 *
68 * **Example:** Named network with a description
69 * ```typescript
70 * const network = yield* GCP.Compute.CrossSiteNetwork("backbone", {
71 * crossSiteNetworkName: "prod-backbone",
72 * description: "cross-cloud interconnect fabric",
73 * });
74 * ```
75 *
76 * @resource
77 * @category Compute
78 */
79 export const CrossSiteNetwork = Resource<CrossSiteNetwork>("GCP.Compute.CrossSiteNetwork");
80
81 export class CrossSiteNetworkNotResolved extends Data.TaggedError(
82 "GCP.Compute.CrossSiteNetworkNotResolved",
83 )<{
84 crossSiteNetworkName: string;
85 }> {}
86
87 const rfc1035 = (name: string): string => {
88 let next = name
89 .toLowerCase()
90 .replace(/[^a-z0-9-]/g, "-")
91 .replace(/-+/g, "-")
92 .replace(/^-+/, "")
93 .replace(/-+$/, "");
94 if (!/^[a-z]/.test(next)) {
95 next = `c${next}`;
96 }
97 next = next.slice(0, 63).replace(/-+$/, "");
98 return next.length > 0 ? next : "crosssitenetwork";
99 };
100
101 const toName = (id: string, name: string | undefined, existing?: string) =>
102 Effect.gen(function* () {
103 if (name !== undefined) return name;
104 if (existing !== undefined) return existing;
105 return rfc1035(
106 yield* createPhysicalName({
107 id,
108 maxLength: 63,
109 lowercase: true,
110 }),
111 );
112 });
113
114 const encodeDescription = (
115 labels: Record<string, string>,
116 description: string | undefined,
117 ): string => {
118 const marker = `[alchemy ${alchemyLabelKeys.stack}=${labels[alchemyLabelKeys.stack]} ${alchemyLabelKeys.stage}=${labels[alchemyLabelKeys.stage]} ${alchemyLabelKeys.id}=${labels[alchemyLabelKeys.id]}]`;
119 return description ? `${marker}\n${description}` : marker;
120 };
121
122 const parseDescription = (
123 description: string | undefined,
124 ): {
125 labels: Record<string, string>;
126 description: string | undefined;
127 } => {
128 if (!description?.startsWith("[alchemy ")) {
129 return { labels: {}, description };
130 }
131 const end = description.indexOf("]");
132 if (end < 0) return { labels: {}, description };
133 const labels: Record<string, string> = {};
134 for (const part of description.slice("[alchemy ".length, end).split(/\s+/)) {
135 const eq = part.indexOf("=");
136 if (eq > 0) {
137 labels[part.slice(0, eq)] = part.slice(eq + 1);
138 }
139 }
140 const rest = description.slice(end + 1).replace(/^\n/, "");
141 return { labels, description: rest.length > 0 ? rest : undefined };
142 };
143
144 const toAttrs = (
145 network: compute.CrossSiteNetwork,
146 project: string,
147 ): CrossSiteNetwork["Attributes"] => {
148 const parsed = parseDescription(network.description);
149 return {
150 crossSiteNetworkName: network.name ?? network.id ?? "",
151 project,
152 description: parsed.description,
153 crossSiteNetworkId: network.id,
154 selfLink: network.selfLink,
155 creationTimestamp: network.creationTimestamp,
156 kind: network.kind,
157 };
158 };
159
160 const getByName = (project: string, crossSiteNetwork: string) =>
161 compute
162 .getCrossSiteNetworks({ project, crossSiteNetwork })
163 .pipe(Effect.catchTag("NotFound", () => Effect.undefined));
164
165 const awaitResource = (project: string, crossSiteNetworkName: string) =>
166 getByName(project, crossSiteNetworkName).pipe(
167 Effect.repeat({
168 schedule: Schedule.spaced("1 second"),
169 until: (network) => network !== undefined,
170 times: 8,
171 }),
172 );
173
174 export const CrossSiteNetworkProvider = () =>
175 Provider.succeed(CrossSiteNetwork, {
176 stables: [
177 "crossSiteNetworkName",
178 "project",
179 "crossSiteNetworkId",
180 "selfLink",
181 "creationTimestamp",
182 ],
183
184 diff: Effect.fn(function* ({ news, olds, output }) {
185 if (!isResolved(news)) return undefined;
186 const previousName = olds?.crossSiteNetworkName ?? output?.crossSiteNetworkName;
187 const nextName = news.crossSiteNetworkName;
188 if (previousName !== undefined && nextName !== undefined && previousName !== nextName) {
189 return { action: "replace" as const };
190 }
191 return undefined;
192 }),
193
194 read: Effect.fn(function* ({ id, olds, output }) {
195 const env = yield* GcpEnvironment.current;
196 const crossSiteNetworkName = yield* toName(
197 id,
198 olds?.crossSiteNetworkName,
199 output?.crossSiteNetworkName,
200 );
201 const existing = yield* getByName(env.project, crossSiteNetworkName);
202 if (existing === undefined) return undefined;
203 const attrs = toAttrs(existing, env.project);
204 const { labels } = parseDescription(existing.description);
205 return (yield* hasAlchemyLabels(id, labels)) ? attrs : Unowned(attrs);
206 }),
207
208 list: () =>
209 Effect.gen(function* () {
210 const env = yield* GcpEnvironment.current;
211 return yield* compute.listCrossSiteNetworks
212 .items({ project: env.project, maxResults: 500 })
213 .pipe(
214 Stream.filter((network) => {
215 const { labels } = parseDescription(network.description);
216 return Object.keys(labels).some((key) => key.startsWith("alchemy-"));
217 }),
218 Stream.map((network) => toAttrs(network, env.project)),
219 Stream.runCollect,
220 Effect.map((chunk) => Array.from(chunk)),
221 );
222 }),
223
224 reconcile: Effect.fn(function* ({ id, news, output }) {
225 const env = yield* GcpEnvironment.current;
226 const crossSiteNetworkName = yield* toName(
227 id,
228 news.crossSiteNetworkName,
229 output?.crossSiteNetworkName,
230 );
231 const ownership = yield* createInternalLabels(id);
232 const description = encodeDescription(ownership, news.description);
233
234 let current = yield* getByName(env.project, crossSiteNetworkName);
235
236 if (current === undefined) {
237 yield* compute
238 .insertCrossSiteNetworks({
239 project: env.project,
240 body: {
241 name: crossSiteNetworkName,
242 description,
243 },
244 })
245 .pipe(
246 Effect.flatMap((operation) =>
247 waitGlobalOperation(env.project, operation, {
248 ignore: ["RESOURCE_ALREADY_EXISTS"],
249 }),
250 ),
251 Effect.catchTag("Conflict", () => Effect.undefined),
252 );
253 current = yield* awaitResource(env.project, crossSiteNetworkName);
254 }
255
256 if (current === undefined) {
257 return yield* new CrossSiteNetworkNotResolved({
258 crossSiteNetworkName,
259 });
260 }
261
262 if ((current.description ?? "") !== description) {
263 yield* compute
264 .patchCrossSiteNetworks({
265 project: env.project,
266 crossSiteNetwork: crossSiteNetworkName,
267 updateMask: "description",
268 body: {
269 name: crossSiteNetworkName,
270 description,
271 },
272 })
273 .pipe(Effect.flatMap((operation) => waitGlobalOperation(env.project, operation)));
274 current = yield* getByName(env.project, crossSiteNetworkName);
275 if (current === undefined) {
276 return yield* new CrossSiteNetworkNotResolved({
277 crossSiteNetworkName,
278 });
279 }
280 }
281
282 return toAttrs(current, env.project);
283 }),
284
285 delete: Effect.fn(function* ({ output }) {
286 const env = yield* GcpEnvironment.current;
287 const operation = yield* compute
288 .deleteCrossSiteNetworks({
289 project: env.project,
290 crossSiteNetwork: output.crossSiteNetworkName,
291 })
292 .pipe(
293 Effect.retry({
294 while: (error) => error._tag === "Conflict",
295 schedule: Schedule.spaced("2 seconds"),
296 times: 8,
297 }),
298 Effect.catchTag("NotFound", () => Effect.undefined),
299 );
300 if (operation !== undefined) {
301 yield* waitGlobalOperation(env.project, operation).pipe(
302 Effect.catchTag("NotFound", () => Effect.void),
303 );
304 }
305 }),
306 });