slash-port 0.1.0

package/dist/scan/linux.js

@@ -0,0 +1,239 @@
+import { readFile, readdir, readlink } from 'node:fs/promises';
+import { mapConcurrent, normaliseAddress } from './shared.js';
+/** TCP_LISTEN as `/proc/net/tcp` writes it. */
+export const TCP_LISTEN = '0A';
+/**
+ * Decode a `/proc/net` address literal.
+ *
+ * The kernel writes each 32-bit word in host byte order, which on every
+ * platform this runs on is little-endian, so `0100007F` is 127.0.0.1 and not
+ * 1.0.0.127. IPv6 is four such words, each independently byte-swapped.
+ */
+export function decodeAddress(hex) {
+    if (hex.length === 8) {
+        const bytes = hexBytes(hex).reverse();
+        return { address: bytes.join('.'), family: 4 };
+    }
+    if (hex.length === 32) {
+        const bytes = [];
+        for (let word = 0; word < 4; word += 1) {
+            bytes.push(...hexBytes(hex.slice(word * 8, word * 8 + 8)).reverse());
+        }
+        return { address: formatIpv6(bytes), family: 6 };
+    }
+    throw new Error(`unrecognised /proc address literal: ${hex}`);
+}
+function hexBytes(hex) {
+    const bytes = [];
+    for (let index = 0; index < hex.length; index += 2) {
+        bytes.push(Number.parseInt(hex.slice(index, index + 2), 16));
+    }
+    return bytes;
+}
+function formatIpv6(bytes) {
+    // IPv4-mapped addresses read far better in their dotted form.
+    const mapped = bytes.slice(0, 10).every((byte) => byte === 0) && bytes[10] === 0xff && bytes[11] === 0xff;
+    if (mapped) {
+        return `::ffff:${bytes.slice(12).join('.')}`;
+    }
+    const groups = [];
+    for (let index = 0; index < 16; index += 2) {
+        groups.push((bytes[index] << 8) | bytes[index + 1]);
+    }
+    // Compress the longest run of two or more zero groups, per RFC 5952.
+    let bestStart = -1;
+    let bestLength = 0;
+    let runStart = -1;
+    for (let index = 0; index <= groups.length; index += 1) {
+        if (index < groups.length && groups[index] === 0) {
+            if (runStart === -1)
+                runStart = index;
+        }
+        else if (runStart !== -1) {
+            const length = index - runStart;
+            if (length > bestLength && length > 1) {
+                bestStart = runStart;
+                bestLength = length;
+            }
+            runStart = -1;
+        }
+    }
+    const parts = groups.map((group) => group.toString(16));
+    if (bestStart === -1)
+        return parts.join(':');
+    const head = parts.slice(0, bestStart).join(':');
+    const tail = parts.slice(bestStart + bestLength).join(':');
+    return `${head}::${tail}`;
+}
+/**
+ * Parse the whole of a `/proc/net` socket table, listening or not. Split from
+ * file reading so it can be tested against a fixture instead of whatever the
+ * host happens to have open.
+ */
+export function parseProcNetRows(content) {
+    const rows = [];
+    for (const line of content.split('\n')) {
+        const fields = line.trim().split(/\s+/);
+        // sl local rem st tx:rx tr:when retrnsmt uid timeout inode
+        if (fields.length < 10)
+            continue;
+        if (!/^\d+:$/.test(fields[0]))
+            continue;
+        const local = fields[1].split(':');
+        const remote = fields[2].split(':');
+        if (local.length !== 2 || remote.length !== 2)
+            continue;
+        let decoded;
+        let decodedRemote;
+        try {
+            decoded = decodeAddress(local[0]);
+            decodedRemote = decodeAddress(remote[0]);
+        }
+        catch {
+            continue;
+        }
+        rows.push({
+            address: decoded.address,
+            port: Number.parseInt(local[1], 16),
+            family: decoded.family,
+            remoteAddress: decodedRemote.address,
+            remotePort: Number.parseInt(remote[1], 16),
+            state: fields[3].toUpperCase(),
+            uid: Number.parseInt(fields[7], 10),
+            inode: Number.parseInt(fields[9], 10),
+        });
+    }
+    return rows;
+}
+/**
+ * The rows worth showing: TCP sockets in LISTEN, and UDP sockets with no peer,
+ * which is as close as UDP gets to the idea of listening.
+ */
+export function parseProcNet(content, protocol) {
+    const rows = parseProcNetRows(content);
+    if (protocol === 'tcp') {
+        return rows.filter((row) => row.state === TCP_LISTEN);
+    }
+    return rows.filter((row) => row.remotePort === 0);
+}
+async function readTable(path, protocol) {
+    try {
+        return parseProcNet(await readFile(path, 'utf8'), protocol);
+    }
+    catch {
+        // tcp6/udp6 are absent on kernels built without IPv6. That is not an error.
+        return [];
+    }
+}
+/** uid → user name, read straight from `/etc/passwd` so there is no dependency. */
+async function readPasswd() {
+    const users = new Map();
+    try {
+        const content = await readFile('/etc/passwd', 'utf8');
+        for (const line of content.split('\n')) {
+            const fields = line.split(':');
+            if (fields.length < 3)
+                continue;
+            const uid = Number.parseInt(fields[2], 10);
+            if (Number.isInteger(uid) && fields[0])
+                users.set(uid, fields[0]);
+        }
+    }
+    catch {
+        // Unreadable /etc/passwd only costs us the names; uids still display.
+    }
+    return users;
+}
+async function listProcessIds() {
+    const entries = await readdir('/proc');
+    const pids = [];
+    for (const entry of entries) {
+        if (/^\d+$/.test(entry))
+            pids.push(Number.parseInt(entry, 10));
+    }
+    return pids;
+}
+/**
+ * Map socket inodes to the pids holding them by walking `/proc/[pid]/fd`.
+ *
+ * Descriptors belonging to other users are not readable without privileges, so
+ * those inodes stay unmapped and the row reports a null pid rather than
+ * failing the whole scan.
+ */
+async function mapInodesToPids(wanted) {
+    const owners = new Map();
+    const pids = await listProcessIds();
+    await mapConcurrent(pids, 64, async (pid) => {
+        let descriptors;
+        try {
+            descriptors = await readdir(`/proc/${pid}/fd`);
+        }
+        catch {
+            return;
+        }
+        for (const descriptor of descriptors) {
+            let target;
+            try {
+                target = await readlink(`/proc/${pid}/fd/${descriptor}`);
+            }
+            catch {
+                continue;
+            }
+            const match = /^socket:\[(\d+)\]$/.exec(target);
+            if (!match)
+                continue;
+            const inode = Number.parseInt(match[1], 10);
+            if (wanted.has(inode) && !owners.has(inode))
+                owners.set(inode, pid);
+        }
+    });
+    return owners;
+}
+async function readProcessInfo(pid) {
+    const [name, command] = await Promise.all([
+        readFile(`/proc/${pid}/comm`, 'utf8')
+            .then((value) => value.trim() || null)
+            .catch(() => null),
+        readFile(`/proc/${pid}/cmdline`, 'utf8')
+            .then((value) => value.replace(/\0+$/, '').split('\0').join(' ').trim() || null)
+            .catch(() => null),
+    ]);
+    return { name, command };
+}
+export async function scanLinux(options = {}) {
+    const tables = [
+        readTable('/proc/net/tcp', 'tcp'),
+        readTable('/proc/net/tcp6', 'tcp'),
+    ];
+    if (options.udp) {
+        tables.push(readTable('/proc/net/udp', 'udp'), readTable('/proc/net/udp6', 'udp'));
+    }
+    const [tcp4, tcp6, udp4 = [], udp6 = []] = await Promise.all(tables);
+    const tagged = [
+        ...tcp4.map((row) => ({ row, protocol: 'tcp' })),
+        ...tcp6.map((row) => ({ row, protocol: 'tcp' })),
+        ...udp4.map((row) => ({ row, protocol: 'udp' })),
+        ...udp6.map((row) => ({ row, protocol: 'udp' })),
+    ];
+    const wanted = new Set(tagged.map(({ row }) => row.inode).filter((inode) => inode > 0));
+    const [owners, users] = await Promise.all([mapInodesToPids(wanted), readPasswd()]);
+    const uniquePids = [...new Set(owners.values())];
+    const details = new Map();
+    await mapConcurrent(uniquePids, 64, async (pid) => {
+        details.set(pid, await readProcessInfo(pid));
+    });
+    return tagged.map(({ row, protocol }) => {
+        const pid = owners.get(row.inode) ?? null;
+        const info = pid === null ? undefined : details.get(pid);
+        return {
+            protocol,
+            family: row.family,
+            address: normaliseAddress(row.address),
+            port: row.port,
+            pid,
+            processName: info?.name ?? null,
+            command: info?.command ?? null,
+            user: users.get(row.uid) ?? String(row.uid),
+        };
+    });
+}

