@staff0rd/assist 0.297.4 → 0.298.1

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.297.4",
+  version: "0.298.1",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -18412,6 +18412,44 @@ function daemonLog(message) {
   console.log(`${(/* @__PURE__ */ new Date()).toISOString()} [${process.pid}] ${message}`);
 }
 
+// src/commands/sessions/daemon/loadActiveSelection.ts
+import { z as z5 } from "zod";
+var ACTIVE_FILE = "active.json";
+var activeSelectionSchema = z5.record(z5.string(), z5.string());
+function loadActiveSelection() {
+  const parsed = activeSelectionSchema.safeParse(
+    loadJson(ACTIVE_FILE)
+  );
+  return parsed.success ? parsed.data : {};
+}
+function saveActiveSelection(active) {
+  saveJson(ACTIVE_FILE, active);
+}
+
+// src/commands/sessions/daemon/ActiveSelection.ts
+var ActiveSelection = class {
+  // why: onChange triggers a broadcast only when the selection actually changes
+  constructor(onChange) {
+    this.onChange = onChange;
+  }
+  byRepo = /* @__PURE__ */ new Map();
+  set(cwd, sessionId) {
+    if (!cwd) return;
+    this.byRepo.delete(cwd);
+    this.byRepo.set(cwd, sessionId);
+    saveActiveSelection(this.toJSON());
+    this.onChange();
+  }
+  // why: on daemon restart, reload persisted selections but drop any whose session was not restored
+  restore(isLive) {
+    for (const [cwd, sessionId] of Object.entries(loadActiveSelection()))
+      if (isLive(sessionId)) this.byRepo.set(cwd, sessionId);
+  }
+  toJSON() {
+    return Object.fromEntries(this.byRepo);
+  }
+};
+
 // src/commands/sessions/daemon/broadcast.ts
 function sendTo(client, msg) {
   client.send(JSON.stringify(msg));
@@ -18424,17 +18462,17 @@ function broadcast(clients, msg) {
 }
 
 // src/commands/sessions/daemon/loadPersistedSessions.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 var SESSIONS_FILE = "sessions.json";
-var persistedSessionSchema = z5.object({
-  name: z5.string(),
-  commandType: z5.enum(["claude", "run", "assist"]),
-  cwd: z5.string(),
-  startedAt: z5.number(),
-  claudeSessionId: z5.string().optional(),
-  runName: z5.string().optional(),
-  runArgs: z5.array(z5.string()).optional(),
-  assistArgs: z5.array(z5.string()).optional(),
+var persistedSessionSchema = z6.object({
+  name: z6.string(),
+  commandType: z6.enum(["claude", "run", "assist"]),
+  cwd: z6.string(),
+  startedAt: z6.number(),
+  claudeSessionId: z6.string().optional(),
+  runName: z6.string().optional(),
+  runArgs: z6.array(z6.string()).optional(),
+  assistArgs: z6.array(z6.string()).optional(),
   activity: activitySchema.optional()
 });
 function loadPersistedSessions() {
@@ -18501,11 +18539,13 @@ function toSessionInfo({
 }
 
 // src/commands/sessions/daemon/broadcastSessions.ts
-function broadcastSessions(sessions, clients, windowsSessions = []) {
+function broadcastSessions(sessions, clients, windowsSessions = [], active) {
   persistLiveSessions(sessions);
+  const local = [...sessions.values()].map(toSessionInfo);
   broadcast(clients, {
     type: "sessions",
-    sessions: [...sessions.values()].map(toSessionInfo).concat(windowsSessions)
+    sessions: local.concat(windowsSessions),
+    active: active?.toJSON() ?? {}
   });
 }
 
@@ -18643,8 +18683,7 @@ function replayScrollback(sessions, client) {
 }
 
 // src/commands/sessions/daemon/greetClient.ts
-function greetClient(client, sessions, list4, windowsProxy) {
-  sendTo(client, { type: "sessions", sessions: list4() });
+function greetClient(client, sessions, windowsProxy) {
   replayScrollback(sessions, client);
   windowsProxy.replayScrollback(client);
   void windowsProxy.discover();
@@ -18887,33 +18926,6 @@ 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 (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    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";
 
@@ -19320,30 +19332,94 @@ var WindowsConnection = class {
   }
 };
 
+// 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 (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    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/WindowsVersionHealer.ts
+var UNRECOVERABLE_MESSAGE = "Windows host is on an incompatible version that auto-update could not resolve; not reconnecting. Update the Windows host manually, then restart.";
+var WindowsVersionHealer = class {
+  constructor(conn, state, heal) {
+    this.conn = conn;
+    this.state = state;
+    this.heal = heal;
+  }
+  healAttempted = false;
+  healing = false;
+  unrecoverable = false;
+  get blocked() {
+    return this.unrecoverable;
+  }
+  refusal() {
+    return { type: "error", message: UNRECOVERABLE_MESSAGE };
+  }
+  async onMismatch(version2) {
+    if (this.healing || this.unrecoverable) return;
+    if (this.healAttempted) return this.giveUp(version2);
+    this.healing = true;
+    this.healAttempted = true;
+    try {
+      await autoHealWindowsDaemon(this.conn, this.state, this.heal, version2);
+    } finally {
+      this.healing = false;
+    }
+  }
+  giveUp(version2) {
+    this.unrecoverable = true;
+    daemonLog(
+      `windows proxy: version mismatch ${version2} persists after heal; not reconnecting until the WSL daemon restarts`
+    );
+    this.conn.dispose();
+    this.state.broadcast(this.refusal());
+  }
+};
+
 // src/commands/sessions/daemon/WindowsProxy.ts
 var WindowsProxy = class {
+  state;
+  conn;
+  healer;
   constructor(clients, onSessionsChanged, connect3 = defaultConnect, heal = healWindowsDaemon) {
-    this.heal = heal;
     this.state = createState(
       (msg) => broadcast(clients, msg),
       onSessionsChanged,
-      (version2) => void this.handleVersionMismatch(version2)
+      (version2) => void this.healer.onMismatch(version2)
     );
     this.conn = new WindowsConnection({
       connect: connect3,
       onLine: (line) => handleInbound(this.state, line),
       onClose: () => this.handleClose()
     });
+    this.healer = new WindowsVersionHealer(this.conn, this.state, heal);
   }
-  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;
   }
   discover() {
+    if (this.healer.blocked) return Promise.resolve();
     return discoverWindowsSessions(this.conn);
   }
   replayScrollback(client) {
@@ -19353,7 +19429,8 @@ var WindowsProxy = class {
   // windows-origin cwd is forwarded, as is I/O for a namespaced session id.
   route(client, data) {
     if (isWindowsCreate(data)) {
-      void forwardWindowsCreate(this.conn, this.state, client, data);
+      if (this.healer.blocked) sendTo(client, this.healer.refusal());
+      else void forwardWindowsCreate(this.conn, this.state, client, data);
       return true;
     }
     if (isWindowsIo(data)) {
@@ -19366,16 +19443,6 @@ var WindowsProxy = class {
   dispose() {
     this.conn.dispose();
   }
-  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");
     for (const client of this.state.pendingCreators)
@@ -19688,6 +19755,8 @@ var SessionManager = class {
     this.onIdleChange = onIdleChange;
   }
   sessions = /* @__PURE__ */ new Map();
+  // why: dispatch calls active.set() on card click; broadcasts include active.toJSON()
+  active = new ActiveSelection(() => this.notify());
   clients = new ClientHub();
   nextId = 1;
   shuttingDown = false;
@@ -19695,16 +19764,14 @@ var SessionManager = class {
   windowsProxy = new WindowsProxy(this.clients, () => this.notify());
   addClient(client) {
     this.clients.add(client);
-    this.onIdleChange?.(this.isIdle());
-    greetClient(client, this.sessions, this.listSessions, this.windowsProxy);
+    this.notify();
+    greetClient(client, this.sessions, this.windowsProxy);
   }
   removeClient(client) {
     this.clients.delete(client);
     this.onIdleChange?.(this.isIdle());
   }
-  isIdle() {
-    return this.sessions.size === 0 && this.clients.size === 0;
-  }
+  isIdle = () => this.sessions.size === 0 && this.clients.size === 0;
   shutdown() {
     this.shuttingDown = true;
     shutdownSessions(this.sessions);
@@ -19772,7 +19839,7 @@ var SessionManager = class {
   notify = () => {
     if (this.shuttingDown) return;
     const windows = this.windowsProxy.sessions();
-    broadcastSessions(this.sessions, this.clients, windows);
+    broadcastSessions(this.sessions, this.clients, windows, this.active);
     this.onIdleChange?.(this.isIdle());
   };
 };
@@ -19950,7 +20017,8 @@ var handlers = {
   ),
   "set-autoadvance": routed(
     (_client, m, d) => m.setAutoAdvance(d.sessionId, d.enabled)
-  )
+  ),
+  "set-active": (_client, m, d) => m.active.set(d.cwd, d.sessionId)
 };
 function dispatchMessage(client, manager, data) {
   handlers[data.type]?.(client, manager, data);
@@ -20021,6 +20089,8 @@ function onListening(manager, checkAutoExit) {
   });
   process.on("exit", cleanupOwnedFiles);
   const restored = manager.restore();
+  const liveIds = new Set(manager.listSessions().map((s) => s.id));
+  manager.active.restore((id2) => liveIds.has(id2));
   daemonLog(
     restored.length > 0 ? `restored ${restored.length} session(s): ${restored.join(", ")}` : "no persisted sessions to restore"
   );

package/package.json

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