@ebowwa/hetzner 0.3.0 → 0.3.2

package/dist/onboarding/types.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Onboarding Types
+ *
+ * Type definitions for server onboarding operations.
+ */
+/**
+ * Onboarding configuration for a server
+ */
+export interface OnboardingConfig {
+    /** Server IP or hostname */
+    host: string;
+    /** SSH user (default: root) */
+    user?: string;
+    /** SSH port (default: 22) */
+    port?: number;
+    /** Doppler configuration */
+    doppler?: {
+        /** Doppler service token */
+        token: string;
+        /** Doppler project (default: seed) */
+        project?: string;
+        /** Doppler config (default: prd) */
+        config?: string;
+    };
+    /** Tailscale configuration */
+    tailscale?: {
+        /** Tailscale auth key */
+        authKey: string;
+        /** Tailscale hostname (optional) */
+        hostname?: string;
+        /** Tailscale tags (optional) */
+        tags?: string[];
+    };
+    /** Git configuration */
+    git?: {
+        /** Git username */
+        username?: string;
+        /** Git email */
+        email?: string;
+        /** GitHub token for gh cli */
+        githubToken?: string;
+    };
+    /** Claude Code configuration */
+    claude?: {
+        /** Skip installation if already installed (default: true) */
+        skipIfInstalled?: boolean;
+    };
+}
+/**
+ * Onboarding status for a single service
+ */
+export interface ServiceStatus {
+    /** Service name */
+    service: "doppler" | "tailscale" | "git" | "claude";
+    /** Whether service is configured */
+    configured: boolean;
+    /** Status message */
+    message: string;
+    /** Configuration details (sanitized) */
+    details?: Record<string, unknown>;
+}
+/**
+ * Overall onboarding status
+ */
+export interface OnboardingStatus {
+    /** Server being checked */
+    host: string;
+    /** Status of each service */
+    services: {
+        doppler: ServiceStatus;
+        tailscale: ServiceStatus;
+        git: ServiceStatus;
+        claude: ServiceStatus;
+    };
+    /** Overall onboarding complete */
+    complete: boolean;
+    /** Timestamp */
+    checkedAt: string;
+}
+/**
+ * Result of an onboarding operation
+ */
+export interface OnboardingResult {
+    /** Server that was onboarded */
+    host: string;
+    /** Services that were configured */
+    configured: ("doppler" | "tailscale" | "git" | "claude")[];
+    /** Services that failed */
+    failed: Array<{
+        service: "doppler" | "tailscale" | "git" | "claude";
+        error: string;
+    }>;
+    /** Overall success */
+    success: boolean;
+    /** Timestamp */
+    completedAt: string;
+}
+/**
+ * Batch onboarding result
+ */
+export interface BatchOnboardingResult {
+    /** Results for each server */
+    results: OnboardingResult[];
+    /** Summary statistics */
+    summary: {
+        total: number;
+        succeeded: number;
+        failed: number;
+        partial: number;
+    };
+}

package/dist/pricing.d.ts

