@hasna/skills 0.1.60 → 0.1.61

package/skills/consolelog/src/lib/types.ts

@@ -1,189 +0,0 @@
-// Database Types
-
-export interface App {
-  id: number;
-  name: string;
-  port: number;
-  base_url: string;
-  description: string | null;
-  active: number;
-  created_at: string;
-  updated_at: string;
-}
-
-export interface Page {
-  id: number;
-  app_id: number;
-  path: string;
-  name: string | null;
-  wait_for: string | null;
-  timeout: number;
-  active: number;
-  created_at: string;
-}
-
-export interface Scan {
-  id: number;
-  app_id: number;
-  started_at: string;
-  completed_at: string | null;
-  status: "running" | "completed" | "failed";
-  pages_scanned: number;
-  errors_found: number;
-}
-
-export interface ConsoleLog {
-  id: number;
-  scan_id: number;
-  page_id: number;
-  level: ConsoleLogLevel;
-  message: string;
-  source_url: string | null;
-  line_number: number | null;
-  column_number: number | null;
-  stack_trace: string | null;
-  timestamp: string;
-}
-
-export type ConsoleLogLevel = "error" | "warn" | "info" | "log" | "debug";
-
-// Input Types
-
-export interface CreateAppInput {
-  name: string;
-  port: number;
-  base_url: string;
-  description?: string;
-}
-
-export interface UpdateAppInput {
-  name?: string;
-  port?: number;
-  base_url?: string;
-  description?: string;
-  active?: boolean;
-}
-
-export interface CreatePageInput {
-  app_id: number;
-  path: string;
-  name?: string;
-  wait_for?: string;
-  timeout?: number;
-}
-
-export interface CreateScanInput {
-  app_id: number;
-}
-
-export interface CreateConsoleLogInput {
-  scan_id: number;
-  page_id: number;
-  level: ConsoleLogLevel;
-  message: string;
-  source_url?: string;
-  line_number?: number;
-  column_number?: number;
-  stack_trace?: string;
-}
-
-// Query Filters
-
-export interface LogFilter {
-  app_id?: number;
-  scan_id?: number;
-  page_id?: number;
-  level?: ConsoleLogLevel;
-  since?: string;
-  until?: string;
-  limit?: number;
-  offset?: number;
-}
-
-export interface ScanFilter {
-  app_id?: number;
-  status?: "running" | "completed" | "failed";
-  limit?: number;
-  offset?: number;
-}
-
-// Scan Options
-
-export interface ScanOptions {
-  timeout?: number;
-  waitFor?: string;
-  captureScreenshot?: boolean;
-  screenshotDir?: string;
-}
-
-// Screenshot
-
-export interface Screenshot {
-  id: number;
-  scan_id: number;
-  page_id: number;
-  filename: string;
-  filepath: string;
-  created_at: string;
-}
-
-export interface CreateScreenshotInput {
-  scan_id: number;
-  page_id: number;
-  filename: string;
-  filepath: string;
-}
-
-// Console Log Entry (from Playwright)
-
-export interface ConsoleLogEntry {
-  level: string;
-  message: string;
-  sourceUrl?: string;
-  lineNumber?: number;
-  columnNumber?: number;
-  stackTrace?: string;
-}
-
-// Page Scan Result
-
-export interface PageScanResult {
-  logs: ConsoleLogEntry[];
-  screenshotPath?: string;
-}
-
-// Watch Status
-
-export interface WatchStatus {
-  appId: number;
-  appName: string;
-  active: boolean;
-  intervalMs?: number;
-  lastScan?: string;
-}
-
-// Config
-
-export interface Config {
-  databasePath: string;
-  headless: boolean;
-  defaultTimeout: number;
-  watchInterval: number;
-  logLevel: "debug" | "info" | "warn" | "error";
-}
-
-// API Response Types
-
-export interface ApiResponse<T = unknown> {
-  success: boolean;
-  data?: T;
-  error?: string;
-}
-
-export interface PaginatedResponse<T> {
-  success: boolean;
-  data: T[];
-  total: number;
-  limit: number;
-  offset: number;
-}

package/skills/consolelog/src/lib/watcher.ts

