team 0.0.1 → 0.1.1

package/dist/watch/dialect.js

@@ -0,0 +1,430 @@
+// The regex dialect both engines share. The loader rewrites the shorthand classes
+// before compiling, so a pattern means the same thing under JavaScript's `u` flag
+// and under Rust's Unicode mode. The shape rules are what bound a single pattern:
+// JavaScript cannot interrupt a RegExp that is already running.
+const MAX_PATTERN = 200;
+const MAX_QUANTIFIER = 1000;
+// JavaScript's `\s`, ASCII and the Unicode spaces it has matched since ES2019.
+// U+180E is not among them. The set is fixed so the rewrite does not depend on
+// which flag the host gives `\s`.
+const WS_CODEPOINTS = [
+    0x0009, 0x000a, 0x000b, 0x000c, 0x000d, 0x0020, 0x00a0, 0x1680,
+    0x2000, 0x2001, 0x2002, 0x2003, 0x2004, 0x2005, 0x2006, 0x2007, 0x2008, 0x2009, 0x200a,
+    0x2028, 0x2029, 0x202f, 0x205f, 0x3000, 0xfeff,
+];
+const DIGITS = range(0x30, 0x39);
+const WORD = [...range(0x30, 0x39), ...range(0x41, 0x5a), ...range(0x61, 0x7a), 0x5f];
+export class DialectError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'DialectError';
+    }
+}
+/** Compile one pattern. `ignoreCase` is the stage's flag, never an inline `(?i)`. */
+export function compilePattern(source, ignoreCase = false) {
+    if (source.length === 0)
+        throw new DialectError('a pattern is empty');
+    if (source.length > MAX_PATTERN)
+        throw new DialectError(`a pattern is longer than ${MAX_PATTERN} characters`);
+    refuseSpelling(source);
+    const parser = new Parser(source);
+    const body = parser.parseAlt();
+    if (!parser.done())
+        throw new DialectError('a pattern has an extra ")"');
+    const flags = ignoreCase ? 'iu' : 'u';
+    return new RegExp(body.source, flags);
+}
+class Parser {
+    at = 0;
+    source;
+    constructor(source) {
+        this.source = source;
+    }
+    done() {
+        return this.at >= this.source.length;
+    }
+    parseAlt() {
+        const branches = [this.parseSeq()];
+        while (this.eat('|'))
+            branches.push(this.parseSeq());
+        return {
+            source: branches.map((branch) => seqSource(branch)).join('|'),
+            min: 1,
+            max: 1,
+            literal: false,
+            group: branches.length > 1,
+            branches,
+        };
+    }
+    parseSeq() {
+        const atoms = [];
+        while (!this.done() && this.peek() !== '|' && this.peek() !== ')')
+            atoms.push(this.parseAtom());
+        return atoms;
+    }
+    parseAtom() {
+        const piece = this.parsePiece();
+        const quant = this.parseQuantifier();
+        if (!quant)
+            return piece;
+        if (piece.group && quant.unbounded)
+            this.checkRepeatedGroup(piece);
+        return {
+            source: piece.source + quant.source,
+            min: quant.min,
+            max: quant.max,
+            literal: false,
+            group: piece.group,
+            branches: piece.branches,
+        };
+    }
+    // A group under `*`, `+` or `{n,}` whose first atom is optional or itself repeated
+    // backtracks badly. Alternation is allowed only when every branch opens on a literal.
+    checkRepeatedGroup(group) {
+        if (group.branches.length > 1) {
+            for (const branch of group.branches) {
+                const first = branch[0];
+                if (!first?.literal)
+                    throw new DialectError('a repeated alternation must open every branch with a literal');
+            }
+            return;
+        }
+        if (risky(group.branches[0]?.[0]))
+            throw new DialectError('a repeated group starts with an optional or repeated atom');
+    }
+    parsePiece() {
+        const ch = this.peek();
+        if (ch === undefined || ch === '|' || ch === ')' || ch === '*' || ch === '+' || ch === '?' || ch === '{') {
+            throw new DialectError('a quantifier needs something to repeat');
+        }
+        if (ch === '(')
+            return this.parseGroup();
+        if (ch === '[')
+            return this.leaf(this.parseClass(), false);
+        if (ch === '^' || ch === '$') {
+            this.at++;
+            return this.leaf(ch, false);
+        }
+        if (ch === '.') {
+            this.at++;
+            return this.leaf('.', false);
+        }
+        if (ch === '\\')
+            return this.parseEscape();
+        if (ch === ')')
+            throw new DialectError('a pattern has an extra ")"');
+        const cp = this.readCodePoint();
+        return this.leaf(escapeLiteral(cp), true);
+    }
+    parseGroup() {
+        this.expect('(');
+        if (this.peek() !== '?') {
+            const body = this.parseAlt();
+            this.expect(')');
+            return { ...body, source: `(${body.source})`, group: true, literal: false };
+        }
+        this.expect('?');
+        if (this.peek() === ':') {
+            this.expect(':');
+            const body = this.parseAlt();
+            this.expect(')');
+            return { ...body, source: `(?:${body.source})`, group: true, literal: false };
+        }
+        throw new DialectError('lookaround, named groups and inline flags are not allowed');
+    }
+    parseQuantifier() {
+        const ch = this.peek();
+        if (ch !== '*' && ch !== '+' && ch !== '?' && ch !== '{')
+            return null;
+        this.at++;
+        let min;
+        let max;
+        let text;
+        let unbounded;
+        if (ch === '*') {
+            min = 0;
+            max = Infinity;
+            text = '*';
+            unbounded = true;
+        }
+        else if (ch === '+') {
+            min = 1;
+            max = Infinity;
+            text = '+';
+            unbounded = true;
+        }
+        else if (ch === '?') {
+            min = 0;
+            max = 1;
+            text = '?';
+            unbounded = false;
+        }
+        else {
+            const count = this.readCount();
+            min = count.min;
+            max = count.max;
+            text = count.text;
+            unbounded = count.max === Infinity;
+        }
+        if (this.peek() === '?') {
+            this.at++;
+            text += '?';
+        }
+        return { source: text, min, max, unbounded };
+    }
+    readCount() {
+        const start = this.at;
+        const first = this.readNumber();
+        if (first === null)
+            throw new DialectError('a "{ }" quantifier needs a number');
+        if (this.eat(',')) {
+            const second = this.readNumber();
+            this.expect('}');
+            if (second === null)
+                return { min: first, max: Infinity, text: this.source.slice(start - 1, this.at) };
+            if (second < first)
+                throw new DialectError('a "{n,m}" quantifier has m below n');
+            return { min: first, max: second, text: this.source.slice(start - 1, this.at) };
+        }
+        this.expect('}');
+        return { min: first, max: first, text: this.source.slice(start - 1, this.at) };
+    }
+    readNumber() {
+        const start = this.at;
+        while (this.peek() !== undefined && this.peek() >= '0' && this.peek() <= '9')
+            this.at++;
+        if (this.at === start)
+            return null;
+        const n = Number(this.source.slice(start, this.at));
+        if (n > MAX_QUANTIFIER)
+            throw new DialectError(`a quantifier is above ${MAX_QUANTIFIER}`);
+        return n;
+    }
+    parseClass() {
+        this.expect('[');
+        const negated = this.eat('^');
+        const parts = [];
+        let first = true;
+        while (!this.done() && (this.peek() !== ']' || first)) {
+            first = false;
+            if (this.peek() === '\\')
+                parts.push(this.parseClassEscape());
+            else
+                parts.push({ kind: 'char', cp: this.readCodePoint() });
+        }
+        this.expect(']');
+        return classSource(negated, foldRanges(parts));
+    }
+    parseClassEscape() {
+        this.expect('\\');
+        const ch = this.peek();
+        if (ch === undefined)
+            throw new DialectError('a pattern ends with "\\"');
+        this.at++;
+        const shorthand = shorthandSet(ch);
+        if (shorthand)
+            return shorthand;
+        const cp = simpleEscape(ch);
+        if (cp === null)
+            throw new DialectError(`an unsupported escape "\\${ch}"`);
+        return { kind: 'char', cp };
+    }
+    parseEscape() {
+        this.expect('\\');
+        const ch = this.peek();
+        if (ch === undefined)
+            throw new DialectError('a pattern ends with "\\"');
+        this.at++;
+        if (ch >= '1' && ch <= '9')
+            throw new DialectError('backreferences are not allowed');
+        if (ch === 'b')
+            return this.leaf('\\b', false);
+        const shorthand = shorthandSet(ch);
+        if (shorthand?.kind === 'chars')
+            return this.leaf(emitClass(false, shorthand.cps), false);
+        if (shorthand?.kind === 'not')
+            return this.leaf(emitClass(true, shorthand.cps), false);
+        const cp = simpleEscape(ch);
+        if (cp === null)
+            throw new DialectError(`an unsupported escape "\\${ch}"`);
+        return this.leaf(escapeLiteral(cp), true);
+    }
+    leaf(source, literal) {
+        return { source, min: 1, max: 1, literal, group: false, branches: [] };
+    }
+    peek() {
+        return this.source[this.at];
+    }
+    eat(ch) {
+        if (this.peek() !== ch)
+            return false;
+        this.at++;
+        return true;
+    }
+    expect(ch) {
+        if (!this.eat(ch))
+            throw new DialectError(`expected "${ch}"`);
+    }
+    readCodePoint() {
+        const cp = this.source.codePointAt(this.at);
+        if (cp === undefined)
+            throw new DialectError('a pattern ended early');
+        this.at += cp > 0xffff ? 2 : 1;
+        return cp;
+    }
+}
+function shorthandSet(ch) {
+    if (ch === 'd')
+        return { kind: 'chars', cps: DIGITS };
+    if (ch === 'w')
+        return { kind: 'chars', cps: WORD };
+    if (ch === 's')
+        return { kind: 'chars', cps: WS_CODEPOINTS };
+    if (ch === 'D')
+        return { kind: 'not', cps: DIGITS };
+    if (ch === 'W')
+        return { kind: 'not', cps: WORD };
+    if (ch === 'S')
+        return { kind: 'not', cps: WS_CODEPOINTS };
+    return null;
+}
+function simpleEscape(ch) {
+    if (ch === 'n')
+        return 0x0a;
+    if (ch === 'r')
+        return 0x0d;
+    if (ch === 't')
+        return 0x09;
+    if (ch === 'f')
+        return 0x0c;
+    if (ch === 'v')
+        return 0x0b;
+    if (ch === 'b')
+        return null;
+    if ('\\.^$|?*+()[]{}-/'.includes(ch))
+        return ch.codePointAt(0);
+    return null;
+}
+function refuseSpelling(source) {
+    for (let i = 0; i < source.length; i++) {
+        if (source[i] !== '\\')
+            continue;
+        const next = source[i + 1];
+        if (next === 'u' || next === 'U' || next === 'x')
+            throw new DialectError('a "\\u" or "\\x" escape is not allowed: write the character itself');
+        if (next === '\\')
+            i++;
+    }
+}
+// A class is a finite set, except a complement shorthand (`\S`, `\D`, `\W`), whose
+// negation brings it back to a finite set. `[^\S\n]` is the whitespace set without
+// a newline, which is what the working-line pattern relies on.
+function classSource(negated, parts) {
+    const positive = new Set();
+    const complements = [];
+    for (const part of parts) {
+        if (part.kind === 'char')
+            positive.add(part.cp);
+        else if (part.kind === 'chars')
+            for (const cp of part.cps)
+                positive.add(cp);
+        else
+            complements.push(part.cps);
+    }
+    if (complements.length === 0)
+        return emitClass(negated, [...positive]);
+    let inter = new Set(complements[0]);
+    for (const extra of complements.slice(1))
+        inter = new Set([...inter].filter((cp) => extra.includes(cp)));
+    const remaining = [...inter].filter((cp) => !positive.has(cp));
+    return emitClass(!negated, remaining);
+}
+function foldRanges(parts) {
+    const out = [];
+    for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        const next = parts[i + 1];
+        const after = parts[i + 2];
+        if (part.kind === 'char' && next?.kind === 'char' && next.cp === 0x2d && after?.kind === 'char') {
+            // A hyphen between two characters is a range. A hyphen after a shorthand stays a hyphen.
+            if (after.cp < part.cp)
+                throw new DialectError('a character range is backwards');
+            const cps = [];
+            for (let cp = part.cp; cp <= after.cp; cp++)
+                cps.push(cp);
+            out.push({ kind: 'chars', cps });
+            i += 2;
+        }
+        else
+            out.push(part);
+    }
+    return out;
+}
+function emitClass(negated, cps) {
+    const sorted = [...new Set(cps)].sort((a, b) => a - b);
+    let body = '';
+    for (let i = 0; i < sorted.length;) {
+        const start = sorted[i];
+        let end = start;
+        while (i + 1 < sorted.length && sorted[i + 1] === end + 1) {
+            i++;
+            end = sorted[i];
+        }
+        if (end - start >= 2)
+            body += classChar(start) + '-' + classChar(end);
+        else
+            for (let cp = start; cp <= end; cp++)
+                body += classChar(cp);
+        i++;
+    }
+    if (!body)
+        return negated ? '[\\s\\S]' : '[^\\s\\S]';
+    return negated ? `[^${body}]` : `[${body}]`;
+}
+function classChar(cp) {
+    if (cp === 0x09)
+        return '\\t';
+    if (cp === 0x0a)
+        return '\\n';
+    if (cp === 0x0b)
+        return '\\v';
+    if (cp === 0x0c)
+        return '\\f';
+    if (cp === 0x0d)
+        return '\\r';
+    if (cp === 0x2d || cp === 0x5d || cp === 0x5e || cp === 0x5c)
+        return `\\${String.fromCodePoint(cp)}`;
+    if (cp < 0x20 || cp > 0x7e)
+        return `\\u${cp.toString(16).padStart(4, '0')}`;
+    return String.fromCodePoint(cp);
+}
+function escapeLiteral(cp) {
+    const ch = String.fromCodePoint(cp);
+    if ('\\.^$|?*+()[]{}'.includes(ch))
+        return `\\${ch}`;
+    if (cp < 0x20 || cp > 0x7e)
+        return `\\u${cp.toString(16).padStart(4, '0')}`;
+    return ch;
+}
+function seqSource(atoms) {
+    return atoms.map((atom) => atom.source).join('');
+}
+// Optional (`?`, `*`, `{0,…}`) or repeated (`+`, `*`, `{n,}` with room for more than one).
+// A group that is itself exactly once still counts when its own first atom is.
+function risky(atom) {
+    if (!atom)
+        return true;
+    if (atom.min === 0 || atom.max > 1)
+        return true;
+    if (!atom.group)
+        return false;
+    if (atom.branches.length > 1)
+        return atom.branches.some((branch) => !branch[0]?.literal);
+    return risky(atom.branches[0]?.[0]);
+}
+function range(from, to) {
+    const out = [];
+    for (let cp = from; cp <= to; cp++)
+        out.push(cp);
+    return out;
+}

