datagrok-tools 6.1.5 → 6.1.7

package/CLAUDE.md

@@ -1,31 +1,12 @@
 # CLAUDE.md
 
-This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
-
 ## Overview
 
 This is **datagrok-tools**, a CLI utility for creating, validating, testing, and publishing packages to Datagrok. The tool is distributed as `grok` command globally via npm.
 
-## Build & Development Commands
-
-### Build the CLI
-```bash
-npm run build                    # Transpile TypeScript to JavaScript using Babel
-npm run debug-source-map         # Build with source maps for debugging
-```
-
-The build process uses Babel with `@babel/preset-typescript` to transpile TypeScript files from `bin/` to `bin/` (in-place). **Important:** `.ts` source and `.js` output coexist in the same `bin/` directory — `grok.js` requires the transpiled `.js` files, not the `.ts` sources. After editing any `.ts` file, you must run `npm run build` before testing.
-
-### Link for Local Development
-```bash
-npm link                         # Make 'grok' command available globally for testing
-```
+## Build Notes
 
-### Testing
-While this CLI tool manages testing for Datagrok packages, it doesn't have its own test suite. To test changes:
-1. Build the tool: `npm run build`
-2. Link it: `npm link`
-3. Test commands manually: `grok create test-package`, `grok check`, etc.
+The build process uses Babel with `@babel/preset-typescript` to transpile TypeScript files from `bin/` to `bin/` (in-place). `.ts` source and `.js` output coexist in the same `bin/` directory -- `grok.js` requires the transpiled `.js` files, not the `.ts` sources. After editing any `.ts` file, you must run `npm run build` before testing.
 
 ## Code Architecture
 
@@ -110,14 +91,32 @@ The `publish` command executes these steps:
 1. Gather files using `ignore-walk` (respects .npmignore/.gitignore/.grokignore)
 2. Run validation checks (signatures, imports, package.json, changelog)
 3. Process environment variables in `/connections/*.json` files (replace `${VAR}`)
-4. Create ZIP archive with archiver-promise
-5. Upload to server: `POST ${host}/packages/dev/${devKey}/${packageName}`
+4. **Process Docker images** (see below)
+5. Create ZIP archive with archiver-promise (includes `image.json` metadata per container)
+6. Upload to server: `POST ${host}/packages/dev/${devKey}/${packageName}`
 
 **Key flags:**
 - `--debug` (default) - Package visible only to developer
 - `--release` - Public package
 - `--build` / `--rebuild` - Control webpack bundling
 - `--skip-check` - Skip validation
+- `--rebuild-docker` - Force rebuild Docker images locally before pushing to registry
+- `--skip-docker-rebuild` - Skip auto-rebuild even when dockerfile folder has changed
+
+### Docker Image Handling in `publish`
+
+Implemented in `bin/commands/publish.ts` (`processDockerImages()`, `discoverDockerfiles()`).
+
+When a package has a `dockerfiles/` directory, `grok publish` automatically manages Docker images:
+
+1. **Discovery** — scans `dockerfiles/` for subdirectories containing a `Dockerfile`. Image name = `<packageName>-<folderName>`.
+2. **Change detection** — computes SHA256 of the entire dockerfile directory. If the hash differs from what the server has, rebuilds automatically (unless `--skip-docker-rebuild`).
+3. **Build** — `docker build --platform linux/amd64` (always cross-compiled for linux/amd64).
+4. **Registry** — tags and pushes to configured Docker registry if one is set.
+5. **Metadata** — writes `image.json` into the ZIP for each container so the server knows which image to use.
+6. **Fallback** — if a local build isn't available, queries the server for a compatible pre-built image.
+
+**Practical implication:** editing any file inside `dockerfiles/<name>/` will cause `grok publish` to rebuild that container image on the next publish, without needing `--rebuild-docker`.
 
 ### Testing Framework
 
@@ -273,16 +272,6 @@ servers:
     key: ''
 ```
 
-### Webpack Externals
-
-The CLI validates that imports match webpack externals to prevent bundling datagrok-api and other provided libraries. Common externals:
-- `datagrok-api`
-- `rxjs`
-- `cash-dom`
-- `dayjs`
-- `openchemlib/full`
-- `wu`
-
 ## File References
 
 When working with commands, key entry points are:

package/bin/commands/help.js

@@ -21,6 +21,8 @@ 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)
+    run         Build, publish, and open in browser
     test        Run package tests
     testall     Run packages tests
     migrate     Migrate legacy tags to meta.role
@@ -321,6 +323,42 @@ Examples:
 // file and converting your scripts in the \`package.json\` file
 // `;
 
+const HELP_RUN = `
+Usage: grok run [host]
+
+Build, publish, and open the package in the browser.
+
+Runs \`grok build\`, publishes the package to the server, then opens the server in the default browser.
+
+Options:
+[-k | --key] [--release] [-v | --verbose]
+
+--key       Developer key (overrides config)
+--release   Publish as a release version (default: debug)
+--verbose   Print detailed output
+
+Examples:
+  grok run              Build, publish to default server, and open browser
+  grok run dev          Build, publish to 'dev' server alias, and open browser
+  grok run https://my.datagrok.ai/api --key abc123
+`;
+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 +371,8 @@ const help = exports.help = {
   init: HELP_INIT,
   link: HELP_LINK,
   publish: HELP_PUBLISH,
+  report: HELP_REPORT,
+  run: HELP_RUN,
   test: HELP_TEST,
   testall: HELP_TESTALL,
   migrate: HELP_MIGRATE,

package/bin/commands/publish.js

@@ -60,6 +60,18 @@ function discoverDockerfiles(packageName, version, debug) {
       fullLocalName: `${imageName}:${imageTag}`
     });
   }
