myaidev-method 0.3.4 → 0.3.5

package/dist/mcp/openstack-server.js

@@ -29,7 +29,7 @@ const DEFAULT_CLOUD_INIT = process.env.CLOUD_INIT;
 const server = new McpServer({
   name: "openstack-mcp-server",
   version: "1.0.0",
-  description: "OpenStack MCP Server for VM management and orchestration"
+  description: "OpenStack MCP Server for VM management and orchestration",
 });
 
 // Session storage for tracking operations
@@ -56,7 +56,7 @@ function getOpenStackEnv() {
     OS_AUTH_VERSION: OS_IDENTITY_API_VERSION,
     OS_ENDPOINT_TYPE: "publicURL",
     OS_INTERFACE: "publicURL",
-    OS_NO_CACHE: "1"
+    OS_NO_CACHE: "1",
   };
 }
 
@@ -67,13 +67,17 @@ async function runOpenStackCommand(args, timeout = 120000) {
 
     // Check for required environment variables
     if (!OS_AUTH_URL || !OS_USERNAME || !OS_PASSWORD || !OS_PROJECT_ID) {
-      reject(new Error("Missing required OpenStack environment variables. Please configure using /myai-configure openstack"));
+      reject(
+        new Error(
+          "Missing required OpenStack environment variables. Please configure using /myai-configurator openstack",
+        ),
+      );
       return;
     }
 
     const proc = spawn("openstack", args, {
       env,
-      stdio: ["pipe", "pipe", "pipe"]
+      stdio: ["pipe", "pipe", "pipe"],
     });
 
     let stdout = "";
@@ -95,7 +99,11 @@ async function runOpenStackCommand(args, timeout = 120000) {
     proc.on("close", (code) => {
       clearTimeout(timeoutId);
       if (code === 0) {
-        resolve({ success: true, output: stdout.trim(), stderr: stderr.trim() });
+        resolve({
+          success: true,
+          output: stdout.trim(),
+          stderr: stderr.trim(),
+        });
       } else {
         reject(new Error(stderr || `Command failed with exit code ${code}`));
       }
@@ -110,15 +118,21 @@ async function runOpenStackCommand(args, timeout = 120000) {
 
 // Parse OpenStack table output to JSON
 function parseTableOutput(output) {
-  const lines = output.split("\n").filter(line => line.trim() && !line.startsWith("+"));
+  const lines = output
+    .split("\n")
+    .filter((line) => line.trim() && !line.startsWith("+"));
   if (lines.length < 2) return [];
 
-  const headers = lines[0].split("|")
-    .map(h => h.trim().toLowerCase().replace(/\s+/g, "_"))
-    .filter(h => h);
+  const headers = lines[0]
+    .split("|")
+    .map((h) => h.trim().toLowerCase().replace(/\s+/g, "_"))
+    .filter((h) => h);
 
-  return lines.slice(1).map(line => {
-    const values = line.split("|").map(v => v.trim()).filter(v => v !== "");
+  return lines.slice(1).map((line) => {
+    const values = line
+      .split("|")
+      .map((v) => v.trim())
+      .filter((v) => v !== "");
     const obj = {};
     headers.forEach((header, i) => {
       obj[header] = values[i] || "";
@@ -132,7 +146,7 @@ async function fetchFromUrl(url) {
   return new Promise((resolve, reject) => {
     // Convert GitHub Gist URL to raw URL if needed
     let fetchUrl = url;
-    if (url.includes('gist.github.com') && !url.includes('/raw')) {
+    if (url.includes("gist.github.com") && !url.includes("/raw")) {
       // Extract gist ID and convert to raw URL
       const gistMatch = url.match(/gist\.github\.com\/([^\/]+)\/([a-f0-9]+)/);
       if (gistMatch) {
@@ -140,33 +154,45 @@ async function fetchFromUrl(url) {
       }
     }
 
-    const protocol = fetchUrl.startsWith('https') ? https : http;
+    const protocol = fetchUrl.startsWith("https") ? https : http;
 
-    const request = protocol.get(fetchUrl, {
-      headers: {
-        'User-Agent': 'MyAIDev-Method-OpenStack-MCP/1.0'
-      }
-    }, (response) => {
-      // Handle redirects
-      if (response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) {
-        fetchFromUrl(response.headers.location).then(resolve).catch(reject);
-        return;
-      }
+    const request = protocol.get(
+      fetchUrl,
+      {
+        headers: {
+          "User-Agent": "MyAIDev-Method-OpenStack-MCP/1.0",
+        },
+      },
+      (response) => {
+        // Handle redirects
+        if (
+          response.statusCode >= 300 &&
+          response.statusCode < 400 &&
+          response.headers.location
+        ) {
+          fetchFromUrl(response.headers.location).then(resolve).catch(reject);
+          return;
+        }
 
-      if (response.statusCode !== 200) {
-        reject(new Error(`HTTP ${response.statusCode}: Failed to fetch ${fetchUrl}`));
-        return;
-      }
+        if (response.statusCode !== 200) {
+          reject(
+            new Error(
+              `HTTP ${response.statusCode}: Failed to fetch ${fetchUrl}`,
+            ),
+          );
+          return;
+        }
 
-      let data = '';
-      response.on('data', chunk => data += chunk);
-      response.on('end', () => resolve(data));
-    });
+        let data = "";
+        response.on("data", (chunk) => (data += chunk));
+        response.on("end", () => resolve(data));
+      },
+    );
 
-    request.on('error', reject);
+    request.on("error", reject);
     request.setTimeout(30000, () => {
       request.destroy();
-      reject(new Error('Request timeout'));
+      reject(new Error("Request timeout"));
     });
   });
 }
@@ -177,7 +203,7 @@ async function resolveCloudInit(params) {
 
   // 1. Explicit user_data content provided
   if (params.user_data) {
-    return { content: params.user_data, source: 'inline' };
+    return { content: params.user_data, source: "inline" };
   }
 
   // 2. Cloud-init URL provided
@@ -193,7 +219,7 @@ async function resolveCloudInit(params) {
   // 3. Cloud-init file path provided
   if (params.cloud_init_file) {
     try {
-      const content = fs.readFileSync(params.cloud_init_file, 'utf8');
+      const content = fs.readFileSync(params.cloud_init_file, "utf8");
       return { content, source: `file:${params.cloud_init_file}` };
     } catch (error) {
       throw new Error(`Failed to read cloud-init file: ${error.message}`);
@@ -204,11 +230,14 @@ async function resolveCloudInit(params) {
   if (params.use_default_cloud_init && DEFAULT_CLOUD_INIT) {
     try {
       // Check if it's a URL or file path
-      if (DEFAULT_CLOUD_INIT.startsWith('http://') || DEFAULT_CLOUD_INIT.startsWith('https://')) {
+      if (
+        DEFAULT_CLOUD_INIT.startsWith("http://") ||
+        DEFAULT_CLOUD_INIT.startsWith("https://")
+      ) {
         const content = await fetchFromUrl(DEFAULT_CLOUD_INIT);
         return { content, source: `default_url:${DEFAULT_CLOUD_INIT}` };
       } else {
-        const content = fs.readFileSync(DEFAULT_CLOUD_INIT, 'utf8');
+        const content = fs.readFileSync(DEFAULT_CLOUD_INIT, "utf8");
         return { content, source: `default_file:${DEFAULT_CLOUD_INIT}` };
       }
     } catch (error) {
@@ -221,1369 +250,1825 @@ async function resolveCloudInit(params) {
 }
 
 // Cloud-init fetch and preview tool
-server.registerTool("os_cloud_init_fetch", {
-  title: "Fetch Cloud-Init Configuration",
-  description: "Fetch and preview cloud-init configuration from URL, file, or default",
-  inputSchema: {
-    type: "object",
-    properties: {
-      url: {
-        type: "string",
-        description: "URL to fetch cloud-init from (supports GitHub Gist URLs)"
-      },
-      file: {
-        type: "string",
-        description: "Local file path to cloud-init script"
+server.registerTool(
+  "os_cloud_init_fetch",
+  {
+    title: "Fetch Cloud-Init Configuration",
+    description:
+      "Fetch and preview cloud-init configuration from URL, file, or default",
+    inputSchema: {
+      type: "object",
+      properties: {
+        url: {
+          type: "string",
+          description:
+            "URL to fetch cloud-init from (supports GitHub Gist URLs)",
+        },
+        file: {
+          type: "string",
+          description: "Local file path to cloud-init script",
+        },
+        use_default: {
+          type: "boolean",
+          description: "Fetch from the default CLOUD_INIT environment variable",
+          default: false,
+        },
       },
-      use_default: {
-        type: "boolean",
-        description: "Fetch from the default CLOUD_INIT environment variable",
-        default: false
-      }
+      additionalProperties: false,
     },
-    additionalProperties: false
-  }
-}, async (params) => {
-  try {
-    let content = null;
-    let source = null;
-
-    if (params.url) {
-      content = await fetchFromUrl(params.url);
-      source = `url:${params.url}`;
-    } else if (params.file) {
-      content = fs.readFileSync(params.file, 'utf8');
-      source = `file:${params.file}`;
-    } else if (params.use_default && DEFAULT_CLOUD_INIT) {
-      if (DEFAULT_CLOUD_INIT.startsWith('http://') || DEFAULT_CLOUD_INIT.startsWith('https://')) {
-        content = await fetchFromUrl(DEFAULT_CLOUD_INIT);
-        source = `default_url:${DEFAULT_CLOUD_INIT}`;
+  },
+  async (params) => {
+    try {
+      let content = null;
+      let source = null;
+
+      if (params.url) {
+        content = await fetchFromUrl(params.url);
+        source = `url:${params.url}`;
+      } else if (params.file) {
+        content = fs.readFileSync(params.file, "utf8");
+        source = `file:${params.file}`;
+      } else if (params.use_default && DEFAULT_CLOUD_INIT) {
+        if (
+          DEFAULT_CLOUD_INIT.startsWith("http://") ||
+          DEFAULT_CLOUD_INIT.startsWith("https://")
+        ) {
+          content = await fetchFromUrl(DEFAULT_CLOUD_INIT);
+          source = `default_url:${DEFAULT_CLOUD_INIT}`;
+        } else {
+          content = fs.readFileSync(DEFAULT_CLOUD_INIT, "utf8");
+          source = `default_file:${DEFAULT_CLOUD_INIT}`;
+        }
+      } else if (params.use_default && !DEFAULT_CLOUD_INIT) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  success: false,
+                  error: "No default CLOUD_INIT configured in environment",
+                },
+                null,
+                2,
+              ),
+            },
+          ],
+        };
       } else {
-        content = fs.readFileSync(DEFAULT_CLOUD_INIT, 'utf8');
-        source = `default_file:${DEFAULT_CLOUD_INIT}`;
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  success: false,
+                  error: "Please provide url, file, or set use_default to true",
+                },
+                null,
+                2,
+              ),
+            },
+          ],
+        };
       }
-    } else if (params.use_default && !DEFAULT_CLOUD_INIT) {
+
       return {
-        content: [{
-          type: "text",
-          text: JSON.stringify({
-            success: false,
-            error: "No default CLOUD_INIT configured in environment"
-          }, null, 2)
-        }]
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: true,
+                source,
+                content_length: content.length,
+                preview:
+                  content.substring(0, 2000) +
+                  (content.length > 2000 ? "\n... (truncated)" : ""),
+                full_content: content,
+              },
+              null,
+              2,
+            ),
+          },
+        ],
       };
-    } else {
+    } catch (error) {
       return {
-        content: [{
-          type: "text",
-          text: JSON.stringify({
-            success: false,
-            error: "Please provide url, file, or set use_default to true"
-          }, null, 2)
-        }]
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: false,
+                error: error.message,
+              },
+              null,
+              2,
+            ),
+          },
+        ],
       };
     }
+  },
+);
 
+// Get default cloud-init info
+server.registerTool(
+  "os_cloud_init_info",
+  {
+    title: "Cloud-Init Info",
+    description: "Get information about configured cloud-init defaults",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      additionalProperties: false,
+    },
+  },
+  async () => {
     return {
-      content: [{
-        type: "text",
-        text: JSON.stringify({
-          success: true,
-          source,
-          content_length: content.length,
-          preview: content.substring(0, 2000) + (content.length > 2000 ? '\n... (truncated)' : ''),
-          full_content: content
-        }, null, 2)
-      }]
-    };
-  } catch (error) {
-    return {
-      content: [{
-        type: "text",
-        text: JSON.stringify({
-          success: false,
-          error: error.message
-        }, null, 2)
-      }]
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(
+            {
+              success: true,
+              default_cloud_init: DEFAULT_CLOUD_INIT || null,
+              configured: !!DEFAULT_CLOUD_INIT,
+              type: DEFAULT_CLOUD_INIT
+                ? DEFAULT_CLOUD_INIT.startsWith("http")
+                  ? "url"
+                  : "file"
+                : null,
+              usage: {
+                use_default:
+                  "Set use_default_cloud_init: true when creating a server",
+                custom_url: "Provide cloud_init_url parameter with any URL",
+                custom_file:
+                  "Provide cloud_init_file parameter with local path",
+                inline: "Provide user_data parameter with YAML content",
+              },
+            },
+            null,
+            2,
+          ),
+        },
+      ],
     };
-  }
-});
-
-// Get default cloud-init info
-server.registerTool("os_cloud_init_info", {
-  title: "Cloud-Init Info",
-  description: "Get information about configured cloud-init defaults",
-  inputSchema: {
-    type: "object",
-    properties: {},
-    additionalProperties: false
-  }
-}, async () => {
-  return {
-    content: [{
-      type: "text",
-      text: JSON.stringify({
-        success: true,
-        default_cloud_init: DEFAULT_CLOUD_INIT || null,
-        configured: !!DEFAULT_CLOUD_INIT,
-        type: DEFAULT_CLOUD_INIT ?
-          (DEFAULT_CLOUD_INIT.startsWith('http') ? 'url' : 'file') :
-          null,
-        usage: {
-          use_default: "Set use_default_cloud_init: true when creating a server",
-          custom_url: "Provide cloud_init_url parameter with any URL",
-          custom_file: "Provide cloud_init_file parameter with local path",
-          inline: "Provide user_data parameter with YAML content"
-        }
-      }, null, 2)
-    }]
-  };
-});
+  },
+);
 
 // Session management tool
-server.registerTool("os_session_create", {
-  title: "Create OpenStack Session",
-  description: "Create a new session for tracking OpenStack operations",
-  inputSchema: {
-    type: "object",
-    properties: {
-      description: {
-        type: "string",
-        description: "Description of the session purpose"
-      }
+server.registerTool(
+  "os_session_create",
+  {
+    title: "Create OpenStack Session",
+    description: "Create a new session for tracking OpenStack operations",
+    inputSchema: {
+      type: "object",
+      properties: {
+        description: {
+          type: "string",
+          description: "Description of the session purpose",
+        },
+      },
+      additionalProperties: false,
     },
-    additionalProperties: false
-  }
-}, async (params) => {
-  const sessionId = generateSessionId();
-  sessions.set(sessionId, {
-    id: sessionId,
-    description: params.description || "OpenStack operations session",
-    created: new Date().toISOString(),
-    operations: []
-  });
+  },
+  async (params) => {
+    const sessionId = generateSessionId();
+    sessions.set(sessionId, {
+      id: sessionId,
+      description: params.description || "OpenStack operations session",
+      created: new Date().toISOString(),
+      operations: [],
+    });
 
-  return {
-    content: [{
-      type: "text",
-      text: JSON.stringify({
-        success: true,
-        session_id: sessionId,
-        message: "Session created successfully"
-      }, null, 2)
-    }]
-  };
-});
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(
+            {
+              success: true,
+              session_id: sessionId,
+              message: "Session created successfully",
+            },
+            null,
+            2,
+          ),
+        },
+      ],
+    };
+  },
+);
 
 // Health check tool
-server.registerTool("os_health_check", {
-  title: "OpenStack Health Check",
-  description: "Check OpenStack API connectivity and authentication",
-  inputSchema: {
-    type: "object",
-    properties: {},
-    additionalProperties: false
-  }
-}, async () => {
-  try {
-    const result = await runOpenStackCommand(["token", "issue", "-f", "json"]);
-    const tokenInfo = JSON.parse(result.output);
+server.registerTool(
+  "os_health_check",
+  {
+    title: "OpenStack Health Check",
+    description: "Check OpenStack API connectivity and authentication",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      additionalProperties: false,
+    },
+  },
+  async () => {
+    try {
+      const result = await runOpenStackCommand([
+        "token",
+        "issue",
+        "-f",
+        "json",
+      ]);
+      const tokenInfo = JSON.parse(result.output);
 
-    return {
-      content: [{
-        type: "text",
-        text: JSON.stringify({
-          success: true,
-          message: "OpenStack API is responding",
-          auth_url: OS_AUTH_URL,
-          project_id: OS_PROJECT_ID,
-          region: OS_REGION_NAME,
-          token_expires: tokenInfo.expires,
-          server_version: "1.0.0"
-        }, null, 2)
-      }]
-    };
-  } catch (error) {
-    return {
-      content: [{
-        type: "text",
-        text: JSON.stringify({
-          success: false,
-          error: error.message,
-          suggestion: "Check your OpenStack credentials. Run /myai-configure openstack to reconfigure."
-        }, null, 2)
-      }]
-    };
-  }
-});
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: true,
+                message: "OpenStack API is responding",
+                auth_url: OS_AUTH_URL,
+                project_id: OS_PROJECT_ID,
+                region: OS_REGION_NAME,
+                token_expires: tokenInfo.expires,
+                server_version: "1.0.0",
+              },
+              null,
+              2,
+            ),
+          },
+        ],
+      };
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: false,
+                error: error.message,
+                suggestion:
+                  "Check your OpenStack credentials. Run /myai-configure openstack to reconfigure.",
+              },
+              null,
+              2,
+            ),
+          },
+        ],
+      };
+    }
+  },
+);
 
 // List available images
