@hasna/skills 0.1.60 → 0.1.62

package/skills/consolelog/package.json

@@ -1,40 +0,0 @@
-{
-  "name": "consolelog",
-  "version": "0.2.2",
-  "type": "module",
-  "description": "Monitor console logs from web applications using Playwright headless browser",
-  "private": true,
-  "publishConfig": {
-    "registry": "https://registry.npmjs.org",
-    "access": "restricted"
-  },
-  "bin": {
-    "consolelog": "src/index.ts"
-  },
-  "files": [
-    "bin",
-    "src",
-    "scripts",
-    "tsconfig.json"
-  ],
-  "scripts": {
-    "start": "bun run bin/cli.ts",
-    "dev": "bun --watch run bin/cli.ts",
-    "server": "bun run src/server/index.ts",
-    "server:dev": "bun --watch run src/server/index.ts",
-    "build": "bun build bin/cli.ts --compile --outfile=consolelog",
-    "db:migrate": "bun run scripts/migrate.ts",
-    "db:seed": "bun run scripts/seed.ts",
-    "db:reset": "rm -f data/consolelog.db && bun run db:migrate && bun run db:seed",
-    "test": "bun test",
-    "test:watch": "bun test --watch"
-  },
-  "dependencies": {
-    "playwright": "^1.49.0",
-    "postgres": "^3.4.4"
-  },
-  "devDependencies": {
-    "@types/bun": "^1.1.14",
-    "typescript": "^5.7.2"
-  }
-}

package/skills/consolelog/scripts/migrate.ts

@@ -1,26 +0,0 @@
-#!/usr/bin/env bun
-import { createTables, dropTables } from "../src/db/schema";
-import { getDb, closeConnection } from "../src/db/index";
-
-async function main() {
-  const args = process.argv.slice(2);
-
-  if (args.includes("--drop")) {
-    console.log("Dropping tables...");
-    await dropTables();
-    console.log("✓ Tables dropped");
-  }
-
-  console.log("Creating tables...");
-  getDb();
-  await createTables();
-  console.log("✓ Tables created");
-
-  await closeConnection();
-  console.log("✓ Migration complete");
-}
-
-main().catch((err) => {
-  console.error("Migration failed:", err);
-  process.exit(1);
-});

package/skills/consolelog/scripts/seed.ts

@@ -1,48 +0,0 @@
-#!/usr/bin/env bun
-import { createTables } from "../src/db/schema";
-import { getDb, closeConnection } from "../src/db/index";
-import { createApp, createPage } from "../src/db/queries";
-
-// Ensure tables exist
-getDb();
-createTables();
-
-console.log("Seeding database...\n");
-
-try {
-  // Create a sample app
-  const app = createApp({
-    name: "sample-app",
-    port: 3000,
-    base_url: "http://localhost:3000",
-    description: "Sample application for testing",
-  });
-  console.log(`✓ Created app: ${app.name} (ID: ${app.id})`);
-
-  // Add sample pages
-  const pages = [
-    { path: "/", name: "Home" },
-    { path: "/dashboard", name: "Dashboard" },
-    { path: "/settings", name: "Settings" },
-  ];
-
-  for (const pageData of pages) {
-    const page = createPage({
-      app_id: app.id,
-      path: pageData.path,
-      name: pageData.name,
-    });
-    console.log(`  ✓ Added page: ${page.path}`);
-  }
-
-  console.log("\n✓ Seed complete");
-} catch (error) {
-  const err = error as Error;
-  if (err.message.includes("UNIQUE constraint")) {
-    console.log("⚠ Sample data already exists");
-  } else {
-    console.error("✗ Error:", err.message);
-  }
-}
-
-closeConnection();

package/skills/consolelog/src/db/index.ts

