endia 0.0.0-stage → 0.0.2

package/dist/contract/machines.d.ts

@@ -0,0 +1,199 @@
+import type { ApiError, Timestamp } from "./common.js";
+import type { PurposeDetail, PurposeSource, PurposeSummary } from "./purposes.js";
+/** One machine as `endia ps` and `endia compose ps` list it: what it is, which fleet and service it belongs to, what it runs, and its state, readiness and health as Hyper-V and its record give them now. */
+export interface MachineSummary {
+    /** The machine ID: the Hyper-V ID of its virtual machine, as a lower-case GUID with hyphens. */
+    readonly id: string;
+    /** The machine name, for example `classroom-server-1`. */
+    readonly name: string;
+    /** The name of the fleet the machine belongs to. */
+    readonly fleet: string;
+    /** The Compose service the machine runs. */
+    readonly service: string;
+    /** The machine's number among the replicas of its service, from 1. */
+    readonly index: number;
+    /** The image as the service names it, for example `lab/dotnet:10`. */
+    readonly image: string;
+    /** The digest of the image the machine was made from. */
+    readonly imageDigest: string;
+    /** The main process's command line, its words joined by spaces; empty when the machine has no main process. */
+    readonly command: string;
+    /** When the machine was created. */
+    readonly created: Timestamp;
+    /** The machine's state: `created`, `running`, `restarting`, `exited` or `removing`. */
+    readonly state: string;
+    /** The state in Docker's words, such as `Up 3 minutes (healthy)`, as `MachineStatusText` words it. */
+    readonly status: string;
+    /** The exit code of the machine's last stop, or null when none is recorded. */
+    readonly exitCode: number | null;
+    /** Whether the machine is ready: its virtual machine runs, it was configured in this boot, and nothing has failed since. */
+    readonly ready: boolean;
+    /** The machine's health: `none`, `starting`, `healthy` or `unhealthy`. */
+    readonly health: string;
+    /** The machine's ports published on the host. */
+    readonly ports: readonly PortBinding[];
+    /** What the machine is being used for: its own purpose, else its fleet's, else null. */
+    readonly purpose: PurposeSummary | null;
+    /** Where `purpose` comes from, or null when there is none. */
+    readonly purposeSource: PurposeSource | null;
+}
+/** One port of a machine published on the host: a program on the host that connects to `HostIp` and `Published` reaches `Target` inside the machine. */
+export interface PortBinding {
+    /** The host address the port listens on: `127.0.0.1`. */
+    readonly hostIp: string;
+    /** The port on the host. */
+    readonly published: number;
+    /** The TCP port inside the machine. */
+    readonly target: number;
+}
+/** One machine in full, as `endia inspect` prints it: the machine's record with what was created for it and what has happened to it since, and what its virtual machine and guest service report now: its addresses, its boot, and its desktop user. */
+export interface MachineDetail {
+    /** The machine ID: the Hyper-V ID of its virtual machine, as a lower-case GUID with hyphens. */
+    readonly id: string;
+    /** The machine name. */
+    readonly name: string;
+    /** The name of the fleet the machine belongs to. */
+    readonly fleet: string;
+    /** The Compose service the machine runs. */
+    readonly service: string;
+    /** The machine's number among the replicas of its service, from 1. */
+    readonly index: number;
+    /** The image as the service names it. */
+    readonly image: string;
+    /** The digest of the image the machine was made from. */
+    readonly imageDigest: string;
+    /** The service's resolved definition the machine was created with, as `compose config --format json` prints a service. */
+    readonly definition: unknown;
+    /** When the machine was created. */
+    readonly created: Timestamp;
+    /** The Windows computer name inside the machine. */
+    readonly computerName: string;
+    /** The most memory the machine may grow to, in bytes: its service's memory limit, or the configured ceiling when the service sets none. */
+    readonly memoryBytes: number;
+    /** The memory the machine starts with, in bytes. A machine whose record was written when machines had static memory starts with all of `memoryBytes`, and gives that figure here. */
+    readonly startupMemoryBytes: number;
+    /** The machine's number of virtual processors. */
+    readonly processors: number;
+    /** The machine's network cards. */
+    readonly cards: readonly MachineCardDetail[];
+    /** The named volumes attached to the machine. */
+    readonly volumes: readonly MachineVolumeDetail[];
+    /** The machine's ports published on the host. */
+    readonly ports: readonly PortBinding[];
+    /** The machine's state: `created`, `running`, `restarting`, `exited` or `removing`. */
+    readonly state: string;
+    /** Whether the machine is ready, as `MachineSummary.ready` says. When its image signs a user in by itself, ready also means that user was signed in with the desktop helper ready. */
+    readonly ready: boolean;
+    /** Whether a user stopped the machine, which the restart policy `unless-stopped` respects. */
+    readonly stoppedByUser: boolean;
+    /** How many times EastIndia has started the machine again under its restart policy. */
+    readonly restartCount: number;
+    /** When the machine last started, or null when it never has. */
+    readonly started: Timestamp | null;
+    /** When the machine last stopped, or null when it never has. */
+    readonly exited: Timestamp | null;
+    /** The exit code of the machine's last stop, or null when none is recorded. */
+    readonly exitCode: number | null;
+    /** The guest service's boot ID: from the guest service while the machine runs and answers, otherwise the one last recorded, or null. */
+    readonly bootId: string | null;
+    /** The boot ID of the boot in which the machine was last made ready, or null when it never was. The machine is ready while it runs, has no last error, and this ID equals the boot ID recorded for its current boot. */
+    readonly readyBootId: string | null;
+    /** The machine's main process as last recorded, or null when it has none or it has not started. */
+    readonly mainProcess: MainProcessDetail | null;
+    /** The machine's health checks: their status, failing streak and last results. */
+    readonly health: MachineHealthDetail;
+    /** The error that last stopped the machine or kept it from starting, or null. */
+    readonly lastError: ApiError | null;
+    /** The machine's IPv4 addresses by network: each fleet network's static address under the network's name, and the address Hyper-V reports for the `internet` card under `internet` while the machine runs. */
+    readonly addresses: Readonly<Record<string, string>>;
+    /** The account signed in on the machine's desktop, or null when none is or the guest service does not answer. */
+    readonly desktopUser: string | null;
+    /** Whether the desktop helper in that account's session has reported ready. */
+    readonly desktopReady: boolean;
+    /** Whether the elevation prompt can be automated, which is when `PromptOnSecureDesktop` is 0 in the machine; null while the guest service does not report that value. */
+    readonly uacPromptAutomation: boolean | null;
+    /** What the machine is being used for, in full: its own purpose, else its fleet's, else null. */
+    readonly purpose: PurposeDetail | null;
+    /** Where `purpose` comes from, or null when there is none. */
+    readonly purposeSource: PurposeSource | null;
+}
+/** One network card of a machine: the network and switch it is on, and the addresses it was given. */
+export interface MachineCardDetail {
+    /** The name of the fleet network the card is on, or `internet` for the card on the host's internet switch. */
+    readonly network: string;
+    /** The name of the Hyper-V switch the card is connected to. */
+    readonly switchName: string;
+    /** The card's MAC address. */
+    readonly macAddress: string;
+    /** The card's static IPv4 address on a fleet network, or null for the `internet` card, which takes its address by DHCP. */
+    readonly ipv4Address: string | null;
+}
+/** One named volume attached to a machine: where its disk is attached and where the guest service mounts it. */
+export interface MachineVolumeDetail {
+    /** The volume's name. */
+    readonly name: string;
+    /** The folder inside the machine where the volume is mounted, for example `C:\data`. */
+    readonly target: string;
+    /** Whether the volume is mounted read-only. */
+    readonly readOnly: boolean;
+    /** The location on SCSI controller 0 where the volume's disk is attached: 1 for the first volume, 2 for the next, and so on. */
+    readonly scsiLocation: number;
+}
+/** A machine's main process as last recorded: its process ID and start time, and once it has exited, its exit code and exit time. */
+export interface MainProcessDetail {
+    /** The process ID inside the machine. */
+    readonly pid: number;
+    /** When the process started. */
+    readonly started: Timestamp;
+    /** The process's exit code, or null while it runs. */
+    readonly exitCode: number | null;
+    /** When the process exited, or null while it runs. */
+    readonly exited: Timestamp | null;
+}
+/** A machine's health checks as `endia inspect` shows them: the status they have given it, how many have failed in a row, and the last results, so that a caller can see why a machine is unhealthy. */
+export interface MachineHealthDetail {
+    /** The status: `none`, `starting`, `healthy` or `unhealthy`. */
+    readonly status: string;
+    /** How many checks in a row have failed since the last success. */
+    readonly failingStreak: number;
+    /** The last five results at most, oldest first. */
+    readonly log: readonly HealthCheckRunDetail[];
+}
+/** One run of a machine's health check: when it ran, how it exited and what it printed. */
+export interface HealthCheckRunDetail {
+    /** When the check started. */
+    readonly start: Timestamp;
+    /** When the check ended. */
+    readonly end: Timestamp;
+    /** The check's exit code; 0 is a success. */
+    readonly exitCode: number;
+    /** What the check printed, cut to 4096 bytes. */
+    readonly output: string;
+}
+/** One line of a machine's main process output, as the log routes stream it, one JSON object per line of `application/x-ndjson`. A fleet's log route names the machine of each line; a machine's own log route does not. */
+export interface MachineLogLine {
+    /** The machine that wrote the line; present only in a fleet's log. */
+    readonly machine?: string | null;
+    /** When the line was written. */
+    readonly time: Timestamp;
+    /** The output the line came from: `stdout` or `stderr`. */
+    readonly stream: string;
+    /** The text of the line, without its line ending. */
+    readonly line: string;
+}
+/** The result of `endia start` and `endia stop`: the machines the operation acted on. */
+export interface MachinesResult {
+    /** The names of the machines started or stopped. */
+    readonly machines: readonly string[];
+}
+/** The result of `endia restart` for one machine: the boot it left, the boot it reached, and whether its virtual machine had to be turned off. */
+export interface MachineRestartResult {
+    /** The machine's name. */
+    readonly name: string;
+    /** The guest service's boot ID before the restart, or null when the machine was not running. */
+    readonly previousBootId: string | null;
+    /** The guest service's boot ID after the restart, which a restart that succeeds always has. */
+    readonly bootId: string;
+    /** Whether the virtual machine was turned off rather than Windows restarting in an orderly way. */
+    readonly turnedOff: boolean;
+}

