@dotrino/vaultd 0.6.0

package/src/secretsStore.js

@@ -0,0 +1,61 @@
+/**
+ * Store de SECRETOS de servicios (`secrets.json`, 0600, mismo dir 0700 que la
+ * maestra — mismo dominio de confianza, v1 en claro en reposo igual que
+ * `identity.json`; el cifrado en reposo con contraseña llega con v2 para todo
+ * el dir). Organizado por NAMESPACE de servicio (`proxy`, `geo`, `bots`…):
+ * un cert `vault:secrets:<ns>` solo puede leer SU ns.
+ */
+import path from 'node:path'
+import { readJson, writeJson } from './paths.js'
+import { isValidSecretsNs } from './protocol.js'
+
+const SCHEMA_VERSION = 1
+const MAX_VALUE_LEN = 8 * 1024
+const KEY_RE = /^[A-Z0-9_]{1,64}$/
+
+export function openSecretsStore (dir) {
+  const file = path.join(dir, 'secrets.json')
+  let data = readJson(file, null)
+  if (!data || data.schemaVersion !== SCHEMA_VERSION) {
+    data = { schemaVersion: SCHEMA_VERSION, ns: {} }
+    writeJson(file, data)
+  }
+  const save = () => writeJson(file, data)
+
+  const assertNs = (ns) => {
+    if (!isValidSecretsNs(ns)) throw new Error('namespace inválido (usa [a-z0-9-]{1,32}, p.ej. "proxy")')
+  }
+
+  return {
+    /** Secretos de un ns (objeto plano KEY→valor; {} si no hay). */
+    get (ns) {
+      assertNs(ns)
+      return { ...(data.ns[ns] || {}) }
+    },
+    set (ns, key, value) {
+      assertNs(ns)
+      if (!KEY_RE.test(String(key || ''))) throw new Error('clave inválida (usa MAYUSCULAS_CON_GUION_BAJO, p.ej. TURN_KEY_ID)')
+      if (typeof value !== 'string' || !value) throw new Error('el valor debe ser un string no vacío')
+      if (value.length > MAX_VALUE_LEN) throw new Error(`valor demasiado largo (máx ${MAX_VALUE_LEN})`)
+      if (!data.ns[ns]) data.ns[ns] = {}
+      data.ns[ns][key] = value
+      save()
+    },
+    delete (ns, key) {
+      assertNs(ns)
+      const existed = !!(data.ns[ns] && key in data.ns[ns])
+      if (existed) {
+        delete data.ns[ns][key]
+        if (Object.keys(data.ns[ns]).length === 0) delete data.ns[ns]
+        save()
+      }
+      return existed
+    },
+    /** Solo nombres (ns → [claves]), sin valores: para `secret list`. */
+    list () {
+      const out = {}
+      for (const ns of Object.keys(data.ns)) out[ns] = Object.keys(data.ns[ns])
+      return out
+    }
+  }
+}

package/src/store.js

@@ -0,0 +1,64 @@
+/**
+ * Store del árbol de contenidos del vault (`vault.json`). Versionado con
+ * `schemaVersion` para que v2 pueda introducir cifrado en reposo sin migración
+ * dolorosa. NO guarda identidad/dispositivos/certs: de eso se encarga
+ * `@dotrino/identity` dentro del mismo dir (keypair, contactos, delegaciones,
+ * revocaciones). Aquí vive solo lo del usuario: el árbol y los settings.
+ */
+import path from 'node:path'
+import { readJson, writeJson } from './paths.js'
+
+const SCHEMA_VERSION = 1
+
+function newTree () {
+  return { id: 'root', name: '', type: 'folder', children: [] }
+}
+
+function findNode (node, id) {
+  if (!node) return null
+  if (node.id === id) return node
+  if (Array.isArray(node.children)) {
+    for (const c of node.children) {
+      const r = findNode(c, id)
+      if (r) return r
+    }
+  }
+  return null
+}
+
+export function openStore (dir) {
+  const file = path.join(dir, 'vault.json')
+  let data = readJson(file, null)
+  if (!data || data.schemaVersion !== SCHEMA_VERSION) {
+    data = { schemaVersion: SCHEMA_VERSION, tree: newTree(), settings: {} }
+    writeJson(file, data)
+  }
+  const save = () => writeJson(file, data)
+
+  return {
+    get raw () { return data },
+    getTree () { return data.tree },
+    getNode (id) { return findNode(data.tree, id || 'root') },
+    addNode (parentId, node) {
+      const parent = findNode(data.tree, parentId || 'root')
+      if (!parent) throw new Error('nodo padre no encontrado: ' + parentId)
+      if (!Array.isArray(parent.children)) parent.children = []
+      parent.children.push(node)
+      save()
+      return node
+    },
+    removeNode (id) {
+      const remove = (node) => {
+        if (!Array.isArray(node.children)) return false
+        const i = node.children.findIndex((c) => c.id === id)
+        if (i >= 0) { node.children.splice(i, 1); return true }
+        return node.children.some(remove)
+      }
+      const ok = remove(data.tree)
+      if (ok) save()
+      return ok
+    },
+    getSetting (k) { return data.settings[k] },
+    setSetting (k, v) { data.settings[k] = v; save() }
+  }
+}

