@tokentop/ttop 0.2.2 → 0.3.0

package/src/tui/driver/cli.ts

@@ -1,28 +1,28 @@
 #!/usr/bin/env bun
-import * as readline from 'readline';
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import { diffFrames, highlightDiff } from './diff.ts';
-import { assertSnapshot, listGoldenFiles, deleteGoldenFile, getGoldenFile } from './assertions.ts';
-import { createDriver, type Driver, type DriverOptions } from './driver.ts';
+import * as fs from "fs/promises";
+import * as path from "path";
+import * as readline from "readline";
+import { assertSnapshot, deleteGoldenFile, getGoldenFile, listGoldenFiles } from "./assertions.ts";
+import {
+  type CoverageTracker,
+  createCoverageTracker,
+  detectViewFromFrame,
+  formatCoverageReport,
+} from "./coverage.ts";
+import { diffFrames, highlightDiff } from "./diff.ts";
+import { createDriver, type Driver, type DriverOptions } from "./driver.ts";
 import {
   createRecorder,
-  replayRecording,
-  saveRecording,
-  loadRecording,
-  listRecordings,
   deleteRecording,
+  listRecordings,
+  loadRecording,
   type Recorder,
   type Recording,
-} from './recorder.ts';
-import {
-  createCoverageTracker,
-  detectViewFromFrame,
-  formatCoverageReport,
-  type CoverageTracker,
-} from './coverage.ts';
+  replayRecording,
+  saveRecording,
+} from "./recorder.ts";
 