-server.registerTool("os_image_list", {
-  title: "List OpenStack Images",
-  description: "List available VM images in OpenStack",
-  inputSchema: {
-    type: "object",
-    properties: {
-      limit: {
-        type: "number",
-        description: "Maximum number of images to return",
-        default: 20
+server.registerTool(
+  "os_image_list",
+  {
+    title: "List OpenStack Images",
+    description: "List available VM images in OpenStack",
+    inputSchema: {
+      type: "object",
+      properties: {
+        limit: {
+          type: "number",
+          description: "Maximum number of images to return",
+          default: 20,
+        },
+        status: {
+          type: "string",
+          enum: ["active", "queued", "saving", "deleted"],
+          description: "Filter by image status",
+        },
       },
-      status: {
-        type: "string",
-        enum: ["active", "queued", "saving", "deleted"],
-        description: "Filter by image status"
-      }
+      additionalProperties: false,
     },
-    additionalProperties: false
-  }
-}, async (params) => {
-  try {
-    const args = ["image", "list", "-f", "json"];
-    if (params.limit) args.push("--limit", params.limit.toString());
-    if (params.status) args.push("--status", params.status);
+  },
+  async (params) => {
+    try {
+      const args = ["image", "list", "-f", "json"];
+      if (params.limit) args.push("--limit", params.limit.toString());
+      if (params.status) args.push("--status", params.status);
 
-    const result = await runOpenStackCommand(args);
-    const images = JSON.parse(result.output);
+      const result = await runOpenStackCommand(args);
+      const images = JSON.parse(result.output);
 
-    return {
-      content: [{
-        type: "text",
-        text: JSON.stringify({
-          success: true,
-          count: images.length,
-          images: images.map(img => ({
-            id: img.ID,
-            name: img.Name,
-            status: img.Status
-          }))
-        }, null, 2)
-      }]
-    };
-  } catch (error) {
-    return {
-      content: [{
-        type: "text",
-        text: JSON.stringify({
-          success: false,
-          error: error.message
-        }, null, 2)
-      }]
-    };
-  }
-});
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: true,
+                count: images.length,
+                images: images.map((img) => ({
+                  id: img.ID,
+                  name: img.Name,
+                  status: img.Status,
+                })),
+              },
+              null,
+              2,
+            ),
+          },
+        ],
+      };
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: false,
+                error: error.message,
+              },
+              null,
+              2,
+            ),
+          },
+        ],
+      };
+    }
+  },
+);
 
 // List available flavors