package/dist/watch/end.d.ts

@@ -0,0 +1,11 @@
+export type EndView = {
+    kind: 'result';
+    exists: boolean;
+} | {
+    kind: 'merged';
+    verdict: 'merged' | 'open' | 'unproven';
+    detail: string;
+    ownNow: number;
+};
+/** What the watch reads for one end. A missing base cannot prove a merge. */
+export declare function readEnd(root: string, until: string, base: string | null, ownBefore: boolean): EndView;

package/dist/watch/end.js

@@ -0,0 +1,17 @@
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { readMerge } from "../end/condition.js";
+/** What the watch reads for one end. A missing base cannot prove a merge. */
+export function readEnd(root, until, base, ownBefore) {
+    if (until.startsWith('result:') && until.length > 'result:'.length) {
+        return { kind: 'result', exists: existsSync(resolve(root, until.slice('result:'.length))) };
+    }
+    if (!until.startsWith('merged:') || until.length <= 'merged:'.length) {
+        return { kind: 'merged', verdict: 'unproven', ownNow: 0, detail: 'the end is not one this version reads; nothing is removed' };
+    }
+    if (!base) {
+        return { kind: 'merged', verdict: 'unproven', ownNow: 0, detail: 'workspace.base is required to read a merged end; nothing is removed' };
+    }
+    const read = readMerge(root, until.slice('merged:'.length), base, ownBefore);
+    return { kind: 'merged', verdict: read.verdict, detail: read.detail, ownNow: read.ownNow };
+}

