@alchemy.run/daytona 0.0.0-stage → 2.0.0-beta.86

package/lib/Sandbox.d.ts

@@ -0,0 +1,376 @@
+import * as sandboxes from "@distilled.cloud/daytona/sandbox";
+import type * as Bundle from "alchemy/Bundle/Bundle";
+import type { MountCapability } from "alchemy/Mount";
+import { Platform, type Main, type PlatformProps } from "alchemy/Platform";
+import * as Provider from "alchemy/Provider";
+import type { Resource, LookupMethod } from "alchemy/Resource";
+import { type HostRuntimeContext, type ServerHost } from "alchemy/Runtime/Process";
+import { Stack } from "alchemy/Stack";
+import type * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import { type ProgramState } from "./internal/Program.ts";
+import { type Ref } from "./internal/Ref.ts";
+import type { Providers } from "./Providers.ts";
+/** A snapshot, by name. Accepts a `Daytona.Snapshot` or `{ name }`. */
+export type SandboxSnapshot = {
+    readonly name: string;
+};
+/** A volume, by id. Accepts a `Daytona.Volume` or `{ volumeId }`. */
+export type SandboxVolumeRef = {
+    readonly volumeId: string;
+};
+/** A secret, by name. Accepts a `Daytona.Secret` or `{ name }`. */
+export type SandboxSecretRef = {
+    readonly name: string;
+};
+/** A volume mounted into a sandbox. */
+export interface SandboxMount {
+    /** The volume to mount: a `Daytona.Volume`. */
+    volume: Ref<SandboxVolumeRef>;
+    /** Absolute path in the sandbox. */
+    path: string;
+    /** Mount only this directory of the volume. */
+    subpath?: string;
+}
+/** A volume a binding mounts into a sandbox (`Daytona.MountVolume`). */
+export interface SandboxVolumeBinding {
+    volumeId: string;
+    path: string;
+    subpath?: string;
+}
+/**
+ * What bindings attach to a sandbox that runs a program: environment
+ * variables for the process, and `mounts`: volumes to mount
+ * (`Daytona.MountVolume`), or `alchemy/Mount` capabilities whose clients
+ * the sandbox's image needs (a derived snapshot installs them).
+ */
+export interface SandboxBinding {
+    env?: Record<string, any>;
+    mounts?: ReadonlyArray<SandboxVolumeBinding | MountCapability>;
+}
+/** Another sandbox, by id. Accepts a `Daytona.Sandbox` or `{ sandboxId }`. */
+export type SandboxLinkRef = {
+    readonly sandboxId: string;
+};
+/** Whether the sandbox should be running, stopped (disk kept) or archived (moved to object storage). */
+export type SandboxRunState = "started" | "stopped" | "archived";
+export interface SandboxProps extends PlatformProps {
+    /**
+     * Sandbox name, unique in the organization. If omitted, a unique name is
+     * generated from the stack, stage and logical ID. Changing it replaces
+     * the sandbox.
+     */
+    name?: string;
+    /**
+     * Snapshot to boot from. Defaults to Daytona's default snapshot. The
+     * snapshot sets the sandbox's CPU, memory, disk and GPUs: declare a
+     * `Daytona.Snapshot` with the size you want. Changing it replaces the
+     * sandbox.
+     */
+    snapshot?: Ref<SandboxSnapshot>;
+    /** OS user commands run as. Changing it replaces the sandbox. */
+    user?: string;
+    /**
+     * Environment variables. On a sandbox without `main` they are the
+     * sandbox's, and changing them replaces it. On a sandbox with `main`
+     * they are the program's, and changing them restarts it.
+     */
+    env?: Record<string, any>;
+    /**
+     * Secrets exposed as environment variables, keyed by variable name. The
+     * sandbox sees each secret's placeholder; Daytona swaps in the value only
+     * on requests to the secret's `hosts`. Updated in place.
+     */
+    secrets?: Record<string, Ref<SandboxSecretRef>>;
+    /** Labels. Updated in place. */
+    labels?: Record<string, string>;
+    /** Whether preview URLs work without a token. Updated in place. @default false */
+    public?: boolean;
+    /** Block all outbound traffic. Updated in place. @default false */
+    networkBlockAll?: boolean;
+    /** CIDR ranges outbound traffic may reach (at most 10). Updated in place. */
+    networkAllowList?: string[];
+    /** Domains outbound traffic may reach (at most 100). Updated in place. */
+    domainAllowList?: string[];
+    /**
+     * A forward proxy for the sandbox's HTTP(S) traffic, set as `HTTP_PROXY`
+     * and `HTTPS_PROXY` in the sandbox, and enforced at the network only with a
+     * `domainAllowList`. HTTPS reaches it as `CONNECT` tunnels, so a Cloudflare
+     * Worker can't serve it. The sandbox can read the URL. Changing it
+     * replaces the sandbox.
+     */
+    outboundProxyUrl?: string;
+    /** Region. Changing it replaces the sandbox. */
+    target?: string;
+    /**
+     * Run a GPU sandbox on spot capacity: cheaper, but Daytona can end it
+     * without notice. Changing it replaces the sandbox.
+     */
+    spot?: boolean;
+    /** Expose `/dev/kvm` (VM sandboxes). Changing it replaces the sandbox. */
+    kvm?: boolean;
+    /**
+     * Volumes to mount. A program's `Daytona.MountVolume` bindings add to
+     * them. Changing them replaces the sandbox.
+     */
+    mounts?: SandboxMount[];
+    /** Stop after this long without activity. `0` never stops. Updated in place. @default "15 minutes" */
+    autoStopInterval?: Duration.Input;
+    /**
+     * Pause (memory kept) after this long without activity. Only `linux-vm`
+     * and `windows` sandboxes can pause; a container fails with
+     * `AutoPauseNotSupported`. Updated in place.
+     */
+    autoPauseInterval?: Duration.Input;
+    /** Archive after being stopped this long. Updated in place. @default "7 days" */
+    autoArchiveInterval?: Duration.Input;
+    /** Delete after being stopped this long. Updated in place. */
+    autoDeleteInterval?: Duration.Input;
+    /**
+     * Destroy the sandbox this long after it is created (or after the deploy
+     * that last changed it), whatever its state. Changing it restarts the
+     * clock from now. `0` disables it, unless the region caps sandbox lifespan.
+     */
+    ttl?: Duration.Input;
+    /**
+     * Give up if no runner takes the sandbox within this long. The
+     * organization needs the queue-timeout feature; without it, creating the
+     * sandbox fails with `QueueTimeoutNotEnabled`. Only used when the sandbox
+     * is created.
+     */
+    queueTimeout?: Duration.Input;
+    /**
+     * Schedule the sandbox on the same runner as this one, so the two share
+     * a local network. Both must be ephemeral (`autoDeleteInterval: 0`), and
+     * neither can have GPUs. Changing it replaces the sandbox.
+     */
+    linkedSandbox?: Ref<SandboxLinkRef>;
+    /**
+     * Send the sandbox's OpenTelemetry data here instead of Daytona's
+     * collector. It then doesn't show in Daytona's dashboard or the
+     * telemetry API. Changing it replaces the sandbox.
+     */
+    otelEndpointOverride?: string;
+    /**
+     * Whether the sandbox should be running, stopped (disk kept) or archived
+     * (disk moved to object storage). Archiving can take many minutes, so a
+     * deploy returns once Daytona has started it. Updated in place.
+     * @default "started"
+     */
+    state?: SandboxRunState;
+    /**
+     * Module entrypoint of a program to run in the sandbox, typically
+     * `import.meta.url` in the class form. Alchemy bundles it, uploads it
+     * into the sandbox and runs it with Node; a code change uploads it again
+     * and restarts the process, without replacing the sandbox. The snapshot
+     * needs Node.js 20 or later (Daytona's default snapshot has Node 24).
+     */
+    main?: string;
+    /**
+     * Port the program listens on. Written to `PORT`; the sandbox's preview
+     * URL of this port is `url`.
+     * @default 3000
+     */
+    port?: number;
+    /**
+     * Named export to load from `main`.
+     * @default "default"
+     */
+    handler?: string;
+    /** Bundler configuration for `main`. */
+    build?: Bundle.BundleConfig;
+}
+export interface SandboxAttributes {
+    /** Sandbox ID. */
+    sandboxId: string;
+    /** Sandbox name. */
+    name: string;
+    /** Organization ID. */
+    organizationId: string;
+    /** Snapshot it booted from. */
+    snapshot: string | undefined;
+    /** Current state. */
+    state: sandboxes.SandboxState | undefined;
+    /** Region. */
+    target: string;
+    /** vCPUs. */
+    cpu: number;
+    /** Memory in GiB. */
+    memory: number;
+    /** Disk in GiB. */
+    disk: number;
+    /** GPUs. */
+    gpu: number;
+    /** Sandbox class: `container`, `linux-vm` or `windows`, set by the snapshot. */
+    sandboxClass: sandboxes.SandboxSandboxClass | undefined;
+    /** When the TTL destroys the sandbox, if one is set. */
+    autoDestroyAt: string | undefined;
+    /** ID of the sandbox it shares a runner with. */
+    linkedSandboxId: string | undefined;
+    /** Labels you set (alchemy's ownership labels excluded). */
+    labels: Record<string, string>;
+    /** Whether previews are public. */
+    public: boolean;
+    /** Base URL of the sandbox's toolbox proxy. */
+    toolboxProxyUrl: string;
+    /**
+     * Preview URL of the program's port, for a sandbox with `main`. It is
+     * open when the sandbox is `public`; otherwise send the preview token
+     * (`getPortPreviewUrl`) in `X-Daytona-Preview-Token`.
+     */
+    url: string | undefined;
+    /** The program the sandbox runs, for a sandbox with `main`. */
+    program: ProgramState | undefined;
+    /**
+     * The snapshot built for this sandbox when its bindings need clients
+     * installed (`alchemy/Mount` capabilities): `FROM` its snapshot plus their
+     * install lines. Deleted with the sandbox.
+     */
+    derivedSnapshot: string | undefined;
+}
+export type Sandbox = Resource<"Daytona.Sandbox", SandboxProps, SandboxAttributes, SandboxBinding, Providers, SandboxLookup>;
+/**
+ * Props for {@link Sandbox.lookup}: find a sandbox this stack
+ * doesn't manage by its name or id.
+ */
+export interface SandboxLookup {
+    /** Sandbox name or id. */
+    name: string;
+}
+export type SandboxServices = ServerHost;
+/** A program's shape: a long-running server returning `{ fetch }`, or `host.run` loops. */
+export type SandboxShape = Main<SandboxServices>;
+export type SandboxRuntimeContext = HostRuntimeContext;
+/**
+ * A long-lived Daytona sandbox: an isolated machine with its own
+ * filesystem, processes and network, for a dev box, a preview environment
+ * or a persistent agent workspace. Its disk survives stops; Daytona stops
+ * it when idle and archives it later, and deploy starts it again.
+ *
+ * The class form runs an Effect program in the sandbox: give it `main`
+ * and an implementation, and Alchemy bundles the program, uploads it and
+ * runs it with Node, served on the sandbox's preview URL (`url`). A code
+ * change uploads the new bundle and restarts the process; the sandbox and
+ * its URL stay the same. The process lives as long as the sandbox runs,
+ * so a sandbox with `main` never auto-stops unless `autoStopInterval` says
+ * so; if it stopped anyway, the next deploy starts it and the program.
+ *
+ * For sandboxes created per request or per task, use
+ * {@link CreateSandbox} at runtime instead; for one declared here, use
+ * {@link ConnectSandbox} to run commands in it from a Worker.
+ * @see https://www.daytona.io/docs/en/sandboxes/
+ *
+ * ### Creating a Sandbox
+ * **Example:** A dev box from a snapshot
+ * ```typescript
+ * export const DevBox = Daytona.Sandbox("DevBox", {
+ *   snapshot: Base,
+ *   autoStopInterval: "30 minutes",
+ * });
+ * ```
+ *
+ * ### Restricting the Network
+ * **Example:** Only GitHub and npm are reachable
+ * ```typescript
+ * export const Locked = Daytona.Sandbox("Locked", {
+ *   snapshot: Base,
+ *   domainAllowList: ["github.com", "registry.npmjs.org"],
+ * });
+ * ```
+ *
+ * ### Volumes and Secrets
+ * **Example:** A shared cache volume and an npm token only sent to npm
+ * ```typescript
+ * export const Builder = Daytona.Sandbox("Builder", {
+ *   snapshot: Base,
+ *   mounts: [{ volume: Cache, path: "/cache" }],
+ *   secrets: { NPM_TOKEN: NpmToken },
+ * });
+ * ```
+ *
+ * ### Running a Program
+ * **Example:** An HTTP server with a mounted volume
+ * ```typescript
+ * export default class Agent extends Daytona.Sandbox<Agent>()(
+ *   "Agent",
+ *   { snapshot: Base, main: import.meta.url, public: true },
+ *   Effect.gen(function* () {
+ *     const data = yield* Daytona.MountVolume(Data, { path: "/data" });
+ *     const fs = yield* FileSystem.FileSystem;
+ *     return {
+ *       fetch: Effect.gen(function* () {
+ *         return yield* HttpServerResponse.json(yield* fs.readDirectory(data.path));
+ *       }),
+ *     };
+ *   }).pipe(Effect.provide(Daytona.MountVolumeLive)),
+ * ) {}
+ * ```
+ *
+ * A mount binding that needs a client in the image (an `alchemy/Mount`
+ * capability) makes the sandbox boot from a derived snapshot: its snapshot
+ * plus the client's install lines, built on Daytona, named from a hash and
+ * deleted with the sandbox. Sandboxes provide FUSE; a client that needs
+ * NFS fails with `MountUnsupported`.
+ *
+ * The program reaches the internet as its sandbox does. Below Daytona's
+ * Tier 3, sandboxes reach only an allowlist of essential services
+ * (package registries, GitHub, AI APIs, Daytona's API), so bindings that
+ * manage sandboxes work but toolbox calls are refused.
+ *
+ * ### GPUs
+ * A GPU sandbox boots from a GPU snapshot, such as Daytona's `daytona-gpu`
+ * (one H100) in its `earth` region, and must be ephemeral. The
+ * organization needs GPU credits in its wallet.
+ *
+ * **Example:** An ephemeral H100 sandbox on spot capacity
+ * ```typescript
+ * export const Trainer = Daytona.Sandbox("Trainer", {
+ *   snapshot: { name: "daytona-gpu" },
+ *   target: "earth",
+ *   autoDeleteInterval: 0,
+ *   spot: true,
+ * });
+ * ```
+ *
+ * ### Limiting Its Lifetime
+ * **Example:** Destroyed two hours after it is created
+ * ```typescript
+ * export const Scratch = Daytona.Sandbox("Scratch", { ttl: "2 hours" });
+ * ```
+ *
+ * ### Sharing a Runner
+ * **Example:** A database and an app on one local network
+ * ```typescript
+ * export const Db = Daytona.Sandbox("Db", { autoDeleteInterval: 0 });
+ * export const App = Daytona.Sandbox("App", {
+ *   autoDeleteInterval: 0,
+ *   linkedSandbox: Db,
+ * });
+ * ```
+ *
+ * ### Looking up an existing sandbox
+ * `Sandbox.lookup` references a sandbox Alchemy doesn't manage (created in
+ * the Daytona dashboard or by another stack). It is read during plan/deploy,
+ * never created, updated or deleted.
+ * `url` and `program` are `undefined`: they come from the deploy that started
+ * the sandbox's program.
+ *
+ * **Example:** Reference an existing sandbox
+ * ```typescript
+ * const box = Daytona.Sandbox.lookup({ name: "research" });
+ * ```
+ *
+ * @resource
+ * @product Sandbox
+ */
+export declare const Sandbox: Platform<Sandbox, SandboxServices, SandboxShape, SandboxRuntimeContext> & LookupMethod<Sandbox>;
+/** What both `getSandbox` and the sandbox list return. */
+export type SandboxInfo = Omit<sandboxes.Sandbox2, "env" | "kvm">;
+export declare const toSandboxAttributes: (s: SandboxInfo) => SandboxAttributes;
+export declare const getSandbox: (idOrName: string) => Effect.Effect<sandboxes.Sandbox2 | undefined, sandboxes.DaytonaOpError, sandboxes.DaytonaOpContext>;
+export declare const waitForSandbox: (idOrName: string, want?: SandboxRunState | "paused") => Effect.Effect<sandboxes.Sandbox2, import("./internal/Wait.ts").StateFailed | import("./internal/Wait.ts").StateTimeout | sandboxes.GetSandboxError, sandboxes.DaytonaOpContext>;
+/** Move a sandbox to the run state it should be in. */
+export declare const syncRunState: (current: sandboxes.Sandbox2, want: SandboxRunState) => Effect.Effect<sandboxes.Sandbox2, import("./internal/Wait.ts").StateFailed | import("./internal/Wait.ts").StateTimeout | sandboxes.GetSandboxError, sandboxes.DaytonaOpContext>;
+export declare const deleteSandboxById: (idOrName: string) => Effect.Effect<void, import("./internal/Wait.ts").StateTimeout | sandboxes.DaytonaOpError, sandboxes.DaytonaOpContext>;
+export declare const SandboxProvider: () => import("effect/Layer").Layer<Provider.Provider<Sandbox>, never, import("effect/FileSystem").FileSystem | import("effect/Path").Path | Stack | import("alchemy/Stage").Stage | sandboxes.DaytonaOpContext>;
+//# 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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"}