flashnode 0.2.0__py3-none-any.whl

flashnode/identity/enrol.py

@@ -0,0 +1,179 @@
+"""Device-code enrolment: claim this machine from a browser.
+
+The volunteer runs one command on the machine they are lending, reads a
+short code off the terminal, and types it into a page they are already
+signed in to — on any device, typically a phone. The machine never handles
+the account password, and the person approving is provably the account
+owner because the approval endpoint requires their session.
+
+This is RFC 8628's device authorization grant, which exists for exactly
+this shape of problem: a client that can display a code but cannot host a
+login. The API implements the server half (`/v1alpha1/device/code`,
+`/v1alpha1/device/token`); this is the client half, which was missing —
+`flashnode login` required `--token`, a credential the enrolment flow never
+hands out, so the documented path could not be walked.
+
+Everything I/O-ish is injected (`http`, `sleep`, `now`) so the polling loop
+is testable without a server or real time passing.
+"""
+
+from __future__ import annotations
+
+import json
+import platform as platform_mod
+import socket
+import time
+import urllib.error
+import urllib.request
+from dataclasses import dataclass
+from typing import Callable, Protocol
+
+__all__ = [
+    "DeviceCodeStart",
+    "EnrolmentError",
+    "describe_this_machine",
+    "request_device_code",
+    "poll_for_token",
+]
+
+# Cap on how long we keep polling if the server never tells us otherwise.
+# The server's own expiry is authoritative; this only bounds the case where
+# it hands back something unparseable.
+MAX_POLL_SECONDS = 15 * 60
+DEFAULT_INTERVAL = 5.0
+
+
+class EnrolmentError(RuntimeError):
+    """Enrolment could not complete. The message is shown to a human."""
+
+
+class Http(Protocol):
+    def __call__(self, url: str, payload: dict) -> tuple[int, dict]:
+        """POST `payload` as JSON, return (status, decoded body)."""
+
+
+@dataclass(frozen=True)
+class DeviceCodeStart:
+    device_code: str
+    user_code: str
+    verification_uri: str
+    interval: float
+    expires_at: str
+
+
+def _post(url: str, payload: dict) -> tuple[int, dict]:
+    """POST JSON with the stdlib. flashnode deliberately has no HTTP
+    dependency — every byte a volunteer installs is a byte they did not ask
+    for — and `agent/daemon.py` already reaches for urllib for the same
+    reason."""
+    body = json.dumps(payload).encode()
+    req = urllib.request.Request(
+        url,
+        data=body,
+        headers={"Content-Type": "application/json"},
+        method="POST",
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=30) as resp:
+            return resp.status, json.loads(resp.read() or b"{}")
+    except urllib.error.HTTPError as exc:
+        # A 400 is the protocol's "not yet" and carries a body worth
+        # reading, so this is control flow, not an error path.
+        raw = exc.read() or b"{}"
+        try:
+            return exc.code, json.loads(raw)
+        except ValueError:
+            return exc.code, {"error": raw.decode("utf-8", "replace")[:200]}
+    except urllib.error.URLError as exc:
+        raise EnrolmentError(
+            f"could not reach {url}: {exc.reason}. Check the --coordinator "
+            "URL, and that you are online."
+        ) from exc
+
+
+def describe_this_machine() -> tuple[str, str]:
+    """(hostname, platform) for the approval screen.
+
+    Purely for the human deciding whether to approve: a list of machines
+    reading "fn-9c2a…" tells them nothing, "phongs-macbook-air / macOS-15"
+    tells them which laptop they are looking at. Never trusted by the
+    server for anything.
+    """
+    try:
+        hostname = socket.gethostname() or "unknown"
+    except OSError:
+        hostname = "unknown"
+    return hostname[:120], platform_mod.platform()[:120]
+
+
+def request_device_code(
+    api_base: str,
+    node_id: str,
+    hostname: str,
+    platform_name: str,
+    http: Http = _post,
+) -> DeviceCodeStart:
+    status, body = http(
+        f"{api_base.rstrip('/')}/v1alpha1/device/code",
+        {"node_id": node_id, "hostname": hostname, "platform": platform_name},
+    )
+    if status != 200:
+        detail = body.get("detail") or body.get("error") or f"HTTP {status}"
+        raise EnrolmentError(f"could not start enrolment: {detail}")
+    try:
+        return DeviceCodeStart(
+            device_code=body["device_code"],
+            user_code=body["user_code"],
+            verification_uri=body["verification_uri"],
+            interval=float(body.get("interval") or DEFAULT_INTERVAL),
+            expires_at=str(body.get("expires_at") or ""),
+        )
+    except (KeyError, TypeError, ValueError) as exc:
+        raise EnrolmentError(
+            f"enrolment response was not in the expected shape: {body!r}"
+        ) from exc
+
+
+def poll_for_token(
+    api_base: str,
+    device_code: str,
+    interval: float = DEFAULT_INTERVAL,
+    http: Http = _post,
+    sleep: Callable[[float], None] = time.sleep,
+    now: Callable[[], float] = time.monotonic,
+    max_seconds: float = MAX_POLL_SECONDS,
+) -> str:
+    """Block until a human approves, then return the machine token.
+
+    The server answers unknown / unapproved / expired / already-redeemed
+    with one indistinguishable `authorization_pending`, deliberately, so a
+    caller cannot probe which codes exist. That means we cannot report
+    *why* nothing happened — only that nothing did — so the timeout message
+    has to name the likely causes itself.
+    """
+    url = f"{api_base.rstrip('/')}/v1alpha1/device/token"
+    deadline = now() + max_seconds
+    # Never poll faster than the server asked, and never so slowly that an
+    # approval sits unnoticed. A server that returns 0 or something absurd
+    # must not turn this into a hot loop against its own API.
+    wait = min(max(float(interval or DEFAULT_INTERVAL), 1.0), 30.0)
+
+    while True:
+        status, body = http(url, {"device_code": device_code})
+        if status == 200 and body.get("token"):
+            return str(body["token"])
+        if status == 400 and body.get("error") == "authorization_pending":
+            server_interval = body.get("interval")
+            if server_interval:
+                wait = min(max(float(server_interval), 1.0), 30.0)
+        elif status != 400:
+            detail = body.get("detail") or body.get("error") or f"HTTP {status}"
+            raise EnrolmentError(f"enrolment failed: {detail}")
+
+        if now() >= deadline:
+            raise EnrolmentError(
+                "timed out waiting for approval. The code may have expired, "
+                "or it was never approved — run `flashnode login` again to "
+                "get a fresh one."
+            )
+        sleep(wait)

