@pimote/pimote 0.1.0

package/server/dist/paths.js

@@ -0,0 +1,14 @@
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+function getXdgConfigHome() {
+    return process.env.XDG_CONFIG_HOME || join(homedir(), '.config');
+}
+function getXdgStateHome() {
+    return process.env.XDG_STATE_HOME || join(homedir(), '.local', 'state');
+}
+export const PIMOTE_CONFIG_DIR = join(getXdgConfigHome(), 'pimote');
+export const PIMOTE_STATE_DIR = join(getXdgStateHome(), 'pimote');
+export const PIMOTE_CONFIG_PATH = join(PIMOTE_CONFIG_DIR, 'config.json');
+export const PIMOTE_PUSH_SUBSCRIPTIONS_PATH = join(PIMOTE_STATE_DIR, 'push-subscriptions.json');
+export const PIMOTE_SESSION_METADATA_PATH = join(PIMOTE_STATE_DIR, 'session-metadata.json');
+export const LEGACY_PIMOTE_PUSH_SUBSCRIPTIONS_PATH = join(PIMOTE_CONFIG_DIR, 'push-subscriptions.json');

package/server/dist/push-infrastructure.js

@@ -0,0 +1,73 @@
+import { readFile, writeFile, mkdir, rename, copyFile, unlink } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import webpush from 'web-push';
+async function exists(path) {
+    try {
+        await readFile(path);
+        return true;
+    }
+    catch (err) {
+        if (err && typeof err === 'object' && 'code' in err && err.code === 'ENOENT') {
+            return false;
+        }
+        throw err;
+    }
+}
+export async function migratePushSubscriptionStore(oldPath, newPath) {
+    if (oldPath === newPath)
+        return;
+    if (await exists(newPath))
+        return;
+    if (!(await exists(oldPath)))
+        return;
+    await mkdir(dirname(newPath), { recursive: true });
+    try {
+        await rename(oldPath, newPath);
+    }
+    catch (err) {
+        if (err && typeof err === 'object' && 'code' in err && err.code === 'EXDEV') {
+            await copyFile(oldPath, newPath);
+            await unlink(oldPath);
+            return;
+        }
+        throw new Error('Failed to migrate push subscriptions', { cause: err });
+    }
+}
+export class FilePushSubscriptionStore {
+    filePath;
+    constructor(filePath) {
+        this.filePath = filePath;
+    }
+    async load() {
+        try {
+            const raw = await readFile(this.filePath, 'utf-8');
+            return JSON.parse(raw);
+        }
+        catch (err) {
+            if (err && typeof err === 'object' && 'code' in err && err.code === 'ENOENT') {
+                return [];
+            }
+            throw new Error('Failed to load push subscriptions', { cause: err });
+        }
+    }
+    async save(subscriptions) {
+        try {
+            await mkdir(dirname(this.filePath), { recursive: true });
+            const tmpPath = this.filePath + '.tmp';
+            await writeFile(tmpPath, JSON.stringify(subscriptions, null, 2) + '\n', 'utf-8');
+            await rename(tmpPath, this.filePath);
+        }
+        catch {
+            throw new Error('Failed to save push subscriptions');
+        }
+    }
+}
+export class WebPushSender {
+    constructor(vapidPublicKey, vapidPrivateKey, vapidEmail) {
+        webpush.setVapidDetails('mailto:' + vapidEmail, vapidPublicKey, vapidPrivateKey);
+    }
+    async sendNotification(subscription, payload) {
+        const response = await webpush.sendNotification(subscription, payload);
+        return { statusCode: response.statusCode };
+    }
+}

package/server/dist/push-notification.js

