@rho-workspace/rho 0.5.3 → 0.5.5

package/scripts/screen-check.mjs

@@ -0,0 +1,193 @@
+#!/usr/bin/env node
+// Opens a page in a real browser at each viewport and reports what it shows: whether it scrolls
+// sideways, the elements that cross the right edge, unnamed buttons, overlapping boxes of a selector,
+// page and console errors, requests that leave the page, and a screenshot per viewport. It reports
+// what the page does; it does not judge the design, and it changes nothing on the page.
+//
+//   rho-screen-check <url or page.html> [--viewport WxH]... [--out DIR] [--overlap SELECTOR]
+//                    [--full-page] [--settle MS] [--browser auto|chrome|msedge|chromium|PATH]
+//
+// Prints the report as JSON and writes it to DIR/report.json (default ./screen-check).
+// Exit status: 0 the check ran (its findings are in the report); 1 an argument was wrong;
+// 2 the check did not run (error.kind, error.message and error.next say why and what to do).
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { parseArgs } from 'node:util';
+import { chromium } from 'playwright-core';
+import { pageFindings, viewports } from './browser-checks.mjs';
+
+class CheckError extends Error {
+  constructor(kind, message, next) {
+    super(message);
+    this.kind = kind;
+    this.next = next;
+  }
+}
+
+const usage = `Usage: rho-screen-check <url or page.html> [options]
+
+Options:
+  --viewport WxH       a viewport to check, repeatable
+                       (default 1440x900, 1024x768, 768x1024, 390x844)
+  --out DIR            folder for the screenshots and report.json (default ./screen-check)
+  --overlap SELECTOR   report pairs of visible boxes matching SELECTOR that overlap
+  --full-page          screenshot the whole page, not only the window
+  --settle MS          wait after load before measuring (default 800)
+  --browser NAME       auto (default: Chrome, then Edge, then Playwright's Chromium), chrome,
+                       msedge, chromium, or the path of a Chromium-based browser
+  -h, --help           show this help
+
+Prints the report as JSON on stdout and writes it to DIR/report.json.
+Exit status: 0 the check ran; 1 an argument was wrong; 2 the check did not run.
+`;
+
+const firstLine = error => String(error?.message ?? error).split('\n')[0].slice(0, 300);
+
+function parseSize(text) {
+  const match = /^(\d{3,4})x(\d{3,4})$/.exec(text);
+  const width = match ? Number(match[1]) : 0;
+  const height = match ? Number(match[2]) : 0;
+  if (!match || width < 200 || width > 3840 || height < 200 || height > 2400) {
+    throw new CheckError('usage', `Viewport "${text}" is not WIDTHxHEIGHT, between 200 and 3840 wide and 200 and 2400 high.`, 'Use a form such as --viewport 390x844.');
+  }
+  return [width, height];
+}
+
+async function targetOf(text) {
+  if (/^https?:\/\//i.test(text)) {
+    try {
+      return new URL(text);
+    } catch {
+      throw new CheckError('usage', `"${text}" is not a valid address.`, 'Give the full address, such as http://127.0.0.1:8080/.');
+    }
+  }
+  const file = path.resolve(text);
+  try {
+    await fs.access(file);
+  } catch {
+    throw new CheckError('usage', `There is no file at ${file}.`, 'Give the path of an HTML file, or an address that starts with http:// or https://.');
+  }
+  return new URL(pathToFileURL(file).href);
+}
+
+// The report names the page without its query, fragment or credentials: a token in an address stays out of the output.
+function shownTarget(url) {
+  const copy = new URL(url.href);
+  copy.username = '';
+  copy.password = '';
+  copy.search = '';
+  copy.hash = '';
+  return copy.href;
+}
+
+async function launchBrowser(choice) {
+  const names = choice === 'auto' ? ['chrome', 'msedge', 'chromium'] : [choice];
+  const attempts = [];
+  for (const name of names) {
+    const options = { headless: true };
+    if (name === 'chrome' || name === 'msedge') options.channel = name;
+    else if (name !== 'chromium') options.executablePath = name;
+    try {
+      return { browser: await chromium.launch(options), name };
+    } catch (error) {
+      attempts.push(`${name}: ${firstLine(error)}`);
+    }
+  }
+  throw new CheckError('browser_missing', `No browser could be started. ${attempts.join(' | ')}`, 'Install Google Chrome or Microsoft Edge, or pass --browser with the path of an installed Chromium-based browser; then run the check again.');
+}
+
+async function checkViewport(browser, target, [width, height], out, settle, values) {
+  const context = await browser.newContext({ viewport: { width, height } });
+  try {
+    const page = await context.newPage();
+    const pageErrors = [];
+    const consoleErrors = [];
+    const outside = new Set();
+    page.on('pageerror', error => pageErrors.push(firstLine(error)));
+    page.on('console', message => { if (message.type() === 'error') consoleErrors.push(message.text().slice(0, 300)); });
+    page.on('request', request => {
+      const url = new URL(request.url());
+      if ((url.protocol === 'http:' || url.protocol === 'https:') && url.origin !== target.origin) outside.add(url.origin + url.pathname);
+    });
+    const httpErrors = new Map();
+    page.on('response', response => {
+      if (response.status() < 400) return;
+      const url = new URL(response.url()), address = url.origin + url.pathname;
+      httpErrors.set(`${response.status()} ${address}`, { status: response.status(), url: address });
+    });
+    try {
+      await page.goto(target.href, { waitUntil: 'load', timeout: 30000 });
+    } catch (error) {
+      throw new CheckError('unreachable', `The page did not load: ${firstLine(error)}`, 'Check the address, that the service is running or the file exists, and that the page opens in a browser; then run the check again.');
+    }
+    await page.waitForTimeout(settle);
+    const findings = await pageFindings(page, { selector: values.overlap ?? null });
+    const screenshot = path.join(out, `${width}x${height}.png`);
+    await page.screenshot({ path: screenshot, fullPage: Boolean(values['full-page']) });
+    return {
+      viewport: `${width}x${height}`, screenshot, ...findings,
+      pageErrors, consoleErrors,
+      httpErrors: [...httpErrors.values()].slice(0, 20), httpErrorsTotal: httpErrors.size,
+      requestsOutsideTarget: [...outside].slice(0, 20), requestsOutsideTargetTotal: outside.size,
+    };
+  } finally {
+    await context.close();
+  }
+}
+
+async function main(argv) {
+  let parsed;
+  try {
+    parsed = parseArgs({
+      args: argv,
+      allowPositionals: true,
+      options: {
+        viewport: { type: 'string', multiple: true },
+        out: { type: 'string' },
+        overlap: { type: 'string' },
+        'full-page': { type: 'boolean' },
+        settle: { type: 'string' },
+        browser: { type: 'string' },
+        help: { type: 'boolean', short: 'h' },
+      },
+    });
+  } catch (error) {
+    throw new CheckError('usage', firstLine(error), 'Run rho-screen-check --help to see the options.');
+  }
+  const { values, positionals } = parsed;
+  if (values.help) {
+    process.stdout.write(usage);
+    return 0;
+  }
+  if (positionals.length !== 1) throw new CheckError('usage', 'Give exactly one page: a URL or an HTML file.', 'Run rho-screen-check --help to see the forms.');
+  const target = await targetOf(positionals[0]);
+  const sizes = values.viewport?.length ? values.viewport.map(parseSize) : viewports;
+  const settle = values.settle === undefined ? 800 : Number(values.settle);
+  if (!Number.isInteger(settle) || settle < 0 || settle > 10000) throw new CheckError('usage', `--settle must be a whole number of milliseconds from 0 to 10000, not "${values.settle}".`, 'Use a form such as --settle 800.');
+  const out = path.resolve(values.out ?? 'screen-check');
+  await fs.mkdir(out, { recursive: true });
+  const { browser, name } = await launchBrowser(values.browser ?? 'auto');
+  try {
+    const reports = [];
+    for (const size of sizes) reports.push(await checkViewport(browser, target, size, out, settle, values));
+    const report = { tool: 'rho-screen-check', target: shownTarget(target), browser: name, checkedAt: new Date().toISOString(), viewports: reports };
+    const file = path.join(out, 'report.json');
+    await fs.writeFile(file, JSON.stringify(report, null, 2) + '\n');
+    process.stdout.write(JSON.stringify({ ok: true, ...report, report: file }, null, 2) + '\n');
+    return 0;
+  } finally {
+    await browser.close();
+  }
+}
+
+try {
+  process.exitCode = await main(process.argv.slice(2));
+} catch (error) {
+  const usageError = error instanceof CheckError && error.kind === 'usage';
+  const detail = error instanceof CheckError
+    ? { kind: error.kind, message: error.message, next: error.next }
+    : { kind: 'failed', message: firstLine(error), next: 'Run the check again. If it fails the same way, open the page in a browser and read what it shows.' };
+  process.stdout.write(JSON.stringify({ ok: false, error: detail }, null, 2) + '\n');
+  process.exitCode = usageError ? 1 : 2;
+}

