@melaya/runner 1.0.103 → 1.0.104

package/dist/connection.js

@@ -14,7 +14,7 @@ import { io } from "socket.io-client";
 import chalk from "chalk";
 import ora from "ora";
 import { spawn } from "child_process";
-import { writeFileSync, mkdirSync, existsSync } from "fs";
+import { writeFileSync, mkdirSync, existsSync, readFileSync } from "fs";
 import { dirname, join } from "path";
 import { fileURLToPath } from "url";
 import { tmpdir, homedir } from "os";
@@ -28,6 +28,19 @@ import { ensureSharedModules, getSharedDir } from "./sharedVendor.js";
 import { startLumaBrowserBridge } from "./lumaBrowserBridge.js";
 const HEARTBEAT_INTERVAL = 30_000;
 const activeProcesses = new Map();
+// PR4/P1-5: the assistant-session wire protocol version. Bumped whenever the
+// handshake contract changes (this rev adds hostInstanceId + configHash + a
+// versioned ready/hello). The server enforces a MINIMUM: a runner advertising a
+// lower protocol never gets an assistant session routed to it (it gets a clear
+// "update your runner" instead of a silent stale-memory turn).
+const ASSISTANT_PROTOCOL_VERSION = 2;
+// Best-effort read of our own package version (mirrors cli.ts). Advertised in the
+// hello so the server can log / gate on a package floor too.
+let RUNNER_VERSION = "0.0.0";
+try {
+    RUNNER_VERSION = String(JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf-8")).version || "0.0.0");
+}
+catch { /* dev tree layout differs — non-fatal */ }
 const activeAssistants = new Map();
 // PR4: sid-keyed boot reservation. The guard-then-spawn in runner:assistant_start
 // has an async gap (ensureSharedModules / ensurePythonEnv awaits) between the
@@ -133,7 +146,7 @@ export async function connect(opts) {
         // Advertise capabilities so the server only routes assistant chat sessions
         // to runners new enough to host them (older runners never get one → the
         // server falls back with a clear "update your runner" instead of hanging).
-        socket.emit("runner:hello", { capabilities: ["assistant_session"], package: "@melaya/runner" });
+        socket.emit("runner:hello", { capabilities: ["assistant_session"], package: "@melaya/runner", version: RUNNER_VERSION, assistantProtocol: ASSISTANT_PROTOCOL_VERSION });
         // Start local event relay
         if (!relay) {
             relay = await startLocalRelay(socket, opts.verbose, opts.serverUrl);
@@ -894,7 +907,7 @@ export async function connect(opts) {
         // that booted under an older generation and reboot it instead of serving the
         // next turn from stale memory/config. A bare ready hid this.
         if (live) {
-            emitEv({ kind: "ready", memoryWatermark: live.memoryWatermark || 0, generation: live.generation });
+            emitEv({ kind: "ready", memoryWatermark: live.memoryWatermark || 0, generation: live.generation, hostInstanceId: live.hostInstanceId, configHash: live.configHash, protocol: ASSISTANT_PROTOCOL_VERSION });
             return;
         }
         // A boot is already in flight for this sid (concurrent start / server restart
@@ -993,7 +1006,10 @@ export async function connect(opts) {
                 ...(payload.credentials || {}),
             };
             const proc = spawn(envResult.pythonPath, ["-u", stagedHost], { cwd: workDir, env, stdio: ["pipe", "pipe", "pipe"] });
-            const session = { proc, lastActivity: Date.now(), stdoutBuf: "", generation, memoryWatermark: 0 };
+            // hostInstanceId + configHash are filled from the host's OWN `ready` frame
+            // (assistantHost.py _HOST_ID / _config_hash) as it boots — authoritative and
+            // server-aligned. Start empty; the stdout parser captures them.
+            const session = { proc, lastActivity: Date.now(), stdoutBuf: "", generation, memoryWatermark: 0, hostInstanceId: "", configHash: "" };
             activeAssistants.set(sid, session);
             console.log(chalk.hex("#7c6ff0")(`  ◆ Assistant session ${sid.slice(0, 10)}… (${payload.provider})`));
             proc.stdout?.on("data", (data) => {
@@ -1011,6 +1027,16 @@ export async function connect(opts) {
                             // truthful watermark and the server skips a needless rehydrate.
                             if (typeof parsed?.memoryWatermark === "number")
                                 session.memoryWatermark = parsed.memoryWatermark;
+                            // CAPTURE the host's authoritative identity off its `ready` frame
+                            // (_HOST_ID / _config_hash) so the live-host ready path can re-report
+                            // them without the host re-emitting; ADD only the wire protocol.
+                            if (parsed?.kind === "ready") {
+                                if (typeof parsed.hostInstanceId === "string")
+                                    session.hostInstanceId = parsed.hostInstanceId;
+                                if (typeof parsed.configHash === "string")
+                                    session.configHash = parsed.configHash;
+                                parsed.protocol = ASSISTANT_PROTOCOL_VERSION;
+                            }
                             socket.emit("runner:assistant_event", { sessionId: sid, ...parsed });
                         }
                         catch { /* skip malformed */ }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@melaya/runner",
-  "version": "1.0.103",
+  "version": "1.0.104",
   "description": "Run Melaya AI pipelines locally with your own LM Studio or Ollama models",
   "license": "UNLICENSED",
   "private": false,