@@ -0,0 +1,56 @@
+export class PushNotificationService {
+    sender;
+    store;
+    subscriptions = [];
+    constructor(sender, store) {
+        this.sender = sender;
+        this.store = store;
+    }
+    /** Load subscriptions from store on startup */
+    async initialize() {
+        this.subscriptions = await this.store.load();
+    }
+    /** Store a new push subscription (or update if endpoint matches) */
+    async addSubscription(subscription) {
+        const idx = this.subscriptions.findIndex((s) => s.endpoint === subscription.endpoint);
+        if (idx !== -1) {
+            this.subscriptions[idx] = subscription;
+        }
+        else {
+            this.subscriptions.push(subscription);
+        }
+        await this.store.save(this.subscriptions);
+    }
+    /** Remove a subscription by endpoint */
+    async removeSubscription(endpoint) {
+        const before = this.subscriptions.length;
+        this.subscriptions = this.subscriptions.filter((s) => s.endpoint !== endpoint);
+        if (this.subscriptions.length !== before) {
+            await this.store.save(this.subscriptions);
+        }
+    }
+    /** Get all current subscriptions */
+    getSubscriptions() {
+        return [...this.subscriptions];
+    }
+    /** Send push notification to all subscriptions */
+    async notify(payload) {
+        const expiredEndpoints = [];
+        const payloadStr = JSON.stringify(payload);
+        for (const sub of this.subscriptions) {
+            try {
+                const result = await this.sender.sendNotification(sub, payloadStr);
+                if (result.statusCode === 410) {
+                    expiredEndpoints.push(sub.endpoint);
+                }
+            }
+            catch (err) {
+                console.warn('[PushNotificationService] Failed to send notification:', err.message ?? err);
+            }
+        }
+        if (expiredEndpoints.length > 0) {
+            this.subscriptions = this.subscriptions.filter((s) => !expiredEndpoints.includes(s.endpoint));
+            await this.store.save(this.subscriptions);
+        }
+    }
+}

package/server/dist/server.js

