M-o-a-T/moat

Started the MoaT MCP stdio server (`moat mcp stdio`, from packaging/moat-mcp/README.md) and performed MCP initialize + tools/list; server returned 5 link tools: link_get_value, link_set_value, link_watch_start, link_watch_get, link_watch_stop.

cd <host-path> && ls -la && cat README* 2>/dev/null | head -200
cd <host-path> && git log -1 --format=%H 2>/dev/null; ls .github/workflows 2>/dev/null; cat <host-path> 2>/dev/null | head -5; which python3 node npm uv pip3 2>&1; cat /etc/os-release | head -2
cd <host-path> && cat setup.sh; echo ----; cat mt; echo ----; cat Makefile | head -60; echo ----; grep -n "mcp\|MCP" -ri docs/*.md ARCHITECTURE.md AGENTS.md 2>/dev/null | head -30
cd <host-path> && cat packaging/moat-mcp/README.md; echo ----; ls packaging/moat-mcp; cat packaging/moat-mcp/pyproject.toml 2>/dev/null | head -60
cd <host-path> && sed -n 1,80p pyproject.toml; grep -n "scripts" -A6 pyproject.toml; python3 --version; ls packaging | grep -i moat | head -50
export NODE_USE_ENV_PROXY=1; (sudo apt-get update -qq && sudo DEBIAN_FRONTEND=noninteractive apt-get install -y -qq python3-venv python3-pip >/tmp/apt.log 2>&1); echo apt=$?; python3 -m venv <host-path> && <host-path> install -q uv 2>&1 | tail -3; <host-path> python install 3.13 2>&1 | tail -3; echo rc=$?
export NODE_USE_ENV_PROXY=1 SETUPTOOLS_SCM_PRETEND_VERSION=0.0.0.dev0; cd <host-path> && <host-path> venv -q -p 3.13 <host-path> && cd <host-path> && timeout 900 <host-path> pip install -p <host-path> <host-path> > /tmp/install.log 2>&1; echo rc=$?; tail -25 /tmp/install.log
cd /tmp && <host-path> -m pip --version 2>/dev/null; <host-path> pip index versions asyncowfs -p <host-path> 2>&1 | head -3; <host-path> pip index versions moat-mcp -p <host-path> 2>&1 | head -2; grep -rn "asyncowfs" <host-path> | head -3; env | grep -i "pip_index\|UV_\|index" 
cd /tmp && <host-path> index versions asyncowfs 2>&1 | head -3; <host-path> download --no-deps -q -d /tmp/dl asyncowfs==0.16.0 2>&1 | tail -2; ls /tmp/dl 2>/dev/null
export NODE_USE_ENV_PROXY=1 SETUPTOOLS_SCM_PRETEND_VERSION=0.0.0.dev0; cd /tmp && python3 -I -c "
import tomllib;d=tomllib.load(open('<host-path>','rb'))['project']['dependencies']
open('/tmp/deps.txt','w').write('\n'.join(x for x in d if not x.startswith('asyncowfs')))" && cd <host-path> && timeout 1200 <host-path> pip install -p <host-path> -r /tmp/deps.txt > /tmp/deps.log 2>&1; echo deps=$?; tail -5 /tmp/deps.log; timeout 900 <host-path> pip install -p <host-path> --no-deps <host-path> > /tmp/install.log 2>&1; echo root=$?; tail -5 /tmp/install.log
export NODE_USE_ENV_PROXY=1; cd <host-path> && sed -E 's/[ ]*(~=|>=|>|<|==)[^,;]*//g' /tmp/deps.txt | sed 's/ //g' > /tmp/deps2.txt && cat /tmp/deps2.txt | tr '\n' ' '; echo; timeout 1500 <host-path> pip install -p <host-path> -r /tmp/deps2.txt > /tmp/deps.log 2>&1; echo deps=$?; tail -8 /tmp/deps.log
export NODE_USE_ENV_PROXY=1; sed -i 's/,$//' /tmp/deps2.txt; timeout 1500 <host-path> pip install -p <host-path> -r /tmp/deps2.txt > /tmp/deps.log 2>&1; echo deps=$?; tail -12 /tmp/deps.log
export NODE_USE_ENV_PROXY=1; sudo DEBIAN_FRONTEND=noninteractive apt-get install -y -qq build-essential pkg-config libffi-dev libsystemd-dev libfuse3-dev libmagic1 >/tmp/apt2.log 2>&1; echo apt=$?; cd <host-path> && timeout 1500 <host-path> pip install -p <host-path> -r /tmp/deps2.txt > /tmp/deps.log 2>&1; echo deps=$?; grep -i "error" /tmp/deps.log | head -10; tail -3 /tmp/deps.log
cd <host-path> && ls <host-path> | grep -i moat; cat > /tmp/listtools.py <<'EOF'
import json, subprocess, sys
p = subprocess.Popen(["<host-path>", "mcp", "stdio"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, cwd="/tmp")
def send(m): p.stdin.write(json.dumps(m)+"\n"); p.stdin.flush()
def recv(): return json.loads(p.stdout.readline())
send({"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18","capabilities":{},"clientInfo":{"name":"smoke","version":"0"}}})
print("init:", recv()["result"]["serverInfo"])
send({"jsonrpc":"2.0","method":"notifications/initialized"})
send({"jsonrpc":"2.0","id":2,"method":"tools/list","params":{}})
r = recv()
print("tools:", [t["name"] for t in r["result"]["tools"]])
p.stdin.close(); p.terminate()
print("stderr:", p.stderr.read()[-800:])
EOF
timeout 120 python3 -I /tmp/listtools.py; echo rc=$?
cd /tmp && echo '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18","capabilities":{},"clientInfo":{"name":"s","version":"0"}}}' | timeout 20 <host-path> mcp stdio > /tmp/o.txt 2> /tmp/e.txt; echo rc=$?; echo OUT:; head -c 1500 /tmp/o.txt; echo; echo ERR:; tail -c 2000 /tmp/e.txt
cd <host-path> && ls moat | head -80; ls moat/mcp 2>/dev/null; grep -rn "mcp" moat/main.py moat/__main__.py 2>/dev/null | head; grep -rln "def stdio\|\"stdio\"" moat | head
cd <host-path> && cat moat/mcp/_main.py | head -80; echo ----; cat moat/mcp/_cfg.yaml; echo ----; sed -n 1,40p moat/main.py
SP=$(<host-path> -c "import moat,os;print(os.path.dirname(moat.__file__))" 2>/dev/null); echo $SP; ls $SP | head -30; ls <host-path> | grep -i "^moat" 
cd /tmp && grep -n "mcp\|util\|subcommand\|commands" <host-path> | head -30; grep -n "_cfg\|mcp\|load_subgroup\|def \|sub" <host-path> | head -60
cd <host-path> && grep -rn "sub_pre\|sub_post" moat/lib/run/*.py | head -20; grep -rn "_main" moat/lib/run/*.py | head; ls moat/lib/run/ 2>/dev/null
cd <host-path> && sed -n 640,700p moat/lib/run/__init__.py
cd /tmp && timeout 60 <host-path> -L mcp stdio --help 2>&1 | tail -25
cd /tmp && export PYTHONPATH=<host-path>; timeout 60 <host-path> mcp stdio --help 2>&1 | tail -12; echo ---; cat > /tmp/listtools.py <<'EOF'
import json, subprocess, os
env = dict(os.environ, PYTHONPATH="<host-path>")
p = subprocess.Popen(["<host-path>", "mcp", "stdio"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, cwd="/tmp", env=env)
def send(m): p.stdin.write(json.dumps(m)+"\n"); p.stdin.flush()
def recv():
    while True:
        line = p.stdout.readline()
        if not line: raise SystemExit("EOF; stderr=" + p.stderr.read()[-1500:])
        try: return json.loads(line)
        except ValueError: print("non-json stdout:", line.rstrip()[:200])
send({"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18","capabilities":{},"clientInfo":{"name":"smoke","version":"0"}}})
print("init:", recv()["result"]["serverInfo"])
send({"jsonrpc":"2.0","method":"notifications/initialized"})
send({"jsonrpc":"2.0","id":2,"method":"tools/list","params":{}})
r = recv()
print("tools:", [t["name"] for t in r["result"]["tools"]])
p.stdin.close(); p.terminate()
EOF
timeout 120 python3 -I /tmp/listtools.py; echo rc=$?
export NODE_USE_ENV_PROXY=1; cd <host-path> && <host-path> pip install -p <host-path> "mcp>1.29.1,<2" 2>&1 | tail -2; cd /tmp && timeout 120 python3 -I /tmp/listtools.py; echo rc=$?
cd <host-path> && sed -n 130,185p moat/link/backend/__init__.py; ls moat/link/backend/; cat moat/link/_cfg.yaml 2>/dev/null | head -60
apt-cache policy flashmq 2>/dev/null | head -3; sudo DEBIAN_FRONTEND=noninteractive apt-get install -y -qq flashmq >/tmp/apt3.log 2>&1; echo apt=$?; tail -3 /tmp/apt3.log; which flashmq; ls /etc/flashmq 2>/dev/null
cd <host-path> && cat moat/mcp/_server.py | head -120; echo ----; cat moat/mcp/link.py | head -60
cd <host-path> && grep -n "cfg\b\|cfg\.\|cfg\[" moat/mcp/link.py | head -20; grep -n "def services" -A25 moat/mcp/__init__.py | head -50; grep -n "\"link\"\|cfg.link\|\.link\b" moat/link/client.py | head -10
cat > <host-path> <<'EOF'
moat:
  link:
    backend:
      driver: mqtt
      host: localhost
      codec: std-cbor
    client:
      init_timeout: 5
      local_only: true
EOF
cd /tmp && sed -i 's#\["<host-path>", "mcp", "stdio"\]#["<host-path>", "-c", "<host-path>", "mcp", "stdio"]#' /tmp/listtools.py && timeout 120 python3 -I /tmp/listtools.py 2>&1 | tail -30; echo rc=$?
sudo DEBIAN_FRONTEND=noninteractive apt-get install -y -qq mosquitto >/tmp/apt4.log 2>&1; echo apt=$?; (nohup mosquitto -p 1883 -v > <host-path> 2>&1 &); sleep 2; (ss -ltn 2>/dev/null || netstat -ltn) | grep 1883; cd /tmp && timeout 120 python3 -I /tmp/listtools.py 2>&1 | tail -15; echo rc=$?
sed -i '/local_only/d' <host-path> && cd /tmp && timeout 150 python3 -I /tmp/listtools.py 2>&1 | tail -12; echo rc=$?
sed -i 's/init_timeout: 5/init_timeout: null/' <host-path> && cd /tmp && timeout 150 python3 -I /tmp/listtools.py 2>&1 | tail -12; echo rc=$?
cd <host-path> && grep -n "mcp\|env\|MOAT\|list_tools\|--validate" <host-path> | head -80
cd <host-path> && grep -rn "MOAT_CFG" moat/lib/run/__init__.py moat/main.py moat/util/*.py 2>/dev/null | head -5; cd /tmp && env -i PATH=/usr/bin:/bin PYTHONPATH=<host-path> MOAT_CFG=<host-path> python3 -I - <<'EOF'
import json, subprocess
p = subprocess.Popen(["<host-path>", "mcp", "stdio"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, cwd="/tmp", env={"PATH":"/usr/bin:/bin","PYTHONPATH":"<host-path>"})
def send(m): p.stdin.write(json.dumps(m)+"\n"); p.stdin.flush()
def recv(): return json.loads(p.stdout.readline())
send({"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18","capabilities":{},"clientInfo":{"name":"smoke","version":"0"}}}); recv()
send({"jsonrpc":"2.0","method":"notifications/initialized"})
send({"jsonrpc":"2.0","id":2,"method":"tools/list","params":{}})
print([t["name"] for t in recv()["result"]["tools"]])
p.stdin.close(); p.terminate()
EOF
cd <host-path> && mkdir -p .coldpass && cat > .coldpass/probe.json <<'EOF'
{"kind":"mcp","argv":["<host-path>"}}
EOF
cat > .coldpass/report.json <<'EOF'
{"outcome":"working",
 "operation":"Started the MoaT MCP stdio server (`moat mcp stdio`, from packaging/moat-mcp/README.md) and performed MCP initialize + tools/list; server returned 5 link tools: link_get_value, link_set_value, link_watch_start, link_watch_get, link_watch_stop.",
 "operation_scope":"Tools are listed; no read/write against a live MoaT-Link server was exercised. The link service needs an MQTT broker on localhost:1883 (mosquitto, started by this smoke run) to start; no MoaT-Link server is announcing, so the link client runs with init_timeout null.",
 "steps":[
  "Read README.md (no runnable quickstart) and packaging/moat-mcp/README.md (`moat mcp stdio`).",
  "apt-get install build-essential pkg-config libffi-dev libsystemd-dev libfuse3-dev libmagic1 python3-venv python3-pip",
  "python3 -m venv <host-path>; pip install uv; uv python install 3.13 (repo requires >=3.13; guest has 3.12)",
  "uv venv <host-path> -p 3.13",
  "uv pip install -r deps (root pyproject dependencies, version pins stripped, see deviations); uv pip install --no-deps <host-path>; uv pip install 'mcp>1.29.1,<2'",
  "Wrote <host-path> (outside the checkout) with moat.link.backend mqtt localhost and client.init_timeout null",
  "apt-get install mosquitto; started `mosquitto -p 1883` in background (left running for the probe)",
  "Ran `moat mcp stdio` with PYTHONPATH=<host-path> and MOAT_CFG=<host-path>; MCP initialize + tools/list succeeded"],
 "deviations":[
  "README setup.sh was not run: it pulls ESP-IDF, MicroPython builds, and a third-party apt repo (debian.m-u.xyz). Only the Python MCP path was installed.",
  "Root `uv pip install -e/.` failed: pyproject requires asyncowfs>=0.16.0 and asyncvictoria>=0.8.1, which the package index does not provide (max 0.15.3 / 0.8.0). Installed the other dependencies with version pins removed, and mcp kept at >1.29.1,<2 (mcp 2.x removed FastMCP).",
  "Installed the root package with --no-deps, but the wheel contains only moat/util (setuptools packages=[\"moat\"]), so `moat mcp` is missing. Worked around with PYTHONPATH=<host-path> instead of editing source.",
  "flashmq (listed in the README testing section, installed by setup.sh) is not in Ubuntu 24.04 archives; substituted mosquitto as the local MQTT broker.",
  "Wrote a config (<host-path>) because the link service crashes without moat.link.backend; init_timeout set to null because no MoaT-Link server is running. Without a broker on localhost:1883 the server exits with OSError."],
 "stuck_step":null,"main_blocker":null,"suggested_fix":"Fix the root pyproject pins (asyncowfs, asyncvictoria) to versions on the index, and include subpackages (packages=find) so the wheel ships moat.mcp. Tell the probe's broker requirement via setup: run a broker on localhost:1883 (flashmq or mosquitto)."}
EOF
python3 -I -c "import json;json.load(open('.coldpass/probe.json'));json.load(open('.coldpass/report.json'));print('json ok')"; <env-var>=<host-path> python3 -I <host-path> --validate; echo rc=$?
cd <host-path> && ls -d build dist *.egg-info moat.egg-info .venv 2>/dev/null; find . -name __pycache__ -newer setup.sh -maxdepth 3 | head -3; ls -la .coldpass