@dotrino/vaultd 0.154.1 → 0.156.0

package/lib/src/enroll.js

@@ -31,6 +31,7 @@
  */
 import { verifyDeviceSig, pubkeyId, commitCode } from '@dotrino/identity/capabilities'
 import { verifyContinuity, canSeal, DEVICE_CAPS, VAULT_CN } from '@dotrino/identity/acta'
+import { cleanMachine } from '@dotrino/identity/machine'
 
 /** Un token de emparejamiento vale 5 min. */
 export const PAIRING_TTL_MS = 5 * 60 * 1000
@@ -113,7 +114,7 @@ export async function deviceIdOf (pub) {
  * @param {(pub:string, obj:object)=>void} opts.sendByPubkey   dirigir por pubkey (cola offline 24 h).
  * @param {(op:string, info?:object)=>void} [opts.audit]
  * @param {(...a:any[])=>void} [opts.log]
- * @param {(c:{deviceId:string, scope:any, label:string})=>void} [opts.onChallenge]  un dispositivo espera aprobación.
+ * @param {(c:{deviceId:string, scope:any, label:string, machine?:any, mode?:string})=>void} [opts.onChallenge]  un dispositivo espera aprobación.
  * @param {()=>void} [opts.onPendingChange]
  * @param {(sub:string)=>void} [opts.onDeviceRemoved]  se quitó un aparato (fuera del acta y sin papeles):
  *   para que quien guarde algo indexado por esa llave lo suelte. Se avisa desde AQUÍ y no desde
@@ -210,7 +211,7 @@ export function createEnrollDesk ({
   function listPending () {
     return [...pending.values()]
       .filter((p) => p.state === 'PENDING_CONFIRM')
-      .map((p) => ({ deviceId: p.deviceId, label: p.label || '', scope: p.scope }))
+      .map((p) => ({ deviceId: p.deviceId, label: p.label || '', scope: p.scope, machine: p.machine || null }))
   }
 
   function findPending (deviceId) {
@@ -314,12 +315,15 @@ export function createEnrollDesk ({
     // cuál era cuál. Si en `pair` le diste un nombre, ese es el nombre; el del aparato
     // sigue valiendo como propuesta cuando no dijiste nada.
     if (d.label && !pend.label) pend.label = String(d.label).slice(0, 60)
+    // DÓNDE CORRE (`@dotrino/identity/machine`): entra al acta con el aparato, para que la
+    // lista lo distinga de los demás aunque todos se llamen igual.
+    pend.machine = cleanMachine(d.machine)
     // Camino A: de qué cuenta estamos hablando. Se guarda para poder comprobar, cuando
     // llegue el acta sellada, que es la que este dispositivo dijo que iba a entregar.
     if (intent === 'adopt' && typeof d.profileId === 'string') pend.profileId = d.profileId
 
     reply(from, { type: MSG_ENROLL_CHALLENGE, deviceId })
-    fire(onChallenge, { deviceId, scope: pend.scope, label: pend.label || '', mode: pend.mode || 'join' })
+    fire(onChallenge, { deviceId, scope: pend.scope, label: pend.label || '', machine: pend.machine || null, mode: pend.mode || 'join' })
     fire(onPendingChange)
     return { deviceId }
   }
@@ -396,7 +400,7 @@ export function createEnrollDesk ({
     const { cert } = await identity.signDelegation(pend.dpub, pend.scope, { ttlMs: pend.ttlMs, label: pend.label })
 
     try {
-      await identity.admitMember({ pub: pend.dpub, encPub: pend.encPub || null, label: pend.label || '', cn, caps, cert, continuity: pend.continuity || null })
+      await identity.admitMember({ pub: pend.dpub, encPub: pend.encPub || null, label: pend.label || '', cn, caps, cert, continuity: pend.continuity || null, machine: pend.machine || null })
     } catch (e) {
       // El certificado ya está firmado y no se entrega: se revoca, para que no quede uno
       // válido suelto. Si ni eso sale, se dice también.

package/lib/src/proc.js

@@ -29,18 +29,10 @@
  */
 import fs from 'node:fs'
 import os from 'node:os'
-import crypto from 'node:crypto'
+import { cleanMachine } from '@dotrino/identity/machine'
+import { MAX_PATH_BYTES, clip, trimArgv, sanitizeContext, commandFingerprint, sameCommand, commandLine } from './procContext.js'
 
-/** Topes. Un `argv` puede ser enorme y esto viaja en cada pedido y se pinta en un teléfono. */
-export const MAX_ARGV_BYTES = 4096
-export const MAX_PATH_BYTES = 1024
-/** Cuántos argumentos como mucho: más que esto no lo lee nadie. */
-export const MAX_ARGV_ITEMS = 64
-
-const clip = (s, max) => {
-  if (typeof s !== 'string') return ''
-  return Buffer.byteLength(s) <= max ? s : Buffer.from(s).subarray(0, max).toString('utf8')
-}
+export { MAX_ARGV_BYTES, MAX_PATH_BYTES, MAX_ARGV_ITEMS, sanitizeContext, commandFingerprint, sameCommand, commandLine } from './procContext.js'
 
 /** ¿Hay `/proc`? Es lo que separa poder medir de tener que creer. */
 export const hasProc = () => { try { return fs.statSync('/proc/self').isDirectory() } catch (_) { return false } }
@@ -53,24 +45,6 @@ function readCmdline (pid) {
   return parts
 }
 
-/**
- * Recorta el `argv` a lo que se puede enseñar y transportar. Devuelve también si sobró
- * algo: un comando cortado que no dice que está cortado se lee como otro comando.
- */
-function trimArgv (argv) {
-  const list = (Array.isArray(argv) ? argv : []).map((a) => String(a))
-  let cut = list.length > MAX_ARGV_ITEMS
-  const kept = list.slice(0, MAX_ARGV_ITEMS)
-  let total = 0
-  const out = []
-  for (const a of kept) {
-    const b = Buffer.byteLength(a)
-    if (total + b > MAX_ARGV_BYTES) { cut = true; break }
-    total += b
-    out.push(a)
-  }
-  return { argv: out, truncated: cut }
-}
 
 /**
  * LA HORA DE ARRANQUE del proceso (campo 22 de `/proc/<pid>/stat`, en ticks). Sirve para
@@ -131,62 +105,18 @@ export function selfContext () {
   }
 }
 
-const safeCwd = () => { try { return process.cwd() } catch (_) { return '' } }
-const userName = () => { try { return os.userInfo().username } catch (_) { return '' } }
-
-/**
- * LO QUE LLEGA POR LA RED NO SE CREE NI EN LA FORMA. Este dato lo manda otro proceso, se
- * guarda en memoria y se pinta en un teléfono: se recorta a lo que cabe y se tira lo que no
- * tiene el tipo que debería. Devuelve `null` si no queda nada que enseñar — que no es lo
- * mismo que un contexto vacío, y por eso no se devuelve un objeto a medias.
- */
-export function sanitizeContext (raw) {
-  if (!raw || typeof raw !== 'object') return null
-  const argvRaw = Array.isArray(raw.argv) ? raw.argv.filter((a) => typeof a === 'string') : []
-  const { argv, truncated } = trimArgv(argvRaw)
-  const exe = clip(typeof raw.exe === 'string' ? raw.exe : '', MAX_PATH_BYTES)
-  const cwd = clip(typeof raw.cwd === 'string' ? raw.cwd : '', MAX_PATH_BYTES)
-  if (!exe && !argv.length) return null
-  return {
-    pid: Number.isInteger(raw.pid) && raw.pid > 0 ? raw.pid : null,
-    uid: Number.isInteger(raw.uid) ? raw.uid : null,
-    exe,
-    cwd,
-    argv,
-    truncated: truncated || raw.truncated === true,
-    start: Number.isFinite(raw.start) ? raw.start : null,
-    user: clip(typeof raw.user === 'string' ? raw.user : '', 64),
-    host: clip(typeof raw.host === 'string' ? raw.host : '', 64)
-  }
-}
-
 /**
- * LA HUELLA DEL COMANDO: qué binario, desde qué carpeta y con qué argumentos. Es la llave
- * de la concesión por tiempo — aprobar `node server.js` en `/srv/app` no aprueba otra cosa
- * ni la misma cosa en otro sitio.
- *
- * El pid NO entra: cambia en cada arranque y la gracia es justamente que el mismo comando
- * se reconozca la próxima vez.
+ * DÓNDE CORRE ESTE PROCESO (`@dotrino/identity/machine`): para que la bóveda lo reconozca en
+ * su lista de aparatos. Va en lo que el aparato firma al emparejarse y en cada pedido de
+ * secretos, así que se refresca solo cuando cambia de máquina o de sistema.
  */
-export function commandFingerprint (ctx) {
-  if (!ctx || typeof ctx !== 'object') return null
-  const argv = Array.isArray(ctx.argv) ? ctx.argv : []
-  if (!ctx.exe && !argv.length) return null
-  const material = [ctx.exe || '', ctx.cwd || '', ...argv].join('\0')
-  return crypto.createHash('sha256').update(material).digest('hex')
+export function selfMachine () {
+  const tipo = os.type()
+  const sistema = tipo === 'Darwin' ? 'macOS' : tipo === 'Windows_NT' ? 'Windows' : tipo
+  return cleanMachine({ kind: 'node', os: `${sistema} ${os.release()}`, name: os.hostname() })
 }
 
-/** ¿Son el mismo comando? Mismo binario, misma carpeta, mismos argumentos. */
-export const sameCommand = (a, b) => {
-  const fa = commandFingerprint(a)
-  return !!fa && fa === commandFingerprint(b)
-}
-
-/** El comando en una línea, para un log o una pantalla estrecha. */
-export function commandLine (ctx, max = 160) {
-  const argv = Array.isArray(ctx?.argv) ? ctx.argv : []
-  const linea = argv.length ? argv.join(' ') : (ctx?.exe || '')
-  return linea.length > max ? linea.slice(0, max - 1) + '…' : linea
-}
+const safeCwd = () => { try { return process.cwd() } catch (_) { return '' } }
+const userName = () => { try { return os.userInfo().username } catch (_) { return '' } }
 
 export default { selfContext, readProcContext, sanitizeContext, commandFingerprint, sameCommand, commandLine, hasProc }

package/lib/src/procContext.js

@@ -0,0 +1,97 @@
+/**
+ * LA PARTE PORTABLE DE `proc.js`: limpiar el contexto que declara quien pide, su huella y su
+ * línea. La usan el binario y la bóveda del navegador (que no tiene `/proc` y nunca mide,
+ * así que todo lo que le llega se queda como declarado). Leer `/proc` sigue en `proc.js`,
+ * que es solo de Node.
+ */
+import { sha256Hex } from './core/sha256.js'
+
+/** Topes. Un `argv` puede ser enorme y esto viaja en cada pedido y se pinta en un teléfono. */
+export const MAX_ARGV_BYTES = 4096
+export const MAX_PATH_BYTES = 1024
+/** Cuántos argumentos como mucho: más que esto no lo lee nadie. */
+export const MAX_ARGV_ITEMS = 64
+
+const enc = new TextEncoder()
+const byteLength = (s) => enc.encode(s).length
+export const clip = (s, max) => {
+  if (typeof s !== 'string') return ''
+  const b = enc.encode(s)
+  return b.length <= max ? s : new TextDecoder().decode(b.subarray(0, max))
+}
+
+/**
+ * Recorta el `argv` a lo que se puede enseñar y transportar. Devuelve también si sobró
+ * algo: un comando cortado que no dice que está cortado se lee como otro comando.
+ */
+export function trimArgv (argv) {
+  const list = (Array.isArray(argv) ? argv : []).map((a) => String(a))
+  let cut = list.length > MAX_ARGV_ITEMS
+  const kept = list.slice(0, MAX_ARGV_ITEMS)
+  let total = 0
+  const out = []
+  for (const a of kept) {
+    const b = byteLength(a)
+    if (total + b > MAX_ARGV_BYTES) { cut = true; break }
+    total += b
+    out.push(a)
+  }
+  return { argv: out, truncated: cut }
+}
+
+/**
+ * LO QUE LLEGA POR LA RED NO SE CREE NI EN LA FORMA. Este dato lo manda otro proceso, se
+ * guarda en memoria y se pinta en un teléfono: se recorta a lo que cabe y se tira lo que no
+ * tiene el tipo que debería. Devuelve `null` si no queda nada que enseñar — que no es lo
+ * mismo que un contexto vacío, y por eso no se devuelve un objeto a medias.
+ */
+export function sanitizeContext (raw) {
+  if (!raw || typeof raw !== 'object') return null
+  const argvRaw = Array.isArray(raw.argv) ? raw.argv.filter((a) => typeof a === 'string') : []
+  const { argv, truncated } = trimArgv(argvRaw)
+  const exe = clip(typeof raw.exe === 'string' ? raw.exe : '', MAX_PATH_BYTES)
+  const cwd = clip(typeof raw.cwd === 'string' ? raw.cwd : '', MAX_PATH_BYTES)
+  if (!exe && !argv.length) return null
+  return {
+    pid: Number.isInteger(raw.pid) && raw.pid > 0 ? raw.pid : null,
+    uid: Number.isInteger(raw.uid) ? raw.uid : null,
+    exe,
+    cwd,
+    argv,
+    truncated: truncated || raw.truncated === true,
+    start: Number.isFinite(raw.start) ? raw.start : null,
+    user: clip(typeof raw.user === 'string' ? raw.user : '', 64),
+    host: clip(typeof raw.host === 'string' ? raw.host : '', 64)
+  }
+}
+
+/**
+ * LA HUELLA DEL COMANDO: qué binario, desde qué carpeta y con qué argumentos. Es la llave
+ * de la concesión por tiempo — aprobar `node server.js` en `/srv/app` no aprueba otra cosa
+ * ni la misma cosa en otro sitio.
+ *
+ * El pid NO entra: cambia en cada arranque y la gracia es justamente que el mismo comando
+ * se reconozca la próxima vez.
+ */
+export function commandFingerprint (ctx) {
+  if (!ctx || typeof ctx !== 'object') return null
+  const argv = Array.isArray(ctx.argv) ? ctx.argv : []
+  if (!ctx.exe && !argv.length) return null
+  const material = [ctx.exe || '', ctx.cwd || '', ...argv].join('\0')
+  return sha256Hex(material)
+}
+
+/** ¿Son el mismo comando? Mismo binario, misma carpeta, mismos argumentos. */
+export const sameCommand = (a, b) => {
+  const fa = commandFingerprint(a)
+  return !!fa && fa === commandFingerprint(b)
+}
+
+/** El comando en una línea, para un log o una pantalla estrecha. */
+export function commandLine (ctx, max = 160) {
+  const argv = Array.isArray(ctx?.argv) ? ctx.argv : []
+  const linea = argv.length ? argv.join(' ') : (ctx?.exe || '')
+  return linea.length > max ? linea.slice(0, max - 1) + '…' : linea
+}
+
+export default { sanitizeContext, commandFingerprint, sameCommand, commandLine, trimArgv }

package/lib/src/service.js

@@ -32,7 +32,7 @@ import { makeEphemeralKey, openSealed } from './sealed.js'
 import { parseInvite } from './invite.js'
 import { atRestFor } from './atrest.js'
 import { connectLocal, hasLocalVault } from './localdesk.js'
-import { selfContext } from './proc.js'
+import { selfContext, selfMachine } from './proc.js'
 
 const IDENTITY_FILE = 'service-identity.json'
 const FRESH_WINDOW_MS = 5 * 60 * 1000
@@ -378,7 +378,7 @@ export async function enrollWithVault ({ qr, label = 'agent', expectedScope = nu
     // aprende solo cuando un humano lo tipea → aprobar exige TENER esta máquina.
     const code = makePairingCode()
     const commit = await commitCode({ code, dpub: device.publickey, sn: qr.sn })
-    const data = { op: 'enroll', intent: 'join', dpub: device.publickey, encPub: enc?.encPublickey || null, token: qr.token || qr.sn, sn: qr.sn, commit, label, ts: Date.now() }
+    const data = { op: 'enroll', intent: 'join', dpub: device.publickey, encPub: enc?.encPublickey || null, token: qr.token || qr.sn, sn: qr.sn, commit, label, machine: selfMachine(), ts: Date.now() }
     const { signature } = await signWithDevice({ privateJwk: device.privateJwk, data })
 
     const enrolled = new Promise((resolve, reject) => {
@@ -908,7 +908,7 @@ export async function fetchSecrets ({ dir, ns, proxyUrl, masterPubkey, device, c
     const ctx = client.local ? selfContext() : null
     // `publicOnly` VIAJA FIRMADO (va dentro de `data`), así que nadie lo puede quitar ni
     // poner por el camino. Quien decide qué se manda es la bóveda; esto solo es la petición.
-    const data = { op: 'secrets', ns, ek: eph.ek, publickey: device.publickey, ts: Date.now(), v: MY_VERSION, ...(ctx ? { ctx } : {}), ...(publicOnly ? { publicOnly: true } : {}) }
+    const data = { op: 'secrets', ns, ek: eph.ek, publickey: device.publickey, ts: Date.now(), v: MY_VERSION, machine: selfMachine(), ...(ctx ? { ctx } : {}), ...(publicOnly ? { publicOnly: true } : {}) }
     const { signature } = await signWithDevice({ privateJwk: device.privateJwk, data })
     // A QUIÉN SE LE PREGUNTA: primero a la bóveda, y si no contesta, a los REPLICADORES
     // que el acta nombraba la última vez que la vimos (`docs/replicas.md` §8: «el servicio

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.154.1",
+  "version": "0.156.0",
   "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": {
@@ -22,11 +22,11 @@
   },
   "dependencies": {
     "@dotrino/compat": "0.4.0",
-    "@dotrino/identity": "^0.111.0",
+    "@dotrino/identity": "^0.116.0",
     "@dotrino/opaque": "0.1.0",
     "@dotrino/passmanager": "0.17.0",
     "@dotrino/proxy-client": "^0.32.2",
-    "@dotrino/roadmap": "0.3.19",
+    "@dotrino/roadmap": "0.4.13",
     "@dotrino/store": "0.11.0",
     "@dotrino/update": "0.5.1",
     "ws": "^8.18.0"

package/src/ctl.js

@@ -30,7 +30,7 @@ import { pubkeyId } from '@dotrino/identity/capabilities'
 import { dataDir } from './paths.js'
 // EL CANAL LOCAL VA CIFRADO (ver `ipc.js`): por aquí salen la contraseña y los valores.
 import { ipcRead, ipcWrite } from './ipc.js'
-import { assertVar } from './secretsStore.js'
+import { assertVar } from '../lib/src/core/secretsStore.js'
 import { isValidSecretsNs } from './protocol.js'
 import { parseEnvText, PAIR_RE } from '../lib/src/envtext.js'
 import { qrToString } from './qr.js'
@@ -39,7 +39,8 @@ import { atRestFor, readConfig as readKekConfig, probe as probeKek, rekeyDir, en
 import { VERSION } from './version.js'
 import * as hw from './hwkeys.js'
 import { isNewer } from './update.js'
-import { COMM_CN } from './commKey.js'
+import { COMM_CN } from '../lib/src/core/commKey.js'
+import { machineLine } from '@dotrino/identity/machine'
 
 const dir = dataDir()
 const stateFile = path.join(dir, 'state.json')
@@ -673,6 +674,8 @@ async function cmdMembers () {
     if (m.renounced?.length) {
       console.log('      %s↓ renunció a %s (pendiente de sellar: abre la bóveda)%s', R, m.renounced.join(', '), Z)
     }
+    // DÓNDE CORRE (`@dotrino/identity/machine`): con qué se reconoce cuál es cuál.
+    if (machineLine(m.machine)) console.log('      %s%s%s', D, machineLine(m.machine), Z)
     if (m.running) {
       const v = `${m.running.product} ${m.running.version}`
       if (m.running.compatible) console.log('      %scorre %s%s', D, v, Z)

package/src/daemon.js

@@ -29,7 +29,7 @@ import { latestRelease, isNewer, CHECK_EVERY_MS, isUserInstall, installUserRelea
 import { VERSION } from './version.js'
 import { readSettings } from './settings.js'
 import { approversOfAll, firstYes, readAsked, writeAsked, clearAsked, shouldAsk, resultOfNo, readRootTold, writeRootTold, shouldTellRoot } from './updateApproval.js'
-import { UPDATE_TTL_MS } from './approvals.js'
+import { UPDATE_TTL_MS } from '../lib/src/core/approvals.js'
 import crypto from 'node:crypto'
 
 const readJsonSafe = (f) => ipcRead(f, null)
@@ -87,8 +87,8 @@ export async function runDaemon () {
   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 }) => {
-    ipcWrite(pendingEnrollFile, { v: 2, at: Date.now(), deviceId, scope, profile, profileName })
+  const onEnrollChallenge = ({ deviceId, scope, profile, profileName, machine }) => {
+    ipcWrite(pendingEnrollFile, { v: 2, at: Date.now(), deviceId, scope, profile, profileName, machine: machine || null })
   }
 
   const mgr = await startVaultManager({ root: dir, proxyUrl, onEnrollChallenge })

package/src/disk.js

@@ -0,0 +1,54 @@
+/**
+ * EL DISCO DEL BINARIO: archivos de verdad bajo el directorio del perfil, en modo 0600 y
+ * cifrados en reposo con la llave de esta máquina. Es la implementación de la interfaz de
+ * `lib/src/core/disk.js` que usa el demonio; el navegador pone la suya.
+ *
+ * Todo lo que es de Node y de un sistema de archivos con permisos (el `chmod`, escribir
+ * aparte y renombrar) vive aquí, y no en el núcleo, para que el núcleo sea el mismo código
+ * en las tres bóvedas.
+ */
+import fs from 'node:fs'
+import path from 'node:path'
+import { atRestFor, kekFor } from './atrest.js'
+import { ensureDir } from './paths.js'
+
+/** El modo de un archivo que existía con otro más abierto (las bitácoras de antes de 0.89). */
+function narrow (file) {
+  try { if ((fs.statSync(file).mode & 0o077) !== 0) fs.chmodSync(file, 0o600) } catch (_) {}
+}
+
+export function nodeDisk (dir, { atRest = null } = {}) {
+  ensureDir(dir)
+  const at = (name) => path.join(dir, name)
+  return {
+    dir,
+    read (name) {
+      try { return fs.readFileSync(at(name), 'utf8') } catch (e) {
+        if (e.code === 'ENOENT') return null
+        throw e
+      }
+    },
+    write (name, text) {
+      const file = at(name)
+      ensureDir(path.dirname(file))
+      const tmp = file + '.tmp'
+      fs.writeFileSync(tmp, text, { mode: 0o600 })
+      fs.renameSync(tmp, file)
+      narrow(file)
+    },
+    append (name, text) {
+      const file = at(name)
+      fs.appendFileSync(file, text, { mode: 0o600 })
+      // El `mode` de `appendFileSync` solo aplica al CREAR.
+      narrow(file)
+    },
+    exists: (name) => fs.existsSync(at(name)),
+    remove: (name) => { fs.rmSync(at(name), { force: true }) },
+    rename: (from, to) => { fs.renameSync(at(from), at(to)) },
+    size: (name) => { try { return fs.statSync(at(name)).size } catch (_) { return 0 } },
+    atRest: atRest || atRestFor(dir),
+    machineKey: () => new Uint8Array(kekFor(dir))
+  }
+}
+
+export default { nodeDisk }

package/src/platform.js

@@ -0,0 +1,139 @@
+/**
+ * LO QUE EL BINARIO PONE PARA CORRER LA BÓVEDA (`lib/src/core/vault.js`): el disco del
+ * perfil, la identidad leída de su directorio, `/proc`, el nombre de la máquina y el
+ * mostrador local por socket de archivo. El navegador pone lo suyo en
+ * `lib/src/core/browserPlatform.js`; el núcleo es el mismo.
+ */
+import fs from 'node:fs'
+import net from 'node:net'
+import os from 'node:os'
+import path from 'node:path'
+import { Identity } from '@dotrino/identity/node'
+import { MSG } from '../lib/src/protocol.js'
+import { readProcContext } from '../lib/src/proc.js'
+import { localSocketPath, socketDir } from '../lib/src/localdesk.js'
+import { kekFor, migrateFile, encryptText, decryptText, atRestFor } from './atrest.js'
+import { assertKeyOwnsDir } from './keyowner.js'
+import { installNodeGlobals } from './node-globals.js'
+import { nodeDisk } from './disk.js'
+import { VERSION } from './version.js'
+
+/**
+ * EL MOSTRADOR LOCAL: el mismo protocolo, sin salir de la máquina.
+ *
+ * Un servicio en ESTA máquina hablaba con la bóveda dando la vuelta por
+ * `proxy.dotrino.com`: sale a internet, vuelve, y si el proxio tiene un mal momento el
+ * arranque se retrasa cinco segundos por nada. Absurdo cuando los dos procesos comparten
+ * disco (dueño, 2026-09-03: «estando en la misma máquina debería ser inmediato»).
+ *
+ * Es EL MISMO PROTOCOLO y el mismo enrutador: llega `{type, data, signature, cert}` y se
+ * comprueba igual, contra el certificado y contra el acta. **Alcanzar el socket no
+ * autoriza nada** — es la misma puerta por un camino más corto, no una puerta de atrás.
+ * Por eso no hay un solo `if` de «viene de local» en ningún handler, y no debe haberlo.
+ *
+ * Y no es un puerto: es un socket de archivo, en modo 0600 y bajo el directorio del
+ * usuario. No se alcanza desde otra máquina ni desde otro usuario, así que la promesa
+ * del `docker-compose` —«la bóveda no escucha nada»— sigue siendo cierta donde importa.
+ */
+function openLocalDesk ({ name, onMessage, channels: canales, maxBytes: MAX_REPLY_BYTES, log }) {
+  const socketPath = localSocketPath(name)
+  let n = 0
+  const server = net.createServer((sock) => {
+    const id = 'local:' + (++n)
+    let buf = ''
+    const enviar = (obj) => { try { sock.write(JSON.stringify(obj) + '\n') } catch (_) {} }
+    canales.set(id, enviar)
+    sock.on('data', (chunk) => {
+      buf += chunk
+      // UN TOPE, y por lo mismo que en las respuestas: sin él, quien se conecte puede
+      // hacer crecer este buffer hasta tumbar la bóveda mandando y sin saltos de línea.
+      if (buf.length > MAX_REPLY_BYTES) { buf = ''; enviar({ type: MSG.ERROR, error: 'request too big' }); return }
+      let i
+      while ((i = buf.indexOf('\n')) >= 0) {
+        const linea = buf.slice(0, i); buf = buf.slice(i + 1)
+        if (!linea.trim()) continue
+        let p = null
+        try { p = JSON.parse(linea) } catch (_) { enviar({ type: MSG.ERROR, error: 'malformed request' }); continue }
+        onMessage(id, p).catch((e) => enviar({ type: MSG.ERROR, error: e.message }))
+      }
+    })
+    const cerrar = () => canales.delete(id)
+    sock.on('close', cerrar)
+    sock.on('error', cerrar)
+  })
+  server.on('error', (e) => log('[vault] the local desk could not open (' + e.message + '): services will use the proxy'))
+  // EL DIRECTORIO ES EL CONTROL, no el modo del socket.
+  //
+  // `mkdir` con `mode` NO corrige un directorio que ya existe, y sin `XDG_RUNTIME_DIR`
+  // —un servicio de sistema, un contenedor— esto cae en `/tmp`, donde cualquiera puede
+  // haberlo creado antes con permiso de escritura para todos. Quien sea dueño del
+  // directorio puede borrar el socket y poner el suyo: los servicios de esta máquina
+  // acabarían hablando con él. No leería nada (la respuesta va firmada por una llave que
+  // nombra el acta y el cliente la comprueba), pero los deja sin arrancar.
+  //
+  // Y el `chmod 0600` de abajo llega DESPUÉS de `listen`, así que por sí solo deja una
+  // rendija. Lo que la cierra de verdad es que el directorio sea nuestro y solo nuestro.
+  const dir = socketDir()
+  try { fs.mkdirSync(dir, { recursive: true, mode: 0o700 }) } catch (_) {}
+  try {
+    const st = fs.statSync(dir)
+    const ajeno = typeof process.getuid === 'function' && st.uid !== process.getuid()
+    const abierto = (st.mode & 0o077) !== 0
+    if (ajeno || abierto) {
+      return log(`[vault] the local desk stays closed: ${dir} is ${ajeno ? 'owned by another user' : 'writable by others'} ` +
+        '— services on this machine will use the proxy instead')
+    }
+  } catch (e) {
+    return log('[vault] the local desk stays closed: could not check ' + dir + ' (' + e.message + ')')
+  }
+  try { fs.rmSync(socketPath, { force: true }) } catch (_) {}
+  server.listen(socketPath, () => {
+    try { fs.chmodSync(socketPath, 0o600) } catch (_) {}
+    log('[vault] local desk at ' + socketPath + ' (same machine, no round trip)')
+  })
+  server.unref?.()
+  return server
+}
+
+/**
+ * @param {string} dir  el directorio del perfil
+ */
+export function nodePlatform (dir) {
+  const disk = nodeDisk(dir)
+  // El transporte del ecosistema guarda su par en `localStorage`, y en Node no lo hay.
+  installNodeGlobals(dir)
+  return {
+    disk,
+    product: 'vaultd',
+    version: VERSION,
+    hostname: () => os.hostname(),
+    readProcContext,
+    openLocalDesk,
+    noticeGroupMs: Number(process.env.DOTRINO_VAULT_NOTICE_MS) || 3000,
+    async openIdentity ({ openKey = null, log = console.log } = {}) {
+      // CIFRADO EN REPOSO ligado a esta máquina: ningún archivo del dir queda en claro, así
+      // que copiarlos a otro equipo no sirve de nada. La identidad se migra AQUÍ (verificando
+      // antes de reemplazar); el resto lo hace su propio almacén al abrirse.
+      try {
+        const r = migrateFile(path.join(dir, 'identity.json'), kekFor(dir))
+        if (r === 'migrado') log('[vault] identity encrypted at rest (bound to this machine)')
+      } catch (e) { log('[vault] could not encrypt the identity at rest:', e.message) }
+      /**
+       * EL CANDADO DE LA MAESTRA. La mitad privada se guarda sellada con la llave que sale de
+       * la contraseña del perfil (`openKey`), no con la de la máquina: cerrada, la maestra no
+       * está en memoria y no hay con qué sacarla del disco. Un perfil sin contraseña no tiene
+       * `openKey`: se queda bajo la llave de máquina, y la consola lo dice en voz alta.
+       */
+      const keyLock = {
+        seal: async (texto) => { const k = openKey?.(); return k ? encryptText(texto, k) : null },
+        open: async (blob) => { const k = openKey?.(); if (!k) return null; try { return decryptText(blob, k) } catch (_) { return null } }
+      }
+      const identity = await Identity.connect({ dir, atRest: atRestFor(dir), keyLock })
+      // ESTE DIRECTORIO ES DE ESTA LLAVE: varias bóvedas en un disco, cada una con el suyo.
+      assertKeyOwnsDir(dir, identity.me?.publickey || null)
+      return identity
+    }
+  }
+}
+
+export default { nodePlatform }

package/src/tui/app.js

@@ -41,6 +41,7 @@ import * as hw from '../hwkeys.js'
 import { VERSION } from '../version.js'
 import * as up from '../update.js'
 import { DEVICE_CAPS } from '@dotrino/identity/acta'
+import { machineLine } from '@dotrino/identity/machine'
 
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms))
 
@@ -158,6 +159,9 @@ function mergeMembersAndCerts (members, issued) {
       // QUÉ CORRE ESE APARATO (CONVENCIONES §14). Lo apunta la bóveda cuando le habla, así
       // que aquí solo hay que dejarlo pasar — que es justo lo que le faltaba a `addedAt`.
       running: m.running || null,
+      // DÓNDE CORRE (`@dotrino/identity/machine`): lo último que dijo firmado o, si no, lo
+      // que dijo al emparejarse. Es lo que distingue tres navegadores que se llaman igual.
+      machine: m.machine || cert?.machine || null,
       // SI LE LLEGAN LOS AVISOS, solo en quien aprueba (`undefined` = no aprueba, no se pinta).
       notifiedAt: (m.caps || []).includes('approve') && 'notifiedAt' in m ? m.notifiedAt : undefined
     }
@@ -473,6 +477,9 @@ function deviceRows (st, t) {
   }
   for (const d of devices) {
     const label = d.label || t.muted(i.noLabel)
+    // Dónde corre (`node · Linux 7.0 · mi-pc`), pegado al nombre: es con lo que se reconoce.
+    const maquina = machineLine(d.machine)
+    const donde = maquina ? t.muted(`  ${maquina}`) : ''
     const vars = devVarsOf(st, d.sub).length
     const debt = debtOf(st, d.sub)
     const desde = d.addedAt ? t.muted(`  ${i.deviceSince}:${fmtExp(d.addedAt)}`) : ''
@@ -511,7 +518,7 @@ function deviceRows (st, t) {
         ? t.muted(i.thisVault)
         : t.muted('scope:' + shortScope(d.scope)) + '  ' + t.muted('exp:' + fmtExp(d.exp)))
     const marca = conCambios.has(d.sub) ? t.bold('*') : ' '
-    rows.push({ text: `${marca}${t.bold(d.deviceId)}  ${label}${desde}  ${status}${extra}`, sel: true, meta: d })
+    rows.push({ text: `${marca}${t.bold(d.deviceId)}  ${label}${donde}${desde}  ${status}${extra}`, sel: true, meta: d })
   }
   const revoked = st.devices?.revoked || []
   if (revoked.length) {
@@ -2504,7 +2511,11 @@ function pairingBody (st, t, cols, height) {
   lines.push('')
   lines.push(t.danger(i.pairWarning))
   lines.push('')
-  if (st.pending) lines.push(t.warn(i.pairConnected(st.pending.deviceId)))
+  if (st.pending) {
+    lines.push(t.warn(i.pairConnected(st.pending.deviceId)))
+    // Dónde dice que corre, para comprobar que es el aparato que tienes delante.
+    if (machineLine(st.pending.machine)) lines.push(t.muted('  ' + machineLine(st.pending.machine)))
+  }
   else lines.push(t.muted(i.pairWaiting))
   return lines
 }