chatnut 0.3.0__tar.gz

chatnut-0.3.0/.gitignore

@@ -0,0 +1,15 @@
+__pycache__/
+*.pyc
+*.pyo
+*.egg-info/
+dist/
+build/
+.venv/
+*.db
+.pytest_cache/
+working-scope.md  # local task scoping file (worktree-specific, not committed)
+node_modules/
+.DS_Store
+.env
+.env.*
+!data/dev.db

chatnut-0.3.0/.python-version

@@ -0,0 +1 @@
+3.12

chatnut-0.3.0/PKG-INFO

@@ -0,0 +1,27 @@
+Metadata-Version: 2.4
+Name: chatnut
+Version: 0.3.0
+Summary: ChatNut — shared chatrooms for AI agent teams
+Project-URL: Repository, https://github.com/runno-ai/chatnut
+Project-URL: Homepage, https://github.com/runno-ai/chatnut
+Author-email: Runno AI <hi@runno.dev>
+License: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: FastAPI
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Communications :: Chat
+Requires-Python: >=3.12
+Requires-Dist: anyio>=4.0
+Requires-Dist: fastapi>=0.115.0
+Requires-Dist: fastmcp<4,>=3.0.0
+Requires-Dist: httpx>=0.28.0
+Requires-Dist: sse-starlette>=2.0.0
+Requires-Dist: uvicorn[standard]>=0.34.0
+Provides-Extra: test
+Requires-Dist: httpx>=0.28.0; extra == 'test'
+Requires-Dist: pytest-anyio>=0.0.0; extra == 'test'
+Requires-Dist: pytest-asyncio>=0.24; extra == 'test'
+Requires-Dist: pytest>=8.0; extra == 'test'

chatnut-0.3.0/chatnut/__main__.py

@@ -0,0 +1,4 @@
+"""Allow running as python -m chatnut."""
+from chatnut.cli import main
+
+main()

chatnut-0.3.0/chatnut/app.py

@@ -0,0 +1,103 @@
+# chatnut/app.py
+"""FastAPI application — mounts MCP + REST/SSE routes + static file serving."""
+
+import asyncio
+import logging
+import os
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
+from functools import lru_cache
+from pathlib import Path
+
+from fastapi import FastAPI
+from fastapi.responses import FileResponse, JSONResponse
+from fastmcp.utilities.lifespan import combine_lifespans
+
+logger = logging.getLogger(__name__)
+
+AUTO_ARCHIVE_INTERVAL = 300  # check every 5 minutes
+AUTO_ARCHIVE_INACTIVE_SECONDS = 7200  # archive after 2 hours of inactivity
+
+from chatnut.config import DB_PATH
+from chatnut.db import init_db
+from chatnut.service import ChatService
+from chatnut import mcp as mcp_module
+from chatnut.mcp import mcp
+from chatnut.routes import create_router
+
+
+def _default_static_dir() -> str:
+    """Return the package-internal static/ directory path."""
+    return str(Path(__file__).parent / "static")
+
+
+STATIC_DIR = os.environ.get("STATIC_DIR", _default_static_dir())
+
+
+@lru_cache(maxsize=1)
+def _get_service() -> ChatService:
+    db_conn = init_db(DB_PATH)
+    return ChatService(db_conn)
+
+
+# Wire MCP tools to use the same service instance as REST routes
+mcp_module.set_service_factory(_get_service)
+
+# Get MCP ASGI sub-app — path="/" so mount("/mcp") serves at /mcp (not /mcp/mcp)
+mcp_app = mcp.http_app(path="/", transport="streamable-http")
+
+
+async def _auto_archive_loop() -> None:
+    """Periodically archive stale live rooms."""
+    while True:
+        await asyncio.sleep(AUTO_ARCHIVE_INTERVAL)
+        try:
+            archived = _get_service().auto_archive_stale_rooms(AUTO_ARCHIVE_INACTIVE_SECONDS)
+            if archived:
+                names = [r["name"] for r in archived]
+                logger.info("Auto-archived %d stale rooms: %s", len(archived), names)
+        except Exception:
+            logger.exception("Auto-archive failed")
+
+
+@asynccontextmanager
+async def app_lifespan(_app: FastAPI) -> AsyncIterator[None]:
+    # Ensure service is initialized at startup
+    _get_service()
+    mcp_module.set_event_loop(asyncio.get_running_loop())
+    task = asyncio.create_task(_auto_archive_loop())
+    yield
+    task.cancel()
+    try:
+        await task
+    except asyncio.CancelledError:
+        pass
+    mcp_module.set_event_loop(None)  # Clear stale reference; _notify_waiters guards against closed loop
+
+
+app = FastAPI(
+    title="ChatNut",
+    lifespan=combine_lifespans(app_lifespan, mcp_app.lifespan),
+)
+
+# Mount MCP at /mcp — path="/" in http_app() + mount("/mcp") = /mcp
+app.mount("/mcp", mcp_app)
+
+# Mount API routes
+api_router = create_router(_get_service)
+app.include_router(api_router)
+
+
+# Serve React SPA — static files + fallback to index.html
+@app.get("/{full_path:path}")
+async def serve_spa(full_path: str):
+    static_dir = Path(STATIC_DIR).resolve()
+    file_path = (static_dir / full_path).resolve()
+    if not file_path.is_relative_to(static_dir):
+        return JSONResponse(status_code=404, content={"error": "Not found"})
+    if file_path.is_file():
+        return FileResponse(file_path)
+    index_path = static_dir / "index.html"
+    if index_path.is_file():
+        return FileResponse(index_path)
+    return JSONResponse(status_code=503, content={"error": "Frontend not built. Run: cd app/fe && bun run build"})

chatnut-0.3.0/chatnut/cli.py

