Merge windows-support: Windows installers, CI job, platform fixes

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: sparkly-quasar

.github/workflows/release.yml

@@ -1,10 +1,12 @@
 # SPDX-License-Identifier: LicenseRef-PolyForm-Noncommercial-1.0.0
 # Build installable binaries and attach them to a GitHub Release on every v* tag.
 #
-# macOS  → universal .dmg (Apple Silicon + Intel). Signs + notarizes automatically
-#          IF the APPLE_* secrets are set; otherwise the .dmg is unsigned
-#          (users right-click → Open the first time).
-# Linux  → .AppImage / .deb / .rpm.
+# macOS   → universal .dmg (Apple Silicon + Intel). Signs + notarizes automatically
+#           IF the APPLE_* secrets are set; otherwise the .dmg is unsigned
+#           (users right-click → Open the first time).
+# Linux   → .AppImage / .deb / .rpm.
+# Windows → .exe (NSIS) / .msi (WiX). Unsigned, so SmartScreen shows
+#           "More info → Run anyway" on first launch.
 name: Release
 
 on:
@@ -26,6 +28,9 @@ jobs:
           - platform: ubuntu-22.04
             args: ""
             rust-targets: ""
+          - platform: windows-latest
+            args: ""
+            rust-targets: ""
     runs-on: ${{ matrix.platform }}
     steps:
       - uses: actions/checkout@v4
@@ -41,6 +46,12 @@ jobs:
             libayatana-appindicator3-dev \
             librsvg2-dev patchelf
 
+      - name: Install NASM (Windows)
+        # The vendored OpenSSL that backs SQLCipher assembles with NASM on MSVC.
+        # Strawberry Perl is already on the runner; NASM is not.
+        if: matrix.platform == 'windows-latest'
+        uses: ilammy/setup-nasm@v1
+
       - name: Set up Node
         uses: actions/setup-node@v4
         with:
@@ -95,6 +106,9 @@ jobs:
             4. Scroll to the **Security** section — you'll see a message that the app was blocked.
             5. Click **Open Anyway**, enter your Mac's login password, and click **OK**.
 
+            **Windows:** download the `-setup.exe` installer. It isn't code-signed yet, so
+            SmartScreen may warn on first launch — click **More info → Run anyway**.
+
             **Linux:** use the .AppImage (portable), or the .deb / .rpm for your distro.
 
             The Companion and text-import features run a model locally — the app guides

.github/workflows/windows-build.yml

