tylor-mcp 1.1.0 → 1.1.2

package/server/tools/security.py

@@ -1,5 +1,6 @@
 """Bumblebee security gate and risky execution guard."""
 from __future__ import annotations
+import asyncio
 import json
 import os
 import re
@@ -160,3 +161,143 @@ def validate_skill_package(source_path: str | Path) -> None:
             "Bumblebee security gate blocked skill installation because the scan detected risky exposure. "
             f"stdout: {stdout} stderr: {stderr}"
         )
+
+
+# ── Dependency file watcher ───────────────────────────────────────────────────
+
+DEP_FILES: frozenset[str] = frozenset({
+    "requirements.txt",
+    "package.json",
+    "package-lock.json",
+    "yarn.lock",
+    "poetry.lock",
+    "Pipfile.lock",
+    "pyproject.toml",
+})
+
+PUSH_PATTERNS: list[re.Pattern] = [
+    re.compile(r"\bgit\s+push\b", re.I),
+]
+
+
+def is_dep_file(path: str) -> bool:
+    return Path(path).name in DEP_FILES
+
+
+def should_prompt_on_push(command: str) -> bool:
+    return any(p.search(command) for p in PUSH_PATTERNS)
+
+
+# ── Async package scanners ────────────────────────────────────────────────────
+
+async def _run_scanner_async(args: list[str], cwd: str, timeout: int = 60) -> tuple[int, str, str]:
+    try:
+        result = await asyncio.to_thread(
+            subprocess.run,
+            args,
+            cwd=cwd,
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+            check=False,
+        )
+        return result.returncode, result.stdout.strip(), result.stderr.strip()
+    except (OSError, subprocess.TimeoutExpired, FileNotFoundError) as exc:
+        return -1, "", str(exc)
+
+
+def _parse_pip_audit(stdout: str) -> list[str]:
+    try:
+        data = json.loads(stdout)
+    except (json.JSONDecodeError, ValueError):
+        return []
+    findings: list[str] = []
+    deps = data.get("dependencies", []) if isinstance(data, dict) else (data if isinstance(data, list) else [])
+    for dep in deps:
+        for vuln in dep.get("vulns", []):
+            pkg = dep.get("name", "?")
+            ver = dep.get("version", "?")
+            vid = vuln.get("id", "?")
+            desc = (vuln.get("description") or "")[:120]
+            findings.append(f"{pkg}=={ver} [{vid}]: {desc}")
+    return findings
+
+
+def _parse_npm_audit(stdout: str) -> list[str]:
+    try:
+        data = json.loads(stdout)
+    except (json.JSONDecodeError, ValueError):
+        return []
+    findings: list[str] = []
+    vulns = data.get("vulnerabilities", {})
+    for name, info in (vulns.items() if isinstance(vulns, dict) else []):
+        severity = info.get("severity", "?")
+        via = info.get("via", [])
+        title = (via[0].get("title", "") if via and isinstance(via[0], dict) else "") or name
+        findings.append(f"{name} ({severity}): {title}")
+        if len(findings) >= 20:
+            break
+    return findings
+
+
+def _parse_bumblebee_findings(stdout: str) -> list[str]:
+    parsed = _parse_bumblebee_output(stdout)
+    if not _is_risky_scan_result(parsed):
+        return []
+    if isinstance(parsed, dict):
+        for key in ("findings", "issues", "alerts", "warnings", "violations"):
+            items = parsed.get(key)
+            if isinstance(items, list) and items:
+                return [str(item)[:200] for item in items[:10]]
+    return ["bumblebee detected risky exposure"]
+
+
+def _parse_safety(stdout: str) -> list[str]:
+    try:
+        data = json.loads(stdout)
+    except (json.JSONDecodeError, ValueError):
+        return []
+    findings: list[str] = []
+    for item in (data if isinstance(data, list) else [])[:20]:
+        if isinstance(item, list) and len(item) >= 4:
+            pkg, _, installed, desc = item[0], item[1], item[2], item[3]
+            findings.append(f"{pkg}=={installed}: {str(desc)[:120]}")
+    return findings
+
+
+async def scan_packages_async(cwd: str | None = None) -> list[str]:
+    """
+    Non-blocking vulnerability scan. Tries pip-audit → npm audit → bumblebee → safety.
+    Returns deduplicated finding strings. Never raises — errors are swallowed silently.
+    """
+    cwd_str = str(Path(cwd or os.getcwd()).expanduser())
+    findings: list[str] = []
+
+    if shutil.which("pip-audit"):
+        rc, out, _ = await _run_scanner_async(["pip-audit", "--format=json", "-q"], cwd_str)
+        if out:
+            findings.extend(_parse_pip_audit(out))
+
+    if (Path(cwd_str) / "package.json").exists() and shutil.which("npm"):
+        _, out, _ = await _run_scanner_async(["npm", "audit", "--json"], cwd_str)
+        if out:
+            findings.extend(_parse_npm_audit(out))
+
+    bb = _bumblebee_path()
+    if bb:
+        rc, out, _ = await _run_scanner_async([bb, "scan", "--json"], cwd_str)
+        if out:
+            findings.extend(_parse_bumblebee_findings(out))
+
+    if not shutil.which("pip-audit") and shutil.which("safety"):
+        rc, out, _ = await _run_scanner_async(["safety", "check", "--json"], cwd_str)
+        if out:
+            findings.extend(_parse_safety(out))
+
+    seen: set[str] = set()
+    deduped: list[str] = []
+    for f in findings:
+        if f not in seen:
+            seen.add(f)
+            deduped.append(f)
+    return deduped

