dnx_core/

hooks.rs

//! Hook system for `.pnpmfile.cjs` compatibility.
//!
//! Launches a long-lived Node.js child process that loads the user's
//! `.pnpmfile.cjs` and communicates via JSON-over-stdin/stdout IPC.
//! This amortizes the ~30ms Node.js startup cost across all packages.

use crate::errors::{DnxError, Result};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::io::{BufRead, BufReader, Write};
use std::path::{Path, PathBuf};
use std::process::{Child, Command, Stdio};
use tracing::{debug, warn};

// ---------------------------------------------------------------------------
// Embedded JS worker script
// ---------------------------------------------------------------------------

const WORKER_SCRIPT: &str = r#"
'use strict';
const path = require('path');
const readline = require('readline');

const pnpmfilePath = process.argv[2];
let hooks;
try {
    hooks = require(path.resolve(pnpmfilePath));
} catch (e) {
    process.stderr.write('dnx-hook: failed to load ' + pnpmfilePath + ': ' + e.message + '\n');
    process.exit(1);
}

const context = {
    log: function(msg) {
        process.stderr.write('dnx-hook: ' + msg + '\n');
    }
};

const rl = readline.createInterface({ input: process.stdin, terminal: false });

rl.on('line', async (line) => {
    let request;
    try {
        request = JSON.parse(line);
    } catch (e) {
        process.stdout.write(JSON.stringify({ error: 'Invalid JSON: ' + e.message }) + '\n');
        return;
    }

    try {
        if (request.type === 'readPackage') {
            if (hooks.hooks && typeof hooks.hooks.readPackage === 'function') {
                let result = hooks.hooks.readPackage(request.pkg, context);
                if (result && typeof result.then === 'function') {
                    result = await result;
                }
                process.stdout.write(JSON.stringify({ pkg: result || request.pkg }) + '\n');
            } else {
                process.stdout.write(JSON.stringify({ pkg: request.pkg }) + '\n');
            }
        } else if (request.type === 'afterAllResolved') {
            if (hooks.hooks && typeof hooks.hooks.afterAllResolved === 'function') {
                let result = hooks.hooks.afterAllResolved(request.lockfile, context);
                if (result && typeof result.then === 'function') {
                    result = await result;
                }
                process.stdout.write(JSON.stringify({ lockfile: result || request.lockfile }) + '\n');
            } else {
                process.stdout.write(JSON.stringify({ lockfile: request.lockfile }) + '\n');
            }
        } else if (request.type === 'ping') {
            process.stdout.write(JSON.stringify({ pong: true }) + '\n');
        } else {
            process.stdout.write(JSON.stringify({ error: 'Unknown request type' }) + '\n');
        }
    } catch (e) {
        process.stdout.write(JSON.stringify({ error: e.message }) + '\n');
    }
});

rl.on('close', () => process.exit(0));
"#;

// ---------------------------------------------------------------------------
// Public types
// ---------------------------------------------------------------------------

/// Serializable package metadata sent to/from hooks.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct HookPackage {
    pub name: String,
    pub version: String,
    #[serde(default, skip_serializing_if = "HashMap::is_empty")]
    pub dependencies: HashMap<String, String>,
    #[serde(
        rename = "devDependencies",
        default,
        skip_serializing_if = "HashMap::is_empty"
    )]
    pub dev_dependencies: HashMap<String, String>,
    #[serde(
        rename = "peerDependencies",
        default,
        skip_serializing_if = "HashMap::is_empty"
    )]
    pub peer_dependencies: HashMap<String, String>,
    #[serde(
        rename = "optionalDependencies",
        default,
        skip_serializing_if = "HashMap::is_empty"
    )]
    pub optional_dependencies: HashMap<String, String>,
}

/// Hook system — either active (with a running Node.js worker) or no-op.
pub enum Hooks {
    /// Hooks are active — `.pnpmfile.cjs` is loaded in a child process.
    Active(HookRunner),
    /// No hooks configured — all calls are no-ops.
    Noop,
}

