@legios/quartermaster 0.1.4 → 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 -1175
- package/bin/buscar-node.cmd +80 -0
- package/bin/qm +17 -0
- package/bin/qm-barra +38 -0
- package/bin/qm-barra.swift +48 -1
- package/bin/qm-indicator +131 -5
- package/bin/qm-tray-quitar.cmd +19 -0
- package/bin/qm-tray.cmd +20 -0
- package/bin/qm-tray.ps1 +1402 -273
- 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 +190 -2
- package/dist/cli/qm.js.map +1 -1
- package/dist/core/presupuesto.js +75 -0
- package/dist/core/presupuesto.js.map +1 -0
- package/dist/core/tipos.js +43 -2
- package/dist/core/tipos.js.map +1 -1
- package/dist/render/tablero.html +68 -6
- package/package.json +6 -3
- package/scripts/bumpear.mjs +127 -0
- package/scripts/construir.mjs +15 -4
- package/scripts/cortar-release.sh +76 -0
- package/scripts/gate-bandeja.ps1 +255 -0
- package/scripts/gate-calentado.py +119 -0
- package/scripts/gate-dibujo.sh +49 -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
- package/src/render/tablero.html +68 -6
|
@@ -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")
|
package/scripts/gate-dibujo.sh
CHANGED
|
@@ -40,6 +40,55 @@ python3 -c "import py_compile,sys; py_compile.compile(sys.argv[1], cfile=sys.arg
|
|
|
40
40
|
cp -f "extension/quartermaster@legios/extension.js" "$salida/ext.mjs"
|
|
41
41
|
node --check "$salida/ext.mjs" || fallar "extension.js no parsea"
|
|
42
42
|
|
|
43
|
+
# Y la bandeja de Windows, que es la superficie que más tiempo estuvo sin que la
|
|
44
|
+
# mirara nadie: de sus ~1500 líneas el CI comprobaba UNA función. Acá sólo se
|
|
45
|
+
# parsea —dibujar necesita System.Drawing, que es de Windows, y eso lo hace
|
|
46
|
+
# scripts/gate-bandeja.ps1 en el runner de Windows—, pero parsear ya es lo más
|
|
47
|
+
# barato de romper y lo más caro de descubrir: un error de sintaxis se ve recién
|
|
48
|
+
# cuando alguien inicia sesión.
|
|
49
|
+
if command -v pwsh >/dev/null 2>&1; then
|
|
50
|
+
pwsh -NoProfile -Command '
|
|
51
|
+
$e = $null
|
|
52
|
+
[System.Management.Automation.Language.Parser]::ParseFile(
|
|
53
|
+
(Resolve-Path bin/qm-tray.ps1), [ref]$null, [ref]$e) | Out-Null
|
|
54
|
+
if ($e -and $e.Count) {
|
|
55
|
+
$e | Select-Object -First 5 | ForEach-Object {
|
|
56
|
+
[Console]::Error.WriteLine(" línea $($_.Extent.StartLineNumber): $($_.Message)") }
|
|
57
|
+
exit 1
|
|
58
|
+
}' || fallar "bin/qm-tray.ps1 no parsea"
|
|
59
|
+
echo "bandeja: bin/qm-tray.ps1 parsea"
|
|
60
|
+
elif [ -n "$QM_GATE_EXIGE_PWSH" ]; then
|
|
61
|
+
fallar "falta pwsh y este job lo exige"
|
|
62
|
+
else
|
|
63
|
+
echo " · salteada: la bandeja de Windows (no hay pwsh en esta máquina)"
|
|
64
|
+
fi
|
|
65
|
+
|
|
66
|
+
# Y la barra de menú de macOS, que era el ÚNICO fuente del repo que no abría
|
|
67
|
+
# ningún gate: gate-duraciones.py le extrae una función y compila esa sola, así
|
|
68
|
+
# que el resto del archivo podía tener un error de sintaxis y el CI no se
|
|
69
|
+
# enteraba. Es el mismo agujero que tenían el indicador de GNOME y la bandeja de
|
|
70
|
+
# Windows, contado dos veces en este archivo.
|
|
71
|
+
#
|
|
72
|
+
# AppKit es de macOS, pero `swiftc -parse` sólo PARSEA: no carga módulos ni
|
|
73
|
+
# chequea tipos, así que el error más barato de cometer —y el más caro de
|
|
74
|
+
# descubrir, porque hoy se ve recién cuando alguien compila en una Mac— se
|
|
75
|
+
# agarra desde Ubuntu. Si este swiftc igual no puede, lo dice y se saltea: nunca
|
|
76
|
+
# se da por bueno en silencio.
|
|
77
|
+
if command -v swiftc >/dev/null 2>&1; then
|
|
78
|
+
if swift_salida=$(swiftc -parse bin/qm-barra.swift 2>&1); then
|
|
79
|
+
echo "barra de macOS: bin/qm-barra.swift parsea"
|
|
80
|
+
elif echo "$swift_salida" | grep -qi "no such module"; then
|
|
81
|
+
echo " · salteada: la barra de macOS (este swiftc no parsea sin AppKit)"
|
|
82
|
+
else
|
|
83
|
+
echo "$swift_salida" | head -5 >&2
|
|
84
|
+
fallar "bin/qm-barra.swift no parsea"
|
|
85
|
+
fi
|
|
86
|
+
elif [ -n "$QM_GATE_EXIGE_SWIFT" ]; then
|
|
87
|
+
fallar "falta swiftc y este job lo exige"
|
|
88
|
+
else
|
|
89
|
+
echo " · salteada: la barra de macOS (no hay swiftc en esta máquina)"
|
|
90
|
+
fi
|
|
91
|
+
|
|
43
92
|
python3 bin/qm-indicator --desde test/fixtures/panel.json --oscuro \
|
|
44
93
|
--captura "$salida/panel.png" >/dev/null || fallar "no dibujó el panel"
|
|
45
94
|
python3 bin/qm-indicator --desde test/fixtures/panel.json --oscuro \
|
|
@@ -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
|
|
@@ -0,0 +1,123 @@
|
|
|
1
|
+
#!/bin/sh
|
|
2
|
+
# El zip de la extensión, con la forma que pide extensions.gnome.org.
|
|
3
|
+
#
|
|
4
|
+
# Por qué existe. La extensión está escrita desde hace rato y la única forma de
|
|
5
|
+
# instalarla es clonar el repo y correr `make extension`. extensions.gnome.org
|
|
6
|
+
# es el catálogo por defecto de GNOME —lo que se abre desde «Extensiones» en
|
|
7
|
+
# cualquier escritorio GNOME— y ahí no está, así que para quien no clona el
|
|
8
|
+
# repo, sencillamente no existe.
|
|
9
|
+
#
|
|
10
|
+
# El formato tiene una regla que se rompe sola si uno arma el zip a mano:
|
|
11
|
+
# metadata.json y extension.js van en la RAÍZ del zip, no adentro de un
|
|
12
|
+
# directorio con el uuid. Por eso se usa `gnome-extensions pack`, que además
|
|
13
|
+
# valida el metadata.json, y por eso el gate de abajo mira lo que salió en vez
|
|
14
|
+
# de confiar.
|
|
15
|
+
#
|
|
16
|
+
# Subirlo es a mano y con cuenta: https://extensions.gnome.org/upload/
|
|
17
|
+
# Ver paquetes/README.md para lo que mira el revisor.
|
|
18
|
+
|
|
19
|
+
set -e
|
|
20
|
+
raiz=$(cd "$(dirname "$0")/.." && pwd)
|
|
21
|
+
cd "$raiz"
|
|
22
|
+
|
|
23
|
+
fuente="$raiz/extension/quartermaster@legios"
|
|
24
|
+
destino=${1:-$raiz/dist}
|
|
25
|
+
mkdir -p "$destino"
|
|
26
|
+
|
|
27
|
+
[ -f "$fuente/metadata.json" ] || { echo "no está $fuente/metadata.json" >&2; exit 1; }
|
|
28
|
+
|
|
29
|
+
zip="$destino/quartermaster@legios.shell-extension.zip"
|
|
30
|
+
rm -f "$zip"
|
|
31
|
+
|
|
32
|
+
# `gnome-extensions pack` es el camino bueno —arma el zip y de paso valida el
|
|
33
|
+
# metadata.json— pero viene con gnome-shell, que en un runner de CI no está y
|
|
34
|
+
# que instalar para esto serían cientos de megas. Con `zip` sale lo mismo: la
|
|
35
|
+
# forma del archivo es tres archivos en la raíz, y eso lo comprueba el gate de
|
|
36
|
+
# abajo mire quien lo haya armado.
|
|
37
|
+
if command -v gnome-extensions >/dev/null 2>&1; then
|
|
38
|
+
gnome-extensions pack "$fuente" --out-dir="$destino" --force
|
|
39
|
+
elif command -v zip >/dev/null 2>&1; then
|
|
40
|
+
echo "· sin gnome-extensions: armando el zip con \`zip\`"
|
|
41
|
+
(cd "$fuente" && zip -q -X "$zip" metadata.json extension.js stylesheet.css)
|
|
42
|
+
else
|
|
43
|
+
echo "no tengo con qué armar el zip: falta \`gnome-extensions\` y falta \`zip\`." >&2
|
|
44
|
+
exit 1
|
|
45
|
+
fi
|
|
46
|
+
|
|
47
|
+
[ -f "$zip" ] || { echo "gnome-extensions dijo que sí pero no está $zip" >&2; exit 1; }
|
|
48
|
+
|
|
49
|
+
# ── el gate del zip ────────────────────────────────────────────────────
|
|
50
|
+
# Tres cosas que el sitio rechaza y que no se ven mirando el directorio:
|
|
51
|
+
adentro=$(unzip -Z1 "$zip")
|
|
52
|
+
|
|
53
|
+
echo "$adentro" | grep -qx 'metadata.json' || {
|
|
54
|
+
echo "✗ metadata.json no está en la raíz del zip: el sitio lo rechaza" >&2; exit 1; }
|
|
55
|
+
echo "$adentro" | grep -qx 'extension.js' || {
|
|
56
|
+
echo "✗ extension.js no está en la raíz del zip" >&2; exit 1; }
|
|
57
|
+
echo "$adentro" | grep -qx 'stylesheet.css' || {
|
|
58
|
+
echo "✗ el stylesheet no viajó: el panel saldría sin estilos" >&2; exit 1; }
|
|
59
|
+
|
|
60
|
+
# La versión la asigna el sitio; mandar una propia confunde el número de
|
|
61
|
+
# revisión con el del repo.
|
|
62
|
+
if grep -q '"version"[[:space:]]*:' "$fuente/metadata.json"; then
|
|
63
|
+
echo "✗ metadata.json trae \"version\": ése número lo pone extensions.gnome.org." >&2
|
|
64
|
+
echo " Lo nuestro va en \"version-name\"." >&2
|
|
65
|
+
exit 1
|
|
66
|
+
fi
|
|
67
|
+
|
|
68
|
+
# El metadata.json tiene que ser JSON válido y traer las cinco claves que el
|
|
69
|
+
# sitio exige. `gnome-extensions pack` lo valida; el camino de `zip` no, así
|
|
70
|
+
# que se valida acá y vale para los dos.
|
|
71
|
+
python3 - "$fuente/metadata.json" <<'PY'
|
|
72
|
+
import json, sys
|
|
73
|
+
ruta = sys.argv[1]
|
|
74
|
+
try:
|
|
75
|
+
m = json.load(open(ruta, encoding='utf-8'))
|
|
76
|
+
except Exception as e:
|
|
77
|
+
print(f"✗ {ruta} no es JSON válido: {e}", file=sys.stderr)
|
|
78
|
+
sys.exit(1)
|
|
79
|
+
faltan = [k for k in ('uuid', 'name', 'description', 'shell-version', 'url') if k not in m]
|
|
80
|
+
if faltan:
|
|
81
|
+
print(f"✗ al metadata.json le faltan claves que el sitio exige: {', '.join(faltan)}", file=sys.stderr)
|
|
82
|
+
sys.exit(1)
|
|
83
|
+
if not isinstance(m['shell-version'], list) or not m['shell-version']:
|
|
84
|
+
print("✗ shell-version tiene que ser una lista con al menos una versión", file=sys.stderr)
|
|
85
|
+
sys.exit(1)
|
|
86
|
+
PY
|
|
87
|
+
|
|
88
|
+
# El uuid tiene que coincidir con el nombre del directorio, o al instalar queda
|
|
89
|
+
# en un lado y el shell lo busca en otro.
|
|
90
|
+
uuid=$(sed -n 's/.*"uuid"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' "$fuente/metadata.json")
|
|
91
|
+
[ "$uuid" = "$(basename "$fuente")" ] || {
|
|
92
|
+
echo "✗ el uuid ($uuid) no coincide con el directorio ($(basename "$fuente"))" >&2; exit 1; }
|
|
93
|
+
|
|
94
|
+
# ── el analizador que recomienda el propio sitio ───────────────────────
|
|
95
|
+
# `shexli` es de extensions.gnome.org y encuentra lo que marca la revisión. La
|
|
96
|
+
# primera vez que se corrió sacó dos: señales sin desconectar (la causa de
|
|
97
|
+
# rechazo más común) y una lectura de archivo sincrónica adentro del
|
|
98
|
+
# compositor. Dos minutos de análisis contra una vuelta de revisión de semanas.
|
|
99
|
+
#
|
|
100
|
+
# No es obligatorio tenerlo: si no está, se dice y se sigue. Instalarlo:
|
|
101
|
+
# python3 -m venv venv && ./venv/bin/pip install -U shexli
|
|
102
|
+
if command -v shexli >/dev/null 2>&1; then
|
|
103
|
+
ANALIZADOR=shexli
|
|
104
|
+
elif [ -x "$raiz/venv/bin/shexli" ]; then
|
|
105
|
+
ANALIZADOR="$raiz/venv/bin/shexli"
|
|
106
|
+
else
|
|
107
|
+
ANALIZADOR=""
|
|
108
|
+
fi
|
|
109
|
+
|
|
110
|
+
if [ -n "$ANALIZADOR" ]; then
|
|
111
|
+
if ! "$ANALIZADOR" "$zip"; then
|
|
112
|
+
echo "" >&2
|
|
113
|
+
echo "✗ shexli encontró algo. Eso mismo lo va a marcar la revisión." >&2
|
|
114
|
+
exit 1
|
|
115
|
+
fi
|
|
116
|
+
else
|
|
117
|
+
echo "· sin shexli: el análisis estático que recomienda el sitio no se corrió"
|
|
118
|
+
echo " (python3 -m venv venv && ./venv/bin/pip install -U shexli)"
|
|
119
|
+
fi
|
|
120
|
+
|
|
121
|
+
bytes=$(wc -c < "$zip")
|
|
122
|
+
echo "✓ $zip (${bytes} bytes)"
|
|
123
|
+
echo " subir a: https://extensions.gnome.org/upload/"
|