@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/README.md +11 -7
- package/bin/qm-barra.swift +95 -2
- package/bin/qm-indicator +115 -6
- package/bin/qm-tray +10 -0
- package/bin/qm-tray.ps1 +154 -4
- package/bin/qm.mjs +25 -0
- package/dist/adapters/barra.js +129 -13
- package/dist/adapters/barra.js.map +1 -1
- package/dist/cli/qm.js +22 -9
- package/dist/cli/qm.js.map +1 -1
- package/dist/render/barras.js +19 -2
- package/dist/render/barras.js.map +1 -1
- package/extension/gnome43/quartermaster@legios/metadata.json +1 -1
- package/extension/quartermaster@legios/metadata.json +1 -1
- package/package.json +1 -1
- package/scripts/gate-lazo.py +396 -0
- package/scripts/hacer-cambios.mjs +0 -0
package/README.md
CHANGED
|
@@ -49,16 +49,18 @@ brew install legiosai/tap/quartermaster # macOS and Linux
|
|
|
49
49
|
npm install -g @legios/quartermaster # anywhere
|
|
50
50
|
```
|
|
51
51
|
|
|
52
|
-
**The bar item, on
|
|
53
|
-
|
|
52
|
+
**The bar item, on all three:** the first time you run `qm` in a terminal, it
|
|
53
|
+
asks once whether to put it in the bar and start it at every login — the menu
|
|
54
|
+
bar on macOS, the top bar on GNOME, the notification area on Windows. The
|
|
54
55
|
install itself can't: brew can't start anything from a formula, the `.deb` drops
|
|
55
|
-
the files and leaves,
|
|
56
|
-
|
|
57
|
-
quartermaster` on macOS, and
|
|
56
|
+
the files and leaves, npm's postinstall won't register anything either, and a
|
|
57
|
+
tool that reads OAuth tokens shouldn't register login agents nobody asked for.
|
|
58
|
+
Without the question: `brew services start quartermaster` on macOS, and
|
|
58
59
|
|
|
59
60
|
```sh
|
|
60
|
-
qm-indicator --instalar-extension # the item that opens the panel on click
|
|
61
|
+
qm-indicator --instalar-extension # Linux: the item that opens the panel on click
|
|
61
62
|
qm-indicator --instalar-arranque # and start it once: qm-indicator &
|
|
63
|
+
bin/qm-tray --instalar-arranque # Windows, from WSL: then run bin/qm-tray
|
|
62
64
|
```
|
|
63
65
|
|
|
64
66
|
Saying yes on Linux **also installs the GNOME extension**, which is what makes a
|
|
@@ -74,7 +76,9 @@ extension already in place, or a GNOME Shell to install ours into. Without those
|
|
|
74
76
|
the process would start anyway and nothing would appear up there, which is worse
|
|
75
77
|
than not offering. `qm --diagnostico` says which one is missing.
|
|
76
78
|
|
|
77
|
-
**Windows:**
|
|
79
|
+
**Windows:** `npm install -g @legios/quartermaster` inside WSL works too, and
|
|
80
|
+
the first `qm` asks the same question — the tray ships in the package. For a
|
|
81
|
+
native install without WSL, the installer from the [latest
|
|
78
82
|
release](https://github.com/legiosai/quartermaster/releases/latest). Per-user
|
|
79
83
|
and no UAC: it puts `qm` on your `PATH`, the tray in the Start menu, and — if
|
|
80
84
|
you leave the box ticked — the tray in startup.
|
package/bin/qm-barra.swift
CHANGED
|
@@ -31,6 +31,12 @@ import Foundation
|
|
|
31
31
|
let SEGUNDOS_SONDEO: TimeInterval = 300
|
|
32
32
|
// Coalescer escrituras: Claude Code reescribe .claude.json varias veces seguidas.
|
|
33
33
|
let DEBOUNCE: TimeInterval = 1.5
|
|
34
|
+
/// Cada cuánto mira el vigía, y a partir de qué atraso da la alarma. El plazo
|
|
35
|
+
/// son cuatro sondeos: con la cadencia en su techo, un calentado que no ocurrió
|
|
36
|
+
/// en veinte minutos no es lentitud, es que el lazo se cortó.
|
|
37
|
+
let VIGIA_SEGUNDOS: TimeInterval = 60
|
|
38
|
+
let VIGIA_PLAZO: TimeInterval = 20 * 60
|
|
39
|
+
|
|
34
40
|
/// Piso para cualquier cadencia que salga a la RED.
|
|
35
41
|
///
|
|
36
42
|
/// La primera versión bajaba a 20 s cuando una barra pasaba el 90 %, y como
|
|
@@ -876,6 +882,13 @@ final class Barra: NSObject, NSApplicationDelegate {
|
|
|
876
882
|
}
|
|
877
883
|
var pendiente: DispatchWorkItem?
|
|
878
884
|
var reloj: Timer?
|
|
885
|
+
/// Cuándo terminó el último calentado, y si el vigía ya avisó de este corte.
|
|
886
|
+
/// Es lo que mira `vigia`: la pregunta no es «¿está armado el timer?» —eso
|
|
887
|
+
/// se puede creer y estar equivocado— sino «¿cuándo fue la última vez que
|
|
888
|
+
/// de verdad le preguntamos al servidor?».
|
|
889
|
+
var calentadoEn: Date?
|
|
890
|
+
var vigiaAviso = false
|
|
891
|
+
var relojVigia: Timer?
|
|
879
892
|
/// Sin esto macOS le aplica App Nap —es una app sin ventanas— y los timers
|
|
880
893
|
/// se corren minutos. Medido: un sondeo de 5 min que no disparó en 7.
|
|
881
894
|
var actividad: NSObjectProtocol?
|
|
@@ -923,6 +936,7 @@ final class Barra: NSObject, NSApplicationDelegate {
|
|
|
923
936
|
options: [.userInitiated, .idleSystemSleepDisabled],
|
|
924
937
|
reason: "mirar la cuota a tiempo")
|
|
925
938
|
refrescar()
|
|
939
|
+
armarVigia()
|
|
926
940
|
calentarCodex()
|
|
927
941
|
}
|
|
928
942
|
|
|
@@ -946,9 +960,45 @@ final class Barra: NSObject, NSApplicationDelegate {
|
|
|
946
960
|
|
|
947
961
|
var minutosAlTecho: Double? = nil
|
|
948
962
|
|
|
949
|
-
|
|
963
|
+
/// Agenda el próximo calentado, y NUNCA lo aleja.
|
|
964
|
+
///
|
|
965
|
+
/// Esto se llama al final del armado del menú, y el menú se arma en cada
|
|
966
|
+
/// `refrescar()` — que acá lo dispara el vigía de archivos, y Claude Code
|
|
967
|
+
/// reescribe su .claude.json cada veinte segundos. Rearmar siempre
|
|
968
|
+
/// significaba correr la fecha del calentado con cada escritura ajena:
|
|
969
|
+
/// el calentado no llegaba a vencer nunca.
|
|
970
|
+
///
|
|
971
|
+
/// Del lado de GNOME, que tiene la misma forma con el sondeo periódico en
|
|
972
|
+
/// vez del vigía de archivos, pasó de verdad: medido el 2026-09-15, un solo
|
|
973
|
+
/// calentado al arrancar y siete horas y media sin ninguno, con la bandera
|
|
974
|
+
/// libre y un temporizador armado todo el tiempo —armado y reiniciado, que
|
|
975
|
+
/// es distinto de disparado—.
|
|
976
|
+
///
|
|
977
|
+
/// La regla es simple: una fecha más lejos que la que ya hay no reemplaza a
|
|
978
|
+
/// nada. Apretar la cadencia sigue andando, porque ésa siempre es más cerca.
|
|
979
|
+
func programar(forzando: Bool = false) {
|
|
980
|
+
let cuanto = cadencia()
|
|
981
|
+
let cuando = Date().addingTimeInterval(cuanto)
|
|
982
|
+
// `forzando` es para el vigía: cuando el calentado está parado, la fecha
|
|
983
|
+
// agendada YA VENCIÓ, así que cualquier fecha nueva es «más lejos» y la
|
|
984
|
+
// guarda la rechazaría. La defensa contra el hambre desactivaba a la
|
|
985
|
+
// defensa contra el silencio.
|
|
986
|
+
if let r = reloj, r.isValid {
|
|
987
|
+
if !forzando, cuando >= r.fireDate { return }
|
|
988
|
+
// Forzando también tiene un límite: sólo reemplaza un reloj cuya
|
|
989
|
+
// fecha YA PASÓ. El vigía corre cada minuto y, una vez que avisó,
|
|
990
|
+
// llamaba a esto con `forzando` en cada vuelta: cada llamada
|
|
991
|
+
// invalidaba el Timer de cinco minutos recién armado y ponía otro
|
|
992
|
+
// de cinco minutos. Un reloj que se reemplaza cada 60 s con uno de
|
|
993
|
+
// 300 s no dispara nunca. Medido el 2026-09-16: «lo rearmo» a las
|
|
994
|
+
// 13:57 del día anterior, y desde ahí veinte horas sin un solo
|
|
995
|
+
// calentado, con el proceso vivo, el token vigente desde las 09:32
|
|
996
|
+
// y el vigía «rearmando» en silencio cada minuto. La defensa
|
|
997
|
+
// contra el silencio se había vuelto la causa del silencio.
|
|
998
|
+
if forzando, r.fireDate > Date() { return }
|
|
999
|
+
}
|
|
950
1000
|
reloj?.invalidate()
|
|
951
|
-
let t = Timer(timeInterval:
|
|
1001
|
+
let t = Timer(timeInterval: cuanto, repeats: false) { _ in
|
|
952
1002
|
// Codex primero: su número no está en ningún disco hasta que
|
|
953
1003
|
// alguien lo pide, y el refresco de abajo lee del cache.
|
|
954
1004
|
self.calentarCodex()
|
|
@@ -960,6 +1010,47 @@ final class Barra: NSObject, NSApplicationDelegate {
|
|
|
960
1010
|
reloj = t
|
|
961
1011
|
}
|
|
962
1012
|
|
|
1013
|
+
/// Que el calentado no pueda dejar de ocurrir en silencio.
|
|
1014
|
+
///
|
|
1015
|
+
/// `programar()` arma un Timer de UNA sola vez, y el único lugar que lo
|
|
1016
|
+
/// vuelve a armar es el final del armado del menú. Cualquier corte en esa
|
|
1017
|
+
/// cadena apaga el calentado para toda la vida del proceso y sin ruido.
|
|
1018
|
+
///
|
|
1019
|
+
/// Pasó del lado de GNOME, que tiene la misma forma: el 2026-09-15, con
|
|
1020
|
+
/// 0.1.13, el indicador de Linux dejó de preguntarle al endpoint y estuvo
|
|
1021
|
+
/// siete horas y media sin escribir una línea, con el proceso vivo y el
|
|
1022
|
+
/// item redibujándose. Acá no se esperó a que pasara.
|
|
1023
|
+
///
|
|
1024
|
+
/// Esto mira desde afuera, se repite solo y no depende del calentado: si
|
|
1025
|
+
/// pasó el plazo sin una lectura, lo ANOTA una vez y lo rearma.
|
|
1026
|
+
func armarVigia() {
|
|
1027
|
+
// Con la hora de arranque y no en nil: si el PRIMER calentado nunca
|
|
1028
|
+
// termina, un vigía que espera a tener una marca no mira nunca.
|
|
1029
|
+
if calentadoEn == nil { calentadoEn = Date() }
|
|
1030
|
+
relojVigia?.invalidate()
|
|
1031
|
+
let t = Timer(timeInterval: VIGIA_SEGUNDOS, repeats: true) { [weak self] _ in
|
|
1032
|
+
self?.vigia()
|
|
1033
|
+
}
|
|
1034
|
+
t.tolerance = 0
|
|
1035
|
+
RunLoop.main.add(t, forMode: .common)
|
|
1036
|
+
relojVigia = t
|
|
1037
|
+
}
|
|
1038
|
+
|
|
1039
|
+
func vigia() {
|
|
1040
|
+
guard let desde = calentadoEn else { return }
|
|
1041
|
+
let atraso = Date().timeIntervalSince(desde)
|
|
1042
|
+
guard atraso > VIGIA_PLAZO else {
|
|
1043
|
+
vigiaAviso = false
|
|
1044
|
+
return
|
|
1045
|
+
}
|
|
1046
|
+
// Una vez por corte, no una por minuto: el log tiene que poder leerse.
|
|
1047
|
+
if !vigiaAviso {
|
|
1048
|
+
registrar("el calentado no ocurre hace \(duracion(Int(atraso))): lo rearmo")
|
|
1049
|
+
vigiaAviso = true
|
|
1050
|
+
}
|
|
1051
|
+
programar(forzando: true)
|
|
1052
|
+
}
|
|
1053
|
+
|
|
963
1054
|
/// Refresca las dos puntas —el endpoint de cada perfil de Claude y el de
|
|
964
1055
|
/// Codex— y deja los números en el cache de qm, para que las lecturas de la
|
|
965
1056
|
/// barra —que son `--breve`— sigan tardando milisegundos y encuentren algo
|
|
@@ -1017,6 +1108,8 @@ final class Barra: NSObject, NSApplicationDelegate {
|
|
|
1017
1108
|
self.motivosCalentado.insert(m)
|
|
1018
1109
|
registrar(m)
|
|
1019
1110
|
}
|
|
1111
|
+
self.calentadoEn = Date()
|
|
1112
|
+
self.vigiaAviso = false
|
|
1020
1113
|
self.refrescar()
|
|
1021
1114
|
}
|
|
1022
1115
|
}
|
package/bin/qm-indicator
CHANGED
|
@@ -65,6 +65,11 @@ ACTIVA_SEGUNDOS = 600
|
|
|
65
65
|
# es que su callback no va a llegar.
|
|
66
66
|
CALENTADO_PLAZO_US = 120 * 1_000_000
|
|
67
67
|
SEGUNDOS_SONDEO = 300
|
|
68
|
+
#: Cada cuánto mira el vigía, y a partir de qué atraso da la alarma. El plazo es
|
|
69
|
+
#: cuatro sondeos: con la cadencia en su techo de 300 s, un calentado que no
|
|
70
|
+
#: ocurrió en 20 minutos no es lentitud, es que el lazo se cortó.
|
|
71
|
+
VIGIA_SEGUNDOS = 60
|
|
72
|
+
VIGIA_PLAZO_US = 4 * SEGUNDOS_SONDEO * 1_000_000
|
|
68
73
|
# Piso para cualquier cadencia que salga a la RED. Claude Code pide la cuota del
|
|
69
74
|
# orden de una vez por sesión; un endpoint no documentado, que además puede
|
|
70
75
|
# desaparecer sin aviso, no es lugar para sondear más rápido que esto. Y la
|
|
@@ -1730,6 +1735,14 @@ class Indicador:
|
|
|
1730
1735
|
# y sólo las que se mueven, así que que un motivo no aparezca NO dice
|
|
1731
1736
|
# que se arregló.
|
|
1732
1737
|
self._motivos_calentado: set[str] = set()
|
|
1738
|
+
# Cuándo terminó el último calentado. Es lo que mira el vigía: la
|
|
1739
|
+
# pregunta no es «¿está armado el temporizador?» —eso se puede creer y
|
|
1740
|
+
# estar equivocado— sino «¿cuándo fue la última vez que de verdad le
|
|
1741
|
+
# preguntamos al servidor?».
|
|
1742
|
+
# Arranca con la hora de arranque y no en None: si el PRIMER calentado
|
|
1743
|
+
# nunca termina, un vigía que espera a tener una marca no mira nunca.
|
|
1744
|
+
self._ultimo_calentado: int | None = GLib.get_monotonic_time()
|
|
1745
|
+
self._vigia_avisado = False
|
|
1733
1746
|
self.reloj: int | None = None
|
|
1734
1747
|
self.proxima_lectura: int | None = None
|
|
1735
1748
|
self.turno = 0
|
|
@@ -1741,9 +1754,15 @@ class Indicador:
|
|
|
1741
1754
|
self.vigilar_extension()
|
|
1742
1755
|
self.vigilar_tema()
|
|
1743
1756
|
self.vigilar_version()
|
|
1744
|
-
|
|
1757
|
+
# Envuelto, y devolviendo True SIEMPRE. Un callback de GLib que tira
|
|
1758
|
+
# deja de devolver un valor verdadero y la fuente se QUITA: una sola
|
|
1759
|
+
# excepción en un refresco mataba el sondeo para siempre, y con él al
|
|
1760
|
+
# calentado, que se rearma desde acá. El envoltorio no arregla el error
|
|
1761
|
+
# —lo anota— pero no deja que se lleve puesto al lazo.
|
|
1762
|
+
GLib.timeout_add_seconds(SEGUNDOS_SONDEO, self._sondear)
|
|
1745
1763
|
self.programar_calentado(5)
|
|
1746
1764
|
self.vigilar_suspension()
|
|
1765
|
+
GLib.timeout_add_seconds(VIGIA_SEGUNDOS, self._vigia)
|
|
1747
1766
|
|
|
1748
1767
|
# Vigilancia de archivos ------------------------------------------------
|
|
1749
1768
|
def vigilar(self) -> None:
|
|
@@ -2073,11 +2092,39 @@ class Indicador:
|
|
|
2073
2092
|
seg = min(seg, 120)
|
|
2074
2093
|
return max(MINIMO_RED, seg)
|
|
2075
2094
|
|
|
2076
|
-
def programar_calentado(self, segundos: int | None = None) -> None:
|
|
2095
|
+
def programar_calentado(self, segundos: int | None = None, forzar: bool = False) -> None:
|
|
2096
|
+
"""Agenda el próximo calentado, y NUNCA lo aleja.
|
|
2097
|
+
|
|
2098
|
+
Acá estaba el hambre. Esto rearmaba siempre, y `refrescar()` lo llama en
|
|
2099
|
+
cada vuelta; el sondeo corre cada SEGUNDOS_SONDEO y `cadencia()` devuelve
|
|
2100
|
+
exactamente eso cuando no hay nada alto —el caso normal—. Los dos
|
|
2101
|
+
temporizadores quedaban empatados en 300 s y el del sondeo llegaba
|
|
2102
|
+
primero, así que cada sondeo reiniciaba la cuenta regresiva del
|
|
2103
|
+
calentado justo antes de que venciera. El calentado no ocurría NUNCA.
|
|
2104
|
+
|
|
2105
|
+
Medido el 2026-09-15 con 0.1.13: un solo calentado al arrancar y después
|
|
2106
|
+
siete horas y media sin ninguno, con `calentando` en False y un
|
|
2107
|
+
temporizador armado todo el tiempo —armado y reiniciado, que es distinto
|
|
2108
|
+
de disparado—. Y por eso forzar un `refrescar()` no lo revivía: volvía a
|
|
2109
|
+
correr la cuenta 300 s más allá.
|
|
2110
|
+
|
|
2111
|
+
La regla es simple: una fecha que está más lejos que la que ya hay no
|
|
2112
|
+
reemplaza a nada. Apretar la cadencia —que es para lo que existe volver
|
|
2113
|
+
a llamar— sigue funcionando, porque ésa siempre es más cerca.
|
|
2114
|
+
"""
|
|
2115
|
+
cuanto = self.cadencia() if segundos is None else segundos
|
|
2116
|
+
cuando = GLib.get_monotonic_time() + cuanto * 1_000_000
|
|
2117
|
+
# `forzar` es para el vigía, y no es un detalle: cuando el calentado está
|
|
2118
|
+
# parado, la fecha agendada YA VENCIÓ, así que cualquier fecha nueva es
|
|
2119
|
+
# «más lejos» y la guarda de arriba la rechazaría. La defensa contra el
|
|
2120
|
+
# hambre desactivaba a la defensa contra el silencio. Lo encontró el gate
|
|
2121
|
+
# corriendo el Swift, no leyéndolo.
|
|
2122
|
+
if (not forzar and self.reloj is not None and self.proxima_lectura is not None
|
|
2123
|
+
and cuando >= self.proxima_lectura):
|
|
2124
|
+
return
|
|
2077
2125
|
if self.reloj is not None:
|
|
2078
2126
|
GLib.source_remove(self.reloj)
|
|
2079
|
-
|
|
2080
|
-
self.proxima_lectura = GLib.get_monotonic_time() + cuanto * 1_000_000
|
|
2127
|
+
self.proxima_lectura = cuando
|
|
2081
2128
|
self.reloj = GLib.timeout_add_seconds(cuanto, self.calentar)
|
|
2082
2129
|
|
|
2083
2130
|
def falta_para_lectura(self) -> float | None:
|
|
@@ -2088,6 +2135,57 @@ class Indicador:
|
|
|
2088
2135
|
return 0.0
|
|
2089
2136
|
return max(0.0, (self.proxima_lectura - GLib.get_monotonic_time()) / 1_000_000)
|
|
2090
2137
|
|
|
2138
|
+
def _sondear(self) -> bool:
|
|
2139
|
+
"""El refresco periódico, que NUNCA puede sacarse su propia fuente."""
|
|
2140
|
+
try:
|
|
2141
|
+
self.refrescar()
|
|
2142
|
+
except Exception as e: # noqa: BLE001 — anotar y seguir, no morir callado
|
|
2143
|
+
registrar("sondeo.reventó", error=f"{type(e).__name__}: {e}"[:110])
|
|
2144
|
+
return True
|
|
2145
|
+
|
|
2146
|
+
def _vigia(self) -> bool:
|
|
2147
|
+
"""Que el calentado no pueda dejar de ocurrir en silencio.
|
|
2148
|
+
|
|
2149
|
+
El 2026-09-15, con 0.1.13, este indicador dejó de preguntarle al
|
|
2150
|
+
endpoint a las 02:35 y estuvo siete horas y media sin escribir una sola
|
|
2151
|
+
línea: el proceso vivo, `estado.json` reescrito hacía un minuto y la
|
|
2152
|
+
cuota de hacía siete horas. Forzar un `refrescar()` —que rearma el
|
|
2153
|
+
calentado— no lo revivió en diez minutos, con la cadencia en un techo de
|
|
2154
|
+
cinco. No fue la suspensión: BOOTTIME y MONOTONIC daban lo mismo.
|
|
2155
|
+
|
|
2156
|
+
La causa de fondo no es una línea, es la FORMA: el calentado se rearmaba
|
|
2157
|
+
desde un solo lugar —el final de `refrescar()`—, así que cualquier corte
|
|
2158
|
+
en esa cadena lo apagaba para toda la vida del proceso y sin ruido.
|
|
2159
|
+
|
|
2160
|
+
Esto lo mira desde afuera y no se puede quedar callado: es una fuente
|
|
2161
|
+
que devuelve True siempre, no depende del calentado ni del sondeo, y
|
|
2162
|
+
pregunta lo único que importa —cuánto hace que no le preguntamos al
|
|
2163
|
+
servidor—. Si se pasa del plazo, lo ANOTA y lo destraba.
|
|
2164
|
+
"""
|
|
2165
|
+
try:
|
|
2166
|
+
ahora = GLib.get_monotonic_time()
|
|
2167
|
+
desde = self._ultimo_calentado
|
|
2168
|
+
atraso = None if desde is None else ahora - desde
|
|
2169
|
+
if atraso is None or atraso <= VIGIA_PLAZO_US:
|
|
2170
|
+
self._vigia_avisado = False
|
|
2171
|
+
return True
|
|
2172
|
+
# Una vez por corte, no una por minuto: el log tiene que poder
|
|
2173
|
+
# leerse. Se vuelve a habilitar solo cuando el calentado vuelve.
|
|
2174
|
+
if not self._vigia_avisado:
|
|
2175
|
+
registrar("calentar.parado",
|
|
2176
|
+
hace=duracion(int(atraso / 1_000_000)),
|
|
2177
|
+
calentando=self.calentando,
|
|
2178
|
+
desde=self.calentando_desde is not None,
|
|
2179
|
+
reloj=self.reloj is not None)
|
|
2180
|
+
self._vigia_avisado = True
|
|
2181
|
+
# Y destrabarlo: la bandera pegada se suelta y se rearma ya.
|
|
2182
|
+
self.calentando = False
|
|
2183
|
+
self.calentando_desde = None
|
|
2184
|
+
self.programar_calentado(1, forzar=True)
|
|
2185
|
+
except Exception as e: # noqa: BLE001 — el vigía no puede ser lo que se cae
|
|
2186
|
+
registrar("vigia.reventó", error=f"{type(e).__name__}: {e}"[:110])
|
|
2187
|
+
return True
|
|
2188
|
+
|
|
2091
2189
|
def calentar(self) -> bool:
|
|
2092
2190
|
self.reloj = None
|
|
2093
2191
|
if self.calentando:
|
|
@@ -2107,9 +2205,18 @@ class Indicador:
|
|
|
2107
2205
|
# llega— no hay nada más que lo apague. Así que además de
|
|
2108
2206
|
# reprogramar, se le pone un plazo: pasado eso, el callback no viene
|
|
2109
2207
|
# y la bandera se suelta.
|
|
2208
|
+
# `desde` en None con `calentando` en True es un estado que el
|
|
2209
|
+
# código no debería poder producir —se ponen juntas— y por eso
|
|
2210
|
+
# mismo era el único silencio posible: con el `is not None` de
|
|
2211
|
+
# antes, ese caso caía al `else` y se rearmaba para siempre sin
|
|
2212
|
+
# anotar nada. Ahora una bandera sin instante se trata como lo que
|
|
2213
|
+
# es: pegada.
|
|
2110
2214
|
desde = self.calentando_desde
|
|
2111
|
-
|
|
2112
|
-
|
|
2215
|
+
pasado = desde is None or (GLib.get_monotonic_time() - desde) > CALENTADO_PLAZO_US
|
|
2216
|
+
if pasado:
|
|
2217
|
+
registrar("calentar.colgado",
|
|
2218
|
+
segundos=None if desde is None else int((GLib.get_monotonic_time() - desde) / 1_000_000),
|
|
2219
|
+
sin_instante=desde is None or None)
|
|
2113
2220
|
self.calentando = False
|
|
2114
2221
|
self.calentando_desde = None
|
|
2115
2222
|
else:
|
|
@@ -2176,6 +2283,8 @@ class Indicador:
|
|
|
2176
2283
|
fallo = f"salió {proc.get_exit_status()}"
|
|
2177
2284
|
if primera:
|
|
2178
2285
|
fallo += f": {primera[0][:110]}"
|
|
2286
|
+
self._ultimo_calentado = GLib.get_monotonic_time()
|
|
2287
|
+
self._vigia_avisado = False
|
|
2179
2288
|
self._anotar_calentado(fallo)
|
|
2180
2289
|
# Los motivos por cuenta van aunque el calentado haya salido 0: que una
|
|
2181
2290
|
# cuenta no se pueda calentar no hace fallar a las otras, y sin esto la
|
package/bin/qm-tray
CHANGED
|
@@ -35,6 +35,16 @@ GUION=$(wslpath -w "$AQUI/qm-tray.ps1")
|
|
|
35
35
|
# la misma razón: el arranque automático no pasa por el .bashrc del usuario.
|
|
36
36
|
QM=$(command -v qm 2>/dev/null || echo "$AQUI/qm")
|
|
37
37
|
|
|
38
|
+
# `--instalar-arranque` se traduce a la forma de PowerShell. La bandera se
|
|
39
|
+
# escribe igual en las tres plataformas —qm-barra, qm-indicator y ésta— para
|
|
40
|
+
# que el ofrecimiento de la primera corrida de `qm` no tenga que saber cuál
|
|
41
|
+
# está abajo; lo que cambia es que del otro lado del exec manda PowerShell, que
|
|
42
|
+
# nombra sus parámetros con un guion y en CamelCase.
|
|
43
|
+
if [ "${1-}" = "--instalar-arranque" ]; then
|
|
44
|
+
shift
|
|
45
|
+
set -- -InstalarArranque "$@"
|
|
46
|
+
fi
|
|
47
|
+
|
|
38
48
|
# -WindowStyle Hidden deja una consola parpadeando un instante al arrancar.
|
|
39
49
|
# Es el precio de no empaquetar un .exe, y pasa una sola vez por sesión.
|
|
40
50
|
exec powershell.exe -NoProfile -ExecutionPolicy Bypass -WindowStyle Hidden \
|
package/bin/qm-tray.ps1
CHANGED
|
@@ -101,12 +101,44 @@ param(
|
|
|
101
101
|
# El tema es una lectura del registro, y en un runner de CI no está el que
|
|
102
102
|
# uno quiere comprobar. En modo captura se fuerza a mano.
|
|
103
103
|
[switch]$Oscuro,
|
|
104
|
-
[switch]$Claro
|
|
104
|
+
[switch]$Claro,
|
|
105
|
+
|
|
106
|
+
# ── el arranque de sesión ─────────────────────────────────────────────
|
|
107
|
+
# Escribe el acceso directo en la carpeta de Inicio de Windows y sale. Es la
|
|
108
|
+
# misma bandera que `qm-barra --instalar-arranque` y `qm-indicator
|
|
109
|
+
# --instalar-arranque`, y existe para que quien ofrece la barra en la primera
|
|
110
|
+
# corrida de `qm` no tenga que saber qué hay abajo en cada plataforma.
|
|
111
|
+
#
|
|
112
|
+
# Va acá y no en el lanzador de WSL porque el acceso directo necesita la ruta
|
|
113
|
+
# de ESTE archivo en coordenadas de Windows, y este archivo la sabe sin
|
|
114
|
+
# traducir nada: `$PSCommandPath`. Del otro lado habría que pasarla por
|
|
115
|
+
# `wslpath` y volver a escaparla.
|
|
116
|
+
[switch]$InstalarArranque
|
|
105
117
|
)
|
|
106
118
|
|
|
107
119
|
Set-StrictMode -Version Latest
|
|
108
120
|
$ErrorActionPreference = 'Stop'
|
|
109
121
|
|
|
122
|
+
if ($InstalarArranque) {
|
|
123
|
+
$sh = New-Object -ComObject WScript.Shell
|
|
124
|
+
$lnk = $sh.CreateShortcut((Join-Path $sh.SpecialFolders('Startup') 'quartermaster.lnk'))
|
|
125
|
+
$lnk.TargetPath = 'powershell.exe'
|
|
126
|
+
# -QmLinux se conserva: el arranque de sesión no pasa por el .bashrc, así que
|
|
127
|
+
# sin esto la bandeja no encontraría el qm de adentro de WSL.
|
|
128
|
+
# Se llama $linea y no $args: $args es una variable automática de PowerShell
|
|
129
|
+
# y pisarla adentro de un script es pedir un bug que no se ve.
|
|
130
|
+
$linea = '-NoProfile -ExecutionPolicy Bypass -WindowStyle Hidden -File "' + $PSCommandPath + '"'
|
|
131
|
+
if ($QmLinux) { $linea += ' -QmLinux "' + $QmLinux + '"' }
|
|
132
|
+
if ($Iconos) { $linea += ' -Iconos "' + $Iconos + '"' }
|
|
133
|
+
$lnk.Arguments = $linea
|
|
134
|
+
# 7 es minimizado: sin esto parpadea una consola en cada inicio de sesión.
|
|
135
|
+
$lnk.WindowStyle = 7
|
|
136
|
+
$lnk.Description = 'quartermaster · cuota en la bandeja'
|
|
137
|
+
$lnk.Save()
|
|
138
|
+
Write-Host ('escrito: ' + $lnk.FullName)
|
|
139
|
+
exit 0
|
|
140
|
+
}
|
|
141
|
+
|
|
110
142
|
# ¿Pidieron explícitamente el qm de adentro de WSL? Se captura ACÁ, al nivel
|
|
111
143
|
# del script, y no adentro de ResolverQm: en una función $PSBoundParameters es
|
|
112
144
|
# el de la función, así que allá esta pregunta siempre daría «no».
|
|
@@ -570,6 +602,54 @@ function PctDiario($pre) {
|
|
|
570
602
|
# clave cambia sola y el mismo umbral puede volver a avisar. Sin eso, o
|
|
571
603
|
# spameás cada minuto o avisás una sola vez en la vida.
|
|
572
604
|
|
|
605
|
+
# ── el registro ────────────────────────────────────────────────────────
|
|
606
|
+
#
|
|
607
|
+
# De las tres barras, ésta era la única MUDA. La de macOS anota desde 0.1.8 y la
|
|
608
|
+
# de GNOME desde antes; acá, si se te caía la bandeja, no quedaba rastro: las
|
|
609
|
+
# frases de error viajaban al panel y se perdían al cerrarlo. Medido el
|
|
610
|
+
# 2026-09-15 contando escrituras a un log: macOS 12, GNOME 24, Windows 0.
|
|
611
|
+
#
|
|
612
|
+
# Y sirvió inmediatamente: del lado de GNOME el log es lo único que dejó ver que
|
|
613
|
+
# el calentado se había parado siete horas antes.
|
|
614
|
+
#
|
|
615
|
+
# Va a un archivo y no al Visor de eventos: escribir ahí pide permisos de
|
|
616
|
+
# administrador para registrar la fuente, y una herramienta por usuario que se
|
|
617
|
+
# instala sin UAC no los tiene. Se recorta pasando 1 MB, como el de macOS.
|
|
618
|
+
$script:RutaLog = Join-Path $env:LOCALAPPDATA 'quartermaster\bandeja.log'
|
|
619
|
+
$script:LogUltimo = @{}
|
|
620
|
+
# Si la última lectura de qm fue una frase y no un objeto: sirve para anotar la
|
|
621
|
+
# VUELTA, que sin ella toda falla queda abierta para siempre.
|
|
622
|
+
$script:QmFallaba = $false
|
|
623
|
+
|
|
624
|
+
function Registrar {
|
|
625
|
+
param([string]$Evento, [hashtable]$Datos, [switch]$SoloSiCambia)
|
|
626
|
+
try {
|
|
627
|
+
$extra = ''
|
|
628
|
+
if ($Datos) {
|
|
629
|
+
$extra = ' ' + (($Datos.GetEnumerator() | Sort-Object Name |
|
|
630
|
+
Where-Object { $null -ne $_.Value } |
|
|
631
|
+
ForEach-Object { "$($_.Key)=$($_.Value)" }) -join ' ')
|
|
632
|
+
}
|
|
633
|
+
$linea = "$Evento$extra"
|
|
634
|
+
# Lo que se repite cada minuto no se lee. Con -SoloSiCambia, un evento que
|
|
635
|
+
# dice lo mismo que la vez pasada no se vuelve a escribir.
|
|
636
|
+
if ($SoloSiCambia) {
|
|
637
|
+
if ($script:LogUltimo[$Evento] -eq $linea) { return }
|
|
638
|
+
$script:LogUltimo[$Evento] = $linea
|
|
639
|
+
}
|
|
640
|
+
$dir = Split-Path $script:RutaLog -Parent
|
|
641
|
+
if (-not (Test-Path $dir)) { New-Item -ItemType Directory -Path $dir -Force | Out-Null }
|
|
642
|
+
if ((Test-Path $script:RutaLog) -and (Get-Item $script:RutaLog).Length -gt 1MB) {
|
|
643
|
+
$cola = Get-Content $script:RutaLog -Tail 500 -Encoding UTF8
|
|
644
|
+
Set-Content $script:RutaLog -Value $cola -Encoding UTF8
|
|
645
|
+
}
|
|
646
|
+
Add-Content -Path $script:RutaLog -Encoding UTF8 `
|
|
647
|
+
-Value ("{0} {1}" -f (Get-Date -Format 'yyyy-MM-dd HH:mm:ss'), $linea)
|
|
648
|
+
} catch {
|
|
649
|
+
# Un registro que rompe a la bandeja es peor que no tener registro.
|
|
650
|
+
}
|
|
651
|
+
}
|
|
652
|
+
|
|
573
653
|
$script:RutaAvisos = Join-Path $env:LOCALAPPDATA 'quartermaster\avisados.json'
|
|
574
654
|
$script:Vistos = @{}
|
|
575
655
|
try {
|
|
@@ -1629,6 +1709,27 @@ function Leer {
|
|
|
1629
1709
|
try { return ($salida | ConvertFrom-Json) } catch { return 'qm no devolvió JSON' }
|
|
1630
1710
|
}
|
|
1631
1711
|
|
|
1712
|
+
# `Leer` devuelve un OBJETO cuando pudo y una FRASE cuando no. Esa frase se
|
|
1713
|
+
# mostraba en el panel y se perdía al cerrarlo: si qm fallaba a las tres de la
|
|
1714
|
+
# mañana, al otro día no había forma de saber por qué. Se anota el cambio, no
|
|
1715
|
+
# cada vuelta —una falla repetida cada minuto no se lee— y también la VUELTA,
|
|
1716
|
+
# porque sin ella toda falla queda abierta para siempre.
|
|
1717
|
+
function LeerAnotando {
|
|
1718
|
+
param([string]$argumentos)
|
|
1719
|
+
$r = Leer $argumentos
|
|
1720
|
+
if ($r -is [string]) {
|
|
1721
|
+
Registrar 'qm.sin-datos' @{ motivo = $r } -SoloSiCambia
|
|
1722
|
+
$script:QmFallaba = $true
|
|
1723
|
+
} else {
|
|
1724
|
+
if ($script:QmFallaba) {
|
|
1725
|
+
Registrar 'qm.volvio'
|
|
1726
|
+
$script:LogUltimo.Remove('qm.sin-datos')
|
|
1727
|
+
}
|
|
1728
|
+
$script:QmFallaba = $false
|
|
1729
|
+
}
|
|
1730
|
+
return $r
|
|
1731
|
+
}
|
|
1732
|
+
|
|
1632
1733
|
# Cada cuánto volver a preguntarle al endpoint.
|
|
1633
1734
|
#
|
|
1634
1735
|
# Un intervalo fijo de 5 minutos es inservible para una barra que sube rápido:
|
|
@@ -2373,7 +2474,7 @@ function ModeloPaneles($datos, [bool]$avisar) {
|
|
|
2373
2474
|
}
|
|
2374
2475
|
|
|
2375
2476
|
function Refrescar {
|
|
2376
|
-
$datos =
|
|
2477
|
+
$datos = LeerAnotando
|
|
2377
2478
|
# Los dos temas, que son dos claves distintas del registro y pueden no
|
|
2378
2479
|
# coincidir. Si el de las apps cambió, AplicarTema rehace la paleta y vuelve a
|
|
2379
2480
|
# vestir todos los menús; se redibujan igual acá abajo.
|
|
@@ -2668,7 +2769,7 @@ CrearFuentes
|
|
|
2668
2769
|
# -Panel elige cuál: 'general' (el de todas las cuentas) o el nombre corto de
|
|
2669
2770
|
# una, que es exactamente lo que muestra el ícono de esa cuenta.
|
|
2670
2771
|
function Capturar([string]$ruta, [string]$cual) {
|
|
2671
|
-
$datos =
|
|
2772
|
+
$datos = LeerAnotando
|
|
2672
2773
|
$m = ModeloPaneles $datos $false
|
|
2673
2774
|
if (-not $cual) { $cual = 'general' }
|
|
2674
2775
|
if (-not $m.paneles.Contains($cual)) {
|
|
@@ -2726,13 +2827,60 @@ $timer = New-Object System.Windows.Forms.Timer
|
|
|
2726
2827
|
$timer.Interval = $Segundos * 1000
|
|
2727
2828
|
# RevisarVersion va PRIMERO: si el archivo cambió, no tiene sentido gastar un
|
|
2728
2829
|
# calentado y un redibujo con el código viejo antes de saltar al nuevo.
|
|
2729
|
-
|
|
2830
|
+
# Envuelto: una excepción adentro de un Add_Tick de WinForms se lleva puesta a
|
|
2831
|
+
# la aplicación entera con un diálogo que nadie va a ver, y la bandeja
|
|
2832
|
+
# desaparece sin dejar nada escrito. Anotarla y seguir es siempre mejor.
|
|
2833
|
+
$timer.Add_Tick({
|
|
2834
|
+
try {
|
|
2835
|
+
RevisarVersion
|
|
2836
|
+
$null = Calentar
|
|
2837
|
+
$script:CalentadoEn = Get-Date
|
|
2838
|
+
Refrescar
|
|
2839
|
+
} catch {
|
|
2840
|
+
Registrar 'tick.reventó' @{ error = $_.Exception.Message } -SoloSiCambia
|
|
2841
|
+
}
|
|
2842
|
+
})
|
|
2730
2843
|
$timer.Start()
|
|
2731
2844
|
|
|
2845
|
+
# El vigía, por lo mismo que en GNOME y en macOS: que el calentado no pueda
|
|
2846
|
+
# dejar de ocurrir en silencio. Acá el riesgo es distinto —el Timer de WinForms
|
|
2847
|
+
# se repite solo, no hay un rearme único que se pueda cortar— pero la pregunta
|
|
2848
|
+
# que contesta es la misma: ¿cuánto hace que no le preguntamos al servidor?
|
|
2849
|
+
$script:CalentadoEn = Get-Date
|
|
2850
|
+
$script:VigiaAviso = $false
|
|
2851
|
+
$script:Vigia = New-Object System.Windows.Forms.Timer
|
|
2852
|
+
$script:Vigia.Interval = 60000
|
|
2853
|
+
$script:Vigia.Add_Tick({
|
|
2854
|
+
try {
|
|
2855
|
+
$atraso = (Get-Date) - $script:CalentadoEn
|
|
2856
|
+
if ($atraso.TotalSeconds -le (4 * $Segundos)) { $script:VigiaAviso = $false; return }
|
|
2857
|
+
if (-not $script:VigiaAviso) {
|
|
2858
|
+
Registrar 'calentar.parado' @{ hace = [int]$atraso.TotalSeconds }
|
|
2859
|
+
$script:VigiaAviso = $true
|
|
2860
|
+
}
|
|
2861
|
+
$null = Calentar
|
|
2862
|
+
$script:CalentadoEn = Get-Date
|
|
2863
|
+
Refrescar
|
|
2864
|
+
} catch {
|
|
2865
|
+
Registrar 'vigia.reventó' @{ error = $_.Exception.Message } -SoloSiCambia
|
|
2866
|
+
}
|
|
2867
|
+
})
|
|
2868
|
+
$script:Vigia.Start()
|
|
2869
|
+
|
|
2732
2870
|
$script:Latido = New-Object System.Windows.Forms.Timer
|
|
2733
2871
|
$script:Latido.Interval = 1000
|
|
2734
2872
|
$script:Latido.Add_Tick({ LatirPie })
|
|
2735
2873
|
|
|
2874
|
+
# Qué arrancó: con qué qm —puede ser el nativo o el de adentro de WSL, y esa
|
|
2875
|
+
# elección decide si hay números o no hay nada—, con qué cadencia y con qué pid.
|
|
2876
|
+
$script:QmDeArranque = ResolverQm
|
|
2877
|
+
Registrar 'arranca' @{
|
|
2878
|
+
modo = $script:QmDeArranque.Modo
|
|
2879
|
+
qm = $script:QmDeArranque.Qm
|
|
2880
|
+
cadencia = $Segundos
|
|
2881
|
+
pid = $PID
|
|
2882
|
+
}
|
|
2883
|
+
|
|
2736
2884
|
$null = Calentar
|
|
2737
2885
|
Refrescar
|
|
2738
2886
|
|
|
@@ -2740,6 +2888,8 @@ try {
|
|
|
2740
2888
|
[System.Windows.Forms.Application]::Run($script:Ctx)
|
|
2741
2889
|
} finally {
|
|
2742
2890
|
$timer.Stop()
|
|
2891
|
+
$script:Vigia.Stop()
|
|
2892
|
+
Registrar 'sale'
|
|
2743
2893
|
$script:Latido.Stop()
|
|
2744
2894
|
GuardarPrevios
|
|
2745
2895
|
foreach ($ni in @($script:Bandeja.Values)) {
|
package/bin/qm.mjs
CHANGED
|
@@ -43,6 +43,31 @@ const compilado = join(RAIZ, 'dist', 'cli', 'qm.js');
|
|
|
43
43
|
const fuente = join(RAIZ, 'src', 'cli', 'qm.ts');
|
|
44
44
|
|
|
45
45
|
if (sirveEsteNode() && existsSync(compilado)) {
|
|
46
|
+
// `src/adapters/opencode.ts` usa node:sqlite, que es experimental, así que
|
|
47
|
+
// Node escribe dos renglones en stderr en cada corrida:
|
|
48
|
+
//
|
|
49
|
+
// (node:56893) ExperimentalWarning: SQLite is an experimental feature…
|
|
50
|
+
// (Use `node --trace-warnings ...` to show where the warning was created)
|
|
51
|
+
//
|
|
52
|
+
// Eso no es de qm y no es para quien lo corre, pero sale por el mismo canal
|
|
53
|
+
// por el que qm explica: `qm --calentar` dice por ahí por qué una cuenta no
|
|
54
|
+
// se calentó, y las tres barras anotan esos renglones en su log. Medido el
|
|
55
|
+
// 2026-09-15: el journal del indicador de GNOME quedaba con dos warnings por
|
|
56
|
+
// cada pid de node y el motivo de verdad enterrado entre ellos.
|
|
57
|
+
//
|
|
58
|
+
// El lanzador de shell lo apaga con --disable-warning, pero por ACÁ no pasa:
|
|
59
|
+
// cuando el Node que corre sirve, el CLI se importa en este mismo proceso, y
|
|
60
|
+
// este proceso lo arrancó npm sin banderas. Así que se filtra a mano.
|
|
61
|
+
//
|
|
62
|
+
// Se saca SÓLO esa clase: el manejador de siempre se guarda y se le sigue
|
|
63
|
+
// pasando todo lo demás, para que una deprecación de verdad no se pierda.
|
|
64
|
+
const porDefecto = process.listeners('warning')[0];
|
|
65
|
+
process.removeAllListeners('warning');
|
|
66
|
+
process.on('warning', (w) => {
|
|
67
|
+
if (w.name === 'ExperimentalWarning') return;
|
|
68
|
+
if (porDefecto) porDefecto(w);
|
|
69
|
+
else console.error(w.stack ?? String(w));
|
|
70
|
+
});
|
|
46
71
|
// El CLI hace su trabajo al importarse y maneja su propio código de salida.
|
|
47
72
|
await import(pathToFileURL(compilado).href);
|
|
48
73
|
} else {
|