specbox 6.17.0 → 6.18.0

package/README.md

@@ -1,6 +1,6 @@
 # specbox
 
-Connect this computer to [SpecBox](https://specbox.embed.build) without copying tokens.
+Connect this computer to [SpecBox](https://specbox.build/en/) without copying tokens.
 
 ```bash
 npx specbox login

package/lib/claude.mjs

@@ -10,10 +10,10 @@
  * `~/.claude.json` a mano: Claude Code lo reescribe mientras está abierto. Si
  * `claude` no está en el PATH, se devuelve la orden para ejecutarla a mano.
  */
-import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join, posix, win32 } from "node:path";
-import { SERVER_NAME } from "./config.mjs";
+import { SERVER_NAME, isLegacyMcpUrl, migrateMcpUrl, serverOrigins, specboxHome } from "./config.mjs";
 import { runCommand } from "./store.mjs";
 
 export function quoteArg(value) {
@@ -74,10 +74,13 @@ function origin(url) {
   }
 }
 
-/** Entradas de `~/.claude.json` (usuario y locales) que apuntan al servidor de SpecBox. */
+/**
+ * Entradas de `~/.claude.json` (usuario y locales) que apuntan al servidor de SpecBox, por
+ * cualquiera de sus nombres (UC-5102: también el anterior, para mudarlas al de ahora).
+ */
 export function findSpecboxEntries(claudeJson, mcpUrl) {
-  const target = origin(mcpUrl);
-  const matches = (entry) => entry && typeof entry.url === "string" && origin(entry.url) === target;
+  const targets = new Set(serverOrigins(mcpUrl));
+  const matches = (entry) => entry && typeof entry.url === "string" && targets.has(origin(entry.url));
   const found = [];
   for (const [name, entry] of Object.entries(claudeJson?.mcpServers ?? {})) {
     if (matches(entry)) found.push({ scope: "user", name, entry, cwd: null });
@@ -90,19 +93,51 @@ export function findSpecboxEntries(claudeJson, mcpUrl) {
   return found;
 }
 
-/** La entrada con el ayudante, sin ninguna cabecera Authorization fija que lo contradiga. */
+/**
+ * La entrada con el ayudante, sin ninguna cabecera Authorization fija que lo contradiga, y
+ * con el nombre de ahora del servidor si apuntaba a uno anterior (UC-5102).
+ */
 export function withHelper(entry, helperCmd) {
   const { headers, headersHelper: _old, ...rest } = entry ?? {};
   void _old;
   const kept = Object.fromEntries(Object.entries(headers ?? {}).filter(([k]) => k.toLowerCase() !== "authorization"));
   return {
     ...rest,
+    ...(typeof rest.url === "string" ? { url: migrateMcpUrl(rest.url) } : {}),
     type: rest.type ?? "http",
     ...(Object.keys(kept).length ? { headers: kept } : {}),
     headersHelper: helperCmd,
   };
 }
 
+/** Una entrada para la copia de seguridad: igual, pero sin el valor de ninguna cabecera Authorization. */
+export function redactEntry(entry) {
+  const headers = entry?.headers;
+  if (!headers) return entry;
+  return {
+    ...entry,
+    headers: Object.fromEntries(Object.entries(headers).map(([k, v]) => [k, k.toLowerCase() === "authorization" ? "***" : v])),
+  };
+}
+
+/**
+ * UC-5102 AC-02: guarda lo que se va a cambiar (las entradas tal como estaban) en
+ * ~/.specbox/backups/claude-mcp-<fecha>.json. Devuelve la ruta, o null si no pudo.
+ */
+export function saveEntriesBackup(entries, { dir = join(specboxHome(), "backups"), now = new Date() } = {}) {
+  if (!entries.length) return null;
+  try {
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const stamp = now.toISOString().replace(/[-:]/g, "").replace(/\.\d+Z$/, "Z");
+    const file = join(dir, `claude-mcp-${stamp}.json`);
+    const body = { saved_at: now.toISOString(), reason: "specbox: entradas de SpecBox-MCP antes de reconfigurarlas", entries };
+    writeFileSync(file, `${JSON.stringify(body, null, 2)}\n`, { mode: 0o600 });
+    return file;
+  } catch {
+    return null;
+  }
+}
+
 export function configureClaudeCode({
   mcpUrl,
   helperCmd,
@@ -110,12 +145,32 @@ export function configureClaudeCode({
   claudeJsonPath = join(homedir(), ".claude.json"),
   readFile = readFileSync,
   projectExists = existsSync,
+  backup = saveEntriesBackup,
 }) {
   const userEntry = JSON.stringify({ type: "http", url: mcpUrl, headersHelper: helperCmd });
   const manual = `claude mcp add-json ${SERVER_NAME} '${userEntry}' --scope user`;
   const probe = run("claude", ["--version"]);
   if (probe.error || probe.status === null) return { ok: false, reason: "claude_missing", manual };
 
+  // Se lee antes de tocar nada: así la copia de seguridad guarda las entradas como estaban.
+  let claudeJson = {};
+  try {
+    claudeJson = JSON.parse(readFile(claudeJsonPath, "utf8"));
+  } catch {
+    // sin ~/.claude.json no hay más entradas que migrar
+  }
+  const pending = findSpecboxEntries(claudeJson, mcpUrl).filter((found) => {
+    if (found.scope === "user" && found.name === SERVER_NAME) return false;
+    if (found.entry.headersHelper === helperCmd && !isLegacyMcpUrl(found.entry.url)) return false;
+    return !(found.cwd && !projectExists(found.cwd)); // proyecto que ya no existe
+  });
+  const previousUser = claudeJson?.mcpServers?.[SERVER_NAME];
+  const userChanges = previousUser && JSON.stringify(previousUser) !== userEntry;
+  const backupFile = backup([
+    ...(userChanges ? [{ scope: "user", name: SERVER_NAME, cwd: null, entry: redactEntry(previousUser) }] : []),
+    ...pending.map((f) => ({ scope: f.scope, name: f.name, cwd: f.cwd, entry: redactEntry(f.entry) })),
+  ]);
+
   run("claude", ["mcp", "remove", SERVER_NAME, "--scope", "user"]); // puede no existir
   const added = run("claude", ["mcp", "add-json", SERVER_NAME, userEntry, "--scope", "user"]);
   if (added.status !== 0) {
@@ -124,16 +179,7 @@ export function configureClaudeCode({
 
   const updated = [{ scope: "user", name: SERVER_NAME, cwd: null }];
   const failed = [];
-  let claudeJson = {};
-  try {
-    claudeJson = JSON.parse(readFile(claudeJsonPath, "utf8"));
-  } catch {
-    // sin ~/.claude.json no hay más entradas que migrar
-  }
-  for (const found of findSpecboxEntries(claudeJson, mcpUrl)) {
-    if (found.scope === "user" && found.name === SERVER_NAME) continue;
-    if (found.entry.headersHelper === helperCmd) continue;
-    if (found.cwd && !projectExists(found.cwd)) continue; // proyecto que ya no existe
+  for (const found of pending) {
     const opts = found.cwd ? { cwd: found.cwd } : {};
     run("claude", ["mcp", "remove", found.name, "--scope", found.scope], opts);
     const res = run(
@@ -143,14 +189,16 @@ export function configureClaudeCode({
     );
     (res.status === 0 ? updated : failed).push({ scope: found.scope, name: found.name, cwd: found.cwd });
   }
-  return { ok: true, updated, failed };
+  return { ok: true, updated, failed, ...(backupFile ? { backup: backupFile } : {}) };
 }
 
 /**
  * ¿La entrada de usuario usa nuestro ayudante y este puede ejecutarse? (para
  * `specbox status` y la extensión). Si el Node grabado ya no existe (p. ej.
  * una versión que borró el gestor de paquetes), es `false`: la extensión
- * vuelve a configurar Claude Code en el siguiente arranque.
+ * vuelve a configurar Claude Code en el siguiente arranque. También si la
+ * entrada apunta a un nombre anterior del servidor (UC-5102): así la extensión
+ * actualizada muda las entradas al nombre de ahora sin pasos manuales.
  */
 export function claudeUsesHelper({
   claudeJsonPath = join(homedir(), ".claude.json"),
@@ -159,6 +207,7 @@ export function claudeUsesHelper({
 } = {}) {
   try {
     const entry = JSON.parse(readFile(claudeJsonPath, "utf8"))?.mcpServers?.[SERVER_NAME];
+    if (isLegacyMcpUrl(entry?.url)) return false;
     const paths = helperPaths(entry?.headersHelper);
     return Boolean(paths && paths.helper.endsWith("mcp-headers.mjs") && exists(paths.node) && exists(paths.helper));
   } catch {

package/lib/config.mjs

@@ -9,7 +9,15 @@
 import { homedir } from "node:os";
 import { join } from "node:path";
 
-export const DEFAULT_MCP_URL = "https://mcp-specbox-engine.jpsdeveloper.com/mcp";
+export const DEFAULT_MCP_URL = "https://mcp.specbox.build/mcp";
+
+/**
+ * UC-5102: nombres anteriores del mismo servidor. Comparten credencial con DEFAULT_MCP_URL
+ * (`accountFor` los traduce) y sus entradas en Claude Code se mudan a él. El nombre antiguo
+ * sigue respondiendo (UC-5101), así que una instalación sin actualizar no se rompe.
+ */
+export const LEGACY_MCP_URLS = ["https://mcp-specbox-engine.jpsdeveloper.com/mcp"];
+
 export const DEFAULT_CLOUD_API = "https://api-cloud.specbox.build/api";
 export const HOW_TO_CONNECT_URL = "https://cloud.specbox.build/como-se-conecta";
 
@@ -33,12 +41,52 @@ export function resolveConfig({ server, cloud } = {}, env = process.env) {
   };
 }
 
-/** Clave de la credencial en el almacén: la URL del servidor sin barra final. */
+/**
+ * Clave de la credencial en el almacén: la URL del servidor sin barra final. Un nombre
+ * anterior del servidor da la clave del nombre de ahora (UC-5102): una sola credencial.
+ */
 export function accountFor(mcpUrl) {
+  const key = urlKey(mcpUrl);
+  return LEGACY_MCP_URLS.some((legacy) => urlKey(legacy) === key) ? urlKey(DEFAULT_MCP_URL) : key;
+}
+
+/** Las claves con las que una versión anterior pudo guardar la credencial de `account`. */
+export function legacyAccountsFor(account) {
+  return account === urlKey(DEFAULT_MCP_URL) ? LEGACY_MCP_URLS.map(urlKey) : [];
+}
+
+/** ¿Apunta esta URL a un nombre anterior del servidor? (cualquier ruta de ese origen) */
+export function isLegacyMcpUrl(value) {
+  const from = originOf(value);
+  return Boolean(from) && LEGACY_MCP_URLS.some((legacy) => originOf(legacy) === from);
+}
+
+/** La misma URL con el nombre de ahora en lugar de uno anterior; cualquier otra, igual. */
+export function migrateMcpUrl(value) {
+  if (!isLegacyMcpUrl(value)) return value;
+  const url = new URL(value);
+  return `${new URL(DEFAULT_MCP_URL).origin}${url.pathname}${url.search}`;
+}
+
+/** Los orígenes que son este servidor: el suyo y, si es el de SpecBox, los anteriores. */
+export function serverOrigins(mcpUrl) {
+  const own = originOf(mcpUrl);
+  return own === originOf(DEFAULT_MCP_URL) ? [own, ...LEGACY_MCP_URLS.map(originOf)] : [own];
+}
+
+function urlKey(mcpUrl) {
   const url = new URL(mcpUrl);
   return stripSlash(`${url.origin}${url.pathname}`);
 }
 
+function originOf(value) {
+  try {
+    return new URL(value).origin;
+  } catch {
+    return null;
+  }
+}
+
 function stripSlash(value) {
   return String(value).replace(/\/+$/, "");
 }

package/lib/store.mjs

@@ -21,6 +21,7 @@ import { spawnSync } from "node:child_process";
 import { createHash } from "node:crypto";
 import { chmodSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { legacyAccountsFor } from "./config.mjs";
 
 export const SERVICE = "SpecBox MCP";
 const SECRET_TOOL_SERVICE = "specbox-mcp";
@@ -205,10 +206,51 @@ function withFallback(primary, fallback) {
   };
 }
 
-export function createStore({ platform = process.platform, run = runCommand, home } = {}) {
-  if (!home) throw new Error("createStore needs the specbox home");
+/**
+ * UC-5102: una versión anterior guardó la credencial con la URL antigua del servidor como
+ * clave. Al leer, si no está con la clave de ahora pero sí con una antigua, se copia a la de
+ * ahora y se usa: el ordenador sigue identificado tras la mudanza a mcp.specbox.build. La
+ * copia antigua se queda (una instalación sin actualizar la sigue leyendo). Al borrar
+ * (`specbox logout`) se borran todas.
+ */
+export function withLegacyAccounts(store) {
+  return {
+    get kind() {
+      return store.kind;
+    },
+    read(account) {
+      const value = store.read(account);
+      if (value) return value;
+      for (const legacy of legacyAccountsFor(account)) {
+        const old = store.read(legacy);
+        if (!old) continue;
+        try {
+          store.write(account, old);
+        } catch {
+          // se reintenta en la próxima lectura; la credencial sirve igual
+        }
+        return old;
+      }
+      return null;
+    },
+    write(account, credential) {
+      store.write(account, credential);
+    },
+    remove(account) {
+      store.remove(account);
+      for (const legacy of legacyAccountsFor(account)) store.remove(legacy);
+    },
+  };
+}
+
+function platformStore({ platform, run, home }) {
   if (platform === "darwin") return keychainStore(run);
   if (platform === "win32") return dpapiStore(run, home);
   if (platform === "linux") return withFallback(secretToolStore(run), fileStore(home));
   return fileStore(home);
 }
+
+export function createStore({ platform = process.platform, run = runCommand, home } = {}) {
+  if (!home) throw new Error("createStore needs the specbox home");
+  return withLegacyAccounts(platformStore({ platform, run, home }));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "specbox",
-  "version": "6.17.0",
+  "version": "6.18.0",
   "description": "Conecta este ordenador a SpecBox sin copiar tokens: specbox login, status y logout.",
   "type": "module",
   "bin": {