estela 0.2.1 → 0.2.3

package/README.md

@@ -197,6 +197,11 @@ and Teams have no limit.
 The dashboard's footer says "Hours filled in by Estela", linking to
 getestela.dev. On Pro and Teams, `--no-credit` removes that line.
 
+Before uploading, `estela publish` shows what will become public — authors,
+branches, file paths, client emails — and asks you to confirm (`--yes` skips
+it). `estela unpublish <project>` deletes the dashboard from the server and the
+link stops working; `--all` takes them all down.
+
 ## Showing what you built
 
 A badge for your project's README, with its measured hours and what the AI
@@ -288,7 +293,9 @@ Hours measured today on this project (the same number the report will
 give), this project's share of your Claude Code usage this week, and — only
 if Claude Code sends them — its own weekly and 5-hour limit percentages, as
 they come. Estela never estimates a limit or counts down to a reset. The
-5-hour figure turns amber from 80%. On a narrow terminal the line drops the
+5-hour figure turns amber from 80%. A new session shows the last figures Claude
+Code sent until fresh ones arrive, if that window hasn't reset yet. On a
+narrow terminal the line drops the
 5-hour figure first, then the week, then shortens the name, then this
 project, then today; `estela` always stays. It runs in about 50 ms and only
 reads what's new in the current session's transcript.
@@ -317,6 +324,24 @@ from them and marks it as **estimated**, so you know which part of your hours is
 measured and which is assumed. The estimate errs on the short side on purpose:
 these hours end up in a report someone pays for.
 
