datagrok-tools 6.1.6 → 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

@@ -22,6 +22,7 @@ Commands:
     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
@@ -322,6 +323,25 @@ 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>
 
@@ -352,6 +372,7 @@ const help = exports.help = {
   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/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

@@ -19,6 +19,7 @@ const commands = {
   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.6",
+  "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": {