@cueloop/daemon 0.1.0-alpha.82 → 0.1.0-alpha.83

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cueloop/daemon",
-  "version": "0.1.0-alpha.82",
+  "version": "0.1.0-alpha.83",
   "description": "The cueloop session daemon and its client: socket protocol, atomic store, resumable waits",
   "homepage": "https://github.com/mmurakaru/cueloop#readme",
   "bugs": {
@@ -38,7 +38,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@cueloop/schema": "0.1.0-alpha.82",
+    "@cueloop/schema": "0.1.0-alpha.83",
     "@pierre/diffs": "^1.4.1",
     "effect": "^4.0.0-rc.115",
     "smol-toml": "^1.8.0",

package/src/client.ts

@@ -77,7 +77,7 @@ type PendingRequest = {
 
 const EmptyResultSchema = v.object({});
 // version is optional: a daemon from before the handshake carried one reads as
-// undefined, which never equals this build - so it is treated as stale and replaced
+// undefined, which never equals this build.
 const PingResultSchema = v.object({ pid: v.number(), version: v.optional(v.string()) });
 const RefreshDiffResultSchema = v.object({ changed: v.boolean() });
 const HerdrThreadSurfaceResultSchema = v.nullable(
@@ -180,6 +180,7 @@ export interface ThreadClient {
 /** What a connection says about itself: its role, the owner token when it claims ownership, the author it acts as otherwise. */
 interface HelloParams {
   role: DaemonRole;
+  clientVersion: string;
   token?: string;
   author?: string;
 }
@@ -209,9 +210,8 @@ export class DaemonClient implements ThreadClient {
   private writer: BackpressureWriter | null = null;
   private connectionEpoch = 0;
   private pending = new Map<number, PendingRequest>();
-  /** The connected daemon's build version and pid, learned from the ping handshake. */
+  /** The connected daemon's build version, learned from the ping handshake. */
   private daemonVersion: string | undefined;
-  private daemonPid: number | undefined;
   private nextId = 1;
   private eventListeners = new Set<(event: EventFrame) => void>();
   private disconnectListeners = new Set<() => void>();
@@ -230,52 +230,25 @@ export class DaemonClient implements ThreadClient {
     client.home = home;
     try {
       await client.dial(path);
-      // A daemon from an earlier build lingers after an upgrade; talking to it
-      // means new client, old behaviour. The owner replaces it so an upgrade
-      // never needs a manual restart; without autostart there is nothing to
-      // replace it with, so the caller hears exactly why.
       if (client.daemonVersion === DAEMON_VERSION) return client;
-      if (!options.autostart) {
-        client.close();
-        throw new DaemonClientError(
-          "version_mismatch",
-          `daemon is version ${client.daemonVersion ?? "unknown"}, but this client is ${DAEMON_VERSION}; restart the daemon`,
-        );
-      }
-      await client.stopStaleDaemon(path);
-    } catch (err) {
-      // a live daemon that refused the handshake is not a dead socket: the
-      // caller hears why instead of the client replacing a running daemon
-      if (!options.autostart || err instanceof DaemonClientError) throw err;
-    }
-    // Socket dead, absent, or just-replaced: let the new daemon own socket cleanup.
-    return client.attachFreshDaemon(home, path);
-  }
+      const daemonVersion = client.daemonVersion ?? "unknown";
 
-  /**
-   * Tear down a daemon from an earlier build so a fresh one can bind: ask it to
-   * shut down (owner-gated) or, failing that, signal its pid, then wait for it to
-   * release the socket. Best-effort - the next daemon reclaims stale socket
-   * and lock files after it takes ownership.
-   */
-  private async stopStaleDaemon(path: string): Promise<void> {
-    const pid = this.daemonPid;
+      client.close();
+      throw new DaemonClientError(
+        "version_mismatch",
+        `daemon is version ${daemonVersion}, but this client is ${DAEMON_VERSION}; align cueloop versions before restarting the daemon`,
+      );
+    } catch (err) {
+      // Autostart repairs an unavailable socket, never a live incompatible daemon.
+      if (!options.autostart || err instanceof DaemonClientError) {
+        client.close();
 
-    try {
-      await this.request("daemon.shutdown", {}, EmptyResultSchema, 2_000);
-    } catch {
-      if (pid !== undefined) {
-        try {
-          process.kill(pid);
-        } catch {}
+        throw err;
       }
     }
-    this.socket?.end();
-    this.resetConnection();
-    // the old daemon removes its socket in stop(); wait so the new one binds cleanly
-    const deadline = Date.now() + 5_000;
 
-    while (Date.now() < deadline && existsSync(path)) await sleep(50);
+    // Socket dead or absent: let the new daemon own stale socket cleanup.
+    return client.attachFreshDaemon(home, path);
   }
 
   /** Reset per-connection state so a fresh dial() can reuse this client instance. */
@@ -383,11 +356,10 @@ export class DaemonClient implements ThreadClient {
     }
     // Verify liveness: a dead socket file accepts connects on some platforms
     // only to fail later, so a ping is the actual handshake. It also carries the
-    // daemon's build version and pid, so connect() can replace a stale daemon.
+    // daemon's build version, so connect() can reject incompatible clients.
     const pong = await this.request("daemon.ping", {}, PingResultSchema, 2_000);
 
     this.daemonVersion = pong.version;
-    this.daemonPid = pong.pid;
     // Every connection starts as a collaborator; the owner proves itself with
     // the token the daemon wrote into the home it serves, which only the home's
     // user can read. A capped role just names itself.
@@ -397,13 +369,15 @@ export class DaemonClient implements ThreadClient {
   private helloParams(): HelloParams {
     if (this.role !== "owner") {
       return this.author === undefined
-        ? { role: this.role }
-        : { role: this.role, author: this.author };
+        ? { role: this.role, clientVersion: DAEMON_VERSION }
+        : { role: this.role, clientVersion: DAEMON_VERSION, author: this.author };
     }
     const token = readOwnerToken(this.home);
 
     // a daemon from before owner tokens has no file; it still knows the bare hello
-    return token === undefined ? { role: "owner" } : { role: "owner", token };
+    return token === undefined
+      ? { role: "owner", clientVersion: DAEMON_VERSION }
+      : { role: "owner", clientVersion: DAEMON_VERSION, token };
   }
 
   onEvent(listener: (event: EventFrame) => void): () => void {

package/src/daemon-version.test.ts

@@ -6,12 +6,13 @@
  */
 
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { mkdtempSync, rmSync } from "node:fs";
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { DaemonServer } from "./server";
 import { DaemonClient, DaemonClientError, daemonSpawnCommand } from "./client";
 import { DAEMON_VERSION } from "./version";
+import { pidPath } from "./paths";
 import type { Artifact, WorkspaceKey } from "@cueloop/schema";
 
 const WS: WorkspaceKey = { repoRoot: "/repo", branch: "main" };
@@ -29,7 +30,12 @@ afterEach(() => {
 });
 
 function server(version?: string): DaemonServer {
-  const daemonServer = new DaemonServer({ home, idleExitMs: 0, version });
+  const daemonServer = new DaemonServer({
+    home,
+    idleExitMs: 0,
+    version,
+    onIdleExit: () => {},
+  });
 
   servers.push(daemonServer);
 
@@ -50,6 +56,49 @@ describe("daemon version handshake", () => {
     );
   });
 
+  test("autostart never replaces a live daemon from another version", async () => {
+    const liveServer = server("0.1.0-alpha.81");
+
+    liveServer.start();
+    const session = liveServer.core.sessionCreate({ workspace: WS, artifact: PLAN });
+    let replacement: DaemonClient | undefined;
+    let connectionError: unknown;
+
+    try {
+      replacement = await DaemonClient.connect({ home, autostart: true });
+    } catch (error) {
+      connectionError = error;
+    }
+
+    replacement?.close();
+    expect(connectionError).toBeInstanceOf(DaemonClientError);
+    expect(connectionError).toMatchObject({ code: "version_mismatch" });
+    expect(readFileSync(pidPath(home), "utf8")).toBe(String(process.pid));
+    expect(liveServer.core.sessionGet(session.id).id).toBe(session.id);
+  });
+
+  test("a rejected client releases its connection so the daemon can become idle", async () => {
+    let idleExited = false;
+    const liveServer = new DaemonServer({
+      home,
+      idleExitMs: 50,
+      version: "0.1.0-alpha.81",
+      onIdleExit: () => {
+        idleExited = true;
+      },
+    });
+
+    servers.push(liveServer);
+    liveServer.start();
+
+    await expect(DaemonClient.connect({ home, autostart: true })).rejects.toMatchObject({
+      code: "version_mismatch",
+    });
+    await Bun.sleep(100);
+
+    expect(idleExited).toBe(true);
+  });
+
   test("a current daemon connects and serves normally", async () => {
     // Arrange - a daemon on this build
     server(DAEMON_VERSION).start();

package/src/server.test.ts

@@ -5,6 +5,7 @@ import { join } from "node:path";
 import * as v from "valibot";
 import { DaemonServer } from "./server";
 import { DaemonClient, DaemonClientError } from "./client";
+import { DAEMON_VERSION } from "./version";
 import type { Artifact, WorkspaceKey } from "@cueloop/schema";
 
 const WS: WorkspaceKey = { repoRoot: "/repo", branch: "main" };
@@ -413,7 +414,15 @@ describe("ownership is proven, never declared", () => {
     // Act: the token the daemon wrote into its home
     const token = readFileSync(join(home, "owner.token"), "utf8").trim();
 
-    expect((await raw.call("daemon.hello", { role: "owner", token })).error).toBeUndefined();
+    expect(
+      (
+        await raw.call("daemon.hello", {
+          role: "owner",
+          token,
+          clientVersion: DAEMON_VERSION,
+        })
+      ).error,
+    ).toBeUndefined();
 
     // Assert: owner primitives open up
     const created = await raw.call("session.create", { workspace: WS, artifact: PLAN });
@@ -422,6 +431,18 @@ describe("ownership is proven, never declared", () => {
     raw.close();
   });
 
+  test("an older owner cannot shut down a newer daemon", async () => {
+    const raw = await rawConnection();
+    const token = readFileSync(join(home, "owner.token"), "utf8").trim();
+
+    expect((await raw.call("daemon.hello", { role: "owner", token })).error?.code).toBe(
+      "version_mismatch",
+    );
+    expect((await raw.call("daemon.shutdown", {})).error?.code).toBe("forbidden");
+    expect((await raw.call("daemon.ping", {})).error).toBeUndefined();
+    raw.close();
+  });
+
   test("a refused handshake reaches the caller and leaves the live daemon's socket alone", async () => {
     // Arrange: a token file that is not what the daemon minted
     const tokenPath = join(home, "owner.token");

package/src/server.ts

@@ -297,6 +297,13 @@ export class DaemonServer {
       if (params.role === "owner" && params.token !== this.ownerToken) {
         throw new DaemonError("forbidden", "owner token required");
       }
+      if (params.clientVersion !== this.version) {
+        throw new DaemonError(
+          "version_mismatch",
+          `daemon is version ${this.version}, but this client is ${params.clientVersion ?? "unknown"}; align cueloop versions before restarting the daemon`,
+        );
+      }
+
       connection.role = params.role;
       // identity is bound once, here; a non-owner never names it per call
       if (params.role !== "owner" && params.author !== undefined) connection.author = params.author;

package/src/validate.ts

@@ -282,6 +282,7 @@ export const Params = {
   // the owner token proves ownership; without it a request for owner stays a collaborator
   "daemon.hello": v.object({
     role: v.picklist(["owner", "collaborator", "agent"]),
+    clientVersion: v.optional(v.string()),
     token: v.optional(v.string()),
     // the author a non-owner acts as, bound once for the connection
     author: v.optional(NonEmpty),