fix(main): robust docker fallback for LSP spawn

- Check Docker container existence before spawning LSP
- Use local executable if container is missing or check fails
- Remove redundant error handling and fallback logic
- Improve debug and warn tracing for process selection
- Ensure consistent argument handling for both modes

Author: richardhapb

Cargo.lock

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

Cargo.toml

@@ -215,11 +215,17 @@ Logs are written to a temporary directory. On Unix systems, this is located at `
 tail -f /tmp/lspdock_rust-analyzer.log
 ```
 
-
 ## CLI Arguments <a id="cli-arguments"></a>
 
 The following arguments can be used. These arguments take precedence over the config file. If an argument is provided, the config file field (if it exists) will be overridden. All arguments passed after `--` will be forwarded to the LSP. If any of these arguments are included, and the LSP arguments are passed directly, e.g. `lspdock --stdio`, all arguments will be sent directly to the LSP.
 
+**Variable Expansion:** CLI arguments support the same variable expansion as the config file (`$CWD`, `$PARENT`, `$HOME`). Use single quotes to prevent shell expansion:
+```bash
+lspdock --container '$PARENT-web' --docker-path /app --local-path '$HOME/dev'
+```
+
+Without single quotes, your shell will expand the variables before lspdock receives them.
+
 ```text
 Usage: lspdock [OPTIONS] [-- <ARGS>...]
 
@@ -238,6 +244,12 @@ Options:
   -V, --version                    Print version
 ```
 
+**Why single quotes matter:**
+- `"$HOME"` → Shell expands to `/home/user` → lspdock receives `/home/user`
+- `'$HOME'` → Shell doesn't expand → lspdock receives `$HOME` → lspdock expands it
+
+Single quotes preserve the literal `$` so lspdock can do the expansion.
+
 ### When to Use `--`
 
 Use the `--` separator to avoid ambiguity when your LSP server has flags that conflict with lspdock:

README.md

@@ -1,6 +1,6 @@
 use std::process::Stdio;
 use tokio::process::Command;
-use tracing::{debug, error, info};
+use tracing::{debug, error, info, warn};
 use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
 mod config;
 mod lsp;
@@ -47,8 +47,38 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     debug!(?config, "configuration file");
 
-    // Call docker only if the pattern matches.
-    let (cmd, mut cmd_args) = if config.use_docker {
+    info!("Initializing LSP");
+
+    let mut using_docker = config.use_docker;
+
+    // Check if Docker container exists before trying to use it
+    if using_docker {
+        let container_check = Command::new("docker")
+            .args(["inspect", "-f", "{{.State.Running}}", &config.container])
+            .output();
+
+        match container_check.await {
+            Ok(output) if output.status.success() => {
+                let running = String::from_utf8_lossy(&output.stdout).trim() == "true";
+                if !running {
+                    warn!(container=%config.container, "Container exists but is not running, falling back to local");
+                    using_docker = false;
+                } else {
+                    debug!(container=%config.container, "Container is running");
+                }
+            }
+            Ok(_) => {
+                warn!(container=%config.container, "Container not found, falling back to local");
+                using_docker = false;
+            }
+            Err(e) => {
+                warn!(%e, "Failed to check Docker, falling back to local");
+                using_docker = false;
+            }
+        }
+    }
+
+    let (cmd, cmd_args) = if using_docker {
         let cmd = vec![
             "exec".into(),
             "-i".into(),
@@ -59,55 +89,29 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         ];
         ("docker".into(), cmd)
     } else {
-        (config.executable.clone(), vec![])
+        (get_fallback_exec(&config), vec![])
     };
 
-    debug!(%config.container, ?cmd_args, "Connecting to LSP");
-    debug!(?cli.args, "args received");
-    cmd_args.extend(cli.args.clone());
-    debug!(?cmd_args, "full command");
+    let mut final_args = cmd_args;
+    final_args.extend(cli.args.clone());
 
-    info!("Initializing LSP");
+    debug!(?cmd, ?final_args, "Spawning LSP");
 
-    let mut using_docker = config.use_docker;
-    let mut child = match Command::new(&cmd)
-        .args(cmd_args)
+    let mut child = Command::new(&cmd)
+        .args(&final_args)
         .stdin(Stdio::piped())
         .stdout(Stdio::piped())
         .stderr(Stdio::null())
         .spawn()
-    {
-        Ok(ch) => ch,
-        Err(_) if config.use_docker => {
-            // Fallback to local lsp
-            let exec = get_fallback_exec(&config);
-            using_docker = false;
-
-            info!("Cannot connect to container, falling back to local");
-
-            // Last try, panic if cannot initialize
-            Command::new(&exec)
-                .args(cli.args)
-                .stdin(Stdio::piped())
-                .stdout(Stdio::piped())
-                .stderr(Stdio::null())
-                .spawn()
-                .expect("failed to initialize in Docker and local")
-        }
-
-        Err(err) => {
-            error!(%err, "initializing lsp");
-            std::process::exit(1);
-        }
-    };
+        .expect("failed to spawn LSP process");
 
     let stdout = BufReader::new(child.stdout.take().unwrap());
     let stdin = BufWriter::new(child.stdin.take().unwrap());
 
     if using_docker {
         info!(%config.container, "Attached to stdout/stdin");
     } else {
-        info!(%config.executable, "Attached to stdout/stdin");
+        info!(%config.executable, "Attached to stdout/stdin (local)");
     }
 
     // Main proxy handler