impl Hooks {
    /// Detect and initialize hooks for a project.
    ///
    /// - If `pnpmfile_config` is `Some("false")`, hooks are disabled.
    /// - If `pnpmfile_config` is `Some(path)`, that path is used.
    /// - If `pnpmfile_config` is `None`, auto-detects `.pnpmfile.cjs` in `project_root`.
    pub fn detect(project_root: &Path, pnpmfile_config: Option<&str>) -> Self {
        match pnpmfile_config {
            Some("false") => {
                debug!("Hooks disabled by configuration");
                Hooks::Noop
            }
            Some(path) => {
                let pnpmfile_path = if Path::new(path).is_absolute() {
                    PathBuf::from(path)
                } else {
                    project_root.join(path)
                };
                if pnpmfile_path.exists() {
                    match HookRunner::new(&pnpmfile_path) {
                        Ok(runner) => {
                            debug!("Hooks loaded from {}", pnpmfile_path.display());
                            Hooks::Active(runner)
                        }
                        Err(e) => {
                            warn!("Failed to start hook runner: {}", e);
                            Hooks::Noop
                        }
                    }
                } else {
                    warn!("Configured pnpmfile not found: {}", pnpmfile_path.display());
                    Hooks::Noop
                }
            }
            None => {
                let default_path = project_root.join(".pnpmfile.cjs");
                if default_path.exists() {
                    match HookRunner::new(&default_path) {
                        Ok(runner) => {
                            debug!("Hooks loaded from .pnpmfile.cjs");
                            Hooks::Active(runner)
                        }
                        Err(e) => {
                            warn!("Failed to start hook runner: {}", e);
                            Hooks::Noop
                        }
                    }
                } else {
                    Hooks::Noop
                }
            }
        }
    }

    /// Run `readPackage` hook on a package's metadata.
    /// Returns the (possibly modified) package metadata.
    pub fn read_package(&mut self, pkg: HookPackage) -> Result<HookPackage> {
        match self {
            Hooks::Active(runner) => runner.read_package(pkg),
            Hooks::Noop => Ok(pkg),
        }
    }

    /// Run `afterAllResolved` hook on the lockfile content.
    /// Returns the (possibly modified) lockfile string.
    pub fn after_all_resolved(&mut self, lockfile: &str) -> Result<String> {
        match self {
            Hooks::Active(runner) => runner.after_all_resolved(lockfile),
            Hooks::Noop => Ok(lockfile.to_string()),
        }
    }

    /// Returns true if hooks are active.
    pub fn is_active(&self) -> bool {
        matches!(self, Hooks::Active(_))
    }
}

// ---------------------------------------------------------------------------
// HookRunner — manages the Node.js child process
// ---------------------------------------------------------------------------

pub struct HookRunner {
    child: Child,
    stdin: Option<std::process::ChildStdin>,
    reader: BufReader<std::process::ChildStdout>,
}

/// IPC request types
#[derive(Serialize)]
#[serde(tag = "type")]
enum HookRequest {
    #[serde(rename = "readPackage")]
    ReadPackage { pkg: Box<HookPackage> },
    #[serde(rename = "afterAllResolved")]
    AfterAllResolved { lockfile: String },
    #[serde(rename = "ping")]
    Ping,
}

/// IPC response types
#[derive(Deserialize)]
struct ReadPackageResponse {
    pkg: Option<HookPackage>,
    error: Option<String>,
}

#[derive(Deserialize)]
struct AfterAllResolvedResponse {
    lockfile: Option<String>,
    error: Option<String>,
}

#[derive(Deserialize)]
struct PingResponse {
    pong: Option<bool>,
    error: Option<String>,
}

impl HookRunner {
    /// Spawn a Node.js worker process that loads the given `.pnpmfile.cjs`.
    pub fn new(pnpmfile_path: &Path) -> Result<Self> {
        // Write worker script to a temp file
        let temp_dir = std::env::temp_dir();
        let worker_path = temp_dir.join("dnx-hook-worker.js");
        std::fs::write(&worker_path, WORKER_SCRIPT)
            .map_err(|e| DnxError::Hook(format!("Failed to write hook worker script: {}", e)))?;

        let mut child = Command::new("node")
            .arg(&worker_path)
            .arg(pnpmfile_path)
            .stdin(Stdio::piped())
            .stdout(Stdio::piped())
            .stderr(Stdio::inherit()) // Hook logs go to stderr
            .spawn()
            .map_err(|e| {
                DnxError::Hook(format!(
                    "Failed to spawn Node.js for hooks (is Node.js installed?): {}",
                    e
                ))
            })?;

        let stdin = child
            .stdin
            .take()
            .ok_or_else(|| DnxError::Hook("Failed to capture hook worker stdin".to_string()))?;
        let stdout = child
            .stdout
            .take()
            .ok_or_else(|| DnxError::Hook("Failed to capture hook worker stdout".to_string()))?;
        let reader = BufReader::new(stdout);

        let mut runner = Self {
            child,
            stdin: Some(stdin),
            reader,
        };

        // Verify the worker is alive with a ping
        runner.ping()?;

        Ok(runner)
    }

