@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/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
@@ -690,6 +695,14 @@ class VistaCuenta:
690
695
  + (" · viejo" if edad >= VIEJO_SEGUNDOS else ""))
691
696
  self.lecturas = "lecturas: " + " · ".join(partes) if partes else None
692
697
 
698
+ # Por qué esta cuenta quedó al fondo y no encabeza. El núcleo ya lo
699
+ # resolvió y lo escribió en palabras; acá sólo se dibuja. Una cuenta
700
+ # que cambia de lugar sin decir por qué es indistinguible de un bug.
701
+ rel = p.get("relevancia") or {}
702
+ self.dormida = None
703
+ if rel.get("dormida"):
704
+ self.dormida = "dormida: " + " · ".join(rel.get("porque") or [])
705
+
693
706
  @staticmethod
694
707
  def _ancho_contenido() -> float:
695
708
  return ANCHO_PANEL - 2 * MARGEN - 2 * PAD_TARJETA
@@ -708,6 +721,8 @@ class VistaCuenta:
708
721
  alto += 4 + 16 * len(self.presupuesto)
709
722
  if self.lecturas:
710
723
  alto += 17
724
+ if self.dormida:
725
+ alto += 17
711
726
  return alto + PAD_TARJETA - 4
712
727
 
713
728
  def _curva(self, cr, pluma, caja, color) -> None:
@@ -831,6 +846,11 @@ class VistaCuenta:
831
846
  if not self.ritmo and not self.presupuesto:
832
847
  y += 4
833
848
  pluma.escribir(ix, y, self.lecturas, 10.5, TEMA.terciario, ancho=ancho, elipsis=True)
849
+ y += 17
850
+ if self.dormida:
851
+ if not self.ritmo and not self.presupuesto and not self.lecturas:
852
+ y += 4
853
+ pluma.escribir(ix, y, self.dormida, 10.5, TEMA.terciario, ancho=ancho, elipsis=True)
834
854
  return arriba + alto
835
855
 
836
856
 
@@ -897,21 +917,33 @@ class VistaResumen:
897
917
  self.nivel, self.reinicia = nivel, reinicia
898
918
 
899
919
  @staticmethod
900
- def desde(perfiles: list) -> "VistaResumen | None":
901
- mejor = None
902
- for p in perfiles:
903
- cuota = p.get("cuota") or {}
904
- if cuota.get("estado") != "ok":
905
- continue
906
- v = cuota.get("frena")
907
- if v and (mejor is None or v["porcentaje"] > mejor[1]["porcentaje"]):
908
- mejor = (p, v)
909
- if mejor is None:
920
+ def desde(datos: dict) -> "VistaResumen | None":
921
+ """Lee quién encabeza del JSON. NO lo vuelve a decidir.
922
+
923
+ Acá adentro había un `for` que se quedaba con el `frena` de porcentaje
924
+ más alto. Decía lo mismo que el CLI sólo por casualidad, y dejó de
925
+ decirlo el día que el criterio cambió: una cuenta dormida en 100 % ya no
926
+ encabeza, y esta copia no se había enterado. La misma elección estaba
927
+ escrita seis veces, una por pantalla.
928
+
929
+ CONTRIBUTING.md lo dice así: una regla que un renderer tiene que
930
+ reimplementar es un bug del CLI. Ahora el CLI la emite en
931
+ `frenaPrimero` y esto sólo la busca.
932
+ """
933
+ lider = datos.get("frenaPrimero")
934
+ if not lider:
935
+ return None
936
+ v = lider.get("ventana")
937
+ if not v:
910
938
  return None
911
- p, v = mejor
939
+ # El perfil completo, para la proyección. Si no aparece —no debería—
940
+ # igual se dibuja la cabecera con lo que vino.
941
+ p = next((x for x in datos.get("perfiles", [])
942
+ if x.get("perfil") == lider.get("perfil")), {})
912
943
  proy = p.get("proyeccion")
913
944
  choca = bool(proy and proy.get("estado") == "sube" and proy.get("chocasAntesDelReinicio"))
