@jonnyhoo/ccs 1.0.0

package/dist/web-server/routes/cliproxy-stats-routes.js

@@ -0,0 +1,681 @@
+"use strict";
+/**
+ * CLIProxy Stats Routes - Stats, status, models, error logs for CLIProxyAPI
+ */
+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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = require("express");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const stats_fetcher_1 = require("../../cliproxy/stats-fetcher");
+const quota_fetcher_1 = require("../../cliproxy/quota-fetcher");
+const quota_fetcher_codex_1 = require("../../cliproxy/quota-fetcher-codex");
+const quota_fetcher_gemini_cli_1 = require("../../cliproxy/quota-fetcher-gemini-cli");
+const quota_response_cache_1 = require("../../cliproxy/quota-response-cache");
+const profile_detector_1 = require("../../auth/profile-detector");
+const config_generator_1 = require("../../cliproxy/config-generator");
+const session_tracker_1 = require("../../cliproxy/session-tracker");
+const service_manager_1 = require("../../cliproxy/service-manager");
+const binary_manager_1 = require("../../cliproxy/binary-manager");
+const version_checker_1 = require("../../cliproxy/binary/version-checker");
+const platform_detector_1 = require("../../cliproxy/platform-detector");
+const unified_config_loader_1 = require("../../config/unified-config-loader");
+const router = (0, express_1.Router)();
+/** Get configured backend from config */
+function getConfiguredBackend() {
+    try {
+        const config = (0, unified_config_loader_1.loadOrCreateUnifiedConfig)();
+        return config.cliproxy?.backend || platform_detector_1.DEFAULT_BACKEND;
+    }
+    catch {
+        return platform_detector_1.DEFAULT_BACKEND;
+    }
+}
+/**
+ * Extract status code and model from error log file (lightweight parsing)
+ * Reads first 4KB for model, last 2KB for status code
+ */
+async function extractErrorLogMetadata(filePath) {
+    try {
+        const fd = fs.openSync(filePath, 'r');
+        const stat = fs.fstatSync(fd);
+        const fileSize = stat.size;
+        // Read first 4KB for model (in request body)
+        const startBuffer = Buffer.alloc(Math.min(4096, fileSize));
+        fs.readSync(fd, startBuffer, 0, startBuffer.length, 0);
+        const startContent = startBuffer.toString('utf-8');
+        // Extract model from request body JSON: "model":"gemini-3-flash-preview"
+        const modelMatch = startContent.match(/"model"\s*:\s*"([^"]+)"/);
+        const model = modelMatch ? modelMatch[1] : undefined;
+        // Read last 2KB for status code (in response section at end)
+        let statusCode;
+        if (fileSize > 2048) {
+            const endBuffer = Buffer.alloc(2048);
+            fs.readSync(fd, endBuffer, 0, 2048, fileSize - 2048);
+            const endContent = endBuffer.toString('utf-8');
+            const statusMatch = endContent.match(/Status:\s*(\d{3})/);
+            statusCode = statusMatch ? parseInt(statusMatch[1], 10) : undefined;
+        }
+        else {
+            // Small file - check start content for status
+            const statusMatch = startContent.match(/Status:\s*(\d{3})/);
+            statusCode = statusMatch ? parseInt(statusMatch[1], 10) : undefined;
+        }
+        fs.closeSync(fd);
+        return { statusCode, model };
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Shared handler for stats/usage endpoint
+ */
+const handleStatsRequest = async (_req, res) => {
+    try {
+        // Check if proxy is running first
+        const running = await (0, stats_fetcher_1.isCliproxyRunning)();
+        if (!running) {
+            res.status(503).json({
+                error: 'CLIProxy Plus not running',
+                message: 'Start a CLIProxy session (gemini, codex, agy) to collect stats',
+            });
+            return;
+        }
+        // Fetch stats from management API
+        const stats = await (0, stats_fetcher_1.fetchCliproxyStats)();
+        if (!stats) {
+            res.status(503).json({
+                error: 'Stats unavailable',
+                message: 'CLIProxy Plus is running but stats endpoint not responding',
+            });
+            return;
+        }
+        res.json(stats);
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+};
+/**
+ * GET /api/cliproxy/stats - Get CLIProxyAPI usage statistics
+ * Returns: CliproxyStats or error if proxy not running
+ */
+router.get('/stats', handleStatsRequest);
+/**
+ * GET /api/cliproxy/usage - Alias for /stats (frontend compatibility)
+ */
+router.get('/usage', handleStatsRequest);
+/**
+ * GET /api/cliproxy/status - Check CLIProxyAPI running status
+ * Returns: { running: boolean }
+ */
+router.get('/status', async (_req, res) => {
+    try {
+        const running = await (0, stats_fetcher_1.isCliproxyRunning)();
+        res.json({ running });
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+/**
+ * GET /api/cliproxy/proxy-status - Get detailed proxy process status
+ * Returns: { running, port?, pid?, sessionCount?, startedAt? }
+ * Combines session tracker data with actual port check for accuracy
+ */
+router.get('/proxy-status', async (_req, res) => {
+    try {
+        // First check session tracker for detailed info
+        const sessionStatus = (0, session_tracker_1.getProxyStatus)();
+        // If session tracker says running, trust it
+        if (sessionStatus.running) {
+            res.json(sessionStatus);
+            return;
+        }
+        // Session tracker says not running, but proxy might be running without session tracking
+        // (e.g., started before session persistence was implemented)
+        const actuallyRunning = await (0, stats_fetcher_1.isCliproxyRunning)();
+        if (actuallyRunning) {
+            // Proxy running but no session lock - legacy/untracked instance
+            res.json({
+                running: true,
+                port: 8317, // Default port
+                sessionCount: 0, // Unknown sessions
+                // No pid/startedAt since we don't have session lock
+            });
+        }
+        else {
+            res.json(sessionStatus);
+        }
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+/**
+ * POST /api/cliproxy/proxy-start - Start the CLIProxy service
+ * Returns: { started, alreadyRunning, port, error? }
+ * Starts proxy in background if not already running
+ */
+router.post('/proxy-start', async (_req, res) => {
+    try {
+        const result = await (0, service_manager_1.ensureCliproxyService)();
+        res.json(result);
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+/**
+ * POST /api/cliproxy/proxy-stop - Stop the CLIProxy service
+ * Returns: { stopped, pid?, sessionCount?, error? }
+ */
+router.post('/proxy-stop', async (_req, res) => {
+    try {
+        const result = await (0, session_tracker_1.stopProxy)();
+        res.json(result);
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+/**
+ * GET /api/cliproxy/update-check - Check for CLIProxyAPI binary updates
+ * Returns: { hasUpdate, currentVersion, latestVersion, fromCache }
+ */
+router.get('/update-check', async (_req, res) => {
+    try {
+        const backend = getConfiguredBackend();
+        const result = await (0, binary_manager_1.checkCliproxyUpdate)(backend);
+        res.json(result);
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+/**
+ * GET /api/cliproxy/models - Get available models from CLIProxyAPI
+ * Returns: { models: CliproxyModel[], byCategory: Record<string, CliproxyModel[]>, totalCount: number }
+ */
+router.get('/models', async (_req, res) => {
+    try {
+        // Check if proxy is running first
+        const running = await (0, stats_fetcher_1.isCliproxyRunning)();
+        if (!running) {
+            res.status(503).json({
+                error: 'CLIProxy Plus not running',
+                message: 'Start a CLIProxy session (gemini, codex, agy) to fetch available models',
+            });
+            return;
+        }
+        // Fetch models from /v1/models endpoint
+        const modelsResponse = await (0, stats_fetcher_1.fetchCliproxyModels)();
+        if (!modelsResponse) {
+            res.status(503).json({
+                error: 'Models unavailable',
+                message: 'CLIProxy Plus is running but /v1/models endpoint not responding',
+            });
+            return;
+        }
+        res.json(modelsResponse);
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+// ==================== Error Logs ====================
+/**
+ * GET /api/cliproxy/error-logs - Get list of error log files
+ * Returns: { files: CliproxyErrorLog[] } or error if proxy not running
+ */
+router.get('/error-logs', async (_req, res) => {
+    try {
+        const running = await (0, stats_fetcher_1.isCliproxyRunning)();
+        if (!running) {
+            res.status(503).json({
+                error: 'CLIProxy Plus not running',
+                message: 'Start a CLIProxy session to view error logs',
+            });
+            return;
+        }
+        const files = await (0, stats_fetcher_1.fetchCliproxyErrorLogs)();
+        if (files === null) {
+            res.status(503).json({
+                error: 'Error logs unavailable',
+                message: 'CLIProxy Plus is running but error logs endpoint not responding',
+            });
+            return;
+        }
+        // Inject absolute paths and extract metadata from each file
+        const logsDir = path.join((0, config_generator_1.getCliproxyWritablePath)(), 'logs');
+        const filesWithMetadata = await Promise.all(files.map(async (file) => {
+            const absolutePath = path.join(logsDir, file.name);
+            const metadata = await extractErrorLogMetadata(absolutePath);
+            return {
+                ...file,
+                absolutePath,
+                statusCode: metadata.statusCode,
+                model: metadata.model,
+            };
+        }));
+        res.json({ files: filesWithMetadata });
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+/**
+ * GET /api/cliproxy/error-logs/:name - Get content of a specific error log
+ * Returns: plain text log content
+ */
+router.get('/error-logs/:name', async (req, res) => {
+    const { name } = req.params;
+    // Validate filename format and prevent path traversal
+    if (!name ||
+        !name.startsWith('error-') ||
+        !name.endsWith('.log') ||
+        name.includes('..') ||
+        name.includes('/') ||
+        name.includes('\\')) {
+        res.status(400).json({ error: 'Invalid error log filename' });
+        return;
+    }
+    try {
+        const running = await (0, stats_fetcher_1.isCliproxyRunning)();
+        if (!running) {
+            res.status(503).json({ error: 'CLIProxy Plus not running' });
+            return;
+        }
+        const content = await (0, stats_fetcher_1.fetchCliproxyErrorLogContent)(name);
+        if (content === null) {
+            res.status(404).json({ error: 'Error log not found' });
+            return;
+        }
+        res.type('text/plain').send(content);
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+// ==================== Config File ====================
+/**
+ * GET /api/cliproxy/config.yaml - Get CLIProxy YAML config content
+ * Returns: plain text YAML content
+ */
+router.get('/config.yaml', async (_req, res) => {
+    try {
+        const configPath = (0, config_generator_1.getCliproxyConfigPath)();
+        if (!fs.existsSync(configPath)) {
+            res.status(404).json({ error: 'Config file not found' });
+            return;
+        }
+        const content = fs.readFileSync(configPath, 'utf8');
+        res.type('text/yaml').send(content);
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+/**
+ * PUT /api/cliproxy/config.yaml - Save CLIProxy YAML config content
+ * Body: { content: string }
+ * Returns: { success: true, path: string }
+ */
+router.put('/config.yaml', async (req, res) => {
+    try {
+        const { content } = req.body;
+        if (typeof content !== 'string') {
+            res.status(400).json({ error: 'Missing required field: content' });
+            return;
+        }
+        const configPath = (0, config_generator_1.getCliproxyConfigPath)();
+        // Ensure parent directory exists
+        const configDir = path.dirname(configPath);
+        if (!fs.existsSync(configDir)) {
+            fs.mkdirSync(configDir, { recursive: true });
+        }
+        // Write atomically
+        const tempPath = configPath + '.tmp';
+        fs.writeFileSync(tempPath, content);
+        fs.renameSync(tempPath, configPath);
+        res.json({ success: true, path: configPath });
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+// ==================== Auth Files ====================
+/**
+ * GET /api/cliproxy/auth-files - List auth files in auth directory
+ * Returns: { files: Array<{ name, size, mtime }> }
+ */
+router.get('/auth-files', async (_req, res) => {
+    try {
+        const authDir = (0, config_generator_1.getAuthDir)();
+        if (!fs.existsSync(authDir)) {
+            res.json({ files: [] });
+            return;
+        }
+        const entries = fs.readdirSync(authDir, { withFileTypes: true });
+        const files = entries
+            .filter((entry) => entry.isFile())
+            .map((entry) => {
+            const filePath = path.join(authDir, entry.name);
+            const stat = fs.statSync(filePath);
+            return {
+                name: entry.name,
+                size: stat.size,
+                mtime: stat.mtime.getTime(),
+            };
+        });
+        res.json({ files, directory: authDir });
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+/**
+ * GET /api/cliproxy/auth-files/download - Download auth file content
+ * Query: ?name=filename
+ * Returns: file content as octet-stream
+ */
+router.get('/auth-files/download', async (req, res) => {
+    try {
+        const { name } = req.query;
+        if (!name || typeof name !== 'string') {
+            res.status(400).json({ error: 'Missing required query parameter: name' });
+            return;
+        }
+        // Validate filename - prevent path traversal
+        if (name.includes('..') || name.includes('/') || name.includes('\\')) {
+            res.status(400).json({ error: 'Invalid filename' });
+            return;
+        }
+        const authDir = (0, config_generator_1.getAuthDir)();
+        const filePath = path.join(authDir, name);
+        if (!fs.existsSync(filePath)) {
+            res.status(404).json({ error: 'Auth file not found' });
+            return;
+        }
+        const content = fs.readFileSync(filePath);
+        res.setHeader('Content-Disposition', `attachment; filename="${name}"`);
+        res.type('application/octet-stream').send(content);
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+// ==================== Model Updates ====================
+/**
+ * PUT /api/cliproxy/models/:provider - Update model for a provider
+ * Body: { model: string }
+ * Returns: { success: true, provider, model }
+ */
+router.put('/models/:provider', async (req, res) => {
+    try {
+        const { provider } = req.params;
+        const { model } = req.body;
+        if (!model || typeof model !== 'string') {
+            res.status(400).json({ error: 'Missing required field: model' });
+            return;
+        }
+        // Get the settings file for this provider
+        const ccsDir = (0, config_generator_1.getCliproxyWritablePath)();
+        const settingsPath = path.join(ccsDir, `${provider}.settings.json`);
+        if (!fs.existsSync(settingsPath)) {
+            res.status(404).json({ error: `Settings file not found for provider: ${provider}` });
+            return;
+        }
+        // Read and update settings
+        const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+        settings.env = settings.env || {};
+        settings.env.ANTHROPIC_MODEL = model;
+        // Write atomically
+        const tempPath = settingsPath + '.tmp';
+        fs.writeFileSync(tempPath, JSON.stringify(settings, null, 2) + '\n');
+        fs.renameSync(tempPath, settingsPath);
+        res.json({ success: true, provider, model });
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+// ==================== Account Quota ====================
+// NOTE: Specific routes MUST be defined BEFORE generic routes for Express routing to work correctly
+// NOTE: All quota endpoints use in-memory caching (2 min TTL) to reduce external API calls
+/**
+ * GET /api/cliproxy/quota/codex/:accountId - Get Codex quota for a specific account
+ * Returns: CodexQuotaResult with rate limit windows
+ * Caching: 2 minute TTL to reduce ChatGPT API calls
+ */
+router.get('/quota/codex/:accountId', async (req, res) => {
+    const { accountId } = req.params;
+    // Validate accountId - prevent path traversal
+    if (!accountId ||
+        accountId.includes('..') ||
+        accountId.includes('/') ||
+        accountId.includes('\\')) {
+        res.status(400).json({ error: 'Invalid account ID' });
+        return;
+    }
+    try {
+        // Check cache first
+        const cached = (0, quota_response_cache_1.getCachedQuota)('codex', accountId);
+        if (cached) {
+            res.json({ ...cached, cached: true });
+            return;
+        }
+        // Fetch from external API
+        const result = await (0, quota_fetcher_codex_1.fetchCodexQuota)(accountId);
+        // Cache successful results (don't cache errors that need reauth)
+        if (result.success || !result.needsReauth) {
+            (0, quota_response_cache_1.setCachedQuota)('codex', accountId, result);
+        }
+        res.json(result);
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+/**
+ * GET /api/cliproxy/quota/gemini/:accountId - Get Gemini quota for a specific account
+ * Returns: GeminiCliQuotaResult with quota buckets
+ * Caching: 2 minute TTL to reduce Google Cloud API calls
+ */
+router.get('/quota/gemini/:accountId', async (req, res) => {
+    const { accountId } = req.params;
+    // Validate accountId - prevent path traversal
+    if (!accountId ||
+        accountId.includes('..') ||
+        accountId.includes('/') ||
+        accountId.includes('\\')) {
+        res.status(400).json({ error: 'Invalid account ID' });
+        return;
+    }
+    try {
+        // Check cache first
+        const cached = (0, quota_response_cache_1.getCachedQuota)('gemini', accountId);
+        if (cached) {
+            res.json({ ...cached, cached: true });
+            return;
+        }
+        // Fetch from external API
+        const result = await (0, quota_fetcher_gemini_cli_1.fetchGeminiCliQuota)(accountId);
+        // Cache successful results (don't cache errors that need reauth)
+        if (result.success || !result.needsReauth) {
+            (0, quota_response_cache_1.setCachedQuota)('gemini', accountId, result);
+        }
+        res.json(result);
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+/**
+ * GET /api/cliproxy/quota/:provider/:accountId - Get quota for a specific account (generic)
+ * Returns: QuotaResult with model quotas and reset times
+ * NOTE: This generic route MUST come after specific routes (codex, gemini) to avoid matching them
+ * Caching: 2 minute TTL to reduce external API calls
+ */
+router.get('/quota/:provider/:accountId', async (req, res) => {
+    const { provider, accountId } = req.params;
+    // Validate provider - use canonical CLIPROXY_PROFILES
+    const validProviders = [...profile_detector_1.CLIPROXY_PROFILES];
+    if (!validProviders.includes(provider)) {
+        res.status(400).json({
+            error: 'Invalid provider',
+            message: `Provider must be one of: ${validProviders.join(', ')}`,
+        });
+        return;
+    }
+    // Validate accountId - prevent path traversal
+    if (!accountId ||
+        accountId.includes('..') ||
+        accountId.includes('/') ||
+        accountId.includes('\\')) {
+        res.status(400).json({ error: 'Invalid account ID' });
+        return;
+    }
+    try {
+        // Check cache first
+        const cached = (0, quota_response_cache_1.getCachedQuota)(provider, accountId);
+        if (cached) {
+            res.json({ ...cached, cached: true });
+            return;
+        }
+        // Fetch from external API
+        const result = await (0, quota_fetcher_1.fetchAccountQuota)(provider, accountId);
+        // Cache successful results
+        if (result.success) {
+            (0, quota_response_cache_1.setCachedQuota)(provider, accountId, result);
+        }
+        res.json(result);
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+// ==================== Version Management ====================
+/**
+ * GET /api/cliproxy/versions - Get all available CLIProxyAPI versions
+ * Returns: { versions, latestStable, latest, currentVersion, maxStableVersion }
+ */
+router.get('/versions', async (_req, res) => {
+    try {
+        const backend = getConfiguredBackend();
+        const result = await (0, version_checker_1.fetchAllVersions)(false, backend);
+        const currentVersion = (0, binary_manager_1.getInstalledCliproxyVersion)(backend);
+        res.json({
+            ...result,
+            currentVersion,
+            maxStableVersion: platform_detector_1.CLIPROXY_MAX_STABLE_VERSION,
+            faultyRange: platform_detector_1.CLIPROXY_FAULTY_RANGE,
+        });
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+/**
+ * POST /api/cliproxy/install - Install specific CLIProxyAPI version
+ * Body: { version: string, force?: boolean }
+ * Returns: { success, requiresConfirmation?, message? }
+ */
+router.post('/install', async (req, res) => {
+    try {
+        const { version, force } = req.body;
+        if (!version || typeof version !== 'string') {
+            res.status(400).json({ error: 'Missing required field: version' });
+            return;
+        }
+        // Validate version format
+        if (!/^\d+\.\d+\.\d+(-\d+)?$/.test(version)) {
+            res.status(400).json({ error: 'Invalid version format. Expected: X.Y.Z or X.Y.Z-N' });
+            return;
+        }
+        // Check if version is faulty (v81-85) or experimental (above max stable)
+        const isFaulty = (0, version_checker_1.isVersionFaulty)(version);
+        const isExperimental = (0, version_checker_1.isNewerVersion)(version, platform_detector_1.CLIPROXY_MAX_STABLE_VERSION);
+        if (isFaulty && !force) {
+            res.json({
+                success: false,
+                requiresConfirmation: true,
+                message: `Version ${version} has known bugs (v${platform_detector_1.CLIPROXY_FAULTY_RANGE.min.replace(/-\d+$/, '')}-${platform_detector_1.CLIPROXY_FAULTY_RANGE.max.replace(/-\d+$/, '')}). Set force=true to proceed.`,
+            });
+            return;
+        }
+        if (isExperimental && !force) {
+            res.json({
+                success: false,
+                requiresConfirmation: true,
+                message: `Version ${version} is experimental (above stable ${platform_detector_1.CLIPROXY_MAX_STABLE_VERSION.replace(/-\d+$/, '')}). Set force=true to proceed.`,
+            });
+            return;
+        }
+        // Stop proxy first if running
+        await (0, session_tracker_1.stopProxy)();
+        // Small delay to ensure port is released
+        await new Promise((r) => setTimeout(r, 500));
+        // Install the version
+        const backend = getConfiguredBackend();
+        await (0, binary_manager_1.installCliproxyVersion)(version, true, backend);
+        res.json({
+            success: true,
+            version,
+            isFaulty,
+            isExperimental,
+            message: `Successfully installed CLIProxy Plus v${version}`,
+        });
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+/**
+ * POST /api/cliproxy/restart - Restart CLIProxy without version change
+ * Returns: { success, port?, error? }
+ */
+router.post('/restart', async (_req, res) => {
+    try {
+        // Stop proxy first
+        await (0, session_tracker_1.stopProxy)();
+        // Small delay to ensure port is released
+        await new Promise((r) => setTimeout(r, 500));
+        // Start proxy
+        const startResult = await (0, service_manager_1.ensureCliproxyService)();
+        if (startResult.started || startResult.alreadyRunning) {
+            res.json({ success: true, port: startResult.port });
+        }
+        else {
+            res.json({ success: false, error: startResult.error || 'Failed to start proxy' });
+        }
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+exports.default = router;
+//# sourceMappingURL=cliproxy-stats-routes.js.map