@legios/quartermaster 0.1.15 → 0.1.16
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +7 -0
- package/bin/qm-indicator +71 -11
- package/extension/gnome43/quartermaster@legios/metadata.json +1 -1
- package/extension/quartermaster@legios/metadata.json +1 -1
- package/package.json +1 -1
- package/scripts/descargas.d.mts +45 -0
- package/scripts/descargas.mjs +388 -0
- package/scripts/gate-copias.sh +75 -0
- package/scripts/gate-dibujo.sh +13 -0
- package/scripts/gate-sellos.py +69 -0
package/README.md
CHANGED
|
@@ -26,6 +26,13 @@ MIT
|
|
|
26
26
|
|
|
27
27
|
</div>
|
|
28
28
|
|
|
29
|
+
```sh
|
|
30
|
+
brew install legiosai/tap/quartermaster # macOS and Linux
|
|
31
|
+
npm install -g @legios/quartermaster # anywhere
|
|
32
|
+
```
|
|
33
|
+
|
|
34
|
+
<div align="center"><sub>Then run <code>qm</code>. Details, the bar item and Windows: <a href="#install">Install</a>.</sub></div>
|
|
35
|
+
|
|
29
36
|
> **Mission.** Nobody should find out their quota is gone by hitting the wall.
|
|
30
37
|
|
|
31
38
|
## The problem
|
package/bin/qm-indicator
CHANGED
|
@@ -89,6 +89,12 @@ ESTADO = CACHE / "estado.json"
|
|
|
89
89
|
EXTENSION_VIVA = CACHE / "extension-viva"
|
|
90
90
|
# Donde la extensión deja el click.
|
|
91
91
|
PEDIDO = CACHE / "pedido"
|
|
92
|
+
# Cuántos dibujos viejos quedan sin borrar. El nombre de cada dibujo no se
|
|
93
|
+
# repite nunca (ver `pintar`), así que hay que barrerlos o el cache crece sin
|
|
94
|
+
# techo. Tres y no uno: uno es el que estado.json está señalando, y los otros
|
|
95
|
+
# cubren la lectura asíncrona del shell, que puede seguir cargando el anterior
|
|
96
|
+
# cuando éste ya se escribió. Borrar de más se ve como un item sin icono.
|
|
97
|
+
DIBUJOS_QUE_QUEDAN = 3
|
|
92
98
|
# El panel, dibujado a un PNG para que lo muestre la extensión.
|
|
93
99
|
#
|
|
94
100
|
# Por qué un PNG y no la ventana: un menú de GTK sobre XWayland no logra
|
|
@@ -112,6 +118,24 @@ ICONO_AVISO = "dialog-warning-symbolic"
|
|
|
112
118
|
ICONO_GRAVE = "dialog-error-symbolic"
|
|
113
119
|
|
|
114
120
|
|
|
121
|
+
_ULTIMO_SELLO = 0
|
|
122
|
+
|
|
123
|
+
|
|
124
|
+
def sello_nuevo() -> int:
|
|
125
|
+
"""Un número que no se repite NUNCA. De esto cuelga el nombre de cada dibujo.
|
|
126
|
+
|
|
127
|
+
No alcanza con leer el reloj. `time_ns()` promete nanosegundos pero no
|
|
128
|
+
promete resolución, y dos refrescos seguidos pueden caer en la misma
|
|
129
|
+
lectura; y un ajuste de NTP mueve el reloj para atrás, que devolvería un
|
|
130
|
+
sello ya usado. Las dos cosas terminan en el mismo lugar: dos dibujos
|
|
131
|
+
distintos con el mismo nombre, que es exactamente lo que el sello existe
|
|
132
|
+
para evitar (ver `pintar`). El máximo contra el anterior lo cierra.
|
|
133
|
+
"""
|
|
134
|
+
global _ULTIMO_SELLO
|
|
135
|
+
_ULTIMO_SELLO = max(time.time_ns(), _ULTIMO_SELLO + 1)
|
|
136
|
+
return _ULTIMO_SELLO
|
|
137
|
+
|
|
138
|
+
|
|
115
139
|
# ── formato ──────────────────────────────────────────────────────────────
|
|
116
140
|
def corto(nombre: str) -> str:
|
|
117
141
|
"""`.claude-teams` -> `teams`; el perfil por defecto -> `main`."""
|
|
@@ -1745,7 +1769,6 @@ class Indicador:
|
|
|
1745
1769
|
self._vigia_avisado = False
|
|
1746
1770
|
self.reloj: int | None = None
|
|
1747
1771
|
self.proxima_lectura: int | None = None
|
|
1748
|
-
self.turno = 0
|
|
1749
1772
|
self.iconos = CACHE
|
|
1750
1773
|
self.panel = Panel(self.refrescar, self.falta_para_lectura)
|
|
1751
1774
|
self.monitores: list[Gio.FileMonitor] = []
|
|
@@ -2417,11 +2440,24 @@ class Indicador:
|
|
|
2417
2440
|
self.ind.set_icon_full(ICONO_AVISO, "sin cuota")
|
|
2418
2441
|
return
|
|
2419
2442
|
|
|
2420
|
-
#
|
|
2421
|
-
#
|
|
2422
|
-
#
|
|
2423
|
-
|
|
2424
|
-
|
|
2443
|
+
# Cada refresco estrena nombre de archivo, con un sello del reloj.
|
|
2444
|
+
#
|
|
2445
|
+
# El shell cachea la textura por ruta y sólo suelta la entrada vieja
|
|
2446
|
+
# cuando su propio GFileMonitor le avisa que el archivo cambió: ese
|
|
2447
|
+
# aviso llega DESPUÉS de que la extensión ya leyó estado.json y pintó,
|
|
2448
|
+
# y no vuelve a pintar solo. Reescribir siempre la misma ruta dejaba el
|
|
2449
|
+
# item clavado en el dibujo viejo —parecía que la cuota no se mueve—,
|
|
2450
|
+
# pero turnarse entre DOS nombres tampoco alcanza: uno de cada dos
|
|
2451
|
+
# refrescos vuelve a caer sobre una ruta que el cache ya tiene.
|
|
2452
|
+
#
|
|
2453
|
+
# Del lado del usuario eso se veía como que los números cambian cuando
|
|
2454
|
+
# le pasás el mouse por arriba. No los cambia el hover: el hover
|
|
2455
|
+
# recalcula el estilo, obliga a releer el archivo y recién ahí aparece
|
|
2456
|
+
# la cifra de verdad, que estuvo tapada todo el tiempo por el dibujo
|
|
2457
|
+
# cacheado. Una ruta que el shell nunca vio no puede tener una entrada
|
|
2458
|
+
# vieja en el cache, así que el sello va en el nombre.
|
|
2459
|
+
sello = sello_nuevo()
|
|
2460
|
+
destino = self.iconos / f"barra-{sello}.png"
|
|
2425
2461
|
try:
|
|
2426
2462
|
self.iconos.mkdir(parents=True, exist_ok=True)
|
|
2427
2463
|
ancho, alto, descripcion = dibujar_item(piezas, str(destino))
|
|
@@ -2432,15 +2468,16 @@ class Indicador:
|
|
|
2432
2468
|
# el mismo número en dos idiomas y ocupar el doble de barra.
|
|
2433
2469
|
self.ind.set_label("", "")
|
|
2434
2470
|
self.ind.set_icon_full(str(destino), descripcion)
|
|
2435
|
-
self.publicar(destino, ancho, alto, descripcion)
|
|
2471
|
+
self.publicar(destino, ancho, alto, descripcion, sello)
|
|
2436
2472
|
|
|
2437
|
-
def publicar(self, ruta: Path, ancho: int, alto: int, descripcion: str
|
|
2473
|
+
def publicar(self, ruta: Path, ancho: int, alto: int, descripcion: str,
|
|
2474
|
+
sello: int) -> None:
|
|
2438
2475
|
"""Deja escrito qué dibujó, para la extensión de GNOME Shell."""
|
|
2439
2476
|
panel = {}
|
|
2440
2477
|
try:
|
|
2441
|
-
#
|
|
2442
|
-
#
|
|
2443
|
-
destino = self.iconos / f"panel-{
|
|
2478
|
+
# Mismo sello que el item, y por lo mismo: sin un nombre que el
|
|
2479
|
+
# shell nunca haya visto, el panel que se abre es el de hace un rato.
|
|
2480
|
+
destino = self.iconos / f"panel-{sello}.png"
|
|
2444
2481
|
# Un nombre propio, y no `alto` otra vez: pisar el parámetro dejaba
|
|
2445
2482
|
# escrito que el ICONO de la barra medía lo que mide el PANEL —
|
|
2446
2483
|
# 576 px de alto para un dibujo de 22. La extensión le cree al
|
|
@@ -2456,6 +2493,29 @@ class Indicador:
|
|
|
2456
2493
|
}))
|
|
2457
2494
|
except OSError:
|
|
2458
2495
|
pass # sin extensión instalada esto no le importa a nadie
|
|
2496
|
+
self.barrer()
|
|
2497
|
+
|
|
2498
|
+
def barrer(self) -> None:
|
|
2499
|
+
"""Borra los dibujos que ya nadie mira.
|
|
2500
|
+
|
|
2501
|
+
Como el nombre lleva un sello y no se repite nunca, sin esto el
|
|
2502
|
+
directorio de cache junta un PNG por refresco para siempre. El panel
|
|
2503
|
+
pesa ~100 kB, así que no es una molestia teórica.
|
|
2504
|
+
"""
|
|
2505
|
+
for prefijo in ("barra", "panel"):
|
|
2506
|
+
try:
|
|
2507
|
+
# Por (largo, texto) y no alfabético a secas: el sufijo es un
|
|
2508
|
+
# número, y así `barra-0.png` de una versión vieja queda
|
|
2509
|
+
# primero en vez de colarse entre los sellos.
|
|
2510
|
+
viejos = sorted(self.iconos.glob(f"{prefijo}-*.png"),
|
|
2511
|
+
key=lambda p: (len(p.stem), p.stem))
|
|
2512
|
+
except OSError:
|
|
2513
|
+
continue
|
|
2514
|
+
for viejo in viejos[:-DIBUJOS_QUE_QUEDAN]:
|
|
2515
|
+
try:
|
|
2516
|
+
viejo.unlink()
|
|
2517
|
+
except OSError:
|
|
2518
|
+
pass # el próximo barrido lo vuelve a intentar
|
|
2459
2519
|
|
|
2460
2520
|
def revisar_avisos(self, perfil: str, ventanas: list, frena: dict | None,
|
|
2461
2521
|
proy: dict | None, chocas: bool) -> None:
|
|
@@ -2,7 +2,7 @@
|
|
|
2
2
|
"uuid": "quartermaster@legios",
|
|
3
3
|
"name": "quartermaster",
|
|
4
4
|
"description": "Shows the quartermaster meter in the top bar: at a glance, how much quota is left in every agent account on the machine — each Claude Code profile, Codex, and the providers stored by opencode. One click opens the full panel.\n\nThis extension only displays and forwards the click: the numbers, the icon and the panel are drawn by the quartermaster CLI (https://github.com/legiosai/quartermaster), which has to be installed and running. It knows nothing about credentials or HTTP; it reads the PNGs the CLI leaves in the user cache directory and writes a one-line request file back when you click.\n\nIt exists because the AppIndicator extension keeps the left click for its own menu, so seeing the panel took two clicks. With an item of our own, the first click opens it.\n\nThis is the GNOME 43/44 build of the same extension: identical behaviour, written against the pre-45 extension API. It exists for Debian 12 and other distributions still on GNOME 43.",
|
|
5
|
-
"version-name": "0.1.
|
|
5
|
+
"version-name": "0.1.16",
|
|
6
6
|
"shell-version": [
|
|
7
7
|
"43",
|
|
8
8
|
"44"
|
|
@@ -2,7 +2,7 @@
|
|
|
2
2
|
"uuid": "quartermaster@legios",
|
|
3
3
|
"name": "quartermaster",
|
|
4
4
|
"description": "Shows the quartermaster meter in the top bar: at a glance, how much quota is left in every agent account on the machine — each Claude Code profile, Codex, and the providers stored by opencode. One click opens the full panel.\n\nThis extension only displays and forwards the click: the numbers, the icon and the panel are drawn by the quartermaster CLI (https://github.com/legiosai/quartermaster), which has to be installed and running. It knows nothing about credentials or HTTP; it reads the PNGs the CLI leaves in the user cache directory and writes a one-line request file back when you click.\n\nIt exists because the AppIndicator extension keeps the left click for its own menu, so seeing the panel took two clicks. With an item of our own, the first click opens it.",
|
|
5
|
-
"version-name": "0.1.
|
|
5
|
+
"version-name": "0.1.16",
|
|
6
6
|
"shell-version": ["45", "46", "47", "48", "49"],
|
|
7
7
|
"url": "https://github.com/legiosai/quartermaster"
|
|
8
8
|
}
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@legios/quartermaster",
|
|
3
|
-
"version": "0.1.
|
|
3
|
+
"version": "0.1.16",
|
|
4
4
|
"description": "Cuánta cuota te queda en TODOS los perfiles de Claude Code de la máquina, más Codex y los proveedores de opencode. Sin red y sin credenciales: el número sale del cache que Claude Code deja en disco.",
|
|
5
5
|
"keywords": [
|
|
6
6
|
"claude-code",
|
|
@@ -0,0 +1,45 @@
|
|
|
1
|
+
// Los tipos de descargas.mjs, para que el test lo importe bajo tsc. El script
|
|
2
|
+
// es JS a propósito —como el resto de scripts/, corre en el workflow sin build—
|
|
3
|
+
// y esto es lo único que hace falta para que el test tenga tipos.
|
|
4
|
+
export declare const PISO: { readonly exe: number; readonly zip: number };
|
|
5
|
+
export type TipoAdjunto = 'exe' | 'zip' | 'deb' | 'extension';
|
|
6
|
+
export declare function tipoAdjunto(nombre: string): TipoAdjunto | null;
|
|
7
|
+
|
|
8
|
+
export interface DiaNpm { readonly day: string; readonly downloads: number }
|
|
9
|
+
export interface FilaNpm { readonly dia: string; readonly descargas: number; readonly publicaciones: number; readonly humanas: number | null }
|
|
10
|
+
export declare function separarNpm(dias: readonly DiaNpm[], publicaciones: readonly string[]): {
|
|
11
|
+
readonly total: number; readonly enDiasSinPublicar: number; readonly porPublicacion: number | null; readonly dias: FilaNpm[];
|
|
12
|
+
};
|
|
13
|
+
|
|
14
|
+
export interface Adjunto { readonly name: string; readonly download_count: number }
|
|
15
|
+
export interface Release { readonly tag_name: string; readonly published_at: string | null; readonly assets?: readonly Adjunto[] }
|
|
16
|
+
export declare function separarAdjuntos(releases: readonly Release[]): {
|
|
17
|
+
readonly humanas: number;
|
|
18
|
+
readonly porVersion: { readonly version: string; readonly publicada: string | null; readonly humanas: number; readonly adjuntos: Record<string, { bajadas: number; netas: number }> }[];
|
|
19
|
+
};
|
|
20
|
+
|
|
21
|
+
export interface LineaHistorial { readonly fecha: string; readonly npm: number; readonly github: number }
|
|
22
|
+
export declare function agregarAlHistorial(historial: readonly LineaHistorial[], hoy: string, npmHumanas: number, githubHumanas: number): LineaHistorial[];
|
|
23
|
+
export declare function estaSemana(historial: readonly LineaHistorial[], hoy: string): { desde: string; npm: number; github: number } | null;
|
|
24
|
+
|
|
25
|
+
// Los dos canales sin contador: un tap de Homebrew y un bucket de scoop no
|
|
26
|
+
// reportan instalaciones, y lo único que dejan es el git fetch del cliente.
|
|
27
|
+
export declare const REPOS_CANAL: { readonly brew: string; readonly scoop: string };
|
|
28
|
+
export interface DiaClones { readonly timestamp: string; readonly count: number; readonly uniques: number }
|
|
29
|
+
export interface FilaClones { readonly dia: string; readonly clones: number; readonly unicos: number; readonly huboRelease: boolean; readonly quietos: number | null }
|
|
30
|
+
export declare function separarClones(dias: readonly DiaClones[] | undefined, fechasDeRelease: readonly string[]): {
|
|
31
|
+
readonly total: number; readonly unicos: number; readonly enDiasSinRelease: number; readonly diasSinRelease: number; readonly dias: FilaClones[];
|
|
32
|
+
};
|
|
33
|
+
|
|
34
|
+
// Sin la cabecera `star+json` la API devuelve el usuario pelado, sin fecha:
|
|
35
|
+
// ése es justo el caso que el test cubre.
|
|
36
|
+
export interface Estrella { readonly starred_at?: string; readonly login?: string }
|
|
37
|
+
export declare function separarEstrellas(stargazers: readonly Estrella[] | undefined): {
|
|
38
|
+
readonly total: number; readonly dias: { readonly dia: string; readonly estrellas: number }[];
|
|
39
|
+
};
|
|
40
|
+
|
|
41
|
+
// Los días que le faltan al historial: el cron de GitHub se atrasa y a veces se
|
|
42
|
+
// saltea una corrida, y «esta semana» sigue dando un número igual.
|
|
43
|
+
export declare function huecosDelHistorial(historial: readonly LineaHistorial[] | undefined, hoy: string): {
|
|
44
|
+
readonly desde: string | null; readonly esperados: number; readonly anotados: number; readonly faltan: string[];
|
|
45
|
+
};
|
|
@@ -0,0 +1,388 @@
|
|
|
1
|
+
#!/usr/bin/env node
|
|
2
|
+
// ¿Alguien instaló esto? Un número, y no una comparación a ojo.
|
|
3
|
+
//
|
|
4
|
+
// node scripts/descargas.mjs # escribe docs/descargas.json
|
|
5
|
+
// node scripts/descargas.mjs --seco # lo imprime y no escribe nada
|
|
6
|
+
//
|
|
7
|
+
// Los contadores públicos que hay —npm y los adjuntos de cada release— cuentan
|
|
8
|
+
// también lo nuestro, y lo nuestro es casi todo. Medido el 2026-09-16, con
|
|
9
|
+
// quince versiones publicadas y ninguna anunciada:
|
|
10
|
+
//
|
|
11
|
+
// · npm: 345, 180 y 777 descargas en los tres días con publicaciones (3, 1 y
|
|
12
|
+
// 5 publicaciones), y CERO en los días sin ninguna. Son los mirrors y los
|
|
13
|
+
// escáneres que bajan cada versión nueva, entre 115 y 180 por publicación.
|
|
14
|
+
// Una persona instalando se ve como un goteo en días sin publicar, y ése es
|
|
15
|
+
// el número que vale: `enDiasSinPublicar`.
|
|
16
|
+
// · releases: el instalador de Windows tenía entre 4 y 11 bajadas por versión
|
|
17
|
+
// y el zip entre 2 y 4, en todas, desde el minuto de publicadas. release.yml
|
|
18
|
+
// baja los dos una vez para el hash de winget (línea ~372) y las
|
|
19
|
+
// validaciones de winget y scoop los bajan de nuevo. El piso observado —4 y
|
|
20
|
+
// 2— se resta y lo que sobra se cuenta. El .deb y el zip de la extensión no
|
|
21
|
+
// los toca ningún automatismo: se cuentan enteros.
|
|
22
|
+
//
|
|
23
|
+
// El JSON va a docs/ a propósito: docs/ es la landing, así que queda público en
|
|
24
|
+
// quartermaster.legios.com.ar/descargas.json y una página lo puede leer sin
|
|
25
|
+
// preguntarle a dos APIs. Y guarda un historial de una línea por día, porque
|
|
26
|
+
// los adjuntos de GitHub son acumulados: «esta semana» sólo existe restando
|
|
27
|
+
// contra lo que decía hace siete días.
|
|
28
|
+
//
|
|
29
|
+
// La herramienta sigue sin telemetría: acá se leen dos APIs públicas desde
|
|
30
|
+
// nuestro lado, y la máquina de quien instala no manda nada.
|
|
31
|
+
import { existsSync, readFileSync, writeFileSync } from 'node:fs';
|
|
32
|
+
import { dirname, join } from 'node:path';
|
|
33
|
+
import { fileURLToPath, pathToFileURL } from 'node:url';
|
|
34
|
+
|
|
35
|
+
const RAIZ = join(dirname(fileURLToPath(import.meta.url)), '..');
|
|
36
|
+
const SALIDA = join(RAIZ, 'docs/descargas.json');
|
|
37
|
+
const PAQUETE = '@legios/quartermaster';
|
|
38
|
+
const REPO = 'legiosai/quartermaster';
|
|
39
|
+
|
|
40
|
+
/** Lo que baja nuestra propia automatización de cada release, por adjunto. */
|
|
41
|
+
export const PISO = { exe: 4, zip: 2 };
|
|
42
|
+
|
|
43
|
+
/** De qué adjunto se trata, por el nombre. `null` para lo que no se cuenta (SHA256SUMS). */
|
|
44
|
+
export function tipoAdjunto(nombre) {
|
|
45
|
+
if (/-setup\.exe$/.test(nombre)) return 'exe';
|
|
46
|
+
if (/-win\.zip$/.test(nombre)) return 'zip';
|
|
47
|
+
if (/\.deb$/.test(nombre)) return 'deb';
|
|
48
|
+
if (/shell-extension\.zip$/.test(nombre)) return 'extension';
|
|
49
|
+
return null;
|
|
50
|
+
}
|
|
51
|
+
|
|
52
|
+
/**
|
|
53
|
+
* npm por día, separando los días con publicación de los que no.
|
|
54
|
+
*
|
|
55
|
+
* `dias`: [{day, downloads}] tal como los da api.npmjs.org.
|
|
56
|
+
* `publicaciones`: los ISO de `time` del registry (sin created/modified).
|
|
57
|
+
*/
|
|
58
|
+
export function separarNpm(dias, publicaciones) {
|
|
59
|
+
const porDia = new Map();
|
|
60
|
+
for (const iso of publicaciones) {
|
|
61
|
+
const d = iso.slice(0, 10);
|
|
62
|
+
porDia.set(d, (porDia.get(d) ?? 0) + 1);
|
|
63
|
+
}
|
|
64
|
+
const filas = dias.map((x) => {
|
|
65
|
+
const publicadas = porDia.get(x.day) ?? 0;
|
|
66
|
+
return { dia: x.day, descargas: x.downloads, publicaciones: publicadas, humanas: publicadas === 0 ? x.downloads : null };
|
|
67
|
+
});
|
|
68
|
+
const total = filas.reduce((s, f) => s + f.descargas, 0);
|
|
69
|
+
const enDiasSinPublicar = filas.reduce((s, f) => s + (f.humanas ?? 0), 0);
|
|
70
|
+
const conPublicacion = filas.filter((f) => f.publicaciones > 0);
|
|
71
|
+
const bajadasEsosDias = conPublicacion.reduce((s, f) => s + f.descargas, 0);
|
|
72
|
+
const cantidad = conPublicacion.reduce((s, f) => s + f.publicaciones, 0);
|
|
73
|
+
return {
|
|
74
|
+
total,
|
|
75
|
+
enDiasSinPublicar,
|
|
76
|
+
porPublicacion: cantidad === 0 ? null : Math.round(bajadasEsosDias / cantidad),
|
|
77
|
+
dias: filas,
|
|
78
|
+
};
|
|
79
|
+
}
|
|
80
|
+
|
|
81
|
+
/**
|
|
82
|
+
* Los adjuntos de cada release, con el piso de la automatización restado.
|
|
83
|
+
* `releases`: [{tag_name, published_at, assets: [{name, download_count}]}].
|
|
84
|
+
*/
|
|
85
|
+
export function separarAdjuntos(releases) {
|
|
86
|
+
const porVersion = [];
|
|
87
|
+
let humanas = 0;
|
|
88
|
+
for (const r of releases) {
|
|
89
|
+
const adjuntos = {};
|
|
90
|
+
let propias = 0;
|
|
91
|
+
for (const a of r.assets ?? []) {
|
|
92
|
+
const tipo = tipoAdjunto(a.name);
|
|
93
|
+
if (tipo === null) continue;
|
|
94
|
+
const netas = Math.max(0, a.download_count - (PISO[tipo] ?? 0));
|
|
95
|
+
adjuntos[tipo] = { bajadas: a.download_count, netas };
|
|
96
|
+
propias += netas;
|
|
97
|
+
}
|
|
98
|
+
humanas += propias;
|
|
99
|
+
porVersion.push({ version: r.tag_name, publicada: r.published_at?.slice(0, 10) ?? null, humanas: propias, adjuntos });
|
|
100
|
+
}
|
|
101
|
+
return { humanas, porVersion };
|
|
102
|
+
}
|
|
103
|
+
|
|
104
|
+
/**
|
|
105
|
+
* Los repos que SIRVEN un canal. `brew install legiosai/tap/…` y `scoop update`
|
|
106
|
+
* son un git fetch contra estos, y GitHub los cuenta como clones.
|
|
107
|
+
*
|
|
108
|
+
* Existe porque el CTA principal —la landing y el README arrancan con
|
|
109
|
+
* `brew install legiosai/tap/quartermaster`— es justo el canal SIN contador:
|
|
110
|
+
* un tap de Homebrew no reporta instalaciones a nadie. Medido el 2026-09-17,
|
|
111
|
+
* con la 0.1.15 publicada y un anuncio en LinkedIn el día anterior, el tablero
|
|
112
|
+
* decía «npm 0» y de brew y scoop no decía NADA. Eso no es cero: es que no se
|
|
113
|
+
* estaba mirando, y la diferencia importa cuando lo que se concluye es «nadie
|
|
114
|
+
* lo instaló».
|
|
115
|
+
*
|
|
116
|
+
* No reemplaza a un contador: son clones, y ahí adentro hay CI y escáneres.
|
|
117
|
+
* Por eso se cuentan igual que los días de npm —sólo los días sin release—,
|
|
118
|
+
* que es el mismo truco que hace confiable `enDiasSinPublicar`.
|
|
119
|
+
*/
|
|
120
|
+
export const REPOS_CANAL = {
|
|
121
|
+
brew: 'legiosai/homebrew-tap',
|
|
122
|
+
scoop: 'legiosai/scoop-bucket',
|
|
123
|
+
};
|
|
124
|
+
|
|
125
|
+
/**
|
|
126
|
+
* Los clones de un repo de canal, separando los días con release de los que no.
|
|
127
|
+
*
|
|
128
|
+
* Un día con release tiene los checkouts de release.yml y la ronda de mirrors;
|
|
129
|
+
* un día sin release no tiene ninguno de los dos, así que lo que quede ahí es
|
|
130
|
+
* lo más cerca de «alguien corrió brew install» que se puede medir sin
|
|
131
|
+
* telemetría. Mismo criterio que `separarNpm`, y por la misma razón.
|
|
132
|
+
*
|
|
133
|
+
* `dias`: [{timestamp, count, uniques}] tal como los da la API de tráfico.
|
|
134
|
+
* `fechasDeRelease`: los ISO de publicación de las releases.
|
|
135
|
+
*/
|
|
136
|
+
export function separarClones(dias, fechasDeRelease) {
|
|
137
|
+
const conRelease = new Set(fechasDeRelease.map((f) => f.slice(0, 10)));
|
|
138
|
+
const filas = (dias ?? []).map((d) => {
|
|
139
|
+
const dia = d.timestamp.slice(0, 10);
|
|
140
|
+
const hubo = conRelease.has(dia);
|
|
141
|
+
return { dia, clones: d.count, unicos: d.uniques, huboRelease: hubo, quietos: hubo ? null : d.uniques };
|
|
142
|
+
});
|
|
143
|
+
return {
|
|
144
|
+
total: filas.reduce((s, f) => s + f.clones, 0),
|
|
145
|
+
unicos: filas.reduce((s, f) => s + f.unicos, 0),
|
|
146
|
+
enDiasSinRelease: filas.reduce((s, f) => s + (f.quietos ?? 0), 0),
|
|
147
|
+
// Cuántos días quietos hubo, que es lo que le da peso al número de arriba.
|
|
148
|
+
// Cortando una release por día quedan cero, y entonces `enDiasSinRelease`
|
|
149
|
+
// vale 0 por falta de ventana y no por falta de gente. Sin este contador
|
|
150
|
+
// las dos cosas se leen igual.
|
|
151
|
+
diasSinRelease: filas.filter((f) => !f.huboRelease).length,
|
|
152
|
+
dias: filas,
|
|
153
|
+
};
|
|
154
|
+
}
|
|
155
|
+
|
|
156
|
+
/** Las estrellas por día, que es lo único que viene con una persona atrás. */
|
|
157
|
+
export function separarEstrellas(stargazers) {
|
|
158
|
+
const porDia = new Map();
|
|
159
|
+
for (const s of stargazers ?? []) {
|
|
160
|
+
const d = (s.starred_at ?? '').slice(0, 10);
|
|
161
|
+
if (d) porDia.set(d, (porDia.get(d) ?? 0) + 1);
|
|
162
|
+
}
|
|
163
|
+
return {
|
|
164
|
+
total: (stargazers ?? []).length,
|
|
165
|
+
dias: [...porDia.entries()].sort().map(([dia, estrellas]) => ({ dia, estrellas })),
|
|
166
|
+
};
|
|
167
|
+
}
|
|
168
|
+
|
|
169
|
+
/**
|
|
170
|
+
* Una línea por día: reemplaza la de hoy si ya está, y con eso «esta semana»
|
|
171
|
+
* es restar contra la línea de hace siete días o más.
|
|
172
|
+
*/
|
|
173
|
+
export function agregarAlHistorial(historial, hoy, npmHumanas, githubHumanas) {
|
|
174
|
+
const sinHoy = historial.filter((h) => h.fecha !== hoy);
|
|
175
|
+
return [...sinHoy, { fecha: hoy, npm: npmHumanas, github: githubHumanas }].sort((a, b) => a.fecha.localeCompare(b.fecha));
|
|
176
|
+
}
|
|
177
|
+
|
|
178
|
+
/**
|
|
179
|
+
* Los días que le FALTAN al historial entre el primero que tiene y hoy.
|
|
180
|
+
*
|
|
181
|
+
* El historial es la única serie de tiempo del proyecto, y existe sólo porque
|
|
182
|
+
* los adjuntos de GitHub son acumulados: «esta semana» es restar contra la
|
|
183
|
+
* línea de hace siete días, y esa línea la escribe la corrida diaria. Si la
|
|
184
|
+
* corrida no ocurre, no se rompe nada visible — `estaSemana` sigue devolviendo
|
|
185
|
+
* un número, con un `desde` más cercano, y se lee igual que una semana entera.
|
|
186
|
+
*
|
|
187
|
+
* Y no ocurrir es el caso probable, no el raro: el cron de GitHub se atrasa y a
|
|
188
|
+
* veces directamente se saltea una corrida. Medido el 2026-09-17, con
|
|
189
|
+
* `0 12 * * *` configurado desde el día anterior, a las 14:44 UTC no había
|
|
190
|
+
* corrido NI UNA vez por `schedule` — las tres corridas del historial eran
|
|
191
|
+
* todas a mano.
|
|
192
|
+
*
|
|
193
|
+
* Así que el número que falta se cuenta y se dice. Es el mismo criterio que el
|
|
194
|
+
* resto del archivo: un dato que no se pudo tomar no puede parecerse a un cero.
|
|
195
|
+
*/
|
|
196
|
+
export function huecosDelHistorial(historial, hoy) {
|
|
197
|
+
if (!historial || historial.length === 0) return { desde: null, esperados: 0, anotados: 0, faltan: [] };
|
|
198
|
+
const desde = historial[0].fecha;
|
|
199
|
+
const tiene = new Set(historial.map((h) => h.fecha));
|
|
200
|
+
const faltan = [];
|
|
201
|
+
let esperados = 0;
|
|
202
|
+
const d = new Date(`${desde}T00:00:00Z`);
|
|
203
|
+
const fin = new Date(`${hoy}T00:00:00Z`);
|
|
204
|
+
while (d <= fin) {
|
|
205
|
+
const iso = d.toISOString().slice(0, 10);
|
|
206
|
+
esperados += 1;
|
|
207
|
+
if (!tiene.has(iso)) faltan.push(iso);
|
|
208
|
+
d.setUTCDate(d.getUTCDate() + 1);
|
|
209
|
+
}
|
|
210
|
+
return { desde, esperados, anotados: historial.length, faltan };
|
|
211
|
+
}
|
|
212
|
+
|
|
213
|
+
export function estaSemana(historial, hoy) {
|
|
214
|
+
const ultima = historial.find((h) => h.fecha === hoy);
|
|
215
|
+
if (!ultima) return null;
|
|
216
|
+
const hace7 = new Date(`${hoy}T00:00:00Z`);
|
|
217
|
+
hace7.setUTCDate(hace7.getUTCDate() - 7);
|
|
218
|
+
const corte = hace7.toISOString().slice(0, 10);
|
|
219
|
+
// La más reciente de las que tienen siete días o más; si el historial es
|
|
220
|
+
// más corto que una semana, la primera que haya.
|
|
221
|
+
const base = [...historial].reverse().find((h) => h.fecha <= corte) ?? historial[0];
|
|
222
|
+
return { desde: base.fecha, npm: ultima.npm - base.npm, github: ultima.github - base.github };
|
|
223
|
+
}
|
|
224
|
+
|
|
225
|
+
async function json(url, cabeceras = {}) {
|
|
226
|
+
const r = await fetch(url, { headers: { accept: 'application/json', 'user-agent': 'quartermaster-descargas', ...cabeceras } });
|
|
227
|
+
if (!r.ok) throw new Error(`${url} → HTTP ${r.status}`);
|
|
228
|
+
return r.json();
|
|
229
|
+
}
|
|
230
|
+
|
|
231
|
+
/**
|
|
232
|
+
* Lo mismo, pero devolviendo el porqué en vez de tumbar la corrida.
|
|
233
|
+
*
|
|
234
|
+
* La API de tráfico pide permiso de push, y el token de un canal no es el mismo
|
|
235
|
+
* que el del repo. Un 403 ahí no puede llevarse puesto el conteo de npm — pero
|
|
236
|
+
* tampoco puede desaparecer: el JSON dice `null` Y dice por qué, que es la
|
|
237
|
+
* diferencia entre «nadie lo clonó» y «no lo miramos».
|
|
238
|
+
*/
|
|
239
|
+
async function jsonOpcional(url, cabeceras = {}) {
|
|
240
|
+
try {
|
|
241
|
+
return { datos: await json(url, cabeceras), porQueNo: null };
|
|
242
|
+
} catch (e) {
|
|
243
|
+
return { datos: null, porQueNo: e.message.replace(/^https:\/\/api\.github\.com\/repos\//, '') };
|
|
244
|
+
}
|
|
245
|
+
}
|
|
246
|
+
|
|
247
|
+
async function principal() {
|
|
248
|
+
const seco = process.argv.includes('--seco');
|
|
249
|
+
const hoy = new Date().toISOString().slice(0, 10);
|
|
250
|
+
|
|
251
|
+
const registry = await json(`https://registry.npmjs.org/${PAQUETE}`);
|
|
252
|
+
const publicaciones = Object.entries(registry.time)
|
|
253
|
+
.filter(([k]) => k !== 'created' && k !== 'modified')
|
|
254
|
+
.map(([, v]) => v);
|
|
255
|
+
const desde = registry.time.created.slice(0, 10);
|
|
256
|
+
const rango = await json(`https://api.npmjs.org/downloads/range/${desde}:${hoy}/${encodeURIComponent(PAQUETE)}`);
|
|
257
|
+
const npm = separarNpm(rango.downloads ?? [], publicaciones);
|
|
258
|
+
|
|
259
|
+
const token = process.env.GITHUB_TOKEN;
|
|
260
|
+
const releases = await json(`https://api.github.com/repos/${REPO}/releases?per_page=100`, token ? { authorization: `Bearer ${token}` } : {});
|
|
261
|
+
const github = separarAdjuntos(releases);
|
|
262
|
+
|
|
263
|
+
// ── el interés, que es la otra mitad y faltaba entera ────────────────
|
|
264
|
+
// El tablero medía descargas y nada más, así que el día del anuncio —21
|
|
265
|
+
// visitantes únicos y tres estrellas de gente que no conocemos— se veía
|
|
266
|
+
// igual que un martes cualquiera: npm 0. Lo que sigue no son instalaciones,
|
|
267
|
+
// y por eso va en otra sección: es cuánta gente llegó, de dónde, y qué pasó
|
|
268
|
+
// en los dos canales que no tienen contador.
|
|
269
|
+
const auth = token ? { authorization: `Bearer ${token}` } : {};
|
|
270
|
+
const fechasDeRelease = releases.map((r) => r.published_at).filter(Boolean);
|
|
271
|
+
|
|
272
|
+
// La API de TRÁFICO pide permiso de push, y el GITHUB_TOKEN de un workflow no
|
|
273
|
+
// lo da: `administration` ni siquiera es una clave válida en `permissions:`.
|
|
274
|
+
// Así que las visitas, los referentes y los clones van con un PAT. El tap y
|
|
275
|
+
// el bucket, además, son otros repos, donde el token del job no llega nunca.
|
|
276
|
+
const tokenTrafico = process.env.TOKEN_PAQUETES || token;
|
|
277
|
+
const authTrafico = tokenTrafico ? { authorization: `Bearer ${tokenTrafico}` } : {};
|
|
278
|
+
|
|
279
|
+
const vistas = await jsonOpcional(`https://api.github.com/repos/${REPO}/traffic/views`, authTrafico);
|
|
280
|
+
const referentes = await jsonOpcional(`https://api.github.com/repos/${REPO}/traffic/popular/referrers`, authTrafico);
|
|
281
|
+
// Las estrellas son públicas: ésas sí con el token del job.
|
|
282
|
+
const estrellas = await jsonOpcional(`https://api.github.com/repos/${REPO}/stargazers?per_page=100`, {
|
|
283
|
+
...auth, accept: 'application/vnd.github.star+json',
|
|
284
|
+
});
|
|
285
|
+
|
|
286
|
+
const canales = {};
|
|
287
|
+
for (const [canal, repo] of Object.entries(REPOS_CANAL)) {
|
|
288
|
+
const r = await jsonOpcional(`https://api.github.com/repos/${repo}/traffic/clones`, authTrafico);
|
|
289
|
+
canales[canal] = r.datos
|
|
290
|
+
? { repo, ...separarClones(r.datos.clones, fechasDeRelease) }
|
|
291
|
+
: { repo, porQueNo: r.porQueNo, nota: 'la API de tráfico pide permiso de push: hace falta un PAT en TOKEN_PAQUETES' };
|
|
292
|
+
}
|
|
293
|
+
|
|
294
|
+
const interes = {
|
|
295
|
+
nota: 'Nada de esto es una instalación. Es quién llegó, de dónde, y el único rastro que dejan brew y scoop.',
|
|
296
|
+
vistas: vistas.datos
|
|
297
|
+
? { total: vistas.datos.count, unicos: vistas.datos.uniques, dias: (vistas.datos.views ?? []).map((v) => ({ dia: v.timestamp.slice(0, 10), vistas: v.count, unicos: v.uniques })) }
|
|
298
|
+
: { porQueNo: vistas.porQueNo },
|
|
299
|
+
referentes: referentes.datos
|
|
300
|
+
? referentes.datos.map((r) => ({ sitio: r.referrer, vistas: r.count, unicos: r.uniques }))
|
|
301
|
+
: { porQueNo: referentes.porQueNo },
|
|
302
|
+
estrellas: estrellas.datos ? separarEstrellas(estrellas.datos) : { porQueNo: estrellas.porQueNo },
|
|
303
|
+
canalesSinContador: canales,
|
|
304
|
+
};
|
|
305
|
+
|
|
306
|
+
const previo = existsSync(SALIDA) ? JSON.parse(readFileSync(SALIDA, 'utf8')) : {};
|
|
307
|
+
const historial = agregarAlHistorial(previo.historial ?? [], hoy, npm.enDiasSinPublicar, github.humanas);
|
|
308
|
+
const huecos = huecosDelHistorial(historial, hoy);
|
|
309
|
+
|
|
310
|
+
const salida = {
|
|
311
|
+
generado: new Date().toISOString(),
|
|
312
|
+
// Lo que importa, arriba y en dos números.
|
|
313
|
+
resumen: {
|
|
314
|
+
humanasHastaHoy: { npm: npm.enDiasSinPublicar, github: github.humanas },
|
|
315
|
+
estaSemana: estaSemana(historial, hoy),
|
|
316
|
+
// Los dos canales sin contador, arriba y no enterrados: el CTA principal
|
|
317
|
+
// es `brew install` y durante quince versiones no se miró ni una vez.
|
|
318
|
+
sinContador: Object.fromEntries(Object.entries(interes.canalesSinContador)
|
|
319
|
+
.map(([c, v]) => [c, v.enDiasSinRelease ?? null])),
|
|
320
|
+
llegaron: interes.vistas?.unicos ?? null,
|
|
321
|
+
estrellas: interes.estrellas?.total ?? null,
|
|
322
|
+
// Cuántos días de los que debería tener, tiene. `estaSemana` devuelve un
|
|
323
|
+
// número igual con el historial lleno de huecos, sólo que ese número
|
|
324
|
+
// cubre menos días de los que parece.
|
|
325
|
+
cobertura: huecos.faltan.length === 0 ? 'completa' : `faltan ${huecos.faltan.length} de ${huecos.esperados} días`,
|
|
326
|
+
nota: 'npm publica sus números con uno o dos días de atraso; los últimos dos días siempre están incompletos.',
|
|
327
|
+
},
|
|
328
|
+
npm,
|
|
329
|
+
github,
|
|
330
|
+
interes,
|
|
331
|
+
piso: PISO,
|
|
332
|
+
huecos,
|
|
333
|
+
historial,
|
|
334
|
+
};
|
|
335
|
+
// Una sección en null es un dato, pero adentro de un JSON de 400 líneas no la
|
|
336
|
+
// ve nadie —que es exactamente cómo el AUR pasó diez releases sin publicar—.
|
|
337
|
+
// Así que sale por el log del workflow, donde se mira. Va ACÁ arriba y no
|
|
338
|
+
// junto a la escritura porque los dos `return` de abajo se la saltearían, y
|
|
339
|
+
// el día sin cambios es justo el día en que nadie abre el archivo.
|
|
340
|
+
const enNull = [
|
|
341
|
+
['vistas', salida.interes.vistas?.porQueNo],
|
|
342
|
+
['referentes', salida.interes.referentes?.porQueNo],
|
|
343
|
+
['estrellas', salida.interes.estrellas?.porQueNo],
|
|
344
|
+
...Object.entries(salida.interes.canalesSinContador).map(([c, v]) => [c, v.porQueNo]),
|
|
345
|
+
].filter(([, porQue]) => porQue);
|
|
346
|
+
if (huecos.faltan.length > 0 && !seco) {
|
|
347
|
+
console.log(`::warning::al historial le faltan ${huecos.faltan.length} de ${huecos.esperados} días` +
|
|
348
|
+
` (${huecos.faltan.slice(0, 5).join(', ')}${huecos.faltan.length > 5 ? '…' : ''}).` +
|
|
349
|
+
' «esta semana» se calcula contra el día más viejo que haya, así que sigue dando un número:' +
|
|
350
|
+
' uno que cubre menos días de los que dice. El cron de GitHub se atrasa y a veces se saltea' +
|
|
351
|
+
' una corrida — si faltan varios seguidos, conviene despacharlo a mano.');
|
|
352
|
+
}
|
|
353
|
+
|
|
354
|
+
// Con --seco no: lo único que sale por stdout ahí es el JSON.
|
|
355
|
+
if (enNull.length > 0 && !seco) {
|
|
356
|
+
for (const [que, porQue] of enNull) console.log(`::warning::${que}: sin número — ${porQue}`);
|
|
357
|
+
console.log('::warning::La API de tráfico pide permiso de ADMIN sobre el repo, no sólo push.' +
|
|
358
|
+
' Hace falta un PAT con ese permiso en TOKEN_PAQUETES (fine-grained: Administration=read,' +
|
|
359
|
+
' sobre quartermaster, homebrew-tap y scoop-bucket). Sin eso el tablero mide descargas y no mide interés.');
|
|
360
|
+
}
|
|
361
|
+
|
|
362
|
+
const texto = `${JSON.stringify(salida, null, 2)}\n`;
|
|
363
|
+
if (seco) {
|
|
364
|
+
process.stdout.write(texto);
|
|
365
|
+
return;
|
|
366
|
+
}
|
|
367
|
+
// Si lo único que cambió es la hora de la corrida, no se escribe: el
|
|
368
|
+
// workflow comitea cuando el archivo cambia, y un `generado` distinto cada
|
|
369
|
+
// día es un commit diario que no dice nada. La primera corrida del día que
|
|
370
|
+
// no trae ni una descarga nueva deja el archivo como estaba.
|
|
371
|
+
const sinHora = (o) => JSON.stringify({ ...o, generado: null });
|
|
372
|
+
if (sinHora(previo) === sinHora(salida)) {
|
|
373
|
+
console.log('docs/descargas.json sin cambios: ningún número se movió');
|
|
374
|
+
return;
|
|
375
|
+
}
|
|
376
|
+
writeFileSync(SALIDA, texto);
|
|
377
|
+
|
|
378
|
+
const s = salida.resumen;
|
|
379
|
+
console.log(`docs/descargas.json escrito · humanas hasta hoy: npm ${s.humanasHastaHoy.npm} · github ${s.humanasHastaHoy.github}` +
|
|
380
|
+
(s.estaSemana ? ` · esta semana (desde ${s.estaSemana.desde}): npm ${s.estaSemana.npm} · github ${s.estaSemana.github}` : ''));
|
|
381
|
+
}
|
|
382
|
+
|
|
383
|
+
if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
|
|
384
|
+
principal().catch((e) => {
|
|
385
|
+
console.error(`descargas: ${e.message}`);
|
|
386
|
+
process.exit(1);
|
|
387
|
+
});
|
|
388
|
+
}
|
|
@@ -0,0 +1,75 @@
|
|
|
1
|
+
#!/usr/bin/env bash
|
|
2
|
+
# Gate contra la segunda copia de los gates.
|
|
3
|
+
#
|
|
4
|
+
# Los gates vivían en ci.yml y release.yml tenía los suyos: cinco pasos de los
|
|
5
|
+
# trece. Nadie lo hizo a propósito — se desincronizó solo. Un gate nuevo se
|
|
6
|
+
# agrega donde duele, que es el CI, y el job de la release se queda como estaba,
|
|
7
|
+
# EN VERDE, sin que nada lo señale. Así fue como gate-dibujo, gate-cambios,
|
|
8
|
+
# gate-duraciones, gate-lazo, gate-presupuesto, gate-calentado,
|
|
9
|
+
# gate-winget-rojo y gate-paquetes-rojo dejaron de mirar un tag, con la
|
|
10
|
+
# cabecera de release.yml diciendo «corre los MISMOS gates que el CI».
|
|
11
|
+
#
|
|
12
|
+
# Arreglarlo una vez no alcanza: la copia vuelve la próxima vez que alguien
|
|
13
|
+
# tenga apuro. Esto comprueba la forma que lo impide —un solo gates.yml, y los
|
|
14
|
+
# dos workflows delegando en él— y no la lista de gates, que es justo lo que
|
|
15
|
+
# vuelve a quedar desactualizado.
|
|
16
|
+
#
|
|
17
|
+
# Lo que se comprueba es de FORMA a propósito: si ci.yml corre un gate propio,
|
|
18
|
+
# es una copia aunque hoy diga lo mismo que gates.yml.
|
|
19
|
+
|
|
20
|
+
set -euo pipefail
|
|
21
|
+
raiz=$(cd "$(dirname "$0")/.." && pwd)
|
|
22
|
+
cd "$raiz"
|
|
23
|
+
|
|
24
|
+
fallas=0
|
|
25
|
+
fallar() { echo "✗ $1" >&2; fallas=$((fallas + 1)); }
|
|
26
|
+
|
|
27
|
+
GATES=.github/workflows/gates.yml
|
|
28
|
+
CI=.github/workflows/ci.yml
|
|
29
|
+
REL=.github/workflows/release.yml
|
|
30
|
+
|
|
31
|
+
# ── 1. gates.yml existe y es llamable ──────────────────────────────────
|
|
32
|
+
if [ ! -f "$GATES" ]; then
|
|
33
|
+
fallar "no existe $GATES: los gates volvieron a vivir en cada workflow"
|
|
34
|
+
else
|
|
35
|
+
grep -q 'workflow_call' "$GATES" \
|
|
36
|
+
|| fallar "$GATES no tiene 'on: workflow_call': nadie puede llamarlo"
|
|
37
|
+
fi
|
|
38
|
+
|
|
39
|
+
# ── 2. los dos workflows delegan ───────────────────────────────────────
|
|
40
|
+
for wf in "$CI" "$REL"; do
|
|
41
|
+
grep -q 'uses: \./\.github/workflows/gates\.yml' "$wf" \
|
|
42
|
+
|| fallar "$wf no llama a gates.yml: o corre otra cosa, o no corre nada"
|
|
43
|
+
done
|
|
44
|
+
|
|
45
|
+
# ── 3. y ninguno corre gates por su cuenta ─────────────────────────────
|
|
46
|
+
# El CI no tiene nada que correr fuera de gates.yml. La release sí —arma el
|
|
47
|
+
# .deb, publica, firma el repo de apt—, así que acá se mira sólo que no vuelva
|
|
48
|
+
# a aparecer un `make gate-…` o un scripts/gate-… suelto: eso es la copia.
|
|
49
|
+
if grep -nE '^\s+- (run|name):' "$CI" >/dev/null 2>&1; then
|
|
50
|
+
fallar "$CI tiene pasos propios: los gates del CI van en gates.yml"
|
|
51
|
+
fi
|
|
52
|
+
|
|
53
|
+
sueltos=$(grep -nE 'make gate-|scripts/gate-|el-paquete-de-npm-corre' "$REL" \
|
|
54
|
+
| grep -v '^\s*#' | grep -vE '^[0-9]+:\s*#' || true)
|
|
55
|
+
if [ -n "$sueltos" ]; then
|
|
56
|
+
fallar "$REL corre gates por su cuenta — ésa es la copia que se desincroniza:"
|
|
57
|
+
echo "$sueltos" | sed 's/^/ /' >&2
|
|
58
|
+
fi
|
|
59
|
+
|
|
60
|
+
# ── 4. que gates.yml tenga de verdad los tres jobs ─────────────────────
|
|
61
|
+
# Delegar en un gates.yml vacío pasaría los tres puntos de arriba.
|
|
62
|
+
for job in check dibujo bandeja; do
|
|
63
|
+
grep -qE "^ $job:" "$GATES" \
|
|
64
|
+
|| fallar "$GATES no tiene el job '$job': se delega en un archivo incompleto"
|
|
65
|
+
done
|
|
66
|
+
|
|
67
|
+
if [ "$fallas" -ne 0 ]; then
|
|
68
|
+
echo "" >&2
|
|
69
|
+
echo " Hay una segunda copia de los gates. La de la release fue la que se" >&2
|
|
70
|
+
echo " quedó atrás la vez pasada, y estuvo ocho gates corta durante quince" >&2
|
|
71
|
+
echo " versiones sin que nada se pusiera rojo." >&2
|
|
72
|
+
exit 1
|
|
73
|
+
fi
|
|
74
|
+
|
|
75
|
+
echo "✓ un solo gates.yml, y ci.yml y release.yml delegan los dos en él"
|
package/scripts/gate-dibujo.sh
CHANGED
|
@@ -136,4 +136,17 @@ PY
|
|
|
136
136
|
# menú, y un menú rueda item por item.
|
|
137
137
|
python3 scripts/gate-tarjetas.py || exit 1
|
|
138
138
|
|
|
139
|
+
# 5 · que el nombre de cada dibujo no se repita NUNCA.
|
|
140
|
+
#
|
|
141
|
+
# GNOME Shell cachea la textura por ruta y sólo suelta la entrada vieja
|
|
142
|
+
# cuando su GFileMonitor le avisa, que llega después de que la extensión ya
|
|
143
|
+
# leyó estado.json y pintó. Un nombre repetido deja el item mostrando el
|
|
144
|
+
# dibujo de antes hasta que algo lo obliga a releer —pasarle el mouse por
|
|
145
|
+
# arriba, por ejemplo—, y desde afuera se ve como que los números cambian
|
|
146
|
+
# solos cuando movés el mouse por la barra. Acá vivió una rotación de DOS
|
|
147
|
+
# nombres que parecía alcanzar: no alcanzaba, uno de cada dos refrescos
|
|
148
|
+
# volvía a caer sobre una ruta que el cache ya tenía. Un sello que se pisa
|
|
149
|
+
# bajo carga, o un reloj que salta para atrás, traen el mismo bug de vuelta.
|
|
150
|
+
python3 scripts/gate-sellos.py || fallar "el nombre de los dibujos se puede repetir"
|
|
151
|
+
|
|
139
152
|
echo "gate de dibujo: verde"
|
|
@@ -0,0 +1,69 @@
|
|
|
1
|
+
#!/usr/bin/env python3
|
|
2
|
+
"""Que el nombre de cada dibujo no se repita nunca.
|
|
3
|
+
|
|
4
|
+
Cada refresco del indicador escribe un PNG nuevo y le deja la ruta a la
|
|
5
|
+
extensión de GNOME Shell. El shell cachea la textura POR RUTA y sólo suelta la
|
|
6
|
+
entrada vieja cuando su propio GFileMonitor le avisa que el archivo cambió: ese
|
|
7
|
+
aviso llega después de que la extensión ya leyó estado.json y pintó, y no vuelve
|
|
8
|
+
a pintar solo. O sea que reescribir una ruta que el shell ya vio deja el item
|
|
9
|
+
mostrando el dibujo anterior, y ahí se queda hasta que algo lo obliga a releer.
|
|
10
|
+
|
|
11
|
+
Pasarle el mouse por arriba lo obliga: el hover recalcula el estilo. Por eso el
|
|
12
|
+
bug se veía como «los números cambian cuando paso el mouse por la barra» — no
|
|
13
|
+
los cambiaba el hover, los destapaba.
|
|
14
|
+
|
|
15
|
+
Antes había una rotación de dos nombres (`barra-0.png` / `barra-1.png`) puesta
|
|
16
|
+
justamente para esquivar ese cache. No alcanza: con dos nombres, uno de cada dos
|
|
17
|
+
refrescos vuelve a caer sobre una ruta que el cache ya tiene. Hoy el nombre
|
|
18
|
+
lleva un sello que no se repite, y esto es lo que lo comprueba.
|
|
19
|
+
"""
|
|
20
|
+
|
|
21
|
+
import importlib.machinery
|
|
22
|
+
import importlib.util
|
|
23
|
+
import sys
|
|
24
|
+
|
|
25
|
+
# Son muchos y seguidos a propósito: así es como se pisan dos lecturas del reloj
|
|
26
|
+
# si la máquina no tiene la resolución que `time_ns` promete.
|
|
27
|
+
CUANTOS = 20_000
|
|
28
|
+
|
|
29
|
+
|
|
30
|
+
def cargar():
|
|
31
|
+
"""bin/qm-indicator no termina en .py: hay que darle el loader a mano."""
|
|
32
|
+
spec = importlib.util.spec_from_loader(
|
|
33
|
+
"qm", importlib.machinery.SourceFileLoader("qm", "bin/qm-indicator"))
|
|
34
|
+
modulo = importlib.util.module_from_spec(spec)
|
|
35
|
+
spec.loader.exec_module(modulo)
|
|
36
|
+
return modulo
|
|
37
|
+
|
|
38
|
+
|
|
39
|
+
def main() -> int:
|
|
40
|
+
qmi = cargar()
|
|
41
|
+
fallas = []
|
|
42
|
+
|
|
43
|
+
sellos = [qmi.sello_nuevo() for _ in range(CUANTOS)]
|
|
44
|
+
repetidos = len(sellos) - len(set(sellos))
|
|
45
|
+
if repetidos:
|
|
46
|
+
fallas.append(f"{repetidos} sellos repetidos de {CUANTOS}: dos dibujos "
|
|
47
|
+
"distintos compartirían nombre")
|
|
48
|
+
if sellos != sorted(sellos):
|
|
49
|
+
fallas.append("los sellos no siempre crecen")
|
|
50
|
+
|
|
51
|
+
# Y con el reloj movido para atrás, que es lo que hace un ajuste de NTP.
|
|
52
|
+
# Sin la guardia, el sello vuelve a un número ya usado y el nombre se repite.
|
|
53
|
+
ultimo = sellos[-1]
|
|
54
|
+
qmi.time.time_ns = lambda: 1
|
|
55
|
+
if qmi.sello_nuevo() <= ultimo:
|
|
56
|
+
fallas.append("con el reloj para atrás el sello vuelve a uno ya usado")
|
|
57
|
+
|
|
58
|
+
if fallas:
|
|
59
|
+
for f in fallas:
|
|
60
|
+
print(f"GATE ROJO: {f}", file=sys.stderr)
|
|
61
|
+
return 1
|
|
62
|
+
|
|
63
|
+
print(f"sellos: {CUANTOS} seguidos sin repetir uno, y un reloj que salta "
|
|
64
|
+
"para atrás no los rompe")
|
|
65
|
+
return 0
|
|
66
|
+
|
|
67
|
+
|
|
68
|
+
if __name__ == "__main__":
|
|
69
|
+
sys.exit(main())
|