@serve.zone/interfaces 5.0.4 → 5.4.2

package/ts/data/baremetal.ts

@@ -0,0 +1,73 @@
+import * as plugins from '../plugins.js';
+
+export interface IBareMetal {
+  id: string;
+  data: {
+    hostname: string;
+    
+    /**
+     * IPMI management IP address
+     */
+    ipmiAddress?: string;
+    
+    /**
+     * Encrypted IPMI credentials
+     */
+    ipmiCredentials?: {
+      username: string;
+      passwordEncrypted: string;
+    };
+    
+    /**
+     * Primary network IP address
+     */
+    primaryIp: string;
+    
+    /**
+     * Provider of the physical server
+     */
+    provider: 'hetzner' | 'aws' | 'digitalocean' | 'onpremise';
+    
+    /**
+     * Data center or location
+     */
+    location: string;
+    
+    /**
+     * Hardware specifications
+     */
+    specs: {
+      cpuModel: string;
+      cpuCores: number;
+      memoryGB: number;
+      storageGB: number;
+      storageType: 'ssd' | 'hdd' | 'nvme';
+    };
+    
+    /**
+     * Current power state
+     */
+    powerState: 'on' | 'off' | 'unknown';
+    
+    /**
+     * Operating system information
+     */
+    osInfo: {
+      name: string;
+      version: string;
+      kernel?: string;
+    };
+    
+    /**
+     * Array of ClusterNode IDs running on this hardware
+     */
+    assignedNodeIds: string[];
+    
+    /**
+     * Metadata for provider-specific information
+     */
+    providerMetadata?: {
+      [key: string]: any;
+    };
+  };
+}

package/{ts_interfaces → ts}/data/cloudlyconfig.ts

