@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.
- package/LICENSE +21 -0
- package/README.md +1276 -0
- package/bin/qm +66 -0
- package/bin/qm-barra +63 -0
- package/bin/qm-barra.swift +1253 -0
- package/bin/qm-indicator +2063 -0
- package/bin/qm-tray +41 -0
- package/bin/qm-tray.ps1 +1241 -0
- package/bin/qm-web +137 -0
- package/dist/adapters/cache-cuota.js +45 -0
- package/dist/adapters/cache-cuota.js.map +1 -0
- package/dist/adapters/cache-endpoint.js +66 -0
- package/dist/adapters/cache-endpoint.js.map +1 -0
- package/dist/adapters/codex.js +462 -0
- package/dist/adapters/codex.js.map +1 -0
- package/dist/adapters/credenciales.js +88 -0
- package/dist/adapters/credenciales.js.map +1 -0
- package/dist/adapters/cuota.js +73 -0
- package/dist/adapters/cuota.js.map +1 -0
- package/dist/adapters/historial.js +103 -0
- package/dist/adapters/historial.js.map +1 -0
- package/dist/adapters/opencode.js +214 -0
- package/dist/adapters/opencode.js.map +1 -0
- package/dist/adapters/transcripciones.js +129 -0
- package/dist/adapters/transcripciones.js.map +1 -0
- package/dist/adapters/utilizacion.js +151 -0
- package/dist/adapters/utilizacion.js.map +1 -0
- package/dist/cli/demo-h1.js +60 -0
- package/dist/cli/demo-h1.js.map +1 -0
- package/dist/cli/preflight.js +39 -0
- package/dist/cli/preflight.js.map +1 -0
- package/dist/cli/qm.js +779 -0
- package/dist/cli/qm.js.map +1 -0
- package/dist/core/config.js +63 -0
- package/dist/core/config.js.map +1 -0
- package/dist/core/perfiles.js +139 -0
- package/dist/core/perfiles.js.map +1 -0
- package/dist/core/proyeccion.js +83 -0
- package/dist/core/proyeccion.js.map +1 -0
- package/dist/core/tipos.js +101 -0
- package/dist/core/tipos.js.map +1 -0
- package/dist/render/barras.js +62 -0
- package/dist/render/barras.js.map +1 -0
- package/dist/render/tablero.html +664 -0
- package/package.json +59 -0
- 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
|