@@ -1038,6 +1051,26 @@ onUnmounted(() => assist.clearSelection());
font-size: 0.92rem;
color: var(--color-primary);
}
+.prompt-editor {
+ width: 100%;
+ min-height: 60vh;
+ margin-top: 8px;
+ padding: 14px 16px;
+ border: 1px solid var(--color-border);
+ border-radius: 8px;
+ background: var(--color-surface);
+ color: var(--color-text);
+ /* Prompts are plain markdown β a code-style editor, not rich text. */
+ font-family: var(--font-mono, ui-monospace, SFMono-Regular, Menlo, Consolas, monospace);
+ font-size: 0.88rem;
+ line-height: 1.55;
+ tab-size: 2;
+ resize: vertical;
+ outline: none;
+}
+.prompt-editor:focus {
+ border-color: var(--color-primary);
+}
.ef-input {
padding: 8px 12px;
border: 1px solid var(--color-border);
diff --git a/frontend/src/views/SettingsView.vue b/frontend/src/views/SettingsView.vue
index eeeba59..b95baef 100644
--- a/frontend/src/views/SettingsView.vue
+++ b/frontend/src/views/SettingsView.vue
@@ -14,25 +14,10 @@ const toastStore = useToastStore();
const userTimezone = ref("");
const savingTimezone = ref(false);
const timezoneSaved = ref(false);
-const autoConsolidateTasks = ref(true);
-const savingAutoConsolidate = ref(false);
const trashRetentionDays = ref("90");
const savingRetention = ref(false);
const retentionSaved = ref(false);
-async function saveAutoConsolidate() {
- savingAutoConsolidate.value = true;
- try {
- await apiPut('/api/settings', {
- auto_consolidate_tasks: autoConsolidateTasks.value ? "true" : "false",
- });
- } catch {
- toastStore.show('Failed to save setting', 'error');
- } finally {
- savingAutoConsolidate.value = false;
- }
-}
-
// think_enabled setting removed 2026-05-23. The chat+curator architecture
// has tools=[] on the chat model; think on a no-tools conversational pass
// is pure latency cost. See generation_task.py:run_generation comment for
@@ -403,8 +388,6 @@ onMounted(async () => {
const allSettings = await apiGet
>("/api/settings");
userTimezone.value = allSettings.user_timezone ?? "";
trashRetentionDays.value = allSettings.trash_retention_days ?? "90";
- // Default true if unset; explicit "false" disables auto-consolidation.
- autoConsolidateTasks.value = (allSettings.auto_consolidate_tasks ?? "true") !== "false";
if (allSettings.notify_task_reminders !== undefined) {
notifyTaskReminders.value = allSettings.notify_task_reminders !== "false";
}
@@ -992,29 +975,6 @@ function formatUserDate(iso: string): string {
-
-
- Tasks
-
- Task bodies are auto-summarized from accumulated work logs. The summary runs every few logs, plus on task close.
-
-
-
-
-
- When off, the task body is only refreshed when you click "Re-consolidate"
- on a task. Existing summaries remain in place.
-
-
-
Timezone
diff --git a/src/fabledassistant/app.py b/src/fabledassistant/app.py
index 8feb60c..333ab55 100644
--- a/src/fabledassistant/app.py
+++ b/src/fabledassistant/app.py
@@ -27,6 +27,7 @@ from fabledassistant.routes.profile import profile_bp
from fabledassistant.routes.knowledge import knowledge_bp
from fabledassistant.routes.rulebooks import rulebooks_bp
from fabledassistant.routes.trash import trash_bp
+from fabledassistant.routes.dashboard import dashboard_bp
from fabledassistant.mcp import mount_mcp
STATIC_DIR = Path(__file__).parent / "static"
@@ -87,6 +88,7 @@ def create_app() -> Quart:
app.register_blueprint(knowledge_bp)
app.register_blueprint(rulebooks_bp)
app.register_blueprint(trash_bp)
+ app.register_blueprint(dashboard_bp)
@app.before_request
async def before_request():
@@ -148,12 +150,14 @@ def create_app() -> Quart:
async def startup():
import asyncio
+ from fabledassistant.services.auth import start_auth_token_retention_loop
from fabledassistant.services.embeddings import backfill_note_embeddings
from fabledassistant.services.logging import start_log_retention_loop
from fabledassistant.services.notifications import start_notification_loop
start_log_retention_loop()
start_notification_loop()
+ start_auth_token_retention_loop()
# Backfill embeddings for any notes that don't have one. Runs in the
# background so it never blocks the server from accepting requests.
diff --git a/src/fabledassistant/mcp/auth.py b/src/fabledassistant/mcp/auth.py
index 4cad787..ab1c3da 100644
--- a/src/fabledassistant/mcp/auth.py
+++ b/src/fabledassistant/mcp/auth.py
@@ -17,3 +17,21 @@ async def resolve_bearer_to_user_id(auth_header: str | None) -> int | None:
return None
api_key = await lookup_key(raw_token)
return api_key.user_id if api_key else None
+
+
+async def resolve_bearer(auth_header: str | None) -> tuple[int, str] | None:
+ """Resolve a Bearer token to (user_id, scope).
+
+ scope is 'read' or 'write'. Returns None for a missing/malformed/invalid
+ token. The MCP dispatch layer uses scope to deny write-class tool calls
+ from read-only keys β the same read/write boundary the REST API enforces.
+ """
+ if not auth_header or not auth_header.startswith("Bearer "):
+ return None
+ raw_token = auth_header[len("Bearer "):].strip()
+ if not raw_token:
+ return None
+ api_key = await lookup_key(raw_token)
+ if api_key is None:
+ return None
+ return api_key.user_id, (api_key.scope or "write")
diff --git a/src/fabledassistant/mcp/server.py b/src/fabledassistant/mcp/server.py
index 9b18199..81fe11e 100644
--- a/src/fabledassistant/mcp/server.py
+++ b/src/fabledassistant/mcp/server.py
@@ -78,9 +78,76 @@ descendants) to the trash and returns a deleted_batch_id. Use list_trash() to
see trashed batches, restore(deleted_batch_id) to undo a deletion, and
purge_trash(deleted_batch_id, confirmed=True) for a permanent delete. Trash
auto-purges after the operator's retention window.
+
+Scribe stores reusable Processes β saved prompts/workflows (note_type
+"process"), e.g. a drift audit or a DRY pass. When the operator says "run the
+X process" or otherwise references a saved process, call list_processes() /
+get_process(name) and follow the returned prompt verbatim, including any
+"clarify first" steps it contains. Author a new one with create_process(title,
+body); edit with update_process.
"""
+# Tools a read-only API key may call. Anything not listed is treated as a
+# write for read keys (default-deny), so a newly-added tool is locked down
+# until explicitly classified here.
+_READ_ONLY_TOOLS = frozenset({
+ "get_event", "get_note", "get_project", "get_rule", "get_rulebook",
+ "get_task", "get_recent", "enter_project",
+ "list_events", "list_lists", "list_milestones", "list_notes",
+ "list_persons", "list_places", "list_projects", "list_rulebooks",
+ "list_rules", "list_tags", "list_tasks", "list_topics", "list_trash",
+ "list_always_on_rules", "search",
+})
+
+
+async def _buffer_request_body(receive):
+ """Drain the ASGI request body and return (body_bytes, replay_receive).
+
+ The MCP sub-app still needs to read the body, so we return a fresh
+ `receive` that replays the buffered bytes.
+ """
+ chunks: list[bytes] = []
+ more = True
+ while more:
+ message = await receive()
+ if message["type"] == "http.request":
+ chunks.append(message.get("body", b""))
+ more = message.get("more_body", False)
+ else: # http.disconnect
+ more = False
+ body = b"".join(chunks)
+
+ sent = False
+
+ async def replay():
+ nonlocal sent
+ if not sent:
+ sent = True
+ return {"type": "http.request", "body": body, "more_body": False}
+ return {"type": "http.disconnect"}
+
+ return body, replay
+
+
+def _body_calls_write_tool(body: bytes) -> bool:
+ """True if the JSON-RPC body invokes a tool outside the read all-list."""
+ import json
+ try:
+ payload = json.loads(body)
+ except Exception:
+ return False
+ items = payload if isinstance(payload, list) else [payload]
+ for item in items:
+ if not isinstance(item, dict):
+ continue
+ if item.get("method") == "tools/call":
+ name = (item.get("params") or {}).get("name", "")
+ if name and name not in _READ_ONLY_TOOLS:
+ return True
+ return False
+
+
def build_mcp_server() -> FastMCP:
"""Build the FastMCP instance with all tools registered.
@@ -128,7 +195,7 @@ def mount_mcp(app: Quart) -> None:
inside Quart, we hook the session manager's `run()` async context manager
into Quart's serving lifecycle (before_serving / after_serving).
"""
- from fabledassistant.mcp.auth import resolve_bearer_to_user_id
+ from fabledassistant.mcp.auth import resolve_bearer
mcp = build_mcp_server()
mcp_asgi = mcp.streamable_http_app()
@@ -151,8 +218,8 @@ def mount_mcp(app: Quart) -> None:
return await mcp_asgi(scope, receive, send)
# ASGI headers are lowercase bytes per spec; lowercase explicitly to be safe.
headers = {k.decode().lower(): v.decode() for k, v in scope.get("headers", [])}
- user_id = await resolve_bearer_to_user_id(headers.get("authorization"))
- if user_id is None:
+ resolved = await resolve_bearer(headers.get("authorization"))
+ if resolved is None:
await send({
"type": "http.response.start",
"status": 401,
@@ -166,6 +233,27 @@ def mount_mcp(app: Quart) -> None:
"body": b'{"error":"unauthorized"}',
})
return
+ user_id, key_scope = resolved
+
+ # Enforce read-only keys: REST blocks non-GET for scope='read', and the
+ # MCP surface must match or the read-only guarantee is void. A tool call
+ # arrives as a JSON-RPC POST; buffer the body, and if it invokes a tool
+ # outside the read all-list, reject before dispatch. (default-deny: any
+ # unknown/new tool is treated as a write for read keys.)
+ if key_scope == "read" and scope.get("method") == "POST":
+ body, receive = await _buffer_request_body(receive)
+ if _body_calls_write_tool(body):
+ await send({
+ "type": "http.response.start",
+ "status": 403,
+ "headers": [(b"content-type", b"application/json")],
+ })
+ await send({
+ "type": "http.response.body",
+ "body": b'{"error":"read-only API key cannot call write tools"}',
+ })
+ return
+
scope["scribe_user_id"] = user_id
from fabledassistant.mcp._context import _user_id_ctx
token = _user_id_ctx.set(user_id)
diff --git a/src/fabledassistant/mcp/tools/__init__.py b/src/fabledassistant/mcp/tools/__init__.py
index 93a5393..58c776d 100644
--- a/src/fabledassistant/mcp/tools/__init__.py
+++ b/src/fabledassistant/mcp/tools/__init__.py
@@ -5,7 +5,7 @@ to a FastMCP instance. `register_all(mcp)` is the single entry point called
from `mcp.server.build_mcp_server`.
"""
from fabledassistant.mcp.tools import (
- entities, events, milestones, notes, projects, recent, rulebooks, search, tags, tasks, trash,
+ entities, events, milestones, notes, processes, projects, recent, rulebooks, search, tags, tasks, trash,
)
@@ -20,5 +20,6 @@ def register_all(mcp) -> None:
tags.register(mcp)
recent.register(mcp)
entities.register(mcp)
+ processes.register(mcp)
rulebooks.register(mcp)
trash.register(mcp)
diff --git a/src/fabledassistant/mcp/tools/processes.py b/src/fabledassistant/mcp/tools/processes.py
new file mode 100644
index 0000000..7718dd3
--- /dev/null
+++ b/src/fabledassistant/mcp/tools/processes.py
@@ -0,0 +1,91 @@
+"""Stored-process MCP tools: reusable saved prompts (note_type='process').
+
+A process is a Note whose body is a prompt the operator fires later
+("run the X process"). Mirrors entities.py β the tools wrap notes_svc directly.
+get_process is the fire mechanism: it returns the full prompt for Claude to run.
+"""
+from __future__ import annotations
+
+from fabledassistant.mcp._context import current_user_id
+from fabledassistant.services import knowledge as knowledge_svc
+from fabledassistant.services import notes as notes_svc
+
+
+async def list_processes(q: str = "", tag: str = "", limit: int = 50) -> dict:
+ """List stored processes (reusable saved prompts).
+
+ Args:
+ q: Free-text search across title + body (optional).
+ tag: Filter to a single tag (optional).
+ limit: Max results (1-100).
+
+ Returns {"processes": [{id, title, tags, preview}], "total": int}.
+ """
+ uid = current_user_id()
+ items, total = await knowledge_svc.query_knowledge(
+ user_id=uid, note_type="process", tags=[tag] if tag else [],
+ sort="modified", q=q or None, limit=max(1, min(limit, 100)), offset=0,
+ )
+ procs = [{"id": it["id"], "title": it["title"], "tags": it.get("tags", []),
+ "preview": it.get("snippet", "")} for it in items]
+ return {"processes": procs, "total": total}
+
+
+async def create_process(title: str, body: str, tags: list[str] | None = None) -> dict:
+ """Create a stored process (a reusable saved prompt).
+
+ Args:
+ title: Process name, e.g. "Drift Audit" (required).
+ body: The full prompt to run later (markdown). Required.
+ tags: Plain-string tags, no # prefix.
+ """
+ if not (title or "").strip() or not (body or "").strip():
+ raise ValueError("create_process requires a non-empty title and body")
+ uid = current_user_id()
+ note = await notes_svc.create_note(
+ uid, title=title.strip(), body=body, note_type="process", tags=tags,
+ )
+ return note.to_dict()
+
+
+async def get_process(name_or_id: str) -> dict:
+ """Fetch a stored process by name or id and return its full prompt β the
+ fire mechanism. The operator says "run the process"; call this and
+ follow the returned body (including any 'clarify first' steps it contains).
+
+ Resolution: numeric id β exact (case-insensitive) title β substring. On an
+ ambiguous substring match, the best (most-recent) match is returned with an
+ `other_matches` list so you can disambiguate with the operator.
+ """
+ uid = current_user_id()
+ note, candidates = await notes_svc.resolve_process(uid, name_or_id)
+ if note is None:
+ raise ValueError(f"process {name_or_id!r} not found")
+ out = note.to_dict()
+ if candidates:
+ out["other_matches"] = candidates
+ return out
+
+
+async def update_process(process_id: int, title: str = "", body: str = "",
+ tags: list[str] | None = None) -> dict:
+ """Update a stored process. Only provided fields change β empty title/body
+ leave that field unchanged; pass tags to replace the tag set."""
+ uid = current_user_id()
+ note = await notes_svc.get_note(uid, process_id)
+ if note is None or note.note_type != "process":
+ raise ValueError(f"process {process_id} not found")
+ fields: dict = {}
+ if title.strip():
+ fields["title"] = title.strip()
+ if body.strip():
+ fields["body"] = body
+ if tags is not None:
+ fields["tags"] = tags
+ updated = await notes_svc.update_note(uid, process_id, **fields)
+ return updated.to_dict()
+
+
+def register(mcp) -> None:
+ for fn in (list_processes, create_process, get_process, update_process):
+ mcp.tool(name=fn.__name__)(fn)
diff --git a/src/fabledassistant/mcp/tools/projects.py b/src/fabledassistant/mcp/tools/projects.py
index 422a11a..73e1e28 100644
--- a/src/fabledassistant/mcp/tools/projects.py
+++ b/src/fabledassistant/mcp/tools/projects.py
@@ -27,7 +27,7 @@ from fabledassistant.services import trash as trash_svc
async def list_projects() -> dict:
"""List all Scribe projects for the current user.
- Returns id, title, description, goal, status (active/archived), color,
+ Returns id, title, description, goal, status (active/paused/completed/archived), color,
and a short auto-generated summary for each project.
"""
uid = current_user_id()
@@ -142,7 +142,7 @@ async def create_project(
title: Project name (required).
description: Short summary of what the project is.
goal: The desired outcome or definition of done for the project.
- status: active (default) or archived.
+ status: one of active (default), paused, completed, archived.
color: Optional hex colour for the project card (e.g. "#6366f1").
"""
uid = current_user_id()
@@ -172,7 +172,7 @@ async def update_project(
title: New title, or omit to leave unchanged.
description: New description, or omit to leave unchanged.
goal: New goal/definition-of-done, or omit to leave unchanged.
- status: New status β active or archived.
+ status: New status β one of active, paused, completed, archived.
color: New hex colour, or omit to leave unchanged.
"""
uid = current_user_id()
diff --git a/src/fabledassistant/mcp/tools/recent.py b/src/fabledassistant/mcp/tools/recent.py
index 2d80aaf..dc2d1e9 100644
--- a/src/fabledassistant/mcp/tools/recent.py
+++ b/src/fabledassistant/mcp/tools/recent.py
@@ -38,7 +38,8 @@ async def get_recent(days: int = 7, limit: int = 25) -> dict:
items: list[dict] = []
async with async_session() as session:
notes = (await session.execute(
- select(Note).where(Note.user_id == uid, Note.updated_at >= since)
+ select(Note).where(Note.user_id == uid, Note.updated_at >= since,
+ Note.deleted_at.is_(None))
.order_by(Note.updated_at.desc()).limit(limit)
)).scalars().all()
for n in notes:
@@ -50,7 +51,8 @@ async def get_recent(days: int = 7, limit: int = 25) -> dict:
})
projects = (await session.execute(
select(Project).where(Project.user_id == uid,
- Project.updated_at >= since)
+ Project.updated_at >= since,
+ Project.deleted_at.is_(None))
.order_by(Project.updated_at.desc()).limit(limit)
)).scalars().all()
for p in projects:
@@ -62,7 +64,8 @@ async def get_recent(days: int = 7, limit: int = 25) -> dict:
})
events = (await session.execute(
select(Event).where(Event.user_id == uid,
- Event.updated_at >= since)
+ Event.updated_at >= since,
+ Event.deleted_at.is_(None))
.order_by(Event.updated_at.desc()).limit(limit)
)).scalars().all()
for e in events:
diff --git a/src/fabledassistant/mcp/tools/rulebooks.py b/src/fabledassistant/mcp/tools/rulebooks.py
index fabb55e..d95d81a 100644
--- a/src/fabledassistant/mcp/tools/rulebooks.py
+++ b/src/fabledassistant/mcp/tools/rulebooks.py
@@ -322,7 +322,7 @@ async def update_rule(
async def delete_rule(rule_id: int, confirmed: bool = False) -> dict:
- """Permanently delete a rule. Requires confirmed=True."""
+ """Move a rule to the trash (recoverable). Requires confirmed=True."""
uid = current_user_id()
rule = await rulebooks_svc.get_rule(rule_id, uid)
if rule is None:
@@ -330,8 +330,8 @@ async def delete_rule(rule_id: int, confirmed: bool = False) -> dict:
if not confirmed:
return {
"warning": (
- f"Rule {rule_id} ('{rule.title}') will be permanently deleted. "
- f"Pass confirmed=True to proceed."
+ f"Rule {rule_id} ('{rule.title}') will be moved to the trash "
+ f"(recoverable via restore). Pass confirmed=True to proceed."
),
"confirmed_required": True,
}
diff --git a/src/fabledassistant/mcp/tools/tags.py b/src/fabledassistant/mcp/tools/tags.py
index 40f5f9b..1ea85f8 100644
--- a/src/fabledassistant/mcp/tools/tags.py
+++ b/src/fabledassistant/mcp/tools/tags.py
@@ -39,7 +39,7 @@ async def list_tags(limit: int = 50) -> dict:
limit = max(1, min(limit, 200))
async with async_session() as session:
result = await session.execute(
- select(Note.tags).where(Note.user_id == uid)
+ select(Note.tags).where(Note.user_id == uid, Note.deleted_at.is_(None))
)
tag_lists = [row[0] for row in result.all()]
counts = _aggregate_tag_counts(tag_lists)
diff --git a/src/fabledassistant/models/project.py b/src/fabledassistant/models/project.py
index cfdf900..ccf4db5 100644
--- a/src/fabledassistant/models/project.py
+++ b/src/fabledassistant/models/project.py
@@ -8,6 +8,7 @@ from fabledassistant.models.base import TimestampMixin, SoftDeleteMixin
class ProjectStatus(str, enum.Enum):
active = "active"
+ paused = "paused"
completed = "completed"
archived = "archived"
diff --git a/src/fabledassistant/models/rulebook.py b/src/fabledassistant/models/rulebook.py
index e65f9b9..67799aa 100644
--- a/src/fabledassistant/models/rulebook.py
+++ b/src/fabledassistant/models/rulebook.py
@@ -1,6 +1,6 @@
from datetime import datetime, timezone
-from sqlalchemy import BigInteger, Boolean, Column, DateTime, ForeignKey, Integer, Table, Text, UniqueConstraint
+from sqlalchemy import BigInteger, Boolean, Column, DateTime, ForeignKey, Index, Integer, Table, Text, text
from sqlalchemy.orm import Mapped, mapped_column
from fabledassistant.models import Base
@@ -42,8 +42,13 @@ class Rulebook(Base, SoftDeleteMixin):
class RulebookTopic(Base, SoftDeleteMixin):
__tablename__ = "rulebook_topics"
+ # Partial unique: a title is unique among LIVE topics in a rulebook, so a
+ # trashed topic doesn't block recreating/restoring the same title.
__table_args__ = (
- UniqueConstraint("rulebook_id", "title", name="uq_topic_per_rulebook"),
+ Index(
+ "uq_topic_per_rulebook", "rulebook_id", "title",
+ unique=True, postgresql_where=text("deleted_at IS NULL"),
+ ),
)
id: Mapped[int] = mapped_column(BigInteger, primary_key=True)
@@ -76,8 +81,13 @@ class RulebookTopic(Base, SoftDeleteMixin):
class Rule(Base, SoftDeleteMixin):
__tablename__ = "rules"
+ # Partial unique: title unique among LIVE rules in a topic (soft-deleted
+ # rules don't block recreating/restoring the same title).
__table_args__ = (
- UniqueConstraint("topic_id", "title", name="uq_rule_per_topic"),
+ Index(
+ "uq_rule_per_topic", "topic_id", "title",
+ unique=True, postgresql_where=text("deleted_at IS NULL"),
+ ),
)
id: Mapped[int] = mapped_column(BigInteger, primary_key=True)
diff --git a/src/fabledassistant/models/user_profile.py b/src/fabledassistant/models/user_profile.py
index 0e13e61..a5999d5 100644
--- a/src/fabledassistant/models/user_profile.py
+++ b/src/fabledassistant/models/user_profile.py
@@ -1,6 +1,4 @@
-from datetime import datetime
-
-from sqlalchemy import DateTime, ForeignKey, Integer, Text
+from sqlalchemy import ForeignKey, Integer, Text
from sqlalchemy.dialects.postgresql import ARRAY, JSONB
from sqlalchemy.orm import Mapped, mapped_column
@@ -27,13 +25,6 @@ class UserProfile(Base, TimestampMixin):
interests: Mapped[list[str] | None] = mapped_column(ARRAY(Text), nullable=True)
# {days: ["Mon","Tue",...], start: "09:00", end: "17:00"}
work_schedule: Mapped[dict | None] = mapped_column(JSONB, nullable=True)
- # LLM-consolidated summary of learned preferences
- learned_summary: Mapped[str | None] = mapped_column(Text, nullable=True)
- # [{date: "YYYY-MM-DD", bullets: "..."}, ...]
- observations_raw: Mapped[list | None] = mapped_column(JSONB, nullable=True)
- observations_updated_at: Mapped[datetime | None] = mapped_column(
- DateTime(timezone=True), nullable=True
- )
def to_dict(self) -> dict:
return {
@@ -45,11 +36,4 @@ class UserProfile(Base, TimestampMixin):
"tone": self.tone or "casual",
"interests": self.interests or [],
"work_schedule": self.work_schedule or {},
- "learned_summary": self.learned_summary or "",
- "observations_count": len(self.observations_raw or []),
- "observations_updated_at": (
- self.observations_updated_at.isoformat()
- if self.observations_updated_at
- else None
- ),
}
diff --git a/src/fabledassistant/routes/dashboard.py b/src/fabledassistant/routes/dashboard.py
new file mode 100644
index 0000000..f1b6b7b
--- /dev/null
+++ b/src/fabledassistant/routes/dashboard.py
@@ -0,0 +1,13 @@
+"""Dashboard REST endpoint β the aggregated landing payload."""
+from quart import Blueprint, g, jsonify
+
+from fabledassistant.auth import login_required
+from fabledassistant.services.dashboard import build_dashboard
+
+dashboard_bp = Blueprint("dashboard", __name__, url_prefix="/api/dashboard")
+
+
+@dashboard_bp.get("")
+@login_required
+async def get_dashboard():
+ return jsonify(await build_dashboard(g.user.id))
diff --git a/src/fabledassistant/routes/knowledge.py b/src/fabledassistant/routes/knowledge.py
index b51ef21..7a2aa4d 100644
--- a/src/fabledassistant/routes/knowledge.py
+++ b/src/fabledassistant/routes/knowledge.py
@@ -10,7 +10,7 @@ logger = logging.getLogger(__name__)
knowledge_bp = Blueprint("knowledge", __name__, url_prefix="/api/knowledge")
-_VALID_TYPES = {"note", "person", "place", "list", "task", "plan"}
+_VALID_TYPES = {"note", "person", "place", "list", "task", "plan", "process"}
_VALID_SORTS = {"modified", "created", "alpha", "type"}
diff --git a/src/fabledassistant/routes/notes.py b/src/fabledassistant/routes/notes.py
index acac8c2..50a3f2b 100644
--- a/src/fabledassistant/routes/notes.py
+++ b/src/fabledassistant/routes/notes.py
@@ -8,12 +8,12 @@ from quart import Blueprint, jsonify, request
from fabledassistant.auth import login_required, get_current_user_id
from fabledassistant.routes.utils import not_found, parse_iso_date, parse_pagination
+from fabledassistant.services.access import can_write_note
from fabledassistant.services.notes import (
build_note_graph,
convert_note_to_task,
convert_task_to_note,
create_note,
- delete_note,
get_all_tags,
get_backlinks,
get_note,
@@ -192,6 +192,15 @@ async def get_note_route(note_id: int):
@login_required
async def update_note_route(note_id: int):
uid = get_current_user_id()
+ # Share-aware: resolve through the ACL and write as the OWNER, so a shared
+ # editor's save isn't rejected by the owner-scoped update service.
+ result = await get_note_for_user(uid, note_id)
+ if result is None:
+ return not_found("Note")
+ note_obj, _ = result
+ if not await can_write_note(uid, note_id):
+ return jsonify({"error": "Permission denied"}), 403
+ owner_uid = note_obj.user_id
data = await request.get_json()
fields = {}
for key in ("title", "body", "description", "parent_id", "project_id", "milestone_id", "status", "priority", "note_type"):
@@ -212,14 +221,14 @@ async def update_note_route(note_id: int):
if "tags" in data:
fields["tags"] = data["tags"]
try:
- note = await update_note(uid, note_id, **fields)
+ note = await update_note(owner_uid, note_id, **fields)
except ValueError as e:
return jsonify({"error": str(e)}), 400
if note is None:
return not_found("Note")
text = f"{note.title}\n{note.body}".strip() if note.body else (note.title or "")
if text:
- asyncio.create_task(upsert_note_embedding(note.id, uid, text))
+ asyncio.create_task(upsert_note_embedding(note.id, owner_uid, text))
return jsonify(note.to_dict())
@@ -227,6 +236,13 @@ async def update_note_route(note_id: int):
@login_required
async def patch_note_route(note_id: int):
uid = get_current_user_id()
+ result = await get_note_for_user(uid, note_id)
+ if result is None:
+ return not_found("Note")
+ note_obj, _ = result
+ if not await can_write_note(uid, note_id):
+ return jsonify({"error": "Permission denied"}), 403
+ owner_uid = note_obj.user_id
data = await request.get_json()
fields = {}
for key in ("title", "body", "description", "parent_id", "project_id", "milestone_id", "status", "priority", "note_type"):
@@ -245,14 +261,14 @@ async def patch_note_route(note_id: int):
if "tags" in data:
fields["tags"] = data["tags"]
try:
- note = await update_note(uid, note_id, **fields)
+ note = await update_note(owner_uid, note_id, **fields)
except ValueError as e:
return jsonify({"error": str(e)}), 400
if note is None:
return not_found("Note")
text = f"{note.title}\n{note.body}".strip() if note.body else (note.title or "")
if text:
- asyncio.create_task(upsert_note_embedding(note.id, uid, text))
+ asyncio.create_task(upsert_note_embedding(note.id, owner_uid, text))
return jsonify(note.to_dict())
@@ -260,8 +276,14 @@ async def patch_note_route(note_id: int):
@login_required
async def delete_note_route(note_id: int):
uid = get_current_user_id()
+ result = await get_note_for_user(uid, note_id)
+ if result is None:
+ return not_found("Note")
+ note_obj, _ = result
+ if not await can_write_note(uid, note_id):
+ return jsonify({"error": "Permission denied"}), 403
from fabledassistant.services.trash import delete as trash_delete
- batch = await trash_delete(uid, "note", note_id)
+ batch = await trash_delete(note_obj.user_id, "note", note_id)
if batch is None:
return not_found("Note")
return "", 204
diff --git a/src/fabledassistant/routes/projects.py b/src/fabledassistant/routes/projects.py
index c90ec66..f1c65e5 100644
--- a/src/fabledassistant/routes/projects.py
+++ b/src/fabledassistant/routes/projects.py
@@ -53,7 +53,7 @@ async def create_project_route():
return jsonify({"error": "title is required"}), 400
status = data.get("status", "active")
if status not in ("active", "paused", "completed", "archived"):
- return jsonify({"error": "status must be 'active', 'completed', or 'archived'"}), 400
+ return jsonify({"error": "status must be 'active', 'paused', 'completed', or 'archived'"}), 400
project = await create_project(
uid,
title=data["title"],
@@ -90,7 +90,7 @@ async def update_project_route(project_id: int):
allowed = {"title", "description", "goal", "status", "color"}
fields = {k: (v if v is not None else "") for k, v in data.items() if k in allowed}
if "status" in fields and fields["status"] not in ("active", "paused", "completed", "archived"):
- return jsonify({"error": "status must be 'active', 'completed', or 'archived'"}), 400
+ return jsonify({"error": "status must be 'active', 'paused', 'completed', or 'archived'"}), 400
project = await update_project(uid, project_id, **fields)
if project is None:
return not_found("Project")
@@ -116,6 +116,9 @@ async def get_project_notes_route(project_id: int):
if result is None:
return not_found("Project")
project, _ = result
+ # Use the project owner's uid so the ownership filter on notes/milestones
+ # matches for shared collaborators (who'd otherwise see an empty panel).
+ owner_uid = project.user_id or uid
# type filter: "note", "task", or None (both)
type_filter = request.args.get("type")
@@ -128,11 +131,11 @@ async def get_project_notes_route(project_id: int):
elif type_filter == "note":
is_task = False
- ms_list = await list_milestones(uid, project_id)
+ ms_list = await list_milestones(owner_uid, project_id)
milestone_ids = [m.id for m in ms_list]
notes, total = await list_notes(
- uid,
+ owner_uid,
is_task=is_task,
status=status_filter,
project_id=project_id,
diff --git a/src/fabledassistant/routes/rulebooks.py b/src/fabledassistant/routes/rulebooks.py
index 4f63d76..5f7c394 100644
--- a/src/fabledassistant/routes/rulebooks.py
+++ b/src/fabledassistant/routes/rulebooks.py
@@ -118,7 +118,8 @@ async def update_topic(topic_id: int):
@rulebooks_bp.delete("/rulebook-topics/")
@login_required
async def delete_topic(topic_id: int):
- await trash_delete(_uid(), "topic", topic_id)
+ if await trash_delete(_uid(), "topic", topic_id) is None:
+ return jsonify({"error": "topic not found"}), 404
return "", 204
@@ -196,7 +197,8 @@ async def update_rule(rule_id: int):
@rulebooks_bp.delete("/rules/")
@login_required
async def delete_rule(rule_id: int):
- await trash_delete(_uid(), "rule", rule_id)
+ if await trash_delete(_uid(), "rule", rule_id) is None:
+ return jsonify({"error": "rule not found"}), 404
return "", 204
diff --git a/src/fabledassistant/routes/tasks.py b/src/fabledassistant/routes/tasks.py
index c008453..87c8bd0 100644
--- a/src/fabledassistant/routes/tasks.py
+++ b/src/fabledassistant/routes/tasks.py
@@ -10,7 +10,6 @@ from fabledassistant.services.access import can_write_note
from fabledassistant.services.embeddings import upsert_note_embedding
from fabledassistant.services.notes import (
create_note,
- delete_note,
get_note,
get_note_for_user,
list_notes,
diff --git a/src/fabledassistant/services/auth.py b/src/fabledassistant/services/auth.py
index 0605186..ab1d005 100644
--- a/src/fabledassistant/services/auth.py
+++ b/src/fabledassistant/services/auth.py
@@ -106,6 +106,11 @@ async def change_password(user_id: int, current_password: str, new_password: str
user = await session.get(User, user_id)
if not user:
return None
+ # OAuth-only accounts have no local password hash β verify_password
+ # would crash on None. Treat as "no local credential to change" (the
+ # route turns None into a clean 4xx, not a 500).
+ if user.password_hash is None:
+ return None
if not verify_password(current_password, user.password_hash):
return None
user.password_hash = hash_password(new_password)
@@ -325,12 +330,23 @@ async def register_with_invitation(raw_token: str, username: str, password: str)
if not invitation or invitation.used or invitation.expires_at < datetime.now(timezone.utc):
return None
- invitation.used = True
- await session.commit()
+ invitation_id = invitation.id
+ invite_email = invitation.email
- # Create user outside the invitation session
- user = await create_user(username, password, invitation.email)
- logger.info("User '%s' registered via invitation for %s", username, invitation.email)
+ # Create the user FIRST, then consume the token. create_user can fail (e.g.
+ # a username collision raises and the route returns 409); marking the token
+ # used before that would burn this single-use invite and lock the invitee
+ # out of retrying. Ordering it after means a failed creation leaves the
+ # token valid.
+ user = await create_user(username, password, invite_email)
+
+ async with async_session() as session:
+ invitation = await session.get(InvitationToken, invitation_id)
+ if invitation is not None:
+ invitation.used = True
+ await session.commit()
+
+ logger.info("User '%s' registered via invitation for %s", username, invite_email)
return user
@@ -356,3 +372,46 @@ async def revoke_invitation(invitation_id: int) -> bool:
await session.commit()
logger.info("Invitation %d revoked", invitation_id)
return True
+
+
+# ββ Token retention βββββββββββββββββββββββββββββββββββββββββββββββββββββ
+# Password-reset and invitation tokens are only ever flipped used=True and are
+# never pruned, so on a long-lived instance both tables grow without bound.
+# A daily sweep deletes any token whose validity window ended over grace_days
+# ago (covers both used and naturally-expired rows once they're cold).
+
+_auth_retention_task = None
+
+
+async def purge_expired_auth_tokens(grace_days: int = 7) -> int:
+ """Delete password-reset / invitation tokens that expired > grace_days ago."""
+ from sqlalchemy import delete
+ cutoff = datetime.now(timezone.utc) - timedelta(days=grace_days)
+ removed = 0
+ async with async_session() as session:
+ for model in (PasswordResetToken, InvitationToken):
+ result = await session.execute(
+ delete(model).where(model.expires_at < cutoff)
+ )
+ removed += result.rowcount or 0
+ await session.commit()
+ return removed
+
+
+async def _auth_token_retention_loop() -> None:
+ import asyncio
+ while True:
+ await asyncio.sleep(86400) # daily
+ try:
+ removed = await purge_expired_auth_tokens()
+ if removed:
+ logger.info("Auth token retention: deleted %d expired token(s)", removed)
+ except Exception:
+ logger.exception("Error in auth token retention cleanup")
+
+
+def start_auth_token_retention_loop() -> None:
+ global _auth_retention_task
+ import asyncio
+ if _auth_retention_task is None or _auth_retention_task.done():
+ _auth_retention_task = asyncio.create_task(_auth_token_retention_loop())
diff --git a/src/fabledassistant/services/caldav.py b/src/fabledassistant/services/caldav.py
index 12a0ec7..cb4c9a3 100644
--- a/src/fabledassistant/services/caldav.py
+++ b/src/fabledassistant/services/caldav.py
@@ -14,6 +14,10 @@ logger = logging.getLogger(__name__)
CALDAV_SETTING_KEYS = ["caldav_url", "caldav_username", "caldav_password", "caldav_calendar_name", "caldav_timezone"]
+# Sentinel: distinguishes "leave the RRULE untouched" from "clear it" (None/"")
+# in update_event, since None is a meaningful value for recurrence.
+_RECURRENCE_UNSET = object()
+
async def get_caldav_config(user_id: int) -> dict[str, str]:
"""Return the user's CalDAV config from their settings."""
@@ -214,14 +218,22 @@ async def create_event(
result_end = d_end.isoformat()
else:
dt_start = _apply_timezone(datetime.fromisoformat(start), tz)
+ event.add("dtstart", dt_start)
+ result_start = dt_start.isoformat()
if end:
dt_end = _apply_timezone(datetime.fromisoformat(end), tz)
+ elif duration:
+ dt_end = dt_start + timedelta(minutes=duration)
else:
- dt_end = dt_start + timedelta(minutes=duration or 60)
- event.add("dtstart", dt_start)
- event.add("dtend", dt_end)
- result_start = dt_start.isoformat()
- result_end = dt_end.isoformat()
+ dt_end = None
+ if dt_end is not None:
+ event.add("dtend", dt_end)
+ result_end = dt_end.isoformat()
+ else:
+ # Point event (no end, no duration): emit DTSTART only. Fabricating
+ # a 60-min DTEND here would round-trip back on the next pull as
+ # duration_minutes=60, silently lengthening a point event.
+ result_end = None
if description:
event.add("description", description)
@@ -325,8 +337,14 @@ async def update_event(
location: str | None = None,
timezone: str | None = None,
calendar_name: str | None = None,
+ recurrence: str | None | object = _RECURRENCE_UNSET,
) -> dict:
- """Update a calendar event matching the query."""
+ """Update a calendar event matching the query.
+
+ ``recurrence``: leave at the sentinel to keep the existing RRULE; pass an
+ RRULE string to set it, or None/"" to remove it. The push path passes the
+ local event's recurrence so RRULE edits propagate to the server.
+ """
config = await get_caldav_config(user_id)
_check_config(config)
tz = timezone or config.get("caldav_timezone") or None
@@ -382,6 +400,18 @@ async def update_event(
if "LOCATION" in component:
del component["LOCATION"]
component.add("location", location)
+ if recurrence is not _RECURRENCE_UNSET:
+ # Authoritatively sync the RRULE to the local event: drop the old
+ # rule, then re-add if a non-empty rule was provided (else clear it).
+ if "RRULE" in component:
+ del component["RRULE"]
+ if recurrence:
+ rrule_parts = {}
+ for part in str(recurrence).split(";"):
+ if "=" in part:
+ key, value = part.split("=", 1)
+ rrule_parts[key.strip().lower()] = value.strip()
+ component.add("rrule", rrule_parts)
# Rebuild ical data and save
cal_data = icalendar.Calendar()
diff --git a/src/fabledassistant/services/caldav_sync.py b/src/fabledassistant/services/caldav_sync.py
index f35ffee..0c04919 100644
--- a/src/fabledassistant/services/caldav_sync.py
+++ b/src/fabledassistant/services/caldav_sync.py
@@ -11,7 +11,7 @@ import uuid
from datetime import datetime, timedelta, timezone
from typing import Any
-from sqlalchemy import select
+from sqlalchemy import select, update
from fabledassistant.models import async_session
from fabledassistant.models.event import Event
@@ -20,6 +20,9 @@ logger = logging.getLogger(__name__)
_SYNC_PAST_DAYS = 30
_SYNC_FUTURE_DAYS = 180
+# Wall-clock cap on the blocking CalDAV fetch so a hung/slow server can't
+# wedge the hourly sweep indefinitely.
+_SYNC_TIMEOUT_SECONDS = 120
def _parse_dt(val: Any) -> datetime | None:
@@ -116,16 +119,24 @@ async def sync_user_events(user_id: int) -> dict:
config = await get_caldav_config(user_id)
+ started = datetime.now(timezone.utc)
+ range_start = started - timedelta(days=_SYNC_PAST_DAYS)
+ range_end = started + timedelta(days=_SYNC_FUTURE_DAYS)
+
loop = asyncio.get_running_loop()
try:
- remote_events: list[dict] = await loop.run_in_executor(
- None, _sync_one_user, config, user_id
+ remote_events: list[dict] = await asyncio.wait_for(
+ loop.run_in_executor(None, _sync_one_user, config, user_id),
+ timeout=_SYNC_TIMEOUT_SECONDS,
)
+ except asyncio.TimeoutError:
+ logger.warning("CalDAV pull sync timed out for user %d after %ds", user_id, _SYNC_TIMEOUT_SECONDS)
+ return {"error": "CalDAV fetch timed out"}
except Exception:
logger.warning("CalDAV pull sync failed for user %d", user_id, exc_info=True)
return {"error": "CalDAV fetch failed"}
- created = updated = unchanged = 0
+ created = updated = unchanged = skipped = deleted = 0
async with async_session() as session:
for ev in remote_events:
@@ -149,6 +160,14 @@ async def sync_user_events(user_id: int) -> dict:
)
existing = result.scalar_one_or_none()
+ if existing is not None and existing.deleted_at is not None:
+ # The user trashed this event locally. Don't resurrect it by
+ # updating, and don't create a duplicate live copy β leave it
+ # in the trash. (Propagating the delete to the remote server is
+ # tracked separately.)
+ skipped += 1
+ continue
+
if existing is None:
# Create new event
new_ev = Event(
@@ -177,13 +196,38 @@ async def sync_user_events(user_id: int) -> dict:
else:
unchanged += 1
+ # Reconcile deletions: a previously-synced event (has a caldav_uid)
+ # that no longer appears remotely within the synced window is
+ # soft-deleted, so a delete on the remote propagates locally instead
+ # of orphaning forever. Guarded on a non-empty fetch so a spurious
+ # empty result can't wipe every local copy.
+ if remote_events:
+ remote_uids = {e["caldav_uid"] for e in remote_events}
+ orphan_batch = str(uuid.uuid4())
+ orphan_res = await session.execute(
+ update(Event)
+ .where(
+ Event.user_id == user_id,
+ Event.caldav_uid.isnot(None),
+ Event.caldav_uid.notin_(remote_uids),
+ Event.deleted_at.is_(None),
+ Event.start_dt >= range_start,
+ Event.start_dt <= range_end,
+ )
+ .values(deleted_at=datetime.now(timezone.utc), deleted_batch_id=orphan_batch)
+ )
+ deleted = orphan_res.rowcount or 0
+
await session.commit()
+ elapsed = (datetime.now(timezone.utc) - started).total_seconds()
logger.info(
- "CalDAV sync user %d: %d created, %d updated, %d unchanged",
- user_id, created, updated, unchanged,
+ "CalDAV sync user %d: %d created, %d updated, %d unchanged, %d skipped (trashed), "
+ "%d deleted (orphaned) in %.1fs",
+ user_id, created, updated, unchanged, skipped, deleted, elapsed,
)
- return {"created": created, "updated": updated, "unchanged": unchanged}
+ return {"created": created, "updated": updated, "unchanged": unchanged,
+ "skipped": skipped, "deleted": deleted}
async def sync_all_users() -> None:
diff --git a/src/fabledassistant/services/calendar_sync.py b/src/fabledassistant/services/calendar_sync.py
deleted file mode 100644
index 0300556..0000000
--- a/src/fabledassistant/services/calendar_sync.py
+++ /dev/null
@@ -1,312 +0,0 @@
-"""Calendar sync service: bridges the DB Event table with local Radicale.
-
-Each user's calendars live at: http://radicale:5232/user_{user_id}/calendar/
-The app connects without auth (Radicale runs with auth.type = none inside Docker).
-
-External clients (iOS, macOS, Thunderbird) connect directly to Radicale on port 5232.
-Their CalDAV URL is: http://:5232/user_{user_id}/calendar/
-"""
-
-import asyncio
-import logging
-import uuid
-from datetime import datetime, timezone
-
-import httpx
-import icalendar
-from sqlalchemy import select
-
-from fabledassistant.config import Config
-from fabledassistant.models import async_session
-from fabledassistant.models.event import Event
-
-logger = logging.getLogger(__name__)
-
-# Internal Radicale URL (Docker service name)
-_RADICALE_INTERNAL = "http://radicale:5232"
-
-
-def _user_calendar_path(user_id: int) -> str:
- return f"/user_{user_id}/calendar/"
-
-
-def _user_calendar_url(user_id: int) -> str:
- base = Config.RADICALE_URL.rstrip("/") if Config.RADICALE_URL else _RADICALE_INTERNAL
- return f"{base}/user_{user_id}/calendar/"
-
-
-async def setup_user_calendar(user_id: int) -> bool:
- """Create Radicale collection for user if it doesn't exist.
-
- Returns True on success or if already exists, False on error.
- """
- base = Config.RADICALE_URL.rstrip("/") if Config.RADICALE_URL else _RADICALE_INTERNAL
- user_url = f"{base}/user_{user_id}/"
- cal_url = f"{base}/user_{user_id}/calendar/"
-
- try:
- async with httpx.AsyncClient(timeout=10.0) as client:
- # Create user home collection
- await client.request(
- "MKCOL",
- user_url,
- headers={"Content-Type": "text/xml"},
- content="""
-
- """,
- )
- # Create calendar collection
- resp = await client.request(
- "MKCOL",
- cal_url,
- headers={"Content-Type": "text/xml"},
- content="""
-
-
-
- Fabled Scribe
-
-
- """,
- )
- if resp.status_code in (201, 405): # 405 = already exists
- logger.info("Calendar collection ready for user %d", user_id)
- return True
- logger.warning("Unexpected status %d creating calendar for user %d", resp.status_code, user_id)
- return False
- except Exception:
- logger.warning("Failed to setup Radicale calendar for user %d", user_id, exc_info=True)
- return False
-
-
-def _make_vcalendar(event: Event) -> str:
- """Build iCalendar string from DB Event."""
- cal = icalendar.Calendar()
- cal.add("prodid", "-//FabledAssistant//EN")
- cal.add("version", "2.0")
-
- vevent = icalendar.Event()
- vevent.add("uid", event.uid)
- vevent.add("summary", event.title)
-
- if event.all_day:
- vevent.add("dtstart", event.start_dt.date())
- if event.end_dt:
- vevent.add("dtend", event.end_dt.date())
- else:
- vevent.add("dtstart", event.start_dt)
- if event.end_dt:
- vevent.add("dtend", event.end_dt)
-
- if event.description:
- vevent.add("description", event.description)
- if event.location:
- vevent.add("location", event.location)
- if event.recurrence:
- rrule_parts: dict = {}
- for part in event.recurrence.split(";"):
- if "=" in part:
- key, value = part.split("=", 1)
- rrule_parts[key.strip().lower()] = value.strip()
- if rrule_parts:
- vevent.add("rrule", rrule_parts)
-
- vevent.add("dtstamp", datetime.now(timezone.utc))
- cal.add_component(vevent)
- return cal.to_ical().decode("utf-8")
-
-
-async def push_event_to_radicale(user_id: int, event: Event) -> bool:
- """Write a DB Event to Radicale. Creates or updates the resource.
-
- Returns True on success.
- """
- base = Config.RADICALE_URL.rstrip("/") if Config.RADICALE_URL else _RADICALE_INTERNAL
- resource_url = f"{base}/user_{user_id}/calendar/{event.uid}.ics"
- ical_data = _make_vcalendar(event)
-
- try:
- async with httpx.AsyncClient(timeout=10.0) as client:
- resp = await client.put(
- resource_url,
- content=ical_data.encode("utf-8"),
- headers={"Content-Type": "text/calendar; charset=utf-8"},
- )
- if resp.status_code in (200, 201, 204):
- return True
- logger.warning("Radicale PUT returned %d for event %s", resp.status_code, event.uid)
- return False
- except Exception:
- logger.warning("Failed to push event %s to Radicale", event.uid, exc_info=True)
- return False
-
-
-async def delete_event_from_radicale(user_id: int, uid: str) -> bool:
- """Delete an event from Radicale by UID."""
- base = Config.RADICALE_URL.rstrip("/") if Config.RADICALE_URL else _RADICALE_INTERNAL
- resource_url = f"{base}/user_{user_id}/calendar/{uid}.ics"
- try:
- async with httpx.AsyncClient(timeout=10.0) as client:
- resp = await client.delete(resource_url)
- return resp.status_code in (200, 204, 404) # 404 is ok (already gone)
- except Exception:
- logger.warning("Failed to delete event %s from Radicale", uid, exc_info=True)
- return False
-
-
-async def sync_event_to_db(user_id: int, ical_uid: str) -> Event | None:
- """Fetch an event from Radicale and upsert into the DB Event table.
-
- Returns the upserted Event or None on error.
- """
- base = Config.RADICALE_URL.rstrip("/") if Config.RADICALE_URL else _RADICALE_INTERNAL
- resource_url = f"{base}/user_{user_id}/calendar/{ical_uid}.ics"
-
- try:
- async with httpx.AsyncClient(timeout=10.0) as client:
- resp = await client.get(resource_url)
- if resp.status_code == 404:
- return None
- resp.raise_for_status()
- ical_data = resp.text
- except Exception:
- logger.warning("Failed to fetch event %s from Radicale", ical_uid, exc_info=True)
- return None
-
- try:
- cal = icalendar.Calendar.from_ical(ical_data)
- for component in cal.walk():
- if component.name != "VEVENT":
- continue
- title = str(component.get("SUMMARY", ""))
- dtstart = component.get("DTSTART")
- dtend = component.get("DTEND")
- description = str(component.get("DESCRIPTION", ""))
- location = str(component.get("LOCATION", ""))
- rrule = component.get("RRULE")
- recurrence = rrule.to_ical().decode("utf-8") if rrule else None
-
- all_day = False
- if dtstart and isinstance(dtstart.dt, datetime):
- start_dt = dtstart.dt if dtstart.dt.tzinfo else dtstart.dt.replace(tzinfo=timezone.utc)
- elif dtstart:
- from datetime import date
- d = dtstart.dt
- start_dt = datetime(d.year, d.month, d.day, tzinfo=timezone.utc)
- all_day = True
- else:
- continue
-
- end_dt = None
- if dtend and isinstance(dtend.dt, datetime):
- end_dt = dtend.dt if dtend.dt.tzinfo else dtend.dt.replace(tzinfo=timezone.utc)
- elif dtend:
- from datetime import date
- d = dtend.dt
- end_dt = datetime(d.year, d.month, d.day, tzinfo=timezone.utc)
-
- # Storage uses duration, not end_dt. Convert iCal DTEND to a
- # minute count anchored on DTSTART. Treat invalid (end <= start)
- # incoming data as a point event rather than rejecting; we
- # don't control external CalDAV writers.
- duration_minutes = None
- if end_dt is not None and end_dt > start_dt:
- duration_minutes = int((end_dt - start_dt).total_seconds() // 60)
-
- async with async_session() as session:
- result = await session.execute(
- select(Event).where(Event.user_id == user_id, Event.uid == ical_uid)
- )
- existing = result.scalars().first()
- if existing:
- existing.title = title
- existing.start_dt = start_dt
- existing.duration_minutes = duration_minutes
- existing.all_day = all_day
- existing.description = description
- existing.location = location
- existing.recurrence = recurrence
- existing.updated_at = datetime.now(timezone.utc)
- await session.commit()
- await session.refresh(existing)
- return existing
- else:
- event_obj = Event(
- user_id=user_id,
- uid=ical_uid,
- title=title,
- start_dt=start_dt,
- duration_minutes=duration_minutes,
- all_day=all_day,
- description=description,
- location=location,
- recurrence=recurrence,
- )
- session.add(event_obj)
- await session.commit()
- await session.refresh(event_obj)
- return event_obj
- except Exception:
- logger.warning("Failed to parse/upsert Radicale event %s", ical_uid, exc_info=True)
- return None
-
-
-async def sync_all_events_from_radicale(user_id: int) -> int:
- """Full sync: fetch all events from Radicale calendar and upsert into DB.
-
- Returns number of events synced.
- """
- base = Config.RADICALE_URL.rstrip("/") if Config.RADICALE_URL else _RADICALE_INTERNAL
- cal_url = f"{base}/user_{user_id}/calendar/"
-
- try:
- async with httpx.AsyncClient(timeout=30.0) as client:
- # PROPFIND to get all .ics resources
- resp = await client.request(
- "PROPFIND",
- cal_url,
- headers={"Depth": "1", "Content-Type": "text/xml"},
- content="""
-