package/scripts/third-party-acceptance.mjs

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+// An opt-in, real scientific episode. R packages must already be available;
+// this script never installs dependencies or touches an existing R session.
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import assert from 'node:assert/strict';
+import { fileURLToPath } from 'node:url';
+import { RhoService } from '../dist/server.js';
+import { RhoClient } from '../dist/client.js';
+
+const repo = fileURLToPath(new URL('../', import.meta.url));
+const source = process.env.RHO_SCLET_PLUGIN ?? path.resolve(repo, '../Rho-plugins/examples/sclet-plugin');
+const root = await fs.mkdtemp(path.join(os.tmpdir(), 'rho-third-party-'));
+await fs.mkdir(path.join(root, 'project'));
+const service = await new RhoService({ root, stateDir: path.join(root, 'state'), rscript: process.env.RHO_RSCRIPT ?? 'Rscript', example: false }).start();
+const client = new RhoClient({ url: service.url, token: service.adminToken });
+const project = await client.call('project.open', { path: 'project' });
+const notes = [];
+let sequence = 0;
+const text = cell => cell.outputs.map(output => output.text ?? '').join('\n') + (cell.error ? '\n' + JSON.stringify(cell.error) : '');
+const json = value => JSON.parse(value.slice(value.indexOf('{'), value.lastIndexOf('}') + 1));
+async function finished(cell) {
+  for (let i = 0; i < 600; i++) {
+    const current = (await client.call('kernel.read', { projectId: project.id, cellId: cell.cellId })).cells[0];
+    if (['done', 'error', 'unknown', 'interrupted'].includes(current.state)) return current;
+    await new Promise(resolve => setTimeout(resolve, 500));
+  }
+  throw new Error('Observation deadline reached; original cell: ' + cell.cellId);
+}
+try {
+  const plugin = await client.call('extension.install', { source });
+  const invoke = (operation, input = {}, changeId = 'acceptance-' + ++sequence) => client.call('extension.call', { projectId: project.id, pluginId: plugin.id, expectedDigest: plugin.digest, operation, input, changeId });
+  assert.deepEqual((await invoke('sessions')).value.sessions, []);
+  async function run(operation, input = {}) {
+    const receipt = await invoke(operation, input); assert.equal(receipt.state, 'completed', receipt.error);
+    const cell = await finished(receipt.value.cell); notes.push({ operation, cellId: cell.cellId, state: cell.state });
+    assert.equal(cell.state, 'done', text(cell)); return { receipt, cell, text: text(cell) };
+  }
+  const library = process.env.RHO_SCLET_LIBRARY;
+  const seedCode = `${library ? '.libPaths(c(' + JSON.stringify(library) + ', .libPaths()))\n' : ''}if (!requireNamespace("sclet", quietly=TRUE)) stop("Set RHO_SCLET_LIBRARY to an existing sclet library.")\nset.seed(19)\nsce <- scuttle::mockSCE(ncells=60, ngenes=200)`;
+  const seed = await client.call('kernel.run', { projectId: project.id, language: 'r', code: seedCode, purpose: 'Disposable third-party plugin trial', changeId: 'seed', waitMs: 0 });
+  const seeded = await finished(seed.cell); assert.equal(seeded.state, 'done', text(seeded));
+  const packages = await run('check');
+  const before = json((await run('ledger', { object: 'sce', includeArtifacts: true })).text);
+  await run('registry', { object: 'sce' }); await run('skill', { name: 'sclet-driver' });
+  const plan = { task: 'plugin-acceptance', context_fingerprint: before.fingerprint, actions: [
+    { id: 'normalize', action: 'normalize_data' },
+    { id: 'hvg', action: 'find_variable_features', params: { nfeatures: 50 }, depends_on: 'normalize' },
+    { id: 'scale', action: 'scale_data', depends_on: 'hvg' },
+    { id: 'pca', action: 'run_pca', params: { ncomponents: 5 }, depends_on: 'scale' },
+  ] };
+  const validated = json((await run('validate', { object: 'sce', plan })).text); assert.equal(validated.validation.valid, true);
+  const executeBody = { validationId: validated.validationId };
+  const execution = await invoke('execute', executeBody, 'execute-once'); assert.equal(execution.state, 'completed', execution.error);
+  const executed = await finished(execution.value.cell); assert.equal(executed.state, 'done', text(executed));
+  assert.equal(json(text(executed)).status, 'completed');
+  assert.equal((await invoke('execute', executeBody, 'execute-once')).value.cell.cellId, executed.cellId);
+  await run('record', { object: 'sce', recordId: 'smoke-report', result: {
+    task: 'plugin-acceptance', answer: 'A synthetic 200-gene, 60-cell input completed normalization, variable feature selection, scaling and PCA. This verifies software integration; no biological conclusion is claimed.',
+    findings: [], evidence: [], warnings: ['Synthetic input, not evidence for a biological hypothesis.'], recommendations: [], proposed_actions: [], success_criteria: [], stop_conditions: [], context: { fingerprint: json(text(executed)).fingerprint }, metadata: { provider: 'integration-test' },
+  } });
+  const report = await run('report', { object: 'sce', recordId: 'smoke-report' }); assert.match(report.text, /all checks passed/);
+  const after = json((await run('ledger', { object: 'sce', includeArtifacts: true })).text);
+  assert.equal(after.dataset.reductions, 'PCA'); assert.equal(after.features.hvg.n, 50);
+  assert.equal(json((await run('validate', { object: 'sce', plan })).text).validation.valid, false);
+  await client.call('extension.manage', { pluginId: plugin.id, expectedDigest: plugin.digest, action: 'disable' });
+  await assert.rejects(invoke('ledger', { object: 'sce' }), /disabled/);
+  await client.call('extension.manage', { pluginId: plugin.id, expectedDigest: plugin.digest, action: 'remove' });
+  assert.equal((await invoke('execute', executeBody, 'execute-once')).value.cell.cellId, executed.cellId);
+  const sessions = await client.call('kernel.read', { projectId: project.id, limit: 1 });
+  assert.ok(sessions.sessions.some(s => s.sessionId === seed.cell.sessionId && s.state !== 'ended'));
+  const output = path.resolve(process.env.RHO_THIRD_PARTY_OUTPUT ?? path.join(repo, 'output/third-party-plugins/acceptance.json'));
+  await fs.mkdir(path.dirname(output), { recursive: true });
+  await fs.writeFile(output, JSON.stringify({ at: new Date().toISOString(), node: process.version, platform: process.platform, source, digest: plugin.digest, packages: packages.text, notes, execution: json(text(executed)), report: report.text, lifecycle: 'disable/remove retained original cell and live R session', passed: true }, null, 2) + '\n');
+  console.log(JSON.stringify({ passed: true, output }));
+} finally { await service.close(); await fs.rm(root, { recursive: true, force: true }); }