kryptheon 0.1.15 → 0.1.17

package/bin/kryptheon.js

@@ -40,10 +40,14 @@ const MIN_NODE = [20, 6, 0];
 const WINDOW_POLL_MS = 5000;
 const WINDOW_TIMEOUT_MS = 30000;
 const WINDOW_HARD_LIMIT_MS = 90000;
-// Lower than the poll interval on purpose: a probe still running when the next
-// one is due is of no use, and every extra second it holds the loop is a second
-// the watchdog is blind.
-const WINDOW_PROBE_TIMEOUT_MS = 4000;
+// This was 4 seconds, kept under the poll interval so a probe never held the
+// loop past the next one. Measured since, on a Windows 11 machine: the probe
+// takes 2.5-3 seconds with nothing else running, and while the browser was
+// starting it ran past 4 seconds three times in a row. On a slower machine
+// every probe ran out of time and nothing was ever learned. A probe that
+// answers late is worth more than one that never answers; the budget is
+// counted by the clock, so a slow tick costs nothing extra.
+const WINDOW_PROBE_TIMEOUT_MS = 10000;
 
 function nodeIsTooOld(version) {
   const parts = String(version || process.versions.node).split('.').map(Number);
@@ -614,6 +618,49 @@ function windowUndetectedLines(seconds) {
   ];
 }
 
+/**
+ * What to do with a browser whose window the watchdog could not confirm:
+ * 'leave' it running, or 'stop' it.
+ *
+ * Found on the first run by somebody new, on Windows 10: the browser opened,
+ * they used their app, and it closed under them - "almost the whole thing" -
+ * with nothing recorded. The probe is a fresh PowerShell each time: measured on
+ * a Windows 11 machine it takes 2.5-3 seconds idle, and ran past its 4 second
+ * limit three times in a row while the browser was starting. On a slower
+ * machine every probe runs out of time, the watchdog learns nothing for 90
+ * seconds, calls that 'unclear' - and the browser somebody was using was
+ * stopped on a guess.
+ *
+ * So the browser is only ever stopped on something known, and never when a
+ * person is at the keyboard to close it themselves:
+ *
+ *   window                       leave - it is up
+ *   unclear                      leave - nothing was learned, so nothing is done
+ *   no-window / never-started    leave with a keyboard, stop without one
+ *
+ * The watchdog exists for the case with no keyboard: an AI assistant, where
+ * there is no desktop and codegen would wait for ever. isTTY can be false in a
+ * perfectly good terminal, so false is not taken as proof of anything - that
+ * case keeps the old behaviour. True is taken as a person being there.
+ */
+function whenWindowUnconfirmed(verdict, atKeyboard) {
+  if (verdict === 'window' || verdict === 'unclear') return 'leave';
+  return atKeyboard ? 'leave' : 'stop';
+}
+
+// Said once, while the person may still be recording, instead of taking the
+// browser away from them.
+function windowUnconfirmedLines() {
+  return [
+    '',
+    '  (I could not confirm the browser window from here - that check is slow',
+    '  on some machines - so I am leaving it alone. If it is on your screen,',
+    '  carry on and close it when you are done. If there is no window',
+    '  anywhere, press Ctrl+C to stop.)',
+    '',
+  ];
+}
+
 // The probe kept failing to answer. Nothing was learned about the browser
 // either way, and saying "no window appeared" would be inventing a fact.
 function probeUnclearLines(answered, unanswered) {
@@ -1520,7 +1567,12 @@ async function record(url) {
       const outcome = watch.tick();
       if (!outcome) return;
       clearInterval(watchdog);
-      if (outcome.verdict === 'window') return;
+      if (whenWindowUnconfirmed(outcome.verdict, !!process.stdin.isTTY) === 'leave') {
+        if (outcome.verdict !== 'window') {
+          for (const line of windowUnconfirmedLines()) console.log(line);
+        }
+        return;
+      }
       stopChild();
       finalise(outcome.verdict, outcome).then(resolve);
     }, WINDOW_POLL_MS);
@@ -2005,6 +2057,57 @@ async function finishWith(code) {
   );
 }
 
