@openqa/cli 1.3.4 → 2.1.0

package/dist/agent/config/index.js

@@ -0,0 +1,588 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+
+// 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/sqlite.ts
+import Database from "better-sqlite3";
+var init_sqlite = __esm({
+  "database/sqlite.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// agent/config/index.ts
+init_esm_shims();
+import { config as dotenvConfig } from "dotenv";
+
+// database/index.ts
+init_esm_shims();
+init_sqlite();
+import { Low } from "lowdb";
+import { JSONFile } from "lowdb/node";
+import { dirname } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { mkdirSync } from "fs";
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = dirname(__filename2);
+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: [],
+      users: []
+    });
+    this.db.read();
+    if (!this.db.data) {
+      this.db.data = {
+        config: {},
+        test_sessions: [],
+        actions: [],
+        bugs: [],
+        kanban_tickets: [],
+        users: []
+      };
+      this.db.write();
+    }
+  }
+  async ensureInitialized() {
+    if (!this.db) {
+      this.initialize();
+    }
+    await this.db.read();
+    let migrated = false;
+    if (!this.db.data.users) {
+      this.db.data.users = [];
+      migrated = true;
+    }
+    if (migrated) await this.db.write();
+  }
+  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 deleteKanbanTicket(id) {
+    await this.ensureInitialized();
+    const index = this.db.data.kanban_tickets.findIndex((t) => t.id === id);
+    if (index !== -1) {
+      this.db.data.kanban_tickets.splice(index, 1);
+      await this.db.write();
+    }
+  }
+  async clearAllConfig() {
+    await this.ensureInitialized();
+    this.db.data.config = {};
+    await this.db.write();
+  }
+  // Get real data methods - connected to actual database records
+  async getActiveAgents() {
+    await this.ensureInitialized();
+    const sessions = await this.getRecentSessions(1);
+    const currentSession = sessions[0];
+    const isRunning = currentSession?.status === "running";
+    const totalActions = currentSession?.total_actions || 0;
+    const agents = [
+      {
+        name: "Main Agent",
+        status: isRunning ? "running" : "idle",
+        purpose: "Autonomous QA orchestration",
+        performance: totalActions > 0 ? Math.min(100, Math.round(totalActions / 100 * 100)) : 0,
+        tasks: totalActions
+      }
+    ];
+    if (currentSession && totalActions > 0) {
+      const actions = await this.getSessionActions(currentSession.id);
+      const actionTypes = actions.reduce((acc, action) => {
+        const type = action.type || "unknown";
+        acc[type] = (acc[type] || 0) + 1;
+        return acc;
+      }, {});
+      if (actionTypes["navigate"] || actionTypes["click"] || actionTypes["screenshot"]) {
+        agents.push({
+          name: "Browser Specialist",
+          status: isRunning ? "running" : "idle",
+          purpose: "UI navigation and interaction",
+          performance: Math.round(((actionTypes["navigate"] || 0) + (actionTypes["click"] || 0)) / totalActions * 100),
+          tasks: (actionTypes["navigate"] || 0) + (actionTypes["click"] || 0)
+        });
+      }
+      if (actionTypes["api_call"] || actionTypes["request"]) {
+        agents.push({
+          name: "API Tester",
+          status: isRunning ? "running" : "idle",
+          purpose: "API endpoint testing",
+          performance: Math.round((actionTypes["api_call"] || actionTypes["request"] || 0) / totalActions * 100),
+          tasks: actionTypes["api_call"] || actionTypes["request"] || 0
+        });
+      }
+      if (actionTypes["auth"] || actionTypes["login"]) {
+        agents.push({
+          name: "Auth Specialist",
+          status: isRunning ? "running" : "idle",
+          purpose: "Authentication testing",
+          performance: Math.round((actionTypes["auth"] || actionTypes["login"] || 0) / totalActions * 100),
+          tasks: actionTypes["auth"] || actionTypes["login"] || 0
+        });
+      }
+    }
+    return agents;
+  }
+  async getCurrentTasks() {
+    await this.ensureInitialized();
+    const sessions = await this.getRecentSessions(1);
+    const currentSession = sessions[0];
+    if (!currentSession) {
+      return [];
+    }
+    const actions = await this.getSessionActions(currentSession.id);
+    const recentActions = actions.slice(-10).reverse();
+    return recentActions.map((action, index) => ({
+      id: action.id,
+      name: action.type || "Unknown Action",
+      status: index === 0 && currentSession.status === "running" ? "running" : "completed",
+      progress: index === 0 && currentSession.status === "running" ? "65%" : "100%",
+      agent: "Main Agent",
+      started_at: action.timestamp,
+      result: action.output || action.description || "Completed"
+    }));
+  }
+  async getCurrentIssues() {
+    await this.ensureInitialized();
+    const bugs = await this.getAllBugs();
+    return bugs.slice(0, 10).map((bug) => ({
+      id: bug.id,
+      title: bug.title,
+      description: bug.description,
+      severity: bug.severity || "medium",
+      status: bug.status || "open",
+      discovered_at: bug.created_at,
+      agent: "Main Agent"
+    }));
+  }
+  async pruneOldSessions(maxAgeDays) {
+    await this.ensureInitialized();
+    const cutoff = new Date(Date.now() - maxAgeDays * 864e5).toISOString();
+    const oldSessions = this.db.data.test_sessions.filter((s) => s.started_at < cutoff);
+    const oldSessionIds = new Set(oldSessions.map((s) => s.id));
+    const actionsBefore = this.db.data.actions.length;
+    this.db.data.actions = this.db.data.actions.filter((a) => !oldSessionIds.has(a.session_id));
+    const actionsRemoved = actionsBefore - this.db.data.actions.length;
+    this.db.data.test_sessions = this.db.data.test_sessions.filter((s) => s.started_at >= cutoff);
+    await this.db.write();
+    return { sessionsRemoved: oldSessions.length, actionsRemoved };
+  }
+  async getStorageStats() {
+    await this.ensureInitialized();
+    return {
+      sessions: this.db.data.test_sessions.length,
+      actions: this.db.data.actions.length,
+      bugs: this.db.data.bugs.length,
+      tickets: this.db.data.kanban_tickets.length
+    };
+  }
+  // ── User management ──────────────────────────────────────────────────────────
+  async countUsers() {
+    await this.ensureInitialized();
+    return this.db.data.users.length;
+  }
+  async findUserByUsername(username) {
+    await this.ensureInitialized();
+    return this.db.data.users.find((u) => u.username === username) ?? null;
+  }
+  async getUserById(id) {
+    await this.ensureInitialized();
+    return this.db.data.users.find((u) => u.id === id) ?? null;
+  }
+  async getAllUsers() {
+    await this.ensureInitialized();
+    return [...this.db.data.users];
+  }
+  async createUser(data) {
+    await this.ensureInitialized();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const user = {
+      id: `user_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`,
+      username: data.username,
+      passwordHash: data.passwordHash,
+      role: data.role,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.db.data.users.push(user);
+    await this.db.write();
+    return user;
+  }
+  async updateUser(id, updates) {
+    await this.ensureInitialized();
+    const idx = this.db.data.users.findIndex((u) => u.id === id);
+    if (idx !== -1) {
+      this.db.data.users[idx] = {
+        ...this.db.data.users[idx],
+        ...updates,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      await this.db.write();
+    }
+  }
+  async deleteUser(id) {
+    await this.ensureInitialized();
+    const idx = this.db.data.users.findIndex((u) => u.id === id);
+    if (idx !== -1) {
+      this.db.data.users.splice(idx, 1);
+      await this.db.write();
+    }
+  }
+  async close() {
+  }
+};
+
+// agent/config/schema.ts
+init_esm_shims();
+import { z } from "zod";
+var llmConfigSchema = z.object({
+  provider: z.enum(["openai", "anthropic", "ollama"]).default("openai"),
+  apiKey: z.string().optional(),
+  model: z.string().optional(),
+  baseUrl: z.string().url().optional()
+});
+var saasConfigSchema = z.object({
+  url: z.string().default(""),
+  authType: z.enum(["none", "basic", "bearer", "session"]).default("none"),
+  username: z.string().optional(),
+  password: z.string().optional()
+});
+var githubConfigSchema = z.object({
+  token: z.string().min(1, "GITHUB_TOKEN is required when GitHub is configured"),
+  owner: z.string().default(""),
+  repo: z.string().default("")
+});
+var agentConfigSchema = z.object({
+  intervalMs: z.number().int().positive().default(36e5),
+  maxIterations: z.number().int().positive().default(20),
+  autoStart: z.boolean().default(false)
+});
+var webConfigSchema = z.object({
+  port: z.number().int().min(1).max(65535).default(4242),
+  host: z.string().default("0.0.0.0")
+});
+var databaseConfigSchema = z.object({
+  path: z.string().default("./data/openqa.db")
+});
+var notificationsConfigSchema = z.object({
+  slack: z.string().url().optional(),
+  discord: z.string().url().optional()
+});
+var openQAConfigSchema = z.object({
+  llm: llmConfigSchema,
+  saas: saasConfigSchema,
+  github: githubConfigSchema.optional(),
+  agent: agentConfigSchema,
+  web: webConfigSchema,
+  database: databaseConfigSchema,
+  notifications: notificationsConfigSchema.optional()
+});
+var saasAppConfigSchema = z.object({
+  name: z.string().min(1, "SaaS application name is required"),
+  description: z.string().min(1, "SaaS application description is required"),
+  url: z.string().url("SaaS application URL must be a valid URL"),
+  repoUrl: z.string().url().optional(),
+  localPath: z.string().optional(),
+  techStack: z.array(z.string()).optional(),
+  authInfo: z.object({
+    type: z.enum(["none", "basic", "oauth", "session"]),
+    testCredentials: z.object({
+      username: z.string(),
+      password: z.string()
+    }).optional()
+  }).optional(),
+  directives: z.array(z.string()).optional()
+});
+function validateConfigSafe(config) {
+  const result = openQAConfigSchema.safeParse(config);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  return {
+    success: false,
+    errors: result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`)
+  };
+}
+
+// agent/logger.ts
+init_esm_shims();
+var LEVELS = { debug: 0, info: 1, warn: 2, error: 3 };
+var MIN_LEVEL = process.env.LOG_LEVEL || "info";
+function shouldLog(level) {
+  return LEVELS[level] >= LEVELS[MIN_LEVEL];
+}
+function format(level, message, context) {
+  const entry = {
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    level,
+    msg: message,
+    ...context
+  };
+  return JSON.stringify(entry);
+}
+var logger = {
+  debug(message, context) {
+    if (shouldLog("debug")) process.stdout.write(format("debug", message, context) + "\n");
+  },
+  info(message, context) {
+    if (shouldLog("info")) process.stdout.write(format("info", message, context) + "\n");
+  },
+  warn(message, context) {
+    if (shouldLog("warn")) process.stderr.write(format("warn", message, context) + "\n");
+  },
+  error(message, context) {
+    if (shouldLog("error")) process.stderr.write(format("error", message, context) + "\n");
+  },
+  child(defaults) {
+    return {
+      debug: (msg, ctx) => logger.debug(msg, { ...defaults, ...ctx }),
+      info: (msg, ctx) => logger.info(msg, { ...defaults, ...ctx }),
+      warn: (msg, ctx) => logger.warn(msg, { ...defaults, ...ctx }),
+      error: (msg, ctx) => logger.error(msg, { ...defaults, ...ctx })
+    };
+  }
+};
+
+// agent/config/index.ts
+dotenvConfig();
+var ConfigManager = class {
+  db = null;
+  envConfig;
+  constructor(dbPath) {
+    this.envConfig = this.loadFromEnv();
+  }
+  loadFromEnv() {
+    const raw = {
+      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
+      }
+    };
+    const result = validateConfigSafe(raw);
+    if (!result.success) {
+      logger.warn("Config validation warnings", { errors: result.errors });
+      return raw;
+    }
+    return result.data;
+  }
+  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) {
+      if (value && typeof value === "object") {
+        value = value[k];
+      } else {
+        return null;
+      }
+    }
+    return value != null ? String(value) : 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]] || typeof obj[keys[i]] !== "object") 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;
+  }
+};
+export {
+  ConfigManager
+};
+//# sourceMappingURL=index.js.map