@xemahq/xema 0.14.0 → 0.15.0

package/dist/runtime/run-manifest.js

@@ -1,36 +1,76 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunManifestServiceState = void 0;
 exports.runManifestPath = runManifestPath;
 exports.writeRunManifest = writeRunManifest;
 exports.readRunManifest = readRunManifest;
-exports.clearRunManifest = clearRunManifest;
+exports.parseRunManifestPayload = parseRunManifestPayload;
+exports.clearRunManifestStrict = clearRunManifestStrict;
 exports.appendRunManifestEntry = appendRunManifestEntry;
+exports.markRunManifestEntryReady = markRunManifestEntryReady;
+exports.removeRunManifestEntryAfterVerifiedStop = removeRunManifestEntryAfterVerifiedStop;
+exports.runManifestEntryVerifiedStopped = runManifestEntryVerifiedStopped;
 exports.parsePidHandle = parsePidHandle;
 exports.reapStaleServices = reapStaleServices;
+exports.runManifestEntryProcessGroupMatches = runManifestEntryProcessGroupMatches;
+exports.runManifestEntryOwnsPort = runManifestEntryOwnsPort;
+exports.runManifestEntryOwnsPortAsync = runManifestEntryOwnsPortAsync;
+exports.runManifestEntryProcessMatches = runManifestEntryProcessMatches;
+exports.runManifestLauncherIsActive = runManifestLauncherIsActive;
+exports.runManifestEntryProcessMatchesAsync = runManifestEntryProcessMatchesAsync;
 const node_child_process_1 = require("node:child_process");
+const node_crypto_1 = require("node:crypto");
 const node_fs_1 = require("node:fs");
 const node_os_1 = require("node:os");
 const node_path_1 = require("node:path");
+const native_process_group_1 = require("./native-process-group");
 const forked_worker_1 = require("../dev/forked-worker");
+var RunManifestServiceState;
+(function (RunManifestServiceState) {
+    RunManifestServiceState["Starting"] = "starting";
+    RunManifestServiceState["Ready"] = "ready";
+})(RunManifestServiceState || (exports.RunManifestServiceState = RunManifestServiceState = {}));
 const REAP_GRACE_MS = 3_000;
 const OWNERSHIP_PROBE_TIMEOUT_MS = 2_000;