flashnode/identity/store.py

@@ -0,0 +1,48 @@
+"""Stable FlashNode identity.
+
+One ID per node, created on first run and persisted in the state directory
+(a hostPath volume in the Kubernetes profile, so the ID survives pod
+restarts and represents the *node*, not the pod). Ed25519 signing keys are a
+documented future step — the POC identity is an opaque random ID.
+"""
+
+from __future__ import annotations
+
+import os
+import uuid
+from pathlib import Path
+
+# Per-user, not system-wide. /var/lib/flashnode was the default and is not
+# writable by an ordinary account on macOS or Windows, so the very first
+# command a volunteer runs died with
+#   PermissionError: [Errno 13] Permission denied: '/var/lib/flashnode'
+# before enrolment could start, and with nothing to suggest that a directory
+# choice was the problem.
+#
+# ~/.flashnode also matches where the credential store already writes
+# (identity/credentials.py), so a machine's identity and its token sit
+# together and `rm -rf ~/.flashnode` fully un-enrols it.
+#
+# The Kubernetes profile sets FLASHNODE_STATE_DIR explicitly
+# (flashml-cloud/infra/base/flashnode.yaml) to a hostPath volume, so there
+# the ID still survives pod restarts and still identifies the *node*.
+DEFAULT_STATE_DIR = "~/.flashnode"
+
+
+def state_dir() -> Path:
+    raw = os.environ.get("FLASHNODE_STATE_DIR") or DEFAULT_STATE_DIR
+    return Path(raw).expanduser()
+
+
+def load_or_create_node_id() -> str:
+    path = state_dir() / "node-id"
+    if path.exists():
+        node_id = path.read_text().strip()
+        if node_id:
+            return node_id
+    node_id = f"fn-{uuid.uuid4().hex[:16]}"
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp = path.with_suffix(".tmp")
+    tmp.write_text(node_id + "\n")
+    tmp.replace(path)
+    return node_id

