subtask-mcp 0.2.6__tar.gz → 0.2.8__tar.gz

{subtask_mcp-0.2.6 → subtask_mcp-0.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: subtask-mcp
-Version: 0.2.6
+Version: 0.2.8
 Summary: Background sub-agents for Claude Code, Codex, Kimi and OpenCode, over MCP or CLI, with a spend cap
 License: MIT
 Project-URL: Homepage, https://github.com/tedin7/subtask
@@ -70,7 +70,7 @@ The distribution is `subtask-mcp` (the PyPI name `subtask` is an unrelated
 project). Full guide, per client, with native commands: [docs/install.md](docs/install.md).
 
 ```sh
-uv tool install "git+https://github.com/tedin7/subtask@v0.2.6"   # or: uv tool install /path/to/checkout
+uv tool install "git+https://github.com/tedin7/subtask@v0.2.8"   # or: uv tool install /path/to/checkout
 subtask install --client all          # prints the plan for every detected client
 subtask install --client all --yes    # applies it: MCP server + skill
 subtask doctor --client all           # checks app, config entry and a real handshake

{subtask_mcp-0.2.6 → subtask_mcp-0.2.8}/README.md

@@ -39,7 +39,7 @@ The distribution is `subtask-mcp` (the PyPI name `subtask` is an unrelated
 project). Full guide, per client, with native commands: [docs/install.md](docs/install.md).
 
 ```sh
-uv tool install "git+https://github.com/tedin7/subtask@v0.2.6"   # or: uv tool install /path/to/checkout
+uv tool install "git+https://github.com/tedin7/subtask@v0.2.8"   # or: uv tool install /path/to/checkout
 subtask install --client all          # prints the plan for every detected client
 subtask install --client all --yes    # applies it: MCP server + skill
 subtask doctor --client all           # checks app, config entry and a real handshake

{subtask_mcp-0.2.6 → subtask_mcp-0.2.8}/subtask/__init__.py

@@ -1,3 +1,3 @@
 """subtask: background sub-agents for coding agents."""
 
-__version__ = "0.2.6"
+__version__ = "0.2.8"

{subtask_mcp-0.2.6 → subtask_mcp-0.2.8}/subtask/core.py

@@ -306,7 +306,12 @@ def _delta(job_ids: list[str], since: str) -> tuple[str, str]:
 
 
 def wait(
-    job_ids: list[str], timeout: int = 50, any_: bool = False, results: bool = True, since: str | None = None
+    job_ids: list[str],
+    timeout: int = 50,
+    any_: bool = False,
+    results: bool = True,
+    since: str | None = None,
+    count: bool = True,
 ) -> str:
     """Block until all jobs end (or the first one, with any_), or timeout.
 
@@ -320,7 +325,8 @@ def wait(
     unknown = [j for j in job_ids if not known(j)]
     if unknown:
         return "unknown job: " + ", ".join(unknown)
-    telemetry.count_call(job_ids, "wait")
+    if count:  # servers poll wait() every second inside one tool call: count that call once
+        telemetry.count_call(job_ids, "wait")
     deadline = time.time() + max(0, min(timeout, 600))
     while True:
         ended = [j for j in job_ids if jobs.status(j).get("state") in jobs.FINAL]

{subtask_mcp-0.2.6 → subtask_mcp-0.2.8}/subtask/events.py

@@ -35,11 +35,24 @@ def emit(
     state: str | None = None,
     source: str = "lifecycle",
     attempt: int | None = None,
+) -> dict | None:
+    """Append one event. Never raises: progress must not be able to fail a job."""
+    try:
+        return _emit(job_id, phase, msg, state, source, attempt)
+    except (OSError, ValueError, TypeError) as exc:
+        import sys
+
+        print(f"subtask: progress event not written: {type(exc).__name__}: {exc}", file=sys.stderr)
+        return None
+
+
+def _emit(
+    job_id: str, phase: str, msg: str, state: str | None, source: str, attempt: int | None
 ) -> dict | None:
     path = _path(job_id)
     if not path.parent.is_dir():
         return None
-    with path.open("a+", encoding="utf-8") as fh:
+    with path.open("ab+") as fh:
         fcntl.flock(fh, fcntl.LOCK_EX)
         last = _last(fh)
         seq = int(last.get("seq", 0)) + 1
@@ -57,16 +70,21 @@ def emit(
             "source": source,
         }
         fh.seek(0, os.SEEK_END)
-        fh.write(json.dumps(event, ensure_ascii=False) + "\n")
+        fh.write((json.dumps(event, ensure_ascii=False) + "\n").encode("utf-8"))
         fh.flush()
     return event
 
 
 def _last(fh) -> dict:
+    """The last complete event, reading only the tail (bytes: the cut may split a UTF-8 character)."""
     fh.seek(0, os.SEEK_END)
     size = fh.tell()
     fh.seek(max(0, size - 4096))
-    lines = fh.read().splitlines()
+    data = fh.read()
+    text = data.decode("utf-8", errors="replace") if isinstance(data, bytes) else data
+    lines = text.splitlines()
+    if size > 4096 and lines:
+        lines = lines[1:]  # the first line is cut by the seek: never trust it
     for line in reversed(lines):
         try:
             return json.loads(line)
@@ -99,7 +117,7 @@ def read_since(job_id: str, offset: int = 0, limit: int = 500) -> tuple[list[dic
 def last(job_id: str) -> dict:
     path = _path(job_id)
     try:
-        with path.open("r", encoding="utf-8") as fh:
+        with path.open("rb") as fh:
             return _last(fh)
-    except FileNotFoundError:
+    except (FileNotFoundError, OSError):
         return {}

{subtask_mcp-0.2.6 → subtask_mcp-0.2.8}/subtask/fastserver.py

@@ -89,8 +89,10 @@ def _wait(
             if core.known(job_id):
                 call.reporter.add(job_id)
         call.reporter.poll()
+    first = True
     while True:
-        out = core.wait(ids, 0, any, since=since)
+        out = core.wait(ids, 0, any, since=since, count=first)
+        first = False
         if not out.startswith("still running") or time.monotonic() >= deadline:
             if call.reporter:
                 call.reporter.poll()

{subtask_mcp-0.2.6 → subtask_mcp-0.2.8}/subtask/server.py

@@ -77,12 +77,14 @@ async def wait(
 
         reporter = Reporter(send, [i for i in ids if core.known(i)])
     deadline = loop.time() + max(1, min(timeout, 600))
+    first = True
     while True:
         if reporter:
             reporter.poll()
             while pending:
                 await pending.pop(0)  # never after the result: progress stops at completion
-        out = core.wait(ids, 0, any, since=since)
+        out = core.wait(ids, 0, any, since=since, count=first)
+        first = False
         if not out.startswith("still running") or loop.time() >= deadline:
             return out
         await asyncio.sleep(1)

{subtask_mcp-0.2.6 → subtask_mcp-0.2.8}/subtask_mcp.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: subtask-mcp
-Version: 0.2.6
+Version: 0.2.8
 Summary: Background sub-agents for Claude Code, Codex, Kimi and OpenCode, over MCP or CLI, with a spend cap
 License: MIT
 Project-URL: Homepage, https://github.com/tedin7/subtask
@@ -70,7 +70,7 @@ The distribution is `subtask-mcp` (the PyPI name `subtask` is an unrelated
 project). Full guide, per client, with native commands: [docs/install.md](docs/install.md).
 
 ```sh
-uv tool install "git+https://github.com/tedin7/subtask@v0.2.6"   # or: uv tool install /path/to/checkout
+uv tool install "git+https://github.com/tedin7/subtask@v0.2.8"   # or: uv tool install /path/to/checkout
 subtask install --client all          # prints the plan for every detected client
 subtask install --client all --yes    # applies it: MCP server + skill
 subtask doctor --client all           # checks app, config entry and a real handshake

{subtask_mcp-0.2.6 → subtask_mcp-0.2.8}/subtask_mcp.egg-info/SOURCES.txt

@@ -57,6 +57,7 @@ tests/test_engines.py
 tests/test_falsify.py
 tests/test_independent_client.py
 tests/test_install.py
+tests/test_live.py
 tests/test_protocol.py
 tests/test_routing_results.py
 tests/test_schema.py

subtask_mcp-0.2.8/tests/test_live.py

@@ -0,0 +1,76 @@
+"""Live adapter checks: one tiny real job per engine, through subtask itself.
+
+Marked `live`: skipped by default (pytest.ini addopts "-m 'not live'"). Run with
+`pytest -m live` when spending is authorized. Each job is capped at 0.20 USD
+(paid engines) and asks for one shell command and a one-word answer, so the
+contract with the real CLI/SDK is exercised: argv accepted, events parsed,
+session id found, result written, cost booked.
+Engines that are not installed or not logged in are skipped, never faked.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+import pytest
+
+pytestmark = pytest.mark.live
+
+TASK = "Run the shell command `echo subtask-live-ok` once, then answer with exactly that output."
+ENGINES = ["haiku-api", "opencode-go", "kimi", "codex"]
+
+
+def _cli(home: Path, *args: str, timeout: float = 300) -> str:
+    env = {**os.environ, "SUBTASK_HOME": str(home), "SUBTASK_MAX_RUNNING": "4"}
+    done = subprocess.run([sys.executable, "-m", "subtask.cli", *args], env=env, capture_output=True,
+                          text=True, timeout=timeout, check=False)  # fmt: skip
+    return done.stdout + done.stderr
+
+
+def _available(engine: str) -> str | None:
+    from subtask import config
+    from subtask.engines import registry
+
+    adapter = registry.get(engine)
+    if adapter is None or not adapter.available():
+        return f"{engine} not installed"
+    if (
+        adapter.capabilities.paid
+        and engine.endswith("-api")
+        and not config.load_secrets().get("ANTHROPIC_API_KEY")
+    ):
+        return "no ANTHROPIC_API_KEY in the subtask env file"
+    cap = adapter.capacity()
+    if cap.value is not None and cap.value < 10:
+        return f"{engine} has no quota left ({cap.note})"
+    return None
+
+
+@pytest.mark.parametrize("engine", ENGINES)
+def test_engine_runs_a_tiny_real_job(engine, tmp_path):
+    reason = _available(engine)
+    if reason:
+        pytest.skip(reason)
+    if shutil.which("git") is None:
+        pytest.skip("git missing")
+    work = tmp_path / "work"
+    work.mkdir()
+    out = _cli(tmp_path / "home", "start", TASK, "--engine", engine, "--cwd", str(work), "--max-usd", "0.2",
+               "--max-turns", "6", "--effort", "low")  # fmt: skip
+    assert " started " in out, out
+    job = out.split()[0]
+    t0 = time.time()
+    final = _cli(tmp_path / "home", "wait", job, "--timeout", "280")
+    assert " done " in final, final
+    env = json.loads(_cli(tmp_path / "home", "result", job, "--evidence"))
+    assert "subtask-live-ok" in env["summary"]["text"], env["summary"]
+    assert env["commands"]["seen"] >= 1, "no shell command observed: event format changed?"
+    if env["cost"]["reserved"] is not None:
+        assert 0 <= (env["cost"]["charged_total"] or 0) <= 0.2
+    assert time.time() - t0 < 300

{subtask_mcp-0.2.6 → subtask_mcp-0.2.8}/tests/test_protocol.py

@@ -262,3 +262,19 @@ def test_reporter_follows_the_latest_change_and_admits_missing_detail(home):
     assert rep._what(b) == progress.NO_DETAIL  # kimi plain output: no structured activity
     core.stop(a)
     core.stop(b)
+
+
+def test_a_long_wait_counts_as_one_round_trip(home):
+    """The server polls core.wait every second; that is not a parent round trip."""
+    from subtask import telemetry
+
+    fake_cli(home, "kimi", "sleep 4; echo done")
+    c = Client(_env())
+    c.send({"jsonrpc": "2.0", "id": 1, "method": "tools/call",
+            "params": {"name": "start", "arguments": {"task": "x", "engine": "kimi", "cwd": str(home)}}})  # fmt: skip
+    job = c.until(1)[0]["result"]["content"][0]["text"].split()[0]
+    c.send({"jsonrpc": "2.0", "id": 2, "method": "tools/call",
+            "params": {"name": "wait", "arguments": {"ids": [job], "timeout": 30}}})  # fmt: skip
+    c.until(2, timeout=40)
+    c.close()
+    assert [x["tool"] for x in telemetry.calls(job)].count("wait") == 1

{subtask_mcp-0.2.6 → subtask_mcp-0.2.8}/tests/test_security.py

@@ -180,3 +180,19 @@ def test_isolated_is_refused_when_bwrap_cannot_run(home, monkeypatch):
     monkeypatch.setattr(runners, "bwrap_available", lambda: False)
     out = core.start("x", engine="kimi", cwd=str(home), policy="isolated")
     assert "bubblewrap" in out and "started" not in out
+
+
+def test_progress_log_survives_multibyte_text_across_the_tail_boundary(home):
+    """Reading the last event seeks back 4096 bytes: that may land inside a UTF-8 character."""
+    import json
+
+    from subtask import events, jobs
+
+    folder = jobs.job_dir("st-utf8utf800")
+    folder.mkdir(parents=True)
+    line = json.dumps({"seq": 1, "msg": "…" * 50}, ensure_ascii=False) + "\n"  # "…" is 3 bytes
+    for pad in range(3):  # one of the three alignments puts byte -4096 inside a "…"
+        body = ("x" * pad + "\n" + line * 40).encode()
+        (folder / "progress.jsonl").write_bytes(body)
+        assert events.emit("st-utf8utf800", "tool", "dopo", source="adapter") is not None, pad
+        assert events.last("st-utf8utf800")["msg"] == "dopo"