@legios/quartermaster 0.1.15 → 0.1.17
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 +11 -4
- package/bin/qm-indicator +71 -11
- package/dist/adapters/gemini.js +308 -0
- package/dist/adapters/gemini.js.map +1 -0
- package/dist/cli/qm.js +54 -9
- package/dist/cli/qm.js.map +1 -1
- package/dist/render/barras.js +29 -0
- package/dist/render/barras.js.map +1 -1
- 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
|
@@ -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())
|