+// The copy that must run `check` is the one the recordings load. Measured: in
+// a folder `record` set up, `npx kryptheon@latest check` ran npx's copy, whose
+// Playwright loads the config, while the recordings loaded the folder's copy -
+// two Playwrights, and "Requiring @playwright/test second time" before a single
+// recording ran. `npx kryptheon check` worked in the same folder only because
+// npx happened to pick the local copy.
+//
+// So when this is not the folder's copy, the folder's copy does the work.
+// Returns its exit code, or null to carry on here.
+function handToFolderCopy() {
+  if (process.env.KRYPTHEON_HANDED_OVER) return null; // once, never in a loop
+  const theirs = project.kryptheonCopyFor(USER_DIR);
+  if (!theirs) return null;
+  let same = false;
+  try {
+    same = fs.realpathSync(theirs) === fs.realpathSync(PACKAGE_DIR);
+  } catch (err) {
+    same = path.resolve(theirs) === path.resolve(PACKAGE_DIR);
+  }
+  if (same) return null;
+
+  let theirVersion = 'unknown';
+  try {
+    theirVersion = JSON.parse(fs.readFileSync(path.join(theirs, 'package.json'), 'utf8')).version;
+  } catch (err) {
+    /* said as unknown */
+  }
+  const mine = packageVersion();
+  if (theirVersion !== mine) {
+    // Not an error: the folder's copy is the one its recordings are written
+    // against. Said, so an older one is never mistaken for this one.
+    console.log('');
+    console.log('  Running the kryptheon installed in this folder (' + theirVersion + '), because your');
+    console.log('  recordings load that one. ' + (mine !== 'unknown' ? 'To move this folder to ' + mine + ':' : 'To update it:'));
+    console.log('    npm i -D kryptheon@latest');
+  }
+  const result = spawnSync(process.execPath, [path.join(theirs, 'bin', 'kryptheon.js')].concat(process.argv.slice(2)), {
+    cwd: USER_DIR,
+    stdio: 'inherit',
+    env: Object.assign({}, process.env, { KRYPTHEON_HANDED_OVER: '1' }),
+  });
+  if (result.error) {
+    console.error('');
+    console.error('  Could not run the kryptheon installed in this folder: ' + result.error.message);
+    console.error('  Reinstalling it usually fixes this:  npm i -D kryptheon@latest');
+    console.error('');
+    return 1;
+  }
+  return result.status === null ? 1 : result.status;
+}
+
 async function main() {
   if (nodeIsTooOld()) {
     console.error('');
@@ -2021,9 +2124,11 @@ async function main() {
     case 'record':
       return finishWith(await record(rest[0]));
       break;
-    case 'check':
+    case 'check': {
+      const handedOver = handToFolderCopy();
+      if (handedOver !== null) return finishWith(handedOver);
       return finishWith(check({ quiet: rest.indexOf('--quiet') !== -1 || rest.indexOf('-q') !== -1 }));
-      break;
+    }
     case 'remove':
     case 'rm':
       return finishWith(await remove(rest.join(" ").trim()));
@@ -2070,6 +2175,7 @@ module.exports = {
   rulesBlock: rulesBlock,
   record: record,
   prepareFolder: prepareFolder,
+  handToFolderCopy: handToFolderCopy,
   finaliseRecording: finaliseRecording,
   takeOutSecrets: takeOutSecrets,
   reportSecrets: reportSecrets,
@@ -2091,9 +2197,12 @@ module.exports = {
   dropOldRecordings: dropOldRecordings,
   askAboutExisting: askAboutExisting,
   askKey: askKey,
+  whenWindowUnconfirmed: whenWindowUnconfirmed,
+  windowUnconfirmedLines: windowUnconfirmedLines,
   WINDOW_TIMEOUT_MS: WINDOW_TIMEOUT_MS,
   WINDOW_HARD_LIMIT_MS: WINDOW_HARD_LIMIT_MS,
   WINDOW_POLL_MS: WINDOW_POLL_MS,
+  WINDOW_PROBE_TIMEOUT_MS: WINDOW_PROBE_TIMEOUT_MS,
   classifyFetchError: classifyFetchError,
   normaliseRecordUrl: normaliseRecordUrl,
   isLocalAddress: isLocalAddress,

package/kryptheon-project.js

@@ -238,6 +238,31 @@ function noRecordingsLines() {
 // missing before the browser, which is a 200MB download on a new machine, and
 // offers to add it.
 
+/**
+ * The installed kryptheon a recording saved in this folder will load - the
+ * nearest node_modules/kryptheon going up - or null if there is none.
+ *
+ * `check` must be run by this same copy. Found through the MCP server, then
+ * measured by hand in a folder `record` had set up: `npx kryptheon@latest
+ * check` runs npx's own copy, whose Playwright loads the config, while the
+ * recordings load this one's - and Playwright stops with "Requiring
+ * @playwright/test second time" before a single recording runs.
+ */
+function kryptheonCopyFor(dir) {
+  let current = path.resolve(String(dir || ''));
+  for (;;) {
+    const candidate = path.join(current, 'node_modules', 'kryptheon');
+    // Whole copies only. A half-finished install - the fixture there, the rest
+    // not - was handed the run and answered with Node's own stack trace.
+    const whole = ['kryptheon-fixture.js', 'package.json', path.join('bin', 'kryptheon.js')]
+      .every((f) => fs.existsSync(path.join(candidate, f)));
+    if (whole) return candidate;
+    const parent = path.dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+}
+
 /**
  * Whether kryptheon can be loaded by a recording saved in this folder.
  *
@@ -505,6 +530,7 @@ module.exports = {
   ESCAPE_HATCH: ESCAPE_HATCH,
   HOME_RECORDINGS: HOME_RECORDINGS,
   kryptheonReachableFrom: kryptheonReachableFrom,
+  kryptheonCopyFor: kryptheonCopyFor,
   kryptheonInstalledIn: kryptheonInstalledIn,
   projectAbove: projectAbove,
   setupPlan: setupPlan,

package/package.json

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