package/dist/scan/shared.js

@@ -0,0 +1,56 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+/** Wildcard bind addresses, shown as `*` the way lsof and netstat do. */
+const WILDCARD = new Set(['0.0.0.0', '::', '*', '[::]', '0000:0000:0000:0000:0000:0000:0000:0000']);
+export function normaliseAddress(address) {
+    const trimmed = address.trim();
+    if (WILDCARD.has(trimmed))
+        return '*';
+    // Strip the brackets netstat puts round IPv6 literals.
+    if (trimmed.startsWith('[') && trimmed.endsWith(']')) {
+        const inner = trimmed.slice(1, -1);
+        return WILDCARD.has(inner) ? '*' : inner;
+    }
+    return trimmed;
+}
+/**
+ * Split `host:port` where the host may itself contain colons. Everything after
+ * the last colon is the port, which is why IPv6 literals arrive bracketed.
+ */
+export function splitHostPort(value) {
+    const separator = value.lastIndexOf(':');
+    if (separator === -1)
+        return null;
+    const rawPort = value.slice(separator + 1);
+    const port = Number.parseInt(rawPort, 10);
+    if (!Number.isInteger(port) || port < 0 || port > 65535)
+        return null;
+    return { address: normaliseAddress(value.slice(0, separator)), port };
+}
+/**
+ * Run a local helper binary. Nothing here touches the network; these are the
+ * platform tools that expose the socket table.
+ */
+export async function run(command, args) {
+    const { stdout, stderr } = await execFileAsync(command, args, {
+        encoding: 'utf8',
+        maxBuffer: 16 * 1024 * 1024,
+        windowsHide: true,
+    });
+    return { stdout, stderr };
+}
+/** Map over items with a bounded number of in-flight operations. */
+export async function mapConcurrent(items, limit, fn) {
+    const results = new Array(items.length);
+    let cursor = 0;
+    const worker = async () => {
+        while (cursor < items.length) {
+            const index = cursor++;
+            results[index] = await fn(items[index]);
+        }
+    };
+    const workers = Array.from({ length: Math.min(limit, items.length) }, worker);
+    await Promise.all(workers);
+    return results;
+}

