1 files changed, 144 insertions, 33 deletions

diff --git a/cli/standalone.rs b/cli/standalone.rs
index af38fd4eb..8379358a0 100644
--- a/cli/standalone.rs
+++ b/cli/standalone.rs
@@ -1,11 +1,17 @@
 use crate::colors;
+use crate::flags::DenoSubcommand;
 use crate::flags::Flags;
 use crate::tokio_util;
 use crate::version;
 use deno_core::error::bail;
 use deno_core::error::type_error;
 use deno_core::error::AnyError;
+use deno_core::error::Context;
 use deno_core::futures::FutureExt;
+use deno_core::serde::Deserialize;
+use deno_core::serde::Serialize;
+use deno_core::serde_json;
+use deno_core::v8_set_flags;
 use deno_core::ModuleLoader;
 use deno_core::ModuleSpecifier;
 use deno_core::OpState;
@@ -15,43 +21,61 @@ use deno_runtime::worker::WorkerOptions;
 use std::cell::RefCell;
 use std::convert::TryInto;
 use std::env::current_exe;
+use std::fs::read;
 use std::fs::File;
 use std::io::Read;
 use std::io::Seek;
 use std::io::SeekFrom;
 use std::io::Write;
+use std::iter::once;
 use std::path::PathBuf;
 use std::pin::Pin;
 use std::rc::Rc;
 use std::sync::Arc;
 
+#[derive(Deserialize, Serialize)]
+struct Metadata {
+  flags: Flags,
+  ca_data: Option<Vec<u8>>,
+}
+
 const MAGIC_TRAILER: &[u8; 8] = b"d3n0l4nd";
 
 /// This function will try to run this binary as a standalone binary
 /// produced by `deno compile`. It determines if this is a stanalone
 /// binary by checking for the magic trailer string `D3N0` at EOF-12.
