@alienplatform/core 1.14.1 → 2.0.1

package/src/common-errors.ts

@@ -1,55 +0,0 @@
-import * as z from "zod/v4"
-import { defineError } from "./error.js"
-
-/**
- * Error thrown when a requested resource cannot be found in the stack state.
- * This matches the Rust alien-core error: RESOURCE_NOT_FOUND
- */
-export const ResourceNotFoundError = defineError({
-  code: "RESOURCE_NOT_FOUND",
-  context: z.object({
-    resourceId: z.string(),
-    availableResources: z.array(z.string()),
-  }),
-  message: ({ resourceId, availableResources }) =>
-    `Resource '${resourceId}' not found in stack state. Available resources: ${JSON.stringify(availableResources)}`,
-  retryable: false,
-  internal: false,
-  httpStatusCode: 404,
-})
-
-/**
- * Error thrown when resource outputs cannot be parsed according to their expected schema.
- * This indicates an internal system error or data corruption.
- */
-export const ResourceOutputsParseError = defineError({
-  code: "RESOURCE_OUTPUTS_PARSE_ERROR",
-  context: z.object({
-    resourceName: z.string(),
-    resourceType: z.string(),
-    validationErrors: z.string(),
-  }),
-  message: ({ resourceName, resourceType, validationErrors }) =>
-    `Failed to parse outputs for resource '${resourceName}' of type '${resourceType}':\n${validationErrors}`,
-  retryable: false,
-  internal: true,
-  httpStatusCode: 500,
-})
-
-/**
- * Error thrown when there's a resource type mismatch during stack operations.
- * This matches the Rust alien-core error: UNEXPECTED_RESOURCE_TYPE
- */
-export const UnexpectedResourceTypeError = defineError({
-  code: "UNEXPECTED_RESOURCE_TYPE",
-  context: z.object({
-    resourceId: z.string(),
-    expected: z.string(),
-    actual: z.string(),
-  }),
-  message: ({ resourceId, expected, actual }) =>
-    `Unexpected resource type for resource '${resourceId}': expected ${expected}, but got ${actual}`,
-  retryable: false,
-  internal: false,
-  httpStatusCode: 400,
-})

package/src/compute-cluster.ts

