estela 0.2.2 → 0.2.4

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/rate-history.d.ts

@@ -0,0 +1,63 @@
+/**
+ * `~/.estela/rate-limits.jsonl`: el historial de los porcentajes de límite que
+ * Claude Code manda a la status line. Es lo que analiza `estela plan`.
+ *
+ * Solo se guarda lo que manda Claude Code, tal cual: el porcentaje usado y el
+ * reinicio de cada ventana, y su versión. Ni sesión, ni rutas, ni proyectos.
+ * Estela no estima ningún límite: sin `rate_limits` en la entrada (API key, o
+ * la primera respuesta de la sesión aún no llegó), no se guarda nada.
+ *
+ * Los transcripts no traen estos porcentajes, así que no hay forma de
+ * recuperar el pasado: el historial empieza el día que se instala la 0.2.4. Y
+ * solo se recoge con Claude Code en la terminal; la extensión de VS Code no
+ * ejecuta la status line.
+ *
+ * Va por el camino rápido de la status line (100 ms): sin `node:sqlite`, una
+ * línea por `appendFileSync`, y cualquier error se ignora.
+ */
+export interface RateSample {
+    /** Epoch en ms de la muestra. */
+    readonly ts: number;
+    readonly src: "claude-code";
+    readonly w5?: number;
+    /** `resets_at` tal cual (epoch en s). */
+    readonly w5_reset?: number;
+    readonly w7?: number;
+    readonly w7_reset?: number;
+    /** Versión de Claude Code, si viene. */
+    readonly cc?: string;
+}
+export declare const KEEP_DAYS = 120;
+export declare function historyPath(dbPath: string): string;
+/**
+ * La muestra que sale del JSON de la status line, o null si no trae ningún
+ * porcentaje. Cada ventana que falte se omite: nunca se escribe un 0.
+ */
+export declare function sampleOf(raw: unknown, now: Date): RateSample | null;
+/**
+ * Si vale la pena guardar la muestra: han pasado 5 minutos desde la última,
+ * algún porcentaje cambió al menos un punto, o empezó una ventana nueva.
+ */
+export declare function shouldWrite(last: RateSample | undefined, s: RateSample): boolean;
+/**
+ * Lo que hace la status line en cada evento. Nunca lanza: es un historial, y
+ * la línea tiene que salir igual aunque no se pueda escribir.
+ *
+ * Solo escribe si ya existe el directorio de Estela: la status line no es
+ * quien empieza a guardar datos.
+ */
+export declare function recordSample(dbPath: string, raw: unknown, now: Date): void;
+/** Lee el historial. Las líneas rotas se saltan. */
+export declare function readSamples(file: string): RateSample[];
+/**
+ * Quita las muestras de hace más de 120 días. Reescribe en un fichero aparte y
+ * lo renombra encima: un corte a mitad no deja el historial a medias.
+ * Devuelve cuántas quitó.
+ *
+ * Corre desde la status line una vez al día, así que lo normal (nada que
+ * quitar) tiene que costar casi nada: el fichero se escribe en orden, y si la
+ * primera muestra no ha caducado, ninguna lo ha hecho. Solo entonces se lee
+ * entero, y el `ts` se saca del principio de cada línea sin parsear el JSON.
+ */
+export declare function pruneSamples(file: string, now: Date, keepDays?: number): number;
+//# sourceMappingURL=rate-history.d.ts.map

