Skip to main content
Glama
L337-org

docker-mcp-server

by L337-org
OverviewSchemaSourceRelated ServersDiscussionsAdmin
Python
Local

container_wait

Read-only

Wait for a Docker container to reach a specified condition: not running, removed, healthy, or a matching log line. Returns met and timed_out flags, so timeouts are never errors.

Instructions

Block until a container reaches a condition: stopped, "healthy", or its logs contain a pattern.

One contract for every mode: never raises on timeout - the result always carries met (condition reached) and timed_out. The stop conditions ("not-running"/"next-exit"/"removed") use the daemon's blocking wait and fill status_code/error (the container's exit info); "healthy" polls the container's HEALTHCHECK every poll_intervals and fills health/status; "log-match" polls recent logs every poll_intervals for pattern and fills matched_line. For a compose project use compose_wait; for swarm services use service_wait.

Health semantics: with no HEALTHCHECK defined, once the container is running the tool returns promptly with health: null and met: false (false = "not confirmed healthy", not "unhealthy" - check health to tell them apart). A container that exits before becoming healthy returns its terminal status and met: false.

Log-match semantics: pattern is matched as a plain substring by default - safe against any input, including adversarial ones. Pass regex=True to match pattern as a regular expression (via re.search) instead; only do this with patterns you trust, since a regex with catastrophic backtracking run against attacker-influenced log content can exhaust CPU (ReDoS). Checks stdout and stderr, most recent lines first within each poll. If the container exits/dies before the pattern ever appears, returns promptly with met=false (not timed_out) - no further logs can arrive, so there's nothing to keep polling for.

Args: until: Condition to wait for: "not-running" (default), "next-exit", "removed", "healthy", or "log-match" (requires pattern) timeout_seconds: Max seconds to wait before returning with timed_out=true poll_interval: "healthy"/"log-match" only: seconds between re-checks (default 2, > 0); capped by the time left so a large value can't push the total wait past the timeout pattern: "log-match" only: substring (or, with regex=True, a regular expression) to look for in the container's logs regex: "log-match" only: treat pattern as a regular expression instead of a plain substring

Returns: dict: {"container", "until", "met", "timed_out", "status_code", "error", "health", "status", "matched_line", "waited_seconds"}; stop modes fill status_code/error, "healthy" fills health ("starting"/"healthy"/"unhealthy", or null with no healthcheck) and status, "log-match" fills matched_line when met and status if the container exited without matching.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
regexNo
untilNonot-running
patternNo
id_or_nameYes
poll_intervalNo
timeout_secondsNo

Schema Changelog

Changes observed during successful MCP inspections.

  1. Changed3 schema fields changedv2.0.1
    • addedInput schema / properties / pattern
      Added value: +{
+  "default": null,
+  "type": "string"
+}
    • addedInput schema / properties / regex
      Added value: +{
+  "default": false,
+  "type": "boolean"
+}
    • changedInput schema / properties / until / enum
      Previous value: -[
-  "not-running",
-  "next-exit",
-  "removed",
-  "healthy"
-]New value: +[
+  "not-running",
+  "next-exit",
+  "removed",
+  "healthy",
+  "log-match"
+]
  2. Addedv2.0.0

TDQS

A5/5.0
Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The description discloses a wealth of behavioral details beyond annotations: never raises on timeout, result always carries met/timed_out, health semantics including returning promptly with health:null if no HEALTHCHECK, log-match semantics (plain substring default, ReDoS risk with regex, checks stdout/stderr, early exit if container dies). All this vastly exceeds the readOnlyHint/destructiveHint annotations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is long but every section earns its place: overview, per-mode contracts, health semantics, log-match safety warning, Args, and Returns. It is front-loaded with the core purpose and then structured with clear subheadings. No filler or tautology; the length is justified by the tool's complexity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Despite no output schema, the description explains the return structure in detail. Combined with full parameter explanations, mode semantics, safety notes, and alternatives routing, nothing an agent needs to call this tool correctly is missing. It is complete for a tool with 6 parameters and three distinct behaviors.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description bears full responsibility for explaining parameters. It does so extensively in the 'Args:' section, covering each parameter (until, timeout_seconds, poll_interval, pattern, regex) with types, defaults, constraints, and mode-specific applicability. This fully compensates for the lack of schema descriptions.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb ('Block') and resource ('a container') with a clear condition ('reaches a condition: stopped, healthy, or its logs contain a pattern'). It distinguishes itself from siblings by explicitly naming compose_wait and service_wait for other scopes. This is precise and unambiguous.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description gives explicit guidance on when to use this tool vs alternatives: 'For a compose project use compose_wait; for swarm services use service_wait.' It also explains when to employ each mode (stop conditions vs healthy vs log-match) with conditions for each, leaving no inference required.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Deploy Server

Other Tools