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

package/src/services/warm_pools.ts

@@ -0,0 +1,209 @@
+// 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 CreateWarmPoolRequest {
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+  /** The snapshot (id or name) to keep warm sandboxes for. A pool only serves sandbox creates that use this snapshot with the default OS user and no custom env, volumes or secrets. */
+  snapshot: string;
+  /** Number of warm sandboxes to keep ready (capped by the organization quota) */
+  pool: number;
+  /** Target region for the warm pool. Defaults to the organization default region. */
+  target?: string;
+}
+export const CreateWarmPoolRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+    snapshot: S.String,
+    pool: S.Number,
+    target: S.optional(S.String),
+  }).pipe(T.Http({ method: "POST", uri: "/warm-pools", code: 200 })),
+).annotate({
+  identifier: "CreateWarmPoolRequest",
+}) as any as S.Schema<CreateWarmPoolRequest>;
+
+export type WarmPoolEnvMap = { [key: string]: string | undefined };
+export const WarmPoolEnvMap = /*@__PURE__*/ S.Record(
+  S.String,
+  S.String,
+) as any as S.Schema<WarmPoolEnvMap>;
+
+export interface WarmPool {
+  id: string;
+  organizationId: string;
+  snapshot: string;
+  target: string;
+  /** Desired number of warm sandboxes */
+  pool: number;
+  /** Current number of ready warm sandboxes in the pool */
+  currentSize: number;
+  cpu: number;
+  mem: number;
+  disk: number;
+  osUser: string;
+  env: WarmPoolEnvMap;
+  errorReason?: string | null;
+  createdAt: string;
+  updatedAt: string;
+}
+export const WarmPool = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String,
+    organizationId: S.String,
+    snapshot: S.String,
+    target: S.String,
+    pool: S.Number,
+    currentSize: S.Number,
+    cpu: S.Number,
+    mem: S.Number,
+    disk: S.Number,
+    osUser: S.String,
+    env: WarmPoolEnvMap,
+    errorReason: S.optional(S.NullOr(S.String)),
+    createdAt: S.String,
+    updatedAt: S.String,
+  }),
+).annotate({ identifier: "WarmPool" }) as any as S.Schema<WarmPool>;
+
+export interface DeleteWarmPoolRequest {
+  /** Warm pool ID */
+  id: string;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const DeleteWarmPoolRequest = /*@__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: "/warm-pools/{id}", code: 200 })),
+).annotate({
+  identifier: "DeleteWarmPoolRequest",
+}) as any as S.Schema<DeleteWarmPoolRequest>;
+
+export interface DeleteWarmPoolResponse {}
+export const DeleteWarmPoolResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "DeleteWarmPoolResponse",
+}) as any as S.Schema<DeleteWarmPoolResponse>;
+
+export interface ListWarmPoolsRequest {
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const ListWarmPoolsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+  }).pipe(T.Http({ method: "GET", uri: "/warm-pools", code: 200 })),
+).annotate({
+  identifier: "ListWarmPoolsRequest",
+}) as any as S.Schema<ListWarmPoolsRequest>;
+
+export type ListWarmPoolsResponseBodyList = Array<WarmPool>;
+export const ListWarmPoolsResponseBodyList = /*@__PURE__*/ S.Array(
+  WarmPool,
+) as any as S.Schema<ListWarmPoolsResponseBodyList>;
+
+export type ListWarmPoolsResponse = ListWarmPoolsResponseBodyList;
+export const ListWarmPoolsResponse = /*@__PURE__*/ S.suspend(() =>
+  ListWarmPoolsResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListWarmPoolsResponse",
+}) as any as S.Schema<ListWarmPoolsResponse>;
+
+export interface UpdateWarmPoolRequest {
+  /** Warm pool ID */
+  id: string;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+  /** New desired number of warm sandboxes (0 drains the pool) */
+  pool: number;
+}
+export const UpdateWarmPoolRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String.pipe(T.Label()),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+    pool: S.Number,
+  }).pipe(T.Http({ method: "PATCH", uri: "/warm-pools/{id}", code: 200 })),
+).annotate({
+  identifier: "UpdateWarmPoolRequest",
+}) as any as S.Schema<UpdateWarmPoolRequest>;
+
+export type CreateWarmPoolError = DaytonaOpError;
+/** Create a warm pool */
+export const createWarmPool: API.OperationMethod<
+  CreateWarmPoolRequest,
+  WarmPool,
+  CreateWarmPoolError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateWarmPoolRequest,
+  output: WarmPool,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteWarmPoolError = DaytonaOpError;
+/** Delete a warm pool */
+export const deleteWarmPool: API.OperationMethod<
+  DeleteWarmPoolRequest,
+  DeleteWarmPoolResponse,
+  DeleteWarmPoolError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteWarmPoolRequest,
+  output: DeleteWarmPoolResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListWarmPoolsError = DaytonaOpError;
+/** List warm pools for the organization */
+export const listWarmPools: API.OperationMethod<
+  ListWarmPoolsRequest,
+  ListWarmPoolsResponse,
+  ListWarmPoolsError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListWarmPoolsRequest,
+  output: ListWarmPoolsResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UpdateWarmPoolError = DaytonaOpError;
+/** Update a warm pool size */
+export const updateWarmPool: API.OperationMethod<
+  UpdateWarmPoolRequest,
+  WarmPool,
+  UpdateWarmPoolError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UpdateWarmPoolRequest,
+  output: WarmPool,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));

