datagrok-tools 6.4.0 → 6.4.2

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Datagrok-tools changelog
 
+## 6.4.2 (2026-06-18)
+
+* `grok publish` — registry-aware Docker fallback: when a package's image isn't built locally and the target server has no compatible record, `grok publish` now checks the configured registry and Docker Hub (`docker manifest inspect`) for the expected `datagrok/<name>:<version>` (and content-hashed) tag and uses it, instead of reporting "No fallback available" and failing. Fixes dependency publishes (e.g. Bio → @datagrok/chem) on CI runners where the image exists in the registry but not locally.
+
+## 6.4.1 (2026-06-18)
+
+* Fixed `grok` failing with `Cannot find module './commands/build'` — the `.npmignore` `build.js` rule was unanchored and excluded the compiled `bin/commands/build.js` from the published package; anchored it to `/build.js`.
+* Pinned `ignore-walk` to ^6.0.5 so the package still supports Node 18 (9.x requires Node 22+).
+
 ## 6.4.0 (2026-06-18)
 
 * Dependencies: sanitized and updated all dependencies; `npm install` is now warning-free and `npm audit` reports 0 vulnerabilities (was 24).

package/bin/commands/build.js

@@ -0,0 +1,209 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.applyFilter = applyFilter;
+exports.build = build;
+exports.confirm = confirm;
+exports.discoverPackages = discoverPackages;
+exports.getNestedValue = getNestedValue;
+var _fs = _interopRequireDefault(require("fs"));
+var _path = _interopRequireDefault(require("path"));
+var _util = require("util");
+var _child_process = require("child_process");
+var readline = _interopRequireWildcard(require("readline"));
+var utils = _interopRequireWildcard(require("../utils/utils"));
+var color = _interopRequireWildcard(require("../utils/color-utils"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+const execAsync = (0, _util.promisify)(_child_process.exec);
+async function build(args) {
+  if (args.verbose) color.setVerbose(true);
+  const buildCmd = args['no-incremental'] ? 'npm run build' : 'npm run build -- --env incremental';
+  if (args.recursive) return await buildRecursive(process.cwd(), args, buildCmd);else return await buildSingle(process.cwd(), buildCmd);
+}
+async function buildSingle(dir, buildCmd) {
+  if (!utils.isPackageDir(dir)) {
+    color.error('Not a package directory (no package.json found)');
+    return false;
+  }
+  const packageJson = JSON.parse(_fs.default.readFileSync(_path.default.join(dir, 'package.json'), 'utf-8'));
+  const name = packageJson.friendlyName || packageJson.name;
+  console.log(`Building ${name}...`);
+  try {
+    await utils.runScript('npm install', dir, color.isVerbose());
+    await utils.runScript(buildCmd, dir, color.isVerbose());
+    color.success(`Successfully built ${name}`);
+    return true;
+  } catch (error) {
+    color.error(`Failed to build ${name}`);
+    if (error.message) color.error(error.message);
+    return false;
+  }
+}
+async function buildRecursive(baseDir, args, buildCmd) {
+  const packages = discoverPackages(baseDir);
+  if (packages.length === 0) {
+    color.warn('No packages found in the current directory');
+    return false;
+  }
+  const filtered = args.filter ? applyFilter(packages, args.filter) : packages;
+  if (filtered.length === 0) {
+    color.warn('No packages match the filter');
+    return false;
+  }
+  console.log(`Found ${filtered.length} package(s): ${filtered.map(p => p.friendlyName).join(', ')}`);
+  if (!args.silent && !args.s) {
+    const confirmed = await confirm(`\nBuild ${filtered.length} package(s)?`);
+    if (!confirmed) {
+      console.log('Aborted.');
+      return false;
+    }
+  }
+  const maxParallel = args.parallel || 4;
+  const results = await buildParallel(filtered, buildCmd, maxParallel);
+  return results.every(r => r.success);
+}
+function discoverPackages(baseDir) {
+  const entries = _fs.default.readdirSync(baseDir);
+  const packages = [];
+  for (const entry of entries) {
+    if (entry.startsWith('.') || entry === 'node_modules') continue;
+    const dir = _path.default.join(baseDir, entry);
+    try {
+      if (!_fs.default.statSync(dir).isDirectory()) continue;
+    } catch (_) {
+      continue;
+    }
+    const packageJsonPath = _path.default.join(dir, 'package.json');
+    if (!_fs.default.existsSync(packageJsonPath)) continue;
+    try {
+      const packageJson = JSON.parse(_fs.default.readFileSync(packageJsonPath, 'utf-8'));
+      packages.push({
+        dir,
+        name: packageJson.name || entry,
+        friendlyName: packageJson.friendlyName || packageJson.name || entry,
+        version: packageJson.version || '0.0.0',
+        packageJson
+      });
+    } catch (_) {
+      continue;
+    }
+  }
+  return packages.sort((a, b) => a.friendlyName.localeCompare(b.friendlyName));
+}
+function applyFilter(packages, filterStr) {
+  const conditions = filterStr.split('&&').map(s => s.trim());
+  const parsedConditions = conditions.map(cond => {
+    const colonIdx = cond.indexOf(':');
+    if (colonIdx === -1) return {
+      field: cond,
+      pattern: new RegExp('.')
+    };
+    const field = cond.substring(0, colonIdx).trim();
+    const pattern = new RegExp(cond.substring(colonIdx + 1).trim());
+    return {
+      field,
+      pattern
+    };
+  });
+  return packages.filter(pkg => {
+    for (const cond of parsedConditions) {
+      const value = getNestedValue(pkg.packageJson, cond.field);
+      if (value === undefined || !cond.pattern.test(String(value))) return false;
+    }
+    return true;
+  });
+}
+function getNestedValue(obj, path) {
+  const parts = path.split('.');
+  let current = obj;
+  for (const part of parts) {
+    if (current == null || typeof current !== 'object') return undefined;
+    current = current[part];
+  }
+  return current;
+}
+async function buildParallel(packages, buildCmd, maxParallel) {
+  const results = [];
+  const headers = ['Plugin', 'Version', 'Build time', 'Bundle size'];
+  const widths = [Math.max(headers[0].length, ...packages.map(p => p.friendlyName.length)), Math.max(headers[1].length, ...packages.map(p => p.version.length)), Math.max(headers[2].length, 10), Math.max(headers[3].length, 40)];
+  const pad = (s, w) => s + ' '.repeat(Math.max(0, w - s.length));
+  console.log(`\nBuilding with ${maxParallel} parallel job(s)...`);
+  console.log(headers.map((h, i) => pad(h, widths[i])).join(' | '));
+  console.log(widths.map(w => '-'.repeat(w)).join('-+-'));
+  const buildOne = async pkg => {
+    const start = Date.now();
+    let success = true;
+    let buildTime = '';
+    let bundleSize = '';
+    try {
+      await execAsync('npm install', {
+        cwd: pkg.dir,
+        maxBuffer: 10 * 1024 * 1024
+      });
+      await execAsync(buildCmd, {
+        cwd: pkg.dir,
+        maxBuffer: 10 * 1024 * 1024
+      });
+      const elapsed = (Date.now() - start) / 1000;
+      buildTime = `${elapsed.toFixed(1)}s`;
+      bundleSize = getBundleSize(pkg.dir);
+    } catch (error) {
+      success = false;
+      buildTime = 'Error';
+      const raw = (error.stderr || error.stdout || error.message || 'Unknown error').trim();
+      bundleSize = raw.replace(/\r?\n/g, ' ').replace(/\s+/g, ' ').substring(0, 40);
+    }
+    const result = {
+      name: pkg.friendlyName,
+      version: pkg.version,
+      buildTime,
+      bundleSize,
+      success
+    };
+    results.push(result);
+    const cells = [result.name, result.version, result.buildTime, result.bundleSize];
+    const line = cells.map((cell, j) => pad(cell, widths[j])).join(' | ');
+    if (success) color.info(line);else color.error(line);
+    return result;
+  };
+  let idx = 0;
+  const next = async () => {
+    while (idx < packages.length) {
+      const pkg = packages[idx++];
+      await buildOne(pkg);
+    }
+  };
+  const workers = Array.from({
+    length: Math.min(maxParallel, packages.length)
+  }, () => next());
+  await Promise.all(workers);
+  const succeeded = results.filter(r => r.success).length;
+  const failed = results.length - succeeded;
+  console.log('');
+  if (failed === 0) color.success(`All ${results.length} package(s) built successfully`);else color.warn(`${succeeded} succeeded, ${failed} failed`);
+  return results;
+}
+function getBundleSize(dir) {
+  const bundlePath = _path.default.join(dir, 'dist', 'package.js');
+  try {
+    const stats = _fs.default.statSync(bundlePath);
+    return `${(stats.size / 1024).toFixed(1)} KB`;
+  } catch (_) {
+    return 'N/A';
+  }
+}
+function confirm(message) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise(resolve => {
+    rl.question(`${message} [Y/n] `, answer => {
+      rl.close();
+      resolve(answer.trim().toLowerCase() !== 'n');
+    });
+  });
+}

package/bin/commands/publish.js

@@ -95,6 +95,30 @@ function localImageExists(fullName, checkPlatform = true) {
     return false;
   }
 }