-server.registerTool("os_flavor_list", {
-  title: "List OpenStack Flavors",
-  description: "List available VM flavors (instance sizes) in OpenStack",
-  inputSchema: {
-    type: "object",
-    properties: {},
-    additionalProperties: false
-  }
-}, async () => {
-  try {
-    const result = await runOpenStackCommand(["flavor", "list", "-f", "json"]);
-    const flavors = JSON.parse(result.output);
+server.registerTool(
+  "os_flavor_list",
+  {
+    title: "List OpenStack Flavors",
+    description: "List available VM flavors (instance sizes) in OpenStack",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      additionalProperties: false,
+    },
+  },
+  async () => {
+    try {
+      const result = await runOpenStackCommand([
+        "flavor",
+        "list",
+        "-f",
+        "json",
+      ]);
+      const flavors = JSON.parse(result.output);
 
-    return {
-      content: [{
-        type: "text",
-        text: JSON.stringify({
-          success: true,
-          count: flavors.length,
-          flavors: flavors.map(f => ({
-            id: f.ID,
-            name: f.Name,
-            vcpus: f.VCPUs,
-            ram_mb: f.RAM,
-            disk_gb: f.Disk
-          }))
-        }, null, 2)
-      }]
-    };
-  } catch (error) {
-    return {
-      content: [{
-        type: "text",
-        text: JSON.stringify({
-          success: false,
-          error: error.message
-        }, null, 2)
-      }]
-    };
-  }
-});
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: true,
+                count: flavors.length,
+                flavors: flavors.map((f) => ({
+                  id: f.ID,
+                  name: f.Name,
+                  vcpus: f.VCPUs,
+                  ram_mb: f.RAM,
+                  disk_gb: f.Disk,
+                })),
+              },
+              null,
+              2,
+            ),
+          },
+        ],
+      };
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: false,
+                error: error.message,
+              },
+              null,
+              2,
+            ),
+          },
+        ],
+      };
+    }
+  },
+);
 
 // List available networks
-server.registerTool("os_network_list", {
-  title: "List OpenStack Networks",
-  description: "List available networks in OpenStack",
-  inputSchema: {
-    type: "object",
-    properties: {},
-    additionalProperties: false
-  }
-}, async () => {
-  try {
-    const result = await runOpenStackCommand(["network", "list", "-f", "json"]);
-    const networks = JSON.parse(result.output);
+server.registerTool(
+  "os_network_list",
+  {
+    title: "List OpenStack Networks",
+    description: "List available networks in OpenStack",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      additionalProperties: false,
+    },
+  },
+  async () => {
+    try {
+      const result = await runOpenStackCommand([
+        "network",
+        "list",
+        "-f",
+        "json",
+      ]);
+      const networks = JSON.parse(result.output);
 
-    return {
-      content: [{
-        type: "text",
-        text: JSON.stringify({
-          success: true,
-          count: networks.length,
-          networks: networks.map(n => ({
-            id: n.ID,
-            name: n.Name,
-            subnets: n.Subnets
-          }))
-        }, null, 2)
-      }]
-    };
-  } catch (error) {
-    return {
-      content: [{
-        type: "text",
-        text: JSON.stringify({
-          success: false,
-          error: error.message
-        }, null, 2)
-      }]
-    };
-  }
-});
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: true,
+                count: networks.length,
+                networks: networks.map((n) => ({
+                  id: n.ID,
+                  name: n.Name,
+                  subnets: n.Subnets,
+                })),
+              },
+              null,
+              2,
+            ),
+          },
+        ],
+      };
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: false,
+                error: error.message,
+              },
+              null,
+              2,
+            ),
+          },
+        ],
+      };
+    }
+  },
+);
 
 // List security groups
-server.registerTool("os_security_group_list", {
-  title: "List Security Groups",
-  description: "List available security groups in OpenStack",
-  inputSchema: {
-    type: "object",
-    properties: {},
-    additionalProperties: false
-  }
-}, async () => {
-  try {
-    const result = await runOpenStackCommand(["security", "group", "list", "-f", "json"]);
-    const groups = JSON.parse(result.output);
+server.registerTool(
+  "os_security_group_list",
+  {
+    title: "List Security Groups",
+    description: "List available security groups in OpenStack",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      additionalProperties: false,
+    },
+  },
+  async () => {
+    try {
+      const result = await runOpenStackCommand([
+        "security",
+        "group",
+        "list",
+        "-f",
+        "json",
+      ]);
+      const groups = JSON.parse(result.output);
 
-    return {
-      content: [{
-        type: "text",
-        text: JSON.stringify({
-          success: true,
-          count: groups.length,
-          security_groups: groups.map(g => ({
-            id: g.ID,
-            name: g.Name,
-            description: g.Description
-          }))
-        }, null, 2)
-      }]
-    };
-  } catch (error) {
-    return {
-      content: [{
-        type: "text",
-        text: JSON.stringify({
-          success: false,
-          error: error.message
-        }, null, 2)
-      }]
-    };
-  }
-});
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: true,
+                count: groups.length,
+                security_groups: groups.map((g) => ({
+                  id: g.ID,
+                  name: g.Name,
+                  description: g.Description,
+                })),
+              },
+              null,
+              2,
+            ),
+          },
+        ],
+      };
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: false,
+                error: error.message,
+              },
+              null,
+              2,
+            ),
+          },
+        ],
+      };
+    }
+  },
+);
 
 // List keypairs
