datagrok-tools 6.1.4 → 6.1.6

package/bin/commands/help.js

@@ -21,6 +21,7 @@ Commands:
     init        Modify a package template
     link        Link \`datagrok-api\` and libraries for local development
     publish     Upload a package
+    report      Manage user error reports (fetch, resolve, create ticket)
     test        Run package tests
     testall     Run packages tests
     migrate     Migrate legacy tags to meta.role
@@ -321,6 +322,23 @@ Examples:
 // file and converting your scripts in the \`package.json\` file
 // `;
 
+const HELP_REPORT = `
+Usage: grok report <subcommand> <instance> <id>
+
+Manage Datagrok user error reports
+
+Subcommands:
+    fetch    Download a report zip from a managed instance
+    resolve  Mark a report as resolved
+    ticket   Create a JIRA ticket for a report via the Datlas API
+
+Examples:
+  grok report fetch dev 1528         Download report #1528 from the 'dev' instance
+  grok report resolve dev 1528       Resolve report #1528 on the 'dev' instance
+  grok report ticket dev <report-uuid>   Create a JIRA ticket for a report
+
+The instance name must match a server alias in ~/.grok/config.yaml.
+`;
 const help = exports.help = {
   add: HELP_ADD,
   api: HELP_API,
@@ -333,6 +351,7 @@ const help = exports.help = {
   init: HELP_INIT,
   link: HELP_LINK,
   publish: HELP_PUBLISH,
+  report: HELP_REPORT,
   test: HELP_TEST,
   testall: HELP_TESTALL,
   migrate: HELP_MIGRATE,

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'
     });