+## Privacy
+
+On the free plan, your sessions, your code and your hours never leave your
+machine: everything lives in `~/.estela/estela.db`, and the `estela web`
+dashboard only listens on `127.0.0.1`. Estela never stores the text of your
+prompts, not even locally.
+
+The only network connection without an account is a check against npm, at most
+once a day, for a new version. Two environment variables:
+
+| Variable | Effect |
+|---|---|
+| `ESTELA_NO_UPDATE_CHECK=1` | Skips the version check (it's also skipped when `CI` is set). |
+| `ESTELA_OFFLINE=1` | No network connections at all: no version check, no banner, no account. |
+
+With an account, only what you turn on is uploaded — a dashboard, sync, Teams.
+What each feature sends, one by one: [getestela.dev/en/privacy](https://getestela.dev/en/privacy).
+
 ## Plans
 
 | | Free | Pro | Teams |

package/dist/cli.js

@@ -203,6 +203,11 @@ estela — registro de horas para desarrollo asistido por IA
         republicaciones no desvinculan a quien ya lo tenía.
         --no-credit quita la línea "Horas rellenadas por Estela" del pie
         (Pro y Teams).
+        Antes de subir enseña lo que va a quedar público (autores, ramas,
+        ficheros, correos del cliente) y pide confirmación; --yes la salta.
+  estela unpublish [<proyecto|token>] [--all] [--yes]
+        Borra el panel del servidor: el enlace deja de funcionar. Sin
+        argumentos, lista tus paneles publicados.
 
   estela team ai-cost --project <id> --allow | --deny
         Si quien te invitó pide ver el coste de IA del proyecto, esta es tu
@@ -270,6 +275,12 @@ Opciones globales:  --db <ruta>   (por defecto ${schema_js_1.DEFAULT_DB_PATH})
                     --lang es|en  Idioma. Sin ella se usa el del sistema;
                                   ESTELA_LANG=en lo fija para siempre.
                     --version     Solo imprime la versión instalada.
+
+Red:  Sin cuenta, Estela solo consulta npm una vez al día por si hay
+      versión nueva.
+      ESTELA_NO_UPDATE_CHECK=1  no la consulta (tampoco con CI definida).
+      ESTELA_OFFLINE=1          ninguna conexión de red: ni versión, ni
+                                banner, ni nada de la cuenta.
 `;
 const HELP_EN = `
 estela — time tracking for AI-assisted development
@@ -394,6 +405,11 @@ estela — time tracking for AI-assisted development
         isn't touched: republishing never unlinks anyone who already had it.
         --no-credit removes the "Hours filled in by Estela" line from the
         footer (Pro and Teams).
+        Before uploading it shows what will become public (authors,
+        branches, files, client emails) and asks to confirm; --yes skips it.
+  estela unpublish [<project|token>] [--all] [--yes]
+        Deletes the dashboard from the server: the link stops working.
+        With no arguments, lists your published dashboards.
 
   estela team ai-cost --project <id> --allow | --deny
         If whoever invited you asks to see the project's AI cost, this is
@@ -461,6 +477,12 @@ Global options:  --db <path>   (default ${schema_js_1.DEFAULT_DB_PATH})
                  --lang es|en  Language. Without it, your system's is used;
                                ESTELA_LANG=en sets it for good.
                  --version     Only prints the installed version.
+
+Network:  Without an account, Estela only checks npm once a day for a new
+          version.
+          ESTELA_NO_UPDATE_CHECK=1  skips that check (so does having CI set).
+          ESTELA_OFFLINE=1          no network connections at all: no
+                                    version check, no banner, no account.
 `;
 function helpText() {
     return (0, index_js_1.getLang)() === "en" ? HELP_EN : HELP_ES;
@@ -1398,7 +1420,7 @@ async function cmdPublish(args, dbPath) {
         const token = str(args, "token") ?? store.getPublicationToken(db, projectId) ?? undefined;
         let result;
         try {
-            result = await (0, publish_js_1.publishPanel)(db, {
+            const panel = await (0, publish_js_1.preparePanel)(db, {
                 projectId,
                 ...(token ? { token } : {}),
                 ...(str(args, "author") ? { authorName: str(args, "author") } : {}),
@@ -1408,6 +1430,19 @@ async function cmdPublish(args, dbPath) {
                 hideCredit: args.flags["no-credit"] === true,
                 ...(explicitLang(args) ? { language: explicitLang(args) } : {}),
             });
+            // Lo que va a quedar público, antes de subirlo: quien tenga el enlace
+            // verá todo esto, y publicar no se deshace solo.
+            printPanelSummary(panel.summary);
+            if (args.flags["yes"] !== true) {
+                if (!process.stdin.isTTY) {
+                    throw new UserError((0, index_js_1.tr) `No se ha publicado nada. Sin terminal no se puede confirmar: añade --yes para publicar.`);
+                }
+                if (!await confirm((0, index_js_1.tr) `¿Publicar? [s/N] `)) {
+                    console.log((0, index_js_1.tr) `\nNo se ha publicado nada.`);
+                    return;
+                }
+            }
+            result = await (0, publish_js_1.uploadPanel)(db, panel);
         }
         catch (error) {
             if (error instanceof publish_js_1.NoAccountError)
@@ -1433,6 +1468,82 @@ async function cmdPublish(args, dbPath) {
         db.close();
     }
 }
+/** Hasta `max` elementos de una lista, y cuántos quedan fuera. */
+function shortList(items, max = 8) {
+    if (items.length === 0)
+        return "—";
+    const shown = items.slice(0, max).join(", ");
+    return items.length > max ? (0, index_js_1.tr) `${shown} y ${items.length - max} más` : shown;
+}
+function printPanelSummary(s) {
+    console.log((0, index_js_1.tr) `\nEsto va a quedar público. Quien tenga el enlace lo ve todo:\n`);
+    const row = (label, value) => console.log(`  ${label.padEnd(14)}${value}`);
+    row((0, index_js_1.tr) `Proyecto`, `${s.project} · ${s.client}`);
+    row((0, index_js_1.tr) `Trabajo`, (0, index_js_1.tr) `${s.days} días, ${s.blocks} bloques, ${s.commitSubjects} mensajes de commit`);
+    row((0, index_js_1.tr) `Autores`, shortList(s.authors));
+    row((0, index_js_1.tr) `Ramas`, shortList(s.branches));
+    row((0, index_js_1.tr) `Ficheros`, shortList(s.files));
+    row((0, index_js_1.tr) `Importes`, s.amounts ? (0, index_js_1.tr) `sí (--with-amounts)` : (0, index_js_1.tr) `no`);
+    row((0, index_js_1.tr) `Clientes`, s.clients.length ? (0, index_js_1.tr) `${s.clients.join(", ")} (recibirán un correo)` : "—");
+    console.log("");
+}
+/**
+ * `estela unpublish <proyecto|token>` y `estela unpublish --all`.
+ *
+ * Borra el panel del servidor: el enlace deja de funcionar para todos al
+ * momento. Sin argumentos, lista lo que tienes publicado.
+ */
+async function cmdUnpublish(args, dbPath) {
+    const db = (0, schema_js_1.openDatabase)(dbPath);
+    try {
+        const target = args._[1] ?? str(args, "project") ?? str(args, "token");
+        try {
+            if (args.flags["all"] === true) {
+                const panels = await (0, publish_js_1.listPublishedPanels)(db);
+                if (panels.length === 0) {
+                    console.log((0, index_js_1.tr) `No tienes ningún panel publicado.`);
+                    return;
+                }
+                for (const p of panels)
+                    console.log(`  ${p.projectName}  ·  ${p.token}`);
+                if (args.flags["yes"] !== true) {
+                    if (!process.stdin.isTTY) {
+                        throw new UserError((0, index_js_1.tr) `No se ha despublicado nada. Sin terminal no se puede confirmar: añade --yes.`);
+                    }
+                    if (!await confirm((0, index_js_1.tr) `\n¿Despublicar estos ${panels.length} paneles? Los enlaces dejarán de funcionar. [s/N] `)) {
+                        console.log((0, index_js_1.tr) `\nNo se ha despublicado nada.`);
+                        return;
+                    }
+                }
+                const gone = await (0, publish_js_1.unpublishAll)(db);
+                console.log((0, index_js_1.tr) `\n${gone.length} paneles despublicados. Sus enlaces ya no funcionan.`);
+                return;
+            }
+            if (!target) {
+                const panels = await (0, publish_js_1.listPublishedPanels)(db);
+                if (panels.length === 0) {
+                    console.log((0, index_js_1.tr) `No tienes ningún panel publicado.`);
+                    return;
+                }
+                console.log((0, index_js_1.tr) `Tus paneles publicados:\n`);
+                for (const p of panels)
+                    console.log(`  ${p.projectId ?? "—"}  ${p.projectName}  ·  ${p.token}`);
+                console.log((0, index_js_1.tr) `\nPara despublicar uno: estela unpublish <proyecto o token>. Todos: estela unpublish --all`);
+                return;
+            }
+            const gone = await (0, publish_js_1.unpublishPanel)(db, target);
+            console.log((0, index_js_1.tr) `Panel de ${gone.projectName} despublicado. El enlace ya no funciona.`);
+        }
+        catch (error) {
+            if (error instanceof publish_js_1.NoAccountError)
+                throw new UserError(error.message);
+            throw error;
+        }
+    }
+    finally {
+        db.close();
+    }
+}
 /**
  * `estela sync enable --project <id>` — opt-in explícito, proyecto por
  * proyecto. Sin esta fila, ese proyecto no sale de esta máquina nunca, sea
@@ -2350,7 +2461,8 @@ async function main() {
     }
     (0, client_js_1.setClientVersion)(VERSION);
     const dbPath = str(args, "db") ?? schema_js_1.DEFAULT_DB_PATH;
-    const command = args._.join(" ");
+    // `estela unpublish <panel>` lleva el panel suelto, sin flag: no es un subcomando.
+    const command = args._[0] === "unpublish" ? "unpublish" : args._.join(" ");
     // Se llama aquí, no al final: un comando que falla a medias (por ejemplo
     // "estela import" sin repositorios) debe avisar igual de que hay una
     // versión nueva, no solo los que terminan bien.
@@ -2434,6 +2546,9 @@ async function main() {
         case "publish":
             await cmdPublish(args, dbPath);
             break;
+        case "unpublish":
+            await cmdUnpublish(args, dbPath);
+            break;
         case "export":
             await cmdExport(args, dbPath);
             break;

package/dist/cloud/client.d.ts

@@ -22,4 +22,6 @@ export declare function cloudPost<T>(baseUrl: string, path: string, body: unknow
  * proyecto es la primera vez que hace falta leer algo.
  */
 export declare function cloudGet<T>(baseUrl: string, path: string, options?: CloudPostOptions): Promise<T>;
+/** Para borrar lo que se subió: hoy, despublicar un panel. */
+export declare function cloudDelete<T>(baseUrl: string, path: string, options?: CloudPostOptions): Promise<T>;
 //# sourceMappingURL=client.d.ts.map

package/dist/cloud/client.js

@@ -12,7 +12,9 @@ exports.CloudError = void 0;
 exports.setClientVersion = setClientVersion;
 exports.cloudPost = cloudPost;
 exports.cloudGet = cloudGet;
+exports.cloudDelete = cloudDelete;
 const index_js_1 = require("../i18n/index.js");
+const offline_js_1 = require("../offline.js");
 class CloudError extends Error {
     status;
     constructor(message, status) {
@@ -29,32 +31,7 @@ exports.CloudError = CloudError;
 let clientVersion = "0.0.0";
 function setClientVersion(v) { clientVersion = v; }
 async function cloudPost(baseUrl, path, body, options = {}) {
-    let res;
-    try {
-        res = await fetch(`${baseUrl}${path}`, {
-            method: "POST",
-            headers: {
-                "content-type": "application/json",
-                "estela-version": clientVersion,
-                // Para que la API conteste en el idioma de la terminal.
-                "x-estela-lang": (0, index_js_1.getLang)(),
-                ...(options.deviceToken ? { authorization: `Bearer ${options.deviceToken}` } : {}),
-            },
-            body: JSON.stringify(body),
-        });
-    }
-    catch {
-        throw new CloudError((0, index_js_1.tr) `Sin respuesta de ${baseUrl}. Puede ser tu conexión o que el servicio esté caído; ` +
-            (0, index_js_1.tr) `en ambos casos, nada de lo tuyo se ha perdido: vuelve a intentarlo.`);
-    }
-    const data = (await res.json().catch(() => ({})));
-    if (!res.ok) {
-        // El status viaja aparte del mensaje: quien llama necesita distinguir
-        // "no tienes sesión" (401, pide login) de "cuota agotada" (402, pide
-        // upgrade) sin tener que analizar el texto en español.
-        throw new CloudError(typeof data["error"] === "string" ? data["error"] : (0, index_js_1.tr) `Error ${res.status}`, res.status);
-    }
-    return data;
+    return request("POST", baseUrl, path, body, options);
 }
 /**
  * Primer GET autenticado de verdad del CLI. Hasta Teams, todo lo que hablaba
@@ -62,16 +39,30 @@ async function cloudPost(baseUrl, path, body, options = {}) {
  * proyecto es la primera vez que hace falta leer algo.
  */
 async function cloudGet(baseUrl, path, options = {}) {
+    return request("GET", baseUrl, path, undefined, options);
+}
+/** Para borrar lo que se subió: hoy, despublicar un panel. */
+async function cloudDelete(baseUrl, path, options = {}) {
+    return request("DELETE", baseUrl, path, undefined, options);
+}
+async function request(method, baseUrl, path, body, options) {
+    // Todas las llamadas a la cuenta pasan por aquí: con ESTELA_OFFLINE=1 no
+    // sale ninguna, y quien llama recibe un error que dice por qué.
+    if ((0, offline_js_1.isOffline)()) {
+        throw new CloudError((0, index_js_1.tr) `ESTELA_OFFLINE=1: Estela no se conecta a la red. Quita la variable para usar tu cuenta.`);
+    }
     let res;
     try {
         res = await fetch(`${baseUrl}${path}`, {
-            method: "GET",
+            method,
             headers: {
+                ...(body !== undefined ? { "content-type": "application/json" } : {}),
                 "estela-version": clientVersion,
                 // Para que la API conteste en el idioma de la terminal.
                 "x-estela-lang": (0, index_js_1.getLang)(),
                 ...(options.deviceToken ? { authorization: `Bearer ${options.deviceToken}` } : {}),
             },
+            ...(body !== undefined ? { body: JSON.stringify(body) } : {}),
         });
     }
     catch {
@@ -80,6 +71,9 @@ async function cloudGet(baseUrl, path, options = {}) {
     }
     const data = (await res.json().catch(() => ({})));
     if (!res.ok) {
+        // El status viaja aparte del mensaje: quien llama necesita distinguir
+        // "no tienes sesión" (401, pide login) de "cuota agotada" (402, pide
+        // upgrade) sin tener que analizar el texto en español.
         throw new CloudError(typeof data["error"] === "string" ? data["error"] : (0, index_js_1.tr) `Error ${res.status}`, res.status);
     }
     return data;

package/dist/db/store.d.ts

@@ -62,6 +62,8 @@ export interface Publication {
  */
 export declare function getPublicationToken(db: DatabaseSync, projectId: string): string | null;
 export declare function recordPublication(db: DatabaseSync, projectId: string, token: string, baseUrl: string | null, at?: Date): void;
+/** Tras despublicar: el proyecto deja de constar como publicado en esta máquina. */
+export declare function forgetPublication(db: DatabaseSync, token: string): void;
 /**
  * Estado de las publicaciones.
  *

package/dist/db/store.js

@@ -17,6 +17,7 @@ exports.getProjectAuthors = getProjectAuthors;
 exports.setProjectAuthors = setProjectAuthors;
 exports.getPublicationToken = getPublicationToken;
 exports.recordPublication = recordPublication;
+exports.forgetPublication = forgetPublication;
 exports.listPublications = listPublications;
 exports.authorsByRepo = authorsByRepo;
 exports.projectForRepo = projectForRepo;
@@ -246,6 +247,10 @@ function recordPublication(db, projectId, token, baseUrl, at = new Date()) {
       base_url = COALESCE(excluded.base_url, publications.base_url)
   `).run(projectId, token, iso(at), baseUrl);
 }