+function imageExistsInRegistry(ref) {
+  try {
+    execSync(`docker manifest inspect ${ref}`, {
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// Looks for an already-published image in the configured registry and on Docker Hub,
+// without pulling it. Prefers the content-hashed release tag (exact dockerfile match),
+// then the plain version tag. Returns the canonical `datagrok/<name>:<tag>` reference
+// for image.json, or null when nothing usable is published.
+function resolveRegistryImage(imageName, registryTag, versionTag, registry) {
+  const tags = registryTag === versionTag ? [versionTag] : [registryTag, versionTag];
+  for (const tag of tags) {
+    const canonical = `datagrok/${imageName}:${tag}`;
+    if (registry && imageExistsInRegistry(`${registry}/${canonical}`)) return canonical;
+    if (imageExistsInRegistry(canonical)) return canonical;
+  }
+  return null;
+}
 function dockerLogin(registry, devKey) {
   try {
     dockerCommand(`login ${registry} -u any -p ${devKey}`);
@@ -333,24 +357,37 @@ async function processDockerImages(packageName, version, registry, devKey, host,
             requestedVersion: registryTag
           };
           if (!result || result.fallback) color.warn(`Build failed. Falling back to ${fallback.image} (hash mismatch)`);
-        } else if (skipDockerRebuild) {
-          color.warn(`No fallback available. Skipping docker build (--skip-docker-rebuild).`);
-          result = {
-            image: null,
-            fallback: true,
-            requestedVersion: registryTag
-          };
         } 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 {
+          // The server has no compatible record, but the image may already be
+          // published in the configured registry / Docker Hub (e.g. pushed by an
+          // earlier CI run). Use it directly rather than failing or rebuilding.
+          const registryImage = resolveRegistryImage(img.imageName, registryTag, img.imageTag, registry);
+          if (registryImage) {
+            result = {
+              image: registryImage,
+              fallback: true,
+              requestedVersion: registryTag
+            };
+            color.success(`Falling back to registry image ${registryImage}`);
+          } else if (skipDockerRebuild) {
+            color.warn(`No fallback available. Skipping docker build (--skip-docker-rebuild).`);
             result = {
               image: null,
               fallback: true,
               requestedVersion: registryTag
             };
-            color.error(`Failed to build ${img.fullLocalName}. No container will be available.`);
+          } 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.`);
+            }
           }
         }
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "datagrok-tools",
-  "version": "6.4.0",
+  "version": "6.4.2",
   "description": "Utility to upload and publish packages to Datagrok",
   "homepage": "https://github.com/datagrok-ai/public/tree/master/tools#readme",
   "dependencies": {
@@ -14,7 +14,7 @@
     "datagrok-api": "^1.27.6",
     "estraverse": "^5.3.0",
     "glob": "^13.0.6",
-    "ignore-walk": "^9.0.0",
+    "ignore-walk": "^6.0.5",
     "inquirer": "^8.2.7",
     "js-yaml": "^4.2.0",
     "minimist": "^1.2.8",