walla-cli 0.1.0__py3-none-any.whl

walla/account/session_store.py

@@ -0,0 +1,36 @@
+"""Session persistence (mode 0600). Never stores the password."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from walla.core.path import session_path
+from walla.models.account import SessionData
+
+__all__ = (
+    "clear_session",
+    "load_session",
+    "save_session",
+)
+
+
+def load_session(path: Path | None = None) -> SessionData | None:
+    p = path or session_path()
+    if not p.is_file():
+        return None
+    return SessionData.model_validate_json(p.read_text(encoding="utf-8"))
+
+
+def save_session(session: SessionData, path: Path | None = None) -> Path:
+    p = path or session_path()
+    p.parent.mkdir(parents=True, exist_ok=True)
+    p.write_text(session.model_dump_json(indent=2), encoding="utf-8")
+    os.chmod(p, 0o600)
+    return p
+
+
+def clear_session(path: Path | None = None) -> None:
+    p = path or session_path()
+    if p.is_file():
+        p.unlink()

walla/cli/__init__.py

@@ -0,0 +1,7 @@
+"""CLI package."""
+
+from __future__ import annotations
+
+from walla.cli.main import app, cli
+
+__all__ = ("app", "cli")

walla/cli/banner.py

@@ -0,0 +1,33 @@
+"""Terminal brand mark for ``walla --help``."""
+
+from __future__ import annotations
+
+from rich.text import Text
+
+from walla.cli.console import console
+
+__all__ = ("print_banner",)
+
+_BANNER_ROWS = (
+    r"██╗    ██╗  █████╗  ██╗      ██╗       █████╗            ██████╗ ██╗      ██╗",
+    r"██║    ██║ ██╔══██╗ ██║      ██║      ██╔══██╗          ██╔════╝ ██║      ██║",
+    r"██║ █╗ ██║ ███████║ ██║      ██║      ███████║  █████╗  ██║      ██║      ██║",
+    r"██║███╗██║ ██╔══██║ ██║      ██║      ██╔══██║  ╚════╝  ██║      ██║      ██║",
+    r"╚███╔███╔╝ ██║  ██║ ███████╗ ███████╗ ██║  ██║          ╚██████╗ ███████╗ ██║",
+    r" ╚══╝╚══╝  ╚═╝  ╚═╝ ╚══════╝ ╚══════╝ ╚═╝  ╚═╝           ╚═════╝ ╚══════╝ ╚═╝",
+)
+
+_STYLE = "bold #A3E635"
+_TAG = "italic #D9F99D"
+_CREDIT = "#84CC16"
+
+
+def print_banner() -> None:
+    if not console.is_terminal:
+        return
+    console.print()
+    for row in _BANNER_ROWS:
+        console.print(Text(row, style=_STYLE))
+    console.print(Text("  look · offer · talk", style=_TAG))
+    console.print(Text("  Dr. Berend Gort  ·  www.berendgort.dev", style=_CREDIT))
+    console.print()

walla/cli/catch.py

@@ -0,0 +1,43 @@
+"""CLI error catching and JSON envelope printing."""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Callable
+from typing import Any, TypeVar
+
+import typer
+
+from walla.cli.console import console
+from walla.core.envelope import error_payload, success_payload
+
+__all__ = (
+    "emit",
+    "run_cmd",
+)
+
+F = TypeVar("F", bound=Callable[..., Any])
+
+
+def emit(payload: dict[str, Any], *, as_json: bool) -> None:
+    if as_json:
+        console.print_json(json.dumps(payload, ensure_ascii=False))
+    else:
+        if payload.get("ok"):
+            data = payload.get("data")
+            console.print(data)
+        else:
+            console.print(f"[red]{payload.get('error')}[/red]")
+            raise typer.Exit(code=1)
+
+
+def run_cmd(fn: Callable[[], Any], *, as_json: bool) -> None:
+    try:
+        data = fn()
+        emit(success_payload(data), as_json=as_json)
+    except Exception as exc:  # noqa: BLE001
+        emit(error_payload(exc), as_json=True if as_json else as_json)
+        if as_json:
+            raise typer.Exit(code=1) from exc
+        console.print(f"[red]{exc}[/red]")
+        raise typer.Exit(code=1) from exc

walla/cli/cmd_account.py

@@ -0,0 +1,162 @@
+"""Account commands: login, inbox, say, offer, fav."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import typer
+
+from walla.account.actions import (
+    add_favorite,
+    list_favorites,
+    make_offer,
+    quote_offer,
+    remove_favorite,
+)
+from walla.account.inbox import list_conversations, list_messages, send_message
+from walla.account.login import login_cookie_text, login_cookies, whoami
+from walla.account.prompt import interactive_login, session_summary
+from walla.account.session_store import clear_session, load_session
+from walla.cli.catch import run_cmd
+from walla.core.exceptions import WallaAuthError
+from walla.search.api import get_item
+
+__all__ = ("register",)
+
+
+def register(app: typer.Typer) -> None:
+    @app.command("login")
+    def login_cmd(
+        cookies: Path | None = typer.Option(None, "--cookies", help="cookies.txt / JSON export"),
+        cookie: str | None = typer.Option(None, "--cookie", help="Raw session cookie value"),
+        password: bool = typer.Option(
+            False, "--password", help="Optional email/password prompt (often fails on MFA)"
+        ),
+        json: bool = typer.Option(False, "--json"),
+    ) -> None:
+        """Log in by pasting a browser session cookie (no .env)."""
+
+        def _run() -> dict[str, Any]:
+            if cookies is not None:
+                sess = login_cookies(cookies)
+            elif cookie:
+                sess = login_cookie_text(cookie)
+            elif json and not password:
+                raise WallaAuthError(
+                    "Non-interactive login needs --cookie '<value>' or --cookies <file>. "
+                    "Or run without --json to paste interactively."
+                )
+            else:
+                sess = interactive_login(password=password)
+            return session_summary(sess)
+
+        run_cmd(_run, as_json=json)
+
+    @app.command("logout")
+    def logout_cmd(json: bool = typer.Option(False, "--json")) -> None:
+        def _run() -> dict[str, Any]:
+            clear_session()
+            return {"authenticated": False}
+
+        run_cmd(_run, as_json=json)
+
+    @app.command("whoami")
+    def whoami_cmd(json: bool = typer.Option(False, "--json")) -> None:
+        run_cmd(lambda: whoami(), as_json=json)
+
+    @app.command("inbox")
+    def inbox_cmd(json: bool = typer.Option(False, "--json")) -> None:
+        def _run() -> dict[str, Any]:
+            rows = list_conversations()
+            return {"conversations": [c.model_dump(mode="json") for c in rows]}
+
+        run_cmd(_run, as_json=json)
+
+    @app.command("thread")
+    def thread_cmd(
+        conversation_id: str = typer.Argument(...),
+        json: bool = typer.Option(False, "--json"),
+    ) -> None:
+        def _run() -> dict[str, Any]:
+            msgs = list_messages(conversation_id)
+            return {
+                "conversation_id": conversation_id,
+                "messages": [m.model_dump(mode="json") for m in msgs],
+            }
+
+        run_cmd(_run, as_json=json)
+
+    @app.command("say")
+    def say_cmd(
+        conversation_id: str = typer.Argument(...),
+        text: str = typer.Argument(...),
+        yes: bool = typer.Option(False, "--yes"),
+        json: bool = typer.Option(False, "--json"),
+    ) -> None:
+        def _run() -> dict[str, Any]:
+            return send_message(conversation_id, text, confirm=yes)
+
+        run_cmd(_run, as_json=json)
+
+    @app.command("offer")
+    def offer_cmd(
+        item_id: str = typer.Argument(...),
+        eur: float = typer.Option(..., "--eur"),
+        yes: bool = typer.Option(False, "--yes"),
+        json: bool = typer.Option(False, "--json"),
+    ) -> None:
+        def _run() -> dict[str, Any]:
+            if not yes:
+                item = get_item(item_id)
+                quote = quote_offer(item, eur)
+                return {
+                    "needs_confirm": True,
+                    "title": item.title,
+                    "url": item.url,
+                    "quote": quote.model_dump(mode="json"),
+                    "hint": "Re-run with --yes to send",
+                }
+            return make_offer(item_id, eur, confirm=True)
+
+        run_cmd(_run, as_json=json)
+
+    fav_app = typer.Typer(help="Favorites")
+    app.add_typer(fav_app, name="fav")
+
+    @fav_app.command("list")
+    def fav_list(json: bool = typer.Option(False, "--json")) -> None:
+        def _run() -> dict[str, Any]:
+            return {"favorites": list_favorites()}
+
+        run_cmd(_run, as_json=json)
+
+    @fav_app.command("add")
+    def fav_add(
+        item_id: str = typer.Argument(...),
+        json: bool = typer.Option(False, "--json"),
+    ) -> None:
+        run_cmd(lambda: add_favorite(item_id), as_json=json)
+
+    @fav_app.command("rm")
+    def fav_rm(
+        item_id: str = typer.Argument(...),
+        json: bool = typer.Option(False, "--json"),
+    ) -> None:
+        run_cmd(lambda: remove_favorite(item_id), as_json=json)
+
+    @app.command("session")
+    def session_cmd(json: bool = typer.Option(False, "--json")) -> None:
+        def _run() -> dict[str, Any]:
+            sess = load_session()
+            if not sess:
+                return {"authenticated": False}
+            return {
+                "authenticated": True,
+                "has_access_token": bool(sess.access_token),
+                "has_cookie": bool(sess.session_cookie),
+                "user_id": sess.user_id,
+                "micro_name": sess.micro_name,
+            }
+
+        run_cmd(_run, as_json=json)

