@vscode/component-explorer-cli 0.1.1-2 → 0.1.1-20

package/dist/daemon/DaemonService.js

@@ -1,19 +1,86 @@
 import { z } from 'zod';
+import * as path from 'node:path';
 import '../external/vscode-observables/observables/dist/observableInternal/index.js';
+import { observableValue } from '../external/vscode-observables/observables/dist/observableInternal/observables/observableValue.js';
 import '../external/vscode-observables/observables/dist/observableInternal/debugLocation.js';
 import { autorun } from '../external/vscode-observables/observables/dist/observableInternal/reactions/autorun.js';
-import '../external/vscode-observables/observables/dist/observableInternal/observables/derived.js';
+import { derived } from '../external/vscode-observables/observables/dist/observableInternal/observables/derived.js';
+import { waitForState } from '../external/vscode-observables/observables/dist/observableInternal/utils/utilsCancellation.js';
 import '../external/vscode-observables/observables/dist/observableInternal/utils/utils.js';
 import '../external/vscode-observables/observables/dist/observableInternal/observables/observableFromEvent.js';
-import { createApiFactory } from '@hediet/simple-api/server';
-import { AsyncStream } from '@hediet/simple-api';
+import { createApiFactory } from '../packages/simple-api/dist/chunk-3R7GHWBM.js';
+import { AsyncStream } from '../packages/simple-api/dist/chunk-SGBCNXYH.js';
 import { ExplorerSession } from '../explorerSession.js';
+import { GitIndexResolver } from '../git/gitIndexResolver.js';
+import { DirtyWorktreeError } from '../git/gitWorktreeManager.js';
+import { execGit } from '../git/gitUtils.js';
 import { PlaywrightBrowserPageFactory } from '../browserPage.js';
 import { DefaultComponentExplorerHttpServerFactory } from '../httpServer.js';
 import { installDependencies } from '../dependencyInstaller.js';
 import { FileApprovalStore } from './approvalStore.js';
 import { contentHash } from '../screenshotCache.js';
+import { WorktreePool } from '../WorktreePool.js';
+import { ViteProjectRef } from '../viteProjectRef.js';
+import { pluginProtocolVersionText, daemonApiVersionText } from './version.js';
+export { isCompatibleVersion, parseVersion } from './version.js';
 
