@hasna/skills 0.1.59 → 0.1.61

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

@@ -1,110 +0,0 @@
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
-import { join, dirname } from "path";
-import { homedir } from "os";
-import type { Config } from "./types";
-
-const CONFIG_FILE = join(homedir(), ".consolelog.json");
-
-const DEFAULT_CONFIG: Config = {
-  databasePath: "./data/service_consolelog.db",
-  headless: true,
-  defaultTimeout: 30000,
-  watchInterval: 300000, // 5 minutes
-  logLevel: "info",
-};
-
-export function loadConfig(): Config {
-  try {
-    if (existsSync(CONFIG_FILE)) {
-      const content = readFileSync(CONFIG_FILE, "utf-8");
-      const parsed = JSON.parse(content);
-      return { ...DEFAULT_CONFIG, ...parsed };
-    }
-  } catch (error) {
-    console.error("Failed to load config file, using defaults");
-  }
-  return { ...DEFAULT_CONFIG };
-}
-
-export function saveConfig(config: Partial<Config>): Config {
-  const current = loadConfig();
-  const updated = { ...current, ...config };
-
-  try {
-    const dir = dirname(CONFIG_FILE);
-    if (!existsSync(dir)) {
-      mkdirSync(dir, { recursive: true });
-    }
-    writeFileSync(CONFIG_FILE, JSON.stringify(updated, null, 2));
-  } catch (error) {
-    console.error("Failed to save config file:", error);
-    throw error;
-  }
-
-  return updated;
-}
-
-export function getConfigValue<K extends keyof Config>(key: K): Config[K] {
-  const config = loadConfig();
-  return config[key];
-}
-
-export function setConfigValue<K extends keyof Config>(
-  key: K,
-  value: Config[K]
-): Config {
-  return saveConfig({ [key]: value });
-}
-
-export function resetConfig(): Config {
-  return saveConfig(DEFAULT_CONFIG);
-}
-
-export function getConfigPath(): string {
-  return CONFIG_FILE;
-}
-
-export function configExists(): boolean {
-  return existsSync(CONFIG_FILE);
-}
-
-// Environment-aware config getters
-export function getDatabasePath(): string {
-  return process.env.DATABASE_PATH || loadConfig().databasePath;
-}
-
-export function isHeadless(): boolean {
-  if (process.env.HEADLESS !== undefined) {
-    return process.env.HEADLESS === "true";
-  }
-  return loadConfig().headless;
-}
-
-export function getDefaultTimeout(): number {
-  if (process.env.DEFAULT_TIMEOUT !== undefined) {
-    return parseInt(process.env.DEFAULT_TIMEOUT, 10);
-  }
-  return loadConfig().defaultTimeout;
-}
-
-export function getWatchInterval(): number {
-  if (process.env.WATCH_INTERVAL !== undefined) {
-    return parseInt(process.env.WATCH_INTERVAL, 10);
-  }
-  return loadConfig().watchInterval;
-}
-
-export function getLogLevel(): Config["logLevel"] {
-  const envLevel = process.env.LOG_LEVEL?.toLowerCase();
-  if (envLevel && ["debug", "info", "warn", "error"].includes(envLevel)) {
-    return envLevel as Config["logLevel"];
-  }
-  return loadConfig().logLevel;
-}
-
-export function getServerPort(): number {
-  if (process.env.PORT !== undefined) {
-    return parseInt(process.env.PORT, 10);
-  }
-  return 3100;
-}

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

@@ -1,294 +0,0 @@
-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/consolelog/src/lib/monitor.ts

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