myaidev-method 0.2.19 → 0.2.22

package/dist/mcp/openstack-server.js

@@ -0,0 +1,1607 @@
+#!/usr/bin/env node
+
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { spawn, execSync } from "child_process";
+import fs from "fs";
+import path from "path";
+import https from "https";
+import http from "http";
+import dotenv from "dotenv";
+
+// Load environment variables
+dotenv.config();
+
+// OpenStack environment variables
+const OS_AUTH_URL = process.env.OS_AUTH_URL;
+const OS_USERNAME = process.env.OS_USERNAME;
+const OS_PASSWORD = process.env.OS_PASSWORD;
+const OS_PROJECT_ID = process.env.OS_PROJECT_ID;
+const OS_USER_DOMAIN_ID = process.env.OS_USER_DOMAIN_ID || "default";
+const OS_PROJECT_DOMAIN_ID = process.env.OS_PROJECT_DOMAIN_ID || "default";
+const OS_REGION_NAME = process.env.OS_REGION_NAME;
+const OS_IDENTITY_API_VERSION = process.env.OS_IDENTITY_API_VERSION || "3";
+
+// Default cloud-init URL from environment
+const DEFAULT_CLOUD_INIT = process.env.CLOUD_INIT;
+
+// Create MCP server
+const server = new McpServer({
+  name: "openstack-mcp-server",
+  version: "1.0.0",
+  description: "OpenStack MCP Server for VM management and orchestration"
+});
+
+// Session storage for tracking operations
+const sessions = new Map();
+const operationHistory = [];
+
+// Helper to generate session IDs
+function generateSessionId() {
+  return `os-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+}
+
+// Build OpenStack environment for subprocess
+function getOpenStackEnv() {
+  return {
+    ...process.env,
+    OS_AUTH_URL,
+    OS_USERNAME,
+    OS_PASSWORD,
+    OS_PROJECT_ID,
+    OS_USER_DOMAIN_ID,
+    OS_PROJECT_DOMAIN_ID,
+    OS_REGION_NAME,
+    OS_IDENTITY_API_VERSION,
+    OS_AUTH_VERSION: OS_IDENTITY_API_VERSION,
+    OS_ENDPOINT_TYPE: "publicURL",
+    OS_INTERFACE: "publicURL",
+    OS_NO_CACHE: "1"
+  };
+}
+
+// Execute OpenStack CLI command
+async function runOpenStackCommand(args, timeout = 120000) {
+  return new Promise((resolve, reject) => {
+    const env = getOpenStackEnv();
+
+    // 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"));
+      return;
+    }
+
+    const proc = spawn("openstack", args, {
+      env,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+
+    let stdout = "";
+    let stderr = "";
+
+    proc.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+
+    proc.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+
+    const timeoutId = setTimeout(() => {
+      proc.kill("SIGTERM");
+      reject(new Error(`Command timed out after ${timeout}ms`));
+    }, timeout);
+
+    proc.on("close", (code) => {
+      clearTimeout(timeoutId);
+      if (code === 0) {
+        resolve({ success: true, output: stdout.trim(), stderr: stderr.trim() });
+      } else {
+        reject(new Error(stderr || `Command failed with exit code ${code}`));
+      }
+    });
+
+    proc.on("error", (error) => {
+      clearTimeout(timeoutId);
+      reject(new Error(`Failed to execute command: ${error.message}`));
+    });
+  });
+}
+
+// Parse OpenStack table output to JSON
+function parseTableOutput(output) {
+  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);
+
+  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] || "";
+    });
+    return obj;
+  });
+}
+
+// Fetch content from URL (supports GitHub Gist raw URLs)
+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')) {
+      // Extract gist ID and convert to raw URL
+      const gistMatch = url.match(/gist\.github\.com\/([^\/]+)\/([a-f0-9]+)/);
+      if (gistMatch) {
+        fetchUrl = `https://gist.githubusercontent.com/${gistMatch[1]}/${gistMatch[2]}/raw`;
+      }
+    }
+
+    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;
+      }
+
+      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));
+    });
+
+    request.on('error', reject);
+    request.setTimeout(30000, () => {
+      request.destroy();
+      reject(new Error('Request timeout'));
+    });
+  });
+}
+
+// Resolve cloud-init from various sources
+async function resolveCloudInit(params) {
+  // Priority: explicit user_data > cloud_init_url > cloud_init_file > use_default_cloud_init > none
+
+  // 1. Explicit user_data content provided
+  if (params.user_data) {
+    return { content: params.user_data, source: 'inline' };
+  }
+
+  // 2. Cloud-init URL provided
+  if (params.cloud_init_url) {
+    try {
+      const content = await fetchFromUrl(params.cloud_init_url);
+      return { content, source: `url:${params.cloud_init_url}` };
+    } catch (error) {
+      throw new Error(`Failed to fetch cloud-init from URL: ${error.message}`);
+    }
+  }
+
+  // 3. Cloud-init file path provided
+  if (params.cloud_init_file) {
+    try {
+      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}`);
+    }
+  }
+
+  // 4. Use default cloud-init from environment if requested
+  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://')) {
+        const content = await fetchFromUrl(DEFAULT_CLOUD_INIT);
+        return { content, source: `default_url:${DEFAULT_CLOUD_INIT}` };
+      } else {
+        const content = fs.readFileSync(DEFAULT_CLOUD_INIT, 'utf8');
+        return { content, source: `default_file:${DEFAULT_CLOUD_INIT}` };
+      }
+    } catch (error) {
+      throw new Error(`Failed to load default cloud-init: ${error.message}`);
+    }
+  }
+
+  // No cloud-init
+  return null;
+}
+
+// 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"
+      },
+      use_default: {
+        type: "boolean",
+        description: "Fetch from the default CLOUD_INIT environment variable",
+        default: 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}`;
+      } 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 {
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            success: false,
+            error: "Please provide url, file, or set use_default to true"
+          }, null, 2)
+        }]
+      };
+    }
+
+    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)
+      }]
+    };
+  }
+});
+
+// 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"
+      }
+    },
+    additionalProperties: false
+  }
+}, 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)
+    }]
+  };
+});
+
+// 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);
+
+    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
+      },
+      status: {
+        type: "string",
+        enum: ["active", "queued", "saving", "deleted"],
+        description: "Filter by image status"
+      }
+    },
+    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);
+
+    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)
+      }]
+    };
+  }
+});
+
+// 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);
+
+    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);
+
+    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);
+
+    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);
+
+    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"
+      },
+      public_key_file: {
+        type: "string",
+        description: "Path to existing public key file (optional, will generate if not provided)"
+      }
+    },
+    required: ["name"],
+    additionalProperties: false
+  }
+}, async (params) => {
+  try {
+    const args = ["keypair", "create", params.name];
+
+    if (params.public_key_file) {
+      args.push("--public-key", params.public_key_file);
+    }
+
+    args.push("-f", "json");
+
+    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"
+    };
+
+    // 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)
+      }]
+    };
+  }
+});
+
+// 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"
+      },
+      name: {
+        type: "string",
+        description: "Filter by server name (partial match)"
+      }
+    },
+    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);
+
+    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)
+      }]
+    };
+  }
+});
+
+// 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)"
+      },
+      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
+  }
+}, async (params) => {
+  let tmpFile = null;
+  let cloudInitInfo = null;
+
+  try {
+    const args = ["server", "create"];
+    args.push("--image", params.image);
+    args.push("--flavor", params.flavor);
+
+    if (params.network) {
+      args.push("--network", params.network);
+    }
+
+    if (params.keypair) {
+      args.push("--key-name", params.keypair);
+    }
+
+    if (params.security_groups && params.security_groups.length > 0) {
+      params.security_groups.forEach(sg => {
+        args.push("--security-group", sg);
+      });
+    }
+
+    // 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.availability_zone) {
+      args.push("--availability-zone", params.availability_zone);
+    }
+
+    if (params.wait !== false) {
+      args.push("--wait");
+    }
+
+    args.push("-f", "json");
+    args.push(params.name);
+
+    const result = await runOpenStackCommand(args, 300000); // 5 minute timeout for server creation
+    const serverResult = JSON.parse(result.output);
+
+    // 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 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"
+    };
+
+    // 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"
+      }
+    },
+    required: ["server"],
+    additionalProperties: false
+  }
+}, 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)
+      }]
+    };
+  }
+});
+
+// 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"
+      },
+      wait: {
+        type: "boolean",
+        description: "Wait for deletion to complete",
+        default: true
+      }
+    },
+    required: ["server"],
+    additionalProperties: false
+  }
+}, async (params) => {
+  try {
+    const args = ["server", "delete", params.server];
+    if (params.wait !== false) {
+      args.push("--wait");
+    }
+
+    await runOpenStackCommand(args, 180000); // 3 minute timeout
+
+    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)
+      }]
+    };
+  }
+});
+
+// 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"
+      }
+    },
+    required: ["server"],
+    additionalProperties: false
+  }
+}, 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)
+      }]
+    };
+  }
+});
+
+// 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"
+      }
+    },
+    required: ["server"],
+    additionalProperties: false
+  }
+}, 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)
+      }]
+    };
+  }
+});
+
+// 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"
+      },
+      hard: {
+        type: "boolean",
+        description: "Perform hard reboot instead of soft reboot",
+        default: 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);
+
+    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)
+      }]
+    };
+  }
+});
+
+// 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"
+      },
+      type: {
+        type: "string",
+        enum: ["novnc", "xvpvnc", "spice", "rdp", "serial"],
+        description: "Console type",
+        default: "novnc"
+      }
+    },
+    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);
+
+    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"
+      }
+    },
+    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);
+
+    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)
+      }]
+    };
+  } 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);
+
+    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"
+      },
+      floating_ip: {
+        type: "string",
+        description: "Floating IP address to associate"
+      }
+    },
+    required: ["server", "floating_ip"],
+    additionalProperties: false
+  }
+}, 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)
+      }]
+    };
+  }
+});
+
+// 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);
+
+    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)"
+      },
+      image: {
+        type: "string",
+        description: "Image ID to create volume from (optional)"
+      }
+    },
+    required: ["name", "size"],
+    additionalProperties: false
+  }
+}, async (params) => {
+  try {
+    const args = ["volume", "create"];
+    args.push("--size", params.size.toString());
+
+    if (params.type) {
+      args.push("--type", params.type);
+    }
+
+    if (params.image) {
+      args.push("--image", params.image);
+    }
+
+    args.push("-f", "json");
+    args.push(params.name);
+
+    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
+          },
+          message: "Volume created successfully"
+        }, 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"
+      },
+      device: {
+        type: "string",
+        description: "Device path (e.g., /dev/vdb), auto-assigned if not specified"
+      }
+    },
+    required: ["server", "volume"],
+    additionalProperties: false
+  }
+}, async (params) => {
+  try {
+    const args = ["server", "add", "volume"];
+
+    if (params.device) {
+      args.push("--device", params.device);
+    }
+
+    args.push(params.server);
+    args.push(params.volume);
+
+    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)
+      }]
+    };
+  }
+});
+
+// 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
+      }
+    },
+    additionalProperties: false
+  }
+}, 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)
+    }]
+  };
+});
+
+// Start the MCP server
+async function main() {
+  try {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+
+    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);
+  }
+}
+
+main().catch((error) => {
+  console.error("Server startup error:", error);
+  process.exit(1);
+});