@dotrino/vaultd 0.6.0

package/src/daemon.js

@@ -0,0 +1,217 @@
+/**
+ * daemon.js — modo SERVICIO del vault. Arranca TODOS los perfiles del usuario
+ * (`manager.js`) y expone control LOCAL por archivos + señales (sin socket/puerto:
+ * nada escucha en red).
+ *
+ *   state.json          perfiles + fingerprint/iss de cada uno (lo lee el CLI/instalador)
+ *   SIGUSR1 → pair.json  inicia un emparejamiento y vuelca el QR
+ *   pending-enroll.json  cuando un dispositivo pide enrolarse: { deviceId } a
+ *                        aprobar (emparejamiento ENDURECIDO, ver docs/)
+ *   SIGUSR2 → consume approve/reject/revoke/secret/profile-request y vuelca
+ *             devices.json / secrets-list.json / profiles-list.json
+ *
+ * MULTI-PERFIL: cada petición de la CLI trae a qué perfil apunta (`profile`); si
+ * no lo trae, va al perfil activo. La maestra del perfil solo firma el cert de un
+ * dispositivo DESPUÉS de `dotrino-vault approve`.
+ */
+import fs from 'node:fs'
+import path from 'node:path'
+import { startVaultManager } from './manager.js'
+import { dataDir, writeJson, readJson } from './paths.js'
+
+const readJsonSafe = (f) => readJson(f, null)
+const rm = (f) => { try { fs.rmSync(f, { force: true }) } catch (_) {} }
+
+export async function runDaemon () {
+  const dir = dataDir()
+  const proxyUrl = process.env.PROXY_URL || 'wss://proxy.dotrino.com'
+
+  const pendingEnrollFile = path.join(dir, 'pending-enroll.json')
+  // Cuando un dispositivo pide enrolarse, exponemos su deviceId (y a QUÉ perfil
+  // quiere entrar) para que el dueño lo compare con el del dispositivo y apruebe.
+  const onEnrollChallenge = ({ deviceId, scope, profile, profileName }) => {
+    writeJson(pendingEnrollFile, { v: 2, at: Date.now(), deviceId, scope, profile, profileName })
+  }
+
+  const mgr = await startVaultManager({ root: dir, proxyUrl, onEnrollChallenge })
+
+  // --- state.json ---
+  const stateFile = path.join(dir, 'state.json')
+  const daemonVersion = (typeof __VAULT_VERSION__ !== 'undefined') ? __VAULT_VERSION__ : 'dev'
+  // Los campos de la raíz (fingerprint/iss) son los del perfil ACTIVO: los leen el
+  // instalador y la web, que son anteriores al multi-perfil. La lista completa va
+  // en `profiles`.
+  const writeState = () => {
+    const cur = mgr.summary().find((p) => p.current) || {}
+    writeJson(stateFile, {
+      v: 2, version: daemonVersion, fingerprint: cur.fingerprint || null, iss: cur.iss || null,
+      proxy: proxyUrl, pid: process.pid, startedAt: new Date().toISOString(),
+      current: mgr.currentId(), profiles: mgr.summary()
+    })
+  }
+  writeState()
+  const profilesFile = path.join(dir, 'profiles-list.json')
+  const dumpProfiles = (extra = {}) => { writeState(); writeJson(profilesFile, { v: 1, at: Date.now(), current: mgr.currentId(), profiles: mgr.summary(), ...extra }) }
+
+  console.log(`dotrino-vault · datos en ${dir} · proxy ${proxyUrl}`)
+  for (const p of mgr.summary()) {
+    console.log(`perfil ${p.current ? '*' : ' '} ${p.name || '(sin nombre)'} · ${p.id} · ${p.fingerprint}${p.protected ? (p.locked ? ' · 🔒 bloqueado' : ' · 🔓 desbloqueado') : ''}`)
+  }
+
+  /** Perfil destino de una petición de la CLI (o el activo si no lo dice). */
+  const resolveTarget = (req) => {
+    try {
+      const id = req?.profile ? mgr.resolve(req.profile) : mgr.currentId()
+      return { id, vault: mgr.get(id) }
+    } catch (e) { console.error('[vault] perfil inválido en la petición:', e.message); return null }
+  }
+  const targetOf = (req) => resolveTarget(req)?.vault || null
+
+  // --- SIGUSR1: iniciar emparejamiento ---
+  const pairFile = path.join(dir, 'pair.json')
+  const pairReqFile = path.join(dir, 'pair-request.json')
+  process.on('SIGUSR1', () => {
+    try {
+      rm(pendingEnrollFile)
+      // Pairing manual por CLI = gesto explícito del dueño → cert de identidad completo.
+      // ttlMs: 30 días (MAX_DELEGATION_MS). Sin esto caía al default de 24 h, pensado
+      // para delegaciones efímeras: los dispositivos emparejados morían al día
+      // siguiente en silencio ("no autorizado" en todas las apps). La renovación
+      // automática la maneja `handleRenew`.
+      const DEVICE_TTL_MS = 30 * 24 * 60 * 60 * 1000
+      // `pair --service <ns>` (vía pair-request.json): cert SOLO con
+      // vault:secrets:<ns> — para enrolar un SERVICIO (proxy, geo…) que lee sus
+      // secretos, sin poder firmar como el usuario ni leer sus datos.
+      const pairReq = readJsonSafe(pairReqFile); rm(pairReqFile)
+      const vault = targetOf(pairReq)
+      if (!vault) return
+      const profileId = pairReq?.profile ? mgr.resolve(pairReq.profile) : mgr.currentId()
+      const isService = typeof pairReq?.service === 'string' && pairReq.service
+      const scope = isService ? ['vault:secrets:' + pairReq.service] : ['vault:sign', 'vault:read', 'vault:store']
+      const label = pairReq?.label || (isService ? 'servicio:' + pairReq.service : 'cli')
+      const { qr, expiresInMs } = vault.startPairing({ scope, label, ttlMs: DEVICE_TTL_MS })
+      writeJson(pairFile, { v: 2, qr, expiresAt: Date.now() + expiresInMs, profile: profileId })
+      // El token es un secreto efímero: no debe quedar en disco más allá de su
+      // vida. Se borra al VENCER (aquí) y al APROBARSE (abajo, consumido).
+      const tok = qr.token
+      setTimeout(() => {
+        const cur = readJsonSafe(pairFile)
+        if (cur?.qr?.token === tok) rm(pairFile)
+      }, expiresInMs + 1000).unref?.()
+      console.log('[vault] emparejamiento iniciado (válido %d min)', expiresInMs / 60000)
+    } catch (e) {
+      console.error('[vault] no se pudo iniciar emparejamiento:', e.message)
+    }
+  })
+
+  // --- SIGUSR2: approve / reject / revoke / secretos / perfiles + volcados ---
+  const devFile = path.join(dir, 'devices.json')
+  const approveReqFile = path.join(dir, 'approve-request.json')
+  const rejectReqFile = path.join(dir, 'reject-request.json')
+  const revokeReqFile = path.join(dir, 'revoke-request.json')
+  const secretReqFile = path.join(dir, 'secret-request.json')
+  const secretsListFile = path.join(dir, 'secrets-list.json')
+  const profileReqFile = path.join(dir, 'profile-request.json')
+  const dumpReqFile = path.join(dir, 'dump-request.json')
+
+  /**
+   * Órdenes de perfil (crear/renombrar/borrar/activar) y del candado
+   * (unlock/lock/password). La contraseña llega en un archivo 0600 dentro del dir
+   * 0700 del vault y se BORRA al consumirla — mismo camino que ya usan los
+   * secretos, y así nunca pasa por `ps` ni por el historial de la shell.
+   */
+  async function handleProfileRequest (req) {
+    const ref = () => mgr.resolve(req.profile || mgr.currentId())
+    switch (req.op) {
+      case 'list': return {} // el volcado de perfiles ya se hace abajo
+      case 'add': { const p = await mgr.add(req.name); return { done: `perfil creado: ${p.name || p.id}` } }
+      case 'rm': { const r = await mgr.remove(req.profile); return { done: `perfil borrado: ${r.name || r.id}` } }
+      case 'rename': { const p = mgr.profiles.rename(ref(), req.name); return { done: `perfil renombrado: ${p.name}` } }
+      case 'use': { const p = mgr.profiles.setCurrent(ref()); return { done: `perfil activo: ${p.name || p.id}` } }
+      case 'unlock': { await mgr.profiles.unlock(ref(), req.password); return { done: 'perfil desbloqueado' } }
+      case 'lock': { mgr.profiles.lock(ref()); return { done: 'perfil bloqueado' } }
+      case 'password-set': { await mgr.profiles.setPassword(ref(), req.password); return { done: 'contraseña guardada' } }
+      case 'password-rm': { mgr.profiles.removePassword(ref()); return { done: 'contraseña quitada' } }
+      default: throw new Error('operación de perfil desconocida: ' + req.op)
+    }
+  }
+
+  process.on('SIGUSR2', async () => {
+    try {
+      const appr = readJsonSafe(approveReqFile)
+      if (appr?.code) {
+        try {
+          const vault = targetOf(appr)
+          const r = await vault.approveDevice(appr.code); rm(pendingEnrollFile); rm(pairFile); console.log('[vault] aprobado %s', r.deviceId)
+        } catch (e) { console.error('[vault] aprobación falló:', e.message) }
+        rm(approveReqFile)
+      }
+      const rej = readJsonSafe(rejectReqFile)
+      if (rej?.deviceId) {
+        try { targetOf(rej)?.rejectDevice(rej.deviceId); rm(pendingEnrollFile) } catch (_) {}
+        rm(rejectReqFile)
+      }
+      // Cambio de permisos de un miembro del acta (`dotrino-vault caps`).
+      const capsReq = readJsonSafe(path.join(dir, 'caps-request.json'))
+      if (capsReq?.pub && Array.isArray(capsReq.caps)) {
+        rm(path.join(dir, 'caps-request.json'))
+        try {
+          await targetOf(capsReq)?.setCaps(capsReq.pub, capsReq.caps)
+          console.log('[vault] permisos actualizados: %s', capsReq.caps.join(', ') || '(ninguno)')
+        } catch (e) { console.error('[vault] no se pudieron cambiar los permisos:', e.message) }
+      }
+      const req = readJsonSafe(revokeReqFile)
+      if (req?.nonce) {
+        try { await targetOf(req)?.revokeDevice(req.nonce); console.log('[vault] revocado nonce=%s', req.nonce) }
+        catch (e) { console.error('[vault] revocación falló:', e.message) }
+        rm(revokeReqFile)
+      }
+      // Secretos de servicios: `secret set/rm` del CLI. El archivo con el valor
+      // vive un instante en el mismo dir 0700 del vault y se borra al consumir.
+      const sec = readJsonSafe(secretReqFile)
+      if (sec?.op) {
+        rm(secretReqFile)
+        try {
+          const vault = targetOf(sec)
+          if (sec.op === 'set') { vault.setSecret(sec.ns, sec.key, sec.value); console.log('[vault] secreto guardado: %s/%s', sec.ns, sec.key) }
+          else if (sec.op === 'rm') { vault.deleteSecret(sec.ns, sec.key); console.log('[vault] secreto borrado: %s/%s', sec.ns, sec.key) }
+        } catch (e) { console.error('[vault] secreto falló:', e.message) }
+      }
+      // Perfiles / candado.
+      const preq = readJsonSafe(profileReqFile)
+      if (preq?.op) {
+        rm(profileReqFile) // lleva la contraseña: fuera del disco cuanto antes
+        let extra = {}
+        try { extra = await handleProfileRequest(preq) }
+        catch (e) { extra = { error: e.message }; console.error('[vault] perfil: %s', e.message) }
+        dumpProfiles(extra)
+      } else {
+        dumpProfiles()
+      }
+      // Volcados que lee la CLI (`devices`, `secret list`). A QUÉ perfil miran lo
+      // dice dump-request.json; sin él, al activo.
+      const dumpReq = readJsonSafe(dumpReqFile); rm(dumpReqFile)
+      const t = resolveTarget(dumpReq || appr || rej || req || sec || {}) || { id: mgr.currentId(), vault: mgr.current() }
+      // Nombres de secretos, nunca valores.
+      writeJson(secretsListFile, { v: 1, at: Date.now(), profile: t.id, ns: t.vault.listSecrets() })
+      writeJson(devFile, { v: 1, at: Date.now(), profile: t.id, ...(await t.vault.listDevices()) })
+      // Acta del perfil: quién es del perfil y qué puede hacer cada uno (`members`/`caps`).
+      try { writeJson(path.join(dir, 'acta.json'), { v: 1, at: Date.now(), profile: t.id, ...(await t.vault.profileMembers()) }) } catch (_) {}
+    } catch (e) {
+      console.error('[vault] error en señal de control:', e.message)
+    }
+  })
+
+  // --- apagado limpio ---
+  const shutdown = (sig) => {
+    console.log(`\n[vault] ${sig} → deteniendo…`)
+    rm(pairFile); rm(pendingEnrollFile)
+    try { mgr.close() } catch (_) {}
+    process.exit(0)
+  }
+  process.on('SIGTERM', () => shutdown('SIGTERM'))
+  process.on('SIGINT', () => shutdown('SIGINT'))
+
+  console.log('[vault] servicio listo.')
+  return mgr
+}