package/src/threadStore.js

@@ -0,0 +1,111 @@
+/**
+ * Sub-store de HILOS + APERTURAS del vault (Fase 3: store centralizado).
+ *
+ * Espeja el modelo de datos de `@dotrino/store` (store.dotrino.com):
+ *   threads: { [threadKey]: Entry[] }   (Entry tiene `id` + `ts`, opaco para el store)
+ *   opens:   { [appId]: { count, ts } } (contador de "recientes" del hub)
+ * para que un dispositivo emparejado pueda guardar su contenido EN el vault del
+ * usuario (su propio servidor) en vez de —o además de— el IndexedDB del navegador.
+ *
+ * File-backed (`threads.json`), síncrono y simple (sin cuota/IndexedDB). Es el
+ * backend autoritativo; el navegador usa su IndexedDB como caché y sincroniza.
+ */
+import path from 'node:path'
+import { readJson, writeJson } from './paths.js'
+
+const MAX_PER_THREAD = 1000
+
+export function openThreadStore (dir) {
+  const file = path.join(dir, 'threads.json')
+  let data = readJson(file, null)
+  if (!data || typeof data !== 'object') data = { v: 1, threads: {}, opens: {} }
+  if (!data.threads) data.threads = {}
+  if (!data.opens) data.opens = {}
+  const save = () => writeJson(file, data)
+  const trim = (arr) => { if (arr.length > MAX_PER_THREAD) arr.splice(0, arr.length - MAX_PER_THREAD) }
+
+  const methods = {
+    appendMessage ({ threadKey, entry }) {
+      if (!threadKey || typeof threadKey !== 'string') throw new Error('threadKey required')
+      if (!entry || typeof entry !== 'object') throw new Error('entry required')
+      if (!entry.id) entry.id = crypto.randomUUID()
+      if (!entry.ts) entry.ts = Date.now()
+      const arr = data.threads[threadKey] || (data.threads[threadKey] = [])
+      const i = arr.findIndex((e) => e.id === entry.id)
+      if (i >= 0) arr[i] = { ...arr[i], ...entry }; else arr.push(entry)
+      trim(arr); save(); return entry
+    },
+    listThread ({ threadKey, limit, before }) {
+      if (!threadKey) return []
+      let arr = data.threads[threadKey] || []
+      if (typeof before === 'number') arr = arr.filter((e) => (e.ts || 0) < before)
+      if (typeof limit === 'number' && limit > 0) arr = arr.slice(-limit)
+      return arr
+    },
+    listThreadKeys () { return Object.keys(data.threads) },
+    getThreadSummaries () {
+      const out = {}
+      for (const [k, arr] of Object.entries(data.threads)) out[k] = { lastEntry: arr.length ? arr[arr.length - 1] : null, count: arr.length }
+      return out
+    },
+    removeThread ({ threadKey }) {
+      const removed = data.threads[threadKey]?.length || 0
+      delete data.threads[threadKey]; save(); return { removed }
+    },
+    removeMessage ({ threadKey, id }) {
+      const arr = data.threads[threadKey] || []; const before = arr.length
+      data.threads[threadKey] = arr.filter((e) => e.id !== id)
+      if (data.threads[threadKey].length === 0) delete data.threads[threadKey]
+      save(); return { removed: before - (data.threads[threadKey]?.length || 0) }
+    },
+    recordOpen ({ appId }) {
+      if (!appId || typeof appId !== 'string') throw new Error('appId required')
+      const prev = data.opens[appId]
+      data.opens[appId] = { count: (prev?.count || 0) + 1, ts: Date.now() }
+      save(); return data.opens[appId]
+    },
+    getOpens () { return { ...data.opens } },
+    clearOpens () { data.opens = {}; save(); return { ok: true } },
+    exportThreads () { return { threads: data.threads } },
+    importThreads ({ threads, mode = 'merge' }) {
+      if (!threads || typeof threads !== 'object') throw new Error('threads required')
+      if (mode === 'replace') { data.threads = threads; save(); return { mode, count: Object.keys(threads).length } }
+      for (const [k, arr] of Object.entries(threads)) {
+        const cur = data.threads[k] || (data.threads[k] = [])
+        const byId = new Map(cur.map((e) => [e.id, e]))
+        for (const e of arr) { if (!e?.id) continue; const pr = byId.get(e.id); if (!pr || (e.ts || 0) > (pr.ts || 0)) byId.set(e.id, e) }
+        data.threads[k] = Array.from(byId.values()).sort((a, b) => (a.ts || 0) - (b.ts || 0)); trim(data.threads[k])
+      }
+      save(); return { mode, count: Object.keys(data.threads).length }
+    },
+    // ----- PERFIL del usuario (me): el vault es la copia AUTORITATIVA -----
+    // Cada dispositivo emparejado lo empuja al editarlo y lo jala al arrancar →
+    // el mismo perfil (apodo/avatar/datos) en todos los dispositivos.
+    profileSet ({ me }) {
+      if (!me || typeof me !== 'object') throw new Error('me required')
+      // nunca guardar llaves de dispositivo (son por-dispositivo)
+      const { publickey, encryptionPubkey, ...content } = me
+      data.profile = { ...content, updatedAt: content.updatedAt || Date.now() }
+      save(); return { ok: true, updatedAt: data.profile.updatedAt }
+    },
+    profileGet () { return { me: data.profile || null } },
+    getStats () {
+      const threads = {}
+      for (const [k, arr] of Object.entries(data.threads)) threads[k] = { count: arr.length }
+      return { threadCount: Object.keys(data.threads).length, threads, opensCount: Object.keys(data.opens).length }
+    }
+  }
+  return { methods, raw: () => data }
+}
+
+/** Métodos del store que son de SOLO LECTURA (para decidir el scope necesario). */
+export const STORE_READ_METHODS = new Set([
+  'listThread', 'listThreadKeys', 'getThreadSummaries', 'getOpens', 'exportThreads', 'getStats', 'profileGet'
+])
+
+/**
+ * Métodos que EDITAN el perfil del usuario (quién es: apodo, avatar, campos).
+ * Son los únicos que el candado por contraseña bloquea (`vault.js`): el resto del
+ * store —contenido de las apps— sigue disponible con el perfil bloqueado.
+ */
+export const PROFILE_EDIT_METHODS = new Set(['profileSet'])