package/skills/tylor-run/SKILL.md

@@ -0,0 +1,61 @@
+---
+name: tylor-run
+description: Activate Tylor to handle a task. Routes the request through the full Tylor harness — intent classification, skill auto-loading, multi-agent orchestration, and Bumblebee security scanning. All responses are labelled Tylor: so you always know the plugin is running, not native Claude/Codex/Antigravity.
+---
+
+# /Tylor_run
+
+Use when the user invokes `/Tylor_run <task>` or explicitly wants Tylor to handle a request.
+
+## How it works
+
+1. Resolve the active thread ID — call `list_threads()` and pick the most recently active thread, or use one the user has already switched to.
+2. Call `run_in_thread(thread_id=<active_thread_id>, message=<user_task>, cwd=<project_dir>)`.
+3. Stream the result back exactly as returned — do not paraphrase or summarise it. The response already starts with `Tylor:` so the user can see the plugin is running.
+
+## What Tylor does automatically (no commands needed)
+
+- Classifies intent and selects the right role(s): researcher, implementer, reviewer, planner, drafter
+- Auto-loads ECC skill groups (ecc/web, ecc/data, ecc/presentation, ecc/diagrams, ecc/pipeline) based on the task
+- Runs a Bumblebee session-start security scan on first use in a thread
+- Watches for dependency file changes and scans them inline
+- Prompts before git push
+- Spawns multiple agents in parallel when the task warrants it
+- Streams a live orchestration log so the user can follow what is happening
+
+## Example interactions
+
+```
+/Tylor_run research the top 3 CI/CD tools and draft a comparison doc
+→ Tylor:
+  [agent101] intent classified: researcher, drafter
+  [agent101] auto-loaded skill: ecc/web (web_scrape, web_fetch)
+  [agent101] auto-loaded skill: ecc/presentation (build_doc)
+  [bumblebee] starting session-start package scan...
+  [agent: researcher #1] starting — gather CI/CD tool comparisons
+  $ web_fetch
+  $ web_fetch
+  [agent: researcher #1] done
+  [agent: drafter #2] starting — build comparison doc from research
+  $ build_doc
+  [agent: drafter #2] done
+  [bumblebee] ✅ session-start scan — no vulnerabilities found
+  [supervisor] complete — 2 agents ran
+
+/Tylor_run fix the failing auth tests
+→ Tylor:
+  [agent101] intent classified: implementer
+  [agent: implementer #1] starting — fix failing auth tests
+  $ Read
+  $ Edit
+  $ Bash
+  [agent: implementer #1] done
+  [supervisor] complete — 1 agent ran
+```
+
+## Notes
+
+- The `Tylor:` label at the top of every response confirms the plugin is active — not native Claude Code, Codex, or Antigravity
+- Works identically across all supported platforms: Claude Code CLI, Claude Desktop, GitHub Copilot CLI, Antigravity
+- If no thread is active, suggest the user run `/new-thread <name>` first
+- Pass `cwd` as the current project directory so agents have filesystem context

