@meshxdata/fops 0.1.52 → 0.1.54

package/src/plugins/bundled/fops-plugin-cloud/fops.plugin.json

@@ -0,0 +1,6 @@
+{
+  "id": "fops-plugin-cloud",
+  "name": "meshXcloud",
+  "version": "0.1.0",
+  "description": "Web-based cloud management panel for Azure deployments"
+}

package/src/plugins/bundled/fops-plugin-cloud/index.js

@@ -0,0 +1,208 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+export async function register(api) {
+  const distDir = path.join(__dirname, "ui", "dist");
+
+  // ── Web Panel ──────────────────────────────────────────
+  const { createCloudApi } = await import("./api.js");
+
+  api.registerWebPanel({
+    name: "cloud",
+    title: "meshXcloud",
+    prefix: "/cloud",
+    distDir,
+    apiFactory: (registry) => createCloudApi(registry),
+  });
+
+  // ── Embeddings: index cost, fleet, and audit data ─────
+  api.registerIndexSource({
+    name: "cloud",
+    fn: async (_root, log) => {
+      const chunks = [];
+      const FOPS_URL = process.env.FOPS_API_URL || "http://127.0.0.1:4100";
+      const safeFetch = async (path) => {
+        try {
+          const res = await fetch(`${FOPS_URL}${path}`, { signal: AbortSignal.timeout(30_000) });
+          if (!res.ok) return null;
+          return res.json();
+        } catch { return null; }
+      };
+
+      // Fleet state
+      const fleet = await safeFetch("/api/fleet");
+      if (fleet?.vms) {
+        for (const vm of fleet.vms) {
+          const svcs = vm.services ? Object.entries(vm.services).map(([k, v]) => `${k}: ${v}`).join(", ") : "";
+          chunks.push({
+            title: `Fleet: ${vm.vm}`,
+            content: `VM ${vm.vm} (${vm.ip || ""}) — status: ${vm.status}, containers: ${vm.containers}, disk: ${vm.disk || "?"}, memory: ${vm.memory || "?"}, load: ${vm.load || "?"}, branch: ${vm.branch || "?"}, commit: ${vm.commit || "?"}, fops: ${vm.fopsVersion || "?"}, services: ${svcs}`,
+            metadata: { source: "cloud-fleet", vm: vm.vm },
+          });
+        }
+        if (log) log(`  cloud: indexed ${fleet.vms.length} VMs`);
+      }
+
+      // Cost data
+      const costs = await safeFetch("/api/tools/azure_cost_all_subscriptions");
+      const costData = costs?.result || costs;
+      if (costData?.subscriptions) {
+        for (const sub of costData.subscriptions) {
+          const services = (sub.services || []).map((s) => `${s.name || s.service}: $${s.cost}`).join(", ");
+          chunks.push({
+            title: `Costs: ${sub.name || sub.subscriptionId}`,
+            content: `Subscription ${sub.name || sub.subscriptionId} — total: $${sub.cost || sub.totalCost || 0}, currency: ${sub.currency || "USD"}, services: ${services}`,
+            metadata: { source: "cloud-costs", subscription: sub.name || sub.subscriptionId },
+          });
+        }
+        if (log) log(`  cloud: indexed ${costData.subscriptions.length} subscription costs`);
+      }
+
+      // Budgets
+      const budgetsRaw = await safeFetch("/api/tools/azure_budgets");
+      const budgetList = Array.isArray(budgetsRaw?.result || budgetsRaw) ? (budgetsRaw?.result || budgetsRaw) : [];
+      for (const b of budgetList) {
+        chunks.push({
+          title: `Budget: ${b.name}`,
+          content: `Budget ${b.name} — limit: $${b.limit || b.amount || 0}, spent: $${b.spent || b.currentSpend || 0}, usage: ${b.limit ? (((b.spent || b.currentSpend || 0) / b.limit) * 100).toFixed(0) : "?"}%`,
+          metadata: { source: "cloud-budgets" },
+        });
+      }
+      if (budgetList.length && log) log(`  cloud: indexed ${budgetList.length} budgets`);
+
+      // Audit findings
+      const audit = await safeFetch("/api/tools/security_audit_all");
+      const auditData = audit?.result || audit;
+      const allFindings = [
+        ...(auditData?.vms?.findings || []),
+        ...(auditData?.aks?.findings || []),
+        ...(auditData?.storage?.findings || []),
+      ];
+      if (allFindings.length) {
+        const warns = allFindings.filter((f) => f.severity === "warn");
+        chunks.push({
+          title: "Security Audit Summary",
+          content: `${allFindings.length} findings (${warns.length} warnings). ${warns.map((f) => `${f.check}: ${f.message}`).join("; ")}`,
+          metadata: { source: "cloud-audit" },
+        });
+        if (log) log(`  cloud: indexed ${allFindings.length} audit findings`);
+      }
+
+      return chunks;
+    },
+  });
+
+  // ── CLI Command ────────────────────────────────────────
+  api.registerCommand((program, registry) => {
+    program
+      .command("cloud")
+      .description("Start meshXcloud web UI with fleet scraping")
+      .option("-p, --port <port>", "Web server port", "3099")
+      .option("--no-open", "Don't open browser automatically")
+      .option("--no-scrape", "Disable fleet scraping")
+      .action(async (opts) => {
+        const chalk = (await import("chalk")).default;
+        const port = parseInt(opts.port);
+        const url = `http://localhost:${port}/cloud`;
+        const root = program._fopsRoot || process.cwd();
+
+        // Check if server is already running
+        try {
+          const res = await fetch(`http://localhost:${port}/api/health`, { signal: AbortSignal.timeout(1000) });
+          if (res.ok) {
+            console.log(`  Server already running on port ${port}`);
+            if (opts.open !== false) {
+              try { const open = (await import("open")).default; await open(url); } catch {}
+            }
+            console.log(`  ${url}`);
+            await new Promise((resolve) => { process.on("SIGINT", resolve); });
+            return;
+          }
+        } catch {}
+
+        console.log(chalk.cyan(`  Starting meshXcloud on port ${port}...`));
+
+        // Resolve core module paths via api.getCliPath (works from ~/.fops/plugins/ or source)
+        const serverPath = api.getCliPath?.("src", "web", "server.js");
+        const fleetPath = api.getCliPath?.("src", "fleet-registry.js");
+        const servePath = api.getCliPath?.("src", "serve.js");
+        const syncPath = api.getCliPath?.("src", "plugins", "bundled", "fops-plugin-azure", "lib", "azure-sync.js");
+
+        if (!serverPath) {
+          console.error(chalk.red("  Cannot resolve core modules. Are you running from the CLI?"));
+          process.exitCode = 1;
+          return;
+        }
+
+        // Start fleet scraper (SSH → VMs, same as fops serve --scrape)
+        if (opts.scrape !== false && fleetPath && servePath && syncPath) {
+          try {
+            const { azureSync, startBackgroundSync } = await import(syncPath);
+            try { await azureSync({ quiet: true }); } catch {}
+            startBackgroundSync(120);
+
+            const { FleetRegistry } = await import(fleetPath);
+            const { setFleetRegistry } = await import(servePath);
+            const fleet = new FleetRegistry({
+              interval: 60,
+              retention: 10,
+              onScrape: (snapshots) => {
+                const ok = snapshots.filter(s => s.status === "healthy").length;
+                console.log(chalk.dim(`  [scrape] ${ok}/${snapshots.length} healthy  ${new Date().toLocaleTimeString()}`));
+              },
+            });
+            setFleetRegistry(fleet);
+            fleet.start();
+            console.log(chalk.dim("  Fleet scraping enabled"));
+          } catch (e) {
+            console.log(chalk.yellow(`  Fleet scraping unavailable: ${e.message}`));
+          }
+        }
+
+        // Start fops serve API on port 4100 (fleet, tools, grafana, exec endpoints)
+        try {
+          const { startServer } = await import(servePath);
+          const servePort = parseInt(process.env.FOPS_API_PORT || "4100");
+          await startServer(registry, { port: servePort, host: "127.0.0.1", skipEmbedIndex: true });
+          console.log(chalk.dim(`  API server on port ${servePort}`));
+        } catch (e) {
+          console.log(chalk.yellow(`  API server unavailable: ${e.message}`));
+        }
+
+        // Start web server (same as fops agent --web, mounts cloud panel + API)
+        try {
+          const { startWebServer } = await import(serverPath);
+          await startWebServer(root, registry, { port });
+          console.log(chalk.green(`  meshXcloud: ${url}`));
+          if (opts.open !== false) {
+            try { const open = (await import("open")).default; await open(url); } catch {}
+          }
+          // Keep alive
+          await new Promise(() => {});
+        } catch (err) {
+          if (err.code === "EADDRINUSE") {
+            console.error(chalk.red(`  Port ${port} in use. Try: fops cloud --port ${port + 1}`));
+            process.exitCode = 1;
+          } else {
+            throw err;
+          }
+        }
+      });
+  });
+
+  // ── Doctor Check ───────────────────────────────────────
+  api.registerDoctorCheck({
+    name: "cloud-ui-built",
+    fn: async ({ ok, warn }) => {
+      const indexPath = path.join(distDir, "index.html");
+      if (fs.existsSync(indexPath)) {
+        ok("meshXcloud UI built");
+      } else {
+        warn("meshXcloud UI not built — run: cd platform-fops/src/plugins/bundled/fops-plugin-cloud/ui && npm run build");
+      }
+    },
+  });
+}

