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

package/src/services/config.ts

@@ -0,0 +1,256 @@
+// 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 Redacted from "effect/Redacted";
+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 GetConfigControllerConfigRequest {}
+export const GetConfigControllerConfigRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(T.Http({ method: "GET", uri: "/config", code: 200 })),
+).annotate({
+  identifier: "GetConfigControllerConfigRequest",
+}) as any as S.Schema<GetConfigControllerConfigRequest>;
+
+export interface PosthogConfig {
+  /** PostHog API key */
+  apiKey: string | Redacted.Redacted<string>;
+  /** PostHog host URL */
+  host: string;
+}
+export const PosthogConfig = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    apiKey: S.String.pipe(T.SensitiveValue({})),
+    host: S.String,
+  }),
+).annotate({ identifier: "PosthogConfig" }) as any as S.Schema<PosthogConfig>;
+
+/** Which identity provider the advertised issuer above belongs to. The dashboard needs this because provider-specific logout URLs are not discoverable from the issuer alone: ending an Auth0 session uses its proprietary /v2/logout, which does not exist on WorkOS AuthKit. Anything that branches on provider behaviour must read this rather than pattern-matching the issuer hostname. */
+export type OidcConfigProvider = "auth0" | "workos";
+export const OidcConfigProvider = S.String;
+
+export interface OidcConfig {
+  /** OIDC issuer */
+  issuer: string;
+  /** OIDC client ID */
+  clientId: string;
+  /** OIDC audience */
+  audience: string;
+  /** Which identity provider the advertised issuer above belongs to. The dashboard needs this because provider-specific logout URLs are not discoverable from the issuer alone: ending an Auth0 session uses its proprietary /v2/logout, which does not exist on WorkOS AuthKit. Anything that branches on provider behaviour must read this rather than pattern-matching the issuer hostname. */
+  provider: OidcConfigProvider;
+  /** WorkOS "Authentication API" custom domain the dashboard's client-side SDK should call instead of api.workos.com, so the refresh-token cookie is first-party. Present only when the provider is workos and a custom domain is configured (WorkOS production environments only); absent means the SDK runs in devMode and keeps the refresh token in localStorage. */
+  authApiHostname?: string;
+}
+export const OidcConfig = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    issuer: S.String,
+    clientId: S.String,
+    audience: S.String,
+    provider: OidcConfigProvider,
+    authApiHostname: S.optional(S.String),
+  }),
+).annotate({ identifier: "OidcConfig" }) as any as S.Schema<OidcConfig>;
+
+export interface SsoOidcConfig {
+  /** OIDC issuer for org-SSO logins (Daytona Auth) */
+  issuer: string;
+  /** OIDC client ID for org-SSO logins */
+  clientId: string;
+}
+export const SsoOidcConfig = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    issuer: S.String,
+    clientId: S.String,
+  }),
+).annotate({ identifier: "SsoOidcConfig" }) as any as S.Schema<SsoOidcConfig>;
+
+/** Feature flags forced on for this deployment regardless of PostHog targeting. Lets environments without PostHog (previews, local dev) enable flag-gated dashboard features. */
+export type DaytonaConfigurationForcedFeatureFlagsList = Array<string>;
+export const DaytonaConfigurationForcedFeatureFlagsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<DaytonaConfigurationForcedFeatureFlagsList>;
+
+export interface Announcement {
+  /** The announcement text */
+  text: string;
+  /** URL to learn more about the announcement */
+  learnMoreUrl?: string;
+}
+export const Announcement = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    text: S.String,
+    learnMoreUrl: S.optional(S.String),
+  }),
+).annotate({ identifier: "Announcement" }) as any as S.Schema<Announcement>;
+
+/** System announcements */
+export type DaytonaConfigurationAnnouncementsMap = {
+  [key: string]: Announcement | undefined;
+};
+export const DaytonaConfigurationAnnouncementsMap = /*@__PURE__*/ S.Record(
+  S.String,
+  Announcement,
+) as any as S.Schema<DaytonaConfigurationAnnouncementsMap>;
+
+/** SSH host public keys presented by the SSH Gateway, as OpenSSH public key lines (`<type> <base64>`). To build a known_hosts entry, prefix each with `sshGatewayHost` when `sshGatewayPort` is 22, or with `[sshGatewayHost]:sshGatewayPort` otherwise. */
+export type DaytonaConfigurationSshGatewayHostKeysList = Array<string>;
+export const DaytonaConfigurationSshGatewayHostKeysList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<DaytonaConfigurationSshGatewayHostKeysList>;
+
+/** SHA256 fingerprints of sshGatewayHostKeys, in the same order, in `ssh-keygen -lf` format. Compare against the fingerprint published at https://github.com/daytona/.github/blob/main/SECURITY.md#ssh-host-key-verification */
+export type DaytonaConfigurationSshGatewayHostKeyFingerprintsList =
+  Array<string>;
+export const DaytonaConfigurationSshGatewayHostKeyFingerprintsList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<DaytonaConfigurationSshGatewayHostKeyFingerprintsList>;
+
+export interface RateLimitEntry {
+  /** Rate limit TTL in seconds */
+  ttl?: number;
+  /** Rate limit max requests */
+  limit?: number;
+}
+export const RateLimitEntry = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ttl: S.optional(S.Number),
+    limit: S.optional(S.Number),
+  }),
+).annotate({ identifier: "RateLimitEntry" }) as any as S.Schema<RateLimitEntry>;
+
+export interface RateLimitConfig {
+  /** Failed authentication rate limit */
+  failedAuth?: RateLimitEntry;
+  /** Authenticated rate limit */
+  authenticated?: RateLimitEntry;
+  /** Sandbox create rate limit */
+  sandboxCreate?: RateLimitEntry;
+  /** Sandbox lifecycle rate limit */
+  sandboxLifecycle?: RateLimitEntry;
+  /** Sandbox list rate limit */
+  sandboxList?: RateLimitEntry;
+}
+export const RateLimitConfig = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    failedAuth: S.optional(RateLimitEntry),
+    authenticated: S.optional(RateLimitEntry),
+    sandboxCreate: S.optional(RateLimitEntry),
+    sandboxLifecycle: S.optional(RateLimitEntry),
+    sandboxList: S.optional(RateLimitEntry),
+  }),
+).annotate({
+  identifier: "RateLimitConfig",
+}) as any as S.Schema<RateLimitConfig>;
+
+export interface DaytonaConfiguration {
+  /** Daytona version */
+  version: string;
+  /** Commit sha of the source the app was built from */
+  buildSha?: string;
+  /** PostHog configuration */
+  posthog?: PosthogConfig;
+  /** OIDC configuration */
+  oidc: OidcConfig;
+  /** OIDC configuration for org-SSO logins (Daytona Auth issuer). Present only when the secondary (org-SSO) issuer is configured; the dashboard uses it as its authority when entered via an organization SSO link. */
+  ssoOidc?: SsoOidcConfig;
+  /** Feature flags forced on for this deployment regardless of PostHog targeting. Lets environments without PostHog (previews, local dev) enable flag-gated dashboard features. */
+  forcedFeatureFlags?: DaytonaConfigurationForcedFeatureFlagsList;
+  /** Whether linked accounts are enabled */
+  linkedAccountsEnabled: boolean;
+  /** System announcements */
+  announcements: DaytonaConfigurationAnnouncementsMap;
+  /** Pylon application ID */
+  pylonAppId?: string;
+  /** Proxy template URL */
+  proxyTemplateUrl: string;
+  /** Toolbox template URL */
+  proxyToolboxUrl: string;
+  /** Default snapshot for sandboxes */
+  defaultSnapshot: string;
+  /** Dashboard URL */
+  dashboardUrl: string;
+  /** Maximum auto-archive interval in minutes */
+  maxAutoArchiveInterval: number;
+  /** Whether maintenance mode is enabled */
+  maintananceMode: boolean;
+  /** Current environment */
+  environment: string;
+  /** Billing API URL */
+  billingApiUrl?: string;
+  /** Analytics API URL */
+  analyticsApiUrl?: string;
+  /** Stripe publishable key for client-side Stripe.js */
+  stripePublishableKey?: string;
+  /** SSH Gateway command */
+  sshGatewayCommand?: string;
+  /** Base64 encoded SSH Gateway public key */
+  sshGatewayPublicKey?: string;
+  /** Hostname of the SSH Gateway that sandbox SSH connections terminate at */
+  sshGatewayHost?: string;
+  /** TCP port of the SSH Gateway */
+  sshGatewayPort?: number;
+  /** SSH host public keys presented by the SSH Gateway, as OpenSSH public key lines (`<type> <base64>`). To build a known_hosts entry, prefix each with `sshGatewayHost` when `sshGatewayPort` is 22, or with `[sshGatewayHost]:sshGatewayPort` otherwise. */
+  sshGatewayHostKeys?: DaytonaConfigurationSshGatewayHostKeysList;
+  /** SHA256 fingerprints of sshGatewayHostKeys, in the same order, in `ssh-keygen -lf` format. Compare against the fingerprint published at https://github.com/daytona/.github/blob/main/SECURITY.md#ssh-host-key-verification */
+  sshGatewayHostKeyFingerprints?: DaytonaConfigurationSshGatewayHostKeyFingerprintsList;
+  /** Rate limit configuration */
+  rateLimit?: RateLimitConfig;
+}
+export const DaytonaConfiguration = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    version: S.String,
+    buildSha: S.optional(S.String),
+    posthog: S.optional(PosthogConfig),
+    oidc: OidcConfig,
+    ssoOidc: S.optional(SsoOidcConfig),
+    forcedFeatureFlags: S.optional(DaytonaConfigurationForcedFeatureFlagsList),
+    linkedAccountsEnabled: S.Boolean,
+    announcements: DaytonaConfigurationAnnouncementsMap,
+    pylonAppId: S.optional(S.String),
+    proxyTemplateUrl: S.String,
+    proxyToolboxUrl: S.String,
+    defaultSnapshot: S.String,
+    dashboardUrl: S.String,
+    maxAutoArchiveInterval: S.Number,
+    maintananceMode: S.Boolean,
+    environment: S.String,
+    billingApiUrl: S.optional(S.String),
+    analyticsApiUrl: S.optional(S.String),
+    stripePublishableKey: S.optional(S.String),
+    sshGatewayCommand: S.optional(S.String),
+    sshGatewayPublicKey: S.optional(S.String),
+    sshGatewayHost: S.optional(S.String),
+    sshGatewayPort: S.optional(S.Number),
+    sshGatewayHostKeys: S.optional(DaytonaConfigurationSshGatewayHostKeysList),
+    sshGatewayHostKeyFingerprints: S.optional(
+      DaytonaConfigurationSshGatewayHostKeyFingerprintsList,
+    ),
+    rateLimit: S.optional(RateLimitConfig),
+  }),
+).annotate({
+  identifier: "DaytonaConfiguration",
+}) as any as S.Schema<DaytonaConfiguration>;
+
+export type GetConfigControllerConfigError = DaytonaOpError;
+/** Get config */
+export const getConfigControllerConfig: API.OperationMethod<
+  GetConfigControllerConfigRequest,
+  DaytonaConfiguration,
+  GetConfigControllerConfigError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetConfigControllerConfigRequest,
+  output: DaytonaConfiguration,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));

