@vscode/component-explorer-cli 0.1.1-17 → 0.1.1-18

package/dist/daemon/DaemonService.js

@@ -1,4 +1,5 @@
 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';
@@ -10,11 +11,17 @@ import '../external/vscode-observables/observables/dist/observableInternal/obser
 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 { 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
@@ -90,12 +97,14 @@ class DaemonService {
     _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, _pipeName, _logger, _browserFactory, _serverFactory, approvalStorePath, idleTimeoutMs) {
@@ -106,6 +115,9 @@ class DaemonService {
         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, pipeName, options) {
@@ -114,11 +126,9 @@ class DaemonService {
         const approvalStorePath = `${config.screenshotDir}/approvals.json`;
         const idleTimeoutMs = options?.idleTimeoutMs ?? 5 * 60 * 1000; // 5 minutes default
         const svc = new DaemonService(config, pipeName ?? '', logger, browserFactory, serverFactory, approvalStorePath, idleTimeoutMs);
-        const currentSession = config.sessions.find(s => s.source.kind === 'current');
-        const resolveViteFrom = currentSession?.viteProject.cwd;
         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;
     }
@@ -172,7 +182,10 @@ class DaemonService {
                             image: (args.includeImage ?? true)
                                 ? Buffer.from(result.screenshots[result.screenshots.length - 1].image).toString('base64')
                                 : undefined,
-                            errors: result.errors.length > 0 ? result.errors : undefined,
+                            hasError: result.hasError,
+                            error: result.error,
+                            events: result.events.length > 0 ? result.events : undefined,
+                            resultData: result.resultData,
                             isStable,
                             stabilityScreenshots,
                         };
@@ -185,7 +198,10 @@ class DaemonService {
                         image: (args.includeImage ?? true)
                             ? Buffer.from(result.image).toString('base64')
                             : undefined,
-                        errors: result.errors.length > 0 ? result.errors : undefined,
+                        hasError: result.hasError,
+                        error: result.error,
+                        events: result.events?.length > 0 ? result.events : undefined,
+                        resultData: result.resultData,
                     };
                 }),
                 takeBatch: createMethod({
@@ -212,7 +228,10 @@ class DaemonService {
                             image: includeImages
                                 ? Buffer.from(result.image).toString('base64')
                                 : undefined,
-                            errors: result.errors.length > 0 ? result.errors : 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`);
@@ -248,8 +267,14 @@ class DaemonService {
                             ? Buffer.from(baselineResult.image).toString('base64') : undefined,
                         currentImage: includeImages
                             ? Buffer.from(currentResult.image).toString('base64') : undefined,
-                        baselineErrors: baselineResult.errors.length > 0 ? baselineResult.errors : undefined,
-                        currentErrors: currentResult.errors.length > 0 ? currentResult.errors : 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,
                         approval: (baselineHash !== currentHash)
                             ? this.approvals.lookup({
                                 fixtureId: args.fixtureId,
@@ -322,6 +347,48 @@ class DaemonService {
                 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();
+            }),
+            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();
@@ -337,18 +404,56 @@ class DaemonService {
         return session;
     }
     getSessionInfos(reader) {
-        return this._config.sessions.map(sc => {
+        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);
+            const meta = this._dynamicSessionMeta.get(sc.name);
             if (!session) {
-                return { name: sc.name, sourceKind: sc.source.kind, isLoading: true };
+                infos.push({ name: sc.name, sourceKind: sc.source.kind, isLoading: true });
             }
-            return {
-                name: sc.name,
-                sourceKind: sc.source.kind,
-                serverUrl: session.serverUrl,
-                sourceTreeId: reader ? session.sourceTreeId.read(reader).value : session.sourceTreeId.get().value,
-            };
-        });
+            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 => {
@@ -447,66 +552,44 @@ 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) {
-                    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);
-        }
-        // 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);
         }
     }
+    _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, 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') {
+        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);
-        if (oldSession) {
-            this._logger.debug(`Disposing session: ${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() });
     }
     // -- Shutdown ------------------------------------------------------------
@@ -524,6 +607,10 @@ class DaemonService {
             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();
         }
@@ -539,48 +626,286 @@ class DaemonService {
             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() };
         }
-        this._logger.log(`Starting server: ${sessionConfig.name}`);
-        // Set daemon config env var so the Vite plugin enables the daemon proxy
-        process.env.COMPONENT_EXPLORER_DAEMON_CONFIG = JSON.stringify({
-            pipeName: this._pipeName,
-            sessionName: 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,
+        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}` };
+        }
+    }
+    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() };
+    }
+    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}` };
+        }
+    }
+    _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)) {
+                previousCommit = commit;
+                this._handleRefChange(sessionName, resolver.ref, commit);
+            }
         });
-        this._sessions.set(sessionConfig.name, session);
-        this._logger.debug(`Session ready: ${sessionConfig.name} (${session.serverUrl})`);
+        this._dynamicRefWatchers.set(sessionName, disposable);
     }
 }
 
-export { ActivityTracker, DaemonService, SourceTreeChangedError };
+export { ActivityTracker, DaemonService, SourceTreeChangedError, daemonApiVersionText, pluginProtocolVersionText };
 //# sourceMappingURL=DaemonService.js.map