package/src/services/webhooks.ts

@@ -0,0 +1,214 @@
+// 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 GetWebhookControllerAppPortalAccessRequest {
+  organizationId: string;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const GetWebhookControllerAppPortalAccessRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      organizationId: S.String.pipe(T.Label()),
+      xDaytonaOrganizationID: S.optional(
+        S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+      ),
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/webhooks/organizations/{organizationId}/app-portal-access",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "GetWebhookControllerAppPortalAccessRequest",
+  }) as any as S.Schema<GetWebhookControllerAppPortalAccessRequest>;
+
+export interface WebhookAppPortalAccess {
+  /** The authentication token for the Svix consumer app portal */
+  token: string;
+  /** The URL to the webhook app portal */
+  url: string;
+}
+export const WebhookAppPortalAccess = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    token: S.String,
+    url: S.String,
+  }),
+).annotate({
+  identifier: "WebhookAppPortalAccess",
+}) as any as S.Schema<WebhookAppPortalAccess>;
+
+export interface GetWebhookControllerInitializationStatusRequest {
+  organizationId: string;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const GetWebhookControllerInitializationStatusRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      organizationId: S.String.pipe(T.Label()),
+      xDaytonaOrganizationID: S.optional(
+        S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+      ),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/webhooks/organizations/{organizationId}/initialization-status",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "GetWebhookControllerInitializationStatusRequest",
+  }) as any as S.Schema<GetWebhookControllerInitializationStatusRequest>;
+
+export interface WebhookInitializationStatus {
+  /** Organization ID */
+  organizationId: string;
+  /** The ID of the Svix application */
+  svixApplicationId: string | null;
+  /** The error reason for the last initialization attempt */
+  lastError: string | null;
+  /** The number of times the initialization has been attempted */
+  retryCount: number;
+  /** When the webhook initialization was created */
+  createdAt: string;
+  /** When the webhook initialization was last updated */
+  updatedAt: string;
+}
+export const WebhookInitializationStatus = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    organizationId: S.String,
+    svixApplicationId: S.NullOr(S.String),
+    lastError: S.NullOr(S.String),
+    retryCount: S.Number,
+    createdAt: S.String,
+    updatedAt: S.String,
+  }),
+).annotate({
+  identifier: "WebhookInitializationStatus",
+}) as any as S.Schema<WebhookInitializationStatus>;
+
+export interface RefreshWebhookControllerEndpointsRequest {
+  organizationId: string;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const RefreshWebhookControllerEndpointsRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      organizationId: S.String.pipe(T.Label()),
+      xDaytonaOrganizationID: S.optional(
+        S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+      ),
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/webhooks/organizations/{organizationId}/refresh-endpoints",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "RefreshWebhookControllerEndpointsRequest",
+}) as any as S.Schema<RefreshWebhookControllerEndpointsRequest>;
+
+export interface RefreshWebhookControllerEndpointsResponse {}
+export const RefreshWebhookControllerEndpointsResponse =
+  /*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+    identifier: "RefreshWebhookControllerEndpointsResponse",
+  }) as any as S.Schema<RefreshWebhookControllerEndpointsResponse>;
+
+export interface WebhookControllerInitializeWebhooksRequest {
+  /** Organization ID */
+  organizationId: string;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const WebhookControllerInitializeWebhooksRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      organizationId: S.String.pipe(T.Label()),
+      xDaytonaOrganizationID: S.optional(
+        S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+      ),
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/webhooks/organizations/{organizationId}/initialize",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "WebhookControllerInitializeWebhooksRequest",
+  }) as any as S.Schema<WebhookControllerInitializeWebhooksRequest>;
+
+export type GetWebhookControllerAppPortalAccessError = DaytonaOpError;
+/** Get Svix Consumer App Portal access for an organization */
+export const getWebhookControllerAppPortalAccess: API.OperationMethod<
+  GetWebhookControllerAppPortalAccessRequest,
+  WebhookAppPortalAccess,
+  GetWebhookControllerAppPortalAccessError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetWebhookControllerAppPortalAccessRequest,
+  output: WebhookAppPortalAccess,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetWebhookControllerInitializationStatusError = DaytonaOpError;
+/** Get webhook initialization status for an organization */
+export const getWebhookControllerInitializationStatus: API.OperationMethod<
+  GetWebhookControllerInitializationStatusRequest,
+  WebhookInitializationStatus,
+  GetWebhookControllerInitializationStatusError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetWebhookControllerInitializationStatusRequest,
+  output: WebhookInitializationStatus,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type RefreshWebhookControllerEndpointsError = DaytonaOpError;
+/** Refresh cached endpoint presence flag for an organization */
+export const refreshWebhookControllerEndpoints: API.OperationMethod<
+  RefreshWebhookControllerEndpointsRequest,
+  RefreshWebhookControllerEndpointsResponse,
+  RefreshWebhookControllerEndpointsError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: RefreshWebhookControllerEndpointsRequest,
+  output: RefreshWebhookControllerEndpointsResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type WebhookControllerInitializeWebhooksError = DaytonaOpError;
+/** Initialize webhooks for an organization */
+export const webhookControllerInitializeWebhooks: API.OperationMethod<
+  WebhookControllerInitializeWebhooksRequest,
+  WebhookInitializationStatus,
+  WebhookControllerInitializeWebhooksError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: WebhookControllerInitializeWebhooksRequest,
+  output: WebhookInitializationStatus,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));

