feat: PWA instalable, cambio de contraseña y dashboards por rol

- POST /api/auth/cambiar-password (bcrypt 12, política ≥8+1 número) +
  modal en las 6 apps con auth
- PWA: manifest + íconos de marca en las 7 apps (sin service worker a
  propósito, documentado); instalable en celular
- Dashboards: 'Mi tablero' para vendedor (sus KPIs y funnel) y sección
  Equipo para coordinador/corporativo/admin
- mi-dia: equipo.porVendedor gana leadsNuevosSemana
- Tests: api 271, cotizador 88, alta 88, cobranza 81, agente-ia 19,
  dashboards 15, mi-dia 11, landing 4

api-gateway/src/controllers/auth.controller.test.ts

@@ -0,0 +1,73 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import type { Request, Response } from 'express'
+import { cambiarPasswordEndpoint } from './auth.controller.js'
+import { AppError } from '../utils/errors.js'
+
+// ---------- Servicio mockeado (la lógica se prueba en auth.service.test) ----------
+
+const servicioMock = vi.hoisted(() => ({ cambiarPassword: vi.fn() }))
+
+vi.mock('../services/auth.service.js', () => ({
+  cambiarPassword: servicioMock.cambiarPassword,
+}))
+
+function reqFake(overrides: Partial<Request> = {}): Request {
+  return {
+    body: { actual: 'Frasa2026', nueva: 'NuevaPass2026' },
+    usuarioToken: { sub: 'u-1', username: 'asesor uno', rol: 'vendedor' },
+    ...overrides,
+  } as Request
+}
+
+function resFake() {
+  const json = vi.fn()
+  const end = vi.fn()
+  const status = vi.fn().mockReturnValue({ json, end })
+  return { res: { json, status } as unknown as Response, status, json, end }
+}
+
+beforeEach(() => {
+  vi.clearAllMocks()
+})
+
+describe('cambiarPasswordEndpoint', () => {
+  it('204 sin cuerpo cuando el servicio cambia la contraseña', async () => {
+    servicioMock.cambiarPassword.mockResolvedValue(undefined)
+    const { res, status, end } = resFake()
+
+    await cambiarPasswordEndpoint(reqFake(), res)
+
+    expect(servicioMock.cambiarPassword).toHaveBeenCalledWith(
+      { sub: 'u-1', username: 'asesor uno', rol: 'vendedor' },
+      'Frasa2026',
+      'NuevaPass2026',
+    )
+    expect(status).toHaveBeenCalledWith(204)
+    expect(end).toHaveBeenCalled()
+  })
+
+  it('sin token verificado: 400', async () => {
+    const { res } = resFake()
+    await expect(cambiarPasswordEndpoint(reqFake({ usuarioToken: undefined }), res)).rejects.toThrow(
+      'Falta el token verificado',
+    )
+    expect(servicioMock.cambiarPassword).not.toHaveBeenCalled()
+  })
+
+  it('body inválido: ZodError (el error handler lo traduce a 400)', async () => {
+    const { res } = resFake()
+    await expect(
+      cambiarPasswordEndpoint(reqFake({ body: { actual: '' } }), res),
+    ).rejects.toThrow()
+    expect(servicioMock.cambiarPassword).not.toHaveBeenCalled()
+  })
+
+  it('propaga el AppError del servicio (actual incorrecta → 400)', async () => {
+    servicioMock.cambiarPassword.mockRejectedValue(
+      new AppError(400, 'La contraseña actual no es correcta'),
+    )
+    const { res } = resFake()
+    const error = await cambiarPasswordEndpoint(reqFake(), res).catch((e: unknown) => e)
+    expect(error).toMatchObject({ status: 400 })
+  })
+})

api-gateway/src/controllers/auth.controller.ts

@@ -1,6 +1,6 @@
 import type { Request, Response } from 'express'
 import { z } from 'zod'