package/dist/contract/machines.js

@@ -0,0 +1 @@
+export {};

package/dist/contract/operations.d.ts

@@ -0,0 +1,28 @@
+import type { ApiError, Timestamp } from "./common.js";
+/**
+ * Work the service carries out in the background because it takes seconds to hours and must survive the caller disconnecting:
+ * a build, an import, a fleet or machine change, or a prune.
+ *
+ * @typeParam TResult - The result the operation's kind gives when it succeeds.
+ */
+export interface Operation<TResult = unknown> {
+    /** 32 lower-case hexadecimal digits. */
+    readonly id: string;
+    /** What the operation does: `import`, `basePrepare`, `build`, `prune`, `fleetUp`, `fleetDown`, `fleetStop`, `fleetStart`, `fleetRestart`, `machineStart`, `machineStop` or `machineRestart`. */
+    readonly kind: string;
+    /** The image reference, fleet or machine the operation works on. */
+    readonly target: string;
+    /** `queued`, `running`, `cancelling`, or one of the final states `succeeded`, `failed`, `cancelled` and `interrupted`. */
+    readonly state: string;
+    /** The step the operation is on, such as `Step 2/5 : RUN setup.cmd`, or null. */
+    readonly step?: string | null;
+    readonly created: Timestamp;
+    readonly started?: Timestamp | null;
+    readonly finished?: Timestamp | null;
+    /** The name of the client certificate that started the operation. */
+    readonly caller: string;
+    /** The result, once the operation has succeeded; otherwise null. */
+    readonly result?: TResult | null;
+    /** Why the operation failed, was cancelled or was interrupted; otherwise null. */
+    readonly error?: ApiError | null;
+}

