@legios/quartermaster 0.1.5 → 0.1.7
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 +185 -1445
- package/bin/buscar-node.cmd +80 -0
- package/bin/qm +17 -0
- package/bin/qm-barra +38 -0
- package/bin/qm-indicator +261 -8
- package/bin/qm-tray-quitar.cmd +19 -0
- package/bin/qm-tray.cmd +20 -0
- package/bin/qm-tray.ps1 +150 -21
- package/bin/qm-web +25 -2
- package/bin/qm-web.cmd +22 -0
- package/bin/qm.cmd +52 -0
- package/bin/qm.mjs +89 -0
- package/dist/adapters/barra.js +154 -0
- package/dist/adapters/barra.js.map +1 -0
- package/dist/adapters/credenciales.js +21 -14
- package/dist/adapters/credenciales.js.map +1 -1
- package/dist/adapters/entorno.js +223 -0
- package/dist/adapters/entorno.js.map +1 -0
- package/dist/adapters/transcripciones.js +28 -0
- package/dist/adapters/transcripciones.js.map +1 -1
- package/dist/cli/qm.js +212 -8
- package/dist/cli/qm.js.map +1 -1
- package/dist/core/presupuesto.js +69 -3
- package/dist/core/presupuesto.js.map +1 -1
- package/dist/core/tipos.js +43 -2
- package/dist/core/tipos.js.map +1 -1
- package/package.json +4 -2
- package/scripts/bumpear.mjs +127 -0
- package/scripts/construir.mjs +15 -4
- package/scripts/cortar-release.sh +76 -0
- package/scripts/gate-bandeja.ps1 +86 -3
- package/scripts/gate-calentado.py +165 -0
- package/scripts/gate-paquetes.sh +118 -0
- package/scripts/gate-windows.ps1 +198 -0
- package/scripts/hacer-deb.sh +10 -0
- package/scripts/hacer-extension-zip.sh +123 -0
- package/scripts/hacer-manifests.mjs +224 -0
- package/scripts/hacer-setup.ps1 +116 -0
- package/scripts/instalar-barra.mjs +57 -59
- package/scripts/mandar-pr-winget.mjs +189 -0
- package/scripts/quartermaster.iss +249 -0
|
@@ -0,0 +1,80 @@
|
|
|
1
|
+
@echo off
|
|
2
|
+
rem Encontrar un Node 22.6 o mas nuevo del lado de Windows. Deja la ruta en %NODO%.
|
|
3
|
+
rem
|
|
4
|
+
rem Es la mitad de bin/qm que no se puede escribir dos veces: la usan qm.cmd y
|
|
5
|
+
rem qm-web.cmd, y se `call`ea SIN setlocal a proposito, porque la gracia es que
|
|
6
|
+
rem la variable quede seteada en quien llama.
|
|
7
|
+
rem
|
|
8
|
+
rem El piso es 22.6 porque qm lee el TypeScript sin paso de build y el type
|
|
9
|
+
rem stripping recien existe desde ahi. No baja con dist\: src\adapters\
|
|
10
|
+
rem opencode.ts usa node:sqlite, que tampoco existe antes.
|
|
11
|
+
rem
|
|
12
|
+
rem Diferencia deliberada con bin/qm: alla las versiones de nvm se ordenan de
|
|
13
|
+
rem mayor a menor para quedarse con la mas nueva. Aca se toma la PRIMERA que
|
|
14
|
+
rem sirva, porque el requisito es un piso y no un maximo: cualquiera que lo pase
|
|
15
|
+
rem corre el mismo codigo. Lo que si se respeta es el orden de las FUENTES, para
|
|
16
|
+
rem que el gestor de versiones que el usuario eligio no quede tapado por una
|
|
17
|
+
rem instalacion vieja en Archivos de programa.
|
|
18
|
+
rem
|
|
19
|
+
rem ASCII puro a proposito: un .cmd con acentos se lee con la codepage de la
|
|
20
|
+
rem consola --850 en Windows en espanol-- y ahi el texto sale roto justo cuando
|
|
21
|
+
rem algo fallo.
|
|
22
|
+
|
|
23
|
+
set "NODO="
|
|
24
|
+
|
|
25
|
+
rem -- 1. el que eligio el usuario ----------------------------------------
|
|
26
|
+
if defined QM_NODE call :probar "%QM_NODE%"
|
|
27
|
+
|
|
28
|
+
rem -- 2. el del PATH -----------------------------------------------------
|
|
29
|
+
if not defined NODO (
|
|
30
|
+
for /f "delims=" %%n in ('where node 2^>nul') do call :probar "%%~n"
|
|
31
|
+
)
|
|
32
|
+
|
|
33
|
+
rem -- 3. los gestores de versiones ---------------------------------------
|
|
34
|
+
rem nvm-windows apunta la version activa con un symlink (NVM_SYMLINK) y guarda
|
|
35
|
+
rem las demas en NVM_HOME\vX.Y.Z. Se prueba primero la activa.
|
|
36
|
+
if not defined NODO if defined NVM_SYMLINK call :probar "%NVM_SYMLINK%\node.exe"
|
|
37
|
+
if not defined NODO if defined NVM_HOME (
|
|
38
|
+
for /f "delims=" %%d in ('dir /b /ad "%NVM_HOME%\v*" 2^>nul') do call :probar "%NVM_HOME%\%%d\node.exe"
|
|
39
|
+
)
|
|
40
|
+
|
|
41
|
+
rem fnm deja cada version en node-versions\vX.Y.Z\installation\node.exe. La activa
|
|
42
|
+
rem cuelga de FNM_MULTISHELL_PATH, que solo existe dentro de un shell donde fnm
|
|
43
|
+
rem ya corrio: por eso no alcanza con mirar esa.
|
|
44
|
+
if not defined NODO if defined FNM_MULTISHELL_PATH call :probar "%FNM_MULTISHELL_PATH%\node.exe"
|
|
45
|
+
set "FNMDIR=%FNM_DIR%"
|
|
46
|
+
if not defined FNMDIR set "FNMDIR=%LOCALAPPDATA%\fnm"
|
|
47
|
+
if not defined NODO (
|
|
48
|
+
for /f "delims=" %%d in ('dir /b /ad "%FNMDIR%\node-versions" 2^>nul') do call :probar "%FNMDIR%\node-versions\%%d\installation\node.exe"
|
|
49
|
+
)
|
|
50
|
+
|
|
51
|
+
if not defined NODO call :probar "%LOCALAPPDATA%\Volta\bin\node.exe"
|
|
52
|
+
|
|
53
|
+
rem -- 4. las instalaciones normales --------------------------------------
|
|
54
|
+
if not defined NODO call :probar "%ProgramFiles%\nodejs\node.exe"
|
|
55
|
+
if not defined NODO call :probar "%ProgramFiles(x86)%\nodejs\node.exe"
|
|
56
|
+
if not defined NODO call :probar "%LOCALAPPDATA%\Programs\nodejs\node.exe"
|
|
57
|
+
|
|
58
|
+
if defined NODO exit /b 0
|
|
59
|
+
|
|
60
|
+
rem Silencio es el bug (SOUL.md): si no hay Node, hay una frase que dice como
|
|
61
|
+
rem conseguirlo, no un error de sintaxis de un archivo .ts.
|
|
62
|
+
echo quartermaster necesita Node ^>= 22.6 y no encontre ninguno.>&2
|
|
63
|
+
echo Lee TypeScript sin paso de build, y eso recien existe desde 22.6.>&2
|
|
64
|
+
echo.>&2
|
|
65
|
+
echo winget install OpenJS.NodeJS.LTS instalarlo>&2
|
|
66
|
+
echo set QM_NODE=C:\ruta\a\node.exe o decirle cual usar>&2
|
|
67
|
+
exit /b 1
|
|
68
|
+
|
|
69
|
+
rem -- :probar ------------------------------------------------------------
|
|
70
|
+
rem Se queda con el candidato si existe Y si la version alcanza. Se guarda
|
|
71
|
+
rem solo, asi que se lo puede llamar en cadena sin envolverlo en ifs: el
|
|
72
|
+
rem primero que sirva gana y los demas no hacen nada.
|
|
73
|
+
:probar
|
|
74
|
+
if defined NODO exit /b 0
|
|
75
|
+
if "%~1"=="" exit /b 0
|
|
76
|
+
if not exist "%~1" exit /b 0
|
|
77
|
+
"%~1" -e "const [a,b]=process.versions.node.split('.').map(Number);process.exit(a>22||(a===22&&b>=6)?0:1)" >nul 2>&1
|
|
78
|
+
if errorlevel 1 exit /b 0
|
|
79
|
+
set "NODO=%~1"
|
|
80
|
+
exit /b 0
|
package/bin/qm
CHANGED
|
@@ -60,6 +60,23 @@ RAIZ=$(cd "$(dirname "$AQUI")/.." && pwd)
|
|
|
60
60
|
# así que un clone, `make instalar`, el .deb y brew siguen leyendo el TypeScript
|
|
61
61
|
# directo como siempre.
|
|
62
62
|
if [ -f "$RAIZ/dist/cli/qm.js" ]; then
|
|
63
|
+
# Un dist/ viejo TAPA al src/ en silencio. Se edita el TypeScript, se corre
|
|
64
|
+
# qm, no cambia nada, y no hay un solo aviso de por qué: `dist/` está en el
|
|
65
|
+
# .gitignore, así que queda de una corrida anterior y nadie se acuerda.
|
|
66
|
+
#
|
|
67
|
+
# Pasó, y costó: `qm --diagnostico` contestaba «opción desconocida» con la
|
|
68
|
+
# bandera ya mergeada en main, porque el dist/ del disco era de diez horas
|
|
69
|
+
# antes.
|
|
70
|
+
#
|
|
71
|
+
# Sólo se comprueba cuando hay un src/ al lado: el tarball de npm no lleva
|
|
72
|
+
# src/cli, así que quien instaló por npm no tiene nada que reconstruir y no
|
|
73
|
+
# tiene por qué ver esto. Y avisa, no falla — el dist/ igual funciona, sólo
|
|
74
|
+
# que no es lo que está escrito.
|
|
75
|
+
if [ -f "$RAIZ/src/cli/qm.ts" ] && [ "$RAIZ/src/cli/qm.ts" -nt "$RAIZ/dist/cli/qm.js" ] 2>/dev/null; then
|
|
76
|
+
echo "qm: dist/ es más viejo que src/, y dist/ es el que se ejecuta." >&2
|
|
77
|
+
echo " Tus cambios en src/ NO se están viendo. Corré \`npm run construir\`," >&2
|
|
78
|
+
echo " o borrá dist/ para volver a leer el TypeScript directo." >&2
|
|
79
|
+
fi
|
|
63
80
|
exec "$NODO" "$RAIZ/dist/cli/qm.js" "$@"
|
|
64
81
|
fi
|
|
65
82
|
|
package/bin/qm-barra
CHANGED
|
@@ -38,6 +38,44 @@ while [ -L "$AQUI" ]; do
|
|
|
38
38
|
done
|
|
39
39
|
RAIZ=$(cd "$(dirname "$AQUI")/.." && pwd)
|
|
40
40
|
|
|
41
|
+
# ── el arranque automático, que ahora se pide ──────────────────────────
|
|
42
|
+
# Esto lo hacía el postinstall de npm solo, sin preguntar. Un paquete que lee
|
|
43
|
+
# credenciales OAuth no puede gastar la confianza que necesita registrando
|
|
44
|
+
# agentes de arranque que nadie le pidió, y encima el camino no era confiable:
|
|
45
|
+
# `npm ci --ignore-scripts` es lo normal en CI y en cualquier organización con
|
|
46
|
+
# políticas. Así que la capacidad sigue existiendo, con el mismo plist — pero
|
|
47
|
+
# la escribe quien la quiere.
|
|
48
|
+
PLIST="$HOME/Library/LaunchAgents/com.legios.quartermaster.barra.plist"
|
|
49
|
+
|
|
50
|
+
case "$1" in
|
|
51
|
+
--instalar-arranque)
|
|
52
|
+
mkdir -p "$(dirname "$PLIST")"
|
|
53
|
+
cat > "$PLIST" <<PLISTEOF
|
|
54
|
+
<?xml version="1.0" encoding="UTF-8"?>
|
|
55
|
+
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
|
|
56
|
+
<plist version="1.0"><dict>
|
|
57
|
+
<key>Label</key><string>com.legios.quartermaster.barra</string>
|
|
58
|
+
<key>ProgramArguments</key><array><string>$AQUI</string></array>
|
|
59
|
+
<key>RunAtLoad</key><true/>
|
|
60
|
+
<key>KeepAlive</key><false/>
|
|
61
|
+
</dict></plist>
|
|
62
|
+
PLISTEOF
|
|
63
|
+
launchctl unload "$PLIST" 2>/dev/null || true
|
|
64
|
+
launchctl load "$PLIST"
|
|
65
|
+
echo "listo: la barra arranca sola al iniciar sesión."
|
|
66
|
+
echo "escrito en $PLIST"
|
|
67
|
+
echo "para sacarla: qm-barra --sacar-arranque"
|
|
68
|
+
exit 0
|
|
69
|
+
;;
|
|
70
|
+
--sacar-arranque)
|
|
71
|
+
launchctl unload "$PLIST" 2>/dev/null || true
|
|
72
|
+
rm -f "$PLIST"
|
|
73
|
+
pkill -f "quartermaster/qm-barra" 2>/dev/null || true
|
|
74
|
+
echo "sacada del arranque automático."
|
|
75
|
+
exit 0
|
|
76
|
+
;;
|
|
77
|
+
esac
|
|
78
|
+
|
|
41
79
|
FUENTE="$RAIZ/bin/qm-barra.swift"
|
|
42
80
|
CACHE="${XDG_CACHE_HOME:-$HOME/.cache}/quartermaster"
|
|
43
81
|
BINARIO="$CACHE/qm-barra"
|
package/bin/qm-indicator
CHANGED
|
@@ -56,6 +56,14 @@ from gi.repository import Gdk, Gio, GLib, Gtk, Pango, PangoCairo # noqa: E402
|
|
|
56
56
|
ID = "quartermaster"
|
|
57
57
|
# Red de seguridad: el FileMonitor es el que manda. Esto sólo cubre el caso de
|
|
58
58
|
# un monitor que se pierda un evento (montajes raros, archivos reemplazados).
|
|
59
|
+
# Cuánto hace falta que una cuenta esté sin usarse para dejar de preguntarle.
|
|
60
|
+
# Diez minutos aguantan una pausa entre prompts sin seguir preguntando por una
|
|
61
|
+
# cuenta que ya cerraste.
|
|
62
|
+
ACTIVA_SEGUNDOS = 600
|
|
63
|
+
# Cuánto se le da a un calentado antes de darlo por colgado. `qm --calentar`
|
|
64
|
+
# tiene su propio timeout de red adentro, así que si en dos minutos no contestó
|
|
65
|
+
# es que su callback no va a llegar.
|
|
66
|
+
CALENTADO_PLAZO_US = 120 * 1_000_000
|
|
59
67
|
SEGUNDOS_SONDEO = 300
|
|
60
68
|
# Piso para cualquier cadencia que salga a la RED. Claude Code pide la cuota del
|
|
61
69
|
# orden de una vez por sesión; un endpoint no documentado, que además puede
|
|
@@ -105,6 +113,38 @@ def corto(nombre: str) -> str:
|
|
|
105
113
|
return nombre.removeprefix(".claude").lstrip("-") or "main"
|
|
106
114
|
|
|
107
115
|
|
|
116
|
+
# ── el registro ──────────────────────────────────────────────────────────
|
|
117
|
+
#
|
|
118
|
+
# Este programa no anotaba NADA. Arrancado por el autostart queda como un scope
|
|
119
|
+
# de systemd, así que todo lo que escriba a stderr lo levanta el journal solo —
|
|
120
|
+
# pero en veinte horas de sesión el journal tenía dos renglones, los que pone
|
|
121
|
+
# systemd al abrir y cerrar el scope, porque el programa nunca dijo nada.
|
|
122
|
+
#
|
|
123
|
+
# Se notó reportando «toco Panel de cuota y se cierra al instante»: no había una
|
|
124
|
+
# sola línea que dijera si el panel había llegado a abrirse, ni cuánto había
|
|
125
|
+
# durado, ni por qué se había cerrado. Un monitor mudo es el bug que originó
|
|
126
|
+
# este repo; el monitor estaba mudo sobre sí mismo.
|
|
127
|
+
#
|
|
128
|
+
# Va a stderr y no a un archivo propio a propósito: el journal ya rota, ya
|
|
129
|
+
# fecha, ya lo sabe leer `journalctl --user`, y `qm --diagnostico` lo recoge de
|
|
130
|
+
# ahí. Un archivo nuestro sería una cosa más que mantener y que se llena sola.
|
|
131
|
+
#
|
|
132
|
+
# QM_SILENCIO=1 lo apaga. No hay nivel de detalle: son unos pocos eventos por
|
|
133
|
+
# apertura de panel, no una traza.
|
|
134
|
+
SILENCIO = os.environ.get("QM_SILENCIO") == "1"
|
|
135
|
+
|
|
136
|
+
|
|
137
|
+
def registrar(evento: str, **datos) -> None:
|
|
138
|
+
"""Un evento por renglón, con sus datos. Nunca puede tirar."""
|
|
139
|
+
if SILENCIO:
|
|
140
|
+
return
|
|
141
|
+
try:
|
|
142
|
+
extra = " ".join(f"{k}={v}" for k, v in datos.items() if v is not None)
|
|
143
|
+
print(f"qm-indicator: {evento}{' ' + extra if extra else ''}", file=sys.stderr, flush=True)
|
|
144
|
+
except Exception: # noqa: BLE001 — registrar no puede romper al programa
|
|
145
|
+
pass
|
|
146
|
+
|
|
147
|
+
|
|
108
148
|
def faltan(iso: str | None) -> int | None:
|
|
109
149
|
if not iso:
|
|
110
150
|
return None
|
|
@@ -926,6 +966,14 @@ def piezas_de(datos, avisar=None) -> list[dict]:
|
|
|
926
966
|
"sesion_alerta": alerta(ses),
|
|
927
967
|
"semanal": sem.get("porcentaje") if sem else None,
|
|
928
968
|
"semanal_alerta": alerta(sem),
|
|
969
|
+
# Cuándo se reinicia cada una. Lo usa `calentar()` para saber si el
|
|
970
|
+
# número que tiene es de una ventana que ya cerró.
|
|
971
|
+
"reinicia_sesion": ses.get("reinicia") if ses else None,
|
|
972
|
+
"reinicia_semanal": sem.get("reinicia") if sem else None,
|
|
973
|
+
# Cuándo se usó esta cuenta por última vez. Es lo que distingue una
|
|
974
|
+
# cuenta al 2 % que está quieta de una al 2 % que estás gastando
|
|
975
|
+
# ahora mismo: el número de la segunda se mueve, el de la primera no.
|
|
976
|
+
"ultimo_uso": p.get("ultimoUso"),
|
|
929
977
|
"viejo": (cuota.get("edadSegundos") or 0) >= VIEJO_SEGUNDOS,
|
|
930
978
|
})
|
|
931
979
|
if avisar is not None:
|
|
@@ -1178,8 +1226,11 @@ class Panel:
|
|
|
1178
1226
|
# Si el compositor le rompe el agarre —pasa cuando el foco se va al lado
|
|
1179
1227
|
# Wayland— el menú tiene que cerrarse, no quedarse colgado arriba de
|
|
1180
1228
|
# todo sin forma de sacarlo.
|
|
1181
|
-
self.menu.connect("grab-broken-event",
|
|
1229
|
+
self.menu.connect("grab-broken-event", self._agarre_roto)
|
|
1182
1230
|
self.menu.connect("unmap", self._al_cerrar)
|
|
1231
|
+
# Cuándo se abrió, para poder decir cuánto duró. Un panel que vive 40 ms
|
|
1232
|
+
# no es lo mismo que uno que el usuario cerró, y desde afuera se ven igual.
|
|
1233
|
+
self.abierto_en = 0
|
|
1183
1234
|
|
|
1184
1235
|
@property
|
|
1185
1236
|
def abierto(self) -> bool:
|
|
@@ -1196,7 +1247,24 @@ class Panel:
|
|
|
1196
1247
|
except (AttributeError, TypeError):
|
|
1197
1248
|
return False
|
|
1198
1249
|
|
|
1250
|
+
def _agarre_roto(self, *_):
|
|
1251
|
+
"""El compositor le sacó el agarre al menú.
|
|
1252
|
+
|
|
1253
|
+
Es la firma del panel que «se cierra solo»: si esto llega a los pocos
|
|
1254
|
+
milisegundos de abrir, el panel no lo cerró el usuario.
|
|
1255
|
+
"""
|
|
1256
|
+
registrar("panel.agarre-roto", vivio_ms=self._vivio_ms())
|
|
1257
|
+
self.menu.popdown()
|
|
1258
|
+
return False
|
|
1259
|
+
|
|
1260
|
+
def _vivio_ms(self) -> int | None:
|
|
1261
|
+
if not self.abierto_en:
|
|
1262
|
+
return None
|
|
1263
|
+
return int((GLib.get_monotonic_time() - self.abierto_en) / 1000)
|
|
1264
|
+
|
|
1199
1265
|
def _al_cerrar(self, *_) -> None:
|
|
1266
|
+
registrar("panel.cerrado", vivio_ms=self._vivio_ms())
|
|
1267
|
+
self.abierto_en = 0
|
|
1200
1268
|
self.cerrado = GLib.get_monotonic_time()
|
|
1201
1269
|
if self.tictac is not None:
|
|
1202
1270
|
GLib.source_remove(self.tictac)
|
|
@@ -1342,8 +1410,12 @@ class Panel:
|
|
|
1342
1410
|
donde.x, donde.y, donde.width, donde.height = area.x + area.width - 6, area.y, 1, 1
|
|
1343
1411
|
raiz = Gdk.get_default_root_window()
|
|
1344
1412
|
if raiz is None: # sin X11 no hay dónde anclarlo; que lo ubique GTK
|
|
1413
|
+
registrar("panel.abierto", donde="puntero", raiz="sin-x11")
|
|
1414
|
+
self.abierto_en = GLib.get_monotonic_time()
|
|
1345
1415
|
self.menu.popup_at_pointer(None)
|
|
1346
1416
|
return
|
|
1417
|
+
registrar("panel.abierto", donde="arriba-derecha", alto=self.alto)
|
|
1418
|
+
self.abierto_en = GLib.get_monotonic_time()
|
|
1347
1419
|
self.menu.popup_at_rect(raiz, donde, Gdk.Gravity.NORTH_EAST,
|
|
1348
1420
|
Gdk.Gravity.NORTH_EAST, self._disparo(raiz))
|
|
1349
1421
|
if self.tictac is None:
|
|
@@ -1380,6 +1452,10 @@ class Avisos:
|
|
|
1380
1452
|
self.vistos = set(json.loads(self.ruta.read_text()))
|
|
1381
1453
|
except (OSError, ValueError):
|
|
1382
1454
|
self.vistos = set()
|
|
1455
|
+
# Sólo para el registro: qué avisos repetidos ya se dijeron en ESTE
|
|
1456
|
+
# proceso. No se persiste — al reiniciar conviene volver a decirlo una
|
|
1457
|
+
# vez, porque el registro nuevo arranca vacío.
|
|
1458
|
+
self.repetidos_dichos: set[str] = set()
|
|
1383
1459
|
|
|
1384
1460
|
def guardar(self) -> None:
|
|
1385
1461
|
try:
|
|
@@ -1391,9 +1467,21 @@ class Avisos:
|
|
|
1391
1467
|
def avisar(self, clave: str, titulo: str, cuerpo: str, urgente: bool) -> None:
|
|
1392
1468
|
"""Una vez por clave y nunca más."""
|
|
1393
1469
|
if clave in self.vistos:
|
|
1470
|
+
# Que un aviso NO salga por repetido es una decisión, no un
|
|
1471
|
+
# no-evento: explica «no me avisó» cuando el aviso sí correspondía.
|
|
1472
|
+
#
|
|
1473
|
+
# Pero esto se evalúa en CADA refresco, o sea cada pocos segundos
|
|
1474
|
+
# mientras la barra siga alta. Registrarlo siempre son tres líneas
|
|
1475
|
+
# iguales cada veinte segundos hasta que la ventana se reinicie: el
|
|
1476
|
+
# registro deja de leerse y el evento que importa queda enterrado.
|
|
1477
|
+
# Se dice una vez por clave y por proceso, que es cuando aporta.
|
|
1478
|
+
if clave not in self.repetidos_dichos:
|
|
1479
|
+
self.repetidos_dichos.add(clave)
|
|
1480
|
+
registrar("aviso.repetido", clave=clave)
|
|
1394
1481
|
return
|
|
1395
1482
|
self.vistos.add(clave)
|
|
1396
1483
|
self.guardar()
|
|
1484
|
+
registrar("aviso", clave=clave, urgente=urgente)
|
|
1397
1485
|
self.notificar(titulo, cuerpo, urgente)
|
|
1398
1486
|
|
|
1399
1487
|
def notificar(self, titulo: str, cuerpo: str, urgente: bool) -> None:
|
|
@@ -1423,8 +1511,11 @@ class Avisos:
|
|
|
1423
1511
|
-1,
|
|
1424
1512
|
None,
|
|
1425
1513
|
)
|
|
1426
|
-
except GLib.Error:
|
|
1427
|
-
|
|
1514
|
+
except GLib.Error as e:
|
|
1515
|
+
# El indicador igual funciona sin servidor de notificaciones, pero
|
|
1516
|
+
# «te liberaste» es el aviso más útil que da el programa: si no sale,
|
|
1517
|
+
# tiene que quedar dicho por qué.
|
|
1518
|
+
registrar("aviso.fallo", motivo=str(e).replace("\n", " ")[:100])
|
|
1428
1519
|
|
|
1429
1520
|
|
|
1430
1521
|
# ── leer a qm ────────────────────────────────────────────────────────────
|
|
@@ -1503,6 +1594,9 @@ class Indicador:
|
|
|
1503
1594
|
self.piezas: list[dict] = []
|
|
1504
1595
|
self.minutos_al_techo: float | None = None
|
|
1505
1596
|
self.calentando = False
|
|
1597
|
+
# Desde cuándo. Sin esto, una bandera que se queda pegada no se puede
|
|
1598
|
+
# distinguir de un calentado que recién arrancó.
|
|
1599
|
+
self.calentando_desde: int | None = None
|
|
1506
1600
|
self.reloj: int | None = None
|
|
1507
1601
|
self.proxima_lectura: int | None = None
|
|
1508
1602
|
self.turno = 0
|
|
@@ -1516,6 +1610,7 @@ class Indicador:
|
|
|
1516
1610
|
self.vigilar_version()
|
|
1517
1611
|
GLib.timeout_add_seconds(SEGUNDOS_SONDEO, self.refrescar)
|
|
1518
1612
|
self.programar_calentado(5)
|
|
1613
|
+
self.vigilar_suspension()
|
|
1519
1614
|
|
|
1520
1615
|
# Vigilancia de archivos ------------------------------------------------
|
|
1521
1616
|
def vigilar(self) -> None:
|
|
@@ -1593,12 +1688,67 @@ class Indicador:
|
|
|
1593
1688
|
print(f"la versión nueva no compila, me quedo con ésta: {e}", file=sys.stderr)
|
|
1594
1689
|
return False
|
|
1595
1690
|
self.panel.menu.popdown()
|
|
1691
|
+
# Un proceso que se reemplaza a sí mismo en silencio explica cualquier
|
|
1692
|
+
# rareza posterior —contadores en cero, panel cerrado, avisos de nuevo—
|
|
1693
|
+
# y hasta acá no dejaba una línea.
|
|
1694
|
+
registrar("reinicio", motivo="el fuente cambió")
|
|
1596
1695
|
try:
|
|
1597
1696
|
os.execv(sys.executable, [sys.executable, str(YO), *sys.argv[1:]])
|
|
1598
1697
|
except OSError as e:
|
|
1698
|
+
registrar("reinicio.fallo", error=str(e)[:80])
|
|
1599
1699
|
print(f"no pude reiniciarme: {e}", file=sys.stderr)
|
|
1600
1700
|
return False
|
|
1601
1701
|
|
|
1702
|
+
def vigilar_suspension(self) -> None:
|
|
1703
|
+
"""Enterarse de que la máquina durmió, y refrescar al volver.
|
|
1704
|
+
|
|
1705
|
+
Sin esto, volver de una suspensión es la peor pantalla que da el
|
|
1706
|
+
programa: los números son de antes de dormir y las ventanas que se
|
|
1707
|
+
reiniciaron mientras tanto salen marcadas «vencida». Todo correcto y
|
|
1708
|
+
todo inútil — lo que hace falta es el número de ahora.
|
|
1709
|
+
|
|
1710
|
+
Y no alcanza con esperar al próximo sondeo. Los timeouts de GLib corren
|
|
1711
|
+
contra el reloj MONOTÓNICO, que en Linux no avanza mientras la máquina
|
|
1712
|
+
duerme: cuatro horas suspendida son cero segundos para el temporizador.
|
|
1713
|
+
El reloj de pared sí saltó, así que la lectura queda vieja de horas
|
|
1714
|
+
mientras el sondeo cree que recién empieza.
|
|
1715
|
+
|
|
1716
|
+
logind avisa con PrepareForSleep: `true` antes de dormir, `false` al
|
|
1717
|
+
volver. El `false` es el que importa.
|
|
1718
|
+
|
|
1719
|
+
Va en el bus del SISTEMA, no en el de sesión. Si no se puede —un
|
|
1720
|
+
contenedor, una máquina sin logind— se sigue sin esto, que es como
|
|
1721
|
+
estaba hasta hoy.
|
|
1722
|
+
"""
|
|
1723
|
+
try:
|
|
1724
|
+
sistema = Gio.bus_get_sync(Gio.BusType.SYSTEM, None)
|
|
1725
|
+
sistema.signal_subscribe(
|
|
1726
|
+
"org.freedesktop.login1",
|
|
1727
|
+
"org.freedesktop.login1.Manager",
|
|
1728
|
+
"PrepareForSleep",
|
|
1729
|
+
"/org/freedesktop/login1",
|
|
1730
|
+
None,
|
|
1731
|
+
Gio.DBusSignalFlags.NONE,
|
|
1732
|
+
self._al_dormir_o_volver,
|
|
1733
|
+
)
|
|
1734
|
+
self.bus_sistema = sistema
|
|
1735
|
+
except GLib.Error as e:
|
|
1736
|
+
registrar("suspension.sin-logind", motivo=str(e)[:90])
|
|
1737
|
+
|
|
1738
|
+
def _al_dormir_o_volver(self, _con, _emisor, _ruta, _iface, _senal, params) -> None:
|
|
1739
|
+
durmiendo = bool(params[0]) if params and len(params) else False
|
|
1740
|
+
if durmiendo:
|
|
1741
|
+
registrar("suspension.duerme")
|
|
1742
|
+
return
|
|
1743
|
+
registrar("suspension.vuelve")
|
|
1744
|
+
# La bandera se suelta a mano: si había un calentado en vuelo cuando la
|
|
1745
|
+
# máquina se durmió, su callback es justo el que puede no llegar.
|
|
1746
|
+
self.calentando = False
|
|
1747
|
+
self.calentando_desde = None
|
|
1748
|
+
# Y se pregunta YA, no en el próximo sondeo: al volver, lo que hay en
|
|
1749
|
+
# pantalla es de antes de dormir.
|
|
1750
|
+
self.programar_calentado(2)
|
|
1751
|
+
|
|
1602
1752
|
def vigilar_tema(self) -> None:
|
|
1603
1753
|
"""El tema del escritorio se cambia con esto andando.
|
|
1604
1754
|
|
|
@@ -1638,14 +1788,24 @@ class Indicador:
|
|
|
1638
1788
|
self.pedido_pendiente = None
|
|
1639
1789
|
try:
|
|
1640
1790
|
accion = PEDIDO.read_text().split(" ", 1)[0].strip()
|
|
1641
|
-
except OSError:
|
|
1791
|
+
except OSError as e:
|
|
1792
|
+
# Un pedido que no se puede leer es un click que se perdió, y sin
|
|
1793
|
+
# esta línea se pierde sin dejar rastro.
|
|
1794
|
+
registrar("pedido.ilegible", error=str(e)[:80])
|
|
1642
1795
|
return False
|
|
1796
|
+
# Saber si el click LLEGÓ es la mitad de cualquier diagnóstico de «no
|
|
1797
|
+
# hace nada»: separa «la extensión no pidió» de «pidió y no pasó nada».
|
|
1798
|
+
# Sin esto hubo que disparar el pedido a mano y mirar el mtime de
|
|
1799
|
+
# estado.json para saber de qué lado estaba el problema.
|
|
1800
|
+
registrar("pedido", accion=accion or "(vacío)")
|
|
1643
1801
|
if accion == "alternar":
|
|
1644
1802
|
# La extensión sólo pide esto cuando NO puede dibujar el panel ella
|
|
1645
1803
|
# misma; si puede, abre su propio menú y no manda nada.
|
|
1646
1804
|
self.abrir_panel()
|
|
1647
1805
|
elif accion == "actualizar":
|
|
1648
1806
|
self.refrescar()
|
|
1807
|
+
else:
|
|
1808
|
+
registrar("pedido.desconocido", accion=accion[:40])
|
|
1649
1809
|
return False
|
|
1650
1810
|
|
|
1651
1811
|
def extension_viva(self) -> bool:
|
|
@@ -1698,6 +1858,64 @@ class Indicador:
|
|
|
1698
1858
|
def _tope(t: dict) -> int:
|
|
1699
1859
|
return max(t["sesion"] or 0, t["semanal"] or 0)
|
|
1700
1860
|
|
|
1861
|
+
@staticmethod
|
|
1862
|
+
def _ya_reinicio(t: dict) -> bool:
|
|
1863
|
+
"""Si alguna de sus ventanas ya pasó su instante de reinicio.
|
|
1864
|
+
|
|
1865
|
+
El número guardado es de ANTES de ese instante, así que no es viejo: es
|
|
1866
|
+
de otra ventana, una que ya cerró. Ahí sí hay algo nuevo que leer.
|
|
1867
|
+
"""
|
|
1868
|
+
for iso in (t.get("reinicia_sesion"), t.get("reinicia_semanal")):
|
|
1869
|
+
seg = faltan(iso)
|
|
1870
|
+
if seg is not None and seg <= 0:
|
|
1871
|
+
return True
|
|
1872
|
+
return False
|
|
1873
|
+
|
|
1874
|
+
@staticmethod
|
|
1875
|
+
def _activa_hace_poco(t: dict) -> bool:
|
|
1876
|
+
"""Si se usó hace poco. Entonces su número se está moviendo."""
|
|
1877
|
+
seg = faltan(t.get("ultimo_uso"))
|
|
1878
|
+
return seg is not None and -ACTIVA_SEGUNDOS <= seg <= 0
|
|
1879
|
+
|
|
1880
|
+
def _vale_preguntar(self, t: dict) -> bool:
|
|
1881
|
+
"""A qué cuentas se les pregunta en el próximo calentado.
|
|
1882
|
+
|
|
1883
|
+
El corte de abajo es ahorro: una cuenta al 9 % no da noticias.
|
|
1884
|
+
|
|
1885
|
+
El de arriba ERA un bug. `cadencia()` tiene razón en no sondear cada
|
|
1886
|
+
minuto una barra en 100 —no puede subir, y el instante del reinicio ya
|
|
1887
|
+
lo sabemos sin preguntar— pero eso es un argumento sobre CADA CUÁNTO, y
|
|
1888
|
+
se había colado acá como un argumento sobre A QUIÉN. Resultado: la
|
|
1889
|
+
cuenta frenada quedaba excluida de todos los calentados, o sea que la
|
|
1890
|
+
única que no podía enterarse de que se liberó era justo la que estaba
|
|
1891
|
+
esperando liberarse. Y «te liberaste» es el aviso más útil que da este
|
|
1892
|
+
programa.
|
|
1893
|
+
|
|
1894
|
+
Medido el 2026-09-13: una cuenta con weekly_all 96 % y weekly_scoped
|
|
1895
|
+
100 % (las dos `critical`) siguió mostrando eso nueve horas, con el
|
|
1896
|
+
reinicio dos horas atrás. Un solo `qm --calentar --cuentas=…` devolvió
|
|
1897
|
+
2 % y 0 %, las dos `normal`.
|
|
1898
|
+
|
|
1899
|
+
Así que el 100 % se saltea mientras su ventana siga abierta, y entra
|
|
1900
|
+
apenas pasa el reinicio — que es el único momento en que tiene algo
|
|
1901
|
+
nuevo para contar.
|
|
1902
|
+
"""
|
|
1903
|
+
if self._ya_reinicio(t):
|
|
1904
|
+
return True
|
|
1905
|
+
# Y la cuenta que estás usando AHORA, esté donde esté.
|
|
1906
|
+
#
|
|
1907
|
+
# El corte de abajo —«una cuenta al 9 % no da noticias»— es cierto de
|
|
1908
|
+
# una cuenta QUIETA. De una que estás gastando es exactamente al revés:
|
|
1909
|
+
# es la única cuyo número está cambiando, y con el corte por nivel se
|
|
1910
|
+
# quedaba sin preguntar hasta llegar al 40 %.
|
|
1911
|
+
#
|
|
1912
|
+
# Medido el 2026-09-13, con dos sesiones abiertas: la cuenta de teams
|
|
1913
|
+
# iba al 2 % y en 55 minutos la barra le preguntó al endpoint UNA vez.
|
|
1914
|
+
# Todos los demás calentados fueron para codex, que estaba al 85 %.
|
|
1915
|
+
if self._activa_hace_poco(t):
|
|
1916
|
+
return True
|
|
1917
|
+
return 40 <= self._tope(t) < 100
|
|
1918
|
+
|
|
1701
1919
|
def cadencia(self) -> int:
|
|
1702
1920
|
# Una barra que ya está en 100 no puede subir: hasta el reinicio no hay
|
|
1703
1921
|
# nada nuevo que leer, y el instante del reinicio ya lo sabemos sin
|
|
@@ -1740,13 +1958,37 @@ class Indicador:
|
|
|
1740
1958
|
def calentar(self) -> bool:
|
|
1741
1959
|
self.reloj = None
|
|
1742
1960
|
if self.calentando:
|
|
1743
|
-
return False
|
|
1961
|
+
# Acá había un `return False` pelado, y eso MATABA el lazo: al
|
|
1962
|
+
# devolver False la fuente de GLib se quita, y como `self.reloj` ya
|
|
1963
|
+
# se soltó arriba, nadie la vuelve a armar. Una sola bandera pegada
|
|
1964
|
+
# dejaba al indicador sin volver a preguntarle al endpoint en lo que
|
|
1965
|
+
# le quedaba de vida — dibujando cada pocos minutos un número que no
|
|
1966
|
+
# se actualizaba nunca.
|
|
1967
|
+
#
|
|
1968
|
+
# Visto el 2026-09-13 después de una suspensión de 4,1 h: el proceso
|
|
1969
|
+
# vivo, estado.json reescrito hacía 4 minutos, y la cuota leída
|
|
1970
|
+
# hacía 5,2 horas.
|
|
1971
|
+
#
|
|
1972
|
+
# `calentando` sólo se apaga en el callback de wait_async. Si ese
|
|
1973
|
+
# callback no llega —y una suspensión en el medio es justo cuando no
|
|
1974
|
+
# llega— no hay nada más que lo apague. Así que además de
|
|
1975
|
+
# reprogramar, se le pone un plazo: pasado eso, el callback no viene
|
|
1976
|
+
# y la bandera se suelta.
|
|
1977
|
+
desde = self.calentando_desde
|
|
1978
|
+
if desde is not None and (GLib.get_monotonic_time() - desde) > CALENTADO_PLAZO_US:
|
|
1979
|
+
registrar("calentar.colgado", segundos=int((GLib.get_monotonic_time() - desde) / 1_000_000))
|
|
1980
|
+
self.calentando = False
|
|
1981
|
+
self.calentando_desde = None
|
|
1982
|
+
else:
|
|
1983
|
+
self.programar_calentado()
|
|
1984
|
+
return False
|
|
1744
1985
|
args = [self.qm, "--calentar"]
|
|
1745
1986
|
# Sólo las cuentas que se mueven: refrescar una que va al 9 % es gastar
|
|
1746
1987
|
# un pedido para confirmar que no pasó nada.
|
|
1747
|
-
mueven = [t["perfil"] for t in self.piezas if
|
|
1988
|
+
mueven = [t["perfil"] for t in self.piezas if self._vale_preguntar(t)]
|
|
1748
1989
|
if mueven and len(mueven) != len(self.piezas):
|
|
1749
1990
|
args.append("--cuentas=" + ",".join(mueven))
|
|
1991
|
+
registrar("calentar", cuentas=",".join(mueven) if mueven else "todas")
|
|
1750
1992
|
try:
|
|
1751
1993
|
proc = Gio.Subprocess.new(
|
|
1752
1994
|
args, Gio.SubprocessFlags.STDOUT_SILENCE | Gio.SubprocessFlags.STDERR_SILENCE
|
|
@@ -1755,15 +1997,20 @@ class Indicador:
|
|
|
1755
1997
|
self.programar_calentado()
|
|
1756
1998
|
return False
|
|
1757
1999
|
self.calentando = True
|
|
2000
|
+
self.calentando_desde = GLib.get_monotonic_time()
|
|
1758
2001
|
proc.wait_async(None, self._fin_calentado)
|
|
1759
2002
|
return False
|
|
1760
2003
|
|
|
1761
2004
|
def _fin_calentado(self, proc, resultado) -> None:
|
|
1762
2005
|
self.calentando = False
|
|
2006
|
+
self.calentando_desde = None
|
|
1763
2007
|
try:
|
|
1764
2008
|
proc.wait_finish(resultado)
|
|
1765
|
-
except GLib.Error:
|
|
1766
|
-
|
|
2009
|
+
except GLib.Error as e:
|
|
2010
|
+
# Se sigue mostrando lo viejo, con su edad a la vista — pero ahora
|
|
2011
|
+
# queda anotado POR QUÉ quedó viejo. Este `except` se tragaba la
|
|
2012
|
+
# única pista de que el refresco no estaba pasando.
|
|
2013
|
+
registrar("calentar.fallo", motivo=str(e).replace("\n", " ")[:120])
|
|
1767
2014
|
self.refrescar()
|
|
1768
2015
|
|
|
1769
2016
|
def disparar(self) -> bool:
|
|
@@ -1778,6 +2025,12 @@ class Indicador:
|
|
|
1778
2025
|
# Dibujo ----------------------------------------------------------------
|
|
1779
2026
|
def refrescar(self) -> bool:
|
|
1780
2027
|
datos = self.leer()
|
|
2028
|
+
# `leer_qm` devuelve una FRASE cuando no pudo: se muestra en el menú y
|
|
2029
|
+
# hasta acá no quedaba escrita en ningún lado. Si qm falla a las tres de
|
|
2030
|
+
# la mañana, mañana no hay forma de saber por qué.
|
|
2031
|
+
if isinstance(datos, str) and datos != getattr(self, "_ultimo_fallo", None):
|
|
2032
|
+
registrar("qm.sin-datos", motivo=datos[:110])
|
|
2033
|
+
self._ultimo_fallo = datos if isinstance(datos, str) else None
|
|
1781
2034
|
self.datos = datos
|
|
1782
2035
|
for hijo in self.menu.get_children():
|
|
1783
2036
|
self.menu.remove(hijo)
|
|
@@ -0,0 +1,19 @@
|
|
|
1
|
+
@echo off
|
|
2
|
+
rem Cerrar la bandeja.
|
|
3
|
+
rem
|
|
4
|
+
rem Existe por dos motivos, y el segundo es el que lo hace un archivo y no una
|
|
5
|
+
rem linea suelta adentro del desinstalador:
|
|
6
|
+
rem
|
|
7
|
+
rem 1. el usuario necesita poder cerrarla sin buscar el proceso a mano;
|
|
8
|
+
rem 2. el desinstalador TIENE que cerrarla antes de borrar nada. Un .ps1 que
|
|
9
|
+
rem un proceso tiene abierto no se puede borrar, asi que la desinstalacion
|
|
10
|
+
rem quedaria a medias y el icono seguiria en la bandeja sin programa
|
|
11
|
+
rem detras -- que es peor que no desinstalar.
|
|
12
|
+
rem
|
|
13
|
+
rem Se filtra por linea de comandos y NO por nombre de proceso: el que corre es
|
|
14
|
+
rem powershell.exe, igual que cualquier otro. Y se excluye el $PID propio
|
|
15
|
+
rem porque la linea de comandos de este mismo proceso contiene el texto que
|
|
16
|
+
rem estamos buscando: sin esa exclusion, lo primero que mata es a si mismo.
|
|
17
|
+
|
|
18
|
+
powershell -NoProfile -ExecutionPolicy Bypass -Command "Get-CimInstance Win32_Process | Where-Object { $_.Name -eq 'powershell.exe' -and $_.ProcessId -ne $PID -and $_.CommandLine -like '*qm-tray.ps1*' } | ForEach-Object { Stop-Process -Id $_.ProcessId -Force }" >nul 2>&1
|
|
19
|
+
exit /b 0
|
package/bin/qm-tray.cmd
ADDED
|
@@ -0,0 +1,20 @@
|
|
|
1
|
+
@echo off
|
|
2
|
+
rem Arrancar la bandeja, del lado de Windows y sin WSL.
|
|
3
|
+
rem
|
|
4
|
+
rem bin/qm-tray (sin extension) es el lanzador que se usa DESDE WSL: traduce
|
|
5
|
+
rem rutas con wslpath y le pasa -QmLinux al guion. Este es el otro lado: la
|
|
6
|
+
rem bandeja nativa, que resuelve sola donde esta qm (ver ResolverQm en
|
|
7
|
+
rem qm-tray.ps1) y no necesita que le digan nada.
|
|
8
|
+
rem
|
|
9
|
+
rem Existe porque un .lnk, un `scoop install` y un doble click necesitan algo
|
|
10
|
+
rem que se pueda ejecutar; un .ps1 suelto no lo es.
|
|
11
|
+
rem
|
|
12
|
+
rem El -WindowStyle Hidden deja una consola parpadeando un instante al arrancar:
|
|
13
|
+
rem es el precio de no empaquetar un .exe, y pasa una sola vez por sesion.
|
|
14
|
+
rem
|
|
15
|
+
rem Todo lo que se le pase viaja tal cual al guion, asi que esto anda:
|
|
16
|
+
rem qm-tray.cmd -Iconos general,codex
|
|
17
|
+
rem qm-tray.cmd -SinCalentar
|
|
18
|
+
|
|
19
|
+
start "" powershell -NoProfile -ExecutionPolicy Bypass -WindowStyle Hidden -File "%~dp0qm-tray.ps1" %*
|
|
20
|
+
exit /b 0
|