-import { login, me } from '../services/auth.service.js'
+import { cambiarPassword, login, me } from '../services/auth.service.js'
 import { BadRequestError } from '../utils/errors.js'
 
 const loginSchema = z.object({
@@ -20,3 +20,16 @@ export async function meEndpoint(req: Request, res: Response): Promise<void> {
   if (!req.usuarioToken) throw new BadRequestError('Falta el token verificado')
   res.json(await me(req.usuarioToken))
 }
+
+const cambiarPasswordSchema = z.object({
+  actual: z.string().min(1),
+  nueva: z.string().min(1),
+})
+
+/** POST /api/auth/cambiar-password (Bearer) { actual, nueva } → 204 */
+export async function cambiarPasswordEndpoint(req: Request, res: Response): Promise<void> {
+  if (!req.usuarioToken) throw new BadRequestError('Falta el token verificado')
+  const { actual, nueva } = cambiarPasswordSchema.parse(req.body)
+  await cambiarPassword(req.usuarioToken, actual, nueva)
+  res.status(204).end()
+}

api-gateway/src/routes/index.ts

@@ -62,7 +62,7 @@ import {
   obtenerConversacion,
   subirDocumento,
 } from '../controllers/ai.controller.js'
-import { loginEndpoint, meEndpoint } from '../controllers/auth.controller.js'
+import { loginEndpoint, meEndpoint, cambiarPasswordEndpoint } from '../controllers/auth.controller.js'
 import { resumenReportes } from '../controllers/reportes.controller.js'
 
 export const apiRouter = Router()
@@ -71,6 +71,7 @@ apiRouter.get('/health', health)
 
 apiRouter.post('/auth/login', loginEndpoint)
 apiRouter.get('/auth/me', meEndpoint)
+apiRouter.post('/auth/cambiar-password', cambiarPasswordEndpoint)
 
 apiRouter.get('/unidades', listarUnidades)
 apiRouter.get('/unidades/:codigo', obtenerUnidad)

api-gateway/src/services/auth.service.test.ts

@@ -1,13 +1,14 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 import bcrypt from 'bcryptjs'
 import type { Usuario } from '@prisma/client'
-import { login, me, normalizarUsername, verificarToken } from './auth.service.js'
+import { cambiarPassword, login, me, normalizarUsername, validarPasswordNueva, verificarToken } from './auth.service.js'
 
 // ---------- Prisma mockeado (los tests no tocan la BD ni la red) ----------
 
 const prismaMock = vi.hoisted(() => ({
   usuario: {
     findUnique: vi.fn(),
+    update: vi.fn(),
   },
 }))
 
@@ -102,3 +103,63 @@ describe('me', () => {
     await expect(me({ sub: 'u-1', username: 'x', rol: 'vendedor' })).rejects.toThrow('Credenciales inválidas')
   })
 })