+// ---------------------------------------------------------------------------
+// ActivityTracker — monitors idle time and triggers shutdown
+// ---------------------------------------------------------------------------
+class ActivityTracker {
+    _idleTimeoutMs;
+    _onIdle;
+    _logger;
+    _lastActivityTime = Date.now();
+    _idleCheckInterval;
+    _autorunDisposable;
+    _disposed = false;
+    _started = false;
+    _activeCount = 0;
+    constructor(_idleTimeoutMs, _onIdle, _logger) {
+        this._idleTimeoutMs = _idleTimeoutMs;
+        this._onIdle = _onIdle;
+        this._logger = _logger;
+    }
+    setActive(value) {
+        if (value) {
+            this._activeCount++;
+            this._lastActivityTime = Date.now();
+        }
+        else {
+            this._activeCount = Math.max(0, this._activeCount - 1);
+        }
+    }
+    reportActivity() {
+        this._lastActivityTime = Date.now();
+    }
+    start() {
+        if (this._started || this._disposed || this._idleTimeoutMs <= 0) {
+            return;
+        }
+        this._started = true;
+        const checkIntervalMs = Math.min(30_000, this._idleTimeoutMs / 2);
+        this._idleCheckInterval = setInterval(() => {
+            if (this._activeCount > 0) {
+                this._lastActivityTime = Date.now();
+                return;
+            }
+            const idleMs = Date.now() - this._lastActivityTime;
+            if (idleMs >= this._idleTimeoutMs) {
+                this._logger.log(`Idle for ${Math.round(idleMs / 1000)}s, shutting down`);
+                this._onIdle();
+            }
+        }, checkIntervalMs);
+    }
+    dispose() {
+        this._disposed = true;
+        this._autorunDisposable?.dispose();
+        if (this._idleCheckInterval) {
+            clearInterval(this._idleCheckInterval);
+            this._idleCheckInterval = undefined;
+        }
+    }
+}
 class SourceTreeChangedError extends Error {
     constructor(sessionName) {
         super(`Source tree changed for session "${sessionName}" — retry with latest sourceTreeId`);
@@ -25,38 +92,44 @@ class SourceTreeChangedError extends Error {
 // ---------------------------------------------------------------------------
 class DaemonService {
     _config;
+    _pipeName;
     _logger;
     _browserFactory;
     _serverFactory;
     _sessions = new Map();
     _sessionConfigs = new Map();
+    _dynamicSessionMeta = new Map();
     _resolvers = new Map();
+    _eventListenerCount = observableValue(this, 0);
     _eventListeners = new Set();
     _shutdownRequested = false;
     _shutdownResolvers = [];
+    _activityTracker;
+    _worktreePool;
     approvals;
     api;
-    constructor(_config, _logger, _browserFactory, _serverFactory, approvalStorePath) {
+    constructor(_config, _pipeName, _logger, _browserFactory, _serverFactory, approvalStorePath, idleTimeoutMs) {
         this._config = _config;
+        this._pipeName = _pipeName;
         this._logger = _logger;
         this._browserFactory = _browserFactory;
         this._serverFactory = _serverFactory;
         this.approvals = new FileApprovalStore(approvalStorePath);
+        this._activityTracker = new ActivityTracker(idleTimeoutMs, () => this.requestShutdown(), this._logger);
+        if (_config.worktreePool) {
+            this._worktreePool = new WorktreePool(_config.worktreePool.maxSlots, _config.repo.worktreeRootPath());
+        }
         this.api = this._buildApi();
     }
-    static async create(config, logger) {
-        const browserFactory = new PlaywrightBrowserPageFactory();
+    static async create(config, logger, pipeName, options) {
+        const browserFactory = new PlaywrightBrowserPageFactory(false, 30_000, logger);
         const serverFactory = new DefaultComponentExplorerHttpServerFactory();
         const approvalStorePath = `${config.screenshotDir}/approvals.json`;
-        // Wrap the logger so messages also appear on the event stream
-        const eventStreamLogger = new EventStreamLogger(logger);
-        const svc = new DaemonService(config, eventStreamLogger, browserFactory, serverFactory, approvalStorePath);
-        eventStreamLogger._emitter = (event) => svc._emit(event);
-        const currentSession = config.sessions.find(s => s.source.kind === 'current');
-        const resolveViteFrom = currentSession?.viteProject.cwd;
+        const idleTimeoutMs = options?.idleTimeoutMs ?? 5 * 60 * 1000; // 5 minutes default
+        const svc = new DaemonService(config, pipeName ?? '', logger, browserFactory, serverFactory, approvalStorePath, idleTimeoutMs);
         for (const sessionConfig of config.sessions) {
             svc._sessionConfigs.set(sessionConfig.name, sessionConfig);
-            await svc._setupSession(sessionConfig, config.repo, resolveViteFrom);
+            await svc._setupSession(sessionConfig);
         }
         return svc;
     }
@@ -71,6 +144,7 @@ class DaemonService {
                         sourceTreeId: z.string(),
                     },
                 }, async (args) => {
+                    this._activityTracker.reportActivity();
                     this.assertSourceTreeId(args.sessionName, args.sourceTreeId);
                     const session = this.getSession(args.sessionName);
                     const result = await session.explorer.listFixtures();
@@ -85,18 +159,50 @@ class DaemonService {
                         sourceTreeId: z.string(),
                         sessionName: z.string(),
                         includeImage: z.boolean().optional(),
+                        stabilityCheck: z.boolean().optional(),
                     },
                 }, async (args) => {
+                    this._activityTracker.reportActivity();
                     const session = this.getSession(args.sessionName);
                     this.assertSourceTreeId(args.sessionName, args.sourceTreeId);
-                    const png = await session.explorer.screenshotFixture(args.fixtureId);
+                    if (args.stabilityCheck) {
+                        const result = await session.explorer.screenshotFixtureStabilityCheck(args.fixtureId);
+                        this.assertSourceTreeId(args.sessionName, args.sourceTreeId);
+                        const hashes = result.screenshots.map(s => contentHash(s.image));
+                        const isStable = hashes[0] === hashes[1] && hashes[1] === hashes[2];
+                        const stabilityScreenshots = result.screenshots.map((s, i) => ({
+                            hash: hashes[i],
+                            delayMs: s.delayMs,
+                            image: (args.includeImage ?? true)
+                                ? Buffer.from(s.image).toString('base64')
+                                : undefined,
+                        }));
+                        return {
+                            hash: hashes[hashes.length - 1],
+                            sourceTreeId: args.sourceTreeId,
+                            image: (args.includeImage ?? true)
+                                ? Buffer.from(result.screenshots[result.screenshots.length - 1].image).toString('base64')
+                                : undefined,
+                            hasError: result.hasError,
+                            error: result.error,
+                            events: result.events.length > 0 ? result.events : undefined,
+                            resultData: result.resultData,
+                            isStable,
+                            stabilityScreenshots,
+                        };
+                    }
+                    const result = await session.explorer.screenshotFixture(args.fixtureId);
                     this.assertSourceTreeId(args.sessionName, args.sourceTreeId);
                     return {
-                        hash: contentHash(png),
+                        hash: contentHash(result.image),
                         sourceTreeId: args.sourceTreeId,
                         image: (args.includeImage ?? true)
-                            ? Buffer.from(png).toString('base64')
+                            ? Buffer.from(result.image).toString('base64')
                             : undefined,
+                        hasError: result.hasError,
+                        error: result.error,
+                        events: result.events?.length > 0 ? result.events : undefined,
+                        resultData: result.resultData,
                     };
                 }),
                 takeBatch: createMethod({
@@ -107,21 +213,29 @@ class DaemonService {
                         includeImages: z.boolean().optional(),
                     },
                 }, async (args) => {
+                    this._activityTracker.reportActivity();
                     const session = this.getSession(args.sessionName);
                     this.assertSourceTreeId(args.sessionName, args.sourceTreeId);
                     const includeImages = args.includeImages ?? false;
+                    this._logger.trace(`takeBatch: ${args.fixtureIds.length} fixtures, session=${args.sessionName}`);
+                    const startTime = Date.now();
                     const screenshots = [];
                     for (const fixtureId of args.fixtureIds) {
-                        const png = await session.explorer.screenshotFixture(fixtureId);
+                        const result = await session.explorer.screenshotFixture(fixtureId);
                         this.assertSourceTreeId(args.sessionName, args.sourceTreeId);
                         screenshots.push({
                             fixtureId,
-                            hash: contentHash(png),
+                            hash: contentHash(result.image),
                             image: includeImages
-                                ? Buffer.from(png).toString('base64')
+                                ? Buffer.from(result.image).toString('base64')
                                 : undefined,
+                            hasError: result.hasError,
+                            error: result.error,
+                            events: result.events.length > 0 ? result.events : undefined,
+                            resultData: result.resultData,
                         });
                     }
+                    this._logger.trace(`takeBatch: done in ${Date.now() - startTime}ms`);
                     return { sourceTreeId: args.sourceTreeId, screenshots };
                 }),
                 compare: createMethod({
@@ -134,25 +248,46 @@ class DaemonService {
                         includeImages: z.boolean().optional(),
                     },
                 }, async (args) => {
+                    this._activityTracker.reportActivity();
                     const baselineSession = this.getSession(args.baselineSessionName);
                     const currentSession = this.getSession(args.currentSessionName);
                     this.assertSourceTreeId(args.baselineSessionName, args.baselineSourceTreeId);
                     this.assertSourceTreeId(args.currentSessionName, args.currentSourceTreeId);
-                    const baselinePng = await baselineSession.explorer.screenshotFixture(args.fixtureId);
+                    const [baselineResult, baselineFixtures] = await Promise.all([
+                        baselineSession.explorer.screenshotFixture(args.fixtureId),
+                        baselineSession.explorer.listFixtures(),
+                    ]);
                     this.assertSourceTreeId(args.baselineSessionName, args.baselineSourceTreeId);
-                    const currentPng = await currentSession.explorer.screenshotFixture(args.fixtureId);
+                    const [currentResult, currentFixtures] = await Promise.all([
+                        currentSession.explorer.screenshotFixture(args.fixtureId),
+                        currentSession.explorer.listFixtures(),
+                    ]);
                     this.assertSourceTreeId(args.currentSessionName, args.currentSourceTreeId);
-                    const baselineHash = contentHash(baselinePng);
-                    const currentHash = contentHash(currentPng);
+                    const baselineHash = contentHash(baselineResult.image);
+                    const currentHash = contentHash(currentResult.image);
                     const includeImages = args.includeImages ?? false;
+                    const currentFixture = currentFixtures.find(f => f.fixtureId === args.fixtureId);
+                    const baselineFixture = baselineFixtures.find(f => f.fixtureId === args.fixtureId);
+                    const labels = currentFixture?.labels;
+                    const labelsChanged = baselineFixture && !arraysEqual(baselineFixture.labels, currentFixture?.labels ?? []);
                     return {
                         match: baselineHash === currentHash,
                         baselineHash,
                         currentHash,
                         baselineImage: includeImages
-                            ? Buffer.from(baselinePng).toString('base64') : undefined,
+                            ? Buffer.from(baselineResult.image).toString('base64') : undefined,
                         currentImage: includeImages
-                            ? Buffer.from(currentPng).toString('base64') : undefined,
+                            ? Buffer.from(currentResult.image).toString('base64') : undefined,
+                        baselineHasError: baselineResult.hasError,
+                        baselineError: baselineResult.error,
+                        baselineEvents: baselineResult.events.length > 0 ? baselineResult.events : undefined,
+                        baselineResultData: baselineResult.resultData,
+                        currentHasError: currentResult.hasError,
+                        currentError: currentResult.error,
+                        currentEvents: currentResult.events.length > 0 ? currentResult.events : undefined,
+                        currentResultData: currentResult.resultData,
+                        labels,
+                        labelsBefore: labelsChanged ? baselineFixture.labels : undefined,
                         approval: (baselineHash !== currentHash)
                             ? this.approvals.lookup({
                                 fixtureId: args.fixtureId,
@@ -172,6 +307,7 @@ class DaemonService {
                         comment: z.string(),
                     },
                 }, async (args) => {
+                    this._activityTracker.reportActivity();
                     this.approvals.approve(args);
                 }),
                 revoke: createMethod({
@@ -181,11 +317,13 @@ class DaemonService {
                         modifiedHash: z.string(),
                     },
                 }, async (args) => {
+                    this._activityTracker.reportActivity();
                     this.approvals.revoke(args);
                 }),
                 list: createMethod({
                     args: { fixtureId: z.string().optional() },
                 }, async (args) => {
+                    this._activityTracker.reportActivity();
                     return this.approvals.list(args.fixtureId);
                 }),
                 lookup: createMethod({
@@ -195,16 +333,77 @@ class DaemonService {
                         modifiedHash: z.string(),
                     },
                 }, async (args) => {
+                    this._activityTracker.reportActivity();
                     return this.approvals.lookup(args) ?? null;
                 }),
             }),
+            evaluate: createMethod({
+                args: {
+                    sessionName: z.string(),
+                    sourceTreeId: z.string(),
+                    expression: z.string(),
+                    fixtureId: z.string().optional(),
+                },
+            }, async (args) => {
+                this._activityTracker.reportActivity();
+                const session = this.getSession(args.sessionName);
+                this.assertSourceTreeId(args.sessionName, args.sourceTreeId);
+                const result = await session.explorer.evaluateJs(args.expression, args.fixtureId);
+                this.assertSourceTreeId(args.sessionName, args.sourceTreeId);
+                return { result };
+            }),
             events: createMethod({ args: {} }, async () => {
                 return AsyncStream.fromIterable(this.eventStream());
             }),
-            sessions: createMethod({ args: {} }, async () => {
+            sessions: createMethod({ args: {} }, async (_args, ctx) => {
+                this._activityTracker.reportActivity();
+                this._logger.trace(`API: sessions (client=${ctx.clientName}, eventListeners=${this._eventListeners.size})`);
+                return this.getSessionInfos();
+            }),
+            version: createMethod({ args: {} }, async () => {
+                this._activityTracker.reportActivity();
+                return {
+                    daemonApiVersion: daemonApiVersionText,
+                    pluginProtocolVersion: pluginProtocolVersionText,
+                };
+            }),
+            restartSession: createMethod({
+                args: { sessionName: z.string() },
+            }, async (args, ctx) => {
+                this._activityTracker.reportActivity();
+                this._logger.debug(`Restart session "${args.sessionName}" requested (client=${ctx.clientName})`);
+                await this._restartSession(args.sessionName);
                 return this.getSessionInfos();
             }),
-            shutdown: createMethod({ args: {} }, async () => {
+            openSession: createMethod({
+                args: {
+                    name: z.string(),
+                    ref: z.string(),
+                },
+            }, async (args, ctx) => {
+                this._activityTracker.reportActivity();
+                this._logger.log(`Open session "${args.name}" @ ${args.ref} requested (client=${ctx.clientName})`);
+                return this._openDynamicSession(args.name, args.ref);
+            }),
+            closeSession: createMethod({
+                args: { name: z.string() },
+            }, async (args, ctx) => {
+                this._activityTracker.reportActivity();
+                this._logger.log(`Close session "${args.name}" requested (client=${ctx.clientName})`);
+                return this._closeDynamicSession(args.name);
+            }),
+            updateSessionRef: createMethod({
+                args: {
+                    name: z.string(),
+                    ref: z.string(),
+                },
+            }, async (args, ctx) => {
+                this._activityTracker.reportActivity();
+                this._logger.log(`Update session ref "${args.name}" → ${args.ref} requested (client=${ctx.clientName})`);
+                return this._updateDynamicSessionRef(args.name, args.ref);
+            }),
+            shutdown: createMethod({ args: {} }, async (_args, ctx) => {
+                this._logger.debug(`Shutdown requested via API (client=${ctx.clientName})`);
                 this.requestShutdown();
             }),
         });
@@ -217,16 +416,65 @@ class DaemonService {
         }
         return session;
     }
-    getSessionInfos() {
-        return this._config.sessions.map(sc => {
+    getSessionInfos(reader) {
+        const infos = [];
+        const reportedNames = new Set();
+        // Static sessions (from config)
+        for (const sc of this._config.sessions) {
+            reportedNames.add(sc.name);
             const session = this._sessions.get(sc.name);
-            return {
-                name: sc.name,
-                sourceKind: sc.source.kind,
-                serverUrl: session.serverUrl,
-                sourceTreeId: session.sourceTreeId.get().value,
-            };
+            const meta = this._dynamicSessionMeta.get(sc.name);
+            if (!session) {
+                infos.push({ name: sc.name, sourceKind: sc.source.kind, isLoading: true });
+            }
+            else if (meta) {
+                infos.push({
+                    name: sc.name,
+                    sourceKind: 'worktree',
+                    serverUrl: session.serverUrl,
+                    sourceTreeId: reader ? session.sourceTreeId.read(reader).value : session.sourceTreeId.get().value,
+                    worktreePath: meta.worktreePath,
+                    ref: meta.ref,
+                });
+            }
+            else {
+                infos.push({
+                    name: sc.name,
+                    sourceKind: sc.source.kind,
+                    serverUrl: session.serverUrl,
+                    sourceTreeId: reader ? session.sourceTreeId.read(reader).value : session.sourceTreeId.get().value,
+                });
+            }
+        }
+        // Dynamic worktree sessions (not already reported as static)
+        for (const [name, meta] of this._dynamicSessionMeta) {
+            if (reportedNames.has(name)) {
+                continue;
+            }
+            const session = this._sessions.get(name);
+            if (!session) {
+                infos.push({ name, sourceKind: 'worktree', isLoading: true });
+            }
+            else {
+                infos.push({
+                    name,
+                    sourceKind: 'worktree',
+                    serverUrl: session.serverUrl,
+                    sourceTreeId: reader ? session.sourceTreeId.read(reader).value : session.sourceTreeId.get().value,
+                    worktreePath: meta.worktreePath,
+                    ref: meta.ref,
+                });
+            }
+        }
+        return infos;
+    }
+    waitForSession(sessionName) {
+        const sessionObs = derived(this, reader => {
+            const infos = this.getSessionInfos(reader);
+            const session = sessionName ? infos.find(s => s.name === sessionName) : infos[0];
+            return session && !session.isLoading ? session : undefined;
         });
+        return waitForState(sessionObs);
     }
     getSourceTreeId(sessionName) {
         return this.getSession(sessionName).sourceTreeId.get().value;
@@ -246,6 +494,9 @@ class DaemonService {
                 let resolve;
                 let done = false;
                 const listener = (event) => {
+                    if (event.type !== 'log') {
+                        self._logger.trace(`Event stream: ${event.type}`);
+                    }
                     if (resolve) {
                         const r = resolve;
                         resolve = undefined;
@@ -256,8 +507,12 @@ class DaemonService {
                     }
                 };
                 self._eventListeners.add(listener);
+                self._eventListenerCount.set(self._eventListeners.size, undefined);
+                self._activityTracker.setActive(true);
+                self._logger.debug(`Event stream opened (listeners: ${self._eventListeners.size})`);
                 const onShutdown = () => {
                     done = true;
+                    cleanup();
                     if (resolve) {
                         const r = resolve;
                         resolve = undefined;
@@ -265,6 +520,12 @@ class DaemonService {
                     }
                 };
                 self._shutdownResolvers.push(onShutdown);
+                const cleanup = () => {
+                    self._eventListeners.delete(listener);
+                    self._eventListenerCount.set(self._eventListeners.size, undefined);
+                    self._activityTracker.setActive(false);
+                    self._logger.debug(`Event stream closed (listeners: ${self._eventListeners.size})`);
+                };
                 return {
                     next() {
                         if (done) {
@@ -277,7 +538,12 @@ class DaemonService {
                     },
                     return() {
                         done = true;
-                        self._eventListeners.delete(listener);
+                        cleanup();
+                        if (resolve) {
+                            const r = resolve;
+                            resolve = undefined;
+                            r({ value: undefined, done: true });
+                        }
                         return Promise.resolve({ value: undefined, done: true });
                     },
                 };
@@ -287,6 +553,7 @@ class DaemonService {
     // -- Event loop ----------------------------------------------------------
     async runEventLoop() {
         this._startSourceChangeWatchers();
+        this._activityTracker.start();
         await new Promise(resolve => {
             if (this._shutdownRequested) {
                 resolve();
@@ -298,64 +565,57 @@ class DaemonService {
     _sourceChangeDisposables = [];
     _startSourceChangeWatchers() {
         for (const [name, session] of this._sessions) {
-            let previousValue = session.sourceTreeId.get().value;
-            const disposable = autorun(reader => {
-                const current = session.sourceTreeId.read(reader);
-                if (current.value !== previousValue) {
-                    previousValue = current.value;
-                    this._emit({ type: 'source-change', sessionName: name, sourceTreeId: current.value });
-                }
-            });
-            this._sourceChangeDisposables.push(disposable);
-        }
-        // Watch for ref changes (worktree sessions)
-        for (const [name, resolver] of this._resolvers) {
-            let previousCommit = resolver.resolvedCommit.get();
-            const disposable = autorun(reader => {
-                const commit = resolver.resolvedCommit.read(reader);
-                if (!previousCommit.equals(commit)) {
-                    previousCommit = commit;
-                    this._handleRefChange(name, resolver.ref, commit);
-                }
-            });
-            this._sourceChangeDisposables.push(disposable);
+            this._addSourceChangeWatcher(name, session);
         }
     }
-    async _handleRefChange(sessionName, ref, newCommit) {
-        this._logger.log(`Ref ${ref} moved to ${newCommit.toShort()}`);
-        const git = this._config.repo;
-        const sessionConfig = this._sessionConfigs.get(sessionName);
-        if (!sessionConfig || sessionConfig.source.kind !== 'worktree') {
+    _addSourceChangeWatcher(name, session) {
+        let previousValue = session.sourceTreeId.get().value;
+        const disposable = autorun(reader => {
+            const current = session.sourceTreeId.read(reader);
+            if (current.value !== previousValue) {
+                this._logger.debug(`Source tree changed: ${name} ${previousValue} → ${current.value}`);
+                previousValue = current.value;
+                this._emit({ type: 'source-change', sessionName: name, sourceTreeId: current.value });
+            }
+        });
+        this._sourceChangeDisposables.push(disposable);
+    }
+    async _handleRefChange(sessionName, ref, previousCommit, newCommit) {
+        const changedFiles = await this._getChangedFiles(previousCommit, newCommit);
+        this._logger.log(`Ref ${ref} moved to ${newCommit.toShort()} (${changedFiles.length} file(s) changed${changedFiles.length > 0 ? ': ' + changedFiles.join(', ') : ''})`);
+        const meta = this._dynamicSessionMeta.get(sessionName);
+        if (!meta) {
             return;
         }
-        const wt = sessionConfig.source.worktree;
-        const wtInfo = await git.worktrees.info(wt.worktreePath);
+        const git = this._config.repo;
+        const wtInfo = await git.worktrees.info(meta.worktreePath);
         if (wtInfo && wtInfo.isDirty) {
             this._logger.log(`Worktree is dirty, skipping update to ${newCommit.toShort()}`);
             return;
         }
-        // Dispose old session
-        const oldSession = this._sessions.get(sessionName);
-        await oldSession?.dispose();
-        // Checkout + reinstall
         if (wtInfo) {
-            await git.worktrees.checkout(wt.worktreePath, newCommit);
+            await git.worktrees.checkout(meta.worktreePath, newCommit);
         }
         else {
-            await git.worktrees.create(wt.worktreePath, newCommit);
+            await git.worktrees.create(meta.worktreePath, newCommit);
         }
-        await installDependencies(wt.worktreePath, wt.install, this._logger);
-        // Recreate session
-        const currentSession = this._config.sessions.find(s => s.source.kind === 'current');
-        const resolveViteFrom = currentSession?.viteProject.cwd;
-        const newSession = await ExplorerSession.create(sessionConfig.name, sessionConfig.viteProject, this._serverFactory, this._browserFactory, {
-            logger: this._logger,
-            resolveViteFrom,
-            hmrAllowedPaths: this._config.viteHmr?.allowedPaths,
-        });
-        this._sessions.set(sessionName, newSession);
+        const sessionConfig = this._sessionConfigs.get(sessionName);
+        const installSetup = (sessionConfig?.source.kind === 'worktree' ? sessionConfig.source.install : undefined)
+            ?? this._config.worktreePool?.setup
+            ?? { kind: 'auto' };
+        await installDependencies(meta.worktreePath, installSetup, this._logger);
         this._emit({ type: 'ref-change', sessionName, newCommit: newCommit.toShort() });
     }
+    async _getChangedFiles(oldCommit, newCommit) {
+        try {
+            const output = await execGit(this._config.repo.gitRoot, ['diff', '--name-only', oldCommit.hash, newCommit.hash]);
+            return output.trim().split('\n').filter(f => f.length > 0);
+        }
+        catch (e) {
+            this._logger.log(`Failed to get changed files (${oldCommit.toShort()}..${newCommit.toShort()}): ${e instanceof Error ? e.message : e}`);
+            return [];
+        }
+    }
     // -- Shutdown ------------------------------------------------------------
     requestShutdown() {
         this._shutdownRequested = true;
@@ -366,10 +626,15 @@ class DaemonService {
     }
     async dispose() {
         this.requestShutdown();
+        this._activityTracker.dispose();
         for (const d of this._sourceChangeDisposables) {
             d.dispose();
         }
         this._sourceChangeDisposables = [];
+        for (const d of this._dynamicRefWatchers.values()) {
+            d.dispose();
+        }
+        this._dynamicRefWatchers.clear();
         for (const session of this._sessions.values()) {
             await session.dispose();
         }
@@ -380,71 +645,303 @@ class DaemonService {
         await this._browserFactory.dispose();
     }
     // -- Private helpers -----------------------------------------------------
-    /** @internal — also called by EventStreamLogger */
     _emit(event) {
         for (const listener of this._eventListeners) {
             listener(event);
         }
     }
-    async _setupSession(sessionConfig, git, resolveViteFrom) {
+    async _restartSession(sessionName) {
+        const config = this._sessionConfigs.get(sessionName);
+        const meta = this._dynamicSessionMeta.get(sessionName);
+        if (!config && !meta) {
+            throw new Error(`Unknown session: "${sessionName}"`);
+        }
+        const existing = this._sessions.get(sessionName);
+        if (existing) {
+            this._logger.debug(`Disposing session: ${sessionName}`);
+            await existing.dispose();
+            this._sessions.delete(sessionName);
+        }
+        this._logger.log(`Restarting server: ${sessionName}`);
+        if (meta) {
+            await this._createWorktreeExplorerSession(sessionName, meta.worktreePath);
+        }
+        else if (config) {
+            await this._createExplorerSession(config);
+        }
+    }
+    async _createExplorerSession(sessionConfig) {
+        const session = await ExplorerSession.create(sessionConfig.name, sessionConfig.viteProject, this._serverFactory, this._browserFactory, {
+            logger: this._logger,
+            hmrAllowedPaths: this._config.viteHmr?.allowedPaths,
+            daemonConfig: {
+                pipeName: this._pipeName,
+                sessionName: sessionConfig.name,
+                daemonApiVersion: daemonApiVersionText,
+                pluginProtocolVersion: pluginProtocolVersionText,
+            },
+        });
+        this._sessions.set(sessionConfig.name, session);
+        this._logger.debug(`Session ready: ${sessionConfig.name} (${session.serverUrl})`);
+    }
+    async _createWorktreeExplorerSession(sessionName, worktreePath) {
+        const configDirRelToGitRoot = path.relative(this._config.repo.gitRoot, this._config.configDir);
+        const worktreeConfigDir = path.resolve(worktreePath, configDirRelToGitRoot);
+        const viteConfigPath = path.resolve(worktreeConfigDir, this._config.defaultViteConfig);
+        const viteProject = ViteProjectRef.fromViteConfigPath(viteConfigPath);
+        const currentSession = this._config.sessions.find(s => s.source.kind === 'current');
+        const resolveViteFrom = currentSession?.viteProject.configFile;
+        this._logger.debug(`Worktree session "${sessionName}": resolveViteFrom=${resolveViteFrom}`);
+        const session = await ExplorerSession.create(sessionName, viteProject, this._serverFactory, this._browserFactory, {
+            logger: this._logger,
+            resolveViteFrom,
+            hmrAllowedPaths: this._config.viteHmr?.allowedPaths,
+            daemonConfig: {
+                pipeName: this._pipeName,
+                sessionName,
+                daemonApiVersion: daemonApiVersionText,
+                pluginProtocolVersion: pluginProtocolVersionText,
+            },
+        });
+        this._sessions.set(sessionName, session);
+        this._logger.debug(`Session ready: ${sessionName} (${session.serverUrl})`);
+    }
+    async _setupSession(sessionConfig) {
+        this._logger.debug(`Setting up session: ${sessionConfig.name} (${sessionConfig.source.kind})`);
+        this._logger.log(`Starting server: ${sessionConfig.name}`);
         if (sessionConfig.source.kind === 'worktree') {
-            const wt = sessionConfig.source.worktree;
-            const resolver = await git.createCommitResolver(wt.ref);
-            this._resolvers.set(sessionConfig.name, resolver);
+            await this._setupWorktreeSession(sessionConfig, sessionConfig.source);
+        }
+        else {
+            await this._createExplorerSession(sessionConfig);
+        }
+    }
+    async _setupWorktreeSession(sessionConfig, source) {
+        if (!this._worktreePool) {
+            throw new Error(`Session "${sessionConfig.name}" requires a worktree but no worktree pool is available`);
+        }
+        const slot = this._worktreePool.allocate(sessionConfig.name);
+        const git = this._config.repo;
+        const ref = source.ref;
+        const resolver = ref === GitIndexResolver.INDEX_REF
+            ? await git.createIndexResolver()
+            : await git.createCommitResolver(ref);
+        this._resolvers.set(sessionConfig.name, resolver);
+        const resolvedCommit = resolver.resolvedCommit.get();
+        const wtInfo = await git.worktrees.info(slot.worktreePath);
+        if (!wtInfo) {
+            this._logger.log(`Creating worktree at ${slot.worktreePath} (${ref} @ ${resolvedCommit.toShort()})`);
+            await git.worktrees.create(slot.worktreePath, resolvedCommit);
+        }
+        else if (!wtInfo.checkedOutCommit.equals(resolvedCommit)) {
+            if (wtInfo.isDirty) {
+                throw new Error(`Worktree slot ${slot.index} is dirty. Dirty files:\n` +
+                    wtInfo.dirtyFiles.map(f => `  ${f}`).join('\n'));
+            }
+            this._logger.log(`Updating worktree to ${resolvedCommit.toShort()}`);
+            await git.worktrees.checkout(slot.worktreePath, resolvedCommit);
+        }
+        else {
+            this._logger.log(`Worktree already at ${resolvedCommit.toShort()}`);
+        }
+        const installSetup = source.install ?? this._config.worktreePool?.setup ?? { kind: 'auto' };
+        await installDependencies(slot.worktreePath, installSetup, this._logger);
+        this._dynamicSessionMeta.set(sessionConfig.name, { ref, worktreePath: slot.worktreePath });
+        await this._createWorktreeExplorerSession(sessionConfig.name, slot.worktreePath);
+        this._addDynamicRefWatcher(sessionConfig.name, resolver);
+    }
+    // -- Dynamic session management ------------------------------------------
+    async _openDynamicSession(name, ref) {
+        if (this._sessions.has(name) || this._sessionConfigs.has(name) || this._dynamicSessionMeta.has(name)) {
+            return { error: `Session "${name}" already exists` };
+        }
+        if (!this._worktreePool) {
+            return { error: 'No worktree pool configured. Add a "worktree" section to your component-explorer.json config.' };
+        }
+        let slot;
+        try {
+            slot = this._worktreePool.allocate(name);
+        }
+        catch (e) {
+            return { error: e instanceof Error ? e.message : String(e) };
+        }
+        const git = this._config.repo;
+        const isIndex = ref === GitIndexResolver.INDEX_REF;
+        try {
+            let resolver;
+            if (isIndex) {
+                resolver = await git.createIndexResolver();
+            }
+            else {
+                resolver = await git.createCommitResolver(ref);
+            }
+            this._resolvers.set(name, resolver);
             const resolvedCommit = resolver.resolvedCommit.get();
-            const wtInfo = await git.worktrees.info(wt.worktreePath);
+            const wtInfo = await git.worktrees.info(slot.worktreePath);
             if (!wtInfo) {
-                this._logger.log(`Creating worktree at ${wt.worktreePath} (${wt.ref} @ ${resolvedCommit.toShort()})`);
-                await git.worktrees.create(wt.worktreePath, resolvedCommit);
-                await installDependencies(wt.worktreePath, wt.install, this._logger);
+                this._logger.log(`Creating worktree at ${slot.worktreePath} (${ref} @ ${resolvedCommit.toShort()})`);
+                await git.worktrees.create(slot.worktreePath, resolvedCommit);
             }
             else if (!wtInfo.checkedOutCommit.equals(resolvedCommit)) {
                 if (wtInfo.isDirty) {
-                    this._logger.log(`Worktree is dirty, using existing checkout at ${wtInfo.checkedOutCommit.toShort()}`);
-                }
-                else {
-                    this._logger.log(`Updating worktree to ${resolvedCommit.toShort()}`);
-                    await git.worktrees.checkout(wt.worktreePath, resolvedCommit);
-                    await installDependencies(wt.worktreePath, wt.install, this._logger);
+                    this._worktreePool.release(name);
+                    this._resolvers.get(name)?.dispose();
+                    this._resolvers.delete(name);
+                    return {
+                        error: `Worktree slot ${slot.index} is dirty. Dirty files:\n` +
+                            wtInfo.dirtyFiles.map(f => `  ${f}`).join('\n'),
+                    };
                 }
+                this._logger.log(`Updating worktree to ${resolvedCommit.toShort()}`);
+                await git.worktrees.checkout(slot.worktreePath, resolvedCommit);
             }
             else {
                 this._logger.log(`Worktree already at ${resolvedCommit.toShort()}`);
             }
+            const poolConfig = this._config.worktreePool;
+            await installDependencies(slot.worktreePath, poolConfig.setup, this._logger);
+            this._dynamicSessionMeta.set(name, { ref, worktreePath: slot.worktreePath });
+            await this._createWorktreeExplorerSession(name, slot.worktreePath);
+            this._addDynamicRefWatcher(name, resolver);
+            this._emit({ type: 'session-change' });
+            return { sessions: this.getSessionInfos() };
+        }
+        catch (e) {
+            this._worktreePool.release(name);
+            this._resolvers.get(name)?.dispose();
+            this._resolvers.delete(name);
+            this._dynamicSessionMeta.delete(name);
+            const msg = e instanceof Error ? e.message : String(e);
+            this._logger.log(`Failed to open session "${name}": ${msg}`);
+            return { error: `Failed to open session: ${msg}` };
         }
-        this._logger.log(`Starting server: ${sessionConfig.name}`);
-        const session = await ExplorerSession.create(sessionConfig.name, sessionConfig.viteProject, this._serverFactory, this._browserFactory, {
-            logger: this._logger,
-            resolveViteFrom: sessionConfig.source.kind === 'worktree' ? resolveViteFrom : undefined,
-            hmrAllowedPaths: this._config.viteHmr?.allowedPaths,
-        });
-        this._sessions.set(sessionConfig.name, session);
-        this._logger.log(`Server ready: ${sessionConfig.name} (${session.serverUrl})`);
     }
-}
-// ---------------------------------------------------------------------------
-// EventStreamLogger — wraps a base logger and also emits log events
-// ---------------------------------------------------------------------------
-class EventStreamLogger {
-    _base;
-    _emitter;
-    constructor(_base) {
-        this._base = _base;
+    async _closeDynamicSession(name) {
+        if (!this._dynamicSessionMeta.has(name)) {
+            if (this._sessionConfigs.has(name)) {
+                return { error: `Session "${name}" is a static session and cannot be closed` };
+            }
+            return { error: `Session "${name}" does not exist` };
+        }
+        const session = this._sessions.get(name);
+        if (session) {
+            this._logger.debug(`Disposing session: ${name}`);
+            await session.dispose();
+            this._sessions.delete(name);
+        }
+        const resolver = this._resolvers.get(name);
+        if (resolver) {
+            resolver.dispose();
+            this._resolvers.delete(name);
+        }
+        // Remove any ref watcher disposable
+        const watcherDisposable = this._dynamicRefWatchers.get(name);
+        if (watcherDisposable) {
+            watcherDisposable.dispose();
+            this._dynamicRefWatchers.delete(name);
+        }
+        if (this._worktreePool) {
+            this._worktreePool.release(name);
+        }
+        this._dynamicSessionMeta.delete(name);
+        this._logger.log(`Session "${name}" closed`);
+        this._emit({ type: 'session-change' });
+        return { sessions: this.getSessionInfos() };
     }
-    log(message) { this.info(message); }
-    info(message) {
-        this._base.info(message);
-        this._emitter?.({ type: 'log', level: 'info', message });
+    async _updateDynamicSessionRef(name, newRef) {
+        const meta = this._dynamicSessionMeta.get(name);
+        if (!meta) {
+            if (this._sessionConfigs.has(name)) {
+                return { error: `Session "${name}" is a static session — use restartSession instead` };
+            }
+            return { error: `Session "${name}" does not exist` };
+        }
+        const git = this._config.repo;
+        // Check dirty before doing anything
+        const wtInfo = await git.worktrees.info(meta.worktreePath);
+        if (wtInfo && wtInfo.isDirty) {
+            return {
+                error: `Worktree is dirty, cannot update ref. Dirty files:\n` +
+                    wtInfo.dirtyFiles.map(f => `  ${f}`).join('\n'),
+            };
+        }
+        // Dispose old resolver
+        const oldResolver = this._resolvers.get(name);
+        if (oldResolver) {
+            oldResolver.dispose();
+            this._resolvers.delete(name);
+        }
+        const oldWatcher = this._dynamicRefWatchers.get(name);
+        if (oldWatcher) {
+            oldWatcher.dispose();
+            this._dynamicRefWatchers.delete(name);
+        }
+        try {
+            const isIndex = newRef === GitIndexResolver.INDEX_REF;
+            let resolver;
+            if (isIndex) {
+                resolver = await git.createIndexResolver();
+            }
+            else {
+                resolver = await git.createCommitResolver(newRef);
+            }
+            this._resolvers.set(name, resolver);
+            const resolvedCommit = resolver.resolvedCommit.get();
+            // Checkout in worktree — don't restart Vite, let HMR handle it
+            if (wtInfo) {
+                if (!wtInfo.checkedOutCommit.equals(resolvedCommit)) {
+                    await git.worktrees.checkout(meta.worktreePath, resolvedCommit);
+                }
+            }
+            else {
+                await git.worktrees.create(meta.worktreePath, resolvedCommit);
+            }
+            const sessionConfig = this._sessionConfigs.get(name);
+            const installSetup = (sessionConfig?.source.kind === 'worktree' ? sessionConfig.source.install : undefined)
+                ?? this._config.worktreePool?.setup
+                ?? { kind: 'auto' };
+            await installDependencies(meta.worktreePath, installSetup, this._logger);
+            meta.ref = newRef;
+            this._addDynamicRefWatcher(name, resolver);
+            return { sessions: this.getSessionInfos() };
+        }
+        catch (e) {
+            if (e instanceof DirtyWorktreeError) {
+                return {
+                    error: `Worktree is dirty, cannot update ref. Dirty files:\n` +
+                        e.dirtyFiles.map(f => `  ${f}`).join('\n'),
+                };
+            }
+            const msg = e instanceof Error ? e.message : String(e);
+            this._logger.log(`Failed to update session ref "${name}": ${msg}`);
+            return { error: `Failed to update session ref: ${msg}` };
+        }
     }
-    debug(message) {
-        this._base.debug(message);
-        this._emitter?.({ type: 'log', level: 'debug', message });
+    _dynamicRefWatchers = new Map();
+    _addDynamicRefWatcher(sessionName, resolver) {
+        let previousCommit = resolver.resolvedCommit.get();
+        const disposable = autorun(reader => {
+            const commit = resolver.resolvedCommit.read(reader);
+            if (!previousCommit.equals(commit)) {
+                const prev = previousCommit;
+                previousCommit = commit;
+                this._handleRefChange(sessionName, resolver.ref, prev, commit);
+            }
+        });
+        this._dynamicRefWatchers.set(sessionName, disposable);
+    }
+}
+function arraysEqual(a, b) {
+    if (a.length !== b.length) {
+        return false;
     }
-    trace(message) {
-        this._base.trace(message);
-        this._emitter?.({ type: 'log', level: 'trace', message });
+    for (let i = 0; i < a.length; i++) {
+        if (a[i] !== b[i]) {
+            return false;
+        }
     }
+    return true;
 }
 
-export { DaemonService, SourceTreeChangedError };
+export { ActivityTracker, DaemonService, SourceTreeChangedError, daemonApiVersionText, pluginProtocolVersionText };
 //# sourceMappingURL=DaemonService.js.map