Auto-update toggle, Windows CLI support, agent guide improvements, bump v0.1.44

aemiguel · aemiguel · commit 07b94d027ad0 · 2026-04-09T19:55:52.000+01:00
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
@@ -21,6 +21,8 @@ jobs:
             os: macos-latest
           - target: aarch64-apple-darwin
             os: macos-latest
+          - target: x86_64-pc-windows-msvc
+            os: windows-latest
 
     runs-on: ${{ matrix.os }}
 
@@ -56,9 +58,12 @@ jobs:
         run: cargo build --release --target ${{ matrix.target }}
 
       - name: Package binaries
+        shell: bash
         run: |
+          ext=""
+          if [[ "${{ matrix.target }}" == *windows* ]]; then ext=".exe"; fi
           for bin in lore lore-server; do
-            src="target/${{ matrix.target }}/release/${bin}"
+            src="target/${{ matrix.target }}/release/${bin}${ext}"
             tar -czf "${bin}-${{ matrix.target }}.tar.gz" -C "$(dirname "$src")" "$(basename "$src")"
             if command -v sha256sum >/dev/null 2>&1; then
               sha256sum "${bin}-${{ matrix.target }}.tar.gz" > "${bin}-${{ matrix.target }}.tar.gz.sha256"
diff --git a/Cargo.toml b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "lore-core"
-version = "0.1.43"
+version = "0.1.44"
 edition = "2024"
 autobins = false
 
@@ -27,7 +27,6 @@ quick-xml = "0.37"
 regex = "1"
 rand_core = { version = "0.6", features = ["getrandom"] }
 reqwest = { version = "0.12", default-features = false, features = ["json", "rustls-tls"] }
-libc = "0.2"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 sha2 = "0.10"
@@ -39,6 +38,9 @@ urlencoding = "2.1"
 uuid = { version = "1.18", features = ["serde", "v4"] }
 v_htmlescape = "0.15"
 
+[target.'cfg(unix)'.dependencies]
+libc = "0.2"
+
 [dev-dependencies]
 tempfile = "3.20"
 tower = { version = "0.5", features = ["util"] }
