aigenora 0.0.1__py3-none-any.whl

aigenora/__init__.py

@@ -0,0 +1,2 @@
+__version__ = "0.1.0"
+

aigenora/__main__.py

@@ -0,0 +1,6 @@
+from .cli import main
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
+

aigenora/agent/__init__.py

@@ -0,0 +1 @@
+

aigenora/agent/_daemon.py

@@ -0,0 +1,96 @@
+from __future__ import annotations
+
+import json
+import os
+import sys
+import time
+from pathlib import Path
+from typing import Any
+
+from aigenora.proto.sdk import EventBus
+
+
+# Cold start of the business subprocess (iroh node + spec load + invitation publish) has been
+# observed at ~18-30s on Windows. 15s caused false "timeout waiting for invite_created" while
+# the subprocess was still alive. Override with AIGENORA_DAEMON_STARTUP_TIMEOUT env if needed.
+DEFAULT_STARTUP_WAIT_SECONDS = 30.0
+
+
+def startup_wait_seconds() -> float:
+    raw = os.environ.get("AIGENORA_DAEMON_STARTUP_TIMEOUT")
+    if raw is None or raw == "":
+        return DEFAULT_STARTUP_WAIT_SECONDS
+    try:
+        return max(0.0, float(raw))
+    except ValueError:
+        return DEFAULT_STARTUP_WAIT_SECONDS
+
+
+def wait_for_event(
+    state_dir: str | Path,
+    event_type: str,
+    *,
+    timeout_seconds: float | None = None,
+    required_data_keys: tuple[str, ...] = (),
+) -> dict[str, Any] | None:
+    """Poll state_dir/events.jsonl until a matching startup event appears."""
+    timeout = startup_wait_seconds() if timeout_seconds is None else max(0.0, timeout_seconds)
+    deadline = time.monotonic() + timeout
+    bus = EventBus(state_dir)
+    while True:
+        for event in bus.read_events():
+            if event.get("type") != event_type:
+                continue
+            data = event.get("data") or {}
+            if all(data.get(k) for k in required_data_keys):
+                return event
+        if time.monotonic() >= deadline:
+            return None
+        time.sleep(0.1)
+
+
+def write_session_meta(state_dir: str | Path, meta: dict[str, Any]) -> None:
+    Path(state_dir, "session.json").write_text(json.dumps(meta, ensure_ascii=False), encoding="utf-8")
+
+
+def update_session_meta(state_dir: str | Path | None, **updates: Any) -> None:
+    """Read-modify-write session.json.
+
+    The daemon parent process (host._run_daemon / join._run_daemon) writes the initial
+    session.json and returns right after startup, so it never observes how the business
+    subprocess ends. The business subprocess therefore calls this on its terminal path to
+    record the final status (closed/aborted), ended_at, game_over and end_reason — otherwise
+    console/list keeps showing a stale "running" session for a process that already exited.
+    Best-effort: a missing/unreadable session.json or a None state_dir is a silent no-op.
+    """
+    if not state_dir:
+        return
+    path = Path(state_dir, "session.json")
+    if not path.exists():
+        return
+    try:
+        meta = json.loads(path.read_text(encoding="utf-8"))
+    except Exception as e:
+        # session.json 损坏/不可读：原为静默 return，导致终态丢失且无从排查。改为记录 warning。
+        print(f"[aigenora] warning: failed to read session.json for update: {e}", file=sys.stderr)
+        return
+    meta.update(updates)
+    path.write_text(json.dumps(meta, ensure_ascii=False), encoding="utf-8")
+
+
+def read_log_excerpt(state_dir: str | Path, name: str = "daemon.err.log", limit: int = 500) -> str:
+    path = Path(state_dir) / name
+    if not path.exists() or path.stat().st_size <= 0:
+        return ""
+    with path.open("rb") as f:
+        size = path.stat().st_size
+        if size > limit:
+            f.seek(size - limit)
+        return f.read().decode("utf-8", errors="replace")
+
+
+def terminate_process(proc: Any) -> None:
+    try:
+        proc.terminate()
+    except Exception:
+        pass