flashnode/inventory/__init__.py

@@ -0,0 +1,5 @@
+"""Hardware and software discovery.
+
+Reports CPU, RAM, disk, OS, architecture, container runtime, and optional
+GPU via psutil and platform probes. Produces NodeCapabilitySnapshot payloads.
+"""

flashnode/inventory/capabilities.py

@@ -0,0 +1,117 @@
+"""Hardware/software discovery for the node the agent runs on.
+
+psutil + platform probes; Kubernetes allocatable values (when available from
+the API) take precedence over raw host numbers because they are what the
+scheduler can actually place on the node.
+"""
+
+from __future__ import annotations
+
+import os
+import platform
+import socket
+
+import psutil
+
+from flashruntime.protocol.v1alpha1 import (
+    NodeCapabilities,
+    NodeEnvironment,
+    NodeRegistration,
+)
+
+# Kubernetes reports arch as amd64/arm64; platform.machine() says x86_64/arm64.
+_ARCH_MAP = {"x86_64": "amd64", "aarch64": "arm64", "arm64": "arm64", "amd64": "amd64"}
+
+# Only labels in these namespaces are reported upstream — never arbitrary
+# cluster metadata.
+_ALLOWED_LABEL_PREFIXES = ("flashml.dev/", "kubernetes.io/arch", "kubernetes.io/os",
+                           "node.kubernetes.io/instance-type",
+                           "topology.kubernetes.io/")
+
+
+def classify_environment() -> NodeEnvironment:
+    value = os.environ.get("FLASHNODE_ENVIRONMENT", "local").lower()
+    try:
+        return NodeEnvironment(value)
+    except ValueError:
+        return NodeEnvironment.LOCAL
+
+
+def filter_node_labels(labels: dict[str, str]) -> dict[str, str]:
+    return {
+        k: v for k, v in labels.items()
+        if any(k.startswith(p) for p in _ALLOWED_LABEL_PREFIXES)
+    }
+
+
+def _parse_k8s_cpu(value: str) -> float:
+    return float(value[:-1]) / 1000 if value.endswith("m") else float(value)
+
+
+def _parse_k8s_memory(value: str) -> int:
+    units = {"Ki": 1024, "Mi": 1024**2, "Gi": 1024**3, "Ti": 1024**4,
+             "K": 1000, "M": 1000**2, "G": 1000**3, "T": 1000**4}
+    for suffix, mult in units.items():
+        if value.endswith(suffix):
+            return int(float(value[: -len(suffix)]) * mult)
+    return int(value)
+
+
+def discover(node_id: str, kubernetes_node: str,
+             node_meta: dict | None = None,
+             argv_capable: bool = False,
+             module_capable: bool = True) -> NodeRegistration:
+    """Build the registration payload. `node_meta` is the Kubernetes Node
+    object (status/metadata) when the agent has API access; None degrades to
+    host-level probes only."""
+    allocatable = (node_meta or {}).get("status", {}).get("allocatable", {})
+    labels = filter_node_labels((node_meta or {}).get("metadata", {}).get("labels", {}))
+
+    if allocatable:
+        cpu = _parse_k8s_cpu(allocatable.get("cpu", "0"))
+        memory = _parse_k8s_memory(allocatable.get("memory", "0"))
+    else:
+        cpu = float(psutil.cpu_count() or 0)
+        memory = psutil.virtual_memory().total
+
+    arch = _ARCH_MAP.get(platform.machine().lower(), platform.machine().lower())
+    environment = classify_environment()
+    sandbox_capable = (
+        os.environ.get("FLASHNODE_SANDBOX_CAPABLE", "").lower() == "true"
+        or labels.get("flashml.dev/sandbox-capable") == "true"
+        # ArgvDockerRunner is container-only by construction — there is no
+        # unsandboxed code path — so argv capability implies sandbox
+        # capability. This is deliberately asymmetric with --runner docker
+        # (DockerRunner does not imply sandboxing on its own): widening that
+        # path is a separate judgment call, not an oversight here.
+        or argv_capable
+    )
+
+    from flashnode import __version__
+
+    return NodeRegistration(
+        node_id=node_id,
+        kubernetes_node=kubernetes_node,
+        hostname=socket.gethostname(),
+        capabilities=NodeCapabilities(
+            cpu_cores=cpu,
+            memory_bytes=memory,
+            gpus=[],  # GPU probing is a documented follow-up; never guess.
+            os=labels.get("kubernetes.io/os", platform.system().lower()),
+            architecture=labels.get("kubernetes.io/arch", arch),
+        ),
+        environment=environment,
+        sandbox_capable=sandbox_capable,
+        # Set by the agent when it is actually running an argv-capable
+        # runner — never inferred, so the coordinator's fail-closed gate
+        # cannot be satisfied by a node that merely has docker installed.
+        argv_capable=argv_capable,
+        # Set by the agent to False only for an argv-only runner — the
+        # coordinator's module gate is fail-open (unlike argv_capable), so
+        # the default here matches every caller that doesn't pass it.
+        module_capable=module_capable,
+        pool=labels.get("flashml.dev/pool", os.environ.get("FLASHNODE_POOL", "local")),
+        runtime_profile=os.environ.get("FLASHNODE_RUNTIME_PROFILE", "kubernetes"),
+        labels=labels,
+        agent_version=__version__,
+    )

