@unerr-ai/unerr 0.2.1 → 0.2.3

package/dist/daemon/system-health.js

@@ -1,134 +0,0 @@
-/**
- * System health probes — power & load awareness for warm-start scheduling.
- *
- * Cross-platform:
- *   macOS:   `pmset -g batt` for battery, os.loadavg() for load
- *   Linux:   /sys/class/power_supply/ for battery, os.loadavg() for load
- *   Windows: wmic for battery, CPU idle delta sampling for load
- *
- * Results are cached for 10 seconds to avoid repeated system calls.
- */
-import { execSync } from "node:child_process";
-import { existsSync, readFileSync, readdirSync } from "node:fs";
-import { cpus, loadavg, platform } from "node:os";
-const CACHE_TTL_MS = 10_000;
-let batteryCache = null;
-let loadCache = null;
-export function onBattery() {
-    const now = Date.now();
-    if (batteryCache && now - batteryCache.ts < CACHE_TTL_MS) {
-        return batteryCache.value;
-    }
-    const result = detectBattery();
-    batteryCache = { value: result, ts: now };
-    return result;
-}
-function detectBattery() {
-    const plat = platform();
-    if (plat === "darwin")
-        return detectBatteryMacOS();
-    if (plat === "linux")
-        return detectBatteryLinux();
-    if (plat === "win32")
-        return detectBatteryWindows();
-    return false; // Unknown platform — assume plugged in
-}
-function detectBatteryMacOS() {
-    try {
-        const out = execSync("pmset -g batt", {
-            encoding: "utf-8",
-            timeout: 3000,
-        });
-        // "Now drawing from 'Battery Power'" means on battery
-        // "Now drawing from 'AC Power'" means plugged in
-        // No battery line at all means desktop Mac
-        if (out.includes("'Battery Power'"))
-            return true;
-        return false;
-    }
-    catch {
-        return false;
-    }
-}
-function detectBatteryLinux() {
-    try {
-        const psDir = "/sys/class/power_supply";
-        if (!existsSync(psDir))
-            return false;
-        const supplies = readdirSync(psDir);
-        for (const name of supplies) {
-            // AC adapters are named AC*, ADP*, etc.
-            if (name.startsWith("AC") || name.startsWith("ADP")) {
-                const onlinePath = `${psDir}/${name}/online`;
-                if (existsSync(onlinePath)) {
-                    const online = readFileSync(onlinePath, "utf-8").trim();
-                    if (online === "0")
-                        return true; // AC disconnected
-                    if (online === "1")
-                        return false; // AC connected
-                }
-            }
-        }
-        return false;
-    }
-    catch {
-        return false;
-    }
-}
-function detectBatteryWindows() {
-    try {
-        const out = execSync("wmic path Win32_Battery get BatteryStatus /value", {
-            encoding: "utf-8",
-            timeout: 5000,
-        });
-        // BatteryStatus=1 means discharging (on battery)
-        // BatteryStatus=2 means AC connected
-        const match = out.match(/BatteryStatus=(\d+)/);
-        if (match)
-            return match[1] === "1";
-        return false;
-    }
-    catch {
-        return false;
-    }
-}
-// ── Load average ──────────────────────────────────────────────
-export function loadAverage1() {
-    const now = Date.now();
-    if (loadCache && now - loadCache.ts < CACHE_TTL_MS) {
-        return loadCache.value;
-    }
-    const result = detectLoad();
-    loadCache = { value: result, ts: now };
-    return result;
-}
-function detectLoad() {
-    if (platform() === "win32")
-        return windowsLoadEstimate();
-    return loadavg()[0] ?? 0;
-}
-/**
- * Estimate 1-minute load average on Windows using a 1s CPU idle delta.
- * This is a rough approximation — Windows doesn't expose loadavg natively.
- */
-function windowsLoadEstimate() {
-    const cores = cpus();
-    const total = cores.length;
-    if (total === 0)
-        return 0;
-    let totalIdle = 0;
-    let totalTick = 0;
-    for (const cpu of cores) {
-        const { user, nice, sys, idle, irq } = cpu.times;
-        totalTick += user + nice + sys + idle + irq;
-        totalIdle += idle;
-    }
-    // Rough estimate: (busy fraction) * core count ≈ load
-    const busy = 1 - totalIdle / totalTick;
-    return Math.max(0, busy * total);
-}
-/** Reset caches (for testing). */
-export function resetHealthCaches() {
-    batteryCache = null;
-    loadCache = null;
-}