-server.registerTool("os_keypair_list", {
-  title: "List SSH Keypairs",
-  description: "List available SSH keypairs in OpenStack",
-  inputSchema: {
-    type: "object",
-    properties: {},
-    additionalProperties: false
-  }
-}, async () => {
-  try {
-    const result = await runOpenStackCommand(["keypair", "list", "-f", "json"]);
-    const keypairs = JSON.parse(result.output);
+server.registerTool(
+  "os_keypair_list",
+  {
+    title: "List SSH Keypairs",
+    description: "List available SSH keypairs in OpenStack",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      additionalProperties: false,
+    },
+  },
+  async () => {
+    try {
+      const result = await runOpenStackCommand([
+        "keypair",
+        "list",
+        "-f",
+        "json",
+      ]);
+      const keypairs = JSON.parse(result.output);
 
-    return {
-      content: [{
-        type: "text",
-        text: JSON.stringify({
-          success: true,
-          count: keypairs.length,
-          keypairs: keypairs.map(k => ({
-            name: k.Name,
-            fingerprint: k.Fingerprint,
-            type: k.Type
-          }))
-        }, null, 2)
-      }]
-    };
-  } catch (error) {
-    return {
-      content: [{
-        type: "text",
-        text: JSON.stringify({
-          success: false,
-          error: error.message
-        }, null, 2)
-      }]
-    };
-  }
-});
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: true,
+                count: keypairs.length,
+                keypairs: keypairs.map((k) => ({
+                  name: k.Name,
+                  fingerprint: k.Fingerprint,
+                  type: k.Type,
+                })),
+              },
+              null,
+              2,
+            ),
+          },
+        ],
+      };
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: false,
+                error: error.message,
+              },
+              null,
+              2,
+            ),
+          },
+        ],
+      };
+    }
+  },
+);
 
 // Create keypair
-server.registerTool("os_keypair_create", {
-  title: "Create SSH Keypair",
-  description: "Create a new SSH keypair for VM access",
-  inputSchema: {
-    type: "object",
-    properties: {
-      name: {
-        type: "string",
-        description: "Name for the keypair"
+server.registerTool(
+  "os_keypair_create",
+  {
+    title: "Create SSH Keypair",
+    description: "Create a new SSH keypair for VM access",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: {
+          type: "string",
+          description: "Name for the keypair",
+        },
+        public_key_file: {
+          type: "string",
+          description:
+            "Path to existing public key file (optional, will generate if not provided)",
+        },
       },
-      public_key_file: {
-        type: "string",
-        description: "Path to existing public key file (optional, will generate if not provided)"
-      }
+      required: ["name"],
+      additionalProperties: false,
     },
-    required: ["name"],
-    additionalProperties: false
-  }
-}, async (params) => {
-  try {
-    const args = ["keypair", "create", params.name];
+  },
+  async (params) => {
+    try {
+      const args = ["keypair", "create", params.name];
 
-    if (params.public_key_file) {
-      args.push("--public-key", params.public_key_file);
-    }
+      if (params.public_key_file) {
+        args.push("--public-key", params.public_key_file);
+      }
 
-    args.push("-f", "json");
+      args.push("-f", "json");
 
-    const result = await runOpenStackCommand(args);
-    const keypair = JSON.parse(result.output);
+      const result = await runOpenStackCommand(args);
+      const keypair = JSON.parse(result.output);
 
-    const response = {
-      success: true,
-      keypair: {
-        name: keypair.name || params.name,
-        fingerprint: keypair.fingerprint
-      },
-      message: "Keypair created successfully"
-    };
+      const response = {
+        success: true,
+        keypair: {
+          name: keypair.name || params.name,
+          fingerprint: keypair.fingerprint,
+        },
+        message: "Keypair created successfully",
+      };
 
-    // If a new keypair was generated (no public key provided), include the private key
-    if (!params.public_key_file && keypair.private_key) {
-      response.private_key = keypair.private_key;
-      response.warning = "Save this private key securely. It will not be shown again!";
-    }
+      // If a new keypair was generated (no public key provided), include the private key
+      if (!params.public_key_file && keypair.private_key) {
+        response.private_key = keypair.private_key;
+        response.warning =
+          "Save this private key securely. It will not be shown again!";
+      }
 
-    return {
-      content: [{
-        type: "text",
-        text: JSON.stringify(response, null, 2)
-      }]
-    };
-  } catch (error) {
-    return {
-      content: [{
-        type: "text",
-        text: JSON.stringify({
-          success: false,
-          error: error.message
-        }, null, 2)
-      }]
-    };
-  }
-});
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(response, null, 2),
+          },
+        ],
+      };
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: false,
+                error: error.message,
+              },
+              null,
+              2,
+            ),
+          },
+        ],
+      };
+    }
+  },
+);
 
 // List servers (VMs)
-server.registerTool("os_server_list", {
-  title: "List Servers",
-  description: "List all VMs/servers in the project",
-  inputSchema: {
-    type: "object",
-    properties: {
-      status: {
-        type: "string",
-        enum: ["ACTIVE", "BUILD", "ERROR", "SHUTOFF", "SUSPENDED", "PAUSED"],
-        description: "Filter by server status"
+server.registerTool(
+  "os_server_list",
+  {
+    title: "List Servers",
+    description: "List all VMs/servers in the project",
+    inputSchema: {
+      type: "object",
+      properties: {
+        status: {
+          type: "string",
+          enum: ["ACTIVE", "BUILD", "ERROR", "SHUTOFF", "SUSPENDED", "PAUSED"],
+          description: "Filter by server status",
+        },
+        name: {
+          type: "string",
+          description: "Filter by server name (partial match)",
+        },
       },
-      name: {
-        type: "string",
-        description: "Filter by server name (partial match)"
-      }
+      additionalProperties: false,
     },
-    additionalProperties: false
-  }
-}, async (params) => {
-  try {
-    const args = ["server", "list", "-f", "json"];
-    if (params.status) args.push("--status", params.status);
-    if (params.name) args.push("--name", params.name);
+  },
+  async (params) => {
+    try {
+      const args = ["server", "list", "-f", "json"];
+      if (params.status) args.push("--status", params.status);
+      if (params.name) args.push("--name", params.name);
 
-    const result = await runOpenStackCommand(args);
-    const servers = JSON.parse(result.output);
+      const result = await runOpenStackCommand(args);
+      const servers = JSON.parse(result.output);
 
-    return {
-      content: [{
-        type: "text",
-        text: JSON.stringify({
-          success: true,
-          count: servers.length,
-          servers: servers.map(s => ({
-            id: s.ID,
-            name: s.Name,
-            status: s.Status,
-            networks: s.Networks,
-            image: s.Image,
-            flavor: s.Flavor
-          }))
-        }, null, 2)
-      }]
-    };
-  } catch (error) {
-    return {
-      content: [{
-        type: "text",
-        text: JSON.stringify({
-          success: false,
-          error: error.message
-        }, null, 2)
-      }]
-    };
-  }
-});
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: true,
+                count: servers.length,
+                servers: servers.map((s) => ({
+                  id: s.ID,
+                  name: s.Name,
+                  status: s.Status,
+                  networks: s.Networks,
+                  image: s.Image,
+                  flavor: s.Flavor,
+                })),
+              },
+              null,
+              2,
+            ),
+          },
+        ],
+      };
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: false,
+                error: error.message,
+              },
+              null,
+              2,
+            ),
+          },
+        ],
+      };
+    }
+  },
+);
 
 // Create server (VM)
