@legios/quartermaster 0.1.12 → 0.1.14
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 +28 -14
- package/bin/qm +39 -10
- package/bin/qm-barra.swift +143 -25
- package/bin/qm-indicator +219 -29
- package/bin/qm-tray +10 -0
- package/bin/qm-tray.ps1 +493 -60
- package/bin/qm.mjs +25 -0
- package/dist/adapters/barra.js +129 -13
- package/dist/adapters/barra.js.map +1 -1
- package/dist/adapters/codex.js +24 -0
- package/dist/adapters/codex.js.map +1 -1
- package/dist/adapters/opencode.js +31 -10
- package/dist/adapters/opencode.js.map +1 -1
- package/dist/adapters/zai.js +221 -0
- package/dist/adapters/zai.js.map +1 -0
- package/dist/cli/qm.js +228 -65
- package/dist/cli/qm.js.map +1 -1
- package/dist/core/relevancia.js +111 -0
- package/dist/core/relevancia.js.map +1 -0
- package/dist/render/tablero.html +19 -11
- package/extension/gnome43/quartermaster@legios/extension.js +261 -0
- package/extension/gnome43/quartermaster@legios/metadata.json +11 -0
- package/extension/gnome43/quartermaster@legios/stylesheet.css +10 -0
- package/extension/quartermaster@legios/metadata.json +1 -1
- package/package.json +3 -2
- package/scripts/bumpear.mjs +9 -0
- package/scripts/gate-bandeja.ps1 +267 -19
- package/scripts/gate-lazo.py +396 -0
- package/scripts/gate-tarjetas.py +46 -1
- package/scripts/hacer-deb.sh +10 -1
- package/src/render/tablero.html +19 -11
package/dist/cli/qm.js
CHANGED
|
@@ -23,12 +23,14 @@ import { anotar, claveBarra, muestras } from "../adapters/historial.js";
|
|
|
23
23
|
import { proyectar, VENTANA_AJUSTE_MS } from "../core/proyeccion.js";
|
|
24
24
|
import { frasePresupuesto, presupuestoDiario } from "../core/presupuesto.js";
|
|
25
25
|
import { consultarCuota } from "../adapters/cuota.js";
|
|
26
|
-
import { codexEnCache, codexEnDisco, modoCodex, consultarCodex, consumoCodex, duenoCodex, hayCodex, DIRECTORIO_CODEX, } from "../adapters/codex.js";
|
|
26
|
+
import { codexEnCache, codexEnDisco, modoCodex, consultarCodex, consumoCodex, duenoCodex, hayCodex, DIRECTORIO_CODEX, ultimaActividadCodex, } from "../adapters/codex.js";
|
|
27
27
|
import { endpointEnCache, frenadoHasta, guardarEndpoint, masNueva } from "../adapters/cache-endpoint.js";
|
|
28
28
|
import { decidirConsulta } from "../core/pedir.js";
|
|
29
29
|
import * as entorno from "../adapters/entorno.js";
|
|
30
30
|
import { cuentaPedida, leerConfigUsuario, RUTA_CONFIG, seleccionar } from "../core/config.js";
|
|
31
|
+
import { elQueFrena, ordenarPorRelevancia, relevancia, } from "../core/relevancia.js";
|
|
31
32
|
import { consumoOpencode, hayOpencode, limitesOpencode, ultimoUsoOpencode, } from "../adapters/opencode.js";
|
|
33
|
+
import { consultarCuotaZai, PROVEEDORES_ZAI } from "../adapters/zai.js";
|
|
32
34
|
import { esPreocupante, frase, nombreVentana, paraMostrar, peor, semanal, sesion, totalTokens, vencida as vencidaVentana, } from "../core/tipos.js";
|
|
33
35
|
import { barra, duracion, negrita, relleno, rojo, tenue, tokens, verde, amarillo, } from "../render/barras.js";
|
|
34
36
|
/**
|
|
@@ -73,7 +75,8 @@ const AYUDA = `qm · cuánta cuota te queda, en todos tus perfiles de Claude Cod
|
|
|
73
75
|
qm --ocultar=a,b mostrar todas menos esas
|
|
74
76
|
qm --sin-codex no mira la cuenta de Codex
|
|
75
77
|
qm --version la versión, y nada más
|
|
76
|
-
qm --calentar refresca el endpoint de cada perfil
|
|
78
|
+
qm --calentar refresca el endpoint de cada perfil, el de Codex y el de
|
|
79
|
+
z.ai (si hay una cuenta en opencode), guarda
|
|
77
80
|
lo que vuelve y no imprime nada. Es lo que corre la barra
|
|
78
81
|
qm --cuentas=a,b con --calentar: sólo esas cuentas. Cada una que se saltea
|
|
79
82
|
es un pedido menos a un endpoint que no es nuestro
|
|
@@ -218,6 +221,8 @@ async function filaCodex(o) {
|
|
|
218
221
|
return {
|
|
219
222
|
producto: 'codex',
|
|
220
223
|
localMedido: local !== null,
|
|
224
|
+
// La credencial la administra codex: desde acá no se puede saber si venció.
|
|
225
|
+
credencialVencida: false,
|
|
221
226
|
perfil,
|
|
222
227
|
veredicto: info === null ? 'la pone codex' : `la pone codex · ${info.creditosReset} reset(s) sin usar`,
|
|
223
228
|
cuota,
|
|
@@ -228,21 +233,47 @@ async function filaCodex(o) {
|
|
|
228
233
|
tokens: local?.tokens ?? 0,
|
|
229
234
|
tokensVentana: ventana?.tokens ?? 0,
|
|
230
235
|
porModelo: [],
|
|
231
|
-
//
|
|
232
|
-
//
|
|
233
|
-
//
|
|
234
|
-
ultimoUso:
|
|
236
|
+
// La fecha del rollout más nuevo. Cuesta un stat por archivo y ningún
|
|
237
|
+
// parseo, así que también vale en --breve — que es donde más hace falta,
|
|
238
|
+
// porque es el modo que corren todas las barras.
|
|
239
|
+
ultimoUso: ultimaActividadCodex(),
|
|
235
240
|
};
|
|
236
241
|
}
|
|
242
|
+
/**
|
|
243
|
+
* Las dos formas del mismo proveedor. opencode no usa un `providerID` estable
|
|
244
|
+
* entre instalaciones: en la máquina donde se escribió esto la base guarda
|
|
245
|
+
* `zai` a secas, y el mapa original sólo tenía `zai-coding-plan` — así que la
|
|
246
|
+
* fila se llamaba `zai` y el nombre lindo no se aplicaba nunca. Verificado
|
|
247
|
+
* contra la base: los providerID reales son zai, openai, amazon-bedrock,
|
|
248
|
+
* anthropic y opencode-go.
|
|
249
|
+
*
|
|
250
|
+
* Vive acá afuera y no adentro de `filasOpencode()` porque `--calentar` filtra
|
|
251
|
+
* con `--cuentas=` por el nombre que ve el usuario —`glm`, no `zai`—, y dos
|
|
252
|
+
* copias del mapa serían dos respuestas distintas a «¿esta cuenta la pediste?».
|
|
253
|
+
*/
|
|
254
|
+
const NOMBRE_OPENCODE = {
|
|
255
|
+
zai: 'glm',
|
|
256
|
+
'zai-coding-plan': 'glm',
|
|
257
|
+
minimax: 'minimax',
|
|
258
|
+
'minimax-coding-plan': 'minimax',
|
|
259
|
+
kimi: 'kimi',
|
|
260
|
+
'kimi-for-coding': 'kimi',
|
|
261
|
+
xai: 'grok',
|
|
262
|
+
'opencode-go': 'opencode-go',
|
|
263
|
+
};
|
|
264
|
+
function nombreOpencode(prov) {
|
|
265
|
+
return NOMBRE_OPENCODE[prov] ?? prov;
|
|
266
|
+
}
|
|
237
267
|
/**
|
|
238
268
|
* Los planes que viven adentro de opencode: GLM (zai), MiniMax, Kimi…
|
|
239
269
|
*
|
|
240
|
-
* Traen consumo real y
|
|
241
|
-
*
|
|
242
|
-
*
|
|
243
|
-
*
|
|
270
|
+
* Traen consumo real siempre, y cuota cuando se la puede conseguir: para z.ai
|
|
271
|
+
* hay un endpoint y se consulta con `--refrescar`; para el resto el porcentaje
|
|
272
|
+
* sólo existe del otro lado y la fila lleva la frase que dice por qué no hay
|
|
273
|
+
* barra. Lo que no pasa nunca es que la fila no esté — una cuenta que gastó
|
|
274
|
+
* 2,7 M de tokens y no aparece es el bug original de este repo, con otro vendor.
|
|
244
275
|
*/
|
|
245
|
-
function filasOpencode(o) {
|
|
276
|
+
async function filasOpencode(o) {
|
|
246
277
|
// Antes esto salía en --breve, y con eso la fila desaparecía de TODAS las
|
|
247
278
|
// pantallas: todas piden --breve. Una cuenta con una key de z.ai que se usó
|
|
248
279
|
// ayer y no aparece es, literalmente, el bug que da nombre a la primera
|
|
@@ -251,22 +282,6 @@ function filasOpencode(o) {
|
|
|
251
282
|
// ~25 ms, que sí entran en el contrato de --breve.
|
|
252
283
|
if (!hayOpencode())
|
|
253
284
|
return [];
|
|
254
|
-
// Las dos formas del mismo proveedor. opencode no usa un `providerID` estable
|
|
255
|
-
// entre instalaciones: en la máquina donde se escribió esto la base guarda
|
|
256
|
-
// `zai` a secas, y el mapa original sólo tenía `zai-coding-plan` — así que la
|
|
257
|
-
// fila se llamaba `zai` y el nombre lindo no se aplicaba nunca. Verificado
|
|
258
|
-
// contra la base: los providerID reales son zai, openai, amazon-bedrock,
|
|
259
|
-
// anthropic y opencode-go.
|
|
260
|
-
const bonito = {
|
|
261
|
-
zai: 'glm',
|
|
262
|
-
'zai-coding-plan': 'glm',
|
|
263
|
-
minimax: 'minimax',
|
|
264
|
-
'minimax-coding-plan': 'minimax',
|
|
265
|
-
kimi: 'kimi',
|
|
266
|
-
'kimi-for-coding': 'kimi',
|
|
267
|
-
xai: 'grok',
|
|
268
|
-
'opencode-go': 'opencode-go',
|
|
269
|
-
};
|
|
270
285
|
const desde = new Date(Date.now() - o.dias * 24 * 3600_000);
|
|
271
286
|
const ventana = new Date(Date.now() - o.ventanaH * 3600_000);
|
|
272
287
|
const enVentana = new Map(consumoOpencode(ventana).map((c) => [c.proveedor, c.tokens]));
|
|
@@ -278,14 +293,16 @@ function filasOpencode(o) {
|
|
|
278
293
|
const proveedores = [...visto.entries()]
|
|
279
294
|
.filter(([, d]) => d.getTime() >= corte)
|
|
280
295
|
.sort((a, b) => (enDias.get(b[0])?.tokens ?? 0) - (enDias.get(a[0])?.tokens ?? 0));
|
|
281
|
-
return proveedores.map(([prov, cuando]) => {
|
|
296
|
+
return await Promise.all(proveedores.map(async ([prov, cuando]) => {
|
|
282
297
|
const c = enDias.get(prov) ?? { proveedor: prov, modelo: null, tokens: 0, sesiones: 0, costo: 0 };
|
|
283
298
|
return ({
|
|
284
299
|
producto: 'opencode',
|
|
285
300
|
localMedido: true,
|
|
301
|
+
// opencode guarda sus propias credenciales y no informa vencimiento.
|
|
302
|
+
credencialVencida: false,
|
|
286
303
|
perfil: {
|
|
287
304
|
directorio: 'opencode',
|
|
288
|
-
nombre:
|
|
305
|
+
nombre: nombreOpencode(prov),
|
|
289
306
|
porDefecto: false,
|
|
290
307
|
// El plan es el proveedor, no el modelo. Acá iba `c.modelo` —el id del
|
|
291
308
|
// modelo más usado— y eso ponía `glm-5.3` donde las otras filas ponen
|
|
@@ -295,29 +312,66 @@ function filasOpencode(o) {
|
|
|
295
312
|
cuenta: { email: null, organizacion: 'opencode', plan: prov },
|
|
296
313
|
},
|
|
297
314
|
veredicto: `vía opencode · último uso hace ${duracion(Date.now() - cuando.getTime())}`,
|
|
298
|
-
cuota:
|
|
315
|
+
cuota: await cuotaDeOpencode(prov, limites.get(prov), o),
|
|
299
316
|
notaRefresco: null,
|
|
300
317
|
proyeccion: null,
|
|
301
318
|
archivos: c.sesiones,
|
|
302
319
|
requests: c.sesiones,
|
|
303
320
|
tokens: c.tokens,
|
|
304
321
|
tokensVentana: enVentana.get(c.proveedor) ?? 0,
|
|
305
|
-
//
|
|
306
|
-
//
|
|
307
|
-
//
|
|
308
|
-
|
|
322
|
+
// La fecha POR PROVEEDOR, que es la que ya se usa dos renglones más arriba
|
|
323
|
+
// para el veredicto. Acá decía null con un comentario que explicaba que la
|
|
324
|
+
// única fecha disponible era la de toda la base — dejó de ser cierto cuando
|
|
325
|
+
// se agregó `ultimoUsoOpencode()`, que hace `max(time_updated) group by
|
|
326
|
+
// proveedor`. El dato estaba, y se escribía sólo como texto.
|
|
327
|
+
ultimoUso: cuando,
|
|
309
328
|
porModelo: c.modelo === null ? [] : [[c.modelo, c.tokens]],
|
|
310
329
|
});
|
|
311
|
-
});
|
|
330
|
+
}));
|
|
312
331
|
}
|
|
313
332
|
/**
|
|
314
|
-
*
|
|
333
|
+
* La cuota de una fila de opencode, de las tres fuentes que puede tener.
|
|
334
|
+
*
|
|
335
|
+
* Por orden de lo que cuesta, que es el orden de SOUL —primero el número que no
|
|
336
|
+
* pide permiso—:
|
|
315
337
|
*
|
|
316
|
-
*
|
|
317
|
-
*
|
|
318
|
-
*
|
|
319
|
-
*
|
|
320
|
-
*
|
|
338
|
+
* 1. El **429 guardado** en la base. Gratis, sin credencial, y lo único que
|
|
339
|
+
* hay para los proveedores sin endpoint conocido. Dice «te frenaron» y
|
|
340
|
+
* cuándo te liberás, que es lo que se hace con el número.
|
|
341
|
+
* 2. El **cache** de la última consulta al endpoint de z.ai. También gratis y
|
|
342
|
+
* sin credencial: lo escribió `--refrescar` o `--calentar` en su momento.
|
|
343
|
+
* 3. El **endpoint** de z.ai, sólo con `--refrescar`. Es el único que abre
|
|
344
|
+
* `auth.json`.
|
|
345
|
+
*
|
|
346
|
+
* Entre las tres gana la más nueva, y eso no es una preferencia de estilo: un
|
|
347
|
+
* 429 de hace dos horas describe mejor el presente que una barra al 40 % de
|
|
348
|
+
* hace dos días, y una barra de recién describe mejor el presente que un 429
|
|
349
|
+
* de anteayer. `masNueva()` ya era la regla para Claude y es la misma acá.
|
|
350
|
+
*/
|
|
351
|
+
async function cuotaDeOpencode(prov, lim, o) {
|
|
352
|
+
let cuota = masNueva(cuotaDeLimite(prov, lim), endpointEnCache(`opencode:${prov}`));
|
|
353
|
+
if (o.refrescar && PROVEEDORES_ZAI.has(prov)) {
|
|
354
|
+
const fresca = await consultarCuotaZai(prov);
|
|
355
|
+
if (fresca.estado === 'ok') {
|
|
356
|
+
guardarEndpoint(`opencode:${prov}`, fresca);
|
|
357
|
+
cuota = fresca;
|
|
358
|
+
}
|
|
359
|
+
// Si no sirvió no se pisa nada: el cache y el 429 siguen siendo mejores
|
|
360
|
+
// que una frase de error donde había un número.
|
|
361
|
+
}
|
|
362
|
+
return cuota;
|
|
363
|
+
}
|
|
364
|
+
/**
|
|
365
|
+
* Lo que se puede afirmar de un plan por API key **sin salir a la red**.
|
|
366
|
+
*
|
|
367
|
+
* En el disco no hay porcentaje —se probó: ni `/models` ni una llamada real
|
|
368
|
+
* devuelven cabeceras de límite en zai ni en minimax, y opencode no guarda
|
|
369
|
+
* ninguna—. Pero cuando el proveedor te frena contesta un 429 con la fecha de
|
|
370
|
+
* reinicio, y opencode guarda esa respuesta. Con eso alcanza para lo único que
|
|
371
|
+
* se hace con el número: saber si estás frenado y cuándo te liberás.
|
|
372
|
+
*
|
|
373
|
+
* Para z.ai hay además una barra de verdad, pero cuesta la clave y por eso vive
|
|
374
|
+
* en `zai.ts` detrás de `--refrescar`. Ésta es la que hay siempre.
|
|
321
375
|
*
|
|
322
376
|
* Si el reinicio ya pasó, no se afirma nada: se dice que no hay barra y cuándo
|
|
323
377
|
* fue la última vez que te frenaron. Un límite de la semana pasada no dice nada
|
|
@@ -407,6 +461,7 @@ async function medir(o) {
|
|
|
407
461
|
return {
|
|
408
462
|
producto: 'claude',
|
|
409
463
|
localMedido: false,
|
|
464
|
+
credencialVencida: cred.vencida,
|
|
410
465
|
perfil,
|
|
411
466
|
veredicto,
|
|
412
467
|
cuota,
|
|
@@ -428,6 +483,7 @@ async function medir(o) {
|
|
|
428
483
|
return {
|
|
429
484
|
producto: 'claude',
|
|
430
485
|
localMedido: true,
|
|
486
|
+
credencialVencida: cred.vencida,
|
|
431
487
|
perfil,
|
|
432
488
|
veredicto,
|
|
433
489
|
cuota,
|
|
@@ -446,13 +502,34 @@ async function medir(o) {
|
|
|
446
502
|
};
|
|
447
503
|
}));
|
|
448
504
|
const codex = o.codex ? await filaCodex(o) : null;
|
|
449
|
-
const todas = [...claude, ...(codex === null ? [] : [codex]), ...filasOpencode(o)];
|
|
505
|
+
const todas = [...claude, ...(codex === null ? [] : [codex]), ...(await filasOpencode(o))];
|
|
450
506
|
// Descubrir todo y mostrar todo no son lo mismo: lo primero es la misión,
|
|
451
507
|
// lo segundo es una preferencia.
|
|
452
508
|
const { filas, nota } = seleccionar(todas, configEfectiva());
|
|
453
509
|
if (nota !== null && !o.json && !o.breve)
|
|
454
510
|
console.error(tenue(` (${nota} · ${RUTA_CONFIG})`));
|
|
455
|
-
|
|
511
|
+
// Y acá, lo último: las dormidas al fondo. Ordenar es del núcleo y no de cada
|
|
512
|
+
// pantalla — ninguno de los seis renderers ordena perfiles, así que con esto
|
|
513
|
+
// alcanza para que el orden sea el mismo en todos.
|
|
514
|
+
return ordenarPorRelevancia(filas, (f) => relevanciaDe(f, o));
|
|
515
|
+
}
|
|
516
|
+
/**
|
|
517
|
+
* Dónde va esta fila: al frente o al fondo.
|
|
518
|
+
*
|
|
519
|
+
* Traduce lo que sabe una `FilaPerfil` a las señales que entiende el núcleo. La
|
|
520
|
+
* traducción vive acá y no adentro de `relevancia()` para que el núcleo no
|
|
521
|
+
* tenga que saber qué es un perfil de Claude ni una fila de Codex.
|
|
522
|
+
*/
|
|
523
|
+
function relevanciaDe(f, o) {
|
|
524
|
+
return relevancia({
|
|
525
|
+
plan: f.perfil.cuenta?.plan ?? null,
|
|
526
|
+
ultimoUso: f.ultimoUso,
|
|
527
|
+
// `localMedido` es la diferencia entre «cero» y «no lo medí», y el núcleo
|
|
528
|
+
// trata esas dos cosas distinto a propósito.
|
|
529
|
+
requests: f.localMedido ? f.requests : null,
|
|
530
|
+
ventanaDias: f.localMedido ? o.dias : null,
|
|
531
|
+
credencialVencida: f.credencialVencida,
|
|
532
|
+
});
|
|
456
533
|
}
|
|
457
534
|
/** La config del archivo, con --solo / --ocultar pisándola. */
|
|
458
535
|
function configEfectiva() {
|
|
@@ -469,12 +546,25 @@ function configEfectiva() {
|
|
|
469
546
|
};
|
|
470
547
|
}
|
|
471
548
|
const colorPct = (p) => (p >= 90 ? rojo : p >= 70 ? amarillo : verde);
|
|
472
|
-
/**
|
|
549
|
+
/**
|
|
550
|
+
* «cache · hace 25m». Que la edad viaje pegada al número es la mitad del punto.
|
|
551
|
+
*
|
|
552
|
+
* La edad sale de `medidoEn` y de nada más. Acá decía `endpoint · ahora` fijo
|
|
553
|
+
* para todo lo que tuviera `origen: 'endpoint'`, y eso era falso desde que
|
|
554
|
+
* existe `endpointEnCache()`: una lectura del endpoint **guardada** conserva su
|
|
555
|
+
* origen y se muestra con su `medidoEn` viejo, así que un número de hace tres
|
|
556
|
+
* días se anunciaba como de recién. Se veía poco mientras las filas de Claude
|
|
557
|
+
* tenían además el cache de `.claude.json` para ganarle; las de opencode no
|
|
558
|
+
* tienen otra fuente, y ahí quedó a la vista.
|
|
559
|
+
*
|
|
560
|
+
* Un número viejo presentado como actual es la misma mentira que el silencio,
|
|
561
|
+
* que es la frase con la que arranca `cache-cuota.ts`.
|
|
562
|
+
*/
|
|
473
563
|
function sello(r) {
|
|
474
564
|
const edadMs = Date.now() - r.medidoEn.getTime();
|
|
475
|
-
|
|
476
|
-
|
|
477
|
-
const texto = `
|
|
565
|
+
// Menos de un minuto es «ahora» y no «hace 3s»: el segundero no le sirve a
|
|
566
|
+
// nadie y hace que la pantalla parezca cambiar cuando no cambió nada.
|
|
567
|
+
const texto = edadMs < 60_000 ? `${r.origen} · ahora` : `${r.origen} · hace ${duracion(edadMs)}`;
|
|
478
568
|
// Seis horas es más que cualquier ventana de 5 h: a esa altura el número
|
|
479
569
|
// puede describir una ventana que ya se reinició.
|
|
480
570
|
return edadMs > 6 * 3600_000 ? amarillo(`${texto} — viejo`) : tenue(texto);
|
|
@@ -547,19 +637,21 @@ function pintar(filas, o) {
|
|
|
547
637
|
if (f.localMedido) {
|
|
548
638
|
console.log(` ${relleno('', 18)} ${tenue(`local: ${tokens(f.tokens)} en ${o.dias}d · ${tokens(f.tokensVentana)} en ${o.ventanaH}h · ${f.requests} requests`)}`);
|
|
549
639
|
}
|
|
640
|
+
// Por qué esta cuenta quedó al fondo. Una cuenta que baja de lugar sin
|
|
641
|
+
// decir por qué es una decisión invisible, y una decisión invisible es
|
|
642
|
+
// indistinguible de un bug.
|
|
643
|
+
const rel = relevanciaDe(f, o);
|
|
644
|
+
if (rel.dormida) {
|
|
645
|
+
console.log(` ${relleno('', 18)} ${tenue(`dormida: ${rel.porque.join(' · ')} — no encabeza`)}`);
|
|
646
|
+
}
|
|
550
647
|
console.log();
|
|
551
648
|
}
|
|
552
649
|
// El renglón que sirve cuando no querés leer la tabla entera.
|
|
553
|
-
|
|
554
|
-
|
|
555
|
-
|
|
556
|
-
|
|
557
|
-
|
|
558
|
-
if (v !== null)
|
|
559
|
-
peores.push({ f, v });
|
|
560
|
-
}
|
|
561
|
-
peores.sort((a, b) => b.v.porcentaje - a.v.porcentaje);
|
|
562
|
-
const top = peores[0];
|
|
650
|
+
// Quién encabeza NO es «el porcentaje más alto»: una cuenta dormida en 100 %
|
|
651
|
+
// ganaría siempre, porque 100 es el máximo. La regla está en el núcleo y la
|
|
652
|
+
// comparten las seis pantallas.
|
|
653
|
+
const lider = elQueFrena(filas, (f) => frenaDe(f)?.porcentaje ?? null, (f) => relevanciaDe(f, o).dormida);
|
|
654
|
+
const top = lider === null ? undefined : { f: lider, v: frenaDe(lider) };
|
|
563
655
|
if (top) {
|
|
564
656
|
console.log(` ${negrita('lo primero que te frena:')} ${top.f.perfil.nombre} · ${nombreVentana(top.v)} ${colorPct(top.v.porcentaje)(`${top.v.porcentaje.toFixed(0)}%`)}` +
|
|
565
657
|
(top.v.reinicia ? tenue(` · reinicia en ${duracion(top.v.reinicia.getTime() - Date.now())}`) : ''));
|
|
@@ -588,7 +680,7 @@ function nombreCorto(n) {
|
|
|
588
680
|
* cada perfil que tenga número. Los perfiles sin cuota no se listan — en una
|
|
589
681
|
* línea de 80 columnas, decir «no sé» de tres perfiles tapa el que sí sabés.
|
|
590
682
|
*/
|
|
591
|
-
function pintarBreve(filas) {
|
|
683
|
+
function pintarBreve(filas, o) {
|
|
592
684
|
const partes = [];
|
|
593
685
|
for (const f of filas) {
|
|
594
686
|
if (f.cuota.estado !== 'ok')
|
|
@@ -600,7 +692,10 @@ function pintarBreve(filas) {
|
|
|
600
692
|
// El «!» ya no es sólo severidad: también avisa que a este ritmo tocás el
|
|
601
693
|
// techo antes de que la ventana se reinicie, que es lo que duele.
|
|
602
694
|
const chocas = f.proyeccion?.estado === 'sube' && f.proyeccion.chocas;
|
|
603
|
-
|
|
695
|
+
// Una cuenta dormida no lleva «!». El signo existe para avisarte de algo
|
|
696
|
+
// que te va a frenar, y una cuenta que nadie usa no te frena: en una
|
|
697
|
+
// statusline de una línea, ese «!» es ruido permanente.
|
|
698
|
+
const aviso = !relevanciaDe(f, o).dormida && (v.severidad !== 'normal' || chocas) ? '!' : '';
|
|
604
699
|
// Dos números, dos preguntas: la sesión dice si podés seguir AHORA, y la
|
|
605
700
|
// barra que frena antes dice si llegás al final de la ventana larga. Una
|
|
606
701
|
// sola de las dos deja media respuesta.
|
|
@@ -716,6 +811,30 @@ function comoJson(filas, o) {
|
|
|
716
811
|
generado: new Date().toISOString(),
|
|
717
812
|
plataforma: process.platform,
|
|
718
813
|
ventanaDias: o.dias,
|
|
814
|
+
// QUIÉN ENCABEZA, ya resuelto.
|
|
815
|
+
//
|
|
816
|
+
// Antes no estaba, y la consecuencia era medible: la elección del perfil
|
|
817
|
+
// que encabeza estaba escrita SEIS veces —terminal, GNOME, macOS, Windows,
|
|
818
|
+
// tablero y waybar— y las seis decían «el `frena` con el porcentaje más
|
|
819
|
+
// alto». Seis copias son seis respuestas el día que alguien cambia el
|
|
820
|
+
// criterio, que es exactamente lo que pasó: bajar las cuentas dormidas
|
|
821
|
+
// habría arreglado una pantalla y dejado las otras cinco como estaban.
|
|
822
|
+
//
|
|
823
|
+
// Es el mismo argumento que dejó escrito `frena` adentro de cada cuota, una
|
|
824
|
+
// vuelta más arriba: el CLI resuelve, los renderers dibujan.
|
|
825
|
+
frenaPrimero: (() => {
|
|
826
|
+
const lider = elQueFrena(filas, (f) => frenaDe(f)?.porcentaje ?? null, (f) => relevanciaDe(f, o).dormida);
|
|
827
|
+
if (lider === null)
|
|
828
|
+
return null;
|
|
829
|
+
return {
|
|
830
|
+
perfil: lider.perfil.nombre,
|
|
831
|
+
producto: lider.producto,
|
|
832
|
+
ventana: ventanaJson0(frenaDe(lider)),
|
|
833
|
+
// true cuando NO quedaba ninguna despierta: el encabezado es lo único
|
|
834
|
+
// que había, y quien dibuja puede decirlo en vez de afirmarlo a secas.
|
|
835
|
+
dormida: relevanciaDe(lider, o).dormida,
|
|
836
|
+
};
|
|
837
|
+
})(),
|
|
719
838
|
perfiles: filas.map((f) => ({
|
|
720
839
|
producto: f.producto,
|
|
721
840
|
perfil: f.perfil.nombre,
|
|
@@ -780,6 +899,9 @@ function comoJson(filas, o) {
|
|
|
780
899
|
// barra, y el sondeo corre --breve. Adentro de `local` el campo estaba
|
|
781
900
|
// escrito pero nunca llegaba a quien lo necesitaba.
|
|
782
901
|
ultimoUso: f.ultimoUso?.toISOString() ?? null,
|
|
902
|
+
// Dónde va esta cuenta en la lista, y por qué. `porque` es prosa para
|
|
903
|
+
// mostrar al lado; no se parsea, igual que `frase`.
|
|
904
|
+
relevancia: relevanciaDe(f, o),
|
|
783
905
|
// En --breve no se leyeron las transcripciones. Informar 0 sería decir
|
|
784
906
|
// "no consumiste nada" cuando lo que pasa es "no lo medí".
|
|
785
907
|
local: o.breve || !f.localMedido
|
|
@@ -794,10 +916,27 @@ function comoJson(filas, o) {
|
|
|
794
916
|
})),
|
|
795
917
|
};
|
|
796
918
|
}
|
|
797
|
-
/**
|
|
798
|
-
function
|
|
919
|
+
/** La ventana que frena en esta fila, ya resuelta. null si no hay número. */
|
|
920
|
+
function frenaDe(f) {
|
|
921
|
+
return f.cuota.estado === 'ok' ? peor(paraMostrar(f.cuota.ventanas)) : null;
|
|
922
|
+
}
|
|
923
|
+
/**
|
|
924
|
+
* El porcentaje más alto que IMPORTA, para --umbral.
|
|
925
|
+
*
|
|
926
|
+
* Las dormidas no cuentan, y no es un detalle de presentación: `--esperar` usa
|
|
927
|
+
* el mismo criterio y duerme hasta el reinicio de la barra más alta. Con una
|
|
928
|
+
* cuenta free abandonada en 100 % que reinicia en quince días, `qm --esperar &&
|
|
929
|
+
* codex ...` se quedaba esperando quince días para correr un comando que podía
|
|
930
|
+
* correr ya. El umbral tiene que mirar lo que te frena de verdad.
|
|
931
|
+
*
|
|
932
|
+
* Si TODAS están dormidas se las mira igual: en ese caso son lo único que hay,
|
|
933
|
+
* y devolver 0 sería afirmar que no hay ninguna barra alta.
|
|
934
|
+
*/
|
|
935
|
+
function maximo(filas, o) {
|
|
936
|
+
const cuentan = filas.filter((f) => !relevanciaDe(f, o).dormida);
|
|
937
|
+
const mirar = cuentan.length > 0 ? cuentan : filas;
|
|
799
938
|
let m = 0;
|
|
800
|
-
for (const f of
|
|
939
|
+
for (const f of mirar) {
|
|
801
940
|
if (f.cuota.estado !== 'ok')
|
|
802
941
|
continue;
|
|
803
942
|
for (const v of f.cuota.ventanas)
|
|
@@ -953,6 +1092,25 @@ if (process.argv.includes('--calentar') || process.argv.includes('--calentar-cod
|
|
|
953
1092
|
fallas.push(`${perfil.nombre}: ${frase(r, perfil.directorio)}`);
|
|
954
1093
|
}
|
|
955
1094
|
}
|
|
1095
|
+
// z.ai entra por el mismo lado que los perfiles de Claude: es la otra cuota
|
|
1096
|
+
// que sólo existe del otro lado del cable, y sin calentarla las pantallas
|
|
1097
|
+
// —que todas corren --breve— nunca verían su barra.
|
|
1098
|
+
for (const prov of soloCodex ? [] : ultimoUsoOpencode().keys()) {
|
|
1099
|
+
if (!PROVEEDORES_ZAI.has(prov))
|
|
1100
|
+
continue;
|
|
1101
|
+
if (cuentas !== null && !cuentaPedida(cuentas, nombreOpencode(prov)))
|
|
1102
|
+
continue;
|
|
1103
|
+
const r = await consultarCuotaZai(prov);
|
|
1104
|
+
if (r.estado === 'ok') {
|
|
1105
|
+
guardarEndpoint(`opencode:${prov}`, r);
|
|
1106
|
+
bien = true;
|
|
1107
|
+
}
|
|
1108
|
+
else if (r.estado !== 'sin-credencial' && r.estado !== 'sin-suscripcion') {
|
|
1109
|
+
// Sin clave guardada no es una falla: es una cuenta de opencode que no
|
|
1110
|
+
// es de z.ai, o una que nunca se autenticó.
|
|
1111
|
+
fallas.push(`${nombreOpencode(prov)}: ${frase(r, prov)}`);
|
|
1112
|
+
}
|
|
1113
|
+
}
|
|
956
1114
|
const c = cuentas !== null && !cuentas.has('codex')
|
|
957
1115
|
? { cuota: { estado: 'no-consultada' } }
|
|
958
1116
|
: await consultarCodex();
|
|
@@ -990,9 +1148,14 @@ if (process.argv.includes('--esperar')) {
|
|
|
990
1148
|
console.error(cuenta === null ? 'no hay ninguna cuenta' : `no encontré la cuenta "${cuenta}"`);
|
|
991
1149
|
process.exit(2);
|
|
992
1150
|
}
|
|
1151
|
+
// Las dormidas no hacen esperar a nadie. Si `--cuenta=` dejó SÓLO dormidas,
|
|
1152
|
+
// se las mira igual: pediste esa cuenta y esperar por ella es lo que
|
|
1153
|
+
// pediste.
|
|
1154
|
+
const despiertas = filas.filter((f) => !relevanciaDe(f, opts).dormida);
|
|
1155
|
+
const cuentan = despiertas.length > 0 ? despiertas : filas;
|
|
993
1156
|
let peorPct = 0;
|
|
994
1157
|
let cuando = null;
|
|
995
|
-
for (const f of
|
|
1158
|
+
for (const f of cuentan) {
|
|
996
1159
|
if (f.cuota.estado !== 'ok')
|
|
997
1160
|
continue;
|
|
998
1161
|
const v = peor(paraMostrar(f.cuota.ventanas));
|
|
@@ -1039,10 +1202,10 @@ const unaVuelta = async () => {
|
|
|
1039
1202
|
if (opciones.json)
|
|
1040
1203
|
console.log(JSON.stringify(comoJson(filas, opciones), null, 2));
|
|
1041
1204
|
else if (opciones.breve)
|
|
1042
|
-
pintarBreve(filas);
|
|
1205
|
+
pintarBreve(filas, opciones);
|
|
1043
1206
|
else
|
|
1044
1207
|
pintar(filas, opciones);
|
|
1045
|
-
if (opciones.umbral !== null && maximo(filas) >= opciones.umbral)
|
|
1208
|
+
if (opciones.umbral !== null && maximo(filas, opciones) >= opciones.umbral)
|
|
1046
1209
|
return 3;
|
|
1047
1210
|
return 0;
|
|
1048
1211
|
};
|