feat(cli): restart command (#839)

<!-- greptile_comment -->

<h2>Greptile Overview</h2>

<h3>Greptile Summary</h3>

This PR adds a new `restart` command to the Helix CLI that stops and
starts database instances (both local Docker-based and cloud Fly.io
instances). The implementation follows existing patterns from `start`
and `stop` commands with proper error handling, progress tracking, and
instance validation.

Key changes:
- **restart.rs**: New command handler with local/cloud branching logic
- **docker.rs**: Added `restart_instance()` method using `docker compose
restart`
- **Testing**: Comprehensive lifecycle tests and CI workflow for
cross-platform testing
- **Data dir fix**: Changed `HELIX_DATA_DIR` to `/data` for consistent
container paths

The restart command properly validates instance existence, checks for
build artifacts, and handles both Docker/Podman runtimes. Cloud restart
uses stop+start sequence via FlyManager. Test infrastructure includes
isolated temp directories via `HELIX_CACHE_DIR` override.

<details><summary><h3>Important Files Changed</h3></summary>




| Filename | Overview |
|----------|----------|
| helix-cli/src/commands/restart.rs | New restart command following
established patterns. Handles local Docker restart efficiently and cloud
Fly.io restart via stop+start. Minor style inconsistency with
todo!/unimplemented! macros. |
| helix-cli/src/docker.rs | Added restart_instance() method using docker
compose restart. Changed HELIX_DATA_DIR to static /data for container
consistency (intentional improvement). |
| helix-cli/src/project.rs | Added HELIX_CACHE_DIR environment variable
override for test isolation, properly documented and implemented. |
| helix-cli/src/tests/lifecycle_tests.rs | Comprehensive lifecycle
command tests covering error paths for start/stop/restart without
Docker. Well-structured with clear test categories. |
| .github/workflows/cli_tests.yml | New CI workflow for cross-platform
CLI testing (Ubuntu/macOS/Windows). Includes cargo caching and runs both
unit and integration tests. |

</details>


</details>


<details><summary><h3>Sequence Diagram</h3></summary>

```mermaid
sequenceDiagram
    participant User
    participant CLI as restart::run()
    participant Project as ProjectContext
    participant Docker as DockerManager
    participant Fly as FlyManager
    participant Container as Docker/Podman

    User->>CLI: helix restart [instance]
    CLI->>Project: find_and_load()
    Project-->>CLI: project context
    
    alt No instance provided & non-interactive
        CLI->>CLI: list_instances()
        CLI-->>User: Error: Available instances
    end
    
    CLI->>Project: get_instance(name)
    Project-->>CLI: instance_config
    
    alt Local Instance
        CLI->>Docker: new(project)
        CLI->>Docker: check_runtime_available()
        Docker-->>CLI: runtime OK
        CLI->>CLI: Check docker-compose.yml exists
        alt Compose file missing
            CLI-->>User: Error: Not built yet
        end
        CLI->>Docker: restart_instance(name)
        Docker->>Container: docker compose restart
        Container-->>Docker: success
        Docker-->>CLI: OK
        CLI-->>User: Container restarted
    else Cloud Instance (Fly.io)
        CLI->>CLI: Validate cluster_id
        CLI->>Fly: new(project, auth_type)
        Fly-->>CLI: fly manager
        CLI->>Fly: stop_instance(name)
        Fly->>Fly: flyctl scale count 0
        Fly-->>CLI: stopped
        CLI->>Fly: start_instance(name)
        Fly->>Fly: flyctl scale count 1
        Fly-->>CLI: started
        CLI-->>User: Cloud instance restarted
    end
```
</details>


<!-- greptile_other_comments_section -->

<!-- /greptile_comment -->

Author: xav-db

.github/workflows/cli_tests.yml

@@ -0,0 +1,58 @@
+# name: CLI Tests
+
+# on:
+#   pull_request:
+#     branches: [main, dev]
+#     paths:
+#       - 'helix-cli/**'
+#       - 'helix-macros/**'
+#       - 'helix-container/**'
+#       - 'helix-db/**'
+#       - 'Cargo.toml'
+#       - 'Cargo.lock'
+
+# env:
+#   CARGO_TERM_COLOR: always
+#   RUST_BACKTRACE: 1
+
+# jobs:
+#   test:
+#     name: Test (${{ matrix.os }})
+#     runs-on: ${{ matrix.os }}
+#     strategy:
+#       fail-fast: false
+#       matrix:
+#         os: [ubuntu-latest, macos-latest, windows-latest]
+
+#     steps:
+#       - name: Checkout repository
+#         uses: actions/checkout@v4
+
+#       - name: Setup Rust toolchain
+#         uses: dtolnay/rust-toolchain@stable
+
+#       - name: Cache cargo registry
+#         uses: actions/cache@v4
+#         with:
+#           path: |
+#             ~/.cargo/registry
+#             ~/.cargo/git
+#             target
+#           key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+#           restore-keys: |
+#             ${{ runner.os }}-cargo-
+
+#       - name: Run helix-cli unit tests
+#         run: cargo test --release --package helix-cli
+#         env:
+#           # Use a unique temp directory for test isolation
+#           HELIX_CACHE_DIR: ${{ runner.temp }}/helix-test-cache-${{ github.run_id }}
+
+#       - name: Run helix-macros tests
+#         run: cargo test --release --package helix-macros
+
+#       # Integration tests that require repo cloning run serially
+#       - name: Run helix-cli integration tests (ignored tests)
+#         run: cargo test --release --package helix-cli -- --ignored --test-threads=1
+#         env:
+#           HELIX_CACHE_DIR: ${{ runner.temp }}/helix-test-cache-ignored-${{ github.run_id }}

.github/workflows/db_tests.yml

@@ -3,6 +3,11 @@ name: Core Database Tests
 on:
   pull_request:
     branches: [ main, dev ]
+    paths:
+      - 'helix-macros/**'
+      - 'helix-db/**'
+      - 'Cargo.toml'
+      - 'Cargo.lock'
 
 jobs:
   test:

.github/workflows/dev_instance_tests.yml

@@ -3,6 +3,12 @@ name: Core Database Tests In Dev Instance Mode
 on:
   pull_request:
     branches: [ main, dev ]
+    paths:
+      - 'helix-macros/**'
+      - 'helix-db/**'
+      - 'Cargo.toml'
+      - 'Cargo.lock'
+
 
 jobs:
   test:

.github/workflows/hql_tests.yml

@@ -3,6 +3,9 @@ name: HQL Tests
 on:
   pull_request:
     branches: [main, dev]
+    paths:
+      - 'helix-macros/**'
+      - 'helix-db/**'
 
 jobs:
   hql-tests:

.github/workflows/production_db_tests.yml

@@ -3,6 +3,11 @@ name: Core Database Tests In Production Mode
 on:
   pull_request:
     branches: [ main, dev ]
+    paths:
+      - 'helix-macros/**'
+      - 'helix-db/**'
+      - 'Cargo.toml'
+      - 'Cargo.lock'
 
 jobs:
   test:

Cargo.lock

@@ -36,6 +36,7 @@ crossterm = "0.28"
 
 [dev-dependencies]
 tempfile = "3.23.0"
+serial_test = "3.2"
 
 [lib]
 name = "helix_cli"

helix-cli/Cargo.toml

@@ -7,9 +7,9 @@ export PATH="$HOME/.cargo/bin:$PATH"
 
 # if dev profile, build with dev profile
 if [ "$1" = "dev" ]; then
-    cargo install --profile dev --force --path . --root ~/.local
+    cargo install --debug --force --path . --root ~/.local
 else
-    cargo install --release --force --path . --root ~/.local
+    cargo install --force --path . --root ~/.local
 fi
 
 if ! echo "$PATH" | grep -q "$HOME/.local/bin"; then

helix-cli/build.sh

@@ -16,6 +16,7 @@ pub mod migrate;
 pub mod prune;
 pub mod pull;
 pub mod push;
+pub mod restart;
 pub mod start;
 pub mod status;
 pub mod stop;

helix-cli/src/commands/mod.rs

@@ -0,0 +1,113 @@
+use crate::commands::integrations::fly::FlyManager;
+use crate::config::CloudConfig;
+use crate::docker::DockerManager;
+use crate::output::{Operation, Step};
+use crate::project::ProjectContext;
+use crate::prompts;
+use eyre::{OptionExt, Result};
+
+pub async fn run(instance_name: Option<String>) -> Result<()> {
+    // Load project context
+    let project = ProjectContext::find_and_load(None)?;
+
+    // Get instance name - prompt if not provided
+    let instance_name = match instance_name {
+        Some(name) => name,
+        None if prompts::is_interactive() => {
+            let instances = project.config.list_instances_with_types();
+            prompts::select_instance(&instances)?
+        }
+        None => {
+            let instances = project.config.list_instances();
+            return Err(eyre::eyre!(
+                "No instance specified. Available instances: {}",
+                instances
+                    .into_iter()
+                    .cloned()
+                    .collect::<Vec<_>>()
+                    .join(", ")
+            ));
+        }
+    };
+
+    // Get instance config
+    let instance_config = project.config.get_instance(&instance_name)?;
+
+    if instance_config.is_local() {
+        restart_local_instance(&project, &instance_name).await
+    } else {
+        restart_cloud_instance(&project, &instance_name, instance_config.into()).await
+    }
+}
+
+async fn restart_local_instance(project: &ProjectContext, instance_name: &str) -> Result<()> {
+    let op = Operation::new("Restarting", instance_name);
+
+    let docker = DockerManager::new(project);
+
+    // Check Docker availability
+    DockerManager::check_runtime_available(docker.runtime)?;
+
+    // Check if instance is built (has docker-compose.yml)
+    let workspace = project.instance_workspace(instance_name);
+    let compose_file = workspace.join("docker-compose.yml");
+
+    if !compose_file.exists() {
+        op.failure();
+        let error = crate::errors::CliError::new(format!(
+            "instance '{instance_name}' has not been built yet"
+        ))
+        .with_hint(format!(
+            "run 'helix build {instance_name}' first to build the instance"
+        ));
+        return Err(eyre::eyre!("{}", error.render()));
+    }
+
+    // Restart the instance
+    let mut restart_step = Step::with_messages("Restarting container", "Container restarted");
+    restart_step.start();
+    docker.restart_instance(instance_name)?;
+    restart_step.done();
+
+    op.success();
+
+    Ok(())
+}
+
+async fn restart_cloud_instance(
+    project: &ProjectContext,
+    instance_name: &str,
+    instance_config: CloudConfig,
+) -> Result<()> {
+    let op = Operation::new("Restarting", instance_name);
+
+    let _cluster_id = instance_config.get_cluster_id().ok_or_eyre(format!(
+        "Cloud instance '{instance_name}' must have a cluster_id"
+    ))?;
+
+    let mut restart_step =
+        Step::with_messages("Restarting cloud instance", "Cloud instance restarted");
+    restart_step.start();
+
+    match instance_config {
+        CloudConfig::FlyIo(config) => {
+            Step::verbose_substep("Stopping Fly.io instance...");
+            let fly = FlyManager::new(project, config.auth_type.clone()).await?;
+            fly.stop_instance(instance_name).await?;
+
+            Step::verbose_substep("Starting Fly.io instance...");
+            fly.start_instance(instance_name).await?;
+        }
+        CloudConfig::Helix(_config) => {
+            todo!()
+        }
+        CloudConfig::Ecr(_config) => {
+            unimplemented!()
+        }
+    }
+
+    restart_step.done();
+    op.success();
+
+    Ok(())
+}