-server.registerTool("os_server_create", {
-  title: "Create Server",
-  description: "Create a new VM/server in OpenStack with optional cloud-init configuration",
-  inputSchema: {
-    type: "object",
-    properties: {
-      name: {
-        type: "string",
-        description: "Name for the new server"
-      },
-      image: {
-        type: "string",
-        description: "Image ID or name to use"
-      },
-      flavor: {
-        type: "string",
-        description: "Flavor ID or name (instance size)"
-      },
-      network: {
-        type: "string",
-        description: "Network ID or name to attach"
-      },
-      keypair: {
-        type: "string",
-        description: "SSH keypair name for access"
-      },
-      security_groups: {
-        type: "array",
-        items: { type: "string" },
-        description: "Security group names to apply"
-      },
-      user_data: {
-        type: "string",
-        description: "Inline cloud-init user data script (plain text YAML)"
-      },
-      cloud_init_url: {
-        type: "string",
-        description: "URL to fetch cloud-init script from (supports GitHub Gist URLs)"
+server.registerTool(
+  "os_server_create",
+  {
+    title: "Create Server",
+    description:
+      "Create a new VM/server in OpenStack with optional cloud-init configuration",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: {
+          type: "string",
+          description: "Name for the new server",
+        },
+        image: {
+          type: "string",
+          description: "Image ID or name to use",
+        },
+        flavor: {
+          type: "string",
+          description: "Flavor ID or name (instance size)",
+        },
+        network: {
+          type: "string",
+          description: "Network ID or name to attach",
+        },
+        keypair: {
+          type: "string",
+          description: "SSH keypair name for access",
+        },
+        security_groups: {
+          type: "array",
+          items: { type: "string" },
+          description: "Security group names to apply",
+        },
+        user_data: {
+          type: "string",
+          description: "Inline cloud-init user data script (plain text YAML)",
+        },
+        cloud_init_url: {
+          type: "string",
+          description:
+            "URL to fetch cloud-init script from (supports GitHub Gist URLs)",
+        },
+        cloud_init_file: {
+          type: "string",
+          description: "Local file path to cloud-init script",
+        },
+        use_default_cloud_init: {
+          type: "boolean",
+          description:
+            "Use the default cloud-init from CLOUD_INIT environment variable",
+          default: false,
+        },
+        availability_zone: {
+          type: "string",
+          description: "Availability zone for the server",
+        },
+        wait: {
+          type: "boolean",
+          description: "Wait for server to become active",
+          default: true,
+        },
       },
-      cloud_init_file: {
-        type: "string",
-        description: "Local file path to cloud-init script"
-      },
-      use_default_cloud_init: {
-        type: "boolean",
-        description: "Use the default cloud-init from CLOUD_INIT environment variable",
-        default: false
-      },
-      availability_zone: {
-        type: "string",
-        description: "Availability zone for the server"
-      },
-      wait: {
-        type: "boolean",
-        description: "Wait for server to become active",
-        default: true
-      }
+      required: ["name", "image", "flavor"],
+      additionalProperties: false,
     },
-    required: ["name", "image", "flavor"],
-    additionalProperties: false
-  }
-}, async (params) => {
-  let tmpFile = null;
-  let cloudInitInfo = null;
-
-  try {
-    const args = ["server", "create"];
-    args.push("--image", params.image);
-    args.push("--flavor", params.flavor);
+  },
+  async (params) => {
+    let tmpFile = null;
+    let cloudInitInfo = null;
 
-    if (params.network) {
-      args.push("--network", params.network);
-    }
+    try {
+      const args = ["server", "create"];
+      args.push("--image", params.image);
+      args.push("--flavor", params.flavor);
 
-    if (params.keypair) {
-      args.push("--key-name", params.keypair);
-    }
+      if (params.network) {
+        args.push("--network", params.network);
+      }
 
-    if (params.security_groups && params.security_groups.length > 0) {
-      params.security_groups.forEach(sg => {
-        args.push("--security-group", sg);
-      });
-    }
+      if (params.keypair) {
+        args.push("--key-name", params.keypair);
+      }
 
-    // Resolve cloud-init from various sources
-    cloudInitInfo = await resolveCloudInit(params);
-    if (cloudInitInfo) {
-      tmpFile = `/tmp/userdata-${Date.now()}.txt`;
-      fs.writeFileSync(tmpFile, cloudInitInfo.content);
-      args.push("--user-data", tmpFile);
-    }
+      if (params.security_groups && params.security_groups.length > 0) {
+        params.security_groups.forEach((sg) => {
+          args.push("--security-group", sg);
+        });
+      }
 
-    if (params.availability_zone) {
-      args.push("--availability-zone", params.availability_zone);
-    }
+      // Resolve cloud-init from various sources
+      cloudInitInfo = await resolveCloudInit(params);
+      if (cloudInitInfo) {
+        tmpFile = `/tmp/userdata-${Date.now()}.txt`;
+        fs.writeFileSync(tmpFile, cloudInitInfo.content);
+        args.push("--user-data", tmpFile);
+      }
 
-    if (params.wait !== false) {
-      args.push("--wait");
-    }
+      if (params.availability_zone) {
+        args.push("--availability-zone", params.availability_zone);
+      }
 
-    args.push("-f", "json");
-    args.push(params.name);
+      if (params.wait !== false) {
+        args.push("--wait");
+      }
 
-    const result = await runOpenStackCommand(args, 300000); // 5 minute timeout for server creation
-    const serverResult = JSON.parse(result.output);
+      args.push("-f", "json");
+      args.push(params.name);
 
-    // Log operation
-    operationHistory.push({
-      type: "server_create",
-      server_id: serverResult.id,
-      server_name: params.name,
-      cloud_init_source: cloudInitInfo ? cloudInitInfo.source : null,
-      timestamp: new Date().toISOString()
-    });
+      const result = await runOpenStackCommand(args, 300000); // 5 minute timeout for server creation
+      const serverResult = JSON.parse(result.output);
 
-    const response = {
-      success: true,
-      server: {
-        id: serverResult.id,
-        name: serverResult.name,
-        status: serverResult.status,
-        addresses: serverResult.addresses,
-        image: serverResult.image,
-        flavor: serverResult.flavor,
-        key_name: serverResult.key_name,
-        security_groups: serverResult.security_groups
-      },
-      message: "Server created successfully"
-    };
+      // Log operation
+      operationHistory.push({
+        type: "server_create",
+        server_id: serverResult.id,
+        server_name: params.name,
+        cloud_init_source: cloudInitInfo ? cloudInitInfo.source : null,
+        timestamp: new Date().toISOString(),
+      });
 
-    // Include cloud-init info in response
-    if (cloudInitInfo) {
-      response.cloud_init = {
-        source: cloudInitInfo.source,
-        applied: true
+      const response = {
+        success: true,
+        server: {
+          id: serverResult.id,
+          name: serverResult.name,
+          status: serverResult.status,
+          addresses: serverResult.addresses,
+          image: serverResult.image,
+          flavor: serverResult.flavor,
+          key_name: serverResult.key_name,
+          security_groups: serverResult.security_groups,
+        },
+        message: "Server created successfully",
       };
-    }
 
-    return {
-      content: [{
-        type: "text",
-        text: JSON.stringify(response, null, 2)
-      }]
-    };
-  } catch (error) {
-    return {
-      content: [{
-        type: "text",
-        text: JSON.stringify({
-          success: false,
-          error: error.message
-        }, null, 2)
-      }]
-    };
-  } finally {
-    // Clean up temp file
-    if (tmpFile) {
-      try {
-        fs.unlinkSync(tmpFile);
-      } catch (e) {}
+      // Include cloud-init info in response
+      if (cloudInitInfo) {
+        response.cloud_init = {
+          source: cloudInitInfo.source,
+          applied: true,
+        };
+      }
+
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(response, null, 2),
+          },
+        ],
+      };
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: false,
+                error: error.message,
+              },
+              null,
+              2,
+            ),
+          },
+        ],
+      };
+    } finally {
+      // Clean up temp file
+      if (tmpFile) {
+        try {
+          fs.unlinkSync(tmpFile);
+        } catch (e) {}
+      }
     }
-  }
-});
+  },
+);
 
 // Get server details
-server.registerTool("os_server_show", {
-  title: "Show Server Details",
-  description: "Get detailed information about a specific server",
-  inputSchema: {
-    type: "object",
-    properties: {
-      server: {
-        type: "string",
-        description: "Server ID or name"
-      }
+server.registerTool(
+  "os_server_show",
+  {
+    title: "Show Server Details",
+    description: "Get detailed information about a specific server",
+    inputSchema: {
+      type: "object",
+      properties: {
+        server: {
+          type: "string",
+          description: "Server ID or name",
+        },
+      },
+      required: ["server"],
+      additionalProperties: false,
     },
-    required: ["server"],
-    additionalProperties: false
-  }
-}, async (params) => {
-  try {
-    const result = await runOpenStackCommand(["server", "show", params.server, "-f", "json"]);
-    const server = JSON.parse(result.output);
+  },
+  async (params) => {
+    try {
+      const result = await runOpenStackCommand([
+        "server",
+        "show",
+        params.server,
+        "-f",
+        "json",
+      ]);
+      const server = JSON.parse(result.output);
 
-    return {
-      content: [{
-        type: "text",
-        text: JSON.stringify({
-          success: true,
-          server: {
-            id: server.id,
-            name: server.name,
-            status: server.status,
-            addresses: server.addresses,
-            image: server.image,
-            flavor: server.flavor,
-            key_name: server.key_name,
-            security_groups: server.security_groups,
-            created: server.created,
-            updated: server.updated,
-            availability_zone: server.availability_zone,
-            host: server["OS-EXT-SRV-ATTR:host"],
-            power_state: server["OS-EXT-STS:power_state"],
-            task_state: server["OS-EXT-STS:task_state"]
-          }
-        }, null, 2)
-      }]
-    };
-  } catch (error) {
-    return {
-      content: [{
-        type: "text",
-        text: JSON.stringify({
-          success: false,
-          error: error.message
-        }, null, 2)
-      }]
-    };
-  }
-});
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: true,
+                server: {
+                  id: server.id,
+                  name: server.name,
+                  status: server.status,
+                  addresses: server.addresses,
+                  image: server.image,
+                  flavor: server.flavor,
+                  key_name: server.key_name,
+                  security_groups: server.security_groups,
+                  created: server.created,
+                  updated: server.updated,
+                  availability_zone: server.availability_zone,
+                  host: server["OS-EXT-SRV-ATTR:host"],
+                  power_state: server["OS-EXT-STS:power_state"],
+                  task_state: server["OS-EXT-STS:task_state"],
+                },
+              },
+              null,
+              2,
+            ),
+          },
+        ],
+      };
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: false,
+                error: error.message,
+              },
+              null,
+              2,
+            ),
+          },
+        ],
+      };
+    }
+  },
+);
 
 // Delete server
