skillo 0.2.6 → 0.2.9

package/scripts/tray-helper-darwin.swift

@@ -1,180 +1,180 @@
-/**
- * Skillo Tray Helper for macOS
- *
- * Native Swift menu bar icon. Communicates with Node via stdin/stdout JSON lines.
- *
- * Protocol (compatible with systray2):
- *   stdin  <- JSON menu config (first line) + {"type":"update-menu","menu":{...}} for updates
- *   stdout -> {"type":"ready"} on launch, {"type":"clicked","item":{...},"seq_id":N} on click
- */
-
-import Cocoa
-
-// MARK: - JSON models
-
-struct TrayMenuItem: Codable {
-    let title: String
-    let tooltip: String
-    var enabled: Bool?
-    var checked: Bool?
-    var hidden: Bool?
-    var items: [TrayMenuItem]?
-}
-
-struct MenuConfig: Codable {
-    let icon: String
-    let title: String
-    let tooltip: String
-    let items: [TrayMenuItem]
-}
-
-struct UpdateAction: Codable {
-    let type: String
-    let menu: MenuConfig?
-}
-
-struct ClickEvent: Codable {
-    let type: String
-    let item: TrayMenuItem
-    let seq_id: Int
-}
-
-// MARK: - Tray controller
-
-class TrayController: NSObject, NSApplicationDelegate {
-    var statusItem: NSStatusItem!
-    var flatItems: [(TrayMenuItem, Int)] = []
-
-    func applicationDidFinishLaunching(_ notification: Notification) {
-        statusItem = NSStatusBar.system.statusItem(withLength: NSStatusItem.variableLength)
-        statusItem.button?.title = "S"
-
-        // Emit ready
-        writeLine("{\"type\": \"ready\"}")
-
-        // Start reading stdin on background thread
-        startStdinReader()
-    }
-
-    // MARK: stdin reader
-
-    func startStdinReader() {
-        DispatchQueue.global(qos: .userInitiated).async { [weak self] in
-            let handle = FileHandle.standardInput
-            var buf = ""
-
-            while true {
-                guard let data = try? handle.availableData, !data.isEmpty else {
-                    // stdin closed — parent exited
-                    DispatchQueue.main.async { NSApp.terminate(nil) }
-                    return
-                }
-                guard let chunk = String(data: data, encoding: .utf8) else { continue }
-                buf += chunk
-
-                while let newline = buf.firstIndex(of: "\n") {
-                    let line = String(buf[buf.startIndex..<newline]).trimmingCharacters(in: .whitespacesAndNewlines)
-                    buf = String(buf[buf.index(after: newline)...])
-                    if !line.isEmpty {
-                        DispatchQueue.main.async { self?.handleLine(line) }
-                    }
-                }
-            }
-        }
-    }
-
-    func handleLine(_ line: String) {
-        guard let data = line.data(using: .utf8) else { return }
-
-        // Try update action
-        if let action = try? JSONDecoder().decode(UpdateAction.self, from: data),
-           action.type == "update-menu",
-           let menu = action.menu {
-            applyMenu(menu)
-            return
-        }
-
-        // Try initial menu config
-        if let menu = try? JSONDecoder().decode(MenuConfig.self, from: data) {
-            applyMenu(menu)
-        }
-    }
-
-    // MARK: Menu rendering
-
-    func applyMenu(_ config: MenuConfig) {
-        flatItems = []
-
-        // Icon
-        if let btn = statusItem.button {
-            if !config.icon.isEmpty, let imgData = Data(base64Encoded: config.icon) {
-                let img = NSImage(data: imgData)
-                img?.size = NSSize(width: 18, height: 18)
-                img?.isTemplate = true
-                btn.image = img
-                btn.title = ""
-            } else if !config.title.isEmpty {
-                btn.image = nil
-                btn.title = config.title
-            }
-            btn.toolTip = config.tooltip
-        }
-
-        // Menu items
-        let menu = NSMenu()
-        var seq = 0
-
-        for item in config.items {
-            if item.title == "<SEPARATOR>" {
-                menu.addItem(NSMenuItem.separator())
-            } else {
-                let mi = NSMenuItem(title: item.title, action: nil, keyEquivalent: "")
-                mi.toolTip = item.tooltip
-                mi.tag = seq
-
-                if item.enabled == true {
-                    mi.target = self
-                    mi.action = #selector(onItemClick(_:))
-                } else {
-                    mi.isEnabled = false
-                }
-
-                if item.checked == true { mi.state = .on }
-                if item.hidden == true { mi.isHidden = true }
-
-                menu.addItem(mi)
-            }
-            flatItems.append((item, seq))
-            seq += 1
-        }
-
-        statusItem.menu = menu
-    }
-
-    // MARK: Click handler
-
-    @objc func onItemClick(_ sender: NSMenuItem) {
-        let seq = sender.tag
-        guard seq < flatItems.count else { return }
-        let (item, _) = flatItems[seq]
-        if let jsonData = try? JSONEncoder().encode(ClickEvent(type: "clicked", item: item, seq_id: seq)),
-           let jsonStr = String(data: jsonData, encoding: .utf8) {
-            writeLine(jsonStr)
-        }
-    }
-
-    // MARK: stdout
-
-    func writeLine(_ s: String) {
-        let out = s + "\n"
-        FileHandle.standardOutput.write(out.data(using: .utf8)!)
-    }
-}
-
-// MARK: - Main
-
-let app = NSApplication.shared
-app.setActivationPolicy(.accessory)
-let controller = TrayController()
-app.delegate = controller
-app.run()
+/**
+ * Skillo Tray Helper for macOS
+ *
+ * Native Swift menu bar icon. Communicates with Node via stdin/stdout JSON lines.
+ *
+ * Protocol (compatible with systray2):
+ *   stdin  <- JSON menu config (first line) + {"type":"update-menu","menu":{...}} for updates
+ *   stdout -> {"type":"ready"} on launch, {"type":"clicked","item":{...},"seq_id":N} on click
+ */
+
+import Cocoa
+
+// MARK: - JSON models
+
+struct TrayMenuItem: Codable {
+    let title: String
+    let tooltip: String
+    var enabled: Bool?
+    var checked: Bool?
+    var hidden: Bool?
+    var items: [TrayMenuItem]?
+}
+
+struct MenuConfig: Codable {
+    let icon: String
+    let title: String
+    let tooltip: String
+    let items: [TrayMenuItem]
+}
+
+struct UpdateAction: Codable {
+    let type: String
+    let menu: MenuConfig?
+}
+
+struct ClickEvent: Codable {
+    let type: String
+    let item: TrayMenuItem
+    let seq_id: Int
+}
+
+// MARK: - Tray controller
+
+class TrayController: NSObject, NSApplicationDelegate {
+    var statusItem: NSStatusItem!
+    var flatItems: [(TrayMenuItem, Int)] = []
+
+    func applicationDidFinishLaunching(_ notification: Notification) {
+        statusItem = NSStatusBar.system.statusItem(withLength: NSStatusItem.variableLength)
+        statusItem.button?.title = "S"
+
+        // Emit ready
+        writeLine("{\"type\": \"ready\"}")
+
+        // Start reading stdin on background thread
+        startStdinReader()
+    }
+
+    // MARK: stdin reader
+
+    func startStdinReader() {
+        DispatchQueue.global(qos: .userInitiated).async { [weak self] in
+            let handle = FileHandle.standardInput
+            var buf = ""
+
+            while true {
+                guard let data = try? handle.availableData, !data.isEmpty else {
+                    // stdin closed — parent exited
+                    DispatchQueue.main.async { NSApp.terminate(nil) }
+                    return
+                }
+                guard let chunk = String(data: data, encoding: .utf8) else { continue }
+                buf += chunk
+
+                while let newline = buf.firstIndex(of: "\n") {
+                    let line = String(buf[buf.startIndex..<newline]).trimmingCharacters(in: .whitespacesAndNewlines)
+                    buf = String(buf[buf.index(after: newline)...])
+                    if !line.isEmpty {
+                        DispatchQueue.main.async { self?.handleLine(line) }
+                    }
+                }
+            }
+        }
+    }
+
+    func handleLine(_ line: String) {
+        guard let data = line.data(using: .utf8) else { return }
+
+        // Try update action
+        if let action = try? JSONDecoder().decode(UpdateAction.self, from: data),
+           action.type == "update-menu",
+           let menu = action.menu {
+            applyMenu(menu)
+            return
+        }
+
+        // Try initial menu config
+        if let menu = try? JSONDecoder().decode(MenuConfig.self, from: data) {
+            applyMenu(menu)
+        }
+    }
+
+    // MARK: Menu rendering
+
+    func applyMenu(_ config: MenuConfig) {
+        flatItems = []
+
+        // Icon
+        if let btn = statusItem.button {
+            if !config.icon.isEmpty, let imgData = Data(base64Encoded: config.icon) {
+                let img = NSImage(data: imgData)
+                img?.size = NSSize(width: 18, height: 18)
+                img?.isTemplate = true
+                btn.image = img
+                btn.title = ""
+            } else if !config.title.isEmpty {
+                btn.image = nil
+                btn.title = config.title
+            }
+            btn.toolTip = config.tooltip
+        }
+
+        // Menu items
+        let menu = NSMenu()
+        var seq = 0
+
+        for item in config.items {
+            if item.title == "<SEPARATOR>" {
+                menu.addItem(NSMenuItem.separator())
+            } else {
+                let mi = NSMenuItem(title: item.title, action: nil, keyEquivalent: "")
+                mi.toolTip = item.tooltip
+                mi.tag = seq
+
+                if item.enabled == true {
+                    mi.target = self
+                    mi.action = #selector(onItemClick(_:))
+                } else {
+                    mi.isEnabled = false
+                }
+
+                if item.checked == true { mi.state = .on }
+                if item.hidden == true { mi.isHidden = true }
+
+                menu.addItem(mi)
+            }
+            flatItems.append((item, seq))
+            seq += 1
+        }
+
+        statusItem.menu = menu
+    }
+
+    // MARK: Click handler
+
+    @objc func onItemClick(_ sender: NSMenuItem) {
+        let seq = sender.tag
+        guard seq < flatItems.count else { return }
+        let (item, _) = flatItems[seq]
+        if let jsonData = try? JSONEncoder().encode(ClickEvent(type: "clicked", item: item, seq_id: seq)),
+           let jsonStr = String(data: jsonData, encoding: .utf8) {
+            writeLine(jsonStr)
+        }
+    }
+
+    // MARK: stdout
+
+    func writeLine(_ s: String) {
+        let out = s + "\n"
+        FileHandle.standardOutput.write(out.data(using: .utf8)!)
+    }
+}
+
+// MARK: - Main
+
+let app = NSApplication.shared
+app.setActivationPolicy(.accessory)
+let controller = TrayController()
+app.delegate = controller
+app.run()

