@legios/quartermaster 0.1.3 → 0.1.5
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 +281 -8
- package/bin/qm-barra.swift +48 -1
- package/bin/qm-indicator +23 -1
- package/bin/qm-tray.ps1 +1252 -252
- package/dist/cli/qm.js +38 -0
- 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/render/tablero.html +68 -6
- package/package.json +8 -4
- package/scripts/construir.mjs +29 -0
- package/scripts/el-paquete-de-npm-corre.sh +48 -0
- package/scripts/gate-bandeja.ps1 +172 -0
- package/scripts/gate-dibujo.sh +139 -0
- package/scripts/gate-duraciones.py +152 -0
- package/scripts/gate-tarjetas.py +87 -0
- package/scripts/hacer-apt.sh +55 -0
- package/scripts/hacer-deb.sh +65 -0
- package/scripts/instalar-barra.mjs +72 -0
- package/scripts/nodo.cjs +20 -0
- package/src/render/tablero.html +68 -6
|
@@ -0,0 +1,172 @@
|
|
|
1
|
+
<#
|
|
2
|
+
El gate de la bandeja de Windows, que era la superficie que nadie miraba.
|
|
3
|
+
|
|
4
|
+
De las ~1500 líneas de bin/qm-tray.ps1, el CI comprobaba UNA función: la
|
|
5
|
+
escalera de duración, que scripts/gate-duraciones.py extrae y corre suelta.
|
|
6
|
+
Todo lo demás —el panel, los íconos, el modelo de qué va en cada uno— pasaba en
|
|
7
|
+
verde con un error de sintaxis adentro. Es exactamente lo que le pasó a
|
|
8
|
+
bin/qm-indicator antes de que existiera scripts/gate-dibujo.sh: se borró medio
|
|
9
|
+
archivo y el CI no se enteró, porque el CI ni lo abría.
|
|
10
|
+
|
|
11
|
+
Cuatro cosas, en orden de qué tan barato es equivocarse:
|
|
12
|
+
|
|
13
|
+
1. que PARSEE — un error de sintaxis no llega a ejecutarse nunca;
|
|
14
|
+
2. que DIBUJE. Con una entrada fija el panel tiene que salir con las medidas
|
|
15
|
+
de siempre y con píxeles adentro. Un error de dibujo —una llamada a GDI+
|
|
16
|
+
con un argumento de menos, una medida que no coincide con lo que pinta— no
|
|
17
|
+
rompe el parseo;
|
|
18
|
+
3. que NADA SE SALGA DE LA TARJETA. GDI+ no recorta cuando se dibuja en un
|
|
19
|
+
punto, así que un nombre de perfil largo se dibujaba por encima del borde
|
|
20
|
+
y un nombre de ventana largo se metía debajo del porcentaje. Se comprueba
|
|
21
|
+
con el fixture de nombres largos, mirando los píxeles de la franja de
|
|
22
|
+
afuera en vez de mirar la imagen a ojo;
|
|
23
|
+
4. que cada ícono tenga SU panel: el general con todas las cuentas y el de
|
|
24
|
+
una cuenta con esa sola. Es la diferencia entre cuatro íconos que sirven
|
|
25
|
+
y cuatro íconos que abren la misma pantalla.
|
|
26
|
+
|
|
27
|
+
Corre en Windows porque System.Drawing y WinForms son de Windows. En el runner
|
|
28
|
+
de Ubuntu se saltea diciéndolo — nunca se da por bueno en silencio.
|
|
29
|
+
#>
|
|
30
|
+
|
|
31
|
+
[CmdletBinding()]
|
|
32
|
+
param()
|
|
33
|
+
|
|
34
|
+
Set-StrictMode -Version Latest
|
|
35
|
+
$ErrorActionPreference = 'Stop'
|
|
36
|
+
|
|
37
|
+
$raiz = Split-Path (Split-Path $PSCommandPath -Parent) -Parent
|
|
38
|
+
$guion = Join-Path $raiz 'bin\qm-tray.ps1'
|
|
39
|
+
$fixture = Join-Path $raiz 'test\fixtures\panel.json'
|
|
40
|
+
$largos = Join-Path $raiz 'test\fixtures\panel-largos.json'
|
|
41
|
+
$salida = Join-Path ([System.IO.Path]::GetTempPath()) ("qm-gate-" + [guid]::NewGuid().ToString('N'))
|
|
42
|
+
New-Item -ItemType Directory -Path $salida -Force | Out-Null
|
|
43
|
+
|
|
44
|
+
$fallas = @()
|
|
45
|
+
function Fallar([string]$que) { $script:fallas += $que }
|
|
46
|
+
|
|
47
|
+
# ── 1 · que parsee ──────────────────────────────────────────────────────
|
|
48
|
+
$errores = $null
|
|
49
|
+
[System.Management.Automation.Language.Parser]::ParseFile($guion, [ref]$null, [ref]$errores) | Out-Null
|
|
50
|
+
if ($errores -and $errores.Count) {
|
|
51
|
+
foreach ($e in $errores | Select-Object -First 5) {
|
|
52
|
+
Fallar "bin/qm-tray.ps1 no parsea (línea $($e.Extent.StartLineNumber)): $($e.Message)"
|
|
53
|
+
}
|
|
54
|
+
foreach ($f in $fallas) { Write-Error "GATE ROJO: $f" -ErrorAction Continue }
|
|
55
|
+
exit 1
|
|
56
|
+
}
|
|
57
|
+
|
|
58
|
+
function Capturar([string]$desde, [string]$panel, [string]$tema, [string]$png) {
|
|
59
|
+
$ps = @('-NoProfile', '-ExecutionPolicy', 'Bypass', '-File', $guion,
|
|
60
|
+
'-Desde', $desde, '-Captura', $png, "-$tema")
|
|
61
|
+
if ($panel) { $ps += @('-Panel', $panel) }
|
|
62
|
+
$p = Start-Process powershell.exe -ArgumentList $ps -NoNewWindow -Wait -PassThru `
|
|
63
|
+
-RedirectStandardOutput "$png.txt" -RedirectStandardError "$png.err"
|
|
64
|
+
if ($p.ExitCode -ne 0) {
|
|
65
|
+
$msg = (Get-Content "$png.err" -Raw -ErrorAction SilentlyContinue)
|
|
66
|
+
Fallar "la captura de '$panel' ($tema) salió $($p.ExitCode): $($msg -split "`n" | Select-Object -First 1)"
|
|
67
|
+
return $null
|
|
68
|
+
}
|
|
69
|
+
if (-not (Test-Path $png)) { Fallar "la captura de '$panel' no escribió el PNG"; return $null }
|
|
70
|
+
return [System.Drawing.Bitmap]::FromFile($png)
|
|
71
|
+
}
|
|
72
|
+
|
|
73
|
+
Add-Type -AssemblyName System.Drawing
|
|
74
|
+
|
|
75
|
+
# ── 2 · que dibuje ──────────────────────────────────────────────────────
|
|
76
|
+
# El ancho es el del diseño y no una casualidad: si cambia, lo cambió alguien.
|
|
77
|
+
$ANCHO = 340
|
|
78
|
+
|
|
79
|
+
$bmp = Capturar $fixture '' 'Oscuro' (Join-Path $salida 'general.png')
|
|
80
|
+
if ($bmp) {
|
|
81
|
+
if ($bmp.Width -ne $ANCHO) { Fallar "el panel general salió de $($bmp.Width) px de ancho y tiene que ser $ANCHO" }
|
|
82
|
+
if ($bmp.Height -lt 300 -or $bmp.Height -gt 2400) {
|
|
83
|
+
Fallar "el panel general salió de $($bmp.Height) px de alto, fuera de lo razonable"
|
|
84
|
+
}
|
|
85
|
+
# Un PNG del tamaño correcto y enteramente del color de fondo pasa cualquier
|
|
86
|
+
# chequeo de medidas y no dibujó nada.
|
|
87
|
+
$fondo = $bmp.GetPixel(2, 2)
|
|
88
|
+
$distintos = 0
|
|
89
|
+
for ($y = 0; $y -lt $bmp.Height; $y += 3) {
|
|
90
|
+
for ($x = 0; $x -lt $bmp.Width; $x += 3) {
|
|
91
|
+
$c = $bmp.GetPixel($x, $y)
|
|
92
|
+
if ($c.R -ne $fondo.R -or $c.G -ne $fondo.G -or $c.B -ne $fondo.B) { $distintos++ }
|
|
93
|
+
}
|
|
94
|
+
}
|
|
95
|
+
if ($distintos -lt 500) { Fallar "el panel general está casi vacío: $distintos muestras con algo" }
|
|
96
|
+
$altoGeneral = $bmp.Height
|
|
97
|
+
$bmp.Dispose()
|
|
98
|
+
} else { $altoGeneral = 0 }
|
|
99
|
+
|
|
100
|
+
# ── 3 · que nada se salga de la tarjeta ─────────────────────────────────
|
|
101
|
+
# La franja de afuera tiene que ser del color del fondo. Los separadores entre
|
|
102
|
+
# tarjetas SÍ cruzan de lado a lado, así que una fila entera de un solo color
|
|
103
|
+
# distinto del fondo es un separador y no un desborde.
|
|
104
|
+
$bmp = Capturar $largos '' 'Oscuro' (Join-Path $salida 'largos.png')
|
|
105
|
+
if ($bmp) {
|
|
106
|
+
$fondo = $bmp.GetPixel(2, 2)
|
|
107
|
+
$FRANJA = 11 # el margen del diseño es 15; se deja aire por el antialias
|
|
108
|
+
$sucias = @()
|
|
109
|
+
for ($y = 0; $y -lt $bmp.Height; $y++) {
|
|
110
|
+
$izq = $bmp.GetPixel(1, $y)
|
|
111
|
+
# Una fila de separador: el píxel del borde y el del centro son iguales.
|
|
112
|
+
$centro = $bmp.GetPixel([int]($bmp.Width / 2), $y)
|
|
113
|
+
if ($izq.R -eq $centro.R -and $izq.G -eq $centro.G -and $izq.B -eq $centro.B -and
|
|
114
|
+
($izq.R -ne $fondo.R -or $izq.G -ne $fondo.G -or $izq.B -ne $fondo.B)) { continue }
|
|
115
|
+
foreach ($x in @(0..($FRANJA - 1)) + @(($bmp.Width - $FRANJA)..($bmp.Width - 1))) {
|
|
116
|
+
$c = $bmp.GetPixel($x, $y)
|
|
117
|
+
if ($c.R -ne $fondo.R -or $c.G -ne $fondo.G -or $c.B -ne $fondo.B) { $sucias += "$x,$y" }
|
|
118
|
+
}
|
|
119
|
+
}
|
|
120
|
+
if ($sucias.Count) {
|
|
121
|
+
Fallar ("con nombres largos hay $($sucias.Count) píxeles dibujados fuera del margen " +
|
|
122
|
+
"(el primero en " + $sucias[0] + "): algo se está saliendo de la tarjeta")
|
|
123
|
+
}
|
|
124
|
+
$bmp.Dispose()
|
|
125
|
+
}
|
|
126
|
+
|
|
127
|
+
# ── 3b · el pie del panel, una vez por vuelta y no una por menú ─────────
|
|
128
|
+
# Esto es una comprobación de TEXTO y no de dibujo, porque el bug que previene
|
|
129
|
+
# no se ve en un PNG: ArmarMenu llegó a dibujar el pie él mismo, o sea una vez
|
|
130
|
+
# por menú, y cada llamada liberaba el bitmap que el menú anterior acababa de
|
|
131
|
+
# recibir. Con cuatro íconos quedaban tres PictureBox apuntando a una imagen
|
|
132
|
+
# muerta: el renglón salía en blanco y, al repintarse, GDI+ tiraba «Parameter is
|
|
133
|
+
# not valid» — medido, 3 imágenes muertas por vuelta contra 0 con el arreglo.
|
|
134
|
+
# El dueño del pie es Refrescar; ArmarMenu sólo lo usa.
|
|
135
|
+
$cuerpoArmar = (Get-Content $guion -Raw -Encoding UTF8)
|
|
136
|
+
$i = $cuerpoArmar.IndexOf('function ArmarMenu(')
|
|
137
|
+
$j = $cuerpoArmar.IndexOf("`nfunction ", $i + 10)
|
|
138
|
+
if ($i -ge 0 -and $j -gt $i -and $cuerpoArmar.Substring($i, $j - $i) -match 'DibujarPieLectura') {
|
|
139
|
+
Fallar ('ArmarMenu dibuja el pie: tiene que recibirlo hecho. Dibujarlo por menú ' +
|
|
140
|
+
'libera el que recibió el menú anterior y lo deja en blanco.')
|
|
141
|
+
}
|
|
142
|
+
|
|
143
|
+
# ── 4 · un panel por ícono ──────────────────────────────────────────────
|
|
144
|
+
# El de una cuenta tiene que ser MÁS CHICO que el general: si son iguales, el
|
|
145
|
+
# ícono de la cuenta está abriendo el panel de todas y los cuatro íconos que
|
|
146
|
+
# pidió el usuario son cuatro veces la misma pantalla.
|
|
147
|
+
$bmp = Capturar $fixture 'teams' 'Oscuro' (Join-Path $salida 'teams.png')
|
|
148
|
+
if ($bmp) {
|
|
149
|
+
if ($bmp.Width -ne $ANCHO) { Fallar "el panel de una cuenta salió de $($bmp.Width) px de ancho" }
|
|
150
|
+
if ($altoGeneral -gt 0 -and $bmp.Height -ge $altoGeneral) {
|
|
151
|
+
Fallar ("el panel de 'teams' mide $($bmp.Height) px y el general ${altoGeneral}: " +
|
|
152
|
+
"el ícono de una cuenta está mostrando todas")
|
|
153
|
+
}
|
|
154
|
+
$bmp.Dispose()
|
|
155
|
+
}
|
|
156
|
+
|
|
157
|
+
# Y el tema claro, que es otra tabla de colores y se rompe sola.
|
|
158
|
+
$bmp = Capturar $fixture '' 'Claro' (Join-Path $salida 'claro.png')
|
|
159
|
+
if ($bmp) {
|
|
160
|
+
$fondo = $bmp.GetPixel(2, 2)
|
|
161
|
+
if ($fondo.R -lt 200) { Fallar "el panel en tema claro salió con fondo oscuro ($fondo)" }
|
|
162
|
+
$bmp.Dispose()
|
|
163
|
+
}
|
|
164
|
+
|
|
165
|
+
Remove-Item $salida -Recurse -Force -ErrorAction SilentlyContinue
|
|
166
|
+
|
|
167
|
+
if ($fallas.Count) {
|
|
168
|
+
foreach ($f in $fallas) { [Console]::Error.WriteLine("GATE ROJO: $f") }
|
|
169
|
+
exit 1
|
|
170
|
+
}
|
|
171
|
+
Write-Host "gate de la bandeja: verde — parsea, dibuja $ANCHO px en los dos temas, nada se sale del margen, y el panel de una cuenta no es el de todas"
|
|
172
|
+
exit 0
|
|
@@ -0,0 +1,139 @@
|
|
|
1
|
+
#!/bin/sh
|
|
2
|
+
# El gate de las superficies que el CI de Node no mira.
|
|
3
|
+
#
|
|
4
|
+
# `npm test` cubre el núcleo en TypeScript. Fuera de eso hay 1.400 líneas de
|
|
5
|
+
# Python que dibujan el panel y el item de GNOME, y una extensión de GNOME Shell
|
|
6
|
+
# en JavaScript, y hasta ahora no las revisaba nadie: en esta misma máquina se
|
|
7
|
+
# borró medio bin/qm-indicator con un corte mal puesto y el archivo siguió
|
|
8
|
+
# pasando el CI, porque el CI ni lo abría.
|
|
9
|
+
#
|
|
10
|
+
# Tres cosas, en orden de qué tan barato es equivocarse:
|
|
11
|
+
#
|
|
12
|
+
# 1. que compile — un error de sintaxis no llega a ejecutarse nunca;
|
|
13
|
+
# 2. que la extensión parsee — un error ahí lo ve GNOME al iniciar sesión,
|
|
14
|
+
# que es el peor momento para enterarse;
|
|
15
|
+
# 3. que DIBUJE. Esto es lo que no se puede reemplazar por un import: con una
|
|
16
|
+
# entrada fija, el panel y el item tienen que salir con las medidas de
|
|
17
|
+
# siempre y con píxeles adentro. Un error de dibujo —una llamada a Cairo
|
|
18
|
+
# con un argumento de menos, una medida que no coincide con lo que pinta—
|
|
19
|
+
# no rompe la importación del módulo.
|
|
20
|
+
|
|
21
|
+
set -e
|
|
22
|
+
raiz=$(cd "$(dirname "$0")/.." && pwd)
|
|
23
|
+
cd "$raiz"
|
|
24
|
+
|
|
25
|
+
salida=$(mktemp -d)
|
|
26
|
+
trap 'rm -rf "$salida"' EXIT
|
|
27
|
+
|
|
28
|
+
fallar() {
|
|
29
|
+
echo "GATE ROJO: $1" >&2
|
|
30
|
+
exit 1
|
|
31
|
+
}
|
|
32
|
+
|
|
33
|
+
# El .pyc va al temporal y no al lado del fuente: `python3 -m py_compile` deja un
|
|
34
|
+
# bin/__pycache__ que después se cuela en el tarball de npm.
|
|
35
|
+
python3 -c "import py_compile,sys; py_compile.compile(sys.argv[1], cfile=sys.argv[2], doraise=True)" \
|
|
36
|
+
bin/qm-indicator "$salida/qm-indicator.pyc" || fallar "bin/qm-indicator no compila"
|
|
37
|
+
|
|
38
|
+
# node --check quiere que el archivo se vea como módulo; la extensión usa
|
|
39
|
+
# import/export y con extensión .js node la lee como CommonJS.
|
|
40
|
+
cp -f "extension/quartermaster@legios/extension.js" "$salida/ext.mjs"
|
|
41
|
+
node --check "$salida/ext.mjs" || fallar "extension.js no parsea"
|
|
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
|
+
|
|
92
|
+
python3 bin/qm-indicator --desde test/fixtures/panel.json --oscuro \
|
|
93
|
+
--captura "$salida/panel.png" >/dev/null || fallar "no dibujó el panel"
|
|
94
|
+
python3 bin/qm-indicator --desde test/fixtures/panel.json --oscuro \
|
|
95
|
+
--captura-item "$salida/item.png" >/dev/null || fallar "no dibujó el item"
|
|
96
|
+
|
|
97
|
+
python3 - "$salida/panel.png" "$salida/item.png" <<'PY'
|
|
98
|
+
import sys
|
|
99
|
+
import cairo
|
|
100
|
+
|
|
101
|
+
def medir(ruta):
|
|
102
|
+
s = cairo.ImageSurface.create_from_png(ruta)
|
|
103
|
+
datos = bytes(s.get_data())
|
|
104
|
+
# Cuántos píxeles tienen algo. Un PNG del tamaño correcto y enteramente
|
|
105
|
+
# transparente pasa cualquier chequeo de medidas y no dibujó nada.
|
|
106
|
+
pintados = sum(1 for i in range(3, len(datos), 4) if datos[i] != 0)
|
|
107
|
+
return s.get_width(), s.get_height(), pintados
|
|
108
|
+
|
|
109
|
+
fallas = []
|
|
110
|
+
ancho, alto, pintados = medir(sys.argv[1])
|
|
111
|
+
if ancho != 360:
|
|
112
|
+
fallas.append(f"el panel salió de {ancho} px de ancho y tiene que ser 360")
|
|
113
|
+
if not 600 <= alto <= 2400:
|
|
114
|
+
fallas.append(f"el panel salió de {alto} px de alto, fuera de lo razonable")
|
|
115
|
+
if pintados < ancho * alto // 2:
|
|
116
|
+
fallas.append(f"el panel está casi vacío: {pintados} píxeles con algo")
|
|
117
|
+
|
|
118
|
+
ancho, alto, pintados = medir(sys.argv[2])
|
|
119
|
+
if alto != 22:
|
|
120
|
+
fallas.append(f"el item salió de {alto} px de alto y tiene que ser 22")
|
|
121
|
+
# La proporción es lo que decide si GNOME lo dibuja a lo ancho o lo encaja en un
|
|
122
|
+
# cuadrado de 16 px. Abajo de 1.5 los medidores se vuelven ilegibles.
|
|
123
|
+
if ancho < alto * 1.5:
|
|
124
|
+
fallas.append(f"el item quedó de {ancho}x{alto}: GNOME lo va a encajar en un cuadrado")
|
|
125
|
+
if pintados == 0:
|
|
126
|
+
fallas.append("el item no tiene un solo píxel dibujado")
|
|
127
|
+
|
|
128
|
+
if fallas:
|
|
129
|
+
for f in fallas:
|
|
130
|
+
print(f"GATE ROJO: {f}", file=sys.stderr)
|
|
131
|
+
raise SystemExit(1)
|
|
132
|
+
print("dibujo verificado: panel 360 px y item ancho, los dos con píxeles adentro")
|
|
133
|
+
PY
|
|
134
|
+
|
|
135
|
+
# 4 · y que ninguna tarjeta sola sea más alta que una pantalla: el panel es un
|
|
136
|
+
# menú, y un menú rueda item por item.
|
|
137
|
+
python3 scripts/gate-tarjetas.py || exit 1
|
|
138
|
+
|
|
139
|
+
echo "gate de dibujo: verde"
|
|
@@ -0,0 +1,152 @@
|
|
|
1
|
+
"""Las cuatro escaleras de duración tienen que dar exactamente lo mismo.
|
|
2
|
+
|
|
3
|
+
Hay una implementación por lenguaje —TypeScript, Python, Swift, PowerShell— y
|
|
4
|
+
cada una vive en un renderizador distinto. La regla siempre estuvo escrita en los
|
|
5
|
+
comentarios; lo que faltaba era comprobarla. El resultado de no comprobarla:
|
|
6
|
+
convivieron DOS convenciones durante meses, tres GUIs de un lado y el CLI del
|
|
7
|
+
otro, en tres puntos a la vez (qué se dice de un instante pasado, si los minutos
|
|
8
|
+
se rellenan con cero, y si un día justo es `1d` o `1d0h`). Sobrevivió porque
|
|
9
|
+
nadie había comparado una GUI contra el CLI: Sol comparó dos GUIs entre sí.
|
|
10
|
+
|
|
11
|
+
El canon está congelado en test/fixtures/duraciones.json, sacado corriendo el
|
|
12
|
+
CLI. Cada implementación se EJECUTA y se compara contra esa tabla. Las que no
|
|
13
|
+
tienen intérprete en esta máquina se saltean diciéndolo — nunca se dan por
|
|
14
|
+
buenas en silencio.
|
|
15
|
+
"""
|
|
16
|
+
|
|
17
|
+
import importlib.machinery
|
|
18
|
+
import importlib.util
|
|
19
|
+
import json
|
|
20
|
+
import os
|
|
21
|
+
import pathlib
|
|
22
|
+
import re
|
|
23
|
+
import shutil
|
|
24
|
+
import subprocess
|
|
25
|
+
import sys
|
|
26
|
+
import tempfile
|
|
27
|
+
|
|
28
|
+
RAIZ = pathlib.Path(__file__).resolve().parent.parent
|
|
29
|
+
TABLA = json.loads((RAIZ / "test/fixtures/duraciones.json").read_text())
|
|
30
|
+
CASOS = [(int(s), esperado) for s, esperado in TABLA["casos"]]
|
|
31
|
+
|
|
32
|
+
|
|
33
|
+
def bloque(ruta: pathlib.Path, arranque: str, abre: str = "{", cierra: str = "}") -> str:
|
|
34
|
+
"""El cuerpo de una función, contando llaves desde su primera línea."""
|
|
35
|
+
texto = ruta.read_text(encoding="utf-8")
|
|
36
|
+
i = texto.index(arranque)
|
|
37
|
+
nivel, j = 0, i
|
|
38
|
+
while True:
|
|
39
|
+
if texto[j] == abre:
|
|
40
|
+
nivel += 1
|
|
41
|
+
elif texto[j] == cierra:
|
|
42
|
+
nivel -= 1
|
|
43
|
+
if nivel == 0:
|
|
44
|
+
return texto[i:j + 1]
|
|
45
|
+
j += 1
|
|
46
|
+
|
|
47
|
+
|
|
48
|
+
def por_typescript():
|
|
49
|
+
guion = (
|
|
50
|
+
"import {duracion} from './src/render/barras.ts';"
|
|
51
|
+
f"const c={json.dumps([s for s, _ in CASOS])};"
|
|
52
|
+
"console.log(JSON.stringify(c.map(s=>duracion(s*1000))));"
|
|
53
|
+
)
|
|
54
|
+
r = subprocess.run(["node", "--experimental-strip-types", "-e", guion],
|
|
55
|
+
cwd=RAIZ, capture_output=True, text=True, timeout=60)
|
|
56
|
+
if r.returncode != 0:
|
|
57
|
+
raise RuntimeError(r.stderr.strip().splitlines()[-1] if r.stderr else "node falló")
|
|
58
|
+
return json.loads(r.stdout)
|
|
59
|
+
|
|
60
|
+
|
|
61
|
+
def por_python():
|
|
62
|
+
spec = importlib.util.spec_from_loader(
|
|
63
|
+
"qm", importlib.machinery.SourceFileLoader("qm", str(RAIZ / "bin/qm-indicator")))
|
|
64
|
+
m = importlib.util.module_from_spec(spec)
|
|
65
|
+
spec.loader.exec_module(m)
|
|
66
|
+
return [m.duracion(s) for s, _ in CASOS]
|
|
67
|
+
|
|
68
|
+
|
|
69
|
+
def por_swift():
|
|
70
|
+
fn = bloque(RAIZ / "bin/qm-barra.swift", "func duracion(_ segundos: Int) -> String {")
|
|
71
|
+
casos = ", ".join(str(s) for s, _ in CASOS)
|
|
72
|
+
guion = f'import Foundation\n{fn}\nprint([{casos}].map {{ duracion($0) }}.joined(separator: "\\n"))\n'
|
|
73
|
+
with tempfile.TemporaryDirectory() as d:
|
|
74
|
+
p = pathlib.Path(d) / "d.swift"
|
|
75
|
+
p.write_text(guion)
|
|
76
|
+
r = subprocess.run(["swift", str(p)], capture_output=True, text=True, timeout=180)
|
|
77
|
+
if r.returncode != 0:
|
|
78
|
+
raise RuntimeError(r.stderr.strip().splitlines()[-1] if r.stderr else "swift falló")
|
|
79
|
+
return r.stdout.strip().split("\n")
|
|
80
|
+
|
|
81
|
+
|
|
82
|
+
def por_powershell():
|
|
83
|
+
fn = bloque(RAIZ / "bin/qm-tray.ps1", "function Dur([int]$segundos) {")
|
|
84
|
+
casos = ", ".join(str(s) for s, _ in CASOS)
|
|
85
|
+
guion = f"{fn}\n@({casos}) | ForEach-Object {{ Dur $_ }}\n"
|
|
86
|
+
with tempfile.TemporaryDirectory() as d:
|
|
87
|
+
p = pathlib.Path(d) / "d.ps1"
|
|
88
|
+
p.write_text(guion)
|
|
89
|
+
r = subprocess.run(["pwsh", "-NoProfile", "-File", str(p)],
|
|
90
|
+
capture_output=True, text=True, timeout=120)
|
|
91
|
+
if r.returncode != 0:
|
|
92
|
+
raise RuntimeError(r.stderr.strip().splitlines()[-1] if r.stderr else "pwsh falló")
|
|
93
|
+
return [l.strip() for l in r.stdout.strip().split("\n")]
|
|
94
|
+
|
|
95
|
+
|
|
96
|
+
IMPLEMENTACIONES = [
|
|
97
|
+
("TypeScript · el CLI", por_typescript, "node"),
|
|
98
|
+
("Python · el panel de GNOME", por_python, None),
|
|
99
|
+
("Swift · la barra de macOS", por_swift, "swift"),
|
|
100
|
+
("PowerShell · la bandeja", por_powershell, "pwsh"),
|
|
101
|
+
]
|
|
102
|
+
|
|
103
|
+
|
|
104
|
+
def main() -> int:
|
|
105
|
+
# QM_GATE_EXIGE lista los intérpretes que TIENEN que estar. En una laptop no
|
|
106
|
+
# hay ni swift ni pwsh y saltearlos es lo razonable; en CI, saltear en
|
|
107
|
+
# silencio convertiría el gate en un adorno, así que cada job exige los que
|
|
108
|
+
# su runner trae.
|
|
109
|
+
exigidos = {x for x in os.environ.get("QM_GATE_EXIGE", "").split(",") if x}
|
|
110
|
+
fallas, salteadas = 0, []
|
|
111
|
+
for nombre, correr, binario in IMPLEMENTACIONES:
|
|
112
|
+
if binario is not None and shutil.which(binario) is None:
|
|
113
|
+
if binario in exigidos:
|
|
114
|
+
print(f"GATE ROJO: falta {binario}, y este job lo exige "
|
|
115
|
+
f"(QM_GATE_EXIGE={','.join(sorted(exigidos))})", file=sys.stderr)
|
|
116
|
+
fallas += 1
|
|
117
|
+
continue
|
|
118
|
+
salteadas.append(f"{nombre} (no hay {binario} en esta máquina)")
|
|
119
|
+
continue
|
|
120
|
+
try:
|
|
121
|
+
salida = correr()
|
|
122
|
+
except Exception as e: # noqa: BLE001 — cualquier fallo es una falla del gate
|
|
123
|
+
print(f"GATE ROJO: no pude correr {nombre}: {e}", file=sys.stderr)
|
|
124
|
+
fallas += 1
|
|
125
|
+
continue
|
|
126
|
+
if len(salida) != len(CASOS):
|
|
127
|
+
print(f"GATE ROJO: {nombre} devolvió {len(salida)} valores y esperaba "
|
|
128
|
+
f"{len(CASOS)}", file=sys.stderr)
|
|
129
|
+
fallas += 1
|
|
130
|
+
continue
|
|
131
|
+
malos = [(s, esp, dio) for (s, esp), dio in zip(CASOS, salida) if esp != dio]
|
|
132
|
+
if malos:
|
|
133
|
+
fallas += 1
|
|
134
|
+
print(f"GATE ROJO: {nombre} no coincide con el canon:", file=sys.stderr)
|
|
135
|
+
for s, esp, dio in malos[:8]:
|
|
136
|
+
print(f" {s:>10} s → esperaba {esp!r}, dio {dio!r}", file=sys.stderr)
|
|
137
|
+
else:
|
|
138
|
+
print(f" ✓ {nombre}: {len(CASOS)}/{len(CASOS)}")
|
|
139
|
+
|
|
140
|
+
for s in salteadas:
|
|
141
|
+
print(f" · salteada: {s}")
|
|
142
|
+
if fallas:
|
|
143
|
+
return 1
|
|
144
|
+
if salteadas:
|
|
145
|
+
print("duraciones: coinciden las que se pudieron correr acá")
|
|
146
|
+
else:
|
|
147
|
+
print("duraciones: las cuatro coinciden")
|
|
148
|
+
return 0
|
|
149
|
+
|
|
150
|
+
|
|
151
|
+
if __name__ == "__main__":
|
|
152
|
+
raise SystemExit(main())
|
|
@@ -0,0 +1,87 @@
|
|
|
1
|
+
"""Dos invariantes del panel que no avisan cuando se rompen.
|
|
2
|
+
|
|
3
|
+
1 · Ninguna tarjeta puede ser más alta que una pantalla.
|
|
4
|
+
2 · Nada se dibuja fuera de la tarjeta.
|
|
5
|
+
|
|
6
|
+
El panel de GNOME es un `Gtk.Menu`, y un menú rueda ITEM por item: con un solo
|
|
7
|
+
item más alto que la pantalla no hay nada que rodar y el menú directamente no
|
|
8
|
+
abre — sin un error, sin un log, sin nada. Pasó de verdad: el panel creció a
|
|
9
|
+
946 px en un monitor cuya área útil son 728 y dejó de abrirse. Partirlo en una
|
|
10
|
+
tarjeta por cuenta lo arregló, pero sólo mientras ninguna tarjeta sola se pase.
|
|
11
|
+
"""
|
|
12
|
+
|
|
13
|
+
import importlib.machinery
|
|
14
|
+
import importlib.util
|
|
15
|
+
import sys
|
|
16
|
+
|
|
17
|
+
# El alto útil más chico que se puede esperar: una pantalla de 768 menos la
|
|
18
|
+
# barra de arriba y algo de aire.
|
|
19
|
+
TECHO = 700
|
|
20
|
+
|
|
21
|
+
|
|
22
|
+
def main() -> int:
|
|
23
|
+
spec = importlib.util.spec_from_loader(
|
|
24
|
+
"qm", importlib.machinery.SourceFileLoader("qm", "bin/qm-indicator"))
|
|
25
|
+
m = importlib.util.module_from_spec(spec)
|
|
26
|
+
spec.loader.exec_module(m)
|
|
27
|
+
m.TEMA = m.Tema(True)
|
|
28
|
+
m.FAMILIA = m.familia_del_sistema()
|
|
29
|
+
|
|
30
|
+
pluma = m._pluma_de_medir()
|
|
31
|
+
_, vistas = m.modelo_panel(m.leer_desde("test/fixtures/panel.json"))
|
|
32
|
+
altos = [(type(v).__name__, round(v.medir(pluma))) for v in vistas]
|
|
33
|
+
if not altos:
|
|
34
|
+
print("GATE ROJO: el fixture no produjo ni una tarjeta", file=sys.stderr)
|
|
35
|
+
return 1
|
|
36
|
+
nombre, alto = max(altos, key=lambda x: x[1])
|
|
37
|
+
if alto > TECHO:
|
|
38
|
+
print(f"GATE ROJO: la tarjeta {nombre} mide {alto} px y no entra en una "
|
|
39
|
+
f"pantalla de {TECHO} px útiles: el menú no va a abrir", file=sys.stderr)
|
|
40
|
+
return 1
|
|
41
|
+
|
|
42
|
+
if not margen_limpio(m):
|
|
43
|
+
return 1
|
|
44
|
+
|
|
45
|
+
print(f"tarjetas: la más alta es {nombre} con {alto} px, bajo el techo de {TECHO}; "
|
|
46
|
+
f"y nada se sale del margen")
|
|
47
|
+
return 0
|
|
48
|
+
|
|
49
|
+
|
|
50
|
+
def margen_limpio(m) -> bool:
|
|
51
|
+
"""Que ningún texto se dibuje fuera de la tarjeta.
|
|
52
|
+
|
|
53
|
+
Cairo no recorta nada: un nombre de perfil más largo que la tarjeta se
|
|
54
|
+
dibujaba por encima del borde y salía del panel. Se comprueba con el fixture
|
|
55
|
+
de nombres largos, midiendo píxeles en la franja de afuera —que tiene que
|
|
56
|
+
quedar exactamente del color del fondo— en vez de mirar la imagen a ojo.
|
|
57
|
+
"""
|
|
58
|
+
import cairo
|
|
59
|
+
|
|
60
|
+
datos = m.leer_desde("test/fixtures/panel-largos.json")
|
|
61
|
+
alto = m.medir_panel(datos)
|
|
62
|
+
sup = cairo.ImageSurface(cairo.FORMAT_ARGB32, m.ANCHO_PANEL, alto)
|
|
63
|
+
cr = cairo.Context(sup)
|
|
64
|
+
m.fondo_panel(cr, m.ANCHO_PANEL, alto)
|
|
65
|
+
m.dibujar_panel(cr, datos, alto)
|
|
66
|
+
sup.flush()
|
|
67
|
+
|
|
68
|
+
pix = bytes(sup.get_data())
|
|
69
|
+
stride = sup.get_stride()
|
|
70
|
+
fondo = pix[(alto // 2) * stride + 4 * 4:(alto // 2) * stride + 4 * 4 + 4]
|
|
71
|
+
# Dos píxeles adentro del borde de la tarjeta hacia afuera: ahí no va nada.
|
|
72
|
+
# Arriba y abajo se saltan 18 px porque ahí está la curva de la esquina
|
|
73
|
+
# redondeada del panel, que sí pasa por esa franja y no es un desborde.
|
|
74
|
+
desde = m.ANCHO_PANEL - m.MARGEN + 2
|
|
75
|
+
for y in range(18, alto - 18):
|
|
76
|
+
fila = y * stride
|
|
77
|
+
for x in range(desde, m.ANCHO_PANEL - 2):
|
|
78
|
+
if pix[fila + x * 4:fila + x * 4 + 4] != fondo:
|
|
79
|
+
print(f"GATE ROJO: hay algo dibujado en x={x}, fuera de la tarjeta "
|
|
80
|
+
f"(el margen empieza en {desde}): un texto largo se está "
|
|
81
|
+
f"saliendo en vez de cortarse", file=sys.stderr)
|
|
82
|
+
return False
|
|
83
|
+
return True
|
|
84
|
+
|
|
85
|
+
|
|
86
|
+
if __name__ == "__main__":
|
|
87
|
+
raise SystemExit(main())
|
|
@@ -0,0 +1,55 @@
|
|
|
1
|
+
#!/bin/sh
|
|
2
|
+
# El repositorio apt, armado dentro de docs/ para que lo sirva la misma página.
|
|
3
|
+
#
|
|
4
|
+
# No es un .deb suelto colgado de una release: es un repo firmado, así que
|
|
5
|
+
# `apt upgrade` trae la versión nueva sola y apt verifica la firma antes de
|
|
6
|
+
# instalar nada. Vive en GitHub Pages porque es estático — un repo apt es un
|
|
7
|
+
# árbol de archivos y un par de índices, no un servicio.
|
|
8
|
+
#
|
|
9
|
+
# La clave: se firma con la que ya tiene el mantenedor en la máquina. Si el
|
|
10
|
+
# agente de gpg no la tiene cacheada, esto va a pedir la contraseña, y eso está
|
|
11
|
+
# bien: firmar un repo de paquetes no es algo que deba pasar sin que nadie mire.
|
|
12
|
+
|
|
13
|
+
set -e
|
|
14
|
+
raiz=$(cd "$(dirname "$0")/.." && pwd)
|
|
15
|
+
cd "$raiz"
|
|
16
|
+
|
|
17
|
+
CLAVE=${QM_CLAVE_GPG:-B001E953E4CB848F}
|
|
18
|
+
SUITE=stable
|
|
19
|
+
APT="$raiz/docs/apt"
|
|
20
|
+
|
|
21
|
+
deb=$(./scripts/hacer-deb.sh "$raiz/dist")
|
|
22
|
+
version=$(dpkg-deb -f "$deb" Version)
|
|
23
|
+
|
|
24
|
+
rm -rf "$APT"
|
|
25
|
+
mkdir -p "$APT/pool/main/q/quartermaster" "$APT/dists/$SUITE/main/binary-all"
|
|
26
|
+
cp -f "$deb" "$APT/pool/main/q/quartermaster/"
|
|
27
|
+
|
|
28
|
+
cd "$APT"
|
|
29
|
+
dpkg-scanpackages --multiversion pool /dev/null > "dists/$SUITE/main/binary-all/Packages" 2>/dev/null
|
|
30
|
+
gzip -9c "dists/$SUITE/main/binary-all/Packages" > "dists/$SUITE/main/binary-all/Packages.gz"
|
|
31
|
+
|
|
32
|
+
apt-ftparchive \
|
|
33
|
+
-o "APT::FTPArchive::Release::Origin=Legios" \
|
|
34
|
+
-o "APT::FTPArchive::Release::Label=quartermaster" \
|
|
35
|
+
-o "APT::FTPArchive::Release::Suite=$SUITE" \
|
|
36
|
+
-o "APT::FTPArchive::Release::Codename=$SUITE" \
|
|
37
|
+
-o "APT::FTPArchive::Release::Architectures=all" \
|
|
38
|
+
-o "APT::FTPArchive::Release::Components=main" \
|
|
39
|
+
-o "APT::FTPArchive::Release::Description=quartermaster · Legios" \
|
|
40
|
+
release "dists/$SUITE" > "$raiz/dist/Release.tmp"
|
|
41
|
+
# A un temporal y después se mueve: la redirección de la shell crea el archivo
|
|
42
|
+
# ANTES de que corra el comando, así que apt-ftparchive encontraba un Release
|
|
43
|
+
# vacío adentro del directorio que estaba escaneando y lo listaba en su propia
|
|
44
|
+
# lista de sumas.
|
|
45
|
+
mv "$raiz/dist/Release.tmp" "dists/$SUITE/Release"
|
|
46
|
+
|
|
47
|
+
# InRelease (firma incorporada) y Release.gpg (separada): apt moderno usa la
|
|
48
|
+
# primera, pero la segunda no cuesta nada y cubre a los que todavía no.
|
|
49
|
+
gpg --batch --yes --default-key "$CLAVE" --clearsign \
|
|
50
|
+
-o "dists/$SUITE/InRelease" "dists/$SUITE/Release"
|
|
51
|
+
gpg --batch --yes --default-key "$CLAVE" -abs \
|
|
52
|
+
-o "dists/$SUITE/Release.gpg" "dists/$SUITE/Release"
|
|
53
|
+
gpg --armor --export "$CLAVE" > legios.gpg
|
|
54
|
+
|
|
55
|
+
echo "repo apt armado: quartermaster $version, firmado con $CLAVE"
|
|
@@ -0,0 +1,65 @@
|
|
|
1
|
+
#!/bin/sh
|
|
2
|
+
# El .deb, armado desde el árbol de trabajo.
|
|
3
|
+
#
|
|
4
|
+
# No compila nada: qm lee el TypeScript directo, así que el paquete es el fuente
|
|
5
|
+
# más un enlace en /usr/bin. Por eso `Architecture: all`.
|
|
6
|
+
#
|
|
7
|
+
# La dependencia dice `nodejs` a secas y no `nodejs (>= 22.6)` a propósito.
|
|
8
|
+
# Debian 13 trae un 20, así que pedir 22.6 haría el paquete instalable en
|
|
9
|
+
# ninguna parte — y la versión nueva suele estar en nvm, que apt no ve. El
|
|
10
|
+
# lanzador ya busca un Node que sirva y, si no lo encuentra, lo dice con todas
|
|
11
|
+
# las letras y explica cómo conseguirlo. Mejor un paquete que instala y avisa
|
|
12
|
+
# que uno que apt se niega a instalar por una razón que no es cierta.
|
|
13
|
+
|
|
14
|
+
set -e
|
|
15
|
+
raiz=$(cd "$(dirname "$0")/.." && pwd)
|
|
16
|
+
cd "$raiz"
|
|
17
|
+
|
|
18
|
+
version=$(node -p "require('./package.json').version" 2>/dev/null ||
|
|
19
|
+
sed -n 's/.*"version": "\([^"]*\)".*/\1/p' package.json | head -1)
|
|
20
|
+
[ -n "$version" ] || { echo "no pude sacar la versión de package.json" >&2; exit 1; }
|
|
21
|
+
|
|
22
|
+
destino=${1:-$raiz/dist}
|
|
23
|
+
mkdir -p "$destino"
|
|
24
|
+
arma=$(mktemp -d)
|
|
25
|
+
trap 'rm -rf "$arma"' EXIT
|
|
26
|
+
|
|
27
|
+
mkdir -p "$arma/DEBIAN" "$arma/usr/lib/quartermaster" "$arma/usr/bin" \
|
|
28
|
+
"$arma/usr/share/doc/quartermaster"
|
|
29
|
+
|
|
30
|
+
cp -r bin src scripts extension Makefile package.json "$arma/usr/lib/quartermaster/"
|
|
31
|
+
cp README.md LICENSE "$arma/usr/share/doc/quartermaster/"
|
|
32
|
+
# El lanzador sigue los symlinks para encontrar el src/, así que un enlace
|
|
33
|
+
# alcanza y no hay que duplicar el árbol.
|
|
34
|
+
ln -sf /usr/lib/quartermaster/bin/qm "$arma/usr/bin/qm"
|
|
35
|
+
find "$arma/usr/lib/quartermaster" -name '__pycache__' -prune -exec rm -rf {} +
|
|
36
|
+
|
|
37
|
+
cat > "$arma/DEBIAN/control" <<EOF
|
|
38
|
+
Package: quartermaster
|
|
39
|
+
Version: $version
|
|
40
|
+
Section: devel
|
|
41
|
+
Priority: optional
|
|
42
|
+
Architecture: all
|
|
43
|
+
Depends: nodejs
|
|
44
|
+
Suggests: python3-gi, python3-cairo, gir1.2-gtk-3.0, gir1.2-ayatanaappindicator3-0.1
|
|
45
|
+
Maintainer: Legios <valentintorassacolombero@gmail.com>
|
|
46
|
+
Homepage: https://github.com/legiosai/quartermaster
|
|
47
|
+
Description: Cuánta cuota te queda en todos tus perfiles de Claude Code
|
|
48
|
+
Lee TODOS los CLAUDE_CONFIG_DIR de la máquina, no sólo el directorio por
|
|
49
|
+
defecto, y suma Codex y los proveedores que guarda opencode.
|
|
50
|
+
.
|
|
51
|
+
El número no necesita red ni credenciales: sale del cache que Claude Code deja
|
|
52
|
+
en el .claude.json de cada perfil, así que se lee aunque el token esté vencido.
|
|
53
|
+
.
|
|
54
|
+
Necesita Node >= 22.6, porque qm lee el TypeScript sin paso de build. El
|
|
55
|
+
lanzador lo busca en el PATH y en nvm; si no encuentra uno que sirva, lo dice.
|
|
56
|
+
EOF
|
|
57
|
+
|
|
58
|
+
chmod 0755 "$arma/usr/lib/quartermaster/bin/qm" \
|
|
59
|
+
"$arma/usr/lib/quartermaster/bin/qm-indicator" \
|
|
60
|
+
"$arma/usr/lib/quartermaster/bin/qm-web" \
|
|
61
|
+
"$arma/usr/lib/quartermaster/scripts/"*.sh 2>/dev/null || true
|
|
62
|
+
|
|
63
|
+
paquete="$destino/quartermaster_${version}_all.deb"
|
|
64
|
+
fakeroot dpkg-deb --build "$arma" "$paquete" >/dev/null
|
|
65
|
+
echo "$paquete"
|