aigenora/agent/_web_mode.py

@@ -0,0 +1,52 @@
+"""Web UI auto-launch mode resolution.
+
+Three modes:
+- auto    : start the relay subprocess and open the browser automatically (default behavior)
+- headless: start the relay subprocess without opening a browser (print the URL for the user to open manually)
+- off     : do not start the relay subprocess (pure CLI)
+
+Priority (high -> low):
+1. CLI argument: --web {auto,headless,off} (mutually-exclusive aliases of --no-web / --no-browser)
+2. Environment variable: AIGENORA_WEB
+3. Default value: auto
+"""
+from __future__ import annotations
+
+import os
+from typing import Literal
+
+WebMode = Literal["auto", "headless", "off"]
+VALID_MODES: tuple[WebMode, ...] = ("auto", "headless", "off")
+DEFAULT_MODE: WebMode = "auto"
+ENV_VAR = "AIGENORA_WEB"
+
+
+def normalize(value: str | None) -> WebMode | None:
+    """Normalize to a valid WebMode; return None if invalid or empty."""
+    if value is None:
+        return None
+    v = value.strip().lower()
+    if v in VALID_MODES:
+        return v  # type: ignore[return-value]
+    return None
+
+
+def resolve_web_mode(args) -> WebMode:
+    """Resolve the final web mode by CLI > env > default.
+
+    args is expected to come from argparse and may contain the following optional attributes:
+      - web      : explicit --web value (auto/headless/off)
+      - no_web   : --no-web flag
+      - no_browser: --no-browser flag
+    """
+    explicit = normalize(getattr(args, "web", None))
+    if explicit is not None:
+        return explicit
+    if getattr(args, "no_web", False):
+        return "off"
+    if getattr(args, "no_browser", False):
+        return "headless"
+    env = normalize(os.environ.get(ENV_VAR))
+    if env is not None:
+        return env
+    return DEFAULT_MODE

aigenora/agent/bootstrap.py