package/scripts/tray-helper-linux.py

@@ -0,0 +1,322 @@
+#!/usr/bin/env python3
+"""
+Skillo Tray Helper for Linux
+
+Native GTK system tray icon using AppIndicator or StatusIcon fallback.
+Communicates with Node.js via stdin/stdout JSON lines.
+
+Protocol:
+  stdout -> {"type":"ready"} on launch
+  stdin  <- JSON menu config (first line) + {"type":"update-menu","menu":{...}} for updates
+  stdout -> {"type":"clicked","item":{...},"seq_id":N} on click
+  stdin EOF -> clean exit
+
+Requires: python3-gi (PyGObject), optionally gir1.2-ayatanaappindicator3-0.1
+"""
+
+import json
+import sys
+import os
+import base64
+import tempfile
+import shutil
+import signal
+import atexit
+
+try:
+    import gi
+except ImportError:
+    sys.stderr.write(
+        "Error: PyGObject (python3-gi) is required.\n"
+        "Install with:\n"
+        "  Ubuntu/Debian: sudo apt install python3-gi gir1.2-ayatanaappindicator3-0.1\n"
+        "  Fedora: sudo dnf install python3-gobject libayatana-appindicator-gtk3\n"
+        "  Arch: sudo pacman -S python-gobject libayatana-appindicator\n"
+    )
+    sys.exit(1)
+
+try:
+    gi.require_version("Gtk", "3.0")
+    from gi.repository import Gtk, GLib, GdkPixbuf, Gio
+except (ValueError, ImportError):
+    sys.stderr.write(
+        "Error: GTK 3.0 is required but not found.\n"
+        "Install with:\n"
+        "  Ubuntu/Debian: sudo apt install python3-gi gir1.2-gtk-3.0\n"
+        "  Fedora: sudo dnf install python3-gobject gtk3\n"
+        "  Arch: sudo pacman -S python-gobject gtk3\n"
+    )
+    sys.exit(1)
+
+# Try AppIndicator (preferred on modern Linux desktops)
+AppIndicator = None
+try:
+    gi.require_version("AyatanaAppIndicator3", "0.1")
+    from gi.repository import AyatanaAppIndicator3 as AppIndicator
+except (ValueError, ImportError):
+    try:
+        gi.require_version("AppIndicator3", "0.1")
+        from gi.repository import AppIndicator3 as AppIndicator
+    except (ValueError, ImportError):
+        AppIndicator = None
+
+
+class TrayHelper:
+    def __init__(self):
+        self.indicator = None
+        self.status_icon = None
+        self.menu = None
+        self.flat_items = []
+        self.stdin_buf = ""
+        self.icon_dir = os.path.join(os.path.expanduser("~"), ".skillo")
+        os.makedirs(self.icon_dir, exist_ok=True)
+        # Use a private temp directory for icon files to avoid symlink TOCTOU attacks
+        self.icon_tmp_dir = tempfile.mkdtemp(prefix="skillo-tray-", dir=self.icon_dir)
+        # AppIndicator requires a freedesktop icon theme directory structure
+        self.icon_theme_dir = os.path.join(self.icon_tmp_dir, "hicolor", "22x22", "apps")
+        os.makedirs(self.icon_theme_dir, exist_ok=True)
+        self.icon_name = "skillo-tray"  # icon name without extension
+        self.icon_path = os.path.join(self.icon_theme_dir, self.icon_name + ".png")
+        # StatusIcon fallback uses raw path
+        self.icon_raw_path = os.path.join(self.icon_tmp_dir, "icon.png")
+        atexit.register(lambda: shutil.rmtree(self.icon_tmp_dir, ignore_errors=True))
+        self.initialized = False
+        self.headless = False  # True when no tray backend is available (Wayland)
+
+    def start(self):
+        # Handle SIGTERM/SIGINT gracefully
+        signal.signal(signal.SIGTERM, lambda *_: Gtk.main_quit())
+        signal.signal(signal.SIGINT, lambda *_: Gtk.main_quit())
+
+        self.setup_indicator()
+
+        # Watch stdin via GLib IO watch (no threads needed)
+        # Include ERR — some kernels fire ERR instead of HUP on broken pipe
+        GLib.io_add_watch(
+            sys.stdin,
+            GLib.PRIORITY_DEFAULT,
+            GLib.IOCondition.IN | GLib.IOCondition.HUP | GLib.IOCondition.ERR,
+            self.on_stdin,
+        )
+
+        # Emit ready on first main loop iteration (after io_add_watch is active)
+        GLib.idle_add(self._emit_ready)
+
+        Gtk.main()
+
+    def _emit_ready(self):
+        self.write_line('{"type":"ready"}')
+        return False  # don't repeat
+
+    def setup_indicator(self):
+        if AppIndicator is not None:
+            try:
+                self.indicator = AppIndicator.Indicator.new(
+                    "skillo-tray",
+                    "application-default-icon",
+                    AppIndicator.IndicatorCategory.APPLICATION_STATUS,
+                )
+                self.indicator.set_status(AppIndicator.IndicatorStatus.ACTIVE)
+                self.indicator.set_title("Skillo")
+                # Set a default empty menu (required by AppIndicator)
+                menu = Gtk.Menu()
+                placeholder = Gtk.MenuItem(label="Loading...")
+                placeholder.set_sensitive(False)
+                menu.append(placeholder)
+                menu.show_all()
+                self.indicator.set_menu(menu)
+                return
+            except Exception:
+                self.indicator = None
+
+        # Fallback to StatusIcon (deprecated but still works on X11)
+        try:
+            self.status_icon = Gtk.StatusIcon()
+            self.status_icon.set_from_icon_name("application-default-icon")
+            self.status_icon.set_tooltip_text("Skillo")
+            self.status_icon.set_visible(True)
+            self.status_icon.connect("popup-menu", self.on_popup)
+        except Exception:
+            # No tray backend available (e.g. Wayland without AppIndicator extension)
+            # Run headless — still respond to stdin so Node.js doesn't hang
+            sys.stderr.write(
+                "Warning: System tray not available in this environment.\n"
+                "On GNOME/Wayland, install: gnome-shell-extension-appindicator\n"
+                "  Ubuntu/Debian: sudo apt install gnome-shell-extension-appindicator gir1.2-ayatanaappindicator3-0.1\n"
+                "  Fedora: sudo dnf install gnome-shell-extension-appindicator libayatana-appindicator-gtk3\n"
+                "  Arch: sudo pacman -S libayatana-appindicator\n"
+                "Skillo will run without a tray icon.\n"
+            )
+            self.headless = True
+
+    def on_popup(self, icon, button, time):
+        """StatusIcon fallback popup handler."""
+        if self.menu:
+            self.menu.popup(None, None, Gtk.StatusIcon.position_menu, icon, button, time)
+
+    def on_stdin(self, source, condition):
+        if condition & (GLib.IOCondition.HUP | GLib.IOCondition.ERR):
+            Gtk.main_quit()
+            return False
+
+        try:
+            data = source.readline()
+        except Exception:
+            Gtk.main_quit()
+            return False
+
+        if not data:
+            Gtk.main_quit()
+            return False
+
+        self.stdin_buf += data
+        while "\n" in self.stdin_buf:
+            line, self.stdin_buf = self.stdin_buf.split("\n", 1)
+            line = line.strip()
+            if line:
+                self.process_line(line)
+
+        return True  # keep watching
+
+    def process_line(self, line):
+        try:
+            data = json.loads(line)
+        except json.JSONDecodeError:
+            return
+
+        if not isinstance(data, dict):
+            return
+
+        # Check if it's an update-menu action
+        if data.get("type") == "update-menu" and "menu" in data:
+            self.apply_menu(data["menu"])
+            return
+
+        # Otherwise treat as initial menu config
+        if "items" in data:
+            self.apply_menu(data)
+
+    def apply_menu(self, config):
+        if not isinstance(config, dict):
+            return
+        if self.headless:
+            return
+
+        # Update icon (atomic write to avoid race conditions)
+        try:
+            icon_b64 = config.get("icon", "")
+            if icon_b64:
+                icon_bytes = base64.b64decode(icon_b64)
+                fd, tmp_path = tempfile.mkstemp(dir=self.icon_tmp_dir, suffix=".png")
+                try:
+                    with os.fdopen(fd, "wb") as f:
+                        f.write(icon_bytes)
+                    os.replace(tmp_path, self.icon_path)  # atomic rename
+                except Exception:
+                    try:
+                        os.unlink(tmp_path)
+                    except OSError:
+                        pass
+                    raise
+
+                if self.indicator:
+                    # AppIndicator expects icon name (not path) + theme directory
+                    self.indicator.set_icon_theme_path(self.icon_tmp_dir)
+                    self.indicator.set_icon_full(self.icon_name, "Skillo")
+                elif self.status_icon:
+                    # Also write raw icon for StatusIcon pixbuf loading
+                    fd2, tmp2 = tempfile.mkstemp(dir=self.icon_tmp_dir, suffix=".png")
+                    try:
+                        with os.fdopen(fd2, "wb") as f2:
+                            f2.write(icon_bytes)
+                        os.replace(tmp2, self.icon_raw_path)
+                    except Exception:
+                        try:
+                            os.unlink(tmp2)
+                        except OSError:
+                            pass
+                    loader = GdkPixbuf.PixbufLoader()
+                    try:
+                        loader.write(icon_bytes)
+                        loader.close()
+                        pixbuf = loader.get_pixbuf()
+                    except Exception:
+                        try:
+                            loader.close()
+                        except Exception:
+                            pass
+                        pixbuf = None
+                    if pixbuf:
+                        pixbuf = pixbuf.scale_simple(22, 22, GdkPixbuf.InterpType.BILINEAR)
+                        self.status_icon.set_from_pixbuf(pixbuf)
+        except Exception:
+            pass
+
+        # Update tooltip
+        try:
+            tooltip = config.get("tooltip", "")
+            if tooltip:
+                if self.indicator:
+                    self.indicator.set_title(tooltip)
+                elif self.status_icon:
+                    self.status_icon.set_tooltip_text(tooltip)
+        except Exception:
+            pass
+
+        # Build menu
+        menu = Gtk.Menu()
+        self.flat_items = []
+        seq = 0
+
+        for item in config.get("items", []):
+            if not isinstance(item, dict):
+                seq += 1
+                continue
+
+            title = item.get("title", "")
+
+            if title == "<SEPARATOR>":
+                menu.append(Gtk.SeparatorMenuItem())
+            else:
+                hidden = item.get("hidden", False)
+                if hidden:
+                    seq += 1
+                    continue
+
+                mi = Gtk.MenuItem(label=title)
+                enabled = item.get("enabled", True)
+
+                if not enabled:
+                    mi.set_sensitive(False)
+                else:
+                    captured_seq = seq
+                    captured_item = item
+                    mi.connect("activate", self.on_click, captured_seq, captured_item)
+
+                self.flat_items.append((item, seq))
+                menu.append(mi)
+
+            seq += 1
+
+        menu.show_all()
+
+        if self.indicator:
+            self.indicator.set_menu(menu)
+        elif self.status_icon:
+            self.menu = menu
+
+    def on_click(self, widget, seq_id, item):
+        event = {"type": "clicked", "item": item, "seq_id": seq_id}
+        self.write_line(json.dumps(event))
+
+    def write_line(self, s):
+        try:
+            sys.stdout.write(s + "\n")
+            sys.stdout.flush()
+        except Exception:
+            pass
+
+
+if __name__ == "__main__":
+    helper = TrayHelper()
+    helper.start()