datagrok-tools 6.1.0 → 6.1.1

package/bin/commands/test.js

@@ -4,12 +4,14 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.matchesFilter = matchesFilter;
 exports.test = test;
 var _child_process = require("child_process");
 var _util = require("util");
 var _fs = _interopRequireDefault(require("fs"));
 var _os = _interopRequireDefault(require("os"));
 var _path = _interopRequireDefault(require("path"));
+var _readline = _interopRequireDefault(require("readline"));
 var _jsYaml = _interopRequireDefault(require("js-yaml"));
 var utils = _interopRequireWildcard(require("../utils/utils"));
 var color = _interopRequireWildcard(require("../utils/color-utils"));
@@ -23,12 +25,85 @@ function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r
 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'];
+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 curDir = process.cwd();
+
+/** Expands camelCase to space-separated lowercase: "dataManipulation" → "data manipulation" */
+function expandCamelCase(s) {
+  return s.replace(/([a-z])([A-Z])/g, '$1 $2').toLowerCase();
+}
+
+/** Checks if a segment matches a filter segment (case-insensitive substring, with camelCase expansion) */
+function segmentMatches(testSegment, filterSegment) {
+  if (filterSegment === '*') return true;
+  const t = expandCamelCase(testSegment.trim());
+  const f = expandCamelCase(filterSegment.trim());
+  return t.includes(f);
+}
+
+/**
+ * Fluent test name filter. Matches a full test name like "Core: d4 | Viewers | Data Manipulation | Scatter plot".
+ *
+ * Supports: substring search, `/`-anchored paths, `|`/`/` delimited segments, camelCase expansion, `*` wildcards.
+ */
+function matchesFilter(fullName, filter) {
+  // Normalize test name: strip "Core: " prefix, split by " | "
+  const normalized = fullName.replace(/^Core:\s*/, '');
+  const testSegments = normalized.split(/\s*\|\s*/);
+
+  // Detect anchored mode: ^ prefix
+  const anchored = filter.startsWith('^');
+  const rawFilter = anchored ? filter.slice(1) : filter;
+
+  // Split filter by / or | (with optional spaces)
+  const filterParts = rawFilter.split(/\s*[/|]\s*/).map(s => s.trim()).filter(s => s.length > 0);
+
+  // Substring mode: single segment, no delimiters, no anchor
+  if (filterParts.length <= 1 && !anchored) {
+    const f = expandCamelCase(filterParts[0] || '');
+    const full = expandCamelCase(normalized);
+    return full.includes(f);
+  }
+
+  // Segment mode: find filterParts in order within testSegments
+  if (anchored) {
+    // Anchored: filter[0] must match testSegments[0], filter[1] must match testSegments[1], etc.
+    if (filterParts.length > testSegments.length) return false;
+    for (let i = 0; i < filterParts.length; i++) {
+      if (!segmentMatches(testSegments[i], filterParts[i])) return false;
+    }
+    return true;
+  }
+
+  // Unanchored: find filter segments in order (with possible gaps, unless wildcard forces position)
+  let ti = 0;
+  for (let fi = 0; fi < filterParts.length; fi++) {
+    let found = false;
+    while (ti < testSegments.length) {
+      if (segmentMatches(testSegments[ti], filterParts[fi])) {
+        ti++;
+        found = true;
+        break;
+      }
+      // If previous filter was wildcard (exact position), don't skip
+      if (fi > 0 && filterParts[fi - 1] === '*') {
+        // Wildcard consumed exactly one segment, so this filter must match next
+        return false;
+      }
+      ti++;
+    }
+    if (!found) return false;
+  }
+  return true;
+}
 const grokDir = _path.default.join(_os.default.homedir(), '.grok');
 const confPath = _path.default.join(grokDir, 'config.yaml');
 const consoleLogOutputDir = _path.default.join(curDir, 'test-console-output.log');
