issue 11: add startup pop up for os autostart

Author: Kanishk2207

docs/toml-config-reference.md

@@ -113,6 +113,12 @@ Videos    = ["mp4", "mkv", "mov", "avi", "webm", "flv", "wmv", "m4v"]
   After `filo init` writes config, automatically start watcher mode.
 - Runtime behavior:
   Used only by `filo init`.
+- Notes:
+  This is a one-time action for the current session, not startup behavior.
+  It does not survive a reboot. Starting filo on every login is a separate
+  choice, offered as its own prompt in `filo init` and available any time as
+  `filo autostart enable`. That setting lives in the OS service manager, not
+  in this file.
 
 #### `watch.debounce_ms`
 
@@ -294,6 +300,7 @@ These are the built-in defaults used when no custom rules are set:
 - `start` watcher is currently non-recursive.
 - Keyword rules match on filename keywords only. Matching a keyword *and* an extension in one rule is not expressible in TOML today; use `filo arrange -k <keyword> -e <ext> -d <path>` for that.
 - Path destinations are not watched implicitly. If you want files that land in a `to_type = "path"` destination to be organized further, add that path to `watch.folders` yourself.
+- OS autostart (start filo on login) has no TOML key. It is a launchd plist, systemd user unit, or Windows registry Run key, installed by `filo autostart enable` or by answering yes to the autostart prompt in `filo init`. Query it with `filo autostart status`. Do not confuse it with `watch.auto_start`.
 
 ## Extending this document for future TOML options
 

readme.md

@@ -155,6 +155,12 @@ filo init
    or `move` (relocate it to a `Duplicates` subfolder next to the category).
 4. **Start watching now?** If yes, `filo` jumps straight into `start` mode
    when setup ends.
