@aron98/load-lock 0.1.2 → 1.1.0

package/dist/test/mcp.test.js

@@ -29,7 +29,7 @@ test("mcp: tool listing + acquire/release/configure round trip", async () => {
     try {
         const tools = await c.listTools();
         const names = tools.tools.map((t) => t.name);
-        for (const expected of ["acquire", "claim", "release", "cancel", "rejoin", "pending", "status", "inspect_machine", "get_config", "configure", "run_with_permit", "job_status", "job_stop", "attach_pid", "mark_started"]) {
+        for (const expected of ["acquire", "claim", "release", "cancel", "rejoin", "pending", "wait_for_turn", "status", "inspect_machine", "get_config", "configure", "run_with_permit", "job_status", "job_stop", "attach_pid", "mark_started"]) {
             assert.ok(names.includes(expected), `tool ${expected} registered`);
         }
         const acq = await callJson(c, "acquire", { reason: "build", op_key: "mcp-rt", agent_id: "mcpAgentA" });
@@ -77,6 +77,41 @@ test("mcp: tool listing + acquire/release/configure round trip", async () => {
         await d.stop();
     }
 });
+test("mcp: wait_for_turn sleeps bounded and returns structured snake_case results", async () => {
+    const d = await startDaemon();
+    const c = await connectMcp(d);
+    try {
+        const a = await callJson(c, "acquire", { reason: "build", op_key: "wft-a", agent_id: "mcpWaitA" });
+        assert.equal(a.state, "granted");
+        const b = await callJson(c, "acquire", { reason: "tests", op_key: "wft-b", agent_id: "mcpWaitB" });
+        assert.equal(b.state, "queued");
+        // Timeout is a structured still_queued result — never a tool error.
+        const t0 = Date.now();
+        const out1 = await callJson(c, "wait_for_turn", { agent_id: "mcpWaitB", timeout_ms: 700 });
+        assert.equal(out1.state, "still_queued");
+        assert.equal(out1.request_id, b.request_id);
+        assert.equal(out1.queue_position, 1);
+        assert.equal(out1.queue_length, 1);
+        assert.ok(Array.isArray(out1.holders) && out1.holders.length >= 1, "holder info included");
+        assert.equal(out1.holders[0].agentId, "mcpWaitA");
+        assert.ok(out1.waited_ms >= 600 && Date.now() - t0 < 5_000, "wait respected the bound");
+        // The cap is discoverable via configure + get_config (snake_case surface).
+        const cfg = await callJson(c, "get_config", {});
+        assert.equal(cfg.config.maxTurnWaitMs, 600_000, "default turn-wait cap present in config");
+        // Wake path: release, sleep again, wake holding an auto-claimed permit.
+        await callJson(c, "release", { permit_token: a.permit_token });
+        const out2 = await callJson(c, "wait_for_turn", { agent_id: "mcpWaitB", timeout_ms: 10_000 });
+        assert.equal(out2.state, "granted");
+        assert.equal(out2.auto_claimed, true, "auto-claim is explicit in the response");
+        assert.ok(out2.permit_token, "granted result carries a top-level permit_token");
+        assert.equal(out2.request_id, b.request_id);
+        await callJson(c, "release", { permit_token: out2.permit_token });
+    }
+    finally {
+        await c.close();
+        await d.stop();
+    }
+});
 test("mcp: run_with_permit tracks a background job and auto-releases", async () => {
     const d = await startDaemon();
     const c = await connectMcp(d);

package/dist/test/platform.test.d.ts

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

package/dist/test/platform.test.js

@@ -0,0 +1,193 @@
+/**
+ * Unit tests for the cross-platform transport seam (src/shared/transport.ts)
+ * and its integration into state-dir/socket-path resolution (persist.ts).
+ *
+ * These tests run on Linux: the Windows branches are exercised by
+ * explicitly injecting platform = "win32" into the pure functions. No
+ * Windows machine was available for live verification — see
+ * docs/COMPATIBILITY.md (platform matrix).
+ */
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, mkdirSync, existsSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { createServer } from "node:net";
+import { spawn } from "node:child_process";
+import { DEFAULT_PIPE_NAME, isWindows, namedPipePath, resolveStateDir, resolveSocketPath, probeTransport, removeStaleEndpoint, killProcessGroup, } from "../shared/transport.js";
+import { stateDir, socketPath } from "../core/persist.js";
+import { isProcessAlive, jobAlive, aliveBySignalZero, processStartTime } from "../core/daemon.js";
+const TMP_BASE = process.env.LL_TEST_TMP ?? join(tmpdir(), "opencode");
+mkdirSync(TMP_BASE, { recursive: true });
+const tmp = mkdtempSync(join(TMP_BASE, "ll-platform-"));
+test("namedPipePath builds \\\\.\\pipe\\load-lock by default", () => {
+    assert.equal(namedPipePath(), "\\\\.\\pipe\\load-lock");
+    assert.equal(namedPipePath(), `\\\\.\\pipe\\${DEFAULT_PIPE_NAME}`);
+    assert.equal(namedPipePath("other"), "\\\\.\\pipe\\other");
+});
+test("isWindows only matches win32", () => {
+    assert.equal(isWindows("win32"), true);
+    assert.equal(isWindows("linux"), false);
+    assert.equal(isWindows("darwin"), false);
+});
+test("resolveStateDir: override wins over env and default", () => {
+    const env = { LOAD_LOCK_STATE_DIR: "/from-env", HOME: "/home/u" };
+    assert.equal(resolveStateDir("win32", env, "/explicit"), "/explicit");
+    assert.equal(resolveStateDir("linux", env, "/explicit"), "/explicit");
+    assert.equal(resolveStateDir("win32", env), "/from-env");
+});
+test("resolveStateDir: win32 uses LOCALAPPDATA, then USERPROFILE fallback", () => {
+    const env = { LOCALAPPDATA: "C:\\Users\\u\\AppData\\Local", USERPROFILE: "C:\\Users\\u" };
+    assert.equal(resolveStateDir("win32", env), "C:\\Users\\u\\AppData\\Local\\load-lock");
+    const env2 = { USERPROFILE: "C:\\Users\\u" };
+    assert.equal(resolveStateDir("win32", env2), "C:\\Users\\u\\AppData\\Local\\load-lock");
+});
+test("resolveStateDir: linux uses XDG_STATE_HOME, then HOME fallback", () => {
+    const env = { XDG_STATE_HOME: "/xdg/state", HOME: "/home/u" };
+    assert.equal(resolveStateDir("linux", env), "/xdg/state/load-lock");
+    const env2 = { HOME: "/home/u" };
+    assert.equal(resolveStateDir("linux", env2), "/home/u/.local/state/load-lock");
+});
+test("resolveSocketPath: win32 default is the named pipe", () => {
+    const env = { LOCALAPPDATA: "C:\\Users\\u\\AppData\\Local" };
+    assert.equal(resolveSocketPath("win32", env), "\\\\.\\pipe\\load-lock");
+});
+test("resolveSocketPath: LOAD_LOCK_SOCKET override wins on every platform", () => {
+    const env = { LOAD_LOCK_SOCKET: "C:\\somewhere\\other.sock" };
+    assert.equal(resolveSocketPath("win32", env), "C:\\somewhere\\other.sock");
+    assert.equal(resolveSocketPath("linux", env), "C:\\somewhere\\other.sock");
+});
+test("resolveSocketPath: linux default is <state dir>/daemon.sock", () => {
+    const env = { HOME: "/home/u" };
+    assert.equal(resolveSocketPath("linux", env), "/home/u/.local/state/load-lock/daemon.sock");
+});
+test("resolveSocketPath: explicit override wins over everything", () => {
+    const env = { LOAD_LOCK_SOCKET: "/from-env", LOAD_LOCK_STATE_DIR: "/s" };
+    assert.equal(resolveSocketPath("linux", env, "/explicit"), "/explicit");
+});
+test("persist stateDir()/socketPath() delegate with the real platform", () => {
+    // On Linux (the only platform these tests run on) the defaults must keep
+    // their current shape, and env overrides must flow through.
+    const savedState = process.env.LOAD_LOCK_STATE_DIR;
+    const savedSock = process.env.LOAD_LOCK_SOCKET;
+    try {
+        delete process.env.LOAD_LOCK_STATE_DIR;
+        delete process.env.LOAD_LOCK_SOCKET;
+        assert.equal(socketPath(), resolveSocketPath(process.platform, process.env));
+        assert.equal(stateDir(), resolveStateDir(process.platform, process.env));
+        process.env.LOAD_LOCK_SOCKET = "/tmp/opencode/ll-platform-override.sock";
+        assert.equal(socketPath(), "/tmp/opencode/ll-platform-override.sock");
+        assert.equal(socketPath("/cli-flag.sock"), "/cli-flag.sock");
+    }
+    finally {
+        if (savedState === undefined)
+            delete process.env.LOAD_LOCK_STATE_DIR;
+        else
+            process.env.LOAD_LOCK_STATE_DIR = savedState;
+        if (savedSock === undefined)
+            delete process.env.LOAD_LOCK_SOCKET;
+        else
+            process.env.LOAD_LOCK_SOCKET = savedSock;
+    }
+});
+async function withUdsServer(fn) {
+    const sockPath = join(tmp, "probe.sock");
+    const server = createServer();
+    await new Promise((resolve) => server.listen(sockPath, resolve));
+    try {
+        await fn(sockPath, server);
+    }
+    finally {
+        await new Promise((resolve) => server.close(() => resolve()));
+        rmSync(sockPath, { force: true });
+    }
+}
+test("probeTransport: true for a live server, false after close", async () => {
+    await withUdsServer(async (sockPath, server) => {
+        assert.equal(await probeTransport(sockPath), true);
+        await new Promise((resolve) => server.close(() => resolve()));
+        assert.equal(await probeTransport(sockPath), false);
+    });
+});
+test("probeTransport: false for a nonexistent endpoint (never throws)", async () => {
+    assert.equal(await probeTransport(join(tmp, "no-such.sock")), false);
+});
+test("removeStaleEndpoint: POSIX unlinks, win32 is a no-op", () => {
+    const stale = join(tmp, "stale.sock");
+    writeFileSync(stale, "");
+    removeStaleEndpoint(stale, "linux");
+    assert.equal(existsSync(stale), false);
+    const stale2 = join(tmp, "stale2.sock");
+    writeFileSync(stale2, "");
+    removeStaleEndpoint(stale2, "win32");
+    assert.equal(existsSync(stale2), true); // untouched on Windows
+    rmSync(stale2, { force: true });
+    // Missing file: must not throw.
+    removeStaleEndpoint(join(tmp, "never-there.sock"), "linux");
+});
+test("killProcessGroup: POSIX path kills a detached process group", async () => {
+    const child = spawn("sleep", ["30"], { detached: true, stdio: "ignore" });
+    child.unref();
+    const pid = child.pid;
+    // Give the process a moment to be scheduled.
+    await new Promise((r) => setTimeout(r, 100));
+    killProcessGroup(pid, "SIGKILL", "linux");
+    const exited = await new Promise((resolve) => {
+        const t = setTimeout(() => resolve(false), 5000);
+        child.once("exit", () => {
+            clearTimeout(t);
+            resolve(true);
+        });
+    });
+    assert.equal(exited, true);
+});
+test("killProcessGroup: win32 branch on Linux swallows taskkill failure", () => {
+    // taskkill does not exist on Linux; the spawn must not throw.
+    assert.doesNotThrow(() => killProcessGroup(12345, "SIGKILL", "win32"));
+    assert.doesNotThrow(() => killProcessGroup(12345, "SIGTERM", "win32"));
+});
+test("killProcessGroup: POSIX path tolerates a dead pgid", () => {
+    assert.doesNotThrow(() => killProcessGroup(999_999, "SIGKILL", "linux"));
+});
+// ------------------------------------------------------------- liveness (win32)
+test("isProcessAlive: win32 branch uses signal-0 semantics (injected platform)", () => {
+    assert.equal(isProcessAlive(process.pid, undefined, "win32"), true);
+    // A start time can't be verified without /proc — pid must still count as
+    // alive (conservative; the pid-reuse defense is documented as absent).
+    assert.equal(isProcessAlive(process.pid, "9999", "win32"), true);
+    // 4194303 is the Windows ceiling; a pid that high is never in use here.
+    assert.equal(isProcessAlive(4_194_303, undefined, "win32"), false);
+});
+test("aliveBySignalZero: own pid alive, pid 1 alive (ours or EPERM), huge pid dead", () => {
+    assert.equal(aliveBySignalZero(process.pid), true);
+    // On Linux init is owned by root: signal 0 yields EPERM, which must count
+    // as alive. On a container where we are root, it trivially succeeds.
+    assert.equal(aliveBySignalZero(1), true);
+    assert.equal(aliveBySignalZero(4_194_303), false);
+});
+test("isProcessAlive: Linux branch still checks /proc start time", () => {
+    const st = processStartTime(process.pid);
+    assert.ok(st !== undefined, "/proc start time must be readable on Linux");
+    assert.equal(isProcessAlive(process.pid, st, "linux"), true);
+    assert.equal(isProcessAlive(process.pid, "9999", "linux"), false); // mismatch = reuse
+});
+test("jobAlive: win32 skips the process-group scan", () => {
+    assert.equal(jobAlive(process.pid, undefined, undefined, "win32"), true);
+    // Dead main pid: released even though a group scan would have been
+    // possible on Linux — Windows has no process groups.
+    assert.equal(jobAlive(4_194_303, process.pid, undefined, "win32"), false);
+    // pgid-only on win32: unknown => conservative keep.
+    assert.equal(jobAlive(undefined, 12345, undefined, "win32"), null);
+});
+test("jobAlive: Linux still scans process groups", () => {
+    assert.equal(jobAlive(process.pid, undefined, undefined, "linux"), true);
+    // pgid 1 exists but a dead pid + live foreign pgid keeps the job "alive"
+    // via the group scan — semantics unchanged on Linux.
+    assert.equal(jobAlive(4_194_303, 1, undefined, "linux"), true);
+    // Both dead => false on Linux (group 999999 has no members).
+    assert.equal(jobAlive(4_194_303, 999_999, undefined, "linux"), false);
+});
+// Clean up once everything finished.
+test("cleanup tmp dir", () => {
+    rmSync(tmp, { recursive: true, force: true });
+});

package/dist/test/testutil.js

@@ -8,7 +8,10 @@ import { join, dirname } from "node:path";
 import { connect } from "node:net";
 import { fileURLToPath } from "node:url";
 import { LLClient } from "../shared/client.js";
-const TMP_BASE = join(tmpdir(), "opencode");
+// Tests must never touch the user's real state dir. LL_TEST_TMP lets the
+// suite run on machines where /tmp/opencode is not writable (same override
+// as daemon.test.ts).
+const TMP_BASE = process.env.LL_TEST_TMP ?? join(tmpdir(), "opencode");
 mkdirSync(TMP_BASE, { recursive: true });
 export const daemonMainPath = join(dirname(fileURLToPath(import.meta.url)), "..", "core", "daemon-main.js");
 export const cliMainPath = join(dirname(fileURLToPath(import.meta.url)), "..", "cli", "main.js");

package/dist/test/tui.test.d.ts

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

package/dist/test/tui.test.js

@@ -0,0 +1,89 @@
+/**
+ * TUI plugin tests (issue #24): the at-a-glance summary behind the
+ * home.footer.status indicator and the new clickable sidebar.footer widget.
+ *
+ * What is testable here without a TUI host:
+ *  - the compiled plugin module loads headless (its runtime imports are
+ *    only @opencode/plugin/tui, solid-js, and the shared client/feed —
+ *    @opentui/* are type-only) and self-describes as "load-lock.tui"
+ *  - the dashboard opens via the in-window PanelPresentation ("panel",
+ *    never fullscreen), pinned by the exported PANEL_PRESENTATION constant
+ *  - poolGlance(): the pure per-pool summary (bits + health) both
+ *    indicator surfaces share
+ *
+ * What is NOT testable here: actual slot rendering, mouse delivery in a
+ * live terminal, and panel.open behavior — those are live-verified in a
+ * real OpenCode session and documented in the PR (see docs/ updates).
+ * plugin.setup() is deliberately NOT invoked: it starts a DashboardFeed
+ * against a real daemon and would spawn/connect outside test isolation.
+ */
+import test from "node:test";
+import assert from "node:assert/strict";
+import tui, { PANEL_PRESENTATION, poolGlance } from "../adapters/opencode/tui.js";
+// ------------------------------------------------------------- fixtures
+function poolView(over = {}) {
+    return {
+        pool: "heavy",
+        capacity: 3,
+        used: 1,
+        heldWeight: 1,
+        offeredWeight: 0,
+        free: 2,
+        utilization: 1 / 3,
+        holders: [],
+        offers: [],
+        queue: [],
+        paused: [],
+        ...over,
+    };
+}
+function view(pools, state = "live") {
+    return {
+        now: 1_760_000_000_000,
+        state,
+        daemon: null,
+        pools,
+        events: [],
+        latestEventId: 0,
+        machine: null,
+        lastSyncAt: 1_760_000_000_000,
+    };
+}
+// ------------------------------------------------------ module contract
+test("tui plugin module loads headless and self-describes", () => {
+    assert.ok(tui, "default export exists");
+    // @opencode/plugin's define() is a passthrough, so the raw shape is
+    // visible without a TUI host.
+    const anyTui = tui;
+    assert.equal(anyTui.id, "load-lock.tui");
+});
+test("dashboard opens in-window: PANEL_PRESENTATION is \"panel\"", () => {
+    // PanelPresentation is exactly "panel" | "fullscreen"; "panel" is the
+    // in-window presentation (issue #24 requirement 1).
+    assert.equal(PANEL_PRESENTATION, "panel");
+});
+// ------------------------------------------------------------ poolGlance
+test("poolGlance reports bits and health per pool state", () => {
+    const healthy = poolGlance(view([poolView({ used: 1, capacity: 3 })]));
+    assert.deepEqual(healthy, { bits: ["1/3"], health: "good" });
+    const full = poolGlance(view([poolView({ used: 3, capacity: 3, free: 0, utilization: 1 })]));
+    assert.deepEqual(full, { bits: ["3/3"], health: "warn" });
+    const queued = poolGlance(view([poolView({ used: 1, capacity: 3, queue: [{}, {}] })]));
+    assert.deepEqual(queued, { bits: ["1/3", "Q2"], health: "warn" });
+    const paused = poolGlance(view([poolView({ used: 1, capacity: 3, paused: [{}] })]));
+    // paused shows in bits but does not degrade health on its own
+    assert.deepEqual(paused, { bits: ["1/3", "P1"], health: "good" });
+    const down = poolGlance(view([poolView({ used: 1, capacity: 3 })], "reconnecting"));
+    assert.deepEqual(down, { bits: ["1/3"], health: "down" });
+});
+test("poolGlance prefers the heavy pool and tolerates missing pools", () => {
+    const heavy = poolGlance(view([
+        poolView({ pool: "gpu-heavy", used: 1, capacity: 1 }),
+        poolView({ pool: "heavy", used: 0, capacity: 3, free: 3, utilization: 0 }),
+    ]));
+    assert.deepEqual(heavy, { bits: ["0/3"], health: "good" });
+    // custom configs: falls back to the first pool when no "heavy" exists
+    const fallback = poolGlance(view([poolView({ pool: "build", used: 2, capacity: 2, free: 0, utilization: 1 })]));
+    assert.deepEqual(fallback, { bits: ["2/2"], health: "warn" });
+    assert.equal(poolGlance(view([])), null);
+});

package/dist/test/wait-turn.test.d.ts

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