smorg 1.2.0__tar.gz

smorg-1.2.0/PKG-INFO

@@ -0,0 +1,61 @@
+Metadata-Version: 2.3
+Name: smorg
+Version: 1.2.0
+Summary: Keyboard-driven terminal dashboard, one tab per connected integration
+License: MIT
+Requires-Dist: httpx>=0.28
+Requires-Dist: keyring>=25.0
+Requires-Dist: pygithub>=2.5
+Requires-Dist: requests>=2.32
+Requires-Dist: textual>=1.0
+Requires-Dist: tomli-w>=1.0
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# smorg
+
+Short for [Smorgasbord](https://en.wikipedia.org/wiki/Smorgasbord): a table
+laid out with many dishes, everyone taking what they want.
+
+smorg is that table for your work — a keyboard-driven terminal dashboard with
+one tab per connected integration, showing what's on your plate and what
+changed since you last looked. It reads and opens things, never writes; it
+refreshes when you look at it, not on a timer. Nothing is enabled by default,
+and anyone can bring a dish: an integration is one directory and one registry
+line.
+
+## Install
+
+One-off run, no install:
+
+    uvx smorg
+
+That first run installs the package before the screen paints, so expect a
+brief blank terminal.
+
+To install it once and reuse it:
+
+    uv tool install smorg
+    smorg
+
+Press `^ + p` and pick "Add integration" to connect one, then select the
+desired connection method.
+
+`smorg connect <integration>` does the same from the CLI, and is also how you
+re-authenticate a tab whose token has expired or been revoked
+
+`smorg logout <integration>` (or "Remove integration" from `^ + p`) removes a tab,
+its stored token, and its seen marks.
+
+Inside the dashboard: `h`/`l` switch tabs, `up`/`down` select an item, `o`
+opens it in your browser, `r` refreshes, `m` marks the tab's changes seen,
+`u` marks the selected item unseen, `?` shows the current tab's keys, `^ + p`
+opens the menu (add/remove integrations, screenshots), `q` quits.
+
+## Status
+
+Two dishes on the table:
+* **Linear**, showing the issues assigned to you
+* **GitHub**, showing what needs your attention
+
+See [docs/ROADMAP.md](docs/ROADMAP.md) for what's ahead.

smorg-1.2.0/README.md

@@ -0,0 +1,47 @@
+# smorg
+
+Short for [Smorgasbord](https://en.wikipedia.org/wiki/Smorgasbord): a table
+laid out with many dishes, everyone taking what they want.
+
+smorg is that table for your work — a keyboard-driven terminal dashboard with
+one tab per connected integration, showing what's on your plate and what
+changed since you last looked. It reads and opens things, never writes; it
+refreshes when you look at it, not on a timer. Nothing is enabled by default,
+and anyone can bring a dish: an integration is one directory and one registry
+line.
+
+## Install
+
+One-off run, no install:
+
+    uvx smorg
+
+That first run installs the package before the screen paints, so expect a
+brief blank terminal.
+
+To install it once and reuse it:
+
+    uv tool install smorg
+    smorg
+
+Press `^ + p` and pick "Add integration" to connect one, then select the
+desired connection method.
+
+`smorg connect <integration>` does the same from the CLI, and is also how you
+re-authenticate a tab whose token has expired or been revoked
+
+`smorg logout <integration>` (or "Remove integration" from `^ + p`) removes a tab,
+its stored token, and its seen marks.
+
+Inside the dashboard: `h`/`l` switch tabs, `up`/`down` select an item, `o`
+opens it in your browser, `r` refreshes, `m` marks the tab's changes seen,
+`u` marks the selected item unseen, `?` shows the current tab's keys, `^ + p`
+opens the menu (add/remove integrations, screenshots), `q` quits.
+
+## Status
+
+Two dishes on the table:
+* **Linear**, showing the issues assigned to you
+* **GitHub**, showing what needs your attention
+
+See [docs/ROADMAP.md](docs/ROADMAP.md) for what's ahead.

smorg-1.2.0/pyproject.toml

@@ -0,0 +1,58 @@
+[project]
+name = "smorg"
+version = "1.2.0"
+description = "Keyboard-driven terminal dashboard, one tab per connected integration"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "httpx>=0.28",
+    "keyring>=25.0",
+    "pygithub>=2.5",
+    "requests>=2.32",
+    "textual>=1.0",
+    "tomli-w>=1.0",
+]
+
+[project.license]
+text = "MIT"
+
+[project.scripts]
+smorg = "smorg.cli:main"
+
+[dependency-groups]
+dev = [
+    "pytest>=8.0",
+    "pytest-asyncio>=0.24",
+    "ruff>=0.9",
+    "pyright>=1.1",
+]
+
+[build-system]
+requires = ["uv_build>=0.11,<0.13"]
+build-backend = "uv_build"
+
+[[tool.uv.index]]
+name = "pypi"
+url = "https://pypi.org/simple"
+default = true
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+asyncio_mode = "auto"
+
+[tool.pyright]
+venvPath = "."
+venv = ".venv"
+
+[tool.ruff]
+line-length = 100
+extend-exclude = ["docs"]
+
+[tool.ruff.lint]
+select = [
+    "E",
+    "F",
+    "I",
+    "UP",
+    "B",
+]

smorg-1.2.0/pyproject.toml.orig

@@ -0,0 +1,52 @@
+[project]
+name = "smorg"
+version = "1.2.0"
+description = "Keyboard-driven terminal dashboard, one tab per connected integration"
+readme = "README.md"
+requires-python = ">=3.12"
+license = { text = "MIT" }
+dependencies = [
+    "httpx>=0.28",
+    "keyring>=25.0",
+    "pygithub>=2.5",
+    "requests>=2.32",
+    "textual>=1.0",
+    "tomli-w>=1.0",
+]
+
+[project.scripts]
+smorg = "smorg.cli:main"
+
+[dependency-groups]
+dev = ["pytest>=8.0", "pytest-asyncio>=0.24", "ruff>=0.9", "pyright>=1.1"]
+
+[build-system]
+requires = ["uv_build>=0.11,<0.13"]
+build-backend = "uv_build"
+
+# Pinned so the lockfile resolves against public PyPI regardless of any index
+# mirror configured in the local environment. Without this a mirror's URLs leak
+# into uv.lock and CI cannot resolve them.
+[[tool.uv.index]]
+name = "pypi"
+url = "https://pypi.org/simple"
+default = true
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+asyncio_mode = "auto"
+
+# Pyright reads this directly, so import resolution does not depend on the
+# editor's Python extension discovering an interpreter.
+[tool.pyright]
+venvPath = "."
+venv = ".venv"
+
+[tool.ruff]
+line-length = 100
+# Ruff formats Python code blocks inside markdown; plan and spec snippets are
+# illustrative and must not be rewritten by the formatter.
+extend-exclude = ["docs"]
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B"]

smorg-1.2.0/src/smorg/__init__.py

@@ -0,0 +1,5 @@
+from importlib.metadata import version
+
+# smorg only ever runs installed — uv installs the project before running
+# anything — so an uninstalled import has nothing sensible to report.
+__version__ = version("smorg")

smorg-1.2.0/src/smorg/auth/login.py

@@ -0,0 +1,139 @@
+"""The browser-driven half of OAuth: run a loopback callback server, send the
+user to authorize, wait for the redirect, and exchange the code.
+
+Print-free: the caller decides how to surface the authorize URL
+(`on_authorize_url`) and whether the wait can be cancelled (`cancelled`).
+`cli.run_login` is the printing frontend; the in-app connect modal is the other.
+"""
+
+from __future__ import annotations
+
+import http.server
+import secrets
+import threading
+import time
+import urllib.parse
+import webbrowser
+from collections.abc import Callable
+
+import httpx
+
+from smorg.auth import oauth
+from smorg.auth.oauth import ProviderConfig
+from smorg.auth.store import Credentials
+from smorg.core.text import sanitize_line
+
+LOGIN_TIMEOUT_SECONDS = 300
+
+
+class LoginCancelled(oauth.OAuthError):
+    """The caller's `cancelled` event was set before the callback arrived."""
+
+
+def _callback_handler(
+    expected_state: str, received: dict[str, str]
+) -> type[http.server.BaseHTTPRequestHandler]:
+    class Handler(http.server.BaseHTTPRequestHandler):
+        def do_GET(self) -> None:
+            parsed = urllib.parse.urlparse(self.path)
+            parsed_query = urllib.parse.parse_qs(parsed.query)
+            query = {key: value[0] for key, value in parsed_query.items()}
+            # Only a request whose `state` matches this login's is accepted —
+            # a stray probe or a forged ?error= is refused without ending the
+            # wait. Compared as bytes, since compare_digest's str form raises
+            # on non-ASCII input.
+            if (
+                parsed.path != "/callback"
+                or not secrets.compare_digest(
+                    query.get("state", "").encode(), expected_state.encode()
+                )
+                or not query.keys() & {"code", "error"}
+            ):
+                self.send_response(404)
+                self.end_headers()
+                return
+            received.update(query)
+            self.send_response(200)
+            self.send_header("content-type", "text/plain; charset=utf-8")
+            self.end_headers()
+            self.wfile.write(b"smorg: authentication complete. You can close this tab.")
+
+        def log_message(self, format: str, *args: object) -> None:
+            """Silence the default access log, which would print over our output."""
+
+    return Handler
+
+
+def _cancellation_requested(cancelled: threading.Event | None) -> bool:
+    if cancelled is None:
+        return False
+    return cancelled.is_set()
+
+
+def perform_login(
+    client: httpx.Client,
+    provider: ProviderConfig,
+    client_id: str | None,
+    *,
+    on_authorize_url: Callable[[str], None],
+    cancelled: threading.Event | None = None,
+    port: int = 0,
+    timeout: float = LOGIN_TIMEOUT_SECONDS,
+) -> tuple[str, Credentials]:
+    """Register if needed, take the user through the browser, return the tokens.
+
+    Returns the client id alongside the credentials so a first-time
+    registration can be persisted for later logins to reuse. The callback
+    listens on an ephemeral port nothing else can predict or squat in
+    advance; see REGISTRATION_PORT for the fixed port named at registration.
+    """
+    verifier, challenge = oauth.make_pkce_pair()
+    state = secrets.token_urlsafe(16)
+    received: dict[str, str] = {}
+
+    try:
+        server = http.server.HTTPServer(("127.0.0.1", port), _callback_handler(state, received))
+    except OSError as error:
+        raise oauth.OAuthError(f"could not open a port for the callback: {error}") from error
+
+    try:
+        # Bound before the redirect is built so an ephemeral port resolves to
+        # the one actually listening.
+        redirect_uri = oauth.redirect_uri_for(server.server_port)
+        metadata = oauth.discover(client, provider)
+        if client_id is None:
+            client_id = oauth.register_client(
+                client, metadata, provider, oauth.REGISTERED_REDIRECT_URI
+            )
+
+        url = oauth.build_authorize_url(
+            metadata, client_id, redirect_uri, challenge, provider.scopes, state
+        )
+        on_authorize_url(url)
+        webbrowser.open(url)
+
+        # One deadline for the whole wait rather than per request, so a drip of
+        # stray requests cannot extend it indefinitely. cancelled is polled at
+        # the same 1-second granularity as the deadline.
+        server.timeout = 1.0  # seconds
+        deadline = time.monotonic() + timeout
+        while (
+            not received and time.monotonic() < deadline and not _cancellation_requested(cancelled)
+        ):
+            server.handle_request()
+
+        # A code that already arrived wins over a cancellation requested in
+        # the same instant — only an empty result can still be cancelled.
+        if not received:
+            if _cancellation_requested(cancelled):
+                raise LoginCancelled("login cancelled before the browser callback arrived")
+            raise oauth.OAuthError("timed out waiting for the browser callback")
+        if "error" in received:
+            raise oauth.OAuthError(f"authorization was refused: {sanitize_line(received['error'])}")
+
+        credentials = oauth.exchange_code(
+            client, metadata, client_id, received["code"], verifier, redirect_uri
+        )
+        return client_id, credentials
+    finally:
+        server.server_close()