package/src/manager.js

@@ -0,0 +1,88 @@
+/**
+ * manager.js — corre TODOS los perfiles del vault a la vez.
+ *
+ * Cada perfil es un `startVault` independiente: su propia maestra, su propio
+ * directorio y su propia conexión al proxy (identificada con SU pubkey). Los N
+ * conviven en el mismo daemon: los dispositivos se direccionan por pubkey, así
+ * que el perfil «activo» NO limita el servicio —es solo el destino por defecto de
+ * la CLI cuando no pasas `--profile`—. Un dispositivo enrolado en el perfil de
+ * trabajo sigue funcionando mientras usas el personal, sin cambiar nada.
+ */
+import { startVault } from './vault.js'
+import { openProfiles } from './profiles.js'
+import { installNodeGlobals } from './node-globals.js'
+import { dataDir, ensureDir } from './paths.js'
+
+export async function startVaultManager ({ root = dataDir(), proxyUrl, log = console.log, onEnrollChallenge } = {}) {
+  ensureDir(root)
+  // El keypair de transporte del proxy-client es del PROCESO, no de la identidad:
+  // se instala apuntando a la RAÍZ (no al dir de un perfil) para que los perfiles
+  // no se peleen por el archivo ni se lo lleven al borrarse.
+  installNodeGlobals(root)
+
+  const profiles = openProfiles(root)
+  const migrated = profiles.migrate()
+  if (migrated?.migrated) log('[vault] identidad mono-perfil migrada al perfil %s', migrated.id)
+
+  const running = new Map() // id -> instancia de startVault
+
+  async function open (id) {
+    const p = profiles.get(id)
+    const tag = p?.name ? `${p.name}` : id
+    const v = await startVault({
+      dir: profiles.dirOf(id),
+      proxyUrl,
+      log: (...a) => log(`[${tag}]`, ...a),
+      isLocked: () => profiles.isLocked(id),
+      onEnrollChallenge: (info) => onEnrollChallenge?.({ ...info, profile: id, profileName: p?.name || '' })
+    })
+    running.set(id, v)
+    return v
+  }
+
+  for (const p of profiles.list()) {
+    try { await open(p.id) } catch (e) { log('[vault] no se pudo abrir el perfil %s: %s', p.id, e.message) }
+  }
+
+  const get = (id) => {
+    const v = running.get(id)
+    if (!v) throw new Error('el perfil no está abierto: ' + id)
+    return v
+  }
+
+  /** Resumen para state.json / `profile ls`: identidad + candado de cada perfil. */
+  const summary = () => profiles.list().map((p) => {
+    const v = running.get(p.id)
+    return { ...p, fingerprint: v?.fingerprint || null, iss: v?.master || null }
+  })
+
+  return {
+    profiles,
+    running,
+    get,
+    list: () => profiles.list(),
+    summary,
+    current: () => get(profiles.current()),
+    currentId: () => profiles.current(),
+    resolve: (ref) => profiles.resolve(ref),
+
+    async add (name) {
+      const p = profiles.add(name)
+      await open(p.id)
+      log('[vault] perfil creado: %s (%s)', p.name || '(sin nombre)', p.id)
+      return profiles.get(p.id)
+    },
+
+    /** Borra el perfil: cierra su conexión y elimina su maestra y sus datos. */
+    async remove (ref) {
+      const id = profiles.resolve(ref)
+      const res = profiles.remove(id) // valida: no es el único, no está bloqueado
+      try { running.get(id)?.close() } catch (_) {}
+      running.delete(id)
+      log('[vault] perfil borrado: %s (%s)', res.name || '(sin nombre)', id)
+      return res
+    },
+
+    close () { for (const v of running.values()) { try { v.close() } catch (_) {} } running.clear() }
+  }
+}