-const DEFAULT_SNAPSHOTS_DIR = './snapshots';
+const DEFAULT_SNAPSHOTS_DIR = "./snapshots";
 
 interface Command {
   action: string;
@@ -49,28 +49,29 @@ async function ensureDir(dir: string): Promise<void> {
 async function saveFrameToFile(frame: string, filePath: string): Promise<string> {
   const dir = path.dirname(filePath);
   await ensureDir(dir);
-  await fs.writeFile(filePath, frame, 'utf-8');
+  await fs.writeFile(filePath, frame, "utf-8");
   return path.resolve(filePath);
 }
 
 async function handleCommand(cmd: Command): Promise<Response> {
   try {
     switch (cmd.action) {
-      case 'launch': {
+      case "launch": {
         if (driver?.isRunning()) {
-          return { ok: false, error: 'Driver already running' };
+          return { ok: false, error: "Driver already running" };
         }
-        currentWidth = typeof cmd.width === 'number' ? cmd.width : 100;
-        currentHeight = typeof cmd.height === 'number' ? cmd.height : 30;
+        currentWidth = typeof cmd.width === "number" ? cmd.width : 100;
+        currentHeight = typeof cmd.height === "number" ? cmd.height : 30;
         const options: DriverOptions = {
           width: currentWidth,
           height: currentHeight,
           appOptions: {
             debug: cmd.debug === true,
             demoMode: cmd.demo === true,
-            ...(typeof cmd.demoSeed === 'number' ? { demoSeed: cmd.demoSeed, demoMode: true } : {}),
-            ...(typeof cmd.demoPreset === 'string' && ['light', 'normal', 'heavy'].includes(cmd.demoPreset)
-              ? { demoPreset: cmd.demoPreset as 'light' | 'normal' | 'heavy', demoMode: true }
+            ...(typeof cmd.demoSeed === "number" ? { demoSeed: cmd.demoSeed, demoMode: true } : {}),
+            ...(typeof cmd.demoPreset === "string" &&
+            ["light", "normal", "heavy"].includes(cmd.demoPreset)
+              ? { demoPreset: cmd.demoPreset as "light" | "normal" | "heavy", demoMode: true }
               : {}),
           },
         };
@@ -79,203 +80,207 @@ async function handleCommand(cmd: Command): Promise<Response> {
         return { ok: true };
       }
 
-      case 'close': {
+      case "close": {
         if (!driver) {
-          return { ok: false, error: 'Driver not running' };
+          return { ok: false, error: "Driver not running" };
         }
         await driver.close();
         driver = null;
         return { ok: true };
       }
 
-      case 'sendKeys': {
+      case "sendKeys": {
         if (!driver?.isRunning()) {
-          return { ok: false, error: 'Driver not running' };
+          return { ok: false, error: "Driver not running" };
         }
-        const keys = typeof cmd.keys === 'string' ? cmd.keys : '';
+        const keys = typeof cmd.keys === "string" ? cmd.keys : "";
         await driver.sendKeys(keys);
-        recorder?.addCommand('sendKeys', { keys });
+        recorder?.addCommand("sendKeys", { keys });
         if (recorder?.isRecording()) {
           recorder.captureFrame(await driver.capture());
         }
         return { ok: true };
       }
 
-      case 'pressKey': {
+      case "pressKey": {
         if (!driver?.isRunning()) {
-          return { ok: false, error: 'Driver not running' };
+          return { ok: false, error: "Driver not running" };
         }
-        const key = typeof cmd.key === 'string' ? cmd.key : '';
-        const modifiers = typeof cmd.modifiers === 'object' && cmd.modifiers !== null
-          ? cmd.modifiers as Record<string, boolean>
-          : {};
+        const key = typeof cmd.key === "string" ? cmd.key : "";
+        const modifiers =
+          typeof cmd.modifiers === "object" && cmd.modifiers !== null
+            ? (cmd.modifiers as Record<string, boolean>)
+            : {};
         await driver.pressKey(key, modifiers);
-        recorder?.addCommand('pressKey', { key, ...(Object.keys(modifiers).length > 0 ? { modifiers } : {}) });
+        recorder?.addCommand("pressKey", {
+          key,
+          ...(Object.keys(modifiers).length > 0 ? { modifiers } : {}),
+        });
         if (recorder?.isRecording()) {
           recorder.captureFrame(await driver.capture());
         }
         return { ok: true };
       }
 
-      case 'typeText': {
+      case "typeText": {
         if (!driver?.isRunning()) {
-          return { ok: false, error: 'Driver not running' };
+          return { ok: false, error: "Driver not running" };
         }
-        const text = typeof cmd.text === 'string' ? cmd.text : '';
-        const delay = typeof cmd.delay === 'number' ? cmd.delay : 0;
+        const text = typeof cmd.text === "string" ? cmd.text : "";
+        const delay = typeof cmd.delay === "number" ? cmd.delay : 0;
         await driver.typeText(text, delay);
-        recorder?.addCommand('typeText', { text, ...(delay > 0 ? { delay } : {}) });
+        recorder?.addCommand("typeText", { text, ...(delay > 0 ? { delay } : {}) });
         if (recorder?.isRecording()) {
           recorder.captureFrame(await driver.capture());
         }
         return { ok: true };
       }
 
-      case 'pressTab': {
+      case "pressTab": {
         if (!driver?.isRunning()) {
-          return { ok: false, error: 'Driver not running' };
+          return { ok: false, error: "Driver not running" };
         }
         await driver.pressTab();
-        recorder?.addCommand('pressTab');
+        recorder?.addCommand("pressTab");
         if (recorder?.isRecording()) {
           recorder.captureFrame(await driver.capture());
         }
         return { ok: true };
       }
 
-      case 'pressEnter': {
+      case "pressEnter": {
         if (!driver?.isRunning()) {
-          return { ok: false, error: 'Driver not running' };
+          return { ok: false, error: "Driver not running" };
         }
         await driver.pressEnter();
-        recorder?.addCommand('pressEnter');
+        recorder?.addCommand("pressEnter");
         if (recorder?.isRecording()) {
           recorder.captureFrame(await driver.capture());
         }
         return { ok: true };
       }
 
-      case 'pressEscape': {
+      case "pressEscape": {
         if (!driver?.isRunning()) {
-          return { ok: false, error: 'Driver not running' };
+          return { ok: false, error: "Driver not running" };
         }
         await driver.pressEscape();
-        recorder?.addCommand('pressEscape');
+        recorder?.addCommand("pressEscape");
         if (recorder?.isRecording()) {
           recorder.captureFrame(await driver.capture());
         }
         return { ok: true };
       }
 
-      case 'pressArrow': {
+      case "pressArrow": {
         if (!driver?.isRunning()) {
-          return { ok: false, error: 'Driver not running' };
+          return { ok: false, error: "Driver not running" };
         }
-        const direction = cmd.direction as 'up' | 'down' | 'left' | 'right';
-        if (!['up', 'down', 'left', 'right'].includes(direction)) {
-          return { ok: false, error: 'Invalid direction. Use: up, down, left, right' };
+        const direction = cmd.direction as "up" | "down" | "left" | "right";
+        if (!["up", "down", "left", "right"].includes(direction)) {
+          return { ok: false, error: "Invalid direction. Use: up, down, left, right" };
         }
         await driver.pressArrow(direction);
-        recorder?.addCommand('pressArrow', { direction });
+        recorder?.addCommand("pressArrow", { direction });
         if (recorder?.isRecording()) {
           recorder.captureFrame(await driver.capture());
         }
         return { ok: true };
       }
 
-      case 'capture': {
+      case "capture": {
         if (!driver?.isRunning()) {
-          return { ok: false, error: 'Driver not running' };
+          return { ok: false, error: "Driver not running" };
         }
-        const result = cmd.meta === true 
-          ? await driver.captureWithMeta()
-          : { frame: await driver.capture() };
-        
-        if (typeof cmd.save === 'string') {
+        const result =
+          cmd.meta === true ? await driver.captureWithMeta() : { frame: await driver.capture() };
+
+        if (typeof cmd.save === "string") {
           const savedPath = await saveFrameToFile(result.frame, cmd.save);
           return { ok: true, ...result, savedTo: savedPath };
         }
-        
+
         return { ok: true, ...result };
       }
 
-      case 'snapshot': {
+      case "snapshot": {
         if (!driver?.isRunning()) {
-          return { ok: false, error: 'Driver not running' };
+          return { ok: false, error: "Driver not running" };
         }
         const result = await driver.captureWithMeta();
-        const dir = typeof cmd.dir === 'string' ? cmd.dir : DEFAULT_SNAPSHOTS_DIR;
-        const name = typeof cmd.name === 'string' 
-          ? cmd.name 
-          : `frame-${String(++frameCounter).padStart(4, '0')}`;
-        
+        const dir = typeof cmd.dir === "string" ? cmd.dir : DEFAULT_SNAPSHOTS_DIR;
+        const name =
+          typeof cmd.name === "string"
+            ? cmd.name
+            : `frame-${String(++frameCounter).padStart(4, "0")}`;
+
         const framePath = path.join(dir, `${name}.txt`);
         const metadataPath = path.join(dir, `${name}.json`);
-        
+
         const metadata = {
           timestamp: new Date(result.timestamp).toISOString(),
           width: result.width,
           height: result.height,
           name,
         };
-        
+
         await ensureDir(dir);
         await Promise.all([
-          fs.writeFile(framePath, result.frame, 'utf-8'),
-          fs.writeFile(metadataPath, JSON.stringify(metadata, null, 2), 'utf-8'),
+          fs.writeFile(framePath, result.frame, "utf-8"),
+          fs.writeFile(metadataPath, JSON.stringify(metadata, null, 2), "utf-8"),
         ]);
-        
-        return { 
-          ok: true, 
-          savedTo: path.resolve(framePath), 
+
+        return {
+          ok: true,
+          savedTo: path.resolve(framePath),
           metadataPath: path.resolve(metadataPath),
           name,
           metadata,
         };
       }
 
-      case 'waitForText': {
+      case "waitForText": {
         if (!driver?.isRunning()) {
-          return { ok: false, error: 'Driver not running' };
+          return { ok: false, error: "Driver not running" };
         }
-        const text = typeof cmd.text === 'string' ? cmd.text : '';
-        const timeout = typeof cmd.timeout === 'number' ? cmd.timeout : 5000;
+        const text = typeof cmd.text === "string" ? cmd.text : "";
+        const timeout = typeof cmd.timeout === "number" ? cmd.timeout : 5000;
         const found = await driver.waitForText(text, { timeout });
         return { ok: true, found };
       }
 
-      case 'waitForStable': {
+      case "waitForStable": {
         if (!driver?.isRunning()) {
-          return { ok: false, error: 'Driver not running' };
+          return { ok: false, error: "Driver not running" };
         }
-        const maxIterations = typeof cmd.maxIterations === 'number' ? cmd.maxIterations : 10;
-        const intervalMs = typeof cmd.intervalMs === 'number' ? cmd.intervalMs : 50;
+        const maxIterations = typeof cmd.maxIterations === "number" ? cmd.maxIterations : 10;
+        const intervalMs = typeof cmd.intervalMs === "number" ? cmd.intervalMs : 50;
         await driver.waitForStable({ maxIterations, intervalMs });
-        recorder?.addCommand('waitForStable', { maxIterations, intervalMs });
+        recorder?.addCommand("waitForStable", { maxIterations, intervalMs });
         return { ok: true };
       }
 
-      case 'sleep': {
-        const ms = typeof cmd.ms === 'number' ? cmd.ms : 1000;
-        await new Promise(resolve => setTimeout(resolve, ms));
-        recorder?.addCommand('sleep', { ms });
+      case "sleep": {
+        const ms = typeof cmd.ms === "number" ? cmd.ms : 1000;
+        await new Promise((resolve) => setTimeout(resolve, ms));
+        recorder?.addCommand("sleep", { ms });
         return { ok: true, sleptMs: ms };
       }
 
-      case 'resize': {
+      case "resize": {
         if (!driver?.isRunning()) {
-          return { ok: false, error: 'Driver not running' };
+          return { ok: false, error: "Driver not running" };
         }
-        const cols = typeof cmd.cols === 'number' ? cmd.cols : 100;
-        const rows = typeof cmd.rows === 'number' ? cmd.rows : 30;
+        const cols = typeof cmd.cols === "number" ? cmd.cols : 100;
+        const rows = typeof cmd.rows === "number" ? cmd.rows : 30;
         await driver.resize(cols, rows);
         currentWidth = cols;
         currentHeight = rows;
-        recorder?.addCommand('resize', { cols, rows });
+        recorder?.addCommand("resize", { cols, rows });
         return { ok: true };
       }
 
-      case 'status': {
+      case "status": {
         return {
           ok: true,
           running: driver?.isRunning() ?? false,
@@ -283,29 +288,30 @@ async function handleCommand(cmd: Command): Promise<Response> {
         };
       }
 
-      case 'diff': {
-        const file1 = typeof cmd.file1 === 'string' ? cmd.file1 : null;
-        const file2 = typeof cmd.file2 === 'string' ? cmd.file2 : null;
-        const frame1 = typeof cmd.frame1 === 'string' ? cmd.frame1 : null;
-        const frame2 = typeof cmd.frame2 === 'string' ? cmd.frame2 : null;
+      case "diff": {
+        const file1 = typeof cmd.file1 === "string" ? cmd.file1 : null;
+        const file2 = typeof cmd.file2 === "string" ? cmd.file2 : null;
+        const frame1 = typeof cmd.frame1 === "string" ? cmd.frame1 : null;
+        const frame2 = typeof cmd.frame2 === "string" ? cmd.frame2 : null;
         const ignoreWhitespace = cmd.ignoreWhitespace === true;
-        
+
         let expected: string;
         let actual: string;
-        
+
         if (file1 && file2) {
-          expected = await fs.readFile(file1, 'utf-8');
-          actual = await fs.readFile(file2, 'utf-8');
+          expected = await fs.readFile(file1, "utf-8");
+          actual = await fs.readFile(file2, "utf-8");
         } else if (frame1 && frame2) {
           expected = frame1;
           actual = frame2;
         } else {
-          return { ok: false, error: 'Provide file1/file2 or frame1/frame2' };
+          return { ok: false, error: "Provide file1/file2 or frame1/frame2" };
         }
-        
+
         const result = diffFrames(expected, actual, { ignoreWhitespace });
-        const visual = cmd.visual === true ? highlightDiff(expected, actual, { ignoreWhitespace }) : undefined;
-        
+        const visual =
+          cmd.visual === true ? highlightDiff(expected, actual, { ignoreWhitespace }) : undefined;
+
         return {
           ok: true,
           identical: result.identical,
@@ -319,21 +325,21 @@ async function handleCommand(cmd: Command): Promise<Response> {
         };
       }
 
-      case 'assert': {
+      case "assert": {
         if (!driver?.isRunning()) {
-          return { ok: false, error: 'Driver not running' };
+          return { ok: false, error: "Driver not running" };
         }
-        const name = typeof cmd.name === 'string' ? cmd.name : null;
+        const name = typeof cmd.name === "string" ? cmd.name : null;
         if (!name) {
-          return { ok: false, error: 'Name is required for assertion' };
+          return { ok: false, error: "Name is required for assertion" };
         }
-        
+
         const frame = await driver.capture();
         const { width, height } = driver.getSize();
-        const goldenDir = typeof cmd.goldenDir === 'string' ? cmd.goldenDir : './golden';
+        const goldenDir = typeof cmd.goldenDir === "string" ? cmd.goldenDir : "./golden";
         const updateGolden = cmd.update === true;
         const ignoreWhitespace = cmd.ignoreWhitespace === true;
-        
+
         const result = await assertSnapshot(name, frame, {
           goldenDir,
           updateGolden,
@@ -341,7 +347,7 @@ async function handleCommand(cmd: Command): Promise<Response> {
           width,
           height,
         });
-        
+
         return {
           ok: true,
           passed: result.passed,
@@ -351,27 +357,29 @@ async function handleCommand(cmd: Command): Promise<Response> {
           width,
           height,
           ...(result.dimensionMismatch ? { dimensionMismatch: result.dimensionMismatch } : {}),
-          ...(result.diff ? {
-            changedLines: result.diff.changedLines,
-            totalLines: result.diff.totalLines,
-            changePercentage: result.diff.changePercentage,
-          } : {}),
+          ...(result.diff
+            ? {
+                changedLines: result.diff.changedLines,
+                totalLines: result.diff.totalLines,
+                changePercentage: result.diff.changePercentage,
+              }
+            : {}),
           ...(result.visual && cmd.visual === true ? { visual: result.visual } : {}),
         };
       }
 
-      case 'listGolden': {
-        const goldenDir = typeof cmd.goldenDir === 'string' ? cmd.goldenDir : './golden';
+      case "listGolden": {
+        const goldenDir = typeof cmd.goldenDir === "string" ? cmd.goldenDir : "./golden";
         const files = await listGoldenFiles(goldenDir);
         return { ok: true, files, count: files.length };
       }
 
-      case 'getGolden': {
-        const name = typeof cmd.name === 'string' ? cmd.name : null;
+      case "getGolden": {
+        const name = typeof cmd.name === "string" ? cmd.name : null;
         if (!name) {
-          return { ok: false, error: 'Name is required' };
+          return { ok: false, error: "Name is required" };
         }
-        const goldenDir = typeof cmd.goldenDir === 'string' ? cmd.goldenDir : './golden';
+        const goldenDir = typeof cmd.goldenDir === "string" ? cmd.goldenDir : "./golden";
         const info = await getGoldenFile(name, goldenDir);
         if (info === null) {
           return { ok: false, error: `Golden file not found: ${name}` };
@@ -388,36 +396,36 @@ async function handleCommand(cmd: Command): Promise<Response> {
         };
       }
 
-      case 'deleteGolden': {
-        const name = typeof cmd.name === 'string' ? cmd.name : null;
+      case "deleteGolden": {
+        const name = typeof cmd.name === "string" ? cmd.name : null;
         if (!name) {
-          return { ok: false, error: 'Name is required' };
+          return { ok: false, error: "Name is required" };
         }
-        const goldenDir = typeof cmd.goldenDir === 'string' ? cmd.goldenDir : './golden';
+        const goldenDir = typeof cmd.goldenDir === "string" ? cmd.goldenDir : "./golden";
         const deleted = await deleteGoldenFile(name, goldenDir);
         return { ok: true, deleted, name };
       }
 
-      case 'startRecording': {
+      case "startRecording": {
         if (!driver?.isRunning()) {
-          return { ok: false, error: 'Driver not running' };
+          return { ok: false, error: "Driver not running" };
         }
         if (recorder?.isRecording()) {
-          return { ok: false, error: 'Already recording' };
+          return { ok: false, error: "Already recording" };
         }
-        const name = typeof cmd.name === 'string' ? cmd.name : `recording-${Date.now()}`;
+        const name = typeof cmd.name === "string" ? cmd.name : `recording-${Date.now()}`;
         const captureFrames = cmd.captureFrames === true;
         recorder = createRecorder(currentWidth, currentHeight, { name, captureFrames });
         recorder.start();
         return { ok: true, name, captureFrames };
       }
 
-      case 'stopRecording': {
+      case "stopRecording": {
         if (!recorder?.isRecording()) {
-          return { ok: false, error: 'Not recording' };
+          return { ok: false, error: "Not recording" };
         }
         const recording = recorder.stop();
-        const recordingsDir = typeof cmd.dir === 'string' ? cmd.dir : './recordings';
+        const recordingsDir = typeof cmd.dir === "string" ? cmd.dir : "./recordings";
         const savedPath = await saveRecording(recording, recordingsDir);
         recorder = null;
         return {
@@ -428,15 +436,15 @@ async function handleCommand(cmd: Command): Promise<Response> {
         };
       }
 
-      case 'cancelRecording': {
+      case "cancelRecording": {
         if (!recorder?.isRecording()) {
-          return { ok: false, error: 'Not recording' };
+          return { ok: false, error: "Not recording" };
         }
         recorder = null;
         return { ok: true };
       }
 
-      case 'recordingStatus': {
+      case "recordingStatus": {
         return {
           ok: true,
           recording: recorder?.isRecording() ?? false,
@@ -444,26 +452,26 @@ async function handleCommand(cmd: Command): Promise<Response> {
         };
       }
 
-      case 'replay': {
+      case "replay": {
         if (!driver?.isRunning()) {
-          return { ok: false, error: 'Driver not running' };
+          return { ok: false, error: "Driver not running" };
         }
-        const name = typeof cmd.name === 'string' ? cmd.name : null;
+        const name = typeof cmd.name === "string" ? cmd.name : null;
         let recording: Recording | null = null;
 
         if (name) {
-          const recordingsDir = typeof cmd.dir === 'string' ? cmd.dir : './recordings';
+          const recordingsDir = typeof cmd.dir === "string" ? cmd.dir : "./recordings";
           recording = await loadRecording(name, recordingsDir);
           if (!recording) {
             return { ok: false, error: `Recording not found: ${name}` };
           }
-        } else if (typeof cmd.recording === 'object' && cmd.recording !== null) {
+        } else if (typeof cmd.recording === "object" && cmd.recording !== null) {
           recording = cmd.recording as Recording;
         } else {
-          return { ok: false, error: 'Provide name or recording object' };
+          return { ok: false, error: "Provide name or recording object" };
         }
 
-        const speed = typeof cmd.speed === 'number' ? cmd.speed : Infinity;
+        const speed = typeof cmd.speed === "number" ? cmd.speed : Infinity;
         const result = await replayRecording(driver, recording, { speed });
 
         return {
@@ -475,18 +483,18 @@ async function handleCommand(cmd: Command): Promise<Response> {
         };
       }
 
-      case 'listRecordings': {
-        const recordingsDir = typeof cmd.dir === 'string' ? cmd.dir : './recordings';
+      case "listRecordings": {
+        const recordingsDir = typeof cmd.dir === "string" ? cmd.dir : "./recordings";
         const recordings = await listRecordings(recordingsDir);
         return { ok: true, recordings, count: recordings.length };
       }
 
-      case 'getRecording': {
-        const name = typeof cmd.name === 'string' ? cmd.name : null;
+      case "getRecording": {
+        const name = typeof cmd.name === "string" ? cmd.name : null;
         if (!name) {
-          return { ok: false, error: 'Name is required' };
+          return { ok: false, error: "Name is required" };
         }
-        const recordingsDir = typeof cmd.dir === 'string' ? cmd.dir : './recordings';
+        const recordingsDir = typeof cmd.dir === "string" ? cmd.dir : "./recordings";
         const recording = await loadRecording(name, recordingsDir);
         if (!recording) {
           return { ok: false, error: `Recording not found: ${name}` };
@@ -494,26 +502,26 @@ async function handleCommand(cmd: Command): Promise<Response> {
         return { ok: true, recording };
       }
 
-      case 'deleteRecording': {
-        const name = typeof cmd.name === 'string' ? cmd.name : null;
+      case "deleteRecording": {
+        const name = typeof cmd.name === "string" ? cmd.name : null;
         if (!name) {
-          return { ok: false, error: 'Name is required' };
+          return { ok: false, error: "Name is required" };
         }
-        const recordingsDir = typeof cmd.dir === 'string' ? cmd.dir : './recordings';
+        const recordingsDir = typeof cmd.dir === "string" ? cmd.dir : "./recordings";
         const deleted = await deleteRecording(name, recordingsDir);
         return { ok: true, deleted, name };
       }
 
-      case 'startCoverage': {
+      case "startCoverage": {
         if (!driver?.isRunning()) {
-          return { ok: false, error: 'Driver not running' };
+          return { ok: false, error: "Driver not running" };
         }
         if (coverageTracker?.isTracking()) {
-          return { ok: false, error: 'Already tracking coverage' };
+          return { ok: false, error: "Already tracking coverage" };
         }
         const knownViews =
           Array.isArray(cmd.knownViews) &&
-          cmd.knownViews.every((v): v is string => typeof v === 'string')
+          cmd.knownViews.every((v): v is string => typeof v === "string")
             ? cmd.knownViews
             : undefined;
         coverageTracker = createCoverageTracker(knownViews);
@@ -521,9 +529,9 @@ async function handleCommand(cmd: Command): Promise<Response> {
         return { ok: true };
       }
 
-      case 'stopCoverage': {
+      case "stopCoverage": {
         if (!coverageTracker?.isTracking()) {
-          return { ok: false, error: 'Not tracking coverage' };
+          return { ok: false, error: "Not tracking coverage" };
         }
         const report = coverageTracker.stop();
         const visual = cmd.visual === true ? formatCoverageReport(report) : undefined;
@@ -535,12 +543,12 @@ async function handleCommand(cmd: Command): Promise<Response> {
         };
       }
 
-      case 'recordViewFromFrame': {
+      case "recordViewFromFrame": {
         if (!driver?.isRunning()) {
-          return { ok: false, error: 'Driver not running' };
+          return { ok: false, error: "Driver not running" };
         }
         if (!coverageTracker?.isTracking()) {
-          return { ok: false, error: 'Not tracking coverage' };
+          return { ok: false, error: "Not tracking coverage" };
         }
         const frame = await driver.capture();
         const view = detectViewFromFrame(frame);
@@ -550,9 +558,9 @@ async function handleCommand(cmd: Command): Promise<Response> {
         return { ok: true, detectedView: view };
       }
 
-      case 'getCoverage': {
+      case "getCoverage": {
         if (!coverageTracker) {
-          return { ok: false, error: 'No coverage tracker' };
+          return { ok: false, error: "No coverage tracker" };
         }
         const report = coverageTracker.getReport();
         const visual = cmd.visual === true ? formatCoverageReport(report) : undefined;
@@ -563,43 +571,43 @@ async function handleCommand(cmd: Command): Promise<Response> {
         };
       }
 
-      case 'help': {
+      case "help": {
         return {
           ok: true,
           commands: [
-            'launch - Start the app (options: width, height, debug; demo mode: demo, demoSeed, demoPreset)',
-            'close - Stop the app',
-            'sendKeys - Send key sequence (options: keys)',
-            'pressKey - Press single key (options: key, modifiers)',
-            'pressTab - Press Tab key',
-            'pressEnter - Press Enter key',
-            'pressEscape - Press Escape key',
-            'pressArrow - Press arrow key (options: direction)',
-            'typeText - Type text (options: text, delay)',
-            'capture - Get current frame (options: meta, save)',
-            'snapshot - Save frame to file (options: dir, name)',
-            'waitForText - Wait for text (options: text, timeout)',
-            'waitForStable - Wait for stable frame (options: maxIterations, intervalMs)',
-            'sleep - Pause for duration (options: ms)',
-            'resize - Resize terminal (options: cols, rows)',
-            'status - Get driver status',
-            'diff - Compare two frames (options: file1, file2 OR frame1, frame2, ignoreWhitespace, visual)',
-            'assert - Assert snapshot matches golden file (options: name, goldenDir, update, ignoreWhitespace, visual)',
-            'listGolden - List all golden files (options: goldenDir)',
-            'getGolden - Get content of golden file (options: name, goldenDir)',
-            'deleteGolden - Delete a golden file (options: name, goldenDir)',
-            'startRecording - Start recording commands (options: name, captureFrames)',
-            'stopRecording - Stop recording and save (options: dir)',
-            'cancelRecording - Cancel recording without saving',
-            'recordingStatus - Get current recording status',
-            'replay - Replay a recording (options: name, dir, speed)',
-            'listRecordings - List all recordings (options: dir)',
-            'getRecording - Get a recording (options: name, dir)',
-            'deleteRecording - Delete a recording (options: name, dir)',
-            'startCoverage - Start tracking view coverage (options: knownViews)',
-            'stopCoverage - Stop tracking and get report (options: visual)',
-            'recordViewFromFrame - Detect and record current view',
-            'getCoverage - Get current coverage report (options: visual)',
+            "launch - Start the app (options: width, height, debug; demo mode: demo, demoSeed, demoPreset)",
+            "close - Stop the app",
+            "sendKeys - Send key sequence (options: keys)",
+            "pressKey - Press single key (options: key, modifiers)",
+            "pressTab - Press Tab key",
+            "pressEnter - Press Enter key",
+            "pressEscape - Press Escape key",
+            "pressArrow - Press arrow key (options: direction)",
+            "typeText - Type text (options: text, delay)",
+            "capture - Get current frame (options: meta, save)",
+            "snapshot - Save frame to file (options: dir, name)",
+            "waitForText - Wait for text (options: text, timeout)",
+            "waitForStable - Wait for stable frame (options: maxIterations, intervalMs)",
+            "sleep - Pause for duration (options: ms)",
+            "resize - Resize terminal (options: cols, rows)",
+            "status - Get driver status",
+            "diff - Compare two frames (options: file1, file2 OR frame1, frame2, ignoreWhitespace, visual)",
+            "assert - Assert snapshot matches golden file (options: name, goldenDir, update, ignoreWhitespace, visual)",
+            "listGolden - List all golden files (options: goldenDir)",
+            "getGolden - Get content of golden file (options: name, goldenDir)",
+            "deleteGolden - Delete a golden file (options: name, goldenDir)",
+            "startRecording - Start recording commands (options: name, captureFrames)",
+            "stopRecording - Stop recording and save (options: dir)",
+            "cancelRecording - Cancel recording without saving",
+            "recordingStatus - Get current recording status",
+            "replay - Replay a recording (options: name, dir, speed)",
+            "listRecordings - List all recordings (options: dir)",
+            "getRecording - Get a recording (options: name, dir)",
+            "deleteRecording - Delete a recording (options: name, dir)",
+            "startCoverage - Start tracking view coverage (options: knownViews)",
+            "stopCoverage - Stop tracking and get report (options: visual)",
+            "recordViewFromFrame - Detect and record current view",
+            "getCoverage - Get current coverage report (options: visual)",
           ],
         };
       }
@@ -617,8 +625,8 @@ async function handleCommand(cmd: Command): Promise<Response> {
 
 async function main() {
   const args = process.argv.slice(2);
-  
-  if (args.includes('--help') || args.includes('-h')) {
+
+  if (args.includes("--help") || args.includes("-h")) {
     console.log(`
 Tokentop Driver CLI
 
@@ -667,7 +675,7 @@ Example:
   async function processQueue(): Promise<void> {
     if (processing) return;
     processing = true;
-    
+
     while (commandQueue.length > 0) {
       const line = commandQueue.shift()!;
       try {
@@ -675,15 +683,17 @@ Example:
         const response = await handleCommand(cmd);
         console.log(JSON.stringify(response));
       } catch (err) {
-        console.log(JSON.stringify({
-          ok: false,
-          error: `Invalid JSON: ${err instanceof Error ? err.message : String(err)}`,
-        }));
+        console.log(
+          JSON.stringify({
+            ok: false,
+            error: `Invalid JSON: ${err instanceof Error ? err.message : String(err)}`,
+          }),
+        );
       }
     }
-    
+
     processing = false;
-    
+
     if (closed && commandQueue.length === 0) {
       if (driver?.isRunning()) {
         await driver.close();
@@ -692,14 +702,14 @@ Example:
     }
   }
 
-  rl.on('line', (line) => {
+  rl.on("line", (line) => {
     const trimmed = line.trim();
     if (!trimmed) return;
     commandQueue.push(trimmed);
     processQueue();
   });
 
-  rl.on('close', () => {
+  rl.on("close", () => {
     closed = true;
     if (!processing && commandQueue.length === 0) {
       if (driver?.isRunning()) {
@@ -712,6 +722,6 @@ Example:
 }
 
 main().catch((err) => {
-  console.error('Driver CLI failed:', err);
+  console.error("Driver CLI failed:", err);
   process.exit(1);
 });