cleaned up code

src-tauri/src/device_manager/manager.rs

@@ -1,8 +1,7 @@
 use std::fs;
 use std::path::{Path, PathBuf};
 
-use libssh_rs::{Session, SshKey, SshResult};
-use log::log;
+use libssh_rs::{Session, SshKey};
 use tokio::fs::{remove_file, File};
 use tokio::io::AsyncWriteExt;
 

src-tauri/src/plugins/cmd.rs

@@ -13,14 +13,6 @@ use crate::event_channel::{EventChannel, EventHandler};
 use crate::session_manager::{Proc, ProcCallback, ProcData, SessionManager};
 use crate::spawn_manager::SpawnManager;
 
-#[derive(Debug, Clone, Serialize, PartialEq)]
-#[serde(tag = "type")]
-pub(crate) enum SpawnResult {
-    Exit { status: i32 },
-    Signal { signal: u32 },
-    Closed,
-}
-
 #[tauri::command]
 async fn exec<R: Runtime>(
     app: AppHandle<R>,
@@ -95,7 +87,7 @@ fn proc_worker<R: Runtime>(
     match proc.wait_close(&app.state::<SessionManager>()) {
         Ok(r) => {
             log::info!("{proc:?} closed with {r:?}");
-            channel.closed(SpawnResult::Exit { status: r });
+            channel.closed(r);
         }
         Err(e) => {
             log::warn!("{proc:?} closed with {e:?}");

src-tauri/src/session_manager/mod.rs

@@ -32,6 +32,14 @@ pub struct ProcData {
     pub data: Vec<u8>,
 }
 
+#[derive(Debug, Clone, Serialize, PartialEq)]
+#[serde(tag = "type")]
+pub enum ProcResult {
+    Exit { status: i32 },
+    Signal { signal: Option<String>, core_dumped: bool },
+    Closed,
+}
+
 pub trait ProcCallback {
     fn rx(&self, fd: u32, data: &[u8]);
 }

src-tauri/src/session_manager/proc.rs

@@ -7,7 +7,7 @@ use libssh_rs::Channel;
 
 use crate::conn_pool::ManagedDeviceConnection;
 use crate::error::Error;
-use crate::session_manager::{Proc, SessionManager};
+use crate::session_manager::{Proc, ProcResult, SessionManager};
 
 impl Proc {
     pub fn is_ready(&self) -> bool {
@@ -53,7 +53,7 @@ impl Proc {
         return Err(Error::Disconnected);
     }
 
-    pub fn wait_close(&self, sessions: &SessionManager) -> Result<i32, Error> {
+    pub fn wait_close(&self, sessions: &SessionManager) -> Result<ProcResult, Error> {
         let session: ManagedDeviceConnection;
         let (sender, receiver) = channel::<Vec<u8>>();
         *self.sender.lock().unwrap() = Some(sender);
@@ -99,14 +99,23 @@ impl Proc {
                 self.data(1, &buf[..buf_size])?;
             }
         }
-        let status = channel.get_exit_status().unwrap_or(-1);
+        let mut result = ProcResult::Closed;
         if interrupted {
             log::debug!("{self:?} channel interrupted by client");
-        } else {
+        } else if let Some(status) = channel.get_exit_status() {
             log::debug!("{self:?} channel closed with status {status}");
+            result = ProcResult::Exit { status };
+        } else if let Some(signal) = channel.get_exit_signal() {
+            log::debug!("{self:?} channel closed with signal {signal:?}");
+            result = ProcResult::Signal {
+                signal: signal.signal_name,
+                core_dumped: signal.core_dumped,
+            };
+        } else {
+            log::debug!("{self:?} channel closed with unknown status");
         }
         session.mark_last_ok();
-        return Ok(status);
+        return Ok(result);
     }
 }
 

src/app/core/services/remote-command.service.ts

@@ -118,11 +118,11 @@ export class CommandSubject<T = Buffer | string> extends ReplaySubject<CommandDa
                     }
                 } else if (payload.type === 'Signal') {
                     // Treat user initiated SIGINT as success
-                    if (this.interrupted && payload.signal === 2) {
+                    if (this.interrupted && payload.signal === "INT") {
                         zone.run(() => subject.complete());
                     } else {
                         zone.run(() => subject.error(new ExecutionError(`Process exited with signal ${payload.signal}`,
-                            128 + payload.signal, this.stderr, command)));
+                            -1, this.stderr, command)));
                     }
                 } else {
                     zone.run(() => subject.error(new Error('Process closed')));
@@ -169,7 +169,8 @@ declare interface SpawnExited {
 
 declare interface SpawnSignaled {
     type: 'Signal';
-    signal: number;
+    signal?: string;
+    coreDumped: boolean;
 }
 
 declare interface SpawnClosed {