use new procinfo package, and update API to be windowed + a quick filter

Author: sawka

frontend/app/store/wshclientapi.ts

@@ -756,6 +756,18 @@ export class RpcApiType {
         return client.wshRpcCall("remotemkdir", data, opts);
     }
 
+    // command "remoteprocesslist" [call]
+    RemoteProcessListCommand(client: WshClient, data: CommandRemoteProcessListData, opts?: RpcOpts): Promise<ProcessListResponse> {
+        if (this.mockClient) return this.mockClient.mockWshRpcCall(client, "remoteprocesslist", data, opts);
+        return client.wshRpcCall("remoteprocesslist", data, opts);
+    }
+
+    // command "remoteprocesssignal" [call]
+    RemoteProcessSignalCommand(client: WshClient, data: CommandRemoteProcessSignalData, opts?: RpcOpts): Promise<void> {
+        if (this.mockClient) return this.mockClient.mockWshRpcCall(client, "remoteprocesssignal", data, opts);
+        return client.wshRpcCall("remoteprocesssignal", data, opts);
+    }
+
     // command "remotereconnecttojobmanager" [call]
     RemoteReconnectToJobManagerCommand(client: WshClient, data: CommandRemoteReconnectToJobManagerData, opts?: RpcOpts): Promise<CommandRemoteReconnectToJobManagerRtnData> {
         if (this.mockClient) return this.mockClient.mockWshRpcCall(client, "remotereconnecttojobmanager", data, opts);

frontend/types/gotypes.d.ts

@@ -557,6 +557,21 @@ declare global {
         fileinfo?: FileInfo[];
     };
 
+    // wshrpc.CommandRemoteProcessListData
+    type CommandRemoteProcessListData = {
+        sortby?: string;
+        sortdesc?: boolean;
+        start?: number;
+        limit?: number;
+        textsearch?: string;
+    };
+
+    // wshrpc.CommandRemoteProcessSignalData
+    type CommandRemoteProcessSignalData = {
+        pid: number;
+        signal: string;
+    };
+
     // wshrpc.CommandRemoteReconnectToJobManagerData
     type CommandRemoteReconnectToJobManagerData = {
         jobid: string;
@@ -1244,6 +1259,39 @@ declare global {
         y: number;
     };
 
+    // wshrpc.ProcessInfo
+    type ProcessInfo = {
+        pid: number;
+        ppid?: number;
+        command?: string;
+        status?: string;
+        user?: string;
+        mem?: number;
+        mempct?: number;
+        cpu?: number;
+        numthreads?: number;
+    };
+
+    // wshrpc.ProcessListResponse
+    type ProcessListResponse = {
+        processes: ProcessInfo[];
+        summary: ProcessSummary;
+        ts: number;
+        hascpu?: boolean;
+        iswindows?: boolean;
+    };
+
+    // wshrpc.ProcessSummary
+    type ProcessSummary = {
+        total: number;
+        load1?: number;
+        load5?: number;
+        load15?: number;
+        memtotal?: number;
+        memused?: number;
+        memfree?: number;
+    };
+
     // uctypes.RateLimitInfo
     type RateLimitInfo = {
         req: number;

package-lock.json

@@ -12,7 +12,6 @@ import (
 	"golang.org/x/sys/unix"
 )
 
-
 // darwinStatStatus maps P_stat from ExternProc to a human-readable name.
 // Values from sys/proc.h: SIDL=1, SRUN=2, SSLEEP=3, SSTOP=4, SZOMB=5, SDEAD=6.
 var darwinStatStatus = map[int8]string{

pkg/util/procinfo/procinfo_darwin.go

@@ -80,3 +80,15 @@ func IsPidRunning(pid int) bool {
 	}
 	return false
 }
+
+func SendSignalByName(pid int, sigName string) error {
+	sig := ParseSignal(sigName)
+	if sig == nil {
+		return fmt.Errorf("unsupported or invalid signal %q", sigName)
+	}
+	p, err := os.FindProcess(pid)
+	if err != nil {
+		return fmt.Errorf("process %d not found: %w", pid, err)
+	}
+	return p.Signal(sig)
+}

pkg/util/unixutil/unixutil_unix.go

@@ -44,3 +44,7 @@ func SignalHup(pid int) error {
 func IsPidRunning(pid int) bool {
 	return false
 }
+
+func SendSignalByName(pid int, sigName string) error {
+	return fmt.Errorf("sending signals is not supported on Windows")
+}

pkg/util/unixutil/unixutil_windows.go

@@ -753,6 +753,18 @@ func RemoteMkdirCommand(w *wshutil.WshRpc, data string, opts *wshrpc.RpcOpts) er
 	return err
 }
 
+// command "remoteprocesslist", wshserver.RemoteProcessListCommand
+func RemoteProcessListCommand(w *wshutil.WshRpc, data wshrpc.CommandRemoteProcessListData, opts *wshrpc.RpcOpts) (*wshrpc.ProcessListResponse, error) {
+	resp, err := sendRpcRequestCallHelper[*wshrpc.ProcessListResponse](w, "remoteprocesslist", data, opts)
+	return resp, err
+}
+
+// command "remoteprocesssignal", wshserver.RemoteProcessSignalCommand
+func RemoteProcessSignalCommand(w *wshutil.WshRpc, data wshrpc.CommandRemoteProcessSignalData, opts *wshrpc.RpcOpts) error {
+	_, err := sendRpcRequestCallHelper[any](w, "remoteprocesssignal", data, opts)
+	return err
+}
+
 // command "remotereconnecttojobmanager", wshserver.RemoteReconnectToJobManagerCommand
 func RemoteReconnectToJobManagerCommand(w *wshutil.WshRpc, data wshrpc.CommandRemoteReconnectToJobManagerData, opts *wshrpc.RpcOpts) (*wshrpc.CommandRemoteReconnectToJobManagerRtnData, error) {
 	resp, err := sendRpcRequestCallHelper[*wshrpc.CommandRemoteReconnectToJobManagerRtnData](w, "remotereconnecttojobmanager", data, opts)