@hasna/skills 0.0.2

package/skills/skill-consolelog/src/lib/installer.ts

@@ -0,0 +1,294 @@
+import { existsSync, mkdirSync, writeFileSync, appendFileSync } from "fs";
+import { join } from "path";
+import { randomUUID } from "crypto";
+import { homedir } from "os";
+
+const SERVICE_DIR_NAME = ".service-consolelog";
+const SNAPSHOTS_DIR_NAME = "snapshots";
+
+export interface InstallOptions {
+  projectRoot?: string;
+  force?: boolean;
+}
+
+// Get the global service directory in home
+export function getGlobalServiceDir(): string {
+  return join(homedir(), SERVICE_DIR_NAME);
+}
+
+// Get the project-specific service directory (for per-project logs)
+export function getServiceDir(projectRoot?: string): string {
+  const root = projectRoot || process.cwd();
+  return join(root, SERVICE_DIR_NAME);
+}
+
+export function getSnapshotsDir(projectRoot?: string): string {
+  return join(getServiceDir(projectRoot), SNAPSHOTS_DIR_NAME);
+}
+
+export function getLogFilePath(projectRoot?: string): string {
+  return join(getServiceDir(projectRoot), "service-consolelog.log");
+}
+
+export function getReadmePath(projectRoot?: string): string {
+  return join(getServiceDir(projectRoot), "README.md");
+}
+
+export function isInstalled(projectRoot?: string): boolean {
+  return existsSync(getServiceDir(projectRoot));
+}
+
+export function isGlobalInstalled(): boolean {
+  return existsSync(getGlobalServiceDir());
+}
+
+// Ensure global service directory in home exists
+export function ensureGlobalInstalled(): void {
+  const globalDir = getGlobalServiceDir();
+  if (!existsSync(globalDir)) {
+    mkdirSync(globalDir, { recursive: true });
+
+    // Create README
+    const readmePath = join(globalDir, "README.md");
+    writeFileSync(readmePath, generateReadme());
+
+    // Create log file
+    const logPath = join(globalDir, "service-consolelog.log");
+    const logHeader = `# service-consolelog log file
+# Created: ${new Date().toISOString()}
+# This file contains global activity history.
+# -------------------------------------------------------
+
+`;
+    writeFileSync(logPath, logHeader);
+  }
+}
+
+export function ensureInstalled(projectRoot?: string): void {
+  // Always ensure global directory exists
+  ensureGlobalInstalled();
+
+  // Also create project-specific directory if projectRoot specified
+  if (projectRoot && !isInstalled(projectRoot)) {
+    install({ projectRoot });
+  }
+}
+
+// Normalize page name for filename (remove special chars, lowercase, replace spaces)
+export function normalizePageName(pageName: string | null, pagePath: string): string {
+  const name = pageName || pagePath;
+  return name
+    .toLowerCase()
+    .replace(/^\//, "") // Remove leading slash
+    .replace(/\//g, "_") // Replace slashes with underscores
+    .replace(/[^a-z0-9_-]/g, "") // Remove special chars
+    .replace(/^$/, "home"); // Default to "home" if empty (root path)
+}
+
+// Generate screenshot filename
+export function generateScreenshotFilename(pageName: string | null, pagePath: string): string {
+  const normalized = normalizePageName(pageName, pagePath);
+  const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const uniqueId = randomUUID().slice(0, 8);
+  return `snapshot_${normalized}_${timestamp}_${uniqueId}.png`;
+}
+
+// Get full screenshot path
+export function getScreenshotPath(filename: string, projectRoot?: string): string {
+  return join(getSnapshotsDir(projectRoot), filename);
+}
+
+// Ensure snapshots directory exists
+export function ensureSnapshotsDir(projectRoot?: string): string {
+  const dir = getSnapshotsDir(projectRoot);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  return dir;
+}
+
+export function install(options: InstallOptions = {}): { success: boolean; path: string; message: string } {
+  const serviceDir = getServiceDir(options.projectRoot);
+
+  if (existsSync(serviceDir) && !options.force) {
+    return {
+      success: false,
+      path: serviceDir,
+      message: "Already installed. Use --force to reinstall.",
+    };
+  }
+
+  // Create directory
+  mkdirSync(serviceDir, { recursive: true });
+
+  // Create snapshots directory
+  mkdirSync(getSnapshotsDir(options.projectRoot), { recursive: true });
+
+  // Create README
+  const readmeContent = generateReadme();
+  writeFileSync(getReadmePath(options.projectRoot), readmeContent);
+
+  // Create empty log file with header
+  const logHeader = `# service-consolelog log file
+# Created: ${new Date().toISOString()}
+# This file contains local scan logs and activity history.
+# -------------------------------------------------------
+
+`;
+  writeFileSync(getLogFilePath(options.projectRoot), logHeader);
+
+  return {
+    success: true,
+    path: serviceDir,
+    message: `Installed at ${serviceDir}`,
+  };
+}
+
+export function uninstall(projectRoot?: string): { success: boolean; message: string } {
+  const serviceDir = getServiceDir(projectRoot);
+
+  if (!existsSync(serviceDir)) {
+    return {
+      success: false,
+      message: "Not installed.",
+    };
+  }
+
+  // Remove directory recursively
+  const { rmSync } = require("fs");
+  rmSync(serviceDir, { recursive: true, force: true });
+
+  return {
+    success: true,
+    message: `Uninstalled from ${serviceDir}`,
+  };
+}
+
+function generateReadme(): string {
+  return `# .service-consolelog
+
+This directory contains local configuration and logs for \`service-consolelog\`.
+
+## Files & Folders
+
+| Path | Description |
+|------|-------------|
+| \`service-consolelog.log\` | Activity log for console monitoring sessions |
+| \`snapshots/\` | Page screenshots captured during scans |
+| \`README.md\` | This file |
+
+## Snapshots
+
+Screenshots are captured during scans and saved to the \`snapshots/\` folder with naming:
+\`\`\`
+snapshot_<pagename>_<timestamp>_<uniqueid>.png
+\`\`\`
+
+Example: \`snapshot_home_2024-01-15T10-30-45-123Z_a1b2c3d4.png\`
+
+## What is service-consolelog?
+
+\`service-consolelog\` is a Bun-based service that monitors console logs from web applications using Playwright headless browser. It helps you:
+
+- Track console errors, warnings, and info messages
+- Monitor multiple pages across your applications
+- View historical scan data
+- Set up continuous monitoring with watch mode
+
+## Usage
+
+\`\`\`bash
+# Add an app to monitor
+service-consolelog app add --name "myapp" --port 3000 --url "http://localhost:3000"
+
+# Add pages to monitor
+service-consolelog page add --app "myapp" --path "/" --name "Home"
+service-consolelog page add --app "myapp" --path "/dashboard" --name "Dashboard"
+
+# Run a scan
+service-consolelog scan --app "myapp"
+
+# View logs
+service-consolelog logs --app "myapp" --level error
+
+# Start watching (continuous monitoring)
+service-consolelog watch start --app "myapp" --interval 5
+\`\`\`
+
+## Log File
+
+The \`service-consolelog.log\` file in this directory contains:
+- Scan timestamps and results
+- Error summaries
+- Watch mode activity
+
+This file is local to your project and is not synced to any remote service.
+
+## Configuration
+
+Global configuration is stored at \`~/.consolelog.json\`.
+Database is stored at \`./data/consolelog.db\` (configurable).
+
+## More Information
+
+For full documentation, see the main project README or run:
+
+\`\`\`bash
+service-consolelog --help
+\`\`\`
+`;
+}
+
+// Logging utilities
+
+export type LogLevel = "debug" | "info" | "warn" | "error";
+
+export function logToFile(
+  message: string,
+  level: LogLevel = "info",
+  projectRoot?: string
+): void {
+  if (!isInstalled(projectRoot)) {
+    return;
+  }
+
+  const timestamp = new Date().toISOString();
+  const logLine = `[${timestamp}] [${level.toUpperCase()}] ${message}\n`;
+
+  try {
+    appendFileSync(getLogFilePath(projectRoot), logLine);
+  } catch {
+    // Silently fail if we can't write to log
+  }
+}
+
+export function logScanStart(appName: string, pageCount: number, projectRoot?: string): void {
+  logToFile(`Starting scan for "${appName}" (${pageCount} pages)`, "info", projectRoot);
+}
+
+export function logScanComplete(
+  appName: string,
+  pagesScanned: number,
+  errorsFound: number,
+  projectRoot?: string
+): void {
+  const level = errorsFound > 0 ? "warn" : "info";
+  logToFile(
+    `Scan complete for "${appName}": ${pagesScanned} pages, ${errorsFound} errors found`,
+    level,
+    projectRoot
+  );
+}
+
+export function logWatchStart(appName: string, intervalMs: number, projectRoot?: string): void {
+  const intervalMin = intervalMs / 60000;
+  logToFile(`Watch mode started for "${appName}" (interval: ${intervalMin}min)`, "info", projectRoot);
+}
+
+export function logWatchStop(appName: string, projectRoot?: string): void {
+  logToFile(`Watch mode stopped for "${appName}"`, "info", projectRoot);
+}
+
+export function logError(error: string, projectRoot?: string): void {
+  logToFile(error, "error", projectRoot);
+}

package/skills/skill-consolelog/src/lib/monitor.ts

@@ -0,0 +1,194 @@
+import { chromium, type Browser, type Page as PlaywrightPage } from "playwright";
+import type { ConsoleLogEntry, ScanOptions, PageScanResult } from "./types";
+
+export class ConsoleMonitor {
+  private browser: Browser | null = null;
+  private headless: boolean;
+
+  constructor(headless = true) {
+    this.headless = headless;
+  }
+
+  async start(): Promise<void> {
+    if (this.browser) {
+      return;
+    }
+    this.browser = await chromium.launch({ headless: this.headless });
+  }
+
+  async stop(): Promise<void> {
+    if (this.browser) {
+      await this.browser.close();
+      this.browser = null;
+    }
+  }
+
+  isRunning(): boolean {
+    return this.browser !== null;
+  }
+
+  async scanPage(url: string, options?: ScanOptions): Promise<PageScanResult> {
+    if (!this.browser) {
+      throw new Error("Browser not started. Call start() first.");
+    }
+
+    const context = await this.browser.newContext();
+    const page = await context.newPage();
+    const logs: ConsoleLogEntry[] = [];
+    let screenshotPath: string | undefined;
+
+    // Attach console listener for all message types
+    page.on("console", (msg) => {
+      const location = msg.location();
+      logs.push({
+        level: mapConsoleType(msg.type()),
+        message: msg.text(),
+        sourceUrl: location.url || undefined,
+        lineNumber: location.lineNumber || undefined,
+        columnNumber: location.columnNumber || undefined,
+      });
+    });
+
+    // Attach error listener for uncaught exceptions
+    page.on("pageerror", (err) => {
+      logs.push({
+        level: "error",
+        message: err.message,
+        stackTrace: err.stack,
+      });
+    });
+
+    try {
+      // Navigate to the page
+      await page.goto(url, {
+        waitUntil: "networkidle",
+        timeout: options?.timeout || 30000,
+      });
+
+      // Wait for specific selector if provided
+      if (options?.waitFor) {
+        await page.waitForSelector(options.waitFor, {
+          timeout: options.timeout || 30000,
+        });
+      }
+
+      // Small delay to catch any async console messages
+      await page.waitForTimeout(1000);
+
+      // Capture screenshot if requested
+      if (options?.captureScreenshot && options?.screenshotDir) {
+        try {
+          screenshotPath = options.screenshotDir;
+          await page.screenshot({
+            path: screenshotPath,
+            fullPage: true,
+          });
+        } catch (screenshotError) {
+          const err = screenshotError as Error;
+          logs.push({
+            level: "warn",
+            message: `Screenshot capture failed: ${err.message}`,
+          });
+          screenshotPath = undefined;
+        }
+      }
+    } catch (error) {
+      const err = error as Error;
+      logs.push({
+        level: "error",
+        message: `Navigation error: ${err.message}`,
+        stackTrace: err.stack,
+      });
+    } finally {
+      await context.close();
+    }
+
+    return { logs, screenshotPath };
+  }
+
+  async scanMultiplePages(
+    pages: { url: string; pageId: number; options?: ScanOptions }[]
+  ): Promise<Map<number, PageScanResult>> {
+    const results = new Map<number, PageScanResult>();
+
+    for (const { url, pageId, options } of pages) {
+      try {
+        const result = await this.scanPage(url, options);
+        results.set(pageId, result);
+      } catch (error) {
+        const err = error as Error;
+        results.set(pageId, {
+          logs: [
+            {
+              level: "error",
+              message: `Failed to scan page: ${err.message}`,
+              stackTrace: err.stack,
+            },
+          ],
+        });
+      }
+    }
+
+    return results;
+  }
+
+  async checkUrl(url: string, timeout = 5000): Promise<boolean> {
+    if (!this.browser) {
+      throw new Error("Browser not started. Call start() first.");
+    }
+
+    const context = await this.browser.newContext();
+    const page = await context.newPage();
+
+    try {
+      const response = await page.goto(url, {
+        waitUntil: "domcontentloaded",
+        timeout,
+      });
+      await context.close();
+      return response?.ok() ?? false;
+    } catch {
+      await context.close();
+      return false;
+    }
+  }
+}
+
+function mapConsoleType(type: string): string {
+  // Map Playwright console types to our levels
+  switch (type) {
+    case "error":
+      return "error";
+    case "warning":
+      return "warn";
+    case "info":
+      return "info";
+    case "log":
+      return "log";
+    case "debug":
+      return "debug";
+    case "trace":
+      return "debug";
+    case "assert":
+      return "error";
+    default:
+      return "log";
+  }
+}
+
+// Singleton instance for convenience
+let monitorInstance: ConsoleMonitor | null = null;
+
+export function getMonitor(headless = true): ConsoleMonitor {
+  if (!monitorInstance) {
+    monitorInstance = new ConsoleMonitor(headless);
+  }
+  return monitorInstance;
+}
+
+export async function shutdownMonitor(): Promise<void> {
+  if (monitorInstance) {
+    await monitorInstance.stop();
+    monitorInstance = null;
+  }
+}

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

@@ -0,0 +1,189 @@
+// 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;
+}