@@ -0,0 +1,151 @@
+"""aigenora bootstrap: one-shot environment probe for user agents.
+
+Design principles (must be followed):
+- Diagnosis only, never auto-fix. Repair suggestions are returned as strings; the
+  caller (human/agent) decides whether to act on them.
+- Output is both machine-parseable (--json) and human-readable.
+- No network dependency, no community-server dependency.
+- Fields are stable; new fields must be backward compatible; do not rename published fields.
+"""
+from __future__ import annotations
+
+import argparse
+import importlib.util
+import json
+import os
+import platform as pyplatform
+import shutil
+import sys
+import sysconfig
+from pathlib import Path
+
+from aigenora import __version__ as PKG_VERSION
+
+
+REQUIRED_DEPS = ("cryptography", "httpx", "iroh")
+
+
+def _platform_id() -> str:
+    sysname = sys.platform
+    if sysname.startswith("win"):
+        return "windows"
+    if sysname == "darwin":
+        return "macos"
+    return "linux"
+
+
+def _check_skill() -> tuple[str | None, str | None, str | None]:
+    """Returns (skill_md_path, skill_version, error)."""
+    try:
+        from importlib import resources
+        from aigenora.agent.skill import _extract_skill_version
+
+        res = resources.files("aigenora.skill").joinpath("SKILL.md")
+        text = res.read_text(encoding="utf-8-sig")
+        ver = _extract_skill_version(text)
+        return (str(res), ver, None if ver else "missing 'version:' frontmatter")
+    except Exception as e:
+        return (None, None, str(e))
+
+
+def _check_deps() -> list[str]:
+    return [m for m in REQUIRED_DEPS if importlib.util.find_spec(m) is None]
+
+
+def _data_dir_default() -> str:
+    raw = os.environ.get("P2P_DATA_DIR") or os.environ.get("AGENT_DIR")
+    if raw:
+        return str(Path(raw).expanduser())
+    return str(Path.cwd() / ".aigenora")
+
+
+def collect() -> dict:
+    """Collect environment probe data."""
+    scripts_dir = sysconfig.get_paths().get("scripts", "")
+    cmd_path = shutil.which("aigenora")
+    in_path = cmd_path is not None
+
+    skill_path, skill_ver, skill_err = _check_skill()
+    missing_deps = _check_deps()
+
+    issues: list[dict] = []
+
+    if missing_deps:
+        issues.append({
+            "code": "DEPS_MISSING",
+            "message": f"missing python packages: {', '.join(missing_deps)}",
+            "fix": "ask user to run: pip install aigenora-client",
+        })
+
+    if skill_err and not skill_path:
+        issues.append({
+            "code": "SKILL_NOT_PACKAGED",
+            "message": f"packaged SKILL.md unavailable: {skill_err}",
+            "fix": "reinstall aigenora-client; the package data may be corrupt",
+        })
+
+    if not in_path:
+        issues.append({
+            "code": "CMD_NOT_IN_PATH",
+            "message": "the `aigenora` console script is not in PATH",
+            "fix": f"use `{sys.executable} -m aigenora ...` (recommended); "
+                   f"or add to PATH: {scripts_dir}",
+        })
+
+    data = {
+        "ok": all(i["code"] not in ("DEPS_MISSING", "SKILL_NOT_PACKAGED") for i in issues),
+        "version": PKG_VERSION,
+        "python": sys.executable,
+        "python_version": pyplatform.python_version(),
+        "platform": _platform_id(),
+        "recommended_entrypoint": f"{sys.executable} -m aigenora",
+        "console_script_in_path": in_path,
+        "console_script_path": cmd_path,
+        "console_script_dir": scripts_dir,
+        "skill_md_path": skill_path,
+        "skill_version": skill_ver,
+        "data_dir_default": _data_dir_default(),
+        "issues": issues,
+    }
+    return data
+
+
+def _print_human(data: dict) -> None:
+    print(f"ok: {data['ok']}")
+    print(f"version: {data['version']}")
+    print(f"python: {data['python']} ({data['python_version']})")
+    print(f"platform: {data['platform']}")
+    print(f"recommended entrypoint: {data['recommended_entrypoint']}")
+    if data["console_script_in_path"]:
+        print(f"aigenora cmd: {data['console_script_path']}")
+    else:
+        print(f"aigenora cmd: NOT IN PATH")
+        print(f"  scripts dir: {data['console_script_dir']}")
+    print(f"skill md: {data['skill_md_path']} (version={data['skill_version']})")
+    print(f"data dir default: {data['data_dir_default']}")
+    if data["issues"]:
+        print("issues:")
+        for i in data["issues"]:
+            print(f"  [{i['code']}] {i['message']}")
+            print(f"    fix: {i['fix']}")
+    else:
+        print("issues: (none)")
+
+
+def run(args) -> int:
+    data = collect()
+    if getattr(args, "json_output", False):
+        print(json.dumps(data, ensure_ascii=False, indent=2))
+    else:
+        _print_human(data)
+    return 0 if data["ok"] else 1
+
+
+def build_subparser(parent_sub) -> argparse.ArgumentParser:
+    bs = parent_sub.add_parser(
+        "bootstrap",
+        help="One-shot environment probe: returns python/package/skill/PATH status (agent-friendly)",
+    )
+    bs.add_argument("--json", action="store_true", dest="json_output",
+                    help="Output machine-parseable JSON")
+    return bs