    fn ping(&mut self) -> Result<()> {
        let request = serde_json::to_string(&HookRequest::Ping)
            .map_err(|e| DnxError::Hook(format!("Failed to serialize ping: {}", e)))?;

        self.send_line(&request)?;
        let response_line = self.read_line()?;

        let response: PingResponse = serde_json::from_str(&response_line)
            .map_err(|e| DnxError::Hook(format!("Failed to parse ping response: {}", e)))?;

        if let Some(err) = response.error {
            return Err(DnxError::Hook(format!("Hook worker error: {}", err)));
        }

        if response.pong != Some(true) {
            return Err(DnxError::Hook(
                "Hook worker did not respond to ping".to_string(),
            ));
        }

        Ok(())
    }

    fn read_package(&mut self, pkg: HookPackage) -> Result<HookPackage> {
        let request = serde_json::to_string(&HookRequest::ReadPackage {
            pkg: Box::new(pkg.clone()),
        })
        .map_err(|e| DnxError::Hook(format!("Failed to serialize readPackage: {}", e)))?;

        self.send_line(&request)?;
        let response_line = self.read_line()?;

        let response: ReadPackageResponse = serde_json::from_str(&response_line)
            .map_err(|e| DnxError::Hook(format!("Failed to parse readPackage response: {}", e)))?;

        if let Some(err) = response.error {
            return Err(DnxError::Hook(format!("readPackage hook error: {}", err)));
        }

        Ok(response.pkg.unwrap_or(pkg))
    }

    fn after_all_resolved(&mut self, lockfile: &str) -> Result<String> {
        let request = serde_json::to_string(&HookRequest::AfterAllResolved {
            lockfile: lockfile.to_string(),
        })
        .map_err(|e| DnxError::Hook(format!("Failed to serialize afterAllResolved: {}", e)))?;

        self.send_line(&request)?;
        let response_line = self.read_line()?;

        let response: AfterAllResolvedResponse =
            serde_json::from_str(&response_line).map_err(|e| {
                DnxError::Hook(format!("Failed to parse afterAllResolved response: {}", e))
            })?;

        if let Some(err) = response.error {
            return Err(DnxError::Hook(format!(
                "afterAllResolved hook error: {}",
                err
            )));
        }

        Ok(response.lockfile.unwrap_or_else(|| lockfile.to_string()))
    }

    fn send_line(&mut self, line: &str) -> Result<()> {
        let stdin = self
            .stdin
            .as_mut()
            .ok_or_else(|| DnxError::Hook("Hook worker stdin is closed".to_string()))?;
        writeln!(stdin, "{}", line)
            .map_err(|e| DnxError::Hook(format!("Failed to write to hook worker: {}", e)))?;
        stdin
            .flush()
            .map_err(|e| DnxError::Hook(format!("Failed to flush hook worker stdin: {}", e)))?;
        Ok(())
    }

    fn read_line(&mut self) -> Result<String> {
        let mut line = String::new();
        self.reader
            .read_line(&mut line)
            .map_err(|e| DnxError::Hook(format!("Failed to read from hook worker: {}", e)))?;
        if line.is_empty() {
            return Err(DnxError::Hook(
                "Hook worker process exited unexpectedly".to_string(),
            ));
        }
        Ok(line.trim().to_string())
    }
}

impl Drop for HookRunner {
    fn drop(&mut self) {
        // Close stdin to signal the worker to exit
        self.stdin.take();

        // Wait up to 2 seconds for the child to exit gracefully.
        // If it's stuck (e.g. after Ctrl+C), kill it to avoid orphans.
        let deadline = std::time::Instant::now() + std::time::Duration::from_secs(2);
        loop {
            match self.child.try_wait() {
                Ok(Some(_)) => break, // exited
                Ok(None) => {
                    // still running
                    if std::time::Instant::now() >= deadline {
                        warn!("Hook worker did not exit in 2s, killing");
                        let _ = self.child.kill();
                        let _ = self.child.wait();
                        break;
                    }
                    std::thread::sleep(std::time::Duration::from_millis(50));
                }
                Err(_) => break, // error querying status
            }
        }
    }
}