@teamscala/service-boot 0.23.338 → 0.23.340

package/package.json

@@ -6,7 +6,7 @@
 	},
 	"name": "@teamscala/service-boot",
 	"type": "module",
-	"version": "0.23.338",
+	"version": "0.23.340",
 	"sideEffects": false,
 	"files": [
 		"src"

package/src/handlers/sweep-host-cache.d.ts

@@ -19,3 +19,6 @@ export declare function checkDirStale(dir: string, cutoffMs: number): Promise<{
     bytes: number;
     fileCount: number;
 }>;
+/** Parse the root-fs Use% from `df --output=pcent,target` output (pure, for tests).
+ *  Returns null if no root-mount line is found. */
+export declare function parseRootDiskPct(out: string): number | null;

package/src/handlers/sweep-host-cache.test.ts

@@ -14,7 +14,7 @@ import { describe, expect, test, beforeEach, afterEach } from "bun:test";
 import { mkdtempSync, mkdirSync, writeFileSync, rmSync, utimesSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
-import { expandGlob, checkDirStale } from "./sweep-host-cache.ts";
+import { expandGlob, checkDirStale, parseRootDiskPct } from "./sweep-host-cache.ts";
 
 const DAY = 86_400_000;
 const now = Date.now();
@@ -83,3 +83,51 @@ describe("checkDirStale", () => {
 		expect(res.fileCount).toBe(0);
 	});
 });
+
+describe("parseRootDiskPct", () => {
+	test("extracts root-fs Use% from df --output=pcent,target output", () => {
+		const df =
+			"Use% Mounted on\n" +
+			"  97% /\n" +
+			"  45% /home\n";
+		expect(parseRootDiskPct(df)).toBe(97);
+	});
+	test("picks the root mount (/) over nested mounts", () => {
+		const df =
+			"Use% Mounted on\n" +
+			"  10% /proc/x\n" +
+			"  76% /\n";
+		expect(parseRootDiskPct(df)).toBe(76);
+	});
+	test("returns null when no root-mount line present", () => {
+		const df = "Use% Mounted on\n  40% /mnt/other\n";
+		expect(parseRootDiskPct(df)).toBeNull();
+	});
+	test("returns null on empty / malformed output", () => {
+		expect(parseRootDiskPct("")).toBeNull();
+		expect(parseRootDiskPct("Use% Mounted on")).toBeNull();
+	});
+});
+
+describe("disk-threshold early-warning regression lock", () => {
+	const { readFileSync } = require("node:fs");
+	// Source-shape lock (same pattern as singleton-tools-currency-watch.test.ts):
+	// the df-check that rides this periodic sweep was once removed in favour of an
+	// in-process interval watchdog — the wrong architecture (interval watchdogs
+	// are forbidden; observability is event-driven). This asserts the corrected
+	// shape survives: the sweep handler MUST carry the event-driven host.disk.high
+	// emission (logger.warn -> GlitchTip) + the pure parseRootDiskPct helper that
+	// backs it. Removing either fails this test. The asserted surface is the
+	// disk early-warning cell of host-resources-have-complete-monitoring.
+	const src = readFileSync(import.meta.dir + "/sweep-host-cache.ts", "utf-8");
+	test("handler emits the host.disk.high event (event-driven, not an interval)", () => {
+		expect(src).toContain('log.warn("host.disk.high"');
+		expect(src).toContain('kind: "host.disk.high"');
+	});
+	test("handler reads df via the sanctioned spawn (no in-process poller)", () => {
+		expect(src).toContain('command: ["df", "--output=pcent,target"]');
+	});
+	test("threshold parse is the exported pure helper", () => {
+		expect(src).toContain("export function parseRootDiskPct");
+	});
+});

package/src/handlers/sweep-host-cache.ts

@@ -42,6 +42,7 @@
 import { rm, readdir, stat } from "node:fs/promises";
 import { readdirSync, type Dirent } from "node:fs";
 import { join } from "node:path";
+import { spawnSync } from "@teamscala/os/spawn/spawn";
 import { userHome, workspaceRoot } from "@teamscala/os/host-paths";
 import { formatBytes } from "@teamscala/formatters/format-bytes";
 import { recordEvent } from "@teamscala/event-log/record-event";
@@ -199,6 +200,14 @@ export async function checkDirStale(
 	return { stale: true, bytes, fileCount };
 }
 
+/** Parse the root-fs Use% from `df --output=pcent,target` output (pure, for tests).
+ *  Returns null if no root-mount line is found. */
+export function parseRootDiskPct(out: string): number | null {
+	const rootLine = out.split("\n").find((l) => l.trim().endsWith("/"));
+	const m = rootLine?.match(/(\d+)%/);
+	return m ? Number(m[1]) : null;
+}
+
 async function sweepHostCache(ctx: {
 	config: { retention?: Record<string, string>; retention_dirs?: Record<string, string> };
 }): Promise<void> {
@@ -289,6 +298,28 @@ async function sweepHostCache(ctx: {
 		},
 	});
 
+	// Disk-threshold observability — rides this periodic sweep (NOT an interval:
+	// this job is genuinely periodic application-DATA work — deletion — and the
+	// df read piggybacks once per run). Emits through the event-driven surface:
+	// logger.warn -> GlitchTip (the paging path, same as host.pressure) +
+	// recordEvent for the durable event_log record. Catches a fill faster than
+	// the nightly prune can absorb (a cache with no retention entry, an external
+	// dump, a runaway log) so the operator learns it within a day, not at 100%.
+	const diskHighPct = 90;
+	try {
+		const dfRes = spawnSync({ name: "df:/", command: ["df", "--output=pcent,target"], timeoutMs: 5_000 });
+		const dfOut = (dfRes.stdout ?? "").trim();
+		const usePct = parseRootDiskPct(dfOut);
+		if (usePct !== null && usePct >= diskHighPct) {
+			log.warn("host.disk.high", { usePct, threshold: diskHighPct, df: dfOut });
+			recordEvent({
+				kind: "host.disk.high",
+				payload: { usePct, threshold: diskHighPct, df: dfOut, completedAt: new Date().toISOString() },
+			});
+		}
+	} catch (error) {
+		log.warn("[host-cache-sweep] disk-threshold read failed: " + String(error));
+	}
 }
 
 pgBossHandlerRegistry.register(