walla/cli/cmd_look.py

@@ -0,0 +1,143 @@
+"""Look commands: search, item, categories, watch."""
+
+from __future__ import annotations
+
+import uuid
+from typing import Any
+
+import typer
+
+from walla.cli.catch import run_cmd
+from walla.hunter.profile_store import load_profile
+from walla.hunter.verdict import score_listing
+from walla.hunter.watches import (
+    Watch,
+    diff_new_ids,
+    load_watches,
+    merge_seen,
+    save_watches,
+)
+from walla.search.api import get_categories, get_item, search_listings
+
+__all__ = ("register",)
+
+
+def register(app: typer.Typer) -> None:
+    @app.command("search")
+    def search(
+        keywords: str = typer.Argument(...),
+        max_results: int = typer.Option(40, "--max"),
+        min_price: float | None = typer.Option(None, "--min"),
+        max_price: float | None = typer.Option(None, "--max-price"),
+        category_id: int | None = typer.Option(None, "--category"),
+        order_by: str = typer.Option("most_relevance", "--order"),
+        json: bool = typer.Option(False, "--json"),
+    ) -> None:
+        def _run() -> dict[str, Any]:
+            profile = load_profile()
+            if not profile.ready:
+                return {
+                    "ready": False,
+                    "intake": {"prompt_to_user": profile.intake_prompt()},
+                }
+            result = search_listings(
+                keywords,
+                latitude=float(profile.lat or 0),
+                longitude=float(profile.lon or 0),
+                max_results=max_results,
+                min_price=min_price,
+                max_price=max_price or profile.budget,
+                category_id=category_id,
+                order_by=order_by,
+            )
+            rows = []
+            for listing in result.listings:
+                listing.verdict = score_listing(listing, profile)
+                rows.append(listing.model_dump(mode="json"))
+            return {
+                "count": len(rows),
+                "next_page": result.next_page,
+                "listings": rows,
+            }
+
+        run_cmd(_run, as_json=json)
+
+    @app.command("item")
+    def item_cmd(
+        item_id: str = typer.Argument(...),
+        json: bool = typer.Option(False, "--json"),
+    ) -> None:
+        def _run() -> dict[str, Any]:
+            listing = get_item(item_id)
+            profile = load_profile()
+            listing.verdict = score_listing(listing, profile)
+            return listing.model_dump(mode="json")
+
+        run_cmd(_run, as_json=json)
+
+    @app.command("categories")
+    def categories_cmd(json: bool = typer.Option(False, "--json")) -> None:
+        def _run() -> dict[str, Any]:
+            cats = get_categories()
+            return {"categories": [c.model_dump(mode="json") for c in cats]}
+
+        run_cmd(_run, as_json=json)
+
+    watch_app = typer.Typer(help="Local saved searches")
+    app.add_typer(watch_app, name="watch")
+
+    @watch_app.command("add")
+    def watch_add(
+        keywords: str = typer.Argument(...),
+        max_price: float | None = typer.Option(None, "--max-price"),
+        json: bool = typer.Option(False, "--json"),
+    ) -> None:
+        def _run() -> dict[str, Any]:
+            store = load_watches()
+            w = Watch(id=str(uuid.uuid4())[:8], keywords=keywords, max_price=max_price)
+            store.watches.append(w)
+            save_watches(store)
+            return w.model_dump(mode="json")
+
+        run_cmd(_run, as_json=json)
+
+    @watch_app.command("list")
+    def watch_list(json: bool = typer.Option(False, "--json")) -> None:
+        def _run() -> dict[str, Any]:
+            store = load_watches()
+            return {"watches": [w.model_dump(mode="json") for w in store.watches]}
+
+        run_cmd(_run, as_json=json)
+
+    @watch_app.command("check")
+    def watch_check(
+        watch_id: str = typer.Argument(...),
+        json: bool = typer.Option(False, "--json"),
+    ) -> None:
+        def _run() -> dict[str, Any]:
+            store = load_watches()
+            watch = next((w for w in store.watches if w.id == watch_id), None)
+            if watch is None:
+                raise ValueError(f"unknown watch {watch_id}")
+            profile = load_profile()
+            if not profile.ready:
+                raise ValueError("profile not ready; run walla setup")
+            result = search_listings(
+                watch.keywords,
+                latitude=float(profile.lat or 0),
+                longitude=float(profile.lon or 0),
+                max_results=40,
+                max_price=watch.max_price,
+            )
+            found = [L.id for L in result.listings]
+            new_ids = diff_new_ids(watch.seen_ids, found)
+            store.watches = [
+                merge_seen(w, found) if w.id == watch_id else w for w in store.watches
+            ]
+            save_watches(store)
+            new_listings = [
+                L.model_dump(mode="json") for L in result.listings if L.id in set(new_ids)
+            ]
+            return {"watch_id": watch_id, "new_ids": new_ids, "listings": new_listings}
+
+        run_cmd(_run, as_json=json)

