khal-os 1.260324.2

package/tauri/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "genie-os"
+version = "0.1.0"
+edition = "2021"
+
+[build-dependencies]
+tauri-build = { version = "2", features = [] }
+
+[dependencies]
+tauri = { version = "2", features = ["macos-private-api", "tray-icon"] }
+tauri-plugin-shell = "2"
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+reqwest = { version = "0.12", features = ["rustls-tls"], default-features = false }
+dirs = "6"
+
+[target."cfg(target_os = \"macos\")".dependencies]
+cocoa = "0.26"
+objc = "0.2"

package/tauri/build.rs

@@ -0,0 +1,3 @@
+fn main() {
+    tauri_build::build()
+}

package/tauri/capabilities/default.json

@@ -0,0 +1,36 @@
+{
+	"identifier": "default",
+	"description": "Default capabilities for Genie OS",
+	"windows": ["*"],
+	"permissions": [
+		"core:default",
+		"core:event:default",
+		"core:event:allow-listen",
+		"core:event:allow-emit",
+		"core:event:allow-emit-to",
+		"core:webview:default",
+		"core:webview:allow-create-webview-window",
+		"core:webview:allow-internal-toggle-devtools",
+		"core:window:default",
+		"core:window:allow-show",
+		"core:window:allow-hide",
+		"core:window:allow-close",
+		"core:window:allow-center",
+		"core:window:allow-minimize",
+		"core:window:allow-maximize",
+		"core:window:allow-unmaximize",
+		"core:window:allow-is-maximized",
+		"core:window:allow-set-focus",
+		"core:window:allow-is-visible",
+		"core:window:allow-set-background-color",
+		"core:window:allow-start-dragging",
+		"core:window:allow-set-decorations",
+		"core:window:allow-set-size",
+		"core:window:allow-set-position",
+		"core:window:allow-create",
+		"core:tray:default",
+		"core:menu:default",
+		"shell:default",
+		"shell:allow-open"
+	]
+}

package/tauri/src/main.rs