+
+  // Handle Dockerfile directly in dockerfiles/ (single-container layout)
+  const rootDockerfile = _path.default.join(dockerfilesDir, 'Dockerfile');
+  if (_fs.default.existsSync(rootDockerfile)) {
+    const cleanName = utils.removeScope(packageName).toLowerCase();
+    results.push({
+      imageName: cleanName,
+      imageTag: version,
+      dirName: '.',
+      fullLocalName: `${cleanName}:${version}`
+    });
+  }
   return results;
 }
 function dockerCommand(args) {

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/commands/run.js

@@ -0,0 +1,132 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.run = run;
+var _fs = _interopRequireDefault(require("fs"));
+var _os = _interopRequireDefault(require("os"));
+var _path = _interopRequireDefault(require("path"));
+var _child_process = require("child_process");
+var _jsYaml = _interopRequireDefault(require("js-yaml"));
+var utils = _interopRequireWildcard(require("../utils/utils"));
+var color = _interopRequireWildcard(require("../utils/color-utils"));
+var _publish = require("./publish");
+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 grokDir = _path.default.join(_os.default.homedir(), '.grok');
+const confPath = _path.default.join(grokDir, 'config.yaml');
+function getWebUrl(apiUrl) {
+  const u = new URL(apiUrl);
+  u.pathname = u.pathname.replace(/\/api\/?$/, '') || '/';
+  return u.toString().replace(/\/$/, '');
+}
+function openBrowser(url) {
+  let command;
+  switch (process.platform) {
+    case 'darwin':
+      command = `open "${url}"`;
+      break;
+    case 'win32':
+      command = `start "" "${url}"`;
+      break;
+    default:
+      command = `xdg-open "${url}"`;
+  }
+  (0, _child_process.exec)(command, err => {
+    if (err) color.warn(`Could not open browser: ${err.message}`);
+  });
+}
+const MISSING_MODULE_PATTERNS = ['cannot find module', 'module not found', 'can\'t resolve'];
+async function buildPackage(dir) {
+  const buildCmd = 'npm run build -- --env incremental';
+  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(buildCmd, dir, color.isVerbose());
+    color.success(`Successfully built ${name}`);
+    return true;
+  } catch (error) {
+    const msg = (error?.message ?? '').toLowerCase();
+    if (MISSING_MODULE_PATTERNS.some(p => msg.includes(p))) {
+      color.warn('Missing modules detected, running npm install...');
+      try {
+        await utils.runScript('npm install', dir, color.isVerbose());
+        await utils.runScript(buildCmd, dir, color.isVerbose());
+        color.success(`Successfully built ${name}`);
+        return true;
+      } catch (retryError) {
+        color.error(`Failed to build ${name}`);
+        if (retryError.message) color.error(retryError.message);
+        return false;
+      }
+    }
+    color.error(`Failed to build ${name}`);
+    if (error.message) color.error(error.message);
+    return false;
+  }
+}
+async function run(args) {
+  color.setVerbose(args.verbose || false);
+
+  // Step 1: Build (skip npm install to preserve npm link; retry with npm install only if needed)
+  const built = await buildPackage(process.cwd());
+  if (!built) return false;
+
+  // Step 2: Resolve server URL and key
+  if (!_fs.default.existsSync(confPath)) {
+    color.error(`Config not found at ${confPath}. Run \`grok config\` first.`);
+    return false;
+  }
+  const config = _jsYaml.default.load(_fs.default.readFileSync(confPath, {
+    encoding: 'utf-8'
+  }));
+  const urls = utils.mapURL(config);
+  let host = config.default;
+  if (args['_'].length === 2) host = args['_'][1];
+  let key = '';
+  let url = '';
+  let registry;
+  try {
+    url = new URL(host).href;
+    if (url.endsWith('/')) url = url.slice(0, -1);
+    if (url in urls) {
+      const alias = urls[url];
+      key = config['servers'][alias]['key'];
+      registry = config['servers'][alias]['registry'];
+    }
+  } catch (error) {
+    if (!(host in config.servers)) {
+      color.error(`Unknown server alias. Please add it to ${confPath}`);
+      return false;
+    }
+    url = config['servers'][host]['url'];
+    key = config['servers'][host]['key'];
+    registry = config['servers'][host]['registry'];
+  }
+  if (args.key) key = args.key;
+  if (key === '') {
+    color.warn('Please provide the key with `--key` option or add it by running `grok config`');
+    return false;
+  }
+  const packDir = _path.default.join(process.cwd(), 'package.json');
+  if (!_fs.default.existsSync(packDir)) {
+    color.error('`package.json` doesn\'t exist');
+    return false;
+  }
+  const packageName = JSON.parse(_fs.default.readFileSync(packDir, {
+    encoding: 'utf-8'
+  })).name;
+
+  // Step 3: Publish
+  process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
+  const code = await (0, _publish.processPackage)(!args.release, false, url, key, packageName, false, undefined, host, registry);
+  if (code !== 0) return false;
+
+  // Step 4: Open browser
+  const webUrl = getWebUrl(url);
+  color.success(`Opening ${webUrl}`);
+  openBrowser(webUrl);
+  return true;
+}

package/bin/grok.js

@@ -18,6 +18,8 @@ const commands = {
   init: require('./commands/init').init,
   link: require('./commands/link').link,
   publish: require('./commands/publish').publish,
+  report: require('./commands/report').report,
+  run: require('./commands/run').run,
   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.5",
+  "version": "6.1.7",
   "description": "Utility to upload and publish packages to Datagrok",
   "homepage": "https://github.com/datagrok-ai/public/tree/master/tools#readme",
   "dependencies": {