@@ -1,207 +0,0 @@
-import { ConsoleMonitor, getMonitor } from "./monitor";
-import {
-  getAppById,
-  getPagesByAppId,
-  createScan,
-  updateScan,
-  createConsoleLogsBatch,
-} from "../db/queries";
-import { getWatchInterval, isHeadless } from "./config";
-import type { WatchStatus, ConsoleLogEntry, CreateConsoleLogInput, ConsoleLogLevel } from "./types";
-
-interface WatcherInfo {
-  timer: Timer;
-  intervalMs: number;
-  lastScan: string | null;
-}
-
-class ConsoleWatcher {
-  private watchers: Map<number, WatcherInfo> = new Map();
-  private monitor: ConsoleMonitor | null = null;
-
-  async ensureMonitor(): Promise<ConsoleMonitor> {
-    if (!this.monitor) {
-      this.monitor = getMonitor(isHeadless());
-      await this.monitor.start();
-    }
-    return this.monitor;
-  }
-
-  async start(appId: number, intervalMs?: number): Promise<boolean> {
-    // Check if already watching
-    if (this.watchers.has(appId)) {
-      return false;
-    }
-
-    // Verify app exists
-    const app = await getAppById(appId);
-    if (!app) {
-      throw new Error(`App with ID ${appId} not found`);
-    }
-
-    const interval = intervalMs || getWatchInterval();
-
-    // Run initial scan
-    await this.scanApp(appId);
-
-    // Set up interval
-    const timer = setInterval(async () => {
-      await this.scanApp(appId);
-    }, interval);
-
-    this.watchers.set(appId, {
-      timer,
-      intervalMs: interval,
-      lastScan: new Date().toISOString(),
-    });
-
-    return true;
-  }
-
-  stop(appId: number): boolean {
-    const info = this.watchers.get(appId);
-    if (!info) {
-      return false;
-    }
-
-    clearInterval(info.timer);
-    this.watchers.delete(appId);
-    return true;
-  }
-
-  async stopAll(): Promise<void> {
-    for (const [appId] of this.watchers) {
-      this.stop(appId);
-    }
-
-    if (this.monitor) {
-      await this.monitor.stop();
-      this.monitor = null;
-    }
-  }
-
-  isWatching(appId: number): boolean {
-    return this.watchers.has(appId);
-  }
-
-  async getStatus(): Promise<WatchStatus[]> {
-    const statuses: WatchStatus[] = [];
-
-    for (const [appId, info] of this.watchers) {
-      const app = await getAppById(appId);
-      if (app) {
-        statuses.push({
-          appId,
-          appName: app.name,
-          active: true,
-          intervalMs: info.intervalMs,
-          lastScan: info.lastScan || undefined,
-        });
-      }
-    }
-
-    return statuses;
-  }
-
-  getWatcherInfo(appId: number): WatcherInfo | undefined {
-    return this.watchers.get(appId);
-  }
-
-  private async scanApp(appId: number): Promise<void> {
-    try {
-      const app = await getAppById(appId);
-      if (!app || !app.active) {
-        this.stop(appId);
-        return;
-      }
-
-      const pages = await getPagesByAppId(appId, true);
-      if (pages.length === 0) {
-        return;
-      }
-
-      const monitor = await this.ensureMonitor();
-
-      // Create scan record
-      const scan = await createScan({ app_id: appId });
-
-      let totalErrors = 0;
-      let pagesScanned = 0;
-
-      // Scan each page
-      for (const page of pages) {
-        const url = `${app.base_url}${page.path}`;
-
-        try {
-          const logs = await monitor.scanPage(url, {
-            timeout: page.timeout,
-            waitFor: page.wait_for || undefined,
-          });
-
-          // Save logs to database
-          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);
-            totalErrors += logs.filter((l) => l.level === "error").length;
-          }
-
-          pagesScanned++;
-        } catch (error) {
-          const err = error as Error;
-          console.error(`Error scanning page ${url}:`, err.message);
-        }
-      }
-
-      // Update scan record
-      await updateScan(scan.id, {
-        status: "completed",
-        pages_scanned: pagesScanned,
-        errors_found: totalErrors,
-        completed_at: new Date().toISOString(),
-      });
-
-      // Update last scan time
-      const info = this.watchers.get(appId);
-      if (info) {
-        info.lastScan = new Date().toISOString();
-      }
-    } catch (error) {
-      const err = error as Error;
-      console.error(`Watch scan failed for app ${appId}:`, err.message);
-    }
-  }
-}
-
-// Singleton instance
-export const watcher = new ConsoleWatcher();
-
-// Convenience exports
-export function startWatching(appId: number, intervalMs?: number): Promise<boolean> {
-  return watcher.start(appId, intervalMs);
-}
-
-export function stopWatching(appId: number): boolean {
-  return watcher.stop(appId);
-}
-
-export async function getWatchStatus(): Promise<WatchStatus[]> {
-  return watcher.getStatus();
-}
-
-export function isWatching(appId: number): boolean {
-  return watcher.isWatching(appId);
-}
-
-export async function stopAllWatchers(): Promise<void> {
-  return watcher.stopAll();
-}

package/skills/consolelog/tests/api.test.ts