+5. **Start filo on system startup/login?** Default: off. If yes, the wizard
+   installs the OS login service for you (launchd on macOS, systemd on Linux,
+   a registry Run key on Windows) and prints where it was installed, so you
+   never have to discover `filo autostart enable` on your own. If the service
+   manager refuses, setup still finishes and prints the exact command to
+   retry. Say no and nothing changes; you can enable it any time later.
 
 The wizard writes `config.toml` to the platform config directory
 (see [Config file](#config-file)). You can re-run `filo init` any time to
@@ -224,6 +230,11 @@ filo autostart disable
 filo autostart status
 ```
 
+`filo init` offers this as a prompt, so you usually never need to run
+`enable` by hand. These commands remain the way to change your mind later.
+On macOS and Linux, enabling also starts the watcher right away; on Windows
+it takes effect at your next login.
+
 ### Examples
 
 Preview what would happen if you cleaned up your Downloads folder right now:
@@ -299,6 +310,8 @@ folders = [
   "/home/you/Desktop",
 ]
 # If true, `filo init` launches `filo start` automatically after setup.
+# This is a one-off for that session, not startup behavior. To run filo on
+# every login, use `filo autostart enable` (or say yes when init asks).
 auto_start = false
 # How long (milliseconds) a file must sit idle before filo acts on it.
 # Protects against operating on files that are still downloading.

src/commands/autostart.rs

@@ -99,6 +99,16 @@ pub fn disable() -> Result<()> {
     Ok(())
 }
 
+/// Whether the login service is currently installed.
+///
+/// Lets callers (notably `filo init`) skip a redundant enable, which on
+/// macOS would fail outright because `launchctl load` rejects an
+/// already-loaded service.
+#[cfg(target_os = "macos")]
+pub fn is_enabled() -> bool {
+    plist_path().map(|p| p.exists()).unwrap_or(false)
+}
+
 #[cfg(target_os = "macos")]
 pub fn status() -> Result<()> {
     let path = plist_path()?;
@@ -192,6 +202,13 @@ pub fn disable() -> Result<()> {
     Ok(())
 }
 
+/// Whether the login service is currently installed. See the macOS
+/// implementation for why callers need this.
+#[cfg(target_os = "linux")]
+pub fn is_enabled() -> bool {
+    unit_path().map(|p| p.exists()).unwrap_or(false)
+}
+
 #[cfg(target_os = "linux")]
 pub fn status() -> Result<()> {
     let path = unit_path()?;
@@ -231,12 +248,24 @@ pub fn enable() -> Result<()> {
 
     if status.success() {
         println!("Autostart enabled. filo will start on login.");
+        println!("  registry: {}\\filo", REG_KEY);
     } else {
         anyhow::bail!("reg add failed (exit {})", status);
     }
     Ok(())
 }
 
+/// Whether the login service is currently installed. See the macOS
+/// implementation for why callers need this.
+#[cfg(target_os = "windows")]
+pub fn is_enabled() -> bool {
+    std::process::Command::new("reg")
+        .args(["query", REG_KEY, "/v", "filo"])
+        .output()
+        .map(|o| o.status.success())
+        .unwrap_or(false)
+}
+
 #[cfg(target_os = "windows")]
 pub fn disable() -> Result<()> {
     let status = std::process::Command::new("reg")

src/commands/init.rs

@@ -6,11 +6,12 @@
 
 use std::io::{self, Write};
 use std::path::PathBuf;
+use std::time::{Duration, Instant};
 
 use anyhow::{Context, Result};
 use dialoguer::{theme::ColorfulTheme, Confirm, MultiSelect, Select};
 
-use crate::commands::scan;
+use crate::commands::{autostart, scan};
 use crate::config::{Config, DuplicateAction};
 use crate::daemon;
 
@@ -69,12 +70,25 @@ pub fn run() -> Result<()> {
         .default(true)
         .interact()?;
 
+    // Asked alongside the other questions so the user decides everything up
+    // front, but acted on further down: installing the login service starts a
+    // watcher that reads the config, so the config has to be on disk first.
+    let want_autostart = Confirm::with_theme(&theme)
+        .with_prompt("Start filo automatically on system startup/login?")
+        .default(false)
+        .interact()?;
+
     let path = config.save().context("saving config")?;
     println!();
     println!("Config saved to: {}", path.display());
     println!("Run `filo preview` to see planned moves, `filo scan` to organize existing files,");
     println!("or `filo start` to begin watching.");
+    if !want_autostart {
+        println!("To start filo on every login later, run `filo autostart enable`.");
+    }
 
+    // The initial scan runs before anything starts watching, so a one-shot
+    // scan and a freshly launched watcher never race over the same files.
     if config.watch.auto_start {
         println!();
         let scan_first = Confirm::with_theme(&theme)
@@ -83,18 +97,101 @@ pub fn run() -> Result<()> {
             .interact()?;
         if scan_first {
             scan::run(&config, false).context("running initial scan before watcher start")?;
-            println!();
         }
-        daemon::spawn_daemon().context("starting daemon")?;
-        match daemon::running_pid() {
+    }
+
+    // launchd and systemd start the watcher the moment the service is
+    // installed, so find out whether that happened before deciding to start
+    // one here.
+    let mut watcher_pid = None;
+    if want_autostart {
+        println!();
+        if install_autostart() {
+            watcher_pid = wait_for_watcher(Duration::from_secs(2));
+            if let Some(pid) = watcher_pid {
+                println!("  It also started the watcher now (PID {}).", pid);
+            }
+        }
+    }
+
+    if config.watch.auto_start {
+        println!();
+        match watcher_pid {
             Some(pid) => println!(
-                "Watcher started in background (PID {}). Use `filo stop` to stop it.",
+                "Watcher is already running (PID {}). Use `filo stop` to stop it.",
                 pid
             ),
-            None => println!("Watcher started in background. Use `filo stop` to stop it."),
+            None => start_watcher()?,
+        }
+    }
+
+    Ok(())
+}
+
+/// Install the OS login service, reporting rather than propagating failure.
+/// Returns whether the service was installed by this call.
+///
+/// By this point the config is already written and setup has essentially
+/// succeeded, so a service manager that refuses to cooperate must not abort
+/// the wizard. The user gets the error and the exact command to retry.
+fn install_autostart() -> bool {
+    if autostart::is_enabled() {
+        println!("Autostart is already enabled; leaving it as it is.");
+        return false;
+    }
+    // `autostart::enable` prints its own success line, including where the
+    // service was installed.
+    match autostart::enable() {
+        Ok(()) => true,
+        Err(e) => {
+            println!("Could not enable autostart: {:#}", e);
+            println!("  Setup is otherwise complete. To retry, run: filo autostart enable");
+            false
+        }
+    }
+}
+
+/// Wait briefly for a just-installed login service to bring the watcher up.
+///
+/// The PID file only appears once the watcher process is running, so checking
+/// immediately after `launchctl load` or `systemctl enable --now` usually
+/// loses the race. Returns `None` on Windows, where the registry Run key
+/// takes effect at the next login rather than now.
+fn wait_for_watcher(timeout: Duration) -> Option<u32> {
+    let deadline = Instant::now() + timeout;
+    loop {
+        if let Some(pid) = daemon::running_pid() {
+            return Some(pid);
         }
+        if Instant::now() >= deadline {
+            return None;
+        }
+        std::thread::sleep(Duration::from_millis(100));
+    }
+}
+
+/// Start the background watcher, unless something already started one.
+///
+/// On macOS and Linux, installing the login service starts the watcher
+/// immediately, so spawning another here would be a second watcher on the
+/// same folders (and `spawn_daemon` would fail outright).
+fn start_watcher() -> Result<()> {
+    if let Some(pid) = daemon::running_pid() {
+        println!(
+            "Watcher is already running (PID {}). Use `filo stop` to stop it.",
+            pid
+        );
+        return Ok(());
     }
 
+    daemon::spawn_daemon().context("starting daemon")?;
+    match daemon::running_pid() {
+        Some(pid) => println!(
+            "Watcher started in background (PID {}). Use `filo stop` to stop it.",
+            pid
+        ),
+        None => println!("Watcher started in background. Use `filo stop` to stop it."),
+    }
     Ok(())
 }