fleet-framework 0.1.0__tar.gz

fleet_framework-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 fleet contributors
+
+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.

fleet_framework-0.1.0/PKG-INFO

@@ -0,0 +1,160 @@
+Metadata-Version: 2.4
+Name: fleet-framework
+Version: 0.1.0
+Summary: generic distributed-automation framework — master/worker, browser pool, anti-bot helpers, and abstract automation contracts (SERP, content, news, place, marketplace, jobs, social)
+Author: Sarper Avci
+License: MIT
+Project-URL: Homepage, https://github.com/sarperavci/fleet
+Project-URL: Repository, https://github.com/sarperavci/fleet
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastapi>=0.115.0
+Requires-Dist: uvicorn[standard]>=0.30.0
+Requires-Dist: pydantic>=2.7.0
+Requires-Dist: websockets>=12.0
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: redis>=5.0.0
+Requires-Dist: jinja2>=3.1.0
+Requires-Dist: psutil>=5.9.0
+Requires-Dist: click>=8.1.0
+Provides-Extra: browser
+Requires-Dist: DrissionPage>=4.1.0; extra == "browser"
+Requires-Dist: cryptography>=42.0.0; extra == "browser"
+Provides-Extra: cloudflare
+Requires-Dist: fleet-framework[browser]; extra == "cloudflare"
+Provides-Extra: otel
+Requires-Dist: opentelemetry-api>=1.27.0; extra == "otel"
+Requires-Dist: opentelemetry-sdk>=1.27.0; extra == "otel"
+Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.27.0; extra == "otel"
+Provides-Extra: test
+Requires-Dist: pytest>=8.0; extra == "test"
+Requires-Dist: pytest-asyncio>=0.23; extra == "test"
+Provides-Extra: all
+Requires-Dist: fleet-framework[browser,cloudflare,otel]; extra == "all"
+Dynamic: license-file
+
+# Fleet
+
+A framework for distributed automation fleets. One master, many workers, typed output streams between them. Born out of a production CAPTCHA-solving farm, generalized to fit any "N machines each doing M parallel things" workload.
+
+## What it is
+
+Two pip packages. `fleet-core` is the framework: master, worker shell, reconcile loop, Redis-backed store, output streams, event bus, a small dashboard. `fleet-browser` is an optional add-on that ships a battle-tested Chromium pool with fingerprint rotation, proxy auth, and orphan-process cleanup.
+
+You write a Python class subclassing `ContinuousAutomation` or `BatchAutomation` and a Pydantic config. Ship it as a pip package with one entry-point line. Install it on the master and on each worker host and the framework wires up everything else: config push, validation, slot lifecycle, recycle, heal, stats, dashboard, stream-based inter-automation comms.
+
+## What's already in the box
+
+- Master process: REST + WebSocket API, auto-discovered plugins, dashboard, Redis-backed state.
+- Worker process: pulls config, runs N concurrent slots, reconciles to desired state, heals on failure.
+- Reconcile loop: pure-functional diff, smallest-converging-plan semantics, slot recycle, self-heal.
+- Typed output streams: ZSET-backed, bounded by length and TTL, one per automation type, pop or peek over REST or in-process.
+- Event bus: Redis pubsub for lightweight signals.
+- Auth: bearer tokens, admin vs worker, constant-time comparison. WebSocket handshake validated before accept.
+- Hardening from the original farm: tini in the worker container reaps zombies, `psutil`-based process-tree cleanup catches orphans, recycle's heal step closes the "zero-slot lockout" failure mode.
+
+## What you write
+
+Roughly 30 lines per automation. Here's a fully working example:
+
+```python
+import asyncio
+import httpx
+from fleet.core import BaseConfig, ContinuousAutomation, register
+
+class PingerConfig(BaseConfig):
+    url: str
+    interval_seconds: float = 5.0
+
+@register("pinger")
+class Pinger(ContinuousAutomation[PingerConfig]):
+    Config = PingerConfig
+
+    async def run_slot(self, ctx):
+        async with httpx.AsyncClient(proxy=ctx.proxy) as client:
+            while not ctx.shutdown.is_set():
+                r = await client.get(ctx.config.url)
+                await ctx.emit({"status": r.status_code})
+                await asyncio.sleep(ctx.config.interval_seconds)
+```
+
+Plus one line in your `pyproject.toml`:
+
+```toml
+[project.entry-points."fleet.automations"]
+pinger = "my_package:Pinger"
+```
+
+## Quickstart
+
+```bash
+git clone <repo-url> fleet && cd fleet
+python3 -m venv .venv && source .venv/bin/activate
+pip install -e packages/fleet-core
+pip install -e examples/hello-world
+
+# in one terminal:
+redis-server --port 6379 --appendonly yes
+# in another:
+FLEET_ADMIN_TOKEN=admin FLEET_WORKER_TOKEN=worker fleet master
+# in another:
+MASTER_URL=http://localhost:8000 FLEET_WORKER_TOKEN=worker fleet worker --type hello-world --id w1
+# in another:
+curl -X PATCH http://localhost:8000/api/v1/automations/hello-world/workers/w1/config \
+  -H "Authorization: Bearer admin" -H "Content-Type: application/json" \
+  -d '{"enabled": true, "slots": 2}'
+curl -X POST http://localhost:8000/api/v1/automations/hello-world/output/pop \
+  -H "Authorization: Bearer admin" -H "Content-Type: application/json" \
+  -d '{"n": 5}'
+```
+
+Walkthrough with explanations: [docs/getting-started/quickstart.md](docs/getting-started/quickstart.md).
+
+## Repo layout
+
+```
+fleet/
+├── packages/
+│   ├── fleet-core/      master, worker, reconcile, store, streams, event bus, dashboard, CLI
+│   └── fleet-browser/   optional Chromium pool, fingerprint, humanizer, proxy auth, cert
+├── examples/
+│   ├── hello-world/     minimal ContinuousAutomation (emit greetings on a timer)
+│   └── echo-consumer/   consumes another automation's output stream
+└── docs/                GitBook-format documentation (also lives on the `docs` branch)
+```
+
+## Documentation
+
+Full docs in [`docs/`](docs/), rendered as a GitBook from the `docs` branch.
+
+- [Introduction](docs/README.md)
+- [Installation](docs/getting-started/installation.md)
+- [Quickstart](docs/getting-started/quickstart.md)
+- [Your first automation](docs/getting-started/first-automation.md)
+- [Architecture](docs/concepts/architecture.md)
+- [Writing a continuous automation](docs/guides/continuous-automation.md)
+- [Writing a batch automation](docs/guides/batch-automation.md)
+- [Making two automations talk](docs/guides/inter-automation.md)
+- [Browser-based automations](docs/guides/browser-automations.md)
+- [Deployment](docs/guides/deployment.md)
+- [REST API](docs/reference/rest-api.md)
+- [WebSocket protocol](docs/reference/ws-protocol.md)
+- [Authentication](docs/operations/auth.md)
+- [Troubleshooting](docs/operations/troubleshooting.md)
+
+## Origins
+
+Fleet started as the control plane for a Cloudflare Turnstile-solving farm. That farm hit every interesting failure mode in distributed automation: zombie subprocess accumulation, master state wipe on Redis restart, gen-counter regression, slot-recycle drops with no heal, and config drift across heterogeneous workers. Each of those has a fix baked into the framework.
+
+The framework is what the original farm should have been from day one. It's deliberately small. If you want a scheduler, an orchestrator, or a service mesh, this isn't it. If you want a thin layer that turns "N hosts doing repetitive work" into a manageable system, it is.
+
+## Status
+
+Pre-alpha. The public API will change. No PyPI release yet — install from source. Production deployments are running on it but with a lot of manual operational knowledge to back them up. Watch the changelog before relying on anything sensitive.
+
+See [ROADMAP.md](ROADMAP.md) for the path to v0.1.
+
+## License
+
+MIT. See [LICENSE](LICENSE).

