@aron98/load-lock 1.4.0 → 1.6.0

package/dist/test/reconnect.test.js

@@ -0,0 +1,389 @@
+/**
+ * Reconnect + update-staleness tests (issue #39): "TUI plugin fails to
+ * reconnect after daemon/plugin update without an opencode restart".
+ *
+ * Diagnosis outcome (see the PR description): the reported incident is the
+ * harness loading plugin code ONCE at startup (opencode never hot-reloads
+ * plugins) — an update swaps the on-disk copy while the session keeps
+ * executing the old code in memory. The feed's reconnect machinery itself
+ * works. These tests pin down the surrounding behaviors that make that
+ * diagnosis visible and close the real gaps found along the way:
+ *
+ *  - H3 (genuine bug, FIXED): a failed INITIAL connect wedged the feed in
+ *    "connecting" forever — no socket was attached, so no close event could
+ *    ever trigger the reconnect loop. Regression test: start a feed with
+ *    spawnDaemon:false, fail, then bring a real daemon up late.
+ *  - H1 repro: SIGKILL the daemon under a live feed; the client auto-spawns
+ *    a replacement (same on-disk code) and the feed goes live again with a
+ *    "daemon restarted" note — proving reconnect works when the plugin code
+ *    in memory matches what is on disk.
+ *  - "restarted onto vX" note: when the v1.3.0 handshake reports a different
+ *    daemon version across a restart, the note says which version it
+ *    restarted onto (mock FeedClient so we can force exact versions).
+ *  - install drift: running copy older than the PATH CLI install is
+ *    detected (fixture PATH) and surfaced as a surface-appropriate hint
+ *    ("restart opencode to pick up vX" for the plugin).
+ *  - H2 hardening: a vanished/unreadable daemon entry must fail the spawn
+ *    probe ("did not come up") instead of crashing the host process with an
+ *    uncaught ENOENT (subprocess test).
+ */
+import test from "node:test";
+import assert from "node:assert/strict";
+import { spawn } from "node:child_process";
+import { chmodSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { DashboardFeed } from "../dashboard/feed.js";
+import { LLClient } from "../shared/client.js";
+import { buildDashboardView } from "../dashboard/view.js";
+import { renderFrame } from "../dashboard/frame.js";
+import { detectInstallDrift, pathInstall, resolveDaemonEntry, } from "../shared/installs.js";
+import { packageVersion } from "../shared/version.js";
+import { daemonMainPath, delay, startDaemon, until } from "./testutil.js";
+const TMP_BASE = process.env.LL_TEST_TMP ?? join(tmpdir(), "opencode");
+/** Kill whatever daemon currently owns the state dir (respawned daemons are not our child). */
+function killDaemonFromJson(dir) {
+    try {
+        const info = JSON.parse(readFileSync(join(dir, "daemon.json"), "utf8"));
+        if (typeof info.pid === "number") {
+            try {
+                process.kill(info.pid, "SIGKILL");
+            }
+            catch {
+                /* already gone */
+            }
+        }
+    }
+    catch {
+        /* no daemon.json — nothing to kill */
+    }
+}
+// ---------------------------------------------------------------- H3 regression
+test("feed: failed initial connect recovers once the daemon appears (issue #39 H3)", async () => {
+    const dir = mkdtempSync(join(TMP_BASE, "ll-h3-"));
+    const sock = join(dir, "daemon.sock");
+    // spawnDaemon:false so the FIRST connect fails hard (no daemon, no spawn).
+    const client = new LLClient({ socket: sock, stateDir: dir, spawnDaemon: false });
+    const feed = new DashboardFeed(client, {
+        reconnectBaseMs: 40,
+        refreshDebounceMs: 5,
+        slowRefreshMs: 60_000,
+        inspectEveryMs: 60_000,
+        driftCheckMs: 0,
+    });
+    await assert.rejects(feed.start(), /unavailable|not running/);
+    // The reconnect loop re-enters "connecting" on each attempt; wait for the
+    // failed attempt to land in "reconnecting" (old code: wedged in
+    // "connecting" forever, so this alone catches the regression).
+    await until("failed start enters the reconnect loop", () => feed.currentState() === "reconnecting");
+    // Daemon shows up LATE. Before the fix, the feed stayed wedged in
+    // "connecting" forever (no socket ever attached → no close event →
+    // handleDisconnect never fired → no reconnect loop).
+    const child = spawn(process.execPath, [daemonMainPath, "--state-dir", dir, "--socket", sock], {
+        stdio: "ignore",
+    });
+    try {
+        await until("feed goes live after late daemon spawn", () => feed.currentState() === "live");
+        const v = feed.view();
+        assert.ok(v.daemon, "daemon card present once live");
+        assert.ok(v.daemon.pid > 0);
+    }
+    finally {
+        await feed.stop();
+        child.kill("SIGKILL");
+        await delay(200);
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
+// ---------------------------------------------------------------- H1 repro
+test("feed: SIGKILL daemon under live feed → auto-respawn and live again (issue #39 H1 repro)", async () => {
+    const d = await startDaemon();
+    let feed = null;
+    try {
+        // spawnDaemon defaults to true: the client auto-spawns a replacement.
+        const client = new LLClient({ socket: d.sock, stateDir: d.dir });
+        feed = new DashboardFeed(client, {
+            reconnectBaseMs: 40,
+            refreshDebounceMs: 5,
+            slowRefreshMs: 60_000,
+            inspectEveryMs: 60_000,
+            driftCheckMs: 0,
+            eventHistory: 100,
+        });
+        await feed.start();
+        assert.equal(feed.currentState(), "live");
+        const oldPid = feed.view().daemon?.pid;
+        assert.ok(oldPid, "daemon pid visible before kill");
+        d.child.kill("SIGKILL");
+        await until("feed notices the daemon died", () => feed.currentState() !== "live");
+        // (State briefly reads "reconnecting" then "connecting" while the client
+        // auto-spawns a replacement; the outcome assertion below is what counts.)
+        // Reconnect machinery (existing code) + client auto-spawn bring it back.
+        await until("feed is live again on the respawned daemon", () => feed.currentState() === "live");
+        const v = feed.view();
+        assert.ok(v.daemon, "daemon card present after respawn");
+        assert.notEqual(v.daemon.pid, oldPid, "a NEW daemon process answered");
+        assert.match(v.daemonRestartNote ?? "", /daemon restarted/);
+        assert.equal(v.daemon.daemonVersion, packageVersion(), "respawned daemon runs the current code");
+    }
+    finally {
+        await feed?.stop();
+        // The respawned daemon is nobody's child — kill via its state dir.
+        killDaemonFromJson(d.dir);
+        await d.stop();
+    }
+});
+// ------------------------------------------------- restart-note version change
+/** Switchable mock daemon for resync-level tests (no real processes). */
+class MockClient {
+    daemon;
+    events;
+    latestEventId;
+    watcher = null;
+    constructor(version) {
+        this.daemon = { pid: 111, startedAt: 1_000, protocolVersion: 1, daemonVersion: version };
+        this.events = [{ id: 1, ts: 1_000, type: "daemon_started" }];
+        this.latestEventId = 1;
+    }
+    async connect() { }
+    async request(method, params = {}) {
+        if (method === "status") {
+            return {
+                daemon: this.daemon,
+                config: {
+                    version: 1,
+                    pools: {},
+                    offerTimeoutMs: 30_000,
+                    maxWaitMs: 600_000,
+                    maxTurnWaitMs: 600_000,
+                    startTimeoutMs: 600_000,
+                    untrackedLeaseMs: 600_000,
+                },
+                pools: [],
+                events: { latestEventId: this.latestEventId },
+            };
+        }
+        if (method === "events") {
+            const since = params.sinceEventId ?? 0;
+            return {
+                events: this.events.filter((e) => e.id > since),
+                latestEventId: this.latestEventId,
+            };
+        }
+        if (method === "watch")
+            return {};
+        throw new Error(`mock: unsupported method ${method}`);
+    }
+    async watch(_agentId, onEvent) {
+        this.watcher = onEvent;
+    }
+    onDisconnect() {
+        return () => { };
+    }
+    close() { }
+    /** Simulate a daemon restart, optionally onto a different version. */
+    restart(newVersion) {
+        this.daemon = { pid: 222, startedAt: 2_000, protocolVersion: 1, daemonVersion: newVersion };
+        this.events = [{ id: 1, ts: 2_000, type: "daemon_recovered" }];
+        this.latestEventId = 1;
+    }
+}
+function mockFeed(c) {
+    return new DashboardFeed(c, {
+        slowRefreshMs: 0,
+        driftCheckMs: 0,
+        refreshDebounceMs: 60_000,
+        inspectEveryMs: 60_000,
+    });
+}
+test("resync: daemon restart onto a DIFFERENT version says 'restarted onto vX (was vY)'", async () => {
+    const c = new MockClient("1.4.0");
+    const feed = mockFeed(c);
+    await feed.start();
+    assert.equal(feed.currentState(), "live");
+    assert.equal(feed.view().daemonRestartNote, undefined, "no note before any restart");
+    c.restart("1.5.0");
+    await feed.resync();
+    const note = feed.view().daemonRestartNote ?? "";
+    assert.match(note, /daemon restarted onto v1\.5\.0/);
+    assert.match(note, /was v1\.4\.0/);
+    await feed.stop();
+});
+test("resync: same-version daemon restart keeps the plain pid-only note", async () => {
+    const c = new MockClient("1.4.0");
+    const feed = mockFeed(c);
+    await feed.start();
+    c.restart("1.4.0");
+    await feed.resync();
+    const note = feed.view().daemonRestartNote ?? "";
+    assert.match(note, /daemon restarted/);
+    assert.doesNotMatch(note, /onto/);
+    await feed.stop();
+});
+test("resync: pre-handshake daemon (no version) never gets an 'onto' note", async () => {
+    const c = new MockClient("1.4.0");
+    const feed = mockFeed(c);
+    await feed.start();
+    c.restart(undefined); // old daemon: daemonVersion absent
+    await feed.resync();
+    const note = feed.view().daemonRestartNote ?? "";
+    assert.match(note, /daemon restarted/);
+    assert.doesNotMatch(note, /onto/);
+    await feed.stop();
+});
+// ---------------------------------------------------------------- install drift
+/** Fixture PATH dir containing a fake `load-lock` install of `version`. */
+function pathFixture(version) {
+    const dir = mkdtempSync(join(TMP_BASE, "ll-pathfix-"));
+    if (version === null)
+        return dir; // empty dir: no bin, no package
+    writeFileSync(join(dir, "package.json"), JSON.stringify({ name: "@aron98/load-lock", version }));
+    const bin = join(dir, "load-lock");
+    writeFileSync(bin, "#!/bin/sh\nexit 0\n");
+    chmodSync(bin, 0o755);
+    return dir;
+}
+test("detectInstallDrift: PATH CLI newer than this copy ⇒ stale", () => {
+    const dir = pathFixture("99.0.0");
+    try {
+        const drift = detectInstallDrift(process.platform, { PATH: dir });
+        assert.equal(drift.pathVersion, "99.0.0");
+        assert.ok(drift.stale, "99.0.0 > " + drift.ownVersion);
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
+test("detectInstallDrift: same version ⇒ not stale; no PATH install ⇒ null", () => {
+    const same = pathFixture(packageVersion());
+    const empty = pathFixture(null);
+    try {
+        const drift = detectInstallDrift(process.platform, { PATH: same });
+        assert.equal(drift.pathVersion, packageVersion());
+        assert.ok(!drift.stale);
+        const none = detectInstallDrift(process.platform, { PATH: empty });
+        assert.equal(none.pathVersion, null);
+        assert.ok(!none.stale);
+    }
+    finally {
+        rmSync(same, { recursive: true, force: true });
+        rmSync(empty, { recursive: true, force: true });
+    }
+});
+test("pathInstall: resolves through the fixture PATH dir", () => {
+    const dir = pathFixture("99.0.0");
+    try {
+        const inst = pathInstall(process.platform, { PATH: dir });
+        assert.ok(inst, "fixture install found");
+        assert.equal(inst.path, dir);
+        assert.equal(inst.version, "99.0.0");
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
+function viewInputs(drift, surface) {
+    return {
+        status: null,
+        inspect: null,
+        events: [],
+        latestEventId: 0,
+        state: "live",
+        lastSyncAt: Date.now(),
+        installDrift: drift,
+        driftSurface: surface,
+        now: 1_760_000_000_000,
+    };
+}
+const STALE_DRIFT = { ownVersion: "1.4.0", pathVersion: "99.0.0", stale: true };
+test("view: drift note for the opencode surface says 'restart opencode to pick up vX'", () => {
+    const v = buildDashboardView(viewInputs(STALE_DRIFT, "opencode"));
+    assert.match(v.installDriftNote ?? "", /plugin updated — restart opencode to pick up v99\.0\.0/);
+    assert.match(v.installDriftNote ?? "", /this session still runs v1\.4\.0/);
+});
+test("view: default (cli) drift note calls out the stale install", () => {
+    const v = buildDashboardView(viewInputs(STALE_DRIFT));
+    assert.match(v.installDriftNote ?? "", /PATH CLI v99\.0\.0 is newer than this copy v1\.4\.0/);
+    assert.match(v.installDriftNote ?? "", /stale install/);
+});
+test("view: no drift note when not stale or unknown", () => {
+    assert.equal(buildDashboardView(viewInputs({ ownVersion: "1.4.0", pathVersion: "1.4.0", stale: false })).installDriftNote, undefined);
+    assert.equal(buildDashboardView(viewInputs({ ownVersion: "1.4.0", pathVersion: null, stale: false })).installDriftNote, undefined);
+    assert.equal(buildDashboardView(viewInputs(null)).installDriftNote, undefined);
+});
+test("frame: drift note renders as a `note:` line", () => {
+    const v = buildDashboardView(viewInputs(STALE_DRIFT, "opencode"));
+    const lines = renderFrame(v, 160).join("\n");
+    assert.match(lines, /note: plugin updated — restart opencode to pick up v99\.0\.0/);
+});
+// ------------------------------------------------------------ resolveDaemonEntry
+test("resolveDaemonEntry: own entry wins when it exists", () => {
+    assert.equal(resolveDaemonEntry(daemonMainPath, process.platform, { PATH: "" }), daemonMainPath);
+});
+test("resolveDaemonEntry: vanished own entry falls back to the PATH install", () => {
+    const dir = pathFixture("99.0.0");
+    try {
+        const nested = join(dir, "dist", "core");
+        mkdirSync(nested, { recursive: true });
+        const entry = join(nested, "daemon-main.js");
+        writeFileSync(entry, "// fixture daemon entry\n");
+        const own = join(dir, "does-not-exist", "daemon-main.js");
+        assert.ok(!existsSync(own));
+        assert.equal(resolveDaemonEntry(own, process.platform, { PATH: dir }), entry);
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
+test("resolveDaemonEntry: vanished own entry with no usable PATH install → own unchanged", () => {
+    const empty = pathFixture(null);
+    try {
+        const own = join(empty, "gone", "daemon-main.js");
+        assert.equal(resolveDaemonEntry(own, process.platform, { PATH: empty }), own);
+    }
+    finally {
+        rmSync(empty, { recursive: true, force: true });
+    }
+});
+// --------------------------------------------------------------------- H2
+test("ensureDaemon: unreadable daemon entry fails the probe, does not crash the host (issue #39 H2)", async () => {
+    const dir = mkdtempSync(join(TMP_BASE, "ll-h2-"));
+    const sock = join(dir, "daemon.sock");
+    // The child imports the COMPILED client and calls ensureDaemon with a
+    // daemon entry that cannot spawn (ENOENT). Without the spawn error
+    // listener, the 'error' event on the detached child is an uncaught
+    // exception and the process dies before it can report anything.
+    const script = join(dir, "child.mjs");
+    writeFileSync(script, `import { ensureDaemon } from ${JSON.stringify(new URL("../shared/client.js", import.meta.url).href)};\ntry {\n  await ensureDaemon(${JSON.stringify(dir)}, ${JSON.stringify(sock)});\n  console.log("unexpected: spawned");\n} catch (e) {\n  console.log("code=" + (e && e.code) + " msg=" + (e && e.message));\n}\n`);
+    const child = spawn(process.execPath, ["--no-warnings", script], {
+        env: {
+            ...process.env,
+            LOAD_LOCK_DAEMON_BIN: "/nonexistent/load-lock-daemon-main.js",
+            LOAD_LOCK_STATE_DIR: dir,
+            LOAD_LOCK_SOCKET: sock,
+        },
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    let out = "";
+    child.stdout.on("data", (b) => (out += b));
+    let err = "";
+    child.stderr.on("data", (b) => (err += b));
+    const code = await new Promise((resolve) => {
+        const timer = setTimeout(() => {
+            child.kill("SIGKILL");
+            resolve(-1);
+        }, 30_000);
+        child.once("exit", (c) => {
+            clearTimeout(timer);
+            resolve(c);
+        });
+    });
+    try {
+        assert.equal(code, 0, `child must exit cleanly (stderr: ${err})`);
+        assert.match(out, /unavailable/);
+        assert.match(out, /did not come up/);
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+});

package/dist/test/runtimes.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/runtimes.test.js

@@ -0,0 +1,282 @@
+/**
+ * Runtime-copy bookkeeping (issue #52):
+ *  - daemon.json records the daemon's package root + version
+ *  - the client envelope carries clientRoot; the daemon keeps a known-copies
+ *    list (runtimes.json) deduped by real path, ignoring bogus hints and
+ *    dropping copies whose path is gone
+ *  - `doctor` lists the copies
+ *  - self-restart onto the newer client's copy (issue #53), with bogus or
+ *    mismatched hints falling back to the same-argv respawn, no loops
+ *
+ * Real daemons over real sockets in temp state dirs (never the user's).
+ */
+import test from "node:test";
+import assert from "node:assert/strict";
+import { spawn } from "node:child_process";
+import { mkdtempSync, rmSync, mkdirSync, writeFileSync, readFileSync, realpathSync, symlinkSync, cpSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { connect, createServer } from "node:net";
+import { LLClient } from "../shared/client.js";
+import { packageVersion, packageRoot } from "../shared/version.js";
+import { loadRuntimes } from "../shared/runtimes.js";
+import { restartEntry } from "../core/daemon.js";
+import { startDaemon, cliMainPath, probe, delay, until } from "./testutil.js";
+const TMP_BASE = process.env.LL_TEST_TMP ?? join(tmpdir(), "opencode");
+mkdirSync(TMP_BASE, { recursive: true });
+/** Send one raw envelope line; resolve the first response (or null). */
+function rawRequest(sockPath, envelope, timeoutMs = 3000) {
+    return new Promise((resolve) => {
+        let buf = "";
+        const s = connect(sockPath, () => s.write(JSON.stringify(envelope) + "\n"));
+        const done = (v) => {
+            s.destroy();
+            resolve(v);
+        };
+        s.on("data", (chunk) => {
+            buf += chunk.toString("utf8");
+            const idx = buf.indexOf("\n");
+            if (idx !== -1)
+                done(JSON.parse(buf.slice(0, idx)));
+        });
+        s.on("error", () => done(null));
+        setTimeout(() => done(null), timeoutMs).unref?.();
+    });
+}
+/** Plant a fake package root with the given package.json name/version. */
+function plantCopy(base, name, pkgName, version) {
+    const dir = join(base, name);
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, "package.json"), JSON.stringify({ name: pkgName, version }));
+    return dir;
+}
+test("daemon.json records the daemon's package root and version", async () => {
+    const d = await startDaemon();
+    try {
+        const info = JSON.parse(readFileSync(join(d.dir, "daemon.json"), "utf8"));
+        assert.equal(info.pid, d.child.pid);
+        assert.equal(info.version, packageVersion());
+        assert.equal(info.packageRoot, realpathSync(packageRoot()));
+        // The daemon's own copy is the first known runtime.
+        assert.ok(loadRuntimes(d.dir).some((c) => c.path === info.packageRoot && c.version === packageVersion()));
+    }
+    finally {
+        await d.stop();
+    }
+});
+test("client envelope carries clientRoot", async () => {
+    const capDir = mkdtempSync(join(TMP_BASE, "ll-capture-"));
+    const capSock = join(capDir, "cap.sock");
+    let captured = "";
+    const server = createServer((s) => {
+        s.on("data", (chunk) => {
+            captured += chunk.toString("utf8");
+            const idx = captured.indexOf("\n");
+            if (idx !== -1)
+                s.write(JSON.stringify({ id: JSON.parse(captured.slice(0, idx)).id, ok: true, result: {} }) + "\n");
+        });
+    });
+    await new Promise((r) => server.listen(capSock, r));
+    try {
+        const c = new LLClient({ socket: capSock, stateDir: capDir, spawnDaemon: false });
+        await c.connect();
+        await c.request("hello", {});
+        c.close();
+        const envelope = JSON.parse(captured.trim());
+        assert.equal(envelope.clientRoot, packageRoot());
+    }
+    finally {
+        await new Promise((r) => server.close(() => r()));
+        rmSync(capDir, { recursive: true, force: true });
+    }
+});
+test("known copies: recorded from handshakes, deduped by real path, bogus hints ignored, gone paths dropped", async () => {
+    const d = await startDaemon();
+    const base = mkdtempSync(join(TMP_BASE, "ll-copies-"));
+    try {
+        const a = plantCopy(base, "a", "@aron98/load-lock", "0.0.1");
+        const b = plantCopy(base, "b", "@aron98/load-lock", "0.0.2");
+        const foreign = plantCopy(base, "foreign", "some-other-pkg", "9.9.9");
+        symlinkSync(a, join(base, "a-link"));
+        // No clientVersion: these hints never trigger a self-restart.
+        for (const root of [a, join(base, "a-link"), foreign, join(base, "missing"), b]) {
+            const r = await rawRequest(d.sock, { id: 1, method: "hello", params: {}, clientRoot: root });
+            assert.ok(r?.ok, `hello with clientRoot ${root}`);
+        }
+        let copies = loadRuntimes(d.dir);
+        const paths = copies.map((c) => c.path);
+        assert.equal(paths.filter((p) => p === realpathSync(a)).length, 1, "symlinked hint deduped by real path");
+        assert.ok(copies.some((c) => c.path === realpathSync(b) && c.version === "0.0.2"), "version read from disk");
+        assert.ok(!paths.some((p) => p.includes("foreign") || p.includes("missing")), `bogus hints ignored: ${paths}`);
+        // Copy a disappears (e.g. npx cache cleaned); the next new sighting
+        // prunes it, and a reader never reports it either.
+        rmSync(a, { recursive: true, force: true });
+        const c = plantCopy(base, "c", "@aron98/load-lock", "0.0.3");
+        await rawRequest(d.sock, { id: 1, method: "hello", params: {}, clientRoot: c });
+        const raw = JSON.parse(readFileSync(join(d.dir, "runtimes.json"), "utf8"));
+        assert.ok(!raw.copies.some((x) => x.path === join(realpathSync(base), "a")), "gone copy pruned on disk");
+        copies = loadRuntimes(d.dir);
+        assert.ok(copies.some((x) => x.version === "0.0.3"));
+    }
+    finally {
+        await d.stop();
+        rmSync(base, { recursive: true, force: true });
+    }
+});
+test("doctor lists the daemon's runtime and known copies", async () => {
+    const d = await startDaemon();
+    const base = mkdtempSync(join(TMP_BASE, "ll-copies-"));
+    try {
+        const a = plantCopy(base, "a", "@aron98/load-lock", "0.0.1");
+        await rawRequest(d.sock, { id: 1, method: "hello", params: {}, clientRoot: a });
+        const r = await new Promise((resolve) => {
+            const child = spawn(process.execPath, [cliMainPath, "doctor", "--json"], { env: d.env });
+            let stdout = "";
+            child.stdout.on("data", (b) => (stdout += b));
+            child.stdin.end();
+            child.once("exit", (code) => resolve({ code, stdout }));
+        });
+        assert.equal(r.code, 0);
+        const report = JSON.parse(r.stdout);
+        assert.equal(report.daemonRuntime.path, realpathSync(packageRoot()));
+        assert.equal(report.daemonRuntime.version, packageVersion());
+        const listed = report.knownRuntimes.map((c) => `${c.version}@${c.path}`);
+        assert.ok(listed.includes(`0.0.1@${realpathSync(a)}`), `planted copy listed: ${listed}`);
+        assert.ok(listed.includes(`${packageVersion()}@${realpathSync(packageRoot())}`), `own copy listed: ${listed}`);
+    }
+    finally {
+        await d.stop();
+        rmSync(base, { recursive: true, force: true });
+    }
+});
+// ------------------------------------------------------------- issue #53
+/**
+ * Plant a runnable load-lock copy: the built dist/ (minus tests), the real
+ * package.json with a different version, node_modules symlinked to ours.
+ */
+function plantRuntime(base, name, version) {
+    const root = realpathSync(packageRoot());
+    const dir = join(base, name);
+    mkdirSync(dir, { recursive: true });
+    cpSync(join(root, "dist"), join(dir, "dist"), { recursive: true, filter: (src) => !src.startsWith(join(root, "dist", "test")) });
+    const pkg = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
+    writeFileSync(join(dir, "package.json"), JSON.stringify({ ...pkg, version }));
+    symlinkSync(join(root, "node_modules"), join(dir, "node_modules"));
+    return realpathSync(dir);
+}
+/** Start a daemon from a planted copy; only raw (version-less) envelopes talk to it. */
+async function startCopyDaemon(copy, dir) {
+    const sock = join(dir, "daemon.sock");
+    const child = spawn(process.execPath, [join(copy, "dist", "core", "daemon-main.js"), "--state-dir", dir, "--socket", sock], {
+        stdio: "ignore",
+        detached: true,
+    });
+    child.unref();
+    await until("planted daemon up", () => probe(sock), 10_000, 100);
+    return { sock, pid: child.pid };
+}
+function killFromJson(dir) {
+    try {
+        process.kill(JSON.parse(readFileSync(join(dir, "daemon.json"), "utf8")).pid, "SIGKILL");
+    }
+    catch {
+        /* gone */
+    }
+}
+async function helloRaw(sock, extra = {}) {
+    const r = await rawRequest(sock, { id: 1, method: "hello", params: {}, ...extra }, 2000);
+    return r?.ok ? r.result : null;
+}
+async function waitNewPid(sock, oldPid) {
+    let hello = null;
+    await until("daemon respawned", async () => {
+        if (!(await probe(sock)))
+            return false;
+        hello = await helloRaw(sock);
+        return hello !== null && hello.pid !== oldPid;
+    });
+    return hello;
+}
+test("restartEntry: only a matching load-lock copy with a daemon entry qualifies", () => {
+    const base = mkdtempSync(join(TMP_BASE, "ll-entry-"));
+    try {
+        const good = plantCopy(base, "good", "@aron98/load-lock", "0.2.0");
+        mkdirSync(join(good, "dist", "core"), { recursive: true });
+        writeFileSync(join(good, "dist", "core", "daemon-main.js"), "");
+        const noEntry = plantCopy(base, "noentry", "@aron98/load-lock", "0.2.0");
+        const foreign = plantCopy(base, "foreign", "not-load-lock", "0.2.0");
+        mkdirSync(join(foreign, "dist", "core"), { recursive: true });
+        writeFileSync(join(foreign, "dist", "core", "daemon-main.js"), "");
+        assert.equal(restartEntry(good, "0.2.0"), join(realpathSync(good), "dist", "core", "daemon-main.js"));
+        assert.equal(restartEntry(good, "0.3.0"), null, "claimed version must match the copy on disk");
+        assert.equal(restartEntry(noEntry, "0.2.0"), null, "copy without a daemon entry");
+        assert.equal(restartEntry(foreign, "0.2.0"), null, "foreign package");
+        assert.equal(restartEntry(join(base, "missing"), "0.2.0"), null, "nonexistent path");
+        assert.equal(restartEntry(undefined, "0.2.0"), null, "no hint");
+    }
+    finally {
+        rmSync(base, { recursive: true, force: true });
+    }
+});
+test("self-restart moves the daemon onto the newer client's copy; state and journal survive", async () => {
+    const base = mkdtempSync(join(TMP_BASE, "ll-2c-"));
+    const dir = join(base, "s");
+    mkdirSync(dir);
+    const sleeper = spawn("sleep", ["60"], { stdio: "ignore" });
+    try {
+        const oldCopy = plantRuntime(base, "old", "0.1.0");
+        const newCopy = plantRuntime(base, "new", "0.2.0");
+        const { sock, pid } = await startCopyDaemon(oldCopy, dir);
+        assert.equal((await helloRaw(sock)).daemonVersion, "0.1.0");
+        // A tracked permit held on the old daemon.
+        const g = await rawRequest(sock, { id: 2, method: "acquire", params: { agentId: "A", opKey: "op1", reason: "two copies" } });
+        const permitToken = g.result.entry.permitToken;
+        await rawRequest(sock, { id: 3, method: "attach_pid", params: { permitToken, pid: sleeper.pid } });
+        // A newer client from a different copy shows up.
+        assert.ok(await helloRaw(sock, { clientVersion: "0.2.0", clientRoot: newCopy }));
+        const h = await waitNewPid(sock, pid);
+        assert.equal(h.daemonVersion, "0.2.0", "daemon now runs the newer copy");
+        const info = JSON.parse(readFileSync(join(dir, "daemon.json"), "utf8"));
+        assert.equal(info.packageRoot, newCopy);
+        assert.equal(info.version, "0.2.0");
+        const st = await rawRequest(sock, { id: 4, method: "status", params: {} });
+        assert.equal(st.result.pools[0].holders.length, 1, "held permit survives the move");
+        assert.equal(st.result.pools[0].holders[0].pid, sleeper.pid);
+        const rel = await rawRequest(sock, { id: 5, method: "release", params: { permitToken } });
+        assert.equal(rel.result.releasedNow, true, "same permit token still releases");
+        // Stable afterwards: the same newer client does not restart it again.
+        await helloRaw(sock, { clientVersion: "0.2.0", clientRoot: newCopy });
+        await delay(600);
+        assert.equal((await helloRaw(sock)).pid, h.pid);
+    }
+    finally {
+        sleeper.kill("SIGKILL");
+        killFromJson(dir);
+        rmSync(base, { recursive: true, force: true });
+    }
+});
+test("bogus or mismatched copy hint: no respawn onto it, same-argv fallback, no restart loop", async () => {
+    const base = mkdtempSync(join(TMP_BASE, "ll-2c-"));
+    const dir = join(base, "s");
+    mkdirSync(dir);
+    try {
+        const oldCopy = plantRuntime(base, "old", "0.1.0");
+        // Claims 0.2.0 but the copy on disk is 0.3.0.
+        const mismatched = plantRuntime(base, "mismatch", "0.3.0");
+        const { sock, pid } = await startCopyDaemon(oldCopy, dir);
+        await helloRaw(sock, { clientVersion: "0.2.0", clientRoot: mismatched });
+        const h = await waitNewPid(sock, pid);
+        assert.equal(h.daemonVersion, "0.1.0", "respawned on its own copy, not the mismatched hint");
+        assert.equal(JSON.parse(readFileSync(join(dir, "daemon.json"), "utf8")).packageRoot, oldCopy);
+        // Further bogus hints for the same or an older version: no loop.
+        await helloRaw(sock, { clientVersion: "0.2.0", clientRoot: mismatched });
+        await helloRaw(sock, { clientVersion: "0.2.0", clientRoot: join(base, "nowhere") });
+        await helloRaw(sock, { clientVersion: "0.1.5", clientRoot: "/" });
+        await delay(800);
+        assert.equal((await helloRaw(sock)).pid, h.pid, "no restart loop");
+    }
+    finally {
+        killFromJson(dir);
+        rmSync(base, { recursive: true, force: true });
+    }
+});

package/dist/test/setup.test.d.ts

@@ -0,0 +1 @@
+export {};