vouchington-tooling 0.0.8 → 0.0.9

package/dist/pnpm-install/native-health.d.mts

@@ -0,0 +1,4 @@
+export type NativeFamily = 'elf' | 'macho' | 'pe';
+export declare function nativeFamilyFromMagic(buffer: Buffer): NativeFamily | undefined;
+export declare function expectedNativeFamily(platform?: NodeJS.Platform): NativeFamily | undefined;
+export declare function nativeBinariesMatchRuntime(root?: string, platform?: NodeJS.Platform): Promise<boolean>;

package/dist/pnpm-install/native-health.mjs

@@ -0,0 +1,84 @@
+import { glob, open, stat } from 'node:fs/promises';
+import path from 'node:path';
+const ELF = Buffer.from([0x7f, 0x45, 0x4c, 0x46]);
+const PE = Buffer.from([0x4d, 0x5a]);
+const MACHO = [
+    Buffer.from([0xcf, 0xfa, 0xed, 0xfe]),
+    Buffer.from([0xfe, 0xed, 0xfa, 0xcf]),
+    Buffer.from([0xce, 0xfa, 0xed, 0xfe]),
+    Buffer.from([0xfe, 0xed, 0xfa, 0xce]),
+    Buffer.from([0xca, 0xfe, 0xba, 0xbe]),
+    Buffer.from([0xbe, 0xba, 0xfe, 0xca]),
+];
+function startsWith(buffer, magic) {
+    return buffer.length >= magic.length && buffer.subarray(0, magic.length).equals(magic);
+}
+export function nativeFamilyFromMagic(buffer) {
+    if (startsWith(buffer, ELF))
+        return 'elf';
+    if (MACHO.some((magic) => startsWith(buffer, magic)))
+        return 'macho';
+    if (startsWith(buffer, PE))
+        return 'pe';
+    return undefined;
+}
+export function expectedNativeFamily(platform = process.platform) {
+    if (platform === 'linux')
+        return 'elf';
+    if (platform === 'darwin')
+        return 'macho';
+    if (platform === 'win32')
+        return 'pe';
+    return undefined;
+}
+async function readMagic(pathname) {
+    let handle;
+    try {
+        handle = await open(pathname, 'r');
+        const buffer = Buffer.alloc(4);
+        const { bytesRead } = await handle.read(buffer, 0, 4, 0);
+        return bytesRead === 0 ? undefined : buffer.subarray(0, bytesRead);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return undefined;
+        throw error;
+    }
+    finally {
+        await handle?.close();
+    }
+}
+async function searchRoot(nodeModules) {
+    const pnpmStore = path.join(nodeModules, '.pnpm');
+    try {
+        const info = await stat(pnpmStore);
+        return info.isDirectory() ? pnpmStore : nodeModules;
+    }
+    catch {
+        return nodeModules;
+    }
+}
+export async function nativeBinariesMatchRuntime(root = process.cwd(), platform = process.platform) {
+    const expected = expectedNativeFamily(platform);
+    if (expected === undefined)
+        return true;
+    const nodeModules = path.join(root, 'node_modules');
+    try {
+        const info = await stat(nodeModules);
+        if (!info.isDirectory())
+            return true;
+    }
+    catch {
+        return true;
+    }
+    const cwd = await searchRoot(nodeModules);
+    for await (const relative of glob('**/*.{node,bin}', { cwd })) {
+        const magic = await readMagic(path.join(cwd, relative));
+        if (magic === undefined)
+            continue;
+        const family = nativeFamilyFromMagic(magic);
+        if (family !== undefined && family !== expected)
+            return false;
+    }
+    return true;
+}

package/dist/pnpm-install/runner.mjs

@@ -1,5 +1,6 @@
 import { scheduler } from 'node:timers/promises';
 import { persistentDependencyTreeIsCold, persistentMetadataFingerprint, persistentMetadataMatches, writePersistentMetadataStamp, } from './metadata.mjs';
+import { nativeBinariesMatchRuntime } from './native-health.mjs';
 import { runPnpm } from './exec.mjs';
 import { INSTALL_TERMINATION_FAILED } from './process.mjs';
 import { formatReleaseAgeFailure, isReleaseAgeViolation } from './release-age.mjs';