fleet_framework-0.1.0/README.md

@@ -0,0 +1,124 @@
+# Fleet
+
+A framework for distributed automation fleets. One master, many workers, typed output streams between them. Born out of a production CAPTCHA-solving farm, generalized to fit any "N machines each doing M parallel things" workload.
+
+## What it is
+
+Two pip packages. `fleet-core` is the framework: master, worker shell, reconcile loop, Redis-backed store, output streams, event bus, a small dashboard. `fleet-browser` is an optional add-on that ships a battle-tested Chromium pool with fingerprint rotation, proxy auth, and orphan-process cleanup.
+
+You write a Python class subclassing `ContinuousAutomation` or `BatchAutomation` and a Pydantic config. Ship it as a pip package with one entry-point line. Install it on the master and on each worker host and the framework wires up everything else: config push, validation, slot lifecycle, recycle, heal, stats, dashboard, stream-based inter-automation comms.
+
+## What's already in the box
+
+- Master process: REST + WebSocket API, auto-discovered plugins, dashboard, Redis-backed state.
+- Worker process: pulls config, runs N concurrent slots, reconciles to desired state, heals on failure.
+- Reconcile loop: pure-functional diff, smallest-converging-plan semantics, slot recycle, self-heal.
+- Typed output streams: ZSET-backed, bounded by length and TTL, one per automation type, pop or peek over REST or in-process.
+- Event bus: Redis pubsub for lightweight signals.
+- Auth: bearer tokens, admin vs worker, constant-time comparison. WebSocket handshake validated before accept.
+- Hardening from the original farm: tini in the worker container reaps zombies, `psutil`-based process-tree cleanup catches orphans, recycle's heal step closes the "zero-slot lockout" failure mode.
+
+## What you write
+
+Roughly 30 lines per automation. Here's a fully working example:
+
+```python
+import asyncio
+import httpx
+from fleet.core import BaseConfig, ContinuousAutomation, register
+
+class PingerConfig(BaseConfig):
+    url: str
+    interval_seconds: float = 5.0
+
+@register("pinger")
+class Pinger(ContinuousAutomation[PingerConfig]):
+    Config = PingerConfig
+
+    async def run_slot(self, ctx):
+        async with httpx.AsyncClient(proxy=ctx.proxy) as client:
+            while not ctx.shutdown.is_set():
+                r = await client.get(ctx.config.url)
+                await ctx.emit({"status": r.status_code})
+                await asyncio.sleep(ctx.config.interval_seconds)
+```
+
+Plus one line in your `pyproject.toml`:
+
+```toml
+[project.entry-points."fleet.automations"]
+pinger = "my_package:Pinger"
+```
+
+## Quickstart
+
+```bash
+git clone <repo-url> fleet && cd fleet
+python3 -m venv .venv && source .venv/bin/activate
+pip install -e packages/fleet-core
+pip install -e examples/hello-world
+
+# in one terminal:
+redis-server --port 6379 --appendonly yes
+# in another:
+FLEET_ADMIN_TOKEN=admin FLEET_WORKER_TOKEN=worker fleet master
+# in another:
+MASTER_URL=http://localhost:8000 FLEET_WORKER_TOKEN=worker fleet worker --type hello-world --id w1
+# in another:
+curl -X PATCH http://localhost:8000/api/v1/automations/hello-world/workers/w1/config \
+  -H "Authorization: Bearer admin" -H "Content-Type: application/json" \
+  -d '{"enabled": true, "slots": 2}'
+curl -X POST http://localhost:8000/api/v1/automations/hello-world/output/pop \
+  -H "Authorization: Bearer admin" -H "Content-Type: application/json" \
+  -d '{"n": 5}'
+```
+
+Walkthrough with explanations: [docs/getting-started/quickstart.md](docs/getting-started/quickstart.md).
+
+## Repo layout
+
+```
+fleet/
+├── packages/
+│   ├── fleet-core/      master, worker, reconcile, store, streams, event bus, dashboard, CLI
+│   └── fleet-browser/   optional Chromium pool, fingerprint, humanizer, proxy auth, cert
+├── examples/
+│   ├── hello-world/     minimal ContinuousAutomation (emit greetings on a timer)
+│   └── echo-consumer/   consumes another automation's output stream
+└── docs/                GitBook-format documentation (also lives on the `docs` branch)
+```
+
+## Documentation
+
+Full docs in [`docs/`](docs/), rendered as a GitBook from the `docs` branch.
+
+- [Introduction](docs/README.md)
+- [Installation](docs/getting-started/installation.md)
+- [Quickstart](docs/getting-started/quickstart.md)
+- [Your first automation](docs/getting-started/first-automation.md)
+- [Architecture](docs/concepts/architecture.md)
+- [Writing a continuous automation](docs/guides/continuous-automation.md)
+- [Writing a batch automation](docs/guides/batch-automation.md)
+- [Making two automations talk](docs/guides/inter-automation.md)
+- [Browser-based automations](docs/guides/browser-automations.md)
+- [Deployment](docs/guides/deployment.md)
+- [REST API](docs/reference/rest-api.md)
+- [WebSocket protocol](docs/reference/ws-protocol.md)
+- [Authentication](docs/operations/auth.md)
+- [Troubleshooting](docs/operations/troubleshooting.md)
+
+## Origins
+
+Fleet started as the control plane for a Cloudflare Turnstile-solving farm. That farm hit every interesting failure mode in distributed automation: zombie subprocess accumulation, master state wipe on Redis restart, gen-counter regression, slot-recycle drops with no heal, and config drift across heterogeneous workers. Each of those has a fix baked into the framework.
+
+The framework is what the original farm should have been from day one. It's deliberately small. If you want a scheduler, an orchestrator, or a service mesh, this isn't it. If you want a thin layer that turns "N hosts doing repetitive work" into a manageable system, it is.
+
+## Status
+
+Pre-alpha. The public API will change. No PyPI release yet — install from source. Production deployments are running on it but with a lot of manual operational knowledge to back them up. Watch the changelog before relying on anything sensitive.
+
+See [ROADMAP.md](ROADMAP.md) for the path to v0.1.
+
+## License
+
+MIT. See [LICENSE](LICENSE).