package/dist/daemon/version-checker.js

@@ -1,262 +0,0 @@
-/**
- * Version checker — daily npm registry check + local cache.
- *
- * Flow:
- *   1. On daemon boot (and every 24h thereafter), HEAD the npm registry
- *   2. Compare latest vs installed version
- *   3. Cache result to ~/.unerr/version.json
- *   4. Expose shouldNotify() for surfaces (CLI banner, dashboard, MCP _meta)
- *
- * Design: notify, never auto-apply. Users run `unerr daemon update` explicitly.
- */
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { get as httpsGet } from "node:https";
-import { homedir } from "node:os";
-import { join } from "node:path";
-// ── Constants ─────────────────────────────────────────────────
-const PACKAGE_NAME = "unerr";
-const REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
-const DEFAULT_CHECK_INTERVAL_S = 86_400; // 24 hours
-const REQUEST_TIMEOUT_MS = 10_000;
-function versionCachePath() {
-    return join(homedir(), ".unerr", "version.json");
-}
-// ── Installed version ─────────────────────────────────────────
-let cachedInstalledVersion = null;
-export function getInstalledVersion() {
-    if (cachedInstalledVersion)
-        return cachedInstalledVersion;
-    try {
-        const pkgPath = join(__dirname, "../../package.json");
-        if (existsSync(pkgPath)) {
-            const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-            cachedInstalledVersion = pkg.version;
-            return pkg.version;
-        }
-    }
-    catch {
-        // Fall through
-    }
-    // Fallback: try to resolve from process.argv
-    try {
-        const binDir = join(process.argv[1] || "", "..");
-        const pkgPath = join(binDir, "../package.json");
-        if (existsSync(pkgPath)) {
-            const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-            cachedInstalledVersion = pkg.version;
-            return pkg.version;
-        }
-    }
-    catch {
-        // Fall through
-    }
-    cachedInstalledVersion = "0.0.1";
-    return "0.0.1";
-}
-// ── Cache read/write ──────────────────────────────────────────
-export function readVersionCache() {
-    const defaults = {
-        lastChecked: "",
-        latestVersion: "",
-        installedVersion: getInstalledVersion(),
-        dismissed: [],
-        checkInterval: DEFAULT_CHECK_INTERVAL_S,
-    };
-    try {
-        const path = versionCachePath();
-        if (!existsSync(path))
-            return defaults;
-        const raw = JSON.parse(readFileSync(path, "utf-8"));
-        return {
-            lastChecked: raw.lastChecked ?? defaults.lastChecked,
-            latestVersion: raw.latestVersion ?? defaults.latestVersion,
-            installedVersion: getInstalledVersion(),
-            dismissed: Array.isArray(raw.dismissed) ? raw.dismissed : [],
-            checkInterval: typeof raw.checkInterval === "number"
-                ? raw.checkInterval
-                : defaults.checkInterval,
-        };
-    }
-    catch {
-        return defaults;
-    }
-}
-export function writeVersionCache(cache) {
-    const dir = join(homedir(), ".unerr");
-    mkdirSync(dir, { recursive: true });
-    writeFileSync(versionCachePath(), JSON.stringify(cache, null, 2), "utf-8");
-}
-function parseSemVer(version) {
-    const clean = version.replace(/^v/, "");
-    const parts = clean.split(".");
-    if (parts.length < 3)
-        return null;
-    const major = Number.parseInt(parts[0], 10);
-    const minor = Number.parseInt(parts[1], 10);
-    const patch = Number.parseInt(parts[2]?.split("-")[0], 10);
-    if (!Number.isFinite(major) ||
-        !Number.isFinite(minor) ||
-        !Number.isFinite(patch))
-        return null;
-    return { major, minor, patch };
-}
-export function isNewer(latest, current) {
-    const l = parseSemVer(latest);
-    const c = parseSemVer(current);
-    if (!l || !c)
-        return false;
-    if (l.major !== c.major)
-        return l.major > c.major;
-    if (l.minor !== c.minor)
-        return l.minor > c.minor;
-    return l.patch > c.patch;
-}
-export function minorsBehind(latest, current) {
-    const l = parseSemVer(latest);
-    const c = parseSemVer(current);
-    if (!l || !c)
-        return 0;
-    if (l.major > c.major)
-        return (l.major - c.major) * 10 + l.minor;
-    if (l.major < c.major)
-        return 0;
-    return Math.max(0, l.minor - c.minor);
-}
-// ── Registry fetch ────────────────────────────────────────────
-export function fetchLatestVersion() {
-    return new Promise((resolve) => {
-        const req = httpsGet(REGISTRY_URL, { headers: { Accept: "application/json" }, timeout: REQUEST_TIMEOUT_MS }, (res) => {
-            if (res.statusCode !== 200) {
-                res.resume();
-                resolve(null);
-                return;
-            }
-            let body = "";
-            res.on("data", (chunk) => {
-                body += chunk.toString();
-            });
-            res.on("end", () => {
-                try {
-                    const data = JSON.parse(body);
-                    resolve(data.version ?? null);
-                }
-                catch {
-                    resolve(null);
-                }
-            });
-        });
-        req.on("error", () => resolve(null));
-        req.on("timeout", () => {
-            req.destroy();
-            resolve(null);
-        });
-    });
-}
-// ── Check logic ───────────────────────────────────────────────
-function shouldCheck(cache) {
-    if (!cache.lastChecked)
-        return true;
-    const lastMs = new Date(cache.lastChecked).getTime();
-    if (Number.isNaN(lastMs))
-        return true;
-    const elapsed = (Date.now() - lastMs) / 1000;
-    return elapsed >= cache.checkInterval;
-}
-/**
- * Perform a version check if due. Returns the current update info.
- * Safe to call frequently — respects the check interval.
- */
-export async function checkForUpdate() {
-    const cache = readVersionCache();
-    const current = getInstalledVersion();
-    if (shouldCheck(cache)) {
-        const latest = await fetchLatestVersion();
-        if (latest) {
-            cache.latestVersion = latest;
-            cache.lastChecked = new Date().toISOString();
-            cache.installedVersion = current;
-            writeVersionCache(cache);
-        }
-    }
-    const latest = cache.latestVersion || current;
-    const available = isNewer(latest, current);
-    const dismissed = cache.dismissed.includes(latest);
-    return {
-        available,
-        current,
-        latest,
-        behindMinor: minorsBehind(latest, current),
-        dismissed,
-    };
-}
-/**
- * Get update info from cache only (no network request).
- * Use this for synchronous surfaces like CLI banners.
- */
-export function getCachedUpdateInfo() {
-    const cache = readVersionCache();
-    const current = getInstalledVersion();
-    const latest = cache.latestVersion || current;
-    const available = isNewer(latest, current);
-    const dismissed = cache.dismissed.includes(latest);
-    return {
-        available,
-        current,
-        latest,
-        behindMinor: minorsBehind(latest, current),
-        dismissed,
-    };
-}
-/**
- * Whether to show update notification — respects dismissal.
- */
-export function shouldNotify() {
-    const info = getCachedUpdateInfo();
-    return info.available && !info.dismissed;
-}
-/**
- * Dismiss notifications for a specific version.
- */
-export function dismissVersion(version) {
-    const cache = readVersionCache();
-    const clean = version.replace(/^v/, "");
-    if (!cache.dismissed.includes(clean)) {
-        cache.dismissed.push(clean);
-        writeVersionCache(cache);
-    }
-}
-/**
- * Set check interval (in seconds). 0 disables checks.
- */
-export function setCheckInterval(seconds) {
-    const cache = readVersionCache();
-    cache.checkInterval = seconds;
-    writeVersionCache(cache);
-}
-// ── Daemon integration ────────────────────────────────────────
-let checkTimer = null;
-/**
- * Start periodic version checking (called by unerrd on boot).
- * Returns a cancel function.
- */
-export function startPeriodicCheck() {
-    // Initial check (deferred 5s to not block boot)
-    const initialTimer = setTimeout(() => {
-        checkForUpdate().catch(() => { });
-    }, 5000);
-    initialTimer.unref();
-    // Periodic check every checkInterval
-    const cache = readVersionCache();
-    const intervalMs = (cache.checkInterval || DEFAULT_CHECK_INTERVAL_S) * 1000;
-    checkTimer = setInterval(() => {
-        checkForUpdate().catch(() => { });
-    }, intervalMs);
-    checkTimer.unref();
-    return () => {
-        clearTimeout(initialTimer);
-        if (checkTimer) {
-            clearInterval(checkTimer);
-            checkTimer = null;
-        }
-    };
-}