+/** Tras despublicar: el proyecto deja de constar como publicado en esta máquina. */
+function forgetPublication(db, token) {
+    db.prepare("DELETE FROM publications WHERE token = ?").run(token);
+}
 /**
  * Estado de las publicaciones.
  *

package/dist/export/panel.d.ts

@@ -83,5 +83,74 @@ export interface PanelTeamMember {
  * porque una caducidad que comprueba el navegador no protege de nada.
  */
 export declare function newPanelToken(): string;
+interface DayData {
+    date: string;
+    seconds: number;
+    items: {
+        what: string;
+        seconds: number;
+        kind: string;
+        amount: string | null;
+        commits: {
+            hash: string;
+            subject: string;
+        }[];
+    }[];
+}
 export declare function buildPanel(options: PanelOptions): string;
+/** Los datos que viajan dentro del panel: lo único que se publica de tu trabajo. */
+export type PanelData = ReturnType<typeof panelData>;
+/**
+ * Lo que va a quedar público, contado antes de subirlo.
+ *
+ * Sale de los mismos datos que se meten en el HTML, no de un cálculo aparte:
+ * un resumen que pudiera decir algo distinto de lo que se publica no
+ * protegería a nadie. `estela publish` lo enseña y pide confirmación.
+ */
+export declare function summarizePanel(data: PanelData): {
+    project: string;
+    client: string;
+    days: number;
+    blocks: number;
+    commitSubjects: number;
+    authors: string[];
+    branches: string[];
+    files: string[];
+    amounts: boolean;
+};
+export declare function panelData(options: PanelOptions): {
+    project: string;
+    client: string;
+    author: string | null;
+    generatedAt: string;
+    totalSeconds: number;
+    totalAmount: string | null;
+    days: DayData[];
+    features: {
+        name: string;
+        seconds: number;
+        days: number;
+        merged: boolean | null;
+        delivered: {
+            hash: string;
+            subject: string;
+        }[];
+        moreDelivered: number;
+    }[];
+    rhythm: {
+        activeDays: number;
+        spanDays: number;
+        medianSeconds: number;
+        longestGapDays: number;
+    };
+    rework: {
+        file: string;
+        touches: number;
+        spanDays: number;
+    }[];
+    open: import("../metrics/index.js").OpenWork[];
+    team: readonly PanelTeamMember[];
+    site: string;
+};
+export {};
 //# sourceMappingURL=panel.d.ts.map

