mt4ctl 0.2.0__tar.gz → 0.3.0__tar.gz

{mt4ctl-0.2.0 → mt4ctl-0.3.0}/CHANGELOG.md

@@ -6,6 +6,21 @@ to [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.3.0] - 2026-05-23
+
+### Added
+
+- `mt4_ea_list` — inventory of experts (strategies) attached per terminal.
+- `mt4_autotrading` — terminal master AutoTrading switch (from `terminal.ini`)
+  plus per-EA live-trading status (best-effort decode of the chart-expert flags).
+- `mt4_info` — terminal build, broker server, and last broker ping (from logs).
+
+### Fixed
+
+- Fan-out tools (`mt4_ea_list`/`mt4_autotrading`/`mt4_info`) no longer blank the
+  whole `all` result when a single host is unreachable — each terminal renders
+  its own error row (matching `mt4_status`).
+
 ## [0.2.0] - 2026-05-23
 
 ### Added
@@ -56,6 +71,7 @@ Initial release.
   fail-fast config resolution and actionable SSH-failure errors.
 - Test suite, strict `mypy`, `ruff`, and a 3.11–3.13 CI matrix.
 
-[Unreleased]: https://github.com/ak40u/mt4ctl/compare/v0.2.0...HEAD
+[Unreleased]: https://github.com/ak40u/mt4ctl/compare/v0.3.0...HEAD
+[0.3.0]: https://github.com/ak40u/mt4ctl/compare/v0.2.0...v0.3.0
 [0.2.0]: https://github.com/ak40u/mt4ctl/compare/v0.1.0...v0.2.0
 [0.1.0]: https://github.com/ak40u/mt4ctl/releases/tag/v0.1.0

{mt4ctl-0.2.0 → mt4ctl-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mt4ctl
-Version: 0.2.0
+Version: 0.3.0
 Summary: MCP server for managing headless MetaTrader terminals over SSH (Wine + systemd)
 Project-URL: Homepage, https://github.com/ak40u/mt4ctl
 Project-URL: Repository, https://github.com/ak40u/mt4ctl
@@ -246,6 +246,9 @@ and an absolute `command` path if `uvx` is not on the GUI app's `PATH` (`which u
 | `mt4_control` | ✓ | `start` / `stop` / `restart` a unit (live needs `confirm`). |
 | `mt4_login` | ✓ | One-time headless login for auto-reconnect (live needs `confirm`). |
 | `mt4_doctor` | – | Diagnose registry, SSH, remote tools, units, and data dirs. |
+| `mt4_ea_list` | – | List the experts (strategies) attached per terminal. |
+| `mt4_autotrading` | – | AutoTrading master switch + per-EA live-trading status. |
+| `mt4_info` | – | Terminal build, broker server, and last broker ping. |
 
 Full reference: [`docs/tools.md`](docs/tools.md).
 

{mt4ctl-0.2.0 → mt4ctl-0.3.0}/README.md

@@ -214,6 +214,9 @@ and an absolute `command` path if `uvx` is not on the GUI app's `PATH` (`which u
 | `mt4_control` | ✓ | `start` / `stop` / `restart` a unit (live needs `confirm`). |
 | `mt4_login` | ✓ | One-time headless login for auto-reconnect (live needs `confirm`). |
 | `mt4_doctor` | – | Diagnose registry, SSH, remote tools, units, and data dirs. |
+| `mt4_ea_list` | – | List the experts (strategies) attached per terminal. |
+| `mt4_autotrading` | – | AutoTrading master switch + per-EA live-trading status. |
+| `mt4_info` | – | Terminal build, broker server, and last broker ping. |
 
 Full reference: [`docs/tools.md`](docs/tools.md).
 

{mt4ctl-0.2.0 → mt4ctl-0.3.0}/docs/tools.md

@@ -92,3 +92,37 @@ reachability, required remote tools, systemd units, data directories, and
 connected, rather than reporting a misleading "all passed"). Returns a ✓/!/✗
 checklist. Use it when a terminal is unexpectedly `unknown` or `mt4_status` looks
 wrong. The same checks are available from the shell as `mt4ctl doctor`.
