specbox 6.14.0

package/lib/internal.mjs

@@ -0,0 +1,176 @@
+/**
+ * Órdenes internas para la extensión de VSCode (UC-3901 AC-03, UC-3904).
+ *
+ * La extensión empaqueta este paquete y lo ejecuta con el Node del sistema
+ * para no reimplementar (y dejar divergir) el almacén seguro, el ayudante ni
+ * la configuración de Claude Code: la extensión y `specbox login` hacen
+ * exactamente lo mismo en un mismo ordenador. Hablan JSON (una línea por
+ * stdout; la entrada, si la hay, por stdin) y no aparecen en `--help`.
+ *
+ *   _device      id y nombre del dispositivo (los mismos que usa `specbox login`)
+ *   _status      ¿hay credencial? dispositivo, caducidad y si Claude Code usa el ayudante
+ *                (nunca el token: solo su huella)
+ *   _connect     guarda la credencial que trae la extensión, instala el ayudante y
+ *                configura Claude Code
+ *   _configure   instala el ayudante y configura Claude Code, sin credencial
+ *   _adopt       con el token que ya tenía la extensión, obtiene un token de
+ *                dispositivo (/devices/adopt, que NO revoca el anterior: puede estar
+ *                pegado en otros sitios) y lo conecta como `_connect`
+ *   _renew       renueva si toca y devuelve el token vigente (para la extensión)
+ *   _disconnect  /devices/logout y borra la credencial local
+ */
+import { createHash } from "node:crypto";
+import { claudeUsesHelper, configureClaudeCode, helperCommand, stableNodePath } from "./claude.mjs";
+import { CLIENT } from "./config.mjs";
+import { deviceId, hostLabel } from "./device.mjs";
+import { installHelper } from "./install.mjs";
+import { credentialFromResponse, renewCredential, renewDue } from "./renew.mjs";
+
+export async function readStdinJson(stream = process.stdin) {
+  let raw = "";
+  for await (const chunk of stream) raw += chunk;
+  return raw.trim() ? JSON.parse(raw) : {};
+}
+
+function tokenSha(token) {
+  return createHash("sha256").update(String(token)).digest("hex").slice(0, 16);
+}
+
+/** Lo que la extensión puede ver de una credencial: todo menos el token. */
+export function credentialMeta(credential) {
+  return {
+    token_sha: tokenSha(credential.token),
+    token_id: credential.token_id ?? null,
+    device_id: credential.device_id ?? null,
+    device_name: credential.device_name ?? null,
+    client: credential.client ?? null,
+    expires_at: credential.expires_at ?? null,
+    renew_after: credential.renew_after ?? null,
+    developer: credential.developer ?? null,
+  };
+}
+
+function safeRead(store, account) {
+  try {
+    return store.read(account);
+  } catch {
+    return null;
+  }
+}
+
+export async function runInternal(command, ctx) {
+  const { config, store, account, home, fetchImpl, readInput, out, deps = {} } = ctx;
+  const device = () => ({
+    device_id: deps.deviceId ?? deviceId(CLIENT, { home }),
+    host: deps.host ?? hostLabel(),
+    client: CLIENT,
+  });
+  const connectClaude = () =>
+    configureClaudeCode({
+      mcpUrl: config.mcpUrl,
+      helperCmd: helperCommand((deps.installHelper ?? installHelper)(home), deps.nodePath ?? stableNodePath()),
+      run: deps.runCommand,
+      claudeJsonPath: deps.claudeJsonPath,
+    });
+  const usesHelper = () => claudeUsesHelper(deps.claudeJsonPath ? { claudeJsonPath: deps.claudeJsonPath } : {});
+
+  switch (command) {
+    case "_device":
+      out(device());
+      return 0;
+
+    case "_status": {
+      const credential = safeRead(store, account);
+      out({
+        connected: Boolean(credential?.token),
+        store: store.kind,
+        ...(credential?.token ? credentialMeta(credential) : {}),
+        claude_helper: usesHelper(),
+      });
+      return 0;
+    }
+
+    case "_connect": {
+      const { credential } = await readInput();
+      if (!credential?.token) {
+        out({ ok: false, reason: "missing_credential" });
+        return 1;
+      }
+      const stored = { ...credential, cloud_api: credential.cloud_api ?? config.cloudApi, updated_at: new Date().toISOString() };
+      store.write(account, stored);
+      out({ ok: true, store: store.kind, ...credentialMeta(stored), claude: connectClaude() });
+      return 0;
+    }
+
+    case "_configure":
+      out({ ok: true, claude: connectClaude() });
+      return 0;
+
+    case "_adopt": {
+      const { token, issued_via: issuedVia = "vscode" } = await readInput();
+      if (!token) {
+        out({ ok: false, reason: "missing_token" });
+        return 1;
+      }
+      let res;
+      try {
+        res = await fetchImpl(`${config.cloudApi}/devices/adopt`, {
+          method: "POST",
+          headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },
+          body: JSON.stringify({ ...device(), issued_via: issuedVia }),
+        });
+      } catch {
+        out({ ok: false, reason: "network" });
+        return 1;
+      }
+      if (res.status !== 200) {
+        const reason = res.status === 401 ? "invalid_token" : res.status === 409 ? "conflict" : `http_${res.status}`;
+        out({ ok: false, reason });
+        return 1;
+      }
+      const credential = credentialFromResponse(await res.json(), config.cloudApi);
+      store.write(account, credential);
+      out({ ok: true, token: credential.token, store: store.kind, ...credentialMeta(credential), claude: connectClaude() });
+      return 0;
+    }
+
+    case "_renew": {
+      let credential = safeRead(store, account);
+      if (!credential?.token) {
+        out({ connected: false });
+        return 0;
+      }
+      let renewed = false;
+      if (renewDue(credential)) {
+        const next = await renewCredential({ store, account, credential, fetchImpl, lockDir: home });
+        renewed = next.token !== credential.token;
+        credential = next;
+      }
+      out({ connected: true, renewed, token: credential.token, ...credentialMeta(credential) });
+      return 0;
+    }
+
+    case "_disconnect": {
+      const credential = safeRead(store, account);
+      let remote = false;
+      if (credential?.token) {
+        try {
+          const res = await fetchImpl(`${credential.cloud_api ?? config.cloudApi}/devices/logout`, {
+            method: "POST",
+            headers: { authorization: `Bearer ${credential.token}` },
+          });
+          remote = res.status === 200 || res.status === 401;
+        } catch {
+          remote = false;
+        }
+      }
+      store.remove(account);
+      out({ ok: true, remote, had_credential: Boolean(credential?.token) });
+      return 0;
+    }
+
+    default:
+      out({ ok: false, reason: "unknown_command" });
+      return 1;
+  }
+}

