feat: add Clone Database to Docker functionality

Clone any database to a local Docker PostgreSQL container with schema
and/or data transfer via pg_dump. Supports three modes: schema only,
full clone, and sample data. Includes container lifecycle management
(start/stop/remove) in the Admin panel, progress tracking with
collapsible process log, and automatic connection creation.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

src-tauri/src/commands/docker.rs

@@ -0,0 +1,666 @@
+use crate::error::{TuskError, TuskResult};
+use crate::models::connection::ConnectionConfig;
+use crate::models::docker::{
+    CloneMode, CloneProgress, CloneResult, CloneToDockerParams, DockerStatus, TuskContainer,
+};
+use crate::state::AppState;
+use std::fs;
+use std::sync::Arc;
+use tauri::{AppHandle, Emitter, Manager, State};
+use tokio::process::Command;
+
+fn docker_err(msg: impl Into<String>) -> TuskError {
+    TuskError::Docker(msg.into())
+}
+
+fn emit_progress(
+    app: &AppHandle,
+    clone_id: &str,
+    stage: &str,
+    percent: u8,
+    message: &str,
+    detail: Option<&str>,
+) {
+    let _ = app.emit(
+        "clone-progress",
+        CloneProgress {
+            clone_id: clone_id.to_string(),
+            stage: stage.to_string(),
+            percent,
+            message: message.to_string(),
+            detail: detail.map(|s| s.to_string()),
+        },
+    );
+}
+
+fn get_connections_path(app: &AppHandle) -> TuskResult<std::path::PathBuf> {
+    let dir = app
+        .path()
+        .app_data_dir()
+        .map_err(|e| TuskError::Custom(e.to_string()))?;
+    fs::create_dir_all(&dir)?;
+    Ok(dir.join("connections.json"))
+}
+
+fn load_connection_config(app: &AppHandle, connection_id: &str) -> TuskResult<ConnectionConfig> {
+    let path = get_connections_path(app)?;
+    if !path.exists() {
+        return Err(TuskError::ConnectionNotFound(connection_id.to_string()));
+    }
+    let data = fs::read_to_string(&path)?;
+    let connections: Vec<ConnectionConfig> = serde_json::from_str(&data)?;
+    connections
+        .into_iter()
+        .find(|c| c.id == connection_id)
+        .ok_or_else(|| TuskError::ConnectionNotFound(connection_id.to_string()))
+}
+
+/// Shell-escape a string for use in single quotes
+fn shell_escape(s: &str) -> String {
+    s.replace('\'', "'\\''")
+}
+
+#[tauri::command]
+pub async fn check_docker() -> TuskResult<DockerStatus> {
+    let output = Command::new("docker")
+        .args(["version", "--format", "{{.Server.Version}}"])
+        .output()
+        .await;
+
+    match output {
+        Ok(out) => {
+            if out.status.success() {
+                let version = String::from_utf8_lossy(&out.stdout).trim().to_string();
+                Ok(DockerStatus {
+                    installed: true,
+                    daemon_running: true,
+                    version: Some(version),
+                    error: None,
+                })
+            } else {
+                let stderr = String::from_utf8_lossy(&out.stderr).trim().to_string();
+                let daemon_running = !stderr.contains("Cannot connect")
+                    && !stderr.contains("connection refused");
+                Ok(DockerStatus {
+                    installed: true,
+                    daemon_running,
+                    version: None,
+                    error: Some(stderr),
+                })
+            }
+        }
+        Err(_) => Ok(DockerStatus {
+            installed: false,
+            daemon_running: false,
+            version: None,
+            error: Some("Docker CLI not found. Please install Docker.".to_string()),
+        }),
+    }
+}
+
+#[tauri::command]
+pub async fn list_tusk_containers() -> TuskResult<Vec<TuskContainer>> {
+    let output = Command::new("docker")
+        .args([
+            "ps",
+            "-a",
+            "--filter",
+            "label=tusk.managed=true",
+            "--format",
+            "{{.ID}}\t{{.Names}}\t{{.Status}}\t{{.Label \"tusk.pg-version\"}}\t{{.Label \"tusk.source-db\"}}\t{{.Label \"tusk.source-connection\"}}\t{{.CreatedAt}}\t{{.Ports}}",
+        ])
+        .output()
+        .await
+        .map_err(|e| docker_err(format!("Failed to run docker ps: {}", e)))?;
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        return Err(docker_err(format!("docker ps failed: {}", stderr)));
+    }
+
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let mut containers = Vec::new();
+
+    for line in stdout.lines() {
+        if line.trim().is_empty() {
+            continue;
+        }
+        let parts: Vec<&str> = line.split('\t').collect();
+        if parts.len() < 8 {
+            continue;
+        }
+
+        let host_port = parse_host_port(parts[7]);
+
+        containers.push(TuskContainer {
+            container_id: parts[0].to_string(),
+            name: parts[1].to_string(),
+            status: parts[2].to_string(),
+            host_port,
+            pg_version: parts[3].to_string(),
+            source_database: if parts[4].is_empty() {
+                None
+            } else {
+                Some(parts[4].to_string())
+            },
+            source_connection: if parts[5].is_empty() {
+                None
+            } else {
+                Some(parts[5].to_string())
+            },
+            created_at: if parts[6].is_empty() {
+                None
+            } else {
+                Some(parts[6].to_string())
+            },
+        });
+    }
+
+    Ok(containers)
+}
+
+fn parse_host_port(ports_str: &str) -> u16 {
+    for part in ports_str.split(',') {
+        let part = part.trim();
+        if let Some(arrow_pos) = part.find("->") {
+            let before = &part[..arrow_pos];
+            if let Some(colon_pos) = before.rfind(':') {
+                if let Ok(port) = before[colon_pos + 1..].parse::<u16>() {
+                    return port;
+                }
+            }
+        }
+    }
+    0
+}
+
+#[tauri::command]
+pub async fn clone_to_docker(
+    app: AppHandle,
+    state: State<'_, Arc<AppState>>,
+    params: CloneToDockerParams,
+    clone_id: String,
+) -> TuskResult<CloneResult> {
+    let state = state.inner().clone();
+    let app_clone = app.clone();
+
+    tokio::spawn(async move { do_clone(&app_clone, &state, &params, &clone_id).await })
+        .await
+        .map_err(|e| docker_err(format!("Clone task panicked: {}", e)))?
+}
+
+async fn do_clone(
+    app: &AppHandle,
+    _state: &Arc<AppState>,
+    params: &CloneToDockerParams,
+    clone_id: &str,
+) -> TuskResult<CloneResult> {
+    // Step 1: Check Docker
+    emit_progress(app, clone_id, "checking", 5, "Checking Docker availability...", None);
+    let status = check_docker().await?;
+    if !status.installed || !status.daemon_running {
+        let msg = status
+            .error
+            .unwrap_or_else(|| "Docker is not available".to_string());
+        emit_progress(app, clone_id, "error", 5, &msg, None);
+        return Err(docker_err(msg));
+    }
+
+    // Step 2: Find available port
+    emit_progress(app, clone_id, "port", 10, "Finding available port...", None);
+    let host_port = match params.host_port {
+        Some(p) => p,
+        None => find_free_port().await?,
+    };
+    emit_progress(app, clone_id, "port", 10, &format!("Using port {}", host_port), None);
+
+    // Step 3: Create container
+    emit_progress(app, clone_id, "container", 20, "Creating PostgreSQL container...", None);
+    let pg_password = params.postgres_password.as_deref().unwrap_or("tusk");
+    let image = format!("postgres:{}", params.pg_version);
+
+    let create_output = Command::new("docker")
+        .args([
+            "run", "-d",
+            "--name", &params.container_name,
+            "-p", &format!("{}:5432", host_port),
+            "-e", &format!("POSTGRES_PASSWORD={}", pg_password),
+            "-l", "tusk.managed=true",
+            "-l", &format!("tusk.source-db={}", params.source_database),
+            "-l", &format!("tusk.source-connection={}", params.source_connection_id),
+            "-l", &format!("tusk.pg-version={}", params.pg_version),
+            &image,
+        ])
+        .output()
+        .await
+        .map_err(|e| docker_err(format!("Failed to create container: {}", e)))?;
+
+    if !create_output.status.success() {
+        let stderr = String::from_utf8_lossy(&create_output.stderr).trim().to_string();
+        emit_progress(app, clone_id, "error", 20, &format!("Failed to create container: {}", stderr), None);
+        return Err(docker_err(format!("Failed to create container: {}", stderr)));
+    }
+
+    let container_id = String::from_utf8_lossy(&create_output.stdout).trim().to_string();
+
+    // Step 4: Wait for PostgreSQL to be ready
+    emit_progress(app, clone_id, "waiting", 30, "Waiting for PostgreSQL to be ready...", None);
+    wait_for_pg_ready(&params.container_name, 30).await?;
+    emit_progress(app, clone_id, "waiting", 35, "PostgreSQL is ready", None);
+
+    // Step 5: Create target database
+    emit_progress(app, clone_id, "database", 35, &format!("Creating database '{}'...", params.source_database), None);
+    let create_db_output = Command::new("docker")
+        .args([
+            "exec", &params.container_name,
+            "psql", "-U", "postgres", "-c",
+            &format!("CREATE DATABASE \"{}\"", params.source_database),
+        ])
+        .output()
+        .await
+        .map_err(|e| docker_err(format!("Failed to create database: {}", e)))?;
+
+    if !create_db_output.status.success() {
+        let stderr = String::from_utf8_lossy(&create_db_output.stderr).trim().to_string();
+        if !stderr.contains("already exists") {
+            emit_progress(app, clone_id, "error", 35, &format!("Failed to create database: {}", stderr), None);
+            return Err(docker_err(format!("Failed to create database: {}", stderr)));
+        }
+    }
+
+    // Step 6: Get source connection URL (using the specific database to clone)
+    emit_progress(app, clone_id, "dump", 40, "Preparing data transfer...", None);
+    let source_config = load_connection_config(app, &params.source_connection_id)?;
+    let source_url = source_config.connection_url_for_db(&params.source_database);
+    emit_progress(
+        app, clone_id, "dump", 40,
+        &format!("Source: {}@{}:{}/{}", source_config.user, source_config.host, source_config.port, params.source_database),
+        None,
+    );
+
+    // Step 7: Transfer data based on clone mode
+    match params.clone_mode {
+        CloneMode::SchemaOnly => {
+            emit_progress(app, clone_id, "transfer", 45, "Dumping schema...", None);
+            transfer_schema_only(app, clone_id, &source_url, &params.container_name, &params.source_database, &params.pg_version).await?;
+        }
+        CloneMode::FullClone => {
+            emit_progress(app, clone_id, "transfer", 45, "Performing full database clone...", None);
+            transfer_full_clone(app, clone_id, &source_url, &params.container_name, &params.source_database, &params.pg_version).await?;
+        }
+        CloneMode::SampleData => {
+            emit_progress(app, clone_id, "transfer", 45, "Dumping schema...", None);
+            transfer_schema_only(app, clone_id, &source_url, &params.container_name, &params.source_database, &params.pg_version).await?;
+            emit_progress(app, clone_id, "transfer", 65, "Copying sample data...", None);
+            let sample_rows = params.sample_rows.unwrap_or(1000);
+            transfer_sample_data(app, clone_id, &source_url, &params.container_name, &params.source_database, &params.pg_version, sample_rows).await?;
+        }
+    }
+
+    // Step 8: Save connection in Tusk
+    emit_progress(app, clone_id, "connection", 90, "Saving connection...", None);
+    let connection_id = uuid::Uuid::new_v4().to_string();
+    let new_config = ConnectionConfig {
+        id: connection_id.clone(),
+        name: format!("{} (Docker clone)", params.source_database),
+        host: "localhost".to_string(),
+        port: host_port,
+        user: "postgres".to_string(),
+        password: pg_password.to_string(),
+        database: params.source_database.clone(),
+        ssl_mode: Some("disable".to_string()),
+        color: Some("#06b6d4".to_string()),
+        environment: Some("local".to_string()),
+    };
+
+    save_connection_config(app, &new_config)?;
+
+    let connection_url = format!(
+        "postgres://postgres:{}@localhost:{}/{}",
+        pg_password, host_port, params.source_database
+    );
+
+    let container = TuskContainer {
+        container_id: container_id[..12.min(container_id.len())].to_string(),
+        name: params.container_name.clone(),
+        status: "Up".to_string(),
+        host_port,
+        pg_version: params.pg_version.clone(),
+        source_database: Some(params.source_database.clone()),
+        source_connection: Some(params.source_connection_id.clone()),
+        created_at: Some(chrono::Local::now().format("%Y-%m-%d %H:%M:%S").to_string()),
+    };
+
+    let result = CloneResult {
+        container,
+        connection_id,
+        connection_url,
+    };
+
+    emit_progress(app, clone_id, "done", 100, "Clone completed successfully!", None);
+
+    Ok(result)
+}
+
+async fn find_free_port() -> TuskResult<u16> {
+    let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
+        .await
+        .map_err(|e| docker_err(format!("Failed to find free port: {}", e)))?;
+    let port = listener
+        .local_addr()
+        .map_err(|e| docker_err(format!("Failed to get port: {}", e)))?
+        .port();
+    drop(listener);
+    Ok(port)
+}
+
+async fn wait_for_pg_ready(container_name: &str, timeout_secs: u64) -> TuskResult<()> {
+    let start = std::time::Instant::now();
+    let timeout = std::time::Duration::from_secs(timeout_secs);
+
+    loop {
+        if start.elapsed() > timeout {
+            return Err(docker_err("PostgreSQL did not become ready in time"));
+        }
+
+        let output = Command::new("docker")
+            .args(["exec", container_name, "pg_isready", "-U", "postgres"])
+            .output()
+            .await;
+
+        if let Ok(out) = output {
+            if out.status.success() {
+                return Ok(());
+            }
+        }
+
+        tokio::time::sleep(std::time::Duration::from_millis(500)).await;
+    }
+}
+
+async fn try_local_pg_dump() -> bool {
+    Command::new("pg_dump")
+        .arg("--version")
+        .output()
+        .await
+        .map(|o| o.status.success())
+        .unwrap_or(false)
+}
+
+/// Build the pg_dump portion of a shell command
+fn pg_dump_shell_cmd(has_local: bool, pg_version: &str, extra_args: &str, source_url: &str) -> String {
+    let escaped_url = shell_escape(source_url);
+    if has_local {
+        format!("pg_dump {} '{}'", extra_args, escaped_url)
+    } else {
+        format!(
+            "docker run --rm --network=host postgres:{} pg_dump {} '{}'",
+            pg_version, extra_args, escaped_url
+        )
+    }
+}
+
+async fn transfer_schema_only(
+    app: &AppHandle,
+    clone_id: &str,
+    source_url: &str,
+    container_name: &str,
+    database: &str,
+    pg_version: &str,
+) -> TuskResult<()> {
+    let has_local = try_local_pg_dump().await;
+    let label = if has_local { "local pg_dump" } else { "Docker-based pg_dump" };
+    emit_progress(app, clone_id, "transfer", 50, &format!("Using {} for schema...", label), None);
+
+    let dump_cmd = pg_dump_shell_cmd(has_local, pg_version, "--schema-only", source_url);
+    let escaped_db = shell_escape(database);
+    let pipe_cmd = format!(
+        "{} | docker exec -i '{}' psql -U postgres -d '{}'",
+        dump_cmd, shell_escape(container_name), escaped_db
+    );
+
+    let output = Command::new("sh")
+        .args(["-c", &pipe_cmd])
+        .output()
+        .await
+        .map_err(|e| docker_err(format!("Schema transfer failed: {}", e)))?;
+
+    let stderr = String::from_utf8_lossy(&output.stderr).trim().to_string();
+    let stdout = String::from_utf8_lossy(&output.stdout).trim().to_string();
+
+    if !output.status.success() {
+        // psql often emits non-fatal warnings; only fail on actual errors
+        if stderr.contains("FATAL") || stderr.contains("could not connect") || stderr.contains("No such file") {
+            emit_progress(app, clone_id, "error", 55, "Schema transfer failed", Some(&stderr));
+            return Err(docker_err(format!("Schema transfer failed: {}", stderr)));
+        }
+    }
+
+    // Log any output for debugging
+    if !stderr.is_empty() {
+        emit_progress(app, clone_id, "transfer", 55, "Schema transferred with warnings", Some(&stderr));
+    }
+    if !stdout.is_empty() {
+        // Count CREATE statements to give user feedback
+        let creates = stdout.lines().filter(|l| l.starts_with("CREATE") || l.starts_with("ALTER")).count();
+        if creates > 0 {
+            emit_progress(app, clone_id, "transfer", 58, &format!("Applied {} DDL statements", creates), None);
+        }
+    }
+
+    emit_progress(app, clone_id, "transfer", 60, "Schema transferred successfully", None);
+    Ok(())
+}
+
+async fn transfer_full_clone(
+    app: &AppHandle,
+    clone_id: &str,
+    source_url: &str,
+    container_name: &str,
+    database: &str,
+    pg_version: &str,
+) -> TuskResult<()> {
+    let has_local = try_local_pg_dump().await;
+    let label = if has_local { "local pg_dump" } else { "Docker-based pg_dump" };
+    emit_progress(app, clone_id, "transfer", 50, &format!("Using {} for full clone...", label), None);
+
+    let dump_cmd = pg_dump_shell_cmd(has_local, pg_version, "-Fc", source_url);
+    let escaped_db = shell_escape(database);
+    let pipe_cmd = format!(
+        "{} | docker exec -i '{}' pg_restore -U postgres -d '{}' --no-owner",
+        dump_cmd, shell_escape(container_name), escaped_db
+    );
+
+    let output = Command::new("sh")
+        .args(["-c", &pipe_cmd])
+        .output()
+        .await
+        .map_err(|e| docker_err(format!("Full clone failed: {}", e)))?;
+
+    let stderr = String::from_utf8_lossy(&output.stderr).trim().to_string();
+
+    if !output.status.success() {
+        if stderr.contains("FATAL") || stderr.contains("could not connect") {
+            emit_progress(app, clone_id, "error", 55, "Full clone failed", Some(&stderr));
+            return Err(docker_err(format!("Full clone failed: {}", stderr)));
+        }
+    }
+
+    // pg_restore often emits warnings about ownership/permissions — log them
+    if !stderr.is_empty() {
+        emit_progress(app, clone_id, "transfer", 80, "Clone completed with warnings", Some(&stderr));
+    }
+
+    emit_progress(app, clone_id, "transfer", 85, "Full clone completed", None);
+    Ok(())
+}
+
+async fn transfer_sample_data(
+    app: &AppHandle,
+    clone_id: &str,
+    source_url: &str,
+    container_name: &str,
+    database: &str,
+    pg_version: &str,
+    sample_rows: u32,
+) -> TuskResult<()> {
+    // List tables from the target (schema already transferred)
+    let target_output = Command::new("docker")
+        .args([
+            "exec", container_name,
+            "psql", "-U", "postgres", "-d", database,
+            "-t", "-A", "-c",
+            "SELECT schemaname || '.' || tablename FROM pg_tables WHERE schemaname NOT IN ('pg_catalog', 'information_schema') ORDER BY schemaname, tablename",
+        ])
+        .output()
+        .await
+        .map_err(|e| docker_err(format!("Failed to list tables: {}", e)))?;
+
+    let tables_str = String::from_utf8_lossy(&target_output.stdout);
+    let tables: Vec<&str> = tables_str.lines().filter(|l| !l.trim().is_empty()).collect();
+    let total = tables.len();
+
+    if total == 0 {
+        emit_progress(app, clone_id, "transfer", 85, "No tables to copy data for", None);
+        return Ok(());
+    }
+
+    let has_local = try_local_pg_dump().await;
+
+    for (i, qualified_table) in tables.iter().enumerate() {
+        let pct = 65 + ((i * 20) / total.max(1)).min(20) as u8;
+        emit_progress(
+            app, clone_id, "transfer", pct,
+            &format!("Copying sample data: {} ({}/{})", qualified_table, i + 1, total),
+            None,
+        );
+
+        let parts: Vec<&str> = qualified_table.splitn(2, '.').collect();
+        if parts.len() != 2 {
+            continue;
+        }
+        let schema = parts[0];
+        let table = parts[1];
+
+        // Use COPY (SELECT ... LIMIT N) TO STDOUT piped to COPY ... FROM STDIN
+        let copy_out_sql = format!(
+            "\\copy (SELECT * FROM \\\"{}\\\".\\\"{}\\\" LIMIT {}) TO STDOUT",
+            schema, table, sample_rows
+        );
+        let copy_in_sql = format!(
+            "\\copy \\\"{}\\\".\\\"{}\\\" FROM STDIN",
+            schema, table
+        );
+
+        let escaped_url = shell_escape(source_url);
+        let escaped_container = shell_escape(container_name);
+        let escaped_db = shell_escape(database);
+
+        let source_cmd = if has_local {
+            format!("psql '{}' -c \"{}\"", escaped_url, copy_out_sql)
+        } else {
+            let image = format!("postgres:{}", pg_version);
+            format!(
+                "docker run --rm --network=host {} psql '{}' -c \"{}\"",
+                image, escaped_url, copy_out_sql
+            )
+        };
+
+        let pipe_cmd = format!(
+            "{} | docker exec -i '{}' psql -U postgres -d '{}' -c \"{}\"",
+            source_cmd, escaped_container, escaped_db, copy_in_sql
+        );
+
+        let output = Command::new("sh")
+            .args(["-c", &pipe_cmd])
+            .output()
+            .await;
+
+        match output {
+            Ok(out) => {
+                let stderr = String::from_utf8_lossy(&out.stderr).trim().to_string();
+                if !stderr.is_empty() && (stderr.contains("ERROR") || stderr.contains("FATAL")) {
+                    emit_progress(
+                        app, clone_id, "transfer", pct,
+                        &format!("Warning: {}", qualified_table),
+                        Some(&stderr),
+                    );
+                }
+            }
+            Err(e) => {
+                emit_progress(
+                    app, clone_id, "transfer", pct,
+                    &format!("Warning: failed to copy {}: {}", qualified_table, e),
+                    None,
+                );
+            }
+        }
+    }
+
+    emit_progress(app, clone_id, "transfer", 85, "Sample data transfer completed", None);
+    Ok(())
+}
+
+fn save_connection_config(app: &AppHandle, config: &ConnectionConfig) -> TuskResult<()> {
+    let path = get_connections_path(app)?;
+    let mut connections = if path.exists() {
+        let data = fs::read_to_string(&path)?;
+        serde_json::from_str::<Vec<ConnectionConfig>>(&data)?
+    } else {
+        vec![]
+    };
+
+    connections.push(config.clone());
+
+    let data = serde_json::to_string_pretty(&connections)?;
+    fs::write(&path, data)?;
+    Ok(())
+}
+
+#[tauri::command]
+pub async fn start_container(name: String) -> TuskResult<()> {
+    let output = Command::new("docker")
+        .args(["start", &name])
+        .output()
+        .await
+        .map_err(|e| docker_err(format!("Failed to start container: {}", e)))?;
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        return Err(docker_err(format!("Failed to start container: {}", stderr)));
+    }
+
+    Ok(())
+}
+
+#[tauri::command]
+pub async fn stop_container(name: String) -> TuskResult<()> {
+    let output = Command::new("docker")
+        .args(["stop", &name])
+        .output()
+        .await
+        .map_err(|e| docker_err(format!("Failed to stop container: {}", e)))?;
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        return Err(docker_err(format!("Failed to stop container: {}", stderr)));
+    }
+
+    Ok(())
+}
+
+#[tauri::command]
+pub async fn remove_container(name: String) -> TuskResult<()> {
+    let output = Command::new("docker")
+        .args(["rm", "-f", &name])
+        .output()
+        .await
+        .map_err(|e| docker_err(format!("Failed to remove container: {}", e)))?;
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        return Err(docker_err(format!("Failed to remove container: {}", stderr)));
+    }
+
+    Ok(())
+}