package/src/plugins/bundled/fops-plugin-cloud/lib/azure-provider.js

@@ -0,0 +1,81 @@
+/**
+ * AzureProvider — wraps the azure plugin service to implement CloudProvider.
+ */
+
+import { CloudProvider } from "./provider.js";
+
+export class AzureProvider extends CloudProvider {
+  constructor(azureService) {
+    super("azure");
+    this.svc = azureService;
+  }
+
+  async listResources() {
+    const { vms } = this.svc.listVms();
+    const { clusters } = this.svc.listClusters();
+    return {
+      vms: vms.map((v) => ({ ...v, provider: "azure", type: "vm" })),
+      clusters: clusters.map((c) => ({ ...c, provider: "azure", type: "cluster" })),
+    };
+  }
+
+  async getResource(type, name) {
+    if (type === "vm") {
+      const detail = this.svc.getVmDetail(name);
+      if (!detail) return null;
+      const live = await this.svc.getVmLiveStatus(name);
+      return { ...detail, live, provider: "azure", type: "vm" };
+    }
+    if (type === "cluster") {
+      const detail = this.svc.getClusterDetail(name);
+      return detail ? { ...detail, provider: "azure", type: "cluster" } : null;
+    }
+    return null;
+  }
+
+  async createResource(type, opts) {
+    if (type === "vm") return this.svc.provisionVm(opts);
+    if (type === "cluster") return this.svc.provisionCluster(opts);
+    throw new Error(`Unknown resource type: ${type}`);
+  }
+
+  async performAction(type, name, action, opts = {}) {
+    if (type === "vm") {
+      switch (action) {
+        case "start": return this.svc.startVm(name);
+        case "stop": return this.svc.stopVm(name);
+        case "resize": return this.svc.resizeVm(name, opts);
+        case "grant-admin": return this.svc.grantAdmin(name, opts);
+        default: throw new Error(`Unknown VM action: ${action}`);
+      }
+    }
+    throw new Error(`Actions not supported for type: ${type}`);
+  }
+
+  async deleteResource(type, name) {
+    if (type === "vm") return this.svc.deleteVm(name);
+    if (type === "cluster") return this.svc.deleteCluster(name);
+    throw new Error(`Unknown resource type: ${type}`);
+  }
+
+  async getFleet() {
+    return this.svc.getFleet();
+  }
+
+  async syncResources() {
+    return this.svc.syncResources({ quiet: true });
+  }
+
+  async getCosts(opts = {}) {
+    return this.svc.getCosts(opts);
+  }
+
+  async healthCheck() {
+    try {
+      const { vms } = this.svc.listVms();
+      return { available: true, vmCount: vms.length };
+    } catch (e) {
+      return { available: false, error: e.message };
+    }
+  }
+}