@@ -1,8 +1,6 @@
 import * as plugins from '../plugins.js';
 
 export interface ICloudlyConfig {
-  cfToken?: string;
-  hetznerToken?: string;
   environment?: 'production' | 'integration';
   letsEncryptEmail?: string;
   letsEncryptPrivateKey?: string;

package/{ts_interfaces → ts}/data/cluster.ts

@@ -1,7 +1,7 @@
 import * as plugins from '../plugins.js';
 
 import { type IDockerRegistryInfo } from '../data/docker.js';
-import type { IServer } from './server.js';
+import type { IClusterNode } from './clusternode.js';
 
 export interface ICluster {
   id: string;
@@ -19,9 +19,14 @@ export interface ICluster {
     cloudlyUrl?: string;
 
     /**
-     * what servers are expected to be part of the cluster
+     * Cluster setup mode - manual by default, or auto-provision with cloud provider
      */
-    servers: IServer[];
+    setupMode?: 'manual' | 'hetzner' | 'aws' | 'digitalocean';
+
+    /**
+     * Nodes that are part of the cluster
+     */
+    nodes: IClusterNode[];
 
     /**
      * ACME info. This is used to get SSL certificates.

package/ts/data/clusternode.ts

@@ -0,0 +1,71 @@
+import * as plugins from '../plugins.js';
+
+export interface IClusterNodeMetrics {
+  cpuUsagePercent: number;
+  memoryUsedMB: number;
+  memoryAvailableMB: number;
+  diskUsedGB: number;
+  diskAvailableGB: number;
+  containerCount: number;
+  timestamp: number;
+}
+
+export interface IClusterNode {
+  id: string;
+  data: {
+    /**
+     * Reference to the cluster this node belongs to
+     */
+    clusterId: string;
+    
+    /**
+     * Reference to the physical server (if applicable)
+     */
+    baremetalId?: string;
+    
+    /**
+     * Type of node
+     */
+    nodeType: 'baremetal' | 'vm' | 'container';
+    
+    /**
+     * Current status of the node
+     */
+    status: 'initializing' | 'online' | 'offline' | 'maintenance';
+    
+    /**
+     * Role of the node in the cluster
+     */
+    role: 'master' | 'worker';
+    
+    /**
+     * Timestamp when node joined the cluster
+     */
+    joinedAt: number;
+    
+    /**
+     * Last health check timestamp
+     */
+    lastHealthCheck: number;
+    
+    /**
+     * Current metrics for the node
+     */
+    metrics?: IClusterNodeMetrics;
+    
+    /**
+     * Docker swarm node ID if part of swarm
+     */
+    swarmNodeId?: string;
+    
+    /**
+     * SSH keys deployed to this node
+     */
+    sshKeys: plugins.tsclass.network.ISshKey[];
+    
+    /**
+     * Debian packages installed on this node
+     */
+    requiredDebianPackages: string[];
+  };
+}

package/ts/data/deployment.ts

@@ -0,0 +1,63 @@
+import * as plugins from '../plugins.js';
+
+/**
+ * a deployment happens when a service is deployed
+ * tracks the status of a deployment
+ */
+export interface IDeployment {
+  id: string;
+  
+  /**
+   * The service being deployed (single service per deployment)
+   */
+  serviceId: string;
+  
+  /**
+   * The node this deployment is running on
+   */
+  nodeId: string;
+  
+  /**
+   * Docker container ID for this deployment
+   */
+  containerId?: string;
+  
+  /**
+   * Image used for this deployment
+   */
+  usedImageId: string;
+  
+  /**
+   * Version of the service deployed
+   */
+  version: string;
+  
+  /**
+   * Timestamp when deployed
+   */
+  deployedAt: number;
+  
+  /**
+   * Deployment log entries
+   */
+  deploymentLog: string[];
+  
+  /**
+   * Current status of the deployment
+   */
+  status: 'scheduled' | 'starting' | 'running' | 'stopping' | 'stopped' | 'failed';
+  
+  /**
+   * Health status of the deployment
+   */
+  healthStatus?: 'healthy' | 'unhealthy' | 'unknown';
+  
+  /**
+   * Resource usage for this deployment
+   */
+  resourceUsage?: {
+    cpuUsagePercent: number;
+    memoryUsedMB: number;
+    lastUpdated: number;
+  };
+}

package/ts/data/dns.ts

@@ -0,0 +1,100 @@
+export type TDnsRecordType = 'A' | 'AAAA' | 'CNAME' | 'MX' | 'TXT' | 'NS' | 'SOA' | 'SRV' | 'CAA' | 'PTR';
+
+export interface IDnsEntry {
+  id: string;
+  data: {
+    /**
+     * The DNS record type
+     */
+    type: TDnsRecordType;
+    
+    /**
+     * The DNS record name (e.g., www, @, mail)
+     * @ represents the root domain
+     */
+    name: string;
+    
+    /**
+     * The value of the DNS record
+     * - For A/AAAA: IP address
+     * - For CNAME: Target domain
+     * - For MX: Mail server hostname
+     * - For TXT: Text value
+     * - For NS: Nameserver hostname
+     * - For SRV: Target hostname
+     * - For CAA: CAA record value
+     * - For PTR: Domain name
+     */
+    value: string;
+    
+    /**
+     * Time to live in seconds
+     * Default: 3600 (1 hour)
+     */
+    ttl: number;
+    
+    /**
+     * Priority (used for MX and SRV records)
+     * Lower values have higher priority
+     */
+    priority?: number;
+    
+    /**
+     * The DNS zone this entry belongs to
+     * e.g., example.com
+     * @deprecated Use domainId instead
+     */
+    zone: string;
+    
+    /**
+     * The domain ID this DNS entry belongs to
+     * Links to the Domain entity
+     */
+    domainId?: string;
+    
+    /**
+     * Additional fields for SRV records
+     */
+    weight?: number;
+    port?: number;
+    
+    /**
+     * Whether this DNS entry is active
+     */
+    active: boolean;
+    
+    /**
+     * Optional description for documentation
+     */
+    description?: string;
+    
+    /**
+     * Timestamp when the entry was created
+     */
+    createdAt?: number;
+    
+    /**
+     * Timestamp when the entry was last updated
+     */
+    updatedAt?: number;
+    
+    /**
+     * Whether this DNS entry was auto-generated
+     */
+    isAutoGenerated?: boolean;
+    
+    /**
+     * The service ID that created this DNS entry (for auto-generated entries)
+     */
+    sourceServiceId?: string;
+    
+    /**
+     * The source type of this DNS entry
+     * - manual: Created by user through UI/API
+     * - service: Auto-generated from service configuration
+     * - system: Created by system processes
+     * - external: Synced from external DNS providers
+     */
+    sourceType?: 'manual' | 'service' | 'system' | 'external';
+  };
+}

package/ts/data/domain.ts

@@ -0,0 +1,124 @@
+export type TDomainStatus = 'active' | 'pending' | 'expired' | 'suspended' | 'transferred';
+export type TDomainVerificationStatus = 'verified' | 'pending' | 'failed' | 'not_required';
+
+export interface IDomain {
+  id: string;
+  data: {
+    /**
+     * The domain name (e.g., example.com)
+     */
+    name: string;
+    
+    /**
+     * Description or notes about the domain
+     */
+    description?: string;
+    
+    /**
+     * Current status of the domain
+     */
+    status: TDomainStatus;
+    
+    /**
+     * Domain verification status
+     */
+    verificationStatus: TDomainVerificationStatus;
+    
+    /**
+     * Nameservers for the domain
+     */
+    nameservers: string[];
+    
+    /**
+     * Domain registrar information
+     */
+    registrar?: {
+      name: string;
+      url?: string;
+    };
+    
+    /**
+     * Domain registration date (timestamp)
+     */
+    registeredAt?: number;
+    
+    /**
+     * Domain expiration date (timestamp)
+     */
+    expiresAt?: number;
+    
+    /**
+     * Whether auto-renewal is enabled
+     */
+    autoRenew: boolean;
+    
+    /**
+     * DNSSEC enabled
+     */
+    dnssecEnabled?: boolean;
+    
+    /**
+     * Tags for categorization
+     */
+    tags?: string[];
+    
+    /**
+     * Whether this domain is primary for the organization
+     */
+    isPrimary?: boolean;
+    
+    /**
+     * SSL certificate status
+     */
+    sslStatus?: 'active' | 'pending' | 'expired' | 'none';
+
+    /**
+     * Cloudly activation state controls whether we actively manage DNS/certificates
+     * - available: discovered/imported, not actively managed
+     * - activated: actively managed (DNS edits allowed, certs considered)
+     * - ignored: explicitly ignored from management/automation
+     */
+    activationState?: 'available' | 'activated' | 'ignored';
+    
+    /**
+     * Last verification attempt timestamp
+     */
+    lastVerificationAt?: number;
+    
+    /**
+     * Verification method used
+     */
+    verificationMethod?: 'dns' | 'http' | 'email' | 'manual';
+    
+    /**
+     * Verification token (for DNS/HTTP verification)
+     */
+    verificationToken?: string;
+    
+    /**
+     * Cloudflare zone ID if managed by Cloudflare
+     */
+    cloudflareZoneId?: string;
+
+    /**
+     * Sync metadata
+     */
+    syncSource?: 'cloudflare' | 'manual' | null;
+    lastSyncAt?: number;
+    
+    /**
+     * Whether domain is managed externally
+     */
+    isExternal?: boolean;
+    
+    /**
+     * Creation timestamp
+     */
+    createdAt?: number;
+    
+    /**
+     * Last update timestamp
+     */
+    updatedAt?: number;
+  };
+}

package/ts/data/externalregistry.ts

@@ -0,0 +1,110 @@
+import * as plugins from '../plugins.js';
+
+export interface IExternalRegistry {
+  id: string;
+  data: {
+    /**
+     * Registry type
+     */
+    type: 'docker' | 'npm';
+    
+    /**
+     * Human-readable name for the registry
+     */
+    name: string;
+    
+    /**
+     * Registry URL (e.g., https://registry.gitlab.com, docker.io)
+     */
+    url: string;
+    
+    /**
+     * Username for authentication (optional for token-based or public registries)
+     */
+    username?: string;
+    
+    /**
+     * Password, access token, or API key for authentication (optional for public registries)
+     */
+    password?: string;
+    
+    /**
+     * Optional description
+     */
+    description?: string;
+    
+    /**
+     * Whether this is the default registry for its type
+     */
+    isDefault?: boolean;
+    
+    /**
+     * Authentication type
+     */
+    authType?: 'none' | 'basic' | 'token' | 'oauth2';
+    
+    /**
+     * Allow insecure registry connections (HTTP or self-signed certs)
+     */
+    insecure?: boolean;
+    
+    /**
+     * Optional namespace/organization for the registry
+     */
+    namespace?: string;
+    
+    /**
+     * Proxy configuration
+     */
+    proxy?: {
+      http?: string;
+      https?: string;
+      noProxy?: string;
+    };
+    
+    /**
+     * Registry-specific configuration
+     */
+    config?: {
+      /**
+       * For Docker registries
+       */
+      dockerConfig?: {
+        email?: string;
+        serverAddress?: string;
+      };
+      /**
+       * For npm registries
+       */
+      npmConfig?: {
+        scope?: string;
+        alwaysAuth?: boolean;
+      };
+    };
+    
+    /**
+     * Status of the registry connection
+     */
+    status?: 'active' | 'inactive' | 'error' | 'unverified';
+    
+    /**
+     * Last error message if status is 'error'
+     */
+    lastError?: string;
+    
+    /**
+     * Timestamp when the registry was last successfully verified
+     */
+    lastVerified?: number;
+    
+    /**
+     * Timestamp when the registry was created
+     */
+    createdAt?: number;
+    
+    /**
+     * Timestamp when the registry was last updated
+     */
+    updatedAt?: number;
+  };
+}

package/{ts_interfaces → ts}/data/index.ts

@@ -2,15 +2,20 @@ export * from './cloudlyconfig.js';
 export * from './cluster.js';
 export * from './config.js';
 export * from './deployment.js';
+export * from './dns.js';
 export * from './docker.js';
+export * from './domain.js';
 export * from './event.js';
 export * from './externalregistry.js';
 export * from './image.js';
 export * from './secretbundle.js';
-export * from './secretgroup.js'
-export * from './server.js';
+export * from './secretgroup.js';
+export * from './baremetal.js';
+export * from './clusternode.js';
+export * from './settings.js';
 export * from './service.js';
 export * from './status.js';
+export * from './taskexecution.js';
 export * from './traffic.js';
 export * from './user.js';
 export * from './version.js';

package/ts/data/service.ts

@@ -0,0 +1,77 @@
+import type { IServiceRessources } from './docker.js';
+
+export interface IService {
+  id: string;
+  data: {
+    name: string;
+    description: string;
+    imageId: string;
+    imageVersion: string;
+    environment: { [key: string]: string };
+    /**
+     * the main secret bundle id, exclusive to the service
+     */
+    secretBundleId: string;
+    /**
+     * those secret bundle ids do not belong to the service itself
+     * and thus live past the service lifecycle
+     */
+    additionalSecretBundleIds?: string[];
+    
+    /**
+     * Service category determines deployment behavior
+     * - base: Core services that run on every node (coreflow, coretraffic, corelog)
+     * - distributed: Services that run on limited nodes (cores3, coremongo)
+     * - workload: User applications
+     */
+    serviceCategory: 'base' | 'distributed' | 'workload';
+    
+    /**
+     * Deployment strategy for the service
+     * - all-nodes: Deploy to every node in the cluster
+     * - limited-replicas: Deploy to a limited number of nodes
+     * - custom: Custom deployment logic
+     */
+    deploymentStrategy: 'all-nodes' | 'limited-replicas' | 'custom';
+    
+    /**
+     * Maximum number of replicas for distributed services
+     * For example, 3 for cores3 or coremongo
+     */
+    maxReplicas?: number;
+    
+    /**
+     * Whether to enforce anti-affinity rules
+     * When true, tries to spread deployments across different BareMetal servers
+     */
+    antiAffinity?: boolean;
+    
+    scaleFactor: number;
+    balancingStrategy: 'round-robin' | 'least-connections';
+    ports: {
+      web: number;
+      custom?: { [domain: string]: string };
+    };
+    resources?: IServiceRessources;
+    domains: {
+      /**
+       * Optional domain ID to specify which domain to use
+       * If not specified, will use the default domain or require manual configuration
+       */
+      domainId?: string;
+      /**
+       * The subdomain name (e.g., 'api', 'www', '@' for root)
+       */
+      name: string;
+      /**
+       * The port to expose (defaults to ports.web if not specified)
+       */
+      port?: number;
+      /**
+       * The protocol for this domain entry
+       */
+      protocol?: 'http' | 'https' | 'ssh';
+    }[];
+    deploymentIds: string[];
+  };
+}