255 lines
8.2 KiB
Python
255 lines
8.2 KiB
Python
# -*- coding: utf-8 -*-
|
|
"""Astraea data layer — no-KYC auth, profiles (avatar + About Me), and settings.
|
|
SQLite at /opt/astraea/astraea.db. stdlib-only.
|
|
"""
|
|
import hashlib
|
|
import json
|
|
import secrets
|
|
import sqlite3
|
|
|
|
DB_PATH = "/opt/astraea/astraea.db"
|
|
|
|
|
|
def _conn():
|
|
c = sqlite3.connect(DB_PATH)
|
|
c.row_factory = sqlite3.Row
|
|
return c
|
|
|
|
|
|
def init_db():
|
|
c = _conn()
|
|
c.executescript("""
|
|
CREATE TABLE IF NOT EXISTS users (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
username TEXT UNIQUE NOT NULL,
|
|
password_hash TEXT NOT NULL,
|
|
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
|
|
);
|
|
CREATE TABLE IF NOT EXISTS sessions (
|
|
token TEXT PRIMARY KEY,
|
|
user_id INTEGER NOT NULL,
|
|
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
|
|
);
|
|
CREATE TABLE IF NOT EXISTS profiles (
|
|
user_id INTEGER PRIMARY KEY,
|
|
display_name TEXT DEFAULT '',
|
|
avatar INTEGER DEFAULT 0,
|
|
about_me TEXT DEFAULT '',
|
|
profile_pic TEXT DEFAULT '',
|
|
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
|
|
);
|
|
CREATE TABLE IF NOT EXISTS settings (
|
|
user_id INTEGER PRIMARY KEY,
|
|
twilio_sid TEXT DEFAULT '',
|
|
twilio_auth_token TEXT DEFAULT '',
|
|
twilio_from TEXT DEFAULT '',
|
|
smtp_host TEXT DEFAULT '',
|
|
smtp_port INTEGER DEFAULT 587,
|
|
smtp_user TEXT DEFAULT '',
|
|
smtp_pass TEXT DEFAULT '',
|
|
email_from TEXT DEFAULT '',
|
|
no_contact_order INTEGER DEFAULT 0,
|
|
partner_name TEXT DEFAULT '',
|
|
domestic_violence INTEGER DEFAULT 0,
|
|
protection_order INTEGER DEFAULT 0,
|
|
safety_notes TEXT DEFAULT '',
|
|
tts_voice TEXT DEFAULT 'aria'
|
|
);
|
|
CREATE TABLE IF NOT EXISTS messages (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
user_id INTEGER NOT NULL,
|
|
agent_id TEXT NOT NULL,
|
|
role TEXT NOT NULL,
|
|
content TEXT NOT NULL,
|
|
citations TEXT DEFAULT '',
|
|
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
|
|
);
|
|
CREATE TABLE IF NOT EXISTS files (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
user_id INTEGER NOT NULL,
|
|
category TEXT DEFAULT 'Other',
|
|
filename TEXT NOT NULL,
|
|
orig_name TEXT NOT NULL,
|
|
mime TEXT DEFAULT '',
|
|
size INTEGER DEFAULT 0,
|
|
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
|
|
);
|
|
""")
|
|
c.commit()
|
|
# migrations for pre-existing DBs
|
|
for col, ddl in [("domestic_violence", "INTEGER DEFAULT 0"),
|
|
("protection_order", "INTEGER DEFAULT 0"),
|
|
("safety_notes", "TEXT DEFAULT ''")]:
|
|
try:
|
|
c.execute(f"ALTER TABLE settings ADD COLUMN {col} {ddl}")
|
|
c.commit()
|
|
except Exception:
|
|
pass
|
|
try:
|
|
c.execute("ALTER TABLE profiles ADD COLUMN profile_pic TEXT DEFAULT ''")
|
|
c.commit()
|
|
except Exception:
|
|
pass
|
|
c.close()
|
|
|
|
|
|
def hash_password(pw):
|
|
return hashlib.sha256(pw.encode()).hexdigest()
|
|
|
|
|
|
def user_from_token(token):
|
|
if not token:
|
|
return None
|
|
c = _conn()
|
|
row = c.execute("SELECT user_id FROM sessions WHERE token=?", (token,)).fetchone()
|
|
c.close()
|
|
return row["user_id"] if row else None
|
|
|
|
|
|
def create_user(username, password):
|
|
c = _conn()
|
|
c.execute("INSERT INTO users (username, password_hash) VALUES (?,?)",
|
|
(username, hash_password(password)))
|
|
c.commit()
|
|
uid = c.execute("SELECT id FROM users WHERE username=?", (username,)).fetchone()["id"]
|
|
c.execute("INSERT OR IGNORE INTO profiles (user_id) VALUES (?)", (uid,))
|
|
c.execute("INSERT OR IGNORE INTO settings (user_id) VALUES (?)", (uid,))
|
|
c.commit()
|
|
c.close()
|
|
return uid
|
|
|
|
|
|
def issue_token(uid):
|
|
token = secrets.token_hex(32)
|
|
c = _conn()
|
|
c.execute("INSERT INTO sessions (token, user_id) VALUES (?,?)", (token, uid))
|
|
c.commit()
|
|
c.close()
|
|
return token
|
|
|
|
|
|
def authenticate(username, password):
|
|
c = _conn()
|
|
row = c.execute("SELECT id, password_hash FROM users WHERE username=?",
|
|
(username,)).fetchone()
|
|
c.close()
|
|
if row and row["password_hash"] == hash_password(password):
|
|
return row["id"]
|
|
return None
|
|
|
|
|
|
def get_profile(uid):
|
|
c = _conn()
|
|
row = c.execute("SELECT * FROM profiles WHERE user_id=?", (uid,)).fetchone()
|
|
c.close()
|
|
if not row:
|
|
return {"display_name": "", "avatar": 0, "about_me": "", "profile_pic": ""}
|
|
return {"display_name": row["display_name"], "avatar": row["avatar"],
|
|
"about_me": row["about_me"], "profile_pic": row["profile_pic"] or ""}
|
|
|
|
|
|
def set_profile(uid, display_name=None, avatar=None, about_me=None, profile_pic=None):
|
|
cur = get_profile(uid)
|
|
dn = cur["display_name"] if display_name is None else display_name
|
|
av = cur["avatar"] if avatar is None else avatar
|
|
am = cur["about_me"] if about_me is None else about_me
|
|
pp = cur.get("profile_pic", "") if profile_pic is None else profile_pic
|
|
c = _conn()
|
|
c.execute("""INSERT INTO profiles (user_id, display_name, avatar, about_me, profile_pic, updated_at)
|
|
VALUES (?,?,?,?,?, CURRENT_TIMESTAMP)
|
|
ON CONFLICT(user_id) DO UPDATE SET
|
|
display_name=excluded.display_name, avatar=excluded.avatar,
|
|
about_me=excluded.about_me, profile_pic=excluded.profile_pic, updated_at=CURRENT_TIMESTAMP""",
|
|
(uid, dn, av, am, pp))
|
|
c.commit()
|
|
c.close()
|
|
return {"display_name": dn, "avatar": av, "about_me": am, "profile_pic": pp}
|
|
|
|
|
|
def get_settings(uid):
|
|
c = _conn()
|
|
row = c.execute("SELECT * FROM settings WHERE user_id=?", (uid,)).fetchone()
|
|
c.close()
|
|
if not row:
|
|
return {}
|
|
# strip auth secrets from the read-back for safety, but return everything to owner
|
|
return dict(row)
|
|
|
|
|
|
def save_message(uid, agent_id, role, content, citations=None):
|
|
c = _conn()
|
|
c.execute("INSERT INTO messages (user_id, agent_id, role, content, citations) VALUES (?,?,?,?,?)",
|
|
(uid, agent_id, role, content, json.dumps(citations or [])))
|
|
c.commit()
|
|
c.close()
|
|
|
|
|
|
def get_conversation(uid, agent_id, limit=60):
|
|
c = _conn()
|
|
rows = c.execute(
|
|
"SELECT role, content, citations FROM messages WHERE user_id=? AND agent_id=? ORDER BY id DESC LIMIT ?",
|
|
(uid, agent_id, limit)).fetchall()
|
|
c.close()
|
|
out = []
|
|
for r in reversed(rows):
|
|
try:
|
|
cit = json.loads(r["citations"]) if r["citations"] else []
|
|
except Exception:
|
|
cit = []
|
|
out.append({"role": r["role"], "content": r["content"], "citations": cit})
|
|
return out
|
|
|
|
|
|
def clear_conversation(uid, agent_id):
|
|
c = _conn()
|
|
c.execute("DELETE FROM messages WHERE user_id=? AND agent_id=?", (uid, agent_id))
|
|
c.commit()
|
|
c.close()
|
|
|
|
|
|
def set_settings(uid, **fields):
|
|
allowed = {"twilio_sid", "twilio_auth_token", "twilio_from", "smtp_host", "smtp_port",
|
|
"smtp_user", "smtp_pass", "email_from", "no_contact_order", "partner_name",
|
|
"domestic_violence", "protection_order", "safety_notes", "tts_voice"}
|
|
updates = {k: v for k, v in fields.items() if k in allowed}
|
|
if not updates:
|
|
return get_settings(uid)
|
|
cols = ", ".join(f"{k}=?" for k in updates)
|
|
c = _conn()
|
|
c.execute(f"UPDATE settings SET {cols} WHERE user_id=?", (*updates.values(), uid))
|
|
c.commit()
|
|
c.close()
|
|
return get_settings(uid)
|
|
|
|
|
|
# ── Document vault ──
|
|
def add_file(uid, category, filename, orig_name, mime, size):
|
|
c = _conn()
|
|
c.execute("INSERT INTO files (user_id, category, filename, orig_name, mime, size) VALUES (?,?,?,?,?,?)",
|
|
(uid, category, filename, orig_name, mime, size))
|
|
c.commit()
|
|
fid = c.execute("SELECT last_insert_rowid()").fetchone()[0]
|
|
c.close()
|
|
return fid
|
|
|
|
|
|
def list_files(uid):
|
|
c = _conn()
|
|
rows = c.execute("SELECT * FROM files WHERE user_id=? ORDER BY created_at DESC, id DESC", (uid,)).fetchall()
|
|
c.close()
|
|
return [dict(r) for r in rows]
|
|
|
|
|
|
def get_file(uid, fid):
|
|
c = _conn()
|
|
row = c.execute("SELECT * FROM files WHERE id=? AND user_id=?", (fid, uid)).fetchone()
|
|
c.close()
|
|
return dict(row) if row else None
|
|
|
|
|
|
def delete_file(uid, fid):
|
|
c = _conn()
|
|
c.execute("DELETE FROM files WHERE id=? AND user_id=?", (fid, uid))
|
|
c.commit()
|
|
c.close()
|