@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.
- package/README.md +165 -1448
- package/bin/buscar-node.cmd +80 -0
- package/bin/qm +17 -0
- package/bin/qm-barra +38 -0
- package/bin/qm-indicator +108 -4
- 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/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/cli/qm.js +152 -2
- package/dist/cli/qm.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 +119 -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/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
|
@@ -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",
|
|
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
|
|
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
|
-
|
|
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
|
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
|
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
|
|
26
|
-
otro lado del 9P de WSL, donde FileSystemWatcher no es confiable.
|
|
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 =
|
|
1190
|
-
$psi
|
|
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
|
-
|
|
1258
|
-
} else {
|
|
1259
|
-
$psi =
|
|
1260
|
-
$psi
|
|
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 =
|
|
2011
|
-
$psi
|
|
2012
|
-
|
|
2013
|
-
|
|
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
|
-
|
|
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
|
-
|
|
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%
|