confsync-server 0.1.0__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
confsync_server/app.py ADDED
@@ -0,0 +1,693 @@
1
+ """Starlette application: REST API (/api/v1) + server-rendered Web UI."""
2
+ from __future__ import annotations
3
+
4
+ import html
5
+ import time
6
+ from contextlib import asynccontextmanager
7
+
8
+ from starlette.applications import Starlette
9
+ from starlette.requests import Request
10
+ from starlette.responses import JSONResponse, PlainTextResponse, RedirectResponse, Response
11
+ from starlette.routing import Route
12
+
13
+ from confsync_server import auth, crypto, db
14
+ from confsync_server.config import ServerSettings, load_settings
15
+
16
+ SESSION_COOKIE = "confsync_session"
17
+ MAX_CONTENT_BYTES = 4 * 1024 * 1024
18
+
19
+ # ── rendering ─────────────────────────────────────────────────────
20
+
21
+ _CSS = """
22
+ body { font-family: -apple-system, "Segoe UI", sans-serif; max-width: 960px;
23
+ margin: 2rem auto; padding: 0 1rem; color: #24292f; }
24
+ nav { display: flex; gap: 1rem; align-items: baseline; border-bottom: 1px solid #ddd;
25
+ padding-bottom: .5rem; margin-bottom: 1.5rem; }
26
+ nav .brand { font-weight: 700; }
27
+ nav .spacer { flex: 1; }
28
+ table { border-collapse: collapse; width: 100%; }
29
+ th, td { text-align: left; padding: .4rem .6rem; border-bottom: 1px solid #eee; }
30
+ th { background: #f6f8fa; }
31
+ textarea { width: 100%; box-sizing: border-box; font-family: ui-monospace, monospace;
32
+ font-size: 13px; }
33
+ input[type=text] { padding: .3rem .5rem; }
34
+ button, .btn { padding: .3rem .8rem; border: 1px solid #ccc; border-radius: 6px;
35
+ background: #f6f8fa; cursor: pointer; text-decoration: none; color: inherit; }
36
+ button.primary { background: #1f883d; color: #fff; border-color: #1f883d; }
37
+ button.danger { color: #cf222e; }
38
+ code.key { background: #fff8c5; padding: .4rem .6rem; border-radius: 6px;
39
+ display: inline-block; margin: .5rem 0; }
40
+ .flash { background: #dafbe1; border: 1px solid #1f883d; padding: .5rem .8rem;
41
+ border-radius: 6px; margin-bottom: 1rem; }
42
+ .error { background: #ffebe9; border: 1px solid #cf222e; padding: .5rem .8rem;
43
+ border-radius: 6px; margin-bottom: 1rem; }
44
+ .muted { color: #656d76; font-size: .9em; }
45
+ form.inline { display: inline; }
46
+ """
47
+
48
+
49
+ def _e(value) -> str:
50
+ return html.escape(str(value), quote=True)
51
+
52
+
53
+ def _fmt_ts(ts: float | None) -> str:
54
+ if not ts:
55
+ return "—"
56
+ return time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(ts))
57
+
58
+
59
+ def _page(title: str, body: str, user=None, flash: str = "", error: str = "") -> Response:
60
+ if user is not None:
61
+ admin_link = '<a href="/admin">Admin</a>' if user["is_admin"] else ""
62
+ nav = f"""
63
+ <nav>
64
+ <span class="brand">confsync</span>
65
+ <a href="/">Documents</a>
66
+ <a href="/keys">API Keys</a>
67
+ {admin_link}
68
+ <span class="spacer"></span>
69
+ <span class="muted">{_e(user['login'])}</span>
70
+ <a href="/logout">Logout</a>
71
+ </nav>"""
72
+ else:
73
+ nav = '<nav><span class="brand">confsync</span></nav>'
74
+ flash_html = f'<div class="flash">{_e(flash)}</div>' if flash else ""
75
+ error_html = f'<div class="error">{_e(error)}</div>' if error else ""
76
+ page = f"""<!DOCTYPE html>
77
+ <html><head>
78
+ <meta charset="utf-8">
79
+ <meta name="viewport" content="width=device-width, initial-scale=1">
80
+ <title>{_e(title)} · confsync</title>
81
+ <style>{_CSS}</style>
82
+ </head><body>
83
+ {nav}
84
+ {flash_html}{error_html}
85
+ {body}
86
+ </body></html>"""
87
+ return Response(page, media_type="text/html")
88
+
89
+
90
+ def _redirect(url: str, flash: str = "") -> RedirectResponse:
91
+ if flash:
92
+ sep = "&" if "?" in url else "?"
93
+ url = f"{url}{sep}flash={flash}"
94
+ return RedirectResponse(url, status_code=303)
95
+
96
+
97
+ # ── context helpers ───────────────────────────────────────────────
98
+
99
+ def _settings(request: Request) -> ServerSettings:
100
+ return request.app.state.settings
101
+
102
+
103
+ def _master_key(request: Request) -> bytes:
104
+ return request.app.state.master_key
105
+
106
+
107
+ def _open_db(request: Request):
108
+ return db.connect(_settings(request).db_path)
109
+
110
+
111
+ def _session_user(request: Request):
112
+ token = request.cookies.get(SESSION_COOKIE)
113
+ if not token:
114
+ return None
115
+ conn = _open_db(request)
116
+ try:
117
+ return db.get_session_user(conn, token)
118
+ finally:
119
+ conn.close()
120
+
121
+
122
+ def _require_web_user(request: Request):
123
+ """Returns (user, response). response is a redirect when not logged in."""
124
+ user = _session_user(request)
125
+ if user is None:
126
+ return None, RedirectResponse("/login", status_code=303)
127
+ return user, None
128
+
129
+
130
+ def _require_api_user(request: Request):
131
+ """Returns (user, response). response is a 401 JSON when unauthorized."""
132
+ header = request.headers.get("Authorization", "")
133
+ if not header.startswith("Bearer "):
134
+ return None, JSONResponse({"error": "missing bearer token"}, status_code=401)
135
+ conn = _open_db(request)
136
+ try:
137
+ user = db.get_user_by_api_key(conn, header[len("Bearer "):])
138
+ finally:
139
+ conn.close()
140
+ if user is None:
141
+ return None, JSONResponse({"error": "invalid or revoked API key"}, status_code=401)
142
+ return user, None
143
+
144
+
145
+ def _decrypt_doc(request: Request, row) -> str:
146
+ aad = crypto.document_aad(row["user_id"], row["app"], row["name"])
147
+ return crypto.decrypt(_master_key(request), row["ciphertext"], aad).decode()
148
+
149
+
150
+ def _store_doc(request: Request, user_id: int, app: str, name: str, content: str) -> int:
151
+ aad = crypto.document_aad(user_id, app, name)
152
+ blob = crypto.encrypt(_master_key(request), content.encode(), aad)
153
+ conn = _open_db(request)
154
+ try:
155
+ return db.put_document(conn, user_id, app, name, blob)
156
+ finally:
157
+ conn.close()
158
+
159
+
160
+ def _flash_error(request: Request) -> dict:
161
+ return {
162
+ "flash": request.query_params.get("flash", ""),
163
+ "error": request.query_params.get("error", ""),
164
+ }
165
+
166
+
167
+ # ── web: auth ─────────────────────────────────────────────────────
168
+
169
+ async def login_page(request: Request) -> Response:
170
+ if _session_user(request) is not None:
171
+ return RedirectResponse("/", status_code=303)
172
+ if not _settings(request).github_client_id:
173
+ body = ("<p class='error'>GitHub OAuth is not configured on this server "
174
+ "(missing github.client_id).</p>")
175
+ return _page("Login", body)
176
+ body = """
177
+ <h1>Sign in</h1>
178
+ <p><a class="btn" href="/auth/github/login">Sign in with GitHub</a></p>
179
+ """
180
+ return _page("Login", body)
181
+
182
+
183
+ async def github_login(request: Request) -> Response:
184
+ s = _settings(request)
185
+ if not s.github_client_id:
186
+ return _page("Error", "", error="GitHub OAuth is not configured.")
187
+ state = auth.generate_oauth_state()
188
+ request.app.state.oauth_states.add(state)
189
+ url = auth.build_authorize_url(
190
+ s.github_client_id, f"{s.external_url}/auth/github/callback", state
191
+ )
192
+ return RedirectResponse(url)
193
+
194
+
195
+ async def github_callback(request: Request) -> Response:
196
+ s = _settings(request)
197
+ state = request.query_params.get("state", "")
198
+ code = request.query_params.get("code", "")
199
+ states = request.app.state.oauth_states
200
+ if not state or state not in states:
201
+ return _page("Error", "", error="Invalid OAuth state; try logging in again.")
202
+ states.discard(state)
203
+ if not code:
204
+ return _page("Error", "", error="Missing OAuth code from GitHub.")
205
+
206
+ try:
207
+ token = await auth.exchange_code(
208
+ s.github_client_id, s.github_client_secret, code,
209
+ f"{s.external_url}/auth/github/callback",
210
+ )
211
+ profile = await auth.fetch_github_user(token)
212
+ except ValueError as exc:
213
+ return _page("Error", "", error=str(exc))
214
+
215
+ conn = _open_db(request)
216
+ try:
217
+ if not db.is_login_allowed(conn, profile["login"]):
218
+ return _page("Access denied", "",
219
+ error=f"GitHub user '{profile['login']}' is not on the allowlist.")
220
+ user = db.upsert_user(conn, profile["id"], profile["login"],
221
+ profile["name"], profile["avatar_url"])
222
+ session_token = auth.generate_session_token()
223
+ db.create_session(conn, user["id"], session_token)
224
+ finally:
225
+ conn.close()
226
+
227
+ resp = RedirectResponse("/", status_code=303)
228
+ resp.set_cookie(
229
+ SESSION_COOKIE, session_token,
230
+ max_age=db.SESSION_TTL, httponly=True, samesite="lax",
231
+ secure=s.external_url.startswith("https://"),
232
+ )
233
+ return resp
234
+
235
+
236
+ async def logout(request: Request) -> Response:
237
+ token = request.cookies.get(SESSION_COOKIE)
238
+ if token:
239
+ conn = _open_db(request)
240
+ try:
241
+ db.delete_session(conn, token)
242
+ finally:
243
+ conn.close()
244
+ resp = RedirectResponse("/login", status_code=303)
245
+ resp.delete_cookie(SESSION_COOKIE)
246
+ return resp
247
+
248
+
249
+ # ── web: documents ────────────────────────────────────────────────
250
+
251
+ async def web_index(request: Request) -> Response:
252
+ user, resp = _require_web_user(request)
253
+ if resp:
254
+ return resp
255
+ conn = _open_db(request)
256
+ try:
257
+ docs = db.list_documents(conn, user["id"])
258
+ finally:
259
+ conn.close()
260
+ rows = "".join(
261
+ f"<tr><td>{_e(d['app'])}</td>"
262
+ f"<td><a href='/docs/{_e(d['app'])}/{_e(d['name'])}'>{_e(d['name'])}</a></td>"
263
+ f"<td>v{d['version']}</td><td>{_fmt_ts(d['updated_at'])}</td>"
264
+ f"<td>{d['size']} B</td></tr>"
265
+ for d in docs
266
+ )
267
+ table = ("<table><tr><th>App</th><th>Name</th><th>Version</th>"
268
+ f"<th>Updated</th><th>Size</th></tr>{rows}</table>" if rows
269
+ else "<p class='muted'>No documents yet. Push one with the confsync CLI "
270
+ "or your app's integration.</p>")
271
+ body = f"<h1>Documents</h1>{table}"
272
+ return _page("Documents", body, user, **_flash_error(request))
273
+
274
+
275
+ async def web_doc_view(request: Request) -> Response:
276
+ user, resp = _require_web_user(request)
277
+ if resp:
278
+ return resp
279
+ app, name = request.path_params["app"], request.path_params["name"]
280
+ version_q = request.query_params.get("version")
281
+ conn = _open_db(request)
282
+ try:
283
+ row = db.get_document(conn, user["id"], app, name)
284
+ if row is None:
285
+ return _page("Not found", "", user, error=f"No document {app}/{name}.")
286
+ history = db.list_history(conn, user["id"], app, name)
287
+ if version_q:
288
+ hrow = db.get_history_version(conn, user["id"], app, name, int(version_q))
289
+ if hrow is None:
290
+ return _page("Not found", "", user, error=f"No version {version_q}.")
291
+ content, shown_version = _decrypt_doc(request, hrow), hrow["version"]
292
+ else:
293
+ content, shown_version = _decrypt_doc(request, row), row["version"]
294
+ finally:
295
+ conn.close()
296
+
297
+ hist_rows = "".join(
298
+ f"<tr><td>v{h['version']}</td><td>{_fmt_ts(h['saved_at'])}</td>"
299
+ f"<td>{h['size']} B</td>"
300
+ f"<td><a href='/docs/{_e(app)}/{_e(name)}?version={h['version']}'>view</a></td>"
301
+ f"<td><form class='inline' method='post' action='/docs/{_e(app)}/{_e(name)}/rollback'>"
302
+ f"<input type='hidden' name='version' value='{h['version']}'>"
303
+ f"<button type='submit'>rollback to this</button></form></td></tr>"
304
+ for h in history
305
+ )
306
+ hist_table = (f"<h2>History</h2><table><tr><th>Version</th><th>Saved</th><th>Size</th>"
307
+ f"<th></th><th></th></tr>{hist_rows}</table>" if hist_rows else "")
308
+ body = f"""
309
+ <h1>{_e(app)} / {_e(name)} <span class="muted">(showing v{shown_version})</span></h1>
310
+ <form method="post" action="/docs/{_e(app)}/{_e(name)}">
311
+ <textarea name="content" rows="24">{_e(content)}</textarea>
312
+ <p>
313
+ <button class="primary" type="submit">Save (new version)</button>
314
+ <a class="btn" href="/docs/{_e(app)}/{_e(name)}/raw">Download</a>
315
+ </p>
316
+ </form>
317
+ <form method="post" action="/docs/{_e(app)}/{_e(name)}/delete"
318
+ onsubmit="return confirm('Delete this document and its history?')">
319
+ <button class="danger" type="submit">Delete document</button>
320
+ </form>
321
+ {hist_table}
322
+ """
323
+ return _page(f"{app}/{name}", body, user, **_flash_error(request))
324
+
325
+
326
+ async def web_doc_save(request: Request) -> Response:
327
+ user, resp = _require_web_user(request)
328
+ if resp:
329
+ return resp
330
+ app, name = request.path_params["app"], request.path_params["name"]
331
+ form = await request.form()
332
+ content = str(form.get("content", ""))
333
+ if len(content.encode()) > MAX_CONTENT_BYTES:
334
+ return _page("Too large", "", user, error="Content exceeds 4 MB limit.")
335
+ version = _store_doc(request, user["id"], app, name, content)
336
+ return _redirect(f"/docs/{app}/{name}", flash=f"Saved as v{version}.")
337
+
338
+
339
+ async def web_doc_raw(request: Request) -> Response:
340
+ user, resp = _require_web_user(request)
341
+ if resp:
342
+ return resp
343
+ app, name = request.path_params["app"], request.path_params["name"]
344
+ version_q = request.query_params.get("version")
345
+ conn = _open_db(request)
346
+ try:
347
+ if version_q:
348
+ row = db.get_history_version(conn, user["id"], app, name, int(version_q))
349
+ else:
350
+ row = db.get_document(conn, user["id"], app, name)
351
+ if row is None:
352
+ return PlainTextResponse("not found", status_code=404)
353
+ content = _decrypt_doc(request, row)
354
+ finally:
355
+ conn.close()
356
+ return PlainTextResponse(content, headers={
357
+ "Content-Disposition": f'attachment; filename="{name.split("/")[-1]}"'
358
+ })
359
+
360
+
361
+ async def web_doc_delete(request: Request) -> Response:
362
+ user, resp = _require_web_user(request)
363
+ if resp:
364
+ return resp
365
+ app, name = request.path_params["app"], request.path_params["name"]
366
+ conn = _open_db(request)
367
+ try:
368
+ db.delete_document(conn, user["id"], app, name)
369
+ finally:
370
+ conn.close()
371
+ return _redirect("/", flash=f"Deleted {app}/{name}.")
372
+
373
+
374
+ async def web_doc_rollback(request: Request) -> Response:
375
+ user, resp = _require_web_user(request)
376
+ if resp:
377
+ return resp
378
+ app, name = request.path_params["app"], request.path_params["name"]
379
+ form = await request.form()
380
+ version = int(form.get("version", "0"))
381
+ conn = _open_db(request)
382
+ try:
383
+ hrow = db.get_history_version(conn, user["id"], app, name, version)
384
+ if hrow is None:
385
+ return _page("Not found", "", user, error=f"No history version {version}.")
386
+ content = _decrypt_doc(request, hrow)
387
+ finally:
388
+ conn.close()
389
+ new_version = _store_doc(request, user["id"], app, name, content)
390
+ return _redirect(f"/docs/{app}/{name}",
391
+ flash=f"Rolled back to v{version} content (saved as v{new_version}).")
392
+
393
+
394
+ # ── web: API keys ─────────────────────────────────────────────────
395
+
396
+ async def web_keys(request: Request) -> Response:
397
+ user, resp = _require_web_user(request)
398
+ if resp:
399
+ return resp
400
+ conn = _open_db(request)
401
+ try:
402
+ keys = db.list_api_keys(conn, user["id"])
403
+ finally:
404
+ conn.close()
405
+ rows = ""
406
+ for k in keys:
407
+ if k["revoked"]:
408
+ action = ""
409
+ status = "revoked"
410
+ else:
411
+ action = (
412
+ f"<form class='inline' method='post' action='/keys/{k['id']}/revoke'>"
413
+ f"<button class='danger' type='submit'>Revoke</button></form>"
414
+ )
415
+ status = ""
416
+ rows += (
417
+ f"<tr><td>{_e(k['name'])}</td><td><code>{_e(k['prefix'])}…</code></td>"
418
+ f"<td>{_fmt_ts(k['created_at'])}</td><td>{_fmt_ts(k['last_used_at'])}</td>"
419
+ f"<td>{status}</td><td>{action}</td></tr>"
420
+ )
421
+ table = ("<table><tr><th>Name</th><th>Prefix</th><th>Created</th><th>Last used</th>"
422
+ f"<th></th><th></th></tr>{rows}</table>" if rows
423
+ else "<p class='muted'>No API keys yet.</p>")
424
+ body = f"""
425
+ <h1>API Keys</h1>
426
+ {table}
427
+ <h2>Create key</h2>
428
+ <form method="post" action="/keys/create">
429
+ <input type="text" name="name" placeholder="key name (e.g. laptop)" required>
430
+ <button class="primary" type="submit">Create</button>
431
+ </form>
432
+ """
433
+ return _page("API Keys", body, user, **_flash_error(request))
434
+
435
+
436
+ async def web_key_create(request: Request) -> Response:
437
+ user, resp = _require_web_user(request)
438
+ if resp:
439
+ return resp
440
+ form = await request.form()
441
+ name = str(form.get("name", "")).strip() or "default"
442
+ plaintext = auth.generate_api_key()
443
+ conn = _open_db(request)
444
+ try:
445
+ db.create_api_key(conn, user["id"], name, plaintext)
446
+ finally:
447
+ conn.close()
448
+ body = f"""
449
+ <h1>API key created</h1>
450
+ <p>Copy it now — it will <b>not</b> be shown again:</p>
451
+ <code class="key">{_e(plaintext)}</code>
452
+ <p>Use it with: <code>confsync login --server {_e(_settings(request).external_url)}</code></p>
453
+ <p><a class="btn" href="/keys">Back to keys</a></p>
454
+ """
455
+ return _page("Key created", body, user)
456
+
457
+
458
+ async def web_key_revoke(request: Request) -> Response:
459
+ user, resp = _require_web_user(request)
460
+ if resp:
461
+ return resp
462
+ key_id = int(request.path_params["key_id"])
463
+ conn = _open_db(request)
464
+ try:
465
+ db.revoke_api_key(conn, user["id"], key_id)
466
+ finally:
467
+ conn.close()
468
+ return _redirect("/keys", flash="Key revoked.")
469
+
470
+
471
+ # ── web: admin ────────────────────────────────────────────────────
472
+
473
+ async def web_admin(request: Request) -> Response:
474
+ user, resp = _require_web_user(request)
475
+ if resp:
476
+ return resp
477
+ if not user["is_admin"]:
478
+ return _page("Forbidden", "", user, error="Admin only.")
479
+ conn = _open_db(request)
480
+ try:
481
+ allowed = db.list_allowed_logins(conn)
482
+ finally:
483
+ conn.close()
484
+ rows = "".join(
485
+ f"<tr><td>{_e(login)}</td>"
486
+ f"<td><form class='inline' method='post' action='/admin/disallow'>"
487
+ f"<input type='hidden' name='login' value='{_e(login)}'>"
488
+ f"<button class='danger' type='submit'>Remove</button></form></td></tr>"
489
+ for login in allowed
490
+ )
491
+ body = f"""
492
+ <h1>Admin — allowed GitHub logins</h1>
493
+ <table><tr><th>Login</th><th></th></tr>{rows}</table>
494
+ <h2>Add login</h2>
495
+ <form method="post" action="/admin/allow">
496
+ <input type="text" name="login" placeholder="github username" required>
497
+ <button class="primary" type="submit">Allow</button>
498
+ </form>
499
+ """
500
+ return _page("Admin", body, user, **_flash_error(request))
501
+
502
+
503
+ async def web_admin_allow(request: Request) -> Response:
504
+ user, resp = _require_web_user(request)
505
+ if resp:
506
+ return resp
507
+ if not user["is_admin"]:
508
+ return _page("Forbidden", "", user, error="Admin only.")
509
+ form = await request.form()
510
+ login = str(form.get("login", "")).strip()
511
+ if login:
512
+ conn = _open_db(request)
513
+ try:
514
+ db.allow_login(conn, login)
515
+ finally:
516
+ conn.close()
517
+ return _redirect("/admin", flash=f"Allowed {login}.")
518
+
519
+
520
+ async def web_admin_disallow(request: Request) -> Response:
521
+ user, resp = _require_web_user(request)
522
+ if resp:
523
+ return resp
524
+ if not user["is_admin"]:
525
+ return _page("Forbidden", "", user, error="Admin only.")
526
+ form = await request.form()
527
+ login = str(form.get("login", "")).strip()
528
+ conn = _open_db(request)
529
+ try:
530
+ db.disallow_login(conn, login)
531
+ finally:
532
+ conn.close()
533
+ return _redirect("/admin", flash=f"Removed {login}.")
534
+
535
+
536
+ # ── REST API ──────────────────────────────────────────────────────
537
+
538
+ async def api_whoami(request: Request) -> Response:
539
+ user, resp = _require_api_user(request)
540
+ if resp:
541
+ return resp
542
+ return JSONResponse({"login": user["login"], "name": user["name"]})
543
+
544
+
545
+ async def api_list(request: Request) -> Response:
546
+ user, resp = _require_api_user(request)
547
+ if resp:
548
+ return resp
549
+ conn = _open_db(request)
550
+ try:
551
+ docs = db.list_documents(conn, user["id"])
552
+ finally:
553
+ conn.close()
554
+ return JSONResponse({"documents": [
555
+ {"app": d["app"], "name": d["name"], "version": d["version"],
556
+ "updated_at": d["updated_at"], "size": d["size"]}
557
+ for d in docs
558
+ ]})
559
+
560
+
561
+ async def api_get(request: Request) -> Response:
562
+ user, resp = _require_api_user(request)
563
+ if resp:
564
+ return resp
565
+ app, name = request.path_params["app"], request.path_params["name"]
566
+ conn = _open_db(request)
567
+ try:
568
+ row = db.get_document(conn, user["id"], app, name)
569
+ if row is None:
570
+ return JSONResponse({"error": f"no document {app}/{name}"}, status_code=404)
571
+ return JSONResponse({
572
+ "app": app, "name": name, "version": row["version"],
573
+ "updated_at": row["updated_at"], "content": _decrypt_doc(request, row),
574
+ })
575
+ finally:
576
+ conn.close()
577
+
578
+
579
+ async def api_put(request: Request) -> Response:
580
+ user, resp = _require_api_user(request)
581
+ if resp:
582
+ return resp
583
+ app, name = request.path_params["app"], request.path_params["name"]
584
+ try:
585
+ body = await request.json()
586
+ except Exception:
587
+ return JSONResponse({"error": "invalid JSON body"}, status_code=400)
588
+ content = body.get("content")
589
+ if not isinstance(content, str):
590
+ return JSONResponse({"error": "body must be {\"content\": \"...\"}"}, status_code=400)
591
+ if len(content.encode()) > MAX_CONTENT_BYTES:
592
+ return JSONResponse({"error": "content exceeds 4 MB limit"}, status_code=413)
593
+ version = _store_doc(request, user["id"], app, name, content)
594
+ return JSONResponse({"app": app, "name": name, "version": version})
595
+
596
+
597
+ async def api_delete(request: Request) -> Response:
598
+ user, resp = _require_api_user(request)
599
+ if resp:
600
+ return resp
601
+ app, name = request.path_params["app"], request.path_params["name"]
602
+ conn = _open_db(request)
603
+ try:
604
+ existed = db.delete_document(conn, user["id"], app, name)
605
+ finally:
606
+ conn.close()
607
+ if not existed:
608
+ return JSONResponse({"error": f"no document {app}/{name}"}, status_code=404)
609
+ return JSONResponse({"deleted": f"{app}/{name}"})
610
+
611
+
612
+ async def api_history(request: Request) -> Response:
613
+ user, resp = _require_api_user(request)
614
+ if resp:
615
+ return resp
616
+ app, name = request.path_params["app"], request.path_params["name"]
617
+ conn = _open_db(request)
618
+ try:
619
+ rows = db.list_history(conn, user["id"], app, name)
620
+ finally:
621
+ conn.close()
622
+ return JSONResponse({"history": [
623
+ {"version": r["version"], "saved_at": r["saved_at"], "size": r["size"]}
624
+ for r in rows
625
+ ]})
626
+
627
+
628
+ async def api_history_get(request: Request) -> Response:
629
+ user, resp = _require_api_user(request)
630
+ if resp:
631
+ return resp
632
+ app, name = request.path_params["app"], request.path_params["name"]
633
+ version = int(request.path_params["version"])
634
+ conn = _open_db(request)
635
+ try:
636
+ row = db.get_history_version(conn, user["id"], app, name, version)
637
+ if row is None:
638
+ return JSONResponse({"error": f"no version {version}"}, status_code=404)
639
+ return JSONResponse({
640
+ "app": app, "name": name, "version": version,
641
+ "saved_at": row["saved_at"], "content": _decrypt_doc(request, row),
642
+ })
643
+ finally:
644
+ conn.close()
645
+
646
+
647
+ # ── app factory ───────────────────────────────────────────────────
648
+
649
+ def create_app(settings: ServerSettings | None = None) -> Starlette:
650
+ settings = settings or load_settings()
651
+ master_key = crypto.load_or_create_master_key(settings.home)
652
+
653
+ @asynccontextmanager
654
+ async def lifespan(app: Starlette):
655
+ conn = db.connect(settings.db_path)
656
+ try:
657
+ db.seed_allowed_logins(conn, settings.allowed_users)
658
+ finally:
659
+ conn.close()
660
+ yield
661
+
662
+ # Specific routes must precede the generic {name:path} routes.
663
+ routes = [
664
+ Route("/", web_index),
665
+ Route("/login", login_page),
666
+ Route("/auth/github/login", github_login),
667
+ Route("/auth/github/callback", github_callback),
668
+ Route("/logout", logout),
669
+ Route("/keys", web_keys),
670
+ Route("/keys/create", web_key_create, methods=["POST"]),
671
+ Route("/keys/{key_id:int}/revoke", web_key_revoke, methods=["POST"]),
672
+ Route("/admin", web_admin),
673
+ Route("/admin/allow", web_admin_allow, methods=["POST"]),
674
+ Route("/admin/disallow", web_admin_disallow, methods=["POST"]),
675
+ Route("/docs/{app}/{name:path}/raw", web_doc_raw),
676
+ Route("/docs/{app}/{name:path}/rollback", web_doc_rollback, methods=["POST"]),
677
+ Route("/docs/{app}/{name:path}/delete", web_doc_delete, methods=["POST"]),
678
+ Route("/docs/{app}/{name:path}", web_doc_view),
679
+ Route("/docs/{app}/{name:path}", web_doc_save, methods=["POST"]),
680
+ Route("/api/v1/whoami", api_whoami),
681
+ Route("/api/v1/documents", api_list),
682
+ Route("/api/v1/documents/{app}/{name:path}/history/{version:int}", api_history_get),
683
+ Route("/api/v1/documents/{app}/{name:path}/history", api_history),
684
+ Route("/api/v1/documents/{app}/{name:path}", api_get, methods=["GET"]),
685
+ Route("/api/v1/documents/{app}/{name:path}", api_put, methods=["PUT"]),
686
+ Route("/api/v1/documents/{app}/{name:path}", api_delete, methods=["DELETE"]),
687
+ ]
688
+
689
+ app = Starlette(routes=routes, lifespan=lifespan)
690
+ app.state.settings = settings
691
+ app.state.master_key = master_key
692
+ app.state.oauth_states = set()
693
+ return app