aigenora/agent/browse.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+import re
+from urllib.parse import urlencode
+
+from aigenora.engine.config import get_server
+from aigenora.engine.keys import load_keys
+from aigenora.engine.rest import RestClient
+
+_PROTOCOL_ID_RE = re.compile(r"[0-9a-f]{64}")
+_TAG_RE = re.compile(r"[A-Za-z0-9_.:-]+")
+
+
+def _pricing_text(item) -> str:
+    if not isinstance(item, dict):
+        return ""
+    options = item.get("options")
+    if isinstance(options, dict):
+        pricing = options.get("pricing")
+    else:
+        pricing = item.get("pricing")
+    if not isinstance(pricing, dict):
+        return ""
+    model = pricing.get("model", "")
+    if model == "free":
+        return "free"
+    amount = pricing.get("amount", "")
+    currency = pricing.get("currency", "")
+    return f"{amount} {currency}".strip() or model
+
+
+def _validate_tags_filter(tags_arg: str | None) -> list[str]:
+    if tags_arg is None:
+        return []
+    if not tags_arg:
+        raise ValueError("--tags cannot be empty")
+    tags: list[str] = []
+    for raw in tags_arg.split(","):
+        tag = raw.strip()
+        if not tag:
+            continue
+        if len(tag) > 64:
+            raise ValueError("--tags entries must be at most 64 characters")
+        if not _TAG_RE.fullmatch(tag):
+            raise ValueError("--tags entries may contain only A-Za-z0-9_.:-")
+        if tag not in tags:
+            tags.append(tag)
+        if len(tags) > 10:
+            raise ValueError("--tags accepts at most 10 tags")
+    if not tags:
+        raise ValueError("--tags cannot be empty")
+    return tags
+
+
+def _validate_filters(args) -> None:
+    if getattr(args, "post_id", None):
+        return
+    _validate_tags_filter(getattr(args, "tags", None))
+    protocol_id = getattr(args, "protocol_id", None)
+    if protocol_id is not None:
+        if not protocol_id:
+            raise ValueError("--protocol-id cannot be empty")
+        if not _PROTOCOL_ID_RE.fullmatch(protocol_id):
+            raise ValueError("--protocol-id must be a 64-char lowercase protocol hash")
+
+
+def run(args) -> int:
+    try:
+        _validate_filters(args)
+    except ValueError as exc:
+        print(f"error: {exc}")
+        return 2
+
+    kp = load_keys(args.data_dir)
+    server = get_server(args.server)
+    client = RestClient(server, kp)
+    if args.post_id:
+        data = client.json("GET", f"/api/v1/invitations/{args.post_id}", expected={200})
+        items = [data]
+        total = 1
+    else:
+        query = {k: v for k, v in {
+            "tags": args.tags,
+            "protocol_id": args.protocol_id,
+            "type": args.type,
+            "limit": args.limit,
+        }.items() if v is not None}
+        path = "/api/v1/invitations"
+        if query:
+            path += "?" + urlencode(query)
+        data = client.json("GET", path, expected={200})
+        items = data.get("results", data if isinstance(data, list) else [])
+        total = data.get("total", len(items)) if isinstance(data, dict) else len(items)
+    if args.oneline:
+        for item in items:
+            tags = item.get("tags", [])
+            if isinstance(tags, list):
+                tags_text = ",".join(str(t) for t in tags)
+            else:
+                tags_text = str(tags or "")
+            print("\t".join([
+                str(item.get("post_id", "")),
+                str(item.get("protocol_id", "") or ""),
+                str(item.get("type", "") or "chat"),
+                str(item.get("message", "") or ""),
+                tags_text,
+                str(item.get("public_key", "") or ""),
+                "true" if item.get("registered", False) else "false",
+                str(item.get("nickname", "") or ""),
+                str(item.get("agent_id", "") or ""),
+                _pricing_text(item),
+            ]))
+        return 0
+    print(f"Total: {total}")
+    for item in items:
+        print(f"{item.get('post_id')} [{item.get('type', 'chat')}] {item.get('message', '')}")
+        print(f"  protocol_id: {item.get('protocol_id', '')}")
+        print(f"  public_key: {item.get('public_key', '')}")
+    return 0
+

aigenora/agent/cancel.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from aigenora.engine.config import get_server
+from aigenora.engine.keys import load_keys
+from aigenora.engine.rest import RestClient
+
+
+def run(args) -> int:
+    kp = load_keys(args.data_dir)
+    client = RestClient(get_server(args.server), kp)
+    client.json("DELETE", f"/api/v1/invitations/{args.post_id}", expected={204})
+    print("[OK] invitation cancelled")
+    return 0
+