add --wait switch

Author: tuncb

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "windbgmsg"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2024"
 
 [dependencies]

Cargo.toml

@@ -10,23 +10,31 @@ This is a Rust console application that reads a process name from the user via t
    ```
 2. Run the project with the process name as an argument (optional):
    ```pwsh
-   cargo run -- <process_name>
+   cargo run -- <process_name> [--wait]
    ```
    Replace `<process_name>` with the name of the executable you want to monitor (e.g., `notepad.exe`).
-   If you omit the argument, debug output from all processes will be captured:
-   ```pwsh
-   cargo run --
-   ```
+   - If you omit the argument, debug output from all processes will be captured:
+     ```pwsh
+     cargo run --
+     ```
+   - You can add the `--wait` switch to wait for the process to appear if it is not running yet:
+     ```pwsh
+     cargo run -- notepad.exe --wait
+     ```
+     The application will wait until the process starts, then attach and capture debug output.
+   - If you use `--wait` without specifying a process name, the application will print an error and exit.
 
 ## Features
 - Finds the process ID by name (case-insensitive)
+- Optionally waits for the process to appear using the `--wait` switch
 - Captures and prints debug output from the target process, or from all processes if no name is given
 - Returns Windows error codes on failure for easier troubleshooting
 
 ## Examples
 ```pwsh
-cargo run -- notepad.exe   # Capture output from notepad.exe only
-cargo run --               # Capture output from all processes
+cargo run -- notepad.exe         # Capture output from notepad.exe only
+cargo run -- notepad.exe --wait  # Wait for notepad.exe to start, then capture output
+cargo run --                    # Capture output from all processes
 ```
 
 If the process is not found or a Windows API call fails, an error message and the error code will be displayed.

README.md

@@ -8,17 +8,45 @@ use winproc::find_process_id_by_name;
 
 use crate::winproc::capture_debug_output;
 
-fn get_app_name_from_args() -> Option<String> {
+struct AppArgs {
+    app_name: Option<String>,
+    wait: bool,
+}
+
+fn get_args() -> AppArgs {
+    let mut app_name = None;
+    let mut wait = false;
     let mut args = env::args();
     args.next(); // skip program name
-    args.next()
+    for arg in args {
+        if arg == "--wait" {
+            wait = true;
+        } else if app_name.is_none() {
+            app_name = Some(arg);
+        }
+    }
+    AppArgs { app_name, wait }
 }
 
 fn main() {
-    match get_app_name_from_args() {
-        Some(app_name) => match find_process_id_by_name(&app_name) {
+    let args = get_args();
+    match (args.app_name, args.wait) {
+        (Some(app_name), true) => {
+            // Wait for process to appear
+            let pid = loop {
+                if let Some(pid) = find_process_id_by_name(&app_name) {
+                    break pid;
+                }
+                std::thread::sleep(std::time::Duration::from_secs(1));
+            };
+            println!("Process ID: {}", pid);
+            if let Err(e) = capture_debug_output(Some(pid)) {
+                eprintln!("Error capturing debug output: {}", e);
+                process::exit(1);
+            }
+        }
+        (Some(app_name), false) => match find_process_id_by_name(&app_name) {
             Some(pid) => {
-                // Print the process ID and capture debug output
                 println!("Process ID: {}", pid);
                 if let Err(e) = capture_debug_output(Some(pid)) {
                     eprintln!("Error capturing debug output: {}", e);
@@ -30,7 +58,11 @@ fn main() {
                 process::exit(1);
             }
         },
-        None => {
+        (None, true) => {
+            eprintln!("Error: --wait switch requires an app name.");
+            process::exit(1);
+        }
+        (None, false) => {
             println!("No app name provided. Capturing debug output from all processes.");
             if let Err(e) = capture_debug_output(None) {
                 eprintln!("Error capturing debug output: {}", e);