kryptheon 0.1.0 → 0.1.2

package/bin/kryptheon.js

@@ -10,7 +10,7 @@
 
 const fs = require('fs');
 const path = require('path');
-const { spawnSync } = require('child_process');
+const { spawn, spawnSync } = require('child_process');
 
 const PACKAGE_DIR = path.join(__dirname, '..');
 const USER_DIR = process.cwd();
@@ -19,6 +19,10 @@ const TESTS_DIR = path.join(USER_DIR, 'tests');
 
 const MIN_NODE = [20, 6, 0];
 
+// How long to wait for a browser window to appear before giving up.
+const WINDOW_POLL_MS = 3000;
+const WINDOW_TIMEOUT_MS = 30000;
+
 function nodeIsTooOld(version) {
   const parts = String(version || process.versions.node).split('.').map(Number);
   for (let i = 0; i < MIN_NODE.length; i++) {
@@ -58,28 +62,36 @@ function findPlaywrightCli() {
 
 // Always runs with the user's folder as the working directory, so tests,
 // baselines and .env are found where they actually live.
-function runPlaywright(args) {
+// Returns { status, stderr }. With quietErrors the child's stderr is captured
+// rather than inherited, so a Node or Playwright stack trace never reaches the
+// person running the command.
+function runPlaywright(args, options) {
+  const quiet = !!(options && options.quietErrors);
   const cli = findPlaywrightCli();
   if (!cli) {
     console.error('');
     console.error('  The testing engine is missing from this install.');
     console.error('  Reinstalling usually fixes it:  npm install -g kryptheon');
     console.error('');
-    return 1;
+    return { status: 1, stderr: '' };
   }
 
   const result = spawnSync(process.execPath, [cli].concat(args), {
     cwd: USER_DIR,
-    stdio: 'inherit',
+    stdio: quiet ? ['inherit', 'inherit', 'pipe'] : 'inherit',
+    encoding: 'utf8',
   });
 
   if (result.error) {
     console.error('');
     console.error('  Could not start the testing engine: ' + result.error.message);
     console.error('');
-    return 1;
+    return { status: 1, stderr: String(result.stderr || '') };
   }
-  return result.status === null ? 1 : result.status;
+  return {
+    status: result.status === null ? 1 : result.status,
+    stderr: String(result.stderr || ''),
+  };
 }
 
 // Chromium is a separate download from the npm package, so the first run on a
@@ -97,7 +109,7 @@ function ensureBrowser() {
   console.log('  Downloading a browser to run your app in.');
   console.log('  This is about 200MB and only happens once.');
   console.log('');
-  const status = runPlaywright(['install', 'chromium']);
+  const status = runPlaywright(['install', 'chromium']).status;
   if (status !== 0) {
     console.error('');
     console.error('  The browser download did not finish.');
@@ -125,6 +137,171 @@ function listSpecFiles() {
     .filter((name) => /\.(spec|test)\.(c|m)?[jt]sx?$/.test(name));
 }
 
+// A plain GET on Node's own http/https, deliberately NOT fetch. fetch keeps
+// its sockets alive in a pool, and those were still open at exit - handles
+// being torn down while the process is ending is how libuv assertions happen
+// on Windows. agent:false closes the socket as soon as we are done with it.
+function httpGet(url, timeoutMs, redirectsLeft) {
+  return new Promise((resolve, reject) => {
+    let parsed;
+    try {
+      parsed = new URL(url);
+    } catch (err) {
+      return reject(Object.assign(new Error('bad address'), { code: 'ERR_INVALID_URL' }));
+    }
+    const lib = parsed.protocol === 'https:' ? require('https') : require('http');
+    const req = lib.get(url, { agent: false, timeout: timeoutMs || 8000 }, (res) => {
+      const location = res.headers && res.headers.location;
+      if (location && res.statusCode >= 300 && res.statusCode < 400 && (redirectsLeft || 0) > 0) {
+        res.resume();
+        req.destroy();
+        return resolve(httpGet(new URL(location, url).toString(), timeoutMs, redirectsLeft - 1));
+      }
+      let body = '';
+      res.setEncoding('utf8');
+      res.on('data', (chunk) => {
+        if (body.length < 300000) body += chunk;
+      });
+      res.on('end', () => {
+        req.destroy();
+        resolve({ status: res.statusCode, body: body });
+      });
+    });
+    req.on('timeout', () => {
+      req.destroy(Object.assign(new Error('timed out'), { code: 'ETIMEDOUT' }));
+    });
+    req.on('error', reject);
+  });
+}
+
+// --- is the address actually there? ----------------------------------------
+
+// "localhost:3000" is what people type; give it a scheme before using it.
+function normaliseRecordUrl(url) {
+  const s = String(url == null ? '' : url).trim();
+  if (!s) return s;
+  if (/^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.test(s)) return s;
+  return 'http://' + s;
+}
+
+function isLocalAddress(url) {
+  let host;
+  try {
+    host = new URL(url).hostname.toLowerCase();
+  } catch (err) {
+    return false;
+  }
+  return (
+    host === 'localhost' ||
+    host === '127.0.0.1' ||
+    host === '0.0.0.0' ||
+    host === '::1' ||
+    host === '[::1]' ||
+    host.endsWith('.local') ||
+    host.endsWith('.localhost')
+  );
+}
+
+// Turns a fetch failure into one of a few plain kinds. Split out from the
+// network call so it can be checked without a network.
+function classifyFetchError(err) {
+  const code = (err && err.cause && err.cause.code) || (err && err.code) || null;
+  if (code === 'ECONNREFUSED') return 'refused';
+  if (code === 'ENOTFOUND' || code === 'EAI_AGAIN') return 'unknown-address';
+  if (err && err.name === 'AbortError') return 'timeout';
+  if (code === 'ETIMEDOUT' || code === 'ECONNRESET') return 'timeout';
+  // A certificate complaint means something IS answering there. Let the
+  // browser deal with it rather than blocking the recording.
+  if (code && /CERT|SSL|SELF_SIGNED|VERIFY/i.test(String(code))) return 'reachable';
+  return 'other';
+}
+
+async function reachability(url, timeoutMs) {
+  try {
+    await httpGet(url, timeoutMs || 8000, 0);
+    return { ok: true, kind: 'reachable' };
+  } catch (err) {
+    const kind = classifyFetchError(err);
+    return kind === 'reachable' ? { ok: true, kind: kind } : { ok: false, kind: kind };
+  }
+}
+
+// One place that explains an address not answering, used both before codegen
+// starts and if codegen itself reports the same thing.
+function explainUnreachable(url, kind) {
+  const local = isLocalAddress(url);
+  console.error('');
+  console.error('  Nothing answered at ' + url);
+  console.error('');
+
+  if (kind === 'unknown-address') {
+    console.error('  That web address could not be found.');
+    console.error('  Check the spelling, and that you are connected to the internet.');
+  } else if (kind === 'timeout') {
+    console.error('  The address did not answer in time.');
+    console.error('  It may be slow, or blocked by a firewall or VPN.');
+  } else if (local) {
+    console.error('  Your app does not look like it is running.');
+    console.error('');
+    console.error('  For an app on your own machine, start it first - usually:');
+    console.error('    npm run dev');
+    console.error('');
+    console.error('  Then check the address and port match what it printed.');
+  } else {
+    console.error('  Nothing is listening at that address.');
+    console.error('  Check the address, including the port number, and that the site is up.');
+  }
+
+  console.error('');
+  console.error('  Nothing was recorded.');
+  console.error('');
+}
+
+// Codegen writes Node/Playwright traces to stderr. We never show those; we
+// pick out the part that means something and say it in plain words.
+function explainCodegenFailure(url, stderr) {
+  const text = String(stderr || '');
+  if (/ERR_CONNECTION_REFUSED/.test(text)) return explainUnreachable(url, 'refused');
+  if (/ERR_NAME_NOT_RESOLVED/.test(text)) return explainUnreachable(url, 'unknown-address');
+  if (/ERR_CONNECTION_TIMED_OUT|ERR_TIMED_OUT/.test(text)) return explainUnreachable(url, 'timeout');
+  if (/ERR_INTERNET_DISCONNECTED/.test(text)) {
+    console.error('');
+    console.error('  There is no internet connection.');
+    console.error('');
+    console.error('  Nothing was recorded.');
+    console.error('');
+    return;
+  }
+  console.error('');
+  console.error('  The browser closed before anything could be recorded.');
+  console.error('');
+  console.error('  Check that ' + url + ' opens normally in your own browser,');
+  console.error('  then try again.');
+  console.error('');
+  console.error('  Nothing was recorded.');
+  console.error('');
+}
+
+// A recording is only worth keeping if the browser actually did something.
+// An abandoned or failed run leaves a test body with no page calls at all.
+function countRecordedActions(source) {
+  const found = String(source || '').match(/\bpage\s*\.\s*[A-Za-z_$][\w$]*\s*\(/g);
+  return found ? found.length : 0;
+}
+
+// A spec that pulls Playwright in directly gets none of our diagnostics.
+function importsPlaywrightDirectly(source) {
+  const text = String(source || '');
+  // The literal specifier is what matters; import and require both carry it.
+  return text.indexOf("'@playwright/test'") !== -1 || text.indexOf('"@playwright/test"') !== -1;
+}
+
+// codegen always writes the opening page.goto. A recording is only real if
+// something else happened as well.
+function isRealRecording(source) {
+  return countRecordedActions(source) >= 2;
+}
+
 function timestampName() {
   const d = new Date();
   const pad = (n) => String(n).padStart(2, '0');
@@ -198,13 +375,9 @@ function nameFromTitle(title) {
 // to the recorded path if this cannot be reached.
 async function fetchTitle(url) {
   try {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), 5000);
-    const res = await fetch(url, { signal: controller.signal });
-    clearTimeout(timer);
-    if (!res.ok) return null;
-    const html = await res.text();
-    const m = html.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
+    const res = await httpGet(url, 5000, 2);
+    if (!res || res.status < 200 || res.status >= 300) return null;
+    const m = String(res.body).match(/<title[^>]*>([\s\S]*?)<\/title>/i);
     return m ? m[1].replace(/\s+/g, ' ').trim() : null;
   } catch (err) {
     return null;
@@ -294,6 +467,127 @@ async function nameRecording(relativeFile) {
   }
   return target;
 }
+// Recording needs a real browser window on someone's screen. Inside an AI
+// coding assistant there is no desktop to draw it on, so codegen would sit
+// there forever and the run would be killed before anything was tidied up.
+function looksLikeNoDesktop() {
+  if (process.env.KRYPTHEON_FORCE_RECORD) return false;
+  return !process.stdout.isTTY;
+}
+
+function explainNoWindow(url) {
+  console.error('');
+  console.error('  Recording needs a real browser window on your screen.');
+  console.error('');
+  console.error('  This terminal cannot show one - that is what happens inside an');
+  console.error('  AI coding assistant, or any window-less session.');
+  console.error('');
+  console.error('  Open Command Prompt (or PowerShell) yourself and run:');
+  console.error('    npx kryptheon record ' + url);
+  console.error('');
+  console.error('  Nothing was recorded.');
+  console.error('');
+}
+
+// Is a Playwright-controlled browser actually showing a window?
+function browserWindowIsUp() {
+  try {
+    if (process.platform === 'win32') {
+      const probe = spawnSync(
+        'powershell',
+        [
+          '-NoProfile',
+          '-Command',
+          "@(Get-Process chrome,msedge -ErrorAction SilentlyContinue | " +
+            "Where-Object { $_.Path -like '*ms-playwright*' -and $_.MainWindowHandle -ne 0 }).Count",
+        ],
+        { encoding: 'utf8', windowsHide: true, timeout: 8000 }
+      );
+      return Number(String(probe.stdout || '').trim()) > 0;
+    }
+    const probe = spawnSync('ps', ['-A', '-o', 'command'], { encoding: 'utf8', timeout: 8000 });
+    return /ms-playwright/.test(String(probe.stdout || ''));
+  } catch (err) {
+    return true; // cannot tell - do not block the user
+  }
+}
+
+// Runs codegen without blocking the event loop, so SIGINT and SIGTERM can
+// still be handled. spawnSync would freeze the loop and no handler would run.
+function startCodegen(args) {
+  const cli = findPlaywrightCli();
+  if (!cli) {
+    console.error('');
+    console.error('  The testing engine is missing from this install.');
+    console.error('  Reinstalling usually fixes it:  npm install -g kryptheon');
+    console.error('');
+    return null;
+  }
+  return spawn(process.execPath, [cli].concat(args), {
+    cwd: USER_DIR,
+    stdio: ['inherit', 'inherit', 'pipe'],
+  });
+}
+
+// Everything that has to happen to whatever codegen left behind, however
+// the run ended. Module level so it can be exercised directly.
+async function finaliseRecording(outFile, context) {
+  const ctx = context || {};
+  const specPath = path.join(USER_DIR, outFile);
+  let source = null;
+  try {
+    source = fs.readFileSync(specPath, 'utf8');
+  } catch (err) {
+    source = null;
+  }
+
+  if (source !== null && isRealRecording(source)) {
+    // Import rewrite first: it is instant, so even a second interruption
+    // leaves behind a spec that works.
+    pointAtFixture(outFile);
+    const named = await nameRecording(outFile);
+    console.log('');
+    console.log('  Saved to ' + named);
+    console.log('  Run it any time with:  kryptheon check');
+    console.log('');
+    return { code: 0, savedAs: named };
+  }
+
+  if (source !== null) {
+    try {
+      fs.unlinkSync(specPath);
+    } catch (err) {
+      /* nothing more we can do */
+    }
+  }
+  if (!ctx.hadTestsDir) {
+    try {
+      if (fs.readdirSync(TESTS_DIR).length === 0) fs.rmdirSync(TESTS_DIR);
+    } catch (err) {
+      /* only tidying up */
+    }
+  }
+
+  if (ctx.reason === 'no-window') {
+    explainNoWindow(ctx.target);
+  } else if (ctx.reason === 'signal') {
+    console.log('');
+    console.log('  Recording stopped before anything was saved.');
+    console.log('');
+    console.log('  Nothing was recorded.');
+    console.log('');
+  } else if (source === null || /ERR_|Error:/.test(String(ctx.stderr || ''))) {
+    explainCodegenFailure(ctx.target, ctx.stderr);
+  } else {
+    console.log('');
+    console.log('  Nothing was recorded.');
+    console.log('');
+    console.log('  The browser closed before anything was clicked or typed.');
+    console.log('  Run the same command again and use your app before closing it.');
+    console.log('');
+  }
+  return { code: 1, savedAs: null };
+}
 
 async function record(url) {
   if (!url) {
@@ -305,18 +599,37 @@ async function record(url) {
     console.error('');
     return 1;
   }
+
+  const target = normaliseRecordUrl(url);
+
+  // No desktop means no window means nothing to record. Say so now rather
+  // than hanging until something kills us.
+  if (looksLikeNoDesktop()) {
+    explainNoWindow(target);
+    return 1;
+  }
+
+  // Fail early and kindly rather than letting codegen throw a stack trace.
+  const reach = await reachability(target);
+  if (!reach.ok) {
+    explainUnreachable(target, reach.kind);
+    return 1;
+  }
+
   if (!ensureBrowser()) return 1;
 
+  const hadTestsDir = fs.existsSync(TESTS_DIR);
   try {
     fs.mkdirSync(TESTS_DIR, { recursive: true });
   } catch (err) {
     /* codegen will report if it cannot write */
   }
 
-  let outFile = path.join('tests', timestampName());
+  const outFile = path.join('tests', timestampName());
+  const specPath = path.join(USER_DIR, outFile);
 
   console.log('');
-  console.log('  Opening ' + url + ' in a browser.');
+  console.log('  Opening ' + target + ' in a browser.');
   console.log('');
   console.log('  Use your app normally - click, type, sign in, whatever you want');
   console.log('  covered. Every step is recorded as you go.');
@@ -324,20 +637,74 @@ async function record(url) {
   console.log('  When you are done, close the browser window to save the test.');
   console.log('');
 
-  const status = runPlaywright(['codegen', '--target', 'playwright-test', '-o', outFile, url]);
+  const child = startCodegen(['codegen', '--target', 'playwright-test', '-o', outFile, target]);
+  if (!child) return 1;
 
-  // Keyed off the file rather than the exit code: codegen still writes the
-  // recording when the window is force-closed, and that file should be wired
-  // up the same way.
-  if (fs.existsSync(path.join(USER_DIR, outFile))) {
-    pointAtFixture(outFile);
-    outFile = await nameRecording(outFile);
-    console.log('');
-    console.log('  Saved to ' + outFile);
-    console.log('  Run it any time with:  kryptheon check');
-    console.log('');
-  }
-  return status;
+  let stderr = '';
+  if (child.stderr) child.stderr.on('data', (chunk) => { stderr += chunk.toString(); });
+
+  // Everything that has to happen no matter how this ends: tidy the file,
+  // wire it up, name it. Runs once, whether codegen exits on its own or we
+  // are interrupted.
+  let finished = false;
+  const finalise = async (reason) => {
+    if (finished) return 1;
+    finished = true;
+    const outcome = await finaliseRecording(outFile, {
+      hadTestsDir: hadTestsDir,
+      target: target,
+      stderr: stderr,
+      reason: reason,
+    });
+    return outcome.code;
+  };
+
+  const stopChild = () => {
+    try {
+      child.kill();
+    } catch (err) {
+      /* already gone */
+    }
+  };
+
+  return await new Promise((resolve) => {
+    // If no window ever appears, stop instead of waiting for someone to kill us.
+    let waited = 0;
+    const watchdog = setInterval(() => {
+      waited += WINDOW_POLL_MS;
+      if (browserWindowIsUp()) {
+        clearInterval(watchdog);
+        return;
+      }
+      if (waited >= WINDOW_TIMEOUT_MS) {
+        clearInterval(watchdog);
+        stopChild();
+        finalise('no-window').then(resolve);
+      }
+    }, WINDOW_POLL_MS);
+
+    const onSignal = () => {
+      clearInterval(watchdog);
+      stopChild();
+      finalise('signal').then(resolve);
+    };
+    process.once('SIGINT', onSignal);
+    process.once('SIGTERM', onSignal);
+    process.once('SIGHUP', onSignal);
+
+    child.on('error', () => {
+      clearInterval(watchdog);
+      finalise('error').then(resolve);
+    });
+
+    child.on('close', () => {
+      clearInterval(watchdog);
+      process.removeListener('SIGINT', onSignal);
+      process.removeListener('SIGTERM', onSignal);
+      process.removeListener('SIGHUP', onSignal);
+      finalise('exit').then(resolve);
+    });
+  });
 }
 
 // Recordings import the fixture by package name, which only resolves if
@@ -371,6 +738,46 @@ function specsNeedThePackage() {
   });
 }
 
+// Older versions, and any run that was killed part way, left specs behind that
+// import Playwright directly (so they produce no diagnostics) or that contain
+// nothing but the opening navigation (so they verify nothing). Repair the
+// first kind and refuse to run the second, rather than reporting a false OK.
+function triageSpecs() {
+  const repaired = [];
+  const notRecordings = [];
+  const runnable = [];
+
+  for (const name of listSpecFiles()) {
+    const full = path.join(TESTS_DIR, name);
+    let source;
+    try {
+      source = fs.readFileSync(full, 'utf8');
+    } catch (err) {
+      continue;
+    }
+
+    if (/(from|require\()\s*(['"])@playwright\/test\2/.test(source)) {
+      const relative = path.join('tests', name);
+      if (pointAtFixture(relative)) {
+        repaired.push(name);
+        try {
+          source = fs.readFileSync(full, 'utf8');
+        } catch (err) {
+          /* keep what we had */
+        }
+      }
+    }
+
+    if (!isRealRecording(source)) {
+      notRecordings.push(name);
+      continue;
+    }
+    runnable.push(name);
+  }
+
+  return { repaired: repaired, notRecordings: notRecordings, runnable: runnable };
+}
+
 function check() {
   if (!listSpecFiles().length) {
     console.log('');
@@ -396,8 +803,50 @@ function check() {
     console.log('');
     return 1;
   }
+  const triage = triageSpecs();
+
+  for (const name of triage.repaired) {
+    console.log('');
+    console.log('  Repaired ' + path.join('tests', name));
+    console.log('  It was saved without the part that explains failures. Fixed now.');
+  }
+
+  for (const name of triage.notRecordings) {
+    console.log('');
+    console.log('  Skipped ' + path.join('tests', name));
+    console.log('  This is not a real recording - it only opens a page and stops,');
+    console.log('  so it cannot tell you whether anything works.');
+    console.log('  Record it again:  kryptheon record <url>');
+  }
+
+  if (!triage.runnable.length) {
+    console.log('');
+    console.log('  Nothing could be checked.');
+    console.log('');
+    console.log('  None of the files in tests/ is a usable recording.');
+    console.log('  Record one with:  kryptheon record <url>');
+    console.log('');
+    return 1;
+  }
+
   if (!ensureBrowser()) return 1;
-  return runPlaywright(['test', '--config', CONFIG]);
+
+  // Only the usable recordings are handed to the test runner, so a file that
+  // cannot produce diagnostics can never be counted as passing.
+  const only = triage.runnable.map((name) => path.join('tests', name).split(path.sep).join('/'));
+  const status = runPlaywright(['test', '--config', CONFIG].concat(only)).status;
+
+  // Without this, a green summary could still hide a recording that checked
+  // nothing at all.
+  if (triage.notRecordings.length) {
+    const many = triage.notRecordings.length > 1;
+    console.log(
+      '  Note: ' + triage.notRecordings.length + ' recording' + (many ? 's' : '') +
+        ' above checked nothing and ' + (many ? 'were' : 'was') + ' skipped.'
+    );
+    console.log('');
+  }
+  return status;
 }
 
 // --- accept -----------------------------------------------------------------
@@ -502,6 +951,29 @@ function accept(name) {
 
 const [command, ...rest] = process.argv.slice(2);
 
+// process.exit() cuts the process off mid-teardown. On Windows a terminal's
+// output is written asynchronously, so exiting while the last line is still
+// queued tears down a handle that is already closing - which is what produces
+// "Assertion failed: !(handle->flags & UV_HANDLE_CLOSING)" in libuv. Setting
+// the code and letting Node wind down on its own avoids that entirely, and
+// still reports the same exit status.
+async function finishWith(code) {
+  process.exitCode = code;
+  const streams = [process.stdout, process.stderr];
+  await Promise.all(
+    streams.map(
+      (stream) =>
+        new Promise((resolve) => {
+          if (!stream || typeof stream.write !== 'function' || !stream.writableLength) return resolve();
+          const done = () => resolve();
+          stream.once('drain', done);
+          const guard = setTimeout(done, 1000);
+          if (guard.unref) guard.unref();
+        })
+    )
+  );
+}
+
 async function main() {
   if (nodeIsTooOld()) {
     console.error('');
@@ -511,31 +983,31 @@ async function main() {
     console.error('');
     console.error('  Download the latest from https://nodejs.org and try again.');
     console.error('');
-    process.exit(1);
+    return finishWith(1);
   }
 
   switch (command) {
     case 'record':
-      process.exit(await record(rest[0]));
+      return finishWith(await record(rest[0]));
       break;
     case 'check':
-      process.exit(check());
+      return finishWith(check());
       break;
     case 'accept':
-      process.exit(accept(rest.join(' ').trim()));
+      return finishWith(accept(rest.join(' ').trim()));
       break;
     case undefined:
     case '-h':
     case '--help':
     case 'help':
       usage();
-      process.exit(0);
+      return finishWith(0);
       break;
     default:
       console.error('');
       console.error('  Unknown command: ' + command);
       usage();
-      process.exit(1);
+      return finishWith(1);
   }
 }
 
@@ -548,6 +1020,16 @@ module.exports = {
   nameRecording: nameRecording,
   pointAtFixture: pointAtFixture,
   listSpecFiles: listSpecFiles,
+  countRecordedActions: countRecordedActions,
+  isRealRecording: isRealRecording,
+  importsPlaywrightDirectly: importsPlaywrightDirectly,
+  triageSpecs: triageSpecs,
+  record: record,
+  finaliseRecording: finaliseRecording,
+  looksLikeNoDesktop: looksLikeNoDesktop,
+  classifyFetchError: classifyFetchError,
+  normaliseRecordUrl: normaliseRecordUrl,
+  isLocalAddress: isLocalAddress,
   nodeIsTooOld: nodeIsTooOld,
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kryptheon",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Record what you do in your app and get plain-language reports when it breaks.",
   "license": "MIT",
   "type": "commonjs",