mdgate 2.0.0__tar.gz

mdgate-2.0.0/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: mdgate
+Version: 2.0.0
+Summary: Serve markdown files as mobile-friendly web pages over Tailscale
+License-Expression: ISC
+Requires-Python: >=3.11
+Requires-Dist: mistune>=3.0
+Requires-Dist: pygments>=2.17

mdgate-2.0.0/pyproject.toml

@@ -0,0 +1,20 @@
+[project]
+name = "mdgate"
+version = "2.0.0"
+description = "Serve markdown files as mobile-friendly web pages over Tailscale"
+requires-python = ">=3.11"
+license = "ISC"
+dependencies = [
+    "mistune>=3.0",
+    "pygments>=2.17",
+]
+
+[project.scripts]
+mdgate = "mdgate.cli:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/mdgate"]

mdgate-2.0.0/src/mdgate/__init__.py

@@ -0,0 +1 @@
+__version__ = "2.0.0"

mdgate-2.0.0/src/mdgate/__main__.py

@@ -0,0 +1,3 @@
+from mdgate.cli import main
+
+main()

mdgate-2.0.0/src/mdgate/cli.py

@@ -0,0 +1,171 @@
+from __future__ import annotations
+
+import json
+import os
+import signal
+import sys
+from pathlib import Path
+from urllib.request import Request, urlopen
+from urllib.error import URLError
+
+from .config import load_config, init_config
+
+
+def main():
+    args = sys.argv[1:]
+    config = load_config()
+
+    if not args or "--help" in args or "-h" in args:
+        _cmd_help(config)
+        return
+
+    if "--init" in args:
+        _cmd_init(args)
+        return
+
+    if "--stop" in args:
+        _cmd_stop()
+        return
+
+    if "--status" in args:
+        _cmd_status()
+        return
+
+    is_review = args[0] == "review"
+    is_daemon = "--daemon" in args
+    effective_args = args[1:] if is_review else args
+
+    port = config["port"]
+    file_path = None
+    share_name = None
+    share_enabled = False
+
+    i = 0
+    while i < len(effective_args):
+        arg = effective_args[i]
+        if arg in ("-p", "--port") and i + 1 < len(effective_args):
+            port = int(effective_args[i + 1])
+            i += 2
+            continue
+        elif arg == "--share":
+            share_enabled = True
+        elif arg.startswith("--share="):
+            share_enabled = True
+            share_name = arg.removeprefix("--share=")
+        elif not arg.startswith("-"):
+            file_path = str(Path(arg).resolve())
+        i += 1
+
+    if is_daemon:
+        from .server import start_server
+        start_server(None, port, config["hosts"], daemon=True)
+        if share_enabled:
+            from .zrok import start_zrok
+            start_zrok(port, share_name)
+    elif not file_path:
+        print("Error: No markdown file specified", file=sys.stderr)
+        sys.exit(1)
+    elif not Path(file_path).exists():
+        print(f"Error: File not found: {file_path}", file=sys.stderr)
+        sys.exit(1)
+    elif is_review:
+        from .server import start_server
+        comments = start_server(file_path, port, config["hosts"], review_mode=True)
+        print(json.dumps(comments, indent=2))
+        sys.exit(0)
+    else:
+        _cmd_serve(file_path, port, config["hosts"], share_enabled, share_name)
+
+
+def _cmd_serve(file_path: str, port: int, hosts: list[str], share_enabled: bool, share_name: str | None):
+    if _is_server_running(port):
+        slug = _register_with_running_server(file_path, port)
+        print(f"Registered: http://localhost:{port}/{slug}/")
+        for h in hosts:
+            print(f"            http://{h}:{port}/{slug}/")
+    else:
+        from .server import start_server
+        if share_enabled:
+            from .zrok import start_zrok
+            start_zrok(port, share_name)
+        start_server(file_path, port, hosts)
+
+
+def _is_server_running(port: int) -> bool:
+    try:
+        req = Request(f"http://127.0.0.1:{port}/health")
+        with urlopen(req, timeout=2) as resp:
+            data = json.loads(resp.read())
+            return data.get("status") == "ok"
+    except Exception:
+        return False
+
+
+def _register_with_running_server(file_path: str, port: int) -> str:
+    abs_file = str(Path(file_path).resolve())
+    base_dir = str(Path(abs_file).parent)
+    body = json.dumps({"filePath": abs_file, "baseDir": base_dir}).encode()
+    req = Request(f"http://127.0.0.1:{port}/_api/register", data=body,
+                  headers={"Content-Type": "application/json"}, method="POST")
+    with urlopen(req, timeout=5) as resp:
+        data = json.loads(resp.read())
+        return data["slug"]
+
+
+def _cmd_help(config: dict):
+    print(f"""mdgate — Serve markdown files as mobile-friendly web pages
+
+Usage:
+  mdgate <file.md>                  Register and serve a markdown file
+  mdgate review <file.md>           Serve for review, block until submitted
+  mdgate --daemon                   Start server without a document (background mode)
+  mdgate --init <host1> [host2...]  Set Tailscale hostnames
+  mdgate --stop                     Stop the running server
+  mdgate --status                   Check server status
+
+Options:
+  -p, --port <port>        Port to listen on (default: {config['port']})
+  --share[=name]           Expose via zrok (optional fixed name)
+  -h, --help               Show this help
+
+Documents persist across server restarts.
+Remove documents from the web dashboard at http://localhost:{config['port']}/
+
+Config: ~/.mdgate/config.json""")
+
+
+def _cmd_init(args: list[str]):
+    idx = args.index("--init")
+    hosts = [a for a in args[idx + 1:] if not a.startswith("-")]
+    if not hosts:
+        print("Usage: mdgate --init <host1> [host2...]", file=sys.stderr)
+        sys.exit(1)
+    init_config(hosts)
+
+
+def _cmd_stop():
+    pid_file = Path.home() / ".mdgate" / "server.pid"
+    if pid_file.exists():
+        pid = int(pid_file.read_text().strip())
+        try:
+            os.kill(pid, signal.SIGTERM)
+            pid_file.unlink(missing_ok=True)
+            print(f"Stopped mdgate server (pid {pid})")
+        except ProcessLookupError:
+            pid_file.unlink(missing_ok=True)
+            print("Server was not running (stale pid file removed)")
+    else:
+        print("No mdgate server is running")
+
+
+def _cmd_status():
+    pid_file = Path.home() / ".mdgate" / "server.pid"
+    if pid_file.exists():
+        pid = int(pid_file.read_text().strip())
+        try:
+            os.kill(pid, 0)
+            print(f"mdgate server is running (pid {pid})")
+        except ProcessLookupError:
+            print("mdgate server is not running (stale pid file)")
+    else:
+        print("No mdgate server is running")

