@monoes/monobrowse 1.0.11 → 1.0.12

package/src/__tests__/open-url-navigate-error.test.ts

@@ -7,8 +7,8 @@
  * this checks that response before doing anything else.
  */
 import { afterEach, describe, expect, it, vi } from 'vitest';
-import type { CdpClient } from '../browser/cdp.js';
 import { openUrl } from '../browser/browser.js';
+import type { CdpClient } from '../browser/cdp.js';
 
 afterEach(() => {
   vi.restoreAllMocks();
@@ -43,9 +43,7 @@ describe('openUrl navigation-failure detection', () => {
     await expect(openUrl(client, 'sess-1', 'http://127.0.0.1:1/')).rejects.toThrow(
       /net::ERR_CONNECTION_REFUSED/,
     );
-    expect(calls).toEqual([
-      { method: 'Page.navigate', params: { url: 'http://127.0.0.1:1/' } },
-    ]);
+    expect(calls).toEqual([{ method: 'Page.navigate', params: { url: 'http://127.0.0.1:1/' } }]);
   });
 
   it('rejects the 2 MB URL guard before ever calling Page.navigate', async () => {

package/src/__tests__/output.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
 
 // The module exports a singleton `output` which reads process.stdout.isTTY at
 // construction time. We need to control that, so we reset modules per test.

package/src/__tests__/reap-idle-browser.test.ts

@@ -0,0 +1,276 @@
+/**
+ * #310: a launched Chrome outlives its session, holding its CDP port (9222 by
+ * convention, which other local tools want) with zero targets left to
+ * reattach to. reapIdleLaunchedBrowser() gives that port back.
+ *
+ * No real Chrome is spawned: the CDP HTTP endpoints (/json/version, /json/list)
+ * are served by a local http server that answers exactly like Chrome does
+ * (same approach as browser-launch.test.ts), the browser-level websocket is a
+ * fake `ws` socket (same approach as close-browser.test.ts), and process.kill
+ * is spied on rather than actually signaling anything.
+ *
+ * Fixed port range (23490-23499) chosen to avoid colliding with real services.
+ */
+
+import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { createServer as createHttpServer, type Server as HttpServer } from 'node:http';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import type { CdpTarget } from '../browser/types.js';
+
+const BASE = 23490;
+const MINUTE = 60_000;
+
+let lastSocket: FakeWs | null = null;
+
+/** Minimal `ws` stand-in: opens on its own and acknowledges every command,
+ *  so `Browser.close` takes the graceful path without a real browser. */
+class FakeWs {
+  handlers = new Map<string, Array<(...a: unknown[]) => void>>();
+  sent: string[] = [];
+  constructor(public url: string) {
+    lastSocket = this;
+    queueMicrotask(() => this.emit('open'));
+  }
+  on(event: string, fn: (...a: unknown[]) => void): void {
+    if (!this.handlers.has(event)) this.handlers.set(event, []);
+    this.handlers.get(event)!.push(fn);
+  }
+  emit(event: string, ...args: unknown[]): void {
+    for (const fn of [...(this.handlers.get(event) ?? [])]) fn(...args);
+  }
+  send(data: string, cb?: (err?: Error) => void): void {
+    void cb;
+    this.sent.push(data);
+    const { id } = JSON.parse(data) as { id: number };
+    queueMicrotask(() => this.emit('message', Buffer.from(JSON.stringify({ id, result: {} }))));
+  }
+  close(): void {}
+  /** Methods this socket was asked to run, e.g. ['Browser.close']. */
+  methods(): string[] {
+    return this.sent.map((s) => (JSON.parse(s) as { method: string }).method);
+  }
+}
+
+vi.mock('ws', () => ({ WebSocket: FakeWs }));
+
+let tempDir: string;
+let servers: HttpServer[] = [];
+let killSpy: ReturnType<typeof vi.spyOn>;
+
+beforeEach(async () => {
+  lastSocket = null;
+  tempDir = await mkdtemp(join(tmpdir(), 'monobrowse-reap-test-'));
+  // ref-cache.ts resolves its cache dir from process.cwd() at module load, so
+  // this must be in place before the dynamic import in each test.
+  vi.spyOn(process, 'cwd').mockReturnValue(tempDir);
+  // The browser is "already gone" by the time closeBrowser polls for its exit
+  // (ESRCH on the liveness probe) — the realistic outcome of Browser.close.
+  killSpy = vi.spyOn(process, 'kill').mockImplementation((_pid: unknown, signal?: unknown) => {
+    if (signal === 0) throw Object.assign(new Error('ESRCH'), { code: 'ESRCH' });
+    return true as never;
+  });
+});
+
+afterEach(async () => {
+  await Promise.all(servers.map((s) => new Promise<void>((resolve) => s.close(() => resolve()))));
+  servers = [];
+  vi.restoreAllMocks();
+  await rm(tempDir, { recursive: true, force: true });
+});
+
+/** An http server answering /json/version and /json/list exactly like Chrome. */
+function fakeChrome(port: number, targets: Partial<CdpTarget>[]): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const s = createHttpServer((req, res) => {
+      if (req.url === '/json/version') {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(
+          JSON.stringify({
+            Browser: 'Chrome/999.0.0.0',
+            webSocketDebuggerUrl: `ws://127.0.0.1:${port}/devtools/browser/fake-browser-id`,
+          }),
+        );
+      } else if (req.url === '/json/list') {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(targets));
+      } else {
+        res.writeHead(404);
+        res.end();
+      }
+    });
+    s.once('error', reject);
+    s.listen(port, '127.0.0.1', () => {
+      servers.push(s);
+      resolve();
+    });
+  });
+}
+
+const PORT_FILE = () => join(tempDir, '.monomind', 'monobrowse', 'active-port.json');
+
+async function writePersistedPort(record: {
+  port: number;
+  pid?: number;
+  launched: boolean;
+  savedAt: number;
+}): Promise<void> {
+  await mkdir(join(tempDir, '.monomind', 'monobrowse'), { recursive: true });
+  await writeFile(PORT_FILE(), JSON.stringify(record), 'utf-8');
+}
+
+async function portFileExists(): Promise<boolean> {
+  return readFile(PORT_FILE(), 'utf-8').then(
+    () => true,
+    () => false,
+  );
+}
+
+async function loadBrowser() {
+  vi.resetModules();
+  return import('../browser/browser.js');
+}
+
+/** A page target as Chrome reports it when NO debugger is attached to it. */
+function idlePageTarget(id: string, port: number): Partial<CdpTarget> {
+  return {
+    id,
+    type: 'page',
+    title: 'Example',
+    url: 'https://example.com/',
+    webSocketDebuggerUrl: `ws://127.0.0.1:${port}/devtools/page/${id}`,
+  };
+}
+
+describe('#310 reapIdleLaunchedBrowser — give back a CDP port nothing is using', () => {
+  it('reaps a launched instance that has had zero targets past the idle threshold', async () => {
+    const port = BASE + 0;
+    await fakeChrome(port, []);
+    await writePersistedPort({
+      port,
+      pid: 54321,
+      launched: true,
+      savedAt: Date.now() - 45 * MINUTE,
+    });
+
+    const { reapIdleLaunchedBrowser } = await loadBrowser();
+    await expect(reapIdleLaunchedBrowser()).resolves.toBe(port);
+
+    expect(lastSocket?.url).toBe(`ws://127.0.0.1:${port}/devtools/browser/fake-browser-id`);
+    expect(lastSocket?.methods()).toContain('Browser.close');
+    // The port file is the session handle — a reaped session must not leave
+    // one behind for the next command to chase.
+    expect(await portFileExists()).toBe(false);
+  });
+
+  it('does NOT reap a launched instance that still has open page targets', async () => {
+    const port = BASE + 1;
+    await fakeChrome(port, [idlePageTarget('AAA', port)]);
+    await writePersistedPort({
+      port,
+      pid: 54322,
+      launched: true,
+      savedAt: Date.now() - 45 * MINUTE,
+    });
+
+    const { reapIdleLaunchedBrowser } = await loadBrowser();
+    await expect(reapIdleLaunchedBrowser()).resolves.toBeNull();
+
+    expect(lastSocket).toBeNull();
+    expect(killSpy).not.toHaveBeenCalled();
+    expect(await portFileExists()).toBe(true);
+  });
+
+  it('does NOT reap a browser this tool never launched, however idle or old it is', async () => {
+    // `connect` records launched:false — that browser belongs to the user.
+    const port = BASE + 2;
+    await fakeChrome(port, []);
+    await writePersistedPort({
+      port,
+      pid: 54323,
+      launched: false,
+      savedAt: Date.now() - 48 * 60 * MINUTE,
+    });
+
+    const { reapIdleLaunchedBrowser } = await loadBrowser();
+    await expect(reapIdleLaunchedBrowser()).resolves.toBeNull();
+
+    expect(lastSocket).toBeNull();
+    expect(killSpy).not.toHaveBeenCalled();
+    expect(await portFileExists()).toBe(true);
+  });
+
+  it('does NOT reap while a client is still attached to a target', async () => {
+    // Chrome omits webSocketDebuggerUrl from a target that already has a
+    // debugger attached — an in-flight session, not an abandoned browser.
+    const port = BASE + 3;
+    await fakeChrome(port, [
+      { id: 'BBB', type: 'page', title: 'Example', url: 'https://example.com/' },
+    ]);
+    await writePersistedPort({
+      port,
+      pid: 54324,
+      launched: true,
+      savedAt: Date.now() - 45 * MINUTE,
+    });
+
+    const { reapIdleLaunchedBrowser } = await loadBrowser();
+    await expect(reapIdleLaunchedBrowser()).resolves.toBeNull();
+
+    expect(lastSocket).toBeNull();
+    expect(await portFileExists()).toBe(true);
+  });
+
+  it('does NOT reap an instance that is still inside the idle threshold', async () => {
+    // A live session can momentarily have no targets (last tab closed, next
+    // command about to open one) — reaping that would break reattach.
+    const port = BASE + 4;
+    await fakeChrome(port, []);
+    await writePersistedPort({ port, pid: 54325, launched: true, savedAt: Date.now() - MINUTE });
+
+    const { reapIdleLaunchedBrowser } = await loadBrowser();
+    await expect(reapIdleLaunchedBrowser()).resolves.toBeNull();
+
+    expect(lastSocket).toBeNull();
+    expect(await portFileExists()).toBe(true);
+  });
+
+  it('does NOT reap when the persisted record has no savedAt (age unknowable)', async () => {
+    const port = BASE + 5;
+    await fakeChrome(port, []);
+    await mkdir(join(tempDir, '.monomind', 'monobrowse'), { recursive: true });
+    await writeFile(PORT_FILE(), JSON.stringify({ port, pid: 54326, launched: true }), 'utf-8');
+
+    const { reapIdleLaunchedBrowser } = await loadBrowser();
+    await expect(reapIdleLaunchedBrowser()).resolves.toBeNull();
+    expect(lastSocket).toBeNull();
+  });
+
+  it('is a no-op with no persisted session at all', async () => {
+    const { reapIdleLaunchedBrowser } = await loadBrowser();
+    await expect(reapIdleLaunchedBrowser()).resolves.toBeNull();
+    expect(killSpy).not.toHaveBeenCalled();
+  });
+
+  it('launchBrowser reaps the stale instance before deciding what to do with the port', async () => {
+    // The wiring that makes the reaper run at all: every launch/attach is a
+    // chance to give back a port a previous session abandoned.
+    const port = BASE + 6;
+    await fakeChrome(port, []);
+    await writePersistedPort({
+      port,
+      pid: 54327,
+      launched: true,
+      savedAt: Date.now() - 45 * MINUTE,
+    });
+
+    const { launchBrowser } = await loadBrowser();
+    // The fake Chrome stays listening, so launchBrowser attaches to it after
+    // the reap rather than spawning a real browser.
+    await expect(launchBrowser({ port })).resolves.toBe(port);
+
+    expect(lastSocket?.methods()).toContain('Browser.close');
+    expect(await portFileExists()).toBe(false);
+  });
+});

