@legios/quartermaster 0.1.13 → 0.1.15

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/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@legios/quartermaster",
3
- "version": "0.1.13",
3
+ "version": "0.1.15",
4
4
  "description": "Cuánta cuota te queda en TODOS los perfiles de Claude Code de la máquina, más Codex y los proveedores de opencode. Sin red y sin credenciales: el número sale del cache que Claude Code deja en disco.",
5
5
  "keywords": [
6
6
  "claude-code",
@@ -0,0 +1,396 @@
1
+ """El calentado no puede dejar de ocurrir en silencio.
2
+
3
+ EL CASO. El 2026-09-15, con 0.1.13 recién publicada, el indicador de GNOME de
4
+ esta máquina dejó de preguntarle al endpoint a las 02:35 y estuvo SIETE HORAS Y
5
+ MEDIA sin escribir una sola línea. Medido, no supuesto: el proceso vivo,
6
+ `estado.json` reescrito hacía un minuto, `endpoint.json` e `historial.jsonl`
7
+ congelados a las 02:35, y el log al día —un `pedido` mandado a mano aparecía al
8
+ instante—. No fue la suspensión, que es el caso que el código ya contempla:
9
+ CLOCK_BOOTTIME y CLOCK_MONOTONIC daban lo mismo y la máquina llevaba 14 h de
10
+ uptime continuo. Forzar un `refrescar()`, que es lo que rearma el calentado, no
11
+ lo revivió en diez minutos con la cadencia en un techo de cinco.
12
+
13
+ Lo que mostraba mientras tanto, contra lo que decía el servidor:
14
+
15
+ mostraba main ~0/30% · teams ~0/29% · codex ~0/30%
16
+ endpoint main 7/31% · teams 10/30% · codex 0/30%
17
+
18
+ El `~` estaba —no mentía— pero un monitor que deja de monitorear sin decirlo es
19
+ exactamente el bug del que nació este repo.
20
+
21
+ LA FORMA, que es lo que se comprueba acá. El calentado se rearmaba desde UN solo
22
+ lugar: el final de `refrescar()`. Cualquier corte en esa cadena lo apagaba para
23
+ toda la vida del proceso, y había un estado —`calentando` en True sin
24
+ `calentando_desde`— que caía en un `else` que rearmaba sin anotar nada. Diez
25
+ vueltas del temporizador, cero líneas.
26
+
27
+ Se comprueban las tres defensas, manejando los callbacks a mano como se los
28
+ haría correr GLib, sin levantar interfaz:
29
+
30
+ 1. una bandera pegada SIN instante se trata como pegada: se anota y se suelta;
31
+ 2. el vigía, que no depende del calentado ni del sondeo, anota el atraso una
32
+ vez y lo destraba;
33
+ 3. el sondeo periódico sobrevive a una excepción de `refrescar()`: la anota y
34
+ devuelve True, porque un callback de GLib que no devuelve un valor
35
+ verdadero se queda sin fuente y se lleva el lazo puesto.
36
+ """
37
+
38
+ import importlib.machinery
39
+ import importlib.util
40
+ import os
41
+ import pathlib
42
+ import re
43
+ import shutil
44
+ import subprocess
45
+ import sys
46
+ import tempfile
47
+
48
+ RAIZ = pathlib.Path(__file__).resolve().parent.parent
49
+
50
+ for _s in (sys.stdout, sys.stderr):
51
+ try:
52
+ _s.reconfigure(encoding="utf-8", errors="replace")
53
+ except (AttributeError, ValueError):
54
+ pass
55
+
56
+
57
+ def cargar():
58
+ spec = importlib.util.spec_from_loader(
59
+ "qmi", importlib.machinery.SourceFileLoader("qmi", str(RAIZ / "bin/qm-indicator")))
60
+ m = importlib.util.module_from_spec(spec)
61
+ spec.loader.exec_module(m)
62
+ return m
63
+
64
+
65
+ class RelojFalso:
66
+ """GLib de mentira: no corre nada, anota qué se armó. El reloj avanza a mano."""
67
+
68
+ def __init__(self):
69
+ self.armados = []
70
+ self.ahora = 10_000 * 1_000_000
71
+ self.vivas = {}
72
+
73
+ def avanzar(self, segundos):
74
+ self.ahora += segundos * 1_000_000
75
+
76
+ def get_monotonic_time(self):
77
+ return self.ahora
78
+
79
+ def timeout_add_seconds(self, seg, _fn):
80
+ self.armados.append(seg)
81
+ idc = len(self.armados)
82
+ self.vivas[idc] = self.ahora + seg * 1_000_000
83
+ return idc
84
+
85
+ def timeout_add(self, _ms, _fn):
86
+ return 1
87
+
88
+ def source_remove(self, idc):
89
+ self.vivas.pop(idc, None)
90
+ return True
91
+
92
+
93
+ def banco(m):
94
+ """Un Indicador sin interfaz, con el estado que se quiera."""
95
+ ind = object.__new__(m.Indicador)
96
+ ind.calentando = False
97
+ ind.calentando_desde = None
98
+ ind.reloj = None
99
+ ind.proxima_lectura = None
100
+ ind.piezas = []
101
+ ind.minutos_al_techo = None
102
+ ind._ultimo_calentado = None
103
+ ind._vigia_avisado = False
104
+ ind._fallo_calentado = None
105
+ ind._motivos_calentado = set()
106
+ ind.qm = "/bin/true"
107
+ return ind
108
+
109
+
110
+ def correr(prueba):
111
+ """Devuelve (renglones anotados, temporizadores armados)."""
112
+ m = cargar()
113
+ anotado = []
114
+ m.registrar = lambda evento, **d: anotado.append(
115
+ evento + ("" if not d else " " + " ".join(
116
+ f"{k}={v}" for k, v in d.items() if v is not None)))
117
+ reloj = RelojFalso()
118
+ m.GLib = reloj
119
+ prueba(m, banco(m), reloj)
120
+ return anotado, reloj.armados
121
+
122
+
123
+ def bandera_pegada(m, ind, _reloj):
124
+ ind.calentando = True
125
+ ind.calentando_desde = None
126
+ for _ in range(10):
127
+ m.Indicador.calentar(ind)
128
+
129
+
130
+ def vigia_con_atraso(m, ind, reloj):
131
+ ind.calentando = True
132
+ ind._ultimo_calentado = reloj.get_monotonic_time() - 1800 * 1_000_000
133
+ # Con un temporizador armado y su fecha YA VENCIDA, que es el estado real de
134
+ # un calentado parado: la guarda anti-hambre ve que cualquier fecha nueva es
135
+ # «más lejos» y, sin forzar, no rearmaría nada. La defensa contra el hambre
136
+ # apagaría a la defensa contra el silencio.
137
+ ind.reloj = 99
138
+ ind.proxima_lectura = reloj.get_monotonic_time() - 600 * 1_000_000
139
+ for _ in range(3):
140
+ m.Indicador._vigia(ind)
141
+
142
+
143
+ def hambre(m, ind, reloj):
144
+ """El sondeo empatado con la cadencia: ¿llega a vencer el calentado?
145
+
146
+ Es el caso REAL: `cadencia()` devuelve SEGUNDOS_SONDEO cuando no hay nada
147
+ alto, y `refrescar()` —que corre cada SEGUNDOS_SONDEO— rearma el calentado
148
+ en cada vuelta. Si rearmar ALEJA la fecha, el calentado no vence jamás.
149
+ """
150
+ ind.piezas = [] # nada alto: cadencia() da el techo
151
+ m.Indicador.programar_calentado(ind) # como el arranque
152
+ for _ in range(12): # doce sondeos = una hora
153
+ reloj.avanzar(m.SEGUNDOS_SONDEO)
154
+ m.Indicador.programar_calentado(ind)
155
+ # ¿Quedó alguna fecha en el pasado? Ésa es la que habría disparado.
156
+ ind.vencio = any(t <= reloj.ahora for t in reloj.vivas.values())
157
+
158
+
159
+ def sondeo_que_revienta(m, ind, _reloj):
160
+ def revienta():
161
+ raise RuntimeError("un refresco cualquiera que falla")
162
+ ind.refrescar = revienta
163
+ ind.devuelto = [m.Indicador._sondear(ind) for _ in range(3)]
164
+
165
+
166
+ def vigia_de_macos() -> list[str]:
167
+ """El vigía de la barra de macOS, EJECUTADO.
168
+
169
+ Compilar no alcanza: lo que hay que comprobar es que con una lectura
170
+ reciente se calle, que con una vieja avise UNA vez, y que rearme. Se le saca
171
+ el cuerpo a `func vigia()` y se lo envuelve con lo que nombra —el reloj, la
172
+ bandera, `registrar`, `duracion` y `programar`— igual que hace
173
+ gate-duraciones con la escalera.
174
+ """
175
+ texto = (RAIZ / "bin/qm-barra.swift").read_text(encoding="utf-8")
176
+ i = texto.index(" func vigia() {")
177
+ j = texto.index("\n }\n", i) + len("\n }\n")
178
+ cuerpo = texto[i:j].replace("func vigia()", "func vigia()")
179
+ # `duracion` de verdad, para que la frase sea la que se va a leer.
180
+ dur_i = texto.index("func duracion(_ segundos: Int) -> String {")
181
+ nivel, k = 0, dur_i
182
+ while True:
183
+ if texto[k] == "{":
184
+ nivel += 1
185
+ elif texto[k] == "}":
186
+ nivel -= 1
187
+ if nivel == 0:
188
+ break
189
+ k += 1
190
+ duracion = texto[dur_i:k + 1]
191
+
192
+ # Y `programar()`, que es donde vivía el hambre: rearmar no puede ALEJAR.
193
+ prog_i = texto.index(" func programar(forzando: Bool = false) {")
194
+ nivel, k = 0, prog_i
195
+ while True:
196
+ if texto[k] == "{":
197
+ nivel += 1
198
+ elif texto[k] == "}":
199
+ nivel -= 1
200
+ if nivel == 0:
201
+ break
202
+ k += 1
203
+ programar = texto[prog_i:k + 1].replace("self.calentarCodex()", "calentados += 1")
204
+ # Contar los rearmes DE VERDAD: el stub que los contaba ya no está, porque
205
+ # ahora se ejecuta el `programar()` real —que es justo lo que hay que medir,
206
+ # porque su guarda anti-hambre podía dejar al vigía sin rearmar nada.
207
+ # El contador va donde el rearme OCURRE —justo antes de guardar el timer
208
+ # nuevo— y no al entrar: puesto arriba contaba llamadas, y una llamada que
209
+ # la guarda rechaza no es un rearme. Medido: daba 3 cuando eran 0.
210
+ assert "rearmes" not in programar
211
+ assert programar.count(" reloj = t") == 1
212
+ programar = programar.replace(" reloj = t", " rearmes += 1\n reloj = t", 1)
213
+
214
+ guion = f"""import Foundation
215
+ {duracion}
216
+ let VIGIA_PLAZO: TimeInterval = 20 * 60
217
+ let SEGUNDOS_SONDEO: TimeInterval = 300
218
+ let MINIMO_RED: TimeInterval = 60
219
+ var anotado: [String] = []
220
+ func registrar(_ t: String) {{ anotado.append(t) }}
221
+ var rearmes = 0
222
+ var calentados = 0
223
+ class Barra {{
224
+ var calentadoEn: Date?
225
+ var vigiaAviso = false
226
+ var reloj: Timer?
227
+ var minutosAlTecho: Double? = nil
228
+ func cadencia() -> TimeInterval {{ SEGUNDOS_SONDEO }} // todo tranquilo
229
+ {programar}
230
+ {cuerpo}
231
+ }}
232
+ let b = Barra()
233
+
234
+ // 1 · el vigía
235
+ let v = Barra()
236
+ v.calentadoEn = Date()
237
+ v.vigia()
238
+ print("callado:\\(anotado.isEmpty)")
239
+ v.calentadoEn = Date().addingTimeInterval(-1800)
240
+ v.vigia(); v.vigia(); v.vigia()
241
+ print("avisos:\\(anotado.count)")
242
+ print("rearmes:\\(rearmes)")
243
+
244
+ // 2 · el hambre: refrescar() rearma en cada vuelta y no puede correr la fecha
245
+ b.programar()
246
+ let primera = b.reloj!.fireDate
247
+ for _ in 0..<12 {{ b.programar() }}
248
+ print("alejado:\\(b.reloj!.fireDate > primera)")
249
+
250
+ // 3 · y la guarda no puede dejar al vigía sin rearmar: con una fecha ya agendada,
251
+ // la del vigía es «más lejos» y sin forzar la guarda la rechazaría.
252
+ let c = Barra()
253
+ c.programar() // deja una fecha agendada
254
+ c.calentadoEn = Date().addingTimeInterval(-1800)
255
+ c.vigiaAviso = false
256
+ let antes = rearmes
257
+ c.vigia()
258
+ print("vigiaRearmo:\\(rearmes > antes)")
259
+ """
260
+ with tempfile.TemporaryDirectory() as d:
261
+ f = pathlib.Path(d) / "v.swift"
262
+ f.write_text(guion, encoding="utf-8")
263
+ r = subprocess.run(["swift", str(f)], capture_output=True, text=True,
264
+ encoding="utf-8", timeout=300)
265
+ if r.returncode != 0:
266
+ # Las últimas líneas, no la última: un error de Swift termina en la
267
+ # línea del fuente y sin las de arriba no dice qué estuvo mal.
268
+ cola = (r.stderr or "swift falló").strip().splitlines()
269
+ errores = [l for l in cola if ": error:" in l] or cola[-4:]
270
+ raise RuntimeError(" / ".join(errores[:3]))
271
+ return r.stdout.strip().splitlines()
272
+
273
+
274
+ def main() -> int:
275
+ fallas = []
276
+
277
+ # Que las defensas EXISTAN, antes de probarlas. Sin esto, una versión que no
278
+ # las tiene sale por un traceback en vez de por un rojo que se pueda leer,
279
+ # y un gate ilegible es medio gate.
280
+ m = cargar()
281
+ for nombre, para_que in (("_vigia", "mirar desde afuera que el calentado siga ocurriendo"),
282
+ ("_sondear", "que una excepción del refresco no se lleve la fuente")):
283
+ if not hasattr(m.Indicador, nombre):
284
+ fallas.append(f"no existe `Indicador.{nombre}`, que es lo que hace falta para {para_que}")
285
+ if fallas:
286
+ for f in fallas:
287
+ print(f"GATE ROJO: {f}", file=sys.stderr)
288
+ return 1
289
+
290
+ # 1 · la bandera pegada sin instante
291
+ anotado, _ = correr(bandera_pegada)
292
+ if not any(l.startswith("calentar.colgado") for l in anotado):
293
+ fallas.append("diez vueltas del temporizador con `calentando` pegada y sin instante "
294
+ "no anotaron un solo `calentar.colgado`: ése es el silencio de siete horas")
295
+ if not any(l.startswith("calentar ") for l in anotado):
296
+ fallas.append("después de soltar la bandera pegada el calentado no volvió a ocurrir")
297
+
298
+ # 2 · el vigía
299
+ anotado, armados = correr(vigia_con_atraso)
300
+ parado = [l for l in anotado if l.startswith("calentar.parado")]
301
+ if not parado:
302
+ fallas.append("el vigía no anotó nada con el calentado parado media hora")
303
+ elif len(parado) != 1:
304
+ fallas.append(f"el vigía anotó {len(parado)} veces en tres vueltas: tiene que avisar "
305
+ "una vez por corte, si no el log no se puede leer")
306
+ if not armados:
307
+ fallas.append("el vigía anotó el atraso pero no rearmó el calentado")
308
+
309
+ # 3 · el hambre: el sondeo empatado con la cadencia
310
+ m2 = cargar()
311
+ m2.registrar = lambda *a, **k: None
312
+ reloj2 = RelojFalso()
313
+ m2.GLib = reloj2
314
+ ind2 = banco(m2)
315
+ hambre(m2, ind2, reloj2)
316
+ if not ind2.vencio:
317
+ fallas.append("con el sondeo y la cadencia empatados, doce vueltas de una hora "
318
+ "no dejaron vencer NI UN calentado: cada refresco corría la fecha "
319
+ "más lejos y el calentado no ocurría nunca")
320
+
321
+ # 4 · el vigía arranca con reloj puesto
322
+ fuente = (RAIZ / "bin/qm-indicator").read_text(encoding="utf-8")
323
+ if "self._ultimo_calentado: int | None = GLib.get_monotonic_time()" not in fuente:
324
+ fallas.append("`_ultimo_calentado` arranca en None: si el PRIMER calentado nunca "
325
+ "termina, el vigía no mira nunca y el silencio vuelve")
326
+ swift = (RAIZ / "bin/qm-barra.swift").read_text(encoding="utf-8")
327
+ if "if calentadoEn == nil { calentadoEn = Date() }" not in swift:
328
+ fallas.append("la barra de macOS arma el vigía sin ponerle reloj: mismo agujero")
329
+ if "$script:CalentadoEn = Get-Date" not in (RAIZ / "bin/qm-tray.ps1").read_text(encoding="utf-8"):
330
+ fallas.append("la bandeja de Windows arma el vigía sin ponerle reloj: mismo agujero")
331
+
332
+ # 5 · el sondeo que sobrevive a su propio error
333
+ m = cargar()
334
+ anotado = []
335
+ m.registrar = lambda evento, **d: anotado.append(evento)
336
+ reloj = RelojFalso()
337
+ m.GLib = reloj
338
+ ind = banco(m)
339
+ sondeo_que_revienta(m, ind, reloj)
340
+ if not all(ind.devuelto):
341
+ fallas.append("un `refrescar()` que tira deja al sondeo devolviendo un valor falso: "
342
+ "GLib le saca la fuente y con ella se va el único rearme del calentado")
343
+ if not any(l.startswith("sondeo.reventó") for l in anotado):
344
+ fallas.append("el sondeo se tragó la excepción sin anotarla")
345
+
346
+ # 5 · el vigía de macOS, ejecutado donde haya swiftc
347
+ exigidos = {x for x in os.environ.get("QM_GATE_EXIGE", "").split(",") if x}
348
+ salteado = ""
349
+ if shutil.which("swift") is None:
350
+ if "swift" in exigidos:
351
+ fallas.append("falta swift y este job lo exige: el vigía de la barra de macOS "
352
+ "quedaría sólo compilado, no corrido")
353
+ else:
354
+ salteado = " · salteado: el vigía de macOS (no hay swift en esta máquina)"
355
+ else:
356
+ try:
357
+ crudo = vigia_de_macos()
358
+ dicho = dict(l.split(":", 1) for l in crudo)
359
+ # Lo que dijo, pegado a cada rojo: un gate que dice «no cuadra» sin
360
+ # decir qué contestó obliga a adivinar, y adivinar es lo que este
361
+ # repo no hace.
362
+ fallas_antes = len(fallas)
363
+ if dicho.get("callado") != "true":
364
+ fallas.append("el vigía de macOS avisa con una lectura RECIENTE: cría lobo")
365
+ if dicho.get("avisos") != "1":
366
+ fallas.append(f"el vigía de macOS avisó {dicho.get('avisos')} veces en tres "
367
+ "vueltas: tiene que ser una por corte")
368
+ if dicho.get("rearmes") != "3":
369
+ fallas.append(f"el vigía de macOS rearmó {dicho.get('rearmes')} veces y "
370
+ "tenían que ser 3: avisar sin rearmar no destraba nada")
371
+ if dicho.get("vigiaRearmo") != "true":
372
+ fallas.append("la guarda anti-hambre de macOS deja al vigía sin rearmar: "
373
+ "con la fecha ya vencida, la fecha nueva siempre es «más "
374
+ "lejos» y la defensa contra el hambre apaga a la del silencio")
375
+ if dicho.get("alejado") != "false":
376
+ fallas.append("en macOS, doce refrescos seguidos ALEJAN la fecha del "
377
+ "calentado: con el .claude.json reescribiéndose cada veinte "
378
+ "segundos, el calentado no vence nunca")
379
+ if len(fallas) > fallas_antes:
380
+ fallas.append("lo que contestó el Swift: " + " · ".join(crudo))
381
+ except Exception as e: # noqa: BLE001
382
+ fallas.append(f"no pude correr el vigía de macOS: {e}")
383
+
384
+ if fallas:
385
+ for f in fallas:
386
+ print(f"GATE ROJO: {f}", file=sys.stderr)
387
+ return 1
388
+ print("lazo: la bandera pegada se suelta y se anota, el vigía avisa una vez y rearma, "
389
+ "y el sondeo sobrevive a su propio error")
390
+ if salteado:
391
+ print(salteado)
392
+ return 0
393
+
394
+
395
+ if __name__ == "__main__":
396
+ raise SystemExit(main())
Binary file