Merge remote-tracking branch 'origin/main' into feature/install-tools…

…-deeplink

.github/workflows/pr-ci-healchecks.yml

@@ -37,7 +37,7 @@ jobs:
       - name: Download side binaries
         env:
           ARCH: x86_64-unknown-linux-gnu
-          SHINKAI_NODE_VERSION: v0.9.3
+          SHINKAI_NODE_VERSION: v0.9.5
           OLLAMA_VERSION: v0.5.4
         run: |
           npx ts-node ./ci-scripts/download-side-binaries.ts

.github/workflows/release-dev.yml

@@ -208,7 +208,7 @@ jobs:
       - name: Download side binaries
         env:
           ARCH: ${{ matrix.arch }}
-          SHINKAI_NODE_VERSION: v0.9.3
+          SHINKAI_NODE_VERSION: v0.9.5
           OLLAMA_VERSION: v0.5.4
         run: |
           npx ts-node ./ci-scripts/download-side-binaries.ts

.github/workflows/release-prod.yml

@@ -76,6 +76,9 @@ jobs:
   #         publish: false
 
   release-shinkai-desktop:
+    permissions:
+      contents: 'read'
+      id-token: 'write'
     needs: prebuild
     name: Release Shinkai Desktop
     environment: production
@@ -206,7 +209,7 @@ jobs:
       - name: Download side binaries
         env:
           ARCH: ${{ matrix.arch }}
-          SHINKAI_NODE_VERSION: v0.9.3
+          SHINKAI_NODE_VERSION: v0.9.5
           OLLAMA_VERSION: v0.5.4
         run: |
           npx ts-node ./ci-scripts/download-side-binaries.ts
@@ -251,6 +254,51 @@ jobs:
           CPAL_ASIO_DIR: ${{ github.workspace }}/asiosdk_2.3.3_2019-06-14
           LIBCLANG_PATH: C:\Program Files\LLVM\bin
           NODE_OPTIONS: "--max_old_space_size=8192"
+
+# --- Signing process ---
+      - name: 'Google auth'
+        if: ${{ matrix.arch == 'x86_64-pc-windows-msvc' }}
+        id: 'auth'
+        uses: 'google-github-actions/auth@v2'
+        with:
+          workload_identity_provider: '${{ secrets.WIF_PROVIDER }}'
+          service_account: '${{ secrets.SERVICE_ACCOUNT }}'
+
+      - name: 'Set up Cloud SDK'
+        if: ${{ matrix.arch == 'x86_64-pc-windows-msvc' }}
+        uses: 'google-github-actions/setup-gcloud@v2'
+        with:
+          project_id: 'shinkai-412316'
+
+
+      - name: Set up Java
+        if: ${{ matrix.arch == 'x86_64-pc-windows-msvc' }}
+        uses: actions/setup-java@v4
+        with:
+          java-version: 17
+          distribution: 'temurin'
+      - name: Download Jsign
+        run: wget https://github.com/ebourg/jsign/releases/download/7.0/jsign-7.0.jar
+
+      - name: Cert to file
+        if: ${{ matrix.arch == 'x86_64-pc-windows-msvc' }}
+        run: |
+          echo -n "$EV_CODE_SIGNING_CERTIFICATE" | base64 --decode -o OS20241029372986.pem
+
+      - name: Sign
+        if: ${{ matrix.arch == 'x86_64-pc-windows-msvc' }}
+        run: >
+          java -jar jsign.jar \
+              --storetype GOOGLECLOUD \
+              --storepass "$(gcloud auth print-access-token)" \
+              --keystore "projects/shinkai-412316/locations/us/keyRings/shinkai-apps" \
+              --alias "EVCodeSigning" \
+              --certfile "OS20241029372986.pem" \
+              --tsmode RFC3161 \
+              --tsaurl http://timestamp.globalsign.com/tsa/r6advanced1 \
+              ${{ matrix.build_output_file_path }}
+# ---
+
       - name: Prepare binary files
         id: prepare-files
         shell: bash

README.md

@@ -46,22 +46,22 @@ $ git clone https://github.com/dcSpark/shinkai-apps
 ```
 ARCH="aarch64-apple-darwin" \
 OLLAMA_VERSION="v0.5.4" \
-SHINKAI_NODE_VERSION="v0.9.3" \
+SHINKAI_NODE_VERSION="v0.9.5" \
 npx ts-node ./ci-scripts/download-side-binaries.ts
 ```
 
 #### Linux
 ```
 ARCH="x86_64-unknown-linux-gnu" \
 OLLAMA_VERSION="v0.5.4"\
-SHINKAI_NODE_VERSION="v0.9.3" \
+SHINKAI_NODE_VERSION="v0.9.5" \
 npx ts-node ./ci-scripts/download-side-binaries.ts
 ```
 
 #### Windows
 ```
 $ENV:OLLAMA_VERSION="v0.5.4"
-$ENV:SHINKAI_NODE_VERSION="v0.9.3"
+$ENV:SHINKAI_NODE_VERSION="v0.9.5"
 $ENV:ARCH="x86_64-pc-windows-msvc"
 npx ts-node ./ci-scripts/download-side-binaries.ts
 ```