@@ -1,44 +0,0 @@
-import postgres from "postgres";
-
-const config = {
-  host: process.env.DB_HOST || "localhost",
-  port: parseInt(process.env.DB_PORT || "5432"),
-  database: process.env.DB_NAME || "serviceconsolelog",
-  username: process.env.DB_USER || "postgres",
-  password: process.env.DB_PASSWORD || "",
-};
-
-// Connection options based on environment
-const isProduction = process.env.DB_HOST?.includes("rds.amazonaws.com");
-
-export const sql = postgres({
-  host: config.host,
-  port: config.port,
-  database: config.database,
-  username: config.username,
-  password: config.password,
-  ssl: isProduction ? "require" : false,
-  max: 10,
-  idle_timeout: 20,
-  connect_timeout: 10,
-});
-
-export function getDb() {
-  return sql;
-}
-
-export async function testConnection(): Promise<boolean> {
-  try {
-    await sql`SELECT 1`;
-    return true;
-  } catch (error) {
-    console.error("Database connection failed:", error);
-    return false;
-  }
-}
-
-export async function closeConnection(): Promise<void> {
-  await sql.end();
-}
-
-export { sql as db };

package/skills/consolelog/src/db/queries.ts

@@ -1,348 +0,0 @@
-import { sql } from "./index";
-import type {
-  App,
-  Page,
-  Scan,
-  ConsoleLog,
-  Screenshot,
-  CreateAppInput,
-  UpdateAppInput,
-  CreatePageInput,
-  CreateScanInput,
-  CreateConsoleLogInput,
-  CreateScreenshotInput,
-  LogFilter,
-  ScanFilter,
-} from "../lib/types";
-
-// ============ APPS ============
-
-export async function createApp(input: CreateAppInput): Promise<App> {
-  const result = await sql<App[]>`
-    INSERT INTO apps (name, port, base_url, description)
-    VALUES (${input.name}, ${input.port}, ${input.base_url}, ${input.description || null})
-    RETURNING *
-  `;
-  return result[0];
-}
-
-export async function getAppById(id: number): Promise<App | null> {
-  const result = await sql<App[]>`SELECT * FROM apps WHERE id = ${id}`;
-  return result[0] || null;
-}
-
-export async function getAppByName(name: string): Promise<App | null> {
-  const result = await sql<App[]>`SELECT * FROM apps WHERE name = ${name}`;
-  return result[0] || null;
-}
-
-export async function getAllApps(activeOnly = false): Promise<App[]> {
-  if (activeOnly) {
-    return sql<App[]>`SELECT * FROM apps WHERE active = true ORDER BY name`;
-  }
-  return sql<App[]>`SELECT * FROM apps ORDER BY name`;
-}
-
-export async function updateApp(id: number, input: UpdateAppInput): Promise<App | null> {
-  const result = await sql<App[]>`
-    UPDATE apps SET
-      name = COALESCE(${input.name}, name),
-      port = COALESCE(${input.port}, port),
-      base_url = COALESCE(${input.base_url}, base_url),
-      description = COALESCE(${input.description}, description),
-      active = COALESCE(${input.active}, active),
-      updated_at = CURRENT_TIMESTAMP
-    WHERE id = ${id}
-    RETURNING *
-  `;
-  return result[0] || null;
-}
-
-export async function deleteApp(id: number): Promise<boolean> {
-  const result = await sql`DELETE FROM apps WHERE id = ${id}`;
-  return result.count > 0;
-}
-
-// ============ PAGES ============
-
-export async function createPage(input: CreatePageInput): Promise<Page> {
-  const result = await sql<Page[]>`
-    INSERT INTO pages (app_id, path, name, wait_for, timeout)
-    VALUES (${input.app_id}, ${input.path}, ${input.name || null}, ${input.wait_for || null}, ${input.timeout || 30000})
-    RETURNING *
-  `;
-  return result[0];
-}
-
-export async function getPageById(id: number): Promise<Page | null> {
-  const result = await sql<Page[]>`SELECT * FROM pages WHERE id = ${id}`;
-  return result[0] || null;
-}
-
-export async function getPagesByAppId(appId: number, activeOnly = false): Promise<Page[]> {
-  if (activeOnly) {
-    return sql<Page[]>`SELECT * FROM pages WHERE app_id = ${appId} AND active = true ORDER BY path`;
-  }
-  return sql<Page[]>`SELECT * FROM pages WHERE app_id = ${appId} ORDER BY path`;
-}
-
-export async function getPageByAppAndPath(appId: number, path: string): Promise<Page | null> {
-  const result = await sql<Page[]>`SELECT * FROM pages WHERE app_id = ${appId} AND path = ${path}`;
-  return result[0] || null;
-}
-
-export async function deletePage(id: number): Promise<boolean> {
-  const result = await sql`DELETE FROM pages WHERE id = ${id}`;
-  return result.count > 0;
-}
-
-export async function updatePageActive(id: number, active: boolean): Promise<boolean> {
-  const result = await sql`UPDATE pages SET active = ${active} WHERE id = ${id}`;
-  return result.count > 0;
-}
-
-// ============ SCANS ============
-
-export async function createScan(input: CreateScanInput): Promise<Scan> {
-  const result = await sql<Scan[]>`
-    INSERT INTO scans (app_id)
-    VALUES (${input.app_id})
-    RETURNING *
-  `;
-  return result[0];
-}
-
-export async function getScanById(id: number): Promise<Scan | null> {
-  const result = await sql<Scan[]>`SELECT * FROM scans WHERE id = ${id}`;
-  return result[0] || null;
-}
-
-export async function getScans(filter: ScanFilter = {}): Promise<Scan[]> {
-  const conditions: string[] = [];
-
-  if (filter.app_id !== undefined) {
-    conditions.push(`app_id = ${filter.app_id}`);
-  }
-  if (filter.status !== undefined) {
-    conditions.push(`status = '${filter.status}'`);
-  }
-
-  const limit = filter.limit !== undefined ? filter.limit : 100;
-  const offset = filter.offset !== undefined ? filter.offset : 0;
-
-  if (conditions.length === 0) {
-    return sql<Scan[]>`SELECT * FROM scans ORDER BY started_at DESC LIMIT ${limit} OFFSET ${offset}`;
-  }
-
-  // Build dynamic query with conditions
-  if (filter.app_id !== undefined && filter.status !== undefined) {
-    return sql<Scan[]>`SELECT * FROM scans WHERE app_id = ${filter.app_id} AND status = ${filter.status} ORDER BY started_at DESC LIMIT ${limit} OFFSET ${offset}`;
-  } else if (filter.app_id !== undefined) {
-    return sql<Scan[]>`SELECT * FROM scans WHERE app_id = ${filter.app_id} ORDER BY started_at DESC LIMIT ${limit} OFFSET ${offset}`;
-  } else if (filter.status !== undefined) {
-    return sql<Scan[]>`SELECT * FROM scans WHERE status = ${filter.status} ORDER BY started_at DESC LIMIT ${limit} OFFSET ${offset}`;
-  }
-
-  return sql<Scan[]>`SELECT * FROM scans ORDER BY started_at DESC LIMIT ${limit} OFFSET ${offset}`;
-}
-
-export async function updateScan(
-  id: number,
-  updates: {
-    status?: "running" | "completed" | "failed";
-    pages_scanned?: number;
-    errors_found?: number;
-    completed_at?: string;
-  }
-): Promise<Scan | null> {
-  const result = await sql<Scan[]>`
-    UPDATE scans SET
-      status = COALESCE(${updates.status}, status),
-      pages_scanned = COALESCE(${updates.pages_scanned}, pages_scanned),
-      errors_found = COALESCE(${updates.errors_found}, errors_found),
-      completed_at = COALESCE(${updates.completed_at}, completed_at)
-    WHERE id = ${id}
-    RETURNING *
-  `;
-  return result[0] || null;
-}
-
-export async function getLastScanForApp(appId: number): Promise<Scan | null> {
-  const result = await sql<Scan[]>`
-    SELECT * FROM scans WHERE app_id = ${appId} ORDER BY started_at DESC LIMIT 1
-  `;
-  return result[0] || null;
-}
-
-// ============ CONSOLE LOGS ============
-
-export async function createConsoleLog(input: CreateConsoleLogInput): Promise<ConsoleLog> {
-  const result = await sql<ConsoleLog[]>`
-    INSERT INTO console_logs (scan_id, page_id, level, message, source_url, line_number, column_number, stack_trace)
-    VALUES (${input.scan_id}, ${input.page_id}, ${input.level}, ${input.message}, ${input.source_url || null}, ${input.line_number || null}, ${input.column_number || null}, ${input.stack_trace || null})
-    RETURNING *
-  `;
-  return result[0];
-}
-
-export async function createConsoleLogsBatch(inputs: CreateConsoleLogInput[]): Promise<number> {
-  if (inputs.length === 0) return 0;
-
-  let count = 0;
-  await sql.begin(async (sql) => {
-    for (const log of inputs) {
-      await sql`
-        INSERT INTO console_logs (scan_id, page_id, level, message, source_url, line_number, column_number, stack_trace)
-        VALUES (${log.scan_id}, ${log.page_id}, ${log.level}, ${log.message}, ${log.source_url || null}, ${log.line_number || null}, ${log.column_number || null}, ${log.stack_trace || null})
-      `;
-      count++;
-    }
-  });
-  return count;
-}
-
-export async function getConsoleLogById(id: number): Promise<ConsoleLog | null> {
-  const result = await sql<ConsoleLog[]>`SELECT * FROM console_logs WHERE id = ${id}`;
-  return result[0] || null;
-}
-
-export async function getConsoleLogs(filter: LogFilter = {}): Promise<ConsoleLog[]> {
-  const limit = filter.limit !== undefined ? filter.limit : 100;
-  const offset = filter.offset !== undefined ? filter.offset : 0;
-
-  // Handle app_id filter with join
-  if (filter.app_id !== undefined) {
-    if (filter.level !== undefined) {
-      return sql<ConsoleLog[]>`
-        SELECT console_logs.* FROM console_logs
-        JOIN scans ON console_logs.scan_id = scans.id
-        WHERE scans.app_id = ${filter.app_id} AND console_logs.level = ${filter.level}
-        ORDER BY console_logs.timestamp DESC
-        LIMIT ${limit} OFFSET ${offset}
-      `;
-    }
-    return sql<ConsoleLog[]>`
-      SELECT console_logs.* FROM console_logs
-      JOIN scans ON console_logs.scan_id = scans.id
-      WHERE scans.app_id = ${filter.app_id}
-      ORDER BY console_logs.timestamp DESC
-      LIMIT ${limit} OFFSET ${offset}
-    `;
-  }
-
-  // Handle other filters
-  if (filter.scan_id !== undefined && filter.level !== undefined) {
-    return sql<ConsoleLog[]>`
-      SELECT * FROM console_logs
-      WHERE scan_id = ${filter.scan_id} AND level = ${filter.level}
-      ORDER BY timestamp DESC
-      LIMIT ${limit} OFFSET ${offset}
-    `;
-  } else if (filter.scan_id !== undefined) {
-    return sql<ConsoleLog[]>`
-      SELECT * FROM console_logs
-      WHERE scan_id = ${filter.scan_id}
-      ORDER BY timestamp DESC
-      LIMIT ${limit} OFFSET ${offset}
-    `;
-  } else if (filter.level !== undefined) {
-    return sql<ConsoleLog[]>`
-      SELECT * FROM console_logs
-      WHERE level = ${filter.level}
-      ORDER BY timestamp DESC
-      LIMIT ${limit} OFFSET ${offset}
-    `;
-  }
-
-  return sql<ConsoleLog[]>`SELECT * FROM console_logs ORDER BY timestamp DESC LIMIT ${limit} OFFSET ${offset}`;
-}
-
-export async function countConsoleLogs(filter: LogFilter = {}): Promise<number> {
-  let result: { count: string }[];
-
-  if (filter.app_id !== undefined) {
-    if (filter.level !== undefined) {
-      result = await sql<{ count: string }[]>`
-        SELECT COUNT(*)::text as count FROM console_logs
-        JOIN scans ON console_logs.scan_id = scans.id
-        WHERE scans.app_id = ${filter.app_id} AND console_logs.level = ${filter.level}
-      `;
-    } else {
-      result = await sql<{ count: string }[]>`
-        SELECT COUNT(*)::text as count FROM console_logs
-        JOIN scans ON console_logs.scan_id = scans.id
-        WHERE scans.app_id = ${filter.app_id}
-      `;
-    }
-  } else if (filter.scan_id !== undefined) {
-    result = await sql<{ count: string }[]>`
-      SELECT COUNT(*)::text as count FROM console_logs WHERE scan_id = ${filter.scan_id}
-    `;
-  } else {
-    result = await sql<{ count: string }[]>`SELECT COUNT(*)::text as count FROM console_logs`;
-  }
-
-  return parseInt(result[0].count, 10);
-}
-
-export async function getLogsByLevel(scanId: number): Promise<Record<string, number>> {
-  const results = await sql<{ level: string; count: string }[]>`
-    SELECT level, COUNT(*)::text as count
-    FROM console_logs
-    WHERE scan_id = ${scanId}
-    GROUP BY level
-  `;
-
-  const counts: Record<string, number> = {
-    error: 0,
-    warn: 0,
-    info: 0,
-    log: 0,
-    debug: 0,
-  };
-
-  for (const row of results) {
-    counts[row.level] = parseInt(row.count, 10);
-  }
-
-  return counts;
-}
-
-// ============ SCREENSHOTS ============
-
-export async function createScreenshot(input: CreateScreenshotInput): Promise<Screenshot> {
-  const result = await sql<Screenshot[]>`
-    INSERT INTO screenshots (scan_id, page_id, filename, filepath)
-    VALUES (${input.scan_id}, ${input.page_id}, ${input.filename}, ${input.filepath})
-    RETURNING *
-  `;
-  return result[0];
-}
-
-export async function getScreenshotById(id: number): Promise<Screenshot | null> {
-  const result = await sql<Screenshot[]>`SELECT * FROM screenshots WHERE id = ${id}`;
-  return result[0] || null;
-}
-
-export async function getScreenshotsByScanId(scanId: number): Promise<Screenshot[]> {
-  return sql<Screenshot[]>`SELECT * FROM screenshots WHERE scan_id = ${scanId} ORDER BY created_at DESC`;
-}
-
-export async function getScreenshotsByPageId(pageId: number): Promise<Screenshot[]> {
-  return sql<Screenshot[]>`SELECT * FROM screenshots WHERE page_id = ${pageId} ORDER BY created_at DESC`;
-}
-
-export async function getLatestScreenshotForPage(scanId: number, pageId: number): Promise<Screenshot | null> {
-  const result = await sql<Screenshot[]>`
-    SELECT * FROM screenshots
-    WHERE scan_id = ${scanId} AND page_id = ${pageId}
-    ORDER BY created_at DESC
-    LIMIT 1
-  `;
-  return result[0] || null;
-}
-
-export async function deleteScreenshot(id: number): Promise<boolean> {
-  const result = await sql`DELETE FROM screenshots WHERE id = ${id}`;
-  return result.count > 0;
-}

