@dotrino/vaultd 0.123.0 → 0.123.1

package/lib/src/loginClient.js

@@ -34,7 +34,7 @@
  * Si algo de eso falla, se PARA con un `code` propio. No hay repliegue: entrar «a medias»
  * en una cuenta es peor que no entrar.
  */
-import { client as opaque } from '@dotrino/opaque'
+import { client as opaquePorDefecto } from '@dotrino/opaque'
 import { pubkeyId, verifyDeviceSig, signWithDevice } from '@dotrino/identity/capabilities'
 import { checkVaultReply } from '@dotrino/identity/acta'
 import { MSG } from './protocol.js'
@@ -82,11 +82,16 @@ const parseJson = (s) => { try { return JSON.parse(s) } catch (_) { return null
  * @param {string} opts.password
  * @param {string} [opts.label]    de dónde se entra («el cyber de la esquina»): es lo que
  *   el dueño va a leer en su consola para decidir si cerrarlo.
+ * @param {object} [opts.opaque]   el OPAQUE a usar. Por defecto el de casa, que va en este
+ *   mismo hilo. Se inyecta porque en una EXTENSIÓN el WASM vive en una página sandbox, al
+ *   otro lado de un `postMessage`, y entonces sus métodos devuelven promesas — igual que en
+ *   `createLoginDesk`, y por el mismo motivo. Aquí se espera siempre: esperar a algo que no
+ *   es una promesa no cuesta nada, y dos firmas serían dos clientes.
  * @returns {Promise<{user:string,address:string,code:string,sid:string,cert:object,
  *   iss:string,acta:object,vaultToken:string,publickey:string,encPublickey:(string|null),
  *   keys:{sign:object,enc:(object|null)}}>}
  */
-export async function loginWithPassword ({ transport, address, password, label = '', timeoutMs = REPLY_TIMEOUT_MS } = {}) {
+export async function loginWithPassword ({ transport, address, password, label = '', timeoutMs = REPLY_TIMEOUT_MS, opaque = opaquePorDefecto } = {}) {
   if (!transport || typeof transport.on !== 'function' || typeof transport.send !== 'function') {
     throw err('no-transport', 'loginWithPassword: a connected transport is required')
   }
@@ -104,7 +109,7 @@ export async function loginWithPassword ({ transport, address, password, label =
   let ultimo = null
   for (const token of tokens) {
     try {
-      return await unIntento({ transport, token, user, code, dir, password, label, timeoutMs })
+      return await unIntento({ transport, token, user, code, dir, password, label, timeoutMs, opaque })
     } catch (e) {
       // Se para: son cosas del que entra, y probar con otra bóveda no las arregla.
       if (e?.code === 'login-failed' || e?.code === 'too-many-tries' || e?.code === 'wrong-account' ||
@@ -115,15 +120,15 @@ export async function loginWithPassword ({ transport, address, password, label =
   throw ultimo || err('no-vault', 'none of the vaults on that address could let you in')
 }
 
-async function unIntento ({ transport, token, user, code, dir, password, label, timeoutMs }) {
-  const start = opaque.loginStart({ password })
+async function unIntento ({ transport, token, user, code, dir, password, label, timeoutMs, opaque }) {
+  const start = await opaque.loginStart({ password })
   transport.send(token, { type: MSG.LOGIN_START, user, request: start.request })
   const r1 = await waitFor(transport, token, (p) => p.type === MSG.LOGIN_RESPONSE || p.type === MSG.ERROR, timeoutMs)
   if (r1.type === MSG.ERROR) throw deVuelta(r1)
 
   let fin
   try {
-    fin = opaque.loginFinish({ state: start.state, response: r1.response, password })
+    fin = await opaque.loginFinish({ state: start.state, response: r1.response, password })
   } catch (_) {
     // OPAQUE comprueba a las dos partes: aquí se sabe que el otro lado NO conoce el
     // registro de este usuario. Contraseña equivocada, usuario que no existe o una bóveda
@@ -198,11 +203,26 @@ function deVuelta (p) {
  * quedarse bloqueado esperándola. La sesión sigue abierta allí hasta que se cierre desde la
  * consola, y eso ya está dicho en el diseño (§3.2).
  */
-export async function closeLogin ({ transport, token, user, sid, publickey, privateJwk, privateKey, timeoutMs = REPLY_TIMEOUT_MS } = {}) {
+export async function closeLogin ({ transport, token, user, sid, publickey, privateJwk, privateKey, sign, timeoutMs = REPLY_TIMEOUT_MS } = {}) {
   if (!transport || typeof transport.send !== 'function') throw err('no-transport', 'closeLogin: transport required')
   if (!token || !user || !sid || !publickey) throw err('bad-input', 'closeLogin: token, user, sid and publickey are required')
   const data = { op: 'login.close', publickey, user, sid, ts: Date.now() }
-  const { signature } = await signWithDevice({ privateJwk, privateKey, publickey, data })
+  // CON LA LLAVE O CON QUIEN LA TIENE. `sign(data)` es lo normal en el ecosistema —el
+  // transporte se identifica con `identity.signData` y no con una llave suelta— y aquí hace
+  // falta de verdad: en una extensión la llave vive en el service worker y quien tiene el
+  // socket es la página, así que o se firma a distancia o la llave privada tendría que
+  // cruzar para nada. Sin ninguna de las dos no se firma, y salir no se puede fingir.
+  //
+  // Se comprueba ANTES de firmar: sin nada con qué hacerlo, WebCrypto revienta con un error
+  // suyo que no dice qué falta («code: 0»), y el de arriba es el que se puede buscar.
+  if (typeof sign !== 'function' && !privateJwk && !privateKey) {
+    throw err('no-signature', 'closeLogin: give it the device key (privateJwk/privateKey) or a sign(data)')
+  }
+  const firmado = typeof sign === 'function'
+    ? await sign(data)
+    : await signWithDevice({ privateJwk, privateKey, publickey, data })
+  const signature = typeof firmado === 'string' ? firmado : firmado?.signature
+  if (typeof signature !== 'string') throw err('no-signature', 'closeLogin: sign(data) returned no signature')
   transport.send(token, { type: MSG.LOGIN_CLOSE, data, signature })
   try {
     const r = await waitFor(transport, token, (p) => p.type === MSG.LOGIN_CLOSED || p.type === MSG.ERROR, timeoutMs)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.123.0",
+  "version": "0.123.1",
   "type": "module",
   "description": "Certificador personal de Dotrino: daemon headless que custodia la clave maestra y delega capacidades a tus dispositivos por el proxy. Tu CA propia.",
   "bin": {

package/src/tui/app.js

@@ -42,6 +42,12 @@ import { DEVICE_CAPS } from '@dotrino/identity/acta'
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms))
 
 // Regex de validación (mismas que el store de secretos, protocol.js).
+// El mínimo de la contraseña de un inicio de sesión. No es manía: quien tenga una COPIA
+// DEL DISCO de la bóveda puede probar contraseñas contra el registro de OPAQUE sin límite y
+// sin que nadie se entere (`temporary-access.md` §4). Contra eso lo único que aguanta es la
+// contraseña. Mismo número que la CLI, que es la misma regla.
+const MIN_LOGIN_PASSWORD = 12
+
 const NS_RE = /^[a-z0-9-]{1,32}$/
 const KEY_RE = /^[A-Z0-9_]{1,64}$/
 
@@ -343,6 +349,42 @@ function deviceRows (st, t) {
   return rows
 }
 
+/**
+ * ENTRAR CON USUARIO Y CONTRASEÑA (`docs/temporary-access.md`).
+ *
+ * Esto estaba SOLO en la línea de comandos, y es lo que la regla de las tres versiones no
+ * admite: lo que hace el binario tiene que poder hacerse en su pantalla. El canal es el
+ * MISMO que usa `dotrino-vault logins` —una pieza, no dos—, así que no se pueden
+ * desincronizar.
+ *
+ * Lo que se ve de cada uno es lo que hace falta para decidir: su DIRECCIÓN (que es lo que
+ * se teclea en el equipo prestado), cuántas sesiones tiene abiertas, y si está esperando
+ * por intentos fallidos.
+ */
+function loginRows (st, t) {
+  const i = L(st)
+  const rows = []
+  const list = st.logins || []
+  if (!list.length) {
+    rows.push({ text: t.muted(i.noLogins), sel: false })
+    rows.push({ text: '', sel: false })
+    rows.push({ text: t.muted(i.loginsHint), sel: false })
+    return rows
+  }
+  for (const l of list) {
+    const espera = l.blockedUntil > Date.now() ? Math.ceil((l.blockedUntil - Date.now()) / 1000) : 0
+    const abiertas = (l.sessions || []).length
+    const extra = [
+      abiertas ? t.warn('  ' + i.loginOpen(abiertas)) : t.muted('  ' + i.loginOpen(0)),
+      l.label ? t.muted('  «' + l.label + '»') : '',
+      espera ? t.danger('  ' + i.loginWait(espera)) : '',
+      l.createdAt ? t.muted('  ' + i.loginCreated(fmtExp(l.createdAt))) : ''
+    ].join('')
+    rows.push({ text: ` ${t.bold(l.address || l.user)}  ${t.muted(l.deviceId || '????-????')}${extra}`, sel: true, meta: l })
+  }
+  return rows
+}
+
 /**
  * LA PREGUNTA DEL EMPAREJAMIENTO. La decisión es del vault (es quien lo inicia) y
  * este daemon puede tener varias cuentas: antes de mostrar el QR hay que decir a
@@ -753,6 +795,17 @@ async function refreshMembers (term, st) {
   const r = await guard(term, st, L(st).loadingMembers, () => vc.listMembers(activeId(st)))
   if (r.ok) st.members = r.v
 }
+/**
+ * Los inicios de sesión de la bóveda activa. Es una petición aparte del volcado normal a
+ * propósito: no hace falta para nada más, y pedirla siempre sería sacar del cifrado algo
+ * que nadie está mirando.
+ */
+async function refreshLogins (term, st, api = vc) {
+  const r = await guard(term, st, L(st).refreshing, () => api.listLogins(activeId(st)))
+  if (r.ok) st.logins = r.v
+  else st.logins = []
+}
+
 async function refreshMe (term, st) {
   const r = await guard(term, st, L(st).loadingProfile, () => vc.getMe(activeId(st)))
   st.me = r.ok ? r.v : null
@@ -1047,6 +1100,105 @@ async function onKeyDevices (term, st, key) {
   return true
 }
 
+/**
+ * ENTRAR CON USUARIO Y CONTRASEÑA: las mismas acciones que el CLI, con las mismas teclas
+ * que el resto de la TUI (`n` nuevo, `c` contraseña, `v` quitar, `x` cerrar, `u` desbloquear).
+ *
+ * `x` es CERRAR SESIONES y no «quitar», porque aquí «quitar» ya es `v` —revocar, como en
+ * Dispositivos— y una tecla significa lo mismo en todas las pantallas.
+ */
+async function onKeyLogins (term, st, key, api = vc) {
+  const i = L(st)
+  const list = st.logins || []
+  moveSel(st, key, 'logins', list.length)
+  const cur = list[Math.min(st.sel.logins || 0, Math.max(0, list.length - 1))]
+  const ch = key.name === 'char' ? key.ch.toLowerCase() : null
+
+  if (ch === 'n') {
+    // Tres preguntas encadenadas: usuario → de dónde entra → contraseña (dos veces). Van
+    // en cadena y no en un formulario porque la TUI pregunta de a una, como en el resto.
+    setInput(st, {
+      label: i.loginUserLabel,
+      hint: i.loginUserHint,
+      onSubmit: async (raw) => {
+        const user = String(raw || '').trim().toLowerCase()
+        if (!user) return
+        setInput(st, {
+          label: i.loginLabelLabel(user),
+          hint: i.loginLabelHint,
+          value: 'equipo prestado',
+          onSubmit: async (rawLabel) => {
+            const label = String(rawLabel || '').trim() || 'equipo prestado'
+            setInput(st, {
+              label: i.loginPassLabel(user),
+              hint: i.loginPassHint,
+              mask: true,
+              onSubmit: async (pw1) => {
+                if (String(pw1 || '').length < MIN_LOGIN_PASSWORD) { flash(st, i.loginPassShort, 'warn'); return }
+                setInput(st, {
+                  label: i.loginPassAgain,
+                  hint: i.loginPassHint,
+                  mask: true,
+                  onSubmit: async (pw2) => {
+                    if (pw1 !== pw2) { flash(st, i.loginPassMismatch, 'warn'); return }
+                    const r = await guard(term, st, i.loginCreating,
+                      () => api.addLogin({ user, password: pw1, label }))
+                    if (r.ok) {
+                      await refreshLogins(term, st, api)
+                      const nuevo = (st.logins || []).find((l) => l.user === user)
+                      flash(st, i.loginCreatedOk(nuevo?.address || user))
+                    }
+                  }
+                })
+              }
+            })
+          }
+        })
+      }
+    })
+  } else if (ch === 'c' && cur) {
+    setInput(st, {
+      label: i.loginOldPass(cur.user),
+      hint: i.loginPassHint,
+      mask: true,
+      onSubmit: async (vieja) => {
+        setInput(st, {
+          label: i.loginNewPass,
+          hint: i.loginPassHint,
+          mask: true,
+          onSubmit: async (nueva) => {
+            if (String(nueva || '').length < MIN_LOGIN_PASSWORD) { flash(st, i.loginPassShort, 'warn'); return }
+            const r = await guard(term, st, i.loginChanging,
+              () => api.passwdLogin({ user: cur.user, oldPassword: vieja, newPassword: nueva }))
+            if (r.ok) { flash(st, i.loginChanged); await refreshLogins(term, st, api) }
+          }
+        })
+      }
+    })
+  } else if (ch === 'x' && cur) {
+    if (!(cur.sessions || []).length) { flash(st, i.loginNoSessions, 'warn'); return true }
+    const r = await guard(term, st, i.loginClosing, () => api.closeLoginSession(cur.user))
+    if (r.ok) { flash(st, i.loginClosed(r.v?.closed ?? (cur.sessions || []).length)); await refreshLogins(term, st, api) }
+  } else if (ch === 'u' && cur) {
+    if (!(cur.blockedUntil > Date.now())) { flash(st, i.loginNotBlocked, 'warn'); return true }
+    const r = await guard(term, st, i.loginUnblocking, () => api.unblockLogin(cur.user))
+    if (r.ok) { flash(st, i.loginUnblocked); await refreshLogins(term, st, api) }
+  } else if ((ch === 'v' || key.name === 'delete') && cur) {
+    setConfirm(st, {
+      text: i.loginRemoveConfirm(cur.user),
+      onYes: async () => {
+        st.confirm = null
+        const r = await guard(term, st, i.loginRemoving, () => api.removeLogin(cur.user))
+        if (r.ok) { flash(st, i.loginRemoved(cur.user)); st.sel.logins = 0; await refreshLogins(term, st, api) }
+      },
+      onNo: () => { st.confirm = null }
+    })
+  } else if (key.name === 'f5') {
+    await refreshLogins(term, st, api)
+  }
+  return true
+}
+
 /**
  * Tira la cuenta que NACIÓ para un emparejamiento que no llegó a término y vuelve a la que
  * estabas usando. Es una cuenta recién creada y vacía —el aparato nunca entró—, así que no
@@ -1794,8 +1946,8 @@ async function onConfirmKey (st, key) {
 
 // Pestañas INTERNAS de una bóveda ya elegida: se cambian con ←→. La lista de
 // bóvedas (profiles) es el nivel de arriba (se entra con Enter, no es una pestaña).
-const INNER_TABS = ['devices', 'secrets', 'me']
-const tabLabel = (i, k) => ({ devices: i.tabDevices, secrets: i.tabSecrets, me: i.tabMe })[k]
+const INNER_TABS = ['devices', 'secrets', 'logins', 'me']
+const tabLabel = (i, k) => ({ devices: i.tabDevices, secrets: i.tabSecrets, logins: i.tabLogins, me: i.tabMe })[k]
 
 /**
  * Las teclas que se pueden usar AHORA, no el catálogo entero. Aprobar/rechazar sin nadie
@@ -1807,6 +1959,7 @@ const helpSegs = (i, screen, st = {}) => {
     profiles: i.helpProfiles,
     devices: i.helpDevices,
     secrets: i.helpSecrets,
+    logins: i.helpLogins,
     pairing: i.helpPairing,
     pairmode: i.helpPairMode,
     join: i.helpJoin,
@@ -1819,12 +1972,18 @@ const helpSegs = (i, screen, st = {}) => {
   // el único que las lee), y las filas seleccionables de la lista son justo los aparatos.
   const devs = mergeMembersAndCerts(st.members, st.devices?.issued || [])
   const cur = devs[Math.min(st.sel?.devices || 0, devs.length - 1)]
+  // El inicio de sesión señalado: `x cerrar` solo tiene sentido si tiene alguna abierta, y
+  // `u quitar espera` solo si está esperando.
+  const lg = (st.logins || [])[Math.min(st.sel?.logins || 0, Math.max(0, (st.logins || []).length - 1))]
   return segs({
     pending: !!st.pending,
     hasDevices: (st.devices?.issued || []).length > 0,
     isService: !!cur?.cn,
     hasSecrets: Object.keys(st.secrets?.ns || {}).length > 0,
-    hasVars: devVarsOf(st, st.varsFor?.pub).length > 0
+    hasVars: devVarsOf(st, st.varsFor?.pub).length > 0,
+    hasLogins: (st.logins || []).length > 0,
+    hasSessions: ((lg?.sessions) || []).length > 0,
+    blocked: (lg?.blockedUntil || 0) > Date.now()
   })
 }
 
@@ -1843,7 +2002,9 @@ function renderTabs (st, t) {
   return INNER_TABS.map((k) => {
     const active = st.screen === k
     return active ? t.bold(t.accent('▐ ' + tabLabel(i, k) + ' ▌')) : t.muted('  ' + tabLabel(i, k) + '  ')
-  }).join('   ') + t.muted(i.tabsHint)
+    // UN espacio entre pestañas, no tres: con cuatro ya no cabía el «(←→ cambiar)» en 80
+    // columnas, y lo que se perdía era justamente la pista de que se puede cambiar.
+  }).join(' ') + t.muted(i.tabsHint)
 }
 
 function pairingBody (st, t, cols, height) {
@@ -1943,6 +2104,7 @@ function render (term, st) {
   if (st.screen === 'profiles') body = renderList(profileRows(st, t), st.sel.profiles, contentH, cols, t, scrollRef)
   else if (st.screen === 'devices') body = renderList(deviceRows(st, t), st.sel.devices, contentH, cols, t, scrollRef)
   else if (st.screen === 'secrets') body = renderList(secretRows(st, t), st.sel.secrets, contentH, cols, t, scrollRef)
+  else if (st.screen === 'logins') body = renderList(loginRows(st, t), st.sel.logins || 0, contentH, cols, t, scrollRef)
   else if (st.screen === 'me') body = renderList(meRows(st, t), -1, contentH, cols, t, scrollRef)
   else if (st.screen === 'caps') body = renderList(capsRows(st, t), st.sel.caps || 0, contentH, cols, t, scrollRef)
   else if (st.screen === 'devvars') body = renderList(devVarRows(st, t), st.sel.devvars || 0, contentH, cols, t, scrollRef)
@@ -2029,7 +2191,7 @@ export async function runTui () {
   const st = {
     screen: 'profiles', // se arranca en la lista de bóvedas: hay que ENTRAR a una
     lang: loadLang(), // es/en — se conmuta con `l` y se recuerda en prefs.json
-    sel: { profiles: 0, devices: 0, secrets: 0, pairmode: 0, devvars: 0 },
+    sel: { profiles: 0, devices: 0, secrets: 0, pairmode: 0, devvars: 0, logins: 0 },
     // Las bóvedas que ha abierto ESTA sesión, para volver a cerrarlas al salir.
     unlockedHere: new Set(),
     // Su contraseña, SOLO en memoria y SOLO mientras la TUI esté abierta: sirve para
@@ -2040,6 +2202,8 @@ export async function runTui () {
     profiles: null,
     devices: null,
     secrets: null,
+    // Los inicios de sesión se piden al ENTRAR en su pestaña, no al arrancar.
+    logins: null,
     pending: null,
     pairing: null,
     state: null,
@@ -2107,6 +2271,7 @@ export async function runTui () {
         // El perfil se pide al ENTRAR en su pestaña, no al arrancar: es contenido del
         // usuario y no hay por qué sacarlo del cifrado si nadie lo está mirando.
         if (st.screen === 'me' && st.me === undefined) await refreshMe(term, st)
+        if (st.screen === 'logins' && st.logins === null) await refreshLogins(term, st)
         continue
       }
       // Esc/'b' desde una pestaña vuelve a la lista de bóvedas (salir de la bóveda
@@ -2118,6 +2283,7 @@ export async function runTui () {
       if (st.screen === 'profiles') running = await onKeyProfiles(term, st, key)
       else if (st.screen === 'devices') running = await onKeyDevices(term, st, key)
       else if (st.screen === 'secrets') running = await onKeySecrets(term, st, key)
+      else if (st.screen === 'logins') running = await onKeyLogins(term, st, key)
       else if (st.screen === 'me') running = await onKeyMe(term, st, key)
       else if (st.screen === 'caps') running = await onKeyCaps(term, st, key)
       else if (st.screen === 'devvars') running = await onKeyDevVars(term, st, key)
@@ -2138,4 +2304,4 @@ export async function runTui () {
 }
 
 // Solo para pruebas headless (render sin terminal real). No usar en runtime.
-export const __test = { render, onKeySecrets, activeLocked, autoLockedIds, autoLockWakeIn, forgetAutoLocked, autoLockMin, refreshAll, ensureUnlocked, profileRows, deviceRows, secretRows, devVarRows, meRows, capsRows, onKeyCaps, pairModeRows, pairingBody, scrollBody, fitHelp, wrapHelp, wrapWords, joinBody, onKeyJoin, promptJoin, onKeyProfiles, onInputKey, toggleLang, mergeMembersAndCerts, seguirAqui, resetToque: () => { ultimoToque = 0 } }
+export const __test = { render, onKeySecrets, loginRows, onKeyLogins, refreshLogins, activeLocked, autoLockedIds, autoLockWakeIn, forgetAutoLocked, autoLockMin, refreshAll, ensureUnlocked, profileRows, deviceRows, secretRows, devVarRows, meRows, capsRows, onKeyCaps, pairModeRows, pairingBody, scrollBody, fitHelp, wrapHelp, wrapWords, joinBody, onKeyJoin, promptJoin, onKeyProfiles, onInputKey, toggleLang, mergeMembersAndCerts, seguirAqui, resetToque: () => { ultimoToque = 0 } }

package/src/tui/i18n.js

@@ -33,6 +33,44 @@ const es = {
   tooSmallHint: (cols, rows) => `Agranda a ≥ 24×9 (hay ${cols}×${rows}).`,
 
   // pestañas y títulos
+  // ----- ENTRAR CON USUARIO Y CONTRASEÑA (`docs/temporary-access.md`) -----
+  tabLogins: 'Entrar',
+  noLogins: 'Todavía no hay ninguno. Con «n» creas uno.',
+  loginsHint: 'Un aparato de esta cuenta que se abre escribiendo una dirección y una contraseña, sin conectar nada. Sirve para entrar desde un equipo prestado.',
+  loginOpen: (n) => `${n} abierto${n === 1 ? '' : 's'}`,
+  loginWait: (s) => `espera ${s} s`,
+  loginCreated: (d) => `creado ${d}`,
+  helpLogins: ({ hasLogins, hasSessions, blocked } = {}) => [
+    '←→ pestaña', '↑↓', 'n nuevo',
+    ...(hasSessions ? ['x cerrar sesiones'] : []),
+    ...(blocked ? ['u quitar espera'] : []),
+    ...(hasLogins ? ['c contraseña', 'v quitar'] : []),
+    'F5 refrescar', 'Esc bóvedas', 'l English', 'q salir'
+  ],
+  loginUserLabel: '¿Qué nombre de usuario?',
+  loginUserHint: 'letras y números, en minúscula (Esc cancela)',
+  loginLabelLabel: (u) => `¿De dónde va a entrar «${u}»?`,
+  loginLabelHint: 'lo que vas a leer aquí para decidir si cerrarlo (Esc cancela)',
+  loginPassLabel: (u) => `Contraseña para «${u}»`,
+  loginPassAgain: 'Escríbela otra vez',
+  loginPassHint: 'mínimo 12 caracteres; no se puede recuperar (Esc cancela)',
+  loginPassShort: 'La contraseña tiene que tener al menos 12 caracteres.',
+  loginPassMismatch: 'No coinciden. Inténtalo otra vez.',
+  loginOldPass: (u) => `Contraseña actual de «${u}»`,
+  loginNewPass: 'Contraseña nueva',
+  loginCreating: 'Creando el inicio de sesión…',
+  loginCreatedOk: (a) => `Listo. La dirección es ${a}`,
+  loginChanging: 'Cambiando la contraseña…',
+  loginChanged: 'Contraseña cambiada.',
+  loginClosing: 'Cerrando las sesiones…',
+  loginClosed: (n) => `${n} sesión(es) cerrada(s).`,
+  loginUnblocking: 'Quitando la espera…',
+  loginUnblocked: 'Ya puede volver a intentarlo.',
+  loginRemoving: 'Quitándolo…',
+  loginRemoved: (u) => `«${u}» se fue, y su llave salió del acta.`,
+  loginRemoveConfirm: (u) => `¿Quitar «${u}»? Su llave sale del acta y ese equipo deja de entrar.`,
+  loginNoSessions: 'Ese no tiene ninguna sesión abierta.',
+  loginNotBlocked: 'Ese no está esperando.',
   tabDevices: 'Dispositivos',
   tabSecrets: 'Scopes y variables',
   tabMe: 'Perfil',
@@ -403,6 +441,43 @@ const en = {
   tooSmall: 'Terminal too small',
   tooSmallHint: (cols, rows) => `Resize to ≥ 24×9 (now ${cols}×${rows}).`,
 
+  tabLogins: 'Sign in',
+  noLogins: 'None yet. Press “n” to create one.',
+  loginsHint: 'A device of this account that opens by typing an address and a password, with nothing to plug in. It is how you sign in from a borrowed computer.',
+  loginOpen: (n) => `${n} open`,
+  loginWait: (s) => `wait ${s} s`,
+  loginCreated: (d) => `created ${d}`,
+  helpLogins: ({ hasLogins, hasSessions, blocked } = {}) => [
+    '←→ tab', '↑↓', 'n new',
+    ...(hasSessions ? ['x close sessions'] : []),
+    ...(blocked ? ['u clear wait'] : []),
+    ...(hasLogins ? ['c password', 'v remove'] : []),
+    'F5 refresh', 'Esc vaults', 'l español', 'q quit'
+  ],
+  loginUserLabel: 'Which username?',
+  loginUserHint: 'lowercase letters and numbers (Esc cancels)',
+  loginLabelLabel: (u) => `Where will “${u}” sign in from?`,
+  loginLabelHint: 'what you will read here to decide whether to close it (Esc cancels)',
+  loginPassLabel: (u) => `Password for “${u}”`,
+  loginPassAgain: 'Type it again',
+  loginPassHint: 'at least 12 characters; it cannot be recovered (Esc cancels)',
+  loginPassShort: 'The password must be at least 12 characters.',
+  loginPassMismatch: 'They do not match. Try again.',
+  loginOldPass: (u) => `Current password for “${u}”`,
+  loginNewPass: 'New password',
+  loginCreating: 'Creating the sign-in…',
+  loginCreatedOk: (a) => `Done. The address is ${a}`,
+  loginChanging: 'Changing the password…',
+  loginChanged: 'Password changed.',
+  loginClosing: 'Closing the sessions…',
+  loginClosed: (n) => `${n} session(s) closed.`,
+  loginUnblocking: 'Clearing the wait…',
+  loginUnblocked: 'It can try again now.',
+  loginRemoving: 'Removing it…',
+  loginRemoved: (u) => `“${u}” is gone, and its key left the account record.`,
+  loginRemoveConfirm: (u) => `Remove “${u}”? Its key leaves the account record and that computer stops getting in.`,
+  loginNoSessions: 'That one has no open sessions.',
+  loginNotBlocked: 'That one is not waiting.',
   tabDevices: 'Devices',
   tabSecrets: 'Scopes & variables',
   tabMe: 'Profile',

package/src/vaultControl.js

@@ -49,7 +49,11 @@ const F = {
   secretReq: 'secret-request.json',
   profileReq: 'profile-request.json',
   meReq: 'me-request.json',
-  dumpReq: 'dump-request.json'
+  dumpReq: 'dump-request.json',
+  // ENTRAR CON USUARIO Y CONTRASEÑA. La respuesta NO se llama `logins.json`: ese nombre ya
+  // es el almacén del escritorio dentro del dir del perfil, y pisarlo los borraría.
+  loginsReq: 'logins-request.json',
+  loginsList: 'logins-list.json'
 }
 
 const p = (name) => path.join(dir, name)
@@ -242,6 +246,96 @@ export const setProfilePassword = (profile, password, current) => profileOp('pas
 // Quitarla también la pide: se re-sella a la llave de la máquina antes de que se vaya.
 export const removeProfilePassword = (profile, password) => profileOp('password-rm', { profile, password })
 
+// ---------------------------------------------------------------------------
+// Inicios de sesión con contraseña (`docs/temporary-access.md`)
+// ---------------------------------------------------------------------------
+
+/**
+ * Un viaje al mostrador de inicios de sesión del daemon. Es el MISMO canal que usa el CLI
+ * (`dotrino-vault logins`) —una pieza, no dos— y por eso la pantalla de la TUI y el
+ * comando no se pueden desincronizar.
+ *
+ * La respuesta se BORRA al leerla: puede traer el paquete de llaves de un aparato.
+ */
+export async function loginsOp (op, extra = {}) {
+  requireAlive()
+  rm(F.loginsList)
+  const since = Date.now()
+  const id = await writeReq(F.loginsReq, { op, ...extra })
+  signalOrCleanup('SIGUSR2', [F.loginsReq])
+  const d = await waitFor(F.loginsList, { req: id, since })
+  rm(F.loginsList)
+  if (!d) throw coded('the daemon did not reply', 'NO_REPLY')
+  if (d.ok === false) {
+    // `too-many-tries` trae cuánto falta, y `PROFILE_LOCKED` se arregla abriendo la bóveda:
+    // los dos cambian lo que hay que hacer, así que viajan con su dato.
+    throw Object.assign(coded(d.error || 'logins: the vault refused', d.code), { waitMs: d.waitMs })
+  }
+  return d
+}
+
+/** Los inicios de sesión de este perfil, con la dirección ya montada. */
+export async function listLogins (profile) {
+  const { logins = [], fingerprint } = await loginsOp('list', profile ? { profile } : {})
+  const { loginAddress } = await import('../lib/src/passwordLogins.js')
+  return logins.map((l) => ({ ...l, address: fingerprint ? loginAddress(l.user, fingerprint) : '' }))
+}
+
+/**
+ * ALTA. Las llaves del aparato NACEN aquí, en esta terminal, y salen ya cerradas con lo
+ * que deriva de la contraseña: lo que la bóveda guarda es un paquete que no puede abrir.
+ *
+ * Se pueden tener VARIOS por perfil, cada uno con sus permisos: son miembros del acta como
+ * cualquier otro aparato.
+ */
+export async function addLogin ({ user, password, label = 'equipo prestado', caps = ['sign', 'read', 'store'] } = {}) {
+  const { client: opaque } = await import('@dotrino/opaque')
+  const { makeDeviceKey, makeDeviceEncKey } = await import('@dotrino/identity/capabilities')
+  const { capScope } = await import('@dotrino/identity/acta')
+  const { sealDeviceKeys } = await import('../lib/src/passwordLogins.js')
+  const start = opaque.registrationStart({ password })
+  const begun = await loginsOp('register-begin', { user, request: start.request })
+  const fin = opaque.registrationFinish({ state: start.state, response: begun.response, password })
+  const device = await makeDeviceKey({ label })
+  const enc = await makeDeviceEncKey()
+  const blob = await sealDeviceKeys(fin.exportKey, { sign: device.privateJwk, enc: enc.privateJwk })
+  // El acta habla de PERMISOS y el papel de SCOPES: los traduce el pilar, no esta pantalla.
+  // `unattended` no es un scope —es «no me pidas aprobación»— y por eso viaja aparte.
+  return loginsOp('register-finish', {
+    user, upload: fin.upload, pub: device.publickey, encPub: enc.publickey, label, blob,
+    scope: caps.filter((c) => c !== 'unattended').map((c) => capScope(c)).filter(Boolean),
+    unattended: caps.includes('unattended')
+  })
+}
+
+/**
+ * Cambiar la contraseña es ABRIR y volver a cerrar, así que hace falta la vieja: el
+ * paquete de llaves está cerrado con lo que salía de ella, y sin abrirlo no hay qué
+ * volver a cerrar. Perderla no se arregla desde aquí — se quita el aparato y se crea otro.
+ */
+export async function passwdLogin ({ user, oldPassword, newPassword } = {}) {
+  const { client: opaque } = await import('@dotrino/opaque')
+  const { sealDeviceKeys, openDeviceKeys } = await import('../lib/src/passwordLogins.js')
+  const start = opaque.loginStart({ password: oldPassword })
+  const begun = await loginsOp('login-begin', { user, request: start.request })
+  let fin
+  try { fin = opaque.loginFinish({ state: start.state, response: begun.response, password: oldPassword }) }
+  catch (_) { throw coded('wrong password', 'login-failed') }
+  const entrada = await loginsOp('login-end', { lid: begun.lid, finalization: fin.finalization, label: 'la consola' })
+  const keys = await openDeviceKeys(fin.exportKey, entrada.blob)
+  const reg = opaque.registrationStart({ password: newPassword })
+  const { response } = await loginsOp('register-begin', { user, request: reg.request, replace: true })
+  const nueva = opaque.registrationFinish({ state: reg.state, response, password: newPassword })
+  return loginsOp('register-finish', {
+    user, upload: nueva.upload, blob: await sealDeviceKeys(nueva.exportKey, keys), replace: true
+  })
+}
+
+export const closeLoginSession = (user, sid = null) => loginsOp('close', { user, ...(sid ? { sid } : {}) })
+export const unblockLogin = (user) => loginsOp('unblock', { user })
+/** Quitarlo lo saca del mostrador **y su llave del acta**: las dos cosas, o ninguna. */
+export const removeLogin = (user) => loginsOp('rm', { user })
+
 // ---------------------------------------------------------------------------
 // Volcado de dispositivos + secretos de un perfil
 // ---------------------------------------------------------------------------