datagrok-tools 6.4.8 → 6.5.1

package/CHANGELOG.md

@@ -1,8 +1,17 @@
 # Datagrok-tools changelog
 
+## 6.5.1 (2026-07-22)
+
+* `grok test` — the Node-pass report now merges into the browser report by column name. The line-wise merge assumed identical column order, so node rows landed misaligned (string values in the integer `ms` column) and the CI test-report upload failed with `invalid input syntax for type integer`.
+
+## 6.5.0 (WIP)
+
+* `grok test` — added a Node (browserless) pass: tests annotated `{node: true}` run headless under the js-api Node runtime before the browser launches; the browser pass excludes them and is skipped entirely when nothing browser-only matches. New flags: `--skip-node`, `--node-only`. Packages opt in by exporting `testNode()` from `package-test.ts`; others keep the previous behavior.
+
 ## 6.4.8 (2026-07-22)
 
 * GROK-20452: `grok publish` — always `docker build` the tools-generated worker dirs (`dockerfiles/queue`, `dockerfiles/celery`, `dockerfiles/<app>-celery`) instead of reusing a cached local tag. The "found local image" shortcut froze the worker at whatever stock base the daemon had when the tag was first built (CI ran day-old worker code with a fresh base available); the layer cache keeps an unchanged rebuild near-instant.
+* `grok test` — `--no-retry` is now honored for Playwright runs. minimist parsed `--no-retry` as `{retry:false}`, so the flag was silently dropped and failed specs were still retried once; normalized so `--retries=0` reaches Playwright.
 
 ## 6.4.7 (2026-07-22)
 
@@ -11,7 +20,6 @@
 ## 6.4.6 (2026-07-22)
 
 * `grok test` — the whole-run Puppeteer cap (60 min) is now overridable via `GROK_TEST_INVOCATION_TIMEOUT_MS`. When the cap fires mid-pass all collected results are discarded (empty `test-report.csv`, "Passed tests: 0"), which CI reports as "no results produced"; loaded CI agents can now raise the cap instead.
-* `grok test` — `--no-retry` is now honored for Playwright runs. minimist parsed `--no-retry` as `{retry:false}`, so the flag was silently dropped and failed specs were still retried once; normalized so `--retries=0` reaches Playwright.
 
 ## 6.4.5 (2026-06-23)
 

package/README.md

@@ -135,6 +135,8 @@ For more information on configuring connections, refer to the [Connections](http
   | report         | Sends a report on test results                                                                                                        |
   | skip-build     | Skips package build step                                                                                                              |
   | skip-publish   | Skips package publish step                                                                                                            |
+  | skip-node      | Skips the Node (browserless) pass; runs all tests in the browser                                                                      |
+  | node-only      | Runs only tests annotated `{node: true}` headless under Node, without a browser                                                       |
   | verbose        | Prints detailed information about passed and skipped tests in the console                                                             |
   | platform       | Runs only platform tests (applicable for ApiTests package only)                                                                       |
   | core           | Runs package & core tests & autotests                                                                                                 |

package/bin/commands/help.js

@@ -207,6 +207,8 @@ Options:
 --skip-publish      Skip the package publication step
 --skip-puppeteer    Skip the Puppeteer/DG.Test pass; only run Playwright (for playwright-only test directories)
 --skip-playwright   Skip the Playwright pass; only run Puppeteer/DG.Test
+--skip-node         Skip the Node (browserless) pass; run all tests in the browser
+--node-only         Run only tests annotated {node: true} headless under Node, no browser
 --link  	        Link the package to local utils
 --record            Records the test execution process in mp4 format
 --platform          Runs only platform tests (applicable for ApiTests package only)

package/bin/commands/test.js

@@ -20,6 +20,7 @@ var Papa = _interopRequireWildcard(require("papaparse"));
 var _testUtils = _interopRequireWildcard(require("../utils/test-utils"));
 var testUtils = _testUtils;
 var playwrightRunner = _interopRequireWildcard(require("../utils/playwright-runner"));
+var _nodeTestRunner = require("../utils/node-test-runner");
 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); }
 /* eslint-disable max-len */
 
@@ -29,7 +30,7 @@ const execFileAsync = (0, _util.promisify)(_child_process.execFile);
 // are discarded (they live in the page until a pass completes). CI runners on
 // loaded agents can exceed the 1h default — override via env.
 const testInvocationTimeout = parseInt(process.env['GROK_TEST_INVOCATION_TIMEOUT_MS'] ?? '', 10) || 3600000;
-const availableCommandOptions = ['host', 'package', 'csv', 'gui', 'catchUnhandled', 'platform', 'core', 'report', 'skip-build', 'skip-publish', 'path', 'record', 'verbose', 'benchmark', 'category', 'test', 'stress-test', 'link', 'tag', 'ci-cd', 'debug', 'no-retry', 'dartium', 'f', 'params', 'logfailed', 'skip-playwright', 'skip-puppeteer'];
+const availableCommandOptions = ['host', 'package', 'csv', 'gui', 'catchUnhandled', 'platform', 'core', 'report', 'skip-build', 'skip-publish', 'path', 'record', 'verbose', 'benchmark', 'category', 'test', 'stress-test', 'link', 'tag', 'ci-cd', 'debug', 'no-retry', 'dartium', 'f', 'params', 'logfailed', 'skip-playwright', 'skip-puppeteer', 'skip-node', 'node-only'];
 const curDir = process.cwd();
 
 /** Expands camelCase to space-separated lowercase: "dataManipulation" → "data manipulation" */
@@ -228,12 +229,34 @@ async function test(args) {
     }
   }
   process.env.TARGET_PACKAGE = packageName;