package/src/traits.ts

@@ -0,0 +1,44 @@
+/**
+ * Daytona SDK trait surface — hand-written.
+ *
+ * Re-exports the generic protocol traits from core so generated operations
+ * import everything from one place. Daytona speaks plain bearer-REST JSON
+ * with no success envelope, so there are no provider-specific traits.
+ */
+export {
+  Body,
+  Header,
+  Query,
+  Label,
+  Http,
+  ResponseCode,
+  HttpBody,
+  FormDataFile,
+  KeyDictionary,
+  UnionCases,
+  applyErrorMatchers,
+  getErrorMatchers,
+  type HttpTrait,
+  type ErrorMatcher,
+  bodySymbol,
+  headerSymbol,
+  querySymbol,
+  labelSymbol,
+  httpSymbol,
+  responseCodeSymbol,
+  httpBodySymbol,
+  formDataFileSymbol,
+  keyDictionarySymbol,
+  unionCasesSymbol,
+  errorMatchersSymbol,
+} from "@distilled.cloud/core/trait";
+
+// Bearer-REST protocol traits (sensitive strings, bare-payload responses).
+export {
+  SensitiveValue,
+  RawResponse,
+  RawResponseRoot,
+  sensitiveValueSymbol,
+  rawResponseSymbol,
+  rawResponseRootSymbol,
+} from "@distilled.cloud/core/protocol-rest";