herdr-remote 0.2.18 → 0.2.19

package/dist/terminal-font/readers.js

@@ -0,0 +1,316 @@
+// Each terminal's own settings, read the way that terminal reads them.
+import path from 'node:path';
+import { parseBinaryPlist, unarchiveKeyed } from '../binary-plist.js';
+import { configHome, dataHome, expandHome, pointsToPx, positiveNumber, } from './deps.js';
+import { familyForPostScriptName } from './files.js';
+import { firstCssFamily, optionValue, parseFontconfigPattern, parseGVariantString, parseIni, parseJsonc, parsePangoFontDescription, parseQtFontString, parseTomlSubset, parseXFontName, xResource, xrmResources, } from './formats.js';
+function gsettingsGet(deps, schema, key) {
+    const result = deps.run('gsettings', ['get', schema, key]);
+    if (result.status !== 0)
+        return null;
+    return result.stdout.trim();
+}
+/** A GNOME-style profile: its own font, or the desktop's monospace font. */
+function readGSettingsProfileFont(deps, { schema, path: profilePath, fontKey = 'font', }) {
+    const useSystem = gsettingsGet(deps, `${schema}:${profilePath}`, 'use-system-font');
+    if (useSystem === null)
+        return null;
+    if (useSystem === 'false') {
+        const font = parsePangoFontDescription(parseGVariantString(gsettingsGet(deps, `${schema}:${profilePath}`, fontKey)));
+        if (font)
+            return font;
+    }
+    return systemMonospaceFont(deps);
+}
+function systemMonospaceFont(deps) {
+    return parsePangoFontDescription(parseGVariantString(gsettingsGet(deps, 'org.gnome.desktop.interface', 'monospace-font-name')));
+}
+export const READERS = {
+    'gnome-terminal': (deps) => {
+        const id = parseGVariantString(gsettingsGet(deps, 'org.gnome.Terminal.ProfilesList', 'default'));
+        if (!id)
+            return null;
+        return readGSettingsProfileFont(deps, {
+            schema: 'org.gnome.Terminal.Legacy.Profile',
+            path: `/org/gnome/terminal/legacy/profiles:/:${id}/`,
+        });
+    },
+    tilix: (deps) => {
+        const id = parseGVariantString(gsettingsGet(deps, 'com.gexperts.Tilix.ProfilesList', 'default'));
+        if (!id)
+            return null;
+        return readGSettingsProfileFont(deps, {
+            schema: 'com.gexperts.Tilix.Profile',
+            path: `/com/gexperts/Tilix/profiles/${id}/`,
+        });
+    },
+    ptyxis: (deps) => {
+        const useSystem = gsettingsGet(deps, 'org.gnome.Ptyxis', 'use-system-font');
+        if (useSystem === 'false') {
+            const font = parsePangoFontDescription(parseGVariantString(gsettingsGet(deps, 'org.gnome.Ptyxis', 'font-name')));
+            if (font)
+                return font;
+        }
+        return useSystem === null ? null : systemMonospaceFont(deps);
+    },
+    konsole: (deps) => {
+        const rc = parseIni(deps.readFile(path.join(configHome(deps), 'konsolerc')));
+        const profileName = rc['Desktop Entry']?.DefaultProfile;
+        if (profileName) {
+            const profile = parseIni(deps.readFile(path.join(dataHome(deps), 'konsole', profileName)));
+            const font = parseQtFontString(profile.Appearance?.Font);
+            if (font)
+                return font;
+        }
+        // Konsole's built-in profile draws with the desktop's fixed-width font.
+        const globals = parseIni(deps.readFile(path.join(configHome(deps), 'kdeglobals')));
+        return parseQtFontString(globals.General?.fixed) || { family: 'Hack', sizePx: pointsToPx(10) };
+    },
+    'xfce4-terminal': (deps) => {
+        // 1.1+ keeps its settings in xfconf; older releases in terminalrc.
+        const query = (property) => {
+            const result = deps.run('xfconf-query', ['-c', 'xfce4-terminal', '-p', property]);
+            return result.status === 0 ? result.stdout.trim() : null;
+        };
+        const rc = parseIni(deps.readFile(path.join(configHome(deps), 'xfce4', 'terminal', 'terminalrc')))
+            .Configuration || {};
+        const useSystem = (query('/font-use-system') ?? rc.FontUseSystem ?? 'false').toLowerCase() === 'true';
+        if (!useSystem) {
+            const font = parsePangoFontDescription(query('/font-name') ?? rc.FontName ?? 'Monospace 12');
+            if (font)
+                return font;
+        }
+        const result = deps.run('xfconf-query', ['-c', 'xsettings', '-p', '/Gtk/MonospaceFontName']);
+        return parsePangoFontDescription(result.status === 0 ? result.stdout.trim() : 'Monospace 10');
+    },
+    kitty: (deps) => {
+        const directory = deps.env.KITTY_CONFIG_DIRECTORY || path.join(configHome(deps), 'kitty');
+        const settings = {};
+        const visit = (file, depth) => {
+            const text = deps.readFile(file);
+            if (text === null || depth > 4)
+                return;
+            for (const rawLine of text.split(/\r?\n/)) {
+                const line = rawLine.trim();
+                if (!line || line.startsWith('#'))
+                    continue;
+                const [key, ...rest] = line.split(/\s+/);
+                const value = rest.join(' ');
+                if (key === 'include')
+                    visit(path.resolve(directory, expandHome(value, deps)), depth + 1);
+                else if (key === 'font_family' || key === 'font_size')
+                    settings[key] = value;
+            }
+        };
+        visit(path.join(directory, 'kitty.conf'), 0);
+        // kitty 0.33+ also accepts `font_family family="JetBrains Mono" style=...`.
+        const raw = settings.font_family || 'monospace';
+        const quoted = /family\s*=\s*(?:"([^"]+)"|'([^']+)'|(\S+))/.exec(raw);
+        const family = quoted ? quoted[1] || quoted[2] || quoted[3] : raw;
+        return { family, sizePx: pointsToPx(settings.font_size || 11) };
+    },
+    alacritty: (deps) => {
+        const candidates = [
+            path.join(configHome(deps), 'alacritty', 'alacritty.toml'),
+            path.join(configHome(deps), 'alacritty.toml'),
+            path.join(deps.home, '.alacritty.toml'),
+        ];
+        const merged = {};
+        const visit = (file, depth) => {
+            const text = deps.readFile(file);
+            if (text === null || depth > 4)
+                return false;
+            const values = parseTomlSubset(text);
+            // Imports come first; the importing file overrides them.
+            for (const imported of [
+                ...(values.import || []),
+                ...(values['general.import'] || []),
+            ]) {
+                visit(path.resolve(path.dirname(file), expandHome(String(imported), deps)), depth + 1);
+            }
+            Object.assign(merged, values);
+            return true;
+        };
+        candidates.some((file) => visit(file, 0));
+        const fallbackFamily = deps.platform === 'darwin' ? 'Menlo' : 'monospace';
+        return {
+            family: String(merged['font.normal.family'] || fallbackFamily),
+            sizePx: pointsToPx(merged['font.size'] || 11.25),
+        };
+    },
+    ghostty: (deps) => {
+        const settings = {
+            families: [],
+            size: undefined,
+        };
+        const visit = (file, depth) => {
+            const text = deps.readFile(file);
+            if (text === null || depth > 4)
+                return;
+            for (const rawLine of text.split(/\r?\n/)) {
+                const line = rawLine.trim();
+                if (!line || line.startsWith('#'))
+                    continue;
+                const equals = line.indexOf('=');
+                if (equals === -1)
+                    continue;
+                const key = line.slice(0, equals).trim();
+                const value = line
+                    .slice(equals + 1)
+                    .trim()
+                    .replace(/^"(.*)"$/, '$1');
+                if (key === 'font-family') {
+                    // An empty value resets the list, per Ghostty's repeatable keys.
+                    if (value)
+                        settings.families.push(value);
+                    else
+                        settings.families = [];
+                }
+                else if (key === 'font-size') {
+                    settings.size = value;
+                }
+                else if (key === 'config-file') {
+                    const target = expandHome(value.replace(/^\?/, ''), deps);
+                    visit(path.resolve(path.dirname(file), target), depth + 1);
+                }
+            }
+        };
+        visit(path.join(configHome(deps), 'ghostty', 'config'), 0);
+        if (deps.platform === 'darwin') {
+            visit(path.join(deps.home, 'Library', 'Application Support', 'com.mitchellh.ghostty', 'config'), 0);
+        }
+        // Ghostty ships JetBrains Mono inside the binary and draws with it by default.
+        return {
+            family: settings.families[0] || 'JetBrains Mono',
+            sizePx: pointsToPx(settings.size || (deps.platform === 'darwin' ? 13 : 12)),
+        };
+    },
+    wezterm: (deps) => {
+        const result = deps.run('wezterm', ['ls-fonts']);
+        const listing = result.status === 0 ? result.stdout : '';
+        const match = /family\s*=\s*"([^"]+)"/.exec(listing) ||
+            /font_with_fallback\(\{[\s\S]*?"([^"]+)"/.exec(listing);
+        let sizePt = 12;
+        for (const file of [
+            path.join(deps.home, '.wezterm.lua'),
+            path.join(configHome(deps), 'wezterm', 'wezterm.lua'),
+        ]) {
+            const size = /font_size\s*=\s*(\d+(?:\.\d+)?)/.exec(deps.readFile(file) || '');
+            if (size) {
+                sizePt = Number(size[1]);
+                break;
+            }
+        }
+        // WezTerm, like Ghostty, embeds JetBrains Mono as its default.
+        return { family: match ? match[1] : 'JetBrains Mono', sizePx: pointsToPx(sizePt) };
+    },
+    foot: (deps) => {
+        const ini = parseIni(deps.readFile(path.join(configHome(deps), 'foot', 'foot.ini')));
+        const value = ini.main?.font || ini['']?.font || 'monospace:size=8';
+        return parseFontconfigPattern(value);
+    },
+    vscode: (deps) => {
+        const base = deps.platform === 'darwin'
+            ? path.join(deps.home, 'Library', 'Application Support')
+            : configHome(deps);
+        for (const product of ['Code', 'Cursor', 'Code - Insiders', 'VSCodium', 'Windsurf']) {
+            const settings = parseJsonc(deps.readFile(path.join(base, product, 'User', 'settings.json')));
+            if (!settings)
+                continue;
+            const family = firstCssFamily(settings['terminal.integrated.fontFamily']) ||
+                firstCssFamily(settings['editor.fontFamily']);
+            const sizePx = positiveNumber(settings['terminal.integrated.fontSize']) ||
+                positiveNumber(settings['editor.fontSize']) ||
+                14;
+            if (family)
+                return { family, sizePx };
+        }
+        return { family: deps.platform === 'darwin' ? 'Menlo' : 'Droid Sans Mono', sizePx: 14 };
+    },
+    iterm2: (deps) => {
+        const prefs = readPreferences('com.googlecode.iterm2', deps);
+        const bookmarks = prefs?.['New Bookmarks'];
+        const profiles = (Array.isArray(bookmarks) ? bookmarks : []);
+        const profile = profiles.find((candidate) => candidate?.Guid === prefs?.['Default Bookmark Guid']) ||
+            profiles[0];
+        // `JetBrainsMonoNF-Regular 13`: a PostScript name, then the size in points.
+        const match = /^(.+?)\s+(\d+(?:\.\d+)?)$/.exec(String(profile?.['Normal Font'] || '').trim());
+        if (!match)
+            return null;
+        const family = familyForPostScriptName(match[1], deps);
+        return family ? { family, sizePx: pointsToPx(match[2]) } : null;
+    },
+    'apple-terminal': (deps) => {
+        const prefs = readPreferences('com.apple.Terminal', deps);
+        if (!prefs)
+            return null;
+        const name = prefs['Default Window Settings'] || prefs['Startup Window Settings'] || 'Basic';
+        const profile = prefs['Window Settings']?.[String(name)];
+        // A profile that was never given a font draws with Terminal's own default,
+        // SF Mono 11 since macOS 10.15.
+        let postscript = 'SFMono-Regular';
+        let points = 11;
+        const archived = profile?.Font;
+        if (Buffer.isBuffer(archived)) {
+            // An archived NSFont: its PostScript name and point size.
+            const font = unarchiveKeyed(parseBinaryPlist(archived));
+            if (typeof font?.NSName === 'string' && font.NSName)
+                postscript = font.NSName;
+            if (Number(font?.NSSize) > 0)
+                points = Number(font?.NSSize);
+        }
+        const family = familyForPostScriptName(postscript, deps);
+        return family ? { family, sizePx: pointsToPx(points) } : null;
+    },
+    xterm: (deps) => {
+        // The emulator's own command line (`-fa`, `-fs`, `-xrm`) over the X
+        // resources, the way xterm itself ranks them. Without a faceName xterm
+        // draws with a bitmap core font, which no browser can load: no answer.
+        const classes = ['XTerm', 'xterm', 'UXTerm', 'uxterm'];
+        const args = deps.terminalArgs || [];
+        const resources = [...xResources(deps), ...xrmResources(args)];
+        const face = optionValue(args, ['-fa', '-faceName']) || xResource(resources, classes, 'faceName');
+        if (!face)
+            return null;
+        const font = parseXFontName(face, { bareIsPattern: true });
+        if (!font)
+            return null;
+        const size = Number(optionValue(args, ['-fs', '-faceSize']) || xResource(resources, classes, 'faceSize'));
+        return size > 0 ? { ...font, sizePx: pointsToPx(size) } : font;
+    },
+    urxvt: (deps) => {
+        const args = deps.terminalArgs || [];
+        const resources = [...xResources(deps), ...xrmResources(args)];
+        const font = optionValue(args, ['-fn']) ||
+            xResource(resources, ['URxvt', 'urxvt', 'Rxvt', 'rxvt'], 'font');
+        return font ? parseXFontName(font) : null;
+    },
+};
+/**
+ * A macOS preferences file, parsed. These are binary plists; one that is not
+ * (edited by hand) is left alone rather than guessed at.
+ */
+function readPreferences(domain, deps) {
+    const data = deps.readBuffer(path.join(deps.home, 'Library', 'Preferences', `${domain}.plist`));
+    if (!data)
+        return null;
+    try {
+        return parseBinaryPlist(data);
+    }
+    catch {
+        return null;
+    }
+}
+/** The X resource database, as `xrdb -query` prints it: `name:\tvalue`. */
+function xResources(deps) {
+    const result = deps.run('xrdb', ['-query']);
+    if (result.status !== 0)
+        return [];
+    return result.stdout
+        .split('\n')
+        .map((line) => {
+        const colon = line.indexOf(':');
+        return colon === -1 ? null : [line.slice(0, colon).trim(), line.slice(colon + 1).trim()];
+    })
+        .filter((entry) => entry !== null);
+}