package/dist/export/panel.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CREDIT_MARKER = void 0;
 exports.newPanelToken = newPanelToken;
 exports.buildPanel = buildPanel;
+exports.summarizePanel = summarizePanel;
+exports.panelData = panelData;
 const node_crypto_1 = require("node:crypto");
 const shared_1 = require("@estela/shared");
 const localize_js_1 = require("../billing/localize.js");
@@ -28,6 +30,50 @@ function shortPath(file) {
     return file.split("/").slice(-2).join("/");
 }
 function buildPanel(options) {
+    const data = panelData(options);
+    // El texto de interfaz va aparte de los datos, en su propio bloque: los datos
+    // son lo único que hay que vigilar de cerca (aquí no entra nada de IA ni de
+    // costes, y hay tests que lo comprueban), y mezclarlos con frases sueltas
+    // haría esa comprobación imposible de hacer sin falsos positivos.
+    const lang = (0, index_js_1.getLang)();
+    const ui = {
+        lang, L: panelLabels(), monthNames: dates_js_1.MONTHS[lang], dayNames: dates_js_1.DAYS[lang],
+        credit: options.hideCredit !== true,
+    };
+    return render(data, ui);
+}
+/**
+ * Lo que va a quedar público, contado antes de subirlo.
+ *
+ * Sale de los mismos datos que se meten en el HTML, no de un cálculo aparte:
+ * un resumen que pudiera decir algo distinto de lo que se publica no
+ * protegería a nadie. `estela publish` lo enseña y pide confirmación.
+ */
+function summarizePanel(data) {
+    const subjects = new Set();
+    const branches = new Set();
+    for (const day of data.days) {
+        for (const item of day.items)
+            for (const c of item.commits)
+                subjects.add(c.subject);
+    }
+    for (const f of data.features)
+        branches.add(f.name);
+    for (const o of data.open)
+        branches.add(o.name);
+    return {
+        project: data.project,
+        client: data.client,
+        days: data.days.length,
+        blocks: data.days.reduce((n, d) => n + d.items.length, 0),
+        commitSubjects: subjects.size,
+        authors: data.team.map((m) => m.name),
+        branches: [...branches].sort(),
+        files: data.rework.map((r) => r.file),
+        amounts: data.totalAmount !== null,
+    };
+}
+function panelData(options) {
     const { project, client, entries } = options;
     const showAmounts = options.withAmounts === true && options.rateAt !== undefined;
     const included = entries
@@ -104,16 +150,7 @@ function buildPanel(options) {
         team: options.team ?? [],
         site: (options.siteUrl ?? "https://getestela.dev").replace(/\/$/, ""),
     };
-    // El texto de interfaz va aparte de los datos, en su propio bloque: los datos
-    // son lo único que hay que vigilar de cerca (aquí no entra nada de IA ni de
-    // costes, y hay tests que lo comprueban), y mezclarlos con frases sueltas
-    // haría esa comprobación imposible de hacer sin falsos positivos.
-    const lang = (0, index_js_1.getLang)();
-    const ui = {
-        lang, L: panelLabels(), monthNames: dates_js_1.MONTHS[lang], dayNames: dates_js_1.DAYS[lang],
-        credit: options.hideCredit !== true,
-    };
-    return render(data, ui);
+    return data;
 }
 /**
  * Todo el texto fijo del panel, en el idioma en curso (`getLang()`).

package/dist/i18n/en.js

@@ -550,5 +550,32 @@ exports.EN = {
     "  {0} recuperadas de sesiones en subcarpetas y worktrees": "  {0} recovered from sessions in subfolders and worktrees",
     "{0} (sin proyecto)": "{0} (no project)",
     "\n{0} de esos bloques son de subcarpetas o worktrees de un proyecto: estela import --yes los imputa.": "\n{0} of those blocks are from a project's subfolders or worktrees: estela import --yes assigns them.",
+    // ── publish: resumen antes de subir, y unpublish ──
+    "No se ha publicado nada. Sin terminal no se puede confirmar: añade --yes para publicar.": "Nothing was published. Without a terminal there's no way to confirm: add --yes to publish.",
+    "¿Publicar? [s/N] ": "Publish? [y/N] ",
+    "\nNo se ha publicado nada.": "\nNothing was published.",
+    "{0} y {1} más": "{0} and {1} more",
+    "\nEsto va a quedar público. Quien tenga el enlace lo ve todo:\n": "\nThis will become public. Anyone with the link sees all of it:\n",
+    "Trabajo": "Work",
+    "{0} días, {1} bloques, {2} mensajes de commit": "{0} days, {1} blocks, {2} commit messages",
+    "Autores": "Authors",
+    "Ramas": "Branches",
+    "Ficheros": "Files",
+    "Importes": "Amounts",
+    "sí (--with-amounts)": "yes (--with-amounts)",
+    "no": "no",
+    "Clientes": "Clients",
+    "{0} (recibirán un correo)": "{0} (they'll get an email)",
+    "No tienes ningún panel publicado.": "You have no published dashboards.",
+    "No se ha despublicado nada. Sin terminal no se puede confirmar: añade --yes.": "Nothing was unpublished. Without a terminal there's no way to confirm: add --yes.",
+    "\n¿Despublicar estos {0} paneles? Los enlaces dejarán de funcionar. [s/N] ": "\nUnpublish these {0} dashboards? The links will stop working. [y/N] ",
+    "\nNo se ha despublicado nada.": "\nNothing was unpublished.",
+    "\n{0} paneles despublicados. Sus enlaces ya no funcionan.": "\n{0} dashboards unpublished. Their links no longer work.",
+    "Tus paneles publicados:\n": "Your published dashboards:\n",
+    "\nPara despublicar uno: estela unpublish <proyecto o token>. Todos: estela unpublish --all": "\nTo unpublish one: estela unpublish <project or token>. All of them: estela unpublish --all",
+    "Panel de {0} despublicado. El enlace ya no funciona.": "{0} dashboard unpublished. The link no longer works.",
+    "No hay ningún panel publicado de \"{0}\". Míralos con: estela unpublish": "There's no published dashboard for \"{0}\". See them with: estela unpublish",
+    // ── ESTELA_OFFLINE ──
+    "ESTELA_OFFLINE=1: Estela no se conecta a la red. Quita la variable para usar tu cuenta.": "ESTELA_OFFLINE=1: Estela doesn't connect to the network. Unset it to use your account.",
 };
 //# sourceMappingURL=en.js.map

package/dist/offline.d.ts

@@ -0,0 +1,10 @@
+/**
+ * `ESTELA_OFFLINE=1`: Estela no abre ninguna conexión de red. Ni la
+ * comprobación de versión, ni el banner del panel local, ni nada de la cuenta
+ * (login, sync, Teams, paneles, pagos). Todo lo local sigue igual.
+ *
+ * Es el interruptor general; `ESTELA_NO_UPDATE_CHECK=1` apaga solo la
+ * comprobación de versión.
+ */
+export declare function isOffline(env?: NodeJS.ProcessEnv): boolean;
+//# sourceMappingURL=offline.d.ts.map