package/lib/login.mjs

@@ -0,0 +1,87 @@
+/**
+ * `specbox login` — conectar este ordenador con un código de un solo uso
+ * (UC-3904 AC-02), gestionado por el panel de SpecBox:
+ *
+ *   1. POST {cloud}/device/code con el dispositivo → código y enlace.
+ *   2. La persona abre el enlace, entra con GitHub y confirma el código.
+ *   3. Mientras, se pregunta a POST {cloud}/device/token cada `interval`
+ *      segundos (más 5 con cada `slow_down`) hasta recibir el token, que va
+ *      directo al almacén seguro: nadie lo ve ni lo copia.
+ */
+import { credentialFromResponse } from "./renew.mjs";
+
+export class LoginError extends Error {
+  constructor(code, detail) {
+    super(detail ? `${code}: ${detail}` : code);
+    this.code = code;
+  }
+}
+
+async function postJson(fetchImpl, url, body) {
+  const res = await fetchImpl(url, {
+    method: "POST",
+    headers: { "content-type": "application/json", accept: "application/json" },
+    body: JSON.stringify(body),
+  });
+  let json = {};
+  try {
+    json = await res.json();
+  } catch {
+    // cuerpo vacío o no JSON
+  }
+  return { status: res.status, json };
+}
+
+/**
+ * Pide el código, avisa (`onCode`) y espera la confirmación. Devuelve la
+ * credencial ya guardada en `store` bajo `account`.
+ */
+export async function deviceLogin({
+  cloudApi,
+  account,
+  store,
+  device,
+  onCode,
+  fetchImpl = fetch,
+  sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+  now = Date.now,
+}) {
+  let code;
+  try {
+    code = await postJson(fetchImpl, `${cloudApi}/device/code`, device);
+  } catch (err) {
+    throw new LoginError("network", err?.message);
+  }
+  if (code.status !== 200 || !code.json.device_code) {
+    throw new LoginError(code.status === 429 ? "rate_limited" : "code_failed", code.json.error_description ?? code.json.message);
+  }
+  const { device_code: deviceCode, expires_in: expiresIn = 600 } = code.json;
+  let interval = Math.max(1, Number(code.json.interval) || 5);
+  await onCode?.(code.json);
+
+  const deadline = now() + expiresIn * 1000;
+  while (now() < deadline) {
+    await sleep(interval * 1000);
+    let res;
+    try {
+      res = await postJson(fetchImpl, `${cloudApi}/device/token`, { device_code: deviceCode });
+    } catch {
+      continue; // un corte de red momentáneo: se vuelve a preguntar
+    }
+    if (res.status === 200 && res.json.access_token) {
+      const credential = credentialFromResponse(res.json, cloudApi);
+      store.write(account, credential);
+      return credential;
+    }
+    const error = res.json.error;
+    if (error === "authorization_pending") continue;
+    if (error === "slow_down" || res.status === 429) {
+      interval += 5;
+      continue;
+    }
+    if (error === "access_denied") throw new LoginError("denied");
+    if (error === "expired_token" || error === "invalid_grant") throw new LoginError("expired");
+    throw new LoginError("unexpected", `HTTP ${res.status} ${error ?? ""}`.trim());
+  }
+  throw new LoginError("expired");
+}

