@legios/quartermaster 0.1.10 → 0.1.12
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 +24 -5
- package/bin/qm +21 -2
- package/bin/qm-barra.swift +21 -10
- package/bin/qm-indicator +247 -11
- package/bin/qm-tray.ps1 +14 -3
- package/dist/adapters/barra.js +142 -31
- package/dist/adapters/barra.js.map +1 -1
- package/dist/cli/qm.js +5 -0
- package/dist/cli/qm.js.map +1 -1
- package/dist/core/presupuesto.js +51 -6
- package/dist/core/presupuesto.js.map +1 -1
- package/dist/render/tablero.html +7 -2
- 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 +2 -1
- package/scripts/gate-presupuesto.py +433 -0
- package/scripts/mandar-pr-winget.mjs +106 -21
- package/src/render/tablero.html +7 -2
package/README.md
CHANGED
|
@@ -49,11 +49,30 @@ brew install legiosai/tap/quartermaster # macOS and Linux
|
|
|
49
49
|
npm install -g @legios/quartermaster # anywhere
|
|
50
50
|
```
|
|
51
51
|
|
|
52
|
-
**The
|
|
53
|
-
asks once whether to put it in the
|
|
54
|
-
install itself can't: brew can't start anything from a formula,
|
|
55
|
-
reads OAuth tokens shouldn't register login
|
|
56
|
-
question: `brew services start
|
|
52
|
+
**The bar item, on macOS and Linux:** the first time you run `qm` in a terminal,
|
|
53
|
+
it asks once whether to put it in the bar and start it at every login. The
|
|
54
|
+
install itself can't: brew can't start anything from a formula, the `.deb` drops
|
|
55
|
+
the files and leaves, and a tool that reads OAuth tokens shouldn't register login
|
|
56
|
+
agents nobody asked for. Without the question: `brew services start
|
|
57
|
+
quartermaster` on macOS, and on Linux
|
|
58
|
+
|
|
59
|
+
```sh
|
|
60
|
+
qm-indicator --instalar-extension # the item that opens the panel on click
|
|
61
|
+
qm-indicator --instalar-arranque # and start it once: qm-indicator &
|
|
62
|
+
```
|
|
63
|
+
|
|
64
|
+
Saying yes on Linux **also installs the GNOME extension**, which is what makes a
|
|
65
|
+
click open the panel: without it the item is hosted by AppIndicator and the click
|
|
66
|
+
falls through to the GTK menu — the one that does not hold the grab and closes
|
|
67
|
+
the moment you touch it. GNOME does not load a freshly installed extension on
|
|
68
|
+
Wayland, so when it had to be installed the closing line says so and you have to
|
|
69
|
+
log out once.
|
|
70
|
+
|
|
71
|
+
The question only appears when there is somewhere to show it: a graphical
|
|
72
|
+
session, `python3-gi` with `AyatanaAppIndicator3`, and a host for the item — an
|
|
73
|
+
extension already in place, or a GNOME Shell to install ours into. Without those
|
|
74
|
+
the process would start anyway and nothing would appear up there, which is worse
|
|
75
|
+
than not offering. `qm --diagnostico` says which one is missing.
|
|
57
76
|
|
|
58
77
|
**Windows:** the installer from the [latest
|
|
59
78
|
release](https://github.com/legiosai/quartermaster/releases/latest). Per-user
|
package/bin/qm
CHANGED
|
@@ -33,6 +33,25 @@ else
|
|
|
33
33
|
done
|
|
34
34
|
fi
|
|
35
35
|
|
|
36
|
+
# `src/adapters/opencode.ts` usa node:sqlite, que es experimental, así que Node
|
|
37
|
+
# escribe DOS renglones en stderr en cada corrida de qm:
|
|
38
|
+
#
|
|
39
|
+
# (node:56893) ExperimentalWarning: SQLite is an experimental feature…
|
|
40
|
+
# (Use `node --trace-warnings ...` to show where the warning was created)
|
|
41
|
+
#
|
|
42
|
+
# Eso no es un mensaje de qm y no es para quien lo corre, pero sale por el mismo
|
|
43
|
+
# canal por el que qm explica las cosas: desde 0.1.8 `qm --calentar` dice por ahí
|
|
44
|
+
# por qué una cuenta no se calentó, y la barra de macOS y el indicador de GNOME
|
|
45
|
+
# anotan esos renglones en el log. Medido el 2026-09-14 con Node 22 en Debian:
|
|
46
|
+
# el journal del indicador quedaba con dos renglones de warning por cada pid de
|
|
47
|
+
# node, y el motivo de verdad enterrado entre ellos. Un monitor cuyo canal de
|
|
48
|
+
# explicaciones viene con ruido de fábrica no se puede leer.
|
|
49
|
+
#
|
|
50
|
+
# Se apaga SÓLO esa clase de warning, no todas: una deprecación de verdad tiene
|
|
51
|
+
# que seguir saliendo. La bandera existe desde Node 21.3 y el piso de este repo
|
|
52
|
+
# es 22.6, así que siempre está.
|
|
53
|
+
SIN_EXPERIMENTAL="--disable-warning=ExperimentalWarning"
|
|
54
|
+
|
|
36
55
|
if [ -z "$NODO" ]; then
|
|
37
56
|
echo "qm necesita Node >= 22.6 y no encontré ninguno." >&2
|
|
38
57
|
echo "Lee TypeScript sin paso de build, y eso recién existe desde 22.6." >&2
|
|
@@ -77,7 +96,7 @@ if [ -f "$RAIZ/dist/cli/qm.js" ]; then
|
|
|
77
96
|
echo " Tus cambios en src/ NO se están viendo. Corré \`npm run construir\`," >&2
|
|
78
97
|
echo " o borrá dist/ para volver a leer el TypeScript directo." >&2
|
|
79
98
|
fi
|
|
80
|
-
exec "$NODO" "$RAIZ/dist/cli/qm.js" "$@"
|
|
99
|
+
exec "$NODO" $SIN_EXPERIMENTAL "$RAIZ/dist/cli/qm.js" "$@"
|
|
81
100
|
fi
|
|
82
101
|
|
|
83
|
-
exec "$NODO" "$RAIZ/src/cli/qm.ts" "$@"
|
|
102
|
+
exec "$NODO" $SIN_EXPERIMENTAL "$RAIZ/src/cli/qm.ts" "$@"
|
package/bin/qm-barra.swift
CHANGED
|
@@ -255,8 +255,11 @@ enum Presupuesto {
|
|
|
255
255
|
/// prendió la máquina. La diferencia es la que separa «gastaste 12 % hoy»
|
|
256
256
|
/// de «gastaste 12 % desde las 11:54», y no se puede borrar: llamar «hoy» a
|
|
257
257
|
/// un tramo que empieza al mediodía es decir de menos con cara de exacto.
|
|
258
|
-
|
|
259
|
-
|
|
258
|
+
/// `porDiaHoy` es el presupuesto fijado al arrancar la medición y `restante`
|
|
259
|
+
/// la resta ya hecha por qm. Restar `gastado` de `porDia` —que es el de ahora
|
|
260
|
+
/// en adelante y ya lo tiene descontado— contaba cada punto dos veces.
|
|
261
|
+
case reparte(porDia: Double, porDiaHoy: Double, quedaHoy: Double,
|
|
262
|
+
gastado: Double?, restante: Double?, desde: Date?, cubreElDia: Bool)
|
|
260
263
|
case no(String)
|
|
261
264
|
|
|
262
265
|
/// Qué parte del presupuesto de HOY ya se gastó, en porcentaje de ese
|
|
@@ -269,10 +272,10 @@ enum Presupuesto {
|
|
|
269
272
|
///
|
|
270
273
|
/// `nil` es «no se pudo medir» y deja la pista vacía, nunca un cero.
|
|
271
274
|
var pctDiario: Int? {
|
|
272
|
-
guard case let .reparte(
|
|
275
|
+
guard case let .reparte(_, porDiaHoy, _, gastado, _, _, _) = self, let g = gastado else { return nil }
|
|
273
276
|
// Sin presupuesto —la ventana ya está en 100 %— cualquier gasto es de más.
|
|
274
|
-
guard
|
|
275
|
-
return Int(max(0, min(100, (g /
|
|
277
|
+
guard porDiaHoy > 0 else { return g > 0 ? 100 : 0 }
|
|
278
|
+
return Int(max(0, min(100, (g / porDiaHoy * 100).rounded())))
|
|
276
279
|
}
|
|
277
280
|
}
|
|
278
281
|
|
|
@@ -448,9 +451,14 @@ func leer() -> Lectura {
|
|
|
448
451
|
// se midió aunque arranque más tarde, y es lo que dibuja el
|
|
449
452
|
// medidor: una máquina que se apaga de noche no tiene nunca el
|
|
450
453
|
// día entero, y un medidor que no dibuja nunca no es honesto.
|
|
451
|
-
|
|
454
|
+
let porDia = pp["porDia"] as? Double ?? 0
|
|
455
|
+
pre = .reparte(porDia: porDia,
|
|
456
|
+
// Un qm anterior no manda los dos campos nuevos: ahí
|
|
457
|
+
// queda la cuenta vieja antes que ninguna.
|
|
458
|
+
porDiaHoy: pp["porDiaHoy"] as? Double ?? porDia,
|
|
452
459
|
quedaHoy: pp["quedaHoy"] as? Double ?? 0,
|
|
453
460
|
gastado: pp["gastadoMedido"] as? Double,
|
|
461
|
+
restante: pp["restanteMedido"] as? Double,
|
|
454
462
|
desde: fecha(pp["medidoDesde"]),
|
|
455
463
|
cubreElDia: pp["cubreElDia"] as? Bool ?? false)
|
|
456
464
|
} else if let motivo = pp["motivo"] as? String {
|
|
@@ -648,7 +656,7 @@ final class VistaCuenta: NSView {
|
|
|
648
656
|
// y vuelven antes de llegar hasta acá.
|
|
649
657
|
if let pre = p.presupuesto, p.hayNumero {
|
|
650
658
|
switch pre {
|
|
651
|
-
case .reparte(let
|
|
659
|
+
case .reparte(_, let porDiaHoy, let quedaHoy, let gastado, let restante, let desde, let cubreElDia):
|
|
652
660
|
// Las mismas tres ramas que `frasePresupuesto` en el núcleo.
|
|
653
661
|
// «hoy te queda X %» se leía como una resta que no ocurría —era
|
|
654
662
|
// el reparto de las horas que faltaban del día, y bajaba solo
|
|
@@ -658,15 +666,18 @@ final class VistaCuenta: NSView {
|
|
|
658
666
|
// En DOS renglones, como la bandeja y GNOME: en uno solo el menú
|
|
659
667
|
// cortaba la frase justo en «te queda X %», que es el número que
|
|
660
668
|
// se viene a buscar. Visto en una captura del menú de la barra.
|
|
661
|
-
|
|
669
|
+
// `porDiaHoy` y `restante` vienen de qm: el presupuesto fijado al
|
|
670
|
+
// arrancar la medición y la resta ya hecha. `porDia - g` contaba
|
|
671
|
+
// dos veces lo gastado hoy; queda sólo para un qm anterior.
|
|
672
|
+
let dia = String(format: "podés gastar %.1f %%/día", porDiaHoy)
|
|
662
673
|
if let g = gastado, cubreElDia {
|
|
663
674
|
self.presupuesto = [dia, String(format: "gastaste %.1f %% hoy · te queda %.1f %%",
|
|
664
|
-
g, max(0,
|
|
675
|
+
g, restante ?? max(0, porDiaHoy - g))]
|
|
665
676
|
} else if let g = gastado, let d = desde {
|
|
666
677
|
let hhmm = DateFormatter()
|
|
667
678
|
hhmm.dateFormat = "HH:mm"
|
|
668
679
|
self.presupuesto = [dia, String(format: "gastaste %.1f %% desde las %@ · te queda %.1f %%",
|
|
669
|
-
g, hhmm.string(from: d), max(0,
|
|
680
|
+
g, hhmm.string(from: d), restante ?? max(0, porDiaHoy - g))]
|
|
670
681
|
} else {
|
|
671
682
|
self.presupuesto = [dia, String(format: "de acá a medianoche te toca %.1f %%", quedaHoy)]
|
|
672
683
|
}
|
package/bin/qm-indicator
CHANGED
|
@@ -192,7 +192,10 @@ def pct_diario(pre: dict | None) -> float | None:
|
|
|
192
192
|
gastado = pre.get("gastadoMedido")
|
|
193
193
|
if gastado is None:
|
|
194
194
|
return None
|
|
195
|
-
|
|
195
|
+
# El presupuesto de HOY, fijado al arrancar la medición. `porDia` es el de
|
|
196
|
+
# ahora en adelante y ya descontó lo gastado hoy: dividir por él contaba
|
|
197
|
+
# cada punto dos veces. `porDia` queda sólo para un qm anterior.
|
|
198
|
+
por_dia = pre.get("porDiaHoy", pre.get("porDia")) or 0
|
|
196
199
|
# Sin presupuesto —la ventana ya está en 100 %— cualquier gasto es de más.
|
|
197
200
|
if por_dia <= 0:
|
|
198
201
|
return 100.0 if gastado > 0 else 0.0
|
|
@@ -218,13 +221,19 @@ def renglones_presupuesto(pre: dict) -> list[str]:
|
|
|
218
221
|
# tarjeta muestra tres ventanas y el número reparte UNA, y sin decir cuál
|
|
219
222
|
# queda un 24.1 que no cierra con ninguno de los tres porcentajes de arriba.
|
|
220
223
|
barra = pre.get("barra")
|
|
221
|
-
|
|
224
|
+
# `porDiaHoy` y `restanteMedido`: el presupuesto fijado al arrancar la
|
|
225
|
+
# medición y la resta ya hecha por el núcleo. Restar de `porDia` contaba dos
|
|
226
|
+
# veces lo gastado hoy. Los de antes quedan para un qm anterior.
|
|
227
|
+
por_dia_hoy = pre.get("porDiaHoy", pre.get("porDia")) or 0
|
|
228
|
+
dia = f"podés gastar {por_dia_hoy:.1f} %/día" + (f" · {barra}" if barra else "")
|
|
222
229
|
gastado, restante = pre.get("gastadoHoy"), pre.get("restanteHoy")
|
|
223
230
|
if gastado is not None and restante is not None:
|
|
224
231
|
return [dia, f"gastaste {gastado:.1f} % hoy · te queda {restante:.1f} %"]
|
|
225
232
|
medido, desde = pre.get("gastadoMedido"), hora_local(pre.get("medidoDesde"))
|
|
226
233
|
if medido is not None and desde is not None:
|
|
227
|
-
queda =
|
|
234
|
+
queda = pre.get("restanteMedido")
|
|
235
|
+
if queda is None:
|
|
236
|
+
queda = max(0.0, por_dia_hoy - medido)
|
|
228
237
|
return [dia, f"gastaste {medido:.1f} % desde las {desde} · te queda {queda:.1f} %"]
|
|
229
238
|
return [dia, f"de acá a medianoche te toca {pre.get('quedaHoy', 0):.1f} %"]
|
|
230
239
|
|
|
@@ -1669,6 +1678,19 @@ class Indicador:
|
|
|
1669
1678
|
# Desde cuándo. Sin esto, una bandera que se queda pegada no se puede
|
|
1670
1679
|
# distinguir de un calentado que recién arrancó.
|
|
1671
1680
|
self.calentando_desde: int | None = None
|
|
1681
|
+
# Lo último que falló de cada cosa, para anotar CAMBIOS y no repetir, y
|
|
1682
|
+
# para poder decir cuándo volvió a andar. Un log que repite la misma
|
|
1683
|
+
# falla cada dos minutos no se lee, y uno que nunca dice «volvió» deja
|
|
1684
|
+
# cada falla abierta para siempre: leyéndolo mañana no hay forma de
|
|
1685
|
+
# saber si el problema duró un minuto o duró toda la noche.
|
|
1686
|
+
self._fallo_calentado: str | None = None
|
|
1687
|
+
self._fallo_lectura: str | None = None
|
|
1688
|
+
self._fallo_lectura_desde: float | None = None
|
|
1689
|
+
# Los motivos por cuenta que qm ya explicó en esta corrida. Van una vez
|
|
1690
|
+
# y no tienen «volvió»: los calentados alternan entre todas las cuentas
|
|
1691
|
+
# y sólo las que se mueven, así que que un motivo no aparezca NO dice
|
|
1692
|
+
# que se arregló.
|
|
1693
|
+
self._motivos_calentado: set[str] = set()
|
|
1672
1694
|
self.reloj: int | None = None
|
|
1673
1695
|
self.proxima_lectura: int | None = None
|
|
1674
1696
|
self.turno = 0
|
|
@@ -2062,27 +2084,67 @@ class Indicador:
|
|
|
2062
2084
|
args.append("--cuentas=" + ",".join(mueven))
|
|
2063
2085
|
registrar("calentar", cuentas=",".join(mueven) if mueven else "todas")
|
|
2064
2086
|
try:
|
|
2087
|
+
# El stderr se PIDE, no se tira. Desde 0.1.8 `qm --calentar` explica
|
|
2088
|
+
# ahí por qué una cuenta no se calentó —sin credencial, token
|
|
2089
|
+
# vencido—, y con STDERR_SILENCE esa explicación se iba a /dev/null:
|
|
2090
|
+
# la barra de macOS la anota desde esa misma versión y acá se
|
|
2091
|
+
# perdía.
|
|
2065
2092
|
proc = Gio.Subprocess.new(
|
|
2066
|
-
args, Gio.SubprocessFlags.STDOUT_SILENCE | Gio.SubprocessFlags.
|
|
2093
|
+
args, Gio.SubprocessFlags.STDOUT_SILENCE | Gio.SubprocessFlags.STDERR_PIPE
|
|
2067
2094
|
)
|
|
2068
|
-
except GLib.Error:
|
|
2095
|
+
except GLib.Error as e:
|
|
2096
|
+
self._anotar_calentado(f"no pude correr qm: {str(e).replace(chr(10), ' ')[:110]}")
|
|
2069
2097
|
self.programar_calentado()
|
|
2070
2098
|
return False
|
|
2071
2099
|
self.calentando = True
|
|
2072
2100
|
self.calentando_desde = GLib.get_monotonic_time()
|
|
2073
|
-
proc.
|
|
2101
|
+
proc.communicate_utf8_async(None, None, self._fin_calentado)
|
|
2074
2102
|
return False
|
|
2075
2103
|
|
|
2104
|
+
def _anotar_calentado(self, fallo: str | None) -> None:
|
|
2105
|
+
"""La falla del calentado, anotada cuando CAMBIA y con su vuelta."""
|
|
2106
|
+
if fallo == self._fallo_calentado:
|
|
2107
|
+
return
|
|
2108
|
+
if fallo is not None:
|
|
2109
|
+
registrar("calentar.fallo", motivo=fallo)
|
|
2110
|
+
else:
|
|
2111
|
+
registrar("calentar.volvio")
|
|
2112
|
+
self._fallo_calentado = fallo
|
|
2113
|
+
|
|
2076
2114
|
def _fin_calentado(self, proc, resultado) -> None:
|
|
2077
2115
|
self.calentando = False
|
|
2078
2116
|
self.calentando_desde = None
|
|
2117
|
+
fallo, dicho = None, ""
|
|
2079
2118
|
try:
|
|
2080
|
-
proc.
|
|
2119
|
+
_, _, dicho = proc.communicate_utf8_finish(resultado)
|
|
2081
2120
|
except GLib.Error as e:
|
|
2082
2121
|
# Se sigue mostrando lo viejo, con su edad a la vista — pero ahora
|
|
2083
2122
|
# queda anotado POR QUÉ quedó viejo. Este `except` se tragaba la
|
|
2084
2123
|
# única pista de que el refresco no estaba pasando.
|
|
2085
|
-
|
|
2124
|
+
fallo = str(e).replace("\n", " ")[:120]
|
|
2125
|
+
else:
|
|
2126
|
+
# Y acá estaba el agujero: NADA de esto tira. `wait_finish` y
|
|
2127
|
+
# `communicate_utf8_finish` devuelven bien con el hijo saliendo 1
|
|
2128
|
+
# —medido: exit=1, sin excepción—, así que el código de salida hay
|
|
2129
|
+
# que mirarlo a mano. Un `qm --calentar` que salía 1 no dejaba una
|
|
2130
|
+
# sola línea. Es justo lo que pasó en 0.1.9, cuando la barra mandaba
|
|
2131
|
+
# `--cuentas=personal` y el CLI comparaba `.claude-personal`: en
|
|
2132
|
+
# macOS se vio en el log y acá no había log que ver.
|
|
2133
|
+
if not proc.get_if_exited():
|
|
2134
|
+
fallo = f"lo mató la señal {proc.get_term_sig()}"
|
|
2135
|
+
elif proc.get_exit_status() != 0:
|
|
2136
|
+
primera = [l.strip() for l in (dicho or "").splitlines() if l.strip()]
|
|
2137
|
+
fallo = f"salió {proc.get_exit_status()}"
|
|
2138
|
+
if primera:
|
|
2139
|
+
fallo += f": {primera[0][:110]}"
|
|
2140
|
+
self._anotar_calentado(fallo)
|
|
2141
|
+
# Los motivos por cuenta van aunque el calentado haya salido 0: que una
|
|
2142
|
+
# cuenta no se pueda calentar no hace fallar a las otras, y sin esto la
|
|
2143
|
+
# única pista de que esa cuenta quedó afuera es un número viejo.
|
|
2144
|
+
for m in [l.strip() for l in (dicho or "").splitlines() if l.strip()]:
|
|
2145
|
+
if m not in self._motivos_calentado:
|
|
2146
|
+
self._motivos_calentado.add(m)
|
|
2147
|
+
registrar("calentar.cuenta", motivo=m[:110])
|
|
2086
2148
|
self.refrescar()
|
|
2087
2149
|
|
|
2088
2150
|
def disparar(self) -> bool:
|
|
@@ -2100,9 +2162,22 @@ class Indicador:
|
|
|
2100
2162
|
# `leer_qm` devuelve una FRASE cuando no pudo: se muestra en el menú y
|
|
2101
2163
|
# hasta acá no quedaba escrita en ningún lado. Si qm falla a las tres de
|
|
2102
2164
|
# la mañana, mañana no hay forma de saber por qué.
|
|
2103
|
-
if isinstance(datos, str)
|
|
2104
|
-
|
|
2105
|
-
|
|
2165
|
+
if isinstance(datos, str):
|
|
2166
|
+
if datos != self._fallo_lectura:
|
|
2167
|
+
registrar("qm.sin-datos", motivo=datos[:110])
|
|
2168
|
+
if self._fallo_lectura_desde is None:
|
|
2169
|
+
self._fallo_lectura_desde = time.time()
|
|
2170
|
+
self._fallo_lectura = datos
|
|
2171
|
+
else:
|
|
2172
|
+
# La caída ya se anotaba; la VUELTA no, y sin ella toda falla queda
|
|
2173
|
+
# abierta para siempre. Leyendo el journal al otro día no había
|
|
2174
|
+
# forma de saber si qm estuvo caído un minuto o toda la noche, que
|
|
2175
|
+
# es justo lo que se va a buscar. Con el rato que duró, que es el
|
|
2176
|
+
# número que contesta esa pregunta.
|
|
2177
|
+
if self._fallo_lectura is not None:
|
|
2178
|
+
registrar("qm.volvio", tras=duracion(int(time.time() - (self._fallo_lectura_desde or time.time()))))
|
|
2179
|
+
self._fallo_lectura = None
|
|
2180
|
+
self._fallo_lectura_desde = None
|
|
2106
2181
|
self.datos = datos
|
|
2107
2182
|
for hijo in self.menu.get_children():
|
|
2108
2183
|
self.menu.remove(hijo)
|
|
@@ -2350,7 +2425,163 @@ def leer_desde(ruta: str) -> dict:
|
|
|
2350
2425
|
return json.loads(pathlib.Path(ruta).read_text())
|
|
2351
2426
|
|
|
2352
2427
|
|
|
2428
|
+
ARRANQUE = Path(os.environ.get("XDG_CONFIG_HOME", str(Path.home() / ".config"))) \
|
|
2429
|
+
/ "autostart" / "quartermaster.desktop"
|
|
2430
|
+
|
|
2431
|
+
|
|
2432
|
+
def instalar_arranque() -> int:
|
|
2433
|
+
"""Que el item arranque solo al iniciar sesión.
|
|
2434
|
+
|
|
2435
|
+
Vive acá y no sólo en el Makefile porque quien instaló por apt o por npm no
|
|
2436
|
+
tiene un Makefile: el .deb deja bin/qm-indicator en /usr/lib/quartermaster y
|
|
2437
|
+
nada más, así que el item quedaba a un comando que hay que saber. Es el
|
|
2438
|
+
mismo agujero que en macOS tapó `qm-barra --instalar-arranque`, y `qm` lo
|
|
2439
|
+
ofrece en la primera corrida por el mismo camino.
|
|
2440
|
+
|
|
2441
|
+
El Exec apunta a ESTE archivo resuelto, no a `qm-indicator` a secas: el
|
|
2442
|
+
arranque de la sesión no pasa por el .zshrc del usuario, así que ~/.local/bin
|
|
2443
|
+
puede no estar en su PATH.
|
|
2444
|
+
"""
|
|
2445
|
+
try:
|
|
2446
|
+
ARRANQUE.parent.mkdir(parents=True, exist_ok=True)
|
|
2447
|
+
ARRANQUE.write_text(
|
|
2448
|
+
"[Desktop Entry]\n"
|
|
2449
|
+
"Type=Application\n"
|
|
2450
|
+
"Name=quartermaster\n"
|
|
2451
|
+
"Comment=Cuota de Claude Code en la barra de arriba\n"
|
|
2452
|
+
f"Exec={YO}\n"
|
|
2453
|
+
"Icon=utilities-system-monitor-symbolic\n"
|
|
2454
|
+
"Terminal=false\n"
|
|
2455
|
+
"X-GNOME-Autostart-enabled=true\n",
|
|
2456
|
+
encoding="utf-8")
|
|
2457
|
+
except OSError as e:
|
|
2458
|
+
print(f"no pude escribir {ARRANQUE}: {e}", file=sys.stderr)
|
|
2459
|
+
return 1
|
|
2460
|
+
print(f"{ARRANQUE} escrito")
|
|
2461
|
+
return 0
|
|
2462
|
+
|
|
2463
|
+
|
|
2464
|
+
def quitar_arranque() -> int:
|
|
2465
|
+
"""Lo contrario, porque instalar sin poder desinstalar no es una opción."""
|
|
2466
|
+
try:
|
|
2467
|
+
ARRANQUE.unlink()
|
|
2468
|
+
except FileNotFoundError:
|
|
2469
|
+
print(f"{ARRANQUE} no estaba")
|
|
2470
|
+
return 0
|
|
2471
|
+
except OSError as e:
|
|
2472
|
+
print(f"no pude borrar {ARRANQUE}: {e}", file=sys.stderr)
|
|
2473
|
+
return 1
|
|
2474
|
+
print(f"{ARRANQUE} borrado")
|
|
2475
|
+
return 0
|
|
2476
|
+
|
|
2477
|
+
|
|
2478
|
+
EXTENSION_UUID = "quartermaster@legios"
|
|
2479
|
+
EXTENSIONES = Path(os.environ.get("XDG_DATA_HOME", str(Path.home() / ".local/share"))) \
|
|
2480
|
+
/ "gnome-shell" / "extensions"
|
|
2481
|
+
#: De dónde sale la extensión: al lado del paquete, sea un clone, el .deb o npm.
|
|
2482
|
+
EXTENSION_FUENTE = YO.parent.parent / "extension" / EXTENSION_UUID
|
|
2483
|
+
|
|
2484
|
+
|
|
2485
|
+
def _habilitadas() -> list[str] | None:
|
|
2486
|
+
"""La lista de `enabled-extensions`, o None si no hay gsettings."""
|
|
2487
|
+
try:
|
|
2488
|
+
dicho = subprocess.run(
|
|
2489
|
+
["gsettings", "get", "org.gnome.shell", "enabled-extensions"],
|
|
2490
|
+
capture_output=True, text=True, timeout=5, check=True).stdout.strip()
|
|
2491
|
+
except (OSError, subprocess.SubprocessError):
|
|
2492
|
+
return None
|
|
2493
|
+
# `@as []` para la lista vacía, `['a', 'b']` para el resto.
|
|
2494
|
+
if dicho.startswith("@as"):
|
|
2495
|
+
dicho = dicho[3:].strip()
|
|
2496
|
+
return [x.strip().strip("'\"") for x in dicho.strip("[]").split(",") if x.strip()]
|
|
2497
|
+
|
|
2498
|
+
|
|
2499
|
+
def instalar_extension() -> int:
|
|
2500
|
+
"""El item propio en la barra: un click abre el panel.
|
|
2501
|
+
|
|
2502
|
+
Sin ella el item lo hospeda AppIndicator y el click izquierdo cae al menú de
|
|
2503
|
+
GTK, que no sostiene el agarre y se cierra apenas lo tocás — el síntoma que
|
|
2504
|
+
la extensión existe para evitar, escrito en su propio extension.js.
|
|
2505
|
+
|
|
2506
|
+
Vive acá y no sólo en el Makefile por lo mismo que `--instalar-arranque`:
|
|
2507
|
+
quien instaló por npm o por apt no tiene un Makefile.
|
|
2508
|
+
|
|
2509
|
+
Salidas: 0 habilitada y andando ya, 2 instalada pero GNOME la carga recién
|
|
2510
|
+
en la próxima sesión, 1 no se pudo. El 2 no es un error y no se puede
|
|
2511
|
+
esconder: decir «listo» de algo que no se ve hasta cerrar sesión es
|
|
2512
|
+
exactamente la mentira que este programa no comete.
|
|
2513
|
+
"""
|
|
2514
|
+
if not EXTENSION_FUENTE.is_dir():
|
|
2515
|
+
print(f"no encuentro la extensión en {EXTENSION_FUENTE}", file=sys.stderr)
|
|
2516
|
+
return 1
|
|
2517
|
+
destino = EXTENSIONES / EXTENSION_UUID
|
|
2518
|
+
try:
|
|
2519
|
+
EXTENSIONES.mkdir(parents=True, exist_ok=True)
|
|
2520
|
+
if destino.exists():
|
|
2521
|
+
shutil.rmtree(destino)
|
|
2522
|
+
shutil.copytree(EXTENSION_FUENTE, destino)
|
|
2523
|
+
except OSError as e:
|
|
2524
|
+
print(f"no pude copiarla a {destino}: {e}", file=sys.stderr)
|
|
2525
|
+
return 1
|
|
2526
|
+
|
|
2527
|
+
# Anotarla en la lista de habilitadas ANTES de pedir el enable: en Wayland
|
|
2528
|
+
# GNOME no carga una extensión recién copiada, así que `gnome-extensions
|
|
2529
|
+
# enable` falla con «doesn't exist» y sin esta anotación no quedaría puesta
|
|
2530
|
+
# tampoco para la próxima sesión.
|
|
2531
|
+
lista = _habilitadas()
|
|
2532
|
+
if lista is not None and EXTENSION_UUID not in lista:
|
|
2533
|
+
nueva = "[" + ", ".join(f"'{x}'" for x in [*lista, EXTENSION_UUID]) + "]"
|
|
2534
|
+
try:
|
|
2535
|
+
subprocess.run(["gsettings", "set", "org.gnome.shell", "enabled-extensions", nueva],
|
|
2536
|
+
capture_output=True, timeout=5, check=True)
|
|
2537
|
+
except (OSError, subprocess.SubprocessError) as e:
|
|
2538
|
+
print(f"no pude anotarla en enabled-extensions: {e}", file=sys.stderr)
|
|
2539
|
+
return 1
|
|
2540
|
+
|
|
2541
|
+
try:
|
|
2542
|
+
ok = subprocess.run(["gnome-extensions", "enable", EXTENSION_UUID],
|
|
2543
|
+
capture_output=True, timeout=5).returncode == 0
|
|
2544
|
+
except OSError:
|
|
2545
|
+
ok = False
|
|
2546
|
+
if ok:
|
|
2547
|
+
print(f"{EXTENSION_UUID} habilitada")
|
|
2548
|
+
return 0
|
|
2549
|
+
print(f"{EXTENSION_UUID} instalada y anotada. GNOME no carga extensiones "
|
|
2550
|
+
"nuevas en Wayland: cerrá sesión y volvé a entrar una vez.")
|
|
2551
|
+
return 2
|
|
2552
|
+
|
|
2553
|
+
|
|
2554
|
+
def quitar_extension() -> int:
|
|
2555
|
+
"""Saca el item propio y devuelve el de AppIndicator."""
|
|
2556
|
+
try:
|
|
2557
|
+
subprocess.run(["gnome-extensions", "disable", EXTENSION_UUID],
|
|
2558
|
+
capture_output=True, timeout=5)
|
|
2559
|
+
except OSError:
|
|
2560
|
+
pass
|
|
2561
|
+
destino = EXTENSIONES / EXTENSION_UUID
|
|
2562
|
+
try:
|
|
2563
|
+
if destino.exists():
|
|
2564
|
+
shutil.rmtree(destino)
|
|
2565
|
+
(CACHE / "extension-viva").unlink(missing_ok=True)
|
|
2566
|
+
except OSError as e:
|
|
2567
|
+
print(f"no pude borrarla: {e}", file=sys.stderr)
|
|
2568
|
+
return 1
|
|
2569
|
+
print(f"{EXTENSION_UUID} quitada")
|
|
2570
|
+
return 0
|
|
2571
|
+
|
|
2572
|
+
|
|
2353
2573
|
def main() -> int:
|
|
2574
|
+
# Antes que nada: ninguna de las dos necesita sesión gráfica ni un qm en el
|
|
2575
|
+
# PATH, y `qm` llama a la primera desde una terminal.
|
|
2576
|
+
if "--instalar-arranque" in sys.argv:
|
|
2577
|
+
return instalar_arranque()
|
|
2578
|
+
if "--quitar-arranque" in sys.argv:
|
|
2579
|
+
return quitar_arranque()
|
|
2580
|
+
if "--instalar-extension" in sys.argv:
|
|
2581
|
+
return instalar_extension()
|
|
2582
|
+
if "--quitar-extension" in sys.argv:
|
|
2583
|
+
return quitar_extension()
|
|
2584
|
+
|
|
2354
2585
|
fijo = None
|
|
2355
2586
|
if "--desde" in sys.argv:
|
|
2356
2587
|
i = sys.argv.index("--desde")
|
|
@@ -2401,6 +2632,11 @@ def main() -> int:
|
|
|
2401
2632
|
print("ya hay un quartermaster corriendo en esta sesión.", file=sys.stderr)
|
|
2402
2633
|
return 0
|
|
2403
2634
|
|
|
2635
|
+
# La primera línea del journal la pone systemd y dice el scope, no dice
|
|
2636
|
+
# QUÉ arrancó: ni qué qm encontró —puede haber uno en ~/.local/bin y otro
|
|
2637
|
+
# del paquete—, ni con qué tema, ni con qué pid. Leyendo el log de ayer eso
|
|
2638
|
+
# es lo primero que hace falta. La barra de macOS lo anota desde 0.1.8.
|
|
2639
|
+
registrar("arranca", qm=qm, pid=os.getpid(), tema="oscuro" if TEMA.oscuro else "claro")
|
|
2404
2640
|
Indicador(qm)
|
|
2405
2641
|
Gtk.main()
|
|
2406
2642
|
return 0
|
package/bin/qm-tray.ps1
CHANGED
|
@@ -484,7 +484,12 @@ function RenglonesPresupuesto($pre) {
|
|
|
484
484
|
# Invariante y no la cultura de la máquina, por lo mismo que el ritmo: el
|
|
485
485
|
# separador decimal acá es parte del dibujo y tiene que coincidir entre
|
|
486
486
|
# pantallas.
|
|
487
|
-
|
|
487
|
+
# El presupuesto de HOY es el que había al arrancar la medición (`porDiaHoy`):
|
|
488
|
+
# `porDia` es el de ahora en adelante y ya tiene descontado lo gastado hoy, así
|
|
489
|
+
# que restarle `gastadoMedido` contaba cada punto dos veces. El núcleo manda
|
|
490
|
+
# la resta hecha en `restanteMedido`; `porDia` queda para un qm anterior.
|
|
491
|
+
$porDiaHoy = if ($pre.PSObject.Properties['porDiaHoy'] -and $null -ne $pre.porDiaHoy) { [double]$pre.porDiaHoy } else { [double]$pre.porDia }
|
|
492
|
+
$porDia = $porDiaHoy.ToString('0.0', [cultureinfo]::InvariantCulture)
|
|
488
493
|
$un = { param($n) ([double]$n).ToString('0.0', [cultureinfo]::InvariantCulture) }
|
|
489
494
|
|
|
490
495
|
# Las mismas tres ramas que `frasePresupuesto` en el núcleo, y por el mismo
|
|
@@ -504,7 +509,12 @@ function RenglonesPresupuesto($pre) {
|
|
|
504
509
|
if ($pre.PSObject.Properties['gastadoMedido'] -and $null -ne $pre.gastadoMedido -and
|
|
505
510
|
$pre.PSObject.Properties['medidoDesde'] -and $null -ne $pre.medidoDesde) {
|
|
506
511
|
$desde = ([datetime]$pre.medidoDesde).ToLocalTime().ToString('HH:mm', [cultureinfo]::InvariantCulture)
|
|
507
|
-
|
|
512
|
+
# `0.0` y no `0`: con un entero de primer argumento PowerShell elige la
|
|
513
|
+
# sobrecarga [math]::Max(int, int) y le redondea el saldo al entero de
|
|
514
|
+
# abajo. Medido en el CI el 2026-09-14 con el JSON de un qm anterior:
|
|
515
|
+
# 14.3 - 14.0 daba «te queda 0.0 %» donde las otras cuatro pantallas
|
|
516
|
+
# decían 0.3. Se corta un presupuesto entero de menos de 1 %.
|
|
517
|
+
$queda = if ($pre.PSObject.Properties['restanteMedido'] -and $null -ne $pre.restanteMedido) { [double]$pre.restanteMedido } else { [math]::Max(0.0, $porDiaHoy - [double]$pre.gastadoMedido) }
|
|
508
518
|
return @($dia, "gastaste $(& $un $pre.gastadoMedido) % desde las $desde · te queda $(& $un $queda) %")
|
|
509
519
|
}
|
|
510
520
|
$hoy = ([double]$pre.quedaHoy).ToString('0.0', [cultureinfo]::InvariantCulture)
|
|
@@ -526,7 +536,8 @@ function PctDiario($pre) {
|
|
|
526
536
|
if (-not $pre.PSObject.Properties['estado'] -or $pre.estado -ne 'ok') { return $null }
|
|
527
537
|
if (-not $pre.PSObject.Properties['gastadoMedido'] -or $null -eq $pre.gastadoMedido) { return $null }
|
|
528
538
|
$gastado = [double]$pre.gastadoMedido
|
|
529
|
-
|
|
539
|
+
# El presupuesto de hoy, no el de ahora en adelante: ése ya descontó lo gastado.
|
|
540
|
+
$porDia = if ($pre.PSObject.Properties['porDiaHoy'] -and $null -ne $pre.porDiaHoy) { [double]$pre.porDiaHoy } else { [double]$pre.porDia }
|
|
530
541
|
# Sin presupuesto —la ventana ya está en 100 %— cualquier gasto es de más.
|
|
531
542
|
if ($porDia -le 0) { if ($gastado -gt 0) { return 100.0 } else { return 0.0 } }
|
|
532
543
|
return [math]::Max(0.0, [math]::Min(100.0, $gastado / $porDia * 100.0))
|