@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.
@@ -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")
@@ -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
@@ -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/"