package/dist/contract/operations.js

@@ -0,0 +1 @@
+export {};

package/dist/contract/processes.d.ts

@@ -0,0 +1,75 @@
+import type { Timestamp, WindowBounds } from "./common.js";
+/** One process running in a machine, as `endia process ls` lists it, as `docker top` lists a container's processes. */
+export interface ProcessSummary {
+    /** The process ID. */
+    readonly processId: number;
+    /** The ID of the process that started it; that process may have ended since. */
+    readonly parentProcessId: number;
+    /** The Windows session it runs in: 0 for the background session, greater than 0 for the desktop user's. */
+    readonly sessionId: number;
+    /** The account it runs as, as `DOMAIN\name`, or null when Windows does not say. */
+    readonly user: string | null;
+    /** When it started, which `--started` takes to name it safely, or null when Windows does not say. */
+    readonly started: Timestamp | null;
+    /** The program's file name, for example `notepad.exe`. */
+    readonly name: string;
+}
+/** One process in full, as `endia process inspect` prints it: what it runs, as whom, whether it still runs, and its windows. A process that has ended is known only when EastIndia started it on the machine's current boot, and then only what EastIndia recorded when it started it: a member that is no longer known is null. */
+export interface ProcessDetail {
+    /** The process ID. */
+    readonly processId: number;
+    /** The ID of the process that started it, or null when it is not known. */
+    readonly parentProcessId: number | null;
+    /** The program's file name, or null when it is not known. */
+    readonly name: string | null;
+    /** The program's full path, or null when it is not known. */
+    readonly executablePath: string | null;
+    /** The command line, or null when it is not known. */
+    readonly commandLine: string | null;
+    /** When it started; `--started` takes this value to name the process safely. */
+    readonly started: Timestamp;
+    /** The Windows session it runs in: 0 for the background session, greater than 0 for the desktop user's. */
+    readonly sessionId: number;
+    /** The account it runs as, as `DOMAIN\name`, or null when it is not known. */
+    readonly user: string | null;
+    /** The integrity level of its token: `low`, `medium`, `high` or `system`; null when it is not known. */
+    readonly integrityLevel: string | null;
+    /** Whether it still runs. */
+    readonly running: boolean;
+    /** Its exit code once it has ended, when EastIndia started it on the current boot; otherwise null. */
+    readonly exitCode: number | null;
+    /** Its top-level windows; empty in the background session and once it has ended. */
+    readonly windows: readonly ProcessWindow[];
+}
+/** One top-level window of a process on the desktop user's screen. */
+export interface ProcessWindow {
+    /** The window handle as hexadecimal text, for example `0x2a0b4c`, which `desktop inspect --window` takes. */
+    readonly handle: string;
+    /** The title bar text; empty when the window has none. */
+    readonly title: string;
+    /** The window class name. */
+    readonly className: string;
+    /** Whether the window is shown. */
+    readonly visible: boolean;
+    /** Where the window is, in physical pixels from the top-left corner of the screen. */
+    readonly bounds: WindowBounds;
+}
+/** The answer to `endia process wait` once the process has ended, as `docker wait` answers. */
+export interface ProcessWaitResult {
+    /** The process's exit code, or null when Windows could not give it, as for a protected process. */
+    readonly exitCode: number | null;
+}
+/** The answer to `endia process stop`: how the process ended and its exit code. */
+export interface ProcessStopResult {
+    /** The process's exit code, or null when Windows could not give it. */
+    readonly exitCode: number | null;
+    /** How it ended: `closed`, `ended` or `alreadyExited`. */
+    readonly how: string;
+}
+/** One line of what a process started by `endia exec -d` wrote, as `process logs` streams it, one JSON object per line of `application/x-ndjson`. */
+export interface ProcessLogLine {
+    /** The output the line came from: `stdout` or `stderr`. */
+    readonly stream: string;
+    /** The text of the line, without its line ending. */
+    readonly line: string;
+}

