@legios/quartermaster 0.1.5 → 0.1.6

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.
@@ -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
@@ -105,6 +105,38 @@ def corto(nombre: str) -> str:
105
105
  return nombre.removeprefix(".claude").lstrip("-") or "main"
106
106
 
107
107
 
108
+ # ── el registro ──────────────────────────────────────────────────────────
109
+ #
110
+ # Este programa no anotaba NADA. Arrancado por el autostart queda como un scope
111
+ # de systemd, así que todo lo que escriba a stderr lo levanta el journal solo —
112
+ # pero en veinte horas de sesión el journal tenía dos renglones, los que pone
113
+ # systemd al abrir y cerrar el scope, porque el programa nunca dijo nada.
114
+ #
115
+ # Se notó reportando «toco Panel de cuota y se cierra al instante»: no había una
116
+ # sola línea que dijera si el panel había llegado a abrirse, ni cuánto había
117
+ # durado, ni por qué se había cerrado. Un monitor mudo es el bug que originó
118
+ # este repo; el monitor estaba mudo sobre sí mismo.
119
+ #
120
+ # Va a stderr y no a un archivo propio a propósito: el journal ya rota, ya
121
+ # fecha, ya lo sabe leer `journalctl --user`, y `qm --diagnostico` lo recoge de
122
+ # ahí. Un archivo nuestro sería una cosa más que mantener y que se llena sola.
123
+ #
124
+ # QM_SILENCIO=1 lo apaga. No hay nivel de detalle: son unos pocos eventos por
125
+ # apertura de panel, no una traza.
126
+ SILENCIO = os.environ.get("QM_SILENCIO") == "1"
127
+
128
+
129
+ def registrar(evento: str, **datos) -> None:
130
+ """Un evento por renglón, con sus datos. Nunca puede tirar."""
131
+ if SILENCIO:
132
+ return
133
+ try:
134
+ extra = " ".join(f"{k}={v}" for k, v in datos.items() if v is not None)
135
+ print(f"qm-indicator: {evento}{' ' + extra if extra else ''}", file=sys.stderr, flush=True)
136
+ except Exception: # noqa: BLE001 — registrar no puede romper al programa
137
+ pass
138
+
139
+
108
140
  def faltan(iso: str | None) -> int | None:
109
141
  if not iso:
110
142
  return None
@@ -926,6 +958,10 @@ def piezas_de(datos, avisar=None) -> list[dict]:
926
958
  "sesion_alerta": alerta(ses),
927
959
  "semanal": sem.get("porcentaje") if sem else None,
928
960
  "semanal_alerta": alerta(sem),
961
+ # Cuándo se reinicia cada una. Lo usa `calentar()` para saber si el
962
+ # número que tiene es de una ventana que ya cerró.
963
+ "reinicia_sesion": ses.get("reinicia") if ses else None,
964
+ "reinicia_semanal": sem.get("reinicia") if sem else None,
929
965
  "viejo": (cuota.get("edadSegundos") or 0) >= VIEJO_SEGUNDOS,
930
966
  })
931
967
  if avisar is not None:
@@ -1178,8 +1214,11 @@ class Panel:
1178
1214
  # Si el compositor le rompe el agarre —pasa cuando el foco se va al lado
1179
1215
  # Wayland— el menú tiene que cerrarse, no quedarse colgado arriba de
1180
1216
  # todo sin forma de sacarlo.
1181
- self.menu.connect("grab-broken-event", lambda *_: (self.menu.popdown(), False)[1])
1217
+ self.menu.connect("grab-broken-event", self._agarre_roto)
1182
1218
  self.menu.connect("unmap", self._al_cerrar)
1219
+ # Cuándo se abrió, para poder decir cuánto duró. Un panel que vive 40 ms
1220
+ # no es lo mismo que uno que el usuario cerró, y desde afuera se ven igual.
1221
+ self.abierto_en = 0
1183
1222
 
1184
1223
  @property
1185
1224
  def abierto(self) -> bool:
@@ -1196,7 +1235,24 @@ class Panel:
1196
1235
  except (AttributeError, TypeError):