flashnode/telemetry/__init__.py

@@ -0,0 +1,79 @@
+"""Telemetry: what this machine is doing, as data the network can use.
+
+Scope boundary — telemetry is *resource observation only*. Lease/attempt
+heartbeats and task progress already live in `executor/loop.py` and must
+stay there (they are correctness signals, not metrics; mixing them with
+best-effort telemetry would let a metrics hiccup look like a dead task).
+
+Intended flow: the work loop calls `collector.sample()` on its node-
+heartbeat cadence and attaches the sample to the heartbeat. NOTE for the
+implementer: `protocol.v1alpha1.NodeHeartbeat` does not carry a telemetry
+field yet — adding `telemetry: dict | None = None` there is an *additive*
+protocol change (allowed within v1alpha1) and is the actual wiring step;
+do it protocol-first, then here.
+
+Privacy stance (trust-through-transparency, AGENTS hard rule 5): samples
+describe the MACHINE (utilization, free space, temperatures), never the
+user of the machine (no process lists, no window titles, no network
+destinations). Every field an owner might question must be visible in this
+schema — that is why it is a typed model, not a dict.
+
+Status: interface complete; the psutil-based collector is a small slice
+(psutil is already an agent dependency via inventory/) — lands with the
+community-pool tier alongside `benchmark/`.
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from datetime import datetime, timezone
+
+from pydantic import BaseModel, Field
+
+__all__ = ["GpuSample", "TelemetrySample", "TelemetryCollector"]
+
+
+class GpuSample(BaseModel):
+    """One GPU's instantaneous state (NVML-shaped; all optional because
+    partial visibility is normal — record what's readable, omit the rest)."""
+
+    index: int = 0
+    utilization_percent: float | None = None
+    memory_used_bytes: int | None = None
+    memory_total_bytes: int | None = None
+    temperature_c: float | None = None
+    power_watts: float | None = None
+
+
+class TelemetrySample(BaseModel):
+    """A point-in-time snapshot of machine health.
+
+    Fields are chosen for what the *coordinator* can act on: scheduling
+    away from thermally-throttling or disk-full nodes, and (later) the
+    reliability score's thermal-stability input (master report §9.1)."""
+
+    timestamp: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+    cpu_percent: float | None = Field(default=None, ge=0)
+    memory_used_bytes: int | None = Field(default=None, ge=0)
+    memory_total_bytes: int | None = Field(default=None, ge=0)
+    disk_free_bytes: int | None = Field(
+        default=None, ge=0, description="Free space on the workdir volume — the checkpoint path"
+    )
+    load_1m: float | None = Field(default=None, ge=0)
+    gpus: list[GpuSample] = Field(default_factory=list)
+
+
+class TelemetryCollector(ABC):
+    """Produces samples; owns nothing else.
+
+    Contract: `sample()` must be cheap (called on the heartbeat cadence,
+    default 5 s), must never raise for missing sensors (absent fields stay
+    None — same honesty rule as probes), and must never block on hardware
+    that is busy (a wedged NVML call gets a short internal timeout and an
+    omitted field, not a stuck heartbeat — the heartbeat is a correctness
+    signal and telemetry must never delay it).
+    """
+
+    @abstractmethod
+    def sample(self) -> TelemetrySample:
+        """Take one snapshot now."""