package/lib/mcp-headers.mjs

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+/**
+ * Ayudante de cabeceras para Claude Code (UC-3901 AC-03, UC-3904 AC-03).
+ *
+ * Claude Code lo ejecuta (`headersHelper`) al conectar con el servidor MCP, al
+ * reconectar y tras un 401/403, y usa como cabeceras el JSON que imprime. Lee
+ * la credencial del almacén seguro para la URL del servidor que recibe en
+ * `CLAUDE_CODE_MCP_SERVER_URL`, la renueva si le quedan menos de 14 días e
+ * imprime `{"Authorization": "Bearer …"}`.
+ *
+ * Sin credencial imprime `{}`: la conexión sale sin token y el servidor decide
+ * (en el periodo de gracia avisa; después la rechaza con el mensaje de cómo
+ * conectarse). Nunca imprime otra cosa por stdout ni falla: un error de
+ * Claude Code aquí dejaría a la persona sin MCP.
+ *
+ * Se instala en ~/.specbox/bin junto a los módulos que importa.
+ */
+import { realpathSync } from "node:fs";
+import { pathToFileURL } from "node:url";
+import { DEFAULT_MCP_URL, accountFor, specboxHome } from "./config.mjs";
+import { renewCredential, renewDue } from "./renew.mjs";
+import { createStore } from "./store.mjs";
+
+export async function headersFor({
+  env = process.env,
+  store = createStore({ home: specboxHome(env) }),
+  fetchImpl = fetch,
+  now = Date.now(),
+} = {}) {
+  const url = env.CLAUDE_CODE_MCP_SERVER_URL || env.SPECBOX_MCP_URL || DEFAULT_MCP_URL;
+  const account = accountFor(url);
+  let credential = store.read(account);
+  if (!credential?.token) return {};
+  if (renewDue(credential, now)) {
+    credential = await renewCredential({ store, account, credential, fetchImpl, lockDir: specboxHome(env) });
+  }
+  return { Authorization: `Bearer ${credential.token}` };
+}
+
+// Por `npx`/npm el script se ejecuta a través de un enlace simbólico: se
+// compara con la ruta real.
+const invokedDirectly = (() => {
+  try {
+    return Boolean(process.argv[1]) && import.meta.url === pathToFileURL(realpathSync(process.argv[1])).href;
+  } catch {
+    return false;
+  }
+})();
+if (invokedDirectly) {
+  headersFor()
+    .then((headers) => process.stdout.write(JSON.stringify(headers)))
+    .catch(() => process.stdout.write("{}"));
+}

package/lib/messages.mjs