1197
1236
  return False
1198
1237
 
1238
+ def _agarre_roto(self, *_):
1239
+ """El compositor le sacó el agarre al menú.
1240
+
1241
+ Es la firma del panel que «se cierra solo»: si esto llega a los pocos
1242
+ milisegundos de abrir, el panel no lo cerró el usuario.
1243
+ """
1244
+ registrar("panel.agarre-roto", vivio_ms=self._vivio_ms())
1245
+ self.menu.popdown()
1246
+ return False
1247
+
1248
+ def _vivio_ms(self) -> int | None:
1249
+ if not self.abierto_en:
1250
+ return None
1251
+ return int((GLib.get_monotonic_time() - self.abierto_en) / 1000)
1252
+
1199
1253
  def _al_cerrar(self, *_) -> None:
1254
+ registrar("panel.cerrado", vivio_ms=self._vivio_ms())
1255
+ self.abierto_en = 0
1200
1256
  self.cerrado = GLib.get_monotonic_time()
1201
1257
  if self.tictac is not None:
1202
1258
  GLib.source_remove(self.tictac)
@@ -1342,8 +1398,12 @@ class Panel:
1342
1398
  donde.x, donde.y, donde.width, donde.height = area.x + area.width - 6, area.y, 1, 1
1343
1399
  raiz = Gdk.get_default_root_window()
1344
1400
  if raiz is None: # sin X11 no hay dónde anclarlo; que lo ubique GTK
1401
+ registrar("panel.abierto", donde="puntero", raiz="sin-x11")
1402
+ self.abierto_en = GLib.get_monotonic_time()
1345
1403
  self.menu.popup_at_pointer(None)
1346
1404
  return
1405
+ registrar("panel.abierto", donde="arriba-derecha", alto=self.alto)
1406
+ self.abierto_en = GLib.get_monotonic_time()
1347
1407
  self.menu.popup_at_rect(raiz, donde, Gdk.Gravity.NORTH_EAST,
1348
1408
  Gdk.Gravity.NORTH_EAST, self._disparo(raiz))
1349
1409
  if self.tictac is None:
@@ -1698,6 +1758,46 @@ class Indicador:
1698
1758
  def _tope(t: dict) -> int:
1699
1759
  return max(t["sesion"] or 0, t["semanal"] or 0)
1700
1760
 
1761
+ @staticmethod
1762
+ def _ya_reinicio(t: dict) -> bool:
1763
+ """Si alguna de sus ventanas ya pasó su instante de reinicio.
1764
+
1765
+ El número guardado es de ANTES de ese instante, así que no es viejo: es
1766
+ de otra ventana, una que ya cerró. Ahí sí hay algo nuevo que leer.
1767
+ """
1768
+ for iso in (t.get("reinicia_sesion"), t.get("reinicia_semanal")):
1769
+ seg = faltan(iso)
1770
+ if seg is not None and seg <= 0:
1771
+ return True
1772
+ return False
1773
+
1774
+ def _vale_preguntar(self, t: dict) -> bool:
1775
+ """A qué cuentas se les pregunta en el próximo calentado.
1776
+
1777
+ El corte de abajo es ahorro: una cuenta al 9 % no da noticias.
1778
+
1779
+ El de arriba ERA un bug. `cadencia()` tiene razón en no sondear cada
1780
+ minuto una barra en 100 —no puede subir, y el instante del reinicio ya
1781
+ lo sabemos sin preguntar— pero eso es un argumento sobre CADA CUÁNTO, y
1782
+ se había colado acá como un argumento sobre A QUIÉN. Resultado: la
1783
+ cuenta frenada quedaba excluida de todos los calentados, o sea que la
1784
+ única que no podía enterarse de que se liberó era justo la que estaba
1785
+ esperando liberarse. Y «te liberaste» es el aviso más útil que da este
1786
+ programa.
1787
+
1788
+ Medido el 2026-09-13: una cuenta con weekly_all 96 % y weekly_scoped
1789
+ 100 % (las dos `critical`) siguió mostrando eso nueve horas, con el
1790
+ reinicio dos horas atrás. Un solo `qm --calentar --cuentas=…` devolvió
1791
+ 2 % y 0 %, las dos `normal`.
1792
+
1793
+ Así que el 100 % se saltea mientras su ventana siga abierta, y entra
1794
+ apenas pasa el reinicio — que es el único momento en que tiene algo
1795
+ nuevo para contar.
1796
+ """
1797
+ if self._ya_reinicio(t):
1798
+ return True
1799
+ return 40 <= self._tope(t) < 100
1800
+
1701
1801
  def cadencia(self) -> int:
