@distilled.cloud/daytona 0.0.0-placeholder → 1.0.0-rc.13

package/src/services/snapshots.ts

@@ -0,0 +1,508 @@
+// AUTO-GENERATED by scripts/generate.ts from .generated-specs (specs/spec-mirror-daytona/specs/{openapi,toolbox-openapi,analytics-openapi}.json). Do not edit.
+import * as S from "@distilled.cloud/core/schema";
+import * as API from "@distilled.cloud/core/api";
+import * as T from "../traits.ts";
+import {
+  DaytonaProtocol,
+  type DaytonaOpError,
+  type DaytonaOpContext,
+} from "../protocol.ts";
+import { UnknownDaytonaError } from "../errors.ts";
+import * as Retry from "../retry.ts";
+
+export type { DaytonaOpError, DaytonaOpContext };
+
+export interface ActivateSnapshotRequest {
+  /** Snapshot ID */
+  id: string;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const ActivateSnapshotRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String.pipe(T.Label()),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+  }).pipe(
+    T.Http({ method: "POST", uri: "/snapshots/{id}/activate", code: 200 }),
+  ),
+).annotate({
+  identifier: "ActivateSnapshotRequest",
+}) as any as S.Schema<ActivateSnapshotRequest>;
+
+export type SnapshotState =
+  | "building"
+  | "pending"
+  | "pulling"
+  | "snapshotting"
+  | "active"
+  | "inactive"
+  | "error"
+  | "build_failed"
+  | "removing";
+export const SnapshotState = S.String;
+
+export type SnapshotDtoEntrypointList = Array<string>;
+export const SnapshotDtoEntrypointList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<SnapshotDtoEntrypointList>;
+
+export type GpuType =
+  | "H100"
+  | "H200"
+  | "RTX-PRO-6000"
+  | "RTX-4090"
+  | "RTX-5090"
+  | "MI355X";
+export const GpuType = S.String;
+
+/** The context hashes used for the build */
+export type BuildInfoContextHashesList = Array<string>;
+export const BuildInfoContextHashesList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<BuildInfoContextHashesList>;
+
+export interface BuildInfo {
+  /** The Dockerfile content used for the build */
+  dockerfileContent?: string;
+  /** The context hashes used for the build */
+  contextHashes?: BuildInfoContextHashesList;
+  /** The creation timestamp */
+  createdAt: string;
+  /** The last update timestamp */
+  updatedAt: string;
+  /** The snapshot reference */
+  snapshotRef: string;
+}
+export const BuildInfo = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    dockerfileContent: S.optional(S.String),
+    contextHashes: S.optional(BuildInfoContextHashesList),
+    createdAt: S.String,
+    updatedAt: S.String,
+    snapshotRef: S.String,
+  }),
+).annotate({ identifier: "BuildInfo" }) as any as S.Schema<BuildInfo>;
+
+/** IDs of regions where the snapshot is available */
+export type SnapshotDtoRegionIdsList = Array<string>;
+export const SnapshotDtoRegionIdsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<SnapshotDtoRegionIdsList>;
+
+/** The sandbox class of the snapshot */
+export type SnapshotDtoSandboxClass =
+  | "linux-vm"
+  | "container"
+  | "android"
+  | "windows";
+export const SnapshotDtoSandboxClass = S.String;
+
+export interface SnapshotDto {
+  id: string;
+  organizationId?: string;
+  general: boolean;
+  name: string;
+  imageName?: string;
+  state: SnapshotState;
+  size: number | null;
+  entrypoint: SnapshotDtoEntrypointList | null;
+  cpu: number;
+  gpu: number;
+  /** The GPU type assigned to the snapshot */
+  gpuType?: GpuType;
+  mem: number;
+  disk: number;
+  errorReason: string | null;
+  createdAt: string;
+  updatedAt: string;
+  lastUsedAt: string | null;
+  /** Build information for the snapshot */
+  buildInfo?: BuildInfo;
+  /** IDs of regions where the snapshot is available */
+  regionIds?: SnapshotDtoRegionIdsList;
+  /** The initial runner ID of the snapshot */
+  initialRunnerId?: string;
+  /** The snapshot reference */
+  ref?: string;
+  /** The ID of the sandbox the snapshot was created from */
+  sourceSandboxId: string | null;
+  /** The sandbox class of the snapshot */
+  sandboxClass?: SnapshotDtoSandboxClass;
+}
+export const SnapshotDto = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String,
+    organizationId: S.optional(S.String),
+    general: S.Boolean,
+    name: S.String,
+    imageName: S.optional(S.String),
+    state: SnapshotState,
+    size: S.NullOr(S.Number),
+    entrypoint: S.NullOr(SnapshotDtoEntrypointList),
+    cpu: S.Number,
+    gpu: S.Number,
+    gpuType: S.optional(GpuType),
+    mem: S.Number,
+    disk: S.Number,
+    errorReason: S.NullOr(S.String),
+    createdAt: S.String,
+    updatedAt: S.String,
+    lastUsedAt: S.NullOr(S.String),
+    buildInfo: S.optional(BuildInfo),
+    regionIds: S.optional(SnapshotDtoRegionIdsList),
+    initialRunnerId: S.optional(S.String),
+    ref: S.optional(S.String),
+    sourceSandboxId: S.NullOr(S.String),
+    sandboxClass: S.optional(SnapshotDtoSandboxClass),
+  }),
+).annotate({ identifier: "SnapshotDto" }) as any as S.Schema<SnapshotDto>;
+
+/** The entrypoint command for the snapshot */
+export type CreateSnapshotRequestEntrypointList = Array<string>;
+export const CreateSnapshotRequestEntrypointList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<CreateSnapshotRequestEntrypointList>;
+
+/** Preferred GPU type for the resulting sandbox. */
+export type CreateSnapshotRequestGpuTypeList = Array<GpuType | (string & {})>;
+export const CreateSnapshotRequestGpuTypeList = /*@__PURE__*/ S.Array(
+  GpuType,
+) as any as S.Schema<CreateSnapshotRequestGpuTypeList>;
+
+/** The context hashes used for the build */
+export type CreateBuildInfoContextHashesList = Array<string>;
+export const CreateBuildInfoContextHashesList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<CreateBuildInfoContextHashesList>;
+
+export interface CreateBuildInfo {
+  /** The Dockerfile content used for the build */
+  dockerfileContent: string;
+  /** The context hashes used for the build */
+  contextHashes?: CreateBuildInfoContextHashesList;
+}
+export const CreateBuildInfo = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    dockerfileContent: S.String,
+    contextHashes: S.optional(CreateBuildInfoContextHashesList),
+  }),
+).annotate({
+  identifier: "CreateBuildInfo",
+}) as any as S.Schema<CreateBuildInfo>;
+
+export type SandboxClass = "linux-vm" | "container" | "android" | "windows";
+export const SandboxClass = S.String;
+
+export interface CreateSnapshotRequest {
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+  /** The name of the snapshot */
+  name: string;
+  /** The image name of the snapshot */
+  imageName?: string;
+  /** The entrypoint command for the snapshot */
+  entrypoint?: CreateSnapshotRequestEntrypointList;
+  /** CPU cores allocated to the resulting sandbox */
+  cpu?: number;
+  /** GPU units allocated to the resulting sandbox */
+  gpu?: number;
+  /** Preferred GPU type for the resulting sandbox. */
+  gpuType?: CreateSnapshotRequestGpuTypeList;
+  /** Memory allocated to the resulting sandbox in GB */
+  memory?: number;
+  /** Disk space allocated to the sandbox in GB */
+  disk?: number;
+  /** Build information for the snapshot */
+  buildInfo?: CreateBuildInfo;
+  /** ID of the region where the snapshot will be available. Defaults to organization default region if not specified. */
+  regionId?: string;
+  /** Target sandbox class. Determines which runners can host sandboxes created from this snapshot. */
+  sandboxClass?: SandboxClass | (string & {});
+}
+export const CreateSnapshotRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+    name: S.String,
+    imageName: S.optional(S.String),
+    entrypoint: S.optional(CreateSnapshotRequestEntrypointList),
+    cpu: S.optional(S.Number),
+    gpu: S.optional(S.Number),
+    gpuType: S.optional(CreateSnapshotRequestGpuTypeList),
+    memory: S.optional(S.Number),
+    disk: S.optional(S.Number),
+    buildInfo: S.optional(CreateBuildInfo),
+    regionId: S.optional(S.String),
+    sandboxClass: S.optional(SandboxClass),
+  }).pipe(T.Http({ method: "POST", uri: "/snapshots", code: 200 })),
+).annotate({
+  identifier: "CreateSnapshotRequest",
+}) as any as S.Schema<CreateSnapshotRequest>;
+
+export interface DeactivateSnapshotRequest {
+  /** Snapshot ID */
+  id: string;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const DeactivateSnapshotRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String.pipe(T.Label()),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+  }).pipe(
+    T.Http({ method: "POST", uri: "/snapshots/{id}/deactivate", code: 200 }),
+  ),
+).annotate({
+  identifier: "DeactivateSnapshotRequest",
+}) as any as S.Schema<DeactivateSnapshotRequest>;
+
+export interface DeactivateSnapshotResponse {}
+export const DeactivateSnapshotResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "DeactivateSnapshotResponse",
+}) as any as S.Schema<DeactivateSnapshotResponse>;
+
+export type GetAllSnapshotsRequestSort =
+  | "name"
+  | "state"
+  | "lastUsedAt"
+  | "createdAt";
+export const GetAllSnapshotsRequestSort = S.String;
+
+export type GetAllSnapshotsRequestOrder = "asc" | "desc";
+export const GetAllSnapshotsRequestOrder = S.String;
+
+export interface GetAllSnapshotsRequest {
+  /** Page number of the results */
+  page?: number;
+  /** Number of results per page */
+  limit?: number;
+  /** Filter by partial name match */
+  name?: string;
+  /** Filter by the ID of the sandbox the snapshot was created from */
+  sourceSandboxId?: string;
+  /** Field to sort by */
+  sort?: GetAllSnapshotsRequestSort | (string & {});
+  /** Direction to sort by */
+  order?: GetAllSnapshotsRequestOrder | (string & {});
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const GetAllSnapshotsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    page: S.optional(S.Number.pipe(T.Query())),
+    limit: S.optional(S.Number.pipe(T.Query())),
+    name: S.optional(S.String.pipe(T.Query())),
+    sourceSandboxId: S.optional(S.String.pipe(T.Query())),
+    sort: S.optional(GetAllSnapshotsRequestSort.pipe(T.Query())),
+    order: S.optional(GetAllSnapshotsRequestOrder.pipe(T.Query())),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+  }).pipe(T.Http({ method: "GET", uri: "/snapshots", code: 200 })),
+).annotate({
+  identifier: "GetAllSnapshotsRequest",
+}) as any as S.Schema<GetAllSnapshotsRequest>;
+
+export type PaginatedSnapshotsItemsList = Array<SnapshotDto>;
+export const PaginatedSnapshotsItemsList = /*@__PURE__*/ S.Array(
+  SnapshotDto,
+) as any as S.Schema<PaginatedSnapshotsItemsList>;
+
+export interface PaginatedSnapshots {
+  items: PaginatedSnapshotsItemsList;
+  total: number;
+  page: number;
+  totalPages: number;
+}
+export const PaginatedSnapshots = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    items: PaginatedSnapshotsItemsList,
+    total: S.Number,
+    page: S.Number,
+    totalPages: S.Number,
+  }),
+).annotate({
+  identifier: "PaginatedSnapshots",
+}) as any as S.Schema<PaginatedSnapshots>;
+
+export interface GetSnapshotRequest {
+  /** Snapshot ID or name */
+  id: string;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const GetSnapshotRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String.pipe(T.Label()),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+  }).pipe(T.Http({ method: "GET", uri: "/snapshots/{id}", code: 200 })),
+).annotate({
+  identifier: "GetSnapshotRequest",
+}) as any as S.Schema<GetSnapshotRequest>;
+
+export interface GetSnapshotBuildLogsUrlRequest {
+  /** Snapshot ID */
+  id: string;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const GetSnapshotBuildLogsUrlRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String.pipe(T.Label()),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/snapshots/{id}/build-logs-url", code: 200 }),
+  ),
+).annotate({
+  identifier: "GetSnapshotBuildLogsUrlRequest",
+}) as any as S.Schema<GetSnapshotBuildLogsUrlRequest>;
+
+export interface Url {
+  /** URL response */
+  url: string;
+}
+export const Url = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    url: S.String,
+  }),
+).annotate({ identifier: "Url" }) as any as S.Schema<Url>;
+
+export interface RemoveSnapshotRequest {
+  /** Snapshot ID */
+  id: string;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const RemoveSnapshotRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String.pipe(T.Label()),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+  }).pipe(T.Http({ method: "DELETE", uri: "/snapshots/{id}", code: 200 })),
+).annotate({
+  identifier: "RemoveSnapshotRequest",
+}) as any as S.Schema<RemoveSnapshotRequest>;
+
+export interface RemoveSnapshotResponse {}
+export const RemoveSnapshotResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "RemoveSnapshotResponse",
+}) as any as S.Schema<RemoveSnapshotResponse>;
+
+export type ActivateSnapshotError = DaytonaOpError;
+/** Activate a snapshot */
+export const activateSnapshot: API.OperationMethod<
+  ActivateSnapshotRequest,
+  SnapshotDto,
+  ActivateSnapshotError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ActivateSnapshotRequest,
+  output: SnapshotDto,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateSnapshotError = DaytonaOpError;
+/** Create a new snapshot */
+export const createSnapshot: API.OperationMethod<
+  CreateSnapshotRequest,
+  SnapshotDto,
+  CreateSnapshotError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateSnapshotRequest,
+  output: SnapshotDto,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeactivateSnapshotError = DaytonaOpError;
+/** Deactivate a snapshot */
+export const deactivateSnapshot: API.OperationMethod<
+  DeactivateSnapshotRequest,
+  DeactivateSnapshotResponse,
+  DeactivateSnapshotError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeactivateSnapshotRequest,
+  output: DeactivateSnapshotResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetAllSnapshotsError = DaytonaOpError;
+/** List all snapshots */
+export const getAllSnapshots: API.OperationMethod<
+  GetAllSnapshotsRequest,
+  PaginatedSnapshots,
+  GetAllSnapshotsError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetAllSnapshotsRequest,
+  output: PaginatedSnapshots,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetSnapshotError = DaytonaOpError;
+/** Get snapshot by ID or name */
+export const getSnapshot: API.OperationMethod<
+  GetSnapshotRequest,
+  SnapshotDto,
+  GetSnapshotError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetSnapshotRequest,
+  output: SnapshotDto,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetSnapshotBuildLogsUrlError = DaytonaOpError;
+/** Get snapshot build logs URL */
+export const getSnapshotBuildLogsUrl: API.OperationMethod<
+  GetSnapshotBuildLogsUrlRequest,
+  Url,
+  GetSnapshotBuildLogsUrlError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetSnapshotBuildLogsUrlRequest,
+  output: Url,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type RemoveSnapshotError = DaytonaOpError;
+/** Delete snapshot */
+export const removeSnapshot: API.OperationMethod<
+  RemoveSnapshotRequest,
+  RemoveSnapshotResponse,
+  RemoveSnapshotError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: RemoveSnapshotRequest,
+  output: RemoveSnapshotResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));

