npm - @vidda/llm-watcher - Versions diffs - 1.0.0 - Mend

@vidda/llm-watcher 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (27) hide show

package/README.md +30 -0
package/cli.js +35 -0
package/client/dist/assets/geist-cyrillic-ext-wght-normal-DjL33-gN.woff2 +0 -0
package/client/dist/assets/geist-cyrillic-wght-normal-BEAKL7Jp.woff2 +0 -0
package/client/dist/assets/geist-latin-ext-wght-normal-DC-KSUi6.woff2 +0 -0
package/client/dist/assets/geist-latin-wght-normal-BgDaEnEv.woff2 +0 -0
package/client/dist/assets/geist-vietnamese-wght-normal-6IgcOCM7.woff2 +0 -0
package/client/dist/assets/index-BCCqRaer.js +16 -0
package/client/dist/assets/index-Bs1XvUcJ.css +2 -0
package/client/dist/frankenstein.txt +7741 -0
package/client/dist/index.html +23 -0
package/client/package.json +47 -0
package/package.json +40 -0
package/server/dist/server/index.d.ts +3 -0
package/server/dist/server/index.js +53 -0
package/server/dist/server/routes/dashboard.d.ts +3 -0
package/server/dist/server/routes/dashboard.js +205 -0
package/server/dist/server/routes/proxy.d.ts +3 -0
package/server/dist/server/routes/proxy.js +135 -0
package/server/dist/server/services/storage.d.ts +19 -0
package/server/dist/server/services/storage.js +225 -0
package/server/dist/server/services/stream.d.ts +25 -0
package/server/dist/server/services/stream.js +250 -0
package/server/dist/shared/types.d.ts +33 -0
package/server/dist/shared/types.js +2 -0
package/server/package.json +31 -0
package/shared/types.ts +37 -0

package/client/dist/index.html ADDED Viewed

@@ -0,0 +1,23 @@
+<!doctype html>
+<html lang="en" class="dark">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Promptglass</title>
+    <script>
+      (function () {
+        try {
+          var stored = localStorage.getItem('promptglass.theme');
+          var theme = stored === 'light' || stored === 'dark' ? stored : 'dark';
+          document.documentElement.classList.toggle('dark', theme === 'dark');
+        } catch (e) {}
+      })();
+    </script>
+    <script type="module" crossorigin src="/assets/index-BCCqRaer.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-Bs1XvUcJ.css">
+  </head>
+  <body>
+    <div id="root"></div>
+  </body>
+</html>

package/client/package.json ADDED Viewed

@@ -0,0 +1,47 @@
+{
+  "name": "@ngvuhuy/promptglass-client",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite --host",
+    "build": "tsc -b && vite build",
+    "lint": "eslint .",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "@base-ui/react": "^1.3.0",
+    "@fontsource-variable/geist": "^5.2.8",
+    "@ngvuhuy/promptglass-server": "file:../server",
+    "cd": "^0.3.3",
+    "class-variance-authority": "^0.7.1",
+    "clsx": "^2.1.1",
+    "date-fns": "^4.1.0",
+    "diff": "^8.0.3",
+    "i18next": "^26.3.2",
+    "lucide-react": "^0.577.0",
+    "react": "^19.2.4",
+    "react-dom": "^19.2.4",
+    "react-i18next": "^17.0.8",
+    "shadcn": "^4.1.0",
+    "tailwind-merge": "^3.5.0",
+    "tw-animate-css": "^1.4.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.4",
+    "@tailwindcss/vite": "^4.2.2",
+    "@types/diff": "^8.0.0",
+    "@types/node": "^24.12.0",
+    "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.2.3",
+    "@vitejs/plugin-react": "^6.0.1",
+    "eslint": "^9.39.4",
+    "eslint-plugin-react-hooks": "^7.0.1",
+    "eslint-plugin-react-refresh": "^0.5.2",
+    "globals": "^17.4.0",
+    "tailwindcss": "^4.2.2",
+    "typescript": "~5.9.3",
+    "typescript-eslint": "^8.57.0",
+    "vite": "^8.0.1"
+  }
+}

