@ebowwa/hetzner 0.3.2 → 0.3.3

package/dist/onboarding/index.d.ts

@@ -1,19 +0,0 @@
-/**
- * Hetzner Onboarding Module
- *
- * Post-boot configuration for newly provisioned servers.
- * Handles services that require secrets/tokens:
- * - Doppler (secrets management)
- * - Tailscale (VPN)
- * - Git (credentials)
- * - Claude Code (AI assistant)
- *
- * This is Phase 2 of the bootstrap process, running after
- * cloud-init completes the initial installation.
- */
-export type { OnboardingConfig, OnboardingStatus, OnboardingResult, BatchOnboardingResult, ServiceStatus } from "./types";
-export { onboardDoppler, checkDopplerStatus } from "./doppler";
-export { onboardTailscale, checkTailscaleStatus } from "./tailscale";
-export { onboardGit, checkGitStatus } from "./git";
-export { onboardClaude, checkClaudeStatus } from "./claude";
-export { onboardServer, checkOnboardingStatus, onboardBatch } from "./onboarding";

package/dist/onboarding/onboarding.d.ts

@@ -1,41 +0,0 @@
-/**
- * Server Onboarding
- *
- * Main onboarding orchestration.
- * Coordinates Doppler, Tailscale, and Git onboarding.
- */
-import type { SSHOptions } from "@ebowwa/terminal/types";
-import type { OnboardingConfig, OnboardingStatus, OnboardingResult, BatchOnboardingResult } from "./types";
-/**
- * Onboard a single server with all configured services
- *
- * @param config - Onboarding configuration
- * @param sshOptions - Additional SSH options
- * @returns Onboarding result
- */
-export declare function onboardServer(config: OnboardingConfig, sshOptions?: Partial<SSHOptions>): Promise<OnboardingResult>;
-/**
- * Check onboarding status of a server
- *
- * @param host - Server IP or hostname
- * @param sshOptions - SSH options
- * @returns Onboarding status
- */
-export declare function checkOnboardingStatus(host: string, sshOptions?: Partial<SSHOptions>): Promise<OnboardingStatus>;
-/**
- * Onboard multiple servers in parallel
- *
- * @param hosts - List of server IPs/hostnames
- * @param sharedConfig - Shared onboarding config for all servers
- * @param sshOptions - SSH options
- * @returns Batch onboarding result
- */
-export declare function onboardBatch(hosts: string[], sharedConfig: Omit<OnboardingConfig, "host">, sshOptions?: Partial<SSHOptions>): Promise<BatchOnboardingResult>;
-/**
- * Quick onboarding check for multiple servers
- *
- * @param hosts - List of server IPs/hostnames
- * @param sshOptions - SSH options
- * @returns Map of host to onboarding status
- */
-export declare function checkBatchStatus(hosts: string[], sshOptions?: Partial<SSHOptions>): Promise<Map<string, OnboardingStatus>>;

package/dist/onboarding/tailscale.d.ts

@@ -1,38 +0,0 @@
-/**
- * Tailscale Onboarding
- *
- * Join Tailscale network on remote servers.
- * Enables secure VPN access to servers.
- */
-import type { SSHOptions } from "@ebowwa/terminal/types";
-export interface TailscaleConfig {
-    authKey: string;
-    hostname?: string;
-    tags?: string[];
-}
-/**
- * Join Tailscale network on a remote server
- *
- * @param host - Server IP or hostname
- * @param config - Tailscale configuration
- * @param sshOptions - SSH options
- * @returns Success status with Tailscale IP
- */
-export declare function onboardTailscale(host: string, config: TailscaleConfig, sshOptions?: Partial<SSHOptions>): Promise<{
-    success: boolean;
-    message: string;
-    tailscaleIp?: string;
-}>;
-/**
- * Check Tailscale status on a remote server
- *
- * @param host - Server IP or hostname
- * @param sshOptions - SSH options
- * @returns Tailscale status
- */
-export declare function checkTailscaleStatus(host: string, sshOptions?: Partial<SSHOptions>): Promise<{
-    configured: boolean;
-    tailscaleIp?: string;
-    hostname?: string;
-    message: string;
-}>;

package/dist/onboarding/types.d.ts

@@ -1,111 +0,0 @@
-/**
- * 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

@@ -1,330 +0,0 @@
-/**
- * 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>;
-}