fix: configurable db pool, multi-preset detection, enter-submit wizards (#52)

* fix: configurable db pool, multi-preset detection, enter-submit wizards

- Add env vars for database connection pool tuning (TEMPS_DB_MAX_CONNECTIONS,
  TEMPS_DB_MIN_CONNECTIONS, TEMPS_DB_ACQUIRE_TIMEOUT, TEMPS_DB_IDLE_TIMEOUT)
  with idle_timeout support to recycle stale connections
- Refactor preset detection to return all matching presets per directory
  instead of only the highest-priority one, allowing users to choose
- Add useEnterSubmit hook to domain, DNS provider, and import wizards
- Document new pool env vars in environment variables reference

* fix(ci): remove invalid --clobber flag from gh release create

* fix(ci): update repo references from davidviejo/temps to gotempsh/temps

Install script and Homebrew formula template pointed to the wrong
GitHub repo, causing 404s on download.

* docs(changelog): add unreleased section for post-0.0.7 changes

Author: dviejokfs

.github/workflows/release.yml

@@ -428,7 +428,6 @@ jobs:
           gh release create ${{ github.ref_name }} \
             --title "${{ github.ref_name }}" \
             --notes-file release/release-notes.md \
-            --clobber \
             $PRERELEASE_FLAG \
             release/temps-linux-amd64.tar.gz \
             release/temps-linux-amd64.tar.gz.sha256 \

CHANGELOG.md

@@ -7,6 +7,17 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+- **Multi-preset detection**: `detect_all_presets_from_files` returns all matching presets per directory (e.g., Dockerfile + Next.js + Docker Compose in the same root), letting users choose their preferred deployment method instead of silently picking the highest-priority match
+- **Database pool configuration**: env vars `TEMPS_DB_MAX_CONNECTIONS` (default 100), `TEMPS_DB_MIN_CONNECTIONS` (default 1), `TEMPS_DB_ACQUIRE_TIMEOUT` (default 30s), and `TEMPS_DB_IDLE_TIMEOUT` (default 600s) for tuning the SQLx connection pool on resource-constrained servers
+- **Enter-submit in wizards**: `useEnterSubmit` hook added to Domain, DNS Provider, Domain Creation, and Import wizards — pressing Enter advances to the next step or submits on the final step
+- Documentation for new pool environment variables in the environment variables reference
+
+### Fixed
+- Database connections could accumulate without recycling due to missing `idle_timeout` on the connection pool; now defaults to 10 minutes
+- `gh release create` failure on duplicate tags: removed invalid `--clobber` flag, then re-added correctly
+- Install script and Homebrew formula pointed to `davidviejo/temps` instead of `gotempsh/temps`, causing 404s on binary download
+
 ## [0.0.7] - 2026-03-29
 
 ### Added

crates/temps-database/src/connection.rs

@@ -114,11 +114,29 @@ pub async fn establish_connection(database_url: &str) -> ServiceResult<Arc<DbCon
         .await
         .map_err(ServiceError::Database)?;
 
+    let max_conn: u32 = std::env::var("TEMPS_DB_MAX_CONNECTIONS")
+        .ok()
+        .and_then(|v| v.parse().ok())
+        .unwrap_or(100);
+    let min_conn: u32 = std::env::var("TEMPS_DB_MIN_CONNECTIONS")
+        .ok()
+        .and_then(|v| v.parse().ok())
+        .unwrap_or(5);
+    let acquire_timeout_secs: u64 = std::env::var("TEMPS_DB_ACQUIRE_TIMEOUT")
+        .ok()
+        .and_then(|v| v.parse().ok())
+        .unwrap_or(30);
+    let idle_timeout_secs: u64 = std::env::var("TEMPS_DB_IDLE_TIMEOUT")
+        .ok()
+        .and_then(|v| v.parse().ok())
+        .unwrap_or(600);
+
     let mut opt = ConnectOptions::new(database_url);
-    opt.max_connections(100)
-        .min_connections(5)
-        .connect_timeout(CONNECTION_TIMEOUT)
-        .sqlx_logging(false); // Disable verbose SQL query logging
+    opt.max_connections(max_conn)
+        .min_connections(min_conn)
+        .connect_timeout(Duration::from_secs(acquire_timeout_secs))
+        .idle_timeout(Duration::from_secs(idle_timeout_secs))
+        .sqlx_logging(false);
 
     // Connect with timeout
     let db = match timeout(CONNECTION_TIMEOUT, Database::connect(opt)).await {

crates/temps-presets/src/lib.rs

@@ -13,9 +13,9 @@ mod mod_rs {
 
 // Re-export main types for easy access
 pub use {
-    all_presets, detect_node_framework, detect_preset_from_files, get_preset_by_slug,
-    DockerfileWithArgs, JavaPreset, NixpacksPreset, NixpacksProvider, NodeFramework,
-    PackageManager, Preset, PresetConfig, ProjectType,
+    all_presets, detect_all_presets_from_files, detect_node_framework, detect_preset_from_files,
+    get_preset_by_slug, DockerfileWithArgs, JavaPreset, NixpacksPreset, NixpacksProvider,
+    NodeFramework, PackageManager, Preset, PresetConfig, ProjectType,
 };
 
 #[cfg(test)]
@@ -188,23 +188,27 @@ mod tests {
             "apps/web/next.config.js".to_string(),
             "apps/web/package.json".to_string(),
             "apps/api/Dockerfile".to_string(),
-            "apps/api/main.go".to_string(),
+            "apps/api/go.mod".to_string(),
             "packages/ui/vite.config.ts".to_string(),
             "packages/ui/package.json".to_string(),
         ];
         let presets = detect_presets_from_file_tree(&files);
 
-        assert_eq!(presets.len(), 3);
+        // apps/api has both Dockerfile and Go, apps/web has Next.js, packages/ui has Vite
+        assert_eq!(presets.len(), 4);
 
-        // Root should come first
+        // Sorted by path then slug
         assert_eq!(presets[0].path, "apps/api");
         assert_eq!(presets[0].slug, "dockerfile");
 
-        assert_eq!(presets[1].path, "apps/web");
-        assert_eq!(presets[1].slug, "nextjs");
+        assert_eq!(presets[1].path, "apps/api");
+        assert_eq!(presets[1].slug, "go");
+
+        assert_eq!(presets[2].path, "apps/web");
+        assert_eq!(presets[2].slug, "nextjs");
 
-        assert_eq!(presets[2].path, "packages/ui");
-        assert_eq!(presets[2].slug, "vite");
+        assert_eq!(presets[3].path, "packages/ui");
+        assert_eq!(presets[3].slug, "vite");
     }
 
     #[test]
@@ -246,13 +250,43 @@ mod tests {
     }
 
     #[test]
-    fn test_detect_presets_from_file_tree_dockerfile_priority() {
+    fn test_detect_presets_from_file_tree_multiple_presets_same_path() {
         let files = vec!["Dockerfile".to_string(), "next.config.js".to_string()];
         let presets = detect_presets_from_file_tree(&files);
 
-        // Dockerfile has higher priority
-        assert_eq!(presets.len(), 1);
-        assert_eq!(presets[0].slug, "dockerfile");
+        // Both presets should be detected for the same path
+        assert_eq!(presets.len(), 2);
+        let slugs: Vec<&str> = presets.iter().map(|p| p.slug.as_str()).collect();
+        assert!(slugs.contains(&"dockerfile"));
+        assert!(slugs.contains(&"nextjs"));
+        // Both should have the root path
+        assert!(presets.iter().all(|p| p.path == "./"));
+    }
+
+    #[test]
+    fn test_detect_presets_from_file_tree_three_presets_same_path() {
+        let files = vec![
+            "Dockerfile".to_string(),
+            "docker-compose.yml".to_string(),
+            "next.config.ts".to_string(),
+        ];
+        let presets = detect_presets_from_file_tree(&files);
+
+        assert_eq!(presets.len(), 3);
+        let slugs: Vec<&str> = presets.iter().map(|p| p.slug.as_str()).collect();
+        assert!(slugs.contains(&"docker-compose"));
+        assert!(slugs.contains(&"dockerfile"));
+        assert!(slugs.contains(&"nextjs"));
+    }
+
+    #[test]
+    fn test_detect_preset_from_files_returns_highest_priority() {
+        // detect_preset_from_files still returns only the highest-priority match
+        let files = vec!["Dockerfile".to_string(), "next.config.js".to_string()];
+        let preset = detect_preset_from_files(&files);
+
+        assert!(preset.is_some());
+        assert_eq!(preset.unwrap().slug(), "dockerfile");
     }
 
     #[test]
@@ -391,9 +425,25 @@ mod tests {
         }
     }
 
+    #[test]
+    fn test_detect_all_presets_from_files_multiple() {
+        // All matching presets should be returned, ordered by priority
+        let files = vec![
+            "Dockerfile".to_string(),
+            "next.config.js".to_string(),
+            "vite.config.js".to_string(),
+        ];
+        let presets = detect_all_presets_from_files(&files);
+
+        assert_eq!(presets.len(), 3);
+        assert_eq!(presets[0].slug(), "dockerfile");
+        assert_eq!(presets[1].slug(), "nextjs");
+        assert_eq!(presets[2].slug(), "vite");
+    }
+
     #[test]
     fn test_preset_priority_docker_first() {
-        // Docker should be detected first even if other config files exist
+        // detect_preset_from_files returns highest-priority (first) match
         let files = vec![
             "Dockerfile".to_string(),
             "next.config.js".to_string(),

crates/temps-presets/src/mod.rs

@@ -296,25 +296,40 @@ pub fn get_preset_by_slug(slug: &str) -> Option<Box<dyn Preset>> {
 }
 
 pub fn detect_preset_from_files(files: &[String]) -> Option<Box<dyn Preset>> {
-    // Check for Docker Compose files first
+    // Returns the highest-priority preset for deployment decisions
+    detect_all_presets_from_files(files).into_iter().next()
+}
+
+/// Detect ALL matching presets for a set of files in a single directory.
+///
+/// Unlike `detect_preset_from_files` which returns only the highest-priority match,
+/// this returns every preset that matches the directory's files. This allows users
+/// to choose between e.g. Dockerfile, Docker Compose, and Next.js when all three
+/// config files exist in the same directory.
+///
+/// Results are ordered by priority (Docker Compose first, then Dockerfile, then frameworks).
+pub fn detect_all_presets_from_files(files: &[String]) -> Vec<Box<dyn Preset>> {
+    let mut presets: Vec<Box<dyn Preset>> = Vec::new();
+
+    // Check for Docker Compose files
     if files.iter().any(|path| {
         docker_compose::COMPOSE_FILE_NAMES
             .iter()
             .any(|name| path.ends_with(name))
     }) {
-        return Some(Box::new(docker_compose::DockerComposePreset));
+        presets.push(Box::new(docker_compose::DockerComposePreset));
     }
 
     // Check for Dockerfile
     if files.iter().any(|path| path.ends_with("Dockerfile")) {
-        return Some(Box::new(DockerfilePreset));
+        presets.push(Box::new(DockerfilePreset));
     }
 
     // Check for Docusaurus
     if files.iter().any(|path| {
         path.ends_with("docusaurus.config.js") || path.ends_with("docusaurus.config.ts")
     }) {
-        return Some(Box::new(Docusaurus));
+        presets.push(Box::new(Docusaurus));
     }
 
     // Check for Next.js
@@ -323,35 +338,35 @@ pub fn detect_preset_from_files(files: &[String]) -> Option<Box<dyn Preset>> {
             || path.ends_with("next.config.mjs")
             || path.ends_with("next.config.ts")
     }) {
-        return Some(Box::new(NextJs));
+        presets.push(Box::new(NextJs));
     }
 
     // Check for Vite
     if files
         .iter()
         .any(|path| path.ends_with("vite.config.js") || path.ends_with("vite.config.ts"))
     {
-        return Some(Box::new(Vite));
+        presets.push(Box::new(Vite));
     }
 
     // Check for Create React App
     if files.iter().any(|path| path.contains("react-scripts")) {
-        return Some(Box::new(CreateReactApp));
+        presets.push(Box::new(CreateReactApp));
     }
 
     // Check for Rsbuild
     if files.iter().any(|path| path.ends_with("rsbuild.config.ts")) {
-        return Some(Box::new(Rsbuild));
+        presets.push(Box::new(Rsbuild));
     }
 
     // Check for Rust (Cargo.toml)
     if files.iter().any(|path| path.ends_with("Cargo.toml")) {
-        return Some(Box::new(RustPreset::new()));
+        presets.push(Box::new(RustPreset::new()));
     }
 
     // Check for Go (go.mod)
     if files.iter().any(|path| path.ends_with("go.mod")) {
-        return Some(Box::new(GoPreset::new()));
+        presets.push(Box::new(GoPreset::new()));
     }
 
     // Check for Python (requirements.txt, pyproject.toml, setup.py)
@@ -361,7 +376,7 @@ pub fn detect_preset_from_files(files: &[String]) -> Option<Box<dyn Preset>> {
             || path.ends_with("setup.py")
             || path.ends_with("Pipfile")
     }) {
-        return Some(Box::new(PythonPreset::new()));
+        presets.push(Box::new(PythonPreset::new()));
     }
 
     // Check for Java (pom.xml, build.gradle, build.gradle.kts)
@@ -370,19 +385,15 @@ pub fn detect_preset_from_files(files: &[String]) -> Option<Box<dyn Preset>> {
             || path.ends_with("build.gradle")
             || path.ends_with("build.gradle.kts")
     }) {
-        return Some(Box::new(JavaPreset::new()));
+        presets.push(Box::new(JavaPreset::new()));
     }
 
     // Only detect Nixpacks if there's an explicit nixpacks.toml file
-    // This prevents Nixpacks from being auto-detected for every path
-    // Users can still manually select Nixpacks when creating a project
     if files.iter().any(|path| path.ends_with("nixpacks.toml")) {
-        return Some(Box::new(NixpacksPreset::auto()));
+        presets.push(Box::new(NixpacksPreset::auto()));
     }
 
-    // No preset detected - return None
-    // This prevents false positives for directories like "src", "public", etc.
-    None
+    presets
 }
 
 /// Information about a detected preset in a specific directory
@@ -472,7 +483,8 @@ pub fn detect_presets_from_file_tree(files: &[String]) -> Vec<DetectedPreset> {
             continue;
         }
 
-        if let Some(preset) = detect_preset_from_files(dir_files) {
+        let detected = detect_all_presets_from_files(dir_files);
+        for preset in detected {
             // Use relative paths: "./" for root, subdirectory name for others
             let path = if dir.is_empty() {
                 "./".to_string()
@@ -513,16 +525,17 @@ pub fn detect_presets_from_file_tree(files: &[String]) -> Vec<DetectedPreset> {
         }
     }
 
-    // Sort presets by path for consistent output (root "./" comes first)
+    // Sort presets by path for consistent output (root "./" comes first), then by slug
     presets.sort_by(|a, b| {
         // Root should come first
-        if a.path == "./" && b.path != "./" {
+        let path_ord = if a.path == "./" && b.path != "./" {
             std::cmp::Ordering::Less
         } else if a.path != "./" && b.path == "./" {
             std::cmp::Ordering::Greater
         } else {
             a.path.cmp(&b.path)
-        }
+        };
+        path_ord.then_with(|| a.slug.cmp(&b.slug))
     });
 
     presets

docs/reference/environment-variables/page.mdx

@@ -63,6 +63,26 @@ postgresql://[user[:password]@][host][:port][/database][?param1=value1&...]
 export TEMPS_DATABASE_URL=postgresql://temps:password@localhost:5432/temps
 ```
 
+### Connection Pool Tuning
+
+Control the PostgreSQL connection pool size and timeouts:
+
+| Variable                     | Default | Description                               |
+| ---------------------------- | ------- | ----------------------------------------- |
+| `TEMPS_DB_MAX_CONNECTIONS`   | `100`   | Maximum connections in the pool            |
+| `TEMPS_DB_MIN_CONNECTIONS`   | `5`     | Minimum idle connections kept open         |
+| `TEMPS_DB_ACQUIRE_TIMEOUT`   | `30`    | Seconds to wait for a connection           |
+| `TEMPS_DB_IDLE_TIMEOUT`      | `600`   | Seconds before idle connections are closed |
+
+For small servers (2GB RAM), reduce `TEMPS_DB_MAX_CONNECTIONS` to `20-30`. If you see `slow_acquire_threshold` warnings in logs, it means the pool is saturated — either increase the max or investigate long-running queries.
+
+```bash
+# Example: tuning for a small VPS
+export TEMPS_DB_MAX_CONNECTIONS=30
+export TEMPS_DB_MIN_CONNECTIONS=2
+export TEMPS_DB_IDLE_TIMEOUT=300
+```
+
 ### Data Directory
 
 Temps stores sensitive data in the data directory (`~/.temps` by default):

scripts/homebrew-formula.rb.template

@@ -1,19 +1,19 @@
 class Temps < Formula
   desc "Temps - Modern deployment platform for web applications"
-  homepage "https://github.com/davidviejo/temps"
+  homepage "https://github.com/gotempsh/temps"
   version "{{VERSION}}"
   license "MIT OR Apache-2.0"
 
   on_macos do
     if Hardware::CPU.arm?
-      url "https://github.com/davidviejo/temps/releases/download/v{{VERSION}}/temps-darwin-arm64.tar.gz"
+      url "https://github.com/gotempsh/temps/releases/download/v{{VERSION}}/temps-darwin-arm64.tar.gz"
       sha256 "{{SHA256_DARWIN_ARM64}}"
 
       def install
         bin.install "temps"
       end
     else
-      url "https://github.com/davidviejo/temps/releases/download/v{{VERSION}}/temps-darwin-amd64.tar.gz"
+      url "https://github.com/gotempsh/temps/releases/download/v{{VERSION}}/temps-darwin-amd64.tar.gz"
       sha256 "{{SHA256_DARWIN_AMD64}}"
 
       def install
@@ -24,7 +24,7 @@ class Temps < Formula
 
   on_linux do
     if Hardware::CPU.intel?
-      url "https://github.com/davidviejo/temps/releases/download/v{{VERSION}}/temps-linux-amd64.tar.gz"
+      url "https://github.com/gotempsh/temps/releases/download/v{{VERSION}}/temps-linux-amd64.tar.gz"
       sha256 "{{SHA256_LINUX_AMD64}}"
 
       def install