@legios/quartermaster 0.1.3

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.
Files changed (46) hide show
  1. package/LICENSE +21 -0
  2. package/README.md +1276 -0
  3. package/bin/qm +66 -0
  4. package/bin/qm-barra +63 -0
  5. package/bin/qm-barra.swift +1253 -0
  6. package/bin/qm-indicator +2063 -0
  7. package/bin/qm-tray +41 -0
  8. package/bin/qm-tray.ps1 +1241 -0
  9. package/bin/qm-web +137 -0
  10. package/dist/adapters/cache-cuota.js +45 -0
  11. package/dist/adapters/cache-cuota.js.map +1 -0
  12. package/dist/adapters/cache-endpoint.js +66 -0
  13. package/dist/adapters/cache-endpoint.js.map +1 -0
  14. package/dist/adapters/codex.js +462 -0
  15. package/dist/adapters/codex.js.map +1 -0
  16. package/dist/adapters/credenciales.js +88 -0
  17. package/dist/adapters/credenciales.js.map +1 -0
  18. package/dist/adapters/cuota.js +73 -0
  19. package/dist/adapters/cuota.js.map +1 -0
  20. package/dist/adapters/historial.js +103 -0
  21. package/dist/adapters/historial.js.map +1 -0
  22. package/dist/adapters/opencode.js +214 -0
  23. package/dist/adapters/opencode.js.map +1 -0
  24. package/dist/adapters/transcripciones.js +129 -0
  25. package/dist/adapters/transcripciones.js.map +1 -0
  26. package/dist/adapters/utilizacion.js +151 -0
  27. package/dist/adapters/utilizacion.js.map +1 -0
  28. package/dist/cli/demo-h1.js +60 -0
  29. package/dist/cli/demo-h1.js.map +1 -0
  30. package/dist/cli/preflight.js +39 -0
  31. package/dist/cli/preflight.js.map +1 -0
  32. package/dist/cli/qm.js +779 -0
  33. package/dist/cli/qm.js.map +1 -0
  34. package/dist/core/config.js +63 -0
  35. package/dist/core/config.js.map +1 -0
  36. package/dist/core/perfiles.js +139 -0
  37. package/dist/core/perfiles.js.map +1 -0
  38. package/dist/core/proyeccion.js +83 -0
  39. package/dist/core/proyeccion.js.map +1 -0
  40. package/dist/core/tipos.js +101 -0
  41. package/dist/core/tipos.js.map +1 -0
  42. package/dist/render/barras.js +62 -0
  43. package/dist/render/barras.js.map +1 -0
  44. package/dist/render/tablero.html +664 -0
  45. package/package.json +59 -0
  46. package/src/render/tablero.html +664 -0