@@ -1,213 +0,0 @@
-import {
-  type ComputeCluster as ComputeClusterConfig,
-  ComputeClusterSchema,
-  type MachineProfile,
-  type ResourceType,
-} from "./generated/index.js"
-import { Resource } from "./resource.js"
-
-export type {
-  ComputeCluster as ComputeClusterConfig,
-  CapacityGroup,
-  CapacityGroupScalePolicy,
-  ComputeChoiceRange as GeneratedComputeChoiceRange,
-  MachineProfile,
-} from "./generated/index.js"
-export {
-  ComputeClusterSchema as ComputeClusterConfigSchema,
-  CapacityGroupSchema,
-  CapacityGroupScalePolicySchema,
-  ComputeChoiceRangeSchema,
-  MachineProfileSchema,
-} from "./generated/index.js"
-
-/**
- * Hardware requirements for a compute pool.
- */
-export type ComputePoolRequirements = {
-  cpu: number | string
-  memory: string
-  ephemeralStorage?: string
-  architecture?: "arm64" | "x86_64"
-  nestedVirtualization?: boolean
-  accelerators?: Array<{
-    type: string
-    count: number
-  }>
-}
-
-export type ComputeChoiceRange =
-  | number
-  | {
-      min: number
-      max: number
-      default: number
-    }
-
-export type ComputePoolScale =
-  | {
-      type: "fixed"
-      machines: ComputeChoiceRange
-    }
-  | {
-      type: "autoscale"
-      min: ComputeChoiceRange
-      max: ComputeChoiceRange
-    }
-
-export type ComputePoolInput = {
-  requirements: ComputePoolRequirements
-  scale: ComputePoolScale
-}
-
-/**
- * Declares a ComputeCluster — the setup-owned machine boundary for daemons and
- * containers. Each capacity group inside the cluster becomes a separate
- * Auto Scaling Group (AWS), Managed Instance Group (GCP), or VM Scale Set
- * (Azure). Daemons reference a cluster via `daemon.cluster(...)` and (when
- * the cluster has more than one capacity group) a specific group via
- * `daemon.pool(...)`.
- *
- * Application source declares portable pool requirements. Provider machine
- * names are selected later through deployment settings.
- */
-export class ComputeCluster {
-  private _config: Partial<ComputeClusterConfig> = {
-    capacityGroups: [],
-  }
-
-  constructor(id: string) {
-    this._config.id = id
-  }
-
-  /**
-   * Returns the resource type for permission targets that apply to all
-   * compute-cluster resources.
-   */
-  public static any(): ResourceType {
-    return "compute-cluster"
-  }
-
-  public pool(groupId: string, config: ComputePoolInput): this {
-    const { minSize, maxSize } = selectedScaleBounds(config.scale)
-    this._config.capacityGroups!.push({
-      groupId,
-      profile: machineProfileFromRequirements(config.requirements),
-      minSize,
-      maxSize,
-      scalePolicy: scalePolicyFromInput(config.scale),
-      nestedVirtualization: config.requirements.nestedVirtualization,
-    })
-    return this
-  }
-
-  /**
-   * Sets the container CIDR block used for inter-container networking inside
-   * the cluster. Each machine gets a /24 subnet carved from this range.
-   * Defaults to 10.244.0.0/16 if not specified.
-   */
-  public containerCidr(cidr: string): this {
-    this._config.containerCidr = cidr
-    return this
-  }
-
-  /**
-   * Builds and validates the cluster configuration.
-   */
-  public build(): Resource {
-    const config = ComputeClusterSchema.parse(this._config)
-    return new Resource({
-      type: "compute-cluster",
-      ...config,
-    })
-  }
-}
-
-function selectedScaleBounds(scale: ComputePoolScale): { minSize: number; maxSize: number } {
-  if (scale.type === "fixed") {
-    const machines = defaultChoice(scale.machines)
-    return { minSize: machines, maxSize: machines }
-  }
-
-  return {
-    minSize: defaultChoice(scale.min),
-    maxSize: defaultChoice(scale.max),
-  }
-}
-
-function scalePolicyFromInput(
-  scale: ComputePoolScale,
-): ComputeClusterConfig["capacityGroups"][number]["scalePolicy"] {
-  if (scale.type === "fixed") {
-    return {
-      type: "fixed",
-      machines: choiceRange(scale.machines),
-    }
-  }
-
-  return {
-    type: "autoscale",
-    min: choiceRange(scale.min),
-    max: choiceRange(scale.max),
-  }
-}
-
-function choiceRange(choice: ComputeChoiceRange): { min: number; max: number; default: number } {
-  if (typeof choice === "number") {
-    return { min: choice, max: choice, default: choice }
-  }
-  return choice
-}
-
-function defaultChoice(choice: ComputeChoiceRange): number {
-  if (typeof choice === "number") {
-    return choice
-  }
-
-  return choice.default
-}
-
-function machineProfileFromRequirements(requirements: ComputePoolRequirements): MachineProfile {
-  return {
-    cpu: typeof requirements.cpu === "number" ? `${requirements.cpu}` : requirements.cpu,
-    memoryBytes: parseQuantityBytes(requirements.memory),
-    ephemeralStorageBytes: parseQuantityBytes(requirements.ephemeralStorage ?? "20Gi"),
-    architecture: requirements.architecture,
-    gpu: requirements.accelerators?.[0]
-      ? {
-          type: requirements.accelerators[0].type,
-          count: requirements.accelerators[0].count,
-        }
-      : undefined,
-  }
-}
-
-function parseQuantityBytes(value: string): number {
-  const match = value.match(/^([0-9]+(?:\.[0-9]+)?)(Ki|Mi|Gi|Ti|k|M|G|T)?$/)
-  if (!match) {
-    throw new Error(`Invalid memory/storage quantity: ${value}`)
-  }
-
-  const amount = Number(match[1])
-  const suffix = match[2]
-  const multiplier =
-    suffix === "Ti"
-      ? 1024 ** 4
-      : suffix === "Gi"
-        ? 1024 ** 3
-        : suffix === "Mi"
-          ? 1024 ** 2
-          : suffix === "Ki"
-            ? 1024
-            : suffix === "T"
-              ? 1000 ** 4
-              : suffix === "G"
-                ? 1000 ** 3
-                : suffix === "M"
-                  ? 1000 ** 2
-                  : suffix === "k"
-                    ? 1000
-                    : 1
-
-  return Math.round(amount * multiplier)
-}