+
+describe('validarPasswordNueva', () => {
+  it('exige al menos 8 caracteres y un número', () => {
+    expect(validarPasswordNueva('corta1')).toContain('8 caracteres')
+    expect(validarPasswordNueva('sinnumeros')).toContain('número')
+    expect(validarPasswordNueva('')).toBeTruthy()
+  })
+
+  it('acepta passwords que cumplen la regla', () => {
+    expect(validarPasswordNueva('Frasa2026')).toBeNull()
+    expect(validarPasswordNueva('12345678')).toBeNull()
+  })
+})
+
+describe('cambiarPassword', () => {
+  const payload = { sub: 'u-1', username: 'erick israel pena ramos', rol: 'vendedor' }
+
+  it('con actual correcta re-hashea y guarda la nueva (cost 12)', async () => {
+    prismaMock.usuario.findUnique.mockResolvedValue(usuarioFake())
+    prismaMock.usuario.update.mockResolvedValue(usuarioFake())
+
+    await cambiarPassword(payload, 'Frasa2026', 'NuevaPass2026')
+
+    expect(prismaMock.usuario.update).toHaveBeenCalledTimes(1)
+    const llamada = prismaMock.usuario.update.mock.calls[0]?.[0] as {
+      where: { id: string }
+      data: { passwordHash: string }
+    }
+    expect(llamada.where).toEqual({ id: 'u-1' })
+    expect(llamada.data.passwordHash).not.toBe('NuevaPass2026')
+    expect(await bcrypt.compare('NuevaPass2026', llamada.data.passwordHash)).toBe(true)
+    // Cost 12: el hash bcrypt lleva el factor en el propio string ($2b$12$…)
+    expect(llamada.data.passwordHash).toMatch(/^\$2[aby]\$12\$/)
+  })
+
+  it('rechaza una nueva que no cumple la política sin tocar la BD', async () => {
+    await expect(cambiarPassword(payload, 'Frasa2026', 'corta')).rejects.toThrow('8 caracteres')
+    expect(prismaMock.usuario.findUnique).not.toHaveBeenCalled()
+    expect(prismaMock.usuario.update).not.toHaveBeenCalled()
+  })
+
+  it('con actual incorrecta responde 400 y no actualiza', async () => {
+    prismaMock.usuario.findUnique.mockResolvedValue(usuarioFake())
+
+    const error = await cambiarPassword(payload, 'mala', 'NuevaPass2026').catch((e: unknown) => e)
+    expect(error).toMatchObject({ status: 400, message: 'La contraseña actual no es correcta' })
+    expect(prismaMock.usuario.update).not.toHaveBeenCalled()
+  })
+
+  it('usuario inexistente o inactivo: 401 genérico', async () => {
+    prismaMock.usuario.findUnique.mockResolvedValue(null)
+    await expect(cambiarPassword(payload, 'Frasa2026', 'NuevaPass2026')).rejects.toThrow(
+      'Credenciales inválidas',
+    )
+    prismaMock.usuario.findUnique.mockResolvedValue(usuarioFake({ activo: false }))
+    await expect(cambiarPassword(payload, 'Frasa2026', 'NuevaPass2026')).rejects.toThrow(
+      'Credenciales inválidas',
+    )
+  })
+})

api-gateway/src/services/auth.service.ts

@@ -81,3 +81,40 @@ export async function me(payload: TokenPayload): Promise<UsuarioPublico> {
   if (!usuario || !usuario.activo) throw new AppError(401, 'Credenciales inválidas')
   return aPublico(usuario)
 }
+
+const BCRYPT_COST = 12
+
+/**
+ * Regla de la contraseña nueva: ≥8 caracteres y al menos 1 número.
+ * Devuelve el mensaje de error o null si es válida (la app cliente replica
+ * esta misma regla para validar antes de llamar al API).
+ */
+export function validarPasswordNueva(nueva: string): string | null {
+  if (nueva.length < 8 || !/\d/.test(nueva)) {
+    return 'La nueva contraseña debe tener al menos 8 caracteres y un número'
+  }
+  return null
+}
+
+/**
+ * POST /auth/cambiar-password: verifica la contraseña actual contra bcrypt y
+ * re-hashea la nueva (cost 12). Errores genéricos: no se filtra si el usuario
+ * existe; una actual incorrecta responde 400 sin más detalle.
+ */
+export async function cambiarPassword(
+  payload: TokenPayload,
+  actual: string,
+  nueva: string,
+): Promise<void> {
+  const errorPolitica = validarPasswordNueva(nueva)
+  if (errorPolitica) throw new AppError(400, errorPolitica)
+
+  const usuario = await prisma.usuario.findUnique({ where: { id: payload.sub } })
+  if (!usuario || !usuario.activo) throw new AppError(401, 'Credenciales inválidas')
+
+  const ok = await bcrypt.compare(actual, usuario.passwordHash)
+  if (!ok) throw new AppError(400, 'La contraseña actual no es correcta')
+
+  const passwordHash = await bcrypt.hash(nueva, BCRYPT_COST)
+  await prisma.usuario.update({ where: { id: usuario.id }, data: { passwordHash } })
+}

