@moldesk/core 0.0.1 → 0.0.2

package/dist/compatibility.test.js

@@ -0,0 +1,362 @@
+import { describe, expect, it } from "vitest";
+import { evaluateCompatibility, shortReason } from "./compatibility.js";
+const GB = 1024 ** 3;
+function baseReport(overrides = {}) {
+    return {
+        capturedAt: "2026-01-01T00:00:00.000Z",
+        platform: "linux",
+        arch: "x64",
+        cpu: { model: "Test CPU", logicalCores: 8 },
+        memory: { totalBytes: 32 * GB },
+        disk: { availableBytes: 200 * GB, path: "/tmp/moldesk-test" },
+        appleSilicon: false,
+        hostPython: { available: false, error: "no python" },
+        docker: { available: true, running: true, version: "24.0.7", gpuAccess: "available" },
+        nvidia: {
+            available: true,
+            driverVersion: "550.54.15",
+            driverCudaVersion: "12.4",
+            gpus: [{ index: 0, name: "NVIDIA A100", totalVramBytes: 80 * GB }],
+        },
+        ...overrides,
+    };
+}
+function baseManifest(overrides = {}) {
+    return {
+        schemaVersion: 1,
+        name: "proteinmpnn",
+        displayName: "ProteinMPNN",
+        modelVersion: "v_48_020",
+        adapterVersion: "0.1.0",
+        description: "test",
+        category: "sequence-design",
+        status: "available",
+        runtimes: [{ kind: "python", python: "3.11", installer: "uv", requirements: [{ name: "torch", version: "2.2.1" }] }],
+        hardware: { platforms: ["darwin-arm64", "linux-x64"] },
+        input: { formats: [".pdb"], required: true },
+        outputs: [{ id: "sequences", glob: "*.fa", required: true }],
+        ...overrides,
+    };
+}
+describe("evaluateCompatibility", () => {
+    it("macOS ARM64 CPU: python model compatible without host python or GPU", () => {
+        const report = baseReport({
+            platform: "darwin",
+            arch: "arm64",
+            appleSilicon: true,
+            nvidia: { available: false, gpus: [], error: "no gpu" },
+            docker: { available: false, running: false, gpuAccess: "unknown" },
+        });
+        const result = evaluateCompatibility(baseManifest(), report);
+        expect(result.status).toBe("compatible");
+        expect(result.selectedRuntime).toBe("python");
+    });
+    it("Linux CPU-only: CUDA-recommended model yields warning, not unsupported", () => {
+        const manifest = baseManifest({
+            hardware: { platforms: ["linux-x64"], nvidiaGpu: "recommended", cuda: { level: "recommended" } },
+        });
+        const report = baseReport({
+            platform: "linux",
+            arch: "x64",
+            nvidia: { available: false, gpus: [], error: "no gpu" },
+        });
+        const result = evaluateCompatibility(manifest, report);
+        expect(result.status).toBe("warning");
+        expect(result.selectedRuntime).toBe("python");
+        expect(result.reasons.some((r) => r.code === "CUDA_NOT_DETECTED")).toBe(true);
+    });
+    it("Linux NVIDIA CUDA: CUDA-required models compatible", () => {
+        const manifest = baseManifest({
+            hardware: {
+                platforms: ["linux-x64"],
+                nvidiaGpu: "required",
+                minVramGb: 16,
+                cuda: { level: "required" },
+            },
+        });
+        const result = evaluateCompatibility(manifest, baseReport());
+        expect(result.status).toBe("compatible");
+    });
+    it("insufficient VRAM is unsupported with INSUFFICIENT_VRAM", () => {
+        const manifest = baseManifest({
+            hardware: { platforms: ["linux-x64"], nvidiaGpu: "required", minVramGb: 160 },
+        });
+        const result = evaluateCompatibility(manifest, baseReport());
+        expect(result.status).toBe("unsupported");
+        expect(result.reasons.some((r) => r.code === "INSUFFICIENT_VRAM")).toBe(true);
+        expect(shortReason(result)).toMatch(/INSUFFICIENT_VRAM/);
+    });
+    it("missing Docker: docker-only model unsupported with DOCKER_NOT_INSTALLED", () => {
+        const manifest = baseManifest({
+            runtimes: [{ kind: "docker", image: "example/model:latest", digest: `sha256:${"a".repeat(64)}`, gpu: "none" }],
+        });
+        const report = baseReport({ docker: { available: false, running: false, gpuAccess: "unknown" } });
+        const result = evaluateCompatibility(manifest, report);
+        expect(result.status).toBe("unsupported");
+        expect(result.reasons.some((r) => r.code === "DOCKER_NOT_INSTALLED")).toBe(true);
+    });
+    it("stopped Docker daemon: DOCKER_NOT_RUNNING", () => {
+        const manifest = baseManifest({
+            runtimes: [{ kind: "docker", image: "example/model:latest", digest: `sha256:${"a".repeat(64)}`, gpu: "none" }],
+        });
+        const report = baseReport({
+            docker: { available: true, running: false, gpuAccess: "unknown", error: "daemon not running" },
+        });
+        const result = evaluateCompatibility(manifest, report);
+        expect(result.status).toBe("unsupported");
+        expect(result.reasons.some((r) => r.code === "DOCKER_NOT_RUNNING")).toBe(true);
+    });
+    it("insufficient RAM/disk flagged with stable codes", () => {
+        const manifest = baseManifest({
+            hardware: { platforms: ["linux-x64"], minRamGb: 64, minDiskGb: 500 },
+        });
+        const result = evaluateCompatibility(manifest, baseReport());
+        expect(result.status).toBe("unsupported");
+        const codes = result.reasons.map((r) => r.code);
+        expect(codes).toContain("INSUFFICIENT_RAM");
+        expect(codes).toContain("DISK_SPACE_LOW");
+    });
+    it("unknown probe output never counts as present", () => {
+        const manifest = baseManifest({
+            hardware: { platforms: ["linux-x64"], nvidiaGpu: "required", cuda: { level: "required" }, minVramGb: 8 },
+        });
+        const report = baseReport({
+            platform: "unknown",
+            arch: "unknown",
+            nvidia: { available: false, gpus: [], error: "probe failed" },
+        });
+        const result = evaluateCompatibility(manifest, report);
+        expect(result.status).toBe("unsupported");
+        expect(result.reasons.some((r) => r.code === "CUDA_NOT_DETECTED")).toBe(true);
+    });
+    it("planned models cannot be installed even on compatible hardware", () => {
+        const result = evaluateCompatibility(baseManifest({ status: "planned" }), baseReport());
+        expect(result.status).toBe("unsupported");
+        expect(result.selectedRuntime).toBeUndefined();
+        expect(result.reasons[0]?.code).toBe("MODEL_PLANNED");
+    });
+    it("requestedRuntime constrains selection without silent fallback", () => {
+        const manifest = baseManifest({
+            runtimes: [
+                { kind: "python", python: "3.11", installer: "uv", requirements: [{ name: "torch", version: "1.0" }] },
+                { kind: "docker", image: "example/m:latest", digest: `sha256:${"b".repeat(64)}`, gpu: "none" },
+            ],
+        });
+        const report = baseReport({ docker: { available: false, running: false, gpuAccess: "unknown" } });
+        const dockerOnly = evaluateCompatibility(manifest, report, { requestedRuntime: "docker" });
+        expect(dockerOnly.status).toBe("unsupported");
+        expect(dockerOnly.selectedRuntime).toBeUndefined();
+        const pythonOnly = evaluateCompatibility(manifest, report, { requestedRuntime: "python" });
+        expect(pythonOnly.status).toBe("compatible");
+        expect(pythonOnly.selectedRuntime).toBe("python");
+    });
+    it("does not reject managed python when host python missing", () => {
+        const report = baseReport({ hostPython: { available: false, error: "absent" } });
+        const result = evaluateCompatibility(baseManifest(), report);
+        expect(result.status).toBe("compatible");
+    });
+    it("managed python unsupported on unknown platform", () => {
+        const report = baseReport({ platform: "unknown", arch: "mips" });
+        const result = evaluateCompatibility(baseManifest(), report);
+        expect(result.status).toBe("unsupported");
+        expect(result.reasons.some((r) => r.code === "MANAGED_PYTHON_PLATFORM_UNSUPPORTED")).toBe(true);
+    });
+    it("prefers fully compatible runtime over earlier warning", () => {
+        const manifest = baseManifest({
+            runtimes: [
+                { kind: "python", python: "3.11", installer: "uv", requirements: [{ name: "torch", version: "1.0" }] },
+                { kind: "docker", image: "example/m:latest", digest: `sha256:${"c".repeat(64)}`, gpu: "none" },
+            ],
+            hardware: { platforms: ["linux-x64"], nvidiaGpu: "recommended" },
+        });
+        // No GPU: python warns, docker... also warns via optional? make docker gpu none -> clean except shared warning.
+        // Both warn; first warning wins deterministically.
+        const report = baseReport({
+            nvidia: { available: false, gpus: [], error: "no gpu" },
+            docker: { available: true, running: true, gpuAccess: "available" },
+        });
+        const result = evaluateCompatibility(manifest, report);
+        expect(result.status).toBe("warning");
+        expect(result.selectedRuntime).toBe("python");
+    });
+    it("minVramGb downgrades to a warning when nvidiaGpu is merely recommended (CPU fallback preserved)", () => {
+        const manifest = baseManifest({
+            hardware: { platforms: ["linux-x64"], nvidiaGpu: "recommended", minVramGb: 160 },
+        });
+        const result = evaluateCompatibility(manifest, baseReport());
+        expect(result.status).toBe("warning");
+        expect(result.reasons.some((r) => r.code === "INSUFFICIENT_VRAM" && r.severity === "warning")).toBe(true);
+    });
+    it("minVramGb stays a hard error when nvidiaGpu is required", () => {
+        const manifest = baseManifest({
+            hardware: { platforms: ["linux-x64"], nvidiaGpu: "required", minVramGb: 160 },
+        });
+        const result = evaluateCompatibility(manifest, baseReport());
+        expect(result.status).toBe("unsupported");
+        expect(result.reasons.some((r) => r.code === "INSUFFICIENT_VRAM" && r.severity === "error")).toBe(true);
+    });
+    it("rejects an insufficient cuda.minDriverCudaVersion with CUDA_VERSION_UNSUPPORTED", () => {
+        const manifest = baseManifest({
+            hardware: {
+                platforms: ["linux-x64"],
+                nvidiaGpu: "required",
+                cuda: { level: "required", minDriverCudaVersion: "12.6" },
+            },
+        });
+        const result = evaluateCompatibility(manifest, baseReport()); // report has driverCudaVersion "12.4"
+        expect(result.status).toBe("unsupported");
+        expect(result.reasons.some((r) => r.code === "CUDA_VERSION_UNSUPPORTED")).toBe(true);
+    });
+    it("accepts a sufficient cuda.minDriverCudaVersion", () => {
+        const manifest = baseManifest({
+            hardware: {
+                platforms: ["linux-x64"],
+                nvidiaGpu: "required",
+                cuda: { level: "required", minDriverCudaVersion: "12.1" },
+            },
+        });
+        const result = evaluateCompatibility(manifest, baseReport());
+        expect(result.status).toBe("compatible");
+    });
+    it("rejects an unsupported managed Python version", () => {
+        const manifest = baseManifest({
+            runtimes: [{ kind: "python", python: "3.8", installer: "uv", requirements: [{ name: "torch", version: "2.2.1" }] }],
+        });
+        const result = evaluateCompatibility(manifest, baseReport());
+        expect(result.status).toBe("unsupported");
+        expect(result.reasons.some((r) => r.code === "MANAGED_PYTHON_VERSION_UNSUPPORTED")).toBe(true);
+    });
+    it("docker GPU required + never verified (Tier 1 'unknown') yields DOCKER_GPU_UNVERIFIED, not UNAVAILABLE", () => {
+        const manifest = baseManifest({
+            runtimes: [{ kind: "docker", image: "example/m:latest", digest: `sha256:${"d".repeat(64)}`, gpu: "required" }],
+        });
+        const report = baseReport({ docker: { available: true, running: true, gpuAccess: "unknown" } });
+        const result = evaluateCompatibility(manifest, report);
+        expect(result.status).toBe("unsupported");
+        expect(result.reasons.some((r) => r.code === "DOCKER_GPU_UNVERIFIED")).toBe(true);
+    });
+    it("docker GPU required + Tier 1/2 confirmed unavailable yields DOCKER_GPU_UNAVAILABLE", () => {
+        const manifest = baseManifest({
+            runtimes: [{ kind: "docker", image: "example/m:latest", digest: `sha256:${"e".repeat(64)}`, gpu: "required" }],
+        });
+        const report = baseReport({ docker: { available: true, running: true, gpuAccess: "unavailable" } });
+        const result = evaluateCompatibility(manifest, report);
+        expect(result.status).toBe("unsupported");
+        expect(result.reasons.some((r) => r.code === "DOCKER_GPU_UNAVAILABLE")).toBe(true);
+    });
+    it("docker GPU access does not consult local nvidia.available — a remote daemon with GPU access stays compatible", () => {
+        const manifest = baseManifest({
+            runtimes: [{ kind: "docker", image: "example/m:latest", digest: `sha256:${"f".repeat(64)}`, gpu: "required" }],
+        });
+        const report = baseReport({
+            nvidia: { available: false, gpus: [], error: "no local gpu" },
+            docker: { available: true, running: true, gpuAccess: "available" },
+        });
+        const result = evaluateCompatibility(manifest, report);
+        expect(result.status).toBe("compatible");
+        expect(result.selectedRuntime).toBe("docker");
+    });
+    it("populates a per-runtime breakdown (not just candidate 0) when every candidate is unsupported for different reasons", () => {
+        const manifest = baseManifest({
+            runtimes: [
+                { kind: "python", python: "3.8", installer: "uv", requirements: [{ name: "torch", version: "1.0" }] },
+                { kind: "docker", image: "example/m:latest", digest: `sha256:${"1".repeat(64)}`, gpu: "required" },
+            ],
+        });
+        const report = baseReport({ docker: { available: true, running: true, gpuAccess: "unavailable" } });
+        const result = evaluateCompatibility(manifest, report);
+        expect(result.status).toBe("unsupported");
+        expect(result.runtimes).toHaveLength(2);
+        expect(result.runtimes.find((r) => r.kind === "python")?.reasons.some((r) => r.code === "MANAGED_PYTHON_VERSION_UNSUPPORTED")).toBe(true);
+        expect(result.runtimes.find((r) => r.kind === "docker")?.reasons.some((r) => r.code === "DOCKER_GPU_UNAVAILABLE")).toBe(true);
+        const codes = result.reasons.map((r) => r.code);
+        expect(codes).toContain("MANAGED_PYTHON_VERSION_UNSUPPORTED");
+        expect(codes).toContain("DOCKER_GPU_UNAVAILABLE");
+    });
+    it("every registry-style model returns exactly one result", () => {
+        for (const status of ["available", "beta", "planned"]) {
+            const result = evaluateCompatibility(baseManifest({ status }), baseReport());
+            expect(["compatible", "warning", "unsupported"]).toContain(result.status);
+            expect(Array.isArray(result.reasons)).toBe(true);
+        }
+    });
+});
+describe("per-platform accelerator resolution", () => {
+    /** A single manifest whose two python runtime entries declare genuinely different
+     * accelerator requirements: CUDA-required on linux-x64 (the "official" runtime),
+     * no CUDA/GPU requirement on darwin-arm64 (an MPS-style runtime) — mirroring a
+     * future Boltz-style dual-runtime manifest. */
+    function dualAcceleratorManifest() {
+        return baseManifest({
+            hardware: { platforms: ["darwin-arm64", "linux-x64"] }, // no manifest-wide accelerator signal
+            runtimes: [
+                {
+                    kind: "python",
+                    python: "3.11",
+                    installer: "uv",
+                    platforms: ["darwin-arm64"],
+                    nvidiaGpu: "unsupported",
+                    requirements: [{ name: "torch", version: "2.6.0" }],
+                },
+                {
+                    kind: "python",
+                    python: "3.11",
+                    installer: "uv",
+                    platforms: ["linux-x64"],
+                    nvidiaGpu: "required",
+                    cuda: { level: "required", minDriverCudaVersion: "12.1" },
+                    minVramGb: 16,
+                    requirements: [{ name: "torch", version: "2.2.1" }],
+                },
+            ],
+        });
+    }
+    it("reports MPS-style (no CUDA requirement) compatibility on a simulated darwin-arm64 host, even with no GPU", () => {
+        const manifest = dualAcceleratorManifest();
+        const report = baseReport({
+            platform: "darwin",
+            arch: "arm64",
+            appleSilicon: true,
+            nvidia: { available: false, gpus: [], error: "no gpu" },
+            docker: { available: false, running: false, gpuAccess: "unknown" },
+        });
+        const result = evaluateCompatibility(manifest, report);
+        expect(result.status).toBe("compatible");
+        expect(result.reasons.some((r) => r.code === "CUDA_NOT_DETECTED")).toBe(false);
+        expect(result.reasons.some((r) => r.code === "NVIDIA_GPU_REQUIRED")).toBe(false);
+    });
+    it("reports CUDA-required compatibility (or its absence as an error) on a simulated linux-x64 host, for the same manifest", () => {
+        const manifest = dualAcceleratorManifest();
+        const cudaReport = baseReport({ platform: "linux", arch: "x64" }); // has CUDA + 80GB VRAM per baseReport()
+        const compatible = evaluateCompatibility(manifest, cudaReport);
+        expect(compatible.status).toBe("compatible");
+        const noGpuReport = baseReport({
+            platform: "linux",
+            arch: "x64",
+            nvidia: { available: false, gpus: [], error: "no gpu" },
+        });
+        const unsupported = evaluateCompatibility(manifest, noGpuReport);
+        expect(unsupported.status).toBe("unsupported");
+        const codes = unsupported.reasons.map((r) => r.code);
+        expect(codes).toContain("NVIDIA_GPU_REQUIRED");
+        expect(codes).toContain("CUDA_NOT_DETECTED");
+    });
+    it("differs correctly between darwin-arm64 and linux-x64 for the identical manifest object (proves per-platform-entry resolution, not manifest-wide)", () => {
+        const manifest = dualAcceleratorManifest();
+        const darwinReport = baseReport({
+            platform: "darwin",
+            arch: "arm64",
+            appleSilicon: true,
+            nvidia: { available: false, gpus: [], error: "no gpu" },
+            docker: { available: false, running: false, gpuAccess: "unknown" },
+        });
+        const linuxReport = baseReport({ platform: "linux", arch: "x64" });
+        const darwinResult = evaluateCompatibility(manifest, darwinReport);
+        const linuxResult = evaluateCompatibility(manifest, linuxReport);
+        expect(darwinResult.status).toBe("compatible");
+        expect(linuxResult.status).toBe("compatible");
+        // Neither host's evaluation should carry the other platform's accelerator
+        // reasons — each host only ever evaluates its own matching runtime entry.
+        expect(darwinResult.reasons.some((r) => r.code.includes("CUDA"))).toBe(false);
+    });
+});

