@meshxdata/fops 0.1.49 → 0.1.50

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

@@ -984,15 +984,50 @@ app.run()
       .command("tray")
       .description("Run a macOS menu bar tray for the Foundation stack")
       .option("--url <url>", "Override the backend API URL")
+      .option("--force", "Kill existing tray and start a new one")
       .action(async (opts) => {
-        const { spawn } = await import("node:child_process");
-        const { writeFileSync, existsSync, realpathSync, readFileSync } = await import("node:fs");
+        const { spawn, execSync } = await import("node:child_process");
+        const { writeFileSync, existsSync, realpathSync, readFileSync, mkdirSync, unlinkSync } = await import("node:fs");
         const { tmpdir, homedir } = await import("node:os");
         const { join, dirname } = await import("node:path");
         const { findComposeRoot } = await import("./lib/tools-write.js");
 
         const composeRoot = program._fopsRoot || findComposeRoot() || "";
 
+        // ── Singleton check ─────────────────────────────────────────────────────
+        const fopsDir = join(homedir(), ".fops");
+        const pidFile = join(fopsDir, ".tray.pid");
+
+        const isProcessRunning = (pid) => {
+          try {
+            process.kill(pid, 0);
+            return true;
+          } catch {
+            return false;
+          }
+        };
+
+        if (existsSync(pidFile)) {
+          try {
+            const existingPid = parseInt(readFileSync(pidFile, "utf8").trim(), 10);
+            if (existingPid && isProcessRunning(existingPid)) {
+              if (opts.force) {
+                console.log(ACCENT("  Killing existing tray process..."));
+                try { process.kill(existingPid, "SIGTERM"); } catch { /* ignore */ }
+                // Wait a bit for process to terminate
+                await new Promise((r) => setTimeout(r, 500));
+              } else {
+                console.log(ACCENT("  Foundation tray is already running (PID: " + existingPid + ")"));
+                console.log(ACCENT("  Use --force to restart it"));
+                return;
+              }
+            }
+          } catch { /* ignore invalid pid file */ }
+        }
+
+        // Ensure .fops directory exists
+        if (!existsSync(fopsDir)) mkdirSync(fopsDir, { recursive: true });
+
         let apiUrl = opts.url || process.env.FOPS_API_URL || "http://127.0.0.1:9001";
 
         // Current fops version — resolve from the running binary's location
@@ -1021,19 +1056,27 @@ app.run()
           if (existsSync(src)) iconPath = src;
         } catch { /* icon optional */ }
 
-        // Discover installed plugins for the Plugins submenu
-        let fopsPluginsJson = "[]";
+        // Plugin discovery paths - tray will discover plugins dynamically
+        const globalPluginsDir = join(homedir(), ".fops", "plugins");
+        let npmPluginsDir = "";
         try {
-          const { discoverPlugins } = await import("../../discovery.js");
-          const { validateManifest } = await import("../../manifest.js");
-          const candidates = discoverPlugins();
-          const pluginList = candidates.map((c) => {
-            const manifest = validateManifest(c.path);
-            return { id: c.id, name: manifest?.name || c.id, source: c.source };
-          }).filter((p) => p.id);
-          fopsPluginsJson = JSON.stringify(pluginList);
+          const pluginsNodeModules = join(homedir(), ".fops", "plugins", "node_modules");
+          const fopsRoot = dirname(realpathSync(pluginsNodeModules));
+          npmPluginsDir = join(fopsRoot, "node_modules");
         } catch { /* optional */ }
 
+        // Common environment for tray processes
+        const trayEnv = {
+          ...process.env,
+          FOUNDATION_API_URL: apiUrl,
+          FOUNDATION_URL: "http://127.0.0.1:3002",
+          FOUNDATION_ICON: iconPath,
+          FOUNDATION_COMPOSE_ROOT: composeRoot,
+          FOPS_VERSION: fopsVersion,
+          FOPS_GLOBAL_PLUGINS_DIR: globalPluginsDir,
+          FOPS_NPM_PLUGINS_DIR: npmPluginsDir,
+        };
+
         // ── Windows tray (PowerShell NotifyIcon) ─────────────────────────────
         if (process.platform === "win32") {
           const ps1Tray = join(tmpdir(), "fops-tray.ps1");
@@ -1044,8 +1087,49 @@ Add-Type -AssemblyName System.Drawing
 $script:apiUrl       = $env:FOUNDATION_API_URL
 $script:composeRoot  = $env:FOUNDATION_COMPOSE_ROOT
 $script:foundationUrl = if ($env:FOUNDATION_URL) { $env:FOUNDATION_URL } else { "http://127.0.0.1:3002" }
-$script:allPlugins   = @()
-try { $script:allPlugins = $env:FOPS_PLUGINS | ConvertFrom-Json } catch {}
+$script:globalPluginsDir = $env:FOPS_GLOBAL_PLUGINS_DIR
+$script:npmPluginsDir = $env:FOPS_NPM_PLUGINS_DIR
+
+function Discover-Plugins {
+    $plugins = @()
+    # Global plugins: ~/.fops/plugins/<name>/
+    if ($script:globalPluginsDir -and (Test-Path $script:globalPluginsDir)) {
+        Get-ChildItem -Path $script:globalPluginsDir -Directory -ErrorAction SilentlyContinue | ForEach-Object {
+            $manifestPath = Join-Path $_.FullName "fops.plugin.json"
+            if (Test-Path $manifestPath) {
+                try {
+                    $manifest = Get-Content $manifestPath -Raw | ConvertFrom-Json
+                    $plugins += [PSCustomObject]@{
+                        id = $_.Name
+                        name = if ($manifest.name) { $manifest.name } else { $_.Name }
+                        source = "global"
+                    }
+                } catch {
+                    $plugins += [PSCustomObject]@{ id = $_.Name; name = $_.Name; source = "global" }
+                }
+            }
+        }
+    }
+    # NPM plugins: node_modules/fops-plugin-*
+    if ($script:npmPluginsDir -and (Test-Path $script:npmPluginsDir)) {
+        Get-ChildItem -Path $script:npmPluginsDir -Directory -Filter "fops-plugin-*" -ErrorAction SilentlyContinue | ForEach-Object {
+            $manifestPath = Join-Path $_.FullName "fops.plugin.json"
+            if (Test-Path $manifestPath) {
+                try {
+                    $manifest = Get-Content $manifestPath -Raw | ConvertFrom-Json
+                    $plugins += [PSCustomObject]@{
+                        id = $_.Name
+                        name = if ($manifest.name) { $manifest.name } else { $_.Name }
+                        source = "npm"
+                    }
+                } catch {
+                    $plugins += [PSCustomObject]@{ id = $_.Name; name = $_.Name; source = "npm" }
+                }
+            }
+        }
+    }
+    return $plugins
+}
 
 function Get-Docker {
     foreach ($p in @("C:\\Program Files\\Docker\\Docker\\resources\\bin\\docker.exe")) {
@@ -1156,11 +1240,12 @@ $menu.Items.Add($composeItem) | Out-Null
 $pluginsItem = [System.Windows.Forms.ToolStripMenuItem]::new("Plugins")
 $pluginsItem.add_DropDownOpening({
     $pluginsItem.DropDownItems.Clear()
-    if ($script:allPlugins.Count -eq 0) {
+    $currentPlugins = Discover-Plugins
+    if ($currentPlugins.Count -eq 0) {
         $n = [System.Windows.Forms.ToolStripMenuItem]::new("No plugins installed")
         $n.Enabled = $false; $pluginsItem.DropDownItems.Add($n) | Out-Null; return
     }
-    foreach ($plugin in $script:allPlugins) {
+    foreach ($plugin in $currentPlugins) {
         $enabled = Read-PluginEnabled $plugin.id
         $prefix  = if ($enabled) { [char]0x2713 + " " } else { "  " }
         $pItem   = [System.Windows.Forms.ToolStripMenuItem]::new($prefix + $plugin.name)
@@ -1235,6 +1320,7 @@ $tray.Visible = $false
             env: trayEnv,
             windowsHide: true,
           });
+          writeFileSync(pidFile, String(winChild.pid));
           winChild.unref();
           return;
         }
@@ -1266,6 +1352,8 @@ func git() -> String {
 let composeRoot  = ProcessInfo.processInfo.environment["FOUNDATION_COMPOSE_ROOT"] ?? ""
 let iconPath     = ProcessInfo.processInfo.environment["FOUNDATION_ICON"] ?? ""
 let fopsVersion  = ProcessInfo.processInfo.environment["FOPS_VERSION"] ?? "0.0.0"
+let globalPluginsDir = ProcessInfo.processInfo.environment["FOPS_GLOBAL_PLUGINS_DIR"] ?? ""
+let npmPluginsDir = ProcessInfo.processInfo.environment["FOPS_NPM_PLUGINS_DIR"] ?? ""
 
 // ── Plugin registry ───────────────────────────────────────────────────────────
 
@@ -1275,15 +1363,52 @@ struct PluginEntry {
     let source: String
 }
 
-let allPlugins: [PluginEntry] = {
-    let raw = ProcessInfo.processInfo.environment["FOPS_PLUGINS"] ?? "[]"
-    guard let data = raw.data(using: .utf8),
-          let arr = try? JSONSerialization.jsonObject(with: data) as? [[String: Any]] else { return [] }
-    return arr.compactMap { obj in
-        guard let id = obj["id"] as? String, let name = obj["name"] as? String else { return nil }
-        return PluginEntry(id: id, name: name, source: (obj["source"] as? String) ?? "")
+func discoverPlugins() -> [PluginEntry] {
+    var plugins: [PluginEntry] = []
+    let fm = FileManager.default
+
+    // Global plugins: ~/.fops/plugins/<name>/
+    if !globalPluginsDir.isEmpty, fm.fileExists(atPath: globalPluginsDir) {
+        if let dirs = try? fm.contentsOfDirectory(atPath: globalPluginsDir) {
+            for dir in dirs {
+                let pluginPath = (globalPluginsDir as NSString).appendingPathComponent(dir)
+                let manifestPath = (pluginPath as NSString).appendingPathComponent("fops.plugin.json")
+                var isDir: ObjCBool = false
+                guard fm.fileExists(atPath: pluginPath, isDirectory: &isDir), isDir.boolValue,
+                      fm.fileExists(atPath: manifestPath) else { continue }
+                var name = dir
+                if let data = try? Data(contentsOf: URL(fileURLWithPath: manifestPath)),
+                   let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
+                   let manifestName = json["name"] as? String {
+                    name = manifestName
+                }
+                plugins.append(PluginEntry(id: dir, name: name, source: "global"))
+            }
+        }
+    }
+
+    // NPM plugins: node_modules/fops-plugin-*
+    if !npmPluginsDir.isEmpty, fm.fileExists(atPath: npmPluginsDir) {
+        if let dirs = try? fm.contentsOfDirectory(atPath: npmPluginsDir) {
+            for dir in dirs where dir.hasPrefix("fops-plugin-") {
+                let pluginPath = (npmPluginsDir as NSString).appendingPathComponent(dir)
+                let manifestPath = (pluginPath as NSString).appendingPathComponent("fops.plugin.json")
+                var isDir: ObjCBool = false
+                guard fm.fileExists(atPath: pluginPath, isDirectory: &isDir), isDir.boolValue,
+                      fm.fileExists(atPath: manifestPath) else { continue }
+                var name = dir
+                if let data = try? Data(contentsOf: URL(fileURLWithPath: manifestPath)),
+                   let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
+                   let manifestName = json["name"] as? String {
+                    name = manifestName
+                }
+                plugins.append(PluginEntry(id: dir, name: name, source: "npm"))
+            }
+        }
     }
-}()
+
+    return plugins
+}
 
 func readPluginEnabled(_ id: String) -> Bool {
     let home = ProcessInfo.processInfo.environment["HOME"] ?? ""
@@ -1316,6 +1441,11 @@ func compose(_ args: [String], capture: Bool = false, done: ((String, Bool) -> V
     run(docker(), ["compose"] + args, capture: capture, done: done)
 }
 
+func fops(_ args: [String], capture: Bool = false, done: ((String, Bool) -> Void)? = nil) {
+    let fopsPath = "/opt/homebrew/bin/fops"
+    run(fopsPath, args, cwd: nil, capture: capture, done: done)
+}
+
 // ── Service discovery ─────────────────────────────────────────────────────────
 
 struct Service {
@@ -1439,6 +1569,12 @@ let pluginsMenu = NSMenu(title: "Plugins")
 pluginsItem.submenu = pluginsMenu
 menu.addItem(pluginsItem)
 
+// Azure > VMs / AKS (populated dynamically)
+let azureItem = NSMenuItem(title: "Azure", action: nil, keyEquivalent: "")
+let azureMenu = NSMenu(title: "Azure")
+azureItem.submenu = azureMenu
+menu.addItem(azureItem)
+
 menu.addItem(NSMenuItem.separator())
 
 let openItem = NSMenuItem(title: "Open Foundation…", action: #selector(AppDelegate.openBrowser), keyEquivalent: "o")
@@ -1474,6 +1610,7 @@ class AppDelegate: NSObject, NSApplicationDelegate, NSMenuDelegate {
     func applicationDidFinishLaunching(_ n: Notification) {
         composeMenu.delegate = self
         pluginsMenu.delegate = pluginsMenuDelegate
+        azureMenu.delegate = self
         refresh()
         let pollTimer = Timer(timeInterval: 8, repeats: true) { _ in self.refresh() }
         RunLoop.main.add(pollTimer, forMode: .common)
@@ -1536,34 +1673,73 @@ class AppDelegate: NSObject, NSApplicationDelegate, NSMenuDelegate {
         RunLoop.main.add(pulse, forMode: .common)
     }
 
+    var updateSpinnerTimer: Timer?
+    var updateSpinnerFrame = 0
+
+    func startUpdateSpinner(item: NSMenuItem, label: String) {
+        item.isEnabled = false
+        updateSpinnerFrame = 0
+        updateSpinnerTimer?.invalidate()
+        let t = Timer(timeInterval: 0.1, repeats: true) { _ in
+            let frame = self.spinnerFrames[self.updateSpinnerFrame % self.spinnerFrames.count]
+            item.title = "\\(frame) \\(label)"
+            self.updateSpinnerFrame += 1
+        }
+        RunLoop.main.add(t, forMode: .common)
+        updateSpinnerTimer = t
+    }
+
+    func stopUpdateSpinner() {
+        updateSpinnerTimer?.invalidate()
+        updateSpinnerTimer = nil
+    }
+
     @objc func checkForUpdateManual() {
-        checkUpdateItem.title = "Checking…"
-        checkUpdateItem.isEnabled = false
+        startUpdateSpinner(item: checkUpdateItem, label: "Checking for updates…")
         checkForUpdate()
         DispatchQueue.main.asyncAfter(deadline: .now() + 3) {
+            self.stopUpdateSpinner()
             checkUpdateItem.title = "Check for updates"
             checkUpdateItem.isEnabled = true
         }
     }
 
     @objc func runUpdate() {
-        updateItem.title = "⬆ Updating…"
-        updateItem.isEnabled = false
+        startUpdateSpinner(item: updateItem, label: "Updating fops…")
         let npm = "/opt/homebrew/bin/npm"
         let p = Process()
         p.executableURL = URL(fileURLWithPath: npm)
         p.arguments = ["install", "-g", "@meshxdata/fops"]
-        p.terminationHandler = { _ in
+        p.terminationHandler = { proc in
             DispatchQueue.main.async {
-                updateItem.title = "✓ Updated — restart tray to apply"
-                updateItem.isEnabled = false
+                self.stopUpdateSpinner()
+                if proc.terminationStatus == 0 {
+                    updateItem.title = "✓ Updated — restarting tray…"
+                    updateItem.isEnabled = false
+                    // Relaunch tray after short delay
+                    DispatchQueue.main.asyncAfter(deadline: .now() + 1) {
+                        let fops = "/opt/homebrew/bin/fops"
+                        let relaunch = Process()
+                        relaunch.executableURL = URL(fileURLWithPath: fops)
+                        relaunch.arguments = ["tray"]
+                        try? relaunch.run()
+                        NSApp.terminate(nil)
+                    }
+                } else {
+                    updateItem.title = "✗ Update failed"
+                    updateItem.isEnabled = true
+                }
             }
         }
         try? p.run()
     }
 
-    // Rebuild Compose submenu each time it opens
+    // Rebuild Compose/Azure submenus each time they open
     func menuWillOpen(_ m: NSMenu) {
+        if m === azureMenu {
+            populateAzureMenu(m)
+            return
+        }
         guard m === composeMenu else { return }
         m.removeAllItems()
         let loading = NSMenuItem(title: "Loading services…", action: nil, keyEquivalent: "")
@@ -1639,6 +1815,102 @@ class AppDelegate: NSObject, NSApplicationDelegate, NSMenuDelegate {
 
     @objc func noop() {}
 
+    // ── Azure Menu ───────────────────────────────────────────────────────────────
+
+    var azureCache: [String: Any]? = nil
+    var azureCacheTime: Date? = nil
+    let azureCacheTTL: TimeInterval = 60 // 60 seconds
+
+    func populateAzureMenu(_ m: NSMenu) {
+        // Use cache if fresh
+        if let cache = azureCache,
+           let cacheTime = azureCacheTime,
+           Date().timeIntervalSince(cacheTime) < azureCacheTTL {
+            renderAzureMenu(m, data: cache)
+            return
+        }
+
+        m.removeAllItems()
+        let loading = NSMenuItem(title: "Loading resources…", action: nil, keyEquivalent: "")
+        loading.isEnabled = false
+        m.addItem(loading)
+
+        // Fetch VMs and AKS clusters via fops azure list --json
+        fops(["azure", "list", "--json"], capture: true) { out, success in
+            guard success,
+                  let data = out.data(using: .utf8),
+                  let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else {
+                m.removeAllItems()
+                let err = NSMenuItem(title: "Not authenticated or plugin disabled", action: nil, keyEquivalent: "")
+                err.isEnabled = false
+                m.addItem(err)
+                return
+            }
+
+            // Update cache
+            self.azureCache = json
+            self.azureCacheTime = Date()
+
+            self.renderAzureMenu(m, data: json)
+        }
+    }
+
+    func renderAzureMenu(_ m: NSMenu, data: [String: Any]) {
+        m.removeAllItems()
+
+        let vms = data["vms"] as? [[String: Any]] ?? []
+        let clusters = data["clusters"] as? [[String: Any]] ?? []
+
+        // VMs section
+        if !vms.isEmpty {
+            let vmHeader = NSMenuItem(title: "VMs", action: nil, keyEquivalent: "")
+            vmHeader.isEnabled = false
+            m.addItem(vmHeader)
+            for vm in vms {
+                let name = vm["name"] as? String ?? "unknown"
+                let ip = vm["publicIp"] as? String ?? ""
+                let ipSuffix = ip.isEmpty ? "" : " (\\(ip))"
+                let item = NSMenuItem(title: "  " + name + ipSuffix, action: #selector(AppDelegate.openAzureVM(_:)), keyEquivalent: "")
+                item.representedObject = name
+                item.target = self
+                m.addItem(item)
+            }
+        }
+
+        // AKS section
+        if !clusters.isEmpty {
+            if !vms.isEmpty { m.addItem(NSMenuItem.separator()) }
+            let aksHeader = NSMenuItem(title: "AKS Clusters", action: nil, keyEquivalent: "")
+            aksHeader.isEnabled = false
+            m.addItem(aksHeader)
+            for cluster in clusters {
+                let name = cluster["name"] as? String ?? "unknown"
+                let state = cluster["provisioningState"] as? String ?? ""
+                let dot = state.lowercased() == "succeeded" ? "● " : "○ "
+                let item = NSMenuItem(title: "  " + dot + name, action: #selector(AppDelegate.openAzureAKS(_:)), keyEquivalent: "")
+                item.representedObject = name
+                item.target = self
+                m.addItem(item)
+            }
+        }
+
+        if vms.isEmpty && clusters.isEmpty {
+            let none = NSMenuItem(title: "No resources found", action: nil, keyEquivalent: "")
+            none.isEnabled = false
+            m.addItem(none)
+        }
+    }
+
+    @objc func openAzureVM(_ sender: NSMenuItem) {
+        guard let name = sender.representedObject as? String else { return }
+        openTerminal(command: "fops azure ssh \\(name)")
+    }
+
+    @objc func openAzureAKS(_ sender: NSMenuItem) {
+        guard let name = sender.representedObject as? String else { return }
+        openTerminal(command: "fops azure aks status \\(name)")
+    }
+
     // ── Stack-level actions ───────────────────────────────────────────────────
 
     func refresh() {
@@ -1946,17 +2218,19 @@ class BranchMenuDelegate: NSObject, NSMenuDelegate {
 
 // ── PluginMenuDelegate ────────────────────────────────────────────────────────
 // Populates the Plugins submenu lazily; clicking a plugin item toggles it.
+// Discovers plugins dynamically each time the menu opens.
 
 class PluginMenuDelegate: NSObject, NSMenuDelegate {
     func menuWillOpen(_ menu: NSMenu) {
         menu.removeAllItems()
-        if allPlugins.isEmpty {
+        let currentPlugins = discoverPlugins()
+        if currentPlugins.isEmpty {
             let none = NSMenuItem(title: "No plugins installed", action: nil, keyEquivalent: "")
             none.isEnabled = false
             menu.addItem(none)
             return
         }
-        for plugin in allPlugins {
+        for plugin in currentPlugins {
             let enabled = readPluginEnabled(plugin.id)
             let prefix = enabled ? "✓ " : "  "
             let item = NSMenuItem(
@@ -1978,16 +2252,6 @@ app.delegate = delegate
 app.run()
 `);
 
-        const trayEnv = {
-          ...process.env,
-          FOUNDATION_API_URL: apiUrl,
-          FOUNDATION_URL: "http://127.0.0.1:3002",
-          FOUNDATION_ICON: iconPath,
-          FOUNDATION_COMPOSE_ROOT: composeRoot,
-          FOPS_VERSION: fopsVersion,
-          FOPS_PLUGINS: fopsPluginsJson,
-        };
-
         console.log(ACCENT("  Foundation tray started — look for the icon in your menu bar"));
 
         const child = spawn("swift", [swiftTray], {
@@ -1995,6 +2259,7 @@ app.run()
           detached: true,
           env: trayEnv,
         });
+        writeFileSync(pidFile, String(child.pid));
         child.unref();
       });
   });