@staff0rd/assist 0.287.0 → 0.288.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.287.0",
+  version: "0.288.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -18570,6 +18570,33 @@ function shutdownSessions(sessions) {
   }
 }
 
+// src/commands/sessions/daemon/autoHealWindowsDaemon.ts
+async function autoHealWindowsDaemon(conn, state, heal, version2) {
+  daemonLog(`windows proxy: auto-healing windows daemon (mismatch ${version2})`);
+  notifyHealing(state);
+  try {
+    conn.dispose();
+    await heal();
+    daemonLog("windows proxy: heal complete, reconnecting to windows daemon");
+    await conn.ensure();
+  } catch (e) {
+    const message = e instanceof Error ? e.message : String(e);
+    daemonLog(`windows proxy: auto-heal failed: ${message}`);
+    state.broadcast({
+      type: "error",
+      message: `Windows host auto-update failed: ${message}`
+    });
+  }
+}
+function notifyHealing(state) {
+  for (const client of state.pendingCreators)
+    sendTo(client, {
+      type: "error",
+      message: "Windows host is out of date; updating it now \u2014 reselect the repo once the update finishes."
+    });
+  state.pendingCreators = [];
+}
+
 // src/commands/sessions/daemon/connectToWindowsDaemon.ts
 import * as net2 from "net";
 
@@ -18600,18 +18627,6 @@ async function isWindowsDaemonRunning() {
   }
 }
 
-// src/commands/sessions/daemon/discoverWindowsSessions.ts
-async function discoverWindowsSessions(conn) {
-  if (conn.connected || !await isWindowsDaemonRunning()) return;
-  daemonLog("windows proxy: discovering sessions on running windows daemon");
-  try {
-    await conn.ensure();
-  } catch (e) {
-    const message = e instanceof Error ? e.message : String(e);
-    daemonLog(`windows proxy: discovery failed: ${message}`);
-  }
-}
-
 // src/commands/sessions/daemon/ensureWindowsDaemonRunning.ts
 import { spawn as spawn10 } from "child_process";
 var SPAWN_TIMEOUT_MS2 = 3e4;
@@ -18661,6 +18676,24 @@ function delay2(ms) {
   return new Promise((resolve16) => setTimeout(resolve16, ms));
 }
 
