datagrok-tools 6.1.3 → 6.1.5

package/bin/commands/publish.js

@@ -52,7 +52,7 @@ function discoverDockerfiles(packageName, version, debug) {
     if (!_fs.default.existsSync(dockerfilePath)) continue;
     const cleanName = utils.removeScope(packageName).toLowerCase();
     const imageName = `${cleanName}-${entry.name.toLowerCase()}`;
-    const imageTag = debug ? version : `${version}.X`;
+    const imageTag = version;
     results.push({
       imageName,
       imageTag,
@@ -68,17 +68,26 @@ function dockerCommand(args) {
     stdio: ['pipe', 'pipe', 'pipe']
   }).trim();
 }
-function localImageExists(fullName) {
+function localImageExists(fullName, checkPlatform = true) {
   try {
     const output = dockerCommand(`images --format "{{.Repository}}:{{.Tag}}"`);
-    return output.split('\n').some(line => line.trim() === fullName);
+    if (!output.split('\n').some(line => line.trim() === fullName)) return false;
+    if (checkPlatform) {
+      // Verify the image is linux/amd64 — ARM images won't run on Datagrok servers
+      const inspect = dockerCommand(`inspect --format "{{.Os}}/{{.Architecture}}" ${fullName}`);
+      if (inspect.trim() !== 'linux/amd64') {
+        color.warn(`Local image ${fullName} is ${inspect.trim()}, not linux/amd64 — treating as not found`);
+        return false;
+      }
+    }
+    return true;
   } catch {
     return false;
   }
 }
 function dockerLogin(registry, devKey) {
   try {
-    dockerCommand(`login ${registry} -u ${devKey} -p ${devKey}`);
+    dockerCommand(`login ${registry} -u any -p ${devKey}`);
     return true;
   } catch (e) {
     color.warn(`Docker login to ${registry} failed: ${e.message || e}`);
@@ -106,10 +115,22 @@ function dockerPush(image) {
     return false;
   }
 }
-function dockerBuild(imageName, dockerfilePath, context) {
+function isLocalhostRegistry(registry) {
+  return registry.startsWith('localhost') || registry.startsWith('127.0.0.1');
+}
+function dockerRemove(imageName) {
+  try {
+    dockerCommand(`rmi ${imageName}`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function dockerBuild(imageName, dockerfilePath, context, usePlatform = true) {
   try {
-    color.log(`Building Docker image ${imageName}...`);
-    execSync(`docker build -t ${imageName} -f ${dockerfilePath} ${context}`, {
+    const platformFlag = usePlatform ? '--platform linux/amd64 ' : '';
+    color.log(`Building Docker image ${imageName}${usePlatform ? ' (platform: linux/amd64)' : ''}...`);
+    execSync(`docker build ${platformFlag}-t ${imageName} -f ${dockerfilePath} ${context}`, {
       encoding: 'utf-8',
       stdio: 'inherit'
     });
@@ -125,13 +146,20 @@ function calculateFolderHash(dirPath) {
   entries.sort((a, b) => a.relPath < b.relPath ? -1 : a.relPath > b.relPath ? 1 : 0);
   for (const entry of entries) {
     if (entry.isDir) {
+      color.log(`  Hash entry: dir:${entry.relPath}:`);
       hash.update(`dir:${entry.relPath}:`);
     } else {
+      // Normalize CRLF to LF to match server-side storage
+      const raw = _fs.default.readFileSync(entry.fullPath);
+      const content = raw.includes(0x0d) && !raw.includes(0x00) ? Buffer.from(raw.toString('utf8').replace(/\r\n/g, '\n'), 'utf8') : raw;
+      color.log(`  Hash entry: file:${entry.relPath}: (${content.length} bytes)`);
       hash.update(`file:${entry.relPath}:`);
-      hash.update(_fs.default.readFileSync(entry.fullPath));
+      hash.update(content);
     }
   }
-  return hash.digest('hex');
+  const result = hash.digest('hex');
+  color.log(`  Folder hash: ${result}`);
+  return result;
 }
 function listRecursive(basePath, rel) {
   const results = [];
@@ -226,62 +254,83 @@ async function processDockerImages(packageName, version, registry, devKey, host,
   if (dockerImages.length === 0) return;
   color.log(`Found ${dockerImages.length} Dockerfile(s)`);
   if (registry) dockerLogin(registry, devKey);
+  const needsPlatform = !!registry && !isLocalhostRegistry(registry);
   for (const img of dockerImages) {
     color.info(`Processing docker image ${img.fullLocalName}...`);
     let result;
     const dockerfileDir = _path.default.join('dockerfiles', img.dirName);
     const dockerfilePath = _path.default.join(dockerfileDir, 'Dockerfile');
     const contentHash = calculateFolderHash(_path.default.join(curDir, dockerfileDir));
-    if (rebuildDocker) {
-      if (dockerBuild(img.fullLocalName, dockerfilePath, dockerfileDir)) {
-        result = pushImage(img, registry);
+
+    // In release mode, append short content hash to tag for cache-busting
+    const shortHash = contentHash.substring(0, 8);
+    const registryTag = debug ? img.imageTag : `${img.imageTag}.${shortHash}`;
+    const remoteFullName = `${img.imageName}:${registryTag}`;
+    const buildAndPush = () => {
+      if (dockerBuild(img.fullLocalName, dockerfilePath, dockerfileDir, needsPlatform)) {
+        if (registry) {
+          const remoteTag = `${registry}/datagrok/${remoteFullName}`;
+          dockerTag(img.fullLocalName, remoteTag);
+        }
         color.success(`Built and tagged ${img.fullLocalName}`);
-      } else {
-        result = await fallbackImage(img, host, devKey, registry, version, contentHash);
+        return pushImage(img.imageName, registryTag, registry);
       }
-    } else if (localImageExists(img.fullLocalName)) {
-      color.success(`Found local image ${img.fullLocalName}`);
-      result = pushImage(img, registry);
+      return null;
+    };
+    if (rebuildDocker) {
+      // Delete old images before rebuilding
+      dockerRemove(img.fullLocalName);
+      if (registry) dockerRemove(`${registry}/datagrok/${remoteFullName}`);
+      result = buildAndPush() ?? (await fallbackImage(img, host, devKey, registry, version, contentHash));
     } else {
-      color.warn(`Local image not found. Expected: ${img.fullLocalName}`);
-      color.log(`  Build it with: docker build -t ${img.fullLocalName} -f ${dockerfilePath} ${dockerfileDir}`);
-      const fallback = await fallbackImage(img, host, devKey, registry, version, contentHash);
-      if (fallback.serverError) {
-        color.error(`Cannot resolve fallback: ${fallback.serverError}`);
-        result = {
-          image: null,
-          fallback: true,
-          requestedVersion: img.imageTag
-        };
-      } else if (fallback.image && fallback.hashMatch === true) {
-        result = fallback;
-        color.success(`Falling back to ${fallback.image} (dockerfile unchanged)`);
-      } else if (fallback.image && fallback.hashMatch === false && !skipDockerRebuild) {
-        color.warn(`Dockerfile folder has changed. Rebuilding image...`);
-        if (dockerBuild(img.fullLocalName, dockerfilePath, dockerfileDir)) {
-          result = pushImage(img, registry);
-          color.success(`Built and tagged ${img.fullLocalName}`);
-        } else {
-          result = {
-            image: fallback.image,
-            fallback: true,
-            requestedVersion: img.imageTag
-          };
-          color.warn(`Build failed. Falling back to ${fallback.image} (hash mismatch)`);
+      // Look for registry-qualified image first, then unqualified
+      let foundLocalName = null;
+      if (registry) {
+        const registryQualified = `${registry}/datagrok/${remoteFullName}`;
+        if (localImageExists(registryQualified, needsPlatform)) foundLocalName = registryQualified;
+      }
+      if (!foundLocalName && localImageExists(img.fullLocalName, needsPlatform)) foundLocalName = img.fullLocalName;
+      if (foundLocalName) {
+        color.success(`Found local image ${foundLocalName}`);
+        if (registry) {
+          const remoteTag = `${registry}/datagrok/${remoteFullName}`;
+          if (foundLocalName !== remoteTag) dockerTag(foundLocalName, remoteTag);
         }
+        result = pushImage(img.imageName, registryTag, registry);
       } else {
-        // No fallback and no local image — must build
-        color.warn(`No fallback available. Building ${img.fullLocalName}...`);
-        if (dockerBuild(img.fullLocalName, dockerfilePath, dockerfileDir)) {
-          result = pushImage(img, registry);
-          color.success(`Built and tagged ${img.fullLocalName}`);
-        } else {
+        color.warn(`Local image not found. Expected: ${img.fullLocalName}`);
+        color.log(`  Build it with: docker build -t ${img.fullLocalName} -f ${dockerfilePath} ${dockerfileDir}`);
+        const fallback = await fallbackImage(img, host, devKey, registry, version, contentHash);
+        if (fallback.serverError) {
+          color.error(`Cannot resolve fallback: ${fallback.serverError}`);
           result = {
             image: null,
             fallback: true,
-            requestedVersion: img.imageTag
+            requestedVersion: registryTag
+          };
+        } else if (fallback.image && fallback.hashMatch === true) {
+          result = fallback;
+          color.success(`Falling back to ${fallback.image} (dockerfile unchanged)`);
+        } else if (fallback.image && fallback.hashMatch === false && !skipDockerRebuild) {
+          color.warn(`Dockerfile folder has changed. Rebuilding image...`);
+          result = buildAndPush() ?? {
+            image: fallback.image,
+            fallback: true,
+            requestedVersion: registryTag
           };
-          color.error(`Failed to build ${img.fullLocalName}. No container will be available.`);
+          if (!result || result.fallback) color.warn(`Build failed. Falling back to ${fallback.image} (hash mismatch)`);
+        } else {
+          // No fallback and no local image — must build
+          color.warn(`No fallback available. Building ${img.fullLocalName}...`);
+          const built = buildAndPush();
+          if (built) result = built;else {
+            result = {
+              image: null,
+              fallback: true,
+              requestedVersion: registryTag
+            };
+            color.error(`Failed to build ${img.fullLocalName}. No container will be available.`);
+          }
         }
       }
     }
@@ -293,11 +342,11 @@ async function processDockerImages(packageName, version, registry, devKey, host,
     color.log(`Added ${imageJsonPath}`);
   }
 }
-function pushImage(img, registry) {
-  const canonicalImage = `datagrok/${img.fullLocalName}`;
+function pushImage(imageName, tag, registry) {
+  const canonicalImage = `datagrok/${imageName}:${tag}`;
   if (registry) {
     const remoteTag = `${registry}/${canonicalImage}`;
-    dockerTag(img.fullLocalName, remoteTag);
+    // Image should already be tagged from build or retag step
     if (dockerPush(remoteTag)) return {
       image: canonicalImage,
       fallback: false

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "datagrok-tools",
-  "version": "6.1.3",
+  "version": "6.1.5",
   "description": "Utility to upload and publish packages to Datagrok",
   "homepage": "https://github.com/datagrok-ai/public/tree/master/tools#readme",
   "dependencies": {