@@ -0,0 +1,223 @@
+import http from 'node:http';
+import { readFile, stat } from 'node:fs/promises';
+import { join, extname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { WebSocketServer } from 'ws';
+import { WsHandler } from './ws-handler.js';
+import crypto from 'node:crypto';
+const __dirname = fileURLToPath(new URL('.', import.meta.url));
+const CLIENT_DIR = process.env.CLIENT_DIR || join(__dirname, '..', '..', 'client', 'build');
+/** Read the SvelteKit build version from _app/version.json. Returns null if unavailable. */
+async function loadClientVersion() {
+    try {
+        const raw = await readFile(join(CLIENT_DIR, '_app', 'version.json'), 'utf-8');
+        const data = JSON.parse(raw);
+        return data.version ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+const MIME_TYPES = {
+    '.html': 'text/html; charset=utf-8',
+    '.js': 'application/javascript; charset=utf-8',
+    '.css': 'text/css; charset=utf-8',
+    '.json': 'application/json; charset=utf-8',
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.svg': 'image/svg+xml',
+    '.woff': 'font/woff',
+    '.woff2': 'font/woff2',
+    '.ico': 'image/x-icon',
+    '.webmanifest': 'application/manifest+json',
+};
+/** Try to serve a static file from CLIENT_DIR. Returns true if served. */
+async function serveStatic(req, res) {
+    const urlPath = req.url === '/' ? '/index.html' : req.url.split('?')[0];
+    const filePath = join(CLIENT_DIR, urlPath);
+    // Prevent directory traversal — ensure path is within CLIENT_DIR
+    if (!filePath.startsWith(CLIENT_DIR + '/') && filePath !== CLIENT_DIR) {
+        return false;
+    }
+    try {
+        const stats = await stat(filePath);
+        if (stats.isFile()) {
+            const ext = extname(filePath);
+            const mime = MIME_TYPES[ext] || 'application/octet-stream';
+            const content = await readFile(filePath);
+            const headers = { 'Content-Type': mime };
+            // HTML, SW, and manifest must not be cached by CDN/proxies.
+            // Immutable hashed assets (_app/immutable/) are safe to cache.
+            if (urlPath === '/sw.js' || urlPath === '/pwa/manifest.json' || ext === '.html') {
+                headers['Cache-Control'] = 'no-cache, no-store, must-revalidate';
+                headers['CDN-Cache-Control'] = 'no-store';
+                headers['Cloudflare-CDN-Cache-Control'] = 'no-store';
+            }
+            else if (urlPath.startsWith('/_app/immutable/')) {
+                headers['Cache-Control'] = 'public, max-age=31536000, immutable';
+            }
+            res.writeHead(200, headers);
+            res.end(content);
+            return true;
+        }
+    }
+    catch {
+        // File not found — fall through
+    }
+    return false;
+}
+/** Serve index.html as SPA fallback. */
+async function serveFallback(res) {
+    try {
+        const indexPath = join(CLIENT_DIR, 'index.html');
+        const content = await readFile(indexPath);
+        res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+        res.end(content);
+    }
+    catch {
+        res.writeHead(404, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'not found' }));
+    }
+}
+export async function createServer(config, sessionManager, folderIndex, pushNotificationService, sessionMetadataStore) {
+    const clientVersion = await loadClientVersion();
+    if (clientVersion) {
+        console.log(`[pimote] Client build version: ${clientVersion}`);
+    }
+    else {
+        console.warn(`[pimote] Could not read client build version from ${CLIENT_DIR}/_app/version.json`);
+    }
+    const httpServer = http.createServer(async (req, res) => {
+        // 1. Health check
+        if (req.method === 'GET' && req.url === '/health') {
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ status: 'ok' }));
+            return;
+        }
+        // 2. VAPID public key for push notification subscription
+        if (req.method === 'GET' && req.url === '/api/vapid-key') {
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ publicKey: config.vapidPublicKey ?? '' }));
+            return;
+        }
+        // 3. Static file lookup
+        if (req.method === 'GET') {
+            const served = await serveStatic(req, res);
+            if (served)
+                return;
+        }
+        // 4. SPA fallback — serve index.html for unmatched GET routes
+        if (req.method === 'GET') {
+            await serveFallback(res);
+            return;
+        }
+        res.writeHead(404, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'not found' }));
+    });
+    // Wire up session manager callbacks for sidebar broadcasts
+    sessionManager.onStatusChange = (sessionId, folderPath) => {
+        WsHandler.broadcastSidebarUpdate(sessionId, folderPath, sessionManager, clientRegistry);
+    };
+    sessionManager.onSessionClosed = (sessionId, folderPath) => {
+        WsHandler.broadcastSidebarUpdate(sessionId, folderPath, sessionManager, clientRegistry);
+    };
+    const wss = new WebSocketServer({ noServer: true });
+    const clientRegistry = new Map();
+    httpServer.on('upgrade', (req, socket, head) => {
+        const url = new URL(req.url ?? '', `http://${req.headers.host}`);
+        if (url.pathname === '/ws') {
+            wss.handleUpgrade(req, socket, head, (ws) => {
+                wss.emit('connection', ws, req);
+            });
+        }
+        else {
+            socket.destroy();
+        }
+    });
+    wss.on('connection', (ws, req) => {
+        const url = new URL(req.url ?? '', `http://${req.headers.host}`);
+        const clientId = url.searchParams.get('clientId') ?? crypto.randomUUID();
+        console.log(`[pimote] WebSocket client connected (clientId=${clientId})`);
+        // Version check — if the client's build version doesn't match the server's,
+        // send a version_mismatch event and close. The client will reload.
+        const incomingVersion = url.searchParams.get('version');
+        if (clientVersion && incomingVersion && incomingVersion !== clientVersion) {
+            console.log(`[pimote] Version mismatch: client=${incomingVersion}, server=${clientVersion} — requesting reload`);
+            const event = { type: 'version_mismatch', serverVersion: clientVersion };
+            ws.send(JSON.stringify(event), () => ws.close());
+            return;
+        }
+        // Register new handler first, then clean up and close any stale connection.
+        // cleanup() disconnects the old handler's WebSocket routing (sets slot.connection = null).
+        // Pending UI responses survive on the ManagedSlot for replay when the new
+        // handler's reconnect commands reclaim sessions via claimSession().
+        // The close handler skips cleanup when the registry already points to a
+        // different handler, so this is the only place it runs.
+        const existing = clientRegistry.get(clientId);
+        const handler = new WsHandler(sessionManager, folderIndex, ws, pushNotificationService, sessionMetadataStore, clientId, clientRegistry);
+        clientRegistry.set(clientId, handler);
+        if (existing) {
+            existing.cleanup();
+            existing.closeWebSocket();
+        }
+        ws.on('message', (data) => {
+            handler.handleMessage(data.toString()).catch((err) => {
+                console.error('[pimote] Unhandled error in message handler:', err);
+            });
+        });
+        ws.on('close', () => {
+            console.log(`[pimote] WebSocket client disconnected (clientId=${clientId})`);
+            // Only clean up if this handler is still the current entry.
+            // If a new handler replaced us (stale-connection reconnect), the new
+            // handler owns the sessions — don't orphan them.
+            if (clientRegistry.get(clientId) === handler) {
+                clientRegistry.delete(clientId);
+                handler.cleanup();
+            }
+        });
+    });
+    return {
+        httpServer,
+        wss,
+        clientRegistry,
+        start(port) {
+            return new Promise((resolve) => {
+                httpServer.listen(port, () => {
+                    resolve();
+                });
+            });
+        },
+        close() {
+            return new Promise((resolve, reject) => {
+                // Force-close all active WebSocket connections
+                wss.clients.forEach((client) => {
+                    client.close();
+                });
+                // Close the WebSocket server with a timeout to prevent hanging
+                const timeout = setTimeout(() => {
+                    console.warn('[pimote] WebSocket server close timeout — forcing shutdown');
+                    httpServer.close((err) => {
+                        if (err)
+                            reject(err);
+                        else
+                            resolve();
+                    });
+                }, 5000);
+                wss.close((err) => {
+                    clearTimeout(timeout);
+                    if (err) {
+                        reject(err);
+                    }
+                    else {
+                        httpServer.close((err) => {
+                            if (err)
+                                reject(err);
+                            else
+                                resolve();
+                        });
+                    }
+                });
+            });
+        },
+    };
+}

