@cevek/screentest 0.5.0 → 0.6.0

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 CHANGED
@@ -34,9 +34,13 @@ APP_URL=http://localhost:5050 npx vitest run --config vitest.screentest.config.t
34
34
  > to your package.json scripts so you can just `npm run screentest`.
35
35
 
36
36
  The daemon lives outside your project — one container serves every
37
- project on your machine. It listens on `ws://localhost:5180`, holds
38
- ~300MB RAM at idle, and stays up across reboots-of-your-app until you
39
- `screentest stop` it.
37
+ project on your machine. It listens on `ws://localhost:5180` and holds
38
+ ~300–450MB RAM while up. It stops itself after 3 minutes without a
39
+ connected client (`SCREENTEST_DAEMON_IDLE_SECONDS`: minimum `10`, `0` =
40
+ never, not a plain number = `180`) and the
41
+ next test run starts it again; a running test run keeps it alive.
42
+ Daemons started before 0.6 never stop on their own — after upgrading, run
43
+ `screentest stop` once.
40
44
 
41
45
  Your **tests run natively on the host** (your normal vitest + TS + path
42
46
  aliases + watch mode); only the Firefox rendering happens in the
@@ -17,13 +17,16 @@ import { request } from "http";
17
17
  import { dirname, resolve } from "path";
18
18
  import { fileURLToPath } from "url";
19
19
  var IMAGE_NAME = "cevek/screentest-firefox";
20
- var IMAGE_TAG = "pw-1.60.0";
20
+ var IMAGE_TAG = "pw-1.60.0-r2";
21
+ var PRE_IDLE_STOP_IMAGE = `${IMAGE_NAME}:pw-1.60.0`;
21
22
  var FULL_IMAGE = `${IMAGE_NAME}:${IMAGE_TAG}`;
22
23
  var CONTAINER_NAME = "screentest-firefox";
23
24
  var PORT = 5180;
24
25
  var WS_PATH = "screentest-firefox";
25
26
  var WS_ENDPOINT = `ws://localhost:${PORT}/${WS_PATH}`;
26
27
  var START_TIMEOUT_MS = 3e4;