diff --git a/scripts/install-cli.ps1 b/scripts/install-cli.ps1
@@ -0,0 +1,114 @@
+# Lore CLI installer for Windows
+$ErrorActionPreference = "Stop"
+
+$Repo = if ($env:LORE_GITHUB_REPO) { $env:LORE_GITHUB_REPO } else { "brontoguana/lore" }
+$Version = if ($env:LORE_VERSION) { $env:LORE_VERSION } else { "latest" }
+$InstallDir = if ($env:LORE_INSTALL_DIR) { $env:LORE_INSTALL_DIR } else { "$env:LOCALAPPDATA\lore\bin" }
+$BinaryName = "lore"
+
+function Resolve-LatestVersion {
+    $release = Invoke-RestMethod -Uri "https://api.github.com/repos/$Repo/releases/latest" -Headers @{ "User-Agent" = "lore-installer" }
+    return $release.tag_name
+}
+
+function Get-CurrentVersion {
+    $exe = Join-Path $InstallDir "$BinaryName.exe"
+    if (Test-Path $exe) {
+        try {
+            $out = & $exe --version 2>&1
+            return ($out -replace "^$BinaryName ", "").Trim()
+        } catch {
+            return "unknown"
+        }
+    }
+    return "not installed"
+}
+
+# Resolve version
+if ($Version -eq "latest") {
+    $RemoteVersion = Resolve-LatestVersion
+} else {
+    $RemoteVersion = $Version
+}
+
+$CurrentVersion = Get-CurrentVersion
+
+# Check if update is needed
+if ($CurrentVersion -ne "not installed") {
+    $remoteCmp = $RemoteVersion -replace "^v", ""
+    $currentCmp = $CurrentVersion -replace "^v", ""
+    if ($remoteCmp -eq $currentCmp) {
+        Write-Host "$BinaryName is already at version $CurrentVersion - nothing to do."
+        exit 0
+    }
+    Write-Host "Updating $BinaryName`: $CurrentVersion -> $RemoteVersion"
+} else {
+    Write-Host "Installing $BinaryName $RemoteVersion"
+}
+
+$Target = "x86_64-pc-windows-msvc"
+$BaseUrl = "https://github.com/$Repo/releases/download/$RemoteVersion"
+$ArchiveName = "$BinaryName-$Target.tar.gz"
+$TmpDir = Join-Path ([System.IO.Path]::GetTempPath()) "lore-install-$([System.Guid]::NewGuid().ToString('N').Substring(0,8))"
+
+try {
+    New-Item -ItemType Directory -Path $TmpDir -Force | Out-Null
+
+    $ArchivePath = Join-Path $TmpDir $ArchiveName
+    $ChecksumPath = "$ArchivePath.sha256"
+
+    Write-Host "Downloading $ArchiveName..."
+    Invoke-WebRequest -Uri "$BaseUrl/$ArchiveName" -OutFile $ArchivePath -UseBasicParsing
+    Invoke-WebRequest -Uri "$BaseUrl/$ArchiveName.sha256" -OutFile $ChecksumPath -UseBasicParsing
+
+    # Verify checksum
+    $expected = (Get-Content $ChecksumPath).Split(" ")[0]
+    $actual = (Get-FileHash -Path $ArchivePath -Algorithm SHA256).Hash.ToLower()
+    if ($expected -ne $actual) {
+        Write-Error "Checksum mismatch for $ArchiveName"
+        exit 1
+    }
+
+    # Extract (tar is available on Windows 10+)
+    tar -xzf $ArchivePath -C $TmpDir
+
+    # Install
+    New-Item -ItemType Directory -Path $InstallDir -Force | Out-Null
+    $src = Join-Path $TmpDir "$BinaryName.exe"
+    $dst = Join-Path $InstallDir "$BinaryName.exe"
+    Copy-Item -Path $src -Destination $dst -Force
+
+    if ($CurrentVersion -ne "not installed") {
+        Write-Host "Updated $BinaryName to $RemoteVersion (was $CurrentVersion)"
+    } else {
+        Write-Host ""
+        Write-Host " _      ____  _____  ______ "
+        Write-Host "| |    / __ \|  __ \|  ____|"
+        Write-Host "| |   | |  | | |__) | |__   "
+        Write-Host "| |   | |  | |  _  /|  __|  "
+        Write-Host "| |___| |__| | | \ \| |____ "
+        Write-Host "|______\____/|_|  \_\______|"
+        Write-Host ""
+        Write-Host "Installed $BinaryName $RemoteVersion to $dst"
+        Write-Host ""
+
+        # Check if InstallDir is on PATH
+        $userPath = [Environment]::GetEnvironmentVariable("Path", "User")
+        if ($userPath -notlike "*$InstallDir*") {
+            Write-Host "Adding $InstallDir to your PATH..."
+            [Environment]::SetEnvironmentVariable("Path", "$userPath;$InstallDir", "User")
+            $env:Path = "$env:Path;$InstallDir"
+            Write-Host "Done. Restart your terminal for PATH changes to take effect."
+        }
+
+        Write-Host ""
+        Write-Host "Quick start:"
+        Write-Host "  lore setup https://your-server.com"
+        Write-Host "  lore projects                # list projects"
+        Write-Host "  lore agent my-agent           # start an agent"
+        Write-Host ""
+        Write-Host "Run lore --help for all commands."
+    }
+} finally {
+    Remove-Item -Path $TmpDir -Recurse -Force -ErrorAction SilentlyContinue
+}
diff --git a/src/api.rs b/src/api.rs
@@ -364,6 +364,10 @@ fn build_app_with_librarian(
         )
         .route("/ui/admin/oidc", post(update_oidc_from_ui))
         .route("/ui/admin/auto-update", post(update_auto_update_from_ui))