package/src/container.ts

@@ -1,423 +0,0 @@
-import {
-  type ContainerAutoscaling,
-  type ContainerCode,
-  type Container as ContainerConfig,
-  type ContainerGpuSpec,
-  ContainerSchema,
-  type HealthCheck,
-  type PersistentStorage,
-  type PublicEndpoint,
-  type ResourceSpec,
-  type ResourceType,
-} from "./generated/index.js"
-import { Resource } from "./resource.js"
-
-export type PublicEndpointOptions =
-  | "http"
-  | "tcp"
-  | {
-      protocol: "http" | "tcp"
-      hostLabel?: string
-      wildcardSubdomains?: boolean
-    }
-
-export type {
-  Container as ContainerConfig,
-  ContainerOutputs,
-  ContainerCode,
-  ContainerAutoscaling,
-  ContainerPort,
-  ExposeProtocol,
-  PublicEndpoint,
-  ContainerGpuSpec,
-  ContainerStatus,
-  HealthCheck,
-  PersistentStorage,
-  ResourceSpec,
-  ReplicaStatus,
-} from "./generated/index.js"
-export {
-  ContainerSchema as ContainerConfigSchema,
-  ContainerPortSchema,
-  ExposeProtocolSchema,
-  ContainerCodeSchema,
-  ContainerAutoscalingSchema,
-} from "./generated/index.js"
-
-export interface PersistentStorageOptions {
-  /**
-   * Mount path inside the container.
-   *
-   * Defaults to `/data`.
-   */
-  mountPath?: string
-}
-
-/**
- * Represents a long-running container workload.
- *
- * Containers run on compute instances (EC2, GCE, Azure VMs) and are orchestrated
- * by the managed container backend. They're designed for always-on workloads
- * like web services, APIs, databases, and background workers.
- */
-export class Container {
-  private _config: Partial<ContainerConfig> = {
-    links: [],
-    ports: [],
-    publicEndpoints: [],
-    environment: {},
-    stateful: false,
-    // cluster is optional - if not set, ComputeClusterMutation will auto-assign
-  }
-
-  /**
-   * Creates a new Container builder.
-   * @param id Identifier for the container. Must be DNS-compatible: lowercase alphanumeric with hyphens.
-   */
-  constructor(id: string) {
-    this._config.id = id
-  }
-
-  /**
-   * Returns a ResourceType representing any container resource.
-   * Used for creating permission targets that apply to all container resources.
-   * @returns The "container" resource type.
-   */
-  public static any(): ResourceType {
-    return "container"
-  }
-
-  /**
-   * Sets the container cluster this container runs on.
-   * @param clusterId The ComputeCluster resource ID.
-   * @returns The Container builder instance.
-   */
-  public cluster(clusterId: string): this {
-    this._config.cluster = clusterId
-    return this
-  }
-
-  /**
-   * Sets the code for the container, either a pre-built image or source code to be built.
-   * @param code The container code configuration.
-   * @returns The Container builder instance.
-   */
-  public code(code: ContainerCode): this {
-    this._config.code = code
-    return this
-  }
-
-  /**
-   * Sets the CPU resources for the container.
-   *
-   * For simplified configuration, use a single number:
-   * - `.cpu(1)` sets both min and desired to 1 vCPU
-   *
-   * For advanced configuration, use ResourceSpec:
-   * - `.cpu({ min: "0.5", desired: "1" })`
-   *
-   * @param value CPU in vCPUs (number) or ResourceSpec with min/desired.
-   * @returns The Container builder instance.
-   */
-  public cpu(value: number | ResourceSpec): this {
-    if (typeof value === "number") {
-      this._config.cpu = { min: value.toString(), desired: value.toString() }
-    } else {
-      this._config.cpu = value
-    }
-    return this
-  }
-
-  /**
-   * Sets the memory resources for the container.
-   *
-   * Format: "<number>Mi" or "<number>Gi"
-   *
-   * Example: "512Mi", "2Gi", "16Gi"
-   *
-   * @param size Memory size string.
-   * @returns The Container builder instance.
-   */
-  public memory(size: string): this {
-    this._config.memory = { min: size, desired: size }
-    return this
-  }
-
-  /**
-   * Sets minimum and maximum replica counts with autoscaling configuration.
-   *
-   * @param min Minimum replicas (always running).
-   * @param max Maximum replicas under load.
-   * @returns The Container builder instance.
-   */
-  public minReplicas(min: number): this {
-    if (!this._config.autoscaling) {
-      this._config.autoscaling = {
-        min,
-        desired: min,
-        max: min * 10, // Default max is 10x min
-      }
-    } else {
-      this._config.autoscaling.min = min
-      this._config.autoscaling.desired = min
-    }
-    return this
-  }
-
-  /**
-   * Sets the maximum replica count for autoscaling.
-   * @param max Maximum replicas.
-   * @returns The Container builder instance.
-   */
-  public maxReplicas(max: number): this {
-    if (!this._config.autoscaling) {
-      this._config.autoscaling = {
-        min: 1,
-        desired: 1,
-        max,
-      }
-    } else {
-      this._config.autoscaling.max = max
-    }
-    return this
-  }
-
-  /**
-   * Sets a fixed replica count (for stateful containers or stateless without autoscaling).
-   * Cannot be used with minReplicas/maxReplicas.
-   * @param count Fixed number of replicas.
-   * @returns The Container builder instance.
-   */
-  public replicas(count: number): this {
-    this._config.replicas = count
-    this._config.autoscaling = undefined
-    return this
-  }
-
-  /**
-   * Configures autoscaling behavior.
-   * @param config Autoscaling configuration.
-   * @returns The Container builder instance.
-   */
-  public autoScale(config: ContainerAutoscaling): this {
-    this._config.autoscaling = config
-    return this
-  }
-
-  /**
-   * Sets whether this container is stateful.
-   * Stateful containers get stable ordinals and support persistent storage.
-   * @param enabled Whether the container is stateful.
-   * @returns The Container builder instance.
-   */
-  public stateful(enabled: boolean): this {
-    this._config.stateful = enabled
-    return this
-  }
-
-  /**
-   * Adds an internal-only port to the container.
-   * Automatically creates DNS records for service discovery.
-   * @param port Port number (e.g., 3000, 8080, 5432).
-   * @returns The Container builder instance.
-   */
-  public port(port: number): this {
-    if (!this._config.ports) {
-      this._config.ports = []
-    }
-    this._config.ports.push({ port })
-    return this
-  }
-
-  /**
-   * Adds multiple internal-only ports to the container.
-   * @param ports Array of port numbers.
-   * @returns The Container builder instance.
-   */
-  public ports(ports: number[]): this {
-    if (!this._config.ports) {
-      this._config.ports = []
-    }
-    this._config.ports.push(...ports.map(port => ({ port })))
-    return this
-  }
-
-  /**
-   * Exposes a named public endpoint for a container port.
-   *
-   * Endpoint names are the stable contract for URLs, DNS, and runtime
-   * environment injection.
-   *
-   * @param name Endpoint name, unique within this container.
-   * @param port Port number to expose.
-   * @param options "http"/"tcp" or endpoint options.
-   * @returns The Container builder instance.
-   */
-  public publicEndpoint(name: string, port: number, options: PublicEndpointOptions = "http"): this {
-    if (!this._config.ports) {
-      this._config.ports = []
-    }
-    if (!this._config.publicEndpoints) {
-      this._config.publicEndpoints = []
-    }
-    const endpoint =
-      typeof options === "string"
-        ? { protocol: options, hostLabel: undefined, wildcardSubdomains: false }
-        : options
-
-    if (!this._config.ports.some(p => p.port === port)) {
-      this._config.ports.push({
-        port,
-      })
-    }
-    this._config.publicEndpoints.push({
-      name,
-      port,
-      protocol: endpoint.protocol,
-      hostLabel: endpoint.hostLabel,
-      wildcardSubdomains: endpoint.wildcardSubdomains ?? false,
-    } satisfies PublicEndpoint)
-    return this
-  }
-
-  /**
-   * Sets environment variables for the container.
-   * @param vars Key-value pairs of environment variables.
-   * @returns The Container builder instance.
-   */
-  public environment(vars: Record<string, string>): this {
-    this._config.environment = { ...this._config.environment, ...vars }
-    return this
-  }
-
-  /**
-   * Sets ephemeral storage size.
-   * Data is lost on container restart.
-   * @param size Storage size (e.g., "10Gi", "100Gi", "500Gi").
-   * @returns The Container builder instance.
-   */
-  public ephemeralStorage(size: string): this {
-    this._config.ephemeralStorage = size
-    return this
-  }
-
-  /**
-   * Configures persistent storage and marks the container stateful.
-   * Data survives container restarts.
-   * @param size Storage size (e.g., "100Gi", "500Gi", "1Ti").
-   * @param options Optional mount path.
-   * @returns The Container builder instance.
-   */
-  public persistentStorage(size: string, options: PersistentStorageOptions = {}): this {
-    const persistentStorage: PersistentStorage = {
-      size,
-      mountPath: options.mountPath ?? "/data",
-    }
-
-    this._config.persistentStorage = persistentStorage
-    this._config.stateful = true
-    return this
-  }
-
-  /**
-   * Requests GPU resources.
-   * @param config GPU configuration with type and count.
-   * @returns The Container builder instance.
-   */
-  public gpu(config: ContainerGpuSpec): this {
-    this._config.gpu = config
-    return this
-  }
-
-  /**
-   * Configures health check for the container.
-   * @param config Health check configuration.
-   * @returns The Container builder instance.
-   */
-  public healthCheck(config: HealthCheck): this {
-    this._config.healthCheck = config
-    return this
-  }
-
-  /**
-   * Configures readiness probe (alias for healthCheck).
-   * @param config Readiness probe configuration with method and path.
-   * @returns The Container builder instance.
-   */
-  public readinessProbe(config: { method: string; path: string }): this {
-    this._config.healthCheck = {
-      path: config.path,
-      method: config.method,
-      timeoutSeconds: 1,
-      failureThreshold: 3,
-    }
-    return this
-  }
-
-  /**
-   * Sets the permission profile for this container.
-   * @param profile Permission profile name from stack permissions configuration.
-   * @returns The Container builder instance.
-   */
-  public permissions(profile: string): this {
-    this._config.permissions = profile
-    return this
-  }
-
-  /**
-   * Assigns the container to a specific compute pool.
-   * @param poolName Compute pool name.
-   * @returns The Container builder instance.
-   */
-  public pool(poolName: string): this {
-    this._config.pool = poolName
-    return this
-  }
-
-  /**
-   * Sets the command to override the image default.
-   * @param command Array of command arguments.
-   * @returns The Container builder instance.
-   */
-  public command(command: string[]): this {
-    this._config.command = command
-    return this
-  }
-
-  /**
-   * Sets the grace period used when stopping replicas during updates, drains, and deletes.
-   *
-   * The value is expressed in seconds. Valid values are 1 through 86400.
-   */
-  public stopGracePeriod(seconds: number): this {
-    this._config.stopGracePeriodSeconds = seconds
-    return this
-  }
-
-  /**
-   * Links this container to another resource (Storage, Queue, KV, etc.).
-   * @param resource The resource to link to.
-   * @returns The Container builder instance.
-   */
-  public link(resource: Resource): this {
-    if (!this._config.links) {
-      this._config.links = []
-    }
-    this._config.links.push(resource.ref())
-    return this
-  }
-
-  /**
-   * Builds and validates the container configuration.
-   * @returns An immutable Resource representing the configured container.
-   * @throws Error if the container configuration is invalid.
-   */
-  public build(): Resource {
-    const config = ContainerSchema.parse(this._config)
-
-    return new Resource({
-      type: "container",
-      ...config,
-    })
-  }
-}