-server.registerTool("os_server_delete", {
-  title: "Delete Server",
-  description: "Delete a VM/server from OpenStack",
-  inputSchema: {
-    type: "object",
-    properties: {
-      server: {
-        type: "string",
-        description: "Server ID or name to delete"
+server.registerTool(
+  "os_server_delete",
+  {
+    title: "Delete Server",
+    description: "Delete a VM/server from OpenStack",
+    inputSchema: {
+      type: "object",
+      properties: {
+        server: {
+          type: "string",
+          description: "Server ID or name to delete",
+        },
+        wait: {
+          type: "boolean",
+          description: "Wait for deletion to complete",
+          default: true,
+        },
       },
-      wait: {
-        type: "boolean",
-        description: "Wait for deletion to complete",
-        default: true
-      }
+      required: ["server"],
+      additionalProperties: false,
     },
-    required: ["server"],
-    additionalProperties: false
-  }
-}, async (params) => {
-  try {
-    const args = ["server", "delete", params.server];
-    if (params.wait !== false) {
-      args.push("--wait");
-    }
+  },
+  async (params) => {
+    try {
+      const args = ["server", "delete", params.server];
+      if (params.wait !== false) {
+        args.push("--wait");
+      }
 
-    await runOpenStackCommand(args, 180000); // 3 minute timeout
+      await runOpenStackCommand(args, 180000); // 3 minute timeout
 
-    operationHistory.push({
-      type: "server_delete",
-      server: params.server,
-      timestamp: new Date().toISOString()
-    });
+      operationHistory.push({
+        type: "server_delete",
+        server: params.server,
+        timestamp: new Date().toISOString(),
+      });
 
-    return {
-      content: [{
-        type: "text",
-        text: JSON.stringify({
-          success: true,
-          message: `Server '${params.server}' deleted successfully`
-        }, null, 2)
-      }]
-    };
-  } catch (error) {
-    return {
-      content: [{
-        type: "text",
-        text: JSON.stringify({
-          success: false,
-          error: error.message
-        }, null, 2)
-      }]
-    };
-  }
-});
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: true,
+                message: `Server '${params.server}' deleted successfully`,
+              },
+              null,
+              2,
+            ),
+          },
+        ],
+      };
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: false,
+                error: error.message,
+              },
+              null,
+              2,
+            ),
+          },
+        ],
+      };
+    }
+  },
+);
 
 // Start server
-server.registerTool("os_server_start", {
-  title: "Start Server",
-  description: "Start a stopped server",
-  inputSchema: {
-    type: "object",
-    properties: {
-      server: {
-        type: "string",
-        description: "Server ID or name to start"
-      }
+server.registerTool(
+  "os_server_start",
+  {
+    title: "Start Server",
+    description: "Start a stopped server",
+    inputSchema: {
+      type: "object",
+      properties: {
+        server: {
+          type: "string",
+          description: "Server ID or name to start",
+        },
+      },
+      required: ["server"],
+      additionalProperties: false,
     },
-    required: ["server"],
-    additionalProperties: false
-  }
-}, async (params) => {
-  try {
-    await runOpenStackCommand(["server", "start", params.server]);
+  },
+  async (params) => {
+    try {
+      await runOpenStackCommand(["server", "start", params.server]);
 
-    return {
-      content: [{
-        type: "text",
-        text: JSON.stringify({
-          success: true,
-          message: `Server '${params.server}' start initiated`
-        }, null, 2)
-      }]
-    };
-  } catch (error) {
-    return {
-      content: [{
-        type: "text",
-        text: JSON.stringify({
-          success: false,
-          error: error.message
-        }, null, 2)
-      }]
-    };
-  }
-});
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: true,
+                message: `Server '${params.server}' start initiated`,
+              },
+              null,
+              2,
+            ),
+          },
+        ],
+      };
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: false,
+                error: error.message,
+              },
+              null,
+              2,
+            ),
+          },
+        ],
+      };
+    }
+  },
+);
 
 // Stop server
-server.registerTool("os_server_stop", {
-  title: "Stop Server",
-  description: "Stop a running server",
-  inputSchema: {
-    type: "object",
-    properties: {
-      server: {
-        type: "string",
-        description: "Server ID or name to stop"
-      }
+server.registerTool(
+  "os_server_stop",
+  {
+    title: "Stop Server",
+    description: "Stop a running server",
+    inputSchema: {
+      type: "object",
+      properties: {
+        server: {
+          type: "string",
+          description: "Server ID or name to stop",
+        },
+      },
+      required: ["server"],
+      additionalProperties: false,
     },
-    required: ["server"],
-    additionalProperties: false
-  }
-}, async (params) => {
-  try {
-    await runOpenStackCommand(["server", "stop", params.server]);
+  },
+  async (params) => {
+    try {
+      await runOpenStackCommand(["server", "stop", params.server]);
 
-    return {
-      content: [{
-        type: "text",
-        text: JSON.stringify({
-          success: true,
-          message: `Server '${params.server}' stop initiated`
-        }, null, 2)
-      }]
-    };
-  } catch (error) {
-    return {
-      content: [{
-        type: "text",
-        text: JSON.stringify({
-          success: false,
-          error: error.message
-        }, null, 2)
-      }]
-    };
-  }
-});
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: true,
+                message: `Server '${params.server}' stop initiated`,
+              },
+              null,
+              2,
+            ),
+          },
+        ],
+      };
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: false,
+                error: error.message,
+              },
+              null,
+              2,
+            ),
+          },
+        ],
+      };
+    }
+  },
+);
 
 // Reboot server
-server.registerTool("os_server_reboot", {
-  title: "Reboot Server",
-  description: "Reboot a server (soft or hard reboot)",
-  inputSchema: {
-    type: "object",
-    properties: {
-      server: {
-        type: "string",
-        description: "Server ID or name to reboot"
+server.registerTool(
+  "os_server_reboot",
+  {
+    title: "Reboot Server",
+    description: "Reboot a server (soft or hard reboot)",
+    inputSchema: {
+      type: "object",
+      properties: {
+        server: {
+          type: "string",
+          description: "Server ID or name to reboot",
+        },
+        hard: {
+          type: "boolean",
+          description: "Perform hard reboot instead of soft reboot",
+          default: false,
+        },
       },
-      hard: {
-        type: "boolean",
-        description: "Perform hard reboot instead of soft reboot",
-        default: false
-      }
+      required: ["server"],
+      additionalProperties: false,
     },
-    required: ["server"],
-    additionalProperties: false
-  }
-}, async (params) => {
-  try {
-    const args = ["server", "reboot"];
-    if (params.hard) {
-      args.push("--hard");
-    } else {
-      args.push("--soft");
-    }
-    args.push(params.server);
+  },
+  async (params) => {
+    try {
+      const args = ["server", "reboot"];
+      if (params.hard) {
+        args.push("--hard");
+      } else {
+        args.push("--soft");
+      }
+      args.push(params.server);
 
-    await runOpenStackCommand(args);
+      await runOpenStackCommand(args);
 
-    return {
-      content: [{
-        type: "text",
-        text: JSON.stringify({
-          success: true,
-          message: `Server '${params.server}' ${params.hard ? 'hard' : 'soft'} reboot initiated`
-        }, null, 2)
-      }]
-    };
-  } catch (error) {
-    return {
-      content: [{
-        type: "text",
-        text: JSON.stringify({
-          success: false,
-          error: error.message
-        }, null, 2)
-      }]
-    };
-  }
-});
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: true,
+                message: `Server '${params.server}' ${params.hard ? "hard" : "soft"} reboot initiated`,
+              },
+              null,
+              2,
+            ),
+          },
+        ],
+      };
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: false,
+                error: error.message,
+              },
+              null,
+              2,
+            ),
+          },
+        ],
+      };
+    }
+  },
+);
 
 // Get server console URL