1702
1802
  # Una barra que ya está en 100 no puede subir: hasta el reinicio no hay
1703
1803
  # nada nuevo que leer, y el instante del reinicio ya lo sabemos sin
@@ -1744,9 +1844,10 @@ class Indicador:
1744
1844
  args = [self.qm, "--calentar"]
1745
1845
  # Sólo las cuentas que se mueven: refrescar una que va al 9 % es gastar
1746
1846
  # un pedido para confirmar que no pasó nada.
1747
- mueven = [t["perfil"] for t in self.piezas if 40 <= self._tope(t) < 100]
1847
+ mueven = [t["perfil"] for t in self.piezas if self._vale_preguntar(t)]
1748
1848
  if mueven and len(mueven) != len(self.piezas):
1749
1849
  args.append("--cuentas=" + ",".join(mueven))
1850
+ registrar("calentar", cuentas=",".join(mueven) if mueven else "todas")
1750
1851
  try:
1751
1852
  proc = Gio.Subprocess.new(
1752
1853
  args, Gio.SubprocessFlags.STDOUT_SILENCE | Gio.SubprocessFlags.STDERR_SILENCE
@@ -1762,8 +1863,11 @@ class Indicador:
1762
1863
  self.calentando = False
1763
1864
  try:
1764
1865
  proc.wait_finish(resultado)
1765
- except GLib.Error:
1766
- pass # si el endpoint no contesta se sigue mostrando lo viejo, con su edad a la vista
1866
+ except GLib.Error as e:
1867
+ # Se sigue mostrando lo viejo, con su edad a la vista — pero ahora
1868
+ # queda anotado POR QUÉ quedó viejo. Este `except` se tragaba la
1869
+ # única pista de que el refresco no estaba pasando.
1870
+ registrar("calentar.fallo", motivo=str(e).replace("\n", " ")[:120])
1767
1871
  self.refrescar()
1768
1872
 
1769
1873
  def disparar(self) -> bool:
@@ -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
@@ -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
package/bin/qm-tray.ps1 CHANGED
@@ -22,9 +22,15 @@ Tres cosas que Windows hace distinto y conviene saber antes de leer el código:
22
22
  de batería), y el detalle va al tooltip y al menú.
23
23
 
24
24
  · No hay FileMonitor. El indicador de GNOME se entera en el acto porque vigila
25
- cada .claude.json con Gio.FileMonitor; desde Windows esos archivos están del
26
- otro lado del 9P de WSL, donde FileSystemWatcher no es confiable. Acá el
27
- sondeo es el mecanismo principal, no la red de seguridad.
25
+ cada .claude.json con Gio.FileMonitor; desde Windows esos archivos pueden
26
+ estar del otro lado del 9P de WSL, donde FileSystemWatcher no es confiable.
27
+ Acá el sondeo es el mecanismo principal, no la red de seguridad.
28
+
29
+ · Hay DOS lugares donde puede vivir qm, y la bandeja anda con los dos. En
30
+ Windows nativo corre `qm.cmd` (el que instala el instalador); desde WSL
31
+ corre `qm` adentro de la distro, que es como nació esto. La elección se
32
+ hace una sola vez en ResolverQm y no se repite en cada llamada — si no,
33
+ son tres lugares que pueden discrepar.
28
34
 
29
35
  · El calentado no puede bloquear. En macOS el refresco del endpoint va en una
30
36
  cola aparte; acá el timer corre en el hilo de la interfaz, así que
@@ -35,8 +41,17 @@ Tres cosas que Windows hace distinto y conviene saber antes de leer el código:
35
41
 
