@agenthippo-ai/agenthippo 0.1.0

package/out/analytics/service.js

@@ -0,0 +1,1279 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnalyticsService = void 0;
+const vscode = __importStar(require("vscode"));
+const path = __importStar(require("path"));
+const fsSync = __importStar(require("fs"));
+const fs_1 = require("fs");
+const child_process_1 = require("child_process");
+const branding_1 = require("../branding");
+const indexingService_1 = require("./dashboard/indexingService");
+const performanceMonitor_1 = require("./dashboard/performanceMonitor");
+const lifecycle_1 = require("./lifecycle");
+const index_1 = require("../utils/index");
+const windowsCommandLine_1 = require("../utils/windowsCommandLine");
+/**
+ * Resolve the preferred PowerShell host on Windows. PowerShell 7 (`pwsh.exe`)
+ * fixed native-command argument quoting bugs that affect inline `bash -c`
+ * scripts containing embedded double quotes. We prefer it when present and
+ * fall back to the always-present Windows PowerShell 5.1 (`powershell.exe`).
+ *
+ * Cached for the lifetime of the extension host — pwsh install state is not
+ * expected to change mid-session, and the lookup hits the filesystem.
+ */
+let cachedWindowsPwshPath;
+function getWindowsPwshOrPowerShell() {
+    if (process.platform !== 'win32') {
+        return 'powershell.exe';
+    }
+    if (cachedWindowsPwshPath === undefined) {
+        cachedWindowsPwshPath = resolvePwshExecutable();
+    }
+    return cachedWindowsPwshPath ?? 'powershell.exe';
+}
+function resolvePwshExecutable() {
+    const candidates = [];
+    const pathDirs = (process.env.PATH ?? '').split(path.delimiter).filter(Boolean);
+    for (const dir of pathDirs) {
+        candidates.push(path.join(dir, 'pwsh.exe'));
+    }
+    const programFiles = process.env.ProgramFiles ?? 'C:\\Program Files';
+    const programFilesX86 = process.env['ProgramFiles(x86)'] ?? 'C:\\Program Files (x86)';
+    const localAppData = process.env.LOCALAPPDATA;
+    for (const major of ['7', '8']) {
+        candidates.push(path.join(programFiles, 'PowerShell', major, 'pwsh.exe'));
+        candidates.push(path.join(programFilesX86, 'PowerShell', major, 'pwsh.exe'));
+    }
+    if (localAppData) {
+        candidates.push(path.join(localAppData, 'Microsoft', 'PowerShell', 'pwsh.exe'));
+    }
+    for (const candidate of candidates) {
+        try {
+            if (fsSync.statSync(candidate).isFile()) {
+                return candidate;
+            }
+        }
+        catch {
+            // not present; continue
+        }
+    }
+    return null;
+}
+/**
+ * Manages LiteLLM Spotlight (OTEL Collector + DuckDB analytics).
+ * Provides status bar indicator and commands for managing the analytics stack.
+ */
+class AnalyticsService {
+    statusBarItem;
+    outputChannel;
+    extensionContext;
+    _status = 'stopped';
+    _lastStackStatus = { otelRunning: false, litellmRunning: false, litellmWithOtel: false };
+    indexProgress = { status: 'idle', percent: 0 };
+    indexingService;
+    performanceMonitor;
+    disposables = [];
+    lifecycleInProgress = false;
+    /**
+     * Get the current status of the analytics stack.
+     */
+    get status() {
+        return this._status;
+    }
+    healthCheckTimer = null;
+    static HEALTH_CHECK_INTERVAL = 30000; // 30 seconds
+    constructor(extensionContext, outputChannel) {
+        this.extensionContext = extensionContext;
+        this.outputChannel = outputChannel;
+        this.performanceMonitor = new performanceMonitor_1.PerformanceMonitor(outputChannel);
+        // Create status bar item
+        this.statusBarItem = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Right, 99);
+        this.statusBarItem.command = 'agentide.analytics.toggle';
+        // Register commands
+        this.registerCommands();
+        // Check if analytics has ever been configured before starting heartbeat
+        void this.initializeWithLazyHeartbeat();
+    }
+    /**
+     * Initialize with lazy heartbeat - only start periodic checks if analytics is configured.
+     * This avoids unnecessary process spawning (pgrep) when user hasn't set up analytics.
+     */
+    async initializeWithLazyHeartbeat() {
+        const isConfigured = await this.isAnalyticsConfigured();
+        if (isConfigured) {
+            // Analytics was set up - do full check and start heartbeat
+            this.updateStatusBar('checking');
+            await this.checkStatus();
+            this.startHeartbeat();
+        }
+        else {
+            // Not configured - show stopped, no heartbeat needed
+            this.updateStatusBar('stopped');
+            this.statusBarItem.show();
+            // Still check for standalone LiteLLM (not tied to analytics)
+            // This allows Language Models table to populate even without analytics setup
+            await this.detectStandaloneLiteLLM();
+        }
+        // Initialize background indexing service for dashboard
+        await this.initializeIndexingService();
+    }
+    /**
+     * Initialize background indexing service.
+     */
+    async initializeIndexingService() {
+        try {
+            const analyticsDir = this.getAnalyticsDir();
+            const tracesDir = path.join(analyticsDir, 'traces');
+            this.indexingService = new indexingService_1.IndexingService(tracesDir, this.outputChannel, this.performanceMonitor);
+            // Subscribe to indexing progress updates
+            this.disposables.push(this.indexingService.onProgressChange((progress) => {
+                this.indexProgress = progress;
+                this.updateStatusBar(this._status); // Refresh status bar with new progress
+            }));
+            // Initialize indexing service (starts file watcher, checks if re-indexing needed)
+            await this.indexingService.initialize();
+        }
+        catch (error) {
+            this.outputChannel.appendLine(`[Analytics] Failed to initialize indexing service: ${error}`);
+        }
+    }
+    /**
+     * Get IndexingService instance (for provider integration).
+     */
+    getIndexingService() {
+        return this.indexingService;
+    }
+    /**
+     * Detect standalone LiteLLM (running without analytics) and update base URL setting.
+     * This is a one-time check on startup to enable model discovery even when analytics
+     * is not configured.
+     */
+    async detectStandaloneLiteLLM() {
+        try {
+            const status = await this.getLiteLLMStatus();
+            if (status.running) {
+                this.outputChannel.appendLine('[Analytics] Detected standalone LiteLLM running');
+            }
+        }
+        catch {
+            // Best-effort only - don't block startup
+        }
+    }
+    /**
+     * Check if analytics has been configured (config files exist).
+     * This is a fast check that doesn't spawn any processes.
+     */
+    async isAnalyticsConfigured() {
+        const analyticsDir = this.getAnalyticsDir();
+        const configPath = path.join(analyticsDir, 'config', 'otel-collector.yaml');
+        try {
+            await fs_1.promises.access(configPath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Start the periodic heartbeat timer.
+     */
+    startHeartbeat() {
+        if (this.healthCheckTimer) {
+            return; // Already running
+        }
+        this.healthCheckTimer = setInterval(() => {
+            void this.checkStatus();
+        }, AnalyticsService.HEALTH_CHECK_INTERVAL);
+    }
+    registerCommands() {
+        this.disposables.push(vscode.commands.registerCommand('agentide.analytics.toggle', () => this.toggle()), vscode.commands.registerCommand('agentide.analytics.restart', () => this.restart()), vscode.commands.registerCommand('agentide.analytics.start', () => this.start()), vscode.commands.registerCommand('agentide.analytics.stop', () => this.stop()), vscode.commands.registerCommand('agentide.analytics.status', () => this.showStatus()), vscode.commands.registerCommand('agentide.analytics.query', () => this.openQueryTerminal()), vscode.commands.registerCommand('agentide.analytics.openLiteLLMConfig', () => this.openLiteLLMConfig()), 
+        // Returns true if the full analytics stack is running (used by core to skip redundant setup prompts)
+        vscode.commands.registerCommand('agentide.analytics.isRunning', () => this.checkStatus()));
+    }
+    /**
+     * Get the analytics home directory.
+     * Uses shared path utility for consistency.
+     */
+    getAnalyticsDir() {
+        return index_1.DIRS.analytics();
+    }
+    /**
+     * Get the PID file path for OTEL Collector.
+     * Uses shared PID_FILES constant for consistency.
+     */
+    getOtelPidFile() {
+        return index_1.PID_FILES.otelcol();
+    }
+    /**
+     * Get the PID file path for LiteLLM.
+     * Uses shared PID_FILES constant for consistency.
+     */
+    getLiteLLMPidFile() {
+        return index_1.PID_FILES.litellm();
+    }
+    /**
+     * Check full analytics stack status (OTEL Collector + LiteLLM).
+     * Returns true only if both services are properly configured.
+     */
+    async checkStatus() {
+        try {
+            const stackStatus = await this.getStackStatus();
+            this._lastStackStatus = stackStatus;
+            if (stackStatus.otelRunning && stackStatus.litellmWithOtel) {
+                // Full stack running properly
+                this.updateStatusBar('running');
+                return true;
+            }
+            else if (this.lifecycleInProgress) {
+                // During an explicit start/setup/restart, OTEL commonly becomes visible
+                // before LiteLLM has written its PID metadata. Keep the UI in a
+                // starting state until readiness monitoring completes.
+                this.updateStatusBar('checking');
+                return false;
+            }
+            else if (stackStatus.otelRunning || stackStatus.litellmRunning) {
+                // Partial - something is running but not fully configured
+                this.updateStatusBar('partial');
+                return false;
+            }
+            else {
+                // Nothing running
+                this.updateStatusBar('stopped');
+                return false;
+            }
+        }
+        catch {
+            this.updateStatusBar('error');
+            return false;
+        }
+    }
+    /**
+     * Get detailed status of each analytics component.
+     */
+    async getStackStatus() {
+        const otelRunning = await this.isOtelRunning();
+        const litellmStatus = await this.getLiteLLMStatus();
+        return {
+            otelRunning,
+            litellmRunning: litellmStatus.running,
+            litellmWithOtel: litellmStatus.withOtel,
+        };
+    }
+    /**
+     * Check if OTEL Collector is running via PID file.
+     * Cost: ~1-2ms (file read + signal check, no process spawn)
+     * Also cleans up stale PID files per ARCHITECTURE.md pattern.
+     */
+    async isOtelRunning() {
+        const result = await (0, index_1.checkPidFileWithCleanup)(this.getOtelPidFile());
+        return result !== null;
+    }
+    /**
+     * Check LiteLLM status via the canonical PID file written by agentide-litellm.{sh,ps1}.
+     * Cost: ~1-2ms (file read + signal check, no process spawn).
+     *
+     * PID file format: "PID\n[otel]\n[url=...]". Process detection / killing across
+     * platforms (incl. winpid) is handled inside the launcher script — this code only
+     * trusts what the launcher wrote.
+     */
+    async getLiteLLMStatus() {
+        const pidData = await (0, index_1.checkPidFileWithCleanup)(this.getLiteLLMPidFile());
+        if (!pidData) {
+            return { running: false, withOtel: false };
+        }
+        const metadata = pidData.metadata ?? [];
+        const withOtel = metadata.some(line => line.trim().toLowerCase() === 'otel');
+        const urlLine = metadata.find(line => line.startsWith('url='));
+        if (urlLine) {
+            await this.maybeUpdateLiteLLMBaseUrlValue(urlLine.slice('url='.length).trim());
+        }
+        return { running: true, withOtel };
+    }
+    async maybeUpdateLiteLLMBaseUrlValue(baseUrl) {
+        const config = vscode.workspace.getConfiguration('agentide.providers.litellm');
+        if (config.get('baseUrl')?.trim()) {
+            return;
+        }
+        const trimmed = baseUrl.trim();
+        if (!trimmed) {
+            return;
+        }
+        await config.update('baseUrl', trimmed, vscode.ConfigurationTarget.Global);
+        this.outputChannel.appendLine(`[Analytics] Auto-detected LiteLLM base URL: ${trimmed}`);
+    }
+    async waitForStackReady(timeoutMs = 30_000, intervalMs = 1_000) {
+        const deadline = Date.now() + timeoutMs;
+        let lastStatus = await this.getStackStatus();
+        while (Date.now() < deadline) {
+            lastStatus = await this.getStackStatus();
+            this._lastStackStatus = lastStatus;
+            if (lastStatus.otelRunning && lastStatus.litellmWithOtel) {
+                return lastStatus;
+            }
+            await new Promise(resolve => setTimeout(resolve, intervalMs));
+        }
+        return lastStatus;
+    }
+    async waitForStackStopped(timeoutMs = 15_000, intervalMs = 500) {
+        const deadline = Date.now() + timeoutMs;
+        let lastStatus = await this.getStackStatus();
+        while (Date.now() < deadline) {
+            lastStatus = await this.getStackStatus();
+            this._lastStackStatus = lastStatus;
+            if (!lastStatus.otelRunning && !lastStatus.litellmRunning) {
+                return lastStatus;
+            }
+            await new Promise(resolve => setTimeout(resolve, intervalMs));
+        }
+        return lastStatus;
+    }
+    async monitorStartupReadiness(reason) {
+        const stackStatus = await this.waitForStackReady();
+        this._lastStackStatus = stackStatus;
+        const status = this.deriveStatusFrom(stackStatus);
+        this.lifecycleInProgress = false;
+        this.updateStatusBar(status);
+        if (status === 'running') {
+            this.log(`Analytics stack ready after ${reason}.`);
+            vscode.window.showInformationMessage(`${branding_1.AGENTIDE_BRAND_NAME}: Spotlight ${reason === 'restart' ? 'restarted' : 'started'}.`);
+            return;
+        }
+        this.log(`Analytics stack not fully ready after ${reason} ` +
+            `(otel=${stackStatus.otelRunning}, litellm=${stackStatus.litellmRunning}, litellmWithOtel=${stackStatus.litellmWithOtel})`);
+        const choice = await vscode.window.showWarningMessage(`${branding_1.AGENTIDE_BRAND_NAME}: Spotlight ${reason === 'restart' ? 'restart' : 'start'} is not fully ready yet.`, 'Show Status');
+        if (choice === 'Show Status') {
+            await this.showStatus();
+        }
+    }
+    async monitorStopReadiness() {
+        const stackStatus = await this.waitForStackStopped();
+        this._lastStackStatus = stackStatus;
+        const status = this.deriveStatusFrom(stackStatus);
+        this.lifecycleInProgress = false;
+        this.updateStatusBar(status);
+        if (status === 'stopped') {
+            this.log('Analytics stack stopped.');
+            vscode.window.showInformationMessage(`${branding_1.AGENTIDE_BRAND_NAME}: Spotlight stopped.`);
+            return;
+        }
+        this.log(`Analytics stack not fully stopped ` +
+            `(otel=${stackStatus.otelRunning}, litellm=${stackStatus.litellmRunning}, litellmWithOtel=${stackStatus.litellmWithOtel})`);
+        const choice = await vscode.window.showWarningMessage(`${branding_1.AGENTIDE_BRAND_NAME}: Spotlight stop is not fully complete yet.`, 'Show Status');
+        if (choice === 'Show Status') {
+            await this.showStatus();
+        }
+    }
+    /**
+     * Handle status bar click.
+     * Always open a menu instantly from cached state.
+     * Heavy checks/actions run only after explicit user choice.
+     */
+    async toggle() {
+        // Don't block the click on a foreground check; act on the cached snapshot.
+        const status = this._status === 'checking'
+            ? this.deriveStatusFrom(this._lastStackStatus)
+            : this._status;
+        if (status === 'running') {
+            await this.showStatusWithRestartOption();
+        }
+        else if (status === 'partial') {
+            await this.showPartialStatusOption();
+        }
+        else {
+            await this.showStoppedStatusOption(status);
+        }
+    }
+    queueBackgroundStatusRefresh(reason) {
+        if (this.lifecycleInProgress) {
+            return;
+        }
+        setTimeout(() => {
+            if (this.lifecycleInProgress) {
+                return;
+            }
+            void this.checkStatus().catch((err) => {
+                this.log(`Background status refresh failed after ${reason}: ${err instanceof Error ? err.message : String(err)}`);
+            });
+        }, 100);
+    }
+    deriveStatusFrom(s) {
+        return (0, lifecycle_1.deriveAnalyticsStatus)(s);
+    }
+    /**
+     * Show options when in partial state (something running but not fully configured).
+     */
+    async showPartialStatusOption() {
+        const stackStatus = this._lastStackStatus;
+        const message = (0, lifecycle_1.getPartialSpotlightMessage)(stackStatus);
+        const choicePromise = vscode.window.showWarningMessage(`${branding_1.AGENTIDE_BRAND_NAME}: ${message}`, 'Install', 'Restart All', 'Show Status');
+        this.queueBackgroundStatusRefresh('opening partial menu');
+        const choice = await choicePromise;
+        switch (choice) {
+            case 'Install':
+                await vscode.commands.executeCommand('agentide.setupAnalytics');
+                break;
+            case 'Restart All':
+                await this.restart();
+                break;
+            case 'Show Status':
+                await this.showStatus();
+                break;
+        }
+    }
+    /**
+     * Show status summary and offer to restart.
+     */
+    async showStatusWithRestartOption() {
+        const choicePromise = vscode.window.showInformationMessage(`${branding_1.AGENTIDE_BRAND_NAME} Spotlight is running.`, 'See Spotlight', 'Restart All', 'Stop', 'Indexing', 'Show Status');
+        this.queueBackgroundStatusRefresh('opening running menu');
+        const choice = await choicePromise;
+        switch (choice) {
+            case 'See Spotlight':
+                await vscode.commands.executeCommand('agentide.analytics.openDashboard');
+                break;
+            case 'Restart All':
+                await this.restart();
+                break;
+            case 'Stop':
+                await this.stop();
+                break;
+            case 'Indexing':
+                await this.triggerIndexing();
+                break;
+            case 'Show Status':
+                await this.showStatus();
+                break;
+        }
+    }
+    /**
+     * Restart the analytics stack: stop LiteLLM, restart OTEL via terminal, start LiteLLM detached.
+     */
+    async restart() {
+        this.log('Restarting analytics stack...');
+        this.lifecycleInProgress = true;
+        this.updateStatusBar('checking');
+        if (!(await this.isAnalyticsConfigured())) {
+            await this.start();
+            return;
+        }
+        const isWindows = process.platform === 'win32';
+        const startScript = await this.findScript(isWindows ? 'start-analytics.ps1' : 'start-analytics.sh');
+        if (!startScript) {
+            this.lifecycleInProgress = false;
+            this.updateStatusBar('error');
+            vscode.window.showErrorMessage(`${branding_1.AGENTIDE_BRAND_NAME}: Spotlight scripts not found. Run Install first.`);
+            return;
+        }
+        const terminal = await this.createSpotlightLifecycleTerminal('Spotlight Restart', 'restart', startScript);
+        terminal.show();
+        this.updateStatusBar('checking');
+        this.startHeartbeat();
+        void this.monitorStartupReadiness('restart');
+    }
+    /**
+     * Run Windows setup end-to-end from the extension, then start LiteLLM via
+     * the existing launcher path. Unix setup remains script-owned for now.
+     */
+    async setupWindowsSpotlight(options = {}) {
+        if (process.platform !== 'win32') {
+            return { success: false, error: 'Windows-only setup flow invoked on a non-Windows platform.' };
+        }
+        const setupScript = await this.findScript('setup-analytics.ps1');
+        if (!setupScript) {
+            const message = `${branding_1.AGENTIDE_BRAND_NAME}: Spotlight install script not found.`;
+            vscode.window.showErrorMessage(message);
+            return { success: false, error: message };
+        }
+        this.lifecycleInProgress = true;
+        this.updateStatusBar('checking');
+        this.outputChannel.show(true);
+        this.log(`${options.reinstall ? 'Reinstalling' : 'Installing/repairing'} Spotlight on Windows...`);
+        vscode.window.showInformationMessage(`${branding_1.AGENTIDE_BRAND_NAME}: ${options.reinstall ? 'Reinstalling' : 'Installing'} Spotlight...`);
+        try {
+            if (options.reinstall) {
+                this.log('Stopping LiteLLM before reinstall...');
+                await this.stopLiteLLMDirectly();
+            }
+            const setupOk = await this.runWindowsSetupScript(setupScript);
+            if (!setupOk) {
+                throw new Error('setup-analytics.ps1 failed');
+            }
+            const litellmStatus = await this.getLiteLLMStatus();
+            if (litellmStatus.running) {
+                this.log('Restarting LiteLLM to apply Spotlight config...');
+                await this.stopLiteLLMDirectly();
+            }
+            this.log('Starting LiteLLM proxy via IDE-managed launcher...');
+            const litellmStarted = await this.startLiteLLMDirectly();
+            if (!litellmStarted) {
+                throw new Error('LiteLLM launcher did not start');
+            }
+            const analyticsDir = this.getAnalyticsDir();
+            this.log(`LiteLLM logs: ${path.join(analyticsDir, 'litellm.log')}`);
+            this.log(`LiteLLM errors: ${path.join(analyticsDir, 'litellm.error.log')}`);
+            this.startHeartbeat();
+            void this.monitorStartupReadiness(options.reinstall ? 'restart' : 'start');
+            return { success: true };
+        }
+        catch (error) {
+            this.lifecycleInProgress = false;
+            this.updateStatusBar('error');
+            const message = error instanceof Error ? error.message : String(error);
+            this.log(`Windows Spotlight install failed: ${message}`);
+            vscode.window.showErrorMessage(`${branding_1.AGENTIDE_BRAND_NAME}: Spotlight install failed. ${message}`);
+            return { success: false, error: message };
+        }
+    }
+    /**
+     * Show options when Spotlight is stopped/unknown.
+     */
+    async showStoppedStatusOption(status) {
+        const message = status === 'error'
+            ? `${branding_1.AGENTIDE_BRAND_NAME}: Spotlight status is unavailable.`
+            : `${branding_1.AGENTIDE_BRAND_NAME}: Spotlight is stopped.`;
+        const choicePromise = vscode.window.showInformationMessage(message, 'Start', 'Install', 'See Spotlight', 'Show Status');
+        this.queueBackgroundStatusRefresh('opening stopped menu');
+        const choice = await choicePromise;
+        switch (choice) {
+            case 'Start':
+                await this.start();
+                break;
+            case 'Install':
+                await vscode.commands.executeCommand('agentide.setupAnalytics');
+                break;
+            case 'See Spotlight':
+                await vscode.commands.executeCommand('agentide.analytics.openDashboard');
+                break;
+            case 'Show Status':
+                await this.showStatus();
+                break;
+        }
+    }
+    async runWindowsSetupScript(scriptPath) {
+        const agentHomeDir = (0, index_1.getAgentideHome)();
+        const args = [
+            '-NoProfile',
+            '-NonInteractive',
+            '-ExecutionPolicy',
+            'Bypass',
+            '-File',
+            scriptPath,
+            '-Yes',
+        ];
+        this.log(`Running ${path.basename(scriptPath)} -Yes...`);
+        return new Promise((resolve) => {
+            let settled = false;
+            const finish = (ok) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                resolve(ok);
+            };
+            const child = (0, child_process_1.spawn)(getWindowsPwshOrPowerShell(), args, {
+                cwd: path.dirname(scriptPath),
+                env: { ...process.env, AGENT_HOME_DIR: agentHomeDir },
+                windowsHide: true,
+            });
+            child.stdout?.on('data', data => {
+                this.outputChannel.append(data.toString());
+            });
+            child.stderr?.on('data', data => {
+                this.outputChannel.append(data.toString());
+            });
+            child.once('error', err => {
+                this.log(`Windows setup script failed to spawn: ${err.message}`);
+                finish(false);
+            });
+            child.once('exit', code => {
+                if (code === 0) {
+                    this.log('Windows Spotlight install script completed.');
+                    finish(true);
+                }
+                else {
+                    this.log(`Windows Spotlight install script exited with code ${code ?? 'unknown'}.`);
+                    finish(false);
+                }
+            });
+        });
+    }
+    /**
+     * Start the OTEL Collector.
+     */
+    async start() {
+        const isRunning = await this.checkStatus();
+        if (isRunning) {
+            vscode.window.showInformationMessage(`${branding_1.AGENTIDE_BRAND_NAME}: Spotlight is already running.`);
+            return;
+        }
+        // Find the start script (platform-specific)
+        const isWindows = process.platform === 'win32';
+        const scriptPath = await this.findScript(isWindows ? 'start-analytics.ps1' : 'start-analytics.sh');
+        if (!scriptPath) {
+            this.lifecycleInProgress = false;
+            vscode.window.showErrorMessage(`${branding_1.AGENTIDE_BRAND_NAME}: Spotlight scripts not found. Run Install first.`);
+            return;
+        }
+        this.lifecycleInProgress = true;
+        this.updateStatusBar('checking');
+        const terminal = await this.createSpotlightLifecycleTerminal('Spotlight Start', 'start', scriptPath);
+        terminal.show();
+        this.log('Starting Spotlight (OTEL Collector + LiteLLM)...');
+        vscode.window.showInformationMessage(`${branding_1.AGENTIDE_BRAND_NAME}: Starting Spotlight...`);
+        this.updateStatusBar('checking');
+        // Start heartbeat if not already running (user just set up analytics)
+        this.startHeartbeat();
+        void this.monitorStartupReadiness('start');
+    }
+    /**
+     * Stop the OTEL Collector.
+     */
+    async stop() {
+        this.lifecycleInProgress = true;
+        this.updateStatusBar('checking');
+        // Find the start script (which also handles stopping)
+        const isWindows = process.platform === 'win32';
+        const scriptPath = await this.findScript(isWindows ? 'start-analytics.ps1' : 'start-analytics.sh');
+        if (!scriptPath) {
+            // Try to stop directly via PID
+            await this.stopDirectly();
+            this.lifecycleInProgress = false;
+            return;
+        }
+        // Run the stop command with visible output
+        const terminal = await this.createSpotlightLifecycleTerminal('Spotlight Stop', 'stop', scriptPath);
+        terminal.show();
+        this.log('Stopping Spotlight (OTEL Collector + LiteLLM)...');
+        this.updateStatusBar('checking');
+        void this.monitorStopReadiness();
+    }
+    /**
+     * Stop OTEL Collector directly via PID file.
+     */
+    async stopDirectly() {
+        try {
+            const pidFile = this.getOtelPidFile();
+            const pidContent = await fs_1.promises.readFile(pidFile, 'utf8');
+            const pid = parseInt(pidContent.trim(), 10);
+            if (!isNaN(pid)) {
+                process.kill(pid, 'SIGTERM');
+                await fs_1.promises.unlink(pidFile).catch(() => { });
+                this.log(`Stopped OTEL Collector (PID: ${pid})`);
+            }
+            await this.stopLiteLLMDirectly();
+            this.updateStatusBar('stopped');
+        }
+        catch (error) {
+            this.log(`Failed to stop directly: ${error}`);
+            this.updateStatusBar('error');
+        }
+    }
+    async createSpotlightLifecycleTerminal(name, action, startScript) {
+        const agentHomeDir = (0, index_1.getAgentideHome)();
+        const analyticsDir = path.join(agentHomeDir, 'analytics');
+        fsSync.mkdirSync(analyticsDir, { recursive: true });
+        const litellmScript = await this.findLiteLLMScript();
+        const configPath = path.join(agentHomeDir, 'litellm-otel.yaml');
+        const stdoutPath = path.join(analyticsDir, 'litellm.log');
+        const stderrPath = path.join(analyticsDir, 'litellm.error.log');
+        if (process.platform === 'win32') {
+            return vscode.window.createTerminal({
+                name,
+                cwd: path.dirname(startScript),
+                env: { AGENT_HOME_DIR: agentHomeDir },
+                shellPath: getWindowsPwshOrPowerShell(),
+                shellArgs: [
+                    '-NoProfile',
+                    '-NoExit',
+                    '-ExecutionPolicy',
+                    'Bypass',
+                    '-Command',
+                    this.buildWindowsSpotlightLifecycleCommand({
+                        action,
+                        startScript,
+                        litellmScript,
+                        agentHomeDir,
+                        configPath,
+                        stdoutPath,
+                        stderrPath,
+                    }),
+                ],
+            });
+        }
+        return vscode.window.createTerminal({
+            name,
+            cwd: path.dirname(startScript),
+            env: { AGENT_HOME_DIR: agentHomeDir },
+            shellPath: '/bin/bash',
+            shellArgs: [
+                '-c',
+                this.buildUnixSpotlightLifecycleCommand({
+                    action,
+                    startScript,
+                    litellmScript,
+                    agentHomeDir,
+                    configPath,
+                    stdoutPath,
+                    stderrPath,
+                }),
+            ],
+        });
+    }
+    buildWindowsSpotlightLifecycleCommand(options) {
+        const q = (value) => `'${this.escapePowerShellSingleQuotedString(value)}'`;
+        const lines = [
+            '$ErrorActionPreference = \'Continue\'',
+            `$env:AGENT_HOME_DIR = ${q(options.agentHomeDir)}`,
+            `Write-Host ${q(this.getLifecycleTerminalIntro(options.action))}`,
+        ];
+        if (options.action === 'stop' || options.action === 'restart') {
+            lines.push('Write-Host ""', 'Write-Host "Stopping LiteLLM proxy..."', ...this.buildWindowsLiteLLMStopCommands(options.litellmScript, q));
+        }
+        if (options.action === 'stop') {
+            lines.push('Write-Host ""', 'Write-Host "Stopping OTEL Collector..."', `& ${q(options.startScript)} -Stop`);
+        }
+        else if (options.action === 'restart') {
+            lines.push('Write-Host ""', 'Write-Host "Restarting OTEL Collector..."', `& ${q(options.startScript)} -Stop`, 'Start-Sleep 1', `& ${q(options.startScript)} -ForceDaemon`);
+        }
+        else {
+            lines.push('Write-Host ""', 'Write-Host "Starting OTEL Collector..."', `& ${q(options.startScript)} -ForceDaemon`);
+        }
+        if (options.action === 'start' || options.action === 'restart') {
+            lines.push('Write-Host ""', ...this.buildWindowsLiteLLMStartCommands(options, q));
+        }
+        lines.push('Write-Host ""', 'Write-Host "You can close this window."');
+        return lines.join('\r\n');
+    }
+    buildWindowsLiteLLMStopCommands(litellmScript, q) {
+        if (!litellmScript) {
+            return ['Write-Host "[WARN] LiteLLM launcher script not found. Skipping LiteLLM stop." -ForegroundColor Yellow'];
+        }
+        return [`& ${q(litellmScript)} -Stop`];
+    }
+    buildWindowsLiteLLMStartCommands(options, q) {
+        if (!options.litellmScript) {
+            return ['Write-Host "[WARN] LiteLLM launcher script not found. Skipping LiteLLM start." -ForegroundColor Yellow'];
+        }
+        const launcherArgumentLine = (0, windowsCommandLine_1.buildWindowsArgumentLine)([
+            '-NoProfile',
+            '-NoLogo',
+            '-ExecutionPolicy',
+            'Bypass',
+            '-File',
+            options.litellmScript,
+            '-ConfigPath',
+            options.configPath,
+        ]);
+        return [
+            'Write-Host "Starting LiteLLM proxy..."',
+            `if (-not (Test-Path ${q(options.configPath)})) {`,
+            `  Write-Host ${q(`[WARN] LiteLLM config not found: ${options.configPath}`)} -ForegroundColor Yellow`,
+            '} else {',
+            `  $env:LITELLM_CONFIG_PATH = ${q(options.configPath)}`,
+            '  try {',
+            `    $proc = Start-Process -FilePath ${q(getWindowsPwshOrPowerShell())} -WindowStyle Hidden -WorkingDirectory ${q(path.dirname(options.litellmScript))} -ArgumentList ${q(launcherArgumentLine)} -RedirectStandardOutput ${q(options.stdoutPath)} -RedirectStandardError ${q(options.stderrPath)} -PassThru -ErrorAction Stop`,
+            '    Write-Host "[OK]   LiteLLM launcher started (PID: $($proc.Id))"',
+            `    Write-Host ${q(`       Logs: ${options.stdoutPath}`)}`,
+            `    Write-Host ${q(`       Errors: ${options.stderrPath}`)}`,
+            '  } catch {',
+            '    Write-Host "[ERROR] Failed to start LiteLLM launcher." -ForegroundColor Red',
+            '    Write-Host $_.Exception.Message -ForegroundColor Red',
+            '  }',
+            '}',
+        ];
+    }
+    buildUnixSpotlightLifecycleCommand(options) {
+        const q = (value) => this.quoteBash(value);
+        const lines = [
+            'set +e',
+            `export AGENT_HOME_DIR=${q(options.agentHomeDir)}`,
+            `mkdir -p ${q(path.dirname(options.stdoutPath))}`,
+            `echo ${q(this.getLifecycleTerminalIntro(options.action))}`,
+        ];
+        if (options.action === 'stop' || options.action === 'restart') {
+            lines.push('echo ""', 'echo "Stopping LiteLLM proxy..."', ...this.buildUnixLiteLLMStopCommands(options.litellmScript, q));
+        }
+        if (options.action === 'stop') {
+            lines.push('echo ""', 'echo "Stopping OTEL Collector..."', `${q(options.startScript)} --stop`);
+        }
+        else if (options.action === 'restart') {
+            lines.push('echo ""', 'echo "Restarting OTEL Collector..."', `${q(options.startScript)} --stop`, 'sleep 1', `${q(options.startScript)} --force-daemon`);
+        }
+        else {
+            lines.push('echo ""', 'echo "Starting OTEL Collector..."', `${q(options.startScript)} --force-daemon`);
+        }
+        if (options.action === 'start' || options.action === 'restart') {
+            lines.push('echo ""', ...this.buildUnixLiteLLMStartCommands(options, q));
+        }
+        lines.push('echo ""', 'echo "Press any key to close..."', 'read -n 1');
+        return lines.join('\n');
+    }
+    buildUnixLiteLLMStopCommands(litellmScript, q) {
+        if (!litellmScript) {
+            return ['echo "[WARN] LiteLLM launcher script not found. Skipping LiteLLM stop." >&2'];
+        }
+        return [`${q(litellmScript)} --stop`];
+    }
+    buildUnixLiteLLMStartCommands(options, q) {
+        if (!options.litellmScript) {
+            return ['echo "[WARN] LiteLLM launcher script not found. Skipping LiteLLM start." >&2'];
+        }
+        return [
+            'echo "Starting LiteLLM proxy..."',
+            `if [ ! -f ${q(options.configPath)} ]; then`,
+            `  echo ${q(`[WARN] LiteLLM config not found: ${options.configPath}`)} >&2`,
+            'else',
+            `  export LITELLM_CONFIG_PATH=${q(options.configPath)}`,
+            `  nohup ${q(options.litellmScript)} --config ${q(options.configPath)} >> ${q(options.stdoutPath)} 2>> ${q(options.stderrPath)} &`,
+            '  echo "[OK]   LiteLLM launcher started (PID: $!)"',
+            `  echo ${q(`       Logs: ${options.stdoutPath}`)}`,
+            `  echo ${q(`       Errors: ${options.stderrPath}`)}`,
+            'fi',
+        ];
+    }
+    getLifecycleTerminalIntro(action) {
+        switch (action) {
+            case 'start':
+                return 'Starting Spotlight (OTEL Collector + LiteLLM)...';
+            case 'stop':
+                return 'Stopping Spotlight (LiteLLM + OTEL Collector)...';
+            case 'restart':
+                return 'Restarting Spotlight (LiteLLM + OTEL Collector)...';
+        }
+    }
+    quoteBash(value) {
+        return `'${value.replace(/'/g, '\'\\\'\'')}'`;
+    }
+    /**
+     * Stop LiteLLM by invoking the launcher script with --stop / -Stop.
+     * The script reads the canonical PID file and handles winpid/taskkill on Windows.
+     */
+    async stopLiteLLMDirectly() {
+        const isWindows = process.platform === 'win32';
+        const args = isWindows ? ['-Stop'] : ['--stop'];
+        return this.runLauncher(args, { detached: false });
+    }
+    /**
+     * Start LiteLLM in a detached background process. Logs go to .agent-hippo/analytics/litellm.{log,error.log}.
+     */
+    async startLiteLLMDirectly() {
+        const configPath = path.join((0, index_1.getAgentideHome)(), 'litellm-otel.yaml');
+        try {
+            await fs_1.promises.access(configPath);
+        }
+        catch {
+            return false;
+        }
+        const isWindows = process.platform === 'win32';
+        const args = isWindows
+            ? ['-ConfigPath', configPath]
+            : ['--config', configPath];
+        return this.runLauncher(args, { detached: true, configPath });
+    }
+    /**
+     * Spawn the agentide-litellm launcher with the given args.
+     * `detached: true` returns immediately and pipes child stdout/stderr to log files.
+     * `detached: false` resolves when the process exits (used for --stop).
+     */
+    async runLauncher(args, opts) {
+        const scriptPath = await this.findLiteLLMScript();
+        if (!scriptPath) {
+            return false;
+        }
+        const isWindows = process.platform === 'win32';
+        const shellPath = isWindows ? getWindowsPwshOrPowerShell() : '/bin/bash';
+        const shellArgs = isWindows
+            ? ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-File', scriptPath, ...args]
+            : [scriptPath, ...args];
+        const env = { ...process.env, AGENT_HOME_DIR: (0, index_1.getAgentideHome)() };
+        if (opts.configPath) {
+            env.LITELLM_CONFIG_PATH = opts.configPath;
+        }
+        if (isWindows && opts.detached) {
+            return this.startLiteLLMViaHiddenWindowsProcess(scriptPath, args, env);
+        }
+        if (opts.detached) {
+            // Open log files synchronously so spawn can dup the fds before we close them.
+            const analyticsDir = path.join((0, index_1.getAgentideHome)(), 'analytics');
+            fsSync.mkdirSync(analyticsDir, { recursive: true });
+            const stdoutFd = fsSync.openSync(path.join(analyticsDir, 'litellm.log'), 'a');
+            const stderrFd = fsSync.openSync(path.join(analyticsDir, 'litellm.error.log'), 'a');
+            try {
+                const child = (0, child_process_1.spawn)(shellPath, shellArgs, {
+                    detached: true,
+                    stdio: ['ignore', stdoutFd, stderrFd],
+                    windowsHide: true,
+                    env,
+                    cwd: path.dirname(scriptPath),
+                });
+                child.unref();
+                this.log(`LiteLLM launcher started (PID: ${child.pid})`);
+                return true;
+            }
+            catch (error) {
+                this.log(`Failed to start LiteLLM: ${error}`);
+                return false;
+            }
+            finally {
+                fsSync.closeSync(stdoutFd);
+                fsSync.closeSync(stderrFd);
+            }
+        }
+        return new Promise((resolve) => {
+            const child = (0, child_process_1.spawn)(shellPath, shellArgs, {
+                windowsHide: true,
+                env,
+                cwd: path.dirname(scriptPath),
+            });
+            child.once('error', (err) => {
+                this.log(`LiteLLM launcher failed to spawn: ${err}`);
+                resolve(false);
+            });
+            child.once('exit', (code) => resolve(code === 0));
+        });
+    }
+    async startLiteLLMViaHiddenWindowsProcess(scriptPath, args, env) {
+        const analyticsDir = path.join((0, index_1.getAgentideHome)(), 'analytics');
+        fsSync.mkdirSync(analyticsDir, { recursive: true });
+        const stdoutPath = path.join(analyticsDir, 'litellm.log');
+        const stderrPath = path.join(analyticsDir, 'litellm.error.log');
+        const launcherArgumentLine = (0, windowsCommandLine_1.buildWindowsArgumentLine)([
+            '-NoProfile',
+            '-NoLogo',
+            '-ExecutionPolicy',
+            'Bypass',
+            '-File',
+            scriptPath,
+            ...args,
+        ]);
+        const psCommand = [
+            `$env:AGENT_HOME_DIR = '${this.escapePowerShellSingleQuotedString(env.AGENT_HOME_DIR ?? (0, index_1.getAgentideHome)())}'`,
+            env.LITELLM_CONFIG_PATH
+                ? `$env:LITELLM_CONFIG_PATH = '${this.escapePowerShellSingleQuotedString(env.LITELLM_CONFIG_PATH)}'`
+                : '',
+            `$proc = Start-Process -FilePath '${this.escapePowerShellSingleQuotedString(getWindowsPwshOrPowerShell())}' -WindowStyle Hidden -WorkingDirectory '${this.escapePowerShellSingleQuotedString(path.dirname(scriptPath))}' -ArgumentList '${this.escapePowerShellSingleQuotedString(launcherArgumentLine)}' -RedirectStandardOutput '${this.escapePowerShellSingleQuotedString(stdoutPath)}' -RedirectStandardError '${this.escapePowerShellSingleQuotedString(stderrPath)}' -PassThru`,
+            'Write-Output $proc.Id',
+        ].filter(Boolean).join('; ');
+        return new Promise((resolve) => {
+            let stdout = '';
+            let stderr = '';
+            const child = (0, child_process_1.spawn)(getWindowsPwshOrPowerShell(), [
+                '-NoProfile',
+                '-ExecutionPolicy',
+                'Bypass',
+                '-Command',
+                psCommand,
+            ], {
+                windowsHide: true,
+                env,
+                cwd: path.dirname(scriptPath),
+            });
+            child.stdout.on('data', data => {
+                stdout += data.toString();
+            });
+            child.stderr.on('data', data => {
+                stderr += data.toString();
+            });
+            child.once('error', (err) => {
+                this.log(`LiteLLM launcher failed to spawn hidden Windows process: ${err}`);
+                resolve(false);
+            });
+            child.once('exit', (code) => {
+                if (code !== 0) {
+                    const detail = stderr.trim() || stdout.trim();
+                    this.log(`LiteLLM hidden Windows launcher exited with code ${code}${detail ? `: ${detail}` : ''}`);
+                    resolve(false);
+                    return;
+                }
+                const startedPid = parseInt(stdout.trim(), 10);
+                if (!Number.isNaN(startedPid)) {
+                    this.log(`LiteLLM hidden Windows process started (PID: ${startedPid})`);
+                }
+                resolve(true);
+            });
+        });
+    }
+    escapePowerShellSingleQuotedString(value) {
+        return value.replace(/'/g, '\'\'');
+    }
+    async findLiteLLMScript() {
+        const extensionPath = this.extensionContext.extensionPath;
+        const isWindows = process.platform === 'win32';
+        const scriptName = isWindows ? 'agentide-litellm.ps1' : 'agentide-litellm.sh';
+        const candidates = [
+            path.join(extensionPath, 'out', 'scripts', scriptName),
+            path.join(extensionPath, 'scripts', scriptName),
+            path.join(extensionPath, '..', '..', 'scripts', scriptName),
+        ];
+        for (const candidate of candidates) {
+            try {
+                await fs_1.promises.access(candidate);
+                return candidate;
+            }
+            catch {
+                // ignore
+            }
+        }
+        return null;
+    }
+    /**
+     * Run DuckDB re-indexing from trace JSONL (dashboard).
+     */
+    async triggerIndexing() {
+        if (!this.indexingService) {
+            vscode.window.showWarningMessage(`${branding_1.AGENTIDE_BRAND_NAME}: Indexing service is not available.`);
+            return;
+        }
+        if (this.indexingService.isIndexing()) {
+            vscode.window.showInformationMessage(`${branding_1.AGENTIDE_BRAND_NAME}: Indexing is already in progress.`);
+            return;
+        }
+        this.indexingService.scheduleIndexing(true);
+        vscode.window.showInformationMessage(`${branding_1.AGENTIDE_BRAND_NAME}: Triggered indexing.`);
+    }
+    /**
+     * Show analytics status in a notification.
+     */
+    async showStatus() {
+        const stackStatus = await this.getStackStatus();
+        const litellmBaseUrl = vscode.workspace
+            .getConfiguration('agentide.providers.litellm')
+            .get('baseUrl')
+            ?.trim();
+        // Build status lines
+        // allow-any-unicode-next-line
+        const otelStatus = stackStatus.otelRunning ? '🟢 127.0.0.1:4318' : '⚫ Not running';
+        let litellmStatus;
+        if (stackStatus.litellmRunning && litellmBaseUrl) {
+            // allow-any-unicode-next-line
+            litellmStatus = `🟢 ${litellmBaseUrl}`;
+        }
+        else if (stackStatus.litellmRunning) {
+            // allow-any-unicode-next-line
+            litellmStatus = '🟢 Set URL in Settings or Stop External LiteLLM';
+        }
+        else {
+            // allow-any-unicode-next-line
+            litellmStatus = '⚫ Not running';
+        }
+        const message = [
+            `LiteLLM: ${litellmStatus}`,
+            `OTEL: ${otelStatus}`,
+        ].join('\n\n');
+        const lifecycleAction = (0, lifecycle_1.getSpotlightLifecycleAction)(stackStatus);
+        const installAction = (0, lifecycle_1.getSpotlightInstallAction)(await this.isAnalyticsConfigured());
+        const action = await vscode.window.showInformationMessage(`${message}`, 'Config', installAction, lifecycleAction);
+        switch (action) {
+            case 'Start':
+                await this.start();
+                break;
+            case 'Stop':
+                await this.stop();
+                break;
+            case 'Config':
+                await this.openLiteLLMConfig();
+                break;
+            case 'Restart All':
+                await this.restart();
+                break;
+            case 'Install':
+                if (process.platform === 'win32') {
+                    await this.setupWindowsSpotlight({ reinstall: false });
+                }
+                else {
+                    await vscode.commands.executeCommand('agentide.setupAnalytics');
+                }
+                break;
+            case 'Reinstall':
+                if (process.platform === 'win32') {
+                    await this.setupWindowsSpotlight({ reinstall: true });
+                }
+                else {
+                    await vscode.commands.executeCommand('agentide.setupAnalytics');
+                }
+                break;
+        }
+    }
+    async openLiteLLMConfig() {
+        const configPath = path.join((0, index_1.getAgentideHome)(), 'litellm-otel.yaml');
+        try {
+            await fs_1.promises.access(configPath);
+        }
+        catch {
+            const choice = await vscode.window.showWarningMessage(`${branding_1.AGENTIDE_BRAND_NAME}: LiteLLM OTEL config not found.`, 'Install');
+            if (choice === 'Install') {
+                await vscode.commands.executeCommand('agentide.setupAnalytics');
+            }
+            return;
+        }
+        const doc = await vscode.workspace.openTextDocument(configPath);
+        await vscode.window.showTextDocument(doc);
+    }
+    /**
+     * Open a terminal with analytics query commands.
+     * Shows the latest session info by default.
+     */
+    async openQueryTerminal() {
+        const scriptPath = await this.findScript('query-analytics.sh');
+        if (!scriptPath) {
+            vscode.window.showErrorMessage(`${branding_1.AGENTIDE_BRAND_NAME}: Query script not found. Run 'Setup Analytics' first.`);
+            return;
+        }
+        // Show latest session info by default - includes chat history and costs
+        // Keep terminal open so user can see the output
+        const terminal = this.createScriptTerminal('Spotlight Query', scriptPath, '--latest-session', true);
+        terminal.show();
+    }
+    /**
+     * Find a script in the extension bundle or source directory.
+     */
+    async findScript(scriptName) {
+        const extensionPath = this.extensionContext.extensionPath;
+        // Try bundled location first
+        const bundledPath = path.join(extensionPath, 'out', 'scripts', 'analytics', scriptName);
+        try {
+            await fs_1.promises.access(bundledPath);
+            return bundledPath;
+        }
+        catch {
+            // Not in bundled location
+        }
+        // Try development location
+        const devPath = path.join(extensionPath, 'scripts', 'analytics', scriptName);
+        try {
+            await fs_1.promises.access(devPath);
+            return devPath;
+        }
+        catch {
+            // Not in dev location
+        }
+        return null;
+    }
+    /**
+     * Update the status bar item.
+     */
+    updateStatusBar(status) {
+        this._status = status;
+        let tooltip;
+        // Use different icons and colors based on status
+        switch (status) {
+            case 'running':
+                this.statusBarItem.text = '$(pulse) Spotlight';
+                tooltip = 'Spotlight: Running (OTEL + LiteLLM configured)';
+                this.statusBarItem.color = new vscode.ThemeColor('testing.iconPassed'); // Green
+                this.statusBarItem.backgroundColor = undefined;
+                break;
+            case 'partial':
+                this.statusBarItem.text = '$(pulse) Spotlight';
+                tooltip = 'Spotlight: Partial (click to configure)';
+                this.statusBarItem.color = new vscode.ThemeColor('editorWarning.foreground'); // Yellow
+                this.statusBarItem.backgroundColor = undefined;
+                break;
+            case 'stopped':
+                this.statusBarItem.text = '$(pulse) Spotlight';
+                tooltip = 'Spotlight: Stopped (click to start)';
+                this.statusBarItem.color = undefined;
+                this.statusBarItem.backgroundColor = undefined;
+                break;
+            case 'checking':
+                this.statusBarItem.text = '$(sync~spin) Spotlight';
+                tooltip = 'Spotlight: Checking...';
+                this.statusBarItem.color = undefined;
+                this.statusBarItem.backgroundColor = undefined;
+                break;
+            case 'error':
+                this.statusBarItem.text = '$(warning) Spotlight';
+                tooltip = 'Spotlight: Error (click to retry)';
+                this.statusBarItem.color = new vscode.ThemeColor('errorForeground');
+                this.statusBarItem.backgroundColor = undefined;
+                break;
+        }
+        if (this.indexProgress.status === 'indexing') {
+            tooltip += `\n\nBackground analytics indexing is running (${this.indexProgress.percent}% complete). Charts may use JSONL fallback until indexing finishes.`;
+        }
+        this.statusBarItem.tooltip = tooltip;
+        this.statusBarItem.show();
+    }
+    log(message) {
+        this.outputChannel.appendLine(`[Analytics] ${message}`);
+    }
+    /**
+     * Create a terminal that runs a command directly via shellArgs.
+     * This avoids the sendText character-dropping issue.
+     */
+    createScriptTerminal(name, scriptPath, args, keepOpen = false) {
+        const agentHomeDir = (0, index_1.getAgentideHome)();
+        if (keepOpen) {
+            // Run the script, then drop into an interactive shell
+            // Uses the same shellPath/shellArgs approach as Setup Analytics to avoid sendText issues
+            // Echo the command first so user can see what's running
+            const cmd = `"${scriptPath}" ${args}`;
+            return vscode.window.createTerminal({
+                name,
+                cwd: path.dirname(scriptPath),
+                env: {
+                    AGENT_HOME_DIR: agentHomeDir,
+                },
+                shellPath: '/bin/bash',
+                shellArgs: ['-c', `echo '$ ${cmd}'; echo ''; ${cmd}; echo ''; exec bash -l`],
+            });
+        }
+        // For non-keepOpen, use bash -c for a one-shot command
+        return vscode.window.createTerminal({
+            name,
+            cwd: path.dirname(scriptPath),
+            env: {
+                AGENT_HOME_DIR: agentHomeDir,
+            },
+            shellPath: '/bin/bash',
+            shellArgs: ['-c', `"${scriptPath}" ${args}`],
+        });
+    }
+    dispose() {
+        if (this.healthCheckTimer) {
+            clearInterval(this.healthCheckTimer);
+            this.healthCheckTimer = null;
+        }
+        this.statusBarItem.dispose();
+        for (const d of this.disposables) {
+            d.dispose();
+        }
+    }
+}
+exports.AnalyticsService = AnalyticsService;