justfill-mcp 0.4.0__tar.gz

justfill_mcp-0.4.0/.gitignore

@@ -0,0 +1,3 @@
+.venv/
+__pycache__/
+*.egg-info/

justfill_mcp-0.4.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Maciej Śnieżyński
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

justfill_mcp-0.4.0/PKG-INFO

@@ -0,0 +1,123 @@
+Metadata-Version: 2.4
+Name: justfill-mcp
+Version: 0.4.0
+Summary: JustFill MCP server — let AI agents detect, review and fill PDF form fields via justfill.app
+Project-URL: Homepage, https://justfill.app
+License-Expression: MIT
+License-File: LICENSE
+Keywords: ai-agents,claude,form-filling,forms,mcp,model-context-protocol,pdf
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Office/Business
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.24.0
+Requires-Dist: mcp>=1.2.0
+Requires-Dist: pillow>=10.0.0
+Requires-Dist: pypdf>=4.0.0
+Description-Content-Type: text/markdown
+
+# JustFill MCP Server
+
+Let AI agents (Claude, ChatGPT, n8n — any MCP client) detect, review and fill
+PDF form fields through [justfill.app](https://justfill.app).
+
+## Why agents can trust it
+
+| Source | Confidence | What it means |
+|---|---|---|
+| **Saved template** | 1.0 | This exact PDF was filled before; geometry is human/agent-verified. No ML runs at all. |
+| **AcroForm** | 1.0 | The PDF has embedded form fields — read from the file, filled natively. |
+| **ML detection** | 0.0–0.95 | An honest draft. Review it visually (`render_preview`), fix it, then `save_template` to lock it in. |
+
+ML confidence is *calibrated*: the detector's raw scores are not
+probabilities (its server-side filter accepts boxes from raw ~0.02 and
+auto-accepts at raw 0.15), so they are mapped onto 0–1 to mean what you'd
+expect — ≥0.75 "detector is sure", 0.4–0.75 "probably right, glance at the
+preview", <0.4 "borderline accept, verify". The raw detector score is kept
+on each field as `raw_score`.
+
+The correction loop (`render_preview` → `add/update/remove_field`) exists
+precisely because ML detection has false positives and negatives. A false
+positive costs nothing (leave it unfilled or remove it); a false negative is
+visible on the preview and fixable with one `add_field` call. Once reviewed,
+`save_template` makes every future fill of that form deterministic.
+
+## Setup
+
+```bash
+uv tool install ./mcp-server        # or: pip install ./mcp-server
+```
+
+Authorize once (opens the browser, one click while logged in to justfill.app):
+
+```bash
+justfill-mcp login
+```
+
+Then the config needs no credentials at all:
+
+```json
+{
+  "mcpServers": {
+    "justfill": { "command": "justfill-mcp" }
+  }
+}
+```
+
+Alternatives, in the order the server checks them:
+
+1. `JUSTFILL_API_KEY` env — create a key at justfill.app → Account → API Keys
+   and put `"env": {"JUSTFILL_API_KEY": "jf_live_…"}` in the config.
+2. The key saved by `justfill-mcp login` (`~/.config/justfill/credentials.json`).
+3. `JUSTFILL_EMAIL` + `JUSTFILL_PASSWORD` — legacy fallback; an API key is
+   better (no password in config files, revocable per client, never expires
+   mid-session).
+
+## Tools
+
+- `open_pdf(path, min_confidence=0.0, max_pages=10, force_detect=False)` —
+  template → AcroForm → ML resolution order. Accepts scanned images too
+  (jpg/png/tiff → converted to PDF, deterministically, so templates still
+  match). `force_detect=True` ignores a saved template and re-runs ML.
+- `render_preview(page_index)` — page image with labeled field boxes (blue = deterministic, green/orange/red = ML confidence)
+- `render_filled_preview(values, page_index)` — the same page with your values
+  drawn in place (checkboxes get an X). Costs no fills — check before you fill.
+- `list_fields(page_index?)`
+- `add_field(x, y, w, h, name, page_index, field_type, align?, vertical_align?)` — coords in % of page, top-left origin
+- `update_field(field_id, …)` / `remove_field(field_id)`
+- `update_fields([{field_id, …}, …])` / `remove_fields([ids])` — batch versions
+- `prune_fields(field_type?, confidence_below?, width_below?, height_below?, page_index?, exclude_ids?)` —
+  bulk-delete detection noise in one call (criteria AND-ed, removed ids returned)
+- `fill_pdf(values, output_path, flatten=True)` — `values` = `{field_id: text}`;
+  responds with `warnings` for values that will be shrunk/truncated to fit
+- `save_template(name)` — persist the reviewed layout for deterministic repeat fills
+- `list_templates()`
+
+Text alignment: `align` = `left|center|right`, `vertical_align` =
+`top|middle|bottom` — set per field (e.g. `right` for RTL forms, `center` for
+boxed digits). Persisted in templates.
+
+## Example agent flow
+
+```
+open_pdf("~/forms/w-9.pdf")            → acroform, 27 fields, confidence 1.0
+fill_pdf({"f1": "Jane Doe", …}, "~/out/w-9-filled.pdf")
+```
+
+```
+open_pdf("~/forms/scan.jpg")           → converted to PDF; ml, 34 fields
+render_preview(0)                      → agent sees noise + one missed line
+prune_fields(field_type="cell", width_below=3)   → 16 removed in one call
+add_field(x=18, y=62.5, w=40, h=3, name="Phone")
+render_filled_preview({…})             → values sit right, no overflow
+fill_pdf({…}, "~/out/filled.pdf")
+save_template("Client intake form")    → next time: deterministic
+```
+
+## Notes
+
+- Auth is a regular justfill.app account; tokens auto-refresh on expiry.
+- Detection is free; downloads consume the account's fill allowance/credits
+  (same rules as the web app).
+- One PDF open at a time per server session (by design — keeps ids stable).

justfill_mcp-0.4.0/README.md

@@ -0,0 +1,104 @@
+# JustFill MCP Server
+
+Let AI agents (Claude, ChatGPT, n8n — any MCP client) detect, review and fill
+PDF form fields through [justfill.app](https://justfill.app).
+
+## Why agents can trust it
+
+| Source | Confidence | What it means |
+|---|---|---|
+| **Saved template** | 1.0 | This exact PDF was filled before; geometry is human/agent-verified. No ML runs at all. |
+| **AcroForm** | 1.0 | The PDF has embedded form fields — read from the file, filled natively. |
+| **ML detection** | 0.0–0.95 | An honest draft. Review it visually (`render_preview`), fix it, then `save_template` to lock it in. |
+
+ML confidence is *calibrated*: the detector's raw scores are not
+probabilities (its server-side filter accepts boxes from raw ~0.02 and
+auto-accepts at raw 0.15), so they are mapped onto 0–1 to mean what you'd
+expect — ≥0.75 "detector is sure", 0.4–0.75 "probably right, glance at the
+preview", <0.4 "borderline accept, verify". The raw detector score is kept
+on each field as `raw_score`.
+
+The correction loop (`render_preview` → `add/update/remove_field`) exists
+precisely because ML detection has false positives and negatives. A false
+positive costs nothing (leave it unfilled or remove it); a false negative is
+visible on the preview and fixable with one `add_field` call. Once reviewed,
+`save_template` makes every future fill of that form deterministic.
+
+## Setup
+
+```bash
+uv tool install ./mcp-server        # or: pip install ./mcp-server
+```
+
+Authorize once (opens the browser, one click while logged in to justfill.app):
+
+```bash
+justfill-mcp login
+```
+
+Then the config needs no credentials at all:
+
+```json
+{
+  "mcpServers": {
+    "justfill": { "command": "justfill-mcp" }
+  }
+}
+```
+
+Alternatives, in the order the server checks them:
+
+1. `JUSTFILL_API_KEY` env — create a key at justfill.app → Account → API Keys
+   and put `"env": {"JUSTFILL_API_KEY": "jf_live_…"}` in the config.
+2. The key saved by `justfill-mcp login` (`~/.config/justfill/credentials.json`).
+3. `JUSTFILL_EMAIL` + `JUSTFILL_PASSWORD` — legacy fallback; an API key is
+   better (no password in config files, revocable per client, never expires
+   mid-session).
+
+## Tools
+
+- `open_pdf(path, min_confidence=0.0, max_pages=10, force_detect=False)` —
+  template → AcroForm → ML resolution order. Accepts scanned images too
+  (jpg/png/tiff → converted to PDF, deterministically, so templates still
+  match). `force_detect=True` ignores a saved template and re-runs ML.
+- `render_preview(page_index)` — page image with labeled field boxes (blue = deterministic, green/orange/red = ML confidence)
+- `render_filled_preview(values, page_index)` — the same page with your values
+  drawn in place (checkboxes get an X). Costs no fills — check before you fill.
+- `list_fields(page_index?)`
+- `add_field(x, y, w, h, name, page_index, field_type, align?, vertical_align?)` — coords in % of page, top-left origin
+- `update_field(field_id, …)` / `remove_field(field_id)`
+- `update_fields([{field_id, …}, …])` / `remove_fields([ids])` — batch versions
+- `prune_fields(field_type?, confidence_below?, width_below?, height_below?, page_index?, exclude_ids?)` —
+  bulk-delete detection noise in one call (criteria AND-ed, removed ids returned)
+- `fill_pdf(values, output_path, flatten=True)` — `values` = `{field_id: text}`;
+  responds with `warnings` for values that will be shrunk/truncated to fit
+- `save_template(name)` — persist the reviewed layout for deterministic repeat fills
+- `list_templates()`
+
+Text alignment: `align` = `left|center|right`, `vertical_align` =
+`top|middle|bottom` — set per field (e.g. `right` for RTL forms, `center` for
+boxed digits). Persisted in templates.
+
+## Example agent flow
+
+```
+open_pdf("~/forms/w-9.pdf")            → acroform, 27 fields, confidence 1.0
+fill_pdf({"f1": "Jane Doe", …}, "~/out/w-9-filled.pdf")
+```
+
+```
+open_pdf("~/forms/scan.jpg")           → converted to PDF; ml, 34 fields
+render_preview(0)                      → agent sees noise + one missed line
+prune_fields(field_type="cell", width_below=3)   → 16 removed in one call
+add_field(x=18, y=62.5, w=40, h=3, name="Phone")
+render_filled_preview({…})             → values sit right, no overflow
+fill_pdf({…}, "~/out/filled.pdf")
+save_template("Client intake form")    → next time: deterministic
+```
+
+## Notes
+
+- Auth is a regular justfill.app account; tokens auto-refresh on expiry.
+- Detection is free; downloads consume the account's fill allowance/credits
+  (same rules as the web app).
+- One PDF open at a time per server session (by design — keeps ids stable).

justfill_mcp-0.4.0/pyproject.toml

@@ -0,0 +1,33 @@
+[project]
+name = "justfill-mcp"
+version = "0.4.0"
+description = "JustFill MCP server — let AI agents detect, review and fill PDF form fields via justfill.app"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+keywords = ["mcp", "pdf", "forms", "form-filling", "ai-agents", "claude", "model-context-protocol"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Topic :: Office/Business",
+]
+dependencies = [
+    "mcp>=1.2.0",
+    "httpx>=0.24.0",
+    "pillow>=10.0.0",
+    "pypdf>=4.0.0",
+]
+
+[project.urls]
+Homepage = "https://justfill.app"
+
+[project.scripts]
+justfill-mcp = "justfill_mcp.server:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/justfill_mcp"]

justfill_mcp-0.4.0/src/justfill_mcp/__init__.py

@@ -0,0 +1,3 @@
+"""JustFill MCP server package."""
+
+__version__ = "0.4.0"

justfill_mcp-0.4.0/src/justfill_mcp/api_client.py

@@ -0,0 +1,181 @@
+"""HTTP client for the JustFill API.
+
+Auth, preferred: a per-user API key (`JUSTFILL_API_KEY`, format `jf_live_…`,
+created at justfill.app → Account → API keys) sent as `Authorization: Bearer`.
+Keys don't expire, so no refresh logic is needed.
+
+Auth, fallback (email+password): POST /api/auth/token sets an httpOnly
+`access_token` cookie whose value is the JWT itself. We lift it out of the
+cookie jar and send it as a Bearer header instead — cookie-less requests
+bypass the CSRF origin check (which only guards cookie-authenticated
+mutations) and work from any non-browser client. Tokens are short-lived
+(~30 min), so any 401 triggers a single transparent re-login + retry.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Any
+
+import httpx
+
+
+class JustFillAuthError(RuntimeError):
+    pass
+
+
+class JustFillApiError(RuntimeError):
+    def __init__(self, status: int, detail: str):
+        self.status = status
+        super().__init__(f"JustFill API error {status}: {detail}")
+
+
+class JustFillClient:
+    def __init__(
+        self,
+        base_url: str | None = None,
+        email: str | None = None,
+        password: str | None = None,
+        api_key: str | None = None,
+        timeout: float = 180.0,
+    ):
+        self.base_url = (base_url or os.getenv("JUSTFILL_API_URL", "https://justfill.app")).rstrip("/")
+        self.email = email or os.getenv("JUSTFILL_EMAIL", "")
+        self.password = password or os.getenv("JUSTFILL_PASSWORD", "")
+        self.api_key = api_key or os.getenv("JUSTFILL_API_KEY", "")
+        if not self.api_key and not (self.email and self.password):
+            # `justfill-mcp login` stores a key in ~/.config/justfill/
+            from justfill_mcp.login import load_stored_api_key
+            self.api_key = load_stored_api_key() or ""
+        self._token: str | None = self.api_key or None
+        self._http = httpx.Client(timeout=timeout, follow_redirects=True)
+
+    # ---------- auth ----------
+
+    def _login(self) -> None:
+        if self.api_key:
+            # API keys don't expire — a 401 with one means it was revoked.
+            raise JustFillAuthError(
+                "JUSTFILL_API_KEY was rejected (revoked or invalid). "
+                "Create a new key at justfill.app."
+            )
+        if not self.email or not self.password:
+            raise JustFillAuthError(
+                "Not authorized. Run `justfill-mcp login` (opens the browser), "
+                "or set JUSTFILL_API_KEY, or JUSTFILL_EMAIL and JUSTFILL_PASSWORD."
+            )
+        resp = self._http.post(
+            f"{self.base_url}/api/auth/token",
+            data={"username": self.email, "password": self.password},
+        )
+        if resp.status_code != 200:
+            raise JustFillAuthError(f"Login failed ({resp.status_code}): {resp.text[:200]}")
+        token = resp.cookies.get("access_token") or self._http.cookies.get("access_token")
+        if not token:
+            raise JustFillAuthError("Login succeeded but no access_token cookie was returned.")
+        self._token = token
+        # Bearer-only from here on: cookies must NOT ride along or the CSRF
+        # origin guard will 403 mutating requests from non-browser clients.
+        self._http.cookies.clear()
+
+    def _request(self, method: str, path: str, *, _retried: bool = False, **kwargs) -> httpx.Response:
+        if self._token is None:
+            self._login()
+        headers = kwargs.pop("headers", {})
+        headers["Authorization"] = f"Bearer {self._token}"
+        resp = self._http.request(method, f"{self.base_url}{path}", headers=headers, **kwargs)
+        if resp.status_code == 401 and not _retried:
+            self._token = None
+            return self._request(method, path, _retried=True, headers=headers, **kwargs)
+        if resp.status_code >= 400:
+            raise JustFillApiError(resp.status_code, resp.text[:500])
+        return resp
+
+    # ---------- endpoints ----------
+
+    def render_page(self, pdf_bytes: bytes, page: int = 0, dpi: int = 150) -> dict[str, Any]:
+        """POST /api/pdfs/render -> {imageBase64, width, height, pageCount}"""
+        resp = self._request(
+            "POST",
+            f"/api/pdfs/render?page={page}&dpi={dpi}",
+            files={"file": ("document.pdf", pdf_bytes, "application/pdf")},
+        )
+        return resp.json()
+
+    def detect_fillable(self, pdf_bytes: bytes) -> dict[str, Any]:
+        """POST /api/analyze/detect-fillable -> {isFillable, fields, pageCount, warnings}"""
+        resp = self._request(
+            "POST",
+            "/api/analyze/detect-fillable",
+            files={"pdf_file": ("document.pdf", pdf_bytes, "application/pdf")},
+        )
+        return resp.json()
+
+    # 200 DPI matches the detector's training resolution — same default the web
+    # UI uses. Measured recall 0.944 @200 vs 0.917 @300 (test_dpi_recall.py);
+    # rendering above the training resolution hurts.
+    def detect_fields_batch(self, pdf_b64: str, pages: list[int], dpi: int = 200) -> dict[str, Any]:
+        """POST /api/detect-fields/batch -> {results: [{pageIndex, imageWidth, imageHeight, fields}], creditsCharged}"""
+        resp = self._request(
+            "POST",
+            "/api/detect-fields/batch",
+            json={"pdfBase64": pdf_b64, "pages": pages, "dpi": dpi},
+        )
+        return resp.json()
+
+    def calibrations_by_hash(self, content_hash: str, include_others: bool = True) -> list[dict[str, Any]]:
+        """GET /api/calibrations/by-hash/{hash} -> own calibrations + published templates."""
+        resp = self._request(
+            "GET",
+            f"/api/calibrations/by-hash/{content_hash}?include_others={'true' if include_others else 'false'}",
+        )
+        data = resp.json()
+        return data.get("items", data) if isinstance(data, dict) else data
+
+    def save_calibration(
+        self,
+        document_id: str,
+        content_hash: str,
+        name: str,
+        fields: list[dict[str, Any]],
+        pdf_bytes: bytes | None,
+    ) -> dict[str, Any]:
+        """PUT /api/calibrations/{document_id} (multipart upsert)."""
+        import json as _json
+
+        calibration = {
+            "documentId": document_id,
+            "contentHash": content_hash,
+            "documentName": name,
+            "displayName": name,
+            "fields": fields,
+        }
+        files: dict[str, Any] = {"calibration_data": (None, _json.dumps(calibration))}
+        if pdf_bytes is not None:
+            files["pdf_file"] = ("document.pdf", pdf_bytes, "application/pdf")
+        resp = self._request("PUT", f"/api/calibrations/{document_id}", files=files)
+        return resp.json()
+
+    def list_calibrations(self, limit: int = 50) -> dict[str, Any]:
+        resp = self._request("GET", f"/api/calibrations?limit={limit}")
+        return resp.json()
+
+    def generate_pdf(
+        self,
+        pdf_bytes: bytes,
+        fields_json: str,
+        flatten: bool = True,
+    ) -> tuple[bytes, str]:
+        """POST /api/generate/pdf -> (filled PDF bytes, output_mode).
+
+        output_mode mirrors the X-Output-Mode header: "clean", or
+        "watermarked" when the account's free fills are used up — the agent
+        must be told, or it silently delivers a watermarked document.
+        """
+        resp = self._request(
+            "POST",
+            "/api/generate/pdf",
+            files={"pdf_file": ("document.pdf", pdf_bytes, "application/pdf")},
+            data={"fields_json": fields_json, "flatten": "true" if flatten else "false"},
+        )
+        return resp.content, resp.headers.get("X-Output-Mode", "clean")

justfill_mcp-0.4.0/src/justfill_mcp/login.py

@@ -0,0 +1,105 @@
+"""`justfill-mcp login` — browser-based authorization (no password in config).
+
+Starts a one-shot loopback HTTP listener, opens https://justfill.app/authorize
+in the browser, the logged-in user clicks Authorize, and the freshly minted
+API key arrives at http://127.0.0.1:PORT/callback?key=... The key is stored in
+~/.config/justfill/credentials.json (0600); the API client picks it up
+automatically when JUSTFILL_API_KEY is not set.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import socket
+import sys
+import threading
+import webbrowser
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from pathlib import Path
+from urllib.parse import parse_qs, quote, urlparse
+
+LOGIN_TIMEOUT_S = 300
+
+_DONE_HTML = """<!doctype html><meta charset="utf-8">
+<title>JustFill — authorized</title>
+<body style="font-family:system-ui;display:grid;place-items:center;height:90vh">
+<div style="text-align:center">
+<h2>&#9989; JustFill MCP is authorized</h2>
+<p>You can close this tab and return to your terminal.</p>
+</div></body>""".encode()
+
+
+def credentials_path() -> Path:
+    base = os.getenv("XDG_CONFIG_HOME") or str(Path.home() / ".config")
+    return Path(base) / "justfill" / "credentials.json"
+
+
+def load_stored_api_key() -> str | None:
+    """Read the API key saved by `justfill-mcp login`, if any."""
+    try:
+        data = json.loads(credentials_path().read_text())
+        return data.get("api_key") or None
+    except Exception:
+        return None
+
+
+def _save(key: str, app_url: str) -> Path:
+    path = credentials_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps({"api_key": key, "app_url": app_url}, indent=1))
+    path.chmod(0o600)
+    return path
+
+
+def main() -> int:
+    app_url = (os.getenv("JUSTFILL_APP_URL") or "https://justfill.app").rstrip("/")
+    result: dict = {}
+    ready = threading.Event()
+
+    class Handler(BaseHTTPRequestHandler):
+        def do_GET(self):  # noqa: N802
+            parsed = urlparse(self.path)
+            if parsed.path != "/callback":
+                self.send_response(404); self.end_headers()
+                return
+            key = (parse_qs(parsed.query).get("key") or [""])[0]
+            if key.startswith("jf_"):
+                result["key"] = key
+            self.send_response(200)
+            self.send_header("Content-Type", "text/html; charset=utf-8")
+            self.end_headers()
+            self.wfile.write(_DONE_HTML)
+            ready.set()
+
+        def log_message(self, *args):  # silence request logging
+            pass
+
+    # OS-assigned free loopback port
+    with socket.socket() as probe:
+        probe.bind(("127.0.0.1", 0))
+        port = probe.getsockname()[1]
+    server = HTTPServer(("127.0.0.1", port), Handler)
+    threading.Thread(target=server.serve_forever, daemon=True).start()
+
+    url = f"{app_url}/authorize?port={port}&name={quote('MCP on ' + (os.uname().nodename if hasattr(os, 'uname') else 'this computer'))}"
+    print("Opening your browser to authorize JustFill MCP…")
+    print(f"If it does not open, visit:\n  {url}\n")
+    webbrowser.open(url)
+
+    if not ready.wait(timeout=LOGIN_TIMEOUT_S) or "key" not in result:
+        server.shutdown()
+        print("Authorization timed out or no key was received.", file=sys.stderr)
+        print("You can also create a key manually at "
+              f"{app_url}/account and set JUSTFILL_API_KEY.", file=sys.stderr)
+        return 1
+    server.shutdown()
+
+    path = _save(result["key"], app_url)
+    print(f"Authorized. API key saved to {path}")
+    print("justfill-mcp will use it automatically — no env vars needed.")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())