36
42
  [CmdletBinding()]
37
43
  param(
44
+ # Ruta de `qm.cmd`, el lanzador NATIVO de Windows. Vacío = se busca solo: al
45
+ # lado de este archivo primero (que es como lo deja el instalador) y en el
46
+ # PATH después. Ver ResolverQm.
47
+ [string]$Qm = '',
48
+
38
49
  # Ruta de `qm` ADENTRO de WSL. Por defecto se resuelve por PATH en un shell
39
50
  # de login, que es donde vive ~/.local/bin.
51
+ #
52
+ # PASARLO ES ELEGIR WSL: es lo que hace el lanzador bin/qm-tray, y es lo que
53
+ # distingue «vengo de WSL» de «me arrancó el instalador». Sin él, la bandeja
54
+ # prefiere el qm nativo si lo encuentra.
40
55
  [string]$QmLinux = 'qm',
41
56
  # Distro de WSL. Vacío = la default.
42
57
  [string]$Distro = '',
@@ -92,6 +107,17 @@ param(
92
107
  Set-StrictMode -Version Latest
93
108
  $ErrorActionPreference = 'Stop'
94
109
 
110
+ # ¿Pidieron explícitamente el qm de adentro de WSL? Se captura ACÁ, al nivel
111
+ # del script, y no adentro de ResolverQm: en una función $PSBoundParameters es
112
+ # el de la función, así que allá esta pregunta siempre daría «no».
113
+ $script:PidieronQmLinux = $PSBoundParameters.ContainsKey('QmLinux')
114
+
115
+ # El directorio donde vive este archivo, que es también donde el instalador
116
+ # deja qm.cmd. Va en una variable en vez de usar $PSScriptRoot directo por una
117
+ # razón concreta: así el gate puede apuntarlo a un directorio de mentira y
118
+ # comprobar la resolución entera sin instalar nada ni tener WSL.
119
+ $script:MiBin = $PSScriptRoot
120
+
95
121
  Add-Type -AssemblyName System.Windows.Forms
96
122
  Add-Type -AssemblyName System.Drawing
97
123
 
@@ -1172,6 +1198,117 @@ function ArgsWsl([string]$cmd) {
1172
1198
  return "$prefijo-e bash -lc `"$cmd`""
1173
1199
  }
1174
1200
 
1201
+ # ── de dónde sale el número: Windows nativo o WSL ───────────────────────
1202
+ #
1203
+ # Hasta acá esto era WSL y nada más: `wsl.exe` estaba escrito a mano en los tres
1204
+ # lugares que corren qm. Eso deja afuera al usuario de Windows NATIVO —el que
1205
+ # instala por winget y tiene Claude Code del lado de Windows— que es justo a
1206
+ # quien apunta tener un instalador. Y el CLI ya andaba nativo: está medido en
1207
+ # numeros/h4-windows.md, con `plataforma: win32`. Lo único que faltaba era
1208
+ # `qm.cmd`, que ahora existe.
1209
+ #
1210
+ # Cómo se elige, en orden, y por qué ese orden:
1211
+ #
1212
+ # 1. -Qm <ruta> lo que el usuario pidió explícitamente, gana siempre.
1213
+ # 2. -QmLinux <ruta> pedir el de adentro de WSL ES pedir WSL. Es lo que pasa
1214
+ # el lanzador bin/qm-tray, así que quien viene de WSL
1215
+ # sigue exactamente como antes.
1216
+ # 3. qm.cmd al lado el instalador deja los dos archivos en el mismo bin\.
1217
+ # 4. qm.cmd en el PATH un `scoop install` o un PATH puesto a mano.
1218
+ # 5. WSL lo de siempre, si hay wsl.exe.
1219
+ #
1220
+ # Si no hay ninguno NO se dibuja un cero: se devuelve una frase. Un ícono que
1221
+ # no encontró a qm y un ícono que encontró un 0 % se ven parecido y significan
1222
+ # cosas opuestas (SOUL.md: silencio es el bug).
1223
+ $script:QmResuelto = $null
1224
+
1225
+ function ResolverQm {
1226
+ if ($null -ne $script:QmResuelto) { return $script:QmResuelto }
1227
+
1228
+ $r = [pscustomobject]@{ Modo = 'ninguno'; Qm = ''; Web = ''; Motivo = '' }
1229
+ $nativo = ''
1230
+
1231
+ if ($Qm) {
1232
+ # 1. Lo que pidieron. Si no está, se dice cuál falta y se termina acá: ir a
1233
+ # buscar otro sería contestar una pregunta distinta de la que hicieron.
1234
+ if (Test-Path -LiteralPath $Qm) { $nativo = $Qm }
1235
+ else { $r.Motivo = "no existe el qm que me pasaste: $Qm" }
1236
+ } elseif ($script:PidieronQmLinux) {
1237
+ # 2. Pedir el de adentro de WSL es pedir WSL, exista o no wsl.exe. No se
1238
+ # comprueba a propósito: si falta, la frase que sale de intentar correrlo
1239
+ # dice qué pasó, y eso es mejor diagnóstico que «no encuentro nada».
1240
+ $r.Modo = 'wsl'
1241
+ $r.Qm = $QmLinux
1242
+ $r.Web = 'qm-web'
1243
+ } else {
1244
+ # 3 y 4. El qm.cmd que dejó el instalador al lado, o uno en el PATH.
1245
+ $alLado = Join-Path $script:MiBin 'qm.cmd'
1246
+ if (Test-Path -LiteralPath $alLado) {
1247
+ $nativo = $alLado
1248
+ } else {
1249
+ $enPath = Get-Command 'qm.cmd' -CommandType Application -ErrorAction SilentlyContinue |
1250
+ Select-Object -First 1
1251
+ if ($enPath) { $nativo = $enPath.Source }
1252
+ }
1253
+ # 5. Y si no hay nada nativo, WSL, que es de donde viene esta bandeja.
1254
+ if (-not $nativo) {
1255
+ if (Get-Command 'wsl.exe' -CommandType Application -ErrorAction SilentlyContinue) {
1256
+ $r.Modo = 'wsl'
1257
+ $r.Qm = $QmLinux
1258
+ $r.Web = 'qm-web'
1259
+ } else {
1260
+ $r.Motivo = 'no encuentro qm.cmd ni wsl.exe: instalá quartermaster o pasame -Qm <ruta>'
1261
+ }
1262
+ }
1263
+ }
1264
+
1265
+ if ($nativo) {
1266
+ $r.Modo = 'nativo'
1267
+ $r.Qm = $nativo
1268
+ # qm-web.cmd vive al lado de qm.cmd, siempre: los instala el mismo paquete.
1269
+ $web = Join-Path (Split-Path -Parent $nativo) 'qm-web.cmd'
1270
+ $r.Web = if (Test-Path -LiteralPath $web) { $web } else { '' }
1271
+ }
1272
+
1273
+ $script:QmResuelto = $r
1274
+ return $r
1275
+ }
1276
+
1277
+ <#
1278
+ Un ProcessStartInfo listo para correr qm (o qm-web) donde sea que esté.
1279
+
1280
+ Los tres lugares que corren qm —leer, calentar y abrir el tablero— pasan por
1281
+ acá, así que el modo se decide UNA vez y no tres. Es la misma razón por la que
1282
+ `mostrar` y `frena` se resuelven en el CLI y no en cada renderer: una regla en
1283
+ tres lugares es una regla que el día que se edita uno da tres respuestas.
1284
+
1285
+ En nativo va por cmd.exe y no directo: un .cmd no es un ejecutable para
1286
+ CreateProcess. Las comillas de más alrededor de todo son las que documenta
1287
+ `cmd /?` para que /s deje el resto intacto, y hacen falta porque la ruta de
1288
+ instalación por defecto tiene espacios.
1289
+ #>
1290
+ function PsiQm([string]$argumentos, [string]$programa = 'qm') {
1291
+ $r = ResolverQm
1292
+ if ($r.Modo -eq 'ninguno') { return $null }
1293
+
1294
+ $psi = New-Object System.Diagnostics.ProcessStartInfo
1295
+ if ($r.Modo -eq 'wsl') {
1296
+ $exe = if ($programa -eq 'web') { $r.Web } else { $r.Qm }
1297
+ $psi.FileName = 'wsl.exe'
1298
+ $psi.Arguments = ArgsWsl "$exe $argumentos"
1299
+ } else {
1300
+ $exe = if ($programa -eq 'web') { $r.Web } else { $r.Qm }
1301
+ if (-not $exe) { return $null }
1302
+ $comspec = $env:ComSpec
1303
+ if (-not $comspec) { $comspec = 'cmd.exe' }
1304
+ $psi.FileName = $comspec
1305
+ $psi.Arguments = "/d /s /c `"`"$exe`" $argumentos`""
1306
+ }
1307
+ $psi.UseShellExecute = $false
1308
+ $psi.CreateNoWindow = $true
1309
+ return $psi
1310
+ }
1311
+
1175
1312
  function Leer {
1176
1313
  # Devuelve el objeto del JSON, o un string con la frase del problema.
1177
1314
  # Silencio es el bug (SOUL.md): si no hay número, hay una frase.
@@ -1186,13 +1323,10 @@ function Leer {
1186
1323
  return ($texto | ConvertFrom-Json)
1187
1324
  }
1188
1325
 
1189
- $psi = New-Object System.Diagnostics.ProcessStartInfo
1190
- $psi.FileName = 'wsl.exe'
1191
- $psi.Arguments = ArgsWsl "$QmLinux --json --breve"
1326
+ $psi = PsiQm '--json --breve'
1327
+ if ($null -eq $psi) { return (ResolverQm).Motivo }
1192
1328
  $psi.RedirectStandardOutput = $true
1193
1329
  $psi.RedirectStandardError = $true
1194
- $psi.UseShellExecute = $false
1195
- $psi.CreateNoWindow = $true
1196
1330
  $psi.StandardOutputEncoding = [System.Text.Encoding]::UTF8
1197
1331
  $psi.StandardErrorEncoding = [System.Text.Encoding]::UTF8
1198
1332
  try {
@@ -1254,13 +1388,10 @@ function Calentar([switch]$Forzado) {
1254
1388
  # Sólo las cuentas que se mueven. Refrescar una que va al 9 % es gastar un
1255
1389
  # pedido para confirmar que no pasó nada.
1256
1390
  $cmd = if ($script:CuentasQueMueven.Count) {
1257
- "$QmLinux --calentar --cuentas=" + ($script:CuentasQueMueven -join ',')
1258
- } else { "$QmLinux --calentar" }
1259
- $psi = New-Object System.Diagnostics.ProcessStartInfo
1260
- $psi.FileName = 'wsl.exe'
1261
- $psi.Arguments = ArgsWsl $cmd
1262
- $psi.UseShellExecute = $false
1263
- $psi.CreateNoWindow = $true
1391
+ '--calentar --cuentas=' + ($script:CuentasQueMueven -join ',')
1392
+ } else { '--calentar' }
1393
+ $psi = PsiQm $cmd
1394
+ if ($null -eq $psi) { return $null }
1264
1395
  try { return [System.Diagnostics.Process]::Start($psi) } catch { return $null }
1265
1396
  }
1266
1397
 
@@ -2007,12 +2138,10 @@ function AbrirTablero {
2007
2138
  $c.Close()
2008
2139
  } catch { $vivo = $false }
2009
2140
  if (-not $vivo) {
2010
- $psi = New-Object System.Diagnostics.ProcessStartInfo
2011
- $psi.FileName = 'wsl.exe'
2012
- $psi.Arguments = ArgsWsl "qm-web --sin-abrir --puerto=$Puerto"
2013
- $psi.UseShellExecute = $false
2014
- $psi.CreateNoWindow = $true
2015
- try { [System.Diagnostics.Process]::Start($psi) | Out-Null; Start-Sleep -Milliseconds 1200 } catch { }
2141
+ $psi = PsiQm "--sin-abrir --puerto=$Puerto" 'web'
2142
+ if ($null -ne $psi) {
2143
+ try { [System.Diagnostics.Process]::Start($psi) | Out-Null; Start-Sleep -Milliseconds 1200 } catch { }
2144
+ }
2016
2145
  }
2017
2146
  Start-Process "http://127.0.0.1:$Puerto"
2018
2147
  }
package/bin/qm-web CHANGED
@@ -27,7 +27,30 @@ const PAGINA = [
27
27
  path.join(RAIZ, 'dist', 'render', 'tablero.html'),
28
28
  path.join(RAIZ, 'src', 'render', 'tablero.html'),
29
29
  ].find((p) => fs.existsSync(p)) ?? path.join(RAIZ, 'src', 'render', 'tablero.html');
30
- const QM = path.join(RAIZ, 'bin', 'qm');
30
+ // El lanzador de esta plataforma. En Windows es el .cmd: `bin/qm` es un
31
+ // /bin/sh y ahí no hay quién lo corra.
32
+ const enWindows = process.platform === 'win32';
33
+ const QM = path.join(RAIZ, 'bin', enWindows ? 'qm.cmd' : 'qm');
34
+
35
+ /**
36
+ * Correr `qm` con argumentos, sin que la plataforma se note río abajo.
37
+ *
38
+ * En Windows un .cmd no se puede lanzar directo —Node lo rechaza desde la
39
+ * 18.20/20.12— así que va por cmd.exe. Las comillas de más alrededor de todo
40
+ * son las que documenta `cmd /?` para que /s no toque el resto: sin ellas una
41
+ * ruta con espacios —la que deja el instalador por defecto— se parte en dos.
42
+ */
43
+ function correrQm(args, opts, cb) {
44
+ if (!enWindows) return execFile(QM, args, opts, cb);
45
+ const citar = (s) => `"${String(s).replace(/"/g, '""')}"`;
46
+ const linea = [citar(QM), ...args.map(citar)].join(' ');
47
+ return execFile(
48
+ process.env.ComSpec || 'cmd.exe',
49
+ ['/d', '/s', '/c', `"${linea}"`],
50
+ { ...opts, windowsVerbatimArguments: true },
51
+ cb,
52
+ );
53
+ }
31
54
 
32
55
  const AYUDA = `qm-web · el tablero de quartermaster en el navegador
33
56
 
@@ -58,7 +81,7 @@ let enVuelo = null;
58
81
  function estado() {
59
82
  if (enVuelo) return enVuelo;
60
83
  enVuelo = new Promise((resolver) => {
61
- execFile(QM, ['--json', `--dias=${opciones.dias}`], { maxBuffer: 32 << 20 }, (err, salida, errSalida) => {
84
+ correrQm(['--json', `--dias=${opciones.dias}`], { maxBuffer: 32 << 20 }, (err, salida, errSalida) => {
62
85
  enVuelo = null;
63
86
  if (err && !salida) {
64
87
  // Silencio es el bug (SOUL.md): si no hay número, hay una frase.
package/bin/qm-web.cmd ADDED
@@ -0,0 +1,22 @@
1
+ @echo off
2
+ rem El tablero en el navegador, del lado de Windows.
3
+ rem
4
+ rem bin/qm-web es JavaScript comun con shebang de Node, asi que en POSIX se
5
+ rem ejecuta solo. En Windows el shebang no significa nada: hace falta alguien
6
+ rem que encuentre el node.exe y se lo pase. Eso es todo lo que hace esto.
7
+ rem
8
+ rem El tablero es la superficie que anda en cualquier maquina: si la bandeja no
9
+ rem aparece --Windows manda los iconos nuevos al desplegable de escondidos-- esta
10
+ rem sigue estando, y es la que usa el menu "Abrir el tablero".
11
+ rem
12
+ rem ASCII puro a proposito: ver el encabezado de buscar-node.cmd.
13
+
14
+ setlocal
15
+
16
+ set "RAIZ=%~dp0.."
17
+
18
+ call "%~dp0buscar-node.cmd"
19
+ if not defined NODO exit /b 1
20
+
21
+ "%NODO%" "%RAIZ%\bin\qm-web" %*
22
+ exit /b %ERRORLEVEL%