product-forge 0.2.0__py3-none-any.whl

forge_agent_bridge/__init__.py

@@ -0,0 +1,11 @@
+"""Forge Agent Bridge — universal agent session layer.
+
+The Bridge owns provider connections, session lifecycle, normalized
+events and approval routing. The Portal owns experience; the agent
+runtime executes; policies authorize. Public surface only — consumers
+(product-forge, forge-portal) import these contracts, never internals.
+"""
+
+__version__ = "0.1.0"
+EVENT_SCHEMA = "forge/AgentBridgeEvent/v1"
+CONTRACT_SCHEMA = "forge/AgentBridgeContract/v1"

forge_agent_bridge/acp.py

@@ -0,0 +1,171 @@
+"""ACP client (§19.2) — JSON-RPC over stdio: handshake, version
+negotiation, session lifecycle, prompt, streaming, cancel.
+
+Transport: newline-delimited JSON-RPC 2.0 on the agent's stdin/stdout.
+No SDK is vendored; the wire contract is documented ACP semantics.
+"""
+
+from __future__ import annotations
+
+import itertools
+import json
+import subprocess
+import threading
+from collections.abc import Iterator
+from typing import Any
+
+from .adapter import BridgeError, ProviderUnavailableError
+
+_ids = itertools.count(1)
+PROTOCOL_VERSION = 1
+
+
+class AcpClient:
+    """Minimal ACP stdio client. One client per spawned agent process."""
+
+    def __init__(self, cmd: list[str], timeout_s: float = 30.0):
+        self.cmd, self.timeout_s = cmd, timeout_s
+        self.proc: subprocess.Popen[bytes] | None = None
+        self._pending: dict[int, dict[str, Any]] = {}
+        self._notifications: list[dict[str, Any]] = []
+        self._lock = threading.Lock()
+        self._reader: threading.Thread | None = None
+        self.protocol_version: int | None = None
+
+    # -- transport ---------------------------------------------------------
+
+    def start(self) -> None:
+        try:
+            self.proc = subprocess.Popen(
+                self.cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE,
+                stderr=subprocess.DEVNULL)
+        except FileNotFoundError as exc:
+            raise ProviderUnavailableError(f"agent executable not found: {self.cmd[0]}") from exc
+        self._reader = threading.Thread(target=self._read_loop, daemon=True)
+        self._reader.start()
+
+    def _read_loop(self) -> None:
+        assert self.proc and self.proc.stdout
+        for line in self.proc.stdout:
+            try:
+                msg = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+            mid = msg.get("id")
+            if mid in self._pending:
+                self._pending[mid] = msg
+            else:
+                self._notifications.append(msg)
+
+    def request_async(self, method: str,
+                      params: dict[str, Any] | None = None) -> int:
+        """Send a request without waiting; returns the request id."""
+        if not self.proc or not self.proc.stdin:
+            raise BridgeError("FAB-TRANSPORT", "client not started")
+        rid = next(_ids)
+        self._pending[rid] = {}
+        self.proc.stdin.write(
+            json.dumps({"jsonrpc": "2.0", "id": rid, "method": method,
+                        "params": params or {}}).encode() + b"\n")
+        self.proc.stdin.flush()
+        return rid
+
+    def response_ready(self, rid: int) -> dict[str, Any] | None:
+        return self._pending.get(rid) or None
+
+    def resolve(self, rid: int) -> dict[str, Any]:
+        """Pop a ready response; raises on RPC error."""
+        resp = self._pending.pop(rid, {})
+        if "error" in resp:
+            e = resp["error"]
+            raise BridgeError(f"FAB-RPC-{e.get('code', 'ERR')}",
+                              str(e.get("message", e)))
+        return resp.get("result", {})
+
+    def request(self, method: str, params: dict[str, Any] | None = None) -> dict[str, Any]:
+        rid = self.request_async(method, params)
+        import time
+        deadline = time.monotonic() + self.timeout_s
+        while time.monotonic() < deadline:
+            if self.response_ready(rid):
+                return self.resolve(rid)
+            time.sleep(0.01)
+        self._pending.pop(rid, None)
+        raise BridgeError("FAB-TIMEOUT", f"{method} timed out after {self.timeout_s}s")
+
+    def notify(self, method: str, params: dict[str, Any] | None = None) -> None:
+        if self.proc and self.proc.stdin:
+            self.proc.stdin.write(
+                json.dumps({"jsonrpc": "2.0", "method": method,
+                            "params": params or {}}).encode() + b"\n")
+            self.proc.stdin.flush()
+
+    def drain_notifications(self) -> list[dict[str, Any]]:
+        """Non-blocking: pop all queued notifications (turn already done)."""
+        with self._lock:
+            out, self._notifications = self._notifications, []
+        return out
+
+    def notifications(self) -> Iterator[dict[str, Any]]:
+        while True:
+            if self._notifications:
+                yield self._notifications.pop(0)
+            else:
+                import time
+                time.sleep(0.02)
+                if self.proc and self.proc.poll() is not None and not self._notifications:
+                    return
+
+    # -- ACP semantics -------------------------------------------------------
+
+    def initialize(self) -> dict[str, Any]:
+        res = self.request("initialize", {
+            "protocolVersion": PROTOCOL_VERSION,
+            "clientCapabilities": {"fs": {"readTextFile": True, "writeTextFile": True},
+                                   "terminal": False}})
+        self.protocol_version = res.get("protocolVersion", PROTOCOL_VERSION)
+        return res
+
+    def new_session(self, cwd: str = ".", mcp_servers: list[dict] | None = None) -> str:
+        res = self.request("session/new", {"cwd": cwd, "mcpServers": mcp_servers or []})
+        sid = res.get("sessionId")
+        if not sid:
+            raise BridgeError("FAB-SESSION", "session/new returned no sessionId")
+        return str(sid)
+
+    def prompt(self, session_id: str, text: str) -> dict[str, Any]:
+        return self.request("session/prompt", {
+            "sessionId": session_id,
+            "prompt": [{"type": "text", "text": text}]})
+
+    def prompt_async(self, session_id: str, text: str) -> int:
+        """Start a turn without blocking — notifications stream while the
+        response is in flight. Resolve via resolve(rid)."""
+        return self.request_async("session/prompt", {
+            "sessionId": session_id,
+            "prompt": [{"type": "text", "text": text}]})
+
+    def load_session(self, session_id: str, cwd: str = ".",
+                     mcp_servers: list[dict] | None = None) -> dict[str, Any]:
+        """ACP session/load — resumes a previous session, replaying its
+        transcript as session/update notifications."""
+        return self.request("session/load", {
+            "sessionId": session_id, "cwd": cwd,
+            "mcpServers": mcp_servers or []})
+
+    def cancel(self, session_id: str) -> None:
+        self.notify("session/cancel", {"sessionId": session_id})
+
+    def close(self) -> None:
+        if self.proc:
+            with _suppress_all():
+                self.proc.terminate()
+                self.proc.wait(timeout=3)
+            if self.proc.poll() is None:
+                self.proc.kill()
+            self.proc = None
+
+
+class _suppress_all:
+    def __enter__(self): return None
+    def __exit__(self, *a): return True

