Start to implement action buttons for group VMs

.drone.yml

@@ -5,7 +5,7 @@ name: default
 
 steps:
 - name: frontend_build
-  image: node:24
+  image: node:23
   volumes:
     - name: frontend_app
       path: /tmp/frontend_build

README.md

@@ -1,11 +1,4 @@
 # VirtWeb Remote
-Web UI that allows to start and stop VMs managed by VirtWEB without having to expose the VirtWEB directly on the Internet.
+WIP project
 
-VirtWebRemote rely on OpenID to authenticate users.
-
-VirtWebRemote authenticates against VirtWEB API using an API token. Both the token ID and private key are required to be able to authenticate against the VirtWEB API.
-
-## Docker image options
-```bash
-docker run --rm -it pierre42100/virtweb_remote --help
-```
+This project aims to use the VirtWeb API to start and stop VM without directly exposing the VirtWEB API to the Internet.

remote_backend/Cargo.toml

@@ -1,28 +1,28 @@
 [package]
 name = "remote_backend"
 version = "0.1.0"
-edition = "2024"
+edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-log = "0.4.28"
-env_logger = "0.11.8"
-clap = { version = "4.5.53", features = ["derive", "env"] }
-serde = { version = "1.0.228", features = ["derive"] }
-light-openid = { version = "1.0.4", features = ["crypto-wrapper"] }
-basic-jwt = "0.3.0"
-actix-web = "4.12.1"
+log = "0.4.21"
+env_logger = "0.11.3"
+clap = { version = "4.5.21", features = ["derive", "env"] }
+serde = { version = "1.0.215", features = ["derive"] }
+light-openid = { version = "1.0.2", features = ["crypto-wrapper"] }
+basic-jwt = "0.2.0"
+actix-web = "4.5.1"
 actix-remote-ip = "0.1.0"
-actix-session = { version = "0.11.0", features = ["cookie-session"] }
-actix-identity = "0.9.0"
-actix-cors = "0.7.1"
-lazy_static = "1.5.0"
-anyhow = "1.0.100"
-reqwest = { version = "0.12.24", features = ["json"] }
-thiserror = "2.0.17"
-uuid = { version = "1.18.1", features = ["v4", "serde"] }
-futures-util = "0.3.31"
-lazy-regex = "3.4.2"
-mime_guess = "2.0.5"
-rust-embed = { version = "8.9.0" }
+actix-session = { version = "0.10.1", features = ["cookie-session"] }
+actix-identity = "0.8.0"
+actix-cors = "0.7.0"
+lazy_static = "1.4.0"
+anyhow = "1.0.93"
+reqwest = { version = "0.12.9", features = ["json"] }
+thiserror = "2.0.3"
+uuid = { version = "1.8.0", features = ["v4", "serde"] }
+futures-util = "0.3.30"
+lazy-regex = "3.1.0"
+mime_guess = "2.0.4"
+rust-embed = { version = "8.3.0" }

remote_backend/Dockerfile

@@ -6,4 +6,4 @@ RUN apt-get update \
 
 COPY remote_backend /usr/local/bin/remote_backend
 
-ENTRYPOINT ["/usr/local/bin/remote_backend"]
+ENTRYPOINT /usr/local/bin/remote_backend

remote_backend/src/controllers/auth_controller.rs

@@ -1,6 +1,6 @@
 use actix_remote_ip::RemoteIP;
 use actix_web::web::Data;
-use actix_web::{HttpResponse, Responder, web};
+use actix_web::{web, HttpResponse, Responder};
 use light_openid::basic_state_manager::BasicStateManager;
 
 use crate::app_config::AppConfig;

remote_backend/src/controllers/group_controller.rs

@@ -1,7 +1,7 @@
 use crate::controllers::HttpResult;
 use crate::virtweb_client;
 use crate::virtweb_client::{GroupID, VMUuid};
-use actix_web::{HttpResponse, web};
+use actix_web::{web, HttpResponse};
 
 #[derive(serde::Deserialize)]
 pub struct GroupIDInPath {

remote_backend/src/controllers/mod.rs

@@ -1,8 +1,9 @@
-use actix_web::HttpResponse;
 use actix_web::body::BoxBody;
 use actix_web::http::StatusCode;
+use actix_web::HttpResponse;
 use std::error::Error;
 use std::fmt::{Display, Formatter};
+use std::io::ErrorKind;
 
 pub mod auth_controller;
 pub mod group_controller;
@@ -37,7 +38,7 @@ impl actix_web::error::ResponseError for HttpErr {
         }
     }
     fn error_response(&self) -> HttpResponse<BoxBody> {
-        log::error!("Error while processing request! {self}");
+        log::error!("Error while processing request! {}", self);
 
         HttpResponse::InternalServerError().body("Failed to execute request!")
     }