package/dist/watch/machine.d.ts

@@ -0,0 +1,38 @@
+import type { TeamFile } from '../file/types.ts';
+export type Machine = {
+    loadPerCore: number | null;
+    memoryFree: number | null;
+    diskFree: number | null;
+    swapFree: number | null;
+    swapUsed: number | null;
+};
+export declare function parseSwapUsage(text: string): {
+    total: number;
+    used: number;
+    free: number;
+} | null;
+export declare function parseMemoryPressure(text: string): number | null;
+export declare function parseLoadavg(text: string): number | null;
+export declare function parseMeminfo(text: string): {
+    memoryFree: number | null;
+    swapFree: number | null;
+    swapUsed: number | null;
+};
+export declare function readMachine(root: string, platform?: string, proc?: string): Machine;
+/** A size as the file writes it: 1 GB is 1e9 bytes, the same spelling the watch uses. */
+export declare function gb(bytes: number): string;
+export type SwapSample = {
+    at: number;
+    used: number;
+};
+/**
+ * Records `used` and returns how far it sits above the smallest sample still inside the window.
+ * The watch and a launch share this, so a figure means the same thing in both places.
+ */
+export declare function recordSwap(samples: SwapSample[], used: number, now: number, windowSeconds: number): number;
+/**
+ * The first `machine:` start limit this reading crosses, or null. A figure that was not read
+ * (null) is neither fine nor a refusal. Swap growth uses the samples this command has already
+ * taken; one reading on its own never crosses it.
+ */
+export declare function launchLimit(machine: Machine, limits: TeamFile['machine'], samples: SwapSample[], now: number): string | null;

