meshcode 2.1.1__tar.gz → 2.2.0__tar.gz

{meshcode-2.1.1 → meshcode-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcode
-Version: 2.1.1
+Version: 2.2.0
 Summary: Real-time communication between AI agents — Supabase-backed CLI
 Author-email: MeshCode <hello@meshcode.io>
 License: MIT

{meshcode-2.1.1 → meshcode-2.2.0}/meshcode/__init__.py

@@ -1,2 +1,2 @@
 """MeshCode — Real-time communication between AI agents."""
-__version__ = "2.1.1"
+__version__ = "2.2.0"

{meshcode-2.1.1 → meshcode-2.2.0}/meshcode/meshcode_mcp/server.py

@@ -289,6 +289,15 @@ if not _PROJECT_ID:
     print(f"[meshcode-mcp] ERROR: project '{PROJECT_NAME}' not found (check MESHCODE_KEYCHAIN_PROFILE / MESHCODE_API_KEY)", file=sys.stderr)
     sys.exit(2)
 
+# Resolve project plan for adaptive features (heartbeat interval, etc.)
+_PROJECT_PLAN = "free"
+try:
+    _plan_rows = be.sb_select("mc_projects", f"id=eq.{_PROJECT_ID}", limit=1)
+    if _plan_rows and isinstance(_plan_rows, list) and len(_plan_rows) > 0:
+        _PROJECT_PLAN = _plan_rows[0].get("plan", "free") or "free"
+except Exception:
+    pass  # default to free
+
 _register_result = be.register_agent(PROJECT_NAME, AGENT_NAME, AGENT_ROLE or "MCP-connected agent")
 if isinstance(_register_result, dict) and _register_result.get("error"):
     print(f"[meshcode-mcp] WARNING: register failed: {_register_result['error']}", file=sys.stderr)
@@ -342,6 +351,7 @@ _current_state = "online"
 _last_tool_at = _time.time()
 _current_tool = ""
 _IDLE_THRESHOLD_S = 120  # seconds without tool call → IDLE
+_SLEEPING_THRESHOLD_S = 300  # seconds in waiting without activity → SLEEPING
 _WORKING_COOLDOWN_S = 60  # seconds after last tool returns before flipping to ONLINE
 _working_timer: Optional[_threading.Timer] = None
 
@@ -422,12 +432,10 @@ def with_working_status(func):
                 return func(*args, **kwargs)
             finally:
                 if not skip:
-                    global _last_tool_at, _processing_timer
+                    global _last_tool_at
                     _last_tool_at = _time.time()
-                    _set_state("processing", "processing...")
-                    _processing_timer = _threading.Timer(_PROCESSING_COOLDOWN_S, _processing_to_online)
-                    _processing_timer.daemon = True
-                    _processing_timer.start()
+                    # Don't flip to online here — CPU-based detection in heartbeat
+                    # will handle the transition when LLM stops generating
         return swrapper
 
 
@@ -565,23 +573,21 @@ def _build_instructions() -> str:
     )
     base = f"""You are agent "{AGENT_NAME}" in meshwork "{PROJECT_NAME}".{role_block}{launch_block}
 
-BEHAVIOR LOOP (your default state — never exit unless told):
-1. Act on task/message → 2. meshcode_send if needed → 3. meshcode_wait()
-4. On message → back to 1. On timeout → meshcode_wait(2x timeout, cap 1800s).
-   Reset to 60s on any message. On got_done → exit loop, summarize, stop.
-5. Only break loop if: user says stop, fatal error, or "tell the human X".
+PERMANENT LOOP (MANDATORY — #1 RULE):
+You MUST stay in meshcode_wait() forever. After EVERY action, call meshcode_wait().
+NEVER exit. NEVER stop. NEVER say "standing by" without calling meshcode_wait().
+The ONLY exits: user says "stop", got_done signal, or fatal error.
+Timeout? Call meshcode_wait() again with 2x timeout (cap 1800s).
+
+LOOP: act → meshcode_send if needed → meshcode_wait() → repeat.
 
 RULES:
-- NEVER use CLI commands (meshcode watch, meshcode read, meshcode send) in bash.
-  Use ONLY the MCP tools: meshcode_check, meshcode_read, meshcode_send, meshcode_wait.
-  CLI commands are for humans in terminal. You have MCP tools — use them.
-- Tasks > messages. Use meshcode_tasks/claim/complete for trackable work.
-- Messages <100 tokens, signal-only. Long content → create task instead.
-- No empty acks ("OK"/"Got it"). No prose padding. JSON reports only.
-- Poll meshcode_tasks() before each meshcode_wait().
-- Threading: pass in_reply_to with original msg id.
-- sensitive=True for credentials/secrets/PII in meshcode_send.
-- No feedback loops: stop if >10 messages on same topic.
+- Use MCP tools only (never CLI commands in bash).
+- Tasks > messages. Claim tasks via meshcode_tasks/task_claim/task_complete.
+- Messages <100 tokens. Long content → create task.
+- No empty acks. JSON reports only.
+- Threading: pass in_reply_to.
+- sensitive=True for secrets/PII.
 
 SESSION START:
 1. meshcode_set_status(status="online", task="ready") — announce you're online
@@ -716,18 +722,22 @@ def _heartbeat_thread_fn():
         try:
             be.sb_rpc("mc_heartbeat", {"p_project_id": _PROJECT_ID, "p_agent_name": AGENT_NAME, "p_version": "2.0.0"})
 
-            # CPU-based status detection: check parent process (editor/LLM) CPU usage
-            if _current_state not in ("waiting",):  # Don't override explicit WAITING
-                parent_cpu = _get_parent_cpu()
-                if parent_cpu > 5.0:
-                    # LLM is actively generating tokens
-                    if _current_state != "working":
-                        _set_state("working", "generating response")
-                elif _current_state == "working" and parent_cpu <= 5.0:
-                    # LLM just finished — flip to online
-                    _set_state("online", "")
-                elif _current_state == "online" and (_time.time() - _last_tool_at) > _IDLE_THRESHOLD_S:
-                    _set_state("idle", f"idle ({int((_time.time() - _last_tool_at) / 60)}m)")
+            # CPU-based status detection
+            parent_cpu = _get_parent_cpu()
+            idle_secs = _time.time() - _last_tool_at
+
+            if _current_state == "waiting":
+                pass  # In meshcode_wait loop — NEVER override. Agent is listening.
+            elif parent_cpu > 5.0:
+                # LLM is actively generating tokens
+                if _current_state != "working":
+                    _set_state("working", "generating response")
+            elif _current_state == "working":
+                # LLM just stopped — brief online before sleeping
+                _set_state("online", "")
+            elif _current_state in ("online", "idle") and idle_secs > 30:
+                # Not in loop, not thinking → sleeping
+                _set_state("sleeping", "sleeping")
 
             # Sync current state to DB (in case realtime missed it)
             try:
@@ -755,7 +765,10 @@ def _heartbeat_thread_fn():
             except Exception as e:
                 log.warning(f"lease renewal failed: {e}")
 
-        _heartbeat_stop.wait(30)  # sleep but interruptible on shutdown
+        # Adaptive heartbeat: fast for paid plans, moderate for free
+        # Free: 15s (~6K req/day/agent). Pro+: 5s (~17K req/day/agent).
+        hb_interval = 5 if _PROJECT_PLAN in ("pro", "team", "enterprise", "unlimited") else 15
+        _heartbeat_stop.wait(hb_interval)
 
 
 @asynccontextmanager
@@ -833,14 +846,7 @@ except Exception:
 @with_working_status
 def meshcode_send(to: str, message: Any, in_reply_to: Optional[str] = None,
                   sensitive: bool = False) -> Dict[str, Any]:
-    """Send a message to an agent. Use "agent@meshwork" for cross-mesh.
-
-    Args:
-        to: Recipient agent name (or agent@meshwork for cross-mesh).
-        message: String or dict payload.
-        in_reply_to: Original message id for threading.
-        sensitive: True to hide from public exports.
-    """
+    """Send message. Use "agent@meshwork" for cross-mesh. sensitive=True hides from exports."""
     if isinstance(message, str):
         payload: Dict[str, Any] = {"text": message}
     elif isinstance(message, dict):
@@ -884,16 +890,7 @@ def meshcode_broadcast(payload: Dict[str, Any]) -> Dict[str, Any]:
 @mcp.tool()
 @with_working_status
 def meshcode_read(include_acks: bool = False) -> Dict[str, Any]:
-    """Read and mark-read all pending messages. ACKs senders.
-
-    Returns a split shape: `messages` (real msgs), `acks`, and `done_signals`
-    — so you don't have to filter by type yourself.
-
-    Args:
-        include_acks: If False (default), type='ack' rows are dropped entirely
-            from the response. Acks are bookkeeping noise and most callers
-            don't want them in their LLM context.
-    """
+    """Read and consume pending messages. Returns {messages, acks, done_signals}."""
     raw = be.read_inbox(_PROJECT_ID, AGENT_NAME)
     normalized = [
         {
@@ -916,13 +913,7 @@ def meshcode_read(include_acks: bool = False) -> Dict[str, Any]:
 @mcp.tool()
 @with_working_status
 def meshcode_history(limit: int = 20, agent_filter: Optional[str] = None) -> Dict[str, Any]:
-    """View recent message history (both read and unread). Use when you need
-    context from past conversations or lost messages after context compression.
-
-    Args:
-        limit: Max messages to return (default 20).
-        agent_filter: Optional agent name to filter (shows messages to/from that agent).
-    """
+    """View past messages (read+unread). Optional agent_filter."""
     raw = be.get_history(_PROJECT_ID, limit=limit, agent_filter=agent_filter or "")
     messages = [
         {
@@ -942,12 +933,7 @@ def meshcode_history(limit: int = 20, agent_filter: Optional[str] = None) -> Dic
 @mcp.tool()
 @with_working_status
 def meshcode_read_message(msg_id: str) -> Dict[str, Any]:
-    """Fetch a specific message by ID. Use when you need to re-read a message
-    after context was compressed or session restarted.
-
-    Args:
-        msg_id: The UUID of the message to fetch.
-    """
+    """Fetch a specific message by its UUID."""
     msg = be.get_message_by_id(_PROJECT_ID, msg_id)
     if not msg:
         return {"error": "message not found", "msg_id": msg_id}
@@ -1043,20 +1029,7 @@ async def _meshcode_wait_inner(actual_timeout: int, include_acks: bool) -> Dict[
         # Realtime unavailable — plain sleep fallback so we still honor timeout.
         await asyncio.sleep(actual_timeout)
 
-    # On timeout, check for unclaimed tasks assigned to this agent
-    timeout_result: Dict[str, Any] = {"timed_out": True}
-    try:
-        api_key = _get_api_key()
-        open_tasks = be.task_list(api_key, _PROJECT_ID, AGENT_NAME, status_filter="open")
-        if isinstance(open_tasks, dict) and open_tasks.get("ok"):
-            my_tasks = [t for t in open_tasks.get("tasks", [])
-                       if t.get("assignee") == AGENT_NAME and not t.get("claimed_by")]
-            if my_tasks:
-                timeout_result["unclaimed_tasks"] = len(my_tasks)
-                timeout_result["hint"] = f"You have {len(my_tasks)} unclaimed task(s) assigned to you. Run meshcode_tasks(status_filter='open') to see them."
-    except Exception:
-        pass
-    return timeout_result
+    return {"timed_out": True}
 
 
 @mcp.tool()
@@ -1085,12 +1058,7 @@ def meshcode_done(reason: str) -> Dict[str, Any]:
 @mcp.tool()
 @with_working_status
 def meshcode_check(include_acks: bool = False) -> Dict[str, Any]:
-    """Non-blocking: returns pending message count + any new messages.
-
-    Checks realtime buffer first, then falls back to DB if buffer is empty
-    but there are pending messages (handles messages that arrived before
-    the realtime listener connected).
-    """
+    """Peek at inbox (non-destructive). Returns pending count + new messages."""
     pending = be.count_pending(_PROJECT_ID, AGENT_NAME)
     # Peek at realtime buffer WITHOUT draining — check is non-destructive
     realtime_buffered = _REALTIME.peek() if _REALTIME else []
@@ -1151,9 +1119,7 @@ def meshcode_status() -> Dict[str, Any]:
 @mcp.tool()
 @with_working_status
 def meshcode_register(role: str = "") -> Dict[str, Any]:
-    """Re-register this agent. Use if disconnected or
-    want to update your role description.
-    """
+    """Re-register agent (update role)."""
     return be.register_agent(PROJECT_NAME, AGENT_NAME, role or AGENT_ROLE)
 
 
@@ -1171,10 +1137,7 @@ def meshcode_set_status(status: str, task: str = "") -> Dict[str, Any]:
 @mcp.tool()
 @with_working_status
 def meshcode_init(project: str, agent: str, role: str = "") -> Dict[str, Any]:
-    """Re-initialize MCP session for different project/agent. Use ONLY
-    if you need to dynamically switch context — normally the env vars set at
-    server start are correct.
-    """
+    """Switch project/agent context. Rarely needed."""
     global PROJECT_NAME, AGENT_NAME, AGENT_ROLE, _PROJECT_ID
     PROJECT_NAME = project
     AGENT_NAME = agent
@@ -1191,18 +1154,7 @@ def meshcode_init(project: str, agent: str, role: str = "") -> Dict[str, Any]:
 @with_working_status
 def meshcode_task_create(title: str, description: str = "", assignee: str = "*",
                           priority: str = "normal", parent_task_id: Optional[str] = None) -> Dict[str, Any]:
-    """Create a task in the shared backlog. Usually called by
-    the commander) want to assign work that needs tracking.
-
-    Args:
-        title: Short title of the task.
-        description: Longer description / acceptance criteria.
-        assignee: Agent name to assign to, or "*" for any agent (anyone can claim).
-        priority: 'low' / 'normal' / 'high' / 'urgent'.
-        parent_task_id: Optional parent task id for nesting subtasks.
-
-    Returns: {"ok": true, "task_id": "...", "title": "..."}
-    """
+    """Create task. assignee="*" for any, priority: low/normal/high/urgent."""
     api_key = _get_api_key()
     result = be.task_create(api_key, _PROJECT_ID, AGENT_NAME, title,
                            description=description, assignee=assignee,
@@ -1239,13 +1191,7 @@ def meshcode_tasks(status_filter: Optional[str] = None) -> Dict[str, Any]:
 @mcp.tool()
 @with_working_status
 def meshcode_task_claim(task_id: str) -> Dict[str, Any]:
-    """Atomically claim an open task. Fails if already claimed by someone
-    else (or assigned to a different agent), this returns an error and another
-    task should be picked.
-
-    Args:
-        task_id: The uuid of the task you want to claim.
-    """
+    """Claim an open task. Fails if already claimed by someone else."""
     api_key = _get_api_key()
     return be.task_claim(api_key, _PROJECT_ID, task_id, AGENT_NAME)
 
@@ -1253,12 +1199,7 @@ def meshcode_task_claim(task_id: str) -> Dict[str, Any]:
 @mcp.tool()
 @with_working_status
 def meshcode_task_complete(task_id: str, summary: str = "") -> Dict[str, Any]:
-    """Mark a task as done. Only the claimer can complete it.
-
-    Args:
-        task_id: The uuid of the task you previously claimed.
-        summary: Short description of what was accomplished + any artifacts.
-    """
+    """Complete a claimed task with summary."""
     api_key = _get_api_key()
     return be.task_complete(api_key, _PROJECT_ID, task_id, AGENT_NAME, summary=summary)
 
@@ -1266,11 +1207,7 @@ def meshcode_task_complete(task_id: str, summary: str = "") -> Dict[str, Any]:
 @mcp.tool()
 @with_working_status
 def meshcode_task_approve(task_id: str) -> Dict[str, Any]:
-    """Approve a task in review. Only the reviewer can approve.
-
-    Args:
-        task_id: Task UUID to approve.
-    """
+    """Approve a reviewed task."""
     api_key = _get_api_key()
     return be.sb_rpc("mc_task_approve", {
         "p_api_key": api_key,
@@ -1283,12 +1220,7 @@ def meshcode_task_approve(task_id: str) -> Dict[str, Any]:
 @mcp.tool()
 @with_working_status
 def meshcode_task_reject(task_id: str, feedback: str = "") -> Dict[str, Any]:
-    """Reject a task in review — sends it back to in_progress with feedback.
-
-    Args:
-        task_id: Task UUID to reject.
-        feedback: Why it was rejected.
-    """
+    """Reject a task, sends back with feedback."""
     api_key = _get_api_key()
     return be.sb_rpc("mc_task_reject", {
         "p_api_key": api_key,
@@ -1305,13 +1237,7 @@ def meshcode_task_reject(task_id: str, feedback: str = "") -> Dict[str, Any]:
 @with_working_status
 def meshcode_link(target_meshwork: str, source_agents: Optional[str] = None,
                   target_agents: Optional[str] = None) -> Dict[str, Any]:
-    """Create a link to another meshwork. Target owner must accept.
-
-    Args:
-        target_meshwork: Meshwork name to link to.
-        source_agents: Comma-separated allowed senders (default: all).
-        target_agents: Comma-separated allowed receivers (default: all).
-    """
+    """Link to another meshwork. Target must accept."""
     api_key = _get_api_key()
     src = source_agents.split(",") if source_agents else ["*"]
     tgt = target_agents.split(",") if target_agents else ["*"]
@@ -1353,12 +1279,7 @@ def meshcode_links() -> Dict[str, Any]:
 @mcp.tool()
 @with_working_status
 def meshcode_expand_link(link_id: str, agents: str) -> Dict[str, Any]:
-    """Expand an active mesh link to allow more agents through.
-
-    Args:
-        link_id: UUID of the active link to expand.
-        agents: Comma-separated agent names to add (applied to both sides).
-    """
+    """Add agents to an active mesh link."""
     api_key = _get_api_key()
     agent_list = [a.strip() for a in agents.split(",")]
     return be.sb_rpc("mc_expand_mesh_link", {
@@ -1374,11 +1295,7 @@ def meshcode_expand_link(link_id: str, agents: str) -> Dict[str, Any]:
 @mcp.tool()
 @with_working_status
 def meshcode_create_meshwork(name: str) -> Dict[str, Any]:
-    """Create a new meshwork for the current user. Tell them to run 'meshcode setup <name> <agent>' next.
-
-    Args:
-        name: Meshwork name (lowercase, hyphens ok).
-    """
+    """Create a new meshwork."""
     api_key = _get_api_key()
     result = be.sb_rpc("mc_create_meshwork_by_api_key", {
         "p_api_key": api_key, "p_name": name,

meshcode-2.2.0/meshcode/meshcode_mcp/test_server_wrapper.py

@@ -0,0 +1,117 @@
+"""Static-analysis test: every name used inside with_working_status must exist.
+
+This is the test that catches the _PROCESSING_COOLDOWN_S class of bugs —
+references to variables that were never defined.  It parses server.py's AST
+and checks that every Name node inside the wrapper functions resolves to a
+local, global, or builtin in the module.
+
+Run:  python -m pytest meshcode/meshcode_mcp/test_server_wrapper.py -v
+  or: python -m unittest meshcode.meshcode_mcp.test_server_wrapper
+"""
+import ast
+import builtins
+import os
+import unittest
+
+_SERVER_PATH = os.path.join(os.path.dirname(__file__), "server.py")
+
+
+def _get_module_globals(tree: ast.Module) -> set[str]:
+    """Collect all names assigned/imported at module level."""
+    names = set()
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                names.add(alias.asname or alias.name.split(".")[0])
+        elif isinstance(node, ast.ImportFrom):
+            for alias in node.names:
+                names.add(alias.asname or alias.name)
+        elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            names.add(node.name)
+        elif isinstance(node, ast.ClassDef):
+            names.add(node.name)
+        elif isinstance(node, ast.Assign):
+            for target in node.targets:
+                if isinstance(target, ast.Name):
+                    names.add(target.id)
+        elif isinstance(node, ast.AnnAssign) and isinstance(node.target, ast.Name):
+            names.add(node.target.id)
+        elif isinstance(node, ast.AugAssign) and isinstance(node.target, ast.Name):
+            names.add(node.target.id)
+    # builtins
+    names.update(dir(builtins))
+    return names
+
+
+def _collect_names_in_func(func_node: ast.AST) -> set[str]:
+    """All Name.id references inside a function body."""
+    refs = set()
+    for node in ast.walk(func_node):
+        if isinstance(node, ast.Name):
+            refs.add(node.id)
+    return refs
+
+
+def _collect_locals(func_node: ast.AST) -> set[str]:
+    """Names assigned, declared global, or used as parameters inside a function."""
+    local = set()
+    for node in ast.walk(func_node):
+        if isinstance(node, ast.Global):
+            local.update(node.names)
+        elif isinstance(node, ast.Assign):
+            for t in node.targets:
+                if isinstance(t, ast.Name):
+                    local.add(t.id)
+        elif isinstance(node, ast.arg):
+            local.add(node.arg)
+        elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            local.add(node.name)
+            for arg in node.args.args:
+                local.add(arg.arg)
+            if node.args.vararg:
+                local.add(node.args.vararg.arg)
+            if node.args.kwarg:
+                local.add(node.args.kwarg.arg)
+    return local
+
+
+class ServerWrapperNamesTest(unittest.TestCase):
+    """Verify no undefined names inside with_working_status."""
+
+    def test_no_undefined_names_in_wrapper(self):
+        with open(_SERVER_PATH) as f:
+            tree = ast.parse(f.read(), _SERVER_PATH)
+
+        module_globals = _get_module_globals(tree)
+
+        # Find the with_working_status function
+        wrapper_func = None
+        for node in ast.walk(tree):
+            if isinstance(node, ast.FunctionDef) and node.name == "with_working_status":
+                wrapper_func = node
+                break
+
+        self.assertIsNotNone(wrapper_func, "with_working_status not found in server.py")
+
+        # Check every nested function inside with_working_status
+        for node in ast.walk(wrapper_func):
+            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                if node.name == "with_working_status":
+                    continue  # skip the outer function itself
+                refs = _collect_names_in_func(node)
+                locals_ = _collect_locals(node)
+                # Add the outer function's params and locals too
+                outer_locals = _collect_locals(wrapper_func)
+                allowed = module_globals | locals_ | outer_locals
+
+                undefined = refs - allowed
+                self.assertEqual(
+                    undefined,
+                    set(),
+                    f"Undefined names in {node.name}() inside with_working_status: "
+                    f"{undefined}. These will cause NameError at runtime.",
+                )
+
+
+if __name__ == "__main__":
+    unittest.main()

{meshcode-2.1.1 → meshcode-2.2.0}/meshcode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcode
-Version: 2.1.1
+Version: 2.2.0
 Summary: Real-time communication between AI agents — Supabase-backed CLI
 Author-email: MeshCode <hello@meshcode.io>
 License: MIT

{meshcode-2.1.1 → meshcode-2.2.0}/meshcode.egg-info/SOURCES.txt

@@ -24,4 +24,5 @@ meshcode/meshcode_mcp/backend.py
 meshcode/meshcode_mcp/realtime.py
 meshcode/meshcode_mcp/server.py
 meshcode/meshcode_mcp/test_backend.py
-meshcode/meshcode_mcp/test_realtime.py
+meshcode/meshcode_mcp/test_realtime.py
+meshcode/meshcode_mcp/test_server_wrapper.py

{meshcode-2.1.1 → meshcode-2.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "meshcode"
-version = "2.1.1"
+version = "2.2.0"
 description = "Real-time communication between AI agents — Supabase-backed CLI"
 readme = "README.md"
 license = {text = "MIT"}