Merge pull request #2161 from golemcloud/ts-base-image-in-sdk

Using the base wasm from the ts sdk

Author: vigoo

Cargo.toml

@@ -27,7 +27,6 @@ members = [
 
 exclude = [
     "cli/desktop-app/src-tauri",
-    "cli/template-golem-agent-ts",
     "test-components/app-and-library",
     "test-components/shopping-cart",
     "test-components/write-stdout",

Makefile.toml

@@ -66,7 +66,6 @@ run_task = [
         "wit-wasm-rpc",
         "wit-golem-common",
         "wit-golem-cli",
-        "wit-template-golem-agent-ts",
         "wit-test-components",
         "wit-debugging-service-test-components",
         "wit-golem-templates",
@@ -134,13 +133,6 @@ cp wit/deps/golem-agent cli/golem-cli/wit/deps
 cp wit/deps/logging cli/golem-cli/wit/deps
 """
 
-[tasks.wit-template-golem-agent-ts]
-private = true
-script_runner = "@duckscript"
-script = """
-glob_cp wit/deps/**/* cli/template-golem-agent-ts/wit/deps
-"""
-
 [tasks.wit-test-components]
 private = true
 script_runner = "@duckscript"
@@ -1087,19 +1079,6 @@ install_crate = "miniserve"
 command = "miniserve"
 args = ["--interfaces", "127.0.0.1", "--port", "41357", "schema.golem.cloud"]
 
-## Agent template management
-[tasks.rebuild-ts-agent-template]
-description = "Rebuilds the TypeScript agent template WASM"
-script_runner = "@duckscript"
-script = '''
-cd cli/template-golem-agent-ts
-exec --fail-on-error npm update
-exec --fail-on-error npm install
-exec --fail-on-error npm run generate
-exec --fail-on-error npm run build
-cp dist/wrapper/target/wasm32-wasip1/release/golem_agent.wasm ../golem-templates/templates/ts/ts-app-common/wasm/golem_agent.wasm
-'''
-
 ## Cleanup
 [tasks.clear-v8]
 description = "Removes the v8 crate from the target directories"

cli/golem-cli/src/app/build/command.rs

@@ -18,7 +18,7 @@ use crate::app::build::task_result_marker::{
     InjectToPrebuiltQuickJsCommandMarkerHash, ResolvedExternalCommandMarkerHash, TaskResultMarker,
 };
 use crate::app::build::{delete_path_logged, is_up_to_date, new_task_up_to_date_check};
-use crate::app::context::ApplicationContext;
+use crate::app::context::{ApplicationContext, ToolsWithEnsuredCommonDeps};
 use crate::app::error::CustomCommandError;
 use crate::fs::compile_and_collect_globs;
 use crate::log::{
@@ -532,7 +532,11 @@ pub async fn execute_external_command(
                 return Err(anyhow!("Empty command!"));
             }
 
-            ensure_common_deps_for_tool(ctx, command_tokens[0].as_str()).await?;
+            ensure_common_deps_for_tool(
+                &ctx.tools_with_ensured_common_deps,
+                command_tokens[0].as_str(),
+            )
+            .await?;
 
             Command::new(command_tokens[0].clone())
                 .args(command_tokens.iter().skip(1))
@@ -544,7 +548,10 @@ pub async fn execute_external_command(
     )
 }
 
-async fn ensure_common_deps_for_tool(ctx: &ApplicationContext, tool: &str) -> anyhow::Result<()> {
+pub async fn ensure_common_deps_for_tool(
+    ctx: &ToolsWithEnsuredCommonDeps,
+    tool: &str,
+) -> anyhow::Result<()> {
     match tool {
         "node" | "npx" => {
             ctx.ensure_common_deps_for_tool_once("node", || async {

cli/golem-cli/src/app/build/gen_rpc.rs

@@ -67,7 +67,7 @@ pub async fn gen_rpc(ctx: &mut ApplicationContext) -> anyhow::Result<()> {
             any_changed |= changed;
         }
         if any_changed {
-            ctx.update_wit_context()?;
+            ctx.update_wit_context().await?;
         }
     }
 

cli/golem-cli/src/app/context.rs

@@ -49,9 +49,52 @@ pub struct ApplicationContext {
     component_generated_base_wit_deps: HashMap<AppComponentName, WitDepsResolver>,
     selected_component_names: BTreeSet<AppComponentName>,
     remote_components: RemoteComponents,
+    pub tools_with_ensured_common_deps: ToolsWithEnsuredCommonDeps,
+}
+
+pub struct ToolsWithEnsuredCommonDeps {
     tools_with_ensured_common_deps: tokio::sync::RwLock<HashSet<String>>,
 }
 
+impl Default for ToolsWithEnsuredCommonDeps {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl ToolsWithEnsuredCommonDeps {
+    pub fn new() -> ToolsWithEnsuredCommonDeps {
+        ToolsWithEnsuredCommonDeps {
+            tools_with_ensured_common_deps: tokio::sync::RwLock::new(HashSet::new()),
+        }
+    }
+
+    pub async fn ensure_common_deps_for_tool_once(
+        &self,
+        tool: &str,
+        ensure: impl AsyncFnOnce() -> anyhow::Result<()>,
+    ) -> anyhow::Result<()> {
+        if self
+            .tools_with_ensured_common_deps
+            .read()
+            .await
+            .contains(tool)
+        {
+            return Ok(());
+        }
+
+        let mut lock = self.tools_with_ensured_common_deps.write().await;
+
+        let result = ensure().await;
+
+        if result.is_ok() {
+            lock.insert(tool.to_string());
+        }
+
+        result
+    }
+}
+
 pub struct ApplicationPreloadResult {
     pub source_mode: ApplicationSourceMode,
     pub loaded_with_warnings: bool,
@@ -81,7 +124,7 @@ impl ApplicationContext {
         }
     }
 
-    pub fn new(
+    pub async fn new(
         available_profiles: &BTreeSet<ProfileName>,
         source_mode: ApplicationSourceMode,
         config: ApplicationConfig,
@@ -93,29 +136,7 @@ impl ApplicationContext {
 
         let ctx = to_anyhow(
             "Failed to load application manifest, see problems above",
-            app_and_calling_working_dir.and_then(|(application, calling_working_dir)| {
-                ResolvedWitApplication::new(&application, config.build_profile.as_ref()).map({
-                    let temp_dir = application.temp_dir();
-                    let offline = config.offline;
-                    move |wit| ApplicationContext {
-                        loaded_with_warnings: false,
-                        config,
-                        application,
-                        wit,
-                        calling_working_dir,
-                        component_stub_defs: HashMap::new(),
-                        common_wit_deps: OnceLock::new(),
-                        component_generated_base_wit_deps: HashMap::new(),
-                        selected_component_names: BTreeSet::new(),
-                        remote_components: RemoteComponents::new(
-                            file_download_client,
-                            temp_dir,
-                            offline,
-                        ),
-                        tools_with_ensured_common_deps: tokio::sync::RwLock::new(HashSet::new()),
-                    }
-                })
-            }),
+            Self::create_context(app_and_calling_working_dir, config, file_download_client).await,
             Some(|mut app_ctx| {
                 app_ctx.loaded_with_warnings = true;
                 app_ctx
@@ -131,6 +152,55 @@ impl ApplicationContext {
         Ok(Some(ctx))
     }
 
+    async fn create_context(
+        app_and_calling_working_dir: ValidatedResult<(Application, PathBuf)>,
+        config: ApplicationConfig,
+        file_download_client: reqwest::Client,
+    ) -> ValidatedResult<ApplicationContext> {
+        let mut result = ValidatedResult::Ok(());
+
+        let (r, v) = result.merge_and_get(app_and_calling_working_dir);
+        result = r;
+        if let Some((application, calling_working_dir)) = v {
+            let tools_with_ensured_common_deps = ToolsWithEnsuredCommonDeps::new();
+            let wit_result = ResolvedWitApplication::new(
+                &application,
+                config.build_profile.as_ref(),
+                &tools_with_ensured_common_deps,
+            )
+            .await;
+
+            let (r, v) = result.merge_and_get(wit_result);
+            result = r;
+            if let Some(wit) = v {
+                let temp_dir = application.temp_dir();
+                let offline = config.offline;
+                let ctx = ApplicationContext {
+                    loaded_with_warnings: false,
+                    config,
+                    application,
+                    wit,
+                    calling_working_dir,
+                    component_stub_defs: HashMap::new(),
+                    common_wit_deps: OnceLock::new(),
+                    component_generated_base_wit_deps: HashMap::new(),
+                    selected_component_names: BTreeSet::new(),
+                    remote_components: RemoteComponents::new(
+                        file_download_client,
+                        temp_dir,
+                        offline,
+                    ),
+                    tools_with_ensured_common_deps,
+                };
+                ValidatedResult::Ok(ctx)
+            } else {
+                result.expect_error()
+            }
+        } else {
+            result.expect_error()
+        }
+    }
+
     fn validate_build_profile(&self) -> anyhow::Result<()> {
         let Some(profile) = &self.config.build_profile else {
             return Ok(());
@@ -160,10 +230,16 @@ impl ApplicationContext {
         self.config.build_profile.as_ref()
     }
 
-    pub fn update_wit_context(&mut self) -> anyhow::Result<()> {
+    pub async fn update_wit_context(&mut self) -> anyhow::Result<()> {
         to_anyhow(
             "Failed to update application wit context, see problems above",
-            ResolvedWitApplication::new(&self.application, self.build_profile()).map(|wit| {
+            ResolvedWitApplication::new(
+                &self.application,
+                self.build_profile(),
+                &self.tools_with_ensured_common_deps,
+            )
+            .await
+            .map(|wit| {
                 self.wit = wit;
             }),
             None,
@@ -639,31 +715,6 @@ impl ApplicationContext {
 
         Ok(())
     }
-
-    pub async fn ensure_common_deps_for_tool_once(
-        &self,
-        tool: &str,
-        ensure: impl AsyncFnOnce() -> anyhow::Result<()>,
-    ) -> anyhow::Result<()> {
-        if self
-            .tools_with_ensured_common_deps
-            .read()
-            .await
-            .contains(tool)
-        {
-            return Ok(());
-        }
-
-        let mut lock = self.tools_with_ensured_common_deps.write().await;
-
-        let result = ensure().await;
-
-        if result.is_ok() {
-            lock.insert(tool.to_string());
-        }
-
-        result
-    }
 }
 
 fn load_app(

cli/golem-cli/src/context.rs

@@ -409,11 +409,13 @@ impl Context {
         &self,
     ) -> anyhow::Result<tokio::sync::RwLockWriteGuard<'_, ApplicationContextState>> {
         let mut state = self.app_context_state.write().await;
-        state.init(
-            &self.available_profile_names,
-            &self.app_context_config,
-            self.file_download_client.clone(),
-        )?;
+        state
+            .init(
+                &self.available_profile_names,
+                &self.app_context_config,
+                self.file_download_client.clone(),
+            )
+            .await?;
         Ok(state)
     }
 
@@ -770,7 +772,7 @@ impl ApplicationContextState {
         }
     }
 
-    fn init(
+    async fn init(
         &mut self,
         available_profile_names: &BTreeSet<ProfileName>,
         config: &ApplicationContextConfig,
@@ -804,6 +806,7 @@ impl ApplicationContextState {
                 app_config,
                 file_download_client,
             )
+            .await
             .map_err(Arc::new),
         );
 

cli/golem-cli/src/validation.rs

@@ -123,6 +123,33 @@ impl<T> ValidatedResult<T> {
         }
         self
     }
+
+    pub fn take(self) -> (ValidatedResult<()>, Option<T>) {
+        match self {
+            ValidatedResult::Ok(value) => (ValidatedResult::Ok(()), Some(value)),
+            ValidatedResult::OkWithWarns(value, warns) => {
+                (ValidatedResult::OkWithWarns((), warns), Some(value))
+            }
+            ValidatedResult::WarnsAndErrors(warns, errors) => {
+                (ValidatedResult::WarnsAndErrors(warns, errors), None)
+            }
+        }
+    }
+
+    pub fn merge_and_get<U>(self, other: ValidatedResult<U>) -> (ValidatedResult<()>, Option<U>) {
+        let next = self.combine(other, |_, other| other);
+        next.take()
+    }
+
+    pub fn expect_error<U>(self) -> ValidatedResult<U> {
+        match self {
+            ValidatedResult::Ok(_) => panic!("Expected error"),
+            ValidatedResult::OkWithWarns(_, _) => panic!("Expected error"),
+            ValidatedResult::WarnsAndErrors(warns, errors) => {
+                ValidatedResult::WarnsAndErrors(warns, errors)
+            }
+        }
+    }
 }
 
 impl<T, E> ValidatedResult<Result<T, E>> {