datagrok-tools 6.1.13 → 6.2.0

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Datagrok-tools changelog
 
+## 6.2.0 (2026-05-04)
+
+* `grok test` — Playwright support: when a package's `package.json` declares `"playwrightTests": "<path>"`, `grok test` runs `npx playwright test` against that directory in addition to the existing Puppeteer pass and merges results into a single `test-report.csv`. Auth is unified with the Puppeteer pass (dev key from `~/.grok/config.yaml` → session token → cookie + `localStorage` injection — no login form). Optional `DATAGROK_DEV_KEY_2` env var enables a second-user identity for specs that need it (`DATAGROK_AUTH_TOKEN_2` exposed to specs). New `--no-playwright` flag opts out of the Playwright pass for a single run.
+
+## 6.1.14 (2026-05-01)
+
+* Reports: `grok report comment` now converts Markdown body to JIRA wiki markup before POSTing, fixing rendered headings/list/HTML-entity mismatches in JIRA UI.
+
 ## 6.1.13 (2026-04-30)
 
 * Reports: `grok report ticket` now uses direct JIRA REST honoring `$JIRA_PROJECT`, replacing the Datlas-mediated path that hardcoded GROK.

package/bin/__tests__/jira-wiki-converter.test.js

@@ -0,0 +1,101 @@
+"use strict";
+
+var _vitest = require("vitest");
+var _report = require("../commands/report");
+(0, _vitest.describe)('markdownToJiraWiki — basic rules', () => {
+  (0, _vitest.it)('converts H1', () => {
+    (0, _vitest.expect)((0, _report.markdownToJiraWiki)('# Title')).toBe('h1. Title');
+  });
+  (0, _vitest.it)('converts H2 / H3 / H6', () => {
+    (0, _vitest.expect)((0, _report.markdownToJiraWiki)('## Sub')).toBe('h2. Sub');
+    (0, _vitest.expect)((0, _report.markdownToJiraWiki)('### Sub-sub')).toBe('h3. Sub-sub');
+    (0, _vitest.expect)((0, _report.markdownToJiraWiki)('###### Deep')).toBe('h6. Deep');
+  });
+  (0, _vitest.it)('converts bold', () => {
+    (0, _vitest.expect)((0, _report.markdownToJiraWiki)('hello **world** foo')).toBe('hello *world* foo');
+  });
+  (0, _vitest.it)('converts italic with single asterisks', () => {
+    (0, _vitest.expect)((0, _report.markdownToJiraWiki)('hello *world* foo')).toBe('hello _world_ foo');
+  });
+  (0, _vitest.it)('converts strikethrough', () => {
+    (0, _vitest.expect)((0, _report.markdownToJiraWiki)('~~gone~~')).toBe('-gone-');
+  });
+  (0, _vitest.it)('converts links', () => {
+    (0, _vitest.expect)((0, _report.markdownToJiraWiki)('see [docs](https://x.example/y)')).toBe('see [docs|https://x.example/y]');
+  });
+  (0, _vitest.it)('converts blockquote', () => {
+    (0, _vitest.expect)((0, _report.markdownToJiraWiki)('> quoted line')).toBe('bq. quoted line');
+  });
+  (0, _vitest.it)('converts unordered list', () => {
+    const md = '- one\n- two\n- three';
+    (0, _vitest.expect)((0, _report.markdownToJiraWiki)(md)).toBe('* one\n* two\n* three');
+  });
+  (0, _vitest.it)('converts one level of nested unordered list', () => {
+    const md = '- top\n  - sub\n- back';
+    (0, _vitest.expect)((0, _report.markdownToJiraWiki)(md)).toBe('* top\n** sub\n* back');
+  });
+  (0, _vitest.it)('converts ordered list', () => {
+    const md = '1. one\n2. two\n3. three';
+    (0, _vitest.expect)((0, _report.markdownToJiraWiki)(md)).toBe('# one\n# two\n# three');
+  });
+  (0, _vitest.it)('converts inline code', () => {
+    (0, _vitest.expect)((0, _report.markdownToJiraWiki)('use `foo()` here')).toBe('use {{foo()}} here');
+  });
+  (0, _vitest.it)('converts plain code fence to noformat', () => {
+    const md = '```\nraw code\nmore\n```';
+    (0, _vitest.expect)((0, _report.markdownToJiraWiki)(md)).toBe('{noformat}\nraw code\nmore\n{noformat}');
+  });
+  (0, _vitest.it)('converts code fence with language tag to {code:lang}', () => {
+    const md = '```js\nconst x = 1;\n```';
+    (0, _vitest.expect)((0, _report.markdownToJiraWiki)(md)).toBe('{code:js}\nconst x = 1;\n{code}');
+  });
+  (0, _vitest.it)('converts HTML entities   / & / < / >', () => {
+    (0, _vitest.expect)((0, _report.markdownToJiraWiki)('a b')).toBe('a b');
+    (0, _vitest.expect)((0, _report.markdownToJiraWiki)('a&b')).toBe('a&b');
+    (0, _vitest.expect)((0, _report.markdownToJiraWiki)('a&lt;b&gt;c')).toBe('a<b>c');
+  });
+});
+(0, _vitest.describe)('markdownToJiraWiki — content-protection inside code fences', () => {
+  (0, _vitest.it)('does not transform `{{plates}}` inside a fenced block (run-#4 false-positive case)', () => {
+    const md = ['Before', '```', 'context: {{plates}} should stay literal', '# not a heading', '- not a list', '```', 'After'].join('\n');
+    const out = (0, _report.markdownToJiraWiki)(md);
+    (0, _vitest.expect)(out).toContain('{noformat}\ncontext: {{plates}} should stay literal');
+    (0, _vitest.expect)(out).toContain('# not a heading');
+    (0, _vitest.expect)(out).toContain('- not a list');
+    (0, _vitest.expect)(out).not.toContain('h1.');
+  });
+  (0, _vitest.it)('does not transform headings/links/lists inside an inline code span', () => {
+    const md = 'use `# not a heading` and `[ref](u)` here';
+    (0, _vitest.expect)((0, _report.markdownToJiraWiki)(md)).toBe('use {{# not a heading}} and {{[ref](u)}} here');
+  });
+});
+(0, _vitest.describe)('markdownToJiraWiki — edge cases', () => {
+  (0, _vitest.it)('handles bold containing italic: **bold *inside* bold**', () => {
+    (0, _vitest.expect)((0, _report.markdownToJiraWiki)('**bold *inside* bold**')).toBe('*bold _inside_ bold*');
+  });
+  (0, _vitest.it)('preserves bold and italic on the same line', () => {
+    (0, _vitest.expect)((0, _report.markdownToJiraWiki)('**a** and *b*')).toBe('*a* and _b_');
+  });
+  (0, _vitest.it)('handles a heading whose text contains backticks', () => {
+    (0, _vitest.expect)((0, _report.markdownToJiraWiki)('## use `foo()` for x')).toBe('h2. use {{foo()}} for x');
+  });
+  (0, _vitest.it)('passes plain text through unchanged', () => {
+    const plain = 'Just a normal sentence with no markdown.';
+    (0, _vitest.expect)((0, _report.markdownToJiraWiki)(plain)).toBe(plain);
+  });
+  (0, _vitest.it)('returns empty string unchanged', () => {
+    (0, _vitest.expect)((0, _report.markdownToJiraWiki)('')).toBe('');
+  });
+  (0, _vitest.it)('handles a multi-block document end-to-end', () => {
+    const md = ['# Handoff', '', 'Some **bold** intro and a [link](https://x.example).', '', '## Findings', '', '- first', '- second', '', '> note: this matters', '', '```js', 'const x = 1;', '```', '', 'Done&nbsp;here.'].join('\n');
+    const out = (0, _report.markdownToJiraWiki)(md);
+    (0, _vitest.expect)(out).toContain('h1. Handoff');
+    (0, _vitest.expect)(out).toContain('h2. Findings');
+    (0, _vitest.expect)(out).toContain('Some *bold* intro and a [link|https://x.example].');
+    (0, _vitest.expect)(out).toContain('* first\n* second');
+    (0, _vitest.expect)(out).toContain('bq. note: this matters');
+    (0, _vitest.expect)(out).toContain('{code:js}\nconst x = 1;\n{code}');
+    (0, _vitest.expect)(out).toContain('Done here.');
+    (0, _vitest.expect)(out).not.toContain('&nbsp;');
+  });
+});