apps/shinkai-desktop/jest.config.ts

@@ -0,0 +1,11 @@
+export default {
+  displayName: 'shinkai-desktop',
+  preset: '../../jest.preset.js',
+  transform: {
+    '^.+\\.[tj]sx?$': ['ts-jest', { tsconfig: '<rootDir>/tsconfig.spec.json' }],
+  },
+  moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx'],
+  coverageDirectory: '../../coverage/apps/shinkai-desktop',
+  setupFilesAfterEnv: ['<rootDir>/src/test-setup.ts'],
+  testEnvironment: 'jsdom',
+};

apps/shinkai-desktop/src-tauri/Cargo.toml

@@ -39,6 +39,7 @@ listeners = "0.2"
 log = "0.4"
 anyhow = "1.0.89"
 uuid = "1.10.0"
+kill_tree = { version = "0.2", features = ["tokio"] }
 
 tauri-plugin-global-shortcut = "2.2"
 tauri-plugin-shell = "2.2"

apps/shinkai-desktop/src-tauri/src/local_shinkai_node/process_handlers/ollama_process_handler.rs

@@ -22,7 +22,6 @@ pub struct OllamaOptions {
     pub ollama_max_loaded_models: String,
     pub ollama_origins: String,
     pub ollama_debug: String,
-    pub ollama_runners_dir: Option<String>,
 }
 
 impl Default for OllamaOptions {
@@ -33,26 +32,6 @@ impl Default for OllamaOptions {
             ollama_max_loaded_models: "2".to_string(),
             ollama_origins: "*".to_string(),
             ollama_debug: "true".to_string(),
-            ollama_runners_dir: None,
-        }
-    }
-}
-
-impl OllamaOptions {
-    pub fn with_app_options(app_resource_dir: PathBuf) -> Self {
-        let ollama_runners_dir = if cfg!(target_os = "windows") {
-            Some(
-                app_resource_dir
-                    .join("external-binaries/ollama/lib/ollama/runners")
-                    .to_string_lossy()
-                    .to_string(),
-            )
-        } else {
-            None
-        };
-        Self {
-            ollama_runners_dir,
-            ..Default::default()
         }
     }
 }
@@ -81,7 +60,7 @@ impl OllamaProcessHandler {
             event_sender,
             ready_matcher,
         );