@@ -0,0 +1,124 @@
+/**
+ * Textos de `specbox` en español e inglés, según el idioma del sistema
+ * (LC_ALL, LC_MESSAGES o LANG empezando por "es" → español).
+ */
+export function pickLang(env = process.env) {
+  const raw = env.LC_ALL || env.LC_MESSAGES || env.LANG || "";
+  return raw.toLowerCase().startsWith("es") ? "es" : "en";
+}
+
+const STORE_LABEL = {
+  es: { keychain: "Llavero de macOS", "secret-service": "Secret Service", dpapi: "DPAPI de Windows", file: "fichero protegido (~/.specbox, 0600)" },
+  en: { keychain: "macOS Keychain", "secret-service": "Secret Service", dpapi: "Windows DPAPI", file: "protected file (~/.specbox, 0600)" },
+};
+
+function day(iso, lang) {
+  if (!iso) return "—";
+  return new Date(iso).toLocaleDateString(lang === "es" ? "es-ES" : "en-GB", { day: "numeric", month: "long", year: "numeric" });
+}
+
+export function messages(lang) {
+  const es = lang === "es";
+  return {
+    usage: es
+      ? [
+          "Uso: specbox <orden> [opciones]",
+          "",
+          "Órdenes:",
+          "  login    conecta este ordenador a SpecBox con tu cuenta de GitHub",
+          "  status   enseña con qué cuenta y dispositivo estás conectado",
+          "  logout   desconecta este ordenador",
+          "",
+          "Opciones:",
+          "  --server <url>   servidor MCP (por defecto el de SpecBox)",
+          "  --cloud <url>    API del panel",
+          "  --no-browser     no abrir el navegador",
+          "  --version, --help",
+        ].join("\n")
+      : [
+          "Usage: specbox <command> [options]",
+          "",
+          "Commands:",
+          "  login    connect this computer to SpecBox with your GitHub account",
+          "  status   show which account and device you are connected with",
+          "  logout   disconnect this computer",
+          "",
+          "Options:",
+          "  --server <url>   MCP server (SpecBox's by default)",
+          "  --cloud <url>    panel API",
+          "  --no-browser     do not open the browser",
+          "  --version, --help",
+        ].join("\n"),
+    loginTitle: es ? "SpecBox · conectar este ordenador" : "SpecBox · connect this computer",
+    openUrl: (url) => (es ? `  1. Abre esta dirección (se abre sola si puede):\n     ${url}` : `  1. Open this address (it opens by itself if it can):\n     ${url}`),
+    confirmCode: (code) =>
+      es
+        ? `  2. Comprueba que el código es este y confírmalo con tu cuenta de GitHub:\n     ${code}`
+        : `  2. Check that the code is this one and confirm it with your GitHub account:\n     ${code}`,
+    waiting: (minutes) => (es ? `\nEsperando la confirmación… (el código caduca en ${minutes} min)` : `\nWaiting for the confirmation… (the code expires in ${minutes} min)`),
+    connected: (cred, storeKind) => {
+      const who = cred.developer?.handle ? `@${cred.developer.handle}` : cred.developer?.display_name ?? "?";
+      return es
+        ? `\n✓ Conectado como ${who} en «${cred.device_name}».\n  El token está en el ${STORE_LABEL.es[storeKind] ?? storeKind}; caduca el ${day(cred.expires_at, "es")} y se renueva solo.`
+        : `\n✓ Connected as ${who} on “${cred.device_name}”.\n  The token is in the ${STORE_LABEL.en[storeKind] ?? storeKind}; it expires on ${day(cred.expires_at, "en")} and renews itself.`;
+    },
+    fileStoreWarning: es
+      ? "  ⚠ No hay almacén seguro del sistema disponible: el token queda en ~/.specbox/credentials.json con permisos 0600."
+      : "  ⚠ No system secure store is available: the token is kept in ~/.specbox/credentials.json with 0600 permissions.",
+    claudeConfigured: (updated) =>
+      es
+        ? `✓ Claude Code configurado: ${updated.map((u) => (u.cwd ? `${u.name} (${u.cwd})` : u.name)).join(", ")} envía el token en cada conexión.\n  Reinicia Claude Code (o /mcp → reconectar) para usarlo ya.`
+        : `✓ Claude Code configured: ${updated.map((u) => (u.cwd ? `${u.name} (${u.cwd})` : u.name)).join(", ")} sends the token on every connection.\n  Restart Claude Code (or /mcp → reconnect) to use it now.`,
+    claudeFailed: (failed) =>
+      es
+        ? `  ⚠ No se pudo actualizar: ${failed.map((f) => `${f.name} (${f.cwd ?? "usuario"})`).join(", ")}.`
+        : `  ⚠ Could not update: ${failed.map((f) => `${f.name} (${f.cwd ?? "user"})`).join(", ")}.`,
+    claudeManual: (cmd) =>
+      es
+        ? `  ⚠ No encuentro la orden \`claude\`. Configura Claude Code con:\n     ${cmd}`
+        : `  ⚠ The \`claude\` command was not found. Configure Claude Code with:\n     ${cmd}`,
+    howItWorks: (url) => (es ? `\nCómo funciona: ${url}` : `\nHow it works: ${url}`),
+    loginError: (code) =>
+      ({
+        denied: es ? "✗ Cancelado en el navegador: el ordenador no se ha conectado." : "✗ Cancelled in the browser: this computer was not connected.",
+        expired: es ? "✗ El código caducó antes de confirmarse. Ejecuta specbox login otra vez." : "✗ The code expired before it was confirmed. Run specbox login again.",
+        rate_limited: es ? "✗ Demasiados intentos seguidos. Espera unos minutos." : "✗ Too many attempts in a row. Wait a few minutes.",
+        network: es ? "✗ No hay conexión con el panel de SpecBox." : "✗ Cannot reach the SpecBox panel.",
+      })[code] ?? (es ? `✗ No se pudo conectar (${code}).` : `✗ Could not connect (${code}).`),
+    notConnected: es ? "Este ordenador no está conectado. Ejecuta: specbox login" : "This computer is not connected. Run: specbox login",
+    statusTitle: es ? "SpecBox · este ordenador" : "SpecBox · this computer",
+    statusLines: (cred, storeKind, server, valid, helper) => {
+      const who = cred.developer?.handle ? `@${cred.developer.handle} (${cred.developer.display_name})` : cred.developer?.display_name ?? "?";
+      const state =
+        valid === null
+          ? es ? "sin comprobar (no hay conexión con el panel)" : "not checked (cannot reach the panel)"
+          : valid
+            ? es ? "válido ✓" : "valid ✓"
+            : es ? "caducado o revocado ✗ → ejecuta specbox login" : "expired or revoked ✗ → run specbox login";
+      return (es
+        ? [
+            `  Cuenta:       ${who}`,
+            `  Dispositivo:  ${cred.device_name}`,
+            `  Caduca:       ${day(cred.expires_at, "es")} (se renueva sola desde el ${day(cred.renew_after, "es")})`,
+            `  Almacén:      ${STORE_LABEL.es[storeKind] ?? storeKind}`,
+            `  Servidor:     ${server}`,
+            `  Token:        ${state}`,
+            `  Claude Code:  ${helper ? "usa el ayudante ✓" : "sin configurar ✗ → ejecuta specbox login"}`,
+          ]
+        : [
+            `  Account:      ${who}`,
+            `  Device:       ${cred.device_name}`,
+            `  Expires:      ${day(cred.expires_at, "en")} (renews itself from ${day(cred.renew_after, "en")})`,
+            `  Store:        ${STORE_LABEL.en[storeKind] ?? storeKind}`,
+            `  Server:       ${server}`,
+            `  Token:        ${state}`,
+            `  Claude Code:  ${helper ? "uses the helper ✓" : "not configured ✗ → run specbox login"}`,
+          ]
+      ).join("\n");
+    },
+    loggedOut: (name, remote) =>
+      es
+        ? `✓ Dispositivo desconectado: «${name}».${remote ? "" : "\n  ⚠ No se pudo avisar al panel: desconéctalo también en Perfil → Dispositivos conectados."}\n  Claude Code seguirá configurado y se conectará sin cuenta hasta que vuelvas a ejecutar specbox login.`
+        : `✓ Device disconnected: “${name}”.${remote ? "" : "\n  ⚠ The panel could not be told: disconnect it also in Profile → Connected devices."}\n  Claude Code stays configured and connects without an account until you run specbox login again.`,
+  };
+}