package/src/node-globals.js

@@ -0,0 +1,37 @@
+/**
+ * Instala los globals del navegador que los paquetes del ecosistema esperan
+ * cuando corren headless en Node: `WebSocket` (paquete `ws`) y un `localStorage`
+ * respaldado en archivo (lo usa `@dotrino/proxy-client` para su keypair de
+ * transporte estable). Mismo patrón que `dotrino-bots/src/core/node-globals.js`
+ * — NO se reimplementa nada, solo se inyecta el entorno.
+ */
+import fs from 'node:fs'
+import path from 'node:path'
+import WebSocket from 'ws'
+
+/** localStorage síncrono respaldado por un archivo JSON (solo lo que usan los paquetes). */
+export function fileLocalStorage (filePath) {
+  let data = {}
+  try { if (fs.existsSync(filePath)) data = JSON.parse(fs.readFileSync(filePath, 'utf8')) || {} } catch (_) {}
+  const flush = () => {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true })
+    fs.writeFileSync(filePath, JSON.stringify(data), { mode: 0o600 })
+  }
+  return {
+    getItem: (k) => (k in data ? data[k] : null),
+    setItem: (k, v) => { data[k] = String(v); flush() },
+    removeItem: (k) => { delete data[k]; flush() },
+    clear: () => { data = {}; flush() },
+    key: (i) => Object.keys(data)[i] ?? null,
+    get length () { return Object.keys(data).length }
+  }
+}
+
+let _installed = false
+export function installNodeGlobals (dir) {
+  if (_installed) return
+  if (typeof globalThis.WebSocket === 'undefined') globalThis.WebSocket = WebSocket
+  // Node ≥22 expone un `localStorage` no funcional sin flag → forzamos el shim.
+  globalThis.localStorage = fileLocalStorage(path.join(dir, 'transport.json'))
+  _installed = true
+}