+        .route(
+            "/ui/admin/auto-update/toggle-json",
+            post(toggle_auto_update_json),
+        )
         .route(
             "/ui/admin/auto-update/check",
             post(check_auto_update_from_ui),
@@ -3397,6 +3401,22 @@ async fn update_oidc_from_ui(
     Ok(Redirect::to("/ui/admin?flash=OIDC%20saved"))
 }
 
+async fn toggle_auto_update_json(
+    State(state): State<AppState>,
+    headers: HeaderMap,
+    Form(form): Form<std::collections::HashMap<String, String>>,
+) -> ApiResult<axum::Json<serde_json::Value>> {
+    let session = require_ui_admin(&state, &headers)?;
+    let csrf = form.get("csrf_token").map(|s| s.as_str()).unwrap_or("");
+    verify_csrf(&session, csrf)?;
+    let enabled = form.get("enabled").map(|s| s == "true").unwrap_or(false);
+    let current = state.auto_update_config.load()?;
+    state
+        .auto_update_config
+        .update(enabled, current.github_repo)?;
+    Ok(axum::Json(serde_json::json!({ "ok": true })))
+}
+
 async fn update_auto_update_from_ui(
     State(state): State<AppState>,
     headers: HeaderMap,
diff --git a/src/bin/lore.rs b/src/bin/lore.rs
@@ -1408,6 +1408,7 @@ fn encode_query(value: &str) -> String {
 
 // --- Helpers ---
 
+#[cfg(unix)]
 fn read_password_hidden(prompt: &str) -> io::Result<String> {
     use std::io::BufRead;
     eprint!("{}", prompt);
@@ -1428,6 +1429,62 @@ fn read_password_hidden(prompt: &str) -> io::Result<String> {
     Ok(password.trim().to_string())
 }
 
+#[cfg(windows)]
+fn read_password_hidden(prompt: &str) -> io::Result<String> {
+    use std::io::BufRead;
+    eprint!("{}", prompt);
+    extern "system" {
+        fn GetStdHandle(nStdHandle: u32) -> isize;
+        fn GetConsoleMode(hConsoleHandle: isize, lpMode: *mut u32) -> i32;
+        fn SetConsoleMode(hConsoleHandle: isize, dwMode: u32) -> i32;
+    }
+    const STD_INPUT_HANDLE: u32 = 0xFFFF_FFF6; // -10 as u32
+    const ENABLE_ECHO_INPUT: u32 = 0x0004;
+    unsafe {
+        let handle = GetStdHandle(STD_INPUT_HANDLE);
+        let mut mode: u32 = 0;
+        GetConsoleMode(handle, &mut mode);
+        SetConsoleMode(handle, mode & !ENABLE_ECHO_INPUT);
+        let mut password = String::new();
+        io::stdin().lock().read_line(&mut password)?;
+        SetConsoleMode(handle, mode);
+        eprintln!();
+        Ok(password.trim().to_string())
+    }
+}
+
+#[cfg(unix)]
+fn is_process_running(pid: u32) -> bool {
+    std::process::Command::new("kill")
+        .args(["-0", &pid.to_string()])
+        .status()
+        .map(|s| s.success())
+        .unwrap_or(false)
+}
+
+#[cfg(unix)]
+fn kill_process(pid: u32) {
+    let _ = std::process::Command::new("kill")
+        .arg(pid.to_string())
+        .status();
+}
+
+#[cfg(windows)]
+fn is_process_running(pid: u32) -> bool {
+    std::process::Command::new("tasklist")
+        .args(["/FI", &format!("PID eq {}", pid), "/NH"])
+        .output()
+        .map(|o| String::from_utf8_lossy(&o.stdout).contains(&pid.to_string()))
+        .unwrap_or(false)
+}
+
+#[cfg(windows)]
+fn kill_process(pid: u32) {
+    let _ = std::process::Command::new("taskkill")
+        .args(["/PID", &pid.to_string(), "/F"])
+        .status();
+}
+
 fn get_hostname() -> String {
     std::process::Command::new("hostname")
         .output()
@@ -1494,14 +1551,10 @@ async fn agent_command(context: &CliContext, args: AgentArgs) -> CliResult<()> {
         if pid_path.exists() {
             if let Ok(pid_str) = fs::read_to_string(&pid_path) {
                 if let Ok(pid) = pid_str.trim().parse::<u32>() {
-                    let check = std::process::Command::new("kill")
-                        .args(["-0", &pid.to_string()])
-                        .status();
-                    if check.map(|s| s.success()).unwrap_or(false) {
+                    let is_running = is_process_running(pid);
+                    if is_running {
                         eprintln!("Stopping existing agent '{}' (pid {})", args.name, pid);
-                        let _ = std::process::Command::new("kill")
-                            .arg(pid.to_string())
-                            .status();
+                        kill_process(pid);
                         tokio::time::sleep(std::time::Duration::from_millis(500)).await;
                     }
                 }
diff --git a/src/main.rs b/src/main.rs
@@ -7,6 +7,7 @@ use std::env;
 use std::fs;
 use std::io::{self, BufRead, Write};
 use std::net::SocketAddr;
+#[cfg(unix)]
 use std::os::unix::io::AsRawFd;
 use std::path::PathBuf;
 
@@ -254,6 +255,7 @@ fn prompt_initial_admin_if_needed(data_root: &str) {
     }
 }
 
+#[cfg(unix)]
 fn read_password_no_echo() -> String {
     let stdin_fd = io::stdin().as_raw_fd();
     let mut termios = std::mem::MaybeUninit::<libc::termios>::uninit();
@@ -284,6 +286,30 @@ fn read_password_no_echo() -> String {
         .to_string()
 }
 
+#[cfg(windows)]
+fn read_password_no_echo() -> String {
+    extern "system" {
+        fn GetStdHandle(nStdHandle: u32) -> isize;
+        fn GetConsoleMode(hConsoleHandle: isize, lpMode: *mut u32) -> i32;
+        fn SetConsoleMode(hConsoleHandle: isize, dwMode: u32) -> i32;
+    }
+    const STD_INPUT_HANDLE: u32 = 0xFFFF_FFF6;
+    const ENABLE_ECHO_INPUT: u32 = 0x0004;
+    unsafe {
+        let handle = GetStdHandle(STD_INPUT_HANDLE);
+        let mut mode: u32 = 0;
+        GetConsoleMode(handle, &mut mode);
+        SetConsoleMode(handle, mode & !ENABLE_ECHO_INPUT);
+        let mut line = String::new();
+        let _ = io::stdin().read_line(&mut line);
+        SetConsoleMode(handle, mode);
+        eprintln!();
+        line.trim_end_matches('\n')
+            .trim_end_matches('\r')
+            .to_string()
+    }
+}
+
 async fn run_server(data_root: String, bind: String) {
     let data_root_path = PathBuf::from(&data_root);
 
diff --git a/src/ui.rs b/src/ui.rs