package/skills/consolelog/src/db/schema.ts

@@ -1,93 +0,0 @@
-import { sql } from "./index";
-
-export async function createTables(): Promise<void> {
-  // Apps table
-  await sql`
-    CREATE TABLE IF NOT EXISTS apps (
-      id SERIAL PRIMARY KEY,
-      name TEXT NOT NULL UNIQUE,
-      port INTEGER NOT NULL,
-      base_url TEXT NOT NULL,
-      description TEXT,
-      active BOOLEAN DEFAULT true,
-      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-      updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-    )
-  `;
-
-  // Pages table
-  await sql`
-    CREATE TABLE IF NOT EXISTS pages (
-      id SERIAL PRIMARY KEY,
-      app_id INTEGER NOT NULL REFERENCES apps(id) ON DELETE CASCADE,
-      path TEXT NOT NULL,
-      name TEXT,
-      wait_for TEXT,
-      timeout INTEGER DEFAULT 30000,
-      active BOOLEAN DEFAULT true,
-      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-      UNIQUE(app_id, path)
-    )
-  `;
-
-  // Scans table
-  await sql`
-    CREATE TABLE IF NOT EXISTS scans (
-      id SERIAL PRIMARY KEY,
-      app_id INTEGER NOT NULL REFERENCES apps(id) ON DELETE CASCADE,
-      started_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-      completed_at TIMESTAMP,
-      status TEXT DEFAULT 'running',
-      pages_scanned INTEGER DEFAULT 0,
-      errors_found INTEGER DEFAULT 0
-    )
-  `;
-
-  // Console logs table
-  await sql`
-    CREATE TABLE IF NOT EXISTS console_logs (
-      id SERIAL PRIMARY KEY,
-      scan_id INTEGER NOT NULL REFERENCES scans(id) ON DELETE CASCADE,
-      page_id INTEGER NOT NULL REFERENCES pages(id) ON DELETE CASCADE,
-      level TEXT NOT NULL,
-      message TEXT NOT NULL,
-      source_url TEXT,
-      line_number INTEGER,
-      column_number INTEGER,
-      stack_trace TEXT,
-      timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-    )
-  `;
-
-  // Screenshots table
-  await sql`
-    CREATE TABLE IF NOT EXISTS screenshots (
-      id SERIAL PRIMARY KEY,
-      scan_id INTEGER NOT NULL REFERENCES scans(id) ON DELETE CASCADE,
-      page_id INTEGER NOT NULL REFERENCES pages(id) ON DELETE CASCADE,
-      filename TEXT NOT NULL,
-      filepath TEXT NOT NULL,
-      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-    )
-  `;
-
-  // Create indexes
-  await sql`CREATE INDEX IF NOT EXISTS idx_console_logs_scan ON console_logs(scan_id)`;
-  await sql`CREATE INDEX IF NOT EXISTS idx_console_logs_level ON console_logs(level)`;
-  await sql`CREATE INDEX IF NOT EXISTS idx_console_logs_timestamp ON console_logs(timestamp DESC)`;
-  await sql`CREATE INDEX IF NOT EXISTS idx_scans_app_id ON scans(app_id)`;
-  await sql`CREATE INDEX IF NOT EXISTS idx_pages_app_id ON pages(app_id)`;
-  await sql`CREATE INDEX IF NOT EXISTS idx_screenshots_scan_id ON screenshots(scan_id)`;
-  await sql`CREATE INDEX IF NOT EXISTS idx_screenshots_page_id ON screenshots(page_id)`;
-
-  console.log("Database tables created successfully");
-}
-
-export async function dropTables(): Promise<void> {
-  await sql`DROP TABLE IF EXISTS screenshots CASCADE`;
-  await sql`DROP TABLE IF EXISTS console_logs CASCADE`;
-  await sql`DROP TABLE IF EXISTS scans CASCADE`;
-  await sql`DROP TABLE IF EXISTS pages CASCADE`;
-  await sql`DROP TABLE IF EXISTS apps CASCADE`;
-  console.log("Database tables dropped");
-}

package/skills/consolelog/src/index.ts

@@ -1,3 +0,0 @@
-#!/usr/bin/env bun
-
-console.log("Usage: skills run consolelog -- <command> [options]");