loki-mode 10.6.7 → 10.6.9

package/mcp/__init__.py

@@ -75,4 +75,4 @@ try:
 except ImportError:
     __all__ = ['mcp']
 
-__version__ = '10.6.7'
+__version__ = '10.6.9'

package/mcp/server.py

@@ -1368,6 +1368,82 @@ async def get_pending_tasks() -> str:
 # ENTERPRISE TOOLS (P0-1)
 # ============================================================
 
+@mcp.tool()
+async def loki_v10_run(ref: str, repo_path: str) -> str:
+    """
+    Start a Loki 10 run in the background (same engine as `loki <ref>`).
+
+    Args:
+        ref: Task text or issue reference (owner/repo#N or issue URL)
+        repo_path: Repository directory (must be inside the project root)
+
+    Returns:
+        JSON with run_id (null if not yet created), pid and log_path. Never blocks.
+    """
+    _emit_tool_event_async('loki_v10_run', 'start', parameters={'repo_path': repo_path})
+    try:
+        from mcp import v10_tools
+        result = await asyncio.to_thread(
+            v10_tools.v10_run, ref, repo_path, lambda p: validate_path(p, allowed_dirs=['.']))
+        _emit_tool_event_async('loki_v10_run', 'complete', result_status='error' if isinstance(result, dict) and result.get('error') else 'success')
+        return json.dumps(result)
+    except Exception as e:
+        logger.error(f"loki_v10_run failed: {e}")
+        _emit_tool_event_async('loki_v10_run', 'complete', result_status='error', error=str(e))
+        return json.dumps({"error": str(e)})
+
+
+@mcp.tool()
+async def loki_v10_status(repo_path: str, run_id: str = "") -> str:
+    """
+    Read the state of a Loki 10 run from its events log.
+
+    Args:
+        repo_path: Repository directory containing .loki/runs
+        run_id: Run id (e10-...); defaults to the newest run
+
+    Returns:
+        JSON with phase, done, verdict (once done) and cost_usd (null if unmeasured)
+    """
+    _emit_tool_event_async('loki_v10_status', 'start', parameters={'repo_path': repo_path, 'run_id': run_id})
+    try:
+        from mcp import v10_tools
+        result = v10_tools.v10_status(
+            run_id, repo_path, lambda p: validate_path(p, allowed_dirs=['.']))
+        _emit_tool_event_async('loki_v10_status', 'complete', result_status='error' if isinstance(result, dict) and result.get('error') else 'success')
+        return json.dumps(result)
+    except Exception as e:
+        logger.error(f"loki_v10_status failed: {e}")
+        _emit_tool_event_async('loki_v10_status', 'complete', result_status='error', error=str(e))
+        return json.dumps({"error": str(e)})
+
+
+@mcp.tool()
+async def loki_v10_verify(receipt_path: str = "", repo_path: str = "") -> str:
+    """
+    Run `loki verify` on a receipt (or the newest run of a repo).
+
+    Args:
+        receipt_path: Path to a receipt.json (takes priority)
+        repo_path: Repository directory; verifies its newest run
+
+    Returns:
+        JSON with exit_code, verified and an output summary
+    """
+    _emit_tool_event_async('loki_v10_verify', 'start', parameters={'receipt_path': receipt_path, 'repo_path': repo_path})
+    try:
+        from mcp import v10_tools
+        result = await asyncio.to_thread(
+            v10_tools.v10_verify, receipt_path, repo_path,
+            lambda p: validate_path(p, allowed_dirs=['.']))
+        _emit_tool_event_async('loki_v10_verify', 'complete', result_status='error' if isinstance(result, dict) and result.get('error') else 'success')
+        return json.dumps(result)
+    except Exception as e:
+        logger.error(f"loki_v10_verify failed: {e}")
+        _emit_tool_event_async('loki_v10_verify', 'complete', result_status='error', error=str(e))
+        return json.dumps({"error": str(e)})
+
+
 @mcp.tool()
 async def loki_start_project(prd_content: str = "", prd_path: str = "") -> str:
     """

package/mcp/tests/test_v10_tools.py

@@ -0,0 +1,193 @@
+"""Unit tests for mcp/v10_tools.py with subprocess mocked."""
+
+import json
+import os
+import subprocess
+import sys
+import tempfile
+import unittest
+from unittest import mock
+
+_REPO_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..'))
+if _REPO_ROOT not in sys.path:
+    sys.path.insert(0, _REPO_ROOT)
+
+from mcp import v10_tools  # noqa: E402
+
+
+def _ok(p):
+    return os.path.realpath(p)
+
+
+def _deny(p):
+    raise PermissionError("Access denied: " + p)
+
+
+def _write_events(repo, run_id, events):
+    d = os.path.join(repo, ".loki", "runs", run_id)
+    os.makedirs(d)
+    with open(os.path.join(d, "events.jsonl"), "w") as f:
+        for e in events:
+            f.write(json.dumps(e) + "\n")
+
+
+class RunTests(unittest.TestCase):
+    def test_rejects_flag_like_ref(self):
+        with mock.patch("subprocess.Popen") as popen:
+            r = v10_tools.v10_run("--help", "/x", _ok)
+        self.assertIn("error", r)
+        popen.assert_not_called()
+
+    def test_path_validation_failure(self):
+        with mock.patch("subprocess.Popen") as popen:
+            r = v10_tools.v10_run("fix the bug", "/etc", _deny)
+        self.assertIn("Access denied", r["error"])
+        popen.assert_not_called()
+
+    def test_starts_in_background_with_arg_list(self):
+        with tempfile.TemporaryDirectory() as repo, \
+                mock.patch.object(v10_tools, "V10_RUN_ID_WAIT_S", 0), \
+                mock.patch("subprocess.Popen") as popen:
+            popen.return_value.pid = 4242
+            r = v10_tools.v10_run("fix the bug", repo, _ok)
+            args, kwargs = popen.call_args
+            self.assertEqual(args[0][1], "fix the bug")
+            self.assertIsInstance(args[0], list)
+            self.assertNotIn("shell", kwargs)
+            self.assertTrue(kwargs["start_new_session"])
+            self.assertEqual(kwargs["env"]["LOKI_ENGINE"], "v10")
+            self.assertEqual(r["pid"], 4242)
+            self.assertIsNone(r["run_id"])
+            self.assertTrue(r["log_path"].startswith(os.path.realpath(repo)))
+
+
+class EnvTests(unittest.TestCase):
+    def test_env_forces_headless_and_drops_secrets(self):
+        secrets = {"LOKI_CONTROL_TOKEN": "t", "SLACK_BOT_TOKEN": "xoxb-1", "SLACK_SIGNING_SECRET": "s",
+                   "SLACK_WEBHOOK_URL": "https://hooks.slack.com/x", "LOKI_NO_BROWSER": "0"}
+        with mock.patch.dict(os.environ, secrets):
+            env = v10_tools._env()
+        self.assertEqual(env["LOKI_NO_BROWSER"], "1")
+        self.assertEqual(env["LOKI_ENGINE"], "v10")
+        for k in ("LOKI_CONTROL_TOKEN", "SLACK_BOT_TOKEN", "SLACK_SIGNING_SECRET", "SLACK_WEBHOOK_URL"):
+            self.assertNotIn(k, env)
+
+    def test_run_child_env_has_no_secrets(self):
+        with tempfile.TemporaryDirectory() as repo, \
+                mock.patch.dict(os.environ, {"SLACK_BOT_TOKEN": "xoxb-1"}), \
+                mock.patch.object(v10_tools, "V10_RUN_ID_WAIT_S", 0), \
+                mock.patch("subprocess.Popen") as popen:
+            popen.return_value.pid = 1
+            v10_tools.v10_run("fix it", repo, _ok)
+            self.assertNotIn("SLACK_BOT_TOKEN", popen.call_args[1]["env"])
+
+
+class RefPassThroughTests(unittest.TestCase):
+    def test_jira_and_linear_refs_pass_through(self):
+        for ref in ("jira:PROJ-123", "linear:ENG-45"):
+            with tempfile.TemporaryDirectory() as repo, \
+                    mock.patch.object(v10_tools, "V10_RUN_ID_WAIT_S", 0), \
+                    mock.patch("subprocess.Popen") as popen:
+                popen.return_value.pid = 7
+                r = v10_tools.v10_run(ref, repo, _ok)
+                self.assertNotIn("error", r)
+                self.assertEqual(popen.call_args[0][0][1], ref)
+
+    def test_leading_dash_still_rejected(self):
+        with mock.patch("subprocess.Popen") as popen:
+            self.assertIn("error", v10_tools.v10_run("-jira:X", "/x", _ok))
+            popen.assert_not_called()
+
+
+class StatusTests(unittest.TestCase):
+    def test_blocked_returns_question(self):
+        ev = [
+            {"seq": 0, "type": "stage.completed", "stage": "implement",
+             "data": {"spec_conflict_reason": "spec says A\nbut tests say B"}},
+            {"seq": 1, "type": "run.completed", "stage": None, "data": {"verdict": "BLOCKED"}},
+        ]
+        with tempfile.TemporaryDirectory() as repo:
+            _write_events(repo, "e10-blk", ev)
+            r = v10_tools.v10_status("e10-blk", repo, _ok)
+        self.assertEqual(r["verdict"], "BLOCKED")
+        self.assertEqual(r["blocked_question"], "spec says A but tests say B")
+
+    def test_verified_has_no_blocked_question(self):
+        ev = [{"seq": 0, "type": "run.completed", "stage": None, "data": {"verdict": "VERIFIED"}}]
+        with tempfile.TemporaryDirectory() as repo:
+            _write_events(repo, "e10-ok", ev)
+            self.assertNotIn("blocked_question", v10_tools.v10_status("e10-ok", repo, _ok))
+
+    def test_done_run(self):
+        ev = [
+            {"seq": 0, "type": "run.started", "stage": None, "data": {}},
+            {"seq": 1, "type": "stage.started", "stage": "plan", "data": {}},
+            {"seq": 2, "type": "cost", "stage": "plan", "data": {"usd": 0.5}},
+            {"seq": 3, "type": "stage.completed", "stage": "plan", "data": {}},
+            {"seq": 4, "type": "run.completed", "stage": None, "data": {"verdict": "VERIFIED"}},
+        ]
+        with tempfile.TemporaryDirectory() as repo:
+            _write_events(repo, "e10-a", ev)
+            r = v10_tools.v10_status("", repo, _ok)
+        self.assertEqual(r["run_id"], "e10-a")
+        self.assertTrue(r["done"])
+        self.assertEqual(r["verdict"], "VERIFIED")
+        self.assertEqual(r["phase"], "done")
+        self.assertAlmostEqual(r["cost_usd"], 0.5)
+
+    def test_running_and_unmeasured_cost(self):
+        ev = [
+            {"seq": 0, "type": "stage.started", "stage": "build", "data": {}},
+            {"seq": 1, "type": "cost", "stage": "build", "data": {}},
+        ]
+        with tempfile.TemporaryDirectory() as repo:
+            _write_events(repo, "e10-b", ev)
+            r = v10_tools.v10_status("e10-b", repo, _ok)
+        self.assertFalse(r["done"])
+        self.assertEqual(r["phase"], "build")
+        self.assertIsNone(r["cost_usd"])
+        self.assertIsNone(r["verdict"])
+
+    def test_bad_run_id_and_missing(self):
+        with tempfile.TemporaryDirectory() as repo:
+            self.assertIn("error", v10_tools.v10_status("../x", repo, _ok))
+            self.assertIn("error", v10_tools.v10_status("", repo, _ok))
+            self.assertIn("error", v10_tools.v10_status("", "", _ok))
+
+
+class VerifyTests(unittest.TestCase):
+    def test_receipt_path_runs_verify(self):
+        with tempfile.TemporaryDirectory() as repo:
+            receipt = os.path.join(repo, "receipt.json")
+            open(receipt, "w").write("{}")
+            cp = subprocess.CompletedProcess([], 0, stdout="VERIFIED\n", stderr="")
+            with mock.patch("subprocess.run", return_value=cp) as run:
+                r = v10_tools.v10_verify(receipt, "", _ok)
+            args, kwargs = run.call_args
+            self.assertEqual(args[0][1:], ["verify", os.path.realpath(receipt)])
+            self.assertEqual(kwargs["timeout"], v10_tools.V10_VERIFY_TIMEOUT_S)
+            self.assertNotIn("shell", kwargs)
+        self.assertEqual(r["exit_code"], 0)
+        self.assertTrue(r["verified"])
+        self.assertIn("VERIFIED", r["output"])
+
+    def test_repo_path_nonzero_exit(self):
+        with tempfile.TemporaryDirectory() as repo:
+            cp = subprocess.CompletedProcess([], 1, stdout="", stderr="hash mismatch")
+            with mock.patch("subprocess.run", return_value=cp):
+                r = v10_tools.v10_verify("", repo, _ok)
+        self.assertEqual(r["exit_code"], 1)
+        self.assertFalse(r["verified"])
+
+    def test_timeout_and_validation(self):
+        with tempfile.TemporaryDirectory() as repo:
+            with mock.patch("subprocess.run", side_effect=subprocess.TimeoutExpired("loki", 1)):
+                self.assertIn("timed out", v10_tools.v10_verify("", repo, _ok)["error"])
+        with mock.patch("subprocess.run") as run:
+            self.assertIn("error", v10_tools.v10_verify("/etc/passwd", "", _deny))
+            self.assertIn("error", v10_tools.v10_verify("", "", _ok))
+            run.assert_not_called()
+
+
+if __name__ == "__main__":
+    unittest.main()

package/mcp/v10_tools.py

@@ -0,0 +1,182 @@
+"""Loki 10 MCP tool helpers: start a v10 run, read its status, verify a receipt.
+
+Plain functions returning dicts so they are testable without the MCP SDK; the
+thin @mcp.tool wrappers live in mcp/server.py. Subprocesses use argument lists
+only (never a shell), and every path is checked by the caller-supplied
+validator before use.
+"""
+
+import json
+import os
+import re
+import subprocess
+import time
+from pathlib import Path
+from typing import Callable, Dict, List, Optional
+
+LOKI_BIN = str(Path(__file__).resolve().parent.parent / "bin" / "loki")
+RUNS_REL = os.path.join(".loki", "runs")
+V10_RUN_ID_WAIT_S = 2.0
+V10_VERIFY_TIMEOUT_S = 120
+_TERMINAL = {"stage.completed", "stage.failed", "stage.skipped"}
+
+
+_DROPPED_ENV = ("LOKI_CONTROL_TOKEN", "SLACK_BOT_TOKEN", "SLACK_SIGNING_SECRET", "SLACK_WEBHOOK_URL")
+
+
+def _env() -> Dict[str, str]:
+    env = {k: v for k, v in os.environ.items() if k not in _DROPPED_ENV}
+    env["LOKI_ENGINE"] = "v10"
+    env["LOKI_NO_BROWSER"] = "1"
+    return env
+
+
+def _run_ids(repo: str) -> List[str]:
+    d = os.path.join(repo, RUNS_REL)
+    if not os.path.isdir(d):
+        return []
+    return sorted(n for n in os.listdir(d) if os.path.isdir(os.path.join(d, n)))
+
+
+def v10_run(ref: str, repo_path: str, validate: Callable[[str], str]) -> dict:
+    if not isinstance(ref, str) or not ref.strip() or ref.startswith("-") or "\x00" in ref:
+        return {"error": "invalid ref: must be a non-empty task or issue reference that does not start with '-'"}
+    try:
+        repo = validate(repo_path)
+    except Exception as e:  # PathTraversalError from the server validator
+        return {"error": str(e)}
+    if not os.path.isdir(repo):
+        return {"error": f"repo_path is not a directory: {repo_path}"}
+    before = set(_run_ids(repo))
+    log_dir = os.path.join(repo, ".loki")
+    os.makedirs(log_dir, exist_ok=True)
+    log_path = os.path.join(log_dir, f"v10-mcp-{int(time.time() * 1000)}.log")
+    try:
+        with open(log_path, "ab") as log:
+            proc = subprocess.Popen(
+                [LOKI_BIN, ref],
+                cwd=repo,
+                env=_env(),
+                stdin=subprocess.DEVNULL,
+                stdout=log,
+                stderr=log,
+                start_new_session=True,
+            )
+    except OSError as e:
+        return {"error": f"could not start loki: {e}"}
+    run_id: Optional[str] = None
+    deadline = time.time() + V10_RUN_ID_WAIT_S
+    while True:
+        new = [r for r in _run_ids(repo) if r not in before]
+        if new:
+            run_id = new[-1]
+            break
+        if time.time() >= deadline:
+            break
+        time.sleep(0.1)
+    return {"run_id": run_id, "pid": proc.pid, "log_path": log_path}
+
+
+def _read_events(path: str) -> List[dict]:
+    events = []
+    with open(path, "r", encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                e = json.loads(line)
+            except ValueError:
+                continue
+            if isinstance(e, dict):
+                events.append(e)
+    return events
+
+
+def v10_status(run_id: str, repo_path: str, validate: Callable[[str], str]) -> dict:
+    if not repo_path:
+        return {"error": "repo_path is required"}
+    try:
+        repo = validate(repo_path)
+    except Exception as e:
+        return {"error": str(e)}
+    if run_id:
+        if "/" in run_id or "\\" in run_id or run_id.startswith(".") or "\x00" in run_id:
+            return {"error": "invalid run_id"}
+    else:
+        ids = _run_ids(repo)
+        if not ids:
+            return {"error": "no v10 runs found under .loki/runs"}
+        run_id = ids[-1]
+    events_path = os.path.join(repo, RUNS_REL, run_id, "events.jsonl")
+    if not os.path.isfile(events_path):
+        return {"error": f"no events.jsonl for run {run_id}"}
+    events = _read_events(events_path)
+    open_stages: Dict[str, bool] = {}
+    verdict = None
+    question = None
+    done = False
+    usd = 0.0
+    saw_cost = False
+    unmeasured = False
+    for e in events:
+        t, stage = e.get("type"), e.get("stage")
+        data = e.get("data") if isinstance(e.get("data"), dict) else {}
+        if stage:
+            if t == "stage.started":
+                open_stages[stage] = True
+            elif t in _TERMINAL:
+                open_stages.pop(stage, None)
+        if t == "stage.completed" and stage == "implement" and isinstance(data.get("spec_conflict_reason"), str):
+            question = re.sub(r"[\x00-\x1f\x7f]+", " ", data["spec_conflict_reason"])[:500]
+        if t == "run.completed":
+            done = True
+            verdict = data.get("verdict") if isinstance(data.get("verdict"), str) else None
+        elif t == "cost":
+            saw_cost = True
+            if isinstance(data.get("usd"), (int, float)):
+                usd += data["usd"]
+            else:
+                unmeasured = True
+    phase = "done" if done else ("+".join(sorted(open_stages)) or "starting")
+    result = {
+        "run_id": run_id,
+        "phase": phase,
+        "done": done,
+        "verdict": verdict,
+        "cost_usd": usd if saw_cost and not unmeasured else None,
+        "events": len(events),
+    }
+    if verdict == "BLOCKED":
+        result["blocked_question"] = question or "see the receipt"
+    return result
+
+
+def v10_verify(receipt_path: str, repo_path: str, validate: Callable[[str], str]) -> dict:
+    args = [LOKI_BIN, "verify"]
+    try:
+        if receipt_path:
+            receipt = validate(receipt_path)
+            if not os.path.isfile(receipt):
+                return {"error": f"receipt not found: {receipt_path}"}
+            args.append(receipt)
+            cwd = os.path.dirname(receipt)
+        elif repo_path:
+            cwd = validate(repo_path)
+            if not os.path.isdir(cwd):
+                return {"error": f"repo_path is not a directory: {repo_path}"}
+        else:
+            return {"error": "receipt_path or repo_path is required"}
+    except Exception as e:
+        return {"error": str(e)}
+    try:
+        p = subprocess.run(
+            args, cwd=cwd, env=_env(), stdin=subprocess.DEVNULL,
+            capture_output=True, text=True, timeout=V10_VERIFY_TIMEOUT_S,
+        )
+    except subprocess.TimeoutExpired:
+        return {"error": f"loki verify timed out after {V10_VERIFY_TIMEOUT_S}s"}
+    except OSError as e:
+        return {"error": f"could not run loki verify: {e}"}
+    out = ((p.stdout or "") + (p.stderr or "")).strip()
+    return {"exit_code": p.returncode, "verified": p.returncode == 0, "output": out[-2000:]}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "loki-mode",
   "mcpName": "io.github.asklokesh/loki-mode",
-  "version": "10.6.7",
+  "version": "10.6.9",
   "description": "An autonomous software factory that knows what it is supposed to deliver, and proves it did.",
   "keywords": [
     "agent",