914
- return VistaResumen(corto(p.get("perfil") or "?"), nombre_ventana(v), v["porcentaje"],
945
+ nombre = p.get("perfil") or lider.get("perfil") or "?"
946
+ return VistaResumen(corto(nombre), nombre_ventana(v), v["porcentaje"],
915
947
  nivel_de(v["porcentaje"], v.get("preocupa", False) or choca),
916
948
  v.get("reinicia"))
917
949
 
@@ -1019,9 +1051,15 @@ def piezas_de(datos, avisar=None) -> list[dict]:
1019
1051
  continue
1020
1052
  proy = p.get("proyeccion")
1021
1053
  chocas = bool(proy and proy["estado"] == "sube" and proy["chocasAntesDelReinicio"])
1022
-
1023
- def alerta(v, _frena=frena, _chocas=chocas) -> bool:
1024
- if not v:
1054
+ # Una cuenta dormida no alarma. El `!` del item y la notificación de
1055
+ # escritorio existen para avisarte de algo que te va a frenar; una
1056
+ # cuenta que nadie usa, en 100 % desde hace semanas, no te frena nada y
1057
+ # el aviso es puro ruido — el mismo ruido que hizo que alguien quisiera
1058
+ # esconderla, que es lo que este repo no quiere que haga falta.
1059
+ dormida = bool((p.get("relevancia") or {}).get("dormida"))
1060
+
1061
+ def alerta(v, _frena=frena, _chocas=chocas, _dormida=dormida) -> bool:
1062
+ if not v or _dormida:
1025
1063
  return False
1026
1064
  return bool(v.get("preocupa")) or (_chocas and v.get("clave") == _frena.get("clave"))
1027
1065
 
@@ -1050,9 +1088,15 @@ def piezas_de(datos, avisar=None) -> list[dict]:
1050
1088
  "ultimo_uso": p.get("ultimoUso"),
1051
1089
  "viejo": (cuota.get("edadSegundos") or 0) >= VIEJO_SEGUNDOS,
1052
1090
  })
1053
- if avisar is not None:
1091
+ if avisar is not None and not dormida:
1054
1092
  # Todas las barras, no sólo la que frena: la semanal puede estar
1055
1093
  # tranquila mientras la de sesión te para, y al revés.
1094
+ #
1095
+ # Salvo si la cuenta está dormida. Una notificación de escritorio
1096
+ # que dice «codex llegó al 95 %» por una cuenta free que nadie toca
1097
+ # hace semanas no avisa de nada: interrumpe. Es el mismo ruido que
1098
+ # hace que alguien termine escondiendo la cuenta, y esconderla es lo
1099
+ # que este cambio existe para que no haga falta.
1056
1100
  avisar(nombre, cuota.get("mostrar") or [], frena, proy, chocas)
1057
1101
  return piezas
1058
1102
 
@@ -1165,7 +1209,7 @@ def modelo_panel(datos):
1165
1209
  i += 1
1166
1210
  if calladas:
1167
1211
  vistas.append(VistaSinCuota(calladas))
1168
- return VistaResumen.desde(perfiles), vistas
1212
+ return VistaResumen.desde(datos), vistas
1169
1213
 
1170
1214
 
1171
1215
  def _pluma_de_medir() -> Pluma:
@@ -1691,6 +1735,14 @@ class Indicador:
1691
1735
  # y sólo las que se mueven, así que que un motivo no aparezca NO dice
1692
1736
  # que se arregló.
1693
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
1694
1746
  self.reloj: int | None = None
1695
1747
  self.proxima_lectura: int | None = None
1696
1748
  self.turno = 0
@@ -1702,9 +1754,15 @@ class Indicador:
1702
1754
  self.vigilar_extension()
1703
1755
  self.vigilar_tema()
1704
1756
  self.vigilar_version()
1705
- GLib.timeout_add_seconds(SEGUNDOS_SONDEO, self.refrescar)
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)
1706
1763
  self.programar_calentado(5)