package/package.json ADDED Viewed

@@ -0,0 +1,40 @@
+{
+  "name": "@vidda/llm-watcher",
+  "version": "1.0.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "LLM Request Inspector & Benchmarking Tool",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vidda/llm-watcher.git"
+  },
+  "bin": {
+    "promptglass": "cli.js"
+  },
+  "files": [
+    "cli.js",
+    "server/dist",
+    "client/dist",
+    "shared",
+    "package.json"
+  ],
+  "scripts": {
+    "install": "npm install && cd client && npm install && cd ../server && npm install",
+    "dev": "concurrently --names \"server,client\" --prefix-colors \"yellow,cyan\" \"npm run dev --prefix server\" \"npm run dev --prefix client\"",
+    "build": "npm run build --prefix client && npm run build --prefix server",
+    "start": "NODE_ENV=production node server/dist/server/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "axios": "^1.13.6",
+    "cors": "^2.8.6",
+    "dotenv": "^17.3.1",
+    "eventsource-parser": "^3.0.6",
+    "express": "^5.2.1",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "concurrently": "^9.2.1"
+  }
+}

package/server/dist/server/index.d.ts ADDED Viewed

@@ -0,0 +1,3 @@
+import { Express } from 'express';
+declare const app: Express;
+export default app;

package/server/dist/server/index.js ADDED Viewed

@@ -0,0 +1,53 @@
+import express from 'express';
+import cors from 'cors';
+import dotenv from 'dotenv';
+import path from 'node:path';
+import fs from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { getDb, closeDb } from './services/storage.js';
+import proxyRouter from './routes/proxy.js';
+import dashboardRouter from './routes/dashboard.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// Try to load .env from the current working directory first, then from the project root
+dotenv.config();
+// In development, the root is one level up from server/. In production (dist), it is three levels up from server/dist/server/
+const isDist = path.basename(path.dirname(__dirname)) === 'dist';
+const projectRoot = isDist ? path.resolve(__dirname, '../../../') : path.resolve(__dirname, '../');
+dotenv.config({ path: path.join(projectRoot, '.env') });
+const app = express();
+const PORT = process.env.PORT || 3001;
+app.use(cors());
+app.use(express.json({ limit: '50mb' }));
+app.get('/api/health', (_req, res) => {
+    res.json({ status: 'ok', timestamp: new Date().toISOString() });
+});
+app.use('/v1', proxyRouter);
+app.use('/api', dashboardRouter);
+// Serve React App in production
+if (process.env.NODE_ENV === 'production') {
+    const clientDist = path.resolve(projectRoot, 'client/dist');
+    if (fs.existsSync(clientDist)) {
+        app.use(express.static(clientDist));
+        app.get('/*path', (req, res) => {
+            res.sendFile(path.join(clientDist, 'index.html'));
+        });
+    }
+    else {
+        console.warn(`Warning: Static files directory not found at ${clientDist}`);
+    }
+}
+const server = app.listen(PORT, () => {
+    console.log(`Server running on port ${PORT}`);
+    getDb();
+});
+function shutdown() {
+    console.log('Shutting down...');
+    closeDb();
+    server.close(() => {
+        process.exit(0);
+    });
+}
+process.on('SIGINT', shutdown);
+process.on('SIGTERM', shutdown);
+export default app;

package/server/dist/server/routes/dashboard.d.ts ADDED Viewed

@@ -0,0 +1,3 @@
+import { Router } from 'express';
+declare const router: Router;
+export default router;

package/server/dist/server/routes/dashboard.js ADDED Viewed

