estela 0.1.3 → 0.1.6

package/dist/cli.js

@@ -54,10 +54,14 @@ const doctor_js_1 = require("./doctor.js");
 const setup_js_1 = require("./setup.js");
 const csv_js_1 = require("./export/csv.js");
 const invoice_pdf_js_1 = require("./export/invoice-pdf.js");
-const panel_js_1 = require("./export/panel.js");
 const share_js_1 = require("./export/share.js");
 const server_js_1 = require("./server.js");
 const updateCheck_js_1 = require("./updateCheck.js");
+const publish_js_1 = require("./publish.js");
+const sync_js_1 = require("./sync.js");
+const team_js_1 = require("./sync/team.js");
+const team_js_2 = require("./team.js");
+const billing_js_1 = require("./billing.js");
 const auth_js_1 = require("./cloud/auth.js");
 const client_js_1 = require("./cloud/client.js");
 const cost_js_1 = require("./pricing/cost.js");
@@ -65,7 +69,6 @@ Object.defineProperty(exports, "breakdownOfTurn", { enumerable: true, get: funct
 const claude_js_1 = require("./watchers/claude.js");
 const git_js_1 = require("./watchers/git.js");
 const identity_js_1 = require("./watchers/identity.js");
-const team_js_1 = require("./metrics/team.js");
 const HELP = `
 estela — registro de horas para desarrollo asistido por IA
 
@@ -121,6 +124,35 @@ estela — registro de horas para desarrollo asistido por IA
   estela logout
         Desvincula esta máquina. Tus datos locales no se tocan.
 
+  estela sync enable --project <id>
+        Activa el sync de un proyecto entre tus máquinas. Función de Pro; sin
+        una fila aquí, ese proyecto no sale de esta máquina nunca.
+  estela sync [--project <id>]
+        Sube y baja lo cambiado desde el último sync. Sin --project,
+        sincroniza todos los proyectos activados (personales y de equipo).
+
+  estela team invite --project <id> --email <a@b.com>[,otro@c.com] [--kind employee|freelancer]
+        Invita a alguien a que sus horas en ese proyecto se midan de verdad
+        en el panel, en vez de estimarse por commits. Función de Teams. Los
+        correos son los de commit del invitado, no con los que se loguee.
+  estela team accept --token <token> --as-id <id-local>
+        Acepta una invitación. Crea el proyecto local con ese id (tuyo, no
+        el del dueño) y lo deja listo para sincronizar.
+  estela team repo --project <id> --add <ruta>
+        Vincula tu clon local a un proyecto de equipo ya aceptado.
+  estela team list --project <id>
+        Quién ha aceptado, sus horas medidas, y cuándo sincronizó por última vez.
+  estela team revoke --token <token>
+        Quita a alguien del equipo. Si pagas Teams, baja lo que se cobra.
+
+  estela upgrade --plan pro|teams
+        Da de alta el plan. Imprime un enlace de Stripe Checkout — el pago
+        se completa ahí, nunca en la terminal.
+  estela billing portal
+        Cambiar de tarjeta o cancelar. Lo hace Stripe, no nosotros.
+  estela account
+        Tu correo, tu plan, y desde qué máquinas te has conectado.
+
   estela export --project <id> [--out <fichero.csv>]
 
   estela report --project <id> --cutoff YYYY-MM-DD [--dry-run]
@@ -334,7 +366,11 @@ async function cmdImport(args, dbPath) {
         const fromAgents = (0, sessionize_js_1.attachCommits)((0, sessionize_js_1.sessionize)(turns), commitsAll);
         const fromCommits = (0, sessionize_js_1.withoutOverlap)((0, sessionize_js_1.sessionizeCommits)(commitsAll), fromAgents);
         const raw = [...fromAgents, ...fromCommits];
-        const blocks = (0, sessionize_js_1.groupByBranchAndDay)(raw);
+        // Se agrupa por PROYECTO, no por ruta: el agente abierto en `repo/` y en
+        // `repo/src/UI` son dos rutas del mismo proyecto, y agrupar por ruta
+        // producía dos bloques que luego se pisaban al guardarse con el mismo id.
+        const porProyecto = (b) => (b.repoPath ? store.projectForRepo(db, b.repoPath) ?? b.repoPath : "");
+        const blocks = (0, sessionize_js_1.groupByBranchAndDay)(raw, porProyecto);
         if (fromCommits.length) {
             console.log(`  ${fromCommits.length} bloques deducidos solo de commits (sin agente)`);
         }
@@ -699,95 +735,296 @@ async function cmdPublish(args, dbPath) {
     const db = (0, schema_js_1.openDatabase)(dbPath);
     try {
         const projectId = required(args, "project");
-        const project = store.getProject(db, projectId);
-        if (!project)
+        // Sin --client no se manda nada, y el servidor deja intacta la lista que
+        // ya hubiera: republicar el avance de la semana no puede desvincular al
+        // cliente que ya tenía este panel en su cuenta.
+        const clientes = str(args, "client")
+            ?.split(",").map((e) => e.trim()).filter(Boolean);
+        let result;
+        try {
+            result = await (0, publish_js_1.publishPanel)(db, {
+                projectId,
+                ...(str(args, "token") ? { token: str(args, "token") } : {}),
+                ...(str(args, "author") ? { authorName: str(args, "author") } : {}),
+                ...(clientes?.length ? { clients: clientes } : {}),
+                withAmounts: args.flags["with-amounts"] === true,
+                includeTeam: args.flags["no-team"] !== true,
+            });
+        }
+        catch (error) {
+            if (error instanceof publish_js_1.NoAccountError)
+                throw new UserError(error.message);
+            throw error;
+        }
+        console.log(`\nPanel publicado.\n`);
+        console.log(`  Enlace: ${result.url}\n`);
+        if (result.adopted) {
+            console.log(`  Este panel ya existía y queda vinculado a tu cuenta desde ahora.\n`);
+        }
+        if (clientes?.length) {
+            console.log(`  Compartido con: ${clientes.join(", ")}`);
+            console.log(`  Al entrar en getestela.dev/app con ese correo, lo verán ahí.\n`);
+        }
+        console.log(`  El token es lo único que protege la página: quien tenga el enlace, entra.`);
+        console.log(`  Al republicar, pasa --token ${result.token} o el cliente perderá su enlace.`);
+    }
+    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
+ * cual sea el plan de la cuenta.
+ */
+function cmdSyncEnable(args, dbPath) {
+    const db = (0, schema_js_1.openDatabase)(dbPath);
+    try {
+        const projectId = required(args, "project");
+        if (!store.getProject(db, projectId)) {
             throw new UserError(`No existe el proyecto "${projectId}".`);
-        const client = store.getClient(db, project.clientId);
-        const rates = store.getRates(db, projectId);
-        // Reutilizar el token si se republica: el cliente ya tiene ese enlace
-        // guardado y cambiárselo sin avisar le rompe el marcador.
-        const token = str(args, "token") ?? (0, panel_js_1.newPanelToken)();
-        // Las métricas necesitan los commits del proyecto y saber qué ramas están
-        // integradas. Sin lo segundo no se puede distinguir entregado de en curso.
-        const projectCommits = commitsOfProject(db, project.repoPaths);
-        const merged = project.repoPaths[0]
-            ? await (0, git_js_1.mergedBranches)(project.repoPaths[0]) : null;
-        // El equipo del proyecto. Se enseña porque el repositorio es del cliente y
-        // esos nombres ya los tiene en su git; lo que no sale de aquí son las horas
-        // ajenas, que se quitan ANTES de construir el fichero. Ocultarlas al pintar
-        // dejaría el dato en el código fuente, que es no ocultarlas.
-        const myEntries = store.getTimeEntries(db, projectId);
-        const mineByRepo = await (0, identity_js_1.myEmailsByRepo)(db, project.repoPaths);
-        const myEmails = new Set();
-        for (const set of mineByRepo.values())
-            for (const email of set)
-                myEmails.add(email);
-        // Acotado al periodo que cubre el panel. Sin esto se compara el historial
-        // entero del repositorio con las semanas que llevas tú: salían 523 commits
-        // de un compañero frente a 11 tuyos, y el panel que venía a respaldar tu
-        // trabajo te dejaba a la altura del betún. Además mete gente que ya no está
-        // en el proyecto.
-        const worked = myEntries.map((e) => (0, shared_1.localDate)(e.startedAt)).sort((a, b) => a.localeCompare(b));
-        const from = worked[0] ?? "0000-01-01";
-        const to = worked[worked.length - 1] ?? "9999-12-31";
-        const inPeriod = projectCommits.filter((c) => {
-            const day = (0, shared_1.localDate)(c.at);
-            return day >= from && day <= to;
-        });
-        const team = (0, team_js_1.teamView)(inPeriod, { myEmails, myEntries }).map((p) => ({
-            name: p.name,
-            isMe: p.isMe,
-            ...(p.isMe ? { seconds: p.seconds } : {}),
-            commits: p.commits,
-            branches: p.branches.length,
-            lastDay: p.lastDay,
-        }));
-        const html = (0, panel_js_1.buildPanel)({
-            project, client,
-            entries: myEntries,
-            ...(args.flags["no-team"] === true ? {} : { team }),
-            ...(str(args, "author") ? { authorName: str(args, "author") } : {}),
-            withAmounts: args.flags["with-amounts"] === true,
-            rateAt: (at) => (0, invoice_js_1.rateAt)(rates, projectId, at),
-            aiPayer: "self",
-            commits: projectCommits,
-            ...(merged ? { merged } : {}),
-            commitsOf: (hashes) => hashes.length
-                ? db.prepare(`SELECT hash, subject FROM commits WHERE hash IN (${hashes.map(() => "?").join(",")})`).all(...hashes)
-                : [],
+        }
+        if (!store.listPersonalSyncCandidates(db).includes(projectId)) {
+            throw new UserError(`"${projectId}" ya está enlazado a un equipo y no puede sincronizarse también como personal.`);
+        }
+        store.setProjectSync(db, {
+            projectId, scope: "personal", remoteProjectId: projectId,
+            remoteOrgId: null, inviteToken: null,
         });
-        // 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.
+        console.log(`Sync activado para "${projectId}". Ejecuta "estela sync" para subir y bajar.`);
+    }
+    finally {
+        db.close();
+    }
+}
+/** `estela sync [--project <id>]` — sin --project, sincroniza todos los proyectos habilitados. */
+async function cmdSync(args, dbPath) {
+    const db = (0, schema_js_1.openDatabase)(dbPath);
+    try {
+        const only = str(args, "project");
+        const projectIds = only ? [only] : store.listProjectSyncs(db).map((s) => s.projectId);
+        if (projectIds.length === 0) {
+            console.log(`Ningún proyecto sincroniza todavía. Actívalo con: estela sync enable --project <id>`);
+            return;
+        }
+        for (const projectId of projectIds) {
+            const project = store.getProject(db, projectId);
+            const label = project?.name ?? projectId;
+            const scope = store.getProjectSync(db, projectId)?.scope;
+            try {
+                if (scope === "team") {
+                    const outcome = await (0, team_js_1.syncTeamProject)(db, projectId);
+                    console.log(`${label}: ${(0, shared_1.formatDuration)(outcome.seconds)} totales enviadas`);
+                }
+                else {
+                    const outcome = await (0, sync_js_1.syncProject)(db, projectId);
+                    console.log(`${label}: ${outcome.pushed} subidas, ${outcome.pulled} bajadas`);
+                }
+            }
+            catch (error) {
+                if (error instanceof publish_js_1.NoAccountError || error instanceof sync_js_1.NotSyncedError)
+                    throw new UserError(error.message);
+                throw error;
+            }
+        }
+    }
+    finally {
+        db.close();
+    }
+}
+/**
+ * `estela team invite --project <id> --email <a@b,c@d> [--kind employee|freelancer]`
+ *
+ * Los correos son los de commit de quien se invita, no con los que se vaya a
+ * loguear en Estela — es el mismo criterio que ya usa "estela author" para
+ * la propia identidad, y es lo que permite emparejarlo en el panel.
+ */
+async function cmdTeamInvite(args, dbPath) {
+    const db = (0, schema_js_1.openDatabase)(dbPath);
+    try {
+        const projectId = required(args, "project");
+        const emails = required(args, "email").split(",").map((e) => e.trim()).filter(Boolean);
+        const kind = (str(args, "kind") ?? "employee");
+        if (kind !== "employee" && kind !== "freelancer") {
+            throw new UserError(`--kind debe ser "employee" o "freelancer".`);
+        }
+        let result;
+        try {
+            result = await (0, team_js_2.inviteTeamMember)(db, { projectId, emails, inviteeKind: kind });
+        }
+        catch (error) {
+            if (error instanceof publish_js_1.NoAccountError)
+                throw new UserError(error.message);
+            throw error;
+        }
+        console.log(`\nInvitación creada para: ${emails.join(", ")}\n`);
+        console.log(`  Pásale esto (por el canal que uses con él, no hace falta correo):\n`);
+        console.log(`    estela login --email <su-correo>`);
+        console.log(`    estela team accept --token ${result.token} --as-id <id-que-elija>\n`);
+    }
+    finally {
+        db.close();
+    }
+}
+/**
+ * `estela team accept --token <token> --as-id <id-local>`
+ *
+ * El id local es obligatorio y nunca se autogenera: reusar el id del dueño
+ * tal cual podría pisar en silencio un proyecto propio que ya tuviera ese
+ * mismo id.
+ */
+async function cmdTeamAccept(args, dbPath) {
+    const db = (0, schema_js_1.openDatabase)(dbPath);
+    try {
+        const token = required(args, "token");
+        const localProjectId = required(args, "as-id");
+        let result;
+        try {
+            result = await (0, team_js_2.acceptTeamInvite)(db, { token, localProjectId });
+        }
+        catch (error) {
+            if (error instanceof publish_js_1.NoAccountError)
+                throw new UserError(error.message);
+            throw error;
+        }
+        console.log(`\nInvitación aceptada: "${result.projectName}"`);
+        console.log(`  Declarada para: ${result.emails.join(", ")} (${result.inviteeKind})`);
+        console.log(`  Si no eres tú, avisa a quien te invitó.\n`);
+        console.log(`Ahora vincula tu repositorio local y sincroniza:\n`);
+        console.log(`  estela team repo --project ${localProjectId} --add <ruta-de-tu-clon>`);
+        console.log(`  estela import`);
+        console.log(`  estela sync\n`);
+    }
+    finally {
+        db.close();
+    }
+}
+/** `estela team repo --project <id> --add <ruta>` — solo añade el repositorio, nada más. */
+function cmdTeamRepo(args, dbPath) {
+    const db = (0, schema_js_1.openDatabase)(dbPath);
+    try {
+        const projectId = required(args, "project");
+        const repo = required(args, "add");
+        if (!store.getProject(db, projectId))
+            throw new UserError(`No existe el proyecto "${projectId}".`);
+        store.addProjectRepo(db, projectId, (0, node_path_1.resolve)(repo));
+        console.log(`Repositorio vinculado a "${projectId}": ${(0, node_path_1.resolve)(repo)}`);
+    }
+    finally {
+        db.close();
+    }
+}
+/** `estela team list --project <id>` — miembros aceptados, sus horas, y cuándo sincronizaron. */
+async function cmdTeamList(args, dbPath) {
+    const db = (0, schema_js_1.openDatabase)(dbPath);
+    try {
+        const projectId = required(args, "project");
+        let members;
+        try {
+            members = await (0, team_js_2.listTeamMembers)(db, projectId);
+        }
+        catch (error) {
+            if (error instanceof publish_js_1.NoAccountError)
+                throw new UserError(error.message);
+            throw error;
+        }
+        if (members.length === 0) {
+            console.log(`Nadie ha aceptado todavía en "${projectId}".`);
+            return;
+        }
+        for (const m of members) {
+            const synced = m.syncedAt ? `sincronizado ${m.syncedAt.slice(0, 10)}` : "sin sincronizar aún";
+            console.log(`  ${m.emails.join(", ")} (${m.inviteeKind}) · ${(0, shared_1.formatDuration)(m.seconds)} · ${synced}`);
+        }
+    }
+    finally {
+        db.close();
+    }
+}
+/** `estela team revoke --token <token>` — también baja la cantidad de la suscripción de Teams. */
+async function cmdTeamRevoke(args, dbPath) {
+    const db = (0, schema_js_1.openDatabase)(dbPath);
+    try {
+        const token = required(args, "token");
+        try {
+            await (0, team_js_2.revokeTeamMember)(db, token);
+        }
+        catch (error) {
+            if (error instanceof publish_js_1.NoAccountError)
+                throw new UserError(error.message);
+            throw error;
+        }
+        console.log(`Invitación revocada.`);
+    }
+    finally {
+        db.close();
+    }
+}
+/** `estela upgrade --plan pro|teams` — imprime la URL de Checkout, no la abre. */
+async function cmdUpgrade(args, dbPath) {
+    const db = (0, schema_js_1.openDatabase)(dbPath);
+    try {
+        const plan = required(args, "plan");
+        if (plan !== "pro" && plan !== "teams")
+            throw new UserError(`--plan debe ser "pro" o "teams".`);
+        let result;
+        try {
+            result = await (0, billing_js_1.upgradeCheckout)(db, plan);
+        }
+        catch (error) {
+            if (error instanceof publish_js_1.NoAccountError)
+                throw new UserError(error.message);
+            throw error;
+        }
+        console.log(`\nAbre esto para completar el alta a ${plan === "pro" ? "Pro" : "Teams"}:\n`);
+        console.log(`  ${result.url}\n`);
+    }
+    finally {
+        db.close();
+    }
+}
+/** `estela billing portal` — cancelar o cambiar de tarjeta pasa en la página de Stripe. */
+async function cmdBillingPortal(dbPath) {
+    const db = (0, schema_js_1.openDatabase)(dbPath);
+    try {
+        let result;
+        try {
+            result = await (0, billing_js_1.openBillingPortal)(db);
+        }
+        catch (error) {
+            if (error instanceof publish_js_1.NoAccountError)
+                throw new UserError(error.message);
+            throw error;
+        }
+        console.log(`\nGestiona tu pago aquí:\n\n  ${result.url}\n`);
+    }
+    finally {
+        db.close();
+    }
+}
+/** `estela account` — primer consumidor real de GET /account. */
+async function cmdAccount(dbPath) {
+    const db = (0, schema_js_1.openDatabase)(dbPath);
+    try {
         const account = store.getCloudAccount(db);
         if (!account) {
-            throw new UserError(`Necesitas una cuenta para publicar. Vincúlala con:\n\n` +
+            throw new UserError(`Esta máquina no está vinculada a ninguna cuenta. Vincúlala con:\n\n` +
                 `  estela login --email tu@correo.com\n`);
         }
-        let result;
+        let info;
         try {
-            result = await (0, client_js_1.cloudPost)(account.apiBaseUrl, "/panels", { token, projectName: project.name, html }, { deviceToken: account.deviceToken });
+            info = await (0, client_js_1.cloudGet)(account.apiBaseUrl, "/account", { deviceToken: account.deviceToken });
         }
         catch (error) {
-            if (error instanceof client_js_1.CloudError && error.status === 402) {
-                // El mensaje ya viene redactado desde el servidor (panels.ts): es la
-                // única fuente de la verdad sobre cuántos paneles permite cada plan,
-                // y duplicar ese texto aquí lo desincronizaría en cuanto cambiara allí.
-                throw new UserError(error.message);
-            }
             if (error instanceof client_js_1.CloudError && error.status === 401) {
-                throw new UserError(`Tu sesión ya no vale. Vuelve a vincular la máquina:\n\n` +
-                    `  estela login --email tu@correo.com\n`);
+                throw new UserError(`Tu sesión ya no vale. Vuelve a vincular la máquina:\n\n  estela login --email tu@correo.com\n`);
             }
             throw error;
         }
-        store.recordPublication(db, projectId, token, "https://getestela.dev");
-        console.log(`\nPanel publicado.\n`);
-        console.log(`  Enlace: ${result.url}\n`);
-        if (result.adopted) {
-            console.log(`  Este panel ya existía y queda vinculado a tu cuenta desde ahora.\n`);
+        console.log(`\n${info.email} · plan ${info.plan}\n`);
+        for (const d of info.devices) {
+            console.log(`  ${d.label ?? "(sin nombre)"} · v${d.clientVersion ?? "?"} · visto ${d.lastSeenAt?.slice(0, 10) ?? "nunca"}`);
         }
-        console.log(`  El token es lo único que protege la página: quien tenga el enlace, entra.`);
-        console.log(`  Al republicar, pasa --token ${token} o el cliente perderá su enlace.`);
     }
     finally {
         db.close();
@@ -831,21 +1068,6 @@ async function cmdAuthor(args, dbPath) {
     }
 }
 /** Commits de los repositorios de un proyecto, con sus ficheros. */
-function commitsOfProject(db, repoPaths) {
-    if (repoPaths.length === 0)
-        return [];
-    const like = repoPaths.map(() => "repo_path LIKE ?").join(" OR ");
-    const rows = db.prepare(`SELECT * FROM commits WHERE ${like}`)
-        .all(...repoPaths.map((p) => `${p}%`));
-    return rows.map((r) => ({
-        repoPath: r["repo_path"], hash: r["hash"],
-        at: new Date(r["at"]), authorEmail: r["author_email"],
-        authorName: r["author_name"] ?? "",
-        branch: r["branch"] ?? null, subject: r["subject"],
-        linesAdded: r["lines_added"], linesDeleted: r["lines_deleted"],
-        files: String(r["files"] ?? "").split("\n").filter(Boolean),
-    }));
-}
 /** Revisa los datos y avisa de lo que rompería una demo. */
 function cmdDoctor(dbPath) {
     const db = (0, schema_js_1.openDatabase)(dbPath);
@@ -1111,6 +1333,36 @@ async function main() {
         case "logout":
             await cmdLogout(dbPath);
             break;
+        case "sync enable":
+            cmdSyncEnable(args, dbPath);
+            break;
+        case "sync":
+            await cmdSync(args, dbPath);
+            break;
+        case "team invite":
+            await cmdTeamInvite(args, dbPath);
+            break;
+        case "team accept":
+            await cmdTeamAccept(args, dbPath);
+            break;
+        case "team repo":
+            cmdTeamRepo(args, dbPath);
+            break;
+        case "team list":
+            await cmdTeamList(args, dbPath);
+            break;
+        case "team revoke":
+            await cmdTeamRevoke(args, dbPath);
+            break;
+        case "upgrade":
+            await cmdUpgrade(args, dbPath);
+            break;
+        case "billing portal":
+            await cmdBillingPortal(dbPath);
+            break;
+        case "account":
+            await cmdAccount(dbPath);
+            break;
         case "":
         case "help":
             console.log(HELP);