forge_agent_bridge/adapter.py

@@ -0,0 +1,57 @@
+"""Provider adapter interface (§5.2) — typed errors, no simulated capability."""
+
+from __future__ import annotations
+
+from collections.abc import Iterator
+from typing import Any, Protocol, runtime_checkable
+
+from .contracts import AgentSession, ProviderDescriptor
+
+
+class BridgeError(Exception):
+    """Typed bridge error — code is part of the contract."""
+
+    def __init__(self, code: str, message: str, *, provider: str | None = None):
+        super().__init__(message)
+        self.code, self.message, self.provider = code, message, provider
+
+
+class ProviderUnavailableError(BridgeError):
+    def __init__(self, msg: str, provider: str | None = None):
+        super().__init__("FAB-UNAVAILABLE", msg, provider=provider)
+
+
+class UnsupportedCapabilityError(BridgeError):
+    def __init__(self, capability: str, provider: str | None = None):
+        super().__init__("FAB-UNSUPPORTED",
+                         f"capability '{capability}' not supported", provider=provider)
+
+
+class AuthenticationError(BridgeError):
+    def __init__(self, msg: str, provider: str | None = None):
+        super().__init__("FAB-AUTH", msg, provider=provider)
+
+
+class SessionError(BridgeError):
+    pass
+
+
+@runtime_checkable
+class ProviderAdapter(Protocol):
+    """§5.2 contract — unsupported features raise UnsupportedCapabilityError
+    or report unavailable state; never simulated behavior."""
+
+    def detect(self) -> ProviderDescriptor: ...
+    def get_version(self) -> str | None: ...
+    def get_auth_status(self) -> str: ...
+    def initialize(self) -> None: ...
+    def create_session(self, **kwargs: Any) -> AgentSession: ...
+    def resume_session(self, session_ref: str) -> AgentSession: ...
+    def list_sessions(self) -> list[AgentSession]: ...
+    def send_prompt(self, session_id: str, prompt: str,
+                    attachments: list[dict[str, Any]] | None = None) -> None: ...
+    def stream_events(self, session_id: str) -> Iterator[dict[str, Any]]: ...
+    def respond_to_approval(self, approval_id: str, approved: bool) -> None: ...
+    def cancel(self, session_id: str) -> None: ...
+    def close_session(self, session_id: str) -> None: ...
+    def dispose(self) -> None: ...

