@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,76 @@
|
|
|
1
|
+
#!/usr/bin/env bash
|
|
2
|
+
# Cortar una versión: un comando, y de ahí salen todos los canales.
|
|
3
|
+
#
|
|
4
|
+
# ./scripts/cortar-release.sh 0.1.7
|
|
5
|
+
# ./scripts/cortar-release.sh patch
|
|
6
|
+
#
|
|
7
|
+
# Lo que hace acá: mover la versión a los siete lugares, correr los gates que se
|
|
8
|
+
# pueden correr en esta máquina, comitear y etiquetar. Lo que pasa después lo
|
|
9
|
+
# hace .github/workflows/release.yml, que con el tag publica en npm, arma el
|
|
10
|
+
# .deb y el instalador, crea la release y empuja a los canales que tengan su
|
|
11
|
+
# secreto configurado.
|
|
12
|
+
#
|
|
13
|
+
# POR QUÉ ETIQUETAR ES EL DISPARADOR. Porque es lo único que no se puede hacer
|
|
14
|
+
# por accidente: un push a main no publica nada, y un tag sí. Y porque el tag y
|
|
15
|
+
# el package.json tienen que decir lo mismo — el workflow lo comprueba antes de
|
|
16
|
+
# tocar nada, que es lo que evita publicar un paquete que no coincide con su
|
|
17
|
+
# release.
|
|
18
|
+
|
|
19
|
+
set -euo pipefail
|
|
20
|
+
raiz=$(cd "$(dirname "$0")/.." && pwd)
|
|
21
|
+
cd "$raiz"
|
|
22
|
+
|
|
23
|
+
pedido=${1:-}
|
|
24
|
+
if [ -z "$pedido" ]; then
|
|
25
|
+
echo "uso: $0 <versión|patch|minor|major>" >&2
|
|
26
|
+
echo "ahora: $(node -p "require('./package.json').version")" >&2
|
|
27
|
+
exit 2
|
|
28
|
+
fi
|
|
29
|
+
|
|
30
|
+
# ── que el árbol esté limpio ───────────────────────────────────────────
|
|
31
|
+
# Etiquetar con cambios sin comitear deja un tag que no corresponde a nada
|
|
32
|
+
# reproducible, y eso se descubre cuando alguien quiere volver a esa versión.
|
|
33
|
+
if [ -n "$(git status --porcelain)" ]; then
|
|
34
|
+
echo "✗ hay cambios sin comitear. Una versión se corta de un árbol limpio." >&2
|
|
35
|
+
git status --short >&2
|
|
36
|
+
exit 1
|
|
37
|
+
fi
|
|
38
|
+
|
|
39
|
+
rama=$(git rev-parse --abbrev-ref HEAD)
|
|
40
|
+
[ "$rama" = "main" ] || { echo "✗ estás en '$rama', no en main" >&2; exit 1; }
|
|
41
|
+
|
|
42
|
+
git fetch origin --quiet
|
|
43
|
+
if [ "$(git rev-parse HEAD)" != "$(git rev-parse origin/main)" ]; then
|
|
44
|
+
echo "✗ main y origin/main no están en el mismo commit" >&2
|
|
45
|
+
exit 1
|
|
46
|
+
fi
|
|
47
|
+
|
|
48
|
+
# ── mover la versión ───────────────────────────────────────────────────
|
|
49
|
+
echo "· moviendo la versión"
|
|
50
|
+
node scripts/bumpear.mjs "$pedido"
|
|
51
|
+
version=$(node -p "require('./package.json').version")
|
|
52
|
+
|
|
53
|
+
# ── los gates que corren acá ───────────────────────────────────────────
|
|
54
|
+
echo ""
|
|
55
|
+
echo "· los gates"
|
|
56
|
+
npm run --silent typecheck
|
|
57
|
+
npm test >/dev/null 2>&1 && echo " ✓ tests" || { echo " ✗ tests" >&2; exit 1; }
|
|
58
|
+
./scripts/gate-paquetes.sh | tail -1
|
|
59
|
+
./scripts/el-paquete-de-npm-corre.sh | tail -1
|
|
60
|
+
|
|
61
|
+
# ── comitear y etiquetar ───────────────────────────────────────────────
|
|
62
|
+
echo ""
|
|
63
|
+
git add -A
|
|
64
|
+
git commit -q -m "$version"
|
|
65
|
+
git tag -a "v$version" -m "quartermaster $version"
|
|
66
|
+
|
|
67
|
+
echo "· listo, local:"
|
|
68
|
+
git --no-pager log --oneline -1
|
|
69
|
+
echo ""
|
|
70
|
+
echo "Para soltarlo a todos los canales:"
|
|
71
|
+
echo ""
|
|
72
|
+
echo " git push origin main && git push origin v$version"
|
|
73
|
+
echo ""
|
|
74
|
+
echo "El tag dispara release.yml: npm (con provenance), el .deb, el instalador"
|
|
75
|
+
echo "de Windows, la release de GitHub, y los canales que tengan su secreto."
|
|
76
|
+
echo "Lo único que queda a mano es extensions.gnome.org, que no tiene API."
|
package/scripts/gate-bandeja.ps1
CHANGED
|
@@ -8,7 +8,7 @@ verde con un error de sintaxis adentro. Es exactamente lo que le pasó a
|
|
|
8
8
|
bin/qm-indicator antes de que existiera scripts/gate-dibujo.sh: se borró medio
|
|
9
9
|
archivo y el CI no se enteró, porque el CI ni lo abría.
|
|
10
10
|
|
|
11
|
-
|
|
11
|
+
Cinco cosas, en orden de qué tan barato es equivocarse:
|
|
12
12
|
|
|
13
13
|
1. que PARSEE — un error de sintaxis no llega a ejecutarse nunca;
|
|
14
14
|
2. que DIBUJE. Con una entrada fija el panel tiene que salir con las medidas
|
|
@@ -22,7 +22,11 @@ Cuatro cosas, en orden de qué tan barato es equivocarse:
|
|
|
22
22
|
afuera en vez de mirar la imagen a ojo;
|
|
23
23
|
4. que cada ícono tenga SU panel: el general con todas las cuentas y el de
|
|
24
24
|
una cuenta con esa sola. Es la diferencia entre cuatro íconos que sirven
|
|
25
|
-
y cuatro íconos que abren la misma pantalla
|
|
25
|
+
y cuatro íconos que abren la misma pantalla;
|
|
26
|
+
5. que sepa DÓNDE está qm. La bandeja corre el qm nativo de Windows o el de
|
|
27
|
+
adentro de WSL, y esa elección decide si hay números o no hay nada. Se
|
|
28
|
+
comprueba sacando las funciones por AST y corriéndolas contra un bin de
|
|
29
|
+
mentira, porque cargar el archivo entero levanta una bandeja de verdad.
|
|
26
30
|
|
|
27
31
|
Corre en Windows porque System.Drawing y WinForms son de Windows. En el runner
|
|
28
32
|
de Ubuntu se saltea diciéndolo — nunca se da por bueno en silencio.
|
|
@@ -162,11 +166,90 @@ if ($bmp) {
|
|
|
162
166
|
$bmp.Dispose()
|
|
163
167
|
}
|
|
164
168
|
|
|
169
|
+
# ── 5 · dónde busca a qm ────────────────────────────────────────────────
|
|
170
|
+
# La bandeja nació hablándole a WSL y `wsl.exe` estaba escrito a mano en los
|
|
171
|
+
# tres lugares que corren qm. Ahora elige entre el qm NATIVO de Windows y el de
|
|
172
|
+
# adentro de WSL, y esa elección es la que decide si el usuario ve números o no
|
|
173
|
+
# ve nada — o sea, exactamente la clase de cosa que no puede estar sin gate.
|
|
174
|
+
#
|
|
175
|
+
# No se puede comprobar cargando el archivo: al cargarlo levanta una bandeja y
|
|
176
|
+
# se queda en el bucle de mensajes. Así que se sacan las tres funciones por AST
|
|
177
|
+
# —no por recorte de texto, que se desincroniza sin avisar— y se corren en un
|
|
178
|
+
# scope de mentira con un qm.cmd de mentira. Es lo mismo que hace
|
|
179
|
+
# scripts/gate-duraciones.py con la escalera, por la misma razón.
|
|
180
|
+
$arbol = [System.Management.Automation.Language.Parser]::ParseFile($guion, [ref]$null, [ref]$null)
|
|
181
|
+
$queridas = @('ArgsWsl', 'ResolverQm', 'PsiQm')
|
|
182
|
+
$fns = $arbol.FindAll({
|
|
183
|
+
param($n)
|
|
184
|
+
$n -is [System.Management.Automation.Language.FunctionDefinitionAst] -and $queridas -contains $n.Name
|
|
185
|
+
}, $true)
|
|
186
|
+
if ($fns.Count -ne $queridas.Count) {
|
|
187
|
+
$hay = ($fns | ForEach-Object { $_.Name }) -join ', '
|
|
188
|
+
Fallar "esperaba las funciones $($queridas -join ', ') en bin/qm-tray.ps1 y encontré: $hay"
|
|
189
|
+
} else {
|
|
190
|
+
$cuerpo = ($fns | ForEach-Object { $_.Extent.Text }) -join "`n`n"
|
|
191
|
+
|
|
192
|
+
# Un bin de mentira CON ESPACIOS en la ruta: es el caso real —el instalador
|
|
193
|
+
# deja todo en «C:\Program Files\quartermaster\bin»— y es el que se rompe si
|
|
194
|
+
# alguien saca un par de comillas.
|
|
195
|
+
$binFalso = Join-Path $salida 'qm gate\bin'
|
|
196
|
+
New-Item -ItemType Directory -Path $binFalso -Force | Out-Null
|
|
197
|
+
Set-Content -Path (Join-Path $binFalso 'qm.cmd') -Value '@echo off' -Encoding ASCII
|
|
198
|
+
Set-Content -Path (Join-Path $binFalso 'qm-web.cmd') -Value '@echo off' -Encoding ASCII
|
|
199
|
+
|
|
200
|
+
function Resolver([hashtable]$escenario) {
|
|
201
|
+
$prologo = @"
|
|
202
|
+
Set-StrictMode -Version Latest
|
|
203
|
+
`$Qm = '$($escenario.Qm)'
|
|
204
|
+
`$QmLinux = '$($escenario.QmLinux)'
|
|
205
|
+
`$Distro = ''
|
|
206
|
+
`$script:PidieronQmLinux = `$$($escenario.PidieronQmLinux)
|
|
207
|
+
`$script:MiBin = '$($escenario.MiBin)'
|
|
208
|
+
`$script:QmResuelto = `$null
|
|
209
|
+
"@
|
|
210
|
+
$epilogo = @'
|
|
211
|
+
[pscustomobject]@{ R = (ResolverQm); Psi = (PsiQm '--json --breve'); Web = (PsiQm '--sin-abrir' 'web') }
|
|
212
|
+
'@
|
|
213
|
+
return & ([scriptblock]::Create("$prologo`n$cuerpo`n$epilogo"))
|
|
214
|
+
}
|
|
215
|
+
|
|
216
|
+
# a · nativo: el qm.cmd que está al lado gana, y la ruta con espacios viaja
|
|
217
|
+
# entera hasta la línea de comandos.
|
|
218
|
+
$a = Resolver @{ Qm = ''; QmLinux = 'qm'; PidieronQmLinux = 'false'; MiBin = $binFalso }
|
|
219
|
+
if ($a.R.Modo -ne 'nativo') {
|
|
220
|
+
Fallar "con un qm.cmd al lado la bandeja tiene que ir por Windows nativo y eligió '$($a.R.Modo)'"
|
|
221
|
+
} else {
|
|
222
|
+
$esperado = '/d /s /c ""' + (Join-Path $binFalso 'qm.cmd') + '" --json --breve"'
|
|
223
|
+
if ($a.Psi.Arguments -ne $esperado) {
|
|
224
|
+
Fallar "la línea nativa quedó mal citada.`n esperaba: $esperado`n salió: $($a.Psi.Arguments)"
|
|
225
|
+
}
|
|
226
|
+
if ($a.Web.Arguments -notmatch [regex]::Escape('qm-web.cmd')) {
|
|
227
|
+
Fallar "el tablero nativo no resolvió a qm-web.cmd: $($a.Web.Arguments)"
|
|
228
|
+
}
|
|
229
|
+
}
|
|
230
|
+
|
|
231
|
+
# b · WSL: pedir -QmLinux es pedir WSL, aunque haya un qm.cmd al lado. Es lo
|
|
232
|
+
# que hace bin/qm-tray, y romperlo deja sin bandeja a quien ya la tenía.
|
|
233
|
+
$b = Resolver @{ Qm = ''; QmLinux = 'qm'; PidieronQmLinux = 'true'; MiBin = $binFalso }
|
|
234
|
+
if ($b.R.Modo -ne 'wsl') { Fallar "con -QmLinux explícito el modo tiene que ser wsl y fue '$($b.R.Modo)'" }
|
|
235
|
+
elseif ($b.Psi.FileName -ne 'wsl.exe') { Fallar "el modo wsl no arranca wsl.exe sino '$($b.Psi.FileName)'" }
|
|
236
|
+
elseif ($b.Psi.Arguments -ne '-e bash -lc "qm --json --breve"') {
|
|
237
|
+
Fallar "la línea de WSL cambió: $($b.Psi.Arguments)"
|
|
238
|
+
}
|
|
239
|
+
|
|
240
|
+
# c · silencio es el bug: un -Qm que no existe tiene que dar una FRASE, no un
|
|
241
|
+
# PsiQm nulo que después dibuje un panel vacío sin explicar nada.
|
|
242
|
+
$c = Resolver @{ Qm = 'Z:\no\existe\qm.cmd'; QmLinux = 'qm'; PidieronQmLinux = 'false'; MiBin = $binFalso }
|
|
243
|
+
if ($c.R.Modo -ne 'ninguno') { Fallar "un -Qm inexistente no puede resolver a '$($c.R.Modo)'" }
|
|
244
|
+
elseif (-not $c.R.Motivo) { Fallar 'un -Qm inexistente se quedó sin frase: eso es el silencio que el repo no acepta' }
|
|
245
|
+
elseif ($null -ne $c.Psi) { Fallar 'sin qm, PsiQm tiene que devolver $null para que Leer conteste la frase' }
|
|
246
|
+
}
|
|
247
|
+
|
|
165
248
|
Remove-Item $salida -Recurse -Force -ErrorAction SilentlyContinue
|
|
166
249
|
|
|
167
250
|
if ($fallas.Count) {
|
|
168
251
|
foreach ($f in $fallas) { [Console]::Error.WriteLine("GATE ROJO: $f") }
|
|
169
252
|
exit 1
|
|
170
253
|
}
|
|
171
|
-
Write-Host "gate de la bandeja: verde — parsea, dibuja $ANCHO px en los dos temas, nada se sale del margen,
|
|
254
|
+
Write-Host "gate de la bandeja: verde — parsea, dibuja $ANCHO px en los dos temas, nada se sale del margen, el panel de una cuenta no es el de todas, y resuelve qm nativo / WSL / frase"
|
|
172
255
|
exit 0
|
|
@@ -0,0 +1,119 @@
|
|
|
1
|
+
"""A qué cuentas se les pregunta en el próximo calentado.
|
|
2
|
+
|
|
3
|
+
POR QUÉ EXISTE. `cadencia()` tiene un argumento correcto y escrito: una barra
|
|
4
|
+
en 100 % no puede subir, y el instante del reinicio ya lo sabemos sin
|
|
5
|
+
preguntar, así que no hay que sondearla cada minuto. Eso es un argumento sobre
|
|
6
|
+
CADA CUÁNTO. Se había colado en `calentar()` como un argumento sobre A QUIÉN
|
|
7
|
+
—`40 <= tope < 100`— y ahí es un bug: la cuenta frenada quedaba fuera de todos
|
|
8
|
+
los calentados, o sea que la única que no podía enterarse de que se liberó era
|
|
9
|
+
justo la que estaba esperando liberarse.
|
|
10
|
+
|
|
11
|
+
Medido el 2026-09-13 en una cuenta real: weekly_all 96 % y weekly_scoped 100 %,
|
|
12
|
+
las dos `critical`, con el `resets_at` dos horas atrás. Nueve horas diciendo
|
|
13
|
+
«estás frenado» a alguien que estaba libre. Un solo
|
|
14
|
+
`qm --calentar --cuentas=…` devolvió 2 % y 0 %, las dos `normal`.
|
|
15
|
+
|
|
16
|
+
Se ejecuta el código DE VERDAD, sacado de bin/qm-indicator, y no una copia:
|
|
17
|
+
una regla copiada a un test es una regla que se puede editar en un solo lado.
|
|
18
|
+
Probado en rojo: `make gate-calentado-rojo`.
|
|
19
|
+
"""
|
|
20
|
+
|
|
21
|
+
import pathlib
|
|
22
|
+
import re
|
|
23
|
+
import sys
|
|
24
|
+
import textwrap
|
|
25
|
+
from datetime import datetime, timedelta, timezone
|
|
26
|
+
|
|
27
|
+
RAIZ = pathlib.Path(__file__).resolve().parent.parent
|
|
28
|
+
FUENTE = (RAIZ / "bin/qm-indicator").read_text(encoding="utf-8")
|
|
29
|
+
|
|
30
|
+
|
|
31
|
+
def funcion(nombre: str) -> str:
|
|
32
|
+
r"""El cuerpo de un `def`, desde su línea hasta el primer renglón que vuelve
|
|
33
|
+
a un sangrado menor o igual. Sirve para métodos y para funciones sueltas.
|
|
34
|
+
|
|
35
|
+
La sangría se mide con `[ \t]*` y no con `\s*`: `\s` incluye el salto de
|
|
36
|
+
línea, así que la versión con `\s*` empezaba a contar desde el renglón
|
|
37
|
+
anterior y devolvía una sangría absurda —o directamente no encontraba el
|
|
38
|
+
método—. Se notó porque este gate extraía la cadena vacía y no se quejaba.
|
|
39
|
+
"""
|
|
40
|
+
m = re.search(rf"^([ \t]*)def {re.escape(nombre)}\(", FUENTE, re.MULTILINE)
|
|
41
|
+
if m is None:
|
|
42
|
+
raise SystemExit(f"✗ no encontré `def {nombre}(` en bin/qm-indicator")
|
|
43
|
+
sangria, i = len(m.group(1)), m.start()
|
|
44
|
+
lineas = FUENTE[i:].splitlines()
|
|
45
|
+
corte = len(lineas)
|
|
46
|
+
for n, linea in enumerate(lineas[1:], start=1):
|
|
47
|
+
if linea.strip() and (len(linea) - len(linea.lstrip())) <= sangria:
|
|
48
|
+
corte = n
|
|
49
|
+
break
|
|
50
|
+
cuerpo = textwrap.dedent("\n".join(lineas[:corte]))
|
|
51
|
+
if not cuerpo.strip():
|
|
52
|
+
raise SystemExit(f"✗ `{nombre}` salió vacía de bin/qm-indicator: la extracción está rota")
|
|
53
|
+
return cuerpo
|
|
54
|
+
|
|
55
|
+
|
|
56
|
+
ambito: dict = {"datetime": datetime, "timezone": timezone}
|
|
57
|
+
for nombre in ("faltan", "_tope", "_ya_reinicio", "_vale_preguntar"):
|
|
58
|
+
exec(compile(funcion(nombre), "qm-indicator", "exec"), ambito) # noqa: S102
|
|
59
|
+
|
|
60
|
+
# `_vale_preguntar` es un método y llama a `self._tope` y a `self._ya_reinicio`,
|
|
61
|
+
# así que se rearma la parte de la clase que necesita en vez de inventar un
|
|
62
|
+
# `self` falso.
|
|
63
|
+
class Indicador:
|
|
64
|
+
_tope = staticmethod(ambito["_tope"])
|
|
65
|
+
_ya_reinicio = staticmethod(ambito["_ya_reinicio"])
|
|
66
|
+
_vale_preguntar = ambito["_vale_preguntar"]
|
|
67
|
+
|
|
68
|
+
|
|
69
|
+
_vale = Indicador()._vale_preguntar
|
|
70
|
+
|
|
71
|
+
|
|
72
|
+
def iso(delta_horas: float) -> str:
|
|
73
|
+
return (datetime.now(timezone.utc) + timedelta(hours=delta_horas)).isoformat()
|
|
74
|
+
|
|
75
|
+
|
|
76
|
+
def pieza(sesion=None, semanal=None, r_sesion=None, r_semanal=None) -> dict:
|
|
77
|
+
return {
|
|
78
|
+
"perfil": ".claude", "sesion": sesion, "semanal": semanal,
|
|
79
|
+
"reinicia_sesion": r_sesion, "reinicia_semanal": r_semanal,
|
|
80
|
+
}
|
|
81
|
+
|
|
82
|
+
|
|
83
|
+
CASOS = [
|
|
84
|
+
# (qué es, pieza, se le pregunta?)
|
|
85
|
+
("una cuenta tranquila al 9 % no gasta un pedido",
|
|
86
|
+
pieza(sesion=9, semanal=9, r_sesion=iso(2), r_semanal=iso(50)), False),
|
|
87
|
+
("una cuenta al 60 %, con su ventana abierta, sí",
|
|
88
|
+
pieza(sesion=60, semanal=30, r_sesion=iso(2), r_semanal=iso(50)), True),
|
|
89
|
+
("una cuenta frenada al 100 % con la ventana TODAVÍA abierta, no: no puede subir",
|
|
90
|
+
pieza(sesion=20, semanal=100, r_sesion=iso(2), r_semanal=iso(50)), False),
|
|
91
|
+
("una cuenta frenada al 100 % cuya semanal YA se reinició: SÍ — es el caso del bug",
|
|
92
|
+
pieza(sesion=20, semanal=100, r_sesion=iso(2), r_semanal=iso(-2)), True),
|
|
93
|
+
("una cuenta al 9 % cuya sesión ya se reinició también: el número es de otra ventana",
|
|
94
|
+
pieza(sesion=9, semanal=9, r_sesion=iso(-1), r_semanal=iso(50)), True),
|
|
95
|
+
("sin fecha de reinicio no se puede afirmar que venció",
|
|
96
|
+
pieza(sesion=100, semanal=100, r_sesion=None, r_semanal=None), False),
|
|
97
|
+
]
|
|
98
|
+
|
|
99
|
+
fallas = 0
|
|
100
|
+
for que, t, esperado in CASOS:
|
|
101
|
+
real = _vale(t)
|
|
102
|
+
if real is esperado:
|
|
103
|
+
print(f" ✓ {que}")
|
|
104
|
+
else:
|
|
105
|
+
print(f"✗ {que}\n esperaba {esperado} y dio {real}", file=sys.stderr)
|
|
106
|
+
fallas += 1
|
|
107
|
+
|
|
108
|
+
# Y que el corte de arriba haya desaparecido de verdad del filtro. Si alguien
|
|
109
|
+
# reintroduce `< 100` en calentar(), los casos de arriba lo cazan igual, pero
|
|
110
|
+
# este mensaje dice DÓNDE.
|
|
111
|
+
if re.search(r"mueven\s*=.*<\s*100", FUENTE):
|
|
112
|
+
print("✗ calentar() volvió a filtrar por `< 100`: la cuenta frenada no se entera de que se liberó",
|
|
113
|
+
file=sys.stderr)
|
|
114
|
+
fallas += 1
|
|
115
|
+
|
|
116
|
+
if fallas:
|
|
117
|
+
print(f"\ngate de calentado: ROJO ({fallas})", file=sys.stderr)
|
|
118
|
+
raise SystemExit(1)
|
|
119
|
+
print("gate de calentado: verde — la cuenta frenada vuelve a preguntar apenas pasa su reinicio")
|
|
@@ -0,0 +1,118 @@
|
|
|
1
|
+
#!/usr/bin/env bash
|
|
2
|
+
# Gate de los paquetes que se mandan a catálogos ajenos.
|
|
3
|
+
#
|
|
4
|
+
# Estos archivos tienen una particularidad incómoda: **el error se descubre del
|
|
5
|
+
# otro lado**. Un PKGBUILD con el .SRCINFO desactualizado lo rechaza el AUR, un
|
|
6
|
+
# manifest de winget con la versión vieja apunta a un artefacto que no existe, y
|
|
7
|
+
# un metadata.json con "version" adentro lo devuelve extensions.gnome.org. En
|
|
8
|
+
# los tres casos hay una persona esperando y una vuelta entera perdida.
|
|
9
|
+
#
|
|
10
|
+
# Todo lo que se comprueba acá es de forma, y se comprueba porque la versión
|
|
11
|
+
# vive en SIETE lugares:
|
|
12
|
+
#
|
|
13
|
+
# package.json · PKGBUILD · .SRCINFO · el version-name de la extensión ·
|
|
14
|
+
# las dos landings · y los manifests que se generan
|
|
15
|
+
#
|
|
16
|
+
# Editar seis de siete no rompe nada visible. Ése es el problema.
|
|
17
|
+
|
|
18
|
+
set -euo pipefail
|
|
19
|
+
raiz=$(cd "$(dirname "$0")/.." && pwd)
|
|
20
|
+
cd "$raiz"
|
|
21
|
+
|
|
22
|
+
fallas=0
|
|
23
|
+
fallar() { echo "✗ $1" >&2; fallas=$((fallas + 1)); }
|
|
24
|
+
|
|
25
|
+
version=$(node -p "require('./package.json').version")
|
|
26
|
+
echo "· versión de package.json: $version"
|
|
27
|
+
|
|
28
|
+
# ── 1. la versión, en todos lados ──────────────────────────────────────
|
|
29
|
+
pkgver=$(sed -n 's/^pkgver=//p' paquetes/aur/PKGBUILD)
|
|
30
|
+
[ "$pkgver" = "$version" ] || fallar "el PKGBUILD dice $pkgver y package.json dice $version"
|
|
31
|
+
|
|
32
|
+
srcver=$(sed -n 's/^\tpkgver = //p' paquetes/aur/.SRCINFO)
|
|
33
|
+
[ "$srcver" = "$version" ] || fallar "el .SRCINFO dice $srcver y package.json dice $version"
|
|
34
|
+
|
|
35
|
+
extver=$(sed -n 's/.*"version-name"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' \
|
|
36
|
+
"extension/quartermaster@legios/metadata.json")
|
|
37
|
+
[ "$extver" = "$version" ] || fallar "el version-name de la extensión dice $extver"
|
|
38
|
+
|
|
39
|
+
for pagina in docs/index.html docs/es/index.html; do
|
|
40
|
+
if grep -q 'quartermaster-[0-9.]*-setup\.exe' "$pagina"; then
|
|
41
|
+
web=$(grep -o 'quartermaster-[0-9.]*-setup\.exe' "$pagina" | head -1 | sed 's/quartermaster-//; s/-setup\.exe//')
|
|
42
|
+
[ "$web" = "$version" ] || fallar "$pagina nombra el instalador $web"
|
|
43
|
+
fi
|
|
44
|
+
|
|
45
|
+
# Y el pie, que es lo que un lector toma por «la versión» sin abrir ninguna
|
|
46
|
+
# pestaña. Estaba fuera del gate, y es justo lo que le pasó: docs/es/index.html
|
|
47
|
+
# anunció v0.1.2 durante cuatro releases —con el nombre del instalador, el
|
|
48
|
+
# PKGBUILD, el .SRCINFO y la extensión los cuatro en 0.1.6— y el gate en verde.
|
|
49
|
+
# El nombre del instalador vive en una pestaña que hay que clickear; el pie
|
|
50
|
+
# está siempre a la vista.
|
|
51
|
+
pie=$(grep -o 'releases">v[0-9][0-9.]*</a>' "$pagina" | head -1 | sed 's|.*">v||; s|</a>||' || true)
|
|
52
|
+
if [ -z "$pie" ]; then
|
|
53
|
+
fallar "$pagina no dice ninguna versión en el pie (¿cambió la forma del enlace?)"
|
|
54
|
+
elif [ "$pie" != "$version" ]; then
|
|
55
|
+
fallar "$pagina dice v$pie en el pie y package.json dice $version"
|
|
56
|
+
fi
|
|
57
|
+
done
|
|
58
|
+
|
|
59
|
+
# ── 2. el PKGBUILD y el .SRCINFO, de acuerdo ───────────────────────────
|
|
60
|
+
# El AUR rechaza el push si no coinciden, y el mensaje no dice en qué campo.
|
|
61
|
+
pkgdesc=$(sed -n 's/^pkgdesc="\(.*\)"$/\1/p' paquetes/aur/PKGBUILD)
|
|
62
|
+
grep -qF "pkgdesc = $pkgdesc" paquetes/aur/.SRCINFO || fallar "el pkgdesc del .SRCINFO no es el del PKGBUILD"
|
|
63
|
+
|
|
64
|
+
# ── 3. la extensión, con lo que exige el sitio ─────────────────────────
|
|
65
|
+
python3 - <<'PY' || fallas=$((fallas + 1))
|
|
66
|
+
import json, sys
|
|
67
|
+
m = json.load(open('extension/quartermaster@legios/metadata.json', encoding='utf-8'))
|
|
68
|
+
mal = []
|
|
69
|
+
for k in ('uuid', 'name', 'description', 'shell-version', 'url'):
|
|
70
|
+
if k not in m: mal.append(f'falta {k}')
|
|
71
|
+
if 'version' in m:
|
|
72
|
+
mal.append('trae "version": ese número lo pone extensions.gnome.org, lo nuestro va en version-name')
|
|
73
|
+
if m.get('uuid') != 'quartermaster@legios':
|
|
74
|
+
mal.append('el uuid no coincide con el directorio')
|
|
75
|
+
for x in mal: print(f'✗ metadata.json: {x}', file=sys.stderr)
|
|
76
|
+
sys.exit(1 if mal else 0)
|
|
77
|
+
PY
|
|
78
|
+
|
|
79
|
+
# ── 4. los manifests se pueden generar ─────────────────────────────────
|
|
80
|
+
# Con hashes de mentira: lo que se comprueba es que el generador corra y que lo
|
|
81
|
+
# que sale sea YAML y JSON válidos con la versión correcta.
|
|
82
|
+
tmp=$(mktemp -d)
|
|
83
|
+
trap 'rm -rf "$tmp"' EXIT
|
|
84
|
+
falso=$(printf 'a%.0s' $(seq 64))
|
|
85
|
+
node scripts/hacer-manifests.mjs --exe "$falso" --zip "$falso" >/dev/null
|
|
86
|
+
dir="dist/paquetes/winget/manifests/l/Legios/Quartermaster/$version"
|
|
87
|
+
[ -d "$dir" ] || fallar "el generador no dejó $dir"
|
|
88
|
+
python3 - "$dir" "$version" <<'PY' || fallas=$((fallas + 1))
|
|
89
|
+
import json, sys, glob, os
|
|
90
|
+
dir, version = sys.argv[1], sys.argv[2]
|
|
91
|
+
try:
|
|
92
|
+
import yaml
|
|
93
|
+
except ImportError:
|
|
94
|
+
print('· (sin PyYAML: no se valida la forma del YAML de winget)')
|
|
95
|
+
yaml = None
|
|
96
|
+
mal = []
|
|
97
|
+
if yaml:
|
|
98
|
+
for f in glob.glob(os.path.join(dir, '*.yaml')):
|
|
99
|
+
d = yaml.safe_load(open(f, encoding='utf-8'))
|
|
100
|
+
if d.get('PackageVersion') != version:
|
|
101
|
+
mal.append(f'{os.path.basename(f)}: PackageVersion {d.get("PackageVersion")}')
|
|
102
|
+
if d.get('PackageIdentifier') != 'Legios.Quartermaster':
|
|
103
|
+
mal.append(f'{os.path.basename(f)}: PackageIdentifier {d.get("PackageIdentifier")}')
|
|
104
|
+
s = json.load(open('dist/paquetes/scoop/quartermaster.json', encoding='utf-8'))
|
|
105
|
+
if s.get('version') != version:
|
|
106
|
+
mal.append(f'scoop: version {s.get("version")}')
|
|
107
|
+
if version not in s.get('url', ''):
|
|
108
|
+
mal.append('scoop: la url no apunta a esta versión')
|
|
109
|
+
for x in mal: print('✗ ' + x, file=sys.stderr)
|
|
110
|
+
sys.exit(1 if mal else 0)
|
|
111
|
+
PY
|
|
112
|
+
|
|
113
|
+
if [ "$fallas" -ne 0 ]; then
|
|
114
|
+
echo "" >&2
|
|
115
|
+
echo "gate de paquetes: ROJO ($fallas)" >&2
|
|
116
|
+
exit 1
|
|
117
|
+
fi
|
|
118
|
+
echo "gate de paquetes: verde — la versión coincide en los siete lugares (pie de las dos landings incluido), el .SRCINFO va con el PKGBUILD, la extensión tiene la forma que pide el sitio, y los manifests se generan"
|
|
@@ -0,0 +1,198 @@
|
|
|
1
|
+
<#
|
|
2
|
+
El gate de Windows como PLATAFORMA, no como dibujo.
|
|
3
|
+
|
|
4
|
+
scripts/gate-bandeja.ps1 comprueba que la bandeja dibuje. Esto comprueba lo de
|
|
5
|
+
más abajo: que del lado de Windows exista un `qm` que arranque. Son dos cosas
|
|
6
|
+
distintas y la segunda estuvo rota todo este tiempo sin que nada la mirara.
|
|
7
|
+
|
|
8
|
+
Las tres cosas que se comprueban, y el defecto real que previene cada una:
|
|
9
|
+
|
|
10
|
+
1. `bin\qm.cmd` corre desde el repo. Hasta que existió, la única forma de
|
|
11
|
+
usar qm en Windows era escribir `node src\cli\qm.ts` a mano: está anotado
|
|
12
|
+
al final de numeros/h4-windows.md como lo que faltaba para que Windows
|
|
13
|
+
fuera una plataforma de primera y no un experimento.
|
|
14
|
+
|
|
15
|
+
2. `npm install -g` deja un comando que ARRANCA. Este es el defecto gordo:
|
|
16
|
+
npm arma los shims a partir del shebang, `bin/qm` es un `#!/bin/sh`, y el
|
|
17
|
+
.cmd que generaba invocaba `sh` — que no está en el PATH de una máquina
|
|
18
|
+
con Git for Windows instalado de la forma normal. O sea: instalaba bien y
|
|
19
|
+
no corría, que es exactamente la forma del defecto que H9 encontró en el
|
|
20
|
+
tarball. Por eso el gate INSTALA y EJECUTA, igual que
|
|
21
|
+
scripts/el-paquete-de-npm-corre.sh en Linux: que el tarball tenga los
|
|
22
|
+
archivos no prueba nada.
|
|
23
|
+
|
|
24
|
+
3. El código de salida sobrevive el viaje. `qm --umbral` sale 3 y hay gente
|
|
25
|
+
encadenando con eso; un lanzador que devuelve siempre 0 rompe eso en
|
|
26
|
+
silencio, que es la peor forma de romperlo.
|
|
27
|
+
|
|
28
|
+
Y una cuarta cosa que no es un chequeo sino una MEDICIÓN: qué hace el shim
|
|
29
|
+
viejo —el de `bin/qm`— en esta misma máquina. El cambio se hizo razonando sobre
|
|
30
|
+
cómo npm arma los shims, y razonar no es medir. No falla el gate: deja el
|
|
31
|
+
número en el log, que es lo que faltaba.
|
|
32
|
+
|
|
33
|
+
Corre en Windows y en ningún otro lado: es sobre cmd.exe y sobre los shims que
|
|
34
|
+
npm genera para Windows. En otra plataforma se saltea diciéndolo.
|
|
35
|
+
#>
|
|
36
|
+
|
|
37
|
+
[CmdletBinding()]
|
|
38
|
+
param()
|
|
39
|
+
|
|
40
|
+
Set-StrictMode -Version Latest
|
|
41
|
+
$ErrorActionPreference = 'Stop'
|
|
42
|
+
|
|
43
|
+
if ($env:OS -ne 'Windows_NT') {
|
|
44
|
+
Write-Host 'gate de Windows: se saltea, esto no es Windows'
|
|
45
|
+
exit 0
|
|
46
|
+
}
|
|
47
|
+
|
|
48
|
+
$raiz = Split-Path (Split-Path $PSCommandPath -Parent) -Parent
|
|
49
|
+
$fallas = @()
|
|
50
|
+
function Fallar([string]$que) { $script:fallas += $que }
|
|
51
|
+
|
|
52
|
+
# ── 1 · qm.cmd desde el repo ────────────────────────────────────────────
|
|
53
|
+
$qmcmd = Join-Path $raiz 'bin\qm.cmd'
|
|
54
|
+
if (-not (Test-Path -LiteralPath $qmcmd)) {
|
|
55
|
+
Fallar 'no está bin\qm.cmd: Windows vuelve a quedarse sin lanzador'
|
|
56
|
+
} else {
|
|
57
|
+
$salida = & cmd.exe /c "`"$qmcmd`" --breve" 2>&1 | Out-String
|
|
58
|
+
$codigo = $LASTEXITCODE
|
|
59
|
+
# 3 es «cruzaste el umbral», no un error; y en una máquina sin ninguna cuenta
|
|
60
|
+
# la salida puede ser una frase en vez de una tira de porcentajes. Lo que NO
|
|
61
|
+
# puede pasar es que no imprima nada o que reviente.
|
|
62
|
+
if ($codigo -ne 0 -and $codigo -ne 3) {
|
|
63
|
+
Fallar "bin\qm.cmd --breve salió $codigo`n$($salida.Trim())"
|
|
64
|
+
} elseif (-not $salida.Trim()) {
|
|
65
|
+
Fallar 'bin\qm.cmd --breve no imprimió nada: silencio es el bug'
|
|
66
|
+
} else {
|
|
67
|
+
Write-Host " ✓ bin\qm.cmd --breve: $($salida.Trim())"
|
|
68
|
+
}
|
|
69
|
+
|
|
70
|
+
# Una opción inventada tiene que salir 2 y explicar, no salir 0 en silencio.
|
|
71
|
+
& cmd.exe /c "`"$qmcmd`" --no-existe-esta-opcion" > $null 2>&1
|
|
72
|
+
if ($LASTEXITCODE -ne 2) {
|
|
73
|
+
Fallar "una opción desconocida tiene que salir 2 y salió $LASTEXITCODE : el código no está viajando"
|
|
74
|
+
} else {
|
|
75
|
+
Write-Host ' ✓ el código de salida viaja (2 con una opción desconocida)'
|
|
76
|
+
}
|
|
77
|
+
}
|
|
78
|
+
|
|
79
|
+
# ── 2 · el paquete de npm, instalado y corriendo ────────────────────────
|
|
80
|
+
$tmp = Join-Path ([System.IO.Path]::GetTempPath()) ("qm-win-" + [guid]::NewGuid().ToString('N'))
|
|
81
|
+
New-Item -ItemType Directory -Path $tmp -Force | Out-Null
|
|
82
|
+
try {
|
|
83
|
+
Push-Location $raiz
|
|
84
|
+
& npm run --silent construir | Out-Null
|
|
85
|
+
if ($LASTEXITCODE -ne 0) { throw "npm run construir salió $LASTEXITCODE" }
|
|
86
|
+
$tarball = (& npm pack --silent --pack-destination $tmp | Select-Object -Last 1).Trim()
|
|
87
|
+
if ($LASTEXITCODE -ne 0) { throw "npm pack salió $LASTEXITCODE" }
|
|
88
|
+
Pop-Location
|
|
89
|
+
|
|
90
|
+
$prefijo = Join-Path $tmp 'pref'
|
|
91
|
+
& npm i -g --silent --prefix $prefijo (Join-Path $tmp $tarball) | Out-Null
|
|
92
|
+
if ($LASTEXITCODE -ne 0) { throw "npm i -g salió $LASTEXITCODE" }
|
|
93
|
+
|
|
94
|
+
# En Windows npm deja los shims en la raíz del prefix, no en bin\.
|
|
95
|
+
$shim = Join-Path $prefijo 'qm.cmd'
|
|
96
|
+
if (-not (Test-Path -LiteralPath $shim)) {
|
|
97
|
+
Fallar "npm no dejó un qm.cmd en $prefijo — el comando no existe después de instalar"
|
|
98
|
+
} else {
|
|
99
|
+
$salida = & cmd.exe /c "`"$shim`" --breve" 2>&1 | Out-String
|
|
100
|
+
$codigo = $LASTEXITCODE
|
|
101
|
+
if ($codigo -ne 0 -and $codigo -ne 3) {
|
|
102
|
+
Fallar "el qm instalado por npm salió $codigo`n$($salida.Trim())"
|
|
103
|
+
} elseif (-not $salida.Trim()) {
|
|
104
|
+
Fallar 'el qm instalado por npm no imprimió nada'
|
|
105
|
+
} else {
|
|
106
|
+
Write-Host " ✓ qm --breve desde el paquete de npm: $($salida.Trim())"
|
|
107
|
+
}
|
|
108
|
+
}
|
|
109
|
+
} catch {
|
|
110
|
+
Fallar "el paquete de npm no se pudo probar: $($_.Exception.Message)"
|
|
111
|
+
} finally {
|
|
112
|
+
Remove-Item $tmp -Recurse -Force -ErrorAction SilentlyContinue
|
|
113
|
+
}
|
|
114
|
+
|
|
115
|
+
# ── 3 · qué hacía el shim viejo, MEDIDO y no supuesto ───────────────────
|
|
116
|
+
# El cambio de `bin/qm` a `bin/qm.mjs` como entrada de npm salió de un
|
|
117
|
+
# razonamiento: npm arma el shim desde el shebang, el shebang es `#!/bin/sh` y
|
|
118
|
+
# `sh` no tiene por qué estar en el PATH de Windows. Razonar no es medir, y
|
|
119
|
+
# este repo tiene una carpeta entera (numeros/) sobre esa diferencia.
|
|
120
|
+
#
|
|
121
|
+
# Ya está medido —en una VM de Windows 10 22H2 sin Git, ver
|
|
122
|
+
# numeros/h10-distribucion.md—: npm genera un qm.cmd que hace
|
|
123
|
+
#
|
|
124
|
+
# IF EXIST "%dp0%\/bin/sh.exe" ( SET "_prog=%dp0%\/bin/sh.exe" )
|
|
125
|
+
# ELSE ( SET "_prog=/bin/sh" )
|
|
126
|
+
#
|
|
127
|
+
# y al invocarlo sale 1 con «El sistema no puede encontrar la ruta
|
|
128
|
+
# especificada», sin una sola palabra sobre qué falta.
|
|
129
|
+
#
|
|
130
|
+
# Esto lo vuelve a medir en cada máquina donde corra. La primera respuesta que
|
|
131
|
+
# dio fue mejor que la hipótesis: en el runner de windows-latest, que SÍ tiene
|
|
132
|
+
# `C:\Program Files\Git\bin\sh.exe` en el PATH, el shim viejo falla igual. El
|
|
133
|
+
# .cmd que genera npm no busca `sh` en el PATH: invoca `/bin/sh`, una ruta
|
|
134
|
+
# POSIX absoluta, salvo que exista `%dp0%\/bin/sh.exe`, que no existe nunca. O
|
|
135
|
+
# sea que el defecto no era «Windows sin Git», era Windows.
|
|
136
|
+
#
|
|
137
|
+
# Aun así NO falla el gate: sigue siendo una medición del entorno y no una
|
|
138
|
+
# propiedad de este repo, y un rojo por cómo está armado el PATH de una máquina
|
|
139
|
+
# no diría nada útil. Lo que hace es dejar el número en el log.
|
|
140
|
+
#
|
|
141
|
+
# $ErrorActionPreference vuelve a Continue acá adentro a propósito: con 'Stop',
|
|
142
|
+
# la primera línea que el shim viejo escribe en stderr es un error terminante y
|
|
143
|
+
# la medición se convierte en «no se pudo medir» — que fue exactamente lo que
|
|
144
|
+
# pasó la primera vez que esto corrió.
|
|
145
|
+
$erroresAntes = $ErrorActionPreference
|
|
146
|
+
$ErrorActionPreference = 'Continue'
|
|
147
|
+
$tmp2 = Join-Path ([System.IO.Path]::GetTempPath()) ("qm-viejo-" + [guid]::NewGuid().ToString('N'))
|
|
148
|
+
New-Item -ItemType Directory -Path $tmp2 -Force | Out-Null
|
|
149
|
+
$paqueteJson = Join-Path $raiz 'package.json'
|
|
150
|
+
$respaldo = Get-Content $paqueteJson -Raw -Encoding UTF8
|
|
151
|
+
try {
|
|
152
|
+
$sh = Get-Command 'sh' -CommandType Application -ErrorAction SilentlyContinue | Select-Object -First 1
|
|
153
|
+
Write-Host (" · sh en el PATH de esta máquina: " + $(if ($sh) { $sh.Source } else { 'no hay' }))
|
|
154
|
+
|
|
155
|
+
# UTF8Encoding $false y no `Set-Content -Encoding UTF8`: en PowerShell 5.1 ese
|
|
156
|
+
# -Encoding UTF8 escribe CON BOM, así que el gate le agregaba un BOM al
|
|
157
|
+
# package.json del repo cada vez que corría. Medido: 1891 bytes con BOM
|
|
158
|
+
# después de una corrida, contra 1888 antes.
|
|
159
|
+
$sinBom = New-Object System.Text.UTF8Encoding $false
|
|
160
|
+
$j = $respaldo | ConvertFrom-Json
|
|
161
|
+
$j.bin.qm = 'bin/qm'
|
|
162
|
+
[IO.File]::WriteAllText($paqueteJson, ($j | ConvertTo-Json -Depth 10), $sinBom)
|
|
163
|
+
|
|
164
|
+
Push-Location $raiz
|
|
165
|
+
$tarballViejo = (& npm pack --silent --pack-destination $tmp2 | Select-Object -Last 1).Trim()
|
|
166
|
+
Pop-Location
|
|
167
|
+
$prefijoViejo = Join-Path $tmp2 'pref'
|
|
168
|
+
& npm i -g --silent --prefix $prefijoViejo (Join-Path $tmp2 $tarballViejo) 2>&1 | Out-Null
|
|
169
|
+
|
|
170
|
+
$shimViejo = Join-Path $prefijoViejo 'qm.cmd'
|
|
171
|
+
if (-not (Test-Path -LiteralPath $shimViejo)) {
|
|
172
|
+
Write-Host ' · con bin/qm (sh), npm no dejó ni un qm.cmd'
|
|
173
|
+
} else {
|
|
174
|
+
$salidaVieja = & cmd.exe /c "`"$shimViejo`" --breve" 2>&1 | Out-String
|
|
175
|
+
$codigoViejo = $LASTEXITCODE
|
|
176
|
+
if ($codigoViejo -eq 0 -or $codigoViejo -eq 3) {
|
|
177
|
+
Write-Host " · con bin/qm (sh) el shim TAMBIÉN arranca en esta máquina (salió $codigoViejo)"
|
|
178
|
+
} else {
|
|
179
|
+
Write-Host " · con bin/qm (sh) el shim NO arranca: salió $codigoViejo — $(($salidaVieja.Trim() -split "`n")[0])"
|
|
180
|
+
}
|
|
181
|
+
}
|
|
182
|
+
} catch {
|
|
183
|
+
Write-Host " · no se pudo medir el shim viejo: $($_.Exception.Message)"
|
|
184
|
+
} finally {
|
|
185
|
+
# El package.json se restaura pase lo que pase: dejarlo apuntando al bin
|
|
186
|
+
# viejo sería romper el paquete sin que nadie se entere hasta publicar. Byte
|
|
187
|
+
# por byte, sin BOM: ver el comentario de arriba.
|
|
188
|
+
[IO.File]::WriteAllText($paqueteJson, $respaldo, (New-Object System.Text.UTF8Encoding $false))
|
|
189
|
+
Remove-Item $tmp2 -Recurse -Force -ErrorAction SilentlyContinue
|
|
190
|
+
$ErrorActionPreference = $erroresAntes
|
|
191
|
+
}
|
|
192
|
+
|
|
193
|
+
if ($fallas.Count) {
|
|
194
|
+
foreach ($f in $fallas) { [Console]::Error.WriteLine("GATE ROJO: $f") }
|
|
195
|
+
exit 1
|
|
196
|
+
}
|
|
197
|
+
Write-Host 'gate de Windows: verde — qm.cmd corre desde el repo, el paquete de npm instala y arranca, y el código de salida viaja'
|
|
198
|
+
exit 0
|
package/scripts/hacer-deb.sh
CHANGED
|
@@ -33,6 +33,16 @@ cp README.md LICENSE "$arma/usr/share/doc/quartermaster/"
|
|
|
33
33
|
# alcanza y no hay que duplicar el árbol.
|
|
34
34
|
ln -sf /usr/lib/quartermaster/bin/qm "$arma/usr/bin/qm"
|
|
35
35
|
find "$arma/usr/lib/quartermaster" -name '__pycache__' -prune -exec rm -rf {} +
|
|
36
|
+
# Lo de Windows no tiene nada que hacer adentro de un .deb: los lanzadores .cmd,
|
|
37
|
+
# la bandeja y el ícono del instalador. Son ~150 kB de archivos que en esta
|
|
38
|
+
# máquina no los va a abrir nadie.
|
|
39
|
+
rm -f "$arma/usr/lib/quartermaster/bin/"*.cmd \
|
|
40
|
+
"$arma/usr/lib/quartermaster/bin/qm-tray.ps1" \
|
|
41
|
+
"$arma/usr/lib/quartermaster/bin/quartermaster.ico" \
|
|
42
|
+
"$arma/usr/lib/quartermaster/scripts/gate-bandeja.ps1" \
|
|
43
|
+
"$arma/usr/lib/quartermaster/scripts/gate-windows.ps1" \
|
|
44
|
+
"$arma/usr/lib/quartermaster/scripts/hacer-setup.ps1" \
|
|
45
|
+
"$arma/usr/lib/quartermaster/scripts/quartermaster.iss"
|
|
36
46
|
|
|
37
47
|
cat > "$arma/DEBIAN/control" <<EOF
|
|
38
48
|
Package: quartermaster
|