@@ -0,0 +1,182 @@
+"""CLI entry point for chatnut.
+
+Usage:
+    chatnut          # stdio mode (default) — proxy to HTTP server
+    chatnut serve    # run HTTP server in foreground
+"""
+import argparse
+import atexit
+import os
+import signal
+import socket
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+import httpx
+
+
+def _get_run_dir() -> Path:
+    """Return the runtime directory for PID/port files."""
+    return Path(os.environ.get("CHATNUT_RUN_DIR", Path.home() / ".chatnut"))
+
+
+def _find_free_port() -> int:
+    """Find a free high port by binding to port 0."""
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.bind(("127.0.0.1", 0))
+        return s.getsockname()[1]
+
+
+def _cleanup_files(run_dir: Path) -> None:
+    """Remove PID and port files."""
+    for f in ("server.pid", "server.port"):
+        (run_dir / f).unlink(missing_ok=True)
+
+
+def cmd_serve(args: argparse.Namespace) -> None:
+    """Run the full FastAPI server in foreground."""
+    import uvicorn
+
+    run_dir = _get_run_dir()
+    run_dir.mkdir(parents=True, exist_ok=True)
+
+    port = args.port if args.port else _find_free_port()
+
+    pid_file = run_dir / "server.pid"
+    pid_file.write_text(str(os.getpid()))
+
+    def cleanup(*_args):
+        _cleanup_files(run_dir)
+        sys.exit(0)
+
+    signal.signal(signal.SIGTERM, cleanup)
+    signal.signal(signal.SIGINT, cleanup)
+    atexit.register(_cleanup_files, run_dir)
+
+    port_file = run_dir / "server.port"
+
+    class _ReadyServer(uvicorn.Server):
+        """Uvicorn Server subclass that writes the port file after startup."""
+
+        async def startup(self, sockets=None):
+            await super().startup(sockets=sockets)
+            if self.started:
+                port_file.write_text(str(port))
+
+    config = uvicorn.Config(
+        "chatnut.app:app",
+        host="127.0.0.1",
+        port=port,
+        log_level="info",
+    )
+    server = _ReadyServer(config)
+    server.run()
+
+
+def _is_server_running() -> bool:
+    """Check if the HTTP server is alive (PID exists + health check passes)."""
+    run_dir = _get_run_dir()
+    pid_file = run_dir / "server.pid"
+    port_file = run_dir / "server.port"
+
+    if not pid_file.exists() or not port_file.exists():
+        return False
+
+    try:
+        pid = int(pid_file.read_text().strip())
+        os.kill(pid, 0)
+    except (OSError, ValueError):
+        _cleanup_files(run_dir)
+        return False
+
+    try:
+        port = int(port_file.read_text().strip())
+        resp = httpx.get(f"http://127.0.0.1:{port}/api/status", timeout=2)
+        return resp.status_code == 200
+    except Exception:
+        return False
+
+
+def _get_server_url() -> str | None:
+    """Read server URL from port file."""
+    port_file = _get_run_dir() / "server.port"
+    if not port_file.exists():
+        return None
+    try:
+        port = int(port_file.read_text().strip())
+        return f"http://127.0.0.1:{port}"
+    except (ValueError, OSError):
+        return None
+
+
+def _ensure_server() -> str:
+    """Ensure the HTTP server is running. Returns the server URL."""
+    if _is_server_running():
+        url = _get_server_url()
+        if url:
+            return url
+
+    run_dir = _get_run_dir()
+    run_dir.mkdir(parents=True, exist_ok=True)
+
+    # Redirect server output to a log file for debugging
+    log_file = run_dir / "server.log"
+    log_fh = open(log_file, "a")  # noqa: SIM115
+    subprocess.Popen(
+        [sys.executable, "-m", "chatnut.cli", "serve"],
+        stdout=log_fh,
+        stderr=log_fh,
+        start_new_session=True,
+    )
+    log_fh.close()
+
+    port_file = run_dir / "server.port"
+    for _ in range(20):
+        time.sleep(0.5)
+        if port_file.exists():
+            url = _get_server_url()
+            if url:
+                try:
+                    resp = httpx.get(f"{url}/api/status", timeout=2)
+                    if resp.status_code == 200:
+                        return url
+                except Exception:
+                    continue
+
+    raise RuntimeError("Failed to start chatnut server within 10 seconds")
+
+
+def cmd_stdio(args: argparse.Namespace) -> None:
+    """Run as stdio MCP proxy — auto-starts HTTP server if needed."""
+    import asyncio
+
+    from fastmcp import FastMCP
+    from fastmcp.server.providers.proxy import ProxyClient, ProxyProvider
+
+    server_url = _ensure_server()
+    mcp_url = f"{server_url}/mcp/"
+
+    proxy = FastMCP("agents-chat")
+    proxy.add_provider(ProxyProvider(lambda: ProxyClient(mcp_url)))
+
+    asyncio.run(proxy.run_stdio_async())
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(prog="chatnut")
+    sub = parser.add_subparsers(dest="command")
+
+    serve_parser = sub.add_parser("serve", help="Run HTTP server in foreground")
+    serve_parser.add_argument("--port", type=int, default=0, help="Port to bind (0 = auto)")
+    serve_parser.set_defaults(func=cmd_serve)
+
+    parser.set_defaults(func=cmd_stdio)
+
+    args = parser.parse_args()
+    args.func(args)
+
+
+if __name__ == "__main__":
+    main()

chatnut-0.3.0/chatnut/config.py

@@ -0,0 +1,5 @@
+"""Shared configuration constants."""
+
+import os
+
+DB_PATH = os.path.expanduser(os.environ.get("CHAT_DB_PATH", "~/.chatnut/chatnut.db"))