@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 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 menu bar item on macOS:** the first time you run `qm` in a terminal, it
53
- asks once whether to put it in the menu bar and start it at every login. The
54
- install itself can't: brew can't start anything from a formula, and a tool that
55
- reads OAuth tokens shouldn't register login agents nobody asked for. Without the
56
- question: `brew services start quartermaster`.
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" "$@"
@@ -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
- case reparte(porDia: Double, quedaHoy: Double,
259
- gastado: Double?, desde: Date?, cubreElDia: Bool)
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(porDia, _, gastado, _, _) = self, let g = gastado else { return nil }
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 porDia > 0 else { return g > 0 ? 100 : 0 }
275
- return Int(max(0, min(100, (g / porDia * 100).rounded())))
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
- pre = .reparte(porDia: pp["porDia"] as? Double ?? 0,
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 porDia, let quedaHoy, let gastado, let desde, let cubreElDia):
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
- let dia = String(format: "podés gastar %.1f %%/día", porDia)
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, porDia - g))]
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, porDia - g))]
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
- por_dia = pre.get("porDia") or 0
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
- dia = f"podés gastar {pre.get('porDia', 0):.1f} %/día" + (f" · {barra}" if barra else "")
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 = max(0.0, (pre.get("porDia") or 0) - medido)
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.STDERR_SILENCE
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.wait_async(None, self._fin_calentado)
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.wait_finish(resultado)
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
- registrar("calentar.fallo", motivo=str(e).replace("\n", " ")[:120])
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) and datos != getattr(self, "_ultimo_fallo", None):
2104
- registrar("qm.sin-datos", motivo=datos[:110])
2105
- self._ultimo_fallo = datos if isinstance(datos, str) else None
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
- $porDia = ([double]$pre.porDia).ToString('0.0', [cultureinfo]::InvariantCulture)
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
- $queda = [math]::Max(0, [double]$pre.porDia - [double]$pre.gastadoMedido)
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
- $porDia = [double]$pre.porDia
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))