@@ -51,7 +52,7 @@ impl From<anyhow::Error> for HttpErr {
 
 impl From<Box<dyn Error>> for HttpErr {
     fn from(value: Box<dyn Error>) -> Self {
-        HttpErr::Err(std::io::Error::other(value.to_string()).into())
+        HttpErr::Err(std::io::Error::new(ErrorKind::Other, value.to_string()).into())
     }
 }
 
@@ -81,7 +82,7 @@ impl From<reqwest::header::ToStrError> for HttpErr {
 
 impl From<actix_web::Error> for HttpErr {
     fn from(value: actix_web::Error) -> Self {
-        HttpErr::Err(std::io::Error::other(value.to_string()).into())
+        HttpErr::Err(std::io::Error::new(ErrorKind::Other, value.to_string()).into())
     }
 }
 

remote_backend/src/controllers/static_controller.rs

@@ -18,7 +18,7 @@ mod serve_static_debug {
 
 #[cfg(not(debug_assertions))]
 mod serve_static_release {
-    use actix_web::{HttpResponse, Responder, web};
+    use actix_web::{web, HttpResponse, Responder};
     use rust_embed::RustEmbed;
 
     #[derive(RustEmbed)]

remote_backend/src/controllers/vm_controller.rs

@@ -3,7 +3,7 @@
 use crate::controllers::HttpResult;
 use crate::virtweb_client;
 use crate::virtweb_client::VMUuid;
-use actix_web::{HttpResponse, web};
+use actix_web::{web, HttpResponse};
 
 #[derive(serde::Deserialize)]
 pub struct ReqPath {

remote_backend/src/extractors/auth_extractor.rs

@@ -1,7 +1,7 @@
 use actix_identity::Identity;
 use actix_web::dev::Payload;
 use actix_web::{Error, FromRequest, HttpMessage, HttpRequest};
-use futures_util::future::{Ready, ready};
+use futures_util::future::{ready, Ready};
 use std::fmt::Display;
 
 pub struct AuthExtractor {

remote_backend/src/main.rs

@@ -1,13 +1,13 @@
 use actix_cors::Cors;
+use actix_identity::config::LogoutBehaviour;
 use actix_identity::IdentityMiddleware;
-use actix_identity::config::LogoutBehavior;
 use actix_remote_ip::RemoteIPConfig;
-use actix_session::SessionMiddleware;
 use actix_session::storage::CookieSessionStore;
+use actix_session::SessionMiddleware;
 use actix_web::cookie::{Key, SameSite};
 use actix_web::middleware::Logger;
 use actix_web::web::Data;
-use actix_web::{App, HttpServer, web};
+use actix_web::{web, App, HttpServer};
 use light_openid::basic_state_manager::BasicStateManager;
 use remote_backend::app_config::AppConfig;
 use remote_backend::constants;
@@ -37,7 +37,7 @@ async fn main() -> std::io::Result<()> {
         .build();
 
         let identity_middleware = IdentityMiddleware::builder()
-            .logout_behavior(LogoutBehavior::PurgeSession)
+            .logout_behaviour(LogoutBehaviour::PurgeSession)
             .visit_deadline(Some(Duration::from_secs(
                 constants::MAX_INACTIVITY_DURATION,
             )))

remote_backend/src/middlewares/auth_middleware.rs

@@ -1,4 +1,4 @@
-use std::future::{Ready, ready};
+use std::future::{ready, Ready};
 use std::rc::Rc;
 
 use crate::app_config::AppConfig;
@@ -7,8 +7,8 @@ use crate::extractors::auth_extractor::AuthExtractor;
 use actix_web::body::EitherBody;
 use actix_web::dev::Payload;
 use actix_web::{
+    dev::{forward_ready, Service, ServiceRequest, ServiceResponse, Transform},
     Error, FromRequest, HttpResponse,
-    dev::{Service, ServiceRequest, ServiceResponse, Transform, forward_ready},
 };
 use futures_util::future::LocalBoxFuture;
 

remote_frontend/.eslintrc.cjs

@@ -0,0 +1,18 @@
+module.exports = {
+  root: true,
+  env: { browser: true, es2020: true },
+  extends: [
+    'eslint:recommended',
+    'plugin:@typescript-eslint/recommended',
+    'plugin:react-hooks/recommended',
+  ],
+  ignorePatterns: ['dist', '.eslintrc.cjs'],
+  parser: '@typescript-eslint/parser',
+  plugins: ['react-refresh'],
+  rules: {
+    'react-refresh/only-export-components': [
+      'warn',
+      { allowConstantExport: true },
+    ],
+  },
+}

remote_frontend/eslint.config.js

@@ -1,28 +0,0 @@
-import js from '@eslint/js'
-import globals from 'globals'
-import reactHooks from 'eslint-plugin-react-hooks'
-import reactRefresh from 'eslint-plugin-react-refresh'
-import tseslint from 'typescript-eslint'
-
-export default tseslint.config(
-  { ignores: ['dist'] },
-  {
-    extends: [js.configs.recommended, ...tseslint.configs.recommended],
-    files: ['**/*.{ts,tsx}'],
-    languageOptions: {
-      ecmaVersion: 2020,
-      globals: globals.browser,
-    },
-    plugins: {
-      'react-hooks': reactHooks,
-      'react-refresh': reactRefresh,
-    },
-    rules: {
-      ...reactHooks.configs.recommended.rules,
-      'react-refresh/only-export-components': [
-        'warn',
-        { allowConstantExport: true },
-      ],
-    },
-  },
-)

remote_frontend/package.json

@@ -10,25 +10,22 @@
     "preview": "vite preview"
   },
   "dependencies": {
-    "@fluentui/react-components": "^9.72.7",
-    "@fluentui/react-icons": "^2.0.315",
-    "filesize": "^11.0.13",
-    "react": "^19.2.0",
-    "react-dom": "^19.2.0"
+    "@fluentui/react-components": "^9.56.3",
+    "@fluentui/react-icons": "^2.0.266",
+    "filesize": "^10.1.6",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0"
   },
   "devDependencies": {
-    "@eslint/js": "^9.39.1",
-    "@types/react": "^19.2.7",
-    "@types/react-dom": "^19.2.3",
-    "@typescript-eslint/eslint-plugin": "^8.48.0",
-    "@typescript-eslint/parser": "^8.48.0",
-    "@vitejs/plugin-react": "^5.1.1",
-    "eslint": "^9.39.1",
-    "eslint-plugin-react-hooks": "^5.2.0",
-    "eslint-plugin-react-refresh": "^0.4.24",
-    "globals": "^16.5.0",
-    "typescript": "^5.9.3",
-    "typescript-eslint": "^8.47.0",
-    "vite": "^7.2.4"
+    "@types/react": "^18.3.12",
+    "@types/react-dom": "^18.3.1",
+    "@typescript-eslint/eslint-plugin": "^8.16.0",
+    "@typescript-eslint/parser": "^8.16.0",
+    "@vitejs/plugin-react": "^4.3.4",
+    "eslint": "^8.57.0",
+    "eslint-plugin-react-hooks": "^5.0.0",
+    "eslint-plugin-react-refresh": "^0.4.14",
+    "typescript": "^5.7.2",
+    "vite": "^6.0.1"
   }
 }

remote_frontend/src/App.tsx

@@ -58,12 +58,7 @@ function AuthenticatedApp(): React.ReactElement {
   const [rights, setRights] = React.useState<Rights | undefined>();
 
   const load = async () => {
-    const rights = await ServerApi.GetRights();
-    setRights(rights);
-
-    if (rights!.groups.length > 0) setTab("group");
-    else if (rights!.vms.length > 0) setTab("vm");
-    else setTab("info");
+    setRights(await ServerApi.GetRights());
   };
 
   return (
@@ -92,21 +87,27 @@ function AuthenticatedApp(): React.ReactElement {
                 selectedValue={tab}
                 onTabSelect={(_, d) => setTab(d.value as any)}
               >
-                {rights!.groups.length > 0 && (
-                  <Tab value="group" icon={<AppListIcon />}>
-                    Groups
-                  </Tab>
-                )}
-                {rights!.vms.length > 0 && (
-                  <Tab value="vm" icon={<DesktopIcon />}>
-                    Virtual machines
-                  </Tab>
-                )}
-                {rights!.sys_info && (
-                  <Tab value="info" icon={<InfoIcon />}>
-                    System info
-                  </Tab>
-                )}
+                <Tab
+                  value="group"
+                  icon={<AppListIcon />}
+                  disabled={rights!.groups.length === 0}
+                >
+                  Groups
+                </Tab>
+                <Tab
+                  value="vm"
+                  icon={<DesktopIcon />}
+                  disabled={rights!.vms.length === 0}
+                >
+                  Virtual machines
+                </Tab>
+                <Tab
+                  value="info"
+                  icon={<InfoIcon />}
+                  disabled={!rights!.sys_info}
+                >
+                  System info
+                </Tab>
               </TabList>
               <div>
                 <MainMenu />

remote_frontend/src/api/GroupApi.ts

@@ -1,16 +1,11 @@
 import { APIClient } from "./ApiClient";
 import { VMGroup } from "./ServerApi";
-import { VMInfo, VMState } from "./VMApi";
+import { VMState } from "./VMApi";
 
 export interface GroupVMState {
   [key: string]: VMState;
 }
 
-export interface TreatmentResult {
-  ok: number;
-  failed: number;
-}
-
 export class GroupApi {
   /**
    * Get the state of the VMs of a group
@@ -20,88 +15,4 @@ export class GroupApi {
       await APIClient.exec({ method: "GET", uri: `/group/${g.id}/vm/state` })
     ).data;
   }
-
-  /**
-   * Request to start the VM of a group
-   */
-  static async StartVM(g: VMGroup, vm?: VMInfo): Promise<TreatmentResult> {
-    return (
-      await APIClient.exec({
-        method: "GET",
-        uri: `/group/${g.id}/vm/start` + (vm ? `?vm_id=${vm.uuid}` : ""),
-      })
-    ).data;
-  }
-
-  /**
-   * Request to suspend the VM of a group
-   */
-  static async SuspendVM(g: VMGroup, vm?: VMInfo): Promise<TreatmentResult> {
-    return (
-      await APIClient.exec({
-        method: "GET",
-        uri: `/group/${g.id}/vm/suspend` + (vm ? `?vm_id=${vm.uuid}` : ""),
-      })
-    ).data;
-  }
-
-  /**
-   * Request to resume the VM of a group
-   */
-  static async ResumeVM(g: VMGroup, vm?: VMInfo): Promise<TreatmentResult> {
-    return (
-      await APIClient.exec({
-        method: "GET",
-        uri: `/group/${g.id}/vm/resume` + (vm ? `?vm_id=${vm.uuid}` : ""),
-      })
-    ).data;
-  }
-
-  /**
-   * Request to shutdown the VM of a group
-   */
-  static async ShutdownVM(g: VMGroup, vm?: VMInfo): Promise<TreatmentResult> {
-    return (
-      await APIClient.exec({
-        method: "GET",
-        uri: `/group/${g.id}/vm/shutdown` + (vm ? `?vm_id=${vm.uuid}` : ""),
-      })
-    ).data;
-  }
-
-  /**
-   * Request to kill the VM of a group
-   */
-  static async KillVM(g: VMGroup, vm?: VMInfo): Promise<TreatmentResult> {
-    return (
-      await APIClient.exec({
-        method: "GET",
-        uri: `/group/${g.id}/vm/kill` + (vm ? `?vm_id=${vm.uuid}` : ""),
-      })
-    ).data;
-  }
-
-  /**
-   * Request to reset the VM of a group
-   */
-  static async ResetVM(g: VMGroup, vm?: VMInfo): Promise<TreatmentResult> {
-    return (
-      await APIClient.exec({
-        method: "GET",
-        uri: `/group/${g.id}/vm/reset` + (vm ? `?vm_id=${vm.uuid}` : ""),
-      })
-    ).data;
-  }
-
-  /**
-   * Request a screenshot of the VM of group
-   */
-  static async ScreenshotVM(g: VMGroup, vm?: VMInfo): Promise<Blob> {
-    return (
-      await APIClient.exec({
-        method: "GET",
-        uri: `/group/${g.id}/vm/screenshot` + (vm ? `?vm_id=${vm.uuid}` : ""),
-      })
-    ).data;
-  }
 }

remote_frontend/src/hooks/providers/ThemeProvider.tsx

@@ -20,7 +20,7 @@ type ThemeContext = { theme: Theme; set: (theme: Theme) => void };
 const ThemeContextK = React.createContext<ThemeContext | null>(null);
 
 export function ThemeProvider(p: React.PropsWithChildren): React.ReactElement {
-  const [theme, setTheme] = React.useState<Theme>("teamsdark");
+  const [theme, setTheme] = React.useState<Theme>("highcontrast");
 
   let fluentTheme = teamsHighContrastTheme;
   switch (theme) {

remote_frontend/src/widgets/GroupVMAction.tsx

@@ -1,19 +1,7 @@
-import { Button, Spinner, Toolbar, Tooltip } from "@fluentui/react-components";
-import {
-  ArrowResetRegular,
-  PauseRegular,
-  PlayCircleRegular,
-  PlayFilled,
-  PowerRegular,
-  StopRegular,
-} from "@fluentui/react-icons";
-import React from "react";
-import { GroupApi, TreatmentResult } from "../api/GroupApi";
+import { Button, Toolbar, Tooltip } from "@fluentui/react-components";
+import { PlayRegular } from "@fluentui/react-icons";
 import { VMGroup } from "../api/ServerApi";
 import { VMInfo, VMState } from "../api/VMApi";
-import { useAlert } from "../hooks/providers/AlertDialogProvider";
-import { useConfirm } from "../hooks/providers/ConfirmDialogProvider";
-import { useToast } from "../hooks/providers/ToastProvider";
 
 export function GroupVMAction(p: {
   group: VMGroup;
@@ -24,79 +12,14 @@ export function GroupVMAction(p: {
     <Toolbar>
       <GroupVMButton
         enabled={p.group.can_start}
-        icon={<PlayFilled />}
+        icon={<PlayRegular />}
         tooltip="Start"
         group={p.group}
         vm={p.vm}
         allowedStates={["Shutdown", "Shutoff", "Crashed"]}
         currState={p.state}
         needConfirm={false}
-        action={GroupApi.StartVM}
-      />
-      <GroupVMButton
-        enabled={p.group.can_suspend}
-        icon={<PauseRegular />}
-        tooltip="Suspend"
-        group={p.group}
-        vm={p.vm}
-        allowedStates={["Running"]}
-        currState={p.state}
-        needConfirm={true}
-        action={GroupApi.SuspendVM}
-      />
-      <GroupVMButton
-        enabled={p.group.can_resume}
-        icon={<PlayCircleRegular />}
-        tooltip="Resume"
-        group={p.group}
-        vm={p.vm}
-        allowedStates={["Paused", "PowerManagementSuspended"]}
-        currState={p.state}
-        needConfirm={false}
-        action={GroupApi.ResumeVM}
-      />
-      <GroupVMButton
-        enabled={p.group.can_shutdown}
-        icon={<PowerRegular />}
-        tooltip="Shutdown"
-        group={p.group}
-        vm={p.vm}
-        allowedStates={["Running"]}
-        currState={p.state}
-        needConfirm={true}
-        action={GroupApi.ShutdownVM}
-      />
-      <GroupVMButton
-        enabled={p.group.can_kill}
-        icon={<StopRegular />}
-        tooltip="Kill"
-        group={p.group}
-        vm={p.vm}
-        allowedStates={[
-          "Running",
-          "Paused",
-          "PowerManagementSuspended",
-          "Blocked",
-        ]}
-        currState={p.state}
-        needConfirm={true}
-        action={GroupApi.KillVM}
-      />
-      <GroupVMButton
-        enabled={p.group.can_reset}
-        icon={<ArrowResetRegular />}
-        tooltip="Reset"
-        group={p.group}
-        vm={p.vm}
-        allowedStates={[
-          "Running",
-          "Paused",
-          "PowerManagementSuspended",
-          "Blocked",
-        ]}
-        currState={p.state}
-        needConfirm={true}
-        action={GroupApi.ResetVM}
+        action={async () => {}}
       />
     </Toolbar>
   );
@@ -105,7 +28,7 @@ export function GroupVMAction(p: {
 function GroupVMButton(p: {
   enabled: boolean;
   icon: React.ReactElement;
-  action: (group: VMGroup, vm?: VMInfo) => Promise<TreatmentResult>;
+  action: (group: VMGroup, vm?: VMGroup) => Promise<void>;
   tooltip: string;
   currState?: VMState;
   allowedStates: VMState[];
@@ -113,62 +36,24 @@ function GroupVMButton(p: {
   vm?: VMInfo;
   needConfirm: boolean;
 }): React.ReactElement {
-  const toast = useToast();
-  const confirm = useConfirm();
-  const alert = useAlert();
-
-  const [running, setRunning] = React.useState(false);
-
-  const target = p.vm
-    ? `the VM ${p.vm.name}`
-    : `all the VM of the group ${p.group.id}`;
+  const process = () => {};
 
   const allowed =
     !p.vm || (p.currState && p.allowedStates.includes(p.currState));
 
-  const perform = async () => {
-    if (running || !allowed) return;
-    try {
-      if (
-        (!p.vm || p.needConfirm) &&
-        !(await confirm(
-          `Do you want to perform ${p.tooltip} action on ${target}?`,
-          `Confirmation`,
-          p.tooltip
-        ))
-      ) {
-        return;
-      }
-
-      setRunning(true);
-
-      const result = await p.action(p.group, p.vm);
-
-      toast(
-        p.tooltip,
-        `${p.tooltip} action on ${target}: ${result.ok} OK / ${result.failed} Failed`,
-        "success"
-      );
-    } catch (e) {
-      console.error("Failed to perform group action!", e);
-
-      alert(`Failed to perform ${p.tooltip} action on ${target}: ${e}`);
-    } finally {
-      setRunning(false);
-    }
-  };
-
   if (!p.enabled) return <></>;
 
   return (
     <Tooltip
-      content={`${p.tooltip} ${target}`}
+      content={`${p.tooltip} ${
+        p.vm ? `the VM ${p.vm.name}` : `all the VM of the group ${p.group.id}`
+      }`}
       relationship="description"
       withArrow
     >
       <Button
-        icon={running ? <Spinner size="tiny" /> : p.icon}
-        onClick={allowed ? perform : undefined}
+        icon={p.icon}
+        onClick={process}
         disabled={!allowed}
         appearance="subtle"
       />

remote_frontend/src/widgets/GroupsWidget.tsx

@@ -1,33 +1,21 @@
 import {
-  Button,
   Card,
-  Dialog,
-  DialogActions,
-  DialogBody,
-  DialogContent,
-  DialogSurface,
-  DialogTitle,
-  DialogTrigger,
   Table,
   TableBody,
   TableCell,
-  TableCellActions,
   TableCellLayout,
   TableHeader,
   TableHeaderCell,
   TableRow,
   Title3,
-  Tooltip,
 } from "@fluentui/react-components";
-import { Desktop24Regular, ScreenshotRegular } from "@fluentui/react-icons";
+import { Desktop24Regular } from "@fluentui/react-icons";
 import { filesize } from "filesize";
 import React from "react";
 import { GroupApi, GroupVMState } from "../api/GroupApi";
 import { Rights, VMGroup } from "../api/ServerApi";
-import { VMInfo } from "../api/VMApi";
 import { useToast } from "../hooks/providers/ToastProvider";
 import { GroupVMAction } from "./GroupVMAction";
-import { VMLiveScreenshot } from "./VMLiveScreenshot";
 
 export function GroupsWidget(p: { rights: Rights }): React.ReactElement {
   return (
@@ -43,17 +31,12 @@ function GroupInfo(p: { group: VMGroup }): React.ReactElement {
   const toast = useToast();
 
   const [state, setState] = React.useState<GroupVMState | undefined>();
-  const [screenshotVM, setScreenshotVM] = React.useState<VMInfo | undefined>();
 
   const load = async () => {
     const newState = await GroupApi.State(p.group);
     if (state !== newState) setState(newState);
   };
 
-  const screenshot = (vm: VMInfo) => {
-    setScreenshotVM(vm);
-  };
-
   React.useEffect(() => {
     const interval = setInterval(async () => {
       try {
@@ -71,101 +54,55 @@ function GroupInfo(p: { group: VMGroup }): React.ReactElement {
   });
 
   return (
-    <>
-      <Card
-        style={{
-          margin: "50px 10px",
-          display: "flex",
-          flexDirection: "column",
-        }}
-      >
-        <div style={{ display: "flex", justifyContent: "space-between" }}>
-          <Title3 style={{ marginLeft: "10px" }}>{p.group.id}</Title3>
-          <GroupVMAction group={p.group} />
-        </div>
-        <Table sortable>
-          <TableHeader>
-            <TableRow>
-              <TableHeaderCell>VM</TableHeaderCell>
-              <TableHeaderCell>Resources</TableHeaderCell>
-              <TableHeaderCell>State</TableHeaderCell>
-              <TableHeaderCell>Actions</TableHeaderCell>
-            </TableRow>
-          </TableHeader>
-          <TableBody>
-            {p.group.vms.map((item) => (
-              <TableRow key={item.uuid}>
-                <TableCell>
-                  <TableCellLayout
-                    media={<Desktop24Regular />}
-                    appearance="primary"
-                    description={item.description}
-                  >
-                    {item.name}
-                  </TableCellLayout>
-                  <TableCellActions>
-                    {state?.[item.uuid] === "Running" && (
-                      <Tooltip
-                        relationship="description"
-                        content={"Take a screenshot of the VM screen"}
-                        withArrow
-                      >
-                        <Button
-                          icon={<ScreenshotRegular />}
-                          appearance="subtle"
-                          aria-label="Edit"
-                          disabled={!p.group.can_screenshot}
-                          onClick={() => screenshot(item)}
-                        />
-                      </Tooltip>
-                    )}
-                  </TableCellActions>
-                </TableCell>
-                <TableCell>
-                  {item.architecture} &bull; RAM :{" "}
-                  {filesize(item.memory)} &bull;{" "}
-                  {item.number_vcpu} vCPU
-                </TableCell>
-                <TableCell>{state?.[item.uuid] ?? ""}</TableCell>
-                <TableCell>
-                  <GroupVMAction
-                    group={p.group}
-                    state={state?.[item.uuid]}
-                    vm={item}
-                  />
-                </TableCell>
-              </TableRow>
-            ))}
-          </TableBody>
-        </Table>
-      </Card>
-      <Dialog
-        open={!!screenshotVM}
-        onOpenChange={(_event, _data) => {
-          if (!screenshotVM) setScreenshotVM(undefined);
-        }}
-      >
-        <DialogSurface>
-          <DialogBody>
-            <DialogTitle>
-              <em>{screenshotVM?.name}</em> screen
-            </DialogTitle>
-            <DialogContent>
-              <VMLiveScreenshot vm={screenshotVM!} group={p.group} />
-            </DialogContent>
-            <DialogActions>
-              <DialogTrigger disableButtonEnhancement>
-                <Button
-                  appearance="secondary"
-                  onClick={() => setScreenshotVM(undefined)}
+    <Card
+      style={{
+        margin: "50px 10px",
+        display: "flex",
+        flexDirection: "column",
+      }}
+    >
+      <div style={{ display: "flex", justifyContent: "space-between" }}>
+        <Title3 style={{ marginLeft: "10px" }}>{p.group.id}</Title3>
+        <GroupVMAction group={p.group} />
+      </div>
+      <Table sortable>
+        <TableHeader>
+          <TableRow>
+            <TableHeaderCell>VM</TableHeaderCell>
+            <TableHeaderCell>Resources</TableHeaderCell>
+            <TableHeaderCell>State</TableHeaderCell>
+            <TableHeaderCell>Actions</TableHeaderCell>
+          </TableRow>
+        </TableHeader>
+        <TableBody>
+          {p.group.vms.map((item) => (
+            <TableRow key={item.uuid}>
+              <TableCell>
+                <TableCellLayout
+                  media={<Desktop24Regular />}
+                  appearance="primary"
+                  description={item.description}
                 >
-                  Close
-                </Button>
-              </DialogTrigger>
-            </DialogActions>
-          </DialogBody>
-        </DialogSurface>
-      </Dialog>
-    </>
+                  {item.name}
+                </TableCellLayout>
+              </TableCell>
+              <TableCell>
+                {item.architecture} &bull; RAM :{" "}
+                {filesize(item.memory * 1000 * 1000)} &bull; {item.number_vcpu}{" "}
+                vCPU
+              </TableCell>
+              <TableCell>{state?.[item.uuid] ?? ""}</TableCell>
+              <TableCell>
+                <GroupVMAction
+                  group={p.group}
+                  state={state?.[item.uuid]}
+                  vm={item}
+                />
+              </TableCell>
+            </TableRow>
+          ))}
+        </TableBody>
+      </Table>
+    </Card>
   );
 }

remote_frontend/src/widgets/VMLiveScreenshot.tsx

@@ -1,13 +1,8 @@
 import React from "react";
-import { GroupApi } from "../api/GroupApi";
-import { VMGroup } from "../api/ServerApi";
 import { VMApi, VMInfo } from "../api/VMApi";
 import { useToast } from "../hooks/providers/ToastProvider";
 
-export function VMLiveScreenshot(p: {
-  vm: VMInfo;
-  group?: VMGroup;
-}): React.ReactElement {
+export function VMLiveScreenshot(p: { vm: VMInfo }): React.ReactElement {
   const toast = useToast();
 
   const [screenshotURL, setScreenshotURL] = React.useState<
@@ -19,9 +14,7 @@ export function VMLiveScreenshot(p: {
   React.useEffect(() => {
     const refresh = async () => {
       try {
-        const screenshot = p.group
-          ? await GroupApi.ScreenshotVM(p.group, p.vm)
-          : await VMApi.Screenshot(p.vm);
+        const screenshot = await VMApi.Screenshot(p.vm);
         const u = URL.createObjectURL(screenshot);
         setScreenshotURL(u);
       } catch (e) {

remote_frontend/src/widgets/VirtualMachinesWidget.tsx

@@ -25,8 +25,8 @@ import { Rights } from "../api/ServerApi";
 import { VMApi, VMInfo, VMInfoAndCaps, VMState } from "../api/VMApi";
 import { useConfirm } from "../hooks/providers/ConfirmDialogProvider";
 import { useToast } from "../hooks/providers/ToastProvider";
-import { SectionContainer } from "./SectionContainer";
 import { VMLiveScreenshot } from "./VMLiveScreenshot";
+import { SectionContainer } from "./SectionContainer";
 
 const useStyles = makeStyles({
   body1Stronger: typographyStyles.body1Stronger,
@@ -107,7 +107,7 @@ function VMWidget(p: { vm: VMInfoAndCaps }): React.ReactElement {
         }
       />
       <p className={styles.caption1} style={{ margin: "0px auto" }}>
-        {p.vm.architecture} &bull; RAM : {filesize(p.vm.memory)}{" "}
+        {p.vm.architecture} &bull; RAM : {filesize(p.vm.memory * 1000 * 1000)}{" "}
         &bull; {p.vm.number_vcpu} vCPU
       </p>
 

remote_frontend/tsconfig.app.json

@@ -1,26 +0,0 @@
-{
-  "compilerOptions": {
-    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
-    "target": "ES2020",
-    "useDefineForClassFields": true,
-    "lib": ["ES2020", "DOM", "DOM.Iterable"],
-    "module": "ESNext",
-    "skipLibCheck": true,
-
-    /* Bundler mode */
-    "moduleResolution": "bundler",
-    "allowImportingTsExtensions": true,
-    "isolatedModules": true,
-    "moduleDetection": "force",
-    "noEmit": true,
-    "jsx": "react-jsx",
-
-    /* Linting */
-    "strict": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true,
-    "noFallthroughCasesInSwitch": true,
-    "noUncheckedSideEffectImports": true
-  },
-  "include": ["src"]
-}

remote_frontend/tsconfig.json

@@ -1,7 +1,25 @@
 {
-  "files": [],
-  "references": [
-    { "path": "./tsconfig.app.json" },
-    { "path": "./tsconfig.node.json" }
-  ]
+  "compilerOptions": {
+    "target": "ES2020",
+    "useDefineForClassFields": true,
+    "lib": ["ES2020", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "jsx": "react-jsx",
+
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": ["src"],
+  "references": [{ "path": "./tsconfig.node.json" }]
 }

remote_frontend/tsconfig.node.json

@@ -1,24 +1,11 @@
 {
   "compilerOptions": {
-    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsbuildinfo",
-    "target": "ES2022",
-    "lib": ["ES2023"],
-    "module": "ESNext",
+    "composite": true,
     "skipLibCheck": true,
-
-    /* Bundler mode */
+    "module": "ESNext",
     "moduleResolution": "bundler",
-    "allowImportingTsExtensions": true,
-    "isolatedModules": true,
-    "moduleDetection": "force",
-    "noEmit": true,
-
-    /* Linting */
-    "strict": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true,
-    "noFallthroughCasesInSwitch": true,
-    "noUncheckedSideEffectImports": true
+    "allowSyntheticDefaultImports": true,
+    "strict": true
   },
   "include": ["vite.config.ts"]
 }

remote_frontend/vite.config.ts

@@ -1,7 +1,7 @@
 import { defineConfig } from 'vite'
 import react from '@vitejs/plugin-react'
 
-// https://vite.dev/config/
+// https://vitejs.dev/config/
 export default defineConfig({
   plugins: [react()],
 })

renovate.json

@@ -1,3 +1,9 @@
 {
-  "extends": ["local>renovate/presets"]
+  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+  "packageRules": [
+    {
+      "matchUpdateTypes": ["major", "minor", "patch"],
+      "automerge": true
+    }
+  ]
 }