package/server/server.log

@@ -1 +0,0 @@
-zsh: command not found: python

package/server/storage/tests/test_dynamo.py

@@ -1,452 +0,0 @@
-"""
-Tests for Story 2.1: DynamoDB Storage Client
-Run: pytest server/storage/tests/test_dynamo.py -v
-"""
-import sys
-from pathlib import Path
-from unittest.mock import MagicMock, patch, call
-
-import pytest
-
-PLUGIN_DIR = Path(__file__).parent.parent.parent.parent
-sys.path.insert(0, str(PLUGIN_DIR))
-
-from mcp.server.fastmcp.exceptions import ToolError
-from server.storage.dynamo import DynamoClient, ITEM_SIZE_LIMIT
-
-
-# ---------------------------------------------------------------------------
-# Helpers
-# ---------------------------------------------------------------------------
-
-def make_client(mock_table=None):
-    """Return a DynamoClient with a mocked DynamoDB table."""
-    with patch("boto3.Session") as mock_session_cls:
-        mock_session = MagicMock()
-        mock_session_cls.return_value = mock_session
-        resource = MagicMock()
-        mock_session.resource.return_value = resource
-        table = mock_table or MagicMock()
-        resource.Table.return_value = table
-        client = DynamoClient(table_name="agent101", user_id="testuser")
-        client.table = table  # keep reference for assertions
-        return client, table
-
-
-# ---------------------------------------------------------------------------
-# AC1: Initialises boto3 on import with configured profile
-# ---------------------------------------------------------------------------
-
-def test_init_creates_boto3_session_no_profile():
-    with patch("boto3.Session") as mock_session_cls:
-        mock_session = MagicMock()
-        mock_session_cls.return_value = mock_session
-        resource = MagicMock()
-        mock_session.resource.return_value = resource
-        resource.Table.return_value = MagicMock()
-
-        DynamoClient(table_name="agent101", user_id="u1")
-
-    mock_session_cls.assert_called_once_with()
-    mock_session.resource.assert_called_once_with("dynamodb")
-
-
-def test_init_creates_boto3_session_with_profile():
-    with patch("boto3.Session") as mock_session_cls:
-        mock_session = MagicMock()
-        mock_session_cls.return_value = mock_session
-        resource = MagicMock()
-        mock_session.resource.return_value = resource
-        resource.Table.return_value = MagicMock()
-
-        DynamoClient(table_name="agent101", user_id="u1", profile="myprofile")
-
-    mock_session_cls.assert_called_once_with(profile_name="myprofile")
-
-
-# ---------------------------------------------------------------------------
-# AC2: put_item writes mandatory base fields for ≤400KB item
-# ---------------------------------------------------------------------------
-
-def test_put_item_injects_mandatory_fields():
-    client, table = make_client()
-    table.get_item.return_value = {}  # item doesn't exist yet
-    table.put_item.return_value = {}
-
-    sk = "THREAD#t1#META"
-    result = client.put_item(sk=sk, attributes={"Name": "alpha"})
-
-    assert result["PK"] == "USER#testuser"
-    assert result["SK"] == sk
-    assert "CreatedAt" in result
-    assert "UpdatedAt" in result
-    assert isinstance(result["Version"], int)
-    assert result["Version"] == 1
-    # Verify DynamoDB was actually called
-    table.put_item.assert_called_once()
-
-
-def test_put_item_passes_correct_item_to_dynamo():
-    client, table = make_client()
-    table.get_item.return_value = {}
-    table.put_item.return_value = {}
-
-    result = client.put_item(sk="THREAD#t1#META", attributes={"Name": "beta"})
-
-    written = table.put_item.call_args.kwargs["Item"]
-    assert written["Name"] == "beta"
-    assert written["PK"] == "USER#testuser"
-
-
-def test_put_item_preserves_created_at_on_update():
-    """UpdatedAt changes; CreatedAt stays the same on subsequent writes."""
-    client, table = make_client()
-    # Simulate existing item
-    existing = {
-        "PK": "USER#testuser",
-        "SK": "THREAD#t1#META",
-        "CreatedAt": "2026-01-01T00:00:00Z",
-        "UpdatedAt": "2026-01-01T00:00:00Z",
-        "Version": 3,
-        "Name": "old",
-    }
-    table.get_item.return_value = {"Item": existing}
-    table.put_item.return_value = {}
-
-    result = client.put_item(sk="THREAD#t1#META", attributes={"Name": "new"})
-
-    assert result["CreatedAt"] == "2026-01-01T00:00:00Z"
-    assert result["Version"] == 4  # incremented
-
-
-# ---------------------------------------------------------------------------
-# AC3: put_item rejects items > 400KB
-# ---------------------------------------------------------------------------
-
-def test_put_item_rejects_oversized_item():
-    client, table = make_client()
-    table.get_item.return_value = {}
-
-    big_content = "x" * (ITEM_SIZE_LIMIT + 10_000)
-    with pytest.raises(ToolError, match="400KB"):
-        client.put_item(sk="THREAD#t1#MSG#ts", attributes={"Content": big_content})
-
-    table.put_item.assert_not_called()
-
-
-def test_put_item_accepts_item_at_size_limit():
-    """Item at exactly ITEM_SIZE_LIMIT should not raise (boundary check)."""
-    client, table = make_client()
-    table.get_item.return_value = {}
-    table.put_item.return_value = {}
-
-    # A small item well under 400KB should pass
-    small = {"Content": "x" * 100}
-    result = client.put_item(sk="THREAD#t1#META", attributes=small)
-    assert result["Version"] == 1
-
-
-# ---------------------------------------------------------------------------
-# AC4: Thread isolation enforced on get_item, query_thread, delete_item
-# ---------------------------------------------------------------------------
-
-def test_get_item_raises_on_isolation_violation():
-    client, table = make_client()
-    with pytest.raises(ToolError, match="Thread isolation violation"):
-        client.get_item(thread_id="t1", sk="THREAD#t2#META")
-
-
-def test_get_item_passes_when_sk_matches_thread():
-    client, table = make_client()
-    table.get_item.return_value = {"Item": {"PK": "USER#testuser", "SK": "THREAD#t1#META"}}
-
-    result = client.get_item(thread_id="t1", sk="THREAD#t1#META")
-    assert result is not None
-
-
-def test_get_item_returns_none_when_not_found():
-    client, table = make_client()
-    table.get_item.return_value = {}  # no "Item" key
-
-    result = client.get_item(thread_id="t1", sk="THREAD#t1#META")
-    assert result is None
-
-
-def test_query_thread_raises_on_isolation_violation():
-    client, table = make_client()
-    with pytest.raises(ToolError, match="Thread isolation violation"):
-        client.query_thread(thread_id="t1", sk_prefix="THREAD#t2#MSG")
-
-
-def test_query_thread_passes_correct_prefix():
-    client, table = make_client()
-    table.query.return_value = {"Items": [{"SK": "THREAD#t1#MSG#001"}]}
-
-    items = client.query_thread(thread_id="t1", sk_prefix="THREAD#t1#MSG")
-    assert len(items) == 1
-    table.query.assert_called_once()
-
-
-def test_delete_item_raises_on_isolation_violation():
-    client, table = make_client()
-    with pytest.raises(ToolError, match="Thread isolation violation"):
-        client.delete_item(thread_id="t1", sk="THREAD#t2#META")
-
-
-def test_delete_item_calls_dynamo_delete():
-    client, table = make_client()
-    table.delete_item.return_value = {}
-
-    client.delete_item(thread_id="t1", sk="THREAD#t1#META")
-
-    table.delete_item.assert_called_once_with(
-        Key={"PK": "USER#testuser", "SK": "THREAD#t1#META"}
-    )
-
-
-# ---------------------------------------------------------------------------
-# Story 3.3: Sub-agent output and handoff persistence
-# ---------------------------------------------------------------------------
-
-def test_put_agent_output_writes_expected_thread_scoped_sk():
-    client, table = make_client()
-    table.get_item.return_value = {}
-    table.put_item.return_value = {}
-
-    item = client.put_agent_output(
-        thread_id="t1",
-        agent_id="agent_a",
-        output="Agent A completed analysis.",
-        task="Analyze risk.",
-    )
-
-    assert item["SK"].startswith("THREAD#t1#AGENT#agent_a#OUT#")
-    assert item["ThreadId"] == "t1"
-    assert item["AgentId"] == "agent_a"
-    assert item["Type"] == "agent_output"
-    assert item["Output"] == "Agent A completed analysis."
-    assert item["Task"] == "Analyze risk."
-
-
-def test_put_agent_output_generates_unique_sk_for_rapid_writes():
-    client, table = make_client()
-    table.get_item.return_value = {}
-    table.put_item.return_value = {}
-
-    first = client.put_agent_output(
-        thread_id="t1",
-        agent_id="agent_a",
-        output="First output.",
-    )
-    second = client.put_agent_output(
-        thread_id="t1",
-        agent_id="agent_a",
-        output="Second output.",
-    )
-
-    assert first["SK"] != second["SK"]
-    assert first["SK"].startswith("THREAD#t1#AGENT#agent_a#OUT#")
-    assert second["SK"].startswith("THREAD#t1#AGENT#agent_a#OUT#")
-
-
-def test_put_agent_handoff_writes_distinct_thread_scoped_sk():
-    client, table = make_client()
-    table.get_item.return_value = {}
-    table.put_item.return_value = {}
-    handoff = {"next_agent": "agent_b", "summary": "Carry this forward."}
-
-    item = client.put_agent_handoff(
-        thread_id="t1",
-        agent_id="agent_a",
-        handoff_state=handoff,
-    )
-
-    assert item["SK"].startswith("THREAD#t1#AGENT#agent_a#HANDOFF#")
-    assert item["ThreadId"] == "t1"
-    assert item["AgentId"] == "agent_a"
-    assert item["Type"] == "agent_handoff"
-    assert item["HandoffState"] == handoff
-
-
-def test_put_agent_handoff_generates_unique_sk_for_rapid_writes():
-    client, table = make_client()
-    table.get_item.return_value = {}
-    table.put_item.return_value = {}
-
-    first = client.put_agent_handoff(
-        thread_id="t1",
-        agent_id="agent_a",
-        handoff_state={"step": 1},
-    )
-    second = client.put_agent_handoff(
-        thread_id="t1",
-        agent_id="agent_a",
-        handoff_state={"step": 2},
-    )
-
-    assert first["SK"] != second["SK"]
-    assert first["SK"].startswith("THREAD#t1#AGENT#agent_a#HANDOFF#")
-    assert second["SK"].startswith("THREAD#t1#AGENT#agent_a#HANDOFF#")
-
-
-def test_put_agent_state_writes_thread_scoped_state_record():
-    client, table = make_client()
-    table.get_item.return_value = {}
-    table.put_item.return_value = {}
-
-    item = client.put_agent_state(
-        thread_id="t1",
-        agent_id="agent_a",
-        state={
-            "Status": "active",
-            "Persona": "analyst",
-            "Task": "Analyze risk.",
-            "ToolsLoaded": ["ecc/web", "ecc/data"],
-        },
-    )
-
-    assert item["SK"] == "THREAD#t1#AGENT#agent_a#STATE"
-    assert item["ThreadId"] == "t1"
-    assert item["AgentId"] == "agent_a"
-    assert item["Type"] == "agent_state"
-    assert item["Status"] == "active"
-    assert item["Persona"] == "analyst"
-
-
-def test_query_agent_states_is_scoped_to_thread_prefix():
-    client, table = make_client()
-    table.query.return_value = {
-        "Items": [
-            {"SK": "THREAD#t1#AGENT#agent_a#STATE", "ThreadId": "t1"},
-        ]
-    }
-
-    result = client.query_agent_states("t1")
-
-    assert result == [{"SK": "THREAD#t1#AGENT#agent_a#STATE", "ThreadId": "t1"}]
-    table.query.assert_called_once()
-
-
-def test_agent_output_rejects_cross_thread_sk_injection():
-    client, table = make_client()
-    with pytest.raises(ToolError, match="Invalid agent_id"):
-        client.put_agent_output(
-            thread_id="t1",
-            agent_id="THREAD#t2#AGENT#agent_a",
-            output="bad",
-        )
-    table.put_item.assert_not_called()
-
-
-def test_switch_thread_suspends_previous_agents_and_resumes_target_agents():
-    client, table = make_client()
-
-    def raw_get_side_effect(Key):
-        sk = Key["SK"]
-        items = {
-            "THREAD#CURRENT#META": {
-                "PK": "USER#testuser",
-                "SK": "THREAD#CURRENT#META",
-                "CurrentThreadId": "thread_alpha",
-                "ActiveAt": "2026-05-12T00:00:00Z",
-                "CreatedAt": "2026-05-12T00:00:00Z",
-                "UpdatedAt": "2026-05-12T00:00:00Z",
-                "Version": 1,
-            },
-            "THREAD#thread_alpha#META": {
-                "PK": "USER#testuser",
-                "SK": "THREAD#thread_alpha#META",
-                "Version": 1,
-            },
-            "THREAD#thread_beta#META": {
-                "PK": "USER#testuser",
-                "SK": "THREAD#thread_beta#META",
-                "Version": 1,
-            },
-        }
-        item = items.get(sk)
-        return {"Item": item} if item else {}
-
-    table.get_item.side_effect = raw_get_side_effect
-
-    query_results = [
-        {
-            "Items": [
-                {
-                    "PK": "USER#testuser",
-                    "SK": "THREAD#thread_alpha#AGENT#agent_a#STATE",
-                    "ThreadId": "thread_alpha",
-                    "AgentId": "agent_a",
-                    "Status": "active",
-                    "Version": 1,
-                }
-            ]
-        },
-        {
-            "Items": [
-                {
-                    "PK": "USER#testuser",
-                    "SK": "THREAD#thread_beta#AGENT#agent_b#STATE",
-                    "ThreadId": "thread_beta",
-                    "AgentId": "agent_b",
-                    "Status": "suspended",
-                    "Version": 1,
-                }
-            ]
-        },
-    ]
-    table.query.side_effect = query_results
-
-    result = client.switch_thread("thread_beta")
-
-    assert result["thread_id"] == "thread_beta"
-    writes = client._client.transact_write_items.call_args.kwargs["TransactItems"]
-    serialised = [w["Put"]["Item"] for w in writes if w["Put"]["Item"]["SK"]["S"].endswith("#STATE")]
-    statuses = {item["SK"]["S"]: item["Status"]["S"] for item in serialised}
-    assert statuses["THREAD#thread_alpha#AGENT#agent_a#STATE"] == "suspended"
-    assert statuses["THREAD#thread_beta#AGENT#agent_b#STATE"] == "active"
-
-
-# ---------------------------------------------------------------------------
-# AC5: Version increments on every write
-# ---------------------------------------------------------------------------
-
-def test_version_starts_at_1_for_new_item():
-    client, table = make_client()
-    table.get_item.return_value = {}
-    table.put_item.return_value = {}
-
-    result = client.put_item(sk="THREAD#t1#META", attributes={})
-    assert result["Version"] == 1
-
-
-def test_version_increments_on_subsequent_writes():
-    client, table = make_client()
-    existing = {
-        "PK": "USER#testuser",
-        "SK": "THREAD#t1#META",
-        "CreatedAt": "2026-01-01T00:00:00Z",
-        "UpdatedAt": "2026-01-01T00:00:00Z",
-        "Version": 7,
-    }
-    table.get_item.return_value = {"Item": existing}
-    table.put_item.return_value = {}
-
-    result = client.put_item(sk="THREAD#t1#META", attributes={})
-    assert result["Version"] == 8
-
-
-# ---------------------------------------------------------------------------
-# ISO 8601 date format
-# ---------------------------------------------------------------------------
-
-def test_created_at_is_iso_8601_utc():
-    import re
-    client, table = make_client()
-    table.get_item.return_value = {}
-    table.put_item.return_value = {}
-
-    result = client.put_item(sk="THREAD#t1#META", attributes={})
-    # Must match YYYY-MM-DDTHH:MM:SSZ
-    assert re.match(r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$", result["CreatedAt"])
-    assert re.match(r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$", result["UpdatedAt"])