package/dist/errors.d.ts

@@ -0,0 +1,2 @@
+export { MoldeskError } from "@moldesk/registry";
+export type { MoldeskErrorData } from "@moldesk/registry";

package/dist/errors.js

@@ -0,0 +1 @@
+export { MoldeskError } from "@moldesk/registry";

package/dist/errors.test.d.ts

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

package/dist/errors.test.js

@@ -0,0 +1,16 @@
+import { describe, expect, it } from "vitest";
+import { MoldeskError } from "./errors.js";
+describe("MoldeskError", () => {
+    it("carries code, message, remediation, and details", () => {
+        const error = new MoldeskError({
+            code: "DEMO_CODE",
+            message: "demo failure",
+            remediation: "do the thing",
+            details: { hello: "world" },
+        });
+        expect(error).toBeInstanceOf(Error);
+        expect(error.code).toBe("DEMO_CODE");
+        expect(error.remediation).toBe("do the thing");
+        expect(error.details).toEqual({ hello: "world" });
+    });
+});

package/dist/hash.d.ts

@@ -0,0 +1,4 @@
+/** Stable sha256 digest of a JSON-serializable value. Shared by installation and run provenance. */
+export declare function digest(value: unknown): string;
+/** sha256 of a file's contents, streamed rather than loaded fully into memory. */
+export declare function sha256File(filePath: string): Promise<string>;

