@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
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(
|
|
901
|
-
|
|
902
|
-
|
|
903
|
-
|
|
904
|
-
|
|
905
|
-
|
|
906
|
-
|
|
907
|
-
|
|
908
|
-
|
|
909
|
-
|
|
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
|
-
|
|
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
|
-
|
|
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
|
-
|
|
1024
|
-
|
|
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(
|
|
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
|
-
|
|
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
|
-
|
|
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
|
-
|
|
2073
|
-
|
|
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
|
-
|
|
2297
|
-
|
|
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
|
-
|
|
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
|
-
|
|
2515
|
-
|
|
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(
|
|
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 \
|