stashes 0.1.8 → 0.1.9

package/dist/mcp.js

@@ -35,6 +35,10 @@ var STASHES_PORT = 4000;
 var DEFAULT_STASH_COUNT = 3;
 var APP_PROXY_PORT = STASHES_PORT + 1;
 var STASH_PORT_START = 4010;
+var STASH_PORT_END = 4030;
+var MAX_PREVIEW_SERVERS = 5;
+var PREVIEW_TTL_MS = 300000;
+var PREVIEW_REAPER_INTERVAL = 30000;
 var DEFAULT_DIRECTIVES = [
   "Minimal and clean \u2014 reduce visual noise, emphasize whitespace, limit to 2-3 colors, typography-driven hierarchy",
   "Bold and expressive \u2014 strong visual identity, use motion/animation, rich interactions, distinctive layout",
@@ -232,6 +236,34 @@ class WorktreeManager {
   getPreviewPort() {
     return PREVIEW_PORT;
   }
+  async createPreviewForPool(stashId) {
+    const previewPath = join2(this.projectPath, ".stashes", "previews", stashId);
+    const branch = `stashes/${stashId}`;
+    if (existsSync2(previewPath)) {
+      try {
+        await this.git.raw(["worktree", "remove", "--force", previewPath]);
+      } catch {
+        rmSync(previewPath, { recursive: true, force: true });
+      }
+      await this.git.raw(["worktree", "prune"]);
+    }
+    logger.info("worktree", `creating pool preview: ${stashId}`, { branch, path: previewPath });
+    await this.git.raw(["worktree", "add", previewPath, branch]);
+    this.symlinkDeps(previewPath);
+    logger.info("worktree", `pool preview created: ${stashId}`);
+    return previewPath;
+  }
+  async removePreviewForPool(stashId) {
+    const previewPath = join2(this.projectPath, ".stashes", "previews", stashId);
+    logger.info("worktree", `removing pool preview: ${stashId}`);
+    try {
+      await this.git.raw(["worktree", "remove", "--force", previewPath]);
+    } catch {
+      if (existsSync2(previewPath)) {
+        rmSync(previewPath, { recursive: true, force: true });
+      }
+    }
+  }
   async apply(stashId) {
     const branch = `stashes/${stashId}`;
     logger.info("worktree", `merging: ${stashId}`, { branch });
@@ -272,6 +304,10 @@ class WorktreeManager {
     if (existsSync2(previewDir)) {
       rmSync(previewDir, { recursive: true, force: true });
     }
+    const previewsDir = join2(this.projectPath, ".stashes", "previews");
+    if (existsSync2(previewsDir)) {
+      rmSync(previewsDir, { recursive: true, force: true });
+    }
     logger.info("worktree", `cleanup complete`);
   }
   symlinkDeps(worktreePath) {
@@ -1049,19 +1085,201 @@ var apiRoutes = app;
 // ../server/dist/services/stash-service.js
 import { readFileSync as readFileSync4, existsSync as existsSync7 } from "fs";
 import { join as join7 } from "path";
+
+// ../server/dist/services/preview-pool.js
+class PreviewPool {
+  entries = new Map;
+  usedPorts = new Set;
+  maxSize;
+  ttlMs;
+  worktreeManager;
+  broadcast;
+  reaperInterval;
+  constructor(worktreeManager, broadcast, maxSize = MAX_PREVIEW_SERVERS, ttlMs = PREVIEW_TTL_MS) {
+    this.worktreeManager = worktreeManager;
+    this.broadcast = broadcast;
+    this.maxSize = maxSize;
+    this.ttlMs = ttlMs;
+    this.reaperInterval = setInterval(() => this.reap(), PREVIEW_REAPER_INTERVAL);
+  }
+  async getOrStart(stashId) {
+    const existing = this.entries.get(stashId);
+    if (existing) {
+      existing.lastHeartbeat = Date.now();
+      logger.info("pool", `warm hit: ${stashId} on port ${existing.port}`);
+      return existing.port;
+    }
+    if (this.entries.size >= this.maxSize) {
+      this.evictOldest();
+    }
+    const port = this.allocatePort();
+    const worktreePath = await this.worktreeManager.createPreviewForPool(stashId);
+    const process2 = Bun.spawn({
+      cmd: ["npm", "run", "dev"],
+      cwd: worktreePath,
+      stdin: "ignore",
+      stdout: "pipe",
+      stderr: "pipe",
+      env: { ...Bun.env, PORT: String(port), BROWSER: "none" }
+    });
+    const entry = {
+      stashId,
+      port,
+      process: process2,
+      worktreePath,
+      lastHeartbeat: Date.now()
+    };
+    this.entries.set(stashId, entry);
+    this.usedPorts.add(port);
+    logger.info("pool", `cold start: ${stashId} on port ${port}`, { poolSize: this.entries.size });
+    await this.waitForPort(port, 60000);
+    return port;
+  }
+  heartbeat(stashId) {
+    const entry = this.entries.get(stashId);
+    if (entry) {
+      entry.lastHeartbeat = Date.now();
+    }
+  }
+  isWarm(stashId) {
+    return this.entries.has(stashId);
+  }
+  getPort(stashId) {
+    return this.entries.get(stashId)?.port ?? null;
+  }
+  async stop(stashId) {
+    const entry = this.entries.get(stashId);
+    if (!entry)
+      return;
+    logger.info("pool", `stopping: ${stashId} on port ${entry.port}`);
+    this.killEntry(entry);
+    this.entries.delete(stashId);
+    this.usedPorts.delete(entry.port);
+    try {
+      await this.worktreeManager.removePreviewForPool(stashId);
+    } catch (err) {
+      logger.warn("pool", `worktree removal failed for ${stashId}`, {
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  prefetchNeighbors(currentStashId, sortedStashIds) {
+    const currentIndex = sortedStashIds.indexOf(currentStashId);
+    if (currentIndex === -1 || sortedStashIds.length < 2)
+      return;
+    const neighbors = [];
+    const prevIndex = (currentIndex - 1 + sortedStashIds.length) % sortedStashIds.length;
+    const nextIndex = (currentIndex + 1) % sortedStashIds.length;
+    if (!this.entries.has(sortedStashIds[prevIndex])) {
+      neighbors.push(sortedStashIds[prevIndex]);
+    }
+    if (!this.entries.has(sortedStashIds[nextIndex])) {
+      neighbors.push(sortedStashIds[nextIndex]);
+    }
+    for (const stashId of neighbors) {
+      if (this.entries.size >= this.maxSize)
+        break;
+      logger.info("pool", `prefetching neighbor: ${stashId}`);
+      this.getOrStart(stashId).then((port) => {
+        this.broadcast({ type: "stash:port", stashId, port });
+      }).catch((err) => {
+        logger.warn("pool", `prefetch failed for ${stashId}`, {
+          error: err instanceof Error ? err.message : String(err)
+        });
+      });
+    }
+  }
+  async shutdown() {
+    logger.info("pool", `shutting down all`, { poolSize: this.entries.size });
+    clearInterval(this.reaperInterval);
+    const stashIds = [...this.entries.keys()];
+    for (const stashId of stashIds) {
+      await this.stop(stashId);
+    }
+  }
+  reap() {
+    const now = Date.now();
+    const expired = [];
+    for (const [stashId, entry] of this.entries) {
+      if (now - entry.lastHeartbeat > this.ttlMs) {
+        expired.push(stashId);
+      }
+    }
+    for (const stashId of expired) {
+      logger.info("pool", `reaping inactive: ${stashId}`);
+      const entry = this.entries.get(stashId);
+      this.killEntry(entry);
+      this.entries.delete(stashId);
+      this.usedPorts.delete(entry.port);
+      this.worktreeManager.removePreviewForPool(stashId).catch((err) => {
+        logger.warn("pool", `reap worktree cleanup failed for ${stashId}`, {
+          error: err instanceof Error ? err.message : String(err)
+        });
+      });
+      this.broadcast({ type: "stash:preview_stopped", stashId });
+    }
+  }
+  evictOldest() {
+    let oldest = null;
+    for (const entry of this.entries.values()) {
+      if (!oldest || entry.lastHeartbeat < oldest.lastHeartbeat) {
+        oldest = entry;
+      }
+    }
+    if (oldest) {
+      logger.info("pool", `evicting: ${oldest.stashId} (oldest heartbeat)`);
+      this.killEntry(oldest);
+      this.entries.delete(oldest.stashId);
+      this.usedPorts.delete(oldest.port);
+      this.worktreeManager.removePreviewForPool(oldest.stashId).catch((err) => {
+        logger.warn("pool", `evict worktree cleanup failed for ${oldest.stashId}`, {
+          error: err instanceof Error ? err.message : String(err)
+        });
+      });
+      this.broadcast({ type: "stash:preview_stopped", stashId: oldest.stashId });
+    }
+  }
+  allocatePort() {
+    for (let port = STASH_PORT_START;port <= STASH_PORT_END; port++) {
+      if (!this.usedPorts.has(port)) {
+        return port;
+      }
+    }
+    throw new Error(`No available ports in range ${STASH_PORT_START}-${STASH_PORT_END}`);
+  }
+  killEntry(entry) {
+    try {
+      entry.process.kill();
+    } catch {}
+  }
+  async waitForPort(port, timeout) {
+    const start = Date.now();
+    while (Date.now() - start < timeout) {
+      try {
+        const res = await fetch(`http://localhost:${port}`, { signal: AbortSignal.timeout(2000) });
+        if (res.ok || res.status < 500)
+          return;
+      } catch {}
+      await new Promise((r) => setTimeout(r, 1000));
+    }
+    throw new Error(`Port ${port} not ready within ${timeout}ms`);
+  }
+}
+
+// ../server/dist/services/stash-service.js
 class StashService {
   projectPath;
   worktreeManager;
   persistence;
   broadcast;
+  previewPool;
   selectedComponent = null;
-  previewServer = null;
-  activePreviewStashId = null;
   constructor(projectPath, worktreeManager, persistence, broadcast) {
     this.projectPath = projectPath;
     this.worktreeManager = worktreeManager;
     this.persistence = persistence;
     this.broadcast = broadcast;
+    this.previewPool = new PreviewPool(worktreeManager, broadcast);
   }
   setSelectedComponent(component) {
     this.selectedComponent = component;
@@ -1220,94 +1438,25 @@ ${refDescriptions.join(`
       onProgress: (event) => this.progressToBroadcast(event)
     });
   }
-  async switchPreview(stashId) {
-    const previewPort = this.worktreeManager.getPreviewPort();
-    let previewPath = this.worktreeManager.getPreviewPath();
-    if (!previewPath) {
-      previewPath = await this.worktreeManager.createPreview();
-    }
-    await this.ensurePreviewServer(previewPath);
-    if (this.activePreviewStashId === stashId) {
-      this.broadcast({ type: "stash:port", stashId, port: previewPort });
-      return;
+  async switchPreview(stashId, sortedStashIds) {
+    const port = await this.previewPool.getOrStart(stashId);
+    this.broadcast({ type: "stash:port", stashId, port });
+    if (sortedStashIds && sortedStashIds.length > 1) {
+      this.previewPool.prefetchNeighbors(stashId, sortedStashIds);
     }
-    await this.worktreeManager.switchPreviewTo(stashId);
-    this.activePreviewStashId = stashId;
-    await this.waitForRecompile(previewPort, 15000);
-    this.broadcast({ type: "stash:port", stashId, port: previewPort });
+  }
+  previewHeartbeat(stashId) {
+    this.previewPool.heartbeat(stashId);
   }
   async applyStash(stashId) {
-    this.stopPreviewServer();
+    await this.previewPool.shutdown();
     await apply({ projectPath: this.projectPath, stashId });
-    this.activePreviewStashId = null;
     this.broadcast({ type: "stash:applied", stashId });
   }
   async deleteStash(stashId) {
-    if (this.activePreviewStashId === stashId) {
-      this.activePreviewStashId = null;
-    }
+    await this.previewPool.stop(stashId);
     await remove(this.projectPath, stashId);
   }
-  async ensurePreviewServer(previewPath) {
-    if (this.previewServer) {
-      const port = this.worktreeManager.getPreviewPort();
-      try {
-        const res = await fetch(`http://localhost:${port}`, { signal: AbortSignal.timeout(2000) });
-        if (res.ok || res.status < 500)
-          return;
-      } catch {
-        this.previewServer = null;
-      }
-    }
-    await this.startPreviewServer(previewPath);
-  }
-  async startPreviewServer(previewPath) {
-    const port = this.worktreeManager.getPreviewPort();
-    this.previewServer = Bun.spawn({
-      cmd: ["npm", "run", "dev"],
-      cwd: previewPath,
-      stdin: "ignore",
-      stdout: "pipe",
-      stderr: "pipe",
-      env: { ...process.env, PORT: String(port), BROWSER: "none" }
-    });
-    await this.waitForPort(port, 60000);
-  }
-  stopPreviewServer() {
-    if (this.previewServer) {
-      this.previewServer.kill();
-      this.previewServer = null;
-    }
-  }
-  async waitForRecompile(port, timeout) {
-    const start = Date.now();
-    await new Promise((r) => setTimeout(r, 500));
-    while (Date.now() - start < timeout) {
-      try {
-        const res = await fetch(`http://localhost:${port}`, {
-          signal: AbortSignal.timeout(3000),
-          headers: { "cache-control": "no-cache" }
-        });
-        if (res.ok) {
-          await new Promise((r) => setTimeout(r, 1000));
-          return;
-        }
-      } catch {}
-      await new Promise((r) => setTimeout(r, 500));
-    }
-  }
-  async waitForPort(port, timeout) {
-    const start = Date.now();
-    while (Date.now() - start < timeout) {
-      try {
-        const res = await fetch(`http://localhost:${port}`, { signal: AbortSignal.timeout(2000) });
-        if (res.ok || res.status < 500)
-          return;
-      } catch {}
-      await new Promise((r) => setTimeout(r, 1000));
-    }
-    throw new Error(`Port ${port} not ready within ${timeout}ms`);
-  }
 }
 
 // ../server/dist/services/websocket.js
@@ -1375,7 +1524,10 @@ function createWebSocketHandler(projectPath, userDevPort, appProxyPort) {
             await stashService.vary(event.sourceStashId, event.prompt);
             break;
           case "interact":
-            await stashService.switchPreview(event.stashId);
+            await stashService.switchPreview(event.stashId, event.sortedStashIds);
+            break;
+          case "preview_heartbeat":
+            stashService.previewHeartbeat(event.stashId);
             break;
           case "apply_stash":
             await stashService.applyStash(event.stashId);