@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/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(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:
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
- p, v = mejor
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
- return VistaResumen(corto(p.get("perfil") or "?"), nombre_ventana(v), v["porcentaje"],
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
- def alerta(v, _frena=frena, _chocas=chocas) -> bool:
1024
- if not v:
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(perfiles), vistas
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.STDERR_SILENCE
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.wait_async(None, self._fin_calentado)
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.wait_finish(resultado)
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
- registrar("calentar.fallo", motivo=str(e).replace("\n", " ")[:120])
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) and datos != getattr(self, "_ultimo_fallo", None):
2113
- registrar("qm.sin-datos", motivo=datos[:110])
2114
- self._ultimo_fallo = datos if isinstance(datos, str) else None
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
- alto = capturar(self.datos, str(destino), self.falta_para_lectura())
2231
- panel = {"panel": str(destino), "panelAncho": ANCHO_PANEL, "panelAlto": alto}
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