@hasna/skills 0.1.12 → 0.1.14

package/skills/skill-consolelog/bin/cli.ts

@@ -0,0 +1,884 @@
+#!/usr/bin/env bun
+import { Command } from "commander";
+import { createTables } from "../src/db/schema";
+import { ensureInstalled } from "../src/lib/installer";
+
+// Ensure service directory exists on startup
+ensureInstalled();
+import {
+  createApp,
+  getAllApps,
+  getAppById,
+  getAppByName,
+  updateApp,
+  deleteApp,
+  createPage,
+  getPagesByAppId,
+  getPageByAppAndPath,
+  deletePage,
+  createScan,
+  getScans,
+  getScanById,
+  updateScan,
+  getConsoleLogs,
+  countConsoleLogs,
+  createConsoleLogsBatch,
+  getLogsByLevel,
+  getLastScanForApp,
+  createScreenshot,
+  getScreenshotsByScanId,
+} from "../src/db/queries";
+import { getDb, closeConnection } from "../src/db/index";
+import { ConsoleMonitor, getMonitor, shutdownMonitor } from "../src/lib/monitor";
+import {
+  loadConfig,
+  saveConfig,
+  getConfigPath,
+  isHeadless,
+  getDefaultTimeout,
+} from "../src/lib/config";
+import {
+  startWatching,
+  stopWatching,
+  getWatchStatus,
+  stopAllWatchers,
+} from "../src/lib/watcher";
+import {
+  install,
+  uninstall,
+  isInstalled,
+  logScanStart,
+  logScanComplete,
+  logWatchStart,
+  logWatchStop,
+  logError,
+  ensureSnapshotsDir,
+  generateScreenshotFilename,
+  getScreenshotPath,
+  getSnapshotsDir,
+} from "../src/lib/installer";
+import type { ConsoleLogLevel, CreateConsoleLogInput } from "../src/lib/types";
+
+// Helper for Commander option parsing (parseInt needs explicit radix)
+const parseIntOption = (val: string) => parseInt(val, 10);
+
+const program = new Command();
+
+program
+  .name("service-consolelog")
+  .description("Monitor console logs from web applications using Playwright")
+  .version("1.0.0");
+
+// ============ INIT/INSTALL COMMANDS ============
+
+program
+  .command("init")
+  .description("Initialize service-consolelog in the current project")
+  .option("-f, --force", "Force reinstall even if already installed")
+  .action((options) => {
+    const result = install({ force: options.force });
+    if (result.success) {
+      console.log(`✓ ${result.message}`);
+      console.log(`  Created: .service-consolelog/README.md`);
+      console.log(`  Created: .service-consolelog/service-consolelog.log`);
+      console.log(`  Created: .service-consolelog/snapshots/`);
+    } else {
+      console.log(`⚠ ${result.message}`);
+    }
+  });
+
+program
+  .command("uninit")
+  .description("Remove service-consolelog from the current project")
+  .action(() => {
+    const result = uninstall();
+    if (result.success) {
+      console.log(`✓ ${result.message}`);
+    } else {
+      console.log(`⚠ ${result.message}`);
+    }
+  });
+
+program
+  .command("status")
+  .description("Check installation status")
+  .action(() => {
+    if (isInstalled()) {
+      console.log("✓ Installed in current project");
+    } else {
+      console.log("✗ Not installed. Run 'service-consolelog init' to set up.");
+    }
+  });
+
+// ============ APP COMMANDS ============
+
+const appCmd = program.command("app").description("Manage monitored applications");
+
+appCmd
+  .command("add")
+  .description("Add a new app to monitor")
+  .requiredOption("-n, --name <name>", "App name")
+  .requiredOption("-p, --port <port>", "App port", parseIntOption)
+  .requiredOption("-u, --url <url>", "Base URL")
+  .option("-d, --description <desc>", "Description")
+  .action(async (options) => {
+    try {
+      await ensureDb();
+      const app = await createApp({
+        name: options.name,
+        port: options.port,
+        base_url: options.url,
+        description: options.description,
+      });
+      console.log(`✓ Created app "${app.name}" (ID: ${app.id})`);
+    } catch (error) {
+      const err = error as Error;
+      if (err.message.includes("unique") || err.message.includes("duplicate")) {
+        console.error(`✗ App "${options.name}" already exists`);
+      } else {
+        console.error(`✗ Error: ${err.message}`);
+      }
+      process.exit(1);
+    }
+  });
+
+appCmd
+  .command("list")
+  .description("List all apps")
+  .option("-a, --active-only", "Show only active apps")
+  .action(async (options) => {
+    await ensureDb();
+    const apps = await getAllApps(options.activeOnly);
+
+    if (apps.length === 0) {
+      console.log("No apps found. Add one with: service-consolelog app add");
+      return;
+    }
+
+    console.log("\nApps:\n");
+    for (const app of apps) {
+      const status = app.active ? "●" : "○";
+      console.log(`  ${status} ${app.name} (ID: ${app.id})`);
+      console.log(`    URL: ${app.base_url}`);
+      console.log(`    Port: ${app.port}`);
+      if (app.description) {
+        console.log(`    Description: ${app.description}`);
+      }
+      console.log();
+    }
+  });
+
+appCmd
+  .command("get <idOrName>")
+  .description("Get app details")
+  .action(async (idOrName) => {
+    await ensureDb();
+    const app = await resolveApp(idOrName);
+
+    if (!app) {
+      console.error(`✗ App "${idOrName}" not found`);
+      process.exit(1);
+    }
+
+    console.log(`\nApp: ${app.name}\n`);
+    console.log(`  ID: ${app.id}`);
+    console.log(`  URL: ${app.base_url}`);
+    console.log(`  Port: ${app.port}`);
+    console.log(`  Active: ${app.active ? "Yes" : "No"}`);
+    if (app.description) {
+      console.log(`  Description: ${app.description}`);
+    }
+    console.log(`  Created: ${app.created_at}`);
+    console.log(`  Updated: ${app.updated_at}`);
+
+    const pages = await getPagesByAppId(app.id);
+    console.log(`  Pages: ${pages.length}`);
+  });
+
+appCmd
+  .command("update <idOrName>")
+  .description("Update an app")
+  .option("-n, --name <name>", "New name")
+  .option("-p, --port <port>", "New port", parseIntOption)
+  .option("-u, --url <url>", "New base URL")
+  .option("-d, --description <desc>", "New description")
+  .option("--active <bool>", "Set active status", (v) => v === "true")
+  .action(async (idOrName, options) => {
+    await ensureDb();
+    const app = await resolveApp(idOrName);
+
+    if (!app) {
+      console.error(`✗ App "${idOrName}" not found`);
+      process.exit(1);
+    }
+
+    const updated = await updateApp(app.id, {
+      name: options.name,
+      port: options.port,
+      base_url: options.url,
+      description: options.description,
+      active: options.active,
+    });
+
+    console.log(`✓ Updated app "${updated?.name}"`);
+  });
+
+appCmd
+  .command("remove <idOrName>")
+  .description("Remove an app")
+  .action(async (idOrName) => {
+    await ensureDb();
+    const app = await resolveApp(idOrName);
+
+    if (!app) {
+      console.error(`✗ App "${idOrName}" not found`);
+      process.exit(1);
+    }
+
+    await deleteApp(app.id);
+    console.log(`✓ Removed app "${app.name}"`);
+  });
+
+// ============ PAGE COMMANDS ============
+
+const pageCmd = program.command("page").description("Manage monitored pages");
+
+pageCmd
+  .command("add")
+  .description("Add a page to monitor")
+  .requiredOption("-a, --app <app>", "App name or ID")
+  .requiredOption("-p, --path <path>", "Page path (e.g., '/', '/dashboard')")
+  .option("-n, --name <name>", "Page name")
+  .option("-w, --wait-for <selector>", "CSS selector to wait for")
+  .option("-t, --timeout <ms>", "Timeout in milliseconds", parseIntOption)
+  .action(async (options) => {
+    await ensureDb();
+    const app = await resolveApp(options.app);
+
+    if (!app) {
+      console.error(`✗ App "${options.app}" not found`);
+      process.exit(1);
+    }
+
+    try {
+      const page = await createPage({
+        app_id: app.id,
+        path: options.path,
+        name: options.name,
+        wait_for: options.waitFor,
+        timeout: options.timeout,
+      });
+      console.log(`✓ Added page "${page.path}" to "${app.name}" (ID: ${page.id})`);
+    } catch (error) {
+      const err = error as Error;
+      if (err.message.includes("unique") || err.message.includes("duplicate")) {
+        console.error(`✗ Page "${options.path}" already exists for "${app.name}"`);
+      } else {
+        console.error(`✗ Error: ${err.message}`);
+      }
+      process.exit(1);
+    }
+  });
+
+pageCmd
+  .command("list")
+  .description("List pages for an app")
+  .requiredOption("-a, --app <app>", "App name or ID")
+  .option("--active-only", "Show only active pages")
+  .action(async (options) => {
+    await ensureDb();
+    const app = await resolveApp(options.app);
+
+    if (!app) {
+      console.error(`✗ App "${options.app}" not found`);
+      process.exit(1);
+    }
+
+    const pages = await getPagesByAppId(app.id, options.activeOnly);
+
+    if (pages.length === 0) {
+      console.log(`No pages for "${app.name}". Add one with: service-consolelog page add`);
+      return;
+    }
+
+    console.log(`\nPages for "${app.name}":\n`);
+    for (const page of pages) {
+      const status = page.active ? "●" : "○";
+      console.log(`  ${status} ${page.path} (ID: ${page.id})`);
+      if (page.name) {
+        console.log(`    Name: ${page.name}`);
+      }
+      if (page.wait_for) {
+        console.log(`    Wait for: ${page.wait_for}`);
+      }
+      console.log(`    Timeout: ${page.timeout}ms`);
+      console.log();
+    }
+  });
+
+pageCmd
+  .command("remove <id>")
+  .description("Remove a page")
+  .action(async (id) => {
+    await ensureDb();
+    const success = await deletePage(parseInt(id, 10));
+
+    if (success) {
+      console.log(`✓ Removed page ID ${id}`);
+    } else {
+      console.error(`✗ Page ID ${id} not found`);
+      process.exit(1);
+    }
+  });
+
+// ============ SCAN COMMANDS ============
+
+program
+  .command("scan")
+  .description("Scan pages for console logs")
+  .option("-a, --app <app>", "App name or ID")
+  .option("--all", "Scan all active apps")
+  .option("-p, --pages <paths...>", "Specific paths to scan")
+  .option("--headless <bool>", "Run headless", (v) => v !== "false")
+  .action(async (options) => {
+    await ensureDb();
+
+    if (!options.app && !options.all) {
+      console.error("✗ Specify --app or --all");
+      process.exit(1);
+    }
+
+    const headless = options.headless ?? isHeadless();
+    const monitor = getMonitor(headless);
+    await monitor.start();
+
+    try {
+      if (options.all) {
+        const apps = await getAllApps(true);
+        for (const app of apps) {
+          await scanApp(app.id, monitor, options.pages);
+        }
+      } else {
+        const app = await resolveApp(options.app);
+        if (!app) {
+          console.error(`✗ App "${options.app}" not found`);
+          process.exit(1);
+        }
+        await scanApp(app.id, monitor, options.pages);
+      }
+    } finally {
+      await shutdownMonitor();
+    }
+  });
+
+// ============ LOG COMMANDS ============
+
+program
+  .command("logs")
+  .description("Query console logs")
+  .requiredOption("-a, --app <app>", "App name or ID")
+  .option("-l, --level <level>", "Filter by level (error, warn, info, log, debug)")
+  .option("-s, --scan <id>", "Filter by scan ID", parseIntOption)
+  .option("--since <date>", "Filter logs since date (ISO format)")
+  .option("--until <date>", "Filter logs until date (ISO format)")
+  .option("--limit <n>", "Limit results", parseIntOption, 50)
+  .option("--offset <n>", "Offset results", parseIntOption, 0)
+  .action(async (options) => {
+    await ensureDb();
+    const app = await resolveApp(options.app);
+
+    if (!app) {
+      console.error(`✗ App "${options.app}" not found`);
+      process.exit(1);
+    }
+
+    const logs = await getConsoleLogs({
+      app_id: app.id,
+      level: options.level as ConsoleLogLevel,
+      scan_id: isNaN(options.scan) ? undefined : options.scan,
+      since: options.since,
+      until: options.until,
+      limit: isNaN(options.limit) ? 50 : options.limit,
+      offset: isNaN(options.offset) ? 0 : options.offset,
+    });
+
+    if (logs.length === 0) {
+      console.log("No logs found matching criteria.");
+      return;
+    }
+
+    console.log(`\nLogs for "${app.name}" (${logs.length} results):\n`);
+
+    for (const log of logs) {
+      const levelIcon = getLevelIcon(log.level);
+      console.log(`${levelIcon} [${log.timestamp}] ${log.level.toUpperCase()}`);
+      console.log(`   ${log.message}`);
+      if (log.source_url) {
+        console.log(`   at ${log.source_url}:${log.line_number || "?"}:${log.column_number || "?"}`);
+      }
+      if (log.stack_trace) {
+        console.log(`   Stack: ${log.stack_trace.split("\n")[0]}...`);
+      }
+      console.log();
+    }
+  });
+
+program
+  .command("history")
+  .description("View scan history")
+  .requiredOption("-a, --app <app>", "App name or ID")
+  .option("--limit <n>", "Limit results", parseIntOption, 10)
+  .action(async (options) => {
+    await ensureDb();
+    const app = await resolveApp(options.app);
+
+    if (!app) {
+      console.error(`✗ App "${options.app}" not found`);
+      process.exit(1);
+    }
+
+    const scans = await getScans({ app_id: app.id, limit: options.limit });
+
+    if (scans.length === 0) {
+      console.log(`No scan history for "${app.name}".`);
+      return;
+    }
+
+    console.log(`\nScan history for "${app.name}":\n`);
+
+    for (const scan of scans) {
+      const statusIcon =
+        scan.status === "completed" ? "✓" : scan.status === "failed" ? "✗" : "◌";
+      console.log(
+        `  ${statusIcon} Scan #${scan.id} - ${scan.status.toUpperCase()}`
+      );
+      console.log(`    Started: ${scan.started_at}`);
+      if (scan.completed_at) {
+        console.log(`    Completed: ${scan.completed_at}`);
+      }
+      console.log(
+        `    Pages: ${scan.pages_scanned} | Errors: ${scan.errors_found}`
+      );
+      console.log();
+    }
+  });
+
+// ============ EXPORT COMMAND ============
+
+program
+  .command("export")
+  .description("Export logs to file")
+  .requiredOption("-a, --app <app>", "App name or ID")
+  .requiredOption("-o, --output <path>", "Output file path")
+  .option("-f, --format <format>", "Format: json or csv", "json")
+  .option("-l, --level <level>", "Filter by level")
+  .option("--since <date>", "Filter logs since date")
+  .option("--until <date>", "Filter logs until date")
+  .action(async (options) => {
+    await ensureDb();
+    const app = await resolveApp(options.app);
+
+    if (!app) {
+      console.error(`✗ App "${options.app}" not found`);
+      process.exit(1);
+    }
+
+    const logs = await getConsoleLogs({
+      app_id: app.id,
+      level: options.level as ConsoleLogLevel,
+      since: options.since,
+      until: options.until,
+    });
+
+    let content: string;
+    if (options.format === "csv") {
+      const headers = [
+        "id",
+        "scan_id",
+        "page_id",
+        "level",
+        "message",
+        "source_url",
+        "line_number",
+        "column_number",
+        "timestamp",
+      ];
+      const rows = logs.map((l) =>
+        [
+          l.id,
+          l.scan_id,
+          l.page_id,
+          l.level,
+          `"${l.message.replace(/"/g, '""')}"`,
+          l.source_url || "",
+          l.line_number || "",
+          l.column_number || "",
+          l.timestamp,
+        ].join(",")
+      );
+      content = [headers.join(","), ...rows].join("\n");
+    } else {
+      content = JSON.stringify(logs, null, 2);
+    }
+
+    Bun.write(options.output, content);
+    console.log(`✓ Exported ${logs.length} logs to ${options.output}`);
+  });
+
+// ============ WATCH COMMANDS ============
+
+const watchCmd = program.command("watch").description("Continuous monitoring");
+
+watchCmd
+  .command("start")
+  .description("Start watching an app")
+  .requiredOption("-a, --app <app>", "App name or ID")
+  .option("-i, --interval <min>", "Interval in minutes", parseIntOption, 5)
+  .action(async (options) => {
+    await ensureDb();
+    const app = await resolveApp(options.app);
+
+    if (!app) {
+      console.error(`✗ App "${options.app}" not found`);
+      process.exit(1);
+    }
+
+    const intervalMs = options.interval * 60 * 1000;
+
+    try {
+      const started = await startWatching(app.id, intervalMs);
+      if (started) {
+        console.log(`✓ Started watching "${app.name}" (interval: ${options.interval}min)`);
+        logWatchStart(app.name, intervalMs);
+
+        // Keep process alive
+        console.log("Press Ctrl+C to stop watching.\n");
+        process.on("SIGINT", async () => {
+          console.log("\nStopping...");
+          await stopAllWatchers();
+          logWatchStop(app.name);
+          process.exit(0);
+        });
+
+        // Keep the process running
+        await new Promise(() => {});
+      } else {
+        console.log(`Already watching "${app.name}"`);
+      }
+    } catch (error) {
+      const err = error as Error;
+      console.error(`✗ Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+
+watchCmd
+  .command("stop")
+  .description("Stop watching an app")
+  .requiredOption("-a, --app <app>", "App name or ID")
+  .action(async (options) => {
+    await ensureDb();
+    const app = await resolveApp(options.app);
+
+    if (!app) {
+      console.error(`✗ App "${options.app}" not found`);
+      process.exit(1);
+    }
+
+    const stopped = stopWatching(app.id);
+    if (stopped) {
+      console.log(`✓ Stopped watching "${app.name}"`);
+      logWatchStop(app.name);
+    } else {
+      console.log(`Not watching "${app.name}"`);
+    }
+  });
+
+watchCmd
+  .command("status")
+  .description("Check watch status")
+  .action(async () => {
+    const statuses = await getWatchStatus();
+
+    if (statuses.length === 0) {
+      console.log("No apps being watched.");
+      return;
+    }
+
+    console.log("\nActive watchers:\n");
+    for (const status of statuses) {
+      const intervalMin = (status.intervalMs || 0) / 60000;
+      console.log(`  ● ${status.appName} (ID: ${status.appId})`);
+      console.log(`    Interval: ${intervalMin}min`);
+      if (status.lastScan) {
+        console.log(`    Last scan: ${status.lastScan}`);
+      }
+      console.log();
+    }
+  });
+
+// ============ CONFIG COMMANDS ============
+
+program
+  .command("config")
+  .description("Manage configuration")
+  .option("--show", "Show current config")
+  .option("--path", "Show config file path")
+  .option("--set-headless <bool>", "Set headless mode", (v) => v === "true")
+  .option("--set-timeout <ms>", "Set default timeout", parseIntOption)
+  .option("--set-db-path <path>", "Set database path")
+  .option("--set-watch-interval <ms>", "Set watch interval", parseIntOption)
+  .action((options) => {
+    if (options.path) {
+      console.log(getConfigPath());
+      return;
+    }
+
+    if (options.show) {
+      const config = loadConfig();
+      console.log("\nConfiguration:\n");
+      console.log(`  Database path: ${config.databasePath}`);
+      console.log(`  Headless: ${config.headless}`);
+      console.log(`  Default timeout: ${config.defaultTimeout}ms`);
+      console.log(`  Watch interval: ${config.watchInterval}ms`);
+      console.log(`  Log level: ${config.logLevel}`);
+      console.log(`\n  Config file: ${getConfigPath()}`);
+      return;
+    }
+
+    const updates: Record<string, unknown> = {};
+    if (options.setHeadless !== undefined) {
+      updates.headless = options.setHeadless;
+    }
+    if (options.setTimeout !== undefined) {
+      updates.defaultTimeout = options.setTimeout;
+    }
+    if (options.setDbPath !== undefined) {
+      updates.databasePath = options.setDbPath;
+    }
+    if (options.setWatchInterval !== undefined) {
+      updates.watchInterval = options.setWatchInterval;
+    }
+
+    if (Object.keys(updates).length > 0) {
+      saveConfig(updates);
+      console.log("✓ Configuration updated");
+    } else {
+      console.log("No changes. Use --show to view config or --set-* to modify.");
+    }
+  });
+
+// ============ SNAPSHOTS COMMAND ============
+
+program
+  .command("snapshots")
+  .description("List snapshots from a scan")
+  .option("-s, --scan <id>", "Scan ID", parseIntOption)
+  .option("-a, --app <app>", "App name or ID (shows latest scan)")
+  .action(async (options) => {
+    await ensureDb();
+
+    let scanId: number | undefined = options.scan;
+
+    if (!scanId && options.app) {
+      const app = await resolveApp(options.app);
+      if (!app) {
+        console.error(`✗ App "${options.app}" not found`);
+        process.exit(1);
+      }
+      const lastScan = await getLastScanForApp(app.id);
+      if (!lastScan) {
+        console.log(`No scans found for "${app.name}"`);
+        return;
+      }
+      scanId = lastScan.id;
+    }
+
+    if (!scanId) {
+      console.error("✗ Specify --scan or --app");
+      process.exit(1);
+    }
+
+    const screenshots = await getScreenshotsByScanId(scanId);
+
+    if (screenshots.length === 0) {
+      console.log("No screenshots found for this scan.");
+      return;
+    }
+
+    console.log(`\nSnapshots for scan #${scanId}:\n`);
+    for (const ss of screenshots) {
+      console.log(`  📸 ${ss.filename}`);
+      console.log(`     Path: ${ss.filepath}`);
+      console.log(`     Created: ${ss.created_at}`);
+      console.log();
+    }
+
+    console.log(`Total: ${screenshots.length} screenshots`);
+    console.log(`\nTo view a screenshot, open the path in your file viewer.`);
+  });
+
+// ============ SERVER COMMAND ============
+
+program
+  .command("server")
+  .description("Start the HTTP API server")
+  .option("-p, --port <port>", "Server port", parseIntOption, 3100)
+  .action(async (options) => {
+    await ensureDb();
+    console.log(`Starting server on port ${options.port}...`);
+    console.log(`See: http://localhost:${options.port}/health`);
+
+    // Import and start server
+    const { startServer } = await import("../src/server/index");
+    startServer(options.port);
+  });
+
+// ============ HELPER FUNCTIONS ============
+
+async function ensureDb(): Promise<void> {
+  getDb();
+  await createTables();
+}
+
+async function resolveApp(idOrName: string) {
+  const id = parseInt(idOrName, 10);
+  if (!isNaN(id)) {
+    return await getAppById(id);
+  }
+  return await getAppByName(idOrName);
+}
+
+async function scanApp(
+  appId: number,
+  monitor: ConsoleMonitor,
+  specificPaths?: string[]
+): Promise<void> {
+  const app = await getAppById(appId);
+  if (!app) {
+    console.error(`✗ App ID ${appId} not found`);
+    return;
+  }
+
+  let pages = await getPagesByAppId(appId, true);
+
+  if (specificPaths && specificPaths.length > 0) {
+    pages = pages.filter((p) => specificPaths.includes(p.path));
+  }
+
+  if (pages.length === 0) {
+    console.log(`No pages to scan for "${app.name}"`);
+    return;
+  }
+
+  // Ensure snapshots directory exists
+  const snapshotsDir = ensureSnapshotsDir();
+
+  console.log(`\nScanning "${app.name}" (${pages.length} pages)...\n`);
+  logScanStart(app.name, pages.length);
+
+  const scan = await createScan({ app_id: appId });
+  let totalErrors = 0;
+  let pagesScanned = 0;
+  const screenshotPaths: string[] = [];
+
+  for (const page of pages) {
+    const url = `${app.base_url}${page.path}`;
+    process.stdout.write(`  Scanning ${page.path}... `);
+
+    // Generate screenshot filename
+    const screenshotFilename = generateScreenshotFilename(page.name, page.path);
+    const screenshotFullPath = getScreenshotPath(screenshotFilename);
+
+    try {
+      const result = await monitor.scanPage(url, {
+        timeout: page.timeout,
+        waitFor: page.wait_for || undefined,
+        captureScreenshot: true,
+        screenshotDir: screenshotFullPath,
+      });
+
+      const { logs, screenshotPath } = result;
+
+      // Save screenshot record if captured
+      if (screenshotPath) {
+        await createScreenshot({
+          scan_id: scan.id,
+          page_id: page.id,
+          filename: screenshotFilename,
+          filepath: screenshotPath,
+        });
+        screenshotPaths.push(screenshotPath);
+      }
+
+      if (logs.length > 0) {
+        const logInputs: CreateConsoleLogInput[] = logs.map((log) => ({
+          scan_id: scan.id,
+          page_id: page.id,
+          level: log.level as ConsoleLogLevel,
+          message: log.message,
+          source_url: log.sourceUrl,
+          line_number: log.lineNumber,
+          column_number: log.columnNumber,
+          stack_trace: log.stackTrace,
+        }));
+
+        await createConsoleLogsBatch(logInputs);
+
+        const errorCount = logs.filter((l) => l.level === "error").length;
+        const warnCount = logs.filter((l) => l.level === "warn").length;
+        totalErrors += errorCount;
+
+        console.log(`${logs.length} logs (${errorCount} errors, ${warnCount} warnings)`);
+      } else {
+        console.log("clean");
+      }
+
+      if (screenshotPath) {
+        console.log(`    📸 ${screenshotPath}`);
+      }
+
+      pagesScanned++;
+    } catch (error) {
+      const err = error as Error;
+      console.log(`failed: ${err.message}`);
+      logError(`Failed to scan ${url}: ${err.message}`);
+    }
+  }
+
+  await updateScan(scan.id, {
+    status: "completed",
+    pages_scanned: pagesScanned,
+    errors_found: totalErrors,
+    completed_at: new Date().toISOString(),
+  });
+
+  console.log(`\n✓ Scan complete: ${pagesScanned} pages, ${totalErrors} errors`);
+  if (screenshotPaths.length > 0) {
+    console.log(`📸 Screenshots saved to: ${getSnapshotsDir()}`);
+    console.log(`\nScreenshot paths:`);
+    for (const path of screenshotPaths) {
+      console.log(`  ${path}`);
+    }
+  }
+  console.log();
+  logScanComplete(app.name, pagesScanned, totalErrors);
+}
+
+function getLevelIcon(level: string): string {
+  switch (level) {
+    case "error":
+      return "❌";
+    case "warn":
+      return "⚠️";
+    case "info":
+      return "ℹ️";
+    case "debug":
+      return "🔍";
+    default:
+      return "📝";
+  }
+}
+
+// Run CLI
+program.parse(process.argv);