package/bin/__tests__/jira-wiki-converter.test.ts

@@ -0,0 +1,150 @@
+import {describe, it, expect} from 'vitest';
+import {markdownToJiraWiki} from '../commands/report';
+
+describe('markdownToJiraWiki — basic rules', () => {
+  it('converts H1', () => {
+    expect(markdownToJiraWiki('# Title')).toBe('h1. Title');
+  });
+
+  it('converts H2 / H3 / H6', () => {
+    expect(markdownToJiraWiki('## Sub')).toBe('h2. Sub');
+    expect(markdownToJiraWiki('### Sub-sub')).toBe('h3. Sub-sub');
+    expect(markdownToJiraWiki('###### Deep')).toBe('h6. Deep');
+  });
+
+  it('converts bold', () => {
+    expect(markdownToJiraWiki('hello **world** foo')).toBe('hello *world* foo');
+  });
+
+  it('converts italic with single asterisks', () => {
+    expect(markdownToJiraWiki('hello *world* foo')).toBe('hello _world_ foo');
+  });
+
+  it('converts strikethrough', () => {
+    expect(markdownToJiraWiki('~~gone~~')).toBe('-gone-');
+  });
+
+  it('converts links', () => {
+    expect(markdownToJiraWiki('see [docs](https://x.example/y)'))
+      .toBe('see [docs|https://x.example/y]');
+  });
+
+  it('converts blockquote', () => {
+    expect(markdownToJiraWiki('> quoted line')).toBe('bq. quoted line');
+  });
+
+  it('converts unordered list', () => {
+    const md = '- one\n- two\n- three';
+    expect(markdownToJiraWiki(md)).toBe('* one\n* two\n* three');
+  });
+
+  it('converts one level of nested unordered list', () => {
+    const md = '- top\n  - sub\n- back';
+    expect(markdownToJiraWiki(md)).toBe('* top\n** sub\n* back');
+  });
+
+  it('converts ordered list', () => {
+    const md = '1. one\n2. two\n3. three';
+    expect(markdownToJiraWiki(md)).toBe('# one\n# two\n# three');
+  });
+
+  it('converts inline code', () => {
+    expect(markdownToJiraWiki('use `foo()` here')).toBe('use {{foo()}} here');
+  });
+
+  it('converts plain code fence to noformat', () => {
+    const md = '```\nraw code\nmore\n```';
+    expect(markdownToJiraWiki(md)).toBe('{noformat}\nraw code\nmore\n{noformat}');
+  });
+
+  it('converts code fence with language tag to {code:lang}', () => {
+    const md = '```js\nconst x = 1;\n```';
+    expect(markdownToJiraWiki(md)).toBe('{code:js}\nconst x = 1;\n{code}');
+  });
+
+  it('converts HTML entities   / & / < / >', () => {
+    expect(markdownToJiraWiki('a b')).toBe('a b');
+    expect(markdownToJiraWiki('a&b')).toBe('a&b');
+    expect(markdownToJiraWiki('a&lt;b&gt;c')).toBe('a<b>c');
+  });
+});
+
+describe('markdownToJiraWiki — content-protection inside code fences', () => {
+  it('does not transform `{{plates}}` inside a fenced block (run-#4 false-positive case)', () => {
+    const md = [
+      'Before',
+      '```',
+      'context: {{plates}} should stay literal',
+      '# not a heading',
+      '- not a list',
+      '```',
+      'After',
+    ].join('\n');
+    const out = markdownToJiraWiki(md);
+    expect(out).toContain('{noformat}\ncontext: {{plates}} should stay literal');
+    expect(out).toContain('# not a heading');
+    expect(out).toContain('- not a list');
+    expect(out).not.toContain('h1.');
+  });
+
+  it('does not transform headings/links/lists inside an inline code span', () => {
+    const md = 'use `# not a heading` and `[ref](u)` here';
+    expect(markdownToJiraWiki(md))
+      .toBe('use {{# not a heading}} and {{[ref](u)}} here');
+  });
+});
+
+describe('markdownToJiraWiki — edge cases', () => {
+  it('handles bold containing italic: **bold *inside* bold**', () => {
+    expect(markdownToJiraWiki('**bold *inside* bold**'))
+      .toBe('*bold _inside_ bold*');
+  });
+
+  it('preserves bold and italic on the same line', () => {
+    expect(markdownToJiraWiki('**a** and *b*')).toBe('*a* and _b_');
+  });
+
+  it('handles a heading whose text contains backticks', () => {
+    expect(markdownToJiraWiki('## use `foo()` for x'))
+      .toBe('h2. use {{foo()}} for x');
+  });
+
+  it('passes plain text through unchanged', () => {
+    const plain = 'Just a normal sentence with no markdown.';
+    expect(markdownToJiraWiki(plain)).toBe(plain);
+  });
+
+  it('returns empty string unchanged', () => {
+    expect(markdownToJiraWiki('')).toBe('');
+  });
+
+  it('handles a multi-block document end-to-end', () => {
+    const md = [
+      '# Handoff',
+      '',
+      'Some **bold** intro and a [link](https://x.example).',
+      '',
+      '## Findings',
+      '',
+      '- first',
+      '- second',
+      '',
+      '> note: this matters',
+      '',
+      '```js',
+      'const x = 1;',
+      '```',
+      '',
+      'Done&nbsp;here.',
+    ].join('\n');
+    const out = markdownToJiraWiki(md);
+    expect(out).toContain('h1. Handoff');
+    expect(out).toContain('h2. Findings');
+    expect(out).toContain('Some *bold* intro and a [link|https://x.example].');
+    expect(out).toContain('* first\n* second');
+    expect(out).toContain('bq. note: this matters');
+    expect(out).toContain('{code:js}\nconst x = 1;\n{code}');
+    expect(out).toContain('Done here.');
+    expect(out).not.toContain('&nbsp;');
+  });
+});