package/src/plugins/bundled/fops-plugin-cloud/lib/provider.js

@@ -0,0 +1,50 @@
+/**
+ * CloudProvider — base interface for cloud providers.
+ * Each provider (Azure, AWS, GCP) implements these methods.
+ */
+
+export class CloudProvider {
+  constructor(name) {
+    this.name = name;
+  }
+
+  /** @returns {{ vms: object[], clusters: object[] }} */
+  async listResources() {
+    throw new Error("listResources() not implemented");
+  }
+
+  /** @returns {object|null} */
+  async getResource(type, name) {
+    throw new Error("getResource() not implemented");
+  }
+
+  /** @returns {object} */
+  async createResource(type, opts) {
+    throw new Error("createResource() not implemented");
+  }
+
+  /** @returns {object} */
+  async performAction(type, name, action, opts) {
+    throw new Error("performAction() not implemented");
+  }
+
+  /** @returns {object} */
+  async deleteResource(type, name) {
+    throw new Error("deleteResource() not implemented");
+  }
+
+  /** @returns {object} */
+  async getFleet() {
+    throw new Error("getFleet() not implemented");
+  }
+
+  /** @returns {object} */
+  async syncResources() {
+    throw new Error("syncResources() not implemented");
+  }
+
+  /** @returns {{ available: boolean, error?: string }} */
+  async healthCheck() {
+    return { available: false, error: "not implemented" };
+  }
+}

