fix(daemon): make idle timeout configurable

Lets browser automation keep a single DevTools connection alive longer so Chrome approval prompts stop recurring after short idle gaps.

Author: afif-reap

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "chrome-devtools-cli"
-version = "0.1.0"
+version = "0.1.1"
 edition = "2021"
 description = "Chrome DevTools Protocol CLI — auto-connects to existing Chrome"
 authors = ["Aero <aero.windwalker@gmail.com>"]

Cargo.toml

@@ -44,7 +44,7 @@ chrome-devtools navigate https://example.com
         │
         ├─ If no daemon → spawn one (background process)
         │   └─ Daemon connects to Chrome WebSocket (one-time approval)
-        │   └─ Listens on Unix socket, 5-min idle timeout
+        │   └─ Listens on Unix socket, configurable idle timeout (default 5m)
         │
         └─ Fallback → direct WebSocket connection (no daemon)
 ```
@@ -149,16 +149,34 @@ You can also use `--page <index>` for quick one-offs, or pass the raw hex target
 | `--ws-endpoint <url>` | Explicit WebSocket URL |
 | `--user-data-dir <path>` | Custom Chrome profile directory |
 | `--channel <ch>` | Chrome channel (stable/beta/canary/dev) |
+| `--daemon-idle-timeout <value>` | Daemon idle timeout (`30m`, `1h`, `never`, or `Ns/Nm/Nh`) |
+
+You can also set `CHROME_DEVTOOLS_DAEMON_IDLE_TIMEOUT` as an environment fallback.
+
+Examples:
+
+```bash
+# Keep daemon alive for 30 minutes of inactivity
+chrome-devtools --daemon-idle-timeout 30m list-pages
+
+# Keep daemon alive for 1 hour (env fallback)
+CHROME_DEVTOOLS_DAEMON_IDLE_TIMEOUT=1h chrome-devtools navigate https://example.com
+
+# Disable idle shutdown
+chrome-devtools --daemon-idle-timeout never snapshot
+```
 
 ## Daemon details
 
 - **Socket**: `/tmp/chrome-devtools-daemon.sock`
 - **PID file**: `/tmp/chrome-devtools-daemon.pid`
-- **Idle timeout**: 5 minutes (auto-exits, cleans up socket)
+- **Idle timeout**: 5 minutes by default (configurable via `--daemon-idle-timeout` or `CHROME_DEVTOOLS_DAEMON_IDLE_TIMEOUT`)
 - **Protocol**: Length-prefixed JSON over Unix socket
 - **Spawned by**: First CLI invocation (transparent to user)
 - **Kill manually**: `pkill -f __daemon__` or delete the socket
 
+If a daemon is already running, passing a new `--daemon-idle-timeout` updates it for future idle periods (no manual restart required).
+
 ## Source layout
 
 ```

README.md

@@ -82,6 +82,9 @@ chrome-devtools --target <name> resize 1280 720
 | `--ws-endpoint <url>` | Explicit WebSocket endpoint (overrides auto-connect) |
 | `--user-data-dir <path>` | Custom Chrome profile directory |
 | `--channel <ch>` | Chrome channel: stable / beta / canary / dev |
+| `--daemon-idle-timeout <value>` | Daemon idle timeout (`30m`, `1h`, `never`, or `Ns/Nm/Nh`) |
+
+Environment fallback: `CHROME_DEVTOOLS_DAEMON_IDLE_TIMEOUT`.
 
 ## Typical task pattern
 
@@ -98,4 +101,6 @@ Use `snapshot` before `screenshot` when trying to understand page structure —
 
 The binary automatically manages a background daemon that holds a persistent WebSocket connection to Chrome. Chrome prompts for DevTools access once; all subsequent commands reuse the connection silently. No manual daemon management is needed.
 
+Daemon idle timeout defaults to 5 minutes. Override it per command with `--daemon-idle-timeout` (for example: `30m`, `1h`, `never`) or via `CHROME_DEVTOOLS_DAEMON_IDLE_TIMEOUT`. If a daemon is already running, a new timeout value is adopted for future idle periods without a manual restart.
+
 To stop it manually: `pkill -f __daemon__`

skill/chrome-devtools/SKILL.md

@@ -18,14 +18,21 @@ pub async fn send_to_daemon(request: &DaemonRequest) -> Result<DaemonResponse> {
 }
 
 /// Spawn the daemon process in the background.