package/dist/hash.js

@@ -0,0 +1,13 @@
+import { createHash } from "node:crypto";
+import fs from "node:fs";
+/** Stable sha256 digest of a JSON-serializable value. Shared by installation and run provenance. */
+export function digest(value) {
+    return createHash("sha256").update(JSON.stringify(value)).digest("hex");
+}
+/** sha256 of a file's contents, streamed rather than loaded fully into memory. */
+export async function sha256File(filePath) {
+    const hash = createHash("sha256");
+    for await (const chunk of fs.createReadStream(filePath))
+        hash.update(chunk);
+    return hash.digest("hex");
+}

package/dist/index.d.ts

@@ -1,5 +1,16 @@
-export { getSystemReport } from "@moldesk/runtime";
-export type { SystemReport } from "@moldesk/runtime";
-export { listInstalledModels, listAvailableModels } from "@moldesk/registry";
-export type { ModelManifest } from "@moldesk/registry";
-export declare const VERSION = "0.0.1";
+export { collectSystemReport, getSystemReport, isImageCachedLocally, pullDockerImage, probeDockerGpuAccess, } from "@moldesk/runtime";
+export type { DiskInfo, DockerCapability, NvidiaCapability, NvidiaGpu, SystemReport, SystemReportDeps, ToolCapability, } from "@moldesk/runtime";
+export { listAvailableModels } from "@moldesk/registry";
+export type { AssetSpec, CommandSpec, HardwareRequirements, InputSpec, ModelManifestV1, ModelStatus, OutputSpec, PlatformId, PostInstallHook, PythonRequirement, PythonRuntimeSpec, RuntimeKind, RuntimeSpec, SourceSpec, } from "@moldesk/registry";
+export { detectHostPlatformId, selectPythonRuntime } from "@moldesk/registry";
+export { MoldeskError } from "./errors.js";
+export type { MoldeskErrorData } from "./errors.js";
+export { evaluateCompatibility, shortReason } from "./compatibility.js";
+export type { CompatibilityOptions, CompatibilityReason, CompatibilityResult, CompatibilityStatus, RuntimeCompatibility, } from "./compatibility.js";
+export { listInstalledModels, } from "./install-state.js";
+export type { InstalledModel, InstalledPostInstallResult } from "./install-state.js";
+export { createInstallationPlan, installModel, INSTALL_CONFIRMATION_DISK_BYTES, INSTALL_CONFIRMATION_DOWNLOAD_BYTES, requiresInstallConfirmation, runtimeFingerprint, uninstallModel, } from "./installation.js";
+export type { InstallationPlanResult, InstallCostEstimate, InstallModelOptions, InstallModelResult, UninstallModelOptions, } from "./installation.js";
+export { runModel } from "./run.js";
+export type { RunModelOptions, RunModelResult, RunRecord } from "./run.js";
+export { VERSION } from "./version.js";