@@ -0,0 +1,205 @@
+import { Router } from 'express';
+import { getRequests, getRequestById, saveSetting, getSetting, deleteRequest, deleteRequests, getProxyProfiles, getActiveProxyProfile, setActiveProxyProfile, createProxyProfile, updateProxyProfile, deleteProxyProfile } from '../services/storage.js';
+const router = Router();
+// GET /api/requests
+router.get('/requests', (req, res) => {
+    try {
+        const limit = parseInt(req.query.limit) || 50;
+        const offset = parseInt(req.query.offset) || 0;
+        const requests = getRequests(limit, offset);
+        res.json(requests);
+    }
+    catch (error) {
+        console.error('Error fetching requests:', error);
+        res.status(500).json({ error: 'Failed to fetch requests' });
+    }
+});
+// GET /api/requests/:id
+router.get('/requests/:id', (req, res) => {
+    try {
+        const id = parseInt(req.params.id);
+        if (isNaN(id)) {
+            res.status(400).json({ error: 'Invalid request ID' });
+            return;
+        }
+        const request = getRequestById(id);
+        if (!request) {
+            res.status(404).json({ error: 'Request not found' });
+            return;
+        }
+        res.json(request);
+    }
+    catch (error) {
+        console.error('Error fetching request:', error);
+        res.status(500).json({ error: 'Failed to fetch request' });
+    }
+});
+// DELETE /api/requests/:id
+router.delete('/requests/:id', (req, res) => {
+    try {
+        const id = parseInt(req.params.id);
+        if (isNaN(id)) {
+            res.status(400).json({ error: 'Invalid request ID' });
+            return;
+        }
+        deleteRequest(id);
+        res.json({ success: true });
+    }
+    catch (error) {
+        console.error('Error deleting request:', error);
+        res.status(500).json({ error: 'Failed to delete request' });
+    }
+});
+// DELETE /api/requests
+router.delete('/requests', (req, res) => {
+    try {
+        const { ids } = req.body;
+        if (!Array.isArray(ids) || ids.length === 0) {
+            res.status(400).json({ error: 'Invalid request IDs' });
+            return;
+        }
+        deleteRequests(ids);
+        res.json({ success: true });
+    }
+    catch (error) {
+        console.error('Error deleting requests:', error);
+        res.status(500).json({ error: 'Failed to delete requests' });
+    }
+});
+// PUT /api/settings
+router.put('/settings', (req, res) => {
+    try {
+        const { targetUrl, targetApiKey } = req.body;
+        if (targetUrl !== undefined) {
+            saveSetting('TARGET_URL', targetUrl);
+        }
+        if (targetApiKey !== undefined) {
+            saveSetting('TARGET_API_KEY', targetApiKey);
+        }
+        res.json({ success: true });
+    }
+    catch (error) {
+        console.error('Error saving settings:', error);
+        res.status(500).json({ error: 'Failed to save settings' });
+    }
+});
+// GET /api/settings
+router.get('/settings', (_, res) => {
+    try {
+        const targetUrl = getSetting('TARGET_URL') || process.env.TARGET_URL || '';
+        const targetApiKey = getSetting('TARGET_API_KEY') || process.env.TARGET_API_KEY || '';
+        res.json({
+            targetUrl,
+            targetApiKey: targetApiKey ? '***' : '' // Don't send actual key back to client
+        });
+    }
+    catch (error) {
+        console.error('Error fetching settings:', error);
+        res.status(500).json({ error: 'Failed to fetch settings' });
+    }
+});
+// Mask API key before sending to client: return '***' if set, '' if empty
+function maskProfile(profile) {
+    return {
+        ...profile,
+        targetApiKey: profile.targetApiKey ? '***' : '',
+    };
+}
+// GET /api/proxy-profiles
+router.get('/proxy-profiles', (_, res) => {
+    try {
+        const profiles = getProxyProfiles().map(maskProfile);
+        const active = getActiveProxyProfile();
+        res.json({ profiles, activeId: active?.id || null });
+    }
+    catch (error) {
+        console.error('Error fetching proxy profiles:', error);
+        res.status(500).json({ error: 'Failed to fetch proxy profiles' });
+    }
+});
+// POST /api/proxy-profiles  (create)
+router.post('/proxy-profiles', (req, res) => {
+    try {
+        const { name, targetUrl, targetApiKey, model, inputTokenPrice, outputTokenPrice, cachedInputTokenPrice } = req.body;
+        if (!name || !targetUrl) {
+            res.status(400).json({ error: 'name and targetUrl are required' });
+            return;
+        }
+        const profile = createProxyProfile(name, targetUrl, targetApiKey || '', model, inputTokenPrice, outputTokenPrice, cachedInputTokenPrice);
+        res.json({ profile: maskProfile(profile) });
+    }
+    catch (error) {
+        console.error('Error creating proxy profile:', error);
+        res.status(500).json({ error: 'Failed to create proxy profile' });
+    }
+});
+// PUT /api/proxy-profiles/active  (switch active profile)
+// NOTE: must be registered before '/proxy-profiles/:id', otherwise
+// Express matches the literal segment 'active' against the :id param.
+router.put('/proxy-profiles/active', (req, res) => {
+    try {
+        const { id } = req.body;
+        if (!id) {
+            res.status(400).json({ error: 'id is required' });
+            return;
+        }
+        const profiles = getProxyProfiles();
+        if (!profiles.find((p) => p.id === id)) {
+            res.status(404).json({ error: 'Profile not found' });
+            return;
+        }
+        setActiveProxyProfile(id);
+        res.json({ success: true, activeId: id });
+    }
+    catch (error) {
+        console.error('Error activating proxy profile:', error);
+        res.status(500).json({ error: 'Failed to activate proxy profile' });
+    }
+});
+// PUT /api/proxy-profiles/:id  (update)
+router.put('/proxy-profiles/:id', (req, res) => {
+    try {
+        const id = String(req.params.id);
+        const { name, targetUrl, targetApiKey, model, inputTokenPrice, outputTokenPrice, cachedInputTokenPrice } = req.body;
+        const updates = {};
+        if (name !== undefined)
+            updates.name = name;
+        if (targetUrl !== undefined)
+            updates.targetUrl = targetUrl;
+        // Only update key if client provided a real value (not the '***' mask)
+        if (targetApiKey !== undefined && targetApiKey !== '***')
+            updates.targetApiKey = targetApiKey;
+        if (model !== undefined)
+            updates.model = model;
+        if (inputTokenPrice !== undefined)
+            updates.inputTokenPrice = inputTokenPrice;
+        if (outputTokenPrice !== undefined)
+            updates.outputTokenPrice = outputTokenPrice;
+        if (cachedInputTokenPrice !== undefined)
+            updates.cachedInputTokenPrice = cachedInputTokenPrice;
+        const profile = updateProxyProfile(id, updates);
+        if (!profile) {
+            res.status(404).json({ error: 'Profile not found' });
+            return;
+        }
+        res.json({ profile: maskProfile(profile) });
+    }
+    catch (error) {
+        console.error('Error updating proxy profile:', error);
+        res.status(500).json({ error: 'Failed to update proxy profile' });
+    }
+});
+// DELETE /api/proxy-profiles/:id
+router.delete('/proxy-profiles/:id', (req, res) => {
+    try {
+        const id = String(req.params.id);
+        deleteProxyProfile(id);
+        const active = getActiveProxyProfile();
+        res.json({ success: true, activeId: active?.id || null });
+    }
+    catch (error) {
+        console.error('Error deleting proxy profile:', error);
+        res.status(500).json({ error: 'Failed to delete proxy profile' });
+    }
+});
+export default router;