-server.registerTool("os_server_console", {
-  title: "Get Server Console",
-  description: "Get console URL for accessing server",
-  inputSchema: {
-    type: "object",
-    properties: {
-      server: {
-        type: "string",
-        description: "Server ID or name"
+server.registerTool(
+  "os_server_console",
+  {
+    title: "Get Server Console",
+    description: "Get console URL for accessing server",
+    inputSchema: {
+      type: "object",
+      properties: {
+        server: {
+          type: "string",
+          description: "Server ID or name",
+        },
+        type: {
+          type: "string",
+          enum: ["novnc", "xvpvnc", "spice", "rdp", "serial"],
+          description: "Console type",
+          default: "novnc",
+        },
       },
-      type: {
-        type: "string",
-        enum: ["novnc", "xvpvnc", "spice", "rdp", "serial"],
-        description: "Console type",
-        default: "novnc"
-      }
+      required: ["server"],
+      additionalProperties: false,
     },
-    required: ["server"],
-    additionalProperties: false
-  }
-}, async (params) => {
-  try {
-    const result = await runOpenStackCommand([
-      "console", "url", "show",
-      "--" + (params.type || "novnc"),
-      params.server,
-      "-f", "json"
-    ]);
-    const console_info = JSON.parse(result.output);
+  },
+  async (params) => {
+    try {
+      const result = await runOpenStackCommand([
+        "console",
+        "url",
+        "show",
+        "--" + (params.type || "novnc"),
+        params.server,
+        "-f",
+        "json",
+      ]);
+      const console_info = JSON.parse(result.output);
 
-    return {
-      content: [{
-        type: "text",
-        text: JSON.stringify({
-          success: true,
-          console: {
-            type: console_info.type,
-            url: console_info.url
-          }
-        }, null, 2)
-      }]
-    };
-  } catch (error) {
-    return {
-      content: [{
-        type: "text",
-        text: JSON.stringify({
-          success: false,
-          error: error.message
-        }, null, 2)
-      }]
-    };
-  }
-});
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: true,
+                console: {
+                  type: console_info.type,
+                  url: console_info.url,
+                },
+              },
+              null,
+              2,
+            ),
+          },
+        ],
+      };
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: false,
+                error: error.message,
+              },
+              null,
+              2,
+            ),
+          },
+        ],
+      };
+    }
+  },
+);
 
 // Attach floating IP
-server.registerTool("os_floating_ip_create", {
-  title: "Create Floating IP",
-  description: "Create a new floating IP from an external network",
-  inputSchema: {
-    type: "object",
-    properties: {
-      network: {
-        type: "string",
-        description: "External network name or ID"
-      }
+server.registerTool(
+  "os_floating_ip_create",
+  {
+    title: "Create Floating IP",
+    description: "Create a new floating IP from an external network",
+    inputSchema: {
+      type: "object",
+      properties: {
+        network: {
+          type: "string",
+          description: "External network name or ID",
+        },
+      },
+      required: ["network"],
+      additionalProperties: false,
     },
-    required: ["network"],
-    additionalProperties: false
-  }
-}, async (params) => {
-  try {
-    const result = await runOpenStackCommand([
-      "floating", "ip", "create",
-      params.network,
-      "-f", "json"
-    ]);
-    const floating_ip = JSON.parse(result.output);
+  },
+  async (params) => {
+    try {
+      const result = await runOpenStackCommand([
+        "floating",
+        "ip",
+        "create",
+        params.network,
+        "-f",
+        "json",
+      ]);
+      const floating_ip = JSON.parse(result.output);
 
-    return {
-      content: [{
-        type: "text",
-        text: JSON.stringify({
-          success: true,
-          floating_ip: {
-            id: floating_ip.id,
-            ip: floating_ip.floating_ip_address,
-            network: floating_ip.floating_network_id,
-            status: floating_ip.status
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: true,
+                floating_ip: {
+                  id: floating_ip.id,
+                  ip: floating_ip.floating_ip_address,
+                  network: floating_ip.floating_network_id,
+                  status: floating_ip.status,
+                },
+                message: "Floating IP created successfully",
+              },
+              null,
+              2,
+            ),
           },
-          message: "Floating IP created successfully"
-        }, null, 2)
-      }]
-    };
-  } catch (error) {
-    return {
-      content: [{
-        type: "text",
-        text: JSON.stringify({
-          success: false,
-          error: error.message
-        }, null, 2)
-      }]
-    };
-  }
-});
+        ],
+      };
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: false,
+                error: error.message,
+              },
+              null,
+              2,
+            ),
+          },
+        ],
+      };
+    }
+  },
+);
 
 // List floating IPs
-server.registerTool("os_floating_ip_list", {
-  title: "List Floating IPs",
-  description: "List all floating IPs in the project",
-  inputSchema: {
-    type: "object",
-    properties: {},
-    additionalProperties: false
-  }
-}, async () => {
-  try {
-    const result = await runOpenStackCommand(["floating", "ip", "list", "-f", "json"]);
-    const floating_ips = JSON.parse(result.output);
+server.registerTool(
+  "os_floating_ip_list",
+  {
+    title: "List Floating IPs",
+    description: "List all floating IPs in the project",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      additionalProperties: false,
+    },
+  },
+  async () => {
+    try {
+      const result = await runOpenStackCommand([
+        "floating",
+        "ip",
+        "list",
+        "-f",
+        "json",
+      ]);
+      const floating_ips = JSON.parse(result.output);
 
-    return {
-      content: [{
-        type: "text",
-        text: JSON.stringify({
-          success: true,
-          count: floating_ips.length,
-          floating_ips: floating_ips.map(f => ({
-            id: f.ID,
-            ip: f["Floating IP Address"],
-            fixed_ip: f["Fixed IP Address"],
-            port: f.Port,
-            status: f.Status
-          }))
-        }, null, 2)
-      }]
-    };
-  } catch (error) {
-    return {
-      content: [{
-        type: "text",
-        text: JSON.stringify({
-          success: false,
-          error: error.message
-        }, null, 2)
-      }]
-    };
-  }
-});
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: true,
+                count: floating_ips.length,
+                floating_ips: floating_ips.map((f) => ({
+                  id: f.ID,
+                  ip: f["Floating IP Address"],
+                  fixed_ip: f["Fixed IP Address"],
+                  port: f.Port,
+                  status: f.Status,
+                })),
+              },
+              null,
+              2,
+            ),
+          },
+        ],
+      };
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: false,
+                error: error.message,
+              },
+              null,
+              2,
+            ),
+          },
+        ],
+      };
+    }
+  },
+);
 
 // Associate floating IP with server
-server.registerTool("os_server_add_floating_ip", {
-  title: "Add Floating IP to Server",
-  description: "Associate a floating IP with a server",
-  inputSchema: {
-    type: "object",
-    properties: {
-      server: {
-        type: "string",
-        description: "Server ID or name"
+server.registerTool(
+  "os_server_add_floating_ip",
+  {
+    title: "Add Floating IP to Server",
+    description: "Associate a floating IP with a server",
+    inputSchema: {
+      type: "object",
+      properties: {
+        server: {
+          type: "string",
+          description: "Server ID or name",
+        },
+        floating_ip: {
+          type: "string",
+          description: "Floating IP address to associate",
+        },
       },
-      floating_ip: {
-        type: "string",
-        description: "Floating IP address to associate"
-      }
+      required: ["server", "floating_ip"],
+      additionalProperties: false,
     },
-    required: ["server", "floating_ip"],
-    additionalProperties: false
-  }
-}, async (params) => {
-  try {
-    await runOpenStackCommand([
-      "server", "add", "floating", "ip",
-      params.server,
-      params.floating_ip
-    ]);
+  },
+  async (params) => {
+    try {
+      await runOpenStackCommand([
+        "server",
+        "add",
+        "floating",
+        "ip",
+        params.server,
+        params.floating_ip,
+      ]);
 
-    return {
-      content: [{
-        type: "text",
-        text: JSON.stringify({
-          success: true,
-          message: `Floating IP '${params.floating_ip}' associated with server '${params.server}'`
-        }, null, 2)
-      }]
-    };
-  } catch (error) {
-    return {
-      content: [{
-        type: "text",
-        text: JSON.stringify({
-          success: false,
-          error: error.message
-        }, null, 2)
-      }]
-    };
-  }
-});
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: true,
+                message: `Floating IP '${params.floating_ip}' associated with server '${params.server}'`,
+              },
+              null,
+              2,
+            ),
+          },
+        ],
+      };
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: false,
+                error: error.message,
+              },
+              null,
+              2,
+            ),
+          },
+        ],
+      };
+    }
+  },
+);
 
 // Volume operations