package/src/services/docker_registry.ts

@@ -0,0 +1,325 @@
+// 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 Redacted from "effect/Redacted";
+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 CreateRegistryRequest {
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+  /** Registry name */
+  name: string;
+  /** Registry URL */
+  url: string;
+  /** Registry username */
+  username: string;
+  /** Registry password */
+  password: string | Redacted.Redacted<string>;
+  /** Registry project */
+  project?: string;
+}
+export const CreateRegistryRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+    name: S.String,
+    url: S.String,
+    username: S.String,
+    password: S.String.pipe(T.SensitiveValue({})),
+    project: S.optional(S.String),
+  }).pipe(T.Http({ method: "POST", uri: "/docker-registry", code: 200 })),
+).annotate({
+  identifier: "CreateRegistryRequest",
+}) as any as S.Schema<CreateRegistryRequest>;
+
+/** Registry type */
+export type DockerRegistryRegistryType =
+  | "internal"
+  | "organization"
+  | "transient"
+  | "backup";
+export const DockerRegistryRegistryType = S.String;
+
+export interface DockerRegistry2 {
+  /** Registry ID */
+  id: string;
+  /** Registry name */
+  name: string;
+  /** Registry URL */
+  url: string;
+  /** Registry username */
+  username: string;
+  /** Registry project */
+  project: string;
+  /** Registry type */
+  registryType: DockerRegistryRegistryType;
+  /** Creation timestamp */
+  createdAt: string;
+  /** Last update timestamp */
+  updatedAt: string;
+}
+export const DockerRegistry2 = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String,
+    name: S.String,
+    url: S.String,
+    username: S.String,
+    project: S.String,
+    registryType: DockerRegistryRegistryType,
+    createdAt: S.String,
+    updatedAt: S.String,
+  }),
+).annotate({
+  identifier: "DockerRegistry2",
+}) as any as S.Schema<DockerRegistry2>;
+
+export interface DeleteRegistryRequest {
+  /** ID of the docker registry */
+  id: string;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const DeleteRegistryRequest = /*@__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: "/docker-registry/{id}", code: 200 }),
+  ),
+).annotate({
+  identifier: "DeleteRegistryRequest",
+}) as any as S.Schema<DeleteRegistryRequest>;
+
+export interface DeleteRegistryResponse {}
+export const DeleteRegistryResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "DeleteRegistryResponse",
+}) as any as S.Schema<DeleteRegistryResponse>;
+
+export interface GetRegistryRequest {
+  /** ID of the docker registry */
+  id: string;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const GetRegistryRequest = /*@__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: "/docker-registry/{id}", code: 200 })),
+).annotate({
+  identifier: "GetRegistryRequest",
+}) as any as S.Schema<GetRegistryRequest>;
+
+export interface GetTransientPushAccessRequest {
+  /** ID of the region where the snapshot will be available (defaults to organization default region) */
+  regionId?: string;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const GetTransientPushAccessRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    regionId: S.optional(S.String.pipe(T.Query())),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/docker-registry/registry-push-access",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetTransientPushAccessRequest",
+}) as any as S.Schema<GetTransientPushAccessRequest>;
+
+export interface RegistryPushAccessDto {
+  /** Temporary username for registry authentication */
+  username: string;
+  /** Temporary secret for registry authentication */
+  secret: string | Redacted.Redacted<string>;
+  /** Registry URL */
+  registryUrl: string;
+  /** Registry ID */
+  registryId: string;
+  /** Registry project ID */
+  project: string;
+  /** Token expiration time in ISO format */
+  expiresAt: string;
+}
+export const RegistryPushAccessDto = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    username: S.String,
+    secret: S.String.pipe(T.SensitiveValue({})),
+    registryUrl: S.String,
+    registryId: S.String,
+    project: S.String,
+    expiresAt: S.String,
+  }),
+).annotate({
+  identifier: "RegistryPushAccessDto",
+}) as any as S.Schema<RegistryPushAccessDto>;
+
+export interface ListRegistriesRequest {
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+}
+export const ListRegistriesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+  }).pipe(T.Http({ method: "GET", uri: "/docker-registry", code: 200 })),
+).annotate({
+  identifier: "ListRegistriesRequest",
+}) as any as S.Schema<ListRegistriesRequest>;
+
+export type ListRegistriesResponseBodyList = Array<DockerRegistry2>;
+export const ListRegistriesResponseBodyList = /*@__PURE__*/ S.Array(
+  DockerRegistry2,
+) as any as S.Schema<ListRegistriesResponseBodyList>;
+
+export type ListRegistriesResponse = ListRegistriesResponseBodyList;
+export const ListRegistriesResponse = /*@__PURE__*/ S.suspend(() =>
+  ListRegistriesResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListRegistriesResponse",
+}) as any as S.Schema<ListRegistriesResponse>;
+
+export interface UpdateRegistryRequest {
+  /** ID of the docker registry */
+  id: string;
+  /** Use with JWT to specify the organization ID */
+  xDaytonaOrganizationID?: string;
+  /** Registry name */
+  name: string;
+  /** Registry URL */
+  url: string;
+  /** Registry username */
+  username: string;
+  /** Registry password */
+  password?: string | Redacted.Redacted<string>;
+  /** Registry project */
+  project?: string;
+}
+export const UpdateRegistryRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String.pipe(T.Label()),
+    xDaytonaOrganizationID: S.optional(
+      S.String.pipe(T.Header("X-Daytona-Organization-ID")),
+    ),
+    name: S.String,
+    url: S.String,
+    username: S.String,
+    password: S.optional(S.String.pipe(T.SensitiveValue({}))),
+    project: S.optional(S.String),
+  }).pipe(T.Http({ method: "PATCH", uri: "/docker-registry/{id}", code: 200 })),
+).annotate({
+  identifier: "UpdateRegistryRequest",
+}) as any as S.Schema<UpdateRegistryRequest>;
+
+export type CreateRegistryError = DaytonaOpError;
+/** Create registry */
+export const createRegistry: API.OperationMethod<
+  CreateRegistryRequest,
+  DockerRegistry2,
+  CreateRegistryError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateRegistryRequest,
+  output: DockerRegistry2,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteRegistryError = DaytonaOpError;
+/** Delete registry */
+export const deleteRegistry: API.OperationMethod<
+  DeleteRegistryRequest,
+  DeleteRegistryResponse,
+  DeleteRegistryError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteRegistryRequest,
+  output: DeleteRegistryResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetRegistryError = DaytonaOpError;
+/** Get registry */
+export const getRegistry: API.OperationMethod<
+  GetRegistryRequest,
+  DockerRegistry2,
+  GetRegistryError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetRegistryRequest,
+  output: DockerRegistry2,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetTransientPushAccessError = DaytonaOpError;
+/** Get temporary registry access for pushing snapshots */
+export const getTransientPushAccess: API.OperationMethod<
+  GetTransientPushAccessRequest,
+  RegistryPushAccessDto,
+  GetTransientPushAccessError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetTransientPushAccessRequest,
+  output: RegistryPushAccessDto,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListRegistriesError = DaytonaOpError;
+/** List registries */
+export const listRegistries: API.OperationMethod<
+  ListRegistriesRequest,
+  ListRegistriesResponse,
+  ListRegistriesError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListRegistriesRequest,
+  output: ListRegistriesResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UpdateRegistryError = DaytonaOpError;
+/** Update registry */
+export const updateRegistry: API.OperationMethod<
+  UpdateRegistryRequest,
+  DockerRegistry2,
+  UpdateRegistryError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UpdateRegistryRequest,
+  output: DockerRegistry2,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));