package/dist/rate-history.js

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KEEP_DAYS = void 0;
+exports.historyPath = historyPath;
+exports.sampleOf = sampleOf;
+exports.shouldWrite = shouldWrite;
+exports.recordSample = recordSample;
+exports.readSamples = readSamples;
+exports.pruneSamples = pruneSamples;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const statusline_cache_js_1 = require("./statusline-cache.js");
+const MIN_GAP_MS = 5 * 60_000;
+const MIN_DELTA = 1;
+exports.KEEP_DAYS = 120;
+const PRUNE_EVERY_MS = 24 * 60 * 60_000;
+/** Cada cuánto se reescribe en la caché "se vio una sesión sin rate_limits". */
+const NO_LIMITS_EVERY_MS = 60 * 60_000;
+function historyPath(dbPath) {
+    return (0, node_path_1.join)((0, node_path_1.dirname)(dbPath), "rate-limits.jsonl");
+}
+/**
+ * La muestra que sale del JSON de la status line, o null si no trae ningún
+ * porcentaje. Cada ventana que falte se omite: nunca se escribe un 0.
+ */
+function sampleOf(raw, now) {
+    const o = obj(raw);
+    const limits = obj(o["rate_limits"]);
+    const five = obj(limits["five_hour"]);
+    const seven = obj(limits["seven_day"]);
+    const w5 = num(five["used_percentage"]);
+    const w7 = num(seven["used_percentage"]);
+    if (w5 === undefined && w7 === undefined)
+        return null;
+    const w5Reset = num(five["resets_at"]);
+    const w7Reset = num(seven["resets_at"]);
+    const cc = typeof o["version"] === "string" && o["version"] ? o["version"] : undefined;
+    return {
+        ts: now.getTime(), src: "claude-code",
+        ...(w5 !== undefined ? { w5 } : {}),
+        ...(w5Reset !== undefined ? { w5_reset: w5Reset } : {}),
+        ...(w7 !== undefined ? { w7 } : {}),
+        ...(w7Reset !== undefined ? { w7_reset: w7Reset } : {}),
+        ...(cc ? { cc } : {}),
+    };
+}
+/**
+ * Si vale la pena guardar la muestra: han pasado 5 minutos desde la última,
+ * algún porcentaje cambió al menos un punto, o empezó una ventana nueva.
+ */
+function shouldWrite(last, s) {
+    if (!last)
+        return true;
+    if (s.ts - last.ts >= MIN_GAP_MS)
+        return true;
+    if (moved(last.w5, s.w5) || moved(last.w7, s.w7))
+        return true;
+    return last.w5_reset !== s.w5_reset || last.w7_reset !== s.w7_reset;
+}
+function moved(a, b) {
+    if (a === undefined || b === undefined)
+        return a !== b;
+    return Math.abs(a - b) >= MIN_DELTA;
+}
+/**
+ * Lo que hace la status line en cada evento. Nunca lanza: es un historial, y
+ * la línea tiene que salir igual aunque no se pueda escribir.
+ *
+ * Solo escribe si ya existe el directorio de Estela: la status line no es
+ * quien empieza a guardar datos.
+ */
+function recordSample(dbPath, raw, now) {
+    try {
+        if (!(0, node_fs_1.existsSync)((0, node_path_1.dirname)(dbPath)))
+            return;
+        const cache = (0, statusline_cache_js_1.loadCache)(dbPath);
+        let changed = false;
+        const sample = sampleOf(raw, now);
+        if (!sample) {
+            // Para que `estela plan` distinga "sin datos" de "esto es una API key".
+            if (obj(raw)["rate_limits"] === undefined && stale(cache.noLimitsAt, now, NO_LIMITS_EVERY_MS)) {
+                cache.noLimitsAt = now.toISOString();
+                changed = true;
+            }
+        }
+        else if (shouldWrite(cache.lastSample, sample)) {
+            (0, node_fs_1.appendFileSync)(historyPath(dbPath), JSON.stringify(sample) + "\n");
+            cache.lastSample = sample;
+            changed = true;
+        }
+        if (sample && stale(cache.prunedAt, now, PRUNE_EVERY_MS)) {
+            pruneSamples(historyPath(dbPath), now);
+            cache.prunedAt = now.toISOString();
+            changed = true;
+        }
+        if (changed)
+            (0, statusline_cache_js_1.saveCache)(dbPath, cache);
+    }
+    catch { /* sin historial esta vez; la línea sale igual */ }
+}
+function stale(iso, now, ms) {
+    if (!iso)
+        return true;
+    const t = Date.parse(iso);
+    return Number.isNaN(t) || now.getTime() - t >= ms;
+}
+/** Lee el historial. Las líneas rotas se saltan. */
+function readSamples(file) {
+    let text;
+    try {
+        text = (0, node_fs_1.readFileSync)(file, "utf8");
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const line of text.split("\n")) {
+        if (!line)
+            continue;
+        try {
+            const s = JSON.parse(line);
+            if (s && typeof s.ts === "number")
+                out.push(s);
+        }
+        catch { /* línea a medias: se ignora */ }
+    }
+    return out;
+}
+/**
+ * Quita las muestras de hace más de 120 días. Reescribe en un fichero aparte y
+ * lo renombra encima: un corte a mitad no deja el historial a medias.
+ * Devuelve cuántas quitó.
+ *
+ * Corre desde la status line una vez al día, así que lo normal (nada que
+ * quitar) tiene que costar casi nada: el fichero se escribe en orden, y si la
+ * primera muestra no ha caducado, ninguna lo ha hecho. Solo entonces se lee
+ * entero, y el `ts` se saca del principio de cada línea sin parsear el JSON.
+ */
+function pruneSamples(file, now, keepDays = exports.KEEP_DAYS) {
+    const cutoff = now.getTime() - keepDays * 24 * 60 * 60_000;
+    const first = firstLine(file);
+    if (first === null)
+        return 0;
+    const firstTs = tsOf(first);
+    if (firstTs !== null && firstTs >= cutoff)
+        return 0;
+    const lines = (0, node_fs_1.readFileSync)(file, "utf8").split("\n").filter(Boolean);
+    const kept = lines.filter((line) => {
+        const ts = tsOf(line);
+        return ts !== null && ts >= cutoff;
+    });
+    if (kept.length === lines.length)
+        return 0;
+    const tmp = `${file}.tmp`;
+    (0, node_fs_1.writeFileSync)(tmp, kept.map((l) => l + "\n").join(""));
+    (0, node_fs_1.renameSync)(tmp, file);
+    return lines.length - kept.length;
+}
+/** El `ts` de una línea: siempre es el primer campo, porque así la escribe `sampleOf`. Null si está rota. */
+function tsOf(line) {
+    const m = /^\{"ts":(\d+),/.exec(line);
+    if (!m || !line.endsWith("}"))
+        return null;
+    return Number(m[1]);
+}
+function firstLine(file) {
+    let fd;
+    try {
+        fd = (0, node_fs_1.openSync)(file, "r");
+    }
+    catch {
+        return null;
+    }
+    try {
+        const buf = Buffer.alloc(512);
+        const n = (0, node_fs_1.readSync)(fd, buf, 0, buf.length, 0);
+        if (n === 0)
+            return null;
+        const text = buf.subarray(0, n).toString("utf8");
+        const nl = text.indexOf("\n");
+        return nl >= 0 ? text.slice(0, nl) : text;
+    }
+    finally {
+        (0, node_fs_1.closeSync)(fd);
+    }
+}
+function obj(v) {
+    return v && typeof v === "object" && !Array.isArray(v) ? v : {};
+}
+function num(v) {
+    return typeof v === "number" && Number.isFinite(v) ? v : undefined;
+}
+//# sourceMappingURL=rate-history.js.map

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

@@ -1,3 +1,4 @@
+import type { RateSample } from "./rate-history.js";
 /**
  * `statusline.json`, junto a la base: lo que la status line recuerda entre
  * llamadas.
@@ -7,6 +8,9 @@
  *    (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.
+ *  - `lastSample`, `prunedAt`, `noLimitsAt`: del historial de
+ *    `rate-limits.jsonl` (ver rate-history.ts), para decidir si se guarda una
+ *    muestra sin tener que leer el fichero.
  *
  * Es una caché: si se pierde o se corrompe, todo sigue funcionando, solo que
  * relee más o vuelve a estimar.
@@ -25,6 +29,12 @@ export interface StatuslineCache {
     }>;
     fiveHour?: SeenLimit;
     sevenDay?: SeenLimit;
+    /** La última muestra guardada en rate-limits.jsonl. */
+    lastSample?: RateSample;
+    /** Cuándo se quitaron por última vez las muestras de más de 120 días. */
+    prunedAt?: string;
+    /** La última vez que llegó una entrada sin rate_limits (API key, o sesión recién abierta). */
+    noLimitsAt?: string;
 }
 export declare function cachePath(dbPath: string): string;
 export declare function loadCache(dbPath: string): StatuslineCache;

package/dist/statusline-run.js

@@ -43,6 +43,7 @@ const store = __importStar(require("./db/store.js"));
 const quota_js_1 = require("./metrics/quota.js");
 const paths_js_1 = require("./paths.js");
 const project_of_js_1 = require("./project-of.js");
+const rate_history_js_1 = require("./rate-history.js");
 const statusline_cache_js_1 = require("./statusline-cache.js");
 const statusline_js_1 = require("./statusline.js");
 const claude_js_1 = require("./watchers/claude.js");
@@ -65,6 +66,13 @@ async function runStatusline(argv) {
             }, now);
         }
         catch { /* es una caché: sin ella, la línea sale con lo que llegó */ }
+        // El historial de porcentajes para `estela plan`. No lanza nunca.
+        if (text.trim()) {
+            try {
+                (0, rate_history_js_1.recordSample)(flags.db, JSON.parse(text), now);
+            }
+            catch { /* entrada rota: ya lo cubre lo de abajo */ }
+        }
         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");

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.2",
+  "version": "0.2.4",
   "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",