package/dist/terminal-font/terminals.js

@@ -0,0 +1,128 @@
+// Which terminal emulator this process is running in.
+import fs from 'node:fs';
+import path from 'node:path';
+import { defaultRun } from './deps.js';
+/** Process names of the terminals this module can read, innermost wins. */
+const TERMINAL_PROCESSES = [
+    [/^gnome-terminal/, 'gnome-terminal'],
+    [/^ptyxis/, 'ptyxis'],
+    [/^tilix$/, 'tilix'],
+    [/^konsole$/, 'konsole'],
+    [/^xfce4-terminal$/, 'xfce4-terminal'],
+    [/^kitty$/, 'kitty'],
+    [/^alacritty$/i, 'alacritty'],
+    [/^ghostty$/i, 'ghostty'],
+    [/^wezterm-gui$/, 'wezterm'],
+    [/^foot(client)?$/, 'foot'],
+    [/^iTerm2$/, 'iterm2'],
+    [/^Terminal$/, 'apple-terminal'],
+    [/^xterm$/, 'xterm'],
+    [/^(urxvt|urxvtd|rxvt)$/, 'urxvt'],
+];
+/**
+ * The emulator a process runs under, from its own ancestry first.
+ *
+ * Environment variables leak through nested terminals — a kitty launched from
+ * GNOME Terminal still carries `GNOME_TERMINAL_SCREEN` — whereas the nearest
+ * emulator process above this one is the one actually drawing it. The
+ * environment is the fallback for the common case where there is no such
+ * ancestor: Herdr's server runs detached, so everything it starts, this
+ * connector included, has lost its terminal parent but kept its variables.
+ */
+export function identifyTerminal({ env = process.env, ancestry = [], } = {}) {
+    for (const name of ancestry) {
+        const base = path.basename(String(name || ''));
+        for (const [pattern, id] of TERMINAL_PROCESSES) {
+            if (pattern.test(base))
+                return id;
+        }
+    }
+    const program = env.TERM_PROGRAM || '';
+    if (program === 'vscode')
+        return 'vscode';
+    if (program === 'iTerm.app' || env.ITERM_SESSION_ID)
+        return 'iterm2';
+    if (program === 'Apple_Terminal')
+        return 'apple-terminal';
+    if (program === 'WezTerm' || env.WEZTERM_EXECUTABLE)
+        return 'wezterm';
+    if (program === 'ghostty' || env.GHOSTTY_RESOURCES_DIR)
+        return 'ghostty';
+    if (env.KITTY_WINDOW_ID || env.TERM === 'xterm-kitty')
+        return 'kitty';
+    if (env.ALACRITTY_SOCKET || env.ALACRITTY_WINDOW_ID || env.ALACRITTY_LOG)
+        return 'alacritty';
+    if (/^foot/.test(env.TERM || ''))
+        return 'foot';
+    if (env.KONSOLE_VERSION || env.KONSOLE_DBUS_SESSION)
+        return 'konsole';
+    if (env.PTYXIS_VERSION)
+        return 'ptyxis';
+    if (env.TILIX_ID)
+        return 'tilix';
+    if (env.GNOME_TERMINAL_SCREEN || env.GNOME_TERMINAL_SERVICE)
+        return 'gnome-terminal';
+    if (/^rxvt-unicode/.test(env.TERM || ''))
+        return 'urxvt';
+    // Last: a terminal started from xterm inherits this too.
+    if (env.XTERM_VERSION)
+        return 'xterm';
+    return null;
+}
+/** This process's ancestors, nearest first: `{ pid, name }`. */
+export function processLineage({ platform = process.platform, pid = process.ppid, run = defaultRun, } = {}) {
+    const lineage = [];
+    if (platform === 'linux') {
+        let current = pid;
+        for (let depth = 0; depth < 32 && current > 1; depth += 1) {
+            let stat;
+            try {
+                stat = fs.readFileSync(`/proc/${current}/stat`, 'utf8');
+            }
+            catch {
+                break;
+            }
+            // `pid (comm) state ppid ...`, where comm may itself contain spaces.
+            const open = stat.indexOf('(');
+            const close = stat.lastIndexOf(')');
+            if (open === -1 || close === -1)
+                break;
+            lineage.push({ pid: current, name: stat.slice(open + 1, close) });
+            current = Number(stat.slice(close + 2).split(' ')[1]);
+        }
+        return lineage;
+    }
+    if (platform === 'darwin') {
+        const result = run('ps', ['-axo', 'pid=,ppid=,comm=']);
+        if (result.status !== 0)
+            return lineage;
+        const table = new Map();
+        for (const line of result.stdout.split('\n')) {
+            const match = /^\s*(\d+)\s+(\d+)\s+(.+)$/.exec(line);
+            if (match)
+                table.set(Number(match[1]), { ppid: Number(match[2]), comm: match[3].trim() });
+        }
+        let current = pid;
+        for (let depth = 0; depth < 32 && table.has(current) && current > 1; depth += 1) {
+            const entry = table.get(current);
+            lineage.push({ pid: current, name: entry.comm });
+            current = entry.ppid;
+        }
+    }
+    return lineage;
+}
+/** The command line of a running process, as its argument list. */
+export function processArguments(pid, { platform = process.platform } = {}) {
+    if (platform !== 'linux')
+        return [];
+    try {
+        return fs.readFileSync(`/proc/${pid}/cmdline`, 'utf8').split('\0').filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}
+/** The ancestor process that is `source`'s emulator, if any. */
+export function terminalProcess(source, lineage) {
+    return (lineage.find((entry) => TERMINAL_PROCESSES.some(([pattern, id]) => id === source && pattern.test(path.basename(String(entry.name || ''))))) || null);
+}