package/dist/scan/win32.js

@@ -0,0 +1,148 @@
+import { normaliseAddress, run, splitHostPort } from './shared.js';
+import { ScanError } from '../types.js';
+/**
+ * Parse `netstat -ano`.
+ *
+ * TCP rows carry a state column and UDP rows do not, so the pid is the last
+ * field rather than a fixed index. `netstat` is used in preference to
+ * `Get-NetTCPConnection` because it exists on every edition of Windows and
+ * costs nothing to start, where PowerShell costs about a second.
+ */
+export function parseNetstat(output) {
+    const rows = [];
+    for (const line of output.split('\n')) {
+        const fields = line.trim().split(/\s+/);
+        if (fields.length < 4)
+            continue;
+        const protocol = fields[0].toUpperCase();
+        if (protocol !== 'TCP' && protocol !== 'UDP')
+            continue;
+        // Localised builds translate the state word, so a TCP row also counts as
+        // listening when it has no peer — only LISTEN has a foreign port of zero.
+        if (protocol === 'TCP') {
+            if (fields.length < 5)
+                continue;
+            const listening = fields[3].toUpperCase() === 'LISTENING' || splitHostPort(fields[2])?.port === 0;
+            if (!listening)
+                continue;
+        }
+        const pid = Number.parseInt(fields[fields.length - 1], 10);
+        if (!Number.isInteger(pid))
+            continue;
+        const local = fields[1];
+        const split = splitHostPort(local);
+        if (!split)
+            continue;
+        rows.push({
+            protocol: protocol === 'TCP' ? 'tcp' : 'udp',
+            address: split.address,
+            port: split.port,
+            family: local.startsWith('[') ? 6 : 4,
+            pid,
+        });
+    }
+    return rows;
+}
+/** Minimal RFC 4180 reader; tasklist quotes every field and escapes `"` as `""`. */
+export function parseCsvLine(line) {
+    const fields = [];
+    let current = '';
+    let quoted = false;
+    for (let index = 0; index < line.length; index += 1) {
+        const character = line[index];
+        if (quoted) {
+            if (character === '"') {
+                if (line[index + 1] === '"') {
+                    current += '"';
+                    index += 1;
+                }
+                else {
+                    quoted = false;
+                }
+            }
+            else {
+                current += character;
+            }
+        }
+        else if (character === '"') {
+            quoted = true;
+        }
+        else if (character === ',') {
+            fields.push(current);
+            current = '';
+        }
+        else {
+            current += character;
+        }
+    }
+    fields.push(current);
+    return fields;
+}
+/**
+ * Parse `tasklist /V /FO CSV /NH`: image name, pid, session, session number,
+ * memory, status, user name, cpu time, window title. The column *positions*
+ * are stable across locales even though the headings are not, which is why the
+ * headings are suppressed with `/NH`.
+ */
+export function parseTasklist(output) {
+    const processes = new Map();
+    for (const line of output.split('\n')) {
+        if (!line.trim())
+            continue;
+        const fields = parseCsvLine(line.trim());
+        if (fields.length < 2)
+            continue;
+        const pid = Number.parseInt(fields[1], 10);
+        if (!Number.isInteger(pid))
+            continue;
+        const user = fields[6]?.trim();
+        processes.set(pid, {
+            name: fields[0].trim(),
+            user: user && user !== 'N/A' ? user : null,
+        });
+    }
+    return processes;
+}
+async function runNetstat(args) {
+    try {
+        const { stdout } = await run('netstat', args);
+        return stdout;
+    }
+    catch (error) {
+        const failure = error;
+        if (failure.code === 'ENOENT') {
+            throw new ScanError('netstat could not be found on PATH.', 'Check that %SystemRoot%\\System32 is on PATH.');
+        }
+        if (typeof failure.stdout === 'string')
+            return failure.stdout;
+        throw error;
+    }
+}
+export async function scanWin32(options = {}) {
+    const netstatArgs = options.udp ? ['-ano'] : ['-ano', '-p', 'TCP'];
+    const [netstatOutput, tasklistOutput] = await Promise.all([
+        runNetstat(netstatArgs),
+        // Losing tasklist costs the process names, not the scan.
+        run('tasklist', ['/V', '/FO', 'CSV', '/NH']).then((result) => result.stdout, () => ''),
+    ]);
+    const processes = parseTasklist(tasklistOutput);
+    return parseNetstat(netstatOutput)
+        .filter((row) => options.udp || row.protocol === 'tcp')
+        .map((row) => {
+        const process = processes.get(row.pid);
+        return {
+            protocol: row.protocol,
+            family: row.family,
+            address: normaliseAddress(row.address),
+            port: row.port,
+            // Windows reports pid 0 for the system idle process, which owns
+            // nothing a user can act on.
+            pid: row.pid === 0 ? null : row.pid,
+            processName: process?.name ?? null,
+            // netstat and tasklist cannot supply a command line; the description
+            // heuristics fall back to the image name.
+            command: null,
+            user: process?.user ?? null,
+        };
+    });
+}