package/src/paths.js

@@ -0,0 +1,47 @@
+/**
+ * Resolución del directorio de datos y escritura de archivos con permisos
+ * restrictivos (0600). En v1 la clave maestra va en claro dentro de este dir
+ * (la guarda `@dotrino/identity` en `identity.json`); 0600 evita que sea
+ * world-readable. v2 añadirá cifrado en reposo con contraseña maestra.
+ */
+import os from 'node:os'
+import path from 'node:path'
+import fs from 'node:fs'
+
+/**
+ * Dir de datos del vault. Override con DOTRINO_VAULT_DIR.
+ *
+ * En Linux/macOS: `~/.local/share/dotrino/vault`. DEBE coincidir exactamente con la unit
+ * systemd (`%h/.local/share/...` + ReadWritePaths) y con install.sh (DATA_DIR),
+ * porque el CLI de control corre en la shell del usuario SIN el `Environment=` del
+ * servicio: si difieren, `dotrino-vault status/pair/devices` no encuentra al daemon.
+ *
+ * En Windows: `%LOCALAPPDATA%\Dotrino\vault`, que es donde Windows espera los datos de
+ * una app. El daemon y el CLI lo resuelven igual, así que el contrato por archivos entre
+ * los dos (ver `vaultControl.js`) sigue funcionando sin tocar nada.
+ */
+export function dataDir () {
+  if (process.env.DOTRINO_VAULT_DIR) return process.env.DOTRINO_VAULT_DIR
+  if (process.platform === 'win32') {
+    const base = process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local')
+    return path.join(base, 'Dotrino', 'vault')
+  }
+  return path.join(os.homedir(), '.local', 'share', 'dotrino', 'vault')
+}
+
+export function ensureDir (dir) {
+  fs.mkdirSync(dir, { recursive: true, mode: 0o700 })
+}
+
+export function readJson (file, fallback) {
+  try { return JSON.parse(fs.readFileSync(file, 'utf8')) } catch (_) { return fallback }
+}
+
+/** Escritura atómica (tmp + rename) con modo 0600. */
+export function writeJson (file, obj) {
+  ensureDir(path.dirname(file))
+  const tmp = file + '.tmp'
+  fs.writeFileSync(tmp, JSON.stringify(obj, null, 2), { mode: 0o600 })
+  fs.renameSync(tmp, file)
+  try { fs.chmodSync(file, 0o600) } catch (_) {}
+}