package/src/transport.js

@@ -0,0 +1,64 @@
+/**
+ * Transporte headless del vault: el cliente OFICIAL `@dotrino/proxy-client`
+ * corriendo en Node (mismo patrón que `dotrino-bots/src/core/transport.js`).
+ * Hace el `identify` firmado por la maestra del vault — liga el token efímero de
+ * la conexión a la pubkey estable, habilitando el direccionamiento por pubkey
+ * (`sendByPubkey`) y la cola offline de 24 h del proxy.
+ *
+ * IMPORTANTE: `me.publickey` puede ser null en el primer arranque (solo se puebla
+ * al fijar un nickname), así que la pubkey maestra se obtiene de forma robusta
+ * con un `signData` de cortesía si hace falta. El daemon (vault.js) además puebla
+ * `me` antes de conectar.
+ */
+import { installNodeGlobals } from './node-globals.js'
+
+const DEFAULT_PROXY = 'wss://proxy.dotrino.com'
+
+export async function masterPubkeyOf (identity) {
+  return identity.me?.publickey || (await identity.signData({ op: 'whoami', ts: Date.now() })).publickey
+}
+
+/**
+ * Conecta el transporte y lo identifica con la maestra del vault.
+ * @param {Object} opts
+ * @param {import('@dotrino/identity/node').Identity} opts.identity
+ * @param {string} opts.dir   Directorio de persistencia.
+ * @param {string} [opts.url] URL del proxy (default wss://proxy.dotrino.com).
+ * @returns {Promise<{ client, token:string, identify():Promise<void> }>}
+ */
+export async function createTransport ({ identity, dir, url = DEFAULT_PROXY }) {
+  installNodeGlobals(dir)
+  // Import dinámico DESPUÉS de instalar los globals que el paquete usa.
+  // `WebSocketProxyClient` (la clase) y NO el helper `getWebSocketProxyClient`:
+  // ese es un SINGLETON de proceso, y con multi-perfil el vault necesita una
+  // conexión POR PERFIL (cada maestra se identifica con su propia pubkey ante el
+  // proxy). Con el singleton, el segundo perfil reusaba el cliente del primero y
+  // su `identify` pisaba al anterior. Sigue siendo el cliente oficial del paquete.
+  const { WebSocketProxyClient } = await import('@dotrino/proxy-client')
+
+  // WebRTC off: el vault usa el proxy como transporte (RTCPeerConnection no existe
+  // en Node). Reconexión prácticamente ilimitada: un daemon de larga duración no
+  // debe rendirse tras unos intentos.
+  const client = new WebSocketProxyClient({
+    url, enableWebRTC: false, autoReconnect: true,
+    maxReconnectAttempts: 100000, reconnectDelay: 4000
+  })
+
+  await client.connect()
+
+  const identify = async () => {
+    const publickey = await masterPubkeyOf(identity)
+    if (!publickey || !client.token) return
+    const data = { op: 'identify', publickey, token: client.token, ts: Date.now() }
+    const { signature } = await identity.signData(data)
+    // Con el acta, el proxy bindea también el `profileId`: escribirle a la PERSONA llega
+    // a cualquiera de sus dispositivos, no solo a esta bóveda.
+    const acta = (await identity.profileActa?.().catch(() => null))?.acta || null
+    await client.identify({ data, signature, acta })
+  }
+  await identify()
+  // Re-identificar al reconectar (el token cambia).
+  client.on('token', () => { identify().catch(() => {}) })
+
+  return { client, token: client.token, identify }
+}