Obtenir les ressources système d'un VPS

Instructions

Implementation Reference

• server.js:239-264 (handler)

  The handler function queues an SSH job to run 'uptime && free -h && df -h /' on the specified server, waits for completion, parses the output with ssh.parseSystemResources, and returns JSON formatted resources or error.

      async (params) => {
          try {
              const job = queue.addJob({
                  type: 'ssh',
                  alias: params.alias,
                  cmd: "uptime && free -h && df -h /"
              });
              ssh.executeCommand(job.id);
              const result = await waitForJobCompletion(job.id, config.syncTimeout);
  
              if (!result || result.status !== 'completed') {
                  throw new Error(result ? result.error : `Timeout de la commande de monitoring pour ${params.alias}`);
              }
  
              const parsedOutput = ssh.parseSystemResources(result.output);
              return { content: [{ type: "text", text: JSON.stringify(parsedOutput, null, 2) }] };
          } catch (e) {
              const errorPayload = {
                  toolName: "get_system_resources",
                  errorCode: "MONITORING_ERROR",
                  errorMessage: e.message
              };
              return { content: [{ type: "text", text: JSON.stringify(errorPayload, null, 2) }], isError: true };
          }
      }
  );

• server.js:232-238 (schema)

  Input schema defining the required 'alias' parameter for the target server.

  {
      title: "Obtenir les ressources système d'un VPS",
      description: "Récupère les métriques système vitales (CPU, RAM, Disque) d'un serveur.",
      inputSchema: z.object({
          alias: z.string().describe("Alias du serveur cible.")
      })
  },

• server.js:230-264 (registration)

  Registration of the 'get_system_resources' tool using server.registerTool, including schema and inline handler function.

  server.registerTool(
      "get_system_resources",
      {
          title: "Obtenir les ressources système d'un VPS",
          description: "Récupère les métriques système vitales (CPU, RAM, Disque) d'un serveur.",
          inputSchema: z.object({
              alias: z.string().describe("Alias du serveur cible.")
          })
      },
      async (params) => {
          try {
              const job = queue.addJob({
                  type: 'ssh',
                  alias: params.alias,
                  cmd: "uptime && free -h && df -h /"
              });
              ssh.executeCommand(job.id);
              const result = await waitForJobCompletion(job.id, config.syncTimeout);
  
              if (!result || result.status !== 'completed') {
                  throw new Error(result ? result.error : `Timeout de la commande de monitoring pour ${params.alias}`);
              }
  
              const parsedOutput = ssh.parseSystemResources(result.output);
              return { content: [{ type: "text", text: JSON.stringify(parsedOutput, null, 2) }] };
          } catch (e) {
              const errorPayload = {
                  toolName: "get_system_resources",
                  errorCode: "MONITORING_ERROR",
                  errorMessage: e.message
              };
              return { content: [{ type: "text", text: JSON.stringify(errorPayload, null, 2) }], isError: true };
          }
      }
  );

• ssh.js:368-411 (helper)

  Helper function in ssh.js that parses the raw output from 'uptime && free -h && df -h /' into structured load average, memory, and disk usage data.

  function parseSystemResources(output) {
      const resources = {
          load_average: null,
          memory: null,
          disk: null
      };
      const lines = output.split('\n');
  
      try {
          const uptimeLine = lines.find(line => line.includes('load average:'));
          if (uptimeLine) {
              const parts = uptimeLine.split('load average:')[1];
              resources.load_average = parts.split(',').map(s => s.trim());
          }
  
          const memLine = lines.find(line => line.trim().startsWith('Mem:'));
          if (memLine) {
              const parts = memLine.trim().split(/\s+/);
              resources.memory = {
                  total: parts[1],
                  used: parts[2],
                  free: parts[3],
                  available: parts[6]
              };
          }
  
          const diskLine = lines.find(line => line.startsWith('/dev/'));
          if (diskLine) {
              const parts = diskLine.trim().split(/\s+/);
              resources.disk = {
                  filesystem: parts[0],
                  total: parts[1],
                  used: parts[2],
                  available: parts[3],
                  use_percent: parts[4]
              };
          }
      } catch (e) {
          // En cas d'erreur de parsing, retourner les données brutes
          return { raw_output: output, parsing_error: e.message };
      }
  
      return resources;
  }