@unerr-ai/unerr 0.1.6 → 0.1.7

package/dist/__tests__/daemon-supervisor.test.js

@@ -1,318 +0,0 @@
-/**
- * DM-2: Daemon supervisor tests.
- *
- * Tests cover:
- *   - ProcessManager spawn/stop/IPC/idle sweep
- *   - Daemon entrypoint PID lock + UDS protocol
- *   - Orphan detection in daemon-child mode
- *   - Protocol message handling
- */
-import { mkdirSync, rmSync, writeFileSync, } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-// ── ProcessManager unit tests ──────────────────────────────────────
-describe("ProcessManager", () => {
-    let testDir;
-    let testCounter = 0;
-    beforeEach(() => {
-        testCounter++;
-        testDir = join(tmpdir(), `dm2-pm-test-${Date.now()}-${testCounter}`);
-        mkdirSync(testDir, { recursive: true });
-        // Set up a mock global dir so registry doesn't touch real home
-        vi.stubEnv("UNERR_HOME", testDir);
-        // Create registry file
-        const globalUnerr = join(testDir, ".unerr");
-        mkdirSync(globalUnerr, { recursive: true });
-        writeFileSync(join(globalUnerr, "repos.json"), JSON.stringify({ version: 1, repos: [] }));
-    });
-    afterEach(() => {
-        vi.unstubAllEnvs();
-        try {
-            rmSync(testDir, { recursive: true, force: true });
-        }
-        catch {
-            /* windows race */
-        }
-    });
-    it("creates a ProcessManager instance with no repos", async () => {
-        const { ProcessManager } = await import("../daemon/process-manager.js");
-        const pm = new ProcessManager();
-        const status = pm.getStatus();
-        expect(status).toEqual([]);
-    });
-    it("getManaged returns undefined for unknown repo", async () => {
-        const { ProcessManager } = await import("../daemon/process-manager.js");
-        const pm = new ProcessManager();
-        expect(pm.getManaged("/nonexistent")).toBeUndefined();
-    });
-    it("startIdleSweep + stopIdleSweep lifecycle", async () => {
-        const { ProcessManager } = await import("../daemon/process-manager.js");
-        const pm = new ProcessManager();
-        pm.startIdleSweep();
-        // Calling again is a no-op
-        pm.startIdleSweep();
-        pm.stopIdleSweep();
-        // Calling again after stop is fine
-        pm.stopIdleSweep();
-    });
-    it("shutdownAll gracefully handles empty state", async () => {
-        const { ProcessManager } = await import("../daemon/process-manager.js");
-        const pm = new ProcessManager();
-        await pm.shutdownAll();
-    });
-    it("connect/disconnect on unknown repo is a no-op", async () => {
-        const { ProcessManager } = await import("../daemon/process-manager.js");
-        const pm = new ProcessManager();
-        pm.connect("/unknown");
-        pm.disconnect("/unknown");
-        pm.recordActivity("/unknown");
-    });
-    it("event handler receives lifecycle events", async () => {
-        const { ProcessManager } = await import("../daemon/process-manager.js");
-        const pm = new ProcessManager();
-        const events = [];
-        pm.setEventHandler((event) => {
-            events.push(event);
-        });
-        // No actual events will fire without spawning, but handler should be set
-        expect(events).toEqual([]);
-    });
-});
-// ── Protocol message handling ──────────────────────────────────────
-describe("Daemon protocol types", () => {
-    it("DaemonRequest union covers all commands", async () => {
-        const proto = await import("../daemon/protocol.js");
-        // Verify the type constants exist as expected
-        expect(proto.DEFAULT_IDLE_TIMEOUT_S).toBe(1800);
-        expect(proto.DEFAULT_WARM_START_BUDGET).toBe(3);
-        expect(proto.DEFAULT_WARM_START_DELAY_MS).toBe(30_000);
-        expect(proto.DEFAULT_WARM_START_IDLE_DAYS).toBe(14);
-    });
-    it("ChildMessage types are all present", async () => {
-        // This is a compile-time check — if ChildMessage changes, this test file won't compile
-        const _ = {
-            ready: { type: "ready", sock: "/tmp/test.sock" },
-            activity: { type: "activity" },
-            stats: { type: "stats", entities: 100, edges: 200, memory: 50 },
-            needs_input: { type: "needs_input", signals: [] },
-        };
-        expect(_.ready.type).toBe("ready");
-        expect(_.activity.type).toBe("activity");
-        expect(_.stats.type).toBe("stats");
-        expect(_.needs_input.type).toBe("needs_input");
-    });
-    it("ParentMessage types are all present", async () => {
-        const _ = {
-            shutdown: { type: "shutdown" },
-            getStats: { type: "get-stats" },
-        };
-        expect(_.shutdown.type).toBe("shutdown");
-        expect(_.getStats.type).toBe("get-stats");
-    });
-});
-// ── Daemon entrypoint isolation tests ──────────────────────────────
-describe("Daemon entrypoint", () => {
-    it("daemon.ts imports only from daemon/, proxy/pid-lock, utils/", async () => {
-        const { readFileSync: readSync } = await import("node:fs");
-        const { resolve: res } = await import("node:path");
-        const content = readSync(res(process.cwd(), "src/entrypoints/daemon.ts"), "utf-8");
-        // Must not import from intelligence/, behaviors/, tracking/
-        const forbidden = [
-            /from\s+["']\.\.\/intelligence\//,
-            /from\s+["']\.\.\/behaviors\//,
-            /from\s+["']\.\.\/tracking\//,
-        ];
-        for (const pattern of forbidden) {
-            expect(content).not.toMatch(pattern);
-        }
-        // Must import from daemon/ (ProcessManager, protocol, registry)
-        expect(content).toMatch(/from\s+["']\.\.\/daemon\/process-manager/);
-        expect(content).toMatch(/from\s+["']\.\.\/daemon\/protocol/);
-        expect(content).toMatch(/from\s+["']\.\.\/daemon\/registry/);
-    });
-    it("process-manager.ts imports only from daemon/ and node builtins", async () => {
-        const { readFileSync: readSync } = await import("node:fs");
-        const { resolve: res } = await import("node:path");
-        const content = readSync(res(process.cwd(), "src/daemon/process-manager.ts"), "utf-8");
-        const forbidden = [
-            /from\s+["']\.\.\/intelligence\//,
-            /from\s+["']\.\.\/behaviors\//,
-            /from\s+["']\.\.\/tracking\//,
-            /from\s+["']\.\.\/proxy\//,
-        ];
-        for (const pattern of forbidden) {
-            expect(content).not.toMatch(pattern);
-        }
-    });
-});
-// ── CLI --daemon-child flag ────────────────────────────────────────
-describe("CLI --daemon-child flag", () => {
-    it("cli.ts contains --daemon-child option", async () => {
-        const { readFileSync: readSync } = await import("node:fs");
-        const { resolve: res } = await import("node:path");
-        const content = readSync(res(process.cwd(), "src/entrypoints/cli.ts"), "utf-8");
-        expect(content).toContain("--daemon-child");
-        expect(content).toContain("daemonChildBoot");
-    });
-    it("daemonChildBoot implements orphan detection", async () => {
-        const { readFileSync: readSync } = await import("node:fs");
-        const { resolve: res } = await import("node:path");
-        const content = readSync(res(process.cwd(), "src/entrypoints/cli.ts"), "utf-8");
-        expect(content).toContain("process.ppid");
-        expect(content).toContain("orphanTimer");
-        expect(content).toContain("originalPpid");
-    });
-    it("daemonChildBoot sends IPC ready message", async () => {
-        const { readFileSync: readSync } = await import("node:fs");
-        const { resolve: res } = await import("node:path");
-        const content = readSync(res(process.cwd(), "src/entrypoints/cli.ts"), "utf-8");
-        expect(content).toContain('{ type: "ready", sock: sockPath }');
-        expect(content).toContain("process.send");
-    });
-});
-// ── Idle sweep logic ───────────────────────────────────────────────
-describe("Idle sweep logic", () => {
-    it("process-manager.ts checks connections and lastActivity", async () => {
-        const { readFileSync: readSync } = await import("node:fs");
-        const { resolve: res } = await import("node:path");
-        const content = readSync(res(process.cwd(), "src/daemon/process-manager.ts"), "utf-8");
-        expect(content).toContain("runIdleSweep");
-        expect(content).toContain("repo.connections > 0");
-        expect(content).toContain("repo.idleTimeout");
-        expect(content).toContain("idleMs >= timeoutMs");
-    });
-    it("idle sweep interval is 60 seconds", async () => {
-        const { readFileSync: readSync } = await import("node:fs");
-        const { resolve: res } = await import("node:path");
-        const content = readSync(res(process.cwd(), "src/daemon/process-manager.ts"), "utf-8");
-        expect(content).toContain("IDLE_SWEEP_INTERVAL_MS = 60_000");
-    });
-});
-// ── PID lock in daemon.ts ──────────────────────────────────────────
-describe("Daemon PID lock", () => {
-    let testDir;
-    let testCounter = 0;
-    beforeEach(() => {
-        testCounter++;
-        testDir = join(tmpdir(), `dm2-pid-test-${Date.now()}-${testCounter}`);
-        mkdirSync(testDir, { recursive: true });
-    });
-    afterEach(() => {
-        try {
-            rmSync(testDir, { recursive: true, force: true });
-        }
-        catch {
-            /* cleanup */
-        }
-    });
-    it("daemon.ts writes unerrd.pid with process.pid", async () => {
-        const { readFileSync: readSync } = await import("node:fs");
-        const { resolve: res } = await import("node:path");
-        const content = readSync(res(process.cwd(), "src/entrypoints/daemon.ts"), "utf-8");
-        expect(content).toContain("unerrd.pid");
-        expect(content).toContain("unerrd.sock");
-        expect(content).toContain("acquirePidLock");
-        expect(content).toContain("releasePidLock");
-    });
-    it("daemon.ts handles stale socket cleanup", async () => {
-        const { readFileSync: readSync } = await import("node:fs");
-        const { resolve: res } = await import("node:path");
-        const content = readSync(res(process.cwd(), "src/entrypoints/daemon.ts"), "utf-8");
-        expect(content).toContain("cleanStaleSocket");
-        expect(content).toContain("createConnection");
-    });
-});
-// ── Signal handling ────────────────────────────────────────────────
-describe("Signal handling", () => {
-    it("daemon.ts handles SIGTERM and SIGINT", async () => {
-        const { readFileSync: readSync } = await import("node:fs");
-        const { resolve: res } = await import("node:path");
-        const content = readSync(res(process.cwd(), "src/entrypoints/daemon.ts"), "utf-8");
-        expect(content).toContain("SIGTERM");
-        expect(content).toContain("SIGINT");
-        expect(content).toContain("shutdownAll");
-    });
-    it("daemon-child handles SIGTERM for graceful shutdown", async () => {
-        const { readFileSync: readSync } = await import("node:fs");
-        const { resolve: res } = await import("node:path");
-        const content = readSync(res(process.cwd(), "src/entrypoints/cli.ts"), "utf-8");
-        // Child process listens for SIGTERM
-        expect(content).toContain("SIGTERM");
-        // And calls shutdownProxy
-        expect(content).toContain("shutdownProxy");
-    });
-});
-// ── No interactive prompts in daemon-child ─────────────────────────
-describe("No interactive prompts in daemon-child", () => {
-    it("process.stdin.isTTY is never checked in daemon modules", async () => {
-        const { readFileSync: readSync } = await import("node:fs");
-        const { resolve: res } = await import("node:path");
-        const files = [
-            "src/daemon/process-manager.ts",
-            "src/daemon/protocol.ts",
-            "src/daemon/registry.ts",
-            "src/daemon/settings-schema.ts",
-            "src/entrypoints/daemon.ts",
-        ];
-        for (const file of files) {
-            const content = readSync(res(process.cwd(), file), "utf-8");
-            expect(content).not.toContain("process.stdin.isTTY");
-        }
-    });
-});
-// ── UDS protocol ───────────────────────────────────────────────────
-describe("UDS protocol", () => {
-    it("daemon.ts implements newline-delimited JSON protocol", async () => {
-        const { readFileSync: readSync } = await import("node:fs");
-        const { resolve: res } = await import("node:path");
-        const content = readSync(res(process.cwd(), "src/entrypoints/daemon.ts"), "utf-8");
-        // Newline-delimited JSON framing
-        expect(content).toContain('buffer.indexOf("\\n")');
-        expect(content).toContain("JSON.parse");
-        expect(content).toContain("JSON.stringify");
-    });
-    it("handles all DaemonRequest commands", async () => {
-        const { readFileSync: readSync } = await import("node:fs");
-        const { resolve: res } = await import("node:path");
-        const content = readSync(res(process.cwd(), "src/entrypoints/daemon.ts"), "utf-8");
-        const commands = [
-            "ensure",
-            "connect",
-            "disconnect",
-            "activity",
-            "status",
-            "add",
-            "remove",
-            "stop",
-            "shutdown",
-            "dashboard-state",
-            "repo-detail",
-        ];
-        for (const cmd of commands) {
-            expect(content).toContain(`"${cmd}"`);
-        }
-    });
-});
-// ── ProxyOptions daemonChild flag ──────────────────────────────────
-describe("ProxyOptions daemonChild", () => {
-    it("proxy.ts includes daemonChild in ProxyOptions", async () => {
-        const { readFileSync: readSync } = await import("node:fs");
-        const { resolve: res } = await import("node:path");
-        const content = readSync(res(process.cwd(), "src/proxy/proxy.ts"), "utf-8");
-        expect(content).toContain("daemonChild?: boolean");
-        expect(content).toContain("opts.daemonChild");
-    });
-});
-// ── daemon.ts CLI start/stop commands ──────────────────────────────
-describe("Daemon CLI commands", () => {
-    it("daemon.ts registers start and stop subcommands", async () => {
-        const { readFileSync: readSync } = await import("node:fs");
-        const { resolve: res } = await import("node:path");
-        const content = readSync(res(process.cwd(), "src/commands/daemon.ts"), "utf-8");
-        expect(content).toContain('.command("start")');
-        expect(content).toContain('.command("stop")');
-        expect(content).toContain("--background");
-        expect(content).toContain("startDaemon");
-    });
-});

package/dist/__tests__/daemon-version-check.test.js

@@ -1,275 +0,0 @@
-/**
- * Tests for DM-6 version check system:
- *   - Version comparison logic
- *   - Cache read/write
- *   - Throttled checks (max 1/day)
- *   - Notification gating (>2 minor versions)
- *   - Dismiss logic
- *   - No auto-apply
- */
-import { existsSync, readFileSync, rmSync, writeFileSync, } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-// Save and restore version.json between tests to prevent cross-test pollution
-const versionCachePath = join(homedir(), ".unerr", "version.json");
-let savedVersionCache = null;
-beforeEach(() => {
-    try {
-        if (existsSync(versionCachePath)) {
-            savedVersionCache = readFileSync(versionCachePath, "utf-8");
-        }
-        else {
-            savedVersionCache = null;
-        }
-    }
-    catch {
-        savedVersionCache = null;
-    }
-});
-afterEach(() => {
-    try {
-        if (savedVersionCache !== null) {
-            writeFileSync(versionCachePath, savedVersionCache, "utf-8");
-        }
-        else if (existsSync(versionCachePath)) {
-            rmSync(versionCachePath);
-        }
-    }
-    catch {
-        // Best-effort
-    }
-});
-import { dismissVersion, getCachedUpdateInfo, getInstalledVersion, isNewer, minorsBehind, readVersionCache, shouldNotify, writeVersionCache, } from "../daemon/version-checker.js";
-describe("version comparison — isNewer", () => {
-    it("detects newer patch", () => {
-        expect(isNewer("0.2.2", "0.2.1")).toBe(true);
-    });
-    it("detects newer minor", () => {
-        expect(isNewer("0.3.0", "0.2.1")).toBe(true);
-    });
-    it("detects newer major", () => {
-        expect(isNewer("1.0.0", "0.9.9")).toBe(true);
-    });
-    it("returns false for same version", () => {
-        expect(isNewer("0.2.1", "0.2.1")).toBe(false);
-    });
-    it("returns false for older version", () => {
-        expect(isNewer("0.1.0", "0.2.1")).toBe(false);
-    });
-    it("handles v prefix", () => {
-        expect(isNewer("v0.3.0", "v0.2.1")).toBe(true);
-    });
-    it("handles pre-release suffix", () => {
-        expect(isNewer("0.3.0-beta.1", "0.2.1")).toBe(true);
-    });
-    it("returns false for invalid versions", () => {
-        expect(isNewer("invalid", "0.2.1")).toBe(false);
-        expect(isNewer("0.2.1", "bad")).toBe(false);
-    });
-});
-describe("version comparison — minorsBehind", () => {
-    it("0 for same version", () => {
-        expect(minorsBehind("0.2.1", "0.2.1")).toBe(0);
-    });
-    it("1 for one minor ahead", () => {
-        expect(minorsBehind("0.3.0", "0.2.1")).toBe(1);
-    });
-    it("3 for three minors ahead", () => {
-        expect(minorsBehind("0.5.0", "0.2.1")).toBe(3);
-    });
-    it("handles major version difference", () => {
-        const result = minorsBehind("2.1.0", "0.9.0");
-        expect(result).toBeGreaterThan(2);
-    });
-    it("0 for older latest", () => {
-        expect(minorsBehind("0.1.0", "0.2.1")).toBe(0);
-    });
-    it("handles invalid input gracefully", () => {
-        expect(minorsBehind("bad", "0.2.1")).toBe(0);
-    });
-});
-describe("version cache", () => {
-    it("readVersionCache returns defaults when file missing", () => {
-        // Ensure no cache file exists for this test
-        try {
-            rmSync(versionCachePath);
-        }
-        catch {
-            /* ok */
-        }
-        const cache = readVersionCache();
-        expect(cache.checkInterval).toBe(86_400);
-        expect(cache.dismissed).toEqual([]);
-        expect(cache.installedVersion).toBeTruthy();
-    });
-    it("writeVersionCache persists and reads back", () => {
-        const cache = {
-            lastChecked: "2026-05-14T10:00:00Z",
-            latestVersion: "0.5.0",
-            installedVersion: "0.2.1",
-            dismissed: ["0.3.0"],
-            checkInterval: 86_400,
-        };
-        writeVersionCache(cache);
-        const read = readVersionCache();
-        expect(read.lastChecked).toBe(cache.lastChecked);
-        expect(read.latestVersion).toBe(cache.latestVersion);
-        expect(read.dismissed).toContain("0.3.0");
-        expect(read.checkInterval).toBe(86_400);
-    });
-});
-describe("getCachedUpdateInfo", () => {
-    it("returns available=false when no cache", () => {
-        const info = getCachedUpdateInfo();
-        // Without a real newer version in cache, it should be false
-        expect(typeof info.available).toBe("boolean");
-        expect(info.current).toBeTruthy();
-    });
-    it("returns available=true when cache has newer version", () => {
-        writeVersionCache({
-            lastChecked: new Date().toISOString(),
-            latestVersion: "99.0.0",
-            installedVersion: "0.0.1",
-            dismissed: [],
-            checkInterval: 86_400,
-        });
-        const info = getCachedUpdateInfo();
-        expect(info.available).toBe(true);
-        expect(info.latest).toBe("99.0.0");
-        expect(info.behindMinor).toBeGreaterThan(0);
-    });
-    it("reports dismissed correctly", () => {
-        writeVersionCache({
-            lastChecked: new Date().toISOString(),
-            latestVersion: "99.0.0",
-            installedVersion: "0.0.1",
-            dismissed: ["99.0.0"],
-            checkInterval: 86_400,
-        });
-        const info = getCachedUpdateInfo();
-        expect(info.available).toBe(true);
-        expect(info.dismissed).toBe(true);
-    });
-});
-describe("dismissVersion", () => {
-    it("adds version to dismissed list", () => {
-        writeVersionCache({
-            lastChecked: new Date().toISOString(),
-            latestVersion: "1.0.0",
-            installedVersion: "0.0.1",
-            dismissed: [],
-            checkInterval: 86_400,
-        });
-        dismissVersion("1.0.0");
-        const cache = readVersionCache();
-        expect(cache.dismissed).toContain("1.0.0");
-    });
-    it("strips v prefix", () => {
-        writeVersionCache({
-            lastChecked: new Date().toISOString(),
-            latestVersion: "2.0.0",
-            installedVersion: "0.0.1",
-            dismissed: [],
-            checkInterval: 86_400,
-        });
-        dismissVersion("v2.0.0");
-        const cache = readVersionCache();
-        expect(cache.dismissed).toContain("2.0.0");
-    });
-    it("is idempotent", () => {
-        writeVersionCache({
-            lastChecked: new Date().toISOString(),
-            latestVersion: "3.0.0",
-            installedVersion: "0.0.1",
-            dismissed: ["3.0.0"],
-            checkInterval: 86_400,
-        });
-        dismissVersion("3.0.0");
-        const cache = readVersionCache();
-        expect(cache.dismissed.filter((v) => v === "3.0.0").length).toBe(1);
-    });
-});
-describe("throttle — max 1 check per interval", () => {
-    it("does not re-fetch when last check is recent", async () => {
-        writeVersionCache({
-            lastChecked: new Date().toISOString(),
-            latestVersion: "0.5.0",
-            installedVersion: "0.0.1",
-            dismissed: [],
-            checkInterval: 86_400,
-        });
-        // checkForUpdate should NOT hit the network because lastChecked is fresh
-        const { checkForUpdate } = await import("../daemon/version-checker.js");
-        const info = await checkForUpdate();
-        // Should use cached value
-        expect(info.latest).toBe("0.5.0");
-        expect(info.available).toBe(true);
-    });
-});
-describe("notification gating", () => {
-    it("shouldNotify returns true when available and not dismissed", () => {
-        writeVersionCache({
-            lastChecked: new Date().toISOString(),
-            latestVersion: "10.0.0",
-            installedVersion: "0.0.1",
-            dismissed: [],
-            checkInterval: 86_400,
-        });
-        expect(shouldNotify()).toBe(true);
-    });
-    it("shouldNotify returns false when dismissed", () => {
-        writeVersionCache({
-            lastChecked: new Date().toISOString(),
-            latestVersion: "10.0.0",
-            installedVersion: "0.0.1",
-            dismissed: ["10.0.0"],
-            checkInterval: 86_400,
-        });
-        expect(shouldNotify()).toBe(false);
-    });
-    it("_meta.update_available only fires when >2 minors behind", () => {
-        // This tests the policy: behindMinor > 2 threshold
-        const info1 = {
-            available: true,
-            current: "0.2.0",
-            latest: "0.4.0",
-            behindMinor: 2,
-            dismissed: false,
-        };
-        // 2 minors behind: should NOT inject (threshold is >2, not >=2)
-        expect(info1.behindMinor > 2).toBe(false);
-        const info2 = {
-            available: true,
-            current: "0.2.0",
-            latest: "0.5.0",
-            behindMinor: 3,
-            dismissed: false,
-        };
-        // 3 minors behind: SHOULD inject
-        expect(info2.behindMinor > 2).toBe(true);
-    });
-});
-describe("no auto-apply", () => {
-    it("checkForUpdate never modifies installed version", async () => {
-        const before = getInstalledVersion();
-        const { checkForUpdate } = await import("../daemon/version-checker.js");
-        await checkForUpdate();
-        const after = getInstalledVersion();
-        expect(after).toBe(before);
-    });
-    it("version cache only stores metadata, not binaries", () => {
-        const cache = readVersionCache();
-        const keys = Object.keys(cache);
-        // No "binary", "download", "archive", "update" keys
-        expect(keys).not.toContain("binary");
-        expect(keys).not.toContain("download");
-        expect(keys).not.toContain("archive");
-    });
-});
-describe("getInstalledVersion", () => {
-    it("returns a semver-like string", () => {
-        const v = getInstalledVersion();
-        expect(v).toMatch(/^\d+\.\d+\.\d+/);
-    });
-});