Add unified Live panel with Android logcat streaming and wall clock timestamps

Unify serial port and logcat into a single "Live" panel with source
dropdown. Add LogcatHandler (adb logcat child process), prepend
[HH:MM:SS.mmm] wall clock timestamps to all streamed lines for
time-gap analysis, and rename serial UI to live throughout.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: ozgesolidkey

src/main/index.ts

@@ -11,6 +11,7 @@ import { analyzerRegistry, AnalyzerOptions } from './analyzers';
 import { loadDatadogConfig, saveDatadogConfig, clearDatadogConfig, fetchDatadogLogs, DatadogConfig, DatadogFetchParams } from './datadogClient';
 import { startApiServer, stopApiServer, ApiContext } from './api-server';
 import { SerialHandler } from './serialHandler';
+import { LogcatHandler } from './logcatHandler';
 
 let mainWindow: BrowserWindow | null = null;
 let searchSignal: { cancelled: boolean } = { cancelled: false };
@@ -20,6 +21,9 @@ let currentFilePath: string | null = null;
 // Serial port handler
 const serialHandler = new SerialHandler();
 
+// Logcat handler
+const logcatHandler = new LogcatHandler();
+
 // Filter state - maps file path to array of visible line indices
 const filterState = new Map<string, number[] | null>();
 
