@unerr-ai/unerr 0.0.1 → 0.1.1

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

@@ -0,0 +1,318 @@
+/**
+ * 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

@@ -0,0 +1,275 @@
+/**
+ * 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+/);
+    });
+});