package/src/profiles.js

@@ -0,0 +1,214 @@
+/**
+ * profiles.js — registro MULTI-PERFIL del vault.
+ *
+ * Un mismo PC puede custodiar varias identidades del usuario (personal, trabajo…).
+ * Cada perfil es una maestra distinta y vive en su PROPIO subdirectorio, así que
+ * todo lo que ya era «por dir» (identity.json, peers, vault.json, threads.json,
+ * secrets.json, activity.log) queda naturalmente aislado entre perfiles: un
+ * dispositivo enrolado en un perfil no ve ni firma nada del otro.
+ *
+ *   <root>/profiles.json      este registro: [{ id, name, createdAt, pwd? }] + activo
+ *   <root>/transport.json     keypair del proxy-client (a nivel PROCESO, no por perfil)
+ *   <root>/p/<id>/…           los datos de cada perfil (incluida su maestra)
+ *
+ * CONTRASEÑA (opcional, por perfil): es un VERIFICADOR PBKDF2 —mismo modelo que el
+ * candado del navegador (`@dotrino/identity` vault/core.js)— NO cifra nada en reposo.
+ * Y solo bloquea EDITAR el perfil: el daemon sigue firmando y sirviendo a los
+ * dispositivos ya enrolados aunque el perfil esté bloqueado, para que un reinicio
+ * del PC no deje las apps muertas hasta que alguien teclee la contraseña.
+ * Protege contra que otro que se siente en la máquina —o un dispositivo enrolado—
+ * te reescriba el perfil; NO contra quien pueda leer el disco (para eso hace falta
+ * cifrado en reposo, ver `paths.js`).
+ */
+import fs from 'node:fs'
+import path from 'node:path'
+import { dataDir, ensureDir, readJson, writeJson } from './paths.js'
+
+const REGISTRY = 'profiles.json'
+const PWD_ITER = 300000 // mismo coste que el candado del navegador
+const MAX_NAME = 40
+
+/** Archivos de un perfil que en la versión mono-perfil vivían sueltos en la raíz. */
+const LEGACY_FILES = ['identity.json', 'peers.json', 'vault.json', 'threads.json', 'secrets.json', 'activity.log']
+
+const b64 = (buf) => Buffer.from(new Uint8Array(buf)).toString('base64')
+
+/** PBKDF2-SHA256 → verificador base64 (byte-idéntico al del navegador). */
+async function derivePwd (password, saltB64, iter) {
+  const salt = Buffer.from(saltB64, 'base64')
+  const km = await crypto.subtle.importKey('raw', new TextEncoder().encode(String(password)), 'PBKDF2', false, ['deriveBits'])
+  const bits = await crypto.subtle.deriveBits({ name: 'PBKDF2', hash: 'SHA-256', salt, iterations: iter }, km, 256)
+  return b64(bits)
+}
+
+const newId = () => 'p' + crypto.randomUUID().slice(0, 8)
+const cleanName = (name) => String(name || '').slice(0, MAX_NAME)
+
+export function openProfiles (root = dataDir()) {
+  const file = path.join(root, REGISTRY)
+  let data = readJson(file, null)
+  if (!data || !Array.isArray(data.profiles)) data = { v: 1, current: null, profiles: [] }
+  const save = () => writeJson(file, data)
+
+  // Perfiles DESBLOQUEADOS en esta ejecución del daemon (en memoria: un reinicio
+  // vuelve a bloquear, igual que cerrar la pestaña en el navegador).
+  const unlocked = new Set()
+
+  const find = (id) => data.profiles.find((p) => p.id === id) || null
+  const dirOf = (id) => path.join(root, 'p', id)
+
+  const entry = (p) => ({
+    id: p.id,
+    name: p.name || '',
+    createdAt: p.createdAt || null,
+    protected: !!p.pwd,
+    locked: !!p.pwd && !unlocked.has(p.id),
+    current: p.id === data.current
+  })
+
+  function assertExists (id) {
+    const p = find(id)
+    if (!p) throw new Error('el perfil no existe: ' + id)
+    return p
+  }
+
+  const api = {
+    get root () { return root },
+    dirOf,
+    list: () => data.profiles.map(entry),
+    get: (id) => { const p = find(id); return p ? entry(p) : null },
+    current: () => data.current,
+
+    /**
+     * Resuelve una referencia de la CLI: id exacto, o nombre (sin distinguir
+     * mayúsculas). Un nombre ambiguo es un error explícito, no una elección al azar.
+     */
+    resolve (ref) {
+      if (!ref) return data.current
+      if (find(ref)) return ref
+      const needle = String(ref).trim().toLowerCase()
+      const hits = data.profiles.filter((p) => (p.name || '').toLowerCase() === needle)
+      if (hits.length === 1) return hits[0].id
+      if (hits.length > 1) throw new Error(`hay ${hits.length} perfiles llamados "${ref}"; usa su id (dotrino-vault profile ls)`)
+      throw new Error('el perfil no existe: ' + ref)
+    },
+
+    /**
+     * Migración desde la versión mono-perfil: los datos que vivían sueltos en la
+     * raíz pasan a ser el primer perfil (mismo criterio que la migración del
+     * navegador, que adopta la identidad vieja como «Perfil 1»). `transport.json`
+     * se queda en la raíz: es del proceso, no de la identidad.
+     */
+    migrate () {
+      if (data.profiles.length) return null
+      const legacy = fs.existsSync(path.join(root, 'identity.json'))
+      const id = newId()
+      const dir = dirOf(id)
+      ensureDir(dir)
+      if (legacy) {
+        for (const f of LEGACY_FILES) {
+          const from = path.join(root, f)
+          if (fs.existsSync(from)) { try { fs.renameSync(from, path.join(dir, f)) } catch (_) {} }
+        }
+        // peers namespaceados por el multi-perfil interno de @dotrino/identity
+        for (const f of fs.readdirSync(root)) {
+          if (/^peers\..+\.json$/.test(f)) { try { fs.renameSync(path.join(root, f), path.join(dir, f)) } catch (_) {} }
+        }
+      }
+      // «Perfil 1» tanto al migrar como en una instalación nueva: es un nombre que
+      // el dueño puede cambiar, y evita que la CLI salude con «(sin nombre)».
+      data.profiles.push({ id, name: 'Perfil 1', createdAt: Date.now() })
+      data.current = id
+      save()
+      return { id, migrated: legacy }
+    },
+
+    add (name) {
+      const id = newId()
+      ensureDir(dirOf(id))
+      data.profiles.push({ id, name: cleanName(name), createdAt: Date.now() })
+      if (!data.current) data.current = id
+      save()
+      return entry(find(id))
+    },
+
+    rename (id, name) {
+      const p = assertExists(id)
+      api.assertUnlocked(id)
+      p.name = cleanName(name)
+      save()
+      return entry(p)
+    },
+
+    setCurrent (id) { assertExists(id); data.current = id; save(); return entry(find(id)) },
+
+    /** Borra el perfil y TODOS sus datos (incluida su maestra). Irreversible. */
+    remove (id) {
+      const p = assertExists(id)
+      if (data.profiles.length <= 1) throw new Error('no se puede borrar el único perfil')
+      api.assertUnlocked(id)
+      data.profiles = data.profiles.filter((x) => x.id !== id)
+      if (data.current === id) data.current = data.profiles[0].id
+      save()
+      unlocked.delete(id)
+      try { fs.rmSync(dirOf(id), { recursive: true, force: true }) } catch (_) {}
+      return { id, name: p.name || '' }
+    },
+
+    // ----- candado -----
+
+    isProtected: (id) => !!find(id)?.pwd,
+    isLocked: (id) => { const p = find(id); return !!p?.pwd && !unlocked.has(id) },
+    assertUnlocked (id) {
+      if (api.isLocked(id)) throw new Error('perfil bloqueado: desbloquéalo con tu contraseña (dotrino-vault unlock)')
+    },
+
+    async unlock (id, password) {
+      const p = assertExists(id)
+      if (!p.pwd) { unlocked.add(id); return { ok: true, locked: false } }
+      // Freno de fuerza bruta (una contraseña corta se adivina probando): tras 5
+      // fallos, espera exponencial (2^n s, tope 5 min) persistida en el registro.
+      const tries = p.tries || { n: 0, at: 0 }
+      const waitMs = tries.n >= 5 ? Math.min(2 ** (tries.n - 4) * 1000, 5 * 60 * 1000) : 0
+      const left = tries.at + waitMs - Date.now()
+      if (left > 0) throw new Error(`demasiados intentos: espera ${Math.ceil(left / 1000)} s`)
+      const proof = await derivePwd(password, p.pwd.salt, p.pwd.iter)
+      if (proof !== p.pwd.verifier) {
+        p.tries = { n: tries.n + 1, at: Date.now() }
+        save()
+        throw new Error('contraseña incorrecta')
+      }
+      delete p.tries
+      save()
+      unlocked.add(id)
+      return { ok: true, locked: false }
+    },
+
+    lock (id) { assertExists(id); unlocked.delete(id); return { ok: true, locked: api.isLocked(id) } },
+
+    /** Pone o cambia la contraseña. Cambiarla exige haber desbloqueado antes. */
+    async setPassword (id, password) {
+      const p = assertExists(id)
+      api.assertUnlocked(id)
+      if (!password || String(password).length < 4) throw new Error('la contraseña debe tener al menos 4 caracteres')
+      const salt = b64(crypto.getRandomValues(new Uint8Array(16)))
+      p.pwd = { v: 1, salt, iter: PWD_ITER, verifier: await derivePwd(password, salt, PWD_ITER) }
+      delete p.tries
+      save()
+      unlocked.add(id)
+      return entry(p)
+    },
+
+    removePassword (id) {
+      const p = assertExists(id)
+      api.assertUnlocked(id)
+      delete p.pwd
+      delete p.tries
+      save()
+      unlocked.add(id)
+      return entry(p)
+    }
+  }
+
+  return api
+}