-pub fn spawn_daemon(ws_url: &str) -> Result<()> {
+pub fn spawn_daemon(ws_url: &str, idle_timeout: Option<DaemonIdleTimeout>) -> Result<()> {
     let exe = std::env::current_exe()?;
-    std::process::Command::new(&exe)
-        .args(["__daemon__", ws_url])
+    let mut command = std::process::Command::new(&exe);
+    command
+        .arg("__daemon__")
+        .arg(ws_url)
         .stdin(std::process::Stdio::null())
         .stdout(std::process::Stdio::null())
-        .stderr(std::process::Stdio::null())
-        .spawn()?;
+        .stderr(std::process::Stdio::null());
+
+    if let Some(timeout) = idle_timeout {
+        command.arg(timeout.to_string());
+    }
+
+    command.spawn()?;
     Ok(())
 }
 

src/client.rs

@@ -1,16 +1,17 @@
 use anyhow::{anyhow, Result};
-use std::time::Duration;
 use tokio::net::UnixListener;
 
 use crate::cdp::CdpClient;
 use crate::commands;
 use crate::friendly;
 use crate::protocol::*;
 
-const IDLE_TIMEOUT: Duration = Duration::from_secs(300); // 5 minutes
-
-pub async fn run_daemon(ws_url: &str) -> Result<()> {
+pub async fn run_daemon(
+    ws_url: &str,
+    initial_idle_timeout: Option<DaemonIdleTimeout>,
+) -> Result<()> {
     let mut client = CdpClient::connect(ws_url).await?;
+    let mut idle_timeout = initial_idle_timeout.unwrap_or(DaemonIdleTimeout::DEFAULT);
 
     // Clean up stale socket
     let sock = socket_path();
@@ -23,10 +24,8 @@ pub async fn run_daemon(ws_url: &str) -> Result<()> {
 
     // Signal readiness by socket existence (it's already bound)
     loop {
-        let accept = tokio::time::timeout(IDLE_TIMEOUT, listener.accept()).await;
-
-        match accept {
-            Ok(Ok((mut stream, _))) => {
+        match accept_with_idle_timeout(&listener, idle_timeout).await {
+            Ok(Some((mut stream, _))) => {
                 let req_bytes = match read_msg(&mut stream).await {
                     Ok(b) => b,
                     Err(e) => {
@@ -48,19 +47,23 @@ pub async fn run_daemon(ws_url: &str) -> Result<()> {
                     }
                 };
 
+                if let Some(next_idle_timeout) = request.daemon_idle_timeout {
+                    idle_timeout = next_idle_timeout;
+                }
+
                 let response = handle_request(&mut client, &request).await;
 
                 if let Ok(resp_bytes) = serde_json::to_vec(&response) {
                     let _ = write_msg(&mut stream, &resp_bytes).await;
                 }
             }
-            Ok(Err(e)) => {
-                eprintln!("daemon: accept error: {e}");
-            }
-            Err(_) => {
+            Ok(None) => {
                 // Idle timeout — exit
                 break;
             }
+            Err(e) => {
+                eprintln!("daemon: accept error: {e}");
+            }
         }
     }
 
@@ -69,6 +72,23 @@ pub async fn run_daemon(ws_url: &str) -> Result<()> {
     Ok(())
 }
 
+async fn accept_with_idle_timeout(
+    listener: &UnixListener,
+    idle_timeout: DaemonIdleTimeout,
+) -> std::result::Result<
+    Option<(tokio::net::UnixStream, tokio::net::unix::SocketAddr)>,
+    std::io::Error,
+> {
+    if let Some(duration) = idle_timeout.as_duration() {
+        return match tokio::time::timeout(duration, listener.accept()).await {
+            Ok(accept_result) => accept_result.map(Some),
+            Err(_) => Ok(None),
+        };
+    }
+
+    listener.accept().await.map(Some)
+}
+
 async fn handle_request(client: &mut CdpClient, req: &DaemonRequest) -> DaemonResponse {
     match execute_command(client, req).await {
         Ok(output) => DaemonResponse {
@@ -85,7 +105,10 @@ async fn handle_request(client: &mut CdpClient, req: &DaemonRequest) -> DaemonRe
 }
 
 fn is_browser_level(cmd: &str) -> bool {
-    matches!(cmd, "list-pages" | "new-page" | "close-page" | "select-page")
+    matches!(
+        cmd,
+        "list-pages" | "new-page" | "close-page" | "select-page"
+    )
 }
 
 async fn execute_command(client: &mut CdpClient, req: &DaemonRequest) -> Result<String> {
@@ -145,11 +168,15 @@ async fn execute_command(client: &mut CdpClient, req: &DaemonRequest) -> Result<
             commands::evaluate::evaluate(client, &session_id, expr, req.json_output).await
         }
         "click" => {
-            let sel = args["selector"].as_str().ok_or(anyhow!("selector required"))?;
+            let sel = args["selector"]
+                .as_str()
+                .ok_or(anyhow!("selector required"))?;
             commands::input::click(client, &session_id, sel).await
         }
         "fill" => {
-            let sel = args["selector"].as_str().ok_or(anyhow!("selector required"))?;
+            let sel = args["selector"]
+                .as_str()
+                .ok_or(anyhow!("selector required"))?;
             let val = args["value"].as_str().ok_or(anyhow!("value required"))?;
             commands::input::fill(client, &session_id, sel, val).await
         }
@@ -162,12 +189,12 @@ async fn execute_command(client: &mut CdpClient, req: &DaemonRequest) -> Result<
             commands::input::press_key(client, &session_id, key).await
         }
         "hover" => {
-            let sel = args["selector"].as_str().ok_or(anyhow!("selector required"))?;
+            let sel = args["selector"]
+                .as_str()
+                .ok_or(anyhow!("selector required"))?;
             commands::input::hover(client, &session_id, sel).await
         }
-        "snapshot" => {
-            commands::snapshot::take_snapshot(client, &session_id, req.json_output).await
-        }
+        "snapshot" => commands::snapshot::take_snapshot(client, &session_id, req.json_output).await,
         "resize" => {
             let w = args["width"].as_u64().ok_or(anyhow!("width required"))? as u32;
             let h = args["height"].as_u64().ok_or(anyhow!("height required"))? as u32;