+
+## `mt4_ea_list`
+
+| Arg | Type | Default | Description |
+| --- | --- | --- | --- |
+| `terminal` | string | `"all"` | a terminal id, or "all" |
+
+Read-only. Lists the expert advisors (strategies) attached to a terminal, parsed
+from its chart files. For a single terminal it lists every EA; for `"all"` it
+shows the count per terminal.
+
+## `mt4_autotrading`
+
+| Arg | Type | Default | Description |
+| --- | --- | --- | --- |
+| `terminal` | string | `"all"` | a terminal id, or "all" |
+
+Read-only. Reports whether algo-trading is enabled, at two levels: the terminal
+**master AutoTrading** switch (from `terminal.ini` `Experts=` — authoritative)
+and how many attached experts have live-trading enabled. Flags terminals whose
+master is off (nothing trades) or whose experts have live-trading disabled.
+
+> The per-EA live-trading flag is a *best-effort* decode of the MT4 chart-expert
+> `flags` bitmask (low bit); the terminal master switch is authoritative.
+
+## `mt4_info`
+
+| Arg | Type | Default | Description |
+| --- | --- | --- | --- |
+| `terminal` | string | `"all"` | a terminal id, or "all" |
+
+Read-only. Reports each terminal's build, broker server, and last broker ping,
+parsed from its log — useful to confirm what build/broker a terminal is on and
+its connection latency.