package/src/protocol.js

@@ -0,0 +1,6 @@
+/**
+ * Protocolo dispositivo↔vault. La fuente ÚNICA vive en la lib publicable
+ * (`@dotrino/vault`, lib/src/protocol.js) para que daemon, dispositivos y
+ * SERVICIOS usen exactamente las mismas constantes. Este archivo solo re-exporta.
+ */
+export * from '../lib/src/protocol.js'

package/src/qr.js

@@ -0,0 +1,61 @@
+/**
+ * qr.js — render de un QR en la terminal con bloques Unicode.
+ *
+ * Usa el encoder QR `qrcode-generator` (MIT, Kazuhiko Arase) VENDORIZADO en
+ * `vendor/qrcode-generator.cjs`: JS puro, sin red ni telemetría, y se empaqueta
+ * dentro del binario SEA (regla de privacidad del ecosistema: nada de JS de
+ * terceros cargado en runtime, todo va embebido). No reimplementamos el QR a mano.
+ *
+ * Render con medio bloque por carácter: un QR es "alto", así que dibujamos dos
+ * filas de módulos por línea de texto con ▀▄█/espacio.
+ */
+// Import estático del encoder vendorizado (UMD/CJS). Así esbuild lo INLINE-a en
+// el binario SEA y en dev funciona por el interop ESM↔CJS de Node.
+import qrcodeMod from '../vendor/qrcode-generator.cjs'
+
+const qrcode = typeof qrcodeMod === 'function' ? qrcodeMod : qrcodeMod.default
+
+/**
+ * Devuelve una string con el QR listo para imprimir en la terminal, **negro sobre
+ * blanco** y con zona de silencio blanca, INDEPENDIENTE del tema del terminal.
+ *
+ * Por qué: los escáneres esperan módulos oscuros sobre fondo claro. Si se dibuja
+ * con los colores del terminal (claro sobre oscuro en un terminal oscuro), el QR
+ * queda invertido y sin margen blanco → no escanea. Aquí forzamos el color con
+ * ANSI: medio bloque superior `▀` con color de TEXTO = módulo de arriba y color de
+ * FONDO = módulo de abajo (oscuro=negro, claro=blanco). Compacto (2 filas de
+ * módulos por línea) y siempre con el contraste correcto.
+ *
+ * @param {string} text  Contenido a codificar (modo byte / UTF-8).
+ * @param {number} [quiet=4]  Zona de silencio en módulos (mín. recomendado: 4).
+ */
+export function qrToString (text, quiet = 4) {
+  // typeNumber 0 = autoseleccionar la versión mínima; EC level 'L' (más capacidad).
+  const qr = qrcode(0, 'L')
+  qr.addData(text) // 'Byte' por defecto para datos no numéricos/alfanuméricos
+  qr.make()
+
+  const n = qr.getModuleCount()
+  const N = n + quiet * 2
+  // Fuera de la cuadrícula = zona de silencio = claro (blanco).
+  const dark = (r, c) => {
+    const rr = r - quiet; const cc = c - quiet
+    if (rr < 0 || cc < 0 || rr >= n || cc >= n) return false
+    return qr.isDark(rr, cc)
+  }
+
+  const FG = (d) => (d ? 30 : 37) // texto: negro / blanco
+  const BG = (d) => (d ? 40 : 47) // fondo: negro / blanco
+  const RESET = '\x1b[0m'
+
+  let out = ''
+  for (let r = 0; r < N; r += 2) {
+    for (let c = 0; c < N; c++) {
+      const top = dark(r, c)
+      const bot = r + 1 < N ? dark(r + 1, c) : false
+      out += `\x1b[${FG(top)};${BG(bot)}m▀`
+    }
+    out += RESET + '\n'
+  }
+  return out
+}