package/dist/index.js

@@ -1,3 +1,9 @@
-export { getSystemReport } from "@moldesk/runtime";
-export { listInstalledModels, listAvailableModels } from "@moldesk/registry";
-export const VERSION = "0.0.1";
+export { collectSystemReport, getSystemReport, isImageCachedLocally, pullDockerImage, probeDockerGpuAccess, } from "@moldesk/runtime";
+export { listAvailableModels } from "@moldesk/registry";
+export { detectHostPlatformId, selectPythonRuntime } from "@moldesk/registry";
+export { MoldeskError } from "./errors.js";
+export { evaluateCompatibility, shortReason } from "./compatibility.js";
+export { listInstalledModels, } from "./install-state.js";
+export { createInstallationPlan, installModel, INSTALL_CONFIRMATION_DISK_BYTES, INSTALL_CONFIRMATION_DOWNLOAD_BYTES, requiresInstallConfirmation, runtimeFingerprint, uninstallModel, } from "./installation.js";
+export { runModel } from "./run.js";
+export { VERSION } from "./version.js";

package/dist/install-state.d.ts

@@ -0,0 +1,67 @@
+import { type MoldeskPaths } from "@moldesk/runtime";
+import type { PlatformId, PostInstallHook, RuntimeKind } from "@moldesk/registry";
+export interface InstalledPostInstallResult {
+    hook: PostInstallHook | string;
+    stdout: string;
+    stderr: string;
+}
+export interface InstalledModel {
+    schemaVersion: 1;
+    installationId: string;
+    model: string;
+    displayName: string;
+    modelVersion: string;
+    adapterVersion: string;
+    runtime: {
+        kind: RuntimeKind;
+        fingerprint: string;
+        python?: {
+            version: string;
+            executable: string;
+            lockSha256: string;
+            /** The host platform the selected runtime entry was resolved for, when
+             * determinable (`undefined` on a host outside the supported PlatformId set). */
+            platform?: PlatformId;
+            /** True when the manifest declared a `platforms` field on the selected entry
+             * (a genuine per-platform selection happened) vs. a legacy entry with none. */
+            platformSelected: boolean;
+            /** One entry per `postInstall` hook that ran, in declared order; empty when
+             * the selected runtime entry declared none. */
+            postInstall: InstalledPostInstallResult[];
+        };
+        docker?: {
+            image: string;
+            digest: string;
+        };
+    };
+    environmentFingerprint: string;
+    installDir: string;
+    source?: {
+        repository: string;
+        revision: string;
+    };
+    assets: Array<{
+        id: string;
+        path: string;
+        sha256: string;
+        sizeBytes: number;
+    }>;
+    manifestSha256: string;
+    verification: {
+        passed: boolean;
+        output?: string;
+    };
+    dependencyLock: string[];
+    installedAt: string;
+    verifiedAt: string;
+    status: "ready";
+}
+interface InstallStateFile {
+    schemaVersion: 1;
+    installations: InstalledModel[];
+}
+export declare function rebuildInstallState(paths: MoldeskPaths): InstallStateFile;
+export declare function readInstallState(paths?: MoldeskPaths): InstallStateFile;
+export declare function writeInstallState(state: InstallStateFile, paths?: MoldeskPaths): void;
+export declare function listInstalledModels(paths?: MoldeskPaths): InstalledModel[];
+export {};

