hologit 0.47.3 → 0.47.4

package/lib/Lens.js

@@ -111,45 +111,44 @@ class Lens extends Configurable {
     }
 
     async getImageHash (containerQuery) {
-        // Try local first (fastest)
+        // Get manifest digest from registry without pulling.
+        // This is the only identifier that is consistent across all machines
+        // and Docker storage backends (graphdriver vs containerd-snapshotter).
+        let manifestDigest;
         try {
-            const inspectOutput = await Studio.execDocker(['inspect', containerQuery]);
-            const imageInfo = JSON.parse(inspectOutput)[0];
-            logger.info(`found local image: ${containerQuery}@${imageInfo.Id}`);
-            return { hash: imageInfo.Id, isLocal: true };
+            logger.info(`querying registry for manifest digest: ${containerQuery}`);
+            const output = await Studio.execDocker([
+                'buildx', 'imagetools', 'inspect', '--format', '{{json .}}', containerQuery
+            ]);
+            const info = JSON.parse(output);
+            manifestDigest = info.manifest.digest;
         } catch (err) {
-            // Not found locally, try remote manifest
+            throw new Error(`failed to get manifest digest for container image ${containerQuery}: ${err.message}`);
         }
 
-        // Try remote manifest (doesn't pull the image)
-        try {
-            logger.info(`querying remote manifest for: ${containerQuery}`);
-            const manifestOutput = await Studio.execDocker(['manifest', 'inspect', containerQuery]);
-            const manifest = JSON.parse(manifestOutput);
-
-            // Extract digest from manifest
-            // For multi-arch images, manifest.config.digest contains the config digest
-            // For single-arch images, we may need to look at the digest field
-            const digest = manifest.config?.digest || manifest.digest;
-
-            if (!digest) {
-                throw new Error('No digest found in manifest');
-            }
+        if (!manifestDigest) {
+            throw new Error(`no manifest digest found for ${containerQuery}`);
+        }
 
-            // Ensure the digest is in the format sha256:...
-            const imageHash = digest.startsWith('sha256:') ? digest : `sha256:${digest}`;
-            logger.info(`found remote image hash: ${containerQuery}@${imageHash}`);
-            return { hash: imageHash, isLocal: false };
+        // Check if already available locally by digest reference
+        const repoName = containerQuery.replace(/:.*$/, '');
+        let isLocal = false;
+        try {
+            await Studio.execDocker(['inspect', `${repoName}@${manifestDigest}`]);
+            isLocal = true;
         } catch (err) {
-            throw new Error(`failed to get hash for container image ${containerQuery}: ${err.message}`);
+            // not local
         }
+
+        logger.info(`image ${containerQuery} manifest digest: ${manifestDigest} (local: ${isLocal})`);
+        return { hash: manifestDigest, isLocal };
     }
 
     async buildSpecForContainer (inputTree, config) {
         const { container: containerQuery } = config;
 
-        // Get image hash without pulling
-        const { hash: imageHash, isLocal } = await this.getImageHash(containerQuery);
+        // Get manifest digest from registry without pulling
+        const { hash: imageHash } = await this.getImageHash(containerQuery);
 
         // build spec
         const data = {
@@ -165,8 +164,7 @@ class Lens extends Configurable {
         return {
             ...await SpecObject.write(this.workspace.getRepo(), 'lens', data),
             data,
-            type: 'container',
-            imageIsLocal: isLocal
+            type: 'container'
         };
     }
 
@@ -249,11 +247,11 @@ class Lens extends Configurable {
         };
     }
 
-    async executeSpec (specType, specHash, options) {
-        return Lens.executeSpec(specType, specHash, {...options, repo: this.workspace.getRepo()});
+    async executeSpec (specHash, options) {
+        return Lens.executeSpec(specHash, {...options, repo: this.workspace.getRepo()});
     }
 
-    static async executeSpec (specType, specHash, options) {
+    static async executeSpec (specHash, options) {
         const { refresh=false, cacheFrom=null, cacheTo=null, save=true } = options;
 
 
@@ -262,6 +260,16 @@ class Lens extends Configurable {
         const git = await repo.getGit();
 
 
+        // determine spec type from content
+        const specToml = await git.catFile({ p: true }, specHash);
+        const { holospec: { lens: spec } } = TOML.parse(specToml);
+        const specType = spec.container ? 'container' : spec.package ? 'habitat' : null;
+
+        if (!specType) {
+            throw new Error(`unable to determine spec type: spec has neither container nor package field`);
+        }
+
+
         // check for existing build
         const specRef = SpecObject.buildRef('lens', specHash);
         if (!refresh) {
@@ -324,30 +332,25 @@ class Lens extends Configurable {
             m: specToml
         });
 
-        // extract repository and hash from container string
-        const containerMatch = spec.container.match(/^.+@sha256:([a-f0-9]{64})$/);
-        if (!containerMatch) {
-            throw new Error(`Invalid container format: ${spec.container}`);
+        // use full digest reference (e.g. "ghcr.io/hologit/lenses/shell@sha256:0f8acb01...")
+        // for all docker operations — this is the manifest digest, which works
+        // consistently across Docker storage backends
+        const containerRef = spec.container;
+        if (!containerRef.match(/^.+@sha256:[a-f0-9]{64}$/)) {
+            throw new Error(`Invalid container format: ${containerRef}`);
         }
-        const [, sha256Hash] = containerMatch;
 
         // Ensure image is available locally
         try {
-            await Studio.execDocker(['inspect', sha256Hash]);
+            await Studio.execDocker(['inspect', containerRef]);
         } catch (err) {
-            // Image not found locally, need to pull it
-            // Extract the original container query from spec to pull by name:tag
-            const containerQueryMatch = spec.container.match(/^(.+)@sha256:[a-f0-9]{64}$/);
-            if (containerQueryMatch) {
-                const containerQuery = containerQueryMatch[1];
-                logger.info(`pulling required image: ${containerQuery}`);
-                try {
-                    await Studio.execDocker(['pull', containerQuery], { $relayStdout: true });
-                } catch (pullErr) {
-                    throw new Error(`failed to pull container image ${containerQuery}: ${pullErr.message}`);
-                }
-            } else {
-                throw new Error(`cannot extract container query from spec.container: ${spec.container}`);
+            // Pull by digest — guarantees we get the exact image version
+            // matching the spec that was used for caching
+            logger.info(`pulling required image: ${containerRef}`);
+            try {
+                await Studio.execDocker(['pull', containerRef], { $relayStdout: true });
+            } catch (pullErr) {
+                throw new Error(`failed to pull container image ${containerRef}: ${pullErr.message}`);
             }
         }
 
@@ -376,7 +379,7 @@ class Lens extends Configurable {
                     '-p', '9000:9000',
                     ...(persistentDebugContainer ? ['--name', persistentDebugContainer] : []),
                     ...(process.env.DEBUG ? ['-e', 'DEBUG=1'] : []),
-                    sha256Hash
+                    containerRef
                 ]);
                 containerId = containerId.trim();
 

package/lib/Projection.js

@@ -162,11 +162,11 @@ class Projection {
 
             // build tree of matching files to input to lens
             logger.info(`building input tree for lens ${lens.name} from ${inputRoot == '.' ? '' : (path.join(inputRoot, '.')+'/')}{${inputFiles}}`);
-            const { hash: specHash, type: specType } = await lens.buildSpec(await lens.buildInputTree(this.output.root));
+            const { hash: specHash } = await lens.buildSpec(await lens.buildInputTree(this.output.root));
 
 
             // check for existing output tree
-            const outputTreeHash = await lens.executeSpec(specType, specHash, { cacheFrom, cacheTo });
+            const outputTreeHash = await lens.executeSpec(specHash, { cacheFrom, cacheTo });
 
 
             // verify output

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hologit",
-  "version": "0.47.3",
+  "version": "0.47.4",
   "description": "Hologit automates the projection of layered composite file trees based on flat, declarative plans",
   "repository": "https://github.com/JarvusInnovations/hologit",
   "main": "lib/index.js",