@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
|
@@ -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())
|
package/scripts/gate-tarjetas.py
CHANGED
|
@@ -1,7 +1,8 @@
|
|
|
1
|
-
"""
|
|
1
|
+
"""Tres invariantes del panel que no avisan cuando se rompen.
|
|
2
2
|
|
|
3
3
|
1 · Ninguna tarjeta puede ser más alta que una pantalla.
|
|
4
4
|
2 · Nada se dibuja fuera de la tarjeta.
|
|
5
|
+
3 · La cabecera existe, y no la encabeza una cuenta dormida.
|
|
5
6
|
|
|
6
7
|
El panel de GNOME es un `Gtk.Menu`, y un menú rueda ITEM por item: con un solo
|
|
7
8
|
item más alto que la pantalla no hay nada que rodar y el menú directamente no
|
|
@@ -42,11 +43,55 @@ def main() -> int:
|
|
|
42
43
|
if not margen_limpio(m):
|
|
43
44
|
return 1
|
|
44
45
|
|
|
46
|
+
if not cabecera_correcta(m):
|
|
47
|
+
return 1
|
|
48
|
+
|
|
45
49
|
print(f"tarjetas: la más alta es {nombre} con {alto} px, bajo el techo de {TECHO}; "
|
|
46
50
|
f"y nada se sale del margen")
|
|
51
|
+
print("cabecera: está, y la encabeza una cuenta despierta")
|
|
47
52
|
return 0
|
|
48
53
|
|
|
49
54
|
|
|
55
|
+
def cabecera_correcta(m) -> bool:
|
|
56
|
+
"""Que el panel tenga cabecera, y que no la encabece una cuenta dormida.
|
|
57
|
+
|
|
58
|
+
Las dos mitades existen porque las dos se rompieron de verdad, en silencio:
|
|
59
|
+
|
|
60
|
+
· La cabecera DESAPARECIÓ entera el día que dejó de calcularse acá y pasó a
|
|
61
|
+
leerse de `frenaPrimero`. Los fixtures todavía no traían ese campo, así
|
|
62
|
+
que `VistaResumen.desde()` devolvía None y el panel se dibujaba sin
|
|
63
|
+
encabezado. Los gates siguieron verdes: ninguno miraba si estaba.
|
|
64
|
+
|
|
65
|
+
· Y encabezarla con una cuenta dormida es el bug que originó todo el cambio.
|
|
66
|
+
Una cuenta free abandonada y clavada en 100 % gana por porcentaje siempre,
|
|
67
|
+
porque 100 es el máximo posible.
|
|
68
|
+
"""
|
|
69
|
+
cabecera, _ = m.modelo_panel(m.leer_desde("test/fixtures/panel.json"))
|
|
70
|
+
if cabecera is None:
|
|
71
|
+
print("GATE ROJO: el panel se dibujó SIN cabecera. El fixture no trae "
|
|
72
|
+
"`frenaPrimero`, o el renderer dejó de leerlo.", file=sys.stderr)
|
|
73
|
+
return False
|
|
74
|
+
|
|
75
|
+
datos = m.leer_desde("test/fixtures/panel-dormida.json")
|
|
76
|
+
cabecera, _ = m.modelo_panel(datos)
|
|
77
|
+
if cabecera is None:
|
|
78
|
+
print("GATE ROJO: sin cabecera en el fixture de la cuenta dormida",
|
|
79
|
+
file=sys.stderr)
|
|
80
|
+
return False
|
|
81
|
+
dormidas = {p.get("perfil") for p in datos.get("perfiles", [])
|
|
82
|
+
if (p.get("relevancia") or {}).get("dormida")}
|
|
83
|
+
if not dormidas:
|
|
84
|
+
print("GATE ROJO: el fixture panel-dormida.json perdió su cuenta dormida, "
|
|
85
|
+
"así que no prueba nada", file=sys.stderr)
|
|
86
|
+
return False
|
|
87
|
+
if cabecera.cuenta in {m.corto(x) for x in dormidas}:
|
|
88
|
+
print(f"GATE ROJO: encabeza «{cabecera.cuenta}», que está dormida. Una "
|
|
89
|
+
f"cuenta que nadie usa no puede ser «lo primero que te frena».",
|
|
90
|
+
file=sys.stderr)
|
|
91
|
+
return False
|
|
92
|
+
return True
|
|
93
|
+
|
|
94
|
+
|
|
50
95
|
def margen_limpio(m) -> bool:
|
|
51
96
|
"""Que ningún texto se dibuje fuera de la tarjeta.
|
|
52
97
|
|
package/scripts/hacer-deb.sh
CHANGED
|
@@ -31,7 +31,16 @@ cp -r bin src scripts extension Makefile package.json "$arma/usr/lib/quartermast
|
|
|
31
31
|
cp README.md LICENSE "$arma/usr/share/doc/quartermaster/"
|
|
32
32
|
# El lanzador sigue los symlinks para encontrar el src/, así que un enlace
|
|
33
33
|
# alcanza y no hay que duplicar el árbol.
|
|
34
|
-
|
|
34
|
+
#
|
|
35
|
+
# Los tres que da npm, y no sólo `qm`: `qm-web` es el tablero para una máquina
|
|
36
|
+
# sin barra de GNOME, y `qm-indicator` es el que instala el item y el arranque
|
|
37
|
+
# automático —`--instalar-extension`, `--instalar-arranque`—. Sin el enlace esas
|
|
38
|
+
# banderas quedaban a una ruta de /usr/lib que nadie tiene por qué saber, y los
|
|
39
|
+
# READMEs las documentaban como si estuvieran en el PATH. `qm-barra` no: es de
|
|
40
|
+
# macOS y adentro de un .deb no tiene nada que hacer.
|
|
41
|
+
for enlace in qm qm-web qm-indicator; do
|
|
42
|
+
ln -sf "/usr/lib/quartermaster/bin/$enlace" "$arma/usr/bin/$enlace"
|
|
43
|
+
done
|
|
35
44
|
find "$arma/usr/lib/quartermaster" -name '__pycache__' -prune -exec rm -rf {} +
|
|
36
45
|
# Lo de Windows no tiene nada que hacer adentro de un .deb: los lanzadores .cmd,
|
|
37
46
|
# la bandeja y el ícono del instalador. Son ~150 kB de archivos que en esta
|
package/src/render/tablero.html
CHANGED
|
@@ -300,10 +300,11 @@ td.num { text-align: right; font-variant-numeric: tabular-nums; }
|
|
|
300
300
|
<p class="pie-pagina" id="pie">
|
|
301
301
|
Todo sale del disco de esta máquina: el <code>.claude.json</code> de cada perfil, los rollouts de
|
|
302
302
|
Codex y la base de sesiones de opencode. Lo único que sale a la red es el refresco de cuota, y
|
|
303
|
-
sólo cuando se pide: al mismo lugar al que Claude Code y
|
|
304
|
-
son planes por API key
|
|
305
|
-
|
|
306
|
-
|
|
303
|
+
sólo cuando se pide: al mismo lugar al que Claude Code, Codex y opencode ya hablan. Las cuentas
|
|
304
|
+
de opencode son planes por API key y su porcentaje vive en el endpoint del proveedor: el de z.ai
|
|
305
|
+
se consulta con <code>--refrescar</code> y queda cacheado, y del resto se muestra el consumo y se
|
|
306
|
+
dice por qué no hay barra. <b>La única credencial de opencode que se lee es la clave de z.ai, y
|
|
307
|
+
sólo para ese pedido.</b> El tablero escucha sólo en 127.0.0.1.
|
|
307
308
|
</p>
|
|
308
309
|
</div>
|
|
309
310
|
|
|
@@ -593,6 +594,10 @@ function tarjeta(p) {
|
|
|
593
594
|
</div>
|
|
594
595
|
</div>
|
|
595
596
|
<div class="col">${cuerpo}</div>
|
|
597
|
+
${p.relevancia && p.relevancia.dormida
|
|
598
|
+
? `<div class="frase">dormida: ${esc((p.relevancia.porque || []).join(' · '))} — sigue acá con todos sus
|
|
599
|
+
números, pero no encabeza y va al final de la lista.</div>`
|
|
600
|
+
: ''}
|
|
596
601
|
<div class="consumo">
|
|
597
602
|
<div class="rotulo">consumo local · ${datos.ventanaDias} d</div>
|
|
598
603
|
${p.local === null || p.local === undefined
|
|
@@ -609,13 +614,16 @@ function tarjeta(p) {
|
|
|
609
614
|
}
|
|
610
615
|
|
|
611
616
|
function heroe() {
|
|
612
|
-
// Una sola cifra héroe por vista: la barra que te frena primero, en toda la
|
|
613
|
-
|
|
614
|
-
for
|
|
615
|
-
|
|
616
|
-
|
|
617
|
-
|
|
618
|
-
|
|
617
|
+
// Una sola cifra héroe por vista: la barra que te frena primero, en toda la
|
|
618
|
+
// máquina. QUIÉN encabeza lo decide el CLI y llega en `frenaPrimero`: acá
|
|
619
|
+
// había un `for` que se quedaba con el porcentaje más alto, y esa misma
|
|
620
|
+
// elección estaba escrita en las otras cinco pantallas. Seis copias son seis
|
|
621
|
+
// respuestas en cuanto el criterio cambia — y cambió: una cuenta dormida en
|
|
622
|
+
// 100 % ya no encabeza.
|
|
623
|
+
const lider = datos.frenaPrimero;
|
|
624
|
+
const mejor = lider && lider.ventana
|
|
625
|
+
? { p: datos.perfiles.find((x) => x.perfil === lider.perfil) ?? {}, v: lider.ventana }
|
|
626
|
+
: null;
|
|
619
627
|
if (!mejor) {
|
|
620
628
|
return `<div class="heroe"><div class="texto">
|
|
621
629
|
<div class="rotulo">lo primero que te frena</div>
|