-/// After the magic trailer is a u64 pointer to the start of the JS
-/// file embedded in the binary. This file is read, and run. If no
-/// magic trailer is present, this function exits with Ok(()).
+/// The magic trailer is followed by:
+/// - a u64 pointer to the JS bundle embedded in the binary
+/// - a u64 pointer to JSON metadata (serialized flags) embedded in the binary
+/// These are dereferenced, and the bundle is executed under the configuration
+/// specified by the metadata. If no magic trailer is present, this function
+/// exits with `Ok(())`.
 pub fn try_run_standalone_binary(args: Vec<String>) -> Result<(), AnyError> {
   let current_exe_path = current_exe()?;
 
   let mut current_exe = File::open(current_exe_path)?;
-  let trailer_pos = current_exe.seek(SeekFrom::End(-16))?;
-  let mut trailer = [0; 16];
+  let trailer_pos = current_exe.seek(SeekFrom::End(-24))?;
+  let mut trailer = [0; 24];
   current_exe.read_exact(&mut trailer)?;
-  let (magic_trailer, bundle_pos_arr) = trailer.split_at(8);
+  let (magic_trailer, rest) = trailer.split_at(8);
   if magic_trailer == MAGIC_TRAILER {
-    let bundle_pos_arr: &[u8; 8] = bundle_pos_arr.try_into()?;
-    let bundle_pos = u64::from_be_bytes(*bundle_pos_arr);
+    let (bundle_pos, rest) = rest.split_at(8);
+    let metadata_pos = rest;
+    let bundle_pos = u64_from_bytes(bundle_pos)?;
+    let metadata_pos = u64_from_bytes(metadata_pos)?;
+    let bundle_len = metadata_pos - bundle_pos;
+    let metadata_len = trailer_pos - metadata_pos;
     current_exe.seek(SeekFrom::Start(bundle_pos))?;
 
-    let bundle_len = trailer_pos - bundle_pos;
-    let mut bundle = String::new();
-    current_exe.take(bundle_len).read_to_string(&mut bundle)?;
-    // TODO: check amount of bytes read
+    let bundle = read_string_slice(&mut current_exe, bundle_pos, bundle_len)
+      .context("Failed to read source bundle from the current executable")?;
+    let metadata =
+      read_string_slice(&mut current_exe, metadata_pos, metadata_len)
+        .context("Failed to read metadata from the current executable")?;
 
-    if let Err(err) = tokio_util::run_basic(run(bundle, args)) {
+    let mut metadata: Metadata = serde_json::from_str(&metadata).unwrap();
+    metadata.flags.argv.append(&mut args[1..].to_vec());
+    if let Err(err) = tokio_util::run_basic(run(bundle, metadata)) {
       eprintln!("{}: {}", colors::red_bold("error"), err.to_string());
       std::process::exit(1);
     }
@@ -61,6 +85,25 @@ pub fn try_run_standalone_binary(args: Vec<String>) -> Result<(), AnyError> {
   }
 }
 
+fn u64_from_bytes(arr: &[u8]) -> Result<u64, AnyError> {
+  let fixed_arr: &[u8; 8] = arr
+    .try_into()
+    .context("Failed to convert the buffer into a fixed-size array")?;
+  Ok(u64::from_be_bytes(*fixed_arr))
+}
+
+fn read_string_slice(
+  file: &mut File,
+  pos: u64,
+  len: u64,
+) -> Result<String, AnyError> {
+  let mut string = String::new();
+  file.seek(SeekFrom::Start(pos))?;
+  file.take(len).read_to_string(&mut string)?;
+  // TODO: check amount of bytes read
+  Ok(string)
+}
+
 const SPECIFIER: &str = "file://$deno$/bundle.js";
 
 struct EmbeddedModuleLoader(String);
@@ -106,28 +149,30 @@ impl ModuleLoader for EmbeddedModuleLoader {
   }
 }
 
-async fn run(source_code: String, args: Vec<String>) -> Result<(), AnyError> {
-  let flags = Flags {
-    argv: args[1..].to_vec(),
-    // TODO(lucacasonato): remove once you can specify this correctly through embedded metadata
-    unstable: true,
-    ..Default::default()
-  };
+async fn run(source_code: String, metadata: Metadata) -> Result<(), AnyError> {
+  let Metadata { flags, ca_data } = metadata;
   let main_module = ModuleSpecifier::resolve_url(SPECIFIER)?;
-  let permissions = Permissions::allow_all();
+  let permissions = Permissions::from_options(&flags.clone().into());
   let module_loader = Rc::new(EmbeddedModuleLoader(source_code));
   let create_web_worker_cb = Arc::new(|_| {
     todo!("Worker are currently not supported in standalone binaries");
   });
 
+  // Keep in sync with `main.rs`.
+  v8_set_flags(
+    once("UNUSED_BUT_NECESSARY_ARG0".to_owned())
+      .chain(flags.v8_flags.iter().cloned())
+      .collect::<Vec<_>>(),
+  );
+  // TODO(nayeemrmn): Unify this Flags -> WorkerOptions mapping with `deno run`.
   let options = WorkerOptions {
     apply_source_maps: false,
     args: flags.argv.clone(),
-    debug_flag: false,
+    debug_flag: flags.log_level.map_or(false, |l| l == log::Level::Debug),
     user_agent: crate::http_util::get_user_agent(),
-    unstable: true,
-    ca_filepath: None,
-    seed: None,
+    unstable: flags.unstable,
+    ca_data,
+    seed: flags.seed,
     js_error_create_fn: None,
     create_web_worker_cb,
     attach_inspector: false,
@@ -152,19 +197,31 @@ async fn run(source_code: String, args: Vec<String>) -> Result<(), AnyError> {
 /// This functions creates a standalone deno binary by appending a bundle
 /// and magic trailer to the currently executing binary.
 pub async fn create_standalone_binary(
-  mut source_code: Vec<u8>,
+  source_code: String,
+  flags: Flags,
   output: PathBuf,
 ) -> Result<(), AnyError> {
+  let mut source_code = source_code.as_bytes().to_vec();
+  let ca_data = match &flags.ca_file {
+    Some(ca_file) => Some(read(ca_file)?),
+    None => None,
+  };
+  let metadata = Metadata { flags, ca_data };
+  let mut metadata = serde_json::to_string(&metadata)?.as_bytes().to_vec();
   let original_binary_path = std::env::current_exe()?;
   let mut original_bin = tokio::fs::read(original_binary_path).await?;
 
+  let bundle_pos = original_bin.len();
+  let metadata_pos = bundle_pos + source_code.len();
   let mut trailer = MAGIC_TRAILER.to_vec();
-  trailer.write_all(&original_bin.len().to_be_bytes())?;
+  trailer.write_all(&bundle_pos.to_be_bytes())?;
+  trailer.write_all(&metadata_pos.to_be_bytes())?;
 
   let mut final_bin =
     Vec::with_capacity(original_bin.len() + source_code.len() + trailer.len());
   final_bin.append(&mut original_bin);
   final_bin.append(&mut source_code);
+  final_bin.append(&mut metadata);
   final_bin.append(&mut trailer);
 
   let output =
@@ -181,13 +238,18 @@ pub async fn create_standalone_binary(
     }
 
     // Make sure we don't overwrite any file not created by Deno compiler.
-    // Check for magic trailer in last 16 bytes
+    // Check for magic trailer in last 24 bytes.
+    let mut has_trailer = false;
     let mut output_file = File::open(&output)?;
-    output_file.seek(SeekFrom::End(-16))?;
-    let mut trailer = [0; 16];
-    output_file.read_exact(&mut trailer)?;
-    let (magic_trailer, _) = trailer.split_at(8);
-    if magic_trailer != MAGIC_TRAILER {
+    // This seek may fail because the file is too small to possibly be
+    // `deno compile` output.
+    if output_file.seek(SeekFrom::End(-24)).is_ok() {
+      let mut trailer = [0; 24];
+      output_file.read_exact(&mut trailer)?;
+      let (magic_trailer, _) = trailer.split_at(8);
+      has_trailer = magic_trailer == MAGIC_TRAILER;
+    }
+    if !has_trailer {
       bail!("Could not compile: cannot overwrite {:?}.", &output);
     }
   }
@@ -201,3 +263,52 @@ pub async fn create_standalone_binary(
 
   Ok(())
 }
+
+/// Transform the flags passed to `deno compile` to flags that would be used at
+/// runtime, as if `deno run` were used.
+/// - Flags that affect module resolution, loading, type checking, etc. aren't
+///   applicable at runtime so are set to their defaults like `false`.
+/// - Other flags are inherited.
+pub fn compile_to_runtime_flags(
+  flags: Flags,
+  baked_args: Vec<String>,
+) -> Result<Flags, AnyError> {
+  // IMPORTANT: Don't abbreviate any of this to `..flags` or
+  // `..Default::default()`. That forces us to explicitly consider how any
+  // change to `Flags` should be reflected here.
+  Ok(Flags {
+    argv: baked_args,
+    subcommand: DenoSubcommand::Run {
+      script: "placeholder".to_string(),
+    },
+    allow_env: flags.allow_env,
+    allow_hrtime: flags.allow_hrtime,
+    allow_net: flags.allow_net,
+    allow_plugin: flags.allow_plugin,
+    allow_read: flags.allow_read,
+    allow_run: flags.allow_run,
+    allow_write: flags.allow_write,
+    cache_blocklist: vec![],
+    ca_file: flags.ca_file,
+    cached_only: false,
+    config_path: None,
+    coverage_dir: flags.coverage_dir,
+    ignore: vec![],
+    import_map_path: None,
+    inspect: None,
+    inspect_brk: None,
+    lock: None,
+    lock_write: false,
+    log_level: flags.log_level,
+    no_check: false,
+    no_prompts: flags.no_prompts,
+    no_remote: false,
+    reload: false,
+    repl: false,
+    seed: flags.seed,
+    unstable: flags.unstable,
+    v8_flags: flags.v8_flags,
+    version: false,
+    watch: false,
+  })
+}