package/src/plugins/bundled/fops-plugin-cloud/ui/dist/assets/favicon-C49brna2.svg

@@ -0,0 +1,15 @@
+<svg width="410" height="404" viewBox="0 0 410 404" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M399.641 59.5246L215.643 388.545C211.844 395.338 202.084 395.378 198.228 388.618L10.5817 59.5563C6.38087 52.1896 12.6802 43.2665 21.0281 44.7586L205.223 77.6824C206.398 77.8924 207.601 77.8904 208.776 77.6763L389.119 44.8058C397.439 43.2894 403.768 52.1434 399.641 59.5246Z" fill="url(#paint0_linear)"/>
+<path d="M292.965 1.5744L156.801 28.2552C154.563 28.6937 152.906 30.5903 152.771 32.8664L144.395 174.33C144.198 177.662 147.258 180.248 150.51 179.498L188.42 170.749C191.967 169.931 195.172 173.055 194.443 176.622L183.18 231.775C182.422 235.487 185.907 238.661 189.532 237.56L212.947 230.446C216.577 229.344 220.065 232.527 219.297 236.242L201.398 322.875C200.278 328.294 207.486 331.249 210.492 326.603L212.5 323.5L323.454 102.072C325.312 98.3645 322.108 94.137 318.036 94.9228L279.014 102.454C275.347 103.161 272.227 99.746 273.262 96.1583L298.731 7.86689C299.767 4.27314 296.636 0.855181 292.965 1.5744Z" fill="url(#paint1_linear)"/>
+<defs>
+<linearGradient id="paint0_linear" x1="6.00017" y1="32.9999" x2="235" y2="344" gradientUnits="userSpaceOnUse">
+<stop stop-color="#41D1FF"/>
+<stop offset="1" stop-color="#BD34FE"/>
+</linearGradient>
+<linearGradient id="paint1_linear" x1="194.651" y1="8.81818" x2="236.076" y2="292.989" gradientUnits="userSpaceOnUse">
+<stop stop-color="#FFEA83"/>
+<stop offset="0.0833333" stop-color="#FFDD35"/>
+<stop offset="1" stop-color="#FFA800"/>
+</linearGradient>
+</defs>
+</svg>