package/lib/renew.mjs

@@ -0,0 +1,130 @@
+/**
+ * Renovación automática del token (UC-3904 AC-03).
+ *
+ * A partir de 14 días antes de caducar, el cliente pide un token nuevo con el
+ * vigente (POST /api/devices/renew), guarda el nuevo y el viejo deja de valer.
+ * La persona no hace nada. Varias sesiones de Claude Code pueden intentarlo a
+ * la vez: un cerrojo en ~/.specbox las pone en fila, y quien llega tarde usa
+ * la credencial que ya renovó otra (también si el servidor responde 409).
+ * Si la red falla, se sigue con el token vigente: todavía le quedan días.
+ */
+import { closeSync, mkdirSync, openSync, statSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { RENEW_WINDOW_DAYS } from "./config.mjs";
+
+const DAY = 86_400_000;
+const STALE_LOCK_MS = 60_000;
+
+export function renewDue(credential, now = Date.now()) {
+  if (!credential?.expires_at) return false;
+  const from = credential.renew_after
+    ? Date.parse(credential.renew_after)
+    : Date.parse(credential.expires_at) - RENEW_WINDOW_DAYS * DAY;
+  return now >= from;
+}
+
+/** La credencial que guarda el cliente, a partir de la respuesta del servidor. */
+export function credentialFromResponse(body, cloudApi) {
+  return {
+    token: body.access_token,
+    token_id: body.token_id,
+    expires_at: body.expires_at,
+    renew_after: body.renew_after ?? null,
+    device_id: body.device?.device_id ?? null,
+    device_name: body.device?.device_name ?? null,
+    client: body.device?.client ?? null,
+    developer: body.developer ?? null,
+    cloud_api: cloudApi,
+    updated_at: new Date().toISOString(),
+  };
+}
+
+export function acquireLock(dir, now = Date.now) {
+  const file = join(dir, "renew.lock");
+  mkdirSync(dir, { recursive: true, mode: 0o700 });
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    try {
+      closeSync(openSync(file, "wx"));
+      return () => {
+        try {
+          unlinkSync(file);
+        } catch {
+          // ya no estaba
+        }
+      };
+    } catch (err) {
+      if (err?.code !== "EEXIST") return () => {};
+      try {
+        if (now() - statSync(file).mtimeMs > STALE_LOCK_MS) {
+          unlinkSync(file); // cerrojo abandonado por un proceso que murió
+          continue;
+        }
+      } catch {
+        continue;
+      }
+      return null;
+    }
+  }
+  return null;
+}
+
+async function fetchWithTimeout(fetchImpl, url, init, timeoutMs) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await fetchImpl(url, { ...init, signal: controller.signal });
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+/**
+ * Renueva `credential` si nadie lo está haciendo ya. Nunca lanza: devuelve la
+ * credencial con la que seguir (la nueva, la que renovó otro proceso o la
+ * misma si no se pudo).
+ */
+export async function renewCredential({
+  store,
+  account,
+  credential,
+  lockDir,
+  fetchImpl = fetch,
+  timeoutMs = 5_000,
+  body = {},
+}) {
+  const release = acquireLock(lockDir);
+  if (!release) return safeRead(store, account) ?? credential;
+  try {
+    const stored = safeRead(store, account);
+    if (stored?.token && stored.token !== credential.token) return stored; // otro proceso ya renovó
+    const res = await fetchWithTimeout(
+      fetchImpl,
+      `${credential.cloud_api}/devices/renew`,
+      {
+        method: "POST",
+        headers: { authorization: `Bearer ${credential.token}`, "content-type": "application/json" },
+        body: JSON.stringify(body),
+      },
+      timeoutMs,
+    );
+    if (res.status === 200) {
+      const next = credentialFromResponse(await res.json(), credential.cloud_api);
+      store.write(account, next);
+      return next;
+    }
+    if (res.status === 409) return safeRead(store, account) ?? credential;
+    return credential;
+  } catch {
+    return credential;
+  } finally {
+    release();
+  }
+}
+
+function safeRead(store, account) {
+  try {
+    return store.read(account);
+  } catch {
+    return null;
+  }
+}