meshclaw 0.1.0__tar.gz

meshclaw-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 MeshPOP
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

meshclaw-0.1.0/PKG-INFO

@@ -0,0 +1,234 @@
+Metadata-Version: 2.4
+Name: meshclaw
+Version: 0.1.0
+Summary: Distributed AI agent orchestration across mesh networks
+Author-email: MeshPOP <mpop@mpop.dev>
+License: MIT
+Project-URL: Homepage, https://github.com/meshpop/meshclaw
+Project-URL: Repository, https://github.com/meshpop/meshclaw
+Project-URL: Issues, https://github.com/meshpop/meshclaw/issues
+Keywords: ai,agent,distributed,mesh,orchestration,mcp
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: System :: Distributed Computing
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: meshpop
+Requires-Dist: meshpop; extra == "meshpop"
+Requires-Dist: vssh; extra == "meshpop"
+Requires-Dist: meshpop-wire; extra == "meshpop"
+Dynamic: license-file
+
+# MeshClaw
+
+Distributed AI agent orchestration across mesh networks.
+
+While existing agent frameworks (OpenClaw, etc.) run on a single machine, MeshClaw distributes AI agents across your entire server infrastructure. Build on d1, test on d2, deploy on v1 — all orchestrated by AI.
+
+**Works on a single PC too** — MeshClaw treats local containers (Docker, LXC, rtlinux) as mesh nodes, giving you distributed agent power on one machine.
+
+## What MeshClaw Does That Others Can't
+
+| Feature | OpenClaw | MeshClaw |
+|---------|----------|----------|
+| Single-machine agent | Yes | Yes |
+| Multi-server execution | No | **Yes** |
+| Agent migration between servers | No | **Yes** |
+| Parallel tasks across servers | No | **Yes** |
+| Sequential pipelines across servers | No | **Yes** |
+| Collaborative multi-agent with signals | No | **Yes** |
+| Map-Reduce across infrastructure | No | **Yes** |
+| Container-as-node on single machine | No | **Yes** |
+| MeshPOP infrastructure integration | No | **Yes** |
+
+## Install
+
+```bash
+pip install meshclaw
+```
+
+With MeshPOP integration:
+```bash
+pip install meshclaw[meshpop]
+```
+
+## Quick Start
+
+### CLI
+
+```bash
+# Discover mesh nodes
+meshclaw discover
+
+# Execute on a specific server
+meshclaw exec "uptime" -s d1
+
+# Broadcast to all servers
+meshclaw broadcast "df -h"
+
+# Parallel tasks on different servers
+meshclaw parallel d1:"make build" d2:"make test" v1:"./deploy.sh"
+
+# Sequential pipeline
+meshclaw pipeline d1:"make build" d2:"make test" v1:"./deploy.sh"
+```
+
+### Python API
+
+```python
+from meshclaw import Orchestrator, Task
+from meshclaw.scenario import ParallelScenario, SequentialScenario, CollaborativeScenario
+
+# Auto-discover mesh
+with Orchestrator() as orch:
+    orch.discover()
+
+    # Parallel: different tasks on different servers
+    result = orch.parallel("build-and-test", [
+        Task("build", command="make build", server="d1"),
+        Task("test", command="make test", server="d2"),
+        Task("lint", command="make lint", server="g1"),
+    ])
+
+    # Sequential pipeline: output chains
+    result = orch.pipeline("deploy", [
+        {"server": "d1", "command": "make build"},
+        {"server": "d2", "command": "make test"},
+        {"server": "v1", "command": "./deploy.sh"},
+    ])
+
+    # Broadcast: same command on all servers
+    result = orch.broadcast("health", "uptime")
+```
+
+### Collaborative Workflow
+
+```python
+from meshclaw import Orchestrator
+from meshclaw.scenario import CollaborativeScenario
+
+with Orchestrator() as orch:
+    orch.discover()
+
+    collab = CollaborativeScenario("data-pipeline")
+    collab.add_agent_task("scraper", server="d1",
+        command="curl -s https://api.example.com/data > /tmp/data.json",
+        publishes=["data_ready"])
+    collab.add_agent_task("processor", server="g1",
+        command="python3 /opt/process.py /tmp/data.json",
+        waits_for=["data_ready"],
+        publishes=["processed"])
+    collab.add_agent_task("server", server="v1",
+        command="cp /tmp/output.json /var/www/api/",
+        waits_for=["processed"])
+
+    result = orch.run(collab)
+```
+
+### Agent Migration
+
+```python
+from meshclaw import Agent
+
+agent = Agent("worker", server="d1")
+agent.start()
+agent.execute("heavy-computation.sh")
+
+# Server d1 is overloaded? Move to d2
+agent.migrate("d2")
+agent.execute("continue-work.sh")  # Now runs on d2
+```
+
+### Map-Reduce
+
+```python
+from meshclaw import Orchestrator
+from meshclaw.scenario import MapReduceScenario
+
+with Orchestrator() as orch:
+    orch.discover()
+
+    scenario = MapReduceScenario(
+        "error-count",
+        map_command="grep -c ERROR /var/log/syslog",
+        map_servers=["d1", "d2", "g1", "v1"],
+        reduce_command="python3 -c 'import sys; print(sum(int(l) for l in sys.stdin))'",
+        reduce_server="m1"
+    )
+    result = orch.run(scenario)
+    print(f"Total errors: {result.results[-1].output}")
+```
+
+## MCP Server
+
+MeshClaw includes an MCP server for AI assistant integration:
+
+```json
+{
+  "mcpServers": {
+    "meshclaw": {
+      "command": "python3",
+      "args": ["/path/to/meshclaw-mcp-server.py"]
+    }
+  }
+}
+```
+
+### MCP Tools
+
+| Tool | Description |
+|------|-------------|
+| `meshclaw_discover` | Find mesh nodes |
+| `meshclaw_exec` | Execute on specific server |
+| `meshclaw_broadcast` | Run on all servers |
+| `meshclaw_parallel` | Different tasks, different servers, simultaneously |
+| `meshclaw_pipeline` | Sequential cross-server pipeline |
+| `meshclaw_collab` | Collaborative multi-agent with signals |
+| `meshclaw_mapreduce` | Map-Reduce across mesh |
+| `meshclaw_status` | Orchestrator status |
+| `meshclaw_migrate` | Move agent between servers |
+
+## Single-Machine Mode
+
+No mesh network? No problem. MeshClaw works with local containers:
+
+```python
+# Auto-detects Docker/LXC/rtlinux containers
+orch = Orchestrator(mode="local")
+orch.discover()  # Finds containers as nodes
+
+# Same powerful API, one machine
+result = orch.parallel("local-work", [
+    Task("build", command="make", server="container-1"),
+    Task("test", command="pytest", server="container-2"),
+])
+```
+
+## Architecture
+
+```
+                    Orchestrator
+                    /    |     \
+              Agent-d1  Agent-d2  Agent-v1
+              (build)   (test)    (deploy)
+                |         |         |
+            [vssh/ssh] [vssh/ssh] [vssh/ssh]
+                |         |         |
+              Server-d1 Server-d2 Server-v1
+```
+
+Built on MeshPOP: mpop (management), vssh (execution), wire (networking), meshdb (state), vault (secrets).
+
+## License
+
+MIT
+
+## Links
+
+- [MeshPOP](https://github.com/meshpop)
+- [mpop.dev](https://mpop.dev)
+- [PyPI](https://pypi.org/project/meshclaw/)

meshclaw-0.1.0/README.md

@@ -0,0 +1,209 @@
+# MeshClaw
+
+Distributed AI agent orchestration across mesh networks.
+
+While existing agent frameworks (OpenClaw, etc.) run on a single machine, MeshClaw distributes AI agents across your entire server infrastructure. Build on d1, test on d2, deploy on v1 — all orchestrated by AI.
+
+**Works on a single PC too** — MeshClaw treats local containers (Docker, LXC, rtlinux) as mesh nodes, giving you distributed agent power on one machine.
+
+## What MeshClaw Does That Others Can't
+
+| Feature | OpenClaw | MeshClaw |
+|---------|----------|----------|
+| Single-machine agent | Yes | Yes |
+| Multi-server execution | No | **Yes** |
+| Agent migration between servers | No | **Yes** |
+| Parallel tasks across servers | No | **Yes** |
+| Sequential pipelines across servers | No | **Yes** |
+| Collaborative multi-agent with signals | No | **Yes** |
+| Map-Reduce across infrastructure | No | **Yes** |
+| Container-as-node on single machine | No | **Yes** |
+| MeshPOP infrastructure integration | No | **Yes** |
+
+## Install
+
+```bash
+pip install meshclaw
+```
+
+With MeshPOP integration:
+```bash
+pip install meshclaw[meshpop]
+```
+
+## Quick Start
+
+### CLI
+
+```bash
+# Discover mesh nodes
+meshclaw discover
+
+# Execute on a specific server
+meshclaw exec "uptime" -s d1
+
+# Broadcast to all servers
+meshclaw broadcast "df -h"
+
+# Parallel tasks on different servers
+meshclaw parallel d1:"make build" d2:"make test" v1:"./deploy.sh"
+
+# Sequential pipeline
+meshclaw pipeline d1:"make build" d2:"make test" v1:"./deploy.sh"
+```
+
+### Python API
+
+```python
+from meshclaw import Orchestrator, Task
+from meshclaw.scenario import ParallelScenario, SequentialScenario, CollaborativeScenario
+
+# Auto-discover mesh
+with Orchestrator() as orch:
+    orch.discover()
+
+    # Parallel: different tasks on different servers
+    result = orch.parallel("build-and-test", [
+        Task("build", command="make build", server="d1"),
+        Task("test", command="make test", server="d2"),
+        Task("lint", command="make lint", server="g1"),
+    ])
+
+    # Sequential pipeline: output chains
+    result = orch.pipeline("deploy", [
+        {"server": "d1", "command": "make build"},
+        {"server": "d2", "command": "make test"},
+        {"server": "v1", "command": "./deploy.sh"},
+    ])
+
+    # Broadcast: same command on all servers
+    result = orch.broadcast("health", "uptime")
+```
+
+### Collaborative Workflow
+
+```python
+from meshclaw import Orchestrator
+from meshclaw.scenario import CollaborativeScenario
+
+with Orchestrator() as orch:
+    orch.discover()
+
+    collab = CollaborativeScenario("data-pipeline")
+    collab.add_agent_task("scraper", server="d1",
+        command="curl -s https://api.example.com/data > /tmp/data.json",
+        publishes=["data_ready"])
+    collab.add_agent_task("processor", server="g1",
+        command="python3 /opt/process.py /tmp/data.json",
+        waits_for=["data_ready"],
+        publishes=["processed"])
+    collab.add_agent_task("server", server="v1",
+        command="cp /tmp/output.json /var/www/api/",
+        waits_for=["processed"])
+
+    result = orch.run(collab)
+```
+
+### Agent Migration
+
+```python
+from meshclaw import Agent
+
+agent = Agent("worker", server="d1")
+agent.start()
+agent.execute("heavy-computation.sh")
+
+# Server d1 is overloaded? Move to d2
+agent.migrate("d2")
+agent.execute("continue-work.sh")  # Now runs on d2
+```
+
+### Map-Reduce
+
+```python
+from meshclaw import Orchestrator
+from meshclaw.scenario import MapReduceScenario
+
+with Orchestrator() as orch:
+    orch.discover()
+
+    scenario = MapReduceScenario(
+        "error-count",
+        map_command="grep -c ERROR /var/log/syslog",
+        map_servers=["d1", "d2", "g1", "v1"],
+        reduce_command="python3 -c 'import sys; print(sum(int(l) for l in sys.stdin))'",
+        reduce_server="m1"
+    )
+    result = orch.run(scenario)
+    print(f"Total errors: {result.results[-1].output}")
+```
+
+## MCP Server
+
+MeshClaw includes an MCP server for AI assistant integration:
+
+```json
+{
+  "mcpServers": {
+    "meshclaw": {
+      "command": "python3",
+      "args": ["/path/to/meshclaw-mcp-server.py"]
+    }
+  }
+}
+```
+
+### MCP Tools
+
+| Tool | Description |
+|------|-------------|
+| `meshclaw_discover` | Find mesh nodes |
+| `meshclaw_exec` | Execute on specific server |
+| `meshclaw_broadcast` | Run on all servers |
+| `meshclaw_parallel` | Different tasks, different servers, simultaneously |
+| `meshclaw_pipeline` | Sequential cross-server pipeline |
+| `meshclaw_collab` | Collaborative multi-agent with signals |
+| `meshclaw_mapreduce` | Map-Reduce across mesh |
+| `meshclaw_status` | Orchestrator status |
+| `meshclaw_migrate` | Move agent between servers |
+
+## Single-Machine Mode
+
+No mesh network? No problem. MeshClaw works with local containers:
+
+```python
+# Auto-detects Docker/LXC/rtlinux containers
+orch = Orchestrator(mode="local")
+orch.discover()  # Finds containers as nodes
+
+# Same powerful API, one machine
+result = orch.parallel("local-work", [
+    Task("build", command="make", server="container-1"),
+    Task("test", command="pytest", server="container-2"),
+])
+```
+
+## Architecture
+
+```
+                    Orchestrator
+                    /    |     \
+              Agent-d1  Agent-d2  Agent-v1
+              (build)   (test)    (deploy)
+                |         |         |
+            [vssh/ssh] [vssh/ssh] [vssh/ssh]
+                |         |         |
+              Server-d1 Server-d2 Server-v1
+```
+
+Built on MeshPOP: mpop (management), vssh (execution), wire (networking), meshdb (state), vault (secrets).
+
+## License
+
+MIT
+
+## Links
+
+- [MeshPOP](https://github.com/meshpop)
+- [mpop.dev](https://mpop.dev)
+- [PyPI](https://pypi.org/project/meshclaw/)

meshclaw-0.1.0/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "meshclaw"
+version = "0.1.0"
+description = "Distributed AI agent orchestration across mesh networks"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.9"
+authors = [
+    {name = "MeshPOP", email = "mpop@mpop.dev"}
+]
+keywords = ["ai", "agent", "distributed", "mesh", "orchestration", "mcp"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Topic :: System :: Distributed Computing",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = []
+
+[project.optional-dependencies]
+meshpop = ["meshpop", "vssh", "meshpop-wire"]
+
+[project.scripts]
+meshclaw = "meshclaw.cli:main"
+
+[project.urls]
+Homepage = "https://github.com/meshpop/meshclaw"
+Repository = "https://github.com/meshpop/meshclaw"
+Issues = "https://github.com/meshpop/meshclaw/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]

meshclaw-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

meshclaw-0.1.0/src/meshclaw/__init__.py

@@ -0,0 +1,22 @@
+"""MeshClaw - Distributed AI Agent Orchestration across Mesh Networks.
+
+Unlike single-machine agent frameworks, MeshClaw distributes AI agents
+across multiple servers in a mesh network, enabling parallel execution,
+sequential pipelines, and collaborative multi-agent workflows.
+
+Built on top of MeshPOP infrastructure (mpop/vssh/wire/meshdb/vault).
+"""
+
+__version__ = "0.1.0"
+
+from meshclaw.agent import Agent, AgentState
+from meshclaw.task import Task, TaskResult, TaskState
+from meshclaw.orchestrator import Orchestrator
+from meshclaw.scenario import Scenario, ParallelScenario, SequentialScenario, CollaborativeScenario
+
+__all__ = [
+    "Agent", "AgentState",
+    "Task", "TaskResult", "TaskState",
+    "Orchestrator",
+    "Scenario", "ParallelScenario", "SequentialScenario", "CollaborativeScenario",
+]

meshclaw-0.1.0/src/meshclaw/__main__.py

@@ -0,0 +1,3 @@
+"""Allow running meshclaw as python -m meshclaw."""
+from meshclaw.cli import main
+main()