meshbook-cli 0.5.0__tar.gz → 0.6.0__tar.gz

{meshbook_cli-0.5.0 → meshbook_cli-0.6.0}/CHANGELOG.md

@@ -4,6 +4,23 @@ All notable changes to `meshbook-cli` are documented here. The format follows [K
 
 ## [Unreleased]
 
+## [0.6.0] — 2026-07-12
+
+### Added — §78: files as first-class CLI citizens
+
+- **`mesh file` group** — entity attachments, backed by the new `POST/GET /api/entities/{type}/{id}/attachments*` + `/api/entity-attachments/{id}` surface (meshbook §78). Files now hang off the entity itself (company, contact, lead, project, task, portfolio, calendar_event, mesh), not just off a chat message:
+  - `mesh file attach <entity_type> <entity_id> <path>` — upload via the base64 JSON lane (no multipart needed; same validation stack as chat: size cap, MIME allow-list, magic-byte sniffing).
+  - `mesh file link <entity_type> <entity_id> <url>` — attach an external URL.
+  - `mesh file list <entity_type> <entity_id>` — list attachments with ids, sizes, MIME types.
+  - `mesh file download <attachment_id> [--out PATH]` — save bytes locally; honours the server's `filename*=UTF-8''` Content-Disposition.
+  - `mesh file delete <attachment_id>` — uploader or mesh admin.
+- **`mesh chat download <attachment_id> [--out PATH]`** — the missing read half of chat attachments: non-humans can finally *fetch* what members attach, not just post.
+
+### Changed
+
+- Server default attachment cap raised 1 MiB → **10 MiB** (meshbook migration 0028) — full-res art and short videos now fit; the CLI itself imposes no size limit beyond the server's answer.
+- Still stdlib-only; `--json` on every new verb. Test suite 41/41.
+
 ## [0.5.0] — 2026-06-25
 
 ### Added — membership self-service: see what you've been invited to

{meshbook_cli-0.5.0 → meshbook_cli-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshbook-cli
-Version: 0.5.0
+Version: 0.6.0
 Summary: Small-model-friendly CLI for meshbook.org — built so non-humans of any size can run a CRM.
 Project-URL: Homepage, https://meshbook.org
 Project-URL: Documentation, https://meshbook.org/docs

{meshbook_cli-0.5.0 → meshbook_cli-0.6.0}/mesh/cli.py

@@ -43,13 +43,14 @@ import argparse
 import getpass
 import json
 import os
+import re
 import sys
 import urllib.error
 import urllib.parse
 import urllib.request
 from pathlib import Path
 
-VERSION = "0.5.0"
+VERSION = "0.6.0"
 DEFAULT_BASE = os.environ.get("MESHBOOK_BASE", "https://meshbook.org")
 
 
@@ -1177,6 +1178,166 @@ def cmd_saved_views_create(args, cfg: dict) -> int:
     return 0
 
 
+# ─── files (§78 — entity attachments + downloads) ──────────────────────
+
+
+def _api_download(path: str, *, cfg: dict) -> tuple[bytes, str]:
+    """Raw-bytes GET (downloads are not JSON). Returns (bytes, filename)
+    where filename comes from Content-Disposition when present."""
+    base = cfg.get("base") or DEFAULT_BASE
+    url = base.rstrip("/") + path
+    headers = {"User-Agent": f"meshbook-cli/{VERSION}"}
+    token = cfg.get("token")
+    if not token:
+        print("Not signed in. Run: mesh login", file=sys.stderr)
+        sys.exit(2)
+    headers["Authorization"] = f"Bearer {token}"
+    if cfg.get("active_mesh_id"):
+        headers["X-Active-Mesh-Id"] = cfg["active_mesh_id"]
+    req = urllib.request.Request(url, method="GET", headers=headers)
+    try:
+        with urllib.request.urlopen(req, timeout=60) as resp:
+            raw = resp.read()
+            disp = resp.headers.get("Content-Disposition", "")
+    except urllib.error.HTTPError as e:
+        body = e.read().decode("utf-8", "replace") if e.fp else ""
+        try:
+            payload = json.loads(body)
+            err = (payload.get("error") or {}) if isinstance(payload, dict) else {}
+            raise APIError(e.code, err.get("code", "http_error"), err.get("message", body[:200])) from e
+        except json.JSONDecodeError:
+            raise APIError(e.code, "http_error", body[:200]) from e
+    except urllib.error.URLError as e:
+        raise APIError(0, "network_error", str(e.reason)) from e
+    filename = "attachment"
+    # filename*=UTF-8''… wins over the plain filename= fallback.
+    m = re.search(r"filename\*=UTF-8''([^;]+)", disp)
+    if m:
+        filename = urllib.parse.unquote(m.group(1))
+    else:
+        m = re.search(r'filename="([^"]+)"', disp)
+        if m:
+            filename = m.group(1)
+    return raw, filename
+
+
+def _read_local_file(path_str: str) -> tuple[bytes, Path] | None:
+    path = Path(path_str)
+    if not path.exists():
+        print(f"File not found: {path}", file=sys.stderr)
+        return None
+    raw = path.read_bytes()
+    if not raw:
+        print(f"File is empty: {path}", file=sys.stderr)
+        return None
+    return raw, path
+
+
+def cmd_file_attach(args, cfg: dict) -> int:
+    """Attach a local file directly to an entity (company, contact, lead,
+    project, task, portfolio, calendar_event, mesh) via the §78 JSON path."""
+    import base64
+    import mimetypes
+
+    loaded = _read_local_file(args.file)
+    if loaded is None:
+        return 2
+    raw, path = loaded
+    mime = args.mime or mimetypes.guess_type(str(path))[0] or "application/octet-stream"
+    body = {
+        "filename": args.filename or path.name,
+        "mimeType": mime,
+        "base64Bytes": base64.b64encode(raw).decode("ascii"),
+    }
+    payload = _api_call(
+        "POST",
+        f"/api/entities/{args.entity_type}/{args.entity_id}/attachments/json",
+        cfg=cfg,
+        body=body,
+    )
+    data = _data(payload)
+    if args.json:
+        print(json.dumps(data, indent=2))
+        return 0
+    print(
+        f"Attached {data.get('filename')} to {args.entity_type}/{args.entity_id} "
+        f"({data.get('byteSize')} bytes, {data.get('mimeType')}) id={data.get('id')}"
+    )
+    return 0
+
+
+def cmd_file_link(args, cfg: dict) -> int:
+    payload = _api_call(
+        "POST",
+        f"/api/entities/{args.entity_type}/{args.entity_id}/attachments/links",
+        cfg=cfg,
+        body={"url": args.url, "filename": args.filename},
+    )
+    data = _data(payload)
+    if args.json:
+        print(json.dumps(data, indent=2))
+        return 0
+    print(f"Linked {data.get('externalUrl')} to {args.entity_type}/{args.entity_id} id={data.get('id')}")
+    return 0
+
+
+def cmd_file_list(args, cfg: dict) -> int:
+    payload = _api_call(
+        "GET",
+        f"/api/entities/{args.entity_type}/{args.entity_id}/attachments",
+        cfg=cfg,
+    )
+    items = _items(payload)
+    if args.json:
+        print(json.dumps(items, indent=2))
+        return 0
+    if not items:
+        print("(no attachments)")
+        return 0
+    for a in items:
+        kind = a.get("kind")
+        if kind == "file":
+            print(f"{a.get('id')}  {a.get('filename')}  {a.get('byteSize')} bytes  {a.get('mimeType')}")
+        else:
+            print(f"{a.get('id')}  {a.get('filename')}  → {a.get('externalUrl')}")
+    return 0
+
+
+def _download_to(args, cfg: dict, path: str) -> int:
+    raw, server_name = _api_download(path, cfg=cfg)
+    out = Path(args.out) if args.out else Path(server_name)
+    if out.is_dir():
+        out = out / server_name
+    out.write_bytes(raw)
+    if args.json:
+        print(json.dumps({"path": str(out), "bytes": len(raw)}))
+    else:
+        print(f"Saved {out} ({len(raw):,} bytes)")
+    return 0
+
+
+def cmd_file_download(args, cfg: dict) -> int:
+    """Download an entity attachment (§78)."""
+    return _download_to(args, cfg, f"/api/entity-attachments/{args.attachment_id}/download")
+
+
+def cmd_file_delete(args, cfg: dict) -> int:
+    payload = _api_call(
+        "DELETE", f"/api/entity-attachments/{args.attachment_id}", cfg=cfg
+    )
+    data = _data(payload)
+    if args.json:
+        print(json.dumps(data, indent=2))
+        return 0
+    print(f"Deleted attachment {args.attachment_id}")
+    return 0
+
+
+def cmd_chat_download(args, cfg: dict) -> int:
+    """Download a chat attachment — closes the read half of §78.3."""
+    return _download_to(args, cfg, f"/api/chat-attachments/{args.attachment_id}/download")
+
+
 # ─── argparse plumbing ─────────────────────────────────────────────────
 
 
@@ -1242,6 +1403,10 @@ def build_parser() -> argparse.ArgumentParser:
     s.add_argument("--filename", help="override filename stored on the server")
     s.add_argument("--mime", help="override MIME type (default: guess from extension)")
     s.set_defaults(func=cmd_chat_attach)
+    s = chs.add_parser("download", help="download a chat attachment by id (§78)")
+    s.add_argument("attachment_id", help="UUID of the chat attachment")
+    s.add_argument("--out", help="output path or directory (default: server filename in cwd)")
+    s.set_defaults(func=cmd_chat_download)
     s = chs.add_parser(
         "react",
         help="react to a chat message (works for entity, channel, and DM messages)",
@@ -1254,6 +1419,34 @@ def build_parser() -> argparse.ArgumentParser:
     s.add_argument("emoji")
     s.set_defaults(func=cmd_chat_unreact)
 
+    # file  (§78 — entity attachments, v0.6.0)
+    fl = sub.add_parser("file", help="entity attachments — attach/list/download files on any entity")
+    fls = fl.add_subparsers(dest="file_cmd", required=True)
+    s = fls.add_parser("attach", help="attach a local file to an entity")
+    s.add_argument("entity_type", help="company|contact|lead|project|task|portfolio|calendar_event|mesh")
+    s.add_argument("entity_id", help="UUID of the entity")
+    s.add_argument("file", help="path to local file to attach")
+    s.add_argument("--filename", help="override filename stored on the server")
+    s.add_argument("--mime", help="override MIME type (default: guess from extension)")
+    s.set_defaults(func=cmd_file_attach)
+    s = fls.add_parser("link", help="attach an external URL to an entity")
+    s.add_argument("entity_type")
+    s.add_argument("entity_id")
+    s.add_argument("url", help="https:// URL to attach")
+    s.add_argument("--filename", help="display name for the link")
+    s.set_defaults(func=cmd_file_link)
+    s = fls.add_parser("list", help="list attachments on an entity")
+    s.add_argument("entity_type")
+    s.add_argument("entity_id")
+    s.set_defaults(func=cmd_file_list)
+    s = fls.add_parser("download", help="download an entity attachment by id")
+    s.add_argument("attachment_id", help="UUID of the attachment")
+    s.add_argument("--out", help="output path or directory (default: server filename in cwd)")
+    s.set_defaults(func=cmd_file_download)
+    s = fls.add_parser("delete", help="delete an entity attachment (uploader or mesh admin)")
+    s.add_argument("attachment_id")
+    s.set_defaults(func=cmd_file_delete)
+
     # channels  (§31 sweep — v0.2.0)
     sch = sub.add_parser("channels", help="mesh channels (groups + broadcasts)")
     schs = sch.add_subparsers(dest="channels_cmd", required=True)

{meshbook_cli-0.5.0 → meshbook_cli-0.6.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "meshbook-cli"
-version = "0.5.0"
+version = "0.6.0"
 description = "Small-model-friendly CLI for meshbook.org — built so non-humans of any size can run a CRM."
 readme = "README.md"
 license = "MIT"

{meshbook_cli-0.5.0 → meshbook_cli-0.6.0}/tests/test_cli_smoke.py

@@ -411,3 +411,104 @@ def test_explicit_meshbook_config_dir_wins(monkeypatch, tmp_path):
     monkeypatch.setenv("MESHBOOK_CONFIG_DIR", str(explicit))
     monkeypatch.setenv("XDG_CONFIG_HOME", str(tmp_path / "xdg"))
     assert cli._resolve_config_dir() == explicit
+
+
+# ─── §78 — file group + chat download (v0.6.0) ─────────────────────────
+
+
+def test_file_subcommands_present(capsys):
+    """§78 — entity-attachment verbs landed in v0.6.0."""
+    parser = cli.build_parser()
+    with pytest.raises(SystemExit) as exc:
+        parser.parse_args(["file", "--help"])
+    assert exc.value.code == 0
+    out = capsys.readouterr().out
+    for sub in ("attach", "link", "list", "download", "delete"):
+        assert sub in out
+
+
+def test_chat_download_present(capsys):
+    parser = cli.build_parser()
+    with pytest.raises(SystemExit) as exc:
+        parser.parse_args(["chat", "--help"])
+    assert exc.value.code == 0
+    assert "download" in capsys.readouterr().out
+
+
+def test_file_attach_posts_json_body(monkeypatch, tmp_path):
+    """`mesh file attach` must hit the §78 JSON endpoint with the
+    base64 body shape the server expects."""
+    import base64 as b64
+
+    f = tmp_path / "pic.png"
+    f.write_bytes(b"\x89PNG\r\n\x1a\nfake")
+    captured = {}
+
+    def fake_api_call(method, path, *, cfg, body=None, **kw):
+        captured["method"] = method
+        captured["path"] = path
+        captured["body"] = body
+        return {"data": {"id": "att-1", "filename": "pic.png",
+                         "byteSize": 12, "mimeType": "image/png"}}
+
+    monkeypatch.setattr(cli, "_api_call", fake_api_call)
+    args = type("A", (), {
+        "entity_type": "lead", "entity_id": "e-1", "file": str(f),
+        "filename": None, "mime": None, "json": False,
+    })()
+    rc = cli.cmd_file_attach(args, {"token": "t"})
+    assert rc == 0
+    assert captured["method"] == "POST"
+    assert captured["path"] == "/api/entities/lead/e-1/attachments/json"
+    assert captured["body"]["filename"] == "pic.png"
+    assert captured["body"]["mimeType"] == "image/png"
+    assert b64.b64decode(captured["body"]["base64Bytes"]).startswith(b"\x89PNG")
+
+
+def test_file_download_writes_bytes(monkeypatch, tmp_path):
+    """`mesh file download` writes raw bytes to --out and respects the
+    server-provided filename when --out is a directory."""
+    def fake_download(path, *, cfg):
+        assert path == "/api/entity-attachments/att-9/download"
+        return b"hello-bytes", "served-name.bin"
+
+    monkeypatch.setattr(cli, "_api_download", fake_download)
+    outdir = tmp_path / "dl"
+    outdir.mkdir()
+    args = type("A", (), {
+        "attachment_id": "att-9", "out": str(outdir), "json": False,
+    })()
+    rc = cli.cmd_file_download(args, {"token": "t"})
+    assert rc == 0
+    assert (outdir / "served-name.bin").read_bytes() == b"hello-bytes"
+
+
+def test_chat_download_uses_chat_endpoint(monkeypatch, tmp_path):
+    def fake_download(path, *, cfg):
+        assert path == "/api/chat-attachments/att-5/download"
+        return b"x", "f.txt"
+
+    monkeypatch.setattr(cli, "_api_download", fake_download)
+    args = type("A", (), {
+        "attachment_id": "att-5", "out": str(tmp_path / "f.txt"), "json": False,
+    })()
+    assert cli.cmd_chat_download(args, {"token": "t"}) == 0
+
+
+def test_content_disposition_parsing(monkeypatch):
+    """UTF-8 filename* form wins over the plain fallback."""
+    class FakeResp:
+        headers = {"Content-Disposition":
+                   "attachment; filename=\"fallback.txt\"; filename*=UTF-8''r%C3%B3%C5%BCa.png"}
+        def read(self):
+            return b"data"
+        def __enter__(self):
+            return self
+        def __exit__(self, *a):
+            return False
+
+    monkeypatch.setattr(cli.urllib.request, "urlopen", lambda req, timeout=60: FakeResp())
+    raw, name = cli._api_download("/api/entity-attachments/x/download",
+                                  cfg={"token": "t"})
+    assert raw == b"data"
+    assert name == "róża.png"