fleet_framework-0.1.0/fleet/__init__.py

@@ -0,0 +1 @@
+# namespace marker

fleet_framework-0.1.0/fleet/cli.py

@@ -0,0 +1,290 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+import socket
+import sys
+
+import click
+import uvicorn
+
+from fleet.core.logging import configure_logging
+
+configure_logging()
+
+
+@click.group()
+def cli() -> None:
+    # fleet — master + worker CLI.
+    pass
+
+
+@cli.command()
+@click.option("--host", default="0.0.0.0", show_default=True)
+@click.option("--port", default=8000, show_default=True)
+@click.option(
+    "--backend-url",
+    envvar="FLEET_BACKEND_URL",
+    default=None,
+    show_default=True,
+    help="Backend URL: redis://..., memory://, or any registered scheme. "
+         "Defaults to $FLEET_BACKEND_URL, then $REDIS_URL, then redis://localhost:6379/0.",
+)
+@click.option(
+    "--redis-url",
+    envvar="REDIS_URL",
+    default=None,
+    show_default=True,
+    help="(Legacy) Use --backend-url instead.",
+)
+def master(host: str, port: int, backend_url: str | None, redis_url: str | None) -> None:
+    """Start the master process. Binds REST + WS + dashboard."""
+    from fleet.master import create_app
+
+    url = backend_url or redis_url or "redis://localhost:6379/0"
+    if redis_url:
+        os.environ.setdefault("REDIS_URL", redis_url)
+    os.environ.setdefault("FLEET_BACKEND_URL", url)
+    app = create_app(url)
+    uvicorn.run(app, host=host, port=port, log_level=os.environ.get("LOG_LEVEL", "info").lower())
+
+
+@cli.command()
+@click.option("--type", "automation_type", required=True, help="automation type name (entry-point key)")
+@click.option("--id", "worker_id", default=None, help="worker id (defaults to hostname)")
+@click.option("--master-url", envvar="MASTER_URL", required=True)
+@click.option("--worker-token", envvar="FLEET_WORKER_TOKEN", required=True)
+@click.option(
+    "--backend-url",
+    envvar="FLEET_BACKEND_URL",
+    default=None,
+    help="Backend URL; falls back to --redis-url then redis://localhost:6379/0.",
+)
+@click.option(
+    "--redis-url",
+    envvar="REDIS_URL",
+    default=None,
+    help="(Legacy) Use --backend-url instead.",
+)
+def worker(
+    automation_type: str,
+    worker_id: str | None,
+    master_url: str,
+    worker_token: str,
+    backend_url: str | None,
+    redis_url: str | None,
+) -> None:
+    """Start a worker process pinned to one automation type."""
+    from fleet.worker import Agent
+
+    url = backend_url or redis_url or "redis://localhost:6379/0"
+    wid = worker_id or socket.gethostname()
+    agent = Agent(
+        automation_type=automation_type,
+        worker_id=wid,
+        master_url=master_url,
+        worker_token=worker_token,
+        redis_url=url,
+    )
+    try:
+        asyncio.run(agent.run())
+    except KeyboardInterrupt:
+        sys.exit(0)
+
+
+def _list_plugins() -> None:
+    from fleet.core.automation import load_entry_points
+    from fleet.core.proxy import load_provider_entry_points
+
+    reg = load_entry_points()
+    if reg:
+        click.echo("automations:")
+        for name, cls in reg.items():
+            kind = cls.__mro__[1].__name__
+            click.echo(f"  {name:30} {cls.__module__}.{cls.__name__}  ({kind})")
+    else:
+        click.echo("automations: (none installed)")
+    providers = load_provider_entry_points()
+    if providers:
+        click.echo("proxy providers:")
+        for name in providers:
+            click.echo(f"  {name}")
+
+
+@cli.command()
+def plugins() -> None:
+    """List installed automations + proxy providers discovered via entry-points."""
+    _list_plugins()
+
+
+@cli.command(name="info")
+def info_alias() -> None:
+    """Alias of `plugins`. Kept for backwards compatibility."""
+    _list_plugins()
+
+
+@cli.command()
+@click.argument("automation_type")
+@click.option("--master-url", envvar="MASTER_URL", required=True)
+@click.option("--admin-token", envvar="FLEET_ADMIN_TOKEN", required=True)
+@click.option("--n", default=10, show_default=True, help="entries per pop")
+@click.option("--interval", default=1.0, show_default=True, help="seconds between polls")
+@click.option("--peek", is_flag=True, help="non-destructive read instead of pop")
+def tail(
+    automation_type: str,
+    master_url: str,
+    admin_token: str,
+    n: int,
+    interval: float,
+    peek: bool,
+) -> None:
+    """Stream the output of an automation type to stdout, one JSON object per line."""
+    import httpx
+
+    headers = {"Authorization": f"Bearer {admin_token}"}
+    op = "peek" if peek else "pop"
+    base = master_url.rstrip("/")
+    try:
+        while True:
+            try:
+                if peek:
+                    url = f"{base}/api/v1/automations/{automation_type}/output/peek?n={n}"
+                    r = httpx.get(url, headers=headers, timeout=10)
+                else:
+                    url = f"{base}/api/v1/automations/{automation_type}/output/pop"
+                    r = httpx.post(url, headers=headers, json={"n": n}, timeout=10)
+                r.raise_for_status()
+                for env in r.json():
+                    click.echo(json.dumps(env, default=str))
+            except Exception as e:
+                click.echo(f"# {op} failed: {e}", err=True)
+            import time as _t
+            _t.sleep(max(0.1, interval))
+    except KeyboardInterrupt:
+        sys.exit(0)
+
+
+@cli.command()
+@click.argument("automation_type")
+@click.argument("payload")  # JSON string or @path
+@click.option("--master-url", envvar="MASTER_URL", required=True)
+@click.option("--admin-token", envvar="FLEET_ADMIN_TOKEN", required=True)
+@click.option("--task-id", default=None, help="override the framework's UUID")
+@click.option("--max-attempts", default=None, type=int, help="override per-task retry budget")
+def submit(
+    automation_type: str,
+    payload: str,
+    master_url: str,
+    admin_token: str,
+    task_id: str | None,
+    max_attempts: int | None,
+) -> None:
+    """Submit a single task to a BatchAutomation.
+
+    PAYLOAD is a JSON string or @path/to/file.json. Validated against the
+    automation's TaskPayload schema server-side.
+    """
+    import httpx
+
+    body_text = payload
+    if payload.startswith("@"):
+        body_text = open(payload[1:]).read()
+    try:
+        parsed = json.loads(body_text)
+    except json.JSONDecodeError as e:
+        click.echo(f"payload is not valid JSON: {e}", err=True)
+        sys.exit(2)
+    req: dict = {"payload": parsed}
+    if task_id:
+        req["task_id"] = task_id
+    if max_attempts is not None:
+        req["max_attempts"] = max_attempts
+    url = master_url.rstrip("/") + f"/api/v1/automations/{automation_type}/tasks"
+    r = httpx.post(url, headers={"Authorization": f"Bearer {admin_token}"}, json=req, timeout=10)
+    if r.status_code >= 400:
+        click.echo(f"submit failed ({r.status_code}): {r.text}", err=True)
+        sys.exit(1)
+    click.echo(json.dumps(r.json()))
+
+
+@cli.command()
+@click.option("--master-url", envvar="MASTER_URL", default=None)
+@click.option("--admin-token", envvar="FLEET_ADMIN_TOKEN", default=None)
+@click.option("--worker-token", envvar="FLEET_WORKER_TOKEN", default=None)
+@click.option("--backend-url", envvar="FLEET_BACKEND_URL", default=None)
+def doctor(
+    master_url: str | None,
+    admin_token: str | None,
+    worker_token: str | None,
+    backend_url: str | None,
+) -> None:
+    """Pre-flight sanity checks: env tokens, plugins, backend, master reachable."""
+    asyncio.run(_doctor(master_url, admin_token, worker_token, backend_url))
+
+
+async def _doctor(master_url, admin_token, worker_token, backend_url) -> None:
+    import httpx
+
+    ok = True
+
+    def _check(label: str, condition: bool, detail: str = "") -> None:
+        nonlocal ok
+        mark = "✓" if condition else "✗"
+        ok = ok and condition
+        click.echo(f"{mark} {label}" + (f" — {detail}" if detail else ""))
+
+    _check("FLEET_ADMIN_TOKEN set", bool(admin_token))
+    _check("FLEET_WORKER_TOKEN set", bool(worker_token))
+
+    from fleet.core.automation import load_entry_points
+    reg = load_entry_points()
+    _check("automations discovered", bool(reg), f"{len(reg)} found")
+    for name in reg:
+        click.echo(f"    {name}")
+
+    if backend_url:
+        try:
+            from fleet.core.backend import RedisBackend, backend_from_url
+            be = backend_from_url(backend_url)
+            _check("backend constructs", True, type(be).__name__)
+            if isinstance(be, RedisBackend):
+                try:
+                    pong = await be.r.ping()
+                    _check("redis ping", bool(pong))
+                    info = await be.r.info("persistence")
+                    aof = info.get(b"aof_enabled", info.get("aof_enabled"))
+                    aof_on = str(aof).strip() in ("1", "True", "true")
+                    _check(
+                        "redis AOF on", aof_on,
+                        "" if aof_on else "data lives only in RAM; configs/pools die on restart",
+                    )
+                except Exception as e:
+                    _check("redis reachable", False, str(e))
+                finally:
+                    await be.aclose()
+        except Exception as e:
+            _check("backend constructs", False, str(e))
+    else:
+        click.echo("· backend-url not set (skipping backend checks)")
+
+    if master_url and admin_token:
+        try:
+            async with httpx.AsyncClient(timeout=3) as c:
+                r = await c.get(master_url.rstrip("/") + "/healthz")
+                _check("master /healthz reachable", r.status_code == 200, f"HTTP {r.status_code}")
+                r = await c.get(
+                    master_url.rstrip("/") + "/api/v1/automations",
+                    headers={"Authorization": f"Bearer {admin_token}"},
+                )
+                _check("admin token accepted", r.status_code == 200, f"HTTP {r.status_code}")
+        except Exception as e:
+            _check("master reachable", False, str(e))
+    else:
+        click.echo("· master-url or admin-token not set (skipping master checks)")
+
+    sys.exit(0 if ok else 1)
+
+
+if __name__ == "__main__":
+    cli()