package/dist/watch/machine.js

@@ -0,0 +1,137 @@
+import { execFileSync } from 'node:child_process';
+import { readFileSync, statfsSync } from 'node:fs';
+import { cpus, loadavg } from 'node:os';
+function command(name, args) {
+    try {
+        return execFileSync(name, args, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 10_000 });
+    }
+    catch {
+        return null;
+    }
+}
+// "total = 24576.00M  used = 23261.25M  free = 1314.75M", as macOS's vm.swapusage prints it.
+export function parseSwapUsage(text) {
+    const read = (name) => {
+        const match = new RegExp(`${name} = ([0-9.]+)([KMG])`).exec(text);
+        if (!match)
+            return null;
+        return Number(match[1]) * { K: 1024, M: 1024 ** 2, G: 1024 ** 3 }[match[2]];
+    };
+    const total = read('total');
+    const used = read('used');
+    const free = read('free');
+    return total === null || used === null || free === null ? null : { total, used, free };
+}
+// "System-wide memory free percentage: 44%", the last line of macOS's memory_pressure.
+export function parseMemoryPressure(text) {
+    const match = /free percentage:\s*([0-9]+)%/.exec(text);
+    return match ? Number(match[1]) : null;
+}
+// "0.52 0.58 0.59 1/1234 5678", as /proc/loadavg holds it: the one-minute average first.
+export function parseLoadavg(text) {
+    const match = /^\s*([0-9]+(?:\.[0-9]+)?)\s/.exec(text);
+    return match ? Number(match[1]) : null;
+}
+// One file of a /proc tree, or null when this machine doesn't have it. `proc` is the tree's root,
+// a parameter so a test can read a captured one.
+function procFile(proc, name) {
+    try {
+        return readFileSync(`${proc}/${name}`, 'utf8');
+    }
+    catch {
+        return null;
+    }
+}
+export function parseMeminfo(text) {
+    const kb = (name) => {
+        const match = new RegExp(`^${name}:\\s+([0-9]+) kB`, 'm').exec(text);
+        return match ? Number(match[1]) * 1024 : null;
+    };
+    const total = kb('MemTotal');
+    const available = kb('MemAvailable');
+    const swapTotal = kb('SwapTotal');
+    const swapFree = kb('SwapFree');
+    return {
+        memoryFree: total && available !== null ? (available / total) * 100 : null,
+        swapFree: swapTotal ? swapFree : null,
+        swapUsed: swapTotal && swapFree !== null ? swapTotal - swapFree : null,
+    };
+}
+// This platform's figures: macOS's commands on darwin, Linux's /proc everywhere Linux runs.
+// `platform` and `proc` are parameters for the tests; the command passes neither.
+export function readMachine(root, platform = process.platform, proc = '/proc') {
+    const machine = { loadPerCore: null, memoryFree: null, diskFree: null, swapFree: null, swapUsed: null };
+    const cores = cpus().length;
+    try {
+        const volume = statfsSync(root);
+        machine.diskFree = volume.bavail * volume.bsize;
+    }
+    catch { }
+    if (platform === 'darwin') {
+        if (cores)
+            machine.loadPerCore = loadavg()[0] / cores;
+        const pressure = command('memory_pressure', []);
+        if (pressure)
+            machine.memoryFree = parseMemoryPressure(pressure);
+        const swap = parseSwapUsage(command('sysctl', ['-n', 'vm.swapusage']) ?? '');
+        if (swap && swap.total > 0) {
+            machine.swapFree = swap.free;
+            machine.swapUsed = swap.used;
+        }
+    }
+    else if (platform === 'linux') {
+        // /proc is always there, and reading it is what the platform's own tools do.
+        const load = procFile(proc, 'loadavg');
+        const one = load === null ? null : parseLoadavg(load);
+        if (cores && one !== null)
+            machine.loadPerCore = one / cores;
+        const info = procFile(proc, 'meminfo');
+        if (info !== null)
+            Object.assign(machine, parseMeminfo(info));
+    }
+    else if (cores) {
+        machine.loadPerCore = loadavg()[0] / cores;
+    }
+    return machine;
+}
+/** A size as the file writes it: 1 GB is 1e9 bytes, the same spelling the watch uses. */
+export function gb(bytes) {
+    return `${(bytes / 1e9).toFixed(1)} GB`;
+}
+/**
+ * Records `used` and returns how far it sits above the smallest sample still inside the window.
+ * The watch and a launch share this, so a figure means the same thing in both places.
+ */
+export function recordSwap(samples, used, now, windowSeconds) {
+    samples.push({ at: now, used });
+    const kept = samples.filter((sample) => now - sample.at <= windowSeconds * 1000);
+    samples.splice(0, samples.length, ...kept);
+    return used - Math.min(...kept.map((sample) => sample.used));
+}
+/**
+ * The first `machine:` start limit this reading crosses, or null. A figure that was not read
+ * (null) is neither fine nor a refusal. Swap growth uses the samples this command has already
+ * taken; one reading on its own never crosses it.
+ */
+export function launchLimit(machine, limits, samples, now) {
+    if (machine.loadPerCore !== null && machine.loadPerCore > limits.loadStart) {
+        return `the load is ${machine.loadPerCore.toFixed(1)} per core, above ${limits.loadStart}`;
+    }
+    if (machine.memoryFree !== null && machine.memoryFree < limits.memoryStart) {
+        return `free memory is ${Math.round(machine.memoryFree)}%, below ${limits.memoryStart}%`;
+    }
+    if (machine.diskFree !== null && machine.diskFree < limits.diskMin) {
+        return `free disk is ${gb(machine.diskFree)}, below ${gb(limits.diskMin)}`;
+    }
+    if (machine.swapFree !== null && machine.swapFree < limits.swapFreeMin) {
+        return `free swap is ${gb(machine.swapFree)}, below ${gb(limits.swapFreeMin)}`;
+    }
+    if (machine.swapUsed !== null) {
+        const growth = recordSwap(samples, machine.swapUsed, now, limits.swapGrowthWindow);
+        const minutes = Math.floor((limits.swapGrowthWindow * 1000) / 60_000);
+        if (growth > limits.swapGrowthMax) {
+            return `swap grew by ${gb(growth)} in ${minutes} minutes, above ${gb(limits.swapGrowthMax)}`;
+        }
+    }
+    return null;
+}

package/dist/watch/notify.d.ts

@@ -0,0 +1 @@
+export declare function notify(text: string, title?: string): void;

package/dist/watch/notify.js

@@ -0,0 +1,15 @@
+import { execFileSync } from 'node:child_process';
+import { platform } from 'node:os';
+// A desktop notification, best effort: a machine without one still has the log.
+export function notify(text, title = 'Team watch') {
+    try {
+        if (platform() === 'darwin') {
+            const quote = (value) => `"${value.replace(/[\\"]/g, '\\$&')}"`;
+            execFileSync('osascript', ['-e', `display notification ${quote(text)} with title ${quote(title)}`], { stdio: 'ignore', timeout: 5000 });
+        }
+        else {
+            execFileSync('notify-send', [title, text], { stdio: 'ignore', timeout: 5000 });
+        }
+    }
+    catch { }
+}