@openqa/cli 1.0.13 → 1.1.1

package/dist/cli/index.js

@@ -1,1640 +1,750 @@
 #!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
-// cli/index.ts
-import { Command } from "commander";
-
-// agent/index.ts
-import { ReActAgent as ReActAgent2 } from "@orka-js/agent";
-import { OpenAIAdapter as OpenAIAdapter2 } from "@orka-js/openai";
-import { AnthropicAdapter as AnthropicAdapter2 } from "@orka-js/anthropic";
-import { SessionMemory } from "@orka-js/memory-store";
-import { Tracer } from "@orka-js/observability";
-import { EventEmitter as EventEmitter3 } from "events";
+// node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
 
 // database/index.ts
 import { Low } from "lowdb";
 import { JSONFile } from "lowdb/node";
 import { dirname } from "path";
-import { fileURLToPath } from "url";
+import { fileURLToPath as fileURLToPath2 } from "url";
 import { mkdirSync } from "fs";
-var __filename = fileURLToPath(import.meta.url);
-var __dirname = dirname(__filename);
-var OpenQADatabase = class {
-  constructor(dbPath = "./data/openqa.json") {
-    this.dbPath = dbPath;
-    this.initialize();
-  }
-  db = null;
-  initialize() {
-    const dir = dirname(this.dbPath);
-    mkdirSync(dir, { recursive: true });
-    const adapter = new JSONFile(this.dbPath);
-    this.db = new Low(adapter, {
-      config: {},
-      test_sessions: [],
-      actions: [],
-      bugs: [],
-      kanban_tickets: []
-    });
-    this.db.read();
-    if (!this.db.data) {
-      this.db.data = {
-        config: {},
-        test_sessions: [],
-        actions: [],
-        bugs: [],
-        kanban_tickets: []
-      };
-      this.db.write();
-    }
-  }
-  async ensureInitialized() {
-    if (!this.db) {
-      this.initialize();
-    }
-    await this.db.read();
-  }
-  async getConfig(key) {
-    await this.ensureInitialized();
-    return this.db.data.config[key] || null;
-  }
-  async setConfig(key, value) {
-    await this.ensureInitialized();
-    this.db.data.config[key] = value;
-    await this.db.write();
-  }
-  async getAllConfig() {
-    await this.ensureInitialized();
-    return this.db.data.config;
-  }
-  async createSession(id, metadata) {
-    await this.ensureInitialized();
-    const session = {
-      id,
-      started_at: (/* @__PURE__ */ new Date()).toISOString(),
-      status: "running",
-      total_actions: 0,
-      bugs_found: 0,
-      metadata: metadata ? JSON.stringify(metadata) : void 0
-    };
-    this.db.data.test_sessions.push(session);
-    await this.db.write();
-    return session;
-  }
-  async getSession(id) {
-    await this.ensureInitialized();
-    return this.db.data.test_sessions.find((s) => s.id === id) || null;
-  }
-  async updateSession(id, updates) {
-    await this.ensureInitialized();
-    const index = this.db.data.test_sessions.findIndex((s) => s.id === id);
-    if (index !== -1) {
-      this.db.data.test_sessions[index] = { ...this.db.data.test_sessions[index], ...updates };
-      await this.db.write();
-    }
-  }
-  async getRecentSessions(limit = 10) {
-    await this.ensureInitialized();
-    return this.db.data.test_sessions.sort((a, b) => new Date(b.started_at).getTime() - new Date(a.started_at).getTime()).slice(0, limit);
-  }
-  async createAction(action) {
-    await this.ensureInitialized();
-    const newAction = {
-      id: `action_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      ...action
-    };
-    this.db.data.actions.push(newAction);
-    await this.db.write();
-    return newAction;
-  }
-  async getSessionActions(sessionId) {
-    await this.ensureInitialized();
-    return this.db.data.actions.filter((a) => a.session_id === sessionId).sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
-  }
-  async createBug(bug) {
-    await this.ensureInitialized();
-    const newBug = {
-      id: `bug_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
-      created_at: (/* @__PURE__ */ new Date()).toISOString(),
-      updated_at: (/* @__PURE__ */ new Date()).toISOString(),
-      ...bug
-    };
-    this.db.data.bugs.push(newBug);
-    await this.db.write();
-    return newBug;
-  }
-  async updateBug(id, updates) {
-    await this.ensureInitialized();
-    const index = this.db.data.bugs.findIndex((b) => b.id === id);
-    if (index !== -1) {
-      this.db.data.bugs[index] = {
-        ...this.db.data.bugs[index],
-        ...updates,
-        updated_at: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      await this.db.write();
-    }
-  }
-  async getAllBugs() {
-    await this.ensureInitialized();
-    return this.db.data.bugs.sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime());
-  }
-  async getBugsByStatus(status) {
-    await this.ensureInitialized();
-    return this.db.data.bugs.filter((b) => b.status === status).sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime());
-  }
-  async createKanbanTicket(ticket) {
-    await this.ensureInitialized();
-    const newTicket = {
-      id: `ticket_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
-      created_at: (/* @__PURE__ */ new Date()).toISOString(),
-      updated_at: (/* @__PURE__ */ new Date()).toISOString(),
-      ...ticket
-    };
-    this.db.data.kanban_tickets.push(newTicket);
-    await this.db.write();
-    return newTicket;
-  }
-  async updateKanbanTicket(id, updates) {
-    await this.ensureInitialized();
-    const index = this.db.data.kanban_tickets.findIndex((t) => t.id === id);
-    if (index !== -1) {
-      this.db.data.kanban_tickets[index] = {
-        ...this.db.data.kanban_tickets[index],
-        ...updates,
-        updated_at: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      await this.db.write();
-    }
-  }
-  async getKanbanTickets() {
-    await this.ensureInitialized();
-    return this.db.data.kanban_tickets.sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime());
-  }
-  async getKanbanTicketsByColumn(column) {
-    await this.ensureInitialized();
-    return this.db.data.kanban_tickets.filter((t) => t.column === column).sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime());
-  }
-  async close() {
-  }
-};
-
-// agent/config/index.ts
-import { config as dotenvConfig } from "dotenv";
-dotenvConfig();
-var ConfigManager = class {
-  db = null;
-  envConfig;
-  constructor(dbPath) {
-    this.envConfig = this.loadFromEnv();
-  }
-  loadFromEnv() {
-    return {
-      llm: {
-        provider: process.env.LLM_PROVIDER || "openai",
-        apiKey: process.env.OPENAI_API_KEY || process.env.ANTHROPIC_API_KEY,
-        model: process.env.LLM_MODEL,
-        baseUrl: process.env.OLLAMA_BASE_URL
-      },
-      saas: {
-        url: process.env.SAAS_URL || "",
-        authType: process.env.SAAS_AUTH_TYPE || "none",
-        username: process.env.SAAS_USERNAME,
-        password: process.env.SAAS_PASSWORD
-      },
-      github: process.env.GITHUB_TOKEN ? {
-        token: process.env.GITHUB_TOKEN,
-        owner: process.env.GITHUB_OWNER || "",
-        repo: process.env.GITHUB_REPO || ""
-      } : void 0,
-      agent: {
-        intervalMs: parseInt(process.env.AGENT_INTERVAL_MS || "3600000"),
-        maxIterations: parseInt(process.env.AGENT_MAX_ITERATIONS || "20"),
-        autoStart: process.env.AGENT_AUTO_START === "true"
-      },
-      web: {
-        port: parseInt(process.env.WEB_PORT || "4242"),
-        host: process.env.WEB_HOST || "0.0.0.0"
-      },
-      database: {
-        path: process.env.DB_PATH || "./data/openqa.db"
-      },
-      notifications: {
-        slack: process.env.SLACK_WEBHOOK_URL,
-        discord: process.env.DISCORD_WEBHOOK_URL
+var __filename, __dirname, OpenQADatabase;
+var init_database = __esm({
+  "database/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    __filename = fileURLToPath2(import.meta.url);
+    __dirname = dirname(__filename);
+    OpenQADatabase = class {
+      constructor(dbPath = "./data/openqa.json") {
+        this.dbPath = dbPath;
+        this.initialize();
       }
-    };
-  }
-  getDB() {
-    if (!this.db) {
-      this.db = new OpenQADatabase("./data/openqa.json");
-    }
-    return this.db;
-  }
-  async get(key) {
-    const dbValue = await this.getDB().getConfig(key);
-    if (dbValue) return dbValue;
-    const keys = key.split(".");
-    let value = this.envConfig;
-    for (const k of keys) {
-      value = value?.[k];
-    }
-    return value?.toString() || null;
-  }
-  async set(key, value) {
-    await this.getDB().setConfig(key, value);
-  }
-  async getAll() {
-    const dbConfig = await this.getDB().getAllConfig();
-    const merged = { ...this.envConfig };
-    for (const [key, value] of Object.entries(dbConfig)) {
-      const keys = key.split(".");
-      let obj = merged;
-      for (let i = 0; i < keys.length - 1; i++) {
-        if (!obj[keys[i]]) obj[keys[i]] = {};
-        obj = obj[keys[i]];
-      }
-      obj[keys[keys.length - 1]] = value;
-    }
-    return merged;
-  }
-  async getConfig() {
-    return await this.getAll();
-  }
-  // Synchronous version that only uses env vars (no DB)
-  getConfigSync() {
-    return this.envConfig;
-  }
-};
-
-// agent/tools/browser.ts
-import { chromium } from "playwright";
-import { mkdirSync as mkdirSync2 } from "fs";
-import { join as join2 } from "path";
-var BrowserTools = class {
-  browser = null;
-  page = null;
-  db;
-  sessionId;
-  screenshotDir = "./data/screenshots";
-  constructor(db, sessionId) {
-    this.db = db;
-    this.sessionId = sessionId;
-    mkdirSync2(this.screenshotDir, { recursive: true });
-  }
-  async initialize() {
-    this.browser = await chromium.launch({ headless: true });
-    const context = await this.browser.newContext({
-      viewport: { width: 1920, height: 1080 },
-      userAgent: "OpenQA/1.0 (Automated Testing Agent)"
-    });
-    this.page = await context.newPage();
-  }
-  getTools() {
-    return [
-      {
-        name: "navigate_to_page",
-        description: "Navigate to a specific URL in the application",
-        parameters: {
-          type: "object",
-          properties: {
-            url: { type: "string", description: "The URL to navigate to" }
-          },
-          required: ["url"]
-        },
-        execute: async ({ url }) => {
-          if (!this.page) await this.initialize();
-          try {
-            await this.page.goto(url, { waitUntil: "networkidle" });
-            const title = await this.page.title();
-            this.db.createAction({
-              session_id: this.sessionId,
-              type: "navigate",
-              description: `Navigated to ${url}`,
-              input: url,
-              output: `Page title: ${title}`
-            });
-            return `Successfully navigated to ${url}. Page title: "${title}"`;
-          } catch (error) {
-            return `Failed to navigate: ${error.message}`;
-          }
-        }
-      },
-      {
-        name: "click_element",
-        description: "Click on an element using a CSS selector",
-        parameters: {
-          type: "object",
-          properties: {
-            selector: { type: "string", description: "CSS selector of the element to click" }
-          },
-          required: ["selector"]
-        },
-        execute: async ({ selector }) => {
-          if (!this.page) return "Browser not initialized. Navigate to a page first.";
-          try {
-            await this.page.click(selector, { timeout: 5e3 });
-            this.db.createAction({
-              session_id: this.sessionId,
-              type: "click",
-              description: `Clicked element: ${selector}`,
-              input: selector
-            });
-            return `Successfully clicked element: ${selector}`;
-          } catch (error) {
-            return `Failed to click element: ${error.message}`;
-          }
-        }
-      },
-      {
-        name: "fill_input",
-        description: "Fill an input field with text",
-        parameters: {
-          type: "object",
-          properties: {
-            selector: { type: "string", description: "CSS selector of the input field" },
-            text: { type: "string", description: "Text to fill in the input" }
-          },
-          required: ["selector", "text"]
-        },
-        execute: async ({ selector, text }) => {
-          if (!this.page) return "Browser not initialized. Navigate to a page first.";
-          try {
-            await this.page.fill(selector, text);
-            this.db.createAction({
-              session_id: this.sessionId,
-              type: "fill",
-              description: `Filled input ${selector}`,
-              input: `${selector} = ${text}`
-            });
-            return `Successfully filled input ${selector} with text`;
-          } catch (error) {
-            return `Failed to fill input: ${error.message}`;
-          }
-        }
-      },
-      {
-        name: "take_screenshot",
-        description: "Take a screenshot of the current page for evidence",
-        parameters: {
-          type: "object",
-          properties: {
-            name: { type: "string", description: "Name for the screenshot file" }
-          },
-          required: ["name"]
-        },
-        execute: async ({ name }) => {
-          if (!this.page) return "Browser not initialized. Navigate to a page first.";
-          try {
-            const filename = `${Date.now()}_${name}.png`;
-            const path = join2(this.screenshotDir, filename);
-            await this.page.screenshot({ path, fullPage: true });
-            this.db.createAction({
-              session_id: this.sessionId,
-              type: "screenshot",
-              description: `Screenshot: ${name}`,
-              screenshot_path: path
-            });
-            return `Screenshot saved: ${path}`;
-          } catch (error) {
-            return `Failed to take screenshot: ${error.message}`;
-          }
-        }
-      },
-      {
-        name: "get_page_content",
-        description: "Get the text content of the current page",
-        parameters: {
-          type: "object",
-          properties: {}
-        },
-        execute: async () => {
-          if (!this.page) return "Browser not initialized. Navigate to a page first.";
-          try {
-            const content = await this.page.textContent("body");
-            return content?.slice(0, 1e3) || "No content found";
-          } catch (error) {
-            return `Failed to get content: ${error.message}`;
-          }
-        }
-      },
-      {
-        name: "check_console_errors",
-        description: "Check for JavaScript console errors on the page",
-        parameters: {
-          type: "object",
-          properties: {}
-        },
-        execute: async () => {
-          if (!this.page) return "Browser not initialized. Navigate to a page first.";
-          const errors = [];
-          this.page.on("console", (msg) => {
-            if (msg.type() === "error") {
-              errors.push(msg.text());
-            }
-          });
-          await this.page.waitForTimeout(2e3);
-          if (errors.length > 0) {
-            return `Found ${errors.length} console errors:
-${errors.join("\n")}`;
-          }
-          return "No console errors detected";
+      db = null;
+      initialize() {
+        const dir = dirname(this.dbPath);
+        mkdirSync(dir, { recursive: true });
+        const adapter = new JSONFile(this.dbPath);
+        this.db = new Low(adapter, {
+          config: {},
+          test_sessions: [],
+          actions: [],
+          bugs: [],
+          kanban_tickets: []
+        });
+        this.db.read();
+        if (!this.db.data) {
+          this.db.data = {
+            config: {},
+            test_sessions: [],
+            actions: [],
+            bugs: [],
+            kanban_tickets: []
+          };
+          this.db.write();
         }
       }
-    ];
-  }
-  async close() {
-    if (this.browser) {
-      await this.browser.close();
-      this.browser = null;
-      this.page = null;
-    }
-  }
-};
-
-// agent/tools/github.ts
-import { Octokit } from "@octokit/rest";
-var GitHubTools = class {
-  octokit = null;
-  db;
-  sessionId;
-  config;
-  constructor(db, sessionId, config) {
-    this.db = db;
-    this.sessionId = sessionId;
-    this.config = config;
-    if (config.token) {
-      this.octokit = new Octokit({ auth: config.token });
-    }
-  }
-  getTools() {
-    return [
-      {
-        name: "create_github_issue",
-        description: "Create a GitHub issue when a critical bug is found. Use this for bugs that require developer attention.",
-        parameters: {
-          type: "object",
-          properties: {
-            title: { type: "string", description: "Issue title (concise and descriptive)" },
-            body: { type: "string", description: "Detailed description with steps to reproduce" },
-            severity: { type: "string", enum: ["low", "medium", "high", "critical"], description: "Bug severity" },
-            labels: { type: "array", items: { type: "string" }, description: "Labels for the issue" },
-            screenshot_path: { type: "string", description: "Path to screenshot evidence" }
-          },
-          required: ["title", "body", "severity"]
-        },
-        execute: async ({ title, body, severity, labels = [], screenshot_path }) => {
-          if (!this.octokit || !this.config.owner || !this.config.repo) {
-            return "GitHub not configured. Please set GITHUB_TOKEN, GITHUB_OWNER, and GITHUB_REPO.";
-          }
-          try {
-            const severityLabel = `severity: ${severity}`;
-            const allLabels = ["automated-qa", severityLabel, ...labels];
-            const issueBody = `## \u{1F916} Automated QA Report
-
-${body}
-
----
-
-**Severity:** ${severity.toUpperCase()}
-**Detected by:** OpenQA Agent
-**Session ID:** ${this.sessionId}
-${screenshot_path ? `**Screenshot:** ${screenshot_path}` : ""}
-
-*This issue was automatically created by OpenQA during automated testing.*`;
-            const issue = await this.octokit.rest.issues.create({
-              owner: this.config.owner,
-              repo: this.config.repo,
-              title: `[QA] ${title}`,
-              body: issueBody,
-              labels: allLabels
-            });
-            this.db.createAction({
-              session_id: this.sessionId,
-              type: "github_issue",
-              description: `Created GitHub issue: ${title}`,
-              input: JSON.stringify({ title, severity }),
-              output: issue.data.html_url
-            });
-            const bug = this.db.createBug({
-              session_id: this.sessionId,
-              title,
-              description: body,
-              severity,
-              status: "open",
-              github_issue_url: issue.data.html_url,
-              screenshot_path
-            });
-            return `\u2705 GitHub issue created successfully!
-URL: ${issue.data.html_url}
-Issue #${issue.data.number}`;
-          } catch (error) {
-            return `\u274C Failed to create GitHub issue: ${error.message}`;
-          }
+      async ensureInitialized() {
+        if (!this.db) {
+          this.initialize();
         }
+        await this.db.read();
       }
-    ];
-  }
-};
-
-// agent/tools/kanban.ts
-var KanbanTools = class {
-  db;
-  sessionId;
-  constructor(db, sessionId) {
-    this.db = db;
-    this.sessionId = sessionId;
-  }
-  getTools() {
-    return [
-      {
-        name: "create_kanban_ticket",
-        description: "Create a ticket on the internal Kanban board for QA tracking. Use this for bugs, improvements, or test findings.",
-        parameters: {
-          type: "object",
-          properties: {
-            title: { type: "string", description: "Ticket title" },
-            description: { type: "string", description: "Detailed description" },
-            priority: { type: "string", enum: ["low", "medium", "high", "critical"], description: "Ticket priority" },
-            column: { type: "string", enum: ["backlog", "to-do", "in-progress", "done"], description: "Kanban column" },
-            tags: { type: "array", items: { type: "string" }, description: "Tags for categorization" },
-            screenshot_path: { type: "string", description: "Path to screenshot evidence" }
-          },
-          required: ["title", "description", "priority"]
-        },
-        execute: async ({ title, description, priority, column = "to-do", tags = [], screenshot_path }) => {
-          try {
-            const allTags = ["automated-qa", ...tags];
-            const ticket = this.db.createKanbanTicket({
-              title,
-              description,
-              priority,
-              column,
-              tags: JSON.stringify(allTags),
-              screenshot_url: screenshot_path
-            });
-            this.db.createAction({
-              session_id: this.sessionId,
-              type: "kanban_ticket",
-              description: `Created Kanban ticket: ${title}`,
-              input: JSON.stringify({ title, priority, column }),
-              output: ticket.id
-            });
-            return `\u2705 Kanban ticket created successfully!
-ID: ${ticket.id}
-Column: ${column}
-Priority: ${priority}`;
-          } catch (error) {
-            return `\u274C Failed to create Kanban ticket: ${error.message}`;
-          }
-        }
-      },
-      {
-        name: "update_kanban_ticket",
-        description: "Update an existing Kanban ticket (move columns, change priority, etc.)",
-        parameters: {
-          type: "object",
-          properties: {
-            ticket_id: { type: "string", description: "ID of the ticket to update" },
-            column: { type: "string", enum: ["backlog", "to-do", "in-progress", "done"], description: "New column" },
-            priority: { type: "string", enum: ["low", "medium", "high", "critical"], description: "New priority" }
-          },
-          required: ["ticket_id"]
-        },
-        execute: async ({ ticket_id, column, priority }) => {
-          try {
-            const updates = {};
-            if (column) updates.column = column;
-            if (priority) updates.priority = priority;
-            this.db.updateKanbanTicket(ticket_id, updates);
-            return `\u2705 Kanban ticket ${ticket_id} updated successfully!`;
-          } catch (error) {
-            return `\u274C Failed to update Kanban ticket: ${error.message}`;
-          }
-        }
-      },
-      {
-        name: "get_kanban_board",
-        description: "Get all tickets from the Kanban board to see current status",
-        parameters: {
-          type: "object",
-          properties: {}
-        },
-        execute: async () => {
-          try {
-            const tickets = this.db.getKanbanTickets();
-            const byColumn = {
-              backlog: tickets.filter((t) => t.column === "backlog"),
-              "to-do": tickets.filter((t) => t.column === "to-do"),
-              "in-progress": tickets.filter((t) => t.column === "in-progress"),
-              done: tickets.filter((t) => t.column === "done")
-            };
-            const summary = `
-\u{1F4CA} Kanban Board Status:
-- Backlog: ${byColumn.backlog.length} tickets
-- To Do: ${byColumn["to-do"].length} tickets
-- In Progress: ${byColumn["in-progress"].length} tickets
-- Done: ${byColumn.done.length} tickets
-
-Total: ${tickets.length} tickets
-            `.trim();
-            return summary;
-          } catch (error) {
-            return `\u274C Failed to get Kanban board: ${error.message}`;
-          }
+      async getConfig(key) {
+        await this.ensureInitialized();
+        return this.db.data.config[key] || null;
+      }
+      async setConfig(key, value) {
+        await this.ensureInitialized();
+        this.db.data.config[key] = value;
+        await this.db.write();
+      }
+      async getAllConfig() {
+        await this.ensureInitialized();
+        return this.db.data.config;
+      }
+      async createSession(id, metadata) {
+        await this.ensureInitialized();
+        const session = {
+          id,
+          started_at: (/* @__PURE__ */ new Date()).toISOString(),
+          status: "running",
+          total_actions: 0,
+          bugs_found: 0,
+          metadata: metadata ? JSON.stringify(metadata) : void 0
+        };
+        this.db.data.test_sessions.push(session);
+        await this.db.write();
+        return session;
+      }
+      async getSession(id) {
+        await this.ensureInitialized();
+        return this.db.data.test_sessions.find((s) => s.id === id) || null;
+      }
+      async updateSession(id, updates) {
+        await this.ensureInitialized();
+        const index = this.db.data.test_sessions.findIndex((s) => s.id === id);
+        if (index !== -1) {
+          this.db.data.test_sessions[index] = { ...this.db.data.test_sessions[index], ...updates };
+          await this.db.write();
         }
       }
-    ];
-  }
-};
-
-// agent/webhooks/git-listener.ts
-import { EventEmitter } from "events";
-import { Octokit as Octokit2 } from "@octokit/rest";
-var GitListener = class extends EventEmitter {
-  config;
-  octokit = null;
-  lastCommitSha = null;
-  lastPipelineId = null;
-  pollInterval = null;
-  isRunning = false;
-  constructor(config) {
-    super();
-    this.config = {
-      branch: "main",
-      pollIntervalMs: 6e4,
-      gitlabUrl: "https://gitlab.com",
-      ...config
-    };
-    if (config.provider === "github" && config.token) {
-      this.octokit = new Octokit2({ auth: config.token });
-    }
-  }
-  async start() {
-    if (this.isRunning) return;
-    this.isRunning = true;
-    console.log(`\u{1F517} GitListener started for ${this.config.provider}/${this.config.owner}/${this.config.repo}`);
-    await this.checkInitialState();
-    this.pollInterval = setInterval(() => {
-      this.poll().catch(console.error);
-    }, this.config.pollIntervalMs);
-  }
-  stop() {
-    this.isRunning = false;
-    if (this.pollInterval) {
-      clearInterval(this.pollInterval);
-      this.pollInterval = null;
-    }
-    console.log("\u{1F517} GitListener stopped");
-  }
-  async checkInitialState() {
-    try {
-      if (this.config.provider === "github") {
-        await this.checkGitHubState();
-      } else {
-        await this.checkGitLabState();
+      async getRecentSessions(limit = 10) {
+        await this.ensureInitialized();
+        return this.db.data.test_sessions.sort((a, b) => new Date(b.started_at).getTime() - new Date(a.started_at).getTime()).slice(0, limit);
       }
-    } catch (error) {
-      console.error("Failed to check initial state:", error);
-    }
-  }
-  async poll() {
-    try {
-      if (this.config.provider === "github") {
-        await this.pollGitHub();
-      } else {
-        await this.pollGitLab();
+      async createAction(action) {
+        await this.ensureInitialized();
+        const newAction = {
+          id: `action_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          ...action
+        };
+        this.db.data.actions.push(newAction);
+        await this.db.write();
+        return newAction;
       }
-    } catch (error) {
-      console.error("Poll error:", error);
-    }
-  }
-  async checkGitHubState() {
-    if (!this.octokit) return;
-    const { data: commits } = await this.octokit.repos.listCommits({
-      owner: this.config.owner,
-      repo: this.config.repo,
-      sha: this.config.branch,
-      per_page: 1
-    });
-    if (commits.length > 0) {
-      this.lastCommitSha = commits[0].sha;
-    }
-    try {
-      const { data: runs } = await this.octokit.actions.listWorkflowRunsForRepo({
-        owner: this.config.owner,
-        repo: this.config.repo,
-        branch: this.config.branch,
-        per_page: 1
-      });
-      if (runs.workflow_runs.length > 0) {
-        this.lastPipelineId = runs.workflow_runs[0].id.toString();
+      async getSessionActions(sessionId) {
+        await this.ensureInitialized();
+        return this.db.data.actions.filter((a) => a.session_id === sessionId).sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
       }
-    } catch {
-    }
-  }
-  async pollGitHub() {
-    if (!this.octokit) return;
-    const { data: commits } = await this.octokit.repos.listCommits({
-      owner: this.config.owner,
-      repo: this.config.repo,
-      sha: this.config.branch,
-      per_page: 5
-    });
-    for (const commit of commits) {
-      if (this.lastCommitSha && commit.sha === this.lastCommitSha) break;
-      const isMerge = commit.parents && commit.parents.length > 1;
-      const event = {
-        type: isMerge ? "merge" : "push",
-        provider: "github",
-        branch: this.config.branch,
-        commit: commit.sha,
-        author: commit.commit.author?.name || "unknown",
-        message: commit.commit.message,
-        timestamp: new Date(commit.commit.author?.date || Date.now())
-      };
-      this.emit("git-event", event);
-      if (isMerge) {
-        this.emit("merge", event);
-        console.log(`\u{1F500} Merge detected on ${this.config.branch}: ${commit.sha.slice(0, 7)}`);
+      async createBug(bug) {
+        await this.ensureInitialized();
+        const newBug = {
+          id: `bug_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+          created_at: (/* @__PURE__ */ new Date()).toISOString(),
+          updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+          ...bug
+        };
+        this.db.data.bugs.push(newBug);
+        await this.db.write();
+        return newBug;
       }
-    }
-    if (commits.length > 0) {
-      this.lastCommitSha = commits[0].sha;
-    }
-    try {
-      const { data: runs } = await this.octokit.actions.listWorkflowRunsForRepo({
-        owner: this.config.owner,
-        repo: this.config.repo,
-        branch: this.config.branch,
-        per_page: 5
-      });
-      for (const run of runs.workflow_runs) {
-        if (this.lastPipelineId && run.id.toString() === this.lastPipelineId) break;
-        if (run.status === "completed") {
-          const event = {
-            type: run.conclusion === "success" ? "pipeline_success" : "pipeline_failure",
-            provider: "github",
-            branch: this.config.branch,
-            commit: run.head_sha,
-            author: run.actor?.login || "unknown",
-            message: run.name || "",
-            timestamp: new Date(run.updated_at || Date.now()),
-            pipelineId: run.id.toString(),
-            pipelineStatus: run.conclusion || void 0
+      async updateBug(id, updates) {
+        await this.ensureInitialized();
+        const index = this.db.data.bugs.findIndex((b) => b.id === id);
+        if (index !== -1) {
+          this.db.data.bugs[index] = {
+            ...this.db.data.bugs[index],
+            ...updates,
+            updated_at: (/* @__PURE__ */ new Date()).toISOString()
           };
-          this.emit("git-event", event);
-          if (run.conclusion === "success") {
-            this.emit("pipeline-success", event);
-            console.log(`\u2705 Pipeline success: ${run.name} (${run.id})`);
-          } else {
-            this.emit("pipeline-failure", event);
-            console.log(`\u274C Pipeline failure: ${run.name} (${run.id})`);
-          }
+          await this.db.write();
         }
       }
-      if (runs.workflow_runs.length > 0) {
-        this.lastPipelineId = runs.workflow_runs[0].id.toString();
+      async getAllBugs() {
+        await this.ensureInitialized();
+        return this.db.data.bugs.sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime());
       }
-    } catch {
-    }
-  }
-  async checkGitLabState() {
-    const headers = { "PRIVATE-TOKEN": this.config.token };
-    const projectPath = encodeURIComponent(`${this.config.owner}/${this.config.repo}`);
-    const baseUrl = this.config.gitlabUrl;
-    try {
-      const commitsRes = await fetch(
-        `${baseUrl}/api/v4/projects/${projectPath}/repository/commits?ref_name=${this.config.branch}&per_page=1`,
-        { headers }
-      );
-      const commits = await commitsRes.json();
-      if (commits.length > 0) {
-        this.lastCommitSha = commits[0].id;
+      async getBugsByStatus(status) {
+        await this.ensureInitialized();
+        return this.db.data.bugs.filter((b) => b.status === status).sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime());
       }
-      const pipelinesRes = await fetch(
-        `${baseUrl}/api/v4/projects/${projectPath}/pipelines?ref=${this.config.branch}&per_page=1`,
-        { headers }
-      );
-      const pipelines = await pipelinesRes.json();
-      if (pipelines.length > 0) {
-        this.lastPipelineId = pipelines[0].id.toString();
+      async createKanbanTicket(ticket) {
+        await this.ensureInitialized();
+        const newTicket = {
+          id: `ticket_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+          created_at: (/* @__PURE__ */ new Date()).toISOString(),
+          updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+          ...ticket
+        };
+        this.db.data.kanban_tickets.push(newTicket);
+        await this.db.write();
+        return newTicket;
       }
-    } catch (error) {
-      console.error("GitLab initial state error:", error);
-    }
+      async updateKanbanTicket(id, updates) {
+        await this.ensureInitialized();
+        const index = this.db.data.kanban_tickets.findIndex((t) => t.id === id);
+        if (index !== -1) {
+          this.db.data.kanban_tickets[index] = {
+            ...this.db.data.kanban_tickets[index],
+            ...updates,
+            updated_at: (/* @__PURE__ */ new Date()).toISOString()
+          };
+          await this.db.write();
+        }
+      }
+      async getKanbanTickets() {
+        await this.ensureInitialized();
+        return this.db.data.kanban_tickets.sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime());
+      }
+      async getKanbanTicketsByColumn(column) {
+        await this.ensureInitialized();
+        return this.db.data.kanban_tickets.filter((t) => t.column === column).sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime());
+      }
+      async clearAllConfig() {
+        await this.ensureInitialized();
+        this.db.data.config = {};
+        await this.db.write();
+      }
+      async close() {
+      }
+    };
   }
-  async pollGitLab() {
-    const headers = { "PRIVATE-TOKEN": this.config.token };
-    const projectPath = encodeURIComponent(`${this.config.owner}/${this.config.repo}`);
-    const baseUrl = this.config.gitlabUrl;
-    try {
-      const commitsRes = await fetch(
-        `${baseUrl}/api/v4/projects/${projectPath}/repository/commits?ref_name=${this.config.branch}&per_page=5`,
-        { headers }
-      );
-      const commits = await commitsRes.json();
-      for (const commit of commits) {
-        if (this.lastCommitSha && commit.id === this.lastCommitSha) break;
-        const isMerge = commit.parent_ids && commit.parent_ids.length > 1;
-        const event = {
-          type: isMerge ? "merge" : "push",
-          provider: "gitlab",
-          branch: this.config.branch,
-          commit: commit.id,
-          author: commit.author_name,
-          message: commit.message,
-          timestamp: new Date(commit.created_at)
+});
+
+// agent/config/index.ts
+import { config as dotenvConfig } from "dotenv";
+var ConfigManager;
+var init_config = __esm({
+  "agent/config/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_database();
+    dotenvConfig();
+    ConfigManager = class {
+      db = null;
+      envConfig;
+      constructor(dbPath) {
+        this.envConfig = this.loadFromEnv();
+      }
+      loadFromEnv() {
+        return {
+          llm: {
+            provider: process.env.LLM_PROVIDER || "openai",
+            apiKey: process.env.OPENAI_API_KEY || process.env.ANTHROPIC_API_KEY,
+            model: process.env.LLM_MODEL,
+            baseUrl: process.env.OLLAMA_BASE_URL
+          },
+          saas: {
+            url: process.env.SAAS_URL || "",
+            authType: process.env.SAAS_AUTH_TYPE || "none",
+            username: process.env.SAAS_USERNAME,
+            password: process.env.SAAS_PASSWORD
+          },
+          github: process.env.GITHUB_TOKEN ? {
+            token: process.env.GITHUB_TOKEN,
+            owner: process.env.GITHUB_OWNER || "",
+            repo: process.env.GITHUB_REPO || ""
+          } : void 0,
+          agent: {
+            intervalMs: parseInt(process.env.AGENT_INTERVAL_MS || "3600000"),
+            maxIterations: parseInt(process.env.AGENT_MAX_ITERATIONS || "20"),
+            autoStart: process.env.AGENT_AUTO_START === "true"
+          },
+          web: {
+            port: parseInt(process.env.WEB_PORT || "4242"),
+            host: process.env.WEB_HOST || "0.0.0.0"
+          },
+          database: {
+            path: process.env.DB_PATH || "./data/openqa.db"
+          },
+          notifications: {
+            slack: process.env.SLACK_WEBHOOK_URL,
+            discord: process.env.DISCORD_WEBHOOK_URL
+          }
         };
-        this.emit("git-event", event);
-        if (isMerge) {
-          this.emit("merge", event);
-          console.log(`\u{1F500} Merge detected on ${this.config.branch}: ${commit.id.slice(0, 7)}`);
+      }
+      getDB() {
+        if (!this.db) {
+          this.db = new OpenQADatabase("./data/openqa.json");
         }
+        return this.db;
       }
-      if (commits.length > 0) {
-        this.lastCommitSha = commits[0].id;
+      async get(key) {
+        const dbValue = await this.getDB().getConfig(key);
+        if (dbValue) return dbValue;
+        const keys = key.split(".");
+        let value = this.envConfig;
+        for (const k of keys) {
+          value = value?.[k];
+        }
+        return value?.toString() || null;
       }
-      const pipelinesRes = await fetch(
-        `${baseUrl}/api/v4/projects/${projectPath}/pipelines?ref=${this.config.branch}&per_page=5`,
-        { headers }
-      );
-      const pipelines = await pipelinesRes.json();
-      for (const pipeline of pipelines) {
-        if (this.lastPipelineId && pipeline.id.toString() === this.lastPipelineId) break;
-        if (pipeline.status === "success" || pipeline.status === "failed") {
-          const event = {
-            type: pipeline.status === "success" ? "pipeline_success" : "pipeline_failure",
-            provider: "gitlab",
-            branch: this.config.branch,
-            commit: pipeline.sha,
-            author: pipeline.user?.name || "unknown",
-            message: `Pipeline #${pipeline.id}`,
-            timestamp: new Date(pipeline.updated_at),
-            pipelineId: pipeline.id.toString(),
-            pipelineStatus: pipeline.status
-          };
-          this.emit("git-event", event);
-          if (pipeline.status === "success") {
-            this.emit("pipeline-success", event);
-            console.log(`\u2705 Pipeline success: #${pipeline.id}`);
-          } else {
-            this.emit("pipeline-failure", event);
-            console.log(`\u274C Pipeline failure: #${pipeline.id}`);
+      async set(key, value) {
+        await this.getDB().setConfig(key, value);
+      }
+      async getAll() {
+        const dbConfig = await this.getDB().getAllConfig();
+        const merged = { ...this.envConfig };
+        for (const [key, value] of Object.entries(dbConfig)) {
+          const keys = key.split(".");
+          let obj = merged;
+          for (let i = 0; i < keys.length - 1; i++) {
+            if (!obj[keys[i]]) obj[keys[i]] = {};
+            obj = obj[keys[i]];
           }
+          obj[keys[keys.length - 1]] = value;
         }
+        return merged;
       }
-      if (pipelines.length > 0) {
-        this.lastPipelineId = pipelines[0].id.toString();
+      async getConfig() {
+        return await this.getAll();
       }
-    } catch (error) {
-      console.error("GitLab poll error:", error);
-    }
-  }
-  async setupWebhook(webhookUrl) {
-    if (this.config.provider === "github") {
-      return this.setupGitHubWebhook(webhookUrl);
-    } else {
-      return this.setupGitLabWebhook(webhookUrl);
-    }
-  }
-  async setupGitHubWebhook(webhookUrl) {
-    if (!this.octokit) throw new Error("GitHub not configured");
-    const { data } = await this.octokit.repos.createWebhook({
-      owner: this.config.owner,
-      repo: this.config.repo,
-      config: {
-        url: webhookUrl,
-        content_type: "json"
-      },
-      events: ["push", "pull_request", "workflow_run"]
-    });
-    return data.id.toString();
-  }
-  async setupGitLabWebhook(webhookUrl) {
-    const headers = {
-      "PRIVATE-TOKEN": this.config.token,
-      "Content-Type": "application/json"
-    };
-    const projectPath = encodeURIComponent(`${this.config.owner}/${this.config.repo}`);
-    const res = await fetch(
-      `${this.config.gitlabUrl}/api/v4/projects/${projectPath}/hooks`,
-      {
-        method: "POST",
-        headers,
-        body: JSON.stringify({
-          url: webhookUrl,
-          push_events: true,
-          merge_requests_events: true,
-          pipeline_events: true
-        })
+      // Synchronous version that only uses env vars (no DB)
+      getConfigSync() {
+        return this.envConfig;
       }
-    );
-    const data = await res.json();
-    return data.id.toString();
-  }
-};
-
-// agent/specialists/index.ts
-import { ReActAgent } from "@orka-js/agent";
-import { OpenAIAdapter } from "@orka-js/openai";
-import { AnthropicAdapter } from "@orka-js/anthropic";
-import { EventEmitter as EventEmitter2 } from "events";
-var SPECIALIST_PROMPTS = {
-  "form-tester": `You are a Form Testing Specialist. Your mission:
-- Find all forms on the page (login, signup, contact, search, etc.)
-- Test form validation (empty fields, invalid formats, boundary values)
-- Test error messages and user feedback
-- Test form submission success/failure scenarios
-- Check for proper field types (email, password, phone)
-- Test autofill behavior
-- Report any form-related bugs with clear reproduction steps`,
-  "security-scanner": `You are a Security Scanner Specialist. Your mission:
-- Identify potential security vulnerabilities
-- Check for exposed sensitive data in page source
-- Look for insecure HTTP resources on HTTPS pages
-- Check for missing security headers
-- Identify potential CSRF vulnerabilities
-- Check for information disclosure in error messages
-- Look for hardcoded credentials or API keys
-- Report security issues with severity ratings`,
-  "sql-injection": `You are a SQL Injection Testing Specialist. Your mission:
-- Identify input fields that might interact with databases
-- Test common SQL injection payloads (', ", --, ;, OR 1=1, etc.)
-- Test for blind SQL injection (time-based, boolean-based)
-- Check URL parameters for injection vulnerabilities
-- Test search fields, login forms, and filters
-- Document any successful injections with exact payloads
-- Rate severity based on data exposure risk`,
-  "xss-tester": `You are an XSS (Cross-Site Scripting) Testing Specialist. Your mission:
-- Find all user input fields that reflect content
-- Test for reflected XSS (<script>, onerror, onload, etc.)
-- Test for stored XSS in comments, profiles, messages
-- Check for DOM-based XSS vulnerabilities
-- Test various encoding bypasses
-- Check if Content-Security-Policy is properly configured
-- Document successful XSS with exact payloads`,
-  "component-tester": `You are a UI Component Testing Specialist. Your mission:
-- Test all interactive components (buttons, dropdowns, modals, tabs)
-- Verify component states (hover, active, disabled, loading)
-- Test responsive behavior at different viewport sizes
-- Check for broken layouts or overlapping elements
-- Test keyboard navigation and focus management
-- Verify animations and transitions work correctly
-- Report visual bugs with screenshots`,
-  "accessibility-tester": `You are an Accessibility Testing Specialist. Your mission:
-- Check for proper ARIA labels and roles
-- Verify keyboard navigation works for all interactive elements
-- Check color contrast ratios
-- Verify images have alt text
-- Test screen reader compatibility
-- Check for proper heading hierarchy
-- Verify focus indicators are visible
-- Report WCAG violations with severity`,
-  "performance-tester": `You are a Performance Testing Specialist. Your mission:
-- Measure page load times
-- Identify slow-loading resources
-- Check for render-blocking resources
-- Monitor network requests and response times
-- Identify memory leaks or excessive DOM nodes
-- Check for unnecessary re-renders
-- Test under simulated slow network conditions
-- Report performance issues with metrics`,
-  "api-tester": `You are an API Testing Specialist. Your mission:
-- Monitor network requests made by the application
-- Test API error handling
-- Check for proper authentication on API calls
-- Verify API response formats
-- Test rate limiting behavior
-- Check for exposed internal APIs
-- Verify proper HTTP methods are used
-- Report API issues with request/response details`,
-  "auth-tester": `You are an Authentication Testing Specialist. Your mission:
-- Test login with valid/invalid credentials
-- Test password reset flow
-- Check session management (timeout, persistence)
-- Test logout functionality
-- Check for session fixation vulnerabilities
-- Test remember me functionality
-- Verify proper access control on protected pages
-- Test multi-factor authentication if present`,
-  "navigation-tester": `You are a Navigation Testing Specialist. Your mission:
-- Test all navigation links and menus
-- Verify breadcrumbs work correctly
-- Test browser back/forward behavior
-- Check for broken links (404s)
-- Test deep linking and URL sharing
-- Verify redirects work properly
-- Test pagination and infinite scroll
-- Report navigation issues with affected URLs`
-};
-var SpecialistAgentManager = class extends EventEmitter2 {
-  agents = /* @__PURE__ */ new Map();
-  agentStatuses = /* @__PURE__ */ new Map();
-  db;
-  sessionId;
-  llmConfig;
-  browserTools;
-  constructor(db, sessionId, llmConfig, browserTools) {
-    super();
-    this.db = db;
-    this.sessionId = sessionId;
-    this.llmConfig = llmConfig;
-    this.browserTools = browserTools;
-  }
-  createLLMAdapter() {
-    if (this.llmConfig.provider === "anthropic") {
-      return new AnthropicAdapter({
-        apiKey: this.llmConfig.apiKey,
-        model: this.llmConfig.model || "claude-3-5-sonnet-20241022"
-      });
-    }
-    return new OpenAIAdapter({
-      apiKey: this.llmConfig.apiKey,
-      model: this.llmConfig.model || "gpt-4"
-    });
+    };
   }
-  createSpecialist(type, customPrompt) {
-    const agentId = `${type}_${Date.now()}`;
-    const systemPrompt = customPrompt || SPECIALIST_PROMPTS[type];
-    const agent = new ReActAgent({
-      llm: this.createLLMAdapter(),
-      tools: this.browserTools.getTools(),
-      maxIterations: 15,
-      systemPrompt: `${systemPrompt}
+});
 
-IMPORTANT RULES:
-- Take screenshots as evidence for any bug found
-- Create Kanban tickets for all findings
-- Create GitHub issues for critical/high severity bugs
-- Be thorough but efficient
-- Stop when you've tested the main scenarios for your specialty`
+// cli/server.ts
+var server_exports = {};
+__export(server_exports, {
+  startWebServer: () => startWebServer
+});
+import express from "express";
+import { WebSocketServer } from "ws";
+import chalk from "chalk";
+async function startWebServer() {
+  const config = new ConfigManager();
+  const cfg = config.getConfigSync();
+  const db = new OpenQADatabase("./data/openqa.json");
+  const app = express();
+  app.use(express.json());
+  const wss = new WebSocketServer({ noServer: true });
+  app.get("/api/status", async (req, res) => {
+    res.json({
+      isRunning: true,
+      target: cfg.saas.url || "Not configured"
     });
-    this.agents.set(agentId, agent);
-    const status = {
-      id: agentId,
-      type,
-      status: "idle",
-      progress: 0,
-      findings: 0,
-      actions: 0
-    };
-    this.agentStatuses.set(agentId, status);
-    this.emit("agent-created", status);
-    return agentId;
-  }
-  async runSpecialist(agentId, targetUrl) {
-    const agent = this.agents.get(agentId);
-    const status = this.agentStatuses.get(agentId);
-    if (!agent || !status) {
-      throw new Error(`Agent ${agentId} not found`);
-    }
-    status.status = "running";
-    status.startedAt = /* @__PURE__ */ new Date();
-    status.progress = 0;
-    this.emit("agent-started", status);
+  });
+  app.get("/api/sessions", async (req, res) => {
+    const limit = parseInt(req.query.limit) || 10;
+    const sessions = await db.getRecentSessions(limit);
+    res.json(sessions);
+  });
+  app.get("/api/sessions/:id/actions", async (req, res) => {
+    const actions = await db.getSessionActions(req.params.id);
+    res.json(actions);
+  });
+  app.get("/api/bugs", async (req, res) => {
+    const status = req.query.status;
+    const bugs = status ? await db.getBugsByStatus(status) : await db.getAllBugs();
+    res.json(bugs);
+  });
+  app.get("/api/kanban/tickets", async (req, res) => {
+    const column = req.query.column;
+    const tickets = column ? await db.getKanbanTicketsByColumn(column) : await db.getKanbanTickets();
+    res.json(tickets);
+  });
+  app.patch("/api/kanban/tickets/:id", async (req, res) => {
+    const { id } = req.params;
+    const updates = req.body;
+    await db.updateKanbanTicket(id, updates);
+    res.json({ success: true });
+  });
+  app.get("/api/config", (req, res) => {
+    res.json(cfg);
+  });
+  app.post("/api/config", async (req, res) => {
     try {
-      const result = await agent.run(
-        `Test the application at ${targetUrl}. Focus on your specialty area. Report all findings.`
-      );
-      status.status = "completed";
-      status.completedAt = /* @__PURE__ */ new Date();
-      status.progress = 100;
-      this.emit("agent-completed", { ...status, result });
+      const configData = req.body;
+      for (const [key, value] of Object.entries(configData)) {
+        await config.set(key, String(value));
+      }
+      res.json({ success: true });
     } catch (error) {
-      status.status = "failed";
-      status.completedAt = /* @__PURE__ */ new Date();
-      this.emit("agent-failed", { ...status, error: error.message });
-    }
-  }
-  async runAllSpecialists(targetUrl, types) {
-    const agentTypes = types || [
-      "form-tester",
-      "security-scanner",
-      "component-tester",
-      "navigation-tester"
-    ];
-    const agentIds = agentTypes.map((type) => this.createSpecialist(type));
-    for (const agentId of agentIds) {
-      await this.runSpecialist(agentId, targetUrl);
-    }
-  }
-  async runSecuritySuite(targetUrl) {
-    const securityTypes = [
-      "security-scanner",
-      "sql-injection",
-      "xss-tester",
-      "auth-tester"
-    ];
-    await this.runAllSpecialists(targetUrl, securityTypes);
-  }
-  getAgentStatus(agentId) {
-    return this.agentStatuses.get(agentId);
-  }
-  getAllStatuses() {
-    return Array.from(this.agentStatuses.values());
-  }
-  stopAgent(agentId) {
-    const status = this.agentStatuses.get(agentId);
-    if (status && status.status === "running") {
-      status.status = "failed";
-      status.completedAt = /* @__PURE__ */ new Date();
-      this.emit("agent-stopped", status);
+      res.status(500).json({ success: false, error: error.message });
     }
-  }
-  stopAll() {
-    for (const [agentId] of this.agents) {
-      this.stopAgent(agentId);
-    }
-  }
-};
+  });
+  app.post("/api/config/reset", async (req, res) => {
+    try {
+      await db.clearAllConfig();
+      res.json({ success: true });
+    } catch (error) {
+      res.status(500).json({ success: false, error: error.message });
+    }
+  });
+  app.get("/", (req, res) => {
+    res.send(`
+      <!DOCTYPE html>
+      <html>
+        <head>
+          <title>OpenQA - Dashboard</title>
+          <style>
+            body { font-family: system-ui; max-width: 1200px; margin: 40px auto; padding: 20px; background: #0f172a; color: #e2e8f0; }
+            h1 { color: #38bdf8; }
+            .card { background: #1e293b; border: 1px solid #334155; border-radius: 8px; padding: 20px; margin: 20px 0; }
+            .status { display: inline-block; padding: 4px 12px; border-radius: 4px; font-size: 14px; }
+            .status.running { background: #10b981; color: white; }
+            .status.idle { background: #f59e0b; color: white; }
+            a { color: #38bdf8; text-decoration: none; }
+            a:hover { text-decoration: underline; }
+            nav { margin: 20px 0; }
+            nav a { margin-right: 20px; }
+          </style>
+        </head>
+        <body>
+          <h1>\u{1F916} OpenQA Dashboard</h1>
+          <nav>
+            <a href="/">Dashboard</a>
+            <a href="/kanban">Kanban</a>
+            <a href="/config">Config</a>
+          </nav>
+          <div class="card">
+            <h2>Status</h2>
+            <p>Agent: <span class="status idle">Idle</span></p>
+            <p>Target: ${cfg.saas.url || "Not configured"}</p>
+            <p>Auto-start: ${cfg.agent.autoStart ? "Enabled" : "Disabled"}</p>
+          </div>
+          <div class="card">
+            <h2>Quick Links</h2>
+            <ul>
+              <li><a href="/kanban">View Kanban Board</a></li>
+              <li><a href="/config">Configure OpenQA</a></li>
+            </ul>
+          </div>
+          <div class="card">
+            <h2>Getting Started</h2>
+            <p>Configure your SaaS application target and start testing:</p>
+            <ol>
+              <li>Set SAAS_URL environment variable or use the <a href="/config">Config page</a></li>
+              <li>Enable auto-start: <code>export AGENT_AUTO_START=true</code></li>
+              <li>Restart OpenQA</li>
+            </ol>
+          </div>
+        </body>
+      </html>
+    `);
+  });
+  app.get("/kanban", (req, res) => {
+    res.send(`
+      <!DOCTYPE html>
+      <html>
+        <head>
+          <title>OpenQA - Kanban Board</title>
+          <style>
+            body { font-family: system-ui; max-width: 1400px; margin: 40px auto; padding: 20px; background: #0f172a; color: #e2e8f0; }
+            h1 { color: #38bdf8; }
+            nav { margin: 20px 0; }
+            nav a { color: #38bdf8; text-decoration: none; margin-right: 20px; }
+            nav a:hover { text-decoration: underline; }
+            .board { display: grid; grid-template-columns: repeat(4, 1fr); gap: 20px; margin-top: 30px; }
+            .column { background: #1e293b; border: 1px solid #334155; border-radius: 8px; padding: 15px; }
+            .column h3 { margin-top: 0; color: #38bdf8; }
+            .ticket { background: #334155; padding: 12px; margin: 10px 0; border-radius: 6px; border-left: 3px solid #38bdf8; }
+            .ticket h4 { margin: 0 0 8px 0; font-size: 14px; }
+            .ticket p { margin: 0; font-size: 12px; color: #94a3b8; }
+          </style>
+        </head>
+        <body>
+          <h1>\u{1F4CB} Kanban Board</h1>
+          <nav>
+            <a href="/">Dashboard</a>
+            <a href="/kanban">Kanban</a>
+            <a href="/config">Config</a>
+          </nav>
+          <div class="board">
+            <div class="column">
+              <h3>Backlog</h3>
+              <p style="color: #64748b;">No tickets yet</p>
+            </div>
+            <div class="column">
+              <h3>To Do</h3>
+              <p style="color: #64748b;">No tickets yet</p>
+            </div>
+            <div class="column">
+              <h3>In Progress</h3>
+              <p style="color: #64748b;">No tickets yet</p>
+            </div>
+            <div class="column">
+              <h3>Done</h3>
+              <p style="color: #64748b;">No tickets yet</p>
+            </div>
+          </div>
+          <p style="margin-top: 40px; color: #64748b;">Tickets will appear here when the agent starts finding bugs and creating tasks.</p>
+        </body>
+      </html>
+    `);
+  });
+  app.get("/config", (req, res) => {
+    res.send(`
+      <!DOCTYPE html>
+      <html>
+        <head>
+          <title>OpenQA - Configuration</title>
+          <style>
+            body { font-family: system-ui; max-width: 800px; margin: 40px auto; padding: 20px; background: #0f172a; color: #e2e8f0; }
+            h1 { color: #38bdf8; }
+            nav { margin: 20px 0; }
+            nav a { color: #38bdf8; text-decoration: none; margin-right: 20px; }
+            nav a:hover { text-decoration: underline; }
+            .section { background: #1e293b; border: 1px solid #334155; border-radius: 8px; padding: 20px; margin: 20px 0; }
+            .section h2 { margin-top: 0; color: #38bdf8; font-size: 18px; }
+            .config-item { margin: 15px 0; }
+            .config-item label { display: block; margin-bottom: 5px; color: #94a3b8; font-size: 14px; }
+            .config-item input, .config-item select { 
+              background: #334155; 
+              border: 1px solid #475569; 
+              color: #e2e8f0; 
+              padding: 8px 12px; 
+              border-radius: 4px; 
+              font-family: monospace; 
+              font-size: 14px; 
+              width: 100%;
+              max-width: 400px;
+            }
+            .config-item input:focus, .config-item select:focus { 
+              outline: none; 
+              border-color: #38bdf8; 
+              box-shadow: 0 0 0 2px rgba(56, 189, 248, 0.1); 
+            }
+            .btn { 
+              background: #38bdf8; 
+              color: white; 
+              border: none; 
+              padding: 10px 20px; 
+              border-radius: 6px; 
+              cursor: pointer; 
+              font-size: 14px; 
+              margin-right: 10px;
+            }
+            .btn:hover { background: #0ea5e9; }
+            .btn-secondary { background: #64748b; }
+            .btn-secondary:hover { background: #475569; }
+            .success { color: #10b981; margin-left: 10px; }
+            .error { color: #ef4444; margin-left: 10px; }
+            code { background: #334155; padding: 2px 6px; border-radius: 3px; font-size: 13px; }
+            .checkbox { margin-right: 8px; }
+          </style>
+        </head>
+        <body>
+          <h1>\u2699\uFE0F Configuration</h1>
+          <nav>
+            <a href="/">Dashboard</a>
+            <a href="/kanban">Kanban</a>
+            <a href="/config">Config</a>
+          </nav>
+          
+          <div class="section">
+            <h2>SaaS Target</h2>
+            <form id="configForm">
+              <div class="config-item">
+                <label>URL</label>
+                <input type="url" id="saas_url" name="saas.url" value="${cfg.saas.url || ""}" placeholder="https://your-app.com">
+              </div>
+              <div class="config-item">
+                <label>Auth Type</label>
+                <select id="saas_authType" name="saas.authType">
+                  <option value="none" ${cfg.saas.authType === "none" ? "selected" : ""}>None</option>
+                  <option value="basic" ${cfg.saas.authType === "basic" ? "selected" : ""}>Basic Auth</option>
+                  <option value="bearer" ${cfg.saas.authType === "bearer" ? "selected" : ""}>Bearer Token</option>
+                  <option value="session" ${cfg.saas.authType === "session" ? "selected" : ""}>Session</option>
+                </select>
+              </div>
+              <div class="config-item">
+                <label>Username (for Basic Auth)</label>
+                <input type="text" id="saas_username" name="saas.username" value="${cfg.saas.username || ""}" placeholder="username">
+              </div>
+              <div class="config-item">
+                <label>Password (for Basic Auth)</label>
+                <input type="password" id="saas_password" name="saas.password" value="${cfg.saas.password || ""}" placeholder="password">
+              </div>
+            </form>
+          </div>
 
-// agent/skills/index.ts
-var DEFAULT_SKILLS = [
-  {
-    name: "GDPR Compliance Check",
-    description: "Check for GDPR compliance (cookie consent, privacy policy, data handling)",
-    type: "custom-check",
-    enabled: true,
-    priority: 1,
-    prompt: `Check GDPR compliance:
-- Verify cookie consent banner exists and works
-- Check for privacy policy link
-- Verify data deletion/export options if user accounts exist
-- Check for proper consent checkboxes on forms
-- Report any GDPR violations`,
-    triggers: ["eu", "gdpr", "privacy", "cookies"]
-  },
-  {
-    name: "Mobile Responsiveness",
-    description: "Test application on mobile viewport sizes",
-    type: "test-scenario",
-    enabled: true,
-    priority: 2,
-    prompt: `Test mobile responsiveness:
-- Test at 375px width (iPhone)
-- Test at 768px width (tablet)
-- Check for horizontal scrolling issues
-- Verify touch targets are large enough
-- Check navigation menu behavior on mobile
-- Report any responsive design issues`,
-    triggers: ["mobile", "responsive", "viewport"]
-  },
-  {
-    name: "E-commerce Flow",
-    description: "Test complete e-commerce purchase flow",
-    type: "workflow",
-    enabled: false,
-    priority: 3,
-    prompt: `Test e-commerce flow:
-- Browse products
-- Add items to cart
-- Verify cart updates correctly
-- Test checkout process
-- Test payment form validation
-- Verify order confirmation
-- Report any issues in the purchase flow`,
-    triggers: ["shop", "cart", "checkout", "payment", "ecommerce"]
-  },
-  {
-    name: "Dark Mode Testing",
-    description: "Test dark mode if available",
-    type: "custom-check",
-    enabled: true,
-    priority: 4,
-    prompt: `Test dark mode:
-- Look for dark mode toggle
-- Switch between light and dark modes
-- Check for contrast issues in dark mode
-- Verify all text is readable
-- Check images and icons visibility
-- Report any dark mode specific bugs`,
-    triggers: ["dark", "theme", "mode"]
-  },
-  {
-    name: "Error Handling",
-    description: "Test application error handling",
-    type: "test-scenario",
-    enabled: true,
-    priority: 1,
-    prompt: `Test error handling:
-- Try accessing non-existent pages (404)
-- Submit forms with invalid data
-- Test with network errors (if possible)
-- Check error message clarity
-- Verify errors don't expose sensitive info
-- Test recovery from error states
-- Report poor error handling`,
-    triggers: ["error", "404", "exception"]
-  },
-  {
-    name: "Rate Limiting Check",
-    description: "Test for rate limiting on sensitive endpoints",
-    type: "custom-check",
-    enabled: true,
-    priority: 2,
-    prompt: `Test rate limiting:
-- Attempt multiple rapid login attempts
-- Test API endpoints for rate limiting
-- Check for CAPTCHA on repeated failures
-- Verify account lockout mechanisms
-- Report missing rate limiting as security issue`,
-    triggers: ["rate", "limit", "brute", "ddos"]
-  }
-];
-var SkillManager = class {
-  db;
-  skills = /* @__PURE__ */ new Map();
-  constructor(db) {
-    this.db = db;
-    this.loadSkills();
-  }
-  loadSkills() {
-    DEFAULT_SKILLS.forEach((skill) => {
-      this.createSkill(skill);
-    });
-  }
-  saveSkills() {
-  }
-  createSkill(data) {
-    const skill = {
-      ...data,
-      id: `skill_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
-      createdAt: /* @__PURE__ */ new Date(),
-      updatedAt: /* @__PURE__ */ new Date()
-    };
-    this.skills.set(skill.id, skill);
-    this.saveSkills();
-    return skill;
-  }
-  updateSkill(id, updates) {
-    const skill = this.skills.get(id);
-    if (!skill) return null;
-    const updated = {
-      ...skill,
-      ...updates,
-      updatedAt: /* @__PURE__ */ new Date()
-    };
-    this.skills.set(id, updated);
-    this.saveSkills();
-    return updated;
-  }
-  deleteSkill(id) {
-    const deleted = this.skills.delete(id);
-    if (deleted) {
-      this.saveSkills();
-    }
-    return deleted;
-  }
-  getSkill(id) {
-    return this.skills.get(id);
-  }
-  getAllSkills() {
-    return Array.from(this.skills.values());
-  }
-  getEnabledSkills() {
-    return this.getAllSkills().filter((s) => s.enabled).sort((a, b) => a.priority - b.priority);
-  }
-  getSkillsByType(type) {
-    return this.getAllSkills().filter((s) => s.type === type);
-  }
-  findSkillsByTrigger(text) {
-    const lowerText = text.toLowerCase();
-    return this.getEnabledSkills().filter(
-      (skill) => skill.triggers?.some((trigger) => lowerText.includes(trigger.toLowerCase()))
-    );
-  }
-  generateSkillPrompt(skills) {
-    if (skills.length === 0) return "";
-    const skillInstructions = skills.map(
-      (skill, index) => `### Skill ${index + 1}: ${skill.name}
-${skill.prompt}`
-    ).join("\n\n");
-    return `
-## Additional Skills/Directives to Follow
+          <div class="section">
+            <h2>LLM Configuration</h2>
+            <form id="configForm">
+              <div class="config-item">
+                <label>Provider</label>
+                <select id="llm_provider" name="llm.provider">
+                  <option value="openai" ${cfg.llm.provider === "openai" ? "selected" : ""}>OpenAI</option>
+                  <option value="anthropic" ${cfg.llm.provider === "anthropic" ? "selected" : ""}>Anthropic</option>
+                  <option value="ollama" ${cfg.llm.provider === "ollama" ? "selected" : ""}>Ollama</option>
+                </select>
+              </div>
+              <div class="config-item">
+                <label>Model</label>
+                <input type="text" id="llm_model" name="llm.model" value="${cfg.llm.model || ""}" placeholder="gpt-4, claude-3-sonnet, etc.">
+              </div>
+              <div class="config-item">
+                <label>API Key</label>
+                <input type="password" id="llm_apiKey" name="llm.apiKey" value="${cfg.llm.apiKey || ""}" placeholder="Your API key">
+              </div>
+              <div class="config-item">
+                <label>Base URL (for Ollama)</label>
+                <input type="url" id="llm_baseUrl" name="llm.baseUrl" value="${cfg.llm.baseUrl || ""}" placeholder="http://localhost:11434">
+              </div>
+            </form>
+          </div>
 
-The following skills have been configured. Execute them as part of your testing:
+          <div class="section">
+            <h2>Agent Settings</h2>
+            <form id="configForm">
+              <div class="config-item">
+                <label>
+                  <input type="checkbox" id="agent_autoStart" name="agent.autoStart" class="checkbox" ${cfg.agent.autoStart ? "checked" : ""}>
+                  Auto-start
+                </label>
+              </div>
+              <div class="config-item">
+                <label>Interval (ms)</label>
+                <input type="number" id="agent_intervalMs" name="agent.intervalMs" value="${cfg.agent.intervalMs}" min="60000">
+              </div>
+              <div class="config-item">
+                <label>Max Iterations</label>
+                <input type="number" id="agent_maxIterations" name="agent.maxIterations" value="${cfg.agent.maxIterations}" min="1" max="100">
+              </div>
+            </form>
+          </div>
 
-${skillInstructions}
+          <div class="section">
+            <h2>Actions</h2>
+            <button type="button" class="btn" onclick="saveConfig()">Save Configuration</button>
+            <button type="button" class="btn btn-secondary" onclick="resetConfig()">Reset to Defaults</button>
+            <span id="message"></span>
+          </div>
 
-Remember to report findings from each skill separately.
-`;
-  }
-  toggleSkill(id) {
-    const skill = this.skills.get(id);
-    if (!skill) return null;
-    return this.updateSkill(id, { enabled: !skill.enabled });
-  }
-  reorderSkills(orderedIds) {
-    orderedIds.forEach((id, index) => {
-      const skill = this.skills.get(id);
-      if (skill) {
-        skill.priority = index + 1;
-        skill.updatedAt = /* @__PURE__ */ new Date();
-      }
+          <div class="section">
+            <h2>Environment Variables</h2>
+            <p>You can also set these environment variables before starting OpenQA:</p>
+            <pre style="background: #334155; padding: 15px; border-radius: 6px; overflow-x: auto;"><code>export SAAS_URL="https://your-app.com"
+export AGENT_AUTO_START=true
+export LLM_PROVIDER=openai
+export OPENAI_API_KEY="your-key"
+
+openqa start</code></pre>
+          </div>
+
+          <script>
+            async function saveConfig() {
+              const form = document.getElementById('configForm');
+              const formData = new FormData(form);
+              const config = {};
+              
+              for (let [key, value] of formData.entries()) {
+                if (value === '') continue;
+                
+                // Handle nested keys like "saas.url"
+                const keys = key.split('.');
+                let obj = config;
+                for (let i = 0; i < keys.length - 1; i++) {
+                  if (!obj[keys[i]]) obj[keys[i]] = {};
+                  obj = obj[keys[i]];
+                }
+                
+                // Convert checkbox values to boolean
+                if (key.includes('autoStart')) {
+                  obj[keys[keys.length - 1]] = value === 'on';
+                } else if (key.includes('intervalMs') || key.includes('maxIterations')) {
+                  obj[keys[keys.length - 1]] = parseInt(value);
+                } else {
+                  obj[keys[keys.length - 1]] = value;
+                }
+              }
+              
+              try {
+                const response = await fetch('/api/config', {
+                  method: 'POST',
+                  headers: { 'Content-Type': 'application/json' },
+                  body: JSON.stringify(config)
+                });
+                
+                const result = await response.json();
+                if (result.success) {
+                  showMessage('Configuration saved successfully!', 'success');
+                  setTimeout(() => location.reload(), 1500);
+                } else {
+                  showMessage('Failed to save configuration', 'error');
+                }
+              } catch (error) {
+                showMessage('Error: ' + error.message, 'error');
+              }
+            }
+            
+            async function resetConfig() {
+              if (confirm('Are you sure you want to reset all configuration to defaults?')) {
+                try {
+                  const response = await fetch('/api/config/reset', { method: 'POST' });
+                  const result = await response.json();
+                  if (result.success) {
+                    showMessage('Configuration reset to defaults', 'success');
+                    setTimeout(() => location.reload(), 1500);
+                  }
+                } catch (error) {
+                  showMessage('Error: ' + error.message, 'error');
+                }
+              }
+            }
+            
+            function showMessage(text, type) {
+              const messageEl = document.getElementById('message');
+              messageEl.textContent = text;
+              messageEl.className = type;
+              setTimeout(() => {
+                messageEl.textContent = '';
+                messageEl.className = '';
+              }, 3000);
+            }
+          </script>
+        </body>
+      </html>
+    `);
+  });
+  const server = app.listen(cfg.web.port, cfg.web.host, () => {
+    console.log(chalk.cyan("\n\u{1F4CA} OpenQA Status:"));
+    console.log(chalk.white(`  Agent: ${cfg.agent.autoStart ? "Auto-start enabled" : "Idle"}`));
+    console.log(chalk.white(`  Target: ${cfg.saas.url || "Not configured"}`));
+    console.log(chalk.white(`  Dashboard: http://localhost:${cfg.web.port}`));
+    console.log(chalk.white(`  Kanban: http://localhost:${cfg.web.port}/kanban`));
+    console.log(chalk.white(`  Config: http://localhost:${cfg.web.port}/config`));
+    console.log(chalk.gray("\nPress Ctrl+C to stop\n"));
+    if (!cfg.agent.autoStart) {
+      console.log(chalk.yellow("\u{1F4A1} Auto-start disabled. Agent is idle."));
+      console.log(chalk.cyan("   Set AGENT_AUTO_START=true to enable autonomous mode\n"));
+    }
+  });
+  server.on("upgrade", (request, socket, head) => {
+    wss.handleUpgrade(request, socket, head, (ws) => {
+      wss.emit("connection", ws, request);
     });
-    this.saveSkills();
-  }
-  exportSkills() {
-    return JSON.stringify(this.getAllSkills(), null, 2);
-  }
-  importSkills(json) {
-    const imported = JSON.parse(json);
-    let count = 0;
-    imported.forEach((skill) => {
-      const newSkill = this.createSkill({
-        name: skill.name,
-        description: skill.description,
-        type: skill.type,
-        enabled: skill.enabled,
-        priority: skill.priority,
-        prompt: skill.prompt,
-        triggers: skill.triggers
-      });
-      if (newSkill) count++;
+  });
+  wss.on("connection", (ws) => {
+    console.log("WebSocket client connected");
+    ws.on("close", () => {
+      console.log("WebSocket client disconnected");
     });
-    return count;
-  }
-};
-
-// agent/index.ts
-var OpenQAAgent = class extends EventEmitter3 {
-  agent = null;
-  db;
-  config;
-  browserTools = null;
-  sessionId = "";
-  isRunning = false;
-  intervalId = null;
-  // New v2 features
-  gitListener = null;
-  specialistManager = null;
-  skillManager;
-  constructor(configPath) {
-    super();
-    this.config = new ConfigManager(configPath);
-    this.db = new OpenQADatabase("./data/openqa.json");
-    this.skillManager = new SkillManager(this.db);
-  }
-  createLLMAdapter() {
-    const cfg = this.config.getConfigSync();
-    switch (cfg.llm.provider) {
-      case "anthropic":
-        return new AnthropicAdapter2({
-          apiKey: cfg.llm.apiKey || process.env.ANTHROPIC_API_KEY,
-          model: cfg.llm.model || "claude-3-5-sonnet-20241022"
-        });
-      case "openai":
-      default:
-        return new OpenAIAdapter2({
-          apiKey: cfg.llm.apiKey || process.env.OPENAI_API_KEY,
-          model: cfg.llm.model || "gpt-4"
-        });
-    }
-  }
-  async initialize(triggerType = "manual", triggerData) {
-    const cfg = this.config.getConfigSync();
-    this.sessionId = `session_${Date.now()}`;
-    await this.db.createSession(this.sessionId, {
-      config: cfg,
-      started_at: (/* @__PURE__ */ new Date()).toISOString(),
-      trigger_type: triggerType,
-      trigger_data: triggerData ? JSON.stringify(triggerData) : null
+  });
+  process.on("SIGTERM", () => {
+    console.log("Received SIGTERM, shutting down gracefully...");
+    server.close(() => {
+      process.exit(0);
     });
-    this.browserTools = new BrowserTools(this.db, this.sessionId);
-    const githubTools = new GitHubTools(this.db, this.sessionId, cfg.github || {});
-    const kanbanTools = new KanbanTools(this.db, this.sessionId);
-    const allTools = [
-      ...this.browserTools.getTools(),
-      ...githubTools.getTools(),
-      ...kanbanTools.getTools()
-    ];
-    const llm = this.createLLMAdapter();
-    const memory = new SessionMemory({ maxMessages: 50 });
-    const tracer = new Tracer({ logLevel: "info" });
-    const enabledSkills = this.skillManager.getEnabledSkills();
-    const skillPrompt = this.skillManager.generateSkillPrompt(enabledSkills);
-    const agentConfig = {
-      goal: "Test the SaaS application comprehensively and identify bugs",
-      tools: allTools,
-      tracer,
-      maxIterations: cfg.agent.maxIterations,
-      systemPrompt: `You are OpenQA, an autonomous QA testing agent - intelligent and thorough like a senior QA engineer.
-
-Your mission:
-1. **Systematically test the SaaS application** at ${cfg.saas.url}
-2. **Create comprehensive test flows** - think like a real user AND a security expert
-3. **Identify bugs and issues** - UI bugs, console errors, broken flows, UX issues, security vulnerabilities
-4. **Report findings appropriately**:
-   - Use create_github_issue for critical bugs requiring developer attention
-   - Use create_kanban_ticket for QA tracking, minor issues, or improvements
-   - You can create BOTH for critical bugs
-5. **Learn from previous sessions** - avoid repeating the same tests
-6. **Spawn specialist agents** when needed for deep testing (security, forms, etc.)
-
-Testing strategy:
-- Start with core user flows (signup, login, main features)
-- Test edge cases and error handling
-- Check for console errors and network issues
-- Test security (SQL injection, XSS, auth bypass)
-- Test forms thoroughly (validation, edge cases)
-- Take screenshots as evidence
-- Document steps to reproduce clearly
-
-Reporting guidelines:
-- **Critical/High severity** \u2192 GitHub issue + Kanban ticket
-- **Medium severity** \u2192 Kanban ticket (optionally GitHub if it blocks users)
-- **Low severity/Improvements** \u2192 Kanban ticket only
-
-${skillPrompt}
-
-Always provide clear, actionable information with steps to reproduce. Think step by step like a human QA expert.`
-    };
-    this.agent = new ReActAgent2(agentConfig, llm, memory);
-    this.specialistManager = new SpecialistAgentManager(
-      this.db,
-      this.sessionId,
-      { provider: cfg.llm.provider, apiKey: cfg.llm.apiKey || "" },
-      this.browserTools
-    );
-    this.specialistManager.on("agent-created", (status) => this.emit("specialist-created", status));
-    this.specialistManager.on("agent-started", (status) => this.emit("specialist-started", status));
-    this.specialistManager.on("agent-completed", (data) => this.emit("specialist-completed", data));
-    this.specialistManager.on("agent-failed", (data) => this.emit("specialist-failed", data));
-    console.log(`\u2705 OpenQA Agent initialized (Session: ${this.sessionId})`);
-  }
-  async runSession() {
-    if (!this.agent) {
-      await this.initialize();
-    }
-    const cfg = this.config.getConfig();
-    console.log(`\u{1F680} Starting test session for ${cfg.saas.url}`);
-    try {
-      const result = await this.agent.run(
-        `Continue testing the application at ${cfg.saas.url}. Review previous findings, create new test scenarios, and report any issues discovered. Focus on areas not yet tested.`
-      );
-      this.db.updateSession(this.sessionId, {
-        status: "completed",
-        ended_at: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      console.log("\u2705 Test session completed:", result);
-      return result;
-    } catch (error) {
-      console.error("\u274C Session error:", error);
-      this.db.updateSession(this.sessionId, {
-        status: "failed",
-        ended_at: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      throw error;
-    } finally {
-      if (this.browserTools) {
-        await this.browserTools.close();
-      }
-    }
-  }
-  async startAutonomous() {
-    if (this.isRunning) {
-      console.log("\u26A0\uFE0F  Agent is already running");
-      return;
-    }
-    this.isRunning = true;
-    const cfg = this.config.getConfig();
-    console.log(`\u{1F916} OpenQA Agent starting in autonomous mode`);
-    console.log(`\u{1F4CD} Target: ${cfg.saas.url}`);
-    console.log(`\u23F1\uFE0F  Interval: ${cfg.agent.intervalMs}ms (${cfg.agent.intervalMs / 1e3 / 60} minutes)`);
-    await this.startGitListener();
-    const runLoop = async () => {
-      if (!this.isRunning) return;
-      try {
-        await this.runSession();
-      } catch (error) {
-        console.error("Session failed, will retry on next interval");
-      }
-      if (this.isRunning) {
-        this.sessionId = `session_${Date.now()}`;
-        this.agent = null;
-        this.browserTools = null;
-        this.intervalId = setTimeout(runLoop, cfg.agent.intervalMs);
-      }
-    };
-    await runLoop();
-  }
-  stop() {
-    console.log("\u{1F6D1} Stopping OpenQA Agent...");
-    this.isRunning = false;
-    if (this.intervalId) {
-      clearTimeout(this.intervalId);
-      this.intervalId = null;
-    }
-    if (this.gitListener) {
-      this.gitListener.stop();
-      this.gitListener = null;
-    }
-    if (this.specialistManager) {
-      this.specialistManager.stopAll();
-    }
-    if (this.browserTools) {
-      this.browserTools.close();
-    }
-  }
-  // Git integration
-  async startGitListener() {
-    const cfg = this.config.getConfig();
-    if (cfg.github?.token && cfg.github?.owner && cfg.github?.repo) {
-      this.gitListener = new GitListener({
-        provider: "github",
-        token: cfg.github.token,
-        owner: cfg.github.owner,
-        repo: cfg.github.repo,
-        branch: "main",
-        pollIntervalMs: 6e4
-      });
-    } else if (this.config.get("gitlab.token") && this.config.get("gitlab.project")) {
-      const [owner, repo] = (this.config.get("gitlab.project") || "").split("/");
-      this.gitListener = new GitListener({
-        provider: "gitlab",
-        token: this.config.get("gitlab.token") || "",
-        owner,
-        repo,
-        branch: "main",
-        pollIntervalMs: 6e4,
-        gitlabUrl: this.config.get("gitlab.url") || "https://gitlab.com"
-      });
-    }
-    if (this.gitListener) {
-      this.gitListener.on("merge", async (event) => {
-        console.log(`\u{1F500} Merge detected! Starting test session...`);
-        this.emit("git-merge", event);
-        this.sessionId = `session_${Date.now()}`;
-        this.agent = null;
-        this.browserTools = null;
-        await this.runSession();
-      });
-      this.gitListener.on("pipeline-success", async (event) => {
-        console.log(`\u2705 Pipeline success! Starting test session...`);
-        this.emit("git-pipeline-success", event);
-        this.sessionId = `session_${Date.now()}`;
-        this.agent = null;
-        this.browserTools = null;
-        await this.runSession();
-      });
-      await this.gitListener.start();
-      console.log(`\u{1F517} Git listener started for ${this.gitListener ? "repository" : "none"}`);
-    }
-  }
-  // Specialist agents management
-  async runSecurityScan() {
-    if (!this.specialistManager) {
-      await this.initialize();
-    }
-    const cfg = this.config.getConfig();
-    await this.specialistManager.runSecuritySuite(cfg.saas.url);
-  }
-  async runSpecialist(type) {
-    if (!this.specialistManager) {
-      await this.initialize();
-    }
-    const cfg = this.config.getConfig();
-    const agentId = this.specialistManager.createSpecialist(type);
-    await this.specialistManager.runSpecialist(agentId, cfg.saas.url);
-  }
-  getSpecialistStatuses() {
-    return this.specialistManager?.getAllStatuses() || [];
-  }
-  // Skills management
-  getSkills() {
-    return this.skillManager.getAllSkills();
-  }
-  createSkill(data) {
-    return this.skillManager.createSkill(data);
-  }
-  updateSkill(id, updates) {
-    return this.skillManager.updateSkill(id, updates);
-  }
-  deleteSkill(id) {
-    return this.skillManager.deleteSkill(id);
-  }
-  toggleSkill(id) {
-    return this.skillManager.toggleSkill(id);
-  }
-  getStatus() {
-    return {
-      isRunning: this.isRunning,
-      sessionId: this.sessionId,
-      config: this.config.getConfig(),
-      gitListenerActive: !!this.gitListener,
-      specialists: this.getSpecialistStatuses(),
-      skills: this.skillManager.getEnabledSkills().length
-    };
+  });
+  process.on("SIGINT", () => {
+    console.log("\nShutting down gracefully...");
+    server.close(() => {
+      process.exit(0);
+    });
+  });
+}
+var init_server = __esm({
+  "cli/server.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_config();
+    init_database();
   }
-};
+});
 
 // cli/index.ts
+init_esm_shims();
+init_config();
+init_database();
+import { Command } from "commander";
 import { spawn } from "child_process";
 import { writeFileSync as writeFileSync2, readFileSync as readFileSync2, existsSync, unlinkSync } from "fs";
-import { join as join3 } from "path";
-import chalk from "chalk";
+import { join as join2 } from "path";
+import chalk2 from "chalk";
 import ora from "ora";
 var program = new Command();
 var PID_FILE = "./data/openqa.pid";
@@ -1646,46 +756,31 @@ program.command("start").description("Start the OpenQA agent and web UI").option
       const pid = readFileSync2(PID_FILE, "utf-8").trim();
       try {
         process.kill(parseInt(pid), 0);
-        spinner.fail(chalk.red("OpenQA is already running"));
-        console.log(chalk.yellow(`PID: ${pid}`));
-        console.log(chalk.cyan('Run "openqa stop" to stop it first'));
+        spinner.fail(chalk2.red("OpenQA is already running"));
+        console.log(chalk2.yellow(`PID: ${pid}`));
+        console.log(chalk2.cyan('Run "openqa stop" to stop it first'));
         process.exit(1);
       } catch {
         unlinkSync(PID_FILE);
       }
     }
     if (options.daemon) {
-      const child = spawn("node", [join3(process.cwd(), "dist/cli/daemon.js")], {
+      const child = spawn("node", [join2(process.cwd(), "dist/cli/daemon.js")], {
         detached: true,
         stdio: "ignore"
       });
       child.unref();
       writeFileSync2(PID_FILE, child.pid.toString());
-      spinner.succeed(chalk.green("OpenQA started in daemon mode"));
-      console.log(chalk.cyan(`PID: ${child.pid}`));
+      spinner.succeed(chalk2.green("OpenQA started in daemon mode"));
+      console.log(chalk2.cyan(`PID: ${child.pid}`));
     } else {
-      spinner.succeed(chalk.green("OpenQA started"));
-      const agent = new OpenQAAgent();
-      const config = new ConfigManager();
-      const cfg = config.getConfigSync();
-      console.log(chalk.cyan("\n\u{1F4CA} OpenQA Status:"));
-      console.log(chalk.white(`  Agent: Running`));
-      console.log(chalk.white(`  Target: ${cfg.saas.url || "Not configured"}`));
-      console.log(chalk.white(`  Web UI: http://localhost:${cfg.web.port}`));
-      console.log(chalk.white(`  DevTools: http://localhost:${cfg.web.port}`));
-      console.log(chalk.white(`  Kanban: http://localhost:${cfg.web.port}/kanban`));
-      console.log(chalk.white(`  Config: http://localhost:${cfg.web.port}/config`));
-      console.log(chalk.gray("\nPress Ctrl+C to stop\n"));
-      if (cfg.agent.autoStart) {
-        await agent.startAutonomous();
-      } else {
-        console.log(chalk.yellow("Auto-start disabled. Agent is idle."));
-        console.log(chalk.cyan("Set AGENT_AUTO_START=true to enable autonomous mode"));
-      }
+      const { startWebServer: startWebServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
+      await startWebServer2();
+      spinner.succeed(chalk2.green("OpenQA started"));
     }
   } catch (error) {
-    spinner.fail(chalk.red("Failed to start OpenQA"));
-    console.error(chalk.red(error.message));
+    spinner.fail(chalk2.red("Failed to start OpenQA"));
+    console.error(chalk2.red(error.message));
     process.exit(1);
   }
 });
@@ -1693,78 +788,81 @@ program.command("stop").description("Stop the OpenQA agent").action(() => {
   const spinner = ora("Stopping OpenQA...").start();
   try {
     if (!existsSync(PID_FILE)) {
-      spinner.fail(chalk.red("OpenQA is not running"));
+      spinner.fail(chalk2.red("No OpenQA daemon process found"));
+      console.log(chalk2.yellow("Note: OpenQA might be running in foreground mode"));
+      console.log(chalk2.cyan("Use Ctrl+C to stop foreground processes"));
       process.exit(1);
     }
     const pid = readFileSync2(PID_FILE, "utf-8").trim();
     try {
       process.kill(parseInt(pid), "SIGTERM");
       unlinkSync(PID_FILE);
-      spinner.succeed(chalk.green("OpenQA stopped"));
+      spinner.succeed(chalk2.green("OpenQA daemon stopped"));
     } catch (error) {
-      spinner.fail(chalk.red("Failed to stop OpenQA"));
-      console.error(chalk.red("Process not found. Cleaning up PID file..."));
+      spinner.fail(chalk2.red("Failed to stop OpenQA"));
+      console.error(chalk2.red("Process not found. Cleaning up stale PID file..."));
       unlinkSync(PID_FILE);
+      console.log(chalk2.yellow("The daemon process was already stopped"));
     }
   } catch (error) {
-    spinner.fail(chalk.red("Failed to stop OpenQA"));
-    console.error(chalk.red(error.message));
+    spinner.fail(chalk2.red("Failed to stop OpenQA"));
+    console.error(chalk2.red(error.message));
     process.exit(1);
   }
 });
 program.command("status").description("Show OpenQA status").action(() => {
-  console.log(chalk.cyan.bold("\n\u{1F4CA} OpenQA Status\n"));
+  console.log(chalk2.cyan.bold("\n\u{1F4CA} OpenQA Status\n"));
   if (existsSync(PID_FILE)) {
     const pid = readFileSync2(PID_FILE, "utf-8").trim();
     try {
       process.kill(parseInt(pid), 0);
-      console.log(chalk.green("\u2713 Agent: Running"));
-      console.log(chalk.white(`  PID: ${pid}`));
-      console.log(chalk.yellow("\n\u{1F4CB} Detailed status temporarily disabled"));
+      console.log(chalk2.green("\u2713 Agent: Running"));
+      console.log(chalk2.white(`  PID: ${pid}`));
+      console.log(chalk2.yellow("\n\u{1F4CB} Detailed status temporarily disabled"));
     } catch {
-      console.log(chalk.red("\u2717 Agent: Not running (stale PID file)"));
+      console.log(chalk2.red("\u2717 Agent: Not running (stale PID file)"));
       unlinkSync(PID_FILE);
     }
   } else {
-    console.log(chalk.yellow("\u2717 Agent: Not running"));
+    console.log(chalk2.yellow("\u2717 Agent: Not running"));
   }
 });
 program.command("config").description("Manage configuration").argument("[action]", "Action: get, set, list").argument("[key]", "Configuration key (e.g., llm.provider)").argument("[value]", "Configuration value").action((action, key, value) => {
   const config = new ConfigManager();
   if (!action || action === "list") {
     const cfg = config.getConfigSync();
-    console.log(chalk.cyan.bold("\n\u2699\uFE0F  OpenQA Configuration\n"));
+    console.log(chalk2.cyan.bold("\n\u2699\uFE0F  OpenQA Configuration\n"));
     console.log(JSON.stringify(cfg, null, 2));
     console.log("");
     return;
   }
   if (action === "get") {
     if (!key) {
-      console.error(chalk.red('Error: key is required for "get" action'));
+      console.error(chalk2.red('Error: key is required for "get" action'));
       process.exit(1);
     }
     const val = config.get(key);
-    console.log(chalk.cyan(`${key}:`), chalk.white(val || "Not set"));
+    console.log(chalk2.cyan(`${key}:`), chalk2.white(val || "Not set"));
     return;
   }
   if (action === "set") {
     if (!key || !value) {
-      console.error(chalk.red('Error: key and value are required for "set" action'));
+      console.error(chalk2.red('Error: key and value are required for "set" action'));
       process.exit(1);
     }
     config.set(key, value);
-    console.log(chalk.green(`\u2713 Set ${key} = ${value}`));
+    console.log(chalk2.green(`\u2713 Set ${key} = ${value}`));
     return;
   }
-  console.error(chalk.red(`Unknown action: ${action}`));
-  console.log(chalk.cyan("Available actions: get, set, list"));
+  console.error(chalk2.red(`Unknown action: ${action}`));
+  console.log(chalk2.cyan("Available actions: get, set, list"));
   process.exit(1);
 });
 program.command("logs").description("Show agent logs").option("-f, --follow", "Follow log output").option("-n, --lines <number>", "Number of lines to show", "50").action((options) => {
   const config = new ConfigManager();
   const cfg = config.getConfigSync();
   const db = new OpenQADatabase(cfg.database.path);
-  console.log(chalk.yellow("Logs feature temporarily disabled"));
+  console.log(chalk2.yellow("Logs feature temporarily disabled"));
   return;
 });
 program.parse();