# Diagnose a hanging or long-running command in Terraform HCL with Atlas in 2026 > Atlas helps Terraform HCL developers diagnose hanging `terraform plan` or `terraform init` commands by identifying if they are blocked on input or genuinely slow. In 2026, Atlas helps Terraform HCL developers diagnose hanging or long-running commands like `terraform plan` or `terraform init` by explicitly identifying if they are blocked on interactive input or genuinely slow. Atlas's `bash` tool races every command against a timeout, providing clear `shell_metadata` to guide you in resolving the issue, whether it means adding non-interactive flags or increasing the timeout for a complex `terraform apply`. ## Key takeaways - Atlas's `bash` tool diagnoses hanging Terraform HCL commands by racing them against a timeout. - Atlas explicitly distinguishes between genuinely slow `terraform plan` operations and `terraform apply` commands blocked on interactive input. - For blocked Terraform HCL commands, use non-interactive flags like `-auto-approve` or `-input=false` when re-running with `atlas bash`. - Increase the `atlas bash --timeout` value in milliseconds for long-running `terraform init` or `terraform plan` operations that are genuinely slow. - Atlas provides clear `shell_metadata` in its output, detailing the exact reason a Terraform HCL command was interrupted or timed out. ## How Atlas Identifies Blocked Terraform HCL Commands In 2026, Atlas provides a precise method for identifying why a Terraform HCL command, such as `terraform init` or `terraform plan`, might be hanging. Atlas's `bash` tool executes your command and races it against a configurable timeout, typically 30 seconds by default. If the command exceeds this limit, Atlas analyzes its state to determine if it is genuinely slow or silently blocked, often waiting for interactive input. When you execute a Terraform HCL command through Atlas, for example, `atlas bash "terraform apply"`, Atlas wraps this execution with its intelligent `bash` tool. This tool monitors the command's execution time. If the command does not complete within the specified timeout, Atlas intervenes. Instead of simply killing the process, Atlas attempts to diagnose the cause. It specifically looks for patterns indicating that the command is waiting for user input on `stdin`. This is a critical distinction for Terraform HCL operations, where a `terraform apply` might prompt for confirmation, or a `terraform init` might ask about uninitialized modules, leading to a silent block in an automated or non-interactive environment. Atlas's output will include a `shell_metadata` block that explicitly states if the command was "blocked on interactive input," providing immediate clarity. ## Distinguishing Slow Terraform HCL Operations from Interactive Prompts Atlas helps Terraform HCL developers in 2026 differentiate between a genuinely slow `terraform plan` and one that is silently waiting for input. When Atlas's `bash` tool times out a command, the `shell_metadata` block in its output provides a clear diagnosis. It explicitly states if the command was 'blocked on interactive input' or if it simply exceeded the 60-second default timeout for a complex operation. The core of diagnosing a hanging Terraform HCL command lies in interpreting Atlas's `shell_metadata` output. For instance, if you run `atlas bash "terraform apply -auto-approve=false"` and it hangs, Atlas will report if the command was killed due to a timeout. The crucial part is the diagnostic message. If the message indicates "blocked on interactive input," you know immediately that the `terraform apply` command was waiting for a `yes` or `no` confirmation. This is distinct from a `terraform plan` that might genuinely take several minutes to evaluate a large number of resources defined across multiple `.tf` files in a complex root module. Atlas's explicit diagnosis prevents wasted time spent increasing timeouts for commands that will never resolve without input. This feature is particularly valuable when dealing with provider-specific prompts or module registry interactions during `terraform init`. ## Resolving Hanging Terraform HCL Commands Once Atlas has diagnosed a hanging Terraform HCL command, resolving the issue is straightforward in 2026. If the `shell_metadata` indicates the command was 'blocked on interactive input,' the solution is to re-run it with non-interactive flags. For genuinely slow commands, like a large `terraform plan` that might take 120 seconds, Atlas instructs you to retry with an increased timeout value. If Atlas reports that a Terraform HCL command, such as `terraform init` or `terraform apply`, was blocked on interactive input, the next step is to modify the command to run non-interactively. Common non-interactive flags for Terraform HCL include `-input=false` for `terraform init` or `-auto-approve` for `terraform apply`. For example, if `atlas bash "terraform apply"` was blocked, you would retry with `atlas bash "terraform apply -auto-approve"`. This ensures the command proceeds without waiting for `stdin`. Conversely, if Atlas's diagnosis indicates the command was genuinely slow and simply exceeded the timeout, you can re-run it with a larger timeout. Atlas's `bash` tool allows you to specify a timeout in milliseconds, for example, `atlas bash --timeout 180000 "terraform plan"` for a 3-minute timeout. This clear guidance from Atlas helps you quickly get unstuck and continue your Terraform HCL development workflow. ## Atlas's Safety and Review for Terraform HCL Operations Atlas integrates robust safety mechanisms for Terraform HCL operations, ensuring developers maintain control in 2026. Before Atlas executes any potentially destructive command like `terraform apply`, it operates in a read-only plan agent, drafting a plan and presenting a unified diff for approval. This process applies even when diagnosing hanging commands, as Atlas will prompt for permission before running `terraform validate` or `terraform plan`. When working with Terraform HCL, safety is paramount, especially when diagnosing issues that might involve re-running commands. Atlas ensures that all operations, including those used for debugging, adhere to strict permission and review protocols. Every Atlas tool call is permission-gated, requiring explicit `allow`, `ask`, or `deny` rules. For instance, if Atlas suggests running `terraform plan` to verify a fix after resolving a hanging `terraform init`, it will first present the command and ask for your approval. Furthermore, Atlas computes a unified diff for every file edit it proposes, such as adding a `for_each` block or extracting a repeated resource into a module, and surfaces it for your approval before writing. This level of transparency and control extends to its `bash` tool, where you explicitly invoke commands, ensuring you are always aware of and approve the actions Atlas takes within your `.tf` files and `.terraform.lock.hcl` environment. ## Steps 1. Execute the hanging Terraform HCL command using `atlas bash`: For example, if `terraform apply` is hanging, run `atlas bash "terraform apply"`. Atlas will race this command against its default timeout, typically 30 seconds. 2. Review the `shell_metadata` block in Atlas's output: After the command times out, Atlas will present a detailed `shell_metadata` block. Look for the diagnostic message within this block to understand why the command was killed. 3. Identify if the command was "blocked on interactive input": If the `shell_metadata` explicitly states "blocked on interactive input," it means your Terraform HCL command, such as `terraform init` or `terraform apply`, was waiting for user confirmation or input. 4. Re-run blocked commands with non-interactive flags: If blocked, modify the command to prevent prompts. For `terraform apply`, use `atlas bash "terraform apply -auto-approve"`. For `terraform init`, use `atlas bash "terraform init -input=false"`. 5. Increase timeout for genuinely slow Terraform HCL operations: If Atlas indicates the command was genuinely slow and simply exceeded the timeout, retry with a larger timeout value. For example, `atlas bash --timeout 300000 "terraform plan"` for a 5-minute execution of a complex plan. 6. Confirm user abortion if you manually interrupted: If you manually stopped the command, the `shell_metadata` will clearly state "User aborted the command," distinguishing your action from an Atlas-imposed timeout. ## FAQ ### How do I debug a hanging `terraform plan` in Atlas? Run `atlas bash "terraform plan"`. Atlas will execute the command and, if it times out, its `shell_metadata` block will diagnose if it was blocked on interactive input or genuinely slow. Adjust your command or timeout based on this diagnosis. ### What if `terraform init` is silently blocked in Atlas? If `terraform init` is silently blocked, Atlas's `shell_metadata` will report "blocked on interactive input." Re-run the command using `atlas bash "terraform init -input=false"` to prevent it from waiting for user prompts, especially when interacting with the module registry. ### Can Atlas tell if my `terraform apply` is just slow or waiting for input? Yes, Atlas's `bash` tool explicitly differentiates. If `terraform apply` is waiting for confirmation, the `shell_metadata` will state "blocked on interactive input." If it's a large, complex operation, it will simply report a timeout, prompting you to increase the `--timeout` value. ### How do I increase the timeout for a long-running Terraform HCL command in Atlas? Use the `--timeout` flag with `atlas bash`, specifying the duration in milliseconds. For example, to allow a `terraform plan` to run for 5 minutes, you would use `atlas bash --timeout 300000 "terraform plan"`. ### Does Atlas require permissions to run `terraform validate` or `terraform plan`? Yes, Atlas operates with permission-gated tool calls. Before running commands like `terraform validate` or `terraform plan`, Atlas will present a prompt for your approval, ensuring you maintain control over all operations within your `.tf` files. ### What if I manually stop a Terraform HCL command run by Atlas? If you manually abort a Terraform HCL command, Atlas's `shell_metadata` block will clearly indicate "User aborted the command." This distinguishes your intentional interruption from a command that timed out or was blocked. ### How does Atlas ensure safety when modifying Terraform HCL files? Atlas drafts a plan in a read-only agent, computes a unified diff for every proposed file edit (e.g., to `.tf` files), and surfaces it for your approval before writing. This applies to tasks like adding `terraform test` cases or running `terraform fmt -recursive`. --- Canonical HTML: https://runatlas.sh/resources/stacks/diagnose-a-hanging-or-long-running-command-in-terraform Source of truth: aeo_pages row `/resources/stacks/diagnose-a-hanging-or-long-running-command-in-terraform` (segment: Stacks) (this file is generated from it, never hand-edited). Licence: Atlas is proprietary with a free core. It is not open source and there is no public source repository.