Pouzor
e6d338be13
The only writing surface was `device_inventory.notes`, a single TEXT column rendered as plain preformatted text. No structure, no links, no search, and nowhere to write anything that is not about one device. This adds markdown documents, a navigable tree and a Documentation section in the left rail — the first app-level view that is not a canvas. Model — three tables. `documents` (kind: device / node / design / page / folder), `document_revisions` capped at 50 per document, and a `documents_fts` FTS5 index. A document attaches to the *inventory row*, not to a node, so one device reads the same on every canvas. Every link is SET NULL and the title is denormalized: deleting a device or a canvas must never destroy what the user wrote. Foreign keys are off in this SQLite setup, so `doc_links.unlink_documents` clears those columns by hand in the nodes, scan and designs delete paths. FTS5 is optional. The SQLite shipped in the LXC and Docker images may not carry it — `doc_search` probes once at boot and falls back to LIKE, and the search response names the engine it used so the UI can drop snippet highlighting. A device document is scaffolded once, from the scan facts: identity table, hardware, services (one section per service), network, operations, troubleshooting, dependencies, changelog. Then it belongs to the user and nothing rewrites it. The old `notes` are appended verbatim under `## Notes` behind a provenance comment, and `device_inventory.notes` is left untouched — HACS, the YAML export, MCP and canvas search still read it. Drift is surfaced, never corrected: `facts_snapshot` powers a banner, and `GET /documents/blocks` re-renders one generated block from current facts for the editor's slash commands. `review_every` plus `reviewed_at` produce a "needs attention" bucket, because homelab docs die of staleness. The Devices tree is pivoted client-side from the already-loaded inventory — zone, group, type, physical/virtual, subnet, rack, vendor, discovery source, status, tag, A-Z — so re-pivoting costs no request. The Library beside it is real folders the user makes. The Canvas pivot is scoped to the loaded canvas: `NodeData` carries no `design_id`, so naming every canvas a device appears on would be a guess. Saving is explicit, per the product rule. The dirty body is mirrored to localStorage and offered back on reopen; a draft whose base no longer matches the document is discarded rather than replayed. react-markdown is loaded behind React.lazy, so the canvas path does not pay for it: the main bundle is unchanged and the section brings its own 199 kB chunk. Raw HTML is not rendered, which removes the XSS surface and means no sanitizer. Export/import, a print view, an aggregated open-tasks view and images inside a document are deliberately not in this lot. MCP tools are lot 2. ha-relevant: yes
103 lines
3.7 KiB
Python
103 lines
3.7 KiB
Python
import logging
|
|
import logging.config
|
|
from collections.abc import AsyncGenerator
|
|
from contextlib import asynccontextmanager
|
|
from typing import Any
|
|
|
|
from fastapi import FastAPI
|
|
from fastapi.middleware.cors import CORSMiddleware
|
|
from starlette.middleware.sessions import SessionMiddleware
|
|
|
|
from app.api.routes import (
|
|
auth,
|
|
canvas,
|
|
designs,
|
|
documents,
|
|
edges,
|
|
liveview,
|
|
media,
|
|
nodes,
|
|
proxmox,
|
|
racks,
|
|
scan,
|
|
stats,
|
|
status,
|
|
zigbee,
|
|
zwave,
|
|
)
|
|
from app.api.routes import settings as settings_routes
|
|
from app.core.config import settings
|
|
from app.core.scheduler import start_scheduler, stop_scheduler
|
|
from app.core.security import OIDCCSRFMiddleware
|
|
from app.db.database import AsyncSessionLocal, init_db
|
|
from app.services.scanner import reconcile_orphan_runs
|
|
|
|
|
|
@asynccontextmanager
|
|
async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
|
|
# Ensure app logs are visible: attach a handler to the root logger if none
|
|
# exists (uvicorn only installs handlers on its own loggers, not the root).
|
|
root_logger = logging.getLogger()
|
|
if not root_logger.handlers:
|
|
handler = logging.StreamHandler()
|
|
handler.setFormatter(logging.Formatter("%(levelname)s:%(name)s:%(message)s"))
|
|
root_logger.addHandler(handler)
|
|
root_logger.setLevel(logging.INFO)
|
|
logging.getLogger("app").setLevel(logging.INFO)
|
|
logging.getLogger("app.services.scanner").setLevel(logging.INFO)
|
|
await init_db()
|
|
settings.load_overrides()
|
|
# A scan runs on a background thread in this process, so anything still
|
|
# flagged "running" now was orphaned by a previous one that died mid-scan.
|
|
async with AsyncSessionLocal() as db:
|
|
await reconcile_orphan_runs(db)
|
|
start_scheduler()
|
|
yield
|
|
stop_scheduler()
|
|
|
|
|
|
app = FastAPI(
|
|
title="Homelable API",
|
|
version="1.9.0",
|
|
lifespan=lifespan,
|
|
)
|
|
|
|
app.add_middleware(OIDCCSRFMiddleware)
|
|
app.add_middleware(
|
|
SessionMiddleware,
|
|
secret_key=settings.secret_key,
|
|
session_cookie=("__Host-homelable-oidc-flow" if settings.oidc_cookie_secure else "homelable-oidc-flow"),
|
|
max_age=settings.oidc_transaction_expire_seconds,
|
|
same_site="lax",
|
|
https_only=settings.oidc_cookie_secure,
|
|
)
|
|
app.add_middleware(
|
|
CORSMiddleware,
|
|
allow_origins=settings.cors_origins,
|
|
allow_credentials=True,
|
|
allow_methods=["GET", "POST", "PUT", "PATCH", "DELETE"],
|
|
allow_headers=["Authorization", "Content-Type", "X-Homelable-CSRF", "X-MCP-Service-Key"],
|
|
)
|
|
|
|
app.include_router(auth.router, prefix="/api/v1/auth", tags=["auth"])
|
|
app.include_router(nodes.router, prefix="/api/v1/nodes", tags=["nodes"])
|
|
app.include_router(edges.router, prefix="/api/v1/edges", tags=["edges"])
|
|
app.include_router(canvas.router, prefix="/api/v1/canvas", tags=["canvas"])
|
|
app.include_router(designs.router, prefix="/api/v1/designs", tags=["designs"])
|
|
app.include_router(racks.router, prefix="/api/v1/racks", tags=["racks"])
|
|
app.include_router(scan.router, prefix="/api/v1/scan", tags=["scan"])
|
|
app.include_router(status.router, prefix="/api/v1/status", tags=["status"])
|
|
app.include_router(settings_routes.router, prefix="/api/v1/settings", tags=["settings"])
|
|
app.include_router(liveview.router, prefix="/api/v1/liveview", tags=["liveview"])
|
|
app.include_router(zigbee.router, prefix="/api/v1/zigbee", tags=["zigbee"])
|
|
app.include_router(zwave.router, prefix="/api/v1/zwave", tags=["zwave"])
|
|
app.include_router(proxmox.router, prefix="/api/v1/proxmox", tags=["proxmox"])
|
|
app.include_router(stats.router, prefix="/api/v1/stats", tags=["stats"])
|
|
app.include_router(media.router, prefix="/api/v1/media", tags=["media"])
|
|
app.include_router(documents.router, prefix="/api/v1/documents", tags=["documents"])
|
|
|
|
|
|
@app.get("/api/v1/health")
|
|
async def health() -> dict[str, Any]:
|
|
return {"status": "ok"}
|