estela 0.2.2 → 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
@@ -319,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

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/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.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",

package/web/app.js

@@ -1213,6 +1213,8 @@ function wireProjects() {
     });
   });
 
+  // Publicar va en dos pasos, como en la terminal: primero lo que va a quedar
+  // público (autores, ramas, ficheros, correos), y solo al confirmar se sube.
   document.querySelectorAll(".share-btn").forEach((btn) => {
     btn.addEventListener("click", async () => {
       const card = btn.closest(".pcard");
@@ -1220,54 +1222,91 @@ function wireProjects() {
       const out = card.querySelector(".share-out");
       btn.disabled = true;
       try {
-        // El token ya vive en la base de datos local (una fila por proyecto,
-        // se lee de state.projects.publications): guardarlo también en
-        // localStorage sería una segunda copia que puede desincronizarse de
-        // la real, y lo hizo — un token de una prueba vieja en el navegador
-        // pisó el que de verdad estaba publicado.
         const known = state.projects?.publications?.find((p) => p.projectId === projectId);
-        const r = await api("/api/publish", {
+        const { summary: s } = await api("/api/publish", {
           method: "POST",
-          body: JSON.stringify({ projectId, token: known?.token || "" }),
+          body: JSON.stringify({ projectId, token: known?.token || "", preview: true }),
         });
-
+        const list = (items) => items.length ? items.map(esc).join(", ") : "—";
+        const row = (label, value) => '<p class="share-line">' + label + ' ' + value + '</p>';
         out.hidden = false;
         out.innerHTML =
-          '<p class="share-line"><b>' + (r.adopted ? tr("publish.linked") : tr("publish.published")) +
-          '</b></p>' +
-          '<p class="share-line">' + tr("publish.link") + ' <code>' + esc(r.url) + '</code></p>' +
-          '<p class="share-warn">' + tr("publish.noPassword") + '</p>';
-        toast(r.adopted ? tr("toast.linkedToAccount") : tr("publish.published"));
-
-        // Publicar pone a cero los "bloques nuevos desde que lo publicaste",
-        // pero ese número vive en `state`, que se quedaba con el valor de
-        // antes: el aviso seguía ahí después de resolverlo, y solo se iba
-        // recargando la página a mano. Se vuelve a pedir el estado y se
-        // repinta, conservando el mensaje del enlace recién generado.
-        const recien = out.innerHTML;
-        await loadProjects();
-        const card2 = document.querySelector(`.pcard[data-project="${CSS.escape(projectId)}"]`);
-        const out3 = card2?.querySelector(".share-out");
-        if (out3) { out3.hidden = false; out3.innerHTML = recien; }
+          '<p class="share-line"><b>' + tr("publish.preview.title") + '</b></p>' +
+          row(tr("publish.preview.project"), esc(s.project) + " · " + esc(s.client)) +
+          row(tr("publish.preview.authors"), list(s.authors)) +
+          row(tr("publish.preview.branches"), list(s.branches)) +
+          row(tr("publish.preview.files"), list(s.files)) +
+          row(tr("publish.preview.clients"), list(s.clients)) +
+          '<p class="share-warn">' + tr("publish.noPassword") + '</p>' +
+          '<p><button type="button" class="chip share-confirm">' + tr("publish.preview.confirm") + '</button> ' +
+          '<button type="button" class="chip share-cancel">' + tr("publish.preview.cancel") + '</button></p>';
+        out.querySelector(".share-cancel").addEventListener("click", () => { out.hidden = true; out.innerHTML = ""; });
+        out.querySelector(".share-confirm").addEventListener("click", (e) => {
+          e.currentTarget.disabled = true;
+          publishNow(card, btn);
+        });
       } catch (error) {
-        const out2 = card.querySelector(".share-out");
-        // "Sin cuenta" no es un error cualquiera: se enseña con el comando
-        // exacto para resolverlo, no como un aviso genérico que hay que
-        // interpretar. `needsLogin` viaja en el cuerpo desde /api/publish.
-        if (error.body?.needsLogin) {
-          out2.hidden = false;
-          out2.innerHTML =
-            '<p class="share-line"><b>' + tr("publish.needsLogin.title") + '</b></p>' +
-            '<p class="share-line">' + tr("publish.needsLogin.why") + '</p>' +
-            '<code class="cmd">' + tr("publish.needsLogin.cmd") + '</code>' +
-            '<p class="share-warn">' + tr("publish.needsLogin.once") + '</p>';
-        } else {
-          toast(error.message);
-        }
+        showPublishError(card, error);
       } finally { btn.disabled = false; }
     });
   });
 
+  async function publishNow(card, btn) {
+    const projectId = card.dataset.project;
+    const out = card.querySelector(".share-out");
+    btn.disabled = true;
+    try {
+      // El token ya vive en la base de datos local (una fila por proyecto,
+      // se lee de state.projects.publications): guardarlo también en
+      // localStorage sería una segunda copia que puede desincronizarse de
+      // la real, y lo hizo — un token de una prueba vieja en el navegador
+      // pisó el que de verdad estaba publicado.
+      const known = state.projects?.publications?.find((p) => p.projectId === projectId);
+      const r = await api("/api/publish", {
+        method: "POST",
+        body: JSON.stringify({ projectId, token: known?.token || "" }),
+      });
+
+      out.hidden = false;
+      out.innerHTML =
+        '<p class="share-line"><b>' + (r.adopted ? tr("publish.linked") : tr("publish.published")) +
+        '</b></p>' +
+        '<p class="share-line">' + tr("publish.link") + ' <code>' + esc(r.url) + '</code></p>' +
+        '<p class="share-warn">' + tr("publish.noPassword") + '</p>';
+      toast(r.adopted ? tr("toast.linkedToAccount") : tr("publish.published"));
+
+      // Publicar pone a cero los "bloques nuevos desde que lo publicaste",
+      // pero ese número vive en `state`, que se quedaba con el valor de
+      // antes: el aviso seguía ahí después de resolverlo, y solo se iba
+      // recargando la página a mano. Se vuelve a pedir el estado y se
+      // repinta, conservando el mensaje del enlace recién generado.
+      const recien = out.innerHTML;
+      await loadProjects();
+      const card2 = document.querySelector(`.pcard[data-project="${CSS.escape(projectId)}"]`);
+      const out3 = card2?.querySelector(".share-out");
+      if (out3) { out3.hidden = false; out3.innerHTML = recien; }
+    } catch (error) {
+      showPublishError(card, error);
+    } finally { btn.disabled = false; }
+  }
+
+  function showPublishError(card, error) {
+    const out2 = card.querySelector(".share-out");
+    // "Sin cuenta" no es un error cualquiera: se enseña con el comando
+    // exacto para resolverlo, no como un aviso genérico que hay que
+    // interpretar. `needsLogin` viaja en el cuerpo desde /api/publish.
+    if (error.body?.needsLogin) {
+      out2.hidden = false;
+      out2.innerHTML =
+        '<p class="share-line"><b>' + tr("publish.needsLogin.title") + '</b></p>' +
+        '<p class="share-line">' + tr("publish.needsLogin.why") + '</p>' +
+        '<code class="cmd">' + tr("publish.needsLogin.cmd") + '</code>' +
+        '<p class="share-warn">' + tr("publish.needsLogin.once") + '</p>';
+    } else {
+      toast(error.message);
+    }
+  }
+
   document.querySelectorAll(".rateform").forEach((form) => {
     form.addEventListener("submit", async (e) => {
       e.preventDefault();

package/web/i18n.js

@@ -280,6 +280,14 @@
       "publish.published": "Panel publicado",
       "publish.link": "Enlace:",
       "publish.noPassword": "Quien tenga el enlace, entra: no hay contraseña.",
+      "publish.preview.title": "Esto va a quedar público. Quien tenga el enlace lo ve todo:",
+      "publish.preview.project": "Proyecto:",
+      "publish.preview.authors": "Autores:",
+      "publish.preview.branches": "Ramas:",
+      "publish.preview.files": "Ficheros:",
+      "publish.preview.clients": "Clientes:",
+      "publish.preview.confirm": "Publicar",
+      "publish.preview.cancel": "Cancelar",
       "publish.needsLogin.title": "Hace falta vincular una cuenta",
       "publish.needsLogin.why": "Publicar aloja el panel en getestela.dev, y eso exige sesión:",
       "publish.needsLogin.cmd": "estela login --email tu@correo.com",
@@ -577,6 +585,14 @@
       "publish.published": "Panel published",
       "publish.link": "Link:",
       "publish.noPassword": "Anyone with the link can get in: there's no password.",
+      "publish.preview.title": "This will become public. Anyone with the link sees all of it:",
+      "publish.preview.project": "Project:",
+      "publish.preview.authors": "Authors:",
+      "publish.preview.branches": "Branches:",
+      "publish.preview.files": "Files:",
+      "publish.preview.clients": "Clients:",
+      "publish.preview.confirm": "Publish",
+      "publish.preview.cancel": "Cancel",
       "publish.needsLogin.title": "You need to link an account",
       "publish.needsLogin.why": "Publishing hosts the panel on getestela.dev, which requires signing in:",
       "publish.needsLogin.cmd": "estela login --email you@example.com",