RFC: Introduce bundle serve command.

crates/bundles/src/cache.rs

@@ -658,6 +658,10 @@
             InputOrigin::Other,
         ))
     }
+
+    fn input_path(&mut self, name: &str, status: &mut dyn StatusBackend) -> OpenResult<PathBuf> {
+        self.ensure_file_availability(name, status)
+    }
 }
 
 impl<CB: CacheBackend> Bundle for CachingBundle<CB> {

crates/io_base/src/lib.rs

@@ -485,6 +485,15 @@
         }
     }
 
+    /// Return the path of an input file if it happens to be stored on the file system.
+    ///
+    /// A minimal implementation can always return [`OpenResult::NotAvailable`].
+    /// If a file is on the file system, it is preferred by the "bundle serve" command to return a
+    /// local path rather than dumping the contents.
+    fn input_path(&mut self, _name: &str, _status: &mut dyn StatusBackend) -> OpenResult<PathBuf> {
+        OpenResult::NotAvailable
+    }
+
     /// Open the "primary" input file, which in the context of TeX is the main
     /// input that it's given. When the build is being done using the
     /// filesystem and the input is a file on the filesystem, this function

src/bin/tectonic/v2cli/commands/bundle.rs

@@ -1,8 +1,10 @@
 use clap::{Parser, Subcommand};
+use std::io::Write;
 use tectonic::{
     config::PersistentConfig,
     docmodel::{DocumentExt, DocumentSetupOptions},
     errors::Result,
+    io::{InputFeatures, OpenResult},
     tt_note,
 };
 use tectonic_bundles::Bundle;
@@ -60,20 +62,26 @@
     #[command(name = "search")]
     /// Filter the list of filenames contained in the bundle
     Search(BundleSearchCommand),
+
+    #[command(name = "serve")]
+    /// Dump the contents of files requested on standard input
+    Serve(BundleServeCommand),
 }
 
 impl TectonicCommand for BundleCommand {
     fn customize(&self, cc: &mut CommandCustomizations) {
         match &self.command {
             BundleCommands::Cat(c) => c.customize(cc),
             BundleCommands::Search(c) => c.customize(cc),
+            BundleCommands::Serve(c) => c.customize(cc),
         }
     }
 
     fn execute(self, config: PersistentConfig, status: &mut dyn StatusBackend) -> Result<i32> {
         match self.command {
             BundleCommands::Cat(c) => c.execute(config, status),
             BundleCommands::Search(c) => c.execute(config, status),
+            BundleCommands::Serve(c) => c.execute(config, status),
         }
     }
 }
@@ -138,3 +146,69 @@
         Ok(0)
     }
 }
+
+#[derive(Debug, Eq, PartialEq, Parser)]
+struct BundleServeCommand {
+    /// Use only resource files cached locally
+    #[arg(short = 'C', long)]
+    only_cached: bool,
+}
+
+impl BundleServeCommand {
+    fn customize(&self, cc: &mut CommandCustomizations) {
+        cc.always_stderr = true;
+    }
+
+    fn execute(self, config: PersistentConfig, status: &mut dyn StatusBackend) -> Result<i32> {
+        let mut bundle = get_a_bundle(config, self.only_cached, status)?;
+        let mut filename = String::new();
+        let stdin = std::io::stdin();
+        let mut stdout = std::io::stdout();
+        loop {
+            stdout.flush()?;
+            filename.clear();
+            match stdin.read_line(&mut filename) {
+                Err(error) => {
+                    eprintln!("error: {error}");
+                    return Ok(1);
+                }
+                Ok(0) => return Ok(0),
+                Ok(_) => {
+                    let name = filename.trim_end();
+                    let error = match bundle.input_path(name, status) {
+                        OpenResult::Err(e) => e,
+                        OpenResult::Ok(path) => {
+                            let mut path = path.as_os_str().as_encoded_bytes();
+                            let size = path.len() as u64;
+                            stdout.write_all(&[b'P'])?;
+                            stdout.write_all(&size.to_le_bytes())?;
+                            let copied = std::io::copy(&mut path, &mut stdout)?;
+                            assert!(size == copied);
+                            continue;
+                        }
+                        OpenResult::NotAvailable => {
+                            match bundle.input_open_name(name, status).must_exist() {
+                                Ok(mut t) => {
+                                    let size = t.get_size()? as u64;
+                                    stdout.write_all(&[b'C'])?;
+                                    stdout.write_all(&size.to_le_bytes())?;
+                                    let copied = std::io::copy(&mut t, &mut stdout)?;
+                                    assert!(size == copied);
+                                    continue;
+                                }
+                                Err(e) => e,
+                            }
+                        }
+                    };
+                    let text = error.to_string();
+                    let bytes = text.as_bytes();
+                    let size = bytes.len() as u64;
+                    stdout.write_all(&[b'E'])?;
+                    stdout.write_all(&size.to_le_bytes())?;
+                    stdout.write_all(&bytes)?;
+                }
+            };
+            stdout.flush().unwrap();
+        }
+    }
+}