estela 0.2.1 → 0.2.3

package/dist/publish.js

@@ -35,6 +35,11 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NoAccountError = void 0;
 exports.publishPanel = publishPanel;
+exports.preparePanel = preparePanel;
+exports.uploadPanel = uploadPanel;
+exports.unpublishPanel = unpublishPanel;
+exports.unpublishAll = unpublishAll;
+exports.listPublishedPanels = listPublishedPanels;
 const shared_1 = require("@estela/shared");
 const invoice_js_1 = require("./billing/invoice.js");
 const client_js_1 = require("./cloud/client.js");
@@ -82,9 +87,21 @@ function commitsOfProject(db, repoPaths) {
     }));
 }
 async function publishPanel(db, options) {
+    return uploadPanel(db, await preparePanel(db, options));
+}
+/**
+ * Construye el panel sin subirlo: el HTML y el resumen de lo que va a quedar
+ * público. `estela publish` enseña el resumen y pide confirmación antes de
+ * `uploadPanel`.
+ */
+async function preparePanel(db, options) {
     const project = store.getProject(db, options.projectId);
     if (!project)
         throw new Error((0, index_js_1.tr) `No existe el proyecto "${options.projectId}".`);
+    // Alojarlo exige sesión: es la cuenta la que decide cuántos paneles caben
+    // en tu plan, y sin ella no hay a quién cargarle esa cuota. Se mira antes de
+    // construir nada, para no enseñar un resumen de algo que no se va a subir.
+    requireAccount(db);
     const client = store.getClient(db, project.clientId);
     const rates = store.getRates(db, options.projectId);
     // Reutilizar el token si se republica: el cliente ya tiene ese enlace
@@ -93,10 +110,7 @@ async function publishPanel(db, options) {
     const projectCommits = commitsOfProject(db, project.repoPaths);
     const merged = project.repoPaths[0] ? await (0, git_js_1.mergedBranches)(project.repoPaths[0]) : null;
     const team = await buildTeam(db, project, projectCommits);
-    // El panel es un fichero estático: el idioma queda fijado en el momento de
-    // publicar, y republicar es lo que lo cambia.
-    const lang = (0, index_js_1.documentLang)({ explicit: options.language, clientLanguage: client.language });
-    const html = (0, index_js_1.withLang)(lang, () => (0, panel_js_1.buildPanel)({
+    const panelOptions = {
         project, client,
         entries: store.getTimeEntries(db, options.projectId),
         ...(options.includeTeam !== false ? { team } : {}),
@@ -110,33 +124,100 @@ async function publishPanel(db, options) {
         commitsOf: (hashes) => hashes.length
             ? db.prepare(`SELECT hash, subject FROM commits WHERE hash IN (${hashes.map(() => "?").join(",")})`).all(...hashes)
             : [],
+    };
+    // El panel es un fichero estático: el idioma queda fijado en el momento de
+    // publicar, y republicar es lo que lo cambia.
+    const lang = (0, index_js_1.documentLang)({ explicit: options.language, clientLanguage: client.language });
+    const { html, summary } = (0, index_js_1.withLang)(lang, () => ({
+        html: (0, panel_js_1.buildPanel)(panelOptions),
+        summary: (0, panel_js_1.summarizePanel)((0, panel_js_1.panelData)(panelOptions)),
     }));
-    // Alojarlo exige sesión: es la cuenta la que decide cuántos paneles caben
-    // en tu plan, y sin ella no hay a quién cargarle esa cuota.
-    const account = store.getCloudAccount(db);
-    if (!account) {
-        throw new NoAccountError((0, index_js_1.tr) `Necesitas una cuenta para publicar. Vincúlala con:\n\n` +
-            (0, index_js_1.tr) `  estela login --email tu@correo.com\n`);
-    }
+    return {
+        projectId: project.id, projectName: project.name, token, html,
+        summary: { ...summary, clients: options.clients ?? [] },
+        ...(options.clients ? { clients: options.clients } : {}),
+        hideCredit: options.hideCredit === true,
+    };
+}
+async function uploadPanel(db, panel) {
+    const account = requireAccount(db);
     let result;
     try {
-        result = await (0, client_js_1.cloudPost)(account.apiBaseUrl, "/panels", { token, projectName: project.name, projectId: project.id, html,
-            ...(options.clients ? { clients: options.clients } : {}),
-            ...(options.hideCredit ? { hideCredit: true } : {}) }, { deviceToken: account.deviceToken });
+        result = await (0, client_js_1.cloudPost)(account.apiBaseUrl, "/panels", { token: panel.token, projectName: panel.projectName, projectId: panel.projectId, html: panel.html,
+            ...(panel.clients ? { clients: panel.clients } : {}),
+            ...(panel.hideCredit ? { hideCredit: true } : {}) }, { deviceToken: account.deviceToken });
     }
     catch (error) {
         // Igual que en sync.ts: el 402 se deja pasar. El mensaje ya viene
         // redactado del servidor (panels.ts), que es la única fuente de la verdad
         // sobre cuántos paneles permite cada plan, y el CLI imprime CloudError
         // limpio. Envolverlo lo convertía en un volcado de pila.
-        if (error instanceof client_js_1.CloudError && error.status === 401) {
-            throw new NoAccountError((0, index_js_1.tr) `Tu sesión ya no vale. Vuelve a vincular la máquina:\n\n` +
-                (0, index_js_1.tr) `  estela login --email tu@correo.com\n`);
+        throw sessionError(error);
+    }
+    store.recordPublication(db, panel.projectId, panel.token, "https://getestela.dev");
+    return { token: panel.token, url: result.url, adopted: result.adopted };
+}
+/**
+ * Despublica un panel: el servidor borra el fichero y el enlace deja de
+ * funcionar. `target` es el id de un proyecto (el panel que se publicó desde
+ * esta máquina) o el token del enlace.
+ */
+async function unpublishPanel(db, target) {
+    const account = requireAccount(db);
+    const panels = await listPublishedPanels(db);
+    const token = /^[0-9a-f]{32}$/.test(target) ? target : store.getPublicationToken(db, target);
+    const panel = panels.find((p) => p.token === token)
+        ?? panels.find((p) => p.projectId === target);
+    if (!panel)
+        throw new Error((0, index_js_1.tr) `No hay ningún panel publicado de "${target}". Míralos con: estela unpublish`);
+    try {
+        await (0, client_js_1.cloudDelete)(account.apiBaseUrl, `/panels/${panel.token}`, { deviceToken: account.deviceToken });
+    }
+    catch (error) {
+        throw sessionError(error);
+    }
+    store.forgetPublication(db, panel.token);
+    return panel;
+}
+/** Despublica todos los paneles de la cuenta. Devuelve los que quitó. */
+async function unpublishAll(db) {
+    const account = requireAccount(db);
+    const panels = await listPublishedPanels(db);
+    for (const panel of panels) {
+        try {
+            await (0, client_js_1.cloudDelete)(account.apiBaseUrl, `/panels/${panel.token}`, { deviceToken: account.deviceToken });
+        }
+        catch (error) {
+            throw sessionError(error);
         }
-        throw error;
+        store.forgetPublication(db, panel.token);
+    }
+    return panels;
+}
+async function listPublishedPanels(db) {
+    const account = requireAccount(db);
+    try {
+        const res = await (0, client_js_1.cloudGet)(account.apiBaseUrl, "/panels", { deviceToken: account.deviceToken });
+        return res.panels.map((p) => ({ token: p.token, projectName: p.projectName, projectId: p.projectId ?? null }));
+    }
+    catch (error) {
+        throw sessionError(error);
+    }
+}
+function requireAccount(db) {
+    const account = store.getCloudAccount(db);
+    if (!account) {
+        throw new NoAccountError((0, index_js_1.tr) `Necesitas una cuenta para publicar. Vincúlala con:\n\n` +
+            (0, index_js_1.tr) `  estela login --email tu@correo.com\n`);
+    }
+    return account;
+}
+function sessionError(error) {
+    if (error instanceof client_js_1.CloudError && error.status === 401) {
+        return new NoAccountError((0, index_js_1.tr) `Tu sesión ya no vale. Vuelve a vincular la máquina:\n\n` +
+            (0, index_js_1.tr) `  estela login --email tu@correo.com\n`);
     }
-    store.recordPublication(db, options.projectId, token, "https://getestela.dev");
-    return { token, url: result.url, adopted: result.adopted };
+    return error;
 }
 /**
  * El equipo del proyecto, acotado al periodo que cubre el panel. Sin acotar

package/dist/server.js

@@ -53,6 +53,7 @@ const sync_js_1 = require("./sync.js");
 const team_js_1 = require("./sync/team.js");
 const billing_js_1 = require("./billing.js");
 const client_js_1 = require("./cloud/client.js");
+const offline_js_1 = require("./offline.js");
 const team_js_2 = require("./metrics/team.js");
 const agents_js_1 = require("./watchers/agents.js");
 const git_js_1 = require("./watchers/git.js");
@@ -390,13 +391,19 @@ async function api(req, res, url, dbPath) {
         }
         if (path === "/api/publish" && req.method === "POST") {
             const body = await readJson(req);
+            const options = {
+                projectId: String(body["projectId"] ?? ""),
+                ...(body["token"] ? { token: String(body["token"]) } : {}),
+                ...(body["author"] ? { authorName: String(body["author"]) } : {}),
+                withAmounts: body["withAmounts"] === true,
+            };
             try {
-                const result = await (0, publish_js_1.publishPanel)(db, {
-                    projectId: String(body["projectId"] ?? ""),
-                    ...(body["token"] ? { token: String(body["token"]) } : {}),
-                    ...(body["author"] ? { authorName: String(body["author"]) } : {}),
-                    withAmounts: body["withAmounts"] === true,
-                });
+                // Primero el resumen de lo que va a quedar público; el botón del panel
+                // lo enseña y solo publica al confirmar, igual que `estela publish`.
+                if (body["preview"] === true) {
+                    return json(res, 200, { summary: (await (0, publish_js_1.preparePanel)(db, options)).summary });
+                }
+                const result = await (0, publish_js_1.publishPanel)(db, options);
                 return json(res, 200, result);
             }
             catch (error) {
@@ -455,8 +462,12 @@ async function api(req, res, url, dbPath) {
         // internet, getestela.dev caído) hace que el banner simplemente no
         // aparezca, nunca un error visible en el panel.
         if (path === "/api/banner" && req.method === "GET") {
+            // Solo con sesión (`estela login`): sin cuenta, el panel local no hace
+            // ninguna llamada de red, tampoco para un aviso. Ni con ESTELA_OFFLINE=1.
             const account = store.getCloudAccount(db);
-            const base = (account?.apiBaseUrl ?? "https://getestela.dev").replace(/\/$/, "");
+            if (!account || (0, offline_js_1.isOffline)())
+                return json(res, 200, { enabled: false });
+            const base = account.apiBaseUrl.replace(/\/$/, "");
             const controller = new AbortController();
             const timeout = setTimeout(() => controller.abort(), 2000);
             try {

package/dist/statusline-cache.d.ts

@@ -3,31 +3,60 @@
  * llamadas.
  *
  *  - `files`: hasta qué byte se leyó cada transcript, para leer solo lo nuevo.
- *  - `fiveHour`: el último `rate_limits.five_hour.resets_at` que mandó Claude
- *    Code, y cuándo se vio. `estela quota` lo usa para saber dónde empieza de
- *    verdad la ventana de 5 h en vez de estimarla.
+ *  - `fiveHour` y `sevenDay`: lo último que mandó Claude Code en rate_limits
+ *    (porcentaje y reinicio) y cuándo se vio. La status line lo enseña al
+ *    arrancar una sesión, antes de que lleguen datos nuevos, y `estela quota`
+ *    usa el reinicio de la 5 h para saber dónde empieza de verdad la ventana.
  *
  * Es una caché: si se pierde o se corrompe, todo sigue funcionando, solo que
  * relee más o vuelve a estimar.
  */
+/** Una ventana de límite tal como la mandó Claude Code, y cuándo se vio. */
+export interface SeenLimit {
+    resetsAt: string;
+    seenAt: string;
+    /** El porcentaje usado. Falta si Claude Code mandó el reinicio sin él. */
+    usedPercentage?: number;
+}
 export interface StatuslineCache {
     files: Record<string, {
         offset: number;
         seenAt: string;
     }>;
-    fiveHour?: {
-        resetsAt: string;
-        seenAt: string;
-    };
+    fiveHour?: SeenLimit;
+    sevenDay?: SeenLimit;
 }
 export declare function cachePath(dbPath: string): string;
 export declare function loadCache(dbPath: string): StatuslineCache;
 export declare function saveCache(dbPath: string, cache: StatuslineCache): void;
+/** Lo que llega de rate_limits para una ventana (cualquiera de los dos puede faltar). */
+export interface LimitInput {
+    readonly usedPercentage: number | null;
+    readonly resetsAt: Date | null;
+}
 /**
- * Apunta el `resets_at` de la ventana de 5 h. Solo si existe ya el directorio
- * de Estela: la status line no es quien empieza a guardar datos.
+ * Guarda lo nuevo de rate_limits y, para la ventana que no venga, devuelve el
+ * último porcentaje guardado si su reinicio aún no ha llegado.
+ *
+ * Es para el arranque de una sesión: Claude Code no manda rate_limits hasta la
+ * primera respuesta, y mientras tanto la línea perdía la semana y la 5 h que se
+ * sabían hace un momento. Un valor guardado cuyo reinicio ya pasó es de una
+ * ventana que terminó: no se enseña. En cuanto llega un dato nuevo, lo
+ * reemplaza.
+ *
+ * Usar lo guardado no cuenta como verlo otra vez: `seenAt` solo cambia con un
+ * dato nuevo, que es lo que `estela quota` mira para fiarse de la ventana.
+ *
+ * Solo escribe si existe ya el directorio de Estela: la status line no es
+ * quien empieza a guardar datos.
  */
-export declare function recordFiveHourReset(dbPath: string, resetsAt: Date, now: Date): void;
+export declare function rememberLimits(dbPath: string, input: {
+    readonly fiveHour: LimitInput;
+    readonly sevenDay: LimitInput;
+}, now: Date): {
+    fiveHour: number | null;
+    sevenDay: number | null;
+};
 export declare function readFiveHourReset(dbPath: string): {
     resetsAt: Date;
     seenAt: Date;

package/dist/statusline-cache.js

@@ -3,13 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.cachePath = cachePath;
 exports.loadCache = loadCache;
 exports.saveCache = saveCache;
-exports.recordFiveHourReset = recordFiveHourReset;
+exports.rememberLimits = rememberLimits;
 exports.readFiveHourReset = readFiveHourReset;
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const MAX_FILES = 30;
-/** Con el mismo reinicio, no se reescribe más a menudo que esto. */
-const FIVE_HOUR_REFRESH_MS = 10 * 60_000;
+/** Con el mismo reinicio y el mismo porcentaje, no se reescribe más a menudo que esto. */
+const REFRESH_MS = 10 * 60_000;
 function cachePath(dbPath) {
     return (0, node_path_1.join)((0, node_path_1.dirname)(dbPath), "statusline.json");
 }
@@ -33,19 +33,52 @@ function saveCache(dbPath, cache) {
     catch { /* sin caché, la próxima vez se relee: más lento, no incorrecto */ }
 }
 /**
- * Apunta el `resets_at` de la ventana de 5 h. Solo si existe ya el directorio
- * de Estela: la status line no es quien empieza a guardar datos.
+ * Guarda lo nuevo de rate_limits y, para la ventana que no venga, devuelve el
+ * último porcentaje guardado si su reinicio aún no ha llegado.
+ *
+ * Es para el arranque de una sesión: Claude Code no manda rate_limits hasta la
+ * primera respuesta, y mientras tanto la línea perdía la semana y la 5 h que se
+ * sabían hace un momento. Un valor guardado cuyo reinicio ya pasó es de una
+ * ventana que terminó: no se enseña. En cuanto llega un dato nuevo, lo
+ * reemplaza.
+ *
+ * Usar lo guardado no cuenta como verlo otra vez: `seenAt` solo cambia con un
+ * dato nuevo, que es lo que `estela quota` mira para fiarse de la ventana.
+ *
+ * Solo escribe si existe ya el directorio de Estela: la status line no es
+ * quien empieza a guardar datos.
  */
-function recordFiveHourReset(dbPath, resetsAt, now) {
-    if (!(0, node_fs_1.existsSync)((0, node_path_1.dirname)(dbPath)))
-        return;
+function rememberLimits(dbPath, input, now) {
     const cache = loadCache(dbPath);
-    const prev = cache.fiveHour;
-    const same = prev && new Date(prev.resetsAt).getTime() === resetsAt.getTime();
-    if (same && now.getTime() - new Date(prev.seenAt).getTime() < FIVE_HOUR_REFRESH_MS)
-        return;
-    cache.fiveHour = { resetsAt: resetsAt.toISOString(), seenAt: now.toISOString() };
-    saveCache(dbPath, cache);
+    let changed = false;
+    const pick = (key, fresh) => {
+        const prev = cache[key];
+        if (fresh.resetsAt) {
+            const sameReset = !!prev && new Date(prev.resetsAt).getTime() === fresh.resetsAt.getTime();
+            // Un reinicio sin porcentaje de la misma ventana no borra el que había.
+            const pct = fresh.usedPercentage ?? (sameReset ? prev.usedPercentage ?? null : null);
+            const samePct = (prev?.usedPercentage ?? null) === pct;
+            const recent = !!prev && now.getTime() - new Date(prev.seenAt).getTime() < REFRESH_MS;
+            if (!(sameReset && samePct && recent)) {
+                cache[key] = {
+                    resetsAt: fresh.resetsAt.toISOString(), seenAt: now.toISOString(),
+                    ...(pct !== null ? { usedPercentage: pct } : {}),
+                };
+                changed = true;
+            }
+        }
+        if (fresh.usedPercentage !== null)
+            return fresh.usedPercentage;
+        // Sin dato nuevo: lo último que se vio, si su ventana sigue abierta.
+        const last = cache[key];
+        if (!last || last.usedPercentage === undefined)
+            return null;
+        return new Date(last.resetsAt) > now ? last.usedPercentage : null;
+    };
+    const out = { fiveHour: pick("fiveHour", input.fiveHour), sevenDay: pick("sevenDay", input.sevenDay) };
+    if (changed && (0, node_fs_1.existsSync)((0, node_path_1.dirname)(dbPath)))
+        saveCache(dbPath, cache);
+    return out;
 }
 function readFiveHourReset(dbPath) {
     const f = loadCache(dbPath).fiveHour;

package/dist/statusline-run.js

@@ -55,13 +55,17 @@ async function runStatusline(argv) {
         const reserved = extra ? (0, statusline_js_1.stripAnsi)(extra).length + 3 : 0;
         const columns = Number(process.env["COLUMNS"]) || null;
         const now = new Date();
-        if (input.fiveHourResetsAt) {
-            try {
-                (0, statusline_cache_js_1.recordFiveHourReset)(flags.db, input.fiveHourResetsAt, now);
-            }
-            catch { /* es una caché */ }
+        // Lo nuevo de rate_limits se guarda; lo que no venga (al arrancar una
+        // sesión) se toma de lo último visto, si su ventana sigue abierta.
+        let limits = { fiveHour: input.fiveHour, sevenDay: input.sevenDay };
+        try {
+            limits = (0, statusline_cache_js_1.rememberLimits)(flags.db, {
+                fiveHour: { usedPercentage: input.fiveHour, resetsAt: input.fiveHourResetsAt ?? null },
+                sevenDay: { usedPercentage: input.sevenDay, resetsAt: input.sevenDayResetsAt ?? null },
+            }, now);
         }
-        const data = computeStatus(input, flags.db, now);
+        catch { /* es una caché: sin ella, la línea sale con lo que llegó */ }
+        const data = computeStatus({ ...input, ...limits }, flags.db, now);
         const ours = (0, statusline_js_1.renderStatus)(data, { columns, color: flags.color, reserved });
         process.stdout.write((extra ? `${ours}${flags.color ? "\x1b[90m | \x1b[0m" : " | "}${extra}` : ours) + "\n");
     }
@@ -83,7 +87,7 @@ function parseFlags(argv) {
 }
 /** Ejecutado a mano en una terminal, sin nada por stdin: el directorio actual. */
 function manualInput() {
-    return { dir: process.cwd(), transcriptPath: null, fiveHour: null, sevenDay: null, fiveHourResetsAt: null };
+    return { dir: process.cwd(), transcriptPath: null, fiveHour: null, sevenDay: null, fiveHourResetsAt: null, sevenDayResetsAt: null };
 }
 function readStdin() {
     if (process.stdin.isTTY)

package/dist/statusline.d.ts

@@ -21,6 +21,8 @@ export interface StatusInput {
      * atrás): se guarda para que `estela quota` sepa dónde empieza la ventana.
      */
     readonly fiveHourResetsAt?: Date | null;
+    /** `rate_limits.seven_day.resets_at`: tampoco se enseña nunca. */
+    readonly sevenDayResetsAt?: Date | null;
 }
 /**
  * Lee la entrada. Lanza si no es un objeto JSON: quien llama imprime

package/dist/statusline.js

@@ -23,6 +23,7 @@ function parseStatusInput(text) {
         fiveHour: pct(obj(limits["five_hour"])["used_percentage"]),
         sevenDay: pct(obj(limits["seven_day"])["used_percentage"]),
         fiveHourResetsAt: epoch(obj(limits["five_hour"])["resets_at"]),
+        sevenDayResetsAt: epoch(obj(limits["seven_day"])["resets_at"]),
     };
 }
 /** Segundos desde 1970 (lo que manda Claude Code); por si acaso, también milisegundos. */

package/dist/updateCheck.d.ts

@@ -1,8 +1,13 @@
 /** `1.2.3` > `1.10.0`: comparar como texto ordenaría mal el "10". */
 export declare function isNewer(latest: string, current: string): boolean;
+/** Si quien ejecuta ha pedido que no se compruebe, o es una máquina de CI. */
+export declare function updateCheckDisabled(env?: NodeJS.ProcessEnv): boolean;
 /**
  * Enseña el aviso si el caché dice que hay algo más nuevo, y refresca el
  * caché si ya toca. Se llama una vez al arrancar cualquier comando.
+ *
+ * Desactivada no hace nada, tampoco el aviso del caché: un caché viejo diría
+ * "hay versión nueva" para siempre, sin poder comprobar si sigue siendo así.
  */
-export declare function checkForUpdate(currentVersion: string): void;
+export declare function checkForUpdate(currentVersion: string, env?: NodeJS.ProcessEnv): void;
 //# sourceMappingURL=updateCheck.d.ts.map

package/dist/updateCheck.js

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isNewer = isNewer;
+exports.updateCheckDisabled = updateCheckDisabled;
 exports.checkForUpdate = checkForUpdate;
 const node_fs_1 = require("node:fs");
 const node_os_1 = require("node:os");
 const node_path_1 = require("node:path");
 const index_js_1 = require("./i18n/index.js");
+const offline_js_1 = require("./offline.js");
 /**
  * Avisa cuando hay una versión más nueva en npm.
  *
@@ -22,13 +24,18 @@ const index_js_1 = require("./i18n/index.js");
  *    igual. Un `estela log` no puede tardar más porque el registro esté lento.
  *  - **Como mucho una vez al día.** Consultar npm en cada `estela status` de
  *    un script sería ruido para el registro y para quien lo mira.
+ *
+ * Es la única llamada de red del plan gratuito, y se apaga con
+ * `ESTELA_NO_UPDATE_CHECK=1` (o con `ESTELA_OFFLINE=1`, que apaga toda la red). En CI (con `CI` definida) no se hace nunca: ahí
+ * nadie lee el aviso y la máquina se tira al acabar.
  */
-const CACHE_PATH = (0, node_path_1.join)((0, node_os_1.homedir)(), ".estela", "update-check.json");
+/** Se calcula en cada llamada: con una constante, un test que cambia HOME no tendría efecto. */
+const cachePath = () => (0, node_path_1.join)((0, node_os_1.homedir)(), ".estela", "update-check.json");
 const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
 const FETCH_TIMEOUT_MS = 1500;
 function readCache() {
     try {
-        return JSON.parse((0, node_fs_1.readFileSync)(CACHE_PATH, "utf8"));
+        return JSON.parse((0, node_fs_1.readFileSync)(cachePath(), "utf8"));
     }
     catch {
         return null;
@@ -37,7 +44,7 @@ function readCache() {
 function writeCache(latest) {
     try {
         (0, node_fs_1.mkdirSync)((0, node_path_1.join)((0, node_os_1.homedir)(), ".estela"), { recursive: true });
-        (0, node_fs_1.writeFileSync)(CACHE_PATH, JSON.stringify({ checkedAt: new Date().toISOString(), latest }));
+        (0, node_fs_1.writeFileSync)(cachePath(), JSON.stringify({ checkedAt: new Date().toISOString(), latest }));
     }
     catch {
         // Sin permiso de escritura o disco lleno: el aviso de hoy se pierde, pero
@@ -76,11 +83,25 @@ function refreshInBackground() {
         .catch(() => { })
         .finally(() => clearTimeout(timeout));
 }
+/** Si quien ejecuta ha pedido que no se compruebe, o es una máquina de CI. */
+function updateCheckDisabled(env = process.env) {
+    if ((0, offline_js_1.isOffline)(env))
+        return true;
+    const off = env["ESTELA_NO_UPDATE_CHECK"];
+    if (off !== undefined && off !== "" && off !== "0")
+        return true;
+    return env["CI"] !== undefined;
+}
 /**
  * Enseña el aviso si el caché dice que hay algo más nuevo, y refresca el
  * caché si ya toca. Se llama una vez al arrancar cualquier comando.
+ *
+ * Desactivada no hace nada, tampoco el aviso del caché: un caché viejo diría
+ * "hay versión nueva" para siempre, sin poder comprobar si sigue siendo así.
  */
-function checkForUpdate(currentVersion) {
+function checkForUpdate(currentVersion, env = process.env) {
+    if (updateCheckDisabled(env))
+        return;
     const cache = readCache();
     if (cache && isNewer(cache.latest, currentVersion)) {
         console.log((0, index_js_1.tr) `\n  ↑ Hay una versión nueva de Estela (${cache.latest}, tienes ${currentVersion}).`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "estela",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "Time tracking you never fill in: rebuilds your billable hours from Claude Code, Codex and GitHub Copilot sessions and your Git history, and splits what the AI cost per project.",
   "keywords": [
     "time-tracking",