chore(by-ai): Follow new deno_core API

Author: hanakla

pkgs/ai-deno/Cargo.lock

@@ -47,6 +47,7 @@ deno_package_json = "=0.21.0"
 deno_semver = "=0.9.0"
 deno_cache_dir = "=0.25.0"
 deno_permissions = "=0.78.0"
+deno_bundle_runtime = "0.6.0"
 
 tokio = { version = "1.47.1", features = ["full"] }
 tokio-util = "0.7.16"

pkgs/ai-deno/Cargo.toml

@@ -50,6 +50,10 @@ map_error!(JsError, |e| Error::Runtime(format!(
     "{}\n{}",
     e.message.unwrap_or("".to_string()).to_string(), e.stack.unwrap_or("".to_string()).to_string()
 )));
+map_error!(Box<JsError>, |e| Error::Runtime(format!(
+    "{}\n{}",
+    e.message.clone().unwrap_or("".to_string()).to_string(), e.stack.clone().unwrap_or("".to_string()).to_string()
+)));
 map_error!(std::io::Error, |e| Error::Runtime(e.to_string()));
 map_error!(deno_core::error::CoreError, |e| Error::CoreError(
     e.to_string()

pkgs/ai-deno/src/deno/error.rs

@@ -11,6 +11,7 @@ use std::path::Path;
 use crate::deno::error::Error;
 use crate::deno::runtime::Runtime;
 use crate::deno::traits::{ToDefinedValue, ToV8String};
+use crate::deno_println;
 
 #[derive(Debug, Clone)]
 pub struct Module {
@@ -64,9 +65,10 @@ fn resolve_path(
     path_str: impl AsRef<Path>,
     current_dir: &Path,
 ) -> Result<ModuleSpecifier, JsErrorBox> {
+    use std::borrow::Cow;
     let path = current_dir.join(path_str);
-    let path = deno_core::normalize_path(path);
-    deno_core::url::Url::from_file_path(&path).map_err(|()| {
+    let path = deno_core::normalize_path(Cow::Borrowed(path.as_path()));
+    deno_core::url::Url::from_file_path(path.as_ref()).map_err(|()| {
         JsErrorBox::generic(format!(
             "Failed to resolve path: {}",
             path.to_string_lossy().to_string()
@@ -109,7 +111,12 @@ impl ModuleHandle {
     ) -> Result<v8::Global<v8::Function>, Error> {
         let value = self.get_value_ref(runtime, name)?;
 
-        let mut scope = runtime.deno_runtime().handle_scope();
+        let deno_runtime = runtime.deno_runtime();
+        let context = deno_runtime.main_context();
+        let isolate = deno_runtime.v8_isolate();
+        v8::scope!(handle_scope, isolate);
+        let context_local = v8::Local::new(handle_scope, context);
+        let mut scope = v8::ContextScope::new(handle_scope, context_local);
         let local = v8::Local::<v8::Value>::new(&mut scope, value);
 
         if !local.is_function() {
@@ -141,11 +148,18 @@ impl ModuleHandle {
                 ));
             };
 
-        let mut scope = runtime.deno_runtime().handle_scope();
+        let deno_runtime = runtime.deno_runtime();
+        let context = deno_runtime.main_context();
+        let isolate = deno_runtime.v8_isolate();
+        v8::scope!(handle_scope, isolate);
+        let context_local = v8::Local::new(handle_scope, context);
+        let mut scope = v8::ContextScope::new(handle_scope, context_local);
         let module_namespace = module_namespace.open(&mut scope);
         assert!(module_namespace.is_module_namespace_object());
 
-        let key = name.to_v8_string(&mut scope)?.cast::<v8::Value>();
+        let key = v8::String::new(&scope, name)
+            .ok_or_else(|| Error::V8Encoding(name.to_string()))?
+            .cast::<v8::Value>();
         let value = module_namespace.get(&mut scope, key);
 
         match value.if_defined() {
@@ -155,14 +169,25 @@ impl ModuleHandle {
     }
 
     pub fn get_module_exports(&self, runtime: &mut Runtime) -> Result<Vec<String>, Error> {
+        println!("[DEBUG] get_module_exports: trying to get namespace for module_id: {}", self.module_id);
+
         let module_namespace =
             if let Ok(namespace) = runtime.deno_runtime().get_module_namespace(self.module_id) {
+                println!("[DEBUG] get_module_exports: successfully got namespace");
                 namespace
             } else {
+                println!("[DEBUG] get_module_exports: failed to get namespace for module_id: {}", self.module_id);
+                // Try to get more information about why it failed
+                eprintln!("[DEBUG] Module {} namespace not available - module may not be fully evaluated", self.module_id);
                 return Err(Error::Runtime(self.module_id().to_string()));
             };
 
-        let mut scope = runtime.deno_runtime().handle_scope();
+        let deno_runtime = runtime.deno_runtime();
+        let context = deno_runtime.main_context();
+        let isolate = deno_runtime.v8_isolate();
+        v8::scope!(handle_scope, isolate);
+        let context_local = v8::Local::new(handle_scope, context);
+        let mut scope = v8::ContextScope::new(handle_scope, context_local);
         let module_namespace = module_namespace.open(&mut scope);
         assert!(module_namespace.is_module_namespace_object());
 

pkgs/ai-deno/src/deno/module.rs

@@ -135,14 +135,17 @@ impl AiDenoModuleLoader {
             deno_resolver::cjs::IsCjsResolutionMode::ImplicitTypeCommonJs,
         );
 
-        let cjs_translator = NodeCodeTranslator::new(MaybeArc::new(CjsModuleExportAnalyzer::new(
-            AiDenoCjsCodeAnalyzer::new(MaybeArc::new(RealFs::default()), cjs_tracker),
-            pkg_manager.clone(),
-            node_resolver.clone(),
-            pkg_manager.clone(),
-            pkg_json_resolver.clone(),
-            real_sys.clone(),
-        )));
+        let cjs_translator = NodeCodeTranslator::new(
+            MaybeArc::new(CjsModuleExportAnalyzer::new(
+                AiDenoCjsCodeAnalyzer::new(MaybeArc::new(RealFs::default()), cjs_tracker),
+                pkg_manager.clone(),
+                node_resolver.clone(),
+                pkg_manager.clone(),
+                pkg_json_resolver.clone(),
+                real_sys.clone(),
+            )),
+            node_resolver::analyze::NodeCodeTranslatorMode::ModuleLoader,
+        );
 
         // let module_graph = ModuleGraph::new(deno_graph::GraphKind::All);
 
@@ -230,7 +233,7 @@ impl AiDenoModuleLoader {
         let package_name = specifier.strip_prefix("npm:").unwrap_or(specifier);
 
         let npm_client = self.pkg_manager.npm_client.clone();
-        let (name, version, _sub_path) = parse_npm_specifier(package_name).map_err(|err| {
+        let (name, version, sub_path) = parse_npm_specifier(package_name).map_err(|err| {
             ModuleLoaderError::from(JsErrorBox::generic(format!(
                 "Failed to parse npm specifier: {} - {}",
                 package_name, err
@@ -271,7 +274,14 @@ impl AiDenoModuleLoader {
             deno_println!("Package already installed: {}@{:?}", name, resolved_version);
         }
 
-        return Ok(ModuleSpecifier::parse(specifier).unwrap());
+        // Return specifier with resolved version
+        let resolved_specifier = if sub_path.is_empty() {
+            format!("npm:{}@{}", name, resolved_version)
+        } else {
+            format!("npm:{}@{}/{}", name, resolved_version, sub_path)
+        };
+
+        return Ok(ModuleSpecifier::parse(&resolved_specifier).unwrap());
     }
 
     pub fn resolve_npm_module(
@@ -380,7 +390,13 @@ impl AiDenoModuleLoader {
                 let path = self
                     .pkg_manager
                     .resolve_specifier_to_file_path(module_specifier.as_str(), None)
-                    .unwrap();
+                    .map_err(|err| {
+                        ModuleLoaderError::from(JsErrorBox::generic(format!(
+                            "Failed to resolve npm package: {} - {:?}",
+                            module_specifier,
+                            err
+                        )))
+                    })?;
 
                 let content = std::fs::read_to_string(&path).map_err(|err| {
                     ModuleLoaderError::from(JsErrorBox::generic(format!(

pkgs/ai-deno/src/deno/module_loader.rs

@@ -3,7 +3,6 @@
 
 use deno_ast::{MediaType, ModuleExportsAndReExports, ModuleSpecifier, ParsedSource};
 use deno_error::JsErrorBox;
-use deno_graph::{CapturingEsParser, DefaultEsParser, EsParser, ParseOptions, ParsedSourceStore};
 use deno_resolver::{cjs::CjsTracker, npm::DenoInNpmPackageChecker};
 use deno_runtime::deno_fs;
 use node_resolver::analyze::EsmAnalysisMode;
@@ -157,8 +156,10 @@ impl node_resolver::analyze::CjsCodeAnalyzer for AiDenoCjsCodeAnalyzer {
             Some(source) => source,
             None => {
                 if let Ok(path) = specifier.to_file_path() {
-                    if let Ok(source_from_file) =
-                        self.fs.read_text_file_lossy_async(path, None).await
+                    if let Ok(source_from_file) = self
+                        .fs
+                        .read_text_file_lossy_async(deno_permissions::CheckedPathBuf::unsafe_new(path))
+                        .await
                     {
                         source_from_file
                     } else {
@@ -235,7 +236,7 @@ pub struct ParsedSourceCache {
 /// and in LSP settings the concurrency will be enforced
 /// at a higher level to ensure this will have the latest
 /// parsed source.
-impl deno_graph::ParsedSourceStore for ParsedSourceCache {
+impl ParsedSourceCache {
     fn set_parsed_source(
         &self,
         specifier: ModuleSpecifier,
@@ -251,7 +252,7 @@ impl deno_graph::ParsedSourceStore for ParsedSourceCache {
         self.sources.lock().unwrap().get(specifier).cloned()
     }
 
-    fn remove_parsed_source(&self, specifier: &ModuleSpecifier) -> Option<ParsedSource> {
+    pub fn remove_parsed_source(&self, specifier: &ModuleSpecifier) -> Option<ParsedSource> {
         self.sources.lock().unwrap().remove(specifier)
     }
 
@@ -265,66 +266,20 @@ impl deno_graph::ParsedSourceStore for ParsedSourceCache {
             Some(parsed_source.clone())
         } else {
             // upgrade to have scope analysis
-            let parsed_source = sources.remove(specifier).unwrap();
+            let parsed_source = sources.remove(specifier)?;
             let parsed_source = parsed_source.into_with_scope_analysis();
             sources.insert(specifier.clone(), parsed_source.clone());
             Some(parsed_source)
         }
     }
-}
-
-impl ParsedSourceCache {
-    pub fn get_parsed_source_from_js_module(
-        &self,
-        module: &deno_graph::JsModule,
-    ) -> Result<ParsedSource, deno_ast::ParseDiagnostic> {
-        let parser = self.as_capturing_parser();
-        // this will conditionally parse because it's using a CapturingEsParser
-        parser.parse_program(ParseOptions {
-            specifier: &module.specifier,
-            source: module.source.clone(),
-            media_type: module.media_type,
-            scope_analysis: false,
-        })
-    }
-
-    pub fn remove_or_parse_module(
-        &self,
-        specifier: &ModuleSpecifier,
-        source: Arc<str>,
-        media_type: MediaType,
-    ) -> Result<ParsedSource, deno_ast::ParseDiagnostic> {
-        if let Some(parsed_source) = self.remove_parsed_source(specifier) {
-            if parsed_source.media_type() == media_type
-                && parsed_source.text().as_ref() == source.as_ref()
-            {
-                // note: message used tests
-                // log::debug!("Removed parsed source: {}", specifier);
-                return Ok(parsed_source);
-            }
-        }
-        let options = ParseOptions {
-            specifier,
-            source,
-            media_type,
-            scope_analysis: false,
-        };
-        DefaultEsParser.parse_program(options)
-    }
 
     /// Frees the parsed source from memory.
     pub fn free(&self, specifier: &ModuleSpecifier) {
         self.sources.lock().unwrap().remove(specifier);
     }
 
-    /// Fress all parsed sources from memory.
+    /// Frees all parsed sources from memory.
     pub fn free_all(&self) {
         self.sources.lock().unwrap().clear();
     }
-
-    /// Creates a parser that will reuse a ParsedSource from the store
-    /// if it exists, or else parse.
-    pub fn as_capturing_parser(&self) -> CapturingEsParser {
-        CapturingEsParser::new(None, self)
-    }
 }

pkgs/ai-deno/src/deno/module_loader/cjs_code_analyzer.rs

@@ -63,7 +63,7 @@ impl AiDenoHttpClient {
 
                 if !status.is_success() {
                     return Err(deno_npm_cache::DownloadError {
-                        status_code: Some(StatusCode::from_u16(status.as_u16()).unwrap()),
+                        status_code: Some(status.as_u16()),
                         error: JsErrorBox::generic(format!("Failed to load url: {}", url)),
                     });
                 }
@@ -72,7 +72,7 @@ impl AiDenoHttpClient {
                     .bytes()
                     .await
                     .map_err(|e| deno_npm_cache::DownloadError {
-                        status_code: Some(StatusCode::from_u16(status.as_u16()).unwrap()),
+                        status_code: Some(status.as_u16()),
                         error: JsErrorBox::generic(format!(
                             "Failed to receive bytes: {}; {}",
                             url,

pkgs/ai-deno/src/deno/module_loader/http_client.rs

@@ -38,6 +38,7 @@ impl From<NpmPackageError> for JsErrorBox {
     }
 }
 
+#[derive(Debug)]
 pub struct NpmClient {
     pub registry_url: String,
     pub http_client: reqwest::Client,
@@ -151,16 +152,40 @@ impl NpmCacheHttpClient for NpmClient {
     async fn download_with_retries_on_any_tokio_runtime(
         &self,
         url: Url,
-        maybe_auth_header: Option<(HeaderName, HeaderValue)>,
-    ) -> Result<Option<Vec<u8>>, deno_npm_cache::DownloadError> {
-        let headers = if let Some((name, value)) = maybe_auth_header {
-            Some(vec![(name, value.to_str().unwrap().to_string())])
-        } else {
-            None
+        maybe_header_name: Option<String>,
+        maybe_header_value: Option<String>,
+    ) -> Result<deno_npm_cache::NpmCacheHttpClientResponse, deno_npm_cache::DownloadError> {
+        let headers = match (maybe_header_name, maybe_header_value) {
+            (Some(name), Some(value)) => {
+                let header_name = HeaderName::from_bytes(name.as_bytes())
+                    .map_err(|e| deno_npm_cache::DownloadError {
+                        status_code: None,
+                        error: JsErrorBox::generic(format!("Invalid header name: {}", e)),
+                    })?;
+                let header_value = HeaderValue::from_str(&value)
+                    .map_err(|e| deno_npm_cache::DownloadError {
+                        status_code: None,
+                        error: JsErrorBox::generic(format!("Invalid header value: {}", e)),
+                    })?;
+                Some(vec![(header_name, value)])
+            }
+            _ => None,
         };
 
         AiDenoHttpClient::new()
             .download_with_retries_on_any_tokio_runtime(&url, headers)
             .await
+            .map(|opt_bytes| {
+                if let Some(bytes) = opt_bytes {
+                    deno_npm_cache::NpmCacheHttpClientResponse::Bytes(
+                        deno_npm_cache::NpmCacheHttpClientBytesResponse {
+                            bytes,
+                            etag: None,
+                        }
+                    )
+                } else {
+                    deno_npm_cache::NpmCacheHttpClientResponse::NotFound
+                }
+            })
     }
 }