package/server/dist/server/routes/proxy.d.ts ADDED Viewed

@@ -0,0 +1,3 @@
+import { Router } from 'express';
+declare const router: Router;
+export default router;

package/server/dist/server/routes/proxy.js ADDED Viewed

@@ -0,0 +1,135 @@
+import { Router } from 'express';
+import { saveRequest, getSetting, updateRequest, getActiveProxyProfile } from '../services/storage.js';
+import { processStream } from '../services/stream.js';
+import crypto from 'node:crypto';
+const router = Router();
+// Helper to hash context for cache hit detection
+function hashContext(body) {
+    // Handle Chat (messages), Completions (prompt), and Responses (instructions + input)
+    const context = body.messages || body.prompt || { instructions: body.instructions, input: body.input };
+    const content = JSON.stringify(context);
+    return crypto.createHash('sha256').update(content).digest('hex');
+}
+async function handleProxy(req, res, endpoint) {
+    const activeProfile = getActiveProxyProfile();
+    const configuredUrl = activeProfile?.targetUrl || getSetting('TARGET_URL') || process.env.TARGET_URL;
+    // Strip trailing slashes and common suffixes to get the base URL
+    let baseUrl = (configuredUrl || '').replace(/\/+$/, '');
+    if (baseUrl.endsWith('/chat/completions')) {
+        baseUrl = baseUrl.replace(/\/chat\/completions$/, '');
+    }
+    else if (baseUrl.endsWith('/responses')) {
+        baseUrl = baseUrl.replace(/\/responses$/, '');
+    }
+    const targetUrl = `${baseUrl}/${endpoint}`;
+    const targetApiKey = activeProfile?.targetApiKey || getSetting('TARGET_API_KEY') || process.env.TARGET_API_KEY;
+    if (!baseUrl) {
+        res.status(500).json({ error: 'Target URL is not configured.' });
+        return;
+    }
+    const requestBody = { ...req.body };
+    // Override model if the active proxy profile specifies one
+    if (activeProfile?.model) {
+        requestBody.model = activeProfile.model;
+    }
+    // OpenAI spec for chat/completions include_usage
+    if (endpoint === 'chat/completions' && requestBody.stream === true && !requestBody.stream_options) {
+        requestBody.stream_options = { include_usage: true };
+    }
+    const isStream = requestBody.stream === true;
+    const contextHash = hashContext(requestBody);
+    // Determine mode from custom header, defaulting to 'observe'
+    const modeHeader = req.headers['x-promptglass-mode'];
+    const mode = (modeHeader === 'chat' || modeHeader === 'benchmark') ? modeHeader : 'observe';
+    // Headers for the target LLM
+    const headers = {
+        'Content-Type': 'application/json',
+    };
+    if (targetApiKey) {
+        headers['Authorization'] = `Bearer ${targetApiKey}`;
+    }
+    // Pass through Authorization if provided and target key isn't set
+    if (req.headers.authorization && !targetApiKey) {
+        headers['Authorization'] = req.headers.authorization;
+    }
+    const requestStartTime = performance.now();
+    // Save request immediately as "pending"
+    const requestId = saveRequest(mode, requestBody, undefined, undefined, contextHash);
+    try {
+        // console.log(`[PromptGlass] → ${targetUrl}\n${JSON.stringify(requestBody, null, 2)}`);
+        const targetResponse = await fetch(targetUrl, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(requestBody),
+        });
+        if (!targetResponse.ok) {
+            // If error, proxy it back but don't record metrics
+            const errorText = await targetResponse.text();
+            res.status(targetResponse.status).send(errorText);
+            return;
+        }
+        if (isStream && targetResponse.body) {
+            // Set required headers for SSE
+            res.setHeader('Content-Type', 'text/event-stream');
+            res.setHeader('Cache-Control', 'no-cache');
+            res.setHeader('Connection', 'keep-alive');
+            let lastDbUpdate = 0;
+            const { clientStream, metricsPromise } = processStream(targetResponse, requestStartTime, requestBody, (body) => {
+                const now = Date.now();
+                // Throttled update to database during streaming (every 100ms)
+                if (now - lastDbUpdate > 100) {
+                    updateRequest(requestId, body);
+                    lastDbUpdate = now;
+                }
+            });
+            const reader = clientStream.getReader();
+            const pump = async () => {
+                try {
+                    while (true) {
+                        const { done, value } = await reader.read();
+                        if (done)
+                            break;
+                        res.write(value);
+                    }
+                    res.end();
+                }
+                catch (err) {
+                    console.error('Error pumping stream to client:', err);
+                    res.end();
+                }
+            };
+            pump();
+            // Wait for the stream to finish and metrics to be computed, then save
+            const { metrics, responseBody } = await metricsPromise;
+            updateRequest(requestId, responseBody, metrics);
+        }
+        else {
+            // Non-streaming response handling
+            const responseData = (await targetResponse.json());
+            const totalLatency = performance.now() - requestStartTime;
+            let promptTokens = responseData.usage?.prompt_tokens || responseData.usage?.input_tokens || 0;
+            if (!promptTokens) {
+                const context = requestBody.messages || (requestBody.instructions + (requestBody.input || ''));
+                promptTokens = Math.ceil(JSON.stringify(context).length / 4);
+            }
+            const metrics = {
+                ttft: totalLatency,
+                totalLatency,
+                tokensPerSecond: 0, // Not applicable for non-streaming
+                promptPrefillSpeed: (promptTokens && totalLatency > 0) ? (promptTokens / (totalLatency / 1000)) : 0,
+                tokenCount: responseData.usage?.completion_tokens || responseData.usage?.output_tokens || 0,
+                interTokenLatencies: [],
+                completedAt: new Date().toISOString()
+            };
+            res.json(responseData);
+            updateRequest(requestId, responseData, metrics);
+        }
+    }
+    catch (error) {
+        console.error('Proxy Error:', error);
+        res.status(500).json({ error: 'Failed to proxy request', details: error.message });
+    }
+}
+router.post(['/chat/completions', '/v1/chat/completions'], (req, res) => handleProxy(req, res, 'chat/completions'));
+router.post(['/responses', '/v1/responses'], (req, res) => handleProxy(req, res, 'responses'));
+export default router;