flashnode-0.2.0.dist-info/METADATA

@@ -0,0 +1,160 @@
+Metadata-Version: 2.4
+Name: flashnode
+Version: 0.2.0
+Summary: Open host agent for the FlashML fragmented-compute network: join, benchmark, execute sandboxed ML tasks, earn contribution credits.
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/Zolli-Labs/flashnode
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: flashruntime<0.4,>=0.3
+Requires-Dist: psutil>=5.9
+Requires-Dist: websockets>=12
+Requires-Dist: cryptography>=42
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Dynamic: license-file
+
+# FlashNode
+
+> **The open host agent of the FlashML system.** Install FlashNode on a
+> machine you own, and it can safely execute distributed ML tasks for the
+> FlashML network — earning contribution credits for verified useful work.
+
+FlashNode is one of three components in the FlashML system by
+[Zolli Labs](https://github.com/Zolli-Labs):
+
+- **flashnode** (this repo) — open host agent installed by resource
+  contributors. Because it runs on someone else's machine and executes
+  third-party workloads, it must be inspectable, minimal, and explicit about
+  permissions — which is why it is open source.
+- **[flashruntime](https://github.com/Zolli-Labs/flashruntime)** — the open
+  workload protocol and execution layer.
+- **flashml-cloud** (private) — the managed control plane and dashboard.
+
+Read [`docs/SYSTEM_OVERVIEW.md`](docs/SYSTEM_OVERVIEW.md) for the full
+product architecture, and [`AGENTS.md`](AGENTS.md) if you are an AI coding
+agent working in this repo.
+
+## Status
+
+**Pre-release; the device executor works today** (July 2026). A machine
+with this agent can join a FlashRuntime coordinator over outbound HTTP,
+pull leased tasks, execute them, relay training checkpoints, and commit
+verified results. Two profiles:
+
+- **Device profile** (`flashnode work`) — the pull-based executor for
+  laptops/workstations. Implemented.
+- **Kubernetes profile** (`flashnode agent`) — per-node telemetry reporter
+  inside managed pools (DaemonSet); KubeRay owns workload pods there.
+  Implemented.
+
+## What it does today
+
+```bash
+pip install -e .                      # plus: pip install -e ../flashruntime
+flashnode work --coordinator http://<coordinator>:8100
+# optional hardening / pool config:
+#   FLASHNODE_JOIN_CODE=...          join-code-gated pools
+#   --runner docker + FLASHNODE_ALLOWED_IMAGES=img:tag,...   container tier
+#   FLASHNODE_WORKDIR=$HOME/.cache/flashnode   (macOS + colima: VM-visible workdirs)
+#   FLASHNODE_WORKDIR=C:\Users\<you>\.flashnode  (Windows: must be under a
+#                                                 directory Docker Desktop shares)
+```
+
+If the coordinator enforces per-machine authentication
+(`FLASHML_NODE_TOKENS` set server-side), save the bearer token you were
+given before running `work`:
+
+```bash
+flashnode login --coordinator http://<coordinator>:8100 --token <token>
+flashnode work --coordinator http://<coordinator>:8100   # reads the saved token automatically
+flashnode logout --coordinator http://<coordinator>:8100 # forget it locally (does not revoke server-side)
+```
+
+`login`/`logout` write to a per-coordinator credential store at
+`~/.flashnode/credentials.json` (override with `FLASHNODE_CREDENTIALS`),
+keyed by coordinator URL so one machine can hold separate tokens for
+separate pools. The file is written with mode `0600` on every save. A
+missing or unparseable file is treated as "no saved token" rather than a
+crash. `CoordinatorClient` sends the saved token as a bearer header on
+every request to that coordinator once it's saved — there is nothing else
+to configure. Token issuance is still manual and out-of-band today (the
+coordinator operator hands you the token; there is no self-service signup
+or browser device flow yet), and `flashnode logout` only removes the local
+copy — the operator revokes access by removing your token from the
+coordinator's configuration.
+
+- Stable node identity; registers with capabilities (CPU, RAM, arch, GPU)
+  and **re-registers automatically** if the coordinator restarts.
+- **Outbound-only** HTTP — no inbound ports, no router configuration.
+- Claims task leases, renews them with attempt heartbeats, and stops work
+  the moment a lease is refused (the coordinator's idempotent commit
+  rejects late duplicates regardless — defense in depth).
+- Two execution tiers behind one interface: `SubprocessRunner`
+  (allowlisted Python modules, wall-clock timeout, **scrubbed
+  environment** — agent secrets never reach task code) and `DockerRunner`
+  (allowlisted images, `--network none`, cpu/memory limits, read-only
+  rootfs, uid mapping).
+- Downloads shared input artifacts; uploads outputs with sha256 for the
+  coordinator's commit-time validation.
+- **Checkpoint courier**: tasks stay network-isolated, so the agent
+  fetches the task's latest valid checkpoint before a run (resume) and
+  ships each new checkpoint file during it — a task killed on this
+  machine resumes from its checkpoint on another.
+
+Still to come: Ed25519-signed identity, admission benchmarks (`benchmark/`),
+richer telemetry (`telemetry/`), gVisor/Kata isolation tiers, and the
+`join`/`status`/`leave` UX.
+
+## Security contract
+
+- Outbound-only control connection; no inbound SSH or public ports.
+- Signed node identity; short-lived session credentials.
+- Allowlisted or signed workload images only.
+- Non-root execution; no host Docker socket, device passthrough, or
+  privileged mode.
+- The agent shows exactly which limits and permissions apply to a workload
+  before executing it.
+- Complete event logging of task assignment, image digest, permissions, and
+  artifact commits.
+
+Supported host class (initial): x86-64 Linux, macOS (Docker Desktop or
+Colima), or Windows (Docker Desktop with the **WSL2 backend**), Python
+3.10+, ≥4 CPU cores, ≥8 GB RAM, stable outbound internet.
+
+**Windows note:** `flashnode work` used to crash immediately on Windows
+(`os.getuid`/`os.getgid` don't exist there). It now omits `--user` on
+Windows instead, relying on the curated images' own non-root `USER`
+declaration for non-root execution — see
+[`docs/guides/donate-a-machine.md`](https://github.com/Zolli-Labs/flashruntime/blob/main/docs/guides/donate-a-machine.md#platform-support)
+in flashruntime for the full picture, including honest caveats: **Windows
+support is constructed-argv-verified (tests fake the platform), not yet
+execution-verified against a real Windows machine.**
+
+## Package layout
+
+Working today:
+
+```
+flashnode/
+├── agent/       # CLI (`work`, `agent`), K8s-profile daemon, kube helper
+├── identity/    # stable node ID (Ed25519 signing: planned); credentials.py
+│                #   is the per-coordinator bearer-token store behind
+│                #   `flashnode login`/`logout`
+├── inventory/   # capability discovery (psutil + K8s allocatable)
+└── executor/    # the device work cycle:
+    ├── client.py         # stdlib outbound HTTP: leases, artifacts, checkpoints
+    ├── runner.py         # Tier 1: allowlisted subprocess, scrubbed env
+    ├── docker_runner.py  # Tier 2: allowlisted containers, network-none
+    └── loop.py           # claim → run (heartbeating) → relay ckpts → commit
+```
+
+Scaffolds awaiting their vertical slice: `benchmark/` (admission probes),
+`telemetry/` (rich metrics), `artifacts/` (local caching), `config/`
+(host-owner policy).
+
+## License
+
+[Apache-2.0](LICENSE). Contributions via Developer Certificate of Origin
+(`git commit -s`).

flashnode-0.2.0.dist-info/RECORD

@@ -0,0 +1,30 @@
+flashnode/__init__.py,sha256=TuoTHNk6l-uwAWQNPoHJ3xKrgMmwnOdkJCQT6j4oZJ0,203
+flashnode/agent/__init__.py,sha256=SKSAPuExVvhqDfdDgp-_fNZYzpnBYnw6I9QNuJd8sQw,227
+flashnode/agent/cli.py,sha256=DhTrjIVOiHHOsME6Gnqh_rOJRqR3k_shNGgMtWZ_bi0,10775
+flashnode/agent/daemon.py,sha256=R2bS9ACRlhdAAoGGfk9tasmYDfEzFSFTMHDxNxGJGOg,3868
+flashnode/agent/kube.py,sha256=3olz_oVv0RdDNogFwakiXyUD-q8J7PKVZ5_pABWiQew,1400
+flashnode/artifacts/__init__.py,sha256=J3VdNm08o0AL1kLD_cjsxmGgm8e_uhwnljvYMI5nmek,177
+flashnode/benchmark/__init__.py,sha256=YC66KYR-W7NANMtV0Y8kpixdzBxslgsaK9mDYaDxbBI,4168
+flashnode/config/__init__.py,sha256=t6C8iJkWyIGJmdv9kqh30iFkcw6vkdy73UkPnvDbZhs,4404
+flashnode/executor/__init__.py,sha256=6wQKrF-0zl5jAU21_xkeNA3P3iQ5jhbx0IFUlXdjkNU,1035
+flashnode/executor/archives.py,sha256=HsFpwR_MyICSp7wkw4Wr_4rmobvnaT_d2l2I6LSNJkI,12472
+flashnode/executor/argv_runner.py,sha256=OuvInw5s6QWqdGaLNrYg70NzGVpel98oeuRU5c_XMbg,5284
+flashnode/executor/client.py,sha256=0mSkjIrb1M66Jz9ofL-OqM7fu13arrMjEqTfKgYl2a8,7473
+flashnode/executor/docker_runner.py,sha256=J9Ym1nY18RvFSbnA5b71Zu-PV8Lf34mHF-rQ6YpNh7I,5072
+flashnode/executor/hardening.py,sha256=xha8ab-gM16qAsqEXk0s_zywcmsV323f5cODJ_Jf9Gc,5984
+flashnode/executor/images.py,sha256=OGJt36m1HKwUOErN_MR_sixG3gxIFKH8htfTVK7Opeg,7563
+flashnode/executor/loop.py,sha256=E_gBh6A-T3oEQmR-lvYDR2k5NXrYSySX61RIiOgy4To,16847
+flashnode/executor/runner.py,sha256=AT6M80QDB9p8GFIpT7rgym2Tus-IUNnh5eBpIPavyx0,4218
+flashnode/identity/__init__.py,sha256=bT0-8rAXwZdhGsTpVb1_KcCYSDwr9Tpwzfl7OiP19wc,161
+flashnode/identity/credentials.py,sha256=y-OGUYEyv5J5z_FUT01tSYWGdpPfC9z0F6sX5AyZKv0,2059
+flashnode/identity/enrol.py,sha256=GHvBLQDWdCTfDR45CQ1C70Jd00wFINfcxzvcDRC4ofg,6622
+flashnode/identity/store.py,sha256=ZGCPhSiH63PAE3GRPGrlhlc2nNPgstDSMtNPu4N-OCE,1734
+flashnode/inventory/__init__.py,sha256=epNMD283icBq-jjg5rN0u51tpSWm1RTw8PhkAXr88fM,193
+flashnode/inventory/capabilities.py,sha256=XyE3pAVHG5Tvsk6kslJtx7vo5UXWYP4ZOiVgEym5FpY,4602
+flashnode/telemetry/__init__.py,sha256=MRJ99bQykL1do3dQYMNiQABmYhTuEkgZdfsm5Np0KD4,3363
+flashnode-0.2.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+flashnode-0.2.0.dist-info/METADATA,sha256=qL1vFkT0WcNQ8ZJpOHTVzpxHqfgfskO8uLn8FyDhWa8,7522
+flashnode-0.2.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+flashnode-0.2.0.dist-info/entry_points.txt,sha256=rn0W3v0MU8yhzp6b3j9frGA92h5bN3vgqMQRuYAoBkM,55
+flashnode-0.2.0.dist-info/top_level.txt,sha256=BErbFoSvml51DxXayRtL5l8_1p59Z4XnC2bmKeaWdBo,10
+flashnode-0.2.0.dist-info/RECORD,,

flashnode-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

flashnode-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+flashnode = flashnode.agent.cli:main