package/dist/contract/processes.js

@@ -0,0 +1 @@
+export {};

package/dist/contract/purposes.d.ts

@@ -0,0 +1,62 @@
+import type { Timestamp } from "./common.js";
+/** Where the purpose in effect for a machine comes from: `machine`, its own purpose, or `fleet`, the purpose of its fleet because it has none of its own. */
+export type PurposeSource = "machine" | "fleet";
+/** A purpose without its detail, as the lists of fleets and machines carry it. */
+export interface PurposeSummary {
+    /** What the fleet or machine is being used for, in one line. */
+    readonly title: string;
+    /** The caller who stored the purpose: the client certificate's name over HTTPS, or `npipe:` followed by the Windows account. */
+    readonly setBy: string;
+    /** When the service stored the purpose. */
+    readonly set: Timestamp;
+}
+/** A whole purpose: what a caller said a fleet or machine is being used for, with the caller's notes. EastIndia stores and shows it and does nothing else with it. */
+export interface PurposeDetail extends PurposeSummary {
+    /** The caller's notes in Markdown, exactly as received, or null for none. A sandbox agent may have written them, so a program that renders them should fetch no remote image, open a link only when a person clicks it, and show raw HTML as text. */
+    readonly detail: string | null;
+}
+/** One change to the purpose of a fleet or machine. */
+export interface PurposeHistoryEntry {
+    /** When the service made the change. */
+    readonly time: Timestamp;
+    /** What the change did: `set`, when a caller stored a purpose whether or not one was stored before, or `cleared`, when a caller removed the purpose that was stored. */
+    readonly action: "set" | "cleared";
+    /** The title that was set, or null for a clearing. */
+    readonly title: string | null;
+    /** The detail that was set, or null for a clearing or a purpose set without detail. */
+    readonly detail: string | null;
+    /** The caller who made the change, named as `PurposeSummary.setBy` names callers. */
+    readonly setBy: string;
+}
+/** A fleet's purpose with every change to it while the fleet has existed: `endia purpose show`. */
+export interface FleetPurpose {
+    /** The fleet's purpose, or null when none is set. */
+    readonly purpose: PurposeDetail | null;
+    /** The changes, oldest first. */
+    readonly history: readonly PurposeHistoryEntry[];
+}
+/** A fleet's purpose once a change is stored. */
+export interface FleetPurposeResult {
+    /** The purpose just set, or null after a clearing. */
+    readonly purpose: PurposeDetail | null;
+}
+/** A machine's own purpose with every change to it, and the purpose in effect for the machine: `endia purpose show`. */
+export interface MachinePurpose {
+    /** The machine's own purpose, or null when it has none. */
+    readonly purpose: PurposeDetail | null;
+    /** The changes to the machine's own purpose, oldest first. Changes to its fleet's purpose are in the fleet's history. */
+    readonly history: readonly PurposeHistoryEntry[];
+    /** The machine's own purpose, else its fleet's, else null. */
+    readonly effective: PurposeDetail | null;
+    /** Where `effective` comes from, or null when no purpose is in effect. */
+    readonly purposeSource: PurposeSource | null;
+}
+/** A machine's own purpose once a change is stored, and the purpose in effect then. */
+export interface MachinePurposeResult {
+    /** The machine's own purpose just set, or null after a clearing. */
+    readonly purpose: PurposeDetail | null;
+    /** The machine's own purpose, else its fleet's, else null; after a clearing it is the fleet's. */
+    readonly effective: PurposeDetail | null;
+    /** Where `effective` comes from, or null when no purpose is in effect. */
+    readonly purposeSource: PurposeSource | null;
+}