package/bin/commands/report.js

@@ -4,6 +4,7 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.markdownToJiraWiki = markdownToJiraWiki;
 exports.report = report;
 var _fs = _interopRequireDefault(require("fs"));
 var _os = _interopRequireDefault(require("os"));
@@ -436,8 +437,10 @@ async function handleTicket(args) {
 // the Datagrok org instance; override via --jira-url or $JIRA_URL.
 //
 // Why v2 and not v3: v3 requires comment bodies in ADF (Atlassian Document
-// Format) JSON; v2 accepts plain text / wiki-markup. The handoff prompt emits
-// markdown, which JIRA's plain-text path renders acceptably.
+// Format) JSON, which is much heavier to construct. v2 accepts a plain string
+// body, which JIRA renders as wiki markup — NOT Markdown. So a `# heading`
+// becomes a top-level ordered-list item, ` ` shows up literally, etc.
+// `markdownToJiraWiki` below bridges the gap for Markdown-emitting callers.
 
 function resolveJiraBase(args) {
   const cli = args['jira-url'] || '';
@@ -450,6 +453,76 @@ function jiraAuthHeader() {
   if (!user || !token) return null;
   return 'Basic ' + Buffer.from(`${user}:${token}`).toString('base64');
 }
+
+// Convert a Markdown string to JIRA wiki markup so that REST v2 renders it the
+// way the author intended. Handles the common cases that diverge between the
+// two dialects; for anything not listed, the input is passed through unchanged.
+//
+// Deferred for v1 (left as-is, may render imperfectly):
+//   - tables (Markdown and JIRA wiki use very similar pipe syntax)
+//   - nested lists deeper than two levels
+//   - footnotes, definition lists, raw HTML
+function markdownToJiraWiki(md) {
+  if (!md) return md;
+
+  // 1. Code fences first: extract their content into placeholders so that
+  //    later rules cannot rewrite anything inside `{noformat}` / `{code}`.
+  const placeholders = [];
+  const protect = s => {
+    placeholders.push(s);
+    return `\x00P${placeholders.length - 1}\x00`;
+  };
+  let out = md;
+  out = out.replace(/```([A-Za-z0-9_+\-]*)\r?\n([\s\S]*?)```/g, (_m, lang, code) => {
+    const wiki = lang ? `{code:${lang}}\n${code}{code}` : `{noformat}\n${code}{noformat}`;
+    return protect(wiki);
+  });
+
+  // 2. Inline code spans (after fences, before anything else).
+  out = out.replace(/`([^`\n]+)`/g, (_m, code) => protect(`{{${code}}}`));
+
+  // 3. Headings — h6 → h1 so that the `###` prefix doesn't get matched as `##`.
+  //    Must run before list rules (where `#` would otherwise be ambiguous).
+  out = out.replace(/^###### (.+)$/gm, 'h6. $1');
+  out = out.replace(/^##### (.+)$/gm, 'h5. $1');
+  out = out.replace(/^#### (.+)$/gm, 'h4. $1');
+  out = out.replace(/^### (.+)$/gm, 'h3. $1');
+  out = out.replace(/^## (.+)$/gm, 'h2. $1');
+  out = out.replace(/^# (.+)$/gm, 'h1. $1');
+
+  // 4. Bold then italic. We stash bold runs behind a sentinel first so that
+  //    the inner italic pass can't mistake the leftover single `*` markers for
+  //    italic (and vice-versa for `**bold *italic* bold**`).
+  out = out.replace(/\*\*([\s\S]+?)\*\*/g, '\x01$1\x01');
+  out = out.replace(/(?<!\*)\*([^*\n]+)\*(?!\*)/g, '_$1_');
+  out = out.replace(/\x01/g, '*');
+
+  // 5. Strikethrough.
+  out = out.replace(/~~([^~\n]+)~~/g, '-$1-');
+
+  // 6. Links: [text](url) → [text|url].
+  out = out.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '[$1|$2]');
+
+  // 7. Blockquote.
+  out = out.replace(/^> (.+)$/gm, 'bq. $1');
+
+  // 8. Unordered lists (one level of nesting). Two-space indent → second level.
+  out = out.replace(/^  - /gm, '** ');
+  out = out.replace(/^- /gm, '* ');
+
+  // 9. Ordered lists. After the heading pass so we don't clobber `# Title`.
+  out = out.replace(/^\d+\. /gm, '# ');
+
+  // 10. HTML entities that JIRA wiki shows literally.
+  out = out.replace(/&nbsp;/g, ' ');
+  out = out.replace(/&amp;/g, '&');
+  out = out.replace(/&lt;/g, '<');
+  out = out.replace(/&gt;/g, '>');
+
+  // Restore protected fences / inline code last.
+  out = out.replace(/\x00P(\d+)\x00/g, (_m, idx) => placeholders[Number(idx)]);
+  return out;
+}
 async function handleComment(args) {
   const ticket = args._[2];
   if (!ticket) {
@@ -482,6 +555,10 @@ async function handleComment(args) {
   }
   const base = resolveJiraBase(args);
   const url = `${base}/rest/api/2/issue/${encodeURIComponent(ticket)}/comment`;
+  // Callers (especially the dg-fix-reports M2 handoff) emit Markdown, but JIRA
+  // REST v2 renders the body as wiki markup. Convert before posting so headings,
+  // lists, and HTML entities don't render as garbage in the JIRA UI.
+  const wikiBody = markdownToJiraWiki(body);
   try {
     const resp = await fetch(url, {
       method: 'POST',
@@ -491,7 +568,7 @@ async function handleComment(args) {
         Accept: 'application/json'
       },
       body: JSON.stringify({
-        body
+        body: wikiBody
       })
     });
     if (resp.status !== 200 && resp.status !== 201) {

package/bin/commands/test.js

@@ -19,13 +19,14 @@ var _build = require("./build");
 var Papa = _interopRequireWildcard(require("papaparse"));
 var _testUtils = _interopRequireWildcard(require("../utils/test-utils"));
 var testUtils = _testUtils;
+var playwrightRunner = _interopRequireWildcard(require("../utils/playwright-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 */
 
 const execAsync = (0, _util.promisify)(_child_process.exec);
 const execFileAsync = (0, _util.promisify)(_child_process.execFile);
 const testInvocationTimeout = 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'];
+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', 'no-playwright'];
 const curDir = process.cwd();
 
 /** Expands camelCase to space-separated lowercase: "dataManipulation" → "data manipulation" */
@@ -224,7 +225,28 @@ async function test(args) {
     }
   }
   process.env.TARGET_PACKAGE = packageName;
-  const res = await runTesting(args);
+  let res = await runTesting(args);
+  if (!args['no-playwright']) {
+    const ptDir = playwrightRunner.hasPlaywrightTests(curDir);
+    if (ptDir) {
+      const ptRes = await playwrightRunner.runPlaywrightTests(curDir, ptDir, args, args.host ?? '');
+      // mergeBrowsersResults assumes both inputs have a header row; an empty
+      // Puppeteer CSV (filter matched zero tests) breaks the merge. Take the
+      // Playwright CSV verbatim in that case, otherwise merge.
+      if (!res.csv || res.csv.trim().split('\n').length < 2) {
+        res.csv = ptRes.csv;
+        res.passedAmount += ptRes.passedAmount;
+        res.failedAmount += ptRes.failedAmount;
+        res.skippedAmount += ptRes.skippedAmount;
+        res.failed = res.failed || ptRes.failed;
+        res.verbosePassed = (res.verbosePassed || '') + ptRes.verbosePassed;
+        res.verboseFailed = (res.verboseFailed || '') + ptRes.verboseFailed;
+        res.verboseSkipped = (res.verboseSkipped || '') + ptRes.verboseSkipped;
+      } else if (ptRes.csv && ptRes.csv.trim().split('\n').length >= 2) {
+        res = await (0, _testUtils.mergeBrowsersResults)([res, ptRes]);
+      }
+    }
+  }
   if (args.csv) {
     res.csv = (0, _testUtils.addColumnToCsv)(res.csv, 'stress_test', args['stress-test'] ?? false);
     res.csv = (0, _testUtils.addColumnToCsv)(res.csv, 'benchmark', args.benchmark ?? false);

package/bin/utils/playwright-runner.js

@@ -0,0 +1,255 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.hasPlaywrightTests = hasPlaywrightTests;
+exports.runPlaywrightTests = runPlaywrightTests;
+var _child_process = require("child_process");
+var _fs = _interopRequireDefault(require("fs"));
+var _path = _interopRequireDefault(require("path"));
+var _papaparse = _interopRequireDefault(require("papaparse"));
+var color = _interopRequireWildcard(require("./color-utils"));
+var testUtils = _interopRequireWildcard(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); }
+function hasPlaywrightTests(pkgDir) {
+  const pkgJsonPath = _path.default.join(pkgDir, 'package.json');
+  if (!_fs.default.existsSync(pkgJsonPath)) return null;
+  let pkgJson;
+  try {
+    pkgJson = JSON.parse(_fs.default.readFileSync(pkgJsonPath, 'utf-8'));
+  } catch {
+    return null;
+  }
+  const rel = pkgJson.playwrightTests;
+  if (typeof rel !== 'string' || rel.length === 0) return null;
+  const abs = _path.default.resolve(pkgDir, rel);
+  if (!_fs.default.existsSync(abs)) return null;
+  return abs;
+}
+function flattenSuites(suites, testDir, pkgName, owner, verbose, rows) {
+  if (!suites) return;
+  const isoDate = new Date().toISOString();
+  for (var suite of suites) {
+    if (suite.specs) {
+      for (var spec of suite.specs) {
+        const specFile = spec.file || suite.file || '';
+        const absSpec = _path.default.isAbsolute(specFile) ? specFile : _path.default.resolve(testDir, specFile);
+        const category = _path.default.relative(testDir, _path.default.dirname(absSpec)).replace(/\\/g, '/');
+        for (var t of spec.tests || []) {
+          const result = t.results && t.results[t.results.length - 1] || undefined;
+          if (!result) continue;
+          const status = result.status;
+          const skipped = status === 'skipped';
+          const success = status === 'passed';
+          var errMsg = '';
+          if (!success && !skipped && result.errors && result.errors.length > 0) errMsg = result.errors.map(e => e.message || e.stack || '').filter(s => s.length > 0).join('\n');
+          var logs = '';
+          if (verbose) {
+            const out = (result.stdout || []).map(s => s.text || '').join('');
+            const err = (result.stderr || []).map(s => s.text || '').join('');
+            logs = [out, err].filter(s => s.length > 0).join('\n');
+          }
+          rows.push({
+            date: isoDate,
+            category: category,
+            name: spec.title,
+            success: success,
+            result: errMsg,
+            ms: Math.round(result.duration || 0),
+            skipped: skipped,
+            logs: logs,
+            owner: owner,
+            package: pkgName,
+            widgetsDifference: '',
+            flaking: false
+          });
+        }
+      }
+    }
+    if (suite.suites) flattenSuites(suite.suites, testDir, pkgName, owner, verbose, rows);
+  }
+}
+function rowsToCsv(rows) {
+  const header = ['date', 'category', 'name', 'success', 'result', 'ms', 'skipped', 'logs', 'owner', 'package', 'widgetsDifference', 'flaking'];
+  return _papaparse.default.unparse({
+    fields: header,
+    data: rows.map(r => header.map(h => r[h]))
+  });
+}
+async function runPlaywrightTests(pkgDir, testDir, args, hostKey) {
+  const empty = {
+    failed: false,
+    verbosePassed: '',
+    verboseSkipped: '',
+    verboseFailed: '',
+    passedAmount: 0,
+    skippedAmount: 0,
+    failedAmount: 0,
+    csv: ''
+  };
+  let url;
+  let key;
+  try {
+    ({
+      url,
+      key
+    } = testUtils.getDevKey(hostKey));
+  } catch (e) {
+    color.error(`Playwright: cannot resolve host '${hostKey}': ${e.message || e}`);
+    return {
+      ...empty,
+      failed: true,
+      failedAmount: 1,
+      verboseFailed: `Playwright: ${e.message || e}\n`
+    };
+  }
+  let token;
+  try {
+    token = await testUtils.getToken(url, key);
+  } catch (e) {
+    color.error(`Playwright: cannot exchange dev key for token: ${e.message || e}`);
+    return {
+      ...empty,
+      failed: true,
+      failedAmount: 1,
+      verboseFailed: `Playwright: ${e.message || e}\n`
+    };
+  }
+  let webUrl;
+  try {
+    webUrl = await testUtils.getWebUrl(url, token);
+    if (webUrl.endsWith('/')) webUrl = webUrl.slice(0, -1);
+  } catch {
+    webUrl = url.replace(/\/api\/?$/, '');
+  }
+  let token2 = '';
+  if (process.env.DATAGROK_DEV_KEY_2 && process.env.DATAGROK_DEV_KEY_2.length > 0) {
+    try {
+      token2 = await testUtils.getToken(url, process.env.DATAGROK_DEV_KEY_2);
+    } catch (e) {
+      color.warn(`Playwright: DATAGROK_DEV_KEY_2 set but failed to exchange for token: ${e.message || e}`);
+    }
+  }
+  const configPath = _path.default.join(testDir, 'playwright.config.ts');
+  if (!_fs.default.existsSync(configPath)) {
+    color.error(`Playwright: ${configPath} not found.`);
+    return {
+      ...empty,
+      failed: true,
+      failedAmount: 1,
+      verboseFailed: 'Playwright: missing playwright.config.ts\n'
+    };
+  }
+  const reportFile = _path.default.join(pkgDir, 'test-playwright-report.json');
+  if (_fs.default.existsSync(reportFile)) _fs.default.unlinkSync(reportFile);
+  const cliArgs = ['--no-install', 'playwright', 'test', `--config=${configPath}`];
+  if (!args.gui) cliArgs.push(`--reporter=json`);else cliArgs.push('--headed');
+  if (args.test) cliArgs.push(`--grep=${args.test}`);
+  if (args['no-retry']) cliArgs.push('--retries=0');
+  let testDirFinal = testDir;
+  if (args.category) {
+    const candidate = _path.default.join(testDir, args.category);
+    if (_fs.default.existsSync(candidate)) testDirFinal = candidate;
+  }
+  if (testDirFinal !== testDir) cliArgs.push(testDirFinal);
+  const env = {
+    ...process.env,
+    DATAGROK_URL: webUrl,
+    DATAGROK_AUTH_TOKEN: token,
+    PLAYWRIGHT_JSON_OUTPUT_NAME: reportFile
+  };
+  if (token2) env.DATAGROK_AUTH_TOKEN_2 = token2;
+  color.info(`Playwright: running ${_path.default.relative(pkgDir, testDir) || '.'} against ${webUrl}`);
+  const stdoutChunks = [];
+  const stderrChunks = [];
+  const exitCode = await new Promise(resolve => {
+    const isWin = process.platform === 'win32';
+    const child = (0, _child_process.spawn)(isWin ? 'npx.cmd' : 'npx', cliArgs, {
+      cwd: pkgDir,
+      env: env,
+      shell: isWin
+    });
+    child.stdout.on('data', d => {
+      stdoutChunks.push(d);
+      if (args.gui || args.verbose) process.stdout.write(d);
+    });
+    child.stderr.on('data', d => {
+      stderrChunks.push(d);
+      process.stderr.write(d);
+    });
+    child.on('error', e => {
+      color.error(`Playwright: failed to spawn npx: ${e.message}`);
+      resolve(1);
+    });
+    child.on('close', code => resolve(code ?? 1));
+  });
+  if (args.gui) {
+    return {
+      ...empty,
+      failed: exitCode !== 0,
+      failedAmount: exitCode !== 0 ? 1 : 0,
+      passedAmount: exitCode === 0 ? 1 : 0,
+      verboseFailed: exitCode !== 0 ? 'Playwright (gui mode) exited non-zero\n' : ''
+    };
+  }
+  let report;
+  if (_fs.default.existsSync(reportFile)) {
+    try {
+      report = JSON.parse(_fs.default.readFileSync(reportFile, 'utf-8'));
+    } catch (e) {
+      color.warn(`Playwright: cannot parse JSON report: ${e.message || e}`);
+    }
+  }
+  if (!report) {
+    const stdoutText = Buffer.concat(stdoutChunks).toString('utf-8');
+    try {
+      report = JSON.parse(stdoutText);
+    } catch {/* ignore */}
+  }
+  if (!report) {
+    color.error('Playwright: no JSON report produced.');
+    const tail = Buffer.concat(stderrChunks).toString('utf-8').slice(-2000);
+    return {
+      ...empty,
+      failed: true,
+      failedAmount: 1,
+      verboseFailed: `Playwright: no JSON report. stderr tail:\n${tail}\n`
+    };
+  }
+  const pkgJson = JSON.parse(_fs.default.readFileSync(_path.default.join(pkgDir, 'package.json'), 'utf-8'));
+  const owner = pkgJson.author && (pkgJson.author.email || pkgJson.author) || '';
+  const pkgName = process.env.TARGET_PACKAGE || args.package || pkgJson.name || '';
+  const rows = [];
+  flattenSuites(report.suites, testDir, pkgName, typeof owner === 'string' ? owner : '', args.verbose === true, rows);
+  let passedAmount = 0;
+  let failedAmount = 0;
+  let skippedAmount = 0;
+  let verbosePassed = '';
+  let verboseFailed = '';
+  let verboseSkipped = '';
+  for (var r of rows) {
+    const line = `${r.category}: ${r.name} (${r.ms} ms)\n`;
+    if (r.skipped) {
+      skippedAmount++;
+      verboseSkipped += line;
+    } else if (r.success) {
+      passedAmount++;
+      verbosePassed += line;
+    } else {
+      failedAmount++;
+      verboseFailed += `${r.category}: ${r.name} (${r.ms} ms) :  ${r.result}\n`;
+    }
+  }
+  return {
+    failed: failedAmount > 0,
+    passedAmount: passedAmount,
+    failedAmount: failedAmount,
+    skippedAmount: skippedAmount,
+    verbosePassed: verbosePassed,
+    verboseFailed: verboseFailed,
+    verboseSkipped: verboseSkipped,
+    csv: rowsToCsv(rows)
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "datagrok-tools",
-  "version": "6.1.13",
+  "version": "6.2.0",
   "description": "Utility to upload and publish packages to Datagrok",
   "homepage": "https://github.com/datagrok-ai/public/tree/master/tools#readme",
   "dependencies": {
@@ -14,13 +14,12 @@
     "archiver-promise": "^1.0.0",
     "datagrok-api": "^1.26.0",
     "estraverse": "^5.3.0",
-    "glob": "^11.0.2",
+    "glob": "^13.0.6",
     "ignore-walk": "^3.0.4",
     "inquirer": "^7.3.3",
     "js-yaml": "^4.1.0",
     "minimist": "^1.2.8",
     "node-fetch": "^2.7.0",
-    "node-recursive-directory": "^1.2.0",
     "os": "^0.1.2",
     "papaparse": "^5.4.1",
     "path": "^0.12.7",