@legios/quartermaster 0.1.11 → 0.1.13
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 +41 -12
- package/bin/qm +60 -12
- package/bin/qm-barra.swift +61 -23
- package/bin/qm-indicator +335 -27
- package/bin/qm-tray.ps1 +345 -57
- package/dist/adapters/barra.js +142 -31
- 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/extension.js +257 -0
- package/extension/quartermaster@legios/metadata.json +8 -0
- package/extension/quartermaster@legios/stylesheet.css +10 -0
- package/package.json +4 -2
- package/scripts/bumpear.mjs +9 -0
- package/scripts/gate-bandeja.ps1 +267 -19
- package/scripts/gate-presupuesto.py +433 -0
- package/scripts/gate-tarjetas.py +46 -1
- package/scripts/hacer-deb.sh +10 -1
- package/scripts/mandar-pr-winget.mjs +106 -21
- package/src/render/tablero.html +19 -11
package/bin/qm-indicator
CHANGED
|
@@ -690,6 +690,14 @@ class VistaCuenta:
|
|
|
690
690
|
+ (" · viejo" if edad >= VIEJO_SEGUNDOS else ""))
|
|
691
691
|
self.lecturas = "lecturas: " + " · ".join(partes) if partes else None
|
|
692
692
|
|
|
693
|
+
# Por qué esta cuenta quedó al fondo y no encabeza. El núcleo ya lo
|
|
694
|
+
# resolvió y lo escribió en palabras; acá sólo se dibuja. Una cuenta
|
|
695
|
+
# que cambia de lugar sin decir por qué es indistinguible de un bug.
|
|
696
|
+
rel = p.get("relevancia") or {}
|
|
697
|
+
self.dormida = None
|
|
698
|
+
if rel.get("dormida"):
|
|
699
|
+
self.dormida = "dormida: " + " · ".join(rel.get("porque") or [])
|
|
700
|
+
|
|
693
701
|
@staticmethod
|
|
694
702
|
def _ancho_contenido() -> float:
|
|
695
703
|
return ANCHO_PANEL - 2 * MARGEN - 2 * PAD_TARJETA
|
|
@@ -708,6 +716,8 @@ class VistaCuenta:
|
|
|
708
716
|
alto += 4 + 16 * len(self.presupuesto)
|
|
709
717
|
if self.lecturas:
|
|
710
718
|
alto += 17
|
|
719
|
+
if self.dormida:
|
|
720
|
+
alto += 17
|
|
711
721
|
return alto + PAD_TARJETA - 4
|
|
712
722
|
|
|
713
723
|
def _curva(self, cr, pluma, caja, color) -> None:
|
|
@@ -831,6 +841,11 @@ class VistaCuenta:
|
|
|
831
841
|
if not self.ritmo and not self.presupuesto:
|
|
832
842
|
y += 4
|
|
833
843
|
pluma.escribir(ix, y, self.lecturas, 10.5, TEMA.terciario, ancho=ancho, elipsis=True)
|
|
844
|
+
y += 17
|
|
845
|
+
if self.dormida:
|
|
846
|
+
if not self.ritmo and not self.presupuesto and not self.lecturas:
|
|
847
|
+
y += 4
|
|
848
|
+
pluma.escribir(ix, y, self.dormida, 10.5, TEMA.terciario, ancho=ancho, elipsis=True)
|
|
834
849
|
return arriba + alto
|
|
835
850
|
|
|
836
851
|
|
|
@@ -897,21 +912,33 @@ class VistaResumen:
|
|
|
897
912
|
self.nivel, self.reinicia = nivel, reinicia
|
|
898
913
|
|
|
899
914
|
@staticmethod
|
|
900
|
-
def desde(
|
|
901
|
-
|
|
902
|
-
|
|
903
|
-
|
|
904
|
-
|
|
905
|
-
|
|
906
|
-
|
|
907
|
-
|
|
908
|
-
|
|
909
|
-
|
|
915
|
+
def desde(datos: dict) -> "VistaResumen | None":
|
|
916
|
+
"""Lee quién encabeza del JSON. NO lo vuelve a decidir.
|
|
917
|
+
|
|
918
|
+
Acá adentro había un `for` que se quedaba con el `frena` de porcentaje
|
|
919
|
+
más alto. Decía lo mismo que el CLI sólo por casualidad, y dejó de
|
|
920
|
+
decirlo el día que el criterio cambió: una cuenta dormida en 100 % ya no
|
|
921
|
+
encabeza, y esta copia no se había enterado. La misma elección estaba
|
|
922
|
+
escrita seis veces, una por pantalla.
|
|
923
|
+
|
|
924
|
+
CONTRIBUTING.md lo dice así: una regla que un renderer tiene que
|
|
925
|
+
reimplementar es un bug del CLI. Ahora el CLI la emite en
|
|
926
|
+
`frenaPrimero` y esto sólo la busca.
|
|
927
|
+
"""
|
|
928
|
+
lider = datos.get("frenaPrimero")
|
|
929
|
+
if not lider:
|
|
930
|
+
return None
|
|
931
|
+
v = lider.get("ventana")
|
|
932
|
+
if not v:
|
|
910
933
|
return None
|
|
911
|
-
|
|
934
|
+
# El perfil completo, para la proyección. Si no aparece —no debería—
|
|
935
|
+
# igual se dibuja la cabecera con lo que vino.
|
|
936
|
+
p = next((x for x in datos.get("perfiles", [])
|
|
937
|
+
if x.get("perfil") == lider.get("perfil")), {})
|
|
912
938
|
proy = p.get("proyeccion")
|
|
913
939
|
choca = bool(proy and proy.get("estado") == "sube" and proy.get("chocasAntesDelReinicio"))
|
|
914
|
-
|
|
940
|
+
nombre = p.get("perfil") or lider.get("perfil") or "?"
|
|
941
|
+
return VistaResumen(corto(nombre), nombre_ventana(v), v["porcentaje"],
|
|
915
942
|
nivel_de(v["porcentaje"], v.get("preocupa", False) or choca),
|
|
916
943
|
v.get("reinicia"))
|
|
917
944
|
|
|
@@ -1019,9 +1046,15 @@ def piezas_de(datos, avisar=None) -> list[dict]:
|
|
|
1019
1046
|
continue
|
|
1020
1047
|
proy = p.get("proyeccion")
|
|
1021
1048
|
chocas = bool(proy and proy["estado"] == "sube" and proy["chocasAntesDelReinicio"])
|
|
1022
|
-
|
|
1023
|
-
|
|
1024
|
-
|
|
1049
|
+
# Una cuenta dormida no alarma. El `!` del item y la notificación de
|
|
1050
|
+
# escritorio existen para avisarte de algo que te va a frenar; una
|
|
1051
|
+
# cuenta que nadie usa, en 100 % desde hace semanas, no te frena nada y
|
|
1052
|
+
# el aviso es puro ruido — el mismo ruido que hizo que alguien quisiera
|
|
1053
|
+
# esconderla, que es lo que este repo no quiere que haga falta.
|
|
1054
|
+
dormida = bool((p.get("relevancia") or {}).get("dormida"))
|
|
1055
|
+
|
|
1056
|
+
def alerta(v, _frena=frena, _chocas=chocas, _dormida=dormida) -> bool:
|
|
1057
|
+
if not v or _dormida:
|
|
1025
1058
|
return False
|
|
1026
1059
|
return bool(v.get("preocupa")) or (_chocas and v.get("clave") == _frena.get("clave"))
|
|
1027
1060
|
|
|
@@ -1050,9 +1083,15 @@ def piezas_de(datos, avisar=None) -> list[dict]:
|
|
|
1050
1083
|
"ultimo_uso": p.get("ultimoUso"),
|
|
1051
1084
|
"viejo": (cuota.get("edadSegundos") or 0) >= VIEJO_SEGUNDOS,
|
|
1052
1085
|
})
|
|
1053
|
-
if avisar is not None:
|
|
1086
|
+
if avisar is not None and not dormida:
|
|
1054
1087
|
# Todas las barras, no sólo la que frena: la semanal puede estar
|
|
1055
1088
|
# tranquila mientras la de sesión te para, y al revés.
|
|
1089
|
+
#
|
|
1090
|
+
# Salvo si la cuenta está dormida. Una notificación de escritorio
|
|
1091
|
+
# que dice «codex llegó al 95 %» por una cuenta free que nadie toca
|
|
1092
|
+
# hace semanas no avisa de nada: interrumpe. Es el mismo ruido que
|
|
1093
|
+
# hace que alguien termine escondiendo la cuenta, y esconderla es lo
|
|
1094
|
+
# que este cambio existe para que no haga falta.
|
|
1056
1095
|
avisar(nombre, cuota.get("mostrar") or [], frena, proy, chocas)
|
|
1057
1096
|
return piezas
|
|
1058
1097
|
|
|
@@ -1165,7 +1204,7 @@ def modelo_panel(datos):
|
|
|
1165
1204
|
i += 1
|
|
1166
1205
|
if calladas:
|
|
1167
1206
|
vistas.append(VistaSinCuota(calladas))
|
|
1168
|
-
return VistaResumen.desde(
|
|
1207
|
+
return VistaResumen.desde(datos), vistas
|
|
1169
1208
|
|
|
1170
1209
|
|
|
1171
1210
|
def _pluma_de_medir() -> Pluma:
|
|
@@ -1678,6 +1717,19 @@ class Indicador:
|
|
|
1678
1717
|
# Desde cuándo. Sin esto, una bandera que se queda pegada no se puede
|
|
1679
1718
|
# distinguir de un calentado que recién arrancó.
|
|
1680
1719
|
self.calentando_desde: int | None = None
|
|
1720
|
+
# Lo último que falló de cada cosa, para anotar CAMBIOS y no repetir, y
|
|
1721
|
+
# para poder decir cuándo volvió a andar. Un log que repite la misma
|
|
1722
|
+
# falla cada dos minutos no se lee, y uno que nunca dice «volvió» deja
|
|
1723
|
+
# cada falla abierta para siempre: leyéndolo mañana no hay forma de
|
|
1724
|
+
# saber si el problema duró un minuto o duró toda la noche.
|
|
1725
|
+
self._fallo_calentado: str | None = None
|
|
1726
|
+
self._fallo_lectura: str | None = None
|
|
1727
|
+
self._fallo_lectura_desde: float | None = None
|
|
1728
|
+
# Los motivos por cuenta que qm ya explicó en esta corrida. Van una vez
|
|
1729
|
+
# y no tienen «volvió»: los calentados alternan entre todas las cuentas
|
|
1730
|
+
# y sólo las que se mueven, así que que un motivo no aparezca NO dice
|
|
1731
|
+
# que se arregló.
|
|
1732
|
+
self._motivos_calentado: set[str] = set()
|
|
1681
1733
|
self.reloj: int | None = None
|
|
1682
1734
|
self.proxima_lectura: int | None = None
|
|
1683
1735
|
self.turno = 0
|
|
@@ -2071,27 +2123,67 @@ class Indicador:
|
|
|
2071
2123
|
args.append("--cuentas=" + ",".join(mueven))
|
|
2072
2124
|
registrar("calentar", cuentas=",".join(mueven) if mueven else "todas")
|
|
2073
2125
|
try:
|
|
2126
|
+
# El stderr se PIDE, no se tira. Desde 0.1.8 `qm --calentar` explica
|
|
2127
|
+
# ahí por qué una cuenta no se calentó —sin credencial, token
|
|
2128
|
+
# vencido—, y con STDERR_SILENCE esa explicación se iba a /dev/null:
|
|
2129
|
+
# la barra de macOS la anota desde esa misma versión y acá se
|
|
2130
|
+
# perdía.
|
|
2074
2131
|
proc = Gio.Subprocess.new(
|
|
2075
|
-
args, Gio.SubprocessFlags.STDOUT_SILENCE | Gio.SubprocessFlags.
|
|
2132
|
+
args, Gio.SubprocessFlags.STDOUT_SILENCE | Gio.SubprocessFlags.STDERR_PIPE
|
|
2076
2133
|
)
|
|
2077
|
-
except GLib.Error:
|
|
2134
|
+
except GLib.Error as e:
|
|
2135
|
+
self._anotar_calentado(f"no pude correr qm: {str(e).replace(chr(10), ' ')[:110]}")
|
|
2078
2136
|
self.programar_calentado()
|
|
2079
2137
|
return False
|
|
2080
2138
|
self.calentando = True
|
|
2081
2139
|
self.calentando_desde = GLib.get_monotonic_time()
|
|
2082
|
-
proc.
|
|
2140
|
+
proc.communicate_utf8_async(None, None, self._fin_calentado)
|
|
2083
2141
|
return False
|
|
2084
2142
|
|
|
2143
|
+
def _anotar_calentado(self, fallo: str | None) -> None:
|
|
2144
|
+
"""La falla del calentado, anotada cuando CAMBIA y con su vuelta."""
|
|
2145
|
+
if fallo == self._fallo_calentado:
|
|
2146
|
+
return
|
|
2147
|
+
if fallo is not None:
|
|
2148
|
+
registrar("calentar.fallo", motivo=fallo)
|
|
2149
|
+
else:
|
|
2150
|
+
registrar("calentar.volvio")
|
|
2151
|
+
self._fallo_calentado = fallo
|
|
2152
|
+
|
|
2085
2153
|
def _fin_calentado(self, proc, resultado) -> None:
|
|
2086
2154
|
self.calentando = False
|
|
2087
2155
|
self.calentando_desde = None
|
|
2156
|
+
fallo, dicho = None, ""
|
|
2088
2157
|
try:
|
|
2089
|
-
proc.
|
|
2158
|
+
_, _, dicho = proc.communicate_utf8_finish(resultado)
|
|
2090
2159
|
except GLib.Error as e:
|
|
2091
2160
|
# Se sigue mostrando lo viejo, con su edad a la vista — pero ahora
|
|
2092
2161
|
# queda anotado POR QUÉ quedó viejo. Este `except` se tragaba la
|
|
2093
2162
|
# única pista de que el refresco no estaba pasando.
|
|
2094
|
-
|
|
2163
|
+
fallo = str(e).replace("\n", " ")[:120]
|
|
2164
|
+
else:
|
|
2165
|
+
# Y acá estaba el agujero: NADA de esto tira. `wait_finish` y
|
|
2166
|
+
# `communicate_utf8_finish` devuelven bien con el hijo saliendo 1
|
|
2167
|
+
# —medido: exit=1, sin excepción—, así que el código de salida hay
|
|
2168
|
+
# que mirarlo a mano. Un `qm --calentar` que salía 1 no dejaba una
|
|
2169
|
+
# sola línea. Es justo lo que pasó en 0.1.9, cuando la barra mandaba
|
|
2170
|
+
# `--cuentas=personal` y el CLI comparaba `.claude-personal`: en
|
|
2171
|
+
# macOS se vio en el log y acá no había log que ver.
|
|
2172
|
+
if not proc.get_if_exited():
|
|
2173
|
+
fallo = f"lo mató la señal {proc.get_term_sig()}"
|
|
2174
|
+
elif proc.get_exit_status() != 0:
|
|
2175
|
+
primera = [l.strip() for l in (dicho or "").splitlines() if l.strip()]
|
|
2176
|
+
fallo = f"salió {proc.get_exit_status()}"
|
|
2177
|
+
if primera:
|
|
2178
|
+
fallo += f": {primera[0][:110]}"
|
|
2179
|
+
self._anotar_calentado(fallo)
|
|
2180
|
+
# Los motivos por cuenta van aunque el calentado haya salido 0: que una
|
|
2181
|
+
# cuenta no se pueda calentar no hace fallar a las otras, y sin esto la
|
|
2182
|
+
# única pista de que esa cuenta quedó afuera es un número viejo.
|
|
2183
|
+
for m in [l.strip() for l in (dicho or "").splitlines() if l.strip()]:
|
|
2184
|
+
if m not in self._motivos_calentado:
|
|
2185
|
+
self._motivos_calentado.add(m)
|
|
2186
|
+
registrar("calentar.cuenta", motivo=m[:110])
|
|
2095
2187
|
self.refrescar()
|
|
2096
2188
|
|
|
2097
2189
|
def disparar(self) -> bool:
|
|
@@ -2109,9 +2201,22 @@ class Indicador:
|
|
|
2109
2201
|
# `leer_qm` devuelve una FRASE cuando no pudo: se muestra en el menú y
|
|
2110
2202
|
# hasta acá no quedaba escrita en ningún lado. Si qm falla a las tres de
|
|
2111
2203
|
# la mañana, mañana no hay forma de saber por qué.
|
|
2112
|
-
if isinstance(datos, str)
|
|
2113
|
-
|
|
2114
|
-
|
|
2204
|
+
if isinstance(datos, str):
|
|
2205
|
+
if datos != self._fallo_lectura:
|
|
2206
|
+
registrar("qm.sin-datos", motivo=datos[:110])
|
|
2207
|
+
if self._fallo_lectura_desde is None:
|
|
2208
|
+
self._fallo_lectura_desde = time.time()
|
|
2209
|
+
self._fallo_lectura = datos
|
|
2210
|
+
else:
|
|
2211
|
+
# La caída ya se anotaba; la VUELTA no, y sin ella toda falla queda
|
|
2212
|
+
# abierta para siempre. Leyendo el journal al otro día no había
|
|
2213
|
+
# forma de saber si qm estuvo caído un minuto o toda la noche, que
|
|
2214
|
+
# es justo lo que se va a buscar. Con el rato que duró, que es el
|
|
2215
|
+
# número que contesta esa pregunta.
|
|
2216
|
+
if self._fallo_lectura is not None:
|
|
2217
|
+
registrar("qm.volvio", tras=duracion(int(time.time() - (self._fallo_lectura_desde or time.time()))))
|
|
2218
|
+
self._fallo_lectura = None
|
|
2219
|
+
self._fallo_lectura_desde = None
|
|
2115
2220
|
self.datos = datos
|
|
2116
2221
|
for hijo in self.menu.get_children():
|
|
2117
2222
|
self.menu.remove(hijo)
|
|
@@ -2227,8 +2332,12 @@ class Indicador:
|
|
|
2227
2332
|
# El nombre alterna igual que el del item: el shell cachea la
|
|
2228
2333
|
# textura por ruta y si no, muestra el panel de hace un rato.
|
|
2229
2334
|
destino = self.iconos / f"panel-{self.turno}.png"
|
|
2230
|
-
|
|
2231
|
-
|
|
2335
|
+
# Un nombre propio, y no `alto` otra vez: pisar el parámetro dejaba
|
|
2336
|
+
# escrito que el ICONO de la barra medía lo que mide el PANEL —
|
|
2337
|
+
# 576 px de alto para un dibujo de 22. La extensión le cree al
|
|
2338
|
+
# archivo y arma el item de ese tamaño.
|
|
2339
|
+
alto_panel = capturar(self.datos, str(destino), self.falta_para_lectura())
|
|
2340
|
+
panel = {"panel": str(destino), "panelAncho": ANCHO_PANEL, "panelAlto": alto_panel}
|
|
2232
2341
|
except (OSError, MemoryError):
|
|
2233
2342
|
pass # sin panel dibujado la extensión sigue mostrando el item
|
|
2234
2343
|
try:
|
|
@@ -2359,7 +2468,201 @@ def leer_desde(ruta: str) -> dict:
|
|
|
2359
2468
|
return json.loads(pathlib.Path(ruta).read_text())
|
|
2360
2469
|
|
|
2361
2470
|
|
|
2471
|
+
ARRANQUE = Path(os.environ.get("XDG_CONFIG_HOME", str(Path.home() / ".config"))) \
|
|
2472
|
+
/ "autostart" / "quartermaster.desktop"
|
|
2473
|
+
|
|
2474
|
+
|
|
2475
|
+
def instalar_arranque() -> int:
|
|
2476
|
+
"""Que el item arranque solo al iniciar sesión.
|
|
2477
|
+
|
|
2478
|
+
Vive acá y no sólo en el Makefile porque quien instaló por apt o por npm no
|
|
2479
|
+
tiene un Makefile: el .deb deja bin/qm-indicator en /usr/lib/quartermaster y
|
|
2480
|
+
nada más, así que el item quedaba a un comando que hay que saber. Es el
|
|
2481
|
+
mismo agujero que en macOS tapó `qm-barra --instalar-arranque`, y `qm` lo
|
|
2482
|
+
ofrece en la primera corrida por el mismo camino.
|
|
2483
|
+
|
|
2484
|
+
El Exec apunta a ESTE archivo resuelto, no a `qm-indicator` a secas: el
|
|
2485
|
+
arranque de la sesión no pasa por el .zshrc del usuario, así que ~/.local/bin
|
|
2486
|
+
puede no estar en su PATH.
|
|
2487
|
+
"""
|
|
2488
|
+
try:
|
|
2489
|
+
ARRANQUE.parent.mkdir(parents=True, exist_ok=True)
|
|
2490
|
+
ARRANQUE.write_text(
|
|
2491
|
+
"[Desktop Entry]\n"
|
|
2492
|
+
"Type=Application\n"
|
|
2493
|
+
"Name=quartermaster\n"
|
|
2494
|
+
"Comment=Cuota de Claude Code en la barra de arriba\n"
|
|
2495
|
+
f"Exec={YO}\n"
|
|
2496
|
+
"Icon=utilities-system-monitor-symbolic\n"
|
|
2497
|
+
"Terminal=false\n"
|
|
2498
|
+
"X-GNOME-Autostart-enabled=true\n",
|
|
2499
|
+
encoding="utf-8")
|
|
2500
|
+
except OSError as e:
|
|
2501
|
+
print(f"no pude escribir {ARRANQUE}: {e}", file=sys.stderr)
|
|
2502
|
+
return 1
|
|
2503
|
+
print(f"{ARRANQUE} escrito")
|
|
2504
|
+
return 0
|
|
2505
|
+
|
|
2506
|
+
|
|
2507
|
+
def quitar_arranque() -> int:
|
|
2508
|
+
"""Lo contrario, porque instalar sin poder desinstalar no es una opción."""
|
|
2509
|
+
try:
|
|
2510
|
+
ARRANQUE.unlink()
|
|
2511
|
+
except FileNotFoundError:
|
|
2512
|
+
print(f"{ARRANQUE} no estaba")
|
|
2513
|
+
return 0
|
|
2514
|
+
except OSError as e:
|
|
2515
|
+
print(f"no pude borrar {ARRANQUE}: {e}", file=sys.stderr)
|
|
2516
|
+
return 1
|
|
2517
|
+
print(f"{ARRANQUE} borrado")
|
|
2518
|
+
return 0
|
|
2519
|
+
|
|
2520
|
+
|
|
2521
|
+
EXTENSION_UUID = "quartermaster@legios"
|
|
2522
|
+
EXTENSIONES = Path(os.environ.get("XDG_DATA_HOME", str(Path.home() / ".local/share"))) \
|
|
2523
|
+
/ "gnome-shell" / "extensions"
|
|
2524
|
+
#: De dónde sale la extensión: al lado del paquete, sea un clone, el .deb o npm.
|
|
2525
|
+
EXTENSION_RAIZ = YO.parent.parent / "extension"
|
|
2526
|
+
|
|
2527
|
+
|
|
2528
|
+
def fuente_extension() -> Path:
|
|
2529
|
+
"""Cuál de las dos copias de la extensión corresponde a este GNOME.
|
|
2530
|
+
|
|
2531
|
+
GNOME 45 cambió la forma de cargar extensiones —módulos ESM y una clase que
|
|
2532
|
+
extiende Extension— y la 43 y la 44 usan `imports.gi` con una función
|
|
2533
|
+
`init()` suelta. No son dos sintaxis que convivan en un archivo, así que el
|
|
2534
|
+
mismo item vive dos veces y acá se elige.
|
|
2535
|
+
|
|
2536
|
+
Importa en Debian 12, que trae la 43 y va a seguir soportada años. Instalar
|
|
2537
|
+
ahí la de 45 deja la extensión en ERROR, el item cae al camino de
|
|
2538
|
+
AppIndicator, y entonces pasan las dos cosas que esta extensión existe para
|
|
2539
|
+
evitar: el medidor entra en una casilla cuadrada de 16 px y se ve minúsculo,
|
|
2540
|
+
y el click se lo queda el menú del shell, que le rompe el agarre al menú de
|
|
2541
|
+
GTK — el panel aparece y desaparece en el mismo instante.
|
|
2542
|
+
|
|
2543
|
+
Se pregunta acá y no en el Makefile porque quien instaló por npm o por apt
|
|
2544
|
+
no tiene un Makefile, que es la misma razón por la que la instalación entera
|
|
2545
|
+
se mudó a este archivo. Sin poder saber la versión se elige la nueva, que es
|
|
2546
|
+
la que corresponde a todo lo que no sea Debian estable.
|
|
2547
|
+
"""
|
|
2548
|
+
vieja = EXTENSION_RAIZ / "gnome43" / EXTENSION_UUID
|
|
2549
|
+
if _shell_es_vieja() and vieja.is_dir():
|
|
2550
|
+
return vieja
|
|
2551
|
+
return EXTENSION_RAIZ / EXTENSION_UUID
|
|
2552
|
+
|
|
2553
|
+
|
|
2554
|
+
def _shell_es_vieja() -> bool:
|
|
2555
|
+
"""GNOME 44 o anterior. False si no se puede saber."""
|
|
2556
|
+
try:
|
|
2557
|
+
dicho = subprocess.run(["gnome-shell", "--version"], capture_output=True,
|
|
2558
|
+
text=True, timeout=5, check=True).stdout
|
|
2559
|
+
except (OSError, subprocess.SubprocessError):
|
|
2560
|
+
return False
|
|
2561
|
+
numeros = "".join(c if c.isdigit() else " " for c in dicho).split()
|
|
2562
|
+
return bool(numeros) and int(numeros[0]) <= 44
|
|
2563
|
+
|
|
2564
|
+
|
|
2565
|
+
def _habilitadas() -> list[str] | None:
|
|
2566
|
+
"""La lista de `enabled-extensions`, o None si no hay gsettings."""
|
|
2567
|
+
try:
|
|
2568
|
+
dicho = subprocess.run(
|
|
2569
|
+
["gsettings", "get", "org.gnome.shell", "enabled-extensions"],
|
|
2570
|
+
capture_output=True, text=True, timeout=5, check=True).stdout.strip()
|
|
2571
|
+
except (OSError, subprocess.SubprocessError):
|
|
2572
|
+
return None
|
|
2573
|
+
# `@as []` para la lista vacía, `['a', 'b']` para el resto.
|
|
2574
|
+
if dicho.startswith("@as"):
|
|
2575
|
+
dicho = dicho[3:].strip()
|
|
2576
|
+
return [x.strip().strip("'\"") for x in dicho.strip("[]").split(",") if x.strip()]
|
|
2577
|
+
|
|
2578
|
+
|
|
2579
|
+
def instalar_extension() -> int:
|
|
2580
|
+
"""El item propio en la barra: un click abre el panel.
|
|
2581
|
+
|
|
2582
|
+
Sin ella el item lo hospeda AppIndicator y el click izquierdo cae al menú de
|
|
2583
|
+
GTK, que no sostiene el agarre y se cierra apenas lo tocás — el síntoma que
|
|
2584
|
+
la extensión existe para evitar, escrito en su propio extension.js.
|
|
2585
|
+
|
|
2586
|
+
Vive acá y no sólo en el Makefile por lo mismo que `--instalar-arranque`:
|
|
2587
|
+
quien instaló por npm o por apt no tiene un Makefile.
|
|
2588
|
+
|
|
2589
|
+
Salidas: 0 habilitada y andando ya, 2 instalada pero GNOME la carga recién
|
|
2590
|
+
en la próxima sesión, 1 no se pudo. El 2 no es un error y no se puede
|
|
2591
|
+
esconder: decir «listo» de algo que no se ve hasta cerrar sesión es
|
|
2592
|
+
exactamente la mentira que este programa no comete.
|
|
2593
|
+
"""
|
|
2594
|
+
fuente = fuente_extension()
|
|
2595
|
+
if not fuente.is_dir():
|
|
2596
|
+
print(f"no encuentro la extensión en {fuente}", file=sys.stderr)
|
|
2597
|
+
return 1
|
|
2598
|
+
destino = EXTENSIONES / EXTENSION_UUID
|
|
2599
|
+
try:
|
|
2600
|
+
EXTENSIONES.mkdir(parents=True, exist_ok=True)
|
|
2601
|
+
if destino.exists():
|
|
2602
|
+
shutil.rmtree(destino)
|
|
2603
|
+
shutil.copytree(fuente, destino)
|
|
2604
|
+
except OSError as e:
|
|
2605
|
+
print(f"no pude copiarla a {destino}: {e}", file=sys.stderr)
|
|
2606
|
+
return 1
|
|
2607
|
+
|
|
2608
|
+
# Anotarla en la lista de habilitadas ANTES de pedir el enable: en Wayland
|
|
2609
|
+
# GNOME no carga una extensión recién copiada, así que `gnome-extensions
|
|
2610
|
+
# enable` falla con «doesn't exist» y sin esta anotación no quedaría puesta
|
|
2611
|
+
# tampoco para la próxima sesión.
|
|
2612
|
+
lista = _habilitadas()
|
|
2613
|
+
if lista is not None and EXTENSION_UUID not in lista:
|
|
2614
|
+
nueva = "[" + ", ".join(f"'{x}'" for x in [*lista, EXTENSION_UUID]) + "]"
|
|
2615
|
+
try:
|
|
2616
|
+
subprocess.run(["gsettings", "set", "org.gnome.shell", "enabled-extensions", nueva],
|
|
2617
|
+
capture_output=True, timeout=5, check=True)
|
|
2618
|
+
except (OSError, subprocess.SubprocessError) as e:
|
|
2619
|
+
print(f"no pude anotarla en enabled-extensions: {e}", file=sys.stderr)
|
|
2620
|
+
return 1
|
|
2621
|
+
|
|
2622
|
+
try:
|
|
2623
|
+
ok = subprocess.run(["gnome-extensions", "enable", EXTENSION_UUID],
|
|
2624
|
+
capture_output=True, timeout=5).returncode == 0
|
|
2625
|
+
except OSError:
|
|
2626
|
+
ok = False
|
|
2627
|
+
if ok:
|
|
2628
|
+
print(f"{EXTENSION_UUID} habilitada")
|
|
2629
|
+
return 0
|
|
2630
|
+
print(f"{EXTENSION_UUID} instalada y anotada. GNOME no carga extensiones "
|
|
2631
|
+
"nuevas en Wayland: cerrá sesión y volvé a entrar una vez.")
|
|
2632
|
+
return 2
|
|
2633
|
+
|
|
2634
|
+
|
|
2635
|
+
def quitar_extension() -> int:
|
|
2636
|
+
"""Saca el item propio y devuelve el de AppIndicator."""
|
|
2637
|
+
try:
|
|
2638
|
+
subprocess.run(["gnome-extensions", "disable", EXTENSION_UUID],
|
|
2639
|
+
capture_output=True, timeout=5)
|
|
2640
|
+
except OSError:
|
|
2641
|
+
pass
|
|
2642
|
+
destino = EXTENSIONES / EXTENSION_UUID
|
|
2643
|
+
try:
|
|
2644
|
+
if destino.exists():
|
|
2645
|
+
shutil.rmtree(destino)
|
|
2646
|
+
(CACHE / "extension-viva").unlink(missing_ok=True)
|
|
2647
|
+
except OSError as e:
|
|
2648
|
+
print(f"no pude borrarla: {e}", file=sys.stderr)
|
|
2649
|
+
return 1
|
|
2650
|
+
print(f"{EXTENSION_UUID} quitada")
|
|
2651
|
+
return 0
|
|
2652
|
+
|
|
2653
|
+
|
|
2362
2654
|
def main() -> int:
|
|
2655
|
+
# Antes que nada: ninguna de las dos necesita sesión gráfica ni un qm en el
|
|
2656
|
+
# PATH, y `qm` llama a la primera desde una terminal.
|
|
2657
|
+
if "--instalar-arranque" in sys.argv:
|
|
2658
|
+
return instalar_arranque()
|
|
2659
|
+
if "--quitar-arranque" in sys.argv:
|
|
2660
|
+
return quitar_arranque()
|
|
2661
|
+
if "--instalar-extension" in sys.argv:
|
|
2662
|
+
return instalar_extension()
|
|
2663
|
+
if "--quitar-extension" in sys.argv:
|
|
2664
|
+
return quitar_extension()
|
|
2665
|
+
|
|
2363
2666
|
fijo = None
|
|
2364
2667
|
if "--desde" in sys.argv:
|
|
2365
2668
|
i = sys.argv.index("--desde")
|
|
@@ -2410,6 +2713,11 @@ def main() -> int:
|
|
|
2410
2713
|
print("ya hay un quartermaster corriendo en esta sesión.", file=sys.stderr)
|
|
2411
2714
|
return 0
|
|
2412
2715
|
|
|
2716
|
+
# La primera línea del journal la pone systemd y dice el scope, no dice
|
|
2717
|
+
# QUÉ arrancó: ni qué qm encontró —puede haber uno en ~/.local/bin y otro
|
|
2718
|
+
# del paquete—, ni con qué tema, ni con qué pid. Leyendo el log de ayer eso
|
|
2719
|
+
# es lo primero que hace falta. La barra de macOS lo anota desde 0.1.8.
|
|
2720
|
+
registrar("arranca", qm=qm, pid=os.getpid(), tema="oscuro" if TEMA.oscuro else "claro")
|
|
2413
2721
|
Indicador(qm)
|
|
2414
2722
|
Gtk.main()
|
|
2415
2723
|
return 0
|