@legios/quartermaster 0.1.3 → 0.1.4
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/package.json +6 -3
- package/scripts/construir.mjs +29 -0
- package/scripts/el-paquete-de-npm-corre.sh +48 -0
- package/scripts/gate-dibujo.sh +90 -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/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@legios/quartermaster",
|
|
3
|
-
"version": "0.1.
|
|
3
|
+
"version": "0.1.4",
|
|
4
4
|
"description": "Cuánta cuota te queda en TODOS los perfiles de Claude Code de la máquina, más Codex y los proveedores de opencode. Sin red y sin credenciales: el número sale del cache que Claude Code deja en disco.",
|
|
5
5
|
"keywords": [
|
|
6
6
|
"claude-code",
|
|
@@ -31,11 +31,13 @@
|
|
|
31
31
|
},
|
|
32
32
|
"bin": {
|
|
33
33
|
"qm": "bin/qm",
|
|
34
|
-
"qm-web": "bin/qm-web"
|
|
34
|
+
"qm-web": "bin/qm-web",
|
|
35
|
+
"qm-barra": "bin/qm-barra"
|
|
35
36
|
},
|
|
36
37
|
"files": [
|
|
37
38
|
"bin/",
|
|
38
39
|
"dist/",
|
|
40
|
+
"scripts/",
|
|
39
41
|
"src/render/tablero.html",
|
|
40
42
|
"LICENSE",
|
|
41
43
|
"README.md"
|
|
@@ -50,7 +52,8 @@
|
|
|
50
52
|
"demo-h0": "node scripts/nodo.cjs && node --experimental-strip-types src/cli/preflight.ts",
|
|
51
53
|
"demo-h1": "node scripts/nodo.cjs && node --experimental-strip-types src/cli/demo-h1.ts",
|
|
52
54
|
"construir": "node scripts/construir.mjs",
|
|
53
|
-
"prepublishOnly": "node scripts/nodo.cjs && npm run typecheck && npm test && npm run construir"
|
|
55
|
+
"prepublishOnly": "node scripts/nodo.cjs && npm run typecheck && npm test && npm run construir",
|
|
56
|
+
"postinstall": "node scripts/instalar-barra.mjs"
|
|
54
57
|
},
|
|
55
58
|
"devDependencies": {
|
|
56
59
|
"@types/node": "^22.10.0",
|
|
@@ -0,0 +1,29 @@
|
|
|
1
|
+
// Compila src/ a dist/ y copia los activos estáticos que el TypeScript no toca.
|
|
2
|
+
//
|
|
3
|
+
// Sólo hace falta para el tarball de npm: Node se niega a hacer type stripping
|
|
4
|
+
// bajo node_modules, que es donde vive un `npm install -g`. Las otras tres vías
|
|
5
|
+
// —make instalar, el .deb y brew— leen el TypeScript directo y no pasan por acá.
|
|
6
|
+
import { execFileSync } from 'node:child_process';
|
|
7
|
+
import { cpSync, existsSync, mkdirSync, rmSync } from 'node:fs';
|
|
8
|
+
import { dirname, join } from 'node:path';
|
|
9
|
+
import { fileURLToPath } from 'node:url';
|
|
10
|
+
|
|
11
|
+
const RAIZ = join(dirname(fileURLToPath(import.meta.url)), '..');
|
|
12
|
+
|
|
13
|
+
rmSync(join(RAIZ, 'dist'), { recursive: true, force: true });
|
|
14
|
+
|
|
15
|
+
// El tsc LOCAL, no `npx tsc`: npx resuelve por PATH y en una máquina con otro
|
|
16
|
+
// tsc adelante compila con la versión equivocada, o directamente no lo
|
|
17
|
+
// encuentra si node_modules no está instalado. El binario del lockfile o nada.
|
|
18
|
+
const TSC = join(RAIZ, 'node_modules', '.bin', 'tsc');
|
|
19
|
+
if (!existsSync(TSC)) {
|
|
20
|
+
console.error('falta node_modules/.bin/tsc — corré `npm install` antes de construir');
|
|
21
|
+
process.exit(1);
|
|
22
|
+
}
|
|
23
|
+
execFileSync(TSC, ['-p', 'tsconfig.build.json'], { cwd: RAIZ, stdio: 'inherit' });
|
|
24
|
+
|
|
25
|
+
// El tablero es HTML plano: tsc no lo ve y bin/qm-web lo busca en dist primero.
|
|
26
|
+
mkdirSync(join(RAIZ, 'dist', 'render'), { recursive: true });
|
|
27
|
+
cpSync(join(RAIZ, 'src', 'render', 'tablero.html'), join(RAIZ, 'dist', 'render', 'tablero.html'));
|
|
28
|
+
|
|
29
|
+
console.log('✓ dist/ construido — cli, adapters, core, render y el tablero');
|
|
@@ -0,0 +1,48 @@
|
|
|
1
|
+
#!/usr/bin/env bash
|
|
2
|
+
# Gate: el tarball que sale a npm se instala Y CORRE.
|
|
3
|
+
#
|
|
4
|
+
# Existe por un defecto real. El repo lee el TypeScript directo, sin build, y eso
|
|
5
|
+
# anda para `make instalar`, el .deb y brew. Para npm NO: Node se niega a hacer
|
|
6
|
+
# type stripping de nada bajo node_modules
|
|
7
|
+
# ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING
|
|
8
|
+
# y `npm install -g` deja el paquete exactamente ahí. `npm install` decía "added
|
|
9
|
+
# 1 package" y después `qm` moría en cada invocación.
|
|
10
|
+
#
|
|
11
|
+
# Por eso el gate no comprueba que el tarball EXISTA ni que tenga los archivos:
|
|
12
|
+
# los tenía. Lo instala en un prefix limpio y lo ejecuta, que es la única forma
|
|
13
|
+
# de ver este defecto — vive en la ruta de instalación, no en el contenido.
|
|
14
|
+
#
|
|
15
|
+
# Probado en rojo: `make gate-npm-rojo` saca dist/ del tarball y esto falla con
|
|
16
|
+
# el mismo error que se midió el 2026-09-11.
|
|
17
|
+
set -euo pipefail
|
|
18
|
+
|
|
19
|
+
RAIZ=$(cd "$(dirname "$0")/.." && pwd)
|
|
20
|
+
TMP=$(mktemp -d)
|
|
21
|
+
trap 'rm -rf "$TMP"' EXIT
|
|
22
|
+
|
|
23
|
+
cd "$RAIZ"
|
|
24
|
+
npm run --silent construir >/dev/null
|
|
25
|
+
TARBALL=$(npm pack --silent --pack-destination "$TMP")
|
|
26
|
+
|
|
27
|
+
npm i -g --silent --prefix "$TMP/pref" "$TMP/$TARBALL" >/dev/null
|
|
28
|
+
|
|
29
|
+
# --breve es el camino más corto que toca todo: perfiles, cache y render.
|
|
30
|
+
if ! SALIDA=$("$TMP/pref/bin/qm" --breve 2>&1); then
|
|
31
|
+
echo "✗ el paquete instalado no corre:" >&2
|
|
32
|
+
echo "$SALIDA" | head -5 >&2
|
|
33
|
+
exit 1
|
|
34
|
+
fi
|
|
35
|
+
[ -n "$SALIDA" ] || { echo "✗ qm --breve no imprimió nada desde el paquete instalado" >&2; exit 1; }
|
|
36
|
+
echo " ✓ qm --breve desde el paquete instalado: $SALIDA"
|
|
37
|
+
|
|
38
|
+
if ! "$TMP/pref/bin/qm" --json --redactado >/dev/null 2>&1; then
|
|
39
|
+
echo "✗ qm --json falla desde el paquete instalado" >&2
|
|
40
|
+
exit 1
|
|
41
|
+
fi
|
|
42
|
+
echo " ✓ qm --json desde el paquete instalado"
|
|
43
|
+
|
|
44
|
+
PAQ="$TMP/pref/lib/node_modules/@legios/quartermaster"
|
|
45
|
+
[ -f "$PAQ/dist/render/tablero.html" ] || { echo "✗ el tablero no llegó al paquete: qm-web no tendría qué servir" >&2; exit 1; }
|
|
46
|
+
echo " ✓ el tablero viajó en el paquete"
|
|
47
|
+
|
|
48
|
+
echo "✓ el paquete de npm se instala y corre"
|
|
@@ -0,0 +1,90 @@
|
|
|
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
|
+
python3 bin/qm-indicator --desde test/fixtures/panel.json --oscuro \
|
|
44
|
+
--captura "$salida/panel.png" >/dev/null || fallar "no dibujó el panel"
|
|
45
|
+
python3 bin/qm-indicator --desde test/fixtures/panel.json --oscuro \
|
|
46
|
+
--captura-item "$salida/item.png" >/dev/null || fallar "no dibujó el item"
|
|
47
|
+
|
|
48
|
+
python3 - "$salida/panel.png" "$salida/item.png" <<'PY'
|
|
49
|
+
import sys
|
|
50
|
+
import cairo
|
|
51
|
+
|
|
52
|
+
def medir(ruta):
|
|
53
|
+
s = cairo.ImageSurface.create_from_png(ruta)
|
|
54
|
+
datos = bytes(s.get_data())
|
|
55
|
+
# Cuántos píxeles tienen algo. Un PNG del tamaño correcto y enteramente
|
|
56
|
+
# transparente pasa cualquier chequeo de medidas y no dibujó nada.
|
|
57
|
+
pintados = sum(1 for i in range(3, len(datos), 4) if datos[i] != 0)
|
|
58
|
+
return s.get_width(), s.get_height(), pintados
|
|
59
|
+
|
|
60
|
+
fallas = []
|
|
61
|
+
ancho, alto, pintados = medir(sys.argv[1])
|
|
62
|
+
if ancho != 360:
|
|
63
|
+
fallas.append(f"el panel salió de {ancho} px de ancho y tiene que ser 360")
|
|
64
|
+
if not 600 <= alto <= 2400:
|
|
65
|
+
fallas.append(f"el panel salió de {alto} px de alto, fuera de lo razonable")
|
|
66
|
+
if pintados < ancho * alto // 2:
|
|
67
|
+
fallas.append(f"el panel está casi vacío: {pintados} píxeles con algo")
|
|
68
|
+
|
|
69
|
+
ancho, alto, pintados = medir(sys.argv[2])
|
|
70
|
+
if alto != 22:
|
|
71
|
+
fallas.append(f"el item salió de {alto} px de alto y tiene que ser 22")
|
|
72
|
+
# La proporción es lo que decide si GNOME lo dibuja a lo ancho o lo encaja en un
|
|
73
|
+
# cuadrado de 16 px. Abajo de 1.5 los medidores se vuelven ilegibles.
|
|
74
|
+
if ancho < alto * 1.5:
|
|
75
|
+
fallas.append(f"el item quedó de {ancho}x{alto}: GNOME lo va a encajar en un cuadrado")
|
|
76
|
+
if pintados == 0:
|
|
77
|
+
fallas.append("el item no tiene un solo píxel dibujado")
|
|
78
|
+
|
|
79
|
+
if fallas:
|
|
80
|
+
for f in fallas:
|
|
81
|
+
print(f"GATE ROJO: {f}", file=sys.stderr)
|
|
82
|
+
raise SystemExit(1)
|
|
83
|
+
print("dibujo verificado: panel 360 px y item ancho, los dos con píxeles adentro")
|
|
84
|
+
PY
|
|
85
|
+
|
|
86
|
+
# 4 · y que ninguna tarjeta sola sea más alta que una pantalla: el panel es un
|
|
87
|
+
# menú, y un menú rueda item por item.
|
|
88
|
+
python3 scripts/gate-tarjetas.py || exit 1
|
|
89
|
+
|
|
90
|
+
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"
|
|
@@ -0,0 +1,72 @@
|
|
|
1
|
+
// postinstall: en macOS, deja la barra de menú andando y arrancando sola.
|
|
2
|
+
//
|
|
3
|
+
// Por qué existe: `npm install -g` dejaba el CLI en el PATH y NINGUNA señal
|
|
4
|
+
// visible. La barra es lo que uno mira sin ir a buscarlo —el punto entero del
|
|
5
|
+
// programa— y venía dentro del paquete sin que nada la arrancara ni la pusiera
|
|
6
|
+
// en el PATH. Quien instalaba por npm en macOS instalaba y no pasaba nada.
|
|
7
|
+
//
|
|
8
|
+
// ESTE SCRIPT NUNCA FALLA UNA INSTALACIÓN. Sale 0 pase lo que pase: un
|
|
9
|
+
// postinstall que rompe `npm install` por no poder dibujar un ícono es un trato
|
|
10
|
+
// pésimo. Si algo no sale, lo dice y sigue.
|
|
11
|
+
//
|
|
12
|
+
// Y no corre donde no corresponde: sólo macOS, sólo instalación global, nunca
|
|
13
|
+
// en CI, nunca como root. Un contenedor de build no quiere un agente de launchd.
|
|
14
|
+
import { execFileSync, spawn } from 'node:child_process';
|
|
15
|
+
import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
|
|
16
|
+
import { homedir, platform } from 'node:os';
|
|
17
|
+
import { dirname, join } from 'node:path';
|
|
18
|
+
import { fileURLToPath } from 'node:url';
|
|
19
|
+
|
|
20
|
+
const RAIZ = join(dirname(fileURLToPath(import.meta.url)), '..');
|
|
21
|
+
const ETIQUETA = 'com.legios.quartermaster.barra';
|
|
22
|
+
const PLIST = join(homedir(), 'Library', 'LaunchAgents', `${ETIQUETA}.plist`);
|
|
23
|
+
const BARRA = join(RAIZ, 'bin', 'qm-barra');
|
|
24
|
+
|
|
25
|
+
const saltar = (motivo) => {
|
|
26
|
+
// En silencio: no es un error, es que acá no va.
|
|
27
|
+
if (process.env['QM_DEBUG_POSTINSTALL']) console.log(`qm: sin barra (${motivo})`);
|
|
28
|
+
process.exit(0);
|
|
29
|
+
};
|
|
30
|
+
|
|
31
|
+
try {
|
|
32
|
+
if (platform() !== 'darwin') saltar('no es macOS');
|
|
33
|
+
if (process.env['npm_config_global'] !== 'true') saltar('no es una instalación global');
|
|
34
|
+
if (process.env['CI']) saltar('CI');
|
|
35
|
+
if (typeof process.getuid === 'function' && process.getuid() === 0) saltar('root');
|
|
36
|
+
if (!existsSync(BARRA)) saltar('no está bin/qm-barra');
|
|
37
|
+
|
|
38
|
+
mkdirSync(dirname(PLIST), { recursive: true });
|
|
39
|
+
writeFileSync(
|
|
40
|
+
PLIST,
|
|
41
|
+
`<?xml version="1.0" encoding="UTF-8"?>
|
|
42
|
+
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
|
|
43
|
+
<plist version="1.0"><dict>
|
|
44
|
+
<key>Label</key><string>${ETIQUETA}</string>
|
|
45
|
+
<key>ProgramArguments</key><array><string>${BARRA}</string></array>
|
|
46
|
+
<key>RunAtLoad</key><true/>
|
|
47
|
+
<key>KeepAlive</key><false/>
|
|
48
|
+
</dict></plist>
|
|
49
|
+
`,
|
|
50
|
+
'utf8',
|
|
51
|
+
);
|
|
52
|
+
|
|
53
|
+
// unload primero: si ya había una apuntando al checkout viejo, queda colgada.
|
|
54
|
+
try {
|
|
55
|
+
execFileSync('launchctl', ['unload', PLIST], { stdio: 'ignore' });
|
|
56
|
+
} catch {
|
|
57
|
+
/* no estaba cargada */
|
|
58
|
+
}
|
|
59
|
+
execFileSync('launchctl', ['load', PLIST], { stdio: 'ignore' });
|
|
60
|
+
|
|
61
|
+
// launchd la arranca por RunAtLoad, pero la PRIMERA vez tiene que compilar el
|
|
62
|
+
// Swift y eso tarda. Se lanza también en paralelo y desasociada, así que el
|
|
63
|
+
// ícono aparece durante el install y no varios segundos después.
|
|
64
|
+
spawn(BARRA, [], { detached: true, stdio: 'ignore' }).unref();
|
|
65
|
+
|
|
66
|
+
console.log('qm: barra de menú instalada — arranca sola al iniciar sesión');
|
|
67
|
+
console.log(' sacarla: launchctl unload ' + PLIST);
|
|
68
|
+
} catch (e) {
|
|
69
|
+
console.log(`qm: no pude dejar la barra andando (${e && e.message ? e.message : e}).`);
|
|
70
|
+
console.log(' el CLI quedó bien: probá `qm`. La barra: `qm-barra`.');
|
|
71
|
+
}
|
|
72
|
+
process.exit(0);
|
package/scripts/nodo.cjs
ADDED
|
@@ -0,0 +1,20 @@
|
|
|
1
|
+
// Guarda de versión. Es .cjs a propósito: tiene que poder correr en el Node
|
|
2
|
+
// que el usuario tenga, incluso uno que no entienda TypeScript ni ESM moderno.
|
|
3
|
+
//
|
|
4
|
+
// Sin esto, en Node 20 todo comando de este repo muere con
|
|
5
|
+
// node: bad option: --experimental-strip-types
|
|
6
|
+
// que no le dice a nadie qué hacer. Un error opaco es la misma clase de bug
|
|
7
|
+
// que un monitor mudo (ver SOUL.md).
|
|
8
|
+
|
|
9
|
+
var partes = process.versions.node.split('.').map(Number);
|
|
10
|
+
var mayor = partes[0] || 0;
|
|
11
|
+
var menor = partes[1] || 0;
|
|
12
|
+
|
|
13
|
+
if (mayor < 22 || (mayor === 22 && menor < 6)) {
|
|
14
|
+
process.stderr.write(
|
|
15
|
+
'\nquartermaster necesita Node >= 22.6 (tenés ' + process.versions.node + ').\n' +
|
|
16
|
+
'Lee TypeScript directamente, sin paso de build, y eso recién existe desde 22.6.\n\n' +
|
|
17
|
+
' nvm install 22 && nvm use 22\n\n',
|
|
18
|
+
);
|
|
19
|
+
process.exit(1);
|
|
20
|
+
}
|