1707
1764
  self.vigilar_suspension()
1765
+ GLib.timeout_add_seconds(VIGIA_SEGUNDOS, self._vigia)
1708
1766
 
1709
1767
  # Vigilancia de archivos ------------------------------------------------
1710
1768
  def vigilar(self) -> None:
@@ -2034,11 +2092,39 @@ class Indicador:
2034
2092
  seg = min(seg, 120)
2035
2093
  return max(MINIMO_RED, seg)
2036
2094
 
2037
- 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
2038
2125
  if self.reloj is not None:
2039
2126
  GLib.source_remove(self.reloj)
2040
- cuanto = self.cadencia() if segundos is None else segundos
2041
- self.proxima_lectura = GLib.get_monotonic_time() + cuanto * 1_000_000
2127
+ self.proxima_lectura = cuando
2042
2128
  self.reloj = GLib.timeout_add_seconds(cuanto, self.calentar)
2043
2129
 
2044
2130
  def falta_para_lectura(self) -> float | None:
@@ -2049,6 +2135,57 @@ class Indicador:
2049
2135
  return 0.0
2050
2136
  return max(0.0, (self.proxima_lectura - GLib.get_monotonic_time()) / 1_000_000)
2051
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
+
2052
2189
  def calentar(self) -> bool:
2053
2190
  self.reloj = None
2054
2191
  if self.calentando:
@@ -2068,9 +2205,18 @@ class Indicador:
2068
2205
  # llega— no hay nada más que lo apague. Así que además de
2069
2206
  # reprogramar, se le pone un plazo: pasado eso, el callback no viene
2070
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.
2071
2214
  desde = self.calentando_desde
2072
- if desde is not None and (GLib.get_monotonic_time() - desde) > CALENTADO_PLAZO_US:
2073
- registrar("calentar.colgado", segundos=int((GLib.get_monotonic_time() - desde) / 1_000_000))
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)
2074
2220
  self.calentando = False
2075
2221
  self.calentando_desde = None
2076
2222
  else:
@@ -2137,6 +2283,8 @@ class Indicador:
2137
2283
  fallo = f"salió {proc.get_exit_status()}"
2138
2284
  if primera:
2139
2285
  fallo += f": {primera[0][:110]}"
2286
+ self._ultimo_calentado = GLib.get_monotonic_time()
2287
+ self._vigia_avisado = False
2140
2288
  self._anotar_calentado(fallo)
2141
2289
  # Los motivos por cuenta van aunque el calentado haya salido 0: que una
2142
2290
  # cuenta no se pueda calentar no hace fallar a las otras, y sin esto la
@@ -2293,8 +2441,12 @@ class Indicador:
2293
2441
  # El nombre alterna igual que el del item: el shell cachea la
2294
2442
  # textura por ruta y si no, muestra el panel de hace un rato.
2295
2443
  destino = self.iconos / f"panel-{self.turno}.png"
2296
- alto = capturar(self.datos, str(destino), self.falta_para_lectura())
2297
- panel = {"panel": str(destino), "panelAncho": ANCHO_PANEL, "panelAlto": alto}
2444
+ # Un nombre propio, y no `alto` otra vez: pisar el parámetro dejaba
2445
+ # escrito que el ICONO de la barra medía lo que mide el PANEL —
2446
+ # 576 px de alto para un dibujo de 22. La extensión le cree al
2447
+ # archivo y arma el item de ese tamaño.
2448
+ alto_panel = capturar(self.datos, str(destino), self.falta_para_lectura())
2449
+ panel = {"panel": str(destino), "panelAncho": ANCHO_PANEL, "panelAlto": alto_panel}
2298
2450
  except (OSError, MemoryError):
2299
2451
  pass # sin panel dibujado la extensión sigue mostrando el item
2300
2452
  try:
@@ -2479,7 +2631,44 @@ EXTENSION_UUID = "quartermaster@legios"
2479
2631
  EXTENSIONES = Path(os.environ.get("XDG_DATA_HOME", str(Path.home() / ".local/share"))) \