src-tauri/src/commands/mod.rs

@@ -1,6 +1,7 @@
 pub mod ai;
 pub mod connections;
 pub mod data;
+pub mod docker;
 pub mod export;
 pub mod history;
 pub mod lookup;

src-tauri/src/error.rs

@@ -23,6 +23,9 @@ pub enum TuskError {
     #[error("AI error: {0}")]
     Ai(String),
 
+    #[error("Docker error: {0}")]
+    Docker(String),
+
     #[error("{0}")]
     Custom(String),
 }

src-tauri/src/lib.rs

@@ -100,6 +100,13 @@ pub fn run() {
             commands::ai::fix_sql_error,
             // lookup
             commands::lookup::entity_lookup,
+            // docker
+            commands::docker::check_docker,
+            commands::docker::list_tusk_containers,
+            commands::docker::clone_to_docker,
+            commands::docker::start_container,
+            commands::docker::stop_container,
+            commands::docker::remove_container,
         ])
         .run(tauri::generate_context!())
         .expect("error while running tauri application");

src-tauri/src/models/connection.rs

@@ -16,6 +16,10 @@ pub struct ConnectionConfig {
 
 impl ConnectionConfig {
     pub fn connection_url(&self) -> String {
+        self.connection_url_for_db(&self.database)
+    }
+
+    pub fn connection_url_for_db(&self, database: &str) -> String {
         let ssl = self.ssl_mode.as_deref().unwrap_or("prefer");
         format!(
             "postgres://{}:{}@{}:{}/{}?sslmode={}",
@@ -23,7 +27,7 @@ impl ConnectionConfig {
             urlencoded(&self.password),
             self.host,
             self.port,
-            urlencoded(&self.database),
+            urlencoded(database),
             ssl
         )
     }

src-tauri/src/models/docker.rs

@@ -0,0 +1,57 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct DockerStatus {
+    pub installed: bool,
+    pub daemon_running: bool,
+    pub version: Option<String>,
+    pub error: Option<String>,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum CloneMode {
+    SchemaOnly,
+    FullClone,
+    SampleData,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct CloneToDockerParams {
+    pub source_connection_id: String,
+    pub source_database: String,
+    pub container_name: String,
+    pub pg_version: String,
+    pub host_port: Option<u16>,
+    pub clone_mode: CloneMode,
+    pub sample_rows: Option<u32>,
+    pub postgres_password: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct CloneProgress {
+    pub clone_id: String,
+    pub stage: String,
+    pub percent: u8,
+    pub message: String,
+    pub detail: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TuskContainer {
+    pub container_id: String,
+    pub name: String,
+    pub status: String,
+    pub host_port: u16,
+    pub pg_version: String,
+    pub source_database: Option<String>,
+    pub source_connection: Option<String>,
+    pub created_at: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct CloneResult {
+    pub container: TuskContainer,
+    pub connection_id: String,
+    pub connection_url: String,
+}

src-tauri/src/models/mod.rs

@@ -1,5 +1,6 @@
 pub mod ai;
 pub mod connection;
+pub mod docker;
 pub mod history;
 pub mod lookup;
 pub mod management;

src/components/docker/CloneDatabaseDialog.tsx

@@ -0,0 +1,494 @@
+import { useState, useEffect, useRef } from "react";
+import {
+  Dialog,
+  DialogContent,
+  DialogHeader,
+  DialogTitle,
+  DialogFooter,
+} from "@/components/ui/dialog";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from "@/components/ui/select";
+import { Badge } from "@/components/ui/badge";
+import { useDockerStatus, useCloneToDocker } from "@/hooks/use-docker";
+import { toast } from "sonner";
+import {
+  Loader2,
+  CheckCircle2,
+  XCircle,
+  Container,
+  Copy,
+  ChevronDown,
+  ChevronRight,
+} from "lucide-react";
+import type { CloneMode, CloneProgress } from "@/types";
+
+interface Props {
+  open: boolean;
+  onOpenChange: (open: boolean) => void;
+  connectionId: string;
+  database: string;
+  onConnect?: (connectionId: string) => void;
+}
+
+type Step = "config" | "progress" | "done";
+
+function ProcessLog({
+  entries,
+  open: logOpen,
+  onToggle,
+  endRef,
+}: {
+  entries: CloneProgress[];
+  open: boolean;
+  onToggle: () => void;
+  endRef: React.RefObject<HTMLDivElement | null>;
+}) {
+  if (entries.length === 0) return null;
+
+  return (
+    <div>
+      <button
+        type="button"
+        className="flex items-center gap-1 text-xs text-muted-foreground hover:text-foreground transition-colors"
+        onClick={onToggle}
+      >
+        {logOpen ? (
+          <ChevronDown className="h-3 w-3" />
+        ) : (
+          <ChevronRight className="h-3 w-3" />
+        )}
+        Process Log ({entries.length})
+      </button>
+      {logOpen && (
+        <div className="mt-1.5 rounded-md bg-muted p-3 text-xs font-mono max-h-40 overflow-y-auto">
+          {entries.map((entry, i) => (
+            <div key={i} className="flex gap-2 leading-5">
+              <span className="text-muted-foreground shrink-0 w-8 text-right">
+                {entry.percent}%
+              </span>
+              <span>{entry.message}</span>
+              {entry.detail && (
+                <span className="text-muted-foreground truncate">
+                  — {entry.detail}
+                </span>
+              )}
+            </div>
+          ))}
+          <div ref={endRef} />
+        </div>
+      )}
+    </div>
+  );
+}
+
+export function CloneDatabaseDialog({
+  open,
+  onOpenChange,
+  connectionId,
+  database,
+  onConnect,
+}: Props) {
+  const [step, setStep] = useState<Step>("config");
+  const [containerName, setContainerName] = useState("");
+  const [pgVersion, setPgVersion] = useState("16");
+  const [portMode, setPortMode] = useState<"auto" | "manual">("auto");
+  const [manualPort, setManualPort] = useState(5433);
+  const [cloneMode, setCloneMode] = useState<CloneMode>("schema_only");
+  const [sampleRows, setSampleRows] = useState(1000);
+
+  const [logEntries, setLogEntries] = useState<CloneProgress[]>([]);
+  const [logOpen, setLogOpen] = useState(false);
+  const logEndRef = useRef<HTMLDivElement>(null);
+
+  const { data: dockerStatus } = useDockerStatus();
+  const { clone, result, error, isCloning, progress, reset } =
+    useCloneToDocker();
+
+  // Reset state when dialog opens
+  useEffect(() => {
+    if (open) {
+      setStep("config");
+      setContainerName(
+        `tusk-${database.replace(/[^a-zA-Z0-9_-]/g, "-")}-${Date.now().toString(36)}`
+      );
+      setPgVersion("16");
+      setPortMode("auto");
+      setManualPort(5433);
+      setCloneMode("schema_only");
+      setSampleRows(1000);
+      setLogEntries([]);
+      setLogOpen(false);
+      reset();
+    }
+  }, [open, database, reset]);
+
+  // Accumulate progress events into log
+  useEffect(() => {
+    if (progress) {
+      setLogEntries((prev) => {
+        const last = prev[prev.length - 1];
+        if (last && last.stage === progress.stage && last.message === progress.message) {
+          return prev;
+        }
+        return [...prev, progress];
+      });
+      if (progress.stage === "done" || progress.stage === "error") {
+        setStep("done");
+      }
+    }
+  }, [progress]);
+
+  // Auto-scroll log to bottom
+  useEffect(() => {
+    if (logOpen && logEndRef.current) {
+      logEndRef.current.scrollIntoView({ behavior: "smooth" });
+    }
+  }, [logEntries, logOpen]);
+
+  const handleClone = () => {
+    if (!containerName.trim()) {
+      toast.error("Container name is required");
+      return;
+    }
+
+    setStep("progress");
+
+    const cloneId = crypto.randomUUID();
+    clone({
+      params: {
+        source_connection_id: connectionId,
+        source_database: database,
+        container_name: containerName.trim(),
+        pg_version: pgVersion,
+        host_port: portMode === "manual" ? manualPort : null,
+        clone_mode: cloneMode,
+        sample_rows: cloneMode === "sample_data" ? sampleRows : null,
+        postgres_password: null,
+      },
+      cloneId,
+    });
+  };
+
+  const handleConnect = () => {
+    if (result?.connection_id && onConnect) {
+      onConnect(result.connection_id);
+    }
+    onOpenChange(false);
+  };
+
+  const dockerReady =
+    dockerStatus?.installed && dockerStatus?.daemon_running;
+
+  const logSection = (
+    <ProcessLog
+      entries={logEntries}
+      open={logOpen}
+      onToggle={() => setLogOpen(!logOpen)}
+      endRef={logEndRef}
+    />
+  );
+
+  return (
+    <Dialog open={open} onOpenChange={onOpenChange}>
+      <DialogContent className="sm:max-w-[520px]">
+        <DialogHeader>
+          <DialogTitle className="flex items-center gap-2">
+            <Container className="h-5 w-5" />
+            Clone to Docker
+          </DialogTitle>
+        </DialogHeader>
+
+        {step === "config" && (
+          <>
+            <div className="flex items-center gap-2 rounded-md border px-3 py-2 text-sm">
+              {dockerStatus === undefined ? (
+                <>
+                  <Loader2 className="h-4 w-4 animate-spin text-muted-foreground" />
+                  <span className="text-muted-foreground">
+                    Checking Docker...
+                  </span>
+                </>
+              ) : dockerReady ? (
+                <>
+                  <CheckCircle2 className="h-4 w-4 text-green-500" />
+                  <span>Docker {dockerStatus.version}</span>
+                </>
+              ) : (
+                <>
+                  <XCircle className="h-4 w-4 text-destructive" />
+                  <span className="text-destructive">
+                    {dockerStatus?.error || "Docker not available"}
+                  </span>
+                </>
+              )}
+            </div>
+
+            <div className="grid gap-3 py-2">
+              <div className="grid grid-cols-4 items-center gap-3">
+                <label className="text-right text-sm text-muted-foreground">
+                  Database
+                </label>
+                <div className="col-span-3">
+                  <Badge variant="secondary">{database}</Badge>
+                </div>
+              </div>
+
+              <div className="grid grid-cols-4 items-center gap-3">
+                <label className="text-right text-sm text-muted-foreground">
+                  Container
+                </label>
+                <Input
+                  className="col-span-3"
+                  value={containerName}
+                  onChange={(e) => setContainerName(e.target.value)}
+                  placeholder="tusk-mydb-clone"
+                />
+              </div>
+
+              <div className="grid grid-cols-4 items-center gap-3">
+                <label className="text-right text-sm text-muted-foreground">
+                  PG Version
+                </label>
+                <Select value={pgVersion} onValueChange={setPgVersion}>
+                  <SelectTrigger className="col-span-3">
+                    <SelectValue />
+                  </SelectTrigger>
+                  <SelectContent>
+                    <SelectItem value="17">PostgreSQL 17</SelectItem>
+                    <SelectItem value="16">PostgreSQL 16</SelectItem>
+                    <SelectItem value="15">PostgreSQL 15</SelectItem>
+                    <SelectItem value="14">PostgreSQL 14</SelectItem>
+                  </SelectContent>
+                </Select>
+              </div>
+
+              <div className="grid grid-cols-4 items-center gap-3">
+                <label className="text-right text-sm text-muted-foreground">
+                  Port
+                </label>
+                <div className="col-span-3 flex items-center gap-2">
+                  <Select
+                    value={portMode}
+                    onValueChange={(v) =>
+                      setPortMode(v as "auto" | "manual")
+                    }
+                  >
+                    <SelectTrigger className="w-24">
+                      <SelectValue />
+                    </SelectTrigger>
+                    <SelectContent>
+                      <SelectItem value="auto">Auto</SelectItem>
+                      <SelectItem value="manual">Manual</SelectItem>
+                    </SelectContent>
+                  </Select>
+                  {portMode === "manual" && (
+                    <Input
+                      type="number"
+                      className="flex-1"
+                      value={manualPort}
+                      onChange={(e) =>
+                        setManualPort(parseInt(e.target.value) || 5433)
+                      }
+                      min={1024}
+                      max={65535}
+                    />
+                  )}
+                </div>
+              </div>
+
+              <div className="grid grid-cols-4 items-center gap-3">
+                <label className="text-right text-sm text-muted-foreground">
+                  Clone Mode
+                </label>
+                <Select
+                  value={cloneMode}
+                  onValueChange={(v) => setCloneMode(v as CloneMode)}
+                >
+                  <SelectTrigger className="col-span-3">
+                    <SelectValue />
+                  </SelectTrigger>
+                  <SelectContent>
+                    <SelectItem value="schema_only">
+                      Schema Only
+                    </SelectItem>
+                    <SelectItem value="full_clone">Full Clone</SelectItem>
+                    <SelectItem value="sample_data">
+                      Sample Data
+                    </SelectItem>
+                  </SelectContent>
+                </Select>
+              </div>
+
+              {cloneMode === "sample_data" && (
+                <div className="grid grid-cols-4 items-center gap-3">
+                  <label className="text-right text-sm text-muted-foreground">
+                    Sample Rows
+                  </label>
+                  <Input
+                    className="col-span-3"
+                    type="number"
+                    value={sampleRows}
+                    onChange={(e) =>
+                      setSampleRows(parseInt(e.target.value) || 1000)
+                    }
+                    min={1}
+                    max={100000}
+                  />
+                </div>
+              )}
+            </div>
+
+            <DialogFooter>
+              <Button
+                variant="outline"
+                onClick={() => onOpenChange(false)}
+              >
+                Cancel
+              </Button>
+              <Button onClick={handleClone} disabled={!dockerReady}>
+                Clone
+              </Button>
+            </DialogFooter>
+          </>
+        )}
+
+        {step === "progress" && (
+          <div className="py-4 space-y-4">
+            <div className="space-y-2">
+              <div className="flex items-center justify-between text-sm">
+                <span>{progress?.message || "Starting..."}</span>
+                <span className="text-muted-foreground">
+                  {progress?.percent ?? 0}%
+                </span>
+              </div>
+              <div className="h-2 rounded-full bg-secondary overflow-hidden">
+                <div
+                  className="h-full rounded-full bg-primary transition-all duration-300"
+                  style={{ width: `${progress?.percent ?? 0}%` }}
+                />
+              </div>
+            </div>
+
+            {isCloning && (
+              <div className="flex items-center gap-2 text-sm text-muted-foreground">
+                <Loader2 className="h-4 w-4 animate-spin" />
+                {progress?.stage || "Initializing..."}
+              </div>
+            )}
+
+            {logSection}
+          </div>
+        )}
+
+        {step === "done" && (
+          <div className="py-4 space-y-4">
+            {error ? (
+              <div className="flex items-start gap-3 rounded-md border border-destructive/50 bg-destructive/10 p-4">
+                <XCircle className="h-5 w-5 text-destructive shrink-0 mt-0.5" />
+                <div className="space-y-1">
+                  <p className="text-sm font-medium text-destructive">
+                    Clone Failed
+                  </p>
+                  <p className="text-xs text-muted-foreground">{error}</p>
+                </div>
+              </div>
+            ) : (
+              <div className="space-y-3">
+                <div className="flex items-start gap-3 rounded-md border border-green-500/50 bg-green-500/10 p-4">
+                  <CheckCircle2 className="h-5 w-5 text-green-500 shrink-0 mt-0.5" />
+                  <div className="space-y-1">
+                    <p className="text-sm font-medium">
+                      Clone Completed
+                    </p>
+                    <p className="text-xs text-muted-foreground">
+                      Database cloned to Docker container successfully.
+                    </p>
+                  </div>
+                </div>
+
+                {result && (
+                  <div className="rounded-md border p-3 space-y-2 text-sm">
+                    <div className="flex items-center justify-between">
+                      <span className="text-muted-foreground">
+                        Container
+                      </span>
+                      <span className="font-mono">
+                        {result.container.name}
+                      </span>
+                    </div>
+                    <div className="flex items-center justify-between">
+                      <span className="text-muted-foreground">Port</span>
+                      <span className="font-mono">
+                        {result.container.host_port}
+                      </span>
+                    </div>
+                    <div className="flex items-center justify-between gap-2">
+                      <span className="text-muted-foreground">URL</span>
+                      <div className="flex items-center gap-1">
+                        <span className="font-mono text-xs truncate max-w-[250px]">
+                          {result.connection_url}
+                        </span>
+                        <Button
+                          variant="ghost"
+                          size="sm"
+                          className="h-6 w-6 p-0"
+                          onClick={() => {
+                            navigator.clipboard.writeText(
+                              result.connection_url
+                            );
+                            toast.success("URL copied");
+                          }}
+                        >
+                          <Copy className="h-3 w-3" />
+                        </Button>
+                      </div>
+                    </div>
+                  </div>
+                )}
+              </div>
+            )}
+
+            {logSection}
+
+            <DialogFooter>
+              {error ? (
+                <>
+                  <Button
+                    variant="outline"
+                    onClick={() => onOpenChange(false)}
+                  >
+                    Close
+                  </Button>
+                  <Button
+                    onClick={() => setStep("config")}
+                  >
+                    Retry
+                  </Button>
+                </>
+              ) : (
+                <>
+                  <Button
+                    variant="outline"
+                    onClick={() => onOpenChange(false)}
+                  >
+                    Close
+                  </Button>
+                  {onConnect && result && (
+                    <Button onClick={handleConnect}>Connect</Button>
+                  )}
+                </>
+              )}
+            </DialogFooter>
+          </div>
+        )}
+      </DialogContent>
+    </Dialog>
+  );
+}

src/components/docker/DockerContainersList.tsx

@@ -0,0 +1,179 @@
+import { useState } from "react";
+import {
+  useTuskContainers,
+  useStartContainer,
+  useStopContainer,
+  useRemoveContainer,
+  useDockerStatus,
+} from "@/hooks/use-docker";
+import { Button } from "@/components/ui/button";
+import { Badge } from "@/components/ui/badge";
+import { toast } from "sonner";
+import {
+  ChevronDown,
+  ChevronRight,
+  Container,
+  Play,
+  Square,
+  Trash2,
+  Loader2,
+} from "lucide-react";
+
+export function DockerContainersList() {
+  const [expanded, setExpanded] = useState(true);
+  const { data: dockerStatus } = useDockerStatus();
+  const { data: containers, isLoading } = useTuskContainers();
+  const startMutation = useStartContainer();
+  const stopMutation = useStopContainer();
+  const removeMutation = useRemoveContainer();
+
+  const dockerAvailable =
+    dockerStatus?.installed && dockerStatus?.daemon_running;
+
+  if (!dockerAvailable) {
+    return null;
+  }
+
+  const handleStart = (name: string) => {
+    startMutation.mutate(name, {
+      onSuccess: () => toast.success(`Container "${name}" started`),
+      onError: (err) =>
+        toast.error("Failed to start container", {
+          description: String(err),
+        }),
+    });
+  };
+
+  const handleStop = (name: string) => {
+    stopMutation.mutate(name, {
+      onSuccess: () => toast.success(`Container "${name}" stopped`),
+      onError: (err) =>
+        toast.error("Failed to stop container", {
+          description: String(err),
+        }),
+    });
+  };
+
+  const handleRemove = (name: string) => {
+    if (
+      !confirm(
+        `Remove container "${name}"? This will delete the container and all its data.`
+      )
+    ) {
+      return;
+    }
+    removeMutation.mutate(name, {
+      onSuccess: () => toast.success(`Container "${name}" removed`),
+      onError: (err) =>
+        toast.error("Failed to remove container", {
+          description: String(err),
+        }),
+    });
+  };
+
+  const isRunning = (status: string) =>
+    status.toLowerCase().startsWith("up");
+
+  return (
+    <div className="border-b">
+      <div
+        className="flex items-center gap-1 px-3 py-2 cursor-pointer select-none hover:bg-accent/50"
+        onClick={() => setExpanded(!expanded)}
+      >
+        {expanded ? (
+          <ChevronDown className="h-3.5 w-3.5 text-muted-foreground" />
+        ) : (
+          <ChevronRight className="h-3.5 w-3.5 text-muted-foreground" />
+        )}
+        <Container className="h-3.5 w-3.5 text-muted-foreground" />
+        <span className="text-xs font-semibold flex-1">Docker Clones</span>
+        {containers && containers.length > 0 && (
+          <Badge
+            variant="secondary"
+            className="text-[9px] px-1 py-0"
+          >
+            {containers.length}
+          </Badge>
+        )}
+      </div>
+
+      {expanded && (
+        <div className="pb-1">
+          {isLoading && (
+            <div className="px-3 py-2 text-xs text-muted-foreground flex items-center gap-1">
+              <Loader2 className="h-3 w-3 animate-spin" /> Loading...
+            </div>
+          )}
+          {containers && containers.length === 0 && (
+            <div className="px-6 pb-2 text-xs text-muted-foreground">
+              No Docker clones yet. Right-click a database to clone it.
+            </div>
+          )}
+          {containers?.map((container) => (
+            <div
+              key={container.container_id}
+              className="group flex items-center gap-1.5 px-6 py-1 text-xs hover:bg-accent/50"
+            >
+              <span className="truncate flex-1 font-medium">
+                {container.name}
+              </span>
+              {container.source_database && (
+                <span className="text-[10px] text-muted-foreground shrink-0">
+                  {container.source_database}
+                </span>
+              )}
+              <span className="text-[10px] text-muted-foreground shrink-0">
+                :{container.host_port}
+              </span>
+              <Badge
+                variant={isRunning(container.status) ? "default" : "secondary"}
+                className={`text-[9px] px-1 py-0 shrink-0 ${
+                  isRunning(container.status)
+                    ? "bg-green-600 hover:bg-green-600"
+                    : ""
+                }`}
+              >
+                {isRunning(container.status) ? "running" : "stopped"}
+              </Badge>
+              <div className="flex gap-0.5 opacity-0 group-hover:opacity-100 shrink-0">
+                {isRunning(container.status) ? (
+                  <Button
+                    variant="ghost"
+                    size="sm"
+                    className="h-5 w-5 p-0"
+                    onClick={() => handleStop(container.name)}
+                    title="Stop"
+                    disabled={stopMutation.isPending}
+                  >
+                    <Square className="h-3 w-3" />
+                  </Button>
+                ) : (
+                  <Button
+                    variant="ghost"
+                    size="sm"
+                    className="h-5 w-5 p-0"
+                    onClick={() => handleStart(container.name)}
+                    title="Start"
+                    disabled={startMutation.isPending}
+                  >
+                    <Play className="h-3 w-3" />
+                  </Button>
+                )}
+                <Button
+                  variant="ghost"
+                  size="sm"
+                  className="h-5 w-5 p-0 text-destructive hover:text-destructive"
+                  onClick={() => handleRemove(container.name)}
+                  title="Remove"
+                  disabled={removeMutation.isPending}
+                >
+                  <Trash2 className="h-3 w-3" />
+                </Button>
+              </div>
+            </div>
+          ))}
+        </div>
+      )}
+    </div>
+  );
+}

src/components/management/AdminPanel.tsx

@@ -23,6 +23,7 @@ import {
   Activity,
   Loader2,
 } from "lucide-react";
+import { DockerContainersList } from "@/components/docker/DockerContainersList";
 import type { Tab, RoleInfo } from "@/types";
 
 export function AdminPanel() {
@@ -72,6 +73,7 @@ export function AdminPanel() {
           addTab(tab);
         }}
       />
+      <DockerContainersList />
     </div>
   );
 }

src/components/schema/SchemaTree.tsx

@@ -31,6 +31,7 @@ import {
   ContextMenuTrigger,
 } from "@/components/ui/context-menu";
 import { GrantRevokeDialog } from "@/components/management/GrantRevokeDialog";
+import { CloneDatabaseDialog } from "@/components/docker/CloneDatabaseDialog";
 import type { Tab, SchemaObject } from "@/types";
 
 function formatSize(bytes: number): string {
@@ -65,6 +66,7 @@ export function SchemaTree() {
   const { data: databases } = useDatabases(activeConnectionId);
   const { data: connections } = useConnections();
   const switchDbMutation = useSwitchDatabase();
+  const [cloneTarget, setCloneTarget] = useState<string | null>(null);
 
   if (!activeConnectionId) {
     return (
@@ -112,6 +114,7 @@ export function SchemaTree() {
           connectionId={activeConnectionId}
           onSwitch={() => handleSwitchDb(db)}
           isSwitching={switchDbMutation.isPending}
+          onCloneToDocker={(dbName) => setCloneTarget(dbName)}
           onOpenTable={(schema, table) => {
             const tab: Tab = {
               id: crypto.randomUUID(),
@@ -149,6 +152,12 @@ export function SchemaTree() {
           }}
         />
       ))}
+      <CloneDatabaseDialog
+        open={cloneTarget !== null}
+        onOpenChange={(open) => { if (!open) setCloneTarget(null); }}
+        connectionId={activeConnectionId}
+        database={cloneTarget ?? ""}
+      />
     </div>
   );
 }
@@ -159,6 +168,7 @@ function DatabaseNode({
   connectionId,
   onSwitch,
   isSwitching,
+  onCloneToDocker,
   onOpenTable,
   onViewStructure,
   onViewErd,
@@ -168,6 +178,7 @@ function DatabaseNode({
   connectionId: string;
   onSwitch: () => void;
   isSwitching: boolean;
+  onCloneToDocker: (dbName: string) => void;
   onOpenTable: (schema: string, table: string) => void;
   onViewStructure: (schema: string, table: string) => void;
   onViewErd: (schema: string) => void;
@@ -231,6 +242,9 @@ function DatabaseNode({
           >
             Properties
           </ContextMenuItem>
+          <ContextMenuItem onClick={() => onCloneToDocker(name)}>
+            Clone to Docker
+          </ContextMenuItem>
           <ContextMenuSeparator />
           <ContextMenuItem
             disabled={isActive || isReadOnly}

src/hooks/use-docker.ts

@@ -0,0 +1,111 @@
+import { useState, useEffect, useCallback, useRef } from "react";
+import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
+import {
+  checkDocker,
+  listTuskContainers,
+  cloneToDocker,
+  startContainer,
+  stopContainer,
+  removeContainer,
+  onCloneProgress,
+} from "@/lib/tauri";
+import type { CloneToDockerParams, CloneProgress, CloneResult } from "@/types";
+
+export function useDockerStatus() {
+  return useQuery({
+    queryKey: ["docker-status"],
+    queryFn: checkDocker,
+    staleTime: 30_000,
+  });
+}
+
+export function useTuskContainers() {
+  return useQuery({
+    queryKey: ["tusk-containers"],
+    queryFn: listTuskContainers,
+    refetchInterval: 10_000,
+  });
+}
+
+export function useCloneToDocker() {
+  const [progress, setProgress] = useState<CloneProgress | null>(null);
+  const cloneIdRef = useRef<string>("");
+  const queryClient = useQueryClient();
+
+  const mutation = useMutation({
+    mutationFn: ({
+      params,
+      cloneId,
+    }: {
+      params: CloneToDockerParams;
+      cloneId: string;
+    }) => {
+      cloneIdRef.current = cloneId;
+      setProgress(null);
+      return cloneToDocker(params, cloneId);
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["connections"] });
+      queryClient.invalidateQueries({ queryKey: ["tusk-containers"] });
+    },
+  });
+
+  useEffect(() => {
+    const unlistenPromise = onCloneProgress((p) => {
+      if (p.clone_id === cloneIdRef.current) {
+        setProgress(p);
+      }
+    });
+    return () => {
+      unlistenPromise.then((unlisten) => unlisten());
+    };
+  }, []);
+
+  const mutationRef = useRef(mutation);
+  mutationRef.current = mutation;
+
+  const reset = useCallback(() => {
+    mutationRef.current.reset();
+    setProgress(null);
+    cloneIdRef.current = "";
+  }, []);
+
+  return {
+    clone: mutation.mutate,
+    result: mutation.data as CloneResult | undefined,
+    error: mutation.error ? String(mutation.error) : null,
+    isCloning: mutation.isPending,
+    progress,
+    reset,
+  };
+}
+
+export function useStartContainer() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (name: string) => startContainer(name),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["tusk-containers"] });
+    },
+  });
+}
+
+export function useStopContainer() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (name: string) => stopContainer(name),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["tusk-containers"] });
+    },
+  });
+}
+
+export function useRemoveContainer() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (name: string) => removeContainer(name),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["tusk-containers"] });
+    },
+  });
+}