@@ -0,0 +1,330 @@
+/**
+ * Hetzner pricing operations - fetch server types, locations, and calculate costs
+ */
+import { z } from "zod";
+import type { HetznerServerType, HetznerLocation, HetznerDatacenter } from "./types.js";
+import type { HetznerClient } from "./client.js";
+import type { Environment } from "@ebowwa/codespaces-types/compile";
+/**
+ * Price information for a server type (in EUR)
+ */
+export interface ServerTypePrice {
+    /** Server type name (e.g., "cpx11") */
+    serverType: string;
+    /** Monthly price in EUR */
+    priceMonthly: number;
+    /** Hourly price in EUR */
+    priceHourly: number;
+    /** Whether the server type is deprecated */
+    deprecated: boolean;
+}
+/**
+ * Cost breakdown for a single environment
+ */
+export interface EnvironmentCost {
+    /** Environment ID */
+    environmentId: string;
+    /** Environment name */
+    environmentName: string;
+    /** Server type name */
+    serverType: string;
+    /** Whether the environment is currently running */
+    isRunning: boolean;
+    /** Monthly cost in EUR */
+    costMonthly: number;
+    /** Hourly cost in EUR */
+    costHourly: number;
+    /** Price info (undefined if server type not found) */
+    priceInfo?: ServerTypePrice;
+}
+/**
+ * Total cost calculation result
+ */
+export interface CostCalculationResult {
+    /** Total monthly cost for all running environments (EUR) */
+    totalMonthly: number;
+    /** Total hourly cost for all running environments (EUR) */
+    totalHourly: number;
+    /** Number of environments included in calculation */
+    runningEnvironmentCount: number;
+    /** Number of environments excluded (not running) */
+    stoppedEnvironmentCount: number;
+    /** Number of environments with unknown server types */
+    unknownServerTypeCount: number;
+    /** Detailed breakdown by environment */
+    breakdown: EnvironmentCost[];
+    /** Map of server type names to their prices (for reference) */
+    priceMap: Map<string, ServerTypePrice>;
+}
+/**
+ * Schema for server type price entry
+ */
+export declare const ServerTypePriceSchema: z.ZodObject<{
+    serverType: z.ZodString;
+    priceMonthly: z.ZodNumber;
+    priceHourly: z.ZodNumber;
+    deprecated: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    deprecated?: boolean;
+    serverType?: string;
+    priceMonthly?: number;
+    priceHourly?: number;
+}, {
+    deprecated?: boolean;
+    serverType?: string;
+    priceMonthly?: number;
+    priceHourly?: number;
+}>;
+/**
+ * Schema for environment cost entry
+ */
+export declare const EnvironmentCostSchema: z.ZodObject<{
+    environmentId: z.ZodString;
+    environmentName: z.ZodString;
+    serverType: z.ZodString;
+    isRunning: z.ZodBoolean;
+    costMonthly: z.ZodNumber;
+    costHourly: z.ZodNumber;
+    priceInfo: z.ZodOptional<z.ZodObject<{
+        serverType: z.ZodString;
+        priceMonthly: z.ZodNumber;
+        priceHourly: z.ZodNumber;
+        deprecated: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    }, "strip", z.ZodTypeAny, {
+        deprecated?: boolean;
+        serverType?: string;
+        priceMonthly?: number;
+        priceHourly?: number;
+    }, {
+        deprecated?: boolean;
+        serverType?: string;
+        priceMonthly?: number;
+        priceHourly?: number;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    serverType?: string;
+    environmentId?: string;
+    environmentName?: string;
+    isRunning?: boolean;
+    costMonthly?: number;
+    costHourly?: number;
+    priceInfo?: {
+        deprecated?: boolean;
+        serverType?: string;
+        priceMonthly?: number;
+        priceHourly?: number;
+    };
+}, {
+    serverType?: string;
+    environmentId?: string;
+    environmentName?: string;
+    isRunning?: boolean;
+    costMonthly?: number;
+    costHourly?: number;
+    priceInfo?: {
+        deprecated?: boolean;
+        serverType?: string;
+        priceMonthly?: number;
+        priceHourly?: number;
+    };
+}>;
+/**
+ * Schema for cost calculation result
+ */
+export declare const CostCalculationResultSchema: z.ZodObject<{
+    totalMonthly: z.ZodNumber;
+    totalHourly: z.ZodNumber;
+    runningEnvironmentCount: z.ZodNumber;
+    stoppedEnvironmentCount: z.ZodNumber;
+    unknownServerTypeCount: z.ZodNumber;
+    breakdown: z.ZodArray<z.ZodObject<{
+        environmentId: z.ZodString;
+        environmentName: z.ZodString;
+        serverType: z.ZodString;
+        isRunning: z.ZodBoolean;
+        costMonthly: z.ZodNumber;
+        costHourly: z.ZodNumber;
+        priceInfo: z.ZodOptional<z.ZodObject<{
+            serverType: z.ZodString;
+            priceMonthly: z.ZodNumber;
+            priceHourly: z.ZodNumber;
+            deprecated: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        }, "strip", z.ZodTypeAny, {
+            deprecated?: boolean;
+            serverType?: string;
+            priceMonthly?: number;
+            priceHourly?: number;
+        }, {
+            deprecated?: boolean;
+            serverType?: string;
+            priceMonthly?: number;
+            priceHourly?: number;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        serverType?: string;
+        environmentId?: string;
+        environmentName?: string;
+        isRunning?: boolean;
+        costMonthly?: number;
+        costHourly?: number;
+        priceInfo?: {
+            deprecated?: boolean;
+            serverType?: string;
+            priceMonthly?: number;
+            priceHourly?: number;
+        };
+    }, {
+        serverType?: string;
+        environmentId?: string;
+        environmentName?: string;
+        isRunning?: boolean;
+        costMonthly?: number;
+        costHourly?: number;
+        priceInfo?: {
+            deprecated?: boolean;
+            serverType?: string;
+            priceMonthly?: number;
+            priceHourly?: number;
+        };
+    }>, "many">;
+    priceMap: z.ZodType<Map<string, ServerTypePrice>, z.ZodTypeDef, Map<string, ServerTypePrice>>;
+}, "strip", z.ZodTypeAny, {
+    totalMonthly?: number;
+    totalHourly?: number;
+    runningEnvironmentCount?: number;
+    stoppedEnvironmentCount?: number;
+    unknownServerTypeCount?: number;
+    breakdown?: {
+        serverType?: string;
+        environmentId?: string;
+        environmentName?: string;
+        isRunning?: boolean;
+        costMonthly?: number;
+        costHourly?: number;
+        priceInfo?: {
+            deprecated?: boolean;
+            serverType?: string;
+            priceMonthly?: number;
+            priceHourly?: number;
+        };
+    }[];
+    priceMap?: Map<string, ServerTypePrice>;
+}, {
+    totalMonthly?: number;
+    totalHourly?: number;
+    runningEnvironmentCount?: number;
+    stoppedEnvironmentCount?: number;
+    unknownServerTypeCount?: number;
+    breakdown?: {
+        serverType?: string;
+        environmentId?: string;
+        environmentName?: string;
+        isRunning?: boolean;
+        costMonthly?: number;
+        costHourly?: number;
+        priceInfo?: {
+            deprecated?: boolean;
+            serverType?: string;
+            priceMonthly?: number;
+            priceHourly?: number;
+        };
+    }[];
+    priceMap?: Map<string, ServerTypePrice>;
+}>;
+/**
+ * Parse Hetzner price string to number (EUR)
+ * Hetzner returns prices as strings in gross format (e.g., "5.3400" for 5.34 EUR)
+ *
+ * @param priceString - Price string from Hetzner API (gross field)
+ * @returns Price in EUR as number
+ */
+export declare function parseHetznerPrice(priceString: string): number;
+/**
+ * Extract pricing information from a Hetzner server type
+ * Uses the first price entry (location-agnostic pricing)
+ *
+ * @param serverType - Hetzner server type object
+ * @returns Server type price info or undefined if pricing unavailable
+ */
+export declare function extractServerTypePrice(serverType: HetznerServerType): ServerTypePrice | undefined;
+/**
+ * Build a price lookup map from server types
+ *
+ * @param serverTypes - Array of Hetzner server types
+ * @returns Map of server type name to price info
+ */
+export declare function buildPriceMap(serverTypes: HetznerServerType[]): Map<string, ServerTypePrice>;
+/**
+ * Get the monthly price for a server type from the price map
+ * Returns fallback price for unknown/deprecated types
+ *
+ * @param serverTypeName - Name of the server type
+ * @param priceMap - Price lookup map
+ * @param fallbackPrice - Fallback price for unknown types (default: 5.0 EUR)
+ * @returns Monthly price in EUR
+ */
+export declare function getServerTypeMonthlyPrice(serverTypeName: string, priceMap: Map<string, ServerTypePrice>, fallbackPrice?: number): number;
+/**
+ * Calculate hourly price from monthly price
+ * Uses standard 730 hours per month
+ *
+ * @param monthlyPrice - Monthly price in EUR
+ * @returns Hourly price in EUR
+ */
+export declare function calculateHourlyFromMonthly(monthlyPrice: number): number;
+/**
+ * Calculate total costs for a list of environments
+ *
+ * This function:
+ * - Only includes environments with "running" status
+ * - Handles missing/deprecated server types with fallback pricing
+ * - Returns detailed breakdown and aggregated totals
+ *
+ * @param environments - Array of environment objects
+ * @param serverTypes - Array of Hetzner server types with pricing
+ * @param options - Optional configuration
+ * @returns Cost calculation result with totals and breakdown
+ */
+export declare function calculateCosts(environments: Environment[], serverTypes: HetznerServerType[], options?: {
+    /** Custom fallback price for unknown server types (EUR/month) */
+    fallbackPrice?: number;
+    /** Whether to include stopped environments in breakdown (default: false) */
+    includeStopped?: boolean;
+}): CostCalculationResult;
+export declare class PricingOperations {
+    private client;
+    constructor(client: HetznerClient);
+    /**
+     * List all server types
+     */
+    listServerTypes(): Promise<HetznerServerType[]>;
+    /**
+     * Get a specific server type by name
+     */
+    getServerType(name: string): Promise<HetznerServerType | undefined>;
+    /**
+     * List all locations
+     */
+    listLocations(): Promise<HetznerLocation[]>;
+    /**
+     * Get a specific location by name
+     */
+    getLocation(name: string): Promise<HetznerLocation | undefined>;
+    /**
+     * List all datacenters
+     */
+    listDatacenters(): Promise<HetznerDatacenter[]>;
+    /**
+     * Calculate costs for environments using current Hetzner pricing
+     *
+     * Convenience method that fetches server types and calculates costs in one call
+     *
+     * @param environments - Array of environment objects
+     * @param options - Optional configuration for cost calculation
+     * @returns Cost calculation result
+     */
+    calculateEnvironmentCosts(environments: Environment[], options?: {
+        fallbackPrice?: number;
+        includeStopped?: boolean;
+    }): Promise<CostCalculationResult>;
+}