@@ -0,0 +1,396 @@
+// Genie OS — Native wrapper for the web-based desktop shell.
+//
+// The Tauri app is a thin client that:
+// 1. Starts the backend services (PM2 or genie-os CLI)
+// 2. Opens a webview pointing to the Next.js app at localhost:8888
+// 3. Exposes Tauri IPC so the frontend can open native windows
+//
+// The same frontend works in both modes:
+// - Browser: window management via Zustand store (div-windows)
+// - Tauri:   window management via native OS windows (this app)
+//
+// The frontend detects Tauri via `'__TAURI__' in window` and switches behavior.
+
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
+
+use std::sync::Mutex;
+use tauri::Emitter;
+use tauri::Manager;
+use tauri::WebviewWindowBuilder;
+use tauri::WebviewUrl;
+use tauri::ipc::CapabilityBuilder;
+use tauri::menu::{MenuBuilder, MenuItemBuilder};
+use tauri::tray::TrayIconBuilder;
+
+const GENIE_OS_URL: &str = "http://localhost:8888";
+const DESKTOP_URL: &str = "http://localhost:8888/desktop";
+
+// Track whether we started the services ourselves
+struct AppState {
+    services_started_by_us: bool,
+}
+
+// ── Commands ─────────────────────────────────────────────────────────────────
+
+/// Open a native app window pointing to a URL path on the Genie OS server.
+/// Called from frontend when running in Tauri mode.
+#[tauri::command]
+fn open_app_window(app: tauri::AppHandle, app_id: String, title: Option<String>, url: Option<String>) {
+    let label = format!("app-{}", app_id);
+
+    // If already open, focus it
+    if let Some(window) = app.get_webview_window(&label) {
+        let _ = window.show();
+        let _ = window.set_focus();
+        return;
+    }
+
+    // Each app gets its own standalone page — no desktop shell overhead
+    let target_url = url.unwrap_or_else(|| format!("{}/standalone/{}", GENIE_OS_URL, app_id));
+    let win_title = title.unwrap_or_else(|| app_id.clone());
+
+    let app_clone = app.clone();
+    let label_clone = label.clone();
+
+    if let Ok(w) = WebviewWindowBuilder::new(
+        &app,
+        &label,
+        WebviewUrl::External(target_url.parse().unwrap()),
+    )
+    .title(&win_title)
+    .inner_size(900.0, 600.0)
+    .resizable(true)
+    .decorations(false)
+    .transparent(true)
+    .shadow(false)
+    .visible(false) // Start HIDDEN — show after page loads to prevent flash
+    .initialization_script(r#"
+        // Ensure html/body are transparent for the standalone window
+        document.documentElement.style.background = 'transparent';
+        document.addEventListener('DOMContentLoaded', function() {
+            document.documentElement.style.background = 'transparent';
+            if (document.body) document.body.style.background = 'transparent';
+            // Signal Tauri to show the window now that content is ready
+            if (window.__TAURI__) {
+                window.__TAURI__.core.invoke('show_app_window', { appId: document.body.dataset.appId || '' });
+            }
+        });
+        // Fallback: show after 2s even if signal doesn't fire
+        setTimeout(function() {
+            if (window.__TAURI__) {
+                window.__TAURI__.core.invoke('show_app_window', { appId: '' });
+            }
+        }, 2000);
+    "#)
+    .build() {
+        center_on_cursor_monitor(&w);
+
+        // Fallback: show window after 3s in case initialization_script doesn't fire
+        let label_for_timer = label_clone.clone();
+        std::thread::spawn(move || {
+            std::thread::sleep(std::time::Duration::from_secs(3));
+            if let Some(win) = app_clone.get_webview_window(&label_for_timer) {
+                let _ = win.show();
+            }
+        });
+    }
+}
+
+/// List all open app windows
+#[tauri::command]
+fn list_app_windows(app: tauri::AppHandle) -> Vec<serde_json::Value> {
+    app.webview_windows()
+        .iter()
+        .filter(|(label, _)| label.starts_with("app-"))
+        .map(|(label, _win)| {
+            let app_id = label.strip_prefix("app-").unwrap_or(label);
+            serde_json::json!({ "appId": app_id, "label": label })
+        })
+        .collect()
+}
+
+/// Show an app window (called from initialization_script when page is ready)
+#[tauri::command]
+fn show_app_window(app: tauri::AppHandle, app_id: String) {
+    // Show ALL hidden app windows (the appId from the script may be empty)
+    for (label, window) in app.webview_windows() {
+        if label.starts_with("app-") && !window.is_visible().unwrap_or(true) {
+            let _ = window.show();
+            let _ = window.set_focus();
+        }
+    }
+    // Also try the specific one
+    if !app_id.is_empty() {
+        let label = format!("app-{}", app_id);
+        if let Some(window) = app.get_webview_window(&label) {
+            let _ = window.show();
+            let _ = window.set_focus();
+        }
+    }
+}
+
+/// Focus an app window by appId
+#[tauri::command]
+fn focus_app_window(app: tauri::AppHandle, app_id: String) {
+    let label = format!("app-{}", app_id);
+    if let Some(window) = app.get_webview_window(&label) {
+        let _ = window.show();
+        let _ = window.set_focus();
+    }
+}
+
+/// Close an app window by appId
+#[tauri::command]
+fn close_app_window(app: tauri::AppHandle, app_id: String) {
+    let label = format!("app-{}", app_id);
+    if let Some(window) = app.get_webview_window(&label) {
+        let _ = window.close();
+    }
+}
+
+/// Check if services are healthy
+#[tauri::command]
+async fn check_services() -> Result<bool, String> {
+    // Quick HTTP check on the Next.js server
+    let resp = reqwest::get(GENIE_OS_URL).await;
+    Ok(resp.is_ok())
+}
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+fn center_on_cursor_monitor(window: &tauri::WebviewWindow) {
+    if let Ok(cursor) = window.cursor_position() {
+        if let Ok(Some(monitor)) = window.monitor_from_point(cursor.x, cursor.y) {
+            let mon_pos = monitor.position();
+            let mon_size = monitor.size();
+            if let Ok(win_size) = window.outer_size() {
+                let x = mon_pos.x as f64 + (mon_size.width as f64 - win_size.width as f64) / 2.0;
+                let y = mon_pos.y as f64 + (mon_size.height as f64 - win_size.height as f64) / 2.0;
+                let _ = window.set_position(tauri::Position::Physical(tauri::PhysicalPosition {
+                    x: x as i32,
+                    y: y as i32,
+                }));
+            }
+        } else {
+            let _ = window.center();
+        }
+    } else {
+        let _ = window.center();
+    }
+}
+
+fn start_services() -> bool {
+    // The Tauri app lives in src-tauri/ inside the genie-os-web repo.
+    // ecosystem.config.cjs is in the parent directory (repo root).
+    let genie_os_web = std::env::current_exe()
+        .ok()
+        .and_then(|p| p.parent().map(|p| p.to_path_buf())) // src-tauri/target/debug/
+        .map(|p| p.join("../../../..")) // up to repo root
+        .map(|p| std::fs::canonicalize(p).unwrap_or_default())
+        .unwrap_or_else(|| {
+            // Fallback: try known path
+            dirs::home_dir()
+                .map(|h| h.join("Dev/namastex/genie-os-web"))
+                .unwrap_or_default()
+        });
+
+    if !genie_os_web.join("ecosystem.config.cjs").exists() {
+        eprintln!("[genie-os] ecosystem.config.cjs not found at {:?}", genie_os_web);
+        return false;
+    }
+
+    eprintln!("[genie-os] starting services via PM2...");
+    let status = std::process::Command::new("pm2")
+        .args(["start", "ecosystem.config.cjs"])
+        .current_dir(&genie_os_web)
+        .stdout(std::process::Stdio::null())
+        .stderr(std::process::Stdio::null())
+        .status();
+
+    match status {
+        Ok(s) if s.success() => {
+            eprintln!("[genie-os] PM2 services started");
+            true
+        }
+        _ => {
+            eprintln!("[genie-os] failed to start PM2 services");
+            false
+        }
+    }
+}
+
+fn stop_services() {
+    // Stop only genie-os services, not everything in PM2
+    for name in &["os-nats", "os-services", "os-dev", "os-ws-bridge"] {
+        let _ = std::process::Command::new("pm2")
+            .args(["stop", name])
+            .stdout(std::process::Stdio::null())
+            .stderr(std::process::Stdio::null())
+            .status();
+    }
+    eprintln!("[genie-os] PM2 services stopped");
+}
+
+fn wait_for_server(max_secs: u32) -> bool {
+    for i in 0..max_secs * 2 {
+        if i > 0 {
+            std::thread::sleep(std::time::Duration::from_millis(500));
+        }
+        // Quick TCP check on port 8888
+        if std::net::TcpStream::connect("127.0.0.1:8888").is_ok() {
+            return true;
+        }
+    }
+    false
+}
+
+// ── Main ─────────────────────────────────────────────────────────────────────
+
+fn main() {
+    tauri::Builder::default()
+        .manage(Mutex::new(AppState { services_started_by_us: false }))
+        .plugin(tauri_plugin_shell::init())
+        .invoke_handler(tauri::generate_handler![
+            open_app_window,
+            show_app_window,
+            list_app_windows,
+            focus_app_window,
+            close_app_window,
+            check_services,
+        ])
+        .setup(|app| {
+            // ── Enable IPC for external localhost pages ──────────────────
+            // This allows pages loaded from http://localhost:8888 to access
+            // window.__TAURI__ (invoke, window controls, events, etc.)
+            app.add_capability(
+                CapabilityBuilder::new("localhost-ipc")
+                    .remote("http://localhost:8888".to_string())
+                    .permission("core:default")
+                    .permission("core:window:default")
+                    .permission("core:window:allow-close")
+                    .permission("core:window:allow-minimize")
+                    .permission("core:window:allow-maximize")
+                    .permission("core:window:allow-unmaximize")
+                    .permission("core:window:allow-is-maximized")
+                    .permission("core:window:allow-start-dragging")
+                    .permission("core:window:allow-set-focus")
+                    .permission("core:window:allow-show")
+                    .permission("core:window:allow-hide")
+                    .permission("core:event:default")
+                    .window("*")
+            )?;
+
+            // ── Start services if not already running ────────────────────
+            let server_up = std::net::TcpStream::connect("127.0.0.1:8888").is_ok();
+
+            if !server_up {
+                let started = start_services();
+                if started {
+                    app.state::<Mutex<AppState>>().lock().unwrap().services_started_by_us = true;
+                    // Wait for Next.js to be ready
+                    eprintln!("[genie-os] waiting for server on :8888...");
+                    if !wait_for_server(30) {
+                        eprintln!("[genie-os] server did not start in time — opening anyway");
+                    }
+                }
+            } else {
+                eprintln!("[genie-os] server already running on :8888");
+            }
+
+            // ── Main window: load the web desktop ────────────────────────
+            let main_win = WebviewWindowBuilder::new(
+                app,
+                "main",
+                WebviewUrl::External(DESKTOP_URL.parse().unwrap()),
+            )
+            .title("Genie OS")
+            .inner_size(1280.0, 800.0)
+            .resizable(true)
+            .decorations(false)
+            .transparent(true)
+            .shadow(false)
+            .visible(true)
+            .build()?;
+
+            center_on_cursor_monitor(&main_win);
+
+            // ── Tray icon ────────────────────────────────────────────────
+            let toggle_dock_item = MenuItemBuilder::with_id("toggle_main", "Show/Hide")
+                .build(app)?;
+            let new_terminal = MenuItemBuilder::with_id("new_terminal", "New Terminal")
+                .build(app)?;
+            let settings = MenuItemBuilder::with_id("settings", "Settings")
+                .build(app)?;
+            let quit_item = MenuItemBuilder::with_id("quit", "Quit Genie OS")
+                .build(app)?;
+
+            let tray_menu = MenuBuilder::new(app)
+                .item(&toggle_dock_item)
+                .separator()
+                .item(&new_terminal)
+                .item(&settings)
+                .separator()
+                .item(&quit_item)
+                .build()?;
+
+            let _tray = TrayIconBuilder::new()
+                .icon(app.default_window_icon().cloned().unwrap())
+                .icon_as_template(true)
+                .menu(&tray_menu)
+                .tooltip("Genie OS")
+                .on_menu_event(move |app_handle, event| {
+                    match event.id().as_ref() {
+                        "toggle_main" => {
+                            if let Some(win) = app_handle.get_webview_window("main") {
+                                if win.is_visible().unwrap_or(false) {
+                                    let _ = win.hide();
+                                } else {
+                                    let _ = win.show();
+                                    let _ = win.set_focus();
+                                }
+                            }
+                        }
+                        "new_terminal" => {
+                            open_app_window(
+                                app_handle.clone(),
+                                "terminal".to_string(),
+                                Some("Terminal".to_string()),
+                                None,
+                            );
+                        }
+                        "settings" => {
+                            open_app_window(
+                                app_handle.clone(),
+                                "settings".to_string(),
+                                Some("Settings".to_string()),
+                                None,
+                            );
+                        }
+                        "quit" => {
+                            // Stop services if we started them
+                            if let Some(state) = app_handle.try_state::<Mutex<AppState>>() {
+                                if state.lock().unwrap().services_started_by_us {
+                                    stop_services();
+                                }
+                            }
+                            app_handle.exit(0);
+                        }
+                        _ => {}
+                    }
+                })
+                .build(app)?;
+
+            Ok(())
+        })
+        .build(tauri::generate_context!())
+        .expect("error building genie-os")
+        .run(|app, event| {
+            if let tauri::RunEvent::ExitRequested { .. } = event {
+                if let Some(state) = app.try_state::<Mutex<AppState>>() {
+                    if state.lock().unwrap().services_started_by_us {
+                        stop_services();
+                    }
+                }
+            }
+        });
+}

package/tauri/tauri.conf.json

@@ -0,0 +1,23 @@
+{
+	"productName": "Genie OS",
+	"version": "0.1.0",
+	"identifier": "ai.automagik.genie-os",
+	"build": {
+		"frontendDist": "../dist",
+		"beforeDevCommand": "",
+		"beforeBuildCommand": ""
+	},
+	"app": {
+		"macOSPrivateApi": true,
+		"withGlobalTauri": true,
+		"windows": [],
+		"security": {
+			"csp": "default-src 'self' http://localhost:8888 ws://localhost:* wss://localhost:* ipc: tauri:; style-src 'self' 'unsafe-inline' http://localhost:8888; script-src 'self' 'unsafe-inline' 'unsafe-eval' http://localhost:8888; img-src 'self' data: http://localhost:8888; connect-src 'self' http://localhost:* ws://localhost:* wss://localhost:* ipc: tauri:; font-src 'self' http://localhost:8888 data:"
+		}
+	},
+	"plugins": {
+		"shell": {
+			"open": true
+		}
+	}
+}

package/tsconfig.json

@@ -0,0 +1,43 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": [
+      "dom",
+      "dom.iterable",
+      "esnext"
+    ],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "react-jsx",
+    "incremental": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ],
+    "paths": {
+      "@/*": [
+        "./src/*"
+      ]
+    }
+  },
+  "include": [
+    "next-env.d.ts",
+    "**/*.ts",
+    "**/*.tsx",
+    "**/*.mts",
+    ".next/types/**/*.ts",
+    ".next/dev/types/**/*.ts"
+  ],
+  "exclude": [
+    "node_modules",
+    ".next"
+  ]
+}