package/server/dist/server/services/storage.d.ts ADDED Viewed

@@ -0,0 +1,19 @@
+import { DatabaseSync } from 'node:sqlite';
+import { Metrics, RequestMode, StoredRequest, ProxyProfile } from '../../shared/types.js';
+export declare function getDb(dbPath?: string): DatabaseSync;
+export declare function saveRequest(mode: RequestMode, requestBody: any, responseBody?: any, metrics?: Metrics, contextHash?: string): number;
+export declare function updateRequest(id: number, responseBody: any, metrics?: Metrics): void;
+export declare function getRequests(limit?: number, offset?: number): StoredRequest[];
+export declare function getRequestById(id: number): StoredRequest | null;
+export declare function deleteRequest(id: number): void;
+export declare function deleteRequests(ids: number[]): void;
+export declare function saveSetting(key: string, value: string): void;
+export declare function getSetting(key: string): string | null;
+export declare function closeDb(): void;
+export declare function getProxyProfiles(): ProxyProfile[];
+export declare function saveProxyProfiles(profiles: ProxyProfile[]): void;
+export declare function getActiveProxyProfile(): ProxyProfile | null;
+export declare function setActiveProxyProfile(id: string): void;
+export declare function createProxyProfile(name: string, targetUrl: string, targetApiKey: string, model?: string, inputTokenPrice?: number, outputTokenPrice?: number, cachedInputTokenPrice?: number): ProxyProfile;
+export declare function updateProxyProfile(id: string, updates: Partial<Omit<ProxyProfile, 'id'>>): ProxyProfile | null;
+export declare function deleteProxyProfile(id: string): void;