gemini-cli-devtools 0.1.4 → 0.2.0

package/dist/src/index.js

@@ -4,25 +4,19 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import http from 'node:http';
-import { EventEmitter } from 'node:events';
-import { execFile } from 'node:child_process';
-import fs from 'node:fs';
-import path from 'node:path';
-import os from 'node:os';
+import { randomUUID } from 'node:crypto';
+import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import { EventEmitter } from 'node:events';
 import { WebSocketServer } from 'ws';
-const VITE_DEV_PORT = 5174;
-// Check if running in dev mode by looking for src directory (not in npm package)
-const isDev = (() => {
-    const srcDir = path.dirname(fileURLToPath(import.meta.url));
-    // In dev: src/index.ts -> srcDir is "src"
-    // In prod: dist/src/index.js -> srcDir is "dist/src"
-    return srcDir.endsWith('/src') && !srcDir.includes('/dist/');
-})();
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const indexHtml = readFileSync(join(__dirname, '../../client/index.html'), 'utf-8');
+const mainJs = readFileSync(join(__dirname, '../client/main.js'), 'utf-8');
 /**
  * DevTools Viewer
  *
- * Deeply discovers and tails session logs across all projects.
+ * Receives logs via WebSocket from CLI sessions.
  */
 export class DevTools extends EventEmitter {
     static instance;
@@ -31,8 +25,8 @@ export class DevTools extends EventEmitter {
     server = null;
     wss = null;
     sessions = new Map();
+    heartbeatTimer = null;
     port = 25417;
-    watchedFiles = new Map(); // filePath -> lastSize
     constructor() {
         super();
     }
@@ -42,126 +36,17 @@ export class DevTools extends EventEmitter {
         }
         return DevTools.instance;
     }
-    getNetworkLogs() {
-        return this.logs;
-    }
-    getConsoleLogs() {
-        return this.consoleLogs;
-    }
-    /**
-     * Main entry for log discovery.
-     * It scans both user home and system tmp for .gemini/tmp folders.
-     */
-    setLogFile() {
-        const potentialRoots = [
-            path.join(os.homedir(), '.gemini', 'tmp'),
-            path.join(os.tmpdir(), '.gemini', 'tmp'),
-        ];
-        for (const baseDir of potentialRoots) {
-            if (fs.existsSync(baseDir)) {
-                console.log(`🔍 Scanning for logs in: ${baseDir}`);
-                this.deepDiscover(baseDir);
-                this.watchRoot(baseDir);
-            }
-        }
-    }
-    watchRoot(root) {
-        try {
-            fs.watch(root, { recursive: true }, (_event, filename) => {
-                if (filename &&
-                    filename.includes('session-') &&
-                    filename.endsWith('.jsonl')) {
-                    this.deepDiscover(root);
-                }
-            });
-        }
-        catch {
-            setInterval(() => this.deepDiscover(root), 2000);
-        }
-    }
-    deepDiscover(dir) {
-        try {
-            const items = fs.readdirSync(dir);
-            for (const item of items) {
-                const fullPath = path.join(dir, item);
-                let stats;
-                try {
-                    stats = fs.statSync(fullPath);
-                }
-                catch {
-                    continue;
-                }
-                if (stats.isDirectory()) {
-                    if (item === 'logs' || item.length > 20) {
-                        this.deepDiscover(fullPath);
-                    }
-                }
-                else if (item.startsWith('session-') && item.endsWith('.jsonl')) {
-                    if (!this.watchedFiles.has(fullPath)) {
-                        this.watchedFiles.set(fullPath, 0);
-                        this.readNewLogs(fullPath, 0);
-                    }
-                    else if (stats.size > this.watchedFiles.get(fullPath)) {
-                        this.readNewLogs(fullPath, this.watchedFiles.get(fullPath));
-                        this.watchedFiles.set(fullPath, stats.size);
-                    }
-                }
-            }
-        }
-        catch {
-            /* ignore */
-        }
-    }
-    readNewLogs(filePath, startByte) {
-        try {
-            const filename = path.basename(filePath);
-            const sessionMatch = filename.match(/session-(.*)\.jsonl/);
-            const fallbackSessionId = sessionMatch ? sessionMatch[1] : undefined;
-            const stream = fs.createReadStream(filePath, { start: startByte });
-            let buffer = '';
-            stream.on('data', (chunk) => {
-                buffer += chunk.toString();
-                const lines = buffer.split('\n');
-                buffer = lines.pop() || '';
-                for (const line of lines) {
-                    if (!line.trim())
-                        continue;
-                    try {
-                        const entry = JSON.parse(line);
-                        const sid = entry.sessionId || fallbackSessionId;
-                        if (entry.type === 'console') {
-                            this.addInternalConsoleLog(entry.payload, sid, entry.timestamp);
-                        }
-                        else if (entry.type === 'network') {
-                            this.addInternalNetworkLog(entry.payload, sid, entry.timestamp);
-                        }
-                    }
-                    catch {
-                        /* ignore */
-                    }
-                }
-                try {
-                    this.watchedFiles.set(filePath, fs.statSync(filePath).size);
-                }
-                catch {
-                    /* ignore */
-                }
-            });
-        }
-        catch {
-            /* ignore */
-        }
-    }
     addInternalConsoleLog(payload, sessionId, timestamp) {
-        this.consoleLogs.push({
+        const entry = {
             ...payload,
-            id: Math.random().toString(36).substring(7),
+            id: randomUUID(),
             sessionId,
             timestamp: timestamp || Date.now(),
-        });
+        };
+        this.consoleLogs.push(entry);
         if (this.consoleLogs.length > 5000)
             this.consoleLogs.shift();
-        this.emit('console-update');
+        this.emit('console-update', entry);
     }
     addInternalNetworkLog(payload, sessionId, timestamp) {
         if (!payload.id)
@@ -173,7 +58,6 @@ export class DevTools extends EventEmitter {
             if (payload.chunk) {
                 const chunks = existing.chunks || [];
                 chunks.push(payload.chunk);
-                console.log(`[DevTools] Received chunk ${payload.chunk.index} for request ${payload.id}, total chunks: ${chunks.length}`);
                 this.logs[existingIndex] = {
                     ...existing,
                     chunks,
@@ -191,31 +75,47 @@ export class DevTools extends EventEmitter {
                         : existing.response,
                 };
             }
+            this.emit('update', this.logs[existingIndex]);
         }
         else if (payload.url) {
-            this.logs.push({
+            const entry = {
                 ...payload,
                 sessionId,
                 timestamp: timestamp || Date.now(),
                 chunks: payload.chunk ? [payload.chunk] : undefined,
-            });
+            };
+            this.logs.push(entry);
             if (this.logs.length > 2000)
                 this.logs.shift();
+            this.emit('update', entry);
         }
-        this.emit('update');
     }
     getUrl() {
         return `http://127.0.0.1:${this.port}`;
     }
-    getClientPath() {
-        const srcDir = path.dirname(fileURLToPath(import.meta.url));
-        // When running with tsx from src/, look for dist/client
-        // When running compiled from dist/src/, look for ../client
-        const distClient = path.join(srcDir, '../dist/client');
-        if (fs.existsSync(distClient)) {
-            return distClient;
-        }
-        return path.join(srcDir, '../client');
+    getPort() {
+        return this.port;
+    }
+    stop() {
+        return new Promise((resolve) => {
+            if (this.heartbeatTimer) {
+                clearInterval(this.heartbeatTimer);
+                this.heartbeatTimer = null;
+            }
+            if (this.wss) {
+                this.wss.close();
+                this.wss = null;
+            }
+            if (this.server) {
+                this.server.close(() => resolve());
+                this.server = null;
+            }
+            else {
+                resolve();
+            }
+            // Reset singleton so a fresh start() is possible
+            DevTools.instance = undefined;
+        });
     }
     start() {
         return new Promise((resolve) => {
@@ -223,100 +123,53 @@ export class DevTools extends EventEmitter {
                 resolve(this.getUrl());
                 return;
             }
-            const clientPath = this.getClientPath();
             this.server = http.createServer((req, res) => {
                 res.setHeader('Access-Control-Allow-Origin', '*');
                 // API routes
-                if (req.url === '/logs') {
-                    res.writeHead(200, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify(this.logs));
-                }
-                else if (req.url === '/console-logs') {
-                    res.writeHead(200, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify(this.consoleLogs));
-                }
-                else if (req.url === '/sessions') {
-                    res.writeHead(200, { 'Content-Type': 'application/json' });
-                    const sessionIds = Array.from(this.sessions.keys());
-                    res.end(JSON.stringify(sessionIds));
-                }
-                else if (req.url === '/events') {
+                if (req.url === '/events') {
                     res.writeHead(200, {
                         'Content-Type': 'text/event-stream',
                         'Cache-Control': 'no-cache',
                         Connection: 'keep-alive',
                     });
-                    const l1 = () => res.write(`event: update\ndata: \n\n`);
-                    const l2 = () => res.write(`event: console-update\ndata: \n\n`);
-                    const l3 = () => res.write(`event: session-update\ndata: \n\n`);
-                    this.on('update', l1);
-                    this.on('console-update', l2);
-                    this.on('session-update', l3);
+                    // Send full snapshot on connect
+                    const snapshot = JSON.stringify({
+                        networkLogs: this.logs,
+                        consoleLogs: this.consoleLogs,
+                        sessions: Array.from(this.sessions.keys()),
+                    });
+                    res.write(`event: snapshot\ndata: ${snapshot}\n\n`);
+                    // Incremental updates
+                    const onNetwork = (log) => {
+                        res.write(`event: network\ndata: ${JSON.stringify(log)}\n\n`);
+                    };
+                    const onConsole = (log) => {
+                        res.write(`event: console\ndata: ${JSON.stringify(log)}\n\n`);
+                    };
+                    const onSession = () => {
+                        const sessions = Array.from(this.sessions.keys());
+                        res.write(`event: session\ndata: ${JSON.stringify(sessions)}\n\n`);
+                    };
+                    this.on('update', onNetwork);
+                    this.on('console-update', onConsole);
+                    this.on('session-update', onSession);
                     req.on('close', () => {
-                        this.off('update', l1);
-                        this.off('console-update', l2);
-                        this.off('session-update', l3);
+                        this.off('update', onNetwork);
+                        this.off('console-update', onConsole);
+                        this.off('session-update', onSession);
                     });
                 }
-                else if (req.method === 'POST' && req.url === '/ingest') {
-                    let body = '';
-                    req.on('data', (chunk) => (body += chunk));
-                    req.on('end', () => {
-                        try {
-                            const entry = JSON.parse(body);
-                            if (entry.type === 'console') {
-                                this.addInternalConsoleLog(entry.payload, entry.sessionId, entry.timestamp);
-                            }
-                            else if (entry.type === 'network') {
-                                this.addInternalNetworkLog(entry.payload, entry.sessionId, entry.timestamp);
-                            }
-                            res.writeHead(200);
-                            res.end('OK');
-                        }
-                        catch {
-                            res.writeHead(400);
-                            res.end('Invalid JSON');
-                        }
-                    });
+                else if (req.url === '/' || req.url === '/index.html') {
+                    res.writeHead(200, { 'Content-Type': 'text/html' });
+                    res.end(indexHtml);
                 }
-                else if (req.method === 'POST' && req.url === '/api/to-textproto') {
-                    let body = '';
-                    req.on('data', (chunk) => (body += chunk));
-                    req.on('end', () => {
-                        const tmpIn = path.join(os.tmpdir(), `req-${Date.now()}.json`);
-                        fs.writeFileSync(tmpIn, body);
-                        const script = `
-import sys
-sys.path.insert(0, '/tmp/proto_gen')
-from google.cloud.aiplatform.v1 import prediction_service_pb2
-from google.protobuf.json_format import Parse
-from google.protobuf import text_format
-import json
-
-with open(sys.argv[1]) as f:
-    msg = Parse(f.read(), prediction_service_pb2.GenerateContentRequest(), ignore_unknown_fields=True)
-print(text_format.MessageToString(msg, as_utf8=True), end='')
-`;
-                        execFile('/tmp/proto_venv/bin/python3', ['-c', script, tmpIn], { maxBuffer: 10 * 1024 * 1024 }, (err, stdout, stderr) => {
-                            fs.unlinkSync(tmpIn);
-                            if (err) {
-                                res.writeHead(500, { 'Content-Type': 'text/plain' });
-                                res.end(stderr || err.message);
-                            }
-                            else {
-                                res.writeHead(200, { 'Content-Type': 'text/plain' });
-                                res.end(stdout);
-                            }
-                        });
-                    });
-                }
-                else if (isDev) {
-                    // Dev mode: proxy to Vite
-                    this.proxyToVite(req, res);
+                else if (req.url === '/assets/main.js') {
+                    res.writeHead(200, { 'Content-Type': 'application/javascript' });
+                    res.end(mainJs);
                 }
                 else {
-                    // Production: serve static files
-                    this.serveStatic(req, res, clientPath);
+                    res.writeHead(404);
+                    res.end('Not Found');
                 }
             });
             this.server.on('error', (e) => {
@@ -351,7 +204,6 @@ print(text_format.MessageToString(msg, as_utf8=True), end='')
                             ws,
                             lastPing: Date.now(),
                         });
-                        console.log(`📡 WebSocket registered: ${sessionId}`);
                         // Notify session update
                         this.emit('session-update');
                         // Send registration acknowledgement
@@ -365,28 +217,25 @@ print(text_format.MessageToString(msg, as_utf8=True), end='')
                         this.handleWebSocketMessage(sessionId, message);
                     }
                 }
-                catch (err) {
-                    console.error('Invalid WebSocket message:', err);
+                catch {
+                    // Invalid WebSocket message
                 }
             });
             ws.on('close', () => {
                 if (sessionId) {
-                    console.log(`📡 WebSocket disconnected: ${sessionId}`);
                     this.sessions.delete(sessionId);
-                    this.emit('session-disconnected', sessionId);
                     this.emit('session-update');
                 }
             });
-            ws.on('error', (err) => {
-                console.error(`WebSocket error:`, err);
+            ws.on('error', () => {
+                // WebSocket error — no action needed
             });
         });
         // Heartbeat mechanism
-        setInterval(() => {
+        this.heartbeatTimer = setInterval(() => {
             const now = Date.now();
             this.sessions.forEach((session, sessionId) => {
                 if (now - session.lastPing > 30000) {
-                    console.log(`⚠️ Session ${sessionId} timeout, closing...`);
                     session.ws.close();
                     this.sessions.delete(sessionId);
                 }
@@ -412,47 +261,7 @@ print(text_format.MessageToString(msg, as_utf8=True), end='')
                 this.addInternalNetworkLog(message.payload, sessionId, message.timestamp);
                 break;
             default:
-                console.warn(`Unknown message type: ${message.type}`);
+                break;
         }
     }
-    proxyToVite(req, res) {
-        const proxyReq = http.request({
-            hostname: '127.0.0.1',
-            port: VITE_DEV_PORT,
-            path: req.url,
-            method: req.method,
-            headers: req.headers,
-        }, (proxyRes) => {
-            res.writeHead(proxyRes.statusCode || 200, proxyRes.headers);
-            proxyRes.pipe(res);
-        });
-        proxyReq.on('error', () => {
-            res.writeHead(502);
-            res.end('Vite dev server not ready');
-        });
-        req.pipe(proxyReq);
-    }
-    serveStatic(req, res, clientPath) {
-        const url = req.url === '/' ? '/index.html' : req.url || '/index.html';
-        const filePath = path.join(clientPath, url);
-        fs.readFile(filePath, (err, data) => {
-            if (err) {
-                res.writeHead(404);
-                res.end('Not Found');
-                return;
-            }
-            const ext = path.extname(filePath);
-            const contentTypes = {
-                '.html': 'text/html',
-                '.js': 'application/javascript',
-                '.css': 'text/css',
-                '.svg': 'image/svg+xml',
-                '.json': 'application/json',
-            };
-            res.writeHead(200, {
-                'Content-Type': contentTypes[ext] || 'text/plain',
-            });
-            res.end(data);
-        });
-    }
 }

package/dist/src/types.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export interface NetworkLog {
+    id: string;
+    sessionId?: string;
+    timestamp: number;
+    method: string;
+    url: string;
+    headers: Record<string, string | string[] | undefined>;
+    body?: string;
+    pending?: boolean;
+    chunks?: Array<{
+        index: number;
+        data: string;
+        timestamp: number;
+    }>;
+    response?: {
+        status: number;
+        headers: Record<string, string | string[] | undefined>;
+        body?: string;
+        durationMs: number;
+    };
+    error?: string;
+}
+export interface ConsoleLogPayload {
+    type: 'log' | 'warn' | 'error' | 'debug' | 'info';
+    content: string;
+}
+export interface InspectorConsoleLog extends ConsoleLogPayload {
+    id: string;
+    sessionId?: string;
+    timestamp: number;
+}

package/dist/src/types.js

@@ -0,0 +1,6 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export {};

package/package.json

@@ -1,16 +1,18 @@
 {
   "name": "gemini-cli-devtools",
-  "version": "0.1.4",
+  "version": "0.2.0",
   "type": "module",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
-  "bin": {
-    "gemini-cli-devtools": "dist/src/bin.js"
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "default": "./dist/src/index.js"
+    }
   },
   "scripts": {
-    "dev": "concurrently -k \"vite --port 5174\" \"tsx watch src/bin.ts\"",
-    "build": "npm run build:client && tsc --outDir dist/src --module ESNext --target ESNext --moduleResolution bundler src/index.ts src/bin.ts",
-    "build:client": "vite build"
+    "build": "npm run build:client && tsc --outDir dist/src --declaration --module ESNext --target ESNext --moduleResolution bundler src/index.ts",
+    "build:client": "node esbuild.client.js"
   },
   "files": [
     "dist"
@@ -19,19 +21,16 @@
     "node": ">=20"
   },
   "dependencies": {
-    "react": "^18.2.0",
-    "react-dom": "^18.2.0",
     "ws": "^8.16.0"
   },
   "devDependencies": {
+    "@types/node": "^20.11.24",
     "@types/react": "^18.2.0",
     "@types/react-dom": "^18.2.0",
     "@types/ws": "^8.5.10",
-    "@vitejs/plugin-react": "^4.2.0",
-    "typescript": "^5.3.3",
-    "vite": "^5.0.0",
-    "@types/node": "^20.11.24",
-    "concurrently": "^8.2.2",
-    "tsx": "^4.7.0"
+    "esbuild": "^0.24.0",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "typescript": "^5.3.3"
   }
 }