@legios/quartermaster 0.1.6 → 0.1.8
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 +43 -1
- package/bin/qm-barra.swift +110 -12
- package/bin/qm-indicator +153 -4
- package/dist/adapters/barra.js +154 -0
- package/dist/adapters/barra.js.map +1 -0
- package/dist/adapters/transcripciones.js +28 -0
- package/dist/adapters/transcripciones.js.map +1 -1
- package/dist/cli/qm.js +77 -7
- package/dist/cli/qm.js.map +1 -1
- package/dist/core/presupuesto.js +69 -3
- package/dist/core/presupuesto.js.map +1 -1
- package/package.json +1 -1
- package/scripts/gate-calentado.py +49 -3
- package/scripts/mandar-pr-winget.mjs +189 -0
package/README.md
CHANGED
|
@@ -49,6 +49,12 @@ brew install legiosai/tap/quartermaster # macOS and Linux
|
|
|
49
49
|
npm install -g @legios/quartermaster # anywhere
|
|
50
50
|
```
|
|
51
51
|
|
|
52
|
+
**The menu bar item on macOS:** the first time you run `qm` in a terminal, it
|
|
53
|
+
asks once whether to put it in the menu bar and start it at every login. The
|
|
54
|
+
install itself can't: brew can't start anything from a formula, and a tool that
|
|
55
|
+
reads OAuth tokens shouldn't register login agents nobody asked for. Without the
|
|
56
|
+
question: `brew services start quartermaster`.
|
|
57
|
+
|
|
52
58
|
**Windows:** the installer from the [latest
|
|
53
59
|
release](https://github.com/legiosai/quartermaster/releases/latest). Per-user
|
|
54
60
|
and no UAC: it puts `qm` on your `PATH`, the tray in the Start menu, and — if
|
|
@@ -126,15 +132,51 @@ journalctl --user -b | grep qm-indicator
|
|
|
126
132
|
```
|
|
127
133
|
|
|
128
134
|
```
|
|
135
|
+
qm-indicator: pedido accion=actualizar
|
|
136
|
+
qm-indicator: calentar cuentas=.claude,.claude-teams,codex
|
|
129
137
|
qm-indicator: panel.abierto donde=arriba-derecha alto=1032
|
|
130
138
|
qm-indicator: panel.cerrado vivio_ms=3999
|
|
131
139
|
qm-indicator: panel.agarre-roto
|
|
132
|
-
qm-indicator:
|
|
140
|
+
qm-indicator: aviso clave=teams|weekly_all|2026-09-13T11:00|80 urgente=False
|
|
141
|
+
qm-indicator: qm.sin-datos motivo=qm salió 2: opción desconocida
|
|
133
142
|
```
|
|
134
143
|
|
|
144
|
+
The events, and the question each one answers:
|
|
145
|
+
|
|
146
|
+
| event | answers |
|
|
147
|
+
| --- | --- |
|
|
148
|
+
| `pedido` | did the click reach the indicator at all? |
|
|
149
|
+
| `calentar` / `calentar.fallo` | which accounts were re-read, and why a refresh did not happen |
|
|
150
|
+
| `panel.abierto` / `panel.cerrado` | `vivio_ms` — a panel that lived 40 ms was not closed by you |
|
|
151
|
+
| `panel.agarre-roto` | the compositor took the grab away |
|
|
152
|
+
| `aviso` / `aviso.repetido` / `aviso.fallo` | it fired, it was suppressed as a duplicate, or the notification server refused it |
|
|
153
|
+
| `qm.sin-datos` | why there is no number, instead of only a phrase on screen |
|
|
154
|
+
| `reinicio` | the process replaced itself because the source changed |
|
|
155
|
+
| `suspension.duerme` / `.vuelve` | the machine slept, and the quota was re-read on resume |
|
|
156
|
+
| `calentar.colgado` | a warm never called back and its flag was released after the deadline |
|
|
157
|
+
|
|
135
158
|
`vivio_ms` is the one that matters for "the panel closes on its own": a panel
|
|
136
159
|
that lives 40 ms was not closed by you. `QM_SILENCIO=1` turns it off.
|
|
137
160
|
|
|
161
|
+
**The macOS menu bar writes a log too**, timestamped and capped at 1 MB. With
|
|
162
|
+
brew it is `$(brew --prefix)/var/log/quartermaster.log`:
|
|
163
|
+
|
|
164
|
+
```
|
|
165
|
+
2026-09-14T11:40:02-03:00 [qm-barra] arranca · qm=/opt/homebrew/opt/quartermaster/libexec/bin/qm · pid 812
|
|
166
|
+
2026-09-14T11:40:03-03:00 [qm-barra] posición: ancho=125.0 x=985.0..1110.0 muescaDerechaMinX=825.0 pantalla=1470.0 escondido=false
|
|
167
|
+
2026-09-14T11:40:04-03:00 [qm-barra] calentar · .claude: sin credencial — corré: …
|
|
168
|
+
2026-09-14T12:02:10-03:00 [qm-barra] aviso: quartermaster · teams — …
|
|
169
|
+
2026-09-14T13:15:40-03:00 [qm-barra] calentado (--calentar) falló: salió 1
|
|
170
|
+
2026-09-14T13:21:41-03:00 [qm-barra] calentado volvió a andar
|
|
171
|
+
```
|
|
172
|
+
|
|
173
|
+
It writes changes, not repeats: the item's position once per screen when it
|
|
174
|
+
moves, a refresh or a read the first time it fails and again when it recovers,
|
|
175
|
+
why an account was not refreshed (once per reason), and every notification —
|
|
176
|
+
with a line if `osascript` did not show it.
|
|
177
|
+
`escondido=true` is the one to look for when the item does not appear: macOS
|
|
178
|
+
put it under the notch or ran out of room.
|
|
179
|
+
|
|
138
180
|
## Where you can see it
|
|
139
181
|
|
|
140
182
|
| | |
|
package/bin/qm-barra.swift
CHANGED
|
@@ -65,6 +65,43 @@ func rutaQm() -> String {
|
|
|
65
65
|
return (NSHomeDirectory() as NSString).appendingPathComponent(".local/bin/qm")
|
|
66
66
|
}
|
|
67
67
|
|
|
68
|
+
// ── el log ───────────────────────────────────────────────────────────────
|
|
69
|
+
// Todo lo que la barra tiene para decir va a stderr, que launchd (o `brew
|
|
70
|
+
// services`) manda a un archivo. Antes ahí sólo quedaba dónde se dibujaba el
|
|
71
|
+
// item, sin hora, un renglón por minuto; lo que de verdad importa —un calentado
|
|
72
|
+
// que falla, una lectura que no vuelve, un aviso que no sale— se tiraba. Un
|
|
73
|
+
// calentado roto se veía igual que uno sano: la barra seguía mostrando el
|
|
74
|
+
// número viejo con su edad, y el archivo no decía por qué.
|
|
75
|
+
//
|
|
76
|
+
// Con hora, y con tope: el archivo lo abre launchd y nadie lo rota.
|
|
77
|
+
|
|
78
|
+
let LOG_MAXIMO_BYTES: off_t = 1_000_000
|
|
79
|
+
let colaLog = DispatchQueue(label: "quartermaster.log")
|
|
80
|
+
let horaLog: ISO8601DateFormatter = {
|
|
81
|
+
let f = ISO8601DateFormatter()
|
|
82
|
+
f.formatOptions = [.withInternetDateTime]
|
|
83
|
+
f.timeZone = .current
|
|
84
|
+
return f
|
|
85
|
+
}()
|
|
86
|
+
|
|
87
|
+
func registrar(_ texto: String) {
|
|
88
|
+
let ahora = Date()
|
|
89
|
+
colaLog.async {
|
|
90
|
+
// Sólo se recorta un archivo de verdad: corriendo a mano, stderr es la
|
|
91
|
+
// terminal y no hay nada que recortar.
|
|
92
|
+
var st = stat()
|
|
93
|
+
if fstat(STDERR_FILENO, &st) == 0, (st.st_mode & S_IFMT) == S_IFREG, st.st_size > LOG_MAXIMO_BYTES {
|
|
94
|
+
ftruncate(STDERR_FILENO, 0)
|
|
95
|
+
lseek(STDERR_FILENO, 0, SEEK_SET)
|
|
96
|
+
FileHandle.standardError.write(
|
|
97
|
+
"\(horaLog.string(from: ahora)) [qm-barra] log recortado: pasaba de \(LOG_MAXIMO_BYTES) bytes\n"
|
|
98
|
+
.data(using: .utf8)!)
|
|
99
|
+
}
|
|
100
|
+
let una = texto.replacingOccurrences(of: "\n", with: " / ")
|
|
101
|
+
FileHandle.standardError.write("\(horaLog.string(from: ahora)) [qm-barra] \(una)\n".data(using: .utf8)!)
|
|
102
|
+
}
|
|
103
|
+
}
|
|
104
|
+
|
|
68
105
|
/// La paleta de estado, la misma del tablero y validada contra los dos fondos
|
|
69
106
|
/// que puede tener la barra. El color va en la MARCA, nunca en el texto: el
|
|
70
107
|
/// número se queda con el color de etiqueta del sistema, que se adapta solo.
|
|
@@ -375,7 +412,12 @@ func notificar(titulo: String, cuerpo: String) {
|
|
|
375
412
|
let p = Process()
|
|
376
413
|
p.executableURL = URL(fileURLWithPath: "/usr/bin/osascript")
|
|
377
414
|
p.arguments = ["-e", "display notification \"\(limpio(cuerpo))\" with title \"\(limpio(titulo))\""]
|
|
378
|
-
|
|
415
|
+
registrar("aviso: \(titulo) — \(cuerpo)")
|
|
416
|
+
// Si osascript no sale 0 el aviso no se vio, y es el único rastro de eso.
|
|
417
|
+
p.terminationHandler = { t in
|
|
418
|
+
if t.terminationStatus != 0 { registrar("el aviso no salió: osascript salió \(t.terminationStatus)") }
|
|
419
|
+
}
|
|
420
|
+
do { try p.run() } catch { registrar("el aviso no salió: no pude correr osascript: \(error.localizedDescription)") }
|
|
379
421
|
}
|
|
380
422
|
|
|
381
423
|
|
|
@@ -706,6 +748,14 @@ final class Barra: NSObject, NSApplicationDelegate {
|
|
|
706
748
|
/// Lo último que se vio, para decidir cada cuánto volver a mirar.
|
|
707
749
|
var ultimas: [Trozo] = []
|
|
708
750
|
var avisoBarraLlena = false
|
|
751
|
+
/// Lo último que se anotó de cada cosa, para anotar CAMBIOS y no repetir:
|
|
752
|
+
/// la posición se revisa en cada redibujo —un renglón por minuto, igual en
|
|
753
|
+
/// cada vuelta— y un calentado roto falla en cada sondeo.
|
|
754
|
+
var ultimaPosicion: [String: String] = [:]
|
|
755
|
+
var ultimaFalla: String?
|
|
756
|
+
var ultimoCalentado: String?
|
|
757
|
+
/// Los motivos por cuenta ya anotados en esta corrida («.claude: sin credencial»).
|
|
758
|
+
var motivosCalentado: Set<String> = []
|
|
709
759
|
/// `perfil|barra` -> [minuto de reinicio, porcentaje] de la última vuelta.
|
|
710
760
|
/// Persistido: es lo que permite notar que una ventana se dio vuelta.
|
|
711
761
|
var previos: [String: [Int]] = Barra.leerPrevios()
|
|
@@ -730,6 +780,9 @@ final class Barra: NSObject, NSApplicationDelegate {
|
|
|
730
780
|
// barra llena, cmd-arrastrar el item a un hueco es LA salida, y sin
|
|
731
781
|
// esto se perdería en cada arranque.
|
|
732
782
|
item.autosaveName = "quartermaster"
|
|
783
|
+
// El renglón que separa una corrida de otra en el log: sin esto no se
|
|
784
|
+
// sabe si dos líneas son del mismo proceso ni desde cuándo corre.
|
|
785
|
+
registrar("arranca · qm=\(rutaQm()) · pid \(ProcessInfo.processInfo.processIdentifier)")
|
|
733
786
|
item.button?.title = "qm…"
|
|
734
787
|
item.menu = NSMenu()
|
|
735
788
|
actividad = ProcessInfo.processInfo.beginActivity(
|
|
@@ -792,11 +845,45 @@ final class Barra: NSObject, NSApplicationDelegate {
|
|
|
792
845
|
p.arguments = vale.isEmpty || vale.count == self.ultimas.count
|
|
793
846
|
? ["--calentar"]
|
|
794
847
|
: ["--calentar", "--cuentas=" + vale.joined(separator: ",")]
|
|
848
|
+
// stdout no dice nada; stderr es el porqué de cada cuenta que no se
|
|
849
|
+
// calentó, y antes iba a /dev/null junto con el código de salida.
|
|
850
|
+
let errores = Pipe()
|
|
795
851
|
p.standardOutput = FileHandle.nullDevice
|
|
796
|
-
p.standardError =
|
|
797
|
-
|
|
798
|
-
|
|
799
|
-
|
|
852
|
+
p.standardError = errores
|
|
853
|
+
// Dos cosas distintas, y mezclarlas daba un log que mentía:
|
|
854
|
+
// · el calentado FALLÓ: salió distinto de 0, ninguna cuenta volvió.
|
|
855
|
+
// Se anota cuando empieza y cuando vuelve a andar.
|
|
856
|
+
// · una cuenta no se calentó (sin credencial, token vencido) aunque
|
|
857
|
+
// otras sí. Cada motivo se anota una vez y no tiene «volvió»: los
|
|
858
|
+
// calentados alternan entre todas las cuentas y sólo las que se
|
|
859
|
+
// mueven, así que que un motivo no aparezca NO dice que se arregló.
|
|
860
|
+
var fallo: String?
|
|
861
|
+
var motivos: [String] = []
|
|
862
|
+
do {
|
|
863
|
+
try p.run()
|
|
864
|
+
let dicho = String(data: errores.fileHandleForReading.readDataToEndOfFile(), encoding: .utf8) ?? ""
|
|
865
|
+
p.waitUntilExit()
|
|
866
|
+
motivos = dicho.split(separator: "\n").map { $0.trimmingCharacters(in: .whitespaces) }.filter { !$0.isEmpty }
|
|
867
|
+
if p.terminationStatus != 0 {
|
|
868
|
+
fallo = "calentado (\(p.arguments?.joined(separator: " ") ?? "")) falló: salió \(p.terminationStatus)"
|
|
869
|
+
}
|
|
870
|
+
} catch {
|
|
871
|
+
fallo = "calentado falló: no pude correr qm: \(error.localizedDescription)"
|
|
872
|
+
}
|
|
873
|
+
DispatchQueue.main.async {
|
|
874
|
+
if let fallo {
|
|
875
|
+
if fallo != self.ultimoCalentado { registrar(fallo) }
|
|
876
|
+
self.ultimoCalentado = fallo
|
|
877
|
+
} else if self.ultimoCalentado != nil {
|
|
878
|
+
registrar("calentado volvió a andar")
|
|
879
|
+
self.ultimoCalentado = nil
|
|
880
|
+
}
|
|
881
|
+
for m in motivos where !self.motivosCalentado.contains(m) {
|
|
882
|
+
self.motivosCalentado.insert(m)
|
|
883
|
+
registrar(m)
|
|
884
|
+
}
|
|
885
|
+
self.refrescar()
|
|
886
|
+
}
|
|
800
887
|
}
|
|
801
888
|
}
|
|
802
889
|
|
|
@@ -859,11 +946,17 @@ final class Barra: NSObject, NSApplicationDelegate {
|
|
|
859
946
|
|
|
860
947
|
switch lectura {
|
|
861
948
|
case .falla(let porque):
|
|
949
|
+
// En el menú ya se veía; en el log no, así que una lectura que falló
|
|
950
|
+
// y se recuperó sola no dejaba rastro de haber pasado.
|
|
951
|
+
if porque != ultimaFalla { registrar("lectura de qm falló: \(porque)") }
|
|
952
|
+
ultimaFalla = porque
|
|
862
953
|
item.button?.attributedTitle = comoRenglones("qm ✕")
|
|
863
954
|
item.button?.image = icono("exclamationmark.triangle.fill")
|
|
864
955
|
agregar(menu, porque, activo: false)
|
|
865
956
|
|
|
866
957
|
case .ok(let perfiles):
|
|
958
|
+
if ultimaFalla != nil { registrar("lectura de qm volvió a andar") }
|
|
959
|
+
ultimaFalla = nil
|
|
867
960
|
vigilar(perfiles)
|
|
868
961
|
// Por cuenta: la sesión (la ventana corta) y la barra que frena
|
|
869
962
|
// antes. Son dos preguntas distintas —«¿puedo seguir ahora?» y
|
|
@@ -995,13 +1088,18 @@ final class Barra: NSObject, NSApplicationDelegate {
|
|
|
995
1088
|
let suya = v.screen ?? NSScreen.main
|
|
996
1089
|
let afuera = suya.map { v.frame.minX < $0.frame.minX || v.frame.maxX > $0.frame.maxX } ?? false
|
|
997
1090
|
let escondido = afuera || tapadoPorLaMuesca()
|
|
998
|
-
//
|
|
1091
|
+
// Al log, porque es lo único que explica por qué no se ve nada. Pero
|
|
1092
|
+
// sólo cuando CAMBIA, y por pantalla: con tres monitores esto se
|
|
1093
|
+
// revisaba en cada redibujo y dejaba el mismo renglón una vez por minuto.
|
|
999
1094
|
let pant = v.screen ?? NSScreen.main
|
|
1000
|
-
|
|
1001
|
-
|
|
1002
|
-
|
|
1003
|
-
|
|
1004
|
-
|
|
1095
|
+
let linea = "posición: ancho=\(v.frame.width) x=\(v.frame.minX)..\(v.frame.maxX) "
|
|
1096
|
+
+ "muescaDerechaMinX=\(pant?.auxiliaryTopRightArea?.minX ?? -1) "
|
|
1097
|
+
+ "pantalla=\(pant?.frame.width ?? -1) escondido=\(escondido)"
|
|
1098
|
+
let clave = "\(pant?.frame.width ?? -1)x\(pant?.frame.height ?? -1)"
|
|
1099
|
+
if ultimaPosicion[clave] != linea {
|
|
1100
|
+
ultimaPosicion[clave] = linea
|
|
1101
|
+
registrar(linea)
|
|
1102
|
+
}
|
|
1005
1103
|
// Una sola vez por corrida. Antes se re-armaba al volver a entrar, así
|
|
1006
1104
|
// que un item que oscila entre visible y tapado avisaba en cada vuelta.
|
|
1007
1105
|
if escondido, !avisoBarraLlena {
|
|
@@ -1267,7 +1365,7 @@ final class Barra: NSObject, NSApplicationDelegate {
|
|
|
1267
1365
|
.write(to: URL(fileURLWithPath: ruta.replacingOccurrences(of: ".png", with: "\(sufijo).png")))
|
|
1268
1366
|
}
|
|
1269
1367
|
}
|
|
1270
|
-
|
|
1368
|
+
registrar("capturado ancho=\(caja.width) alto=\(caja.height) filas=\(vistas.count)")
|
|
1271
1369
|
}
|
|
1272
1370
|
|
|
1273
1371
|
// Acciones -------------------------------------------------------------
|
package/bin/qm-indicator
CHANGED
|
@@ -56,6 +56,14 @@ from gi.repository import Gdk, Gio, GLib, Gtk, Pango, PangoCairo # noqa: E402
|
|
|
56
56
|
ID = "quartermaster"
|
|
57
57
|
# Red de seguridad: el FileMonitor es el que manda. Esto sólo cubre el caso de
|
|
58
58
|
# un monitor que se pierda un evento (montajes raros, archivos reemplazados).
|
|
59
|
+
# Cuánto hace falta que una cuenta esté sin usarse para dejar de preguntarle.
|
|
60
|
+
# Diez minutos aguantan una pausa entre prompts sin seguir preguntando por una
|
|
61
|
+
# cuenta que ya cerraste.
|
|
62
|
+
ACTIVA_SEGUNDOS = 600
|
|
63
|
+
# Cuánto se le da a un calentado antes de darlo por colgado. `qm --calentar`
|
|
64
|
+
# tiene su propio timeout de red adentro, así que si en dos minutos no contestó
|
|
65
|
+
# es que su callback no va a llegar.
|
|
66
|
+
CALENTADO_PLAZO_US = 120 * 1_000_000
|
|
59
67
|
SEGUNDOS_SONDEO = 300
|
|
60
68
|
# Piso para cualquier cadencia que salga a la RED. Claude Code pide la cuota del
|
|
61
69
|
# orden de una vez por sesión; un endpoint no documentado, que además puede
|
|
@@ -962,6 +970,10 @@ def piezas_de(datos, avisar=None) -> list[dict]:
|
|
|
962
970
|
# número que tiene es de una ventana que ya cerró.
|
|
963
971
|
"reinicia_sesion": ses.get("reinicia") if ses else None,
|
|
964
972
|
"reinicia_semanal": sem.get("reinicia") if sem else None,
|
|
973
|
+
# Cuándo se usó esta cuenta por última vez. Es lo que distingue una
|
|
974
|
+
# cuenta al 2 % que está quieta de una al 2 % que estás gastando
|
|
975
|
+
# ahora mismo: el número de la segunda se mueve, el de la primera no.
|
|
976
|
+
"ultimo_uso": p.get("ultimoUso"),
|
|
965
977
|
"viejo": (cuota.get("edadSegundos") or 0) >= VIEJO_SEGUNDOS,
|
|
966
978
|
})
|
|
967
979
|
if avisar is not None:
|
|
@@ -1440,6 +1452,10 @@ class Avisos:
|
|
|
1440
1452
|
self.vistos = set(json.loads(self.ruta.read_text()))
|
|
1441
1453
|
except (OSError, ValueError):
|
|
1442
1454
|
self.vistos = set()
|
|
1455
|
+
# Sólo para el registro: qué avisos repetidos ya se dijeron en ESTE
|
|
1456
|
+
# proceso. No se persiste — al reiniciar conviene volver a decirlo una
|
|
1457
|
+
# vez, porque el registro nuevo arranca vacío.
|
|
1458
|
+
self.repetidos_dichos: set[str] = set()
|
|
1443
1459
|
|
|
1444
1460
|
def guardar(self) -> None:
|
|
1445
1461
|
try:
|
|
@@ -1451,9 +1467,21 @@ class Avisos:
|
|
|
1451
1467
|
def avisar(self, clave: str, titulo: str, cuerpo: str, urgente: bool) -> None:
|
|
1452
1468
|
"""Una vez por clave y nunca más."""
|
|
1453
1469
|
if clave in self.vistos:
|
|
1470
|
+
# Que un aviso NO salga por repetido es una decisión, no un
|
|
1471
|
+
# no-evento: explica «no me avisó» cuando el aviso sí correspondía.
|
|
1472
|
+
#
|
|
1473
|
+
# Pero esto se evalúa en CADA refresco, o sea cada pocos segundos
|
|
1474
|
+
# mientras la barra siga alta. Registrarlo siempre son tres líneas
|
|
1475
|
+
# iguales cada veinte segundos hasta que la ventana se reinicie: el
|
|
1476
|
+
# registro deja de leerse y el evento que importa queda enterrado.
|
|
1477
|
+
# Se dice una vez por clave y por proceso, que es cuando aporta.
|
|
1478
|
+
if clave not in self.repetidos_dichos:
|
|
1479
|
+
self.repetidos_dichos.add(clave)
|
|
1480
|
+
registrar("aviso.repetido", clave=clave)
|
|
1454
1481
|
return
|
|
1455
1482
|
self.vistos.add(clave)
|
|
1456
1483
|
self.guardar()
|
|
1484
|
+
registrar("aviso", clave=clave, urgente=urgente)
|
|
1457
1485
|
self.notificar(titulo, cuerpo, urgente)
|
|
1458
1486
|
|
|
1459
1487
|
def notificar(self, titulo: str, cuerpo: str, urgente: bool) -> None:
|
|
@@ -1483,8 +1511,11 @@ class Avisos:
|
|
|
1483
1511
|
-1,
|
|
1484
1512
|
None,
|
|
1485
1513
|
)
|
|
1486
|
-
except GLib.Error:
|
|
1487
|
-
|
|
1514
|
+
except GLib.Error as e:
|
|
1515
|
+
# El indicador igual funciona sin servidor de notificaciones, pero
|
|
1516
|
+
# «te liberaste» es el aviso más útil que da el programa: si no sale,
|
|
1517
|
+
# tiene que quedar dicho por qué.
|
|
1518
|
+
registrar("aviso.fallo", motivo=str(e).replace("\n", " ")[:100])
|
|
1488
1519
|
|
|
1489
1520
|
|
|
1490
1521
|
# ── leer a qm ────────────────────────────────────────────────────────────
|
|
@@ -1563,6 +1594,9 @@ class Indicador:
|
|
|
1563
1594
|
self.piezas: list[dict] = []
|
|
1564
1595
|
self.minutos_al_techo: float | None = None
|
|
1565
1596
|
self.calentando = False
|
|
1597
|
+
# Desde cuándo. Sin esto, una bandera que se queda pegada no se puede
|
|
1598
|
+
# distinguir de un calentado que recién arrancó.
|
|
1599
|
+
self.calentando_desde: int | None = None
|
|
1566
1600
|
self.reloj: int | None = None
|
|
1567
1601
|
self.proxima_lectura: int | None = None
|
|
1568
1602
|
self.turno = 0
|
|
@@ -1576,6 +1610,7 @@ class Indicador:
|
|
|
1576
1610
|
self.vigilar_version()
|
|
1577
1611
|
GLib.timeout_add_seconds(SEGUNDOS_SONDEO, self.refrescar)
|
|
1578
1612
|
self.programar_calentado(5)
|
|
1613
|
+
self.vigilar_suspension()
|
|
1579
1614
|
|
|
1580
1615
|
# Vigilancia de archivos ------------------------------------------------
|
|
1581
1616
|
def vigilar(self) -> None:
|
|
@@ -1653,12 +1688,67 @@ class Indicador:
|
|
|
1653
1688
|
print(f"la versión nueva no compila, me quedo con ésta: {e}", file=sys.stderr)
|
|
1654
1689
|
return False
|
|
1655
1690
|
self.panel.menu.popdown()
|
|
1691
|
+
# Un proceso que se reemplaza a sí mismo en silencio explica cualquier
|
|
1692
|
+
# rareza posterior —contadores en cero, panel cerrado, avisos de nuevo—
|
|
1693
|
+
# y hasta acá no dejaba una línea.
|
|
1694
|
+
registrar("reinicio", motivo="el fuente cambió")
|
|
1656
1695
|
try:
|
|
1657
1696
|
os.execv(sys.executable, [sys.executable, str(YO), *sys.argv[1:]])
|
|
1658
1697
|
except OSError as e:
|
|
1698
|
+
registrar("reinicio.fallo", error=str(e)[:80])
|
|
1659
1699
|
print(f"no pude reiniciarme: {e}", file=sys.stderr)
|
|
1660
1700
|
return False
|
|
1661
1701
|
|
|
1702
|
+
def vigilar_suspension(self) -> None:
|
|
1703
|
+
"""Enterarse de que la máquina durmió, y refrescar al volver.
|
|
1704
|
+
|
|
1705
|
+
Sin esto, volver de una suspensión es la peor pantalla que da el
|
|
1706
|
+
programa: los números son de antes de dormir y las ventanas que se
|
|
1707
|
+
reiniciaron mientras tanto salen marcadas «vencida». Todo correcto y
|
|
1708
|
+
todo inútil — lo que hace falta es el número de ahora.
|
|
1709
|
+
|
|
1710
|
+
Y no alcanza con esperar al próximo sondeo. Los timeouts de GLib corren
|
|
1711
|
+
contra el reloj MONOTÓNICO, que en Linux no avanza mientras la máquina
|
|
1712
|
+
duerme: cuatro horas suspendida son cero segundos para el temporizador.
|
|
1713
|
+
El reloj de pared sí saltó, así que la lectura queda vieja de horas
|
|
1714
|
+
mientras el sondeo cree que recién empieza.
|
|
1715
|
+
|
|
1716
|
+
logind avisa con PrepareForSleep: `true` antes de dormir, `false` al
|
|
1717
|
+
volver. El `false` es el que importa.
|
|
1718
|
+
|
|
1719
|
+
Va en el bus del SISTEMA, no en el de sesión. Si no se puede —un
|
|
1720
|
+
contenedor, una máquina sin logind— se sigue sin esto, que es como
|
|
1721
|
+
estaba hasta hoy.
|
|
1722
|
+
"""
|
|
1723
|
+
try:
|
|
1724
|
+
sistema = Gio.bus_get_sync(Gio.BusType.SYSTEM, None)
|
|
1725
|
+
sistema.signal_subscribe(
|
|
1726
|
+
"org.freedesktop.login1",
|
|
1727
|
+
"org.freedesktop.login1.Manager",
|
|
1728
|
+
"PrepareForSleep",
|
|
1729
|
+
"/org/freedesktop/login1",
|
|
1730
|
+
None,
|
|
1731
|
+
Gio.DBusSignalFlags.NONE,
|
|
1732
|
+
self._al_dormir_o_volver,
|
|
1733
|
+
)
|
|
1734
|
+
self.bus_sistema = sistema
|
|
1735
|
+
except GLib.Error as e:
|
|
1736
|
+
registrar("suspension.sin-logind", motivo=str(e)[:90])
|
|
1737
|
+
|
|
1738
|
+
def _al_dormir_o_volver(self, _con, _emisor, _ruta, _iface, _senal, params) -> None:
|
|
1739
|
+
durmiendo = bool(params[0]) if params and len(params) else False
|
|
1740
|
+
if durmiendo:
|
|
1741
|
+
registrar("suspension.duerme")
|
|
1742
|
+
return
|
|
1743
|
+
registrar("suspension.vuelve")
|
|
1744
|
+
# La bandera se suelta a mano: si había un calentado en vuelo cuando la
|
|
1745
|
+
# máquina se durmió, su callback es justo el que puede no llegar.
|
|
1746
|
+
self.calentando = False
|
|
1747
|
+
self.calentando_desde = None
|
|
1748
|
+
# Y se pregunta YA, no en el próximo sondeo: al volver, lo que hay en
|
|
1749
|
+
# pantalla es de antes de dormir.
|
|
1750
|
+
self.programar_calentado(2)
|
|
1751
|
+
|
|
1662
1752
|
def vigilar_tema(self) -> None:
|
|
1663
1753
|
"""El tema del escritorio se cambia con esto andando.
|
|
1664
1754
|
|
|
@@ -1698,14 +1788,24 @@ class Indicador:
|
|
|
1698
1788
|
self.pedido_pendiente = None
|
|
1699
1789
|
try:
|
|
1700
1790
|
accion = PEDIDO.read_text().split(" ", 1)[0].strip()
|
|
1701
|
-
except OSError:
|
|
1791
|
+
except OSError as e:
|
|
1792
|
+
# Un pedido que no se puede leer es un click que se perdió, y sin
|
|
1793
|
+
# esta línea se pierde sin dejar rastro.
|
|
1794
|
+
registrar("pedido.ilegible", error=str(e)[:80])
|
|
1702
1795
|
return False
|
|
1796
|
+
# Saber si el click LLEGÓ es la mitad de cualquier diagnóstico de «no
|
|
1797
|
+
# hace nada»: separa «la extensión no pidió» de «pidió y no pasó nada».
|
|
1798
|
+
# Sin esto hubo que disparar el pedido a mano y mirar el mtime de
|
|
1799
|
+
# estado.json para saber de qué lado estaba el problema.
|
|
1800
|
+
registrar("pedido", accion=accion or "(vacío)")
|
|
1703
1801
|
if accion == "alternar":
|
|
1704
1802
|
# La extensión sólo pide esto cuando NO puede dibujar el panel ella
|
|
1705
1803
|
# misma; si puede, abre su propio menú y no manda nada.
|
|
1706
1804
|
self.abrir_panel()
|
|
1707
1805
|
elif accion == "actualizar":
|
|
1708
1806
|
self.refrescar()
|
|
1807
|
+
else:
|
|
1808
|
+
registrar("pedido.desconocido", accion=accion[:40])
|
|
1709
1809
|
return False
|
|
1710
1810
|
|
|
1711
1811
|
def extension_viva(self) -> bool:
|
|
@@ -1771,6 +1871,12 @@ class Indicador:
|
|
|
1771
1871
|
return True
|
|
1772
1872
|
return False
|
|
1773
1873
|
|
|
1874
|
+
@staticmethod
|
|
1875
|
+
def _activa_hace_poco(t: dict) -> bool:
|
|
1876
|
+
"""Si se usó hace poco. Entonces su número se está moviendo."""
|
|
1877
|
+
seg = faltan(t.get("ultimo_uso"))
|
|
1878
|
+
return seg is not None and -ACTIVA_SEGUNDOS <= seg <= 0
|
|
1879
|
+
|
|
1774
1880
|
def _vale_preguntar(self, t: dict) -> bool:
|
|
1775
1881
|
"""A qué cuentas se les pregunta en el próximo calentado.
|
|
1776
1882
|
|
|
@@ -1796,6 +1902,18 @@ class Indicador:
|
|
|
1796
1902
|
"""
|
|
1797
1903
|
if self._ya_reinicio(t):
|
|
1798
1904
|
return True
|
|
1905
|
+
# Y la cuenta que estás usando AHORA, esté donde esté.
|
|
1906
|
+
#
|
|
1907
|
+
# El corte de abajo —«una cuenta al 9 % no da noticias»— es cierto de
|
|
1908
|
+
# una cuenta QUIETA. De una que estás gastando es exactamente al revés:
|
|
1909
|
+
# es la única cuyo número está cambiando, y con el corte por nivel se
|
|
1910
|
+
# quedaba sin preguntar hasta llegar al 40 %.
|
|
1911
|
+
#
|
|
1912
|
+
# Medido el 2026-09-13, con dos sesiones abiertas: la cuenta de teams
|
|
1913
|
+
# iba al 2 % y en 55 minutos la barra le preguntó al endpoint UNA vez.
|
|
1914
|
+
# Todos los demás calentados fueron para codex, que estaba al 85 %.
|
|
1915
|
+
if self._activa_hace_poco(t):
|
|
1916
|
+
return True
|
|
1799
1917
|
return 40 <= self._tope(t) < 100
|
|
1800
1918
|
|
|
1801
1919
|
def cadencia(self) -> int:
|
|
@@ -1840,7 +1958,30 @@ class Indicador:
|
|
|
1840
1958
|
def calentar(self) -> bool:
|
|
1841
1959
|
self.reloj = None
|
|
1842
1960
|
if self.calentando:
|
|
1843
|
-
return False
|
|
1961
|
+
# Acá había un `return False` pelado, y eso MATABA el lazo: al
|
|
1962
|
+
# devolver False la fuente de GLib se quita, y como `self.reloj` ya
|
|
1963
|
+
# se soltó arriba, nadie la vuelve a armar. Una sola bandera pegada
|
|
1964
|
+
# dejaba al indicador sin volver a preguntarle al endpoint en lo que
|
|
1965
|
+
# le quedaba de vida — dibujando cada pocos minutos un número que no
|
|
1966
|
+
# se actualizaba nunca.
|
|
1967
|
+
#
|
|
1968
|
+
# Visto el 2026-09-13 después de una suspensión de 4,1 h: el proceso
|
|
1969
|
+
# vivo, estado.json reescrito hacía 4 minutos, y la cuota leída
|
|
1970
|
+
# hacía 5,2 horas.
|
|
1971
|
+
#
|
|
1972
|
+
# `calentando` sólo se apaga en el callback de wait_async. Si ese
|
|
1973
|
+
# callback no llega —y una suspensión en el medio es justo cuando no
|
|
1974
|
+
# llega— no hay nada más que lo apague. Así que además de
|
|
1975
|
+
# reprogramar, se le pone un plazo: pasado eso, el callback no viene
|
|
1976
|
+
# y la bandera se suelta.
|
|
1977
|
+
desde = self.calentando_desde
|
|
1978
|
+
if desde is not None and (GLib.get_monotonic_time() - desde) > CALENTADO_PLAZO_US:
|
|
1979
|
+
registrar("calentar.colgado", segundos=int((GLib.get_monotonic_time() - desde) / 1_000_000))
|
|
1980
|
+
self.calentando = False
|
|
1981
|
+
self.calentando_desde = None
|
|
1982
|
+
else:
|
|
1983
|
+
self.programar_calentado()
|
|
1984
|
+
return False
|
|
1844
1985
|
args = [self.qm, "--calentar"]
|
|
1845
1986
|
# Sólo las cuentas que se mueven: refrescar una que va al 9 % es gastar
|
|
1846
1987
|
# un pedido para confirmar que no pasó nada.
|
|
@@ -1856,11 +1997,13 @@ class Indicador:
|
|
|
1856
1997
|
self.programar_calentado()
|
|
1857
1998
|
return False
|
|
1858
1999
|
self.calentando = True
|
|
2000
|
+
self.calentando_desde = GLib.get_monotonic_time()
|
|
1859
2001
|
proc.wait_async(None, self._fin_calentado)
|
|
1860
2002
|
return False
|
|
1861
2003
|
|
|
1862
2004
|
def _fin_calentado(self, proc, resultado) -> None:
|
|
1863
2005
|
self.calentando = False
|
|
2006
|
+
self.calentando_desde = None
|
|
1864
2007
|
try:
|
|
1865
2008
|
proc.wait_finish(resultado)
|
|
1866
2009
|
except GLib.Error as e:
|
|
@@ -1882,6 +2025,12 @@ class Indicador:
|
|
|
1882
2025
|
# Dibujo ----------------------------------------------------------------
|
|
1883
2026
|
def refrescar(self) -> bool:
|
|
1884
2027
|
datos = self.leer()
|
|
2028
|
+
# `leer_qm` devuelve una FRASE cuando no pudo: se muestra en el menú y
|
|
2029
|
+
# hasta acá no quedaba escrita en ningún lado. Si qm falla a las tres de
|
|
2030
|
+
# la mañana, mañana no hay forma de saber por qué.
|
|
2031
|
+
if isinstance(datos, str) and datos != getattr(self, "_ultimo_fallo", None):
|
|
2032
|
+
registrar("qm.sin-datos", motivo=datos[:110])
|
|
2033
|
+
self._ultimo_fallo = datos if isinstance(datos, str) else None
|
|
1885
2034
|
self.datos = datos
|
|
1886
2035
|
for hijo in self.menu.get_children():
|
|
1887
2036
|
self.menu.remove(hijo)
|