SPB Git

Repository Public

semantic.ts 22.8 KB 326 lines typescript

1// SP Mail Next — recherche sémantique (D-N8) : embeddings calculés sur l'infrastructure du propriétaire (point /embeddings du fournisseur2// local s'il existe, sinon petit modèle multilingue chargé dans le processus), vecteurs en real[] dans PostgreSQL, classement par cosinus3// en mémoire, fusion avec la recherche par mots de JMAP. Sans moteur d'embedding : `available: false` et 409 — jamais de faux résultats.4import type { FastifyInstance } from "fastify"5import { z } from "zod"6import { config } from "../config.js"7import { sql } from "../db.js"8import { folders, jmapOk, type Mbx } from "../mailjmap.js"9import { bad, parse, zUuid } from "../util.js"10import { aiGate, bodyText, loadEmails, loadSettings, summaryOf, SUMMARY_PROPS } from "./ai.js"11import { stripQuoted } from "./ai-prompts.js"12import { nextUser, userMailboxes } from "./common.js"13import { onInbound } from "./hooks.js"14import type { NextWorker } from "./index.js"15import { beat } from "./ops.js"1617// ------------------------------------------------------------------ mathématiques du classement (pures, testées à part)18export function normalize(v: ArrayLike<number>): Float32Array {19  let s = 020  for (let i = 0; i < v.length; i++) s += v[i] * v[i]21  const n = Math.sqrt(s)22  const out = new Float32Array(v.length)23  if (n > 0) for (let i = 0; i < v.length; i++) out[i] = v[i] / n24  return out25}26export function cosine(a: ArrayLike<number>, b: ArrayLike<number>): number {27  if (a.length !== b.length || !a.length) return 028  let dot = 0, na = 0, nb = 029  for (let i = 0; i < a.length; i++) { dot += a[i] * b[i]; na += a[i] * a[i]; nb += b[i] * b[i] }30  return na && nb ? dot / Math.sqrt(na * nb) : 031}32/** Les k meilleurs produits scalaires d'une requête normalisée contre une matrice de vecteurs normalisés (lignes de `dim` valeurs). */33export function topK(matrix: Float32Array, dim: number, query: Float32Array, k: number, keep?: (row: number) => boolean): { row: number; score: number }[] {34  const best: { row: number; score: number }[] = []35  const n = dim ? Math.floor(matrix.length / dim) : 036  for (let r = 0; r < n; r++) {37    if (keep && !keep(r)) continue38    let dot = 039    const off = r * dim40    for (let i = 0; i < dim; i++) dot += matrix[off + i] * query[i]41    if (best.length < k) { best.push({ row: r, score: dot }); if (best.length === k) best.sort((a, b) => b.score - a.score) }42    else if (dot > best[k - 1].score) {43      let i = k - 144      while (i > 0 && best[i - 1].score < dot) { best[i] = best[i - 1]; i-- }45      best[i] = { row: r, score: dot }46    }47  }48  return best.sort((a, b) => b.score - a.score)49}50export const W_SEMANTIC = 0.65, W_KEYWORD = 0.3551export type Ranked = { key: string; score: number; match: "semantic" | "keyword" | "both" }52/**53 * Fusion hybride : score = 0,65 × cosinus (borné à [0, 1]) + 0,35 × score de mots, ce dernier valant de 1 (premier résultat de la54 * recherche par mots de sa boîte) à 0,5 (dernier). Un message trouvé des deux façons passe devant ; les égalités gardent l'ordre sémantique.55 */56export function hybridRank(semantic: { key: string; score: number }[], keywordLists: string[][], limit: number): Ranked[] {57  const m = new Map<string, { s: number; k: number; order: number }>()58  let order = 059  for (const x of semantic) m.set(x.key, { s: Math.min(1, Math.max(0, x.score)), k: 0, order: order++ })60  for (const list of keywordLists) list.forEach((key, i) => {61    const kw = 1 - 0.5 * (list.length > 1 ? i / (list.length - 1) : 0)62    const cur = m.get(key)63    if (cur) cur.k = Math.max(cur.k, kw); else m.set(key, { s: 0, k: kw, order: order++ })64  })65  return [...m.entries()].map(([key, v]) => ({ key, score: Number((W_SEMANTIC * v.s + W_KEYWORD * v.k).toFixed(6)), match: (v.s > 0 && v.k > 0 ? "both" : v.k > 0 ? "keyword" : "semantic") as Ranked["match"], order: v.order }))66    .sort((a, b) => b.score - a.score || a.order - b.order).slice(0, limit).map(({ key, score, match }) => ({ key, score, match }))67}6869/** TEST SEULEMENT : sac de mots haché (256 dimensions), déterministe et sans modèle. Deux textes qui partagent des mots ont un cosinus > 0. */70export function fakeEmbedding(text: string, dim = 256): Float32Array {71  const v = new Float32Array(dim)72  for (const w of text.toLowerCase().normalize("NFKD").replace(/[̀-ͯ]/g, "").split(/[^a-z0-9]+/).filter((x) => x.length >= 2)) {73    let h = 216613626174    for (let i = 0; i < w.length; i++) { h ^= w.charCodeAt(i); h = Math.imul(h, 16777619) }75    v[(h >>> 0) % dim] += 176  }77  return normalize(v)78}7980// ------------------------------------------------------------------ moteurs d'embedding81type Kind = "query" | "passage"82type Backend = { name: "fake" | "endpoint" | "inprocess"; model: string; embed(texts: string[], kind: Kind): Promise<Float32Array[]> }83/** Cause stable de l'indisponibilité (les clients la traduisent ; `reason` reste un texte anglais de diagnostic). */84export type ReasonCode = "disabled_on_server" | "endpoint_not_configured" | "endpoint_failed" | "model_not_installed" | "backend_failed" | "no_backend"85let resolved: { at: number; backend: Backend | null; reason: string; code: ReasonCode | null } | undefined86const RECHECK_MS = 10 * 60_0008788const fakeBackend: Backend = { name: "fake", model: "fake-hash-256", embed: async (texts) => texts.map((t) => fakeEmbedding(t)) }8990async function endpointEmbed(model: string, texts: string[]): Promise<Float32Array[]> {91  const r = await fetch(`${config.aiLocalUrl}/embeddings`, {92    method: "POST", headers: { "content-type": "application/json", ...(config.aiLocalKey ? { authorization: `Bearer ${config.aiLocalKey}` } : {}) },93    body: JSON.stringify({ model, input: texts }), signal: AbortSignal.timeout(config.aiTimeoutMs),94  })95  if (!r.ok) { await r.arrayBuffer().catch(() => undefined); throw new Error(`embeddings endpoint answered ${r.status}`) }96  const j = (await r.json()) as { data?: { index?: number; embedding?: number[] }[] }97  const data = [...(j.data ?? [])].sort((a, b) => (a.index ?? 0) - (b.index ?? 0))98  if (data.length !== texts.length || data.some((d) => !Array.isArray(d.embedding) || !d.embedding.length)) throw new Error("embeddings endpoint returned an unexpected shape")99  return data.map((d) => normalize(d.embedding!))100}101function endpointBackend(): Backend {102  const model = config.aiEmbedEndpointModel || config.aiLocalModel103  return { name: "endpoint", model, embed: (texts) => endpointEmbed(model, texts) }104}105106// Modèle en processus : dépendance FACULTATIVE, importée dynamiquement (le serveur démarre sans elle). Le modèle n'est chargé qu'au premier calcul.107const TRANSFORMERS = "@huggingface/transformers"108type Extractor = (texts: string[], o: { pooling: "mean"; normalize: boolean }) => Promise<{ tolist(): number[][] }>109let extractor: Promise<Extractor> | undefined110function inprocessBackend(): Backend {111  import.meta.resolve(TRANSFORMERS) // lève si la dépendance facultative n'est pas installée ; rien n'est chargé à ce stade112  const load = () => (extractor ??= (import(TRANSFORMERS) as Promise<{ env?: { cacheDir?: string }; pipeline: (task: string, model: string, o?: Record<string, unknown>) => Promise<Extractor> }>)113    .then((mod) => {114      // Cache du modèle hors de node_modules (une réinstallation ne le retélécharge pas) quand SPMAIL_AI_EMBED_CACHE_DIR est défini.115      if (process.env.SPMAIL_AI_EMBED_CACHE_DIR && mod.env) mod.env.cacheDir = process.env.SPMAIL_AI_EMBED_CACHE_DIR116      return mod.pipeline("feature-extraction", config.aiEmbedModel, { dtype: "q8" })117    }).catch((e) => { extractor = undefined; throw e }))118  // Les modèles E5 attendent un préfixe : « query: » pour la requête, « passage: » pour les documents.119  const e5 = /e5/i.test(config.aiEmbedModel)120  return {121    name: "inprocess", model: config.aiEmbedModel,122    embed: async (texts, kind) => (await (await load())(texts.map((t) => (e5 ? `${kind}: ${t}` : t)), { pooling: "mean", normalize: true })).tolist().map((v) => normalize(v)),123  }124}125126async function resolveBackend(): Promise<{ backend: Backend | null; reason: string; code: ReasonCode | null }> {127  if (resolved && (resolved.backend || Date.now() - resolved.at < RECHECK_MS)) return resolved128  const set = (backend: Backend | null, reason: string, code: ReasonCode | null = null) => (resolved = { at: Date.now(), backend, reason, code: backend ? null : code ?? "no_backend" })129  const mode = config.aiEmbedBackend130  if (config.aiEmbedFake) return set(fakeBackend, "")131  if (mode === "off") return set(null, "semantic search is disabled on this server (SPMAIL_AI_EMBED_BACKEND=off)", "disabled_on_server")132  const reasons: string[] = []133  // Le code retenu est celui de la dernière tentative : c'est elle qui décide de l'indisponibilité.134  let code: ReasonCode = "no_backend"135  if ((mode === "auto" || mode === "endpoint") && config.aiLocalUrl) {136    const b = endpointBackend()137    try { await b.embed(["probe"], "query"); return set(b, "") } catch (e) { reasons.push(`local endpoint: ${String((e as Error).message).slice(0, 120)}`); code = "endpoint_failed" }138  } else if (mode === "endpoint") { reasons.push("local endpoint: SPMAIL_AI_LOCAL_URL is not set"); code = "endpoint_not_configured" }139  if (mode === "auto" || mode === "inprocess") {140    try { return set(inprocessBackend(), "") } catch { reasons.push(`in-process model: optional dependency ${TRANSFORMERS} is not installed`); code = "model_not_installed" }141  }142  return set(null, reasons.join("; ") || "no embedding backend", code)143}144export async function embeddingStatus(): Promise<{ available: boolean; backend: string | null; model: string | null; reason: string | null; reason_code: ReasonCode | null }> {145  const r = await resolveBackend()146  return { available: !!r.backend, backend: r.backend?.name ?? null, model: r.backend?.model ?? null, reason: r.backend ? null : r.reason, reason_code: r.backend ? null : r.code }147}148async function requireBackend(): Promise<Backend> {149  const r = await resolveBackend()150  if (!r.backend) throw bad("semantic_unavailable", 409, `Semantic search is unavailable: ${r.reason}`)151  return r.backend152}153/** Calcul protégé : un moteur qui échoue (modèle introuvable, point d'accès tombé) rend la fonction indisponible, sans résultat inventé. */154async function embed(b: Backend, texts: string[], kind: Kind): Promise<Float32Array[]> {155  try { return await b.embed(texts, kind) } catch (e) {156    if (b.name !== "fake") resolved = { at: Date.now(), backend: null, reason: `${b.name}: ${String((e as Error).message).slice(0, 160)}`, code: "backend_failed" }157    throw bad("semantic_unavailable", 409, "Semantic search is unavailable: the embedding backend failed")158  }159}160161// ------------------------------------------------------------------ index : file, travailleur, cache en mémoire162type E = Record<string, any> & { id: string }163const textOf = (e: E) => `${String(e.subject ?? "")}\n${stripQuoted(bodyText(e), 0)}`.slice(0, 2000)164const semanticOn = async (userId: string) => { const s = await loadSettings(userId); return s.provider !== "off" && s.features.semantic }165166/** Efface l'index d'un utilisateur (désactivation de la fonction) : vecteurs et file d'attente. */167export async function dropIndex(userId: string) {168  await sql`delete from mail_embeddings where user_id = ${userId}`169  await sql`delete from semantic_queue where user_id = ${userId}`170  cache.delete(userId)171}172173async function indexBatch() {174  const jobs = await sql`update semantic_queue set locked_until = now() + interval '2 minutes'175    where id in (select id from semantic_queue where next_attempt_at <= now() and (locked_until is null or locked_until < now()) order by id limit 24 for update skip locked)176    returning id, user_id, mailbox_id, email_id, attempts`177  if (!jobs.length) return178  const release = (ids: number[], delaySec: number, error: string | null, countAttempt: boolean) =>179    sql`update semantic_queue set locked_until = null, next_attempt_at = now() + make_interval(secs => ${delaySec}), last_error = ${error}, attempts = attempts + ${countAttempt ? 1 : 0} where id = any(${ids})`180  const backend = (await resolveBackend()).backend181  // Aucun moteur : la file attend (sans compter de tentative) — rien n'est indexé « à blanc ».182  if (!backend) { await release(jobs.map((j) => j.id), 600, "no embedding backend", false); return }183  const byBox = new Map<string, typeof jobs>()184  for (const j of jobs) byBox.set(j.mailbox_id, [...(byBox.get(j.mailbox_id) ?? []), j] as never)185  for (const [mailboxId, list] of byBox) {186    const ids = list.map((j) => j.id as number)187    try {188      const [mb] = (await sql`select id, user_id, address, display_name, stalwart_id, secret_enc from mailboxes where id = ${mailboxId}`) as unknown as Mbx[]189      if (!mb || !(await semanticOn(mb.user_id))) { await sql`delete from semantic_queue where id = any(${ids})`; continue }190      const fl = await folders(mb)191      const skip = new Set(fl.filter((f) => ["trash", "junk", "drafts"].includes(f.role ?? "")).map((f) => f.id))192      const emails = (await loadEmails(mb, list.map((j) => j.email_id as string))).filter((e) => !e.keywords?.$draft && !Object.keys(e.mailboxIds ?? {}).every((id) => skip.has(id)))193      if (emails.length) {194        const vecs = await embed(backend, emails.map(textOf), "passage")195        for (const [i, e] of emails.entries())196          await sql`insert into mail_embeddings (user_id, mailbox_id, email_id, thread_id, model, dim, vec, received_at)197            values (${mb.user_id}, ${mb.id}, ${e.id}, ${e.threadId ?? null}, ${backend.model}, ${vecs[i].length}, ${Array.from(vecs[i])}::real[], ${e.receivedAt ?? null})198            on conflict (mailbox_id, email_id, model) do update set vec = excluded.vec, dim = excluded.dim, thread_id = excluded.thread_id, created_at = now()`199      }200      await sql`delete from semantic_queue where id = any(${ids})` // indexés, ou disparus / non indexables : la file avance201    } catch (e) {202      const dead = list.filter((j) => j.attempts >= 4).map((j) => j.id as number)203      if (dead.length) await sql`delete from semantic_queue where id = any(${dead})`204      await release(ids.filter((id) => !dead.includes(id)), 30, String((e as Error).message ?? e).slice(0, 200), true)205    }206  }207}208209type UserIndex = { sig: string; model: string; dim: number; matrix: Float32Array; rows: { mailbox_id: string; email_id: string }[] }210const cache = new Map<string, UserIndex>()211/** Vecteurs d'un utilisateur en mémoire (Float32Array contiguë). La signature (nombre, dernier identifiant) invalide le cache à toute écriture. */212async function userIndex(userId: string, model: string): Promise<UserIndex> {213  const [s] = await sql`select count(*)::int as n, coalesce(max(id), 0) as m from mail_embeddings where user_id = ${userId} and model = ${model}`214  const sig = `${model}:${s.n}:${s.m}`215  const c = cache.get(userId)216  if (c && c.sig === sig) return c217  const rows = await sql`select mailbox_id, email_id, dim, vec from mail_embeddings where user_id = ${userId} and model = ${model} order by id`218  const dim = rows.length ? Number(rows[0].dim) : 0219  const good = rows.filter((r) => Number(r.dim) === dim && (r.vec as number[]).length === dim)220  const matrix = new Float32Array(good.length * dim)221  good.forEach((r, i) => matrix.set(r.vec as number[], i * dim))222  const idx: UserIndex = { sig, model, dim, matrix, rows: good.map((r) => ({ mailbox_id: r.mailbox_id, email_id: r.email_id })) }223  cache.set(userId, idx)224  if (cache.size > 50) cache.delete(cache.keys().next().value as string)225  return idx226}227228// ------------------------------------------------------------------ routes229export function semanticRoutes(app: FastifyInstance) {230  // Crochet du veilleur (écritures en base seulement) : réceptions mises en file si l'utilisateur a activé l'index ; messages détruits retirés.231  onInbound("semantic", async (tx, batch) => {232    if (batch.destroyed.length) {233      await tx`delete from mail_embeddings where mailbox_id = ${batch.mb.id} and email_id = any(${batch.destroyed})`234      await tx`delete from semantic_queue where mailbox_id = ${batch.mb.id} and email_id = any(${batch.destroyed})`235    }236    if (!batch.received.length) return237    const [on] = await tx`select 1 from ai_settings where user_id = ${batch.mb.user_id} and provider <> 'off' and (features->>'semantic')::boolean is true`238    if (!on) return239    for (const r of batch.received) await tx`insert into semantic_queue (user_id, mailbox_id, email_id) values (${batch.mb.user_id}, ${batch.mb.id}, ${r.email.id}) on conflict (mailbox_id, email_id) do nothing`240  })241242  app.post("/api/next/ai/search", async (req) => {243    const a = await nextUser(req, "ai", 120)244    const b = parse(z.object({ q: z.string().trim().min(1).max(500), mailboxes: z.array(zUuid).max(50).optional(), limit: z.number().int().min(1).max(100).default(25) }).strict(), req.body)245    await aiGate(a.userId, "semantic")246    const backend = await requireBackend()247    const boxes = (await userMailboxes(a.userId)).filter((m) => !b.mailboxes || b.mailboxes.includes(m.id))248    if (b.mailboxes && boxes.length !== new Set(b.mailboxes).size) throw bad("not_found", 404)249    const t0 = Date.now()250    const [qv] = await embed(backend, [b.q], "query")251    const idx = await userIndex(a.userId, backend.model)252    const allowed = new Set(boxes.map((m) => m.id))253    const sem = idx.dim === qv.length ? topK(idx.matrix, idx.dim, qv, b.limit * 2, (r) => allowed.has(idx.rows[r].mailbox_id)).filter((x) => x.score > 0.05).map((x) => ({ key: `${idx.rows[x.row].mailbox_id}:${idx.rows[x.row].email_id}`, score: x.score })) : []254    // Recherche par mots, boîte par boîte (filtre `text` de JMAP) : une boîte injoignable n'empêche pas les autres de répondre.255    const kw = await Promise.all(boxes.map(async (mb) => {256      const [r] = await jmapOk(mb, [["Email/query", { filter: { text: b.q }, sort: [{ property: "receivedAt", isAscending: false }], limit: b.limit }]]).catch(() => [{ ids: [] as string[] }])257      return (r.ids as string[]).map((id) => `${mb.id}:${id}`)258    }))259    const ranked = hybridRank(sem, kw, b.limit)260    const data: (ReturnType<typeof summaryOf> & { score: number; match: string })[] = []261    const gone: { mailbox_id: string; email_id: string }[] = []262    for (const mb of boxes) {263      const mine = ranked.filter((r) => r.key.startsWith(`${mb.id}:`))264      if (!mine.length) continue265      const [g] = await jmapOk(mb, [["Email/get", { ids: mine.map((r) => r.key.slice(mb.id.length + 1)), properties: SUMMARY_PROPS }]])266      const byId = new Map((g.list as E[]).map((e) => [e.id, e]))267      const fl = await folders(mb, false, (g.list as E[]).flatMap((e) => Object.keys(e.mailboxIds ?? {}))).catch(() => [])268      for (const r of mine) {269        const e = byId.get(r.key.slice(mb.id.length + 1))270        if (e) data.push({ ...summaryOf(mb.id, e, fl), score: r.score, match: r.match }); else gone.push({ mailbox_id: mb.id, email_id: r.key.slice(mb.id.length + 1) })271      }272    }273    // Vecteur d'un message qui n'existe plus (suppression non encore vue par le veilleur) : retiré de l'index, jamais rendu.274    for (const g of gone) await sql`delete from mail_embeddings where mailbox_id = ${g.mailbox_id} and email_id = ${g.email_id}`275    await sql`insert into ai_usage (user_id, feature, provider, model, duration_ms, status) values (${a.userId}, 'semantic', ${`embed:${backend.name}`}, ${backend.model}, ${Date.now() - t0}, 'ok')`276    return { data: data.sort((x, y) => y.score - x.score), semantic: { backend: backend.name, model: backend.model, indexed: idx.rows.length } }277  })278279  app.get("/api/next/ai/index/status", async (req) => {280    const a = await nextUser(req, "ai", 240)281    const [settings, st] = await Promise.all([loadSettings(a.userId), embeddingStatus()])282    const boxes = (await userMailboxes(a.userId)).filter((m) => m.owner)283    const indexed = await sql`select mailbox_id, count(*)::int as n, max(created_at) as last from mail_embeddings where user_id = ${a.userId} and (${st.model}::text is null or model = ${st.model}) group by 1`284    const queued = await sql`select mailbox_id, count(*)::int as n from semantic_queue where user_id = ${a.userId} group by 1`285    const mailboxes = await Promise.all(boxes.map(async (mb) => {286      const fl = await folders(mb).catch(() => [])287      const total = fl.filter((f) => !["trash", "junk", "drafts"].includes(f.role ?? "")).reduce((n, f) => n + (f.totalEmails ?? 0), 0)288      return { mailbox_id: mb.id, indexed: indexed.find((x) => x.mailbox_id === mb.id)?.n ?? 0, queued: queued.find((x) => x.mailbox_id === mb.id)?.n ?? 0, total }289    }))290    return {291      enabled: settings.provider !== "off" && settings.features.semantic, ...st, mailboxes,292      indexed: mailboxes.reduce((n, m) => n + m.indexed, 0), queued: mailboxes.reduce((n, m) => n + m.queued, 0), total: mailboxes.reduce((n, m) => n + m.total, 0),293      last_indexed_at: indexed.map((x) => x.last as Date).sort((x, y) => +y - +x)[0] ?? null,294    }295  })296297  // Reconstruction : met en file les messages existants qui n'ont pas encore de vecteur (les plus récents d'abord). Progression : /index/status.298  app.post("/api/next/ai/index/rebuild", async (req) => {299    const a = await nextUser(req, "ai", 20)300    const b = parse(z.object({ mailboxes: z.array(zUuid).max(50).optional(), limit: z.number().int().min(1).max(20_000).default(2000), reset: z.boolean().default(false) }).strict(), req.body ?? {})301    await aiGate(a.userId, "semantic")302    const backend = await requireBackend()303    const boxes = (await userMailboxes(a.userId)).filter((m) => m.owner && (!b.mailboxes || b.mailboxes.includes(m.id)))304    if (b.mailboxes && boxes.length !== new Set(b.mailboxes).size) throw bad("not_found", 404)305    if (b.reset) { await sql`delete from mail_embeddings where user_id = ${a.userId} and mailbox_id = any(${boxes.map((m) => m.id)}::uuid[])`; cache.delete(a.userId) }306    let queued = 0307    for (const mb of boxes) {308      const fl = await folders(mb, true)309      const skip = fl.filter((f) => ["trash", "junk", "drafts"].includes(f.role ?? "")).map((f) => ({ inMailbox: f.id }))310      const have = new Set((await sql`select email_id from mail_embeddings where mailbox_id = ${mb.id} and model = ${backend.model}`).map((r) => r.email_id as string))311      for (let position = 0; position < b.limit; position += 500) {312        const [q] = await jmapOk(mb, [["Email/query", { ...(skip.length ? { filter: { operator: "NOT", conditions: skip } } : {}), sort: [{ property: "receivedAt", isAscending: false }], position, limit: Math.min(500, b.limit - position) }]])313        const ids = (q.ids as string[]).filter((id) => !have.has(id))314        if (ids.length) queued += (await sql`insert into semantic_queue ${sql(ids.map((id) => ({ user_id: mb.user_id, mailbox_id: mb.id, email_id: id })))} on conflict (mailbox_id, email_id) do nothing returning 1`).length315        if ((q.ids as string[]).length < 500) break316      }317    }318    return { queued, backend: backend.name, model: backend.model }319  })320}321322export function semanticWorkers(): NextWorker[] {323  const intervalMs = Math.max(1000, config.workerTickMs)324  return [{ name: "semantic indexer", intervalMs, run: async () => { await indexBatch(); beat("semantic indexer", intervalMs) } }]325}326
Files main
Menu

Theme