gitoria

22.2 KB

1. // tests/push.mjs — THE GATE OF PUSH AND PULL (ticket gitoria#7). Its own gitoria server + its own ident (copy, mail sink),
2. // a real Chrome for everything visible (create a repo, the "add code" box, access tokens), and the REAL `git` binary for
3. // clone / push / fetch over HTTP against the repo address <slug>.gitoria.test (git's http.curloptResolve maps it to 127.0.0.1).
4. // node tests/push.mjs (GITORIA_GATE_PORT 8700, GITORIA_GATE_IDENT_PORT 8701, GITORIA_GATE_CHROME "8703-8707")
5. import { spawn } from 'node:child_process';
6. import { request as httpRequest, createServer } from 'node:http';
7. import { rmSync, mkdirSync, writeFileSync, existsSync, readFileSync } from 'node:fs';
8. import { dirname, join, resolve } from 'node:path';
9. import { fileURLToPath } from 'node:url';
10. import { randomBytes } from 'node:crypto';
11. import { launchBrowser } from './cdp.mjs';
12. import { startIdent } from './identkit.mjs';
14. if (!process.env.HL_CHROME && existsSync('/opt/google/chrome/chrome')) process.env.HL_CHROME = '/opt/google/chrome/chrome';
15. const HERE = dirname(fileURLToPath(import.meta.url));
16. const APP = resolve(HERE, '..');
17. const BIN = join(APP, 'bin/hybriel');
18. const PORT = Number(process.env.GITORIA_GATE_PORT || 8700);
19. const IDENT_PORT = Number(process.env.GITORIA_GATE_IDENT_PORT || 8701);
20. const PROXY = Number(process.env.GITORIA_GATE_PROXY || 8702); // stands in for nginx: buffers a chunked request body and sends it with a length
21. const [CH_FROM, CH_TO] = (process.env.GITORIA_GATE_CHROME || '8703-8707').split('-').map(Number);
22. const API = `http://127.0.0.1:${PORT}`;
23. const BASE = `http://gitoria.test:${PORT}`;
24. const IDENT_B = `http://ident.gitoria.test:${IDENT_PORT}`;
25. const REPO = (slug) => `http://${slug}.gitoria.test:${PORT}`;
26. const hreq = (method, path, host, headers = {}, body = null) => new Promise((res, rej) => {
27. const rq = httpRequest({ host: '127.0.0.1', port: PORT, path, method, headers: { host, ...headers } }, (r) => { let b = ''; r.setEncoding('utf8'); r.on('data', d => b += d); r.on('end', () => res({ status: r.statusCode, headers: r.headers, body: b })); });
28. rq.on('error', rej); if (body) { rq.setHeader('content-length', Buffer.byteLength(body)); rq.write(body); } rq.end();
29. });
30. process.env.HL_CHROME_ARGS = '--host-resolver-rules=MAP *.gitoria.test 127.0.0.1, MAP gitoria.test 127.0.0.1';
31. const SCRATCH = join(APP, '.scratch');
32. const STORE = join(SCRATCH, 'push-store');
33. const WORK = join(STORE, 'work');
34. const IDENT_DIR = process.env.GITORIA_GATE_IDENT_DIR || [resolve(APP, '../ident.worldapi.org'), '/media/STORAGE/projects/ident.worldapi.org'].find(d => existsSync(join(d, 'project.hl')));
35. rmSync(STORE, { recursive: true, force: true });
36. mkdirSync(WORK, { recursive: true });
38. let failures = 0, passes = 0;
39. function check(label, ok, detail = '') {
40. console.log(`${ok ? 'ok ' : 'FAIL'} ${label}${ok ? '' : ' — ' + detail}`);
41. if (ok) passes++; else failures++;
42. }
43. const sleep = (ms) => new Promise(r => setTimeout(r, ms));
44. const J = JSON.stringify;
45. let pageA = null;
46. let log = '', server = null, ident = null, proxy = null;
47. function startProxy() {
48. proxy = createServer((req, res) => {
49. const parts = []; req.on('data', d => parts.push(d));
50. req.on('end', () => {
51. const body = Buffer.concat(parts);
52. const headers = { ...req.headers }; delete headers['transfer-encoding']; headers['content-length'] = String(body.length);
53. const up = httpRequest({ host: '127.0.0.1', port: PORT, path: req.url, method: req.method, headers }, (r) => { res.writeHead(r.statusCode, r.headers); r.pipe(res); });
54. up.on('error', () => { res.writeHead(502); res.end(); });
55. up.end(body);
56. });
57. });
58. proxy.listen(PROXY, '127.0.0.1');
59. }
60. const browsers = [];
62. function startServer(extraEnv = {}) {
63. server = spawn(BIN, ['project.hl'], {
64. cwd: APP,
65. env: { ...process.env, GITORIA_PORT: String(PORT), GITORIA_STORAGE: join(STORE, 'mpackdb'), GITORIA_SESSIONS: join(STORE, 'sessions') + '/', GITORIA_WATCH: '0', GITORIA_GIT: join(STORE, 'git'),
66. GITORIA_PUBLIC_URL: BASE, IDENT_URL: IDENT_B, IDENT_EXCHANGE_URL: ident.base, GITORIA_TICKETS_URL: 'http://127.0.0.1:1', ...extraEnv },
67. stdio: ['ignore', 'pipe', 'pipe'],
68. });
69. server.stdout.on('data', d => log += d); server.stderr.on('data', d => log += d);
70. }
71. async function serverUp() {
72. for (let i = 0; i < 80; i++) { try { const r = await fetch(API + '/api/repos'); if (r.ok) return; } catch {} await sleep(250); }
73. throw new Error('gitoria did not come up\n' + log);
74. }
75. async function stopServer() {
76. if (!server) return;
77. try { server.kill('SIGTERM'); } catch {}
78. await new Promise(r => { if (server.exitCode !== null || server.signalCode !== null) return r(); server.once('exit', r); setTimeout(r, 3000); });
79. server = null;
80. }
81. function patient(page) {
82. const waitFor = page.waitFor.bind(page);
83. page.waitFor = (expr, o = {}) => waitFor(expr, { ...o, timeout: (o.timeout || 10000) * 3 });
84. const goto = page.goto.bind(page);
85. page.goto = (url, o = {}) => goto(url, { ...o, timeout: (o.timeout || 15000) * 3 });
86. return page;
87. }
88. const hydrated = (page) => page.waitFor('!!window.__hl && window.__hl.socket && window.__hl.socket.readyState === 1', { label: 'page hydrated' });
89. const txt = (page, sel) => page.evaluate(`(document.querySelector(${J(sel)}) || {}).textContent || null`);
90. const has = (page, sel) => page.evaluate(`!!document.querySelector(${J(sel)})`);
91. const noOverflow = (page) => page.evaluate('document.documentElement.scrollWidth <= window.innerWidth');
93. // the real git client. HOST = the repo address mapped to 127.0.0.1; credentials in the URL when given
94. const GIT_ENV = { ...process.env, GIT_TERMINAL_PROMPT: '0', GIT_CONFIG_NOSYSTEM: '1', HOME: WORK, LC_ALL: 'C' };
95. function git(cwd, args, slug, extra = {}) {
96. const pre = slug ? ['-c', `http.curloptResolve=${slug}.gitoria.test:${extra.port || PROXY}:127.0.0.1`] : [];
97. const { port: _p, ...envExtra } = extra;
98. // async: the proxy of this gate lives in this process, a blocking spawnSync would starve it
99. return new Promise((res) => {
100. const c = spawn('git', [...pre, '-c', 'user.name=Gate', '-c', '[email protected]', '-c', 'init.defaultBranch=main', ...args], { cwd, env: { ...GIT_ENV, ...envExtra } });
101. let out = ''; c.stdout.on('data', d => out += d); c.stderr.on('data', d => out += d);
102. const t = setTimeout(() => c.kill('SIGKILL'), 120000);
103. c.on('close', (code) => { clearTimeout(t); res({ code, out }); });
104. });
105. }
106. const urlOf = (slug, user, pass, port = PROXY) => `http://${user ? `${user}:${pass}@` : ''}${slug}.gitoria.test:${port}/${slug}.git`;
108. try {
109. ident = await startIdent({ identDir: IDENT_DIR, workDir: join(STORE, 'ident'), port: IDENT_PORT });
110. const alice = await ident.signIn('[email protected]');
111. const bob = await ident.signIn('[email protected]');
112. const APPKEY = await ident.registerApp(alice, 'gitoria (push gate)', [BASE]);
113. startServer({ IDENT_API_KEY: APPKEY.key, IDENT_API_SECRET: APPKEY.secret });
114. await serverUp();
115. startProxy();
117. // ---- alice in Chrome: log in, name, create an empty repo --------------------------------------------------
118. const b = await launchBrowser({ debugPortRange: [CH_FROM, CH_TO] });
119. browsers.push(b);
120. const A = patient(await b.newPage());
121. pageA = A;
122. const [ck, cv] = alice.cookie.split('=');
123. await A.send('Network.enable');
124. await A.send('Network.setCookie', { name: ck, value: cv, url: IDENT_B + '/' });
125. await A.goto(BASE + '/');
126. await A.waitForSelector('#loginbutton');
127. await hydrated(A);
128. check('tokens: signed out, the main page offers no token form', !(await has(A, '#tokenform')));
129. await A.click('#loginbutton');
130. await A.waitForSelector('#chooselist', { timeout: 10000 });
131. await hydrated(A);
132. await A.click('#chooselist li:nth-child(1) .choose');
133. await A.waitForSelector('#nameform');
134. await hydrated(A);
135. await A.type('#displayname', 'alice');
136. await A.click('#namesave');
137. await A.waitFor('!document.querySelector("#nameform") && !!document.querySelector("#createform")', { label: 'named' });
138. await A.type('#slug', 'gamma');
139. await A.type('#description', 'pushed to');
140. await A.click('#createsave');
141. await A.waitForSelector('#created');
143. // ---- the "add code" box of an EMPTY repo (gitoria#20: plain text, only on the Code page) ---------------------
144. await A.goto(REPO('gamma') + '/code');
145. await A.waitFor('!!document.querySelector("#addcode")', { label: 'add code box' });
146. const url = urlOf('gamma', null, null, PORT);
147. check('empty repo: the "add code" box is plain text (no <details>/<summary>)', await A.evaluate('document.querySelector("#addcode").tagName !== "DETAILS" && !document.querySelector("#addcode summary")'));
148. check('empty repo: the clone command names the repo address', (await txt(A, '#clonecommand')) === 'git clone ' + url, await txt(A, '#clonecommand'));
149. const nc = await txt(A, '#newcommands');
150. check('empty repo: the new-project commands are complete', nc.split('\n').length === 6 && /^git init -b main$/m.test(nc) && nc.includes(`git remote add origin ${url}`) && /git push -u origin main$/.test(nc), nc);
151. check('empty repo: the existing-project commands are complete', (await txt(A, '#existingcommands')) === `git remote add origin ${url}\ngit branch -M main\ngit push -u origin main`, await txt(A, '#existingcommands'));
152. check('empty repo: the box links to the access tokens on the main address', (await A.evaluate('document.querySelector("#totokens").getAttribute("href")')) === BASE + '/#tokens');
153. const first = (await hreq('GET', '/code', `gamma.gitoria.test:${PORT}`)).body;
154. check('empty repo: the box is in the FIRST html of /code (no script needed)', /id="addcode"/.test(first) && first.includes(`git clone ${url}`), first.slice(first.indexOf('id="addcode"'), first.indexOf('id="addcode"') + 200));
155. const other = await A.evaluate('1'); // keep the page alive
156. await A.goto(REPO('nothere') + '/');
157. await A.waitFor('!!document.querySelector("#missing")');
158. check('unknown address: no "add code" box', !(await has(A, '#addcode')));
160. // ---- the token, made in the browser -------------------------------------------------------------------------
161. await A.goto(BASE + '/');
162. await A.waitFor('!!document.querySelector("#tokenform")', { label: 'token form' });
163. await hydrated(A);
164. check('tokens: logged in, "You have no tokens yet"', await has(A, '#notokens'));
165. await A.click('#tokensave');
166. await sleep(300);
167. await A.type('#tokenname', 'laptop');
168. await A.click('#tokensave');
169. await A.waitFor('!!document.querySelector("#tokensecret")', { label: 'token shown' });
170. const TOKEN = (await txt(A, '#tokensecret')).trim();
171. check('tokens: a token is shown once (gtr_ + 40 hex), listed by its name', /^gtr_[0-9a-f]{40}$/.test(TOKEN) && (await txt(A, '#tokenlist')).includes('laptop') && !(await has(A, '#notokens')), TOKEN);
172. const stored = readFileSync(join(STORE, 'mpackdb', readdirOf(join(STORE, 'mpackdb')).find(n => n.startsWith('tokens.'))), 'latin1');
173. // hybriel 64527baa: the face's ack syncs `tokens` from the server; the new row must not be listed twice
174. check('tokens: the first token is listed ONCE', (await A.evaluate('document.querySelectorAll("#tokenlist li").length')) === 1, await txt(A, '#tokenlist'));
175. check('tokens: only the hash is stored, never the token', !stored.includes(TOKEN.slice(4)), 'the token text is in the table file');
176. await A.type('#tokenname', 'second');
177. await A.click('#tokensave');
178. await A.waitFor('document.querySelectorAll("#tokenlist li").length === 2', { label: 'two tokens' });
179. const SECOND = (await txt(A, '#tokensecret')).trim();
180. check('tokens: a second token replaces the shown secret', /^gtr_[0-9a-f]{40}$/.test(SECOND) && SECOND !== TOKEN, J({ TOKEN, SECOND }));
182. // ---- real git: clone the empty repo, push, clone, fetch, push again ---------------------------------------------
183. const W = (n) => join(WORK, n);
184. let g = await git(WORK, ['clone', urlOf('gamma'), 'first'], 'gamma');
185. check('git: cloning the empty repo works (an empty repository)', g.code === 0 && /empty repository/.test(g.out), J(g));
186. writeFileSync(join(W('first'), 'README.md'), '# gamma\n\nPushed with **git**.\n');
187. writeFileSync(join(W('first'), 'big.bin'), randomBytes(4000000));
188. await git(W('first'), ['add', '.']); await git(W('first'), ['commit', '-qm', 'first commit']);
189. g = await git(W('first'), ['push', 'origin', 'main'], 'gamma');
190. check('git: a push without credentials is refused and says how to get a token', g.code !== 0 && /terminal prompts disabled|could not read Username|401/.test(g.out) && g.out.length > 0, g.out);
191. const rawNo = await hreq('POST', '/gamma.git/git-receive-pack', `gamma.gitoria.test:${PORT}`, {}, '0000');
192. check('git: the push endpoint answers 401 with a Basic challenge and the hint', rawNo.status === 401 && /Basic/.test(rawNo.headers['www-authenticate'] || '') && /token/.test(rawNo.body), J(rawNo));
193. g = await git(W('first'), ['push', urlOf('gamma', 'alice', 'gtr_' + '0'.repeat(40)), 'main'], 'gamma');
194. check('git: a token nobody made is refused', g.code !== 0 && /Authentication failed|not valid|401/.test(g.out), g.out);
195. // bob logs in through his own ident identity: another user's token must not push to alice's repo
196. const bobCode = await ident.selectorCode(bob, APPKEY, BASE);
197. const bl = await fetch(API + '/login/callback?ident_code=' + bobCode, { redirect: 'manual' });
198. const bobCookie = (bl.headers.get('set-cookie') || '').split(';')[0];
199. const bobName = await fetch(API + '/__hl/emit', { method: 'POST', headers: { 'content-type': 'application/json', cookie: bobCookie }, body: J({ t: 'emit', i: 1, event: 'gitoriaSaveName', payload: ['bob'] }) });
200. const bt = await fetch(API + '/__hl/emit', { method: 'POST', headers: { 'content-type': 'application/json', cookie: bobCookie }, body: J({ t: 'emit', i: 2, event: 'gitoriaMakeToken', payload: ['bobs'] }) });
201. const BOBTOKEN = (JSON.parse(await bt.text()).value || {}).token;
202. check('tokens: bob makes his own token (a face, own session)', /^gtr_[0-9a-f]{40}$/.test(BOBTOKEN || ''), String(BOBTOKEN));
203. g = await git(W('first'), ['push', urlOf('gamma', 'bob', BOBTOKEN), 'main'], 'gamma');
204. check('git: another user\'s token may not push — only the owner may', g.code !== 0 && /only the owner|403/.test(g.out), g.out);
205. g = await git(W('first'), ['push', urlOf('gamma', 'alice', TOKEN), 'main'], 'gamma');
206. check('git: the owner pushes with the token (a 4 MB pack too)', g.code === 0 && /main -> main/.test(g.out), g.out);
207. g = await git(WORK, ['clone', '-q', urlOf('gamma'), 'second'], 'gamma');
208. check('git: a clone needs no login (public read) and has the pushed commit and file', g.code === 0 && readFileSync(join(W('second'), 'README.md'), 'utf8').includes('Pushed with') && readFileSync(join(W('second'), 'big.bin')).equals(readFileSync(join(W('first'), 'big.bin'))), g.out);
209. check('git: the bare repo on the server holds the commit', await (await git(W('first'), ['--git-dir', join(STORE, 'git', 'gamma.git'), 'log', '--format=%s'])).out.trim() === 'first commit');
210. // hybriel#89: hl:http1 reads a chunked request body — a big push straight to the server (no proxy) works (was a 411 before)
211. writeFileSync(join(W('first'), 'direct.bin'), randomBytes(4000000));
212. await git(W('first'), ['add', '.']); await git(W('first'), ['commit', '-qm', 'direct push']);
213. g = await git(W('first'), ['-c', 'http.postBuffer=65536', 'push', urlOf('gamma', 'alice', TOKEN, PORT), 'main'], 'gamma', { port: PORT });
214. check('git: a big push straight to hl:http1 (chunked, no proxy) works (hybriel#89)', g.code === 0 && /main -> main/.test(g.out) && (await git(W('first'), ['--git-dir', join(STORE, 'git', 'gamma.git'), 'log', '-1', '--format=%s'])).out.trim() === 'direct push', g.out);
215. // a fetch with many local commits sends a gzip-compressed request
216. for (let i = 0; i < 300; i++) { await git(W('second'), ['commit', '-q', '--allow-empty', '-m', 'local ' + i]); }
217. writeFileSync(join(W('first'), 'more.txt'), 'more\n'); await git(W('first'), ['add', '.']); await git(W('first'), ['commit', '-qm', 'second commit']);
218. g = await git(W('first'), ['push', urlOf('gamma', 'alice', TOKEN), 'main'], 'gamma');
219. check('git: a second push (fast-forward) works', g.code === 0, g.out);
220. g = await git(W('second'), ['fetch', 'origin'], 'gamma');
221. check('git: a fetch with 300 unpushed local commits (gzip request) works', g.code === 0, g.out);
222. g = await git(W('second'), ['pull', '--no-rebase', '--no-edit', 'origin', 'main'], 'gamma');
223. check('git: pull merges the new commit', g.code === 0 && existsSync(join(W('second'), 'more.txt')), g.out);
224. g = await git(W('first'), ['-c', 'protocol.version=0', 'ls-remote', urlOf('gamma')], 'gamma');
225. check('git: protocol v0 works too', g.code === 0 && /refs\/heads\/main/.test(g.out), g.out);
226. g = await git(W('first'), ['-c', 'protocol.version=2', 'ls-remote', urlOf('gamma')], 'gamma');
227. check('git: protocol v2 works', g.code === 0 && /refs\/heads\/main/.test(g.out), g.out);
229. // ---- odd requests ---------------------------------------------------------------------------------------------
230. const st = async (path, o = {}) => (await hreq(o.method || 'GET', path, `gamma.gitoria.test:${PORT}`, o.headers || {}, o.body)).status;
231. check('transport: dumb-protocol / unknown service → 403', (await st('/gamma.git/info/refs')) === 403 && (await st('/gamma.git/info/refs?service=git-evil')) === 403);
232. check('transport: another repo name in the path / an unknown repo → 404', (await st('/beta.git/info/refs?service=git-upload-pack')) === 404 && (await st('/gamma/info/refs?service=git-upload-pack')) === 404);
233. check('transport: wrong methods → 405', (await st('/gamma.git/git-upload-pack')) === 405 && (await st('/gamma.git/info/refs?service=git-upload-pack', { method: 'POST' })) === 405);
234. check('transport: the main address has no git', (await hreq('GET', '/gamma.git/info/refs?service=git-upload-pack', `gitoria.test:${PORT}`)).status === 404);
235. check('transport: a Basic header that is not base64 is just "no credentials" → 401', (await st('/gamma.git/git-receive-pack', { method: 'POST', body: '0000', headers: { authorization: 'Basic $(touch /tmp/pwned)' } })) === 401 && !existsSync('/tmp/pwned'));
236. check('transport: no temp files left behind', !existsSync(join(STORE, 'git', '.tmp')) || readdirOf(join(STORE, 'git', '.tmp')).length === 0, J(readdirOf(join(STORE, 'git', '.tmp'))));
238. // ---- the box on a repo with code; the pushed code shows; remove a token -----------------------------------------
239. await A.goto(REPO('gamma') + '/');
240. await A.waitFor('!!document.querySelector("#homepage")', { label: 'README of the pushed code' });
241. check('pushed code: the Readme page shows the pushed README', /Pushed with/.test(await txt(A, '#homepage')));
242. check('pushed code: no "add code" box on the Readme', !(await has(A, '#addcode')));
243. await A.goto(REPO('gamma') + '/code');
244. await A.waitFor('!!document.querySelector("#crumbs")', { label: '/code' });
245. check('pushed code: /code has no "add code" box once there is a commit (gitoria#20)', !(await has(A, '#addcode')));
246. await A.goto(BASE + '/');
247. await A.waitFor('document.querySelectorAll("#tokenlist li").length === 2', { label: 'tokens after reload' });
248. await hydrated(A);
249. check('tokens: the list survives a reload; the secret is not shown again', !(await has(A, '#tokensecret')));
250. await A.evaluate('document.querySelector("#tokenlist li .removetoken").click()');
251. await A.waitFor('document.querySelectorAll("#tokenlist li").length === 1', { label: 'one token removed' });
252. const gone = (await txt(A, '#tokenlist')).includes('laptop') ? 'laptop' : 'second';
253. // removed one is the newest = "second"
254. g = await git(W('first'), ['push', urlOf('gamma', 'alice', SECOND), 'main'], 'gamma');
255. check('tokens: a removed token stops working at once', g.code !== 0 && /not valid|Authentication failed|401/.test(g.out) && gone === 'laptop', g.out + ' / left: ' + gone);
256. g = await git(W('first'), ['push', urlOf('gamma', 'alice', TOKEN), 'main'], 'gamma');
257. check('tokens: the other token still works', g.code === 0, g.out);
258. await A.evaluate('document.querySelector("#tokenlist li .removetoken").click()');
259. await A.waitFor('!document.querySelector("#tokenlist li") && !!document.querySelector("#notokens")', { label: 'all removed' });
260. await A.click('#logout');
261. await A.waitFor('!document.querySelector("#tokenform")', { label: 'token form gone at logout' });
262. check('tokens: logout hides the token form', !(await has(A, '#tokenform')) && !(await has(A, '#tokensecret')));
263. // face forgery
264. const fk = await fetch(API + '/__hl/emit', { method: 'POST', headers: { 'content-type': 'application/json' }, body: J({ t: 'emit', i: 3, event: 'gitoriaMakeToken', payload: ['x', { user: { id: 'y' } }] }) });
265. check('tokens: a forged session argument makes no token', !/gtr_/.test(await fk.text()));
266. // layout
267. for (const [w, name] of [[390, 'phone'], [1280, 'wide']]) {
268. await A.send('Emulation.setDeviceMetricsOverride', { width: w, height: 900, deviceScaleFactor: 1, mobile: w < 600 });
269. await A.goto(REPO('gamma') + '/code');
270. await A.waitFor('!!document.querySelector("#crumbs")');
271. check(`layout ${w}px: the pushed repo's code page has no horizontal overflow`, await noOverflow(A));
272. const { data } = await A.send('Page.captureScreenshot', { format: 'png', captureBeyondViewport: true });
273. writeFileSync(join(SCRATCH, `push-${name}.png`), Buffer.from(data, 'base64'));
274. }
275. const problems = A.problems().filter(m => !/favicon|ERR_|Failed to load resource/.test(m.text));
276. check('browser: no console errors', problems.length === 0, problems.map(m => m.text).join(' | '));
277. check('server log: no error other than absorbed ones', !/error(?!: absorbed)/i.test(log.replace(/error absorbed[^\n]*/g, '')), log.split('\n').filter(l => /error/i.test(l)).slice(0, 5).join(' | '));
278. } catch (e) {
279. failures++;
280. console.log('FAIL gate crashed — ' + (e && e.stack || e));
281. if (pageA) { try { console.log('DOM: ' + (await pageA.evaluate('document.querySelector("#tokens") ? document.querySelector("#tokens").outerHTML.slice(0, 1500) : location.href'))); } catch {} }
282. if (pageA) console.log('page problems: ' + J(pageA.problems().map(m => m.text.slice(0, 300))));
283. } finally {
284. for (const b of browsers) { try { await b.close(); } catch {} }
285. if (proxy) proxy.close();
286. await stopServer();
287. if (ident) await ident.stop();
288. writeFileSync(join(SCRATCH, 'push-server.log'), log);
289. console.log(`${passes} passed, ${failures} failed`);
290. process.exit(failures ? 1 : 0);
291. }
292. function readdirOf(d) { try { return require_readdir(d); } catch { return []; } }
293. import { readdirSync as require_readdir } from 'node:fs';