@@ -233,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.`);
+          }
         }
       }
     }
@@ -300,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/bin/commands/report.js

@@ -0,0 +1,184 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.report = report;
+var _fs = _interopRequireDefault(require("fs"));
+var _os = _interopRequireDefault(require("os"));
+var _path = _interopRequireDefault(require("path"));
+var color = _interopRequireWildcard(require("../utils/color-utils"));
+var _testUtils = require("../utils/test-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 fetch = require('node-fetch');
+async function report(args) {
+  const subcommand = args._[1];
+  switch (subcommand) {
+    case 'fetch':
+      return await handleFetch(args);
+    case 'resolve':
+      return await handleResolve(args);
+    case 'ticket':
+      return await handleTicket(args);
+    default:
+      return false;
+  }
+}
+async function handleFetch(args) {
+  const instance = args._[2];
+  const number = args._[3];
+  if (!instance || !number) {
+    color.error('Usage: grok report fetch <instance> <number>');
+    return false;
+  }
+  try {
+    const {
+      url,
+      key
+    } = (0, _testUtils.getDevKey)(instance);
+    const token = await (0, _testUtils.getToken)(url, key);
+    console.log(`Searching for report #${number}...`);
+    const searchResp = await fetch(`${url}/reports?text=number%3D${encodeURIComponent(number)}`, {
+      headers: {
+        Authorization: token
+      }
+    });
+    if (!searchResp.ok) {
+      color.error(`Report search failed (HTTP ${searchResp.status})`);
+      return false;
+    }
+    const results = await searchResp.json();
+    if (!Array.isArray(results) || results.length === 0) {
+      color.error(`Report #${number} not found`);
+      return false;
+    }
+    const reportData = results[0];
+    const reportId = reportData.id || reportData.Id;
+    if (!reportId) {
+      color.error('Report found but has no id field');
+      return false;
+    }
+    console.log(`Downloading report ${reportId}...`);
+    const downloadResp = await fetch(`${url}/reports/${reportId}/zip`, {
+      headers: {
+        Authorization: token
+      }
+    });
+    if (!downloadResp.ok) {
+      color.error(`Report download failed (HTTP ${downloadResp.status})`);
+      return false;
+    }
+    const buffer = await downloadResp.buffer();
+    const outputPath = _path.default.join(_os.default.tmpdir(), `report_${instance}_${number}.zip`);
+    _fs.default.writeFileSync(outputPath, buffer);
+    const metaPath = outputPath.replace('.zip', '_meta.json');
+    _fs.default.writeFileSync(metaPath, JSON.stringify(reportData, null, 2));
+    color.success(`Report saved to: ${outputPath}`);
+    console.log(outputPath);
+    return true;
+  } catch (err) {
+    color.error(`Error: ${err.message}`);
+    return false;
+  }
+}
+async function handleResolve(args) {
+  const instance = args._[2];
+  const number = args._[3];
+  if (!instance || !number) {
+    color.error('Usage: grok report resolve <instance> <number>');
+    return false;
+  }
+  try {
+    const metaPath = _path.default.join(_os.default.tmpdir(), `report_${instance}_${number}_meta.json`);
+    if (!_fs.default.existsSync(metaPath)) {
+      color.error(`Meta file not found: ${metaPath}`);
+      color.warn('Hint: was the report fetched via `grok report fetch` first?');
+      return false;
+    }
+    const meta = JSON.parse(_fs.default.readFileSync(metaPath, 'utf-8'));
+    const reportId = meta.id || meta.Id;
+    if (!reportId) {
+      color.error(`No report id in meta file: ${metaPath}`);
+      return false;
+    }
+    const {
+      url,
+      key
+    } = (0, _testUtils.getDevKey)(instance);
+    const token = await (0, _testUtils.getToken)(url, key);
+    console.log(`Resolving report #${number} (id: ${reportId})...`);
+    const resp = await fetch(`${url}/reports/${reportId}/resolve`, {
+      method: 'POST',
+      headers: {
+        Authorization: token
+      }
+    });
+    if (resp.ok) {
+      color.success(`Report #${number} resolved on ${instance}`);
+      return true;
+    }
+    const body = await resp.text();
+    color.error(`Resolve failed (HTTP ${resp.status}): ${body}`);
+    return false;
+  } catch (err) {
+    color.error(`Error: ${err.message}`);
+    return false;
+  }
+}
+async function handleTicket(args) {
+  const instance = args._[2];
+  const reportId = args._[3];
+  if (!instance || !reportId) {
+    color.error('Usage: grok report ticket <instance> <report-id>');
+    return false;
+  }
+  try {
+    const {
+      url,
+      key
+    } = (0, _testUtils.getDevKey)(instance);
+    const token = await (0, _testUtils.getToken)(url, key);
+    console.log('Getting current user...');
+    const userResp = await fetch(`${url}/users/current`, {
+      headers: {
+        Authorization: token
+      }
+    });
+    if (!userResp.ok) {
+      color.error(`Failed to get current user (HTTP ${userResp.status})`);
+      return false;
+    }
+    const user = await userResp.json();
+    const userId = user.id || user.Id;
+    if (!userId) {
+      color.error('No user id in response');
+      return false;
+    }
+    console.log(`Creating JIRA ticket for report ${reportId}...`);
+    const ticketResp = await fetch(`${url}/reports/${reportId}/jira?assigneeId=${userId}`, {
+      method: 'POST',
+      headers: {
+        Authorization: token,
+        'Content-Type': 'application/json'
+      }
+    });
+    if (ticketResp.status !== 200 && ticketResp.status !== 201) {
+      const body = await ticketResp.text();
+      color.error(`JIRA ticket creation failed (HTTP ${ticketResp.status}): ${body}`);
+      return false;
+    }
+    const result = await ticketResp.json();
+    const ticketKey = result.key;
+    if (!ticketKey) {
+      color.error(`No ticket key in response: ${JSON.stringify(result).slice(0, 200)}`);
+      return false;
+    }
+    color.success(`Created ticket: ${ticketKey}`);
+    console.log(ticketKey);
+    return true;
+  } catch (err) {
+    color.error(`Error: ${err.message}`);
+    return false;
+  }
+}

package/bin/grok.js

@@ -18,6 +18,7 @@ const commands = {
   init: require('./commands/init').init,
   link: require('./commands/link').link,
   publish: require('./commands/publish').publish,
+  report: require('./commands/report').report,
   test: require('./commands/test').test,
   testall: require('./commands/test-all').testAll,
   stresstest: require('./commands/stress-tests').stressTests,

package/package.json

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