-const FORKED_MAIN_MODULE = 'dist/main.js';
-const WATCH_TARGET_MODULE = 'src/main.ts';
-const WATCH_RUNNER_MARKER = 'tsx';
-const MAX_ANCESTRY_DEPTH = 16;
-function runManifestPath() {
-    return (0, node_path_1.join)((0, node_os_1.homedir)(), '.xema', 'run', 'current.json');
+function runManifestPath(executionId) {
+    const digest = (0, node_crypto_1.createHash)('sha256')
+        .update(executionId)
+        .digest('hex');
+    return (0, node_path_1.join)((0, node_os_1.homedir)(), '.xema', 'run', 'sessions', `${digest}.json`);
 }
 function writeRunManifest(manifest) {
-    const path = runManifestPath();
-    (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(path), { recursive: true });
-    (0, node_fs_1.writeFileSync)(path, `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
+    const path = runManifestPath(manifest.executionId);
+    const directory = (0, node_path_1.dirname)(path);
+    (0, node_fs_1.mkdirSync)(directory, { recursive: true, mode: 0o700 });
+    const temporaryPath = `${path}.${String(process.pid)}.${(0, node_crypto_1.randomUUID)()}.tmp`;
+    let descriptor;
+    try {
+        descriptor = (0, node_fs_1.openSync)(temporaryPath, 'wx', 0o600);
+        (0, node_fs_1.writeFileSync)(descriptor, `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
+        (0, node_fs_1.fsyncSync)(descriptor);
+        (0, node_fs_1.closeSync)(descriptor);
+        descriptor = undefined;
+        (0, node_fs_1.renameSync)(temporaryPath, path);
+        const directoryDescriptor = (0, node_fs_1.openSync)(directory, 'r');
+        try {
+            (0, node_fs_1.fsyncSync)(directoryDescriptor);
+        }
+        finally {
+            (0, node_fs_1.closeSync)(directoryDescriptor);
+        }
+    }
+    catch (error) {
+        if (descriptor !== undefined) {
+            (0, node_fs_1.closeSync)(descriptor);
+        }
+        (0, node_fs_1.rmSync)(temporaryPath, { force: true });
+        throw error;
+    }
 }
-function readRunManifest() {
-    return readRunManifestFile()?.services ?? [];
+function readRunManifest(installationId) {
+    return readRunManifestFiles(installationId).flatMap(({ manifest }) => manifest.services);
 }
-function readRunManifestFile() {
-    const path = runManifestPath();
+function readRunManifestFile(path) {
     if (!(0, node_fs_1.existsSync)(path)) {
         return undefined;
     }
@@ -38,36 +78,150 @@ function readRunManifestFile() {
     try {
         raw = (0, node_fs_1.readFileSync)(path, 'utf8');
     }
-    catch {
-        return undefined;
+    catch (error) {
+        throw new Error(`Cannot read native run manifest ${path}.`, {
+            cause: error,
+        });
     }
     let parsed;
     try {
         parsed = JSON.parse(raw);
     }
-    catch {
-        return undefined;
+    catch (error) {
+        throw new Error(`Native run manifest ${path} is not valid JSON.`, {
+            cause: error,
+        });
     }
-    return normalizeManifest(parsed);
-}
-function clearRunManifest() {
     try {
-        (0, node_fs_1.rmSync)(runManifestPath(), { force: true });
+        return parseRunManifestPayload(parsed);
     }
-    catch {
+    catch (error) {
+        throw new Error(`Native run manifest ${path} has an invalid schema.`, {
+            cause: error,
+        });
+    }
+}
+function parseRunManifestPayload(value) {
+    const manifest = normalizeManifest(value);
+    if (manifest === undefined) {
+        throw new Error('Native run manifest payload has an invalid schema.');
+    }
+    return manifest;
+}
+function readRunManifestFiles(installationId) {
+    return sessionManifestPaths().flatMap((path) => {
+        const manifest = readRunManifestFile(path);
+        return manifest === undefined ||
+            (installationId !== undefined &&
+                manifest.installationId !== installationId)
+            ? []
+            : [{ path, manifest }];
+    });
+}
+function sessionManifestPaths() {
+    const directory = (0, node_path_1.join)((0, node_os_1.homedir)(), '.xema', 'run', 'sessions');
+    if (!(0, node_fs_1.existsSync)(directory)) {
+        return [];
     }
+    return (0, node_fs_1.readdirSync)(directory, { withFileTypes: true })
+        .filter((entry) => entry.isFile() && entry.name.endsWith('.json'))
+        .map((entry) => (0, node_path_1.join)(directory, entry.name))
+        .sort();
+}
+function clearRunManifestStrict(executionId) {
+    (0, node_fs_1.rmSync)(runManifestPath(executionId), { force: true });
 }
 function appendRunManifestEntry(entry) {
-    const existing = readRunManifestFile();
+    const existing = readRunManifestFile(runManifestPath(entry.executionId));
     const base = existing ?? {
         startedAt: new Date().toISOString(),
         pid: process.pid,
+        launcherFingerprint: (0, native_process_group_1.captureProcessFingerprint)(process.pid),
+        installationId: entry.installationId,
+        planHash: entry.planHash,
+        executionId: entry.executionId,
         services: [],
     };
+    if (base.installationId !== entry.installationId ||
+        base.planHash !== entry.planHash ||
+        base.executionId !== entry.executionId) {
+        throw new Error(`Run manifest identity mismatch for execution ${entry.executionId}.`);
+    }
     const services = base.services.filter((s) => s.pid !== entry.pid);
-    services.push({ ...entry, mode: (0, forked_worker_1.resolveLaunchMode)() });
+    const processFingerprint = (0, native_process_group_1.captureProcessFingerprint)(entry.pid);
+    const processGroupId = (0, native_process_group_1.processGroupIdForPid)(entry.pid);
+    if (processGroupId !== entry.pid) {
+        throw new Error(`Native service pid ${String(entry.pid)} is not the leader of its dedicated ` +
+            `process group (observed PGID ${String(processGroupId)}).`);
+    }
+    services.push({
+        ...entry,
+        mode: (0, forked_worker_1.resolveLaunchMode)(),
+        processFingerprint,
+        processGroupId,
+        processGroupMembers: [{ pid: entry.pid, processFingerprint }],
+        state: RunManifestServiceState.Starting,
+    });
     writeRunManifest({ ...base, services });
 }
+function markRunManifestEntryReady(executionId, pid) {
+    const path = runManifestPath(executionId);
+    const manifest = readRunManifestFile(path);
+    if (manifest === undefined) {
+        throw new Error(`Cannot mark pid ${String(pid)} ready: execution manifest is missing.`);
+    }
+    let matched = false;
+    const services = manifest.services.map((entry) => {
+        if (entry.pid !== pid) {
+            return entry;
+        }
+        matched = true;
+        const processGroupMembers = captureProcessGroupMemberIdentities(entry.processGroupId);
+        const leader = processGroupMembers.find((member) => member.pid === entry.pid);
+        if (leader === undefined ||
+            leader.processFingerprint !== entry.processFingerprint) {
+            throw new Error(`Cannot mark pid ${String(pid)} ready: process-group leader identity changed.`);
+        }
+        return {
+            ...entry,
+            processGroupMembers,
+            state: RunManifestServiceState.Ready,
+        };
+    });
+    if (!matched) {
+        throw new Error(`Cannot mark pid ${String(pid)} ready: ownership record is missing.`);
+    }
+    writeRunManifest({ ...manifest, services });
+}
+function removeRunManifestEntryAfterVerifiedStop(executionId, pid) {
+    const path = runManifestPath(executionId);
+    const manifest = readRunManifestFile(path);
+    if (manifest === undefined) {
+        return;
+    }
+    const entry = manifest.services.find((candidate) => candidate.pid === pid);
+    if (entry === undefined) {
+        return;
+    }
+    if (!runManifestEntryVerifiedStopped(entry)) {
+        throw new Error(`Refusing to remove pre-ready ownership evidence because process group ` +
+            `${String(entry.processGroupId)} is not verified empty.`);
+    }
+    const services = manifest.services.filter((candidate) => candidate.pid !== pid);
+    if (services.length === 0) {
+        (0, node_fs_1.rmSync)(path, { force: true });
+        return;
+    }
+    writeRunManifest({ ...manifest, services });
+}
+function runManifestEntryVerifiedStopped(entry, groupMembers = native_process_group_1.processGroupMembers) {
+    try {
+        return groupMembers(entry.processGroupId).length === 0;
+    }
+    catch {
+        return false;
+    }
+}
 function parsePidHandle(handle) {
     const prefix = 'pid:';
     if (!handle.startsWith(prefix)) {
@@ -76,85 +230,202 @@ function parsePidHandle(handle) {
     const pid = Number.parseInt(handle.slice(prefix.length), 10);
     return Number.isInteger(pid) && pid > 0 ? pid : undefined;
 }
-function reapStaleServices() {
+function reapStaleServices(installationId) {
     const killed = [];
     const skipped = [];
-    const manifest = readRunManifestFile();
-    if (!manifest || manifest.services.length === 0) {
-        clearRunManifest();
+    const manifests = readRunManifestFiles(installationId);
+    if (manifests.length === 0) {
         return { killed, skipped };
     }
     const confirmed = [];
-    for (const entry of manifest.services) {
-        if (!isAlive(entry.pid)) {
-            continue;
+    const staleManifests = manifests.filter(({ manifest }) => !runManifestLauncherIsActive(manifest));
+    for (const { manifest } of staleManifests) {
+        for (const entry of manifest.services) {
+            const ownership = resolveOwnedProcessGroup(entry);
+            if (ownership === 'gone') {
+                continue;
+            }
+            if (ownership === 'owned') {
+                confirmed.push(entry);
+            }
+            else {
+                skipped.push(entry);
+            }
         }
-        const pids = resolveReapPids(entry);
-        if (pids !== null && pids.length > 0) {
-            confirmed.push({ entry, pids });
+    }
+    for (const entry of confirmed) {
+        try {
+            const terminated = (0, native_process_group_1.terminateProcessGroupSync)(entry.processGroupId, REAP_GRACE_MS, OWNERSHIP_PROBE_TIMEOUT_MS, ownershipCheckingControl(entry));
+            if (terminated) {
+                killed.push(entry);
+            }
+            else {
+                skipped.push(entry);
+            }
         }
-        else {
+        catch {
             skipped.push(entry);
         }
     }
-    const allPids = [...new Set(confirmed.flatMap((c) => c.pids))];
-    for (const pid of allPids) {
-        trySignal(pid, 'SIGTERM');
+    for (const { path, manifest } of staleManifests) {
+        const retained = skipped.filter((entry) => entry.executionId === manifest.executionId);
+        if (retained.length === 0) {
+            (0, node_fs_1.rmSync)(path, { force: true });
+        }
+        else {
+            writeRunManifest({ ...manifest, services: retained });
+        }
     }
-    if (allPids.length > 0) {
-        sleepSync(REAP_GRACE_MS);
+    return { killed, skipped };
+}
+function resolveOwnedProcessGroup(entry) {
+    let members;
+    try {
+        members = (0, native_process_group_1.processGroupMembers)(entry.processGroupId);
     }
-    for (const pid of allPids) {
-        if (isAlive(pid)) {
-            trySignal(pid, 'SIGKILL');
-        }
+    catch {
+        return 'unverified';
     }
-    for (const { entry } of confirmed) {
-        killed.push(entry);
+    if (members.length === 0) {
+        return 'gone';
     }
-    clearRunManifest();
-    return { killed, skipped };
+    return groupHasRecordedMember(entry, members) ? 'owned' : 'unverified';
+}
+function groupHasRecordedMember(entry, members, fingerprint = native_process_group_1.captureProcessFingerprint) {
+    return entry.processGroupMembers.some((identity) => {
+        if (!members.includes(identity.pid)) {
+            return false;
+        }
+        try {
+            return fingerprint(identity.pid) === identity.processFingerprint;
+        }
+        catch {
+            return false;
+        }
+    });
+}
+function runManifestEntryProcessGroupMatches(entry, members, fingerprint = native_process_group_1.captureProcessFingerprint) {
+    return groupHasRecordedMember(entry, members, fingerprint);
+}
+function captureProcessGroupMemberIdentities(processGroupId) {
+    const members = (0, native_process_group_1.processGroupMembers)(processGroupId);
+    if (members.length === 0) {
+        throw new Error(`Cannot capture ownership for empty process group ${String(processGroupId)}.`);
+    }
+    return members.map((pid) => ({
+        pid,
+        processFingerprint: (0, native_process_group_1.captureProcessFingerprint)(pid),
+    }));
+}
+function ownershipCheckingControl(entry) {
+    return {
+        members: (processGroupId) => {
+            const members = (0, native_process_group_1.processGroupMembers)(processGroupId);
+            if (members.length === 0) {
+                return [];
+            }
+            if (!groupHasRecordedMember(entry, members)) {
+                throw new Error(`Process group ${String(processGroupId)} no longer matches recorded ownership.`);
+            }
+            return members;
+        },
+        signal: (processGroupId, signal) => {
+            const members = (0, native_process_group_1.processGroupMembers)(processGroupId);
+            if (members.length === 0) {
+                return;
+            }
+            if (!groupHasRecordedMember(entry, members)) {
+                throw new Error(`Refusing to signal process group ${String(processGroupId)} because ` +
+                    'its current members no longer match recorded birth identities.');
+            }
+            try {
+                process.kill(-processGroupId, signal);
+            }
+            catch (error) {
+                if (error.code !== 'ESRCH') {
+                    throw error;
+                }
+            }
+        },
+        wait: sleepSync,
+    };
+}
+function runManifestEntryOwnsPort(entry) {
+    const listeners = listeningPids(entry.port);
+    const members = (0, native_process_group_1.processGroupMembers)(entry.processGroupId);
+    return listeners.some((listener) => members.includes(listener));
 }
-function resolveReapPids(entry) {
-    return entry.mode === forked_worker_1.LaunchMode.Watch
-        ? resolveWatchReapPids(entry)
-        : resolveDistReapPids(entry);
+async function runManifestEntryOwnsPortAsync(entry) {
+    const [listeners, members] = await Promise.all([
+        listeningPidsAsync(entry.port),
+        (0, native_process_group_1.processGroupMembersAsync)(entry.processGroupId),
+    ]);
+    return listeners.some((listener) => members.includes(listener));
 }
-function resolveDistReapPids(entry) {
-    const command = processCommand(entry.pid);
-    if (command !== null && command.includes(FORKED_MAIN_MODULE)) {
-        return [entry.pid];
+function runManifestEntryProcessMatches(entry, fingerprint = native_process_group_1.captureProcessFingerprint) {
+    try {
+        return fingerprint(entry.pid) === entry.processFingerprint;
     }
-    if (listeningPids(entry.port).includes(entry.pid)) {
-        return [entry.pid];
+    catch {
+        return false;
     }
-    return null;
 }
-function resolveWatchReapPids(entry) {
-    const command = processCommand(entry.pid);
-    const supervisorConfirmed = command !== null && looksLikeWatchSupervisor(command);
-    const ownedListeners = listeningPids(entry.port).filter((listener) => listener === entry.pid || isDescendantOf(listener, entry.pid));
-    if (!supervisorConfirmed && ownedListeners.length === 0) {
-        return null;
+function runManifestLauncherIsActive(manifest, alive = isAlive, fingerprint = native_process_group_1.captureProcessFingerprint) {
+    return (alive(manifest.pid) &&
+        runManifestEntryProcessMatches({
+            pid: manifest.pid,
+            processFingerprint: manifest.launcherFingerprint,
+        }, fingerprint));
+}
+async function runManifestEntryProcessMatchesAsync(entry) {
+    try {
+        return ((await (0, native_process_group_1.captureProcessFingerprintAsync)(entry.pid)) ===
+            entry.processFingerprint);
+    }
+    catch {
+        return false;
     }
-    return [...new Set([entry.pid, ...ownedListeners])];
 }
 function normalizeManifest(value) {
     if (typeof value !== 'object' || value === null) {
         return undefined;
     }
     const obj = value;
-    const rawServices = Array.isArray(obj.services) ? obj.services : [];
+    if (typeof obj.installationId !== 'string' ||
+        obj.installationId.length === 0 ||
+        typeof obj.planHash !== 'string' ||
+        obj.planHash.length === 0 ||
+        typeof obj.executionId !== 'string' ||
+        obj.executionId.length === 0 ||
+        typeof obj.startedAt !== 'string' ||
+        !Number.isFinite(Date.parse(obj.startedAt)) ||
+        typeof obj.pid !== 'number' ||
+        !Number.isInteger(obj.pid) ||
+        obj.pid <= 0 ||
+        typeof obj.launcherFingerprint !== 'string' ||
+        !/^[a-f0-9]{64}$/.test(obj.launcherFingerprint) ||
+        !Array.isArray(obj.services)) {
+        return undefined;
+    }
+    const rawServices = obj.services;
     const services = [];
     for (const raw of rawServices) {
         const entry = normalizeEntry(raw);
-        if (entry) {
-            services.push(entry);
+        if (entry === undefined ||
+            entry.installationId !== obj.installationId ||
+            entry.planHash !== obj.planHash ||
+            entry.executionId !== obj.executionId) {
+            return undefined;
         }
+        services.push(entry);
     }
     return {
-        startedAt: typeof obj.startedAt === 'string' ? obj.startedAt : '',
-        pid: typeof obj.pid === 'number' ? obj.pid : 0,
+        startedAt: obj.startedAt,
+        pid: obj.pid,
+        launcherFingerprint: obj.launcherFingerprint,
+        installationId: obj.installationId,
+        planHash: obj.planHash,
+        executionId: obj.executionId,
         services,
     };
 }
@@ -163,17 +434,74 @@ function normalizeEntry(value) {
         return undefined;
     }
     const obj = value;
-    if (typeof obj.name !== 'string' || typeof obj.pid !== 'number' || typeof obj.port !== 'number') {
+    if (typeof obj.name !== 'string' ||
+        typeof obj.pid !== 'number' ||
+        typeof obj.port !== 'number' ||
+        typeof obj.installationId !== 'string' ||
+        obj.installationId.length === 0 ||
+        typeof obj.planHash !== 'string' ||
+        obj.planHash.length === 0 ||
+        typeof obj.executionId !== 'string' ||
+        obj.executionId.length === 0 ||
+        typeof obj.processFingerprint !== 'string' ||
+        !/^[a-f0-9]{64}$/.test(obj.processFingerprint) ||
+        typeof obj.processGroupId !== 'number' ||
+        !Number.isInteger(obj.processGroupId) ||
+        obj.processGroupId <= 0 ||
+        obj.processGroupId !== obj.pid ||
+        !Array.isArray(obj.processGroupMembers) ||
+        (obj.state !== RunManifestServiceState.Starting &&
+            obj.state !== RunManifestServiceState.Ready)) {
         return undefined;
     }
     if (!Number.isInteger(obj.pid) || obj.pid <= 0) {
         return undefined;
     }
+    if (!Number.isInteger(obj.port) || obj.port <= 0 || obj.port > 65_535) {
+        return undefined;
+    }
     const mode = parseLaunchMode(obj.mode);
     if (mode === undefined) {
         return undefined;
     }
-    return { name: obj.name, pid: obj.pid, port: obj.port, mode };
+    const processGroupMemberIdentities = [];
+    for (const rawIdentity of obj.processGroupMembers) {
+        const identity = normalizeProcessGroupMemberIdentity(rawIdentity);
+        if (identity === undefined) {
+            return undefined;
+        }
+        processGroupMemberIdentities.push(identity);
+    }
+    if (!processGroupMemberIdentities.some((identity) => identity.pid === obj.pid &&
+        identity.processFingerprint === obj.processFingerprint)) {
+        return undefined;
+    }
+    return {
+        name: obj.name,
+        pid: obj.pid,
+        port: obj.port,
+        installationId: obj.installationId,
+        planHash: obj.planHash,
+        executionId: obj.executionId,
+        processFingerprint: obj.processFingerprint,
+        processGroupId: obj.processGroupId,
+        processGroupMembers: processGroupMemberIdentities,
+        state: obj.state,
+        mode,
+    };
+}
+function normalizeProcessGroupMemberIdentity(value) {
+    if (typeof value !== 'object' || value === null) {
+        return undefined;
+    }
+    const obj = value;
+    return typeof obj.pid === 'number' &&
+        Number.isInteger(obj.pid) &&
+        obj.pid > 0 &&
+        typeof obj.processFingerprint === 'string' &&
+        /^[a-f0-9]{64}$/.test(obj.processFingerprint)
+        ? { pid: obj.pid, processFingerprint: obj.processFingerprint }
+        : undefined;
 }
 function parseLaunchMode(value) {
     if (value === forked_worker_1.LaunchMode.Dist || value === forked_worker_1.LaunchMode.Watch) {
@@ -193,25 +521,6 @@ function isAlive(pid) {
         return err.code === 'EPERM';
     }
 }
-function looksLikeWatchSupervisor(command) {
-    return (command.includes(WATCH_RUNNER_MARKER) &&
-        command.includes('watch') &&
-        command.includes(WATCH_TARGET_MODULE));
-}
-function processCommand(pid) {
-    try {
-        const out = (0, node_child_process_1.execFileSync)('ps', ['-p', String(pid), '-o', 'args='], {
-            encoding: 'utf8',
-            timeout: OWNERSHIP_PROBE_TIMEOUT_MS,
-            stdio: ['ignore', 'pipe', 'ignore'],
-        });
-        const line = out.trim();
-        return line.length > 0 ? line : null;
-    }
-    catch {
-        return null;
-    }
-}
 function listeningPids(port) {
     if (!Number.isInteger(port) || port <= 0) {
         return [];
@@ -233,39 +542,44 @@ function listeningPids(port) {
         return [];
     }
 }
-function parentPidOf(pid) {
-    try {
-        const out = (0, node_child_process_1.execFileSync)('ps', ['-p', String(pid), '-o', 'ppid='], {
-            encoding: 'utf8',
-            timeout: OWNERSHIP_PROBE_TIMEOUT_MS,
-            stdio: ['ignore', 'pipe', 'ignore'],
-        });
-        const ppid = Number.parseInt(out.trim(), 10);
-        return Number.isInteger(ppid) && ppid > 0 ? ppid : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-function isDescendantOf(pid, ancestor) {
-    let cursor = parentPidOf(pid);
-    let depth = 0;
-    while (cursor !== undefined && cursor > 1 && depth < MAX_ANCESTRY_DEPTH) {
-        if (cursor === ancestor) {
-            return true;
-        }
-        cursor = parentPidOf(cursor);
-        depth += 1;
+async function listeningPidsAsync(port) {
+    if (!Number.isInteger(port) || port <= 0) {
+        return [];
     }
-    return false;
-}
-function trySignal(pid, signal) {
     try {
-        process.kill(pid, signal);
+        const out = await execFileText('lsof', [
+            '-nP',
+            `-iTCP:${String(port)}`,
+            '-sTCP:LISTEN',
+            '-t',
+        ]);
+        return out
+            .split('\n')
+            .map((value) => value.trim())
+            .filter((value) => value.length > 0)
+            .map((value) => Number.parseInt(value, 10))
+            .filter((value) => Number.isInteger(value) && value > 0);
     }
     catch {
+        return [];
     }
 }
+function execFileText(command, args) {
+    return new Promise((resolve, reject) => {
+        (0, node_child_process_1.execFile)(command, [...args], {
+            encoding: 'utf8',
+            timeout: OWNERSHIP_PROBE_TIMEOUT_MS,
+            killSignal: 'SIGKILL',
+            maxBuffer: 1024 * 1024,
+        }, (error, stdout) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve(stdout);
+        });
+    });
+}
 function sleepSync(ms) {
     const signal = new Int32Array(new SharedArrayBuffer(4));
     Atomics.wait(signal, 0, 0, ms);