-const csvReportDir = _path.default.join(curDir, 'test-report.csv');
+const defaultCsvReportDir = _path.default.join(curDir, 'test-report.csv');
+function resolveCsvPath(csv) {
+  if (typeof csv === 'string' && csv !== 'true' && csv.length > 0) return _path.default.resolve(csv);
+  return defaultCsvReportDir;
+}
 
 /**
  * Detects if the current directory is within a Dart library folder (d4, xamgle, ddt, dml)
@@ -57,12 +132,31 @@ function findGitRoot(startDir) {
   }
 }
 async function test(args) {
+  if (args['_'][1] === 'list') return await listTests(args);
+  if (args.dartium) return await testDartium(args);
   if (args.recursive) return await testRecursive(process.cwd(), args);
   const config = _jsYaml.default.load(_fs.default.readFileSync(confPath, {
     encoding: 'utf-8'
   }));
   isArgsValid(args);
 
+  // Resolve fluent filter into category/test for normal mode (best-effort)
+  const filter = resolveFilter(args);
+  if (filter && !args.category && !args.test) {
+    const anchored = filter.startsWith('/');
+    const raw = anchored ? filter.slice(1) : filter;
+    const parts = raw.split(/\s*[/|]\s*/).map(s => s.trim()).filter(s => s.length > 0);
+    if (parts.length > 1) {
+      // Multi-segment: use all but last as category, last as test
+      args.category = 'Core: ' + parts.slice(0, -1).join(': ');
+      args.test = parts[parts.length - 1];
+    } else if (parts.length === 1) {
+      // Single segment: use as test name filter
+      args.test = parts[0];
+    }
+    color.info(`Filter "${filter}" → category: "${args.category || ''}", test: "${args.test || ''}"`);
+  }
+
   // If running from a core Dart library directory, delegate to DevTools package
   if (!args.package) {
     const detectedCategory = detectDartLibraryCategory();
@@ -134,7 +228,7 @@ async function test(args) {
   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);
-    (0, _testUtils.saveCsvResults)([res.csv], csvReportDir);
+    (0, _testUtils.saveCsvResults)([res.csv], resolveCsvPath(args.csv));
   }
   (0, _testUtils.printBrowsersResult)(res, args.verbose);
   if (res.failed) {
@@ -143,9 +237,12 @@ async function test(args) {
   } else testUtils.exitWithCode(0);
   return true;
 }
+function resolveFilter(args) {
+  return args.f || (args['_'].length > 1 ? String(args['_'][1]) : undefined);
+}
 function isArgsValid(args) {
   const options = Object.keys(args).slice(1);
-  if (args['_'].length > 1 || options.length > availableCommandOptions.length || options.length > 0 && !options.every(op => availableCommandOptions.includes(op))) return false;
+  if (args['_'].length > 2 || options.length > availableCommandOptions.length || options.length > 0 && !options.every(op => availableCommandOptions.includes(op))) return false;
   return true;
 }
 
@@ -206,7 +303,8 @@ async function runTesting(args) {
         debug: args['debug'] ?? false,
         skipToCategory: currentSkipToCategory,
         skipToTest: currentSkipToTest,
-        keepBrowserOpen: useRetry // Keep browser open if retry is enabled
+        keepBrowserOpen: useRetry,
+        urlParams: args.params
       }, browserId, testInvocationTimeout, browserSession);
 
       // Store browser session for potential reuse
@@ -324,6 +422,443 @@ function readCSVResultData(data) {
     rows: parsed.data
   };
 }