28
+ var READY_TIMEOUT_MS = 15e3;
29
+ var IDLE_ENV = "SCREENTEST_DAEMON_IDLE_SECONDS";
27
30
  function run(cmd, argv) {
28
31
  return new Promise((resolveExit) => {
29
32
  const p = spawn(cmd, argv, { stdio: "inherit" });
@@ -34,20 +37,25 @@ function run(cmd, argv) {
34
37
  function daemonState() {
35
38
  const ps = spawnSync(
36
39
  "docker",
37
- ["ps", "-a", "-f", `name=^${CONTAINER_NAME}$`, "--format", "{{.State}} {{.Image}}"],
40
+ ["ps", "-a", "-f", `name=^${CONTAINER_NAME}$`, "--format", "{{.State}} {{.Image}} {{.ID}}"],
38
41
  { stdio: "pipe", encoding: "utf8" }
39
42
  );
40
43
  if (ps.error) return { state: "no-docker", reason: ps.error.message };
41
44
  if (ps.status !== 0) return { state: "no-docker", reason: ps.stderr.trim() };
42
- const [status = "", image = ""] = ps.stdout.trim().split(" ");
43
- if (status === "running") return { state: "running", image: image.trim() };
44
- if (status === "paused") return { state: "paused" };
45
+ const [status = "", image = "", id = ""] = ps.stdout.trim().split(" ");
46
+ if (status === "running") return { state: "running", image: image.trim(), id: id.trim() };
47
+ if (status === "paused") return { state: "paused", id: id.trim() };
45
48
  if (status === "created" || status === "restarting" || status === "removing") {
46
49
  return { state: "transitional", status };
47
50
  }
51
+ const staleId = id.trim();
48
52
  const img = spawnSync("docker", ["image", "inspect", FULL_IMAGE], { stdio: "pipe" });
49
- if (img.status !== 0) return { state: "missing-image" };
50
- return { state: "stopped" };
53
+ if (img.status !== 0) return { state: "missing-image", staleId };
54
+ return { state: "stopped", staleId };
55
+ }
56
+ function sameRunningContainer(id) {
57
+ const s = daemonState();
58
+ return s.state === "running" && s.id === id;
51
59
  }
52
60
  function resolveTemplatesDir() {
53
61
  const here = dirname(fileURLToPath(import.meta.url));
@@ -82,7 +90,13 @@ async function buildImage() {
82
90
  }
83
91
  function probeServer() {
84
92
  return new Promise((resolveProbe) => {
85
- const req = request({ host: "127.0.0.1", port: PORT, path: `/${WS_PATH}`, timeout: 1e3 });
93
+ const req = request({
94
+ host: "127.0.0.1",
95
+ port: PORT,
96
+ path: `/${WS_PATH}`,
97
+ timeout: 1e3,
98
+ agent: false
99
+ });
86
100
  req.once("response", (res) => {
87
101
  res.resume();
88
102
  resolveProbe(true);
@@ -92,14 +106,6 @@ function probeServer() {
92
106
  req.end();
93
107
  });
94
108
  }
95
- async function waitForReady(timeoutMs = 1e4) {
96
- const start = Date.now();
97
- while (Date.now() - start < timeoutMs) {
98
- if (await probeServer()) return true;
99
- await sleep(150);
100
- }
101
- return false;
102
- }
103
109
  function sleep(ms) {
104
110
  return new Promise((r) => setTimeout(r, ms));
105
111
  }
@@ -122,35 +128,57 @@ container (${FULL_IMAGE}). Start Docker, then re-run.
122
128
  `screentest-firefox daemon is running, but on a different image:
123
129
  running: ${s.image}
124
130
  this @cevek/screentest wants: ${FULL_IMAGE}
125
- \u2192 stop it first: screentest stop
131
+ ` + (s.image === PRE_IDLE_STOP_IMAGE ? ` (daemons from @cevek/screentest < 0.6 never stop on their own)
132
+ ` : "") + ` \u2192 stop it first: screentest stop
126
133
  \u2192 then re-run: screentest serve
127
134
  `
128
135
  );
129
136
  }
130
137
  }
131
- function startContainer() {
132
- spawnSync("docker", ["rm", CONTAINER_NAME], { stdio: "pipe" });
138
+ function startContainer(staleId) {
139
+ if (staleId) spawnSync("docker", ["rm", staleId], { stdio: "pipe" });
140
+ const idle = process.env[IDLE_ENV];
133
141
  const r = spawnSync(
134
142
  "docker",
135
- ["run", "-d", "--rm", "--name", CONTAINER_NAME, "--network=host", FULL_IMAGE],
143
+ [
144
+ "run",
145
+ "-d",
146
+ "--rm",
147
+ "--name",
148
+ CONTAINER_NAME,
149
+ "--network=host",
150
+ ...idle ? ["-e", `${IDLE_ENV}=${idle}`] : [],
151
+ FULL_IMAGE
152
+ ],
136
153
  { stdio: "pipe", encoding: "utf8" }
137
154
  );
138
155
  return { ok: !r.error && r.status === 0, stderr: r.stderr?.trim() ?? String(r.error) };
139
156
  }
140
157
  async function ensureDaemon() {
141
- const deadline = Date.now() + START_TIMEOUT_MS;
158
+ let deadline = Date.now() + START_TIMEOUT_MS;
142
159
  let started = false;
143
160
  let lastError = "";
161
+ let deafId = "";
162
+ let deafSince = 0;
144
163
  for (; ; ) {
145
164
  const s = daemonState();
146
165
  assertUsable(s);
147
166
  if (s.state === "running") {
148
- if (await waitForReady()) return { started };
149
- spawnSync("docker", ["logs", CONTAINER_NAME], { stdio: "inherit" });
150
- throw new Error(
151
- `screentest-firefox daemon container is up but never answered on port ${PORT}.
167
+ if (await probeServer() && sameRunningContainer(s.id)) return { started };
168
+ if (deafId !== s.id) {
169
+ deafId = s.id;
170
+ deafSince = Date.now();
171
+ }
172
+ const now = Date.now();
173
+ if (now - deafSince > READY_TIMEOUT_MS || now > deadline + READY_TIMEOUT_MS) {
174
+ spawnSync("docker", ["logs", CONTAINER_NAME], { stdio: "inherit" });
175
+ throw new Error(
176
+ `screentest-firefox daemon container is up but never answered on port ${PORT}.
152
177
  `
153
- );
178
+ );
179
+ }
180
+ await sleep(150);
181
+ continue;
154
182
  }
155
183
  if (Date.now() > deadline) {
156
184
  throw new Error(
@@ -159,14 +187,15 @@ async function ensureDaemon() {
159
187
  `
160
188
  );
161
189
  }
162
- if (s.state === "missing-image" && !await buildImage()) {
163
- throw new Error(`could not build ${FULL_IMAGE}
190
+ if (s.state === "missing-image") {
191
+ if (!await buildImage()) throw new Error(`could not build ${FULL_IMAGE}
164
192
  `);
193
+ deadline = Date.now() + START_TIMEOUT_MS;
165
194
  }
166
195
  if (s.state === "stopped" || s.state === "missing-image") {
167
196
  if (!started) process.stderr.write(`Starting screentest-firefox daemon (port ${PORT})\u2026
168
197
  `);
169
- const r = startContainer();
198
+ const r = startContainer(s.staleId);
170
199
  if (r.ok) started = true;
171
200
  else lastError = r.stderr;
172
201
  }
@@ -15053,16 +15082,18 @@ var PROBE_HTML = `<!doctype html><html><body style="margin:0;background:#fff">
15053
15082
  <p style="font:17px serif;margin:4px 0;transform:rotate(-3.7deg)">rotated glyphs</p>
15054
15083
  <div style="height:24px;border-radius:11px;border:1.5px solid #357;background:linear-gradient(97deg,#f06,#0af)"></div>
15055
15084
  </div></body></html>`;
15056
- async function probeRenderer(wsEndpoint, source) {
15057
- const browser = await firefox.connect(wsEndpoint, { timeout: 3e4 }).catch((err) => {
15085
+ async function connectRenderer(wsEndpoint) {
15086
+ return firefox.connect(wsEndpoint, { timeout: 3e4 }).catch((err) => {
15058
15087
  const msg = err instanceof Error ? err.message.split("\n")[0] : String(err);
15059
15088
  throw new Error(`[screentest] cannot reach the renderer at ${wsEndpoint}: ${msg}`);
15060
15089
  });
15090
+ }
15091
+ async function probeRenderer(browser, source) {
15092
+ const ctx = await browser.newContext({
15093
+ ...CONTEXT_DEFAULTS,
15094
+ viewport: { width: 400, height: 240 }
15095
+ });
15061
15096
  try {
15062
- const ctx = await browser.newContext({
15063
- ...CONTEXT_DEFAULTS,
15064
- viewport: { width: 400, height: 240 }
15065
- });
15066
15097
  const page = await ctx.newPage();
15067
15098
  await page.setContent(PROBE_HTML);
15068
15099
  await waitForVisualStable(page);
@@ -15072,7 +15103,7 @@ async function probeRenderer(wsEndpoint, source) {
15072
15103
  label: `${source}, firefox-${browser.version()}`
15073
15104
  };
15074
15105
  } finally {
15075
- await browser.close().catch(() => {
15106
+ await ctx.close().catch(() => {
15076
15107
  });
15077
15108
  }
15078
15109
  }
@@ -15086,12 +15117,7 @@ async function exists(p) {
15086
15117
  return false;
15087
15118
  }
15088
15119
  }
15089
- async function resolveWsEndpoint() {
15090
- const externalWs = process.env.SCREENTEST_FIREFOX_WS;
15091
- if (externalWs) {
15092
- console.log(`[screentest] using firefox WS from env: ${externalWs}`);
15093
- return { ws: externalWs, source: "SCREENTEST_FIREFOX_WS" };
15094
- }
15120
+ async function ensureDaemonOrExplain() {
15095
15121
  try {
15096
15122
  await ensureDaemon();
15097
15123
  } catch (err) {
@@ -15099,8 +15125,25 @@ async function resolveWsEndpoint() {
15099
15125
  throw new Error(`[screentest] cannot take screenshots:
15100
15126
  ${msg}`);
15101
15127
  }
15128
+ }
15129
+ async function resolveWsEndpoint() {
15130
+ const externalWs = process.env.SCREENTEST_FIREFOX_WS;
15131
+ if (externalWs) {
15132
+ console.log(`[screentest] using firefox WS from env: ${externalWs}`);
15133
+ return { ws: externalWs, source: "SCREENTEST_FIREFOX_WS", daemon: false };
15134
+ }
15135
+ await ensureDaemonOrExplain();
15102
15136
  console.log(`[screentest] using firefox daemon at ${WS_ENDPOINT}`);
15103
- return { ws: WS_ENDPOINT, source: FULL_IMAGE };
15137
+ return { ws: WS_ENDPOINT, source: FULL_IMAGE, daemon: true };
15138
+ }
15139
+ async function connectLease(ws, daemon) {
15140
+ try {
15141
+ return await connectRenderer(ws);
15142
+ } catch (err) {
15143
+ if (!daemon) throw err;
15144
+ await ensureDaemonOrExplain();
15145
+ return connectRenderer(ws);
15146
+ }
15104
15147
  }
15105
15148
  function detectVitestFilter() {
15106
15149
  if (process.env.SCREENTEST_FORCE_DELETION_DETECTION) {
@@ -15146,17 +15189,27 @@ function spawnUI(docFile) {
15146
15189
  }
15147
15190
  async function setup(project) {
15148
15191
  const paths = resolveRunnerPaths();
15149
- const { ws, source } = await resolveWsEndpoint();
15150
- const renderer = await probeRenderer(ws, source);
15151
- project.provide("wsEndpoint", ws);
15152
- await fs2.mkdir(paths.cacheDir, { recursive: true });
15153
- if (!await exists(paths.snapshotFile)) {
15154
- await fs2.mkdir(dirname2(paths.snapshotFile), { recursive: true });
15155
- await fs2.writeFile(paths.snapshotFile, '{\n "groups": []\n}\n');
15156
- }
15157
- await fs2.rm(paths.actualDir, { recursive: true, force: true });
15158
- await fs2.writeFile(paths.runFile, JSON.stringify({ renderer }, null, 2) + "\n");
15192
+ const { ws, source, daemon } = await resolveWsEndpoint();
15193
+ const lease = await connectLease(ws, daemon);
15194
+ const release = () => lease.close().catch(() => {
15195
+ });
15196
+ try {
15197
+ const renderer = await probeRenderer(lease, source);
15198
+ if (!daemon) await release();
15199
+ project.provide("wsEndpoint", ws);
15200
+ await fs2.mkdir(paths.cacheDir, { recursive: true });
15201
+ if (!await exists(paths.snapshotFile)) {
15202
+ await fs2.mkdir(dirname2(paths.snapshotFile), { recursive: true });
15203
+ await fs2.writeFile(paths.snapshotFile, '{\n "groups": []\n}\n');
15204
+ }
15205
+ await fs2.rm(paths.actualDir, { recursive: true, force: true });
15206
+ await fs2.writeFile(paths.runFile, JSON.stringify({ renderer }, null, 2) + "\n");
15207
+ } catch (err) {
15208
+ await release();
15209
+ throw err;
15210
+ }
15159
15211
  return async () => {
15212
+ await release();
15160
15213
  const filter = detectVitestFilter();
15161
15214
  if (filter.filtered) {
15162
15215
  process.stderr.write(
package/dist/index.js CHANGED
@@ -15554,13 +15554,16 @@ import { request } from "http";
15554
15554
  import { dirname as dirname6, resolve as resolve8 } from "path";
15555
15555
  import { fileURLToPath as fileURLToPath4 } from "url";
15556
15556
  var IMAGE_NAME = "cevek/screentest-firefox";
15557
- var IMAGE_TAG = "pw-1.60.0";
15557
+ var IMAGE_TAG = "pw-1.60.0-r2";
15558
+ var PRE_IDLE_STOP_IMAGE = `${IMAGE_NAME}:pw-1.60.0`;
15558
15559
  var FULL_IMAGE = `${IMAGE_NAME}:${IMAGE_TAG}`;
15559
15560
  var CONTAINER_NAME = "screentest-firefox";
15560
15561
  var PORT = 5180;
15561
15562
  var WS_PATH = "screentest-firefox";
15562
15563
  var WS_ENDPOINT = `ws://localhost:${PORT}/${WS_PATH}`;
15563
15564
  var START_TIMEOUT_MS = 3e4;
15565
+ var READY_TIMEOUT_MS = 15e3;
15566
+ var IDLE_ENV = "SCREENTEST_DAEMON_IDLE_SECONDS";
15564
15567
  function run2(cmd, argv) {
15565
15568
  return new Promise((resolveExit) => {
15566
15569
  const p = spawn2(cmd, argv, { stdio: "inherit" });
@@ -15571,20 +15574,32 @@ function run2(cmd, argv) {
15571
15574
  function daemonState() {
15572
15575
  const ps = spawnSync2(
15573
15576
  "docker",
15574
- ["ps", "-a", "-f", `name=^${CONTAINER_NAME}$`, "--format", "{{.State}} {{.Image}}"],
15577
+ ["ps", "-a", "-f", `name=^${CONTAINER_NAME}$`, "--format", "{{.State}} {{.Image}} {{.ID}}"],
15575
15578
  { stdio: "pipe", encoding: "utf8" }
15576
15579
  );
15577
15580
  if (ps.error) return { state: "no-docker", reason: ps.error.message };
15578
15581
  if (ps.status !== 0) return { state: "no-docker", reason: ps.stderr.trim() };
15579
- const [status = "", image = ""] = ps.stdout.trim().split(" ");
15580
- if (status === "running") return { state: "running", image: image.trim() };
15581
- if (status === "paused") return { state: "paused" };
15582
+ const [status = "", image = "", id = ""] = ps.stdout.trim().split(" ");
15583
+ if (status === "running") return { state: "running", image: image.trim(), id: id.trim() };
15584
+ if (status === "paused") return { state: "paused", id: id.trim() };
15582
15585
  if (status === "created" || status === "restarting" || status === "removing") {
15583
15586
  return { state: "transitional", status };
15584
15587
  }
15588
+ const staleId = id.trim();
15585
15589
  const img = spawnSync2("docker", ["image", "inspect", FULL_IMAGE], { stdio: "pipe" });
15586
- if (img.status !== 0) return { state: "missing-image" };
15587
- return { state: "stopped" };
15590
+ if (img.status !== 0) return { state: "missing-image", staleId };
15591
+ return { state: "stopped", staleId };
15592
+ }
15593
+ function sameRunningContainer(id) {
15594
+ const s = daemonState();
15595
+ return s.state === "running" && s.id === id;
15596
+ }
15597
+ function containerExists(id) {
15598
+ const r = spawnSync2("docker", ["ps", "-aq", "--no-trunc", "-f", `id=${id}`], {
15599
+ stdio: "pipe",
15600
+ encoding: "utf8"
15601
+ });
15602
+ return r.status !== 0 || r.stdout.trim() !== "";
15588
15603
  }
15589
15604
  function resolveTemplatesDir() {
15590
15605
  const here = dirname6(fileURLToPath4(import.meta.url));
@@ -15619,7 +15634,13 @@ async function buildImage() {
15619
15634
  }
15620
15635
  function probeServer() {
15621
15636
  return new Promise((resolveProbe) => {
15622
- const req = request({ host: "127.0.0.1", port: PORT, path: `/${WS_PATH}`, timeout: 1e3 });
15637
+ const req = request({
15638
+ host: "127.0.0.1",
15639
+ port: PORT,
15640
+ path: `/${WS_PATH}`,
15641
+ timeout: 1e3,
15642
+ agent: false
15643
+ });
15623
15644
  req.once("response", (res) => {
15624
15645
  res.resume();
15625
15646
  resolveProbe(true);
@@ -15629,14 +15650,6 @@ function probeServer() {
15629
15650
  req.end();
15630
15651
  });
15631
15652
  }
15632
- async function waitForReady(timeoutMs = 1e4) {
15633
- const start = Date.now();
15634
- while (Date.now() - start < timeoutMs) {
15635
- if (await probeServer()) return true;
15636
- await sleep(150);
15637
- }
15638
- return false;
15639
- }
15640
15653
  function sleep(ms) {
15641
15654
  return new Promise((r) => setTimeout(r, ms));
15642
15655
  }
@@ -15659,35 +15672,57 @@ container (${FULL_IMAGE}). Start Docker, then re-run.
15659
15672
  `screentest-firefox daemon is running, but on a different image:
15660
15673
  running: ${s.image}
15661
15674
  this @cevek/screentest wants: ${FULL_IMAGE}
15662
- \u2192 stop it first: screentest stop
15675
+ ` + (s.image === PRE_IDLE_STOP_IMAGE ? ` (daemons from @cevek/screentest < 0.6 never stop on their own)
15676
+ ` : "") + ` \u2192 stop it first: screentest stop
15663
15677
  \u2192 then re-run: screentest serve
15664
15678
  `
15665
15679
  );
15666
15680
  }
15667
15681
  }
15668
- function startContainer() {
15669
- spawnSync2("docker", ["rm", CONTAINER_NAME], { stdio: "pipe" });
15682
+ function startContainer(staleId) {
15683
+ if (staleId) spawnSync2("docker", ["rm", staleId], { stdio: "pipe" });
15684
+ const idle = process.env[IDLE_ENV];
15670
15685
  const r = spawnSync2(
15671
15686
  "docker",
15672
- ["run", "-d", "--rm", "--name", CONTAINER_NAME, "--network=host", FULL_IMAGE],
15687
+ [
15688
+ "run",
15689
+ "-d",
15690
+ "--rm",
15691
+ "--name",
15692
+ CONTAINER_NAME,
15693
+ "--network=host",
15694
+ ...idle ? ["-e", `${IDLE_ENV}=${idle}`] : [],
15695
+ FULL_IMAGE
15696
+ ],
15673
15697
  { stdio: "pipe", encoding: "utf8" }
15674
15698
  );
15675
15699
  return { ok: !r.error && r.status === 0, stderr: r.stderr?.trim() ?? String(r.error) };
15676
15700
  }
15677
15701
  async function ensureDaemon() {
15678
- const deadline = Date.now() + START_TIMEOUT_MS;
15702
+ let deadline = Date.now() + START_TIMEOUT_MS;
15679
15703
  let started = false;
15680
15704
  let lastError = "";
15705
+ let deafId = "";
15706
+ let deafSince = 0;
15681
15707
  for (; ; ) {
15682
15708
  const s = daemonState();
15683
15709
  assertUsable(s);
15684
15710
  if (s.state === "running") {
15685
- if (await waitForReady()) return { started };
15686
- spawnSync2("docker", ["logs", CONTAINER_NAME], { stdio: "inherit" });
15687
- throw new Error(
15688
- `screentest-firefox daemon container is up but never answered on port ${PORT}.
15711
+ if (await probeServer() && sameRunningContainer(s.id)) return { started };
15712
+ if (deafId !== s.id) {
15713
+ deafId = s.id;
15714
+ deafSince = Date.now();
15715
+ }
15716
+ const now = Date.now();
15717
+ if (now - deafSince > READY_TIMEOUT_MS || now > deadline + READY_TIMEOUT_MS) {
15718
+ spawnSync2("docker", ["logs", CONTAINER_NAME], { stdio: "inherit" });
15719
+ throw new Error(
15720
+ `screentest-firefox daemon container is up but never answered on port ${PORT}.
15689
15721
  `
15690
- );
15722
+ );
15723
+ }
15724
+ await sleep(150);
15725
+ continue;
15691
15726
  }
15692
15727
  if (Date.now() > deadline) {
15693
15728
  throw new Error(
@@ -15696,14 +15731,15 @@ async function ensureDaemon() {
15696
15731
  `
15697
15732
  );
15698
15733
  }
15699
- if (s.state === "missing-image" && !await buildImage()) {
15700
- throw new Error(`could not build ${FULL_IMAGE}
15734
+ if (s.state === "missing-image") {
15735
+ if (!await buildImage()) throw new Error(`could not build ${FULL_IMAGE}
15701
15736
  `);
15737
+ deadline = Date.now() + START_TIMEOUT_MS;
15702
15738
  }
15703
15739
  if (s.state === "stopped" || s.state === "missing-image") {
15704
15740
  if (!started) process.stderr.write(`Starting screentest-firefox daemon (port ${PORT})\u2026
15705
15741
  `);
15706
- const r = startContainer();
15742
+ const r = startContainer(s.staleId);
15707
15743
  if (r.ok) started = true;
15708
15744
  else lastError = r.stderr;
15709
15745
  }
@@ -15729,9 +15765,10 @@ async function stopDaemon() {
15729
15765
  process.stdout.write("screentest-firefox daemon is not running\n");
15730
15766
  return 0;
15731
15767
  }
15732
- const code = await run2("docker", ["stop", CONTAINER_NAME]);
15733
- if (code === 0) process.stdout.write("screentest-firefox daemon stopped\n");
15734
- return code;
15768
+ const code = await run2("docker", ["stop", s.id]);
15769
+ const gone = code === 0 || !containerExists(s.id);
15770
+ if (gone) process.stdout.write("screentest-firefox daemon stopped\n");
15771
+ return gone ? 0 : code;
15735
15772
  }
15736
15773
  async function printStatus() {
15737
15774
  const s = daemonState();
@@ -18,7 +18,7 @@ WORKDIR /work
18
18
  RUN npm init -y >/dev/null \
19
19
  && npm install --no-audit --no-fund --no-progress playwright@1.60.0
20
20
 
21
- COPY launch-server.mjs ./
21
+ COPY launch-server.mjs idle-proxy.mjs ./
22
22
 
23
23
  EXPOSE 5180
24
24
 
@@ -0,0 +1,88 @@
1
+ import net from 'node:net';
2
+
3
+ export const DEFAULT_IDLE_SECONDS = 180;
4
+ // A cold start must survive until the host's readiness probe and lease
5
+ // connect land (ensureDaemon polls every 150–300 ms; Firefox may be slow).
6
+ export const MIN_IDLE_SECONDS = 10;
7
+ // setTimeout overflows above 2^31-1 ms and fires after 1 ms instead.
8
+ const MAX_TIMER_MS = 2 ** 31 - 1;
9
+
10
+ /**
11
+ * `SCREENTEST_DAEMON_IDLE_SECONDS`: a non-negative number, `0` = never stop,
12
+ * raised to MIN_IDLE_SECONDS. Anything else falls back to the default rather
13
+ * than disabling the stop.
14
+ *
15
+ * @param {string | undefined} raw
16
+ * @returns {number}
17
+ */
18
+ export function parseIdleSeconds(raw) {
19
+ const s = raw?.trim() ?? '';
20
+ if (!/^\d+(\.\d+)?$/.test(s)) return DEFAULT_IDLE_SECONDS;
21
+ const n = Number(s);
22
+ return n === 0 ? 0 : Math.max(n, MIN_IDLE_SECONDS);
23
+ }
24
+
25
+ /**
26
+ * TCP proxy in front of the Playwright browser-server that counts open client
27
+ * connections; Playwright's BrowserServer exposes no such count. Calls
28
+ * `onIdle` once after `idleMs` with no connection open (counted from start
29
+ * and from every drop to zero), after it has already stopped accepting.
30
+ * `idleMs <= 0` never fires; `close()` stops it for good.
31
+ *
32
+ * @param {{ host: string; port: number; upstreamPort: number; idleMs: number; onIdle: () => void }} opts
33
+ * @returns {Promise<{ port: number; close: () => void }>}
34
+ */
35
+ export function startIdleProxy({ host, port, upstreamPort, idleMs, onIdle }) {
36
+ let open = 0;
37
+ let stopped = false;
38
+ let timer;
39
+ const stop = () => {
40
+ stopped = true;
41
+ clearTimeout(timer);
42
+ proxy.close();
43
+ };
44
+ const wait = (until) => {
45
+ timer = setTimeout(
46
+ () => {
47
+ if (Date.now() < until) return wait(until);
48
+ stop();
49
+ onIdle();
50
+ },
51
+ Math.min(until - Date.now(), MAX_TIMER_MS),
52
+ );
53
+ };
54
+ const arm = () => {
55
+ if (stopped || idleMs <= 0) return;
56
+ wait(Date.now() + idleMs);
57
+ };
58
+
59
+ // Half-open on both legs: a client's FIN must not cut off the reply still
60
+ // coming back. `pipe` forwards each FIN; 'close' fires once both are done.
61
+ const proxy = net.createServer({ allowHalfOpen: true }, (client) => {
62
+ clearTimeout(timer);
63
+ open += 1;
64
+ const upstream = net.connect({ port: upstreamPort, host: '127.0.0.1', allowHalfOpen: true });
65
+ client.pipe(upstream);
66
+ upstream.pipe(client);
67
+ client.on('error', () => upstream.destroy());
68
+ upstream.on('error', () => client.destroy());
69
+ client.on('close', () => {
70
+ upstream.destroy();
71
+ open -= 1;
72
+ if (open === 0) arm();
73
+ });
74
+ upstream.on('close', () => client.destroy());
75
+ });
76
+
77
+ return new Promise((resolveStart, rejectStart) => {
78
+ proxy.once('error', rejectStart);
79
+ proxy.listen(port, host, () => {
80
+ proxy.off('error', rejectStart);
81
+ arm();
82
+ resolveStart({
83
+ port: /** @type {net.AddressInfo} */ (proxy.address()).port,
84
+ close: stop,
85
+ });
86
+ });
87
+ });
88
+ }
@@ -1,22 +1,47 @@
1
1
  // Long-lived headless Firefox browser-server. Tests on the host connect via
2
2
  // WS, see playwright.dev/docs/api/class-browsertype#browser-type-launch-server
3
3
  import { firefox } from 'playwright';
4
+ import { parseIdleSeconds, startIdleProxy } from './idle-proxy.mjs';
4
5
 
5
6
  const port = Number.parseInt(process.env.SCREENTEST_PORT ?? '5180', 10);
6
7
  const wsPath = process.env.SCREENTEST_WS_PATH ?? 'screentest-firefox';
8
+ const idleSeconds = parseIdleSeconds(process.env.SCREENTEST_DAEMON_IDLE_SECONDS);
9
+ // A Firefox that hangs on close must not leave a running container with no
10
+ // listener: ensureDaemon gives such a container READY_TIMEOUT_MS (daemon.ts)
11
+ // before failing instead of starting anew.
12
+ const FORCE_EXIT_MS = 5_000;
7
13
 
8
- const server = await firefox.launchServer({
9
- port,
14
+ // Random loopback port: clients reach Firefox only through the counting proxy.
15
+ const server = await firefox.launchServer({ port: 0, host: '127.0.0.1', wsPath });
16
+ const upstreamPort = Number(new URL(server.wsEndpoint()).port);
17
+
18
+ let closing = false;
19
+ const shutdown = async (reason, code = 0) => {
20
+ if (closing) return;
21
+ closing = true;
22
+ console.log(`[screentest] ${reason}, closing browser-server`);
23
+ proxy.close();
24
+ setTimeout(() => process.exit(code), FORCE_EXIT_MS).unref();
25
+ await server.close().catch(() => {});
26
+ process.exit(code);
27
+ };
28
+
29
+ const proxy = await startIdleProxy({
10
30
  host: '0.0.0.0',
11
- wsPath,
31
+ port,
32
+ upstreamPort,
33
+ idleMs: idleSeconds * 1000,
34
+ onIdle: () => void shutdown(`no clients for ${idleSeconds}s`),
12
35
  });
13
36
 
14
- console.log(`[screentest] firefox browser-server ready: ${server.wsEndpoint()}`);
37
+ // Firefox died on its own: exit so `--rm` frees the name for a fresh daemon
38
+ // instead of a proxy that forwards to nothing.
39
+ server.on('close', () => void shutdown('browser-server closed unexpectedly', 1));
15
40
 
16
- const shutdown = async (signal) => {
17
- console.log(`[screentest] received ${signal}, closing browser-server`);
18
- await server.close();
19
- process.exit(0);
20
- };
21
- process.on('SIGTERM', () => void shutdown('SIGTERM'));
22
- process.on('SIGINT', () => void shutdown('SIGINT'));
41
+ console.log(
42
+ `[screentest] firefox browser-server ready on port ${port}` +
43
+ (idleSeconds > 0 ? `, stops after ${idleSeconds}s without clients` : ''),
44
+ );
45
+
46
+ process.on('SIGTERM', () => void shutdown('received SIGTERM'));
47
+ process.on('SIGINT', () => void shutdown('received SIGINT'));
package/package.json CHANGED
@@ -3,7 +3,7 @@
3
3
  "publishConfig": {
4
4
  "access": "public"
5
5
  },
6
- "version": "0.5.0",
6
+ "version": "0.6.0",
7
7
  "description": "Local desktop tool for visual screenshot-test review — CLI, runner helpers, and review UI shipped as a single package.",
8
8
  "license": "MIT",
9
9
  "type": "module",
@@ -28,6 +28,7 @@
28
28
  "build": "tsup && node scripts/postbuild.mjs",
29
29
  "start": "node dist/index.js",
30
30
  "typecheck": "tsc --noEmit",
31
+ "test": "vitest run",
31
32
  "prepublishOnly": "pnpm -w typecheck && pnpm -w build"
32
33
  },
33
34
  "dependencies": {