@staff0rd/assist 0.318.8 → 0.319.0

package/README.md

@@ -266,6 +266,7 @@ The first backlog command in a repository that still has a local `.assist/backlo
 - `assist daemon status` - Show sessions daemon status, live sessions, and any stray daemon processes or stolen socket
 - `assist daemon stop` - Stop the sessions daemon; running claude sessions resume on next start
 - `assist daemon restart` - Restart the sessions daemon, resuming previously running claude sessions
+- `assist daemon drain` - Remove all sessions from the local daemon for a clean slate (does not affect the Windows daemon)
 
 Web sessions are owned by a long-lived daemon process, not the web server: the server is a thin client that relays WebSocket traffic to the daemon over a local IPC socket (unix domain socket at `~/.assist/daemon/daemon.sock`; named pipe `\\.\pipe\assist-sessions-daemon` on Windows). Restarting the web server leaves sessions running with scrollback intact. The daemon logs to `~/.assist/daemon/daemon.log` (timestamped lines tagged with the daemon's pid, including why it spawned and which sessions it restored) and auto-exits once no sessions remain and no client has been connected for 60 seconds (it is respawned on demand by the web server). Daemon spawning is arbitrated by an `O_EXCL` lockfile so racing clients start at most one daemon; sessions are only restored after the daemon owns the IPC socket, and a daemon that loses ownership of `daemon.pid` shuts down its sessions and exits rather than running orphaned.
 

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.318.8",
+  version: "0.319.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -19934,6 +19934,94 @@ function reportStrays(pids) {
   );
 }
 
+// src/commands/sessions/daemon/drainDaemon.ts
+import { createInterface as createInterface5 } from "readline";
+
+// src/commands/sessions/daemon/loadPersistedSessions.ts
+import { z as z5 } 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(),
+  runningMs: z5.number().optional(),
+  claudeSessionId: z5.string().optional(),
+  runName: z5.string().optional(),
+  runArgs: z5.array(z5.string()).optional(),
+  assistArgs: z5.array(z5.string()).optional(),
+  activity: activitySchema.optional()
+});
+function loadPersistedSessions() {
+  const data = loadJson(SESSIONS_FILE);
+  if (!Array.isArray(data)) return [];
+  return data.flatMap((entry) => {
+    const parsed = persistedSessionSchema.safeParse(entry);
+    return parsed.success ? [parsed.data] : [];
+  });
+}
+function savePersistedSessions(sessions) {
+  saveJson(SESSIONS_FILE, sessions);
+}
+function persistLiveSessions(sessions) {
+  savePersistedSessions(
+    [...sessions.values()].filter((s) => s.pty && s.status !== "done").map(toPersistedSession)
+  );
+}
+function toPersistedSession(session) {
+  return {
+    name: session.name,
+    commandType: session.commandType,
+    cwd: session.cwd ?? process.cwd(),
+    startedAt: session.startedAt,
+    runningMs: accumulatedRunningMs(session),
+    claudeSessionId: session.claudeSessionId,
+    runName: session.runName,
+    runArgs: session.runArgs,
+    assistArgs: session.assistArgs,
+    activity: session.activity
+  };
+}
+function accumulatedRunningMs(session) {
+  return session.runningSince != null ? session.runningMs + Date.now() - session.runningSince : session.runningMs;
+}
+
+// src/commands/sessions/daemon/drainDaemon.ts
+var DRAIN_TIMEOUT_MS = 5e3;
+async function drainDaemon() {
+  let socket;
+  try {
+    socket = await connectToDaemon();
+  } catch {
+    savePersistedSessions([]);
+    console.log("Sessions daemon is not running; cleared persisted sessions");
+    return;
+  }
+  const count6 = await requestDrain(socket);
+  socket.destroy();
+  console.log(`Drained ${count6} session(s)`);
+}
+function requestDrain(socket) {
+  socket.write(`${JSON.stringify({ type: "drain" })}
+`);
+  return new Promise((resolve17) => {
+    const timer = setTimeout(() => resolve17(0), DRAIN_TIMEOUT_MS);
+    const lines = createInterface5({ input: socket });
+    lines.on("error", () => {
+    });
+    lines.on("line", (line) => {
+      try {
+        const data = JSON.parse(line);
+        if (data.type === "drained") {
+          clearTimeout(timer);
+          resolve17(data.count ?? 0);
+        }
+      } catch {
+      }
+    });
+  });
+}
+
 // src/commands/sessions/daemon/runDaemon.ts
 import { mkdirSync as mkdirSync23 } from "fs";
 
@@ -19957,9 +20045,9 @@ function daemonLog(message) {
 }
 
 // src/commands/sessions/daemon/loadActiveSelection.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 var ACTIVE_FILE = "active.json";
-var activeSelectionSchema = z5.record(z5.string(), z5.string());
+var activeSelectionSchema = z6.record(z6.string(), z6.string());
 function loadActiveSelection() {
   const parsed = activeSelectionSchema.safeParse(
     loadJson(ACTIVE_FILE)
@@ -20005,55 +20093,6 @@ function broadcast(clients, msg) {
   }
 }
 
-// src/commands/sessions/daemon/loadPersistedSessions.ts
-import { z as z6 } from "zod";
-var SESSIONS_FILE = "sessions.json";
-var persistedSessionSchema = z6.object({
-  name: z6.string(),
-  commandType: z6.enum(["claude", "run", "assist"]),
-  cwd: z6.string(),
-  startedAt: z6.number(),
-  runningMs: z6.number().optional(),
-  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() {
-  const data = loadJson(SESSIONS_FILE);
-  if (!Array.isArray(data)) return [];
-  return data.flatMap((entry) => {
-    const parsed = persistedSessionSchema.safeParse(entry);
-    return parsed.success ? [parsed.data] : [];
-  });
-}
-function savePersistedSessions(sessions) {
-  saveJson(SESSIONS_FILE, sessions);
-}
-function persistLiveSessions(sessions) {
-  savePersistedSessions(
-    [...sessions.values()].filter((s) => s.pty && s.status !== "done").map(toPersistedSession)
-  );
-}
-function toPersistedSession(session) {
-  return {
-    name: session.name,
-    commandType: session.commandType,
-    cwd: session.cwd ?? process.cwd(),
-    startedAt: session.startedAt,
-    runningMs: accumulatedRunningMs(session),
-    claudeSessionId: session.claudeSessionId,
-    runName: session.runName,
-    runArgs: session.runArgs,
-    assistArgs: session.assistArgs,
-    activity: session.activity
-  };
-}
-function accumulatedRunningMs(session) {
-  return session.runningSince != null ? session.runningMs + Date.now() - session.runningSince : session.runningMs;
-}
-
 // src/commands/sessions/daemon/toSessionInfo.ts
 function toSessionInfo({
   id: id2,
@@ -20481,7 +20520,10 @@ function restoreOne(persisted, spawn12, sessions) {
     logUnresumable(persisted.name, id2, sessions.get(id2));
   } catch (error) {
     const reason = logRestoreError(persisted.name, error);
-    spawn12((id2) => errorSession(id2, persisted, reason));
+    try {
+      spawn12((id2) => errorSession(id2, persisted, reason));
+    } catch {
+    }
   }
 }
 function logUnresumable(name, id2, session) {
@@ -20496,11 +20538,35 @@ function logRestoreError(name, error) {
   return reason;
 }
 
+// src/commands/sessions/daemon/sessionLimits.ts
+var MAX_LIVE = 12;
+var MAX_RESTORE = 10;
+var sessionLimits = {
+  maxRestore: MAX_RESTORE,
+  /** Allocate the next session id from counter, refusing past the absolute
+   * ceiling regardless of caller (restore, web create, retry) so no trigger
+   * can fan out without bound. The counter advances only when allowed. */
+  nextId(liveCount, counter) {
+    if (liveCount >= MAX_LIVE) {
+      daemonLog(`refusing to spawn: at ceiling of ${MAX_LIVE} live sessions`);
+      throw new Error(`session ceiling of ${MAX_LIVE} reached`);
+    }
+    return String(counter.next++);
+  }
+};
+
 // src/commands/sessions/daemon/restoreAll.ts
 function restoreAll(spawn12, sessions) {
-  return loadPersistedSessions().map((persisted) => {
-    restoreOne(persisted, spawn12, sessions);
-    return persisted.name;
+  const persisted = loadPersistedSessions();
+  const toRestore = persisted.slice(0, sessionLimits.maxRestore);
+  const skipped = persisted.length - toRestore.length;
+  if (skipped > 0)
+    daemonLog(
+      `restore capped at ${sessionLimits.maxRestore}; skipping ${skipped} persisted session(s)`
+    );
+  return toRestore.map((persisted2) => {
+    restoreOne(persisted2, spawn12, sessions);
+    return persisted2.name;
   });
 }
 
@@ -20690,10 +20756,10 @@ async function isWindowsDaemonRunning() {
 import { spawn as spawn10 } from "child_process";
 
 // src/commands/sessions/daemon/logChildStream.ts
-import { createInterface as createInterface5 } from "readline";
+import { createInterface as createInterface6 } from "readline";
 function logChildStream(stream, label2) {
   if (!stream) return;
-  const lines = createInterface5({ input: stream });
+  const lines = createInterface6({ input: stream });
   lines.on("line", (line) => daemonLog(`[${label2}] ${line}`));
   lines.on("error", () => {
   });
@@ -20965,7 +21031,7 @@ function isWindowsIo(data) {
 }
 
 // src/commands/sessions/daemon/WindowsConnection.ts
-import { createInterface as createInterface6 } from "readline";
+import { createInterface as createInterface7 } from "readline";
 
 // src/commands/sessions/daemon/LaunchCircuitBreaker.ts
 var MAX_FAILURES = 3;
@@ -21045,7 +21111,7 @@ var WindowsConnection = class {
     return socket;
   }
   wire(socket) {
-    const lines = createInterface6({ input: socket });
+    const lines = createInterface7({ input: socket });
     lines.on("error", () => {
     });
     lines.on("line", (line) => this.deps.onLine(line));
@@ -21223,6 +21289,12 @@ function dismissSession(sessions, id2) {
   sessions.delete(id2);
   return true;
 }
+function drainSessions(sessions, onDrained) {
+  const ids = [...sessions.keys()];
+  for (const id2 of ids) dismissSession(sessions, id2);
+  onDrained();
+  return ids.length;
+}
 
 // src/commands/sessions/daemon/SessionManager.ts
 var SessionManager = class {
@@ -21233,7 +21305,7 @@ var SessionManager = class {
   // why: dispatch calls active.set() on card click; broadcasts include active.toJSON()
   active = new ActiveSelection(() => this.notify());
   clients = new ClientHub(persistUsagePeak);
-  nextId = 1;
+  idCounter = { next: 1 };
   shuttingDown = false;
   // why: dispatch calls windowsProxy.route() to forward windows-origin sessions
   windowsProxy = new WindowsProxy(this.clients, () => this.notify());
@@ -21254,12 +21326,13 @@ var SessionManager = class {
   restore() {
     return restoreAll(this.spawnWith, this.sessions);
   }
+  drain = () => drainSessions(this.sessions, this.notify);
   add(session) {
     this.wire(session);
     watchActivity(session, this.notify);
     return session.id;
   }
-  spawnWith = (create) => this.add(create(String(this.nextId++)));
+  spawnWith = (create) => this.add(create(sessionLimits.nextId(this.sessions.size, this.idCounter)));
   spawn(prompt, cwd) {
     return this.spawnWith((id2) => createSession(id2, prompt, cwd));
   }
@@ -21322,7 +21395,7 @@ import { unlinkSync as unlinkSync19 } from "fs";
 import * as net3 from "net";
 
 // src/commands/sessions/daemon/handleConnection.ts
-import { createInterface as createInterface7 } from "readline";
+import { createInterface as createInterface8 } from "readline";
 
 // src/commands/sessions/shared/discoverSessions.ts
 import * as fs30 from "fs";
@@ -21662,6 +21735,7 @@ var messageHandlers = {
   history: handleHistory,
   "fetch-transcript": handleFetchTranscript,
   shutdown: handleShutdown,
+  drain: (client, m) => sendTo(client, { type: "drained", count: m.drain() }),
   limits: (_client, m, d) => m.clients.updateLimits(d.rateLimits),
   input: routed(
     (_client, m, d) => m.writeToSession(d.sessionId, d.data)
@@ -21698,7 +21772,7 @@ function handleConnection(socket, manager) {
   };
   manager.addClient(client);
   manager.clients.greet(client);
-  const lines = createInterface7({ input: socket });
+  const lines = createInterface8({ input: socket });
   lines.on("error", () => {
   });
   lines.on("line", (line) => {
@@ -21852,6 +21926,9 @@ function registerDaemon(program2) {
   cmd.command("restart").description(
     "Restart the sessions daemon, resuming previously running claude sessions"
   ).action(restartDaemon);
+  cmd.command("drain").description(
+    "Remove all sessions from the local daemon for a clean slate (does not affect the Windows daemon)"
+  ).action(drainDaemon);
 }
 
 // src/commands/sessions/summarise/index.ts

package/package.json

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