package/src/services/system.ts

@@ -0,0 +1,64 @@
+// AUTO-GENERATED by scripts/generate.ts from .generated-specs (specs/spec-mirror-daytona/specs/{openapi,toolbox-openapi,analytics-openapi}.json). Do not edit.
+import * as S from "@distilled.cloud/core/schema";
+import * as API from "@distilled.cloud/core/api";
+import * as T from "../traits.ts";
+import {
+  DaytonaProtocol,
+  type DaytonaOpError,
+  type DaytonaOpContext,
+} from "../protocol.ts";
+import { UnknownDaytonaError } from "../errors.ts";
+import * as Retry from "../retry.ts";
+
+export type { DaytonaOpError, DaytonaOpContext };
+
+export interface GetSystemMetricsRequest {}
+export const GetSystemMetricsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(
+    T.Http({ method: "GET", uri: "/system/metrics", code: 200 }),
+  ),
+).annotate({
+  identifier: "GetSystemMetricsRequest",
+}) as any as S.Schema<GetSystemMetricsRequest>;
+
+export interface SystemMetrics {
+  cpuCount?: number;
+  cpuUsedPct?: number;
+  diskFree?: number;
+  diskTotal?: number;
+  diskUsed?: number;
+  memCache?: number;
+  memTotal?: number;
+  memUsed?: number;
+  timestamp?: string;
+  timestampUnix?: number;
+}
+export const SystemMetrics = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    cpuCount: S.optional(S.Number),
+    cpuUsedPct: S.optional(S.Number),
+    diskFree: S.optional(S.Number),
+    diskTotal: S.optional(S.Number),
+    diskUsed: S.optional(S.Number),
+    memCache: S.optional(S.Number),
+    memTotal: S.optional(S.Number),
+    memUsed: S.optional(S.Number),
+    timestamp: S.optional(S.String),
+    timestampUnix: S.optional(S.Number),
+  }),
+).annotate({ identifier: "SystemMetrics" }) as any as S.Schema<SystemMetrics>;
+
+export type GetSystemMetricsError = DaytonaOpError;
+/** Get sandbox resource metrics Latest CPU/memory/disk usage snapshot for the sandbox. cpuUsedPct is the average CPU usage as a percentage of the CPU limit over the last sample window (0 until the first sample completes). Byte fields are in bytes. */
+export const getSystemMetrics: API.OperationMethod<
+  GetSystemMetricsRequest,
+  SystemMetrics,
+  GetSystemMetricsError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetSystemMetricsRequest,
+  output: SystemMetrics,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));