walla-cli 0.1.10__tar.gz → 0.1.11__tar.gz

{walla_cli-0.1.10 → walla_cli-0.1.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: walla-cli
-Version: 0.1.10
+Version: 0.1.11
 Summary: Wallapop.es CLI - look · offer · talk · sell for humans and agents
 Project-URL: Homepage, https://github.com/berendgort/wallapop-cli
 Project-URL: Repository, https://github.com/berendgort/wallapop-cli

{walla_cli-0.1.10 → walla_cli-0.1.11}/docs/WIRE.md

@@ -34,6 +34,11 @@ Public URL: `https://es.wallapop.com/item/<web_slug>`.
 `leaf_id` + `root_id`. Sell accepts `--category <leaf-or-name>`; `--root` is
 optional.
 
+After `current_step=photo`, the steps `draft` may include `category_leaf_id`
+(title+photo hint). `GET /api/v3/suggested-item-data/{upload_id}` often returns
+empty HTTP 200; still poll before `loading`. CLI: `walla sell … --title … --suggest`.
+`walla desk --watch` polls the inbox until `stack.best` converges.
+
 ## Auth
 
 `POST https://api.wallapop.com/api/v3/access/login` with

walla_cli-0.1.11/fixtures/sell_suggest_draft.json

@@ -0,0 +1,23 @@
+{
+  "schema_version": 1,
+  "note": "After photo step, Wallapop may inject category_leaf_id from title+photos. suggested-item-data often returns empty HTTP 200.",
+  "after_photo": {
+    "step": {"id": "category", "components": []},
+    "draft": {
+      "title": "Escritorio madera oscura patas cromadas",
+      "category_leaf_id": "24208"
+    }
+  },
+  "after_loading": {
+    "step": {"id": "listing", "components": []},
+    "draft": {
+      "title": "Escritorio madera oscura patas cromadas",
+      "category_leaf_id": "24208",
+      "root_category_id": "12467"
+    }
+  },
+  "suggested_item_data": {
+    "http_status": 200,
+    "body": null
+  }
+}

{walla_cli-0.1.10 → walla_cli-0.1.11}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "walla-cli"
-version = "0.1.10"
+version = "0.1.11"
 description = "Wallapop.es CLI - look · offer · talk · sell for humans and agents"
 authors = [{ name = "Dr. Berend Gort", email = "berend.gort@gmail.com" }]
 readme = "README.md"

{walla_cli-0.1.10 → walla_cli-0.1.11}/skills/walla-sell/SKILL.md

@@ -14,10 +14,11 @@ Do not ask the human to type buyer replies. Desk sends those.
 
 ```bash
 walla categories --find escritorio --json
-walla sell ./shot1.jpg ./shot2.jpg --json
+walla sell ./shot1.jpg ./shot2.jpg --title "Escritorio madera" --suggest --json
 ```
 
-Ask every question in `data.questions`, then publish once:
+`--suggest` (or draft with `--title` and no `--category`) asks Wallapop to prefill
+`category_leaf_id` from title+photos. Ask remaining `data.questions`, then:
 
 ```bash
 walla sell ./shot1.jpg ./shot2.jpg \
@@ -26,17 +27,17 @@ walla sell ./shot1.jpg ./shot2.jpg \
   --floor 35 --yes --json
 ```
 
-`--category` accepts a leaf id **or** name tokens (`escritorio`, `hogar/muebles`).
-`--root` is optional (derived from the leaf). `--floor` is the lowest EUR desk may
-accept. Omit it to hold the asking price.
+`--category` accepts a leaf id **or** name tokens. `--root` is optional.
+`--floor` is the lowest EUR desk may accept.
+
 Then:
 
 ```bash
-walla desk --json
+walla desk --watch --seconds 45 --rounds 12 --json
 ```
 
-Desk reads the inbox once and answers buyers. Repeat desk until `stack.best`
-is a sell row. Show the title, agreed EUR, `stack.why`, and the item link.
+Desk answers buyers until `stack.best` converges or rounds end. Show the title,
+agreed EUR, `stack.why`, and the item link.
 
 The human accepts the sale in the Wallapop app. `walla unsell <id> --yes` deletes
 a listing. Never mark the item sold from walla.

{walla_cli-0.1.10 → walla_cli-0.1.11}/tests/test_live.py

@@ -11,7 +11,8 @@ import pytest
 from walla.account.chat import open_conversation
 from walla.account.inbox import list_conversations_raw
 from walla.account.login import ensure_access_token, whoami
-from walla.account.sell import _step, delete_listing, publish_listing, upload_pictures
+from walla.account.sell import delete_listing, publish_listing, upload_pictures
+from walla.account.sell_steps import post_step as _step
 from walla.account.session_store import load_session
 from walla.http.client import HttpClient
 from walla.http.polite import reset_polite

{walla_cli-0.1.10 → walla_cli-0.1.11}/tests/test_sell.py

@@ -119,23 +119,23 @@ def test_publish_listing_mocked(tmp_path: Path) -> None:
     photo.write_bytes(b"\xff\xd8\xff\xd9")
     fake_http = MagicMock()
     fake_http.post.side_effect = [
-        {"step": {"id": "title"}},
-        {"step": {"id": "photo", "picture_upload": {"path": "/api/v3/upload/x/pictures"}}},
-        {"step": {"id": "category"}},
+        {"step": {"id": "title"}, "draft": {}},
+        {"step": {"id": "photo"}, "draft": {"title": "Test item"}},
         {
-            "step": {
-                "id": "loading",
-                "poll_before_next_step": {"path": "/api/v3/suggested-item-data/x"},
-            }
+            "step": {"id": "category"},
+            "draft": {"title": "Test item", "category_leaf_id": "10105"},
         },
-        {"step": {"id": "listing"}},
+        {"step": {"id": "loading"}, "draft": {"title": "Test item"}},
+        {"step": {"id": "listing"}, "draft": {"title": "Test item"}},
     ]
     fake_http.get.return_value = {}
     listing = MagicMock()
     listing.url = "https://es.wallapop.com/item/test-item-99"
     listing.web_slug = "test-item-99"
     with (
-        patch("walla.account.sell._auth_client", return_value=fake_http),
+        patch("walla.account.sell.auth_client", return_value=fake_http),
+        patch("walla.account.sell.post_step", side_effect=fake_http.post.side_effect),
+        patch("walla.account.sell.poll_suggested", return_value=None),
         patch("walla.account.sell.upload_pictures", return_value=1),
         patch(
             "walla.account.sell.create_listing",
@@ -156,7 +156,6 @@ def test_publish_listing_mocked(tmp_path: Path) -> None:
     assert out["id"] == "abc123"
     assert out["photos"] == 1
     assert out["url"] == "https://es.wallapop.com/item/test-item-99"
-    assert fake_http.post.call_count == 5
 
 
 def test_create_listing_multipart(tmp_path: Path) -> None:
@@ -179,7 +178,7 @@ def test_create_listing_multipart(tmp_path: Path) -> None:
     fake_session = MagicMock()
     fake_session.request.return_value = fake_resp
     with (
-        patch("walla.account.sell._auth_headers", return_value={"Authorization": "Bearer x"}),
+        patch("walla.account.sell.auth_headers", return_value={"Authorization": "Bearer x"}),
         patch("walla.account.sell.requests.Session", return_value=fake_session),
         patch("walla.account.sell.CurlMime") as mime_cls,
         patch("walla.account.sell.wait_turn"),
@@ -227,14 +226,16 @@ def test_publish_listing_two_photos(tmp_path: Path) -> None:
     listing.url = "https://es.wallapop.com/item/test-item-99"
     listing.web_slug = "test-item-99"
     with (
-        patch("walla.account.sell._auth_client", return_value=fake_http),
+        patch("walla.account.sell.auth_client", return_value=fake_http),
+        patch("walla.account.sell.post_step", side_effect=fake_http.post.side_effect),
+        patch("walla.account.sell.poll_suggested", return_value=None),
         patch("walla.account.sell.upload_pictures", return_value=2),
         patch(
             "walla.account.sell.create_listing",
             return_value={"id": "abc123", "flags": {}},
         ),
         patch("walla.account.sell.get_item", return_value=listing),
-        patch("walla.account.sell._auth_headers", return_value={}),
+        patch("walla.account.sell.auth_headers", return_value={}),
         patch("walla.account.sell.requests.Session", return_value=fake_session),
         patch("walla.account.sell.CurlMime") as mime_cls,
         patch("walla.account.sell.wait_turn"),

walla_cli-0.1.11/tests/test_suggest_watch.py

@@ -0,0 +1,101 @@
+"""Suggest draft parse + desk watch stop conditions."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+from walla.account.desk_watch import run_desk_watch
+from walla.account.sell_steps import parse_steps_draft
+
+FIX = Path(__file__).resolve().parents[1] / "fixtures"
+
+
+def test_parse_steps_draft_fixture() -> None:
+    raw = json.loads((FIX / "sell_suggest_draft.json").read_text(encoding="utf-8"))
+    after = parse_steps_draft(raw["after_photo"])
+    assert after["category_leaf_id"] == "24208"
+    assert after["title"].startswith("Escritorio")
+    loaded = parse_steps_draft(raw["after_loading"])
+    assert loaded["root_category_id"] == "12467"
+
+
+def test_desk_watch_stops_on_converged() -> None:
+    converged = {
+        "replies": [],
+        "stack": {"best": {"status": "converged", "title": "X", "agreed_eur": 40}},
+        "close_in_app": True,
+    }
+    with patch("walla.account.desk_watch.run_desk", return_value=converged) as desk:
+        with patch("walla.account.desk_watch.time.sleep") as slept:
+            out = run_desk_watch(seconds=5, rounds=5)
+    assert out["watch_stopped"] == "converged"
+    assert out["watch_round"] == 1
+    desk.assert_called_once()
+    slept.assert_not_called()
+
+
+def test_desk_watch_max_rounds() -> None:
+    waiting = {
+        "replies": [],
+        "stack": {"best": None},
+        "close_in_app": True,
+    }
+    with patch("walla.account.desk_watch.run_desk", return_value=waiting) as desk:
+        with patch("walla.account.desk_watch.time.sleep") as slept:
+            out = run_desk_watch(seconds=5, rounds=3)
+    assert out["watch_stopped"] == "max_rounds"
+    assert out["watch_round"] == 3
+    assert desk.call_count == 3
+    assert slept.call_count == 2
+
+
+def test_suggest_from_photos_mocked(tmp_path: Path) -> None:
+    from walla.account.sell_suggest import suggest_from_photos
+
+    photo = tmp_path / "a.jpg"
+    photo.write_bytes(b"\xff\xd8\xff\xd9")
+    steps = [
+        {"step": {"id": "title"}, "draft": {}},
+        {"step": {"id": "photo"}, "draft": {"title": "Escritorio madera"}},
+        {
+            "step": {"id": "category"},
+            "draft": {"title": "Escritorio madera", "category_leaf_id": "24208"},
+        },
+        {
+            "step": {"id": "loading"},
+            "draft": {
+                "title": "Escritorio madera",
+                "category_leaf_id": "24208",
+                "root_category_id": "12467",
+            },
+        },
+        {
+            "step": {"id": "listing"},
+            "draft": {
+                "title": "Escritorio madera",
+                "category_leaf_id": "24208",
+                "root_category_id": "12467",
+            },
+        },
+    ]
+    fake = MagicMock()
+    with (
+        patch("walla.account.sell_suggest.auth_client", return_value=fake),
+        patch("walla.account.sell_suggest.post_step", side_effect=steps),
+        patch("walla.account.sell_suggest.upload_pictures", return_value=1),
+        patch("walla.account.sell_suggest.poll_suggested", return_value=None),
+        patch(
+            "walla.account.sell_suggest.get_categories",
+            return_value=__import__(
+                "walla.search.parse", fromlist=["parse_categories"]
+            ).parse_categories(
+                json.loads((FIX / "categories.json").read_text(encoding="utf-8"))
+            ),
+        ),
+    ):
+        out = suggest_from_photos([photo], title="Escritorio madera")
+    assert out["category_leaf_id"] == "24208"
+    assert out["root_category_id"] == "12467"
+    assert "Escritorios" in (out.get("path") or "")

{walla_cli-0.1.10 → walla_cli-0.1.11}/tests/test_wire_contracts.py

@@ -250,8 +250,9 @@ def test_every_contract_is_sent(
         expires_at=9_999_999_999,
     )
     monkeypatch.setattr("walla.account.login.ensure_access_token", lambda: sess)
-    monkeypatch.setattr("walla.account.sell.ensure_access_token", lambda: sess)
-    monkeypatch.setattr("walla.account.sell._auth_client", lambda: rec)
+    monkeypatch.setattr("walla.account.sell_steps.ensure_access_token", lambda: sess)
+    monkeypatch.setattr("walla.account.sell.auth_client", lambda: rec)
+    monkeypatch.setattr("walla.account.sell_steps.auth_client", lambda: rec)
     monkeypatch.setattr("walla.account.chat.ensure_access_token", _must_not_mint)
     monkeypatch.setattr(
         "walla.account.actions.load_profile",

{walla_cli-0.1.10 → walla_cli-0.1.11}/walla/__init__.py

@@ -4,4 +4,4 @@ from __future__ import annotations
 
 __all__ = ("__version__",)
 
-__version__ = "0.1.10"
+__version__ = "0.1.11"

walla_cli-0.1.11/walla/account/desk_watch.py

@@ -0,0 +1,36 @@
+"""Poll the inbox until a deal converges or rounds run out."""
+
+from __future__ import annotations
+
+import time
+from typing import Any
+
+from walla.account.desk import run_desk
+from walla.http.client import HttpClient
+
+__all__ = ("run_desk_watch",)
+
+
+def run_desk_watch(
+    *,
+    seconds: float = 45.0,
+    rounds: int = 12,
+    client: HttpClient | None = None,
+) -> dict[str, Any]:
+    """Repeat run_desk until stack.best is converged or max rounds."""
+    if seconds < 5:
+        raise ValueError("--seconds must be >= 5")
+    if rounds < 1 or rounds > 60:
+        raise ValueError("--rounds must be 1..60")
+    last: dict[str, Any] = {}
+    for i in range(rounds):
+        last = run_desk(client=client)
+        last["watch_round"] = i + 1
+        best = (last.get("stack") or {}).get("best")
+        if isinstance(best, dict) and best.get("status") == "converged":
+            last["watch_stopped"] = "converged"
+            return last
+        if i + 1 < rounds:
+            time.sleep(float(seconds))
+    last["watch_stopped"] = "max_rounds"
+    return last

{walla_cli-0.1.10 → walla_cli-0.1.11}/walla/account/sell.py

@@ -9,7 +9,13 @@ from typing import Any
 
 from curl_cffi import CurlMime, requests
 
-from walla.account.login import ensure_access_token
+from walla.account.sell_steps import (
+    auth_client,
+    auth_headers,
+    parse_steps_draft,
+    poll_suggested,
+    post_step,
+)
 from walla.account.sell_wire import build_item_body
 from walla.core.exceptions import (
     WallaHTTPError,
@@ -18,7 +24,7 @@ from walla.core.exceptions import (
     WallaUnsupportedError,
 )
 from walla.http.client import HttpClient
-from walla.http.headers import API_BASE, WEB_BASE, default_headers
+from walla.http.headers import API_BASE, WEB_BASE
 from walla.http.polite import wait_turn
 from walla.search.api import get_item
 from walla.search.parse import item_url
@@ -39,42 +45,11 @@ _IMAGE_TYPES = {
 }
 
 
-def _auth_client() -> HttpClient:
-    sess = ensure_access_token()
-    return HttpClient(access_token=sess.access_token, device_id=sess.device_id)
-
-
-def _auth_headers() -> dict[str, str]:
-    sess = ensure_access_token()
-    headers = default_headers(device_id=sess.device_id)
-    headers["Authorization"] = f"Bearer {sess.access_token}"
-    return headers
-
-
-def _step(
-    http: HttpClient,
-    upload_id: str,
-    *,
-    current: str | None,
-    draft: dict[str, Any],
-) -> dict[str, Any]:
-    body: dict[str, Any] = {
-        "mode": {"action": "upload", "id": upload_id},
-        "draft": draft,
-    }
-    if current:
-        body["current_step"] = current
-    raw = http.post("/api/v3/steps", json_body=body, auth=True)
-    if not isinstance(raw, dict):
-        raise WallaUnsupportedError("steps returned non-object")
-    return raw
-
-
 def upload_pictures(upload_id: str, photos: list[Path]) -> int:
     """POST each photo to /api/v3/upload/{id}/pictures (HTTP 204)."""
     if not photos:
         raise ValueError("at least one photo required")
-    headers = {k: v for k, v in _auth_headers().items() if k.lower() != "content-type"}
+    headers = {k: v for k, v in auth_headers().items() if k.lower() != "content-type"}
     session: Any = requests.Session()
     for path in photos:
         data = path.read_bytes()
@@ -101,7 +76,7 @@ def upload_pictures(upload_id: str, photos: list[Path]) -> int:
 
 def create_listing(item: dict[str, Any], first_photo: Path) -> dict[str, Any]:
     """Multipart POST /api/v3/items with Accept upload-v2."""
-    headers = {k: v for k, v in _auth_headers().items() if k.lower() != "content-type"}
+    headers = {k: v for k, v in auth_headers().items() if k.lower() != "content-type"}
     headers["Accept"] = _UPLOAD_ACCEPT
     data = first_photo.read_bytes()
     ctype = _IMAGE_TYPES.get(first_photo.suffix.lower(), "image/jpeg")
@@ -130,7 +105,7 @@ def create_listing(item: dict[str, Any], first_photo: Path) -> dict[str, Any]:
 
 
 def delete_listing(item_id: str, *, client: HttpClient | None = None) -> dict[str, Any]:
-    http = client or _auth_client()
+    http = client or auth_client()
     http.delete(f"/api/v3/items/{item_id}", auth=True)
     return {"id": item_id, "deleted": True}
 
@@ -154,34 +129,26 @@ def publish_listing(
     for p in paths:
         if not p.is_file():
             raise ValueError(f"photo not found: {p}")
-    http = _auth_client()
+    http = auth_client()
     upload_id = str(uuid.uuid4())
     draft: dict[str, Any] = {"title": title.strip()[:50]}
-    _step(http, upload_id, current=None, draft={})
-    _step(http, upload_id, current="title", draft=draft)
+    post_step(http, upload_id, current=None, draft={})
+    post_step(http, upload_id, current="title", draft=draft)
     upload_pictures(upload_id, paths)
-    _step(http, upload_id, current="photo", draft=draft)
-    draft = {
-        **draft,
-        "category_leaf_id": str(category_leaf_id),
-        "root_category_id": str(root_category_id),
-    }
-    _step(http, upload_id, current="category", draft=draft)
-    for _ in range(8):
-        wait_turn()
-        try:
-            http.get(f"/api/v3/suggested-item-data/{upload_id}", auth=True)
-            break
-        except WallaHTTPError as exc:
-            if exc.status_code != 404:
-                raise
-    _step(http, upload_id, current="loading", draft=draft)
+    after_photo = post_step(http, upload_id, current="photo", draft=draft)
+    wire = parse_steps_draft(after_photo)
+    leaf = str(category_leaf_id)
+    root = str(root_category_id)
+    draft = {**draft, "category_leaf_id": leaf, "root_category_id": root}
+    post_step(http, upload_id, current="category", draft=draft)
+    poll_suggested(http, upload_id)
+    post_step(http, upload_id, current="loading", draft=draft)
     item = build_item_body(
         upload_id=upload_id,
         title=title,
         description=description,
         price_eur=price_eur,
-        category_leaf_id=category_leaf_id,
+        category_leaf_id=leaf,
         lat=lat,
         lon=lon,
         condition=condition,
@@ -197,11 +164,11 @@ def publish_listing(
         "title": title.strip()[:50],
         "url": _public_item_url(str(created["id"])),
         "photos": len(paths),
+        "wire_draft": wire,
     }
 
 
 def _public_item_url(item_id: str) -> str:
-    """Wallapop web needs the slug path, not the opaque item hash."""
     try:
         listing = get_item(item_id)
     except (
@@ -222,7 +189,7 @@ def _public_item_url(item_id: str) -> str:
 
 
 def _upload_extra_pictures(item_id: str, photos: list[Path]) -> None:
-    headers = {k: v for k, v in _auth_headers().items() if k.lower() != "content-type"}
+    headers = {k: v for k, v in auth_headers().items() if k.lower() != "content-type"}
     headers["Accept"] = _UPLOAD_ACCEPT
     session: Any = requests.Session()
     for idx, path in enumerate(photos, start=1):

walla_cli-0.1.11/walla/account/sell_steps.py

@@ -0,0 +1,82 @@
+"""Shared Vender step helpers (auth + /api/v3/steps + suggest poll)."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from walla.account.login import ensure_access_token
+from walla.core.exceptions import WallaHTTPError, WallaUnsupportedError
+from walla.http.client import HttpClient
+from walla.http.headers import default_headers
+from walla.http.polite import wait_turn
+
+__all__ = (
+    "auth_client",
+    "auth_headers",
+    "parse_steps_draft",
+    "poll_suggested",
+    "post_step",
+)
+
+
+def auth_client() -> HttpClient:
+    sess = ensure_access_token()
+    return HttpClient(access_token=sess.access_token, device_id=sess.device_id)
+
+
+def auth_headers() -> dict[str, str]:
+    sess = ensure_access_token()
+    headers = default_headers(device_id=sess.device_id)
+    headers["Authorization"] = f"Bearer {sess.access_token}"
+    return headers
+
+
+def post_step(
+    http: HttpClient,
+    upload_id: str,
+    *,
+    current: str | None,
+    draft: dict[str, Any],
+) -> dict[str, Any]:
+    body: dict[str, Any] = {
+        "mode": {"action": "upload", "id": upload_id},
+        "draft": draft,
+    }
+    if current:
+        body["current_step"] = current
+    raw = http.post("/api/v3/steps", json_body=body, auth=True)
+    if not isinstance(raw, dict):
+        raise WallaUnsupportedError("steps returned non-object")
+    return raw
+
+
+def poll_suggested(http: HttpClient, upload_id: str, *, attempts: int = 8) -> Any:
+    """GET suggested-item-data until non-404 (body often empty 200)."""
+    last: Any = None
+    for _ in range(attempts):
+        wait_turn()
+        try:
+            last = http.get(f"/api/v3/suggested-item-data/{upload_id}", auth=True)
+            return last
+        except WallaHTTPError as exc:
+            if exc.status_code != 404:
+                raise
+    return last
+
+
+def parse_steps_draft(payload: dict[str, Any]) -> dict[str, str]:
+    """Pull title/category ids from a steps response draft."""
+    draft = payload.get("draft")
+    if not isinstance(draft, dict):
+        return {}
+    out: dict[str, str] = {}
+    title = draft.get("title")
+    if title:
+        out["title"] = str(title).strip()[:50]
+    leaf = draft.get("category_leaf_id") or draft.get("categoryLeafId")
+    if leaf:
+        out["category_leaf_id"] = str(leaf)
+    root = draft.get("root_category_id") or draft.get("rootCategoryId")
+    if root:
+        out["root_category_id"] = str(root)
+    return out

walla_cli-0.1.11/walla/account/sell_suggest.py

@@ -0,0 +1,77 @@
+"""Ask Wallapop to prefill category from title+photos (steps draft)."""
+
+from __future__ import annotations
+
+import uuid
+from pathlib import Path
+from typing import Any
+
+from walla.account.sell import upload_pictures
+from walla.account.sell_steps import (
+    auth_client,
+    parse_steps_draft,
+    poll_suggested,
+    post_step,
+)
+from walla.search.api import get_categories
+from walla.search.category_find import flatten_categories, resolve_root_id
+
+__all__ = ("suggest_from_photos",)
+
+
+def suggest_from_photos(
+    photos: list[Path],
+    *,
+    title: str,
+    root_category_id: str | None = None,
+) -> dict[str, Any]:
+    """Run title→photos→photo; return draft fields Wallapop injected."""
+    paths = [Path(p) for p in photos]
+    for p in paths:
+        if not p.is_file():
+            raise ValueError(f"photo not found: {p}")
+    text = title.strip()[:50]
+    if not text:
+        raise ValueError("title required for suggest")
+    http = auth_client()
+    upload_id = str(uuid.uuid4())
+    draft: dict[str, Any] = {"title": text}
+    post_step(http, upload_id, current=None, draft={})
+    post_step(http, upload_id, current="title", draft=draft)
+    upload_pictures(upload_id, paths)
+    after_photo = post_step(http, upload_id, current="photo", draft=draft)
+    parsed = parse_steps_draft(after_photo)
+    leaf = parsed.get("category_leaf_id")
+    root = parsed.get("root_category_id") or root_category_id
+    path = None
+    if leaf:
+        roots = get_categories()
+        if not root:
+            root = resolve_root_id(roots, leaf)
+        path = next(
+            (h.path for h in flatten_categories(roots) if h.leaf_id == leaf),
+            None,
+        )
+        draft = {
+            **draft,
+            "category_leaf_id": leaf,
+            "root_category_id": str(root),
+        }
+        post_step(http, upload_id, current="category", draft=draft)
+        suggested_body = poll_suggested(http, upload_id)
+        after_load = post_step(http, upload_id, current="loading", draft=draft)
+        parsed = {**parsed, **parse_steps_draft(after_load)}
+    else:
+        suggested_body = None
+    return {
+        "upload_id": upload_id,
+        "title": parsed.get("title") or text,
+        "category_leaf_id": leaf,
+        "root_category_id": str(root) if root else None,
+        "path": path,
+        "suggested_item_data": suggested_body,
+        "hint": (
+            "Wallapop filled category_leaf_id from title+photos when present. "
+            "Pass --category / --title overrides, then --yes to publish."
+        ),
+    }

{walla_cli-0.1.10 → walla_cli-0.1.11}/walla/cli/cmd_desk.py

@@ -7,6 +7,7 @@ from typing import Any
 import typer
 
 from walla.account.desk import run_desk, run_pursue
+from walla.account.desk_watch import run_desk_watch
 from walla.cli.catch import run_cmd
 
 __all__ = ("register",)
@@ -28,10 +29,19 @@ def register(app: typer.Typer) -> None:
         run_cmd(_run, as_json=json)
 
     @app.command("desk")
-    def desk_cmd(json: bool = typer.Option(False, "--json")) -> None:
-        """Read the inbox once, answer open threads, summarize the best price."""
+    def desk_cmd(
+        watch: bool = typer.Option(
+            False, "--watch", help="Poll inbox until a price converges"
+        ),
+        seconds: float = typer.Option(45.0, "--seconds", help="Sleep between watch rounds"),
+        rounds: int = typer.Option(12, "--rounds", help="Max watch rounds (1..60)"),
+        json: bool = typer.Option(False, "--json"),
+    ) -> None:
+        """Read the inbox, answer open threads, summarize the best price."""
 
         def _run() -> dict[str, Any]:
+            if watch:
+                return run_desk_watch(seconds=seconds, rounds=rounds)
             return run_desk()
 
         run_cmd(_run, as_json=json)

{walla_cli-0.1.10 → walla_cli-0.1.11}/walla/cli/cmd_sell.py

@@ -8,6 +8,7 @@ from typing import Any
 import typer
 
 from walla.account.sell import delete_listing, publish_listing
+from walla.account.sell_suggest import suggest_from_photos
 from walla.account.sell_wire import CONDITIONS, SELL_QUESTIONS, missing_sell_fields
 from walla.cli.catch import run_cmd
 from walla.hunter.profile_store import load_profile
@@ -37,6 +38,11 @@ def register(app: typer.Typer) -> None:
         floor: float | None = typer.Option(
             None, "--floor", help="Lowest EUR desk may accept from a buyer"
         ),
+        suggest: bool = typer.Option(
+            False,
+            "--suggest",
+            help="Prefill category via Wallapop steps (needs --title)",
+        ),
         yes: bool = typer.Option(False, "--yes", help="Publish for real"),
         json: bool = typer.Option(False, "--json"),
     ) -> None:
@@ -47,17 +53,35 @@ def register(app: typer.Typer) -> None:
             for p in paths:
                 if not p.is_file():
                     raise ValueError(f"photo not found: {p}")
+            title_use = title
             leaf = category
             root_id = root
             picked = None
+            suggested = None
+            auto = bool(title) and not category and not yes
+            if suggest or auto:
+                if not title:
+                    raise ValueError("--suggest needs --title")
+                suggested = suggest_from_photos(
+                    paths, title=title, root_category_id=root
+                )
+                if suggested.get("category_leaf_id"):
+                    leaf = str(suggested["category_leaf_id"])
+                    root_id = str(suggested.get("root_category_id") or "")
             if category:
                 picked = pick_sell_category(
                     get_categories(), category=category, root=root
                 )
                 leaf = picked.leaf_id
                 root_id = picked.root_id
+            elif leaf and str(leaf).isdigit():
+                picked = pick_sell_category(
+                    get_categories(), category=str(leaf), root=root_id or root
+                )
+                leaf = picked.leaf_id
+                root_id = picked.root_id
             fields: dict[str, Any] = {
-                "title": title,
+                "title": title_use,
                 "description": description,
                 "eur": eur,
                 "category_leaf_id": leaf,
@@ -82,7 +106,7 @@ def register(app: typer.Typer) -> None:
                 },
                 "hint": (
                     "Fill missing fields, then walla sell <photos> … --yes. "
-                    "Category: leaf id or name (walla categories --find …)."
+                    "walla sell … --title … --suggest prefills category from Wallapop."
                 ),
             }
             if picked is not None:
@@ -91,6 +115,8 @@ def register(app: typer.Typer) -> None:
                     "root_id": picked.root_id,
                     "path": picked.path,
                 }
+            if suggested is not None:
+                draft["suggested"] = suggested
             if not yes:
                 return {"status": "draft", **draft}
             if missing:
@@ -100,15 +126,15 @@ def register(app: typer.Typer) -> None:
                 )
             if profile.lat is None or profile.lon is None:
                 raise ValueError("Set location first: walla setup --lat … --lon …")
-            assert title and description and eur is not None and leaf and root_id
+            assert title_use and description and eur is not None and leaf and root_id
             lowest = min(floor, eur) if floor is not None else eur
             created = publish_listing(
                 paths,
-                title=title,
+                title=title_use,
                 description=description,
                 price_eur=eur,
-                category_leaf_id=leaf,
-                root_category_id=root_id,
+                category_leaf_id=str(leaf),
+                root_category_id=str(root_id),
                 lat=profile.lat,
                 lon=profile.lon,
                 condition=condition,
@@ -118,13 +144,13 @@ def register(app: typer.Typer) -> None:
             remember(
                 Pursuit(
                     item_id=str(created["id"]),
-                    title=title,
+                    title=title_use,
                     url=str(created.get("url") or ""),
                     side="sell",
                     ask_eur=eur,
                     offer_eur=eur,
                     walk_away_eur=lowest,
-                    query=title,
+                    query=title_use,
                     status="waiting",
                     why="Listing is live. Desk talks to buyers. You accept in the app.",
                 )

{walla_cli-0.1.10 → walla_cli-0.1.11}/walla/core/instruct.py

@@ -123,6 +123,7 @@ def instruct_recipe() -> dict[str, Any]:
             "talk": [
                 'walla pursue "<query>" --json',
                 "walla desk --json",
+                "walla desk --watch --seconds 45 --rounds 12 --json",
                 "walla negotiate <id> --json",
                 "walla inbox --json",
             ],
@@ -132,6 +133,7 @@ def instruct_recipe() -> dict[str, Any]:
             ],
             "sell": [
                 "walla categories --find <name> --json",
+                "walla sell <photos> --title … --suggest --json",
                 "walla sell <photo.jpg>… --json  # returns questions",
                 "walla sell <photos> --title … --desc … --eur N "
                 "--category <leaf-or-name> [--root <root>] --yes",
@@ -142,8 +144,10 @@ def instruct_recipe() -> dict[str, Any]:
             "Always present Wallapop shortlists ranked best-first with markdown item links.",
             "search / item / inbox / negotiate are safe reads or drafts.",
             "pursue and desk send negotiation messages. Do not ask the human to send.",
+            "desk --watch polls until stack.best converges; still never pay.",
             "Bare say, offer, and sell still need --yes. Never pay or accept in walla.",
             "Sell: drop photos, ask data.questions, then publish with --yes only.",
+            "Sell --suggest prefills category from Wallapop steps when title is set.",
             "If only asked to look, do not send.",
             "Ambiguous match or multiple GRABs: ask once with candidates.",
             "Default search is all of Spain. Shipping is enough; do not fence on profile.km.",

{walla_cli-0.1.10 → walla_cli-0.1.11}/walla/mcp/server.py

@@ -167,8 +167,16 @@ def build_server() -> Any:
         return _wrap(lambda: run_pursue(keywords, wave=wave))
 
     @mcp.tool()
-    def desk() -> dict[str, Any]:
-        """One inbox pass: answer threads and summarize the best agreed price."""
+    def desk(
+        watch: bool = False,
+        seconds: float = 45.0,
+        rounds: int = 12,
+    ) -> dict[str, Any]:
+        """Inbox pass (or --watch loop) that answers threads until a price converges."""
+        from walla.account.desk_watch import run_desk_watch
+
+        if watch:
+            return _wrap(lambda: run_desk_watch(seconds=seconds, rounds=rounds))
         return _wrap(run_desk)
 
     @mcp.tool()