package/dist/daemon/warm-start.js

@@ -1,223 +0,0 @@
-/**
- * Warm-start scheduler — pre-spawn MRU repos after daemon boot.
- *
- * Reads repos from the registry, sorts by lastActivity (MRU first),
- * respects per-repo autostart policy and global budget. Spawns
- * sequentially at low priority. Aborts if load jumps too high or
- * system is on battery.
- *
- * Events emitted for dashboard timeline:
- *   { type: "warm_start", repo, status: "started"|"skipped"|"failed"|"aborted", ms, reason? }
- */
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { isCI } from "./detect-ci.js";
-import { readRegistry } from "./registry.js";
-import { loadAverage1, onBattery } from "./system-health.js";
-const DEFAULT_CONFIG = {
-    warmStartBudget: 3,
-    warmStartIdleDays: 14,
-    warmStartDelayMs: 30_000,
-};
-export function loadWarmStartConfig() {
-    const configPath = join(homedir(), ".unerr", "config.json");
-    try {
-        if (!existsSync(configPath))
-            return { ...DEFAULT_CONFIG };
-        const raw = JSON.parse(readFileSync(configPath, "utf-8"));
-        return {
-            warmStartBudget: typeof raw.warmStartBudget === "number"
-                ? raw.warmStartBudget
-                : DEFAULT_CONFIG.warmStartBudget,
-            warmStartIdleDays: typeof raw.warmStartIdleDays === "number"
-                ? raw.warmStartIdleDays
-                : DEFAULT_CONFIG.warmStartIdleDays,
-            warmStartDelayMs: typeof raw.warmStartDelayMs === "number"
-                ? raw.warmStartDelayMs
-                : DEFAULT_CONFIG.warmStartDelayMs,
-        };
-    }
-    catch {
-        return { ...DEFAULT_CONFIG };
-    }
-}
-export function saveWarmStartConfig(partial) {
-    const configPath = join(homedir(), ".unerr", "config.json");
-    const dir = join(homedir(), ".unerr");
-    mkdirSync(dir, { recursive: true });
-    let existing = {};
-    try {
-        if (existsSync(configPath)) {
-            existing = JSON.parse(readFileSync(configPath, "utf-8"));
-        }
-    }
-    catch {
-        // Corrupted — reset
-    }
-    const merged = { ...existing, ...partial };
-    writeFileSync(configPath, JSON.stringify(merged, null, 2), "utf-8");
-}
-/**
- * Select repos eligible for warm-start, sorted by MRU.
- * Respects per-repo `autostart` policy and `warmStartIdleDays` cutoff.
- */
-export function selectCandidates(repos, config) {
-    const now = Date.now();
-    const idleCutoff = now - config.warmStartIdleDays * 24 * 60 * 60 * 1000;
-    const candidates = [];
-    const skipped = [];
-    for (const entry of repos) {
-        const autostart = entry.settings?.autostart ?? "auto";
-        if (autostart === "never") {
-            skipped.push({ entry, reason: "autostart=never" });
-            continue;
-        }
-        if (!existsSync(entry.path)) {
-            skipped.push({ entry, reason: "directory not found" });
-            continue;
-        }
-        const lastTs = entry.lastActivity
-            ? new Date(entry.lastActivity).getTime()
-            : 0;
-        if (autostart === "auto" && lastTs < idleCutoff && lastTs > 0) {
-            skipped.push({
-                entry,
-                reason: `inactive >${config.warmStartIdleDays} days`,
-            });
-            continue;
-        }
-        candidates.push({ entry, lastActivityTs: lastTs });
-    }
-    // Eager repos first, then sort by MRU within each tier
-    candidates.sort((a, b) => {
-        const aEager = a.entry.settings?.autostart === "eager" ? 0 : 1;
-        const bEager = b.entry.settings?.autostart === "eager" ? 0 : 1;
-        if (aEager !== bEager)
-            return aEager - bEager;
-        return b.lastActivityTs - a.lastActivityTs;
-    });
-    return { candidates, skipped };
-}
-/**
- * Run the warm-start sweep. Called by daemon entrypoint after boot delay.
- *
- * Spawns repos sequentially through ProcessManager.ensure().
- * Aborts if load average jumps >1.5× baseline.
- */
-export async function runWarmStart(pm, onEvent) {
-    const config = loadWarmStartConfig();
-    const result = {
-        started: [],
-        skipped: [],
-        aborted: false,
-        totalMs: 0,
-    };
-    const overallStart = Date.now();
-    if (config.warmStartBudget <= 0)
-        return result;
-    if (isCI())
-        return result;
-    const registry = readRegistry();
-    const { candidates, skipped } = selectCandidates(registry.repos, config);
-    for (const s of skipped) {
-        result.skipped.push({ label: s.entry.label, reason: s.reason });
-        onEvent?.({
-            type: "warm_start",
-            repo: s.entry.path,
-            label: s.entry.label,
-            status: "skipped",
-            ms: 0,
-            reason: s.reason,
-        });
-    }
-    const baselineLoad = loadAverage1();
-    const toWarm = candidates.slice(0, config.warmStartBudget);
-    for (const c of toWarm) {
-        // Check system health before each spawn
-        if (onBattery()) {
-            result.aborted = true;
-            onEvent?.({
-                type: "warm_start",
-                repo: c.entry.path,
-                label: c.entry.label,
-                status: "aborted",
-                ms: 0,
-                reason: "on battery",
-            });
-            break;
-        }
-        const currentLoad = loadAverage1();
-        if (baselineLoad > 0 && currentLoad > baselineLoad * 1.5) {
-            result.aborted = true;
-            onEvent?.({
-                type: "warm_start",
-                repo: c.entry.path,
-                label: c.entry.label,
-                status: "aborted",
-                ms: 0,
-                reason: `load ${currentLoad.toFixed(1)} > 1.5× baseline ${baselineLoad.toFixed(1)}`,
-            });
-            break;
-        }
-        const start = Date.now();
-        try {
-            await pm.ensure(c.entry.path);
-            const ms = Date.now() - start;
-            result.started.push(c.entry.label);
-            onEvent?.({
-                type: "warm_start",
-                repo: c.entry.path,
-                label: c.entry.label,
-                status: "started",
-                ms,
-            });
-        }
-        catch (err) {
-            const ms = Date.now() - start;
-            onEvent?.({
-                type: "warm_start",
-                repo: c.entry.path,
-                label: c.entry.label,
-                status: "failed",
-                ms,
-                reason: err.message,
-            });
-        }
-    }
-    // Mark remaining candidates beyond budget as skipped
-    for (const c of candidates.slice(config.warmStartBudget)) {
-        result.skipped.push({ label: c.entry.label, reason: "beyond budget" });
-        onEvent?.({
-            type: "warm_start",
-            repo: c.entry.path,
-            label: c.entry.label,
-            status: "skipped",
-            ms: 0,
-            reason: `beyond budget (${config.warmStartBudget})`,
-        });
-    }
-    result.totalMs = Date.now() - overallStart;
-    return result;
-}
-/**
- * Schedule the warm-start sweep after the configured delay.
- * Returns a cancel function.
- */
-export function scheduleWarmStart(pm, onEvent) {
-    if (isCI())
-        return () => { };
-    const config = loadWarmStartConfig();
-    if (config.warmStartBudget <= 0)
-        return () => { };
-    const timer = setTimeout(async () => {
-        try {
-            await runWarmStart(pm, onEvent);
-        }
-        catch {
-            // Warm-start failure is non-fatal
-        }
-    }, config.warmStartDelayMs);
-    timer.unref();
-    return () => clearTimeout(timer);
-}