@ape-egg/vibe-compiler 4.3.10 → 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.10",
+  "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,7 +1599,7 @@ checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
 
 [[package]]
 name = "vibe-compiler"
-version = "4.3.10"
+version = "4.3.11"
 dependencies = [
  "clap",
  "colored",

package/src/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "vibe-compiler"
-version = "4.3.10"
+version = "4.3.11"
 edition = "2021"
 description = "Vibe framework compiler - compiles Vibe source files into optimized output"
 authors = ["Kim Korte"]

package/src/compiler/shutdown.rs

@@ -29,7 +29,7 @@ pub fn block() -> u32 {
 }
 
 #[cfg(target_os = "macos")]
-pub fn release_on_exit(parent: u32, lock: PathBuf) {
+pub fn release_on_exit(parent: u32, launcher: Option<u32>, lock: PathBuf) {
     let event = |ident: usize, filter: i16, fflags: u32| libc::kevent {
         ident,
         filter,
@@ -41,7 +41,11 @@ pub fn release_on_exit(parent: u32, lock: PathBuf) {
     let watched: Vec<libc::kevent> = SIGNALS
         .iter()
         .map(|&sig| event(sig as usize, libc::EVFILT_SIGNAL, 0))
-        .chain([event(parent as usize, libc::EVFILT_PROC, libc::NOTE_EXIT)])
+        .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 {
@@ -55,13 +59,32 @@ pub fn release_on_exit(parent: u32, lock: PathBuf) {
         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),
-            _ => release(&lock, "parent process exited", 0),
+            _ 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, lock: PathBuf) {
+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)
@@ -69,6 +92,8 @@ pub fn release_on_exit(parent: u32, lock: PathBuf) {
     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) };
@@ -82,4 +107,4 @@ pub fn block() -> u32 {
 }
 
 #[cfg(not(unix))]
-pub fn release_on_exit(_parent: u32, _lock: PathBuf) {}
+pub fn release_on_exit(_parent: u32, _launcher: Option<u32>, _lock: PathBuf) {}

package/src/compiler/watcher.rs

@@ -440,12 +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)?;
-    shutdown::release_on_exit(parent, _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);
         }