@@ -0,0 +1,59 @@
+# SPDX-License-Identifier: LicenseRef-PolyForm-Noncommercial-1.0.0
+# Build the Windows installers (NSIS .exe + WiX .msi) WITHOUT releasing anything.
+# Run manually from the Actions tab to prove the Windows build before tagging a
+# release. Artifacts are attached to the run for download/smoke-testing.
+name: Windows build (no release)
+
+on:
+  workflow_dispatch:
+
+jobs:
+  build:
+    runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install NASM
+        # The vendored OpenSSL that backs SQLCipher assembles with NASM on MSVC.
+        # Strawberry Perl is already on the runner; NASM is not.
+        uses: ilammy/setup-nasm@v1
+
+      - name: Set up Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+
+      - name: Set up Rust
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Cache Rust build
+        uses: swatinem/rust-cache@v2
+        with:
+          workspaces: ./src-tauri -> target
+
+      - name: Install frontend dependencies
+        run: npm ci
+
+      # No `cargo test` here: Windows test binaries die at launch with
+      # STATUS_ENTRYPOINT_NOT_FOUND because tauri-build links the app manifest
+      # only to the main binary (tauri-apps/tauri#13419). The shipped app is
+      # unaffected; the suite runs on macOS/Linux where the logic is identical.
+
+      - name: Build installers
+        # No tagName/releaseId → tauri-action builds but does not touch releases.
+        uses: tauri-apps/tauri-action@v0
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          # createUpdaterArtifacts is on in tauri.conf.json, so `tauri build`
+          # refuses to run without the updater signing key even here.
+          TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY }}
+          TAURI_SIGNING_PRIVATE_KEY_PASSWORD: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY_PASSWORD }}
+
+      - name: Upload installers
+        uses: actions/upload-artifact@v4
+        with:
+          name: field-notes-windows
+          path: |
+            src-tauri/target/release/bundle/nsis/*.exe
+            src-tauri/target/release/bundle/msi/*.msi
+          if-no-files-found: error

README.md

@@ -83,7 +83,7 @@ anywhere.
 
 ## Architecture
 
-- **Tauri 2 + Svelte (TypeScript)** desktop app (macOS + Linux).
+- **Tauri 2 + Svelte (TypeScript)** desktop app (macOS + Linux + Windows).
 - **Local SQLite** (`rusqlite`, bundled) at the app data dir — `substances`,
   `experiences`, `doses`, `timeline_events`. No network, no accounts.
 - The safety-critical layers are **deterministic Rust, independent of any model** —
@@ -110,12 +110,16 @@ Download an installer for your platform from the
   so on first launch **right-click → Open** (or `xattr -dr com.apple.quarantine
   "/Applications/Field Notes.app"`).
 - **Linux** — the `.AppImage` (make it executable and run), or the `.deb` / `.rpm`.
+- **Windows** — run the `-setup.exe` installer (or the `.msi`). Not code-signed yet,
+  so SmartScreen may warn on first launch — click **More info → Run anyway**.
 
 **To update:** grab the latest release and install it over the old version
-(replace the app in Applications, or the AppImage; reinstall the `.deb`/`.rpm`).
-**Your journal is safe** — all data lives in the OS app-data directory
+(replace the app in Applications, or the AppImage; reinstall the `.deb`/`.rpm`;
+re-run the Windows installer). **Your journal is safe** — all data lives in the
+OS app-data directory
 (`~/Library/Application Support/com.fieldnotes.journal` on macOS,
-`~/.local/share/com.fieldnotes.journal` on Linux), separate from the app bundle,
+`~/.local/share/com.fieldnotes.journal` on Linux,
+`%APPDATA%\com.fieldnotes.journal` on Windows), separate from the app bundle,
 so updating never touches it. **From v0.2.0 on, the app checks for updates on
 launch** and offers to install them in place ("Install & restart") — signed and
 verified, fully in-app. (v0.1.0 predates the updater, so update to v0.2.0 manually

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "field-notes",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "description": "Offline harm-reduction journal & trip-sitting workstation.",
   "type": "module",
   "private": true,

package.json

@@ -1,6 +1,6 @@
 [package]
 name = "field_notes"
-version = "0.4.1"
+version = "0.5.0"
 description = "Offline harm-reduction journal & trip-sitting workstation"
 authors = ["sparkly-quasar"]
 # Licensed under the PolyForm Noncommercial License 1.0.0 — see ../LICENSE.

src-tauri/Cargo.lock

@@ -884,7 +884,11 @@ pub fn reveal_data_dir(db: State<'_, Db>) -> Result<(), String> {
     {
         std::process::Command::new("xdg-open").arg(dir).spawn().map_err(err)?;
     }
-    #[cfg(not(any(target_os = "macos", target_os = "linux")))]
+    #[cfg(target_os = "windows")]
+    {
+        std::process::Command::new("explorer").arg(dir).spawn().map_err(err)?;
+    }
+    #[cfg(not(any(target_os = "macos", target_os = "linux", target_os = "windows")))]
     {
         let _ = dir;
         return Err("Opening the data folder isn't supported on this platform.".to_string());
@@ -980,21 +984,30 @@ pub struct TailscaleStatus {
 
 /// Where Tailscale's CLI actually lives. The Mac App Store build hides it inside
 /// the .app, which is why `which tailscale` finds nothing on plenty of machines.
+/// The Windows installer puts it in Program Files without touching PATH either.
 fn tailscale_bin() -> Option<String> {
+    #[cfg(not(windows))]
     const PATHS: &[&str] = &[
         "/usr/local/bin/tailscale",
         "/opt/homebrew/bin/tailscale",
         "/usr/bin/tailscale",
         "/Applications/Tailscale.app/Contents/MacOS/Tailscale",
     ];
+    #[cfg(windows)]
+    const PATHS: &[&str] = &[
+        r"C:\Program Files\Tailscale\tailscale.exe",
+        r"C:\Program Files (x86)\Tailscale IPN\tailscale.exe",
+    ];
     PATHS.iter().find(|p| Path::new(p).exists()).map(|p| p.to_string())
 }
 
 /// Run a `tailscale` subcommand, returning its stderr as the error. Tailscale's own
 /// messages are the useful ones here ("HTTPS must be enabled in the admin console",
 /// "not logged in"), and a generic "failed to publish" would throw them away.
 fn tailscale_run(bin: &str, args: &[&str]) -> Result<String, String> {
-    let out = std::process::Command::new(bin)
+    let mut cmd = std::process::Command::new(bin);
+    crate::ollama::hide_console(&mut cmd);
+    let out = cmd
         .args(args)
         .output()
         .map_err(|e| format!("Couldn't run Tailscale: {e}"))?;
@@ -1017,11 +1030,9 @@ pub fn portal_tailscale(portal: State<'_, Portal>) -> TailscaleStatus {
         };
     };
 
-    let host = std::process::Command::new(&bin)
-        .args(["status", "--json"])
-        .output()
+    let host = tailscale_run(&bin, &["status", "--json"])
         .ok()
-        .and_then(|o| serde_json::from_slice::<serde_json::Value>(&o.stdout).ok())
+        .and_then(|s| serde_json::from_str::<serde_json::Value>(&s).ok())
         .and_then(|v| {
             let dns = v["Self"]["DNSName"].as_str()?.trim_end_matches('.').to_string();
             (!dns.is_empty()).then_some(dns)
@@ -1052,7 +1063,7 @@ pub fn portal_tailscale(portal: State<'_, Portal>) -> TailscaleStatus {
 /// refuses if the portal isn't actually running, rather than serving a dead port.
 #[tauri::command]
 pub fn portal_serve(portal: State<'_, Portal>) -> Result<TailscaleStatus, String> {
-    let bin = tailscale_bin().ok_or("Tailscale isn't installed on this Mac.")?;
+    let bin = tailscale_bin().ok_or("Tailscale isn't installed on this computer.")?;
     let port = portal.status().port.ok_or("Turn on phone access first.")?;
     tailscale_run(&bin, &["serve", "--bg", &port.to_string()])?;
     Ok(portal_tailscale(portal))
@@ -1062,7 +1073,7 @@ pub fn portal_serve(portal: State<'_, Portal>) -> Result<TailscaleStatus, String
 /// the tailnet's route to it.
 #[tauri::command]
 pub fn portal_unserve(portal: State<'_, Portal>) -> Result<TailscaleStatus, String> {
-    let bin = tailscale_bin().ok_or("Tailscale isn't installed on this Mac.")?;
+    let bin = tailscale_bin().ok_or("Tailscale isn't installed on this computer.")?;
     tailscale_run(&bin, &["serve", "--https=443", "off"])?;
     Ok(portal_tailscale(portal))
 }

src-tauri/Cargo.toml

@@ -17,6 +17,8 @@ const BASE: &str = "http://127.0.0.1:11434";
 /// install locations. A macOS app launched from Finder/Dock inherits only a
 /// minimal PATH (`/usr/bin:/bin:/usr/sbin:/sbin`) — *not* `/opt/homebrew/bin` —
 /// so without this, `brew` and `ollama` look "missing" even when installed.
+/// On Windows the equivalent gap is a PATH captured before Ollama's installer
+/// appended to the *user* PATH, so its default install dir is added explicitly.
 fn search_dirs() -> Vec<PathBuf> {
     let mut dirs: Vec<PathBuf> = std::env::var_os("PATH")
         .map(|p| std::env::split_paths(&p).collect())
@@ -26,30 +28,57 @@ fn search_dirs() -> Vec<PathBuf> {
             dirs.push(d);
         }
     };
-    for d in [
-        "/opt/homebrew/bin", // Apple Silicon Homebrew
-        "/opt/homebrew/sbin",
-        "/usr/local/bin", // Intel Homebrew + Ollama.app CLI symlink
-        "/usr/local/sbin",
-    ] {
-        push(&mut dirs, PathBuf::from(d));
+    #[cfg(unix)]
+    {
+        for d in [
+            "/opt/homebrew/bin", // Apple Silicon Homebrew
+            "/opt/homebrew/sbin",
+            "/usr/local/bin", // Intel Homebrew + Ollama.app CLI symlink
+            "/usr/local/sbin",
+        ] {
+            push(&mut dirs, PathBuf::from(d));
+        }
+        if let Some(home) = std::env::var_os("HOME") {
+            for sub in [".local/bin", ".ollama/bin"] {
+                push(&mut dirs, PathBuf::from(&home).join(sub));
+            }
+        }
     }
-    if let Some(home) = std::env::var_os("HOME") {
-        for sub in [".local/bin", ".ollama/bin"] {
-            push(&mut dirs, PathBuf::from(&home).join(sub));
+    #[cfg(windows)]
+    {
+        if let Some(local) = std::env::var_os("LOCALAPPDATA") {
+            // OllamaSetup.exe's per-user default.
+            push(&mut dirs, PathBuf::from(&local).join("Programs").join("Ollama"));
+        }
+        if let Some(pf) = std::env::var_os("ProgramFiles") {
+            push(&mut dirs, PathBuf::from(&pf).join("Ollama"));
         }
     }
     dirs
 }
 
 /// Absolute path of an executable found across [`search_dirs`], if any.
 fn find_bin(name: &str) -> Option<PathBuf> {
+    let file = format!("{name}{}", std::env::consts::EXE_SUFFIX);
     search_dirs()
         .into_iter()
-        .map(|d| d.join(name))
+        .map(|d| d.join(&file))
         .find(|p| p.is_file())
 }
 
+/// Keep a spawned console tool from flashing a terminal window on Windows
+/// (CREATE_NO_WINDOW). The app itself is `windows_subsystem = "windows"`, so
+/// every `Command` would otherwise pop one open. No-op elsewhere.
+pub fn hide_console(cmd: &mut Command) {
+    #[cfg(windows)]
+    {
+        use std::os::windows::process::CommandExt;
+        cmd.creation_flags(0x0800_0000);
+    }
+    #[cfg(not(windows))]
+    let _ = cmd;
+}
+
 /// A `Command` for a CLI tool, resolved to its absolute path and with an
 /// augmented PATH exported so any subprocess it spawns resolves too. Falls back
 /// to the bare name (letting the OS search) when the binary isn't found.
@@ -60,6 +89,7 @@ fn command(name: &str) -> Command {
         None => Command::new(name),
     };
     cmd.env("PATH", path);
+    hide_console(&mut cmd);
     cmd
 }
 
@@ -129,7 +159,8 @@ fn run_streamed(app: &AppHandle, event: &str, mut cmd: Command) -> Result<(), St
     }
 }
 
-/// Install Ollama (macOS: Homebrew; Linux: official script), streaming progress.
+/// Install Ollama (macOS: Homebrew; Linux: official script; Windows: WinGet),
+/// streaming progress.
 pub fn install(app: &AppHandle) -> Result<(), String> {
     let _ = app.emit("ai-progress", "Installing Ollama…".to_string());
 
@@ -149,7 +180,21 @@ pub fn install(app: &AppHandle) -> Result<(), String> {
         cmd.args(["-c", "curl -fsSL https://ollama.com/install.sh | sh"]);
         run_streamed(app, "ai-progress", cmd)?;
     }
-    #[cfg(not(any(target_os = "macos", target_os = "linux")))]
+    #[cfg(target_os = "windows")]
+    {
+        let has_winget = command("winget").arg("--version").stdout(Stdio::null()).stderr(Stdio::null()).status().map(|s| s.success()).unwrap_or(false);
+        if !has_winget {
+            return Err("WinGet isn't available. Install Ollama from https://ollama.com/download, then reopen this.".into());
+        }
+        let mut cmd = command("winget");
+        cmd.args([
+            "install", "--exact", "--id", "Ollama.Ollama",
+            "--silent", "--accept-source-agreements", "--accept-package-agreements",
+            "--disable-interactivity",
+        ]);
+        run_streamed(app, "ai-progress", cmd)?;
+    }
+    #[cfg(not(any(target_os = "macos", target_os = "linux", target_os = "windows")))]
     {
         return Err("Automatic install isn't supported on this platform. Install Ollama from https://ollama.com/download.".into());
     }

src-tauri/src/commands.rs

@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "Field Notes",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "identifier": "com.fieldnotes.journal",
   "build": {
     "beforeDevCommand": "npm run dev",