2480
2632
  / "gnome-shell" / "extensions"
2481
2633
  #: De dónde sale la extensión: al lado del paquete, sea un clone, el .deb o npm.
2482
- EXTENSION_FUENTE = YO.parent.parent / "extension" / EXTENSION_UUID
2634
+ EXTENSION_RAIZ = YO.parent.parent / "extension"
2635
+
2636
+
2637
+ def fuente_extension() -> Path:
2638
+ """Cuál de las dos copias de la extensión corresponde a este GNOME.
2639
+
2640
+ GNOME 45 cambió la forma de cargar extensiones —módulos ESM y una clase que
2641
+ extiende Extension— y la 43 y la 44 usan `imports.gi` con una función
2642
+ `init()` suelta. No son dos sintaxis que convivan en un archivo, así que el
2643
+ mismo item vive dos veces y acá se elige.
2644
+
2645
+ Importa en Debian 12, que trae la 43 y va a seguir soportada años. Instalar
2646
+ ahí la de 45 deja la extensión en ERROR, el item cae al camino de
2647
+ AppIndicator, y entonces pasan las dos cosas que esta extensión existe para
2648
+ evitar: el medidor entra en una casilla cuadrada de 16 px y se ve minúsculo,
2649
+ y el click se lo queda el menú del shell, que le rompe el agarre al menú de
2650
+ GTK — el panel aparece y desaparece en el mismo instante.
2651
+
2652
+ Se pregunta acá y no en el Makefile porque quien instaló por npm o por apt
2653
+ no tiene un Makefile, que es la misma razón por la que la instalación entera
2654
+ se mudó a este archivo. Sin poder saber la versión se elige la nueva, que es
2655
+ la que corresponde a todo lo que no sea Debian estable.
2656
+ """
2657
+ vieja = EXTENSION_RAIZ / "gnome43" / EXTENSION_UUID
2658
+ if _shell_es_vieja() and vieja.is_dir():
2659
+ return vieja
2660
+ return EXTENSION_RAIZ / EXTENSION_UUID
2661
+
2662
+
2663
+ def _shell_es_vieja() -> bool:
2664
+ """GNOME 44 o anterior. False si no se puede saber."""
2665
+ try:
2666
+ dicho = subprocess.run(["gnome-shell", "--version"], capture_output=True,
2667
+ text=True, timeout=5, check=True).stdout
2668
+ except (OSError, subprocess.SubprocessError):
2669
+ return False
2670
+ numeros = "".join(c if c.isdigit() else " " for c in dicho).split()
2671
+ return bool(numeros) and int(numeros[0]) <= 44
2483
2672
 
2484
2673
 
2485
2674
  def _habilitadas() -> list[str] | None:
@@ -2511,15 +2700,16 @@ def instalar_extension() -> int:
2511
2700
  esconder: decir «listo» de algo que no se ve hasta cerrar sesión es
2512
2701
  exactamente la mentira que este programa no comete.
2513
2702
  """
2514
- if not EXTENSION_FUENTE.is_dir():
2515
- print(f"no encuentro la extensión en {EXTENSION_FUENTE}", file=sys.stderr)
2703
+ fuente = fuente_extension()
2704
+ if not fuente.is_dir():
2705
+ print(f"no encuentro la extensión en {fuente}", file=sys.stderr)
2516
2706
  return 1
2517
2707
  destino = EXTENSIONES / EXTENSION_UUID
2518
2708
  try:
2519
2709
  EXTENSIONES.mkdir(parents=True, exist_ok=True)
2520
2710
  if destino.exists():
2521
2711
  shutil.rmtree(destino)
2522
- shutil.copytree(EXTENSION_FUENTE, destino)
2712
+ shutil.copytree(fuente, destino)
2523
2713
  except OSError as e:
2524
2714
  print(f"no pude copiarla a {destino}: {e}", file=sys.stderr)
2525
2715
  return 1
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 \