@bobfrankston/mailx 1.0.1

package/launcher/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "mailx-app"
+version = "0.1.0"
+edition = "2021"
+description = "mailx email client — standalone WebView2 launcher"
+
+[dependencies]
+wry = "0.47"
+tao = "0.30"
+image = "0.24"
+
+[target.'cfg(windows)'.build-dependencies]
+winres = "0.1"

package/launcher/build.cmd

@@ -0,0 +1,4 @@
+@echo off
+call "C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Auxiliary\Build\vcvars64.bat" >nul 2>&1
+cd /d "%~dp0"
+cargo build %*

package/launcher/build.rs

@@ -0,0 +1,8 @@
+fn main() {
+    #[cfg(target_os = "windows")]
+    {
+        let mut res = winres::WindowsResource::new();
+        res.set_icon("mailx.ico");
+        res.compile().expect("Failed to compile Windows resources");
+    }
+}

package/launcher/release.cmd

@@ -0,0 +1,4 @@
+@echo off
+call "C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Auxiliary\Build\vcvars64.bat" >nul 2>&1
+cd /d "%~dp0"
+cargo build --release %*

package/launcher/src/main.rs

@@ -0,0 +1,371 @@
+/// mailx-app: Standalone WebView2 launcher for mailx email client.
+/// Starts the Node.js server process and opens a WebView2 window.
+///
+/// Usage: mailx-app [-dev] [-prod] [-restart]
+///   -dev     (default) Start server with --watch for auto-restart on file changes
+///   -prod    Start server without --watch
+///   -restart Kill existing server on port 9333 before starting
+
+use std::process::{Command, Child, Stdio};
+use std::time::Duration;
+use std::thread;
+use std::net::TcpStream;
+use std::path::PathBuf;
+use std::env;
+use std::fs;
+
+use tao::event::{Event, WindowEvent};
+use tao::event_loop::{ControlFlow, EventLoop};
+use tao::window::{WindowBuilder, Icon};
+use wry::WebViewBuilder;
+
+const PORT: u16 = 9333;
+const URL: &str = "http://localhost:9333";
+
+#[derive(Debug)]
+struct WindowState {
+    x: i32,
+    y: i32,
+    width: u32,
+    height: u32,
+}
+
+impl WindowState {
+    fn default() -> Self {
+        WindowState { x: 100, y: 100, width: 1280, height: 800 }
+    }
+
+    fn load() -> Self {
+        let path = Self::path();
+        if !path.exists() { return Self::default(); }
+        match fs::read_to_string(&path) {
+            Ok(s) => Self::parse(&s).unwrap_or_else(Self::default),
+            Err(_) => Self::default(),
+        }
+    }
+
+    fn save(&self) {
+        let path = Self::path();
+        if let Some(dir) = path.parent() {
+            let _ = fs::create_dir_all(dir);
+        }
+        let json = format!("{{\"x\":{},\"y\":{},\"width\":{},\"height\":{}}}", self.x, self.y, self.width, self.height);
+        let _ = fs::write(&path, json);
+    }
+
+    fn path() -> PathBuf {
+        let home = env::var("USERPROFILE").or_else(|_| env::var("HOME")).unwrap_or_else(|_| ".".to_string());
+        PathBuf::from(home).join(".mailx").join("window.json")
+    }
+
+    fn parse(s: &str) -> Option<Self> {
+        // Minimal JSON parser for {x, y, width, height}
+        let get = |key: &str| -> Option<i64> {
+            let pat = format!("\"{}\":", key);
+            let idx = s.find(&pat)? + pat.len();
+            let rest = s[idx..].trim_start();
+            let end = rest.find(|c: char| !c.is_ascii_digit() && c != '-')?;
+            rest[..end].parse().ok()
+        };
+        Some(WindowState {
+            x: get("x")? as i32,
+            y: get("y")? as i32,
+            width: get("width")? as u32,
+            height: get("height")? as u32,
+        })
+    }
+}
+
+/// Find the mailx project root (parent of launcher/)
+fn find_project_root() -> PathBuf {
+    let exe_dir = env::current_exe()
+        .expect("Cannot determine executable path")
+        .parent()
+        .expect("Cannot determine executable directory")
+        .to_path_buf();
+
+    let mut dir = exe_dir.clone();
+    for _ in 0..5 {
+        if dir.join("packages").join("mailx-server").join("index.js").exists() {
+            return dir;
+        }
+        if let Some(parent) = dir.parent() {
+            dir = parent.to_path_buf();
+        } else {
+            break;
+        }
+    }
+
+    let cwd = env::current_dir().unwrap_or(exe_dir);
+    if cwd.join("packages").join("mailx-server").join("index.js").exists() {
+        return cwd;
+    }
+
+    panic!("Cannot find mailx project root (looking for packages/mailx-server/index.js)");
+}
+
+/// Start the Node.js server process
+fn start_server(project_root: &PathBuf, dev_mode: bool) -> Child {
+    let server_script = project_root
+        .join("packages")
+        .join("mailx-server")
+        .join("index.js");
+
+    let mut cmd = Command::new("node");
+    if dev_mode {
+        cmd.arg("--watch");
+    }
+    cmd.arg(&server_script)
+        .current_dir(project_root)
+        .stdout(Stdio::inherit())
+        .stderr(Stdio::inherit())
+        .spawn()
+        .expect("Failed to start Node.js server. Is Node installed?")
+}
+
+/// Wait for the server to be ready (accepting TCP connections)
+fn wait_for_server(timeout_secs: u64) -> bool {
+    let addr = format!("127.0.0.1:{}", PORT);
+    let deadline = std::time::Instant::now() + Duration::from_secs(timeout_secs);
+
+    while std::time::Instant::now() < deadline {
+        if TcpStream::connect(&addr).is_ok() {
+            return true;
+        }
+        thread::sleep(Duration::from_millis(250));
+    }
+    false
+}
+
+fn server_is_running() -> bool {
+    TcpStream::connect(format!("127.0.0.1:{}", PORT)).is_ok()
+}
+
+/// Open a URL in the system default browser
+fn open_in_browser(url: &str) {
+    #[cfg(target_os = "windows")]
+    { let _ = Command::new("cmd").args(["/c", "start", "", url]).spawn(); }
+    #[cfg(target_os = "linux")]
+    { let _ = Command::new("xdg-open").arg(url).spawn(); }
+    #[cfg(target_os = "macos")]
+    { let _ = Command::new("open").arg(url).spawn(); }
+}
+
+/// Kill any process listening on the given port
+fn kill_port(port: u16) {
+    #[cfg(target_os = "windows")]
+    {
+        // Use killport if available, fallback to netstat+taskkill
+        let result = Command::new("killport").arg(port.to_string()).status();
+        if result.is_err() || !result.unwrap().success() {
+            // Fallback: find PID via netstat
+            if let Ok(output) = Command::new("cmd")
+                .args(["/c", &format!("netstat -ano | findstr :{}", port)])
+                .output()
+            {
+                let text = String::from_utf8_lossy(&output.stdout);
+                for line in text.lines() {
+                    if line.contains("LISTENING") {
+                        if let Some(pid) = line.split_whitespace().last() {
+                            let _ = Command::new("taskkill").args(["/F", "/PID", pid]).status();
+                        }
+                    }
+                }
+            }
+        }
+    }
+    #[cfg(not(target_os = "windows"))]
+    {
+        let _ = Command::new("fuser").args(["-k", &format!("{}/tcp", port)]).status();
+    }
+}
+
+fn lock_path() -> PathBuf {
+    let home = env::var("USERPROFILE").or_else(|_| env::var("HOME")).unwrap_or_else(|_| ".".to_string());
+    PathBuf::from(home).join(".mailx").join("mailx-app.lock")
+}
+
+fn is_app_running() -> bool {
+    let path = lock_path();
+    if !path.exists() { return false; }
+    // Check if the PID in the lock file is still alive
+    if let Ok(pid_str) = fs::read_to_string(&path) {
+        if let Ok(pid) = pid_str.trim().parse::<u32>() {
+            #[cfg(target_os = "windows")]
+            {
+                let status = Command::new("tasklist")
+                    .args(["/FI", &format!("PID eq {}", pid), "/NH"])
+                    .output();
+                if let Ok(output) = status {
+                    let text = String::from_utf8_lossy(&output.stdout);
+                    return text.contains(&pid.to_string());
+                }
+            }
+        }
+    }
+    false
+}
+
+fn write_lock() {
+    let path = lock_path();
+    if let Some(dir) = path.parent() {
+        let _ = fs::create_dir_all(dir);
+    }
+    let _ = fs::write(&path, std::process::id().to_string());
+}
+
+fn remove_lock() {
+    let _ = fs::remove_file(lock_path());
+}
+
+fn main() {
+    let args: Vec<String> = env::args().collect();
+    let dev_mode = !args.iter().any(|a| a == "-prod");
+    let restart = args.iter().any(|a| a == "-restart");
+
+    // Check if another mailx-app is already running
+    if !restart && is_app_running() {
+        println!("mailx-app is already running. Use -restart to force.");
+        // Focus existing window by opening in browser as fallback
+        if server_is_running() {
+            open_in_browser(URL);
+        }
+        std::process::exit(0);
+    }
+
+    let project_root = find_project_root();
+    println!("mailx project root: {}", project_root.display());
+    println!("Mode: {}", if dev_mode { "dev (--watch)" } else { "prod" });
+
+    // Kill existing server if -restart
+    if restart && server_is_running() {
+        println!("Killing existing server on port {}...", PORT);
+        kill_port(PORT);
+        remove_lock();
+        thread::sleep(Duration::from_secs(2));
+    }
+
+    // Write lock file
+    write_lock();
+
+    // Start the Node server if not already running
+    let server_process: Option<Child>;
+    if server_is_running() {
+        println!("Server already running on port {}", PORT);
+        server_process = None;
+    } else {
+        let proc = start_server(&project_root, dev_mode);
+        println!("Starting mailx server (port {})...", PORT);
+        server_process = Some(proc);
+
+        if !wait_for_server(30) {
+            eprintln!("Server failed to start within 30 seconds");
+            std::process::exit(1);
+        }
+        println!("Server ready");
+    }
+
+    // Restore window state
+    let saved = WindowState::load();
+    println!("Window: {}x{} at ({}, {})", saved.width, saved.height, saved.x, saved.y);
+
+    let event_loop = EventLoop::new();
+
+    // Load window icon
+    let icon_path = project_root.join("launcher").join("mailx.ico");
+    let window_icon = if icon_path.exists() {
+        match image::open(&icon_path) {
+            Ok(img) => {
+                let rgba = img.to_rgba8();
+                let (w, h) = rgba.dimensions();
+                Icon::from_rgba(rgba.into_raw(), w, h).ok()
+            }
+            Err(e) => { eprintln!("Icon load error: {}", e); None }
+        }
+    } else {
+        None
+    };
+
+    let mut builder = WindowBuilder::new()
+        .with_title("mailx")
+        .with_inner_size(tao::dpi::LogicalSize::new(saved.width as f64, saved.height as f64))
+        .with_position(tao::dpi::LogicalPosition::new(saved.x as f64, saved.y as f64))
+        .with_resizable(true);
+
+    if let Some(icon) = window_icon {
+        builder = builder.with_window_icon(Some(icon));
+    }
+
+    let window = builder
+        .build(&event_loop)
+        .expect("Failed to create window");
+
+    let _webview = WebViewBuilder::new()
+        .with_url(URL)
+        .with_devtools(dev_mode)
+        .with_initialization_script(r#"
+            window.mailxapi = {
+                isApp: true,
+                platform: 'webview2',
+                ensureServer: function() {
+                    // Server is managed by the launcher — always running when app is open
+                    return Promise.resolve(true);
+                },
+                openExternal: function(url) {
+                    // Navigation handler intercepts, but this is explicit
+                    window.open(url, '_blank');
+                }
+            };
+        "#)
+        .with_navigation_handler(|uri| {
+            // Allow localhost navigation (our app), block everything else → open in browser
+            if uri.starts_with("http://localhost") || uri.starts_with("https://localhost") || uri.starts_with("about:") {
+                true // allow
+            } else {
+                open_in_browser(&uri);
+                false // don't navigate in WebView
+            }
+        })
+        .with_new_window_req_handler(|uri| {
+            if uri.starts_with("http://localhost") || uri.starts_with("https://localhost") {
+                true // allow localhost popups (compose, etc.) in WebView
+            } else {
+                open_in_browser(&uri);
+                false // external links → system browser
+            }
+        })
+        .build(&window)
+        .expect("Failed to create WebView");
+
+    // Run the event loop
+    event_loop.run(move |event, _, control_flow| {
+        *control_flow = ControlFlow::Wait;
+
+        // Keep server_process alive so it doesn't get dropped
+        let _ = &server_process;
+
+        match event {
+            Event::WindowEvent {
+                event: WindowEvent::CloseRequested,
+                ..
+            } => {
+                // Save window position and size (convert to logical pixels for DPI independence)
+                let scale = window.scale_factor();
+                let pos = window.outer_position().unwrap_or(tao::dpi::PhysicalPosition::new(100, 100));
+                let size = window.inner_size();
+                let state = WindowState {
+                    x: (pos.x as f64 / scale) as i32,
+                    y: (pos.y as f64 / scale) as i32,
+                    width: (size.width as f64 / scale) as u32,
+                    height: (size.height as f64 / scale) as u32,
+                };
+                state.save();
+                remove_lock();
+                println!("Window saved: {}x{} at ({}, {})", state.width, state.height, state.x, state.y);
+                println!("Server still running on port {}", PORT);
+                *control_flow = ControlFlow::Exit;
+            }
+            _ => {}
+        }
+    });
+}

package/mailx.cmd

@@ -0,0 +1,2 @@
+msger mailx.json
+: npm start

package/mailx.json

@@ -0,0 +1,9 @@
+{
+  "url": "http://localhost:9333",
+  "pos": {
+    "x": 1200,
+    "y": 600,
+    "screen": 0
+  },
+  "detach": true
+}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@bobfrankston/mailx",
+  "version": "1.0.1",
+  "description": "Local-first email client with IMAP sync and standalone native app",
+  "type": "module",
+  "main": "bin/mailx.js",
+  "bin": {
+    "mailx": "bin/mailx.js"
+  },
+  "workspaces": [
+    "packages/*",
+    "client"
+  ],
+  "scripts": {
+    "build": "npm run build --workspaces --if-present",
+    "watch": "tsc -w",
+    "start": "node --watch packages/mailx-server/index.js",
+    "start:prod": "node packages/mailx-server/index.js",
+    "release": "npmglobalize"
+  },
+  "dependencies": {
+    "@bobfrankston/iflow": "^1.0.2",
+    "@bobfrankston/miscinfo": "^1.0.5",
+    "@bobfrankston/oauthsupport": "^1.0.10",
+    "mailparser": "^3.7.2",
+    "quill": "^2.0.3"
+  },
+  "devDependencies": {
+    "@types/mailparser": "^3.4.6"
+  },
+  "keywords": [
+    "email",
+    "imap",
+    "smtp",
+    "mail-client",
+    "webview"
+  ],
+  "author": "Bob Frankston",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/BobFrankston/mailx.git"
+  },
+  ".dependencies": {
+    "@bobfrankston/iflow": "file:../MailApps/iflow",
+    "@bobfrankston/miscinfo": "file:../../projects/npm/miscinfo",
+    "@bobfrankston/oauthsupport": "file:../../projects/oauth/oauthsupport",
+    "mailparser": "^3.7.2",
+    "quill": "^2.0.3"
+  }
+}

package/packages/mailx-api/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @bobfrankston/mailx-api
+ * Express Router with all REST endpoints for the mailx client.
+ */
+import { Router } from "express";
+import { MailxDB } from "@bobfrankston/mailx-store";
+import { ImapManager } from "@bobfrankston/mailx-imap";
+export declare function createApiRouter(db: MailxDB, imapManager: ImapManager): Router;
+//# sourceMappingURL=index.d.ts.map