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

main
ts 265 lines 10.3 KB
Raw
1 import * as codedeploy from "@distilled.cloud/aws/codedeploy";
2 import { isResolved } from "alchemy/Diff";
3 import { createPhysicalName } from "alchemy/PhysicalName";
4 import * as Provider from "alchemy/Provider";
5 import { Resource } from "alchemy/Resource";
6 import { toWireSeconds } from "alchemy/Util/Duration";
7 import type * as Duration from "effect/Duration";
8 import * as Effect from "effect/Effect";
9 import * as Schedule from "effect/Schedule";
10 import * as Stream from "effect/Stream";
11 import { AWSEnvironment } from "../Environment.ts";
12 import type { Providers } from "../Providers.ts";
13
14 /**
15 * Zonal deployment behaviour (EC2/on-prem `Server` platform): deploy one
16 * Availability Zone at a time, monitoring each zone before moving on.
17 * Mirrors the wire `ZonalConfig` with `Duration.Input` monitor durations
18 * (CodeDeploy's wire unit for both is whole seconds).
19 */
20 export interface ZonalConfigProps {
21 /**
22 * How long to monitor the FIRST zone after it finishes before starting
23 * the next zone. Wire unit: whole seconds.
24 * @default monitorDuration
25 */
26 firstZoneMonitorDuration?: Duration.Input;
27 /**
28 * How long to monitor each subsequent zone after it finishes before
29 * starting the next one. Wire unit: whole seconds.
30 * @default 0
31 */
32 monitorDuration?: Duration.Input;
33 /**
34 * Minimum healthy hosts required per Availability Zone while deploying.
35 */
36 minimumHealthyHostsPerZone?: codedeploy.MinimumHealthyHostsPerZone;
37 }
38
39 /** Convert the zonal-config props to the CodeDeploy wire shape (seconds). */
40 const toWireZonalConfig = (
41 props: ZonalConfigProps | undefined,
42 ): codedeploy.ZonalConfig | undefined =>
43 props === undefined
44 ? undefined
45 : {
46 firstZoneMonitorDurationInSeconds: toWireSeconds(props.firstZoneMonitorDuration),
47 monitorDurationInSeconds: toWireSeconds(props.monitorDuration),
48 minimumHealthyHostsPerZone: props.minimumHealthyHostsPerZone,
49 };
50
51 export interface DeploymentConfigProps {
52 /**
53 * Name of the deployment configuration (1-100 chars). If omitted a
54 * deterministic physical name is generated. Changing the name replaces
55 * the configuration.
56 */
57 deploymentConfigName?: string;
58 /**
59 * The compute platform the configuration applies to. Immutable — changing
60 * it replaces the configuration.
61 * @default "Server"
62 */
63 computePlatform?: "Server" | "Lambda" | "ECS";
64 /**
65 * Minimum healthy hosts during the deployment (`HOST_COUNT` or
66 * `FLEET_PERCENT`). `Server` platform only.
67 */
68 minimumHealthyHosts?: codedeploy.MinimumHealthyHosts;
69 /**
70 * How traffic shifts to the new version (`TimeBasedCanary`,
71 * `TimeBasedLinear`, or `AllAtOnce`). `Lambda`/`ECS` platforms. The
72 * `canaryInterval`/`linearInterval` fields are whole minutes (the wire
73 * unit is semantically part of the AWS field).
74 */
75 trafficRoutingConfig?: codedeploy.TrafficRoutingConfig;
76 /**
77 * Deploy one Availability Zone at a time with per-zone monitor
78 * durations. `Server` platform only.
79 */
80 zonalConfig?: ZonalConfigProps;
81 }
82
83 export interface DeploymentConfig extends Resource<
84 "AWS.CodeDeploy.DeploymentConfig",
85 DeploymentConfigProps,
86 {
87 /** Physical name of the deployment configuration. */
88 deploymentConfigName: string;
89 /** Unique CodeDeploy-assigned deployment-config ID. */
90 deploymentConfigId: string;
91 /** ARN of the deployment configuration. */
92 deploymentConfigArn: string;
93 /** The compute platform (`Lambda`, `Server`, or `ECS`). */
94 computePlatform: string;
95 },
96 never,
97 Providers
98 > {}
99
100 /**
101 * A custom AWS CodeDeploy deployment configuration — the rules for how
102 * traffic shifts during a deployment (canary/linear traffic routing for
103 * `Lambda`/`ECS`, minimum-healthy-hosts and zonal rollout for `Server`).
104 * Deployment configurations are immutable: any change replaces the
105 * configuration.
106 *
107 * ### Creating a Deployment Config
108 * **Example:** Lambda Canary Config
109 * ```typescript
110 * const config = yield* CodeDeploy.DeploymentConfig("canary", {
111 * computePlatform: "Lambda",
112 * trafficRoutingConfig: {
113 * type: "TimeBasedCanary",
114 * timeBasedCanary: { canaryPercentage: 10, canaryInterval: 5 },
115 * },
116 * });
117 * ```
118 *
119 * **Example:** Server Config with Minimum Healthy Hosts
120 * ```typescript
121 * const config = yield* CodeDeploy.DeploymentConfig("half-fleet", {
122 * computePlatform: "Server",
123 * minimumHealthyHosts: { type: "FLEET_PERCENT", value: 50 },
124 * });
125 * ```
126 *
127 * @resource
128 */
129 export const DeploymentConfig = Resource<DeploymentConfig>("AWS.CodeDeploy.DeploymentConfig");
130
131 /** Build the ARN for a CodeDeploy deployment configuration. */
132 const deploymentConfigArn = (region: string, account: string, name: string): string =>
133 `arn:aws:codedeploy:${region}:${account}:deploymentconfig:${name}`;
134
135 export const DeploymentConfigProvider = () =>
136 Provider.effect(
137 DeploymentConfig,
138 Effect.gen(function* () {
139 const toName = (id: string, props: Partial<DeploymentConfigProps>) =>
140 props.deploymentConfigName
141 ? Effect.succeed(props.deploymentConfigName)
142 : createPhysicalName({ id, maxLength: 100 });
143
144 const getConfig = Effect.fn(function* (name: string) {
145 const response = yield* codedeploy
146 .getDeploymentConfig({ deploymentConfigName: name })
147 .pipe(Effect.catchTag("DeploymentConfigDoesNotExistException", () => Effect.undefined));
148 return response?.deploymentConfigInfo;
149 });
150
151 return {
152 stables: ["deploymentConfigName", "deploymentConfigId", "computePlatform"],
153
154 diff: Effect.fn(function* ({ id, olds, news }) {
155 if (!isResolved(news)) return undefined;
156 if ((yield* toName(id, olds ?? {})) !== (yield* toName(id, news ?? {}))) {
157 return { action: "replace" } as const;
158 }
159 // Deployment configurations are immutable — any settings change
160 // replaces the configuration.
161 const key = (props: Partial<DeploymentConfigProps>) =>
162 JSON.stringify([
163 props.computePlatform ?? "Server",
164 props.minimumHealthyHosts,
165 props.trafficRoutingConfig,
166 toWireZonalConfig(props.zonalConfig),
167 ]);
168 if (key(olds ?? {}) !== key(news ?? {})) {
169 return { action: "replace" } as const;
170 }
171 }),
172
173 read: Effect.fn(function* ({ id, olds, output }) {
174 const { accountId, region } = yield* AWSEnvironment.current;
175 const name = output?.deploymentConfigName ?? (yield* toName(id, olds ?? {}));
176 const config = yield* getConfig(name);
177 if (config?.deploymentConfigId === undefined) return undefined;
178 // Deployment configurations cannot be tagged, so there is no
179 // ownership marker to check — a name match is treated as ours.
180 return {
181 deploymentConfigName: config.deploymentConfigName ?? name,
182 deploymentConfigId: config.deploymentConfigId,
183 deploymentConfigArn: deploymentConfigArn(region, accountId, name),
184 computePlatform: config.computePlatform ?? "Server",
185 };
186 }),
187
188 reconcile: Effect.fn(function* ({ id, news, output, session }) {
189 const { accountId, region } = yield* AWSEnvironment.current;
190 const name = output?.deploymentConfigName ?? (yield* toName(id, news));
191 const computePlatform = news.computePlatform ?? "Server";
192
193 // 1. Observe — cloud state is authoritative.
194 let config = yield* getConfig(name);
195
196 // 2. Ensure — create if missing (configs are immutable, so there
197 // is nothing to sync). Tolerate an already-exists race.
198 if (config?.deploymentConfigId === undefined) {
199 yield* codedeploy
200 .createDeploymentConfig({
201 deploymentConfigName: name,
202 computePlatform,
203 minimumHealthyHosts: news.minimumHealthyHosts,
204 trafficRoutingConfig: news.trafficRoutingConfig,
205 zonalConfig: toWireZonalConfig(news.zonalConfig),
206 })
207 .pipe(
208 Effect.catchTag("DeploymentConfigAlreadyExistsException", () => Effect.undefined),
209 );
210 config = yield* getConfig(name);
211 }
212
213 // 3. Return fresh attributes.
214 yield* session.note(name);
215 return {
216 deploymentConfigName: config?.deploymentConfigName ?? name,
217 deploymentConfigId: config?.deploymentConfigId ?? "",
218 deploymentConfigArn: deploymentConfigArn(region, accountId, name),
219 computePlatform: config?.computePlatform ?? computePlatform,
220 };
221 }),
222
223 delete: Effect.fn(function* ({ output }) {
224 // A config still referenced by a deployment group fails with
225 // DeploymentConfigInUseException — the engine deletes dependents
226 // first, but the reference release is eventually consistent, so
227 // retry through it (bounded). Deleting a non-existent config
228 // succeeds (no not-found variant in the typed error union).
229 yield* codedeploy
230 .deleteDeploymentConfig({
231 deploymentConfigName: output.deploymentConfigName,
232 })
233 .pipe(
234 Effect.retry({
235 while: (e): boolean => e._tag === "DeploymentConfigInUseException",
236 schedule: Schedule.max([Schedule.fixed(3000), Schedule.recurs(10)]),
237 }),
238 );
239 }),
240
241 list: () =>
242 Effect.gen(function* () {
243 const { accountId, region } = yield* AWSEnvironment.current;
244 const names = yield* codedeploy.listDeploymentConfigs.pages({}).pipe(
245 Stream.runCollect,
246 Effect.map((chunk) =>
247 Array.from(chunk).flatMap((page) => page.deploymentConfigsList ?? []),
248 ),
249 );
250 return (
251 names
252 // Predefined CodeDeployDefault.* configurations are
253 // AWS-managed and cannot be deleted — never ours.
254 .filter((name) => !name.startsWith("CodeDeployDefault."))
255 .map((name) => ({
256 deploymentConfigName: name,
257 deploymentConfigId: "",
258 deploymentConfigArn: deploymentConfigArn(region, accountId, name),
259 computePlatform: "",
260 }))
261 );
262 }),
263 };
264 }),
265 );