walla/cli/cmd_ops.py

@@ -0,0 +1,100 @@
+"""Ops commands: doctor, instruct, setup, profile."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import typer
+
+from walla import __version__
+from walla.account.session_store import load_session
+from walla.cli.catch import run_cmd
+from walla.core.instruct import instruct_recipe
+from walla.hunter.profile_store import load_profile, parse_intake, save_profile
+
+__all__ = ("register",)
+
+
+def register(app: typer.Typer) -> None:
+    @app.command("instruct")
+    def instruct(json: bool = typer.Option(False, "--json")) -> None:
+        """Agent recipe."""
+        run_cmd(instruct_recipe, as_json=json)
+
+    @app.command("doctor")
+    def doctor(json: bool = typer.Option(False, "--json")) -> None:
+        """Network + session (never prints secrets)."""
+
+        def _run() -> dict[str, Any]:
+            sess = load_session()
+            profile = load_profile()
+            reachable = False
+            try:
+                from walla.http.client import HttpClient
+
+                HttpClient().get("/api/v3/categories", use_cache=False)
+                reachable = True
+            except Exception:  # noqa: BLE001
+                reachable = False
+            has_session = bool(sess and (sess.access_token or sess.session_cookie))
+            return {
+                "version": __version__,
+                "network": {"reachable": reachable},
+                "auth": {
+                    "session": has_session,
+                    "how": "walla login  (paste browser session cookie)",
+                },
+                "profile": {"ready": profile.ready, "label": profile.label},
+            }
+
+        run_cmd(_run, as_json=json)
+
+    @app.command("setup")
+    def setup(
+        lat: float | None = typer.Option(None),
+        lon: float | None = typer.Option(None),
+        km: float = typer.Option(30.0),
+        pickup_km: float = typer.Option(30.0, "--pickup-km"),
+        label: str | None = typer.Option(None),
+        budget: float | None = typer.Option(None),
+        intake: str | None = typer.Option(None, "--intake"),
+        json: bool = typer.Option(False, "--json"),
+    ) -> None:
+        """Save home point + radius."""
+
+        def _run() -> dict[str, Any]:
+            if intake:
+                profile = parse_intake(intake)
+            else:
+                profile = load_profile()
+                if lat is not None:
+                    profile.lat = lat
+                if lon is not None:
+                    profile.lon = lon
+                profile.km = km
+                profile.pickup_km = pickup_km
+                if label is not None:
+                    profile.label = label
+                if budget is not None:
+                    profile.budget = budget
+            if not profile.ready:
+                return {
+                    "ready": False,
+                    "intake": {"prompt_to_user": profile.intake_prompt()},
+                }
+            save_profile(profile)
+            return {"ready": True, "profile": profile.model_dump(mode="json")}
+
+        run_cmd(_run, as_json=json)
+
+    @app.command("profile")
+    def profile_cmd(json: bool = typer.Option(False, "--json")) -> None:
+        def _run() -> dict[str, Any]:
+            p = load_profile()
+            return {
+                "ready": p.ready,
+                "profile": p.model_dump(mode="json"),
+                "intake": None if p.ready else {"prompt_to_user": p.intake_prompt()},
+            }
+
+        run_cmd(_run, as_json=json)

walla/cli/console.py

@@ -0,0 +1,9 @@
+"""Rich console for TTY output."""
+
+from __future__ import annotations
+
+from rich.console import Console
+
+__all__ = ("console",)
+
+console = Console()

walla/cli/main.py

@@ -0,0 +1,44 @@
+"""Typer CLI -- agent-friendly Wallapop client."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import typer
+from typer.core import TyperGroup
+
+from walla.cli import cmd_account, cmd_look, cmd_ops
+from walla.cli.banner import print_banner
+
+__all__ = ("app", "cli")
+
+
+class _WallaGroup(TyperGroup):
+    def format_help(self, ctx: Any, formatter: Any) -> None:
+        print_banner()
+        super().format_help(ctx, formatter)
+
+
+app = typer.Typer(
+    name="walla",
+    cls=_WallaGroup,
+    help=(
+        "Wallapop.es look · offer · talk for humans and agents. "
+        "Happy path: setup -> search -> login -> inbox / offer. "
+        "Run `walla instruct --json` for the recipe."
+    ),
+    no_args_is_help=True,
+    add_completion=False,
+)
+
+cmd_ops.register(app)
+cmd_look.register(app)
+cmd_account.register(app)
+
+
+def cli() -> None:
+    app()
+
+
+if __name__ == "__main__":
+    cli()