@@ -1,154 +0,0 @@
-import { describe, test, expect, beforeAll, afterAll } from "bun:test";
-import { existsSync, unlinkSync, mkdirSync } from "fs";
-
-// Test database path
-const TEST_DB_PATH = "./data/test_api_service_consolelog.db";
-process.env.DATABASE_PATH = TEST_DB_PATH;
-
-import { createTables } from "../src/db/schema";
-import { closeConnection } from "../src/db/index";
-import {
-  createApp,
-  createPage,
-  createScan,
-  createConsoleLog,
-  deleteApp,
-} from "../src/db/queries";
-
-// We'll test the API handlers directly since starting the server
-// in tests can cause port conflicts
-
-describe("API Handlers", () => {
-  let testAppId: number;
-  let testPageId: number;
-  let testScanId: number;
-
-  beforeAll(() => {
-    // Ensure data directory exists
-    if (!existsSync("./data")) {
-      mkdirSync("./data", { recursive: true });
-    }
-    // Remove test db if exists
-    if (existsSync(TEST_DB_PATH)) {
-      unlinkSync(TEST_DB_PATH);
-    }
-    if (existsSync(TEST_DB_PATH + "-wal")) {
-      unlinkSync(TEST_DB_PATH + "-wal");
-    }
-    if (existsSync(TEST_DB_PATH + "-shm")) {
-      unlinkSync(TEST_DB_PATH + "-shm");
-    }
-
-    // Initialize database
-    createTables();
-
-    // Create test data
-    const app = createApp({
-      name: "api-test-app",
-      port: 9000,
-      base_url: "http://localhost:9000",
-      description: "API test app",
-    });
-    testAppId = app.id;
-
-    const page = createPage({
-      app_id: testAppId,
-      path: "/",
-      name: "Home",
-    });
-    testPageId = page.id;
-
-    const scan = createScan({ app_id: testAppId });
-    testScanId = scan.id;
-
-    // Add some logs
-    createConsoleLog({
-      scan_id: testScanId,
-      page_id: testPageId,
-      level: "error",
-      message: "Test error",
-    });
-    createConsoleLog({
-      scan_id: testScanId,
-      page_id: testPageId,
-      level: "warn",
-      message: "Test warning",
-    });
-  });
-
-  afterAll(() => {
-    closeConnection();
-    // Cleanup test database
-    if (existsSync(TEST_DB_PATH)) {
-      unlinkSync(TEST_DB_PATH);
-    }
-    if (existsSync(TEST_DB_PATH + "-wal")) {
-      unlinkSync(TEST_DB_PATH + "-wal");
-    }
-    if (existsSync(TEST_DB_PATH + "-shm")) {
-      unlinkSync(TEST_DB_PATH + "-shm");
-    }
-  });
-
-  describe("Data integrity for API", () => {
-    test("should have test app created", () => {
-      const { getAppById } = require("../src/db/queries");
-      const app = getAppById(testAppId);
-      expect(app).toBeDefined();
-      expect(app.name).toBe("api-test-app");
-    });
-
-    test("should have test page created", () => {
-      const { getPageById } = require("../src/db/queries");
-      const page = getPageById(testPageId);
-      expect(page).toBeDefined();
-      expect(page.name).toBe("Home");
-    });
-
-    test("should have test scan created", () => {
-      const { getScanById } = require("../src/db/queries");
-      const scan = getScanById(testScanId);
-      expect(scan).toBeDefined();
-    });
-
-    test("should have logs created", () => {
-      const { getConsoleLogs } = require("../src/db/queries");
-      const logs = getConsoleLogs({ scan_id: testScanId });
-      expect(logs.length).toBe(2);
-    });
-  });
-
-  describe("Query functions for API endpoints", () => {
-    test("getAllApps should return array", () => {
-      const { getAllApps } = require("../src/db/queries");
-      const apps = getAllApps();
-      expect(Array.isArray(apps)).toBe(true);
-      expect(apps.length).toBeGreaterThan(0);
-    });
-
-    test("getScans with filter should work", () => {
-      const { getScans } = require("../src/db/queries");
-      const scans = getScans({ app_id: testAppId, limit: 10 });
-      expect(Array.isArray(scans)).toBe(true);
-    });
-
-    test("getConsoleLogs with multiple filters should work", () => {
-      const { getConsoleLogs } = require("../src/db/queries");
-      const logs = getConsoleLogs({
-        app_id: testAppId,
-        level: "error",
-        limit: 10,
-        offset: 0,
-      });
-      expect(Array.isArray(logs)).toBe(true);
-      expect(logs.every((l: any) => l.level === "error")).toBe(true);
-    });
-
-    test("countConsoleLogs should return number", () => {
-      const { countConsoleLogs } = require("../src/db/queries");
-      const count = countConsoleLogs({ scan_id: testScanId });
-      expect(typeof count).toBe("number");
-      expect(count).toBe(2);
-    });
-  });
-});