src/lib/tauri.ts

@@ -28,6 +28,11 @@ import type {
   OllamaModel,
   EntityLookupResult,
   LookupProgress,
+  DockerStatus,
+  CloneToDockerParams,
+  CloneProgress,
+  CloneResult,
+  TuskContainer,
 } from "@/types";
 
 // Connections
@@ -291,3 +296,27 @@ export const onLookupProgress = (
   callback: (p: LookupProgress) => void
 ): Promise<UnlistenFn> =>
   listen<LookupProgress>("lookup-progress", (e) => callback(e.payload));
+
+// Docker
+export const checkDocker = () =>
+  invoke<DockerStatus>("check_docker");
+
+export const listTuskContainers = () =>
+  invoke<TuskContainer[]>("list_tusk_containers");
+
+export const cloneToDocker = (params: CloneToDockerParams, cloneId: string) =>
+  invoke<CloneResult>("clone_to_docker", { params, cloneId });
+
+export const startContainer = (name: string) =>
+  invoke<void>("start_container", { name });
+
+export const stopContainer = (name: string) =>
+  invoke<void>("stop_container", { name });
+
+export const removeContainer = (name: string) =>
+  invoke<void>("remove_container", { name });
+
+export const onCloneProgress = (
+  callback: (p: CloneProgress) => void
+): Promise<UnlistenFn> =>
+  listen<CloneProgress>("clone-progress", (e) => callback(e.payload));