package/dist/offline.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isOffline = isOffline;
+/**
+ * `ESTELA_OFFLINE=1`: Estela no abre ninguna conexión de red. Ni la
+ * comprobación de versión, ni el banner del panel local, ni nada de la cuenta
+ * (login, sync, Teams, paneles, pagos). Todo lo local sigue igual.
+ *
+ * Es el interruptor general; `ESTELA_NO_UPDATE_CHECK=1` apaga solo la
+ * comprobación de versión.
+ */
+function isOffline(env = process.env) {
+    const v = env["ESTELA_OFFLINE"];
+    return v !== undefined && v !== "" && v !== "0";
+}
+//# sourceMappingURL=offline.js.map

package/dist/publish.d.ts

@@ -1,4 +1,5 @@
 import type { DatabaseSync } from "node:sqlite";
+import { summarizePanel } from "./export/panel.js";
 import { type Lang } from "./i18n/index.js";
 /**
  * Publica un panel, alojado en la cuenta vinculada.
@@ -36,10 +37,47 @@ export interface PublishOptions {
     /** Sin la línea "Horas rellenadas por Estela" del pie. Solo Pro y Teams: el servidor lo comprueba. */
     readonly hideCredit?: boolean;
 }
+/** Lo que va a quedar público al subir el panel, para enseñarlo antes. */
+export type PanelSummary = ReturnType<typeof summarizePanel> & {
+    /** Correos del cliente que recibirán acceso y un aviso por correo. */
+    readonly clients: readonly string[];
+};
+/** Un panel ya construido, a falta de subirlo. */
+export interface PreparedPanel {
+    readonly projectId: string;
+    readonly projectName: string;
+    readonly token: string;
+    readonly html: string;
+    readonly summary: PanelSummary;
+    readonly clients?: readonly string[];
+    readonly hideCredit: boolean;
+}
 export interface PublishResult {
     readonly token: string;
     readonly url: string;
     readonly adopted: boolean;
 }
 export declare function publishPanel(db: DatabaseSync, options: PublishOptions): Promise<PublishResult>;
+/**
+ * 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`.
+ */
+export declare function preparePanel(db: DatabaseSync, options: PublishOptions): Promise<PreparedPanel>;
+export declare function uploadPanel(db: DatabaseSync, panel: PreparedPanel): Promise<PublishResult>;
+/** Un panel publicado en tu cuenta, tal como lo lista el servidor. */
+export interface PublishedPanel {
+    readonly token: string;
+    readonly projectName: string;
+    readonly projectId: string | null;
+}
+/**
+ * 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.
+ */
+export declare function unpublishPanel(db: DatabaseSync, target: string): Promise<PublishedPanel>;
+/** Despublica todos los paneles de la cuenta. Devuelve los que quitó. */
+export declare function unpublishAll(db: DatabaseSync): Promise<PublishedPanel[]>;
+export declare function listPublishedPanels(db: DatabaseSync): Promise<PublishedPanel[]>;
 //# sourceMappingURL=publish.d.ts.map