forge_agent_bridge/approvals.py

@@ -0,0 +1,113 @@
+"""Approval tokens — bound, expiring, single-use authorizations (§25.4).
+
+Replaces client-supplied ``approved: true`` booleans. The server mints an
+approval request when a mutating op is attempted; the actor resolves it;
+the resolved token's argument digest must match the retried operation
+exactly — argument tampering invalidates it. Tokens are one-time.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import secrets as _secrets
+import threading
+import time
+from typing import Any
+
+from .adapter import BridgeError
+
+TTL_S = 600.0  # 10 min
+
+
+def digest_args(args: dict[str, Any]) -> str:
+    """Stable digest of the operation arguments being approved."""
+    canon = json.dumps(args, sort_keys=True, separators=(",", ":"))
+    return hashlib.sha256(canon.encode()).hexdigest()
+
+
+class ApprovalStore:
+    """Pending and resolved approvals; resolved grants are one-time."""
+
+    def __init__(self) -> None:
+        self._pending: dict[str, dict[str, Any]] = {}
+        self._grants: dict[str, dict[str, Any]] = {}
+        self._lock = threading.Lock()
+
+    def request(self, *, session_id: str, actor: str, resource: str,
+                action: str, args: dict[str, Any], risk: str = "medium",
+                scope: str = "session", turn_id: str = "") -> dict[str, Any]:
+        """Create a pending approval bound to op+args digest."""
+        ap = {
+            "approval_id": f"ap_{_secrets.token_hex(8)}",
+            "session_id": session_id, "turn_id": turn_id,
+            "actor": actor, "resource": resource, "action": action,
+            "args_digest": digest_args(args), "scope": scope, "risk": risk,
+            "requested_at": time.time(), "expires_at": time.time() + TTL_S,
+            "state": "pending",
+        }
+        self._pending[ap["approval_id"]] = ap
+        return dict(ap)
+
+    def resolve(self, approval_id: str, *, approved: bool,
+                actor: str) -> dict[str, Any]:
+        with self._lock:
+            ap = self._pending.pop(approval_id, None)
+            if not ap:
+                raise BridgeError("FAB-NOT-FOUND", "unknown approval_id")
+            if time.time() > ap["expires_at"]:
+                raise BridgeError("FAB-VALIDATION", "approval request expired")
+            if not approved:
+                return {"resolved": True, "granted": False,
+                        "approval_id": approval_id}
+            token = _secrets.token_urlsafe(24)
+            self._grants[token] = {
+                "approval_id": approval_id, "session_id": ap["session_id"],
+                "actor": actor, "requester": ap["actor"],
+                "resource": ap["resource"], "action": ap["action"],
+                "args_digest": ap["args_digest"], "scope": ap["scope"],
+                "risk": ap["risk"], "decided_at": time.time(),
+                "expires_at": time.time() + TTL_S, "consumed": False,
+            }
+            return {"resolved": True, "granted": True,
+                    "approval_id": approval_id, "approval_token": token,
+                    "expires_at": self._grants[token]["expires_at"]}
+
+    def consume(self, token: str, *, session_id: str, resource: str,
+                action: str, args: dict[str, Any],
+                actor: str | None = None) -> dict[str, Any]:
+        """Verify + consume a grant: op must match digest exactly, once.
+
+        Consumption is atomic under the store lock: two simultaneous
+        requests cannot both observe ``consumed == False``.
+        """
+        with self._lock:
+            g = self._grants.get(token)
+            if not g:
+                raise BridgeError("FAB-FORBIDDEN", "invalid approval token")
+            if g["consumed"]:
+                raise BridgeError("FAB-FORBIDDEN",
+                                  "approval token already consumed")
+            if time.time() > g["expires_at"]:
+                raise BridgeError("FAB-FORBIDDEN", "approval token expired")
+            if g["session_id"] != session_id or g["resource"] != resource \
+                    or g["action"] != action:
+                raise BridgeError("FAB-FORBIDDEN",
+                                  "approval token does not cover this operation")
+            if g["args_digest"] != digest_args(args):
+                raise BridgeError("FAB-FORBIDDEN",
+                                  "operation arguments differ from approved")
+            if actor is not None and g["requester"] and \
+                    actor != g["requester"]:
+                raise BridgeError(
+                    "FAB-FORBIDDEN",
+                    "approval was requested by a different actor")
+            g["consumed"] = True
+            return {"consumed": True, "approval_id": g["approval_id"],
+                    "actor": g["actor"]}
+
+    def pending_for(self, session_id: str) -> list[dict[str, Any]]:
+        return [dict(a) for a in self._pending.values()
+                if a["session_id"] == session_id]
+
+
+APPROVALS = ApprovalStore()

forge_agent_bridge/backup.py

@@ -0,0 +1,67 @@
+"""Cycle 28.6 — backup/restore of bridge state.
+
+Backs up: session metadata, event history, context bindings, MCP registry,
+budgets, collab, audit. **Never** backs up secrets: pair.token, pairing
+device tokens, and any *.secret/keyring files are excluded by construction.
+Manifest records what was captured so restore is verifiable.
+"""
+
+from __future__ import annotations
+
+import json
+import tarfile
+import tempfile
+import time
+from pathlib import Path
+from typing import Any
+
+# never exported — credentials must not leave the device (§25.8, §28.6)
+EXCLUDED = {"pair.token", "pairing.json", "secrets.json", "keyring.json"}
+INCLUDED_SUFFIXES = (".json", ".jsonl")
+
+
+def create_backup(state_dir: Path, out: Path | None = None) -> dict[str, Any]:
+    """Tarball of non-secret state under `state_dir` → out (or state_dir/)."""
+    out = out or (state_dir / f"backup-{int(time.time())}.tar.gz")
+    manifest: dict[str, Any] = {"created_at": time.time(),
+                                "files": [], "excluded": []}
+    with tempfile.TemporaryDirectory() as td, \
+            tarfile.open(out, "w:gz") as tar:
+        for f in sorted(state_dir.rglob("*")):
+            if not f.is_file():
+                continue
+            rel = f.relative_to(state_dir)
+            if f.name in EXCLUDED or any(
+                    p.name in EXCLUDED for p in rel.parents):
+                manifest["excluded"].append(str(rel))
+                continue
+            if f.suffix not in INCLUDED_SUFFIXES:
+                manifest["excluded"].append(str(rel))
+                continue
+            tar.add(f, arcname=str(rel))
+            manifest["files"].append(
+                {"path": str(rel), "bytes": f.stat().st_size})
+        mf = Path(td) / "manifest.json"
+        mf.write_text(json.dumps(manifest, indent=1))
+        tar.add(mf, arcname="manifest.json")
+    manifest["out"] = str(out)
+    return manifest
+
+
+def restore_backup(backup: Path, state_dir: Path) -> dict[str, Any]:
+    """Extract a backup into `state_dir`. Refuses secret paths — a backup
+    must never inject credentials (they are re-paired, not restored)."""
+    restored, refused = [], []
+    with tarfile.open(backup) as tar:
+        for m in tar.getmembers():
+            name = Path(m.name).name
+            if m.name.startswith("/") or ".." in Path(m.name).parts:
+                refused.append(m.name)              # traversal guard
+                continue
+            if name in EXCLUDED:
+                refused.append(m.name)              # no secrets restore
+                continue
+            if m.isfile():
+                tar.extract(m, state_dir, filter="data")
+                restored.append(m.name)
+    return {"restored": restored, "refused": refused}

forge_agent_bridge/broker.py

@@ -0,0 +1,103 @@
+"""Permission broker — central authorization decisions (§25.3).
+
+Validates identity, session, product/workspace, operation, tool, policy;
+decides allow / deny / require-approval; records the decision. The broker
+complements — never replaces — the owning service's own authorization.
+"""
+from __future__ import annotations
+
+import time
+from typing import Any
+
+from .adapter import BridgeError
+
+# Operations that always require a bound approval token before execution.
+APPROVAL_REQUIRED: dict[tuple[str, str], str] = {
+    ("files", "upload"): "file-write",
+    ("files", "restore"): "file-write",
+    ("sessions", "spawn"): "process-spawn",
+    ("runners", "register"): "runner-registration",
+}
+# Risk classification per action family.
+RISK = {"file-write": "high", "process-spawn": "high",
+        "runner-registration": "medium", "prompt": "low",
+        "share": "medium", "approve": "medium", "handoff": "high"}
+
+
+def require_scope(actor: dict[str, Any], required: str) -> None:
+    """Enforce route permissions; a conversational device is not admin."""
+    scopes = {str(s) for s in (actor.get("scopes") or [])}
+    if actor.get("kind") == "master" or "admin" in scopes or required in scopes:
+        return
+    grants = {
+        "agent:read": {"agent", "agent:read", "session:read", "provider:read"},
+        "agent:execute": {"agent", "agent:execute", "session:manage"},
+        "session:read": {"agent", "agent:read", "session:read"},
+        "session:manage": {"agent", "agent:execute", "session:manage"},
+        "provider:read": {"agent", "agent:read", "provider:read"},
+        "approval:read": {"agent", "agent:read", "approval:read"},
+        "approval:resolve": {"agent", "agent:execute", "approval:resolve"},
+        "files:read": {"agent", "agent:read", "files:read"},
+    }
+    if not scopes.intersection(grants.get(required, set())):
+        raise BridgeError("FAB-FORBIDDEN", f"scope required: {required}")
+
+
+class Decision(dict):
+    """Authorization decision record — auditable."""
+
+
+class Broker:
+    """Central op authorization; decisions are recorded, never silent."""
+
+    def __init__(self) -> None:
+        self.log: list[dict[str, Any]] = []
+
+    def authorize(self, *, actor: dict[str, Any] | None, op: str,
+                  resource: str, session_id: str = "",
+                  product_id: str = "", workspace_id: str = "",
+                  tool: str = "", args: dict[str, Any] | None = None,
+                  principal: str | None = None,
+                  collab: Any = None) -> dict[str, Any]:
+        """Return {allow, require_approval, risk, reason} — or raise FORBIDDEN.
+
+        Order: identity → operation risk → ownership/observer → approval need.
+        """
+        args = args or {}
+        if actor is None:
+            self._record("deny", op, resource, "", "no-identity")
+            raise BridgeError("FAB-AUTH", "authentication required")
+
+        # identity: session tokens carry scopes; master carries 'admin'
+        scopes = actor.get("scopes") or ["admin"]
+        risk = RISK.get(op.split(":")[-1] if ":" in op else op, "medium")
+
+        # session-scope authorization via collab when a session is bound —
+        # ``principal`` is the caller-resolved actor (session tokens can't
+        # impersonate; master may assert for local dev).
+        if session_id and collab is not None:
+            who = principal or actor.get("actor", "local")
+            if op not in ("read", "comment"):
+                collab.assert_can_act(session_id, who)  # raises
+
+        key = (resource.split(":")[0], op.split(":")[-1])
+        needs = APPROVAL_REQUIRED.get(key)
+        dec = {
+            "allow": True, "require_approval": needs is not None,
+            "approval_kind": needs, "risk": risk,
+            "actor": actor.get("actor", "?"), "op": op,
+            "resource": resource, "session_id": session_id,
+            "product_id": product_id, "workspace_id": workspace_id,
+            "tool": tool, "scopes": scopes,
+        }
+        self._record("allow" if not needs else "require-approval",
+                     op, resource, dec["actor"], dec["approval_kind"] or "-")
+        return Decision(dec)
+
+    def _record(self, verdict: str, op: str, res: str,
+                actor: str, detail: str) -> None:
+        self.log.append({"ts": time.time(), "verdict": verdict, "op": op,
+                         "resource": res, "actor": actor, "detail": detail})
+
+
+BROKER = Broker()

forge_agent_bridge/budgets.py

@@ -0,0 +1,104 @@
+"""Budget ledger (§23.4) — limits per scope/window over real usage.
+
+Records token usage from usage.updated events; checks limits BEFORE a
+prompt is accepted. Provider-reported tokens are real data; when a
+provider reports nothing the entry is flagged estimated.
+"""
+
+from __future__ import annotations
+
+import json
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+from .adapter import BridgeError
+from .contracts import utcnow
+from .local_bridge import state_dir
+
+
+def _day() -> str:
+    return datetime.now(UTC).strftime("%Y-%m-%d")
+
+
+def _month() -> str:
+    return datetime.now(UTC).strftime("%Y-%m")
+
+
+class BudgetLedger:
+    def __init__(self, path: Path | None = None) -> None:
+        self.path = path or (state_dir() / "budget.json")
+
+    def _load(self) -> dict[str, Any]:
+        try:
+            return json.loads(self.path.read_text())
+        except (OSError, json.JSONDecodeError):
+            return {"limits": {}, "usage": {}, "entries": {}}
+
+    def _save(self, data: dict[str, Any]) -> None:
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        self.path.write_text(json.dumps(data, indent=1))
+        self.path.chmod(0o600)
+
+    # -- limits --------------------------------------------------------------
+
+    def set_limit(self, scope: str, key: str, window: str,
+                  tokens: int) -> dict[str, Any]:
+        """scope: user|workspace|product|provider|session · window: day|month."""
+        if window not in ("day", "month"):
+            raise BridgeError("FAB-VALIDATION", "window must be day|month")
+        data = self._load()
+        data["limits"][f"{scope}:{key}:{window}"] = tokens
+        self._save(data)
+        return {"scope": scope, "key": key, "window": window, "tokens": tokens}
+
+    def limits(self) -> dict[str, Any]:
+        return dict(self._load()["limits"])
+
+    # -- usage ---------------------------------------------------------------
+
+    def record(self, scope_map: dict[str, str], tokens_in: int,
+               tokens_out: int, *, estimated: bool = False,
+               idempotency_key: str | None = None) -> bool:
+        """scope_map: {user:.., workspace:.., product:.., provider:.., session:..}."""
+        data = self._load()
+        entries = data.setdefault("entries", {})
+        if idempotency_key and idempotency_key in entries:
+            return False
+        for scope, key in scope_map.items():
+            if not key:
+                continue
+            for window, wkey in (("day", _day()), ("month", _month())):
+                k = f"{scope}:{key}:{window}:{wkey}"
+                u = data["usage"].setdefault(
+                    k, {"in": 0, "out": 0, "estimated": estimated, "n": 0})
+                u["in"] += tokens_in
+                u["out"] += tokens_out
+                u["n"] += 1
+                u["estimated"] = u["estimated"] or estimated
+                u["updated_at"] = utcnow()
+        if idempotency_key:
+            entries[idempotency_key] = {"in": tokens_in, "out": tokens_out,
+                                        "estimated": estimated, "at": utcnow()}
+        self._save(data)
+        return True
+
+    def check(self, scope_map: dict[str, str]) -> None:
+        """Raise FAB-BUDGET when any configured limit is already exceeded."""
+        data = self._load()
+        for scope, key in scope_map.items():
+            if not key:
+                continue
+            for window, wkey in (("day", _day()), ("month", _month())):
+                lim = data["limits"].get(f"{scope}:{key}:{window}")
+                if lim is None:
+                    continue
+                u = data["usage"].get(f"{scope}:{key}:{window}:{wkey}")
+                used = (u["in"] + u["out"]) if u else 0
+                if used >= lim:
+                    raise BridgeError(
+                        "FAB-BUDGET",
+                        f"{scope}:{key} {window} budget {lim} tokens exhausted")
+
+    def summary(self) -> dict[str, Any]:
+        return self._load()