@@ -693,6 +697,7 @@ app.on('window-all-closed', () => {
 
 app.on('will-quit', () => {
   serialHandler.cleanupTempFile();
+  logcatHandler.cleanupTempFile();
   stopApiServer();
 });
 
@@ -815,6 +820,102 @@ ipcMain.handle(IPC.SERIAL_SAVE_SESSION, async () => {
   }
 });
 
+// === Logcat ===
+
+ipcMain.handle(IPC.LOGCAT_LIST_DEVICES, async () => {
+  try {
+    const devices = await logcatHandler.listDevices();
+    return { success: true, devices };
+  } catch (error) {
+    return { success: false, error: String(error) };
+  }
+});
+
+ipcMain.handle(IPC.LOGCAT_CONNECT, async (_, config: { device?: string; filter?: string }) => {
+  try {
+    const tempFilePath = await logcatHandler.connect(config);
+
+    // Open temp file with FileHandler
+    const fileHandler = new FileHandler();
+    const info = await fileHandler.open(tempFilePath, () => {});
+    addToCache(tempFilePath, fileHandler);
+    currentFilePath = tempFilePath;
+
+    // Forward events to renderer
+    const onLinesAdded = (count: number) => {
+      const handler = fileHandlerCache.get(tempFilePath);
+      if (handler) {
+        const newLines = handler.indexNewLines();
+        if (newLines > 0) {
+          mainWindow?.webContents.send(IPC.LOGCAT_LINES_ADDED, {
+            totalLines: handler.getTotalLines(),
+            newLines,
+          });
+        }
+      }
+    };
+
+    const onError = (message: string) => {
+      mainWindow?.webContents.send(IPC.LOGCAT_ERROR, message);
+    };
+
+    const onDisconnected = () => {
+      mainWindow?.webContents.send(IPC.LOGCAT_DISCONNECTED);
+      logcatHandler.removeListener('lines-added', onLinesAdded);
+      logcatHandler.removeListener('error', onError);
+      logcatHandler.removeListener('disconnected', onDisconnected);
+    };
+
+    logcatHandler.on('lines-added', onLinesAdded);
+    logcatHandler.on('error', onError);
+    logcatHandler.on('disconnected', onDisconnected);
+
+    return { success: true, info, tempFilePath };
+  } catch (error) {
+    return { success: false, error: String(error) };
+  }
+});
+
+ipcMain.handle(IPC.LOGCAT_DISCONNECT, async () => {
+  try {
+    logcatHandler.disconnect();
+    return { success: true };
+  } catch (error) {
+    return { success: false, error: String(error) };
+  }
+});
+
+ipcMain.handle(IPC.LOGCAT_STATUS, async () => {
+  return logcatHandler.getStatus();
+});
+
+ipcMain.handle(IPC.LOGCAT_SAVE_SESSION, async () => {
+  const tempPath = logcatHandler.getTempFilePath();
+  if (!tempPath || !fs.existsSync(tempPath)) {
+    return { success: false, error: 'No logcat session data' };
+  }
+
+  const result = await dialog.showSaveDialog(mainWindow!, {
+    title: 'Save Logcat Session',
+    defaultPath: path.basename(tempPath),
+    filters: [
+      { name: 'Log Files', extensions: ['log', 'txt'] },
+      { name: 'All Files', extensions: ['*'] },
+    ],
+  });
+
+  if (result.canceled || !result.filePath) {
+    return { success: false, error: 'Cancelled' };
+  }
+
+  try {
+    fs.copyFileSync(tempPath, result.filePath);
+    return { success: true, filePath: result.filePath };
+  } catch (error) {
+    return { success: false, error: String(error) };
+  }
+});
+
 // === File Operations ===
 
 ipcMain.handle(IPC.OPEN_FILE_DIALOG, async () => {

src/main/logcatHandler.ts

@@ -0,0 +1,235 @@
+import { EventEmitter } from 'events';
+import { ChildProcess, spawn, execFile } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { LogcatConfig, LogcatDeviceInfo, LogcatStatus } from '../shared/types';
+import { wallClockPrefix } from './serialHandler';
+
+export class LogcatHandler extends EventEmitter {
+  private process: ChildProcess | null = null;
+  private tempFilePath: string | null = null;
+  private fd: number | null = null;
+  private lineBuffer: string = '';
+  private linesReceived: number = 0;
+  private connectedSince: number | null = null;
+  private config: LogcatConfig | null = null;
+
+  async listDevices(): Promise<LogcatDeviceInfo[]> {
+    return new Promise((resolve, reject) => {
+      execFile('adb', ['devices', '-l'], { timeout: 5000 }, (err, stdout, stderr) => {
+        if (err) {
+          reject(new Error(`adb not found or failed: ${err.message}`));
+          return;
+        }
+        resolve(parseAdbDevices(stdout));
+      });
+    });
+  }
+
+  async connect(config: LogcatConfig): Promise<string> {
+    if (this.process) {
+      throw new Error('Already connected. Disconnect first.');
+    }
+
+    // Create temp directory
+    const tempDir = path.join(os.tmpdir(), 'logan-logcat');
+    if (!fs.existsSync(tempDir)) {
+      fs.mkdirSync(tempDir, { recursive: true });
+    }
+
+    // Create temp file
+    const safeDevice = (config.device || 'default').replace(/[^a-zA-Z0-9]/g, '_');
+    const timestamp = Date.now();
+    this.tempFilePath = path.join(tempDir, `logcat_${safeDevice}_${timestamp}.log`);
+    fs.writeFileSync(this.tempFilePath, '');
+    this.fd = fs.openSync(this.tempFilePath, 'a');
+
+    this.config = config;
+    this.lineBuffer = '';
+    this.linesReceived = 0;
+    this.connectedSince = Date.now();
+
+    // Build adb logcat command args
+    const args: string[] = [];
+    if (config.device) {
+      args.push('-s', config.device);
+    }
+    args.push('logcat');
+    if (config.filter) {
+      args.push(config.filter);
+    }
+
+    this.process = spawn('adb', args, { stdio: ['ignore', 'pipe', 'pipe'] });
+
+    this.process.stdout?.on('data', (chunk: Buffer) => {
+      this.handleData(chunk);
+    });
+
+    this.process.stderr?.on('data', (chunk: Buffer) => {
+      const msg = chunk.toString('utf-8').trim();
+      if (msg) {
+        this.emit('error', msg);
+      }
+    });
+
+    this.process.on('error', (err: Error) => {
+      this.emit('error', err.message);
+      this.cleanup();
+      this.emit('disconnected');
+    });
+
+    this.process.on('close', (code) => {
+      this.process = null;
+      this.config = null;
+      this.connectedSince = null;
+      if (this.fd !== null) {
+        // Flush partial line
+        if (this.lineBuffer.length > 0) {
+          fs.writeSync(this.fd, wallClockPrefix() + ' ' + this.lineBuffer + '\n');
+          this.linesReceived++;
+          this.lineBuffer = '';
+          this.emit('lines-added', 1);
+        }
+        fs.closeSync(this.fd);
+        this.fd = null;
+      }
+      this.emit('disconnected');
+    });
+
+    return this.tempFilePath;
+  }
+
+  private handleData(chunk: Buffer): void {
+    if (!this.fd) return;
+
+    const text = chunk.toString('utf-8');
+    this.lineBuffer += text;
+
+    // Split on any line ending: \r\n, \n, \r
+    const lines: string[] = [];
+    let i = 0;
+    let lineStart = 0;
+
+    while (i < this.lineBuffer.length) {
+      const ch = this.lineBuffer[i];
+      if (ch === '\n') {
+        lines.push(this.lineBuffer.substring(lineStart, i));
+        lineStart = i + 1;
+      } else if (ch === '\r') {
+        lines.push(this.lineBuffer.substring(lineStart, i));
+        if (i + 1 < this.lineBuffer.length && this.lineBuffer[i + 1] === '\n') {
+          i++;
+        }
+        lineStart = i + 1;
+      }
+      i++;
+    }
+
+    // Keep remainder in buffer (partial line)
+    this.lineBuffer = this.lineBuffer.substring(lineStart);
+
+    if (lines.length > 0) {
+      // Write complete lines to temp file with wall clock timestamp
+      const ts = wallClockPrefix();
+      const data = lines.map(l => ts + ' ' + l + '\n').join('');
+      fs.writeSync(this.fd, data);
+      this.linesReceived += lines.length;
+      this.emit('lines-added', lines.length);
+    }
+  }
+
+  disconnect(): void {
+    if (!this.process) return;
+
+    try {
+      this.process.kill('SIGTERM');
+    } catch {
+      // Process may already be dead
+    }
+    // The 'close' event handler will do the rest
+  }
+
+  getStatus(): LogcatStatus {
+    return {
+      connected: this.process !== null && !this.process.killed,
+      deviceId: this.config?.device || null,
+      filter: this.config?.filter || null,
+      linesReceived: this.linesReceived,
+      connectedSince: this.connectedSince,
+      tempFilePath: this.tempFilePath,
+    };
+  }
+
+  getTempFilePath(): string | null {
+    return this.tempFilePath;
+  }
+
+  cleanupTempFile(): void {
+    this.disconnect();
+    // Wait a tick for the close handler to flush
+    if (this.fd !== null) {
+      try { fs.closeSync(this.fd); } catch {}
+      this.fd = null;
+    }
+    if (this.tempFilePath && fs.existsSync(this.tempFilePath)) {
+      try {
+        fs.unlinkSync(this.tempFilePath);
+      } catch {
+        // Best effort
+      }
+    }
+    this.tempFilePath = null;
+  }
+
+  private cleanup(): void {
+    if (this.fd !== null) {
+      fs.closeSync(this.fd);
+      this.fd = null;
+    }
+    if (this.tempFilePath && fs.existsSync(this.tempFilePath)) {
+      try {
+        fs.unlinkSync(this.tempFilePath);
+      } catch {
+        // Best effort
+      }
+    }
+    this.tempFilePath = null;
+    this.config = null;
+    this.connectedSince = null;
+  }
+}
+
+/** Parse `adb devices -l` output into LogcatDeviceInfo[] */
+export function parseAdbDevices(output: string): LogcatDeviceInfo[] {
+  const devices: LogcatDeviceInfo[] = [];
+  const lines = output.split('\n');
+
+  for (const line of lines) {
+    // Skip header and empty lines
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('List of devices') || trimmed.startsWith('*')) {
+      continue;
+    }
+
+    // Format: <serial> <state> [usb:<...>] [product:<...>] [model:<...>] [device:<...>] [transport_id:<...>]
+    const parts = trimmed.split(/\s+/);
+    if (parts.length < 2) continue;
+
+    const id = parts[0];
+    const state = parts[1];
+
+    // Extract model from key:value pairs
+    let model: string | undefined;
+    for (const part of parts.slice(2)) {
+      if (part.startsWith('model:')) {
+        model = part.substring(6).replace(/_/g, ' ');
+        break;
+      }
+    }
+
+    devices.push({ id, state, model });
+  }
+
+  return devices;
+}