package/src/__tests__/ref-cache.test.ts

@@ -1,7 +1,7 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { mkdtemp, readFile, rm, stat } from 'fs/promises';
-import { join } from 'path';
-import { tmpdir } from 'os';
+import { mkdtemp, readFile, rm, stat } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 // We need to mock process.cwd() before importing ref-cache so CACHE_DIR
 // resolves to our temp directory.
@@ -26,7 +26,9 @@ async function importRefCache() {
   return import('../browser/ref-cache.js');
 }
 
-function makeRefs(count = 2): Map<string, { ref: string; role: string; name: string; nodeId: number }> {
+function makeRefs(
+  count = 2,
+): Map<string, { ref: string; role: string; name: string; nodeId: number }> {
   const map = new Map();
   for (let i = 1; i <= count; i++) {
     map.set(`ref${i}`, { ref: `ref${i}`, role: 'button', name: `Button ${i}`, nodeId: i });
@@ -68,7 +70,7 @@ describe('ref-cache', () => {
 
     // Now overwrite the file with invalid JSON
     const cacheFile = join(tempDir, '.monomind', 'monobrowse', 'ax-snapshot.json');
-    const { writeFile: wf } = await import('fs/promises');
+    const { writeFile: wf } = await import('node:fs/promises');
     await wf(cacheFile, '{{{not valid json!!!');
 
     const loaded = await mod.loadRefCache('t');
@@ -117,7 +119,7 @@ describe('ref-cache', () => {
     const cacheFile = join(tempDir, '.monomind', 'monobrowse', 'ax-snapshot.json');
     const raw = JSON.parse(await readFile(cacheFile, 'utf8'));
     raw.savedAt = Date.now() - mod.REF_CACHE_STALE_MS - 5000;
-    const { writeFile: wf } = await import('fs/promises');
+    const { writeFile: wf } = await import('node:fs/promises');
     await wf(cacheFile, JSON.stringify(raw));
 
     const loaded = await mod.loadRefCache('t1');
@@ -138,13 +140,21 @@ describe('active-port persistence', () => {
     const mod = await importRefCache();
     await mod.saveActivePort(9333);
     expect(await mod.loadActivePort()).toBe(9333);
-    expect(await mod.loadActivePortInfo()).toEqual({ port: 9333, launched: true, savedAt: expect.any(Number) });
+    expect(await mod.loadActivePortInfo()).toEqual({
+      port: 9333,
+      launched: true,
+      savedAt: expect.any(Number),
+    });
   });
 
   it('connect provenance: launched:false survives the round-trip', async () => {
     const mod = await importRefCache();
     await mod.saveActivePort(9229, { launched: false });
-    expect(await mod.loadActivePortInfo()).toEqual({ port: 9229, launched: false, savedAt: expect.any(Number) });
+    expect(await mod.loadActivePortInfo()).toEqual({
+      port: 9229,
+      launched: false,
+      savedAt: expect.any(Number),
+    });
   });
 
   it('clear removes the file; load returns null afterwards', async () => {
@@ -196,11 +206,14 @@ describe('active-port persistence', () => {
 
   it('#115: a non-numeric or non-positive persisted pid is dropped, not trusted', async () => {
     const mod = await importRefCache();
-    const { writeFile, mkdir } = await import('fs/promises');
+    const { writeFile, mkdir } = await import('node:fs/promises');
     const dir = join(process.cwd(), '.monomind', 'monobrowse');
     await mkdir(dir, { recursive: true });
     for (const badPid of ['54321', -1, 0, 1.5, null]) {
-      await writeFile(join(dir, 'active-port.json'), JSON.stringify({ port: 9333, launched: true, pid: badPid }));
+      await writeFile(
+        join(dir, 'active-port.json'),
+        JSON.stringify({ port: 9333, launched: true, pid: badPid }),
+      );
       const info = await mod.loadActivePortInfo();
       expect(info!.pid).toBeUndefined();
     }
@@ -208,7 +221,7 @@ describe('active-port persistence', () => {
 
   it('rejects out-of-range or non-integer persisted ports', async () => {
     const mod = await importRefCache();
-    const { writeFile, mkdir } = await import('fs/promises');
+    const { writeFile, mkdir } = await import('node:fs/promises');
     const dir = join(process.cwd(), '.monomind', 'monobrowse');
     await mkdir(dir, { recursive: true });
     for (const bad of [80, 70000, 1.5, '9222', null]) {

package/src/__tests__/session-state.test.ts

@@ -6,23 +6,21 @@
  * validation logic: the CdpClient is a stub that answers the handful of CDP
  * commands the round trip issues.
  */
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { mkdtemp, rm, readFile, stat, mkdir } from 'fs/promises';
-import { join } from 'path';
-import { tmpdir } from 'os';
+
+import { mkdir, mkdtemp, readFile, rm, stat } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import type { CdpClient } from '../browser/cdp.js';
-import {
-  saveStateFile,
-  loadStateFile,
-  saveSession,
-  loadSession,
-  listSessions,
-} from '../browser/session.js';
+import { loadSession, loadStateFile, saveSession, saveStateFile } from '../browser/session.js';
 
 const COOKIES = [{ name: 'sid', value: 'abc', domain: 'x.test', path: '/' }];
 
 /** Records every CDP command and answers the ones session.ts depends on. */
-function stubClient(): { client: CdpClient; calls: Array<{ method: string; params: unknown; sid?: string }> } {
+function stubClient(): {
+  client: CdpClient;
+  calls: Array<{ method: string; params: unknown; sid?: string }>;
+} {
   const calls: Array<{ method: string; params: unknown; sid?: string }> = [];
   const client = {
     send: vi.fn(async (method: string, params: unknown, sid?: string) => {
@@ -30,8 +28,10 @@ function stubClient(): { client: CdpClient; calls: Array<{ method: string; param
       if (method === 'Network.getCookies') return { cookies: COOKIES };
       if (method === 'Runtime.evaluate') {
         const expr = (params as { expression: string }).expression;
-        if (expr.includes('Object.entries(localStorage)')) return { result: { value: '{"k":"v"}' } };
-        if (expr.includes('Object.entries(sessionStorage)')) return { result: { value: '{"s":"1"}' } };
+        if (expr.includes('Object.entries(localStorage)'))
+          return { result: { value: '{"k":"v"}' } };
+        if (expr.includes('Object.entries(sessionStorage)'))
+          return { result: { value: '{"s":"1"}' } };
       }
       return {};
     }),
@@ -69,7 +69,7 @@ describe('validateSessionName (via saveSession/loadSession)', () => {
   for (const [label, name] of bad) {
     it(`rejects ${label}`, async () => {
       await expect(saveSession(client, 'S1', 'T1', name, 'https://x.test', 'T')).rejects.toThrow(
-        /Invalid session name/
+        /Invalid session name/,
       );
       await expect(loadSession(client, 'S1', name)).rejects.toThrow(/Invalid session name/);
     });
@@ -77,7 +77,7 @@ describe('validateSessionName (via saveSession/loadSession)', () => {
 
   it('accepts an ordinary name (fails later, on the missing file, not on validation)', async () => {
     await expect(loadSession(client, 'S1', 'no-such-session-xyz')).rejects.toThrow(
-      'Session not found: no-such-session-xyz'
+      'Session not found: no-such-session-xyz',
     );
   });
 
@@ -103,7 +103,7 @@ describe('validateFilePath (via saveStateFile/loadStateFile)', () => {
   for (const [label, filePath] of bad) {
     it(`rejects ${label}`, async () => {
       await expect(
-        saveStateFile(client, 'S1', 'T1', filePath, 'https://x.test', 'T')
+        saveStateFile(client, 'S1', 'T1', filePath, 'https://x.test', 'T'),
       ).rejects.toThrow(/Invalid file path/);
       await expect(loadStateFile(client, 'S1', filePath)).rejects.toThrow(/Invalid file path/);
     });
@@ -111,7 +111,9 @@ describe('validateFilePath (via saveStateFile/loadStateFile)', () => {
 
   it('allows a plain absolute path', async () => {
     const p = join(dir, 'state.json');
-    await expect(saveStateFile(client, 'S1', 'T1', p, 'https://x.test', 'T')).resolves.toBeUndefined();
+    await expect(
+      saveStateFile(client, 'S1', 'T1', p, 'https://x.test', 'T'),
+    ).resolves.toBeUndefined();
   });
 });
 
@@ -164,38 +166,41 @@ describe('state file round trip', () => {
   it('rejects a state file whose cookies field is not an array', async () => {
     const { client } = stubClient();
     const p = join(dir, 'bad.json');
-    const { writeFile } = await import('fs/promises');
+    const { writeFile } = await import('node:fs/promises');
     await writeFile(p, JSON.stringify({ cookies: { name: 'sid' } }));
     await expect(loadStateFile(client, 'S1', p)).rejects.toThrow(
-      'Invalid state file: cookies is not an array'
+      'Invalid state file: cookies is not an array',
     );
   });
 
   it('rejects a state file whose localStorage is an array rather than an object', async () => {
     const { client } = stubClient();
     const p = join(dir, 'bad2.json');
-    const { writeFile } = await import('fs/promises');
+    const { writeFile } = await import('node:fs/promises');
     await writeFile(p, JSON.stringify({ cookies: [], localStorage: ['nope'] }));
     await expect(loadStateFile(client, 'S1', p)).rejects.toThrow(
-      'Invalid state file: localStorage is not a plain object'
+      'Invalid state file: localStorage is not a plain object',
     );
   });
 
   it('rejects a state file whose sessionStorage is an array', async () => {
     const { client } = stubClient();
     const p = join(dir, 'bad3.json');
-    const { writeFile } = await import('fs/promises');
+    const { writeFile } = await import('node:fs/promises');
     await writeFile(p, JSON.stringify({ cookies: [], sessionStorage: ['nope'] }));
     await expect(loadStateFile(client, 'S1', p)).rejects.toThrow(
-      'Invalid state file: sessionStorage is not a plain object'
+      'Invalid state file: sessionStorage is not a plain object',
     );
   });
 
   it('accepts a state file with neither storage map present', async () => {
     const { client, calls } = stubClient();
     const p = join(dir, 'minimal.json');
-    const { writeFile } = await import('fs/promises');
-    await writeFile(p, JSON.stringify({ targetId: 'T', sessionId: 'S', url: '', title: '', cookies: [] }));
+    const { writeFile } = await import('node:fs/promises');
+    await writeFile(
+      p,
+      JSON.stringify({ targetId: 'T', sessionId: 'S', url: '', title: '', cookies: [] }),
+    );
     await expect(loadStateFile(client, 'S1', p)).resolves.toMatchObject({ cookies: [] });
     expect(calls.filter((c) => c.method === 'Runtime.evaluate')).toEqual([]);
   });
@@ -224,7 +229,7 @@ describe('listSessions', () => {
   it('lists only .json files, with the extension stripped', async () => {
     const sessionDir = join(dir, '.monomind', 'browser-sessions');
     await mkdir(sessionDir, { recursive: true });
-    const { writeFile } = await import('fs/promises');
+    const { writeFile } = await import('node:fs/promises');
     await writeFile(join(sessionDir, 'alpha.json'), '{}');
     await writeFile(join(sessionDir, 'beta.json'), '{}');
     await writeFile(join(sessionDir, 'notes.txt'), 'ignore me');
@@ -236,7 +241,14 @@ describe('listSessions', () => {
   it('saveSession writes into the session dir and loadSession reads it back', async () => {
     const mod = await withHome(dir);
     const saver = stubClient();
-    const filePath = await mod.saveSession(saver.client, 'S1', 'T1', 'my-session', 'https://x.test', 'T');
+    const filePath = await mod.saveSession(
+      saver.client,
+      'S1',
+      'T1',
+      'my-session',
+      'https://x.test',
+      'T',
+    );
     expect(filePath).toBe(join(dir, '.monomind', 'browser-sessions', 'my-session.json'));
     expect((await stat(filePath)).mode & 0o777).toBe(0o600);
     expect((await stat(join(dir, '.monomind', 'browser-sessions'))).mode & 0o777).toBe(0o700);