package/dist/contract/purposes.js

@@ -0,0 +1 @@
+export {};

package/dist/contract/space.d.ts

@@ -0,0 +1,114 @@
+import type { Timestamp } from "./common.js";
+/** The answer to `endia system df`, as `docker system df` answers: what the images, machines, named volumes and build cache hold on disk, which of it is in use and which `system prune` would delete, and how much room the image folder's volume has left. */
+export interface DiskUsage {
+    /** Every image. */
+    readonly images: readonly ImageUsage[];
+    /** Every machine. */
+    readonly machines: readonly MachineUsage[];
+    /** Every named volume. */
+    readonly volumes: readonly VolumeUsage[];
+    /** Every build-cache entry. A service older than multi-stage builds leaves it out. */
+    readonly buildCache?: readonly BuildCacheUsage[];
+    /** The image folder's volume: its free space, its capacity and the space EastIndia keeps free on it. */
+    readonly imageFolder: ImageFolderSpace;
+    /** The storage root: what its records take and the free space on its volume. */
+    readonly storageRoot: StorageRootSpace;
+}
+/** One image as `system df` counts it. */
+export interface ImageUsage {
+    /** The image's digest. */
+    readonly id: string;
+    /** The tags that name the image; empty for an image without tags. */
+    readonly repoTags: readonly string[];
+    /** The digest of the image this image is built on, or null for an imported image, which has no parent. */
+    readonly parentId: string | null;
+    /** When the image was recorded. */
+    readonly created: Timestamp;
+    /** The size on disk of the image's own disk file, without its parents'. */
+    readonly sizeBytes: number;
+    /** The number of machines made from the image. */
+    readonly machines: number;
+    /** The number of images built on the image. */
+    readonly children: number;
+    /** Whether `system prune --all` would delete the image: no machine that a prune keeps uses it, nor is any image built on it. */
+    readonly reclaimable: boolean;
+}
+/** One machine as `system df` counts it: its writable disk, which holds what the machine changed since it was made from its image. */
+export interface MachineUsage {
+    /** The machine name. */
+    readonly name: string;
+    /** The machine's state; `system prune` deletes the machines in state `exited` or `created`. */
+    readonly state: string;
+    /** The size on disk of the machine's writable disk file; 0 when the file does not exist. */
+    readonly sizeBytes: number;
+}
+/** One named volume as `system df` counts it. */
+export interface VolumeUsage {
+    /** The volume name. */
+    readonly name: string;
+    /** The size on disk of the volume's disk file; 0 when the file does not exist. */
+    readonly sizeBytes: number;
+    /** The machine the volume is attached to, or null. */
+    readonly attachedTo: string | null;
+}
+/** One build-cache entry as `system df` counts it: the committed result of a recipe's stage that a build made below its target. It is not an image; a later build whose stage has the same build key reuses it. */
+export interface BuildCacheUsage {
+    /** The entry's digest. */
+    readonly id: string;
+    /** The digest of the image or build-cache entry the entry is built on. */
+    readonly parentId: string | null;
+    /** When a build made the entry. */
+    readonly created: Timestamp;
+    /** When a build last made or found the entry. */
+    readonly lastUsed: Timestamp;
+    /** The size on disk of the entry's own disk file. */
+    readonly sizeBytes: number;
+    /** Whether an image, machine or other entry is built on the entry, or a running build has made or found it. `system df` counts such entries as active. */
+    readonly inUse: boolean;
+    /** Whether `builder prune` would delete the entry. */
+    readonly reclaimable: boolean;
+}
+/** The room left on the image folder's volume, where every disk lives. */
+export interface ImageFolderSpace {
+    /** The image folder's full path. */
+    readonly path: string;
+    /** The free space on its volume. */
+    readonly freeBytes: number;
+    /** The capacity of its volume. */
+    readonly capacityBytes: number;
+    /** The space EastIndia keeps free on the volume: `minFreeDiskGiB`; a disk that would leave less is refused. */
+    readonly reserveBytes: number;
+}
+/** What the storage root takes and the room left on its volume. */
+export interface StorageRootSpace {
+    /** The storage root's full path. */
+    readonly path: string;
+    /** The size of the files under the storage root, leaving out the image folder when it lies there, whose disks the other rows count. */
+    readonly sizeBytes: number;
+    /** The free space on its volume. */
+    readonly freeBytes: number;
+}
+/** The result of a `system prune` operation: what it deleted and the space that freed. */
+export interface PruneResult {
+    /** The stopped machines deleted, by name; the next `compose up` of their fleets creates them again. */
+    readonly deletedMachines: readonly string[];
+    /** The images deleted, by digest. */
+    readonly deletedImages: readonly string[];
+    /** The build-cache entries deleted, by digest: the results of recipe stages below a build's target that nothing used. A service older than multi-stage builds leaves it out. */
+    readonly deletedBuildCache?: readonly string[];
+    /** The named volumes deleted, by name. */
+    readonly deletedVolumes: readonly string[];
+    /** The number of finished operations deleted, those older than `operationRetentionDays`. */
+    readonly deletedOperations: number;
+    /** The owned objects deleted whose owner no longer existed, each as its kind and name. */
+    readonly deletedOrphans: readonly string[];
+    /** The size of the files deleted. */
+    readonly reclaimedBytes: number;
+}
+/** The result of a `builder prune` operation: the build-cache entries it deleted and the space that freed. */
+export interface BuilderPruneResult {
+    /** The build-cache entries deleted, by digest, in the order deleted. */
+    readonly deletedBuildCache: readonly string[];
+    /** The size of the disk files deleted. */
+    readonly reclaimedBytes: number;
+}

