humanish 0.112.0 → 0.113.0

package/dist/substrates/local/runtime.d.ts

@@ -1,4 +1,5 @@
 import type { LocalFirecrackerAssets } from "./firecracker-desktop.js";
+import { type LocalCapacity, type VmSize } from "./capacity.js";
 import { type RuntimeHostOptions } from "./runtime-host.js";
 export interface LocalRuntimeRelease {
     url: string;
@@ -11,13 +12,22 @@ export interface LocalRuntimeStatus {
     installed: boolean;
     message: string;
     assets?: LocalFirecrackerAssets;
+    /** How many desktops fit, when the VM or this machine could be read. */
+    capacity?: LocalCapacity;
 }
 interface RuntimeOptions extends RuntimeHostOptions {
     media?: boolean;
+    /** The Lima VM size `runtime setup --memory --cpus` asks for. Macs only. */
+    size?: Partial<VmSize>;
     progress?: (message: string) => void;
     /** Explicit source-build/test override; never provided by a participant. */
     release?: LocalRuntimeRelease;
 }
+/**
+ * How many desktops the local runtime holds, read without starting anything. Undefined when the
+ * host cannot be read, such as a Mac without Lima: preparing the runtime reports that.
+ */
+export declare function localRuntimeCapacity(options?: RuntimeHostOptions): Promise<LocalCapacity | undefined>;
 /** Read-only host and cache inspection. Never pulls an image or starts a container. */
 export declare function localRuntimeStatus(options?: RuntimeOptions): Promise<LocalRuntimeStatus>;
 /** Docker owns the installed image/cache. The archive is verified before docker load. */

package/dist/substrates/local/runtime.js

@@ -6,30 +6,67 @@ import path from "node:path";
 import { Readable, Transform } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { LOCAL_MEDIA_RUNTIME_RELEASES, LOCAL_RUNTIME_RELEASES } from "./runtime-release.js";
+import { defaultVmSize, localCapacity, machineSize, } from "./capacity.js";
 import { limaStatus, loadRuntimeArchive, prepareLima, runtimeArchitecture, runtimeDocker, runtimeExec, usesLima, } from "./runtime-host.js";
 import { cli } from "../../cli/invocation.js";
 const docker = async (args, options) => (await runtimeDocker(args, options)).stdout.trim();
 const runtimeRelease = (options) => options.release ??
     (options.media ? LOCAL_MEDIA_RUNTIME_RELEASES : LOCAL_RUNTIME_RELEASES)[runtimeArchitecture(options) ?? "amd64"];
+/** Desktops the existing Lima VM holds, the VM setup would create, or this Linux machine. */
+function runtimeCapacity(options, lima) {
+    if (lima === undefined)
+        return localCapacity("linux-host", machineSize(options.machine));
+    const machine = machineSize(options.machine);
+    if (lima.size !== undefined)
+        return localCapacity("lima-vm", lima.size, { machine });
+    // An existing VM whose size Lima did not list has an unknown size, which no default replaces.
+    if (lima.exists)
+        return undefined;
+    const planned = defaultVmSize(machine);
+    return localCapacity("lima-vm", { memoryBytes: planned.memoryGiB * 1024 ** 3, cpus: planned.cpus }, { planned: true, machine });
+}
+/**
+ * How many desktops the local runtime holds, read without starting anything. Undefined when the
+ * host cannot be read, such as a Mac without Lima: preparing the runtime reports that.
+ */
+export async function localRuntimeCapacity(options = {}) {
+    if (runtimeArchitecture(options) === undefined)
+        return undefined;
+    if (!usesLima(options))
+        return runtimeCapacity(options, undefined);
+    try {
+        return runtimeCapacity(options, await limaStatus(options));
+    }
+    catch {
+        return undefined;
+    }
+}
 /** Read-only host and cache inspection. Never pulls an image or starts a container. */
 export async function localRuntimeStatus(options = {}) {
-    const architecture = runtimeArchitecture(options), lima = usesLima(options);
+    const architecture = runtimeArchitecture(options);
     if (!architecture)
         return {
             ok: false,
             installed: false,
             message: "Local browsers need Linux x64 or an M3-or-newer Mac with Lima.",
         };
-    if (lima) {
+    let lima;
+    if (usesLima(options)) {
         try {
-            const status = await limaStatus(options);
-            if (!status.ready)
-                return { ok: true, installed: false, message: status.message };
+            lima = await limaStatus(options);
         }
         catch (error) {
             return { ok: false, installed: false, message: error.message };
         }
     }
+    const capacity = runtimeCapacity(options, lima);
+    const sized = capacity === undefined ? {} : { capacity };
+    if (lima !== undefined && !lima.ready)
+        return { ok: true, installed: false, message: lima.message, ...sized };
+    return { ...(await engineStatus(options, architecture, lima !== undefined)), ...sized };
+}
+/** The Docker engine, devices and cached image the desktops run on. */
+async function engineStatus(options, architecture, lima) {
     const env = options.env ?? process.env;
     if (!lima && env.DOCKER_HOST && !env.DOCKER_HOST.startsWith("unix://")) {
         return {
@@ -142,6 +179,8 @@ export async function localRuntimeStatus(options = {}) {
 export async function prepareLocalRuntime(options = {}) {
     if (!runtimeArchitecture(options))
         throw new Error((await localRuntimeStatus(options)).message);
+    if (options.size !== undefined && !usesLima(options))
+        throw new Error("--memory and --cpus size the humanish Lima VM, which runs only on a Mac. On Linux, desktops use this machine's memory and CPUs directly.");
     if (usesLima(options))
         await prepareLima(options, options.progress);
     const before = await localRuntimeStatus(options);