Calio/scripts/container-smoke.js
Elijah 80fc48b9f1
All checks were successful
Verify and publish Calio container / build-and-push (push) Successful in 1m2s
Add barcode and nutrition label scanning
Barcode scanning
- Scan barcode in the food sheet reads UPC-A/E and EAN-13/8 live from
  the camera with ZXing WebAssembly (bundled, precached, CSP allows
  wasm), with photo and typed-digit fallbacks
- Lookups check saved foods first (offline), then local copies of USDA
  FoodData Central Branded Foods and Open Food Facts, then the live
  Open Food Facts API; API answers and misses are cached
- Server imports refresh in a low-priority child process: USDA when a
  new archive is published, Open Food Facts weekly by streaming its CSV
  export; each import builds a new table and swaps it in atomically
- Every available nutrient is kept: foods and entries gain optional
  barcode (GTIN-14) and extra nutrients, shown under More nutrients and
  included in JSON exports
- Settings shows the size, date and any error for each product copy

Label scanning
- Scan label sends a downscaled photo to the server, read with
  PaddleOCR PP-OCRv5 (server detection, English recognition) on ONNX
  Runtime CPU, about 1.3 s median
- Parser handles US/Canadian, linear, Spanish and EU per-100 g panels,
  tilted photos, OCR misspellings and %DV cross-checks
- Models are pinned and checksum-verified at image build time

Container
- Runtime moves to Debian slim for ONNX Runtime's glibc build; other
  platforms' binaries are pruned
- Smoke tests now read a fixture label inside the container
- README and Unraid docs cover disk use, network access and refresh

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-22 13:41:44 -07:00

183 lines
5.8 KiB
JavaScript

import { execFileSync, spawnSync } from "node:child_process";
import assert from "node:assert/strict";
import { randomBytes } from "node:crypto";
import { readFileSync } from "node:fs";
import { emptyNutrients } from "../shared/domain.js";
const image = process.argv[2] || "calio:local";
const unraid = process.argv.includes("--unraid");
const suffix = randomBytes(4).toString("hex");
const name = "calio-smoke-" + suffix;
const volume = name + "-data";
const password = randomBytes(24).toString("hex");
const docker = (args, input) =>
execFileSync("docker", args, {
encoding: "utf8",
input,
stdio: [input === undefined ? "ignore" : "pipe", "pipe", "pipe"],
}).trim();
async function start() {
docker([
"run",
"-d",
"--name",
name,
...(unraid ? ["--user", "99:100"] : []),
...(unraid
? ["--mount", `type=volume,source=${volume},target=/data,volume-nocopy`]
: ["-v", volume + ":/data"]),
"--read-only",
"--tmpfs",
"/tmp",
"--cap-drop",
"ALL",
"--security-opt",
"no-new-privileges:true",
"-e",
"APP_ORIGIN=http://localhost:3000",
"-e",
"COOKIE_SECURE=false",
"-e",
"CALIO_USERNAME=smoke",
"-e",
"CALIO_PASSWORD=" + password,
image,
]);
let lastError;
for (let i = 0; i < 50; i++) {
try {
if ((await request("/api/health")).status === 200) return;
} catch (error) {
lastError = error;
if (
docker(["inspect", "--format", "{{.State.Running}}", name]) === "false"
)
break;
}
await new Promise((resolve) => setTimeout(resolve, 200));
}
const logs = spawnSync("docker", ["logs", name], { encoding: "utf8" });
throw new Error(
"Container failed to start: " +
logs.stdout +
logs.stderr +
"\n" +
(lastError?.message || "") +
"\n" +
docker(["inspect", "--format", "{{json .State}}", name]),
);
}
// In-container probes work on socket-mounted Forgejo runners without published ports.
// `image` (base64 PNG) is posted as the raw request body.
const request = async (path, body, cookie, image) => {
const probe = `let input=''; for await (const chunk of process.stdin) input+=chunk;
const {path,body,cookie,image}=JSON.parse(input);
const response=await fetch('http://127.0.0.1:3000'+path,{
method:body===undefined&&!image?'GET':'POST',
headers:{'Content-Type':image?'image/png':'application/json',Origin:'http://localhost:3000','X-Calio-Request':'1',Cookie:cookie||''},
body:image?Buffer.from(image,'base64'):body===undefined?undefined:JSON.stringify(body)
});
console.log(JSON.stringify({status:response.status,cookie:response.headers.get('set-cookie'),body:await response.text()}));`;
const result = JSON.parse(
docker(
["exec", "-i", name, "node", "--input-type=module", "-e", probe],
JSON.stringify({ path, body, cookie, image }),
),
);
return {
status: result.status,
headers: new Headers(result.cookie ? { "set-cookie": result.cookie } : {}),
text: async () => result.body,
json: async () => JSON.parse(result.body),
};
};
try {
if (unraid) {
docker(["volume", "create", volume]);
// Only initialize the unique, disposable test volume, as on Unraid appdata.
docker([
"run",
"--rm",
"--user",
"0:0",
"-v",
volume + ":/data",
"--entrypoint",
"sh",
image,
"-c",
"chown 99:100 /data",
]);
}
await start();
assert.equal((await request("/api/records")).status, 401);
const login = await request("/api/login", { username: "smoke", password });
assert.equal(login.status, 200);
const cookie = login.headers.get("set-cookie").split(";")[0];
const record = {
id: "persistence-test",
type: "food",
updatedAt: new Date().toISOString(),
deleted: false,
data: {
name: "Test food",
serving: "1 serving",
nutrients: emptyNutrients(),
},
};
assert.equal(
(await request("/api/sync", { records: [record] }, cookie)).status,
200,
);
for (const path of [
"/",
"/sw.js",
"/sw",
"/manifest.webmanifest",
"/icons/apple-touch-icon.png",
"/icons/apple-touch-icon-v2.png",
])
assert.equal((await request(path)).status, 200, path);
// The bundled OCR models load and read a label inside the image.
const label = await request(
"/api/label",
undefined,
cookie,
readFileSync(
new URL("../tests/fixtures/label.png", import.meta.url),
).toString("base64"),
);
assert.equal(label.status, 200, await label.text());
const read = (await label.json()).label;
assert.deepEqual(read.nutrients, {
calories: 230,
fat: 8,
sodium: 160,
carbs: 37,
fiber: 4,
sugar: 12,
protein: 3,
});
assert.equal(read.serving, "2/3 cup (55 g)");
assert.equal((await request("/api/products", undefined, cookie)).status, 200);
const html = await (await request("/")).text();
const asset = html.match(/src="(\/assets\/[^\"]+)"/)[1];
assert.equal((await request(asset)).status, 200);
assert.equal(docker(["exec", name, "id", "-u"]), unraid ? "99" : "1000");
if (unraid) assert.equal(docker(["exec", name, "id", "-g"]), "100");
docker(["rm", "-f", name]);
await start();
// Session and journal both survive a full container replacement, as during an update.
const response = await request("/api/records", undefined, cookie);
assert.equal(response.status, 200);
assert.deepEqual((await response.json()).records, [record]);
console.log(
`PASS (${unraid ? "Unraid 99:100" : "default 1000"}): non-root container, production assets, authentication, label OCR, read-only root, persistent volume and sessions after container recreation.`,
);
} finally {
try {
docker(["rm", "-f", name]);
} catch {}
try {
docker(["volume", "rm", volume]);
} catch {}
}