walla/core/__init__.py

@@ -0,0 +1,12 @@
+"""Core package facade."""
+
+from __future__ import annotations
+
+from walla.core.envelope import error_payload, success_payload
+from walla.core.exceptions import WallaError
+
+__all__ = (
+    "WallaError",
+    "error_payload",
+    "success_payload",
+)

walla/core/envelope.py

@@ -0,0 +1,46 @@
+"""Shared JSON envelope for CLI and MCP (agent contract)."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from walla.core.errors import classify_error
+from walla.core.exceptions import WallaAmbiguousError, WallaAuthError
+
+__all__ = (
+    "API_VERSION",
+    "dump_model",
+    "error_payload",
+    "success_payload",
+)
+
+API_VERSION = 1
+
+
+def success_payload(data: Any) -> dict[str, Any]:
+    return {"ok": True, "api_version": API_VERSION, "data": data}
+
+
+def error_payload(exc: BaseException) -> dict[str, Any]:
+    classified = classify_error(exc)
+    payload: dict[str, Any] = {
+        "ok": False,
+        "api_version": API_VERSION,
+        "error": str(exc),
+        **classified.as_fields(),
+    }
+    if isinstance(exc, WallaAmbiguousError):
+        payload["candidates"] = [
+            c.model_dump(mode="json") if hasattr(c, "model_dump") else c
+            for c in exc.candidates
+        ]
+    if isinstance(exc, WallaAuthError):
+        from walla.core.human_fix import cookie_export_fix
+
+        payload["human_fix"] = cookie_export_fix()
+    return payload
+
+
+def dump_model(model: Any) -> Any:
+    """Pydantic model to JSON-ready dict."""
+    return model.model_dump(mode="json")