fleet_framework-0.1.0/fleet/core/__init__.py

@@ -0,0 +1,69 @@
+from fleet.core.automation import (
+    BaseAutomation,
+    BatchAutomation,
+    ContinuousAutomation,
+    Task,
+    catalog_doc,
+    get_registry,
+    load_entry_points,
+    register,
+)
+from fleet.core.backend import Backend, RedisBackend
+from fleet.core.config import BaseConfig
+from fleet.core.context import Context
+from fleet.core.contract import Pool, Queue, Stream
+from fleet.core.country_presets import known_presets, resolve_countries
+from fleet.core.primitives import (
+    KV,
+    Counter,
+    Lock,
+    PoolFilter,
+    PoolHandle,
+    PoolItem,
+    QueueHandle,
+    StreamReader,
+)
+from fleet.core.proxy import (
+    ProxyHandle,
+    ProxyProvider,
+    ProxySession,
+    build_provider,
+    get_provider_registry,
+    load_provider_entry_points,
+    register_provider,
+)
+
+__all__ = [
+    "Backend",
+    "BaseAutomation",
+    "BaseConfig",
+    "BatchAutomation",
+    "ContinuousAutomation",
+    "Context",
+    "Counter",
+    "KV",
+    "Lock",
+    "Pool",
+    "PoolFilter",
+    "PoolHandle",
+    "PoolItem",
+    "ProxyHandle",
+    "ProxyProvider",
+    "ProxySession",
+    "Queue",
+    "QueueHandle",
+    "RedisBackend",
+    "Stream",
+    "StreamReader",
+    "Task",
+    "build_provider",
+    "catalog_doc",
+    "get_provider_registry",
+    "get_registry",
+    "known_presets",
+    "load_entry_points",
+    "load_provider_entry_points",
+    "register",
+    "register_provider",
+    "resolve_countries",
+]