{mt4ctl-0.2.0 → mt4ctl-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "mt4ctl"
-version = "0.2.0"
+version = "0.3.0"
 description = "MCP server for managing headless MetaTrader terminals over SSH (Wine + systemd)"
 readme = "README.md"
 requires-python = ">=3.11"

{mt4ctl-0.2.0 → mt4ctl-0.3.0}/src/mt4ctl/__init__.py

@@ -7,6 +7,6 @@ control, and headless first-login — exposed as Model Context Protocol tools.
 
 from __future__ import annotations
 
-__version__ = "0.2.0"
+__version__ = "0.3.0"
 
 __all__ = ["__version__"]

{mt4ctl-0.2.0 → mt4ctl-0.3.0}/src/mt4ctl/models.py

@@ -104,6 +104,58 @@ class TerminalStatus:
         return self.service_state == "active" and self.connected is True
 
 
+# Bit in the MT4 chart-expert ``flags`` bitmask that corresponds to "Allow live
+# trading". Derived (not officially documented); on a healthy SQX farm every
+# trading expert reports flags=343 (odd → this bit set). Treated as best-effort.
+EXPERT_LIVE_TRADING_BIT = 0x01
+
+
+@dataclass(frozen=True, slots=True)
+class Expert:
+    """An expert advisor attached to a chart."""
+
+    name: str
+    """Expert name as stored in the .chr file (``folder\\EA name``)."""
+    flags: int
+    """MT4 chart-expert flags bitmask, or -1 if unparsable."""
+
+    @property
+    def short_name(self) -> str:
+        """The EA name without its folder prefix."""
+        return self.name.replace("\\", "/").rsplit("/", 1)[-1]
+
+    @property
+    def live_trading(self) -> bool | None:
+        """Best-effort decode of the live-trading bit; ``None`` if flags unknown."""
+        if self.flags < 0:
+            return None
+        return bool(self.flags & EXPERT_LIVE_TRADING_BIT)
+
+
+@dataclass(frozen=True, slots=True)
+class ExpertsReport:
+    """AutoTrading master switch + attached experts for one terminal."""
+
+    terminal: str
+    master: bool | None
+    """Terminal-level AutoTrading (``Experts=`` in terminal.ini); None if unknown."""
+    experts: list[Expert]
+    error: str | None = None
+    """Set when the host could not be reached, so one dead host never blanks a fan-out."""
+
+
+@dataclass(frozen=True, slots=True)
+class TerminalInfo:
+    """Build / broker / latency facts parsed from a terminal's log."""
+
+    terminal: str
+    build: str | None
+    server: str | None
+    ping_ms: float | None
+    error: str | None = None
+    """Set when the host could not be reached."""
+
+
 @dataclass(frozen=True, slots=True)
 class Registry:
     """The full set of configured hosts and terminals."""

{mt4ctl-0.2.0 → mt4ctl-0.3.0}/src/mt4ctl/operations.py

@@ -14,7 +14,18 @@ from pathlib import Path
 
 from . import scripts, ssh
 from .errors import ConfirmationRequiredError, RemoteCommandError
-from .models import Env, Host, Registry, Terminal, TerminalStatus
+from .models import (
+    Env,
+    Expert,
+    ExpertsReport,
+    Host,
+    Registry,
+    Terminal,
+    TerminalInfo,
+    TerminalStatus,
+)
+
+_PING_RE = re.compile(r"login on (\S+) through[^(]*\(ping: ([0-9.]+) ms\)")
 
 CONTROL_ACTIONS = ("start", "stop", "restart")
 
@@ -122,6 +133,52 @@ async def logs(
     return result.stdout.strip() or "(no log output)"
 
 
+async def experts(registry: Registry, terminal_id: str) -> ExpertsReport:
+    """Report the AutoTrading master switch and attached experts for a terminal."""
+    term = registry.terminal(terminal_id)
+    host = registry.host_of(term)
+    try:
+        result = await ssh.run(host, scripts.build_experts_script(term.data_dir), check=False)
+    except RemoteCommandError as exc:
+        # One unreachable host must not blank a whole fan-out (matches status()).
+        return ExpertsReport(terminal=terminal_id, master=None, experts=[], error=str(exc))
+    master: bool | None = None
+    eas: list[Expert] = []
+    for line in result.stdout.splitlines():
+        parts = line.split(scripts.SEP)
+        if parts[0] == "MASTER" and len(parts) >= 2:
+            master = {"1": True, "0": False}.get(parts[1].strip())
+        elif parts[0] == "EA" and len(parts) >= 3:
+            try:
+                flags = int(parts[2])
+            except ValueError:
+                flags = -1
+            eas.append(Expert(name=parts[1], flags=flags))
+    return ExpertsReport(terminal=terminal_id, master=master, experts=eas)
+
+
+async def info(registry: Registry, terminal_id: str) -> TerminalInfo:
+    """Report build / broker server / last ping for a terminal, parsed from logs."""
+    term = registry.terminal(terminal_id)
+    host = registry.host_of(term)
+    try:
+        result = await ssh.run(host, scripts.build_info_script(term.data_dir), check=False)
+    except RemoteCommandError as exc:
+        return TerminalInfo(
+            terminal=terminal_id, build=None, server=None, ping_ms=None, error=str(exc)
+        )
+    build = server = None
+    ping: float | None = None
+    for line in result.stdout.splitlines():
+        parts = line.split(scripts.SEP, 1)
+        if parts[0] == "BUILD" and len(parts) == 2:
+            build = parts[1].strip() or None
+        elif parts[0] == "LOGIN" and len(parts) == 2 and (m := _PING_RE.search(parts[1])):
+            server = m.group(1)
+            ping = float(m.group(2))
+    return TerminalInfo(terminal=terminal_id, build=build, server=server, ping_ms=ping)
+
+
 async def control(
     registry: Registry,
     terminal_id: str,

{mt4ctl-0.2.0 → mt4ctl-0.3.0}/src/mt4ctl/scripts.py

@@ -106,6 +106,43 @@ emit() {{
 """
 
 
+def build_experts_script(data_dir: str) -> str:
+    """Build a script reporting the AutoTrading master switch + attached experts.
+
+    Emits ``MASTER|<0|1|?>`` (from ``config/terminal.ini`` ``Experts=``) and one
+    ``EA|<name>|<flags>`` line per attached expert (parsed from the active
+    profile's ``.chr`` files). ``flags`` is the MT4 chart-expert bitmask.
+    """
+    dir_q = sh_quote(data_dir)
+    return f"""\
+set +e
+DIR={dir_q}
+m=$(grep -iE '^Experts=' "$DIR/config/terminal.ini" 2>/dev/null | head -1 | cut -d= -f2 | tr -d '\\r')
+[ -z "$m" ] && m="?"
+echo "MASTER{SEP}$m"
+for f in "$DIR"/profiles/default/*.chr; do
+  [ -e "$f" ] || continue
+  # .chr files are CRLF — strip the trailing CR so it doesn't ride into the name
+  # field, where it would become a stray splitlines() boundary downstream (each
+  # EA record would split apart) and dirty the parsed name.
+  awk '{{sub(/\\r$/,"")}} /<expert>/{{e=1;n=""}} e&&/^name=/{{n=substr($0,6)}} e&&/^flags=/{{print "EA{SEP}"n"{SEP}"substr($0,7); e=0}}' "$f"
+done
+"""
+
+
+def build_info_script(data_dir: str) -> str:
+    """Build a script reporting build, broker, and last login+ping from the log."""
+    dir_q = sh_quote(data_dir)
+    return f"""\
+set +e
+DIR={dir_q}
+if ! ls "$DIR"/logs/*.log >/dev/null 2>&1; then echo "INFO{SEP}nolog"; exit 0; fi
+# Scan all logs (the last login/ping may be in an earlier file than the newest).
+echo "BUILD{SEP}$(grep -ahoE '([A-Za-z0-9]+ MT[45] )?build [0-9]+' "$DIR"/logs/*.log | tail -1)"
+echo "LOGIN{SEP}$(grep -ahoE 'login on [^ ]+ through[^(]*\\(ping: [0-9.]+ ms\\)' "$DIR"/logs/*.log | tail -1)"
+"""
+
+
 def build_logs_script(data_dir: str, pattern: str | None, lines: int) -> str:
     """Build a script that returns the tail of a terminal's newest log file."""
     grep = (

{mt4ctl-0.2.0 → mt4ctl-0.3.0}/src/mt4ctl/server.py

@@ -7,6 +7,7 @@ spawn locally.
 
 from __future__ import annotations
 
+import asyncio
 import functools
 from collections.abc import Awaitable, Callable
 from typing import TypeVar
@@ -228,6 +229,97 @@ async def mt4_doctor() -> str:
     return diagnostics.format_checks(checks)
 
 
+@mcp.tool()
+@_guard
+async def mt4_ea_list(terminal: str = "all") -> str:
+    """List the expert advisors (strategies) attached to terminals.
+
+    For a single terminal, lists every attached EA; for "all", shows the count
+    per terminal. Read-only (parses the terminal's chart files).
+
+    Args:
+        terminal: a terminal id, or "all" (default).
+    """
+    reg = registry()
+    ids = list(reg.terminals) if terminal == "all" else [terminal]
+    reports = await asyncio.gather(*(operations.experts(reg, t) for t in ids))
+    if len(ids) == 1:
+        r = reports[0]
+        if r.error:
+            return f"{ids[0]}: unreachable — {r.error}"
+        names = "\n".join(f"  {e.short_name}" for e in r.experts) or "  (none)"
+        return f"{ids[0]}: {len(r.experts)} experts\n{names}"
+    return "\n".join(
+        f"{r.terminal:<12} unreachable — {r.error}"
+        if r.error
+        else f"{r.terminal:<12} {len(r.experts):>4} experts"
+        for r in reports
+    )
+
+
+@mcp.tool()
+@_guard
+async def mt4_autotrading(terminal: str = "all") -> str:
+    """Report whether algo-trading is enabled — terminal master switch + per-EA.
+
+    Shows the terminal-level AutoTrading button (from terminal.ini) and how many
+    attached experts have live-trading enabled. Flags terminals whose master is
+    off (nothing trades) or whose experts have non-uniform/disabled flags.
+
+    Note: the per-EA live-trading flag is a best-effort decode of the MT4
+    chart-expert bitmask; the terminal master switch is authoritative.
+
+    Args:
+        terminal: a terminal id, or "all" (default).
+    """
+    reg = registry()
+    ids = list(reg.terminals) if terminal == "all" else [terminal]
+    reports = await asyncio.gather(*(operations.experts(reg, t) for t in ids))
+    lines = [f"{'TERMINAL':<12} {'AUTOTRADING':<12} EXPERTS"]
+    for r in reports:
+        if r.error:
+            lines.append(f"{r.terminal:<12} {'?':<12} unreachable — {r.error}")
+            continue
+        master = {True: "on", False: "OFF", None: "?"}[r.master]
+        total = len(r.experts)
+        live = sum(e.live_trading is True for e in r.experts)
+        off = [e.short_name for e in r.experts if e.live_trading is False]
+        unknown = sum(e.live_trading is None for e in r.experts)
+        note = ""
+        if r.master is False:
+            note = "  <- master AutoTrading OFF; nothing trades"
+        elif off:
+            note = f"  <- {len(off)} EA live-trading off: {', '.join(off[:5])}"
+        elif unknown:
+            note = f"  <- {unknown} EA flags unreadable"
+        lines.append(f"{r.terminal:<12} {master:<12} {live}/{total} live{note}")
+    return "\n".join(lines)
+
+
+@mcp.tool()
+@_guard
+async def mt4_info(terminal: str = "all") -> str:
+    """Report each terminal's build, broker server, and last broker ping.
+
+    Read-only (parsed from the terminal's log). Useful to confirm what build and
+    broker a terminal is on and its connection latency.
+
+    Args:
+        terminal: a terminal id, or "all" (default).
+    """
+    reg = registry()
+    ids = list(reg.terminals) if terminal == "all" else [terminal]
+    infos = await asyncio.gather(*(operations.info(reg, t) for t in ids))
+    lines = [f"{'TERMINAL':<12} {'BUILD':<22} {'SERVER':<18} PING"]
+    for i in infos:
+        if i.error:
+            lines.append(f"{i.terminal:<12} unreachable — {i.error}")
+            continue
+        ping = "-" if i.ping_ms is None else f"{i.ping_ms:.0f}ms"
+        lines.append(f"{i.terminal:<12} {(i.build or '-'):<22} {(i.server or '-'):<18} {ping}")
+    return "\n".join(lines)
+
+
 def serve() -> None:
     """Run the MCP server over stdio (the form MCP clients launch)."""
     mcp.run()

{mt4ctl-0.2.0 → mt4ctl-0.3.0}/tests/test_models.py

@@ -5,7 +5,21 @@ from __future__ import annotations
 import pytest
 
 from mt4ctl.errors import UnknownTargetError
-from mt4ctl.models import Env, Host, HostKind, TerminalStatus
+from mt4ctl.models import Env, Expert, Host, HostKind, TerminalStatus
+
+
+def test_expert_short_name_strips_folder():
+    assert Expert(name="SQ-29-03-2026\\SQ AUDUSD H4 0.157419", flags=343).short_name == (
+        "SQ AUDUSD H4 0.157419"
+    )
+
+
+@pytest.mark.parametrize(
+    ("flags", "expected"),
+    [(343, True), (342, False), (0, False), (-1, None)],
+)
+def test_expert_live_trading_decode(flags, expected):
+    assert Expert(name="x", flags=flags).live_trading is expected
 
 
 def test_wsl_host_requires_distro():

mt4ctl-0.3.0/tests/test_operations.py

@@ -0,0 +1,167 @@
+"""Status parsing and the live-confirmation guard."""
+
+from __future__ import annotations
+
+import pytest
+
+from mt4ctl import operations, ssh
+from mt4ctl.errors import ConfirmationRequiredError
+from mt4ctl.operations import _parse_status_line
+
+
+def _term(registry, tid):
+    return registry.terminal(tid)
+
+
+def test_parse_connected_and_age(registry):
+    line = "TERM|demo1|active|12|2|login on Demo"
+    st = _parse_status_line(line, _term(registry, "demo1"))
+    assert st is not None
+    assert st.service_state == "active"
+    assert st.connected is True
+    assert st.log_age_seconds == 12
+    assert st.healthy is True
+    assert st.last_event == "login on Demo"
+
+
+def test_parse_disconnected(registry):
+    st = _parse_status_line("TERM|demo1|active|5|0|", _term(registry, "demo1"))
+    assert st.connected is False
+    assert st.healthy is False
+    assert st.last_event is None
+
+
+def test_parse_unknown_connection_when_estab_negative(registry):
+    st = _parse_status_line("TERM|demo1|active|-1|-1|", _term(registry, "demo1"))
+    assert st.connected is None
+    assert st.log_age_seconds is None
+
+
+def test_parse_rejects_malformed(registry):
+    assert _parse_status_line("garbage", _term(registry, "demo1")) is None
+
+
+async def test_status_marks_unreachable_host(registry, monkeypatch):
+    async def boom(*a, **k):
+        from mt4ctl.errors import RemoteCommandError
+
+        raise RemoteCommandError("demo-box", 255, "unreachable")
+
+    monkeypatch.setattr(ssh, "run", boom)
+    rows = await operations.status(registry, ["demo1"])
+    assert rows[0].service_state == "unknown"
+    assert rows[0].last_event == "host unreachable"
+
+
+async def test_control_live_requires_confirm(registry, monkeypatch):
+    async def fail(*a, **k):
+        raise AssertionError("ssh.run must not be called without confirmation")
+
+    monkeypatch.setattr(ssh, "run", fail)
+    with pytest.raises(ConfirmationRequiredError):
+        await operations.control(registry, "live-main", "restart", confirm=False)
+
+
+async def test_control_rejects_bad_action(registry):
+    with pytest.raises(ValueError, match="action must be"):
+        await operations.control(registry, "demo1", "frobnicate")
+
+
+async def test_experts_parses_master_and_flags(registry, monkeypatch):
+    from mt4ctl.ssh import CommandResult
+
+    out = "MASTER|1\nEA|SQ-29-03-2026\\SQ AUDUSD H4 0.157419|343\nEA|Util\\Heartbeat|342\n"
+
+    async def fake_run(host, script, **kw):
+        return CommandResult(0, out, "")
+
+    monkeypatch.setattr(ssh, "run", fake_run)
+    r = await operations.experts(registry, "demo1")
+    assert r.master is True
+    assert [e.flags for e in r.experts] == [343, 342]
+    assert r.experts[0].short_name == "SQ AUDUSD H4 0.157419"
+
+
+async def test_experts_master_off_and_unknown(registry, monkeypatch):
+    from mt4ctl.ssh import CommandResult
+
+    async def fake_run(host, script, **kw):
+        return CommandResult(0, "MASTER|0\n", "")
+
+    monkeypatch.setattr(ssh, "run", fake_run)
+    r = await operations.experts(registry, "demo1")
+    assert r.master is False and r.experts == []
+
+
+async def test_experts_unparsable_flags_and_unknown_master(registry, monkeypatch):
+    from mt4ctl.ssh import CommandResult
+
+    async def fake_run(host, script, **kw):
+        return CommandResult(0, "MASTER|?\nEA|x\\y|notanumber\n", "")
+
+    monkeypatch.setattr(ssh, "run", fake_run)
+    r = await operations.experts(registry, "demo1")
+    assert r.master is None
+    assert r.experts[0].flags == -1
+    assert r.experts[0].live_trading is None
+
+
+async def test_experts_unreachable_host_does_not_raise(registry, monkeypatch):
+    from mt4ctl.errors import RemoteCommandError
+
+    async def boom(host, script, **kw):
+        raise RemoteCommandError(host.id, 124, "command timed out")
+
+    monkeypatch.setattr(ssh, "run", boom)
+    r = await operations.experts(registry, "demo1")
+    assert r.error is not None and r.experts == [] and r.master is None
+
+
+async def test_info_nolog_and_unreachable(registry, monkeypatch):
+    from mt4ctl.errors import RemoteCommandError
+    from mt4ctl.ssh import CommandResult
+
+    async def fake_run(host, script, **kw):
+        return CommandResult(0, "INFO|nolog\n", "")
+
+    monkeypatch.setattr(ssh, "run", fake_run)
+    i = await operations.info(registry, "demo1")
+    assert i.build is None and i.server is None and i.ping_ms is None and i.error is None
+
+    async def boom(host, script, **kw):
+        raise RemoteCommandError(host.id, 127, "could not start ssh")
+
+    monkeypatch.setattr(ssh, "run", boom)
+    i2 = await operations.info(registry, "demo1")
+    assert i2.error is not None
+
+
+async def test_info_parses_build_server_ping(registry, monkeypatch):
+    from mt4ctl.ssh import CommandResult
+
+    out = (
+        "BUILD|Forex4you MT4 build 1470\n"
+        "LOGIN|login on Darwinex-Demo through primary 2 (ping: 53.40 ms)\n"
+    )
+
+    async def fake_run(host, script, **kw):
+        return CommandResult(0, out, "")
+
+    monkeypatch.setattr(ssh, "run", fake_run)
+    i = await operations.info(registry, "demo1")
+    assert i.build == "Forex4you MT4 build 1470"
+    assert i.server == "Darwinex-Demo"
+    assert i.ping_ms == 53.40
+
+
+async def test_logs_surfaces_ssh_failure(registry, monkeypatch):
+    from mt4ctl.ssh import CommandResult
+
+    async def fake_run(host, script, **kw):
+        return CommandResult(255, "", "ssh: connect to host failed")
+
+    monkeypatch.setattr(ssh, "run", fake_run)
+    out = await operations.logs(registry, "demo1")
+    assert "cannot read logs for demo1" in out
+    assert "SSH to host" in out
+    assert "(no output)" not in out

{mt4ctl-0.2.0 → mt4ctl-0.3.0}/tests/test_scripts.py

@@ -54,6 +54,26 @@ def test_status_script_handles_broker_failure_and_visibility():
     assert "svcuser=$(systemctl show -p User" in out
 
 
+def test_experts_script_reads_master_and_charts():
+    out = scripts.build_experts_script("/home/t/demo1")
+    assert "config/terminal.ini" in out
+    assert "^Experts=" in out
+    assert "profiles/default/*.chr" in out
+    assert "MASTER|" in out and "EA|" in out
+
+
+def test_info_script_extracts_build_and_ping():
+    out = scripts.build_info_script("/home/t/demo1")
+    assert "build [0-9]+" in out
+    assert "ping:" in out
+    assert "BUILD|" in out and "LOGIN|" in out
+
+
+def test_experts_script_strips_crlf():
+    out = scripts.build_experts_script("/home/t/demo1")
+    assert "sub(/\\r$/" in out  # CRLF guard so flags parse and lines don't over-split
+
+
 def test_doctor_script_probes_tools_and_terminals():
     out = scripts.build_doctor_script([("t1", "mt4-t1", "/home/t/t1")])
     assert "command -v" in out

mt4ctl-0.2.0/tests/test_operations.py

@@ -1,80 +0,0 @@
-"""Status parsing and the live-confirmation guard."""
-
-from __future__ import annotations
-
-import pytest
-
-from mt4ctl import operations, ssh
-from mt4ctl.errors import ConfirmationRequiredError
-from mt4ctl.operations import _parse_status_line
-
-
-def _term(registry, tid):
-    return registry.terminal(tid)
-
-
-def test_parse_connected_and_age(registry):
-    line = "TERM|demo1|active|12|2|login on Demo"
-    st = _parse_status_line(line, _term(registry, "demo1"))
-    assert st is not None
-    assert st.service_state == "active"
-    assert st.connected is True
-    assert st.log_age_seconds == 12
-    assert st.healthy is True
-    assert st.last_event == "login on Demo"
-
-
-def test_parse_disconnected(registry):
-    st = _parse_status_line("TERM|demo1|active|5|0|", _term(registry, "demo1"))
-    assert st.connected is False
-    assert st.healthy is False
-    assert st.last_event is None
-
-
-def test_parse_unknown_connection_when_estab_negative(registry):
-    st = _parse_status_line("TERM|demo1|active|-1|-1|", _term(registry, "demo1"))
-    assert st.connected is None
-    assert st.log_age_seconds is None
-
-
-def test_parse_rejects_malformed(registry):
-    assert _parse_status_line("garbage", _term(registry, "demo1")) is None
-
-
-async def test_status_marks_unreachable_host(registry, monkeypatch):
-    async def boom(*a, **k):
-        from mt4ctl.errors import RemoteCommandError
-
-        raise RemoteCommandError("demo-box", 255, "unreachable")
-
-    monkeypatch.setattr(ssh, "run", boom)
-    rows = await operations.status(registry, ["demo1"])
-    assert rows[0].service_state == "unknown"
-    assert rows[0].last_event == "host unreachable"
-
-
-async def test_control_live_requires_confirm(registry, monkeypatch):
-    async def fail(*a, **k):
-        raise AssertionError("ssh.run must not be called without confirmation")
-
-    monkeypatch.setattr(ssh, "run", fail)
-    with pytest.raises(ConfirmationRequiredError):
-        await operations.control(registry, "live-main", "restart", confirm=False)
-
-
-async def test_control_rejects_bad_action(registry):
-    with pytest.raises(ValueError, match="action must be"):
-        await operations.control(registry, "demo1", "frobnicate")
-
-
-async def test_logs_surfaces_ssh_failure(registry, monkeypatch):
-    from mt4ctl.ssh import CommandResult
-
-    async def fake_run(host, script, **kw):
-        return CommandResult(255, "", "ssh: connect to host failed")
-
-    monkeypatch.setattr(ssh, "run", fake_run)
-    out = await operations.logs(registry, "demo1")
-    assert "cannot read logs for demo1" in out
-    assert "SSH to host" in out
-    assert "(no output)" not in out