@zgeoff/imp-client 0.18.0 → 0.19.0

package/dist/index.d.ts

@@ -4614,9 +4614,208 @@ declare const impContract: {
         xfs: "xfs";
         zfs: "zfs";
       }>>;
+      target: z.ZodOptional<z.ZodObject<{
+        firecrackerVersion: z.ZodString;
+        snapshotVersion: z.ZodString;
+        hostKernel: z.ZodString;
+        cpuModel: z.ZodString;
+        cpuFlags: z.ZodString;
+        dataDir: z.ZodString;
+        storage: z.ZodEnum<{
+          xfs: "xfs";
+          zfs: "zfs";
+        }>;
+        subnet: z.ZodString;
+        slotCount: z.ZodInt;
+        brokerPort: z.ZodInt;
+        dns: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+      }, z.core.$strip>>;
     }, z.core.$strip>, z.ZodObject<{
       bytes: z.ZodInt;
       checkpoints: z.ZodInt;
+      warm: z.ZodNullable<z.ZodObject<{
+        slot: z.ZodInt;
+        egressMode: z.ZodString;
+        snapshot: z.ZodObject<{
+          firecrackerVersion: z.ZodString;
+          snapshotVersion: z.ZodString;
+          hostKernel: z.ZodString;
+          cpuModel: z.ZodNullable<z.ZodString>;
+          cpuFlags: z.ZodNullable<z.ZodString>;
+          ipv6Prefix: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+        host: z.ZodObject<{
+          dataDir: z.ZodString;
+          storage: z.ZodEnum<{
+            xfs: "xfs";
+            zfs: "zfs";
+          }>;
+          subnet: z.ZodString;
+          brokerPort: z.ZodInt;
+          dns: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+      NOT_FOUND: {
+        readonly message: "Not found";
+        readonly data: z.ZodObject<{
+          kind: z.ZodEnum<{
+            backup: "backup";
+            checkpoint: "checkpoint";
+            grant: "grant";
+            image: "image";
+            imp: "imp";
+            network: "network";
+            secret: "secret";
+            service: "service";
+            session: "session";
+            "ssh-key": "ssh-key";
+            token: "token";
+          }>;
+          name: z.ZodString;
+        }, z.core.$strip>;
+      };
+      CONFLICT: {
+        readonly message: "Already exists";
+        readonly data: z.ZodObject<{
+          kind: z.ZodEnum<{
+            backup: "backup";
+            checkpoint: "checkpoint";
+            grant: "grant";
+            image: "image";
+            imp: "imp";
+            network: "network";
+            secret: "secret";
+            service: "service";
+            session: "session";
+            "ssh-key": "ssh-key";
+            token: "token";
+          }>;
+          name: z.ZodString;
+        }, z.core.$strip>;
+      };
+      FORBIDDEN: {
+        readonly message: "Not allowed";
+      };
+      PRECONDITION_FAILED: {
+        readonly message: "Not possible on this host";
+      };
+      RAM_BUDGET_EXCEEDED: {
+        readonly message: "Not enough RAM budget, even after sleeping idle imps";
+        readonly status: 503;
+        readonly data: z.ZodObject<{
+          budgetMib: z.ZodInt;
+          usedMib: z.ZodInt;
+          requestedMib: z.ZodInt;
+          neededMib: z.ZodOptional<z.ZodInt>;
+          protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            ramMib: z.ZodInt;
+            leased: z.ZodBoolean;
+            busy: z.ZodBoolean;
+          }, z.core.$strip>>>>;
+          protectedHidden: z.ZodOptional<z.ZodInt>;
+        }, z.core.$strip>;
+      };
+      SERVICE_UNAVAILABLE: {
+        readonly message: "impd is stopping";
+      };
+      INVALID_STATE: {
+        readonly message: "The imp is not in a state that allows this";
+        readonly status: 409;
+        readonly data: z.ZodObject<{
+          state: z.ZodEnum<{
+            creating: "creating";
+            error: "error";
+            running: "running";
+            sleeping: "sleeping";
+            stopped: "stopped";
+          }>;
+          allowed: z.ZodArray<z.ZodEnum<{
+            creating: "creating";
+            error: "error";
+            running: "running";
+            sleeping: "sleeping";
+            stopped: "stopped";
+          }>>;
+          coldBoots: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            bootId: z.ZodString;
+            cause: z.ZodEnum<{
+              recovery: "recovery";
+              restore: "restore";
+              start: "start";
+              unknown: "unknown";
+              wake_fallback: "wake_fallback";
+              watchdog: "watchdog";
+            }>;
+            at: z.ZodISODateTime;
+          }, z.core.$strip>>>>>;
+        }, z.core.$strip>;
+      };
+      INVALID_RESUME: {
+        readonly message: "The resume offset is past the end of the output";
+        readonly status: 409;
+        readonly data: z.ZodReadonly<z.ZodObject<{
+          end: z.ZodInt;
+          bufferStart: z.ZodInt;
+        }, z.core.$strip>>;
+      };
+      DISK_FULL: {
+        readonly message: "Not enough free disk on the host";
+        readonly status: 507;
+        readonly data: z.ZodObject<{
+          availableBytes: z.ZodInt;
+          reserveBytes: z.ZodInt;
+          requestedBytes: z.ZodInt;
+        }, z.core.$strip>;
+      };
+      LEASED: {
+        readonly message: "The imp is leased";
+        readonly status: 409;
+        readonly data: z.ZodObject<{
+          leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            owner: z.ZodObject<{
+              principal: z.ZodString;
+              display: z.ZodString;
+              label: z.ZodString;
+            }, z.core.$strip>;
+            until: z.ZodNullable<z.ZodDate>;
+          }, z.core.$strip>>>;
+          otherCount: z.ZodInt;
+        }, z.core.$strip>;
+      };
+      LEASE_NOT_HELD: {
+        readonly message: "The caller holds no such lease";
+        readonly status: 409;
+      };
+      AGENT_OUTDATED: {
+        readonly message: "The imp's agent is too old for this";
+        readonly status: 409;
+      };
+      MOVING: {
+        readonly message: "The imp is moving between hosts";
+        readonly status: 409;
+        readonly data: z.ZodObject<{
+          retryAfterS: z.ZodInt;
+        }, z.core.$strip>;
+      };
+    }>, Record<never, never>>;
+    facts: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, z.ZodObject<{
+      firecrackerVersion: z.ZodString;
+      snapshotVersion: z.ZodString;
+      hostKernel: z.ZodString;
+      cpuModel: z.ZodString;
+      cpuFlags: z.ZodString;
+      dataDir: z.ZodString;
+      storage: z.ZodEnum<{
+        xfs: "xfs";
+        zfs: "zfs";
+      }>;
+      subnet: z.ZodString;
+      slotCount: z.ZodInt;
+      brokerPort: z.ZodInt;
+      dns: z.ZodReadonly<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
       NOT_FOUND: {
         readonly message: "Not found";
@@ -4766,6 +4965,28 @@ declare const impContract: {
     receive: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
       name: z.ZodString;
       bytes: z.ZodInt;
+      warm: z.ZodOptional<z.ZodObject<{
+        slot: z.ZodInt;
+        egressMode: z.ZodString;
+        snapshot: z.ZodObject<{
+          firecrackerVersion: z.ZodString;
+          snapshotVersion: z.ZodString;
+          hostKernel: z.ZodString;
+          cpuModel: z.ZodNullable<z.ZodString>;
+          cpuFlags: z.ZodNullable<z.ZodString>;
+          ipv6Prefix: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+        host: z.ZodObject<{
+          dataDir: z.ZodString;
+          storage: z.ZodEnum<{
+            xfs: "xfs";
+            zfs: "zfs";
+          }>;
+          subnet: z.ZodString;
+          brokerPort: z.ZodInt;
+          dns: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>;
+      }, z.core.$strip>>;
     }, z.core.$strip>, z.ZodObject<{
       ticket: z.ZodString;
       expiresAt: z.ZodDate;

package/dist/index.js

@@ -3,7 +3,7 @@ import { RPCLink } from "@orpc/client/fetch";
 import * as z from "zod";
 //#endregion
 //#region src/check-server.ts
-const CLIENT_VERSION = "0.18.0";
+const CLIENT_VERSION = "0.19.0";
 async function checkServer(rpc) {
 	const info = await rpc.system.info();
 	return {
@@ -74,9 +74,42 @@ const MoveStateSchema = z.enum([
 	"receiving"
 ]);
 const PeerUrlSchema = z.url({ protocol: /^https?$/ });
+const WarmHostSchema = z.object({
+	firecrackerVersion: z.string(),
+	snapshotVersion: z.string(),
+	hostKernel: z.string(),
+	cpuModel: z.string(),
+	cpuFlags: z.string(),
+	dataDir: z.string(),
+	storage: z.enum(["xfs", "zfs"]),
+	subnet: z.string(),
+	slotCount: z.int().positive(),
+	brokerPort: z.int().positive(),
+	dns: z.array(z.string()).readonly()
+});
+const WarmMoveSchema = z.object({
+	slot: z.int().nonnegative(),
+	egressMode: z.string(),
+	snapshot: z.object({
+		firecrackerVersion: z.string(),
+		snapshotVersion: z.string(),
+		hostKernel: z.string(),
+		cpuModel: z.string().nullable(),
+		cpuFlags: z.string().nullable(),
+		ipv6Prefix: z.string().nullable()
+	}),
+	host: WarmHostSchema.pick({
+		dataDir: true,
+		storage: true,
+		subnet: true,
+		brokerPort: true,
+		dns: true
+	})
+});
 z.object({
 	bytes: z.int().nonnegative(),
-	checkpoints: z.int().nonnegative()
+	checkpoints: z.int().nonnegative(),
+	warm: WarmMoveSchema.nullable()
 });
 z.object({
 	ticket: z.string(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zgeoff/imp-client",
-  "version": "0.18.0",
+  "version": "0.19.0",
   "description": "Typed client for impd, the imp host daemon: imps, checkpoints, images and exec",
   "license": "MIT",
   "repository": {