kryptheon 0.1.44 → 0.1.47
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +72 -0
- package/bin/kryptheon.js +3462 -3242
- package/kryptheon-dashboard-page.js +116 -11
- package/kryptheon-dashboard.html +8 -2
- package/kryptheon-dashboard.js +1132 -1009
- package/kryptheon-edge.js +792 -0
- package/kryptheon-look.js +1 -1
- package/kryptheon-probe-fixture.js +303 -0
- package/kryptheon-probe-reporter.js +29 -0
- package/kryptheon-probe.config.js +37 -0
- package/kryptheon-probe.js +317 -0
- package/kryptheon-reliability.js +599 -0
- package/kryptheon-replay.js +0 -0
- package/package.json +12 -4
|
@@ -0,0 +1,599 @@
|
|
|
1
|
+
// Reliability: does the app do the same thing every time?
|
|
2
|
+
//
|
|
3
|
+
// Two questions, asked of the person's own recorded flows:
|
|
4
|
+
//
|
|
5
|
+
// 1. Flaky. Each flow is replayed three times. A flow that fails and then
|
|
6
|
+
// works again - with nothing changed - does not work every time, and the
|
|
7
|
+
// failed run is the proof: which step, what it said, and anything the
|
|
8
|
+
// app answered differently in it (a 5xx the good runs did not get).
|
|
9
|
+
// Three failures are not flaky - the flow is broken, and the regression
|
|
10
|
+
// check says so. Works-then-stops-working is said as a thing to check,
|
|
11
|
+
// never as flaky: the first run's own data may be what is in the way.
|
|
12
|
+
//
|
|
13
|
+
// 2. Double-click. Each step that saves (Save, Add, Create, Submit...) is
|
|
14
|
+
// clicked twice, quickly, the way an impatient person does. When the app
|
|
15
|
+
// then saves twice - more successful POSTs to the same place than a
|
|
16
|
+
// single click makes - that is reported, with both answers as proof. A
|
|
17
|
+
// duplicate is run once more before it is called a problem.
|
|
18
|
+
//
|
|
19
|
+
// Slower networks are not tried in this release.
|
|
20
|
+
//
|
|
21
|
+
// Every run adds data to the app (the flows save what they were recorded
|
|
22
|
+
// saving), so nothing here starts on its own: kryptheon-probe.js asks first.
|
|
23
|
+
|
|
24
|
+
const fs = require('fs');
|
|
25
|
+
const path = require('path');
|
|
26
|
+
const replay = require('./kryptheon-replay.js');
|
|
27
|
+
const probe = require('./kryptheon-probe.js');
|
|
28
|
+
|
|
29
|
+
const ROUNDS = 3;
|
|
30
|
+
const CONFIRM_RUNS = 5;
|
|
31
|
+
// A re-check of a flaky flow needs more than three runs to say anything.
|
|
32
|
+
const RECHECK_ROUNDS = 5;
|
|
33
|
+
|
|
34
|
+
const CLICK = /^(\s*)(await\s+)?(page\s*\..+?)\.click\(\s*\)\s*;?\s*$/;
|
|
35
|
+
|
|
36
|
+
const ok = (w) => w.status >= 200 && w.status < 300;
|
|
37
|
+
const eventsOf = (r) => (r && r.events) || [];
|
|
38
|
+
const writesOf = (r) => eventsOf(r).filter((e) => e.kind === 'write');
|
|
39
|
+
const leftBehind = (w) => ok(w) && w.method !== 'DELETE' && !w.signIn;
|
|
40
|
+
const routeOf = (w) => w.method + ' ' + (w.origin || w.host || '') + w.path;
|
|
41
|
+
const limited = (r) => eventsOf(r).some((e) => e.kind === 'limited');
|
|
42
|
+
|
|
43
|
+
/**
|
|
44
|
+
* The steps that save, one per line: a plain click on a button whose name
|
|
45
|
+
* says it adds or saves something. Not a sign-up - that makes an account -
|
|
46
|
+
* and not one that only opens a form; that is found out at run time, when a
|
|
47
|
+
* single click of it saves nothing.
|
|
48
|
+
*/
|
|
49
|
+
function saveSteps(source) {
|
|
50
|
+
const lines = String(source || '').split('\n');
|
|
51
|
+
const out = [];
|
|
52
|
+
for (const a of replay.readActions(source)) {
|
|
53
|
+
if (a.method !== 'click' || !a.name) continue;
|
|
54
|
+
if (!replay.CREATES.test(a.name.trim()) || replay.SIGNUP.test(a.name)) continue;
|
|
55
|
+
const m = CLICK.exec(lines[a.line - 1].replace(/\r$/, ''));
|
|
56
|
+
if (!m) continue;
|
|
57
|
+
out.push({ line: a.line, indent: m[1], locator: m[3], name: a.name.trim() });
|
|
58
|
+
}
|
|
59
|
+
return out;
|
|
60
|
+
}
|
|
61
|
+
|
|
62
|
+
/** The plain replay, with a mark before and after each step that saves. */
|
|
63
|
+
function plainSource(source, steps) {
|
|
64
|
+
const before = {};
|
|
65
|
+
const after = {};
|
|
66
|
+
for (const s of steps) {
|
|
67
|
+
before[s.line] = s.indent + "await page.__kxMark('before-" + s.line + "');";
|
|
68
|
+
after[s.line] = s.indent + "await page.__kxMark('after-" + s.line + "');";
|
|
69
|
+
}
|
|
70
|
+
return probe.probeSource(source, { before: before, after: after });
|
|
71
|
+
}
|
|
72
|
+
|
|
73
|
+
/** The same, with one step clicked twice. */
|
|
74
|
+
function doubleSource(source, steps, step) {
|
|
75
|
+
const edits = {};
|
|
76
|
+
edits[step.line] = step.indent + 'await ' + step.locator + '.dblclick();';
|
|
77
|
+
const marked = steps.filter((s) => s.line === step.line);
|
|
78
|
+
const before = {};
|
|
79
|
+
const after = {};
|
|
80
|
+
for (const s of marked) {
|
|
81
|
+
before[s.line] = s.indent + "await page.__kxMark('before-" + s.line + "');";
|
|
82
|
+
after[s.line] = s.indent + "await page.__kxMark('after-" + s.line + "');";
|
|
83
|
+
}
|
|
84
|
+
return probe.probeSource(source, { edits: edits, before: before, after: after });
|
|
85
|
+
}
|
|
86
|
+
|
|
87
|
+
/** The writes a run made between the marks around one step. */
|
|
88
|
+
function windowWrites(result, line) {
|
|
89
|
+
const events = eventsOf(result);
|
|
90
|
+
const start = events.findIndex((e) => e.kind === 'mark' && e.name === 'before-' + line);
|
|
91
|
+
const end = events.findIndex((e) => e.kind === 'mark' && e.name === 'after-' + line);
|
|
92
|
+
if (start === -1 || end === -1 || end < start) return null;
|
|
93
|
+
return events.slice(start + 1, end).filter((e) => e.kind === 'write');
|
|
94
|
+
}
|
|
95
|
+
|
|
96
|
+
/** Successful POSTs that are not the sign-in, counted by where they went. */
|
|
97
|
+
function created(writes) {
|
|
98
|
+
const out = {};
|
|
99
|
+
for (const w of writes || []) {
|
|
100
|
+
if (w.method !== 'POST' || !ok(w) || w.signIn) continue;
|
|
101
|
+
(out[routeOf(w)] = out[routeOf(w)] || []).push(w);
|
|
102
|
+
}
|
|
103
|
+
return out;
|
|
104
|
+
}
|
|
105
|
+
|
|
106
|
+
function show(value) {
|
|
107
|
+
if (value === undefined) return '(no body kept)';
|
|
108
|
+
const s = typeof value === 'string' ? value : JSON.stringify(value);
|
|
109
|
+
return s.length > 120 ? s.slice(0, 100) + '... (' + s.length + ' characters)' : s;
|
|
110
|
+
}
|
|
111
|
+
|
|
112
|
+
function words(w) {
|
|
113
|
+
return w.method + ' ' + (w.host || '') + w.path + ' -> ' + w.status;
|
|
114
|
+
}
|
|
115
|
+
|
|
116
|
+
/**
|
|
117
|
+
* The records a server's answer names: the id (or uuid, or _id) of what it
|
|
118
|
+
* saved, from the answer itself, an array of rows, or a { data } wrapper.
|
|
119
|
+
* Empty when the answer says nothing about what was made.
|
|
120
|
+
*/
|
|
121
|
+
function recordIds(w) {
|
|
122
|
+
const answer = w && w.answer;
|
|
123
|
+
if (answer == null) return [];
|
|
124
|
+
const rows = Array.isArray(answer) ? answer : answer && typeof answer === 'object' && answer.data !== undefined
|
|
125
|
+
? [].concat(answer.data) : [answer];
|
|
126
|
+
const out = [];
|
|
127
|
+
for (const row of rows) {
|
|
128
|
+
if (!row || typeof row !== 'object') continue;
|
|
129
|
+
for (const k of ['id', 'uuid', '_id']) {
|
|
130
|
+
if (typeof row[k] === 'string' || typeof row[k] === 'number') {
|
|
131
|
+
out.push(String(row[k]));
|
|
132
|
+
break;
|
|
133
|
+
}
|
|
134
|
+
}
|
|
135
|
+
}
|
|
136
|
+
return out;
|
|
137
|
+
}
|
|
138
|
+
|
|
139
|
+
/** "Create work order" -> "work order": what the step makes, for the headline. */
|
|
140
|
+
function thingOf(name) {
|
|
141
|
+
const rest = String(name || '').replace(/^[^\p{L}\p{N}]*(add|create|new|save|submit|post|upload|send|register)\b\s*/iu, '').trim();
|
|
142
|
+
return rest || 'it';
|
|
143
|
+
}
|
|
144
|
+
|
|
145
|
+
// --- judging -------------------------------------------------------------
|
|
146
|
+
|
|
147
|
+
/**
|
|
148
|
+
* One flow's three runs, in the order they ran. Returns { outcome, finding?,
|
|
149
|
+
* why } - outcome 'flaky', 'stopped-working', 'held', 'broken' or 'not tested'.
|
|
150
|
+
*/
|
|
151
|
+
function judgeFlaky(flow, runs) {
|
|
152
|
+
const counted = runs.filter((r) => r && !limited(r));
|
|
153
|
+
if (counted.length < 2) {
|
|
154
|
+
return { outcome: 'not tested', why: runs.some(limited) ? 'your app said "too many requests" (429), so too few runs counted' : 'too few of the runs finished' };
|
|
155
|
+
}
|
|
156
|
+
const passed = counted.map((r) => r.status === 'passed');
|
|
157
|
+
if (passed.every(Boolean)) return { outcome: 'held', why: 'it worked all ' + counted.length + ' times' };
|
|
158
|
+
if (!passed.some(Boolean)) return { outcome: 'broken', why: 'it failed every time - that is a broken flow, which the regression check reports' };
|
|
159
|
+
const failedRun = counted[passed.indexOf(false)];
|
|
160
|
+
const goodRuns = counted.filter((r) => r.status === 'passed');
|
|
161
|
+
// Proof the app itself answered differently in the run that failed.
|
|
162
|
+
const seenGood = new Set();
|
|
163
|
+
for (const r of goodRuns) for (const e of eventsOf(r)) if (e.kind === 'server' || e.kind === 'error') seenGood.add(e.kind + ' ' + (e.text || routeOf(e)));
|
|
164
|
+
const onlyBad = eventsOf(failedRun).filter((e) => (e.kind === 'server' || e.kind === 'error') && !seenGood.has(e.kind + ' ' + (e.text || routeOf(e))));
|
|
165
|
+
const pattern = counted.map((r, i) => 'run ' + (i + 1) + ' ' + (r.status === 'passed' ? 'worked' : 'failed')).join(', ');
|
|
166
|
+
const where = flow.file + (failedRun.failedLine ? ':' + failedRun.failedLine : '');
|
|
167
|
+
const proof = [
|
|
168
|
+
'Flow: ' + flow.title + ' (' + flow.file + ')',
|
|
169
|
+
'Replayed ' + counted.length + ' times, nothing changed in between: ' + pattern + '.',
|
|
170
|
+
'The run that failed stopped' + (failedRun.failedLine ? ' at line ' + failedRun.failedLine : '') + ': ' + (failedRun.error || failedRun.status),
|
|
171
|
+
];
|
|
172
|
+
for (const e of onlyBad.slice(0, 3)) {
|
|
173
|
+
proof.push(e.kind === 'server' ? 'In that run only, the server answered: ' + e.method + ' ' + (e.host || '') + e.path + ' -> ' + e.status
|
|
174
|
+
: 'In that run only, the page threw: ' + e.text);
|
|
175
|
+
}
|
|
176
|
+
// A failure followed by a success proves it is not the first run's data in
|
|
177
|
+
// the way. Without one, it is a thing to check.
|
|
178
|
+
const recovered = passed.indexOf(false) < passed.lastIndexOf(true);
|
|
179
|
+
// Only the app's own answer proves the app: a 5xx or a page error that
|
|
180
|
+
// the runs that worked did not get. Without one, a recording that clicked
|
|
181
|
+
// before the page was ready fails in just the same way - so it is said as
|
|
182
|
+
// a thing to check, never as a problem in the app.
|
|
183
|
+
const appEvidence = onlyBad.length > 0;
|
|
184
|
+
if (!recovered) {
|
|
185
|
+
return {
|
|
186
|
+
outcome: 'stopped-working',
|
|
187
|
+
finding: {
|
|
188
|
+
flow: flow.title, where: where, kind: 'flaky', type: 'stopped-working', severity: 'LOW', status: 'verification required',
|
|
189
|
+
headline: 'The flow "' + flow.title + '" worked, then stopped working when replayed again - check whether that is expected.',
|
|
190
|
+
proof: proof.concat(['It never worked again after failing, so the data the first run saved may be what stops it (a name that must be unique, say).']),
|
|
191
|
+
},
|
|
192
|
+
};
|
|
193
|
+
}
|
|
194
|
+
return {
|
|
195
|
+
outcome: 'flaky',
|
|
196
|
+
finding: {
|
|
197
|
+
flow: flow.title, where: where, kind: 'flaky', type: 'flaky',
|
|
198
|
+
severity: appEvidence ? 'MEDIUM' : 'LOW', status: appEvidence ? 'confirmed' : 'verification required',
|
|
199
|
+
headline: appEvidence ? 'The flow "' + flow.title + '" does not work every time.'
|
|
200
|
+
: 'The flow "' + flow.title + '" did not work every time, but your app showed no error - check whether it is the app or the recording\'s timing.',
|
|
201
|
+
proof: proof.concat([appEvidence
|
|
202
|
+
? 'It failed and then worked again with nothing changed, and the app answered differently in the run that failed - so a person doing the same thing will sometimes see it fail.'
|
|
203
|
+
: 'Nothing your app answered was different in the run that failed: no 5xx, no page error. A step that ran before the page was ready fails the same way, so this is not proof the app is at fault.']),
|
|
204
|
+
},
|
|
205
|
+
};
|
|
206
|
+
}
|
|
207
|
+
|
|
208
|
+
/**
|
|
209
|
+
* A step clicked twice, against the same step clicked once. Returns
|
|
210
|
+
* { outcome, finding?, why } - 'duplicate', 'held', 'not tested'.
|
|
211
|
+
*/
|
|
212
|
+
function judgeDouble(flow, step, single, double) {
|
|
213
|
+
if (!double) return { outcome: 'not tested', why: 'this run did not finish' };
|
|
214
|
+
if (limited(double)) return { outcome: 'not tested', why: 'your app said "too many requests" (429)' };
|
|
215
|
+
const once = windowWrites(single, step.line);
|
|
216
|
+
const twice = windowWrites(double, step.line);
|
|
217
|
+
if (!once) return { outcome: 'not tested', why: 'the plain replay did not reach this step' };
|
|
218
|
+
if (!twice) return { outcome: 'not tested', why: 'the double-click run did not get past this step' };
|
|
219
|
+
const one = created(once);
|
|
220
|
+
const two = created(twice);
|
|
221
|
+
for (const route of Object.keys(two)) {
|
|
222
|
+
const before = (one[route] || []).length;
|
|
223
|
+
if (!before) continue; // only what a single click saves is compared
|
|
224
|
+
if (two[route].length <= before) continue;
|
|
225
|
+
const answers = two[route];
|
|
226
|
+
// The server naming one record twice saved it once and answered twice:
|
|
227
|
+
// that is the safe way to handle a double-click, not a duplicate.
|
|
228
|
+
const ids = answers.map(recordIds);
|
|
229
|
+
const named = ids.every((list) => list.length);
|
|
230
|
+
const distinct = Array.from(new Set([].concat.apply([], ids)));
|
|
231
|
+
if (named && distinct.length === 1) {
|
|
232
|
+
return { outcome: 'held', why: 'the server answered both clicks with the same record (id ' + distinct[0] + ') - it was saved once' };
|
|
233
|
+
}
|
|
234
|
+
const same = answers.length >= 2 && JSON.stringify(answers[0].data) === JSON.stringify(answers[1].data);
|
|
235
|
+
const thing = thingOf(step.name);
|
|
236
|
+
return {
|
|
237
|
+
outcome: 'duplicate',
|
|
238
|
+
finding: {
|
|
239
|
+
flow: flow.title, where: flow.file + ':' + step.line, kind: 'double', type: 'double', step: step.name,
|
|
240
|
+
severity: 'HIGH', status: 'confirmed',
|
|
241
|
+
headline: 'Double-clicking "' + step.name + '" saves it twice.',
|
|
242
|
+
proof: [
|
|
243
|
+
'Flow: ' + flow.title + ' (' + flow.file + ':' + step.line + ')',
|
|
244
|
+
'One click on "' + step.name + '": ' + before + ' x ' + route.split(' ')[0] + ' ' + (answers[0].host || '') + answers[0].path + ' answered ' + (one[route] || []).map((w) => w.status).join(', ') + '.',
|
|
245
|
+
'A quick double-click: ' + answers.length + ' x, answered ' + answers.map((w) => w.status).join(', ') + ' - ' + answers.length + ' ' + thing + (/s$/.test(thing) ? '' : 's') + ' created where one was meant.',
|
|
246
|
+
].concat(answers.slice(0, 2).map((w, i) => 'Answer ' + (i + 1) + ': ' + words(w) + ', sent ' + show(w.data !== undefined ? w.data : w.text))).concat(
|
|
247
|
+
same ? ['Both requests carried the same data: the same thing, saved twice.'] : [],
|
|
248
|
+
named ? ['The server\'s answers name ' + distinct.length + ' different records: ' + distinct.map((id) => 'id ' + id).join(', ') + '.']
|
|
249
|
+
: ['The server\'s answers do not say which record each one made, so the proof is the ' + answers.length + ' successful answers.']),
|
|
250
|
+
},
|
|
251
|
+
};
|
|
252
|
+
}
|
|
253
|
+
const posts = Object.keys(one).length;
|
|
254
|
+
return { outcome: 'held', why: posts ? 'a double-click saved it once, as a single click does' : 'a single click of it saves nothing by itself' };
|
|
255
|
+
}
|
|
256
|
+
|
|
257
|
+
/** The fix, said for an AI assistant: what was seen, the proof, and what not to do. */
|
|
258
|
+
function fixPrompt(f) {
|
|
259
|
+
const what = {
|
|
260
|
+
flaky: 'Find why this sometimes fails - a request that sometimes errors, a race between two loads, something not waited for - and make it work every time. Look first at the server answer named above, if there is one.',
|
|
261
|
+
'stopped-working': 'Check whether replaying this flow is meant to fail the second time (for example a name that must be unique). If it is meant to, say so. If not, fix it.',
|
|
262
|
+
double: 'Make saving safe against a double-click: disable the button while the save is in flight, and make the server ignore a repeat of the same request (an idempotency key, or a unique constraint on what makes it the same).',
|
|
263
|
+
}[f.type];
|
|
264
|
+
return [
|
|
265
|
+
'My app does not behave the same way every time. Please fix the app - and nothing else.',
|
|
266
|
+
'',
|
|
267
|
+
'Kryptheon replayed my recorded flow "' + f.flow + '" and saw this:',
|
|
268
|
+
f.headline,
|
|
269
|
+
'',
|
|
270
|
+
].concat(f.proof, ['', what, 'Do not edit the recording in tests/ to make this go away.']).join('\n');
|
|
271
|
+
}
|
|
272
|
+
|
|
273
|
+
// --- running -------------------------------------------------------------
|
|
274
|
+
|
|
275
|
+
/**
|
|
276
|
+
* The whole check. `flows` is [{ file, title, source }] - recordings the
|
|
277
|
+
* caller already found runnable. Same options as kryptheon-edge.js run():
|
|
278
|
+
* say, onControl, confirmed, budget, gapMs; plus `only` for a re-check:
|
|
279
|
+
* { file, kind: 'flaky' } or { file, kind: 'double', line }.
|
|
280
|
+
*/
|
|
281
|
+
async function run(root, flows, options) {
|
|
282
|
+
const opts = options || {};
|
|
283
|
+
const say = typeof opts.say === 'function' ? opts.say : () => {};
|
|
284
|
+
const budget = Math.min(probe.MAX_RUNS, opts.budget || probe.MAX_RUNS);
|
|
285
|
+
const rounds = opts.only && opts.only.kind === 'flaky' ? RECHECK_ROUNDS : opts.only ? 1 : ROUNDS;
|
|
286
|
+
let stopped = false;
|
|
287
|
+
let current = null;
|
|
288
|
+
const control = {
|
|
289
|
+
stop() {
|
|
290
|
+
stopped = true;
|
|
291
|
+
if (current) current.stop();
|
|
292
|
+
},
|
|
293
|
+
};
|
|
294
|
+
if (typeof opts.onControl === 'function') opts.onControl(control);
|
|
295
|
+
const secretNames = [];
|
|
296
|
+
for (const f of flows) {
|
|
297
|
+
for (const m of String(f.source).matchAll(/process\.env\.([A-Za-z_][A-Za-z0-9_]*)/g)) if (!secretNames.includes(m[1])) secretNames.push(m[1]);
|
|
298
|
+
}
|
|
299
|
+
const report = {
|
|
300
|
+
check: 'reliability', startedAt: new Date().toISOString(), endedAt: null,
|
|
301
|
+
stopped: false, runsPlanned: 0, runsDone: 0, flows: [], findings: [], held: [], notTested: [], testData: [], writeHosts: [],
|
|
302
|
+
};
|
|
303
|
+
|
|
304
|
+
const runWith = async (probes, labels) => {
|
|
305
|
+
if (stopped || !probes.length) return {};
|
|
306
|
+
current = probe.runProbes(root, probes, { say: say, labels: labels, secretNames: secretNames, gapMs: opts.gapMs, env: opts.env, hide: opts.hide, childEnv: opts.childEnv });
|
|
307
|
+
const done = await current.done;
|
|
308
|
+
current = null;
|
|
309
|
+
report.runsDone += Object.keys(done.results).length;
|
|
310
|
+
return done.results;
|
|
311
|
+
};
|
|
312
|
+
|
|
313
|
+
// Which flows, within the cap: three plain runs each, and room for at
|
|
314
|
+
// least their saving steps once.
|
|
315
|
+
const chosen = [];
|
|
316
|
+
let planned = 0;
|
|
317
|
+
for (const f of flows) {
|
|
318
|
+
if (opts.only && f.file !== opts.only.file) continue;
|
|
319
|
+
if (replay.findReplayRisks(f.source).some((r) => r.kind === 'signup')) {
|
|
320
|
+
report.flows.push({ title: f.title, file: f.file, state: 'skipped', why: 'it creates an account, and this check never creates accounts' });
|
|
321
|
+
continue;
|
|
322
|
+
}
|
|
323
|
+
const steps = saveSteps(f.source).filter((s) => !opts.only || opts.only.kind !== 'double' || s.line === opts.only.line);
|
|
324
|
+
const cost = rounds + (opts.only && opts.only.kind === 'flaky' ? 0 : steps.length);
|
|
325
|
+
if (planned + cost > budget) {
|
|
326
|
+
report.flows.push({ title: f.title, file: f.file, state: 'not tested', why: 'over the limit of ' + budget + ' runs' });
|
|
327
|
+
continue;
|
|
328
|
+
}
|
|
329
|
+
planned += cost;
|
|
330
|
+
chosen.push(Object.assign({}, f, { steps: steps, runs: [] }));
|
|
331
|
+
}
|
|
332
|
+
report.runsPlanned = planned;
|
|
333
|
+
if (!chosen.length) {
|
|
334
|
+
report.endedAt = new Date().toISOString();
|
|
335
|
+
return report;
|
|
336
|
+
}
|
|
337
|
+
|
|
338
|
+
const plainProbe = (f, round, n) => ({ id: probe.probeId(n, 'run ' + round + ' ' + f.title), source: plainSource(f.source, f.steps), flow: f, round: round });
|
|
339
|
+
const labelsOf = (list, word) => {
|
|
340
|
+
const out = {};
|
|
341
|
+
for (const p of list) out[p.id] = word(p);
|
|
342
|
+
return out;
|
|
343
|
+
};
|
|
344
|
+
let n = 0;
|
|
345
|
+
const keep = (results, list) => {
|
|
346
|
+
for (const p of list) {
|
|
347
|
+
const r = results[p.id] || null;
|
|
348
|
+
if (p.round) p.flow.runs[p.round - 1] = r;
|
|
349
|
+
for (const w of writesOf(r)) {
|
|
350
|
+
if (w.origin && !report.writeHosts.includes(w.origin)) report.writeHosts.push(w.origin);
|
|
351
|
+
if (leftBehind(w)) report.testData.push({ flow: p.flow.title, value: p.round ? 'run ' + p.round : 'double-click', request: words(w) });
|
|
352
|
+
}
|
|
353
|
+
}
|
|
354
|
+
};
|
|
355
|
+
|
|
356
|
+
// 1. The first run of every flow - which is also where the app is seen
|
|
357
|
+
// saving. Somewhere that is not this computer, and not said yes to, stops
|
|
358
|
+
// it here (the same rule as the input check).
|
|
359
|
+
say('Replaying ' + chosen.length + (chosen.length === 1 ? ' flow' : ' flows') + ' ' + rounds + (rounds === 1 ? ' time' : ' times') + ', one round at a time...');
|
|
360
|
+
const first = chosen.map((f) => plainProbe(f, 1, ++n));
|
|
361
|
+
keep(await runWith(first, labelsOf(first, (p) => p.flow.title + ' - run 1 of ' + rounds)), first);
|
|
362
|
+
const unconfirmed = probe.liveLooking(report.writeHosts).filter((h) => !(opts.confirmed || []).includes(h));
|
|
363
|
+
if (unconfirmed.length) {
|
|
364
|
+
for (const f of chosen) {
|
|
365
|
+
report.flows.push({ title: f.title, file: f.file, state: 'not tested',
|
|
366
|
+
why: 'your app saves to ' + unconfirmed.join(', ') + ', which is not this computer. Press again: you will be asked about that address first' });
|
|
367
|
+
}
|
|
368
|
+
report.stopped = stopped;
|
|
369
|
+
report.endedAt = new Date().toISOString();
|
|
370
|
+
return report;
|
|
371
|
+
}
|
|
372
|
+
|
|
373
|
+
// 2. The other rounds: every flow once, then every flow again, so time
|
|
374
|
+
// passes between two runs of the same flow.
|
|
375
|
+
for (let round = 2; round <= rounds && !stopped; round++) {
|
|
376
|
+
const list = chosen.map((f) => plainProbe(f, round, ++n));
|
|
377
|
+
keep(await runWith(list, labelsOf(list, (p) => p.flow.title + ' - run ' + round + ' of ' + rounds)), list);
|
|
378
|
+
}
|
|
379
|
+
|
|
380
|
+
// 3. Each saving step, clicked twice - against a run where it was clicked
|
|
381
|
+
// once and the flow worked.
|
|
382
|
+
const doubles = [];
|
|
383
|
+
if (!(opts.only && opts.only.kind === 'flaky')) {
|
|
384
|
+
for (const f of chosen) {
|
|
385
|
+
const single = f.runs.find((r) => r && r.status === 'passed' && !limited(r)) || null;
|
|
386
|
+
f.single = single;
|
|
387
|
+
for (const s of f.steps) {
|
|
388
|
+
const once = single && windowWrites(single, s.line);
|
|
389
|
+
const posts = once ? Object.keys(created(once)).length : 0;
|
|
390
|
+
const label = { flow: f.title, where: f.file + ':' + s.line, kind: 'double', step: s.name };
|
|
391
|
+
if (!single) report.notTested.push(Object.assign(label, { why: 'the flow never worked as recorded, so there is nothing to compare a double-click with' }));
|
|
392
|
+
else if (!once) report.notTested.push(Object.assign(label, { why: 'the replay did not reach this step' }));
|
|
393
|
+
else if (!posts) report.held.push(Object.assign(label, { why: 'a single click of it saves nothing by itself' }));
|
|
394
|
+
else doubles.push({ id: probe.probeId(++n, 'double ' + s.name), source: doubleSource(f.source, f.steps, s), flow: f, step: s });
|
|
395
|
+
}
|
|
396
|
+
}
|
|
397
|
+
}
|
|
398
|
+
let doubled = {};
|
|
399
|
+
if (doubles.length && !stopped) {
|
|
400
|
+
say('Clicking ' + doubles.length + (doubles.length === 1 ? ' saving step' : ' saving steps') + ' twice, quickly...');
|
|
401
|
+
doubled = await runWith(doubles, labelsOf(doubles, (p) => p.flow.title + ' - "' + p.step.name + '" double-clicked'));
|
|
402
|
+
keep(doubled, doubles.map((p) => Object.assign({}, p, { round: 0 })));
|
|
403
|
+
}
|
|
404
|
+
const dupes = [];
|
|
405
|
+
for (const p of doubles) {
|
|
406
|
+
const v = judgeDouble(p.flow, p.step, p.flow.single, doubled[p.id]);
|
|
407
|
+
const label = { flow: p.flow.title, where: p.flow.file + ':' + p.step.line, kind: 'double', step: p.step.name };
|
|
408
|
+
if (v.outcome === 'duplicate') dupes.push({ probe: p, finding: v.finding });
|
|
409
|
+
else if (v.outcome === 'held') report.held.push(Object.assign(label, { why: v.why }));
|
|
410
|
+
else report.notTested.push(Object.assign(label, { why: !doubled[p.id] && stopped ? 'stopped before it finished' : v.why }));
|
|
411
|
+
}
|
|
412
|
+
|
|
413
|
+
// 4. A duplicate seen once is tried once more: two saves can also come
|
|
414
|
+
// from a slow app answering late, and one sighting is not a finding.
|
|
415
|
+
const again = dupes.slice(0, CONFIRM_RUNS);
|
|
416
|
+
if (again.length && !stopped && report.runsDone + again.length <= probe.MAX_RUNS) {
|
|
417
|
+
say('Double-clicking ' + again.length + ' of them again, to be sure...');
|
|
418
|
+
const list = again.map((d) => Object.assign({}, d.probe, { id: probe.probeId(++n, 'again ' + d.probe.step.name) }));
|
|
419
|
+
report.runsPlanned += list.length;
|
|
420
|
+
const res = await runWith(list, labelsOf(list, (p) => p.flow.title + ' - "' + p.step.name + '" double-clicked again'));
|
|
421
|
+
keep(res, list.map((p) => Object.assign({}, p, { round: 0 })));
|
|
422
|
+
again.forEach((d, i) => {
|
|
423
|
+
const second = judgeDouble(d.probe.flow, d.probe.step, d.probe.flow.single, res[list[i].id]);
|
|
424
|
+
if (second.outcome === 'duplicate') d.finding.proof.push('It happened again on a second try.');
|
|
425
|
+
else {
|
|
426
|
+
d.finding.status = 'verification required';
|
|
427
|
+
d.finding.severity = 'LOW';
|
|
428
|
+
d.finding.headline = d.finding.headline.replace(/\.$/, '') + ' - once, not on a second try.';
|
|
429
|
+
d.finding.proof.push(res[list[i].id] ? 'A second double-click saved it once.' : 'A second try did not finish, so it is not confirmed.');
|
|
430
|
+
}
|
|
431
|
+
});
|
|
432
|
+
} else {
|
|
433
|
+
for (const d of again) d.finding.proof.push('Not tried a second time (stopped, or no room left in the ' + probe.MAX_RUNS + ' runs).');
|
|
434
|
+
}
|
|
435
|
+
for (const d of dupes) report.findings.push(d.finding);
|
|
436
|
+
|
|
437
|
+
// 5. The three runs of each flow. A re-check of a double-click ran its
|
|
438
|
+
// flow once, only to have a single click to compare with - one run says
|
|
439
|
+
// nothing about flakiness, so the flow counts as tested when that run
|
|
440
|
+
// worked, and nothing is judged flaky from it.
|
|
441
|
+
for (const f of chosen) {
|
|
442
|
+
if (opts.only && opts.only.kind === 'double') {
|
|
443
|
+
report.flows.push({ title: f.title, file: f.file, state: f.single ? 'tested' : 'not tested',
|
|
444
|
+
why: f.single ? '' : 'the flow did not work as recorded, so there was nothing to compare the double-click with' });
|
|
445
|
+
continue;
|
|
446
|
+
}
|
|
447
|
+
const v = judgeFlaky(f, f.runs);
|
|
448
|
+
report.flows.push({ title: f.title, file: f.file, state: v.outcome === 'not tested' ? 'not tested' : 'tested', why: v.why || '',
|
|
449
|
+
runs: f.runs.map((r) => (!r ? 'did not finish' : limited(r) ? 'not counted (429)' : r.status)) });
|
|
450
|
+
const label = { flow: f.title, where: f.file, kind: 'flaky' };
|
|
451
|
+
if (v.finding) report.findings.push(v.finding);
|
|
452
|
+
else if (v.outcome === 'held') report.held.push(Object.assign(label, { why: v.why }));
|
|
453
|
+
else if (v.outcome === 'broken') report.notTested.push(Object.assign(label, { why: v.why }));
|
|
454
|
+
else if (v.outcome === 'not tested') report.notTested.push(Object.assign(label, { why: stopped ? 'stopped before it finished' : v.why }));
|
|
455
|
+
}
|
|
456
|
+
|
|
457
|
+
for (const f of report.findings) f.fixPrompt = fixPrompt(f);
|
|
458
|
+
const rank = { HIGH: 0, MEDIUM: 1, LOW: 2 };
|
|
459
|
+
report.findings.sort((a, b) => rank[a.severity] - rank[b.severity]);
|
|
460
|
+
report.stopped = stopped;
|
|
461
|
+
report.endedAt = new Date().toISOString();
|
|
462
|
+
return report;
|
|
463
|
+
}
|
|
464
|
+
|
|
465
|
+
// What a finding is about, for keeping it across presses: the flow for a
|
|
466
|
+
// flaky one, the step for a double-click.
|
|
467
|
+
const keyOf = (x) => (x.kind === 'flaky' ? String(x.where).replace(/:\d+$/, '') : x.where) + '|' + x.kind;
|
|
468
|
+
|
|
469
|
+
/**
|
|
470
|
+
* What a press did not try is not cleared by it: a finding from an earlier
|
|
471
|
+
* press whose flow or step was not tried this time is kept, and says so.
|
|
472
|
+
*/
|
|
473
|
+
function carryOver(previous, report, root) {
|
|
474
|
+
if (!previous || !Array.isArray(previous.findings)) return report;
|
|
475
|
+
const tried = new Set(report.held.concat(report.findings).map(keyOf));
|
|
476
|
+
for (const f of previous.findings) {
|
|
477
|
+
if (tried.has(keyOf(f))) continue;
|
|
478
|
+
const file = String(f.where).replace(/:\d+$/, '');
|
|
479
|
+
if (root && !fs.existsSync(path.join(root, file))) continue;
|
|
480
|
+
const kept = Object.assign({}, f, { carried: f.carried || previous.endedAt || previous.startedAt });
|
|
481
|
+
if (!f.carried) kept.proof = (f.proof || []).concat(['Seen on an earlier run; not tried on the latest one.']);
|
|
482
|
+
report.findings.push(kept);
|
|
483
|
+
}
|
|
484
|
+
return report;
|
|
485
|
+
}
|
|
486
|
+
|
|
487
|
+
function load(root, env) {
|
|
488
|
+
return probe.loadReport(root, 'reliability', env);
|
|
489
|
+
}
|
|
490
|
+
|
|
491
|
+
function save(root, report, env, options) {
|
|
492
|
+
if (!(options && options.asIs)) carryOver(load(root, env), report, root);
|
|
493
|
+
const file = probe.reportFile(root, 'reliability', env);
|
|
494
|
+
fs.mkdirSync(path.dirname(file), { recursive: true });
|
|
495
|
+
fs.writeFileSync(file, JSON.stringify(report, null, 2) + '\n', 'utf8');
|
|
496
|
+
return file;
|
|
497
|
+
}
|
|
498
|
+
|
|
499
|
+
/**
|
|
500
|
+
* Re-checks one finding: a flaky flow is replayed five times and is fixed
|
|
501
|
+
* only when all five work; a double-click is tried again against one plain
|
|
502
|
+
* run. The same four verdicts as every re-check.
|
|
503
|
+
*/
|
|
504
|
+
async function recheck(root, flows, finding, options) {
|
|
505
|
+
const opts = options || {};
|
|
506
|
+
const file = String(finding.where || '').replace(/:\d+$/, '');
|
|
507
|
+
const line = Number((/:(\d+)$/.exec(finding.where || '') || [])[1]);
|
|
508
|
+
const unsure = (why) => ({ verdict: 'could not confirm', why: why, newProblems: [], testData: [] });
|
|
509
|
+
const flow = flows.find((f) => f.file === file);
|
|
510
|
+
if (!flow) return unsure('the recording ' + file + ' is not there, or cannot be run now');
|
|
511
|
+
if (finding.kind === 'double' && !saveSteps(flow.source).some((s) => s.line === line)) return unsure('that step is no longer at line ' + line + ' of ' + file);
|
|
512
|
+
const report = await run(root, [flow], Object.assign({}, opts, {
|
|
513
|
+
only: finding.kind === 'flaky' ? { file: file, kind: 'flaky' } : { file: file, kind: 'double', line: line },
|
|
514
|
+
}));
|
|
515
|
+
const before = load(root, opts.env);
|
|
516
|
+
if (before && report.writeHosts.some((h) => !(before.writeHosts || []).includes(h))) {
|
|
517
|
+
before.writeHosts = Array.from(new Set((before.writeHosts || []).concat(report.writeHosts)));
|
|
518
|
+
save(root, before, opts.env, { asIs: true });
|
|
519
|
+
}
|
|
520
|
+
if (report.stopped) return unsure('it was stopped before it finished');
|
|
521
|
+
const ran = report.flows.find((f) => f.file === file);
|
|
522
|
+
if (!ran || ran.state !== 'tested') return unsure(ran ? ran.why : 'the flow did not run');
|
|
523
|
+
const left = report.notTested.find((x) => keyOf(x) === keyOf(finding));
|
|
524
|
+
if (left) return unsure(left.why);
|
|
525
|
+
const same = report.findings.find((f) => keyOf(f) === keyOf(finding));
|
|
526
|
+
const others = report.findings.filter((f) => f !== same && f.status === 'confirmed');
|
|
527
|
+
const result = same ? { verdict: 'still open', why: same.proof.slice(1).join(' '), newProblems: others }
|
|
528
|
+
: { verdict: 'fixed', why: finding.kind === 'flaky' ? 'it worked all ' + RECHECK_ROUNDS + ' times' : 'a double-click saved it once', newProblems: others };
|
|
529
|
+
const saved = load(root, opts.env);
|
|
530
|
+
if (saved && result.verdict === 'fixed') {
|
|
531
|
+
saved.findings = saved.findings.filter((f) => keyOf(f) !== keyOf(finding));
|
|
532
|
+
save(root, saved, opts.env, { asIs: true });
|
|
533
|
+
}
|
|
534
|
+
result.testData = report.testData;
|
|
535
|
+
return result;
|
|
536
|
+
}
|
|
537
|
+
|
|
538
|
+
/** What is said when it ends, in the terminal and on the page. */
|
|
539
|
+
function summaryLines(report) {
|
|
540
|
+
const lines = [''];
|
|
541
|
+
const problems = report.findings.filter((f) => f.status === 'confirmed');
|
|
542
|
+
const toCheck = report.findings.filter((f) => f.status !== 'confirmed');
|
|
543
|
+
const triedAny = report.held.length || report.findings.some((f) => !f.carried);
|
|
544
|
+
if (report.stopped) lines.push('Stopped after ' + report.runsDone + ' of ' + report.runsPlanned + ' runs. What did not run was NOT tested.');
|
|
545
|
+
lines.push(problems.length ? problems.length + (problems.length === 1 ? ' problem' : ' problems') + ' found:'
|
|
546
|
+
: triedAny ? 'No problem found in what was tried.' : 'Nothing was tested - see why below.');
|
|
547
|
+
for (const f of report.findings) {
|
|
548
|
+
lines.push('');
|
|
549
|
+
lines.push(' ' + f.severity + (f.status === 'confirmed' ? '' : ' (to check)') + ' ' + f.headline);
|
|
550
|
+
for (const p of f.proof) lines.push(' ' + p);
|
|
551
|
+
}
|
|
552
|
+
if (toCheck.length && !problems.length) lines.push('', toCheck.length + (toCheck.length === 1 ? ' thing' : ' things') + ' to check above - not proven problems.');
|
|
553
|
+
if (report.held.length) {
|
|
554
|
+
lines.push('', 'Held (' + report.held.length + '):');
|
|
555
|
+
for (const h of report.held) lines.push(' ' + (h.kind === 'flaky' ? h.flow + ' - ' : '"' + h.step + '" (' + h.where + ') double-clicked - ') + h.why);
|
|
556
|
+
}
|
|
557
|
+
const skipped = report.flows.filter((f) => f.state !== 'tested');
|
|
558
|
+
if (report.notTested.length || skipped.length) {
|
|
559
|
+
lines.push('', 'NOT tested:');
|
|
560
|
+
const said = new Set();
|
|
561
|
+
for (const f of skipped) {
|
|
562
|
+
said.add(f.file);
|
|
563
|
+
lines.push(' ' + f.title + ' - ' + f.why);
|
|
564
|
+
}
|
|
565
|
+
for (const x of report.notTested) {
|
|
566
|
+
if (x.kind === 'flaky' && said.has(x.where)) continue;
|
|
567
|
+
lines.push(' ' + (x.kind === 'flaky' ? x.flow : '"' + x.step + '" (' + x.where + ') double-clicked') + ' - ' + x.why);
|
|
568
|
+
}
|
|
569
|
+
}
|
|
570
|
+
if (report.testData.length) {
|
|
571
|
+
lines.push('', 'Test data left in your app: ' + report.testData.length + (report.testData.length === 1 ? ' write was' : ' writes were') + ' accepted.');
|
|
572
|
+
lines.push('These are your flows\' own saves, replayed. Kryptheon does not delete them. The writes:');
|
|
573
|
+
for (const t of report.testData.slice(0, 15)) lines.push(' ' + t.request + ' (' + t.flow + ', ' + t.value + ')');
|
|
574
|
+
if (report.testData.length > 15) lines.push(' ... and ' + (report.testData.length - 15) + ' more');
|
|
575
|
+
}
|
|
576
|
+
lines.push('');
|
|
577
|
+
return lines;
|
|
578
|
+
}
|
|
579
|
+
|
|
580
|
+
module.exports = {
|
|
581
|
+
ROUNDS: ROUNDS,
|
|
582
|
+
saveSteps: saveSteps,
|
|
583
|
+
plainSource: plainSource,
|
|
584
|
+
doubleSource: doubleSource,
|
|
585
|
+
windowWrites: windowWrites,
|
|
586
|
+
created: created,
|
|
587
|
+
thingOf: thingOf,
|
|
588
|
+
recordIds: recordIds,
|
|
589
|
+
judgeFlaky: judgeFlaky,
|
|
590
|
+
judgeDouble: judgeDouble,
|
|
591
|
+
fixPrompt: fixPrompt,
|
|
592
|
+
run: run,
|
|
593
|
+
recheck: recheck,
|
|
594
|
+
carryOver: carryOver,
|
|
595
|
+
save: save,
|
|
596
|
+
load: load,
|
|
597
|
+
summaryLines: summaryLines,
|
|
598
|
+
knownAddresses: probe.knownAddresses,
|
|
599
|
+
};
|
package/kryptheon-replay.js
CHANGED
|
Binary file
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "kryptheon",
|
|
3
|
-
"version": "0.1.
|
|
3
|
+
"version": "0.1.47",
|
|
4
4
|
"description": "Record what you do in your app and get plain-language reports when it breaks.",
|
|
5
5
|
"license": "SEE LICENSE IN LICENSE",
|
|
6
6
|
"type": "commonjs",
|
|
@@ -44,7 +44,13 @@
|
|
|
44
44
|
"kryptheon-archivo.woff2",
|
|
45
45
|
"kryptheon-changes.js",
|
|
46
46
|
"kryptheon-look.js",
|
|
47
|
-
"kryptheon-autostart.js"
|
|
47
|
+
"kryptheon-autostart.js",
|
|
48
|
+
"kryptheon-edge.js",
|
|
49
|
+
"kryptheon-probe.js",
|
|
50
|
+
"kryptheon-probe-fixture.js",
|
|
51
|
+
"kryptheon-probe-reporter.js",
|
|
52
|
+
"kryptheon-probe.config.js",
|
|
53
|
+
"kryptheon-reliability.js"
|
|
48
54
|
],
|
|
49
55
|
"engines": {
|
|
50
56
|
"node": ">=20.6.0"
|
|
@@ -53,7 +59,7 @@
|
|
|
53
59
|
"@playwright/test": "^1.62.1"
|
|
54
60
|
},
|
|
55
61
|
"scripts": {
|
|
56
|
-
"check": "node kryptheon-store.check.js && node kryptheon-code.check.js && node kryptheon-constdata.check.js && node kryptheon-listitems.check.js && node kryptheon-accept.check.js && node kryptheon-keys.check.js && node kryptheon-dashboard.check.js && node kryptheon-autostart.check.js && node kryptheon-changes.check.js && node kryptheon-look.check.js && node kryptheon-verify.check.js && node kryptheon-recheck.check.js && node kryptheon-reporter.check.js && node kryptheon-signature.check.js && node kryptheon-signature.stream.check.js && node kryptheon-signature.baseline.check.js && node kryptheon-signature.settle.check.js && node kryptheon-signature.number.check.js && node kryptheon-env.check.js && node kryptheon-watchdog.check.js && node kryptheon-phone.check.js && node kryptheon-homedash.check.js && node kryptheon-record.check.js && node kryptheon-selectors.check.js && node kryptheon-recordings.check.js && node kryptheon-testfiles.check.js && node kryptheon-cleanup.check.js && node kryptheon-orphan.check.js && node kryptheon-project.check.js && node kryptheon-setup.check.js && node kryptheon-browser.check.js && node kryptheon-heal.check.js && node kryptheon-load.check.js && node kryptheon-package.check.js",
|
|
62
|
+
"check": "node kryptheon-store.check.js && node kryptheon-code.check.js && node kryptheon-constdata.check.js && node kryptheon-listitems.check.js && node kryptheon-accept.check.js && node kryptheon-keys.check.js && node kryptheon-dashboard.check.js && node kryptheon-edge.check.js && node kryptheon-reliability.check.js && node kryptheon-autostart.check.js && node kryptheon-changes.check.js && node kryptheon-look.check.js && node kryptheon-verify.check.js && node kryptheon-recheck.check.js && node kryptheon-reporter.check.js && node kryptheon-signature.check.js && node kryptheon-signature.stream.check.js && node kryptheon-signature.baseline.check.js && node kryptheon-signature.settle.check.js && node kryptheon-signature.number.check.js && node kryptheon-env.check.js && node kryptheon-watchdog.check.js && node kryptheon-phone.check.js && node kryptheon-homedash.check.js && node kryptheon-record.check.js && node kryptheon-selectors.check.js && node kryptheon-recordings.check.js && node kryptheon-testfiles.check.js && node kryptheon-cleanup.check.js && node kryptheon-orphan.check.js && node kryptheon-project.check.js && node kryptheon-setup.check.js && node kryptheon-browser.check.js && node kryptheon-heal.check.js && node kryptheon-load.check.js && node kryptheon-package.check.js",
|
|
57
63
|
"check:store": "node kryptheon-store.check.js",
|
|
58
64
|
"check:code": "node kryptheon-code.check.js",
|
|
59
65
|
"check:constdata": "node kryptheon-constdata.check.js",
|
|
@@ -84,7 +90,9 @@
|
|
|
84
90
|
"check:package": "node kryptheon-package.check.js",
|
|
85
91
|
"prepublishOnly": "node kryptheon-package.check.js",
|
|
86
92
|
"check:testfiles": "node kryptheon-testfiles.check.js",
|
|
87
|
-
"check:listitems": "node kryptheon-listitems.check.js"
|
|
93
|
+
"check:listitems": "node kryptheon-listitems.check.js",
|
|
94
|
+
"check:edge": "node kryptheon-edge.check.js",
|
|
95
|
+
"check:reliability": "node kryptheon-reliability.check.js"
|
|
88
96
|
},
|
|
89
97
|
"keywords": [
|
|
90
98
|
"playwright",
|