+const DARTIUM_WELL_KNOWN_PATHS = ['C:\\programs\\dartium-win-ia32-stable-1.24.2.0\\chrome.exe', _path.default.join(_os.default.homedir(), 'dartium', 'chrome.exe'), _path.default.join(_os.default.homedir(), 'dartium', 'chrome')];
+const DARTIUM_INACTIVITY_TIMEOUT = 180000; // 3 minutes
+
+function resolveDartiumPath(arg) {
+  if (typeof arg === 'string' && arg !== 'true') {
+    if (!_fs.default.existsSync(arg)) throw new Error(`Dartium not found at: ${arg}`);
+    return arg;
+  }
+  const envPath = process.env.DARTIUM_PATH;
+  if (envPath) {
+    if (!_fs.default.existsSync(envPath)) throw new Error(`DARTIUM_PATH set but not found: ${envPath}`);
+    return envPath;
+  }
+  for (const p of DARTIUM_WELL_KNOWN_PATHS) {
+    if (_fs.default.existsSync(p)) return p;
+  }
+  throw new Error('Dartium not found. Use --dartium=/path/to/chrome.exe or set DARTIUM_PATH');
+}
+function extractConsoleMessage(line) {
+  // Try full format first: "message", source: URL (line)
+  const match = line.match(/INFO:CONSOLE\(\d+\)\] "(.*)", source:/);
+  if (match) return match[1];
+  // Truncated format (long messages): "message" without source suffix
+  const truncated = line.match(/INFO:CONSOLE\(\d+\)\] "(.*)"?\s*$/);
+  return truncated ? truncated[1] : null;
+}
+function parseAutotestLine(msg) {
+  // AUTOTEST_PASS: d4 | Viewers | Inputs (42ms)
+  // AUTOTEST_FAIL: d4 | Viewers | Inputs (42ms) - error message
+  // AUTOTEST_SKIP: d4 | Viewers | Inputs - reason
+  const passMatch = msg.match(/^AUTOTEST_PASS: (.+?) \((\d+)ms\)$/);
+  if (passMatch) {
+    const parts = passMatch[1].split(' | ');
+    return {
+      name: passMatch[1],
+      category: parts.slice(0, -1).join(' | '),
+      testName: parts[parts.length - 1],
+      success: true,
+      ms: parseInt(passMatch[2]),
+      skipped: false,
+      error: ''
+    };
+  }
+  const failMatch = msg.match(/^AUTOTEST_FAIL: (.+?) \((\d+)ms\) - (.*)$/);
+  if (failMatch) {
+    const parts = failMatch[1].split(' | ');
+    return {
+      name: failMatch[1],
+      category: parts.slice(0, -1).join(' | '),
+      testName: parts[parts.length - 1],
+      success: false,
+      ms: parseInt(failMatch[2]),
+      skipped: false,
+      error: failMatch[3]
+    };
+  }
+  const skipMatch = msg.match(/^AUTOTEST_SKIP: (.+?) - (.*)$/);
+  if (skipMatch) {
+    const parts = skipMatch[1].split(' | ');
+    return {
+      name: skipMatch[1],
+      category: parts.slice(0, -1).join(' | '),
+      testName: parts[parts.length - 1],
+      success: true,
+      ms: 0,
+      skipped: true,
+      error: skipMatch[2]
+    };
+  }
+  return null;
+}
+function writeFailedTestsLog(results, args) {
+  const failures = results.filter(r => !r.success && !r.skipped);
+  if (failures.length === 0) return null;
+  let logPath;
+  if (typeof args.logfailed === 'string' && args.logfailed !== 'true' && args.logfailed.length > 0) logPath = _path.default.resolve(args.logfailed);else logPath = _path.default.join(_os.default.tmpdir(), `grok-test-failures-${Date.now()}.md`);
+  const filter = resolveFilter(args) || '';
+  const lines = [];
+  lines.push(`# Failed Tests Report`);
+  lines.push('');
+  lines.push(`Date: ${new Date().toISOString()}`);
+  if (filter) lines.push(`Filter: ${filter}`);
+  lines.push(`Total: ${results.length}, Failed: ${failures.length}`);
+  lines.push('');
+  for (const f of failures) {
+    lines.push(`## ${f.name}`);
+    lines.push('');
+    lines.push(`**Error:** ${f.error}`);
+    lines.push('');
+    if (f.stack && f.stack.length > 0) {
+      lines.push('**Stack trace:**');
+      lines.push('```');
+      for (const sl of f.stack) lines.push(sl);
+      lines.push('```');
+      lines.push('');
+    }
+    const escapedName = f.name.replace(/\|/g, '/').replace(/\s+/g, ' ').trim();
+    lines.push(`**Reproduce:** \`grok test --dartium "${escapedName}"\``);
+    lines.push('');
+    lines.push('---');
+    lines.push('');
+  }
+  _fs.default.writeFileSync(logPath, lines.join('\n'), 'utf8');
+  return logPath;
+}
+async function listTests(args) {
+  const config = _jsYaml.default.load(_fs.default.readFileSync(confPath, {
+    encoding: 'utf-8'
+  }));
+  const dartiumPath = resolveDartiumPath(args.dartium || true);
+  const filter = args.f || (args['_'].length > 2 ? String(args['_'][2]) : '');
+  const {
+    url,
+    key
+  } = testUtils.getDevKey(args.host ?? '');
+  const token = await testUtils.getToken(url, key);
+  const webUrl = await testUtils.getWebUrl(url, token);
+  const urlParams = new URLSearchParams();
+  urlParams.set('token', token);
+  urlParams.set('listTests', filter);
+  urlParams.set('excludePackages', '');
+  const testUrl = `${webUrl}/?${urlParams.toString()}`;
+  const userDataDir = _path.default.join(_os.default.tmpdir(), 'dartium-grok-test');
+  color.info(`Listing tests${filter ? ` matching "${filter}"` : ''}...`);
+  const dartium = (0, _child_process.spawn)(dartiumPath, ['--enable-logging=stderr', '--no-first-run', `--user-data-dir=${userDataDir}`, testUrl], {
+    stdio: ['ignore', 'ignore', 'pipe']
+  });
+  return new Promise(resolve => {
+    const rl = _readline.default.createInterface({
+      input: dartium.stderr
+    });
+    const tests = [];
+    const inactivityCheck = setInterval(() => {
+      color.error('Timed out waiting for test list.');
+      dartium.kill();
+    }, DARTIUM_INACTIVITY_TIMEOUT);
+    rl.on('line', line => {
+      const msg = extractConsoleMessage(line);
+      if (!msg) return;
+      if (msg.startsWith('AUTOTEST_LIST_DONE:')) {
+        clearInterval(inactivityCheck);
+        console.log('');
+        for (const t of tests) console.log(t);
+        console.log(`\n${tests.length} test(s)`);
+        dartium.kill();
+        return;
+      }
+      if (msg.startsWith('AUTOTEST_LIST: ')) tests.push(msg.replace('AUTOTEST_LIST: ', ''));
+    });
+    dartium.on('close', () => {
+      clearInterval(inactivityCheck);
+      rl.close();
+      resolve(true);
+    });
+    process.on('SIGINT', () => {
+      dartium.kill();
+    });
+  });
+}
+/** Runs a single Dartium session with the given URL and collects results. */
+function runDartiumSession(dartiumPath, testUrl, userDataDir, verbose) {
+  const dartium = (0, _child_process.spawn)(dartiumPath, ['--enable-logging=stderr', '--no-first-run', `--user-data-dir=${userDataDir}`, testUrl], {
+    stdio: ['ignore', 'ignore', 'pipe']
+  });
+  const results = [];
+  let totalExpected = 0;
+  let done = false;
+  let lastRunningTest = '';
+  let lastActivityTime = Date.now();
+  return new Promise(resolve => {
+    const rl = _readline.default.createInterface({
+      input: dartium.stderr
+    });
+    const inactivityCheck = setInterval(() => {
+      if (Date.now() - lastActivityTime > DARTIUM_INACTIVITY_TIMEOUT && !done) {
+        process.stdout.write('\r\x1b[K');
+        color.error(`\nTest appears stuck (no output for ${DARTIUM_INACTIVITY_TIMEOUT / 1000}s). Killing Dartium.`);
+        done = true;
+        dartium.kill();
+      }
+    }, 10000);
+    rl.on('line', line => {
+      const msg = extractConsoleMessage(line);
+      if (!msg || !msg.startsWith('AUTOTEST_')) return;
+      lastActivityTime = Date.now();
+      if (msg.startsWith('AUTOTEST_START:')) {
+        const countMatch = msg.match(/(\d+) test/);
+        totalExpected = countMatch ? parseInt(countMatch[1]) : 0;
+        return;
+      }
+      if (msg.startsWith('AUTOTEST_RUN:')) {
+        lastRunningTest = msg.replace('AUTOTEST_RUN: ', '');
+        process.stdout.write(`\r\x1b[K  \x1b[90m\u25B6 ${lastRunningTest}\x1b[0m`);
+        return;
+      }
+      if (msg.startsWith('AUTOTEST_STACK:')) {
+        const stackLine = msg.replace('AUTOTEST_STACK: ', '');
+        const lastResult = results.length > 0 ? results[results.length - 1] : null;
+        if (lastResult && !lastResult.success && !lastResult.skipped) {
+          if (!lastResult.stack) lastResult.stack = [];
+          lastResult.stack.push(stackLine);
+        }
+        return;
+      }
+      if (msg.startsWith('AUTOTEST_DONE:')) {
+        process.stdout.write('\r\x1b[K');
+        done = true;
+        dartium.kill();
+        return;
+      }
+      const result = parseAutotestLine(msg);
+      if (result) {
+        process.stdout.write('\r\x1b[K');
+        results.push(result);
+        lastRunningTest = '';
+        if (verbose) {
+          if (result.skipped) console.log(`  \x1b[33m\u25CB ${result.testName} (skipped: ${result.error})\x1b[0m`);else if (result.success) console.log(`  \x1b[32m\u2714 ${result.testName} (${result.ms}ms)\x1b[0m`);else console.log(`  \x1b[31m\u274C ${result.testName} (${result.ms}ms) - ${result.error}\x1b[0m`);
+        }
+      }
+    });
+    dartium.on('close', () => {
+      clearInterval(inactivityCheck);
+      rl.close();
+      resolve({
+        results,
+        done,
+        totalExpected,
+        lastRunningTest
+      });
+    });
+    process.on('SIGINT', () => {
+      color.warn('\nInterrupted. Killing Dartium...');
+      done = true;
+      dartium.kill();
+    });
+  });
+}
+
+/** Gets the full list of test names matching a filter via Dartium. */
+function getDartiumTestList(dartiumPath, webUrl, token, filter, extraParams) {
+  const urlParams = new URLSearchParams();
+  urlParams.set('token', token);
+  urlParams.set('listTests', filter);
+  urlParams.set('excludePackages', '');
+  if (extraParams) for (const pair of extraParams.split('&')) {
+    const [k, ...v] = pair.split('=');
+    if (k) urlParams.set(k.trim(), v.join('='));
+  }
+  const testUrl = `${webUrl}/?${urlParams.toString()}`;
+  const userDataDir = _path.default.join(_os.default.tmpdir(), 'dartium-grok-test');
+  const dartium = (0, _child_process.spawn)(dartiumPath, ['--enable-logging=stderr', '--no-first-run', `--user-data-dir=${userDataDir}`, testUrl], {
+    stdio: ['ignore', 'ignore', 'pipe']
+  });
+  return new Promise(resolve => {
+    const rl = _readline.default.createInterface({
+      input: dartium.stderr
+    });
+    const tests = [];
+    const timeout = setTimeout(() => {
+      dartium.kill();
+    }, DARTIUM_INACTIVITY_TIMEOUT);
+    rl.on('line', line => {
+      const msg = extractConsoleMessage(line);
+      if (!msg) return;
+      if (msg.startsWith('AUTOTEST_LIST_DONE:')) {
+        clearTimeout(timeout);
+        dartium.kill();
+        return;
+      }
+      if (msg.startsWith('AUTOTEST_LIST: ')) tests.push(msg.replace('AUTOTEST_LIST: ', ''));
+    });
+    dartium.on('close', () => {
+      clearTimeout(timeout);
+      rl.close();
+      resolve(tests);
+    });
+  });
+}
+function buildDartiumUrl(webUrl, token, filter, args) {
+  const urlParams = new URLSearchParams();
+  urlParams.set('token', token);
+  urlParams.set('tests', filter);
+  if (!urlParams.has('excludePackages')) urlParams.set('excludePackages', '');
+  if (args.params) for (const pair of args.params.split('&')) {
+    const [k, ...v] = pair.split('=');
+    if (k) urlParams.set(k.trim(), v.join('='));
+  }
+  return `${webUrl}/?${urlParams.toString()}`;
+}
+function printDartiumSummary(allResults, args) {
+  // Category-level summary
+  const categoryResults = new Map();
+  const categoryFailures = new Map();
+  for (const result of allResults) {
+    if (!categoryResults.has(result.category)) categoryResults.set(result.category, {
+      passed: 0,
+      failed: 0,
+      skipped: 0
+    });
+    const catR = categoryResults.get(result.category);
+    if (result.skipped) catR.skipped++;else if (result.success) catR.passed++;else {
+      catR.failed++;
+      if (!categoryFailures.has(result.category)) categoryFailures.set(result.category, []);
+      categoryFailures.get(result.category).push({
+        testName: result.testName,
+        error: result.error,
+        stack: result.stack || []
+      });
+    }
+  }
+  for (const [cat, r] of categoryResults) {
+    const skippedSuffix = r.skipped > 0 ? `, \x1b[33m${r.skipped} skipped\x1b[0m` : '';
+    if (r.failed > 0) {
+      console.log(`\x1b[31m\u274C ${cat}\x1b[31m (\x1b[32m${r.passed} passed${skippedSuffix}\x1b[31m, ${r.failed} failed)\x1b[0m`);
+      const failures = categoryFailures.get(cat) || [];
+      for (const f of failures) {
+        console.log(`  \x1b[31m\u274C ${f.testName}\x1b[0m${f.error ? `: ${f.error}` : ''}`);
+        for (const sl of f.stack) console.log(`    \x1b[90m${sl}\x1b[0m`);
+      }
+    } else console.log(`\x1b[32m\u2714 ${cat} (${r.passed} passed${skippedSuffix})\x1b[0m`);
+  }
+  const passed = allResults.filter(r => r.success && !r.skipped).length;
+  const failed = allResults.filter(r => !r.success && !r.skipped).length;
+  const skipped = allResults.filter(r => r.skipped).length;
+  console.log('');
+  if (failed > 0) color.error(`Results: ${passed} passed, ${failed} failed${skipped > 0 ? `, ${skipped} skipped` : ''} (${allResults.length} total)`);else color.success(`Results: ${passed} passed${skipped > 0 ? `, ${skipped} skipped` : ''} (${allResults.length} total)`);
+
+  // CSV
+  if (args.csv && allResults.length > 0) {
+    const now = new Date().toISOString();
+    const csvRows = allResults.map(r => ({
+      date: now,
+      category: r.category,
+      name: r.testName,
+      success: r.success,
+      result: r.skipped ? r.error : r.success ? 'OK' : r.error,
+      ms: r.ms,
+      skipped: r.skipped,
+      error: r.success ? '' : r.error
+    }));
+    const csv = Papa.unparse(csvRows);
+    const csvPath = resolveCsvPath(args.csv);
+    _fs.default.writeFileSync(csvPath, csv, 'utf8');
+    color.info(`Saved ${csvPath}`);
+  }
+
+  // Log failed
+  if (failed > 0 || args.logfailed) {
+    const logPath = writeFailedTestsLog(allResults, args);
+    if (logPath) color.warn(`Failed tests log: ${logPath}`);
+  }
+  const totalTestMs = allResults.reduce((sum, r) => sum + r.ms, 0);
+  console.log(`\nPassed tests: ${passed}`);
+  console.log(`Failed tests: ${failed}`);
+  console.log(`Skipped tests: ${skipped}`);
+  console.log(`Total test time: ${(totalTestMs / 1000).toFixed(1)}s`);
+  if (failed > 0) testUtils.exitWithCode(1);else testUtils.exitWithCode(0);
+}
+async function testDartium(args) {
+  const dartiumPath = resolveDartiumPath(args.dartium);
+  color.info(`Using Dartium: ${dartiumPath}`);
+  const {
+    url,
+    key
+  } = testUtils.getDevKey(args.host ?? '');
+  const token = await testUtils.getToken(url, key);
+  const webUrl = await testUtils.getWebUrl(url, token);
+  const filter = resolveFilter(args) || '';
+  const userDataDir = _path.default.join(_os.default.tmpdir(), 'dartium-grok-test');
+  const testUrl = buildDartiumUrl(webUrl, token, filter, args);
+  const useRetry = args['no-retry'] === false;
+  color.info(`Opening: ${webUrl} (tests: ${filter || 'all'})`);
+
+  // Main run
+  const session = await runDartiumSession(dartiumPath, testUrl, userDataDir, args.verbose ?? false);
+  const allResults = [...session.results];
+  if (session.done) {
+    color.info(`Running ${session.totalExpected} test(s)...\n`);
+  }
+
+  // If Dartium crashed mid-run and retry is enabled, retry missing tests individually
+  if (!session.done && useRetry) {
+    const completedNames = new Set(session.results.map(r => r.name));
+
+    // The test that was running when Dartium crashed
+    if (session.lastRunningTest && !completedNames.has(session.lastRunningTest)) {
+      allResults.push({
+        name: session.lastRunningTest,
+        category: session.lastRunningTest.split(/\s*\|\s*/).slice(0, -1).join(' | '),
+        testName: session.lastRunningTest.split(/\s*\|\s*/).pop(),
+        success: false,
+        ms: 0,
+        skipped: false,
+        error: 'Dartium crashed while running this test',
+        stack: []
+      });
+      completedNames.add(session.lastRunningTest);
+    }
+
+    // Get full test list to find what wasn't run
+    color.info('\nDartium crashed. Fetching full test list for retry...');
+    const allTests = await getDartiumTestList(dartiumPath, webUrl, token, filter, args.params);
+    const missingTests = allTests.filter(t => !completedNames.has(t));
+    if (missingTests.length > 0) {
+      color.info(`Retrying ${missingTests.length} unexecuted test(s) individually...\n`);
+      for (let i = 0; i < missingTests.length; i++) {
+        const testName = missingTests[i];
+        const shortName = testName.split(' | ').pop();
+        process.stdout.write(`\r\x1b[K  \x1b[90m[${i + 1}/${missingTests.length}] Retrying: ${shortName}\x1b[0m`);
+
+        // Build URL for this specific test
+        const escapedName = testName.replace(/\|/g, '/').replace(/\s+/g, ' ').trim();
+        const retryUrl = buildDartiumUrl(webUrl, token, escapedName, args);
+        const retrySession = await runDartiumSession(dartiumPath, retryUrl, userDataDir, args.verbose ?? false);
+        if (retrySession.results.length > 0) allResults.push(...retrySession.results);else {
+          // Test crashed Dartium again or produced no output
+          allResults.push({
+            name: testName,
+            category: testName.split(/\s*\|\s*/).slice(0, -1).join(' | '),
+            testName: testName.split(/\s*\|\s*/).pop(),
+            success: false,
+            ms: 0,
+            skipped: false,
+            error: 'Dartium crashed on retry — test consistently crashes the browser',
+            stack: []
+          });
+        }
+      }
+      process.stdout.write('\r\x1b[K');
+      console.log('');
+    }
+  } else if (!session.done && !useRetry) {
+    color.warn(`Dartium exited before tests completed (${allResults.length}/${session.totalExpected || '?'} tests ran). Use --retry to retry missing tests.`);
+  }
+  printDartiumSummary(allResults, args);
+  return allResults.every(r => r.success || r.skipped);
+}
 async function testRecursive(baseDir, args) {
   const packages = (0, _build.discoverPackages)(baseDir);
   if (packages.length === 0) {

package/bin/grok.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 const argv = require('minimist')(process.argv.slice(2), {
   alias: {k: 'key', h: 'help', r: 'recursive', s: 'silent'},
+  boolean: ['dartium'],
 });
 const help = require('./commands/help').help;
 const runAllCommand = require('./utils/utils').runAll;
@@ -13,6 +14,7 @@ const commands = {
   claude: require('./commands/claude').claude,
   config: require('./commands/config').config,
   create: require('./commands/create').create,
+  'docker-gen': require('./commands/docker-gen').dockerGen,
   init: require('./commands/init').init,
   link: require('./commands/link').link,
   publish: require('./commands/publish').publish,