package/server/dist/session-manager.js

@@ -0,0 +1,313 @@
+import { createAgentSessionRuntime, createAgentSessionServices, createAgentSessionFromServices, createEventBus, AuthStorage, ModelRegistry, getAgentDir, SessionManager as PiSessionManager, } from '@mariozechner/pi-coding-agent';
+import { EventBuffer } from './event-buffer.js';
+import { applyPanelMessage, getMergedPanelCards } from './panel-state.js';
+// ---- Slot-based helpers (operate on ManagedSlot) ----
+/** Send an event to the client connected to this slot. No-op if disconnected. */
+export function sendSlotEvent(slot, event) {
+    const ws = slot.connection?.ws;
+    if (!ws || ws.readyState !== 1)
+        return;
+    try {
+        ws.send(JSON.stringify(event));
+    }
+    catch {
+        // WebSocket send failed — ignore (client disconnecting)
+    }
+}
+/** Create a pending promise for a UI dialog response. Stores the request event for replay on reconnect. */
+export function waitForSlotUiResponse(slot, requestId, requestEvent) {
+    return new Promise((resolve) => {
+        slot.sessionState.pendingUiResponses.set(requestId, { resolve, event: requestEvent });
+    });
+}
+/** Resolve a specific pending UI response by requestId. */
+export function resolveSlotPendingUi(slot, requestId, value) {
+    const pending = slot.sessionState.pendingUiResponses.get(requestId);
+    if (pending) {
+        slot.sessionState.pendingUiResponses.delete(requestId);
+        pending.resolve(value);
+    }
+}
+/** Resolve all pending UI responses with undefined. Used on abort, session close, or session reset. */
+export function resolveAllSlotPendingUi(slot) {
+    for (const [, pending] of slot.sessionState.pendingUiResponses) {
+        pending.resolve(undefined);
+    }
+    slot.sessionState.pendingUiResponses.clear();
+}
+/** Re-send all pending UI request events to the current client. Called on reconnect to recover lost dialogs. */
+export function replaySlotPendingUiRequests(slot) {
+    for (const [, pending] of slot.sessionState.pendingUiResponses) {
+        sendSlotEvent(slot, pending.event);
+    }
+}
+// ---- Slot-based session state lifecycle helpers ----
+/** Construct a SessionState from an AgentSession and EventBus.
+ *  Subscribes to session events and sets up panel listeners. */
+function createSessionState(session, eventBus, config, callbacks, slotRef, folderPath) {
+    const sessionId = session.sessionId;
+    const eventBuffer = new EventBuffer(config.bufferSize);
+    const state = {
+        id: sessionId,
+        eventBuffer,
+        status: session.isStreaming ? 'working' : 'idle',
+        needsAttention: false,
+        lastActivity: Date.now(),
+        unsubscribe: () => { },
+        pendingUiResponses: new Map(),
+        extensionsBound: false,
+        panelState: new Map(),
+        panelListenerUnsubs: [],
+        panelThrottleTimer: null,
+    };
+    // Subscribe to session events
+    const unsubscribe = session.subscribe((event) => {
+        if (event.type === 'agent_start' && state.status !== 'working') {
+            state.status = 'working';
+            callbacks.onStatusChange?.(sessionId, folderPath);
+        }
+        else if (event.type === 'agent_end' && state.status !== 'idle') {
+            state.status = 'idle';
+            state.needsAttention = true;
+            if (slotRef.slot)
+                callbacks.onAgentEnd?.(sessionId, slotRef.slot);
+            callbacks.onStatusChange?.(sessionId, folderPath);
+        }
+        eventBuffer.onEvent(event, sessionId, (e) => callbacks.sendEvent(e), () => session.messages[session.messages.length - 1]);
+    });
+    state.unsubscribe = unsubscribe;
+    // Set up panel listeners on the EventBus
+    state.panelListenerUnsubs = setupSlotPanelListeners(eventBus, state, sessionId, callbacks.sendEvent);
+    return state;
+}
+/** Clean up a SessionState: resolve pending UI, clear timers, unsubscribe listeners. */
+function teardownSessionState(state) {
+    // Resolve all pending UI responses
+    for (const [, pending] of state.pendingUiResponses) {
+        pending.resolve(undefined);
+    }
+    state.pendingUiResponses.clear();
+    // Clear panel throttle timer
+    if (state.panelThrottleTimer)
+        clearTimeout(state.panelThrottleTimer);
+    // Remove panel listeners
+    for (const unsub of state.panelListenerUnsubs)
+        unsub();
+    state.panelListenerUnsubs = [];
+    // Unsubscribe from session events
+    state.unsubscribe();
+}
+/** Register panel detection and data listeners for a SessionState on an EventBus. */
+function setupSlotPanelListeners(eventBus, state, sessionId, sendEvent) {
+    const unsub1 = eventBus.on('pimote:detect:request', () => {
+        eventBus.emit('pimote:detect:response', { detected: true });
+    });
+    const unsub2 = eventBus.on('pimote:panels', (data) => {
+        applyPanelMessage(state.panelState, data);
+        scheduleSlotPanelPush(state, sessionId, sendEvent);
+    });
+    return [unsub1, unsub2];
+}
+/** Schedule a throttled panel push (~200ms) for a SessionState. */
+function scheduleSlotPanelPush(state, sessionId, sendEvent) {
+    if (state.panelThrottleTimer !== null)
+        return;
+    state.panelThrottleTimer = setTimeout(() => {
+        state.panelThrottleTimer = null;
+        const cards = getMergedPanelCards(state.panelState);
+        sendEvent({ type: 'panel_update', sessionId, cards });
+    }, 200);
+}
+export class PimoteSessionManager {
+    config;
+    pushNotificationService;
+    authStorage;
+    modelRegistry;
+    sessions = new Map();
+    idleCheckHandle = null;
+    onStatusChange;
+    onSessionClosed;
+    constructor(config, pushNotificationService) {
+        this.config = config;
+        this.pushNotificationService = pushNotificationService;
+        this.authStorage = AuthStorage.create();
+        this.modelRegistry = ModelRegistry.create(this.authStorage);
+    }
+    async openSession(folderPath, sessionFilePath) {
+        const eventBusRef = { current: null };
+        const sharedAuthStorage = this.authStorage;
+        const sharedModelRegistry = this.modelRegistry;
+        const factory = async ({ cwd, agentDir, sessionManager, sessionStartEvent }) => {
+            const eventBus = createEventBus();
+            eventBusRef.current = eventBus;
+            const services = await createAgentSessionServices({
+                cwd,
+                agentDir,
+                authStorage: sharedAuthStorage,
+                modelRegistry: sharedModelRegistry,
+                resourceLoaderOptions: { eventBus },
+            });
+            return {
+                ...(await createAgentSessionFromServices({ services, sessionManager, sessionStartEvent })),
+                services,
+                diagnostics: services.diagnostics,
+            };
+        };
+        const runtime = await createAgentSessionRuntime(factory, {
+            cwd: folderPath,
+            agentDir: getAgentDir(),
+            sessionManager: sessionFilePath ? PiSessionManager.open(sessionFilePath) : PiSessionManager.create(folderPath),
+        });
+        const session = runtime.session;
+        const sessionId = session.sessionId;
+        // Diagnostics: log model registry state after factory has loaded extensions
+        const availableModels = this.modelRegistry.getAvailable();
+        console.log(`[pimote] openSession: ${availableModels.length} models available, session model: ${session.model ? `${session.model.provider}/${session.model.id}` : 'none'}`);
+        // Apply default model from config (only for new sessions without an existing model preference)
+        if (!sessionFilePath && this.config.defaultProvider && this.config.defaultModel) {
+            const models = this.modelRegistry.getAvailable();
+            const defaultModel = models.find((m) => m.provider === this.config.defaultProvider && m.id === this.config.defaultModel);
+            if (defaultModel) {
+                await session.setModel(defaultModel);
+                console.log(`[pimote] Set default model: ${defaultModel.provider}/${defaultModel.id}`);
+            }
+            else {
+                console.warn(`[pimote] Default model not found: ${this.config.defaultProvider}/${this.config.defaultModel}`);
+            }
+        }
+        // Apply default thinking level from config
+        if (!sessionFilePath && this.config.defaultThinkingLevel) {
+            session.setThinkingLevel(this.config.defaultThinkingLevel);
+            console.log(`[pimote] Set default thinking level: ${this.config.defaultThinkingLevel}`);
+        }
+        // Create the slot object. Use a slotRef so createSessionState callbacks can reference the slot.
+        const slotRef = { slot: null };
+        const sessionState = createSessionState(session, eventBusRef.current, this.config, {
+            onStatusChange: (sid, fp) => this.onStatusChange?.(sid, fp),
+            onAgentEnd: (sid, s) => this.handleAgentEnd(sid, s),
+            sendEvent: (e) => sendSlotEvent(slot, e),
+        }, slotRef, folderPath);
+        const slot = {
+            runtime,
+            folderPath,
+            eventBusRef,
+            connection: null,
+            sessionState,
+            get session() {
+                return this.runtime.session;
+            },
+        };
+        slotRef.slot = slot;
+        this.sessions.set(sessionId, slot);
+        return sessionId;
+    }
+    handleAgentEnd(sessionId, slot) {
+        const folderPath = slot.folderPath;
+        const projectName = folderPath.split('/').pop() ?? 'Unknown';
+        const firstMessage = this.extractFirstMessage(slot);
+        const lastAgentMessage = this.extractLastAgentMessage(slot);
+        this.pushNotificationService
+            .notify({
+            projectName,
+            folderPath,
+            sessionId,
+            sessionName: slot.session.sessionName,
+            firstMessage,
+            reason: 'idle',
+            lastAgentMessage,
+        })
+            .catch((err) => console.error('[SessionManager] Push notification error:', err));
+    }
+    extractLastAgentMessage(slot) {
+        const messages = slot.session.messages ?? [];
+        for (let i = messages.length - 1; i >= 0; i--) {
+            const msg = messages[i];
+            if (msg.role !== 'assistant')
+                continue;
+            const text = msg.content
+                .filter((c) => c.type === 'text')
+                .map((c) => c.text)
+                .join('');
+            if (text)
+                return text.slice(0, 200);
+            break;
+        }
+        return undefined;
+    }
+    extractFirstMessage(slot) {
+        const messages = slot.session.messages ?? [];
+        for (const msg of messages) {
+            if (msg.role !== 'user')
+                continue;
+            const { content } = msg;
+            if (typeof content === 'string')
+                return content.slice(0, 100);
+            if (Array.isArray(content)) {
+                for (const c of content) {
+                    if (c.type === 'text')
+                        return c.text.slice(0, 100);
+                }
+            }
+            break;
+        }
+        return undefined;
+    }
+    async closeSession(sessionId) {
+        const slot = this.sessions.get(sessionId);
+        if (!slot)
+            return;
+        teardownSessionState(slot.sessionState);
+        slot.eventBusRef.current?.clear();
+        const folderPath = slot.folderPath;
+        await slot.runtime.dispose();
+        this.sessions.delete(sessionId);
+        this.onSessionClosed?.(sessionId, folderPath);
+    }
+    /** Re-key a slot in the session map after session replacement. */
+    reKeySession(slot, oldId, newId) {
+        this.sessions.delete(oldId);
+        this.sessions.set(newId, slot);
+    }
+    /** Rebuild a slot's SessionState after session replacement.
+     *  Tears down the old state and creates a new one from the current runtime.session. */
+    rebuildSessionState(slot) {
+        teardownSessionState(slot.sessionState);
+        const slotRef = { slot: slot };
+        slot.sessionState = createSessionState(slot.runtime.session, slot.eventBusRef.current, this.config, {
+            onStatusChange: (sid, fp) => this.onStatusChange?.(sid, fp),
+            onAgentEnd: (sid, s) => this.handleAgentEnd(sid, s),
+            sendEvent: (e) => sendSlotEvent(slot, e),
+        }, slotRef, slot.folderPath);
+    }
+    getSession(sessionId) {
+        return this.sessions.get(sessionId);
+    }
+    getAllSessions() {
+        return Array.from(this.sessions.values());
+    }
+    startIdleCheck(idleTimeout, isClientConnected) {
+        this.stopIdleCheck();
+        this.idleCheckHandle = setInterval(() => {
+            for (const [sessionId, slot] of this.sessions) {
+                const clientId = slot.connection?.connectedClientId ?? null;
+                const hasConnectedClient = clientId !== null && (isClientConnected?.(clientId) ?? false);
+                if (!hasConnectedClient && Date.now() - slot.sessionState.lastActivity > idleTimeout) {
+                    this.closeSession(sessionId).catch(() => {
+                        // Best-effort cleanup — swallow errors during idle reaping
+                    });
+                }
+            }
+        }, 60_000);
+    }
+    stopIdleCheck() {
+        if (this.idleCheckHandle !== null) {
+            clearInterval(this.idleCheckHandle);
+            this.idleCheckHandle = null;
+        }
+    }
+    async dispose() {
+        this.stopIdleCheck();
+        const sessionIds = Array.from(this.sessions.keys());
+        await Promise.all(sessionIds.map((id) => this.closeSession(id)));
+    }
+}