package/dist/types.js

@@ -0,0 +1,9 @@
+/** A scan failure the user can act on, as opposed to a crash. */
+export class ScanError extends Error {
+    hint;
+    constructor(message, hint) {
+        super(message);
+        this.name = 'ScanError';
+        this.hint = hint;
+    }
+}

package/dist/ui/App.js

@@ -0,0 +1,223 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, useApp, useInput, useStdout } from 'ink';
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import { formatAddresses, formatDescription, formatPid, formatPort, formatProcess, formatUser, matchesFilter, } from '../format.js';
+import { killEntry } from '../kill.js';
+import { scan } from '../scan/index.js';
+import { cell, color, layout, truncate } from './theme.js';
+/** Header, column titles, filter line, status line, and the two help lines. */
+const CHROME_ROWS = 7;
+function useTerminalSize() {
+    const { stdout } = useStdout();
+    // A stdout that reports zero columns is one that does not know its own
+    // size, not a terminal zero characters wide.
+    const read = useCallback(() => ({ columns: stdout?.columns || 80, rows: stdout?.rows || 24 }), [stdout]);
+    const [size, setSize] = useState(read);
+    useEffect(() => {
+        if (!stdout || typeof stdout.on !== 'function')
+            return;
+        const onResize = () => setSize(read());
+        stdout.on('resize', onResize);
+        return () => {
+            stdout.off?.('resize', onResize);
+        };
+    }, [stdout, read]);
+    return size;
+}
+const STATUS_COLOR = {
+    info: 'muted',
+    ok: 'ok',
+    warn: 'warn',
+    error: 'danger',
+};
+function statusFor(result) {
+    switch (result.status) {
+        case 'terminated':
+            return { kind: 'ok', text: result.message };
+        case 'gone':
+            return { kind: 'info', text: result.message };
+        case 'failed':
+            return { kind: 'error', text: result.message };
+        default:
+            return { kind: 'warn', text: result.message };
+    }
+}
+export function App({ initialEntries, initialFilter = '', udp: initialUdp = false, scanner = scan, killer = killEntry, }) {
+    const { exit } = useApp();
+    const { columns, rows } = useTerminalSize();
+    const [entries, setEntries] = useState(initialEntries ?? []);
+    const [loading, setLoading] = useState(initialEntries === undefined);
+    const [udp, setUdp] = useState(initialUdp);
+    const [filter, setFilter] = useState(initialFilter);
+    const [filtering, setFiltering] = useState(false);
+    const [selected, setSelected] = useState(0);
+    const [offset, setOffset] = useState(0);
+    const [dialog, setDialog] = useState(null);
+    const [busy, setBusy] = useState(false);
+    const [status, setStatus] = useState(null);
+    const refresh = useCallback(async (options) => {
+        setLoading(true);
+        try {
+            setEntries(await scanner(options));
+        }
+        catch (error) {
+            setStatus({ kind: 'error', text: error.message });
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [scanner]);
+    useEffect(() => {
+        if (initialEntries !== undefined)
+            return;
+        void refresh({ udp });
+        // Re-scanning is driven by `r` and `u`; this effect only covers the first load.
+    }, []);
+    const visible = useMemo(() => entries.filter((entry) => matchesFilter(entry, filter)), [entries, filter]);
+    const viewport = Math.max(3, rows - CHROME_ROWS);
+    // The list can shrink underneath the cursor — a filter keystroke, or a
+    // rescan after a kill — so the selection is clamped rather than left dangling.
+    useEffect(() => {
+        setSelected((current) => Math.min(current, Math.max(0, visible.length - 1)));
+    }, [visible.length]);
+    useEffect(() => {
+        setOffset((current) => {
+            if (selected < current)
+                return selected;
+            if (selected >= current + viewport)
+                return selected - viewport + 1;
+            return Math.min(current, Math.max(0, visible.length - viewport));
+        });
+    }, [selected, viewport, visible.length]);
+    const current = visible[selected];
+    const performKill = useCallback(async (entry, signal) => {
+        setDialog(null);
+        setBusy(true);
+        try {
+            setStatus(statusFor(await killer(entry, { signal })));
+        }
+        catch (error) {
+            setStatus({ kind: 'error', text: error.message });
+        }
+        finally {
+            setBusy(false);
+        }
+        await refresh({ udp });
+    }, [killer, refresh, udp]);
+    useInput((input, key) => {
+        if (busy)
+            return;
+        if (dialog) {
+            if (input === 'y')
+                void performKill(dialog, 'SIGTERM');
+            else if (input === 'f')
+                void performKill(dialog, 'SIGKILL');
+            else if (input === 'n' || key.escape) {
+                setDialog(null);
+                setStatus({ kind: 'info', text: 'Cancelled. Nothing was signalled.' });
+            }
+            return;
+        }
+        if (filtering) {
+            if (key.escape) {
+                setFiltering(false);
+                setFilter('');
+            }
+            else if (key.return) {
+                setFiltering(false);
+            }
+            else if (key.backspace || key.delete) {
+                setFilter((value) => value.slice(0, -1));
+            }
+            else if (input && !key.ctrl && !key.meta) {
+                setFilter((value) => value + input);
+            }
+            return;
+        }
+        if (input === 'q' || key.escape) {
+            exit();
+            return;
+        }
+        if (key.upArrow || input === 'k')
+            setSelected((value) => Math.max(0, value - 1));
+        else if (key.downArrow || input === 'j')
+            setSelected((value) => Math.min(visible.length - 1, value + 1));
+        else if (key.pageUp)
+            setSelected((value) => Math.max(0, value - viewport));
+        else if (key.pageDown)
+            setSelected((value) => Math.min(visible.length - 1, value + viewport));
+        else if (input === 'g')
+            setSelected(0);
+        else if (input === 'G')
+            setSelected(Math.max(0, visible.length - 1));
+        else if (input === '/') {
+            setFiltering(true);
+            setStatus(null);
+        }
+        else if (input === 'r')
+            void refresh({ udp });
+        else if (input === 'u') {
+            const next = !udp;
+            setUdp(next);
+            setStatus({ kind: 'info', text: next ? 'Showing UDP as well as TCP.' : 'Showing TCP only.' });
+            void refresh({ udp: next });
+        }
+        else if (input === 'x' || key.return) {
+            if (!current)
+                return;
+            // Protected rows are refused here, before any dialog: there is no
+            // confirmation that lets you kill your own shell.
+            if (current.guard) {
+                setStatus({ kind: 'warn', text: `Refusing to kill ${current.guard}.` });
+                return;
+            }
+            setStatus(null);
+            setDialog(current);
+        }
+    });
+    const columnLayout = layout(columns);
+    const window = visible.slice(offset, offset + viewport);
+    // A zero-width column is one the terminal is too narrow for, and is dropped
+    // entirely rather than rendered as an empty gap.
+    const columnise = (values) => [
+        cell(values.port, columnLayout.port),
+        columnLayout.pid && cell(values.pid, columnLayout.pid),
+        columnLayout.user && cell(values.user, columnLayout.user),
+        columnLayout.process && cell(values.process, columnLayout.process),
+        columnLayout.address && cell(values.address, columnLayout.address),
+    ]
+        .filter((value) => typeof value === 'string')
+        .join(' ');
+    const header = columnise({
+        port: 'PORT',
+        pid: 'PID',
+        user: 'USER',
+        process: 'PROCESS',
+        address: 'ADDRESS',
+    });
+    return (_jsxs(Box, { flexDirection: "column", width: columnLayout.total, children: [_jsxs(Box, { justifyContent: "space-between", children: [_jsx(Text, { color: color('heading'), bold: true, children: "slash-port" }), _jsx(Text, { color: color('muted'), children: loading
+                            ? 'scanning…'
+                            : `${visible.length}/${entries.length} ${udp ? 'tcp+udp' : 'tcp'}` })] }), _jsxs(Box, { children: [_jsxs(Text, { color: color('muted'), children: [header, " "] }), _jsx(Text, { color: color('muted'), children: cell('DESCRIPTION', columnLayout.description) })] }), window.map((entry, index) => {
+                const isSelected = offset + index === selected;
+                const rowColor = entry.guard ? color('warn') : entry.pid === null ? color('muted') : undefined;
+                const left = columnise({
+                    port: formatPort(entry),
+                    pid: formatPid(entry),
+                    user: formatUser(entry),
+                    process: formatProcess(entry),
+                    address: formatAddresses(entry),
+                });
+                return (_jsxs(Box, { children: [_jsxs(Text, { inverse: isSelected, color: rowColor, children: [left, ' '] }), _jsx(Text, { inverse: isSelected, color: rowColor ?? color('accent'), children: cell(formatDescription(entry), columnLayout.description) })] }, entry.id));
+            }), !loading && entries.length === 0 && (_jsxs(Text, { color: color('muted'), children: ["Nothing is listening", udp ? '' : ' on TCP', ". Press u to include UDP, r to rescan."] })), !loading && entries.length > 0 && visible.length === 0 && (_jsxs(Text, { color: color('muted'), children: ["No port matches \u201C", filter, "\u201D. Press Esc to clear the filter."] })), dialog && _jsx(ConfirmDialog, { entry: dialog, width: columnLayout.total }), filtering && (_jsxs(Text, { children: [_jsx(Text, { color: color('heading'), children: "filter " }), _jsx(Text, { children: filter }), _jsx(Text, { color: color('muted'), children: "\u258E" })] })), !filtering && filter !== '' && (_jsxs(Text, { color: color('muted'), children: ["filter: ", truncate(filter, Math.max(8, columnLayout.total - 10))] })), status && (_jsx(Text, { color: color(STATUS_COLOR[status.kind]), children: truncate(status.text, columnLayout.total) })), !dialog && (_jsx(Text, { color: color('muted'), children: truncate('↑↓/jk move · PgUp/PgDn/g/G jump · / filter · x kill · r rescan · u udp · q quit', columnLayout.total) }))] }));
+}
+function ConfirmDialog({ entry, width }) {
+    const inner = Math.max(20, width - 4);
+    const owner = [
+        entry.processName ?? 'unknown process',
+        `pid ${entry.pid ?? 'unknown'}`,
+        entry.user ? `user ${entry.user}` : null,
+    ]
+        .filter(Boolean)
+        .join(' · ');
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: color('warn'), paddingX: 1, children: [_jsx(Text, { color: color('warn'), bold: true, children: truncate(`Kill whatever holds port ${entry.port}/${entry.protocol}?`, inner) }), _jsx(Text, { children: truncate(formatDescription(entry), inner) }), _jsx(Text, { color: color('muted'), children: truncate(owner, inner) }), _jsx(Text, { children: " " }), _jsxs(Text, { children: [_jsx(Text, { color: color('ok'), children: "y" }), " terminate (SIGTERM) \u00B7", ' ', _jsx(Text, { color: color('danger'), children: "f" }), " force (SIGKILL) \u00B7 ", _jsx(Text, { color: color('heading'), children: "n" }), " cancel"] })] }));
+}