package/dist/cli/qm.js ADDED
@@ -0,0 +1,779 @@
1
+ #!/usr/bin/env node
2
+ // qm · cuánta cuota te queda, en todos tus perfiles.
3
+ //
4
+ // Tres fuentes, de la más barata a la más cara:
5
+ //
6
+ // 1. `cachedUsageUtilization` en .claude.json — la última respuesta de cuota
7
+ // que recibió Claude Code. Sin red, sin credencial, y funciona aunque el
8
+ // token esté vencido. Es el camino por defecto.
9
+ // 2. el endpoint, sólo con --refrescar, para el perfil cuyo cache quedó viejo.
10
+ // 3. las transcripciones locales, que no dicen el límite pero no fallan nunca.
11
+ //
12
+ // La 3 no es un fallback opcional: es el piso. Si no hay número de cuota, igual
13
+ // hay consumo — y además una frase que dice por qué falta el otro.
14
+ import { homedir } from 'node:os';
15
+ import { descubrirPerfiles } from "../core/perfiles.js";
16
+ import { estadoCredencial } from "../adapters/credenciales.js";
17
+ import { consumoDesde, transcripciones } from "../adapters/transcripciones.js";
18
+ import { cuotaEnCache } from "../adapters/cache-cuota.js";
19
+ import { anotar, claveBarra, muestras } from "../adapters/historial.js";
20
+ import { proyectar, VENTANA_AJUSTE_MS } from "../core/proyeccion.js";
21
+ import { consultarCuota } from "../adapters/cuota.js";
22
+ import { codexEnCache, codexEnDisco, modoCodex, consultarCodex, consumoCodex, duenoCodex, hayCodex, DIRECTORIO_CODEX, } from "../adapters/codex.js";
23
+ import { endpointEnCache, guardarEndpoint, masNueva } from "../adapters/cache-endpoint.js";
24
+ import { leerConfigUsuario, RUTA_CONFIG, seleccionar } from "../core/config.js";
25
+ import { consumoOpencode, hayOpencode, limitesOpencode, ultimoUsoOpencode, } from "../adapters/opencode.js";
26
+ import { esPreocupante, frase, nombreVentana, paraMostrar, peor, semanal, sesion, totalTokens, } from "../core/tipos.js";
27
+ import { barra, duracion, negrita, relleno, rojo, tenue, tokens, verde, amarillo, } from "../render/barras.js";
28
+ /**
29
+ * Cuánto vale el cache de Codex antes de volver a preguntar. Codex no deja la
30
+ * cuota en el disco, así que el cache es nuestro: si está viejo se refresca
31
+ * solo, salvo en --breve, que tiene que seguir tardando milisegundos.
32
+ */
33
+ const CODEX_FRESCO_MS = 5 * 60_000;
34
+ const AYUDA = `qm · cuánta cuota te queda, en todos tus perfiles de Claude Code
35
+
36
+ qm cuota y consumo de cada perfil. Sin red y sin credencial:
37
+ lee la cuota que Claude Code ya dejó en .claude.json
38
+ qm --refrescar además pide el número al endpoint (necesita token vigente)
39
+ qm --json lo mismo, para scripts y statuslines
40
+ qm --watch [seg] se redibuja cada N segundos (mínimo 30, por defecto 60)
41
+ qm --dias=N ventana del consumo local (por defecto 7)
42
+ qm --umbral=N sale con código 3 si alguna barra pasa el N %
43
+ qm --esperar no vuelve hasta que la cuota baje del umbral (80 por
44
+ defecto). Para encadenar: qm --esperar && codex ...
45
+ qm --cuenta=NOMBRE con --esperar: mirar sólo esa cuenta (codex, personal…)
46
+ qm --redactado con --json, saca mails y rutas de casa: para comitear
47
+ qm --breve un renglón y nada más. No lee transcripciones, así que
48
+ tarda milisegundos: es lo que va en una statusline
49
+ qm --solo=a,b mostrar SÓLO esas cuentas (personal, teams, codex…)
50
+ qm --ocultar=a,b mostrar todas menos esas
51
+ qm --sin-codex no mira la cuenta de Codex
52
+ qm --calentar refresca el endpoint de cada perfil y el de Codex, guarda
53
+ lo que vuelve y no imprime nada. Es lo que corre la barra
54
+ qm --cuentas=a,b con --calentar: sólo esas cuentas. Cada una que se saltea
55
+ es un pedido menos a un endpoint que no es nuestro
56
+ qm --calentar-codex igual pero sólo Codex, sin tocar el llavero
57
+
58
+ Nunca refresca un token. Si una credencial venció, lo dice y sigue con el
59
+ resto de los perfiles — la cuota igual se lee, porque sale del disco.`;
60
+ function parsearArgs(argv) {
61
+ const o = {
62
+ json: false,
63
+ watch: null,
64
+ refrescar: false,
65
+ dias: 7,
66
+ ventanaH: 5,
67
+ umbral: null,
68
+ redactado: false,
69
+ breve: false,
70
+ codex: true,
71
+ };
72
+ for (let i = 0; i < argv.length; i += 1) {
73
+ const a = argv[i];
74
+ if (a === '--json')
75
+ o.json = true;
76
+ else if (a === '--redactado')
77
+ o.redactado = true;
78
+ else if (a === '--breve')
79
+ o.breve = true;
80
+ else if (a === '--sin-codex')
81
+ o.codex = false;
82
+ // La selección la lee configEfectiva() de process.argv; acá sólo se
83
+ // aceptan para que el parser no las rechace.
84
+ else if (a.startsWith('--solo=') || a.startsWith('--ocultar='))
85
+ continue;
86
+ else if (a === '--refrescar' || a === '--red')
87
+ o.refrescar = true;
88
+ // --sin-red era el nombre viejo de lo que ahora es el comportamiento por
89
+ // defecto. Se acepta sin decir nada para no romper a quien ya lo escribió.
90
+ else if (a === '--sin-red' || a === '--offline')
91
+ o.refrescar = false;
92
+ else if (a === '--watch' || a.startsWith('--watch=')) {
93
+ const crudo = a.includes('=') ? a.split('=')[1] : argv[++i];
94
+ const n = crudo === undefined ? 60 : Number(crudo);
95
+ if (!Number.isFinite(n))
96
+ return `--watch espera segundos, no "${crudo}"`;
97
+ // Menos de 30 s no aporta nada y castiga un endpoint que no es nuestro.
98
+ o.watch = Math.max(30, n);
99
+ }
100
+ else if (a.startsWith('--dias=')) {
101
+ const n = Number(a.split('=')[1]);
102
+ if (!Number.isFinite(n) || n <= 0)
103
+ return '--dias espera un número de días';
104
+ o.dias = n;
105
+ }
106
+ else if (a.startsWith('--umbral=')) {
107
+ const n = Number(a.split('=')[1]);
108
+ if (!Number.isFinite(n) || n < 0 || n > 100)
109
+ return '--umbral espera un porcentaje 0..100';
110
+ o.umbral = n;
111
+ }
112
+ else if (a === '-h' || a === '--help')
113
+ return AYUDA;
114
+ else
115
+ return `opción desconocida: ${a}\n\n${AYUDA}`;
116
+ }
117
+ return o;
118
+ }
119
+ /**
120
+ * La cuenta de Codex como una fila más.
121
+ *
122
+ * Se le da forma de Perfil para que el render, el JSON y la proyección no
123
+ * tengan que saber que existen dos productos: lo único que cambia es de dónde
124
+ * salió el número, y eso ya lo dice `origen`.
125
+ */
126
+ async function filaCodex(o) {
127
+ if (!hayCodex())
128
+ return null;
129
+ // El disco primero, igual que en Claude: Codex deja la cuota en sus rollouts
130
+ // y leerla no cuesta red ni credencial. Se compara con lo último que dejó el
131
+ // app-server y gana la más nueva de las dos.
132
+ let { cuota, info } = codexEnDisco();
133
+ const guardada = codexEnCache();
134
+ if (guardada.cuota.estado === 'ok' &&
135
+ (cuota.estado !== 'ok' || guardada.cuota.medidoEn.getTime() > cuota.medidoEn.getTime())) {
136
+ ({ cuota, info } = guardada);
137
+ }
138
+ // Sólo se sale a la red cuando lo piden. Antes se refrescaba solo con el
139
+ // cache vencido, y eso —con la barra sondeando— era pegarle al app-server
140
+ // todo el tiempo para confirmar lo que el disco ya decía.
141
+ let notaRefresco = null;
142
+ if (o.refrescar) {
143
+ const fresca = await consultarCodex();
144
+ if (fresca.cuota.estado === 'ok')
145
+ ({ cuota, info } = fresca);
146
+ else if (cuota.estado !== 'ok')
147
+ cuota = fresca.cuota;
148
+ else
149
+ notaRefresco = frase(fresca.cuota, 'codex');
150
+ }
151
+ const dueno = duenoCodex();
152
+ const perfil = {
153
+ directorio: DIRECTORIO_CODEX,
154
+ nombre: 'codex',
155
+ porDefecto: false,
156
+ cuenta: {
157
+ email: dueno?.email ?? info?.accountId ?? null,
158
+ organizacion: null,
159
+ // El modo va al final y no antes: si hay suscripción de verdad, el plan
160
+ // que informa el rollout o el id_token es más preciso que «api key».
161
+ plan: info?.plan ?? dueno?.plan ?? (modoCodex() === 'apikey' ? 'api key' : null),
162
+ },
163
+ };
164
+ let proyeccion = null;
165
+ if (cuota.estado === 'ok') {
166
+ try {
167
+ anotar(cuota.ventanas.map((v) => ({
168
+ perfil: 'codex',
169
+ barra: claveBarra(v.clave, v.alcance),
170
+ medidoEn: cuota.medidoEn,
171
+ porcentaje: v.porcentaje,
172
+ })));
173
+ }
174
+ catch {
175
+ // Igual que con Claude: sin historial se pierde la proyección, nada más.
176
+ }
177
+ const p = peor(paraMostrar(cuota.ventanas));
178
+ if (p !== null) {
179
+ proyeccion = proyectar(muestras('codex', claveBarra(p.clave, p.alcance)), p.porcentaje, p.reinicia);
180
+ }
181
+ }
182
+ // El piso que pide SOUL: aunque el app-server se caiga y el disco no traiga
183
+ // barras, los rollouts siguen teniendo cuántos tokens gastaste.
184
+ const local = o.breve
185
+ ? null
186
+ : consumoCodex(new Date(Date.now() - o.dias * 24 * 3600_000));
187
+ const ventana = o.breve ? null : consumoCodex(new Date(Date.now() - o.ventanaH * 3600_000));
188
+ return {
189
+ producto: 'codex',
190
+ localMedido: local !== null,
191
+ perfil,
192
+ veredicto: info === null ? 'la pone codex' : `la pone codex · ${info.creditosReset} reset(s) sin usar`,
193
+ cuota,
194
+ notaRefresco,
195
+ proyeccion,
196
+ archivos: local?.archivos ?? 0,
197
+ requests: local?.requests ?? 0,
198
+ tokens: local?.tokens ?? 0,
199
+ tokensVentana: ventana?.tokens ?? 0,
200
+ porModelo: [],
201
+ };
202
+ }
203
+ /**
204
+ * Los planes que viven adentro de opencode: GLM (zai), MiniMax, Kimi…
205
+ *
206
+ * Traen consumo real y NO traen cuota: son planes por API key y el porcentaje
207
+ * sólo existe del otro lado. La fila igual se muestra, con la frase que dice
208
+ * por qué no hay barra — una cuenta que gastó 2,7 M de tokens y no aparece es
209
+ * el bug original de este repo, con otro vendor.
210
+ */
211
+ function filasOpencode(o) {
212
+ // Antes esto salía en --breve, y con eso la fila desaparecía de TODAS las
213
+ // pantallas: todas piden --breve. Una cuenta con una key de z.ai que se usó
214
+ // ayer y no aparece es, literalmente, el bug que da nombre a la primera
215
+ // sección del README. Lo que costaba era limitesOpencode() —439 ms—, así que
216
+ // se arregló la consulta en vez de esconder la fila: opencode entero son
217
+ // ~25 ms, que sí entran en el contrato de --breve.
218
+ if (!hayOpencode())
219
+ return [];
220
+ // Las dos formas del mismo proveedor. opencode no usa un `providerID` estable
221
+ // entre instalaciones: en la máquina donde se escribió esto la base guarda
222
+ // `zai` a secas, y el mapa original sólo tenía `zai-coding-plan` — así que la
223
+ // fila se llamaba `zai` y el nombre lindo no se aplicaba nunca. Verificado
224
+ // contra la base: los providerID reales son zai, openai, amazon-bedrock,
225
+ // anthropic y opencode-go.
226
+ const bonito = {
227
+ zai: 'glm',
228
+ 'zai-coding-plan': 'glm',
229
+ minimax: 'minimax',
230
+ 'minimax-coding-plan': 'minimax',
231
+ kimi: 'kimi',
232
+ 'kimi-for-coding': 'kimi',
233
+ xai: 'grok',
234
+ 'opencode-go': 'opencode-go',
235
+ };
236
+ const desde = new Date(Date.now() - o.dias * 24 * 3600_000);
237
+ const ventana = new Date(Date.now() - o.ventanaH * 3600_000);
238
+ const enVentana = new Map(consumoOpencode(ventana).map((c) => [c.proveedor, c.tokens]));
239
+ const enDias = new Map(consumoOpencode(desde).map((c) => [c.proveedor, c]));
240
+ const visto = ultimoUsoOpencode();
241
+ const limites = limitesOpencode();
242
+ // 30 días: una cuenta que usás cada tanto tiene que seguir estando.
243
+ const corte = Date.now() - 30 * 24 * 3600_000;
244
+ const proveedores = [...visto.entries()]
245
+ .filter(([, d]) => d.getTime() >= corte)
246
+ .sort((a, b) => (enDias.get(b[0])?.tokens ?? 0) - (enDias.get(a[0])?.tokens ?? 0));
247
+ return proveedores.map(([prov, cuando]) => {
248
+ const c = enDias.get(prov) ?? { proveedor: prov, modelo: null, tokens: 0, sesiones: 0, costo: 0 };
249
+ return ({
250
+ producto: 'opencode',
251
+ localMedido: true,
252
+ perfil: {
253
+ directorio: 'opencode',
254
+ nombre: bonito[prov] ?? prov,
255
+ porDefecto: false,
256
+ // El plan es el proveedor, no el modelo. Acá iba `c.modelo` —el id del
257
+ // modelo más usado— y eso ponía `glm-5.3` donde las otras filas ponen
258
+ // `team_tier_1` o `plus`: un modelo no es un plan, y además cambia solo
259
+ // cuando cambiás de modelo. El modelo ya se muestra en el desglose de
260
+ // abajo, que es su lugar.
261
+ cuenta: { email: null, organizacion: 'opencode', plan: prov },
262
+ },
263
+ veredicto: `vía opencode · último uso hace ${duracion(Date.now() - cuando.getTime())}`,
264
+ cuota: cuotaDeLimite(prov, limites.get(prov)),
265
+ notaRefresco: null,
266
+ proyeccion: null,
267
+ archivos: c.sesiones,
268
+ requests: c.sesiones,
269
+ tokens: c.tokens,
270
+ tokensVentana: enVentana.get(c.proveedor) ?? 0,
271
+ porModelo: c.modelo === null ? [] : [[c.modelo, c.tokens]],
272
+ });
273
+ });
274
+ }
275
+ /**
276
+ * Lo que se puede afirmar de un plan por API key.
277
+ *
278
+ * No hay porcentaje —se probó: ni `/models` ni una llamada real devuelven
279
+ * cabeceras de límite en zai ni en minimax—. Pero cuando el proveedor te frena
280
+ * contesta un 429 con la fecha de reinicio, y opencode guarda esa respuesta.
281
+ * Con eso alcanza para lo único que se hace con el número: saber si estás
282
+ * frenado y cuándo te liberás.
283
+ *
284
+ * Si el reinicio ya pasó, no se afirma nada: se dice que no hay barra y cuándo
285
+ * fue la última vez que te frenaron. Un límite de la semana pasada no dice nada
286
+ * de hoy.
287
+ */
288
+ function cuotaDeLimite(prov, lim) {
289
+ const sinBarra = (extra) => ({
290
+ estado: 'sin-cuota-legible',
291
+ detalle: `plan por API key: el porcentaje no está en esta máquina${extra}`,
292
+ });
293
+ if (lim === undefined)
294
+ return sinBarra('');
295
+ if (lim.reinicia !== null && lim.reinicia.getTime() > Date.now()) {
296
+ // Evidencia directa: el proveedor dijo que te frenó y cuándo se libera.
297
+ return {
298
+ estado: 'ok',
299
+ origen: 'cache',
300
+ medidoEn: lim.cuando,
301
+ ventanas: [
302
+ {
303
+ clave: 'plan',
304
+ alcance: null,
305
+ grupo: 'weekly',
306
+ porcentaje: 100,
307
+ severidad: 'warning',
308
+ activa: true,
309
+ reinicia: lim.reinicia,
310
+ },
311
+ ],
312
+ };
313
+ }
314
+ return sinBarra(` · último límite hace ${duracion(Date.now() - lim.cuando.getTime())}`);
315
+ }
316
+ async function medir(o) {
317
+ const perfiles = descubrirPerfiles();
318
+ const desde = new Date(Date.now() - o.dias * 24 * 3600_000);
319
+ const desdeVentana = new Date(Date.now() - o.ventanaH * 3600_000);
320
+ const claude = await Promise.all(perfiles.map(async (perfil) => {
321
+ const cred = estadoCredencial(perfil);
322
+ const veredicto = cred.error !== null
323
+ ? `ilegible · ${cred.error}`
324
+ : !cred.presente
325
+ ? 'sin credencial'
326
+ : cred.vencida
327
+ ? 'vencida'
328
+ : `vigente (${duracion((cred.expiraEn?.getTime() ?? 0) - Date.now())})`;
329
+ // El cache primero: es gratis y no necesita credencial. Se toma la más
330
+ // nueva entre la que dejó Claude Code y la que dejamos nosotros la última
331
+ // vez que se consultó el endpoint.
332
+ let cuota = masNueva(cuotaEnCache(perfil), endpointEnCache(perfil.nombre));
333
+ let notaRefresco = null;
334
+ if (o.refrescar) {
335
+ const fresca = await consultarCuota(perfil);
336
+ if (fresca.estado === 'ok') {
337
+ cuota = fresca;
338
+ guardarEndpoint(perfil.nombre, fresca);
339
+ }
340
+ else
341
+ notaRefresco = frase(fresca, perfil.directorio);
342
+ }
343
+ // Cada lectura alimenta la serie que hace posible la proyección. Se
344
+ // indexa por `medidoEn`, así que mirar el mismo cache diez veces deja
345
+ // una sola muestra.
346
+ let proyeccion = null;
347
+ if (cuota.estado === 'ok') {
348
+ const lecturas = cuota.ventanas.map((v) => ({
349
+ perfil: perfil.nombre,
350
+ barra: claveBarra(v.clave, v.alcance),
351
+ medidoEn: cuota.medidoEn,
352
+ porcentaje: v.porcentaje,
353
+ }));
354
+ try {
355
+ anotar(lecturas);
356
+ }
357
+ catch {
358
+ // Si el cache del usuario no es escribible, se pierde la proyección
359
+ // y nada más. No es motivo para no mostrar el número.
360
+ }
361
+ const p = peor(paraMostrar(cuota.ventanas));
362
+ if (p !== null) {
363
+ proyeccion = proyectar(muestras(perfil.nombre, claveBarra(p.clave, p.alcance)), p.porcentaje, p.reinicia);
364
+ }
365
+ }
366
+ // En modo breve no se tocan las transcripciones: son 128 archivos y un
367
+ // segundo entero, y una statusline se dibuja todo el tiempo.
368
+ if (o.breve) {
369
+ return {
370
+ producto: 'claude',
371
+ localMedido: false,
372
+ perfil,
373
+ veredicto,
374
+ cuota,
375
+ notaRefresco,
376
+ proyeccion,
377
+ archivos: 0,
378
+ requests: 0,
379
+ tokens: 0,
380
+ tokensVentana: 0,
381
+ porModelo: [],
382
+ };
383
+ }
384
+ const c = await consumoDesde(perfil, desde);
385
+ const v = await consumoDesde(perfil, desdeVentana);
386
+ return {
387
+ producto: 'claude',
388
+ localMedido: true,
389
+ perfil,
390
+ veredicto,
391
+ cuota,
392
+ notaRefresco,
393
+ proyeccion,
394
+ archivos: transcripciones(perfil).length,
395
+ requests: c.requests,
396
+ tokens: totalTokens(c),
397
+ tokensVentana: totalTokens(v),
398
+ porModelo: [...c.porModelo].sort((a, b) => b[1] - a[1]).slice(0, 3),
399
+ };
400
+ }));
401
+ const codex = o.codex ? await filaCodex(o) : null;
402
+ const todas = [...claude, ...(codex === null ? [] : [codex]), ...filasOpencode(o)];
403
+ // Descubrir todo y mostrar todo no son lo mismo: lo primero es la misión,
404
+ // lo segundo es una preferencia.
405
+ const { filas, nota } = seleccionar(todas, configEfectiva());
406
+ if (nota !== null && !o.json && !o.breve)
407
+ console.error(tenue(` (${nota} · ${RUTA_CONFIG})`));
408
+ return filas;
409
+ }
410
+ /** La config del archivo, con --solo / --ocultar pisándola. */
411
+ function configEfectiva() {
412
+ const base = leerConfigUsuario();
413
+ const arg = (n) => {
414
+ const a = process.argv.find((x) => x.startsWith(`--${n}=`));
415
+ return a === undefined ? null : a.slice(n.length + 3).split(',').filter((x) => x !== '');
416
+ };
417
+ const solo = arg('solo');
418
+ const ocultar = arg('ocultar');
419
+ return {
420
+ mostrar: solo ?? base.mostrar,
421
+ ocultar: ocultar ?? base.ocultar,
422
+ };
423
+ }
424
+ const colorPct = (p) => (p >= 90 ? rojo : p >= 70 ? amarillo : verde);
425
+ /** «cache · hace 25m». Que la edad viaje pegada al número es la mitad del punto. */
426
+ function sello(r) {
427
+ const edadMs = Date.now() - r.medidoEn.getTime();
428
+ if (r.origen === 'endpoint')
429
+ return tenue('endpoint · ahora');
430
+ const texto = `cache · hace ${duracion(edadMs)}`;
431
+ // Seis horas es más que cualquier ventana de 5 h: a esa altura el número
432
+ // puede describir una ventana que ya se reinició.
433
+ return edadMs > 6 * 3600_000 ? amarillo(`${texto} — viejo`) : tenue(texto);
434
+ }
435
+ function pintarVentana(v, marca) {
436
+ const pct = `${v.porcentaje.toFixed(0)}%`.padStart(4);
437
+ const resta = v.reinicia
438
+ ? tenue(` reinicia en ${duracion(v.reinicia.getTime() - Date.now())}`)
439
+ : '';
440
+ const aviso = v.severidad !== 'normal' ? ` ${amarillo(v.severidad)}` : '';
441
+ const flecha = marca ? negrita('▸ ') : ' ';
442
+ console.log(` ${relleno('', 17)}${flecha}${relleno(nombreVentana(v), 24)} ${barra(v.porcentaje / 100)} ${colorPct(v.porcentaje)(pct)}${aviso}${resta}`);
443
+ }
444
+ /**
445
+ * Hacia dónde va. La frase de 'sin-datos' importa tanto como la proyección:
446
+ * es la diferencia entre «no vas a chocarte» y «todavía no sé si te vas a
447
+ * chocar», y confundirlas es exactamente el error que esta herramienta evita.
448
+ */
449
+ function fraseProyeccion(p) {
450
+ switch (p.estado) {
451
+ case 'sube': {
452
+ const cuando = `${p.ritmo.toFixed(1)} pts/h · 100 % en ${duracion(p.techo.getTime() - Date.now())}`;
453
+ return p.chocas ? rojo(`${cuando} — antes del reinicio`) : tenue(`${cuando} — después del reinicio`);
454
+ }
455
+ case 'plano':
456
+ return tenue(`no sube (${p.muestras} lecturas)`);
457
+ case 'sin-datos':
458
+ return tenue(`todavía no sé el ritmo: ${p.motivo}`);
459
+ }
460
+ }
461
+ function pintar(filas, o) {
462
+ console.log(negrita(`\nqm · ${process.platform} · consumo de ${o.dias}d\n`));
463
+ for (const f of filas) {
464
+ const cuenta = f.perfil.cuenta?.email ?? 'sin cuenta';
465
+ const plan = f.perfil.cuenta?.plan ? tenue(` · ${f.perfil.cuenta.plan}`) : '';
466
+ const colorCred = f.producto === 'codex'
467
+ ? tenue
468
+ : f.veredicto.startsWith('vigente')
469
+ ? verde
470
+ : f.veredicto === 'vencida'
471
+ ? amarillo
472
+ : rojo;
473
+ console.log(` ${negrita(relleno(f.perfil.nombre, 18))} ${relleno(cuenta, 30)}${plan}`);
474
+ console.log(` ${relleno('', 18)} ${tenue('credencial: ')}${colorCred(f.veredicto)}`);
475
+ if (f.cuota.estado === 'ok') {
476
+ const mostrar = paraMostrar(f.cuota.ventanas);
477
+ const p = peor(mostrar);
478
+ console.log(` ${relleno('', 18)} ${sello(f.cuota)}`);
479
+ for (const v of mostrar)
480
+ pintarVentana(v, p !== null && v.clave === p.clave);
481
+ }
482
+ else {
483
+ // Sin número de cuota, una frase. Nunca un renglón en blanco.
484
+ console.log(` ${relleno('', 18)} ${tenue(`cuota: ${frase(f.cuota, f.perfil.directorio)}`)}`);
485
+ }
486
+ if (f.proyeccion !== null) {
487
+ console.log(` ${relleno('', 18)} ${tenue('ritmo: ')}${fraseProyeccion(f.proyeccion)}`);
488
+ }
489
+ if (f.notaRefresco !== null) {
490
+ console.log(` ${relleno('', 18)} ${tenue(`--refrescar no sirvió: ${f.notaRefresco}`)}`);
491
+ }
492
+ if (f.localMedido) {
493
+ console.log(` ${relleno('', 18)} ${tenue(`local: ${tokens(f.tokens)} en ${o.dias}d · ${tokens(f.tokensVentana)} en ${o.ventanaH}h · ${f.requests} requests`)}`);
494
+ }
495
+ console.log();
496
+ }
497
+ // El renglón que sirve cuando no querés leer la tabla entera.
498
+ const peores = [];
499
+ for (const f of filas) {
500
+ if (f.cuota.estado !== 'ok')
501
+ continue;
502
+ const v = peor(paraMostrar(f.cuota.ventanas));
503
+ if (v !== null)
504
+ peores.push({ f, v });
505
+ }
506
+ peores.sort((a, b) => b.v.porcentaje - a.v.porcentaje);
507
+ const top = peores[0];
508
+ if (top) {
509
+ console.log(` ${negrita('lo primero que te frena:')} ${top.f.perfil.nombre} · ${nombreVentana(top.v)} ${colorPct(top.v.porcentaje)(`${top.v.porcentaje.toFixed(0)}%`)}` +
510
+ (top.v.reinicia ? tenue(` · reinicia en ${duracion(top.v.reinicia.getTime() - Date.now())}`) : ''));
511
+ console.log();
512
+ }
513
+ }
514
+ /**
515
+ * Los artefactos que se comitean no llevan direcciones de mail ni la ruta de
516
+ * casa de nadie. En la terminal se muestran enteros: es la máquina del dueño.
517
+ */
518
+ function redactar(o, texto) {
519
+ if (!o.redactado || texto === null)
520
+ return texto;
521
+ const arroba = texto.lastIndexOf('@');
522
+ if (arroba >= 0 && !texto.includes('/'))
523
+ return `***${texto.slice(arroba)}`;
524
+ return texto.replace(homedir(), '~');
525
+ }
526
+ /** `.claude-teams` → `teams`; el por defecto → `main`. Para que entre en una línea. */
527
+ function nombreCorto(n) {
528
+ const sin = n.replace(/^\.claude-?/, '');
529
+ return sin.length === 0 ? 'main' : sin;
530
+ }
531
+ /**
532
+ * Un renglón, pensado para una statusline: sólo la barra que más apremia de
533
+ * cada perfil que tenga número. Los perfiles sin cuota no se listan — en una
534
+ * línea de 80 columnas, decir «no sé» de tres perfiles tapa el que sí sabés.
535
+ */
536
+ function pintarBreve(filas) {
537
+ const partes = [];
538
+ for (const f of filas) {
539
+ if (f.cuota.estado !== 'ok')
540
+ continue;
541
+ const v = peor(paraMostrar(f.cuota.ventanas));
542
+ if (v === null)
543
+ continue;
544
+ const viejo = Date.now() - f.cuota.medidoEn.getTime() > 6 * 3600_000 ? '~' : '';
545
+ // El «!» ya no es sólo severidad: también avisa que a este ritmo tocás el
546
+ // techo antes de que la ventana se reinicie, que es lo que duele.
547
+ const chocas = f.proyeccion?.estado === 'sube' && f.proyeccion.chocas;
548
+ const aviso = v.severidad !== 'normal' || chocas ? '!' : '';
549
+ // Dos números, dos preguntas: la sesión dice si podés seguir AHORA, y la
550
+ // barra que frena antes dice si llegás al final de la ventana larga. Una
551
+ // sola de las dos deja media respuesta.
552
+ const sesion = paraMostrar(f.cuota.ventanas).find((w) => w.grupo === 'session' || w.clave === 'session');
553
+ const cifra = sesion === undefined || sesion.clave === v.clave
554
+ ? `${v.porcentaje.toFixed(0)}%`
555
+ : `${sesion.porcentaje.toFixed(0)}/${v.porcentaje.toFixed(0)}%`;
556
+ partes.push(`${nombreCorto(f.perfil.nombre)} ${colorPct(v.porcentaje)(`${viejo}${cifra}${aviso}`)}`);
557
+ }
558
+ console.log(partes.length === 0 ? 'sin cuota en cache' : partes.join(tenue(' · ')));
559
+ }
560
+ /** Las muestras recientes de la barra que frena, ya recortadas a la ventana de ajuste. */
561
+ function historiaDe(f) {
562
+ if (f.cuota.estado !== 'ok')
563
+ return [];
564
+ const v = peor(paraMostrar(f.cuota.ventanas));
565
+ if (v === null)
566
+ return [];
567
+ const ahora = Date.now();
568
+ return muestras(f.perfil.nombre, claveBarra(v.clave, v.alcance))
569
+ .filter((m) => ahora - m.t <= VENTANA_AJUSTE_MS && m.t <= ahora)
570
+ .sort((a, b) => a.t - b.t)
571
+ .map((m) => ({ t: m.t, porcentaje: m.porcentaje }));
572
+ }
573
+ function ventanaJson(v) {
574
+ return {
575
+ clave: v.clave,
576
+ alcance: v.alcance,
577
+ grupo: v.grupo,
578
+ porcentaje: v.porcentaje,
579
+ severidad: v.severidad,
580
+ activa: v.activa,
581
+ reinicia: v.reinicia?.toISOString() ?? null,
582
+ nombre: nombreVentana(v),
583
+ preocupa: esPreocupante(v),
584
+ };
585
+ }
586
+ const ventanaJson0 = (v) => v === null ? null : ventanaJson(v);
587
+ function comoJson(filas, o) {
588
+ return {
589
+ generado: new Date().toISOString(),
590
+ plataforma: process.platform,
591
+ ventanaDias: o.dias,
592
+ perfiles: filas.map((f) => ({
593
+ producto: f.producto,
594
+ perfil: f.perfil.nombre,
595
+ directorio: redactar(o, f.perfil.directorio),
596
+ cuenta: redactar(o, f.perfil.cuenta?.email ?? null),
597
+ plan: f.perfil.cuenta?.plan ?? null,
598
+ credencial: f.veredicto,
599
+ cuota: f.cuota.estado === 'ok'
600
+ ? {
601
+ estado: 'ok',
602
+ origen: f.cuota.origen,
603
+ medidoEn: f.cuota.medidoEn.toISOString(),
604
+ edadSegundos: Math.round((Date.now() - f.cuota.medidoEn.getTime()) / 1000),
605
+ ventanas: f.cuota.ventanas.map(ventanaJson),
606
+ // Las respuestas ya masticadas. Existen para que los que dibujan
607
+ // NO reimplementen las reglas: `peor()` y `paraMostrar()` llegaron
608
+ // a estar copiadas en Python, JavaScript y Swift, y una regla
609
+ // copiada tres veces vale distinto en cada pantalla en cuanto
610
+ // alguien toca el núcleo.
611
+ mostrar: paraMostrar(f.cuota.ventanas).map(ventanaJson),
612
+ frena: ventanaJson0(peor(paraMostrar(f.cuota.ventanas))),
613
+ sesion: ventanaJson0(sesion(paraMostrar(f.cuota.ventanas))),
614
+ semanal: ventanaJson0(semanal(paraMostrar(f.cuota.ventanas))),
615
+ // La serie de la barra que frena, para que se pueda DIBUJAR el
616
+ // ritmo en vez de sólo afirmarlo. «100 % en 21m» pide creerle a
617
+ // un número sin nada atrás; la curva se mira y se entiende sola,
618
+ // y además muestra las mesetas, que es cuando la recta no aplica.
619
+ historia: historiaDe(f),
620
+ }
621
+ : {
622
+ estado: f.cuota.estado,
623
+ frase: redactar(o, frase(f.cuota, f.perfil.directorio)),
624
+ },
625
+ proyeccion: f.proyeccion === null
626
+ ? null
627
+ : f.proyeccion.estado === 'sube'
628
+ ? {
629
+ estado: 'sube',
630
+ ritmoPuntosPorHora: Number(f.proyeccion.ritmo.toFixed(3)),
631
+ techo: f.proyeccion.techo.toISOString(),
632
+ chocasAntesDelReinicio: f.proyeccion.chocas,
633
+ muestras: f.proyeccion.muestras,
634
+ }
635
+ : f.proyeccion.estado === 'plano'
636
+ ? { estado: 'plano', muestras: f.proyeccion.muestras }
637
+ : { estado: 'sin-datos', motivo: f.proyeccion.motivo },
638
+ // En --breve no se leyeron las transcripciones. Informar 0 sería decir
639
+ // "no consumiste nada" cuando lo que pasa es "no lo medí".
640
+ local: o.breve || !f.localMedido
641
+ ? null
642
+ : {
643
+ tokens: f.tokens,
644
+ tokensVentana: f.tokensVentana,
645
+ requests: f.requests,
646
+ transcripciones: f.archivos,
647
+ porModelo: Object.fromEntries(f.porModelo),
648
+ },
649
+ })),
650
+ };
651
+ }
652
+ /** El porcentaje más alto visto en cualquier perfil, para --umbral. */
653
+ function maximo(filas) {
654
+ let m = 0;
655
+ for (const f of filas) {
656
+ if (f.cuota.estado !== 'ok')
657
+ continue;
658
+ for (const v of f.cuota.ventanas)
659
+ m = Math.max(m, v.porcentaje);
660
+ }
661
+ return m;
662
+ }
663
+ // --calentar sale antes que nada: es lo que corre el item de la barra en su
664
+ // sondeo, para que las lecturas rápidas (--breve) encuentren números frescos
665
+ // sin tener que hablar con nadie. Refresca las dos puntas —el endpoint de cada
666
+ // perfil de Claude y Codex— y no imprime nada.
667
+ if (process.argv.includes('--calentar') || process.argv.includes('--calentar-codex')) {
668
+ const soloCodex = !process.argv.includes('--calentar');
669
+ // --cuentas=a,b limita a quiénes se les pregunta. Cada cuenta que se salta
670
+ // es un pedido menos a un endpoint que no es nuestro.
671
+ const filtro = process.argv.find((a) => a.startsWith('--cuentas='));
672
+ const cuentas = filtro === undefined ? null : new Set(filtro.slice('--cuentas='.length).split(','));
673
+ let bien = false;
674
+ if (!soloCodex) {
675
+ for (const perfil of descubrirPerfiles()) {
676
+ if (cuentas !== null && !cuentas.has(perfil.nombre))
677
+ continue;
678
+ const r = await consultarCuota(perfil);
679
+ if (r.estado === 'ok') {
680
+ guardarEndpoint(perfil.nombre, r);
681
+ bien = true;
682
+ }
683
+ }
684
+ }
685
+ const c = cuentas !== null && !cuentas.has('codex')
686
+ ? { cuota: { estado: 'no-consultada' } }
687
+ : await consultarCodex();
688
+ process.exit(c.cuota.estado === 'ok' || bien ? 0 : 1);
689
+ }
690
+ /**
691
+ * `--esperar`: no volver hasta que se pueda trabajar.
692
+ *
693
+ * Es la otra mitad de `--umbral`. Ese contesta «¿estoy pasado?» y sirve para
694
+ * abortar; este contesta «avisame cuándo pueda» y sirve para encadenar:
695
+ *
696
+ * qm --esperar --cuenta=codex && codex exec "seguí donde quedaste"
697
+ *
698
+ * Duerme hasta el reinicio de la barra que frena —no hace polling ciego— con
699
+ * un piso de 60 s, que es el mismo piso que tiene todo lo que sale a la red.
700
+ */
701
+ if (process.argv.includes('--esperar')) {
702
+ const arg = (n) => process.argv.find((a) => a.startsWith(`--${n}=`))?.slice(n.length + 3) ?? null;
703
+ const cuenta = arg('cuenta');
704
+ const umbral = Number(arg('umbral') ?? 80);
705
+ const opts = { ...parsearArgs([]), breve: true };
706
+ for (;;) {
707
+ const filas = (await medir(opts)).filter((f) => cuenta === null || f.perfil.nombre.includes(cuenta));
708
+ if (filas.length === 0) {
709
+ console.error(cuenta === null ? 'no hay ninguna cuenta' : `no encontré la cuenta "${cuenta}"`);
710
+ process.exit(2);
711
+ }
712
+ let peorPct = 0;
713
+ let cuando = null;
714
+ for (const f of filas) {
715
+ if (f.cuota.estado !== 'ok')
716
+ continue;
717
+ const v = peor(paraMostrar(f.cuota.ventanas));
718
+ if (v === null)
719
+ continue;
720
+ if (v.porcentaje > peorPct) {
721
+ peorPct = v.porcentaje;
722
+ cuando = v.reinicia;
723
+ }
724
+ }
725
+ if (peorPct < umbral) {
726
+ console.log(`libre: la barra que más apremia va ${peorPct} % (umbral ${umbral} %)`);
727
+ process.exit(0);
728
+ }
729
+ // Dormir hasta el reinicio, no sondear a ciegas.
730
+ const faltan = cuando === null ? 60_000 : Math.max(60_000, cuando.getTime() - Date.now() + 5_000);
731
+ console.error(`${peorPct} % · esperando ${duracion(faltan)}` +
732
+ (cuando === null ? '' : ` (reinicia ${cuando.toLocaleTimeString()})`));
733
+ await new Promise((r) => setTimeout(r, faltan));
734
+ }
735
+ }
736
+ const opciones = parsearArgs(process.argv.slice(2));
737
+ if (typeof opciones === 'string') {
738
+ console.log(opciones);
739
+ process.exit(opciones === AYUDA ? 0 : 2);
740
+ }
741
+ const unaVuelta = async () => {
742
+ const filas = await medir(opciones);
743
+ if (filas.length === 0) {
744
+ // --json es un contrato, y tiene que devolver JSON también cuando la
745
+ // respuesta es «ninguna». Antes escupía una frase en castellano, así que
746
+ // cualquier statusline o script que lo parseara se rompía justo en la
747
+ // máquina donde todavía no hay nada instalado — que es la primera vez que
748
+ // alguien lo corre.
749
+ if (opciones.json)
750
+ console.log(JSON.stringify(comoJson(filas, opciones), null, 2));
751
+ else
752
+ console.log('No se encontró ninguna cuenta de Claude Code ni de Codex en esta máquina.');
753
+ // Y no es un error: que no haya cuentas es una respuesta, no una falla.
754
+ return 0;
755
+ }
756
+ if (opciones.json)
757
+ console.log(JSON.stringify(comoJson(filas, opciones), null, 2));
758
+ else if (opciones.breve)
759
+ pintarBreve(filas);
760
+ else
761
+ pintar(filas, opciones);
762
+ if (opciones.umbral !== null && maximo(filas) >= opciones.umbral)
763
+ return 3;
764
+ return 0;
765
+ };
766
+ if (opciones.watch === null) {
767
+ process.exit(await unaVuelta());
768
+ }
769
+ // --watch: se redibuja hasta que lo maten. Se limpia la pantalla sólo si hay
770
+ // terminal; redirigido a un archivo, un \x1b[2J cada minuto es basura.
771
+ const limpiar = process.stdout.isTTY === true;
772
+ for (;;) {
773
+ if (limpiar)
774
+ process.stdout.write('\x1b[2J\x1b[H');
775
+ await unaVuelta();
776
+ console.log(tenue(` actualiza cada ${opciones.watch}s · ctrl-c para salir`));
777
+ await new Promise((r) => setTimeout(r, opciones.watch * 1000));
778
+ }
779
+ //# sourceMappingURL=qm.js.map