src/types/index.ts

@@ -323,6 +323,52 @@ export interface ErdData {
   relationships: ErdRelationship[];
 }
 
+// Docker
+export interface DockerStatus {
+  installed: boolean;
+  daemon_running: boolean;
+  version: string | null;
+  error: string | null;
+}
+
+export type CloneMode = "schema_only" | "full_clone" | "sample_data";
+
+export interface CloneToDockerParams {
+  source_connection_id: string;
+  source_database: string;
+  container_name: string;
+  pg_version: string;
+  host_port: number | null;
+  clone_mode: CloneMode;
+  sample_rows: number | null;
+  postgres_password: string | null;
+}
+
+export interface CloneProgress {
+  clone_id: string;
+  stage: string;
+  percent: number;
+  message: string;
+  detail: string | null;
+}
+
+export interface TuskContainer {
+  container_id: string;
+  name: string;
+  status: string;
+  host_port: number;
+  pg_version: string;
+  source_database: string | null;
+  source_connection: string | null;
+  created_at: string | null;
+}
+
+export interface CloneResult {
+  container: TuskContainer;
+  connection_id: string;
+  connection_url: string;
+}
+
 export type TabType = "query" | "table" | "structure" | "roles" | "sessions" | "lookup" | "erd";
 
 export interface Tab {