-        let options = OllamaOptions::with_app_options(app_resource_dir.clone());
+        let options = OllamaOptions::default();
         OllamaProcessHandler {
             app,
             process_handler,
@@ -124,20 +103,9 @@ impl OllamaProcessHandler {
     pub async fn spawn(&self, ensure_model: Option<&str>) -> Result<(), String> {
         let _ = self.kill().await;
 
-        let ollama_process_cwd = if cfg!(target_os = "windows") {
-            Some(PathBuf::from(
-                self.app_resource_dir
-                    .clone()
-                    .join("external-binaries/ollama")
-                    .to_string_lossy()
-                    .to_string(),
-            ))
-        } else {
-            None
-        };
         let env = options_to_env(&self.options);
         self.process_handler
-            .spawn(env, ["serve"].to_vec(), ollama_process_cwd)
+            .spawn(env, ["serve"].to_vec(), None)
             .await?;
         if let Err(e) = self.wait_ollama_server().await {
             self.process_handler.kill().await;

apps/shinkai-desktop/src-tauri/src/local_shinkai_node/process_handlers/process_handler.rs

@@ -142,14 +142,24 @@ impl ProcessHandler {
         tauri::async_runtime::spawn(async move {
             while let Some(event) = rx.recv().await {
                 let message = Self::command_event_to_message(event.clone());
-                let mut logger = logger_mutex.write().await;
-                let log_entry = logger.add_log(message.clone());
-                let event_sender = event_sender_mutex.lock().await;
-                let _ = event_sender.send(ProcessHandlerEvent::Log(log_entry)).await;
+                let log_entry;
+                {
+                    let mut logger = logger_mutex.write().await;
+                    log_entry = logger.add_log(message.clone());
+                }
+                {
+                    let event_sender = event_sender_mutex.lock().await;
+                    let _ = event_sender.send(ProcessHandlerEvent::Log(log_entry)).await;
+                }
                 if matches!(event, CommandEvent::Terminated { .. }) {
-                    let mut process = process_mutex.lock().await;
-                    *process = None;
-                    let _ = event_sender.send(ProcessHandlerEvent::Stopped).await;
+                    {
+                        let mut process = process_mutex.lock().await;
+                        *process = None;
+                    }
+                    {
+                        let event_sender = event_sender_mutex.lock().await;
+                        let _ = event_sender.send(ProcessHandlerEvent::Stopped).await;
+                    }
                 }
                 if ready_matcher.is_match(&message) {
                     let mut is_ready = is_ready_mutex.lock().await;
@@ -169,16 +179,23 @@ impl ProcessHandler {
                 let process = process_mutex.lock().await;
                 let is_ready = is_ready_mutex_clone.lock().await;
                 if process.is_none() {
-                    let event_sender = event_sender_mutex.lock().await;
-                    let mut logger = logger_mutex.write().await;
                     let message = "failed to spawn shinkai-node, it crashed before min time alive"
                         .to_string();
-                    let log_entry = logger.add_log(message.clone());
-                    let _ = event_sender.send(ProcessHandlerEvent::Log(log_entry)).await;
+                    let log_entry: LogEntry;
+                    {
+                        let mut logger = logger_mutex.write().await;
+                        log_entry = logger.add_log(message.clone());
+                    }
+                    {
+                        let event_sender = event_sender_mutex.lock().await;
+                        let _ = event_sender.send(ProcessHandlerEvent::Log(log_entry)).await;
+                    }
                     return Err(message.to_string());
                 } else if *is_ready {
                     break;
                 }
+                drop(process);
+                drop(is_ready);
                 std::thread::sleep(std::time::Duration::from_millis(500));
             }
             Ok(())
@@ -194,11 +211,13 @@ impl ProcessHandler {
     pub async fn kill(&self) {
         let mut process = self.process.lock().await;
         if let Some(child) = process.take() {
-            match child.kill() {
+            let kill_result = kill_tree::tokio::kill_tree(child.pid()).await;
+            match kill_result {
                 Ok(_) => log::info!("{}: process killed", self.process_name),
                 Err(e) => log::warn!("{}: failed to kill {}", self.process_name, e),
             }
             *process = None;
+            drop(process);
             let event_sender = self.event_sender.lock().await;
             let _ = event_sender.send(ProcessHandlerEvent::Stopped).await;
         } else {

apps/shinkai-desktop/src-tauri/src/local_shinkai_node/process_handlers/process_utils.rs

@@ -29,7 +29,7 @@ pub async fn kill_process_by_name(app: AppHandle, process_name: &str) {
         // Windows: Use taskkill command
         app.shell()
             .command("taskkill")
-            .args(["/F", "/IM", &adapted_process_name])
+            .args(["/F", "/T", "/IM", &adapted_process_name])
             .output()
     } else {
         // Unix-like systems: Use pkill command
@@ -86,7 +86,7 @@ pub async fn kill_process_by_pid(app: AppHandle, process_id: &str) {
         // windows: use taskkill command
         app.shell()
             .command("taskkill")
-            .args(["/F", "/PID", process_id])
+            .args(["/F", "/T", "/PID", process_id])
             .output()
     } else {
         app.shell()

apps/shinkai-desktop/src-tauri/src/main.rs

@@ -162,7 +162,7 @@ fn main() {
                     let mut shinkai_node_manager_guard =
                         SHINKAI_NODE_MANAGER_INSTANCE.get().unwrap().lock().await;
                     shinkai_node_manager_guard.kill().await;
-
+                    drop(shinkai_node_manager_guard);
                     // Force exit the application
                     std::process::exit(0);
                 });

apps/shinkai-desktop/src-tauri/src/tray.rs

@@ -61,6 +61,7 @@ pub fn create_tray(app: &tauri::AppHandle) -> tauri::Result<()> {
                     if shinkai_node_manager_guard.is_running().await {
                         shinkai_node_manager_guard.kill().await;
                     }
+                    drop(shinkai_node_manager_guard);
                     std::process::exit(0);
                 });
             }

apps/shinkai-desktop/src-tauri/tauri.windows.conf.json

@@ -8,9 +8,9 @@
         "template": "./dummy.wxs"
       }
     },
-    "resources": [
-      "external-binaries/shinkai-node/pdfium.dll",
-      "external-binaries/ollama/lib"
-    ]
+    "resources": {
+      "external-binaries/shinkai-node/pdfium.dll": "external-binaries/shinkai-node/pdfium.dll",
+      "external-binaries/ollama/lib/": "lib/"
+    }
   }
 }