api-gateway/src/services/mi-dia.service.test.ts

@@ -166,6 +166,7 @@ describe('resumenMiDia (GET /api/mi-dia/resumen)', () => {
         lead({ id: '3', vendedorIds: [MI_ID] }),
         lead({ id: '4', vendedorIds: [MI_ID], estado: 'DESCARTADO' }), // terminal: no cuenta
         lead({ id: '5', vendedorIds: [OTRO_ID] }),
+        lead({ id: '6', vendedorIds: [OTRO_ID], createdAt: '2026-08-10T08:00:00' }), // viejo: no es nuevo de la semana
       ],
     })
     const nombres = new Map([[MI_ID, 'Martin Zavala']])
@@ -176,8 +177,8 @@ describe('resumenMiDia (GET /api/mi-dia/resumen)', () => {
     const rCoord = await resumenMiDia(monday, coordinador, nombres, AHORA)
     expect(rCoord.equipo?.leadsNuevosSinAsignar).toBe(1)
     expect(rCoord.equipo?.porVendedor).toEqual([
-      { mondayUserId: MI_ID, nombre: 'Martin Zavala', leadsAsignados: 1 },
-      { mondayUserId: OTRO_ID, nombre: null, leadsAsignados: 1 },
+      { mondayUserId: OTRO_ID, nombre: null, leadsAsignados: 2, leadsNuevosSemana: 1 },
+      { mondayUserId: MI_ID, nombre: 'Martin Zavala', leadsAsignados: 1, leadsNuevosSemana: 1 },
     ])
   })
 

api-gateway/src/services/mi-dia.service.ts

@@ -64,7 +64,13 @@ export interface ResumenMiDia {
   // Solo roles coordinador/corporativo/admin
   equipo?: {
     leadsNuevosSinAsignar: number
-    porVendedor: { mondayUserId: number; nombre: string | null; leadsAsignados: number }[]
+    porVendedor: {
+      mondayUserId: number
+      nombre: string | null
+      leadsAsignados: number
+      /** Leads del vendedor creados en los últimos 7 días naturales */
+      leadsNuevosSemana: number
+    }[]
   }
 }
 
@@ -170,9 +176,14 @@ export async function resumenMiDia(
   if (ROLES_CON_EQUIPO.includes(usuario.rol)) {
     const sinAsignar = leads.filter((l) => l.vendedorIds.length === 0 && !esEstadoTerminalLead(l.estado))
     const conteoPorId = new Map<number, number>()
+    const nuevosPorId = new Map<number, number>()
     for (const l of leads) {
       if (esEstadoTerminalLead(l.estado)) continue
-      for (const id of l.vendedorIds) conteoPorId.set(id, (conteoPorId.get(id) ?? 0) + 1)
+      const esNuevoSemana = Date.parse(l.createdAt) >= hace7DiasMs
+      for (const id of l.vendedorIds) {
+        conteoPorId.set(id, (conteoPorId.get(id) ?? 0) + 1)
+        if (esNuevoSemana) nuevosPorId.set(id, (nuevosPorId.get(id) ?? 0) + 1)
+      }
     }
     resumen.equipo = {
       leadsNuevosSinAsignar: sinAsignar.filter((l) => l.estado.trim().toUpperCase() === 'NUEVO').length,
@@ -181,6 +192,7 @@ export async function resumenMiDia(
           mondayUserId,
           nombre: nombresPorMondayId.get(mondayUserId) ?? null,
           leadsAsignados,
+          leadsNuevosSemana: nuevosPorId.get(mondayUserId) ?? 0,
         }))
         .sort((a, b) => b.leadsAsignados - a.leadsAsignados),
     }