@alchemy.run/archil 0.0.0 → 2.0.0-beta.86

package/lib/Sandbox.d.ts

@@ -0,0 +1,507 @@
+import * as archil from "@distilled.cloud/archil";
+import { type MountCapability } from "alchemy/Mount";
+import { Platform, type Main, type PlatformProps } from "alchemy/Platform";
+import * as Provider from "alchemy/Provider";
+import type { LookupMethod, Resource } from "alchemy/Resource";
+import { type HostRuntimeContext, type ServerHost } from "alchemy/Runtime/Process";
+import { Stack } from "alchemy/Stack";
+import * as Effect from "effect/Effect";
+import type * as Redacted from "effect/Redacted";
+import { type ImagePush } from "./Image.ts";
+import { type ProgramBuildOptions, type ProgramExtraFile } from "./internal/hosted.ts";
+import type { Providers } from "./Providers.ts";
+import { MountDiskUnresolved, type DiskMount, type DiskMountOptions, type SandboxEgress, type SandboxEndpoint } from "./SandboxOptions.ts";
+declare const SandboxSetupFailed_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "Archil.SandboxSetupFailed";
+} & Readonly<A>;
+/** A disk a binding mounts into a program sandbox (`MountDisk` inside one). */
+/** A sandbox's `run` command exited non-zero. */
+export declare class SandboxSetupFailed extends SandboxSetupFailed_base<{
+    readonly sandbox: string;
+    readonly command: string;
+    readonly exitCode: number;
+    readonly stderr: string;
+}> {
+    get message(): string;
+}
+export interface SandboxMountBinding extends DiskMountOptions {
+    readonly diskId: string;
+}
+/**
+ * What bindings attach to a sandbox: its program's environment, disks it
+ * mounts natively (`SandboxMountBinding`), and filesystem clients other
+ * mount bindings install into its image (`MountCapability`, from
+ * `alchemy/Mount`).
+ */
+export interface SandboxBinding {
+    env?: Record<string, any>;
+    mounts?: ReadonlyArray<SandboxMountBinding | MountCapability>;
+}
+export interface SandboxProps extends PlatformProps {
+    /**
+     * Sandbox name, unique within your account: lowercase letters, digits
+     * and `-`, at most 63 characters. If omitted, a unique name is generated
+     * from the stack, stage, and logical ID. Changing it replaces the sandbox.
+     */
+    name?: string;
+    /**
+     * Image id from an {@link Image} (e.g. `image.imageId`), for a private
+     * image or a pinned digest. Exclusive with `baseImage`. Changing it
+     * replaces the sandbox.
+     */
+    image?: string;
+    /**
+     * Public OCI image reference with a `linux/amd64` manifest. Exclusive
+     * with `image`. Changing it replaces the sandbox.
+     * @default "node:24-bookworm"
+     */
+    baseImage?: string;
+    /** vCPUs, 1–32. Changing it replaces the sandbox. @default 1 */
+    vcpuCount?: number;
+    /** Memory in MiB, 256–65536. Changing it replaces the sandbox. @default 2048 */
+    memSizeMiB?: number;
+    /**
+     * TCP ports to serve publicly. Updated in place. When set, it is the
+     * whole list (plus the program's `port`): ports not in it are unexposed.
+     */
+    ports?: number[];
+    /**
+     * Let services inside the sandbox publish their own ingress.
+     * Changing it replaces the sandbox. @default false
+     */
+    enableServiceIngress?: boolean;
+    /**
+     * Environment variables. With `main`, they are the program's environment
+     * and a change restarts it. Without `main`, every process in the sandbox
+     * gets them, and a change replaces the sandbox.
+     */
+    env?: Record<string, string | Redacted.Redacted<string>>;
+    /** Outbound network policy. Updated in place. */
+    network?: {
+        egress?: SandboxEgress;
+    };
+    /**
+     * Disks to mount: a declared `Archil.Disk` (or the Effect that declares
+     * it) at a `path`. Updated in place: the sandbox stops, then starts with
+     * the new mounts, keeping its root filesystem.
+     */
+    mounts?: DiskMount[];
+    /**
+     * Seconds a powered-on session may run before the sandbox pauses
+     * (at most 24 hours). Changing it replaces the sandbox.
+     */
+    maxTtlSeconds?: number;
+    /**
+     * Seconds without a process connection before the sandbox pauses.
+     * `0` disables idle expiry. Updated in place.
+     */
+    idleTtlSeconds?: number;
+    /** Concurrent processes allowed. Changing it replaces the sandbox. */
+    maxConcurrentExecs?: number;
+    /**
+     * Shell commands run in the sandbox, in order, once it is created: clone
+     * a repository, install packages, warm a cache. A non-zero exit fails the
+     * deploy with `SandboxSetupFailed`. Changing them replaces the sandbox,
+     * so it starts again from its image and runs the new commands. Fork the
+     * result at run time with `Archil.CreateSandbox(sandbox)`.
+     */
+    run?: string[];
+    /**
+     * A program to run in the sandbox. In the Effect form, `import.meta.url`
+     * (the file is both the bundle entry and the program). In the async form,
+     * a path to a module whose default export has `fetch(request, env)`.
+     * A code change uploads it and restarts the program in place.
+     */
+    main?: string;
+    /** Named export to load from `main`. @default "default" */
+    handler?: string;
+    /**
+     * TCP port the program listens on, passed to it as `PORT`. Alchemy
+     * exposes it publicly and returns its URL as `url`.
+     * @default 3000
+     */
+    port?: number;
+    /**
+     * Bundler options for `main` (rolldown `input` / `output`), and
+     * `install`: packages to `npm install` next to the program instead of
+     * bundling them.
+     */
+    build?: ProgramBuildOptions;
+    /**
+     * Host files or directories uploaded with the program, e.g. a site's
+     * built assets. With `extraFiles`, an async `main` is treated as a
+     * complete Node program and uploaded as built instead of bundled.
+     * Their content is part of `code.hash`, so a change redeploys.
+     */
+    extraFiles?: ReadonlyArray<ProgramExtraFile>;
+    /**
+     * Where Alchemy pushes the sandbox's derived image, for Archil to pull.
+     * Only needed when a binding installs a filesystem client (an
+     * `alchemy/Mount` capability) into the program's image: Alchemy builds
+     * the base image plus those install lines with your local Docker.
+     */
+    push?: ImagePush;
+}
+export interface SandboxAttributes {
+    /** Sandbox id. */
+    sandboxId: string;
+    /** Sandbox name. */
+    name: string;
+    /** Lifecycle state when last observed, e.g. `running` or `paused`. */
+    status: string;
+    /** The image reference the sandbox boots. */
+    baseImage: string;
+    /** Digest of the booted image. */
+    imageDigest: string | undefined;
+    vcpuCount: number;
+    memSizeMiB: number;
+    /** Public hostnames of the exposed ports. */
+    endpoints: SandboxEndpoint[];
+    /** `https://` URL of the program's port, or of the first exposed port. */
+    url: string | undefined;
+    /** The port the program listens on, when the sandbox runs one. */
+    port: number | undefined;
+    /** Content hash of the deployed program, when the sandbox runs one. */
+    code: {
+        hash: string;
+    } | undefined;
+    /**
+     * The image Alchemy built for the sandbox (its base plus the install
+     * lines its bindings contribute), when it needed one.
+     */
+    derivedImage: {
+        imageId: string;
+        hash: string;
+    } | undefined;
+    /** Hash of the `run` commands the sandbox was set up with. */
+    setupHash: string | undefined;
+}
+export type Sandbox = Resource<"Archil.Sandbox", SandboxProps, SandboxAttributes, SandboxBinding, Providers, SandboxLookup>;
+/**
+ * Props for {@link Sandbox.lookup}: find a sandbox this stack
+ * doesn't manage by its name.
+ */
+export interface SandboxLookup {
+    /** Sandbox name. */
+    name: string;
+}
+export type SandboxShape = Main<ServerHost>;
+/**
+ * An Archil sandbox: a Firecracker microVM with disks mounted, public
+ * ports, and an outbound network policy that can inject credentials at the
+ * boundary. It pauses when idle and resumes on the next connection,
+ * keeping its memory.
+ *
+ * Declare one as a box (a dev box or a preview environment that outlives
+ * deploys), or give it a `main` and it runs your program: Alchemy bundles
+ * it, uploads it, and registers it with Archil's service manager, which
+ * restarts it when it crashes and starts it whenever the sandbox boots. Its
+ * port gets a public `https://` URL, and a request to a stopped sandbox
+ * starts it again, typically in a few seconds. A code change uploads the
+ * program and restarts it in place.
+ *
+ * Short-lived sandboxes for one user or task are created at run time with
+ * {@link CreateSandbox}; act on a declared one with {@link ConnectSandbox}.
+ *
+ * :::caution
+ * Changing the image, size, timeouts, or the `env` of a sandbox without
+ * `main` replaces the sandbox, and a new one starts with an empty root
+ * filesystem. Keep data on a mounted disk. `mounts`, `ports`, `network`
+ * and the program update in place.
+ * :::
+ *
+ * :::caution
+ * An exposed port is public: anyone with the URL can call it. Check
+ * requests yourself, or hand clients an `Archil.SandboxPortToken`.
+ * :::
+ * @see https://docs.archil.com/compute/sandboxes/introduction
+ *
+ * ### Creating a Sandbox
+ * **Example:** A dev box with a disk mounted
+ * ```typescript
+ * export const Workspace = Archil.Disk("Workspace", {});
+ * export const DevBox = Archil.Sandbox("DevBox", {
+ *   baseImage: "node:24-bookworm",
+ *   vcpuCount: 2,
+ *   memSizeMiB: 4096,
+ *   mounts: [{ disk: Workspace, path: "/workspace" }],
+ *   ports: [3000],
+ *   idleTtlSeconds: 600,
+ * });
+ * ```
+ *
+ * **Example:** A bigger sandbox that never pauses while idle
+ * ```typescript
+ * export const Box = Archil.Sandbox("Box", {
+ *   vcpuCount: 4,
+ *   memSizeMiB: 8192,
+ *   idleTtlSeconds: 0,
+ * });
+ * ```
+ *
+ * **Example:** Boot a private image
+ * ```typescript
+ * export const AgentImage = Archil.Image("AgentImage", {
+ *   image: "ghcr.io/acme/agent:1",
+ *   registry: { server: "ghcr.io", username: "acme", password: Config.Redacted("GHCR_TOKEN") },
+ * });
+ * export const Agent = Effect.gen(function* () {
+ *   const image = yield* AgentImage;
+ *   return yield* Archil.Sandbox("Agent", { image: image.imageId });
+ * });
+ * ```
+ *
+ * ### Setting Up at Deploy and Forking at Run Time
+ * **Example:** Clone a repository once, then fork the sandbox per task
+ * ```typescript
+ * export const Golden = Archil.Sandbox("Golden", {
+ *   run: ["git clone --depth 1 https://github.com/sindresorhus/is /work/is"],
+ * });
+ *
+ * // in a Worker or program:
+ * const sandboxes = yield* Archil.CreateSandbox(Golden);
+ * const task = yield* sandboxes.create({ name: "task-1" });
+ * const result = yield* task.exec("git log -1", { cwd: "/work/is" });
+ * ```
+ *
+ * ### Running a Program
+ * **Example:** An Effect program that reads a mounted disk
+ * ```typescript
+ * // src/Api.ts
+ * import * as Archil from "@alchemy.run/archil";
+ * import * as Effect from "effect/Effect";
+ * import * as FileSystem from "effect/FileSystem";
+ * import * as HttpServerResponse from "effect/http/HttpServerResponse";
+ *
+ * export const Dataset = Archil.Disk("Dataset", {});
+ *
+ * export default class Api extends Archil.Sandbox<Api>()(
+ *   "Api",
+ *   { main: import.meta.url, port: 3000 },
+ *   Effect.gen(function* () {
+ *     const dataset = yield* Archil.MountDisk(Dataset, { path: "/data", mode: "read-only" });
+ *     const fs = yield* FileSystem.FileSystem;
+ *     return {
+ *       fetch: Effect.gen(function* () {
+ *         return yield* HttpServerResponse.json(yield* fs.readDirectory(dataset.path));
+ *       }).pipe(Effect.orDie),
+ *     };
+ *   }).pipe(Effect.provide(Archil.MountDiskLive)),
+ * ) {}
+ * ```
+ *
+ * **Example:** A plain async handler with typed `env`
+ * ```typescript
+ * // src/infra.ts
+ * export const Hello = Archil.Sandbox("Hello", {
+ *   main: "./src/hello.ts",
+ *   env: { GREETING: "hello" },
+ * });
+ * export type HelloEnv = Archil.InferEnv<typeof Hello>;
+ * ```
+ *
+ * ```typescript
+ * // src/hello.ts
+ * import type { HelloEnv } from "./infra.ts";
+ *
+ * export default {
+ *   async fetch(request: Request, env: HelloEnv) {
+ *     return new Response(`${env.GREETING} from ${new URL(request.url).pathname}`);
+ *   },
+ * };
+ * ```
+ *
+ * **Example:** Secrets in the program's environment
+ * ```typescript
+ * export const Billing = Archil.Sandbox("Billing", {
+ *   main: "./src/billing.ts",
+ *   env: { STRIPE_KEY: Config.Redacted("STRIPE_KEY") },
+ * });
+ * ```
+ *
+ * ### Mounting Disks
+ * Archil sandboxes mount disks natively. Each entry names the disk and a
+ * `path`, with Archil's own options: `mode` (`exclusive`, `conditional`
+ * or `read-only`), `subdirectory`, and `queueMs`.
+ *
+ * **Example:** Mount two disks, one read-only
+ * ```typescript
+ * export const Box = Archil.Sandbox("Box", {
+ *   mounts: [
+ *     { disk: Workspace, path: "/workspace" },
+ *     { disk: Dataset, path: "/data", mode: "read-only" },
+ *   ],
+ * });
+ * ```
+ *
+ * **Example:** Mount from the program with `MountDisk`
+ * ```typescript
+ * const uploads = yield* Archil.MountDisk(Uploads, { path: "/uploads", mode: "conditional" });
+ * // runtime: the disk is already mounted at uploads.path
+ * yield* fs.writeFileString(`${uploads.path}/${id}.txt`, body);
+ * ```
+ *
+ * ### Mount Clients From Other Bindings
+ * A binding that installs a filesystem client (an `alchemy/Mount`
+ * capability) into a program's image makes Alchemy build one: the
+ * sandbox's base plus the client's install lines, built with your local
+ * Docker and pushed to `push.repository` for Archil to pull. A different
+ * set of clients replaces the sandbox.
+ *
+ * **Example:** Give a program sandbox a repository for its derived image
+ * ```typescript
+ * export default class Indexer extends Archil.Sandbox<Indexer>()(
+ *   "Indexer",
+ *   {
+ *     main: import.meta.url,
+ *     push: {
+ *       repository: "ghcr.io/acme/indexer",
+ *       credentials: { server: "ghcr.io", username: "acme-bot", password: Alchemy.Secret("GHCR_TOKEN") },
+ *     },
+ *   },
+ *   Effect.gen(function* () {
+ *     const media = yield* Cloud.MountBucket(Media, { path: "/media" }); // installs a FUSE client
+ *     return { fetch: Effect.succeed(HttpServerResponse.text(media.path)) };
+ *   }),
+ * ) {}
+ * ```
+ *
+ * ### Packaging
+ * Alchemy bundles `main` with rolldown into one Node program. Packages
+ * that can't be bundled (native modules, or ones that read their own files
+ * at run time) go in `build.install` and are installed next to it with
+ * `npm install`.
+ *
+ * **Example:** Install a native package
+ * ```typescript
+ * export const Thumbs = Archil.Sandbox("Thumbs", {
+ *   main: "./src/thumbs.ts",
+ *   build: { install: ["sharp"] },
+ * });
+ * ```
+ *
+ * **Example:** Upload static files next to the program
+ * ```typescript
+ * export const Site = Archil.Sandbox("Site", {
+ *   main: "./dist/server.mjs",
+ *   extraFiles: [{ source: "./dist/client", destination: "client" }],
+ * });
+ * ```
+ *
+ * ### Ports
+ * **Example:** Serve a port and hand out a token for it
+ * ```typescript
+ * export const Preview = Archil.Sandbox("Preview", { ports: [8080] });
+ * export const PreviewToken = Effect.gen(function* () {
+ *   const preview = yield* Preview;
+ *   return yield* Archil.SandboxPortToken("PreviewToken", {
+ *     sandbox: preview.sandboxId,
+ *     port: 8080,
+ *     ttl: "24h",
+ *   });
+ * });
+ * ```
+ *
+ * ### Network Policy
+ * **Example:** Deny by default, inject a token for one API
+ * ```typescript
+ * export const Agent = Archil.Sandbox("Agent", {
+ *   network: {
+ *     egress: {
+ *       default: "deny",
+ *       allow: [
+ *         "registry.npmjs.org",
+ *         { target: "api.github.com", headers: { Authorization: Alchemy.Secret("GITHUB_AUTH") } },
+ *       ],
+ *     },
+ *   },
+ * });
+ * ```
+ *
+ * **Example:** Forward an API's requests to a Worker gateway that adds the key
+ * ```typescript
+ * const gateway = yield* MyGateway;
+ * const sandbox = yield* Archil.Sandbox("MySandbox", {
+ *   network: {
+ *     egress: {
+ *       default: "deny",
+ *       allow: [
+ *         {
+ *           target: "api.example.com",
+ *           // proves to the gateway that the request came through this policy
+ *           headers: { "X-Gateway-Token": Config.Redacted("GATEWAY_TOKEN") },
+ *           forwardUrl: gateway.url.as<string>(),
+ *         },
+ *       ],
+ *     },
+ *   },
+ * });
+ * ```
+ *
+ * ### Using a Sandbox at Run Time
+ * **Example:** Run a command and fork a preview from a Worker
+ * ```typescript
+ * const preview = yield* Archil.ConnectSandbox(Preview);
+ * const result = yield* preview.exec("pnpm build", { cwd: "/workspace" });
+ * const fork = yield* preview.fork({ name: "pr-42" });
+ * ```
+ *
+ * ### Looking up an existing sandbox
+ * `Sandbox.lookup` references a sandbox Alchemy doesn't manage (created in
+ * the Archil console or by another stack). It is read during plan/deploy,
+ * never created, updated or deleted.
+ * Its program fields are `undefined`: they come from the deploy that started
+ * the sandbox's program.
+ *
+ * **Example:** Reference an existing sandbox
+ * ```typescript
+ * const box = Archil.Sandbox.lookup({ name: "research" });
+ * ```
+ *
+ * @resource
+ * @product Sandbox
+ */
+export declare const Sandbox: Platform<Sandbox, ServerHost, SandboxShape, HostRuntimeContext> & LookupMethod<Sandbox>;
+/**
+ * Map a sandbox and its exposed ports to attributes. Archil lists port
+ * hostnames separately; sandbox responses don't carry them. `program` is
+ * the port and code of the program the sandbox runs, if any.
+ */
+export declare const toSandboxAttributes: (sandbox: archil.Sandbox, ports: ReadonlyArray<{
+    port: number;
+    hostname: string;
+}>, program?: {
+    readonly port: number;
+    readonly code: {
+        hash: string;
+    };
+}, derivedImage?: {
+    readonly imageId: string;
+    readonly hash: string;
+}) => SandboxAttributes;
+/** Read a sandbox's exposed ports and map it to attributes. */
+export declare const observeSandbox: (sandbox: archil.Sandbox, program?: {
+    readonly port: number;
+    readonly code: {
+        hash: string;
+    };
+} | undefined, derivedImage?: {
+    readonly imageId: string;
+    readonly hash: string;
+} | undefined) => Effect.Effect<SandboxAttributes, archil.ArchilParseError | archil.BadGateway | import("@distilled.cloud/core/errors").BadRequest | archil.ConfigError | import("@distilled.cloud/core/errors").Conflict | import("@distilled.cloud/core/errors").Forbidden | archil.GatewayTimeout | import("effect/http/HttpClientError").HttpClientError | archil.InternalServerError | import("@distilled.cloud/core/protocol-http").InvalidInput | archil.Locked | import("@distilled.cloud/core/sdk-error").SdkError | archil.ServiceUnavailable | archil.TooManyRequests | archil.Unauthorized | archil.UnknownArchilError | archil.UnprocessableEntity, archil.ArchilOpContext>;
+/** The create request for sandbox props, with mounts already on the wire. */
+export declare const toCreateSandboxRequest: (name: string | undefined, props: Omit<SandboxProps, "name" | "mounts">, mounts: ReadonlyArray<archil.SandboxMount> | undefined) => archil.CreateSandboxRequest;
+/**
+ * Delete a sandbox and wait until it is gone. Archil only deletes stopped,
+ * exited or failed sandboxes, so a live one is stopped first. Deleting a
+ * missing sandbox succeeds.
+ */
+export declare const deleteSandbox: (sid: string) => Effect.Effect<void, import("./index.ts").ArchilFailed | import("./index.ts").ArchilNotReady | archil.ArchilParseError | archil.BadGateway | import("@distilled.cloud/core/errors").BadRequest | archil.BadRequest | archil.ConfigError | import("@distilled.cloud/core/errors").Conflict | import("@distilled.cloud/core/errors").Forbidden | archil.GatewayTimeout | import("effect/http/HttpClientError").HttpClientError | archil.InternalServerError | import("@distilled.cloud/core/protocol-http").InvalidInput | archil.Locked | archil.SandboxHasForks | archil.SandboxNotDeletable | archil.SandboxStopConflict | import("@distilled.cloud/core/sdk-error").SdkError | archil.ServiceUnavailable | archil.TooManyRequests | archil.Unauthorized | archil.UnknownArchilError | archil.UnprocessableEntity, archil.ArchilOpContext>;
+/**
+ * Wire mounts for a list of entries whose disks resolved to attributes or
+ * handles. Fails when a disk has no id yet.
+ */
+export declare const toSandboxMounts: (owner: string, mounts: readonly DiskMount[]) => Effect.Effect<archil.SandboxMount[], MountDiskUnresolved | import("./SandboxOptions.ts").MountOptionUnsupported, never>;
+export declare const SandboxProvider: () => import("effect/Layer").Layer<Provider.Provider<Sandbox>, never, import("effect/process/ChildProcessSpawner").ChildProcessSpawner | import("@alchemy.run/docker/Docker").Docker | import("effect/FileSystem").FileSystem | import("effect/Path").Path | Stack | import("alchemy").Stage | archil.ArchilOpContext>;
+export {};
+//# sourceMappingURL=Sandbox.d.ts.map

package/lib/Sandbox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Sandbox.d.ts","sources":["../src/Sandbox.ts"],"names":[],"mappings":"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"}