@ape-egg/vibe-compiler 4.3.9 → 4.3.11

package/bin/vibe-compile.js

@@ -45,6 +45,8 @@ const wireLifecycle = (child) => {
   process.on('exit', () => child.kill());
 };
 
+const launcherArgs = ['--launcher', String(process.ppid)];
+
 const run = () => {
   const binary = getPlatformBinary();
   const binaryPath = join(nativeDir, binary);
@@ -78,7 +80,7 @@ const run = () => {
     }
 
     // Pass --cwd to tell the Rust binary the original working directory
-    const cargoArgs = ['run', '--release', '--', '--cwd', originalCwd, ...userArgs];
+    const cargoArgs = ['run', '--release', '--', '--cwd', originalCwd, ...launcherArgs, ...userArgs];
 
     const cargo = spawn('cargo', cargoArgs, {
       cwd: srcDir,
@@ -103,7 +105,7 @@ const run = () => {
   }
 
   // Run the native binary (it runs in the user's cwd, so no --cwd needed)
-  const child = spawn(binaryPath, userArgs, {
+  const child = spawn(binaryPath, [...launcherArgs, ...userArgs], {
     stdio: 'inherit',
   });
   wireLifecycle(child);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ape-egg/vibe-compiler",
-  "version": "4.3.9",
+  "version": "4.3.11",
   "type": "module",
   "description": "Optional Rust compiler for Vibe \u2014 pre-renders, inlines components, and optimizes iterations. The runtime never needs it.",
   "homepage": "https://vibe.korte.kim",

package/src/Cargo.lock

@@ -1599,12 +1599,13 @@ checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
 
 [[package]]
 name = "vibe-compiler"
-version = "4.3.9"
+version = "4.3.11"
 dependencies = [
  "clap",
  "colored",
  "glob",
  "html5ever",
+ "libc",
  "markup5ever",
  "markup5ever_rcdom",
  "notify",

package/src/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "vibe-compiler"
-version = "4.3.9"
+version = "4.3.11"
 edition = "2021"
 description = "Vibe framework compiler - compiles Vibe source files into optimized output"
 authors = ["Kim Korte"]
@@ -30,6 +30,7 @@ swc_ecma_visit = "=0.107.0"
 notify = "6.1"
 notify-debouncer-full = "0.3"
 rayon = "1.10"
+libc = "0.2"
 
 [profile.release]
 opt-level = 3

package/src/compiler/mod.rs

@@ -9,6 +9,7 @@ mod component_tagger;
 mod binding_case;
 mod name_binding_protect;
 mod reassignment_analyzer;
+mod shutdown;
 pub mod watcher;
 
 pub use compile::Compiler;

package/src/compiler/shutdown.rs

@@ -0,0 +1,110 @@
+use std::path::PathBuf;
+
+#[cfg(unix)]
+const SIGNALS: [libc::c_int; 3] = [libc::SIGINT, libc::SIGTERM, libc::SIGHUP];
+
+#[cfg(unix)]
+fn signal_set() -> libc::sigset_t {
+    unsafe {
+        let mut set = std::mem::zeroed();
+        libc::sigemptyset(&mut set);
+        SIGNALS.iter().for_each(|&sig| {
+            libc::sigaddset(&mut set, sig);
+        });
+        set
+    }
+}
+
+#[cfg(unix)]
+fn release(lock: &PathBuf, reason: &str, code: i32) -> ! {
+    let _ = std::fs::remove_file(lock);
+    eprintln!("{} — shutting down watcher", reason);
+    std::process::exit(code)
+}
+
+#[cfg(unix)]
+pub fn block() -> u32 {
+    unsafe { libc::pthread_sigmask(libc::SIG_BLOCK, &signal_set(), std::ptr::null_mut()) };
+    std::os::unix::process::parent_id()
+}
+
+#[cfg(target_os = "macos")]
+pub fn release_on_exit(parent: u32, launcher: Option<u32>, lock: PathBuf) {
+    let event = |ident: usize, filter: i16, fflags: u32| libc::kevent {
+        ident,
+        filter,
+        flags: libc::EV_ADD,
+        fflags,
+        data: 0,
+        udata: std::ptr::null_mut(),
+    };
+    let watched: Vec<libc::kevent> = SIGNALS
+        .iter()
+        .map(|&sig| event(sig as usize, libc::EVFILT_SIGNAL, 0))
+        .chain(
+            std::iter::once(parent)
+                .chain(launcher)
+                .map(|pid| event(pid as usize, libc::EVFILT_PROC, libc::NOTE_EXIT)),
+        )
+        .collect();
+    let queue = unsafe { libc::kqueue() };
+    let registered = unsafe {
+        libc::kevent(queue, watched.as_ptr(), watched.len() as i32, std::ptr::null_mut(), 0, std::ptr::null())
+    };
+    if registered == -1 || std::os::unix::process::parent_id() != parent {
+        release(&lock, "parent process exited", 0);
+    }
+    std::thread::spawn(move || {
+        let mut fired = event(0, 0, 0);
+        unsafe { libc::kevent(queue, std::ptr::null(), 0, &mut fired, 1, std::ptr::null()) };
+        match fired.filter {
+            libc::EVFILT_SIGNAL => release(&lock, "received shutdown signal", 128 + fired.ident as i32),
+            _ if fired.ident == parent as usize => release(&lock, "parent process exited", 0),
+            _ => release(&lock, "launcher process exited", 0),
+        }
+    });
+}
+
+#[cfg(target_os = "linux")]
+fn release_on_launcher_exit(launcher: u32, lock: &PathBuf) {
+    match unsafe { libc::syscall(libc::SYS_pidfd_open, launcher, 0) } as libc::c_int {
+        -1 if std::io::Error::last_os_error().raw_os_error() == Some(libc::ESRCH) => {
+            release(lock, "launcher process exited", 0)
+        }
+        -1 => {}
+        pidfd => {
+            let lock = lock.clone();
+            std::thread::spawn(move || {
+                let mut exited = libc::pollfd { fd: pidfd, events: libc::POLLIN, revents: 0 };
+                unsafe { libc::poll(&mut exited, 1, -1) };
+                release(&lock, "launcher process exited", 0)
+            });
+        }
+    }
+}
+
+#[cfg(all(unix, not(target_os = "macos")))]
+pub fn release_on_exit(parent: u32, launcher: Option<u32>, lock: PathBuf) {
+    #[cfg(target_os = "linux")]
+    unsafe {
+        libc::prctl(libc::PR_SET_PDEATHSIG, libc::SIGHUP)
+    };
+    if std::os::unix::process::parent_id() != parent {
+        release(&lock, "parent process exited", 0);
+    }
+    #[cfg(target_os = "linux")]
+    launcher.iter().for_each(|&pid| release_on_launcher_exit(pid, &lock));
+    std::thread::spawn(move || {
+        let mut sig = 0;
+        unsafe { libc::sigwait(&signal_set(), &mut sig) };
+        release(&lock, "received shutdown signal", 128 + sig)
+    });
+}
+
+#[cfg(not(unix))]
+pub fn block() -> u32 {
+    0
+}
+
+#[cfg(not(unix))]
+pub fn release_on_exit(_parent: u32, _launcher: Option<u32>, _lock: PathBuf) {}

package/src/compiler/watcher.rs

@@ -6,7 +6,7 @@ use colored::Colorize;
 use notify_debouncer_full::{new_debouncer, notify::{RecursiveMode, Watcher}};
 use regex::Regex;
 
-use super::{Compiler, compile::should_skip_path};
+use super::{Compiler, compile::should_skip_path, shutdown};
 use crate::config::Config;
 use crate::constants::{HYPERSPEED_DIR, MANIFEST_SUFFIX};
 
@@ -406,27 +406,6 @@ fn scan_directory(
     Ok(())
 }
 
-/// A watcher whose spawning wrapper dies without unwinding (SIGKILL, crashed
-/// dev server) is orphaned: it keeps watching and its lock blocks every future
-/// `--watch` on the same output. Reparenting is the orphan signal — when the
-/// parent pid changes (to init or a reaper), the owner is gone, so release the
-/// lock and exit. `std::process::exit` skips Drop, hence the explicit remove.
-#[cfg(unix)]
-fn exit_when_orphaned(lock_path: PathBuf) {
-    let parent = std::os::unix::process::parent_id();
-    std::thread::spawn(move || loop {
-        std::thread::sleep(Duration::from_secs(2));
-        if std::os::unix::process::parent_id() != parent {
-            eprintln!("parent process exited — shutting down watcher");
-            let _ = std::fs::remove_file(&lock_path);
-            std::process::exit(0);
-        }
-    });
-}
-
-#[cfg(not(unix))]
-fn exit_when_orphaned(_lock_path: PathBuf) {}
-
 /// A config change invalidates every piece of watcher state — dependency
 /// graph, compiler, parser, watch roots, output lock. The cleanest
 /// expression is a fresh start: release the lock and exec the same binary
@@ -461,11 +440,12 @@ fn restart_with_fresh_config(lock: WatchLock) -> ! {
 }
 
 /// Start watching for file changes
-pub fn watch(config: Config, verbose: bool) -> std::result::Result<(), Box<dyn std::error::Error>> {
+pub fn watch(config: Config, verbose: bool, launcher: Option<u32>) -> std::result::Result<(), Box<dyn std::error::Error>> {
     // Held for the watcher's whole lifetime; a second watcher on the same
     // output exits loudly instead of silently racing this one.
+    let parent = shutdown::block();
     let _watch_lock = WatchLock::acquire(&config.output)?;
-    exit_when_orphaned(_watch_lock.path.clone());
+    shutdown::release_on_exit(parent, launcher, _watch_lock.path.clone());
 
     println!("{}", "Building dependency graph...".cyan());
     let mut graph = build_dependency_graph(&config)?;

package/src/main.rs

@@ -98,6 +98,10 @@ struct Args {
     /// Compile the pages tree to SPA output: fragments + route table + shell
     #[arg(long)]
     spa: bool,
+
+    /// Pid of the process that launched the wrapper; --watch also exits when it does
+    #[arg(long, hide = true)]
+    launcher: Option<u32>,
 }
 
 fn main() {
@@ -256,7 +260,7 @@ fn main() {
 
     // Handle watch mode
     if args.watch {
-        if let Err(e) = compiler::watcher::watch(config, args.verbose) {
+        if let Err(e) = compiler::watcher::watch(config, args.verbose, args.launcher) {
             eprintln!("{}: {}", "Error".red(), e);
             std::process::exit(1);
         }