+// src/commands/sessions/daemon/defaultConnect.ts
+async function defaultConnect() {
+  await ensureWindowsDaemonRunning();
+  return connectToWindowsDaemon();
+}
+
+// src/commands/sessions/daemon/discoverWindowsSessions.ts
+async function discoverWindowsSessions(conn) {
+  if (conn.connected || !await isWindowsDaemonRunning()) return;
+  daemonLog("windows proxy: discovering sessions on running windows daemon");
+  try {
+    await conn.ensure();
+  } catch (e) {
+    const message = e instanceof Error ? e.message : String(e);
+    daemonLog(`windows proxy: discovery failed: ${message}`);
+  }
+}
+
 // src/commands/sessions/daemon/forwardWindowsCreate.ts
 async function forwardWindowsCreate(conn, state, client, data) {
   daemonLog(`windows proxy: routing ${data.type} (cwd=${data.cwd})`);
@@ -18693,13 +18726,14 @@ function versionsMatch(a, b) {
 
 // src/commands/sessions/daemon/WindowsProxyState.ts
 var MAX_SCROLLBACK2 = 256 * 1024;
-function createState(broadcast2, onSessionsChanged) {
+function createState(broadcast2, onSessionsChanged, onVersionMismatch) {
   return {
     windowsSessions: [],
     scrollback: /* @__PURE__ */ new Map(),
     pendingCreators: [],
     broadcast: broadcast2,
-    onSessionsChanged
+    onSessionsChanged,
+    onVersionMismatch
   };
 }
 function resetState(state) {
@@ -18730,7 +18764,7 @@ function handleInbound(state, line) {
   inbound[msg.type]?.(state, msg);
 }
 var inbound = {
-  hello: (_state, msg) => handleHello(msg),
+  hello: handleHello,
   created: handleCreated,
   sessions: handleSessions,
   output: handleOutput,
@@ -18740,11 +18774,13 @@ var inbound = {
     state.broadcast(msg);
   }
 };
-function handleHello(msg) {
-  if (isHello(msg) && !versionsMatch(msg.version, ASSIST_VERSION))
+function handleHello(state, msg) {
+  if (isHello(msg) && !versionsMatch(msg.version, ASSIST_VERSION)) {
     daemonLog(
       `windows daemon version mismatch: ${msg.version} (wsl ${ASSIST_VERSION})`
     );
+    state.onVersionMismatch(msg.version);
+  }
 }
 function handleCreated(state, msg) {
   daemonLog(`windows daemon: created session ${nsId(msg)}`);
@@ -18775,6 +18811,57 @@ function nsId(msg) {
   return toWindowsSessionId(msg.sessionId);
 }
 
+// src/commands/sessions/daemon/healWindowsDaemon.ts
+import { spawn as spawn11 } from "child_process";
+import { createInterface as createInterface5 } from "readline";
+var UPDATE_TIMEOUT_MS = 5 * 6e4;
+var STOP_TIMEOUT_MS2 = 3e4;
+async function healWindowsDaemon() {
+  daemonLog("windows daemon: auto-heal: running `assist update` on host");
+  await runOnWindowsHost("assist update", UPDATE_TIMEOUT_MS);
+  daemonLog("windows daemon: auto-heal: update done, stopping stale daemon");
+  await runOnWindowsHost("assist daemon stop", STOP_TIMEOUT_MS2);
+  daemonLog("windows daemon: auto-heal: stale daemon stopped");
+}
+function runOnWindowsHost(command, timeoutMs) {
+  return new Promise((resolve16, reject) => {
+    const child = spawn11("pwsh.exe", ["-Command", command], {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    logStream(child.stdout, command);
+    logStream(child.stderr, command);
+    const timer = setTimeout(() => {
+      child.kill();
+      reject(
+        new Error(
+          `'${command}' on the Windows host timed out after ${timeoutMs}ms`
+        )
+      );
+    }, timeoutMs);
+    child.on("error", (e) => {
+      clearTimeout(timer);
+      reject(e);
+    });
+    child.on("exit", (code) => {
+      clearTimeout(timer);
+      if (code === 0) resolve16();
+      else
+        reject(
+          new Error(
+            `'${command}' on the Windows host exited with code ${code}`
+          )
+        );
+    });
+  });
+}
+function logStream(stream, command) {
+  if (!stream) return;
+  const lines = createInterface5({ input: stream });
+  lines.on("line", (line) => daemonLog(`[windows ${command}] ${line}`));
+  lines.on("error", () => {
+  });
+}
+
 // src/commands/sessions/daemon/isWindowsCwd.ts
 function isWindowsCwd(cwd) {
   return /^[A-Za-z]:[\\/]/.test(cwd);
@@ -18783,8 +18870,16 @@ function shouldProxyToWindows(cwd) {
   return detectPlatform() === "wsl" && isWindowsCwd(cwd);
 }
 
+// src/commands/sessions/daemon/isWindowsCreate.ts
+function isWindowsCreate(data) {
+  return typeof data.cwd === "string" && shouldProxyToWindows(data.cwd);
+}
+function isWindowsIo(data) {
+  return typeof data.sessionId === "string" && isWindowsSessionId(data.sessionId);
+}
+
 // src/commands/sessions/daemon/WindowsConnection.ts
-import { createInterface as createInterface5 } from "readline";
+import { createInterface as createInterface6 } from "readline";
 var WindowsConnection = class {
   constructor(deps2) {
     this.deps = deps2;
@@ -18821,7 +18916,7 @@ var WindowsConnection = class {
     const socket = await this.deps.connect();
     daemonLog("windows connection: tcp connected, sending hello");
     this.socket = socket;
-    const lines = createInterface5({ input: socket });
+    const lines = createInterface6({ input: socket });
     lines.on("error", () => {
     });
     lines.on("line", (line) => this.deps.onLine(line));
@@ -18842,12 +18937,12 @@ var WindowsConnection = class {
 
 // src/commands/sessions/daemon/WindowsProxy.ts
 var WindowsProxy = class {
-  state;
-  conn;
-  constructor(clients, onSessionsChanged, connect3 = defaultConnect) {
+  constructor(clients, onSessionsChanged, connect3 = defaultConnect, heal = healWindowsDaemon) {
+    this.heal = heal;
     this.state = createState(
       (msg) => broadcast(clients, msg),
-      onSessionsChanged
+      onSessionsChanged,
+      (version2) => void this.handleVersionMismatch(version2)
     );
     this.conn = new WindowsConnection({
       connect: connect3,
@@ -18855,6 +18950,11 @@ var WindowsProxy = class {
       onClose: () => this.handleClose()
     });
   }
+  state;
+  conn;
+  // why: heal runs once per proxy lifetime; if WSL is the older side, updating Windows can't close the gap, so a repeat mismatch must not loop
+  healAttempted = false;
+  healing = false;
   sessions() {
     return this.state.windowsSessions;
   }
@@ -18868,7 +18968,7 @@ var WindowsProxy = class {
   // windows-origin cwd is forwarded, as is I/O for a namespaced session id.
   route(client, data) {
     if (isWindowsCreate(data)) {
-      void this.forwardCreate(client, data);
+      void forwardWindowsCreate(this.conn, this.state, client, data);
       return true;
     }
     if (isWindowsIo(data)) {
@@ -18881,8 +18981,15 @@ var WindowsProxy = class {
   dispose() {
     this.conn.dispose();
   }
-  async forwardCreate(client, data) {
-    await forwardWindowsCreate(this.conn, this.state, client, data);
+  async handleVersionMismatch(version2) {
+    if (this.healing || this.healAttempted) return;
+    this.healing = true;
+    this.healAttempted = true;
+    try {
+      await autoHealWindowsDaemon(this.conn, this.state, this.heal, version2);
+    } finally {
+      this.healing = false;
+    }
   }
   handleClose() {
     daemonLog("windows proxy: connection to windows daemon closed");
@@ -18895,16 +19002,6 @@ var WindowsProxy = class {
     this.state.onSessionsChanged();
   }
 };
-function isWindowsCreate(data) {
-  return typeof data.cwd === "string" && shouldProxyToWindows(data.cwd);
-}
-function isWindowsIo(data) {
-  return typeof data.sessionId === "string" && isWindowsSessionId(data.sessionId);
-}
-async function defaultConnect() {
-  await ensureWindowsDaemonRunning();
-  return connectToWindowsDaemon();
-}
 
 // src/commands/sessions/daemon/watchClaudeSessionId.ts
 import * as fs27 from "fs";
@@ -19300,7 +19397,7 @@ import { unlinkSync as unlinkSync19 } from "fs";
 import * as net3 from "net";
 
 // src/commands/sessions/daemon/handleConnection.ts
-import { createInterface as createInterface6 } from "readline";
+import { createInterface as createInterface7 } from "readline";
 
 // src/commands/sessions/shared/parseTranscript.ts
 import * as fs28 from "fs";
@@ -19394,10 +19491,10 @@ function safeParse2(line) {
 }
 
 // src/commands/sessions/daemon/dispatchMessage.ts
-function creator(spawn11) {
+function creator(spawn12) {
   return (client, m, d) => {
     if (m.windowsProxy.route(client, d)) return;
-    sendTo(client, { type: "created", sessionId: spawn11(m, d) });
+    sendTo(client, { type: "created", sessionId: spawn12(m, d) });
   };
 }
 function handleHistory(client) {
@@ -19478,7 +19575,7 @@ function handleConnection(socket, manager) {
     }
   };
   manager.addClient(client);
-  const lines = createInterface6({ input: socket });
+  const lines = createInterface7({ input: socket });
   lines.on("error", () => {
   });
   lines.on("line", (line) => {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@staff0rd/assist",
-	"version": "0.287.0",
+	"version": "0.288.0",
 	"type": "module",
 	"main": "dist/index.js",
 	"bin": {