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

main
ts 709 lines 25.3 KB
Raw
1 import type { DockerfileBuildOptions } from "@alchemy.run/docker/ImageSource";
2 import type * as Bundle from "alchemy/Bundle/Bundle";
3 import { isResolved } from "alchemy/Diff";
4 import * as Output from "alchemy/Output";
5 import { createPhysicalName } from "alchemy/PhysicalName";
6 import { Platform, type PlatformProps, type PlatformServices } from "alchemy/Platform";
7 import * as Provider from "alchemy/Provider";
8 import { Resource } from "alchemy/Resource";
9 import type { HostRuntimeContext } from "alchemy/Runtime/Process";
10 import { packEnvValue, unpackEnvValue, RuntimeContext } from "alchemy/RuntimeContext";
11 import { Stack } from "alchemy/Stack";
12 import { createInternalTags } from "alchemy/Tags";
13 import { unwrapRedacted } from "alchemy/Util/data";
14 import { sha256Object } from "alchemy/Util/sha256";
15 import * as Effect from "effect/Effect";
16 import type { Scope } from "effect/Scope";
17 import {
18 connectCluster,
19 deleteObjects,
20 ifClusterExists,
21 readObject,
22 reconcileObjects,
23 } from "./Client.ts";
24 import {
25 findClusterAdapter,
26 type IdentityState,
27 type RegistryState,
28 type WorkloadBindingContract,
29 type WorkloadIdentityOptions,
30 type WorkloadImageSource,
31 type WorkloadServices,
32 } from "./ClusterAdapter.ts";
33 import { toConnection, type ClusterLike, type Connection } from "./Connection.ts";
34 import { makeConnectionRegistry } from "./internal/registry.ts";
35 import {
36 collectBindingEnv,
37 containerEnvValue,
38 connectionIdentity,
39 connectionOfOutput,
40 deepMerge,
41 imagePlatformOf,
42 makeJobBootstrap,
43 resolveWorkloadImage,
44 tryConnectionOf,
45 workloadImageHash,
46 } from "./internal/workload.ts";
47 import type { KubernetesObjectDefinition, KubernetesObjectRef } from "./Objects.ts";
48 import type { Providers } from "./Providers.ts";
49
50 export const isJob = (value: any): value is Job =>
51 typeof value === "object" && value !== null && "Type" in value && value.Type === "Kubernetes.Job";
52
53 export interface JobPropsBase extends PlatformProps {
54 /**
55 * Target cluster the job runs on: a cluster resource
56 * (`Kubernetes.LocalCluster`, `AWS.EKS.Cluster`), a
57 * `Kubernetes.KubeConfig(...)`, or a raw `Kubernetes.Connection`. The
58 * connection supplies authentication and the registry `main` / `context`
59 * images are pushed to.
60 */
61 cluster: ClusterLike;
62 /**
63 * Base name for the generated Job / ServiceAccount. If omitted, a
64 * deterministic name is derived from the stack, stage, and logical id.
65 */
66 name?: string;
67 /**
68 * Kubernetes namespace to run in. The namespace must already exist.
69 * @default "default"
70 */
71 namespace?: string;
72 /**
73 * Number of retries before the Job is marked failed (Kubernetes
74 * `backoffLimit`).
75 */
76 backoffLimit?: number;
77 /**
78 * Cron schedule (standard 5-field cron, e.g. `"0 3 * * *"`). When set, a
79 * Kubernetes `CronJob` is synthesized instead of a plain `Job`.
80 */
81 schedule?: string;
82 /**
83 * Restart policy for the job's pods.
84 * @default "Never"
85 */
86 restartPolicy?: "Never" | "OnFailure";
87 /**
88 * Seconds after completion before the finished Job is garbage-collected
89 * (Kubernetes `ttlSecondsAfterFinished`).
90 */
91 ttlSecondsAfterFinished?: number;
92 /**
93 * Container entrypoint override (Kubernetes `command`). Mostly useful with
94 * `image` / `context` sources.
95 */
96 command?: string[];
97 /**
98 * Container arguments (Kubernetes `args`).
99 */
100 args?: string[];
101 /**
102 * Container CPU/memory requests + limits (Kubernetes resource quantities).
103 */
104 resources?: {
105 requests?: { cpu?: string; memory?: string };
106 limits?: { cpu?: string; memory?: string };
107 };
108 /**
109 * Additional environment variables for the container.
110 */
111 env?: Record<string, any>;
112 /**
113 * Container image build architecture.
114 * @default the connection's `architecture`, else "amd64"
115 */
116 architecture?: "amd64" | "arm64";
117 /**
118 * Deep-partial Kubernetes Pod template merged into the synthesized
119 * template (objects merge recursively; arrays and primitives replace) —
120 * a literal object in the shape of `PodTemplateSpec`, e.g.
121 * `{ spec: { tolerations: [...], nodeSelector: {...} } }`.
122 */
123 podTemplate?: Record<string, unknown>;
124 /**
125 * Cloud-specific workload-identity options, consumed by the cluster
126 * platform's identity adapter (on EKS: `{ managedPolicyArns: [...] }`
127 * attaches extra managed policies to the generated pod-identity role; on
128 * GKE: `{ gcpServiceAccount }` runs the pods as an existing Google
129 * service account instead of the ServiceAccount's own principal).
130 */
131 identity?: WorkloadIdentityOptions;
132 /**
133 * Job / pod labels, merged over the generated `app.kubernetes.io/name`
134 * label.
135 */
136 labels?: Record<string, string>;
137 /**
138 * User-defined tags applied to workload-owned cloud resources (identity
139 * roles, image repositories).
140 */
141 tags?: Record<string, string>;
142 }
143
144 /** Bundle an inline Effect program (`main`) into a generated image. */
145 export interface BundledJobProps extends JobPropsBase {
146 /**
147 * Module entrypoint for the bundled program. This should typically be
148 * `import.meta.url` from an inline Effect program.
149 */
150 main: string;
151 /**
152 * Environment image used as the generated Dockerfile's `FROM`; must be
153 * able to run the bun runtime.
154 * @default "oven/bun:1"
155 */
156 image?: string;
157 /** Named export to load from `main`. @default "default" */
158 handler?: string;
159 /** Bundler configuration for the entrypoint. */
160 build?: Bundle.BundleConfig;
161 /** Environment Dockerfile (path or inline content). */
162 dockerfile?: WorkloadImageSource["dockerfile"];
163 /** Build context for a path {@link dockerfile} environment. */
164 context?: string;
165 }
166
167 /** Build the user's own Dockerfile (`context` + optional `dockerfile` path). */
168 export interface DockerfileJobProps extends JobPropsBase, DockerfileBuildOptions {
169 /** Docker build context directory. */
170 context?: string;
171 /**
172 * Path to the Dockerfile (relative to the cwd), or inline content.
173 * @default `${context}/Dockerfile`
174 */
175 dockerfile?: WorkloadImageSource["dockerfile"];
176 }
177
178 /** Run a pre-built registry image. */
179 export interface ImageJobProps extends JobPropsBase {
180 /**
181 * A pre-built image reference, e.g. `ghcr.io/acme/migrator:v3`, pulled
182 * by the nodes as written. EKS clusters mirror it into ECR first.
183 */
184 image: string;
185 }
186
187 export type JobProps = BundledJobProps | DockerfileJobProps | ImageJobProps;
188
189 export interface Job extends Resource<
190 "Kubernetes.Job",
191 JobProps,
192 {
193 /** The connection of the cluster the job runs on. */
194 connection: Connection;
195 /** The Kubernetes namespace the job's objects live in. */
196 namespace: string;
197 /** The Kubernetes kind synthesized for the workload (`Job`, or `CronJob` when `schedule` is set). */
198 kind: "Job" | "CronJob";
199 /** The name of the Kubernetes Job/CronJob object. */
200 jobName: string;
201 /** The cron schedule, when the workload is a CronJob. */
202 schedule: string | undefined;
203 /** The name of the service account the pods run as. */
204 serviceAccountName: string;
205 /** The URI of the container image the job runs. */
206 imageUri: string;
207 /**
208 * Workload-identity state provisioned by the cluster platform's
209 * adapter (on EKS: the pod-identity role + association; on GKE: the
210 * Workload Identity principal and the IAM grants applied to it).
211 */
212 // oxlint-disable-next-line typescript/no-redundant-type-constituents -- registry type is `never` until cloud packages augment it
213 identity: IdentityState | undefined;
214 /**
215 * Image-registry state provisioned by the cluster platform's adapter
216 * (on EKS: the ECR repository).
217 */
218 registry: RegistryState | undefined;
219 /** References to the Kubernetes objects created for the job. */
220 kubernetesObjects: KubernetesObjectRef[];
221 /** The content hash of the container image source. */
222 code: {
223 hash: string;
224 };
225 },
226 WorkloadBindingContract,
227 Providers
228 > {}
229
230 export type JobServices = WorkloadServices;
231
232 /**
233 * The impl shape: `{ run, ...rpc }`. `run` executes to completion inside
234 * the pod; the process exits when it returns.
235 */
236 export type JobMain<InitServices = never> = void | {
237 run?: Effect.Effect<void, never, InitServices | PlatformServices | RuntimeContext | Scope>;
238 };
239
240 export type JobShape = JobMain<JobServices>;
241
242 export interface JobRuntimeContext extends HostRuntimeContext {
243 readonly Type: "Kubernetes.Job";
244 }
245
246 /**
247 * Run-to-completion work on any Kubernetes cluster, as a container image
248 * or an Effect program.
249 *
250 * `Job` provisions a Kubernetes `Job` (or `CronJob` when `schedule` is
251 * set) via server-side apply and a ServiceAccount, plus — through the
252 * target cluster's platform adapter — workload identity and a container
253 * image from exactly one of three sources flat on props: `main` (bundle an
254 * inline Effect program whose impl returns `{ run }`), `context` (build
255 * your own Dockerfile), or `image` (a pre-built registry reference).
256 * `main` and `context` images are built on the deploying machine and
257 * pushed to the connection's registry (`Kubernetes.LocalCluster` includes
258 * one; EKS uses ECR; GKE uses Artifact Registry). On `AWS.EKS.Cluster`
259 * targets, bindings attach IAM policy statements to a generated
260 * pod-identity role; on `GCP.Container.Cluster` targets, GCP bindings grant
261 * their IAM roles to the Kubernetes ServiceAccount's Workload Identity
262 * Federation principal — exactly like `Kubernetes.Deployment`.
263 * ### Creating a Job
264 * **Example:** Remote image (external — no Effect runtime in the container)
265 * ```typescript
266 * const migrate = yield* Kubernetes.Job("DbMigrate", {
267 * cluster,
268 * image: "ghcr.io/acme/migrator:v3",
269 * backoffLimit: 2,
270 * });
271 * ```
272 *
273 * **Example:** Your own Dockerfile with build args and secrets
274 * ```typescript
275 * // Dockerfile:
276 * // ARG NODE_ENV
277 * // RUN --mount=type=secret,id=NPM_TOKEN,env=NPM_TOKEN npm ci
278 * const migrate = yield* Kubernetes.Job("DbMigrate", {
279 * cluster,
280 * context: "./migrator",
281 * build: {
282 * args: { NODE_ENV: "production" },
283 * // Mounted only into the RUN step that asks for it; never in the image.
284 * secrets: { NPM_TOKEN: Config.Redacted("NPM_TOKEN") },
285 * },
286 * backoffLimit: 2,
287 * });
288 * ```
289 *
290 * **Example:** Inline Effect program
291 * ```typescript
292 * const cluster = yield* Kubernetes.LocalCluster("Cluster", {
293 * name: "alchemy",
294 * });
295 *
296 * const hello = yield* Kubernetes.Job(
297 * "Hello",
298 * { cluster, main: import.meta.url, backoffLimit: 2 },
299 * Effect.gen(function* () {
300 * return {
301 * run: Effect.log("hello from a Job"),
302 * };
303 * }),
304 * );
305 * ```
306 *
307 * **Example:** Inline Effect program with a DynamoDB binding (EKS)
308 * ```typescript
309 * const seed = yield* Kubernetes.Job(
310 * "SeedData",
311 * { cluster, main: import.meta.url },
312 * Effect.gen(function* () {
313 * const putItem = yield* AWS.DynamoDB.PutItem(table);
314 * return {
315 * run: Effect.gen(function* () {
316 * yield* putItem({ Item: { id: { S: "seed" } } });
317 * }),
318 * };
319 * }).pipe(Effect.provide(AWS.DynamoDB.PutItemHttp)),
320 * );
321 * ```
322 *
323 * **Example:** Tagged Effect program
324 * ```typescript
325 * export class Backfill extends Kubernetes.Job<Backfill, {
326 * progress: () => Effect.Effect<number>;
327 * }>()("Backfill") {}
328 *
329 * export default Backfill.make(
330 * { cluster, main: import.meta.url, backoffLimit: 1 },
331 * Effect.gen(function* () {
332 * return {
333 * run: Effect.gen(function* () { }),
334 * progress: () => Effect.succeed(0),
335 * };
336 * }),
337 * );
338 * ```
339 *
340 * ### Bundling & Tree-shaking
341 * `main` is bundled with rolldown at deploy time. Unused code is
342 * tree-shaken. `effect`, alchemy, and `@distilled.cloud` are marked
343 * pure so unused parts prune more aggressively. Your app is not
344 * marked pure.
345 *
346 * **Example:** Mark additional packages as pure
347 * Only list packages with no top-level side effects.
348 * ```typescript
349 * {
350 * main: import.meta.url,
351 * build: {
352 * pure: { packages: ["my-lib", "@my-scope/*"] },
353 * },
354 * }
355 * ```
356 *
357 * **Example:** Turn it off
358 * ```typescript
359 * {
360 * main: import.meta.url,
361 * build: { pure: false },
362 * }
363 * ```
364 *
365 * ### Scheduling
366 * **Example:** Nightly CronJob
367 * ```typescript
368 * const nightly = yield* Kubernetes.Job("NightlyBackfill", {
369 * cluster,
370 * main: import.meta.url,
371 * schedule: "0 3 * * *",
372 * });
373 * ```
374 *
375 * @resource
376 * @product Workloads
377 */
378 export const Job: Platform<Job, JobServices, JobShape, JobRuntimeContext> = Platform(
379 "Kubernetes.Job",
380 {
381 aliases: ["AWS.EKS.Job"],
382 createRuntimeContext: (id: string): JobRuntimeContext => {
383 // A one-shot host context: `serve` (invoked by the Platform machinery
384 // with the impl shape) registers the shape's `run` effect as the
385 // program instead of an HTTP server, so the generated entry executes
386 // it to completion and exits.
387 const runners: Effect.Effect<void, never, any>[] = [];
388 const env: Record<string, any> = {};
389 const context: JobRuntimeContext = {
390 Type: "Kubernetes.Job",
391 id,
392 env,
393 set: (bindingId: string, output: Output.Output) =>
394 Effect.sync(() => {
395 const key = bindingId.replaceAll(/[^a-zA-Z0-9]/g, "_");
396 env[key] = output.pipe(Output.map(packEnvValue));
397 return key;
398 }),
399 get: <T>(key: string) => Effect.sync(() => unpackEnvValue<T>(process.env[key]) as T),
400 run: (effect: Effect.Effect<void, never, any>) =>
401 Effect.sync(() => {
402 runners.push(effect);
403 }),
404 serve: ((_handler, options) =>
405 Effect.sync(() => {
406 const run = options?.shape?.run;
407 if (Effect.isEffect(run)) {
408 // oxlint-disable-next-line effecttsgo/unsafe-effect-type-assertion -- `run` is a user program; the host runner surfaces its failures
409 runners.push(run as Effect.Effect<void, never, any>);
410 }
411 })) as HostRuntimeContext["serve"],
412 exports: Effect.sync(() => ({
413 program: Effect.all(runners, { concurrency: "unbounded" }).pipe(Effect.asVoid),
414 })),
415 };
416 return context;
417 },
418 },
419 );
420
421 export const JobProvider = () =>
422 Provider.effect(
423 Job,
424 Effect.gen(function* () {
425 const stack = yield* Stack;
426 const connectionRegistry = yield* makeConnectionRegistry;
427
428 const alchemyEnv = {
429 ALCHEMY_STACK_NAME: stack.name,
430 ALCHEMY_STAGE: stack.stage,
431 ALCHEMY_PHASE: "runtime",
432 };
433
434 // The base name doubles as the `app.kubernetes.io/name` label value
435 // (and the Service name), both capped at 63 characters.
436 const toBaseName = (id: string, props: { name?: string } = {}) =>
437 props.name
438 ? Effect.succeed(props.name)
439 : createPhysicalName({ id, maxLength: 63, lowercase: true }).pipe(
440 Effect.map((name) => name.replaceAll(/[^a-z0-9-]/g, "-")),
441 );
442
443 return {
444 stables: ["connection", "namespace", "serviceAccountName", "identity", "registry"],
445 // A Job's identity spans in-cluster Kubernetes objects plus
446 // adapter-owned cloud resources — no single enumeration
447 // reconstructs the composite, so enumeration is empty; `read`
448 // refreshes known instances.
449 list: () => Effect.succeed([] as Job["Attributes"][]),
450 diff: Effect.fn(function* ({ olds = {} as JobProps, news: input, output }) {
451 // `exports` carries the program's runtime Effects (never plain
452 // data); everything else must be resolved to diff.
453 const { exports: _exports, ...declared } = input as typeof input & {
454 exports?: unknown;
455 };
456 if (!isResolved(declared)) return;
457 const news = input as unknown as JobProps;
458 const oldCluster = connectionIdentity(tryConnectionOf(olds.cluster));
459 const newCluster = connectionIdentity(tryConnectionOf(news.cluster));
460 if (oldCluster !== undefined && newCluster !== undefined && oldCluster !== newCluster) {
461 return { action: "replace" } as const;
462 }
463 if (
464 oldCluster !== undefined &&
465 (olds.namespace ?? "default") !== (news.namespace ?? "default")
466 ) {
467 return { action: "replace" } as const;
468 }
469 // Content drift (see Deployment).
470 const connection = tryConnectionOf(news.cluster);
471 if (output && connection) {
472 const adapter = yield* findClusterAdapter(connection.auth.kind);
473 const source = news as WorkloadImageSource;
474 const hash = yield* workloadImageHash({
475 adapter,
476 connection,
477 connectionRegistry,
478 source,
479 platform: imagePlatformOf(news.architecture, connection),
480 isExternal: news.isExternal,
481 bootstrap: (adapter.bootstrap?.job ?? makeJobBootstrap)(source.handler ?? "default"),
482 });
483 if (hash !== undefined && hash !== output.code.hash) {
484 return { action: "update" } as const;
485 }
486 }
487 }),
488 read: Effect.fn(function* ({ output }) {
489 if (!output) return undefined;
490 const connection = connectionOfOutput(output);
491 if (!connection) return undefined;
492 const transport = yield* connectCluster(connection);
493 // The ServiceAccount is the stable existence anchor: one-shot Job
494 // objects are content-addressed and may have been TTL-collected.
495 const anchor = (output.kubernetesObjects ?? [])[0];
496 if (!anchor) return output;
497 const observed = yield* readObject({
498 transport,
499 object: anchor,
500 }).pipe(Effect.catchTag("KubernetesNotFound", () => Effect.undefined));
501 if (observed === undefined) return undefined;
502 return output;
503 }),
504 reconcile: Effect.fn(function* ({ id, news, bindings, output, session }) {
505 const connection = toConnection(news.cluster);
506 const adapter = yield* findClusterAdapter(connection.auth.kind);
507 const transport = yield* adapter.connect(connection);
508 const namespace = news.namespace ?? "default";
509
510 const baseName = yield* toBaseName(id, news);
511 const serviceAccountName = output?.serviceAccountName ?? baseName;
512 const tags = {
513 ...(yield* createInternalTags(id)),
514 ...news.tags,
515 };
516
517 const { env: bindingEnv, grantKeys } = collectBindingEnv(bindings);
518 if (grantKeys.length > 0 && adapter.identity === undefined) {
519 return yield* Effect.die(
520 new Error(
521 `'${id}': bindings carry cloud credential grants ` +
522 `(${grantKeys.join(", ")}) but this cluster's platform ` +
523 "has no workload-identity adapter. Target a managed " +
524 "cluster (e.g. AWS.EKS.Cluster) or bind through " +
525 "environment variables instead.",
526 ),
527 );
528 }
529 const identity = adapter.identity
530 ? yield* adapter.identity.reconcile({
531 id,
532 connection,
533 namespace,
534 serviceAccount: serviceAccountName,
535 bindings,
536 options: news.identity,
537 state:
538 (output?.identity as Record<string, unknown> | undefined) ??
539 (output as Record<string, unknown> | undefined),
540 tags,
541 })
542 : undefined;
543
544 // Resolve the container image (`main` | `context` | `image`).
545 const source = news as WorkloadImageSource;
546 const resolved = yield* resolveWorkloadImage({
547 adapter,
548 connection,
549 connectionRegistry,
550 id,
551 source,
552 platform: imagePlatformOf(news.architecture, connection),
553 isExternal: news.isExternal,
554 bootstrap: (adapter.bootstrap?.job ?? makeJobBootstrap)(source.handler ?? "default"),
555 tags,
556 state:
557 (output?.registry as Record<string, unknown> | undefined) ??
558 (output as Record<string, unknown> | undefined),
559 session,
560 });
561
562 // Synthesize the Kubernetes objects. The generated name label is
563 // always present so selectors and Kueue-style extra labels
564 // compose without erasing the workload's identity label.
565 const labels = {
566 "app.kubernetes.io/name": baseName,
567 ...news.labels,
568 };
569 const containerEnv = {
570 ...bindingEnv,
571 ...identity?.env,
572 ...alchemyEnv,
573 ...news.env,
574 };
575
576 const serviceAccountObject: KubernetesObjectDefinition = {
577 apiVersion: "v1",
578 kind: "ServiceAccount",
579 metadata: {
580 name: serviceAccountName,
581 namespace,
582 labels,
583 ...(identity?.serviceAccountAnnotations
584 ? { annotations: identity.serviceAccountAnnotations }
585 : {}),
586 },
587 };
588 const podTemplate = deepMerge(
589 {
590 metadata: { labels },
591 spec: {
592 serviceAccountName,
593 restartPolicy: news.restartPolicy ?? "Never",
594 containers: [
595 {
596 name: baseName,
597 image: resolved.imageUri,
598 command: news.command,
599 args: news.args,
600 env: Object.entries(containerEnv).map(([name, value]) => ({
601 name,
602 value: containerEnvValue(value),
603 })),
604 resources: news.resources,
605 },
606 ],
607 },
608 },
609 news.podTemplate,
610 );
611 const jobSpec = {
612 backoffLimit: news.backoffLimit,
613 ttlSecondsAfterFinished: news.ttlSecondsAfterFinished,
614 template: podTemplate,
615 };
616
617 const kind: "Job" | "CronJob" = news.schedule ? "CronJob" : "Job";
618
619 // A Kubernetes Job's pod template is immutable after creation, so
620 // one-shot Jobs are content-addressed: the object name embeds a
621 // hash of the spec, and a spec change applies a NEW Job (which
622 // runs) while `reconcileObjects` deletes the previous one.
623 // CronJobs are mutable and keep the stable base name.
624 // Kubernetes rejects Job names over 63 characters (the API
625 // stamps the name into the batch.kubernetes.io/job-name pod
626 // label, and label values cap at 63) — truncate the base so the
627 // content-address suffix always fits.
628 const jobName = news.schedule
629 ? baseName.slice(0, 52).replace(/-+$/, "")
630 : `${baseName.slice(0, 54).replace(/-+$/, "")}-${(yield* sha256Object(unwrapRedacted(jobSpec))).slice(0, 8)}`;
631
632 const workloadObject: KubernetesObjectDefinition = news.schedule
633 ? {
634 apiVersion: "batch/v1",
635 kind: "CronJob",
636 metadata: { name: jobName, namespace, labels },
637 spec: {
638 schedule: news.schedule,
639 jobTemplate: {
640 metadata: { labels },
641 spec: jobSpec,
642 },
643 },
644 }
645 : {
646 apiVersion: "batch/v1",
647 kind: "Job",
648 metadata: { name: jobName, namespace, labels },
649 spec: jobSpec,
650 };
651
652 const desiredObjects = [serviceAccountObject, workloadObject];
653
654 const kubernetesObjects = yield* reconcileObjects({
655 transport,
656 previousObjects: output?.kubernetesObjects ?? [],
657 desiredObjects,
658 });
659
660 yield* session.note(`Applied Kubernetes ${kind} ${namespace}/${jobName}`);
661
662 return {
663 connection,
664 namespace,
665 kind,
666 jobName,
667 schedule: news.schedule,
668 serviceAccountName,
669 imageUri: resolved.imageUri,
670 identity: identity?.state,
671 registry: resolved.state,
672 kubernetesObjects,
673 code: { hash: resolved.codeHash },
674 };
675 }),
676 delete: Effect.fn(function* ({ output }) {
677 const connection = connectionOfOutput(output);
678 if (!connection) return;
679 const adapter = yield* findClusterAdapter(connection.auth.kind);
680
681 // Skip only a missing cluster, then still clean up adapter-owned
682 // cloud resources (image repository, identity role).
683 const transport = yield* ifClusterExists(adapter.connect(connection));
684 if (transport && (output.kubernetesObjects ?? []).length > 0) {
685 yield* deleteObjects({
686 transport,
687 objects: output.kubernetesObjects ?? [],
688 });
689 }
690
691 if (adapter.identity) {
692 yield* adapter.identity.delete({
693 connection,
694 state:
695 (output.identity as Record<string, unknown> | undefined) ??
696 (output as Record<string, unknown>),
697 });
698 }
699 if (adapter.registry) {
700 yield* adapter.registry.delete({
701 state:
702 (output.registry as Record<string, unknown> | undefined) ??
703 (output as Record<string, unknown>),
704 });
705 }
706 }),
707 };
708 }),
709 );