package/dist/install-state.js

@@ -0,0 +1,137 @@
+import fs from "node:fs";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import { getMoldeskPaths, modelInstallDir } from "@moldesk/runtime";
+function statePath(paths) {
+    return path.join(paths.state, "installed-models.json");
+}
+function isInstalledModel(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const item = value;
+    return item["schemaVersion"] === 1 &&
+        typeof item["installationId"] === "string" &&
+        typeof item["model"] === "string" &&
+        typeof item["displayName"] === "string" &&
+        typeof item["modelVersion"] === "string" &&
+        typeof item["adapterVersion"] === "string" &&
+        !!item["runtime"] && typeof item["runtime"] === "object" &&
+        (item["runtime"]["kind"] === "python" || item["runtime"]["kind"] === "docker") &&
+        typeof item["runtime"]["fingerprint"] === "string" &&
+        typeof item["environmentFingerprint"] === "string" &&
+        typeof item["installDir"] === "string" &&
+        Array.isArray(item["dependencyLock"]) &&
+        item["dependencyLock"].every((entry) => typeof entry === "string") &&
+        typeof item["installedAt"] === "string" &&
+        typeof item["verifiedAt"] === "string" &&
+        item["status"] === "ready" &&
+        Array.isArray(item["assets"]) && item["assets"].every((asset) => {
+        if (!asset || typeof asset !== "object")
+            return false;
+        const record = asset;
+        return typeof record["id"] === "string" && typeof record["path"] === "string" &&
+            typeof record["sha256"] === "string" && typeof record["sizeBytes"] === "number";
+    }) &&
+        typeof item["manifestSha256"] === "string" &&
+        !!item["verification"] && typeof item["verification"] === "object" &&
+        item["verification"]["passed"] === true;
+}
+function validManagedRecord(record, recordDir, paths) {
+    try {
+        const expected = modelInstallDir(record.model, record.modelVersion, record.runtime.fingerprint, { MOLDESK_HOME: paths.home });
+        return path.resolve(record.installDir) === path.resolve(expected) && path.resolve(recordDir) === path.resolve(expected);
+    }
+    catch {
+        return false;
+    }
+}
+function scanInstallationRecords(paths) {
+    if (!fs.existsSync(paths.models))
+        return [];
+    const records = [];
+    for (const model of fs.readdirSync(paths.models, { withFileTypes: true })) {
+        if (!model.isDirectory())
+            continue;
+        const modelDir = path.join(paths.models, model.name);
+        for (const version of fs.readdirSync(modelDir, { withFileTypes: true })) {
+            if (!version.isDirectory())
+                continue;
+            const versionDir = path.join(modelDir, version.name);
+            for (const runtime of fs.readdirSync(versionDir, { withFileTypes: true })) {
+                if (!runtime.isDirectory() || runtime.name.includes(".partial-") || runtime.name.includes(".backup-"))
+                    continue;
+                const recordDir = path.join(versionDir, runtime.name);
+                const file = path.join(recordDir, "installation.json");
+                if (!fs.existsSync(file))
+                    continue;
+                try {
+                    const record = JSON.parse(fs.readFileSync(file, "utf8"));
+                    if (isInstalledModel(record) && validManagedRecord(record, recordDir, paths))
+                        records.push(record);
+                }
+                catch {
+                    // A directory alone never counts as installed; skip invalid records.
+                }
+            }
+        }
+    }
+    return records.sort((a, b) => a.installationId.localeCompare(b.installationId));
+}
+export function rebuildInstallState(paths) {
+    const rebuilt = { schemaVersion: 1, installations: scanInstallationRecords(paths) };
+    writeInstallState(rebuilt, paths);
+    return rebuilt;
+}
+export function readInstallState(paths = getMoldeskPaths()) {
+    const file = statePath(paths);
+    if (!fs.existsSync(file)) {
+        if (!fs.existsSync(paths.models))
+            return { schemaVersion: 1, installations: [] };
+        return rebuildInstallState(paths);
+    }
+    let raw;
+    try {
+        raw = JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch {
+        return rebuildInstallState(paths);
+    }
+    if (!raw || typeof raw !== "object" || raw["schemaVersion"] !== 1) {
+        return rebuildInstallState(paths);
+    }
+    const installations = raw["installations"];
+    if (!Array.isArray(installations) || !installations.every(isInstalledModel)) {
+        return rebuildInstallState(paths);
+    }
+    for (const record of installations) {
+        const expected = modelInstallDir(record.model, record.modelVersion, record.runtime.fingerprint, { MOLDESK_HOME: paths.home });
+        if (path.resolve(record.installDir) !== path.resolve(expected)) {
+            return rebuildInstallState(paths);
+        }
+    }
+    return { schemaVersion: 1, installations };
+}
+export function writeInstallState(state, paths = getMoldeskPaths()) {
+    fs.mkdirSync(paths.state, { recursive: true });
+    const file = statePath(paths);
+    const temporary = `${file}.tmp-${process.pid}-${randomUUID()}`;
+    fs.writeFileSync(temporary, `${JSON.stringify(state, null, 2)}\n`, { mode: 0o600 });
+    fs.renameSync(temporary, file);
+}
+export function listInstalledModels(paths = getMoldeskPaths()) {
+    const state = readInstallState(paths);
+    const valid = state.installations.filter((record) => {
+        const file = path.join(record.installDir, "installation.json");
+        if (!fs.existsSync(file))
+            return false;
+        try {
+            const onDisk = JSON.parse(fs.readFileSync(file, "utf8"));
+            return isInstalledModel(onDisk) && onDisk.installationId === record.installationId && validManagedRecord(onDisk, record.installDir, paths);
+        }
+        catch {
+            return false;
+        }
+    });
+    const installations = valid.length === state.installations.length ? valid : rebuildInstallState(paths).installations;
+    return installations.sort((a, b) => a.model.localeCompare(b.model));
+}