package/dist/contract/space.js

@@ -0,0 +1 @@
+export {};

package/dist/contract/stats.d.ts

@@ -0,0 +1,58 @@
+import type { Timestamp } from "./common.js";
+/** One reading of the host, as `endia stats --host` shows it above the machines: its processor use, its memory, the memory EastIndia keeps free and the memory the running machines hold, so that one command shows how much room is left. */
+export interface HostStats {
+    /** When the reading was taken. */
+    readonly read: Timestamp;
+    /** The host's number of logical processors. */
+    readonly logicalProcessors: number;
+    /** The share of all the host's logical processors in use during the last interval, from 0 to 100; null when not taken. */
+    readonly cpuPercent: number | null;
+    /** The host's physical memory; null when not taken. */
+    readonly memoryTotalBytes: number | null;
+    /** The host's available memory; null when not taken. */
+    readonly memoryAvailableBytes: number | null;
+    /** The memory that must remain free after a virtual machine starts: `hostReserveMiB`. */
+    readonly memoryReserveBytes: number;
+    /** The memory that every running virtual machine EastIndia owns started with. */
+    readonly machinesMemoryBytes: number;
+    /** Each reading that is null, with the reason. */
+    readonly unavailable: readonly UnavailableReading[];
+}
+/** One reading of a machine, as `endia stats` shows it in a row, as `docker stats` shows a container's: processor use, memory, network and disk traffic and the number of processes. The hypervisor measures the processors, the cards and the disks from outside; the guest service reports memory in use and the processes from inside. */
+export interface MachineStats {
+    /** When the reading was taken. */
+    readonly read: Timestamp;
+    /** The machine ID. */
+    readonly id: string;
+    /** The machine name. */
+    readonly name: string;
+    /** The machine's state, as `endia ps` shows it. */
+    readonly state: string;
+    /** The machine's number of virtual processors. */
+    readonly processors: number;
+    /** The processor time the machine's virtual processors used during the last interval, as a percentage of one host logical processor, so that a machine keeping two processors busy shows 200, as Docker shows it on Linux; null when not taken. */
+    readonly cpuPercent: number | null;
+    /** The memory in use inside Windows (physical memory less available memory, as Task Manager counts it); null when not taken. */
+    readonly memoryUsageBytes: number | null;
+    /** The most memory the machine may grow to. */
+    readonly memoryLimitBytes: number;
+    /** The bytes all the machine's cards received since its virtual machine started; null when not taken. */
+    readonly networkReceivedBytes: number | null;
+    /** The bytes all the machine's cards sent since its virtual machine started; null when not taken. */
+    readonly networkSentBytes: number | null;
+    /** The bytes read from all the machine's disks since its virtual machine started; null when not taken. */
+    readonly diskReadBytes: number | null;
+    /** The bytes written to all the machine's disks since its virtual machine started; null when not taken. */
+    readonly diskWrittenBytes: number | null;
+    /** The number of processes in Windows; null when not taken. */
+    readonly processes: number | null;
+    /** Each reading that is null, with the reason. */
+    readonly unavailable: readonly UnavailableReading[];
+}
+/** A reading that could not be taken, and why. A reading is never shown as zero when it was not taken: its member is null and an entry of this kind names it. */
+export interface UnavailableReading {
+    /** The member that is null, for example `cpuPercent`. */
+    readonly reading: string;
+    /** Why, for example `A rate needs two samples; this is the first.` */
+    readonly reason: string;
+}

package/dist/contract/stats.js

@@ -0,0 +1 @@
+export {};