@@ -47,11 +48,15 @@ async function persistent(options) {
     const runCapture = (args) => runPnpm(args, options, true);
     const fingerprint = await persistentMetadataFingerprint(runCapture, options.installScripts);
     const stamped = await persistentMetadataMatches(fingerprint);
+    const nativesMatch = await nativeBinariesMatchRuntime();
+    const provenanceOk = stamped && nativesMatch;
     // An absent tree has nothing to repair, so one ordinary install below matches the
     // reconciled end state. Check first: an install would otherwise make the tree non-cold.
-    const cold = !stamped && (await persistentDependencyTreeIsCold());
-    if (!stamped && !cold) {
-        console.warn('persistent dependency metadata provenance is missing or changed; reconciling');
+    const cold = !provenanceOk && (await persistentDependencyTreeIsCold());
+    if (!provenanceOk && !cold) {
+        console.warn(stamped && !nativesMatch
+            ? 'persistent optional native binaries do not match this runtime; reconciling'
+            : 'persistent dependency metadata provenance is missing or changed; reconciling');
         await reconcileOrFail(options, runCapture);
         await writePersistentMetadataStamp(fingerprint);
         return 'persistent metadata reconciled';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vouchington-tooling",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "description": "Vouchington CLI and extractable tooling libraries.",
   "homepage": "https://github.com/vouchington/vouchington-tooling/tree/main/packages/vouchington-tooling#readme",
   "bugs": {

package/scripts/allocate-browser-safe-ports.py

@@ -211,6 +211,7 @@ SCRIPT_NAME = "allocate-browser-safe-ports.py"
 HOLD_POLL_SECONDS = 0.05
 HOLD_READY_TIMEOUT_SECONDS = 2.0
 CONTROL_WAIT_SECONDS = 2.0
+OWNER_PROBE_SECONDS = 0.4
 
 
 def resolve_workspace(workspace: str) -> str:
@@ -560,6 +561,90 @@ def port_is_bindable(port: int) -> bool:
         probe.close()
 
 
+def run_owner_probe(command: list[str]) -> str:
+    try:
+        result = subprocess.run(
+            command,
+            capture_output=True,
+            text=True,
+            check=False,
+            timeout=OWNER_PROBE_SECONDS,
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return ""
+    return result.stdout
+
+
+def compact_probe_text(output: str) -> str:
+    lines = [line.strip() for line in output.splitlines() if line.strip()]
+    return " | ".join(lines)[:200]
+
+
+def pids_holding_port(port: int) -> list[int]:
+    pids: list[int] = []
+    seen: set[int] = set()
+    for raw in run_owner_probe(["lsof", "-nP", "-t", f"-iTCP:{port}"]).split():
+        if not raw.isdigit():
+            continue
+        pid = int(raw)
+        if pid in seen:
+            continue
+        seen.add(pid)
+        pids.append(pid)
+    if pids:
+        return pids
+    for token in run_owner_probe(["ss", "-ntp", f"( sport = :{port} )"]).replace(",", " ").split():
+        if not token.startswith("pid="):
+            continue
+        raw_pid = token[4:].split(")")[0]
+        if not raw_pid.isdigit():
+            continue
+        pid = int(raw_pid)
+        if pid in seen:
+            continue
+        seen.add(pid)
+        pids.append(pid)
+    return pids
+
+
+def sibling_allocator_owner(port: int, excluded_pid: int | None) -> tuple[int, str] | None:
+    for owner_pid in pids_holding_port(port):
+        if excluded_pid is not None and owner_pid == excluded_pid:
+            continue
+        command = process_command_line(owner_pid)
+        if command is None or SCRIPT_NAME not in command:
+            continue
+        return owner_pid, command
+    return None
+
+
+def describe_port_owner(port: int) -> str:
+    pids = pids_holding_port(port)
+    if pids:
+        details: list[str] = []
+        for owner_pid in pids:
+            command = process_command_line(owner_pid) or "unknown"
+            details.append(f"pid {owner_pid} {command}")
+        return compact_probe_text("; ".join(details))
+    lsof_text = compact_probe_text(run_owner_probe(["lsof", "-nP", f"-iTCP:{port}"]))
+    if lsof_text:
+        return f"lsof {lsof_text}"
+    ss_text = compact_probe_text(run_owner_probe(["ss", "-ntp", f"( sport = :{port} )"]))
+    if ss_text:
+        lowered = ss_text.lower()
+        if "time-wait" in lowered or "time_wait" in lowered:
+            return f"TIME_WAIT {ss_text}"
+        return f"ss {ss_text}"
+    return "no owner"
+
+
+def report_sibling_owner(port: int, owner_pid: int, command: str) -> None:
+    print(
+        f"port {port} still held by pid {owner_pid} ({command}); leaving owner in place",
+        file=sys.stderr,
+    )
+
+
 def wait_until_port_bindable(port: int) -> None:
     deadline = time.monotonic() + CONTROL_WAIT_SECONDS
     while time.monotonic() < deadline:
@@ -569,6 +654,29 @@ def wait_until_port_bindable(port: int) -> None:
     raise RuntimeError(f"port {port} did not become bindable")
 
 
+def wait_until_port_bindable_or_sibling(port: int, excluded_pid: int | None) -> None:
+    deadline = time.monotonic() + CONTROL_WAIT_SECONDS
+    probed = False
+    while time.monotonic() < deadline:
+        if port_is_bindable(port):
+            return
+        if not probed:
+            sibling = sibling_allocator_owner(port, excluded_pid)
+            if sibling is not None:
+                report_sibling_owner(port, sibling[0], sibling[1])
+                return
+            probed = True
+        time.sleep(HOLD_POLL_SECONDS)
+    sibling = sibling_allocator_owner(port, excluded_pid)
+    if sibling is not None:
+        report_sibling_owner(port, sibling[0], sibling[1])
+        return
+    occupancy = describe_port_owner(port)
+    raise RuntimeError(
+        f"port {port} did not become bindable after {CONTROL_WAIT_SECONDS}s ({occupancy})"
+    )
+
+
 def request_release(hold_dir: Path, port: int) -> None:
     hold_dir = hold_dir.resolve()
     release_path = hold_dir / "release" / str(port)
@@ -592,9 +700,11 @@ def request_stop(hold_dir: Path, workspace: str) -> None:
     (hold_dir / "stop").write_text("1")
     pid_path = hold_dir / "pid"
     pid = read_pid(pid_path) if pid_path.is_file() else None
+    stopped_live_holder = False
     if pid is not None and pid_is_alive(pid) and is_our_holder(pid, workspace):
         try:
             os.kill(pid, signal.SIGTERM)
+            stopped_live_holder = True
         except ProcessLookupError:
             pass
     deadline = time.monotonic() + CONTROL_WAIT_SECONDS
@@ -607,8 +717,10 @@ def request_stop(hold_dir: Path, workspace: str) -> None:
     if successor is not None and successor != pid:
         # A replacement holder for this workspace already reaped us and took the ports.
         return
+    if not stopped_live_holder:
+        return
     for port in remaining:
-        wait_until_port_bindable(port)
+        wait_until_port_bindable_or_sibling(port, pid)
 
 
 def check_holder(hold_dir: Path, workspace: str) -> None: