@kici-dev/orchestrator 0.0.0 → 0.1.2

package/dist/scaler/config.d.ts

@@ -0,0 +1,303 @@
+/**
+ * YAML configuration loading and Zod validation for the scaler module.
+ *
+ * Handles:
+ * - Main YAML config file parsing
+ * - scalers.d/ directory merging (alphabetically sorted)
+ * - Zod schema validation with type-specific refinements
+ * - Memory string parsing (e.g., "2g" -> bytes)
+ */
+import { z } from 'zod';
+import type { ScalerConfig } from './types.js';
+/**
+ * Zod schema for network policy configuration on a label set.
+ * Controls RFC1918 and internet access for spawned agents.
+ */
+export declare const networkPolicySchema: z.ZodOptional<z.ZodObject<{
+    allowlist: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    denyAll: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>>;
+/**
+ * Zod schema for a label-set configuration entry.
+ */
+export declare const labelSetConfigSchema: z.ZodObject<{
+    labels: z.ZodArray<z.ZodString>;
+    image: z.ZodOptional<z.ZodString>;
+    imagePullPolicy: z.ZodDefault<z.ZodEnum<{
+        Always: "Always";
+        IfNotPresent: "IfNotPresent";
+        Never: "Never";
+    }>>;
+    binaryPath: z.ZodOptional<z.ZodString>;
+    resources: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodObject<{
+        requests: z.ZodOptional<z.ZodObject<{
+            memory: z.ZodOptional<z.ZodString>;
+            cpus: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        limits: z.ZodOptional<z.ZodObject<{
+            memory: z.ZodOptional<z.ZodString>;
+            cpus: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        memory: z.ZodOptional<z.ZodString>;
+        cpus: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>]>, z.ZodTransform<{
+        requests?: {
+            cpus?: number;
+            memory?: string;
+        };
+        limits?: {
+            cpus?: number;
+            memory?: string;
+        };
+    }, {
+        memory?: string | undefined;
+        cpus?: number | undefined;
+    } | {
+        requests?: {
+            memory?: string | undefined;
+            cpus?: number | undefined;
+        } | undefined;
+        limits?: {
+            memory?: string | undefined;
+            cpus?: number | undefined;
+        } | undefined;
+    }>>>;
+    volumes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    containerSocket: z.ZodDefault<z.ZodBoolean>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    backpressureMode: z.ZodOptional<z.ZodEnum<{
+        pause: "pause";
+        drop: "drop";
+    }>>;
+    networkPolicy: z.ZodOptional<z.ZodObject<{
+        allowlist: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        denyAll: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    rootfsPath: z.ZodOptional<z.ZodString>;
+    kernelPath: z.ZodOptional<z.ZodString>;
+    vcpuCount: z.ZodOptional<z.ZodNumber>;
+    memSizeMib: z.ZodOptional<z.ZodNumber>;
+    overlayDriveSizeMib: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+/**
+ * Zod schema for Firecracker network configuration.
+ * Global across all Firecracker scalers on the orchestrator.
+ */
+export declare const firecrackerNetworkSchema: z.ZodObject<{
+    cidr: z.ZodDefault<z.ZodString>;
+    bridgeName: z.ZodDefault<z.ZodString>;
+    gateway: z.ZodDefault<z.ZodString>;
+    netmask: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Zod schema for the complete scaler configuration file.
+ * Validates version, global limits, defaults, and scaler entries.
+ */
+export declare const scalerFileSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    globalMaxAgents: z.ZodDefault<z.ZodNumber>;
+    defaults: z.ZodOptional<z.ZodObject<{
+        resources: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodObject<{
+            requests: z.ZodOptional<z.ZodObject<{
+                memory: z.ZodOptional<z.ZodString>;
+                cpus: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>;
+            limits: z.ZodOptional<z.ZodObject<{
+                memory: z.ZodOptional<z.ZodString>;
+                cpus: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodObject<{
+            memory: z.ZodOptional<z.ZodString>;
+            cpus: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>]>, z.ZodTransform<{
+            requests?: {
+                cpus?: number;
+                memory?: string;
+            };
+            limits?: {
+                cpus?: number;
+                memory?: string;
+            };
+        }, {
+            memory?: string | undefined;
+            cpus?: number | undefined;
+        } | {
+            requests?: {
+                memory?: string | undefined;
+                cpus?: number | undefined;
+            } | undefined;
+            limits?: {
+                memory?: string | undefined;
+                cpus?: number | undefined;
+            } | undefined;
+        }>>>;
+    }, z.core.$strip>>;
+    globalResourceCap: z.ZodOptional<z.ZodPipe<z.ZodObject<{
+        maxCpu: z.ZodOptional<z.ZodNumber>;
+        maxMemory: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodTransform<{
+        maxCpu: number | undefined;
+        maxMemoryBytes: number | undefined;
+    }, {
+        maxCpu?: number | undefined;
+        maxMemory?: string | undefined;
+    }>>>;
+    machinePools: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        cap: z.ZodPipe<z.ZodObject<{
+            maxCpu: z.ZodOptional<z.ZodNumber>;
+            maxMemory: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodTransform<{
+            maxCpu: number | undefined;
+            maxMemoryBytes: number | undefined;
+        }, {
+            maxCpu?: number | undefined;
+            maxMemory?: string | undefined;
+        }>>;
+    }, z.core.$strict>>>;
+    scalers: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            container: "container";
+            "bare-metal": "bare-metal";
+            firecracker: "firecracker";
+        }>;
+        maxAgents: z.ZodNumber;
+        labelSets: z.ZodArray<z.ZodObject<{
+            labels: z.ZodArray<z.ZodString>;
+            image: z.ZodOptional<z.ZodString>;
+            imagePullPolicy: z.ZodDefault<z.ZodEnum<{
+                Always: "Always";
+                IfNotPresent: "IfNotPresent";
+                Never: "Never";
+            }>>;
+            binaryPath: z.ZodOptional<z.ZodString>;
+            resources: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodObject<{
+                requests: z.ZodOptional<z.ZodObject<{
+                    memory: z.ZodOptional<z.ZodString>;
+                    cpus: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strict>>;
+                limits: z.ZodOptional<z.ZodObject<{
+                    memory: z.ZodOptional<z.ZodString>;
+                    cpus: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>, z.ZodObject<{
+                memory: z.ZodOptional<z.ZodString>;
+                cpus: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>]>, z.ZodTransform<{
+                requests?: {
+                    cpus?: number;
+                    memory?: string;
+                };
+                limits?: {
+                    cpus?: number;
+                    memory?: string;
+                };
+            }, {
+                memory?: string | undefined;
+                cpus?: number | undefined;
+            } | {
+                requests?: {
+                    memory?: string | undefined;
+                    cpus?: number | undefined;
+                } | undefined;
+                limits?: {
+                    memory?: string | undefined;
+                    cpus?: number | undefined;
+                } | undefined;
+            }>>>;
+            volumes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            containerSocket: z.ZodDefault<z.ZodBoolean>;
+            env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            backpressureMode: z.ZodOptional<z.ZodEnum<{
+                pause: "pause";
+                drop: "drop";
+            }>>;
+            networkPolicy: z.ZodOptional<z.ZodObject<{
+                allowlist: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                denyAll: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strip>>;
+            rootfsPath: z.ZodOptional<z.ZodString>;
+            kernelPath: z.ZodOptional<z.ZodString>;
+            vcpuCount: z.ZodOptional<z.ZodNumber>;
+            memSizeMib: z.ZodOptional<z.ZodNumber>;
+            overlayDriveSizeMib: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        host: z.ZodOptional<z.ZodString>;
+        socketPath: z.ZodOptional<z.ZodString>;
+        runtime: z.ZodDefault<z.ZodEnum<{
+            docker: "docker";
+            podman: "podman";
+            auto: "auto";
+        }>>;
+        orchestratorUrl: z.ZodOptional<z.ZodString>;
+        extraHosts: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        networkIsolation: z.ZodDefault<z.ZodBoolean>;
+        warmPool: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            size: z.ZodDefault<z.ZodNumber>;
+            idleTimeoutSeconds: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+        mandatoryLabels: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        roles: z.ZodPipe<z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            builder: "builder";
+            "init-runner": "init-runner";
+            all: "all";
+        }>>>, z.ZodTransform<string[] | undefined, ("builder" | "init-runner" | "all")[] | undefined>>;
+        resourceCap: z.ZodOptional<z.ZodPipe<z.ZodObject<{
+            maxCpu: z.ZodOptional<z.ZodNumber>;
+            maxMemory: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodTransform<{
+            maxCpu: number | undefined;
+            maxMemoryBytes: number | undefined;
+        }, {
+            maxCpu?: number | undefined;
+            maxMemory?: string | undefined;
+        }>>>;
+        machinePool: z.ZodOptional<z.ZodString>;
+        enforceCgroups: z.ZodDefault<z.ZodBoolean>;
+        firecrackerPath: z.ZodOptional<z.ZodString>;
+        jailerPath: z.ZodOptional<z.ZodString>;
+        kernelPath: z.ZodOptional<z.ZodString>;
+        chrootBaseDir: z.ZodDefault<z.ZodString>;
+        uid: z.ZodOptional<z.ZodNumber>;
+        gid: z.ZodOptional<z.ZodNumber>;
+        vcpuCount: z.ZodDefault<z.ZodNumber>;
+        memSizeMib: z.ZodDefault<z.ZodNumber>;
+        requireSudo: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    firecracker: z.ZodOptional<z.ZodObject<{
+        cidr: z.ZodDefault<z.ZodString>;
+        bridgeName: z.ZodDefault<z.ZodString>;
+        gateway: z.ZodDefault<z.ZodString>;
+        netmask: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Parse a memory string with unit suffix to bytes.
+ *
+ * Supported formats:
+ * - "512m" or "512M" -> 536870912 (512 * 1024^2)
+ * - "2g" or "2G" -> 2147483648 (2 * 1024^3)
+ * - "1024k" or "1024K" -> 1048576 (1024 * 1024)
+ *
+ * @throws Error if the format is invalid
+ */
+export declare function parseMemoryString(memory: string): number;
+/**
+ * Load and validate the scaler configuration from YAML files.
+ *
+ * 1. Reads the main config file
+ * 2. If scalersDirPath provided, reads all *.yaml and *.yml files
+ *    from the directory (sorted alphabetically) and merges their
+ *    scalers arrays into the main config
+ * 3. Validates the merged config through Zod schema
+ *
+ * @param configPath - Path to the main scaler YAML config file
+ * @param scalersDirPath - Optional path to scalers.d/ directory for additional scaler definitions
+ * @returns Validated ScalerConfig
+ * @throws ZodError if validation fails
+ */
+export declare function loadScalerConfig(configPath: string, scalersDirPath?: string): Promise<ScalerConfig>;
+//# sourceMappingURL=config.d.ts.map

package/dist/scaler/container-backend.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Container scaler backend implementation.
+ *
+ * Manages ephemeral agent containers using Docker or Podman via dockerode.
+ * Supports auto-detection of container runtime socket.
+ * Handles full container lifecycle: pull, create, start, stop, remove.
+ * Supports container socket sharing, resource limits, and orphan cleanup.
+ */
+import { type ToolRequirement } from '@kici-dev/shared';
+import type { AgentTokenStore } from '../agent/token-store.js';
+import type { ScalerBackend, ManagedAgent, LabelSetConfig, LogCapture, ResourceRequest, EffectiveLimits, ScalerEventCallback, ValidationResult } from './types.js';
+/**
+ * Result of runtime detection.
+ */
+export interface DetectedRuntime {
+    socketPath: string;
+    runtime: 'docker' | 'podman';
+}
+/**
+ * Probe known socket paths to detect which container runtime is available.
+ * Returns the first accessible socket found, or null if none found.
+ */
+export declare function detectRuntime(runtimeHint?: 'docker' | 'podman' | 'auto'): Promise<DetectedRuntime | null>;
+export interface ContainerScalerBackendOptions {
+    /** Human-readable name for this scaler */
+    name: string;
+    /** Label sets this backend can provision */
+    labelSets: LabelSetConfig[];
+    /** Maximum concurrent agents */
+    maxAgents: number;
+    /** Container runtime host for remote connections (works for Docker and Podman remote) */
+    host?: string;
+    /** Explicit socket path (overrides auto-detection) */
+    socketPath?: string;
+    /** Runtime type hint: 'docker', 'podman', or 'auto' (default: 'auto') */
+    runtime?: 'docker' | 'podman' | 'auto';
+    /** Default resource limits applied when label set has none */
+    defaultResources?: ResourceRequest;
+    /** Extra host:IP mappings injected into spawned containers (e.g. ["verdaccio.local:host-gateway"]) */
+    extraHosts?: string[];
+    /** Disable nftables-based network isolation (default: true). Set to false when nft is unavailable (e.g. rootless containers without NET_ADMIN). */
+    networkIsolation?: boolean;
+    /** Token store for creating ephemeral agent auth tokens. Optional -- when undefined, no token is injected. */
+    tokenStore?: AgentTokenStore;
+    /** TTL for ephemeral agent tokens in ms. Default: 1 hour. */
+    tokenTtlMs?: number;
+    /** Agent roles for this scaler. undefined = all, [] = execution only. */
+    roles?: string[];
+}
+export declare class ContainerScalerBackend implements ScalerBackend {
+    readonly type: "container";
+    readonly maxAgents: number;
+    private _labelSets;
+    private readonly name;
+    private readonly docker;
+    private readonly defaultResources?;
+    /** The resolved socket path (for socket sharing bind mounts) */
+    private readonly resolvedSocketPath;
+    /** The detected or configured runtime type */
+    private readonly detectedRuntime;
+    /** Extra host:IP mappings for spawned containers */
+    private readonly extraHosts?;
+    /** Whether nftables-based network isolation is enabled */
+    private readonly networkIsolation;
+    /** Token store for creating ephemeral agent auth tokens */
+    private readonly tokenStore?;
+    /** TTL for ephemeral agent tokens in ms */
+    private readonly tokenTtlMs;
+    /** Agent roles for this scaler. undefined = all, [] = execution only. */
+    private readonly roles;
+    /** ID of the isolated bridge network (set after creation/discovery) */
+    private isolatedNetworkId;
+    /** Host bridge interface name for the isolated network (used by nftables) */
+    private isolatedBridgeIface;
+    /** Tracks all managed agent containers by ManagedAgent.id */
+    private readonly agents;
+    /** Maps container ID to ManagedAgent.id for reverse lookup */
+    private readonly containerToManaged;
+    /** LogCapture instances for each managed agent (keyed by ManagedAgent.id) */
+    private readonly logCaptures;
+    /** Maps managedId → container IP on the isolated network (for per-container nftables cleanup) */
+    private readonly containerIps;
+    private constructor();
+    /**
+     * Ensure the isolated bridge network exists and nftables rules are applied.
+     *
+     * Creates `kici-agent-net` if it doesn't exist, inspects the network to
+     * discover the host bridge interface name, then applies RFC1918 + metadata
+     * blocking rules via nftables with a gateway exception.
+     *
+     * Idempotent: safe to call across orchestrator restarts.
+     */
+    private ensureIsolatedNetwork;
+    /**
+     * Declare required tools for a container scaler entry.
+     * Container runtime socket and nftables are validated during create() — no
+     * additional tool declarations needed here.
+     */
+    static getRequiredTools(): ToolRequirement[];
+    /**
+     * Create a ContainerScalerBackend with auto-detected or configured socket.
+     * Throws if no container runtime is found and no host is configured.
+     */
+    static create(options: ContainerScalerBackendOptions): Promise<ContainerScalerBackend>;
+    /** Log source identifier: 'docker' or 'podman' based on detected runtime. */
+    get logsSource(): string;
+    get labelSets(): LabelSetConfig[];
+    getActiveCount(): number;
+    spawn(labelSet: string[], agentId: string, orchestratorUrl: string, onEvent?: ScalerEventCallback, effectiveLimits?: EffectiveLimits): Promise<ManagedAgent>;
+    getScalerContext(agentId: string): Record<string, unknown> | undefined;
+    destroy(managedId: string): Promise<void>;
+    /**
+     * Get the LogCapture for a managed agent (used by ScalerManager for log forwarding).
+     */
+    getLogCapture(managedId: string): LogCapture | undefined;
+    shutdownAll(): Promise<void>;
+    reload(labelSets: LabelSetConfig[]): ValidationResult;
+    /**
+     * Clean up orphaned kici-managed containers on startup.
+     * Finds containers with the `kici-managed=true` label and removes them.
+     * Returns the count of cleaned containers.
+     */
+    cleanupOrphans(): Promise<number>;
+}
+//# sourceMappingURL=container-backend.d.ts.map

package/dist/scaler/file-tail.d.ts

@@ -0,0 +1,23 @@
+/**
+ * File tailing utility for append-only log files.
+ *
+ * Provides an async generator that yields complete lines as they are appended
+ * to a file, using `fs.watch()` for change notifications and partial line
+ * buffering for split writes.
+ *
+ * Used by the Firecracker backend to tail serial console and VMM log files
+ * from the jailer chroot directory.
+ */
+/**
+ * Tail an append-only file, yielding complete lines as they are written.
+ *
+ * Pre-creates the file if it does not exist to avoid watch errors.
+ * Tracks byte offset and partial (incomplete) trailing lines across reads.
+ * Stops when the provided AbortSignal is triggered.
+ *
+ * @param filePath - Path to the file to tail
+ * @param signal - AbortSignal to stop tailing
+ * @yields Complete lines (non-empty) as they are appended to the file
+ */
+export declare function tailFile(filePath: string, signal: AbortSignal): AsyncGenerator<string>;
+//# sourceMappingURL=file-tail.d.ts.map

package/dist/scaler/firecracker-api.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Firecracker REST API client over Unix domain sockets.
+ *
+ * Provides a thin wrapper around Node.js built-in `http` module for communicating
+ * with Firecracker's REST API. Uses the `socketPath` option for HTTP-over-Unix-socket.
+ *
+ * Only used for post-boot operations:
+ * - MMDS data injection (passing agent config to the guest VM)
+ * - Graceful shutdown via SendCtrlAltDel (x86_64 only)
+ * - Socket readiness polling after jailer invocation
+ *
+ * Pre-boot VM configuration uses `--config-file` JSON (atomic, simpler).
+ *
+ * @see https://github.com/firecracker-microvm/firecracker/blob/main/docs/getting-started.md
+ * @see https://github.com/firecracker-microvm/firecracker/blob/main/docs/mmds/mmds-user-guide.md
+ */
+/**
+ * Error thrown when the Firecracker API returns a non-2xx status code
+ * or a network-level error occurs.
+ */
+export declare class FirecrackerApiError extends Error {
+    /** HTTP status code from the Firecracker API (undefined for network errors) */
+    readonly statusCode: number | undefined;
+    /** The API path that was requested */
+    readonly path: string;
+    /** The response body from the Firecracker API */
+    readonly responseBody: string;
+    constructor(message: string, path: string, statusCode?: number, responseBody?: string);
+}
+/**
+ * Thin REST client for the Firecracker API over Unix domain sockets.
+ *
+ * No external dependencies -- uses Node.js built-in `http` module with
+ * the `socketPath` option for HTTP-over-Unix-socket communication.
+ */
+export declare class FirecrackerApi {
+    private readonly socketPath;
+    constructor(socketPath: string);
+    /**
+     * Send an HTTP request to the Firecracker API.
+     *
+     * @param method - HTTP method (GET, PUT, PATCH)
+     * @param path - API path (e.g., '/mmds', '/actions', '/')
+     * @param body - Optional JSON body for PUT/PATCH requests
+     * @returns Response with statusCode and body
+     * @throws FirecrackerApiError on non-2xx status or network error
+     */
+    private request;
+    /**
+     * Inject MMDS (Micro VM Metadata Service) data into a running VM.
+     *
+     * Uses MMDS v2 data injection endpoint. The data should follow the structure:
+     * `{ latest: { 'meta-data': { ... } } }`
+     *
+     * The guest VM reads this data from http://169.254.169.254/latest/meta-data/
+     * using a token-based session (MMDS v2).
+     *
+     * @param data - Metadata object to inject
+     * @see https://github.com/firecracker-microvm/firecracker/blob/main/docs/mmds/mmds-user-guide.md
+     */
+    putMmds(data: Record<string, unknown>): Promise<void>;
+    /**
+     * Clear MMDS data after agent has received config via WS.
+     * Replaces the MMDS data with an empty meta-data object.
+     * Called after receiving config.ack from the agent.
+     */
+    clearMmds(): Promise<void>;
+    /**
+     * Send a SendCtrlAltDel action for graceful x86_64 shutdown.
+     *
+     * This simulates pressing Ctrl+Alt+Del on the virtual keyboard,
+     * which triggers a clean shutdown in most Linux distributions.
+     *
+     * Note: Only works on x86_64. On arm64, the i8042 keyboard controller
+     * is not available, so this action is not supported. Use process kill
+     * as fallback on arm64.
+     *
+     * @see https://github.com/firecracker-microvm/firecracker/blob/main/docs/getting-started.md
+     */
+    sendCtrlAltDel(): Promise<void>;
+    /**
+     * Get instance info from the Firecracker API root endpoint.
+     *
+     * Used to check if the API socket is reachable and the VM is running.
+     * Returns the parsed JSON response with instance information.
+     */
+    getInstanceInfo(): Promise<Record<string, unknown>>;
+    /**
+     * Poll the Firecracker API socket until it becomes reachable or timeout expires.
+     *
+     * Used after jailer invocation to wait for Firecracker to create the API socket
+     * and become ready to accept requests.
+     *
+     * @param timeoutMs - Maximum time to wait in milliseconds (default: 5000)
+     * @param intervalMs - Polling interval in milliseconds (default: 100)
+     * @returns true if socket became reachable, false on timeout
+     */
+    waitForSocket(timeoutMs?: number, intervalMs?: number): Promise<boolean>;
+}
+//# sourceMappingURL=firecracker-api.d.ts.map