+
+  // Node (browserless) pass: runs tests annotated {node: true} headless under the
+  // js-api Node runtime; the browser pass then excludes them. Skipped for --gui/--debug
+  // so every test stays visible in the browser there.
+  let nodeRes = undefined;
+  if (!args['skip-node'] && !args['skip-puppeteer'] && !args.gui && !args.debug && !args.package) {
+    nodeRes = await (0, _nodeTestRunner.runNodeTests)({
+      packageDir: curDir,
+      packageName: packageName,
+      host: args.host ?? '',
+      category: args.category,
+      test: args.test,
+      stressTest: args['stress-test'],
+      benchmark: args.benchmark,
+      verbose: args.verbose
+    });
+  }
+  if (args['node-only'] && nodeRes == null) {
+    color.error('--node-only: the Node test pass is not available for this package.');
+    process.exit(1);
+  }
   let res;
-  if (args['skip-puppeteer']) {
+  if (args['skip-puppeteer'] || args['node-only'] || nodeRes != null && nodeRes.browserTestsRemaining === 0) {
     // Playwright-only mode: skip the Puppeteer browser launch + DG.Test runner.
     // Used by Playwright-only test directories (e.g. public/playwright-public)
     // that have a `playwrightTests` field in package.json but no Dart/JS package
-    // tests on the server.
+    // tests on the server. Also taken when the Node pass covered every matched test.
+    if (nodeRes != null && nodeRes.browserTestsRemaining === 0 && !args['node-only'] && !args['skip-puppeteer']) color.info('All matched tests ran in the Node pass; skipping the browser run.');
     res = {
       failed: false,
       verbosePassed: '',
@@ -246,7 +269,7 @@ async function test(args) {
     };
   } else {
     try {
-      res = await runTesting(args);
+      res = await runTesting(args, nodeRes != null);
     } catch (e) {
       // Don't let Puppeteer-side failures (login error, browser crash) skip the
       // Playwright pass — the two suites have independent auth and runtime paths,
@@ -265,7 +288,21 @@ async function test(args) {
       };
     }
   }
-  if (!args['skip-playwright']) {
+  if (nodeRes != null) {
+    // Merge the Node pass into the browser result. CSVs merge by column NAME —
+    // the two passes emit different column orders, and a line-wise concat would
+    // misalign rows (string values in integer columns break the report upload).
+    res.csv = testUtils.mergeCsvByHeader(res.csv, nodeRes.csv);
+    res.passedAmount += nodeRes.passedAmount;
+    res.failedAmount += nodeRes.failedAmount;
+    res.skippedAmount += nodeRes.skippedAmount;
+    res.failed = res.failed || nodeRes.failed;
+    res.verbosePassed = (res.verbosePassed || '') + nodeRes.verbosePassed;
+    res.verboseFailed = (res.verboseFailed || '') + nodeRes.verboseFailed;
+    res.verboseSkipped = (res.verboseSkipped || '') + nodeRes.verboseSkipped;
+    res.modernOutput = res.modernOutput || nodeRes.modernOutput;
+  }
+  if (!args['skip-playwright'] && !args['node-only']) {
     const ptDir = playwrightRunner.hasPlaywrightTests(curDir);
     if (ptDir) {
       const ptRes = await playwrightRunner.runPlaywrightTests(curDir, ptDir, args, args.host ?? '');
@@ -312,7 +349,7 @@ const retriedTests = new Set();
 let totalRetries = 0;
 const MAX_RETRIES_PER_SESSION = 10;
 let retryEnabled = true;
-async function runTesting(args) {
+async function runTesting(args, excludeNodeTests = false) {
   retryEnabled = args['retry'] ?? true;
   if (args.test || args.category) retryEnabled = false;
   let organized = {
@@ -320,6 +357,7 @@ async function runTesting(args) {
     params: {
       category: args.category ?? '',
       test: args.test ?? '',
+      excludeNodeTests: excludeNodeTests || undefined,
       options: {
         catchUnhandled: args.catchUnhandled,
         report: args.report
@@ -956,6 +994,8 @@ function buildTestArgs(args) {
   if (args['stress-test']) parts.push('--stress-test');
   if (args['ci-cd']) parts.push('--ci-cd');
   if (args['no-retry']) parts.push('--no-retry');
+  if (args['skip-node']) parts.push('--skip-node');
+  if (args['node-only']) parts.push('--node-only');
   return parts;
 }
 function parseTestOutput(stdout) {

package/bin/utils/node-test-runner.js

@@ -0,0 +1,121 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.runNodeTests = runNodeTests;
+var _child_process = require("child_process");
+var _fs = _interopRequireDefault(require("fs"));
+var _os = _interopRequireDefault(require("os"));
+var _path = _interopRequireDefault(require("path"));
+var _readline = _interopRequireDefault(require("readline"));
+var color = _interopRequireWildcard(require("./color-utils"));
+var _testUtils = require("./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); }
+/* eslint-disable max-len */
+/**
+ * CLI side of the `grok test` Node (browserless) pass: spawns node-test-worker.js
+ * with cwd = the package directory, streams its progress output through the shared
+ * TestProgressReporter, and returns a ResultObject-compatible report.
+ *
+ * Returns undefined when the package doesn't support the Node pass (no testNode export,
+ * no datagrok-api Node runtime, not published) or the worker fails — the caller then
+ * runs everything in the browser as before.
+ */
+
+const workerTimeout = 3600000;
+async function runNodeTests(opts) {
+  // Cheap opt-in gate: don't pay the worker spawn + runtime init for the vast
+  // majority of packages that don't export testNode() from package-test.ts.
+  try {
+    const testSrc = ['ts', 'js'].map(ext => _path.default.join(opts.packageDir, 'src', `package-test.${ext}`)).find(p => _fs.default.existsSync(p));
+    if (testSrc != null && !_fs.default.readFileSync(testSrc, 'utf8').includes('testNode')) return undefined;
+  } catch {}
+  let url;
+  let key;
+  try {
+    ({
+      url,
+      key
+    } = (0, _testUtils.getDevKey)(opts.host));
+  } catch (e) {
+    color.warn(`Node test pass skipped: ${e?.message ?? e}`);
+    return undefined;
+  }
+  const token = await (0, _testUtils.getToken)(url, key);
+  const workerPath = _path.default.join(__dirname, 'node-test-worker.js');
+  const outPath = _path.default.join(_os.default.tmpdir(), `grok-node-test-${Date.now()}-${process.pid}.json`);
+  const args = [workerPath, `--out=${outPath}`];
+  if (opts.category) args.push(`--category=${opts.category}`);
+  if (opts.test) args.push(`--test=${opts.test}`);
+  if (opts.stressTest) args.push('--stress-test');
+  if (opts.benchmark) args.push('--benchmark');
+  if (opts.verbose) args.push('--verbose');
+  color.info('Running Node (browserless) test pass...');
+  const reporter = new _testUtils.TestProgressReporter(opts.verbose ?? false);
+  const stderrTail = [];
+  const exitCode = await new Promise(resolve => {
+    const child = (0, _child_process.spawn)(process.execPath, args, {
+      cwd: opts.packageDir,
+      env: {
+        ...process.env,
+        DG_API_URL: url,
+        DG_API_TOKEN: token,
+        TARGET_PACKAGE: opts.packageName
+      },
+      stdio: ['ignore', 'pipe', 'pipe']
+    });
+    const killTimer = setTimeout(() => {
+      color.error(`Node test pass timed out after ${workerTimeout / 1000}s. Killing worker.`);
+      child.kill();
+    }, workerTimeout);
+    const rlOut = _readline.default.createInterface({
+      input: child.stdout
+    });
+    rlOut.on('line', line => {
+      if (line.startsWith('Package testing: ')) reporter.onLine(line);else if (line.startsWith('Node pass unavailable: ')) color.info(line);else if (opts.verbose) console.log(line);
+    });
+    const rlErr = _readline.default.createInterface({
+      input: child.stderr
+    });
+    rlErr.on('line', line => {
+      stderrTail.push(line);
+      if (stderrTail.length > 50) stderrTail.shift();
+      if (opts.verbose) console.error(line);
+    });
+    child.on('close', code => {
+      clearTimeout(killTimer);
+      rlOut.close();
+      rlErr.close();
+      resolve(code ?? 2);
+    });
+    child.on('error', e => {
+      clearTimeout(killTimer);
+      color.warn(`Failed to spawn Node test worker: ${e.message}`);
+      resolve(2);
+    });
+  });
+  reporter.finish();
+  if (exitCode === 3) {
+    color.info('Node test pass is not supported here; running all tests in the browser.');
+    return undefined;
+  }
+  if (exitCode !== 0) {
+    if (!opts.verbose && stderrTail.length > 0) console.error(stderrTail.join('\n'));
+    color.warn(`Node test pass failed (exit code ${exitCode}); running all tests in the browser.`);
+    return undefined;
+  }
+  try {
+    const report = JSON.parse(_fs.default.readFileSync(outPath, 'utf8'));
+    _fs.default.unlinkSync(outPath);
+    color.info(`Node pass: ${report.passedAmount} passed, ${report.failedAmount} failed, ${report.skippedAmount} skipped; ` + `${report.browserTestsRemaining} test(s) left for the browser.`);
+    return {
+      ...report,
+      modernOutput: true
+    };
+  } catch (e) {
+    color.warn(`Could not read Node test report: ${e?.message ?? e}; running all tests in the browser.`);
+    return undefined;
+  }
+}

package/bin/utils/node-test-worker.js

@@ -0,0 +1,210 @@
+"use strict";
+
+var vm = _interopRequireWildcard(require("vm"));
+var fs = _interopRequireWildcard(require("fs"));
+var path = _interopRequireWildcard(require("path"));
+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); }
+/* eslint-disable max-len */
+/**
+ * Standalone worker for the `grok test` Node (browserless) pass.
+ *
+ * Spawned by node-test-runner.ts with cwd = the package directory:
+ * 1. loads the js-api Node runtime (`datagrok-api/datagrok`) from the package's own node_modules,
+ * 2. resolves the published package version the platform would serve and evaluates its
+ *    `dist/package-test.js` bundle (webpack var-library `<name>_test`),
+ * 3. runs init-tagged functions of the test bundle, then calls its exported `testNode()`
+ *    which executes only tests marked `{node: true}`,
+ * 4. counts the tests the browser pass still has to run, and writes a JSON report to --out.
+ *
+ * Exit codes: 0 = pass executed (test failures are conveyed in the report),
+ * 3 = Node pass unsupported for this package (caller falls back to the browser for everything),
+ * anything else = infrastructure error.
+ */
+
+const UNSUPPORTED_EXIT_CODE = 3;
+const RESULT_COLUMNS = ['date', 'category', 'name', 'success', 'result', 'ms', 'skipped', 'logs', 'owner', 'package', 'widgetsDifference', 'flaking'];
+function getArg(name) {
+  const prefix = `--${name}=`;
+  const arg = process.argv.find(a => a.startsWith(prefix));
+  return arg ? arg.slice(prefix.length) : undefined;
+}
+function hasFlag(name) {
+  return process.argv.includes(`--${name}`);
+}
+function unsupported(reason) {
+  console.log(`Node pass unavailable: ${reason}`);
+  process.exit(UNSUPPORTED_EXIT_CODE);
+}
+
+// A crashing async callback (e.g. a socket handler inside the Dart runtime) must not
+// kill the whole pass — log it and let the per-test timeout fail the affected test.
+process.on('uncaughtException', err => {
+  console.error('Uncaught exception:', err?.stack ?? err);
+});
+process.on('unhandledRejection', reason => {
+  console.error('Unhandled rejection:', reason);
+});
+async function main() {
+  const apiUrl = process.env.DG_API_URL;
+  const token = process.env.DG_API_TOKEN;
+  const packageName = process.env.TARGET_PACKAGE;
+  const outPath = getArg('out');
+  const categoryArg = getArg('category');
+  const testArg = getArg('test');
+  const stressTest = hasFlag('stress-test');
+  const benchmark = hasFlag('benchmark');
+  const verbose = hasFlag('verbose');
+  let dgEntry;
+  try {
+    dgEntry = require.resolve('datagrok-api/datagrok', {
+      paths: [process.cwd()]
+    });
+  } catch {
+    unsupported('the installed datagrok-api has no Node runtime (datagrok-api/datagrok)');
+  }
+  const dgApi = require(dgEntry);
+  if (typeof dgApi.startDatagrok !== 'function') unsupported('the installed datagrok-api has no startDatagrok()');
+  await dgApi.startDatagrok({
+    apiUrl,
+    apiToken: token
+  });
+  const g = globalThis;
+  const grok = g.grok;
+  const DG = g.DG;
+
+  // Package bundles map webpack externals to browser globals (rxjs, rxjs.operators,
+  // dayjs, utc, wu, $). The Node runtime guarantees DG/grok/ui; provide the rest
+  // from datagrok-api's own dependencies so bundle evaluation doesn't throw.
+  const req = id => require(require.resolve(id, {
+    paths: [path.dirname(dgEntry), process.cwd()]
+  }));
+  const ensureGlobal = (name, resolve) => {
+    if (g[name] == null) try {
+      g[name] = resolve();
+    } catch {}
+  };
+  ensureGlobal('rxjs', () => req('rxjs'));
+  if (g.rxjs != null && g.rxjs.operators == null) try {
+    g.rxjs = Object.assign({}, g.rxjs, {
+      operators: req('rxjs/operators')
+    });
+  } catch {}
+  ensureGlobal('dayjs', () => req('dayjs'));
+  ensureGlobal('utc', () => req('dayjs/plugin/utc'));
+  ensureGlobal('wu', () => req('wu'));
+  ensureGlobal('$', () => req('cash-dom'));
+
+  // Resolve the published version the platform would serve: the caller's debug version
+  // if one exists, else the current one (mirrors js-api's Node loadPackage()).
+  const headers = {
+    Authorization: token
+  };
+  const listResp = await fetch(`${apiUrl}/packages?text=${encodeURIComponent(packageName)}`, {
+    headers
+  });
+  if (!listResp.ok) throw new Error(`Failed to list packages: HTTP ${listResp.status}`);
+  const packages = await listResp.json();
+  const pkgInfo = packages.find(p => p.name?.toLowerCase() === packageName.toLowerCase());
+  if (!pkgInfo) unsupported(`package "${packageName}" is not published on ${apiUrl}`);
+  const versions = pkgInfo.publishedVersions ?? [];
+  const login = (await grok.dapi.users.current()).login;
+  const cur = versions.find(v => v.debug && v.version === login) ?? versions.find(v => v.isCurrent) ?? versions.find(v => v.isLatest) ?? versions[0];
+  if (!cur) unsupported(`package "${packageName}" has no published versions`);
+  const webRoot = `${apiUrl}/packages/published/files/${pkgInfo.name}/${cur.version}/${cur.buildHash}/${cur.buildNumber}/`;
+  const jsUrl = `${webRoot}dist/package-test.js`;
+  const codeResp = await fetch(jsUrl, {
+    headers
+  });
+  if (!codeResp.ok) unsupported(`no test bundle at ${jsUrl} (HTTP ${codeResp.status})`);
+  vm.runInThisContext(await codeResp.text(), {
+    filename: jsUrl
+  });
+  const moduleName = `${packageName.toLowerCase()}_test`;
+  const testModule = g[moduleName] ?? g[Object.keys(g).find(k => k.endsWith('_test') && g[k]?.tests) ?? ''];
+  if (!testModule?.tests) unsupported(`test bundle did not define a "${moduleName}" module`);
+  if (typeof testModule.testNode !== 'function') unsupported('package-test.ts does not export testNode()');
+  if (testModule._package != null) {
+    testModule._package.webRoot = webRoot;
+    testModule._package.name = pkgInfo.name;
+    testModule._package.version = cur.version;
+  }
+
+  // The package must carry the resolved published-version id: functions are attached to
+  // package versions, and runTests' initAutoTests filters `package.id = <id>` to register
+  // the annotation-driven auto tests. The family-level entity id matches nothing.
+  const pkg = (await grok.dapi.packages.find(cur.id)) ?? (await grok.dapi.packages.filter(`shortName = "${pkgInfo.name}"`).first());
+  if (!pkg) unsupported(`package entity "${pkgInfo.name}" not found`);
+  try {
+    if (pkg.name !== pkgInfo.name) pkg.name = pkgInfo.name;
+  } catch {}
+  if (benchmark) DG.Test.isInBenchmark = true;
+  const results = await testModule.testNode(pkg, {
+    category: categoryArg,
+    test: testArg,
+    stressTest,
+    verbose
+  });
+
+  // Count what the browser pass still has to run. testNode() ran initAutoTests(), so the
+  // registry now also holds the annotation-driven auto/demo/detector tests.
+  let browserTestsRemaining = 0;
+  for (const [catName, cat] of Object.entries(testModule.tests)) {
+    if (categoryArg != null && !catName.toLowerCase().startsWith(categoryArg.toLowerCase().trim())) continue;
+    for (const t of cat.tests ?? []) {
+      if (testArg != null && t.name.toLowerCase() !== testArg.toLowerCase()) continue;
+      if (benchmark && !t.options?.benchmark) continue;
+      if (stressTest && !t.options?.stressTest) continue;
+      if (!(t.options?.node ?? cat.node ?? false)) browserTestsRemaining++;
+    }
+  }
+
+  // Shape the report like the browser pass does — same CSV columns in the same order,
+  // so the two passes merge row-wise.
+  const Papa = require('papaparse');
+  const rows = results.map(r => {
+    const row = {};
+    for (const c of RESULT_COLUMNS) row[c] = r[c] ?? (c === 'widgetsDifference' ? 0 : '');
+    return row;
+  });
+  let failed = false;
+  let passedAmount = 0;
+  let skippedAmount = 0;
+  let failedAmount = 0;
+  let verbosePassed = '';
+  let verboseSkipped = '';
+  let verboseFailed = '';
+  for (const r of results) {
+    const line = `${r.category}: ${r.name} (${r.ms} ms) :  ${r.result}\n`;
+    if (r.skipped) {
+      skippedAmount++;
+      verboseSkipped += line;
+    } else if (r.success) {
+      passedAmount++;
+      verbosePassed += line;
+    } else {
+      failedAmount++;
+      verboseFailed += line;
+      failed = true;
+    }
+  }
+  const report = {
+    failed,
+    verbosePassed,
+    verboseSkipped,
+    verboseFailed,
+    passedAmount,
+    skippedAmount,
+    failedAmount,
+    csv: rows.length ? Papa.unparse(rows, {
+      columns: RESULT_COLUMNS
+    }) : '',
+    browserTestsRemaining,
+    nodeTestsRun: results.length
+  };
+  fs.writeFileSync(outPath, JSON.stringify(report), 'utf8');
+  process.exit(0);
+}
+main().catch(e => {
+  console.error(e?.stack ?? e?.message ?? String(e));
+  process.exit(2);
+});

package/bin/utils/test-utils.js

@@ -4,7 +4,7 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.TestContext = void 0;
+exports.TestProgressReporter = exports.TestContext = void 0;
 exports.addColumnToCsv = addColumnToCsv;
 exports.addLogsToFile = addLogsToFile;
 exports.defaultLaunchParameters = void 0;
@@ -20,6 +20,7 @@ exports.loadPackage = loadPackage;
 exports.loadPackages = loadPackages;
 exports.loadTestsList = loadTestsList;
 exports.mergeBrowsersResults = mergeBrowsersResults;
+exports.mergeCsvByHeader = mergeCsvByHeader;
 exports.printBrowsersResult = printBrowsersResult;
 exports.runBrowser = runBrowser;
 exports.runWithTimeout = runWithTimeout;
@@ -363,6 +364,132 @@ async function loadTestsList(packages, core = false, record = false) {
 function addLogsToFile(filePath, stringToSave) {
   _fs.default.appendFileSync(filePath, `${stringToSave}`);
 }
+
+/**
+ * Parses the `Package testing: ...` progress lines emitted by the
+ * @datagrok-libraries/test runner and prints live per-category summaries.
+ * Used for both the Puppeteer console stream and the Node-pass worker stdout.
+ */
+class TestProgressReporter {
+  modernOutput = false;
+  categoryResults = new Map();
+  currentCategory = null;
+  pendingFailures = [];
+  pendingSkipped = [];
+  pendingBeforeFailure = null;
+  pendingAfterFailure = null;
+  constructor(verbose = false) {
+    this.verbose = verbose;
+  }
+  printCategorySummary(category) {
+    const results = this.categoryResults.get(category);
+    if (!results) return;
+    const passedCount = results.passed;
+    const skippedSuffix = results.skipped > 0 ? `, \x1b[33m${results.skipped} skipped\x1b[0m` : '';
+    if (results.failed > 0 || this.pendingBeforeFailure || this.pendingAfterFailure) {
+      console.log(`\x1b[31m❌ ${category}\x1b[31m (\x1b[32m${passedCount} passed${skippedSuffix}\x1b[31m)\x1b[0m`);
+      if (this.pendingBeforeFailure) {
+        console.log(`  \x1b[31m❌ before\x1b[0m`);
+        if (this.pendingBeforeFailure.error) console.log(`    \x1b[31m${this.pendingBeforeFailure.error}\x1b[0m`);
+        console.log(`    \x1b[33mTo run this category separately use --category "${category}"\x1b[0m`);
+      }
+      if (this.pendingAfterFailure) {
+        console.log(`  \x1b[31m❌ after\x1b[0m`);
+        if (this.pendingAfterFailure.error) console.log(`    \x1b[31m${this.pendingAfterFailure.error}\x1b[0m`);
+        console.log(`    \x1b[33mTo run this category separately use --category "${category}"\x1b[0m`);
+      }
+      for (const skippedName of this.pendingSkipped) console.log(`  \x1b[33m⊘ ${skippedName}\x1b[0m`);
+      for (const failure of this.pendingFailures) {
+        console.log(`  \x1b[31m❌ ${failure.testName}\x1b[0m`);
+        if (failure.error) console.log(`    \x1b[31m${failure.error}\x1b[0m`);
+        console.log(`    \x1b[33mTo run this test separately use --category "${category}" --test "${failure.testName}"\x1b[0m`);
+      }
+    } else {
+      console.log(`\x1b[32m✅ ${category} (${passedCount} passed${skippedSuffix}\x1b[32m)\x1b[0m`);
+      for (const skippedName of this.pendingSkipped) console.log(`  \x1b[33m⊘ ${skippedName}\x1b[0m`);
+    }
+    this.pendingFailures = [];
+    this.pendingSkipped = [];
+    this.pendingBeforeFailure = null;
+    this.pendingAfterFailure = null;
+  }
+  onLine(text) {
+    if (!text.startsWith('Package testing: ')) return;
+    this.modernOutput = true;
+    // Extract tokens in {{...}} format
+    const tokens = [];
+    const tokenRegex = /\{\{([^}]+)\}\}/g;
+    let match;
+    while ((match = tokenRegex.exec(text)) !== null) tokens.push(match[1]);
+
+    // Category start: "Package testing: Started {{Category}}" or "Package testing: Started {{Category}} skipped {{N}}"
+    if (text.includes('Started') && (tokens.length === 1 || tokens.length === 2 && text.includes('skipped'))) {
+      if (this.currentCategory && this.categoryResults.has(this.currentCategory)) this.printCategorySummary(this.currentCategory);
+      this.currentCategory = tokens[0];
+      const skippedCount = tokens.length === 2 ? parseInt(tokens[1]) || 0 : 0;
+      this.categoryResults.set(this.currentCategory, {
+        passed: 0,
+        failed: 0,
+        skipped: skippedCount
+      });
+      this.pendingFailures = [];
+      this.pendingSkipped = [];
+      this.pendingBeforeFailure = null;
+      this.pendingAfterFailure = null;
+    } else if (text.includes('Skipped') && tokens.length === 2 && !text.includes('benchmark')) {
+      // Individual skipped test: "Package testing: Skipped {{Category}} {{TestName}}"
+      if (tokens[0] === this.currentCategory) this.pendingSkipped.push(tokens[1]);
+    } else if (text.includes('Started') && tokens.length === 2) {
+      // Test start: "Package testing: Started {{Category}} {{TestName}}"
+      process.stdout.write(`${tokens[0]}: ${tokens[1]}...`);
+    } else if (text.includes('Finished') && tokens.length === 3) {
+      // Test finish: "Package testing: Finished {{Category}} {{TestName}} with {{success/error}} for X ms"
+      const results = this.categoryResults.get(tokens[0]);
+      if (!this.verbose) process.stdout.write('\r\x1b[K');
+      if (tokens[2] === 'success') {
+        if (results) results.passed++;
+      } else {
+        if (results) results.failed++;
+        this.pendingFailures.push({
+          testName: tokens[1],
+          error: null
+        });
+      }
+    } else if (text.includes('Result for') && tokens.length === 2) {
+      // Error result: "Package testing: Result for {{Category}} {{TestName}}: error message"
+      const errorMsg = text.split(': ').slice(-1)[0];
+      if (this.pendingFailures.length > 0) this.pendingFailures[this.pendingFailures.length - 1].error = errorMsg;
+    } else if (text.includes('Category before()') && text.includes('failed') && tokens.length >= 1) {
+      // Category before() failed: "Package testing: Category before() {{Category}} failed"
+      process.stdout.write('\r\x1b[K');
+      this.pendingBeforeFailure = {
+        error: null
+      };
+    } else if (text.includes('Result for') && text.includes('before:') && tokens.length >= 1) {
+      // Before error result: "Package testing: Result for {{Category}} before: error message"
+      const errorMsg = text.split('before: ').slice(-1)[0];
+      if (this.pendingBeforeFailure) this.pendingBeforeFailure.error = errorMsg;
+    } else if (text.includes('Category after()') && text.includes('failed') && tokens.length >= 1) {
+      // Category after() failed: "Package testing: Category after() {{Category}} failed"
+      process.stdout.write('\r\x1b[K');
+      this.pendingAfterFailure = {
+        error: null
+      };
+    } else if (text.includes('Result for') && text.includes('after:') && tokens.length >= 1) {
+      // After error result: "Package testing: Result for {{Category}} after: error message"
+      const errorMsg = text.split('after: ').slice(-1)[0];
+      if (this.pendingAfterFailure) this.pendingAfterFailure.error = errorMsg;
+    } else if (text.includes('Unhandled Exception')) {
+      process.stdout.write('\r\x1b[K\n');
+      const errorMsg = text.replace('Package testing: Unhandled Exception: ', '');
+      if (errorMsg && errorMsg !== 'null') console.log(`\x1b[31m❌ Unhandled Exception: ${errorMsg}\x1b[0m`);
+    }
+  }
+  finish() {
+    if (this.currentCategory && this.categoryResults.has(this.currentCategory)) this.printCategorySummary(this.currentCategory);
+  }
+}
+exports.TestProgressReporter = TestProgressReporter;
 function printBrowsersResult(browserResult, verbose = false) {
   // Skip detailed summary if modernOutput was used (already printed per-category)
   if (!browserResult.modernOutput) {
@@ -414,8 +541,9 @@ async function runTests(testParams) {
   let countSkipped = 0;
   let countFailed = 0;
   try {
-    // Check if retry is supported by looking for skipToCategory parameter
+    // Check feature support by looking at the test function's declared inputs
     let retrySupported = false;
+    let excludeNodeSupported = false;
     try {
       const funcs = window.DG.Func.find({
         package: testParams.package,
@@ -424,6 +552,7 @@ async function runTests(testParams) {
       if (funcs && funcs.length > 0) {
         const testFunc = funcs[0];
         retrySupported = testFunc.inputs?.some(input => input.name === 'skipToCategory') === true;
+        excludeNodeSupported = testFunc.inputs?.some(input => input.name === 'excludeNodeTests') === true;
       }
     } catch (e) {
       retrySupported = false;
@@ -431,6 +560,8 @@ async function runTests(testParams) {
     const testCallParams = {};
     if (testParams.params?.category) testCallParams.category = testParams.params.category;
     if (testParams.params?.test) testCallParams.test = testParams.params.test;
+    // Skip node-marked tests in the browser only when the Node pass already ran them
+    if (testParams.params?.excludeNodeTests && excludeNodeSupported) testCallParams.excludeNodeTests = true;
     // Only pass retry-related params if supported
     if (retrySupported) {
       if (testParams.params?.skipToCategory) testCallParams.skipToCategory = testParams.params.skipToCategory;
@@ -692,54 +823,8 @@ async function runBrowser(testExecutionData, browserOptions, browsersId, testInv
       });
     }
 
-    // State tracking for test output formatting
-    const categoryResults = new Map();
-    let currentCategory = null;
-    let currentTestName = null;
-    // Store failed tests with their errors to print after category header
-    let pendingFailures = [];
-    let pendingSkipped = [];
-    let pendingBeforeFailure = null;
-    let pendingAfterFailure = null;
-    let modernOutput = false;
-    const printCategorySummary = category => {
-      const results = categoryResults.get(category);
-      if (!results) return;
-      const formattedCategory = category;
-      const passedCount = results.passed;
-      const skippedSuffix = results.skipped > 0 ? `, \x1b[33m${results.skipped} skipped\x1b[0m` : '';
-      if (results.failed > 0 || pendingBeforeFailure || pendingAfterFailure) {
-        console.log(`\x1b[31m❌ ${formattedCategory}\x1b[31m (\x1b[32m${passedCount} passed${skippedSuffix}\x1b[31m)\x1b[0m`);
-        // Print before() failure first
-        if (pendingBeforeFailure) {
-          console.log(`  \x1b[31m❌ before\x1b[0m`);
-          if (pendingBeforeFailure.error) console.log(`    \x1b[31m${pendingBeforeFailure.error}\x1b[0m`);
-          console.log(`    \x1b[33mTo run this category separately use --category "${category}"\x1b[0m`);
-        }
-        // Print after() failure
-        if (pendingAfterFailure) {
-          console.log(`  \x1b[31m❌ after\x1b[0m`);
-          if (pendingAfterFailure.error) console.log(`    \x1b[31m${pendingAfterFailure.error}\x1b[0m`);
-          console.log(`    \x1b[33mTo run this category separately use --category "${category}"\x1b[0m`);
-        }
-        // Print skipped tests
-        for (const skippedName of pendingSkipped) console.log(`  \x1b[33m⊘ ${skippedName}\x1b[0m`);
-        // Print test failures
-        for (const failure of pendingFailures) {
-          console.log(`  \x1b[31m❌ ${failure.testName}\x1b[0m`);
-          if (failure.error) console.log(`    \x1b[31m${failure.error}\x1b[0m`);
-          console.log(`    \x1b[33mTo run this test separately use --category "${category}" --test "${failure.testName}"\x1b[0m`);
-        }
-      } else {
-        console.log(`\x1b[32m✅ ${formattedCategory} (${passedCount} passed${skippedSuffix}\x1b[32m)\x1b[0m`);
-        // Print skipped tests
-        for (const skippedName of pendingSkipped) console.log(`  \x1b[33m⊘ ${skippedName}\x1b[0m`);
-      }
-      pendingFailures = [];
-      pendingSkipped = [];
-      pendingBeforeFailure = null;
-      pendingAfterFailure = null;
-    };
+    // Live test-output formatting (shared with the Node pass)
+    const reporter = new TestProgressReporter(browserOptions.verbose ?? false);
 
     // Print all console messages when verbose mode is enabled
     if (browserOptions.verbose) {
@@ -756,95 +841,7 @@ async function runBrowser(testExecutionData, browserOptions, browsersId, testInv
 
     // Subscribe to page console events for modern output formatting
     // On retry, old listeners were removed so we need to re-attach
-    page.on('console', msg => {
-      const text = msg.text();
-      if (!text.startsWith('Package testing: ')) return;
-      modernOutput = true;
-      // Extract tokens in {{...}} format
-      const tokens = [];
-      const tokenRegex = /\{\{([^}]+)\}\}/g;
-      let match;
-      while ((match = tokenRegex.exec(text)) !== null) tokens.push(match[1]);
-
-      // Category start: "Package testing: Started {{Category}}" or "Package testing: Started {{Category}} skipped {{N}}"
-      if (text.includes('Started') && (tokens.length === 1 || tokens.length === 2 && text.includes('skipped'))) {
-        // Print summary of previous category if exists
-        if (currentCategory && categoryResults.has(currentCategory)) printCategorySummary(currentCategory);
-        currentCategory = tokens[0];
-        const skippedCount = tokens.length === 2 ? parseInt(tokens[1]) || 0 : 0;
-        categoryResults.set(currentCategory, {
-          passed: 0,
-          failed: 0,
-          skipped: skippedCount
-        });
-        pendingFailures = [];
-        pendingSkipped = [];
-        pendingBeforeFailure = null;
-        pendingAfterFailure = null;
-      } else if (text.includes('Skipped') && tokens.length === 2 && !text.includes('benchmark')) {
-        // Individual skipped test: "Package testing: Skipped {{Category}} {{TestName}}"
-        // Only collect if the test belongs to the current active category
-        if (tokens[0] === currentCategory) pendingSkipped.push(tokens[1]);
-      } else if (text.includes('Started') && tokens.length === 2) {
-        // Test start: "Package testing: Started {{Category}} {{TestName}}"
-        const category = tokens[0];
-        currentTestName = tokens[1];
-        process.stdout.write(`${category}: ${currentTestName}...`);
-      } else if (text.includes('Finished') && tokens.length === 3) {
-        // Test finish: "Package testing: Finished {{Category}} {{TestName}} with {{success/error}} for X ms"
-        const category = tokens[0];
-        const testName = tokens[1];
-        const status = tokens[2];
-        const results = categoryResults.get(category);
-
-        // Clear the current test line
-        if (!browserOptions.verbose) process.stdout.write('\r\x1b[K');
-        if (status === 'success') {
-          if (results) results.passed++;
-        } else {
-          if (results) results.failed++;
-          pendingFailures.push({
-            testName,
-            error: null
-          });
-        }
-        currentTestName = null;
-      } else if (text.includes('Result for') && tokens.length === 2) {
-        // Error result: "Package testing: Result for {{Category}} {{TestName}}: error message"
-        const errorMsg = text.split(': ').slice(-1)[0];
-        // Attach error to the last pending failure
-        if (pendingFailures.length > 0) pendingFailures[pendingFailures.length - 1].error = errorMsg;
-      } else if (text.includes('Category before()') && text.includes('failed') && tokens.length >= 1) {
-        // Category before() failed: "Package testing: Category before() {{Category}} failed"
-        process.stdout.write('\r\x1b[K');
-        pendingBeforeFailure = {
-          error: null
-        };
-      } else if (text.includes('Result for') && text.includes('before:') && tokens.length >= 1) {
-        // Before error result: "Package testing: Result for {{Category}} before: error message"
-        const errorMsg = text.split('before: ').slice(-1)[0];
-        if (pendingBeforeFailure) pendingBeforeFailure.error = errorMsg;
-      } else if (text.includes('Category after()') && text.includes('failed') && tokens.length >= 1) {
-        // Category after() failed: "Package testing: Category after() {{Category}} failed"
-        process.stdout.write('\r\x1b[K');
-        pendingAfterFailure = {
-          error: null
-        };
-      } else if (text.includes('Result for') && text.includes('after:') && tokens.length >= 1) {
-        // After error result: "Package testing: Result for {{Category}} after: error message"
-        const errorMsg = text.split('after: ').slice(-1)[0];
-        if (pendingAfterFailure) pendingAfterFailure.error = errorMsg;
-      } else if (text.includes('Unhandled Exception')) {
-        // Unhandled exception: "Package testing: Unhandled Exception: ..."
-        // Clear any pending test line and move to new line
-        process.stdout.write('\r\x1b[K\n');
-        const errorMsg = text.replace('Package testing: Unhandled Exception: ', '');
-        if (errorMsg && errorMsg !== 'null') console.log(`\x1b[31m❌ Unhandled Exception: ${errorMsg}\x1b[0m`);
-      }
-    });
-    const printFinalCategorySummary = () => {
-      if (currentCategory && categoryResults.has(currentCategory)) printCategorySummary(currentCategory);
-    };
+    page.on('console', msg => reporter.onLine(msg.text()));
     const testingResults = await page.evaluate((testData, options) => {
       if (options.benchmark) window.DG.Test.isInBenchmark = true;
       if (options.reproduce) window.DG.Test.isReproducing = true;
@@ -889,9 +886,9 @@ async function runBrowser(testExecutionData, browserOptions, browsersId, testInv
     }, testsToRun, browserOptions);
 
     // Print the final category summary
-    printFinalCategorySummary();
+    reporter.finish();
     if (browserOptions.record && !existingBrowserSession) await recorder?.stop();
-    if (modernOutput) {
+    if (reporter.modernOutput) {
       testingResults.verbosePassed = '';
       testingResults.verboseSkipped = '';
       testingResults.verboseFailed = '';
@@ -908,7 +905,7 @@ async function runBrowser(testExecutionData, browserOptions, browsersId, testInv
         page,
         webUrl
       } : undefined,
-      modernOutput
+      modernOutput: reporter.modernOutput
     };
   }, testInvocationTimeout);
 }
@@ -950,6 +947,29 @@ class TestContext {
   }
 }
 exports.TestContext = TestContext;
+/**
+ * Merges two test-result CSVs by column NAME (union of headers), unlike
+ * mergeBrowsersResults' line concatenation which assumes identical column order.
+ * Used to merge the Node-pass report into the browser report.
+ */
+function mergeCsvByHeader(a, b) {
+  const hasRows = csv => csv && csv.trim().split('\n').length >= 2;
+  if (!hasRows(a)) return hasRows(b) ? b : a || b || '';
+  if (!hasRows(b)) return a;
+  const pa = _papaparse.default.parse(a.trim(), {
+    header: true,
+    skipEmptyLines: true
+  });
+  const pb = _papaparse.default.parse(b.trim(), {
+    header: true,
+    skipEmptyLines: true
+  });
+  const columns = [...(pa.meta.fields ?? [])];
+  for (const f of pb.meta.fields ?? []) if (!columns.includes(f)) columns.push(f);
+  return _papaparse.default.unparse([...pa.data, ...pb.data], {
+    columns
+  });
+}
 function addColumnToCsv(csv, columnName, defaultValue) {
   const results = _papaparse.default.parse(csv, {
     header: true,

package/package.json

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