specrails-desktop 2.0.0

package/server/dist/terminal-manager.js

@@ -0,0 +1,633 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TerminalManager = exports.TERMINAL_EARLY_EXIT_MS = exports.TerminalSpawnError = exports.TerminalNameInvalidError = exports.TerminalNotFoundError = exports.TerminalLimitExceededError = exports.RingBuffer = exports.TERMINAL_DEFAULT_ROWS = exports.TERMINAL_DEFAULT_COLS = exports.TERMINAL_NAME_MAX = exports.TERMINAL_MAX_PER_PROJECT = exports.TERMINAL_KILL_GRACE_MS = exports.TERMINAL_SCROLLBACK_BYTES = void 0;
+exports.resolveShell = resolveShell;
+exports.resolveShellFor = resolveShellFor;
+exports.shellArgs = shellArgs;
+exports.mapSpawnError = mapSpawnError;
+exports.getTerminalManager = getTerminalManager;
+exports._resetTerminalManagerForTest = _resetTerminalManagerForTest;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const node_pty_1 = require("node-pty");
+const ids_1 = require("./ids");
+const terminal_osc_parser_1 = require("./terminal-osc-parser");
+const terminal_marks_store_1 = require("./terminal-marks-store");
+const terminal_shell_integration_1 = require("./terminal-shell-integration");
+exports.TERMINAL_SCROLLBACK_BYTES = 262_144;
+exports.TERMINAL_KILL_GRACE_MS = 2_000;
+exports.TERMINAL_MAX_PER_PROJECT = 10;
+exports.TERMINAL_NAME_MAX = 64;
+exports.TERMINAL_DEFAULT_COLS = 80;
+exports.TERMINAL_DEFAULT_ROWS = 24;
+const WS_OPEN = 1;
+// ─── Spawn-helper permission fix ──────────────────────────────────────────────
+// node-pty's prebuilds occasionally lose the executable bit during npm extraction
+// on some systems. Best-effort chmod so the first Terminal spawn does not fail
+// with `posix_spawnp failed`.
+function ensureSpawnHelperExecutable() {
+    if (process.platform === 'win32')
+        return;
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const ptyPkgPath = require.resolve('node-pty/package.json');
+        const ptyPkgDir = path_1.default.dirname(ptyPkgPath);
+        const arch = process.arch === 'arm64' ? 'arm64' : process.arch === 'x64' ? 'x64' : process.arch;
+        const platform = process.platform;
+        const helperPath = path_1.default.join(ptyPkgDir, 'prebuilds', `${platform}-${arch}`, 'spawn-helper');
+        if (fs_1.default.existsSync(helperPath)) {
+            const stat = fs_1.default.statSync(helperPath);
+            if ((stat.mode & 0o111) === 0) {
+                fs_1.default.chmodSync(helperPath, 0o755);
+            }
+        }
+    }
+    catch {
+        // Best effort only — if the helper is missing or unreachable, node-pty will
+        // surface a clearer error on the first spawn call.
+    }
+}
+ensureSpawnHelperExecutable();
+// ─── Shell resolution ─────────────────────────────────────────────────────────
+function resolveShell() {
+    return resolveShellFor(process.platform, process.env, (p) => { try {
+        return fs_1.default.existsSync(p);
+    }
+    catch {
+        return false;
+    } });
+}
+/**
+ * Pure, injectable shell resolver (testable on any platform).
+ * Order: explicit `$SHELL` → platform default.
+ * On Windows the default prefers PowerShell over cmd.exe: PowerShell 7 (`pwsh.exe`
+ * on PATH) → Windows PowerShell (`powershell.exe`, always present on Win10/11 at a
+ * known absolute path) → `COMSPEC`/cmd.exe as a last resort. cmd.exe is a poor
+ * default and has no shell-integration shim.
+ */
+function resolveShellFor(platform, env, exists) {
+    const envShell = env.SHELL;
+    if (envShell && envShell.trim().length > 0)
+        return envShell.trim();
+    if (platform === 'win32') {
+        for (const dir of (env.PATH ?? '').split(';')) {
+            if (!dir)
+                continue;
+            const pwsh = `${dir.replace(/[\\/]$/, '')}\\pwsh.exe`;
+            if (exists(pwsh))
+                return pwsh;
+        }
+        const sysRoot = (env.SystemRoot || env.windir || 'C:\\Windows').replace(/[\\/]$/, '');
+        const winPosh = `${sysRoot}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe`;
+        if (exists(winPosh))
+            return winPosh;
+        return env.COMSPEC || 'cmd.exe';
+    }
+    return '/bin/zsh';
+}
+function shellArgs(shell) {
+    // Normalize so Windows paths (C:\foo\bar.exe) work even when running cross-platform tests.
+    const normalized = shell.replace(/\\/g, '/');
+    const base = path_1.default.posix.basename(normalized).toLowerCase();
+    if (base === 'zsh' || base === 'bash')
+        return ['-l', '-i'];
+    if (base === 'fish')
+        return ['-i'];
+    if (base === 'powershell.exe' || base === 'pwsh' || base === 'pwsh.exe' || base === 'powershell')
+        return ['-NoLogo'];
+    if (base === 'cmd.exe' || base === 'cmd')
+        return [];
+    return ['-i'];
+}
+// ─── Ring buffer ──────────────────────────────────────────────────────────────
+class RingBuffer {
+    capacity;
+    chunks = [];
+    total = 0;
+    constructor(capacity) {
+        this.capacity = capacity;
+    }
+    append(chunk) {
+        if (chunk.length === 0)
+            return;
+        this.chunks.push(chunk);
+        this.total += chunk.length;
+        // Drop whole chunks from the front until we fit (except the last, which we trim)
+        while (this.total > this.capacity && this.chunks.length > 1) {
+            const drop = this.chunks.shift();
+            this.total -= drop.length;
+        }
+        if (this.total > this.capacity && this.chunks.length === 1) {
+            const head = this.chunks[0];
+            const excess = this.total - this.capacity;
+            this.chunks[0] = head.subarray(excess);
+            this.total = this.chunks[0].length;
+        }
+    }
+    snapshot() {
+        if (this.total === 0)
+            return Buffer.alloc(0);
+        return Buffer.concat(this.chunks, this.total);
+    }
+    size() { return this.total; }
+    clear() { this.chunks = []; this.total = 0; }
+}
+exports.RingBuffer = RingBuffer;
+class TerminalLimitExceededError extends Error {
+    limit = exports.TERMINAL_MAX_PER_PROJECT;
+    constructor() { super('terminal_limit_exceeded'); this.name = 'TerminalLimitExceededError'; }
+}
+exports.TerminalLimitExceededError = TerminalLimitExceededError;
+class TerminalNotFoundError extends Error {
+    constructor() { super('terminal_not_found'); this.name = 'TerminalNotFoundError'; }
+}
+exports.TerminalNotFoundError = TerminalNotFoundError;
+class TerminalNameInvalidError extends Error {
+    constructor() { super('terminal_name_invalid'); this.name = 'TerminalNameInvalidError'; }
+}
+exports.TerminalNameInvalidError = TerminalNameInvalidError;
+/** Thrown when node-pty fails to spawn the shell (e.g. the host is out of file
+ *  descriptors). Lets the REST layer return a concrete, actionable error instead
+ *  of an opaque 500. */
+class TerminalSpawnError extends Error {
+    reason;
+    constructor(reason, detail) {
+        super(`terminal_spawn_failed:${reason}${detail ? ` (${detail})` : ''}`);
+        this.reason = reason;
+        this.name = 'TerminalSpawnError';
+    }
+}
+exports.TerminalSpawnError = TerminalSpawnError;
+/** Map a node-pty spawn exception to a typed TerminalSpawnError. EMFILE/ENFILE
+ *  (the host is out of file descriptors — the failure mode that broke terminals
+ *  under the chokidar fd leak) get a distinct reason the client can act on. */
+function mapSpawnError(err) {
+    const e = err;
+    if (e?.code === 'EMFILE' || e?.code === 'ENFILE') {
+        return new TerminalSpawnError('out-of-file-descriptors', e.message);
+    }
+    return new TerminalSpawnError('spawn-failed', e?.message ?? String(err));
+}
+/** A session that exits within this window of being created is treated as an
+ *  "early exit" (probable failed spawn — e.g. no controlling tty under fd
+ *  pressure) so the client can surface a clear failure instead of a blank pane. */
+exports.TERMINAL_EARLY_EXIT_MS = 1_500;
+const TOMBSTONE_TTL_MS = 30_000;
+// ─── Manager ──────────────────────────────────────────────────────────────────
+class TerminalManager {
+    sessions = new Map();
+    byProject = new Map();
+    tombstones = new Map();
+    tombstoneTimers = new Map();
+    listForProject(projectId) {
+        const set = this.byProject.get(projectId);
+        if (!set)
+            return [];
+        const out = [];
+        for (const id of set) {
+            const s = this.sessions.get(id);
+            if (s)
+                out.push(this.toMeta(s));
+        }
+        return out.sort((a, b) => a.createdAt - b.createdAt);
+    }
+    /** Scoped lookup: returns session only if both id AND projectId match. */
+    get(projectId, sessionId) {
+        const s = this.sessions.get(sessionId);
+        if (!s)
+            return undefined;
+        if (s.projectId !== projectId)
+            return undefined;
+        return s;
+    }
+    /** Unscoped lookup — used by the WS upgrade handler to validate cross-project access. */
+    getUnsafe(sessionId) {
+        return this.sessions.get(sessionId);
+    }
+    create(projectId, opts) {
+        const currentCount = this.byProject.get(projectId)?.size ?? 0;
+        if (currentCount >= exports.TERMINAL_MAX_PER_PROJECT)
+            throw new TerminalLimitExceededError();
+        const shell = resolveShell();
+        const baseArgs = shellArgs(shell);
+        const cols = clampDim(opts.cols ?? exports.TERMINAL_DEFAULT_COLS, 2, 1000);
+        const rows = clampDim(opts.rows ?? exports.TERMINAL_DEFAULT_ROWS, 2, 1000);
+        const env = {};
+        for (const [k, v] of Object.entries(process.env)) {
+            if (typeof v === 'string')
+                env[k] = v;
+        }
+        env.TERM = 'xterm-256color';
+        env.COLORTERM = 'truecolor';
+        const id = (0, ids_1.newId)();
+        const projectSlug = opts.projectSlug ?? projectId;
+        // Shell-integration: compose extra args/env when the resolved settings allow it.
+        const shellIntegration = (0, terminal_shell_integration_1.composeShellIntegrationSpawn)(shell, id, projectSlug, opts.settings ?? { shellIntegrationEnabled: false });
+        for (const [k, v] of Object.entries(shellIntegration.env))
+            env[k] = v;
+        const args = shellIntegration.args.length > 0
+            ? [...shellIntegration.args, ...baseArgs]
+            : baseArgs;
+        let pty;
+        try {
+            pty = (0, node_pty_1.spawn)(shell, args, {
+                cwd: opts.cwd,
+                cols, rows,
+                env,
+                name: 'xterm-256color',
+            });
+        }
+        catch (err) {
+            throw mapSpawnError(err);
+        }
+        const name = validateName(opts.name) ?? this.autoName(projectId, shell);
+        const session = {
+            id, projectId, name, shell, cwd: opts.cwd, cols, rows,
+            createdAt: Date.now(),
+            pty, buffer: new RingBuffer(exports.TERMINAL_SCROLLBACK_BYTES),
+            clients: new Set(),
+            exited: false,
+            oscParser: shellIntegration.shimPath ? new terminal_osc_parser_1.OscParser() : null,
+            currentCwd: null,
+            projectSlug,
+            projectDb: opts.projectDb ?? null,
+            shellIntegration,
+        };
+        pty.onData((chunk) => {
+            const buf = Buffer.from(chunk, 'utf8');
+            session.buffer.append(buf);
+            // Forward bytes to attached clients (binary, untouched).
+            for (const ws of session.clients) {
+                if (ws.readyState === WS_OPEN) {
+                    try {
+                        ws.send(buf, { binary: true });
+                    }
+                    catch { /* ignore */ }
+                }
+            }
+            // Then optionally parse for OSC marks and broadcast structured frames.
+            if (session.oscParser) {
+                const events = session.oscParser.feed(buf);
+                if (events.length > 0)
+                    this.handleMarkEvents(session, events);
+            }
+        });
+        pty.onExit((e) => {
+            session.exited = true;
+            const now = Date.now();
+            const early = now - session.createdAt < exports.TERMINAL_EARLY_EXIT_MS;
+            // Any open mark gets recorded as killed.
+            if (session.projectDb) {
+                try {
+                    (0, terminal_marks_store_1.markOpenAsKilled)(session.projectDb, session.id, now);
+                }
+                catch { /* ignore */ }
+            }
+            // Record a tombstone unless this is a deliberate kill (killSession removes
+            // the session from the registry first, so `!this.sessions.has` distinguishes
+            // an unexpected pty death from an intentional kill).
+            if (this.sessions.has(session.id)) {
+                this.recordTombstone(session.id, session.projectId, e?.exitCode ?? null, e?.signal ?? null, early);
+                // Tell attached clients WHY the session ended before closing the socket,
+                // so the UI shows a reason instead of a silent black pane.
+                const frame = JSON.stringify({ type: 'exit', code: e?.exitCode ?? null, signal: e?.signal ?? null, early });
+                for (const ws of session.clients) {
+                    if (ws.readyState === WS_OPEN) {
+                        try {
+                            ws.send(frame);
+                        }
+                        catch { /* ignore */ }
+                    }
+                }
+            }
+            for (const ws of session.clients) {
+                try {
+                    ws.close(1000, early ? 'pty_exit_early' : 'pty_exit');
+                }
+                catch { /* ignore */ }
+            }
+            (0, terminal_shell_integration_1.cleanupSessionShim)(session.projectSlug, session.id);
+            this.removeFromRegistry(session);
+        });
+        this.sessions.set(id, session);
+        let set = this.byProject.get(projectId);
+        if (!set) {
+            set = new Set();
+            this.byProject.set(projectId, set);
+        }
+        set.add(id);
+        return this.toMeta(session);
+    }
+    /**
+     * Attach a WebSocket to the session: sends snapshot + ready frame, then wires live output.
+     * Caller is responsible for having verified projectId scope.
+     */
+    attach(sessionId, ws) {
+        const s = this.sessions.get(sessionId);
+        if (!s || s.exited)
+            return null;
+        try {
+            const snapshot = s.buffer.snapshot();
+            if (snapshot.length > 0)
+                ws.send(snapshot, { binary: true });
+            ws.send(JSON.stringify({ type: 'ready', id: s.id, name: s.name, cols: s.cols, rows: s.rows }));
+        }
+        catch {
+            return null;
+        }
+        s.clients.add(ws);
+        return this.toMeta(s);
+    }
+    detach(sessionId, ws) {
+        const s = this.sessions.get(sessionId);
+        if (!s)
+            return;
+        s.clients.delete(ws);
+    }
+    /** Returns the tombstone for a recently-exited session, scoped to projectId,
+     *  or undefined. Used by the WS upgrade/attach path to report why a session a
+     *  client is trying to reach has already gone. */
+    getTombstone(sessionId, projectId) {
+        const t = this.tombstones.get(sessionId);
+        if (!t || t.projectId !== projectId)
+            return undefined;
+        return t;
+    }
+    recordTombstone(sessionId, projectId, code, signal, early) {
+        this.tombstones.set(sessionId, { projectId, exitedAt: Date.now(), code, signal, early });
+        const prev = this.tombstoneTimers.get(sessionId);
+        if (prev)
+            clearTimeout(prev);
+        const timer = setTimeout(() => {
+            this.tombstones.delete(sessionId);
+            this.tombstoneTimers.delete(sessionId);
+        }, TOMBSTONE_TTL_MS);
+        // Don't keep the event loop alive solely for tombstone eviction.
+        if (typeof timer.unref === 'function')
+            timer.unref();
+        this.tombstoneTimers.set(sessionId, timer);
+    }
+    write(sessionId, data) {
+        const s = this.sessions.get(sessionId);
+        if (!s || s.exited)
+            return;
+        const str = typeof data === 'string' ? data : data.toString('utf8');
+        try {
+            s.pty.write(str);
+        }
+        catch { /* pty may have died between checks */ }
+    }
+    resize(sessionId, cols, rows) {
+        const s = this.sessions.get(sessionId);
+        if (!s || s.exited)
+            return;
+        const c = clampDim(cols, 2, 1000);
+        const r = clampDim(rows, 2, 1000);
+        try {
+            s.pty.resize(c, r);
+        }
+        catch { /* ignore */ }
+        s.cols = c;
+        s.rows = r;
+    }
+    rename(projectId, sessionId, name) {
+        const s = this.get(projectId, sessionId);
+        if (!s)
+            throw new TerminalNotFoundError();
+        const validated = validateName(name);
+        if (!validated)
+            throw new TerminalNameInvalidError();
+        s.name = validated;
+        const msg = JSON.stringify({ type: 'renamed', id: s.id, name: s.name });
+        for (const ws of s.clients) {
+            if (ws.readyState === WS_OPEN) {
+                try {
+                    ws.send(msg);
+                }
+                catch { /* ignore */ }
+            }
+        }
+        return this.toMeta(s);
+    }
+    kill(projectId, sessionId) {
+        const s = this.get(projectId, sessionId);
+        if (!s)
+            return false;
+        this.killSession(s);
+        return true;
+    }
+    killAllForProject(projectId) {
+        const set = this.byProject.get(projectId);
+        if (!set)
+            return 0;
+        const ids = Array.from(set);
+        let killed = 0;
+        for (const id of ids) {
+            const s = this.sessions.get(id);
+            if (s) {
+                this.killSession(s);
+                killed++;
+            }
+        }
+        return killed;
+    }
+    async shutdown() {
+        const all = Array.from(this.sessions.values());
+        for (const s of all) {
+            try {
+                s.pty.kill('SIGTERM');
+            }
+            catch { /* ignore */ }
+        }
+        await new Promise((r) => setTimeout(r, exports.TERMINAL_KILL_GRACE_MS));
+        for (const s of Array.from(this.sessions.values())) {
+            try {
+                s.pty.kill('SIGKILL');
+            }
+            catch { /* ignore */ }
+            this.removeFromRegistry(s);
+        }
+        for (const timer of this.tombstoneTimers.values())
+            clearTimeout(timer);
+        this.tombstoneTimers.clear();
+        this.tombstones.clear();
+    }
+    sessionCount() { return this.sessions.size; }
+    // ─── Private ────────────────────────────────────────────────────────────────
+    /**
+     * Process an OSC parser event: persist command marks where appropriate and
+     * broadcast a JSON control frame `{type:"mark",kind,...}` on every attached
+     * WebSocket. Bytes are forwarded to xterm separately.
+     */
+    handleMarkEvents(session, events) {
+        const ts = Date.now();
+        for (const ev of events) {
+            // Persist where applicable.
+            if (session.projectDb) {
+                try {
+                    if (ev.kind === 'pre-exec') {
+                        // Open a new mark; if a previous one is still open (no D before next C),
+                        // close it as killed-by-prompt.
+                        const dangling = (0, terminal_marks_store_1.getOpenMark)(session.projectDb, session.id);
+                        if (dangling) {
+                            (0, terminal_marks_store_1.closeOpenMark)(session.projectDb, session.id, ts, null, null, session.currentCwd ?? null);
+                        }
+                        (0, terminal_marks_store_1.appendMark)(session.projectDb, {
+                            sessionId: session.id,
+                            startedAt: ts,
+                            cwd: session.currentCwd ?? null,
+                        });
+                    }
+                    else if (ev.kind === 'post-exec') {
+                        (0, terminal_marks_store_1.closeOpenMark)(session.projectDb, session.id, ts, ev.exitCode ?? null, null, session.currentCwd ?? null);
+                    }
+                    else if (ev.kind === 'cwd') {
+                        session.currentCwd = ev.payload ?? null;
+                    }
+                }
+                catch { /* persistence is best-effort */ }
+            }
+            else if (ev.kind === 'cwd') {
+                session.currentCwd = ev.payload ?? null;
+            }
+            // Broadcast control frame.
+            const payload = { type: 'mark', kind: ev.kind, ts };
+            if (ev.exitCode !== undefined)
+                payload.payload = { exitCode: ev.exitCode };
+            if (ev.kind === 'cwd' && ev.payload)
+                payload.payload = { path: ev.payload };
+            const json = JSON.stringify(payload);
+            for (const ws of session.clients) {
+                if (ws.readyState === WS_OPEN) {
+                    try {
+                        ws.send(json);
+                    }
+                    catch { /* ignore */ }
+                }
+            }
+        }
+    }
+    /**
+     * Kill semantics: remove the session from the public registry immediately so
+     * subsequent lookups (REST, WS attach) return 404, then SIGTERM in the
+     * background, then SIGKILL after a grace period if needed. The onExit handler
+     * installed at creation becomes a no-op for already-removed sessions.
+     */
+    killSession(s) {
+        // Idempotent: if already removed from registry, skip.
+        if (!this.sessions.has(s.id))
+            return;
+        this.detachFromRegistry(s);
+        if (!s.exited) {
+            try {
+                s.pty.kill('SIGTERM');
+            }
+            catch { /* ignore */ }
+            s.killTimer = setTimeout(() => {
+                if (!s.exited) {
+                    try {
+                        s.pty.kill('SIGKILL');
+                    }
+                    catch { /* ignore */ }
+                }
+            }, exports.TERMINAL_KILL_GRACE_MS);
+        }
+        // Close any open command mark with the session's death timestamp.
+        if (s.projectDb) {
+            try {
+                (0, terminal_marks_store_1.markOpenAsKilled)(s.projectDb, s.id, Date.now());
+            }
+            catch { /* ignore */ }
+        }
+        (0, terminal_shell_integration_1.cleanupSessionShim)(s.projectSlug, s.id);
+        // Close clients so the WS upgrade handlers detach cleanly
+        for (const ws of s.clients) {
+            try {
+                ws.close(1000, 'session_closed');
+            }
+            catch { /* ignore */ }
+        }
+        s.clients.clear();
+        s.buffer.clear();
+    }
+    detachFromRegistry(s) {
+        this.sessions.delete(s.id);
+        const set = this.byProject.get(s.projectId);
+        if (set) {
+            set.delete(s.id);
+            if (set.size === 0)
+                this.byProject.delete(s.projectId);
+        }
+    }
+    removeFromRegistry(s) {
+        if (s.killTimer) {
+            clearTimeout(s.killTimer);
+            s.killTimer = undefined;
+        }
+        this.detachFromRegistry(s);
+        for (const ws of s.clients) {
+            try {
+                ws.close(1000, 'session_closed');
+            }
+            catch { /* ignore */ }
+        }
+        s.clients.clear();
+        s.buffer.clear();
+    }
+    autoName(projectId, shell) {
+        const base = path_1.default.basename(shell);
+        const metas = this.listForProject(projectId);
+        const matching = metas.filter((m) => m.name === base || m.name.startsWith(base + ' ('));
+        if (matching.length === 0)
+            return base;
+        return `${base} (${matching.length + 1})`;
+    }
+    toMeta(s) {
+        return {
+            id: s.id, projectId: s.projectId, name: s.name, shell: s.shell,
+            cwd: s.cwd, cols: s.cols, rows: s.rows, createdAt: s.createdAt,
+        };
+    }
+}
+exports.TerminalManager = TerminalManager;
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+function clampDim(n, lo, hi) {
+    if (!Number.isFinite(n))
+        return lo;
+    const v = Math.trunc(n);
+    if (v < lo)
+        return lo;
+    if (v > hi)
+        return hi;
+    return v;
+}
+function validateName(name) {
+    if (typeof name !== 'string')
+        return null;
+    const trimmed = name.trim();
+    if (trimmed.length < 1 || trimmed.length > exports.TERMINAL_NAME_MAX)
+        return null;
+    return trimmed;
+}
+// ─── Singleton ────────────────────────────────────────────────────────────────
+let _instance = null;
+/**
+ * Returns the process-wide TerminalManager. Lazy-initialised so that test suites
+ * that don't touch terminals pay no cost.
+ */
+function getTerminalManager() {
+    if (!_instance)
+        _instance = new TerminalManager();
+    return _instance;
+}
+/** Reset the singleton. Tests only. */
+function _resetTerminalManagerForTest() {
+    if (_instance) {
+        // Best-effort sync cleanup — tests call this in beforeEach
+        void _instance.shutdown();
+    }
+    _instance = null;
+}