-server.registerTool("os_volume_list", {
-  title: "List Volumes",
-  description: "List all volumes in the project",
-  inputSchema: {
-    type: "object",
-    properties: {},
-    additionalProperties: false
-  }
-}, async () => {
-  try {
-    const result = await runOpenStackCommand(["volume", "list", "-f", "json"]);
-    const volumes = JSON.parse(result.output);
+server.registerTool(
+  "os_volume_list",
+  {
+    title: "List Volumes",
+    description: "List all volumes in the project",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      additionalProperties: false,
+    },
+  },
+  async () => {
+    try {
+      const result = await runOpenStackCommand([
+        "volume",
+        "list",
+        "-f",
+        "json",
+      ]);
+      const volumes = JSON.parse(result.output);
 
-    return {
-      content: [{
-        type: "text",
-        text: JSON.stringify({
-          success: true,
-          count: volumes.length,
-          volumes: volumes.map(v => ({
-            id: v.ID,
-            name: v.Name,
-            status: v.Status,
-            size_gb: v.Size,
-            attached_to: v["Attached to"]
-          }))
-        }, null, 2)
-      }]
-    };
-  } catch (error) {
-    return {
-      content: [{
-        type: "text",
-        text: JSON.stringify({
-          success: false,
-          error: error.message
-        }, null, 2)
-      }]
-    };
-  }
-});
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: true,
+                count: volumes.length,
+                volumes: volumes.map((v) => ({
+                  id: v.ID,
+                  name: v.Name,
+                  status: v.Status,
+                  size_gb: v.Size,
+                  attached_to: v["Attached to"],
+                })),
+              },
+              null,
+              2,
+            ),
+          },
+        ],
+      };
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: false,
+                error: error.message,
+              },
+              null,
+              2,
+            ),
+          },
+        ],
+      };
+    }
+  },
+);
 
 // Create volume
-server.registerTool("os_volume_create", {
-  title: "Create Volume",
-  description: "Create a new block storage volume",
-  inputSchema: {
-    type: "object",
-    properties: {
-      name: {
-        type: "string",
-        description: "Volume name"
-      },
-      size: {
-        type: "number",
-        description: "Volume size in GB"
-      },
-      type: {
-        type: "string",
-        description: "Volume type (optional)"
+server.registerTool(
+  "os_volume_create",
+  {
+    title: "Create Volume",
+    description: "Create a new block storage volume",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: {
+          type: "string",
+          description: "Volume name",
+        },
+        size: {
+          type: "number",
+          description: "Volume size in GB",
+        },
+        type: {
+          type: "string",
+          description: "Volume type (optional)",
+        },
+        image: {
+          type: "string",
+          description: "Image ID to create volume from (optional)",
+        },
       },
-      image: {
-        type: "string",
-        description: "Image ID to create volume from (optional)"
-      }
+      required: ["name", "size"],
+      additionalProperties: false,
     },
-    required: ["name", "size"],
-    additionalProperties: false
-  }
-}, async (params) => {
-  try {
-    const args = ["volume", "create"];
-    args.push("--size", params.size.toString());
+  },
+  async (params) => {
+    try {
+      const args = ["volume", "create"];
+      args.push("--size", params.size.toString());
 
-    if (params.type) {
-      args.push("--type", params.type);
-    }
+      if (params.type) {
+        args.push("--type", params.type);
+      }
 
-    if (params.image) {
-      args.push("--image", params.image);
-    }
+      if (params.image) {
+        args.push("--image", params.image);
+      }
 
-    args.push("-f", "json");
-    args.push(params.name);
+      args.push("-f", "json");
+      args.push(params.name);
 
-    const result = await runOpenStackCommand(args, 180000);
-    const volume = JSON.parse(result.output);
+      const result = await runOpenStackCommand(args, 180000);
+      const volume = JSON.parse(result.output);
 
-    return {
-      content: [{
-        type: "text",
-        text: JSON.stringify({
-          success: true,
-          volume: {
-            id: volume.id,
-            name: volume.name,
-            size: volume.size,
-            status: volume.status,
-            type: volume.type
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: true,
+                volume: {
+                  id: volume.id,
+                  name: volume.name,
+                  size: volume.size,
+                  status: volume.status,
+                  type: volume.type,
+                },
+                message: "Volume created successfully",
+              },
+              null,
+              2,
+            ),
           },
-          message: "Volume created successfully"
-        }, null, 2)
-      }]
-    };
-  } catch (error) {
-    return {
-      content: [{
-        type: "text",
-        text: JSON.stringify({
-          success: false,
-          error: error.message
-        }, null, 2)
-      }]
-    };
-  }
-});
+        ],
+      };
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: false,
+                error: error.message,
+              },
+              null,
+              2,
+            ),
+          },
+        ],
+      };
+    }
+  },
+);
 
 // Attach volume to server
-server.registerTool("os_server_add_volume", {
-  title: "Attach Volume to Server",
-  description: "Attach a volume to a server",
-  inputSchema: {
-    type: "object",
-    properties: {
-      server: {
-        type: "string",
-        description: "Server ID or name"
-      },
-      volume: {
-        type: "string",
-        description: "Volume ID or name"
+server.registerTool(
+  "os_server_add_volume",
+  {
+    title: "Attach Volume to Server",
+    description: "Attach a volume to a server",
+    inputSchema: {
+      type: "object",
+      properties: {
+        server: {
+          type: "string",
+          description: "Server ID or name",
+        },
+        volume: {
+          type: "string",
+          description: "Volume ID or name",
+        },
+        device: {
+          type: "string",
+          description:
+            "Device path (e.g., /dev/vdb), auto-assigned if not specified",
+        },
       },
-      device: {
-        type: "string",
-        description: "Device path (e.g., /dev/vdb), auto-assigned if not specified"
-      }
+      required: ["server", "volume"],
+      additionalProperties: false,
     },
-    required: ["server", "volume"],
-    additionalProperties: false
-  }
-}, async (params) => {
-  try {
-    const args = ["server", "add", "volume"];
+  },
+  async (params) => {
+    try {
+      const args = ["server", "add", "volume"];
 
-    if (params.device) {
-      args.push("--device", params.device);
-    }
+      if (params.device) {
+        args.push("--device", params.device);
+      }
 
-    args.push(params.server);
-    args.push(params.volume);
+      args.push(params.server);
+      args.push(params.volume);
 
-    await runOpenStackCommand(args);
+      await runOpenStackCommand(args);
 
-    return {
-      content: [{
-        type: "text",
-        text: JSON.stringify({
-          success: true,
-          message: `Volume '${params.volume}' attached to server '${params.server}'`
-        }, null, 2)
-      }]
-    };
-  } catch (error) {
-    return {
-      content: [{
-        type: "text",
-        text: JSON.stringify({
-          success: false,
-          error: error.message
-        }, null, 2)
-      }]
-    };
-  }
-});
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: true,
+                message: `Volume '${params.volume}' attached to server '${params.server}'`,
+              },
+              null,
+              2,
+            ),
+          },
+        ],
+      };
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: false,
+                error: error.message,
+              },
+              null,
+              2,
+            ),
+          },
+        ],
+      };
+    }
+  },
+);
 
 // Get operation history
-server.registerTool("os_operation_history", {
-  title: "Get Operation History",
-  description: "Get history of OpenStack operations performed",
-  inputSchema: {
-    type: "object",
-    properties: {
-      limit: {
-        type: "number",
-        description: "Maximum number of operations to return",
-        default: 20
-      }
+server.registerTool(
+  "os_operation_history",
+  {
+    title: "Get Operation History",
+    description: "Get history of OpenStack operations performed",
+    inputSchema: {
+      type: "object",
+      properties: {
+        limit: {
+          type: "number",
+          description: "Maximum number of operations to return",
+          default: 20,
+        },
+      },
+      additionalProperties: false,
     },
-    additionalProperties: false
-  }
-}, async (params) => {
-  const limit = params.limit || 20;
-  const history = operationHistory.slice(-limit);
+  },
+  async (params) => {
+    const limit = params.limit || 20;
+    const history = operationHistory.slice(-limit);
 
-  return {
-    content: [{
-      type: "text",
-      text: JSON.stringify({
-        success: true,
-        count: history.length,
-        operations: history
-      }, null, 2)
-    }]
-  };
-});
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(
+            {
+              success: true,
+              count: history.length,
+              operations: history,
+            },
+            null,
+            2,
+          ),
+        },
+      ],
+    };
+  },
+);
 
 // Start the MCP server
 async function main() {
@@ -1594,7 +2079,6 @@ async function main() {
     console.error("OpenStack MCP Server v1.0.0 running...");
     console.error(`Auth URL: ${OS_AUTH_URL || "Not configured"}`);
     console.error(`Region: ${OS_REGION_NAME || "Not configured"}`);
-
   } catch (error) {
     console.error("Failed to start server:", error.message);
     process.exit(1);