mdgate-2.0.0/src/mdgate/comments.py

@@ -0,0 +1,60 @@
+import json
+import time
+import random
+import string
+from datetime import datetime, timezone
+from pathlib import Path
+
+
+def _comments_path(md_abs_path: str) -> Path:
+    return Path(md_abs_path + ".comments.json")
+
+
+def _make_id() -> str:
+    t = int(time.time() * 1000)
+    rand = "".join(random.choices(string.ascii_lowercase + string.digits, k=4))
+    return f"{t:x}{rand}"
+
+
+def load_comments(md_abs_path: str) -> list[dict]:
+    try:
+        return json.loads(_comments_path(md_abs_path).read_text())
+    except Exception:
+        return []
+
+
+def add_comment(md_abs_path: str, section: str, text: str) -> dict:
+    comments = load_comments(md_abs_path)
+    entry = {
+        "id": _make_id(),
+        "section": section,
+        "text": text,
+        "ts": datetime.now(timezone.utc).isoformat(),
+    }
+    comments.append(entry)
+    _comments_path(md_abs_path).write_text(json.dumps(comments, indent=2) + "\n")
+    return entry
+
+
+def update_comment(md_abs_path: str, comment_id: str, new_text: str) -> dict | None:
+    comments = load_comments(md_abs_path)
+    comment = next((c for c in comments if c["id"] == comment_id), None)
+    if not comment:
+        return None
+    comment["text"] = new_text
+    comment["editedAt"] = datetime.now(timezone.utc).isoformat()
+    _comments_path(md_abs_path).write_text(json.dumps(comments, indent=2) + "\n")
+    return comment
+
+
+def clear_comments(md_abs_path: str):
+    _comments_path(md_abs_path).write_text("[]\n")
+
+
+def delete_comment(md_abs_path: str, comment_id: str) -> bool:
+    comments = load_comments(md_abs_path)
+    filtered = [c for c in comments if c["id"] != comment_id]
+    if len(filtered) == len(comments):
+        return False
+    _comments_path(md_abs_path).write_text(json.dumps(filtered, indent=2) + "\n")
+    return True

mdgate-2.0.0/src/mdgate/config.py

@@ -0,0 +1,23 @@
+import json
+from pathlib import Path
+
+CONFIG_DIR = Path.home() / ".mdgate"
+CONFIG_FILE = CONFIG_DIR / "config.json"
+
+DEFAULTS = {"port": 9483, "hosts": []}
+
+
+def load_config() -> dict:
+    try:
+        raw = json.loads(CONFIG_FILE.read_text())
+        return {**DEFAULTS, **raw}
+    except Exception:
+        return {**DEFAULTS}
+
+
+def init_config(hosts: list[str]) -> dict:
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    config = {**DEFAULTS, "hosts": hosts}
+    CONFIG_FILE.write_text(json.dumps(config, indent=2) + "\n")
+    print(f"Config written to {CONFIG_FILE}")
+    return config

mdgate-2.0.0/src/mdgate/registry.py

@@ -0,0 +1,60 @@
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+
+STATE_DIR = Path.home() / ".mdgate"
+REGISTRY_FILE = STATE_DIR / "registry.json"
+
+
+def load_registry() -> list[dict]:
+    try:
+        return json.loads(REGISTRY_FILE.read_text())
+    except Exception:
+        return []
+
+
+def save_registry(entries: list[dict]):
+    STATE_DIR.mkdir(parents=True, exist_ok=True)
+    REGISTRY_FILE.write_text(json.dumps(entries, indent=2) + "\n")
+
+
+def _make_slug(file_path: str) -> str:
+    p = Path(file_path)
+    parent = p.parent.name
+    name = p.stem
+    return f"{parent}/{name}"
+
+
+def add_entry(file_path: str, base_dir: str) -> str:
+    entries = load_registry()
+    abs_path = str(Path(file_path).resolve())
+
+    existing = next((e for e in entries if e["filePath"] == abs_path), None)
+    if existing:
+        return existing["slug"]
+
+    base = _make_slug(abs_path)
+    slug = base
+    i = 2
+    while any(e["slug"] == slug for e in entries):
+        slug = f"{base}-{i}"
+        i += 1
+
+    entries.append({
+        "slug": slug,
+        "filePath": abs_path,
+        "baseDir": str(Path(base_dir).resolve()),
+        "entryFile": Path(file_path).name,
+        "registeredAt": datetime.now(timezone.utc).isoformat(),
+    })
+    save_registry(entries)
+    return slug
+
+
+def remove_entry(slug: str) -> bool:
+    entries = load_registry()
+    filtered = [e for e in entries if e["slug"] != slug]
+    if len(filtered) == len(entries):
+        return False
+    save_registry(filtered)
+    return True